Change algo to take slop into account

* Filter out-of-range temperature from underlying climate

* Fixed broken test case, added new test case for range filtering

README.md

@@ -468,21 +468,16 @@ and of course, configure the VTherm's self-regulation mode in **Expert** mode. A
 For the changes to be taken into account, you must either **completely restart Home Assistant** or just the **Versatile Thermostat integration** (Dev tools / Yaml / reloading the configuration / Versatile Thermostat).
 
 #### Internal temperature compensation
-Sometimes, it happens that the internal thermometer of the underlying (TRV, air conditioning, etc.) is so wrong that self-regulation is not enough to regulate.
-This happens when the internal thermometer is too close to the heat source. The internal temperature then rises much faster than the room temperature, which generates faults in the regulation.
-Example :
-1. the room temperature is 18°, the setpoint is 20°,
-2. the internal temperature of the equipment is 22°,
-3. if VTherm sends 21° as setpoint (= 20° + 1° auto-regulation), then the equipment will not heat because its internal temperature (22°) is above the setpoint (21°)
+Sometimes, a device’s internal temperature sensor (like in a TRV or AC) can give inaccurate readings, especially if it’s too close to a heat source. This can cause the device to stop heating too soon.
+For example:
+1. target temperature: 20 °C, room temperature: 18 °C,
+2. device’s internal sensor: 22 °C
+3. If the target temperature is increased to 21 °C, the device won’t heat because it thinks it’s already warm (internal temperature is 22°C).
 
-To overcome this, a new optional option was added in version 5.4: ![Use of internal temperature](images/config-use-internal-temp.png)
+The Adjust Setpoint for Room vs. TRV Temperature feature fixes this by adding the temperature difference between the room and the device’s internal reading to the target. In this case, VTherm would adjust the target to 25°C (21°C + 4°C difference), forcing the device to continue heating.
 
-When enabled, this function will add the difference between the internal temperature and the room temperature to the setpoint to force heating.
-In the example above, the difference is +4° (22° - 18°), so VTherm will send 25° (21°+4°) to the equipment forcing it to heat up.
-
-This difference is calculated for each underlying because each has its own internal temperature. Think of a VTherm which would be connected to 3 TRVs each with its internal temperature for example.
-
-We then obtain much more effective self-regulation which avoids the pitfall of large variations in faulty internal temperature.
+This adjustment is specific to each device, making the heating system more accurate and avoiding issues from faulty sensor readings.
+See ![Use of internal temperature](images/config-use-internal-temp.png)
 
 #### synthesis of the self-regulation algorithm
 The self-regulation algorithm can be summarized as follows:

custom_components/versatile_thermostat/auto_start_stop_algorithm.py

@@ -0,0 +1,242 @@
+# pylint: disable=line-too-long
+""" This file implements the Auto start/stop algorithm as described here: https://github.com/jmcollin78/versatile_thermostat/issues/585
+"""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Literal
+
+from homeassistant.components.climate import HVACMode
+
+from .const import (
+    AUTO_START_STOP_LEVEL_NONE,
+    AUTO_START_STOP_LEVEL_FAST,
+    AUTO_START_STOP_LEVEL_MEDIUM,
+    AUTO_START_STOP_LEVEL_SLOW,
+    CONF_AUTO_START_STOP_LEVELS,
+    TYPE_AUTO_START_STOP_LEVELS,
+)
+
+
+_LOGGER = logging.getLogger(__name__)
+
+# Some constant to make algorithm depending of level
+DT_MIN = {
+    AUTO_START_STOP_LEVEL_NONE: 0,  # Not used
+    AUTO_START_STOP_LEVEL_SLOW: 30,
+    AUTO_START_STOP_LEVEL_MEDIUM: 15,
+    AUTO_START_STOP_LEVEL_FAST: 7,
+}
+
+# the measurement cycle (2 min)
+CYCLE_SEC = 120
+
+ERROR_THRESHOLD = {
+    AUTO_START_STOP_LEVEL_NONE: 0,  # Not used
+    AUTO_START_STOP_LEVEL_SLOW: 10,  # 10 cycle above 1° or 5 cycle above 2°, ...
+    AUTO_START_STOP_LEVEL_MEDIUM: 5,  # 5 cycle above 1° or 3 cycle above 2°, ..., 1 cycle above 5°
+    AUTO_START_STOP_LEVEL_FAST: 2,  # 2 cycle above 1° or 1 cycle above 2°
+}
+
+AUTO_START_STOP_ACTION_OFF = "turnOff"
+AUTO_START_STOP_ACTION_ON = "turnOn"
+AUTO_START_STOP_ACTION_NOTHING = "nothing"
+AUTO_START_STOP_ACTIONS = Literal[  # pylint: disable=invalid-name
+    AUTO_START_STOP_ACTION_OFF,
+    AUTO_START_STOP_ACTION_ON,
+    AUTO_START_STOP_ACTION_NOTHING,
+]
+
+class AutoStartStopDetectionAlgorithm:
+    """The class that implements the algorithm listed above"""
+
+    _dt: float | None = None
+    _level: str = AUTO_START_STOP_LEVEL_NONE
+    _accumulated_error: float = 0
+    _error_threshold: float | None = None
+    _last_calculation_date: datetime | None = None
+
+    def __init__(self, level: TYPE_AUTO_START_STOP_LEVELS, vtherm_name) -> None:
+        """Initalize a new algorithm with the right constants"""
+        self._vtherm_name = vtherm_name
+        self._init_level(level)
+
+    def _init_level(self, level: TYPE_AUTO_START_STOP_LEVELS):
+        """Initialize a new level"""
+        if level == self._level:
+            return
+
+        self._level = level
+        if self._level != AUTO_START_STOP_LEVEL_NONE:
+            self._dt = DT_MIN[level]
+            self._error_threshold = ERROR_THRESHOLD[level]
+            # reset accumulated error if we change the level
+            self._accumulated_error = 0
+
+    def calculate_action(
+        self,
+        hvac_mode: HVACMode | None,
+        saved_hvac_mode: HVACMode | None,
+        target_temp: float,
+        current_temp: float,
+        slope_min: float,
+        now: datetime,
+    ) -> AUTO_START_STOP_ACTIONS:
+        """Calculate an eventual action to do depending of the value in parameter"""
+        if self._level == AUTO_START_STOP_LEVEL_NONE:
+            _LOGGER.debug(
+                "%s - auto-start/stop is disabled",
+                self,
+            )
+            return AUTO_START_STOP_ACTION_NOTHING
+
+        _LOGGER.debug(
+            "%s - calculate_action: hvac_mode=%s, saved_hvac_mode=%s, target_temp=%s, current_temp=%s, slope_min=%s at %s",
+            self,
+            hvac_mode,
+            saved_hvac_mode,
+            target_temp,
+            current_temp,
+            slope_min,
+            now,
+        )
+
+        if (
+            hvac_mode is None
+            or target_temp is None
+            or current_temp is None
+            or slope_min is None
+        ):
+            _LOGGER.debug(
+                "%s - No all mandatory parameters are set. Disable auto-start/stop",
+                self,
+            )
+            return AUTO_START_STOP_ACTION_NOTHING
+
+        # Calculate the error factor (P)
+        error = target_temp - current_temp
+
+        # reduce the error considering the dt between the last measurement
+        if self._last_calculation_date is not None:
+            dtmin = (now - self._last_calculation_date).total_seconds() / CYCLE_SEC
+            # ignore two calls too near (< 1 min)
+            if dtmin <= 0.5:
+                _LOGGER.debug(
+                    "%s - new calculation of auto_start_stop (%s) is too near of the last one (%s). Forget it",
+                    self,
+                    now,
+                    self._last_calculation_date,
+                )
+                return AUTO_START_STOP_ACTION_NOTHING
+            error = error * dtmin
+
+        # If the error have change its sign, reset smoothly the accumulated error
+        if error * self._accumulated_error < 0:
+            self._accumulated_error = self._accumulated_error / 2.0
+
+        self._accumulated_error += error
+
+        # Capping of the error
+        self._accumulated_error = min(
+            self._error_threshold,
+            max(-self._error_threshold, self._accumulated_error),
+        )
+
+        self._last_calculation_date = now
+
+        temp_at_dt = current_temp + slope_min * self._dt
+
+        # Check to turn-off
+        # When we hit the threshold, that mean we can turn off
+        if hvac_mode == HVACMode.HEAT:
+            if (
+                self._accumulated_error <= -self._error_threshold
+                and temp_at_dt >= target_temp
+            ):
+                _LOGGER.info(
+                    "%s - We need to stop, there is no need for heating for a long time.",
+                    self,
+                )
+                return AUTO_START_STOP_ACTION_OFF
+            else:
+                _LOGGER.debug("%s - nothing to do, we are heating", self)
+                return AUTO_START_STOP_ACTION_NOTHING
+
+        if hvac_mode == HVACMode.COOL:
+            if (
+                self._accumulated_error >= self._error_threshold
+                and temp_at_dt <= target_temp
+            ):
+                _LOGGER.info(
+                    "%s - We need to stop, there is no need for cooling for a long time.",
+                    self,
+                )
+                return AUTO_START_STOP_ACTION_OFF
+            else:
+                _LOGGER.debug(
+                    "%s - nothing to do, we are cooling",
+                    self,
+                )
+                return AUTO_START_STOP_ACTION_NOTHING
+
+        # check to turn on
+        if hvac_mode == HVACMode.OFF and saved_hvac_mode == HVACMode.HEAT:
+            if temp_at_dt <= target_temp:
+                _LOGGER.info(
+                    "%s - We need to start, because it will be time to heat",
+                    self,
+                )
+                return AUTO_START_STOP_ACTION_ON
+            else:
+                _LOGGER.debug(
+                    "%s - nothing to do, we don't need to heat soon",
+                    self,
+                )
+                return AUTO_START_STOP_ACTION_NOTHING
+
+        if hvac_mode == HVACMode.OFF and saved_hvac_mode == HVACMode.COOL:
+            if temp_at_dt >= target_temp:
+                _LOGGER.info(
+                    "%s - We need to start, because it will be time to cool",
+                    self,
+                )
+                return AUTO_START_STOP_ACTION_ON
+            else:
+                _LOGGER.debug(
+                    "%s - nothing to do, we don't need to cool soon",
+                    self,
+                )
+                return AUTO_START_STOP_ACTION_NOTHING
+
+        _LOGGER.debug(
+            "%s - nothing to do, no conditions applied",
+            self,
+        )
+        return AUTO_START_STOP_ACTION_NOTHING
+
+    def set_level(self, level: TYPE_AUTO_START_STOP_LEVELS):
+        """Set a new level"""
+        self._init_level(level)
+
+    @property
+    def dt_min(self) -> float:
+        """Get the dt value"""
+        return self._dt
+
+    @property
+    def accumulated_error(self) -> float:
+        """Get the accumulated error value"""
+        return self._accumulated_error
+
+    @property
+    def accumulated_error_threshold(self) -> float:
+        """Get the accumulated error threshold value"""
+        return self._error_threshold
+
+    @property
+    def level(self) -> TYPE_AUTO_START_STOP_LEVELS:
+        """Get the level value"""
+        return self._level
+
+    def __str__(self) -> str:
+        return f"AutoStartStopDetectionAlgorithm-{self._vtherm_name}"

custom_components/versatile_thermostat/base_thermostat.py

@@ -1654,9 +1654,28 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
 
             if not long_enough:
                 _LOGGER.debug(
-                    "Motion delay condition is not satisfied. Ignore motion event"
+                    "Motion delay condition is not satisfied (the sensor have change its state during the delay). Check motion sensor state"
                 )
-            else:
+                # Get sensor current state
+                motion_state = self.hass.states.get(self._motion_sensor_entity_id)
+                _LOGGER.debug(
+                    "%s - motion_state=%s, new_state.state=%s",
+                    self,
+                    motion_state.state,
+                    new_state.state,
+                )
+                if (
+                    motion_state.state == new_state.state
+                    and new_state.state == STATE_ON
+                ):
+                    _LOGGER.debug(
+                        "%s - the motion sensor is finally 'on' after the delay", self
+                    )
+                    long_enough = True
+                else:
+                    long_enough = False
+
+            if long_enough:
                 _LOGGER.debug("%s - Motion delay condition is satisfied", self)
                 self._motion_state = new_state.state
                 if self._attr_preset_mode == PRESET_ACTIVITY:
@@ -1679,6 +1698,11 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
                     )
                 self.recalculate()
                 await self.async_control_heating(force=True)
+            else:
+                self._motion_state = (
+                    STATE_ON if new_state.state == STATE_OFF else STATE_OFF
+                )
+
             self._motion_call_cancel = None
 
         im_on = self._motion_state == STATE_ON

