Home Assistant, gestion avancée du chauffage

Avoir un système domotique est avant tout un moyen de gérer de manière centralisée ses équipements de la maison. La majorité des débutants commencent par contrôler les lumières en mettant des temporisations ou bien des capteurs de présence ou d’ouverture.

Nous avons vu dans un précédent article : utiliser le thermostat générique d’Home Assistant, les bases pour la gestion d’un chauffage, il est temps de passer un cran au-dessus.

Cet article représente beaucoup de travail, je vais décrire les différentes étapes pour la mise en place d’un système complet de chauffage de la maison.

N’ayant pas encore ce qu’il faut pour domotiser l’ensemble de ma maison, j’ai fait les automatisations avec une seule pièce en anticipant au maximum mes futurs besoins.

Je mets l’ensemble des scripts nécessaires, en effet, beaucoup de sites n’ont pas mis l’intégralité de leur configuration.

J’ai trouvé pas mal de piste sur le site de My Canaletto.

Objectifs

Mon but était de réaliser un système me permettant :

  • gérer des absences prolongées de toutes les personnes ou bien de quelques une
  • avoir un fonctionnement manuel ou automatique
  • gérer différentes plages horaires en fonction des moments clés de la journée
  • pouvoir modifier les plages horaires
  • avoir différents modes de chauffage (éco, normal, confort)
  • pouvoir modifier les consignes de température de chaque mode

Les prérequis

Je sais que je me répète beaucoup, j’imagine que tu as une installation d’Home Assistant fonctionnelle sinon tu peux te rendre sur cet article : Installation d’Home Assistant.

Côté matériel, j’ai réutilisé un chauffage électrique (j’avoue, il y a mieux en terme de consommation) que j’ai branché sur une prise connecté, voici un lien pour l’acquérir : prise connectée.

Concernant le capteur de température, j’avais un capteur xiaomi.

Durant tout cette lecture, tu auras besoin de l’add-on File Editor, voir l’installation.

Pour la partie visuel, tu auras besoin d’avoir HACS, Installer HACS.

Préparation

Avant de commencer le gros du sujet, on va définir mes différents fichiers, voici mon fichier configuration.yaml :

automation: !include_dir_merge_list automation/

sensor: !include sensors.yaml

binary_sensor: !include binary_sensors.yaml

climate: !include_dir_merge_list climate/
# les entrées
input_boolean: !include input_booleans.yaml
input_number: !include input_numbers.yaml
input_select: !include input_selects.yaml
input_datetime: !include input_datetimes.yaml

Si dans le dossier config, tu n’as pas ces fichiers, commences par les créer.

Pour climate, j’ai créé un dossier climate puis y ait placé le fichier chauffage_parents.yaml.

Pour les automation, j’ai également créer un dossier automation et y ait créer 3 fichiers :

  • chauffage_absent.yaml
  • chauffage_parents.yaml
  • demarrage.yaml

Le thermostat générique

J’ai repris le thermostat que j’ai créé dans mon précédent article : Utiliser un thermostat générique d’Home Assistant.

Voici le contenu du fichier chauffage_parents.yaml (présent dans le dossier climate) :

# configuration du chauffage de la chambre des parents
- platform: generic_thermostat
  name: chauffage_parents
  heater: switch.prise_chauffage_parent_on_off
  target_sensor: sensor.tz3000_i8jfiezr_ts0201_9ff5c019_temperature
  min_temp: 16
  max_temp: 22
  ac_mode: false
  target_temp: 18
  cold_tolerance: 0
  hot_tolerance: 0
  initial_hvac_mode: "off"
  away_temp: 16
  precision: 0.1
  min_cycle_duration:
    seconds: 5
  keep_alive:
    minutes: 3

Je n’irai pas plus loin, si besoin, relis l’article précédent.

Les plages horaires

