Issue 444 ha 2024.04.3 (#452 )

* HA 2024.4.3 and release * [#444] - fix initial temp values with standalone presets --------- Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>
HA 2024.4.3 and release (#447 )
2024-04-23 07:58:22 +02:00 · 2024-04-16 08:54:59 +02:00 · 2024-04-16 07:14:38 +02:00 · 2024-04-15 08:06:07 +02:00 · 2024-04-08 05:33:56 +00:00 · 2024-04-01 12:34:18 +02:00
25 changed files with 763 additions and 280 deletions
--- a/.devcontainer/configuration.yaml
+++ b/.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:
--- a/README-fr.md
+++ b/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 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 ?

@@ -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>

--- a/README.md
+++ b/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 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>

--- a/custom_components/versatile_thermostat/init.py
+++ b/custom_components/versatile_thermostat/init.py
@@ -107,6 +107,8 @@ 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()
@@ -156,8 +158,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

--- a/custom_components/versatile_thermostat/base_thermostat.py
+++ b/custom_components/versatile_thermostat/base_thermostat.py
@@ -68,6 +68,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 +243,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
@@ -393,6 +397,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 +532,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 +581,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 +645,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 +654,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 +844,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 +873,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 +1063,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:
@@ -1238,6 +1261,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
        )
@@ -1441,6 +1489,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")
@@ -2085,6 +2171,8 @@ class BaseThermostat(ClimateEntity, RestoreEntity, Generic[T]):
            new_central_mode,
        )

+        first_init = self._last_central_mode == None
+
        self._last_central_mode = new_central_mode

        def save_all():
@@ -2093,7 +2181,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 +2330,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 +2362,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 +2597,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 +2795,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)

--- a/custom_components/versatile_thermostat/config_schema.py
+++ b/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,
--- a/custom_components/versatile_thermostat/const.py
+++ b/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"
--- a/custom_components/versatile_thermostat/manifest.json
+++ b/custom_components/versatile_thermostat/manifest.json
@@ -14,6 +14,6 @@
  "quality_scale": "silver",
  "requirements": [],
  "ssdp": [],
-  "version": "6.0.2",
+  "version": "6.2.3",
  "zeroconf": []
 }
--- a/custom_components/versatile_thermostat/number.py
+++ b/custom_components/versatile_thermostat/number.py
@@ -11,6 +11,9 @@ 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,
@@ -53,6 +56,7 @@ from .const import (
    CONF_USE_PRESENCE_FEATURE,
    CONF_USE_CENTRAL_BOILER_FEATURE,
    overrides,
+    CONF_USE_MAIN_CENTRAL_CONFIG,
 )

 PRESET_ICON_MAPPING = {
@@ -341,7 +345,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 +360,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}"
@@ -395,9 +402,11 @@ class TemperatureNumber(  # pylint: disable=abstract-method
        self._attr_device_class = NumberDeviceClass.TEMPERATURE
        self._attr_native_unit_of_measurement = UnitOfTemperature.CELSIUS

-        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 +468,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 +487,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}"

@@ -485,3 +500,26 @@ class TemperatureNumber(  # pylint: disable=abstract-method
        if not self.my_climate:
            return UnitOfTemperature.CELSIUS
        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
+            )
--- a/custom_components/versatile_thermostat/prop_algorithm.py
+++ b/custom_components/versatile_thermostat/prop_algorithm.py
@@ -24,16 +24,19 @@ 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,
        )
+        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,7 +60,10 @@ 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:
@@ -83,7 +89,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 +98,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 +118,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 +137,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 +148,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()

--- a/custom_components/versatile_thermostat/select.py
+++ b/custom_components/versatile_thermostat/select.py
@@ -18,6 +18,9 @@ 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 +99,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:
@@ -122,17 +128,9 @@ class CentralModeSelect(SelectEntity, RestoreEntity):

    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}"
--- a/custom_components/versatile_thermostat/sensor.py
+++ b/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
--- a/custom_components/versatile_thermostat/strings.json
+++ b/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"
        }
      },
@@ -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"
        }
      },
@@ -572,4 +578,4 @@
      }
    }
  }