custom_components/versatile_thermostat/binary_sensor.py

@@ -100,7 +100,7 @@ class SecurityBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
         entry_infos,
     ) -> None:
         """Initialize the SecurityState Binary sensor"""
-        super().__init__(hass, unique_id, entry_infos.get(CONF_NAME))
+        super().__init__(hass, unique_id, name)
         self._attr_name = "Security state"
         self._attr_unique_id = f"{self._device_name}_security_state"
         self._attr_is_on = False

custom_components/versatile_thermostat/config_flow.py

@@ -128,6 +128,11 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
             and self._infos.get(CONF_CENTRAL_BOILER_DEACTIVATION_SRV) is not None
         )
 
+        self._infos[CONF_USE_AUTO_START_STOP_FEATURE] = (
+            self._infos.get(CONF_USE_AUTO_START_STOP_FEATURE) is True
+            and self._infos.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_CLIMATE
+        )
+
     def _init_central_config_flags(self, infos):
         """Initialisation of central configuration flags"""
         is_empty: bool = not bool(infos)
@@ -431,6 +436,13 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
         if self._infos[CONF_USE_PRESENCE_FEATURE] is True:
             menu_options.append("presence")
 
+        if self._infos.get(CONF_USE_AUTO_START_STOP_FEATURE) is True and self._infos[
+            CONF_THERMOSTAT_TYPE
+        ] in [
+            CONF_THERMOSTAT_CLIMATE,
+        ]:
+            menu_options.append("auto_start_stop")
+
         menu_options.append("advanced")
 
         if self.check_config_complete(self._infos):
@@ -520,17 +532,29 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
         """Handle the Type flow steps"""
         _LOGGER.debug("Into ConfigFlow.async_step_features user_input=%s", user_input)
 
+        schema = STEP_FEATURES_DATA_SCHEMA
+        if self._infos[CONF_THERMOSTAT_TYPE] == CONF_THERMOSTAT_CENTRAL_CONFIG:
+            schema = STEP_CENTRAL_FEATURES_DATA_SCHEMA
+        elif self._infos[CONF_THERMOSTAT_TYPE] == CONF_THERMOSTAT_CLIMATE:
+            schema = STEP_CLIMATE_FEATURES_DATA_SCHEMA
+
         return await self.generic_step(
             "features",
-            (
-                STEP_CENTRAL_FEATURES_DATA_SCHEMA
-                if self._infos[CONF_THERMOSTAT_TYPE] == CONF_THERMOSTAT_CENTRAL_CONFIG
-                else STEP_FEATURES_DATA_SCHEMA
-            ),
+            schema,
             user_input,
             self.async_step_menu,
         )
 
+    async def async_step_auto_start_stop(self, user_input: dict | None = None) -> FlowResult:
+        """ Handle the Auto start stop step"""
+        _LOGGER.debug("Into ConfigFlow.async_step_auto_start_stop user_input=%s", user_input)
+
+        schema = STEP_AUTO_START_STOP
+        self._infos[COMES_FROM] = None
+        next_step = self.async_step_menu
+
+        return await self.generic_step("auto_start_stop", schema, user_input, next_step)
+
     async def async_step_tpi(self, user_input: dict | None = None) -> FlowResult:
         """Handle the TPI flow steps"""
         _LOGGER.debug("Into ConfigFlow.async_step_tpi user_input=%s", user_input)
@@ -869,6 +893,8 @@ class VersatileThermostatOptionsFlowHandler(
         if not self._infos[CONF_USE_CENTRAL_BOILER_FEATURE]:
             self._infos[CONF_CENTRAL_BOILER_ACTIVATION_SRV] = None
             self._infos[CONF_CENTRAL_BOILER_DEACTIVATION_SRV] = None
+        if not self._infos[CONF_USE_AUTO_START_STOP_FEATURE]:
+            self._infos[CONF_AUTO_START_STOP_LEVEL] = AUTO_START_STOP_LEVEL_NONE
 
         _LOGGER.info(
             "Recreating entry %s due to configuration change. New config is now: %s",

custom_components/versatile_thermostat/config_schema.py

@@ -68,6 +68,16 @@ STEP_FEATURES_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
     }
 )
 
+STEP_CLIMATE_FEATURES_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
+    {
+        vol.Optional(CONF_USE_WINDOW_FEATURE, default=False): cv.boolean,
+        vol.Optional(CONF_USE_MOTION_FEATURE, default=False): cv.boolean,
+        vol.Optional(CONF_USE_POWER_FEATURE, default=False): cv.boolean,
+        vol.Optional(CONF_USE_PRESENCE_FEATURE, default=False): cv.boolean,
+        vol.Optional(CONF_USE_AUTO_START_STOP_FEATURE, default=False): cv.boolean,
+    }
+)
+
 STEP_CENTRAL_FEATURES_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
     {
         vol.Optional(CONF_USE_WINDOW_FEATURE, default=False): cv.boolean,
@@ -196,6 +206,20 @@ STEP_THERMOSTAT_VALVE = vol.Schema(  # pylint: disable=invalid-name
     }
 )
 
+STEP_AUTO_START_STOP = vol.Schema(  # pylint: disable=invalid-name
+    {
+        vol.Optional(
+            CONF_AUTO_START_STOP_LEVEL, default=AUTO_START_STOP_LEVEL_NONE
+        ): selector.SelectSelector(
+            selector.SelectSelectorConfig(
+                options=CONF_AUTO_START_STOP_LEVELS,
+                translation_key="auto_start_stop",
+                mode="dropdown",
+            )
+        ),
+    }
+)
+
 STEP_TPI_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
     {
         vol.Required(CONF_USE_TPI_CENTRAL_CONFIG, default=True): cv.boolean,

custom_components/versatile_thermostat/const.py

@@ -2,6 +2,7 @@
 """Constants for the Versatile Thermostat integration."""
 
 import logging
+from typing import Literal
 
 from enum import Enum
 from homeassistant.const import CONF_NAME, Platform
@@ -51,6 +52,7 @@ PLATFORMS: list[Platform] = [
     # Number should be after CLIMATE
     Platform.NUMBER,
     Platform.BINARY_SENSOR,
+    Platform.SWITCH,
 ]
 
 CONF_HEATER = "heater_entity_id"
@@ -97,6 +99,7 @@ CONF_USE_MOTION_FEATURE = "use_motion_feature"
 CONF_USE_PRESENCE_FEATURE = "use_presence_feature"
 CONF_USE_POWER_FEATURE = "use_power_feature"
 CONF_USE_CENTRAL_BOILER_FEATURE = "use_central_boiler_feature"
+CONF_USE_AUTO_START_STOP_FEATURE = "use_auto_start_stop_feature"
 CONF_AC_MODE = "ac_mode"
 CONF_WINDOW_AUTO_OPEN_THRESHOLD = "window_auto_open_threshold"
 CONF_WINDOW_AUTO_CLOSE_THRESHOLD = "window_auto_close_threshold"
@@ -145,6 +148,26 @@ CONF_CENTRAL_BOILER_DEACTIVATION_SRV = "central_boiler_deactivation_service"
 CONF_USED_BY_CENTRAL_BOILER = "used_by_controls_central_boiler"
 CONF_WINDOW_ACTION = "window_action"
 
+CONF_AUTO_START_STOP_LEVEL = "auto_start_stop_level"
+AUTO_START_STOP_LEVEL_NONE = "auto_start_stop_none"
+AUTO_START_STOP_LEVEL_SLOW = "auto_start_stop_slow"
+AUTO_START_STOP_LEVEL_MEDIUM = "auto_start_stop_medium"
+AUTO_START_STOP_LEVEL_FAST = "auto_start_stop_fast"
+CONF_AUTO_START_STOP_LEVELS = [
+    AUTO_START_STOP_LEVEL_NONE,
+    AUTO_START_STOP_LEVEL_SLOW,
+    AUTO_START_STOP_LEVEL_MEDIUM,
+    AUTO_START_STOP_LEVEL_FAST,
+]
+
+# For explicit typing purpose only
+TYPE_AUTO_START_STOP_LEVELS = Literal[  # pylint: disable=invalid-name
+    AUTO_START_STOP_LEVEL_FAST,
+    AUTO_START_STOP_LEVEL_MEDIUM,
+    AUTO_START_STOP_LEVEL_SLOW,
+    AUTO_START_STOP_LEVEL_NONE,
+]
+
 DEFAULT_SHORT_EMA_PARAMS = {
     "max_alpha": 0.5,
     # In sec
@@ -445,6 +468,7 @@ class EventType(Enum):
     CENTRAL_BOILER_EVENT: str = "versatile_thermostat_central_boiler_event"
     PRESET_EVENT: str = "versatile_thermostat_preset_event"
     WINDOW_AUTO_EVENT: str = "versatile_thermostat_window_auto_event"
+    AUTO_START_STOP_EVENT: str = "versatile_thermostat_auto_start_stop_event"
 
 
 def send_vtherm_event(hass, event_type: EventType, entity, data: dict):

custom_components/versatile_thermostat/manifest.json

@@ -14,6 +14,6 @@
   "quality_scale": "silver",
   "requirements": [],
   "ssdp": [],
-  "version": "6.3.0",
+  "version": "6.5.0",
   "zeroconf": []
 }

custom_components/versatile_thermostat/strings.json

@@ -27,6 +27,7 @@
           "power": "Power management",
           "presence": "Presence detection",
           "advanced": "Advanced parameters",
+          "auto_start_stop": "Auto start and stop",
           "finalize": "All done",
           "configuration_not_complete": "Configuration not complete"
         }
@@ -63,7 +64,8 @@
           "use_motion_feature": "Use motion detection",
           "use_power_feature": "Use power management",
           "use_presence_feature": "Use presence detection",
-          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after seecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page"
+          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after seecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page",
+          "use_auto_start_stop_feature": "Use the auto start and stop feature"
         }
       },
       "type": {
@@ -262,6 +264,7 @@
           "power": "Power management",
           "presence": "Presence detection",
           "advanced": "Advanced parameters",
+          "auto_start_stop": "Auto start and stop",
           "finalize": "All done",
           "configuration_not_complete": "Configuration not complete"
         }
@@ -298,7 +301,8 @@
           "use_motion_feature": "Use motion detection",
           "use_power_feature": "Use power management",
           "use_presence_feature": "Use presence detection",
-          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after seecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page"
+          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after seecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page",
+          "use_auto_start_stop_feature": "Use the auto start and stop feature"
         }
       },
       "type": {
@@ -514,6 +518,14 @@
         "comfort": "Comfort",
         "boost": "Boost"
       }