Commençons par les plages horaires, j’ai choisi de découper ma journée en 4 parties :

  • le levée car madame (ma dame) ne souhaite pas avoir froid en sorti du lit => mode confort
  • la journée, de manière générale, nous sommes actifs ou peu présent, le but est de maintenir une température agréable => mode normal
  • la soirée, en rentrant du boulot ou d’une sortie, il est agréable de retrouver un cocon chaud et douillé => mode confort
  • la nuit, la température n’a pas besoin d’être élevée, un petit 16°C lorsque l’on dort est tout à fait agréable => mode eco

Pour la gestion de ses plages, j’ai choisi de créer une variable binaire que je pourrais ré-utiliser facilement sans alourdir mes automatisations.

En premier lieu, on définit les différentes heures en tant que input_datetime dans le fichier input_datetimes.yaml :

# réglage des heures de la journée par défaut au démarrage
heure_chauffage_debut_levee:
  has_date: false
  has_time: true
  initial: '06:00'
heure_chauffage_fin_levee: # est aussi l'heure de début de journée
  has_date: false
  has_time: true
  initial: '08:30'
heure_chauffage_fin_journee: # est aussi l'heure de début de soirée
  has_date: false
  has_time: true
  initial: '17:30'
heure_chauffage_fin_soiree: # est aussi l'heure de début de nuit
  has_date: false
  has_time: true
  initial: '22:00'

J’ai définit seulement 4 variables, une heure de fin de période correspondant au début de la période suivante. Cela permettra d’éviter que des plages se superposent ou bien des trous dans la journée.

Pour les variables binaire représentant chaque période, je crée donc 4 sensors voici le fichier binary_sensors.yaml :

# sensor pour la gestion de l'heure du thermostat
- platform: template
  sensors:
    chauffage_moment_levee:
      friendly_name: "Chauffage moment du levée"
      value_template: >
        {% if states.sensor.time.state > states.input_datetime.heure_chauffage_debut_levee.state %}
          {% if states.sensor.time.state < states.input_datetime.heure_chauffage_fin_levee.state %}
            on
          {% else %}
            off
          {% endif %}
        {% else %}
          off
        {% endif %}
- platform: template
  sensors:
    chauffage_moment_journee:
      friendly_name: "Chauffage moment du la journée"
      value_template: >
        {% if states.sensor.time.state > states.input_datetime.heure_chauffage_fin_levee.state %}
          {% if states.sensor.time.state < states.input_datetime.heure_chauffage_fin_journee.state %}
            on
          {% else %}
            off
          {% endif %}
        {% else %}
          off
        {% endif %}
- platform: template
  sensors:
    chauffage_moment_soiree:
      friendly_name: "Chauffage moment de la soiree"
      value_template: >
        {% if states.sensor.time.state > states.input_datetime.heure_chauffage_fin_journee.state %}
          {% if states.sensor.time.state < states.input_datetime.heure_chauffage_fin_soiree.state %}
            on
          {% else %}
            off
          {% endif %}
        {% else %}
          off
        {% endif %}
- platform: template
  sensors:
    chauffage_moment_nuit:
      friendly_name: "Chauffage moment de la nuit"
      value_template: >
        {% if( states.sensor.time.state > states.input_datetime.heure_chauffage_fin_soiree.state and states.sensor.time.state < '23:59:59') or ( states.sensor.time.state > '00:00:00' and states.sensor.time.state < states.input_datetime.heure_chauffage_debut_levee.state ) %}
            on
        {% else %}
          off
        {% endif %}
  

Ici, j’utilise mes variables datetime, représentant mes débuts et fins de plage.

Pour finir avec les heures, dans le fichier sensors.yaml, écrire :

# utiliser pour la gestion du temps
- platform: time_date
  display_options:
  - 'time'
  - 'date'
  - 'date_time'
  - 'date_time_utc'
  - 'date_time_iso'
  - 'time_date'
  - 'time_utc'
  - 'beat'
  

