FIX #518 (#543)

Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>

.devcontainer/configuration.yaml

@@ -3,9 +3,12 @@ default_config:
 logger:
     default: warning
     logs:
-    #    custom_components.versatile_thermostat: debug
-    #    custom_components.versatile_thermostat.underlyings: debug
-    #    custom_components.versatile_thermostat.climate: debug
+       custom_components.versatile_thermostat: debug
+       # custom_components.versatile_thermostat.underlyings: info
+       # custom_components.versatile_thermostat.climate: info
+       # custom_components.versatile_thermostat.base_thermostat: debug
+       custom_components.versatile_thermostat.sensor: info
+       custom_components.versatile_thermostat.binary_sensor: info
 
 # If you need to debug uncommment the line below (doc: https://www.home-assistant.io/integrations/debugpy/)
 debugpy:
@@ -166,8 +169,15 @@ climate:
       heater: input_boolean.fake_heater_switch3
       target_sensor: input_number.fake_temperature_sensor1
 
+input_datetime:
+    fake_last_seen:
+        name: Last seen temp sensor
+        icon: mdi:update
+        has_date: true
+        has_time: true
+
 recorder:
-    commit_interval: 1
+    commit_interval: 0
     include:
         domains:
             - input_boolean
@@ -176,6 +186,9 @@ recorder:
             - climate
             - sensor
             - binary_sensor
+            - number
+            - input_select
+            - versatile_thermostat
 
 template:
     - binary_sensor:

.vscode/settings.json

@@ -4,7 +4,6 @@
         "editor.formatOnSave": true,
         "editor.formatOnSaveMode": "modifications"
     },
-    "pylint.lintOnChange": false,
     "files.associations": {
         "*.yaml": "home-assistant"
     },

README-fr.md

