Issue #615 - VTherm switch to manual on its own (#618 )

Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>
Issue 600 energy can be negative after configuration (#614 )
2024-11-09 18:44:13 +01:00 · 2024-11-07 21:57:08 +01:00 · 2024-11-05 22:47:42 +01:00 · 2024-11-05 22:39:26 +01:00 · 2024-11-05 10:40:49 +01:00 · 2024-11-05 06:37:27 +00:00
33 changed files with 3856 additions and 863 deletions
--- a/.devcontainer/configuration.yaml
+++ b/.devcontainer/configuration.yaml
@@ -152,6 +152,7 @@ climate:
      name: Underlying thermostat2
      heater: input_boolean.fake_heater_switch3
      target_sensor: input_number.fake_temperature_sensor1
+      ac_mode: false
    - platform: generic_thermostat
      name: Underlying thermostat3
      heater: input_boolean.fake_heater_switch3
--- a/.github/ISSUE_TEMPLATE/issue.md
+++ b/.github/ISSUE_TEMPLATE/issue.md
@@ -4,6 +4,8 @@ about: Create a report to help us improve

 ---

+> Please read carefuly this instructions and fill this form before writing an issue. It helps me to help you.
+
 <!-- This template will allow the maintainer to be efficient and post the more accurante response as possible. There is many types / modes / configuration possible, so the analysis can be very tricky. If don't follow this template, your issue could be rejected without any message. Please help me to help you. -->

 <!-- Before you open a new issue, search through the existing issues to see if others have had the same problem.
--- a/README-fr.md
+++ b/README-fr.md
@@ -31,6 +31,7 @@
      - [Compensation de la température interne](#compensation-de-la-température-interne)
      - [Synthèse de l'algorithme d'auto-régulation](#synthèse-de-lalgorithme-dauto-régulation)
      - [Le mode auto-fan](#le-mode-auto-fan)
+      - [Le démarrage / arrêt automatique](#le-démarrage--arrêt-automatique)
    - [Pour un thermostat de type ```thermostat_over_valve```:](#pour-un-thermostat-de-type-thermostat_over_valve)
  - [Configurez les coefficients de l'algorithme TPI](#configurez-les-coefficients-de-lalgorithme-tpi)
  - [Configurer les températures préréglées](#configurer-les-températures-préréglées)
@@ -92,6 +93,9 @@ Ce composant personnalisé pour Home Assistant est une mise à niveau et est une


 > ![Nouveau](images/new-icon.png) _*Historique des dernières versions*_
+> * **Release 6.5** :
+>   - Ajout d'une nouvelle fonction permettant l'arrêt et la relance automatique d'un VTherm `over_climate` [585](https://github.com/jmcollin78/versatile_thermostat/issues/585)
+>   - Amélioration de la gestion des ouvertures au démarrage. Permet de mémoriser et de recalculer l'état d'une ouverture au redémarage de Home Assistant [504](https://github.com/jmcollin78/versatile_thermostat/issues/504)
 > * **Release 6.0** :
 >   - Ajout d'entités du domaine Number permettant de configurer les températures des presets [354](https://github.com/jmcollin78/versatile_thermostat/issues/354)
 >   - Refonte complète du menu de configuration pour supprimer les températures et utililsation d'un menu au lieu d'un tunnel de configuration [354](https://github.com/jmcollin78/versatile_thermostat/issues/354)
@@ -100,14 +104,14 @@ Ce composant personnalisé pour Home Assistant est une mise à niveau et est une
 >   - ajout de seuils de régulation pour les `over_valve` pour éviter de trop vider la batterie des TRV [#338](https://github.com/jmcollin78/versatile_thermostat/issues/338),
 >   - ajout d'une option permettant d'utiliser la température interne d'un TRV pour forcer l' auto-régulation [#348](https://github.com/jmcollin78/versatile_thermostat/issues/348),
 >   - ajout d'une fonction de keep-alive pour les VTherm `over_switch` [#345](https://github.com/jmcollin78/versatile_thermostat/issues/345)
-> * **Release 5.3** : Ajout d'une fonction de pilotage d'une chaudière centrale [#234](https://github.com/jmcollin78/versatile_thermostat/issues/234) - plus d'infos ici: [Le contrôle d'une chaudière centrale](#le-contrôle-dune-chaudière-centrale). Ajout de la possibilité de désactiver le mode sécurité pour le thermomètre extérieur [#343](https://github.com/jmcollin78/versatile_thermostat/issues/343)
-> * **Release 5.2** : Ajout d'un `central_mode` permettant de piloter tous les VTherms de façon centralisée [#158](https://github.com/jmcollin78/versatile_thermostat/issues/158).
-> * **Release 5.1** : Limitation des valeurs envoyées aux valves et au température envoyées au climate sous-jacent.
-> * **Release 5.0** : Ajout d'une configuration centrale permettant de mettre en commun les attributs qui peuvent l'être [#239](https://github.com/jmcollin78/versatile_thermostat/issues/239).

 <details>
 <summary>Autres versions</summary>

+> * **Release 5.3** : Ajout d'une fonction de pilotage d'une chaudière centrale [#234](https://github.com/jmcollin78/versatile_thermostat/issues/234) - plus d'infos ici: [Le contrôle d'une chaudière centrale](#le-contrôle-dune-chaudière-centrale). Ajout de la possibilité de désactiver le mode sécurité pour le thermomètre extérieur [#343](https://github.com/jmcollin78/versatile_thermostat/issues/343)
+> * **Release 5.2** : Ajout d'un `central_mode` permettant de piloter tous les VTherms de façon centralisée [#158](https://github.com/jmcollin78/versatile_thermostat/issues/158).
+> * **Release 5.1** : Limitation des valeurs envoyées aux valves et au température envoyées au climate sous-jacent.
+> * **Release 5.0** : Ajout d'une configuration centrale permettant de mettre en commun les attributs qui peuvent l'être [#239](https://github.com/jmcollin78/versatile_thermostat/issues/239).
 > * **Release 4.3** : Ajout d'un mode auto-fan pour le type `over_climate` permettant d'activer la ventilation si l'écart de température est important [#223](https://github.com/jmcollin78/versatile_thermostat/issues/223).
 > * **Release 4.2** : Le calcul de la pente de la courbe de température se fait maintenant en °/heure et non plus en °/min [#242](https://github.com/jmcollin78/versatile_thermostat/issues/242). Correction de la détection automatique des ouvertures par l'ajout d'un lissage de la courbe de température .
 > * **Release 4.1** : Ajout d'un mode de régulation **Expert** dans lequel l'utilisateur peut spécifier ses propres paramètres d'auto-régulation au lieu d'utiliser les pre-programmés [#194](https://github.com/jmcollin78/versatile_thermostat/issues/194).
@@ -510,6 +514,17 @@ Il faut évidemment que votre équipement sous-jacent soit équipée d'une venti
 Si votre équipement ne comprend pas le mode Turbo, le mode Forte` sera utilisé en remplacement.
 Une fois l'écart de température redevenu faible, la ventilation se mettra dans un mode "normal" qui dépend de votre équipement à savoir (dans l'ordre) : `Silence (mute)`, `Auto (auto)`, `Faible (low)`. La première valeur qui est possible pour votre équipement sera choisie.

+#### Le démarrage / arrêt automatique
+Cette fonction a été introduite en 6.5.0. Elle permet d'autoriser VTherm a stopper un équipement qui n'a pas besoin d'être allumé et de le redémarrer lorsque les conditions le réclame. Cette fonction est munie de 3 réglages qui permettent d'arrêter / relancer plus ou moins rapidement l'équipement.
+
+Pour l'utiliser, vous devez :
+1. Ajouter la fonction `Avec démmarrage et extinction automatique` dans le menu 'Fonctions',
+2. Paramétrer le niveau de détection dans l'option 'Allumage/extinction automatique' qui s'affiche lorsque la fonction a été activée. Vous choisissez le niveau de détection entre 'Lent', 'Moyen' et 'Rapide'. Les arrêts/relances seront plus nombreux avec le niveau 'Rapide'.
+
+Une fois paramétré, vous aurez maintenant une nouvelle entité de type `switch` qui vous permet d'autoriser ou non l'arrêt/relance automatique sans toucher à la configuration. Cette entité est disponible sur l'appareil VTherm et se nomme `switch.<name>_enable_auto_start_stop`. Cochez la pour autoriser le démarrage et extinction automatique.
+
+L'algorithme de détection est décrit [ici](https://github.com/jmcollin78/versatile_thermostat/issues/585).
+
 ### Pour un thermostat de type ```thermostat_over_valve```:
 ![image](images/config-linked-entity3.png)
 Vous pouvez choisir jusqu'à entité du domaine ```number``` ou ```ìnput_number``` qui vont commander les vannes.
@@ -911,6 +926,8 @@ context:
 | ``central_boiler_activation_service``     | Service d'activation de la chaudière                                              | -             | -                   | -            | X                        |
 | ``central_boiler_deactivation_service``   | Service de desactivation de la chaudière                                          | -             | -                   | -            | X                        |
 | ``used_by_controls_central_boiler``       | Indique si le VTherm contrôle la chaudière centrale                               | X             | X                   | X            | -                        |
+| ``use_auto_start_stop_feature``           | Indique si la fonction de démarrage/extinction automatique est activée            | -             | X                   | -            | -                        |
+| ``auto_start_stop_lvel``                  | Le niveau de détection de l'auto start/stop                                       | -             | X                   | -            | -                        |
 </details>

 # Exemples de réglage
@@ -1168,6 +1185,9 @@ Les attributs personnalisés sont les suivants :
 | ``is_controlled_by_central_mode`` | True si le VTherm peut être controlé de façon centrale                                                                                                                   |
 | ``last_central_mode``             | Le dernier mode central utilisé (None si le VTherm n'est pas controlé en central)                                                                                        |
 | ``is_used_by_central_boiler``     | Indique si le VTherm peut contrôler la chaudière centrale                                                                                                                |
+| ``auto_start_stop_enable``        | Indique si le VTherm est autorisé à s'auto démarrer/arrêter                                                                                                              |
+| ``auto_start_stop_level``         | Indique le niveau d'auto start/stop                                                                                                                                      |
+| ``hvac_off_reason``               | Indique la raison de l'arrêt (hvac_off) du VTherm. Ce peut être Window, Auto-start/stop ou Manuel                                                                        |

 # Quelques résultats

--- a/README.md
+++ b/README.md
@@ -32,6 +32,7 @@
      - [Internal temperature compensation](#internal-temperature-compensation)
      - [synthesis of the self-regulation algorithm](#synthesis-of-the-self-regulation-algorithm)
      - [Auto-fan mode](#auto-fan-mode)
+      - [Automatic start/stop](#automatic-startstop)
    - [For a thermostat of type ```thermostat_over_valve```:](#for-a-thermostat-of-type-thermostat_over_valve)
  - [Configure the TPI algorithm coefficients](#configure-the-tpi-algorithm-coefficients)
  - [Configure the preset temperature](#configure-the-preset-temperature)
@@ -93,6 +94,9 @@
 This custom component for Home Assistant is an upgrade and is a complete rewrite of the component "Awesome thermostat" (see [Github](https://github.com/dadge/awesome_thermostat)) with addition of features.

 >![New](images/new-icon.png) _*Latest releases*_
+> * **Release 6.5** :
+> - Added a new function allowing the automatic shutdown and restart of a VTherm `over_climate` [585](https://github.com/jmcollin78/versatile_thermostat/issues/585)
+> - Improved management of openings at startup. Allows to memorize and recalculate the state of an opening when restarting Home Assistant [504](https://github.com/jmcollin78/versatile_thermostat/issues/504)
 > * **Release 6.0**:
 > - Added entities from the Number domain to configure preset temperatures [354](https://github.com/jmcollin78/versatile_thermostat/issues/354)
 > - Complete redesign of the configuration menu to remove temperatures and use a menu instead of a configuration tunnel [354](https://github.com/jmcollin78/versatile_thermostat/issues/354)
@@ -101,13 +105,13 @@ This custom component for Home Assistant is an upgrade and is a complete rewrite
 >   - addition of regulation thresholds for the `over_valve` to avoid draining the TRV battery too much [#338](https://github.com/jmcollin78/versatile_thermostat/issues/338),
 >   - added an option allowing the internal temperature of a TRV to be used to force self-regulation [#348](https://github.com/jmcollin78/versatile_thermostat/issues/348),
 >   - added a keep-alive function for VTherm `over_switch` [#345](https://github.com/jmcollin78/versatile_thermostat/issues/345)
+<details>
+<summary>Others releases</summary>
+
 > * **Release 5.3**: Added a central boiler control function [#234](https://github.com/jmcollin78/versatile_thermostat/issues/234) - more information here: [Controlling a central boiler](#controlling-a-central-boiler). Added the ability to disable security mode for outdoor thermometer [#343](https://github.com/jmcollin78/versatile_thermostat/issues/343)
 > * **Release 5.2**: Added a `central_mode` allowing all VTherms to be controlled centrally [#158](https://github.com/jmcollin78/versatile_thermostat/issues/158).
 > * **Release 5.1**: Limitation of the values sent to the valves and the temperature sent to the underlying climate.
 > * **Release 5.0**: Added a central configuration allowing the sharing of attributes that can be shared [#239](https://github.com/jmcollin78/versatile_thermostat/issues/239).
-<details>
-<summary>Others releases</summary>
-
 > * **Release 4.3**: Added an auto-fan mode for the `over_climate` type allowing ventilation to be activated if the temperature difference is significant [#223](https://github.com/jmcollin78/versatile_thermostat/issues/223).
 > * **Release 4.2**: The calculation of the slope of the temperature curve is now done in °/hour and no longer in °/min [#242](https://github.com/jmcollin78/versatile_thermostat/issues/242). Correction of automatic detection of openings by adding smoothing of the temperature curve.
 > * **Release 4.1**: Added an **Expert** regulation mode in which the user can specify their own auto-regulation parameters instead of using the pre-programmed ones [#194]( https://github.com/jmcollin78/versatile_thermostat/issues/194).
@@ -468,21 +472,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:
@@ -505,6 +504,17 @@ Obviously your underlying equipment must be equipped with ventilation and be con
 If your equipment does not include Turbo mode, Forte` mode will be used as a replacement.
 Once the temperature difference becomes low again, the ventilation will go into a "normal" mode which depends on your equipment, namely (in order): `Silence (mute)`, `Auto (auto)`, `Low (low)`. The first value that is possible for your equipment will be chosen.

+#### Automatic start/stop
+This function was introduced in 6.5.0. It allows VTherm to stop equipment that does not need to be turned on and to restart it when conditions require it. This function has 3 settings that allow the equipment to be stopped/restarted more or less quickly.
+
+To use it, you must:
+1. Add the `Use the auto start and stop feature` function in the 'Features' menu,
+2. Set the detection level in the `Auto start and stop` option that is displayed when the function has been activated. You choose the detection level between 'Slow', 'Medium' and 'Fast'. The 'Fast' level will result in more shutdowns/restarts.
+
+Once configured, you will now have a new entity of type `switch` that allows you to authorize or not the automatic shutdown/restart without touching the configuration. This entity is available on the VTherm device and is called `switch.<name>_enable_auto_start_stop`. Check it to authorize the automatic startup and shutdown.
+
+The detection algorithm is described [here](https://github.com/jmcollin78/versatile_thermostat/issues/585).
+
 ### For a thermostat of type ```thermostat_over_valve```:
 ![image](images/config-linked-entity3.png)
 You can choose up to domain entity ```number``` or ```ìnput_number``` which will control the valves.
@@ -905,6 +915,8 @@ context:
 | ``central_boiler_activation_service``     | Activation service of the boiler                                              | -             | -                   | -            | X                       |
 | ``central_boiler_deactivation_service``   | Deactivaiton service of the boiler                                            | -             | -                   | -            | X                       |
 | ``used_by_controls_central_boiler``       | Indicate if the VTherm control the central boiler                             | X             | X                   | X            | -                       |
+| ``use_auto_start_stop_feature``           | Indique si la fonction de démarrage/extinction automatique est activée        | -             | X                   | -            | -                       |
+| ``auto_start_stop_lvel``                  | Le niveau de détection de l'auto start/stop                                   | -             | X                   | -            | -                       |
 </details>

 # Tuning examples
@@ -1160,6 +1172,9 @@ Custom attributes are the following:
 | ``is_controlled_by_central_mode`` | True if the VTherm can be centrally controlled                                                                                   |
 | ``last_central_mode``             | The last central mode used (None if the VTherm is not centrally controlled)                                                      |
 | ``is_used_by_central_boiler``     | Indicate if the VTherm can control the central boiler                                                                            |
+| ``auto_start_stop_enable``        | Indicate if the VTherm is allowed to do auto start and stop                                                                      |
+| ``auto_start_stop_level``         | Give the level of auto start/stop                                                                                                |
+| ``hvac_off_reason``               | Give the reason of stop of the VTherm. This could be Window, Auto-start/stop or Manual                                           |

 # Some results

@@ -1338,7 +1353,7 @@ Example of graph obtained with Plotly :


 ## And always better and better with the NOTIFIER daemon app to notify events
-This automation uses the excellent App Daemon named NOTIFIER developed by Horizon Domotique that you will find in demonstration [here](https://www.youtube.com/watch?v=chJylIK0ASo&ab_channel=HorizonDomotique) and the code is [here](https ://github.com/jlpouffier/home-assistant-config/blob/master/appdaemon/apps/notifier.py). It allows you to notify the users of the accommodation when one of the events affecting safety occurs on one of the Versatile Thermostats.
+This automation uses the excellent App Daemon named NOTIFIER developed by Horizon Domotique that you will find in demonstration [here](https://www.youtube.com/watch?v=chJylIK0ASo&ab_channel=HorizonDomotique) and the code is [here](https://github.com/jlpouffier/home-assistant-config/blob/master/appdaemon/apps/notifier.py). It allows you to notify the users of the accommodation when one of the events affecting safety occurs on one of the Versatile Thermostats.

 This is a great example of using the notifications described here [notification](#notifications).

--- a/custom_components/versatile_thermostat/init.py
+++ b/custom_components/versatile_thermostat/init.py
@@ -38,6 +38,22 @@ from .const import (
    CONF_USE_CENTRAL_BOILER_FEATURE,
    CONF_POWER_SENSOR,
    CONF_PRESENCE_SENSOR,
+    CONF_UNDERLYING_LIST,
+    CONF_HEATER,
+    CONF_HEATER_2,
+    CONF_HEATER_3,
+    CONF_HEATER_4,
+    CONF_CLIMATE,
+    CONF_CLIMATE_2,
+    CONF_CLIMATE_3,
+    CONF_CLIMATE_4,
+    CONF_VALVE,
+    CONF_VALVE_2,
+    CONF_VALVE_3,
+    CONF_VALVE_4,
+    CONF_THERMOSTAT_SWITCH,
+    CONF_THERMOSTAT_CLIMATE,
+    CONF_THERMOSTAT_VALVE,
 )

 from .vtherm_api import VersatileThermostatAPI
@@ -162,13 +178,20 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:

    if hass.state == CoreState.running:
        await api.reload_central_boiler_entities_list()
-        await api.init_vtherm_links()
+        await api.init_vtherm_links(entry.entry_id)

    return True


 async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
    """Update listener."""
+
+    _LOGGER.debug(
+        "Calling update_listener entry: entry_id='%s', value='%s'",
+        entry.entry_id,
+        entry.data,
+    )
+
    if entry.data.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_CENTRAL_CONFIG:
        await reload_all_vtherm(hass)
    else:
@@ -177,7 +200,7 @@ async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
        api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(hass)
        if api is not None:
            await api.reload_central_boiler_entities_list()
-            await api.init_vtherm_links()
+            await api.init_vtherm_links(entry.entry_id)


 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
@@ -208,10 +231,9 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry):
        )
        new = {**config_entry.data}

-        if (
-            config_entry.data.get(CONF_THERMOSTAT_TYPE)
-            == CONF_THERMOSTAT_CENTRAL_CONFIG
-        ):
+        thermostat_type = config_entry.data.get(CONF_THERMOSTAT_TYPE)
+
+        if thermostat_type == CONF_THERMOSTAT_CENTRAL_CONFIG:
            new[CONF_USE_WINDOW_FEATURE] = True
            new[CONF_USE_MOTION_FEATURE] = True
            new[CONF_USE_POWER_FEATURE] = new.get(CONF_POWER_SENSOR, None) is not None
@@ -223,6 +245,50 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry):
                "add_central_boiler_control", False
            ) or new.get(CONF_USE_CENTRAL_BOILER_FEATURE, False)

+        if config_entry.data.get(CONF_UNDERLYING_LIST, None) is None:
+            underlying_list = []
+            if thermostat_type == CONF_THERMOSTAT_SWITCH:
+                underlying_list = [
+                    config_entry.data.get(CONF_HEATER, None),
+                    config_entry.data.get(CONF_HEATER_2, None),
+                    config_entry.data.get(CONF_HEATER_3, None),
+                    config_entry.data.get(CONF_HEATER_4, None),
+                ]
+            elif thermostat_type == CONF_THERMOSTAT_CLIMATE:
+                underlying_list = [
+                    config_entry.data.get(CONF_CLIMATE, None),
+                    config_entry.data.get(CONF_CLIMATE_2, None),
+                    config_entry.data.get(CONF_CLIMATE_3, None),
+                    config_entry.data.get(CONF_CLIMATE_4, None),
+                ]
+            elif thermostat_type == CONF_THERMOSTAT_VALVE:
+                underlying_list = [
+                    config_entry.data.get(CONF_VALVE, None),
+                    config_entry.data.get(CONF_VALVE_2, None),
+                    config_entry.data.get(CONF_VALVE_3, None),
+                    config_entry.data.get(CONF_VALVE_4, None),
+                ]
+
+            new[CONF_UNDERLYING_LIST] = [
+                entity for entity in underlying_list if entity is not None
+            ]
+
+            for key in [
+                CONF_HEATER,
+                CONF_HEATER_2,
+                CONF_HEATER_3,
+                CONF_HEATER_4,
+                CONF_CLIMATE,
+                CONF_CLIMATE_2,
+                CONF_CLIMATE_3,
+                CONF_CLIMATE_4,
+                CONF_VALVE,
+                CONF_VALVE_2,
+                CONF_VALVE_3,
+                CONF_VALVE_4,
+            ]:
+                new.pop(key, None)
+
        hass.config_entries.async_update_entry(
            config_entry,
            data=new,
--- a/custom_components/versatile_thermostat/auto_start_stop_algorithm.py
+++ b/custom_components/versatile_thermostat/auto_start_stop_algorithm.py
@@ -0,0 +1,239 @@
+# 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
+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,
+    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
+
+# A temp hysteresis to avoid rapid OFF/ON
+TEMP_HYSTERESIS = 0.5
+
+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 | None,
+        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:
+            _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 (< 24 sec)
+            if dtmin <= 0.2:
+                _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 + TEMP_HYSTERESIS
+            ):
+                _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 - TEMP_HYSTERESIS
+            ):
+                _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 - TEMP_HYSTERESIS:
+                _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 + TEMP_HYSTERESIS:
+                _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}"
--- a/custom_components/versatile_thermostat/base_thermostat.py
+++ b/custom_components/versatile_thermostat/base_thermostat.py
@@ -19,7 +19,10 @@ from homeassistant.core import (
 )

 from homeassistant.components.climate import ClimateEntity
-from homeassistant.helpers.restore_state import RestoreEntity
+from homeassistant.helpers.restore_state import (
+    RestoreEntity,
+    async_get as restore_async_get,
+)
 from homeassistant.helpers.entity import Entity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.helpers.device_registry import DeviceInfo, DeviceEntryType
@@ -62,72 +65,7 @@ from homeassistant.const import (
    STATE_NOT_HOME,
 )

-from .const import (
-    DOMAIN,
-    DEVICE_MANUFACTURER,
-    CONF_POWER_SENSOR,
-    CONF_TEMP_SENSOR,
-    CONF_LAST_SEEN_TEMP_SENSOR,
-    CONF_EXTERNAL_TEMP_SENSOR,
-    CONF_MAX_POWER_SENSOR,
-    CONF_WINDOW_SENSOR,
-    CONF_WINDOW_DELAY,
-    CONF_WINDOW_AUTO_CLOSE_THRESHOLD,
-    CONF_WINDOW_AUTO_OPEN_THRESHOLD,
-    CONF_WINDOW_AUTO_MAX_DURATION,
-    CONF_MOTION_SENSOR,
-    CONF_MOTION_DELAY,
-    CONF_MOTION_OFF_DELAY,
-    CONF_MOTION_PRESET,
-    CONF_NO_MOTION_PRESET,
-    CONF_DEVICE_POWER,
-    CONF_PRESETS,
-    # CONF_PRESETS_AWAY,
-    # CONF_PRESETS_WITH_AC,
-    # CONF_PRESETS_AWAY_WITH_AC,
-    CONF_CYCLE_MIN,
-    CONF_PROP_FUNCTION,
-    CONF_TPI_COEF_INT,
-    CONF_TPI_COEF_EXT,
-    CONF_PRESENCE_SENSOR,
-    CONF_PRESET_POWER,
-    SUPPORT_FLAGS,
-    PRESET_FROST_PROTECTION,
-    PRESET_POWER,
-    PRESET_SECURITY,
-    PROPORTIONAL_FUNCTION_TPI,
-    PRESET_AWAY_SUFFIX,
-    CONF_SECURITY_DELAY_MIN,
-    CONF_SECURITY_MIN_ON_PERCENT,
-    CONF_SECURITY_DEFAULT_ON_PERCENT,
-    DEFAULT_SECURITY_MIN_ON_PERCENT,
-    DEFAULT_SECURITY_DEFAULT_ON_PERCENT,
-    CONF_MINIMAL_ACTIVATION_DELAY,
-    CONF_USE_MAIN_CENTRAL_CONFIG,
-    CONF_USE_TPI_CENTRAL_CONFIG,
-    CONF_USE_PRESETS_CENTRAL_CONFIG,
-    CONF_USE_WINDOW_CENTRAL_CONFIG,
-    CONF_USE_MOTION_CENTRAL_CONFIG,
-    CONF_USE_POWER_CENTRAL_CONFIG,
-    CONF_USE_PRESENCE_CENTRAL_CONFIG,
-    CONF_USE_ADVANCED_CENTRAL_CONFIG,
-    CONF_USE_PRESENCE_FEATURE,
-    CONF_TEMP_MAX,
-    CONF_TEMP_MIN,
-    HIDDEN_PRESETS,
-    CONF_AC_MODE,
-    EventType,
-    ATTR_MEAN_POWER_CYCLE,
-    ATTR_TOTAL_ENERGY,
-    PRESET_AC_SUFFIX,
-    DEFAULT_SHORT_EMA_PARAMS,
-    CENTRAL_MODE_AUTO,
-    CENTRAL_MODE_STOPPED,
-    CENTRAL_MODE_HEAT_ONLY,
-    CENTRAL_MODE_COOL_ONLY,
-    CENTRAL_MODE_FROST_PROTECTION,
-    send_vtherm_event,
-)
+from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import

 from .config_schema import *  # pylint: disable=wildcard-import, unused-wildcard-import

@@ -149,6 +87,10 @@ def get_tz(hass: HomeAssistant):
    return dt_util.get_time_zone(hass.config.time_zone)


+_LOGGER_ENERGY = logging.getLogger(
+    "custom_components.versatile_thermostat.energy_debug"
+)
+
 class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
    """Representation of a base class for all Versatile Thermostat device."""

@@ -199,6 +141,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
                    "is_device_active",
                    "target_temperature_step",
                    "is_used_by_central_boiler",
+                    "temperature_slope"
                }
            )
        )
@@ -262,6 +205,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
        self._attr_translation_key = "versatile_thermostat"

        self._total_energy = None
+        _LOGGER_ENERGY.debug("%s - _init_ resetting energy to None", self)

        # because energy of climate is calculated in the thermostat we have to keep that here and not in underlying entity
        self._underlying_climate_start_hvac_action_date = None
@@ -303,6 +247,8 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):

        self._use_central_config_temperature = False

+        self._hvac_off_reason: HVAC_OFF_REASONS | None = None
+
        self.post_init(entry_infos)

    def clean_central_config_doublon(
@@ -532,6 +478,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
        self._presence_state = None

        self._total_energy = None
+        _LOGGER_ENERGY.debug("%s - post_init_ resetting energy to None", self)

        # Read the parameter from configuration.yaml if it exists
        short_ema_params = DEFAULT_SHORT_EMA_PARAMS
@@ -647,14 +594,24 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
        # issue 428. Link to others entities will start at link
        # await self.async_startup()

+    async def async_will_remove_from_hass(self):
+        """Try to force backup of entity"""
+        _LOGGER_ENERGY.debug(
+            "%s - force write before remove. Energy is %s", self, self.total_energy
+        )
+        # Force dump in background
+        await restore_async_get(self.hass).async_dump_states()
+
    def remove_thermostat(self):
        """Called when the thermostat will be removed"""
        _LOGGER.info("%s - Removing thermostat", self)
+
        for under in self._underlyings:
            under.remove_entity()

    async def async_startup(self, central_configuration):
-        """Triggered on startup, used to get old state and set internal states accordingly"""
+        """Triggered on startup, used to get old state and set internal states accordingly. This is triggered by
+        VTherm API"""
        _LOGGER.debug("%s - Calling async_startup", self)

        _LOGGER.debug("%s - Calling async_startup_internal", self)
@@ -848,18 +805,29 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
            else:
                self._attr_preset_mode = PRESET_NONE

+            # Restore old hvac_off_reason
+            self._hvac_off_reason = old_state.attributes.get(HVAC_OFF_REASON_NAME, None)
+
            if old_state.state in [
                HVACMode.OFF,
                HVACMode.HEAT,
                HVACMode.COOL,
            ]:
                self._hvac_mode = old_state.state
-            else:
-                if not self._hvac_mode:
-                    self._hvac_mode = HVACMode.OFF
+
+            # restpre also saved info so that window detection will work
+            self._saved_hvac_mode = old_state.attributes.get("saved_hvac_mode", None)
+            self._saved_preset_mode = old_state.attributes.get(
+                "saved_preset_mode", None
+            )

            old_total_energy = old_state.attributes.get(ATTR_TOTAL_ENERGY)
-            self._total_energy = old_total_energy if old_total_energy else 0
+            self._total_energy = old_total_energy if old_total_energy is not None else 0
+            _LOGGER_ENERGY.debug(
+                "%s - get_my_previous_state restored energy is %s",
+                self,
+                self._total_energy,
+            )

            self.restore_specific_previous_state(old_state)
        else:
@@ -873,13 +841,20 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
                "No previously saved temperature, setting to %s", self._target_temp
            )
            self._total_energy = 0
+            _LOGGER_ENERGY.debug(
+                "%s - get_my_previous_state  no previous state energy is %s",
+                self,
+                self._total_energy,
+            )

-        self._saved_target_temp = self._target_temp
-
-        # Set default state to off
        if not self._hvac_mode:
            self._hvac_mode = HVACMode.OFF

+        if not self.is_on and self.hvac_off_reason is None:
+            self.set_hvac_off_reason(HVAC_OFF_REASON_MANUAL)
+
+        self._saved_target_temp = self._target_temp
+
        self.send_event(EventType.PRESET_EVENT, {"preset": self._attr_preset_mode})
        self.send_event(EventType.HVAC_MODE_EVENT, {"hvac_mode": self._hvac_mode})

@@ -987,16 +962,6 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
    @property
    def hvac_mode(self) -> HVACMode | None:
        """Return current operation."""
-        # Issue #114 - returns my current hvac_mode and not the underlying hvac_mode which could be different
-        # delta will be managed by climate_state_change event.
-        # if self.is_over_climate:
-        # if one not OFF -> return it
-        # else OFF
-        #    for under in self._underlyings:
-        #        if (mode := under.hvac_mode) not in [HVACMode.OFF]
-        #            return mode
-        #    return HVACMode.OFF
-
        return self._hvac_mode

    @property
@@ -1193,6 +1158,13 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
        """True if this VTHerm uses the central configuration temperature"""
        return self._use_central_config_temperature

+    @property
+    def hvac_off_reason(self) -> HVAC_OFF_REASONS:
+        """Returns the reason of the last switch to HVAC_OFF
+        This is useful for features that turns off the VTherm like
+        window detection or auto-start-stop"""
+        return self._hvac_off_reason
+
    def underlying_entity_id(self, index=0) -> str | None:
        """The climate_entity_id. Added for retrocompatibility reason"""
        if index < self.nb_underlying_entities:
@@ -1255,9 +1227,11 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):

        # Ensure we update the current operation after changing the mode
        self.reset_last_temperature_time()
-
        self.reset_last_change_time()

+        if self._hvac_mode != HVACMode.OFF:
+            self.set_hvac_off_reason(None)
+
        self.update_custom_attributes()
        self.async_write_ha_state()
        self.send_event(EventType.HVAC_MODE_EVENT, {"hvac_mode": self._hvac_mode})
@@ -1654,9 +1628,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 +1672,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
@@ -1736,6 +1734,19 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
        for under in self._underlyings:
            await under.check_initial_state(self._hvac_mode)

+        # Prevent from starting a VTherm if window is open
+        if (
+            self.is_window_auto_enabled
+            and self._window_sensor_entity_id is not None
+            and self._hass.states.is_state(self._window_sensor_entity_id, STATE_ON)
+            and self.is_on
+            and self.window_action == CONF_WINDOW_TURN_OFF
+        ):
+            _LOGGER.info("%s - the window is open. Prevent starting the VTherm")
+            self._window_auto_state = True
+            self.save_hvac_mode()
+            await self.async_set_hvac_mode(HVACMode.OFF)
+
        # Starts the initial control loop (don't wait for an update of temperature)
        await self.async_control_heating(force=True)

@@ -2072,6 +2083,10 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
            self._hvac_mode,
        )

+    def set_hvac_off_reason(self, hvac_off_reason: HVAC_OFF_REASONS):
+        """Set the reason of hvac_off"""
+        self._hvac_off_reason = hvac_off_reason
+
    async def restore_hvac_mode(self, need_control_heating=False):
        """Restore a previous hvac_mod"""
        await self.async_set_hvac_mode(self._saved_hvac_mode, need_control_heating)
@@ -2203,13 +2218,16 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
            if self.window_state is not STATE_ON and not first_init:
                await self.restore_hvac_mode()
                await self.restore_preset_mode()
-
+            elif self.window_state is STATE_ON and self.hvac_mode == HVACMode.OFF:
+                # do not restore but mark the reason of off with window detection
+                self.set_hvac_off_reason(HVAC_OFF_REASON_WINDOW_DETECTION)
            return

        if old_central_mode == CENTRAL_MODE_AUTO and self.window_state is not STATE_ON:
            save_all()

        if new_central_mode == CENTRAL_MODE_STOPPED:
+            self.set_hvac_off_reason(HVAC_OFF_REASON_MANUAL)
            await self.async_set_hvac_mode(HVACMode.OFF)
            return

@@ -2217,6 +2235,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
            if HVACMode.COOL in self.hvac_modes:
                await self.async_set_hvac_mode(HVACMode.COOL)
            else:
+                self.set_hvac_off_reason(HVAC_OFF_REASON_MANUAL)
                await self.async_set_hvac_mode(HVACMode.OFF)
            return

@@ -2224,6 +2243,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
            if HVACMode.HEAT in self.hvac_modes:
                await self.async_set_hvac_mode(HVACMode.HEAT)
            else:
+                self.set_hvac_off_reason(HVAC_OFF_REASON_MANUAL)
                await self.async_set_hvac_mode(HVACMode.OFF)
            return

@@ -2237,6 +2257,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
                    PRESET_FROST_PROTECTION, overwrite_saved_preset=False
                )
            else:
+                self.set_hvac_off_reason(HVAC_OFF_REASON_MANUAL)
                await self.async_set_hvac_mode(HVACMode.OFF)
            return

@@ -2416,17 +2437,27 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
        """Change the window detection state.
        new_state is on if an open window have been detected or off else
        """
-        if not new_state:
+        if new_state is False:
            _LOGGER.info(
-                "%s - Window is closed. Restoring hvac_mode '%s' if central_mode is not STOPPED",
+                "%s - Window is closed. Restoring hvac_mode '%s' if stopped by window detection or temperature %s",
                self,
                self._saved_hvac_mode,
+                self._saved_target_temp,
            )
            if self._window_action in [CONF_WINDOW_FROST_TEMP, CONF_WINDOW_ECO_TEMP]:
                await self._async_internal_set_temperature(self._saved_target_temp)
+
            # default to TURN_OFF
-            elif self._window_action in [CONF_WINDOW_TURN_OFF, CONF_WINDOW_FAN_ONLY]:
+            elif self._window_action in [CONF_WINDOW_TURN_OFF]:
+                if (
+                    self.last_central_mode != CENTRAL_MODE_STOPPED
+                    and self.hvac_off_reason == HVAC_OFF_REASON_WINDOW_DETECTION
+                ):
+                    self.set_hvac_off_reason(None)
+                    await self.restore_hvac_mode(True)
+            elif self._window_action in [CONF_WINDOW_FAN_ONLY]:
                if self.last_central_mode != CENTRAL_MODE_STOPPED:
+                    self.set_hvac_off_reason(None)
                    await self.restore_hvac_mode(True)
            else:
                _LOGGER.error(
@@ -2438,6 +2469,12 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
            _LOGGER.info(
                "%s - Window is open. Set hvac_mode to '%s'", self, HVACMode.OFF
            )
+            if self._window_action == CONF_WINDOW_TURN_OFF and not self.is_on:
+                _LOGGER.debug(
+                    "%s is already off. Forget turning off VTherm due to window detection"
+                )
+                return
+
            if self.last_central_mode in [CENTRAL_MODE_AUTO, None]:
                if self._window_action in [CONF_WINDOW_TURN_OFF, CONF_WINDOW_FAN_ONLY]:
                    self.save_hvac_mode()
@@ -2467,6 +2504,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
                    self.find_preset_temp(PRESET_ECO)
                )
            else:  # default is to turn_off
+                self.set_hvac_off_reason(HVAC_OFF_REASON_WINDOW_DETECTION)
                await self.async_set_hvac_mode(HVACMode.OFF)

    async def async_control_heating(self, force=False, _=None) -> bool:
@@ -2609,8 +2647,26 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
            "is_device_active": self.is_device_active,
            "ema_temp": self._ema_temp,
            "is_used_by_central_boiler": self.is_used_by_central_boiler,
+            "temperature_slope": round(self.last_temperature_slope or 0, 3),
+            "hvac_off_reason": self.hvac_off_reason,
        }

+        _LOGGER_ENERGY.debug(
+            "%s - update_custom_attributes saved energy is %s",
+            self,
+            self.total_energy,
+        )
+
+    @overrides
+    def async_write_ha_state(self):
+        """overrides to have log"""
+        _LOGGER_ENERGY.debug(
+            "%s - async_write_ha_state written state energy is %s",
+            self,
+            self._total_energy,
+        )
+        return super().async_write_ha_state()
+
    @callback
    def async_registry_entry_updated(self):
        """update the entity if the config entry have been updated
--- a/custom_components/versatile_thermostat/binary_sensor.py
+++ b/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
--- a/custom_components/versatile_thermostat/commons.py
+++ b/custom_components/versatile_thermostat/commons.py
@@ -17,7 +17,6 @@ from .const import DOMAIN, DEVICE_MANUFACTURER, ServiceConfigurationError

 _LOGGER = logging.getLogger(__name__)

-
 def get_tz(hass: HomeAssistant):
    """Get the current timezone"""

--- a/custom_components/versatile_thermostat/config_flow.py
+++ b/custom_components/versatile_thermostat/config_flow.py
@@ -109,17 +109,17 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
            or self._infos.get(CONF_WINDOW_AUTO_OPEN_THRESHOLD) is not None
        )
        self._infos[CONF_USE_MOTION_FEATURE] = self._infos.get(
-            CONF_USE_MOTION_FEATURE
+            CONF_USE_MOTION_FEATURE, False
        ) and (self._infos.get(CONF_MOTION_SENSOR) is not None or is_central_config)

        self._infos[CONF_USE_POWER_FEATURE] = self._infos.get(
-            CONF_USE_POWER_CENTRAL_CONFIG
+            CONF_USE_POWER_CENTRAL_CONFIG, False
        ) or (
            self._infos.get(CONF_POWER_SENSOR) is not None
            and self._infos.get(CONF_MAX_POWER_SENSOR) is not None
        )
        self._infos[CONF_USE_PRESENCE_FEATURE] = (
-            self._infos.get(CONF_USE_PRESENCE_CENTRAL_CONFIG)
+            self._infos.get(CONF_USE_PRESENCE_CENTRAL_CONFIG, False)
            or self._infos.get(CONF_PRESENCE_SENSOR) is not None
        )

@@ -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, False) 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)
@@ -140,12 +145,17 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
            CONF_USE_PRESETS_CENTRAL_CONFIG,
            CONF_USE_PRESENCE_CENTRAL_CONFIG,
            CONF_USE_ADVANCED_CENTRAL_CONFIG,
+            CONF_USE_CENTRAL_MODE,
        ):
            if not is_empty:
                current_config = self._infos.get(config, None)
-                self._infos[config] = current_config is True or (
-                    current_config is None and self._central_config is not None
+
+                self._infos[config] = self._central_config is not None and (
+                    current_config is True or current_config is None
                )
+                # self._infos[config] = current_config is True or (
+                #     current_config is None and self._central_config is not None
+                # )
            else:
                self._infos[config] = self._central_config is not None

@@ -160,7 +170,7 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):

        # check the heater_entity_id
        for conf in [
-            CONF_HEATER,
+            CONF_UNDERLYING_LIST,
            CONF_TEMP_SENSOR,
            CONF_EXTERNAL_TEMP_SENSOR,
            CONF_WINDOW_SENSOR,
@@ -168,15 +178,17 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
            CONF_POWER_SENSOR,
            CONF_MAX_POWER_SENSOR,
            CONF_PRESENCE_SENSOR,
-            CONF_CLIMATE,
        ]:
            d = data.get(conf, None)  # pylint: disable=invalid-name
-            if d is not None and self.hass.states.get(d) is None:
-                _LOGGER.error(
-                    "Entity id %s doesn't have any state. We cannot use it in the Versatile Thermostat configuration",  # pylint: disable=line-too-long
-                    d,
-                )
-                raise UnknownEntity(conf)
+            if not isinstance(d, list):
+                d = [d]
+            for e in d:
+                if e is not None and self.hass.states.get(e) is None:
+                    _LOGGER.error(
+                        "Entity id %s doesn't have any state. We cannot use it in the Versatile Thermostat configuration",  # pylint: disable=line-too-long
+                        e,
+                    )
+                    raise UnknownEntity(conf)

        # Check that only one window feature is used
        ws = self._infos.get(CONF_WINDOW_SENSOR)  # pylint: disable=invalid-name
@@ -202,6 +214,9 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
                CONF_USE_PRESENCE_CENTRAL_CONFIG,
                CONF_USE_PRESETS_CENTRAL_CONFIG,
                CONF_USE_ADVANCED_CENTRAL_CONFIG,
+                CONF_USE_CENTRAL_MODE,
+                # CONF_USE_CENTRAL_BOILER_FEATURE, this is for Central Config
+                CONF_USED_BY_CENTRAL_BOILER,
            ]:
                if data.get(conf) is True:
                    _LOGGER.error(
@@ -265,21 +280,8 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
            ):
                return False

-            if (
-                infos.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_SWITCH
-                and infos.get(CONF_HEATER, None) is None
-            ):
-                return False
-
-            if (
-                infos.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_CLIMATE
-                and infos.get(CONF_CLIMATE, None) is None
-            ):
-                return False
-
-            if (
-                infos.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_VALVE
-                and infos.get(CONF_VALVE, None) is None
+            if infos.get(CONF_UNDERLYING_LIST, None) is not None and not infos.get(
+                CONF_UNDERLYING_LIST, None
            ):
                return False

@@ -312,6 +314,22 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
            ):
                return False

+            if (
+                infos.get(CONF_PROP_FUNCTION, None) == PROPORTIONAL_FUNCTION_TPI
+                and infos.get(CONF_USE_TPI_CENTRAL_CONFIG, False) is False
+                and (
+                    infos.get(CONF_TPI_COEF_INT, None) is None
+                    or infos.get(CONF_TPI_COEF_EXT) is None
+                )
+            ):
+                return False
+
+            if (
+                infos.get(CONF_USE_PRESETS_CENTRAL_CONFIG, False) is True
+                and self._central_config is None
+            ):
+                return False
+
        return True

    def merge_user_input(self, data_schema: vol.Schema, user_input: dict):
@@ -431,6 +449,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 +545,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 +906,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",
--- a/custom_components/versatile_thermostat/config_schema.py
+++ b/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,
@@ -109,17 +119,10 @@ STEP_CENTRAL_BOILER_SCHEMA = vol.Schema(

 STEP_THERMOSTAT_SWITCH = vol.Schema(  # pylint: disable=invalid-name
    {
-        vol.Required(CONF_HEATER): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]),
-        ),
-        vol.Optional(CONF_HEATER_2): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]),
-        ),
-        vol.Optional(CONF_HEATER_3): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]),
-        ),
-        vol.Optional(CONF_HEATER_4): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]),
+        vol.Required(CONF_UNDERLYING_LIST): selector.EntitySelector(
+            selector.EntitySelectorConfig(
+                domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN], multiple=True
+            ),
        ),
        vol.Optional(CONF_HEATER_KEEP_ALIVE): cv.positive_int,
        vol.Required(CONF_PROP_FUNCTION, default=PROPORTIONAL_FUNCTION_TPI): vol.In(
@@ -134,17 +137,8 @@ STEP_THERMOSTAT_SWITCH = vol.Schema(  # pylint: disable=invalid-name

 STEP_THERMOSTAT_CLIMATE = vol.Schema(  # pylint: disable=invalid-name
    {
-        vol.Required(CONF_CLIMATE): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=CLIMATE_DOMAIN),
-        ),
-        vol.Optional(CONF_CLIMATE_2): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=CLIMATE_DOMAIN),
-        ),
-        vol.Optional(CONF_CLIMATE_3): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=CLIMATE_DOMAIN),
-        ),
-        vol.Optional(CONF_CLIMATE_4): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=CLIMATE_DOMAIN),
+        vol.Required(CONF_UNDERLYING_LIST): selector.EntitySelector(
+            selector.EntitySelectorConfig(domain=CLIMATE_DOMAIN, multiple=True),
        ),
        vol.Optional(CONF_AC_MODE, default=False): cv.boolean,
        vol.Optional(
@@ -173,17 +167,10 @@ STEP_THERMOSTAT_CLIMATE = vol.Schema(  # pylint: disable=invalid-name

 STEP_THERMOSTAT_VALVE = vol.Schema(  # pylint: disable=invalid-name
    {
-        vol.Required(CONF_VALVE): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN]),
-        ),
-        vol.Optional(CONF_VALVE_2): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN]),
-        ),
-        vol.Optional(CONF_VALVE_3): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN]),
-        ),
-        vol.Optional(CONF_VALVE_4): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN]),
+        vol.Required(CONF_UNDERLYING_LIST): selector.EntitySelector(
+            selector.EntitySelectorConfig(
+                domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN], multiple=True
+            ),
        ),
        vol.Required(CONF_PROP_FUNCTION, default=PROPORTIONAL_FUNCTION_TPI): vol.In(
            [
@@ -196,6 +183,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,
--- a/custom_components/versatile_thermostat/const.py
+++ b/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
@@ -22,8 +23,8 @@ from .prop_algorithm import (

 _LOGGER = logging.getLogger(__name__)

-CONFIG_VERSION = 1
-CONFIG_MINOR_VERSION = 2
+CONFIG_VERSION = 2
+CONFIG_MINOR_VERSION = 0

 PRESET_TEMP_SUFFIX = "_temp"
 PRESET_AC_SUFFIX = "_ac"
@@ -51,12 +52,10 @@ PLATFORMS: list[Platform] = [
    # Number should be after CLIMATE
    Platform.NUMBER,
    Platform.BINARY_SENSOR,
+    Platform.SWITCH,
 ]

-CONF_HEATER = "heater_entity_id"
-CONF_HEATER_2 = "heater_entity2_id"
-CONF_HEATER_3 = "heater_entity3_id"
-CONF_HEATER_4 = "heater_entity4_id"
+CONF_UNDERLYING_LIST = "underlying_entity_ids"
 CONF_HEATER_KEEP_ALIVE = "heater_keep_alive"
 CONF_TEMP_SENSOR = "temperature_sensor_entity_id"
 CONF_LAST_SEEN_TEMP_SENSOR = "last_seen_temperature_sensor_entity_id"
@@ -88,23 +87,16 @@ CONF_THERMOSTAT_CENTRAL_CONFIG = "thermostat_central_config"
 CONF_THERMOSTAT_SWITCH = "thermostat_over_switch"
 CONF_THERMOSTAT_CLIMATE = "thermostat_over_climate"
 CONF_THERMOSTAT_VALVE = "thermostat_over_valve"
-CONF_CLIMATE = "climate_entity_id"
-CONF_CLIMATE_2 = "climate_entity2_id"
-CONF_CLIMATE_3 = "climate_entity3_id"
-CONF_CLIMATE_4 = "climate_entity4_id"
 CONF_USE_WINDOW_FEATURE = "use_window_feature"
 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"
 CONF_WINDOW_AUTO_MAX_DURATION = "window_auto_max_duration"
-CONF_VALVE = "valve_entity_id"
-CONF_VALVE_2 = "valve_entity2_id"
-CONF_VALVE_3 = "valve_entity3_id"
-CONF_VALVE_4 = "valve_entity4_id"
 CONF_AUTO_REGULATION_MODE = "auto_regulation_mode"
 CONF_AUTO_REGULATION_NONE = "auto_regulation_none"
 CONF_AUTO_REGULATION_SLOW = "auto_regulation_slow"
@@ -124,6 +116,20 @@ CONF_AUTO_FAN_HIGH = "auto_fan_high"
 CONF_AUTO_FAN_TURBO = "auto_fan_turbo"
 CONF_STEP_TEMPERATURE = "step_temperature"

+# Deprecated
+CONF_HEATER = "heater_entity_id"
+CONF_HEATER_2 = "heater_entity2_id"
+CONF_HEATER_3 = "heater_entity3_id"
+CONF_HEATER_4 = "heater_entity4_id"
+CONF_CLIMATE = "climate_entity_id"
+CONF_CLIMATE_2 = "climate_entity2_id"
+CONF_CLIMATE_3 = "climate_entity3_id"
+CONF_CLIMATE_4 = "climate_entity4_id"
+CONF_VALVE = "valve_entity_id"
+CONF_VALVE_2 = "valve_entity2_id"
+CONF_VALVE_3 = "valve_entity3_id"
+CONF_VALVE_4 = "valve_entity4_id"
+
 # Global params into configuration.yaml
 CONF_SHORT_EMA_PARAMS = "short_ema_params"
 CONF_SAFETY_MODE = "safety_mode"
@@ -145,6 +151,36 @@ 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,
+]
+
+HVAC_OFF_REASON_NAME = "hvac_off_reason"
+HVAC_OFF_REASON_MANUAL = "manual"
+HVAC_OFF_REASON_AUTO_START_STOP = "auto_start_stop"
+HVAC_OFF_REASON_WINDOW_DETECTION = "window_detection"
+HVAC_OFF_REASONS = Literal[  # pylint: disable=invalid-name
+    HVAC_OFF_REASON_MANUAL,
+    HVAC_OFF_REASON_AUTO_START_STOP,
+    HVAC_OFF_REASON_WINDOW_DETECTION,
+]
+
 DEFAULT_SHORT_EMA_PARAMS = {
    "max_alpha": 0.5,
    # In sec
@@ -216,10 +252,6 @@ CONF_PRESETS_AWAY_WITH_AC_VALUES = list(CONF_PRESETS_AWAY_WITH_AC.values())
 ALL_CONF = (
    [
        CONF_NAME,
-        CONF_HEATER,
-        CONF_HEATER_2,
-        CONF_HEATER_3,
-        CONF_HEATER_4,
        CONF_HEATER_KEEP_ALIVE,
        CONF_TEMP_SENSOR,
        CONF_EXTERNAL_TEMP_SENSOR,
@@ -249,20 +281,12 @@ ALL_CONF = (
        CONF_THERMOSTAT_TYPE,
        CONF_THERMOSTAT_SWITCH,
        CONF_THERMOSTAT_CLIMATE,
-        CONF_CLIMATE,
-        CONF_CLIMATE_2,
-        CONF_CLIMATE_3,
-        CONF_CLIMATE_4,
        CONF_USE_WINDOW_FEATURE,
        CONF_USE_MOTION_FEATURE,
        CONF_USE_PRESENCE_FEATURE,
        CONF_USE_POWER_FEATURE,
        CONF_USE_CENTRAL_BOILER_FEATURE,
        CONF_AC_MODE,
-        CONF_VALVE,
-        CONF_VALVE_2,
-        CONF_VALVE_3,
-        CONF_VALVE_4,
        CONF_AUTO_REGULATION_MODE,
        CONF_AUTO_REGULATION_DTEMP,
        CONF_AUTO_REGULATION_PERIOD_MIN,
@@ -330,7 +354,11 @@ CONF_WINDOW_ACTIONS = [
    CONF_WINDOW_ECO_TEMP,
 ]

-SUPPORT_FLAGS = ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.TURN_OFF | ClimateEntityFeature.TURN_ON
+SUPPORT_FLAGS = (
+    ClimateEntityFeature.TARGET_TEMPERATURE
+    | ClimateEntityFeature.TURN_OFF
+    | ClimateEntityFeature.TURN_ON
+)

 SERVICE_SET_PRESENCE = "set_presence"
 SERVICE_SET_PRESET_TEMPERATURE = "set_preset_temperature"
@@ -445,6 +473,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):
--- a/custom_components/versatile_thermostat/icons.json
+++ b/custom_components/versatile_thermostat/icons.json
@@ -0,0 +1,18 @@
+{
+  "entity": {
+    "climate": {
+      "versatile_thermostat": {
+        "state_attributes": {
+          "preset_mode": {
+            "state": {
+              "shedding": "mdi:power-plug-off",
+              "safety": "mdi:shield-alert",
+              "none": "mdi:knob",
+              "frost": "mdi:snowflake"
+            }
+          }
+        }
+      }
+    }
+  }
+}
--- a/custom_components/versatile_thermostat/manifest.json
+++ b/custom_components/versatile_thermostat/manifest.json
@@ -14,6 +14,6 @@
  "quality_scale": "silver",
  "requirements": [],
  "ssdp": [],
-  "version": "6.3.0",
+  "version": "6.6.0",
  "zeroconf": []
 }
--- a/custom_components/versatile_thermostat/strings.json
+++ b/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,28 +64,18 @@
          "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": {
        "title": "Linked entities",
        "description": "Linked entities attributes",
        "data": {
-          "heater_entity_id": "1st heater switch",
-          "heater_entity2_id": "2nd heater switch",
-          "heater_entity3_id": "3rd heater switch",
-          "heater_entity4_id": "4th heater switch",
+          "underlying_entity_ids": "The device(s) to be controlled",
          "heater_keep_alive": "Switch keep-alive interval in seconds",
          "proportional_function": "Algorithm",
-          "climate_entity_id": "1st underlying climate",
-          "climate_entity2_id": "2nd underlying climate",
-          "climate_entity3_id": "3rd underlying climate",
-          "climate_entity4_id": "4th underlying climate",
          "ac_mode": "AC mode",
-          "valve_entity_id": "1st valve number",
-          "valve_entity2_id": "2nd valve number",
-          "valve_entity3_id": "3rd valve number",
-          "valve_entity4_id": "4th valve number",
          "auto_regulation_mode": "Self-regulation",
          "auto_regulation_dtemp": "Regulation threshold",
          "auto_regulation_periode_min": "Regulation minimum period",
@@ -93,21 +84,10 @@
          "auto_fan_mode": "Auto fan mode"
        },
        "data_description": {
-          "heater_entity_id": "Mandatory heater entity id",
-          "heater_entity2_id": "Optional 2nd Heater entity id. Leave empty if not required",
-          "heater_entity3_id": "Optional 3rd Heater entity id. Leave empty if not required",
-          "heater_entity4_id": "Optional 4th Heater entity id. Leave empty if not required",
+          "underlying_entity_ids": "The device(s) to be controlled - 1 is required",
          "heater_keep_alive": "Optional heater switch state refresh interval. Leave empty if not required.",
          "proportional_function": "Algorithm to use (TPI is the only one for now)",
-          "climate_entity_id": "Underlying climate entity id",
-          "climate_entity2_id": "2nd underlying climate entity id",
-          "climate_entity3_id": "3rd underlying climate entity id",
-          "climate_entity4_id": "4th underlying climate entity id",
          "ac_mode": "Use the Air Conditioning (AC) mode",
-          "valve_entity_id": "1st valve number entity id",
-          "valve_entity2_id": "2nd valve number entity id",
-          "valve_entity3_id": "3rd valve number entity id",
-          "valve_entity4_id": "4th valve number entity id",
          "auto_regulation_mode": "Auto adjustment of the target temperature",
          "auto_regulation_dtemp": "The threshold in ° (or % for valve) under which the temperature change will not be sent",
          "auto_regulation_periode_min": "Duration in minutes between two regulation update",
@@ -262,6 +242,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,28 +279,18 @@
          "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": {
        "title": "Entities - {name}",
        "description": "Linked entities attributes",
        "data": {
-          "heater_entity_id": "1st heater switch",
-          "heater_entity2_id": "2nd heater switch",
-          "heater_entity3_id": "3rd heater switch",
-          "heater_entity4_id": "4th heater switch",
+          "underlying_entity_ids": "The device(s) to be controlled",
          "heater_keep_alive": "Switch keep-alive interval in seconds",
          "proportional_function": "Algorithm",
-          "climate_entity_id": "1st underlying climate",
-          "climate_entity2_id": "2nd underlying climate",
-          "climate_entity3_id": "3rd underlying climate",
-          "climate_entity4_id": "4th underlying climate",
          "ac_mode": "AC mode",
-          "valve_entity_id": "1st valve number",
-          "valve_entity2_id": "2nd valve number",
-          "valve_entity3_id": "3rd valve number",
-          "valve_entity4_id": "4th valve number",
          "auto_regulation_mode": "Self-regulation",
          "auto_regulation_dtemp": "Regulation threshold",
          "auto_regulation_periode_min": "Regulation minimum period",
@@ -328,21 +299,10 @@
          "auto_fan_mode": "Auto fan mode"
        },
        "data_description": {
-          "heater_entity_id": "Mandatory heater entity id",
-          "heater_entity2_id": "Optional 2nd Heater entity id. Leave empty if not used",
-          "heater_entity3_id": "Optional 3rd Heater entity id. Leave empty if not used",
-          "heater_entity4_id": "Optional 4th Heater entity id. Leave empty if not used",
+          "underlying_entity_ids": "The device(s) to be controlled - 1 is required",
          "heater_keep_alive": "Optional heater switch state refresh interval. Leave empty if not required.",
          "proportional_function": "Algorithm to use (TPI is the only one for now)",
-          "climate_entity_id": "Underlying climate entity id",
-          "climate_entity2_id": "2nd underlying climate entity id",
-          "climate_entity3_id": "3rd underlying climate entity id",
-          "climate_entity4_id": "4th underlying climate entity id",
          "ac_mode": "Use the Air Conditioning (AC) mode",
-          "valve_entity_id": "1st valve number entity id",
-          "valve_entity2_id": "2nd valve number entity id",
-          "valve_entity3_id": "3rd valve number entity id",
-          "valve_entity4_id": "4th valve number entity id",
          "auto_regulation_mode": "Auto adjustment of the target temperature",
          "auto_regulation_dtemp": "The threshold in ° (or % for valve) under which the temperature change will not be sent",
          "auto_regulation_periode_min": "Duration in minutes between two regulation update",
@@ -514,6 +474,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": {
@@ -524,7 +492,8 @@
            "state": {
              "power": "Shedding",
              "security": "Safety",
-              "none": "Manual"
+              "none": "Manual",
+              "frost": "Frost"
            }
          }
        }
--- a/custom_components/versatile_thermostat/switch.py
+++ b/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}_enable_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-sleep"
+
+    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()
--- a/custom_components/versatile_thermostat/thermostat_climate.py
+++ b/custom_components/versatile_thermostat/thermostat_climate.py
@@ -20,42 +20,21 @@ from .commons import NowClass, round_to_nearest
 from .base_thermostat import BaseThermostat, ConfigData
 from .pi_algorithm import PITemperatureRegulator

-from .const import (
-    overrides,
-    DOMAIN,
-    CONF_CLIMATE,
-    CONF_CLIMATE_2,
-    CONF_CLIMATE_3,
-    CONF_CLIMATE_4,
-    CONF_AUTO_REGULATION_MODE,
-    CONF_AUTO_REGULATION_NONE,
-    CONF_AUTO_REGULATION_SLOW,
-    CONF_AUTO_REGULATION_LIGHT,
-    CONF_AUTO_REGULATION_MEDIUM,
-    CONF_AUTO_REGULATION_STRONG,
-    CONF_AUTO_REGULATION_EXPERT,
-    CONF_AUTO_REGULATION_DTEMP,
-    CONF_AUTO_REGULATION_PERIOD_MIN,
-    CONF_AUTO_REGULATION_USE_DEVICE_TEMP,
-    CONF_AUTO_FAN_MODE,
-    CONF_AUTO_FAN_NONE,
-    CONF_AUTO_FAN_LOW,
-    CONF_AUTO_FAN_MEDIUM,
-    CONF_AUTO_FAN_HIGH,
-    CONF_AUTO_FAN_TURBO,
-    RegulationParamSlow,
-    RegulationParamLight,
-    RegulationParamMedium,
-    RegulationParamStrong,
-    AUTO_FAN_DTEMP_THRESHOLD,
-    AUTO_FAN_DEACTIVATED_MODES,
-    UnknownEntity,
-)
+from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import

 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__)
+_LOGGER_ENERGY = logging.getLogger(
+    "custom_components.versatile_thermostat.energy_debug"
+)
+

 HVAC_ACTION_ON = [  # pylint: disable=invalid-name
    HVACAction.COOLING,
@@ -64,7 +43,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 +59,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(
@@ -88,10 +69,7 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
                {
                    "is_over_climate",
                    "start_hvac_action_date",
-                    "underlying_climate_0",
-                    "underlying_climate_1",
-                    "underlying_climate_2",
-                    "underlying_climate_3",
+                    "underlying_entities",
                    "regulation_accumulated_error",
                    "auto_regulation_mode",
                    "auto_fan_mode",
@@ -99,6 +77,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 +96,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 config_entry.get(CONF_UNDERLYING_LIST):
+            self._underlyings.append(
+                UnderlyingClimate(
+                    hass=self._hass,
+                    thermostat=self,
+                    climate_entity_id=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
+        )
+
+        use_auto_start_stop = config_entry.get(CONF_USE_AUTO_START_STOP_FEATURE, False)
+        if use_auto_start_stop:
+            self._auto_start_stop_level = config_entry.get(
+                CONF_AUTO_START_STOP_LEVEL, AUTO_START_STOP_LEVEL_NONE
+            )
+        else:
+            self._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 +266,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 +330,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
@@ -520,18 +500,10 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
        self._attr_extra_state_attributes["start_hvac_action_date"] = (
            self._underlying_climate_start_hvac_action_date
        )
-        self._attr_extra_state_attributes["underlying_climate_0"] = self._underlyings[
-            0
-        ].entity_id
-        self._attr_extra_state_attributes["underlying_climate_1"] = (
-            self._underlyings[1].entity_id if len(self._underlyings) > 1 else None
-        )
-        self._attr_extra_state_attributes["underlying_climate_2"] = (
-            self._underlyings[2].entity_id if len(self._underlyings) > 2 else None
-        )
-        self._attr_extra_state_attributes["underlying_climate_3"] = (
-            self._underlyings[3].entity_id if len(self._underlyings) > 3 else None
-        )
+
+        self._attr_extra_state_attributes["underlying_entities"] = [
+            underlying.entity_id for underlying in self._underlyings
+        ]

        if self.is_regulated:
            self._attr_extra_state_attributes["is_regulated"] = self.is_regulated
@@ -562,7 +534,26 @@ 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",
            self,
@@ -609,8 +600,18 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):

        if self._total_energy is None:
            self._total_energy = added_energy
+            _LOGGER_ENERGY.debug(
+                "%s - incremente_energy set energy is %s",
+                self,
+                self._total_energy,
+            )
        else:
            self._total_energy += added_energy
+            _LOGGER_ENERGY.debug(
+                "%s - incremente_energy incremented energy is %s",
+                self,
+                self._total_energy,
+            )

        _LOGGER.debug(
            "%s - added energy is %.3f . Total energy is now: %.3f",
@@ -692,6 +693,13 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
            else None
        )

+        last_sent_temperature = under.last_sent_temperature or 0
+        under_temp_diff = (
+            (new_target_temp - last_sent_temperature) if new_target_temp else 0
+        )
+        if -1 < under_temp_diff < 1:
+            under_temp_diff = 0
+
        # Issue 99 - some AC turn hvac_mode=cool and hvac_action=idle when sending a HVACMode_OFF command
        # Issue 114 - Remove this because hvac_mode is now managed by local _hvac_mode and use idle action as is
        # if self._hvac_mode == HVACMode.OFF and new_hvac_action == HVACAction.IDLE:
@@ -702,7 +710,7 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
        if (
            new_hvac_mode == self._hvac_mode
            and new_hvac_action == old_hvac_action
-            and new_target_temp is None
+            and under_temp_diff == 0
            and (new_fan_mode is None or new_fan_mode == self._attr_fan_mode)
        ):
            _LOGGER.debug(
@@ -711,6 +719,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)",
@@ -828,17 +852,15 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
            changes = True

        # try to manage new target temperature set if state if no other changes have been found
-        if not changes:
+        # and if a target temperature have already been sent
+        if not changes and under.last_sent_temperature is not None:
            _LOGGER.debug(
                "Do temperature check. under.last_sent_temperature is %s, new_target_temp is %s",
                under.last_sent_temperature,
                new_target_temp,
            )
-            if (
-                # if the underlying have change its target temperature
-                new_target_temp is not None
-                and new_target_temp != under.last_sent_temperature
-            ):
+            # if the underlying have change its target temperature
+            if under_temp_diff != 0:
                _LOGGER.info(
                    "%s - Target temp in underlying have change to %s (vs %s)",
                    self,
@@ -849,17 +871,95 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
                changes = True
            else:
                _LOGGER.debug(
-                    "%s - Forget the eventual underlying temperature change because VTherm is regulated",
+                    "%s - Forget the eventual underlying temperature change there is no real change",
                    self,
                )

        await end_climate_changed(changes)

+    async def check_auto_start_stop(self):
+        """Check the auto-start-stop and an eventual action
+        Return False if we should stop the control_heating method"""
+        slope = (self.last_temperature_slope or 0) / 60  # to have the slope in °/min
+        action = self._auto_start_stop_algo.calculate_action(
+            self.hvac_mode,
+            self._saved_hvac_mode,
+            self.target_temperature,
+            self.current_temperature,
+            slope,
+            self.now,
+        )
+        _LOGGER.debug("%s - auto_start_stop action is %s", self, action)
+        if action == AUTO_START_STOP_ACTION_OFF and self.is_on:
+            _LOGGER.info(
+                "%s - Turning OFF the Vtherm due to auto-start-stop conditions",
+                self,
+            )
+            self.set_hvac_off_reason(HVAC_OFF_REASON_AUTO_START_STOP)
+            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": round(slope, 3),
+                    "accumulated_error": self._auto_start_stop_algo.accumulated_error,
+                    "accumulated_error_threshold": self._auto_start_stop_algo.accumulated_error_threshold,
+                },
+            )
+
+            # Stop here
+            return False
+        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": round(slope, 3),
+                    "accumulated_error": self._auto_start_stop_algo.accumulated_error,
+                    "accumulated_error_threshold": self._auto_start_stop_algo.accumulated_error_threshold,
+                },
+            )
+
+            self.update_custom_attributes()
+
+        return True
+
    @overrides
    async def async_control_heating(self, force=False, _=None) -> bool:
        """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:
+            continu = await self.check_auto_start_stop()
+            if not continu:
+                return ret
+        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:
@@ -867,6 +967,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"""
@@ -1013,6 +1118,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"""
--- a/custom_components/versatile_thermostat/thermostat_switch.py
+++ b/custom_components/versatile_thermostat/thermostat_switch.py
@@ -10,10 +10,7 @@ from homeassistant.helpers.event import (
 from homeassistant.components.climate import HVACMode

 from .const import (
-    CONF_HEATER,
-    CONF_HEATER_2,
-    CONF_HEATER_3,
-    CONF_HEATER_4,
+    CONF_UNDERLYING_LIST,
    CONF_HEATER_KEEP_ALIVE,
    CONF_INVERSE_SWITCH,
    overrides,
@@ -24,7 +21,9 @@ from .underlyings import UnderlyingSwitch
 from .prop_algorithm import PropAlgorithm

 _LOGGER = logging.getLogger(__name__)
-
+_LOGGER_ENERGY = logging.getLogger(
+    "custom_components.versatile_thermostat.energy_debug"
+)

 class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
    """Representation of a base class for a Versatile Thermostat over a switch."""
@@ -35,10 +34,7 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
                {
                    "is_over_switch",
                    "is_inversed",
-                    "underlying_switch_0",
-                    "underlying_switch_1",
-                    "underlying_switch_2",
-                    "underlying_switch_3",
+                    "underlying_entities",
                    "on_time_sec",
                    "off_time_sec",
                    "cycle_min",
@@ -90,13 +86,7 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
            self.name,
        )

-        lst_switches = [config_entry.get(CONF_HEATER)]
-        if config_entry.get(CONF_HEATER_2):
-            lst_switches.append(config_entry.get(CONF_HEATER_2))
-        if config_entry.get(CONF_HEATER_3):
-            lst_switches.append(config_entry.get(CONF_HEATER_3))
-        if config_entry.get(CONF_HEATER_4):
-            lst_switches.append(config_entry.get(CONF_HEATER_4))
+        lst_switches = config_entry.get(CONF_UNDERLYING_LIST)

        delta_cycle = self._cycle_min * 60 / len(lst_switches)
        for idx, switch in enumerate(lst_switches):
@@ -140,16 +130,10 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
        self._attr_extra_state_attributes["is_over_switch"] = self.is_over_switch
        self._attr_extra_state_attributes["is_inversed"] = self.is_inversed
        self._attr_extra_state_attributes["keep_alive_sec"] = under0.keep_alive_sec
-        self._attr_extra_state_attributes["underlying_switch_0"] = under0.entity_id
-        self._attr_extra_state_attributes["underlying_switch_1"] = (
-            self._underlyings[1].entity_id if len(self._underlyings) > 1 else None
-        )
-        self._attr_extra_state_attributes["underlying_switch_2"] = (
-            self._underlyings[2].entity_id if len(self._underlyings) > 2 else None
-        )
-        self._attr_extra_state_attributes["underlying_switch_3"] = (
-            self._underlyings[3].entity_id if len(self._underlyings) > 3 else None
-        )
+
+        self._attr_extra_state_attributes["underlying_entities"] = [
+           underlying.entity_id for underlying in self._underlyings
+        ]

        self._attr_extra_state_attributes[
            "on_percent"
@@ -201,8 +185,18 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):

        if self._total_energy is None:
            self._total_energy = added_energy
+            _LOGGER_ENERGY.debug(
+                "%s - incremente_energy set energy is %s",
+                self,
+                self._total_energy,
+            )
        else:
            self._total_energy += added_energy
+            _LOGGER_ENERGY.debug(
+                "%s - incremente_energy increment energy is %s",
+                self,
+                self._total_energy,
+            )

        self.update_custom_attributes()

--- a/custom_components/versatile_thermostat/thermostat_valve.py
+++ b/custom_components/versatile_thermostat/thermostat_valve.py
@@ -15,10 +15,7 @@ from .base_thermostat import BaseThermostat, ConfigData
 from .prop_algorithm import PropAlgorithm

 from .const import (
-    CONF_VALVE,
-    CONF_VALVE_2,
-    CONF_VALVE_3,
-    CONF_VALVE_4,
+    CONF_UNDERLYING_LIST,
    # This is not really self-regulation but regulation here
    CONF_AUTO_REGULATION_DTEMP,
    CONF_AUTO_REGULATION_PERIOD_MIN,
@@ -28,7 +25,9 @@ from .const import (
 from .underlyings import UnderlyingValve

 _LOGGER = logging.getLogger(__name__)
-
+_LOGGER_ENERGY = logging.getLogger(
+    "custom_components.versatile_thermostat.energy_debug"
+)

 class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=abstract-method
    """Representation of a class for a Versatile Thermostat over a Valve"""
@@ -37,10 +36,7 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a
        frozenset(
            {
                "is_over_valve",
-                "underlying_valve_0",
-                "underlying_valve_1",
-                "underlying_valve_2",
-                "underlying_valve_3",
+                "underlying_entities",
                "on_time_sec",
                "off_time_sec",
                "cycle_min",
@@ -105,13 +101,7 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a
            self.name,
        )

-        lst_valves = [config_entry.get(CONF_VALVE)]
-        if config_entry.get(CONF_VALVE_2):
-            lst_valves.append(config_entry.get(CONF_VALVE_2))
-        if config_entry.get(CONF_VALVE_3):
-            lst_valves.append(config_entry.get(CONF_VALVE_3))
-        if config_entry.get(CONF_VALVE_4):
-            lst_valves.append(config_entry.get(CONF_VALVE_4))
+        lst_valves = config_entry.get(CONF_UNDERLYING_LIST)

        for _, valve in enumerate(lst_valves):
            self._underlyings.append(
@@ -163,18 +153,10 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a
            "valve_open_percent"
        ] = self.valve_open_percent
        self._attr_extra_state_attributes["is_over_valve"] = self.is_over_valve
-        self._attr_extra_state_attributes["underlying_valve_0"] = self._underlyings[
-            0
-        ].entity_id
-        self._attr_extra_state_attributes["underlying_valve_1"] = (
-            self._underlyings[1].entity_id if len(self._underlyings) > 1 else None
-        )
-        self._attr_extra_state_attributes["underlying_valve_2"] = (
-            self._underlyings[2].entity_id if len(self._underlyings) > 2 else None
-        )
-        self._attr_extra_state_attributes["underlying_valve_3"] = (
-            self._underlyings[3].entity_id if len(self._underlyings) > 3 else None
-        )
+
+        self._attr_extra_state_attributes["underlying_entities"] = [
+           underlying.entity_id for underlying in self._underlyings
+        ]

        self._attr_extra_state_attributes[
            "on_percent"
@@ -285,8 +267,18 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a

        if self._total_energy is None:
            self._total_energy = added_energy
+            _LOGGER_ENERGY.debug(
+                "%s - incremente_energy set energy is %s",
+                self,
+                self._total_energy,
+            )
        else:
            self._total_energy += added_energy
+            _LOGGER_ENERGY.debug(
+                "%s - get_my_previous_state increment energy is %s",
+                self,
+                self._total_energy,
+            )

        self.update_custom_attributes()

--- a/custom_components/versatile_thermostat/translations/en.json
+++ b/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,28 +64,18 @@
          "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 selecting 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": {
        "title": "Linked entities",
        "description": "Linked entities attributes",
        "data": {
-          "heater_entity_id": "1st heater switch",
-          "heater_entity2_id": "2nd heater switch",
-          "heater_entity3_id": "3rd heater switch",
-          "heater_entity4_id": "4th heater switch",
+          "underlying_entity_ids": "The device(s) to be controlled",
          "heater_keep_alive": "Switch keep-alive interval in seconds",
          "proportional_function": "Algorithm",
-          "climate_entity_id": "1st underlying climate",
-          "climate_entity2_id": "2nd underlying climate",
-          "climate_entity3_id": "3rd underlying climate",
-          "climate_entity4_id": "4th underlying climate",
          "ac_mode": "AC mode",
-          "valve_entity_id": "1st valve number",
-          "valve_entity2_id": "2nd valve number",
-          "valve_entity3_id": "3rd valve number",
-          "valve_entity4_id": "4th valve number",
          "auto_regulation_mode": "Self-regulation",
          "auto_regulation_dtemp": "Regulation threshold",
          "auto_regulation_periode_min": "Regulation minimum period",
@@ -93,21 +84,10 @@
          "auto_fan_mode": "Auto fan mode"
        },
        "data_description": {
-          "heater_entity_id": "Mandatory heater entity id",
-          "heater_entity2_id": "Optional 2nd Heater entity id. Leave empty if not required",
-          "heater_entity3_id": "Optional 3rd Heater entity id. Leave empty if not required",
-          "heater_entity4_id": "Optional 4th Heater entity id. Leave empty if not required",
+          "underlying_entity_ids": "The device(s) to be controlled - 1 is required",
          "heater_keep_alive": "Optional heater switch state refresh interval. Leave empty if not required.",
          "proportional_function": "Algorithm to use (TPI is the only one for now)",
-          "climate_entity_id": "Underlying climate entity id",
-          "climate_entity2_id": "2nd underlying climate entity id",
-          "climate_entity3_id": "3rd underlying climate entity id",
-          "climate_entity4_id": "4th underlying climate entity id",
          "ac_mode": "Use the Air Conditioning (AC) mode",
-          "valve_entity_id": "1st valve number entity id",
-          "valve_entity2_id": "2nd valve number entity id",
-          "valve_entity3_id": "3rd valve number entity id",
-          "valve_entity4_id": "4th valve number entity id",
          "auto_regulation_mode": "Auto adjustment of the target temperature",
          "auto_regulation_dtemp": "The threshold in ° (or % for valve) under which the temperature change will not be sent",
          "auto_regulation_periode_min": "Duration in minutes between two regulation update",
@@ -262,6 +242,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,28 +279,18 @@
          "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": {
        "title": "Entities - {name}",
        "description": "Linked entities attributes",
        "data": {
-          "heater_entity_id": "1st heater switch",
-          "heater_entity2_id": "2nd heater switch",
-          "heater_entity3_id": "3rd heater switch",
-          "heater_entity4_id": "4th heater switch",
+          "underlying_entity_ids": "The device(s) to be controlled",
          "heater_keep_alive": "Switch keep-alive interval in seconds",
          "proportional_function": "Algorithm",
-          "climate_entity_id": "1st underlying climate",
-          "climate_entity2_id": "2nd underlying climate",
-          "climate_entity3_id": "3rd underlying climate",
-          "climate_entity4_id": "4th underlying climate",
          "ac_mode": "AC mode",
-          "valve_entity_id": "1st valve number",
-          "valve_entity2_id": "2nd valve number",
-          "valve_entity3_id": "3rd valve number",
-          "valve_entity4_id": "4th valve number",
          "auto_regulation_mode": "Self-regulation",
          "auto_regulation_dtemp": "Regulation threshold",
          "auto_regulation_periode_min": "Regulation minimum period",
@@ -328,21 +299,10 @@
          "auto_fan_mode": "Auto fan mode"
        },
        "data_description": {
-          "heater_entity_id": "Mandatory heater entity id",
-          "heater_entity2_id": "Optional 2nd Heater entity id. Leave empty if not used",
-          "heater_entity3_id": "Optional 3rd Heater entity id. Leave empty if not used",
-          "heater_entity4_id": "Optional 4th Heater entity id. Leave empty if not used",
+          "underlying_entity_ids": "The device(s) to be controlled - 1 is required",
          "heater_keep_alive": "Optional heater switch state refresh interval. Leave empty if not required.",
          "proportional_function": "Algorithm to use (TPI is the only one for now)",
-          "climate_entity_id": "Underlying climate entity id",
-          "climate_entity2_id": "2nd underlying climate entity id",
-          "climate_entity3_id": "3rd underlying climate entity id",
-          "climate_entity4_id": "4th underlying climate entity id",
          "ac_mode": "Use the Air Conditioning (AC) mode",
-          "valve_entity_id": "1st valve number entity id",
-          "valve_entity2_id": "2nd valve number entity id",
-          "valve_entity3_id": "3rd valve number entity id",
-          "valve_entity4_id": "4th valve number entity id",
          "auto_regulation_mode": "Auto adjustment of the target temperature",
          "auto_regulation_dtemp": "The threshold in ° (or % for valve) under which the temperature change will not be sent",
          "auto_regulation_periode_min": "Duration in minutes between two regulation update",
@@ -514,6 +474,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": {
@@ -524,7 +492,8 @@
            "state": {
              "power": "Shedding",
              "security": "Safety",
-              "none": "Manual"
+              "none": "Manual",
+              "frost": "Frost"
            }
          }
        }
@@ -578,4 +547,4 @@
      }
    }
  }
-}
+}
--- a/custom_components/versatile_thermostat/translations/fr.json
+++ b/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": {
@@ -542,7 +554,8 @@
            "state": {
              "power": "Délestage",
              "security": "Sécurité",
-              "none": "Manuel"
+              "none": "Manuel",
+              "frost": "Hors Gel"
            }
          }
        }
--- a/custom_components/versatile_thermostat/translations/it.json
+++ b/custom_components/versatile_thermostat/translations/it.json
@@ -364,7 +364,8 @@
            "state": {
              "power": "Ripartizione",
              "security": "Sicurezza",
-              "none": "Manuale"
+              "none": "Manuale",
+              "frost": "Gelo"
            }
          }
        }
--- a/custom_components/versatile_thermostat/underlyings.py
+++ b/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."""
--- a/custom_components/versatile_thermostat/vtherm_api.py
+++ b/custom_components/versatile_thermostat/vtherm_api.py
@@ -150,10 +150,11 @@ class VersatileThermostatAPI(dict):
                return entity.state
        return None

-    async def init_vtherm_links(self):
+    async def init_vtherm_links(self, entry_id=None):
        """Initialize all VTherms entities links
        This method is called when HA is fully started (and all entities should be initialized)
        Or when we need to reload all VTherm links (with Number temp entities, central boiler, ...)
+        If entry_id is set, only the VTherm of this entry will be reloaded
        """
        await self.reload_central_boiler_binary_listener()
        await self.reload_central_boiler_entities_list()
@@ -175,7 +176,8 @@ class VersatileThermostatAPI(dict):
                    entity.device_info
                    and entity.device_info.get("model", None) == DOMAIN
                ):
-                    await entity.async_startup(self.find_central_configuration())
+                    if entry_id is None or entry_id == entity.unique_id:
+                        await entity.async_startup(self.find_central_configuration())

    async def init_vtherm_preset_with_central(self):
        """Init all VTherm presets when the VTherm uses central temperature"""
--- a/hacs.json
+++ b/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"
 }
--- a/requirements_dev.txt
+++ b/requirements_dev.txt
@@ -1 +1 @@
-homeassistant==2024.9.3
+homeassistant==2024.10.4
--- a/tests/const.py
+++ b/tests/const.py
@@ -74,7 +74,7 @@ MOCK_TH_OVER_SWITCH_CENTRAL_MAIN_CONFIG = {
 }

 MOCK_TH_OVER_SWITCH_TYPE_CONFIG = {
-    CONF_HEATER: "switch.mock_switch",
+    CONF_UNDERLYING_LIST: ["switch.mock_switch"],
    CONF_HEATER_KEEP_ALIVE: 0,
    CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
    CONF_AC_MODE: False,
@@ -82,17 +82,14 @@ MOCK_TH_OVER_SWITCH_TYPE_CONFIG = {
 }

 MOCK_TH_OVER_SWITCH_AC_TYPE_CONFIG = {
-    CONF_HEATER: "switch.mock_air_conditioner",
+    CONF_UNDERLYING_LIST: ["switch.mock_air_conditioner"],
    CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
    CONF_AC_MODE: True,
    CONF_INVERSE_SWITCH: False,
 }

 MOCK_TH_OVER_4SWITCH_TYPE_CONFIG = {
-    CONF_HEATER: "switch.mock_4switch0",
-    CONF_HEATER_2: "switch.mock_4switch1",
-    CONF_HEATER_3: "switch.mock_4switch2",
-    CONF_HEATER_4: "switch.mock_4switch3",
+    CONF_UNDERLYING_LIST: ["switch.mock_4switch0", "switch.mock_4switch1","switch.mock_4switch2","switch.mock_4switch3"],
    CONF_HEATER_KEEP_ALIVE: 0,
    CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
    CONF_AC_MODE: False,
@@ -105,7 +102,7 @@ MOCK_TH_OVER_SWITCH_TPI_CONFIG = {
 }

 MOCK_TH_OVER_CLIMATE_TYPE_CONFIG = {
-    CONF_CLIMATE: "climate.mock_climate",
+    CONF_UNDERLYING_LIST: ["climate.mock_climate"],
    CONF_AC_MODE: False,
    CONF_AUTO_REGULATION_MODE: CONF_AUTO_REGULATION_STRONG,
    CONF_AUTO_REGULATION_DTEMP: 0.5,
@@ -115,7 +112,7 @@ MOCK_TH_OVER_CLIMATE_TYPE_CONFIG = {
 }

 MOCK_TH_OVER_CLIMATE_TYPE_USE_DEVICE_TEMP_CONFIG = {
-    CONF_CLIMATE: "climate.mock_climate",
+    CONF_UNDERLYING_LIST: ["climate.mock_climate"],
    CONF_AC_MODE: False,
    CONF_AUTO_REGULATION_MODE: CONF_AUTO_REGULATION_STRONG,
    CONF_AUTO_REGULATION_DTEMP: 0.1,
@@ -125,13 +122,13 @@ MOCK_TH_OVER_CLIMATE_TYPE_USE_DEVICE_TEMP_CONFIG = {
 }

 MOCK_TH_OVER_CLIMATE_TYPE_NOT_REGULATED_CONFIG = {
-    CONF_CLIMATE: "climate.mock_climate",
+    CONF_UNDERLYING_LIST: ["climate.mock_climate"],
    CONF_AC_MODE: False,
    CONF_AUTO_REGULATION_MODE: CONF_AUTO_REGULATION_NONE,
 }

 MOCK_TH_OVER_CLIMATE_TYPE_AC_CONFIG = {
-    CONF_CLIMATE: "climate.mock_climate",
+    CONF_UNDERLYING_LIST: ["climate.mock_climate"],
    CONF_AC_MODE: True,
    CONF_AUTO_REGULATION_MODE: CONF_AUTO_REGULATION_STRONG,
    CONF_AUTO_REGULATION_DTEMP: 0.5,
--- a/tests/test_auto_start_stop.py
+++ b/tests/test_auto_start_stop.py
--- a/tests/test_central_mode.py
+++ b/tests/test_central_mode.py
@@ -982,7 +982,8 @@ async def test_switch_change_central_mode_true_with_cool_only_and_window(
        await select_entity.async_select_option(CENTRAL_MODE_COOL_ONLY)

        assert entity.last_central_mode is CENTRAL_MODE_COOL_ONLY
-        await entity.async_set_hvac_mode(HVACMode.OFF)
+        assert entity.hvac_mode is HVACMode.OFF
+        assert entity.hvac_off_reason == HVAC_OFF_REASON_MANUAL
        await entity.async_set_preset_mode(PRESET_ACTIVITY)
        assert entity._saved_hvac_mode == HVACMode.HEAT
        assert entity._saved_preset_mode == PRESET_ACTIVITY
@@ -1000,12 +1001,14 @@ async def test_switch_change_central_mode_true_with_cool_only_and_window(

        await try_function(None)

-        assert mock_send_event.call_count == 1
-        mock_send_event.assert_has_calls(
-            [call.send_event(EventType.HVAC_MODE_EVENT, {"hvac_mode": HVACMode.OFF})]
-        )
+        # The VTherm is already off -> window detection is ignored
+        assert mock_send_event.call_count == 0
+        # mock_send_event.assert_has_calls(
+        #    [call.send_event(EventType.HVAC_MODE_EVENT, {"hvac_mode": HVACMode.OFF})]
+        # )

        assert entity.hvac_mode == HVACMode.OFF
+        assert entity.hvac_off_reason == HVAC_OFF_REASON_MANUAL
        assert entity.preset_mode == PRESET_ACTIVITY
        assert entity._saved_hvac_mode == HVACMode.HEAT
        assert entity._saved_preset_mode == PRESET_ACTIVITY
@@ -1021,6 +1024,8 @@ async def test_switch_change_central_mode_true_with_cool_only_and_window(
        assert entity.last_central_mode is CENTRAL_MODE_AUTO
        # No change
        assert entity.hvac_mode == HVACMode.OFF
+        # We have to a reason of WINDOW_DETECTION
+        assert entity.hvac_off_reason == HVAC_OFF_REASON_WINDOW_DETECTION
        assert entity.preset_mode == PRESET_ACTIVITY
        assert entity._saved_hvac_mode == HVACMode.HEAT
        assert entity._saved_preset_mode == PRESET_ACTIVITY
@@ -1046,6 +1051,7 @@ async def test_switch_change_central_mode_true_with_cool_only_and_window(

        # We should stay off because central is STOPPED
        assert entity.hvac_mode == HVACMode.HEAT
+        assert entity.hvac_off_reason is None
        assert entity.preset_mode == PRESET_ACTIVITY
        assert entity._saved_hvac_mode == HVACMode.HEAT
        assert entity._saved_preset_mode == PRESET_ACTIVITY
--- a/tests/test_config_flow.py
+++ b/tests/test_config_flow.py
--- a/tests/test_movement.py
+++ b/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
--- a/tests/test_overclimate.py
+++ b/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,13 +295,102 @@ 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
+        # Wait 11 sec
+        event_timestamp = now + timedelta(seconds=11)
+        await send_climate_change_event_with_temperature(
+            entity,
+            HVACMode.HEAT,
+            HVACMode.HEAT,
+            HVACAction.OFF,
+            HVACAction.OFF,
+            event_timestamp,
+            entity.min_temp + 1.5,
+            True,
+            "climate.mock_climate",  # the underlying climate entity id
+        )
+        assert entity.target_temperature == entity.min_temp + 1
+        assert entity.preset_mode is PRESET_NONE
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_bug_615(
+    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 don't change its own temperature target if no
+    target_temperature have already been sent"""
+
+    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
+    )
+
+    # 1. create the thermostat
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ), patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
+        return_value=fake_underlying_climate,
+    ):
+        vtherm = await create_thermostat(hass, entry, "climate.theoverclimatemockname")
+
+        assert vtherm
+
+        assert vtherm.name == "TheOverClimateMockName"
+        assert vtherm.is_over_climate is True
+        assert vtherm.hvac_mode is HVACMode.OFF
+        # because in MockClimate HVACAction is HEATING if hvac_mode is not set
+        assert vtherm.hvac_action is HVACAction.HEATING
+
+        # Force a preset_mode without sending a temperature (as it was restored with a preset)
+        vtherm._attr_preset_mode = PRESET_BOOST
+
+        assert vtherm.target_temperature == vtherm.min_temp
+        assert vtherm.preset_mode is PRESET_BOOST
+
+    with patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.set_hvac_mode"
+    ) as mock_underlying_set_hvac_mode:
+        # 2. Change the target temp of underlying thermostat at now + 1 min
+        now = now + timedelta(minutes=1)
+        await send_climate_change_event_with_temperature(
+            vtherm,
+            HVACMode.OFF,
+            HVACMode.OFF,
+            HVACAction.OFF,
+            HVACAction.OFF,
+            now,
+            25,
+            True,
+            "climate.mock_climate",  # the underlying climate entity id
+        )
+        # Should NOT have been taken the new target temp nor have change the preset
+        assert vtherm.target_temperature == vtherm.min_temp
+        assert vtherm.preset_mode is PRESET_BOOST
+
+        mock_underlying_set_hvac_mode.assert_not_called()
+

@pytest.mark.parametrize("expected_lingering_timers", [True])
 async def test_bug_508(
@@ -506,3 +595,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
--- a/tests/test_window.py
+++ b/tests/test_window.py
@@ -205,6 +205,8 @@ async def test_window_management_time_enough(
        assert mock_heater_off.call_count == 2
        assert mock_condition.call_count == 1
        assert entity.hvac_mode is HVACMode.OFF
+        assert entity._saved_hvac_mode is HVACMode.HEAT
+        assert entity.hvac_off_reason == HVAC_OFF_REASON_WINDOW_DETECTION
        assert entity.window_state == STATE_ON

    # Close the window
@@ -242,6 +244,9 @@ async def test_window_management_time_enough(
            any_order=False,
        )
        assert entity.preset_mode is PRESET_BOOST
+        assert entity.hvac_mode is HVACMode.HEAT
+        assert entity._saved_hvac_mode is HVACMode.HEAT  # No change
+        assert entity.hvac_off_reason == None

    # Clean the entity
    entity.remove_thermostat()
@@ -1339,6 +1344,7 @@ async def test_window_action_fan_only(hass: HomeAssistant, skip_hass_states_is_s
        # The underlying should be in FAN_ONLY hvac_mode
        assert entity.hvac_mode is HVACMode.FAN_ONLY
        assert entity._saved_hvac_mode is HVACMode.HEAT
+        assert entity.hvac_off_reason is None  # Hvac is not off
        assert entity.preset_mode is PRESET_COMFORT

    # 3. Close the window
@@ -1357,7 +1363,7 @@ async def test_window_action_fan_only(hass: HomeAssistant, skip_hass_states_is_s
        await try_function(None)

        # Wait for initial delay of heater
-        await asyncio.sleep(0.3)
+        await hass.async_block_till_done()

        assert entity.window_state == STATE_OFF
        assert mock_send_event.call_count == 1
@@ -1379,6 +1385,7 @@ async def test_window_action_fan_only(hass: HomeAssistant, skip_hass_states_is_s
        )
        assert entity.hvac_mode is HVACMode.HEAT
        assert entity.preset_mode is PRESET_COMFORT
+        assert entity.hvac_off_reason is None

    # Clean the entity
    entity.remove_thermostat()
Author	SHA1	Message	Date
Jean-Marc Collin	f9df925181	Issue #615 - VTherm switch to manual on its own (#618 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-11-09 18:44:13 +01:00
Jean-Marc Collin	2d72efe447	Issue 600 energy can be negative after configuration (#614 ) * Add logs to diagnose the case * Issue #552 (#608) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com> * Fix typo (#607) * - Force writing state when entity is removed - Fix bug with issue #552 on CONF_USE_CENTRAL_BOILER_FEATURE which should be proposed on a central configuration - Improve reload of entity to avoid reloading all VTherm. Only the reconfigured one will be reloaded --------- Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com> Co-authored-by: Ludovic BOUÉ <lboue@users.noreply.github.com>	2024-11-07 21:57:08 +01:00
Ludovic BOUÉ	95af6eba97	Fix typo (#607 )	2024-11-05 22:47:42 +01:00
Jean-Marc Collin	06dc537767	Issue #552 (#608 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-11-05 22:39:26 +01:00
Joeri Colman	2d79d961dc	Update en.json (#604 ) fixed typo	2024-11-05 10:40:49 +01:00
Jean-Marc Collin	027bf8386b	Add message into issue template.	2024-11-05 06:37:27 +00:00
Jean-Marc Collin	a0e548ef71	Release	2024-11-03 22:16:15 +00:00
Jean-Marc Collin	132519b471	Merge #590 and fix some tests	2024-11-03 22:12:56 +00:00
hilburn	e6c330fc9d	Underlying config changes (#590 ) * Changes config_flow to allow dynamic length list of underlying entities Updates previously defined 4x entries to new config style Changes to thermostat_X to load underlying entities from list Changes to thermostat X to display underlying entities as a list - COULD BREAK EXISTING TEMPLATES * Modifies tests to use the new list format * Added English translation for UI * Removed all references to individual entities in strings/en.json * Fix merge mistake --------- Co-authored-by: Jean-Marc Collin <jm.collin.78@gmail.com>	2024-11-03 22:52:19 +01:00
Jean-Marc Collin	968e8286ea	Add some infos	2024-11-03 21:50:42 +00:00
hilburn	0f60c070ab	Preset display tweaks (#599 ) * Addded Frost Preset to translations Added Icons for Shedding, Safety, Manual and Frost Presets * Fixed French Translation	2024-11-03 11:50:37 +01:00
Jean-Marc Collin	810430f7b1	Update README.md #597	2024-11-02 19:16:24 +01:00
Jean-Marc Collin	b4860c2b8d	Issue 585 add auto start/stop feature (#594 ) * Migrate to HA 2024.10.4 * Auto start/stop alog and testu + ConfigFlow * With config flow ok * Change algo * All is fine * Add change_preset test * + comment * FIX too much start/stop * Change algo to take slop into account * Allow calculation even if slope is None * With enable + tests + hysteresis in calculation * Add hvac_off_reason and test with window interaction * Fix some tests * Restore saved_state * Release --------- Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-11-01 18:54:22 +01:00
Gernot Messow	60bd522a97	Filter out-of-range target temperature sent from underlying climate devices (#581 ) * Filter out-of-range temperature from underlying climate * Fixed broken test case, added new test case for range filtering	2024-10-27 09:21:08 +01:00
Jean-Marc Collin	fc39cf5f40	Maia suggestion to README	2024-10-26 11:27:16 +02:00
Jean-Marc Collin	f6fb7487d5	Issue #467 - Always apply offset compensation (#567 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-10-16 19:33:55 +02:00
Jean-Marc Collin	0f585be0c9	issue #556 - enhance motion detection feature (2)	2024-10-16 05:08:57 +00:00
Jean-Marc Collin	492c95aff5	FIX issue #556 - enhance motion detection feature (#560 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-10-14 20:14:51 +02:00
Jean-Marc Collin	a530051bbd	FIX #518 TypeError: unsupported operand type(s) for -: 'int' and 'NoneType' (#559 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-10-14 19:29:34 +02:00
Jean-Marc Collin	4ef82af8ce	Merge branch 'issue_554-simulate-hvac-action'	2024-10-14 17:01:01 +00:00
Jean-Marc Collin	2ea5cf471b	Cleaning	2024-10-14 16:58:18 +00:00
Jean-Marc Collin	f6afaf2715	with local tests ok. (#555 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-10-14 09:02:50 +02:00
Jean-Marc Collin	f29b2f9b81	with local tests ok.	2024-10-14 07:01:27 +00:00
Jean-Marc Collin	de9b95903e	Add testu	2024-10-14 04:56:12 +00:00
Jean-Marc Collin	d112273c58	Fix preset temp is sommetimes lost on over_climate	2024-10-14 04:43:19 +00:00