Issue #872 (#886)

* ConfigFlow (translation to change)

* +1

* With implemn in thermostat_switch (not finished)

* GUI fixe

* +1

* Select Working

* Test input in config_flow ok

* documentation

* Add github copilot
Add first test ok for UnderlyingSwitch

* All tests ok

* Fix warnings

* Fix All tests ok

* Translations

* safety

* Add quick-start documentation

---------

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

.devcontainer/Dockerfile

@@ -1,2 +1,2 @@
-FROM mcr.microsoft.com/devcontainers/python:1-3.12
-RUN apt update && apt install -y ffmpeg
+FROM mcr.microsoft.com/devcontainers/python:1-3.13
+RUN apt update && apt install -y ffmpeg libturbojpeg0-dev

.devcontainer/configuration.yaml

@@ -1,14 +1,31 @@
 default_config:
 
+recorder:
+    auto_purge: true
+    purge_keep_days: 1
+    commit_interval: 5
+    include:
+        domains:
+            - input_boolean
+            - input_number
+            - input_select
+            - switch
+            - climate
+            - sensor
+            - binary_sensor
+            - number
+            - select
+            - versatile_thermostat
+
 logger:
     default: warning
     logs:
-       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
+        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:
@@ -75,6 +92,48 @@ input_number:
         icon: mdi:thermostat
         unit_of_measurement: °C
         mode: box
+    fake_offset_calibration1:
+        name: Sonoff offset calibration 1
+        min: -12
+        max: 12
+        icon: mdi:tune
+        unit_of_measurement: °C
+        mode: box
+    fake_opening_degree1:
+        name: Sonoff Opening degree 1
+        min: 0
+        max: 100
+        icon: mdi:valve-open
+        unit_of_measurement: "%"
+        mode: box
+    fake_closing_degree1:
+        name: Sonoff Closing degree 1
+        min: 0
+        max: 100
+        icon: mdi:valve-closed
+        unit_of_measurement: "%"
+        mode: box
+    fake_offset_calibration2:
+        name: Sonoff offset calibration 2
+        min: -12
+        max: 12
+        icon: mdi:tune
+        unit_of_measurement: °C
+        mode: box
+    fake_opening_degree2:
+        name: Sonoff Opening degree 2
+        min: 0
+        max: 100
+        icon: mdi:valve-open
+        unit_of_measurement: "%"
+        mode: box
+    fake_closing_degree2:
+        name: Sonoff Closing degree 2
+        min: 0
+        max: 100
+        icon: mdi:valve-closed
+        unit_of_measurement: "%"
+        mode: box
 
 input_boolean:
     # input_boolean to simulate the windows entity. Only for development environment.
@@ -126,6 +185,12 @@ input_boolean:
     fake_presence_sensor1:
         name: Presence Sensor 1
         icon: mdi:home
+    fake_valve_sonoff_trvzb1:
+        name: Valve Sonoff TRVZB1
+        icon: mdi:valve
+    fake_valve_sonoff_trvzb2:
+        name: Valve Sonoff TRVZB2
+        icon: mdi:valve
 
 climate:
     - platform: generic_thermostat
@@ -136,6 +201,7 @@ climate:
       name: Underlying thermostat2
       heater: input_boolean.fake_heater_switch3
       target_sensor: input_number.fake_temperature_sensor1
+      ac_mode: false
     - platform: generic_thermostat
       name: Underlying thermostat3
       heater: input_boolean.fake_heater_switch3
@@ -168,6 +234,21 @@ climate:
       name: Underlying thermostat9
       heater: input_boolean.fake_heater_switch3
       target_sensor: input_number.fake_temperature_sensor1
+    - platform: generic_thermostat
+      name: Underlying Sonoff TRVZB1
+      heater: input_boolean.fake_valve_sonoff_trvzb1
+      target_sensor: input_number.fake_temperature_sensor1
+      ac_mode: false
+    - platform: generic_thermostat
+      name: Underlying Sonoff TRVZB2
+      heater: input_boolean.fake_valve_sonoff_trvzb2
+      target_sensor: input_number.fake_temperature_sensor1
+      ac_mode: false
+    - platform: generic_thermostat
+      name: Underlying switch climate
+      heater: input_boolean.fake_heater_switch2
+      target_sensor: input_number.fake_temperature_sensor1
+      ac_mode: false
 
 input_datetime:
     fake_last_seen:
@@ -176,20 +257,6 @@ input_datetime:
         has_date: true
         has_time: true
 
-recorder:
-    commit_interval: 0
-    include:
-        domains:
-            - input_boolean
-            - input_number
-            - switch
-            - climate
-            - sensor
-            - binary_sensor
-            - number
-            - input_select
-            - versatile_thermostat
-
 template:
     - binary_sensor:
           - name: maison_occupee
@@ -235,14 +302,14 @@ switch:
               friendly_name: "Pilote chauffage SDB RDC"
               value_template: "{{ is_state_attr('switch_seche_serviettes_sdb_rdc', 'sensor_state', 'on') }}"
               turn_on:
-                  service: select.select_option
+                  action: select.select_option
                   data:
                       option: comfort
                   target:
                       entity_id: select.seche_serviettes_sdb_rdc_cable_outlet_mode
 
               turn_off:
-                  service: select.select_option
+                  action: select.select_option
                   data:
                       option: comfort-2
                   target:

.devcontainer/devcontainer.json

@@ -1,15 +1,13 @@
 // See https://aka.ms/vscode-remote/devcontainer.json for format details.
 // "image": "ghcr.io/ludeeus/devcontainer/integration:latest",
 {
-	"build": {
-		"dockerfile": "Dockerfile"
-	},
-	"name": "Versatile Thermostat integration",
-	"appPort": [
-		"8123:8123"
-	],
-	// "postCreateCommand": "container install",
-	"postCreateCommand": "./container dev-setup",
+    "build": {
+        "dockerfile": "Dockerfile"
+    },
+    "name": "Versatile Thermostat integration",
+    "appPort": ["8123:8123"],
+    // "postCreateCommand": "container install",
+    "postCreateCommand": "./container dev-setup",
 
     "mounts": [
         "source=${localEnv:HOME}/.ssh,target=/home/vscode/.ssh,type=bind,consistency=cached",
@@ -17,52 +15,56 @@
         "source=${localEnv:HOME}/SugarSync/Projets/home-assistant/versatile-thermostat-ui-card/dist,target=/workspaces/versatile_thermostat/config/www/community/versatile-thermostat-ui-card,type=bind,consistency=cached"
     ],
 
-	"customizations": {
-		"vscode": {
-			"extensions": [
-				"ms-python.python",
-				"ms-python.pylint",
-				// Doesn't work (crash). Default in python is to use Jedi see Settings / Python / Default Language
-				// "ms-python.vscode-pylance",
-				"ms-python.isort",
-				"ms-python.black-formatter",
-				"visualstudioexptteam.vscodeintellicode",
-				"redhat.vscode-yaml",
-				"github.vscode-pull-request-github",
-				"ryanluker.vscode-coverage-gutters",
-				"ferrierbenjamin.fold-unfold-all-icone",
-				"LittleFoxTeam.vscode-python-test-adapter",
-				"donjayamanne.githistory",
-				"waderyan.gitblame",
-				"keesschollaart.vscode-home-assistant",
-				"vscode.markdown-math",
-				"yzhang.markdown-all-in-one",
-				"github.vscode-github-actions",
-				"azuretools.vscode-docker"
-			],
-			"settings": {
-				"files.eol": "\n",
-				"editor.tabSize": 4,
-				"terminal.integrated.profiles.linux": {
-					"bash": {
-						"path": "bash",
-						"args": []
-					}
-				},
-				"terminal.integrated.defaultProfile.linux": "bash",
-				// "terminal.integrated.shell.linux": "/bin/bash",
-				"python.pythonPath": "/usr/bin/python3",
-				"python.analysis.autoSearchPaths": true,
-				"pylint.lintOnChange": false,
-				"python.formatting.provider": "black",
-				"python.formatting.blackPath": "/usr/local/py-utils/bin/black",
-				"editor.formatOnPaste": false,
-				"editor.formatOnSave": true,
-				"editor.formatOnType": true,
-				"files.trimTrailingWhitespace": true
-				// "python.experiments.optOutFrom": ["pythonTestAdapter"],
-    			// "python.analysis.logLevel": "Trace"
-			}
-		}
-	}
+    "customizations": {
+        "vscode": {
+            "extensions": [
+                "ms-python.python",
+                "ms-python.pylint",
+                // Doesn't work (crash). Default in python is to use Jedi see Settings / Python / Default Language
+                // "ms-python.vscode-pylance",
+                "ms-python.isort",
+                "ms-python.black-formatter",
+                "visualstudioexptteam.vscodeintellicode",
+                "redhat.vscode-yaml",
+                "github.vscode-pull-request-github",
+                "ryanluker.vscode-coverage-gutters",
+                "ferrierbenjamin.fold-unfold-all-icone",
+                "LittleFoxTeam.vscode-python-test-adapter",
+                "donjayamanne.githistory",
+                "waderyan.gitblame",
+                "keesschollaart.vscode-home-assistant",
+                "vscode.markdown-math",
+                "yzhang.markdown-all-in-one",
+                "github.vscode-github-actions",
+                "azuretools.vscode-docker",
+                "huizhou.githd",
+                "github.copilot",
+                "github.copilot-chat"
+            ],
+            "settings": {
+                "files.eol": "\n",
+                "editor.tabSize": 4,
+                "terminal.integrated.profiles.linux": {
+                    "bash": {
+                        "path": "bash",
+                        "args": []
+                    }
+                },
+                "terminal.integrated.defaultProfile.linux": "bash",
+                // "terminal.integrated.shell.linux": "/bin/bash",
+                "python.pythonPath": "/usr/bin/python3",
+                "python.analysis.autoSearchPaths": true,
+                "pylint.lintOnChange": false,
+                "python.formatting.provider": "black",
+                "python.formatting.blackArgs": ["--line-length", "180"],
+                "python.formatting.blackPath": "/usr/local/py-utils/bin/black",
+                "editor.formatOnPaste": false,
+                "editor.formatOnSave": true,
+                "editor.formatOnType": true,
+                "files.trimTrailingWhitespace": true
+                // "python.experiments.optOutFrom": ["pythonTestAdapter"],
+                // "python.analysis.logLevel": "Trace"
+            }
+        }
+    }
 }

.devcontainer/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+asyncio_default_fixture_loop_scope = function

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/issue.md

@@ -4,13 +4,18 @@ about: Create a report to help us improve
 
 ---
 
+# Read this carefully
+
+> Please read carefully this instructions and fill this form before writing an issue. It helps me to help you.
+> If you choose to not follow this template, you accept to have no answer from the author. The tag on the issue 'Template not respected' means you don't respect this template. Potentially, you will not have a relevant answer.
+
 <!-- This template will allow the maintainer to be efficient and post the more accurante response as possible. There is many types / modes / configuration possible, so the analysis can be very tricky. If don't follow this template, your issue could be rejected without any message. Please help me to help you. -->
 
 <!-- Before you open a new issue, search through the existing issues to see if others have had the same problem.
 
 If you have a simple question or you are not sure this is an issue, don't open an issue but open a new discussion [here](https://github.com/jmcollin78/versatile_thermostat/discussions).
 
-Check also in the [Troubleshooting](#troubleshooting) paragrah of the README if the aswer is not already given.
+Check also in the [Troubleshooting] paragrah of the README if the aswer is not already given.
 
 Issues not containing the minimum requirements will be closed:
 
@@ -67,10 +72,10 @@ motion_state: 'off'
 overpowering_state: false
 presence_state: 'on'
 window_auto_state: false
-window_bypass_state: false
-security_delay_min: 2
-security_min_on_percent: 0.5
-security_default_on_percent: 0.1
+is_window_bypass: false
+safety_delay_min: 2
+safety_min_on_percent: 0.5
+safety_default_on_percent: 0.1
 last_temperature_datetime: '2023-11-05T00:48:54.873157+01:00'
 last_ext_temperature_datetime: '2023-11-05T00:48:53.240122+01:00'
 security_state: true

.pylintrc

@@ -0,0 +1,2 @@
+[FORMAT]
+max-line-length=180

.vscode/settings.json

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

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
 
@@ -28,6 +29,9 @@ from .const import (
     CONF_AUTO_REGULATION_EXPERT,
     CONF_SHORT_EMA_PARAMS,
     CONF_SAFETY_MODE,
+    CONF_SAFETY_DELAY_MIN,
+    CONF_SAFETY_MIN_ON_PERCENT,
+    CONF_SAFETY_DEFAULT_ON_PERCENT,
     CONF_THERMOSTAT_CENTRAL_CONFIG,
     CONF_THERMOSTAT_TYPE,
     CONF_USE_WINDOW_FEATURE,
@@ -37,6 +41,23 @@ from .const import (
     CONF_USE_CENTRAL_BOILER_FEATURE,
     CONF_POWER_SENSOR,
     CONF_PRESENCE_SENSOR,
+    CONF_UNDERLYING_LIST,
+    CONF_HEATER,
+    CONF_HEATER_2,
+    CONF_HEATER_3,
+    CONF_HEATER_4,
+    CONF_CLIMATE,
+    CONF_CLIMATE_2,
+    CONF_CLIMATE_3,
+    CONF_CLIMATE_4,
+    CONF_VALVE,
+    CONF_VALVE_2,
+    CONF_VALVE_3,
+    CONF_VALVE_4,
+    CONF_THERMOSTAT_SWITCH,
+    CONF_THERMOSTAT_CLIMATE,
+    CONF_THERMOSTAT_VALVE,
+    CONF_MAX_ON_PERCENT,
 )
 
 from .vtherm_api import VersatileThermostatAPI
@@ -69,6 +90,7 @@ CONFIG_SCHEMA = vol.Schema(
                 CONF_AUTO_REGULATION_EXPERT: vol.Schema(SELF_REGULATION_PARAM_SCHEMA),
                 CONF_SHORT_EMA_PARAMS: vol.Schema(EMA_PARAM_SCHEMA),
                 CONF_SAFETY_MODE: vol.Schema(SAFETY_MODE_PARAM_SCHEMA),
+                vol.Optional(CONF_MAX_ON_PERCENT): vol.Coerce(float),
             }
         ),
     },
@@ -115,7 +137,8 @@ async def async_setup(
     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,
@@ -160,13 +183,20 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     if hass.state == CoreState.running:
         await api.reload_central_boiler_entities_list()
-        await api.init_vtherm_links()
+        await api.init_vtherm_links(entry.entry_id)
 
     return True
 
 
 async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
     """Update listener."""
+
+    _LOGGER.debug(
+        "Calling update_listener entry: entry_id='%s', value='%s'",
+        entry.entry_id,
+        entry.data,
+    )
+
     if entry.data.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_CENTRAL_CONFIG:
         await reload_all_vtherm(hass)
     else:
@@ -175,7 +205,7 @@ async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
         api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(hass)
         if api is not None:
             await api.reload_central_boiler_entities_list()
-            await api.init_vtherm_links()
+            await api.init_vtherm_links(entry.entry_id)
 
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
@@ -206,10 +236,9 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry):
         )
         new = {**config_entry.data}
 
-        if (
-            config_entry.data.get(CONF_THERMOSTAT_TYPE)
-            == CONF_THERMOSTAT_CENTRAL_CONFIG
-        ):
+        thermostat_type = config_entry.data.get(CONF_THERMOSTAT_TYPE)
+
+        if thermostat_type == CONF_THERMOSTAT_CENTRAL_CONFIG:
             new[CONF_USE_WINDOW_FEATURE] = True
             new[CONF_USE_MOTION_FEATURE] = True
             new[CONF_USE_POWER_FEATURE] = new.get(CONF_POWER_SENSOR, None) is not None
@@ -221,6 +250,64 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry):
                 "add_central_boiler_control", False
             ) or new.get(CONF_USE_CENTRAL_BOILER_FEATURE, False)
 
+        if config_entry.data.get(CONF_UNDERLYING_LIST, None) is None:
+            underlying_list = []
+            if thermostat_type == CONF_THERMOSTAT_SWITCH:
+                underlying_list = [
+                    config_entry.data.get(CONF_HEATER, None),
+                    config_entry.data.get(CONF_HEATER_2, None),
+                    config_entry.data.get(CONF_HEATER_3, None),
+                    config_entry.data.get(CONF_HEATER_4, None),
+                ]
+            elif thermostat_type == CONF_THERMOSTAT_CLIMATE:
+                underlying_list = [
+                    config_entry.data.get(CONF_CLIMATE, None),
+                    config_entry.data.get(CONF_CLIMATE_2, None),
+                    config_entry.data.get(CONF_CLIMATE_3, None),
+                    config_entry.data.get(CONF_CLIMATE_4, None),
+                ]
+            elif thermostat_type == CONF_THERMOSTAT_VALVE:
+                underlying_list = [
+                    config_entry.data.get(CONF_VALVE, None),
+                    config_entry.data.get(CONF_VALVE_2, None),
+                    config_entry.data.get(CONF_VALVE_3, None),
+                    config_entry.data.get(CONF_VALVE_4, None),
+                ]
+
+            new[CONF_UNDERLYING_LIST] = [
+                entity for entity in underlying_list if entity is not None
+            ]
+
+            for key in [
+                CONF_HEATER,
+                CONF_HEATER_2,
+                CONF_HEATER_3,
+                CONF_HEATER_4,
+                CONF_CLIMATE,
+                CONF_CLIMATE_2,
+                CONF_CLIMATE_3,
+                CONF_CLIMATE_4,
+                CONF_VALVE,
+                CONF_VALVE_2,
+                CONF_VALVE_3,
+                CONF_VALVE_4,
+            ]:
+                new.pop(key, None)
+
+            # Migration 2.0 to 2.1 -> rename security parameters into safety
+
+        if config_entry.version == CONFIG_VERSION and config_entry.minor_version == 0:
+            for key in [
+                "security_delay_min",
+                "security_min_on_percent",
+                "security_default_on_percent",
+            ]:
+                new_key = key.replace("security_", "safety_")
+                old_value = config_entry.data.get(key, None)
+                if old_value is not None:
+                    new[new_key] = old_value
+                new.pop(key, None)
+
         hass.config_entries.async_update_entry(
             config_entry,
             data=new,

custom_components/versatile_thermostat/auto_start_stop_algorithm.py

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

custom_components/versatile_thermostat/base_entity.py

@@ -0,0 +1,119 @@
+""" A base class for all VTherm entities"""
+
+import logging
+from datetime import timedelta
+from homeassistant.core import HomeAssistant, callback, Event
+from homeassistant.components.climate import ClimateEntity
+from homeassistant.components.climate.const import DOMAIN as CLIMATE_DOMAIN
+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.device_registry import DeviceInfo, DeviceEntryType
+from homeassistant.helpers.event import async_track_state_change_event, async_call_later
+
+
+from .const import DOMAIN, DEVICE_MANUFACTURER
+
+from .base_thermostat import BaseThermostat
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class VersatileThermostatBaseEntity(Entity):
+    """A base class for all entities"""
+
+    _my_climate: BaseThermostat
+    hass: HomeAssistant
+    _config_id: str
+    _device_name: str
+
+    def __init__(self, hass: HomeAssistant, config_id, device_name) -> None:
+        """The CTOR"""
+        self.hass = hass
+        self._config_id = config_id
+        self._device_name = device_name
+        self._my_climate = None
+        self._cancel_call = None
+        self._attr_has_entity_name = True
+
+    @property
+    def should_poll(self) -> bool:
+        """Do not poll for those entities"""
+        return False
+
+    @property
+    def my_climate(self) -> BaseThermostat | None:
+        """Returns my climate if found"""
+        if not self._my_climate:
+            self._my_climate = self.find_my_versatile_thermostat()
+            if self._my_climate:
+                # Only the first time
+                self.my_climate_is_initialized()
+        return self._my_climate
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the device info."""
+        return DeviceInfo(
+            entry_type=DeviceEntryType.SERVICE,
+            identifiers={(DOMAIN, self._config_id)},
+            name=self._device_name,
+            manufacturer=DEVICE_MANUFACTURER,
+            model=DOMAIN,
+        )
+
+    def find_my_versatile_thermostat(self) -> BaseThermostat:
+        """Find the underlying climate entity"""
+        try:
+            component: EntityComponent[ClimateEntity] = self.hass.data[CLIMATE_DOMAIN]
+            for entity in component.entities:
+                # _LOGGER.debug("Device_info is %s", entity.device_info)
+                if entity.device_info == self.device_info:
+                    _LOGGER.debug("Found %s!", entity)
+                    return entity
+        except KeyError:
+            pass
+
+        return None
+
+    @callback
+    async def async_added_to_hass(self):
+        """Listen to my climate state change"""
+
+        # Check delay condition
+        async def try_find_climate(_):
+            _LOGGER.debug(
+                "%s - Calling VersatileThermostatBaseEntity.async_added_to_hass", self
+            )
+            mcl = self.my_climate
+            if mcl:
+                if self._cancel_call:
+                    self._cancel_call()
+                    self._cancel_call = None
+                self.async_on_remove(
+                    async_track_state_change_event(
+                        self.hass,
+                        [mcl.entity_id],
+                        self.async_my_climate_changed,
+                    )
+                )
+            else:
+                _LOGGER.debug("%s - no entity to listen. Try later", self)
+                self._cancel_call = async_call_later(
+                    self.hass, timedelta(seconds=1), try_find_climate
+                )
+
+        await try_find_climate(None)
+
+    @callback
+    def my_climate_is_initialized(self):
+        """Called when the associated climate is initialized"""
+        return
+
+    @callback
+    async def async_my_climate_changed(
+        self, event: Event
+    ):  # pylint: disable=unused-argument
+        """Called when my climate have change
+        This method aims to be overridden to take the status change
+        """
+        return

custom_components/versatile_thermostat/base_manager.py

@@ -0,0 +1,62 @@
+""" Implements a base Feature Manager for Versatile Thermostat """
+
+import logging
+from typing import Any
+
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant
+
+from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from .commons import ConfigData
+
+from .config_schema import *  # pylint: disable=wildcard-import, unused-wildcard-import
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class BaseFeatureManager:
+    """A base class for all feature"""
+
+    def __init__(self, vtherm: Any, hass: HomeAssistant, name: str = None):
+        """Init of a featureManager"""
+        self._vtherm = vtherm
+        self._name = vtherm.name if vtherm else name
+        self._active_listener: list[CALLBACK_TYPE] = []
+        self._hass = hass
+
+    def post_init(self, entry_infos: ConfigData):
+        """Initialize the attributes of the FeatureManager"""
+        raise NotImplementedError()
+
+    async def start_listening(self):
+        """Start listening the underlying entity"""
+        raise NotImplementedError()
+
+    def stop_listening(self) -> bool:
+        """stop listening to the sensor"""
+        while self._active_listener:
+            self._active_listener.pop()()
+
+        self._active_listener = []
+
+    async def refresh_state(self):
+        """Refresh the state and return True if a change have been made"""
+        return False
+
+    def add_listener(self, func: CALLBACK_TYPE) -> None:
+        """Add a listener to the list of active listener"""
+        self._active_listener.append(func)
+
+    @property
+    def is_configured(self) -> bool:
+        """True if the FeatureManager is fully configured"""
+        raise NotImplementedError()
+
+    @property
+    def name(self) -> str:
+        """The name"""
+        return self._name
+
+    @property
+    def hass(self) -> HomeAssistant:
+        """The HA instance"""
+        return self._hass

custom_components/versatile_thermostat/binary_sensor.py

@@ -25,10 +25,8 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .vtherm_api import VersatileThermostatAPI
-from .commons import (
-    VersatileThermostatBaseEntity,
-    check_and_extract_service_configuration,
-)
+from .commons import check_and_extract_service_configuration
+from .base_entity import VersatileThermostatBaseEntity
 from .const import (
     DOMAIN,
     DEVICE_MANUFACTURER,
@@ -100,7 +98,7 @@ class SecurityBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
         entry_infos,
     ) -> None:
         """Initialize the SecurityState Binary sensor"""
-        super().__init__(hass, unique_id, entry_infos.get(CONF_NAME))
+        super().__init__(hass, unique_id, name)
         self._attr_name = "Security state"
         self._attr_unique_id = f"{self._device_name}_security_state"
         self._attr_is_on = False
@@ -108,10 +106,10 @@ class SecurityBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         old_state = self._attr_is_on
-        self._attr_is_on = self.my_climate.security_state is True
+        self._attr_is_on = self.my_climate.safety_manager.is_safety_detected
         if old_state != self._attr_is_on:
             self.async_write_ha_state()
         return
@@ -147,10 +145,10 @@ class OverpoweringBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         old_state = self._attr_is_on
-        self._attr_is_on = self.my_climate.overpowering_state is True
+        self._attr_is_on = self.my_climate.overpowering_state is STATE_ON
         if old_state != self._attr_is_on:
             self.async_write_ha_state()
         return
@@ -186,7 +184,7 @@ class WindowBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         old_state = self._attr_is_on
         # Issue 120 - only take defined presence value
@@ -236,7 +234,7 @@ class MotionBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
         old_state = self._attr_is_on
         # Issue 120 - only take defined presence value
         if self.my_climate.motion_state in [STATE_ON, STATE_OFF]:
@@ -277,7 +275,7 @@ class PresenceBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
 
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
         old_state = self._attr_is_on
         # Issue 120 - only take defined presence value
         if self.my_climate.presence_state in [STATE_ON, STATE_OFF]:
@@ -317,10 +315,10 @@ class WindowByPassBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
         old_state = self._attr_is_on
-        if self.my_climate.window_bypass_state in [True, False]:
-            self._attr_is_on = self.my_climate.window_bypass_state
+        if self.my_climate.is_window_bypass in [True, False]:
+            self._attr_is_on = self.my_climate.is_window_bypass
             if old_state != self._attr_is_on:
                 self.async_write_ha_state()
         return

custom_components/versatile_thermostat/central_feature_power_manager.py

@@ -0,0 +1,324 @@
+""" Implements a central Power Feature Manager for Versatile Thermostat """
+
+import logging
+from typing import Any
+from functools import cmp_to_key
+
+from datetime import timedelta
+
+from homeassistant.const import STATE_OFF
+from homeassistant.core import HomeAssistant, Event, callback
+from homeassistant.helpers.event import (
+    async_track_state_change_event,
+    EventStateChangedData,
+    async_call_later,
+)
+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.components.climate import (
+    ClimateEntity,
+    DOMAIN as CLIMATE_DOMAIN,
+)
+
+
+from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from .commons import ConfigData
+from .base_manager import BaseFeatureManager
+
+# circular dependency
+# from .base_thermostat import BaseThermostat
+
+MIN_DTEMP_SECS = 20
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CentralFeaturePowerManager(BaseFeatureManager):
+    """A central Power feature manager"""
+
+    def __init__(self, hass: HomeAssistant, vtherm_api: Any):
+        """Init of a featureManager"""
+        super().__init__(None, hass, "centralPowerManager")
+        self._hass: HomeAssistant = hass
+        self._vtherm_api = vtherm_api  # no type due to circular reference
+        self._is_configured: bool = False
+        self._power_sensor_entity_id: str = None
+        self._max_power_sensor_entity_id: str = None
+        self._current_power: float = None
+        self._current_max_power: float = None
+        self._power_temp: float = None
+        self._cancel_calculate_shedding_call = None
+        self._started_vtherm_total_power: float = None
+        # Not used now
+        self._last_shedding_date = None
+
+    def post_init(self, entry_infos: ConfigData):
+        """Gets the configuration parameters"""
+        central_config = self._vtherm_api.find_central_configuration()
+        if not central_config:
+            _LOGGER.info("No central configuration is found. Power management will be deactivated")
+            return
+
+        self._power_sensor_entity_id = entry_infos.get(CONF_POWER_SENSOR)
+        self._max_power_sensor_entity_id = entry_infos.get(CONF_MAX_POWER_SENSOR)
+        self._power_temp = entry_infos.get(CONF_PRESET_POWER)
+
+        self._is_configured = False
+        self._current_power = None
+        self._current_max_power = None
+        if (
+            entry_infos.get(CONF_USE_POWER_FEATURE, False)
+            and self._max_power_sensor_entity_id
+            and self._power_sensor_entity_id
+            and self._power_temp
+        ):
+            self._is_configured = True
+            self._started_vtherm_total_power = 0
+        else:
+            _LOGGER.info("Power management is not fully configured and will be deactivated")
+
+    async def start_listening(self):
+        """Start listening the power sensor"""
+        if not self._is_configured:
+            return
+
+        self.stop_listening()
+
+        self.add_listener(
+            async_track_state_change_event(
+                self.hass,
+                [self._power_sensor_entity_id],
+                self._power_sensor_changed,
+            )
+        )
+
+        self.add_listener(
+            async_track_state_change_event(
+                self.hass,
+                [self._max_power_sensor_entity_id],
+                self._max_power_sensor_changed,
+            )
+        )
+
+    @callback
+    async def _power_sensor_changed(self, event: Event[EventStateChangedData]):
+        """Handle power changes."""
+        _LOGGER.debug("Receive new Power event")
+        _LOGGER.debug(event)
+
+        self._started_vtherm_total_power = 0
+        await self.refresh_state()
+
+    @callback
+    async def _max_power_sensor_changed(self, event: Event[EventStateChangedData]):
+        """Handle power max changes."""
+        _LOGGER.debug("Receive new Power Max event")
+        _LOGGER.debug(event)
+        await self.refresh_state()
+
+    @overrides
+    async def refresh_state(self) -> bool:
+        """Tries to get the last state from sensor
+        Returns True if a change has been made"""
+
+        async def _calculate_shedding_internal(_):
+            _LOGGER.debug("Do the shedding calculation")
+            await self.calculate_shedding()
+            if self._cancel_calculate_shedding_call:
+                self._cancel_calculate_shedding_call()
+                self._cancel_calculate_shedding_call = None
+
+        if not self._is_configured:
+            return False
+
+        # Retrieve current power
+        new_power = get_safe_float(self._hass, self._power_sensor_entity_id)
+        power_changed = new_power is not None and self._current_power != new_power
+        if power_changed:
+            self._current_power = new_power
+            _LOGGER.debug("New current power has been retrieved: %.3f", self._current_power)
+
+        # Retrieve max power
+        new_max_power = get_safe_float(self._hass, self._max_power_sensor_entity_id)
+        max_power_changed = new_max_power is not None and self._current_max_power != new_max_power
+        if max_power_changed:
+            self._current_max_power = new_max_power
+            _LOGGER.debug("New current max power has been retrieved: %.3f", self._current_max_power)
+
+        # Schedule shedding calculation if there's any change
+        if power_changed or max_power_changed:
+            if not self._cancel_calculate_shedding_call:
+                self._cancel_calculate_shedding_call = async_call_later(self.hass, timedelta(seconds=MIN_DTEMP_SECS), _calculate_shedding_internal)
+            return True
+
+        return False
+
+    # For testing purpose only, do an immediate shedding calculation
+    async def _do_immediate_shedding(self):
+        """Do an immmediate shedding calculation if a timer was programmed.
+        Else, do nothing"""
+        if self._cancel_calculate_shedding_call:
+            self._cancel_calculate_shedding_call()
+            self._cancel_calculate_shedding_call = None
+            await self.calculate_shedding()
+
+    async def calculate_shedding(self):
+        """Do the shedding calculation and set/unset VTherm into overpowering state"""
+        if not self.is_configured or self.current_max_power is None or self.current_power is None:
+            return
+
+        _LOGGER.debug("-------- Start of calculate_shedding")
+        # Find all VTherms
+        available_power = self.current_max_power - self.current_power
+        vtherms_sorted = self.find_all_vtherm_with_power_management_sorted_by_dtemp()
+
+        # shedding only
+        if available_power < 0:
+            _LOGGER.debug(
+                "The available power is is < 0 (%s). Set overpowering only for list: %s",
+                available_power,
+                vtherms_sorted,
+            )
+            # we will set overpowering for the nearest target temp first
+            total_power_gain = 0
+
+            for vtherm in vtherms_sorted:
+                if vtherm.is_device_active and not vtherm.power_manager.is_overpowering_detected:
+                    device_power = vtherm.power_manager.device_power
+                    total_power_gain += device_power
+                    _LOGGER.info("vtherm %s should be in overpowering state (device_power=%.2f)", vtherm.name, device_power)
+                    await vtherm.power_manager.set_overpowering(True, device_power)
+
+                _LOGGER.debug("after vtherm %s total_power_gain=%s, available_power=%s", vtherm.name, total_power_gain, available_power)
+                if total_power_gain >= -available_power:
+                    _LOGGER.debug("We have found enough vtherm to set to overpowering")
+                    break
+        # unshedding only
+        else:
+            vtherms_sorted.reverse()
+            _LOGGER.debug("The available power is is > 0 (%s). Do a complete shedding/un-shedding calculation for list: %s", available_power, vtherms_sorted)
+
+            total_power_added = 0
+
+            for vtherm in vtherms_sorted:
+                # We want to do always unshedding in order to initialize the state
+                # so we cannot use is_overpowering_detected which test also UNKNOWN and UNAVAILABLE
+                if vtherm.power_manager.overpowering_state == STATE_OFF:
+                    continue
+
+                power_consumption_max = device_power = vtherm.power_manager.device_power
+                # calculate the power_consumption_max
+                if vtherm.on_percent is not None:
+                    power_consumption_max = max(
+                        device_power / vtherm.nb_underlying_entities,
+                        device_power * vtherm.on_percent,
+                    )
+
+                _LOGGER.debug("vtherm %s power_consumption_max is %s (device_power=%s, overclimate=%s)", vtherm.name, power_consumption_max, device_power, vtherm.is_over_climate)
+
+                # or not ... is for initializing the overpowering state if not already done
+                if total_power_added + power_consumption_max < available_power or not vtherm.power_manager.is_overpowering_detected:
+                    # we count the unshedding only if the VTherm was in shedding
+                    if vtherm.power_manager.is_overpowering_detected:
+                        _LOGGER.info("vtherm %s should not be in overpowering state (power_consumption_max=%.2f)", vtherm.name, power_consumption_max)
+                        total_power_added += power_consumption_max
+
+                    await vtherm.power_manager.set_overpowering(False)
+
+                if total_power_added >= available_power:
+                    _LOGGER.debug("We have found enough vtherm to set to non-overpowering")
+                    break
+
+                _LOGGER.debug("after vtherm %s total_power_added=%s, available_power=%s", vtherm.name, total_power_added, available_power)
+
+        self._last_shedding_date = self._vtherm_api.now
+        _LOGGER.debug("-------- End of calculate_shedding")
+
+    def get_climate_components_entities(self) -> list:
+        """Get all VTherms entitites"""
+        vtherms = []
+        component: EntityComponent[ClimateEntity] = self._hass.data.get(
+            CLIMATE_DOMAIN, None
+        )
+        if component:
+            for entity in component.entities:
+                # 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
+                ):
+                    vtherms.append(entity)
+        return vtherms
+
+    def find_all_vtherm_with_power_management_sorted_by_dtemp(
+        self,
+    ) -> list:
+        """Returns all the VTherms with power management activated"""
+        entities = self.get_climate_components_entities()
+        vtherms = [
+            vtherm
+            for vtherm in entities
+            if vtherm.power_manager.is_configured and vtherm.is_on
+        ]
+
+        # sort the result with the min temp difference first. A and B should be BaseThermostat class
+        def cmp_temps(a, b) -> int:
+            diff_a = float("inf")
+            diff_b = float("inf")
+            a_target = a.target_temperature if not a.power_manager.is_overpowering_detected else a.saved_target_temp
+            b_target = b.target_temperature if not b.power_manager.is_overpowering_detected else b.saved_target_temp
+            if a.current_temperature is not None and a_target is not None:
+                diff_a = a_target - a.current_temperature
+            if b.current_temperature is not None and b_target is not None:
+                diff_b = b_target - b.current_temperature
+
+            if diff_a == diff_b:
+                return 0
+            return 1 if diff_a > diff_b else -1
+
+        vtherms.sort(key=cmp_to_key(cmp_temps))
+        return vtherms
+
+    def add_started_vtherm_total_power(self, started_power: float):
+        """Add the power into the _started_vtherm_total_power which holds all VTherm started after
+        the last power measurement"""
+        self._started_vtherm_total_power += started_power
+        _LOGGER.debug("%s - started_vtherm_total_power is now %s", self, self._started_vtherm_total_power)
+
+    @property
+    def is_configured(self) -> bool:
+        """True if the FeatureManager is fully configured"""
+        return self._is_configured
+
+    @property
+    def current_power(self) -> float | None:
+        """Return the current power from sensor"""
+        return self._current_power
+
+    @property
+    def current_max_power(self) -> float | None:
+        """Return the current power from sensor"""
+        return self._current_max_power
+
+    @property
+    def power_temperature(self) -> float | None:
+        """Return the power temperature"""
+        return self._power_temp
+
+    @property
+    def power_sensor_entity_id(self) -> float | None:
+        """Return the power sensor entity id"""
+        return self._power_sensor_entity_id
+
+    @property
+    def max_power_sensor_entity_id(self) -> float | None:
+        """Return the max power sensor entity id"""
+        return self._max_power_sensor_entity_id
+
+    @property
+    def started_vtherm_total_power(self) -> float | None:
+        """Return the started_vtherm_total_power"""
+        return self._started_vtherm_total_power
+
+    def __str__(self):
+        return "CentralPowerManager"

custom_components/versatile_thermostat/climate.py

@@ -22,26 +22,13 @@ from homeassistant.const import (
     STATE_NOT_HOME,
 )
 
-from .const import (
-    DOMAIN,
-    PLATFORMS,
-    CONF_PRESETS_WITH_AC,
-    SERVICE_SET_PRESENCE,
-    SERVICE_SET_PRESET_TEMPERATURE,
-    SERVICE_SET_SECURITY,
-    SERVICE_SET_WINDOW_BYPASS,
-    SERVICE_SET_AUTO_REGULATION_MODE,
-    SERVICE_SET_AUTO_FAN_MODE,
-    CONF_THERMOSTAT_TYPE,
-    CONF_THERMOSTAT_SWITCH,
-    CONF_THERMOSTAT_CLIMATE,
-    CONF_THERMOSTAT_VALVE,
-    CONF_THERMOSTAT_CENTRAL_CONFIG,
-)
+from .const import *  # pylint: disable=wildcard-import,unused-wildcard-import
 
 from .thermostat_switch import ThermostatOverSwitch
 from .thermostat_climate import ThermostatOverClimate
 from .thermostat_valve import ThermostatOverValve
+from .thermostat_climate_valve import ThermostatOverClimateValve
+from .vtherm_api import VersatileThermostatAPI
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -60,8 +47,14 @@ async def async_setup_entry(
     unique_id = entry.entry_id
     name = entry.data.get(CONF_NAME)
     vt_type = entry.data.get(CONF_THERMOSTAT_TYPE)
+    have_valve_regulation = (
+        entry.data.get(CONF_AUTO_REGULATION_MODE) == CONF_AUTO_REGULATION_VALVE
+    )
 
     if vt_type == CONF_THERMOSTAT_CENTRAL_CONFIG:
+        # Initialize the central power manager
+        vtherm_api = VersatileThermostatAPI.get_vtherm_api(hass)
+        vtherm_api.central_power_manager.post_init(entry.data)
         return
 
     # Instantiate the right base class
@@ -69,9 +62,19 @@ async def async_setup_entry(
     if vt_type == CONF_THERMOSTAT_SWITCH:
         entity = ThermostatOverSwitch(hass, unique_id, name, entry.data)
     elif vt_type == CONF_THERMOSTAT_CLIMATE:
-        entity = ThermostatOverClimate(hass, unique_id, name, entry.data)
+        if have_valve_regulation is True:
+            entity = ThermostatOverClimateValve(hass, unique_id, name, entry.data)
+        else:
+            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)
 
@@ -98,13 +101,13 @@ async def async_setup_entry(
     )
 
     platform.async_register_entity_service(
-        SERVICE_SET_SECURITY,
+        SERVICE_SET_SAFETY,
         {
             vol.Optional("delay_min"): cv.positive_int,
             vol.Optional("min_on_percent"): vol.Coerce(float),
             vol.Optional("default_on_percent"): vol.Coerce(float),
         },
-        "service_set_security",
+        "SERVICE_SET_SAFETY",
     )
 
     platform.async_register_entity_service(
@@ -119,7 +122,7 @@ async def async_setup_entry(
         SERVICE_SET_AUTO_REGULATION_MODE,
         {
             vol.Required("auto_regulation_mode"): vol.In(
-                ["None", "Light", "Medium", "Strong", "Slow"]
+                ["None", "Light", "Medium", "Strong", "Slow", "Expert"]
             ),
         },
         "service_set_auto_regulation_mode",

custom_components/versatile_thermostat/commons.py

@@ -3,39 +3,18 @@
 # pylint: disable=line-too-long
 
 import logging
-from datetime import timedelta, datetime
-from homeassistant.core import HomeAssistant, callback, Event
-from homeassistant.components.climate import ClimateEntity, DOMAIN as CLIMATE_DOMAIN
-from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.entity import Entity
-from homeassistant.helpers.device_registry import DeviceInfo, DeviceEntryType
-from homeassistant.helpers.event import async_track_state_change_event, async_call_later
-from homeassistant.util import dt as dt_util
+import warnings
+from types import MappingProxyType
+from typing import Any, TypeVar
 
-from .base_thermostat import BaseThermostat
-from .const import DOMAIN, DEVICE_MANUFACTURER, ServiceConfigurationError
+from .const import ServiceConfigurationError
+from .underlyings import UnderlyingEntity
+
+ConfigData = MappingProxyType[str, Any]
+T = TypeVar("T", bound=UnderlyingEntity)
 
 _LOGGER = logging.getLogger(__name__)
 
-
-def get_tz(hass: HomeAssistant):
-    """Get the current timezone"""
-
-    return dt_util.get_time_zone(hass.config.time_zone)
-
-
-class NowClass:
-    """For testing purpose only"""
-
-    @staticmethod
-    def get_now(hass: HomeAssistant) -> datetime:
-        """A test function to get the now.
-        For testing purpose this method can be overriden to get a specific
-        timestamp.
-        """
-        return datetime.now(get_tz(hass))
-
-
 def round_to_nearest(n: float, x: float) -> float:
     """Round a number to the nearest x (which should be decimal but not null)
     Example:
@@ -156,102 +135,18 @@ def check_and_extract_service_configuration(service_config) -> dict:
     return ret
 
 
-class VersatileThermostatBaseEntity(Entity):
-    """A base class for all entities"""
+def deprecated(message):
+    """A decorator to indicate that the method/attribut is deprecated"""
 
-    _my_climate: BaseThermostat
-    hass: HomeAssistant
-    _config_id: str
-    _device_name: str
-
-    def __init__(self, hass: HomeAssistant, config_id, device_name) -> None:
-        """The CTOR"""
-        self.hass = hass
-        self._config_id = config_id
-        self._device_name = device_name
-        self._my_climate = None
-        self._cancel_call = None
-        self._attr_has_entity_name = True
-
-    @property
-    def should_poll(self) -> bool:
-        """Do not poll for those entities"""
-        return False
-
-    @property
-    def my_climate(self) -> BaseThermostat | None:
-        """Returns my climate if found"""
-        if not self._my_climate:
-            self._my_climate = self.find_my_versatile_thermostat()
-            if self._my_climate:
-                # Only the first time
-                self.my_climate_is_initialized()
-        return self._my_climate
-
-    @property
-    def device_info(self) -> DeviceInfo:
-        """Return the device info."""
-        return DeviceInfo(
-            entry_type=DeviceEntryType.SERVICE,
-            identifiers={(DOMAIN, self._config_id)},
-            name=self._device_name,
-            manufacturer=DEVICE_MANUFACTURER,
-            model=DOMAIN,
-        )
-
-    def find_my_versatile_thermostat(self) -> BaseThermostat:
-        """Find the underlying climate entity"""
-        try:
-            component: EntityComponent[ClimateEntity] = self.hass.data[CLIMATE_DOMAIN]
-            for entity in component.entities:
-                # _LOGGER.debug("Device_info is %s", entity.device_info)
-                if entity.device_info == self.device_info:
-                    _LOGGER.debug("Found %s!", entity)
-                    return entity
-        except KeyError:
-            pass
-
-        return None
-
-    @callback
-    async def async_added_to_hass(self):
-        """Listen to my climate state change"""
-
-        # Check delay condition
-        async def try_find_climate(_):
-            _LOGGER.debug(
-                "%s - Calling VersatileThermostatBaseEntity.async_added_to_hass", self
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            warnings.warn(
+                f"{func.__name__} is deprecated: {message}",
+                DeprecationWarning,
+                stacklevel=2,
             )
-            mcl = self.my_climate
-            if mcl:
-                if self._cancel_call:
-                    self._cancel_call()
-                    self._cancel_call = None
-                self.async_on_remove(
-                    async_track_state_change_event(
-                        self.hass,
-                        [mcl.entity_id],
-                        self.async_my_climate_changed,
-                    )
-                )
-            else:
-                _LOGGER.debug("%s - no entity to listen. Try later", self)
-                self._cancel_call = async_call_later(
-                    self.hass, timedelta(seconds=1), try_find_climate
-                )
+            return func(*args, **kwargs)
 
-        await try_find_climate(None)
+        return wrapper
 
-    @callback
-    def my_climate_is_initialized(self):
-        """Called when the associated climate is initialized"""
-        return
-
-    @callback
-    async def async_my_climate_changed(
-        self, event: Event
-    ):  # pylint: disable=unused-argument
-        """Called when my climate have change
-        This method aims to be overriden to take the status change
-        """
-        return
+    return decorator

custom_components/versatile_thermostat/config_flow.py

@@ -4,13 +4,12 @@
 from __future__ import annotations
 
 from typing import Any
+import re
 import logging
 import copy
-from collections.abc import Mapping
+from collections.abc import Mapping  # pylint: disable=import-error
 import voluptuous as vol
 
-from homeassistant.exceptions import HomeAssistantError
-
 from homeassistant.core import callback
 from homeassistant.config_entries import (
     ConfigEntry,
@@ -29,27 +28,6 @@ COMES_FROM = "comes_from"
 
 _LOGGER = logging.getLogger(__name__)
 
-
-# Not used but can be useful in other context
-# def schema_defaults(schema, **defaults):
-#    """Create a new schema with default values filled in."""
-#    copy = schema.extend({})
-#    for field, field_type in copy.schema.items():
-#        if isinstance(field_type, vol.In):
-#            value = None
-#
-#            if value in field_type.container:
-#                # field.default = vol.default_factory(value)
-#                field.description = {"suggested_value": value}
-#                continue
-#
-#        if field.schema in defaults:
-#            # field.default = vol.default_factory(defaults[field])
-#            field.description = {"suggested_value": defaults[field]}
-#    return copy
-#
-
-
 def add_suggested_values_to_schema(
     data_schema: vol.Schema, suggested_values: Mapping[str, Any]
 ) -> vol.Schema:
@@ -77,7 +55,6 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
     VERSION = CONFIG_VERSION
     MINOR_VERSION = CONFIG_MINOR_VERSION
 
-    _infos: dict
     _placeholders = {
         CONF_NAME: "",
     }
@@ -85,7 +62,7 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
     def __init__(self, infos) -> None:
         super().__init__()
         _LOGGER.debug("CTOR BaseConfigFlow infos: %s", infos)
-        self._infos = infos
+        self._infos: dict = infos
 
         # VTherm API should have been initialized before arriving here
         vtherm_api = VersatileThermostatAPI.get_vtherm_api()
@@ -94,39 +71,44 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
         else:
             self._central_config = None
 
-        self._init_feature_flags(infos)
         self._init_central_config_flags(infos)
+        self._init_feature_flags(infos)
 
     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.get(CONF_POWER_SENSOR) is not None
-            and self._infos.get(CONF_MAX_POWER_SENSOR) is not None
+        self._infos[CONF_USE_MOTION_FEATURE] = self._infos.get(
+            CONF_USE_MOTION_FEATURE, False
+        ) and (self._infos.get(CONF_MOTION_SENSOR) is not None or is_central_config)
+
+        self._infos[CONF_USE_POWER_FEATURE] = (
+            self._infos.get(CONF_USE_POWER_CENTRAL_CONFIG, False)
+            or self._infos.get(CONF_USE_POWER_FEATURE, False)
+            or (is_central_config and 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, False)
+            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
         )
 
+        self._infos[CONF_USE_AUTO_START_STOP_FEATURE] = (
+            self._infos.get(CONF_USE_AUTO_START_STOP_FEATURE, False) is True
+            and self._infos.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_CLIMATE
+        )
+
     def _init_central_config_flags(self, infos):
         """Initialisation of central configuration flags"""
         is_empty: bool = not bool(infos)
@@ -139,27 +121,70 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
             CONF_USE_PRESETS_CENTRAL_CONFIG,
             CONF_USE_PRESENCE_CENTRAL_CONFIG,
             CONF_USE_ADVANCED_CENTRAL_CONFIG,
+            CONF_USE_CENTRAL_MODE,
         ):
             if not is_empty:
                 current_config = self._infos.get(config, None)
-                self._infos[config] = current_config is True or (
-                    current_config is None and self._central_config is not None
+
+                self._infos[config] = self._central_config is not None and (
+                    current_config is True or current_config is None
                 )
+                # self._infos[config] = current_config is True or (
+                #     current_config is None and self._central_config is not None
+                # )
             else:
                 self._infos[config] = self._central_config is not None
 
         if COMES_FROM in self._infos:
             del self._infos[COMES_FROM]
 
-    async def validate_input(self, data: dict) -> None:
+    def is_valve_regulation_selected(self, infos) -> bool:
+        """True of the valve regulation mode is selected"""
+        return infos.get(CONF_AUTO_REGULATION_MODE, None) == CONF_AUTO_REGULATION_VALVE
+
+    def check_valve_regulation_nb_entities(self, data: dict, step_id=None) -> bool:
+        """Check the number of entities for Valve regulation"""
+        if step_id not in ["type", "valve_regulation", "check_complete"]:
+            return True
+
+        underlyings_to_check = data if step_id == "type" else self._infos
+        # underlyings_to_check = self._infos  # data if step_id == "type" else self._infos
+        regulation_infos_to_check = (
+            data if step_id == "valve_regulation" else self._infos
+        )
+
+        ret = True
+        if (
+            self.is_valve_regulation_selected(underlyings_to_check)
+            and step_id != "type"
+        ):
+            nb_unders = len(underlyings_to_check.get(CONF_UNDERLYING_LIST))
+            nb_offset = len(
+                regulation_infos_to_check.get(CONF_OFFSET_CALIBRATION_LIST, [])
+            )
+            nb_opening = len(
+                regulation_infos_to_check.get(CONF_OPENING_DEGREE_LIST, [])
+            )
+            nb_closing = len(
+                regulation_infos_to_check.get(CONF_CLOSING_DEGREE_LIST, [])
+            )
+            if (
+                nb_unders != nb_opening
+                or (nb_unders != nb_offset and nb_offset > 0)
+                or (nb_unders != nb_closing and nb_closing > 0)
+            ):
+                ret = False
+        return ret
+
+    async def validate_input(self, data: dict, step_id) -> None:
         """Validate the user input allows us to connect.
 
         Data has the keys from STEP_*_DATA_SCHEMA with values provided by the user.
         """
 
-        # check the heater_entity_id
+        # check the entity_ids
         for conf in [
-            CONF_HEATER,
+            CONF_UNDERLYING_LIST,
             CONF_TEMP_SENSOR,
             CONF_EXTERNAL_TEMP_SENSOR,
             CONF_WINDOW_SENSOR,
@@ -167,15 +192,20 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
             CONF_POWER_SENSOR,
             CONF_MAX_POWER_SENSOR,
             CONF_PRESENCE_SENSOR,
-            CONF_CLIMATE,
+            CONF_OFFSET_CALIBRATION_LIST,
+            CONF_OPENING_DEGREE_LIST,
+            CONF_CLOSING_DEGREE_LIST,
         ]:
             d = data.get(conf, None)  # pylint: disable=invalid-name
-            if d is not None and self.hass.states.get(d) is None:
-                _LOGGER.error(
-                    "Entity id %s doesn't have any state. We cannot use it in the Versatile Thermostat configuration",  # pylint: disable=line-too-long
-                    d,
-                )
-                raise UnknownEntity(conf)
+            if not isinstance(d, list):
+                d = [d]
+            for e in d:
+                if e is not None and self.hass.states.get(e) is None:
+                    _LOGGER.error(
+                        "Entity id %s doesn't have any state. We cannot use it in the Versatile Thermostat configuration",  # pylint: disable=line-too-long
+                        e,
+                    )
+                    raise UnknownEntity(conf)
 
         # Check that only one window feature is used
         ws = self._infos.get(CONF_WINDOW_SENSOR)  # pylint: disable=invalid-name
@@ -201,6 +231,9 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
                 CONF_USE_PRESENCE_CENTRAL_CONFIG,
                 CONF_USE_PRESETS_CENTRAL_CONFIG,
                 CONF_USE_ADVANCED_CENTRAL_CONFIG,
+                CONF_USE_CENTRAL_MODE,
+                # CONF_USE_CENTRAL_BOILER_FEATURE, this is for Central Config
+                CONF_USED_BY_CENTRAL_BOILER,
             ]:
                 if data.get(conf) is True:
                     _LOGGER.error(
@@ -219,6 +252,54 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
                 except ServiceConfigurationError as err:
                     raise ServiceConfigurationError(conf) from err
 
+        # Check that the number of offet_calibration and opening_degree and closing_degree are equals
+        # to the number of underlying entities
+        if not self.check_valve_regulation_nb_entities(data, step_id):
+            raise ValveRegulationNbEntitiesIncorrect()
+
+        # Check that the min_opening_degrees is correctly set
+        raw_list = data.get(CONF_MIN_OPENING_DEGREES, None)
+        if raw_list:
+            try:
+                # Validation : Convertir la liste saisie
+                int_list = [int(x.strip()) for x in raw_list.split(",")]
+
+                # Optionnel : Vérifiez des conditions supplémentaires sur la liste
+                if any(x < 0 for x in int_list):
+                    raise ValueError
+            except ValueError as exc:
+                raise ValveRegulationMinOpeningDegreesIncorrect(
+                    CONF_MIN_OPENING_DEGREES
+                ) from exc
+
+        # Check the VSWITCH configuration. There should be the same number of vswitch_on (resp. vswitch_off) than the number of underlying entity
+        if self._infos.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_SWITCH and step_id == "type":
+            if not self.check_vswitch_configuration(data):
+                raise VirtualSwitchConfigurationIncorrect(CONF_VSWITCH_ON_CMD_LIST)
+
+    def check_vswitch_configuration(self, data) -> bool:
+        """Check the Virtual switch configuration and return True if the configuration is correct"""
+        nb_under = len(data.get(CONF_UNDERLYING_LIST, []))
+
+        # check format of each command_on
+        for command in data.get(CONF_VSWITCH_ON_CMD_LIST, []) + data.get(CONF_VSWITCH_OFF_CMD_LIST, []):
+            pattern = r"^(?P<command>[a-zA-Z0-9_]+)(?:/(?P<argument>[a-zA-Z0-9_]+)(?::(?P<value>[a-zA-Z0-9_]+))?)?$"
+            if not re.match(pattern, command):
+                return False
+
+        nb_command_on = len(data.get(CONF_VSWITCH_ON_CMD_LIST, []))
+        nb_command_off = len(data.get(CONF_VSWITCH_OFF_CMD_LIST, []))
+        if (nb_command_on == nb_under or nb_command_on == 0) and (nb_command_off == nb_under or nb_command_off == 0):
+            # There is enough command_on and off
+            # Check if one under is not a switch (which have default command).
+            if any(
+                not thermostat_type.startswith(SWITCH_DOMAIN) and not thermostat_type.startswith(INPUT_BOOLEAN_DOMAIN) for thermostat_type in data.get(CONF_UNDERLYING_LIST, [])
+            ):
+                if nb_command_on != nb_under or nb_command_off != nb_under:
+                    return False
+            return True
+        return False
+
     def check_config_complete(self, infos) -> bool:
         """True if the config is now complete (ie all mandatory attributes are set)"""
         is_central_config = (
@@ -264,22 +345,8 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
             ):
                 return False
 
-            if (
-                infos.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_SWITCH
-                and infos.get(CONF_HEATER, None) is None
-            ):
-                return False
-
-            if (
-                infos.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_CLIMATE
-                and infos.get(CONF_CLIMATE, None) is None
-            ):
-                return False
-
-            if (
-                infos.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_VALVE
-                and infos.get(CONF_VALVE, None) is None
-            ):
+            # checks that at least one underlying is set but not it central configuration
+            if len(infos.get(CONF_UNDERLYING_LIST, [])) < 1:
                 return False
 
             if (
@@ -288,14 +355,7 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
             ):
                 return False
 
-            if (
-                infos.get(CONF_USE_POWER_FEATURE, False) is True
-                and infos.get(CONF_USE_POWER_CENTRAL_CONFIG, False) is False
-                and (
-                    infos.get(CONF_POWER_SENSOR, None) is None
-                    or infos.get(CONF_MAX_POWER_SENSOR, None) is None
-                )
-            ):
+            if infos.get(CONF_USE_POWER_FEATURE, False) is True and infos.get(CONF_USE_POWER_CENTRAL_CONFIG, False) is False and infos.get(CONF_PRESET_POWER, None) is None:
                 return False
 
             if (
@@ -311,6 +371,25 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
             ):
                 return False
 
+            if (
+                infos.get(CONF_PROP_FUNCTION, None) == PROPORTIONAL_FUNCTION_TPI
+                and infos.get(CONF_USE_TPI_CENTRAL_CONFIG, False) is False
+                and (
+                    infos.get(CONF_TPI_COEF_INT, None) is None
+                    or infos.get(CONF_TPI_COEF_EXT) is None
+                )
+            ):
+                return False
+
+            if (
+                infos.get(CONF_USE_PRESETS_CENTRAL_CONFIG, False) is True
+                and self._central_config is None
+            ):
+                return False
+
+            if not self.check_valve_regulation_nb_entities(infos, "check_complete"):
+                return False
+
         return True
 
     def merge_user_input(self, data_schema: vol.Schema, user_input: dict):
@@ -340,7 +419,7 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
         if user_input is not None:
             defaults.update(user_input or {})
             try:
-                await self.validate_input(user_input)
+                await self.validate_input(user_input, step_id)
             except UnknownEntity as err:
                 errors[str(err)] = "unknown_entity"
             except WindowOpenDetectionMethod as err:
@@ -351,6 +430,12 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
                 errors[str(err)] = "service_configuration_format"
             except ConfigurationNotCompleteError as err:
                 errors["base"] = "configuration_not_complete"
+            except ValveRegulationNbEntitiesIncorrect as err:
+                errors["base"] = "valve_regulation_nb_entities_incorrect"
+            except ValveRegulationMinOpeningDegreesIncorrect as err:
+                errors[str(err)] = "min_opening_degrees_format"
+            except VirtualSwitchConfigurationIncorrect as err:
+                errors["base"] = "vswitch_configuration_incorrect"
             except Exception:  # pylint: disable=broad-except
                 _LOGGER.exception("Unexpected exception")
                 errors["base"] = "unknown"
@@ -402,6 +487,7 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
         if (
             self._infos.get(CONF_PROP_FUNCTION) == PROPORTIONAL_FUNCTION_TPI
             or is_central_config
+            or self.is_valve_regulation_selected(self._infos)
         ):
             menu_options.append("tpi")
 
@@ -430,6 +516,16 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
         if self._infos[CONF_USE_PRESENCE_FEATURE] is True:
             menu_options.append("presence")
 
+        if self._infos.get(CONF_USE_AUTO_START_STOP_FEATURE) is True and self._infos[
+            CONF_THERMOSTAT_TYPE
+        ] in [
+            CONF_THERMOSTAT_CLIMATE,
+        ]:
+            menu_options.append("auto_start_stop")
+
+        if self.is_valve_regulation_selected(self._infos):
+            menu_options.append("valve_regulation")
+
         menu_options.append("advanced")
 
         if self.check_config_complete(self._infos):
@@ -499,6 +595,23 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
         """Handle the Type flow steps"""
         _LOGGER.debug("Into ConfigFlow.async_step_type user_input=%s", user_input)
 
+        if (
+            self._infos[CONF_THERMOSTAT_TYPE] == CONF_THERMOSTAT_CLIMATE
+            and user_input is not None
+            and not self.is_valve_regulation_selected(user_input)
+        ):
+            # Remove TPI info
+            for key in [
+                CONF_PROP_FUNCTION,
+                CONF_TPI_COEF_INT,
+                CONF_TPI_COEF_EXT,
+                CONF_OFFSET_CALIBRATION_LIST,
+                CONF_OPENING_DEGREE_LIST,
+                CONF_CLOSING_DEGREE_LIST,
+            ]:
+                if self._infos.get(key):
+                    del self._infos[key]
+
         if self._infos[CONF_THERMOSTAT_TYPE] == CONF_THERMOSTAT_SWITCH:
             return await self.generic_step(
                 "type", STEP_THERMOSTAT_SWITCH, user_input, self.async_step_menu
@@ -519,17 +632,45 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
         """Handle the Type flow steps"""
         _LOGGER.debug("Into ConfigFlow.async_step_features user_input=%s", user_input)
 
+        schema = STEP_FEATURES_DATA_SCHEMA
+        if self._infos[CONF_THERMOSTAT_TYPE] == CONF_THERMOSTAT_CENTRAL_CONFIG:
+            schema = STEP_CENTRAL_FEATURES_DATA_SCHEMA
+        elif self._infos[CONF_THERMOSTAT_TYPE] == CONF_THERMOSTAT_CLIMATE:
+            schema = STEP_CLIMATE_FEATURES_DATA_SCHEMA
+
         return await self.generic_step(
             "features",
-            (
-                STEP_CENTRAL_FEATURES_DATA_SCHEMA
-                if self._infos[CONF_THERMOSTAT_TYPE] == CONF_THERMOSTAT_CENTRAL_CONFIG
-                else STEP_FEATURES_DATA_SCHEMA
-            ),
+            schema,
             user_input,
             self.async_step_menu,
         )
 
+    async def async_step_auto_start_stop(self, user_input: dict | None = None) -> FlowResult:
+        """ Handle the Auto start stop step"""
+        _LOGGER.debug("Into ConfigFlow.async_step_auto_start_stop user_input=%s", user_input)
+
+        schema = STEP_AUTO_START_STOP
+        self._infos[COMES_FROM] = None
+        next_step = self.async_step_menu
+
+        return await self.generic_step("auto_start_stop", schema, user_input, next_step)
+
+    async def async_step_valve_regulation(
+        self, user_input: dict | None = None
+    ) -> FlowResult:
+        """Handle the valve regulation configuration step"""
+        _LOGGER.debug(
+            "Into ConfigFlow.async_step_valve_regulation user_input=%s", user_input
+        )
+
+        schema = STEP_VALVE_REGULATION
+        self._infos[COMES_FROM] = None
+        next_step = self.async_step_menu
+
+        return await self.generic_step(
+            "valve_regulation", schema, user_input, next_step
+        )
+
     async def async_step_tpi(self, user_input: dict | None = None) -> FlowResult:
         """Handle the TPI flow steps"""
         _LOGGER.debug("Into ConfigFlow.async_step_tpi user_input=%s", user_input)
@@ -694,7 +835,7 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
         """Handle the specific power flow steps"""
         _LOGGER.debug("Into ConfigFlow.async_step_spec_power user_input=%s", user_input)
 
-        schema = STEP_CENTRAL_POWER_DATA_SCHEMA
+        schema = STEP_NON_CENTRAL_POWER_DATA_SCHEMA
 
         self._infos[COMES_FROM] = "async_step_spec_power"
 
@@ -788,13 +929,45 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
         return await self.generic_step("advanced", schema, user_input, next_step)
 
     async def async_step_finalize(self, _):
-        """Should be implemented by Leaf classes"""
-        raise HomeAssistantError(
-            "async_finalize not implemented on VersatileThermostat sub-class"
-        )
+        """Finalize the creation. Should be overriden by underlyings"""
+        if not self._infos[CONF_USE_WINDOW_FEATURE]:
+            self._infos[CONF_USE_WINDOW_CENTRAL_CONFIG] = False
+            if CONF_WINDOW_SENSOR in self._infos:
+                del self._infos[CONF_WINDOW_SENSOR]
+            if CONF_WINDOW_AUTO_CLOSE_THRESHOLD in self._infos:
+                del self._infos[CONF_WINDOW_AUTO_CLOSE_THRESHOLD]
+            if CONF_WINDOW_AUTO_OPEN_THRESHOLD in self._infos:
+                del self._infos[CONF_WINDOW_AUTO_OPEN_THRESHOLD]
+            if CONF_WINDOW_AUTO_MAX_DURATION in self._infos:
+                del self._infos[CONF_WINDOW_AUTO_MAX_DURATION]
+        if not self._infos[CONF_USE_MOTION_FEATURE]:
+            self._infos[CONF_USE_MOTION_CENTRAL_CONFIG] = False
+            if CONF_MOTION_SENSOR in self._infos:
+                del self._infos[CONF_MOTION_SENSOR]
+        if not self._infos[CONF_USE_POWER_FEATURE]:
+            self._infos[CONF_USE_POWER_CENTRAL_CONFIG] = False
+            if CONF_POWER_SENSOR in self._infos:
+                del self._infos[CONF_POWER_SENSOR]
+            if CONF_MAX_POWER_SENSOR in self._infos:
+                del self._infos[CONF_MAX_POWER_SENSOR]
+        if not self._infos[CONF_USE_PRESENCE_FEATURE]:
+            self._infos[CONF_USE_PRESENCE_CENTRAL_CONFIG] = False
+            if CONF_PRESENCE_SENSOR in self._infos:
+                del self._infos[CONF_PRESENCE_SENSOR]
+        if not self._infos[CONF_USE_CENTRAL_BOILER_FEATURE]:
+            if CONF_CENTRAL_BOILER_ACTIVATION_SRV in self._infos:
+                del self._infos[CONF_CENTRAL_BOILER_ACTIVATION_SRV]
+            if CONF_CENTRAL_BOILER_DEACTIVATION_SRV in self._infos:
+                del self._infos[CONF_CENTRAL_BOILER_DEACTIVATION_SRV]
+        if not self._infos[CONF_USE_AUTO_START_STOP_FEATURE]:
+            self._infos[CONF_AUTO_START_STOP_LEVEL] = AUTO_START_STOP_LEVEL_NONE
+
+        # Removes temporary value
+        if COMES_FROM in self._infos:
+            del self._infos[COMES_FROM]
 
 
-class VersatileThermostatConfigFlow(
+class VersatileThermostatConfigFlow(  # pylint: disable=abstract-method
     VersatileThermostatBaseConfigFlow, HAConfigFlow, domain=DOMAIN
 ):
     """Handle a config flow for Versatile Thermostat."""
@@ -808,14 +981,15 @@ class VersatileThermostatConfigFlow(
     @callback
     def async_get_options_flow(config_entry: ConfigEntry):
         """Get options flow for this handler"""
+        # #713 doesn't work as explained here:https://developers.home-assistant.io/blog/2024/11/12/options-flow
+        #  should be - return VersatileThermostatOptionsFlowHandler() but hass is not initialized
         return VersatileThermostatOptionsFlowHandler(config_entry)
 
     async def async_step_finalize(self, _):
         """Finalization of the ConfigEntry creation"""
         _LOGGER.debug("ConfigFlow.async_finalize")
-        # Removes temporary value
-        if COMES_FROM in self._infos:
-            del self._infos[COMES_FROM]
+        await super().async_step_finalize(_)
+
         return self.async_create_entry(title=self._infos[CONF_NAME], data=self._infos)
 
 
@@ -826,8 +1000,12 @@ class VersatileThermostatOptionsFlowHandler(
 
     def __init__(self, config_entry: ConfigEntry) -> None:
         """Initialize options flow."""
+
+        self._conf_app_id: str | None = None
+
         super().__init__(config_entry.data.copy())
-        self.config_entry = config_entry
+        # #713
+        # self.config_entry = config_entry
         _LOGGER.debug(
             "CTOR VersatileThermostatOptionsFlowHandler info: %s, entry_id: %s",
             self._infos,
@@ -849,35 +1027,13 @@ class VersatileThermostatOptionsFlowHandler(
 
     async def async_step_finalize(self, _):
         """Finalization of the ConfigEntry creation"""
-        if not self._infos[CONF_USE_WINDOW_FEATURE]:
-            self._infos[CONF_USE_WINDOW_CENTRAL_CONFIG] = False
-            self._infos[CONF_WINDOW_SENSOR] = None
-            self._infos[CONF_WINDOW_AUTO_CLOSE_THRESHOLD] = None
-            self._infos[CONF_WINDOW_AUTO_OPEN_THRESHOLD] = None
-            self._infos[CONF_WINDOW_AUTO_MAX_DURATION] = None
-        if not self._infos[CONF_USE_MOTION_FEATURE]:
-            self._infos[CONF_USE_MOTION_CENTRAL_CONFIG] = False
-            self._infos[CONF_MOTION_SENSOR] = None
-        if not self._infos[CONF_USE_POWER_FEATURE]:
-            self._infos[CONF_USE_POWER_CENTRAL_CONFIG] = False
-            self._infos[CONF_POWER_SENSOR] = None
-            self._infos[CONF_MAX_POWER_SENSOR] = None
-        if not self._infos[CONF_USE_PRESENCE_FEATURE]:
-            self._infos[CONF_USE_PRESENCE_CENTRAL_CONFIG] = False
-            self._infos[CONF_PRESENCE_SENSOR] = None
-        if not self._infos[CONF_USE_CENTRAL_BOILER_FEATURE]:
-            self._infos[CONF_CENTRAL_BOILER_ACTIVATION_SRV] = None
-            self._infos[CONF_CENTRAL_BOILER_DEACTIVATION_SRV] = None
 
         _LOGGER.info(
             "Recreating entry %s due to configuration change. New config is now: %s",
             self.config_entry.entry_id,
             self._infos,
         )
-
-        # Removes temporary value
-        if COMES_FROM in self._infos:
-            del self._infos[COMES_FROM]
+        await super().async_step_finalize(_)
 
         self.hass.config_entries.async_update_entry(self.config_entry, data=self._infos)
         return self.async_create_entry(title=None, data=None)

custom_components/versatile_thermostat/config_schema.py

@@ -16,6 +16,14 @@ from homeassistant.components.input_number import (
     DOMAIN as INPUT_NUMBER_DOMAIN,
 )
 
+from homeassistant.components.select import (
+    DOMAIN as SELECT_DOMAIN,
+)
+
+from homeassistant.components.input_select import (
+    DOMAIN as INPUT_SELECT_DOMAIN,
+)
+
 from homeassistant.components.input_datetime import (
     DOMAIN as INPUT_DATETIME_DOMAIN,
 )
@@ -68,6 +76,16 @@ STEP_FEATURES_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
     }
 )
 
+STEP_CLIMATE_FEATURES_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
+    {
+        vol.Optional(CONF_USE_WINDOW_FEATURE, default=False): cv.boolean,
+        vol.Optional(CONF_USE_MOTION_FEATURE, default=False): cv.boolean,
+        vol.Optional(CONF_USE_POWER_FEATURE, default=False): cv.boolean,
+        vol.Optional(CONF_USE_PRESENCE_FEATURE, default=False): cv.boolean,
+        vol.Optional(CONF_USE_AUTO_START_STOP_FEATURE, default=False): cv.boolean,
+    }
+)
+
 STEP_CENTRAL_FEATURES_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
     {
         vol.Optional(CONF_USE_WINDOW_FEATURE, default=False): cv.boolean,
@@ -109,17 +127,8 @@ STEP_CENTRAL_BOILER_SCHEMA = vol.Schema(
 
 STEP_THERMOSTAT_SWITCH = vol.Schema(  # pylint: disable=invalid-name
     {
-        vol.Required(CONF_HEATER): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]),
-        ),
-        vol.Optional(CONF_HEATER_2): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]),
-        ),
-        vol.Optional(CONF_HEATER_3): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]),
-        ),
-        vol.Optional(CONF_HEATER_4): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]),
+        vol.Required(CONF_UNDERLYING_LIST): selector.EntitySelector(
+            selector.EntitySelectorConfig(domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN, SELECT_DOMAIN, INPUT_SELECT_DOMAIN, CLIMATE_DOMAIN], multiple=True),
         ),
         vol.Optional(CONF_HEATER_KEEP_ALIVE): cv.positive_int,
         vol.Required(CONF_PROP_FUNCTION, default=PROPORTIONAL_FUNCTION_TPI): vol.In(
@@ -129,22 +138,17 @@ STEP_THERMOSTAT_SWITCH = vol.Schema(  # pylint: disable=invalid-name
         ),
         vol.Optional(CONF_AC_MODE, default=False): cv.boolean,
         vol.Optional(CONF_INVERSE_SWITCH, default=False): cv.boolean,
+        vol.Optional("on_command_text"): vol.In([]),
+        vol.Optional(CONF_VSWITCH_ON_CMD_LIST): selector.TextSelector(selector.TextSelectorConfig(type=selector.TextSelectorType.TEXT, multiple=True)),
+        vol.Optional("off_command_text"): vol.In([]),
+        vol.Optional(CONF_VSWITCH_OFF_CMD_LIST): selector.TextSelector(selector.TextSelectorConfig(type=selector.TextSelectorType.TEXT, multiple=True)),
     }
 )
 
 STEP_THERMOSTAT_CLIMATE = vol.Schema(  # pylint: disable=invalid-name
     {
-        vol.Required(CONF_CLIMATE): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=CLIMATE_DOMAIN),
-        ),
-        vol.Optional(CONF_CLIMATE_2): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=CLIMATE_DOMAIN),
-        ),
-        vol.Optional(CONF_CLIMATE_3): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=CLIMATE_DOMAIN),
-        ),
-        vol.Optional(CONF_CLIMATE_4): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=CLIMATE_DOMAIN),
+        vol.Required(CONF_UNDERLYING_LIST): selector.EntitySelector(
+            selector.EntitySelectorConfig(domain=CLIMATE_DOMAIN, multiple=True),
         ),
         vol.Optional(CONF_AC_MODE, default=False): cv.boolean,
         vol.Optional(
@@ -173,17 +177,10 @@ STEP_THERMOSTAT_CLIMATE = vol.Schema(  # pylint: disable=invalid-name
 
 STEP_THERMOSTAT_VALVE = vol.Schema(  # pylint: disable=invalid-name
     {
-        vol.Required(CONF_VALVE): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN]),
-        ),
-        vol.Optional(CONF_VALVE_2): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN]),
-        ),
-        vol.Optional(CONF_VALVE_3): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN]),
-        ),
-        vol.Optional(CONF_VALVE_4): selector.EntitySelector(
-            selector.EntitySelectorConfig(domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN]),
+        vol.Required(CONF_UNDERLYING_LIST): selector.EntitySelector(
+            selector.EntitySelectorConfig(
+                domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN], multiple=True
+            ),
         ),
         vol.Required(CONF_PROP_FUNCTION, default=PROPORTIONAL_FUNCTION_TPI): vol.In(
             [
@@ -196,6 +193,46 @@ STEP_THERMOSTAT_VALVE = vol.Schema(  # pylint: disable=invalid-name
     }
 )
 
+STEP_AUTO_START_STOP = vol.Schema(  # pylint: disable=invalid-name
+    {
+        vol.Optional(
+            CONF_AUTO_START_STOP_LEVEL, default=AUTO_START_STOP_LEVEL_NONE
+        ): selector.SelectSelector(
+            selector.SelectSelectorConfig(
+                options=CONF_AUTO_START_STOP_LEVELS,
+                translation_key="auto_start_stop",
+                mode="dropdown",
+            )
+        ),
+    }
+)
+
+STEP_VALVE_REGULATION = vol.Schema(  # pylint: disable=invalid-name
+    {
+        vol.Required(CONF_OPENING_DEGREE_LIST): selector.EntitySelector(
+            selector.EntitySelectorConfig(
+                domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN], multiple=True
+            ),
+        ),
+        vol.Optional(CONF_OFFSET_CALIBRATION_LIST): selector.EntitySelector(
+            selector.EntitySelectorConfig(
+                domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN], multiple=True
+            ),
+        ),
+        vol.Optional(CONF_CLOSING_DEGREE_LIST): selector.EntitySelector(
+            selector.EntitySelectorConfig(
+                domain=[NUMBER_DOMAIN, INPUT_NUMBER_DOMAIN], multiple=True
+            ),
+        ),
+        vol.Required(CONF_PROP_FUNCTION, default=PROPORTIONAL_FUNCTION_TPI): vol.In(
+            [
+                PROPORTIONAL_FUNCTION_TPI,
+            ]
+        ),
+        vol.Optional(CONF_MIN_OPENING_DEGREES, default=""): str,
+    }
+)
+
 STEP_TPI_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
     {
         vol.Required(CONF_USE_TPI_CENTRAL_CONFIG, default=True): cv.boolean,
@@ -204,8 +241,8 @@ STEP_TPI_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
 
 STEP_CENTRAL_TPI_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
     {
-        vol.Required(CONF_TPI_COEF_INT, default=0.6): vol.Coerce(float),
-        vol.Required(CONF_TPI_COEF_EXT, default=0.01): vol.Coerce(float),
+        vol.Required(CONF_TPI_COEF_INT, default=0.6): selector.NumberSelector(selector.NumberSelectorConfig(min=0.0, max=1.0, step=0.01, mode=selector.NumberSelectorMode.BOX)),
+        vol.Required(CONF_TPI_COEF_EXT, default=0.01): selector.NumberSelector(selector.NumberSelectorConfig(min=0.0, max=1.0, step=0.001, mode=selector.NumberSelectorMode.BOX)),
     }
 )
 
@@ -230,12 +267,11 @@ STEP_WINDOW_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
 STEP_CENTRAL_WINDOW_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
     {
         vol.Optional(CONF_WINDOW_DELAY, default=30): cv.positive_int,
+        vol.Optional(CONF_WINDOW_OFF_DELAY, default=30): cv.positive_int,
         vol.Optional(CONF_WINDOW_AUTO_OPEN_THRESHOLD, default=3): vol.Coerce(float),
         vol.Optional(CONF_WINDOW_AUTO_CLOSE_THRESHOLD, default=0): vol.Coerce(float),
         vol.Optional(CONF_WINDOW_AUTO_MAX_DURATION, default=30): cv.positive_int,
-        vol.Optional(
-            CONF_WINDOW_ACTION, default=CONF_WINDOW_TURN_OFF
-        ): selector.SelectSelector(
+        vol.Optional(CONF_WINDOW_ACTION, default=CONF_WINDOW_TURN_OFF): selector.SelectSelector(
             selector.SelectSelectorConfig(
                 options=CONF_WINDOW_ACTIONS,
                 translation_key="window_action",
@@ -248,9 +284,8 @@ STEP_CENTRAL_WINDOW_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
 STEP_CENTRAL_WINDOW_WO_AUTO_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
     {
         vol.Optional(CONF_WINDOW_DELAY, default=30): cv.positive_int,
-        vol.Optional(
-            CONF_WINDOW_ACTION, default=CONF_WINDOW_TURN_OFF
-        ): selector.SelectSelector(
+        vol.Optional(CONF_WINDOW_OFF_DELAY, default=30): cv.positive_int,
+        vol.Optional(CONF_WINDOW_ACTION, default=CONF_WINDOW_TURN_OFF): selector.SelectSelector(
             selector.SelectSelectorConfig(
                 options=CONF_WINDOW_ACTIONS,
                 translation_key="window_action",
@@ -304,6 +339,12 @@ STEP_CENTRAL_POWER_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
     }
 )
 
+STEP_NON_CENTRAL_POWER_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
+    {
+        vol.Optional(CONF_PRESET_POWER, default="13"): vol.Coerce(float),
+    }
+)
+
 STEP_POWER_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
     {
         vol.Required(CONF_USE_POWER_CENTRAL_CONFIG, default=True): cv.boolean,
@@ -333,14 +374,14 @@ STEP_PRESENCE_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
 STEP_CENTRAL_ADVANCED_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
     {
         vol.Required(CONF_MINIMAL_ACTIVATION_DELAY, default=10): cv.positive_int,
-        vol.Required(CONF_SECURITY_DELAY_MIN, default=60): cv.positive_int,
+        vol.Required(CONF_SAFETY_DELAY_MIN, default=60): cv.positive_int,
         vol.Required(
-            CONF_SECURITY_MIN_ON_PERCENT,
-            default=DEFAULT_SECURITY_MIN_ON_PERCENT,
+            CONF_SAFETY_MIN_ON_PERCENT,
+            default=DEFAULT_SAFETY_MIN_ON_PERCENT,
         ): vol.Coerce(float),
         vol.Required(
-            CONF_SECURITY_DEFAULT_ON_PERCENT,
-            default=DEFAULT_SECURITY_DEFAULT_ON_PERCENT,
+            CONF_SAFETY_DEFAULT_ON_PERCENT,
+            default=DEFAULT_SAFETY_DEFAULT_ON_PERCENT,
         ): vol.Coerce(float),
     }
 )

custom_components/versatile_thermostat/const.py

@@ -2,8 +2,13 @@
 """Constants for the Versatile Thermostat integration."""
 
 import logging
+import math
+from typing import Literal
+
+from datetime import datetime
 
 from enum import Enum
+from homeassistant.core import HomeAssistant
 from homeassistant.const import CONF_NAME, Platform
 
 from homeassistant.components.climate import (
@@ -15,6 +20,7 @@ from homeassistant.components.climate import (
 )
 
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.util import dt as dt_util
 
 from .prop_algorithm import (
     PROPORTIONAL_FUNCTION_TPI,
@@ -22,8 +28,8 @@ from .prop_algorithm import (
 
 _LOGGER = logging.getLogger(__name__)
 
-CONFIG_VERSION = 1
-CONFIG_MINOR_VERSION = 2
+CONFIG_VERSION = 2
+CONFIG_MINOR_VERSION = 1
 
 PRESET_TEMP_SUFFIX = "_temp"
 PRESET_AC_SUFFIX = "_ac"
@@ -36,10 +42,10 @@ DEVICE_MANUFACTURER = "JMCOLLIN"
 DEVICE_MODEL = "Versatile Thermostat"
 
 PRESET_POWER = "power"
-PRESET_SECURITY = "security"
+PRESET_SAFETY = "security"
 PRESET_FROST_PROTECTION = "frost"
 
-HIDDEN_PRESETS = [PRESET_POWER, PRESET_SECURITY]
+HIDDEN_PRESETS = [PRESET_POWER, PRESET_SAFETY]
 
 DOMAIN = "versatile_thermostat"
 
@@ -51,12 +57,10 @@ PLATFORMS: list[Platform] = [
     # Number should be after CLIMATE
     Platform.NUMBER,
     Platform.BINARY_SENSOR,
+    Platform.SWITCH,
 ]
 
-CONF_HEATER = "heater_entity_id"
-CONF_HEATER_2 = "heater_entity2_id"
-CONF_HEATER_3 = "heater_entity3_id"
-CONF_HEATER_4 = "heater_entity4_id"
+CONF_UNDERLYING_LIST = "underlying_entity_ids"
 CONF_HEATER_KEEP_ALIVE = "heater_keep_alive"
 CONF_TEMP_SENSOR = "temperature_sensor_entity_id"
 CONF_LAST_SEEN_TEMP_SENSOR = "last_seen_temperature_sensor_entity_id"
@@ -69,6 +73,7 @@ CONF_DEVICE_POWER = "device_power"
 CONF_CYCLE_MIN = "cycle_min"
 CONF_PROP_FUNCTION = "proportional_function"
 CONF_WINDOW_DELAY = "window_delay"
+CONF_WINDOW_OFF_DELAY = "window_off_delay"
 CONF_MOTION_DELAY = "motion_delay"
 CONF_MOTION_OFF_DELAY = "motion_off_delay"
 CONF_MOTION_PRESET = "motion_preset"
@@ -80,33 +85,27 @@ CONF_PRESET_POWER = "power_temp"
 CONF_MINIMAL_ACTIVATION_DELAY = "minimal_activation_delay"
 CONF_TEMP_MIN = "temp_min"
 CONF_TEMP_MAX = "temp_max"
-CONF_SECURITY_DELAY_MIN = "security_delay_min"
-CONF_SECURITY_MIN_ON_PERCENT = "security_min_on_percent"
-CONF_SECURITY_DEFAULT_ON_PERCENT = "security_default_on_percent"
+CONF_SAFETY_DELAY_MIN = "safety_delay_min"
+CONF_SAFETY_MIN_ON_PERCENT = "safety_min_on_percent"
+CONF_SAFETY_DEFAULT_ON_PERCENT = "safety_default_on_percent"
 CONF_THERMOSTAT_TYPE = "thermostat_type"
 CONF_THERMOSTAT_CENTRAL_CONFIG = "thermostat_central_config"
 CONF_THERMOSTAT_SWITCH = "thermostat_over_switch"
 CONF_THERMOSTAT_CLIMATE = "thermostat_over_climate"
 CONF_THERMOSTAT_VALVE = "thermostat_over_valve"
-CONF_CLIMATE = "climate_entity_id"
-CONF_CLIMATE_2 = "climate_entity2_id"
-CONF_CLIMATE_3 = "climate_entity3_id"
-CONF_CLIMATE_4 = "climate_entity4_id"
 CONF_USE_WINDOW_FEATURE = "use_window_feature"
 CONF_USE_MOTION_FEATURE = "use_motion_feature"
 CONF_USE_PRESENCE_FEATURE = "use_presence_feature"
 CONF_USE_POWER_FEATURE = "use_power_feature"
 CONF_USE_CENTRAL_BOILER_FEATURE = "use_central_boiler_feature"
+CONF_USE_AUTO_START_STOP_FEATURE = "use_auto_start_stop_feature"
 CONF_AC_MODE = "ac_mode"
 CONF_WINDOW_AUTO_OPEN_THRESHOLD = "window_auto_open_threshold"
 CONF_WINDOW_AUTO_CLOSE_THRESHOLD = "window_auto_close_threshold"
 CONF_WINDOW_AUTO_MAX_DURATION = "window_auto_max_duration"
-CONF_VALVE = "valve_entity_id"
-CONF_VALVE_2 = "valve_entity2_id"
-CONF_VALVE_3 = "valve_entity3_id"
-CONF_VALVE_4 = "valve_entity4_id"
 CONF_AUTO_REGULATION_MODE = "auto_regulation_mode"
 CONF_AUTO_REGULATION_NONE = "auto_regulation_none"
+CONF_AUTO_REGULATION_VALVE = "auto_regulation_valve"
 CONF_AUTO_REGULATION_SLOW = "auto_regulation_slow"
 CONF_AUTO_REGULATION_LIGHT = "auto_regulation_light"
 CONF_AUTO_REGULATION_MEDIUM = "auto_regulation_medium"
@@ -123,10 +122,32 @@ CONF_AUTO_FAN_MEDIUM = "auto_fan_medium"
 CONF_AUTO_FAN_HIGH = "auto_fan_high"
 CONF_AUTO_FAN_TURBO = "auto_fan_turbo"
 CONF_STEP_TEMPERATURE = "step_temperature"
+CONF_OFFSET_CALIBRATION_LIST = "offset_calibration_entity_ids"
+CONF_OPENING_DEGREE_LIST = "opening_degree_entity_ids"
+CONF_CLOSING_DEGREE_LIST = "closing_degree_entity_ids"
+CONF_MIN_OPENING_DEGREES = "min_opening_degrees"
+
+CONF_VSWITCH_ON_CMD_LIST = "vswitch_on_command"
+CONF_VSWITCH_OFF_CMD_LIST = "vswitch_off_command"
+
+# Deprecated
+CONF_HEATER = "heater_entity_id"
+CONF_HEATER_2 = "heater_entity2_id"
+CONF_HEATER_3 = "heater_entity3_id"
+CONF_HEATER_4 = "heater_entity4_id"
+CONF_CLIMATE = "climate_entity_id"
+CONF_CLIMATE_2 = "climate_entity2_id"
+CONF_CLIMATE_3 = "climate_entity3_id"
+CONF_CLIMATE_4 = "climate_entity4_id"
+CONF_VALVE = "valve_entity_id"
+CONF_VALVE_2 = "valve_entity2_id"
+CONF_VALVE_3 = "valve_entity3_id"
+CONF_VALVE_4 = "valve_entity4_id"
 
 # Global params into configuration.yaml
 CONF_SHORT_EMA_PARAMS = "short_ema_params"
 CONF_SAFETY_MODE = "safety_mode"
+CONF_MAX_ON_PERCENT = "max_on_percent"
 
 CONF_USE_MAIN_CENTRAL_CONFIG = "use_main_central_config"
 CONF_USE_TPI_CENTRAL_CONFIG = "use_tpi_central_config"
@@ -145,6 +166,36 @@ CONF_CENTRAL_BOILER_DEACTIVATION_SRV = "central_boiler_deactivation_service"
 CONF_USED_BY_CENTRAL_BOILER = "used_by_controls_central_boiler"
 CONF_WINDOW_ACTION = "window_action"
 
+CONF_AUTO_START_STOP_LEVEL = "auto_start_stop_level"
+AUTO_START_STOP_LEVEL_NONE = "auto_start_stop_none"
+AUTO_START_STOP_LEVEL_SLOW = "auto_start_stop_slow"
+AUTO_START_STOP_LEVEL_MEDIUM = "auto_start_stop_medium"
+AUTO_START_STOP_LEVEL_FAST = "auto_start_stop_fast"
+CONF_AUTO_START_STOP_LEVELS = [
+    AUTO_START_STOP_LEVEL_NONE,
+    AUTO_START_STOP_LEVEL_SLOW,
+    AUTO_START_STOP_LEVEL_MEDIUM,
+    AUTO_START_STOP_LEVEL_FAST,
+]
+
+# For explicit typing purpose only
+TYPE_AUTO_START_STOP_LEVELS = Literal[  # pylint: disable=invalid-name
+    AUTO_START_STOP_LEVEL_FAST,
+    AUTO_START_STOP_LEVEL_MEDIUM,
+    AUTO_START_STOP_LEVEL_SLOW,
+    AUTO_START_STOP_LEVEL_NONE,
+]
+
+HVAC_OFF_REASON_NAME = "hvac_off_reason"
+HVAC_OFF_REASON_MANUAL = "manual"
+HVAC_OFF_REASON_AUTO_START_STOP = "auto_start_stop"
+HVAC_OFF_REASON_WINDOW_DETECTION = "window_detection"
+HVAC_OFF_REASONS = Literal[  # pylint: disable=invalid-name
+    HVAC_OFF_REASON_MANUAL,
+    HVAC_OFF_REASON_AUTO_START_STOP,
+    HVAC_OFF_REASON_WINDOW_DETECTION,
+]
+
 DEFAULT_SHORT_EMA_PARAMS = {
     "max_alpha": 0.5,
     # In sec
@@ -216,10 +267,6 @@ CONF_PRESETS_AWAY_WITH_AC_VALUES = list(CONF_PRESETS_AWAY_WITH_AC.values())
 ALL_CONF = (
     [
         CONF_NAME,
-        CONF_HEATER,
-        CONF_HEATER_2,
-        CONF_HEATER_3,
-        CONF_HEATER_4,
         CONF_HEATER_KEEP_ALIVE,
         CONF_TEMP_SENSOR,
         CONF_EXTERNAL_TEMP_SENSOR,
@@ -227,6 +274,7 @@ ALL_CONF = (
         CONF_MAX_POWER_SENSOR,
         CONF_WINDOW_SENSOR,
         CONF_WINDOW_DELAY,
+        CONF_WINDOW_OFF_DELAY,
         CONF_WINDOW_AUTO_OPEN_THRESHOLD,
         CONF_WINDOW_AUTO_CLOSE_THRESHOLD,
         CONF_WINDOW_AUTO_MAX_DURATION,
@@ -243,26 +291,18 @@ ALL_CONF = (
         CONF_MINIMAL_ACTIVATION_DELAY,
         CONF_TEMP_MIN,
         CONF_TEMP_MAX,
-        CONF_SECURITY_DELAY_MIN,
-        CONF_SECURITY_MIN_ON_PERCENT,
-        CONF_SECURITY_DEFAULT_ON_PERCENT,
+        CONF_SAFETY_DELAY_MIN,
+        CONF_SAFETY_MIN_ON_PERCENT,
+        CONF_SAFETY_DEFAULT_ON_PERCENT,
         CONF_THERMOSTAT_TYPE,
         CONF_THERMOSTAT_SWITCH,
         CONF_THERMOSTAT_CLIMATE,
-        CONF_CLIMATE,
-        CONF_CLIMATE_2,
-        CONF_CLIMATE_3,
-        CONF_CLIMATE_4,
         CONF_USE_WINDOW_FEATURE,
         CONF_USE_MOTION_FEATURE,
         CONF_USE_PRESENCE_FEATURE,
         CONF_USE_POWER_FEATURE,
         CONF_USE_CENTRAL_BOILER_FEATURE,
         CONF_AC_MODE,
-        CONF_VALVE,
-        CONF_VALVE_2,
-        CONF_VALVE_3,
-        CONF_VALVE_4,
         CONF_AUTO_REGULATION_MODE,
         CONF_AUTO_REGULATION_DTEMP,
         CONF_AUTO_REGULATION_PERIOD_MIN,
@@ -296,6 +336,7 @@ CONF_FUNCTIONS = [
 
 CONF_AUTO_REGULATION_MODES = [
     CONF_AUTO_REGULATION_NONE,
+    CONF_AUTO_REGULATION_VALVE,
     CONF_AUTO_REGULATION_LIGHT,
     CONF_AUTO_REGULATION_MEDIUM,
     CONF_AUTO_REGULATION_STRONG,
@@ -330,17 +371,21 @@ CONF_WINDOW_ACTIONS = [
     CONF_WINDOW_ECO_TEMP,
 ]
 
-SUPPORT_FLAGS = ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.TURN_OFF | ClimateEntityFeature.TURN_ON
+SUPPORT_FLAGS = (
+    ClimateEntityFeature.TARGET_TEMPERATURE
+    | ClimateEntityFeature.TURN_OFF
+    | ClimateEntityFeature.TURN_ON
+)
 
 SERVICE_SET_PRESENCE = "set_presence"
 SERVICE_SET_PRESET_TEMPERATURE = "set_preset_temperature"
-SERVICE_SET_SECURITY = "set_security"
+SERVICE_SET_SAFETY = "set_safety"
 SERVICE_SET_WINDOW_BYPASS = "set_window_bypass"
 SERVICE_SET_AUTO_REGULATION_MODE = "set_auto_regulation_mode"
 SERVICE_SET_AUTO_FAN_MODE = "set_auto_fan_mode"
 
-DEFAULT_SECURITY_MIN_ON_PERCENT = 0.5
-DEFAULT_SECURITY_DEFAULT_ON_PERCENT = 0.1
+DEFAULT_SAFETY_MIN_ON_PERCENT = 0.5
+DEFAULT_SAFETY_DEFAULT_ON_PERCENT = 0.1
 
 ATTR_TOTAL_ENERGY = "total_energy"
 ATTR_MEAN_POWER_CYCLE = "mean_cycle_power"
@@ -430,9 +475,9 @@ class RegulationParamVeryStrong:
     kp: float = 0.6
     ki: float = 0.1
     k_ext: float = 0.2
-    offset_max: float = 4
+    offset_max: float = 8
     stabilization_threshold: float = 0.1
-    accumulated_error_threshold: float = 30
+    accumulated_error_threshold: float = 80
 
 
 class EventType(Enum):
@@ -445,6 +490,7 @@ class EventType(Enum):
     CENTRAL_BOILER_EVENT: str = "versatile_thermostat_central_boiler_event"
     PRESET_EVENT: str = "versatile_thermostat_preset_event"
     WINDOW_AUTO_EVENT: str = "versatile_thermostat_window_auto_event"
+    AUTO_START_STOP_EVENT: str = "versatile_thermostat_auto_start_stop_event"
 
 
 def send_vtherm_event(hass, event_type: EventType, entity, data: dict):
@@ -456,6 +502,40 @@ def send_vtherm_event(hass, event_type: EventType, entity, data: dict):
     hass.bus.fire(event_type.value, data)
 
 
+def get_safe_float(hass, entity_id: str):
+    """Get a safe float state value for an entity.
+    Return None if entity is not available"""
+    if (
+        entity_id is None
+        or not (state := hass.states.get(entity_id))
+        or state.state is None
+        or state.state == "None"
+        or state.state == "unknown"
+        or state.state == "unavailable"
+    ):
+        return None
+    float_val = float(state.state)
+    return None if math.isinf(float_val) or not math.isfinite(float_val) else float_val
+
+
+def get_tz(hass: HomeAssistant):
+    """Get the current timezone"""
+
+    return dt_util.get_time_zone(hass.config.time_zone)
+
+
+class NowClass:
+    """For testing purpose only"""
+
+    @staticmethod
+    def get_now(hass: HomeAssistant) -> datetime:
+        """A test function to get the now.
+        For testing purpose this method can be overriden to get a specific
+        timestamp.
+        """
+        return datetime.now(get_tz(hass))
+
+
 class UnknownEntity(HomeAssistantError):
     """Error to indicate there is an unknown entity_id given."""
 
@@ -476,6 +556,19 @@ class ConfigurationNotCompleteError(HomeAssistantError):
     """Error the configuration is not complete"""
 
 
+class ValveRegulationNbEntitiesIncorrect(HomeAssistantError):
+    """Error to indicate there is an error in the configuration of the TRV with valve regulation.
+    The number of specific entities is incorrect."""
+
+
+class ValveRegulationMinOpeningDegreesIncorrect(HomeAssistantError):
+    """Error to indicate that the minimal opening degrees is not a list of int separated by coma"""
+
+
+class VirtualSwitchConfigurationIncorrect(HomeAssistantError):
+    """Error when a virtual switch is not configured correctly"""
+
+
 class overrides:  # pylint: disable=invalid-name
     """An annotation to inform overrides"""
 

custom_components/versatile_thermostat/feature_auto_start_stop_manager.py

@@ -0,0 +1,240 @@
+""" Implements the Auto-start/stop Feature Manager """
+
+# pylint: disable=line-too-long
+
+import logging
+from typing import Any
+
+from homeassistant.core import (
+    HomeAssistant,
+)
+from homeassistant.components.climate import HVACMode
+
+from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from .commons import ConfigData
+
+from .base_manager import BaseFeatureManager
+
+from .auto_start_stop_algorithm import (
+    AutoStartStopDetectionAlgorithm,
+    AUTO_START_STOP_ACTION_OFF,
+    AUTO_START_STOP_ACTION_ON,
+)
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class FeatureAutoStartStopManager(BaseFeatureManager):
+    """The implementation of the AutoStartStop feature"""
+
+    unrecorded_attributes = frozenset(
+        {
+            "auto_start_stop_level",
+            "auto_start_stop_dtmin",
+            "auto_start_stop_enable",
+            "auto_start_stop_accumulated_error",
+            "auto_start_stop_accumulated_error_threshold",
+            "auto_start_stop_last_switch_date",
+        }
+    )
+
+    def __init__(self, vtherm: Any, hass: HomeAssistant):
+        """Init of a featureManager"""
+        super().__init__(vtherm, hass)
+
+        self._auto_start_stop_level: TYPE_AUTO_START_STOP_LEVELS = (
+            AUTO_START_STOP_LEVEL_NONE
+        )
+        self._auto_start_stop_algo: AutoStartStopDetectionAlgorithm | None = None
+        self._is_configured: bool = False
+        self._is_auto_start_stop_enabled: bool = False
+
+    @overrides
+    def post_init(self, entry_infos: ConfigData):
+        """Reinit of the manager"""
+
+        use_auto_start_stop = entry_infos.get(CONF_USE_AUTO_START_STOP_FEATURE, False)
+        if use_auto_start_stop:
+            self._auto_start_stop_level = (
+                entry_infos.get(CONF_AUTO_START_STOP_LEVEL, None)
+                or AUTO_START_STOP_LEVEL_NONE
+            )
+            self._is_configured = True
+        else:
+            self._auto_start_stop_level = AUTO_START_STOP_LEVEL_NONE
+            self._is_configured = False
+
+        # Instanciate the auto start stop algo
+        self._auto_start_stop_algo = AutoStartStopDetectionAlgorithm(
+            self._auto_start_stop_level, self.name
+        )
+
+        # Fix an eventual incoherent state
+        if self._vtherm.is_on and self._vtherm.hvac_off_reason == HVAC_OFF_REASON_AUTO_START_STOP:
+            self._vtherm.hvac_off_reason = None
+
+    @overrides
+    async def start_listening(self):
+        """Start listening the underlying entity"""
+
+    @overrides
+    def stop_listening(self):
+        """Stop listening and remove the eventual timer still running"""
+
+    @overrides
+    async def refresh_state(self) -> bool:
+        """Check the auto-start-stop and an eventual action
+        Return False if we should stop the control_heating method"""
+
+        if not self._is_configured or not self._is_auto_start_stop_enabled:
+            _LOGGER.debug("%s - auto start/stop is disabled (or not configured)", self)
+            return True
+
+        slope = (
+            self._vtherm.last_temperature_slope or 0
+        ) / 60  # to have the slope in °/min
+        action = self._auto_start_stop_algo.calculate_action(
+            self._vtherm.hvac_mode,
+            self._vtherm.saved_hvac_mode,
+            self._vtherm.target_temperature,
+            self._vtherm.current_temperature,
+            slope,
+            self._vtherm.now,
+        )
+        _LOGGER.debug("%s - auto_start_stop action is %s", self, action)
+        if action == AUTO_START_STOP_ACTION_OFF and self._vtherm.is_on:
+            _LOGGER.info(
+                "%s - Turning OFF the Vtherm due to auto-start-stop conditions",
+                self,
+            )
+            self._vtherm.set_hvac_off_reason(HVAC_OFF_REASON_AUTO_START_STOP)
+            await self._vtherm.async_turn_off()
+
+            # Send an event
+            self._vtherm.send_event(
+                event_type=EventType.AUTO_START_STOP_EVENT,
+                data={
+                    "type": "stop",
+                    "name": self.name,
+                    "cause": "Auto stop conditions reached",
+                    "hvac_mode": self._vtherm.hvac_mode,
+                    "saved_hvac_mode": self._vtherm.saved_hvac_mode,
+                    "target_temperature": self._vtherm.target_temperature,
+                    "current_temperature": self._vtherm.current_temperature,
+                    "temperature_slope": round(slope, 3),
+                    "accumulated_error": self._auto_start_stop_algo.accumulated_error,
+                    "accumulated_error_threshold": self._auto_start_stop_algo.accumulated_error_threshold,
+                },
+            )
+
+            # Stop here
+            return False
+        elif (
+            action == AUTO_START_STOP_ACTION_ON
+            and self._vtherm.hvac_off_reason == HVAC_OFF_REASON_AUTO_START_STOP
+        ):
+            _LOGGER.info(
+                "%s - Turning ON the Vtherm due to auto-start-stop conditions", self
+            )
+            await self._vtherm.async_turn_on()
+
+            # Send an event
+            self._vtherm.send_event(
+                event_type=EventType.AUTO_START_STOP_EVENT,
+                data={
+                    "type": "start",
+                    "name": self.name,
+                    "cause": "Auto start conditions reached",
+                    "hvac_mode": self._vtherm.hvac_mode,
+                    "saved_hvac_mode": self._vtherm.saved_hvac_mode,
+                    "target_temperature": self._vtherm.target_temperature,
+                    "current_temperature": self._vtherm.current_temperature,
+                    "temperature_slope": round(slope, 3),
+                    "accumulated_error": self._auto_start_stop_algo.accumulated_error,
+                    "accumulated_error_threshold": self._auto_start_stop_algo.accumulated_error_threshold,
+                },
+            )
+
+            self._vtherm.update_custom_attributes()
+
+        return True
+
+    def set_auto_start_stop_enable(self, is_enabled: bool):
+        """Enable/Disable the auto-start/stop feature"""
+        self._is_auto_start_stop_enabled = is_enabled
+        if (
+            self._vtherm.hvac_mode == HVACMode.OFF
+            and self._vtherm.hvac_off_reason == HVAC_OFF_REASON_AUTO_START_STOP
+        ):
+            _LOGGER.debug(
+                "%s - the vtherm is off cause auto-start/stop and enable have been set to false -> starts the VTherm"
+            )
+            self.hass.create_task(self._vtherm.async_turn_on())
+
+            # Send an event
+            self._vtherm.send_event(
+                event_type=EventType.AUTO_START_STOP_EVENT,
+                data={
+                    "type": "start",
+                    "name": self.name,
+                    "cause": "Auto start stop disabled",
+                    "hvac_mode": self._vtherm.hvac_mode,
+                    "saved_hvac_mode": self._vtherm.saved_hvac_mode,
+                    "target_temperature": self._vtherm.target_temperature,
+                    "current_temperature": self._vtherm.current_temperature,
+                    "temperature_slope": round(
+                        self._vtherm.last_temperature_slope or 0, 3
+                    ),
+                    "accumulated_error": self._auto_start_stop_algo.accumulated_error,
+                    "accumulated_error_threshold": self._auto_start_stop_algo.accumulated_error_threshold,
+                },
+            )
+
+        self._vtherm.update_custom_attributes()
+
+    def add_custom_attributes(self, extra_state_attributes: dict[str, Any]):
+        """Add some custom attributes"""
+        extra_state_attributes.update(
+            {
+                "is_auto_start_stop_configured": self.is_configured,
+            }
+        )
+        if self.is_configured:
+            extra_state_attributes.update(
+                {
+                    "auto_start_stop_enable": self.auto_start_stop_enable,
+                    "auto_start_stop_level": self._auto_start_stop_algo.level,
+                    "auto_start_stop_dtmin": self._auto_start_stop_algo.dt_min,
+                    "auto_start_stop_accumulated_error": self._auto_start_stop_algo.accumulated_error,
+                    "auto_start_stop_accumulated_error_threshold": self._auto_start_stop_algo.accumulated_error_threshold,
+                    "auto_start_stop_last_switch_date": self._auto_start_stop_algo.last_switch_date,
+                }
+            )
+
+    @overrides
+    @property
+    def is_configured(self) -> bool:
+        """Return True of the aiuto-start/stop feature is configured"""
+        return self._is_configured
+
+    @property
+    def auto_start_stop_level(self) -> TYPE_AUTO_START_STOP_LEVELS:
+        """Return the auto start/stop level."""
+        return self._auto_start_stop_level
+
+    @property
+    def auto_start_stop_enable(self) -> bool:
+        """Returns the auto_start_stop_enable"""
+        return self._is_auto_start_stop_enabled
+
+    @property
+    def is_auto_stopped(self) -> bool:
+        """Returns the is vtherm is stopped and reason is AUTO_START_STOP"""
+        return (
+            self._vtherm.hvac_mode == HVACMode.OFF
+            and self._vtherm.hvac_off_reason == HVAC_OFF_REASON_AUTO_START_STOP
+        )
+
+    def __str__(self):
+        return f"AutoStartStopManager-{self.name}"

custom_components/versatile_thermostat/feature_motion_manager.py

@@ -0,0 +1,343 @@
+""" Implements the Motion Feature Manager """
+
+# pylint: disable=line-too-long
+
+import logging
+from typing import Any
+from datetime import timedelta
+
+from homeassistant.const import (
+    STATE_ON,
+    STATE_OFF,
+    STATE_UNAVAILABLE,
+    STATE_UNKNOWN,
+)
+from homeassistant.core import (
+    HomeAssistant,
+    callback,
+    Event,
+)
+from homeassistant.helpers.event import (
+    async_track_state_change_event,
+    EventStateChangedData,
+    async_call_later,
+)
+
+from homeassistant.components.climate import (
+    PRESET_ACTIVITY,
+)
+
+from homeassistant.exceptions import ConditionError
+from homeassistant.helpers import condition
+
+from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from .commons import ConfigData
+
+from .base_manager import BaseFeatureManager
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class FeatureMotionManager(BaseFeatureManager):
+    """The implementation of the Motion feature"""
+
+    unrecorded_attributes = frozenset(
+        {
+            "motion_sensor_entity_id",
+            "is_motion_configured",
+            "motion_delay_sec",
+            "motion_off_delay_sec",
+            "motion_preset",
+            "no_motion_preset",
+        }
+    )
+
+    def __init__(self, vtherm: Any, hass: HomeAssistant):
+        """Init of a featureManager"""
+        super().__init__(vtherm, hass)
+        self._motion_state: str = STATE_UNAVAILABLE
+        self._motion_sensor_entity_id: str = None
+        self._motion_delay_sec: int | None = 0
+        self._motion_off_delay_sec: int | None = 0
+        self._motion_preset: str | None = None
+        self._no_motion_preset: str | None = None
+        self._is_configured: bool = False
+        self._motion_call_cancel: callable = None
+
+    @overrides
+    def post_init(self, entry_infos: ConfigData):
+        """Reinit of the manager"""
+        self.dearm_motion_timer()
+
+        self._motion_sensor_entity_id = entry_infos.get(CONF_MOTION_SENSOR, None)
+        self._motion_delay_sec = entry_infos.get(CONF_MOTION_DELAY, 0)
+        self._motion_off_delay_sec = entry_infos.get(CONF_MOTION_OFF_DELAY, None)
+        if not self._motion_off_delay_sec:
+            self._motion_off_delay_sec = self._motion_delay_sec
+
+        self._motion_preset = entry_infos.get(CONF_MOTION_PRESET)
+        self._no_motion_preset = entry_infos.get(CONF_NO_MOTION_PRESET)
+        if (
+            self._motion_sensor_entity_id is not None
+            and self._motion_preset is not None
+            and self._no_motion_preset is not None
+        ):
+            self._is_configured = True
+            self._motion_state = STATE_UNKNOWN
+
+    @overrides
+    async def start_listening(self):
+        """Start listening the underlying entity"""
+        if self._is_configured:
+            self.stop_listening()
+            self.add_listener(
+                async_track_state_change_event(
+                    self.hass,
+                    [self._motion_sensor_entity_id],
+                    self._motion_sensor_changed,
+                )
+            )
+
+    @overrides
+    def stop_listening(self):
+        """Stop listening and remove the eventual timer still running"""
+        self.dearm_motion_timer()
+        super().stop_listening()
+
+    def dearm_motion_timer(self):
+        """Dearm the eventual motion time running"""
+        if self._motion_call_cancel:
+            self._motion_call_cancel()
+            self._motion_call_cancel = None
+
+    @overrides
+    async def refresh_state(self) -> bool:
+        """Tries to get the last state from sensor
+        Returns True if a change has been made"""
+        ret = False
+        if self._is_configured:
+
+            motion_state = self.hass.states.get(self._motion_sensor_entity_id)
+            if motion_state and motion_state.state not in (
+                STATE_UNAVAILABLE,
+                STATE_UNKNOWN,
+            ):
+                _LOGGER.debug(
+                    "%s - Motion state have been retrieved: %s",
+                    self,
+                    self._motion_state,
+                )
+                # recalculate the right target_temp in activity mode
+                ret = await self.update_motion_state(motion_state.state, False)
+
+        return ret
+
+    @callback
+    async def _motion_sensor_changed(self, event: Event[EventStateChangedData]):
+        """Handle motion sensor changes."""
+        new_state = event.data.get("new_state")
+        _LOGGER.info(
+            "%s - Motion changed. Event.new_state is %s, _attr_preset_mode=%s, activity=%s",
+            self,
+            new_state,
+            self._vtherm.preset_mode,
+            PRESET_ACTIVITY,
+        )
+
+        if new_state is None or new_state.state not in (STATE_OFF, STATE_ON):
+            return
+
+        # Check delay condition
+        async def try_motion_condition(_):
+            self.dearm_motion_timer()
+
+            try:
+                delay = (
+                    self._motion_delay_sec
+                    if new_state.state == STATE_ON
+                    else self._motion_off_delay_sec
+                )
+                long_enough = condition.state(
+                    self.hass,
+                    self._motion_sensor_entity_id,
+                    new_state.state,
+                    timedelta(seconds=delay),
+                )
+            except ConditionError:
+                long_enough = False
+
+            if not long_enough:
+                _LOGGER.debug(
+                    "Motion delay condition is not satisfied (the sensor have change its state during the delay). Check motion sensor state"
+                )
+                # Get sensor current state
+                motion_state = self.hass.states.get(self._motion_sensor_entity_id)
+                _LOGGER.debug(
+                    "%s - motion_state=%s, new_state.state=%s",
+                    self,
+                    motion_state.state,
+                    new_state.state,
+                )
+                if (
+                    motion_state.state == new_state.state
+                    and new_state.state == STATE_ON
+                ):
+                    _LOGGER.debug(
+                        "%s - the motion sensor is finally 'on' after the delay", self
+                    )
+                    long_enough = True
+                else:
+                    long_enough = False
+
+            if long_enough:
+                _LOGGER.debug("%s - Motion delay condition is satisfied", self)
+                await self.update_motion_state(new_state.state)
+            else:
+                await self.update_motion_state(
+                    STATE_ON if new_state.state == STATE_OFF else STATE_OFF
+                )
+
+        im_on = self._motion_state == STATE_ON
+        delay_running = self._motion_call_cancel is not None
+        event_on = new_state.state == STATE_ON
+
+        def arm():
+            """Arm the timer"""
+            delay = (
+                self._motion_delay_sec
+                if new_state.state == STATE_ON
+                else self._motion_off_delay_sec
+            )
+            self._motion_call_cancel = async_call_later(
+                self.hass, timedelta(seconds=delay), try_motion_condition
+            )
+
+        # if I'm off
+        if not im_on:
+            if event_on and not delay_running:
+                _LOGGER.debug(
+                    "%s - Arm delay cause i'm off and event is on and no delay is running",
+                    self,
+                )
+                arm()
+                return try_motion_condition
+            # Ignore the event
+            _LOGGER.debug("%s - Event ignored cause i'm already off", self)
+            return None
+        else:  # I'm On
+            if not event_on and not delay_running:
+                _LOGGER.info("%s - Arm delay cause i'm on and event is off", self)
+                arm()
+                return try_motion_condition
+            if event_on and delay_running:
+                _LOGGER.debug(
+                    "%s - Desarm off delay cause i'm on and event is on and a delay is running",
+                    self,
+                )
+                self.dearm_motion_timer()
+                return None
+            # Ignore the event
+            _LOGGER.debug("%s - Event ignored cause i'm already on", self)
+            return None
+
+    async def update_motion_state(
+        self, new_state: str = None, recalculate: bool = True
+    ) -> bool:
+        """Update the value of the motion sensor and update the VTherm state accordingly
+        Return true if a change has been made"""
+
+        _LOGGER.info("%s - Updating motion state. New state is %s", self, new_state)
+        old_motion_state = self._motion_state
+        if new_state is not None:
+            self._motion_state = STATE_ON if new_state == STATE_ON else STATE_OFF
+
+        if self._vtherm.preset_mode == PRESET_ACTIVITY:
+            new_preset = self.get_current_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 motion into account
+            new_temp = self._vtherm.find_preset_temp(new_preset)
+            old_temp = self._vtherm.target_temperature
+            if new_temp != old_temp:
+                await self._vtherm.change_target_temperature(new_temp)
+
+            if new_temp != old_temp and recalculate:
+                self._vtherm.recalculate()
+                await self._vtherm.async_control_heating(force=True)
+
+        return old_motion_state != self._motion_state
+
+    def get_current_motion_preset(self) -> str:
+        """Calculate and return the current motion preset"""
+        return (
+            self._motion_preset
+            if self._motion_state == STATE_ON
+            else self._no_motion_preset
+        )
+
+    def add_custom_attributes(self, extra_state_attributes: dict[str, Any]):
+        """Add some custom attributes"""
+        extra_state_attributes.update(
+            {
+                "motion_sensor_entity_id": self._motion_sensor_entity_id,
+                "motion_state": self._motion_state,
+                "is_motion_configured": self._is_configured,
+                "motion_delay_sec": self._motion_delay_sec,
+                "motion_off_delay_sec": self._motion_off_delay_sec,
+                "motion_preset": self._motion_preset,
+                "no_motion_preset": self._no_motion_preset,
+            }
+        )
+
+    @overrides
+    @property
+    def is_configured(self) -> bool:
+        """Return True of the motion is configured"""
+        return self._is_configured
+
+    @property
+    def motion_state(self) -> str | None:
+        """Return the current motion state STATE_ON or STATE_OFF
+        or STATE_UNAVAILABLE if not configured"""
+        if not self._is_configured:
+            return STATE_UNAVAILABLE
+        return self._motion_state
+
+    @property
+    def is_motion_detected(self) -> bool:
+        """Return true if the motion is configured and motion sensor is OFF"""
+        return self._is_configured and self._motion_state in [
+            STATE_ON,
+        ]
+
+    @property
+    def motion_sensor_entity_id(self) -> bool:
+        """Return true if the motion is configured and motion sensor is OFF"""
+        return self._motion_sensor_entity_id
+
+    @property
+    def motion_delay_sec(self) -> bool:
+        """Return the motion delay"""
+        return self._motion_delay_sec
+
+    @property
+    def motion_off_delay_sec(self) -> bool:
+        """Return motion delay off"""
+        return self._motion_off_delay_sec
+
+    @property
+    def motion_preset(self) -> bool:
+        """Return motion preset"""
+        return self._motion_preset
+
+    @property
+    def no_motion_preset(self) -> bool:
+        """Return no motion preset"""
+        return self._no_motion_preset
+
+    def __str__(self):
+        return f"MotionManager-{self.name}"

custom_components/versatile_thermostat/feature_power_manager.py

@@ -0,0 +1,268 @@
+""" Implements the Power Feature Manager """
+
+# pylint: disable=line-too-long
+
+import logging
+from typing import Any
+
+from homeassistant.const import (
+    STATE_ON,
+    STATE_OFF,
+    STATE_UNAVAILABLE,
+    STATE_UNKNOWN,
+)
+
+from homeassistant.core import (
+    HomeAssistant,
+)
+
+from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from .commons import ConfigData
+
+from .base_manager import BaseFeatureManager
+from .vtherm_api import VersatileThermostatAPI
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class FeaturePowerManager(BaseFeatureManager):
+    """The implementation of the Power feature"""
+
+    unrecorded_attributes = frozenset(
+        {
+            "power_sensor_entity_id",
+            "max_power_sensor_entity_id",
+            "is_power_configured",
+            "device_power",
+            "power_temp",
+            "current_power",
+            "current_max_power",
+        }
+    )
+
+    def __init__(self, vtherm: Any, hass: HomeAssistant):
+        """Init of a featureManager"""
+        super().__init__(vtherm, hass)
+        self._power_temp = None
+        self._overpowering_state = STATE_UNAVAILABLE
+        self._is_configured: bool = False
+        self._device_power: float = 0
+        self._use_power_feature: bool = False
+
+    @overrides
+    def post_init(self, entry_infos: ConfigData):
+        """Reinit of the manager"""
+
+        # Power management
+        self._power_temp = entry_infos.get(CONF_PRESET_POWER)
+
+        self._device_power = entry_infos.get(CONF_DEVICE_POWER) or 0
+        self._use_power_feature = entry_infos.get(CONF_USE_POWER_FEATURE, False)
+        self._is_configured = False
+
+    @overrides
+    async def start_listening(self):
+        """Start listening the underlying entity. There is nothing to listen"""
+        central_power_configuration = (
+            VersatileThermostatAPI.get_vtherm_api().central_power_manager.is_configured
+        )
+
+        if self._use_power_feature and self._device_power and central_power_configuration:
+            self._is_configured = True
+            # Try to restore _overpowering_state from previous state
+            old_state = await self._vtherm.async_get_last_state()
+            self._overpowering_state = STATE_ON if old_state and old_state.attributes and old_state.attributes.get("overpowering_state") == STATE_ON else STATE_UNKNOWN
+        else:
+            if self._use_power_feature:
+                if not central_power_configuration:
+                    _LOGGER.warning(
+                        "%s - Power management is not fully configured. You have to configure the central configuration power",
+                        self,
+                    )
+                else:
+                    _LOGGER.warning(
+                        "%s - Power management is not fully configured. You have to configure the power feature of the VTherm",
+                        self,
+                    )
+
+    def add_custom_attributes(self, extra_state_attributes: dict[str, Any]):
+        """Add some custom attributes"""
+        vtherm_api = VersatileThermostatAPI.get_vtherm_api()
+        extra_state_attributes.update(
+            {
+                "power_sensor_entity_id": vtherm_api.central_power_manager.power_sensor_entity_id,
+                "max_power_sensor_entity_id": vtherm_api.central_power_manager.max_power_sensor_entity_id,
+                "overpowering_state": self._overpowering_state,
+                "is_power_configured": self._is_configured,
+                "device_power": self._device_power,
+                "power_temp": self._power_temp,
+                "current_power": vtherm_api.central_power_manager.current_power,
+                "current_max_power": vtherm_api.central_power_manager.current_max_power,
+                "mean_cycle_power": self.mean_cycle_power,
+            }
+        )
+
+    async def check_power_available(self) -> bool:
+        """Check if the Vtherm can be started considering overpowering.
+        Returns True if no overpowering conditions are found.
+        If True the vtherm power is written into the temporay vtherm started
+        """
+
+        vtherm_api = VersatileThermostatAPI.get_vtherm_api()
+        if (
+            not self._is_configured
+            or not vtherm_api.central_power_manager.is_configured
+        ):
+            return True
+
+        current_power = vtherm_api.central_power_manager.current_power
+        current_max_power = vtherm_api.central_power_manager.current_max_power
+        started_vtherm_total_power = vtherm_api.central_power_manager.started_vtherm_total_power
+        if (
+            current_power is None
+            or current_max_power is None
+            or self._device_power is None
+        ):
+            _LOGGER.warning(
+                "%s - power not valued. check_power_available not available", self
+            )
+            return True
+
+        _LOGGER.debug(
+            "%s - overpowering check: power=%.3f, max_power=%.3f heater power=%.3f",
+            self,
+            current_power,
+            current_max_power,
+            self._device_power,
+        )
+
+        # issue 407 - power_consumption_max is power we need to add. If already active we don't need to add more power
+        if self._vtherm.is_device_active:
+            power_consumption_max = 0
+        else:
+            if self._vtherm.is_over_climate:
+                power_consumption_max = self._device_power
+            else:
+                power_consumption_max = max(
+                    self._device_power / self._vtherm.nb_underlying_entities,
+                    self._device_power * self._vtherm.proportional_algorithm.on_percent,
+                )
+
+        ret = (current_power + started_vtherm_total_power + power_consumption_max) < current_max_power
+        if not ret:
+            _LOGGER.info(
+                "%s - there is not enough power available power=%.3f, max_power=%.3f heater power=%.3f",
+                self,
+                current_power,
+                current_max_power,
+                self._device_power,
+            )
+        else:
+            # Adds the current_power_max to the started vtherm total power
+            vtherm_api.central_power_manager.add_started_vtherm_total_power(power_consumption_max)
+
+        return ret
+
+    async def set_overpowering(self, overpowering: bool, power_consumption_max=0):
+        """Force the overpowering state for the VTherm"""
+
+        vtherm_api = VersatileThermostatAPI.get_vtherm_api()
+        current_power = vtherm_api.central_power_manager.current_power
+        current_max_power = vtherm_api.central_power_manager.current_max_power
+
+        if overpowering and not self.is_overpowering_detected:
+            _LOGGER.warning(
+                "%s - overpowering is detected. Heater preset will be set to 'power'",
+                self,
+            )
+
+            self._overpowering_state = STATE_ON
+
+            if self._vtherm.is_over_climate:
+                self._vtherm.save_hvac_mode()
+
+            self._vtherm.save_preset_mode()
+            await self._vtherm.async_underlying_entity_turn_off()
+            await self._vtherm.async_set_preset_mode_internal(PRESET_POWER, force=True)
+            self._vtherm.send_event(
+                EventType.POWER_EVENT,
+                {
+                    "type": "start",
+                    "current_power": current_power,
+                    "device_power": self._device_power,
+                    "current_max_power": current_max_power,
+                    "current_power_consumption": power_consumption_max,
+                },
+            )
+        elif not overpowering and self.is_overpowering_detected:
+            _LOGGER.warning(
+                "%s - end of overpowering is detected. Heater preset will be restored to '%s'",
+                self,
+                self._vtherm._saved_preset_mode,  # pylint: disable=protected-access
+            )
+            self._overpowering_state = STATE_OFF
+
+            # restore state
+            if self._vtherm.is_over_climate:
+                await self._vtherm.restore_hvac_mode()
+            await self._vtherm.restore_preset_mode()
+            # restart cycle
+            await self._vtherm.async_control_heating(force=True)
+            self._vtherm.send_event(
+                EventType.POWER_EVENT,
+                {
+                    "type": "end",
+                    "current_power": current_power,
+                    "device_power": self._device_power,
+                    "current_max_power": current_max_power,
+                },
+            )
+        elif not overpowering and self._overpowering_state != STATE_OFF:
+            # just set to not overpowering the state which was not set
+            self._overpowering_state = STATE_OFF
+        else:
+            # Nothing to do (already in the right state)
+            return
+        self._vtherm.update_custom_attributes()
+
+    @overrides
+    @property
+    def is_configured(self) -> bool:
+        """Return True of the presence is configured"""
+        return self._is_configured
+
+    @property
+    def overpowering_state(self) -> str | None:
+        """Return the current overpowering state STATE_ON or STATE_OFF
+        or STATE_UNAVAILABLE if not configured"""
+        if not self._is_configured:
+            return STATE_UNAVAILABLE
+        return self._overpowering_state
+
+    @property
+    def is_overpowering_detected(self) -> str | None:
+        """Return True if the Vtherm is in overpowering state"""
+        return self._overpowering_state == STATE_ON
+
+    @property
+    def power_temperature(self) -> bool:
+        """Return the power temperature"""
+        return self._power_temp
+
+    @property
+    def device_power(self) -> bool:
+        """Return the device power"""
+        return self._device_power
+
+    @property
+    def mean_cycle_power(self) -> float | None:
+        """Returns the mean power consumption during the cycle"""
+        if not self._device_power or not self._vtherm.proportional_algorithm:
+            return None
+
+        return float(
+            self._device_power * self._vtherm.proportional_algorithm.on_percent
+        )
+
+    def __str__(self):
+        return f"PowerManager-{self.name}"

custom_components/versatile_thermostat/feature_presence_manager.py

@@ -0,0 +1,200 @@
+""" Implements the Presence Feature Manager """
+
+# pylint: disable=line-too-long
+
+import logging
+from typing import Any
+
+from homeassistant.const import (
+    STATE_ON,
+    STATE_OFF,
+    STATE_HOME,
+    STATE_NOT_HOME,
+    STATE_UNAVAILABLE,
+    STATE_UNKNOWN,
+)
+from homeassistant.core import (
+    HomeAssistant,
+    callback,
+    Event,
+)
+from homeassistant.helpers.event import (
+    async_track_state_change_event,
+    EventStateChangedData,
+)
+
+from homeassistant.components.climate import PRESET_ACTIVITY, PRESET_BOOST, PRESET_COMFORT, PRESET_ECO
+
+from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from .commons import ConfigData
+
+from .base_manager import BaseFeatureManager
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class FeaturePresenceManager(BaseFeatureManager):
+    """The implementation of the Presence feature"""
+
+    unrecorded_attributes = frozenset(
+        {
+            "presence_sensor_entity_id",
+            "is_presence_configured",
+        }
+    )
+
+    def __init__(self, vtherm: Any, hass: HomeAssistant):
+        """Init of a featureManager"""
+        super().__init__(vtherm, hass)
+        self._presence_state: str = STATE_UNAVAILABLE
+        self._presence_sensor_entity_id: str = None
+        self._is_configured: bool = False
+
+    @overrides
+    def post_init(self, entry_infos: ConfigData):
+        """Reinit of the manager"""
+        self._presence_sensor_entity_id = entry_infos.get(CONF_PRESENCE_SENSOR)
+        if (
+            entry_infos.get(CONF_USE_PRESENCE_FEATURE, False)
+            and self._presence_sensor_entity_id is not None
+        ):
+            self._is_configured = True
+            self._presence_state = STATE_UNKNOWN
+
+    @overrides
+    async def start_listening(self):
+        """Start listening the underlying entity"""
+        if self._is_configured:
+            self.stop_listening()
+            self.add_listener(
+                async_track_state_change_event(
+                    self.hass,
+                    [self._presence_sensor_entity_id],
+                    self._presence_sensor_changed,
+                )
+            )
+
+    @overrides
+    async def refresh_state(self) -> bool:
+        """Tries to get the last state from sensor
+        Returns True if a change has been made"""
+        ret = False
+        if self._is_configured:
+            # 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,
+            ):
+                ret = await self.update_presence(presence_state.state)
+                _LOGGER.debug(
+                    "%s - Presence have been retrieved: %s",
+                    self,
+                    presence_state.state,
+                )
+        return ret
+
+    @callback
+    async def _presence_sensor_changed(self, event: Event[EventStateChangedData]):
+        """Handle presence changes."""
+        new_state = event.data.get("new_state")
+        _LOGGER.info(
+            "%s - Presence changed. Event.new_state is %s, _attr_preset_mode=%s, activity=%s",
+            self,
+            new_state,
+            self._vtherm.preset_mode,
+            PRESET_ACTIVITY,
+        )
+        if new_state is None:
+            return
+
+        if await self.update_presence(new_state.state):
+            await self._vtherm.async_control_heating(force=True)
+
+    async def update_presence(self, new_state: str) -> bool:
+        """Update the value of the presence sensor and update the VTherm state accordingly
+        Return true if a change has been made"""
+
+        _LOGGER.info("%s - Updating presence. New state is %s", self, new_state)
+        old_presence_state = self._presence_state
+        self._presence_state = (
+            STATE_ON if new_state in (STATE_ON, STATE_HOME) else STATE_OFF
+        )
+        if self._vtherm.preset_mode in HIDDEN_PRESETS or self._is_configured is False:
+            _LOGGER.info(
+                "%s - Ignoring presence change cause in Power or Security preset or presence not configured",
+                self,
+            )
+            return old_presence_state != self._presence_state
+
+        if new_state is None or new_state not in (
+            STATE_OFF,
+            STATE_ON,
+            STATE_HOME,
+            STATE_NOT_HOME,
+        ):
+            self._presence_state = STATE_UNKNOWN
+            return old_presence_state != self._presence_state
+
+        if self._vtherm.preset_mode not in [
+            PRESET_BOOST,
+            PRESET_COMFORT,
+            PRESET_ECO,
+            PRESET_ACTIVITY,
+            PRESET_FROST_PROTECTION,
+        ]:
+            return old_presence_state != self._presence_state
+
+        new_temp = self._vtherm.find_preset_temp(self._vtherm.preset_mode)
+        if new_temp is not None:
+            _LOGGER.debug(
+                "%s - presence change in temperature mode new_temp will be: %.2f",
+                self,
+                new_temp,
+            )
+            await self._vtherm.change_target_temperature(new_temp)
+            self._vtherm.recalculate()
+
+            return True
+
+        return old_presence_state != self._presence_state
+
+    def add_custom_attributes(self, extra_state_attributes: dict[str, Any]):
+        """Add some custom attributes"""
+        extra_state_attributes.update(
+            {
+                "presence_sensor_entity_id": self._presence_sensor_entity_id,
+                "presence_state": self._presence_state,
+                "is_presence_configured": self._is_configured,
+            }
+        )
+
+    @overrides
+    @property
+    def is_configured(self) -> bool:
+        """Return True of the presence is configured"""
+        return self._is_configured
+
+    @property
+    def presence_state(self) -> str | None:
+        """Return the current presence state STATE_ON or STATE_OFF
+        or STATE_UNAVAILABLE if not configured"""
+        if not self._is_configured:
+            return STATE_UNAVAILABLE
+        return self._presence_state
+
+    @property
+    def is_absence_detected(self) -> bool:
+        """Return true if the presence is configured and presence sensor is OFF"""
+        return self._is_configured and self._presence_state in [
+            STATE_NOT_HOME,
+            STATE_OFF,
+        ]
+
+    @property
+    def presence_sensor_entity_id(self) -> bool:
+        """Return true if the presence is configured and presence sensor is OFF"""
+        return self._presence_sensor_entity_id
+
+    def __str__(self):
+        return f"PresenceManager-{self.name}"

custom_components/versatile_thermostat/feature_safety_manager.py

@@ -0,0 +1,322 @@
+# pylint: disable=line-too-long
+
+""" Implements the Safety as a Feature Manager"""
+
+import logging
+from typing import Any
+
+from homeassistant.const import (
+    STATE_ON,
+    STATE_OFF,
+    STATE_UNAVAILABLE,
+    STATE_UNKNOWN,
+)
+
+from homeassistant.core import HomeAssistant
+from homeassistant.components.climate import HVACMode, HVACAction
+
+from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from .commons import ConfigData
+
+from .base_manager import BaseFeatureManager
+from .vtherm_api import VersatileThermostatAPI
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class FeatureSafetyManager(BaseFeatureManager):
+    """The implementation of the Safety feature"""
+
+    unrecorded_attributes = frozenset(
+        {
+            "safety_delay_min",
+            "safety_min_on_percent",
+            "safety_default_on_percent",
+            "is_safety_configured",
+        }
+    )
+
+    def __init__(self, vtherm: Any, hass: HomeAssistant):
+        """Init of a featureManager"""
+        super().__init__(vtherm, hass)
+
+        self._is_configured: bool = False
+        self._safety_delay_min = None
+        self._safety_min_on_percent = None
+        self._safety_default_on_percent = None
+        self._safety_state = STATE_UNAVAILABLE
+
+    @overrides
+    def post_init(self, entry_infos: ConfigData):
+        """Reinit of the manager"""
+        self._safety_delay_min = entry_infos.get(CONF_SAFETY_DELAY_MIN)
+        self._safety_min_on_percent = (
+            entry_infos.get(CONF_SAFETY_MIN_ON_PERCENT)
+            if entry_infos.get(CONF_SAFETY_MIN_ON_PERCENT) is not None
+            else DEFAULT_SAFETY_MIN_ON_PERCENT
+        )
+        self._safety_default_on_percent = (
+            entry_infos.get(CONF_SAFETY_DEFAULT_ON_PERCENT)
+            if entry_infos.get(CONF_SAFETY_DEFAULT_ON_PERCENT) is not None
+            else DEFAULT_SAFETY_DEFAULT_ON_PERCENT
+        )
+
+        if (
+            self._safety_delay_min is not None
+            and self._safety_default_on_percent is not None
+            and self._safety_default_on_percent is not None
+        ):
+            self._safety_state = STATE_UNKNOWN
+            self._is_configured = True
+
+    @overrides
+    async def start_listening(self):
+        """Start listening the underlying entity"""
+
+    @overrides
+    def stop_listening(self):
+        """Stop listening and remove the eventual timer still running"""
+
+    @overrides
+    async def refresh_state(self) -> bool:
+        """Check the safety and an eventual action
+        Return True is safety should be active"""
+
+        if not self._is_configured:
+            _LOGGER.debug("%s - safety is disabled (or not configured)", self)
+            return False
+
+        now = self._vtherm.now
+        current_tz = dt_util.get_time_zone(self._hass.config.time_zone)
+
+        is_safety_detected = self.is_safety_detected
+
+        delta_temp = (
+            now - self._vtherm.last_temperature_measure.replace(tzinfo=current_tz)
+        ).total_seconds() / 60.0
+        delta_ext_temp = (
+            now - self._vtherm.last_ext_temperature_measure.replace(tzinfo=current_tz)
+        ).total_seconds() / 60.0
+
+        mode_cond = self._vtherm.hvac_mode != HVACMode.OFF
+
+        api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api()
+        is_outdoor_checked = (
+            not api.safety_mode
+            or api.safety_mode.get("check_outdoor_sensor") is not False
+        )
+
+        temp_cond: bool = delta_temp > self._safety_delay_min or (
+            is_outdoor_checked and delta_ext_temp > self._safety_delay_min
+        )
+        climate_cond: bool = (
+            self._vtherm.is_over_climate
+            and self._vtherm.hvac_action
+            not in [
+                HVACAction.COOLING,
+                HVACAction.IDLE,
+            ]
+        )
+        switch_cond: bool = (
+            not self._vtherm.is_over_climate
+            and self._vtherm.proportional_algorithm is not None
+            and self._vtherm.proportional_algorithm.calculated_on_percent
+            >= self._safety_min_on_percent
+        )
+
+        _LOGGER.debug(
+            "%s - checking safety delta_temp=%.1f delta_ext_temp=%.1f mod_cond=%s temp_cond=%s climate_cond=%s switch_cond=%s",
+            self,
+            delta_temp,
+            delta_ext_temp,
+            mode_cond,
+            temp_cond,
+            climate_cond,
+            switch_cond,
+        )
+
+        # Issue 99 - a climate is regulated by the device itself and not by VTherm. So a VTherm should never be in safety !
+        should_climate_be_in_security = False  # temp_cond and climate_cond
+        should_switch_be_in_security = temp_cond and switch_cond
+        should_be_in_security = (
+            should_climate_be_in_security or should_switch_be_in_security
+        )
+
+        should_start_security = (
+            mode_cond and not is_safety_detected and should_be_in_security
+        )
+        # attr_preset_mode is not necessary normaly. It is just here to be sure
+        should_stop_security = (
+            is_safety_detected
+            and not should_be_in_security
+            and self._vtherm.preset_mode == PRESET_SAFETY
+        )
+
+        # Logging and event
+        if should_start_security:
+            if should_climate_be_in_security:
+                _LOGGER.warning(
+                    "%s - No temperature received for more than %.1f minutes (dt=%.1f, dext=%.1f) and underlying climate is %s. Setting it into safety mode",
+                    self,
+                    self._safety_delay_min,
+                    delta_temp,
+                    delta_ext_temp,
+                    self.hvac_action,
+                )
+            elif should_switch_be_in_security:
+                _LOGGER.warning(
+                    "%s - No temperature received for more than %.1f minutes (dt=%.1f, dext=%.1f) and on_percent (%.2f %%) is over defined value (%.2f %%). Set it into safety mode",
+                    self,
+                    self._safety_delay_min,
+                    delta_temp,
+                    delta_ext_temp,
+                    self._vtherm.proportional_algorithm.on_percent * 100,
+                    self._safety_min_on_percent * 100,
+                )
+
+            self._vtherm.send_event(
+                EventType.TEMPERATURE_EVENT,
+                {
+                    "last_temperature_measure": self._vtherm.last_temperature_measure.replace(
+                        tzinfo=current_tz
+                    ).isoformat(),
+                    "last_ext_temperature_measure": self._vtherm.last_ext_temperature_measure.replace(
+                        tzinfo=current_tz
+                    ).isoformat(),
+                    "current_temp": self._vtherm.current_temperature,
+                    "current_ext_temp": self._vtherm.current_outdoor_temperature,
+                    "target_temp": self._vtherm.target_temperature,
+                },
+            )
+
+        # Start safety mode
+        if should_start_security:
+            self._safety_state = STATE_ON
+            self._vtherm.save_hvac_mode()
+            self._vtherm.save_preset_mode()
+            if self._vtherm.proportional_algorithm:
+                self._vtherm.proportional_algorithm.set_safety(
+                    self._safety_default_on_percent
+                )
+            await self._vtherm.async_set_preset_mode_internal(PRESET_SAFETY)
+            # Turn off the underlying climate or heater if safety default on_percent is 0
+            if self._vtherm.is_over_climate or self._safety_default_on_percent <= 0.0:
+                await self._vtherm.async_set_hvac_mode(HVACMode.OFF, False)
+
+            self._vtherm.send_event(
+                EventType.SECURITY_EVENT,
+                {
+                    "type": "start",
+                    "last_temperature_measure": self._vtherm.last_temperature_measure.replace(
+                        tzinfo=current_tz
+                    ).isoformat(),
+                    "last_ext_temperature_measure": self._vtherm.last_ext_temperature_measure.replace(
+                        tzinfo=current_tz
+                    ).isoformat(),
+                    "current_temp": self._vtherm.current_temperature,
+                    "current_ext_temp": self._vtherm.current_outdoor_temperature,
+                    "target_temp": self._vtherm.target_temperature,
+                },
+            )
+
+        # Stop safety mode
+        elif should_stop_security:
+            _LOGGER.warning(
+                "%s - End of safety mode. restoring hvac_mode to %s and preset_mode to %s",
+                self,
+                self._vtherm.saved_hvac_mode,
+                self._vtherm.saved_preset_mode,
+            )
+            self._safety_state = STATE_OFF
+            if self._vtherm.proportional_algorithm:
+                self._vtherm.proportional_algorithm.unset_safety()
+            # Restore hvac_mode if previously saved
+            if self._vtherm.is_over_climate or self._safety_default_on_percent <= 0.0:
+                await self._vtherm.restore_hvac_mode(False)
+            await self._vtherm.restore_preset_mode()
+            self._vtherm.send_event(
+                EventType.SECURITY_EVENT,
+                {
+                    "type": "end",
+                    "last_temperature_measure": self._vtherm.last_temperature_measure.replace(
+                        tzinfo=current_tz
+                    ).isoformat(),
+                    "last_ext_temperature_measure": self._vtherm.last_ext_temperature_measure.replace(
+                        tzinfo=current_tz
+                    ).isoformat(),
+                    "current_temp": self._vtherm.current_temperature,
+                    "current_ext_temp": self._vtherm.current_outdoor_temperature,
+                    "target_temp": self._vtherm.target_temperature,
+                },
+            )
+
+        # Initialize the safety_state if not already done
+        elif not should_be_in_security and self._safety_state in [STATE_UNKNOWN]:
+            self._safety_state = STATE_OFF
+
+        return should_be_in_security
+
+    def add_custom_attributes(self, extra_state_attributes: dict[str, Any]):
+        """Add some custom attributes"""
+
+        extra_state_attributes.update(
+            {
+                "is_safety_configured": self._is_configured,
+                "safety_state": self._safety_state,
+            }
+        )
+
+        if self._is_configured:
+            extra_state_attributes.update(
+                {
+                    "safety_delay_min": self._safety_delay_min,
+                    "safety_min_on_percent": self._safety_min_on_percent,
+                    "safety_default_on_percent": self._safety_default_on_percent,
+                }
+            )
+
+    @overrides
+    @property
+    def is_configured(self) -> bool:
+        """Return True of the safety feature is configured"""
+        return self._is_configured
+
+    def set_safety_delay_min(self, safety_delay_min):
+        """Set the delay min"""
+        self._safety_delay_min = safety_delay_min
+
+    def set_safety_min_on_percent(self, safety_min_on_percent):
+        """Set the min on percent"""
+        self._safety_min_on_percent = safety_min_on_percent
+
+    def set_safety_default_on_percent(self, safety_default_on_percent):
+        """Set the default on_percent"""
+        self._safety_default_on_percent = safety_default_on_percent
+
+    @property
+    def is_safety_detected(self) -> bool:
+        """Returns the is vtherm is in safety mode"""
+        return self._safety_state == STATE_ON
+
+    @property
+    def safety_state(self) -> str:
+        """Returns the safety state: STATE_ON, STATE_OFF, STATE_UNKWNON, STATE_UNAVAILABLE"""
+        return self._safety_state
+
+    @property
+    def safety_delay_min(self) -> bool:
+        """Returns the safety delay min"""
+        return self._safety_delay_min
+
+    @property
+    def safety_min_on_percent(self) -> bool:
+        """Returns the safety min on percent"""
+        return self._safety_min_on_percent
+
+    @property
+    def safety_default_on_percent(self) -> bool:
+        """Returns the safety safety_default_on_percent"""
+        return self._safety_default_on_percent
+
+    def __str__(self):
+        return f"SafetyManager-{self.name}"

custom_components/versatile_thermostat/feature_window_manager.py

@@ -0,0 +1,555 @@
+""" Implements the Window Feature Manager """
+
+# pylint: disable=line-too-long
+
+import logging
+from typing import Any
+from datetime import timedelta
+
+from homeassistant.const import (
+    STATE_ON,
+    STATE_OFF,
+    STATE_UNAVAILABLE,
+    STATE_UNKNOWN,
+)
+from homeassistant.core import (
+    HomeAssistant,
+    callback,
+    Event,
+)
+from homeassistant.helpers.event import (
+    async_track_state_change_event,
+    EventStateChangedData,
+    async_call_later,
+)
+
+from homeassistant.components.climate import HVACMode
+
+from homeassistant.exceptions import ConditionError
+from homeassistant.helpers import condition
+
+from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from .commons import ConfigData
+
+from .base_manager import BaseFeatureManager
+from .open_window_algorithm import WindowOpenDetectionAlgorithm
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class FeatureWindowManager(BaseFeatureManager):
+    """The implementation of the Window feature"""
+
+    unrecorded_attributes = frozenset(
+        {
+            "window_sensor_entity_id",
+            "is_window_configured",
+            "is_window_bypass",
+            "window_delay_sec",
+            "window_off_delay_sec",
+            "window_auto_configured",
+            "window_auto_open_threshold",
+            "window_auto_close_threshold",
+            "window_auto_max_duration",
+            "window_action",
+        }
+    )
+
+    def __init__(self, vtherm: Any, hass: HomeAssistant):
+        """Init of a featureManager"""
+        super().__init__(vtherm, hass)
+        self._window_sensor_entity_id: str = None
+        self._window_state: str = STATE_UNAVAILABLE
+        self._window_auto_open_threshold: float = 0
+        self._window_auto_close_threshold: float = 0
+        self._window_auto_max_duration: int = 0
+        self._window_auto_state: bool = False
+        self._window_auto_algo: WindowOpenDetectionAlgorithm = None
+        self._is_window_bypass: bool = False
+        self._window_action: str = None
+        self._window_delay_sec: int | None = 0
+        self._window_off_delay_sec: int | None = 0
+        self._is_configured: bool = False
+        self._is_window_auto_configured: bool = False
+        self._window_call_cancel: callable = None
+
+    @overrides
+    def post_init(self, entry_infos: ConfigData):
+        """Reinit of the manager"""
+        self.dearm_window_timer()
+
+        self._window_auto_state = STATE_UNAVAILABLE
+        self._window_state = STATE_UNAVAILABLE
+
+        self._window_sensor_entity_id = entry_infos.get(CONF_WINDOW_SENSOR)
+        self._window_delay_sec = entry_infos.get(CONF_WINDOW_DELAY)
+        # default is the WINDOW_ON delay if not configured
+        self._window_off_delay_sec = entry_infos.get(CONF_WINDOW_OFF_DELAY, self._window_delay_sec)
+
+        self._window_action = (
+            entry_infos.get(CONF_WINDOW_ACTION) or CONF_WINDOW_TURN_OFF
+        )
+
+        self._window_auto_open_threshold = entry_infos.get(
+            CONF_WINDOW_AUTO_OPEN_THRESHOLD
+        )
+        self._window_auto_close_threshold = entry_infos.get(
+            CONF_WINDOW_AUTO_CLOSE_THRESHOLD
+        )
+        self._window_auto_max_duration = entry_infos.get(CONF_WINDOW_AUTO_MAX_DURATION)
+
+        use_window_feature = entry_infos.get(CONF_USE_WINDOW_FEATURE, False)
+
+        if (  # pylint: disable=too-many-boolean-expressions
+            use_window_feature
+            and self._window_sensor_entity_id is None
+            and self._window_auto_open_threshold is not None
+            and self._window_auto_open_threshold > 0.0
+            and self._window_auto_close_threshold is not None
+            and self._window_auto_max_duration is not None
+            and self._window_auto_max_duration > 0
+            and self._window_action is not None
+        ):
+            self._is_window_auto_configured = True
+            self._window_auto_state = STATE_UNKNOWN
+
+        self._window_auto_algo = WindowOpenDetectionAlgorithm(
+            alert_threshold=self._window_auto_open_threshold,
+            end_alert_threshold=self._window_auto_close_threshold,
+        )
+
+        if self._is_window_auto_configured or (
+            use_window_feature
+            and self._window_sensor_entity_id is not None
+            and self._window_delay_sec is not None
+            and self._window_action is not None
+        ):
+            self._is_configured = True
+            self._window_state = STATE_UNKNOWN
+
+    @overrides
+    async def start_listening(self):
+        """Start listening the underlying entity"""
+        if self._is_configured:
+            self.stop_listening()
+            if self._window_sensor_entity_id:
+                self.add_listener(
+                    async_track_state_change_event(
+                        self.hass,
+                        [self._window_sensor_entity_id],
+                        self._window_sensor_changed,
+                    )
+                )
+
+    @overrides
+    def stop_listening(self):
+        """Stop listening and remove the eventual timer still running"""
+        self.dearm_window_timer()
+        super().stop_listening()
+
+    def dearm_window_timer(self):
+        """Dearm the eventual motion time running"""
+        if self._window_call_cancel:
+            self._window_call_cancel()
+            self._window_call_cancel = None
+
+    @overrides
+    async def refresh_state(self) -> bool:
+        """Tries to get the last state from sensor
+        Returns True if a change has been made"""
+        ret = False
+        if self._is_configured and self._window_sensor_entity_id is not None:
+
+            window_state = self.hass.states.get(self._window_sensor_entity_id)
+            if window_state and window_state.state not in (
+                STATE_UNAVAILABLE,
+                STATE_UNKNOWN,
+            ):
+                _LOGGER.debug(
+                    "%s - Window state have been retrieved: %s",
+                    self,
+                    self._window_state,
+                )
+                # recalculate the right target_temp in activity mode
+                ret = await self.update_window_state(window_state.state)
+
+        return ret
+
+    @callback
+    async def _window_sensor_changed(self, event: Event[EventStateChangedData]):
+        """Handle window sensor changes."""
+        new_state = event.data.get("new_state")
+        old_state = event.data.get("old_state")
+        _LOGGER.info(
+            "%s - Window changed. Event.new_state is %s, _hvac_mode=%s, _saved_hvac_mode=%s",
+            self,
+            new_state,
+            self._vtherm.hvac_mode,
+            self._vtherm.saved_hvac_mode,
+        )
+
+        # Check delay condition
+        async def try_window_condition(_):
+            try:
+                long_enough = condition.state(
+                    self._hass,
+                    self._window_sensor_entity_id,
+                    new_state.state,
+                    timedelta(seconds=delay),
+                )
+            except ConditionError:
+                long_enough = False
+
+            if not long_enough:
+                _LOGGER.debug(
+                    "Window delay condition is not satisfied. Ignore window event"
+                )
+                self._window_state = old_state.state or STATE_OFF
+                return
+
+            _LOGGER.debug("%s - Window delay condition is satisfied", self)
+
+            if self._window_state == new_state.state:
+                _LOGGER.debug("%s - no change in window state. Forget the event")
+                return
+
+            _LOGGER.debug("%s - Window ByPass is : %s", self, self._is_window_bypass)
+            if self._is_window_bypass:
+                _LOGGER.info(
+                    "%s - Window ByPass is activated. Ignore window event", self
+                )
+                # We change tne state but we don't apply the change
+                self._window_state = new_state.state
+            else:
+                await self.update_window_state(new_state.state)
+
+            self._vtherm.update_custom_attributes()
+
+        delay = self._window_delay_sec if new_state.state == STATE_ON else self._window_off_delay_sec
+        if new_state is None or old_state is None or new_state.state == old_state.state:
+            return try_window_condition
+
+        self.dearm_window_timer()
+        self._window_call_cancel = async_call_later(self.hass, timedelta(seconds=delay), try_window_condition)
+        # For testing purpose we need to access the inner function
+        return try_window_condition
+
+    async def update_window_state(self, new_state: str = None) -> bool:
+        """Change the window detection state.
+        new_state is on if an open window have been detected or off else
+        return True if the state have changed
+        """
+
+        if self._window_state == new_state:
+            return False
+
+        if new_state != STATE_ON:
+            _LOGGER.info(
+                "%s - Window is closed. Restoring hvac_mode '%s' if stopped by window detection or temperature %s",
+                self,
+                self._vtherm.saved_hvac_mode,
+                self._vtherm.saved_target_temp,
+            )
+
+            if self._window_action in [
+                CONF_WINDOW_FROST_TEMP,
+                CONF_WINDOW_ECO_TEMP,
+            ]:
+                await self._vtherm.restore_target_temp()
+
+            # default to TURN_OFF
+            elif self._window_action in [CONF_WINDOW_TURN_OFF]:
+                if (
+                    self._vtherm.last_central_mode != CENTRAL_MODE_STOPPED
+                    and self._vtherm.hvac_off_reason == HVAC_OFF_REASON_WINDOW_DETECTION
+                ):
+                    self._vtherm.set_hvac_off_reason(None)
+                    await self._vtherm.restore_hvac_mode(True)
+            elif self._window_action in [CONF_WINDOW_FAN_ONLY]:
+                if self._vtherm.last_central_mode != CENTRAL_MODE_STOPPED:
+                    self._vtherm.set_hvac_off_reason(None)
+                    await self._vtherm.restore_hvac_mode(True)
+            else:
+                _LOGGER.error(
+                    "%s - undefined window_action %s. Please open a bug in the github of this project with this log",
+                    self,
+                    self._window_action,
+                )
+                return False
+        else:
+            _LOGGER.info(
+                "%s - Window is open. Apply window action %s", self, self._window_action
+            )
+            if self._window_action == CONF_WINDOW_TURN_OFF and not self._vtherm.is_on:
+                _LOGGER.debug(
+                    "%s is already off. Forget turning off VTherm due to window detection"
+                )
+                self._window_state = new_state
+                return False
+
+            # self._window_state = new_state
+            if self._vtherm.last_central_mode in [CENTRAL_MODE_AUTO, None]:
+                if self._window_action in [
+                    CONF_WINDOW_TURN_OFF,
+                    CONF_WINDOW_FAN_ONLY,
+                ]:
+                    self._vtherm.save_hvac_mode()
+                elif self._window_action in [
+                    CONF_WINDOW_FROST_TEMP,
+                    CONF_WINDOW_ECO_TEMP,
+                ]:
+                    self._vtherm.save_target_temp()
+
+            if (
+                self._window_action == CONF_WINDOW_FAN_ONLY
+                and HVACMode.FAN_ONLY in self._vtherm.hvac_modes
+            ):
+                await self._vtherm.async_set_hvac_mode(HVACMode.FAN_ONLY)
+            elif (
+                self._window_action == CONF_WINDOW_FROST_TEMP
+                and self._vtherm.is_preset_configured(PRESET_FROST_PROTECTION)
+            ):
+                await self._vtherm.change_target_temperature(
+                    self._vtherm.find_preset_temp(PRESET_FROST_PROTECTION)
+                )
+            elif (
+                self._window_action == CONF_WINDOW_ECO_TEMP
+                and self._vtherm.is_preset_configured(PRESET_ECO)
+            ):
+                await self._vtherm.change_target_temperature(
+                    self._vtherm.find_preset_temp(PRESET_ECO)
+                )
+            else:  # default is to turn_off
+                self._vtherm.set_hvac_off_reason(HVAC_OFF_REASON_WINDOW_DETECTION)
+                await self._vtherm.async_set_hvac_mode(HVACMode.OFF)
+
+        self._window_state = new_state
+        return True
+
+    async def manage_window_auto(self, in_cycle=False) -> callable:
+        """The management of the window auto feature
+        Returns the dearm function used to deactivate the window auto"""
+
+        async def dearm_window_auto(_):
+            """Callback that will be called after end of WINDOW_AUTO_MAX_DURATION"""
+            _LOGGER.info("Unset window auto because MAX_DURATION is exceeded")
+            await deactivate_window_auto(auto=True)
+
+        async def deactivate_window_auto(auto=False):
+            """Deactivation of the Window auto state"""
+            _LOGGER.warning(
+                "%s - End auto detection of open window slope=%.3f", self, slope
+            )
+            # Send an event
+            cause = "max duration expiration" if auto else "end of slope alert"
+            self._vtherm.send_event(
+                EventType.WINDOW_AUTO_EVENT,
+                {"type": "end", "cause": cause, "curve_slope": slope},
+            )
+            # Set attributes
+            self._window_auto_state = STATE_OFF
+            await self.update_window_state(self._window_auto_state)
+            # await self.restore_hvac_mode(True)
+
+            self.dearm_window_timer()
+
+        if not self._window_auto_algo:
+            return None
+
+        if in_cycle:
+            slope = self._window_auto_algo.check_age_last_measurement(
+                temperature=self._vtherm.ema_temperature,
+                datetime_now=self._vtherm.now,
+            )
+        else:
+            slope = self._window_auto_algo.add_temp_measurement(
+                temperature=self._vtherm.ema_temperature,
+                datetime_measure=self._vtherm.last_temperature_measure,
+            )
+
+        _LOGGER.debug(
+            "%s - Window auto is on, check the alert. last slope is %.3f",
+            self,
+            slope if slope is not None else 0.0,
+        )
+
+        if self.is_window_bypass or not self._is_window_auto_configured:
+            _LOGGER.debug(
+                "%s - Window auto event is ignored because bypass is ON or window auto detection is disabled",
+                self,
+            )
+            return None
+
+        if (
+            self._window_auto_algo.is_window_open_detected()
+            and self._window_auto_state in [STATE_UNKNOWN, STATE_OFF]
+            and self._vtherm.hvac_mode != HVACMode.OFF
+        ):
+            if (
+                self._vtherm.proportional_algorithm
+                and self._vtherm.proportional_algorithm.on_percent <= 0.0
+            ):
+                _LOGGER.info(
+                    "%s - Start auto detection of open window slope=%.3f but no heating detected (on_percent<=0). Forget the event",
+                    self,
+                    slope,
+                )
+                return dearm_window_auto
+
+            _LOGGER.warning(
+                "%s - Start auto detection of open window slope=%.3f", self, slope
+            )
+
+            # Send an event
+            self._vtherm.send_event(
+                EventType.WINDOW_AUTO_EVENT,
+                {"type": "start", "cause": "slope alert", "curve_slope": slope},
+            )
+            # Set attributes
+            self._window_auto_state = STATE_ON
+            await self.update_window_state(self._window_auto_state)
+
+            # Arm the end trigger
+            self.dearm_window_timer()
+            self._window_call_cancel = async_call_later(
+                self.hass,
+                timedelta(minutes=self._window_auto_max_duration),
+                dearm_window_auto,
+            )
+
+        elif (
+            self._window_auto_algo.is_window_close_detected()
+            and self._window_auto_state == STATE_ON
+        ):
+            await deactivate_window_auto(False)
+
+        # For testing purpose we need to return the inner function
+        return dearm_window_auto
+
+    def add_custom_attributes(self, extra_state_attributes: dict[str, Any]):
+        """Add some custom attributes"""
+        extra_state_attributes.update(
+            {
+                "window_state": self.window_state,
+                "window_auto_state": self.window_auto_state,
+                "window_action": self.window_action,
+                "is_window_bypass": self._is_window_bypass,
+                "window_sensor_entity_id": self._window_sensor_entity_id,
+                "window_delay_sec": self._window_delay_sec,
+                "window_off_delay_sec": self._window_off_delay_sec,
+                "is_window_configured": self._is_configured,
+                "is_window_auto_configured": self._is_window_auto_configured,
+                "window_auto_open_threshold": self._window_auto_open_threshold,
+                "window_auto_close_threshold": self._window_auto_close_threshold,
+                "window_auto_max_duration": self._window_auto_max_duration,
+            }
+        )
+
+    async def set_window_bypass(self, window_bypass: bool) -> bool:
+        """Set the window bypass flag
+        Return True if state have been changed"""
+        self._is_window_bypass = window_bypass
+        if not self._is_window_bypass and self._window_state:
+            _LOGGER.info(
+                "%s - Last window state was open & ByPass is now off. Set hvac_mode to '%s'",
+                self,
+                HVACMode.OFF,
+            )
+            self._vtherm.save_hvac_mode()
+            await self._vtherm.async_set_hvac_mode(HVACMode.OFF)
+            return True
+
+        if self._is_window_bypass and self._window_state:
+            _LOGGER.info(
+                "%s - Last window state was open & ByPass is now on. Set hvac_mode to last available mode",
+                self,
+            )
+            await self._vtherm.restore_hvac_mode(True)
+            return True
+        return False
+
+    @overrides
+    @property
+    def is_configured(self) -> bool:
+        """Return True of the window feature is configured"""
+        return self._is_configured
+
+    @property
+    def is_window_auto_configured(self) -> bool:
+        """Return True of the window automatic detection is configured"""
+        return self._is_window_auto_configured
+
+    @property
+    def window_state(self) -> str | None:
+        """Return the current window state STATE_ON or STATE_OFF
+        or STATE_UNAVAILABLE if not configured"""
+        if not self._is_configured:
+            return STATE_UNAVAILABLE
+        return self._window_state
+
+    @property
+    def window_auto_state(self) -> str | None:
+        """Return the current window auto state STATE_ON or STATE_OFF
+        or STATE_UNAVAILABLE if not configured"""
+        if not self._is_configured:
+            return STATE_UNAVAILABLE
+        return self._window_auto_state
+
+    @property
+    def is_window_bypass(self) -> str | None:
+        """Return True if the window bypass is activated"""
+        if not self._is_configured:
+            return False
+        return self._is_window_bypass
+
+    @property
+    def is_window_detected(self) -> bool:
+        """Return true if the presence is configured and presence sensor is OFF"""
+        return self._is_configured and (
+            self._window_state == STATE_ON or self._window_auto_state == STATE_ON
+        )
+
+    @property
+    def window_sensor_entity_id(self) -> bool:
+        """Return true if the presence is configured and presence sensor is OFF"""
+        return self._window_sensor_entity_id
+
+    @property
+    def window_delay_sec(self) -> bool:
+        """Return the window on delay"""
+        return self._window_delay_sec
+
+    @property
+    def window_off_delay_sec(self) -> bool:
+        """Return the window off delay"""
+        return self._window_off_delay_sec
+
+    @property
+    def window_action(self) -> bool:
+        """Return the window action"""
+        return self._window_action
+
+    @property
+    def window_auto_open_threshold(self) -> bool:
+        """Return the window_auto_open_threshold"""
+        return self._window_auto_open_threshold
+
+    @property
+    def window_auto_close_threshold(self) -> bool:
+        """Return the window_auto_close_threshold"""
+        return self._window_auto_close_threshold
+
+    @property
+    def window_auto_max_duration(self) -> bool:
+        """Return the window_auto_max_duration"""
+        return self._window_auto_max_duration
+
+    @property
+    def last_slope(self) -> float:
+        """Return the last slope (in °C/hour)"""
+        if not self._window_auto_algo:
+            return None
+        return self._window_auto_algo.last_slope
+
+    def __str__(self):
+        return f"WindowManager-{self.name}"

custom_components/versatile_thermostat/icons.json

@@ -0,0 +1,18 @@
+{
+  "entity": {
+    "climate": {
+      "versatile_thermostat": {
+        "state_attributes": {
+          "preset_mode": {
+            "state": {
+              "shedding": "mdi:power-plug-off",
+              "safety": "mdi:shield-alert",
+              "none": "mdi:knob",
+              "frost": "mdi:snowflake"
+            }
+          }
+        }
+      }
+    }
+  }
+}

custom_components/versatile_thermostat/manifest.json

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

custom_components/versatile_thermostat/number.py

@@ -20,7 +20,6 @@ from homeassistant.components.climate import (
     PRESET_COMFORT,
     PRESET_ECO,
 )
-from homeassistant.components.sensor import UnitOfTemperature
 
 from homeassistant.helpers.device_registry import DeviceInfo, DeviceEntryType
 from homeassistant.config_entries import ConfigEntry
@@ -29,7 +28,7 @@ from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.util import slugify
 
 from .vtherm_api import VersatileThermostatAPI
-from .commons import VersatileThermostatBaseEntity
+from .base_entity import VersatileThermostatBaseEntity
 
 from .const import (
     DOMAIN,
@@ -368,9 +367,6 @@ class CentralConfigTemperatureNumber(
     @property
     def native_unit_of_measurement(self) -> str | None:
         """The unit of measurement"""
-        # 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 self.hass.config.units.temperature_unit
 
 
@@ -487,8 +483,8 @@ 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
+        # 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):

custom_components/versatile_thermostat/open_window_algorithm.py

@@ -26,20 +26,14 @@ MIN_NB_POINT = 4  # do not calculate slope until we have enough point
 class WindowOpenDetectionAlgorithm:
     """The class that implements the algorithm listed above"""
 
-    _alert_threshold: float
-    _end_alert_threshold: float
-    _last_slope: float
-    _last_datetime: datetime
-    _last_temperature: float
-    _nb_point: int
-
     def __init__(self, alert_threshold, end_alert_threshold) -> None:
         """Initalize a new algorithm with the both threshold"""
-        self._alert_threshold = alert_threshold
-        self._end_alert_threshold = end_alert_threshold
-        self._last_slope = None
-        self._last_datetime = None
-        self._nb_point = 0
+        self._alert_threshold: float = alert_threshold
+        self._end_alert_threshold: float = end_alert_threshold
+        self._last_slope: float | None = None
+        self._last_datetime: datetime = None
+        self._last_temperature: float | None = None
+        self._nb_point: int = 0
 
     def check_age_last_measurement(self, temperature, datetime_now) -> float:
         """ " Check if last measurement is old and add

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"""
 
@@ -25,6 +31,7 @@ class PropAlgorithm:
         cycle_min: int,
         minimal_activation_delay: int,
         vtherm_entity_id: str = None,
+        max_on_percent: float = None,
     ) -> None:
         """Initialisation of the Proportional Algorithm"""
         _LOGGER.debug(
@@ -36,6 +43,30 @@ class PropAlgorithm:
             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
@@ -48,6 +79,7 @@ class PropAlgorithm:
         self._off_time_sec = self._cycle_min * 60
         self._security = False
         self._default_on_percent = 0
+        self._max_on_percent = max_on_percent
 
     def calculate(
         self,
@@ -131,6 +163,15 @@ class PropAlgorithm:
             )
             self._on_percent = self._calculated_on_percent
 
+        if self._max_on_percent is not None and self._on_percent > self._max_on_percent:
+            _LOGGER.debug(
+                "%s - Heating period clamped to %s (instead of %s) due to max_on_percent setting.",
+                self._vtherm_entity_id,
+                self._max_on_percent,
+                self._on_percent,
+            )
+            self._on_percent = self._max_on_percent
+
         self._on_time_sec = self._on_percent * self._cycle_min * 60
 
         # Do not heat for less than xx sec
@@ -146,7 +187,7 @@ class PropAlgorithm:
 
         self._off_time_sec = self._cycle_min * 60 - self._on_time_sec
 
-    def set_security(self, default_on_percent: float):
+    def set_safety(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
@@ -155,7 +196,7 @@ class PropAlgorithm:
         self._default_on_percent = default_on_percent
         self._calculate_internal()
 
-    def unset_security(self):
+    def unset_safety(self):
         """Unset the safety mode"""
         _LOGGER.info(
             "%s - Proportional Algo - set security to OFF", self._vtherm_entity_id

custom_components/versatile_thermostat/select.py

@@ -3,19 +3,15 @@
 """ 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,
 )
 
@@ -126,6 +122,12 @@ 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)

custom_components/versatile_thermostat/sensor.py

@@ -3,7 +3,7 @@
 import logging
 import math
 
-from homeassistant.core import HomeAssistant, callback, Event, CoreState
+from homeassistant.core import HomeAssistant, callback, Event, CoreState, State
 
 from homeassistant.const import (
     UnitOfTime,
@@ -17,26 +17,25 @@ from homeassistant.components.sensor import (
     SensorEntity,
     SensorDeviceClass,
     SensorStateClass,
-    UnitOfTemperature,
 )
 from homeassistant.config_entries import ConfigEntry
 
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.device_registry import DeviceInfo, DeviceEntryType
 from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.event import async_track_state_change_event
+from homeassistant.helpers.event import (
+    async_track_state_change_event,
+)
 
 from homeassistant.components.climate import (
     ClimateEntity,
     DOMAIN as CLIMATE_DOMAIN,
-    HVACAction,
-    HVACMode,
 )
 
 
 from .base_thermostat import BaseThermostat
 from .vtherm_api import VersatileThermostatAPI
-from .commons import VersatileThermostatBaseEntity
+from .base_entity import VersatileThermostatBaseEntity
 from .const import (
     DOMAIN,
     DEVICE_MANUFACTURER,
@@ -50,6 +49,8 @@ from .const import (
     CONF_THERMOSTAT_TYPE,
     CONF_THERMOSTAT_CENTRAL_CONFIG,
     CONF_USE_CENTRAL_BOILER_FEATURE,
+    CONF_AUTO_REGULATION_VALVE,
+    CONF_AUTO_REGULATION_MODE,
     overrides,
 )
 
@@ -71,6 +72,9 @@ async def async_setup_entry(
     unique_id = entry.entry_id
     name = entry.data.get(CONF_NAME)
     vt_type = entry.data.get(CONF_THERMOSTAT_TYPE)
+    have_valve_regulation = (
+        entry.data.get(CONF_AUTO_REGULATION_MODE) == CONF_AUTO_REGULATION_VALVE
+    )
 
     entities = None
 
@@ -99,10 +103,16 @@ async def async_setup_entry(
             entities.append(OnTimeSensor(hass, unique_id, name, entry.data))
             entities.append(OffTimeSensor(hass, unique_id, name, entry.data))
 
-        if entry.data.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_VALVE:
+        if (
+            entry.data.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_VALVE
+            or have_valve_regulation
+        ):
             entities.append(ValveOpenPercentSensor(hass, unique_id, name, entry.data))
 
-        if entry.data.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_CLIMATE:
+        if (
+            entry.data.get(CONF_THERMOSTAT_TYPE) == CONF_THERMOSTAT_CLIMATE
+            and not have_valve_regulation
+        ):
             entities.append(
                 RegulatedTemperatureSensor(hass, unique_id, name, entry.data)
             )
@@ -123,7 +133,7 @@ class EnergySensor(VersatileThermostatBaseEntity, SensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         energy = self.my_climate.total_energy
         if energy is None:
@@ -155,7 +165,7 @@ class EnergySensor(VersatileThermostatBaseEntity, SensorEntity):
         if not self.my_climate:
             return None
 
-        if self.my_climate.device_power > THRESHOLD_WATT_KILO:
+        if self.my_climate.power_manager.device_power > THRESHOLD_WATT_KILO:
             return UnitOfEnergy.WATT_HOUR
         else:
             return UnitOfEnergy.KILO_WATT_HOUR
@@ -178,18 +188,19 @@ class MeanPowerSensor(VersatileThermostatBaseEntity, SensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
-        if math.isnan(float(self.my_climate.mean_cycle_power)) or math.isinf(
-            self.my_climate.mean_cycle_power
-        ):
+        if math.isnan(
+            float(self.my_climate.power_manager.mean_cycle_power)
+        ) or math.isinf(self.my_climate.power_manager.mean_cycle_power):
             raise ValueError(
-                f"Sensor has illegal state {self.my_climate.mean_cycle_power}"
+                f"Sensor has illegal state {self.my_climate.power_manager.mean_cycle_power}"
             )
 
         old_state = self._attr_native_value
         self._attr_native_value = round(
-            self.my_climate.mean_cycle_power, self.suggested_display_precision
+            self.my_climate.power_manager.mean_cycle_power,
+            self.suggested_display_precision,
         )
         if old_state != self._attr_native_value:
             self.async_write_ha_state()
@@ -212,7 +223,7 @@ class MeanPowerSensor(VersatileThermostatBaseEntity, SensorEntity):
         if not self.my_climate:
             return None
 
-        if self.my_climate.device_power > THRESHOLD_WATT_KILO:
+        if self.my_climate.power_manager.device_power > THRESHOLD_WATT_KILO:
             return UnitOfPower.WATT
         else:
             return UnitOfPower.KILO_WATT
@@ -235,7 +246,7 @@ class OnPercentSensor(VersatileThermostatBaseEntity, SensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         on_percent = (
             float(self.my_climate.proportional_algorithm.on_percent)
@@ -290,7 +301,11 @@ class ValveOpenPercentSensor(VersatileThermostatBaseEntity, SensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+
+        if not self.my_climate or not hasattr(self.my_climate, "valve_open_percent"):
+            _LOGGER.warning("%s - my_climate not found or no valve_open_percent property found. This could be normal at startup. Ignore the underlying device change.", self)
+            return
 
         old_state = self._attr_native_value
         self._attr_native_value = self.my_climate.valve_open_percent
@@ -332,7 +347,7 @@ class OnTimeSensor(VersatileThermostatBaseEntity, SensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         on_time = (
             float(self.my_climate.proportional_algorithm.on_time_sec)
@@ -381,7 +396,7 @@ class OffTimeSensor(VersatileThermostatBaseEntity, SensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         off_time = (
             float(self.my_climate.proportional_algorithm.off_time_sec)
@@ -429,7 +444,7 @@ class LastTemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         old_state = self._attr_native_value
         self._attr_native_value = self.my_climate.last_temperature_measure
@@ -458,7 +473,7 @@ class LastExtTemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         old_state = self._attr_native_value
         self._attr_native_value = self.my_climate.last_ext_temperature_measure
@@ -487,7 +502,7 @@ class TemperatureSlopeSensor(VersatileThermostatBaseEntity, SensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         last_slope = self.my_climate.last_temperature_slope
         if last_slope is None:
@@ -540,7 +555,7 @@ class RegulatedTemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         new_temp = self.my_climate.regulated_target_temp
         if new_temp is None:
@@ -591,7 +606,7 @@ class EMATemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
     @callback
     async def async_my_climate_changed(self, event: Event = None):
         """Called when my climate have change"""
-        _LOGGER.debug("%s - climate state change", self._attr_unique_id)
+        # _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
         new_ema = self.my_climate.ema_temperature
         if new_ema is None:
@@ -634,6 +649,10 @@ class NbActiveDeviceForBoilerSensor(SensorEntity):
     """Representation of the threshold of the number of VTherm
     which should be active to activate the boiler"""
 
+    _entity_component_unrecorded_attributes = SensorEntity._entity_component_unrecorded_attributes.union(  # pylint: disable=protected-access
+        frozenset({"active_device_ids"})
+    )
+
     def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos) -> None:
         """Initialize the energy sensor"""
         self._hass = hass
@@ -643,6 +662,14 @@ class NbActiveDeviceForBoilerSensor(SensorEntity):
         self._attr_unique_id = "nb_device_active_boiler"
         self._attr_value = self._attr_native_value = None  # default value
         self._entities = []
+        self._attr_active_device_ids = []  # Holds the entity ids of active devices
+
+    @property
+    def extra_state_attributes(self) -> dict:
+        """Return additional attributes for the sensor."""
+        return {
+            "active_device_ids": self._attr_active_device_ids,
+        }
 
     @property
     def icon(self) -> str | None:
@@ -698,7 +725,7 @@ class NbActiveDeviceForBoilerSensor(SensorEntity):
         for entity in component.entities:
             if isinstance(entity, BaseThermostat) and entity.is_used_by_central_boiler:
                 self._entities.append(entity)
-                for under in entity.underlying_entities:
+                for under in entity.activable_underlying_entities:
                     underlying_entities_id.append(under.entity_id)
         if len(underlying_entities_id) > 0:
             # Arme l'écoute de la première entité
@@ -708,36 +735,86 @@ class NbActiveDeviceForBoilerSensor(SensorEntity):
                 self.calculate_nb_active_devices,
             )
             _LOGGER.info(
-                "%s - the underlyings that could controls the central boiler are %s",
+                "%s - the underlyings that could control the central boiler are %s",
                 self,
                 underlying_entities_id,
             )
             self.async_on_remove(listener_cancel)
         else:
-            _LOGGER.debug("%s - no VTherm could controls the central boiler", self)
+            _LOGGER.debug("%s - no VTherm could control the central boiler", self)
 
         await self.calculate_nb_active_devices(None)
 
-    async def calculate_nb_active_devices(self, _):
+    async def calculate_nb_active_devices(self, event: Event):
         """Calculate the number of active VTherm that have an
-        influence on central boiler"""
+        influence on the central boiler and update the list of active device names."""
 
-        _LOGGER.debug("%s - calculating the number of active VTherm", self)
-        nb_active = 0
-        for entity in self._entities:
-            _LOGGER.debug(
-                "Examining the hvac_action of %s",
-                entity.name,
+        # _LOGGER.debug("%s- calculate_nb_active_devices - the event is %s ", self, event)
+
+        if event is not None:
+            new_state: State = event.data.get("new_state")
+            # _LOGGER.debug(
+            #     "%s - calculate_nb_active_devices new_state is %s", self, new_state
+            # )
+            if not new_state:
+                return
+
+            old_state: State = event.data.get("old_state")
+
+            # For underlying climate, we need to observe also the hvac_action if available
+            new_hvac_action = new_state.attributes.get("hvac_action")
+            old_hvac_action = (
+                old_state.attributes.get("hvac_action")
+                if old_state is not None
+                else None
             )
+
+            # Filter events that are not interested for us
             if (
-                entity.hvac_mode in [HVACMode.HEAT, HVACMode.AUTO]
-                and entity.hvac_action == HVACAction.HEATING
+                old_state is not None
+                and new_state.state == old_state.state
+                and new_hvac_action == old_hvac_action
+                # issue 698 - force recalculation when underlying climate doesn't have any hvac_action
+                and new_hvac_action is not None
             ):
-                for under in entity.underlying_entities:
-                    nb_active += 1 if under.is_device_active else 0
+                # A false state change
+                return
+
+            _LOGGER.debug(
+                "%s - calculating the number of active underlying device for boiler activation. change change from %s to %s",
+                self,
+                old_state,
+                new_state,
+            )
+        else:
+            _LOGGER.debug(
+                "%s - calculating the number of active underlying device for boiler activation. First time calculation",
+                self,
+            )
+
+        nb_active = 0
+        active_device_ids = []
+
+        for entity in self._entities:
+            device_actives = entity.device_actives
+            _LOGGER.debug(
+                "After examining the hvac_action of %s, device_actives is %s",
+                entity.name,
+                device_actives,
+            )
+
+            nb_active += len(device_actives)
+            active_device_ids.extend(device_actives)
 
         self._attr_native_value = nb_active
+        self._attr_active_device_ids = active_device_ids
+
         self.async_write_ha_state()
 
+    @property
+    def active_device_ids(self) -> list:
+        """Get the list of active device id"""
+        return self._attr_active_device_ids
+
     def __str__(self):
         return f"VersatileThermostat-{self.name}"

custom_components/versatile_thermostat/services.yaml

@@ -76,7 +76,7 @@ set_preset_temperature:
                     unit_of_measurement: °
                     mode: slider
 
-set_security:
+set_safety:
     name: Set safety
     description: Change the safety parameters
     target:

custom_components/versatile_thermostat/strings.json

@@ -27,13 +27,15 @@
           "power": "Power management",
           "presence": "Presence detection",
           "advanced": "Advanced parameters",
+          "auto_start_stop": "Auto start and stop",
+          "valve_regulation": "Valve regulation configuration",
           "finalize": "All done",
           "configuration_not_complete": "Configuration not complete"
         }
       },
       "main": {
         "title": "Add new Versatile Thermostat",
-        "description": "Main mandatory attributes",
+        "description": "Main mandatory attributes [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/base-attributes.md)",
         "data": {
           "name": "Name",
           "thermostat_type": "Thermostat type",
@@ -63,62 +65,46 @@
           "use_motion_feature": "Use motion detection",
           "use_power_feature": "Use power management",
           "use_presence_feature": "Use presence detection",
-          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after seecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page"
+          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after selecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page",
+          "use_auto_start_stop_feature": "Use the auto start and stop feature"
         }
       },
       "type": {
         "title": "Linked entities",
-        "description": "Linked entities attributes",
+        "description": "Linked entities attributes [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/over-switch.md#configuration)",
         "data": {
-          "heater_entity_id": "1st heater switch",
-          "heater_entity2_id": "2nd heater switch",
-          "heater_entity3_id": "3rd heater switch",
-          "heater_entity4_id": "4th heater switch",
+          "underlying_entity_ids": "The device(s) to be controlled",
           "heater_keep_alive": "Switch keep-alive interval in seconds",
           "proportional_function": "Algorithm",
-          "climate_entity_id": "1st underlying climate",
-          "climate_entity2_id": "2nd underlying climate",
-          "climate_entity3_id": "3rd underlying climate",
-          "climate_entity4_id": "4th underlying climate",
           "ac_mode": "AC mode",
-          "valve_entity_id": "1st valve number",
-          "valve_entity2_id": "2nd valve number",
-          "valve_entity3_id": "3rd valve number",
-          "valve_entity4_id": "4th valve number",
           "auto_regulation_mode": "Self-regulation",
           "auto_regulation_dtemp": "Regulation threshold",
           "auto_regulation_periode_min": "Regulation minimum period",
           "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",
+          "on_command_text": "Turn on command customization",
+          "vswitch_on_command": "Optional turn on commands",
+          "off_command_text": "Turn off command customization",
+          "vswitch_off_command": "Optional turn off commands"
         },
         "data_description": {
-          "heater_entity_id": "Mandatory heater entity id",
-          "heater_entity2_id": "Optional 2nd Heater entity id. Leave empty if not required",
-          "heater_entity3_id": "Optional 3rd Heater entity id. Leave empty if not required",
-          "heater_entity4_id": "Optional 4th Heater entity id. Leave empty if not required",
+          "underlying_entity_ids": "The device(s) to be controlled - 1 is required",
           "heater_keep_alive": "Optional heater switch state refresh interval. Leave empty if not required.",
           "proportional_function": "Algorithm to use (TPI is the only one for now)",
-          "climate_entity_id": "Underlying climate entity id",
-          "climate_entity2_id": "2nd underlying climate entity id",
-          "climate_entity3_id": "3rd underlying climate entity id",
-          "climate_entity4_id": "4th underlying climate entity id",
           "ac_mode": "Use the Air Conditioning (AC) mode",
-          "valve_entity_id": "1st valve number entity id",
-          "valve_entity2_id": "2nd valve number entity id",
-          "valve_entity3_id": "3rd valve number entity id",
-          "valve_entity4_id": "4th valve number entity id",
           "auto_regulation_mode": "Auto adjustment of the target temperature",
           "auto_regulation_dtemp": "The threshold in ° (or % for valve) under which the temperature change will not be sent",
           "auto_regulation_periode_min": "Duration in minutes between two regulation update",
           "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",
+          "on_command_text": "For underlying of type `select` or `climate` you have to customize the commands."
         }
       },
       "tpi": {
         "title": "TPI",
-        "description": "Time Proportional Integral attributes",
+        "description": "Time Proportional Integral attributes [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/algorithms.md#lalgorithme-tpi)",
         "data": {
           "tpi_coef_int": "coef_int",
           "tpi_coef_ext": "coef_ext",
@@ -132,17 +118,18 @@
       },
       "presets": {
         "title": "Presets",
-        "description": "Select if the thermostat will use central preset - deselect for the thermostat to have its own presets",
+        "description": "Select if the thermostat will use central preset - deselect for the thermostat to have its own presets [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-presets.md)",
         "data": {
           "use_presets_central_config": "Use central presets configuration"
         }
       },
       "window": {
         "title": "Window management",
-        "description": "Open window management.\nYou can also configure automatic window open detection based on temperature decrease",
+        "description": "Open window management.\nYou can also configure automatic window open detection based on temperature decrease [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-window.md)",
         "data": {
           "window_sensor_entity_id": "Window sensor entity id",
-          "window_delay": "Window sensor delay (seconds)",
+          "window_delay": "Window sensor 'on' delay (seconds)",
+          "window_off_delay": "Window sensor 'off' delay (seconds)",
           "window_auto_open_threshold": "Temperature decrease threshold for automatic window open detection (in °/hours)",
           "window_auto_close_threshold": "Temperature increase threshold for end of automatic detection (in °/hours)",
           "window_auto_max_duration": "Maximum duration of automatic window open detection (in min)",
@@ -151,7 +138,8 @@
         },
         "data_description": {
           "window_sensor_entity_id": "Leave empty if no window sensor should be used and to use the automatic detection",
-          "window_delay": "The delay in seconds before sensor detection is taken into account",
+          "window_delay": "The delay in seconds before sensor 'on' detection is taken into account",
+          "window_off_delay": "The delay in seconds before sensor 'off' detection is taken into account. Leave it empty to use the same value as window on delay",
           "window_auto_open_threshold": "Recommended value: between 3 and 10. Leave empty if automatic window open detection is not used",
           "window_auto_close_threshold": "Recommended value: 0. Leave empty if automatic window open detection is not used",
           "window_auto_max_duration": "Recommended value: 60 (one hour). Leave empty if automatic window open detection is not used",
@@ -161,7 +149,7 @@
       },
       "motion": {
         "title": "Motion management",
-        "description": "Motion sensor management. Preset can switch automatically depending on motion detection\nmotion_preset and no_motion_preset should be set to the corresponding preset name",
+        "description": "Motion sensor management. Preset can switch automatically depending on motion detection\nmotion_preset and no_motion_preset should be set to the corresponding preset name [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-motion.md)",
         "data": {
           "motion_sensor_entity_id": "Motion sensor entity id",
           "motion_delay": "Activation delay",
@@ -181,7 +169,7 @@
       },
       "power": {
         "title": "Power management",
-        "description": "Power management attributes.\nGives the power and max power sensor of your home.\nSpecify the power consumption of the heater when on.\nAll sensors and device power should use the same unit (kW or W).",
+        "description": "Power management attributes.\nGives the power and max power sensor of your home.\nSpecify the power consumption of the heater when on.\nAll sensors and device power should use the same unit (kW or W) [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-power.md)",
         "data": {
           "power_sensor_entity_id": "Power",
           "max_power_sensor_entity_id": "Max power",
@@ -197,7 +185,7 @@
       },
       "presence": {
         "title": "Presence management",
-        "description": "Presence management attributes.\nGives the a presence sensor of your home (true is someone is present) and give the corresponding temperature preset setting.",
+        "description": "Presence management attributes.\nGives the a presence sensor of your home (true is someone is present) and give the corresponding temperature preset setting [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-presence.md)",
         "data": {
           "presence_sensor_entity_id": "Presence sensor",
           "use_presence_central_config": "Use central presence temperature configuration. Deselect to use specific temperature entities"
@@ -208,21 +196,51 @@
       },
       "advanced": {
         "title": "Advanced parameters",
-        "description": "Configuration of advanced parameters. Leave the default values if you don't know what you are doing.\nThese parameters can lead to very poor temperature control or bad power regulation.",
+        "description": "Configuration of advanced parameters. Leave the default values if you don't know what you are doing.\nThese parameters can lead to very poor temperature control or bad power regulation [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-advanced.md)",
         "data": {
           "minimal_activation_delay": "Minimum activation delay",
-          "security_delay_min": "Safety delay (in minutes)",
-          "security_min_on_percent": "Minimum power percent to enable safety mode",
-          "security_default_on_percent": "Power percent to use in safety mode",
+          "safety_delay_min": "Safety delay (in minutes)",
+          "safety_min_on_percent": "Minimum power percent to enable safety mode",
+          "safety_default_on_percent": "Power percent to use in safety mode",
           "use_advanced_central_config": "Use central advanced configuration"
         },
         "data_description": {
           "minimal_activation_delay": "Delay in seconds under which the equipment will not be activated",
-          "security_delay_min": "Maximum allowed delay in minutes between two temperature measurements. Above this delay the thermostat will turn to a safety off state",
-          "security_min_on_percent": "Minimum heating percent value for safety preset activation. Below this amount of power percent the thermostat won't go into safety preset",
-          "security_default_on_percent": "The default heating power percent value in safety preset. Set to 0 to switch off heater in safety preset",
+          "safety_delay_min": "Maximum allowed delay in minutes between two temperature measurements. Above this delay the thermostat will turn to a safety off state",
+          "safety_min_on_percent": "Minimum heating percent value for safety preset activation. Below this amount of power percent the thermostat won't go into safety preset",
+          "safety_default_on_percent": "The default heating power percent value in safety preset. Set to 0 to switch off heater in safety preset",
           "use_advanced_central_config": "Check to use the central advanced configuration. Uncheck to use a specific advanced configuration for this VTherm"
         }
+      },
+      "central_boiler": {
+        "title": "Control of the central boiler",
+        "description": "Enter the services to call to turn on/off the central boiler. Leave blank if no service call is to be made (in this case, you will have to manage the turning on/off of your central boiler yourself). The service called must be formatted as follows: `entity_id/service_name[/attribute:value]` (/attribute:value is optional)\nFor example:\n- to turn on a switch: `switch.controle_chaudiere/switch.turn_on`\n- to turn off a switch: `switch.controle_chaudiere/switch.turn_off`\n- to program the boiler to 25° and thus force its ignition: `climate.thermostat_chaudiere/climate.set_temperature/temperature:25`\n- to send 10° to the boiler and thus force its extinction: `climate.thermostat_chaudiere/climate.set_temperature/temperature:10` [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-central-boiler.md)",
+        "data": {
+          "central_boiler_activation_service": "Command to turn-on",
+          "central_boiler_deactivation_service": "Command to turn-off"
+        },
+        "data_description": {
+          "central_boiler_activation_service": "Command to turn-on the central boiler formatted like entity_id/service_name[/attribut:valeur]",
+          "central_boiler_deactivation_service": "Command to turn-off the central boiler formatted like entity_id/service_name[/attribut:valeur]"
+        }
+      },
+      "valve_regulation": {
+        "title": "Self-regulation with valve",
+        "description": "Configuration for self-regulation with direct control of the valve [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/self-regulation.md#auto-régulation-par-contrôle-direct-de-la-vanne)",
+        "data": {
+          "offset_calibration_entity_ids": "Offset calibration entities",
+          "opening_degree_entity_ids": "Opening degree entities",
+          "closing_degree_entity_ids": "Closing degree entities",
+          "proportional_function": "Algorithm",
+          "min_opening_degrees": "Min opening degrees"
+        },
+        "data_description": {
+          "offset_calibration_entity_ids": "The list of the 'offset calibration' entities. Set it if your TRV has the entity for better regulation. There should be one per underlying climate entities",
+          "opening_degree_entity_ids": "The list of the 'opening degree' entities. There should be one per underlying climate entities",
+          "closing_degree_entity_ids": "The list of the 'closing degree' entities. Set it if your TRV has the entity for better regulation. There should be one per underlying climate entities",
+          "proportional_function": "Algorithm to use (TPI is the only one for now)",
+          "min_opening_degrees": "Opening degree minimum value for each underlying device, comma separated. Default to 0. Example: 20, 25, 30"
+        }
       }
     },
     "error": {
@@ -262,13 +280,15 @@
           "power": "Power management",
           "presence": "Presence detection",
           "advanced": "Advanced parameters",
+          "auto_start_stop": "Auto start and stop",
+          "valve_regulation": "Valve regulation configuration",
           "finalize": "All done",
           "configuration_not_complete": "Configuration not complete"
         }
       },
       "main": {
         "title": "Main - {name}",
-        "description": "Main mandatory attributes",
+        "description": "Main mandatory attributes [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/base-attributes.md)",
         "data": {
           "name": "Name",
           "thermostat_type": "Thermostat type",
@@ -298,62 +318,46 @@
           "use_motion_feature": "Use motion detection",
           "use_power_feature": "Use power management",
           "use_presence_feature": "Use presence detection",
-          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after seecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page"
+          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after selecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page",
+          "use_auto_start_stop_feature": "Use the auto start and stop feature"
         }
       },
       "type": {
         "title": "Entities - {name}",
-        "description": "Linked entities attributes",
+        "description": "Linked entities attributes [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/over-switch.md#configuration)",
         "data": {
-          "heater_entity_id": "1st heater switch",
-          "heater_entity2_id": "2nd heater switch",
-          "heater_entity3_id": "3rd heater switch",
-          "heater_entity4_id": "4th heater switch",
+          "underlying_entity_ids": "The device(s) to be controlled",
           "heater_keep_alive": "Switch keep-alive interval in seconds",
           "proportional_function": "Algorithm",
-          "climate_entity_id": "1st underlying climate",
-          "climate_entity2_id": "2nd underlying climate",
-          "climate_entity3_id": "3rd underlying climate",
-          "climate_entity4_id": "4th underlying climate",
           "ac_mode": "AC mode",
-          "valve_entity_id": "1st valve number",
-          "valve_entity2_id": "2nd valve number",
-          "valve_entity3_id": "3rd valve number",
-          "valve_entity4_id": "4th valve number",
           "auto_regulation_mode": "Self-regulation",
           "auto_regulation_dtemp": "Regulation threshold",
           "auto_regulation_periode_min": "Regulation minimum period",
           "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",
+          "on_command_text": "Turn on command customization",
+          "vswitch_on_command": "Optional turn on commands",
+          "off_command_text": "Turn off command customization",
+          "vswitch_off_command": "Optional turn off commands"
         },
         "data_description": {
-          "heater_entity_id": "Mandatory heater entity id",
-          "heater_entity2_id": "Optional 2nd Heater entity id. Leave empty if not used",
-          "heater_entity3_id": "Optional 3rd Heater entity id. Leave empty if not used",
-          "heater_entity4_id": "Optional 4th Heater entity id. Leave empty if not used",
+          "underlying_entity_ids": "The device(s) to be controlled - 1 is required",
           "heater_keep_alive": "Optional heater switch state refresh interval. Leave empty if not required.",
           "proportional_function": "Algorithm to use (TPI is the only one for now)",
-          "climate_entity_id": "Underlying climate entity id",
-          "climate_entity2_id": "2nd underlying climate entity id",
-          "climate_entity3_id": "3rd underlying climate entity id",
-          "climate_entity4_id": "4th underlying climate entity id",
           "ac_mode": "Use the Air Conditioning (AC) mode",
-          "valve_entity_id": "1st valve number entity id",
-          "valve_entity2_id": "2nd valve number entity id",
-          "valve_entity3_id": "3rd valve number entity id",
-          "valve_entity4_id": "4th valve number entity id",
           "auto_regulation_mode": "Auto adjustment of the target temperature",
           "auto_regulation_dtemp": "The threshold in ° (or % for valve) under which the temperature change will not be sent",
           "auto_regulation_periode_min": "Duration in minutes between two regulation update",
           "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"
+          "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",
+          "on_command_text": "For underlying of type `select` or `climate` you have to customize the commands."
         }
       },
       "tpi": {
         "title": "TPI - {name}",
-        "description": "Time Proportional Integral attributes",
+        "description": "Time Proportional Integral attributes [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/algorithms.md#lalgorithme-tpi)",
         "data": {
           "tpi_coef_int": "coef_int",
           "tpi_coef_ext": "coef_ext",
@@ -367,17 +371,18 @@
       },
       "presets": {
         "title": "Presets - {name}",
-        "description": "Check if the thermostat will use central presets. Uncheck and the thermostat will have its own preset entities",
+        "description": "Check if the thermostat will use central presets. Uncheck and the thermostat will have its own preset entities [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-presets.md)",
         "data": {
           "use_presets_central_config": "Use central presets configuration"
         }
       },
       "window": {
         "title": "Window - {name}",
-        "description": "Open window management.\nYou can also configure automatic window open detection based on temperature decrease",
+        "description": "Open window management.\nYou can also configure automatic window open detection based on temperature decrease [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-window.md)",
         "data": {
           "window_sensor_entity_id": "Window sensor entity id",
-          "window_delay": "Window sensor delay (seconds)",
+          "window_delay": "Window sensor 'on' delay (seconds)",
+          "window_off_delay": "Window sensor 'off' delay (seconds)",
           "window_auto_open_threshold": "Temperature decrease threshold for automatic window open detection (in °/hours)",
           "window_auto_close_threshold": "Temperature increase threshold for end of automatic detection (in °/hours)",
           "window_auto_max_duration": "Maximum duration of automatic window open detection (in min)",
@@ -386,8 +391,8 @@
         },
         "data_description": {
           "window_sensor_entity_id": "Leave empty if no window sensor should be used and to use the automatic detection",
-          "window_delay": "The delay in seconds before sensor detection is taken into account",
-          "window_auto_open_threshold": "Recommended value: between 3 and 10. Leave empty if automatic window open detection is not used",
+          "window_delay": "The delay in seconds before sensor 'on' detection is taken into account",
+          "window_off_delay": "The delay in seconds before sensor 'off' detection is taken into account. Leave it empty to use the same value as window on delay",
           "window_auto_close_threshold": "Recommended value: 0. Leave empty if automatic window open detection is not used",
           "window_auto_max_duration": "Recommended value: 60 (one hour). Leave empty if automatic window open detection is not used",
           "use_window_central_config": "Check to use the central window configuration. Uncheck to use a specific window configuration for this VTherm",
@@ -396,7 +401,7 @@
       },
       "motion": {
         "title": "Motion - {name}",
-        "description": "Motion management. Preset can switch automatically depending of a motion detection\nmotion_preset and no_motion_preset should be set to the corresponding preset name",
+        "description": "Motion management. Preset can switch automatically depending of a motion detection\nmotion_preset and no_motion_preset should be set to the corresponding preset name [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-motion.md)",
         "data": {
           "motion_sensor_entity_id": "Motion sensor entity id",
           "motion_delay": "Activation delay",
@@ -416,7 +421,7 @@
       },
       "power": {
         "title": "Power - {name}",
-        "description": "Power management attributes.\nGives the power and max power sensor of your home.\nThen specify the power consumption of the heater when on.\nAll sensors and device power should have the same unit (kW or W).",
+        "description": "Power management attributes.\nGives the power and max power sensor of your home.\nSpecify the power consumption of the heater when on.\nAll sensors and device power should use the same unit (kW or W) [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-power.md)",
         "data": {
           "power_sensor_entity_id": "Power",
           "max_power_sensor_entity_id": "Max power",
@@ -432,7 +437,7 @@
       },
       "presence": {
         "title": "Presence - {name}",
-        "description": "Presence management attributes.\nGives the a presence sensor of your home (true is someone is present) and give the corresponding temperature preset setting.",
+        "description": "Presence management attributes.\nGives the a presence sensor of your home (true is someone is present) and give the corresponding temperature preset setting [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-presence.md)",
         "data": {
           "presence_sensor_entity_id": "Presence sensor",
           "use_presence_central_config": "Use central presence temperature configuration. Uncheck to use specific temperature entities"
@@ -443,21 +448,51 @@
       },
       "advanced": {
         "title": "Advanced - {name}",
-        "description": "Advanced parameters. Leave the default values if you don't know what you are doing.\nThese parameters can lead to very poor temperature control or bad power regulation.",
+        "description": "Configuration of advanced parameters. Leave the default values if you don't know what you are doing.\nThese parameters can lead to very poor temperature control or bad power regulation [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-advanced.md)",
         "data": {
           "minimal_activation_delay": "Minimum activation delay",
-          "security_delay_min": "Safety delay (in minutes)",
-          "security_min_on_percent": "Minimum power percent to enable safety mode",
-          "security_default_on_percent": "Power percent to use in safety mode",
+          "safety_delay_min": "Safety delay (in minutes)",
+          "safety_min_on_percent": "Minimum power percent to enable safety mode",
+          "safety_default_on_percent": "Power percent to use in safety mode",
           "use_advanced_central_config": "Use central advanced configuration"
         },
         "data_description": {
           "minimal_activation_delay": "Delay in seconds under which the equipment will not be activated",
-          "security_delay_min": "Maximum allowed delay in minutes between two temperature measurements. Above this delay the thermostat will turn to a safety off state",
-          "security_min_on_percent": "Minimum heating percent value for safety preset activation. Below this amount of power percent the thermostat won't go into safety preset",
-          "security_default_on_percent": "The default heating power percent value in safety preset. Set to 0 to switch off heater in safety preset",
+          "safety_delay_min": "Maximum allowed delay in minutes between two temperature measurements. Above this delay the thermostat will turn to a safety off state",
+          "safety_min_on_percent": "Minimum heating percent value for safety preset activation. Below this amount of power percent the thermostat won't go into safety preset",
+          "safety_default_on_percent": "The default heating power percent value in safety preset. Set to 0 to switch off heater in safety preset",
           "use_advanced_central_config": "Check to use the central advanced configuration. Uncheck to use a specific advanced configuration for this VTherm"
         }
+      },
+      "central_boiler": {
+        "title": "Control of the central boiler - {name}",
+        "description": "Enter the services to call to turn on/off the central boiler. Leave blank if no service call is to be made (in this case, you will have to manage the turning on/off of your central boiler yourself). The service called must be formatted as follows: `entity_id/service_name[/attribute:value]` (/attribute:value is optional)\nFor example:\n- to turn on a switch: `switch.controle_chaudiere/switch.turn_on`\n- to turn off a switch: `switch.controle_chaudiere/switch.turn_off`\n- to program the boiler to 25° and thus force its ignition: `climate.thermostat_chaudiere/climate.set_temperature/temperature:25`\n- to send 10° to the boiler and thus force its extinction: `climate.thermostat_chaudiere/climate.set_temperature/temperature:10` [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-central-boiler.md)",
+        "data": {
+          "central_boiler_activation_service": "Command to turn-on",
+          "central_boiler_deactivation_service": "Command to turn-off"
+        },
+        "data_description": {
+          "central_boiler_activation_service": "Command to turn-on the central boiler formatted like entity_id/service_name[/attribut:valeur]",
+          "central_boiler_deactivation_service": "Command to turn-off the central boiler formatted like entity_id/service_name[/attribut:valeur]"
+        }
+      },
+      "valve_regulation": {
+        "title": "Self-regulation with valve - {name}",
+        "description": "Configuration for self-regulation with direct control of the valve [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/self-regulation.md#auto-régulation-par-contrôle-direct-de-la-vanne)",
+        "data": {
+          "offset_calibration_entity_ids": "Offset calibration entities",
+          "opening_degree_entity_ids": "Opening degree entities",
+          "closing_degree_entity_ids": "Closing degree entities",
+          "proportional_function": "Algorithm",
+          "min_opening_degrees": "Min opening degrees"
+        },
+        "data_description": {
+          "offset_calibration_entity_ids": "The list of the 'offset calibration' entities. Set it if your TRV has the entity for better regulation. There should be one per underlying climate entities",
+          "opening_degree_entity_ids": "The list of the 'opening degree' entities. There should be one per underlying climate entities",
+          "closing_degree_entity_ids": "The list of the 'closing degree' entities. Set it if your TRV has the entity for better regulation. There should be one per underlying climate entities",
+          "proportional_function": "Algorithm to use (TPI is the only one for now)",
+          "min_opening_degrees": "Opening degree minimum value for each underlying device, comma separated. Default to 0. Example: 20, 25, 30"
+        }
       }
     },
     "error": {
@@ -465,7 +500,9 @@
       "unknown_entity": "Unknown entity id",
       "window_open_detection_method": "Only one window open detection method should be used. Use either window sensor or automatic detection through temperature threshold but not both",
       "no_central_config": "You cannot check 'use central configuration' because no central configuration was found. You need to create a Versatile Thermostat of type 'Central Configuration' to use it.",
-      "service_configuration_format": "The format of the service configuration is wrong"
+      "service_configuration_format": "The format of the service configuration is wrong",
+      "valve_regulation_nb_entities_incorrect": "The number of valve entities for valve regulation should be equal to the number of underlyings",
+      "min_opening_degrees_format": "A comma separated list of positive integer is expected. Example: 20, 25, 30"
     },
     "abort": {
       "already_configured": "Device is already configured"
@@ -487,7 +524,8 @@
         "auto_regulation_medium": "Medium",
         "auto_regulation_light": "Light",
         "auto_regulation_expert": "Expert",
-        "auto_regulation_none": "No auto-regulation"
+        "auto_regulation_none": "No auto-regulation",
+        "auto_regulation_valve": "Direct control of valve"
       }
     },
     "auto_fan_mode": {
@@ -514,6 +552,14 @@
         "comfort": "Comfort",
         "boost": "Boost"
       }
+    },
+    "auto_start_stop": {
+      "options": {
+        "auto_start_stop_none": "No auto start/stop",
+        "auto_start_stop_slow": "Slow detection",
+        "auto_start_stop_medium": "Medium detection",
+        "auto_start_stop_fast": "Fast detection"
+      }
     }
   },
   "entity": {
@@ -523,8 +569,9 @@
           "preset_mode": {
             "state": {
               "power": "Shedding",
-              "security": "Safety",
-              "none": "Manual"
+              "safety": "Safety",
+              "none": "Manual",
+              "frost": "Frost"
             }
           }
         }

custom_components/versatile_thermostat/switch.py

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

custom_components/versatile_thermostat/thermostat_climate.py

@@ -1,125 +1,144 @@
-# pylint: disable=line-too-long, too-many-lines
-""" A climate over switch classe """
+# pylint: disable=line-too-long, too-many-lines, abstract-method
+""" A climate over climate classe """
 import logging
 from datetime import timedelta, datetime
 
-from homeassistant.core import HomeAssistant, State, callback
+from homeassistant.const import STATE_ON, STATE_UNAVAILABLE, STATE_UNKNOWN
+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,
     ClimateEntityFeature,
 )
 
-from .commons import NowClass, round_to_nearest
+from .commons import round_to_nearest
 from .base_thermostat import BaseThermostat, ConfigData
 from .pi_algorithm import PITemperatureRegulator
 
-from .const import (
-    overrides,
-    DOMAIN,
-    CONF_CLIMATE,
-    CONF_CLIMATE_2,
-    CONF_CLIMATE_3,
-    CONF_CLIMATE_4,
-    CONF_AUTO_REGULATION_MODE,
-    CONF_AUTO_REGULATION_NONE,
-    CONF_AUTO_REGULATION_SLOW,
-    CONF_AUTO_REGULATION_LIGHT,
-    CONF_AUTO_REGULATION_MEDIUM,
-    CONF_AUTO_REGULATION_STRONG,
-    CONF_AUTO_REGULATION_EXPERT,
-    CONF_AUTO_REGULATION_DTEMP,
-    CONF_AUTO_REGULATION_PERIOD_MIN,
-    CONF_AUTO_REGULATION_USE_DEVICE_TEMP,
-    CONF_AUTO_FAN_MODE,
-    CONF_AUTO_FAN_NONE,
-    CONF_AUTO_FAN_LOW,
-    CONF_AUTO_FAN_MEDIUM,
-    CONF_AUTO_FAN_HIGH,
-    CONF_AUTO_FAN_TURBO,
-    RegulationParamSlow,
-    RegulationParamLight,
-    RegulationParamMedium,
-    RegulationParamStrong,
-    AUTO_FAN_DTEMP_THRESHOLD,
-    AUTO_FAN_DEACTIVATED_MODES,
-    UnknownEntity,
-)
+from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import
 
 from .vtherm_api import VersatileThermostatAPI
 from .underlyings import UnderlyingClimate
+from .feature_auto_start_stop_manager import FeatureAutoStartStopManager
 
 _LOGGER = logging.getLogger(__name__)
 
+HVAC_ACTION_ON = [  # pylint: disable=invalid-name
+    HVACAction.COOLING,
+    HVACAction.DRYING,
+    HVACAction.FAN,
+    HVACAction.HEATING,
+]
 
 class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
     """Representation of a base class for a Versatile Thermostat over a climate"""
 
-    _auto_regulation_mode: str | None = None
-    _regulation_algo = None
-    _regulated_target_temp: float | None = None
-    _auto_regulation_dtemp: float | None = None
-    _auto_regulation_period_min: int | None = None
-    _last_regulation_change: datetime | None = None
-    # The fan mode configured in configEntry
-    _auto_fan_mode: str | None = None
-    # The current fan mode (could be change by service call)
-    _current_auto_fan_mode: str | None = None
-    # The fan_mode name depending of the current_mode
-    _auto_activated_fan_mode: str | None = None
-    _auto_deactivated_fan_mode: str | None = None
-
-    _entity_component_unrecorded_attributes = (
-        BaseThermostat._entity_component_unrecorded_attributes.union(
-            frozenset(
-                {
-                    "is_over_climate",
-                    "start_hvac_action_date",
-                    "underlying_climate_0",
-                    "underlying_climate_1",
-                    "underlying_climate_2",
-                    "underlying_climate_3",
-                    "regulation_accumulated_error",
-                    "auto_regulation_mode",
-                    "auto_fan_mode",
-                    "current_auto_fan_mode",
-                    "auto_activated_fan_mode",
-                    "auto_deactivated_fan_mode",
-                    "auto_regulation_use_device_temp",
-                }
-            )
-        )
+    _entity_component_unrecorded_attributes = BaseThermostat._entity_component_unrecorded_attributes.union(  # pylint: disable=protected-access
+        frozenset(
+            {
+                "is_over_climate",
+                "start_hvac_action_date",
+                "underlying_entities",
+                "regulation_accumulated_error",
+                "auto_regulation_mode",
+                "auto_fan_mode",
+                "current_auto_fan_mode",
+                "auto_activated_fan_mode",
+                "auto_deactivated_fan_mode",
+                "auto_regulation_use_device_temp",
+                "follow_underlying_temp_change",
+            }
+        ).union(FeatureAutoStartStopManager.unrecorded_attributes)
     )
 
     def __init__(
         self, hass: HomeAssistant, unique_id: str, name: str, entry_infos: ConfigData
     ):
         """Initialize the thermostat over switch."""
+        self._auto_regulation_mode: str | None = None
+        self._regulation_algo = None
+        self._regulated_target_temp: float | None = None
+        self._auto_regulation_dtemp: float | None = None
+        self._auto_regulation_period_min: int | None = None
+        self._last_regulation_change: datetime | None = None
+        # The fan mode configured in configEntry
+        self._auto_fan_mode: str | None = None
+        # The current fan mode (could be change by service call)
+        self._current_auto_fan_mode: str | None = None
+        # The fan_mode name depending of the current_mode
+        self._auto_activated_fan_mode: str | None = None
+        self._auto_deactivated_fan_mode: str | None = None
+        self._follow_underlying_temp_change: bool = False
+        self._last_regulation_change = None  # NowClass.get_now(hass)
+
         # super.__init__ calls post_init at the end. So it must be called after regulation initialization
         super().__init__(hass, unique_id, name, entry_infos)
         self._regulated_target_temp = self.target_temperature
-        self._last_regulation_change = NowClass.get_now(hass)
+
+    @overrides
+    def post_init(self, config_entry: ConfigData):
+        """Initialize the Thermostat"""
+
+        self._auto_start_stop_manager: FeatureAutoStartStopManager = (
+            FeatureAutoStartStopManager(self, self._hass)
+        )
+
+        self.register_manager(self._auto_start_stop_manager)
+
+        super().post_init(config_entry)
+
+        for climate in config_entry.get(CONF_UNDERLYING_LIST):
+            under = UnderlyingClimate(
+                hass=self._hass,
+                thermostat=self,
+                climate_entity_id=climate,
+            )
+            self._underlyings.append(under)
+
+        self.choose_auto_regulation_mode(
+            config_entry.get(CONF_AUTO_REGULATION_MODE)
+            if config_entry.get(CONF_AUTO_REGULATION_MODE) is not None
+            else CONF_AUTO_REGULATION_NONE
+        )
+
+        self._auto_regulation_dtemp = (
+            config_entry.get(CONF_AUTO_REGULATION_DTEMP)
+            if config_entry.get(CONF_AUTO_REGULATION_DTEMP) is not None
+            else 0.5
+        )
+        self._auto_regulation_period_min = (
+            config_entry.get(CONF_AUTO_REGULATION_PERIOD_MIN)
+            if config_entry.get(CONF_AUTO_REGULATION_PERIOD_MIN) is not None
+            else 5
+        )
+
+        self._auto_fan_mode = (
+            config_entry.get(CONF_AUTO_FAN_MODE)
+            if config_entry.get(CONF_AUTO_FAN_MODE) is not None
+            else CONF_AUTO_FAN_NONE
+        )
+
+        self._auto_regulation_use_device_temp = config_entry.get(
+            CONF_AUTO_REGULATION_USE_DEVICE_TEMP, False
+        )
 
     @property
     def is_over_climate(self) -> bool:
         """True if the Thermostat is over_climate"""
         return True
 
-    @property
-    def hvac_action(self) -> HVACAction | None:
-        """Returns the current hvac_action by checking all hvac_action of the underlyings"""
-
+    def calculate_hvac_action(self, under_list: list) -> HVACAction | None:
+        """Calculate an hvac action based on the hvac_action of the list in argument"""
         # if one not IDLE or OFF -> return it
         # else if one IDLE -> IDLE
         # else OFF
         one_idle = False
-        for under in self._underlyings:
+        for under in under_list:
             if (action := under.hvac_action) not in [
                 HVACAction.IDLE,
                 HVACAction.OFF,
@@ -131,19 +150,35 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             return HVACAction.IDLE
         return HVACAction.OFF
 
+    @property
+    def hvac_action(self) -> HVACAction | None:
+        """Returns the current hvac_action by checking all hvac_action of the underlyings"""
+        return self.calculate_hvac_action(self._underlyings)
+
     @overrides
-    async def _async_internal_set_temperature(self, temperature: float):
+    async def change_target_temperature(self, temperature: float):
         """Set the target temperature and the target temperature of underlying climate if any"""
-        await super()._async_internal_set_temperature(temperature)
+        await super().change_target_temperature(temperature)
 
         self._regulation_algo.set_target_temp(self.target_temperature)
+        # Is necessary cause control_heating method will not force the update.
         await self._send_regulated_temperature(force=True)
 
     async def _send_regulated_temperature(self, force=False):
         """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(
@@ -152,16 +187,18 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             force,
         )
 
-        now: datetime = NowClass.get_now(self._hass)
-        period = float((now - self._last_regulation_change).total_seconds()) / 60.0
-        if not force and period < self._auto_regulation_period_min:
-            _LOGGER.info(
-                "%s - period (%.1f) min is < %.0f min -> forget the regulation send",
-                self,
-                period,
-                self._auto_regulation_period_min,
+        if self._last_regulation_change is not None:
+            period = (
+                float((self.now - self._last_regulation_change).total_seconds()) / 60.0
             )
-            return
+            if not force and period < self._auto_regulation_period_min:
+                _LOGGER.info(
+                    "%s - period (%.1f) min is < %.0f min -> forget the regulation send",
+                    self,
+                    period,
+                    self._auto_regulation_period_min,
+                )
+                return
 
         if not self._regulated_target_temp:
             self._regulated_target_temp = self.target_temperature
@@ -170,16 +207,17 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
 
         # 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 of regulation_step: %.2f ",
-                      self,
-                      regulation_step)
-        
-        new_regulated_temp = round_to_nearest(
-            self._regulation_algo.calculate_regulated_temperature(
-                self.current_temperature, self._cur_ext_temp
-            ),
-            regulation_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,27 +236,18 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             new_regulated_temp,
         )
 
-        self._last_regulation_change = now
+        self._last_regulation_change = self.now
         for under in self._underlyings:
             # issue 348 - use device temperature if configured as offset
             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)
-                and (
-                    (
-                        self.hvac_mode == HVACMode.COOL
-                        and self.target_temperature < self.current_temperature
-                    )
-                    or (
-                        self.hvac_mode == HVACMode.HEAT
-                        and self.target_temperature > self.current_temperature
-                    )
-                )
             ):
                 offset_temp = device_temp - self.current_temperature
 
@@ -283,53 +312,6 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             )
             await self.async_set_fan_mode(self._auto_deactivated_fan_mode)
 
-    @overrides
-    def post_init(self, config_entry: ConfigData):
-        """Initialize the Thermostat"""
-
-        super().post_init(config_entry)
-        for climate in [
-            CONF_CLIMATE,
-            CONF_CLIMATE_2,
-            CONF_CLIMATE_3,
-            CONF_CLIMATE_4,
-        ]:
-            if config_entry.get(climate):
-                self._underlyings.append(
-                    UnderlyingClimate(
-                        hass=self._hass,
-                        thermostat=self,
-                        climate_entity_id=config_entry.get(climate),
-                    )
-                )
-
-        self.choose_auto_regulation_mode(
-            config_entry.get(CONF_AUTO_REGULATION_MODE)
-            if config_entry.get(CONF_AUTO_REGULATION_MODE) is not None
-            else CONF_AUTO_REGULATION_NONE
-        )
-
-        self._auto_regulation_dtemp = (
-            config_entry.get(CONF_AUTO_REGULATION_DTEMP)
-            if config_entry.get(CONF_AUTO_REGULATION_DTEMP) is not None
-            else 0.5
-        )
-        self._auto_regulation_period_min = (
-            config_entry.get(CONF_AUTO_REGULATION_PERIOD_MIN)
-            if config_entry.get(CONF_AUTO_REGULATION_PERIOD_MIN) is not None
-            else 5
-        )
-
-        self._auto_fan_mode = (
-            config_entry.get(CONF_AUTO_FAN_MODE)
-            if config_entry.get(CONF_AUTO_FAN_MODE) is not None
-            else CONF_AUTO_FAN_NONE
-        )
-
-        self._auto_regulation_use_device_temp = config_entry.get(
-            CONF_AUTO_REGULATION_USE_DEVICE_TEMP, False
-        )
-
     def choose_auto_regulation_mode(self, auto_regulation_mode: str):
         """Choose or change the regulation mode"""
         self._auto_regulation_mode = auto_regulation_mode
@@ -500,18 +482,10 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
         self._attr_extra_state_attributes["start_hvac_action_date"] = (
             self._underlying_climate_start_hvac_action_date
         )
-        self._attr_extra_state_attributes["underlying_climate_0"] = self._underlyings[
-            0
-        ].entity_id
-        self._attr_extra_state_attributes["underlying_climate_1"] = (
-            self._underlyings[1].entity_id if len(self._underlyings) > 1 else None
-        )
-        self._attr_extra_state_attributes["underlying_climate_2"] = (
-            self._underlyings[2].entity_id if len(self._underlyings) > 2 else None
-        )
-        self._attr_extra_state_attributes["underlying_climate_3"] = (
-            self._underlyings[3].entity_id if len(self._underlyings) > 3 else None
-        )
+
+        self._attr_extra_state_attributes["underlying_entities"] = [
+            underlying.entity_id for underlying in self._underlyings
+        ]
 
         if self.is_regulated:
             self._attr_extra_state_attributes["is_regulated"] = self.is_regulated
@@ -542,7 +516,12 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             self.auto_regulation_use_device_temp
         )
 
+        self._attr_extra_state_attributes["follow_underlying_temp_change"] = (
+            self._follow_underlying_temp_change
+        )
+
         self.async_write_ha_state()
+
         _LOGGER.debug(
             "%s - Calling update_custom_attributes: %s",
             self,
@@ -570,7 +549,7 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             _LOGGER.info(
                 "%s - Force resent target temp cause we turn on some over climate"
             )
-            await self._async_internal_set_temperature(self._target_temp)
+            await self.change_target_temperature(self._target_temp)
 
     @overrides
     def incremente_energy(self):
@@ -579,18 +558,29 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
         if self.hvac_mode == HVACMode.OFF:
             return
 
+        device_power = self.power_manager.device_power
         added_energy = 0
         if (
             self.is_over_climate
             and self._underlying_climate_delta_t is not None
-            and self._device_power
+            and device_power
         ):
-            added_energy = self._device_power * self._underlying_climate_delta_t
+            added_energy = device_power * self._underlying_climate_delta_t
 
         if self._total_energy is None:
             self._total_energy = added_energy
+            _LOGGER.debug(
+                "%s - incremente_energy set energy is %s",
+                self,
+                self._total_energy,
+            )
         else:
             self._total_energy += added_energy
+            _LOGGER.debug(
+                "%s - incremente_energy incremented energy is %s",
+                self,
+                self._total_energy,
+            )
 
         _LOGGER.debug(
             "%s - added energy is %.3f . Total energy is now: %.3f",
@@ -600,7 +590,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
@@ -613,7 +603,8 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
         async def end_climate_changed(changes: bool):
             """To end the event management"""
             if changes:
-                self.async_write_ha_state()
+                # already done by update_custom_attribute
+                # self.async_write_ha_state()
                 self.update_custom_attributes()
                 await self.async_control_heating()
 
@@ -622,10 +613,29 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
         if not new_state:
             return
 
+        # Find the underlying which have change
+        under: UnderlyingClimate = self.find_underlying_by_entity_id(new_state.entity_id)
+
+        if not under:
+            _LOGGER.warning(
+                "We have a receive an event from entity %s which is NOT one of our underlying entities. This is not normal and should be reported to the developper of the integration"
+            )
+            return
+
         changes = False
         new_hvac_mode = new_state.state
 
         old_state = event.data.get("old_state")
+
+        # Issue #829 - refresh underlying command if it comes back to life
+        if old_state is not None and new_state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN) and old_state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
+            _LOGGER.warning("%s - underlying %s come back to life. New state=%s, old_state=%s. Will refresh its status", self, under.entity_id, new_state.state, old_state.state)
+            # Force hvac_mode and target temperature
+            await under.set_hvac_mode(self.hvac_mode)
+            await self._send_regulated_temperature(force=True)
+
+            return
+
         old_hvac_action = (
             old_state.attributes.get("hvac_action")
             if old_state and old_state.attributes
@@ -656,26 +666,76 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             new_state.last_updated if new_state and new_state.last_updated else None
         )
 
+        new_target_temp = (
+            new_state.attributes.get("temperature")
+            if new_state and new_state.attributes
+            else None
+        )
+
+        last_sent_temperature = under.last_sent_temperature or 0
+        under_temp_diff = (
+            (new_target_temp - last_sent_temperature) if new_target_temp else 0
+        )
+
+        step = self.target_temperature_step or 1
+        if -step < under_temp_diff < step:
+            under_temp_diff = 0
+
         # Issue 99 - some AC turn hvac_mode=cool and hvac_action=idle when sending a HVACMode_OFF command
         # Issue 114 - Remove this because hvac_mode is now managed by local _hvac_mode and use idle action as is
         # if self._hvac_mode == HVACMode.OFF and new_hvac_action == HVACAction.IDLE:
         #    _LOGGER.debug("The underlying switch to idle instead of OFF. We will consider it as OFF")
         #    new_hvac_mode = HVACMode.OFF
 
+        # Forget event when the event holds no real changes
+        if (
+            new_hvac_mode == self._hvac_mode
+            and new_hvac_action == old_hvac_action
+            and under_temp_diff == 0
+            and (new_fan_mode is None or new_fan_mode == self._attr_fan_mode)
+        ):
+            _LOGGER.debug(
+                "%s - a underlying state change event is received but no real change have been found. Forget the event",
+                self,
+            )
+            return
+
+        # Ignore new target temperature when out of range
+        if (
+            not new_target_temp is None
+            and not self._attr_min_temp is None
+            and not self._attr_max_temp is None
+            and not (self._attr_min_temp <= new_target_temp <= self._attr_max_temp)
+        ):
+            _LOGGER.debug(
+                "%s - underlying sent a target temperature (%s) which is out of configured min/max range (%s / %s). The value will be ignored",
+                self,
+                new_target_temp,
+                self._attr_min_temp,
+                self._attr_max_temp,
+            )
+            new_target_temp = None
+            under_temp_diff = 0
+
+        # A real changes have to be managed
         _LOGGER.info(
-            "%s - Underlying climate %s changed. Event.new_hvac_mode is %s, current_hvac_mode=%s, new_hvac_action=%s, old_hvac_action=%s",
+            "%s - Underlying climate %s have changed. new_hvac_mode is %s (vs %s), new_hvac_action=%s (vs %s), new_target_temp=%s (vs %s), new_fan_mode=%s (vs %s)",
             self,
-            new_state.entity_id,
+            under.entity_id,
             new_hvac_mode,
             self._hvac_mode,
             new_hvac_action,
             old_hvac_action,
+            new_target_temp,
+            self.target_temperature,
+            new_fan_mode,
+            self._attr_fan_mode,
         )
 
         _LOGGER.debug(
             "%s - last_change_time=%s old_state_date_changed=%s old_state_date_updated=%s new_state_date_changed=%s new_state_date_updated=%s",
             self,
-            self._last_change_time,
+            self._last_change_time_from_vtherm,
             old_state_date_changed,
             old_state_date_updated,
             new_state_date_changed,
@@ -683,12 +743,6 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
         )
 
         # Interpretation of hvac action
-        HVAC_ACTION_ON = [  # pylint: disable=invalid-name
-            HVACAction.COOLING,
-            HVACAction.DRYING,
-            HVACAction.FAN,
-            HVACAction.HEATING,
-        ]
         if old_hvac_action not in HVAC_ACTION_ON and new_hvac_action in HVAC_ACTION_ON:
             self._underlying_climate_start_hvac_action_date = (
                 self.get_last_updated_date_or_now(new_state)
@@ -721,10 +775,13 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             )
             changes = True
 
+        # Filter new state when received just after a change from VTherm
         # Issue #120 - Some TRV are changing target temperature a very long time (6 sec) after the change.
         # In that case a loop is possible if a user change multiple times during this 6 sec.
-        if new_state_date_updated and self._last_change_time:
-            delta = (new_state_date_updated - self._last_change_time).total_seconds()
+        if new_state_date_updated and self._last_change_time_from_vtherm:
+            delta = (
+                new_state_date_updated - self._last_change_time_from_vtherm
+            ).total_seconds()
             if delta < 10:
                 _LOGGER.info(
                     "%s - underlying event is received less than 10 sec after command. Forget it to avoid loop",
@@ -733,6 +790,7 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
                 await end_climate_changed(changes)
                 return
 
+        # Update all underlyings hvac_mode state if it has change
         if (
             new_hvac_mode
             in [
@@ -747,7 +805,6 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             ]
             and self._hvac_mode != new_hvac_mode
         ):
-            # Update all underlyings state
             # Issue #334 - if all underlyings are not aligned with the same hvac_mode don't change the underlying and wait they are aligned
             if self.is_over_climate:
                 for under in self._underlyings:
@@ -778,27 +835,34 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             self._attr_fan_mode = new_fan_mode
             changes = True
 
-        if not changes:
-            # try to manage new target temperature set if state
+        # try to manage new target temperature set if state if no other changes have been found
+        # and if a target temperature have already been sent
+        if (
+            self._follow_underlying_temp_change
+            and not changes
+            and under.last_sent_temperature is not None
+        ):
             _LOGGER.debug(
-                "Do temperature check. temperature is %s, new_state.attributes is %s",
-                self.target_temperature,
-                new_state.attributes,
+                "%s - Do temperature check. under.last_sent_temperature is %s, new_target_temp is %s",
+                self,
+                under.last_sent_temperature,
+                new_target_temp,
             )
-            if (
-                # we do not change target temperature on regulated VTherm
-                not self.is_regulated
-                and new_state.attributes
-                and (new_target_temp := new_state.attributes.get("temperature"))
-                and new_target_temp != self.target_temperature
-            ):
+            # if the underlying have change its target temperature
+            if under_temp_diff != 0:
                 _LOGGER.info(
-                    "%s - Target temp in underlying have change to %s",
+                    "%s - Target temp in underlying have change to %s (vs %s)",
                     self,
                     new_target_temp,
+                    under.last_sent_temperature,
                 )
                 await self.async_set_temperature(temperature=new_target_temp)
                 changes = True
+            else:
+                _LOGGER.debug(
+                    "%s - Forget the eventual underlying temperature change there is no real change",
+                    self,
+                )
 
         await end_climate_changed(changes)
 
@@ -807,6 +871,14 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
         """The main function used to run the calculation at each cycle"""
         ret = await super().async_control_heating(force, _)
 
+        # Check if we need to auto start/stop the Vtherm
+        continu = await self.auto_start_stop_manager.refresh_state()
+        if not continu:
+            return ret
+
+        # Continue the normal async_control_heating
+
+        # Send the regulated temperature to the underlyings
         await self._send_regulated_temperature()
 
         if self._auto_fan_mode and self._auto_fan_mode != CONF_AUTO_FAN_NONE:
@@ -814,6 +886,11 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
 
         return ret
 
+    def set_follow_underlying_temp_change(self, follow: bool):
+        """Set the flaf follow the underlying temperature changes"""
+        self._follow_underlying_temp_change = follow
+        self.update_custom_attributes()
+
     @property
     def auto_regulation_mode(self) -> str | None:
         """Get the regulation mode"""
@@ -910,15 +987,6 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
 
         return self._support_flags
 
-    # We keep the step configured for the VTherm and not the step of the underlying
-    # @property
-    # def target_temperature_step(self) -> float | None:
-    #     """Return the supported step of target temperature."""
-    #     if self.underlying_entity(0):
-    #         return self.underlying_entity(0).target_temperature_step
-    #
-    #     return None
-
     @property
     def target_temperature_high(self) -> float | None:
         """Return the highbound target temperature we try to reach.
@@ -941,6 +1009,14 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
 
         return None
 
+    @property
+    def current_humidity(self) -> float | None:
+        """Return the humidity."""
+        if self.underlying_entity(0):
+            return self.underlying_entity(0).current_humidity
+
+        return None
+
     @property
     def is_aux_heat(self) -> bool | None:
         """Return true if aux heater.
@@ -960,6 +1036,16 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
                 return False
         return True
 
+    @property
+    def follow_underlying_temp_change(self) -> bool:
+        """Get the follow underlying temp change flag"""
+        return self._follow_underlying_temp_change
+
+    @property
+    def auto_start_stop_manager(self) -> FeatureAutoStartStopManager:
+        """Return the auto-start-stop Manager"""
+        return self._auto_start_stop_manager
+
     @overrides
     def init_underlyings(self):
         """Init the underlyings if not already done"""
@@ -1018,7 +1104,7 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
     @overrides
     async def async_set_humidity(self, humidity: int):
         """Set new target humidity."""
-        _LOGGER.info("%s - Set fan mode: %s", self, humidity)
+        _LOGGER.info("%s - Set humidity: %s", self, humidity)
         if humidity is None:
             return
         for under in self._underlyings:
@@ -1029,7 +1115,7 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
     @overrides
     async def async_set_swing_mode(self, swing_mode):
         """Set new target swing operation."""
-        _LOGGER.info("%s - Set fan mode: %s", self, swing_mode)
+        _LOGGER.info("%s - Set swing mode: %s", self, swing_mode)
         if swing_mode is None:
             return
         for under in self._underlyings:
@@ -1062,6 +1148,13 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             self.choose_auto_regulation_mode(CONF_AUTO_REGULATION_SLOW)
         elif auto_regulation_mode == "Expert":
             self.choose_auto_regulation_mode(CONF_AUTO_REGULATION_EXPERT)
+        else:
+            _LOGGER.warning(
+                "%s - auto_regulation_mode %s is not supported",
+                self,
+                auto_regulation_mode,
+            )
+            return
 
         await self._send_regulated_temperature()
         self.update_custom_attributes()
@@ -1091,3 +1184,29 @@ class ThermostatOverClimate(BaseThermostat[UnderlyingClimate]):
             self.choose_auto_fan_mode(CONF_AUTO_FAN_TURBO)
 
         self.update_custom_attributes()
+
+    @overrides
+    async def async_turn_off(self) -> None:
+        # if window is open, don't overwrite the saved_hvac_mode
+        if self.window_state != STATE_ON:
+            self.save_hvac_mode()
+        await self.async_set_hvac_mode(HVACMode.OFF)
+
+    @overrides
+    async def async_turn_on(self) -> None:
+
+        # don't turn_on if window is open
+        if self.window_state == STATE_ON:
+            _LOGGER.info(
+                "%s - refuse to turn on because window is open. We keep the save_hvac_mode",
+                self,
+            )
+            return
+
+        if self._saved_hvac_mode is not None:  # pylint: disable=protected-access
+            await self.restore_hvac_mode(True)
+        else:
+            if self._ac_mode:
+                await self.async_set_hvac_mode(HVACMode.COOL)
+            else:
+                await self.async_set_hvac_mode(HVACMode.HEAT)

custom_components/versatile_thermostat/thermostat_climate_valve.py

@@ -0,0 +1,311 @@
+# pylint: disable=line-too-long, too-many-lines, abstract-method
+""" A climate with a direct valve regulation class """
+
+import logging
+from datetime import datetime
+
+from homeassistant.core import HomeAssistant
+from homeassistant.components.climate import HVACMode, HVACAction
+
+from .underlyings import UnderlyingValveRegulation
+
+# from .commons import NowClass, round_to_nearest
+from .base_thermostat import ConfigData
+from .thermostat_climate import ThermostatOverClimate
+from .prop_algorithm import PropAlgorithm
+
+from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import
+
+# from .vtherm_api import VersatileThermostatAPI
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ThermostatOverClimateValve(ThermostatOverClimate):
+    """This class represent a VTherm over a climate with a direct valve regulation"""
+
+    _entity_component_unrecorded_attributes = ThermostatOverClimate._entity_component_unrecorded_attributes.union(  # pylint: disable=protected-access
+        frozenset(
+            {
+                "is_over_climate",
+                "have_valve_regulation",
+                "underlying_entities",
+                "on_time_sec",
+                "off_time_sec",
+                "cycle_min",
+                "function",
+                "tpi_coef_int",
+                "tpi_coef_ext",
+                "power_percent",
+                "min_opening_degrees",
+            }
+        )
+    )
+
+    def __init__(
+        self, hass: HomeAssistant, unique_id: str, name: str, entry_infos: ConfigData
+    ):
+        """Initialize the ThermostatOverClimateValve class"""
+        _LOGGER.debug("%s - creating a ThermostatOverClimateValve VTherm", name)
+        self._underlyings_valve_regulation: list[UnderlyingValveRegulation] = []
+        self._valve_open_percent: int | None = None
+        self._last_calculation_timestamp: datetime | None = None
+        self._auto_regulation_dpercent: float | None = None
+        self._auto_regulation_period_min: int | None = None
+        self._min_opening_degress: list[int] = []
+
+        super().__init__(hass, unique_id, name, entry_infos)
+
+    @overrides
+    def post_init(self, config_entry: ConfigData):
+        """Initialize the Thermostat and underlyings
+        Beware that the underlyings list contains the climate which represent the TRV
+        but also the UnderlyingValveRegulation which reprensent the valve"""
+
+        super().post_init(config_entry)
+
+        self._auto_regulation_dpercent = (
+            config_entry.get(CONF_AUTO_REGULATION_DTEMP)
+            if config_entry.get(CONF_AUTO_REGULATION_DTEMP) is not None
+            else 0.0
+        )
+        self._auto_regulation_period_min = (
+            config_entry.get(CONF_AUTO_REGULATION_PERIOD_MIN)
+            if config_entry.get(CONF_AUTO_REGULATION_PERIOD_MIN) is not None
+            else 0
+        )
+
+        # Initialization of the TPI algo
+        self._prop_algorithm = PropAlgorithm(
+            self._proportional_function,
+            self._tpi_coef_int,
+            self._tpi_coef_ext,
+            self._cycle_min,
+            self._minimal_activation_delay,
+            self.name,
+        )
+
+        offset_list = config_entry.get(CONF_OFFSET_CALIBRATION_LIST, [])
+        opening_list = config_entry.get(CONF_OPENING_DEGREE_LIST)
+        closing_list = config_entry.get(CONF_CLOSING_DEGREE_LIST, [])
+
+        self._min_opening_degrees = config_entry.get(CONF_MIN_OPENING_DEGREES, None)
+        min_opening_degrees_list = []
+        if self._min_opening_degrees:
+            min_opening_degrees_list = [
+                int(x.strip()) for x in self._min_opening_degrees.split(",")
+            ]
+
+        for idx, _ in enumerate(config_entry.get(CONF_UNDERLYING_LIST)):
+            offset = offset_list[idx] if idx < len(offset_list) else None
+            # number of opening should equal number of underlying
+            opening = opening_list[idx]
+            closing = closing_list[idx] if idx < len(closing_list) else None
+            under = UnderlyingValveRegulation(
+                hass=self._hass,
+                thermostat=self,
+                offset_calibration_entity_id=offset,
+                opening_degree_entity_id=opening,
+                closing_degree_entity_id=closing,
+                climate_underlying=self._underlyings[idx],
+                min_opening_degree=(
+                    min_opening_degrees_list[idx]
+                    if idx < len(min_opening_degrees_list)
+                    else 0
+                ),
+            )
+            self._underlyings_valve_regulation.append(under)
+
+    @overrides
+    def update_custom_attributes(self):
+        """Custom attributes"""
+        super().update_custom_attributes()
+
+        self._attr_extra_state_attributes["have_valve_regulation"] = (
+            self.have_valve_regulation
+        )
+
+        self._attr_extra_state_attributes["underlyings_valve_regulation"] = [
+            underlying.valve_entity_ids
+            for underlying in self._underlyings_valve_regulation
+        ]
+
+        self._attr_extra_state_attributes["on_percent"] = (
+            self._prop_algorithm.on_percent
+        )
+        self._attr_extra_state_attributes["power_percent"] = self.power_percent
+        self._attr_extra_state_attributes["on_time_sec"] = (
+            self._prop_algorithm.on_time_sec
+        )
+        self._attr_extra_state_attributes["off_time_sec"] = (
+            self._prop_algorithm.off_time_sec
+        )
+        self._attr_extra_state_attributes["cycle_min"] = self._cycle_min
+        self._attr_extra_state_attributes["function"] = self._proportional_function
+        self._attr_extra_state_attributes["tpi_coef_int"] = self._tpi_coef_int
+        self._attr_extra_state_attributes["tpi_coef_ext"] = self._tpi_coef_ext
+
+        self._attr_extra_state_attributes["min_opening_degrees"] = (
+            self._min_opening_degrees
+        )
+
+        self._attr_extra_state_attributes["valve_open_percent"] = (
+            self.valve_open_percent
+        )
+
+        self._attr_extra_state_attributes["auto_regulation_dpercent"] = (
+            self._auto_regulation_dpercent
+        )
+        self._attr_extra_state_attributes["auto_regulation_period_min"] = (
+            self._auto_regulation_period_min
+        )
+        self._attr_extra_state_attributes["last_calculation_timestamp"] = (
+            self._last_calculation_timestamp.astimezone(self._current_tz).isoformat()
+            if self._last_calculation_timestamp
+            else None
+        )
+
+        self.async_write_ha_state()
+        _LOGGER.debug(
+            "%s - Calling update_custom_attributes: %s",
+            self,
+            self._attr_extra_state_attributes,
+        )
+
+    @overrides
+    def recalculate(self):
+        """A utility function to force the calculation of a the algo and
+        update the custom attributes and write the state
+        """
+        _LOGGER.debug("%s - recalculate the open percent", self)
+
+        # TODO this is exactly the same method as the thermostat_valve recalculate. Put that in common
+
+        # For testing purpose. Should call _set_now() before
+        now = self.now
+
+        if self._last_calculation_timestamp is not None:
+            period = (now - self._last_calculation_timestamp).total_seconds() / 60
+            if period < self._auto_regulation_period_min:
+                _LOGGER.info(
+                    "%s - do not calculate TPI because regulation_period (%d) is not exceeded",
+                    self,
+                    period,
+                )
+                return
+
+        self._prop_algorithm.calculate(
+            self._target_temp,
+            self._cur_temp,
+            self._cur_ext_temp,
+            self._hvac_mode or HVACMode.OFF,
+        )
+
+        new_valve_percent = round(
+            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 self._valve_open_percent is not None
+            else 0
+        )
+        if (
+            self._last_calculation_timestamp is not None
+            and 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",
+                self,
+                dpercent,
+            )
+
+            return
+
+        if (
+            self._last_calculation_timestamp is not None
+            and self._valve_open_percent == new_valve_percent
+        ):
+            _LOGGER.debug("%s - no change in valve_open_percent.", self)
+            return
+
+        self._valve_open_percent = new_valve_percent
+
+        self._last_calculation_timestamp = now
+
+        super().recalculate()
+
+    async def _send_regulated_temperature(self, force=False):
+        """Sends the regulated temperature to all underlying"""
+        if self.target_temperature is None:
+            return
+
+        for under in self._underlyings:
+            if self.target_temperature != under.last_sent_temperature:
+                await under.set_temperature(
+                    self.target_temperature,
+                    self._attr_max_temp,
+                    self._attr_min_temp,
+                )
+
+        self._last_regulation_change = self.now
+        self.reset_last_change_time_from_vtherm()
+
+        _LOGGER.debug(
+            "%s - last_regulation_change is now: %s and last_change_from_vtherm is now: %s", self, self._last_regulation_change, self._last_change_time_from_vtherm
+        )  # pylint: disable=protected-access
+
+        for under in self._underlyings_valve_regulation:
+            await under.set_valve_open_percent()
+
+    @property
+    def have_valve_regulation(self) -> bool:
+        """True if the Thermostat is regulated by valve"""
+        return True
+
+    @property
+    def valve_open_percent(self) -> int:
+        """Gives the percentage of valve needed"""
+        if self._hvac_mode == HVACMode.OFF or self._valve_open_percent is None:
+            return 0
+        else:
+            return self._valve_open_percent
+
+    @property
+    def hvac_action(self) -> HVACAction | None:
+        """Returns the current hvac_action by checking all hvac_action of the _underlyings_valve_regulation"""
+
+        return self.calculate_hvac_action(self._underlyings_valve_regulation)
+
+    @property
+    def is_device_active(self) -> bool:
+        """A hack to overrides the state from underlyings"""
+        return self.valve_open_percent > 0
+
+    @property
+    def device_actives(self) -> int:
+        """Calculate the number of active devices"""
+        if self.is_device_active:
+            return [
+                under.opening_degree_entity_id
+                for under in self._underlyings_valve_regulation
+            ]
+        else:
+            return []
+
+    @property
+    def activable_underlying_entities(self) -> list | None:
+        """Returns the activable underlying entities for controling the central boiler"""
+        return self._underlyings_valve_regulation
+
+    @overrides
+    async def service_set_auto_regulation_mode(self, auto_regulation_mode: str):
+        """This should not be possible in valve regulation mode"""
+        return

custom_components/versatile_thermostat/thermostat_switch.py

@@ -1,22 +1,21 @@
-# pylint: disable=line-too-long
+# pylint: disable=line-too-long, abstract-method
 
 """ 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.core import HomeAssistant
 from homeassistant.components.climate import HVACMode
 
 from .const import (
-    CONF_HEATER,
-    CONF_HEATER_2,
-    CONF_HEATER_3,
-    CONF_HEATER_4,
+    CONF_UNDERLYING_LIST,
     CONF_HEATER_KEEP_ALIVE,
     CONF_INVERSE_SWITCH,
+    CONF_VSWITCH_ON_CMD_LIST,
+    CONF_VSWITCH_OFF_CMD_LIST,
     overrides,
 )
 
@@ -26,37 +25,35 @@ from .prop_algorithm import PropAlgorithm
 
 _LOGGER = logging.getLogger(__name__)
 
-
 class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
     """Representation of a base class for a Versatile Thermostat over a switch."""
 
-    _entity_component_unrecorded_attributes = (
-        BaseThermostat._entity_component_unrecorded_attributes.union(
-            frozenset(
-                {
-                    "is_over_switch",
-                    "is_inversed",
-                    "underlying_switch_0",
-                    "underlying_switch_1",
-                    "underlying_switch_2",
-                    "underlying_switch_3",
-                    "on_time_sec",
-                    "off_time_sec",
-                    "cycle_min",
-                    "function",
-                    "tpi_coef_int",
-                    "tpi_coef_ext",
-                    "power_percent",
-                }
-            )
+    _entity_component_unrecorded_attributes = BaseThermostat._entity_component_unrecorded_attributes.union(  # pylint: disable=protected-access
+        frozenset(
+            {
+                "is_over_switch",
+                "is_inversed",
+                "underlying_entities",
+                "on_time_sec",
+                "off_time_sec",
+                "cycle_min",
+                "function",
+                "tpi_coef_int",
+                "tpi_coef_ext",
+                "power_percent",
+                "calculated_on_percent",
+                "vswitch_on_commands",
+                "vswitch_off_commands",
+            }
         )
     )
 
-    # useless for now
-    # def __init__(self, hass: HomeAssistant, unique_id, name, config_entry) -> None:
-    #    """Initialize the thermostat over switch."""
-    #    super().__init__(hass, unique_id, name, config_entry)
-    _is_inversed: bool | None = None
+    def __init__(self, hass: HomeAssistant, unique_id, name, config_entry) -> None:
+        """Initialize the thermostat over switch."""
+        self._is_inversed: bool | None = None
+        self._lst_vswitch_on: list[str] = []
+        self._lst_vswitch_off: list[str] = []
+        super().__init__(hass, unique_id, name, config_entry)
 
     @property
     def is_over_switch(self) -> bool:
@@ -68,14 +65,6 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
         """True if the switch is inversed (for pilot wire and diode)"""
         return self._is_inversed is True
 
-    @property
-    def power_percent(self) -> float | None:
-        """Get the current on_percent value"""
-        if self._prop_algorithm:
-            return round(self._prop_algorithm.on_percent * 100, 0)
-        else:
-            return None
-
     @overrides
     def post_init(self, config_entry: ConfigData):
         """Initialize the Thermostat"""
@@ -89,18 +78,19 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
             self._cycle_min,
             self._minimal_activation_delay,
             self.name,
+            max_on_percent=self._max_on_percent,
         )
 
-        lst_switches = [config_entry.get(CONF_HEATER)]
-        if config_entry.get(CONF_HEATER_2):
-            lst_switches.append(config_entry.get(CONF_HEATER_2))
-        if config_entry.get(CONF_HEATER_3):
-            lst_switches.append(config_entry.get(CONF_HEATER_3))
-        if config_entry.get(CONF_HEATER_4):
-            lst_switches.append(config_entry.get(CONF_HEATER_4))
+        self._is_inversed = config_entry.get(CONF_INVERSE_SWITCH) is True
+
+        lst_switches = config_entry.get(CONF_UNDERLYING_LIST)
+        self._lst_vswitch_on = config_entry.get(CONF_VSWITCH_ON_CMD_LIST, [])
+        self._lst_vswitch_off = config_entry.get(CONF_VSWITCH_OFF_CMD_LIST, [])
 
         delta_cycle = self._cycle_min * 60 / len(lst_switches)
         for idx, switch in enumerate(lst_switches):
+            vswitch_on = self._lst_vswitch_on[idx] if idx < len(self._lst_vswitch_on) else None
+            vswitch_off = self._lst_vswitch_off[idx] if idx < len(self._lst_vswitch_off) else None
             self._underlyings.append(
                 UnderlyingSwitch(
                     hass=self._hass,
@@ -108,10 +98,11 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
                     switch_entity_id=switch,
                     initial_delay_sec=idx * delta_cycle,
                     keep_alive_sec=config_entry.get(CONF_HEATER_KEEP_ALIVE, 0),
+                    vswitch_on=vswitch_on,
+                    vswitch_off=vswitch_off,
                 )
             )
 
-        self._is_inversed = config_entry.get(CONF_INVERSE_SWITCH) is True
         self._should_relaunch_control_heating = False
 
     @overrides
@@ -141,16 +132,10 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
         self._attr_extra_state_attributes["is_over_switch"] = self.is_over_switch
         self._attr_extra_state_attributes["is_inversed"] = self.is_inversed
         self._attr_extra_state_attributes["keep_alive_sec"] = under0.keep_alive_sec
-        self._attr_extra_state_attributes["underlying_switch_0"] = under0.entity_id
-        self._attr_extra_state_attributes["underlying_switch_1"] = (
-            self._underlyings[1].entity_id if len(self._underlyings) > 1 else None
-        )
-        self._attr_extra_state_attributes["underlying_switch_2"] = (
-            self._underlyings[2].entity_id if len(self._underlyings) > 2 else None
-        )
-        self._attr_extra_state_attributes["underlying_switch_3"] = (
-            self._underlyings[3].entity_id if len(self._underlyings) > 3 else None
-        )
+
+        self._attr_extra_state_attributes["underlying_entities"] = [
+           underlying.entity_id for underlying in self._underlyings
+        ]
 
         self._attr_extra_state_attributes[
             "on_percent"
@@ -166,6 +151,12 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
         self._attr_extra_state_attributes["function"] = self._proportional_function
         self._attr_extra_state_attributes["tpi_coef_int"] = self._tpi_coef_int
         self._attr_extra_state_attributes["tpi_coef_ext"] = self._tpi_coef_ext
+        self._attr_extra_state_attributes[
+            "calculated_on_percent"
+        ] = self._prop_algorithm.calculated_on_percent
+
+        self._attr_extra_state_attributes["vswitch_on_commands"] = self._lst_vswitch_on
+        self._attr_extra_state_attributes["vswitch_off_commands"] = self._lst_vswitch_off
 
         self.async_write_ha_state()
         _LOGGER.debug(
@@ -187,7 +178,8 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
             self._hvac_mode or HVACMode.OFF,
         )
         self.update_custom_attributes()
-        self.async_write_ha_state()
+        # already done bu update_custom_attributes
+        # self.async_write_ha_state()
 
     @overrides
     def incremente_energy(self):
@@ -196,13 +188,27 @@ class ThermostatOverSwitch(BaseThermostat[UnderlyingSwitch]):
             return
 
         added_energy = 0
-        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
+        if not self.is_over_climate and self.power_manager.mean_cycle_power is not None:
+            added_energy = (
+                self.power_manager.mean_cycle_power * float(self._cycle_min) / 60.0
+            )
 
         if self._total_energy is None:
             self._total_energy = added_energy
+            _LOGGER.debug(
+                "%s - incremente_energy set energy is %s",
+                self,
+                self._total_energy,
+            )
         else:
             self._total_energy += added_energy
+            _LOGGER.debug(
+                "%s - incremente_energy increment energy is %s",
+                self,
+                self._total_energy,
+            )
+
+        self.update_custom_attributes()
 
         _LOGGER.debug(
             "%s - added energy is %.3f . Total energy is now: %.3f",
@@ -212,7 +218,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

@@ -1,4 +1,4 @@
-# pylint: disable=line-too-long
+# pylint: disable=line-too-long, abstract-method
 """ A climate over switch classe """
 import logging
 from datetime import timedelta, datetime
@@ -8,18 +8,14 @@ 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
 from .prop_algorithm import PropAlgorithm
 
 from .const import (
-    CONF_VALVE,
-    CONF_VALVE_2,
-    CONF_VALVE_3,
-    CONF_VALVE_4,
+    CONF_UNDERLYING_LIST,
     # This is not really self-regulation but regulation here
     CONF_AUTO_REGULATION_DTEMP,
     CONF_AUTO_REGULATION_PERIOD_MIN,
@@ -30,30 +26,25 @@ from .underlyings import UnderlyingValve
 
 _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_entities",
+                "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",
+                "calculated_on_percent",
+            }
         )
     )
 
@@ -106,15 +97,10 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a
             self._cycle_min,
             self._minimal_activation_delay,
             self.name,
+            max_on_percent=self._max_on_percent,
         )
 
-        lst_valves = [config_entry.get(CONF_VALVE)]
-        if config_entry.get(CONF_VALVE_2):
-            lst_valves.append(config_entry.get(CONF_VALVE_2))
-        if config_entry.get(CONF_VALVE_3):
-            lst_valves.append(config_entry.get(CONF_VALVE_3))
-        if config_entry.get(CONF_VALVE_4):
-            lst_valves.append(config_entry.get(CONF_VALVE_4))
+        lst_valves = config_entry.get(CONF_UNDERLYING_LIST)
 
         for _, valve in enumerate(lst_valves):
             self._underlyings.append(
@@ -149,7 +135,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.
         """
@@ -166,18 +152,10 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a
             "valve_open_percent"
         ] = self.valve_open_percent
         self._attr_extra_state_attributes["is_over_valve"] = self.is_over_valve
-        self._attr_extra_state_attributes["underlying_valve_0"] = self._underlyings[
-            0
-        ].entity_id
-        self._attr_extra_state_attributes["underlying_valve_1"] = (
-            self._underlyings[1].entity_id if len(self._underlyings) > 1 else None
-        )
-        self._attr_extra_state_attributes["underlying_valve_2"] = (
-            self._underlyings[2].entity_id if len(self._underlyings) > 2 else None
-        )
-        self._attr_extra_state_attributes["underlying_valve_3"] = (
-            self._underlyings[3].entity_id if len(self._underlyings) > 3 else None
-        )
+
+        self._attr_extra_state_attributes["underlying_entities"] = [
+           underlying.entity_id for underlying in self._underlyings
+        ]
 
         self._attr_extra_state_attributes[
             "on_percent"
@@ -203,6 +181,9 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a
             if self._last_calculation_timestamp
             else None
         )
+        self._attr_extra_state_attributes[
+            "calculated_on_percent"
+        ] = self._prop_algorithm.calculated_on_percent
 
         self.async_write_ha_state()
         _LOGGER.debug(
@@ -242,10 +223,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",
@@ -261,13 +248,15 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a
 
         self._valve_open_percent = new_valve_percent
 
-        for under in self._underlyings:
-            under.set_valve_open_percent()
+        # is one in start_cycle now
+        # for under in self._underlyings:
+        #    under.set_valve_open_percent()
 
         self._last_calculation_timestamp = now
 
         self.update_custom_attributes()
-        self.async_write_ha_state()
+        # already done in update_custom_attributes
+        # self.async_write_ha_state()
 
     @overrides
     def incremente_energy(self):
@@ -276,13 +265,27 @@ class ThermostatOverValve(BaseThermostat[UnderlyingValve]):  # pylint: disable=a
             return
 
         added_energy = 0
-        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
+        if not self.is_over_climate and self.power_manager.mean_cycle_power is not None:
+            added_energy = (
+                self.power_manager.mean_cycle_power * float(self._cycle_min) / 60.0
+            )
 
         if self._total_energy is None:
             self._total_energy = added_energy
+            _LOGGER.debug(
+                "%s - incremente_energy set energy is %s",
+                self,
+                self._total_energy,
+            )
         else:
             self._total_energy += added_energy
+            _LOGGER.debug(
+                "%s - get_my_previous_state increment energy is %s",
+                self,
+                self._total_energy,
+            )
+
+        self.update_custom_attributes()
 
         _LOGGER.debug(
             "%s - added energy is %.3f . Total energy is now: %.3f",

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": {
@@ -152,15 +152,15 @@
         "description": "Διαμόρφωση των προχωρημένων παραμέτρων. Αφήστε τις προεπιλεγμένες τιμές αν δεν γνωρίζετε τι κάνετε.\nΑυτές οι παράμετροι μπορούν να οδηγήσουν σε πολύ κακή ρύθμιση θερμοκρασίας ή ενέργειας.",
         "data": {
           "minimal_activation_delay": "Ελάχιστη καθυστέρηση ενεργοποίησης",
-          "security_delay_min": "Καθυστέρηση ασφαλείας (σε λεπτά)",
-          "security_min_on_percent": "Ελάχιστο ποσοστό ισχύος για ενεργοποίηση λειτουργίας ασφαλείας",
-          "security_default_on_percent": "Ποσοστό ισχύος για χρήση σε λειτουργία ασφαλείας"
+          "safety_delay_min": "Καθυστέρηση ασφαλείας (σε λεπτά)",
+          "safety_min_on_percent": "Ελάχιστο ποσοστό ισχύος για ενεργοποίηση λειτουργίας ασφαλείας",
+          "safety_default_on_percent": "Ποσοστό ισχύος για χρήση σε λειτουργία ασφαλείας"
         },
         "data_description": {
           "minimal_activation_delay": "Καθυστέρηση σε δευτερόλεπτα κάτω από την οποία η συσκευή δεν θα ενεργοποιηθεί",
-          "security_delay_min": "Μέγιστη επιτρεπτή καθυστέρηση σε λεπτά μεταξύ δύο μετρήσεων θερμοκρασίας. Πέρα από αυτή την καθυστέρηση, ο θερμοστάτης θα μεταβεί σε κατάσταση ασφαλείας",
-          "security_min_on_percent": "Ελάχιστη τιμή ποσοστού θέρμανσης για την ενεργοποίηση του προεπιλεγμένου ασφάλειας. Κάτω από αυτό το ποσοστό ισχύος το θερμοστάτη δεν θα πάει στο προεπιλεγμένο ασφάλειας.",
-          "security_default_on_percent": "Η προεπιλεγμένη τιμή ποσοστού ισχύος θέρμανσης στο προεπιλεγμένο ασφάλειας. Ορίστε σε 0 για να απενεργοποιήσετε τη θερμάστρα στο παρόν ασφάλειας."
+          "safety_delay_min": "Μέγιστη επιτρεπτή καθυστέρηση σε λεπτά μεταξύ δύο μετρήσεων θερμοκρασίας. Πέρα από αυτή την καθυστέρηση, ο θερμοστάτης θα μεταβεί σε κατάσταση ασφαλείας",
+          "safety_min_on_percent": "Ελάχιστη τιμή ποσοστού θέρμανσης για την ενεργοποίηση του προεπιλεγμένου ασφάλειας. Κάτω από αυτό το ποσοστό ισχύος το θερμοστάτη δεν θα πάει στο προεπιλεγμένο ασφάλειας.",
+          "safety_default_on_percent": "Η προεπιλεγμένη τιμή ποσοστού ισχύος θέρμανσης στο προεπιλεγμένο ασφάλειας. Ορίστε σε 0 για να απενεργοποιήσετε τη θερμάστρα στο παρόν ασφάλειας."
         }
       }
     },
@@ -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": {
@@ -325,15 +325,15 @@
         "description": "Διαμόρφωση των προηγμένων παραμέτρων. Αφήστε τις προεπιλεγμένες τιμές εάν δεν γνωρίζετε τι κάνετε.\nΑυτές οι παράμετροι μπορούν να οδηγήσουν σε πολύ κακή ρύθμιση θερμοκρασίας ή ενέργειας.",
         "data": {
           "minimal_activation_delay": "Ελάχιστη καθυστέρηση ενεργοποίησης",
-          "security_delay_min": "Καθυστέρηση ασφαλείας (σε λεπτά)",
-          "security_min_on_percent": "Ελάχιστο ποσοστό ισχύος για τη λειτουργία ασφαλείας",
-          "security_default_on_percent": "Ποσοστό ισχύος που θα χρησιμοποιηθεί στη λειτουργία ασφαλείας"
+          "safety_delay_min": "Καθυστέρηση ασφαλείας (σε λεπτά)",
+          "safety_min_on_percent": "Ελάχιστο ποσοστό ισχύος για τη λειτουργία ασφαλείας",
+          "safety_default_on_percent": "Ποσοστό ισχύος που θα χρησιμοποιηθεί στη λειτουργία ασφαλείας"
         },
         "data_description": {
           "minimal_activation_delay": "Καθυστέρηση σε δευτερόλεπτα κάτω από την οποία ο εξοπλισμός δεν θα ενεργοποιηθεί",
-          "security_delay_min": "Μέγιστη επιτρεπόμενη καθυστέρηση σε λεπτά μεταξύ δύο μετρήσεων θερμοκρασίας. Πάνω από αυτή την καθυστέρηση, ο θερμοστάτης θα μεταβεί σε κατάσταση ασφαλείας",
-          "security_min_on_percent": "Ελάχιστη τιμή ποσοστού θέρμανσης για ενεργοποίηση του προεπιλεγμένου ασφαλείας. Κάτω από αυτό το ποσοστό ισχύος, ο θερμοστάτης δεν θα μεταβεί στο προεπιλεγμένο ασφαλείας",
-          "security_default_on_percent": "Η προεπιλεγμένη τιμή ποσοστού ισχύος θέρμανσης στο προεπιλεγμένο ασφαλείας. Ορίστε σε 0 για να απενεργοποιήσετε τη θερμάστρα στο παρόν ασφαλείας"
+          "safety_delay_min": "Μέγιστη επιτρεπόμενη καθυστέρηση σε λεπτά μεταξύ δύο μετρήσεων θερμοκρασίας. Πάνω από αυτή την καθυστέρηση, ο θερμοστάτης θα μεταβεί σε κατάσταση ασφαλείας",
+          "safety_min_on_percent": "Ελάχιστη τιμή ποσοστού θέρμανσης για ενεργοποίηση του προεπιλεγμένου ασφαλείας. Κάτω από αυτό το ποσοστό ισχύος, ο θερμοστάτης δεν θα μεταβεί στο προεπιλεγμένο ασφαλείας",
+          "safety_default_on_percent": "Η προεπιλεγμένη τιμή ποσοστού ισχύος θέρμανσης στο προεπιλεγμένο ασφαλείας. Ορίστε σε 0 για να απενεργοποιήσετε τη θερμάστρα στο παρόν ασφαλείας"
         }
       }
     },

custom_components/versatile_thermostat/translations/en.json

@@ -27,13 +27,15 @@
           "power": "Power management",
           "presence": "Presence detection",
           "advanced": "Advanced parameters",
+          "auto_start_stop": "Auto start and stop",
+          "valve_regulation": "Valve regulation configuration",
           "finalize": "All done",
           "configuration_not_complete": "Configuration not complete"
         }
       },
       "main": {
         "title": "Add new Versatile Thermostat",
-        "description": "Main mandatory attributes",
+        "description": "Main mandatory attributes [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/base-attributes.md)",
         "data": {
           "name": "Name",
           "thermostat_type": "Thermostat type",
@@ -63,62 +65,46 @@
           "use_motion_feature": "Use motion detection",
           "use_power_feature": "Use power management",
           "use_presence_feature": "Use presence detection",
-          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after seecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page"
+          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after selecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page",
+          "use_auto_start_stop_feature": "Use the auto start and stop feature"
         }
       },
       "type": {
         "title": "Linked entities",
-        "description": "Linked entities attributes",
+        "description": "Linked entities attributes [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/over-switch.md#configuration)",
         "data": {
-          "heater_entity_id": "1st heater switch",
-          "heater_entity2_id": "2nd heater switch",
-          "heater_entity3_id": "3rd heater switch",
-          "heater_entity4_id": "4th heater switch",
+          "underlying_entity_ids": "The device(s) to be controlled",
           "heater_keep_alive": "Switch keep-alive interval in seconds",
           "proportional_function": "Algorithm",
-          "climate_entity_id": "1st underlying climate",
-          "climate_entity2_id": "2nd underlying climate",
-          "climate_entity3_id": "3rd underlying climate",
-          "climate_entity4_id": "4th underlying climate",
           "ac_mode": "AC mode",
-          "valve_entity_id": "1st valve number",
-          "valve_entity2_id": "2nd valve number",
-          "valve_entity3_id": "3rd valve number",
-          "valve_entity4_id": "4th valve number",
           "auto_regulation_mode": "Self-regulation",
           "auto_regulation_dtemp": "Regulation threshold",
           "auto_regulation_periode_min": "Regulation minimum period",
           "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",
+          "on_command_text": "Turn on command customization",
+          "vswitch_on_command": "Optional turn on commands",
+          "off_command_text": "Turn off command customization",
+          "vswitch_off_command": "Optional turn off commands"
         },
         "data_description": {
-          "heater_entity_id": "Mandatory heater entity id",
-          "heater_entity2_id": "Optional 2nd Heater entity id. Leave empty if not required",
-          "heater_entity3_id": "Optional 3rd Heater entity id. Leave empty if not required",
-          "heater_entity4_id": "Optional 4th Heater entity id. Leave empty if not required",
+          "underlying_entity_ids": "The device(s) to be controlled - 1 is required",
           "heater_keep_alive": "Optional heater switch state refresh interval. Leave empty if not required.",
           "proportional_function": "Algorithm to use (TPI is the only one for now)",
-          "climate_entity_id": "Underlying climate entity id",
-          "climate_entity2_id": "2nd underlying climate entity id",
-          "climate_entity3_id": "3rd underlying climate entity id",
-          "climate_entity4_id": "4th underlying climate entity id",
           "ac_mode": "Use the Air Conditioning (AC) mode",
-          "valve_entity_id": "1st valve number entity id",
-          "valve_entity2_id": "2nd valve number entity id",
-          "valve_entity3_id": "3rd valve number entity id",
-          "valve_entity4_id": "4th valve number entity id",
           "auto_regulation_mode": "Auto adjustment of the target temperature",
           "auto_regulation_dtemp": "The threshold in ° (or % for valve) under which the temperature change will not be sent",
           "auto_regulation_periode_min": "Duration in minutes between two regulation update",
           "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",
+          "on_command_text": "For underlying of type `select` or `climate` you have to customize the commands."
         }
       },
       "tpi": {
         "title": "TPI",
-        "description": "Time Proportional Integral attributes",
+        "description": "Time Proportional Integral attributes [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/algorithms.md#lalgorithme-tpi)",
         "data": {
           "tpi_coef_int": "coef_int",
           "tpi_coef_ext": "coef_ext",
@@ -132,17 +118,18 @@
       },
       "presets": {
         "title": "Presets",
-        "description": "Select if the thermostat will use central preset - deselect for the thermostat to have its own presets",
+        "description": "Select if the thermostat will use central preset - deselect for the thermostat to have its own presets [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-presets.md)",
         "data": {
           "use_presets_central_config": "Use central presets configuration"
         }
       },
       "window": {
         "title": "Window management",
-        "description": "Open window management.\nYou can also configure automatic window open detection based on temperature decrease",
+        "description": "Open window management.\nYou can also configure automatic window open detection based on temperature decrease [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-window.md)",
         "data": {
           "window_sensor_entity_id": "Window sensor entity id",
-          "window_delay": "Window sensor delay (seconds)",
+          "window_delay": "Window sensor 'on' delay (seconds)",
+          "window_off_delay": "Window sensor 'off' delay (seconds)",
           "window_auto_open_threshold": "Temperature decrease threshold for automatic window open detection (in °/hours)",
           "window_auto_close_threshold": "Temperature increase threshold for end of automatic detection (in °/hours)",
           "window_auto_max_duration": "Maximum duration of automatic window open detection (in min)",
@@ -151,7 +138,8 @@
         },
         "data_description": {
           "window_sensor_entity_id": "Leave empty if no window sensor should be used and to use the automatic detection",
-          "window_delay": "The delay in seconds before sensor detection is taken into account",
+          "window_delay": "The delay in seconds before sensor 'on' detection is taken into account",
+          "window_off_delay": "The delay in seconds before sensor 'off' detection is taken into account. Leave it empty to use the same value as window on delay",
           "window_auto_open_threshold": "Recommended value: between 3 and 10. Leave empty if automatic window open detection is not used",
           "window_auto_close_threshold": "Recommended value: 0. Leave empty if automatic window open detection is not used",
           "window_auto_max_duration": "Recommended value: 60 (one hour). Leave empty if automatic window open detection is not used",
@@ -161,7 +149,7 @@
       },
       "motion": {
         "title": "Motion management",
-        "description": "Motion sensor management. Preset can switch automatically depending on motion detection\nmotion_preset and no_motion_preset should be set to the corresponding preset name",
+        "description": "Motion sensor management. Preset can switch automatically depending on motion detection\nmotion_preset and no_motion_preset should be set to the corresponding preset name [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-motion.md)",
         "data": {
           "motion_sensor_entity_id": "Motion sensor entity id",
           "motion_delay": "Activation delay",
@@ -181,7 +169,7 @@
       },
       "power": {
         "title": "Power management",
-        "description": "Power management attributes.\nGives the power and max power sensor of your home.\nSpecify the power consumption of the heater when on.\nAll sensors and device power should use the same unit (kW or W).",
+        "description": "Power management attributes.\nGives the power and max power sensor of your home.\nSpecify the power consumption of the heater when on.\nAll sensors and device power should use the same unit (kW or W) [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-power.md)",
         "data": {
           "power_sensor_entity_id": "Power",
           "max_power_sensor_entity_id": "Max power",
@@ -197,7 +185,7 @@
       },
       "presence": {
         "title": "Presence management",
-        "description": "Presence management attributes.\nGives the a presence sensor of your home (true is someone is present) and give the corresponding temperature preset setting.",
+        "description": "Presence management attributes.\nGives the a presence sensor of your home (true is someone is present) and give the corresponding temperature preset setting [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-presence.md)",
         "data": {
           "presence_sensor_entity_id": "Presence sensor",
           "use_presence_central_config": "Use central presence temperature configuration. Deselect to use specific temperature entities"
@@ -208,21 +196,51 @@
       },
       "advanced": {
         "title": "Advanced parameters",
-        "description": "Configuration of advanced parameters. Leave the default values if you don't know what you are doing.\nThese parameters can lead to very poor temperature control or bad power regulation.",
+        "description": "Configuration of advanced parameters. Leave the default values if you don't know what you are doing.\nThese parameters can lead to very poor temperature control or bad power regulation [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-advanced.md)",
         "data": {
           "minimal_activation_delay": "Minimum activation delay",
-          "security_delay_min": "Safety delay (in minutes)",
-          "security_min_on_percent": "Minimum power percent to enable safety mode",
-          "security_default_on_percent": "Power percent to use in safety mode",
+          "safety_delay_min": "Safety delay (in minutes)",
+          "safety_min_on_percent": "Minimum power percent to enable safety mode",
+          "safety_default_on_percent": "Power percent to use in safety mode",
           "use_advanced_central_config": "Use central advanced configuration"
         },
         "data_description": {
           "minimal_activation_delay": "Delay in seconds under which the equipment will not be activated",
-          "security_delay_min": "Maximum allowed delay in minutes between two temperature measurements. Above this delay the thermostat will turn to a safety off state",
-          "security_min_on_percent": "Minimum heating percent value for safety preset activation. Below this amount of power percent the thermostat won't go into safety preset",
-          "security_default_on_percent": "The default heating power percent value in safety preset. Set to 0 to switch off heater in safety preset",
+          "safety_delay_min": "Maximum allowed delay in minutes between two temperature measurements. Above this delay the thermostat will turn to a safety off state",
+          "safety_min_on_percent": "Minimum heating percent value for safety preset activation. Below this amount of power percent the thermostat won't go into safety preset",
+          "safety_default_on_percent": "The default heating power percent value in safety preset. Set to 0 to switch off heater in safety preset",
           "use_advanced_central_config": "Check to use the central advanced configuration. Uncheck to use a specific advanced configuration for this VTherm"
         }
+      },
+      "central_boiler": {
+        "title": "Control of the central boiler",
+        "description": "Enter the services to call to turn on/off the central boiler. Leave blank if no service call is to be made (in this case, you will have to manage the turning on/off of your central boiler yourself). The service called must be formatted as follows: `entity_id/service_name[/attribute:value]` (/attribute:value is optional)\nFor example:\n- to turn on a switch: `switch.controle_chaudiere/switch.turn_on`\n- to turn off a switch: `switch.controle_chaudiere/switch.turn_off`\n- to program the boiler to 25° and thus force its ignition: `climate.thermostat_chaudiere/climate.set_temperature/temperature:25`\n- to send 10° to the boiler and thus force its extinction: `climate.thermostat_chaudiere/climate.set_temperature/temperature:10` [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-central-boiler.md)",
+        "data": {
+          "central_boiler_activation_service": "Command to turn-on",
+          "central_boiler_deactivation_service": "Command to turn-off"
+        },
+        "data_description": {
+          "central_boiler_activation_service": "Command to turn-on the central boiler formatted like entity_id/service_name[/attribut:valeur]",
+          "central_boiler_deactivation_service": "Command to turn-off the central boiler formatted like entity_id/service_name[/attribut:valeur]"
+        }
+      },
+      "valve_regulation": {
+        "title": "Self-regulation with valve",
+        "description": "Configuration for self-regulation with direct control of the valve [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/self-regulation.md#auto-régulation-par-contrôle-direct-de-la-vanne)",
+        "data": {
+          "offset_calibration_entity_ids": "Offset calibration entities",
+          "opening_degree_entity_ids": "Opening degree entities",
+          "closing_degree_entity_ids": "Closing degree entities",
+          "proportional_function": "Algorithm",
+          "min_opening_degrees": "Min opening degrees"
+        },
+        "data_description": {
+          "offset_calibration_entity_ids": "The list of the 'offset calibration' entities. Set it if your TRV has the entity for better regulation. There should be one per underlying climate entities",
+          "opening_degree_entity_ids": "The list of the 'opening degree' entities. There should be one per underlying climate entities",
+          "closing_degree_entity_ids": "The list of the 'closing degree' entities. Set it if your TRV has the entity for better regulation. There should be one per underlying climate entities",
+          "proportional_function": "Algorithm to use (TPI is the only one for now)",
+          "min_opening_degrees": "Opening degree minimum value for each underlying device, comma separated. Default to 0. Example: 20, 25, 30"
+        }
       }
     },
     "error": {
@@ -262,13 +280,15 @@
           "power": "Power management",
           "presence": "Presence detection",
           "advanced": "Advanced parameters",
+          "auto_start_stop": "Auto start and stop",
+          "valve_regulation": "Valve regulation configuration",
           "finalize": "All done",
           "configuration_not_complete": "Configuration not complete"
         }
       },
       "main": {
         "title": "Main - {name}",
-        "description": "Main mandatory attributes",
+        "description": "Main mandatory attributes [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/base-attributes.md)",
         "data": {
           "name": "Name",
           "thermostat_type": "Thermostat type",
@@ -298,62 +318,46 @@
           "use_motion_feature": "Use motion detection",
           "use_power_feature": "Use power management",
           "use_presence_feature": "Use presence detection",
-          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after seecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page"
+          "use_central_boiler_feature": "Use a central boiler. Check to add a control to your central boiler. You will have to configure the VTherm which will have a control of the central boiler after selecting this checkbox to take effect. If one VTherm requires heating, the boiler will be turned on. If no VTherm requires heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the related configuration page",
+          "use_auto_start_stop_feature": "Use the auto start and stop feature"
         }
       },
       "type": {
         "title": "Entities - {name}",
-        "description": "Linked entities attributes",
+        "description": "Linked entities attributes [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/over-switch.md#configuration)",
         "data": {
-          "heater_entity_id": "1st heater switch",
-          "heater_entity2_id": "2nd heater switch",
-          "heater_entity3_id": "3rd heater switch",
-          "heater_entity4_id": "4th heater switch",
+          "underlying_entity_ids": "The device(s) to be controlled",
           "heater_keep_alive": "Switch keep-alive interval in seconds",
           "proportional_function": "Algorithm",
-          "climate_entity_id": "1st underlying climate",
-          "climate_entity2_id": "2nd underlying climate",
-          "climate_entity3_id": "3rd underlying climate",
-          "climate_entity4_id": "4th underlying climate",
           "ac_mode": "AC mode",
-          "valve_entity_id": "1st valve number",
-          "valve_entity2_id": "2nd valve number",
-          "valve_entity3_id": "3rd valve number",
-          "valve_entity4_id": "4th valve number",
           "auto_regulation_mode": "Self-regulation",
           "auto_regulation_dtemp": "Regulation threshold",
           "auto_regulation_periode_min": "Regulation minimum period",
           "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",
+          "on_command_text": "Turn on command customization",
+          "vswitch_on_command": "Optional turn on commands",
+          "off_command_text": "Turn off command customization",
+          "vswitch_off_command": "Optional turn off commands"
         },
         "data_description": {
-          "heater_entity_id": "Mandatory heater entity id",
-          "heater_entity2_id": "Optional 2nd Heater entity id. Leave empty if not used",
-          "heater_entity3_id": "Optional 3rd Heater entity id. Leave empty if not used",
-          "heater_entity4_id": "Optional 4th Heater entity id. Leave empty if not used",
+          "underlying_entity_ids": "The device(s) to be controlled - 1 is required",
           "heater_keep_alive": "Optional heater switch state refresh interval. Leave empty if not required.",
           "proportional_function": "Algorithm to use (TPI is the only one for now)",
-          "climate_entity_id": "Underlying climate entity id",
-          "climate_entity2_id": "2nd underlying climate entity id",
-          "climate_entity3_id": "3rd underlying climate entity id",
-          "climate_entity4_id": "4th underlying climate entity id",
           "ac_mode": "Use the Air Conditioning (AC) mode",
-          "valve_entity_id": "1st valve number entity id",
-          "valve_entity2_id": "2nd valve number entity id",
-          "valve_entity3_id": "3rd valve number entity id",
-          "valve_entity4_id": "4th valve number entity id",
           "auto_regulation_mode": "Auto adjustment of the target temperature",
           "auto_regulation_dtemp": "The threshold in ° (or % for valve) under which the temperature change will not be sent",
           "auto_regulation_periode_min": "Duration in minutes between two regulation update",
           "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"
+          "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",
+          "on_command_text": "For underlying of type `select` or `climate` you have to customize the commands."
         }
       },
       "tpi": {
         "title": "TPI - {name}",
-        "description": "Time Proportional Integral attributes",
+        "description": "Time Proportional Integral attributes [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/algorithms.md#lalgorithme-tpi)",
         "data": {
           "tpi_coef_int": "coef_int",
           "tpi_coef_ext": "coef_ext",
@@ -367,17 +371,18 @@
       },
       "presets": {
         "title": "Presets - {name}",
-        "description": "Check if the thermostat will use central presets. Uncheck and the thermostat will have its own preset entities",
+        "description": "Check if the thermostat will use central presets. Uncheck and the thermostat will have its own preset entities [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-presets.md)",
         "data": {
           "use_presets_central_config": "Use central presets configuration"
         }
       },
       "window": {
         "title": "Window - {name}",
-        "description": "Open window management.\nYou can also configure automatic window open detection based on temperature decrease",
+        "description": "Open window management.\nYou can also configure automatic window open detection based on temperature decrease [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-window.md)",
         "data": {
           "window_sensor_entity_id": "Window sensor entity id",
-          "window_delay": "Window sensor delay (seconds)",
+          "window_delay": "Window sensor 'on' delay (seconds)",
+          "window_off_delay": "Window sensor 'off' delay (seconds)",
           "window_auto_open_threshold": "Temperature decrease threshold for automatic window open detection (in °/hours)",
           "window_auto_close_threshold": "Temperature increase threshold for end of automatic detection (in °/hours)",
           "window_auto_max_duration": "Maximum duration of automatic window open detection (in min)",
@@ -386,8 +391,8 @@
         },
         "data_description": {
           "window_sensor_entity_id": "Leave empty if no window sensor should be used and to use the automatic detection",
-          "window_delay": "The delay in seconds before sensor detection is taken into account",
-          "window_auto_open_threshold": "Recommended value: between 3 and 10. Leave empty if automatic window open detection is not used",
+          "window_delay": "The delay in seconds before sensor 'on' detection is taken into account",
+          "window_off_delay": "The delay in seconds before sensor 'off' detection is taken into account. Leave it empty to use the same value as window on delay",
           "window_auto_close_threshold": "Recommended value: 0. Leave empty if automatic window open detection is not used",
           "window_auto_max_duration": "Recommended value: 60 (one hour). Leave empty if automatic window open detection is not used",
           "use_window_central_config": "Check to use the central window configuration. Uncheck to use a specific window configuration for this VTherm",
@@ -396,7 +401,7 @@
       },
       "motion": {
         "title": "Motion - {name}",
-        "description": "Motion management. Preset can switch automatically depending of a motion detection\nmotion_preset and no_motion_preset should be set to the corresponding preset name",
+        "description": "Motion management. Preset can switch automatically depending of a motion detection\nmotion_preset and no_motion_preset should be set to the corresponding preset name [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-motion.md)",
         "data": {
           "motion_sensor_entity_id": "Motion sensor entity id",
           "motion_delay": "Activation delay",
@@ -416,7 +421,7 @@
       },
       "power": {
         "title": "Power - {name}",
-        "description": "Power management attributes.\nGives the power and max power sensor of your home.\nThen specify the power consumption of the heater when on.\nAll sensors and device power should have the same unit (kW or W).",
+        "description": "Power management attributes.\nGives the power and max power sensor of your home.\nSpecify the power consumption of the heater when on.\nAll sensors and device power should use the same unit (kW or W) [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-power.md)",
         "data": {
           "power_sensor_entity_id": "Power",
           "max_power_sensor_entity_id": "Max power",
@@ -432,7 +437,7 @@
       },
       "presence": {
         "title": "Presence - {name}",
-        "description": "Presence management attributes.\nGives the a presence sensor of your home (true is someone is present) and give the corresponding temperature preset setting.",
+        "description": "Presence management attributes.\nGives the a presence sensor of your home (true is someone is present) and give the corresponding temperature preset setting [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-presence.md)",
         "data": {
           "presence_sensor_entity_id": "Presence sensor",
           "use_presence_central_config": "Use central presence temperature configuration. Uncheck to use specific temperature entities"
@@ -443,21 +448,51 @@
       },
       "advanced": {
         "title": "Advanced - {name}",
-        "description": "Advanced parameters. Leave the default values if you don't know what you are doing.\nThese parameters can lead to very poor temperature control or bad power regulation.",
+        "description": "Configuration of advanced parameters. Leave the default values if you don't know what you are doing.\nThese parameters can lead to very poor temperature control or bad power regulation [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/en/feature-advanced.md)",
         "data": {
           "minimal_activation_delay": "Minimum activation delay",
-          "security_delay_min": "Safety delay (in minutes)",
-          "security_min_on_percent": "Minimum power percent to enable safety mode",
-          "security_default_on_percent": "Power percent to use in safety mode",
+          "safety_delay_min": "Safety delay (in minutes)",
+          "safety_min_on_percent": "Minimum power percent to enable safety mode",
+          "safety_default_on_percent": "Power percent to use in safety mode",
           "use_advanced_central_config": "Use central advanced configuration"
         },
         "data_description": {
           "minimal_activation_delay": "Delay in seconds under which the equipment will not be activated",
-          "security_delay_min": "Maximum allowed delay in minutes between two temperature measurements. Above this delay the thermostat will turn to a safety off state",
-          "security_min_on_percent": "Minimum heating percent value for safety preset activation. Below this amount of power percent the thermostat won't go into safety preset",
-          "security_default_on_percent": "The default heating power percent value in safety preset. Set to 0 to switch off heater in safety preset",
+          "safety_delay_min": "Maximum allowed delay in minutes between two temperature measurements. Above this delay the thermostat will turn to a safety off state",
+          "safety_min_on_percent": "Minimum heating percent value for safety preset activation. Below this amount of power percent the thermostat won't go into safety preset",
+          "safety_default_on_percent": "The default heating power percent value in safety preset. Set to 0 to switch off heater in safety preset",
           "use_advanced_central_config": "Check to use the central advanced configuration. Uncheck to use a specific advanced configuration for this VTherm"
         }
+      },
+      "central_boiler": {
+        "title": "Control of the central boiler - {name}",
+        "description": "Enter the services to call to turn on/off the central boiler. Leave blank if no service call is to be made (in this case, you will have to manage the turning on/off of your central boiler yourself). The service called must be formatted as follows: `entity_id/service_name[/attribute:value]` (/attribute:value is optional)\nFor example:\n- to turn on a switch: `switch.controle_chaudiere/switch.turn_on`\n- to turn off a switch: `switch.controle_chaudiere/switch.turn_off`\n- to program the boiler to 25° and thus force its ignition: `climate.thermostat_chaudiere/climate.set_temperature/temperature:25`\n- to send 10° to the boiler and thus force its extinction: `climate.thermostat_chaudiere/climate.set_temperature/temperature:10` [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-central-boiler.md)",
+        "data": {
+          "central_boiler_activation_service": "Command to turn-on",
+          "central_boiler_deactivation_service": "Command to turn-off"
+        },
+        "data_description": {
+          "central_boiler_activation_service": "Command to turn-on the central boiler formatted like entity_id/service_name[/attribut:valeur]",
+          "central_boiler_deactivation_service": "Command to turn-off the central boiler formatted like entity_id/service_name[/attribut:valeur]"
+        }
+      },
+      "valve_regulation": {
+        "title": "Self-regulation with valve - {name}",
+        "description": "Configuration for self-regulation with direct control of the valve [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/self-regulation.md#auto-régulation-par-contrôle-direct-de-la-vanne)",
+        "data": {
+          "offset_calibration_entity_ids": "Offset calibration entities",
+          "opening_degree_entity_ids": "Opening degree entities",
+          "closing_degree_entity_ids": "Closing degree entities",
+          "proportional_function": "Algorithm",
+          "min_opening_degrees": "Min opening degrees"
+        },
+        "data_description": {
+          "offset_calibration_entity_ids": "The list of the 'offset calibration' entities. Set it if your TRV has the entity for better regulation. There should be one per underlying climate entities",
+          "opening_degree_entity_ids": "The list of the 'opening degree' entities. There should be one per underlying climate entities",
+          "closing_degree_entity_ids": "The list of the 'closing degree' entities. Set it if your TRV has the entity for better regulation. There should be one per underlying climate entities",
+          "proportional_function": "Algorithm to use (TPI is the only one for now)",
+          "min_opening_degrees": "Opening degree minimum value for each underlying device, comma separated. Default to 0. Example: 20, 25, 30"
+        }
       }
     },
     "error": {
@@ -465,7 +500,9 @@
       "unknown_entity": "Unknown entity id",
       "window_open_detection_method": "Only one window open detection method should be used. Use either window sensor or automatic detection through temperature threshold but not both",
       "no_central_config": "You cannot check 'use central configuration' because no central configuration was found. You need to create a Versatile Thermostat of type 'Central Configuration' to use it.",
-      "service_configuration_format": "The format of the service configuration is wrong"
+      "service_configuration_format": "The format of the service configuration is wrong",
+      "valve_regulation_nb_entities_incorrect": "The number of valve entities for valve regulation should be equal to the number of underlyings",
+      "min_opening_degrees_format": "A comma separated list of positive integer is expected. Example: 20, 25, 30"
     },
     "abort": {
       "already_configured": "Device is already configured"
@@ -487,7 +524,8 @@
         "auto_regulation_medium": "Medium",
         "auto_regulation_light": "Light",
         "auto_regulation_expert": "Expert",
-        "auto_regulation_none": "No auto-regulation"
+        "auto_regulation_none": "No auto-regulation",
+        "auto_regulation_valve": "Direct control of valve"
       }
     },
     "auto_fan_mode": {
@@ -514,6 +552,14 @@
         "comfort": "Comfort",
         "boost": "Boost"
       }
+    },
+    "auto_start_stop": {
+      "options": {
+        "auto_start_stop_none": "No auto start/stop",
+        "auto_start_stop_slow": "Slow detection",
+        "auto_start_stop_medium": "Medium detection",
+        "auto_start_stop_fast": "Fast detection"
+      }
     }
   },
   "entity": {
@@ -523,8 +569,9 @@
           "preset_mode": {
             "state": {
               "power": "Shedding",
-              "security": "Safety",
-              "none": "Manual"
+              "safety": "Safety",
+              "none": "Manual",
+              "frost": "Frost"
             }
           }
         }

custom_components/versatile_thermostat/translations/fr.json

@@ -5,6 +5,7 @@
     "step": {
       "user": {
         "title": "Type du nouveau Versatile Thermostat",
+        "description": "Choisissez le type de thermostat que vous voulez créer [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/creation.md)",
         "data": {
           "thermostat_type": "Type de thermostat"
         },
@@ -27,13 +28,15 @@
           "power": "Gestion de la puissance",
           "presence": "Détection de présence",
           "advanced": "Paramètres avancés",
+          "auto_start_stop": "Allumage/extinction automatique",
+          "valve_regulation": "Configuration de la regulation par vanne",
           "finalize": "Finaliser la création",
           "configuration_not_complete": "Configuration incomplète"
         }
       },
       "main": {
         "title": "Ajout d'un nouveau thermostat",
-        "description": "Principaux attributs obligatoires",
+        "description": "Principaux attributs obligatoires [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/base-attributes.md)",
         "data": {
           "name": "Nom",
           "thermostat_type": "Type de thermostat",
@@ -63,62 +66,46 @@
           "use_motion_feature": "Avec détection de mouvement",
           "use_power_feature": "Avec gestion de la puissance",
           "use_presence_feature": "Avec détection de présence",
-          "use_central_boiler_feature": "Ajouter une chaudière centrale. Cochez pour ajouter un controle sur une chaudière centrale. Vous devrez ensuite configurer les VTherms qui commande la chaudière centrale pour que cette option prenne effet. Si au moins un des VTherm a besoin de chauffer, la chaudière centrale sera activée. Si aucun VTherm n'a besoin de chauffer, elle sera éteinte. Les commandes pour allumer/éteindre la chaudière centrale sont données dans la page de configuration suivante."
+          "use_central_boiler_feature": "Ajouter une chaudière centrale. Cochez pour ajouter un controle sur une chaudière centrale. Vous devrez ensuite configurer les VTherms qui commande la chaudière centrale pour que cette option prenne effet. Si au moins un des VTherm a besoin de chauffer, la chaudière centrale sera activée. Si aucun VTherm n'a besoin de chauffer, elle sera éteinte. Les commandes pour allumer/éteindre la chaudière centrale sont données dans la page de configuration suivante.",
+          "use_auto_start_stop_feature": "Avec démarrage et extinction automatique"
         }
       },
       "type": {
         "title": "Entité(s) liée(s)",
-        "description": "Attributs de(s) l'entité(s) liée(s)",
+        "description": "Attributs de(s) l'entité(s) liée(s) [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/over-switch.md#configuration)",
         "data": {
-          "heater_entity_id": "1er radiateur",
-          "heater_entity2_id": "2ème radiateur",
-          "heater_entity3_id": "3ème radiateur",
-          "heater_entity4_id": "4ème radiateur",
+          "underlying_entity_ids": "Les équipements à controller",
           "heater_keep_alive": "keep-alive (sec)",
           "proportional_function": "Algorithme",
-          "climate_entity_id": "Thermostat sous-jacent",
-          "climate_entity2_id": "2ème thermostat sous-jacent",
-          "climate_entity3_id": "3ème thermostat sous-jacent",
-          "climate_entity4_id": "4ème thermostat sous-jacent",
           "ac_mode": "AC mode ?",
-          "valve_entity_id": "1ère valve number",
-          "valve_entity2_id": "2ème valve number",
-          "valve_entity3_id": "3ème valve number",
-          "valve_entity4_id": "4ème valve number",
           "auto_regulation_mode": "Auto-régulation",
           "auto_regulation_dtemp": "Seuil de régulation",
           "auto_regulation_periode_min": "Période minimale de régulation",
-          "auto_regulation_use_device_temp": "Utiliser la température interne du sous-jacent",
+          "auto_regulation_use_device_temp": "Compenser la température interne du sous-jacent",
           "inverse_switch_command": "Inverser la commande",
-          "auto_fan_mode": " Auto ventilation mode"
+          "auto_fan_mode": " Auto ventilation mode",
+          "on_command_text": "Personnalisation des commandes d'allumage",
+          "vswitch_on_command": "Commande d'allumage (optionnel)",
+          "off_command_text": "Personnalisation des commandes d'extinction",
+          "vswitch_off_command": "Commande d'extinction (optionnel)"
         },
         "data_description": {
-          "heater_entity_id": "Entity id du 1er radiateur obligatoire",
-          "heater_entity2_id": "Optionnel entity id du 2ème radiateur",
-          "heater_entity3_id": "Optionnel entity id du 3ème radiateur",
-          "heater_entity4_id": "Optionnel entity id du 4ème radiateur",
+          "underlying_entity_ids": "La liste des équipements qui seront controlés par ce VTherm",
           "heater_keep_alive": "Intervalle de rafraichissement du switch en secondes. Laisser vide pour désactiver. À n'utiliser que pour les switchs qui le nécessite.",
           "proportional_function": "Algorithme à utiliser (Seul TPI est disponible pour l'instant)",
-          "climate_entity_id": "Entity id du thermostat sous-jacent",
-          "climate_entity2_id": "Entity id du 2ème thermostat sous-jacent",
-          "climate_entity3_id": "Entity id du 3ème thermostat sous-jacent",
-          "climate_entity4_id": "Entity id du 4ème thermostat sous-jacent",
           "ac_mode": "Utilisation du mode Air Conditionné (AC)",
-          "valve_entity_id": "Entity id de la 1ère valve",
-          "valve_entity2_id": "Entity id de la 2ème valve",
-          "valve_entity3_id": "Entity id de la 3ème valve",
-          "valve_entity4_id": "Entity id de la 4ème valve",
-          "auto_regulation_mode": "Ajustement automatique de la température cible",
-          "auto_regulation_dtemp": "Le seuil en ° (ou % pour les valves) en-dessous duquel la régulation ne sera pas envoyée",
+          "auto_regulation_mode": "Utilisation de l'auto-régulation faite par VTherm",
+          "auto_regulation_dtemp": "Le seuil en ° (ou % pour les vannes) en-dessous duquel la régulation ne sera pas envoyée",
           "auto_regulation_periode_min": "La durée en minutes entre deux mise à jour faites par la régulation",
-          "auto_regulation_use_device_temp": "Utiliser la temperature interne du sous-jacent pour accélérer l'auto-régulation",
+          "auto_regulation_use_device_temp": "Compenser la temperature interne du sous-jacent pour accélérer l'auto-régulation",
           "inverse_switch_command": "Inverse la commande du switch pour une installation avec fil pilote et diode",
-          "auto_fan_mode": "Active la ventilation automatiquement en cas d'écart important"
+          "auto_fan_mode": "Active la ventilation automatiquement en cas d'écart important",
+          "on_command_text": "Pour les sous-jacents de type `select` ou `climate` vous devez personnaliser les commandes."
         }
       },
       "tpi": {
         "title": "TPI",
-        "description": "Attributs de l'algo Time Proportional Integral",
+        "description": "Attributs de l'algo Time Proportional Integral [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/algorithms.md#lalgorithme-tpi)",
         "data": {
           "tpi_coef_int": "coeff_int",
           "tpi_coef_ext": "coeff_ext",
@@ -132,17 +119,18 @@
       },
       "presets": {
         "title": "Pre-réglages",
-        "description": "Cochez pour que ce thermostat utilise les pré-réglages de la configuration centrale. Décochez pour utiliser des entités de température spécifiques",
+        "description": "Cochez pour que ce thermostat utilise les pré-réglages de la configuration centrale. Décochez pour utiliser des entités de température spécifiques [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-presets.md)",
         "data": {
           "use_presets_central_config": "Utiliser la configuration des pré-réglages centrale"
         }
       },
       "window": {
         "title": "Gestion d'une ouverture",
-        "description": "Coupe le radiateur si l'ouverture est ouverte.\nLaissez l'id d'entité vide pour utiliser la détection automatique.",
+        "description": "Coupe le radiateur si l'ouverture est ouverte.\nLaissez l'id d'entité vide pour utiliser la détection automatique [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-window.md)",
         "data": {
           "window_sensor_entity_id": "Détecteur d'ouverture (entity id)",
-          "window_delay": "Délai avant extinction (secondes)",
+          "window_delay": "Délai de prise en compte à l'ouverture (secondes)",
+          "window_off_delay": "Délai de prise compte à la fermeture (secondes)",
           "window_auto_open_threshold": "Seuil haut de chute de température pour la détection automatique (en °/heure)",
           "window_auto_close_threshold": "Seuil bas de chute de température pour la fin de détection automatique (en °/heure)",
           "window_auto_max_duration": "Durée maximum d'une extinction automatique (en min)",
@@ -151,7 +139,8 @@
         },
         "data_description": {
           "window_sensor_entity_id": "Laissez vide si vous n'avez de détecteur et pour utiliser la détection automatique",
-          "window_delay": "Le délai (en secondes) avant que le changement du détecteur soit pris en compte",
+          "window_delay": "Le délai (en secondes) avant que le changement du détecteur soit pris en compte lors de la détection d'une ouverture",
+          "window_off_delay": "Le délai (en secondes) avant que le changement du détecteur soit pris en compte lors de la détection d'une fermeture. Laissez vide pour utiliser le même délai à l'ouveture et à la fermeture",
           "window_auto_open_threshold": "Valeur recommandée: entre 3 et 10. Laissez vide si vous n'utilisez pas la détection automatique",
           "window_auto_close_threshold": "Valeur recommandée: 0. Laissez vide si vous n'utilisez pas la détection automatique",
           "window_auto_max_duration": "Valeur recommandée: 60 (1 heure). Laissez vide si vous n'utilisez pas la détection automatique",
@@ -161,7 +150,7 @@
       },
       "motion": {
         "title": "Gestion de la détection de mouvement",
-        "description": "Le preset s'ajuste automatiquement si un mouvement est détecté\n'Preset mouvement' et 'Preset sans mouvement' doivent être choisis avec les preset à utiliser.",
+        "description": "Le preset s'ajuste automatiquement si un mouvement est détecté\n'Preset mouvement' et 'Preset sans mouvement' doivent être choisis avec les preset à utiliser [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-motion.md)",
         "data": {
           "motion_sensor_entity_id": "Détecteur de mouvement",
           "motion_delay": "Délai d'activation",
@@ -172,7 +161,7 @@
         },
         "data_description": {
           "motion_sensor_entity_id": "Id d'entité du détecteur de mouvement",
-          "motion_delay": "Délai avant activation lorsqu'un mouvement est détecté (secondss)",
+          "motion_delay": "Délai avant activation lorsqu'un mouvement est détecté (secondes)",
           "motion_off_delai": "Délai avant désactivation lorsqu'aucun mouvement n'est détecté (secondes)",
           "motion_preset": "Preset à utiliser si mouvement détecté",
           "no_motion_preset": "Preset à utiliser si pas de mouvement détecté",
@@ -181,7 +170,7 @@
       },
       "power": {
         "title": "Gestion de la puissance",
-        "description": "Sélectionne automatiquement le preset 'power' si la puissance consommée est supérieure à un maximum.\nDonnez les entity id des capteurs qui mesurent la puissance totale et la puissance max autorisée.\nEnsuite donnez la puissance de l'équipement.\nTous les capteurs et la puissance consommée par l'équipement doivent avoir la même unité de mesure (kW ou W).",
+        "description": "Sélectionne automatiquement le preset 'power' si la puissance consommée est supérieure à un maximum.\nDonnez les entity id des capteurs qui mesurent la puissance totale et la puissance max autorisée.\nEnsuite donnez la puissance de l'équipement.\nTous les capteurs et la puissance consommée par l'équipement doivent avoir la même unité de mesure (kW ou W) [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-power.md)",
         "data": {
           "power_sensor_entity_id": "Capteur de puissance totale (entity id)",
           "max_power_sensor_entity_id": "Capteur de puissance Max (entity id)",
@@ -196,8 +185,8 @@
         }
       },
       "presence": {
-        "title": "Gestion de la présence",
-        "description": "Donnez un capteur de présence (true si quelqu'un est présent) et les températures cibles à utiliser en cas d'abs.",
+        "title": "Gestion de la présenc",
+        "description": "Donnez un capteur de présence (true si quelqu'un est présent) et les températures cibles à utiliser en cas d'absence [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-presence.md)",
         "data": {
           "presence_sensor_entity_id": "Capteur de présence",
           "use_presence_central_config": "Utiliser la configuration centrale des températures en cas d'absence. Décochez pour avoir des entités de température dédiées"
@@ -208,25 +197,25 @@
       },
       "advanced": {
         "title": "Parameters avancés",
-        "description": "Configuration des paramètres avancés. Laissez les valeurs par défaut si vous ne savez pas ce que vous faites.\nCes paramètres peuvent induire des mauvais comportements du thermostat.",
+        "description": "Configuration des paramètres avancés. Laissez les valeurs par défaut si vous ne savez pas ce que vous faites.\nCes paramètres peuvent induire des mauvais comportements du thermostat [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-advanced.md)",
         "data": {
           "minimal_activation_delay": "Délai minimal d'activation",
-          "security_delay_min": "Délai maximal entre 2 mesures de températures",
-          "security_min_on_percent": "Pourcentage minimal de puissance",
-          "security_default_on_percent": "Pourcentage de puissance a utiliser en mode securité",
+          "safety_delay_min": "Délai maximal entre 2 mesures de températures",
+          "safety_min_on_percent": "Pourcentage minimal de puissance",
+          "safety_default_on_percent": "Pourcentage de puissance a utiliser en mode securité",
           "use_advanced_central_config": "Utiliser la configuration centrale avancée"
         },
         "data_description": {
-          "minimal_activation_delay": "Délai en seondes en-dessous duquel l'équipement ne sera pas activé",
-          "security_delay_min": "Délai maximal autorisé en minutes entre 2 mesures de températures. Au-dessus de ce délai, le thermostat se mettra en position de sécurité",
-          "security_min_on_percent": "Seuil minimal de pourcentage de chauffage en-dessous duquel le préréglage sécurité ne sera jamais activé",
-          "security_default_on_percent": "Valeur par défaut pour le pourcentage de chauffage en mode sécurité. Mettre 0 pour éteindre le radiateur en mode sécurité",
+          "minimal_activation_delay": "Délai en secondes en-dessous duquel l'équipement ne sera pas activé",
+          "safety_delay_min": "Délai maximal autorisé en minutes entre 2 mesures de températures. Au-dessus de ce délai, le thermostat se mettra en position de sécurité",
+          "safety_min_on_percent": "Seuil minimal de pourcentage de chauffage en-dessous duquel le préréglage sécurité ne sera jamais activé",
+          "safety_default_on_percent": "Valeur par défaut pour le pourcentage de chauffage en mode sécurité. Mettre 0 pour éteindre le radiateur en mode sécurité",
           "use_advanced_central_config": "Cochez pour utiliser la configuration centrale avancée. Décochez et saisissez les attributs pour utiliser une configuration spécifique avancée"
         }
       },
       "central_boiler": {
         "title": "Contrôle de la chaudière centrale",
-        "description": "Donnez les services à appeler pour allumer/éteindre la chaudière centrale. Laissez vide, si aucun appel de service ne doit être effectué (dans ce cas, vous devrez gérer vous même l'allumage/extinction de votre chaudière centrale). Le service a appelé doit être formatté comme suit: `entity_id/service_name[/attribut:valeur]` (/attribut:valeur est facultatif)\nPar exemple:\n- pour allumer un switch: `switch.controle_chaudiere/switch.turn_on`\n- pour éteindre un switch: `switch.controle_chaudiere/switch.turn_off`\n- pour programmer la chaudière sur 25° et ainsi forcer son allumage: `climate.thermostat_chaudiere/climate.set_temperature/temperature:25`\n- pour envoyer 10° à la chaudière et ainsi forcer son extinction: `climate.thermostat_chaudiere/climate.set_temperature/temperature:10`",
+        "description": "Donnez les services à appeler pour allumer/éteindre la chaudière centrale. Laissez vide, si aucun appel de service ne doit être effectué (dans ce cas, vous devrez gérer vous même l'allumage/extinction de votre chaudière centrale). Le service a appelé doit être formatté comme suit: `entity_id/service_name[/attribut:valeur]` (/attribut:valeur est facultatif)\nPar exemple:\n- pour allumer un switch: `switch.controle_chaudiere/switch.turn_on`\n- pour éteindre un switch: `switch.controle_chaudiere/switch.turn_off`\n- pour programmer la chaudière sur 25° et ainsi forcer son allumage: `climate.thermostat_chaudiere/climate.set_temperature/temperature:25`\n- pour envoyer 10° à la chaudière et ainsi forcer son extinction: `climate.thermostat_chaudiere/climate.set_temperature/temperature:10` [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-central-boiler.md)",
         "data": {
           "central_boiler_activation_service": "Commande pour allumer",
           "central_boiler_deactivation_service": "Commande pour éteindre"
@@ -235,6 +224,24 @@
           "central_boiler_activation_service": "Commande à éxecuter pour allumer la chaudière centrale au format entity_id/service_name[/attribut:valeur]",
           "central_boiler_deactivation_service": "Commande à éxecuter pour étiendre la chaudière centrale au format entity_id/service_name[/attribut:valeur]"
         }
+      },
+      "valve_regulation": {
+        "title": "Auto-régulation par vanne",
+        "description": "Configuration de l'auto-régulation par controle direct de la vanne [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/self-regulation.md#auto-régulation-par-contrôle-direct-de-la-vanne)",
+        "data": {
+          "offset_calibration_entity_ids": "Entités de 'calibrage du décalage''",
+          "opening_degree_entity_ids": "Entités 'ouverture de vanne'",
+          "closing_degree_entity_ids": "Entités 'fermeture de la vanne'",
+          "proportional_function": "Algorithme",
+          "min_opening_degrees": "Ouvertures minimales"
+        },
+        "data_description": {
+          "offset_calibration_entity_ids": "La liste des entités 'calibrage du décalage' (offset calibration). Configurez le si votre TRV possède cette fonction pour une meilleure régulation. Il doit y en avoir une par entité climate sous-jacente",
+          "opening_degree_entity_ids": "La liste des entités 'ouverture de vanne'. Il doit y en avoir une par entité climate sous-jacente",
+          "closing_degree_entity_ids": "La liste des entités 'fermeture de la vanne'. Configurez le si votre TRV possède cette fonction pour une meilleure régulation. Il doit y en avoir une par entité climate sous-jacente",
+          "proportional_function": "Algorithme à utiliser (seulement TPI est disponible)",
+          "min_opening_degrees": "Une liste séparée par des virgules de minimum d'ouverture. Valeur par défaut : 0. Exemple : 20, 25, 30"
+        }
       }
     },
     "error": {
@@ -252,6 +259,7 @@
     "step": {
       "user": {
         "title": "Type - {name}",
+        "description": "Choisissez le type de thermostat que vous voulez créer [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/creation.md)",
         "data": {
           "thermostat_type": "Type de thermostat"
         },
@@ -274,13 +282,15 @@
           "power": "Gestion de la puissance",
           "presence": "Détection de présence",
           "advanced": "Paramètres avancés",
+          "auto_start_stop": "Allumage/extinction automatique",
+          "valve_regulation": "Configuration de la regulation par vanne",
           "finalize": "Finaliser les modifications",
           "configuration_not_complete": "Configuration incomplète"
         }
       },
       "main": {
         "title": "Attributs - {name}",
-        "description": "Principaux attributs obligatoires",
+        "description": "Principaux attributs obligatoires [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/base-attributes.md)",
         "data": {
           "name": "Nom",
           "thermostat_type": "Type de thermostat",
@@ -310,62 +320,46 @@
           "use_motion_feature": "Avec détection de mouvement",
           "use_power_feature": "Avec gestion de la puissance",
           "use_presence_feature": "Avec détection de présence",
-          "use_central_boiler_feature": "Ajouter une chaudière centrale. Cochez pour ajouter un controle sur une chaudière centrale. Vous devrez ensuite configurer les VTherms qui commande la chaudière centrale pour que cette option prenne effet. Si au moins un des VTherm a besoin de chauffer, la chaudière centrale sera activée. Si aucun VTherm n'a besoin de chauffer, elle sera éteinte. Les commandes pour allumer/éteindre la chaudière centrale sont données dans la page de configuration suivante."
+          "use_central_boiler_feature": "Ajouter une chaudière centrale. Cochez pour ajouter un controle sur une chaudière centrale. Vous devrez ensuite configurer les VTherms qui commande la chaudière centrale pour que cette option prenne effet. Si au moins un des VTherm a besoin de chauffer, la chaudière centrale sera activée. Si aucun VTherm n'a besoin de chauffer, elle sera éteinte. Les commandes pour allumer/éteindre la chaudière centrale sont données dans la page de configuration suivante.",
+          "use_auto_start_stop_feature": "Avec démarrage et extinction automatique"
         }
       },
       "type": {
-        "title": "Entités - {name}",
-        "description": "Attributs de(s) l'entité(s) liée(s)",
+        "title": "Entité(s) liée(s) - {name}",
+        "description": "Attributs de(s) l'entité(s) liée(s) [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/over-switch.md#configuration)",
         "data": {
-          "heater_entity_id": "1er radiateur",
-          "heater_entity2_id": "2ème radiateur",
-          "heater_entity3_id": "3ème radiateur",
-          "heater_entity4_id": "4ème radiateur",
-          "heater_keep_alive": "Keep-alive (sec)",
+          "underlying_entity_ids": "Les équipements à controller",
+          "heater_keep_alive": "keep-alive (sec)",
           "proportional_function": "Algorithme",
-          "climate_entity_id": "Thermostat sous-jacent",
-          "climate_entity2_id": "2ème thermostat sous-jacent",
-          "climate_entity3_id": "3ème thermostat sous-jacent",
-          "climate_entity4_id": "4ème thermostat sous-jacent",
           "ac_mode": "AC mode ?",
-          "valve_entity_id": "1ère valve",
-          "valve_entity2_id": "2ème valve",
-          "valve_entity3_id": "3ème valve",
-          "valve_entity4_id": "4ème valve",
-          "auto_regulation_mode": "Auto-regulation",
+          "auto_regulation_mode": "Auto-régulation",
           "auto_regulation_dtemp": "Seuil de régulation",
           "auto_regulation_periode_min": "Période minimale de régulation",
-          "auto_regulation_use_device_temp": "Utiliser la température interne du sous-jacent",
+          "auto_regulation_use_device_temp": "Compenser la température interne du sous-jacent",
           "inverse_switch_command": "Inverser la commande",
-          "auto_fan_mode": " Auto fan mode"
+          "auto_fan_mode": " Auto ventilation mode",
+          "on_command_text": "Personnalisation des commandes d'allumage",
+          "vswitch_on_command": "Commande d'allumage (optionnel)",
+          "off_command_text": "Personnalisation des commandes d'extinction",
+          "vswitch_off_command": "Commande d'extinction (optionnel)"
         },
         "data_description": {
-          "heater_entity_id": "Entity id du 1er radiateur obligatoire",
-          "heater_entity2_id": "Optionnel entity id du 2ème radiateur",
-          "heater_entity3_id": "Optionnel entity id du 3ème radiateur",
-          "heater_entity4_id": "Optionnel entity id du 4ème radiateur",
+          "underlying_entity_ids": "La liste des équipements qui seront controlés par ce VTherm",
           "heater_keep_alive": "Intervalle de rafraichissement du switch en secondes. Laisser vide pour désactiver. À n'utiliser que pour les switchs qui le nécessite.",
           "proportional_function": "Algorithme à utiliser (Seul TPI est disponible pour l'instant)",
-          "climate_entity_id": "Entity id du thermostat sous-jacent",
-          "climate_entity2_id": "Entity id du 2ème thermostat sous-jacent",
-          "climate_entity3_id": "Entity id du 3ème thermostat sous-jacent",
-          "climate_entity4_id": "Entity id du 4ème thermostat sous-jacent",
           "ac_mode": "Utilisation du mode Air Conditionné (AC)",
-          "valve_entity_id": "Entity id de la 1ère valve",
-          "valve_entity2_id": "Entity id de la 2ème valve",
-          "valve_entity3_id": "Entity id de la 3ème valve",
-          "valve_entity4_id": "Entity id de la 4ème valve",
-          "auto_regulation_mode": "Ajustement automatique de la consigne",
-          "auto_regulation_dtemp": "Le seuil en ° (ou % pour les valves) en-dessous duquel la régulation ne sera pas envoyée",
+          "auto_regulation_mode": "Utilisation de l'auto-régulation faite par VTherm",
+          "auto_regulation_dtemp": "Le seuil en ° (ou % pour les vannes) en-dessous duquel la régulation ne sera pas envoyée",
           "auto_regulation_periode_min": "La durée en minutes entre deux mise à jour faites par la régulation",
-          "auto_regulation_use_device_temp": "Utiliser la temperature interne du sous-jacent pour accélérer l'auto-régulation",
+          "auto_regulation_use_device_temp": "Compenser la temperature interne du sous-jacent pour accélérer l'auto-régulation",
           "inverse_switch_command": "Inverse la commande du switch pour une installation avec fil pilote et diode",
-          "auto_fan_mode": "Active la ventilation automatiquement en cas d'écart important"
+          "auto_fan_mode": "Active la ventilation automatiquement en cas d'écart important",
+          "on_command_text": "Pour les sous-jacents de type `select` ou `climate`"
         }
       },
       "tpi": {
         "title": "TPI - {name}",
-        "description": "Attributs de l'algo Time Proportional Integral",
+        "description": "Attributs de l'algo Time Proportional Integral [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/algorithms.md#lalgorithme-tpi)",
         "data": {
           "tpi_coef_int": "coeff_int : Coefficient à utiliser pour le delta de température interne",
           "tpi_coef_ext": "coeff_ext : Coefficient à utiliser pour le delta de température externe"
@@ -373,17 +367,18 @@
       },
       "presets": {
         "title": "Pre-réglages - {name}",
-        "description": "Cochez pour que ce thermostat utilise les pré-réglages de la configuration centrale. Décochez pour utiliser des entités de température spécifiques",
+        "description": "Cochez pour que ce thermostat utilise les pré-réglages de la configuration centrale. Décochez pour utiliser des entités de température spécifiques [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-presets.md)",
         "data": {
           "use_presets_central_config": "Utiliser la configuration des pré-réglages centrale"
         }
       },
       "window": {
         "title": "Ouverture - {name}",
-        "description": "Coupe le radiateur si l'ouverture est ouverte.\nLaissez l'id d'entité vide pour utiliser la détection automatique.",
+        "description": "Coupe le radiateur si l'ouverture est ouverte.\nLaissez l'id d'entité vide pour utiliser la détection automatique [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-window.md)",
         "data": {
           "window_sensor_entity_id": "Détecteur d'ouverture (entity id)",
           "window_delay": "Délai avant extinction (secondes)",
+          "window_off_delay": "Délai de prise compte à la fermeture (secondes)",
           "window_auto_open_threshold": "Seuil haut de chute de température pour la détection automatique (en °/heure)",
           "window_auto_close_threshold": "Seuil bas de chute de température pour la fin de détection automatique (en °/heure)",
           "window_auto_max_duration": "Durée maximum d'une extinction automatique (en min)",
@@ -393,6 +388,7 @@
         "data_description": {
           "window_sensor_entity_id": "Laissez vide si vous n'avez de détecteur et pour utiliser la détection automatique",
           "window_delay": "Le délai (en secondes) avant que le changement du détecteur soit pris en compte",
+          "window_off_delay": "Le délai (en secondes) avant que le changement du détecteur soit pris en compte lors de la détection d'une fermeture. Laissez vide pour utiliser le même délai à l'ouveture et à la fermeture",
           "window_auto_open_threshold": "Valeur recommandée: entre 3 et 10. Laissez vide si vous n'utilisez pas la détection automatique",
           "window_auto_close_threshold": "Valeur recommandée: 0. Laissez vide si vous n'utilisez pas la détection automatique",
           "window_auto_max_duration": "Valeur recommandée: 60 (1 heure). Laissez vide si vous n'utilisez pas la détection automatique",
@@ -402,7 +398,7 @@
       },
       "motion": {
         "title": "Mouvement - {name}",
-        "description": "Gestion du mouvement. Le preset s'ajuste automatiquement si un mouvement est détecté\n'Preset mouvement' et 'Preset sans mouvement' doivent être choisis avec les preset à utiliser.",
+        "description": "Le preset s'ajuste automatiquement si un mouvement est détecté\n'Preset mouvement' et 'Preset sans mouvement' doivent être choisis avec les preset à utiliser [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-motion.md)",
         "data": {
           "motion_sensor_entity_id": "Détecteur de mouvement",
           "motion_delay": "Délai d'activation",
@@ -422,7 +418,7 @@
       },
       "power": {
         "title": "Puissance - {name}",
-        "description": "Gestion de la puissance. Sélectionne automatiquement le preset 'power' si la puissance consommée est supérieure à un maximum. Tous les capteurs et la puissance consommée par l'équipement doivent avoir la même unité de mesure (kW ou W).",
+        "description": "Sélectionne automatiquement le preset 'power' si la puissance consommée est supérieure à un maximum.\nDonnez les entity id des capteurs qui mesurent la puissance totale et la puissance max autorisée.\nEnsuite donnez la puissance de l'équipement.\nTous les capteurs et la puissance consommée par l'équipement doivent avoir la même unité de mesure (kW ou W) [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-power.md)",
         "data": {
           "power_sensor_entity_id": "Puissance totale",
           "max_power_sensor_entity_id": "Capteur de puissance Max (entity id)",
@@ -438,7 +434,7 @@
       },
       "presence": {
         "title": "Présence - {name}",
-        "description": "Donnez un capteur de présence (true si quelqu'un est présent) et les températures cibles à utiliser en cas d'abs.",
+        "description": "Donnez un capteur de présence (true si quelqu'un est présent) et les températures cibles à utiliser en cas d'absence [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-presence.md)",
         "data": {
           "presence_sensor_entity_id": "Capteur de présence",
           "use_presence_central_config": "Utiliser la configuration centrale des températures en cas d'absence. Décochez pour avoir des entités de température dédiées"
@@ -449,25 +445,25 @@
       },
       "advanced": {
         "title": "Avancés - {name}",
-        "description": "Paramètres avancés. Laissez les valeurs par défaut si vous ne savez pas ce que vous faites.\nCes paramètres peuvent induire des mauvais comportements du thermostat.",
+        "description": "Configuration des paramètres avancés. Laissez les valeurs par défaut si vous ne savez pas ce que vous faites.\nCes paramètres peuvent induire des mauvais comportements du thermostat [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-advanced.md)",
         "data": {
           "minimal_activation_delay": "Délai minimal d'activation",
-          "security_delay_min": "Délai maximal entre 2 mesures de températures",
-          "security_min_on_percent": "Pourcentage minimal de puissance",
-          "security_default_on_percent": "Pourcentage de puissance a utiliser en mode securité",
+          "safety_delay_min": "Délai maximal entre 2 mesures de températures",
+          "safety_min_on_percent": "Pourcentage minimal de puissance",
+          "safety_default_on_percent": "Pourcentage de puissance a utiliser en mode securité",
           "use_advanced_central_config": "Utiliser la configuration centrale avancée"
         },
         "data_description": {
           "minimal_activation_delay": "Délai en seondes en-dessous duquel l'équipement ne sera pas activé",
-          "security_delay_min": "Délai maximal autorisé en minutes entre 2 mesures de températures. Au-dessus de ce délai, le thermostat se mettra en position de sécurité",
-          "security_min_on_percent": "Seuil minimal de pourcentage de chauffage en-dessous duquel le préréglage sécurité ne sera jamais activé",
-          "security_default_on_percent": "Valeur par défaut pour le pourcentage de chauffage en mode sécurité. Mettre 0 pour éteindre le radiateur en mode sécurité",
+          "safety_delay_min": "Délai maximal autorisé en minutes entre 2 mesures de températures. Au-dessus de ce délai, le thermostat se mettra en position de sécurité",
+          "safety_min_on_percent": "Seuil minimal de pourcentage de chauffage en-dessous duquel le préréglage sécurité ne sera jamais activé",
+          "safety_default_on_percent": "Valeur par défaut pour le pourcentage de chauffage en mode sécurité. Mettre 0 pour éteindre le radiateur en mode sécurité",
           "use_advanced_central_config": "Cochez pour utiliser la configuration centrale avancée. Décochez et saisissez les attributs pour utiliser une configuration spécifique avancée"
         }
       },
       "central_boiler": {
         "title": "Contrôle de la chaudière centrale - {name}",
-        "description": "Donnez les services à appeler pour allumer/éteindre la chaudière centrale. Laissez vide, si aucun appel de service ne doit être effectué (dans ce cas, vous devrez gérer vous même l'allumage/extinction de votre chaudière centrale). Le service a appelé doit être formatté comme suit: `entity_id/service_name[/attribut:valeur]` (/attribut:valeur est facultatif)\nPar exemple:\n- pour allumer un switch: `switch.controle_chaudiere/switch.turn_on`\n- pour éteindre un switch: `switch.controle_chaudiere/switch.turn_off`\n- pour programmer la chaudière sur 25° et ainsi forcer son allumage: `climate.thermostat_chaudiere/climate.set_temperature/temperature:25`\n- pour envoyer 10° à la chaudière et ainsi forcer son extinction: `climate.thermostat_chaudiere/climate.set_temperature/temperature:10`",
+        "description": "Donnez les services à appeler pour allumer/éteindre la chaudière centrale. Laissez vide, si aucun appel de service ne doit être effectué (dans ce cas, vous devrez gérer vous même l'allumage/extinction de votre chaudière centrale). Le service a appelé doit être formatté comme suit: `entity_id/service_name[/attribut:valeur]` (/attribut:valeur est facultatif)\nPar exemple:\n- pour allumer un switch: `switch.controle_chaudiere/switch.turn_on`\n- pour éteindre un switch: `switch.controle_chaudiere/switch.turn_off`\n- pour programmer la chaudière sur 25° et ainsi forcer son allumage: `climate.thermostat_chaudiere/climate.set_temperature/temperature:25`\n- pour envoyer 10° à la chaudière et ainsi forcer son extinction: `climate.thermostat_chaudiere/climate.set_temperature/temperature:10` [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/feature-central-boiler.md)",
         "data": {
           "central_boiler_activation_service": "Commande pour allumer",
           "central_boiler_deactivation_service": "Commande pour éteindre"
@@ -476,6 +472,24 @@
           "central_boiler_activation_service": "Commande à éxecuter pour allumer la chaudière centrale au format entity_id/service_name[/attribut:valeur]",
           "central_boiler_deactivation_service": "Commande à éxecuter pour étiendre la chaudière centrale au format entity_id/service_name[/attribut:valeur]"
         }
+      },
+      "valve_regulation": {
+        "title": "Auto-régulation par vanne - {name}",
+        "description": "Configuration de l'auto-régulation par controle direct de la vanne [![?](https://img.icons8.com/color/18/help.png)](https://github.com/jmcollin78/versatile_thermostat/blob/main/documentation/fr/self-regulation.md#auto-régulation-par-contrôle-direct-de-la-vanne)",
+        "data": {
+          "offset_calibration_entity_ids": "Entités de 'calibrage du décalage''",
+          "opening_degree_entity_ids": "Entités 'ouverture de vanne'",
+          "closing_degree_entity_ids": "Entités 'fermeture de la vanne'",
+          "proportional_function": "Algorithme",
+          "min_opening_degrees": "Ouvertures minimales"
+        },
+        "data_description": {
+          "offset_calibration_entity_ids": "La liste des entités 'calibrage du décalage' (offset calibration). Configurez le si votre TRV possède cette fonction pour une meilleure régulation. Il doit y en avoir une par entité climate sous-jacente",
+          "opening_degree_entity_ids": "La liste des entités 'ouverture de vanne'. Il doit y en avoir une par entité climate sous-jacente",
+          "closing_degree_entity_ids": "La liste des entités 'fermeture de la vanne'. Configurez le si votre TRV possède cette fonction pour une meilleure régulation. Il doit y en avoir une par entité climate sous-jacente",
+          "proportional_function": "Algorithme à utiliser (seulement TPI est disponible)",
+          "min_opening_degrees": "Une liste séparée par des virgules de minimum d'ouverture. Valeur par défaut : 0. Exemple : 20, 25, 30"
+        }
       }
     },
     "error": {
@@ -483,7 +497,10 @@
       "unknown_entity": "entity id inconnu",
       "window_open_detection_method": "Une seule méthode de détection des ouvertures ouvertes doit être utilisée. Utilisez le détecteur d'ouverture ou les seuils de température mais pas les deux.",
       "no_central_config": "Vous ne pouvez pas cocher 'Utiliser la configuration centrale' car aucune configuration centrale n'a été trouvée. Vous devez créer un Versatile Thermostat de type 'Central Configuration' pour pouvoir l'utiliser.",
-      "service_configuration_format": "Mauvais format de la configuration du service"
+      "service_configuration_format": "Mauvais format de la configuration du service",
+      "valve_regulation_nb_entities_incorrect": "Le nombre d'entités pour la régulation par vanne doit être égal au nombre d'entité sous-jacentes",
+      "min_opening_degrees_format": "Une liste d'entiers positifs séparés par des ',' est attendu. Exemple : 20, 25, 30",
+      "vswitch_configuration_incorrect": "La configuration de la personnalisation des commandes est incorrecte. Elle est obligatoire pour les sous-jacents non switch et le format doit être 'service_name[/attribut:valeur]'. Plus d'informations dans le README."
     },
     "abort": {
       "already_configured": "Le device est déjà configuré"
@@ -495,7 +512,7 @@
         "thermostat_central_config": "Configuration centrale",
         "thermostat_over_switch": "Thermostat sur un switch",
         "thermostat_over_climate": "Thermostat sur un autre thermostat",
-        "thermostat_over_valve": "Thermostat sur une valve"
+        "thermostat_over_valve": "Thermostat sur une vanne"
       }
     },
     "auto_regulation_mode": {
@@ -505,7 +522,8 @@
         "auto_regulation_medium": "Moyenne",
         "auto_regulation_light": "Légère",
         "auto_regulation_expert": "Expert",
-        "auto_regulation_none": "Aucune"
+        "auto_regulation_none": "Aucune",
+        "auto_regulation_valve": "Contrôle direct de la vanne"
       }
     },
     "auto_fan_mode": {
@@ -532,6 +550,14 @@
         "comfort": "Confort",
         "boost": "Renforcé (boost)"
       }
+    },
+    "auto_start_stop": {
+      "options": {
+        "auto_start_stop_none": "No auto start/stop",
+        "auto_start_stop_slow": "Slow detection",
+        "auto_start_stop_medium": "Medium detection",
+        "auto_start_stop_fast": "Fast detection"
+      }
     }
   },
   "entity": {
@@ -541,8 +567,9 @@
           "preset_mode": {
             "state": {
               "power": "Délestage",
-              "security": "Sécurité",
-              "none": "Manuel"
+              "safety": "Sécurité",
+              "none": "Manuel",
+              "frost": "Hors Gel"
             }
           }
         }

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": {
@@ -143,15 +143,15 @@
         "description": "Configurazione avanzata dei parametri. Lasciare i valori predefiniti se non conoscete cosa state modificando.\nQuesti parametri possono determinare una pessima gestione della temperatura e della potenza.",
         "data": {
           "minimal_activation_delay": "Ritardo minimo di accensione",
-          "security_delay_min": "Ritardo di sicurezza (in minuti)",
-          "security_min_on_percent": "Percentuale minima di potenza per la modalità di sicurezza",
-          "security_default_on_percent": "Percentuale di potenza per la modalità di sicurezza"
+          "safety_delay_min": "Ritardo di sicurezza (in minuti)",
+          "safety_min_on_percent": "Percentuale minima di potenza per la modalità di sicurezza",
+          "safety_default_on_percent": "Percentuale di potenza per la modalità di sicurezza"
         },
         "data_description": {
           "minimal_activation_delay": "Ritardo in secondi al di sotto del quale l'apparecchiatura non verrà attivata",
-          "security_delay_min": "Ritardo massimo consentito in minuti tra due misure di temperatura. Al di sopra di questo ritardo, il termostato passerà allo stato di sicurezza",
-          "security_min_on_percent": "Soglia percentuale minima di riscaldamento al di sotto della quale il preset di sicurezza non verrà mai attivato",
-          "security_default_on_percent": "Valore percentuale predefinito della potenza di riscaldamento nella modalità di sicurezza. Impostare a 0 per spegnere il riscaldatore nella modalità di sicurezza"
+          "safety_delay_min": "Ritardo massimo consentito in minuti tra due misure di temperatura. Al di sopra di questo ritardo, il termostato passerà allo stato di sicurezza",
+          "safety_min_on_percent": "Soglia percentuale minima di riscaldamento al di sotto della quale il preset di sicurezza non verrà mai attivato",
+          "safety_default_on_percent": "Valore percentuale predefinito della potenza di riscaldamento nella modalità di sicurezza. Impostare a 0 per spegnere il riscaldatore nella modalità di sicurezza"
         }
       }
     },
@@ -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": {
@@ -307,15 +307,15 @@
         "description": "Configurazione avanzata dei parametri. Lasciare i valori predefiniti se non conoscete cosa state modificando.\nQuesti parametri possono determinare una pessima gestione della temperatura e della potenza.",
         "data": {
           "minimal_activation_delay": "Ritardo minimo di accensione",
-          "security_delay_min": "Ritardo di sicurezza (in minuti)",
-          "security_min_on_percent": "Percentuale minima di potenza per la modalità di sicurezza",
-          "security_default_on_percent": "Percentuale di potenza per la modalità di sicurezza"
+          "safety_delay_min": "Ritardo di sicurezza (in minuti)",
+          "safety_min_on_percent": "Percentuale minima di potenza per la modalità di sicurezza",
+          "safety_default_on_percent": "Percentuale di potenza per la modalità di sicurezza"
         },
         "data_description": {
           "minimal_activation_delay": "Ritardo in secondi al di sotto del quale l'apparecchiatura non verrà attivata",
-          "security_delay_min": "Ritardo massimo consentito in minuti tra due misure di temperatura. Al di sopra di questo ritardo, il termostato passerà allo stato di sicurezza",
-          "security_min_on_percent": "Soglia percentuale minima di riscaldamento al di sotto della quale il preset di sicurezza non verrà mai attivato",
-          "security_default_on_percent": "Valore percentuale predefinito della potenza di riscaldamento nella modalità di sicurezza. Impostare a 0 per spegnere il riscaldatore nella modalità di sicurezza"
+          "safety_delay_min": "Ritardo massimo consentito in minuti tra due misure di temperatura. Al di sopra di questo ritardo, il termostato passerà allo stato di sicurezza",
+          "safety_min_on_percent": "Soglia percentuale minima di riscaldamento al di sotto della quale il preset di sicurezza non verrà mai attivato",
+          "safety_default_on_percent": "Valore percentuale predefinito della potenza di riscaldamento nella modalità di sicurezza. Impostare a 0 per spegnere il riscaldatore nella modalità di sicurezza"
         }
       }
     },
@@ -364,7 +364,8 @@
             "state": {
               "power": "Ripartizione",
               "security": "Sicurezza",
-              "none": "Manuale"
+              "none": "Manuale",
+              "frost": "Gelo"
             }
           }
         }

custom_components/versatile_thermostat/translations/sk.json

@@ -211,16 +211,16 @@
         "description": "Konfigurácia pokročilých parametrov. Ak neviete, čo robíte, ponechajte predvolené hodnoty.\nTento parameter môže viesť k veľmi zlej regulácii teploty alebo výkonu.",
         "data": {
           "minimal_activation_delay": "Minimálne oneskorenie aktivácie",
-          "security_delay_min": "Bezpečnostné oneskorenie (v minútach)",
-          "security_min_on_percent": "Minimálne percento výkonu na aktiváciu bezpečnostného režimu",
-          "security_default_on_percent": "Percento výkonu na použitie v bezpečnostnom režime",
+          "safety_delay_min": "Bezpečnostné oneskorenie (v minútach)",
+          "safety_min_on_percent": "Minimálne percento výkonu na aktiváciu bezpečnostného režimu",
+          "safety_default_on_percent": "Percento výkonu na použitie v bezpečnostnom režime",
           "use_advanced_central_config": "Použite centrálnu rozšírenú konfiguráciu"
         },
         "data_description": {
           "minimal_activation_delay": "Oneskorenie v sekundách, pri ktorom sa zariadenie neaktivuje",
-          "security_delay_min": "Maximálne povolené oneskorenie v minútach medzi dvoma meraniami teploty. Po uplynutí tohto oneskorenia sa termostat prepne do bezpečnostného vypnutého stavu",
-          "security_min_on_percent": "Minimálna percentuálna hodnota ohrevu pre aktiváciu prednastavenej bezpečnosti. Pod týmto percentom výkonu termostat neprejde do prednastavenia zabezpečenia",
-          "security_default_on_percent": "Predvolená percentuálna hodnota vykurovacieho výkonu v bezpečnostnej predvoľbe. Nastavte na 0, ak chcete vypnúť ohrievač v zabezpečenom stave",
+          "safety_delay_min": "Maximálne povolené oneskorenie v minútach medzi dvoma meraniami teploty. Po uplynutí tohto oneskorenia sa termostat prepne do bezpečnostného vypnutého stavu",
+          "safety_min_on_percent": "Minimálna percentuálna hodnota ohrevu pre aktiváciu prednastavenej bezpečnosti. Pod týmto percentom výkonu termostat neprejde do prednastavenia zabezpečenia",
+          "safety_default_on_percent": "Predvolená percentuálna hodnota vykurovacieho výkonu v bezpečnostnej predvoľbe. Nastavte na 0, ak chcete vypnúť ohrievač v zabezpečenom stave",
           "use_advanced_central_config": "Začiarknite, ak chcete použiť centrálnu rozšírenú konfiguráciu. Zrušte začiarknutie, ak chcete použiť špecifickú rozšírenú konfiguráciu pre tento VTherm"
         }
       }
@@ -446,16 +446,16 @@
         "description": "Konfigurácia pokročilých parametrov. Ak neviete, čo robíte, ponechajte predvolené hodnoty.\nTento parameter môže viesť k veľmi zlej regulácii teploty alebo výkonu.",
         "data": {
           "minimal_activation_delay": "Minimálne oneskorenie aktivácie",
-          "security_delay_min": "Bezpečnostné oneskorenie (v minútach)",
-          "security_min_on_percent": "Minimálne percento výkonu pre bezpečnostný režim",
-          "security_default_on_percent": "Percento výkonu na použitie v bezpečnostnom režime",
+          "safety_delay_min": "Bezpečnostné oneskorenie (v minútach)",
+          "safety_min_on_percent": "Minimálne percento výkonu pre bezpečnostný režim",
+          "safety_default_on_percent": "Percento výkonu na použitie v bezpečnostnom režime",
           "use_advanced_central_config": "Použite centrálnu rozšírenú konfiguráciu"
         },
         "data_description": {
           "minimal_activation_delay": "Oneskorenie v sekundách, pri ktorom sa zariadenie neaktivuje",
-          "security_delay_min": "Maximálne povolené oneskorenie v minútach medzi dvoma meraniami teploty. Po uplynutí tohto oneskorenia sa termostat prepne do bezpečnostného vypnutého stavu",
-          "security_min_on_percent": "Minimálna percentuálna hodnota ohrevu pre aktiváciu prednastavenej bezpečnosti. Pod týmto percentom výkonu termostat neprejde do prednastavenia zabezpečenia",
-          "security_default_on_percent": "Predvolená percentuálna hodnota vykurovacieho výkonu v bezpečnostnej predvoľbe. Nastavte na 0, ak chcete vypnúť ohrievač v zabezpečenom stave",
+          "safety_delay_min": "Maximálne povolené oneskorenie v minútach medzi dvoma meraniami teploty. Po uplynutí tohto oneskorenia sa termostat prepne do bezpečnostného vypnutého stavu",
+          "safety_min_on_percent": "Minimálna percentuálna hodnota ohrevu pre aktiváciu prednastavenej bezpečnosti. Pod týmto percentom výkonu termostat neprejde do prednastavenia zabezpečenia",
+          "safety_default_on_percent": "Predvolená percentuálna hodnota vykurovacieho výkonu v bezpečnostnej predvoľbe. Nastavte na 0, ak chcete vypnúť ohrievač v zabezpečenom stave",
           "use_advanced_central_config": "Začiarknite, ak chcete použiť centrálnu rozšírenú konfiguráciu. Zrušte začiarknutie, ak chcete použiť špecifickú rozšírenú konfiguráciu pre tento VTherm"
         }
       }
@@ -578,4 +578,4 @@
       }
     }
   }
-}
+}

custom_components/versatile_thermostat/underlyings.py

@@ -1,11 +1,13 @@
-# pylint: disable=unused-argument, line-too-long
+# pylint: disable=unused-argument, line-too-long, too-many-lines
 
 """ Underlying entities classes """
 import logging
-from typing import Any
+import re
+from typing import Any, Dict, Tuple
+
 from enum import StrEnum
 
-from homeassistant.const import ATTR_ENTITY_ID, STATE_ON, STATE_UNAVAILABLE
+from homeassistant.const import ATTR_ENTITY_ID, STATE_ON, STATE_OFF, STATE_UNAVAILABLE
 from homeassistant.core import State
 
 from homeassistant.exceptions import ServiceNotFound
@@ -32,7 +34,7 @@ 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 .const import UnknownEntity, overrides, get_safe_float
 from .keep_alive import IntervalCaller
 
 _LOGGER = logging.getLogger(__name__)
@@ -53,6 +55,9 @@ class UnderlyingEntityType(StrEnum):
     # a valve
     VALVE = "valve"
 
+    # a direct valve regulation
+    VALVE_REGULATION = "valve_regulation"
+
 
 class UnderlyingEntity:
     """Represent a underlying device which could be a switch or a climate"""
@@ -62,6 +67,7 @@ class UnderlyingEntity:
     _thermostat: Any
     _entity_id: str
     _type: UnderlyingEntityType
+    _hvac_mode: HVACMode | None
 
     def __init__(
         self,
@@ -75,6 +81,7 @@ class UnderlyingEntity:
         self._thermostat = thermostat
         self._type = entity_type
         self._entity_id = entity_id
+        self._hvac_mode = None
 
     def __str__(self):
         return str(self._thermostat) + "-" + self._entity_id
@@ -100,13 +107,24 @@ class UnderlyingEntity:
 
     async def set_hvac_mode(self, hvac_mode: HVACMode):
         """Set the HVACmode"""
+        self._hvac_mode = hvac_mode
         return
 
+    @property
+    def hvac_mode(self) -> HVACMode | None:
+        """Return the current hvac_mode"""
+        return self._hvac_mode
+
     @property
     def is_device_active(self) -> bool | None:
         """If the toggleable device is currently active."""
         return None
 
+    @property
+    def hvac_action(self) -> HVACAction:
+        """Calculate a hvac_action"""
+        return HVACAction.HEATING if self.is_device_active is True else HVACAction.OFF
+
     async def set_temperature(self, temperature, max_temp, min_temp):
         """Set the target temperature"""
         return
@@ -174,22 +192,27 @@ class UnderlyingEntity:
         """capping of the value send to the underlying eqt"""
         return value
 
+    async def turn_off_and_cancel_cycle(self):
+        """Turn off and cancel eventual running cycle"""
+        self._cancel_cycle()
+        await self.turn_off()
+
+    async def check_overpowering(self) -> bool:
+        """Check that a underlying can be turned on, else
+        activate the overpowering state of the VTherm associated.
+        Returns True if the check is ok (no overpowering needed)"""
+        if not await self._thermostat.power_manager.check_power_available():
+            _LOGGER.debug("%s - overpowering is detected", self)
+            await self._thermostat.power_manager.set_overpowering(True)
+            return False
+        return True
+
 
 class UnderlyingSwitch(UnderlyingEntity):
     """Represent a underlying switch"""
 
-    _initialDelaySec: int
-    _on_time_sec: int
-    _off_time_sec: int
-    _hvac_mode: HVACMode
-
     def __init__(
-        self,
-        hass: HomeAssistant,
-        thermostat: Any,
-        switch_entity_id: str,
-        initial_delay_sec: int,
-        keep_alive_sec: float,
+        self, hass: HomeAssistant, thermostat: Any, switch_entity_id: str, initial_delay_sec: int, keep_alive_sec: float, vswitch_on: str = None, vswitch_off: str = None
     ) -> None:
         """Initialize the underlying switch"""
 
@@ -204,8 +227,15 @@ class UnderlyingSwitch(UnderlyingEntity):
         self._should_relaunch_control_heating = False
         self._on_time_sec = 0
         self._off_time_sec = 0
-        self._hvac_mode = None
         self._keep_alive = IntervalCaller(hass, keep_alive_sec)
+        self._vswitch_on = vswitch_on.strip() if vswitch_on else None
+        self._vswitch_off = vswitch_off.strip() if vswitch_off else None
+        self._domain = self._entity_id.split(".")[0]
+        # build command
+        command, data, state_on = self.build_command(use_on=True)
+        self._on_command = {"command": command, "data": data, "state": state_on}
+        command, data, state_off = self.build_command(use_on=False)
+        self._off_command = {"command": command, "data": data, "state": state_off}
 
     @property
     def initial_delay_sec(self):
@@ -214,7 +244,7 @@ class UnderlyingSwitch(UnderlyingEntity):
 
     @overrides
     @property
-    def is_inversed(self):
+    def is_inversed(self) -> bool:
         """Tells if the switch command should be inversed"""
         return self._thermostat.is_inversed
 
@@ -237,8 +267,8 @@ class UnderlyingSwitch(UnderlyingEntity):
                 await self.turn_off()
             self._cancel_cycle()
 
-        if self._hvac_mode != hvac_mode:
-            self._hvac_mode = hvac_mode
+        if self.hvac_mode != hvac_mode:
+            await super().set_hvac_mode(hvac_mode)
             return True
         else:
             return False
@@ -246,10 +276,15 @@ class UnderlyingSwitch(UnderlyingEntity):
     @property
     def is_device_active(self):
         """If the toggleable device is currently active."""
-        real_state = self._hass.states.is_state(self._entity_id, STATE_ON)
-        return (self.is_inversed and not real_state) or (
-            not self.is_inversed and real_state
-        )
+        # real_state = self._hass.states.is_state(self._entity_id, STATE_ON)
+        # return (self.is_inversed and not real_state) or (
+        #    not self.is_inversed and real_state
+        # )
+        is_on = self._hass.states.is_state(self._entity_id, self._on_command.get("state"))
+        if self.is_inversed:
+            return not is_on
+
+        return is_on
 
     async def _keep_alive_callback(self):
         """Keep alive: Turn on if already turned on, turn off if already turned off."""
@@ -276,18 +311,48 @@ class UnderlyingSwitch(UnderlyingEntity):
                 )
             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
+    def build_command(self, use_on: bool) -> Tuple[str, Dict[str, str]]:
+        """Build a command and returns a command and a dict as data"""
+
+        value = None
+        data = {ATTR_ENTITY_ID: self._entity_id}
+        take_on = (use_on and not self.is_inversed) or (not use_on and self.is_inversed)
+        vswitch = self._vswitch_on if take_on else self._vswitch_off
+        if vswitch:
+            pattern = r"^(?P<command>[^\s/]+)(?:/(?P<argument>[^\s:]+)(?::(?P<value>[^\s]+))?)?$"
+            match = re.match(pattern, vswitch)
+
+            if match:
+                # Extraire les groupes nommés
+                command = match.group("command")
+                argument = match.group("argument")
+                value = match.group("value")
+                if argument is not None and value is not None:
+                    data.update({argument: value})
+            else:
+                raise ValueError(f"Invalid input format: {vswitch}. Must be conform to 'command[/argument[:value]]'")
+
+        else:
+            command = SERVICE_TURN_ON if take_on else SERVICE_TURN_OFF
+
+        if value is None:
+            value = STATE_ON if take_on else STATE_OFF
+
+        return command, data, value
+
     async def turn_off(self):
         """Turn heater toggleable device off."""
         self._keep_alive.cancel()  # Cancel early to avoid a turn_on/turn_off race condition
         _LOGGER.debug("%s - Stopping underlying entity %s", self, self._entity_id)
-        command = SERVICE_TURN_OFF if not self.is_inversed else SERVICE_TURN_ON
-        domain = self._entity_id.split(".")[0]
+
+        command = self._off_command.get("command")
+        data = self._off_command.get("data")
+
         # This may fails if called after shutdown
         try:
             try:
-                data = {ATTR_ENTITY_ID: self._entity_id}
-                await self._hass.services.async_call(domain, command, data)
+                _LOGGER.debug("%s - Sending command %s with data=%s", self, command, data)
+                await self._hass.services.async_call(self._domain, command, data)
                 self._keep_alive.set_async_action(self._keep_alive_callback)
             except Exception:
                 self._keep_alive.cancel()
@@ -299,13 +364,18 @@ class UnderlyingSwitch(UnderlyingEntity):
         """Turn heater toggleable device on."""
         self._keep_alive.cancel()  # Cancel early to avoid a turn_on/turn_off race condition
         _LOGGER.debug("%s - Starting underlying entity %s", self, self._entity_id)
-        command = SERVICE_TURN_ON if not self.is_inversed else SERVICE_TURN_OFF
-        domain = self._entity_id.split(".")[0]
+
+        if not await self.check_overpowering():
+            return False
+
+        command = self._on_command.get("command")
+        data = self._on_command.get("data")
         try:
             try:
-                data = {ATTR_ENTITY_ID: self._entity_id}
-                await self._hass.services.async_call(domain, command, data)
+                _LOGGER.debug("%s - Sending command %s with data=%s", self, command, data)
+                await self._hass.services.async_call(self._domain, command, data)
                 self._keep_alive.set_async_action(self._keep_alive_callback)
+                return True
             except Exception:
                 self._keep_alive.cancel()
                 raise
@@ -395,11 +465,8 @@ class UnderlyingSwitch(UnderlyingEntity):
                 await self.turn_off()
             return
 
-        if await self._thermostat.check_overpowering():
-            _LOGGER.debug("%s - End of cycle (3)", self)
-            return
         # safety mode could have change the on_time percent
-        await self._thermostat.check_safety()
+        await self._thermostat.safety_manager.refresh_state()
         time = self._on_time_sec
 
         action_label = "start"
@@ -412,7 +479,8 @@ class UnderlyingSwitch(UnderlyingEntity):
                 time // 60,
                 time % 60,
             )
-            await self.turn_on()
+            if not await self.turn_on():
+                return
         else:
             _LOGGER.debug("%s - No action on heater cause duration is 0", self)
         self._async_cancel_cycle = self.call_later(
@@ -488,6 +556,7 @@ class UnderlyingClimate(UnderlyingEntity):
             entity_id=climate_entity_id,
         )
         self._underlying_climate = None
+        self._last_sent_temperature = None
 
     def find_underlying_climate(self) -> ClimateEntity:
         """Find the underlying climate entity"""
@@ -536,6 +605,10 @@ class UnderlyingClimate(UnderlyingEntity):
             )
             return False
 
+        # When turning on a climate, check that power is available
+        if hvac_mode in (HVACMode.HEAT, HVACMode.COOL) and not await self.check_overpowering():
+            return False
+
         data = {ATTR_ENTITY_ID: self._entity_id, "hvac_mode": hvac_mode}
         await self._hass.services.async_call(
             CLIMATE_DOMAIN,
@@ -549,14 +622,11 @@ class UnderlyingClimate(UnderlyingEntity):
     def is_device_active(self):
         """If the toggleable device is currently active."""
         if self.is_initialized:
-            return (
-                self._underlying_climate.hvac_mode != HVACMode.OFF
-                and self._underlying_climate.hvac_action
-                not in [
-                    HVACAction.IDLE,
-                    HVACAction.OFF,
-                ]
-            )
+            return self.hvac_mode != HVACMode.OFF and self.hvac_action not in [
+                HVACAction.IDLE,
+                HVACAction.OFF,
+                None,
+            ]
         else:
             return None
 
@@ -577,7 +647,7 @@ class UnderlyingClimate(UnderlyingEntity):
 
     async def set_humidity(self, humidity: int):
         """Set new target humidity."""
-        _LOGGER.info("%s - Set fan mode: %s", self, humidity)
+        _LOGGER.info("%s - Set humidity: %s", self, humidity)
         if not self.is_initialized:
             return
         data = {
@@ -593,7 +663,7 @@ class UnderlyingClimate(UnderlyingEntity):
 
     async def set_swing_mode(self, swing_mode):
         """Set new target swing operation."""
-        _LOGGER.info("%s - Set fan mode: %s", self, swing_mode)
+        _LOGGER.info("%s - Set swing mode: %s", self, swing_mode)
         if not self.is_initialized:
             return
         data = {
@@ -612,25 +682,75 @@ class UnderlyingClimate(UnderlyingEntity):
         if not self.is_initialized:
             return
 
+        # Issue 508 we have to take care of service set_temperature or set_range
+        target_temp = self.cap_sent_value(temperature)
         data = {
             ATTR_ENTITY_ID: self._entity_id,
-            "temperature": self.cap_sent_value(temperature),
-            "target_temp_high": max_temp,
-            "target_temp_low": min_temp,
         }
 
+        _LOGGER.info("%s - Set setpoint temperature to: %s", self, target_temp)
+
+        # Issue 807 add TARGET_TEMPERATURE only if in the features
+        if ClimateEntityFeature.TARGET_TEMPERATURE_RANGE in self._underlying_climate.supported_features:
+            data.update(
+                {
+                    "target_temp_high": target_temp,
+                    "target_temp_low": target_temp,
+                }
+            )
+
+        if ClimateEntityFeature.TARGET_TEMPERATURE in self._underlying_climate.supported_features:
+            data["temperature"] = target_temp
+
         await self._hass.services.async_call(
             CLIMATE_DOMAIN,
             SERVICE_SET_TEMPERATURE,
             data,
         )
 
+        self._last_sent_temperature = target_temp
+        _LOGGER.debug("%s - Last_sent_temperature is now: %s", self, self._last_sent_temperature)
+
+    @property
+    def last_sent_temperature(self) -> float | None:
+        """Get the last send temperature. None if no temperature have been sent yet"""
+        return self._last_sent_temperature
+
     @property
     def hvac_action(self) -> HVACAction | None:
         """Get the hvac action of the underlying"""
         if not self.is_initialized:
             return None
-        return self._underlying_climate.hvac_action
+
+        hvac_action = self._underlying_climate.hvac_action
+        if hvac_action is None:
+            target = (
+                self.underlying_target_temperature
+                or self._thermostat.target_temperature
+            )
+            current = (
+                self.underlying_current_temperature
+                or self._thermostat.current_temperature
+            )
+            hvac_mode = self.hvac_mode
+
+            _LOGGER.debug(
+                "%s - hvac_action simulation target=%s, current=%s, hvac_mode=%s",
+                self,
+                target,
+                current,
+                hvac_mode,
+            )
+            hvac_action = HVACAction.IDLE
+            if target is not None and current is not None:
+                dtemp = target - current
+
+                if hvac_mode == HVACMode.COOL and dtemp < 0:
+                    hvac_action = HVACAction.COOLING
+                elif hvac_mode in [HVACMode.HEAT, HVACMode.HEAT_COOL] and dtemp > 0:
+                    hvac_action = HVACAction.HEATING
+
+        return hvac_action
 
     @property
     def hvac_mode(self) -> HVACMode | None:
@@ -667,6 +787,13 @@ class UnderlyingClimate(UnderlyingEntity):
             return []
         return self._underlying_climate.hvac_modes
 
+    @property
+    def current_humidity(self) -> float | None:
+        """Get the humidity"""
+        if not self.is_initialized:
+            return None
+        return self._underlying_climate.current_humidity
+
     @property
     def fan_modes(self) -> list[str]:
         """Get the fan_modes"""
@@ -710,11 +837,19 @@ class UnderlyingClimate(UnderlyingEntity):
         return self._underlying_climate.target_temperature_low
 
     @property
-    def is_aux_heat(self) -> bool:
-        """Get the is_aux_heat"""
+    def underlying_target_temperature(self) -> float:
+        """Get the target_temperature"""
         if not self.is_initialized:
-            return False
-        return self._underlying_climate.is_aux_heat
+            return None
+
+        if not hasattr(self._underlying_climate, "target_temperature"):
+            return None
+        else:
+            return self._underlying_climate.target_temperature
+
+        # return self._hass.states.get(self._entity_id).attributes.get(
+        #    "target_temperature"
+        # )
 
     @property
     def underlying_current_temperature(self) -> float | None:
@@ -725,8 +860,17 @@ class UnderlyingClimate(UnderlyingEntity):
 
         if not hasattr(self._underlying_climate, "current_temperature"):
             return None
+        else:
+            return self._underlying_climate.current_temperature
 
-        return self._hass.states.get(self._entity_id).attributes.get("current_temperature")
+        # return self._hass.states.get(self._entity_id).attributes.get("current_temperature")
+
+    @property
+    def is_aux_heat(self) -> bool:
+        """Get the is_aux_heat"""
+        if not self.is_initialized:
+            return False
+        return self._underlying_climate.is_aux_heat
 
     def turn_aux_heat_on(self) -> None:
         """Turn auxiliary heater on."""
@@ -784,11 +928,16 @@ class UnderlyingValve(UnderlyingEntity):
     _hvac_mode: HVACMode
     # This is the percentage of opening int integer (from 0 to 100)
     _percent_open: int
+    _last_sent_temperature = None
 
     def __init__(
-        self, hass: HomeAssistant, thermostat: Any, valve_entity_id: str
+        self,
+        hass: HomeAssistant,
+        thermostat: Any,
+        valve_entity_id: str,
+        entity_type: UnderlyingEntityType = UnderlyingEntityType.VALVE,
     ) -> None:
-        """Initialize the underlying switch"""
+        """Initialize the underlying valve"""
 
         super().__init__(
             hass=hass,
@@ -799,16 +948,15 @@ class UnderlyingValve(UnderlyingEntity):
         self._async_cancel_cycle = None
         self._should_relaunch_control_heating = False
         self._hvac_mode = None
-        self._percent_open = self._thermostat.valve_open_percent
+        self._percent_open = None  # self._thermostat.valve_open_percent
         self._valve_entity_id = valve_entity_id
 
-    async def send_percent_open(self):
-        """Send the percent open to the underlying valve"""
-        # This may fails if called after shutdown
+    async def _send_value_to_number(self, number_entity_id: str, value: int):
+        """Send a value to a number entity"""
         try:
-            data = {"value": self._percent_open}
-            target = {ATTR_ENTITY_ID: self._entity_id}
-            domain = self._entity_id.split(".")[0]
+            data = {"value": value}
+            target = {ATTR_ENTITY_ID: number_entity_id}
+            domain = number_entity_id.split(".")[0]
             await self._hass.services.async_call(
                 domain=domain,
                 service=SERVICE_SET_VALUE,
@@ -820,6 +968,11 @@ class UnderlyingValve(UnderlyingEntity):
             # This could happens in unit test if input_number domain is not yet loaded
             # raise err
 
+    async def send_percent_open(self):
+        """Send the percent open to the underlying valve"""
+        # This may fails if called after shutdown
+        return await self._send_value_to_number(self._entity_id, self._percent_open)
+
     async def turn_off(self):
         """Turn heater toggleable device off."""
         _LOGGER.debug("%s - Stopping underlying valve entity %s", self, self._entity_id)
@@ -831,7 +984,7 @@ class UnderlyingValve(UnderlyingEntity):
 
     async def turn_on(self):
         """Nothing to do for Valve because it cannot be turned on"""
-        self.set_valve_open_percent()
+        await self.set_valve_open_percent()
 
     async def set_hvac_mode(self, hvac_mode: HVACMode) -> bool:
         """Set the HVACmode. Returns true if something have change"""
@@ -869,9 +1022,8 @@ class UnderlyingValve(UnderlyingEntity):
         force=False,
     ):
         """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()
+        # if force:
+        await self.set_valve_open_percent()
 
     @overrides
     def cap_sent_value(self, value) -> float:
@@ -904,7 +1056,7 @@ class UnderlyingValve(UnderlyingEntity):
 
         return new_value
 
-    def set_valve_open_percent(self):
+    async def set_valve_open_percent(self):
         """Update the valve open percent"""
         caped_val = self.cap_sent_value(self._thermostat.valve_open_percent)
         if self._percent_open == caped_val:
@@ -918,8 +1070,198 @@ class UnderlyingValve(UnderlyingEntity):
             "%s - Setting valve ouverture percent to %s", self, self._percent_open
         )
         # Send the change to the valve, in background
-        self._hass.create_task(self.send_percent_open())
+        # self._hass.create_task(self.send_percent_open())
+        await self.send_percent_open()
 
     def remove_entity(self):
         """Remove the entity after stopping its cycle"""
         self._cancel_cycle()
+
+
+class UnderlyingValveRegulation(UnderlyingValve):
+    """A specific underlying class for Valve regulation"""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        thermostat: Any,
+        offset_calibration_entity_id: str,
+        opening_degree_entity_id: str,
+        closing_degree_entity_id: str,
+        climate_underlying: UnderlyingClimate,
+        min_opening_degree: int = 0,
+    ) -> None:
+        """Initialize the underlying TRV with valve regulation"""
+        super().__init__(
+            hass,
+            thermostat,
+            opening_degree_entity_id,
+            entity_type=UnderlyingEntityType.VALVE_REGULATION,
+        )
+        self._offset_calibration_entity_id: str = offset_calibration_entity_id
+        self._opening_degree_entity_id: str = opening_degree_entity_id
+        self._closing_degree_entity_id: str = closing_degree_entity_id
+        self._climate_underlying = climate_underlying
+        self._is_min_max_initialized: bool = False
+        self._max_opening_degree: float = None
+        self._min_offset_calibration: float = None
+        self._max_offset_calibration: float = None
+        self._min_opening_degree: int = min_opening_degree
+
+    async def send_percent_open(self):
+        """Send the percent open to the underlying valve"""
+        if not self._is_min_max_initialized:
+            _LOGGER.debug(
+                "%s - initialize min offset_calibration and max open_degree", self
+            )
+            self._max_opening_degree = self._hass.states.get(
+                self._opening_degree_entity_id
+            ).attributes.get("max")
+
+            if self.have_offset_calibration_entity:
+                self._min_offset_calibration = self._hass.states.get(
+                    self._offset_calibration_entity_id
+                ).attributes.get("min")
+                self._max_offset_calibration = self._hass.states.get(
+                    self._offset_calibration_entity_id
+                ).attributes.get("max")
+
+            self._is_min_max_initialized = self._max_opening_degree is not None and (
+                not self.have_offset_calibration_entity
+                or (
+                    self._min_offset_calibration is not None
+                    and self._max_offset_calibration is not None
+                )
+            )
+
+        if not self._is_min_max_initialized:
+            _LOGGER.warning(
+                "%s - impossible to initialize max_opening_degree or min_offset_calibration. Abort sending percent open to the valve. This could be a temporary message at startup."
+            )
+            return
+
+        # Caclulate percent_open
+        if self._percent_open >= 1:
+            self._percent_open = round(
+                self._min_opening_degree
+                + (self._percent_open
+                   * (100 - self._min_opening_degree) / 100)
+                )
+        else:
+            self._percent_open = 0
+
+        # Send opening_degree
+        await super().send_percent_open()
+
+        # Send closing_degree if set
+        closing_degree = None
+        if self.have_closing_degree_entity:
+            await self._send_value_to_number(
+                self._closing_degree_entity_id,
+                closing_degree := self._max_opening_degree - self._percent_open,
+            )
+
+        # send offset_calibration to the difference between target temp and local temp
+        offset = None
+        if self.have_offset_calibration_entity:
+            if (
+                (local_temp := self._climate_underlying.underlying_current_temperature)
+                is not None
+                and (room_temp := self._thermostat.current_temperature) is not None
+                and (
+                    current_offset := get_safe_float(
+                        self._hass, self._offset_calibration_entity_id
+                    )
+                )
+                is not None
+            ):
+                offset = min(
+                    self._max_offset_calibration,
+                    max(
+                        self._min_offset_calibration,
+                        room_temp - (local_temp - current_offset),
+                    ),
+                )
+
+                await self._send_value_to_number(
+                    self._offset_calibration_entity_id, offset
+                )
+
+        _LOGGER.debug(
+            "%s - valve regulation - I have sent offset_calibration=%s opening_degree=%s closing_degree=%s",
+            self,
+            offset,
+            self._percent_open,
+            closing_degree,
+        )
+
+    @property
+    def offset_calibration_entity_id(self) -> str:
+        """The offset_calibration_entity_id"""
+        return self._offset_calibration_entity_id
+
+    @property
+    def opening_degree_entity_id(self) -> str:
+        """The offset_calibration_entity_id"""
+        return self._opening_degree_entity_id
+
+    @property
+    def closing_degree_entity_id(self) -> str:
+        """The offset_calibration_entity_id"""
+        return self._closing_degree_entity_id
+
+    @property
+    def min_opening_degree(self) -> int:
+        """The minimum opening degree"""
+        return self._min_opening_degree
+
+    @property
+    def have_closing_degree_entity(self) -> bool:
+        """Return True if the underlying have a closing_degree entity"""
+        return self._closing_degree_entity_id is not None
+
+    @property
+    def have_offset_calibration_entity(self) -> bool:
+        """Return True if the underlying have a offset_calibration entity"""
+        return self._offset_calibration_entity_id is not None
+
+    @property
+    def hvac_modes(self) -> list[HVACMode]:
+        """Get the hvac_modes"""
+        if not self.is_initialized:
+            return []
+        return [HVACMode.OFF, HVACMode.HEAT]
+
+    @overrides
+    async def start_cycle(
+        self,
+        hvac_mode: HVACMode,
+        _1,
+        _2,
+        _3,
+        force=False,
+    ):
+        """We use this function to change the on_percent"""
+        # if force:
+        await self.set_valve_open_percent()
+
+    @property
+    def is_device_active(self):
+        """If the opening valve is open."""
+        try:
+            return get_safe_float(self._hass, self._opening_degree_entity_id) > 0
+        except Exception:  # pylint: disable=broad-exception-caught
+            return False
+
+    @property
+    def valve_entity_ids(self) -> [str]:
+        """get an arrary with all entityd id of the valve"""
+        ret = []
+        for entity in [
+            self.opening_degree_entity_id,
+            self.closing_degree_entity_id,
+            self.offset_calibration_entity_id,
+        ]:
+            if entity:
+                ret.append(entity)
+        return ret

custom_components/versatile_thermostat/vtherm_api.py

@@ -1,6 +1,7 @@
 """ The API of Versatile Thermostat"""
 
 import logging
+from datetime import datetime
 from homeassistant.core import HomeAssistant
 from homeassistant.config_entries import ConfigEntry
 
@@ -15,8 +16,12 @@ from .const import (
     CONF_SAFETY_MODE,
     CONF_THERMOSTAT_TYPE,
     CONF_THERMOSTAT_CENTRAL_CONFIG,
+    CONF_MAX_ON_PERCENT,
+    NowClass,
 )
 
+from .central_feature_power_manager import CentralFeaturePowerManager
+
 VTHERM_API_NAME = "vtherm_api"
 
 _LOGGER = logging.getLogger(__name__)
@@ -60,6 +65,13 @@ class VersatileThermostatAPI(dict):
         self._central_mode_select = None
         # A dict that will store all Number entities which holds the temperature
         self._number_temperatures = dict()
+        self._max_on_percent = None
+        self._central_power_manager = CentralFeaturePowerManager(
+            VersatileThermostatAPI._hass, self
+        )
+
+        # the current time (for testing purpose)
+        self._now = None
 
     def find_central_configuration(self):
         """Search for a central configuration"""
@@ -107,6 +119,12 @@ class VersatileThermostatAPI(dict):
         if self._safety_mode:
             _LOGGER.debug("We have found safet_mode params %s", self._safety_mode)
 
+        self._max_on_percent = config.get(CONF_MAX_ON_PERCENT)
+        if self._max_on_percent:
+            _LOGGER.debug(
+                "We have found max_on_percent setting %s", self._max_on_percent
+            )
+
     def register_central_boiler(self, central_boiler_entity):
         """Register the central boiler entity. This is used by the CentralBoilerBinarySensor
         class to register itself at creation"""
@@ -117,15 +135,10 @@ class VersatileThermostatAPI(dict):
     ):
         """register the two number entities needed for boiler activation"""
         self._threshold_number_entity = threshold_number_entity
-        # If sensor and threshold number are initialized, reload the listener
-        # if self._nb_active_number_entity and self._central_boiler_entity:
-        #     self._hass.async_add_job(self.reload_central_boiler_binary_listener)
 
     def register_nb_device_active_boiler(self, nb_active_number_entity):
         """register the two number entities needed for boiler activation"""
         self._nb_active_number_entity = nb_active_number_entity
-        # if self._threshold_number_entity and self._central_boiler_entity:
-        #     self._hass.async_add_job(self.reload_central_boiler_binary_listener)
 
     def register_temperature_number(
         self,
@@ -150,10 +163,11 @@ class VersatileThermostatAPI(dict):
                 return entity.state
         return None
 
-    async def init_vtherm_links(self):
+    async def init_vtherm_links(self, entry_id=None):
         """Initialize all VTherms entities links
         This method is called when HA is fully started (and all entities should be initialized)
         Or when we need to reload all VTherm links (with Number temp entities, central boiler, ...)
+        If entry_id is set, only the VTherm of this entry will be reloaded
         """
         await self.reload_central_boiler_binary_listener()
         await self.reload_central_boiler_entities_list()
@@ -163,19 +177,18 @@ 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())
-
-                # A little hack to test if the climate is a VTherm. Cannot use isinstance due to circular dependency of BaseThermostat
+                # 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())
+                    if entry_id is None or entry_id == entity.unique_id:
+                        await entity.async_startup(self.find_central_configuration())
+
+        # start listening for the central power manager if not only one vtherm reload
+        if not entry_id:
+            await self.central_power_manager.start_listening()
 
     async def init_vtherm_preset_with_central(self):
         """Init all VTherm presets when the VTherm uses central temperature"""
@@ -239,6 +252,11 @@ class VersatileThermostatAPI(dict):
         """Get the safety_mode params"""
         return self._safety_mode
 
+    @property
+    def max_on_percent(self):
+        """Get the max_open_percent params"""
+        return self._max_on_percent
+
     @property
     def central_boiler_entity(self):
         """Get the central boiler binary_sensor entity"""
@@ -285,3 +303,18 @@ class VersatileThermostatAPI(dict):
     def hass(self):
         """Get the HomeAssistant object"""
         return VersatileThermostatAPI._hass
+
+    @property
+    def central_power_manager(self) -> any:
+        """Returns the central power manager"""
+        return self._central_power_manager
+
+    # For testing purpose
+    def _set_now(self, now: datetime):
+        """Set the now timestamp. This is only for tests purpose"""
+        self._now = now
+
+    @property
+    def now(self) -> datetime:
+        """Get now. The local datetime or the overloaded _set_now date"""
+        return self._now if self._now is not None else NowClass.get_now(self._hass)

documentation/en/additions.md

@@ -0,0 +1,211 @@
+# Some Essential Add-Ons
+
+- [Some Essential Add-Ons](#some-essential-add-ons)
+  - [the Versatile Thermostat UI Card](#the-versatile-thermostat-ui-card)
+  - [the Scheduler Component!](#the-scheduler-component)
+  - [Regulation curves with Plotly to Fine-Tune Your Thermostat](#regulation-curves-with-plotly-to-fine-tune-your-thermostat)
+  - [Event notification with the AppDaemon NOTIFIER](#event-notification-with-the-appdaemon-notifier)
+
+## the Versatile Thermostat UI Card
+A dedicated card for the Versatile Thermostat has been developed (based on Better Thermostat). It is available here: [Versatile Thermostat UI Card](https://github.com/jmcollin78/versatile-thermostat-ui-card) and offers a modern view of all the VTherm statuses:
+
+![image](https://github.com/jmcollin78/versatile-thermostat-ui-card/blob/master/assets/1.png?raw=true)
+
+## the Scheduler Component!
+
+To make the most out of the Versatile Thermostat, I recommend using it with the [Scheduler Component](https://github.com/nielsfaber/scheduler-component). The scheduler component provides climate scheduling based on predefined modes. While this feature is somewhat limited with the generic thermostat, it becomes very powerful when paired with the Versatile Thermostat.
+
+Assuming you have installed both the Versatile Thermostat and the Scheduler Component, here’s an example:
+
+In Scheduler, add a schedule:
+
+![image](https://user-images.githubusercontent.com/1717155/119146454-ee1a9d80-ba4a-11eb-80ae-3074c3511830.png)
+
+Choose the "Climate" group, select one (or more) entity, pick "MAKE SCHEME," and click next:
+(You can also choose "SET PRESET," but I prefer "MAKE SCHEME.")
+
+![image](https://user-images.githubusercontent.com/1717155/119147210-aa746380-ba4b-11eb-8def-479a741c0ba7.png)
+
+Define your mode scheme and save:
+
+![image](https://user-images.githubusercontent.com/1717155/119147784-2f5f7d00-ba4c-11eb-9de4-5e62ff5e71a8.png)
+
+In this example, I set ECO mode during the night and when no one is home during the day, BOOST in the morning, and COMFORT in the evening.
+
+I hope this example helps; feel free to share your feedback!
+
+## Regulation curves with Plotly to Fine-Tune Your Thermostat
+You can obtain a curve similar to the one shown in [some results](#some-results) using a Plotly graph configuration by leveraging the thermostat's custom attributes described [here](#custom-attributes):
+
+Replace the values between `[[ ]]` with your own.
+<details>
+
+```yaml
+- type: custom:plotly-graph
+  entities:
+    - entity: '[[climate]]'
+      attribute: temperature
+      yaxis: y1
+      name: Consigne
+    - entity: '[[climate]]'
+      attribute: current_temperature
+      yaxis: y1
+      name: T°
+    - entity: '[[climate]]'
+      attribute: ema_temp
+      yaxis: y1
+      name: Ema
+    - entity: '[[climate]]'
+      attribute: on_percent
+      yaxis: y2
+      name: Power percent
+      fill: tozeroy
+      fillcolor: rgba(200, 10, 10, 0.3)
+      line:
+        color: rgba(200, 10, 10, 0.9)
+    - entity: '[[slope]]'
+      name: Slope
+      fill: tozeroy
+      yaxis: y9
+      fillcolor: rgba(100, 100, 100, 0.3)
+      line:
+        color: rgba(100, 100, 100, 0.9)
+  hours_to_show: 4
+  refresh_interval: 10
+  height: 800
+  config:
+    scrollZoom: true
+  layout:
+    margin:
+      r: 50
+    legend:
+      x: 0
+      'y': 1.2
+      groupclick: togglegroup
+      title:
+        side: top right
+    yaxis:
+      visible: true
+      position: 0
+    yaxis2:
+      visible: true
+      position: 0
+      fixedrange: true
+      range:
+        - 0
+        - 1
+    yaxis9:
+      visible: true
+      fixedrange: false
+      range:
+        - -2
+        - 2
+      position: 1
+    xaxis:
+      rangeselector:
+        'y': 1.1
+        x: 0.7
+        buttons:
+          - count: 1
+            step: hour
+          - count: 12
+            step: hour
+          - count: 1
+            step: day
+          - count: 7
+            step: day
+```
+</details>
+
+Example of curves obtained with Plotly:
+
+![image](images/plotly-curves.png)
+
+## Event notification with the AppDaemon NOTIFIER
+This automation leverages the excellent AppDaemon app named NOTIFIER, developed by Horizon Domotique, demonstrated [here](https://www.youtube.com/watch?v=chJylIK0ASo&ab_channel=HorizonDomotique), and the code is available [here](https://github.com/jlpouffier/home-assistant-config/blob/master/appdaemon/apps/notifier.py). It allows users to be notified of security-related events occurring on any Versatile Thermostat.
+
+This is a great example of using the notifications described here: [notification](#notifications).
+<details>
+
+```yaml
+alias: Surveillance Mode Sécurité chauffage
+description: Envoi une notification si un thermostat passe en mode sécurité ou power
+trigger:
+  - platform: event
+    event_type: versatile_thermostat_security_event
+    id: versatile_thermostat_security_event
+  - platform: event
+    event_type: versatile_thermostat_power_event
+    id: versatile_thermostat_power_event
+  - platform: event
+    event_type: versatile_thermostat_temperature_event
+    id: versatile_thermostat_temperature_event
+condition: []
+action:
+  - choose:
+      - conditions:
+          - condition: trigger
+            id: versatile_thermostat_security_event
+        sequence:
+          - event: NOTIFIER
+            event_data:
+              action: send_to_jmc
+              title: >-
+                Radiateur {{ trigger.event.data.name }} - {{
+                trigger.event.data.type }} Sécurité
+              message: >-
+                Le radiateur {{ trigger.event.data.name }} est passé en {{
+                trigger.event.data.type }} sécurité car le thermomètre ne répond
+                plus.\n{{ trigger.event.data }}
+              callback:
+                - title: Stopper chauffage
+                  event: stopper_chauffage
+              image_url: /media/local/alerte-securite.jpg
+              click_url: /lovelace-chauffage/4
+              icon: mdi:radiator-off
+              tag: radiateur_security_alerte
+              persistent: true
+      - conditions:
+          - condition: trigger
+            id: versatile_thermostat_power_event
+        sequence:
+          - event: NOTIFIER
+            event_data:
+              action: send_to_jmc
+              title: >-
+                Radiateur {{ trigger.event.data.name }} - {{
+                trigger.event.data.type }} Délestage
+              message: >-
+                Le radiateur {{ trigger.event.data.name }} est passé en {{
+                trigger.event.data.type }} délestage car la puissance max est
+                dépassée.\n{{ trigger.event.data }}
+              callback:
+                - title: Stopper chauffage
+                  event: stopper_chauffage
+              image_url: /media/local/alerte-delestage.jpg
+              click_url: /lovelace-chauffage/4
+              icon: mdi:radiator-off
+              tag: radiateur_power_alerte
+              persistent: true
+      - conditions:
+          - condition: trigger
+            id: versatile_thermostat_temperature_event
+        sequence:
+          - event: NOTIFIER
+            event_data:
+              action: send_to_jmc
+              title: >-
+                Le thermomètre du radiateur {{ trigger.event.data.name }} ne
+                répond plus
+              message: >-
+                Le thermomètre du radiateur {{ trigger.event.data.name }} ne
+                répond plus depuis longtemps.\n{{ trigger.event.data }}
+              image_url: /media/local/thermometre-alerte.jpg
+              click_url: /lovelace-chauffage/4
+              icon: mdi:radiator-disabled
+              tag: radiateur_thermometre_alerte
+              persistent: true
+mode: queued
+max: 30
+```
+</details>

documentation/en/algorithms.md

@@ -0,0 +1,67 @@
+# The Different Algorithms Used
+
+- [The Different Algorithms Used](#the-different-algorithms-used)
+  - [The TPI Algorithm](#the-tpi-algorithm)
+    - [Configuring the TPI Algorithm Coefficients](#configuring-the-tpi-algorithm-coefficients)
+    - [Principle](#principle)
+  - [The Self-Regulation Algorithm (Without Valve Control)](#the-self-regulation-algorithm-without-valve-control)
+  - [The Auto-Start/Stop Function Algorithm](#the-auto-startstop-function-algorithm)
+
+## The TPI Algorithm
+
+### Configuring the TPI Algorithm Coefficients
+
+If you have selected a thermostat of type `over_switch`, `over_valve`, or `over_climate` with self-regulation in `Direct Valve Control` mode and choose the "TPI" option in the menu, you will land on this page:
+
+![image](images/config-tpi.png)
+
+You need to provide:
+1. the coefficient `coef_int` for the TPI algorithm,
+2. the coefficient `coef_ext` for the TPI algorithm.
+
+### Principle
+
+The TPI algorithm calculates the On vs Off percentage for the radiator at each cycle, using the target temperature, the current room temperature, and the current outdoor temperature. This algorithm is only applicable for Versatile Thermostats operating in `over_switch` and `over_valve` modes.
+
+The percentage is calculated using this formula:
+
+    on_percent = coef_int * (target_temperature - current_temperature) + coef_ext * (target_temperature - outdoor_temperature)
+    Then, the algorithm ensures that 0 <= on_percent <= 1.
+
+The default values for `coef_int` and `coef_ext` are `0.6` and `0.01`, respectively. These default values are suitable for a standard well-insulated room.
+
+When adjusting these coefficients, keep the following in mind:
+1. **If the target temperature is not reached** after stabilization, increase `coef_ext` (the `on_percent` is too low),
+2. **If the target temperature is exceeded** after stabilization, decrease `coef_ext` (the `on_percent` is too high),
+3. **If reaching the target temperature is too slow**, increase `coef_int` to provide more power to the heater,
+4. **If reaching the target temperature is too fast and oscillations occur** around the target, decrease `coef_int` to provide less power to the radiator.
+
+In `over_valve` mode, the `on_percent` value is converted to a percentage (0 to 100%) and directly controls the valve's opening level.
+
+## The Self-Regulation Algorithm (Without Valve Control)
+
+The self-regulation algorithm can be summarized as follows:
+
+1. Initialize the target temperature as the VTherm setpoint,
+2. If self-regulation is enabled:
+   1. Calculate the regulated temperature (valid for a VTherm),
+   2. Use this temperature as the target,
+3. For each underlying device of the VTherm:
+     1. If "Use Internal Temperature" is checked:
+          1. Calculate the compensation (`trv_internal_temp - room_temp`),
+     2. Add the offset to the target temperature,
+     3. Send the target temperature (= regulated_temp + (internal_temp - room_temp)) to the underlying device.
+
+## The Auto-Start/Stop Function Algorithm
+
+The algorithm used in the auto-start/stop function operates as follows:
+1. If "Enable Auto-Start/Stop" is off, stop here.
+2. If VTherm is on and in Heating mode, when `error_accumulated` < `-error_threshold` -> turn off and save HVAC mode.
+3. If VTherm is on and in Cooling mode, when `error_accumulated` > `error_threshold` -> turn off and save HVAC mode.
+4. If VTherm is off and the saved HVAC mode is Heating, and `current_temperature + slope * dt <= target_temperature`, turn on and set the HVAC mode to the saved mode.
+5. If VTherm is off and the saved HVAC mode is Cooling, and `current_temperature + slope * dt >= target_temperature`, turn on and set the HVAC mode to the saved mode.
+6. `error_threshold` is set to `10 (° * min)` for slow detection, `5` for medium, and `2` for fast.
+
+`dt` is set to `30 min` for slow, `15 min` for medium, and `7 min` for fast detection levels.
+
+The function is detailed [here](https://github.com/jmcollin78/versatile_thermostat/issues/585).

documentation/en/base-attributes.md

@@ -0,0 +1,45 @@
+- [Choosing Basic Attributes](#choosing-basic-attributes)
+- [Choosing the features to Use](#choosing-the-features-to-use)
+
+# Choosing Basic Attributes
+
+Select the "Main Attributes" menu.
+
+![image](images/config-main.png)
+
+Provide the mandatory main attributes. These attributes are common to all VTherms:
+1. A name (this will be both the integration's name and the `climate` entity name),
+2. An entity ID of a temperature sensor that provides the room temperature where the radiator is installed,
+3. An optional sensor entity providing the last seen date and time of the sensor (`last_seen`). If available, specify it here. It helps prevent safety shutdowns when the temperature is stable, and the sensor stops reporting for a long time (see [here](troubleshooting.md#why-does-my-versatile-thermostat-go-into-safety-mode)),
+4. A cycle duration in minutes. At each cycle:
+   1. For `over_switch`: VTherm will turn the radiator on/off, modulating the proportion of time it is on,
+   2. For `over_valve`: VTherm will calculate a new valve opening level and send it if it has changed,
+   3. For `over_climate`: The cycle performs basic controls and recalculates the self-regulation coefficients. The cycle may result in a new setpoint sent to underlying devices or a valve opening adjustment in the case of a controllable TRV.
+5. The equipment's power, which will activate power and energy consumption sensors for the device. If multiple devices are linked to the same VTherm, specify the total maximum power of all devices here. The power unit is not important here. What is important is that all _VTherm_ and all power sensors have the same unit (see: Power shedding feature),
+6. The option to use additional parameters from centralized configuration:
+   1. Outdoor temperature sensor,
+   2. Minimum/maximum temperature and temperature step size,
+7. The option to control the thermostat centrally. See [centralized control](#centralized-control),
+8. A checkbox if this VTherm is used to trigger a central boiler.
+
+> ![Tip](images/tips.png) _*Notes*_
+>  1. With the `over_switch` and `over_valve` types, calculations are performed at each cycle. In case of changing conditions, you will need to wait for the next cycle to see a change. For this reason, the cycle should not be too long. **5 minutes is a good value**, but it should be adjusted to your heating type. The greater the inertia, the longer the cycle should be. See [Tuning examples](tuning-examples.md).
+>  2. If the cycle is too short, the radiator may never reach the target temperature. For example, with a storage heater, it will be unnecessarily activated.
+
+# Choosing the features to Use
+
+Select the "Features" menu.
+
+![image](images/config-features.png)
+
+Choose the features you want to use for this VTherm:
+1. **Opening detection** (doors, windows) stops heating when an opening is detected. (see [managing openings](feature-window.md)),
+2. **Motion detection**: VTherm can adjust the target temperature when motion is detected in the room. (see [motion detection](feature-motion.md)),
+3. **Power management**: VTherm can stop a device if the power consumption in your home exceeds a threshold. (see [load-shedding management](feature-power.md)),
+4. **Presence detection**: If you have a sensor indicating presence or absence in your home, you can use it to change the target temperature. See [presence management](feature-presence.md). Note the difference between this function and motion detection: presence is typically used at the home level, while motion detection is more room-specific.
+5. **Automatic start/stop**: For `over_climate` VTherms only. This function stops a device when VTherm detects it will not be needed for a while. It uses the temperature curve to predict when the device will be needed again and turns it back on at that time. See [automatic start/stop management](feature-auto-start-stop.md).
+
+> ![Tip](images/tips.png) _*Notes*_
+> 1. The list of available functions adapts to your VTherm type.
+> 2. When you enable a function, a new menu entry is added to configure it.
+> 3. You cannot validate the creation of a VTherm if all parameters for all enabled functions have not been configured.

documentation/en/creation.md

@@ -0,0 +1,71 @@
+# Choosing a VTherm
+
+- [Choosing a VTherm](#choosing-a-vtherm)
+  - [Creating a New Versatile Thermostat](#creating-a-new-versatile-thermostat)
+- [Choosing a VTherm Type](#choosing-a-vtherm-type)
+  - [Centralized configuration](#centralized-configuration)
+  - [VTherm over a switch](#vtherm-over-a-switch)
+  - [VTherm over another thermostat](#vtherm-over-another-thermostat)
+  - [VTherm over a valve](#vtherm-over-a-valve)
+- [Making the right choice](#making-the-right-choice)
+- [Reference Article](#reference-article)
+
+> ![Tip](images/tips.png) _*Notes*_
+>
+> There are three ways to work with VTherms:
+> 1. Each Versatile Thermostat is fully configured independently. Choose this option if you do not want any centralized configuration or management.
+> 2. Some aspects are configured centrally. For example, you can define the minimum/maximum temperatures, open window detection parameters, etc., at a single central instance. For each VTherm you configure, you can then choose to use the central configuration or override it with custom parameters.
+> 3. In addition to centralized configuration, all VTherms can be controlled by a single `select` entity called `central_mode`. This feature allows you to stop/start/set frost protection/etc. for all VTherms at once. For each VTherm, you can specify if it is affected by this `central_mode`.
+
+## Creating a New Versatile Thermostat
+
+Click on "Add Integration" on the integration page (or click 'Add device' in the integration page)
+
+![image](images/add-an-integration.png)
+
+then:
+
+![image](images/config-main0.png)
+
+The configuration can be modified via the same interface. Simply select the thermostat to modify, press "Configure," and you will be able to change some parameters or settings.
+
+Follow the configuration steps by selecting the menu option to configure.
+
+# Choosing a VTherm Type
+
+## Centralized configuration
+This option allows you to configure certain repetitive aspects for all VTherms at once, such as:
+1. Parameters for different algorithms (TPI, open window detection, motion detection, power sensors for your home, presence detection). These parameters apply across all VTherms. You only need to enter them once in `Centralized Configuration`. This configuration does not create a VTherm itself but centralizes parameters that would be tedious to re-enter for each VTherm. Note that you can override these parameters on individual VTherms to specialize them if needed.
+2. Configuration for controlling a central heating system,
+3. Certain advanced parameters, such as safety settings.
+
+## VTherm over a switch
+This VTherm type controls a switch that turns a radiator on or off. The switch can be a physical switch directly controlling a radiator (often electric) or a virtual switch that can perform any action when turned on or off. The latter type can, for example, control pilot wire switches or DIY pilot wire solutions with diodes. VTherm modulates the proportion of time the radiator is on (`on_percent`) to achieve the desired temperature. If it is cold, it turns on more frequently (up to 100%); if it is warm, it reduces the on time.
+
+The underlying entities for this type are `switches` or `input_booleans`.
+
+## VTherm over another thermostat
+When your device is controlled by a `climate` entity in Home Assistant and you only have access to this, you should use this VTherm type. In this case, VTherm simply adjusts the target temperature of the underlying `climate` entity.
+
+This type also includes advanced self-regulation features to adjust the setpoint sent to the underlying device, helping to achieve the target temperature faster and mitigating poor internal regulation. For example, if the device's internal thermometer is too close to the heating element, it may incorrectly assume the room is warm while the setpoint is far from being achieved in other areas.
+
+Since version 6.8, this VTherm type can also regulate directly by controlling the valve. Ideal for controllable TRVs, as Sonoff TRVZB, this type is recommended if you have such devices.
+
+The underlying entities for this VTherm type are exclusively `climate`.
+
+## VTherm over a valve
+If the only entity available to regulate your radiator's temperature is a `number` entity, you should use the `over_valve` type. VTherm adjusts the valve opening based on the difference between the target temperature and the actual room temperature (and the outdoor temperature, if available).
+
+This type can be used for TRVs without an associated `climate` entity or other DIY solutions exposing a `number` entity.
+
+# Making the right choice
+> ![Tip](images/tips.png) _*How to Choose the Type*_
+> Choosing the correct type is crucial. It cannot be changed later via the configuration interface. To make the right choice, consider the following questions:
+> 1. **What type of equipment will I control?** Follow this order of preference:
+>    1. If you have a controllable thermostatic valve (TRV) in Home Assistant through a `number` entity (e.g., a Shelly TRV), choose the `over_valve` type. This is the most direct type and ensures the best regulation.
+>    2. If you have an electric radiator (with or without a pilot wire) controlled by a `switch` entity to turn it on/off, then the `over_switch` type is preferable. Regulation will be managed by the Versatile Thermostat based on the temperature measured by your thermometer at its placement location.
+>    3. In all other cases, use the `over_climate` mode. You retain your original `climate` entity, and the Versatile Thermostat "only" controls the on/off state and target temperature of your original thermostat. Regulation is handled by your original thermostat in this case. This mode is particularly suited for all-in-one reversible air conditioning systems exposed as a `climate` entity in Home Assistant. Advanced self-regulation can achieve the setpoint faster by forcing the setpoint or directly controlling the valve when possible.
+> 2. **What type of regulation do I want?** If the controlled equipment has its own built-in regulation mechanism (e.g., HVAC systems, certain TRVs) and it works well, choose `over_climate`. For TRVs with a controllable valve in Home Assistant, the `over_climate` type with `Direct Valve Control` self-regulation is the best choice.
+
+# Reference Article
+For more information on these concepts, refer to this article (in French): https://www.hacf.fr/optimisation-versatile-thermostat/#optimiser-vos-vtherm

documentation/en/feature-advanced.md

@@ -0,0 +1,53 @@
+# Advanced Configuration
+
+- [Advanced Configuration](#advanced-configuration)
+  - [Advanced Settings](#advanced-settings)
+    - [Minimum Activation Delay](#minimum-activation-delay)
+    - [Safety Mode](#safety-mode)
+
+These settings refine the thermostat's operation, particularly the safety mechanism for a _VTherm_. Missing temperature sensors (room or outdoor) can pose a risk to your home. For instance, if the temperature sensor gets stuck at 10°C, the `over_climate` or `over_valve` _VTherm_ types will command maximum heating of the underlying devices, which could lead to room overheating or even property damage, at worst resulting in a fire hazard.
+
+To prevent this, _VTherm_ ensures that thermometers report values regularly. If they don't, the _VTherm_ switches to a special mode called Safety Mode. This mode ensures minimal heating to prevent the opposite risk: a completely unheated home in the middle of winter, for example.
+
+The challenge lies in that some thermometers—especially battery-operated ones—only send temperature updates when the value changes. It is entirely possible to receive no temperature updates for hours without the thermometer failing. The parameters below allow fine-tuning of the thresholds for activating Safety Mode.
+
+If your thermometer has a `last seen` attribute indicating the last contact time, you can specify it in the _VTherm_'s main attributes to greatly reduce false Safety Mode activations. See [configuration](base-attributes.md#choosing-base-attributes) and [troubleshooting](troubleshooting.md#why-does-my-versatile-thermostat-switch-to-safety-mode).
+
+For `over_climate` _VTherms_, which self-regulate, Safety Mode is disabled. In this case, there is no danger, only the risk of an incorrect temperature.
+
+## Advanced Settings
+
+The advanced configuration form looks like this:
+
+![image](images/config-advanced.png)
+
+### Minimum Activation Delay
+
+The first delay (`minimal_activation_delay_sec`) in seconds is the minimum acceptable delay to turn on the heating. If the calculated activation time is shorter than this value, the heating remains off. This parameter only applies to _VTherm_ with cyclic triggering `over_switch`. If the activation time is too short, rapid switching will not allow the device to heat up properly.
+
+### Safety Mode
+
+The second delay (`safety_delay_min`) is the maximum time between two temperature measurements before the _VTherm_ switches to Safety Mode.
+
+The third parameter (`safety_min_on_percent`) is the minimum `on_percent` below which Safety Mode will not be activated. This setting prevents activating Safety Mode if the controlled radiator does not heat sufficiently. In this case, there is no physical risk to the home, only the risk of overheating or underheating.
+Setting this parameter to `0.00` will trigger Safety Mode regardless of the last heating setting, whereas `1.00` will never trigger Safety Mode (effectively disabling the feature). This can be useful to adapt the safety mechanism to your specific needs.
+
+The fourth parameter (`safety_default_on_percent`) defines the `on_percent` used when the thermostat switches to `security` mode. Setting it to `0` will turn off the thermostat in Safety Mode, while setting it to a value like `0.2` (20%) ensures some heating remains, avoiding a completely frozen home in case of a thermometer failure.
+
+It is possible to disable Safety Mode triggered by missing data from the outdoor thermometer. Since the outdoor thermometer usually has a minor impact on regulation (depending on your configuration), it might not be critical if it's unavailable. To do this, add the following lines to your `configuration.yaml`:
+
+```yaml
+versatile_thermostat:
+...
+    safety_mode:
+        check_outdoor_sensor: false
+```
+
+By default, the outdoor thermometer can trigger Safety Mode if it stops sending data. Remember that Home Assistant must be restarted for these changes to take effect. This setting applies to all _VTherms_ sharing the outdoor thermometer.
+
+> ![Tip](images/tips.png) _*Notes*_
+> 1. When the temperature sensor resumes reporting, the preset will be restored to its previous value.
+> 2. Two temperature sources are required: the indoor and outdoor temperatures. Both must report values, or the thermostat will switch to "security" preset.
+> 3. An action is available to adjust the three safety parameters. This can help adapt Safety Mode to your needs.
+> 4. For normal use, `safety_default_on_percent` should be lower than `safety_min_on_percent`.
+> 5. If you use the Versatile Thermostat UI card (see [here](additions.md#better-with-the-versatile-thermostat-ui-card)), a _VTherm_ in Safety Mode is indicated by a gray overlay showing the faulty thermometer and the time since its last value update: ![safety mode](images/safety-mode-icon.png).

documentation/en/feature-auto-start-stop.md

@@ -0,0 +1,41 @@
+# Auto-start / Auto-stop
+
+- [Auto-start / Auto-stop](#auto-start--auto-stop)
+  - [Configure Auto-start/stop](#configure-auto-startstop)
+  - [Usage](#usage)
+
+This feature allows _VTherm_ to stop an appliance that doesn't need to be on and restart it when conditions require it. This function includes three settings that control how quickly the appliance is stopped and restarted.
+Exclusively reserved for _VTherm_ of type `over_climate`, it applies to the following use case:
+1. Your appliance is permanently powered on and consumes electricity even when heating (or cooling) is not needed. This is often the case with heat pumps (_PAC_) that consume power even in standby mode.
+2. The temperature conditions are such that heating (or cooling) is not needed for a long period: the setpoint is higher (or lower) than the room temperature.
+3. The temperature rises (or falls), remains stable, or falls (or rises) slowly.
+
+In such cases, it is preferable to ask the appliance to turn off to avoid unnecessary power consumption in standby mode.
+
+## Configure Auto-start/stop
+
+To use this feature, you need to:
+1. Add the `With auto-start and stop` function in the 'Functions' menu.
+2. Set the detection level in the 'Auto-start/stop' option that appears when the function is activated. Choose the detection level between 'Slow', 'Medium', and 'Fast'. With the 'Fast' setting, stops and restarts will occur more frequently.
+
+![image](images/config-auto-start-stop.png)
+
+The 'Slow' setting allows about 30 minutes between a stop and a restart,
+The 'Medium' setting sets the threshold to about 15 minutes, and the 'Fast' setting puts it at 7 minutes.
+
+Note that these are not absolute settings since the algorithm takes into account the slope of the room temperature curve to respond accordingly. It is still possible that a restart occurs shortly after a stop if the temperature drops significantly.
+
+## Usage
+
+Once the function is configured, you will now have a new `switch` type entity that allows you to enable or disable auto-start/stop without modifying the configuration. This entity is available on the _VTherm_ device and is named `switch.<name>_enable_auto_start_stop`.
+
+![image](images/enable-auto-start-stop-entity.png)
+
+Check the box to allow auto-start and auto-stop, and leave it unchecked to disable the feature.
+
+Note: The auto-start/stop function will only turn a _VTherm_ back on if it was turned off by this function. This prevents unwanted or unexpected activations. Naturally, the off state is preserved even after a Home Assistant restart.
+
+> ![Tip](images/tips.png) _*Notes*_
+> 1. The detection algorithm is described [here](algorithms.md#auto-startstop-algorithm).
+> 2. Some appliances (boilers, underfloor heating, _PAC_, etc.) may not like being started/stopped too frequently. If that's the case, it might be better to disable the function when you know the appliance will be used. For example, I disable this feature during the day when presence is detected because I know my _PAC_ will turn on often. I enable auto-start/stop at night or when no one is home, as the setpoint is lowered and it rarely triggers.
+> 3. If you use the Versatile Thermostat UI card (see [here](additions.md#better-with-the-versatile-thermostat-ui-card)), a checkbox is directly visible on the card to disable auto-start/stop, and a _VTherm_ stopped by auto-start/stop is indicated by the icon: ![auto-start/stop icon](images/auto-start-stop-icon.png).

documentation/en/feature-central-boiler.md

@@ -0,0 +1,123 @@
+# Le contrôle d'une chaudière centrale# Controlling a Central Boiler
+
+- [Le contrôle d'une chaudière centrale# Controlling a Central Boiler](#le-contrôle-dune-chaudière-centrale-controlling-a-central-boiler)
+  - [Principle](#principle)
+  - [Configuration](#configuration)
+    - [How to Find the Right Action?](#how-to-find-the-right-action)
+  - [Events](#events)
+  - [Warning](#warning)
+
+You can control a centralized boiler. As long as it's possible to trigger or stop the boiler from Home Assistant, Versatile Thermostat will be able to control it directly.
+
+## Principle
+The basic principle is as follows:
+1. A new entity of type `binary_sensor`, named by default `binary_sensor.central_boiler`, is added.
+2. In the configuration of the _VTherms_, you specify whether the _VTherm_ should control the boiler. In a heterogeneous installation, some _VTherms_ should control the boiler, and others should not. Therefore, you need to indicate in each _VTherm_ configuration whether it controls the boiler.
+3. The `binary_sensor.central_boiler` listens for state changes in the equipment of the _VTherms_ marked as controlling the boiler.
+4. When the number of devices controlled by the _VTherm_ requesting heating (i.e., when its `hvac_action` changes to `Heating`) exceeds a configurable threshold, the `binary_sensor.central_boiler` turns `on`, and **if an activation service has been configured, that service is called**.
+5. If the number of devices requesting heating drops below the threshold, the `binary_sensor.central_boiler` turns `off`, and **if a deactivation service has been configured, that service is called**.
+6. You have access to two entities:
+   - A `number` type entity, named by default `number.boiler_activation_threshold`, which gives the activation threshold. This threshold is the number of devices (radiators) requesting heating.
+   - A `sensor` type entity, named by default `sensor.nb_device_active_for_boiler`, which shows the number of devices requesting heating. For example, a _VTherm_ with 4 valves, 3 of which request heating, will make this sensor show 3. Only the devices from _VTherms_ marked to control the central boiler are counted.
+
+You therefore always have the information to manage and adjust the triggering of the boiler.
+
+All these entities are linked to the central configuration service:
+
+![Boiler Control Entities](images/entitites-central-boiler.png)
+
+## Configuration
+To configure this feature, you need a centralized configuration (see [Configuration](#configuration)) and check the 'Add Central Boiler' box:
+
+![Add a Central Boiler](images/config-central-boiler-1.png)
+
+On the next page, you can provide the configuration for the actions (e.g., services) to be called when the boiler is turned on/off:
+
+![Add a Central Boiler](images/config-central-boiler-2.png)
+
+The actions (e.g., services) are configured as described on the page:
+1. The general format is `entity_id/service_id[/attribute:value]` (where `/attribute:value` is optional).
+2. `entity_id` is the name of the entity controlling the boiler in the form `domain.entity_name`. For example: `switch.chaudiere` for a boiler controlled by a switch, or `climate.chaudière` for a boiler controlled by a thermostat, or any other entity that allows boiler control (there is no limitation). You can also toggle inputs (`helpers`) such as `input_boolean` or `input_number`.
+3. `service_id` is the name of the service to be called in the form `domain.service_name`. For example: `switch.turn_on`, `switch.turn_off`, `climate.set_temperature`, `climate.set_hvac_mode` are valid examples.
+4. Some services require a parameter. This could be the 'HVAC Mode' for `climate.set_hvac_mode` or the target temperature for `climate.set_temperature`. This parameter should be configured in the format `attribute:value` at the end of the string.
+
+Examples (to adjust to your case):
+- `climate.chaudiere/climate.set_hvac_mode/hvac_mode:heat`: to turn the boiler thermostat on in heating mode.
+- `climate.chaudiere/climate.set_hvac_mode/hvac_mode:off`: to turn off the boiler thermostat.
+- `switch.pompe_chaudiere/switch.turn_on`: to turn on the switch powering the boiler pump.
+- `switch.pompe_chaudiere/switch.turn_off`: to turn off the switch powering the boiler pump.
+- ...
+
+### How to Find the Right Action?
+To find the correct action to use, it's best to go to "Developer Tools / Services", search for the action to call, the entity to control, and any required parameters.
+Click 'Call Service'. If your boiler turns on, you have the correct configuration. Then switch to YAML mode and copy the parameters.
+
+Example:
+
+In "Developer Tools / Actions":
+
+![Service Configuration](images/dev-tools-turnon-boiler-1.png)
+
+In YAML mode:
+
+![Service Configuration](images/dev-tools-turnon-boiler-2.png)
+
+The service to configure will then be: `climate.sonoff/climate.set_hvac_mode/hvac_mode:heat` (note the removal of spaces in `hvac_mode:heat`).
+
+Do the same for the off service, and you’re ready to go.
+
+## Events
+
+Each successful boiler activation or deactivation sends an event from Versatile Thermostat. This can be captured by an automation, for example, to notify you of the change.
+The events look like this:
+
+An activation event:
+```yaml
+event_type: versatile_thermostat_central_boiler_event
+data:
+  central_boiler: true
+  entity_id: binary_sensor.central_boiler
+  name: Central boiler
+  state_attributes: null
+origin: LOCAL
+time_fired: "2024-01-14T11:33:52.342026+00:00"
+context:
+  id: 01HM3VZRJP3WYYWPNSDAFARW1T
+  parent_id: null
+  user_id: null
+```yaml
+event_type: versatile_thermostat_central_boiler_event
+data:
+  central_boiler: true
+  entity_id: binary_sensor.central_boiler
+  name: Central boiler
+  state_attributes: null
+origin: LOCAL
+time_fired: "2024-01-14T11:33:52.342026+00:00"
+context:
+  id: 01HM3VZRJP3WYYWPNSDAFARW1T
+  parent_id: null
+  user_id: null
+```
+
+Un évènement d'extinction :
+```yaml
+event_type: versatile_thermostat_central_boiler_event
+data:
+  central_boiler: false
+  entity_id: binary_sensor.central_boiler
+  name: Central boiler
+  state_attributes: null
+origin: LOCAL
+time_fired: "2024-01-14T11:43:52.342026+00:00"
+context:
+  id: 01HM3VZRJP3WYYWPNSDAFBRW1T
+  parent_id: null
+  user_id: null
+```
+
+## Warning
+
+> ![Astuce](images/tips.png) _*Notes*_
+>
+> Software or home automation control of a central boiler may pose risks to its proper operation. Before using these functions, ensure that your boiler has proper safety features and that they are functioning correctly. For example, turning on a boiler with all valves closed can create excessive pressure.

documentation/en/feature-central-mode.md

@@ -0,0 +1,31 @@
+# Centralized Control
+
+- [Centralized Control](#centralized-control)
+  - [Configuration of Centralized Control](#configuration-of-centralized-control)
+  - [Usage](#usage)
+
+This feature allows you to control all your _VTherms_ from a single control point.
+A typical use case is when you leave for an extended period and want to set all your _VTherms_ to frost protection, and when you return, you want to set them back to their initial state.
+
+Centralized control is done from a special _VTherm_ called centralized configuration. See [here](creation.md#centralized-configuration) for more information.
+
+## Configuration of Centralized Control
+
+If you have set up a centralized configuration, you will have a new entity named `select.central_mode` that allows you to control all _VTherms_ with a single action.
+
+![central_mode](images/central-mode.png)
+
+This entity appears as a list of choices containing the following options:
+1. `Auto`: the 'normal' mode where each _VTherm_ operates autonomously,
+2. `Stopped`: all _VTherms_ are turned off (`hvac_off`),
+3. `Heat only`: all _VTherms_ are set to heating mode if supported, otherwise they are stopped,
+4. `Cool only`: all _VTherms_ are set to cooling mode if supported, otherwise they are stopped,
+5. `Frost protection`: all _VTherms_ are set to frost protection mode if supported, otherwise they are stopped.
+
+## Usage
+
+For a _VTherm_ to be controllable centrally, its configuration attribute named `use_central_mode` must be true. This attribute is available in the configuration page `Main Attributes`.
+
+![central_mode](images/use-central-mode.png)
+
+This means you can control all _VTherms_ (those explicitly designated) with a single control.

documentation/en/feature-motion.md

@@ -0,0 +1,40 @@
+# Motion or Activity Detection
+
+- [Motion or Activity Detection](#motion-or-activity-detection)
+  - [Configure Activity Mode or Motion Detection](#configure-activity-mode-or-motion-detection)
+  - [Usage](#usage)
+
+This feature allows you to change presets when motion is detected in a room. If you don't want to heat your office when the room is occupied and only when the room is occupied, you need a motion (or presence) sensor in the room and configure this feature.
+
+This function is often confused with the presence feature. They are complementary but not interchangeable. The 'motion' function is local to a room equipped with a motion sensor, while the 'presence' function is designed to be global to the entire home.
+
+## Configure Activity Mode or Motion Detection
+
+If you have chosen the `With motion detection` feature:
+
+![image](images/config-motion.png)
+
+What we need:
+- a **motion sensor**. Entity ID of a motion sensor. The states of the motion sensor must be "on" (motion detected) or "off" (no motion detected),
+- a **detection delay** (in seconds) defining how long we wait for confirmation of the motion before considering the motion. This parameter can be **greater than your motion sensor's delay**, otherwise, the detection will happen with every motion detected by the sensor,
+- an **inactivity delay** (in seconds) defining how long we wait for confirmation of no motion before no longer considering the motion,
+- a **"motion" preset**. We will use the temperature of this preset when activity is detected,
+- a **"no motion" preset**. We will use the temperature of this second preset when no activity is detected.
+
+## Usage
+
+To tell a _VTherm_ that it should listen to the motion sensor, you must set it to the special 'Activity' preset. If you have installed the Versatile Thermostat UI card (see [here](additions.md#much-better-with-the-versatile-thermostat-ui-card)), this preset is displayed as follows: ![activity preset](images/activity-preset-icon.png).
+
+You can then, upon request, set a _VTherm_ to motion detection mode.
+
+The behavior will be as follows:
+- we have a room with a thermostat set to activity mode, the "motion" mode chosen is comfort (21.5°C), the "no motion" mode chosen is Eco (18.5°C), and the motion delay is 30 seconds on detection and 5 minutes on the end of detection.
+- the room has been empty for a while (no activity detected), the setpoint temperature in this room is 18.5°.
+- someone enters the room, and activity is detected if the motion is present for at least 30 seconds. The temperature then goes up to 21.5°.
+- if the motion is present for less than 30 seconds (quick passage), the temperature stays at 18.5°.
+- imagine the temperature has gone up to 21.5°, when the person leaves the room, after 5 minutes the temperature is returned to 18.5°.
+- if the person returns before the 5 minutes, the temperature stays at 21.5°.
+
+> ![Tip](images/tips.png) _*Notes*_
+> 1. As with other presets, `Activity` will only be offered if it is correctly configured. In other words, all 4 configuration keys must be set.
+> 2. If you are using the Versatile Thermostat UI card (see [here](additions.md#much-better-with-the-versatile-thermostat-ui-card)), motion detection is represented as follows: ![motion](images/motion-detection-icon.png).

documentation/en/feature-power.md

@@ -0,0 +1,51 @@
+# Power Management - Load Shedding
+
+- [Power Management - Load Shedding](#power-management---load-shedding)
+    - [Example Use Case:](#example-use-case)
+  - [Configuring Power Management](#configuring-power-management)
+
+This feature allows you to regulate the electrical consumption of your heaters. Known as load shedding, it lets you limit the electrical consumption of your heating equipment if overconsumption conditions are detected.
+You will need a **sensor for the total instantaneous power consumption** of your home and a **sensor for the maximum allowed power**.
+
+The behavior of this feature is as follows:
+1. When a new measurement of the home's power consumption or the maximum allowed power is received,
+2. If the maximum power is exceeded, the central command will shed the load of all active devices starting with those closest to the setpoint. This continues until enough _VTherms_ are shed,
+3. If there is available power reserve and some _VTherms_ are shed, the central command will re-enable as many devices as possible, starting with those furthest from the setpoint (at the time they were shed).
+4. When a _VTherm_ starts, a check is performed to determine if the declared power is available. If not, the _VTherm_ is put into shed mode.
+
+**WARNING:** This is **not a safety feature** but an optimization function to manage consumption at the expense of some heating degradation. Overconsumption is still possible depending on the frequency of your consumption sensor updates and the actual power used by your equipment. Always maintain a safety margin.
+
+### Example Use Case:
+1. You have an electric meter limited to 11 kW,
+2. You occasionally charge an electric vehicle at 5 kW,
+3. This leaves 6 kW for everything else, including heating,
+4. You have 1 kW of other active devices,
+5. You declare a sensor (`input_number`) for the maximum allowed power at 9 kW (= 11 kW - reserved power for other devices - safety margin).
+
+If the vehicle is charging, the total consumed power is 6 kW (5 + 1), and a _VTherm_ will only turn on if its declared power is a maximum of 3 kW (9 kW - 6 kW).
+If the vehicle is charging and another _VTherm_ of 2 kW is on, the total consumed power is 8 kW (5 + 1 + 2), and a _VTherm_ will only turn on if its declared power is a maximum of 1 kW (9 kW - 8 kW). Otherwise, it will skip its turn (cycle).
+If the vehicle is not charging, the total consumed power is 1 kW, and a _VTherm_ will only turn on if its declared power is a maximum of 8 kW (9 kW - 1 kW).
+
+## Configuring Power Management
+
+In the centralized configuration, if you have selected the `With power detection` feature, configure it as follows:
+
+![image](images/config-power.png)
+
+1. The entity ID of the **sensor for total instantaneous power consumption** of your home,
+2. The entity ID of the **sensor for maximum allowed power**,
+3. The temperature to apply if load shedding is activated.
+
+Ensure that all power values use the same units (e.g., kW or W).
+Having a **sensor for maximum allowed power** allows you to modify the maximum power dynamically using a scheduler or automation.
+
+Note that due to centralized load-shedding, it is not possible to override the consumption and maximum consumption sensors on individual _VTherms_. This configuration must be done in the centralized settings. See [Centralized Configuration](./creation.md#centralized-configuration).
+
+> ![Tip](images/tips.png) _*Notes*_
+>
+> 1. During load shedding, the heater is set to the preset named `power`. This is a hidden preset that cannot be manually selected.
+> 2. Always maintain a margin, as the maximum power can briefly be exceeded while waiting for the next cycle's calculation or due to uncontrolled devices.
+> 3. If you do not wish to use this feature, uncheck it in the 'Features' menu.
+> 4. If a single _VTherm_ controls multiple devices, the **declared heating power consumption** should correspond to the total power of all devices.
+> 5. If you use the Versatile Thermostat UI card (see [here](additions.md#better-with-the-versatile-thermostat-ui-card)), load shedding is represented as follows: ![load shedding](images/power-exceeded-icon.png).
+> 6. There may be a delay of up to 20 seconds between receiving a new value from the power consumption sensor and triggering load shedding for _VTherms_. This delay prevents overloading Home Assistant if your consumption updates are very frequent.

documentation/en/feature-presence.md

@@ -0,0 +1,24 @@
+# Presence / Absence Management
+
+- [Presence / Absence Management](#presence--absence-management)
+  - [Configure Presence (or Absence)](#configure-presence-or-absence)
+
+## Configure Presence (or Absence)
+
+If this feature is selected, it allows you to dynamically adjust the preset temperatures of the thermostat when presence (or absence) is detected. To do this, you need to configure the temperature to be used for each preset when presence is disabled. When the presence sensor turns off, these temperatures will be applied. When it turns back on, the "normal" temperature configured for the preset will be used. See [preset management](feature-presets.md).
+
+To configure presence, fill out this form:
+
+![image](images/config-presence.png)
+
+For this, you simply need to configure an **occupancy sensor** whose state must be 'on' or 'home' if someone is present, or 'off' or 'not_home' otherwise.
+
+Temperatures are configured in the entities of the device corresponding to your _VTherm_ (Settings/Integration/Versatile Thermostat/the vtherm).
+
+WARNING: People groups do not work as a presence sensor. They are not recognized as a presence sensor. You need to use a template as described here [Using a People Group as a Presence Sensor](troubleshooting.md#using-a-people-group-as-a-presence-sensor).
+
+> ![Tip](images/tips.png) _*Notes*_
+>
+> 1. The temperature change is immediate and is reflected on the front panel. The calculation will consider the new target temperature at the next cycle calculation.
+> 2. You can use the direct person.xxxx sensor or a Home Assistant sensor group. The presence sensor handles the states `on` or `home` as present and `off` or `not_home` as absent.
+> 3. To pre-heat your home when everyone is absent, you can add an `input_boolean` entity to your people group. If you set this `input_boolean` to 'On', the presence sensor will be forced to 'On' and the presets with presence will be used. You can also set this `input_boolean` to 'On' via an automation, for example, when you leave a zone to start preheating your home.

documentation/en/feature-presets.md

@@ -0,0 +1,30 @@
+# Presets (Pre-configured Settings)
+
+- [Presets (Pre-configured Settings)](#presets-pre-configured-settings)
+  - [Configure Pre-configured Temperatures](#configure-pre-configured-temperatures)
+
+## Configure Pre-configured Temperatures
+
+The preset mode allows you to pre-configure the target temperature. Used in conjunction with Scheduler (see [scheduler](additions.md#the-scheduler-component)), you'll have a powerful and simple way to optimize the temperature relative to the electricity consumption in your home. The managed presets are as follows:
+ - **Eco**: the device is in energy-saving mode
+ - **Comfort**: the device is in comfort mode
+ - **Boost**: the device fully opens all valves
+
+If the AC mode is used, you can also configure temperatures when the equipment is in air conditioning mode.
+
+**None** is always added to the list of modes, as it is a way to not use presets but instead set a **manual temperature**.
+
+The presets are configured directly from the _VTherm_ entities or the central configuration if you're using centralized control. Upon creating the _VTherm_, you will have different entities that will allow you to set the temperatures for each preset:
+
+![presets](images/config-preset-temp.png).
+
+The list of entities varies depending on your feature choices:
+1. If the 'presence detection' function is activated, you will have the presets with an "absence" version prefixed with _abs_.
+2. If you have selected the _AC_ option, you will also have presets for 'air conditioning' prefixed with _clim_.
+
+> ![Tip](images/tips.png) _*Notes*_
+>
+> 1. When you manually change the target temperature, the preset switches to None (no preset).
+> 2. The standard preset `Away` is a hidden preset that cannot be directly selected. Versatile Thermostat uses presence management or motion detection to automatically and dynamically adjust the target temperature based on presence in the home or activity in the room. See [presence management](feature-presence.md).
+> 3. If you're using load shedding management, you will see a hidden preset named `power`. The heating element's preset is set to "power" when overload conditions are met and load shedding is active for that heating element. See [power management](feature-power.md).
+> 4. If you're using advanced configuration, you will see the preset set to `safety` if the temperature could not be retrieved after a certain delay. See [Safety Mode](feature-advanced.md#safety-mode).

documentation/en/feature-window.md

@@ -0,0 +1,64 @@
+# Door/Window Open Detection
+
+- [Door/Window Open Detection](#doorwindow-open-detection)
+  - [Sensor Mode](#sensor-mode)
+  - [Auto Mode](#auto-mode)
+
+You must have selected the `With Open Detection` feature on the first page to reach this page.
+Open detection can be done in two ways:
+1. By using a sensor placed on the opening (sensor mode),
+2. By detecting a sudden temperature drop (auto mode)
+
+## Sensor Mode
+To switch to sensor mode, you need to provide an entity of type `binary_sensor` or `input_boolean`.
+In this mode, you need to fill in the following information:
+
+![mode window sensor](images/config-window-sensor.png)
+
+1. A **delay in seconds** before any change. This allows you to open a window quickly without stopping the heating.
+2. The action to take when the opening is detected as open. The possible actions are:
+   1. _Turn off_: the _VTherm_ will be turned off.
+   2. _Fan only_: heating or cooling will be turned off, but the equipment will continue to ventilate (for compatible equipment).
+   3. _Frost protection_: the "Frost Protection" preset temperature will be selected on the _VTherm_ without changing the current preset (see notes below).
+   4. _Eco_: the "Eco" preset temperature will be applied to the _VTherm_ without changing the current preset (see notes below).
+
+When the detector switches to open:
+1. _VTherm_ waits for the specified delay.
+2. If the window is still open after the delay, the _VTherm_ state (Heating / Cooling / ..., current preset, current target temperature) is saved and the action is performed.
+
+Similarly, when the detector switches to closed:
+1. _VTherm_ waits for the specified delay.
+2. If the window is still closed after the delay, the state before the window opening is restored.
+
+## Auto Mode
+In auto mode, the configuration is as follows:
+
+![image](images/config-window-auto.png)
+
+1. A **delay in seconds** before any change. This allows you to open a window quickly without stopping the heating.
+2. A detection threshold in degrees per hour. When the temperature drops beyond this threshold, the thermostat will turn off. The lower this value, the faster the detection (with a higher risk of false positives).
+3. A threshold for ending detection in degrees per hour. When the temperature drop exceeds this value, the thermostat will return to the previous mode (mode and preset).
+4. A maximum detection duration. Beyond this duration, the thermostat will return to its previous mode and preset even if the temperature continues to drop.
+5. The action to take when the opening is detected as open. The actions are the same as in sensor mode described above.
+
+To adjust the thresholds, it is recommended to start with the reference values and adjust the detection thresholds. Some tests gave me the following values (for an office):
+- Detection threshold: 3°C/hour
+- No detection threshold: 0°C/hour
+- Max duration: 30 min.
+
+A new sensor called "slope" has been added for all thermostats. It provides the slope of the temperature curve in °C/hour (or °K/hour). This slope is smoothed and filtered to avoid aberrant thermometer values that could interfere with the measurement.
+
+![image](images/temperature-slope.png)
+
+To adjust it properly, it is recommended to display both the temperature curve and the slope of the curve ("slope") on the same historical graph:
+
+![image](images/window-auto-tuning.png)
+
+> ![Tip](images/tips.png) _*Notes*_
+>
+> 1. If you want to use **multiple door/window sensors** to automate your thermostat, simply create a group with the usual behavior (https://www.home-assistant.io/integrations/binary_sensor.group/)
+> 2. If you don't have a door/window sensor in your room, simply leave the sensor entity ID empty.
+> 3. **Only one mode is allowed**. You cannot configure a thermostat with both a sensor and auto detection. The two modes might contradict each other, so both modes cannot be active at the same time.
+> 4. It is not recommended to use auto mode for equipment subjected to frequent and normal temperature variations (hallways, open areas, etc.).
+> 5. To avoid interfering with your current preset settings, the actions _Frost protection_ and _Eco_ change the target temperature without changing the preset. So, you may notice a discrepancy between the selected preset and the setpoint.
+> 6. If you use the Versatile Thermostat UI card (see [here](additions.md#even-better-with-the-versatile-thermostat-ui-card)), open detection is represented as follows: ![window](images/window-detection-icon.png).