@@ -75,6 +75,7 @@
 - [Dépannages](#dépannages)
   - [Utilisation d'un Heatzy](#utilisation-dun-heatzy)
   - [Utilisation d'un radiateur avec un fil pilote](#utilisation-dun-radiateur-avec-un-fil-pilote)
+  - [Utilisation d'un radiateur avec un fil pilote](#utilisation-dun-radiateur-avec-un-fil-pilote-1)
   - [Seul le premier radiateur chauffe](#seul-le-premier-radiateur-chauffe)
   - [Le radiateur chauffe alors que la température de consigne est dépassée ou ne chauffe pas alors que la température de la pièce est bien en-dessous de la consigne](#le-radiateur-chauffe-alors-que-la-température-de-consigne-est-dépassée-ou-ne-chauffe-pas-alors-que-la-température-de-la-pièce-est-bien-en-dessous-de-la-consigne)
     - [Type `over_switch` ou `over_valve`](#type-over_switch-ou-over_valve)
@@ -211,7 +212,7 @@ En conséquence toute la phase de paramètrage d'un VTherm a été profondemment
 </details>
 
 # Merci pour la bière [buymecoffee](https://www.buymeacoffee.com/jmcollin78)
-Un grand merci à @salabur, @pvince83, @bergoglio, @EPicLURcher, @ecolorado66, @Kriss1670, @maia, @f.maymil, @moutte69, @Jerome, @Gunnar M, @Greg.o, @John Burgess, @abyssmal, @capinfo26, @Helge, @MattG @Mexx62, @Someone, @Lajull, @giopeco, @fredericselier, @philpagan, @studiogriffanti, @Edwin, @Sebbou, @Gerard R. pour les bières. Ca fait très plaisir et ça m'encourage à continuer !
+Un grand merci à @salabur, @pvince83, @bergoglio, @EPicLURcher, @ecolorado66, @Kriss1670, @maia, @f.maymil, @moutte69, @Jerome, @Gunnar M, @Greg.o, @John Burgess, @abyssmal, @capinfo26, @Helge, @MattG @Mexx62, @Someone, @Lajull, @giopeco, @fredericselier, @philpagan, @studiogriffanti, @Edwin, @Sebbou, @Gerard R., @John Burgess, @Sylvoliv, @cdenfert, @stephane.l, @jms92100 pour les bières. Ca fait très plaisir et ça m'encourage à continuer !
 
 
 # Quand l'utiliser et ne pas l'utiliser
@@ -235,6 +236,7 @@ Certains thermostat de type TRV sont réputés incompatibles avec le Versatile T
 3. les thermostats de type Heatzy qui ne supportent pas les commandes de type set_temperature
 4. les thermostats de type Rointe ont tendance a se réveiller tout seul. Le reste fonctionne normalement.
 5. les TRV de type Aqara SRTS-A01 et MOES TV01-ZB qui n'ont pas le retour d'état `hvac_action` permettant de savoir si elle chauffe ou pas. Donc les retours d'état sont faussés, le reste à l'air fonctionnel.
+6. La clim Airwell avec l'intégration "Midea AC LAN". Si 2 commandes de VTherm sont trop rapprochées, la clim s'arrête d'elle même.
 
 # Pourquoi une nouvelle implémentation du thermostat ?
 
@@ -1200,9 +1202,9 @@ Une carte spéciale pour le Versatile Thermostat a été développée (sur la ba
 ## Encore mieux avec le composant Scheduler !
 
 Afin de profiter de toute la puissance du Versatile Thermostat, je vous invite à l'utiliser avec https://github.com/nielsfaber/scheduler-component
-En effet, le composant scheduler propose une gestion de la base climatique sur les modes prédéfinis. Cette fonctionnalité a un intérêt limité avec le thermostat générique mais elle devient très puissante avec le thermostat Awesome :
+En effet, le composant scheduler propose une gestion de la base climatique sur les modes prédéfinis. Cette fonctionnalité a un intérêt limité avec le thermostat générique mais elle devient très puissante avec le Versatile Thermostat :
 
-À partir d'ici, je suppose que vous avez installé Awesome Thermostat et Scheduler Component.
+À partir d'ici, je suppose que vous avez installé Versatile Thermostat et Scheduler Component.
 
 Dans Scheduler, ajoutez un planning :
 
@@ -1497,6 +1499,43 @@ Exemple :
 
 </details>
 
+<details>
+<summary>Utilisation d'un radiateur avec un module Nodon</summary>
+
+## Utilisation d'un radiateur avec un fil pilote
+Comme pour le Heatzy ci-dessus vous pouvez utiliser un switch virtuel qui va changer le preset de votre radiateur en fonction de l'état d'allumage du VTherm.
+Exemple :
+```
+- platform: template
+  switches:
+    chauffage_chb_parents:
+      unique_id: chauffage_chb_parents
+      friendly_name: Chauffage chambre parents
+      value_template: "{{ is_state('select.fp_chb_parents_pilot_wire_mode', 'comfort') }}"
+      icon_template: >-
+        {% if is_state('select.fp_chb_parents_pilot_wire_mode', 'comfort') %}
+          mdi:radiator
+        {% elif is_state('select.fp_chb_parents_pilot_wire_mode', 'frost_protection') %}
+          mdi:snowflake
+        {% else %}
+          mdi:radiator-disabled
+        {% endif %}
+      turn_on:
+        service: select.select_option
+        target:
+          entity_id: select.fp_chb_parents_pilot_wire_mode
+        data:
+          option: comfort
+      turn_off:
+        service: select.select_option
+        target:
+          entity_id: select.fp_chb_parents_pilot_wire_mode
+        data:
+          option: eco
+```
+
+</details>
+
 <details>
 <summary>Seul le premier radiateur chauffe</summary>
 

README.md

@@ -76,6 +76,7 @@
 - [Troubleshooting](#troubleshooting)
   - [Using a Heatzy](#using-a-heatzy)
   - [Using a Heatsink with a Pilot Wire](#using-a-heatsink-with-a-pilot-wire)
+  - [Using a heater with a Nodon module](#using-a-heater-with-a-nodon-module)
   - [Only the first radiator heats](#only-the-first-radiator-heats)
   - [The radiator heats up even though the setpoint temperature is exceeded or does not heat up even though the room temperature is well below the setpoint](#the-radiator-heats-up-even-though-the-setpoint-temperature-is-exceeded-or-does-not-heat-up-even-though-the-room-temperature-is-well-below-the-setpoint)
     - [Type `over_switch` or `over_valve`](#type-over_switch-or-over_valve)
@@ -212,7 +213,7 @@ Consequently, the entire configuration phase of a VTherm has been profoundly mod
 </details>
 
 # Thanks for the beer [buymecoffee](https://www.buymeacoffee.com/jmcollin78)
-Many thanks to @salabur, @pvince83, @bergoglio, @EPicLURcher, @ecolorado66, @Kriss1670, @maia, @f.maymil, @moutte69, @Jerome, @Gunnar M, @Greg.o, @John Burgess, @abyssmal, @capinfo26, @Helge, @MattG, @MattG, @Mexx62, @Someone, @Lajull, @giopeco, @fredericselier, @philpagan, @studiogriffanti, @Edwin, @Sebbou, @Gerard R. for the beers. It's very nice and encourages me to continue!
+Many thanks to @salabur, @pvince83, @bergoglio, @EPicLURcher, @ecolorado66, @Kriss1670, @maia, @f.maymil, @moutte69, @Jerome, @Gunnar M, @Greg.o, @John Burgess, @abyssmal, @capinfo26, @Helge, @MattG, @MattG, @Mexx62, @Someone, @Lajull, @giopeco, @fredericselier, @philpagan, @studiogriffanti, @Edwin, @Sebbou, @Gerard R., @John Burgess, @Sylvoliv, @cdenfert, @stephane.l, @jms92100 for the beers. It's very nice and encourages me to continue!
 
 # When to use / not use
 This thermostat can control 3 types of equipment:
@@ -236,6 +237,7 @@ Some TRV type thermostats are known to be incompatible with the Versatile Thermo
 3. Thermostat of type Heatzy which doesn't supports the set_temperature command.
 4. Thermostats of type Rointe tends to awake alone even if VTherm turns it off. Others functions works fine.
 5. TRV of type Aqara SRTS-A01 and MOES TV01-ZB which doesn't have the return state `hvac_action` allowing to know if it is heating or not. So return states are not available. Others features, seems to work normally.
+6. The Airwell with the "Midea AC LAN" integration. If two orders are too close, the device shut off.
 
 # Why another thermostat implementation ?
 
@@ -1488,6 +1490,43 @@ Example :
 ```
 </details>
 
+<details>
+<summary>Using a heater with a Nodon</summary>
+
+## Using a heater with a Nodon module
+As for the heatzy module above you can use a virtual switch which will change the preset of your heater depending of the state of the VTherm.
+Example :
+```
+- platform: template
+  switches:
+    chauffage_chb_parents:
+      unique_id: chauffage_chb_parents
+      friendly_name: Chauffage chambre parents
+      value_template: "{{ is_state('select.fp_chb_parents_pilot_wire_mode', 'comfort') }}"
+      icon_template: >-
+        {% if is_state('select.fp_chb_parents_pilot_wire_mode', 'comfort') %}
+          mdi:radiator
+        {% elif is_state('select.fp_chb_parents_pilot_wire_mode', 'frost_protection') %}
+          mdi:snowflake
+        {% else %}
+          mdi:radiator-disabled
+        {% endif %}
+      turn_on:
+        service: select.select_option
+        target:
+          entity_id: select.fp_chb_parents_pilot_wire_mode
+        data:
+          option: comfort
+      turn_off:
+        service: select.select_option
+        target:
+          entity_id: select.fp_chb_parents_pilot_wire_mode
+        data:
+          option: eco
+```
+
+</details>
+
 <details>
 <summary>Only the first radiator heats</summary>
 

custom_components/versatile_thermostat/__init__.py

@@ -13,6 +13,7 @@ from homeassistant.const import SERVICE_RELOAD, EVENT_HOMEASSISTANT_STARTED
 
 from homeassistant.config_entries import ConfigEntry, ConfigType
 from homeassistant.core import HomeAssistant, CoreState, callback
+from homeassistant.helpers.service import async_register_admin_service
 
 from .base_thermostat import BaseThermostat
 
@@ -107,13 +108,16 @@ async def async_setup(
             "VersatileThermostat - HA is started, initialize all links between VTherm entities"
         )
         await api.init_vtherm_links()
+        await api.notify_central_mode_change()
+        await api.reload_central_boiler_entities_list()
 
     if hass.state == CoreState.running:
         await _async_startup_internal()
     else:
         hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STARTED, _async_startup_internal)
 
-    hass.helpers.service.async_register_admin_service(
+    async_register_admin_service(
+        hass,
         DOMAIN,
         SERVICE_RELOAD,
         _handle_reload,
@@ -156,8 +160,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
-    await api.reload_central_boiler_entities_list()
-    await api.init_vtherm_links()
+    if hass.state == CoreState.running:
+        await api.reload_central_boiler_entities_list()
+        await api.init_vtherm_links()
 
     return True
 

custom_components/versatile_thermostat/base_thermostat.py

@@ -13,7 +13,6 @@ from homeassistant.util import dt as dt_util
 from homeassistant.core import (
     HomeAssistant,
     callback,
-    CoreState,
     Event,
     State,
 )
@@ -22,7 +21,6 @@ from homeassistant.components.climate import ClimateEntity
 from homeassistant.helpers.restore_state import RestoreEntity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.helpers.device_registry import DeviceInfo, DeviceEntryType
-from homeassistant.helpers.typing import EventType as HASSEventType
 
 from homeassistant.helpers.event import (
     async_track_state_change_event,
@@ -58,7 +56,6 @@ from homeassistant.const import (
     STATE_UNKNOWN,
     STATE_OFF,
     STATE_ON,
-    EVENT_HOMEASSISTANT_START,
     STATE_HOME,
     STATE_NOT_HOME,
 )
@@ -68,6 +65,7 @@ from .const import (
     DEVICE_MANUFACTURER,
     CONF_POWER_SENSOR,
     CONF_TEMP_SENSOR,
+    CONF_LAST_SEEN_TEMP_SENSOR,
     CONF_EXTERNAL_TEMP_SENSOR,
     CONF_MAX_POWER_SENSOR,
     CONF_WINDOW_SENSOR,
@@ -242,6 +240,9 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
         self._motion_call_cancel = None
         self._cur_temp = None
         self._ac_mode = None
+        self._temp_sensor_entity_id = None
+        self._last_seen_temp_sensor_entity_id = None
+        self._ext_temp_sensor_entity_id = None
         self._last_ext_temperature_measure = None
         self._last_temperature_measure = None
         self._cur_ext_temp = None
@@ -296,7 +297,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
         self._presets: dict[str, Any] = {}  # presets
         self._presets_away: dict[str, Any] = {}  # presets_away
 
-        self._attr_preset_modes: list[str] | None
+        self._attr_preset_modes: list[str] = []
 
         self._use_central_config_temperature = False
 
@@ -393,6 +394,9 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
 
         self._proportional_function = entry_infos.get(CONF_PROP_FUNCTION)
         self._temp_sensor_entity_id = entry_infos.get(CONF_TEMP_SENSOR)
+        self._last_seen_temp_sensor_entity_id = entry_infos.get(
+            CONF_LAST_SEEN_TEMP_SENSOR
+        )
         self._ext_temp_sensor_entity_id = entry_infos.get(CONF_EXTERNAL_TEMP_SENSOR)
         self._power_sensor_entity_id = entry_infos.get(CONF_POWER_SENSOR)
         self._max_power_sensor_entity_id = entry_infos.get(CONF_MAX_POWER_SENSOR)
@@ -525,7 +529,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
         self._overpowering_state = None
         self._presence_state = None
 
-        self._total_energy = 0
+        self._total_energy = None
 
         # Read the parameter from configuration.yaml if it exists
         short_ema_params = DEFAULT_SHORT_EMA_PARAMS
@@ -574,6 +578,15 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
             )
         )
 
+        if self._last_seen_temp_sensor_entity_id:
+            self.async_on_remove(
+                async_track_state_change_event(
+                    self.hass,
+                    [self._last_seen_temp_sensor_entity_id],
+                    self._async_last_seen_temperature_changed,
+                )
+            )
+
         if self._ext_temp_sensor_entity_id:
             self.async_on_remove(
                 async_track_state_change_event(
@@ -629,7 +642,8 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
 
         self.async_on_remove(self.remove_thermostat)
 
-        await self.async_startup()
+        # issue 428. Link to others entities will start at link
+        # await self.async_startup()
 
     def remove_thermostat(self):
         """Called when the thermostat will be removed"""
@@ -637,155 +651,157 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
         for under in self._underlyings:
             under.remove_entity()
 
-    async def async_startup(self):
+    async def async_startup(self, central_configuration):
         """Triggered on startup, used to get old state and set internal states accordingly"""
         _LOGGER.debug("%s - Calling async_startup", self)
 
-        @callback
-        async def _async_startup_internal(*_):
-            _LOGGER.debug("%s - Calling async_startup_internal", self)
-            need_write_state = False
+        _LOGGER.debug("%s - Calling async_startup_internal", self)
+        need_write_state = False
 
-            # Initialize all UnderlyingEntities
-            self.init_underlyings()
+        await self.get_my_previous_state()
 
-            temperature_state = self.hass.states.get(self._temp_sensor_entity_id)
-            if temperature_state and temperature_state.state not in (
+        await self.init_presets(central_configuration)
+
+        # Initialize all UnderlyingEntities
+        self.init_underlyings()
+
+        temperature_state = self.hass.states.get(self._temp_sensor_entity_id)
+        if temperature_state and temperature_state.state not in (
+            STATE_UNAVAILABLE,
+            STATE_UNKNOWN,
+        ):
+            _LOGGER.debug(
+                "%s - temperature sensor have been retrieved: %.1f",
+                self,
+                float(temperature_state.state),
+            )
+            await self._async_update_temp(temperature_state)
+            need_write_state = True
+
+        if self._ext_temp_sensor_entity_id:
+            ext_temperature_state = self.hass.states.get(
+                self._ext_temp_sensor_entity_id
+            )
+            if ext_temperature_state and ext_temperature_state.state not in (
                 STATE_UNAVAILABLE,
                 STATE_UNKNOWN,
             ):
                 _LOGGER.debug(
-                    "%s - temperature sensor have been retrieved: %.1f",
+                    "%s - external temperature sensor have been retrieved: %.1f",
                     self,
-                    float(temperature_state.state),
+                    float(ext_temperature_state.state),
                 )
-                await self._async_update_temp(temperature_state)
-                need_write_state = True
-
-            if self._ext_temp_sensor_entity_id:
-                ext_temperature_state = self.hass.states.get(
-                    self._ext_temp_sensor_entity_id
-                )
-                if ext_temperature_state and ext_temperature_state.state not in (
-                    STATE_UNAVAILABLE,
-                    STATE_UNKNOWN,
-                ):
-                    _LOGGER.debug(
-                        "%s - external temperature sensor have been retrieved: %.1f",
-                        self,
-                        float(ext_temperature_state.state),
-                    )
-                    await self._async_update_ext_temp(ext_temperature_state)
-                else:
-                    _LOGGER.debug(
-                        "%s - external temperature sensor have NOT been retrieved cause unknown or unavailable",
-                        self,
-                    )
+                await self._async_update_ext_temp(ext_temperature_state)
             else:
                 _LOGGER.debug(
-                    "%s - external temperature sensor have NOT been retrieved cause no external sensor",
+                    "%s - external temperature sensor have NOT been retrieved cause unknown or unavailable",
                     self,
                 )
-
-            if self._pmax_on:
-                # try to acquire current power and power max
-                current_power_state = self.hass.states.get(self._power_sensor_entity_id)
-                if current_power_state and current_power_state.state not in (
-                    STATE_UNAVAILABLE,
-                    STATE_UNKNOWN,
-                ):
-                    self._current_power = float(current_power_state.state)
-                    _LOGGER.debug(
-                        "%s - Current power have been retrieved: %.3f",
-                        self,
-                        self._current_power,
-                    )
-                    need_write_state = True
-
-                # Try to acquire power max
-                current_power_max_state = self.hass.states.get(
-                    self._max_power_sensor_entity_id
-                )
-                if current_power_max_state and current_power_max_state.state not in (
-                    STATE_UNAVAILABLE,
-                    STATE_UNKNOWN,
-                ):
-                    self._current_power_max = float(current_power_max_state.state)
-                    _LOGGER.debug(
-                        "%s - Current power max have been retrieved: %.3f",
-                        self,
-                        self._current_power_max,
-                    )
-                    need_write_state = True
-
-                # try to acquire window entity state
-                if self._window_sensor_entity_id:
-                    window_state = self.hass.states.get(self._window_sensor_entity_id)
-                    if window_state and window_state.state not in (
-                        STATE_UNAVAILABLE,
-                        STATE_UNKNOWN,
-                    ):
-                        self._window_state = window_state.state == STATE_ON
-                        _LOGGER.debug(
-                            "%s - Window state have been retrieved: %s",
-                            self,
-                            self._window_state,
-                        )
-                        need_write_state = True
-
-                # try to acquire motion entity state
-                if self._motion_sensor_entity_id:
-                    motion_state = self.hass.states.get(self._motion_sensor_entity_id)
-                    if motion_state and motion_state.state not in (
-                        STATE_UNAVAILABLE,
-                        STATE_UNKNOWN,
-                    ):
-                        self._motion_state = motion_state.state
-                        _LOGGER.debug(
-                            "%s - Motion state have been retrieved: %s",
-                            self,
-                            self._motion_state,
-                        )
-                        # recalculate the right target_temp in activity mode
-                        await self._async_update_motion_temp()
-                        need_write_state = True
-
-            if self._presence_on:
-                # try to acquire presence entity state
-                presence_state = self.hass.states.get(self._presence_sensor_entity_id)
-                if presence_state and presence_state.state not in (
-                    STATE_UNAVAILABLE,
-                    STATE_UNKNOWN,
-                ):
-                    await self._async_update_presence(presence_state.state)
-                    _LOGGER.debug(
-                        "%s - Presence have been retrieved: %s",
-                        self,
-                        presence_state.state,
-                    )
-                    need_write_state = True
-
-            if need_write_state:
-                self.async_write_ha_state()
-                if self._prop_algorithm:
-                    self._prop_algorithm.calculate(
-                        self._target_temp,
-                        self._cur_temp,
-                        self._cur_ext_temp,
-                        self._hvac_mode or HVACMode.OFF,
-                    )
-
-            self.reset_last_change_time()
-
-        await self.get_my_previous_state()
-
-        if self.hass.state == CoreState.running:
-            await _async_startup_internal()
         else:
-            self.hass.bus.async_listen_once(
-                EVENT_HOMEASSISTANT_START, _async_startup_internal
+            _LOGGER.debug(
+                "%s - external temperature sensor have NOT been retrieved cause no external sensor",
+                self,
             )
 
+        if self._pmax_on:
+            # try to acquire current power and power max
+            current_power_state = self.hass.states.get(self._power_sensor_entity_id)
+            if current_power_state and current_power_state.state not in (
+                STATE_UNAVAILABLE,
+                STATE_UNKNOWN,
+            ):
+                self._current_power = float(current_power_state.state)
+                _LOGGER.debug(
+                    "%s - Current power have been retrieved: %.3f",
+                    self,
+                    self._current_power,
+                )
+                need_write_state = True
+
+            # Try to acquire power max
+            current_power_max_state = self.hass.states.get(
+                self._max_power_sensor_entity_id
+            )
+            if current_power_max_state and current_power_max_state.state not in (
+                STATE_UNAVAILABLE,
+                STATE_UNKNOWN,
+            ):
+                self._current_power_max = float(current_power_max_state.state)
+                _LOGGER.debug(
+                    "%s - Current power max have been retrieved: %.3f",
+                    self,
+                    self._current_power_max,
+                )
+                need_write_state = True
+
+        # try to acquire window entity state
+        if self._window_sensor_entity_id:
+            window_state = self.hass.states.get(self._window_sensor_entity_id)
+            if window_state and window_state.state not in (
+                STATE_UNAVAILABLE,
+                STATE_UNKNOWN,
+            ):
+                self._window_state = window_state.state == STATE_ON
+                _LOGGER.debug(
+                    "%s - Window state have been retrieved: %s",
+                    self,
+                    self._window_state,
+                )
+                need_write_state = True
+
+        # try to acquire motion entity state
+        if self._motion_sensor_entity_id:
+            motion_state = self.hass.states.get(self._motion_sensor_entity_id)
+            if motion_state and motion_state.state not in (
+                STATE_UNAVAILABLE,
+                STATE_UNKNOWN,
+            ):
+                self._motion_state = motion_state.state
+                _LOGGER.debug(
+                    "%s - Motion state have been retrieved: %s",
+                    self,
+                    self._motion_state,
+                )
+                # recalculate the right target_temp in activity mode
+                await self._async_update_motion_temp()
+                need_write_state = True
+
+        if self._presence_on:
+            # try to acquire presence entity state
+            presence_state = self.hass.states.get(self._presence_sensor_entity_id)
+            if presence_state and presence_state.state not in (
+                STATE_UNAVAILABLE,
+                STATE_UNKNOWN,
+            ):
+                await self._async_update_presence(presence_state.state)
+                _LOGGER.debug(
+                    "%s - Presence have been retrieved: %s",
+                    self,
+                    presence_state.state,
+                )
+                need_write_state = True
+
+        if need_write_state:
+            self.async_write_ha_state()
+            if self._prop_algorithm:
+                self._prop_algorithm.calculate(
+                    self._target_temp,
+                    self._cur_temp,
+                    self._cur_ext_temp,
+                    self._hvac_mode or HVACMode.OFF,
+                )
+
+        self.hass.create_task(self._check_initial_state())
+
+        self.reset_last_change_time()
+
+        # if self.hass.state == CoreState.running:
+        #     await _async_startup_internal()
+        # else:
+        #     self.hass.bus.async_listen_once(
+        #         EVENT_HOMEASSISTANT_START, _async_startup_internal
+        #     )
+
     def init_underlyings(self):
         """Initialize all underlyings. Should be overriden if necessary"""
 
@@ -825,23 +841,23 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
             # Never restore a Power or Security preset
             if old_preset_mode is not None and old_preset_mode not in HIDDEN_PRESETS:
                 # old_preset_mode in self._attr_preset_modes
-                self._attr_preset_mode = old_state.attributes.get(ATTR_PRESET_MODE)
+                self._attr_preset_mode = old_preset_mode
                 self.save_preset_mode()
             else:
                 self._attr_preset_mode = PRESET_NONE
 
-            if not self._hvac_mode and old_state.state in [
+            if old_state.state in [
                 HVACMode.OFF,
                 HVACMode.HEAT,
                 HVACMode.COOL,
             ]:
                 self._hvac_mode = old_state.state
             else:
-                self._hvac_mode = HVACMode.OFF
+                if not self._hvac_mode:
+                    self._hvac_mode = HVACMode.OFF
 
             old_total_energy = old_state.attributes.get(ATTR_TOTAL_ENERGY)
-            if old_total_energy:
-                self._total_energy = old_total_energy
+            self._total_energy = old_total_energy if old_total_energy else 0
 
             self.restore_specific_previous_state(old_state)
         else:
@@ -854,6 +870,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
             _LOGGER.warning(
                 "No previously saved temperature, setting to %s", self._target_temp
             )
+            self._total_energy = 0
 
         self._saved_target_temp = self._target_temp
 
@@ -1043,7 +1060,10 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
     @property
     def total_energy(self) -> float | None:
         """Returns the total energy calculated for this thermostast"""
-        return round(self._total_energy, 2)
+        if self._total_energy is not None:
+            return round(self._total_energy, 2)
+        else:
+            return None
 
     @property
     def device_power(self) -> float | None:
@@ -1215,7 +1235,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
             )
 
         # If AC is on maybe we have to change the temperature in force mode, but not in frost mode (there is no Frost protection possible in AC mode)
-        if self._hvac_mode == HVACMode.COOL and self.preset_mode != PRESET_NONE:
+        if self._hvac_mode in [HVACMode.COOL, HVACMode.HEAT, HVACMode.HEAT_COOL] and self.preset_mode != PRESET_NONE:
             if self.preset_mode != PRESET_FROST_PROTECTION:
                 await self._async_set_preset_mode_internal(self.preset_mode, True)
             else:
@@ -1238,6 +1258,31 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
         self, preset_mode: str, overwrite_saved_preset=True
     ):
         """Set new preset mode."""
+
+        # Wer accept a new preset when:
+        # 1. last_central_mode is not set,
+        # 2. or last_central_mode is AUTO,
+        # 3. or last_central_mode is CENTRAL_MODE_FROST_PROTECTION and preset_mode is PRESET_FROST_PROTECTION (to be abel to re-set the preset_mode)
+        accept = self._last_central_mode in [
+            None,
+            CENTRAL_MODE_AUTO,
+            CENTRAL_MODE_COOL_ONLY,
+            CENTRAL_MODE_HEAT_ONLY,
+            CENTRAL_MODE_STOPPED,
+        ] or (
+            self._last_central_mode == CENTRAL_MODE_FROST_PROTECTION
+            and preset_mode == PRESET_FROST_PROTECTION
+        )
+        if not accept:
+            _LOGGER.info(
+                "%s - Impossible to change the preset to %s because central mode is %s",
+                self,
+                preset_mode,
+                self._last_central_mode,
+            )
+
+            return
+
         await self._async_set_preset_mode_internal(
             preset_mode, force=False, overwrite_saved_preset=overwrite_saved_preset
         )
@@ -1329,11 +1374,19 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
         if preset_mode == PRESET_POWER:
             return self._power_temp
         if preset_mode == PRESET_ACTIVITY:
-            motion_preset = (
-                self._motion_preset
-                if self._motion_state == STATE_ON
-                else self._no_motion_preset
-            )
+            if self._ac_mode and self._hvac_mode == HVACMode.COOL:
+                motion_preset = (
+                    self._motion_preset + PRESET_AC_SUFFIX
+                    if self._motion_state == STATE_ON
+                    else self._no_motion_preset + PRESET_AC_SUFFIX
+                )
+            else:
+                motion_preset = (
+                    self._motion_preset
+                    if self._motion_state == STATE_ON
+                    else self._no_motion_preset
+                )
+
             if motion_preset in self._presets:
                 return self._presets[motion_preset]
             else:
@@ -1441,6 +1494,44 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
         await self.async_control_heating(force=False)
         return dearm_window_auto
 
+    @callback
+    async def _async_last_seen_temperature_changed(self, event: Event):
+        """Handle last seen temperature sensor changes."""
+        new_state: State = event.data.get("new_state")
+        _LOGGER.debug(
+            "%s - Last seen temperature changed. Event.new_state is %s",
+            self,
+            new_state,
+        )
+        if new_state is None or new_state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
+            return
+
+        # try to extract the datetime (from state)
+        try:
+            # Convertir la chaîne au format ISO 8601 en objet datetime
+            self._last_temperature_measure = self.get_last_updated_date_or_now(
+                new_state
+            )
+            self.reset_last_change_time()
+            _LOGGER.debug(
+                "%s - new last_temperature_measure is now: %s",
+                self,
+                self._last_temperature_measure,
+            )
+
+            # try to restart if we were in safety mode
+            if self._security_state:
+                await self.check_safety()
+
+        except ValueError as err:
+            # La conversion a échoué, la chaîne n'est pas au format ISO 8601
+            _LOGGER.warning(
+                "%s - impossible to convert last seen datetime %s. Error is: %s",
+                self,
+                new_state.state,
+                err,
+            )
+
     async def _async_ext_temperature_changed(self, event: Event):
         """Handle external temperature opf the sensor changes."""
         new_state: State = event.data.get("new_state")
@@ -1560,6 +1651,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
                 _LOGGER.debug("%s - Motion delay condition is satisfied", self)
                 self._motion_state = new_state.state
                 if self._attr_preset_mode == PRESET_ACTIVITY:
+
                     new_preset = (
                         self._motion_preset
                         if self._motion_state == STATE_ON
@@ -1572,6 +1664,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
                     )
                     # We do not change the preset which is kept to ACTIVITY but only the target_temperature
                     # We take the presence into account
+
                     await self._async_internal_set_temperature(
                         self.find_preset_temp(new_preset)
                     )
@@ -1694,7 +1787,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
             _LOGGER.error("Unable to update external temperature from sensor: %s", ex)
 
     @callback
-    async def _async_power_changed(self, event: HASSEventType[EventStateChangedData]):
+    async def _async_power_changed(self, event: Event[EventStateChangedData]):
         """Handle power changes."""
         _LOGGER.debug("Thermostat %s - Receive new Power event", self.name)
         _LOGGER.debug(event)
@@ -1720,9 +1813,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
             _LOGGER.error("Unable to update current_power from sensor: %s", ex)
 
     @callback
-    async def _async_max_power_changed(
-        self, event: HASSEventType[EventStateChangedData]
-    ):
+    async def _async_max_power_changed(self, event: Event[EventStateChangedData]):
         """Handle power max changes."""
         _LOGGER.debug("Thermostat %s - Receive new Power Max event", self.name)
         _LOGGER.debug(event)
@@ -1747,9 +1838,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
             _LOGGER.error("Unable to update current_power from sensor: %s", ex)
 
     @callback
-    async def _async_presence_changed(
-        self, event: HASSEventType[EventStateChangedData]
-    ):
+    async def _async_presence_changed(self, event: Event[EventStateChangedData]):
         """Handle presence changes."""
         new_state = event.data.get("new_state")
         _LOGGER.info(
@@ -1810,16 +1899,23 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
         ):
             return
 
+        new_preset = (
+                        self._motion_preset
+                        if self._motion_state == STATE_ON
+                        else self._no_motion_preset
+                    )
+        _LOGGER.info(
+                    "%s - Motion condition have changes. New preset temp will be %s",
+                        self,
+                        new_preset,
+                    )
+        # We do not change the preset which is kept to ACTIVITY but only the target_temperature
+        # We take the presence into account
+
         await self._async_internal_set_temperature(
-            self._presets.get(
-                (
-                    self._motion_preset
-                    if self._motion_state == STATE_ON
-                    else self._no_motion_preset
-                ),
-                None,
-            )
+            self.find_preset_temp(new_preset)
         )
+
         _LOGGER.debug(
             "%s - regarding motion, target_temp have been set to %.2f",
             self,
@@ -2085,6 +2181,8 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
             new_central_mode,
         )
 
+        first_init = self._last_central_mode is None
+
         self._last_central_mode = new_central_mode
 
         def save_all():
@@ -2093,7 +2191,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
             self.save_hvac_mode()
 
         if new_central_mode == CENTRAL_MODE_AUTO:
-            if self.window_state is not STATE_ON:
+            if self.window_state is not STATE_ON and not first_init:
                 await self.restore_hvac_mode()
                 await self.restore_preset_mode()
 
@@ -2242,12 +2340,12 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
             self._security_state = True
             self.save_hvac_mode()
             self.save_preset_mode()
+            if self._prop_algorithm:
+                self._prop_algorithm.set_security(self._security_default_on_percent)
             await self._async_set_preset_mode_internal(PRESET_SECURITY)
             # Turn off the underlying climate or heater if security default on_percent is 0
             if self.is_over_climate or self._security_default_on_percent <= 0.0:
                 await self.async_set_hvac_mode(HVACMode.OFF, False)
-            if self._prop_algorithm:
-                self._prop_algorithm.set_security(self._security_default_on_percent)
 
             self.send_event(
                 EventType.SECURITY_EVENT,
@@ -2274,12 +2372,12 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
                 self._saved_preset_mode,
             )
             self._security_state = False
+            if self._prop_algorithm:
+                self._prop_algorithm.unset_security()
             # Restore hvac_mode if previously saved
             if self.is_over_climate or self._security_default_on_percent <= 0.0:
                 await self.restore_hvac_mode(False)
             await self.restore_preset_mode()
-            if self._prop_algorithm:
-                self._prop_algorithm.unset_security()
             self.send_event(
                 EventType.SECURITY_EVENT,
                 {
@@ -2509,7 +2607,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
         """update the entity if the config entry have been updated
         Note: this don't work either
         """
-        _LOGGER.info("%s - The config entry have been updated")
+        _LOGGER.info("%s - The config entry have been updated", self)
 
     async def service_set_presence(self, presence: str):
         """Called by a service call:
@@ -2707,8 +2805,6 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
         if self._attr_preset_mode:
             await self._async_set_preset_mode_internal(self._attr_preset_mode, True)
 
-        self.hass.create_task(self._check_initial_state())
-
     async def async_turn_off(self) -> None:
         await self.async_set_hvac_mode(HVACMode.OFF)
 

custom_components/versatile_thermostat/climate.py

@@ -72,6 +72,13 @@ async def async_setup_entry(
         entity = ThermostatOverClimate(hass, unique_id, name, entry.data)
     elif vt_type == CONF_THERMOSTAT_VALVE:
         entity = ThermostatOverValve(hass, unique_id, name, entry.data)
+    else:
+        _LOGGER.error(
+            "Cannot create Versatile Thermostat name=%s of type %s which is unknown",
+            name,
+            vt_type,
+        )
+        return
 
     async_add_entities([entity], True)
 

custom_components/versatile_thermostat/config_flow.py

@@ -99,30 +99,31 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
 
     def _init_feature_flags(self, _):
         """Fix features selection depending to infos"""
-        is_empty: bool = False  # TODO remove this not bool(infos)
         is_central_config = (
             self._infos.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_CENTRAL_CONFIG
         )
 
         self._infos[CONF_USE_WINDOW_FEATURE] = (
-            is_empty
+            self._infos.get(CONF_USE_WINDOW_CENTRAL_CONFIG)
             or self._infos.get(CONF_WINDOW_SENSOR) is not None
             or self._infos.get(CONF_WINDOW_AUTO_OPEN_THRESHOLD) is not None
         )
-        self._infos[CONF_USE_MOTION_FEATURE] = (
-            is_empty
-            or self._infos.get(CONF_MOTION_SENSOR) is not None
-            or is_central_config
-        )
-        self._infos[CONF_USE_POWER_FEATURE] = is_empty or (
+        self._infos[CONF_USE_MOTION_FEATURE] = self._infos.get(
+            CONF_USE_MOTION_FEATURE
+        ) 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
+        ) 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] = (
-            is_empty or self._infos.get(CONF_PRESENCE_SENSOR) is not None
+            self._infos.get(CONF_USE_PRESENCE_CENTRAL_CONFIG)
+            or self._infos.get(CONF_PRESENCE_SENSOR) is not None
         )
 
-        self._infos[CONF_USE_CENTRAL_BOILER_FEATURE] = is_empty or (
+        self._infos[CONF_USE_CENTRAL_BOILER_FEATURE] = (
             self._infos.get(CONF_CENTRAL_BOILER_ACTIVATION_SRV) is not None
             and self._infos.get(CONF_CENTRAL_BOILER_DEACTIVATION_SRV) is not None
         )

custom_components/versatile_thermostat/config_schema.py

@@ -16,6 +16,10 @@ from homeassistant.components.input_number import (
     DOMAIN as INPUT_NUMBER_DOMAIN,
 )
 
+from homeassistant.components.input_datetime import (
+    DOMAIN as INPUT_DATETIME_DOMAIN,
+)
+
 from homeassistant.components.person import DOMAIN as PERSON_DOMAIN
 from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
 
@@ -42,6 +46,11 @@ STEP_MAIN_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
         vol.Required(CONF_TEMP_SENSOR): selector.EntitySelector(
             selector.EntitySelectorConfig(domain=[SENSOR_DOMAIN, INPUT_NUMBER_DOMAIN]),
         ),
+        vol.Optional(CONF_LAST_SEEN_TEMP_SENSOR): selector.EntitySelector(
+            selector.EntitySelectorConfig(
+                domain=[SENSOR_DOMAIN, INPUT_DATETIME_DOMAIN]
+            ),
+        ),
         vol.Required(CONF_CYCLE_MIN, default=5): cv.positive_int,
         vol.Optional(CONF_DEVICE_POWER, default="1"): vol.Coerce(float),
         vol.Required(CONF_USE_MAIN_CENTRAL_CONFIG, default=True): cv.boolean,

custom_components/versatile_thermostat/const.py

@@ -59,6 +59,7 @@ CONF_HEATER_3 = "heater_entity3_id"
 CONF_HEATER_4 = "heater_entity4_id"
 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"
 CONF_EXTERNAL_TEMP_SENSOR = "external_temperature_sensor_entity_id"
 CONF_POWER_SENSOR = "power_sensor_entity_id"
 CONF_MAX_POWER_SENSOR = "max_power_sensor_entity_id"

custom_components/versatile_thermostat/keep_alive.py

@@ -10,6 +10,7 @@ the keep_alive setting of Home Assistant's Generic Thermostat integration:
 import logging
 from collections.abc import Awaitable, Callable
 from datetime import timedelta, datetime
+from time import monotonic
 
 from homeassistant.core import HomeAssistant, CALLBACK_TYPE
 from homeassistant.helpers.event import async_track_time_interval
@@ -18,6 +19,79 @@ from homeassistant.helpers.event import async_track_time_interval
 _LOGGER = logging.getLogger(__name__)
 
 
+class BackoffTimer:
+    """Exponential backoff timer with a non-blocking polling-style implementation.
+
+    Usage example:
+        timer = BackoffTimer(multiplier=1.5, upper_limit_sec=600)
+        while some_condition:
+            if timer.is_ready():
+                do_something()
+    """
+
+    def __init__(
+        self,
+        *,
+        multiplier=2.0,
+        lower_limit_sec=30,
+        upper_limit_sec=86400,
+        initially_ready=True,
+    ):
+        """Initialize a BackoffTimer instance.
+
+        Args:
+            multiplier (int, optional): Period multiplier applied when is_ready() is True.
+            lower_limit_sec (int, optional): Initial backoff period in seconds.
+            upper_limit_sec (int, optional): Maximum backoff period in seconds.
+            initially_ready (bool, optional): Whether is_ready() should return True the
+            first time it is called, or after a call to reset().
+        """
+        self._multiplier = multiplier
+        self._lower_limit_sec = lower_limit_sec
+        self._upper_limit_sec = upper_limit_sec
+        self._initially_ready = initially_ready
+
+        self._timestamp = 0
+        self._period_sec = self._lower_limit_sec
+
+    @property
+    def in_progress(self) -> bool:
+        """Whether the backoff timer is in progress (True after a call to is_ready())."""
+        return bool(self._timestamp)
+
+    def reset(self):
+        """Reset a BackoffTimer instance."""
+        self._timestamp = 0
+        self._period_sec = self._lower_limit_sec
+
+    def is_ready(self) -> bool:
+        """Check whether an exponentially increasing period of time has passed.
+
+        Whenever is_ready() returns True, the timer period is multiplied so that
+        it takes longer until is_ready() returns True again.
+        Returns:
+            bool: True if enough time has passed since one of the following events,
+            in relation to an instance of this class:
+            - The last time when this method returned True, if it ever did.
+            - Or else, when this method was first called after a call to reset().
+            - Or else, when this method was first called.
+            False otherwise.
+        """
+        now = monotonic()
+        if self._timestamp == 0:
+            self._timestamp = now
+            return self._initially_ready
+        elif now - self._timestamp >= self._period_sec:
+            self._timestamp = now
+            self._period_sec = max(
+                self._lower_limit_sec,
+                min(self._upper_limit_sec, self._period_sec * self._multiplier),
+            )
+            return True
+
+        return False
+
+
 class IntervalCaller:
     """Repeatedly call a given async action function at a given regular interval.
 
@@ -28,6 +102,7 @@ class IntervalCaller:
         self._hass = hass
         self._interval_sec = interval_sec
         self._remove_handle: CALLBACK_TYPE | None = None
+        self.backoff_timer = BackoffTimer()
 
     @property
     def interval_sec(self) -> float:

custom_components/versatile_thermostat/manifest.json

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

custom_components/versatile_thermostat/number.py

@@ -11,13 +11,15 @@ from homeassistant.components.number import (
     NumberMode,
     NumberDeviceClass,
     DOMAIN as NUMBER_DOMAIN,
+    DEFAULT_MAX_VALUE,
+    DEFAULT_MIN_VALUE,
+    DEFAULT_STEP,
 )
 from homeassistant.components.climate import (
     PRESET_BOOST,
     PRESET_COMFORT,
     PRESET_ECO,
 )
-from homeassistant.components.sensor import UnitOfTemperature
 
 from homeassistant.helpers.device_registry import DeviceInfo, DeviceEntryType
 from homeassistant.config_entries import ConfigEntry
@@ -53,6 +55,7 @@ from .const import (
     CONF_USE_PRESENCE_FEATURE,
     CONF_USE_CENTRAL_BOILER_FEATURE,
     overrides,
+    CONF_USE_MAIN_CENTRAL_CONFIG,
 )
 
 PRESET_ICON_MAPPING = {
@@ -279,7 +282,7 @@ class CentralConfigTemperatureNumber(
         self.entity_id = f"{NUMBER_DOMAIN}.{slugify(name)}_preset_{preset_name}"
         self._attr_unique_id = f"central_configuration_preset_{preset_name}"
         self._attr_device_class = NumberDeviceClass.TEMPERATURE
-        self._attr_native_unit_of_measurement = UnitOfTemperature.CELSIUS
+        self._attr_native_unit_of_measurement = hass.config.units.temperature_unit
 
         self._attr_native_step = entry_infos.get(CONF_STEP_TEMPERATURE, 0.5)
         self._attr_native_min_value = entry_infos.get(CONF_TEMP_MIN)
@@ -341,7 +344,10 @@ class CentralConfigTemperatureNumber(
     async def async_set_native_value(self, value: float) -> None:
         """The value have change from the Number Entity in UI"""
         float_value = float(value)
-        old_value = float(self._attr_native_value)
+        old_value = (
+            None if self._attr_native_value is None else float(self._attr_native_value)
+        )
+
         if float_value == old_value:
             return
 
@@ -353,7 +359,7 @@ class CentralConfigTemperatureNumber(
         # We have to reload all VTherm for which uses the central configuration
         api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(self.hass)
         # Update the VTherms which have temperature in central config
-        self.hass.create_task(api.init_vtherm_links(only_use_central=True))
+        self.hass.create_task(api.init_vtherm_preset_with_central())
 
     def __str__(self):
         return f"VersatileThermostat-{self.name}"
@@ -364,7 +370,7 @@ class CentralConfigTemperatureNumber(
         # TODO Kelvin ? It seems not because all internal values are stored in
         # ° Celsius but only the render in front can be in °K depending on the
         # user configuration.
-        return UnitOfTemperature.CELSIUS
+        return self.hass.config.units.temperature_unit
 
 
 class TemperatureNumber(  # pylint: disable=abstract-method
@@ -393,11 +399,13 @@ class TemperatureNumber(  # pylint: disable=abstract-method
 
         self._attr_unique_id = f"{self._device_name}_preset_{preset_name}"
         self._attr_device_class = NumberDeviceClass.TEMPERATURE
-        self._attr_native_unit_of_measurement = UnitOfTemperature.CELSIUS
+        self._attr_native_unit_of_measurement = hass.config.units.temperature_unit
 
-        self._attr_native_step = entry_infos.get(CONF_STEP_TEMPERATURE, 0.5)
-        self._attr_native_min_value = entry_infos.get(CONF_TEMP_MIN)
-        self._attr_native_max_value = entry_infos.get(CONF_TEMP_MAX)
+        self._has_central_main_attributes = entry_infos.get(
+            CONF_USE_MAIN_CENTRAL_CONFIG, False
+        )
+
+        self.init_min_max_step(entry_infos)
 
         # Initialize the values if included into the entry_infos. This will do
         # the temperature migration.
@@ -459,7 +467,9 @@ class TemperatureNumber(  # pylint: disable=abstract-method
             return
 
         float_value = float(value)
-        old_value = float(self._attr_native_value)
+        old_value = (
+            None if self._attr_native_value is None else float(self._attr_native_value)
+        )
 
         if float_value == old_value:
             return
@@ -476,6 +486,10 @@ class TemperatureNumber(  # pylint: disable=abstract-method
             )
         )
 
+        # We set the min, max and step from central config if relevant because it is possible
+        # that central config was not loaded at startup
+        self.init_min_max_step()
+
     def __str__(self):
         return f"VersatileThermostat-{self.name}"
 
@@ -483,5 +497,28 @@ class TemperatureNumber(  # pylint: disable=abstract-method
     def native_unit_of_measurement(self) -> str | None:
         """The unit of measurement"""
         if not self.my_climate:
-            return UnitOfTemperature.CELSIUS
+            return self.hass.config.units.temperature_unit
         return self.my_climate.temperature_unit
+
+    def init_min_max_step(self, entry_infos=None):
+        """Initialize min, max and step value from config or from central config"""
+        if self._has_central_main_attributes:
+            vthermapi: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api()
+            central_config = vthermapi.find_central_configuration()
+            if central_config:
+                self._attr_native_step = central_config.data.get(CONF_STEP_TEMPERATURE)
+                self._attr_native_min_value = central_config.data.get(CONF_TEMP_MIN)
+                self._attr_native_max_value = central_config.data.get(CONF_TEMP_MAX)
+
+                return
+
+        if entry_infos:
+            self._attr_native_step = entry_infos.get(
+                CONF_STEP_TEMPERATURE, DEFAULT_STEP
+            )
+            self._attr_native_min_value = entry_infos.get(
+                CONF_TEMP_MIN, DEFAULT_MIN_VALUE
+            )
+            self._attr_native_max_value = entry_infos.get(
+                CONF_TEMP_MAX, DEFAULT_MAX_VALUE
+            )

custom_components/versatile_thermostat/prop_algorithm.py

@@ -1,4 +1,5 @@
 """ The TPI calculation module """
+# pylint: disable='line-too-long'
 import logging
 
 from homeassistant.components.climate import HVACMode
@@ -14,6 +15,11 @@ PROPORTIONAL_MIN_DURATION_SEC = 10
 FUNCTION_TYPE = [PROPORTIONAL_FUNCTION_ATAN, PROPORTIONAL_FUNCTION_LINEAR]
 
 
+def is_number(value):
+    """check if value is a number"""
+    return isinstance(value, (int, float))
+
+
 class PropAlgorithm:
     """This class aims to do all calculation of the Proportional alogorithm"""
 
@@ -24,16 +30,43 @@ class PropAlgorithm:
         tpi_coef_ext,
         cycle_min: int,
         minimal_activation_delay: int,
+        vtherm_entity_id: str = None,
     ) -> None:
         """Initialisation of the Proportional Algorithm"""
         _LOGGER.debug(
-            "Creation new PropAlgorithm function_type: %s, tpi_coef_int: %s, tpi_coef_ext: %s, cycle_min:%d, minimal_activation_delay:%d",  # pylint: disable=line-too-long
+            "%s - Creation new PropAlgorithm function_type: %s, tpi_coef_int: %s, tpi_coef_ext: %s, cycle_min:%d, minimal_activation_delay:%d",  # pylint: disable=line-too-long
+            vtherm_entity_id,
             function_type,
             tpi_coef_int,
             tpi_coef_ext,
             cycle_min,
             minimal_activation_delay,
         )
+
+        # Issue 506 - check parameters
+        if (
+            vtherm_entity_id is None
+            or not is_number(tpi_coef_int)
+            or not is_number(tpi_coef_ext)
+            or not is_number(cycle_min)
+            or not is_number(minimal_activation_delay)
+            or function_type != PROPORTIONAL_FUNCTION_TPI
+        ):
+            _LOGGER.error(
+                "%s - configuration is wrong. function_type=%s, entity_id is %s, tpi_coef_int is %s, tpi_coef_ext is %s, cycle_min is %s, minimal_activation_delay is %s",
+                vtherm_entity_id,
+                function_type,
+                vtherm_entity_id,
+                tpi_coef_int,
+                tpi_coef_ext,
+                cycle_min,
+                minimal_activation_delay,
+            )
+            raise TypeError(
+                "TPI parameters are not set correctly. VTherm will not work as expected. Please reconfigure it correctly. See previous log for values"
+            )
+
+        self._vtherm_entity_id = vtherm_entity_id
         self._function = function_type
         self._tpi_coef_int = tpi_coef_int
         self._tpi_coef_ext = tpi_coef_ext
@@ -57,16 +90,19 @@ class PropAlgorithm:
         if target_temp is None or current_temp is None:
             log = _LOGGER.debug if hvac_mode == HVACMode.OFF else _LOGGER.warning
             log(
-                "Proportional algorithm: calculation is not possible cause target_temp or current_temp is null. Heating/cooling will be disabled"  # pylint: disable=line-too-long
+                "%s - Proportional algorithm: calculation is not possible cause target_temp (%s) or current_temp (%s) is null. Heating/cooling will be disabled. This could be normal at startup",  # pylint: disable=line-too-long
+                self._vtherm_entity_id,
+                target_temp,
+                current_temp,
             )
             self._calculated_on_percent = 0
         else:
             if hvac_mode == HVACMode.COOL:
                 delta_temp = current_temp - target_temp
                 delta_ext_temp = (
-                    ext_current_temp
+                    ext_current_temp - target_temp
                     if ext_current_temp is not None
-                    else 0 - target_temp
+                    else 0
                 )
             else:
                 delta_temp = target_temp - current_temp
@@ -83,7 +119,8 @@ class PropAlgorithm:
                 )
             else:
                 _LOGGER.warning(
-                    "Proportional algorithm: unknown %s function. Heating will be disabled",
+                    "%s - Proportional algorithm: unknown %s function. Heating will be disabled",
+                    self._vtherm_entity_id,
                     self._function,
                 )
                 self._calculated_on_percent = 0
@@ -91,7 +128,8 @@ class PropAlgorithm:
         self._calculate_internal()
 
         _LOGGER.debug(
-            "heating percent calculated for current_temp %.1f, ext_current_temp %.1f and target_temp %.1f is %.2f, on_time is %d (sec), off_time is %d (sec)",  # pylint: disable=line-too-long
+            "%s - heating percent calculated for current_temp %.1f, ext_current_temp %.1f and target_temp %.1f is %.2f, on_time is %d (sec), off_time is %d (sec)",  # pylint: disable=line-too-long
+            self._vtherm_entity_id,
             current_temp if current_temp else -9999.0,
             ext_current_temp if ext_current_temp else -9999.0,
             target_temp if target_temp else -9999.0,
@@ -110,11 +148,12 @@ class PropAlgorithm:
             self._calculated_on_percent = 0
 
         if self._security:
-            _LOGGER.debug(
-                "Security is On using the default_on_percent %f",
-                self._default_on_percent,
-            )
             self._on_percent = self._default_on_percent
+            _LOGGER.info(
+                "%s - Security is On using the default_on_percent %f",
+                self._vtherm_entity_id,
+                self._on_percent,
+            )
         else:
             _LOGGER.debug(
                 "Security is Off using the calculated_on_percent %f",
@@ -128,13 +167,8 @@ class PropAlgorithm:
         if self._on_time_sec < self._minimal_activation_delay:
             if self._on_time_sec > 0:
                 _LOGGER.info(
-                    "No heating period due to heating period too small (%f < %f)",
-                    self._on_time_sec,
-                    self._minimal_activation_delay,
-                )
-            else:
-                _LOGGER.debug(
-                    "No heating period due to heating period too small (%f < %f)",
+                    "%s - No heating period due to heating period too small (%f < %f)",
+                    self._vtherm_entity_id,
                     self._on_time_sec,
                     self._minimal_activation_delay,
                 )
@@ -144,12 +178,18 @@ class PropAlgorithm:
 
     def set_security(self, default_on_percent: float):
         """Set a default value for on_percent (used for safety mode)"""
+        _LOGGER.info(
+            "%s - Proportional Algo - set security to ON", self._vtherm_entity_id
+        )
         self._security = True
         self._default_on_percent = default_on_percent
         self._calculate_internal()
 
     def unset_security(self):
         """Unset the safety mode"""
+        _LOGGER.info(
+            "%s - Proportional Algo - set security to OFF", self._vtherm_entity_id
+        )
         self._security = False
         self._calculate_internal()
 

custom_components/versatile_thermostat/select.py

@@ -3,21 +3,20 @@
 """ Implements the VersatileThermostat select component """
 import logging
 
-from homeassistant.const import EVENT_HOMEASSISTANT_START
-from homeassistant.core import HomeAssistant, CoreState, callback
+from homeassistant.core import HomeAssistant
 
-from homeassistant.components.climate import ClimateEntity, DOMAIN as CLIMATE_DOMAIN
 from homeassistant.components.select import SelectEntity
 from homeassistant.helpers.device_registry import DeviceInfo, DeviceEntryType
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.helpers.restore_state import RestoreEntity
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.entity_component import EntityComponent
 
 from custom_components.versatile_thermostat.base_thermostat import (
-    BaseThermostat,
     ConfigData,
 )
+
+from custom_components.versatile_thermostat.vtherm_api import VersatileThermostatAPI
+
 from .const import (
     DOMAIN,
     DEVICE_MANUFACTURER,
@@ -96,17 +95,20 @@ class CentralModeSelect(SelectEntity, RestoreEntity):
         if old_state is not None:
             self._attr_current_option = old_state.state
 
-        @callback
-        async def _async_startup_internal(*_):
-            _LOGGER.debug("%s - Calling async_startup_internal", self)
-            await self.notify_central_mode_change()
+        api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(self.hass)
+        api.register_central_mode_select(self)
 
-        if self.hass.state == CoreState.running:
-            await _async_startup_internal()
-        else:
-            self.hass.bus.async_listen_once(
-                EVENT_HOMEASSISTANT_START, _async_startup_internal
-            )
+        # @callback
+        # async def _async_startup_internal(*_):
+        #     _LOGGER.debug("%s - Calling async_startup_internal", self)
+        #     await self.notify_central_mode_change()
+        #
+        # if self.hass.state == CoreState.running:
+        #     await _async_startup_internal()
+        # else:
+        #     self.hass.bus.async_listen_once(
+        #         EVENT_HOMEASSISTANT_START, _async_startup_internal
+        #     )
 
     @overrides
     async def async_select_option(self, option: str) -> None:
@@ -120,19 +122,17 @@ class CentralModeSelect(SelectEntity, RestoreEntity):
             self._attr_current_option = option
             await self.notify_central_mode_change(old_central_mode=old_option)
 
+    @overrides
+    def select_option(self, option: str) -> None:
+        """Change the selected option"""
+        # Update the VTherms which have temperature in central config
+        self.hass.create_task(self.async_select_option(option))
+
     async def notify_central_mode_change(self, old_central_mode: str | None = None):
         """Notify all VTherm that the central_mode have change"""
+        api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(self.hass)
         # Update all VTherm states
-        component: EntityComponent[ClimateEntity] = self.hass.data[CLIMATE_DOMAIN]
-        for entity in component.entities:
-            if isinstance(entity, BaseThermostat):
-                _LOGGER.debug(
-                    "Changing the central_mode. We have find %s to update",
-                    entity.name,
-                )
-                await entity.check_central_mode(
-                    self._attr_current_option, old_central_mode
-                )
+        await api.notify_central_mode_change(old_central_mode)
 
     def __str__(self) -> str:
         return f"VersatileThermostat-{self.name}"

custom_components/versatile_thermostat/sensor.py

@@ -125,15 +125,15 @@ class EnergySensor(VersatileThermostatBaseEntity, SensorEntity):
         """Called when my climate have change"""
         _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
-        if math.isnan(self.my_climate.total_energy) or math.isinf(
-            self.my_climate.total_energy
-        ):
+        energy = self.my_climate.total_energy
+        if energy is None:
+            return
+
+        if math.isnan(energy) or math.isinf(energy):
             raise ValueError(f"Sensor has illegal state {self.my_climate.total_energy}")
 
         old_state = self._attr_native_value
-        self._attr_native_value = round(
-            self.my_climate.total_energy, self.suggested_display_precision
-        )
+        self._attr_native_value = round(energy, self.suggested_display_precision)
         if old_state != self._attr_native_value:
             self.async_write_ha_state()
         return
@@ -570,7 +570,7 @@ class RegulatedTemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
     @property
     def native_unit_of_measurement(self) -> str | None:
         if not self.my_climate:
-            return UnitOfTemperature.CELSIUS
+            return self.hass.config.units.temperature_unit
         return self.my_climate.temperature_unit
 
     @property
@@ -621,7 +621,7 @@ class EMATemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
     @property
     def native_unit_of_measurement(self) -> str | None:
         if not self.my_climate:
-            return UnitOfTemperature.CELSIUS
+            return self.hass.config.units.temperature_unit
         return self.my_climate.temperature_unit
 
     @property

custom_components/versatile_thermostat/strings.json

@@ -37,7 +37,8 @@
         "data": {
           "name": "Name",
           "thermostat_type": "Thermostat type",
-          "temperature_sensor_entity_id": "Room temperature sensor entity id",
+          "temperature_sensor_entity_id": "Room temperature",
+          "last_seen_temperature_sensor_entity_id": "Last seen room temperature datetime",
           "external_temperature_sensor_entity_id": "Outdoor temperature sensor entity id",
           "cycle_min": "Cycle duration (minutes)",
           "temp_min": "Minimum temperature allowed",
@@ -49,6 +50,8 @@
           "used_by_controls_central_boiler": "Used by central boiler. Check if this VTherm should have control on the central boiler"
         },
         "data_description": {
+          "temperature_sensor_entity_id": "Room temperature sensor entity id",
+          "last_seen_temperature_sensor_entity_id": "Last seen room temperature sensor entity id. Should be datetime sensor",
           "external_temperature_sensor_entity_id": "Outdoor temperature sensor entity id. Not used if central configuration is selected"
         }
       },
@@ -87,7 +90,7 @@
           "auto_regulation_periode_min": "Regulation minimum period",
           "auto_regulation_use_device_temp": "Use internal temperature of the underlying",
           "inverse_switch_command": "Inverse switch command",
-          "auto_fan_mode": " Auto fan mode"
+          "auto_fan_mode": "Auto fan mode"
         },
         "data_description": {
           "heater_entity_id": "Mandatory heater entity id",
@@ -110,7 +113,7 @@
           "auto_regulation_periode_min": "Duration in minutes between two regulation update",
           "auto_regulation_use_device_temp": "Use the eventual internal temperature sensor of the underlying to speedup the self-regulation",
           "inverse_switch_command": "For switch with pilot wire and diode you may need to inverse the command",
-          "auto_fan_mode": " Automatically activate fan when huge heating/cooling is necessary"
+          "auto_fan_mode": "Automatically activate fan when huge heating/cooling is necessary"
         }
       },
       "tpi": {
@@ -269,7 +272,8 @@
         "data": {
           "name": "Name",
           "thermostat_type": "Thermostat type",
-          "temperature_sensor_entity_id": "Room temperature sensor entity id",
+          "temperature_sensor_entity_id": "Room temperature",
+          "last_seen_temperature_sensor_entity_id": "Last seen room temperature datetime",
           "external_temperature_sensor_entity_id": "Outdoor temperature sensor entity id",
           "cycle_min": "Cycle duration (minutes)",
           "temp_min": "Minimum temperature allowed",
@@ -281,6 +285,8 @@
           "used_by_controls_central_boiler": "Used by central boiler. Check if this VTherm should have control on the central boiler"
         },
         "data_description": {
+          "temperature_sensor_entity_id": "Room temperature sensor entity id",
+          "last_seen_temperature_sensor_entity_id": "Last seen room temperature sensor entity id. Should be datetime sensor",
           "external_temperature_sensor_entity_id": "Outdoor temperature sensor entity id. Not used if central configuration is selected"
         }
       },
@@ -319,7 +325,7 @@
           "auto_regulation_periode_min": "Regulation minimum period",
           "auto_regulation_use_device_temp": "Use internal temperature of the underlying",
           "inverse_switch_command": "Inverse switch command",
-          "auto_fan_mode": " Auto fan mode"
+          "auto_fan_mode": "Auto fan mode"
         },
         "data_description": {
           "heater_entity_id": "Mandatory heater entity id",
@@ -342,7 +348,7 @@
           "auto_regulation_periode_min": "Duration in minutes between two regulation update",
           "auto_regulation_use_device_temp": "Use the eventual internal temperature sensor of the underlying to speedup the self-regulation",
           "inverse_switch_command": "For switch with pilot wire and diode you may need to invert the command",
-          "auto_fan_mode": " Automatically activate fan when huge heating/cooling is necessary"
+          "auto_fan_mode": "Automatically activate fan when huge heating/cooling is necessary"
         }
       },
       "tpi": {
@@ -572,4 +578,4 @@
       }
     }
   }
-}
+}

custom_components/versatile_thermostat/thermostat_climate.py

@@ -3,13 +3,12 @@
 import logging
 from datetime import timedelta, datetime
 
-from homeassistant.core import HomeAssistant, State, callback
+from homeassistant.core import Event, HomeAssistant, State, callback
 from homeassistant.helpers.event import (
     async_track_state_change_event,
     async_track_time_interval,
     EventStateChangedData,
 )
-from homeassistant.helpers.typing import EventType as HASSEventType
 from homeassistant.components.climate import (
     HVACAction,
     HVACMode,
@@ -143,7 +142,17 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
         """Sends the regulated temperature to all underlying"""
 
         if self.hvac_mode == HVACMode.OFF:
-            _LOGGER.debug("%s - don't send regulated temperature cause VTherm is off ")
+            _LOGGER.debug(
+                "%s - don't send regulated temperature cause VTherm is off ", self
+            )
+            return
+
+        if self.target_temperature is None:
+            _LOGGER.warning(
+                "%s - don't send regulated temperature cause VTherm target_temp (%s) is None. This should be a temporary warning message.",
+                self,
+                self.target_temperature,
+            )
             return
 
         _LOGGER.info(
@@ -168,12 +177,19 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
 
         _LOGGER.info("%s - regulation calculation will be done", self)
 
-        new_regulated_temp = round_to_nearest(
-            self._regulation_algo.calculate_regulated_temperature(
-                self.current_temperature, self._cur_ext_temp
-            ),
-            self._auto_regulation_dtemp,
-        )
+        # use _attr_target_temperature_step to round value if _auto_regulation_dtemp is equal to 0
+        regulation_step = self._auto_regulation_dtemp if self._auto_regulation_dtemp else self._attr_target_temperature_step
+        _LOGGER.debug("%s - usage regulation_step: %.2f ", self, regulation_step)
+
+        if self.current_temperature is not None:
+            new_regulated_temp = round_to_nearest(
+                self._regulation_algo.calculate_regulated_temperature(
+                    self.current_temperature, self._cur_ext_temp
+                ),
+                regulation_step,
+            )
+        else:
+            new_regulated_temp = self.target_temperature
         dtemp = new_regulated_temp - self._regulated_target_temp
 
         if not force and abs(dtemp) < self._auto_regulation_dtemp:
@@ -198,8 +214,10 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             offset_temp = 0
             device_temp = 0
             if (
+                # current_temperature is set
+                self.current_temperature is not None
                 # regulation can use the device_temp
-                self.auto_regulation_use_device_temp
+                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)
@@ -216,7 +234,7 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             ):
                 offset_temp = device_temp - self.current_temperature
 
-            target_temp = round_to_nearest(self.regulated_target_temp + offset_temp, self._auto_regulation_dtemp)
+            target_temp = round_to_nearest(self.regulated_target_temp + offset_temp, regulation_step)
 
             _LOGGER.debug(
                 "%s - The device offset temp for regulation is %.2f - internal temp is %.2f. New target is %.2f",
@@ -581,7 +599,11 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
         ):
             added_energy = self._device_power * self._underlying_climate_delta_t
 
-        self._total_energy += added_energy
+        if self._total_energy is None:
+            self._total_energy = added_energy
+        else:
+            self._total_energy += added_energy
+
         _LOGGER.debug(
             "%s - added energy is %.3f . Total energy is now: %.3f",
             self,
@@ -590,7 +612,7 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
         )
 
     @callback
-    async def _async_climate_changed(self, event: HASSEventType[EventStateChangedData]):
+    async def _async_climate_changed(self, event: Event[EventStateChangedData]):
         """Handle unerdlying climate state changes.
         This method takes the underlying values and update the VTherm with them.
         To avoid loops (issues #121 #101 #95 #99), we discard the event if it is received
@@ -890,10 +912,7 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
     @property
     def temperature_unit(self) -> str:
         """Return the unit of measurement."""
-        if self.underlying_entity(0):
-            return self.underlying_entity(0).temperature_unit
-
-        return self._unit
+        return self.hass.config.units.temperature_unit
 
     @property
     def supported_features(self):

custom_components/versatile_thermostat/thermostat_switch.py

@@ -2,12 +2,11 @@
 
 """ A climate over switch classe """
 import logging
-from homeassistant.core import callback
+from homeassistant.core import Event, callback
 from homeassistant.helpers.event import (
     async_track_state_change_event,
     EventStateChangedData,
 )
-from homeassistant.helpers.typing import EventType as HASSEventType
 from homeassistant.components.climate import HVACMode
 
 from .const import (
@@ -88,6 +87,7 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
             self._tpi_coef_ext,
             self._cycle_min,
             self._minimal_activation_delay,
+            self.name,
         )
 
         lst_switches = [config_entry.get(CONF_HEATER)]
@@ -198,7 +198,11 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
         if not self.is_over_climate and self.mean_cycle_power is not None:
             added_energy = self.mean_cycle_power * float(self._cycle_min) / 60.0
 
-        self._total_energy += added_energy
+        if self._total_energy is None:
+            self._total_energy = added_energy
+        else:
+            self._total_energy += added_energy
+
         _LOGGER.debug(
             "%s - added energy is %.3f . Total energy is now: %.3f",
             self,
@@ -207,7 +211,7 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
         )
 
     @callback
-    def _async_switch_changed(self, event: HASSEventType[EventStateChangedData]):
+    def _async_switch_changed(self, event: Event[EventStateChangedData]):
         """Handle heater switch state changes."""
         new_state = event.data.get("new_state")
         old_state = event.data.get("old_state")

custom_components/versatile_thermostat/thermostat_valve.py

@@ -8,8 +8,7 @@ from homeassistant.helpers.event import (
     async_track_time_interval,
     EventStateChangedData,
 )
-from homeassistant.helpers.typing import EventType as HASSEventType
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.components.climate import HVACMode
 
 from .base_thermostat import BaseThermostat, ConfigData
@@ -34,26 +33,24 @@ _LOGGER = logging.getLogger(__name__)
 class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=abstract-method
     """Representation of a class for a Versatile Thermostat over a Valve"""
 
-    _entity_component_unrecorded_attributes = (
-        BaseThermostat._entity_component_unrecorded_attributes.union(
-            frozenset(
-                {
-                    "is_over_valve",
-                    "underlying_valve_0",
-                    "underlying_valve_1",
-                    "underlying_valve_2",
-                    "underlying_valve_3",
-                    "on_time_sec",
-                    "off_time_sec",
-                    "cycle_min",
-                    "function",
-                    "tpi_coef_int",
-                    "tpi_coef_ext",
-                    "auto_regulation_dpercent",
-                    "auto_regulation_period_min",
-                    "last_calculation_timestamp",
-                }
-            )
+    _entity_component_unrecorded_attributes = BaseThermostat._entity_component_unrecorded_attributes.union(  # pylint: disable=protected-access
+        frozenset(
+            {
+                "is_over_valve",
+                "underlying_valve_0",
+                "underlying_valve_1",
+                "underlying_valve_2",
+                "underlying_valve_3",
+                "on_time_sec",
+                "off_time_sec",
+                "cycle_min",
+                "function",
+                "tpi_coef_int",
+                "tpi_coef_ext",
+                "auto_regulation_dpercent",
+                "auto_regulation_period_min",
+                "last_calculation_timestamp",
+            }
         )
     )
 
@@ -105,6 +102,7 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a
             self._tpi_coef_ext,
             self._cycle_min,
             self._minimal_activation_delay,
+            self.name,
         )
 
         lst_valves = [config_entry.get(CONF_VALVE)]
@@ -148,7 +146,7 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a
         )
 
     @callback
-    async def _async_valve_changed(self, event: HASSEventType[EventStateChangedData]):
+    async def _async_valve_changed(self, event: Event[EventStateChangedData]):
         """Handle unerdlying valve state changes.
         This method just log the change. It changes nothing to avoid loops.
         """
@@ -241,10 +239,16 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a
             max(0, min(self.proportional_algorithm.on_percent, 1)) * 100
         )
 
+        # Issue 533 - don't filter with dtemp if valve should be close. Else it will never close
+        if new_valve_percent < self._auto_regulation_dpercent:
+            new_valve_percent = 0
+
         dpercent = new_valve_percent - self.valve_open_percent
         if (
-            dpercent >= -1 * self._auto_regulation_dpercent
-            and dpercent < self._auto_regulation_dpercent
+            new_valve_percent > 0
+            and -1 * self._auto_regulation_dpercent
+            <= dpercent
+            < self._auto_regulation_dpercent
         ):
             _LOGGER.debug(
                 "%s - do not calculate TPI because regulation_dpercent (%.1f) is not exceeded",
@@ -278,7 +282,11 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a
         if not self.is_over_climate and self.mean_cycle_power is not None:
             added_energy = self.mean_cycle_power * float(self._cycle_min) / 60.0
 
-        self._total_energy += added_energy
+        if self._total_energy is None:
+            self._total_energy = added_energy
+        else:
+            self._total_energy += added_energy
+
         _LOGGER.debug(
             "%s - added energy is %.3f . Total energy is now: %.3f",
             self,

custom_components/versatile_thermostat/translations/el.json

@@ -43,7 +43,7 @@
           "auto_regulation_dtemp": "Όριο ρύθμισης",
           "auto_regulation_periode_min": "Ελάχιστη περίοδος ρύθμισης",
           "inverse_switch_command": "Αντίστροφη εντολή διακόπτη",
-          "auto_fan_mode": " Auto fan mode"
+          "auto_fan_mode": "Auto fan mode"
         },
         "data_description": {
           "heater_entity_id": "Υποχρεωτική ταυτότητα οντότητας θερμαντήρα",
@@ -64,7 +64,7 @@
           "auto_regulation_dtemp": "Το όριο σε ° κάτω από το οποίο η αλλαγή θερμοκρασίας δεν θα αποστέλλεται",
           "auto_regulation_periode_min": "Διάρκεια σε λεπτά μεταξύ δύο ενημερώσεων ρύθμισης",
           "inverse_switch_command": "Για διακόπτη με πιλοτικό καλώδιο και δίοδο μπορεί να χρειαστεί να αντιστρέψετε την εντολή",
-          "auto_fan_mode": " Automatically activate fan when huge heating/cooling is necessary"
+          "auto_fan_mode": "Automatically activate fan when huge heating/cooling is necessary"
         }
       },
       "tpi": {
@@ -216,7 +216,7 @@
           "auto_regulation_dtemp": "Όριο ρύθμισης",
           "auto_regulation_periode_min": "Ελάχιστη περίοδος ρύθμισης",
           "inverse_switch_command": "Αντίστροφη εντολή διακόπτη",
-          "auto_fan_mode": " Auto fan mode"
+          "auto_fan_mode": "Auto fan mode"
         },
         "data_description": {
           "heater_entity_id": "Υποχρεωτική ταυτότητα οντότητας θερμαντήρα",
@@ -237,7 +237,7 @@
           "auto_regulation_dtemp": "Το κατώφλι σε °C κάτω από το οποίο η αλλαγή της θερμοκρασίας δεν θα αποστέλλεται",
           "auto_regulation_periode_min": "Διάρκεια σε λεπτά μεταξύ δύο ενημερώσεων ρύθμισης",
           "inverse_switch_command": "Για διακόπτες με πιλοτικό καλώδιο και δίοδο μπορεί να χρειαστεί να αντιστραφεί η εντολή",
-          "auto_fan_mode": " Automatically activate fan when huge heating/cooling is necessary"
+          "auto_fan_mode": "Automatically activate fan when huge heating/cooling is necessary"
         }
       },
       "tpi": {

custom_components/versatile_thermostat/translations/en.json

@@ -37,7 +37,8 @@
         "data": {
           "name": "Name",
           "thermostat_type": "Thermostat type",
-          "temperature_sensor_entity_id": "Room temperature sensor entity id",
+          "temperature_sensor_entity_id": "Room temperature",
+          "last_seen_temperature_sensor_entity_id": "Last seen room temperature datetime",
           "external_temperature_sensor_entity_id": "Outdoor temperature sensor entity id",
           "cycle_min": "Cycle duration (minutes)",
           "temp_min": "Minimum temperature allowed",
@@ -49,6 +50,8 @@
           "used_by_controls_central_boiler": "Used by central boiler. Check if this VTherm should have control on the central boiler"
         },
         "data_description": {
+          "temperature_sensor_entity_id": "Room temperature sensor entity id",
+          "last_seen_temperature_sensor_entity_id": "Last seen room temperature sensor entity id. Should be datetime sensor",
           "external_temperature_sensor_entity_id": "Outdoor temperature sensor entity id. Not used if central configuration is selected"
         }
       },
@@ -87,7 +90,7 @@
           "auto_regulation_periode_min": "Regulation minimum period",
           "auto_regulation_use_device_temp": "Use internal temperature of the underlying",
           "inverse_switch_command": "Inverse switch command",
-          "auto_fan_mode": " Auto fan mode"
+          "auto_fan_mode": "Auto fan mode"
         },
         "data_description": {
           "heater_entity_id": "Mandatory heater entity id",
@@ -110,7 +113,7 @@
           "auto_regulation_periode_min": "Duration in minutes between two regulation update",
           "auto_regulation_use_device_temp": "Use the eventual internal temperature sensor of the underlying to speedup the self-regulation",
           "inverse_switch_command": "For switch with pilot wire and diode you may need to inverse the command",
-          "auto_fan_mode": " Automatically activate fan when huge heating/cooling is necessary"
+          "auto_fan_mode": "Automatically activate fan when huge heating/cooling is necessary"
         }
       },
       "tpi": {
@@ -269,7 +272,8 @@
         "data": {
           "name": "Name",
           "thermostat_type": "Thermostat type",
-          "temperature_sensor_entity_id": "Room temperature sensor entity id",
+          "temperature_sensor_entity_id": "Room temperature",
+          "last_seen_temperature_sensor_entity_id": "Last seen room temperature datetime",
           "external_temperature_sensor_entity_id": "Outdoor temperature sensor entity id",
           "cycle_min": "Cycle duration (minutes)",
           "temp_min": "Minimum temperature allowed",
@@ -281,6 +285,8 @@
           "used_by_controls_central_boiler": "Used by central boiler. Check if this VTherm should have control on the central boiler"
         },
         "data_description": {
+          "temperature_sensor_entity_id": "Room temperature sensor entity id",
+          "last_seen_temperature_sensor_entity_id": "Last seen room temperature sensor entity id. Should be datetime sensor",
           "external_temperature_sensor_entity_id": "Outdoor temperature sensor entity id. Not used if central configuration is selected"
         }
       },
@@ -319,7 +325,7 @@
           "auto_regulation_periode_min": "Regulation minimum period",
           "auto_regulation_use_device_temp": "Use internal temperature of the underlying",
           "inverse_switch_command": "Inverse switch command",
-          "auto_fan_mode": " Auto fan mode"
+          "auto_fan_mode": "Auto fan mode"
         },
         "data_description": {
           "heater_entity_id": "Mandatory heater entity id",
@@ -342,7 +348,7 @@
           "auto_regulation_periode_min": "Duration in minutes between two regulation update",
           "auto_regulation_use_device_temp": "Use the eventual internal temperature sensor of the underlying to speedup the self-regulation",
           "inverse_switch_command": "For switch with pilot wire and diode you may need to invert the command",
-          "auto_fan_mode": " Automatically activate fan when huge heating/cooling is necessary"
+          "auto_fan_mode": "Automatically activate fan when huge heating/cooling is necessary"
         }
       },
       "tpi": {
@@ -572,4 +578,4 @@
       }
     }
   }
-}
+}

custom_components/versatile_thermostat/translations/fr.json

@@ -37,8 +37,9 @@
         "data": {
           "name": "Nom",
           "thermostat_type": "Type de thermostat",
-          "temperature_sensor_entity_id": "Température sensor entity id",
-          "external_temperature_sensor_entity_id": "Température exterieure sensor entity id",
+          "temperature_sensor_entity_id": "Capteur de température",
+          "last_seen_temperature_sensor_entity_id": "Dernière vue capteur de température",
+          "external_temperature_sensor_entity_id": "Capteur de température exterieure",
           "cycle_min": "Durée du cycle (minutes)",
           "temp_min": "Température minimale permise",
           "temp_max": "Température maximale permise",
@@ -49,7 +50,9 @@
           "used_by_controls_central_boiler": "Utilisé par la chaudière centrale. Cochez si ce VTherm doit contrôler la chaudière centrale."
         },
         "data_description": {
-          "external_temperature_sensor_entity_id": "Entity id du capteur de température extérieure."
+          "temperature_sensor_entity_id": "Id d'entité du capteur de température",
+          "last_seen_temperature_sensor_entity_id": "Id d'entité du capteur donnant la date et heure de dernière vue capteur de température. L'état doit être au format date heure (ex: 2024-03-31T17:07:03+00:00)",
+          "external_temperature_sensor_entity_id": "Entity id du capteur de température extérieure. Non utilisé si une configuration centrale est définie"
         }
       },
       "features": {
@@ -281,19 +284,22 @@
         "data": {
           "name": "Nom",
           "thermostat_type": "Type de thermostat",
-          "temperature_sensor_entity_id": "Température sensor entity id",
-          "external_temperature_sensor_entity_id": "Température exterieure sensor entity id",
+          "temperature_sensor_entity_id": "Capteur de température",
+          "last_seen_temperature_sensor_entity_id": "Dernière vue capteur de température",
+          "external_temperature_sensor_entity_id": "Capteur de température exterieure",
           "cycle_min": "Durée du cycle (minutes)",
           "temp_min": "Température minimale permise",
           "temp_max": "Température maximale permise",
           "step_temperature": "Pas de température",
           "device_power": "Puissance de l'équipement",
           "use_central_mode": "Autoriser le controle par une entity centrale ('nécessite une config. centrale`). Cochez pour autoriser le contrôle du VTherm par la liste déroulante 'central_mode' de l'entité configuration centrale.",
-          "use_main_central_config": "Utiliser la configuration centrale supplémentaire. Cochez pour utiliser la configuration centrale supplémentaire (température externe, min, max, pas, ...).",
+          "use_main_central_config": "Utiliser la configuration centrale supplémentaire. Cochez pour utiliser la configuration centrale supplémentaire (température externe, min, max, pas, ...)",
           "used_by_controls_central_boiler": "Utilisé par la chaudière centrale. Cochez si ce VTherm doit contrôler la chaudière centrale."
         },
         "data_description": {
-          "external_temperature_sensor_entity_id": "Entity id du capteur de température extérieure. N'est pas utilisé si la configuration centrale est utilisée."
+          "temperature_sensor_entity_id": "Id d'entité du capteur de température",
+          "last_seen_temperature_sensor_entity_id": "Id d'entité du capteur donnant la date et heure de dernière vue capteur de température. L'état doit être au format date heure (ex: 2024-03-31T17:07:03+00:00)",
+          "external_temperature_sensor_entity_id": "Entity id du capteur de température extérieure. Non utilisé si une configuration centrale est définie"
         }
       },
       "features": {
@@ -331,7 +337,7 @@
           "auto_regulation_periode_min": "Période minimale de régulation",
           "auto_regulation_use_device_temp": "Utiliser la température interne du sous-jacent",
           "inverse_switch_command": "Inverser la commande",
-          "auto_fan_mode": " Auto fan mode"
+          "auto_fan_mode": "Auto fan mode"
         },
         "data_description": {
           "heater_entity_id": "Entity id du 1er radiateur obligatoire",

custom_components/versatile_thermostat/translations/it.json

@@ -42,7 +42,7 @@
           "valve_entity4_id": "Quarta valvola",
           "auto_regulation_mode": "Autoregolamentazione",
           "inverse_switch_command": "Comando inverso",
-          "auto_fan_mode": " Auto fan mode"
+          "auto_fan_mode": "Auto fan mode"
         },
         "data_description": {
           "heater_entity_id": "Entity id obbligatoria del primo riscaldatore",
@@ -62,7 +62,7 @@
           "valve_entity4_id": "Entity id della quarta valvola",
           "auto_regulation_mode": "Regolazione automatica della temperatura target",
           "inverse_switch_command": "Inverte il controllo dell'interruttore per un'installazione con filo pilota e diodo",
-          "auto_fan_mode": " Automatically activate fan when huge heating/cooling is necessary"
+          "auto_fan_mode": "Automatically activate fan when huge heating/cooling is necessary"
         }
       },
       "tpi": {
@@ -206,7 +206,7 @@
           "valve_entity4_id": "Quarta valvola",
           "auto_regulation_mode": "Autoregolamentazione",
           "inverse_switch_command": "Comando inverso",
-          "auto_fan_mode": " Auto fan mode"
+          "auto_fan_mode": "Auto fan mode"
         },
         "data_description": {
           "heater_entity_id": "Entity id obbligatoria del primo riscaldatore",
@@ -226,7 +226,7 @@
           "valve_entity4_id": "Entity id della quarta valvola",
           "auto_regulation_mode": "Autoregolamentazione",
           "inverse_switch_command": "Inverte il controllo dell'interruttore per un'installazione con filo pilota e diodo",
-          "auto_fan_mode": " Automatically activate fan when huge heating/cooling is necessary"
+          "auto_fan_mode": "Automatically activate fan when huge heating/cooling is necessary"
         }
       },
       "tpi": {

custom_components/versatile_thermostat/translations/sk.json

@@ -12,6 +12,25 @@
           "thermostat_type": "Len jeden centrálny typ konfigurácie je možný"
         }
       },
+      "menu": {
+        "title": "Menu",
+        "description": "Nakonfigurujte si termostat. Po zadaní všetkých požadovaných parametrov budete môcť dokončiť konfiguráciu.",
+        "menu_options": {
+          "main": "Hlavné atribúty",
+          "central_boiler": "Centrálny kotol",
+          "type": "Podklady",
+          "tpi": "TPI parametre",
+          "features": "Vlastnosti",
+          "presets": "Predvoľby",
+          "window": "Detekcia okien",
+          "motion": "Detekcia pohybu",
+          "power": "Správa napájania",
+          "presence": "Detekcia prítomnosti",
+          "advanced": "Pokročilé parametre",
+          "finalize": "Všetko hotové",
+          "configuration_not_complete": "Konfigurácia nie je dokončená"
+        }
+      },
       "main": {
         "title": "Pridajte nový všestranný termostat",
         "description": "Hlavné povinné atribúty",
@@ -19,22 +38,32 @@
           "name": "Názov",
           "thermostat_type": "Termostat typ",
           "temperature_sensor_entity_id": "ID entity snímača teploty",
+          "last_seen_temperature_sensor_entity_id": "Dátum posledného zobrazenia izbovej teploty",
           "external_temperature_sensor_entity_id": "ID entity externého snímača teploty",
           "cycle_min": "Trvanie cyklu (minúty)",
           "temp_min": "Minimálna povolená teplota",
           "temp_max": "Maximálna povolená teplota",
+          "step_temperature": "Krok teploty",
           "device_power": "Napájanie zariadenia",
           "use_central_mode": "Povoliť ovládanie centrálnou entitou (potrebná centrálna konfigurácia)",
+          "use_main_central_config": "Použite dodatočnú centrálnu hlavnú konfiguráciu. Začiarknite, ak chcete použiť centrálnu hlavnú konfiguráciu (vonkajšia teplota, min, max, krok, ...).",
+          "used_by_controls_central_boiler": "Používa sa centrálnym kotlom. Skontrolujte, či má mať tento VTherm ovládanie na centrálnom kotli"
+        },
+        "data_description": {
+          "temperature_sensor_entity_id": "ID entity snímača izbovej teploty",
+          "last_seen_temperature_sensor_entity_id": "Naposledy videný snímač izbovej teploty ID entity. Mal by to byť snímač dátumu a času",
+          "external_temperature_sensor_entity_id": "ID entity snímača vonkajšej teploty. Nepoužíva sa, ak je zvolená centrálna konfigurácia"
+        }
+      },
+      "features": {
+        "title": "Vlastnosti",
+        "description": "Vlastnosti termostatu",
+        "data": {
           "use_window_feature": "Použite detekciu okien",
           "use_motion_feature": "Použite detekciu pohybu",
           "use_power_feature": "Použite správu napájania",
           "use_presence_feature": "Použite detekciu prítomnosti",
-          "use_main_central_config": "Použite centrálnu hlavnú konfiguráciu"
-        },
-        "data_description": {
-          "use_central_mode": "Zaškrtnutím povolíte ovládanie VTherm pomocou vybraných entít central_mode",
-          "use_main_central_config": "Začiarknite, ak chcete použiť centrálnu hlavnú konfiguráciu. Zrušte začiarknutie, ak chcete použiť špecifickú hlavnú konfiguráciu pre tento VTherm",
-          "external_temperature_sensor_entity_id": "ID entity snímača vonkajšej teploty. Nepoužíva sa, ak je zvolená centrálna konfigurácia"
+          "use_central_boiler_feature": "Použite centrálny kotol. Začiarknutím tohto políčka pridáte ovládanie do centrálneho kotla. Po zaškrtnutí tohto políčka budete musieť nakonfigurovať VTherm, ktorý bude mať ovládanie centrálneho kotla, aby sa prejavilo. Ak jeden VTherm vyžaduje ohrev, kotol sa zapne. Ak žiadny VTherm nevyžaduje ohrev, kotol sa vypne. Príkazy na zapnutie/vypnutie centrálneho kotla sú uvedené na príslušnej konfiguračnej stránke"
         }
       },
       "type": {
@@ -45,6 +74,7 @@
           "heater_entity2_id": "2. spínač ohrievača",
           "heater_entity3_id": "3. spínač ohrievača",
           "heater_entity4_id": "4. spínač ohrievača",
+          "heater_keep_alive": "Prepnite interval udržiavania v sekundách",
           "proportional_function": "Algoritmus",
           "climate_entity_id": "1. základná klíma",
           "climate_entity2_id": "2. základná klíma",
@@ -58,6 +88,7 @@
           "auto_regulation_mode": "Samoregulácia",
           "auto_regulation_dtemp": "Regulačný prah",
           "auto_regulation_periode_min": "Regulačné minimálne obdobie",
+          "auto_regulation_use_device_temp": "Použite vnútornú teplotu podkladu",
           "inverse_switch_command": "Inverzný prepínací príkaz",
           "auto_fan_mode": "Režim automatického ventilátora"
         },
@@ -66,6 +97,7 @@
           "heater_entity2_id": "Voliteľné ID entity 2. ohrievača. Ak sa nepoužíva, nechajte prázdne",
           "heater_entity3_id": "Voliteľné ID entity 3. ohrievača. Ak sa nepoužíva, nechajte prázdne",
           "heater_entity4_id": "Voliteľné ID entity 4. ohrievača. Ak sa nepoužíva, nechajte prázdne",
+          "heater_keep_alive": "Voliteľný interval obnovy stavu spínača ohrievača. Ak to nie je potrebné, nechajte prázdne.",
           "proportional_function": "Algoritmus, ktorý sa má použiť (TPI je zatiaľ jediný)",
           "climate_entity_id": "ID základnej klimatickej entity",
           "climate_entity2_id": "2. základné identifikačné číslo klimatickej entity",
@@ -79,6 +111,7 @@
           "auto_regulation_mode": "Automatické nastavenie cieľovej teploty",
           "auto_regulation_dtemp": "Hranica v °, pod ktorou sa zmena teploty neodošle",
           "auto_regulation_periode_min": "Trvanie v minútach medzi dvoma aktualizáciami predpisov",
+          "auto_regulation_use_device_temp": "Na urýchlenie samoregulácie použite prípadný vnútorný snímač teploty podkladu",
           "inverse_switch_command": "V prípade spínača s pilotným vodičom a diódou možno budete musieť príkaz invertovať",
           "auto_fan_mode": "Automaticky aktivujte ventilátor, keď je potrebné veľké vykurovanie/chladenie"
         }
@@ -101,24 +134,7 @@
         "title": "Predvoľby",
         "description": "Pre každú predvoľbu zadajte cieľovú teplotu (0, ak chcete predvoľbu ignorovať)",
         "data": {
-          "eco_temp": "Teplota v predvoľbe Eco",
-          "comfort_temp": "Prednastavená teplota v komfortnom režime",
-          "boost_temp": "Teplota v prednastavení Boost",
-          "frost_temp": "Teplota v prednastavení Frost protection",
-          "eco_ac_temp": "Teplota v režime Eco prednastavená pre režim AC",
-          "comfort_ac_temp": "Teplota v režime Comfort je prednastavená pre režim AC",
-          "boost_ac_temp": "Prednastavená teplota v režime Boost pre režim AC",
           "use_presets_central_config": "Použite konfiguráciu centrálnych predvolieb"
-        },
-        "data_description": {
-          "eco_temp": "Teplota v predvoľbe Eco",
-          "comfort_temp": "Prednastavená teplota v komfortnom režime",
-          "boost_temp": "Teplota v prednastavení Boost",
-          "frost_temp": "Teplota v prednastavenej ochrane proti mrazu",
-          "eco_ac_temp": "Teplota v režime Eco prednastavená pre režim AC",
-          "comfort_ac_temp": "Teplota v režime Comfort je prednastavená pre režim AC",
-          "boost_ac_temp": "Prednastavená teplota v režime Boost pre režim AC",
-          "use_presets_central_config": "Začiarknite, ak chcete použiť konfiguráciu centrálnych predvolieb. Zrušte začiarknutie, ak chcete použiť špecifickú konfiguráciu predvolieb pre tento VTherm"
         }
       },
       "window": {
@@ -130,7 +146,8 @@
           "window_auto_open_threshold": "Prah poklesu teploty pre automatickú detekciu otvoreného okna (v °/hodina)",
           "window_auto_close_threshold": "Prahová hodnota zvýšenia teploty pre koniec automatickej detekcie (v °/hodina)",
           "window_auto_max_duration": "Maximálne trvanie automatickej detekcie otvoreného okna (v min)",
-          "use_window_central_config": "Použite centrálnu konfiguráciu okna"
+          "use_window_central_config": "Použite centrálnu konfiguráciu okna",
+          "window_action": "Akcia"
         },
         "data_description": {
           "window_sensor_entity_id": "Nechajte prázdne, ak nemáte použiť žiadny okenný senzor",
@@ -138,7 +155,8 @@
           "window_auto_open_threshold": "Odporúčaná hodnota: medzi 3 a 10. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
           "window_auto_close_threshold": "Odporúčaná hodnota: 0. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
           "window_auto_max_duration": "Odporúčaná hodnota: 60 (jedna hodina). Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
-          "use_window_central_config": "Začiarknite, ak chcete použiť konfiguráciu centrálneho okna. Zrušte začiarknutie, ak chcete použiť špecifickú konfiguráciu okna pre tento VTherm"
+          "use_window_central_config": "Začiarknite, ak chcete použiť konfiguráciu centrálneho okna. Zrušte začiarknutie, ak chcete použiť špecifickú konfiguráciu okna pre tento VTherm",
+          "window_action": "Akcia, ktorá sa má vykonať, ak sa okno zistí ako otvorené"
         }
       },
       "motion": {
@@ -181,26 +199,11 @@
         "title": "Riadenie prítomnosti",
         "description": "Atribúty správy prítomnosti.\nPoskytuje senzor prítomnosti vášho domova (pravda, ak je niekto prítomný).\nPotom zadajte buď predvoľbu, ktorá sa má použiť, keď je senzor prítomnosti nepravdivý, alebo posun teploty, ktorý sa má použiť.\nAk je zadaná predvoľba, posun sa nepoužije.\nAk sa nepoužije, ponechajte zodpovedajúce entity_id prázdne.",
         "data": {
-          "presence_sensor_entity_id": "ID entity senzora prítomnosti",
-          "eco_away_temp": "Teplota v prednastavenej Eco, keď nie je žiadna prítomnosť",
-          "comfort_away_temp": "Teplota v režime Comfort je prednastavená, keď nie je prítomný",
-          "boost_away_temp": "Prednastavená teplota v režime Boost, keď nie je prítomný",
-          "frost_away_temp": "Prednastavená teplota v režime Frost protection, keď nie je prítomný",
-          "eco_ac_away_temp": "Teplota v prednastavenej Eco, keď nie je prítomná v režime AC",
-          "comfort_ac_away_temp": "Teplota v režime Comfort je prednastavená, keď nie je prítomný v režime AC",
-          "boost_ac_away_temp": "Teplota v prednastavenom Boost, keď nie je prítomný v režime AC",
-          "use_presence_central_config": "Použite centrálnu konfiguráciu prítomnosti"
+          "presence_sensor_entity_id": "Senzora prítomnosti",
+          "use_presence_central_config": "Použite konfiguráciu centrálnej prítomnosti teploty. Ak chcete použiť špecifické teplotné entity, zrušte výber"
         },
         "data_description": {
-          "presence_sensor_entity_id": "ID entity senzora prítomnosti",
-          "eco_away_temp": "Teplota v prednastavenej Eco, keď nie je žiadna prítomnosť",
-          "comfort_away_temp": "Teplota v režime Comfort je prednastavená, keď nie je prítomný",
-          "boost_away_temp": "Prednastavená teplota v režime Boost, keď nie je prítomný",
-          "frost_away_temp": "Teplota v Prednastavená ochrana pred mrazom, keď nie je prítomný",
-          "eco_ac_away_temp": "Teplota v prednastavenej Eco, keď nie je prítomná v režime AC",
-          "comfort_ac_away_temp": "Teplota v režime Comfort je prednastavená, keď nie je prítomný v režime AC",
-          "boost_ac_away_temp": "Teplota v prednastavenom Boost, keď nie je prítomný v režime AC",
-          "use_presence_central_config": "Začiarknite, ak chcete použiť konfiguráciu centrálnej prítomnosti. Zrušte začiarknutie, ak chcete použiť špecifickú konfiguráciu prítomnosti pre tento VTherm"
+          "presence_sensor_entity_id": "ID entity senzora prítomnosti"
         }
       },
       "advanced": {
@@ -244,6 +247,25 @@
           "thermostat_type": "Je možný len jeden centrálny typ konfigurácie"
         }
       },
+      "menu": {
+        "title": "Menu",
+        "description": "Nakonfigurujte si termostat. Po zadaní všetkých požadovaných parametrov budete môcť dokončiť konfiguráciu.",
+        "menu_options": {
+          "main": "Hlavné atribúty",
+          "central_boiler": "Centrálny kotol",
+          "type": "Podklady",
+          "tpi": "TPI parametre",
+          "features": "Vlastnosti",
+          "presets": "Predvoľby",
+          "window": "Detekcia okien",
+          "motion": "Detekcia pohybu",
+          "power": "Správa napájania",
+          "presence": "Detekcia prítomnosti",
+          "advanced": "Pokročilé parametre",
+          "finalize": "Všetko hotové",
+          "configuration_not_complete": "Konfigurácia nie je dokončená"
+        }
+      },
       "main": {
         "title": "Hlavný - {name}",
         "description": "Hlavné povinné atribúty",
@@ -251,22 +273,32 @@
           "name": "Názov",
           "thermostat_type": "Termostat typ",
           "temperature_sensor_entity_id": "ID entity snímača teploty",
+          "last_seen_temperature_sensor_entity_id": "Dátum posledného zobrazenia izbovej teploty",
           "external_temperature_sensor_entity_id": "ID entity externého snímača teploty",
           "cycle_min": "Trvanie cyklu (minúty)",
           "temp_min": "Minimálna povolená teplota",
           "temp_max": "Maximálna povolená teplota",
+          "step_temperature": "Krok teploty",
           "device_power": "Výkon zariadenia (kW)",
-          "use_central_mode": "Povoliť ovládanie centrálnou entitou (potrebná centrálna konfigurácia)",
+          "use_central_mode": "Povoliť ovládanie centrálnou entitou (vyžaduje centrálnu konfiguráciu). Zaškrtnutím povolíte ovládanie VTherm pomocou vybraných entít central_mode.",
+          "use_main_central_config": "Použite dodatočnú centrálnu hlavnú konfiguráciu. Začiarknite, ak chcete použiť centrálnu hlavnú konfiguráciu (vonkajšia teplota, min, max, krok, ...).",
+          "used_by_controls_central_boiler": "Používa sa centrálnym kotlom. Skontrolujte, či má mať tento VTherm ovládanie na centrálnom kotli"
+        },
+        "data_description": {
+          "temperature_sensor_entity_id": "ID entity snímača izbovej teploty",
+          "last_seen_temperature_sensor_entity_id": "Naposledy videný snímač izbovej teploty ID entity. Mal by to byť snímač dátumu a času",
+          "external_temperature_sensor_entity_id": "ID entity snímača vonkajšej teploty. Nepoužíva sa, ak je zvolená centrálna konfigurácia"
+        }
+      },
+      "features": {
+        "title": "Vlastnosti - {name}",
+        "description": "Vlastnosti termostatu",
+        "data": {
           "use_window_feature": "Použite detekciu okien",
           "use_motion_feature": "Použite detekciu pohybu",
           "use_power_feature": "Použite správu napájania",
           "use_presence_feature": "Použite detekciu prítomnosti",
-          "use_main_central_config": "Použite centrálnu hlavnú konfiguráciu"
-        },
-        "data_description": {
-          "use_central_mode": "Zaškrtnutím povolíte ovládanie VTherm pomocou vybraných entít central_mode",
-          "use_main_central_config": "Začiarknite, ak chcete použiť centrálnu hlavnú konfiguráciu. Ak chcete použiť špecifickú konfiguráciu pre tento VTherm, zrušte začiarknutie",
-          "external_temperature_sensor_entity_id": "ID entity snímača vonkajšej teploty. Nepoužíva sa, ak je zvolená centrálna konfigurácia"
+          "use_central_boiler_feature": "Použite centrálny kotol. Začiarknutím tohto políčka pridáte ovládanie do centrálneho kotla. Po zaškrtnutí tohto políčka budete musieť nakonfigurovať VTherm, ktorý bude mať ovládanie centrálneho kotla, aby sa prejavilo. Ak jeden VTherm vyžaduje ohrev, kotol sa zapne. Ak žiadny VTherm nevyžaduje ohrev, kotol sa vypne. Príkazy na zapnutie/vypnutie centrálneho kotla sú uvedené na príslušnej konfiguračnej stránke"
         }
       },
       "type": {
@@ -277,6 +309,7 @@
           "heater_entity2_id": "2. spínač ohrievača",
           "heater_entity3_id": "3. spínač ohrievača",
           "heater_entity4_id": "4. spínač ohrievača",
+          "heater_keep_alive": "Prepnite interval udržiavania v sekundách",
           "proportional_function": "Algoritmus",
           "climate_entity_id": "Základná klíma",
           "climate_entity2_id": "2. základná klíma",
@@ -290,6 +323,7 @@
           "auto_regulation_mode": "Samoregulácia",
           "auto_regulation_dtemp": "Regulačný prah",
           "auto_regulation_periode_min": "Regulačné minimálne obdobie",
+          "auto_regulation_use_device_temp": "Použite vnútornú teplotu podkladu",
           "inverse_switch_command": "Inverzný prepínací príkaz",
           "auto_fan_mode": "Režim automatického ventilátora"
         },
@@ -298,6 +332,7 @@
           "heater_entity2_id": "Voliteľné ID entity 2. ohrievača. Ak sa nepoužíva, nechajte prázdne",
           "heater_entity3_id": "Voliteľné ID entity 3. ohrievača. Ak sa nepoužíva, nechajte prázdne",
           "heater_entity4_id": "Voliteľné ID entity 4. ohrievača. Ak sa nepoužíva, nechajte prázdne",
+          "heater_keep_alive": "Voliteľný interval obnovy stavu spínača ohrievača. Ak to nie je potrebné, nechajte prázdne.",
           "proportional_function": "Algoritmus, ktorý sa má použiť (TPI je zatiaľ jediný)",
           "climate_entity_id": "ID základnej klimatickej entity",
           "climate_entity2_id": "2. základný identifikátor klimatickej entity",
@@ -311,6 +346,7 @@
           "auto_regulation_mode": "Automatické nastavenie cieľovej teploty",
           "auto_regulation_dtemp": "Hranica v °, pod ktorou sa zmena teploty neodošle",
           "auto_regulation_periode_min": "Trvanie v minútach medzi dvoma aktualizáciami predpisov",
+          "auto_regulation_use_device_temp": "Na urýchlenie samoregulácie použite prípadný vnútorný snímač teploty podkladu",
           "inverse_switch_command": "V prípade spínača s pilotným vodičom a diódou možno budete musieť príkaz invertovať",
           "auto_fan_mode": "Automaticky aktivujte ventilátor, keď je potrebné veľké vykurovanie/chladenie"
         }
@@ -333,24 +369,7 @@
         "title": "Predvoľby - {name}",
         "description": "Pre každú predvoľbu zadajte cieľovú teplotu (0, ak chcete predvoľbu ignorovať)",
         "data": {
-          "eco_temp": "Teplota v predvoľbe Eco",
-          "comfort_temp": "Prednastavená teplota v komfortnom režime",
-          "boost_temp": "Teplota v prednastavení Boost",
-          "frost_temp": "Teplota v prednastavení Frost protection",
-          "eco_ac_temp": "Teplota v režime Eco prednastavená pre režim AC",
-          "comfort_ac_temp": "Teplota v režime Comfort je prednastavená pre režim AC",
-          "boost_ac_temp": "Prednastavená teplota v režime Boost pre režim AC",
           "use_presets_central_config": "Použite konfiguráciu centrálnych predvolieb"
-        },
-        "data_description": {
-          "eco_temp": "Teplota v predvoľbe Eco",
-          "comfort_temp": "Prednastavená teplota v komfortnom režime",
-          "boost_temp": "Teplota v prednastavení Boost",
-          "frost_temp": "Teplota v prednastavenej ochrane proti mrazu",
-          "eco_ac_temp": "Teplota v režime Eco prednastavená pre režim AC",
-          "comfort_ac_temp": "Teplota v režime Comfort je prednastavená pre režim AC",
-          "boost_ac_temp": "Prednastavená teplota v režime Boost pre režim AC",
-          "use_presets_central_config": "Začiarknite, ak chcete použiť konfiguráciu centrálnych predvolieb. Zrušte začiarknutie, ak chcete použiť špecifickú konfiguráciu predvolieb pre tento VTherm"
         }
       },
       "window": {
@@ -362,7 +381,8 @@
           "window_auto_open_threshold": "Prah poklesu teploty pre automatickú detekciu otvoreného okna (v °/hodina)",
           "window_auto_close_threshold": "Prahová hodnota zvýšenia teploty pre koniec automatickej detekcie (v °/hodina)",
           "window_auto_max_duration": "Maximálne trvanie automatickej detekcie otvoreného okna (v min)",
-          "use_window_central_config": "Použite centrálnu konfiguráciu okna"
+          "use_window_central_config": "Použite centrálnu konfiguráciu okna",
+          "window_action": "Akcia"
         },
         "data_description": {
           "window_sensor_entity_id": "Nechajte prázdne, ak nemáte použiť žiadny okenný senzor",
@@ -370,7 +390,8 @@
           "window_auto_open_threshold": "Odporúčaná hodnota: medzi 3 a 10. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
           "window_auto_close_threshold": "Odporúčaná hodnota: 0. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
           "window_auto_max_duration": "Odporúčaná hodnota: 60 (jedna hodina). Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
-          "use_window_central_config": "Začiarknite, ak chcete použiť konfiguráciu centrálneho okna. Zrušte začiarknutie, ak chcete použiť špecifickú konfiguráciu okna pre tento VTherm"
+          "use_window_central_config": "Začiarknite, ak chcete použiť konfiguráciu centrálneho okna. Zrušte začiarknutie, ak chcete použiť špecifickú konfiguráciu okna pre tento VTherm",
+          "window_action": "Akcia, ktorá sa má vykonať, ak sa okno zistí ako otvorené"
         }
       },
       "motion": {
@@ -410,29 +431,14 @@
         }
       },
       "presence": {
-        "title": "Riadenie prítomnosti",
-        "description": "Atribúty správy prítomnosti.\nPoskytuje senzor prítomnosti vášho domova (pravda, ak je niekto prítomný).\nPotom zadajte buď predvoľbu, ktorá sa má použiť, keď je senzor prítomnosti nepravdivý, alebo posun teploty, ktorý sa má použiť.\nAk je zadaná predvoľba, posun sa nepoužije.\nAk sa nepoužije, ponechajte zodpovedajúce entity_id prázdne.",
+        "title": "Prítommnosť - {name}",
+        "description": "Atribúty riadenia prítomnosti.\nPoskytuje senzor prítomnosti vášho domova (pravda, je niekto prítomný) a poskytuje zodpovedajúce prednastavené nastavenie teploty.",
         "data": {
-          "presence_sensor_entity_id": "ID entity senzora prítomnosti (pravda je prítomná)",
-          "eco_away_temp": "Teplota v prednastavenej Eco, keď nie je žiadna prítomnosť",
-          "comfort_away_temp": "Teplota v režime Comfort je prednastavená, keď nie je prítomný",
-          "boost_away_temp": "Prednastavená teplota v režime Boost, keď nie je prítomný",
-          "frost_away_temp": "Prednastavená teplota v režime Frost protection, keď nie je prítomný",
-          "eco_ac_away_temp": "Teplota v prednastavenej Eco, keď nie je prítomná v režime AC",
-          "comfort_ac_away_temp": "Teplota v režime Comfort je prednastavená, keď nie je prítomný v režime AC",
-          "boost_ac_away_temp": "Teplota v prednastavenom Boost, keď nie je prítomný v režime AC",
-          "use_presence_central_config": "Použite centrálnu konfiguráciu prítomnosti"
+          "presence_sensor_entity_id": "Senzor prítomnosti",
+          "use_presence_central_config": "Použite konfiguráciu centrálnej prítomnosti teploty. Ak chcete použiť špecifické entity teploty, zrušte začiarknutie"
         },
         "data_description": {
-          "presence_sensor_entity_id": "ID entity senzora prítomnosti",
-          "eco_away_temp": "Teplota v prednastavenej Eco, keď nie je žiadna prítomnosť",
-          "comfort_away_temp": "Teplota v režime Comfort je prednastavená, keď nie je prítomný",
-          "boost_away_temp": "Prednastavená teplota v režime Boost, keď nie je prítomný",
-          "frost_away_temp": "Teplota v Prednastavená ochrana pred mrazom, keď nie je prítomný",
-          "eco_ac_away_temp": "Teplota v prednastavenej Eco, keď nie je prítomná v režime AC",
-          "comfort_ac_away_temp": "Teplota v režime Comfort je prednastavená, keď nie je prítomný v režime AC",
-          "boost_ac_away_temp": "Teplota v prednastavenom Boost, keď nie je prítomný v režime AC",
-          "use_presence_central_config": "Začiarknite, ak chcete použiť konfiguráciu centrálnej prítomnosti. Zrušte začiarknutie, ak chcete použiť špecifickú konfiguráciu prítomnosti pre tento VTherm"
+          "presence_sensor_entity_id": "ID entity senzora prítomnosti"
         }
       },
       "advanced": {
@@ -458,7 +464,8 @@
       "unknown": "Neočakávaná chyba",
       "unknown_entity": "Neznáme ID entity",
       "window_open_detection_method": "Mala by sa použiť iba jedna metóda detekcie otvoreného okna. Použite senzor alebo automatickú detekciu cez teplotný prah, ale nie oboje",
-      "no_central_config": "Nemôžete zaškrtnúť „použiť centrálnu konfiguráciu“, pretože sa nenašla žiadna centrálna konfigurácia. Aby ste ho mohli používať, musíte si vytvoriť všestranný termostat typu „Central Configuration“."
+      "no_central_config": "Nemôžete zaškrtnúť „použiť centrálnu konfiguráciu“, pretože sa nenašla žiadna centrálna konfigurácia. Aby ste ho mohli používať, musíte si vytvoriť všestranný termostat typu „Central Configuration“.",
+      "service_configuration_format": "Formát konfigurácie služby je nesprávny"
     },
     "abort": {
       "already_configured": "Zariadenie je už nakonfigurované"
@@ -491,6 +498,22 @@
         "auto_fan_high": "Vysoký",
         "auto_fan_turbo": "Turbo"
       }
