Issue #244 - make ema params configurable. Try to reproduce bug on Security mode

* Add ema calculation class, calculate an emo temperature, use the ema_temperature in auto_window dectection

* Removes circular dependency error

* Fix ema_temp unknown and remove slope smoothing

* 15 sec between two slope calculation

* Take Maia feedbacks on the algo.

* Maia comments: change MAX_ALPHA to 0.5, add slope calculation at each cycle.

* With EMA entity and slope calculation optimisations

* Change open_window_detection fake datapoint threshold

* Try auto window new algo

* Don't store datetime of fake datapoint

* Change auto window threshold in °/hour

---------

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

.devcontainer/configuration.yaml

@@ -21,6 +21,10 @@ versatile_thermostat:
         offset_max: 5
         stabilization_threshold: 0.1
         accumulated_error_threshold: 50
+    short_ema_params:
+        max_alpha: 0.6
+        halflife_sec: 301
+        precision: 3
 
 input_number:
     fake_temperature_sensor1:

README-fr.md

@@ -58,19 +58,24 @@
   - [Toujours mieux avec Apex-chart pour régler votre thermostat](#toujours-mieux-avec-apex-chart-pour-régler-votre-thermostat)
   - [Et toujours de mieux en mieux avec l'AappDaemon NOTIFIER pour notifier les évènements](#et-toujours-de-mieux-en-mieux-avec-laappdaemon-notifier-pour-notifier-les-évènements)
 - [Les contributions sont les bienvenues !](#les-contributions-sont-les-bienvenues)
-
+- [Dépannages](#dépannages)
+  - [Utilisation d'un Heatzy](#utilisation-dun-heatzy)
+  - [Utilisation d'un radiateur avec un fil pilote](#utilisation-dun-radiateur-avec-un-fil-pilote)
+  - [Seul le premier radiateur chauffe](#seul-le-premier-radiateur-chauffe)
+  - [Régler les paramètres de détection d'ouverture de fenêtre en mode auto](#régler-les-paramètres-de-détection-douverture-de-fenêtre-en-mode-auto)
 
 Ce composant personnalisé pour Home Assistant est une mise à niveau et est une réécriture complète du composant "Awesome thermostat" (voir [Github](https://github.com/dadge/awesome_thermostat)) avec l'ajout de fonctionnalités.
 
 
 > ![Nouveau](https://github.com/jmcollin78/versatile_thermostat/blob/main/images/new-icon.png?raw=true) _*Nouveautés*_
+> * **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).
-> * **Release 3.7**: Ajout du type de **Versatile Thermostat `over valve`** pour piloter une vanne TRV directement ou tout autre équipement type gradateur pour le chauffage. La régulation se fait alors directement en agissant sur le pourcentage d'ouverture de l'entité sous-jacente : 0 la vanne est coupée, 100 : la vanne est ouverte à fond. Cf. [#131](https://github.com/jmcollin78/versatile_thermostat/issues/131). Ajout d'une fonction permettant le bypass de la détection d'ouverture [#138](https://github.com/jmcollin78/versatile_thermostat/issues/138). Ajout de la langue Slovaque
 <details>
 <summary>Autres versions</summary>
 
+> * **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).
+> * **Release 3.7**: Ajout du type de **Versatile Thermostat `over valve`** pour piloter une vanne TRV directement ou tout autre équipement type gradateur pour le chauffage. La régulation se fait alors directement en agissant sur le pourcentage d'ouverture de l'entité sous-jacente : 0 la vanne est coupée, 100 : la vanne est ouverte à fond. Cf. [#131](https://github.com/jmcollin78/versatile_thermostat/issues/131). Ajout d'une fonction permettant le bypass de la détection d'ouverture [#138](https://github.com/jmcollin78/versatile_thermostat/issues/138). Ajout de la langue Slovaque
 > * **Release 3.6**: Ajout du paramètre `motion_off_delay` pour améliorer la gestion de des mouvements [#116](https://github.com/jmcollin78/versatile_thermostat/issues/116), [#128](https://github.com/jmcollin78/versatile_thermostat/issues/128). Ajout du mode AC (air conditionné) pour un VTherm over switch. Préparation du projet Github pour faciliter les contributions [#127](https://github.com/jmcollin78/versatile_thermostat/issues/127)
 > * **Release 3.5**: Plusieurs thermostats sont possibles en "thermostat over climate" mode [#113](https://github.com/jmcollin78/versatile_thermostat/issues/113)
 > * **Release 3.4**: bug fix et exposition des preset temperatures pour le mode AC [#103](https://github.com/jmcollin78/versatile_thermostat/issues/103)
@@ -84,10 +89,11 @@ Ce composant personnalisé pour Home Assistant est une mise à niveau et est une
 </details>
 
 # Changements majeurs dans la version 4.0.0
-La puissance de l'appareil doit maintenant être la puissance totale de tous les appareils controlée par le VTherm. Cela permet d'avoir des équipements hétérogènes de puissance différente. Dans le cas de plusieurs appareils contrôlés par un seul VTherm, vous devrez éditer et changer la valeur `device_power`. Vous devez configurer la puissance totale de tous les appareils.
+1. La puissance de l'appareil doit maintenant être la puissance totale de tous les appareils controlée par le VTherm. Cela permet d'avoir des équipements hétérogènes de puissance différente. Dans le cas de plusieurs appareils contrôlés par un seul VTherm, vous devrez éditer et changer la valeur `device_power`. Vous devez configurer la puissance totale de tous les appareils.
+2. Le seuil de détection automatique des ouvertures doit être spécifié en °/heure et pas plus en °/min. Pour conserver les mêmes paramètres il faut multiplier la valeur configurée par 60.
 
 # Merci pour la bière [buymecoffee](https://www.buymeacoffee.com/jmcollin78)
-Un grand merci à @salabur, @pvince83, @bergoglio, @EPicLURcher, @ecolorado66, @Kriss1670, @maia, @f.maymil, @moutte69, @Jerome, @Gunnar M pour les bières. Ca fait très plaisir et ça m'encourage à continuer !
+Un grand merci à @salabur, @pvince83, @bergoglio, @EPicLURcher, @ecolorado66, @Kriss1670, @maia, @f.maymil, @moutte69, @Jerome, @Gunnar M, @Greg.o, @John Burgess pour les bières. Ca fait très plaisir et ça m'encourage à continuer !
 
 
 # Quand l'utiliser et ne pas l'utiliser
@@ -107,7 +113,7 @@ Les installations avec fil pilote et diode d'activation bénéficie d'une option
 ## Incompatibilités
 Certains thermostat de type TRV sont réputés incompatibles avec le Versatile Thermostat. C'est le cas des vannes suivantes :
 1. les vannes POPP de Danfoss avec retour de température. Il est impossible d'éteindre cette vanne et elle s'auto-régule d'elle-même causant des conflits avec le VTherm,
-2. les vannes thermstatiques "Homematic radio". Elles ont un cycle de service incompatible avec une commande par le Versatile Thermostat,
+2. Les thermostats « Homematic » (et éventuellement Homematic IP) sont connus pour rencontrer des problèmes avec le Versatile Thermostat en raison des limitations du protocole RF sous-jacent. Ce problème se produit particulièrement lorsque vous essayez de contrôler plusieurs thermostats Homematic à la fois dans une seule instance de VTherm. Afin de réduire la charge du cycle de service, vous pouvez par ex. regroupez les thermostats avec des procédures spécifiques à Homematic (par exemple en utilisant un thermostat mural) et laissez Versatile Thermostat contrôler uniquement le thermostat mural directement. Une autre option consiste à contrôler un seul thermostat et à propager les changements de mode CVC et de température par un automatisme,
 3. les thermostats de type Heatzy qui ne supportent pas les commandes de type set_temperature
 4. les thermostats de type Rointe ont tendance a se réveiller tout seul. Le reste fonctionne normalement.
 
@@ -483,8 +489,8 @@ Voir [exemple de réglages](#examples-tuning) pour avoir des exemples de réglag
 | - | - | - | - | - |
 | ``name`` | Nom | X | X | X |
 | ``thermostat_type`` | Type de thermostat | X | X | X |
-| ``temperature_sensor_entity_id`` | Temperature sensor entity id | X | - | X |
-| ``external_temperature_sensor_entity_id`` | Température exterieure sensor entity id | X | - | X |
+| ``temperature_sensor_entity_id`` | Temperature sensor entity id | X | X (auto-regulation) | X |
+| ``external_temperature_sensor_entity_id`` | Température de l'exterieur sensor entity id | X | X (auto-regulation) | X |
 | ``cycle_min`` | Durée du cycle (minutes) | X | X | X |
 | ``temp_min`` | Température minimale permise | X | X | X |
 | ``temp_max`` | Température maximale permise | X | X | X |
@@ -1037,6 +1043,82 @@ max: 30
 
 Si vous souhaitez contribuer, veuillez lire les [directives de contribution](CONTRIBUTING.md)
 
+# Dépannages
+
+## Utilisation d'un Heatzy
+L'utilisation d'un Heatzy est possible à la condition d'utiliser un switch virtuel sur ce modèle :
+```
+- platform: template
+  switches:
+    chauffage_sdb:
+      unique_id: chauffage_sdb
+      friendly_name: Chauffage salle de bain
+      value_template: "{{ is_state_attr('climate.salle_de_bain', 'preset_mode', 'comfort') }}"
+      icon_template: >-
+        {% if is_state_attr('climate.salle_de_bain', 'preset_mode', 'comfort') %}
+          mdi:radiator
+        {% elif is_state_attr('climate.salle_de_bain', 'preset_mode', 'away') %}
+          mdi:snowflake
+        {% else %}
+          mdi:radiator-disabled
+        {% endif %}
+      turn_on:
+        service: climate.set_preset_mode
+        entity_id: climate.salle_de_bain
+        data:
+          preset_mode: "comfort"
+      turn_off:
+        service: climate.set_preset_mode
+        entity_id: climate.salle_de_bain
+        data:
+          preset_mode: "eco"
+```
+Merci à @gael pour cet exemple.
+
+## Utilisation d'un radiateur avec un fil pilote
+Comme pour le Heatzy ci-dessus vous pouvez utiliser un switch virtuel qui va changer le preset de votre radiateur en fonction de l'état d'allumage du VTherm.
+Exemple :
+```
+- platform: template
+  switches:
+    radiateur_soan:
+        friendly_name: radiateur_soan_inv
+        value_template: "{{ is_state('switch.radiateur_soan', 'off') }}"
+        turn_on:
+          service: switch.turn_off
+          data:
+            entity_id: switch.radiateur_soan
+        turn_off:
+          service: switch.turn_on
+          data:
+            entity_id: switch.radiateur_soan
+        icon_template: "{% if is_state('switch.radiateur_soan', 'on') %}mdi:radiator-disabled{% else %}mdi:radiator{% endif %}"
+```
+
+## Seul le premier radiateur chauffe
+En mode `over_switch` si plusieurs radiateurs sont configurés pour un même VTherm, l'alllumage va se faire de façon séquentiel pour lisser au plus possible les pics de consommation.
+Cela est tout à fait normal et voulu. C'est décrit ici : [Pour un thermostat de type ```thermostat_over_switch```](#pour-un-thermostat-de-type-thermostat_over_switch)
+
+## Régler les paramètres de détection d'ouverture de fenêtre en mode auto
+
+Si vous n'arrivez pas à régler la fonction de détection des ouvertures en mode auto (cf. [auto](#le-mode-auto)), vous pouvez essayer de modifier les paramètres de l'algorithme de lissage de la température.
+En effet, la détection automatique d'ouverture est basée sur le calcul de la pente de la température (slope). Pour éviter les artefacts due à un capteur de température imprécis, cette pente est calculée sur une température lissée avec un algorithme de lissage nommée Exponential Moving Average (Moyenne mobile exponentielle).
+Cet algorithm possède 3 paramètres :
+1. `lifecycle_sec` : la durée en secondes prise en compte pour le lissage. Plus elle est forte et plus le lissage sera important mais plus il y aura de délai de détection,
+2. `max_alpha` : si deux mesures de température sont éloignées dans le temps, la deuxième aura un poid beaucoup fort. Le paramètre permet de limiter le poid d'une mesure qui arrive bien après la précédente. Cette valeur doit être comprise entre 0 et 1. Plus elle est faible et moins les valeurs éloignées sont prises en compte. La valeur par défaut est de 0,5. Cela fait que lorsqu'une nouvelle valeur de température ne pèsera jamais plus que la moitié de la moyenne mobile,
+3. `precision` : le nombre de chiffre après la virgule conservée pour le calcul de la moyenne mobile.
+
+Pour changer ses paramètres, il faut modifier le fichier `configuration.yaml` et ajouter la section suivante (les valeurs sont les valeurs par défaut):
+```
+versatile_thermostat:
+  short_ema_params:
+    max_alpha: 0.5
+    halflife_sec: 300
+    precision: 2
+```
+
+Ces paramètres sont sensibles et assez difficiles à régler. Merci de ne les utiliser que si vous savez ce que vous faites et que vos mesures de température ne sont pas déjà lisses.
+
 ***
 
 [versatile_thermostat]: https://github.com/jmcollin78/versatile_thermostat

README.md

@@ -57,11 +57,17 @@
   - [Even better with Apex-chart to tune your Thermostat](#even-better-with-apex-chart-to-tune-your-thermostat)
   - [And always better and better with the NOTIFIER daemon app to notify events](#and-always-better-and-better-with-the-notifier-daemon-app-to-notify-events)
 - [Contributions are welcome!](#contributions-are-welcome)
+- [Troubleshooting](#troubleshooting)
+  - [Using a Heatzy](#using-a-heatzy)
+  - [Using a Heatsink with a Pilot Wire](#using-a-heatsink-with-a-pilot-wire)
+  - [Only the first radiator heats](#only-the-first-radiator-heats)
+  - [Adjust window opening detection parameters in auto mode](#adjust-window-opening-detection-parameters-in-auto-mode)
 
 
 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 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).
@@ -82,17 +88,18 @@ This custom component for Home Assistant is an upgrade and is a complete rewrite
 </details>
 
 # Breaking changes in 4.0.0
-The power of the device should now be the total power of all controler devices by the VTherm. This allow to have eterogeneous equipment with different power. In case of multi-devices controlled by a single VTherm you will have to edit and change the `device_power` value. Set the total power of all devices.
+1. The power of the device should now be the total power of all controler devices by the VTherm. This allow to have eterogeneous equipment with different power. In case of multi-devices controlled by a single VTherm you will have to edit and change the `device_power` value. Set the total power of all devices.
+2. The threshold for auto window auto detection should be specified in °/hour and no more in °/min. To keep the same parameters you have to multiply the configured value by 60.
 
 # Thanks for the beer [buymecoffee](https://www.buymeacoffee.com/jmcollin78)
-Many thanks to @salabur, @pvince83, @bergoglio, @EPicLURcher, @ecolorado66, @Kriss1670, @maia, @f.maymil, @moutte69, @Jerome, @Gunnar M for the beers. It's very nice and encourages me to continue!
+Many thanks to @salabur, @pvince83, @bergoglio, @EPicLURcher, @ecolorado66, @Kriss1670, @maia, @f.maymil, @moutte69, @Jerome, @Gunnar M, @Greg.o, @John Burgess for the beers. It's very nice and encourages me to continue!
 
 # When to use / not use
 This thermostat can control 3 types of equipment:
 1. a radiator that only operates in on/off mode (called ``thermostat_over_switch```). The minimum configuration necessary to use this type thermostat is:
    1. equipment such as a radiator (a ``switch``` or equivalent),
    2. a temperature probe for the room (or an input_number),
-   3. an external temperature sensor (consider weather integration if you don't have one)
+   3. an outdoor temperature sensor (consider weather integration if you don't have one)
 2. another thermostat which has its own operating modes (named ``thermostat_over_climate```). For this type of thermostat the minimum configuration requires:
    1. equipment - such as air conditioning, a thermostatic valve - which is controlled by its own ``climate'' type entity,
 3. equipment which can take a value from 0 to 100% (called `thermostat_over_valve`). At 0 the heating is cut off, 100% it is fully opened. This type allows you to control a thermostatic valve (see Shelly valve) which exposes an entity of type `number.` allowing you to directly control the opening of the valve. Versatile Thermostat regulates the room temperature by adjusting the opening percentage, using the interior and exterior temperature sensors using the TPI algorithm described below.
@@ -105,7 +112,7 @@ Installations with pilot wire and activation diode benefit from an option which
 
 Some TRV type thermostats are known to be incompatible with the Versatile Thermostat. This is the case for the following valves:
 1. Danfoss POPP valves with temperature feedback. It is impossible to turn off this valve and it self-regulates, causing conflicts with the VTherm,
-2. “Homematic radio” thermostatic valves. They have a duty cycle incompatible with control by the Versatile Thermostat,
+2. "Homematic" (and possible Homematic IP) thermostats are known to have problems with Versatile Thermostats because of limitations of the underlying RF protocol. This problem especially occurs when trying to control several Homematic thermostats at once in one Versatile Thermostat instance. In order to reduce duty cycle load, you may e.g. group thermostats with Homematic-specific procedures (e.g. using a wall thermostat) and let Versatile Thermostat only control the wall thermostat directly. Another option is to control only one thermostat and propagate the changes in HVAC mode and temperature by an automation.
 3. Thermostat of type Heatzy which doesn't supports the set_temperature command.
 4. Thermostats of type Rointe tends to awake alone even if VTherm turns it off. Others functions works fine.
 
@@ -466,8 +473,8 @@ See [example tuning](#examples-tuning) for common tuning examples
 | ----------| --------| --- | --- | -- |
 | ``name`` | Name | X | X | X |
 | ``thermostat_type`` | Thermostat type | X | X | X |
-| ``temperature_sensor_entity_id`` | Temperature sensor entity id | X | - | X |
-| ``external_temperature_sensor_entity_id`` | External temperature sensor entity id | X | - | X |
+| ``temperature_sensor_entity_id`` | Temperature sensor entity id | X | X (self-regulation) | X |
+| ``external_temperature_sensor_entity_id`` | External temperature sensor entity id | X | X (self-regulation) | X |
 | ``cycle_min`` | Cycle duration (minutes) | X | X | X |
 | ``temp_min`` | Minimal temperature allowed | X | X | X |
 | ``temp_max`` | Maximal temperature allowed | X | X | X |
@@ -1017,6 +1024,82 @@ max: 30
 
 If you want to contribute to this please read the [Contribution guidelines](CONTRIBUTING.md)
 
+# Troubleshooting
+
+## Using a Heatzy
+The use of a Heatzy is possible provided you use a virtual switch on this model:
+```
+- platform:template
+   switches:
+     bathroom_heating:
+       unique_id: heating_bathroom
+       friendly_name: Bathroom heating
+       value_template: "{{ is_state_attr('climate.bathroom', 'preset_mode', 'comfort') }}"
+       icon_template: >-
+         {% if is_state_attr('climate.bathroom', 'preset_mode', 'comfort') %}
+           mdi:radiator
+         {% elif is_state_attr('climate.bathroom', 'preset_mode', 'away') %}
+           mdi:snowflake
+         {% else %}
+           mdi:radiator-disabled
+         {% endif %}
+       turn on:
+         service: climate.set_preset_mode
+         entity_id: climate.bathroom
+         data:
+           preset_mode: "comfort"
+       turn_off:
+         service: climate.set_preset_mode
+         entity_id: climate.bathroom
+         data:
+           preset_mode: "eco"
+```
+Thanks to @gael for this example.
+
+## Using a Heatsink with a Pilot Wire
+As with the Heatzy above you can use a virtual switch which will change the preset of your radiator depending on the ignition state of the VTherm.
+Example :
+```
+- platform:template
+   switches:
+     radiator_soan:
+         friendly_name: radiator_soan_inv
+         value_template: "{{ is_state('switch.radiateur_soan', 'off') }}"
+         turn on:
+           service: switch.turn_off
+           data:
+             entity_id: switch.radiateur_soan
+         turn_off:
+           service: switch.turn_on
+           data:
+             entity_id: switch.radiateur_soan
+         icon_template: "{% if is_state('switch.radiateur_soan', 'on') %}mdi:radiator-disabled{% else %}mdi:radiator{% endif %}"
+```
+
+## Only the first radiator heats
+In `over_switch` mode if several radiators are configured for the same VTherm, switching on will be done sequentially to smooth out consumption peaks as much as possible.
+This is completely normal and desired. It is described here: [For a thermostat of type ``thermostat_over_switch```](#for-a-thermostat-of-type-thermostat_over_switch)
+
+## Adjust window opening detection parameters in auto mode
+
+If you cannot set the opening detection function in auto mode (see [auto](#auto-mode)), you can try modifying the parameters of the temperature smoothing algorithm.
+In fact, automatic opening detection is based on the calculation of the temperature slope. To avoid artifacts due to an imprecise temperature sensor, this slope is calculated on a smoothed temperature with a smoothing algorithm called Exponential Moving Average.
+This algorithm has 3 parameters:
+1. `lifecycle_sec`: the duration in seconds taken into account for smoothing. The stronger it is, the greater the smoothing will be, but the longer there will be a detection delay,
+2. `max_alpha`: if two temperature measurements are separated in time, the second will have a very strong weight. The parameter makes it possible to limit the weight of a measurement which arrives well after the previous one. This value must be between 0 and 1. The lower it is, the less distant values are taken into account. The default is 0.5. This means that when a new temperature value will never weigh more than half of the moving average,
+3. `precision`: the number of digits after the decimal point retained for calculating the moving average.
+
+To change its parameters, you must modify the `configuration.yaml` file and add the following section (the values are the default values):
+```
+versatile_thermostat:
+  short_ema_params:
+    max_alpha: 0.5
+    halflife_sec: 300
+    accuracy: 2
+```
+
+These parameters are sensitive and quite difficult to adjust. Please only use them if you know what you are doing and your temperature measurements are not already smooth.
+
 ***
 
 [versatile_thermostat]: https://github.com/jmcollin78/versatile_thermostat

custom_components/versatile_thermostat/__init__.py

@@ -5,6 +5,7 @@ from typing import Dict
 
 import logging
 import voluptuous as vol
+import homeassistant.helpers.config_validation as cv
 
 from homeassistant.config_entries import ConfigEntry, ConfigType
 from homeassistant.core import HomeAssistant
@@ -19,39 +20,34 @@ from .const import (
     CONF_AUTO_REGULATION_STRONG,
     CONF_AUTO_REGULATION_SLOW,
     CONF_AUTO_REGULATION_EXPERT,
+    CONF_SHORT_EMA_PARAMS,
 )
 
 from .vtherm_api import VersatileThermostatAPI
 
 _LOGGER = logging.getLogger(__name__)
 
-SELF_REGULATION_PARAM_SCHEMA = (
-    vol.Schema(
-        {
-            vol.Required("kp"): vol.Coerce(float),
-            vol.Required("ki"): vol.Coerce(float),
-            vol.Required("k_ext"): vol.Coerce(float),
-            vol.Required("offset_max"): vol.Coerce(float),
-            vol.Required("stabilization_threshold"): vol.Coerce(float),
-            vol.Required("accumulated_error_threshold"): vol.Coerce(float),
-        }
-    ),
-)
+SELF_REGULATION_PARAM_SCHEMA = {
+    vol.Required("kp"): vol.Coerce(float),
+    vol.Required("ki"): vol.Coerce(float),
+    vol.Required("k_ext"): vol.Coerce(float),
+    vol.Required("offset_max"): vol.Coerce(float),
+    vol.Required("stabilization_threshold"): vol.Coerce(float),
+    vol.Required("accumulated_error_threshold"): vol.Coerce(float),
+}
+
+EMA_PARAM_SCHEMA = {
+    vol.Required("max_alpha"): vol.Coerce(float),
+    vol.Required("halflife_sec"): vol.Coerce(float),
+    vol.Required("precision"): cv.positive_int,
+}
 
 CONFIG_SCHEMA = vol.Schema(
     {
         DOMAIN: vol.Schema(
             {
-                CONF_AUTO_REGULATION_EXPERT: vol.Schema(
-                    {
-                        vol.Required("kp"): vol.Coerce(float),
-                        vol.Required("ki"): vol.Coerce(float),
-                        vol.Required("k_ext"): vol.Coerce(float),
-                        vol.Required("offset_max"): vol.Coerce(float),
-                        vol.Required("stabilization_threshold"): vol.Coerce(float),
-                        vol.Required("accumulated_error_threshold"): vol.Coerce(float),
-                    }
-                ),
+                CONF_AUTO_REGULATION_EXPERT: vol.Schema(SELF_REGULATION_PARAM_SCHEMA),
+                CONF_SHORT_EMA_PARAMS: vol.Schema(EMA_PARAM_SCHEMA),
             }
         ),
     },

custom_components/versatile_thermostat/base_thermostat.py

@@ -107,16 +107,25 @@ from .const import (
     ATTR_MEAN_POWER_CYCLE,
     ATTR_TOTAL_ENERGY,
     PRESET_AC_SUFFIX,
+    DEFAULT_SHORT_EMA_PARAMS,
 )
 
+from .vtherm_api import VersatileThermostatAPI
 from .underlyings import UnderlyingEntity
 
 from .prop_algorithm import PropAlgorithm
 from .open_window_algorithm import WindowOpenDetectionAlgorithm
+from .ema import ExponentialMovingAverage
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def get_tz(hass: HomeAssistant):
+    """Get the current timezone"""
+
+    return dt_util.get_time_zone(hass.config.time_zone)
+
+
 class BaseThermostat(ClimateEntity, RestoreEntity):
     """Representation of a base class for all Versatile Thermostat device."""
 
@@ -246,6 +255,9 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
 
         self._underlyings = []
 
+        self._ema_temp = None
+        self._ema_algo = None
+        self._now = None
         self.post_init(entry_infos)
 
     def post_init(self, entry_infos):
@@ -450,6 +462,23 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
 
         self._total_energy = 0
 
+        # Read the parameter from configuration.yaml if it exists
+        api: VersatileThermostatAPI = VersatileThermostatAPI.get_vtherm_api(self._hass)
+
+        short_ema_params = DEFAULT_SHORT_EMA_PARAMS
+        if api is not None and api.short_ema_params:
+            short_ema_params = api.short_ema_params
+
+        self._ema_algo = ExponentialMovingAverage(
+            self.name,
+            short_ema_params.get("halflife_sec"),
+            # Needed for time calculation
+            get_tz(self._hass),
+            # two digits after the coma for temperature slope calculation
+            short_ema_params.get("precision"),
+            short_ema_params.get("max_alpha"),
+        )
+
         _LOGGER.debug(
             "%s - Creation of a new VersatileThermostat entity: unique_id=%s",
             self,
@@ -862,6 +891,11 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
         """Return the unit of measurement."""
         return self._unit
 
+    @property
+    def ema_temperature(self) -> str:
+        """Return the EMA temperature."""
+        return self._ema_temp
+
     @property
     def hvac_mode(self) -> HVACMode | None:
         """Return current operation."""
@@ -1170,11 +1204,11 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
             return self._power_temp
         else:
             # Select _ac presets if in COOL Mode (or over_switch with _ac_mode)
-            if self._ac_mode and (
-                self._hvac_mode == HVACMode.COOL or not self.is_over_climate
-            ):
+            if self._ac_mode and self._hvac_mode == HVACMode.COOL:
                 preset_mode = preset_mode + PRESET_AC_SUFFIX
 
+            _LOGGER.info("%s - find preset temp: %s", self, preset_mode)
+
             if self._presence_on is False or self._presence_state in [
                 STATE_ON,
                 STATE_HOME,
@@ -1476,6 +1510,11 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
 
             self._last_temperature_mesure = self.get_state_date_or_now(state)
 
+            # calculate the smooth_temperature with EMA calculation
+            self._ema_temp = self._ema_algo.calculate_ema(
+                self._cur_temp, self._last_temperature_mesure
+            )
+
             _LOGGER.debug(
                 "%s - After setting _last_temperature_mesure %s , state.last_changed.replace=%s",
                 self,
@@ -1648,7 +1687,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
         for under in self._underlyings:
             await under.turn_off()
 
-    async def _async_manage_window_auto(self):
+    async def _async_manage_window_auto(self, in_cycle=False):
         """The management of the window auto feature"""
 
         async def dearm_window_auto(_):
@@ -1678,9 +1717,17 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
         if not self._window_auto_algo:
             return
 
-        slope = self._window_auto_algo.add_temp_measurement(
-            temperature=self._cur_temp, datetime_measure=self._last_temperature_mesure
-        )
+        if in_cycle:
+            slope = self._window_auto_algo.check_age_last_measurement(
+                temperature=self._ema_temp,
+                datetime_now=datetime.now(get_tz(self._hass)),
+            )
+        else:
+            slope = self._window_auto_algo.add_temp_measurement(
+                temperature=self._ema_temp,
+                datetime_measure=self._last_temperature_mesure,
+            )
+
         _LOGGER.debug(
             "%s - Window auto is on, check the alert. last slope is %.3f",
             self,
@@ -1869,9 +1916,18 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
 
         return self._overpowering_state
 
+    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 datetime.now(self._current_tz)
+
     async def check_security(self) -> bool:
         """Check if last temperature date is too long"""
-        now = datetime.now(self._current_tz)
+        now = self.now
         delta_temp = (
             now - self._last_temperature_mesure.replace(tzinfo=self._current_tz)
         ).total_seconds() / 60.0
@@ -1959,6 +2015,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
                 },
             )
 
+        # Start security mode
         if shouldStartSecurity:
             self._security_state = True
             self.save_hvac_mode()
@@ -1986,6 +2043,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
                 },
             )
 
+        # Stop security mode
         if shouldStopSecurity:
             _LOGGER.warning(
                 "%s - End of security mode. restoring hvac_mode to %s and preset_mode to %s",
@@ -2029,6 +2087,9 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
             self._attr_preset_mode,
         )
 
+        # check auto_window conditions
+        await self._async_manage_window_auto(in_cycle=True)
+
         # Issue 56 in over_climate mode, if the underlying climate is not initialized, try to initialize it
         for under in self._underlyings:
             if not under.is_initialized:
@@ -2155,6 +2216,7 @@ class BaseThermostat(ClimateEntity, RestoreEntity):
             "max_power_sensor_entity_id": self._max_power_sensor_entity_id,
             "temperature_unit": self.temperature_unit,
             "is_device_active": self.is_device_active,
+            "ema_temp": self._ema_temp,
         }
 
     @callback

custom_components/versatile_thermostat/const.py

@@ -94,6 +94,14 @@ CONF_AUTO_REGULATION_EXPERT = "auto_regulation_expert"
 CONF_AUTO_REGULATION_DTEMP = "auto_regulation_dtemp"
 CONF_AUTO_REGULATION_PERIOD_MIN = "auto_regulation_periode_min"
 CONF_INVERSE_SWITCH = "inverse_switch_command"
+CONF_SHORT_EMA_PARAMS = "short_ema_params"
+
+DEFAULT_SHORT_EMA_PARAMS = {
+    "max_alpha": 0.5,
+    # In sec
+    "halflife_sec": 300,
+    "precision": 2,
+}
 
 CONF_PRESETS = {
     p: f"{p}_temp"

custom_components/versatile_thermostat/ema.py

@@ -0,0 +1,92 @@
+# pylint: disable=line-too-long
+"""The Estimated Mobile Average calculation used for temperature slope
+and maybe some others feature"""
+
+import logging
+import math
+from datetime import datetime, tzinfo
+
+_LOGGER = logging.getLogger(__name__)
+
+MIN_TIME_DECAY_SEC = 0
+
+# MAX_ALPHA:
+# As for the EMA calculation of irregular time series, I've seen that it might be useful to
+# have an upper limit for alpha in case the last measurement was too long ago.
+# For example when using a half life of 10 minutes a measurement that is 60 minutes ago
+# (if there's nothing inbetween) would contribute to the smoothed value with 1,5%,
+# giving the current measurement 98,5% relevance. It could be wise to limit the alpha to e.g. 4x the half life (=0.9375).
+
+
+class ExponentialMovingAverage:
+    """A class that will do the Estimated Mobile Average calculation"""
+
+    def __init__(
+        self,
+        vterm_name: str,
+        halflife: float,
+        timezone: tzinfo,
+        precision: int = 3,
+        max_alpha: float = 0.5,
+    ):
+        """The halflife is the duration in secondes of a normal cycle"""
+        self._halflife: float = halflife
+        self._timezone = timezone
+        self._current_ema: float = None
+        self._last_timestamp: datetime = datetime.now(self._timezone)
+        self._name = vterm_name
+        self._precision = precision
+        self._max_alpha = max_alpha
+
+    def __str__(self) -> str:
+        return f"EMA-{self._name}"
+
+    def calculate_ema(self, measurement: float, timestamp: datetime) -> float | None:
+        """Calculate the new EMA from a new measurement measured at timestamp
+        Return the EMA or None if all parameters are not initialized now
+        """
+
+        if measurement is None or timestamp is None:
+            _LOGGER.warning(
+                "%s - Cannot calculate EMA: measurement and timestamp are mandatory. This message can be normal at startup but should not persist",
+                self,
+            )
+            return measurement
+
+        if self._current_ema is None:
+            _LOGGER.debug(
+                "%s - First init of the EMA",
+                self,
+            )
+            self._current_ema = measurement
+            self._last_timestamp = timestamp
+            return self._current_ema
+
+        time_decay = (timestamp - self._last_timestamp).total_seconds()
+        if time_decay < MIN_TIME_DECAY_SEC:
+            _LOGGER.debug(
+                "%s - time_decay %s is too small (< %s). Forget the measurement",
+                self,
+                time_decay,
+                MIN_TIME_DECAY_SEC,
+            )
+            return self._current_ema
+
+        alpha = 1 - math.exp(math.log(0.5) * time_decay / self._halflife)
+        # capping alpha to avoid gap if last measurement was long time ago
+        alpha = min(alpha, self._max_alpha)
+        new_ema = alpha * measurement + (1 - alpha) * self._current_ema
+
+        self._last_timestamp = timestamp
+        self._current_ema = new_ema
+        _LOGGER.debug(
+            "%s - timestamp=%s alpha=%.2f measurement=%.2f current_ema=%.2f new_ema=%.2f",
+            self,
+            timestamp,
+            alpha,
+            measurement,
+            self._current_ema,
+            new_ema,
+        )
+
+        return round(self._current_ema, self._precision)

custom_components/versatile_thermostat/open_window_algorithm.py

@@ -1,3 +1,4 @@
+# pylint: disable=line-too-long
 """ This file implements the Open Window by temperature algorithm
     This algo works the following way:
     - each time a new temperature is measured
@@ -12,8 +13,14 @@ from datetime import datetime
 _LOGGER = logging.getLogger(__name__)
 
 # To filter bad values
-MIN_DELTA_T_SEC = 30  # two temp mesure should be > 10 sec
-MAX_SLOPE_VALUE = 2  # slope cannot be > 2 or < -2 -> else this is an aberrant point
+MIN_DELTA_T_SEC = 0  # two temp mesure should be > 0 sec
+MAX_SLOPE_VALUE = (
+    120  # slope cannot be > 2°/min or < -2°/min -> else this is an aberrant point
+)
+
+MAX_DURATION_MIN = 30  # a fake data point is added in the cycle if last measurement was older than 30 min
+
+MIN_NB_POINT = 4  # do not calculate slope until we have enough point
 
 
 class WindowOpenDetectionAlgorithm:
@@ -24,6 +31,7 @@ class WindowOpenDetectionAlgorithm:
     _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"""
@@ -31,9 +39,24 @@ class WindowOpenDetectionAlgorithm:
         self._end_alert_threshold = end_alert_threshold
         self._last_slope = None
         self._last_datetime = None
+        self._nb_point = 0
+
+    def check_age_last_measurement(self, temperature, datetime_now) -> float:
+        """ " Check if last measurement is old and add
+        a fake measurement point if this is the case
+        """
+        if self._last_datetime is None:
+            return self.add_temp_measurement(temperature, datetime_now)
+
+        delta_t_sec = float((datetime_now - self._last_datetime).total_seconds()) / 60.0
+        if delta_t_sec >= MAX_DURATION_MIN:
+            return self.add_temp_measurement(temperature, datetime_now, False)
+        else:
+            # do nothing
+            return self._last_slope
 
     def add_temp_measurement(
-        self, temperature: float, datetime_measure: datetime
+        self, temperature: float, datetime_measure: datetime, store_date: bool = True
     ) -> float:
         """Add a new temperature measurement
         returns the last slope
@@ -42,6 +65,7 @@ class WindowOpenDetectionAlgorithm:
             _LOGGER.debug("First initialisation")
             self._last_datetime = datetime_measure
             self._last_temperature = temperature
+            self._nb_point = self._nb_point + 1
             return None
 
         _LOGGER.debug(
@@ -61,8 +85,10 @@ class WindowOpenDetectionAlgorithm:
             )
             return lspe
 
+        delta_t_hour = delta_t / 60.0
+
         delta_temp = float(temperature - self._last_temperature)
-        new_slope = delta_temp / delta_t
+        new_slope = delta_temp / delta_t_hour
         if new_slope > MAX_SLOPE_VALUE or new_slope < -MAX_SLOPE_VALUE:
             _LOGGER.debug(
                 "New_slope is abs(%.2f) > %.2f which should be not possible. We don't consider this value",
@@ -72,21 +98,28 @@ class WindowOpenDetectionAlgorithm:
             return lspe
 
         if self._last_slope is None:
-            self._last_slope = new_slope
+            self._last_slope = round(new_slope, 2)
         else:
-            self._last_slope = (0.5 * self._last_slope) + (0.5 * new_slope)
+            self._last_slope = round((0.2 * self._last_slope) + (0.8 * new_slope), 2)
+
+        # if we are in cycle check and so adding a fake datapoint, we don't store the event datetime
+        # so that, when we will receive a real temperature point we will not calculate a wrong slope
+        if store_date:
+            self._last_datetime = datetime_measure
 
-        self._last_datetime = datetime_measure
         self._last_temperature = temperature
 
+        self._nb_point = self._nb_point + 1
         _LOGGER.debug(
-            "delta_t=%.3f delta_temp=%.3f new_slope=%.3f last_slope=%s slope=%.3f",
+            "delta_t=%.3f delta_temp=%.3f new_slope=%.3f last_slope=%s slope=%.3f nb_point=%s",
             delta_t,
             delta_temp,
             new_slope,
             lspe,
             self._last_slope,
+            self._nb_point,
         )
+
         return self._last_slope
 
     def is_window_open_detected(self) -> bool:
@@ -94,22 +127,20 @@ class WindowOpenDetectionAlgorithm:
         if self._alert_threshold is None:
             return False
 
-        return (
-            self._last_slope < -self._alert_threshold
-            if self._last_slope is not None
-            else False
-        )
+        if self._nb_point < MIN_NB_POINT or self._last_slope is None:
+            return False
+
+        return self._last_slope < -self._alert_threshold
 
     def is_window_close_detected(self) -> bool:
         """True if the last calculated slope is above (cause negative) the _end_alert_threshold"""
         if self._end_alert_threshold is None:
             return False
 
-        return (
-            self._last_slope >= self._end_alert_threshold
-            if self._last_slope is not None
-            else False
-        )
+        if self._nb_point < MIN_NB_POINT or self._last_slope is None:
+            return False
+
+        return self._last_slope >= self._end_alert_threshold
 
     @property
     def last_slope(self) -> float:

custom_components/versatile_thermostat/pi_algorithm.py

@@ -49,7 +49,8 @@ class PITemperatureRegulator:
         self.target_temp = target_temp
         # Do not reset the accumulated error
         # Discussion #191. After a target change we should reset the accumulated error which is certainly wrong now.
-        self.accumulated_error = 0
+        if self.accumulated_error < 0:
+            self.accumulated_error = 0
 
     def calculate_regulated_temperature(
         self, internal_temp: float, external_temp: float

custom_components/versatile_thermostat/sensor.py

@@ -51,6 +51,7 @@ async def async_setup_entry(
         LastTemperatureSensor(hass, unique_id, name, entry.data),
         LastExtTemperatureSensor(hass, unique_id, name, entry.data),
         TemperatureSlopeSensor(hass, unique_id, name, entry.data),
+        EMATemperatureSensor(hass, unique_id, name, entry.data),
     ]
     if entry.data.get(CONF_DEVICE_POWER):
         entities.append(EnergySensor(hass, unique_id, name, entry.data))
@@ -483,7 +484,7 @@ class TemperatureSlopeSensor(VersatileThermostatBaseEntity, SensorEntity):
         if not self.my_climate:
             return None
 
-        return self.my_climate.temperature_unit + "/min"
+        return self.my_climate.temperature_unit + "/hour"
 
     @property
     def suggested_display_precision(self) -> int | None:
@@ -505,17 +506,15 @@ class RegulatedTemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
         """Called when my climate have change"""
         _LOGGER.debug("%s - climate state change", self._attr_unique_id)
 
-        if math.isnan(self.my_climate.regulated_target_temp) or math.isinf(
-            self.my_climate.regulated_target_temp
-        ):
-            raise ValueError(
-                f"Sensor has illegal state {self.my_climate.regulated_target_temp}"
-            )
+        new_temp = self.my_climate.regulated_target_temp
+        if new_temp is None:
+            return
+
+        if math.isnan(new_temp) or math.isinf(new_temp):
+            raise ValueError(f"Sensor has illegal state {new_temp}")
 
         old_state = self._attr_native_value
-        self._attr_native_value = round(
-            self.my_climate.regulated_target_temp, self.suggested_display_precision
-        )
+        self._attr_native_value = round(new_temp, self.suggested_display_precision)
         if old_state != self._attr_native_value:
             self.async_write_ha_state()
         return
@@ -542,3 +541,54 @@ class RegulatedTemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
     def suggested_display_precision(self) -> int | None:
         """Return the suggested number of decimal digits for display."""
         return 1
+
+
+class EMATemperatureSensor(VersatileThermostatBaseEntity, SensorEntity):
+    """Representation of a Exponential Moving Average temp"""
+
+    def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos) -> None:
+        """Initialize the regulated temperature sensor"""
+        super().__init__(hass, unique_id, entry_infos.get(CONF_NAME))
+        self._attr_name = "EMA temperature"
+        self._attr_unique_id = f"{self._device_name}_ema_temperature"
+
+    @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)
+
+        new_ema = self.my_climate.ema_temperature
+        if new_ema is None:
+            return
+
+        if math.isnan(new_ema) or math.isinf(new_ema):
+            raise ValueError(f"Sensor has illegal state {new_ema}")
+
+        old_state = self._attr_native_value
+        self._attr_native_value = new_ema
+        if old_state != self._attr_native_value:
+            self.async_write_ha_state()
+        return
+
+    @property
+    def icon(self) -> str | None:
+        return "mdi:thermometer-lines"
+
+    @property
+    def device_class(self) -> SensorDeviceClass | None:
+        return SensorDeviceClass.TEMPERATURE
+
+    @property
+    def state_class(self) -> SensorStateClass | None:
+        return SensorStateClass.MEASUREMENT
+
+    @property
+    def native_unit_of_measurement(self) -> str | None:
+        if not self.my_climate:
+            return UnitOfTemperature.CELSIUS
+        return self.my_climate.temperature_unit
+
+    @property
+    def suggested_display_precision(self) -> int | None:
+        """Return the suggested number of decimal digits for display."""
+        return 2

custom_components/versatile_thermostat/strings.json

@@ -91,14 +91,14 @@
         "data": {
           "window_sensor_entity_id": "Window sensor entity id",
           "window_delay": "Window sensor delay (seconds)",
-          "window_auto_open_threshold": "Temperature decrease threshold for automatic window open detection (in °/min)",
-          "window_auto_close_threshold": "Temperature increase threshold for end of automatic detection (in °/min)",
+          "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)"
         },
         "data_description": {
           "window_sensor_entity_id": "Leave empty if no window sensor should be use",
           "window_delay": "The delay in seconds before sensor detection is taken into account",
-          "window_auto_open_threshold": "Recommended value: between 0.05 and 0.1. Leave empty if automatic window open detection is not use",
+          "window_auto_open_threshold": "Recommended value: between 3 and 10. Leave empty if automatic window open detection is not use",
           "window_auto_close_threshold": "Recommended value: 0. Leave empty if automatic window open detection is not use",
           "window_auto_max_duration": "Recommended value: 60 (one hour). Leave empty if automatic window open detection is not use"
         }
@@ -260,14 +260,14 @@
         "data": {
           "window_sensor_entity_id": "Window sensor entity id",
           "window_delay": "Window sensor delay (seconds)",
-          "window_auto_open_threshold": "Temperature decrease threshold for automatic window open detection (in °/min)",
-          "window_auto_close_threshold": "Temperature increase threshold for end of automatic detection (in °/min)",
+          "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)"
         },
         "data_description": {
           "window_sensor_entity_id": "Leave empty if no window sensor should be use",
           "window_delay": "The delay in seconds before sensor detection is taken into account",
-          "window_auto_open_threshold": "Recommended value: between 0.05 and 0.1. Leave empty if automatic window open detection is not use",
+          "window_auto_open_threshold": "Recommended value: between 3 and 10. Leave empty if automatic window open detection is not use",
           "window_auto_close_threshold": "Recommended value: 0. Leave empty if automatic window open detection is not use",
           "window_auto_max_duration": "Recommended value: 60 (one hour). Leave empty if automatic window open detection is not use"
         }

custom_components/versatile_thermostat/translations/el.json

@@ -0,0 +1,375 @@
+{
+  "title": "Διαμόρφωση Ευέλικτου Θερμοστάτη",
+  "config": {
+    "flow_title": "Διαμόρφωση Ευέλικτου Θερμοστάτη",
+    "step": {
+      "user": {
+        "title": "Προσθήκη νέου Ευέλικτου Θερμοστάτη",
+        "description": "Κύρια υποχρεωτικά χαρακτηριστικά",
+        "data": {
+          "name": "Όνομα",
+          "thermostat_type": "Τύπος Θερμοστάτη",
+          "temperature_sensor_entity_id": "Ταυτότητα οντότητας αισθητήρα θερμοκρασίας",
+          "external_temperature_sensor_entity_id": "Ταυτότητα οντότητας εξωτερικού αισθητήρα θερμοκρασίας",
+          "cycle_min": "Διάρκεια κύκλου (λεπτά)",
+          "temp_min": "Ελάχιστη επιτρεπτή θερμοκρασία",
+          "temp_max": "Μέγιστη επιτρεπτή θερμοκρασία",
+          "device_power": "Ισχύς συσκευής",
+          "use_window_feature": "Χρήση ανίχνευσης παραθύρου",
+          "use_motion_feature": "Χρήση ανίχνευσης κίνησης",
+          "use_power_feature": "Χρήση διαχείρισης ισχύος",
+          "use_presence_feature": "Χρήση ανίχνευσης παρουσίας"
+        }
+      },
+      "type": {
+        "title": "Συνδεδεμένες οντότητες",
+        "description": "Χαρακτηριστικά συνδεδεμένων οντοτήτων",
+        "data": {
+          "heater_entity_id": "1ος διακόπτης θερμαντήρα",
+          "heater_entity2_id": "2ος διακόπτης θερμαντήρα",
+          "heater_entity3_id": "3ος διακόπτης θερμαντήρα",
+          "heater_entity4_id": "4ος διακόπτης θερμαντήρα",
+          "proportional_function": "Αλγόριθμος",
+          "climate_entity_id": "1η υποκείμενη κλιματική οντότητα",
+          "climate_entity2_id": "2η υποκείμενη κλιματική οντότητα",
+          "climate_entity3_id": "3η υποκείμενη κλιματική οντότητα",
+          "climate_entity4_id": "4η υποκείμενη κλιματική οντότητα",
+          "ac_mode": "Λειτουργία AC",
+          "valve_entity_id": "1ος αριθμός βαλβίδας",
+          "valve_entity2_id": "2ος αριθμός βαλβίδας",
+          "valve_entity3_id": "3ος αριθμός βαλβίδας",
+          "valve_entity4_id": "4ος αριθμός βαλβίδας",
+          "auto_regulation_mode": "Αυτόματη ρύθμιση",
+          "auto_regulation_dtemp": "Όριο ρύθμισης",
+          "auto_regulation_periode_min": "Ελάχιστη περίοδος ρύθμισης",
+          "inverse_switch_command": "Αντίστροφη εντολή διακόπτη"
+        },
+        "data_description": {
+          "heater_entity_id": "Υποχρεωτική ταυτότητα οντότητας θερμαντήρα",
+          "heater_entity2_id": "Προαιρετική 2η ταυτότητα οντότητας θερμαντήρα. Αφήστε κενό αν δεν χρησιμοποιείται",
+          "heater_entity3_id": "Προαιρετική 3η ταυτότητα οντότητας θερμαντήρα. Αφήστε κενό αν δεν χρησιμοποιείται",
+          "heater_entity4_id": "Προαιρετική 4η ταυτότητα οντότητας θερμαντήρα. Αφήστε κενό αν δεν χρησιμοποιείται",
+          "proportional_function": "Αλγόριθμος προς χρήση (TPI είναι ο μόνος για τώρα)",
+          "climate_entity_id": "Ταυτότητα υποκείμενης κλιματικής οντότητας",
+          "climate_entity2_id": "2η ταυτότητα υποκείμενης κλιματικής οντότητας",
+          "climate_entity3_id": "3η ταυτότητα υποκείμενης κλιματικής οντότητας",
+          "climate_entity4_id": "4η ταυτότητα υποκείμενης κλιματικής οντότητας",
+          "ac_mode": "Χρήση της λειτουργίας Κλιματισμού (AC)",
+          "valve_entity_id": "1η ταυτότητα αριθμού βαλβίδας",
+          "valve_entity2_id": "2η ταυτότητα αριθμού βαλβίδας",
+          "valve_entity3_id": "3η ταυτότητα αριθμού βαλβίδας",
+          "valve_entity4_id": "4η ταυτότητα αριθμού βαλβίδας",
+          "auto_regulation_mode": "Αυτόματη προσαρμογή της στοχευμένης θερμοκρασίας",
+          "auto_regulation_dtemp": "Το όριο σε ° κάτω από το οποίο η αλλαγή θερμοκρασίας δεν θα αποστέλλεται",
+          "auto_regulation_periode_min": "Διάρκεια σε λεπτά μεταξύ δύο ενημερώσεων ρύθμισης",
+          "inverse_switch_command": "Για διακόπτη με πιλοτικό καλώδιο και δίοδο μπορεί να χρειαστεί να αντιστρέψετε την εντολή"
+        }
+      },
+      "tpi": {
+        "title": "TPI",
+        "description": "Χαρακτηριστικά Χρονικά Αναλογικού Ολοκληρωτικού (TPI)",
+        "data": {
+          "tpi_coef_int": "Συντελεστής για χρήση στη διαφορά εσωτερικής θερμοκρασίας",
+          "tpi_coef_ext": "Συντελεστής για χρήση στη διαφορά εξωτερικής θερμοκρασίας"
+        }
+      },
+      "presets": {
+        "title": "Προκαθορισμένα",
+        "description": "Για κάθε προκαθορισμένο, δώστε την επιθυμητή θερμοκρασία (0 για να αγνοηθεί το προκαθορισμένο)",
+        "data": {
+          "eco_temp": "Θερμοκρασία στο προκαθορισμένο Eco",
+          "comfort_temp": "Θερμοκρασία στο προκαθορισμένο Comfort",
+          "boost_temp": "Θερμοκρασία στο προκαθορισμένο Boost",
+          "eco_ac_temp": "Θερμοκρασία στο προκαθορισμένο Eco για λειτουργία AC",
+          "comfort_ac_temp": "Θερμοκρασία στο προκαθορισμένο Comfort για λειτουργία AC",
+          "boost_ac_temp": "Θερμοκρασία στο προκαθορισμένο Boost για λειτουργία AC"
+        }
+      },
+      "window": {
+        "title": "Διαχείριση Παραθύρων",
+        "description": "Ανοίξτε τη διαχείριση παραθύρων.\nΑφήστε το αντίστοιχο entity_id κενό αν δεν χρησιμοποιείται\nΜπορείτε επίσης να ρυθμίσετε αυτόματη ανίχνευση ανοίγματος παραθύρου με βάση τη μείωση της θερμοκρασίας",
+        "data": {
+          "window_sensor_entity_id": "Ταυτότητα οντότητας αισθητήρα παραθύρου",
+          "window_delay": "Καθυστέρηση αισθητήρα παραθύρου (δευτερόλεπτα)",
+          "window_auto_open_threshold": "Κατώφλι μείωσης θερμοκρασίας για αυτόματη ανίχνευση ανοίγματος παραθύρου (σε °/λεπτό)",
+          "window_auto_close_threshold": "Κατώφλι αύξησης θερμοκρασίας για τέλος αυτόματης ανίχνευσης (σε °/λεπτό)",
+          "window_auto_max_duration": "Μέγιστη διάρκεια αυτόματης ανίχνευσης ανοίγματος παραθύρου (σε λεπτά)"
+        },
+        "data_description": {
+          "window_sensor_entity_id": "Αφήστε κενό αν δεν πρέπει να χρησιμοποιηθεί αισθητήρας παραθύρου",
+          "window_delay": "Η καθυστέρηση σε δευτερόλεπτα πριν ληφθεί υπόψη η ανίχνευση του αισθητήρα",
+          "window_auto_open_threshold": "Συνιστώμενη τιμή: μεταξύ 0.05 και 0.1. Αφήστε κενό αν δεν χρησιμοποιείται αυτόματη ανίχνευση ανοίγματος παραθύρου",
+          "window_auto_close_threshold": "Συνιστώμενη τιμή: 0. Αφήστε κενό αν δεν χρησιμοποιείται αυτόματη ανίχνευση ανοίγματος παραθύρου",
+          "window_auto_max_duration": "Συνιστώμενη τιμή: 60 (μία ώρα). Αφήστε κενό αν δεν χρησιμοποιείται αυτόματη ανίχνευση ανοίγματος παραθύρου"
+        }
+      },
+      "motion": {
+        "title": "Διαχείριση Κίνησης",
+        "description": "Διαχείριση αισθητήρα κίνησης. Το προκαθορισμένο μπορεί να αλλάζει αυτόματα ανάλογα με ανίχνευση κίνησης\nΑφήστε το αντίστοιχο entity_id κενό αν δεν χρησιμοποιείται.\nΟι επιλογές motion_preset και no_motion_preset πρέπει να οριστούν στο αντίστοιχο όνομα προκαθορισμένου",
+        "data": {
+          "motion_sensor_entity_id": "Ταυτότητα οντότητας αισθητήρα κίνησης",
+          "motion_delay": "Καθυστέρηση ενεργοποίησης",
+          "motion_off_delay": "Καθυστέρηση απενεργοποίησης",
+          "motion_preset": "Προκαθορισμένο κίνησης",
+          "no_motion_preset": "Προκαθορισμένο χωρίς κίνηση"
+        },
+        "data_description": {
+          "motion_sensor_entity_id": "Η ταυτότητα οντότητας του αισθητήρα κίνησης",
+          "motion_delay": "Καθυστέρηση ενεργοποίησης κίνησης (δευτερόλεπτα)",
+          "motion_off_delay": "Καθυστέρηση απενεργοποίησης κίνησης (δευτερόλεπτα)",
+          "motion_preset": "Το προκαθορισμένο που θα χρησιμοποιηθεί όταν ανιχνευθεί κίνηση",
+          "no_motion_preset": "Το προκαθορισμένο που θα χρησιμοποιηθεί όταν δεν ανιχνευθεί κίνηση"
+        }
+      },
+      "power": {
+        "title": "Διαχείριση Ενέργειας",
+        "description": "Χαρακτηριστικά διαχείρισης ενέργειας.\nΔίνει τον αισθητήρα ενέργειας και τον μέγιστο αισθητήρα ενέργειας του σπιτιού σας.\nΣτη συνέχεια καθορίστε την κατανάλωση ενέργειας του θερμαντήρα όταν είναι ενεργοποιημένος.\nΌλοι οι αισθητήρες και η ισχύς της συσκευής πρέπει να έχουν την ίδια μονάδα (kW ή W).\nΑφήστε το αντίστοιχο entity_id κενό αν δεν χρησιμοποιείται.",
+        "data": {
+          "power_sensor_entity_id": "Ταυτότητα οντότητας αισθητήρα ενέργειας",
+          "max_power_sensor_entity_id": "Ταυτότητα οντότητας αισθητήρα μέγιστης ενέργειας",
+          "power_temp": "Θερμοκρασία για Αποβολή Ενέργειας"
+        }
+      },
+      "presence": {
+        "title": "Διαχείριση Παρουσίας",
+        "description": "Χαρακτηριστικά διαχείρισης παρουσίας.\nΔίνει έναν αισθητήρα παρουσίας του σπιτιού σας (αληθές αν κάποιος είναι παρών).\nΣτη συνέχεια καθορίστε είτε το προκαθορισμένο που θα χρησιμοποιηθεί όταν ο αισθητήρας παρουσίας είναι ψευδής ή την απόκλιση στη θερμοκρασία που θα εφαρμοστεί.\nΑν δοθεί προκαθορισμένο, η απόκλιση δεν θα χρησιμοποιηθεί.\nΑφήστε το αντίστοιχο entity_id κενό αν δεν χρησιμοποιείται.",
+        "data": {
+          "presence_sensor_entity_id": "Ταυτότητα οντότητας αισθητήρα παρουσίας",
+          "eco_away_temp": "Θερμοκρασία στο προκαθορισμένο Eco όταν δεν υπάρχει παρουσία",
+          "comfort_away_temp": "Θερμοκρασία στο προκαθορισμένο Comfort όταν δεν υπάρχει παρουσία",
+          "boost_away_temp": "Θερμοκρασία στο προκαθορισμένο Boost όταν δεν υπάρχει παρουσία",
+          "eco_ac_away_temp": "Θερμοκρασία στο προκαθορισμένο Eco όταν δεν υπάρχει παρουσία σε λειτουργία AC",
+          "comfort_ac_away_temp": "Θερμοκρασία στο προκαθορισμένο Comfort όταν δεν υπάρχει παρουσία σε λειτουργία AC",
+          "boost_ac_away_temp": "Θερμοκρασία στο προκαθορισμένο Boost όταν δεν υπάρχει παρουσία σε λειτουργία AC"
+        }
+      },
+      "advanced": {
+        "title": "Προχωρημένες Παράμετροι",
+        "description": "Διαμόρφωση των προχωρημένων παραμέτρων. Αφήστε τις προεπιλεγμένες τιμές αν δεν γνωρίζετε τι κάνετε.\nΑυτές οι παράμετροι μπορούν να οδηγήσουν σε πολύ κακή ρύθμιση θερμοκρασίας ή ενέργειας.",
+        "data": {
+          "minimal_activation_delay": "Ελάχιστη καθυστέρηση ενεργοποίησης",
+          "security_delay_min": "Καθυστέρηση ασφαλείας (σε λεπτά)",
+          "security_min_on_percent": "Ελάχιστο ποσοστό ισχύος για ενεργοποίηση λειτουργίας ασφαλείας",
+          "security_default_on_percent": "Ποσοστό ισχύος για χρήση σε λειτουργία ασφαλείας"
+        },
+        "data_description": {
+          "minimal_activation_delay": "Καθυστέρηση σε δευτερόλεπτα κάτω από την οποία η συσκευή δεν θα ενεργοποιηθεί",
+          "security_delay_min": "Μέγιστη επιτρεπτή καθυστέρηση σε λεπτά μεταξύ δύο μετρήσεων θερμοκρασίας. Πέρα από αυτή την καθυστέρηση, ο θερμοστάτης θα μεταβεί σε κατάσταση ασφαλείας",
+          "security_min_on_percent": "Ελάχιστη τιμή ποσοστού θέρμανσης για την ενεργοποίηση του προεπιλεγμένου ασφάλειας. Κάτω από αυτό το ποσοστό ισχύος το θερμοστάτη δεν θα πάει στο προεπιλεγμένο ασφάλειας.",
+          "security_default_on_percent": "Η προεπιλεγμένη τιμή ποσοστού ισχύος θέρμανσης στο προεπιλεγμένο ασφάλειας. Ορίστε σε 0 για να απενεργοποιήσετε τη θερμάστρα στο παρόν ασφάλειας."
+        }
+      }
+    },
+    "error": {
+      "unknown": "Απρόσμενο σφάλμα",
+      "unknown_entity": "Άγνωστο αναγνωριστικό οντότητας",
+      "window_open_detection_method": "Πρέπει να χρησιμοποιείται μόνο μία μέθοδος ανίχνευσης ανοιχτού παραθύρου. Χρησιμοποιήστε αισθητήρα ή αυτόματη ανίχνευση μέσω του κατωφλίου θερμοκρασίας, αλλά όχι και τα δύο"
+    },
+    "abort": {
+      "already_configured": "Η συσκευή έχει ήδη ρυθμιστεί"
+    }
+  },
+  "options": {
+    "flow_title": "Διαμόρφωση Ευέλικτου Θερμοστάτη",
+    "step": {
+      "user": {
+        "title": "Προσθήκη νέου Ευέλικτου Θερμοστάτη",
+        "description": "Κύρια υποχρεωτικά χαρακτηριστικά",
+        "data": {
+          "name": "Όνομα",
+          "thermostat_type": "Τύπος θερμοστάτη",
+          "temperature_sensor_entity_id": "Ταυτότητα οντότητας αισθητήρα θερμοκρασίας",
+          "external_temperature_sensor_entity_id": "Ταυτότητα οντότητας εξωτερικού αισθητήρα θερμοκρασίας",
+          "cycle_min": "Διάρκεια κύκλου (λεπτά)",
+          "temp_min": "Ελάχιστη επιτρεπόμενη θερμοκρασία",
+          "temp_max": "Μέγιστη επιτρεπόμενη θερμοκρασία",
+          "device_power": "Ισχύς συσκευής (kW)",
+          "use_window_feature": "Χρήση ανίχνευσης παραθύρου",
+          "use_motion_feature": "Χρήση ανίχνευσης κίνησης",
+          "use_power_feature": "Χρήση διαχείρισης ενέργειας",
+          "use_presence_feature": "Χρήση ανίχνευσης παρουσίας"
+        }
+      },
+      "type": {
+        "title": "Συνδεδεμένες οντότητες",
+        "description": "Χαρακτηριστικά συνδεδεμένων οντοτήτων",
+        "data": {
+          "heater_entity_id": "1ος διακόπτης θερμαντήρα",
+          "heater_entity2_id": "2ος διακόπτης θερμαντήρα",
+          "heater_entity3_id": "3ος διακόπτης θερμαντήρα",
+          "heater_entity4_id": "4ος διακόπτης θερμαντήρα",
+          "proportional_function": "Αλγόριθμος",
+          "climate_entity_id": "1η υποκείμενη κλιματική οντότητα",
+          "climate_entity2_id": "2η υποκείμενη κλιματική οντότητα",
+          "climate_entity3_id": "3η υποκείμενη κλιματική οντότητα",
+          "climate_entity4_id": "4η υποκείμενη κλιματική οντότητα",
+          "ac_mode": "Λειτουργία AC",
+          "valve_entity_id": "1ος αριθμός βαλβίδας",
+          "valve_entity2_id": "2ος αριθμός βαλβίδας",
+          "valve_entity3_id": "3ος αριθμός βαλβίδας",
+          "valve_entity4_id": "4ος αριθμός βαλβίδας",
+          "auto_regulation_mode": "Αυτορύθμιση",
+          "auto_regulation_dtemp": "Όριο ρύθμισης",
+          "auto_regulation_periode_min": "Ελάχιστη περίοδος ρύθμισης",
+          "inverse_switch_command": "Αντίστροφη εντολή διακόπτη"
+        },
+        "data_description": {
+          "heater_entity_id": "Υποχρεωτική ταυτότητα οντότητας θερμαντήρα",
+          "heater_entity2_id": "Προαιρετική ταυτότητα οντότητας 2ου θερμαντήρα. Αφήστε το κενό αν δεν χρησιμοποιείται",
+          "heater_entity3_id": "Προαιρετική ταυτότητα οντότητας 3ου θερμαντήρα. Αφήστε το κενό αν δεν χρησιμοποιείται",
+          "heater_entity4_id": "Προαιρετική ταυτότητα οντότητας 4ου θερμαντήρα. Αφήστε το κενό αν δεν χρησιμοποιείται",
+          "proportional_function": "Αλγόριθμος που θα χρησιμοποιηθεί (TPI είναι ο μόνος για τώρα)",
+          "climate_entity_id": "Ταυτότητα οντότητας υποκείμενου κλίματος",
+          "climate_entity2_id": "Ταυτότητα οντότητας 2ου υποκείμενου κλίματος",
+          "climate_entity3_id": "Ταυτότητα οντότητας 3ου υποκείμενου κλίματος",
+          "climate_entity4_id": "Ταυτότητα οντότητας 4ου υποκείμενου κλίματος",
+          "ac_mode": "Χρήση της λειτουργίας Κλιματισμού (AC)",
+          "valve_entity_id": "Ταυτότητα οντότητας 1ης βαλβίδας",
+          "valve_entity2_id": "Ταυτότητα οντότητας 2ης βαλβίδας",
+          "valve_entity3_id": "Ταυτότητα οντότητας 3ης βαλβίδας",
+          "valve_entity4_id": "Ταυτότητα οντότητας 4ης βαλβίδας",
+          "auto_regulation_mode": "Αυτόματη ρύθμιση της στοχευόμενης θερμοκρασίας",
+          "auto_regulation_dtemp": "Το κατώφλι σε °C κάτω από το οποίο η αλλαγή της θερμοκρασίας δεν θα αποστέλλεται",
+          "auto_regulation_periode_min": "Διάρκεια σε λεπτά μεταξύ δύο ενημερώσεων ρύθμισης",
+          "inverse_switch_command": "Για διακόπτες με πιλοτικό καλώδιο και δίοδο μπορεί να χρειαστεί να αντιστραφεί η εντολή"
+        }
+      },
+      "tpi": {
+        "title": "TPI",
+        "description": "Χαρακτηριστικά Χρονικού Αναλογικού Ολοκληρωτικού (TPI)",
+        "data": {
+          "tpi_coef_int": "Συντελεστής που θα χρησιμοποιηθεί για την εσωτερική διαφορά θερμοκρασίας",
+          "tpi_coef_ext": "Συντελεστής που θα χρησιμοποιηθεί για την εξωτερική διαφορά θερμοκρασίας"
+        }
+      },
+      "presets": {
+        "title": "Προεπιλογές",
+        "description": "Για κάθε προεπιλογή, δώστε τη στοχευόμενη θερμοκρασία (0 για να αγνοηθεί η προεπιλογή)",
+        "data": {
+          "eco_temp": "Θερμοκρασία στην οικονομική προεπιλογή",
+          "comfort_temp": "Θερμοκρασία στην άνετη προεπιλογή",
+          "boost_temp": "Θερμοκρασία στην ενισχυμένη προεπιλογή",
+          "eco_ac_temp": "Θερμοκρασία στην οικονομική προεπιλογή για τη λειτουργία AC",
+          "comfort_ac_temp": "Θερμοκρασία στην άνετη προεπιλογή για τη λειτουργία AC",
+          "boost_ac_temp": "Θερμοκρασία στην ενισχυμένη προεπιλογή για τη λειτουργία AC"
+        }
+      },
+      "window": {
+        "title": "Διαχείριση παραθύρου",
+        "description": "Διαχείριση ανοιχτού παραθύρου.\nΑφήστε την αντίστοιχη ταυτότητα οντότητας κενή αν δεν χρησιμοποιείται\nΜπορείτε επίσης να διαμορφώσετε την αυτόματη ανίχνευση ανοίγματος παραθύρου βάσει της μείωσης της θερμοκρασίας",
+        "data": {
+          "window_sensor_entity_id": "Ταυτότητα οντότητας αισθητήρα παραθύρου",
+          "window_delay": "Καθυστέρηση αισθητήρα παραθύρου (δευτερόλεπτα)",
+          "window_auto_open_threshold": "Όριο μείωσης θερμοκρασίας για αυτόματη ανίχνευση ανοίγματος παραθύρου (σε °/λεπτό)",
+          "window_auto_close_threshold": "Όριο αύξησης θερμοκρασίας για τέλος αυτόματης ανίχνευσης (σε °/λεπτό)",
+          "window_auto_max_duration": "Μέγιστη διάρκεια αυτόματης ανίχνευσης ανοίγματος παραθύρου (σε λεπτά)"
+        },
+        "data_description": {
+          "window_sensor_entity_id": "Αφήστε κενό αν δεν πρέπει να χρησιμοποιηθεί αισθητήρας παραθύρου",
+          "window_delay": "Η καθυστέρηση σε δευτερόλεπτα πριν ληφθεί υπόψη η ανίχνευση αισθητήρα",
+          "window_auto_open_threshold": "Συνιστώμενη τιμή: μεταξύ 0.05 και 0.1. Αφήστε κενό αν δεν χρησιμοποιείται αυτόματη ανίχνευση ανοίγματος παραθύρου",
+          "window_auto_close_threshold": "Συνιστώμενη τιμή: 0. Αφήστε κενό αν δεν χρησιμοποιείται αυτόματη ανίχνευση ανοίγματος παραθύρου",
+          "window_auto_max_duration": "Συνιστώμενη τιμή: 60 (μία ώρα). Αφήστε κενό αν δεν χρησιμοποιείται αυτόματη ανίχνευση ανοίγματος παραθύρου"
+        }
+      },
+      "motion": {
+        "title": "Διαχείριση κίνησης",
+        "description": "Διαχείριση αισθητήρα κίνησης. Ο προεπιλεγμένος τρόπος μπορεί να αλλάξει αυτόματα ανάλογα με την ανίχνευση κίνησης\nΑφήστε το αντίστοιχο entity_id κενό αν δεν χρησιμοποιείται.\nΤα motion_preset και no_motion_preset πρέπει να οριστούν στο αντίστοιχο όνομα προεπιλογής",
+        "data": {
+          "motion_sensor_entity_id": "Ανιχνευτής κίνησης entity id",
+          "motion_delay": "Καθυστέρηση ενεργοποίησης",
+          "motion_off_delay": "Καθυστέρηση απενεργοποίησης",
+          "motion_preset": "Προεπιλογή κίνησης",
+          "no_motion_preset": "Προεπιλογή χωρίς κίνηση"
+        },
+        "data_description": {
+          "motion_sensor_entity_id": "Το entity id του ανιχνευτή κίνησης",
+          "motion_delay": "Καθυστέρηση ενεργοποίησης κίνησης (δευτερόλεπτα)",
+          "motion_off_delay": "Καθυστέρηση απενεργοποίησης κίνησης (δευτερόλεπτα)",
+          "motion_preset": "Η προεπιλογή που χρησιμοποιείται όταν ανιχνεύεται κίνηση",
+          "no_motion_preset": "Η προεπιλογή που χρησιμοποιείται όταν δεν ανιχνεύεται κίνηση"
+        }
+      },
+      "power": {
+        "title": "Διαχείριση Ενέργειας",
+        "description": "Χαρακτηριστικά διαχείρισης ενέργειας.\nΠαρέχει τον αισθητήρα ισχύος και τον μέγιστο αισθητήρα ισχύος του σπιτιού σας.\nΣτη συνέχεια καθορίστε την κατανάλωση ενέργειας του θερμαντήρα όταν είναι ενεργοποιημένος.\nΌλοι οι αισθητήρες και η ισχύς της συσκευής πρέπει να έχουν την ίδια μονάδα (kW ή W).\nΑφήστε το αντίστοιχο entity_id κενό εάν δεν χρησιμοποιείται.",
+        "data": {
+          "power_sensor_entity_id": "Ταυτότητα οντότητας αισθητήρα ισχύος",
+          "max_power_sensor_entity_id": "Ταυτότητα οντότητας αισθητήρα μέγιστης ισχύος",
+          "power_temp": "Θερμοκρασία για Μείωση Ισχύος"
+        }
+      },
+      "presence": {
+        "title": "Διαχείριση Παρουσίας",
+        "description": "Χαρακτηριστικά διαχείρισης παρουσίας.\nΠαρέχει έναν αισθητήρα παρουσίας του σπιτιού σας (αληθές εάν κάποιος είναι παρών).\nΣτη συνέχεια καθορίστε είτε το προεπιλεγμένο πρόγραμμα που θα χρησιμοποιηθεί όταν ο αισθητήρας παρουσίας είναι ψευδής είτε την θερμοκρασιακή διαφορά που θα εφαρμοστεί.\nΕάν δίνεται προεπιλογή, η διαφορά δεν θα χρησιμοποιηθεί.\nΑφήστε το αντίστοιχο entity_id κενό εάν δεν χρησιμοποιείται.",
+        "data": {
+          "presence_sensor_entity_id": "Ταυτότητα οντότητας αισθητήρα παρουσίας (αληθές είναι παρών)",
+          "eco_away_temp": "Θερμοκρασία στο πρόγραμμα Eco όταν δεν υπάρχει παρουσία",
+          "comfort_away_temp": "Θερμοκρασία στο πρόγραμμα Comfort όταν δεν υπάρχει παρουσία",
+          "boost_away_temp": "Θερμοκρασία στο πρόγραμμα Boost όταν δεν υπάρχει παρουσία",
+          "eco_ac_away_temp": "Θερμοκρασία στο πρόγραμμα Eco όταν δεν υπάρχει παρουσία σε λειτουργία AC",
+          "comfort_ac_away_temp": "Θερμοκρασία στο πρόγραμμα Comfort όταν δεν υπάρχει παρουσία σε λειτουργία AC",
+          "boost_ac_away_temp": "Θερμοκρασία στο πρόγραμμα Boost όταν δεν υπάρχει παρουσία σε λειτουργία AC"
+        }
+      },
+      "advanced": {
+        "title": "Προηγμένες Παράμετροι",
+        "description": "Διαμόρφωση των προηγμένων παραμέτρων. Αφήστε τις προεπιλεγμένες τιμές εάν δεν γνωρίζετε τι κάνετε.\nΑυτές οι παράμετροι μπορούν να οδηγήσουν σε πολύ κακή ρύθμιση θερμοκρασίας ή ενέργειας.",
+        "data": {
+          "minimal_activation_delay": "Ελάχιστη καθυστέρηση ενεργοποίησης",
+          "security_delay_min": "Καθυστέρηση ασφαλείας (σε λεπτά)",
+          "security_min_on_percent": "Ελάχιστο ποσοστό ισχύος για τη λειτουργία ασφαλείας",
+          "security_default_on_percent": "Ποσοστό ισχύος που θα χρησιμοποιηθεί στη λειτουργία ασφαλείας"
+        },
+        "data_description": {
+          "minimal_activation_delay": "Καθυστέρηση σε δευτερόλεπτα κάτω από την οποία ο εξοπλισμός δεν θα ενεργοποιηθεί",
+          "security_delay_min": "Μέγιστη επιτρεπόμενη καθυστέρηση σε λεπτά μεταξύ δύο μετρήσεων θερμοκρασίας. Πάνω από αυτή την καθυστέρηση, ο θερμοστάτης θα μεταβεί σε κατάσταση ασφαλείας",
+          "security_min_on_percent": "Ελάχιστη τιμή ποσοστού θέρμανσης για ενεργοποίηση του προεπιλεγμένου ασφαλείας. Κάτω από αυτό το ποσοστό ισχύος, ο θερμοστάτης δεν θα μεταβεί στο προεπιλεγμένο ασφαλείας",
+          "security_default_on_percent": "Η προεπιλεγμένη τιμή ποσοστού ισχύος θέρμανσης στο προεπιλεγμένο ασφαλείας. Ορίστε σε 0 για να απενεργοποιήσετε τη θερμάστρα στο παρόν ασφαλείας"
+        }
+      }
+    },
+    "error": {
+      "unknown": "Απροσδόκητο λάθος",
+      "unknown_entity": "Άγνωστο αναγνωριστικό οντότητας",
+      "window_open_detection_method": "Πρέπει να χρησιμοποιηθεί μόνο μία μέθοδος ανίχνευσης ανοιχτού παραθύρου. Χρησιμοποιήστε αισθητήρα ή αυτόματη ανίχνευση μέσω κατωφλίου θερμοκρασίας αλλά όχι και τα δύο"
+    },
+    "abort": {
+      "already_configured": "Η συσκευή έχει ήδη ρυθμιστεί"
+    }
+  },
+  "selector": {
+    "thermostat_type": {
+      "options": {
+        "thermostat_over_switch": "Θερμοστάτης πάνω σε διακόπτη",
+        "thermostat_over_climate": "Θερμοστάτης πάνω σε κλίμα",
+        "thermostat_over_valve": "Θερμοστάτης πάνω σε βαλβίδα"
+      }
+    },
+    "auto_regulation_mode": {
+      "options": {
+        "auto_regulation_slow": "Αργή",
+        "auto_regulation_strong": "Δυνατή",
+        "auto_regulation_medium": "Μέτρια",
+        "auto_regulation_light": "Ελαφριά",
+        "auto_regulation_expert": "Εμπειρογνώμων",
+        "auto_regulation_none": "Χωρίς αυτόματη ρύθμιση"
+      }
+    }
+  },
+  "entity": {
+    "climate": {
+      "versatile_thermostat": {
+        "state_attributes": {
+          "preset_mode": {
+            "state": {
+              "power": "Μείωση",
+              "security": "Ασφάλεια",
+              "none": "Χειροκίνητο"
+            }
+          }
+        }
+      }
+    }
+  }
+}

custom_components/versatile_thermostat/translations/en.json

@@ -25,17 +25,17 @@
         "title": "Linked entities",
         "description": "Linked entities attributes",
         "data": {
-          "heater_entity_id": "1rst heater switch",
+          "heater_entity_id": "1st heater switch",
           "heater_entity2_id": "2nd heater switch",
           "heater_entity3_id": "3rd heater switch",
           "heater_entity4_id": "4th heater switch",
           "proportional_function": "Algorithm",
-          "climate_entity_id": "1rst underlying climate",
+          "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": "1rst valve number",
+          "valve_entity_id": "1st valve number",
           "valve_entity2_id": "2nd valve number",
           "valve_entity3_id": "3rd valve number",
           "valve_entity4_id": "4th valve number",
@@ -55,14 +55,14 @@
           "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": "1rst valve number entity id",
+          "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 ° under which the temperature change will not be send",
+          "auto_regulation_dtemp": "The threshold in ° under which the temperature change will not be sent",
           "auto_regulation_periode_min": "Duration in minutes between two regulation update",
-          "inverse_switch_command": "For switch with pilot wire and diode you may need to inverse the command"
+          "inverse_switch_command": "For switch with pilot wire and diode you may need to invert the command"
         }
       },
       "tpi": {
@@ -75,7 +75,7 @@
       },
       "presets": {
         "title": "Presets",
-        "description": "For each presets, give the target temperature (0 to ignore preset)",
+        "description": "For each preset set the target temperature (0 to ignore preset)",
         "data": {
           "eco_temp": "Temperature in Eco preset",
           "comfort_temp": "Temperature in Comfort preset",
@@ -91,21 +91,21 @@
         "data": {
           "window_sensor_entity_id": "Window sensor entity id",
           "window_delay": "Window sensor delay (seconds)",
-          "window_auto_open_threshold": "Temperature decrease threshold for automatic window open detection (in °/min)",
-          "window_auto_close_threshold": "Temperature increase threshold for end of automatic detection (in °/min)",
+          "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)"
         },
         "data_description": {
-          "window_sensor_entity_id": "Leave empty if no window sensor should be use",
+          "window_sensor_entity_id": "Leave empty if no window sensor should be used",
           "window_delay": "The delay in seconds before sensor detection is taken into account",
-          "window_auto_open_threshold": "Recommended value: between 0.05 and 0.1. Leave empty if automatic window open detection is not use",
-          "window_auto_close_threshold": "Recommended value: 0. Leave empty if automatic window open detection is not use",
-          "window_auto_max_duration": "Recommended value: 60 (one hour). Leave empty if automatic window open detection is not use"
+          "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"
         }
       },
       "motion": {
         "title": "Motion management",
-        "description": "Motion sensor management. Preset can switch automatically depending of a motion detection\nLeave corresponding entity_id empty if not used.\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\nLeave corresponding entity_id empty if not used.\nmotion_preset and no_motion_preset should be set to the corresponding preset name",
         "data": {
           "motion_sensor_entity_id": "Motion sensor entity id",
           "motion_delay": "Activation delay",
@@ -115,7 +115,7 @@
         },
         "data_description": {
           "motion_sensor_entity_id": "The entity id of the motion sensor",
-          "motion_delay": "Motion activation activation delay (seconds)",
+          "motion_delay": "Motion activation delay (seconds)",
           "motion_off_delay": "Motion deactivation delay (seconds)",
           "motion_preset": "Preset to use when motion is detected",
           "no_motion_preset": "Preset to use when no motion is detected"
@@ -145,7 +145,7 @@
       },
       "advanced": {
         "title": "Advanced parameters",
-        "description": "Configuration of advanced parameters. Leave the default values if you don't know what you are doing.\nThis parameters can lead to a very bad temperature or 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.",
         "data": {
           "minimal_activation_delay": "Minimal activation delay",
           "security_delay_min": "Security delay (in minutes)",
@@ -154,16 +154,16 @@
         },
         "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 mesures. Above this delay, the thermostat will turn to a security off state",
+          "security_delay_min": "Maximum allowed delay in minutes between two temperature measurements. Above this delay the thermostat will turn to a security off state",
           "security_min_on_percent": "Minimal heating percent value for security preset activation. Below this amount of power percent the thermostat won't go into security preset",
-          "security_default_on_percent": "The default heating power percent value in security preset. Set to 0 to switch off heater in security present"
+          "security_default_on_percent": "The default heating power percent value in security preset. Set to 0 to switch off heater in security preset"
         }
       }
     },
     "error": {
       "unknown": "Unexpected error",
       "unknown_entity": "Unknown entity id",
-      "window_open_detection_method": "Only one window open detection method should be used. Use sensor or automatic detection through temperature threshold but not both"
+      "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"
     },
     "abort": {
       "already_configured": "Device is already configured"
@@ -194,17 +194,17 @@
         "title": "Linked entities",
         "description": "Linked entities attributes",
         "data": {
-          "heater_entity_id": "1rst heater switch",
+          "heater_entity_id": "1st heater switch",
           "heater_entity2_id": "2nd heater switch",
           "heater_entity3_id": "3rd heater switch",
           "heater_entity4_id": "4th heater switch",
           "proportional_function": "Algorithm",
-          "climate_entity_id": "1rst underlying climate",
+          "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": "1rst valve number",
+          "valve_entity_id": "1st valve number",
           "valve_entity2_id": "2nd valve number",
           "valve_entity3_id": "3rd valve number",
           "valve_entity4_id": "4th valve number",
@@ -224,14 +224,14 @@
           "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": "1rst valve number entity id",
+          "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 ° under which the temperature change will not be send",
+          "auto_regulation_dtemp": "The threshold in ° under which the temperature change will not be sent",
           "auto_regulation_periode_min": "Duration in minutes between two regulation update",
-          "inverse_switch_command": "For switch with pilot wire and diode you may need to inverse the command"
+          "inverse_switch_command": "For switch with pilot wire and diode you may need to invert the command"
         }
       },
       "tpi": {
@@ -244,7 +244,7 @@
       },
       "presets": {
         "title": "Presets",
-        "description": "For each presets, give the target temperature (0 to ignore preset)",
+        "description": "For each preset set the target temperature (0 to ignore preset)",
         "data": {
           "eco_temp": "Temperature in Eco preset",
           "comfort_temp": "Temperature in Comfort preset",
@@ -260,16 +260,16 @@
         "data": {
           "window_sensor_entity_id": "Window sensor entity id",
           "window_delay": "Window sensor delay (seconds)",
-          "window_auto_open_threshold": "Temperature decrease threshold for automatic window open detection (in °/min)",
-          "window_auto_close_threshold": "Temperature increase threshold for end of automatic detection (in °/min)",
+          "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)"
         },
         "data_description": {
-          "window_sensor_entity_id": "Leave empty if no window sensor should be use",
+          "window_sensor_entity_id": "Leave empty if no window sensor should be used",
           "window_delay": "The delay in seconds before sensor detection is taken into account",
-          "window_auto_open_threshold": "Recommended value: between 0.05 and 0.1. Leave empty if automatic window open detection is not use",
-          "window_auto_close_threshold": "Recommended value: 0. Leave empty if automatic window open detection is not use",
-          "window_auto_max_duration": "Recommended value: 60 (one hour). Leave empty if automatic window open detection is not use"
+          "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"
         }
       },
       "motion": {
@@ -284,7 +284,7 @@
         },
         "data_description": {
           "motion_sensor_entity_id": "The entity id of the motion sensor",
-          "motion_delay": "Motion activation activation delay (seconds)",
+          "motion_delay": "Motion activation delay (seconds)",
           "motion_off_delay": "Motion deactivation delay (seconds)",
           "motion_preset": "Preset to use when motion is detected",
           "no_motion_preset": "Preset to use when no motion is detected"
@@ -303,7 +303,7 @@
         "title": "Presence management",
         "description": "Presence management attributes.\nGives the a presence sensor of your home (true is someone is present).\nThen specify either the preset to use when presence sensor is false or the offset in temperature to apply.\nIf preset is given, the offset will not be used.\nLeave corresponding entity_id empty if not used.",
         "data": {
-          "presence_sensor_entity_id": "Presence sensor entity id (true is present)",
+          "presence_sensor_entity_id": "Presence sensor entity id",
           "eco_away_temp": "Temperature in Eco preset when no presence",
           "comfort_away_temp": "Temperature in Comfort preset when no presence",
           "boost_away_temp": "Temperature in Boost preset when no presence",
@@ -314,25 +314,25 @@
       },
       "advanced": {
         "title": "Advanced parameters",
-        "description": "Configuration of advanced parameters. Leave the default values if you don't know what you are doing.\nThis parameters can lead to a very bad temperature or 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.",
         "data": {
           "minimal_activation_delay": "Minimal activation delay",
           "security_delay_min": "Security delay (in minutes)",
-          "security_min_on_percent": "Minimal power percent for security mode",
+          "security_min_on_percent": "Minimal power percent to enable security mode",
           "security_default_on_percent": "Power percent to use in security mode"
         },
         "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 mesures. Above this delay, the thermostat will turn to a security off state",
+          "security_delay_min": "Maximum allowed delay in minutes between two temperature measurements. Above this delay the thermostat will turn to a security off state",
           "security_min_on_percent": "Minimal heating percent value for security preset activation. Below this amount of power percent the thermostat won't go into security preset",
-          "security_default_on_percent": "The default heating power percent value in security preset. Set to 0 to switch off heater in security present"
+          "security_default_on_percent": "The default heating power percent value in security preset. Set to 0 to switch off heater in security preset"
         }
       }
     },
     "error": {
       "unknown": "Unexpected error",
       "unknown_entity": "Unknown entity id",
-      "window_open_detection_method": "Only one window open detection method should be used. Use sensor or automatic detection through temperature threshold but not both"
+      "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"
     },
     "abort": {
       "already_configured": "Device is already configured"

custom_components/versatile_thermostat/translations/fr.json

@@ -91,14 +91,14 @@
         "data": {
           "window_sensor_entity_id": "Détecteur d'ouverture (entity id)",
           "window_delay": "Délai avant extinction (secondes)",
-          "window_auto_open_threshold": "Seuil haut de chute de température pour la détection automatique (en °/min)",
-          "window_auto_close_threshold": "Seuil bas de chute de température pour la fin de détection automatique (en °/min)",
+          "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)"
         },
         "data_description": {
           "window_sensor_entity_id": "Laissez vide si vous n'avez de détecteur",
           "window_delay": "Le délai (en secondes) avant que le changement du détecteur soit pris en compte",
-          "window_auto_open_threshold": "Valeur recommandée: entre 0.05 et 0.1. Laissez vide si vous n'utilisez pas la détection automatique",
+          "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"
         }
@@ -261,14 +261,14 @@
         "data": {
           "window_sensor_entity_id": "Détecteur d'ouverture (entity id)",
           "window_delay": "Délai avant extinction (secondes)",
-          "window_auto_open_threshold": "seuil haut de chute de température pour la détection automatique (en °/min)",
-          "window_auto_close_threshold": "Seuil bas de chute de température pour la fin de détection automatique (en °/min)",
+          "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)"
         },
         "data_description": {
           "window_sensor_entity_id": "Laissez vide si vous n'avez de détecteur",
           "window_delay": "Le délai (en secondes) avant que le changement du détecteur soit pris en compte",
-          "window_auto_open_threshold": "Valeur recommandée: entre 0.05 et 0.1. Laissez vide si vous n'utilisez pas la détection automatique",
+          "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"
         }

custom_components/versatile_thermostat/translations/it.json

@@ -87,14 +87,14 @@
         "data": {
           "window_sensor_entity_id": "Entity id sensore finestra",
           "window_delay": "Ritardo sensore finestra (secondi)",
-          "window_auto_open_threshold": "Soglia di diminuzione della temperatura per il rilevamento automatico della finestra aperta (in °/min)",
-          "window_auto_close_threshold": "Soglia di aumento della temperatura per la fine del rilevamento automatico (in °/min)",
+          "window_auto_open_threshold": "Soglia di diminuzione della temperatura per il rilevamento automatico della finestra aperta (in °/ora)",
+          "window_auto_close_threshold": "Soglia di aumento della temperatura per la fine del rilevamento automatico (in °/ora)",
           "window_auto_max_duration": "Durata massima del rilevamento automatico della finestra aperta (in min)"
         },
         "data_description": {
           "window_sensor_entity_id": "Lasciare vuoto se non deve essere utilizzato alcun sensore finestra",
           "window_delay": "Ritardo in secondi prima che il rilevamento del sensore sia preso in considerazione",
-          "window_auto_open_threshold": "Valore consigliato: tra 0.05 e 0.1. Lasciare vuoto se il rilevamento automatico della finestra aperta non è utilizzato",
+          "window_auto_open_threshold": "Valore consigliato: tra 3 e 10. Lasciare vuoto se il rilevamento automatico della finestra aperta non è utilizzato",
           "window_auto_close_threshold": "Valore consigliato: 0. Lasciare vuoto se il rilevamento automatico della finestra aperta non è utilizzato",
           "window_auto_max_duration": "Valore consigliato: 60 (un'ora). Lasciare vuoto se il rilevamento automatico della finestra aperta non è utilizzato"
         }
@@ -245,16 +245,16 @@
         "data": {
           "window_sensor_entity_id": "Entity id sensore finestra",
           "window_delay": "Ritardo sensore finestra (secondi)",
-          "window_auto_open_threshold": "Soglia di diminuzione della temperatura per il rilevamento automatico della finestra aperta (in °/min)",
-          "window_auto_close_threshold": "Soglia di aumento della temperatura per la fine del rilevamento automatico (in °/min)",
+          "window_auto_open_threshold": "Soglia di diminuzione della temperatura per il rilevamento automatico della finestra aperta (in °/ora)",
+          "window_auto_close_threshold": "Soglia di aumento della temperatura per la fine del rilevamento automatico (in °/ora)",
           "window_auto_max_duration": "Durata massima del rilevamento automatico della finestra aperta (in min)"
         },
         "data_description": {
           "window_sensor_entity_id": "Lasciare vuoto se non deve essere utilizzato alcun sensore finestra",
           "window_delay": "Ritardo in secondi prima che il rilevamento del sensore sia preso in considerazione",
-          "window_auto_open_threshold": "Valore consigliato: tra 0.05 e 0.1 - Lasciare vuoto se il rilevamento automatico della finestra aperta non è utilizzato",
-          "window_auto_close_threshold": "Valore consigliato: 0 - Lasciare vuoto se il rilevamento automatico della finestra aperta non è utilizzato",
-          "window_auto_max_duration": "Valore consigliato: 60 minuti. Lasciare vuoto se il rilevamento automatico della finestra aperta non è utilizzato"
+          "window_auto_open_threshold": "Valore consigliato: tra 3 e 10. Lasciare vuoto se il rilevamento automatico della finestra aperta non è utilizzato",
+          "window_auto_close_threshold": "Valore consigliato: 0. Lasciare vuoto se il rilevamento automatico della finestra aperta non è utilizzato",
+          "window_auto_max_duration": "Valore consigliato: 60 (un'ora). Lasciare vuoto se il rilevamento automatico della finestra aperta non è utilizzato"
         }
       },
       "motion": {

custom_components/versatile_thermostat/translations/sk.json

@@ -91,14 +91,14 @@
         "data": {
           "window_sensor_entity_id": "ID entity snímača okna",
           "window_delay": "Oneskorenie snímača okna (sekundy)",
-          "window_auto_open_threshold": "Prah poklesu teploty pre automatickú detekciu otvoreného okna (v °/min)",
-          "window_auto_close_threshold": "Prahová hodnota zvýšenia teploty pre koniec automatickej detekcie (v °/min)",
+          "window_auto_open_threshold": "Prah poklesu teploty pre automatickú detekciu otvoreného okna (v °/hodina)",
+          "window_auto_close_threshold": "Prahová hodnota zvýšenia teploty pre koniec automatickej detekcie (v °/hodina)",
           "window_auto_max_duration": "Maximálne trvanie automatickej detekcie otvoreného okna (v min)"
         },
         "data_description": {
           "window_sensor_entity_id": "Nechajte prázdne, ak nemáte použiť žiadny okenný senzor",
           "window_delay": "Zohľadňuje sa oneskorenie v sekundách pred detekciou snímača",
-          "window_auto_open_threshold": "Odporúčaná hodnota: medzi 0,05 a 0,1. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
+          "window_auto_open_threshold": "Odporúčaná hodnota: medzi 3 a 10. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
           "window_auto_close_threshold": "Odporúčaná hodnota: 0. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
           "window_auto_max_duration": "Odporúčaná hodnota: 60 (jedna hodina). Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne"
         }
@@ -260,14 +260,14 @@
         "data": {
           "window_sensor_entity_id": "ID entity snímača okna",
           "window_delay": "Oneskorenie snímača okna (sekundy)",
-          "window_auto_open_threshold": "Prah poklesu teploty pre automatickú detekciu otvoreného okna (v °/min)",
-          "window_auto_close_threshold": "Prahová hodnota zvýšenia teploty pre koniec automatickej detekcie (v °/min)",
+          "window_auto_open_threshold": "Prah poklesu teploty pre automatickú detekciu otvoreného okna (v °/hodina)",
+          "window_auto_close_threshold": "Prahová hodnota zvýšenia teploty pre koniec automatickej detekcie (v °/hodina)",
           "window_auto_max_duration": "Maximálne trvanie automatickej detekcie otvoreného okna (v min)"
         },
         "data_description": {
           "window_sensor_entity_id": "Nechajte prázdne, ak nemáte použiť žiadny okenný senzor",
           "window_delay": "Zohľadňuje sa oneskorenie v sekundách pred detekciou snímača",
-          "window_auto_open_threshold": "Odporúčaná hodnota: medzi 0,05 a 0,1. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
+          "window_auto_open_threshold": "Odporúčaná hodnota: medzi 3 a 10. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
           "window_auto_close_threshold": "Odporúčaná hodnota: 0. Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne",
           "window_auto_max_duration": "Odporúčaná hodnota: 60 (jedna hodina). Ak sa nepoužíva automatická detekcia otvoreného okna, nechajte prázdne"
         }

custom_components/versatile_thermostat/vtherm_api.py

@@ -3,10 +3,7 @@ import logging
 from homeassistant.core import HomeAssistant
 from homeassistant.config_entries import ConfigEntry
 
-from .const import (
-    DOMAIN,
-    CONF_AUTO_REGULATION_EXPERT,
-)
+from .const import DOMAIN, CONF_AUTO_REGULATION_EXPERT, CONF_SHORT_EMA_PARAMS
 
 VTHERM_API_NAME = "vtherm_api"
 
@@ -33,6 +30,7 @@ class VersatileThermostatAPI(dict):
         super().__init__()
         self._hass = hass
         self._expert_params = None
+        self._short_ema_params = None
 
     def add_entry(self, entry: ConfigEntry):
         """Add a new entry"""
@@ -59,11 +57,20 @@ class VersatileThermostatAPI(dict):
         if self._expert_params:
             _LOGGER.debug("We have found expert params %s", self._expert_params)
 
+        self._short_ema_params = config.get(CONF_SHORT_EMA_PARAMS)
+        if self._short_ema_params:
+            _LOGGER.debug("We have found short ema params %s", self._short_ema_params)
+
     @property
     def self_regulation_expert(self):
         """Get the self regulation params"""
         return self._expert_params
 
+    @property
+    def short_ema_params(self):
+        """Get the self regulation params"""
+        return self._short_ema_params
+
     @property
     def hass(self):
         """Get the HomeAssistant object"""

tests/test_auto_regulation.py

@@ -363,12 +363,12 @@ async def test_over_climate_regulation_limitations(
             "custom_components.versatile_thermostat.commons.NowClass.get_now",
             return_value=event_timestamp,
         ):
-            await send_temperature_change_event(entity, 16, event_timestamp)
+            await send_temperature_change_event(entity, 15, event_timestamp)
             await send_ext_temperature_change_event(entity, 12, event_timestamp)
 
             # the regulated should have been done
             assert entity.regulated_target_temp != old_regulated_temp
             assert entity.regulated_target_temp >= entity.target_temperature
             assert (
-                entity.regulated_target_temp == 17 + 0.5
+                entity.regulated_target_temp == 17 + 1.5
             )  # 0.7 without round_to_nearest

tests/test_ema.py

@@ -0,0 +1,54 @@
+# pylint: disable=line-too-long
+""" Tests de EMA calculation"""
+from datetime import datetime, timedelta
+
+from homeassistant.core import HomeAssistant
+
+from custom_components.versatile_thermostat.ema import ExponentialMovingAverage
+
+from .commons import get_tz
+
+
+def test_ema_basics(hass: HomeAssistant):
+    """Test the EMA calculation with basic features"""
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    the_ema = ExponentialMovingAverage(
+        "test",
+        # 5 minutes
+        300,
+        # Needed for time calculation
+        get_tz(hass),
+        1,
+    )
+
+    assert the_ema
+
+    current_timestamp = now
+    # First initialization
+    assert the_ema.calculate_ema(20, current_timestamp) == 20
+
+    current_timestamp = current_timestamp + timedelta(minutes=1)
+    # One minute later, same temperature. EMA temperature should not have change
+    assert the_ema.calculate_ema(20, current_timestamp) == 20
+
+    # Too short measurement should be ignored
+    assert the_ema.calculate_ema(2000, current_timestamp) == 20
+
+    current_timestamp = current_timestamp + timedelta(seconds=4)
+    assert the_ema.calculate_ema(20, current_timestamp) == 20
+
+    # a new normal measurement 5 minutes later
+    current_timestamp = current_timestamp + timedelta(minutes=5)
+    ema = the_ema.calculate_ema(25, current_timestamp)
+    assert ema > 20
+    assert ema == 22.5
+
+    # a big change in a short time does have a limited effect
+    current_timestamp = current_timestamp + timedelta(seconds=5)
+    ema = the_ema.calculate_ema(30, current_timestamp)
+    assert ema > 22.5
+    assert ema < 23
+    assert ema == 22.6

tests/test_multiple_switch.py

@@ -386,6 +386,7 @@ async def test_multiple_climates(
             CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
             CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
             CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 8,
             CONF_TEMP_MIN: 15,
             CONF_TEMP_MAX: 30,
             "eco_temp": 17,
@@ -486,6 +487,7 @@ async def test_multiple_climates_underlying_changes(
             CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
             CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
             CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 8,
             CONF_TEMP_MIN: 15,
             CONF_TEMP_MAX: 30,
             "eco_temp": 17,

tests/test_open_window_algo.py

@@ -2,7 +2,9 @@
 """ Test the OpenWindow algorithm """
 
 from datetime import datetime, timedelta
-from custom_components.versatile_thermostat.open_window_algorithm import WindowOpenDetectionAlgorithm
+from custom_components.versatile_thermostat.open_window_algorithm import (
+    WindowOpenDetectionAlgorithm,
+)
 
 from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
 
@@ -13,24 +15,34 @@ async def test_open_window_algo(
 ):
     """Tests the Algo"""
 
-    the_algo = WindowOpenDetectionAlgorithm(1.0, 0.0)
+    the_algo = WindowOpenDetectionAlgorithm(60.0, 0.0)
     assert the_algo.last_slope is None
 
     tz = get_tz(hass)  # pylint: disable=invalid-name
     now = datetime.now(tz)
 
-    event_timestamp = now - timedelta(minutes=5)
+    event_timestamp = now - timedelta(minutes=10)
     last_slope = the_algo.add_temp_measurement(
         temperature=10, datetime_measure=event_timestamp
     )
 
-    # We need at least 2 measurement
+    # We need at least 4 measurement
     assert last_slope is None
     assert the_algo.last_slope is None
     assert the_algo.is_window_close_detected() is False
     assert the_algo.is_window_open_detected() is False
 
-    event_timestamp = now - timedelta(minutes=4)
+    event_timestamp = now - timedelta(minutes=9)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=10, datetime_measure=event_timestamp
+    )
+
+    event_timestamp = now - timedelta(minutes=8)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=10, datetime_measure=event_timestamp
+    )
+
+    event_timestamp = now - timedelta(minutes=7)
     last_slope = the_algo.add_temp_measurement(
         temperature=10, datetime_measure=event_timestamp
     )
@@ -41,62 +53,62 @@ async def test_open_window_algo(
     assert the_algo.is_window_close_detected() is True
     assert the_algo.is_window_open_detected() is False
 
-    event_timestamp = now - timedelta(minutes=3)
+    event_timestamp = now - timedelta(minutes=6)
     last_slope = the_algo.add_temp_measurement(
         temperature=9, datetime_measure=event_timestamp
     )
 
     # A slope is calculated
-    assert last_slope == -0.5
-    assert the_algo.last_slope == -0.5
+    assert last_slope == -48.0
+    assert the_algo.last_slope == -48.0
     assert the_algo.is_window_close_detected() is False
     assert the_algo.is_window_open_detected() is False
 
     # A new temperature with 2 degre less in one minute (value will be rejected)
+    event_timestamp = now - timedelta(minutes=5)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=7, datetime_measure=event_timestamp
+    )
+
+    # A slope is calculated
+    assert last_slope == (-48.0 * 0.2 - 120.0 * 0.8)
+    assert the_algo.last_slope == -105.6
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is True
+
+    # A new temperature with 1 degre less
+    event_timestamp = now - timedelta(minutes=4)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=6, datetime_measure=event_timestamp
+    )
+
+    # A slope is calculated
+    assert last_slope == -105.6 * 0.2 - 60.0 * 0.8
+    assert the_algo.last_slope == -69.12
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is True
+
+    # A new temperature with 0 degre less
+    event_timestamp = now - timedelta(minutes=3)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=6, datetime_measure=event_timestamp
+    )
+
+    # A slope is calculated
+    assert last_slope == round(-69.12 * 0.2 - 0.0 * 0.8, 2)
+    assert the_algo.last_slope == -13.82
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is False
+
+    # A new temperature with 1 degre more
     event_timestamp = now - timedelta(minutes=2)
     last_slope = the_algo.add_temp_measurement(
         temperature=7, datetime_measure=event_timestamp
     )
 
     # A slope is calculated
-    assert last_slope == -0.5 / 2.0 - 2.0 / 2.0
-    assert the_algo.last_slope == -1.25
-    assert the_algo.is_window_close_detected() is False
-    assert the_algo.is_window_open_detected() is True
-
-    # A new temperature with 1 degre less
-    event_timestamp = now - timedelta(minutes=1)
-    last_slope = the_algo.add_temp_measurement(
-        temperature=6, datetime_measure=event_timestamp
-    )
-
-    # A slope is calculated
-    assert last_slope == -1.25 / 2 - 1.0 / 2.0
-    assert the_algo.last_slope == -1.125
-    assert the_algo.is_window_close_detected() is False
-    assert the_algo.is_window_open_detected() is True
-
-    # A new temperature with 0 degre less
-    event_timestamp = now - timedelta(minutes=0)
-    last_slope = the_algo.add_temp_measurement(
-        temperature=6, datetime_measure=event_timestamp
-    )
-
-    # A slope is calculated
-    assert last_slope == -1.125 / 2
-    assert the_algo.last_slope == -1.125 / 2
-    assert the_algo.is_window_close_detected() is False
-    assert the_algo.is_window_open_detected() is False
-
-    # A new temperature with 1 degre more
-    event_timestamp = now + timedelta(minutes=1)
-    last_slope = the_algo.add_temp_measurement(
-        temperature=7, datetime_measure=event_timestamp
-    )
-
-    # A slope is calculated
-    assert last_slope == -1.125 / 4 + 0.5
-    assert the_algo.last_slope == 0.21875
+    assert last_slope == round(-13.82 * 0.2 + 60.0 * 0.8, 2)
+    assert the_algo.last_slope == 45.24
     assert the_algo.is_window_close_detected() is True
     assert the_algo.is_window_open_detected() is False
 
@@ -106,7 +118,7 @@ async def test_open_window_algo_wrong(
     skip_hass_states_is_state,
 ):
     """Tests the Algo with wrong date"""
-    the_algo = WindowOpenDetectionAlgorithm(1.0, 0.0)
+    the_algo = WindowOpenDetectionAlgorithm(60.0, 0.0)
     assert the_algo.last_slope is None
 
     tz = get_tz(hass)  # pylint: disable=invalid-name
@@ -134,3 +146,95 @@ async def test_open_window_algo_wrong(
     assert the_algo.last_slope is None
     assert the_algo.is_window_close_detected() is False
     assert the_algo.is_window_open_detected() is False
+
+
+async def test_open_window_algo_fake_point(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+):
+    """Tests the Algo with adding fake point"""
+
+    the_algo = WindowOpenDetectionAlgorithm(3.0, 0.1)
+    assert the_algo.last_slope is None
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now = datetime.now(tz)
+
+    event_timestamp = now
+    last_slope = the_algo.check_age_last_measurement(
+        temperature=10, datetime_now=event_timestamp
+    )
+
+    # We need at least 4 measurement
+    assert last_slope is None
+    assert the_algo.last_slope is None
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is False
+
+    event_timestamp = now + timedelta(minutes=1)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=10, datetime_measure=event_timestamp
+    )
+
+    event_timestamp = now + timedelta(minutes=2)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=10, datetime_measure=event_timestamp
+    )
+
+    event_timestamp = now + timedelta(minutes=3)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=10, datetime_measure=event_timestamp
+    )
+
+    # No slope because same temperature
+    assert last_slope == 0
+    assert the_algo.last_slope == 0
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is False
+
+    event_timestamp = now + timedelta(minutes=4)
+    last_slope = the_algo.add_temp_measurement(
+        temperature=9, datetime_measure=event_timestamp
+    )
+
+    # A slope is calculated
+    assert last_slope == -48.0
+    assert the_algo.last_slope == -48.0
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is True  # One degre in one minute
+
+    # 1 Add a fake point one minute later
+    event_timestamp = now + timedelta(minutes=5)
+    last_slope = the_algo.check_age_last_measurement(
+        temperature=8, datetime_now=event_timestamp
+    )
+
+    # The slope not have change (fake point is ignored)
+    assert last_slope == -48.0
+    assert the_algo.last_slope == -48.0
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is True  # One degre in one minute
+
+    # 2 Add a fake point 31 minute later -> +2 degres in 32 minutes
+    event_timestamp = event_timestamp + timedelta(minutes=31)
+    last_slope = the_algo.check_age_last_measurement(
+        temperature=10, datetime_now=event_timestamp
+    )
+
+    # The slope should have change (fake point is added)
+    assert last_slope == -8.1
+    assert the_algo.last_slope == -8.1
+    assert the_algo.is_window_close_detected() is False
+    assert the_algo.is_window_open_detected() is True
+
+    # 3 Add a 2nd fake point 30 minute later -> +3 degres in 30 minutes
+    event_timestamp = event_timestamp + timedelta(minutes=31)
+    last_slope = the_algo.check_age_last_measurement(
+        temperature=13, datetime_now=event_timestamp
+    )
+
+    # The slope should have change (fake point is added)
+    assert last_slope == 0.67
+    assert the_algo.last_slope == 0.67
+    assert the_algo.is_window_close_detected() is True
+    assert the_algo.is_window_open_detected() is False

tests/test_security.py

@@ -5,8 +5,12 @@ from unittest.mock import patch, call
 from datetime import timedelta, datetime
 import logging
 
-from custom_components.versatile_thermostat.thermostat_climate import ThermostatOverClimate
-from custom_components.versatile_thermostat.thermostat_switch import ThermostatOverSwitch
+from custom_components.versatile_thermostat.thermostat_climate import (
+    ThermostatOverClimate,
+)
+from custom_components.versatile_thermostat.thermostat_switch import (
+    ThermostatOverSwitch,
+)
 from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
 
 
@@ -195,6 +199,197 @@ async def test_security_feature(hass: HomeAssistant, skip_hass_states_is_state):
         assert mock_heater_on.call_count == 1
 
 
+@pytest.mark.parametrize("expected_lingering_tasks", [True])
+@pytest.mark.parametrize("expected_lingering_timers", [True])
+async def test_security_feature_back_on_percent(
+    hass: HomeAssistant, skip_hass_states_is_state
+):
+    """Test the security feature and https://github.com/jmcollin78/versatile_thermostat/issues/49:
+    1. creates a thermostat and check that security is off, preset Boost
+    2. change temperature so that on_percent is high
+    3. send next timestamp date so that security is on WITH A Eco preset that makes a on_percent low
+    4. this shoud resolve the date issue
+    4. check that security is off and preset is Boost
+    """
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            "name": "TheOverSwitchMockName",
+            "thermostat_type": "thermostat_over_switch",
+            "temperature_sensor_entity_id": "sensor.mock_temp_sensor",
+            "external_temperature_sensor_entity_id": "sensor.mock_ext_temp_sensor",
+            "cycle_min": 5,
+            "temp_min": 15,
+            "temp_max": 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            "use_window_feature": False,
+            "use_motion_feature": False,
+            "use_power_feature": False,
+            "use_presence_feature": False,
+            "heater_entity_id": "switch.mock_switch",
+            "proportional_function": "tpi",
+            "tpi_coef_int": 0.3,
+            "tpi_coef_ext": 0.01,
+            "minimal_activation_delay": 30,
+            "security_delay_min": 5,  # 5 minutes
+            "security_min_on_percent": 0.2,
+            "security_default_on_percent": 0.1,
+        },
+    )
+
+    # 1. creates a thermostat and check that security is off
+    now: datetime = datetime.now(tz=tz)
+    entity: ThermostatOverSwitch = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    assert entity._security_state is False
+    assert entity.preset_mode is not PRESET_SECURITY
+    assert entity._last_ext_temperature_mesure is not None
+    assert entity._last_temperature_mesure is not None
+    assert (entity._last_temperature_mesure.astimezone(tz) - now).total_seconds() < 1
+    assert (
+        entity._last_ext_temperature_mesure.astimezone(tz) - now
+    ).total_seconds() < 1
+
+    # set a preset
+    assert entity.preset_mode is PRESET_NONE
+    await entity.async_set_preset_mode(PRESET_BOOST)
+    assert entity.preset_mode is PRESET_BOOST
+
+    # Turn On the thermostat
+    assert entity.hvac_mode == HVACMode.OFF
+    await entity.async_set_hvac_mode(HVACMode.HEAT)
+    assert entity.hvac_mode == HVACMode.HEAT
+
+    # 2. activate on_percent
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on:
+        event_timestamp = now + timedelta(minutes=1)
+        entity._set_now(event_timestamp)  # pylint: disable=protected-access
+
+        # set temperature to 17 so that on_percent will be > security_min_on_percent (0.2)
+        await send_temperature_change_event(entity, 17, event_timestamp)
+        assert entity._prop_algorithm.calculated_on_percent == 0.6
+        assert entity.preset_mode == PRESET_BOOST
+        assert entity.security_state is False
+        assert mock_send_event.call_count == 0
+
+    # 3. Set security mode with a preset change
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on:
+        # 6 min between two mesure
+        event_timestamp = event_timestamp + timedelta(minutes=6)
+        entity._set_now(event_timestamp)  # pylint: disable=protected-access
+
+        await send_temperature_change_event(entity, 17, event_timestamp)
+
+        assert entity._prop_algorithm.calculated_on_percent == 0.6
+
+        assert entity.security_state is True
+        assert entity.preset_mode == PRESET_SECURITY
+        assert entity._saved_preset_mode == PRESET_BOOST
+
+        assert mock_send_event.call_count == 3
+        mock_send_event.assert_has_calls(
+            [
+                call.send_event(EventType.PRESET_EVENT, {"preset": PRESET_SECURITY}),
+                call.send_event(
+                    EventType.TEMPERATURE_EVENT,
+                    {
+                        "last_temperature_mesure": event_timestamp.isoformat(),
+                        "last_ext_temperature_mesure": entity._last_ext_temperature_mesure.isoformat(),
+                        "current_temp": 17,
+                        "current_ext_temp": None,
+                        "target_temp": 19,
+                    },
+                ),
+                call.send_event(
+                    EventType.SECURITY_EVENT,
+                    {
+                        "type": "start",
+                        "last_temperature_mesure": event_timestamp.isoformat(),
+                        "last_ext_temperature_mesure": entity._last_ext_temperature_mesure.isoformat(),
+                        "current_temp": 17,
+                        "current_ext_temp": None,
+                        "target_temp": 19,
+                    },
+                ),
+            ],
+            any_order=True,
+        )
+
+        # heating have been started on the previous call
+        assert mock_heater_on.call_count == 0
+
+    # 4. change preset so that on_percent will be low
+    event_timestamp = event_timestamp + timedelta(minutes=1)
+    entity._set_now(event_timestamp)  # pylint: disable=protected-access
+
+    await entity.async_set_preset_mode(PRESET_ECO)
+    assert entity.security_state is True
+    assert entity.preset_mode == PRESET_SECURITY
+
+    # 5. resolve the datetime issue
+    with patch(
+        "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on:
+        # +2 min between two mesure
+        event_timestamp = event_timestamp + timedelta(minutes=2)
+        entity._set_now(event_timestamp)  # pylint: disable=protected-access
+
+        # set temperature to 18.9 so that on_percent will be > security_min_on_percent (0.2)
+        await send_temperature_change_event(entity, 18.92, event_timestamp)
+
+        assert entity._security_state is False
+        assert entity.preset_mode == PRESET_ECO
+        assert entity._saved_preset_mode == PRESET_ECO
+        assert entity._prop_algorithm.on_percent == 0.0
+        assert entity._prop_algorithm.calculated_on_percent == 0.0
+
+        assert mock_send_event.call_count == 2
+        mock_send_event.assert_has_calls(
+            [
+                call.send_event(EventType.PRESET_EVENT, {"preset": PRESET_ECO}),
+                call.send_event(
+                    EventType.SECURITY_EVENT,
+                    {
+                        "type": "end",
+                        "last_temperature_mesure": event_timestamp.astimezone(
+                            tz
+                        ).isoformat(),
+                        "last_ext_temperature_mesure": entity._last_ext_temperature_mesure.astimezone(
+                            tz
+                        ).isoformat(),
+                        "current_temp": 18.92,
+                        "current_ext_temp": None,
+                        "target_temp": 17,
+                    },
+                ),
+            ],
+            any_order=True,
+        )
+
+        # Heater is stays off
+        assert mock_heater_on.call_count == 0
+
+
 @pytest.mark.parametrize("expected_lingering_tasks", [True])
 @pytest.mark.parametrize("expected_lingering_timers", [True])
 async def test_security_over_climate(
@@ -212,10 +407,12 @@ async def test_security_over_climate(
         domain=DOMAIN,
         title="TheOverClimateMockName",
         unique_id="uniqueId",
-        data=PARTIAL_CLIMATE_CONFIG, # 5 minutes security delay
+        data=PARTIAL_CLIMATE_CONFIG,  # 5 minutes security delay
     )
 
-    fake_underlying_climate = MockClimate(hass, "mockUniqueId", "MockClimateName", {}, HVACMode.HEAT, HVACAction.HEATING)
+    fake_underlying_climate = MockClimate(
+        hass, "mockUniqueId", "MockClimateName", {}, HVACMode.HEAT, HVACAction.HEATING
+    )
 
     with patch(
         "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
@@ -274,7 +471,9 @@ async def test_security_over_climate(
         # Force security mode
         assert entity._last_ext_temperature_mesure is not None
         assert entity._last_temperature_mesure is not None
-        assert (entity._last_temperature_mesure.astimezone(tz) - now).total_seconds() < 1
+        assert (
+            entity._last_temperature_mesure.astimezone(tz) - now
+        ).total_seconds() < 1
         assert (
             entity._last_ext_temperature_mesure.astimezone(tz) - now
         ).total_seconds() < 1
@@ -305,5 +504,5 @@ async def test_security_over_climate(
             await send_temperature_change_event(entity, 15, event_timestamp)
             # Should stay False because a climate is never in security mode
             assert entity.security_state is False
-            assert entity.preset_mode == 'none'
-            assert entity._saved_preset_mode == 'none'
+            assert entity.preset_mode == "none"
+            assert entity._saved_preset_mode == "none"

tests/test_switch_ac.py

@@ -123,7 +123,7 @@ async def test_over_switch_ac_full_start(hass: HomeAssistant, skip_hass_states_i
 
             assert entity.hvac_mode is HVACMode.OFF
             assert entity.hvac_action is HVACAction.OFF
-            assert entity.target_temperature == 27 # eco_ac_away
+            assert entity.target_temperature == 16 # eco_ac_away
 
         # Close a window
         with patch(
@@ -142,11 +142,18 @@ async def test_over_switch_ac_full_start(hass: HomeAssistant, skip_hass_states_i
         await entity.async_set_hvac_mode(HVACMode.HEAT)
         assert entity.hvac_mode is HVACMode.HEAT
 
+        # switch to comfort
         await entity.async_set_preset_mode(PRESET_COMFORT)
         assert entity.preset_mode is PRESET_COMFORT
-        assert entity.target_temperature == 26
+        assert entity.target_temperature == 17
 
         # switch to Eco
         await entity.async_set_preset_mode(PRESET_ECO)
         assert entity.preset_mode is PRESET_ECO
-        assert entity.target_temperature == 27
+        assert entity.target_temperature == 16
+
+        # switch to boost
+        await entity.async_set_preset_mode(PRESET_BOOST)
+        assert entity.preset_mode is PRESET_BOOST
+        assert entity.target_temperature == 18
+

tests/test_window.py

@@ -296,6 +296,14 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
 
     assert entity.window_state is STATE_OFF
 
+    # Initialize the slope algo with 2 measurements
+    event_timestamp = now + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 19, event_timestamp)
+    event_timestamp = event_timestamp + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 19, event_timestamp)
+    event_timestamp = event_timestamp + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 19, event_timestamp)
+
     # Make the temperature down
     with patch(
         "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
@@ -307,13 +315,13 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
         "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
         return_value=True,
     ):
-        event_timestamp = now - timedelta(minutes=4)
+        event_timestamp = event_timestamp + timedelta(minutes=1)
         await send_temperature_change_event(entity, 19, event_timestamp)
 
         # The heater turns on
         assert mock_send_event.call_count == 0
-        assert mock_heater_on.call_count == 1
-        assert entity.last_temperature_slope is None
+        assert entity.is_device_active is True
+        assert entity.last_temperature_slope == 0.0
         assert entity._window_auto_algo.is_window_open_detected() is False
         assert entity._window_auto_algo.is_window_close_detected() is False
         assert entity.hvac_mode is HVACMode.HEAT
@@ -329,14 +337,14 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
         "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
         return_value=True,
     ):
-        event_timestamp = now - timedelta(minutes=3)
+        event_timestamp = event_timestamp + timedelta(minutes=1)
         await send_temperature_change_event(entity, 18, event_timestamp)
 
         # The heater turns on
         assert mock_send_event.call_count == 2
         assert mock_heater_on.call_count == 0
         assert mock_heater_off.call_count >= 1
-        assert entity.last_temperature_slope == -1
+        assert entity.last_temperature_slope == -6.24
         assert entity._window_auto_algo.is_window_open_detected() is True
         assert entity._window_auto_algo.is_window_close_detected() is False
         assert entity.window_auto_state == STATE_ON
@@ -347,7 +355,7 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
                 call.send_event(EventType.HVAC_MODE_EVENT, {"hvac_mode": HVACMode.OFF}),
                 call.send_event(
                     EventType.WINDOW_AUTO_EVENT,
-                    {"type": "start", "cause": "slope alert", "curve_slope": -1.0},
+                    {"type": "start", "cause": "slope alert", "curve_slope": -6.24},
                 ),
             ],
             any_order=True,
@@ -365,14 +373,14 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
         new_callable=PropertyMock,
         return_value=False,
     ):
-        event_timestamp = now - timedelta(minutes=2)
+        event_timestamp = event_timestamp + timedelta(minutes=1)
         await send_temperature_change_event(entity, 17.9, event_timestamp)
 
         # The heater turns on
         assert mock_send_event.call_count == 0
         assert mock_heater_on.call_count == 0
         assert mock_heater_off.call_count == 0
-        assert round(entity.last_temperature_slope, 3) == -0.1 * 0.5 - 1 * 0.5
+        assert round(entity.last_temperature_slope, 3) == -7.49
         assert entity._window_auto_algo.is_window_open_detected() is True
         assert entity._window_auto_algo.is_window_close_detected() is False
         assert entity.window_auto_state == STATE_ON
@@ -390,7 +398,7 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
         new_callable=PropertyMock,
         return_value=False,
     ):
-        event_timestamp = now - timedelta(minutes=1)
+        event_timestamp = event_timestamp + timedelta(minutes=1)
         await send_temperature_change_event(entity, 19, event_timestamp)
 
         # The heater turns on
@@ -405,7 +413,7 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
                     {
                         "type": "end",
                         "cause": "end of slope alert",
-                        "curve_slope": 0.27500000000000036,
+                        "curve_slope": 0.42,
                     },
                 ),
             ],
@@ -413,7 +421,7 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
         )
         assert mock_heater_on.call_count == 1
         assert mock_heater_off.call_count == 0
-        assert round(entity.last_temperature_slope, 3) == 0.275
+        assert entity.last_temperature_slope == 0.42
         assert entity._window_auto_algo.is_window_open_detected() is False
         assert entity._window_auto_algo.is_window_close_detected() is True
         assert entity.window_auto_state == STATE_OFF
@@ -451,8 +459,8 @@ async def test_window_auto_auto_stop(hass: HomeAssistant, skip_hass_states_is_st
             CONF_MINIMAL_ACTIVATION_DELAY: 30,
             CONF_SECURITY_DELAY_MIN: 5,
             CONF_SECURITY_MIN_ON_PERCENT: 0.3,
-            CONF_WINDOW_AUTO_OPEN_THRESHOLD: 0.1,
-            CONF_WINDOW_AUTO_CLOSE_THRESHOLD: 0.1,
+            CONF_WINDOW_AUTO_OPEN_THRESHOLD: 6,
+            CONF_WINDOW_AUTO_CLOSE_THRESHOLD: 6,
             CONF_WINDOW_AUTO_MAX_DURATION: 0,  # Should be 0 for test
         },
     )
@@ -477,6 +485,14 @@ async def test_window_auto_auto_stop(hass: HomeAssistant, skip_hass_states_is_st
 
     assert entity.window_state is STATE_OFF
 
+    # Initialize the slope algo with 2 measurements
+    event_timestamp = now + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 19, event_timestamp)
+    event_timestamp = event_timestamp + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 19, event_timestamp)
+    event_timestamp = event_timestamp + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 19, event_timestamp)
+
     # Make the temperature down
     with patch(
         "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
@@ -486,12 +502,13 @@ async def test_window_auto_auto_stop(hass: HomeAssistant, skip_hass_states_is_st
         "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.is_device_active",
         return_value=True,
     ):
-        event_timestamp = now - timedelta(minutes=4)
+        # This is the 3rd measurment. Slope is not ready
+        event_timestamp = event_timestamp + timedelta(minutes=1)
         await send_temperature_change_event(entity, 19, event_timestamp)
 
         # The climate turns on but was alredy on
         assert mock_set_hvac_mode.call_count == 0
-        assert entity.last_temperature_slope is None
+        assert entity.last_temperature_slope == 0.0
         assert entity._window_auto_algo.is_window_open_detected() is False
         assert entity._window_auto_algo.is_window_close_detected() is False
         assert entity.hvac_mode is HVACMode.HEAT
@@ -505,9 +522,13 @@ async def test_window_auto_auto_stop(hass: HomeAssistant, skip_hass_states_is_st
         "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
         return_value=True,
     ):
-        event_timestamp = now - timedelta(minutes=3)
+        event_timestamp = event_timestamp + timedelta(minutes=1)
         await send_temperature_change_event(entity, 18, event_timestamp, sleep=False)
 
+        assert entity.last_temperature_slope == -6.24
+        assert entity._window_auto_algo.is_window_open_detected() is True
+        assert entity._window_auto_algo.is_window_close_detected() is False
+
         assert mock_send_event.call_count == 2
         # The heater turns off
         mock_send_event.assert_has_calls(
@@ -518,20 +539,22 @@ async def test_window_auto_auto_stop(hass: HomeAssistant, skip_hass_states_is_st
                     {
                         "type": "start",
                         "cause": "slope alert",
-                        "curve_slope": -1.0,
+                        "curve_slope": -6.24,
                     },
                 ),
             ],
             any_order=True,
         )
         assert mock_set_hvac_mode.call_count >= 1
-        assert entity.last_temperature_slope == -1
-        assert entity._window_auto_algo.is_window_open_detected() is True
-        assert entity._window_auto_algo.is_window_close_detected() is False
         assert entity.window_auto_state == STATE_ON
         assert entity.hvac_mode is HVACMode.OFF
 
-        # Waits for automatic disable
+    # This is to avoid that the slope stayx under 6, else we will reactivate the window immediatly
+    event_timestamp = event_timestamp + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 19, event_timestamp, sleep=False)
+    assert entity.last_temperature_slope > -6.0
+
+    # Waits for automatic disable
     with patch(
         "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
     ) as mock_send_event, patch(
@@ -542,14 +565,14 @@ async def test_window_auto_auto_stop(hass: HomeAssistant, skip_hass_states_is_st
     ):
         await asyncio.sleep(0.3)
 
-        assert mock_set_hvac_mode.call_count == 1
-        assert round(entity.last_temperature_slope, 3) == -1
-        # Because the algorithm is not aware of the expiration, for the algo we are still in alert
-        assert entity._window_auto_algo.is_window_open_detected() is True
-        assert entity._window_auto_algo.is_window_close_detected() is False
-        assert entity.window_auto_state == STATE_OFF
         assert entity.hvac_mode is HVACMode.HEAT
         assert entity.preset_mode is PRESET_BOOST
+        assert entity.window_auto_state == STATE_OFF
+
+        assert mock_set_hvac_mode.call_count == 1
+        assert round(entity.last_temperature_slope, 3) == -0.29
+        assert entity._window_auto_algo.is_window_open_detected() is False
+        assert entity._window_auto_algo.is_window_close_detected() is False
 
     # Clean the entity
     entity.remove_thermostat()
@@ -576,7 +599,7 @@ async def test_window_auto_no_on_percent(
             CONF_TEMP_MAX: 30,
             "eco_temp": 17,
             "comfort_temp": 18,
-            "boost_temp": 21,
+            "boost_temp": 20,
             CONF_USE_WINDOW_FEATURE: True,
             CONF_USE_MOTION_FEATURE: False,
             CONF_USE_POWER_FEATURE: False,
@@ -588,8 +611,8 @@ async def test_window_auto_no_on_percent(
             CONF_MINIMAL_ACTIVATION_DELAY: 30,
             CONF_SECURITY_DELAY_MIN: 5,
             CONF_SECURITY_MIN_ON_PERCENT: 0.3,
-            CONF_WINDOW_AUTO_OPEN_THRESHOLD: 0.1,
-            CONF_WINDOW_AUTO_CLOSE_THRESHOLD: 0.1,
+            CONF_WINDOW_AUTO_OPEN_THRESHOLD: 6,
+            CONF_WINDOW_AUTO_CLOSE_THRESHOLD: 6,
             CONF_WINDOW_AUTO_MAX_DURATION: 0,  # Should be 0 for test
         },
     )
@@ -610,10 +633,18 @@ async def test_window_auto_no_on_percent(
     assert entity.hvac_mode is HVACMode.HEAT
     assert entity.preset_mode is PRESET_BOOST
     assert entity.overpowering_state is None
-    assert entity.target_temperature == 21
+    assert entity.target_temperature == 20
 
     assert entity.window_state is STATE_OFF
 
+    # Initialize the slope algo with 2 measurements
+    event_timestamp = now + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 21, event_timestamp)
+    event_timestamp = event_timestamp + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 21, event_timestamp)
+    event_timestamp = event_timestamp + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 21, event_timestamp)
+
     # Make the temperature down
     with patch(
         "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
@@ -625,12 +656,12 @@ async def test_window_auto_no_on_percent(
         "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
         return_value=True,
     ):
-        event_timestamp = now - timedelta(minutes=4)
-        await send_temperature_change_event(entity, 21.5, event_timestamp)
+        event_timestamp = event_timestamp + timedelta(minutes=1)
+        await send_temperature_change_event(entity, 21, event_timestamp)
 
-        # The heater turns on
+        # The heater don't turns on
         assert mock_heater_on.call_count == 0
-        assert entity.last_temperature_slope is None
+        assert entity.last_temperature_slope == 0.0
         assert entity._window_auto_algo.is_window_open_detected() is False
         assert entity._window_auto_algo.is_window_close_detected() is False
         assert entity.hvac_mode is HVACMode.HEAT
@@ -647,16 +678,19 @@ async def test_window_auto_no_on_percent(
         "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
         return_value=True,
     ):
-        event_timestamp = now - timedelta(minutes=3)
+        event_timestamp = event_timestamp + timedelta(minutes=1)
         await send_temperature_change_event(entity, 20, event_timestamp)
 
         # The heater turns on but no alert because the heater was not heating
+        assert entity.proportional_algorithm.on_percent == 0.0
         assert mock_send_event.call_count == 0
-        assert mock_heater_on.call_count == 1
-        assert mock_heater_off.call_count == 0
-        assert entity.last_temperature_slope == -1.5
+        assert mock_heater_on.call_count == 0
+        assert mock_heater_off.call_count == 1
+        assert entity.last_temperature_slope == -6.24
+        # The algo calculate open ...
         assert entity._window_auto_algo.is_window_open_detected() is True
         assert entity._window_auto_algo.is_window_close_detected() is False
+        # But the entity is still on
         assert entity.window_auto_state == STATE_OFF
         assert entity.hvac_mode is HVACMode.HEAT
 
@@ -831,8 +865,8 @@ async def test_window_auto_bypass(hass: HomeAssistant, skip_hass_states_is_state
             CONF_MINIMAL_ACTIVATION_DELAY: 30,
             CONF_SECURITY_DELAY_MIN: 5,
             CONF_SECURITY_MIN_ON_PERCENT: 0.3,
-            CONF_WINDOW_AUTO_OPEN_THRESHOLD: 0.1,
-            CONF_WINDOW_AUTO_CLOSE_THRESHOLD: 0.1,
+            CONF_WINDOW_AUTO_OPEN_THRESHOLD: 6,
+            CONF_WINDOW_AUTO_CLOSE_THRESHOLD: 6,
             CONF_WINDOW_AUTO_MAX_DURATION: 0,  # Should be 0 for test
         },
     )
@@ -857,6 +891,14 @@ async def test_window_auto_bypass(hass: HomeAssistant, skip_hass_states_is_state
 
     assert entity.window_state is STATE_OFF
 
+    # Initialize the slope algo with 2 measurements
+    event_timestamp = now + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 19, event_timestamp)
+    event_timestamp = event_timestamp + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 19, event_timestamp)
+    event_timestamp = event_timestamp + timedelta(minutes=1)
+    await send_temperature_change_event(entity, 19, event_timestamp)
+
     # Make the temperature down
     with patch(
         "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
@@ -868,12 +910,12 @@ async def test_window_auto_bypass(hass: HomeAssistant, skip_hass_states_is_state
         "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
         return_value=True,
     ):
-        event_timestamp = now - timedelta(minutes=4)
+        event_timestamp = event_timestamp + timedelta(minutes=1)
         await send_temperature_change_event(entity, 19, event_timestamp)
 
         # The heater turns on
-        assert mock_heater_on.call_count == 1
-        assert entity.last_temperature_slope is None
+        assert entity.is_device_active is True
+        assert entity.last_temperature_slope == 0.0
         assert entity._window_auto_algo.is_window_open_detected() is False
         assert entity._window_auto_algo.is_window_close_detected() is False
         assert entity.hvac_mode is HVACMode.HEAT
@@ -881,7 +923,6 @@ async def test_window_auto_bypass(hass: HomeAssistant, skip_hass_states_is_state
     # send one degre down in one minute with window bypass on
     await entity.service_set_window_bypass_state(True)
     assert entity.window_bypass_state is True
-    # entity._window_bypass_state = True
 
     with patch(
         "custom_components.versatile_thermostat.base_thermostat.BaseThermostat.send_event"
@@ -893,7 +934,7 @@ async def test_window_auto_bypass(hass: HomeAssistant, skip_hass_states_is_state
         "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
         return_value=True,
     ):
-        event_timestamp = now - timedelta(minutes=3)
+        event_timestamp = event_timestamp + timedelta(minutes=1)
         await send_temperature_change_event(entity, 18, event_timestamp, sleep=False)
 
         # No change should have been done
@@ -901,7 +942,7 @@ async def test_window_auto_bypass(hass: HomeAssistant, skip_hass_states_is_state
 
         assert mock_heater_on.call_count == 0
         assert mock_heater_off.call_count == 0
-        assert entity.last_temperature_slope == -1
+        assert entity.last_temperature_slope == -6.24
         assert entity._window_auto_algo.is_window_open_detected() is True
         assert entity._window_auto_algo.is_window_close_detected() is False
         assert entity.window_auto_state == STATE_OFF