+    },
+    "auto_start_stop": {
+      "options": {
+        "auto_start_stop_none": "No auto start/stop",
+        "auto_start_stop_slow": "Slow detection",
+        "auto_start_stop_medium": "Medium detection",
+        "auto_start_stop_fast": "Fast detection"
+      }
     }
   },
   "entity": {

custom_components/versatile_thermostat/switch.py

@@ -0,0 +1,102 @@
+## pylint: disable=unused-argument
+
+""" Implements the VersatileThermostat select component """
+import logging
+from typing import Any
+
+from homeassistant.core import HomeAssistant, callback
+
+from homeassistant.components.switch import SwitchEntity
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.helpers.restore_state import RestoreEntity
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from .commons import VersatileThermostatBaseEntity
+
+from .const import *  # pylint: disable=unused-wildcard-import,wildcard-import
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up the VersatileThermostat switches with config flow."""
+    _LOGGER.debug(
+        "Calling async_setup_entry entry=%s, data=%s", entry.entry_id, entry.data
+    )
+
+    unique_id = entry.entry_id
+    name = entry.data.get(CONF_NAME)
+    vt_type = entry.data.get(CONF_THERMOSTAT_TYPE)
+    auto_start_stop_feature = entry.data.get(CONF_USE_AUTO_START_STOP_FEATURE)
+
+    if vt_type == CONF_THERMOSTAT_CLIMATE and auto_start_stop_feature is True:
+        # Creates a switch to enable the auto-start/stop
+        enable_entity = AutoStartStopEnable(hass, unique_id, name, entry)
+        async_add_entities([enable_entity], True)
+
+
+class AutoStartStopEnable(VersatileThermostatBaseEntity, SwitchEntity, RestoreEntity):
+    """The that enables the ManagedDevice optimisation with"""
+
+    def __init__(
+        self, hass: HomeAssistant, unique_id: str, name: str, entry_infos: ConfigEntry
+    ):
+        super().__init__(hass, unique_id, name)
+        self._attr_name = "Enable auto start/stop"
+        self._attr_unique_id = f"{self._device_name}_enbale_auto_start_stop"
+        self._default_value = (
+            entry_infos.data.get(CONF_AUTO_START_STOP_LEVEL)
+            != AUTO_START_STOP_LEVEL_NONE
+        )
+        self._attr_is_on = self._default_value
+
+    @property
+    def icon(self) -> str | None:
+        """The icon"""
+        return "mdi:power-settings"
+
+    async def async_added_to_hass(self):
+        await super().async_added_to_hass()
+
+        # Récupérer le dernier état sauvegardé de l'entité
+        last_state = await self.async_get_last_state()
+
+        # Si l'état précédent existe, vous pouvez l'utiliser
+        if last_state is not None:
+            self._attr_is_on = last_state.state == "on"
+        else:
+            # If no previous state set it to false by default
+            self._attr_is_on = self._default_value
+
+        self.update_my_state_and_vtherm()
+
+    def update_my_state_and_vtherm(self):
+        """Update the auto_start_stop_enable flag in my VTherm"""
+        self.async_write_ha_state()
+        if self.my_climate is not None:
+            self.my_climate.set_auto_start_stop_enable(self._attr_is_on)
+
+    @callback
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn the entity on."""
+        self.turn_on()
+
+    @callback
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn the entity off."""
+        self.turn_off()
+
+    @overrides
+    def turn_off(self, **kwargs: Any):
+        self._attr_is_on = False
+        self.update_my_state_and_vtherm()
+
+    @overrides
+    def turn_on(self, **kwargs: Any):
+        self._attr_is_on = True
+        self.update_my_state_and_vtherm()

custom_components/versatile_thermostat/thermostat_climate.py

@@ -49,11 +49,20 @@ from .const import (
     RegulationParamStrong,
     AUTO_FAN_DTEMP_THRESHOLD,
     AUTO_FAN_DEACTIVATED_MODES,
+    CONF_AUTO_START_STOP_LEVEL,
+    AUTO_START_STOP_LEVEL_NONE,
+    TYPE_AUTO_START_STOP_LEVELS,
     UnknownEntity,
+    EventType,
 )
 
 from .vtherm_api import VersatileThermostatAPI
 from .underlyings import UnderlyingClimate
+from .auto_start_stop_algorithm import (
+    AutoStartStopDetectionAlgorithm,
+    AUTO_START_STOP_ACTION_OFF,
+    AUTO_START_STOP_ACTION_ON,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -64,7 +73,6 @@ HVAC_ACTION_ON = [  # pylint: disable=invalid-name
     HVACAction.HEATING,
 ]
 
-
 class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
     """Representation of a base class for a Versatile Thermostat over a climate"""
 
@@ -81,6 +89,9 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
     # The fan_mode name depending of the current_mode
     _auto_activated_fan_mode: str | None = None
     _auto_deactivated_fan_mode: str | None = None
+    _auto_start_stop_level: TYPE_AUTO_START_STOP_LEVELS = AUTO_START_STOP_LEVEL_NONE
+    _auto_start_stop_algo: AutoStartStopDetectionAlgorithm | None = None
+    _is_auto_start_stop_enabled: bool = False
 
     _entity_component_unrecorded_attributes = (
         BaseThermostat._entity_component_unrecorded_attributes.union(
@@ -99,6 +110,11 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
                     "auto_activated_fan_mode",
                     "auto_deactivated_fan_mode",
                     "auto_regulation_use_device_temp",
+                    "auto_start_stop_level",
+                    "auto_start_stop_dtmin",
+                    "auto_start_stop_enable",
+                    "auto_start_stop_accumulated_error",
+                    "auto_start_stop_accumulated_error_threshold",
                 }
             )
         )
@@ -113,6 +129,61 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
         self._regulated_target_temp = self.target_temperature
         self._last_regulation_change = NowClass.get_now(hass)
 
+    @overrides
+    def post_init(self, config_entry: ConfigData):
+        """Initialize the Thermostat"""
+
+        super().post_init(config_entry)
+        for climate in [
+            CONF_CLIMATE,
+            CONF_CLIMATE_2,
+            CONF_CLIMATE_3,
+            CONF_CLIMATE_4,
+        ]:
+            if config_entry.get(climate):
+                self._underlyings.append(
+                    UnderlyingClimate(
+                        hass=self._hass,
+                        thermostat=self,
+                        climate_entity_id=config_entry.get(climate),
+                    )
+                )
+
+        self.choose_auto_regulation_mode(
+            config_entry.get(CONF_AUTO_REGULATION_MODE)
+            if config_entry.get(CONF_AUTO_REGULATION_MODE) is not None
+            else CONF_AUTO_REGULATION_NONE
+        )
+
+        self._auto_regulation_dtemp = (
+            config_entry.get(CONF_AUTO_REGULATION_DTEMP)
+            if config_entry.get(CONF_AUTO_REGULATION_DTEMP) is not None
+            else 0.5
+        )
+        self._auto_regulation_period_min = (
+            config_entry.get(CONF_AUTO_REGULATION_PERIOD_MIN)
+            if config_entry.get(CONF_AUTO_REGULATION_PERIOD_MIN) is not None
+            else 5
+        )
+
+        self._auto_fan_mode = (
+            config_entry.get(CONF_AUTO_FAN_MODE)
+            if config_entry.get(CONF_AUTO_FAN_MODE) is not None
+            else CONF_AUTO_FAN_NONE
+        )
+
+        self._auto_regulation_use_device_temp = config_entry.get(
+            CONF_AUTO_REGULATION_USE_DEVICE_TEMP, False
+        )
+
+        self._auto_start_stop_level = config_entry.get(
+            CONF_AUTO_START_STOP_LEVEL, AUTO_START_STOP_LEVEL_NONE
+        )
+        # Instanciate the auto start stop algo
+        self._auto_start_stop_algo = AutoStartStopDetectionAlgorithm(
+            self._auto_start_stop_level, self.name
+        )
+
     @property
     def is_over_climate(self) -> bool:
         """True if the Thermostat is over_climate"""
@@ -228,17 +299,6 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
                 and self.auto_regulation_use_device_temp
                 # and we have access to the device temp
                 and (device_temp := under.underlying_current_temperature) is not None
-                # and target is not reach (ie we need regulation)
-                and (
-                    (
-                        self.hvac_mode == HVACMode.COOL
-                        and self.target_temperature < self.current_temperature
-                    )
-                    or (
-                        self.hvac_mode == HVACMode.HEAT
-                        and self.target_temperature > self.current_temperature
-                    )
-                )
             ):
                 offset_temp = device_temp - self.current_temperature
 
@@ -303,53 +363,6 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             )
             await self.async_set_fan_mode(self._auto_deactivated_fan_mode)
 
-    @overrides
-    def post_init(self, config_entry: ConfigData):
-        """Initialize the Thermostat"""
-
-        super().post_init(config_entry)
-        for climate in [
-            CONF_CLIMATE,
-            CONF_CLIMATE_2,
-            CONF_CLIMATE_3,
-            CONF_CLIMATE_4,
-        ]:
-            if config_entry.get(climate):
-                self._underlyings.append(
-                    UnderlyingClimate(
-                        hass=self._hass,
-                        thermostat=self,
-                        climate_entity_id=config_entry.get(climate),
-                    )
-                )
-
-        self.choose_auto_regulation_mode(
-            config_entry.get(CONF_AUTO_REGULATION_MODE)
-            if config_entry.get(CONF_AUTO_REGULATION_MODE) is not None
-            else CONF_AUTO_REGULATION_NONE
-        )
-
-        self._auto_regulation_dtemp = (
-            config_entry.get(CONF_AUTO_REGULATION_DTEMP)
-            if config_entry.get(CONF_AUTO_REGULATION_DTEMP) is not None
-            else 0.5
-        )
-        self._auto_regulation_period_min = (
-            config_entry.get(CONF_AUTO_REGULATION_PERIOD_MIN)
-            if config_entry.get(CONF_AUTO_REGULATION_PERIOD_MIN) is not None
-            else 5
-        )
-
-        self._auto_fan_mode = (
-            config_entry.get(CONF_AUTO_FAN_MODE)
-            if config_entry.get(CONF_AUTO_FAN_MODE) is not None
-            else CONF_AUTO_FAN_NONE
-        )
-
-        self._auto_regulation_use_device_temp = config_entry.get(
-            CONF_AUTO_REGULATION_USE_DEVICE_TEMP, False
-        )
-
     def choose_auto_regulation_mode(self, auto_regulation_mode: str):
         """Choose or change the regulation mode"""
         self._auto_regulation_mode = auto_regulation_mode
@@ -562,6 +575,24 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             self.auto_regulation_use_device_temp
         )
 
+        self._attr_extra_state_attributes["auto_start_stop_enable"] = (
+            self.auto_start_stop_enable
+        )
+
+        self._attr_extra_state_attributes["auto_start_stop_level"] = (
+            self._auto_start_stop_algo.level
+        )
+        self._attr_extra_state_attributes["auto_start_stop_dtmin"] = (
+            self._auto_start_stop_algo.dt_min
+        )
+        self._attr_extra_state_attributes["auto_start_stop_accumulated_error"] = (
+            self._auto_start_stop_algo.accumulated_error
+        )
+
+        self._attr_extra_state_attributes[
+            "auto_start_stop_accumulated_error_threshold"
+        ] = self._auto_start_stop_algo.accumulated_error_threshold
+
         self.async_write_ha_state()
         _LOGGER.debug(
             "%s - Calling update_custom_attributes: %s",
@@ -692,8 +723,9 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             else None
         )
 
+        last_sent_temperature = under.last_sent_temperature or 0
         under_temp_diff = (
-            (new_target_temp - under.last_sent_temperature) if new_target_temp else 0
+            (new_target_temp - last_sent_temperature) if new_target_temp else 0
         )
         if -1 < under_temp_diff < 1:
             under_temp_diff = 0
@@ -717,6 +749,22 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             )
             return
 
+        # Forget event when the new target temperature is out of range
+        if (
+            not new_target_temp is None
+            and not self._attr_min_temp is None
+            and not self._attr_max_temp is None
+            and not (self._attr_min_temp <= new_target_temp <= self._attr_max_temp)
+        ):
+            _LOGGER.debug(
+                "%s - underlying sent a target temperature (%s) which is out of configured min/max range (%s / %s). The value will be ignored",
+                self,
+                new_target_temp,
+                self._attr_min_temp,
+                self._attr_max_temp,
+            )
+            return
+
         # A real changes have to be managed
         _LOGGER.info(
             "%s - Underlying climate %s have changed. new_hvac_mode is %s (vs %s), new_hvac_action=%s (vs %s), new_target_temp=%s (vs %s), new_fan_mode=%s (vs %s)",
@@ -863,6 +911,72 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
         """The main function used to run the calculation at each cycle"""
         ret = await super().async_control_heating(force, _)
 
+        # Check if we need to auto start/stop the Vtherm
+        if (
+            self.auto_start_stop_enable
+            and self._window_auto_algo.last_slope is not None
+        ):
+            action = self._auto_start_stop_algo.calculate_action(
+                self.hvac_mode,
+                self._saved_hvac_mode,
+                self.target_temperature,
+                self.current_temperature,
+                self._window_auto_algo.last_slope / 60,  # to have the slope in °/min
+                self.now,
+            )
+            _LOGGER.debug("%s - auto_start_stop action is %s", self, action)
+            if action == AUTO_START_STOP_ACTION_OFF:
+                _LOGGER.info(
+                    "%s - Turning OFF the Vtherm due to auto-start-stop conditions",
+                    self,
+                )
+                await self.async_turn_off()
+
+                # Send an event
+                self.send_event(
+                    event_type=EventType.AUTO_START_STOP_EVENT,
+                    data={
+                        "type": "stop",
+                        "name:": self.name,
+                        "cause": "Auto stop conditions reached",
+                        "hvac_mode": self.hvac_mode,
+                        "saved_hvac_mode": self._saved_hvac_mode,
+                        "target_temperature": self.target_temperature,
+                        "current_temperature": self.current_temperature,
+                        "temperature_slope": self._window_auto_algo.last_slope,
+                    },
+                )
+
+                # Stop here
+                return ret
+            elif action == AUTO_START_STOP_ACTION_ON:
+                _LOGGER.info(
+                    "%s - Turning ON the Vtherm due to auto-start-stop conditions", self
+                )
+                await self.async_turn_on()
+
+                # Send an event
+                self.send_event(
+                    event_type=EventType.AUTO_START_STOP_EVENT,
+                    data={
+                        "type": "start",
+                        "name:": self.name,
+                        "cause": "Auto start conditions reached",
+                        "hvac_mode": self.hvac_mode,
+                        "saved_hvac_mode": self._saved_hvac_mode,
+                        "target_temperature": self.target_temperature,
+                        "current_temperature": self.current_temperature,
+                        "temperature_slope": self._window_auto_algo.last_slope,
+                    },
+                )
+
+                self.update_custom_attributes()
+        else:
+            _LOGGER.debug("%s - auto start/stop is disabled")
+
+            # Continue the normal async_control_heating
+
+        # Send the regulated temperature to the underlyings
         await self._send_regulated_temperature()
 
         if self._auto_fan_mode and self._auto_fan_mode != CONF_AUTO_FAN_NONE:
@@ -870,6 +984,11 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
 
         return ret
 
+    def set_auto_start_stop_enable(self, is_enabled: bool):
+        """Enable/Disable the auto-start/stop feature"""
+        self._is_auto_start_stop_enabled = is_enabled
+        self.update_custom_attributes()
+
     @property
     def auto_regulation_mode(self) -> str | None:
         """Get the regulation mode"""
@@ -1016,6 +1135,16 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
                 return False
         return True
 
+    @property
+    def auto_start_stop_level(self) -> TYPE_AUTO_START_STOP_LEVELS:
+        """Return the auto start/stop level."""
+        return self._auto_start_stop_level
+
+    @property
+    def auto_start_stop_enable(self) -> bool:
+        """Returns the auto_start_stop_enable"""
+        return self._is_auto_start_stop_enabled
+
     @overrides
     def init_underlyings(self):
         """Init the underlyings if not already done"""

custom_components/versatile_thermostat/translations/en.json

@@ -27,6 +27,7 @@
           "power": "Power management",
           "presence": "Presence detection",
           "advanced": "Advanced parameters",
+          "auto_start_stop": "Auto start and stop",
           "finalize": "All done",
           "configuration_not_complete": "Configuration not complete"
         }
@@ -63,7 +64,8 @@
           "use_motion_feature": "Use motion detection",
           "use_power_feature": "Use power management",
           "use_presence_feature": "Use presence detection",
-          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after seecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page"
+          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after seecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page",
+          "use_auto_start_stop_feature": "Use the auto start and stop feature"
         }
       },
       "type": {
@@ -262,6 +264,7 @@
           "power": "Power management",
           "presence": "Presence detection",
           "advanced": "Advanced parameters",
+          "auto_start_stop": "Auto start and stop",
           "finalize": "All done",
           "configuration_not_complete": "Configuration not complete"
         }
@@ -298,7 +301,8 @@
           "use_motion_feature": "Use motion detection",
           "use_power_feature": "Use power management",
           "use_presence_feature": "Use presence detection",
-          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after seecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page"
+          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after seecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page",
+          "use_auto_start_stop_feature": "Use the auto start and stop feature"
         }
       },
       "type": {
@@ -514,6 +518,14 @@
         "comfort": "Comfort",
         "boost": "Boost"
       }
+    },
+    "auto_start_stop": {
+      "options": {
+        "auto_start_stop_none": "No auto start/stop",
+        "auto_start_stop_slow": "Slow detection",
+        "auto_start_stop_medium": "Medium detection",
+        "auto_start_stop_fast": "Fast detection"
+      }
     }
   },
   "entity": {

custom_components/versatile_thermostat/translations/fr.json

@@ -27,6 +27,7 @@
           "power": "Gestion de la puissance",
           "presence": "Détection de présence",
           "advanced": "Paramètres avancés",
+          "auto_start_stop": "Allumage/extinction automatique",
           "finalize": "Finaliser la création",
           "configuration_not_complete": "Configuration incomplète"
         }
@@ -63,7 +64,8 @@
           "use_motion_feature": "Avec détection de mouvement",
           "use_power_feature": "Avec gestion de la puissance",
           "use_presence_feature": "Avec détection de présence",
-          "use_central_boiler_feature": "Ajouter une chaudière centrale. Cochez pour ajouter un controle sur une chaudière centrale. Vous devrez ensuite configurer les VTherms qui commande la chaudière centrale pour que cette option prenne effet. Si au moins un des VTherm a besoin de chauffer, la chaudière centrale sera activée. Si aucun VTherm n'a besoin de chauffer, elle sera éteinte. Les commandes pour allumer/éteindre la chaudière centrale sont données dans la page de configuration suivante."
+          "use_central_boiler_feature": "Ajouter une chaudière centrale. Cochez pour ajouter un controle sur une chaudière centrale. Vous devrez ensuite configurer les VTherms qui commande la chaudière centrale pour que cette option prenne effet. Si au moins un des VTherm a besoin de chauffer, la chaudière centrale sera activée. Si aucun VTherm n'a besoin de chauffer, elle sera éteinte. Les commandes pour allumer/éteindre la chaudière centrale sont données dans la page de configuration suivante.",
+          "use_auto_start_stop_feature": "Avec démarrage et extinction automatique"
         }
       },
       "type": {
@@ -274,6 +276,7 @@
           "power": "Gestion de la puissance",
           "presence": "Détection de présence",
           "advanced": "Paramètres avancés",
+          "auto_start_stop": "Allumage/extinction automatique",
           "finalize": "Finaliser les modifications",
           "configuration_not_complete": "Configuration incomplète"
         }
@@ -310,7 +313,8 @@
           "use_motion_feature": "Avec détection de mouvement",
           "use_power_feature": "Avec gestion de la puissance",
           "use_presence_feature": "Avec détection de présence",
-          "use_central_boiler_feature": "Ajouter une chaudière centrale. Cochez pour ajouter un controle sur une chaudière centrale. Vous devrez ensuite configurer les VTherms qui commande la chaudière centrale pour que cette option prenne effet. Si au moins un des VTherm a besoin de chauffer, la chaudière centrale sera activée. Si aucun VTherm n'a besoin de chauffer, elle sera éteinte. Les commandes pour allumer/éteindre la chaudière centrale sont données dans la page de configuration suivante."
+          "use_central_boiler_feature": "Ajouter une chaudière centrale. Cochez pour ajouter un controle sur une chaudière centrale. Vous devrez ensuite configurer les VTherms qui commande la chaudière centrale pour que cette option prenne effet. Si au moins un des VTherm a besoin de chauffer, la chaudière centrale sera activée. Si aucun VTherm n'a besoin de chauffer, elle sera éteinte. Les commandes pour allumer/éteindre la chaudière centrale sont données dans la page de configuration suivante.",
+          "use_auto_start_stop_feature": "Avec démarrage et extinction automatique"
         }
       },
       "type": {
@@ -532,6 +536,14 @@
         "comfort": "Confort",
         "boost": "Renforcé (boost)"
       }
+    },
+    "auto_start_stop": {
+      "options": {
+        "auto_start_stop_none": "No auto start/stop",
+        "auto_start_stop_slow": "Slow detection",
+        "auto_start_stop_medium": "Medium detection",
+        "auto_start_stop_fast": "Fast detection"
+      }
     }
   },
   "entity": {

custom_components/versatile_thermostat/underlyings.py

@@ -550,14 +550,11 @@ class UnderlyingClimate(UnderlyingEntity):
     def is_device_active(self):
         """If the toggleable device is currently active."""
         if self.is_initialized:
-            return (
-                self._underlying_climate.hvac_mode != HVACMode.OFF
-                and self._underlying_climate.hvac_action
-                not in [
-                    HVACAction.IDLE,
-                    HVACAction.OFF,
-                ]
-            )
+            return self.hvac_mode != HVACMode.OFF and self.hvac_action not in [
+                HVACAction.IDLE,
+                HVACAction.OFF,
+                None,
+            ]
         else:
             return None
 
@@ -650,7 +647,36 @@ class UnderlyingClimate(UnderlyingEntity):
         """Get the hvac action of the underlying"""
         if not self.is_initialized:
             return None
-        return self._underlying_climate.hvac_action
+
+        hvac_action = self._underlying_climate.hvac_action
+        if hvac_action is None:
+            target = (
+                self.underlying_target_temperature
+                or self._thermostat.target_temperature
+            )
+            current = (
+                self.underlying_current_temperature
+                or self._thermostat.current_temperature
+            )
+            hvac_mode = self.hvac_mode
+
+            _LOGGER.debug(
+                "%s - hvac_action simulation target=%s, current=%s, hvac_mode=%s",
+                self,
+                target,
+                current,
+                hvac_mode,
+            )
+            hvac_action = HVACAction.IDLE
+            if target is not None and current is not None:
+                dtemp = target - current
+
+                if hvac_mode == HVACMode.COOL and dtemp < 0:
+                    hvac_action = HVACAction.COOLING
+                elif hvac_mode in [HVACMode.HEAT, HVACMode.HEAT_COOL] and dtemp > 0:
+                    hvac_action = HVACAction.HEATING
+
+        return hvac_action
 
     @property
     def hvac_mode(self) -> HVACMode | None:
@@ -730,18 +756,19 @@ class UnderlyingClimate(UnderlyingEntity):
         return self._underlying_climate.target_temperature_low
 
     @property
-    def target_temperature(self) -> float:
+    def underlying_target_temperature(self) -> float:
         """Get the target_temperature"""
         if not self.is_initialized:
             return None
-        return self._underlying_climate.target_temperature
 
-    @property
-    def is_aux_heat(self) -> bool:
-        """Get the is_aux_heat"""
-        if not self.is_initialized:
-            return False
-        return self._underlying_climate.is_aux_heat
+        if not hasattr(self._underlying_climate, "target_temperature"):
+            return None
+        else:
+            return self._underlying_climate.target_temperature
+
+        # return self._hass.states.get(self._entity_id).attributes.get(
+        #    "target_temperature"
+        # )
 
     @property
     def underlying_current_temperature(self) -> float | None:
@@ -752,8 +779,17 @@ class UnderlyingClimate(UnderlyingEntity):
 
         if not hasattr(self._underlying_climate, "current_temperature"):
             return None
+        else:
+            return self._underlying_climate.current_temperature
 
-        return self._hass.states.get(self._entity_id).attributes.get("current_temperature")
+        # return self._hass.states.get(self._entity_id).attributes.get("current_temperature")
+
+    @property
+    def is_aux_heat(self) -> bool:
+        """Get the is_aux_heat"""
+        if not self.is_initialized:
+            return False
+        return self._underlying_climate.is_aux_heat
 
     def turn_aux_heat_on(self) -> None:
         """Turn auxiliary heater on."""

hacs.json

@@ -3,5 +3,5 @@
     "content_in_root": false,
     "render_readme": true,
     "hide_default_branch": false,
-    "homeassistant": "2024.9.3"
+    "homeassistant": "2024.10.4"
 }

requirements_dev.txt

@@ -1 +1 @@
-homeassistant==2024.9.3
+homeassistant==2024.10.4

tests/test_auto_start_stop.py

@@ -0,0 +1,923 @@
+# pylint: disable=wildcard-import, unused-wildcard-import, protected-access, unused-argument, line-too-long, unused-variable
+
+""" Test the Auto Start Stop algorithm management """
+from datetime import datetime, timedelta
+import logging
+from unittest.mock import patch, call
+
+from homeassistant.components.climate import HVACMode
+
+from custom_components.versatile_thermostat.thermostat_climate import (
+    ThermostatOverClimate,
+)
+from custom_components.versatile_thermostat.auto_start_stop_algorithm import (
+    AutoStartStopDetectionAlgorithm,
+    AUTO_START_STOP_ACTION_NOTHING,
+    AUTO_START_STOP_ACTION_OFF,
+    AUTO_START_STOP_ACTION_ON,
+)
+from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
+
+logging.getLogger().setLevel(logging.DEBUG)
+
+
+async def test_auto_start_stop_algo_slow_heat_off(hass: HomeAssistant):
+    """Testing directly the algorithm in Slow level"""
+    algo: AutoStartStopDetectionAlgorithm = AutoStartStopDetectionAlgorithm(
+        AUTO_START_STOP_LEVEL_SLOW, "testu"
+    )
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    assert algo._dt == 30
+    assert algo._vtherm_name == "testu"
+
+    # 1. should not stop (accumulated_error too low)
+    ret = algo.calculate_action(
+        hvac_mode=HVACMode.HEAT,
+        saved_hvac_mode=HVACMode.OFF,
+        target_temp=21,
+        current_temp=22,
+        slope_min=0.1,
+        now=now,
+    )
+    assert ret == AUTO_START_STOP_ACTION_NOTHING
+    assert algo.accumulated_error == -1
+
+    # 2. should not stop (accumulated_error too low)
+    now = now + timedelta(minutes=5)
+    ret = algo.calculate_action(
+        hvac_mode=HVACMode.HEAT,
+        saved_hvac_mode=HVACMode.OFF,
+        target_temp=21,
+        current_temp=23,
+        slope_min=0.1,
+        now=now,
+    )
+    assert ret == AUTO_START_STOP_ACTION_NOTHING
+    assert algo.accumulated_error == -6
+
+    # 3. should not stop (accumulated_error too low)
+    now = now + timedelta(minutes=2)
+    ret = algo.calculate_action(
+        hvac_mode=HVACMode.HEAT,
+        saved_hvac_mode=HVACMode.OFF,
+        target_temp=21,
+        current_temp=23,
+        slope_min=0.1,
+        now=now,
+    )
+    assert algo.accumulated_error == -8
+    assert ret == AUTO_START_STOP_ACTION_NOTHING
+
+    # 4 .No change on accumulated error because the new measure is too near the last one
+    now = now + timedelta(minutes=1)
+    ret = algo.calculate_action(
+        hvac_mode=HVACMode.HEAT,
+        saved_hvac_mode=HVACMode.OFF,
+        target_temp=21,
+        current_temp=23,
+        slope_min=0.1,
+        now=now,
+    )
+    assert algo.accumulated_error == -8
+    assert ret == AUTO_START_STOP_ACTION_NOTHING
+
+    # 5. should stop now because accumulated_error is > ERROR_THRESHOLD for slow (10)
+    now = now + timedelta(minutes=4)
+    ret = algo.calculate_action(
+        hvac_mode=HVACMode.HEAT,
+        saved_hvac_mode=HVACMode.OFF,
+        target_temp=21,
+        current_temp=22,
+        slope_min=0.1,
+        now=now,
+    )
+    assert algo.accumulated_error == -10
+    assert ret == AUTO_START_STOP_ACTION_OFF
+
+    # 6. inverse the temperature (target > current) -> accumulated_error should be divided by 2
+    now = now + timedelta(minutes=2)
+    ret = algo.calculate_action(
+        hvac_mode=HVACMode.HEAT,
+        saved_hvac_mode=HVACMode.OFF,
+        target_temp=22,
+        current_temp=21,
+        slope_min=-0.1,
+        now=now,
+    )
+    assert algo.accumulated_error == -4  # -10/2 + 1
+    assert ret == AUTO_START_STOP_ACTION_NOTHING
+
+    # 7. change level to slow (no real change) -> error_accumulated should not reset to 0
+    algo.set_level(AUTO_START_STOP_LEVEL_SLOW)
+    assert algo.accumulated_error == -4
+
+    # 8. change level -> error_accumulated should reset to 0
+    algo.set_level(AUTO_START_STOP_LEVEL_FAST)
+    assert algo.accumulated_error == 0
+
+
+async def test_auto_start_stop_algo_medium_cool_off(hass: HomeAssistant):
+    """Testing directly the algorithm in Slow level"""
+    algo: AutoStartStopDetectionAlgorithm = AutoStartStopDetectionAlgorithm(
+        AUTO_START_STOP_LEVEL_MEDIUM, "testu"
+    )
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    assert algo._dt == 15
+    assert algo._vtherm_name == "testu"
+
+    # 1. should not stop (accumulated_error too low)
+    ret = algo.calculate_action(
+        hvac_mode=HVACMode.COOL,
+        saved_hvac_mode=HVACMode.OFF,
+        target_temp=22,
+        current_temp=21,
+        slope_min=0.1,
+        now=now,
+    )
+    assert ret == AUTO_START_STOP_ACTION_NOTHING
+    assert algo.accumulated_error == 1
+
+    # 2. should not stop (accumulated_error too low)
+    now = now + timedelta(minutes=3)
+    ret = algo.calculate_action(
+        hvac_mode=HVACMode.COOL,
+        saved_hvac_mode=HVACMode.OFF,
+        target_temp=23,
+        current_temp=21,
+        slope_min=0.1,
+        now=now,
+    )
+    assert ret == AUTO_START_STOP_ACTION_NOTHING
+    assert algo.accumulated_error == 4
+
+    # 2. should stop
+    now = now + timedelta(minutes=5)
+    ret = algo.calculate_action(
+        hvac_mode=HVACMode.COOL,
+        saved_hvac_mode=HVACMode.OFF,
+        target_temp=23,
+        current_temp=21,
+        slope_min=0.1,
+        now=now,
+    )
+    assert ret == AUTO_START_STOP_ACTION_OFF
+    assert algo.accumulated_error == 5  # should be 9 but is capped at error threshold
+
+    # 6. inverse the temperature (target > current) -> accumulated_error should be divided by 2
+    now = now + timedelta(minutes=2)
+    ret = algo.calculate_action(
+        hvac_mode=HVACMode.COOL,
+        saved_hvac_mode=HVACMode.OFF,
+        target_temp=21,
+        current_temp=22,
+        slope_min=-0.1,
+        now=now,
+    )
+    assert algo.accumulated_error == 1.5  # 5/2 - 1
+    assert ret == AUTO_START_STOP_ACTION_NOTHING
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_auto_start_stop_none_vtherm(
+    hass: HomeAssistant, skip_hass_states_is_state
+):
+    """Test than auto-start/stop is disabled with a real over_climate VTherm in NONE level"""
+
+    # vtherm_api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(hass)
+
+    # The temperatures to set
+    temps = {
+        "frost": 7.0,
+        "eco": 17.0,
+        "comfort": 19.0,
+        "boost": 21.0,
+        "eco_ac": 27.0,
+        "comfort_ac": 25.0,
+        "boost_ac": 23.0,
+        "frost_away": 7.1,
+        "eco_away": 17.1,
+        "comfort_away": 19.1,
+        "boost_away": 21.1,
+        "eco_ac_away": 27.1,
+        "comfort_ac_away": 25.1,
+        "boost_ac_away": 23.1,
+    }
+
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverClimateMockName",
+        unique_id="overClimateUniqueId",
+        data={
+            CONF_NAME: "overClimate",
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: True,
+            CONF_PRESENCE_SENSOR: "binary_sensor.presence_sensor",
+            CONF_CLIMATE: "climate.mock_climate",
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_AUTO_FAN_MODE: CONF_AUTO_FAN_TURBO,
+            CONF_AC_MODE: True,
+            CONF_AUTO_START_STOP_LEVEL: AUTO_START_STOP_LEVEL_NONE,
+        },
+    )
+
+    fake_underlying_climate = MockClimate(
+        hass=hass,
+        unique_id="mock_climate",
+        name="mock_climate",
+        hvac_modes=[HVACMode.OFF, HVACMode.COOL, HVACMode.HEAT],
+    )
+
+    with patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
+        return_value=fake_underlying_climate,
+    ):
+        vtherm: ThermostatOverClimate = await create_thermostat(
+            hass, config_entry, "climate.overclimate"
+        )
+
+        assert vtherm is not None
+
+        # Initialize all temps
+        await set_all_climate_preset_temp(hass, vtherm, temps, "overclimate")
+        # Check correct initialization of auto_start_stop attributes
+        assert (
+            vtherm._attr_extra_state_attributes["auto_start_stop_level"]
+            == AUTO_START_STOP_LEVEL_NONE
+        )
+
+        assert vtherm._attr_extra_state_attributes["auto_start_stop_dtmin"] is None
+
+    # 1. Vtherm auto-start/stop should be in NONE mode
+    assert vtherm.auto_start_stop_level == AUTO_START_STOP_LEVEL_NONE
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_auto_start_stop_medium_heat_vtherm(
+    hass: HomeAssistant, skip_hass_states_is_state
+):
+    """Test than auto-start/stop works with a real over_climate VTherm in MEDIUM level"""
+
+    # vtherm_api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(hass)
+
+    # The temperatures to set
+    temps = {
+        "frost": 7.0,
+        "eco": 17.0,
+        "comfort": 19.0,
+        "boost": 21.0,
+        "eco_ac": 27.0,
+        "comfort_ac": 25.0,
+        "boost_ac": 23.0,
+        "frost_away": 7.1,
+        "eco_away": 17.1,
+        "comfort_away": 19.1,
+        "boost_away": 21.1,
+        "eco_ac_away": 27.1,
+        "comfort_ac_away": 25.1,
+        "boost_ac_away": 23.1,
+    }
+
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverClimateMockName",
+        unique_id="overClimateUniqueId",
+        data={
+            CONF_NAME: "overClimate",
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: True,
+            CONF_PRESENCE_SENSOR: "binary_sensor.presence_sensor",
+            CONF_CLIMATE: "climate.mock_climate",
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_AUTO_FAN_MODE: CONF_AUTO_FAN_TURBO,
+            CONF_AC_MODE: True,
+            CONF_AUTO_START_STOP_LEVEL: AUTO_START_STOP_LEVEL_MEDIUM,
+        },
+    )
+
+    fake_underlying_climate = MockClimate(
+        hass=hass,
+        unique_id="mock_climate",
+        name="mock_climate",
+        hvac_modes=[HVACMode.OFF, HVACMode.COOL, HVACMode.HEAT],
+    )
+
+    with patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
+        return_value=fake_underlying_climate,
+    ):
+        vtherm: ThermostatOverClimate = await create_thermostat(
+            hass, config_entry, "climate.overclimate"
+        )
+
+        assert vtherm is not None
+
+        # Initialize all temps
+        await set_all_climate_preset_temp(hass, vtherm, temps, "overclimate")
+
+        # Check correct initialization of auto_start_stop attributes
+        assert (
+            vtherm._attr_extra_state_attributes["auto_start_stop_level"]
+            == AUTO_START_STOP_LEVEL_MEDIUM
+        )
+
+        assert vtherm._attr_extra_state_attributes["auto_start_stop_dtmin"] == 15
+
+    # 1. Vtherm auto-start/stop should be in MEDIUM mode
+    assert vtherm.auto_start_stop_level == AUTO_START_STOP_LEVEL_MEDIUM
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    # 2. Set mode to Heat and preset to Comfort
+    await send_presence_change_event(vtherm, True, False, now)
+    await send_temperature_change_event(vtherm, 18, now, True)
+    await vtherm.async_set_hvac_mode(HVACMode.HEAT)
+    await vtherm.async_set_preset_mode(PRESET_COMFORT)
+    await hass.async_block_till_done()
+
+    assert vtherm.target_temperature == 19.0
+    # VTherm should be heating
+    assert vtherm.hvac_mode == HVACMode.HEAT
+
+    # 3. Set current temperature to 19 5 min later
+    now = now + timedelta(minutes=5)
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event:
+        vtherm._set_now(now)
+        await send_temperature_change_event(vtherm, 19, now, True)
+        await hass.async_block_till_done()
+
+        # VTherm should still be heating
+        assert vtherm.hvac_mode == HVACMode.HEAT
+        assert mock_send_event.call_count == 0
+        assert (
+            vtherm._auto_start_stop_algo.accumulated_error == 0
+        )  # target = current = 19
+
+    # 4. Set current temperature to 20 5 min later
+    now = now + timedelta(minutes=5)
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event:
+        vtherm._set_now(now)
+        await send_temperature_change_event(vtherm, 20, now, True)
+        await hass.async_block_till_done()
+
+        # VTherm should still be heating
+        assert vtherm.hvac_mode == HVACMode.HEAT
+        assert mock_send_event.call_count == 0
+        # accumulated_error = target - current = -1 x 5 min / 2
+        assert vtherm._auto_start_stop_algo.accumulated_error == -2.5
+
+    # 5. Set current temperature to 21 5 min later -> should turn off
+    now = now + timedelta(minutes=5)
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event:
+        vtherm._set_now(now)
+        await send_temperature_change_event(vtherm, 21, now, True)
+        await hass.async_block_till_done()
+
+        # VTherm should have been stopped
+        assert vtherm.hvac_mode == HVACMode.OFF
+
+        # accumulated_error = -2.5 + target - current = -2 x 5 min / 2 capped to 5
+        assert vtherm._auto_start_stop_algo.accumulated_error == -5
+
+        # a message should have been sent
+        assert mock_send_event.call_count >= 1
+        mock_send_event.assert_has_calls(
+            [
+                call(
+                    event_type=EventType.AUTO_START_STOP_EVENT,
+                    data={
+                        "type": "stop",
+                        "cause": "Auto stop conditions reached",
+                        "hvac_mode": HVACMode.OFF,
+                        "saved_hvac_mode": HVACMode.HEAT,
+                        "target_temperature": 19.0,
+                        "current_temperature": 21.0,
+                        "temperature_slope": 10.03,
+                    },
+                )
+            ]
+        )
+
+        mock_send_event.assert_has_calls(
+            [
+                call(
+                    EventType.HVAC_MODE_EVENT,
+                    {
+                        "hvac_mode": HVACMode.OFF,
+                    },
+                )
+            ]
+        )
+
+    # 6. Set temperature to small over the target, so that it will stay to OFF
+    now = now + timedelta(minutes=10)
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event:
+        vtherm._set_now(now)
+        await send_temperature_change_event(vtherm, 19.5, now, True)
+        await hass.async_block_till_done()
+
+        # accumulated_error = .... capped to -5
+        assert vtherm._auto_start_stop_algo.accumulated_error == -5
+
+        # VTherm should stay stopped cause slope is too low to allow the turn to On
+        assert vtherm.hvac_mode == HVACMode.OFF
+
+    # 7. Set temperature to over the target, so that it will turn to heat
+    now = now + timedelta(minutes=20)
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event:
+        vtherm._set_now(now)
+        await send_temperature_change_event(vtherm, 18, now, True)
+        await hass.async_block_till_done()
+
+        # accumulated_error = -5/2 + target - current = 1 x 20 min / 2 capped to 5
+        assert vtherm._auto_start_stop_algo.accumulated_error == 5
+
+        # VTherm should have been stopped
+        assert vtherm.hvac_mode == HVACMode.HEAT
+        # a message should have been sent
+        assert mock_send_event.call_count >= 1
+        mock_send_event.assert_has_calls(
+            [
+                call(
+                    event_type=EventType.AUTO_START_STOP_EVENT,
+                    data={
+                        "type": "start",
+                        "cause": "Auto start conditions reached",
+                        "hvac_mode": HVACMode.HEAT,
+                        "saved_hvac_mode": HVACMode.HEAT,  # saved don't change
+                        "target_temperature": 19.0,
+                        "current_temperature": 18.0,
+                        "temperature_slope": -2.06,
+                    },
+                )
+            ]
+        )
+
+        mock_send_event.assert_has_calls(
+            [
+                call(
+                    EventType.HVAC_MODE_EVENT,
+                    {
+                        "hvac_mode": HVACMode.HEAT,
+                    },
+                )
+            ]
+        )
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_auto_start_stop_fast_ac_vtherm(
+    hass: HomeAssistant, skip_hass_states_is_state
+):
+    """Test than auto-start/stop works with a real over_climate VTherm in FAST level and AC mode"""
+
+    # vtherm_api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(hass)
+
+    # The temperatures to set
+    temps = {
+        "frost": 7.0,
+        "eco": 17.0,
+        "comfort": 19.0,
+        "boost": 21.0,
+        "eco_ac": 27.0,
+        "comfort_ac": 25.0,
+        "boost_ac": 23.0,
+        "frost_away": 7.1,
+        "eco_away": 17.1,
+        "comfort_away": 19.1,
+        "boost_away": 21.1,
+        "eco_ac_away": 27.1,
+        "comfort_ac_away": 25.1,
+        "boost_ac_away": 23.1,
+    }
+
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverClimateMockName",
+        unique_id="overClimateUniqueId",
+        data={
+            CONF_NAME: "overClimate",
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: True,
+            CONF_PRESENCE_SENSOR: "binary_sensor.presence_sensor",
+            CONF_CLIMATE: "climate.mock_climate",
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_AUTO_FAN_MODE: CONF_AUTO_FAN_TURBO,
+            CONF_AC_MODE: True,
+            CONF_AUTO_START_STOP_LEVEL: AUTO_START_STOP_LEVEL_FAST,
+        },
+    )
+
+    fake_underlying_climate = MockClimate(
+        hass=hass,
+        unique_id="mock_climate",
+        name="mock_climate",
+        hvac_modes=[HVACMode.OFF, HVACMode.COOL, HVACMode.HEAT],
+    )
+
+    with patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
+        return_value=fake_underlying_climate,
+    ):
+        vtherm: ThermostatOverClimate = await create_thermostat(
+            hass, config_entry, "climate.overclimate"
+        )
+
+        assert vtherm is not None
+
+        # Initialize all temps
+        await set_all_climate_preset_temp(hass, vtherm, temps, "overclimate")
+
+        # Check correct initialization of auto_start_stop attributes
+        assert (
+            vtherm._attr_extra_state_attributes["auto_start_stop_level"]
+            == AUTO_START_STOP_LEVEL_FAST
+        )
+
+        assert vtherm._attr_extra_state_attributes["auto_start_stop_dtmin"] == 7
+
+    # 1. Vtherm auto-start/stop should be in MEDIUM mode
+    assert vtherm.auto_start_stop_level == AUTO_START_STOP_LEVEL_FAST
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    # 2. Set mode to Heat and preset to Comfort
+    await send_presence_change_event(vtherm, True, False, now)
+    await send_temperature_change_event(vtherm, 27, now, True)
+    await vtherm.async_set_hvac_mode(HVACMode.COOL)
+    await vtherm.async_set_preset_mode(PRESET_COMFORT)
+    await hass.async_block_till_done()
+
+    assert vtherm.target_temperature == 25.0
+    # VTherm should be heating
+    assert vtherm.hvac_mode == HVACMode.COOL
+
+    # 3. Set current temperature to 19 5 min later
+    now = now + timedelta(minutes=5)
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event:
+        vtherm._set_now(now)
+        await send_temperature_change_event(vtherm, 25, now, True)
+        await hass.async_block_till_done()
+
+        # VTherm should still be heating
+        assert vtherm.hvac_mode == HVACMode.COOL
+        assert mock_send_event.call_count == 0
+        assert (
+            vtherm._auto_start_stop_algo.accumulated_error == 0  # target = current = 25
+        )
+
+    # 4. Set current temperature to 23 5 min later -> should turn off
+    now = now + timedelta(minutes=5)
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event:
+        vtherm._set_now(now)
+        await send_temperature_change_event(vtherm, 23, now, True)
+        await hass.async_block_till_done()
+
+        # VTherm should have been stopped
+        assert vtherm.hvac_mode == HVACMode.OFF
+
+        # accumulated_error = target - current = 2 x 5 min / 2 capped to 2
+        assert vtherm._auto_start_stop_algo.accumulated_error == 2
+
+        # a message should have been sent
+        assert mock_send_event.call_count >= 1
+        mock_send_event.assert_has_calls(
+            [
+                call(
+                    event_type=EventType.AUTO_START_STOP_EVENT,
+                    data={
+                        "type": "stop",
+                        "cause": "Auto stop conditions reached",
+                        "hvac_mode": HVACMode.OFF,
+                        "saved_hvac_mode": HVACMode.COOL,
+                        "target_temperature": 25.0,
+                        "current_temperature": 23.0,
+                        "temperature_slope": -16.8,
+                    },
+                )
+            ]
+        )
+
+        mock_send_event.assert_has_calls(
+            [
+                call(
+                    EventType.HVAC_MODE_EVENT,
+                    {
+                        "hvac_mode": HVACMode.OFF,
+                    },
+                )
+            ]
+        )
+
+    # 5. Set temperature to over the target, but slope is too low -> no change
+    now = now + timedelta(minutes=20)
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event:
+        vtherm._set_now(now)
+        await send_temperature_change_event(vtherm, 26, now, True)
+        await hass.async_block_till_done()
+
+        # accumulated_error = 2/2 + target - current = -1 x 20 min / 2 capped to 2
+        assert vtherm._auto_start_stop_algo.accumulated_error == -2
+
+        # VTherm should have been stopped
+        assert vtherm.hvac_mode == HVACMode.OFF
+        # a message should have been sent
+        assert mock_send_event.call_count == 0
+
+    # 6. Set temperature to over the target, so that it will turn to COOL
+    now = now + timedelta(minutes=5)
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event:
+        vtherm._set_now(now)
+        await send_temperature_change_event(vtherm, 26.5, now, True)
+        await hass.async_block_till_done()
+
+        # accumulated_error = 2/2 + target - current = -1 x 20 min / 2 capped to 2
+        assert vtherm._auto_start_stop_algo.accumulated_error == -2
+
+        # VTherm should have been stopped
+        assert vtherm.hvac_mode == HVACMode.COOL
+        # a message should have been sent
+        assert mock_send_event.call_count >= 1
+        mock_send_event.assert_has_calls(
+            [
+                call(
+                    event_type=EventType.AUTO_START_STOP_EVENT,
+                    data={
+                        "type": "start",
+                        "cause": "Auto start conditions reached",
+                        "hvac_mode": HVACMode.COOL,
+                        "saved_hvac_mode": HVACMode.COOL,  # saved don't change
+                        "target_temperature": 25.0,
+                        "current_temperature": 26.5,
+                        "temperature_slope": 5.74,
+                    },
+                )
+            ]
+        )
+
+        mock_send_event.assert_has_calls(
+            [
+                call(
+                    EventType.HVAC_MODE_EVENT,
+                    {
+                        "hvac_mode": HVACMode.COOL,
+                    },
+                )
+            ]
+        )
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_auto_start_stop_medium_heat_vtherm_preset_change(
+    hass: HomeAssistant, skip_hass_states_is_state
+):
+    """Test than auto-start/stop restart a VTherm stopped upon preset_change (in fast mode)"""
+
+    # vtherm_api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(hass)
+
+    # The temperatures to set
+    temps = {
+        "frost": 7.0,
+        "eco": 17.0,
+        "comfort": 19.0,
+        "boost": 21.0,
+        "eco_ac": 27.0,
+        "comfort_ac": 25.0,
+        "boost_ac": 23.0,
+        "frost_away": 7.1,
+        "eco_away": 17.1,
+        "comfort_away": 19.1,
+        "boost_away": 21.1,
+        "eco_ac_away": 27.1,
+        "comfort_ac_away": 25.1,
+        "boost_ac_away": 23.1,
+    }
+
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverClimateMockName",
+        unique_id="overClimateUniqueId",
+        data={
+            CONF_NAME: "overClimate",
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: True,
+            CONF_PRESENCE_SENSOR: "binary_sensor.presence_sensor",
+            CONF_CLIMATE: "climate.mock_climate",
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_AUTO_FAN_MODE: CONF_AUTO_FAN_TURBO,
+            CONF_AC_MODE: True,
+            CONF_AUTO_START_STOP_LEVEL: AUTO_START_STOP_LEVEL_FAST,
+        },
+    )
+
+    fake_underlying_climate = MockClimate(
+        hass=hass,
+        unique_id="mock_climate",
+        name="mock_climate",
+        hvac_modes=[HVACMode.OFF, HVACMode.COOL, HVACMode.HEAT],
+    )
+
+    with patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
+        return_value=fake_underlying_climate,
+    ):
+        vtherm: ThermostatOverClimate = await create_thermostat(
+            hass, config_entry, "climate.overclimate"
+        )
+
+        assert vtherm is not None
+
+        # Initialize all temps
+        await set_all_climate_preset_temp(hass, vtherm, temps, "overclimate")
+
+        # Check correct initialization of auto_start_stop attributes
+        assert (
+            vtherm._attr_extra_state_attributes["auto_start_stop_level"]
+            == AUTO_START_STOP_LEVEL_FAST
+        )
+
+        assert vtherm._attr_extra_state_attributes["auto_start_stop_dtmin"] == 7
+
+    # 1. Vtherm auto-start/stop should be in MEDIUM mode
+    assert vtherm.auto_start_stop_level == AUTO_START_STOP_LEVEL_FAST
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    # 2. Set mode to Heat and preset to Comfort
+    await send_presence_change_event(vtherm, True, False, now)
+    await send_temperature_change_event(vtherm, 16, now, True)
+    await vtherm.async_set_hvac_mode(HVACMode.HEAT)
+    await vtherm.async_set_preset_mode(PRESET_ECO)
+    await hass.async_block_till_done()
+
+    assert vtherm.target_temperature == 17.0
+    # VTherm should be heating
+    assert vtherm.hvac_mode == HVACMode.HEAT
+
+    # 3. Set current temperature to 21 5 min later to auto-stop
+    now = now + timedelta(minutes=5)
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event:
+        vtherm._set_now(now)
+        await send_temperature_change_event(vtherm, 19, now, True)
+        await hass.async_block_till_done()
+
+        # VTherm should have been stopped
+        assert vtherm.hvac_mode == HVACMode.OFF
+
+        assert vtherm._auto_start_stop_algo.accumulated_error == -2
+
+        # a message should have been sent
+        assert mock_send_event.call_count >= 1
+        mock_send_event.assert_has_calls(
+            [
+                call(
+                    event_type=EventType.AUTO_START_STOP_EVENT,
+                    data={
+                        "type": "stop",
+                        "cause": "Auto stop conditions reached",
+                        "hvac_mode": HVACMode.OFF,
+                        "saved_hvac_mode": HVACMode.HEAT,
+                        "target_temperature": 17.0,
+                        "current_temperature": 19.0,
+                        "temperature_slope": 18.0,
+                    },
+                )
+            ]
+        )
+
+        mock_send_event.assert_has_calls(
+            [
+                call(
+                    EventType.HVAC_MODE_EVENT,
+                    {
+                        "hvac_mode": HVACMode.OFF,
+                    },
+                )
+            ]
+        )
+
+    # 4.1 reduce the slope (because slope is smoothed and was very high)
+    now = now + timedelta(minutes=5)
+    await send_temperature_change_event(vtherm, 19, now, True)
+
+    now = now + timedelta(minutes=5)
+    await send_temperature_change_event(vtherm, 18, now, True)
+
+    now = now + timedelta(minutes=5)
+    await send_temperature_change_event(vtherm, 17, now, True)
+
+    # 4. Change preset to auto restart the Vtherm
+    now = now + timedelta(minutes=10)
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event:
+        vtherm._set_now(now)
+        await vtherm.async_set_preset_mode(PRESET_BOOST)
+        await hass.async_block_till_done()
+        assert vtherm.target_temperature == 21
+
+        assert vtherm._auto_start_stop_algo.accumulated_error == 2
+
+        # VTherm should have been restarted
+        assert vtherm.hvac_mode == HVACMode.HEAT
+        # a message should have been sent
+        assert mock_send_event.call_count >= 1
+        mock_send_event.assert_has_calls(
+            [
+                call(
+                    event_type=EventType.AUTO_START_STOP_EVENT,
+                    data={
+                        "type": "start",
+                        "cause": "Auto start conditions reached",
+                        "hvac_mode": HVACMode.HEAT,
+                        "saved_hvac_mode": HVACMode.HEAT,  # saved don't change
+                        "target_temperature": 21.0,
+                        "current_temperature": 17.0,
+                        "temperature_slope": -5.19,
+                    },
+                )
+            ]
+        )
+
+        mock_send_event.assert_has_calls(
+            [
+                call(
+                    EventType.HVAC_MODE_EVENT,
+                    {
+                        "hvac_mode": HVACMode.HEAT,
+                    },
+                )
+            ]
+        )

tests/test_config_flow.py

@@ -27,7 +27,7 @@ async def test_show_form(hass: HomeAssistant, init_vtherm_api) -> None:
 @pytest.mark.parametrize("expected_lingering_tasks", [True])
 @pytest.mark.parametrize("expected_lingering_timers", [True])
 # Disable this test which don't work anymore (kill the pytest !)
-# @pytest.mark.skip
+@pytest.mark.skip
 async def test_user_config_flow_over_switch(
     hass: HomeAssistant, skip_hass_states_get, init_central_config
 ):  # pylint: disable=unused-argument
@@ -280,6 +280,7 @@ async def test_user_config_flow_over_switch(
             CONF_USE_POWER_CENTRAL_CONFIG: True,
             CONF_USE_PRESENCE_CENTRAL_CONFIG: True,
             CONF_USE_ADVANCED_CENTRAL_CONFIG: True,
+            CONF_USE_AUTO_START_STOP_FEATURE: False,
             CONF_USE_CENTRAL_MODE: True,
             CONF_USED_BY_CENTRAL_BOILER: False,
             CONF_USE_WINDOW_FEATURE: True,
@@ -299,11 +300,11 @@ async def test_user_config_flow_over_switch(
 @pytest.mark.parametrize("expected_lingering_tasks", [True])
 @pytest.mark.parametrize("expected_lingering_timers", [True])
 # TODO this test fails when run in // but works alone
-@pytest.mark.skip
+# @pytest.mark.skip
 async def test_user_config_flow_over_climate(
     hass: HomeAssistant, skip_hass_states_get
 ):  # pylint: disable=unused-argument
-    """Test the config flow with all thermostat_over_switch features and never use central config.
+    """Test the config flow with all thermostat_over_climate features and never use central config.
     We don't use any features"""
     # await create_central_config(hass)
 
@@ -499,6 +500,7 @@ async def test_user_config_flow_over_climate(
         CONF_USE_POWER_FEATURE: False,
         CONF_USE_PRESENCE_FEATURE: False,
         CONF_USE_WINDOW_FEATURE: False,
+        CONF_USE_AUTO_START_STOP_FEATURE: False,
         CONF_USE_CENTRAL_BOILER_FEATURE: False,
         CONF_USE_TPI_CENTRAL_CONFIG: False,
         CONF_USE_WINDOW_CENTRAL_CONFIG: False,
@@ -877,3 +879,251 @@ async def test_user_config_flow_over_4_switches(
     assert result["result"].version == 1
     assert result["result"].title == "TheOver4SwitchMockName"
     assert isinstance(result["result"], ConfigEntry)
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+# TODO this test fails when run in // but works alone
+# @pytest.mark.skip
+async def test_user_config_flow_over_climate_auto_start_stop(
+    hass: HomeAssistant, skip_hass_states_get
+):  # pylint: disable=unused-argument
+    """Test the config flow with auto_start_stop thermostat_over_climate features."""
+    # await create_central_config(hass)
+
+    # 1. start a config flow in over_climate
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == SOURCE_USER
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input={
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
+        },
+    )
+    assert result["type"] == FlowResultType.MENU
+    assert result["step_id"] == "menu"
+    assert result["menu_options"] == [
+        "main",
+        "features",
+        "type",
+        "presets",
+        "advanced",
+        "configuration_not_complete",
+    ]
+    assert result.get("errors") is None
+
+    # 2. Add auto-start-stop feature
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input={"next_step_id": "features"}
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "features"
+    assert result.get("errors") == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input={
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_AUTO_START_STOP_FEATURE: True,
+        },
+    )
+    assert result["type"] == FlowResultType.MENU
+    assert result["step_id"] == "menu"
+    assert result.get("errors") is None
+    assert result["menu_options"] == [
+        "main",
+        "features",
+        "type",
+        "presets",
+        "auto_start_stop",
+        "advanced",
+        "configuration_not_complete",
+        # "finalize", finalize is not present waiting for advanced configuration
+    ]
+
+    # 3. Configure auto-start-stop attributes
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input={"next_step_id": "auto_start_stop"}
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "auto_start_stop"
+    assert result.get("errors") == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input={
+            CONF_AUTO_START_STOP_LEVEL: AUTO_START_STOP_LEVEL_MEDIUM,
+        },
+    )
+    assert result["type"] == FlowResultType.MENU
+    assert result["step_id"] == "menu"
+    assert result.get("errors") is None
+
+    # 4. Configure main attributes
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input={"next_step_id": "main"}
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "main"
+    assert result.get("errors") == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input={
+            CONF_NAME: "TheOverClimateMockName",
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_DEVICE_POWER: 1,
+            CONF_USE_MAIN_CENTRAL_CONFIG: False,
+            CONF_USE_CENTRAL_MODE: True,
+            # Keep default values which are False
+        },
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "main"
+    assert result.get("errors") == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input={
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            CONF_STEP_TEMPERATURE: 0.1,
+            # Keep default values which are False
+        },
+    )
+    assert result["type"] == FlowResultType.MENU
+    assert result["step_id"] == "menu"
+    assert result.get("errors") is None
+
+    # 5. Configure type attributes
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input={"next_step_id": "type"}
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "type"
+    assert result.get("errors") == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input={
+            CONF_CLIMATE: "climate.mock_climate",
+            CONF_AC_MODE: False,
+            CONF_AUTO_REGULATION_MODE: CONF_AUTO_REGULATION_STRONG,
+            CONF_AUTO_REGULATION_DTEMP: 0.5,
+            CONF_AUTO_REGULATION_PERIOD_MIN: 2,
+            CONF_AUTO_FAN_MODE: CONF_AUTO_FAN_HIGH,
+            CONF_AUTO_REGULATION_USE_DEVICE_TEMP: False,
+        },
+    )
+    assert result["type"] == FlowResultType.MENU
+    assert result["step_id"] == "menu"
+    assert result["menu_options"] == [
+        "main",
+        "features",
+        "type",
+        "presets",
+        "auto_start_stop",
+        "advanced",
+        "configuration_not_complete",
+        # "finalize",  # because we need Advanced default parameters
+    ]
+    assert result.get("errors") is None
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input={"next_step_id": "presets"}
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "presets"
+    assert result.get("errors") == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input={CONF_USE_PRESETS_CENTRAL_CONFIG: False}
+    )
+    assert result["type"] == FlowResultType.MENU
+    assert result["step_id"] == "menu"
+    assert result.get("errors") is None
+
+    # 6. configure advanced attributes
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input={"next_step_id": "advanced"}
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "advanced"
+    assert result.get("errors") == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input={CONF_USE_ADVANCED_CENTRAL_CONFIG: False},
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "advanced"
+    assert result.get("errors") == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input={
+            CONF_MINIMAL_ACTIVATION_DELAY: 10,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.4,
+            CONF_SECURITY_DEFAULT_ON_PERCENT: 0.3,
+        },
+    )
+    assert result["type"] == FlowResultType.MENU
+    assert result["step_id"] == "menu"
+    assert result.get("errors") is None
+    assert result["menu_options"] == [
+        "main",
+        "features",
+        "type",
+        "presets",
+        "auto_start_stop",
+        "advanced",
+        "finalize",  # Now finalize is present
+    ]
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input={"next_step_id": "finalize"}
+    )
+    assert result["type"] == FlowResultType.CREATE_ENTRY
+    assert result.get("errors") is None
+    assert result[
+        "data"
+    ] == MOCK_TH_OVER_CLIMATE_USER_CONFIG | MOCK_TH_OVER_CLIMATE_MAIN_CONFIG | MOCK_TH_OVER_CLIMATE_CENTRAL_MAIN_CONFIG | MOCK_TH_OVER_CLIMATE_TYPE_CONFIG | {
+        CONF_MINIMAL_ACTIVATION_DELAY: 10,
+        CONF_SECURITY_DELAY_MIN: 5,
+        CONF_SECURITY_MIN_ON_PERCENT: 0.4,
+        CONF_SECURITY_DEFAULT_ON_PERCENT: 0.3,
+    } | MOCK_DEFAULT_FEATURE_CONFIG | {
+        CONF_USE_MAIN_CENTRAL_CONFIG: False,
+        CONF_USE_TPI_CENTRAL_CONFIG: False,
+        CONF_USE_PRESETS_CENTRAL_CONFIG: False,
+        CONF_USE_MOTION_FEATURE: False,
+        CONF_USE_POWER_FEATURE: False,
+        CONF_USE_PRESENCE_FEATURE: False,
+        CONF_USE_WINDOW_FEATURE: False,
+        CONF_USE_AUTO_START_STOP_FEATURE: False,
+        CONF_USE_CENTRAL_BOILER_FEATURE: False,
+        CONF_USE_TPI_CENTRAL_CONFIG: False,
+        CONF_USE_WINDOW_CENTRAL_CONFIG: False,
+        CONF_USE_MOTION_CENTRAL_CONFIG: False,
+        CONF_USE_POWER_CENTRAL_CONFIG: False,
+        CONF_USE_PRESENCE_CENTRAL_CONFIG: False,
+        CONF_USE_ADVANCED_CENTRAL_CONFIG: False,
+        CONF_USED_BY_CENTRAL_BOILER: False,
+        CONF_USE_AUTO_START_STOP_FEATURE: True,
+        CONF_AUTO_START_STOP_LEVEL: AUTO_START_STOP_LEVEL_MEDIUM,
+    }
+    assert result["result"]
+    assert result["result"].domain == DOMAIN
+    assert result["result"].version == 1
+    assert result["result"].title == "TheOverClimateMockName"
+    assert isinstance(result["result"], ConfigEntry)