+    },
+    "window_action": {
+      "options": {
+        "window_turn_off": "Vypnúť",
+        "window_fan_only": "Len ventilátor",
+        "window_frost_temp": "Ochrana pred mrazom",
+        "window_eco_temp": "Eco"
+      }
+    },
+    "presets": {
+      "options": {
+        "frost": "Ochrana proti mrazu",
+        "eco": "Eco",
+        "comfort": "Komfort",
+        "boost": "Boost"
+      }
     }
   },
   "entity": {
@@ -506,6 +529,53 @@
           }
         }
       }
+    },
+    "number": {
+      "frost_temp": {
+        "name": "Mráz"
+      },
+      "eco_temp": {
+        "name": "Eco"
+      },
+      "comfort_temp": {
+        "name": "Komfort"
+      },
+      "boost_temp": {
+        "name": "Boost"
+      },
+      "frost_ac_temp": {
+        "name": "Mráz ac"
+      },
+      "eco_ac_temp": {
+        "name": "Eco ac"
+      },
+      "comfort_ac_temp": {
+        "name": "Komfort ac"
+      },
+      "boost_ac_temp": {
+        "name": "Boost ac"
+      },
+      "frost_away_temp": {
+        "name": "Mráz mimo"
+      },
+      "eco_away_temp": {
+        "name": "Eko mimo"
+      },
+      "comfort_away_temp": {
+        "name": "Komfort mimo"
+      },
+      "boost_away_temp": {
+        "name": "Boost mimo"
+      },
+      "eco_ac_away_temp": {
+        "name": "Eco ac mimo"
+      },
+      "comfort_ac_away_temp": {
+        "name": "Komfort ac mimo"
+      },
+      "boost_ac_away_temp": {
+        "name": "Boost ac mimo"
+      }
     }
   }
 }