J’avoue ne pas savoir pourquoi on doit l’écrire mais il le faut (désolé, pas d’explication).

Les consignes de température

Nous allons créer nos 3 consignes de température pour nos plages (eco, confort et normal), ce sont des nombres, voici le fichier input_numbers.yaml :

# Réglage des consignes de température par défaut au démarrage
consigne_confort:
  name: 'Température de confort'
  initial: 20
  min: 15
  max: 25
  step: 0.1
  unit_of_measurement: °C
  
consigne_normal:
  name: 'Température normale'
  initial: 19
  min: 15
  max: 25
  step: 0.1
  unit_of_measurement: °C

consigne_eco:
  name: 'Température économique'
  initial: 16
  min: 15
  max: 25
  step: 0.1
  unit_of_measurement: °C

Le nommage que j’ai choisi est important, il sera réutilisé dans mes automatisations.

Les modes de chauffage

Pour les 3 modes de chauffage :

  • eco
  • normal
  • confort

J’ai choisi d’utiliser un select, je l’ai définit dans le fichier input_selects.yaml :

# Les différents modes de chauffage
mode_chauffage:
  name: "Mode de chauffage"
  options:
    - eco
    - normal
    - confort
  initial: eco

Pareil que précédemment, le nommage est important, chaque nom est identique à la fin du nom de la consigne.

Mode de fonctionnent

Pour pouvoir choisir entre le mode de fonctionnement auto ou manuel, nous allons utiliser des booléens, voici le fichier input_booleans.yaml :

# entrée pour le choix de mode  
chauffage_auto:
  name: "Mode de chauffage auto"
  initial: false

chauffage_manuel:
  name: "Mode de chauffage manuel"
  initial: false

Au démarrage, les deux modes sont éteints.

Les absences

Pour représenter les absences, toujours dans le fichier input_booleans.yaml, nous allons ajouter :

# Présence des personnes
vacances:
  name: Vacances
  icon: mdi:airplane
  
absence_parents:
  name: "Absence des parents"
  icon: mdi:human-male-female
  
absence_noemie:
  name: "Absence de Noémie"
  icon: mdi:face-woman
  
absence_raphael:
  name: "Absence de Raphael"
  icon: mdi:face-man

L’entrée Vacances signifie que tous le monde est absent.

Automatisation pour la gestion de la présence

Maintenant que toutes nos entités sont créées, attaquons la gestion de la présence, dans le fichier chauffage_absent.yaml :

# met tous les personnes absentes
- alias: chauffage_maison_vacances_depart
  trigger:
    - platform: state
      entity_id: input_boolean.vacances
      from: "off"
      to: "on"
  action:
    - service: input_boolean.turn_on
      target:
        entity_id:
          - input_boolean.absence_parents
          - input_boolean.absence_noemie
          - input_boolean.absence_raphael

# Met toutes les personnes présentes
- alias: chauffage_maison_vacances_retour
  trigger:
    - platform: state
      entity_id: input_boolean.vacances
      from: "on"
      to: "off"
  action:
    - service: input_boolean.turn_off
      target:
        entity_id:
          - input_boolean.absence_parents
          - input_boolean.absence_noemie
          - input_boolean.absence_raphael

# mets les parents absents
- alias: chauffage_absence_parent
  trigger:
    - platform: state
      entity_id: input_boolean.absence_parents
      from: "off"
      to: "on"
  action:
    - service: input_boolean.turn_off
      target:
        entity_id:
          - input_boolean.chauffage_auto
          - input_boolean.chauffage_manuel

# Empêche la mise "on" du mode auto et manu, les replace en off
- alias: chauffage_annulation
  trigger:
    - platform: state
      entity_id: input_boolean.chauffage_manuel
      from: "off"
      to: "on"
    - platform: state
      entity_id: input_boolean.chauffage_auto
      from: "off"
      to: "on"
  condition:
    - condition: or
      conditions:
      - condition: state
        entity_id: input_boolean.absence_parents
        state: "on"
      - condition: state
        entity_id: input_boolean.vacances
        state: "on"
  action:
    - service: input_boolean.turn_off
      target:
        entity_id:
          - input_boolean.chauffage_auto
          - input_boolean.chauffage_manuel
      
      

