FIX #341 - when window state change, open_valve_percent should be resend

Add events in README
Documentation and release.
2024-01-14 23:02:23 +00:00 · 2024-01-14 16:50:59 +00:00 · 2024-01-14 16:44:38 +00:00 · 2024-01-14 12:37:09 +00:00 · 2024-01-14 00:33:52 +00:00 · 2024-01-13 17:46:41 +00:00
24 changed files with 773 additions and 90 deletions
--- a/.devcontainer/configuration.yaml
+++ b/.devcontainer/configuration.yaml
@@ -66,6 +66,13 @@ input_number:
        max: 90
        icon: mdi:pipe-valve
        unit_of_measurement: percentage
+    fake_boiler_temperature:
+        name: Boiler temperature
+        min: 0
+        max: 30
+        icon: mdi:water-boiler
+        unit_of_measurement: °C
+        mode: box

 input_boolean:
    # input_boolean to simulate the windows entity. Only for development environment.
@@ -161,6 +168,7 @@ climate:
      target_sensor: input_number.fake_temperature_sensor1

 recorder:
+    commit_interval: 1
    include:
        domains:
            - input_boolean
@@ -168,6 +176,7 @@ recorder:
            - switch
            - climate
            - sensor
+            - binary_sensor

 template:
    - binary_sensor:
--- a/README-fr.md
+++ b/README-fr.md
@@ -36,6 +36,11 @@
  - [Configurer la présence ou l'occupation](#configurer-la-présence-ou-loccupation)
  - [Configuration avancée](#configuration-avancée)
  - [Le contrôle centralisé](#le-contrôle-centralisé)
+  - [Le contrôle d'une chaudière centrale](#le-contrôle-dune-chaudière-centrale)
+    - [Configuration](#configuration-1)
+    - [Comment trouver le bon service ?](#comment-trouver-le-bon-service-)
+    - [Les évènements](#les-évènements)
+    - [Avertissement](#avertissement)
  - [Synthèse des paramètres](#synthèse-des-paramètres)
 - [Exemples de réglage](#exemples-de-réglage)
  - [Chauffage électrique](#chauffage-électrique)
@@ -79,14 +84,15 @@ Ce composant personnalisé pour Home Assistant est une mise à niveau et est une


 > ![Nouveau](https://github.com/jmcollin78/versatile_thermostat/blob/main/images/new-icon.png?raw=true) _*Nouveautés*_
+> * **Release 5.3** : Ajout d'une fonction de pilotage d'une chaudière centrale [#234](https://github.com/jmcollin78/versatile_thermostat/issues/234). Plus d'infos ici: [Le contrôle d'une chaudière centrale](#le-contrôle-dune-chaudière-centrale),
 > * **Release 5.2** : Ajout d'un `central_mode` permettant de piloter tous les VTherms de façon centralisée [#158](https://github.com/jmcollin78/versatile_thermostat/issues/158).
 > * **Release 5.1** : Limitation des valeurs envoyées aux valves et au température envoyées au climate sous-jacent.
 > * **Release 5.0** : Ajout d'une configuration centrale permettant de mettre en commun les attributs qui peuvent l'être [#239](https://github.com/jmcollin78/versatile_thermostat/issues/239).
 > * **Release 4.3** : Ajout d'un mode auto-fan pour le type `over_climate` permettant d'activer la ventilation si l'écart de température est important [#223](https://github.com/jmcollin78/versatile_thermostat/issues/223).
-> * **Release 4.2** : Le calcul de la pente de la courbe de température se fait maintenant en °/heure et non plus en °/min [#242](https://github.com/jmcollin78/versatile_thermostat/issues/242). Correction de la détection automatique des ouvertures par l'ajout d'un lissage de la courbe de température .
 <details>
 <summary>Autres versions</summary>

+> * **Release 4.2** : Le calcul de la pente de la courbe de température se fait maintenant en °/heure et non plus en °/min [#242](https://github.com/jmcollin78/versatile_thermostat/issues/242). Correction de la détection automatique des ouvertures par l'ajout d'un lissage de la courbe de température .
 > * **Release 4.1** : Ajout d'un mode de régulation **Expert** dans lequel l'utilisateur peut spécifier ses propres paramètres d'auto-régulation au lieu d'utiliser les pre-programmés [#194](https://github.com/jmcollin78/versatile_thermostat/issues/194).
 > * **Release 4.0** : Ajout de la prise en charge de la **Versatile Thermostat UI Card**. Voir [Versatile Thermostat UI Card](https://github.com/jmcollin78/versatile-thermostat-ui-card). Ajout d'un mode de régulation **Slow** pour les appareils de chauffage à latence lente [#168](https://github.com/jmcollin78/versatile_thermostat/issues/168). Changement de la façon dont **la puissance est calculée** dans le cas de VTherm avec des équipements multi-sous-jacents [#146](https://github.com/jmcollin78/versatile_thermostat/issues/146). Ajout de la prise en charge de AC et Heat pour VTherm via un interrupteur également [#144](https://github.com/jmcollin78/versatile_thermostat/pull/144)
 > * **Release 3.8**: Ajout d'une **fonction d'auto-régulation** pour les thermostats `over climate` dont la régulation est faite par le climate sous-jacent. Cf. [L'auto-régulation](#lauto-régulation) et [#129](https://github.com/jmcollin78/versatile_thermostat/issues/129). Ajout de la **possibilité d'inverser la commande** pour un thermostat `over switch` pour adresser les installations avec fil pilote et diode [#124](https://github.com/jmcollin78/versatile_thermostat/issues/124).
@@ -159,6 +165,7 @@ Ce composant nommé __Versatile thermostat__ gère les cas d'utilisation suivant
 - Des **services pour interagir avec le thermostat** à partir d'autres intégrations : vous pouvez forcer la présence / la non-présence à l'aide d'un service, et vous pouvez modifier dynamiquement la température des préréglages et changer les paramètres de sécurité.
 - Ajouter des capteurs pour voir les états internes du thermostat,
 - Contrôle centralisé de tous les Versatile Thermostat pour les stopper tous, les passer tous en hors-gel, les forcer en mode Chauffage (l'hiver), les forcer en mode Climatisation (l'été).
+- Contrôle d'une chaudière centrale et des VTherm qui doivent contrôler cette chaudière.

 # Comment installer cet incroyable Thermostat Versatile ?

@@ -550,6 +557,100 @@ Exemple de rendu :

 ![central_mode](/images/central_mode.png?raw=true)

+## Le contrôle d'une chaudière centrale
+Depuis la release 5.3, vous avez la possibilité de contrôler une chaudière centralisée. A partir du moment où il est possible de déclencher ou stopper cette chaudière depuis Home Assistant, alors Versatile Thermostat va pouvoir la commander directement.
+
+Le principe mis en place est globalement le suivant :
+1. une nouvelle entité de type `binary_sensor` et nommée par défaut `binary_sensor.central_boiler` est ajoutée,
+2. dans la configuration des VTherms vous indiqué si le VTherm doit contrôler la chaudière. En effet, dans une installation hétérogène, certains VTherm doivent commander la chaudière et d'autres non. Vous devez donc indiqué dans chaque configuration de VTherm si il contrôle la chaudière ou pas,
+3. le `binary_sensor.central_boiler` écoute les changements d'états des VTherm marqués comme contrôlant la chaudière,
+4. si l'un des VTherm écoutés demande du chauffage (ie son `hvac_action` passe à `Heating`), alors le `binary_sensor.central_boiler` passe à `on` et si un service d'activation a été configuré, alors ce service est appelé,
+5. si plus aucun VTherm écoutés ne demande du chauffage (ie aucun `hvac_action` n'est `Heating`), alors le `binary_sensor.central_boiler` passe à `off` et si un service de désactivation a été configuré, alors ce service est appelé.
+
+Vous avez donc en permanence, un indicateur qui donne l'info que au moins un des radiateurs est à besoin de chauffer.
+
+### Configuration
+Pour configurer cette fonction, vous devez avoir une configuration centralisée (cf. [Configuration](#configuration)) et cochez la case 'Ajouter une chuadière centrale' :
+
+![Ajout d'une chaudière centrale](/images/config-central-boiler-1.png?raw=true)
+
+Sur la page suivante vous pouvez donner la configuration des services à appeler lors de l'allumage / extinction de la chaudière :
+
+![Ajout d'une chaudière centrale](/images/config-central-boiler-2.png?raw=true)
+
+Les services se configurent comme indiqués dans la page :
+1. le format général est `entity_id/service_id[/attribut:valeur]` (où `/attribut:valeur` est facultatif),
+2. `entity_id` est le nom de l'entité qui commande la chaudière sous la forme `domain.entity_name`. Par exemple: `switch.chaudiere` pour les chaudière commandée par un switch ou `climate.chaudière` pour une chaudière commandée par un thermostat ou tout autre entité qui permet le contrôle de la chaudière (il n'y a pas de limitation).  On peut aussi commuter des entrées (`helpers`) comme des `input_boolean` ou `input_number`.
+3. `service_id` est le nom du service à appeler sous la forme `domain.service_name`. Par exemple: `switch.turn_on`, `switch.turn_off`, `climate.set_temperature`, `climate.set_hvac_mode` sont des exemples valides.
+4. pour certain service vous aurez besoin d'un paramètre. Cela peut être le 'Mode CVC' `climate.set_hvac_mode` ou la température cible pour `climate.set_temperature`. Ce paramètre doit être configuré sous la forme `attribut:valeur` en fin de chaine.
+
+Exemples (à ajuster à votre cas) :
+- `climate.chaudiere/climate.set_hvac_mode/hvac_mode:heat` : pour allumer le thermostat de la chaudière en mode chauffage,
+- `climate.chaudiere/climate.set_hvac_mode/hvac_mode:off` : pour stopper le thermostat de la chaudière,
+- `switch.pompe_chaudiere/switch.turn_on` : pour allumer le swicth qui alimente la pompe de la chaudière,
+- `switch.pompe_chaudiere/switch.turn_off` : pour allumer le swicth qui alimente la pompe de la chaudière,
+- ...
+
+### Comment trouver le bon service ?
+Pour trouver le services a utiliser, le mieux est d'aller dans "Outils de développement / Services", chercher le service a appelé, l'entité à commander et l'éventuel paramètre à donner.
+Cliquez sur 'Appeler le service'. Si votre chaudière s'allume vous avez la bonne configuration. Passez alors en mode Yaml et recopiez les paramètres.
+
+Exemple:
+
+Sous "Outils de développement / Service" :
+
+![Configuration du service](/images/dev-tools-turnon-boiler-1.png?raw=true)
+
+En mode yaml :
+
+![Configuration du service](/images/dev-tools-turnon-boiler-2.png?raw=true)
+
+Le service à configurer est alors le suivant: `climate.empty_thermostast/climate.set_hvac_mode/hvac_mode:heat` (notez la suppression du blanc dans `hvac_mode:heat`)
+
+Faite alors de même pour le service d'extinction et vous êtes parés.
+
+### Les évènements
+
+A chaque allumage ou extinction réussie de la chaudière un évènement est envoyé par Versatile Thermostat. Il peut avantageusement être capté par une automatisation, par exemple pour notifier un changement.
+Les évènements ressemblent à ça :
+
+Un évènement d'allumage :
+```
+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 :
+```
+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
+```
+
+### Avertissement
+
+> ![Astuce](https://github.com/jmcollin78/versatile_thermostat/blob/main/images/tips.png?raw=true) _*Notes*_
+> Le contrôle par du logiciel ou du matériel de type domotique d'une chaudière centrale peut induire des risques pour son bon fonctionnement. Assurez-vous avant d'utiliser ces fonctions, que votre chaudière possède bien des fonctions de sécurité et que celles-ci fonctionnent. Allumer une chaudière si tous les robinets sont fermés peut générer de la sur-pression par exemple.
+
 ## Synthèse des paramètres

 | Paramètre                                 | Libellé                                                                           | "over switch" | "over climate"      | "over valve" | "configuration centrale" |
@@ -618,7 +719,11 @@ Exemple de rendu :
 | ``auto_regulation_dtemp``                 | La seuil d'auto-régulation                                                        | -             | X                   | -            | -                        |
 | ``auto_regulation_period_min``            | La période minimale d'auto-régulation                                             | -             | X                   | -            | -                        |
 | ``inverse_switch_command``                | Inverse la commande du switch (pour switch avec fil pilote)                       | X             | -                   | -            | -                        |
-| ``auto_fan_mode`                          | Mode de ventilation automatique                                                   | -             | X                   | -            | -                        |
+| ``auto_fan_mode``                         | Mode de ventilation automatique                                                   | -             | X                   | -            | -                        |
+| ``add_central_boiler_control``            | Ajout du controle d'une chaudière centrale                                        | -             | -                   | -            | X                        |
+| ``central_boiler_activation_service``     | Service d'activation de la chaudière                                              | -             | -                   | -            | X                        |
+| ``central_boiler_deactivation_service``   | Service de desactivation de la chaudière                                          | -             | -                   | -            | X                        |
+| ``used_by_controls_central_boiler``       | Indique si le VTherm contrôle la chaudière centrale                               | X             | X                   | X            | -                        |

 # Exemples de réglage

@@ -814,6 +919,7 @@ Les évènements notifiés sont les suivants:
 - ``versatile_thermostat_temperature_event`` : une ou les deux mesures de température d'un thermostat n'ont pas été mis à jour depuis plus de `security_delay_min`` minutes
 - ``versatile_thermostat_hvac_mode_event`` : le thermostat est allumé ou éteint. Cet évènement est aussi diffusé au démarrage du thermostat
 - ``versatile_thermostat_preset_event`` : un nouveau preset est sélectionné sur le thermostat. Cet évènement est aussi diffusé au démarrage du thermostat
+- ``versatile_thermostat_central_boiler_event`` : un évènement indiquant un changement dans l'état de la chaudière.

 Si vous avez bien suivi, lorsqu'un thermostat passe en mode sécurité, 3 évènements sont déclenchés :
 1. ``versatile_thermostat_temperature_event`` pour indiquer qu'un thermomètre ne répond plus,
@@ -873,6 +979,7 @@ Les attributs personnalisés sont les suivants :
 | ``is_inversed``                   | True si la commande est inversée (fil pilote avec diode)                                                                                                                 |
 | ``is_controlled_by_central_mode`` | True si le VTherm peut être controlé de façon centrale                                                                                                                   |
 | ``last_central_mode``             | Le dernier mode central utilisé (None si le VTherm n'est pas controlé en central)                                                                                        |
+| ``is_used_by_central_boiler``     | Indique si le VTherm peut contrôler la chaudière centrale                                                                                                                |

 # Quelques résultats

--- a/README.md
+++ b/README.md
@@ -36,6 +36,11 @@
  - [Configure presence or occupancy](#configure-presence-or-occupancy)
  - [Advanced configuration](#advanced-configuration)
  - [Centralized control](#centralized-control)
+  - [Control of a central boiler](#control-of-a-central-boiler)
+    - [Setup](#setup)
+    - [How to find the right service?](#how-to-find-the-right-service)
+    - [The events](#the-events)
+    - [Warning](#warning)
  - [Parameters synthesis](#parameters-synthesis)
 - [Examples tuning](#examples-tuning)
  - [Electrical heater](#electrical-heater)
@@ -79,14 +84,15 @@
 This custom component for Home Assistant is an upgrade and is a complete rewrite of the component "Awesome thermostat" (see [Github](https://github.com/dadge/awesome_thermostat)) with addition of features.

 >![New](https://github.com/jmcollin78/versatile_thermostat/blob/main/images/new-icon.png?raw=true) _*News*_
+> * **Release 5.3**: Added a central boiler control function [#234](https://github.com/jmcollin78/versatile_thermostat/issues/234). More information here: [Controlling a central boiler](#controlling-a-central-boiler),
 > * **Release 5.2**: Added a `central_mode` allowing all VTherms to be controlled centrally [#158](https://github.com/jmcollin78/versatile_thermostat/issues/158).
 > * **Release 5.1**: Limitation of the values sent to the valves and the temperature sent to the underlying climate.
 > * **Release 5.0**: Added a central configuration allowing the sharing of attributes that can be shared [#239](https://github.com/jmcollin78/versatile_thermostat/issues/239).
 > * **Release 4.3**: Added an auto-fan mode for the `over_climate` type allowing ventilation to be activated if the temperature difference is significant [#223](https://github.com/jmcollin78/versatile_thermostat/issues/223).
-> * **Release 4.2**: The calculation of the slope of the temperature curve is now done in °/hour and no longer in °/min [#242](https://github.com/jmcollin78/versatile_thermostat/issues/242). Correction of automatic detection of openings by adding smoothing of the temperature curve.
 <details>
 <summary>Others releases</summary>

+> * **Release 4.2**: The calculation of the slope of the temperature curve is now done in °/hour and no longer in °/min [#242](https://github.com/jmcollin78/versatile_thermostat/issues/242). Correction of automatic detection of openings by adding smoothing of the temperature curve.
 > * **Release 4.1**: Added an **Expert** regulation mode in which the user can specify their own auto-regulation parameters instead of using the pre-programmed ones [#194]( https://github.com/jmcollin78/versatile_thermostat/issues/194).
 > * **Release 4.0**: Added the support of **Versatile Thermostat UI Card**. See [Versatile Thermostat UI Card](https://github.com/jmcollin78/versatile-thermostat-ui-card). Added a **Slow** regulation mode for slow latency heating devices [#168](https://github.com/jmcollin78/versatile_thermostat/issues/168). Change the way **the power is calculated** in case of VTherm with multi-underlying equipements [#146](https://github.com/jmcollin78/versatile_thermostat/issues/146). Added the support of AC and Heat for VTherm over switch alse [#144](https://github.com/jmcollin78/versatile_thermostat/pull/144)
 > * **Release 3.8**: Added a **self-regulation function** for `over climate` thermostats whose regulation is done by the underlying climate. See [Self-regulation](#self-regulation) and [#129](https://github.com/jmcollin78/versatile_thermostat/issues/129). Added the possibility of **inverting the command** for an `over switch` thermostat to address installations with pilot wire and diode [#124](https://github.com/jmcollin78/versatile_thermostat/issues/124).
@@ -159,6 +165,7 @@ This component named __Versatile thermostat__ manage the following use cases :
 - Add **services to interact with the thermostat** from others integration: you can force the presence / un-presence using a service, and you can dynamically change the temperature of the presets and change dynamically the safety parameters.
 - Add sensors to see the internal states of the thermostat,
 - Centralized control of all Versatile Thermostats to stop them all, switch them all to frost protection, force them into Heating mode (winter), force them into Cooling mode (summer).
+- Control of a central boiler and the VTherms which must control this boiler.

 # How to install this incredible Versatile Thermostat ?

@@ -536,6 +543,100 @@ Example rendering:

 ![central_mode](/images/central_mode.png?raw=true)

+## Control of a central boiler
+Since release 5.3, you have the possibility of controlling a centralized boiler. From the moment it is possible to start or stop this boiler from Home Assistant, then Versatile Thermostat will be able to control it directly.
+
+The principle put in place is generally as follows:
+1. a new entity of type `binary_sensor` and named by default `binary_sensor.central_boiler` is added,
+2. in the VTherms configuration you indicate whether the VTherm should control the boiler. Indeed, in a heterogeneous installation, some VTherm must control the boiler and others not. You must therefore indicate in each VTherm configuration whether it controls the boiler or not,
+3. the `binary_sensor.central_boiler` listens for changes in state of the VTherms marked as controlling the boiler,
+4. if one of the listened VTherms requests heating (ie its `hvac_action` changes to `Heating`), then the `binary_sensor.central_boiler` changes to `on` and if an activation service has been configured, then this service is called,
+5. if no more listened VTherm requests heating (ie no `hvac_action` is `Heating`), then the `binary_sensor.central_boiler` goes to `off` and if a deactivation service has been configured, then this service is called.
+
+You therefore always have an indicator which gives information that at least one of the radiators needs to be heated.
+
+### Setup
+To configure this function, you must have a centralized configuration (see [Configuration](#configuration)) and check the 'Add a central boiler' box:
+
+![Adding a central boiler](/images/config-central-boiler-1.png?raw=true)
+
+On the following page you can configure the services to be called when switching the boiler on/off:
+
+![Adding a central boiler](/images/config-central-boiler-2.png?raw=true)
+
+The services are configured as indicated 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 that controls the boiler in the form `domain.entity_name`. For example: `switch.boiler` for boilers controlled by a switch or `climate.boiler` for a boiler controlled by a thermostat or any other entity which allows control of the boiler (there is no limitation). We can also switch inputs (`helpers`) like `input_boolean` or `input_number`.
+3. `service_id` is the name of the service to call 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. For some service you will need a parameter. This can be the 'HVAC Mode' `climate.set_hvac_mode` or the target temperature for `climate.set_temperature`. This parameter must be configured in the form `attribute:value` at the end of the string.
+
+Examples (to be adjusted to your case):
+- `climate.chaudiere/climate.set_hvac_mode/hvac_mode:heat`: to turn on the boiler thermostat in heating mode,
+- `climate.chaudiere/climate.set_hvac_mode/hvac_mode:off`: to stop the boiler thermostat,
+- `switch.pompe_chaudiere/switch.turn_on`: to turn on the switch which powers the boiler pump,
+- `switch.pompe_chaudiere/switch.turn_off`: to turn on the switch which powers the boiler pump,
+- ...
+
+### How to find the right service?
+To find the service to use, the best is to go to "Development tools / Services", look for the service called, the entity to order and the possible parameter to give.
+Click on 'Call Service'. If your boiler lights up you have the correct configuration. Then switch to Yaml mode and copy the parameters.
+
+Example:
+
+Under "Development Tools / Service":
+
+![Service configuration](/images/dev-tools-turnon-boiler-1.png?raw=true)
+
+In yaml mode:
+
+![Service configuration](/images/dev-tools-turnon-boiler-2.png?raw=true)
+
+The service to configure is then the following: `climate.empty_thermostast/climate.set_hvac_mode/hvac_mode:heat` (note the removal of the blank in `hvac_mode:heat`)
+
+Then do the same for the extinguishing service and you are all set.
+
+### The events
+
+Each time the boiler is successfully switched on or off, an event is sent by Versatile Thermostat. It can advantageously be captured by automation, for example to notify a change.
+The events look like this:
+
+An ignition event:
+```
+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
+```
+
+An extinction event:
+```
+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
+
+> ![Tip](https://github.com/jmcollin78/versatile_thermostat/blob/main/images/tips.png?raw=true) _*Notes*_
+> Controlling a central boiler using software or hardware such as home automation can pose risks to its proper functioning. Before using these functions, make sure that your boiler has safety functions and that they are working. Turning on a boiler if all the taps are closed can generate excess pressure, for example.
+
 ## Parameters synthesis

 | Paramètre                                 | Libellé                                                                       | "over switch" | "over climate"      | "over valve" | "central configuration" |
@@ -605,7 +706,12 @@ Example rendering:
 | ``auto_regulation_dtemp``                 | La seuil d'auto-régulation                                                    | -             | X                   | -            | -                       |
 | ``auto_regulation_period_min``            | La période minimale d'auto-régulation                                         | -             | X                   | -            | -                       |
 | ``inverse_switch_command``                | Inverse the switch command (for pilot wire switch)                            | X             | -                   | -            | -                       |
-| ``auto_fan_mode`                          | Auto fan mode                                                                 | -             | X                   | -            | -                       |
+| ``auto_fan_mode``                         | Auto fan mode                                                                 | -             | X                   | -            | -                       |
+| ``add_central_boiler_control``            | Add the control of a central boiler                                           | -             | -                   | -            | X                       |
+| ``central_boiler_activation_service``     | Activation service of the boiler                                              | -             | -                   | -            | X                       |
+| ``central_boiler_deactivation_service``   | Deactivaiton service of the boiler                                            | -             | -                   | -            | X                       |
+| ``used_by_controls_central_boiler``       | Indicate if the VTherm control the central boiler                             | X             | X                   | X            | -                       |
+

 # Examples tuning

@@ -799,6 +905,7 @@ The notified events are as follows:
 - ``versatile_thermostat_temperature_event``: one or both temperature measurements of a thermostat have not been updated for more than ``security_delay_min`` minutes
 - ``versatile_thermostat_hvac_mode_event``: the thermostat is on or off. This event is also broadcast when the thermostat starts up
 - ``versatile_thermostat_preset_event``: a new preset is selected on the thermostat. This event is also broadcast when the thermostat starts up
+- ``versatile_thermostat_central_boiler_event``: an event indicating a change in the state of the central boiler.

 If you have followed correctly, when a thermostat goes into safety mode, 3 events are triggered:
 1. ``versatile_thermostat_temperature_event`` to indicate that a thermometer has become unresponsive,
@@ -858,6 +965,7 @@ Custom attributes are the following:
 | ``is_inversed``                   | True if the command is inversed (pilot wire with diode)                                                                          |
 | ``is_controlled_by_central_mode`` | True if the VTherm can be centrally controlled                                                                                   |
 | ``last_central_mode``             | The last central mode used (None if the VTherm is not centrally controlled)                                                      |
+| ``is_used_by_central_boiler``     | Indicate if the VTherm can control the central boiler                                                                            |

 # Some results

--- a/custom_components/versatile_thermostat/init.py
+++ b/custom_components/versatile_thermostat/init.py
@@ -105,6 +105,9 @@ async def reload_all_vtherm(hass):
    ]

    await asyncio.gather(*reload_tasks)
+    api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(hass)
+    if api:
+        await api.reload_central_boiler_entities_list()


 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
@@ -133,6 +136,10 @@ async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
        await reload_all_vtherm(hass)
    else:
        await hass.config_entries.async_reload(entry.entry_id)
+        # Reload the central boiler list of entities
+        api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(hass)
+        if api is not None:
+            await api.reload_central_boiler_entities_list()


 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
@@ -142,6 +149,7 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
        if api:
            api.remove_entry(entry)
+            await api.reload_central_boiler_entities_list()

    return unload_ok

--- a/custom_components/versatile_thermostat/base_thermostat.py
+++ b/custom_components/versatile_thermostat/base_thermostat.py
@@ -121,6 +121,7 @@ from .const import (
    CENTRAL_MODE_HEAT_ONLY,
    CENTRAL_MODE_COOL_ONLY,
    CENTRAL_MODE_FROST_PROTECTION,
+    send_vtherm_event,
 )

 from .config_schema import *  # pylint: disable=wildcard-import, unused-wildcard-import
@@ -203,6 +204,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
                    "temperature_unit",
                    "is_device_active",
                    "target_temperature_step",
+                    "is_used_by_central_boiler",
                }
            )
        )
@@ -283,6 +285,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity):

        self._is_central_mode = None
        self._last_central_mode = None
+        self._is_used_by_central_boiler = False
        self.post_init(entry_infos)

    def clean_central_config_doublon(self, config_entry, central_config) -> dict:
@@ -569,6 +572,10 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
            entry_infos.get(CONF_USE_CENTRAL_MODE) is False
        )  # Default value (None) is True

+        self._is_used_by_central_boiler = (
+            entry_infos.get(CONF_USED_BY_CENTRAL_BOILER) is True
+        )
+
        _LOGGER.debug(
            "%s - Creation of a new VersatileThermostat entity: unique_id=%s",
            self,
@@ -1010,6 +1017,12 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
            action = HVACAction.HEATING
        return action

+    @property
+    def is_used_by_central_boiler(self) -> HVACAction | None:
+        """Return true is the VTherm is configured to be used by
+        central boiler"""
+        return self._is_used_by_central_boiler
+
    @property
    def target_temperature(self):
        """Return the temperature we try to reach."""
@@ -1855,7 +1868,10 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
        )

        if self.window_bypass_state or not self.is_window_auto_enabled:
-            _LOGGER.info("%s - Window auto event is ignored because bypass is ON or window auto detection is disabled", self)
+            _LOGGER.info(
+                "%s - Window auto event is ignored because bypass is ON or window auto detection is disabled",
+                self,
+            )
            return

        if (
@@ -2404,6 +2420,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
            "temperature_unit": self.temperature_unit,
            "is_device_active": self.is_device_active,
            "ema_temp": self._ema_temp,
+            "is_used_by_central_boiler": self.is_used_by_central_boiler,
        }

    @callback
@@ -2526,8 +2543,9 @@ class BaseThermostat(ClimateEntity, RestoreEntity):

    def send_event(self, event_type: EventType, data: dict):
        """Send an event"""
-        _LOGGER.info("%s - Sending event %s with data: %s", self, event_type, data)
-        data["entity_id"] = self.entity_id
-        data["name"] = self.name
-        data["state_attributes"] = self.state_attributes
-        self._hass.bus.fire(event_type.value, data)
+        send_vtherm_event(self._hass, event_type=event_type, entity=self, data=data)
+        # _LOGGER.info("%s - Sending event %s with data: %s", self, event_type, data)
+        # data["entity_id"] = self.entity_id
+        # data["name"] = self.name
+        # data["state_attributes"] = self.state_attributes
+        # self._hass.bus.fire(event_type.value, data)
--- a/custom_components/versatile_thermostat/binary_sensor.py
+++ b/custom_components/versatile_thermostat/binary_sensor.py
@@ -1,9 +1,21 @@
 """ Implements the VersatileThermostat binary sensors component """
+# pylint: disable=unused-argument
+
 import logging

-from homeassistant.core import HomeAssistant, callback, Event
+from homeassistant.core import (
+    HomeAssistant,
+    callback,
+    Event,
+    CoreState,
+    HomeAssistantError,
+)

-from homeassistant.const import STATE_ON, STATE_OFF
+from homeassistant.const import STATE_ON, STATE_OFF, EVENT_HOMEASSISTANT_START
+
+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.components.binary_sensor import (
    BinarySensorEntity,
@@ -13,8 +25,22 @@ from homeassistant.config_entries import ConfigEntry

 from homeassistant.helpers.entity_platform import AddEntitiesCallback

-from .commons import VersatileThermostatBaseEntity
+from homeassistant.components.climate import (
+    ClimateEntity,
+    HVACMode,
+    HVACAction,
+    DOMAIN as CLIMATE_DOMAIN,
+)
+
+from custom_components.versatile_thermostat.base_thermostat import BaseThermostat
+from .vtherm_api import VersatileThermostatAPI
+from .commons import (
+    VersatileThermostatBaseEntity,
+    check_and_extract_service_configuration,
+)
 from .const import (
+    DOMAIN,
+    DEVICE_MANUFACTURER,
    CONF_NAME,
    CONF_USE_POWER_FEATURE,
    CONF_USE_PRESENCE_FEATURE,
@@ -22,6 +48,11 @@ from .const import (
    CONF_USE_WINDOW_FEATURE,
    CONF_THERMOSTAT_TYPE,
    CONF_THERMOSTAT_CENTRAL_CONFIG,
+    CONF_CENTRAL_BOILER_ACTIVATION_SRV,
+    CONF_CENTRAL_BOILER_DEACTIVATION_SRV,
+    overrides,
+    EventType,
+    send_vtherm_event,
 )

 _LOGGER = logging.getLogger(__name__)
@@ -42,20 +73,22 @@ async def async_setup_entry(
    vt_type = entry.data.get(CONF_THERMOSTAT_TYPE)

    if vt_type == CONF_THERMOSTAT_CENTRAL_CONFIG:
-        return
-
-    entities = [
-        SecurityBinarySensor(hass, unique_id, name, entry.data),
-        WindowByPassBinarySensor(hass, unique_id, name, entry.data),
-    ]
-    if entry.data.get(CONF_USE_MOTION_FEATURE):
-        entities.append(MotionBinarySensor(hass, unique_id, name, entry.data))
-    if entry.data.get(CONF_USE_WINDOW_FEATURE):
-        entities.append(WindowBinarySensor(hass, unique_id, name, entry.data))
-    if entry.data.get(CONF_USE_PRESENCE_FEATURE):
-        entities.append(PresenceBinarySensor(hass, unique_id, name, entry.data))
-    if entry.data.get(CONF_USE_POWER_FEATURE):
-        entities.append(OverpoweringBinarySensor(hass, unique_id, name, entry.data))
+        entities = [
+            CentralBoilerBinarySensor(hass, unique_id, name, entry.data),
+        ]
+    else:
+        entities = [
+            SecurityBinarySensor(hass, unique_id, name, entry.data),
+            WindowByPassBinarySensor(hass, unique_id, name, entry.data),
+        ]
+        if entry.data.get(CONF_USE_MOTION_FEATURE):
+            entities.append(MotionBinarySensor(hass, unique_id, name, entry.data))
+        if entry.data.get(CONF_USE_WINDOW_FEATURE):
+            entities.append(WindowBinarySensor(hass, unique_id, name, entry.data))
+        if entry.data.get(CONF_USE_PRESENCE_FEATURE):
+            entities.append(PresenceBinarySensor(hass, unique_id, name, entry.data))
+        if entry.data.get(CONF_USE_POWER_FEATURE):
+            entities.append(OverpoweringBinarySensor(hass, unique_id, name, entry.data))

    async_add_entities(entities, True)

@@ -269,7 +302,6 @@ class PresenceBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
            return "mdi:nature-people"


-# PR - Adding Window ByPass
 class WindowByPassBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity):
    """Representation of a BinarySensor which exposes the Window ByPass state"""

@@ -307,3 +339,161 @@ class WindowByPassBinarySensor(VersatileThermostatBaseEntity, BinarySensorEntity
            return "mdi:window-shutter-cog"
        else:
            return "mdi:window-shutter-auto"
+
+
+class CentralBoilerBinarySensor(BinarySensorEntity):
+    """Representation of a BinarySensor which exposes the Central Boiler state"""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        unique_id,
+        name,  # pylint: disable=unused-argument
+        entry_infos,
+    ) -> None:
+        """Initialize the CentralBoiler Binary sensor"""
+        self._config_id = unique_id
+        self._attr_name = "Central boiler"
+        self._attr_unique_id = "central_boiler_state"
+        self._attr_is_on = False
+        self._device_name = entry_infos.get(CONF_NAME)
+        self._entities = []
+        self._hass = hass
+        self._service_activate = check_and_extract_service_configuration(
+            entry_infos.get(CONF_CENTRAL_BOILER_ACTIVATION_SRV)
+        )
+        self._service_deactivate = check_and_extract_service_configuration(
+            entry_infos.get(CONF_CENTRAL_BOILER_DEACTIVATION_SRV)
+        )
+
+    @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,
+        )
+
+    @property
+    def device_class(self) -> BinarySensorDeviceClass | None:
+        return BinarySensorDeviceClass.RUNNING
+
+    @property
+    def icon(self) -> str | None:
+        if self._attr_is_on:
+            return "mdi:water-boiler"
+        else:
+            return "mdi:water-boiler-off"
+
+    @overrides
+    async def async_added_to_hass(self) -> None:
+        await super().async_added_to_hass()
+
+        @callback
+        async def _async_startup_internal(*_):
+            _LOGGER.debug("%s - Calling async_startup_internal", self)
+            api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(
+                self._hass
+            )
+            api.register_central_boiler(self)
+            await self.listen_vtherms_entities()
+
+        if self.hass.state == CoreState.running:
+            await _async_startup_internal()
+        else:
+            self.hass.bus.async_listen_once(
+                EVENT_HOMEASSISTANT_START, _async_startup_internal
+            )
+
+    async def listen_vtherms_entities(self):
+        """Initialize the listening of state change of VTherms"""
+
+        # Listen to all VTherm state change
+        self._entities = []
+        entities_id = []
+
+        component: EntityComponent[ClimateEntity] = self.hass.data[CLIMATE_DOMAIN]
+        for entity in component.entities:
+            if isinstance(entity, BaseThermostat) and entity.is_used_by_central_boiler:
+                self._entities.append(entity)
+                entities_id.append(entity.entity_id)
+        if len(self._entities) > 0:
+            # Arme l'écoute de la première entité
+            listener_cancel = async_track_state_change_event(
+                self._hass,
+                entities_id,
+                self.calculate_central_boiler_state,
+            )
+            _LOGGER.info(
+                "%s - VTherm that could controls the central boiler are %s",
+                self,
+                entities_id,
+            )
+            self.async_on_remove(listener_cancel)
+        else:
+            _LOGGER.debug("%s - no VTherm could controls the central boiler", self)
+
+        await self.calculate_central_boiler_state(None)
+
+    async def calculate_central_boiler_state(self, _):
+        """Calculate the central boiler state depending on all VTherm that
+        controls this central boiler"""
+
+        _LOGGER.debug("%s - calculating the new central boiler state", self)
+        active = False
+        for entity in self._entities:
+            _LOGGER.debug(
+                "Examining the hvac_action of %s",
+                entity.name,
+            )
+            if (
+                entity.hvac_mode == HVACMode.HEAT
+                and entity.hvac_action == HVACAction.HEATING
+            ):
+                active = True
+                break
+
+        if self._attr_is_on != active:
+            try:
+                if active:
+                    await self.call_service(self._service_activate)
+                    _LOGGER.info("%s - central boiler have been turned on", self)
+                else:
+                    await self.call_service(self._service_deactivate)
+                    _LOGGER.info("%s - central boiler have been turned off", self)
+                self._attr_is_on = active
+                send_vtherm_event(
+                    hass=self._hass,
+                    event_type=EventType.CENTRAL_BOILER_EVENT,
+                    entity=self,
+                    data={"central_boiler": active},
+                )
+                self.async_write_ha_state()
+            except HomeAssistantError as err:
+                _LOGGER.error(
+                    "%s - Impossible to activate/deactivat boiler due to error %s."
+                    "Central boiler will not being controled by VTherm."
+                    "Please check your service configuration. Cf. README.",
+                    self,
+                    err,
+                )
+
+    async def call_service(self, service_config: dict):
+        """Make a call to a service if correctly configured"""
+        if not service_config:
+            return
+
+        await self._hass.services.async_call(
+            service_config["service_domain"],
+            service_config["service_name"],
+            service_data=service_config["data"],
+            target={
+                "entity_id": service_config["entity_id"],
+            },
+        )
+
+    def __str__(self):
+        return f"VersatileThermostat-{self.name}"
--- a/custom_components/versatile_thermostat/commons.py
+++ b/custom_components/versatile_thermostat/commons.py
@@ -1,4 +1,6 @@
 """ Some usefull commons class """
+# pylint: disable=line-too-long
+
 import logging
 from datetime import timedelta, datetime
 from homeassistant.core import HomeAssistant, callback, Event
@@ -10,41 +12,148 @@ from homeassistant.helpers.event import async_track_state_change_event, async_ca
 from homeassistant.util import dt as dt_util

 from .base_thermostat import BaseThermostat
-from .const import DOMAIN, DEVICE_MANUFACTURER
+from .const import DOMAIN, DEVICE_MANUFACTURER, ServiceConfigurationError

 _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"""
+    """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.
+        """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))
+        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:
-            nombre1 = 3.2
-            nombre2 = 4.7
-            x = 0.3

-            nombre_arrondi1 = round_to_nearest(nombre1, x)
-            nombre_arrondi2 = round_to_nearest(nombre2, x)
+def round_to_nearest(n: float, x: float) -> float:
+    """Round a number to the nearest x (which should be decimal but not null)
+    Example:
+        nombre1 = 3.2
+        nombre2 = 4.7
+        x = 0.3

-            print(nombre_arrondi1)  # Output: 3.3
-            print(nombre_arrondi2)  # Output: 4.6
+        nombre_arrondi1 = round_to_nearest(nombre1, x)
+        nombre_arrondi2 = round_to_nearest(nombre2, x)
+
+        print(nombre_arrondi1)  # Output: 3.3
+        print(nombre_arrondi2)  # Output: 4.6
    """
    assert x > 0
-    return round(n * (1/x)) / (1/x)
+    return round(n * (1 / x)) / (1 / x)
+
+
+def check_and_extract_service_configuration(service_config) -> dict:
+    """Raise a ServiceConfigurationError. In return you have a dict formatted like follows.
+    Example if you call with 'climate.central_boiler/climate.set_temperature/temperature:10':
+    {
+        "service_domain": "climate",
+        "service_name": "set_temperature",
+        "entity_id": "climate.central_boiler",
+        "entity_domain": "climate",
+        "entity_name": "central_boiler",
+        "data": {
+            "temperature": "10"
+        },
+        "attribute_name": "temperature",
+        "attribute_value: "10"
+    }
+
+    For this example 'switch.central_boiler/switch.turn_off' you will have this:
+    {
+        "service_domain": "switch",
+        "service_name": "turn_off",
+        "entity_id": "switch.central_boiler",
+        "entity_domain": "switch",
+        "entity_name": "central_boiler",
+        "data": { },
+    }
+
+    All values are striped (white space are removed) and are string
+    """
+
+    ret = {}
+
+    if service_config is None:
+        return ret
+
+    parties = service_config.split("/")
+    if len(parties) < 2:
+        raise ServiceConfigurationError(
+            f"Incorrect service configuration. Service {service_config} should be formatted with: 'entity_name/service_name[/data]'. See README for more information."
+        )
+    entity_id = parties[0]
+    service_name = parties[1]
+
+    service_infos = service_name.split(".")
+    if len(service_infos) != 2:
+        raise ServiceConfigurationError(
+            f"Incorrect service configuration. The service {service_config} should be formatted like: 'domain.service_name' (ex: 'switch.turn_on'). See README for more information."
+        )
+
+    ret.update(
+        {
+            "service_domain": service_infos[0].strip(),
+            "service_name": service_infos[1].strip(),
+        }
+    )
+
+    entity_infos = entity_id.split(".")
+    if len(entity_infos) != 2:
+        raise ServiceConfigurationError(
+            f"Incorrect service configuration. The entity_id {entity_id} should be formatted like: 'domain.entity_name' (ex: 'switch.central_boiler_switch'). See README for more information."
+        )
+
+    ret.update(
+        {
+            "entity_domain": entity_infos[0].strip(),
+            "entity_name": entity_infos[1].strip(),
+            "entity_id": entity_id.strip(),
+        }
+    )
+
+    if len(parties) == 3:
+        data = parties[2]
+        if len(data) > 0:
+            data_infos = None
+            data_infos = data.split(":")
+            if (
+                len(data_infos) != 2
+                or len(data_infos[0]) <= 0
+                or len(data_infos[1]) <= 0
+            ):
+                raise ServiceConfigurationError(
+                    f"Incorrect service configuration. The data {data} should be formatted like: 'attribute:value' (ex: 'value:25'). See README for more information."
+                )
+
+            ret.update(
+                {
+                    "attribute_name": data_infos[0].strip(),
+                    "attribute_value": data_infos[1].strip(),
+                    "data": {data_infos[0].strip(): data_infos[1].strip()},
+                }
+            )
+        else:
+            raise ServiceConfigurationError(
+                f"Incorrect service configuration. The data {data} should be formatted like: 'attribute:value' (ex: 'value:25'). See README for more information."
+            )
+    else:
+        ret.update({"data": {}})
+
+    _LOGGER.debug(
+        "check_and_extract_service_configuration(%s) gives '%s'", service_config, ret
+    )
+    return ret
+

 class VersatileThermostatBaseEntity(Entity):
    """A base class for all entities"""
@@ -130,7 +239,9 @@ class VersatileThermostatBaseEntity(Entity):
        await try_find_climate(None)

    @callback
-    async def async_my_climate_changed(self, event: Event):         # pylint: disable=unused-argument
+    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
        """
--- a/custom_components/versatile_thermostat/config_flow.py
+++ b/custom_components/versatile_thermostat/config_flow.py
@@ -23,6 +23,7 @@ from homeassistant.data_entry_flow import FlowHandler, FlowResult
 from .const import *  # pylint: disable=wildcard-import, unused-wildcard-import
 from .config_schema import *  # pylint: disable=wildcard-import, unused-wildcard-import
 from .vtherm_api import VersatileThermostatAPI
+from .commons import check_and_extract_service_configuration

 COMES_FROM = "comes_from"

@@ -191,6 +192,17 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
                    )
                    raise NoCentralConfig(conf)

+        # Check the service for central boiler format
+        if self._infos.get(CONF_ADD_CENTRAL_BOILER_CONTROL):
+            for conf in [
+                CONF_CENTRAL_BOILER_ACTIVATION_SRV,
+                CONF_CENTRAL_BOILER_DEACTIVATION_SRV,
+            ]:
+                try:
+                    check_and_extract_service_configuration(data.get(conf))
+                except ServiceConfigurationError as err:
+                    raise ServiceConfigurationError(conf) from err
+
    def merge_user_input(self, data_schema: vol.Schema, user_input: dict):
        """For each schema entry not in user_input, set or remove values in infos"""
        self._infos.update(user_input)
@@ -225,6 +237,8 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
                errors[str(err)] = "window_open_detection_method"
            except NoCentralConfig as err:
                errors[str(err)] = "no_central_config"
+            except ServiceConfigurationError as err:
+                errors[str(err)] = "service_configuration_format"
            except Exception:  # pylint: disable=broad-except
                _LOGGER.exception("Unexpected exception")
                errors["base"] = "unknown"
@@ -263,7 +277,10 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
        if self._infos[CONF_THERMOSTAT_TYPE] == CONF_THERMOSTAT_CENTRAL_CONFIG:
            self._infos[CONF_NAME] = CENTRAL_CONFIG_NAME
            schema = STEP_CENTRAL_MAIN_DATA_SCHEMA
-            next_step = self.async_step_tpi
+            if user_input and user_input.get(CONF_ADD_CENTRAL_BOILER_CONTROL) is True:
+                next_step = self.async_step_central_boiler
+            else:
+                next_step = self.async_step_tpi
        elif user_input and user_input.get(CONF_USE_MAIN_CENTRAL_CONFIG) is False:
            next_step = self.async_step_spec_main
            schema = STEP_MAIN_DATA_SCHEMA
@@ -278,7 +295,10 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
        """Handle the specific main flow steps"""
        _LOGGER.debug("Into ConfigFlow.async_step_spec_main user_input=%s", user_input)

-        schema = STEP_CENTRAL_MAIN_DATA_SCHEMA
+        if self._infos[CONF_THERMOSTAT_TYPE] == CONF_THERMOSTAT_CENTRAL_CONFIG:
+            schema = STEP_CENTRAL_MAIN_DATA_SCHEMA
+        else:
+            schema = STEP_CENTRAL_SPEC_MAIN_DATA_SCHEMA
        next_step = self.async_step_type

        self._infos[COMES_FROM] = "async_step_spec_main"
@@ -286,6 +306,19 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
        # This will return to async_step_main (to keep the "main" step)
        return await self.generic_step("main", schema, user_input, next_step)

+    async def async_step_central_boiler(
+        self, user_input: dict | None = None
+    ) -> FlowResult:
+        """Handle the central boiler flow steps"""
+        _LOGGER.debug(
+            "Into ConfigFlow.async_step_central_boiler user_input=%s", user_input
+        )
+
+        schema = STEP_CENTRAL_BOILER_SCHEMA
+        next_step = self.async_step_tpi
+
+        return await self.generic_step("central_boiler", schema, user_input, next_step)
+
    async def async_step_type(self, user_input: dict | None = None) -> FlowResult:
        """Handle the Type flow steps"""
        _LOGGER.debug("Into ConfigFlow.async_step_type user_input=%s", user_input)
--- a/custom_components/versatile_thermostat/config_schema.py
+++ b/custom_components/versatile_thermostat/config_schema.py
@@ -43,11 +43,12 @@ STEP_MAIN_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
        vol.Required(CONF_CYCLE_MIN, default=5): cv.positive_int,
        vol.Optional(CONF_DEVICE_POWER, default="1"): vol.Coerce(float),
        vol.Optional(CONF_USE_CENTRAL_MODE, default=True): cv.boolean,
+        vol.Required(CONF_USE_MAIN_CENTRAL_CONFIG, default=True): cv.boolean,
        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.Required(CONF_USE_MAIN_CENTRAL_CONFIG, default=True): cv.boolean,
+        vol.Required(CONF_USED_BY_CENTRAL_BOILER, default=False): cv.boolean,
    }
 )

@@ -58,6 +59,24 @@ STEP_CENTRAL_MAIN_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
        ),
        vol.Required(CONF_TEMP_MIN, default=7): vol.Coerce(float),
        vol.Required(CONF_TEMP_MAX, default=35): vol.Coerce(float),
+        vol.Required(CONF_ADD_CENTRAL_BOILER_CONTROL, default=False): cv.boolean,
+    }
+)
+
+STEP_CENTRAL_SPEC_MAIN_DATA_SCHEMA = vol.Schema(  # pylint: disable=invalid-name
+    {
+        vol.Required(CONF_EXTERNAL_TEMP_SENSOR): selector.EntitySelector(
+            selector.EntitySelectorConfig(domain=[SENSOR_DOMAIN, INPUT_NUMBER_DOMAIN]),
+        ),
+        vol.Required(CONF_TEMP_MIN, default=7): vol.Coerce(float),
+        vol.Required(CONF_TEMP_MAX, default=35): vol.Coerce(float),
+    }
+)
+
+STEP_CENTRAL_BOILER_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_CENTRAL_BOILER_ACTIVATION_SRV, default=""): str,
+        vol.Optional(CONF_CENTRAL_BOILER_DEACTIVATION_SRV, default=""): str,
    }
 )

--- a/custom_components/versatile_thermostat/const.py
+++ b/custom_components/versatile_thermostat/const.py
@@ -1,6 +1,8 @@
 # pylint: disable=line-too-long
 """Constants for the Versatile Thermostat integration."""

+import logging
+
 from enum import Enum
 from homeassistant.const import CONF_NAME, Platform

@@ -18,6 +20,8 @@ from .prop_algorithm import (
    PROPORTIONAL_FUNCTION_TPI,
 )

+_LOGGER = logging.getLogger(__name__)
+
 PRESET_AC_SUFFIX = "_ac"
 PRESET_ECO_AC = PRESET_ECO + PRESET_AC_SUFFIX
 PRESET_COMFORT_AC = PRESET_COMFORT + PRESET_AC_SUFFIX
@@ -120,6 +124,12 @@ CONF_USE_ADVANCED_CENTRAL_CONFIG = "use_advanced_central_config"

 CONF_USE_CENTRAL_MODE = "use_central_mode"

+CONF_ADD_CENTRAL_BOILER_CONTROL = "add_central_boiler_control"
+CONF_CENTRAL_BOILER_ACTIVATION_SRV = "central_boiler_activation_service"
+CONF_CENTRAL_BOILER_DEACTIVATION_SRV = "central_boiler_deactivation_service"
+
+CONF_USED_BY_CENTRAL_BOILER = "used_by_controls_central_boiler"
+
 DEFAULT_SHORT_EMA_PARAMS = {
    "max_alpha": 0.5,
    # In sec
@@ -250,6 +260,10 @@ ALL_CONF = (
        CONF_USE_PRESENCE_CENTRAL_CONFIG,
        CONF_USE_ADVANCED_CENTRAL_CONFIG,
        CONF_USE_CENTRAL_MODE,
+        CONF_ADD_CENTRAL_BOILER_CONTROL,
+        CONF_USED_BY_CENTRAL_BOILER,
+        CONF_CENTRAL_BOILER_ACTIVATION_SRV,
+        CONF_CENTRAL_BOILER_DEACTIVATION_SRV,
    ]
    + CONF_PRESETS_VALUES
    + CONF_PRESETS_AWAY_VALUES
@@ -393,10 +407,20 @@ class EventType(Enum):
    POWER_EVENT: str = "versatile_thermostat_power_event"
    TEMPERATURE_EVENT: str = "versatile_thermostat_temperature_event"
    HVAC_MODE_EVENT: str = "versatile_thermostat_hvac_mode_event"
+    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"


+def send_vtherm_event(hass, event_type: EventType, entity, data: dict):
+    """Send an event"""
+    _LOGGER.info("%s - Sending event %s with data: %s", entity, event_type, data)
+    data["entity_id"] = entity.entity_id
+    data["name"] = entity.name
+    data["state_attributes"] = entity.state_attributes
+    hass.bus.fire(event_type.value, data)
+
+
 class UnknownEntity(HomeAssistantError):
    """Error to indicate there is an unknown entity_id given."""

@@ -409,6 +433,10 @@ class NoCentralConfig(HomeAssistantError):
    """Error to indicate that we try to use a central configuration but no VTherm of type CENTRAL CONFIGURATION has been found"""


+class ServiceConfigurationError(HomeAssistantError):
+    """Error in the service configuration to control the central boiler"""
+
+
 class overrides:  # pylint: disable=invalid-name
    """An annotation to inform overrides"""

--- a/custom_components/versatile_thermostat/manifest.json
+++ b/custom_components/versatile_thermostat/manifest.json
@@ -14,6 +14,6 @@
  "quality_scale": "silver",
  "requirements": [],
  "ssdp": [],
-  "version": "5.2.2",
+  "version": "5.3.0",
  "zeroconf": []
-}
+}
--- a/custom_components/versatile_thermostat/strings.json
+++ b/custom_components/versatile_thermostat/strings.json
@@ -24,16 +24,16 @@
          "temp_min": "Minimal temperature allowed",
          "temp_max": "Maximal temperature allowed",
          "device_power": "Device power",
-          "use_central_mode": "Enable the control by central entity (need central config)",
+          "use_central_mode": "Enable the control by central entity (need central config). Check to enable the control of the VTherm with the select central_mode entities.",
          "use_window_feature": "Use window detection",
          "use_motion_feature": "Use motion detection",
          "use_power_feature": "Use power management",
          "use_presence_feature": "Use presence detection",
-          "use_main_central_config": "Use central main configuration"
+          "use_main_central_config": "Use central main configuration. Check to use the central main configuration. Uncheck to use a specific main configuration for this VTherm",
+          "add_central_boiler_control": "Add 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 need heating, the boiler will be turned on. If no VTherm needs heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the next configuration page",
+          "used_by_controls_central_boiler": "Used by central boiler. Check if this VTherm should have control on the central boiler"
        },
        "data_description": {
-          "use_central_mode": "Check to enable the control of the VTherm with the select central_mode entities",
-          "use_main_central_config": "Check to use the central main configuration. Uncheck to use a specific main configuration for this VTherm",
          "external_temperature_sensor_entity_id": "Outdoor temperature sensor entity id. Not used if central configuration is selected"
        }
      },
@@ -256,16 +256,16 @@
          "temp_min": "Minimal temperature allowed",
          "temp_max": "Maximal temperature allowed",
          "device_power": "Device power",
-          "use_central_mode": "Enable the control by central entity (need central config)",
+          "use_central_mode": "Enable the control by central entity (need central config). Check to enable the control of the VTherm with the select central_mode entities.",
          "use_window_feature": "Use window detection",
          "use_motion_feature": "Use motion detection",
          "use_power_feature": "Use power management",
          "use_presence_feature": "Use presence detection",
-          "use_main_central_config": "Use central main configuration"
+          "use_main_central_config": "Use central main configuration. Check to use the central main configuration. Uncheck to use a specific main configuration for this VTherm",
+          "add_central_boiler_control": "Add 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 need heating, the boiler will be turned on. If no VTherm needs heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the next configuration page",
+          "used_by_controls_central_boiler": "Used by central boiler. Check if this VTherm should have control on the central boiler"
        },
        "data_description": {
-          "use_central_mode": "Check to enable the control of the VTherm with the select central_mode entities",
-          "use_main_central_config": "Check to use the central main configuration. Uncheck to use a specific configuration for this VTherm",
          "external_temperature_sensor_entity_id": "Outdoor temperature sensor entity id. Not used if central configuration is selected"
        }
      },
@@ -458,7 +458,8 @@
      "unknown": "Unexpected error",
      "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."
+      "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"
    },
    "abort": {
      "already_configured": "Device is already configured"
--- a/custom_components/versatile_thermostat/thermostat_switch.py
+++ b/custom_components/versatile_thermostat/thermostat_switch.py
@@ -208,5 +208,6 @@ class ThermostatOverSwitch(BaseThermostat):
            return
        if old_state is None:
            self.hass.create_task(self._check_initial_state())
+
        self.async_write_ha_state()
        self.update_custom_attributes()
--- a/custom_components/versatile_thermostat/thermostat_valve.py
+++ b/custom_components/versatile_thermostat/thermostat_valve.py
@@ -13,7 +13,13 @@ from homeassistant.components.climate import HVACMode
 from .base_thermostat import BaseThermostat
 from .prop_algorithm import PropAlgorithm

-from .const import CONF_VALVE, CONF_VALVE_2, CONF_VALVE_3, CONF_VALVE_4, overrides
+from .const import (
+    CONF_VALVE,
+    CONF_VALVE_2,
+    CONF_VALVE_3,
+    CONF_VALVE_4,
+    overrides,
+)

 from .underlyings import UnderlyingValve

--- a/custom_components/versatile_thermostat/translations/en.json
+++ b/custom_components/versatile_thermostat/translations/en.json
@@ -24,16 +24,16 @@
          "temp_min": "Minimal temperature allowed",
          "temp_max": "Maximal temperature allowed",
          "device_power": "Device power",
-          "use_central_mode": "Enable the control by central entity (need central config)",
+          "use_central_mode": "Enable the control by central entity (need central config). Check to enable the control of the VTherm with the select central_mode entities.",
          "use_window_feature": "Use window detection",
          "use_motion_feature": "Use motion detection",
          "use_power_feature": "Use power management",
          "use_presence_feature": "Use presence detection",
-          "use_main_central_config": "Use central main configuration"
+          "use_main_central_config": "Use central main configuration. Check to use the central main configuration. Uncheck to use a specific main configuration for this VTherm",
+          "add_central_boiler_control": "Add 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 need heating, the boiler will be turned on. If no VTherm needs heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the next configuration page",
+          "used_by_controls_central_boiler": "Used by central boiler. Check if this VTherm should have control on the central boiler"
        },
        "data_description": {
-          "use_central_mode": "Check to enable the control of the VTherm with the select central_mode entities",
-          "use_main_central_config": "Check to use the central main configuration. Uncheck to use a specific main configuration for this VTherm",
          "external_temperature_sensor_entity_id": "Outdoor temperature sensor entity id. Not used if central configuration is selected"
        }
      },
@@ -256,16 +256,16 @@
          "temp_min": "Minimal temperature allowed",
          "temp_max": "Maximal temperature allowed",
          "device_power": "Device power",
-          "use_central_mode": "Enable the control by central entity (need central config)",
+          "use_central_mode": "Enable the control by central entity (need central config). Check to enable the control of the VTherm with the select central_mode entities.",
          "use_window_feature": "Use window detection",
          "use_motion_feature": "Use motion detection",
          "use_power_feature": "Use power management",
          "use_presence_feature": "Use presence detection",
-          "use_main_central_config": "Use central main configuration"
+          "use_main_central_config": "Use central main configuration. Check to use the central main configuration. Uncheck to use a specific main configuration for this VTherm",
+          "add_central_boiler_control": "Add 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 need heating, the boiler will be turned on. If no VTherm needs heating, the boiler will be turned off. Commands for turning on/off the central boiler are given in the next configuration page",
+          "used_by_controls_central_boiler": "Used by central boiler. Check if this VTherm should have control on the central boiler"
        },
        "data_description": {
-          "use_central_mode": "Check to enable the control of the VTherm with the select central_mode entities",
-          "use_main_central_config": "Check to use the central main configuration. Uncheck to use a specific configuration for this VTherm",
          "external_temperature_sensor_entity_id": "Outdoor temperature sensor entity id. Not used if central configuration is selected"
        }
      },
@@ -458,7 +458,8 @@
      "unknown": "Unexpected error",
      "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."
+      "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"
    },
    "abort": {
      "already_configured": "Device is already configured"
--- a/custom_components/versatile_thermostat/translations/fr.json
+++ b/custom_components/versatile_thermostat/translations/fr.json
@@ -24,17 +24,17 @@
          "temp_min": "Température minimale permise",
          "temp_max": "Température maximale permise",
          "device_power": "Puissance de l'équipement",
-          "use_central_mode": "Autoriser le controle par une entity centrale ('nécessite une config. centrale`)",
+          "use_central_mode": "Autoriser le controle par une entity centrale ('nécessite une config. centrale`). Cochez pour autoriser le contrôle du VTherm par la liste déroulante 'central_mode' de l'entité configuration centrale.",
          "use_window_feature": "Avec détection des ouvertures",
          "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_main_central_config": "Utiliser la configuration centrale principale"
+          "use_main_central_config": "Utiliser la configuration centrale. Cochez pour utiliser la configuration centrale. Décochez et saisissez les attributs pour utiliser une configuration spécifique.",
+          "add_central_boiler_control": "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.",
+          "used_by_controls_central_boiler": "Utilisé par la chaudière centrale. Cochez si ce VTherm doit contrôler la chaudière centrale."
        },
        "data_description": {
-          "use_central_mode": "Cochez pour autoriser le contrôle du VTherm par la liste déroulante 'central_mode' de l'entité configuration centrale",
-          "external_temperature_sensor_entity_id": "Entity id du capteur de température extérieure.",
-          "use_main_central_config": "Cochez pour utiliser la configuration centrale principale. Décochez et saisissez les attributs pour utiliser une configuration spécifique principale"
+          "external_temperature_sensor_entity_id": "Entity id du capteur de température extérieure."
        }
      },
      "type": {
@@ -220,6 +220,18 @@
          "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é",
          "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`",
+        "data": {
+          "central_boiler_activation_service": "Commande pour allumer",
+          "central_boiler_deactivation_service": "Commande pour éteindre"
+        },
+        "data_description": {
+          "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]"
+        }
      }
    },
    "error": {
@@ -256,17 +268,17 @@
          "temp_min": "Température minimale permise",
          "temp_max": "Température maximale permise",
          "device_power": "Puissance de l'équipement",
-          "use_central_mode": "Autoriser le controle par une entity centrale ('nécessite une config. centrale`)",
+          "use_central_mode": "Autoriser le controle par une entity centrale ('nécessite une config. centrale`). Cochez pour autoriser le contrôle du VTherm par la liste déroulante 'central_mode' de l'entité configuration centrale.",
          "use_window_feature": "Avec détection des ouvertures",
          "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_main_central_config": "Utiliser la configuration centrale"
+          "use_main_central_config": "Utiliser la configuration centrale. Cochez pour utiliser la configuration centrale. Décochez et saisissez les attributs pour utiliser une configuration spécifique.",
+          "add_central_boiler_control": "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.",
+          "used_by_controls_central_boiler": "Utilisé par la chaudière centrale. Cochez si ce VTherm doit contrôler la chaudière centrale."
        },
        "data_description": {
-          "use_central_mode": "Cochez pour autoriser le contrôle du VTherm par la liste déroulante 'central_mode' de l'entité configuration centrale",
-          "use_main_central_config": "Cochez pour utiliser la configuration centrale. Décochez et saisissez les attributs pour utiliser une configuration spécifique",
-          "external_temperature_sensor_entity_id": "Entity id du capteur de température extérieure. N'est pas utilisé si la configuration centrale est utilisée"
+          "external_temperature_sensor_entity_id": "Entity id du capteur de température extérieure. N'est pas utilisé si la configuration centrale est utilisée."
        }
      },
      "type": {
@@ -446,13 +458,26 @@
          "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é",
          "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`",
+        "data": {
+          "central_boiler_activation_service": "Commande pour allumer",
+          "central_boiler_deactivation_service": "Commande pour éteindre"
+        },
+        "data_description": {
+          "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]"
+        }
      }
    },
    "error": {
      "unknown": "Erreur inattendue",
      "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."
+      "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"
    },
    "abort": {
      "already_configured": "Le device est déjà configuré"
--- a/custom_components/versatile_thermostat/underlyings.py
+++ b/custom_components/versatile_thermostat/underlyings.py
@@ -758,21 +758,25 @@ class UnderlyingValve(UnderlyingEntity):
    async def turn_off(self):
        """Turn heater toggleable device off."""
        _LOGGER.debug("%s - Stopping underlying valve entity %s", self, self._entity_id)
-        self._percent_open = 0
-        if self.is_device_active:
+        # Issue 341
+        is_active = self.is_device_active
+        self._percent_open = self.cap_sent_value(0)
+        if is_active:
            await self.send_percent_open()

    async def turn_on(self):
        """Nothing to do for Valve because it cannot be turned off"""
+        self.set_valve_open_percent()

    async def set_hvac_mode(self, hvac_mode: HVACMode) -> bool:
        """Set the HVACmode. Returns true if something have change"""

-        if hvac_mode == HVACMode.OFF:
-            await self.turn_off()
-
        if self._hvac_mode != hvac_mode:
            self._hvac_mode = hvac_mode
+            if hvac_mode == HVACMode.OFF:
+                await self.turn_off()
+            else:
+                await self.turn_on()
            return True
        else:
            return False
--- a/custom_components/versatile_thermostat/vtherm_api.py
+++ b/custom_components/versatile_thermostat/vtherm_api.py
@@ -46,6 +46,7 @@ class VersatileThermostatAPI(dict):
        super().__init__()
        self._expert_params = None
        self._short_ema_params = None
+        self._central_boiler_entity = None

    def find_central_configuration(self):
        """Search for a central configuration"""
@@ -87,6 +88,16 @@ class VersatileThermostatAPI(dict):
        if self._short_ema_params:
            _LOGGER.debug("We have found short ema params %s", self._short_ema_params)

+    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"""
+        self._central_boiler_entity = central_boiler_entity
+
+    async def reload_central_boiler_entities_list(self):
+        """Reload the central boiler list of entities if a central boiler is used"""
+        if self._central_boiler_entity is not None:
+            await self._central_boiler_entity.listen_vtherms_entities()
+
    @property
    def self_regulation_expert(self):
        """Get the self regulation params"""
--- a/images/config-central-boiler-1.png
+++ b/images/config-central-boiler-1.png
--- a/images/config-central-boiler-2.png
+++ b/images/config-central-boiler-2.png
--- a/images/dev-tools-turnon-boiler-1.png
+++ b/images/dev-tools-turnon-boiler-1.png
--- a/images/dev-tools-turnon-boiler-2.png
+++ b/images/dev-tools-turnon-boiler-2.png
--- a/tests/test_config_flow.py
+++ b/tests/test_config_flow.py
@@ -143,6 +143,8 @@ async def test_user_config_flow_over_switch(
            CONF_USE_POWER_CENTRAL_CONFIG: True,
            CONF_USE_PRESENCE_CENTRAL_CONFIG: True,
            CONF_USE_ADVANCED_CENTRAL_CONFIG: True,
+            CONF_USE_CENTRAL_MODE: True,
+            CONF_USED_BY_CENTRAL_BOILER: False,
        }
    )
    assert result["result"]
@@ -239,6 +241,7 @@ async def test_user_config_flow_over_climate(
        CONF_USE_POWER_CENTRAL_CONFIG: False,
        CONF_USE_PRESENCE_CENTRAL_CONFIG: False,
        CONF_USE_ADVANCED_CENTRAL_CONFIG: False,
+        CONF_USED_BY_CENTRAL_BOILER: False,
    }
    assert result["result"]
    assert result["result"].domain == DOMAIN
@@ -287,6 +290,7 @@ async def test_user_config_flow_window_auto_ok(
            CONF_USE_POWER_FEATURE: False,
            CONF_USE_PRESENCE_FEATURE: False,
            CONF_USE_MAIN_CENTRAL_CONFIG: True,
+            CONF_USED_BY_CENTRAL_BOILER: True,
        },
    )

@@ -373,6 +377,7 @@ async def test_user_config_flow_window_auto_ok(
        CONF_USE_POWER_CENTRAL_CONFIG: False,
        CONF_USE_PRESENCE_CENTRAL_CONFIG: False,
        CONF_USE_ADVANCED_CENTRAL_CONFIG: True,
+        CONF_USED_BY_CENTRAL_BOILER: True,
    }
    assert result["result"]
    assert result["result"].domain == DOMAIN
@@ -512,6 +517,7 @@ async def test_user_config_flow_over_4_switches(
        CONF_USE_PRESENCE_FEATURE: False,
        CONF_USE_MAIN_CENTRAL_CONFIG: True,
        CONF_USE_CENTRAL_MODE: False,
+        CONF_USED_BY_CENTRAL_BOILER: False,
    }

    TYPE_CONFIG = {  # pylint: disable=wildcard-import, invalid-name
--- a/tests/test_valve.py
+++ b/tests/test_valve.py
@@ -321,9 +321,6 @@ async def test_over_valve_full_start(
            await try_condition(None)

            assert entity.hvac_mode is HVACMode.HEAT
-            assert (
-                entity.hvac_action is HVACAction.OFF
-                or entity.hvac_action is HVACAction.IDLE
-            )
+            assert entity.hvac_action is HVACAction.HEATING
            assert entity.target_temperature == 17.1  # eco
            assert entity.valve_open_percent == 10
Author	SHA1	Message	Date
Jean-Marc Collin	67844d4ae8	FIX #341 - when window state change, open_valve_percent should be resend	2024-01-14 23:02:23 +00:00
Jean-Marc Collin	513e65f79c	Add events in README	2024-01-14 16:50:59 +00:00
Jean-Marc Collin	31f782ffa3	Documentation and release.	2024-01-14 16:44:38 +00:00
Jean-Marc Collin	2831257732	Full featured but without testu	2024-01-14 12:37:09 +00:00
Jean-Marc Collin	0343d0f0e8	Fonctional before testu. Miss the service call	2024-01-14 00:33:52 +00:00
Jean-Marc Collin	208c80752c	Creation of the central boiler config + binary_sensor entity	2024-01-13 17:46:41 +00:00