custom_components/versatile_thermostat/underlyings.py

@@ -5,7 +5,7 @@ import logging
 from typing import Any
 from enum import StrEnum
 
-from homeassistant.const import ATTR_ENTITY_ID, STATE_ON, UnitOfTemperature
+from homeassistant.const import ATTR_ENTITY_ID, STATE_ON, STATE_UNAVAILABLE
 from homeassistant.core import State
 
 from homeassistant.exceptions import ServiceNotFound
@@ -30,6 +30,7 @@ from homeassistant.components.number import SERVICE_SET_VALUE
 
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.event import async_call_later
+from homeassistant.util.unit_conversion import TemperatureConverter
 
 from .const import UnknownEntity, overrides
 from .keep_alive import IntervalCaller
@@ -252,7 +253,28 @@ class UnderlyingSwitch(UnderlyingEntity):
 
     async def _keep_alive_callback(self):
         """Keep alive: Turn on if already turned on, turn off if already turned off."""
-        await (self.turn_on() if self.is_device_active else self.turn_off())
+        timer = self._keep_alive.backoff_timer
+        state: State | None = self._hass.states.get(self._entity_id)
+        # Normal, expected state.state values are "on" and "off". An absent
+        # underlying MQTT switch was observed to produce either state == None
+        # or state.state == STATE_UNAVAILABLE ("unavailable").
+        if state is None or state.state == STATE_UNAVAILABLE:
+            if timer.is_ready():
+                _LOGGER.warning(
+                    "Entity %s is not available (state: %s). Will keep trying "
+                    "keep alive calls, but won't log this condition every time.",
+                    self._entity_id,
+                    state.state if state else "None",
+                )
+        else:
+            if timer.in_progress:
+                timer.reset()
+                _LOGGER.warning(
+                    "Entity %s has recovered (state: %s).",
+                    self._entity_id,
+                    state.state,
+                )
+            await (self.turn_on() if self.is_device_active else self.turn_off())
 
     # @overrides this breaks some unit tests TypeError: object MagicMock can't be used in 'await' expression
     async def turn_off(self):