Les 3 premières automations permettent de mettre à jour le statut de moi et ma femme et des enfants que ce soit pour le départ ou le retour.

La dernière automatisation permet d’éviter la mise en route du chauffage (quelque-soit le mode fonctionnement) en cas d’absence.

Au démarrage de Home Assistant

En cas de reboot du système, je réinitialise mon chauffage qui est un chauffage électrique branché sur une prise connectée. Voici le fichier demarrage.yaml :

- alias: "Démarrage d'Home Assistant"
  trigger:
    - platform: homeassistant
      event: start
  action:
    # éteint le chauffage si celui-ci est activé au démarrage
    - service: switch.turn_off
      entity_id: switch.prise_chauffage_parent_on_off

La gestion du chauffage

Voici la plus grosse partie de cet article, tout ce qui suit se trouve dans le fichier chauffage_parents.yaml présent dans le dossier automation. Nous utiliserons les fonctions de climate.

Choix du mode de chauffage

Afin de choisir le mode de chauffage (eco, normal et confort), celui-ci ne fonctionne que si le mode de fonctionnement manuel est en cours d’utilisation :

# Modification du mode de chauffage en manuel quand celui-ci est activé
- alias: chauffage_parent_modification_mode
  trigger:
     - platform: state
       entity_id: input_select.mode_chauffage
  condition:
    - condition: state
      entity_id: input_boolean.chauffage_manuel
      state: "on"
  action:
    - service: climate.set_temperature
      data_template:
        entity_id: climate.chauffage_parents
        temperature: "{{ states('input_number.consigne_'+ states('input_select.mode_chauffage')) | float }}"

Si nous sommes en fonctionnement manuel, la consigne de température est modifiée. Sinon, le mode est préselectionné.

C’est ici que le nommage des variables a son important, la température est modifiée en prenant l’état de la consigne en fonction du mode choisi.

Modification de la consigne de température manuellement

Les trois mode de fonctionnement peuvent ne pas correspondre à un besoin ponctuelle, il est possible de modifier la température de consigne de chaque mode :

# Modifie la consigne de la température eco quand le mode manuel est activé en mode éco
- alias: chauffage_parent_eco
  trigger:
    - platform: state
      entity_id: input_number.consigne_eco
  condition:
  - condition: or
    conditions:
      - condition: and
        conditions:
          - condition: state
            entity_id: input_select.mode_chauffage
            state: "eco"
          - condition: state
            entity_id: input_boolean.chauffage_manuel
            state: "on"
      - condition: and
        conditions:
          - condition: state
            entity_id: input_boolean.chauffage_auto
            state: "on"
          - condition: state
            entity_id: binary_sensor.chauffage_moment_nuit
            state: 'on'
  action:
    - service: climate.set_temperature
      data_template:
        entity_id: climate.chauffage_parents
        temperature: "{{ states('input_number.consigne_eco') | float }}"

# Modifie la consigne de la température confort quand le mode manuel ou auto est activé en mode confort
- alias: chauffage_parent_confort
  trigger:
    - platform: state
      entity_id: input_number.consigne_confort
  condition:
  - condition: or
    conditions:
      - condition: and
        conditions:
          - condition: state
            entity_id: input_select.mode_chauffage
            state: "confort"
          - condition: state
            entity_id: input_boolean.chauffage_manuel
            state: "on"
      - condition: and
        conditions:
          - condition: state
            entity_id: input_boolean.chauffage_auto
            state: "on"
          - condition: or
            conditions:
              - condition: state
                entity_id: binary_sensor.chauffage_moment_soiree
                state: 'on'
              - condition: state
                entity_id: binary_sensor.chauffage_moment_levee
                state: 'on'
  action:
    - service: climate.set_temperature
      data_template:
        entity_id: climate.chauffage_parents
        temperature: "{{ states('input_number.consigne_confort') | float }}"