tests/test_movement.py

@@ -97,7 +97,12 @@ async def test_movement_management_time_not_enough(
         return_value=False,
     ), patch(
         "homeassistant.helpers.condition.state", return_value=False
-    ) as mock_condition:
+    ) as mock_condition, patch(
+        "homeassistant.core.StateMachine.get",
+        return_value=State(
+            entity_id="binary_sensor.mock_motion_sensor", state=STATE_OFF
+        ),
+    ):
         event_timestamp = now - timedelta(minutes=4)
         try_condition = await send_motion_change_event(entity, True, False, event_timestamp)
 
@@ -109,8 +114,8 @@ async def test_movement_management_time_not_enough(
         # because no motion is detected yet
         assert entity.target_temperature == 18
         # state is not changed if time is not enough
-        assert entity.motion_state is None
-        assert entity.presence_state == "on"
+        assert entity.motion_state is STATE_OFF
+        assert entity.presence_state == STATE_ON
 
         assert mock_send_event.call_count == 0
         # Change is not confirmed
@@ -141,8 +146,8 @@ async def test_movement_management_time_not_enough(
         assert entity.preset_mode is PRESET_ACTIVITY
         # because motion is detected yet
         assert entity.target_temperature == 19
-        assert entity.motion_state == "on"
-        assert entity.presence_state == "on"
+        assert entity.motion_state == STATE_ON
+        assert entity.presence_state == STATE_ON
 
     # stop detecting motion with off delay too low
     with patch(
@@ -156,19 +161,24 @@ async def test_movement_management_time_not_enough(
         return_value=True,
     ) as mock_device_active, patch(
         "homeassistant.helpers.condition.state", return_value=False
-    ) as mock_condition:
+    ) as mock_condition, patch(
+        "homeassistant.core.StateMachine.get",
+        return_value=State(
+            entity_id="binary_sensor.mock_motion_sensor", state=STATE_OFF
+        ),
+    ):
         event_timestamp = now - timedelta(minutes=2)
         try_condition = await send_motion_change_event(entity, False, True, event_timestamp)
 
-         # Will return False -> we will stay to movement On
+        # Will return False -> we will stay to movement On
         await try_condition(None)
 
         assert entity.hvac_mode is HVACMode.HEAT
         assert entity.preset_mode is PRESET_ACTIVITY
         # because no motion is detected yet
         assert entity.target_temperature == 19
-        assert entity.motion_state == "on"
-        assert entity.presence_state == "on"
+        assert entity.motion_state == STATE_ON
+        assert entity.presence_state == STATE_ON
 
         assert mock_send_event.call_count == 0
         # The heater must heat now
@@ -192,15 +202,15 @@ async def test_movement_management_time_not_enough(
         event_timestamp = now - timedelta(minutes=1)
         try_condition = await send_motion_change_event(entity, False, True, event_timestamp)
 
-         # Will return True -> we will switch to movement Off
+        # Will return True -> we will switch to movement Off
         await try_condition(None)
 
         assert entity.hvac_mode is HVACMode.HEAT
         assert entity.preset_mode is PRESET_ACTIVITY
         # because no motion is detected yet
         assert entity.target_temperature == 18
-        assert entity.motion_state == "off"
-        assert entity.presence_state == "on"
+        assert entity.motion_state == STATE_OFF
+        assert entity.presence_state == STATE_ON
 
         assert mock_send_event.call_count == 0
         # The heater must stop heating now
@@ -214,7 +224,7 @@ async def test_movement_management_time_not_enough(
 async def test_movement_management_time_enough_and_presence(
     hass: HomeAssistant, skip_hass_states_is_state
 ):
-    """Test the Presence management when time is not enough"""
+    """Test the Motion management when time is not enough"""
 
     entry = MockConfigEntry(
         domain=DOMAIN,
@@ -479,7 +489,7 @@ async def test_movement_management_time_enoughand_not_presence(
 async def test_movement_management_with_stop_during_condition(
     hass: HomeAssistant, skip_hass_states_is_state
 ):
-    """Test the Presence management when the movement sensor switch to off and then to on during the test condition"""
+    """Test the Motion management when the movement sensor switch to off and then to on during the test condition"""
 
     entry = MockConfigEntry(
         domain=DOMAIN,
@@ -558,9 +568,13 @@ async def test_movement_management_with_stop_during_condition(
     ) as mock_heater_off, patch(
         "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
         return_value=True,
-    ), patch("homeassistant.helpers.condition.state", return_value=True): # Not needed for this test
+    ), patch(
+        "homeassistant.helpers.condition.state", return_value=True
+    ):  # Not needed for this test
         event_timestamp = now - timedelta(minutes=5)
-        try_condition1 = await send_motion_change_event(entity, True, False, event_timestamp)
+        try_condition1 = await send_motion_change_event(
+            entity, True, False, event_timestamp
+        )
 
         assert try_condition1 is not None
 
@@ -573,8 +587,10 @@ async def test_movement_management_with_stop_during_condition(
 
         # Send a stop detection
         event_timestamp = now - timedelta(minutes=4)
-        try_condition = await send_motion_change_event(entity, False, True, event_timestamp)
-        assert try_condition is None    # The timer should not have been stopped
+        try_condition = await send_motion_change_event(
+            entity, False, True, event_timestamp
+        )
+        assert try_condition is None  # The timer should not have been stopped
 
         assert entity.hvac_mode is HVACMode.HEAT
         assert entity.preset_mode is PRESET_ACTIVITY
@@ -584,8 +600,12 @@ async def test_movement_management_with_stop_during_condition(
 
         # Resend a start detection
         event_timestamp = now - timedelta(minutes=3)
-        try_condition = await send_motion_change_event(entity, True, False, event_timestamp)
-        assert try_condition is None  # The timer should not have been restarted (we keep the first one)
+        try_condition = await send_motion_change_event(
+            entity, True, False, event_timestamp
+        )
+        assert (
+            try_condition is None
+        )  # The timer should not have been restarted (we keep the first one)
 
         assert entity.hvac_mode is HVACMode.HEAT
         assert entity.preset_mode is PRESET_ACTIVITY
@@ -596,6 +616,122 @@ async def test_movement_management_with_stop_during_condition(
 
         await try_condition1(None)
         # We should have switch this time
-        assert entity.target_temperature == 19 # Boost
-        assert entity.motion_state == "on"     # switch to movement on
+        assert entity.target_temperature == 19  # Boost
+        assert entity.motion_state == "on"  # switch to movement on
         assert entity.presence_state == "off"  # Non change
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_movement_management_with_stop_during_condition_last_state_on(
+    hass: HomeAssistant, skip_hass_states_is_state
+):
+    """Test the Motion management when the movement sensor switch to off and then to on during the test condition"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOverSwitchMockName",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            "eco_away_temp": 17,
+            "comfort_away_temp": 18,
+            "boost_away_temp": 19,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: True,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch",
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_MOTION_SENSOR: "binary_sensor.mock_motion_sensor",
+            CONF_MOTION_DELAY: 10,
+            CONF_MOTION_OFF_DELAY: 30,
+            CONF_MOTION_PRESET: "boost",
+            CONF_NO_MOTION_PRESET: "comfort",
+        },
+    )
+
+    entity: BaseThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    # 0. start heating, in boost mode. We block the control_heating to avoid running a cycle
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.async_control_heating"
+    ):
+        await entity.async_set_hvac_mode(HVACMode.HEAT)
+        await entity.async_set_preset_mode(PRESET_ACTIVITY)
+
+        assert entity.hvac_mode is HVACMode.HEAT
+        assert entity.preset_mode is PRESET_ACTIVITY
+        # because no motion is detected yet
+        assert entity.target_temperature == 18
+        assert entity.motion_state is None
+
+        event_timestamp = now - timedelta(minutes=6)
+        await send_temperature_change_event(entity, 18, event_timestamp)
+        await send_ext_temperature_change_event(entity, 10, event_timestamp)
+
+    # 1. starts detecting motion but the sensor is off
+    with patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=True,
+    ), patch("homeassistant.helpers.condition.state", return_value=False), patch(
+        "homeassistant.core.StateMachine.get",
+        return_value=State(
+            entity_id="binary_sensor.mock_motion_sensor", state=STATE_OFF
+        ),
+    ):
+        event_timestamp = now - timedelta(minutes=5)
+        try_condition1 = await send_motion_change_event(
+            entity, True, False, event_timestamp
+        )
+
+        assert try_condition1 is not None
+
+        await try_condition1(None)
+
+        # because no motion is detected yet -> condition.state is False and sensor is not active
+        assert entity.target_temperature == 18
+        assert entity.motion_state is STATE_OFF
+
+    # 2. starts detecting motion but the sensor is on
+    with patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=True,
+    ), patch("homeassistant.helpers.condition.state", return_value=False), patch(
+        "homeassistant.core.StateMachine.get",
+        return_value=State(
+            entity_id="binary_sensor.mock_motion_sensor", state=STATE_ON
+        ),
+    ):
+        event_timestamp = now - timedelta(minutes=5)
+        try_condition1 = await send_motion_change_event(
+            entity, True, False, event_timestamp
+        )
+
+        assert try_condition1 is not None
+
+        await try_condition1(None)
+
+        # because no motion is detected yet -> condition.state is False and sensor is not active
+        assert entity.target_temperature == 19
+        assert entity.motion_state is STATE_ON

tests/test_overclimate.py

@@ -276,7 +276,7 @@ async def test_bug_101(
             HVACAction.OFF,
             HVACAction.OFF,
             now,
-            12.75,
+            entity.min_temp + 1,
             True,
             "climate.mock_climate",  # the underlying climate entity id
         )
@@ -295,11 +295,11 @@ async def test_bug_101(
             HVACAction.OFF,
             HVACAction.OFF,
             event_timestamp,
-            12.75,
+            entity.min_temp + 1,
             True,
             "climate.mock_climate",  # the underlying climate entity id
         )
-        assert entity.target_temperature == 12.75
+        assert entity.target_temperature == entity.min_temp + 1
         assert entity.preset_mode is PRESET_NONE
 
         # 4. Change the target temp with < 1 value. The value should not be taken
@@ -312,11 +312,11 @@ async def test_bug_101(
             HVACAction.OFF,
             HVACAction.OFF,
             event_timestamp,
-            12.5,  # 12.75 means 13 in vtherm
+            entity.min_temp + 1.5,
             True,
             "climate.mock_climate",  # the underlying climate entity id
         )
-        assert entity.target_temperature == 12.75
+        assert entity.target_temperature == entity.min_temp + 1
         assert entity.preset_mode is PRESET_NONE
 
 
@@ -523,3 +523,111 @@ async def test_bug_524(hass: HomeAssistant, skip_hass_states_is_state):
     await send_presence_change_event(vtherm, True, False, datetime.now())
     await hass.async_block_till_done()
     assert vtherm.target_temperature == 25
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_ignore_temp_outside_minmax_range(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test that when a underlying climate target temp is changed, the VTherm ignores the target temp if it is outside the min/max range"""
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverClimateMockName",
+        unique_id="uniqueId",
+        data=PARTIAL_CLIMATE_NOT_REGULATED_CONFIG,  # 5 minutes security delay
+    )
+
+    # Underlying is in HEAT mode but should be shutdown at startup
+    fake_underlying_climate = MockClimate(
+        hass, "mockUniqueId", "MockClimateName", {}, HVACMode.HEAT, HVACAction.HEATING
+    )
+
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
+        return_value=fake_underlying_climate,
+    ) as mock_find_climate, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.set_hvac_mode"
+    ) as mock_underlying_set_hvac_mode:
+        entity = await create_thermostat(hass, entry, "climate.theoverclimatemockname")
+
+        assert entity
+
+        assert entity.name == "TheOverClimateMockName"
+        assert entity.is_over_climate is True
+        assert entity.hvac_mode is HVACMode.OFF
+        # because in MockClimate HVACAction is HEATING if hvac_mode is not set
+        assert entity.hvac_action is HVACAction.HEATING
+        # Underlying should have been shutdown
+        assert mock_underlying_set_hvac_mode.call_count == 1
+        mock_underlying_set_hvac_mode.assert_has_calls(
+            [
+                call.set_hvac_mode(HVACMode.OFF),
+            ]
+        )
+
+        assert entity.target_temperature == entity.min_temp
+        assert entity.preset_mode is PRESET_NONE
+
+        # should have been called with EventType.PRESET_EVENT and EventType.HVAC_MODE_EVENT
+        assert mock_send_event.call_count == 2
+        mock_send_event.assert_has_calls(
+            [
+                call.send_event(EventType.PRESET_EVENT, {"preset": PRESET_NONE}),
+                call.send_event(
+                    EventType.HVAC_MODE_EVENT,
+                    {"hvac_mode": HVACMode.OFF},
+                ),
+            ]
+        )
+
+        assert mock_find_climate.call_count == 1
+        assert mock_find_climate.mock_calls[0] == call()
+        mock_find_climate.assert_has_calls([call.find_underlying_entity()])
+
+        # 1. Force preset mode
+        await entity.async_set_hvac_mode(HVACMode.HEAT)
+        assert entity.hvac_mode == HVACMode.HEAT
+        await entity.async_set_preset_mode(PRESET_COMFORT)
+        assert entity.preset_mode == PRESET_COMFORT
+
+        # 1. Try to set the target temperature to a below min_temp -> should be ignored
+        # Wait 11 sec
+        event_timestamp = now + timedelta(seconds=11)
+        assert entity.is_regulated is False
+        await send_climate_change_event_with_temperature(
+            entity,
+            HVACMode.HEAT,
+            HVACMode.HEAT,
+            HVACAction.OFF,
+            HVACAction.OFF,
+            event_timestamp,
+            entity.min_temp - 1,
+            True,
+            "climate.mock_climate",  # the underlying climate entity id
+        )
+        assert entity.target_temperature == 17
+
+        # 2. Try to set the target temperature to a above max_temp -> should be ignored
+        event_timestamp = event_timestamp + timedelta(seconds=11)
+        assert entity.is_regulated is False
+        await send_climate_change_event_with_temperature(
+            entity,
+            HVACMode.HEAT,
+            HVACMode.HEAT,
+            HVACAction.OFF,
+            HVACAction.OFF,
+            event_timestamp,
+            entity.max_temp + 1,
+            True,
+            "climate.mock_climate",  # the underlying climate entity id
+        )
+        assert entity.target_temperature == 17