@@ -486,8 +508,8 @@ class UnderlyingClimate(UnderlyingEntity):
                 self._underlying_climate,
             )
         else:
-            _LOGGER.error(
-                "%s - Cannot find the underlying climate entity: %s. Thermostat will not be operational",
+            _LOGGER.info(
+                "%s - Cannot find the underlying climate entity: %s. Thermostat will not be operational. Will try later.",
                 self,
                 self.entity_id,
             )
@@ -590,12 +612,24 @@ class UnderlyingClimate(UnderlyingEntity):
         if not self.is_initialized:
             return
 
-        data = {
-            ATTR_ENTITY_ID: self._entity_id,
-            "temperature": self.cap_sent_value(temperature),
-            "target_temp_high": max_temp,
-            "target_temp_low": min_temp,
-        }
+        # Issue 508 we have to take care of service set_temperature or set_range
+        target_temp = self.cap_sent_value(temperature)
+        if (
+            ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
+            in self._underlying_climate.supported_features
+        ):
+            data = {
+                ATTR_ENTITY_ID: self._entity_id,
+                "target_temp_high": target_temp,
+                "target_temp_low": target_temp,
+                # issue 518 - we should send also the target temperature, even in TARGET RANGE
+                "temperature": target_temp,
+            }
+        else:
+            data = {
+                ATTR_ENTITY_ID: self._entity_id,
+                "temperature": target_temp,
+            }
 
         await self._hass.services.async_call(
             CLIMATE_DOMAIN,
@@ -663,7 +697,7 @@ class UnderlyingClimate(UnderlyingEntity):
     def temperature_unit(self) -> str:
         """Get the temperature_unit"""
         if not self.is_initialized:
-            return UnitOfTemperature.CELSIUS
+            return self._hass.config.units.temperature_unit
         return self._underlying_climate.temperature_unit
 
     @property
@@ -704,7 +738,7 @@ class UnderlyingClimate(UnderlyingEntity):
         if not hasattr(self._underlying_climate, "current_temperature"):
             return None
 
-        return self._underlying_climate.current_temperature
+        return self._hass.states.get(self._entity_id).attributes.get("current_temperature")
 
     def turn_aux_heat_on(self) -> None:
         """Turn auxiliary heater on."""
@@ -731,8 +765,12 @@ class UnderlyingClimate(UnderlyingEntity):
             self._underlying_climate.min_temp is not None
             and self._underlying_climate is not None
         ):
-            min_val = self._underlying_climate.min_temp
-            max_val = self._underlying_climate.max_temp
+            min_val = TemperatureConverter.convert(
+                self._underlying_climate.min_temp, self._underlying_climate.temperature_unit, self._hass.config.units.temperature_unit
+            )
+            max_val = TemperatureConverter.convert(
+                self._underlying_climate.max_temp, self._underlying_climate.temperature_unit, self._hass.config.units.temperature_unit
+            )
 
             new_value = max(min_val, min(value, max_val))
         else:
@@ -780,15 +818,19 @@ class UnderlyingValve(UnderlyingEntity):
         """Send the percent open to the underlying valve"""
         # This may fails if called after shutdown
         try:
-            data = {ATTR_ENTITY_ID: self._entity_id, "value": self._percent_open}
+            data = {"value": self._percent_open}
+            target = {ATTR_ENTITY_ID: self._entity_id}
             domain = self._entity_id.split(".")[0]
             await self._hass.services.async_call(
-                domain,
-                SERVICE_SET_VALUE,
-                data,
+                domain=domain,
+                service=SERVICE_SET_VALUE,
+                service_data=data,
+                target=target,
             )
         except ServiceNotFound as err:
             _LOGGER.error(err)
+            # This could happens in unit test if input_number domain is not yet loaded
+            # raise err
 
     async def turn_off(self):
         """Turn heater toggleable device off."""
@@ -840,8 +882,10 @@ class UnderlyingValve(UnderlyingEntity):
     ):
         """We use this function to change the on_percent"""
         if force:
-            self._percent_open = self.cap_sent_value(self._percent_open)
-            await self.send_percent_open()
+            # self._percent_open = self.cap_sent_value(self._percent_open)
+            # await self.send_percent_open()
+            # avoid to send 2 times the same value at startup
+            self.set_valve_open_percent()
 
     @overrides
     def cap_sent_value(self, value) -> float:
@@ -857,7 +901,7 @@ class UnderlyingValve(UnderlyingEntity):
             min_val = valve_state.attributes["min"]
             max_val = valve_state.attributes["max"]
 
-            new_value = round(max(min_val, min(value, max_val)))
+            new_value = round(max(min_val, min(value / 100 * max_val, max_val)))
         else:
             _LOGGER.debug("%s - no min and max attributes on underlying", self)
             new_value = value

custom_components/versatile_thermostat/vtherm_api.py

@@ -57,6 +57,7 @@ class VersatileThermostatAPI(dict):
         self._threshold_number_entity = None
         self._nb_active_number_entity = None
         self._central_configuration = None
+        self._central_mode_select = None
         # A dict that will store all Number entities which holds the temperature
         self._number_temperatures = dict()
 
@@ -149,8 +150,8 @@ class VersatileThermostatAPI(dict):
                 return entity.state
         return None
 
-    async def init_vtherm_links(self, only_use_central=False):
-        """INitialize all VTherms entities links
+    async def init_vtherm_links(self):
+        """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, ...)
         """
@@ -162,12 +163,34 @@ class VersatileThermostatAPI(dict):
         )
         if component:
             for entity in component.entities:
-                if hasattr(entity, "init_presets"):
-                    if (
-                        only_use_central is False
-                        or entity.use_central_config_temperature
-                    ):
-                        await entity.init_presets(self.find_central_configuration())
+                # if hasattr(entity, "init_presets"):
+                #     if (
+                #         only_use_central is False
+                #         or entity.use_central_config_temperature
+                #     ):
+                #         await entity.init_presets(self.find_central_configuration())
+
+                # A little hack to test if the climate is a VTherm. Cannot use isinstance due to circular dependency of BaseThermostat
+                if (
+                    entity.device_info
+                    and entity.device_info.get("model", None) == DOMAIN
+                ):
+                    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"""
+        # Initialization of all preset for all VTherm
+        component: EntityComponent[ClimateEntity] = self._hass.data.get(
+            CLIMATE_DOMAIN, None
+        )
+        if component:
+            for entity in component.entities:
+                if (
+                    entity.device_info
+                    and entity.device_info.get("model", None) == DOMAIN
+                    and entity.use_central_config_temperature
+                ):
+                    await entity.init_presets(self.find_central_configuration())
 
     async def reload_central_boiler_binary_listener(self):
         """Reloads the BinarySensor entity which listen to the number of
@@ -180,6 +203,27 @@ class VersatileThermostatAPI(dict):
         if self._nb_active_number_entity is not None:
             await self._nb_active_number_entity.listen_vtherms_entities()
 
+    def register_central_mode_select(self, central_mode_select):
+        """Register the select entity which holds the central_mode"""
+        self._central_mode_select = central_mode_select
+
+    async def notify_central_mode_change(self, old_central_mode: str | None = None):
+        """Notify all VTherm that the central_mode have change"""
+        if self._central_mode_select is None:
+            return
+
+        # Update all VTherm states
+        component: EntityComponent[ClimateEntity] = self.hass.data[CLIMATE_DOMAIN]
+        for entity in component.entities:
+            if entity.device_info and entity.device_info.get("model", None) == DOMAIN:
+                _LOGGER.debug(
+                    "Changing the central_mode. We have find %s to update",
+                    entity.name,
+                )
+                await entity.check_central_mode(
+                    self._central_mode_select.state, old_central_mode
+                )
+
     @property
     def self_regulation_expert(self):
         """Get the self regulation params"""
@@ -229,6 +273,14 @@ class VersatileThermostatAPI(dict):
             return None
         return int(self._threshold_number_entity.native_value)
 
+    @property
+    def central_mode(self) -> str | None:
+        """Get the current central mode or None"""
+        if self._central_mode_select:
+            return self._central_mode_select.state
+        else:
+            return None
+
     @property
     def hass(self):
         """Get the HomeAssistant object"""

hacs.json

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

requirements_dev.txt

@@ -1 +1 @@
-homeassistant==2024.3.1
+homeassistant==2024.9.3

tests/commons.py

@@ -435,6 +435,86 @@ class MagicMockClimate(MagicMock):
         return 19
 
 
+class MagicMockClimateWithTemperatureRange(MagicMock):
+    """A Magic Mock class for a underlying climate entity"""
+
+    @property
+    def temperature_unit(self):  # pylint: disable=missing-function-docstring
+        return UnitOfTemperature.CELSIUS
+
+    @property
+    def hvac_mode(self):  # pylint: disable=missing-function-docstring
+        return HVACMode.HEAT
+
+    @property
+    def hvac_action(self):  # pylint: disable=missing-function-docstring
+        return HVACAction.IDLE
+
+    @property
+    def target_temperature(self):  # pylint: disable=missing-function-docstring
+        return 15
+
+    @property
+    def current_temperature(self):  # pylint: disable=missing-function-docstring
+        return 14
+
+    @property
+    def target_temperature_step(  # pylint: disable=missing-function-docstring
+        self,
+    ) -> float | None:
+        return 0.5
+
+    @property
+    def target_temperature_high(  # pylint: disable=missing-function-docstring
+        self,
+    ) -> float | None:
+        return 35
+
+    @property
+    def target_temperature_low(  # pylint: disable=missing-function-docstring
+        self,
+    ) -> float | None:
+        return 7
+
+    @property
+    def hvac_modes(  # pylint: disable=missing-function-docstring
+        self,
+    ) -> list[str] | None:
+        return [HVACMode.HEAT, HVACMode.OFF, HVACMode.COOL]
+
+    @property
+    def fan_modes(  # pylint: disable=missing-function-docstring
+        self,
+    ) -> list[str] | None:
+        return None
+
+    @property
+    def swing_modes(  # pylint: disable=missing-function-docstring
+        self,
+    ) -> list[str] | None:
+        return None
+
+    @property
+    def fan_mode(self) -> str | None:  # pylint: disable=missing-function-docstring
+        return None
+
+    @property
+    def swing_mode(self) -> str | None:  # pylint: disable=missing-function-docstring
+        return None
+
+    @property
+    def supported_features(self):  # pylint: disable=missing-function-docstring
+        return ClimateEntityFeature.TARGET_TEMPERATURE_RANGE
+
+    @property
+    def min_temp(self):  # pylint: disable=missing-function-docstring
+        return 10
+
+    @property
+    def max_temp(self):  # pylint: disable=missing-function-docstring
+        return 31
+
+
 class MockSwitch(SwitchEntity):
     """A fake switch to be used instead real switch"""
 
@@ -472,7 +552,14 @@ class MockNumber(NumberEntity):
     """A fake switch to be used instead real switch"""
 
     def __init__(  # pylint: disable=unused-argument, dangerous-default-value
-        self, hass: HomeAssistant, unique_id, name, entry_infos={}
+        self,
+        hass: HomeAssistant,
+        unique_id,
+        name,
+        min=0,
+        max=100,
+        step=1,
+        entry_infos={},
     ):
         """Init the switch"""
         super().__init__()
@@ -482,7 +569,9 @@ class MockNumber(NumberEntity):
         self.entity_id = self.platform + "." + unique_id
         self._name = name
         self._attr_native_value = 0
-        self._attr_native_min_value = 0
+        self._attr_native_min_value = min
+        self._attr_native_max_value = max
+        self._attr_step = step
 
     @property
     def name(self) -> str:
@@ -580,6 +669,31 @@ async def send_temperature_change_event(
     return dearm_window_auto
 
 
+async def send_last_seen_temperature_change_event(
+    entity: BaseThermostat, date, sleep=True
+):
+    """Sending a new last seen event simulating a change on last seen temperature sensor"""
+    _LOGGER.info(
+        "------- Testu: sending send_last_seen_temperature_change_event, date=%s on %s",
+        date,
+        entity,
+    )
+    last_seen_event = Event(
+        EVENT_STATE_CHANGED,
+        {
+            "new_state": State(
+                entity_id=entity.entity_id,
+                state=date,
+                last_changed=date,
+                last_updated=date,
+            )
+        },
+    )
+    await entity._async_last_seen_temperature_changed(last_seen_event)
+    if sleep:
+        await asyncio.sleep(0.1)
+
+
 async def send_ext_temperature_change_event(
     entity: BaseThermostat, new_temp, date, sleep=True
 ):
@@ -882,3 +996,31 @@ async def set_climate_preset_temp(
     )
     if temp_entity:
         await temp_entity.async_set_native_value(temp)
+    else:
+        _LOGGER.warning(
+            "commons tests set_cliamte_preset_temp: cannot find number entity with entity_id '%s'",
+            number_entity_id,
+        )
+
+
+async def set_all_climate_preset_temp(
+    hass, vtherm: BaseThermostat, temps: dict, number_entity_base_name: str
+):
+    """Initialize all temp of preset for a VTherm entity"""
+    # We initialize
+    for preset_name, value in temps.items():
+
+        await set_climate_preset_temp(vtherm, preset_name, value)
+
+        # Search the number entity to control it is correctly set
+        number_entity_name = (
+            f"number.{number_entity_base_name}_preset_{preset_name}{PRESET_TEMP_SUFFIX}"
+        )
+        temp_entity: NumberEntity = search_entity(
+            hass,
+            number_entity_name,
+            NUMBER_DOMAIN,
+        )
+        assert temp_entity
+        # Because set_value is not implemented in Number class (really don't understand why...)
+        assert temp_entity.state == value

tests/test_auto_regulation.py

@@ -53,18 +53,6 @@ async def test_over_climate_regulation(
         return_value=fake_underlying_climate,
     ):
         entity = await create_thermostat(hass, entry, "climate.theoverclimatemockname")
-        # entry.add_to_hass(hass)
-        # await hass.config_entries.async_setup(entry.entry_id)
-        # assert entry.state is ConfigEntryState.LOADED
-        #
-        # def find_my_entity(entity_id) -> ClimateEntity:
-        #    """Find my new entity"""
-        #    component: EntityComponent[ClimateEntity] = hass.data[CLIMATE_DOMAIN]
-        #    for entity in component.entities:
-        #        if entity.entity_id == entity_id:
-        #            return entity
-        #
-        # entity: ThermostatOverClimate = find_my_entity("climate.theoverclimatemockname")
 
         assert entity
         assert isinstance(entity, ThermostatOverClimate)
@@ -163,18 +151,6 @@ async def test_over_climate_regulation_ac_mode(
         return_value=fake_underlying_climate,
     ):
         entity = await create_thermostat(hass, entry, "climate.theoverclimatemockname")
-        # entry.add_to_hass(hass)
-        # await hass.config_entries.async_setup(entry.entry_id)
-        # assert entry.state is ConfigEntryState.LOADED
-        #
-        # def find_my_entity(entity_id) -> ClimateEntity:
-        #     """Find my new entity"""
-        #     component: EntityComponent[ClimateEntity] = hass.data[CLIMATE_DOMAIN]
-        #     for entity in component.entities:
-        #         if entity.entity_id == entity_id:
-        #             return entity
-        #
-        # entity: ThermostatOverClimate = find_my_entity("climate.theoverclimatemockname")
 
         assert entity
         assert isinstance(entity, ThermostatOverClimate)
@@ -544,3 +520,112 @@ async def test_over_climate_regulation_use_device_temp(
                     ),
                 ]
             )
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_over_climate_regulation_dtemp_null(
+    hass: HomeAssistant, skip_hass_states_is_state, skip_send_event
+):
+    """Test the regulation of an over climate thermostat with no Dtemp limitation"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverClimateMockName",
+        unique_id="uniqueId",
+        # This is include a medium regulation
+        data=PARTIAL_CLIMATE_AC_CONFIG | {CONF_AUTO_REGULATION_DTEMP: 0, CONF_STEP_TEMPERATURE: 0.1},
+    )
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+    fake_underlying_climate = MockClimate(hass, "mockUniqueId", "MockClimateName", {})
+
+    # Creates the regulated VTherm over climate
+    # change temperature so that the heating will start
+    event_timestamp = now - timedelta(minutes=20)
+
+    with patch(
+        "custom_components.versatile_thermostat.commons.NowClass.get_now",
+        return_value=event_timestamp,
+    ), patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
+        return_value=fake_underlying_climate,
+    ):
+        entity = await create_thermostat(hass, entry, "climate.theoverclimatemockname")
+
+        assert entity
+        assert isinstance(entity, ThermostatOverClimate)
+
+        assert entity.name == "TheOverClimateMockName"
+        assert entity.is_over_climate is True
+        assert entity.is_regulated is True
+
+        # Activate the heating by changing HVACMode and temperature
+        # Select a hvacmode, presence and preset
+        await entity.async_set_hvac_mode(HVACMode.HEAT)
+        assert entity.hvac_mode is HVACMode.HEAT
+        assert entity.hvac_action == HVACAction.OFF
+
+        # change temperature so that the heating will start
+        await send_temperature_change_event(entity, 15, event_timestamp)
+        await send_ext_temperature_change_event(entity, 10, event_timestamp)
+
+        # set manual target temp
+        event_timestamp = now - timedelta(minutes=17)
+        with patch(
+            "custom_components.versatile_thermostat.commons.NowClass.get_now",
+            return_value=event_timestamp,
+        ):
+            await entity.async_set_temperature(temperature=20)
+
+            fake_underlying_climate.set_hvac_action(
+                HVACAction.HEATING
+            )  # simulate under cooling
+            assert entity.hvac_action == HVACAction.HEATING
+            assert entity.preset_mode == PRESET_NONE  # Manual mode
+
+            # the regulated temperature should be lower
+            assert entity.regulated_target_temp > entity.target_temperature
+            assert (
+                entity.regulated_target_temp == 20 + 2.4
+            )  # In medium we could go up to +3 degre
+            assert entity.hvac_action == HVACAction.HEATING
+
+        # change temperature so that the regulated temperature should slow down
+        event_timestamp = now - timedelta(minutes=15)
+        with patch(
+            "custom_components.versatile_thermostat.commons.NowClass.get_now",
+            return_value=event_timestamp,
+        ):
+            await send_temperature_change_event(entity, 19, event_timestamp)
+            await send_ext_temperature_change_event(entity, 10, event_timestamp)
+
+            # the regulated temperature should be greater
+            assert entity.regulated_target_temp > entity.target_temperature
+            assert entity.regulated_target_temp == 20 + 0.9
+
+            # change temperature so that the regulated temperature should slow down
+        event_timestamp = now - timedelta(minutes=13)
+        with patch(
+            "custom_components.versatile_thermostat.commons.NowClass.get_now",
+            return_value=event_timestamp,
+        ):
+            await send_temperature_change_event(entity, 20, event_timestamp)
+            await send_ext_temperature_change_event(entity, 10, event_timestamp)
+
+            # the regulated temperature should be greater
+            assert entity.regulated_target_temp > entity.target_temperature
+            assert entity.regulated_target_temp == 20 + 0.5
+
+        old_regulated_temp = entity.regulated_target_temp
+        # Test if a small temperature change is taken into account : change temperature so that dtemp < 0.5 and time is > period_min (+ 3min)
+        event_timestamp = now - timedelta(minutes=10)
+        with patch(
+            "custom_components.versatile_thermostat.commons.NowClass.get_now",
+            return_value=event_timestamp,
+        ):
+            await send_temperature_change_event(entity, 19.6, event_timestamp)
+            await send_ext_temperature_change_event(entity, 10, event_timestamp)
+
+            # the regulated temperature should be greater. This does not work if dtemp is not null
+            assert entity.regulated_target_temp > old_regulated_temp

tests/test_bugs.py

@@ -8,10 +8,22 @@ from datetime import datetime, timedelta
 
 import logging
 
+from homeassistant.core import HomeAssistant, State
 from homeassistant.components.climate import (
     SERVICE_SET_TEMPERATURE,
 )
 
+from custom_components.versatile_thermostat.config_flow import (
+    VersatileThermostatBaseConfigFlow,
+)
+from custom_components.versatile_thermostat.thermostat_valve import ThermostatOverValve
+from custom_components.versatile_thermostat.thermostat_climate import (
+    ThermostatOverClimate,
+)
+from custom_components.versatile_thermostat.thermostat_switch import (
+    ThermostatOverSwitch,
+)
+
 from .commons import *
 
 logging.getLogger().setLevel(logging.DEBUG)
@@ -657,8 +669,8 @@ async def test_bug_272(
                     {
                         "entity_id": "climate.mock_climate",
                         "temperature": 17.5,
-                        "target_temp_high": 30,
-                        "target_temp_low": 15,
+                        # "target_temp_high": 30,
+                        # "target_temp_low": 15,
                     },
                 ),
             ]
@@ -687,8 +699,8 @@ async def test_bug_272(
                     {
                         "entity_id": "climate.mock_climate",
                         "temperature": 15,  # the minimum acceptable
-                        "target_temp_high": 30,
-                        "target_temp_low": 15,
+                        # "target_temp_high": 30,
+                        # "target_temp_low": 15,
                     },
                 ),
             ]