# Modifie la consigne de la température normal quand le mode manuel ou auto est activé en mode normal
- alias: chauffage_parent_normal
  trigger:
    - platform: state
      entity_id: input_number.consigne_normal
  condition:
  - condition: or
    conditions:
      - condition: and
        conditions:
          - condition: state
            entity_id: input_select.mode_chauffage
            state: "normal"
          - condition: state
            entity_id: input_boolean.chauffage_manuel
            state: "on"
      - condition: and
        conditions:
          - condition: state
            entity_id: input_boolean.chauffage_auto
            state: "on"
          - condition: state
            entity_id: binary_sensor.chauffage_moment_journee
            state: 'on'
  action:
    - service: climate.set_temperature
      data_template:
        entity_id: climate.chauffage_parents
        temperature: "{{ states('input_number.consigne_normal') | float }}"

Nous mettons à jours la température de consigne du thermostat seulement si le mode en cours correspond.

Nous pouvons mettre à jour les autres modes mais les consignes seront prises seulement au redémarrage du mode.

Il s’agit d’un gros pavé mais dans chaque automatisation, une seule condition change. Je verrai pour simplifier ce bout de code avec un template.

Démarrage du mode auto

Voici l’automation correspondante :

# démarre le chauffage en auto si présence des parents, le mode est pris en fonction de l'heure
- alias: chauffage_parent_auto_start
  trigger:
    - platform: state
      entity_id: input_boolean.chauffage_auto
      from: "off"
      to: "on"
  condition:
    - condition: state
      entity_id: input_boolean.absence_parents
      state: "off"
  action:
    - service: input_boolean.turn_off
      target: 
        entity_id: input_boolean.chauffage_manuel
    - service: climate.set_temperature
      data_template:
        entity_id: climate.chauffage_parents
        temperature: >
          {% if states.binary_sensor.chauffage_moment_levee.state == 'on' %}
            {{ states.input_number.consigne_confort.state | float }}
          {% elif states.binary_sensor.chauffage_moment_journee.state == 'on' %}
            {{ states.input_number.consigne_normal.state | float }}
          {% elif states.binary_sensor.chauffage_moment_soiree.state == 'on' %}
            {{ states.input_number.consigne_confort.state | float }}
          {% else %}
            {{ states.input_number.consigne_eco.state | float }}
          {% endif %}
    - service: climate.turn_on
      target:
        entity_id: climate.chauffage_parents

A la sélection du mode auto, on vient vérifier si aucune absence est en cours, les parents vu que c’est notre chambre. Lorsque le mode vacance est activé, les parents sont mis en absence également.

Si la condition est respectée, on commence par éteindre le mode de chauffage manuel. Ensuite on récupère la consigne de température correspondant à la plage horaire.

On finit par allumer le chauffage.

Modification de la consigne en mode auto

Maintenant que notre chauffage a bien démarré en mode auto, il faut lui faire modifier sa consigne en fonction du moment de la journée :

# Modification de la consigne en fonction de l'heure
- alias: chauffage_modification_consigne_auto
  trigger:
    - platform: state
      entity_id: binary_sensor.chauffage_moment_levee
      from: "off"
      to: "on"
    - platform: state
      entity_id: binary_sensor.chauffage_moment_journee
      from: "off"
      to: "on"
    - platform: state
      entity_id: binary_sensor.chauffage_moment_soiree
      from: "off"
      to: "on"
    - platform: state
      entity_id: binary_sensor.chauffage_moment_nuit
      from: "off"
      to: "on"
  condition:
    - condition: state
      entity_id: input_boolean.chauffage_auto
      state: "on"
  action:
    - service: climate.set_temperature
      data_template:
        entity_id: climate.chauffage_parents
        temperature: >
          {% if states.binary_sensor.chauffage_moment_levee.state == 'on' %}
            {{ states.input_number.consigne_confort.state | float }}
          {% elif states.binary_sensor.chauffage_moment_journee.state == 'on' %}
            {{ states.input_number.consigne_normal.state | float }}
          {% elif states.binary_sensor.chauffage_moment_soiree.state == 'on' %}
            {{ states.input_number.consigne_confort.state | float }}
          {% else %}
            {{ states.input_number.consigne_eco.state | float }}
          {% endif %}

