Wake up Time ! (et bonne année)
Niveau: pas si difficile… version beta à rendre plus facile
Bonjour 
Je me lance pour partager une première version tout juste fonctionnelle de calcul de l’heure de relance du chauffage… (une autre approche, et surtout une méthode simple pour déterminer les coef, de ce qu’on trouve par ailleurs dans les régulations comme celle très complète de jmcollin avec le détail [ici])
1. Pourquoi faire ça ?
2. La formule mathématique pour les curieux
3. [ÉTAPE 1] Déterminer 2 constantes qui caractérisent ma pièce (procédure à la mano)
4. [ÉTAPE 2] pack variables + script
5. [ÉTAPE 3] utilisation et config dans mes automatisations
1. Objectif… Pour qui ? Pourquoi allumer le chauffage avant de se réveiller le matin ?
confort + économie & simplicité maximum dans le paramétrage (mais précis)
L’inertie thermique (épaisseur des murs, radiateurs à inertie sèche, panneaux rayonnants, etc.) c’est bien pour le confort (chaleur douce), mais le matin le temps que le chauffage se mette en route, je suis déjà parti au boulot, et en heures creuses de nuit c’est plus économique…
Bref, le problème ici c’est d’allumer le chauffage ni trop tôt, ni trop tard, et que ça dépend essentiellement de 2 variables qui changent tous les jours:
- la température intérieure
Tint(°C) - la température extérieure
Text(°C)
Et d’un objectif fixé :
Tsp(set point) ou température de consigne qu’on souhaite au petit-déj !
Voici un exemple concret avec mes température d’une nuit de ce mois de décembre… L’augmentation/diminution de Tint n’est évidemment pas linéaire (mais c’est classique, ce qui est rassurant).
Mon calcul approximatif m’a dit de relancer le chauffage entre 3 et 4h (ma formule n’était pas encore bien calée), et il faut un peu du temps pour que la température augmente (c’est l’inertie thermique de la pièce en plus des déperditions)
Pour ceux qui n’ont pas d’inertie (ex: ventilo-convecteur et logement bien isolé par l’intérieur), ce tuto est inutile, car quelques minutes de chauffage suffisent (et il vaut mieux regarder du côté PID et autres thermostats intelligents ailleurs sur le forum).
2. Trouver le temps nécessaire pour atteindre Tsp le plus simplement possible
Il y a plusieurs paramètres qu’on peut simplifier au maximum en 2 paramètres à déterminer :
RCth: combinaison de l’isolation & inertie thermique effectiveRPth: combinaison de l’isolation et de la puissance de chauffage effective
L’équation est plutôt simple à mettre dans une automatisation (voir la suite) :
Pour les curieux, comment trouver cette formule plus de détails ici
La puissance de chauffage compense les pertes et l’augmentation nécessaire de température :
En supposant que Text est à peu près constant (sinon on prend la moyenne en approximation)
On isole les variations dTint et dt
Et on intègre en Tint,init et Tsp pour la température, et 0 et t pour le temps:
ce qui donne la formule précédente…
3 → ÉTAPE 1. Avant le programme dans HA…
Comment trouver mes deux paramètres
RCthetRPthle plus simplement possible ? A priori ça peut se faire tout seul dans HA (automatisation en cours), mais en attendant une automatisation complète il faut faire les 2 petites manips suivantes…
ÉTAPE 1a
RCthà partir de seulement 3 valeurs de températures par nuit calme
L’idéal c’est de regarder dans l’historique plusieurs nuits les plus froides possibles (écarts de température importants plus défavorables et descente importantes de températures) et de noter :
- la durée, je prend par exemple une durée de
3h(de minuit à 3h du matin - dans les faits il vaut mieux prendre plus longtemps si possible) Texten moyenne entre minuit et 3hTint(0h)Tint(3h)
Et comme le chauffage est éteint, le terme RPth précédent est nul
(prendre une heure de début de période un peu après l’extinction des radiateurs), et donc :
Pour ce calcul (version beta 
)… à vous de faire une feuille EXCEL, en attendant mieux…
Et le vent ?
en fonction des infiltrations d’air du logement, le vent peut avoir de l’influence → RCth diminue quand la vitesse du vent WIND augmente
sujet traité à la suite (et dans un premier temps prendre des nuits sans trop de vent… ou avec beaucoup si on veut le cas vraiment défavorable mais exceptionnel)
automatisation >> en cours
TODO: faire une belle automatisation qui fasse ça tout seul - je n’ai pas trouvé de moyen simple d’extraire une valeur historique de température à une heure donnée
→ en expérimentation
ÉTAPE 1b
RPthla même nuit à la relance du chauffage → comme en 1a, à partir de seulement 3 valeurs de températures par nuit calme…
Par exemple on relance le chauffage à 3h du matin et on note les 3 valeurs de températures :
Tint(3h)la température intérieure au démarrage (ici à 3h du matin)Tint(6h)la température intérieure à la fin de la période de 3h (ici à 6h du matin)Texten moyenne entre 3h et 6h
Et grâce à la valeur deRCthtrouvée juste avant on obtientRPth:
Démonstration pour les curieux
D’après l’équation du temps déterminée en (2.) pour chauffer de Tint(3h) à Tint(6h) en 3 h de temps:
Donc
d’où la formule ci-dessus.
4. → ÉTAPE 2
le plus dur est passé…
Il faut définir dans HA au préalable :
- un input datetime
heure_relance_chauffage(le script va calculer sa valeur) → pour ça on suit dans l’interfaceparamètres >> appareils et services >> onglet Entrées >> bouton + Créer une entrée - format Heure (pas Date, ni Date et Heure) - Ajouter le package ci-dessous dans un fichier que j’appelle ici
thermal_recovery_time.yaml:- à placer dans son dossier package en suivant le très bon tuto ici pour que tout soit opérationnel au redémarrage de home assistant,
- et sans oublier de remplacer
sensor.salon_temperaturepar votre propre sensor de température intérieure dans le script
thermal_recovery_time.yaml
input_datetime:
target_hour:
name: Wake Up Time (heure de lever)
has_date: false
has_time: true
recoverycalc_hour:
name: Recovery calculation hour (e.g. 1AM)
has_date: false
has_time: true
input_number:
rcth:
name: Coefficient RCth
min: 0
max: 1000
step: 0.1
unit_of_measurement: "h"
rpth:
name: Coefficient RPth
min: -100
max: 100
step: 0.1
unit_of_measurement: "°C"
tsp:
name: Consigne (Set Point)
min: 13
max: 26
step: 0.1
unit_of_measurement: "°C"
template:
- sensor:
- name: "RCth"
state: "{{ states('input_number.rcth') }}"
unit_of_measurement: "h"
- name: "RPth"
state: "{{ states('input_number.rpth') }}"
unit_of_measurement: "°C"
- name: "RCth_calculated"
state: "{{ states('input_number.rcth') }}"
unit_of_measurement: "h"
- name: "RPth_calculated"
state: "{{ states('input_number.rpth') }}"
unit_of_measurement: "°C"
- name: "Tsp"
state: "{{ states('input_number.tsp') }}"
unit_of_measurement: "°C"
- name: "exterior_temperature"
state: >
{% set weather_entities = states.weather | selectattr('attributes.temperature', 'defined') | list %}
{% if weather_entities | length > 0 %}
{{ weather_entities[0].attributes.temperature }}
{% else %}
N/A
{% endif %}
unit_of_measurement: "°C"
script:
calculate_recovery_time:
alias: calcul relance radiateur
sequence:
- variables:
heure_relance_chauffage: >-
{% set text = states('sensor.exterior_temperature')|float %}
{% set tint = states('sensor.salon_temperature')|float %} {# REMPLACER PAR VOTRE SENSOR #}
{% set tsp = states('input_number.tsp')|float %}
{% set rcth = states('input_number.rcth')|float %}
{% set rpth = states('input_number.rpth')|float %}
{% set target_hour = states.input_datetime.target_hour.attributes.hour %}
{% set target_minute = states.input_datetime.target_hour.attributes.minute %}
{% set target_time = now().replace(hour=target_hour, minute=target_minute, second=0, microsecond=0) %}
{# Calcul de l'heure cible en s'assurant qu'elle est dans le futur #}
{% if target_time < now() %}
{% set target_time = target_time + timedelta(days=1) %}
{% endif %}
{% set time_remaining = (target_time - now()).total_seconds() / 3600 %}
{% set max_duration = max((time_remaining - 1/6), 0) %}
{% set duree_relance = min(max(rcth*log(max((rpth+text-tint)/(rpth+text-tsp),0.1)),0),max_duration) %}
{# (Prédiction itérative de la température de début de relance et recalcul de la duree de relance) x 4 #}
{% for i in range(20) %}
{% set tint_start = text+(tint-text)/e**((time_remaining-duree_relance)/rcth) %}
{% set duree_relance = min(max(rcth*log(max((rpth+text-tint_start)/(rpth+text-tsp),0.1)),0),max_duration) %}
{% endfor %}
{% set seconds = (duree_relance*3600)| int %}
{% set time = target_time - timedelta(seconds=seconds) %}
{{ time.strftime('%H:%M:%S') }}
- metadata: {}
data:
datetime: "{{ now().strftime('%Y-%m-%d ') + heure_relance_chauffage }}"
target:
entity_id: input_datetime.heure_relance_chauffage
action: input_datetime.set_datetime
mode: single
icon: mdi:hours-24
5. → ÉTAPE 3 (utilisation)
Un petit dashboard pour configurer et tester le script :
On peut changer les valeurs cibles et lancer le calcul pour voir à quelle heure il faudrait relancer le chauffage (avec 4h max de temps de relance dans cette version).
Code du dashboard
type: grid
cards:
- type: heading
heading: PARAMETERS (input)
heading_style: title
badges: []
- type: tile
entity: input_datetime.target_hour
- type: tile
entity: input_number.tsp
- type: custom:mushroom-number-card
entity: input_number.rpth
display_mode: buttons
name: RPth
- type: custom:mushroom-number-card
entity: input_number.rcth
display_mode: buttons
name: RCth
- type: tile
entity: sensor.rpth
- type: tile
entity: sensor.rcth
- type: tile
grid_options:
columns: 12
rows: 1
entity: script.calcul_relance_radiateur
- type: tile
entity: input_datetime.heure_relance_chauffage
- type: tile
entity: sensor.heure_relance_chauffage_value
Automatiser le tout
Il suffit de créer 2 automatisations :
- l’une à heure fixe la nuit (je prends 1h25), pour calculer l’heure de relance
par ex
- l’autre pour lancer le chauffage quand on atteint l’heure de relance
par ex avec mes Nodon fil pilotes
TODO List
- [EN COURS] automatiser et actualiser au fil de l’eau le calcul des constantes en vérifiant les valeurs aberrantes
- [EN COURS] recalcul de l’heure prévue en « permanence » (au tiers du temps restant) avant la relance (
calculer en permanence la température minimale intérieure en période d’absence, en fonction du temps restant avant le retour, et avec donc aucun ralenti à part le hors-gel. Les ralentis consomment sans intérêt quand on a une relance intelligente…) - [EN COURS] ajouter l’effet du vent (cf. détails réponse suivante)
- [EN COURS] apprentissage auto et relaxation
- [+TARD] optimiser les temps de relance en fonction des heures creuses (coût des relances), surtout après une période de vacances et une chute importante de température intérieure
- [+ TARD] prise en compte de l’ensoleillement (combiné à la gestion des stores) pour la relance de jour
- [++ TARD] anticiper sur la température extérieure en prenant les valeurs à venir à partir de la météo (utile pour les matins très froids avec de fortes chutes de température)
- [++ TARD] Mettre toutes les variables dans un template pour pouvoir générer plusieurs zones avec chacune son jeu de param.
UPDATE 2025-03jan
- AJOUT: calcul automatique de la prédiction de température de début de relance en supposant que le chauffage est éteint à ce moment-là (température en décroissance, usage normal du lancement du calcul de la relance)
- AJOUT: ajout automatique du sensor température extérieure de la météo HA
- EN COURS: calculs automatiques des paramètres RCth et RPth pour chaque relance (chaque jour) → opérationnel et en cours d’expérimentation chez moi, et update à prévoir si (… le temps le permet, les gens sont intéressés, etc.)
UPDATE 2025-02jan
- AJOUT: calcul automatique du temps maximum de relance disponible (pas limité à 4h) en considérant l’heure cible comme le lendemain si passée (p. ex. si on lance le calcul à 22h pour une cible à 6h du matin, 8h max de temps de relance)
- FIXED: correction de bugs sur les valeurs temps calculées
)
)
).