@@ -714,8 +726,8 @@ async def test_bug_272(
                     {
                         "entity_id": "climate.mock_climate",
                         "temperature": 19,  # the maximum acceptable
-                        "target_temp_high": 30,
-                        "target_temp_low": 15,
+                        # "target_temp_high": 30,
+                        # "target_temp_low": 15,
                     },
                 ),
             ]
@@ -924,3 +936,443 @@ async def test_bug_339(
     assert api.nb_active_device_for_boiler == 1
 
     entity.remove_thermostat()
+
+
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_bug_508(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test that it not possible to set the target temperature under the min_temp setting"""
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverClimateMockName",
+        unique_id="uniqueId",
+        # default value are min 15°, max 31°, step 0.1
+        data=PARTIAL_CLIMATE_CONFIG,  # 5 minutes security delay
+    )
+
+    # Min_temp is 10 and max_temp is 31 and features contains TARGET_TEMPERATURE_RANGE
+    fake_underlying_climate = MagicMockClimateWithTemperatureRange()
+
+    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,
+    ), patch(
+        "homeassistant.core.ServiceRegistry.async_call"
+    ) as mock_service_call:
+        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
+        # The VTherm value and not the underlying value
+        assert entity.target_temperature_step == 0.1
+        assert entity.target_temperature == entity.min_temp
+        assert entity.is_regulated is True
+
+        assert mock_service_call.call_count == 0
+
+        # Set the hvac_mode to HEAT
+        await entity.async_set_hvac_mode(HVACMode.HEAT)
+
+        # Not In the accepted interval -> should be converted into 10 (the min) and send with target_temp_high and target_temp_low
+        await entity.async_set_temperature(temperature=8.5)
+
+        # MagicMock climate is already HEAT by default. So there is no SET_HAVC_MODE call
+        assert mock_service_call.call_count == 1
+        mock_service_call.assert_has_calls(
+            [
+                call.async_call(
+                    "climate",
+                    SERVICE_SET_TEMPERATURE,
+                    {
+                        "entity_id": "climate.mock_climate",
+                        # "temperature": 17.5,
+                        "target_temp_high": 10,
+                        "target_temp_low": 10,
+                        "temperature": 10,
+                    },
+                ),
+            ]
+        )
+
+    with patch("homeassistant.core.ServiceRegistry.async_call") as mock_service_call:
+        # Not In the accepted interval -> should be converted into 10 (the min) and send with target_temp_high and target_temp_low
+        await entity.async_set_temperature(temperature=32)
+
+        # MagicMock climate is already HEAT by default. So there is no SET_HAVC_MODE call
+        assert mock_service_call.call_count == 1
+        mock_service_call.assert_has_calls(
+            [
+                call.async_call(
+                    "climate",
+                    SERVICE_SET_TEMPERATURE,
+                    {
+                        "entity_id": "climate.mock_climate",
+                        "target_temp_high": 31,
+                        "target_temp_low": 31,
+                        "temperature": 31,
+                    },
+                ),
+            ]
+        )
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_bug_500_1(hass: HomeAssistant, init_vtherm_api) -> None:
+    """Test that the form is served with no input"""
+
+    config = {
+        CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+        CONF_USE_WINDOW_CENTRAL_CONFIG: True,
+        CONF_USE_POWER_CENTRAL_CONFIG: True,
+        CONF_USE_PRESENCE_CENTRAL_CONFIG: True,
+        CONF_USE_MOTION_FEATURE: True,
+        CONF_MOTION_SENSOR: "sensor.theMotionSensor",
+    }
+
+    flow = VersatileThermostatBaseConfigFlow(config)
+
+    assert flow._infos[CONF_USE_WINDOW_FEATURE] is True
+    assert flow._infos[CONF_USE_POWER_FEATURE] is True
+    assert flow._infos[CONF_USE_PRESENCE_FEATURE] is True
+    assert flow._infos[CONF_USE_MOTION_FEATURE] is True
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_bug_500_2(hass: HomeAssistant, init_vtherm_api) -> None:
+    """Test that the form is served with no input"""
+
+    config = {
+        CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+        CONF_USE_WINDOW_CENTRAL_CONFIG: False,
+        CONF_USE_POWER_CENTRAL_CONFIG: False,
+        CONF_USE_PRESENCE_CENTRAL_CONFIG: False,
+        CONF_USE_MOTION_FEATURE: False,
+    }
+
+    flow = VersatileThermostatBaseConfigFlow(config)
+
+    assert flow._infos[CONF_USE_WINDOW_FEATURE] is False
+    assert flow._infos[CONF_USE_POWER_FEATURE] is False
+    assert flow._infos[CONF_USE_PRESENCE_FEATURE] is False
+    assert flow._infos[CONF_USE_MOTION_FEATURE] is False
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_bug_500_3(hass: HomeAssistant, init_vtherm_api) -> None:
+    """Test that the form is served with no input"""
+
+    config = {
+        CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+        CONF_USE_WINDOW_CENTRAL_CONFIG: False,
+        CONF_WINDOW_SENSOR: "sensor.theWindowSensor",
+        CONF_USE_POWER_CENTRAL_CONFIG: False,
+        CONF_POWER_SENSOR: "sensor.thePowerSensor",
+        CONF_MAX_POWER_SENSOR: "sensor.theMaxPowerSensor",
+        CONF_USE_PRESENCE_CENTRAL_CONFIG: False,
+        CONF_PRESENCE_SENSOR: "sensor.thePresenceSensor",
+        CONF_USE_MOTION_FEATURE: True,  # motion sensor need to be checked AND a motion sensor set
+        CONF_MOTION_SENSOR: "sensor.theMotionSensor",
+    }
+
+    flow = VersatileThermostatBaseConfigFlow(config)
+
+    assert flow._infos[CONF_USE_WINDOW_FEATURE] is True
+    assert flow._infos[CONF_USE_POWER_FEATURE] is True
+    assert flow._infos[CONF_USE_PRESENCE_FEATURE] is True
+    assert flow._infos[CONF_USE_MOTION_FEATURE] is True
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_bug_524(hass: HomeAssistant, skip_hass_states_is_state):
+    """Test when switching from Cool to Heat the new temperature in Heat mode should be used"""
+
+    vtherm_api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(hass)
+
+    # The temperatures to set
+    temps = {
+        "frost": 7.0,
+        "eco": 17.0,
+        "comfort": 19.0,
+        "boost": 21.0,
+        "eco_ac": 27.0,
+        "comfort_ac": 25.0,
+        "boost_ac": 23.0,
+        "frost_away": 7.1,
+        "eco_away": 17.1,
+        "comfort_away": 19.1,
+        "boost_away": 21.1,
+        "eco_ac_away": 27.1,
+        "comfort_ac_away": 25.1,
+        "boost_ac_away": 23.1,
+    }
+
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverClimateMockName",
+        unique_id="overClimateUniqueId",
+        data={
+            CONF_NAME: "overClimate",
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: True,
+            CONF_PRESENCE_SENSOR: "binary_sensor.presence_sensor",
+            CONF_CLIMATE: "climate.mock_climate",
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_AUTO_FAN_MODE: CONF_AUTO_FAN_TURBO,
+            CONF_AC_MODE: True,
+        },
+        # | temps,
+    )
+
+    fake_underlying_climate = MockClimate(
+        hass=hass,
+        unique_id="mock_climate",
+        name="mock_climate",
+        hvac_modes=[HVACMode.OFF, HVACMode.COOL, HVACMode.HEAT, HVACMode.FAN_ONLY],
+    )
+
+    with patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
+        return_value=fake_underlying_climate,
+    ):
+        vtherm: ThermostatOverClimate = await create_thermostat(
+            hass, config_entry, "climate.overclimate"
+        )
+
+    assert vtherm is not None
+
+    # We search for NumberEntities
+    for preset_name, value in temps.items():
+
+        await set_climate_preset_temp(vtherm, preset_name, value)
+
+        temp_entity: NumberEntity = search_entity(
+            hass,
+            "number.overclimate_preset_" + preset_name + PRESET_TEMP_SUFFIX,
+            NUMBER_DOMAIN,
+        )
+        assert temp_entity
+        # Because set_value is not implemented in Number class (really don't understand why...)
+        assert temp_entity.state == value
+
+    # 1. Set mode to Heat and preset to Comfort
+    await send_presence_change_event(vtherm, True, False, datetime.now())
+    await vtherm.async_set_hvac_mode(HVACMode.HEAT)
+    await vtherm.async_set_preset_mode(PRESET_COMFORT)
+    await hass.async_block_till_done()
+
+    assert vtherm.target_temperature == 19.0
+
+    # 2. Only change the HVAC_MODE (and keep preset to comfort)
+    await vtherm.async_set_hvac_mode(HVACMode.COOL)
+    await hass.async_block_till_done()
+    assert vtherm.target_temperature == 25.0
+
+    # 3. Only change the HVAC_MODE (and keep preset to comfort)
+    await vtherm.async_set_hvac_mode(HVACMode.HEAT)
+    await hass.async_block_till_done()
+    assert vtherm.target_temperature == 19.0
+
+    # 4. Change presence to off
+    await send_presence_change_event(vtherm, False, True, datetime.now())
+    await hass.async_block_till_done()
+    assert vtherm.target_temperature == 19.1
+
+    # 5. Change hvac_mode to AC
+    await vtherm.async_set_hvac_mode(HVACMode.COOL)
+    await hass.async_block_till_done()
+    assert vtherm.target_temperature == 25.1
+
+    # 6. Change presence to on
+    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_bug_533(hass: HomeAssistant, skip_hass_states_is_state):
+    """Test that with an over_valve and _auto_regulation_dpercent is set that the valve could close totally"""
+
+    vtherm_api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(hass)
+
+    # The temperatures to set
+    temps = {
+        "frost": 7.0,
+        "eco": 17.0,
+        "comfort": 19.0,
+        "boost": 21.0,
+    }
+
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverValveMockName",
+        unique_id="overValveUniqueId",
+        data={
+            CONF_NAME: "overValve",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_VALVE,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.5,
+            CONF_TPI_COEF_EXT: 0,
+            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,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_VALVE: "number.mock_valve",
+            CONF_AUTO_REGULATION_DTEMP: 10,  # This parameter makes the bug
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 60,
+        },
+        # | temps,
+    )
+
+    # Not used because number is not registred so we can use directly the underlying number
+    # fake_underlying_number = MockNumber(
+    #     hass=hass, unique_id="mock_number", name="mock_number"
+    # )
+
+    vtherm: ThermostatOverClimate = await create_thermostat(
+        hass, config_entry, "climate.overvalve"
+    )
+
+    assert vtherm is not None
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    # Set all temps and check they are correctly initialized
+    await set_all_climate_preset_temp(hass, vtherm, temps, "overvalve")
+    await send_temperature_change_event(vtherm, 15, now)
+    await send_ext_temperature_change_event(vtherm, 15, now)
+
+    # 1. Set mode to Heat and preset to Comfort
+    await vtherm.async_set_hvac_mode(HVACMode.HEAT)
+    with patch(
+        "homeassistant.core.StateMachine.get",
+        return_value=State(
+            entity_id="number.mock_valve",
+            state="100",
+            attributes={"min": 0, "max": 100},
+        ),
+    ), patch("homeassistant.core.ServiceRegistry.async_call") as mock_service_call:
+        await vtherm.async_set_preset_mode(PRESET_COMFORT)
+        await hass.async_block_till_done()
+
+        assert vtherm.target_temperature == 19.0
+        assert mock_service_call.call_count == 1
+        mock_service_call.assert_has_calls(
+            [
+                call.async_call(
+                    domain="number",
+                    service="set_value",
+                    service_data={"value": 100},
+                    target={"entity_id": "number.mock_valve"},
+                ),
+            ]
+        )
+
+    # 2. set current temperature to 18 -> still 50% open, so there is a call
+    now = now + timedelta(minutes=1)
+    with patch(
+        "homeassistant.core.StateMachine.get",
+        return_value=State(
+            entity_id="number.mock_valve",
+            state="100",
+            attributes={"min": 0, "max": 100},
+        ),
+    ), patch("homeassistant.core.ServiceRegistry.async_call") as mock_service_call:
+        await send_temperature_change_event(vtherm, 18, now)
+        await hass.async_block_till_done()
+
+        assert mock_service_call.call_count == 1
+        mock_service_call.assert_has_calls(
+            [
+                call.async_call(
+                    domain="number",
+                    service="set_value",
+                    service_data={"value": 50},
+                    target={"entity_id": "number.mock_valve"},
+                ),
+            ]
+        )
+
+    # 3. set current temperature to 18.8 -> still 10% open, so there is one call
+    now = now + timedelta(minutes=1)
+    with patch(
+        "homeassistant.core.StateMachine.get",
+        return_value=State(
+            entity_id="number.mock_valve",
+            state="50",
+            attributes={"min": 0, "max": 100},
+        ),
+    ), patch("homeassistant.core.ServiceRegistry.async_call") as mock_service_call:
+        await send_temperature_change_event(vtherm, 18.8, now)
+        await hass.async_block_till_done()
+
+        assert mock_service_call.call_count == 1
+        mock_service_call.assert_has_calls(
+            [
+                call.async_call(
+                    domain="number",
+                    service="set_value",
+                    service_data={"value": 10},
+                    target={"entity_id": "number.mock_valve"},
+                ),
+            ]
+        )
+
+    # 4. set current temperature to 19 -> should have 0% open and one call to set the 0
+    now = now + timedelta(minutes=1)
+    with patch(
+        "homeassistant.core.StateMachine.get",
+        return_value=State(
+            entity_id="number.mock_valve",
+            state="10",  # the previous value
+            attributes={"min": 0, "max": 100},
+        ),
+    ), patch("homeassistant.core.ServiceRegistry.async_call") as mock_service_call:
+        await send_temperature_change_event(vtherm, 19, now)
+        await hass.async_block_till_done()
+
+        assert mock_service_call.call_count == 1
+        mock_service_call.assert_has_calls(
+            [
+                call.async_call(
+                    domain="number",
+                    service="set_value",
+                    service_data={"value": 0},
+                    target={"entity_id": "number.mock_valve"},
+                ),
+            ]
+        )

tests/test_central_boiler.py

@@ -69,7 +69,7 @@ async def test_add_a_central_config_with_boiler(
     assert api.nb_active_device_for_boiler == 0
 
     assert api.nb_active_device_for_boiler_threshold_entity is not None
-    assert api.nb_active_device_for_boiler_threshold is 1  # the default value is 1
+    assert api.nb_active_device_for_boiler_threshold == 1  # the default value is 1
 
 
 async def test_update_central_boiler_state_simple(
@@ -731,7 +731,7 @@ async def test_update_central_boiler_state_simple_climate(
         "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
         return_value=climate1,
     ):
-        entity: ThermostatOverValve = await create_thermostat(
+        entity: ThermostatOverClimate = await create_thermostat(
             hass, entry, "climate.theoverclimatemockname"
         )
         assert entity

tests/test_central_config.py

@@ -514,4 +514,4 @@ async def test_migration_of_central_config(
     assert api.nb_active_device_for_boiler == 0
 
     assert api.nb_active_device_for_boiler_threshold_entity is not None
-    assert api.nb_active_device_for_boiler_threshold is 1  # the default value is 1
+    assert api.nb_active_device_for_boiler_threshold == 1  # the default value is 1

tests/test_last_seen.py

@@ -0,0 +1,136 @@
+# pylint: disable=wildcard-import, unused-wildcard-import, protected-access, unused-argument, line-too-long
+
+""" Test the Security featrure """
+from unittest.mock import patch, call
+from datetime import timedelta, datetime
+import logging
+
+from custom_components.versatile_thermostat.thermostat_switch import (
+    ThermostatOverSwitch,
+)
+from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
+
+
+logging.getLogger().setLevel(logging.DEBUG)
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_last_seen_feature(hass: HomeAssistant, skip_hass_states_is_state):
+    """Test the last_ssen feature
+    1. creates a thermostat and check that security is off
+    2. activate security feature when date is expired
+    3. change the last seen sensor
+    4. check that security is off
+    """
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            "name": "TheOverSwitchMockName",
+            "thermostat_type": "thermostat_over_switch",
+            "temperature_sensor_entity_id": "sensor.mock_temp_sensor",
+            "last_seen_temperature_sensor_entity_id": "sensor.mock_last_seen_temp_sensor",
+            "external_temperature_sensor_entity_id": "sensor.mock_ext_temp_sensor",
+            "cycle_min": 5,
+            "temp_min": 15,
+            "temp_max": 30,
+            "frost_temp": 7,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            "use_window_feature": False,
+            "use_motion_feature": False,
+            "use_power_feature": False,
+            "use_presence_feature": False,
+            "heater_entity_id": "switch.mock_switch",
+            "proportional_function": "tpi",
+            "tpi_coef_int": 0.3,
+            "tpi_coef_ext": 0.01,
+            "minimal_activation_delay": 30,
+            "security_delay_min": 5,  # 5 minutes
+            "security_min_on_percent": 0.2,
+            "security_default_on_percent": 0.1,
+        },
+    )
+
+    # 1. creates a thermostat and check that security is off
+    now: datetime = datetime.now(tz=tz)
+    entity: ThermostatOverSwitch = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    assert entity._security_state is False
+    assert entity.preset_mode is not PRESET_SECURITY
+    assert entity._last_ext_temperature_measure is not None
+    assert entity._last_temperature_measure is not None
+    assert (entity._last_temperature_measure.astimezone(tz) - now).total_seconds() < 1
+    assert (
+        entity._last_ext_temperature_measure.astimezone(tz) - now
+    ).total_seconds() < 1
+
+    # set a preset
+    assert entity.preset_mode is PRESET_NONE
+    await entity.async_set_preset_mode(PRESET_COMFORT)
+    assert entity.preset_mode is PRESET_COMFORT
+
+    # Turn On the thermostat
+    assert entity.hvac_mode == HVACMode.OFF
+    await entity.async_set_hvac_mode(HVACMode.HEAT)
+    assert entity.hvac_mode == HVACMode.HEAT
+
+    # 2. activate security feature when date is expired
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on:
+        event_timestamp = now - timedelta(minutes=6)
+
+        # set temperature to 15 so that on_percent will be > security_min_on_percent (0.2)
+        await send_temperature_change_event(entity, 15, event_timestamp)
+        assert entity.security_state is True
+        assert entity.preset_mode == PRESET_SECURITY
+
+        assert mock_send_event.call_count == 3
+        mock_send_event.assert_has_calls(
+            [
+                call.send_event(EventType.PRESET_EVENT, {"preset": PRESET_SECURITY}),
+                call.send_event(
+                    EventType.TEMPERATURE_EVENT,
+                    {
+                        "last_temperature_measure": event_timestamp.isoformat(),
+                        "last_ext_temperature_measure": entity._last_ext_temperature_measure.isoformat(),
+                        "current_temp": 15,
+                        "current_ext_temp": None,
+                        "target_temp": 18,
+                    },
+                ),
+                call.send_event(
+                    EventType.SECURITY_EVENT,
+                    {
+                        "type": "start",
+                        "last_temperature_measure": event_timestamp.isoformat(),
+                        "last_ext_temperature_measure": entity._last_ext_temperature_measure.isoformat(),
+                        "current_temp": 15,
+                        "current_ext_temp": None,
+                        "target_temp": 18,
+                    },
+                ),
+            ],
+            any_order=True,
+        )
+
+        assert mock_heater_on.call_count == 1
+
+    # 3. change the last seen sensor
+    event_timestamp = now - timedelta(minutes=4)
+    await send_last_seen_temperature_change_event(entity, event_timestamp)
+    assert entity.security_state is False
+    assert entity.preset_mode is PRESET_COMFORT
+    assert entity._last_temperature_measure == event_timestamp

tests/test_movement.py

@@ -83,7 +83,7 @@ async def test_movement_management_time_not_enough(
         await send_ext_temperature_change_event(entity, 10, event_timestamp)
 
         await send_presence_change_event(entity, True, False, event_timestamp)
-        assert entity.presence_state is "on"
+        assert entity.presence_state == "on"
 
     # starts detecting motion with time not enough
     with patch(
@@ -110,7 +110,7 @@ async def test_movement_management_time_not_enough(
         assert entity.target_temperature == 18
         # state is not changed if time is not enough
         assert entity.motion_state is None
-        assert entity.presence_state is "on"
+        assert entity.presence_state == "on"
 
         assert mock_send_event.call_count == 0
         # Change is not confirmed
@@ -141,8 +141,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 is "on"
-        assert entity.presence_state is "on"
+        assert entity.motion_state == "on"
+        assert entity.presence_state == "on"
 
     # stop detecting motion with off delay too low
     with patch(
@@ -167,8 +167,8 @@ async def test_movement_management_time_not_enough(
         assert entity.preset_mode is PRESET_ACTIVITY
         # because no motion is detected yet
         assert entity.target_temperature == 19
-        assert entity.motion_state is "on"
-        assert entity.presence_state is "on"
+        assert entity.motion_state == "on"
+        assert entity.presence_state == "on"
 
         assert mock_send_event.call_count == 0
         # The heater must heat now
@@ -199,8 +199,8 @@ async def test_movement_management_time_not_enough(
         assert entity.preset_mode is PRESET_ACTIVITY
         # because no motion is detected yet
         assert entity.target_temperature == 18
-        assert entity.motion_state is "off"
-        assert entity.presence_state is "on"
+        assert entity.motion_state == "off"
+        assert entity.presence_state == "on"
 
         assert mock_send_event.call_count == 0
         # The heater must stop heating now
@@ -280,7 +280,7 @@ async def test_movement_management_time_enough_and_presence(
         await send_ext_temperature_change_event(entity, 10, event_timestamp)
 
         await send_presence_change_event(entity, True, False, event_timestamp)
-        assert entity.presence_state is "on"
+        assert entity.presence_state == "on"
 
     # starts detecting motion
     with patch(
@@ -302,8 +302,8 @@ async def test_movement_management_time_enough_and_presence(
         assert entity.preset_mode is PRESET_ACTIVITY
         # because motion is detected yet -> switch to Boost mode
         assert entity.target_temperature == 19
-        assert entity.motion_state is "on"
-        assert entity.presence_state is "on"
+        assert entity.motion_state == "on"
+        assert entity.presence_state == "on"
 
         assert mock_send_event.call_count == 0
         # Change is confirmed. Heater should be started
@@ -331,8 +331,8 @@ async def test_movement_management_time_enough_and_presence(
         assert entity.preset_mode is PRESET_ACTIVITY
         # because no motion is detected yet
         assert entity.target_temperature == 18
-        assert entity.motion_state is "off"
-        assert entity.presence_state is "on"
+        assert entity.motion_state == "off"
+        assert entity.presence_state == "on"
 
         assert mock_send_event.call_count == 0
         assert mock_heater_on.call_count == 0
@@ -412,7 +412,7 @@ async def test_movement_management_time_enoughand_not_presence(
         await send_ext_temperature_change_event(entity, 10, event_timestamp)
 
         await send_presence_change_event(entity, False, True, event_timestamp)
-        assert entity.presence_state is "off"
+        assert entity.presence_state == "off"
 
     # starts detecting motion
     with patch(
@@ -434,8 +434,8 @@ async def test_movement_management_time_enoughand_not_presence(
         assert entity.preset_mode is PRESET_ACTIVITY
         # because motion is detected yet -> switch to Boost away mode
         assert entity.target_temperature == 19.1
-        assert entity.motion_state is "on"
-        assert entity.presence_state is "off"
+        assert entity.motion_state == "on"
+        assert entity.presence_state == "off"
 
         assert mock_send_event.call_count == 0
         # Change is confirmed. Heater should be started
@@ -463,8 +463,8 @@ async def test_movement_management_time_enoughand_not_presence(
         assert entity.preset_mode is PRESET_ACTIVITY
         # because no motion is detected yet
         assert entity.target_temperature == 18.1
-        assert entity.motion_state is "off"
-        assert entity.presence_state is "off"
+        assert entity.motion_state == "off"
+        assert entity.presence_state == "off"
 
         assert mock_send_event.call_count == 0
         # 18.1 starts heating with a low on_percent
@@ -546,7 +546,7 @@ async def test_movement_management_with_stop_during_condition(
         await send_ext_temperature_change_event(entity, 10, event_timestamp)
 
         await send_presence_change_event(entity, False, True, event_timestamp)
-        assert entity.presence_state is "off"
+        assert entity.presence_state == "off"
 
     # starts detecting motion
     with patch(
@@ -569,7 +569,7 @@ async def test_movement_management_with_stop_during_condition(
         # because motion is detected yet -> switch to Boost mode
         assert entity.target_temperature == 18
         assert entity.motion_state is None
-        assert entity.presence_state is "off"
+        assert entity.presence_state == "off"
 
         # Send a stop detection
         event_timestamp = now - timedelta(minutes=4)
@@ -580,7 +580,7 @@ async def test_movement_management_with_stop_during_condition(
         assert entity.preset_mode is PRESET_ACTIVITY
         assert entity.target_temperature == 18
         assert entity.motion_state is None
-        assert entity.presence_state is "off"
+        assert entity.presence_state == "off"
 
         # Resend a start detection
         event_timestamp = now - timedelta(minutes=3)
@@ -592,10 +592,10 @@ async def test_movement_management_with_stop_during_condition(
         # still no motion detected
         assert entity.target_temperature == 18
         assert entity.motion_state is None
-        assert entity.presence_state is "off"
+        assert entity.presence_state == "off"
 
         await try_condition1(None)
         # We should have switch this time
         assert entity.target_temperature == 19 # Boost
-        assert entity.motion_state is "on"     # switch to movement on
-        assert entity.presence_state is "off"  # Non change
+        assert entity.motion_state == "on"     # switch to movement on
+        assert entity.presence_state == "off"  # Non change

tests/test_start.py

@@ -254,6 +254,9 @@ async def test_over_switch_deactivate_preset(
             CONF_HEATER_KEEP_ALIVE: 0,
             CONF_SECURITY_DELAY_MIN: 10,
             CONF_MINIMAL_ACTIVATION_DELAY: 10,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.6,
+            CONF_TPI_COEF_EXT: 0.01,
         },
     )
 

tests/test_switch_keep_alive.py

@@ -6,6 +6,7 @@ from unittest.mock import ANY, _Call, call, patch
 from datetime import datetime, timedelta
 from typing import cast
 
+from custom_components.versatile_thermostat.keep_alive import BackoffTimer
 from custom_components.versatile_thermostat.thermostat_switch import (
     ThermostatOverSwitch,
 )
@@ -52,6 +53,7 @@ class CommonMocks:
     hass: HomeAssistant
     thermostat: ThermostatOverSwitch
     mock_is_state: MagicMock
+    mock_get_state: MagicMock
     mock_service_call: MagicMock
     mock_async_track_time_interval: MagicMock
     mock_send_event: MagicMock
@@ -73,15 +75,18 @@ async def common_mocks(
         thermostat = cast(ThermostatOverSwitch, await create_thermostat(
             hass, config_entry, "climate.theoverswitchmockname"
         ))
-        yield CommonMocks(
-            config_entry=config_entry,
-            hass=hass,
-            thermostat=thermostat,
-            mock_is_state=mock_is_state,
-            mock_service_call=mock_service_call,
-            mock_async_track_time_interval=mock_async_track_time_interval,
-            mock_send_event=mock_send_event,
-        )
+        with patch("homeassistant.core.StateMachine.get") as mock_get_state:
+            mock_get_state.return_value.state = "off"
+            yield CommonMocks(
+                config_entry=config_entry,
+                hass=hass,
+                thermostat=thermostat,
+                mock_is_state=mock_is_state,
+                mock_get_state=mock_get_state,
+                mock_service_call=mock_service_call,
+                mock_async_track_time_interval=mock_async_track_time_interval,
+                mock_send_event=mock_send_event,
+            )
         # Clean the entity
         thermostat.remove_thermostat()
 
@@ -256,3 +261,123 @@ class TestKeepAlive:
                 call("switch", SERVICE_TURN_OFF, {"entity_id": "switch.mock_switch"}),
             ],
         )
+
+
+class TestBackoffTimer:
+    """Test the keep_alive.BackoffTimer helper class."""
+
+    def test_exponential_period_increase(self):
+        """Test that consecutive calls to is_ready() produce increasing wait periods."""
+        with patch(
+            "custom_components.versatile_thermostat.keep_alive.monotonic"
+        ) as mock_monotonic:
+            timer = BackoffTimer(
+                multiplier=2,
+                lower_limit_sec=30,
+                upper_limit_sec=86400,
+                initially_ready=True,
+            )
+            mock_monotonic.return_value = 100
+            assert timer.is_ready()
+            mock_monotonic.return_value = 129
+            assert not timer.is_ready()
+            mock_monotonic.return_value = 130
+            assert timer.is_ready()
+            mock_monotonic.return_value = 188
+            assert not timer.is_ready()
+            mock_monotonic.return_value = 189
+            assert not timer.is_ready()
+            mock_monotonic.return_value = 190
+            assert timer.is_ready()
+            mock_monotonic.return_value = 309
+            assert not timer.is_ready()
+
+    def test_the_upper_limit_option(self):
+        """Test the timer.in_progress property and the effect of timer.reset()."""
+        with patch(
+            "custom_components.versatile_thermostat.keep_alive.monotonic"
+        ) as mock_monotonic:
+            timer = BackoffTimer(
+                multiplier=2,
+                lower_limit_sec=30,
+                upper_limit_sec=50,
+                initially_ready=True,
+            )
+            mock_monotonic.return_value = 100
+            assert timer.is_ready()
+            mock_monotonic.return_value = 129
+            assert not timer.is_ready()
+            mock_monotonic.return_value = 130
+            assert timer.is_ready()
+            mock_monotonic.return_value = 178
+            assert not timer.is_ready()
+            mock_monotonic.return_value = 179
+            assert not timer.is_ready()
+            mock_monotonic.return_value = 180
+            assert timer.is_ready()
+            mock_monotonic.return_value = 229
+            assert not timer.is_ready()
+            mock_monotonic.return_value = 230
+            assert timer.is_ready()
+
+    def test_the_lower_limit_option(self):
+        """Test the timer.in_progress property and the effect of timer.reset()."""
+        with patch(
+            "custom_components.versatile_thermostat.keep_alive.monotonic"
+        ) as mock_monotonic:
+            timer = BackoffTimer(
+                multiplier=0.5,
+                lower_limit_sec=30,
+                upper_limit_sec=50,
+                initially_ready=True,
+            )
+            mock_monotonic.return_value = 100
+            assert timer.is_ready()
+            mock_monotonic.return_value = 129
+            assert not timer.is_ready()
+            mock_monotonic.return_value = 130
+            assert timer.is_ready()
+            mock_monotonic.return_value = 158
+            assert not timer.is_ready()
+            mock_monotonic.return_value = 159
+            assert not timer.is_ready()
+            mock_monotonic.return_value = 160
+            assert timer.is_ready()
+
+    def test_initial_is_ready_result(self):
+        """Test that the first call to is_ready() produces the initially_ready option value."""
+        with patch(
+            "custom_components.versatile_thermostat.keep_alive.monotonic"
+        ) as mock_monotonic:
+            for initial in [True, False]:
+                timer = BackoffTimer(
+                    multiplier=2,
+                    lower_limit_sec=30,
+                    upper_limit_sec=86400,
+                    initially_ready=initial,
+                )
+                mock_monotonic.return_value = 100
+                assert timer.is_ready() == initial
+                assert not timer.is_ready()
+
+    def test_in_progress_and_reset(self):
+        """Test the timer.in_progress property and the effect of timer.reset()."""
+        with patch(
+            "custom_components.versatile_thermostat.keep_alive.monotonic"
+        ) as mock_monotonic:
+            timer = BackoffTimer(
+                multiplier=2,
+                lower_limit_sec=30,
+                upper_limit_sec=86400,
+                initially_ready=True,
+            )
+            mock_monotonic.return_value = 100
+            assert not timer.in_progress
+            assert timer.is_ready()
+            assert timer.in_progress
+            assert not timer.is_ready()
+            timer.reset()
+            assert not timer.in_progress
+            assert timer.is_ready()
+            assert timer.in_progress
+            assert not timer.is_ready()

tests/test_temp_number.py

@@ -79,6 +79,7 @@ async def test_add_number_for_central_config(
             CONF_SECURITY_MIN_ON_PERCENT: 0.5,
             CONF_SECURITY_DEFAULT_ON_PERCENT: 0.2,
             CONF_USE_CENTRAL_BOILER_FEATURE: False,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
         }
         | temps,
     )
@@ -156,6 +157,7 @@ async def test_add_number_for_central_config_without_temp(
             CONF_TEMP_MAX: 30,
             CONF_TPI_COEF_INT: 0.5,
             CONF_TPI_COEF_EXT: 0.02,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
             CONF_WINDOW_DELAY: 15,
             CONF_WINDOW_AUTO_OPEN_THRESHOLD: 4,
             CONF_WINDOW_AUTO_CLOSE_THRESHOLD: 1,
@@ -250,6 +252,7 @@ async def test_add_number_for_central_config_without_temp_ac_mode(
             CONF_AC_MODE: True,
             CONF_TPI_COEF_INT: 0.5,
             CONF_TPI_COEF_EXT: 0.02,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
             CONF_WINDOW_DELAY: 15,
             CONF_WINDOW_AUTO_OPEN_THRESHOLD: 4,
             CONF_WINDOW_AUTO_CLOSE_THRESHOLD: 1,
@@ -343,6 +346,7 @@ async def test_add_number_for_central_config_without_temp_restore(
             CONF_AC_MODE: False,
             CONF_TPI_COEF_INT: 0.5,
             CONF_TPI_COEF_EXT: 0.02,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
             CONF_WINDOW_DELAY: 15,
             CONF_WINDOW_AUTO_OPEN_THRESHOLD: 4,
             CONF_WINDOW_AUTO_CLOSE_THRESHOLD: 1,
@@ -441,6 +445,7 @@ async def test_add_number_for_over_switch_use_central(
             CONF_AC_MODE: False,
             CONF_TPI_COEF_INT: 0.5,
             CONF_TPI_COEF_EXT: 0.02,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
             CONF_USE_PRESENCE_CENTRAL_CONFIG: True,
             CONF_USE_ADVANCED_CENTRAL_CONFIG: True,
             CONF_USE_MAIN_CENTRAL_CONFIG: True,
@@ -666,6 +671,7 @@ async def test_add_number_for_over_switch_use_central_presets_and_restore(
             CONF_AC_MODE: False,
             CONF_TPI_COEF_INT: 0.5,
             CONF_TPI_COEF_EXT: 0.02,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
             CONF_CYCLE_MIN: 5,
             CONF_HEATER: "switch.mock_switch1",
             CONF_USE_PRESENCE_FEATURE: True,
@@ -788,6 +794,7 @@ async def test_change_central_config_temperature(
             CONF_TEMP_MAX: 30,
             CONF_TPI_COEF_INT: 0.5,
             CONF_TPI_COEF_EXT: 0.02,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
             CONF_CYCLE_MIN: 5,
             CONF_VALVE: "switch.mock_valve",
             CONF_USE_PRESENCE_FEATURE: True,
@@ -823,6 +830,7 @@ async def test_change_central_config_temperature(
             CONF_TPI_COEF_INT: 0.5,
             CONF_TPI_COEF_EXT: 0.02,
             CONF_CYCLE_MIN: 5,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
             CONF_VALVE: "switch.mock_valve",
             CONF_USE_PRESENCE_FEATURE: True,
             CONF_USE_PRESENCE_CENTRAL_CONFIG: False,
@@ -905,6 +913,7 @@ async def test_change_vtherm_temperature(
             CONF_TPI_COEF_INT: 0.5,
             CONF_TPI_COEF_EXT: 0.02,
             CONF_CYCLE_MIN: 5,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
             CONF_VALVE: "switch.mock_valve",
             CONF_USE_PRESENCE_FEATURE: True,
             CONF_USE_PRESENCE_CENTRAL_CONFIG: True,
@@ -939,6 +948,7 @@ async def test_change_vtherm_temperature(
             CONF_TPI_COEF_INT: 0.5,
             CONF_TPI_COEF_EXT: 0.02,
             CONF_CYCLE_MIN: 5,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
             CONF_VALVE: "switch.mock_valve",
             CONF_USE_PRESENCE_FEATURE: True,
             CONF_USE_PRESENCE_CENTRAL_CONFIG: False,
@@ -1022,6 +1032,7 @@ async def test_change_vtherm_temperature_with_presence(
             CONF_TEMP_MAX: 30,
             CONF_TPI_COEF_INT: 0.5,
             CONF_TPI_COEF_EXT: 0.02,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
             CONF_CYCLE_MIN: 5,
             CONF_AC_MODE: True,
             CONF_VALVE: "switch.mock_valve",
@@ -1063,6 +1074,7 @@ async def test_change_vtherm_temperature_with_presence(
             CONF_TEMP_MAX: 30,
             CONF_TPI_COEF_INT: 0.5,
             CONF_TPI_COEF_EXT: 0.02,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
             CONF_CYCLE_MIN: 5,
             CONF_VALVE: "switch.mock_valve",
             CONF_USE_PRESENCE_FEATURE: True,

tests/test_tpi.py

@@ -3,7 +3,10 @@
 from homeassistant.components.climate import HVACMode
 
 from custom_components.versatile_thermostat.base_thermostat import BaseThermostat
-from custom_components.versatile_thermostat.prop_algorithm import PropAlgorithm
+from custom_components.versatile_thermostat.prop_algorithm import (
+    PropAlgorithm,
+    PROPORTIONAL_FUNCTION_TPI,
+)
 from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
 
 
@@ -121,3 +124,123 @@ async def test_tpi_calculation(
     assert tpi_algo.calculated_on_percent == 0
     assert tpi_algo.on_time_sec == 0
     assert tpi_algo.off_time_sec == 300
+
+
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_wrong_tpi_parameters(
+    hass: HomeAssistant, skip_hass_states_is_state: None
+):  # pylint: disable=unused-argument
+    """Test the wrong TPI parameters"""
+
+    # Nominal case
+    try:
+        algo = PropAlgorithm(
+            PROPORTIONAL_FUNCTION_TPI,
+            0.6,
+            0.01,
+            5,
+            1,
+            "entity_id",
+        )
+        # We should not be there
+        assert True
+    except TypeError as e:
+        # the normal case
+        assert False
+
+    # Test TPI function
+    try:
+        algo = PropAlgorithm(
+            "WRONG",
+            1,
+            0,
+            2,
+            3,
+            "entity_id",
+        )
+        # We should not be there
+        assert False
+    except TypeError as e:
+        # the normal case
+        pass
+
+    # Test coef_int
+    try:
+        algo = PropAlgorithm(
+            PROPORTIONAL_FUNCTION_TPI,
+            None,
+            0,
+            2,
+            3,
+            "entity_id",
+        )
+        # We should not be there
+        assert False
+    except TypeError as e:
+        # the normal case
+        pass
+
+    # Test coef_ext
+    try:
+        algo = PropAlgorithm(
+            PROPORTIONAL_FUNCTION_TPI,
+            0.6,
+            None,
+            2,
+            3,
+            "entity_id",
+        )
+        # We should not be there
+        assert False
+    except TypeError as e:
+        # the normal case
+        pass
+
+    # Test cycle_min
+    try:
+        algo = PropAlgorithm(
+            PROPORTIONAL_FUNCTION_TPI,
+            0.6,
+            0.00001,
+            None,
+            3,
+            "entity_id",
+        )
+        # We should not be there
+        assert False
+    except TypeError as e:
+        # the normal case
+        pass
+
+    # Test minimal_activation_delay
+    try:
+        algo = PropAlgorithm(
+            PROPORTIONAL_FUNCTION_TPI,
+            0.6,
+            0.00001,
+            0,
+            None,
+            "entity_id",
+        )
+        # We should not be there
+        assert False
+    except TypeError as e:
+        # the normal case
+        pass
+
+    # Test vtherm_entity_id
+    try:
+        algo = PropAlgorithm(
+            PROPORTIONAL_FUNCTION_TPI,
+            0.6,
+            0.00001,
+            0,
+            12,
+            None,
+        )
+        # We should not be there
+        assert False
+    except TypeError as e:
+        # the normal case
+        pass

tests/test_valve.py

@@ -74,22 +74,12 @@ async def test_over_valve_full_start(
     tz = get_tz(hass)  # pylint: disable=invalid-name
     now: datetime = datetime.now(tz=tz)
 
+    # 1. create the entity
     with patch(
         "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
     ) as mock_send_event:
-        entry.add_to_hass(hass)
-        await hass.config_entries.async_setup(entry.entry_id)
-        assert entry.state is ConfigEntryState.LOADED
 
-        def find_my_entity(entity_id) -> ClimateEntity:
-            """Find my new entity"""
-            component: EntityComponent[ClimateEntity] = hass.data[CLIMATE_DOMAIN]
-            for entity in component.entities:
-                if entity.entity_id == entity_id:
-                    return entity
-
-        # The name is in the CONF and not the title of the entry
-        entity: ThermostatOverValve = find_my_entity("climate.theovervalvemockname")
+        entity = await create_thermostat(hass, entry, "climate.theovervalvemockname")
 
         assert entity
         assert isinstance(entity, ThermostatOverValve)
@@ -130,7 +120,7 @@ async def test_over_valve_full_start(
             ]
         )
 
-    # Set the HVACMode to HEAT, with manual preset and target_temp to 18 before receiving temperature
+    # 2. Set the HVACMode to HEAT, with manual preset and target_temp to 18 before receiving temperature
     with patch(
         "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
     ) as mock_send_event:
@@ -158,7 +148,7 @@ async def test_over_valve_full_start(
         # Nothing have changed cause we don't have room and external temperature
         assert mock_send_event.call_count == 1
 
-    # Set temperature and external temperature
+    # 3. Set temperature and external temperature
     with patch(
         "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
     ) as mock_send_event, patch(
@@ -181,14 +171,18 @@ async def test_over_valve_full_start(
         mock_service_call.assert_has_calls(
             [
                 call.async_call(
-                    "number",
-                    "set_value",
-                    {"entity_id": "number.mock_valve", "value": 90},
+                    domain="number",
+                    service="set_value",
+                    service_data={"value": 90},
+                    target={"entity_id": "number.mock_valve"},
+                    # {"entity_id": "number.mock_valve", "value": 90},
                 ),
                 call.async_call(
-                    "number",
-                    "set_value",
-                    {"entity_id": "number.mock_valve", "value": 98},
+                    domain="number",
+                    service="set_value",
+                    service_data={"value": 98},
+                    target={"entity_id": "number.mock_valve"},
+                    # {"entity_id": "number.mock_valve", "value": 98},
                 ),
             ]
         )
@@ -216,7 +210,7 @@ async def test_over_valve_full_start(
         assert entity.is_device_active is True
         assert entity.hvac_action == HVACAction.HEATING
 
-    # Change internal temperature
+    # 4. Change internal temperature
     expected_state = State(
         entity_id="number.mock_valve", state="0", attributes={"min": 10, "max": 50}
     )
@@ -241,9 +235,10 @@ async def test_over_valve_full_start(
         mock_service_call.assert_has_calls(
             [
                 call.async_call(
-                    "number",
-                    "set_value",
-                    {"entity_id": "number.mock_valve", "value": 10},
+                    domain="number",
+                    service="set_value",
+                    service_data={"value": 10},
+                    target={"entity_id": "number.mock_valve"},
                 )
             ]
         )
@@ -254,20 +249,18 @@ async def test_over_valve_full_start(
         mock_service_call.assert_has_calls(
             [
                 call.async_call(
-                    "number",
-                    "set_value",
-                    {
-                        "entity_id": "number.mock_valve",
-                        "value": 10,
-                    },  # the min allowed value
+                    domain="number",
+                    service="set_value",
+                    service_data={"value": 10},
+                    target={"entity_id": "number.mock_valve"},  # the min allowed value
                 ),
                 call.async_call(
-                    "number",
-                    "set_value",
-                    {
-                        "entity_id": "number.mock_valve",
-                        "value": 50,
-                    },  # the max allowed value
+                    domain="number",
+                    service="set_value",
+                    service_data={
+                        "value": 34
+                    },  # 34 is 50 x open_percent (69%) and is the max allowed value
+                    target={"entity_id": "number.mock_valve"},
                 ),
             ]
         )
@@ -286,9 +279,9 @@ async def test_over_valve_full_start(
         assert entity.is_device_active is True
         assert entity.hvac_action == HVACAction.HEATING
 
-    # Test window open/close (with a normal min/max so that is_device_active is False when open_percent is 0)
+    # 5. Test window open/close (with a normal min/max so that is_device_active is False when open_percent is 0)
     expected_state = State(
-        entity_id="number.mock_valve", state="0", attributes={"min": 0, "max": 99}
+        entity_id="number.mock_valve", state="0", attributes={"min": 0, "max": 255}
     )
 
     with patch(
@@ -466,9 +459,10 @@ async def test_over_valve_regulation(
         mock_service_call.assert_has_calls(
             [
                 call.async_call(
-                    "number",
-                    "set_value",
-                    {"entity_id": "number.mock_valve", "value": 90},
+                    domain="number",
+                    service="set_value",
+                    service_data={"value": 90},
+                    target={"entity_id": "number.mock_valve"},
                 ),
             ]
         )
@@ -524,9 +518,10 @@ async def test_over_valve_regulation(
         mock_service_call.assert_has_calls(
             [
                 call.async_call(
-                    "number",
-                    "set_value",
-                    {"entity_id": "number.mock_valve", "value": 96},
+                    domain="number",
+                    service="set_value",
+                    service_data={"value": 96},
+                    target={"entity_id": "number.mock_valve"},
                 ),
             ]
         )