Lorsque que le moment de la journée change (en fonction de l’état des capteurs binaires créés), nous modifions la consigne en prenant celle correspondant au mode de fonctionnement :

  • eco pour la nuit
  • normal pour la journée
  • confort pour le levée et la soirée

Démarrage du mode manuel

Pour ce qui est du mode manuel, voici son script :

# démarre le chauffage manuel si les parents sont présent en fonction du mode de chauffage choisi (eco, normal, confort)
- alias: chauffage_parent_manuel_start
  trigger:
    - platform: state
      entity_id: input_boolean.chauffage_manuel
      from: "off"
      to: "on"
  condition:
    - condition: state
      entity_id: input_boolean.absence_parents
      state: "off"
  action:
    - service: input_boolean.turn_off
      target: 
        entity_id: input_boolean.chauffage_auto
    - service: climate.set_temperature
      data_template:
        entity_id: climate.chauffage_parents
        temperature: "{{ states('input_number.consigne_'+ states('input_select.mode_chauffage')) | float }}"
    - service: climate.turn_on
      target:
        entity_id: climate.chauffage_parents

A la mise en route du mode manuel, si il n’y pas pas d’absence des parents, on commence par éteindre le mode auto.

On récupère la température de consigne correspondante au mode de chauffage sélectionné et on démarre le chauffage.

Les arrêts de fonctionnement

Voilà les deux automations pour l’arrêt du chauffage (mode auto et manuel) :

# stoppe le chauffage manuel
- alias: chauffage_parent_manuel_stop
  trigger:
    - platform: state
      entity_id: input_boolean.chauffage_manuel
      from: "on"
      to: "off"
  action:
    - service: climate.turn_off
      target:
        entity_id: climate.chauffage_parents

# stop le chauffage en mode auto
- alias: chauffage_parent_auto_stop
  trigger:
    - platform: state
      entity_id: input_boolean.chauffage_auto
      from: "on"
      to: "off"
  action:
    - service: climate.turn_off
      target:
        entity_id: climate.chauffage_parents

A présent, toutes nos automatisations fonctionnent.

Le tableau de bord

Commencer par installer le plugin Multiple Entity Row, cela permettra de mettre sur une même ligne plusieurs entités, notamment les heures pour les plages horaires. Rends toi dans HACS puis Frontend, recherches et installes Multiple Entity Row :

Gestion de la présence

Créer une première carte en allant sur ton tableau de bord, puis modifier et ajouter une carte manuelle, en mode YAML, ajoutes :

type: entities
entities:
  - entity: input_boolean.vacances
  - entity: input_boolean.absence_parents
  - entity: input_boolean.absence_noemie
  - entity: input_boolean.absence_raphael
state_color: true

Pour bien comprendre où mettre le script (méthode utilisée pour tous les autres visuels), voici une capture :

Visualisation de l’état du thermostat

On ajoute une seconde carte permettant de voir l’état du thermostat ainsi que la température de consigne et la température mesurée mais aussi le statut du chauffage (dans mon cas la prise) :

type: entities
entities:
  - entity: climate.chauffage_parents
  - entity: switch.prise_chauffage_parent_on_off
state_color: true

Ce que cela donne :

Carte des réglages du chauffage

C’est ici que l’add-on Multiple Entity Row est utilisé (sur les plages horaires) :