-}
+}
--- a/custom_components/versatile_thermostat/thermostat_climate.py
+++ b/custom_components/versatile_thermostat/thermostat_climate.py
@@ -581,7 +581,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,
--- a/custom_components/versatile_thermostat/thermostat_switch.py
+++ b/custom_components/versatile_thermostat/thermostat_switch.py
@@ -88,6 +88,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 +199,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,
--- a/custom_components/versatile_thermostat/thermostat_valve.py
+++ b/custom_components/versatile_thermostat/thermostat_valve.py
@@ -105,6 +105,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)]
@@ -278,7 +279,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,
--- a/custom_components/versatile_thermostat/translations/en.json
+++ b/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"
        }
      },
@@ -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"
        }
      },
@@ -572,4 +578,4 @@
      }
    }
  }
-}
+}
--- a/custom_components/versatile_thermostat/translations/fr.json
+++ b/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": {
--- a/custom_components/versatile_thermostat/underlyings.py
+++ b/custom_components/versatile_thermostat/underlyings.py
@@ -486,8 +486,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,
            )
@@ -780,15 +780,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."""
@@ -857,7 +861,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
--- a/custom_components/versatile_thermostat/vtherm_api.py
+++ b/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"""
--- a/hacs.json
+++ b/hacs.json
@@ -3,5 +3,5 @@
    "content_in_root": false,
    "render_readme": true,
    "hide_default_branch": false,
-    "homeassistant": "2024.3.1"
+    "homeassistant": "2024.4.3"
 }
--- a/requirements_dev.txt
+++ b/requirements_dev.txt
@@ -1 +1 @@
-homeassistant==2024.3.1
+homeassistant==2024.4.3
--- a/tests/commons.py
+++ b/tests/commons.py
@@ -580,6 +580,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
 ):
--- a/tests/test_last_seen.py
+++ b/tests/test_last_seen.py
@@ -0,0 +1,139 @@
+# 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_climate import (
+    ThermostatOverClimate,
+)
+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
--- a/tests/test_valve.py
+++ b/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"},
                ),
            ]
        )
Author	SHA1	Message	Date
Jean-Marc Collin	7b657ffabf	Issue 444 ha 2024.04.3 (#452 ) * HA 2024.4.3 and release * [#444] - fix initial temp values with standalone presets --------- Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-04-23 07:58:22 +02:00
Jean-Marc Collin	acd22d1fc4	HA 2024.4.3 and release (#447 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-04-16 08:54:59 +02:00
Jean-Marc Collin	d6f33d5796	[#438 ] - manage total_energy none until restored or calculated (#446 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-04-16 07:14:38 +02:00
Jean-Marc Collin	c1ebb46ac6	[#358 ] - Block preset_mode change on central_mode status (#445 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-04-15 08:06:07 +02:00
Jean-Marc Collin	eee4a9c4e3	Beers !	2024-04-08 05:33:56 +00:00
Jean-Marc Collin	2a3d3ff877	[#429 ] - VTherm doesn't respect target temperature (#435 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-04-01 12:34:18 +02:00
Jean-Marc Collin	a9c368d64c	Release 6.2.0	2024-03-31 18:48:47 +00:00
Jean-Marc Collin	1595ff32a2	[#432 ] - Use valve number max value instead of 100 (#434 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-03-31 20:47:04 +02:00
Jean-Marc Collin	c49545d9e3	[#398 ] - Add last_seen sensor to update temperature last datetime (#433 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-03-31 20:25:34 +02:00
Jean-Marc Collin	f4598a407e	Ajout incompatibilité Airwell	2024-03-31 16:57:32 +00:00
Jean-Marc Collin	d96fe4bec7	Add Nodon module virtuak switch example	2024-03-30 07:51:22 +00:00
Jean-Marc Collin	a9b87b3aee	Release 6.1.0	2024-03-26 20:10:29 +00:00
Jean-Marc Collin	c512cb6f74	[#428 ] - Refacto start versatile_thermostat (#430 ) Co-authored-by: Jean-Marc Collin <jean-marc.collin-extern@renault.com>	2024-03-26 21:06:25 +01:00
Jean-Marc Collin	9269240fe3	Release	2024-03-25 07:43:09 +00:00