+ comment

custom_components/versatile_thermostat/auto_start_stop_algorithm.py

@@ -0,0 +1,223 @@
+# 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
+
+        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
+
+        _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,
+        )
+
+        # 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 (< 2,5 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
+
+        # 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:
+                _LOGGER.info(
+                    "%s - We need to stop, there is no need for heating for a long time.",
+                )
+                return AUTO_START_STOP_ACTION_OFF
+            else:
+                _LOGGER.debug(
+                    "%s - nothing to do, we are heating",
+                )
+                return AUTO_START_STOP_ACTION_NOTHING
+
+        if hvac_mode == HVACMode.COOL:
+            if self._accumulated_error >= self._error_threshold:
+                _LOGGER.info(
+                    "%s - We need to stop, there is no need for cooling for a long time.",
+                )
+                return AUTO_START_STOP_ACTION_OFF
+            else:
+                _LOGGER.debug(
+                    "%s - nothing to do, we are cooling",
+                )
+                return AUTO_START_STOP_ACTION_NOTHING
+
+        # check to turn on
+        if hvac_mode == HVACMode.OFF and saved_hvac_mode == HVACMode.HEAT:
+            if current_temp + slope_min * self._dt <= target_temp:
+                _LOGGER.info(
+                    "%s - We need to start, because it will be time to heat",
+                )
+                return AUTO_START_STOP_ACTION_ON
+            else:
+                _LOGGER.debug(
+                    "%s - nothing to do, we don't need to heat soon",
+                )
+                return AUTO_START_STOP_ACTION_NOTHING
+
+        if hvac_mode == HVACMode.OFF and saved_hvac_mode == HVACMode.COOL:
+            if current_temp + slope_min * self._dt >= target_temp:
+                _LOGGER.info(
+                    "%s - We need to start, because it will be time to cool",
+                )
+                return AUTO_START_STOP_ACTION_ON
+            else:
+                _LOGGER.debug(
+                    "%s - nothing to do, we don't need to cool soon",
+                )
+                return AUTO_START_STOP_ACTION_NOTHING
+
+        _LOGGER.debug(
+            "%s - nothing to do, no conditions applied",
+        )
+        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 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/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
@@ -97,6 +98,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 +147,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 +467,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/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,8 @@ 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
 
     _entity_component_unrecorded_attributes = (
         BaseThermostat._entity_component_unrecorded_attributes.union(
@@ -99,6 +109,9 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
                     "auto_activated_fan_mode",
                     "auto_deactivated_fan_mode",
                     "auto_regulation_use_device_temp",
+                    "auto_start_stop_level",
+                    "auto_start_stop_dtemp",
+                    "auto_start_stop_dtmin",
                 }
             )
         )
@@ -113,6 +126,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,18 +296,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
-                # issue 467 - always apply offset. TODO removes this if ok
-                # 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
 
@@ -304,53 +360,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
@@ -563,6 +572,13 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             self.auto_regulation_use_device_temp
         )
 
+        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.async_write_ha_state()
         _LOGGER.debug(
             "%s - Calling update_custom_attributes: %s",
@@ -881,6 +897,61 @@ 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
+        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,
+            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",
+                    "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",
+                    "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,
+                },
+            )
+
+            # 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:
@@ -1034,6 +1105,11 @@ 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
+
     @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": {

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)