type: entities
title: Réglages chauffage
state_color: true
entities:
  - entity: input_boolean.chauffage_auto
    name: Chauffage automatique
  - type: section
  - entity: input_boolean.chauffage_manuel
    name: Chauffage manuel
  - entity: input_select.mode_chauffage
    name: Mode de chauffage Manuel
  - type: section
  - entity: input_datetime.heure_chauffage_debut_levee
    type: custom:multiple-entity-row
    name: Levée (confort)
    show_state: false
    entities:
      - entity: input_datetime.heure_chauffage_debut_levee
        name: Début
      - entity: input_datetime.heure_chauffage_fin_levee
        name: Fin
  - entity: input_datetime.heure_chauffage_debut_levee
    type: custom:multiple-entity-row
    name: Journée (normal)
    show_state: false
    entities:
      - entity: input_datetime.heure_chauffage_fin_levee
        name: Début
      - entity: input_datetime.heure_chauffage_fin_journee
        name: Fin
  - entity: input_datetime.heure_chauffage_debut_levee
    type: custom:multiple-entity-row
    name: Soirée (confort)
    show_state: false
    entities:
      - entity: input_datetime.heure_chauffage_fin_journee
        name: Début
      - entity: input_datetime.heure_chauffage_fin_soiree
        name: Fin
  - entity: input_datetime.heure_chauffage_debut_levee
    type: custom:multiple-entity-row
    name: Nuit (eco)
    show_state: false
    entities:
      - entity: input_datetime.heure_chauffage_fin_soiree
        name: Début
      - entity: input_datetime.heure_chauffage_debut_levee
        name: Fin
  - type: section
  - entity: input_number.consigne_confort
  - entity: input_number.consigne_normal
  - entity: input_number.consigne_eco
show_header_toggle: false

Voici le rendu :

Bien entendu, libre à toi d’imaginer ton propre tableau de bord.

Les futures pistes d’amélioration

N’ayant pas de thermomètre extérieur, je n’ai pas pu ajouter une condition au démarrage du chauffage en mode automatique en fonction de la température extérieure (avec un bouton pour activer ou désactiver cette option).

Toujours à cause du même manque de matériel, il peut être utile de désactiver le chauffage si une fenêtre ou une porte est ouverte.

Il est également possible de gérer la ventilation en fonction de l’humidité (avec une VMC par exemple).

Dans mon automatisation, j’ai quelques améliorations à faire, notamment pour éviter de répéter le choix des consignes en créant un sensor que j’appelera à la place :

{% if states.binary_sensor.chauffage_moment_levee.state == 'on' %}
  {{ states.input_number.consigne_confort.state | float }}
{% elif states.binary_sensor.chauffage_moment_journee.state == 'on' %}
  {{ states.input_number.consigne_normal.state | float }}
{% elif states.binary_sensor.chauffage_moment_soiree.state == 'on' %}
  {{ states.input_number.consigne_confort.state | float }}
{% else %}
  {{ states.input_number.consigne_eco.state | float }}
{% endif %}

Ce sont des points que je mettrai en place dans un second temps.

Je mettrai à jour cet article au fur et à mesure que je rajouterai les chauffages dans les 2 autres chambres.

Conclusion

Voilà qui est fait, tu es arrivé au bout et j’espère que j’ai pu répondre à un maximum de tes interrogations, j’ai passé beaucoup de temps à mettre en place cette automatisation, internet contenant que des bribes d’éléments.

N’hésites pas à me faire part de tes commentaires.

Un commentaire :

  1. Bonjour,

    Merci beaucoup pour ce travail complet ! Je débute et je suis en train de m’équiper (je vais essayer d’utiliser le fil pilote avec des switch zigbee et une diode, sur 2 ordres), je pense que je vais utiliser votre travail en référence, c’est exactement ce que je chercher à réaliser avec Home Assistant. »

    A bientôt,

    FX de Rennes

Laisser un commentaire

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.