Home Assistant & Planification, Schedy, la suite !

Encore, allez vous me dire ! Oui car d'une part mon dernier article sur Schedy était un peu fouillis, et surtout en relisant les réponses de son auteur à ceux qui tentent de créer une interface, je me suis aperçu que l'approche que j'avais, qui consistait à faire passer à Schedy des plages horaires, n'était pas la plus simple ni la plus adaptée. D'une part il faut transformer des input_time en sensor ou en input_number (les deux seules possibilité pour transmettre à Schedy un horaire de début et de fin de plage sous la forme du nombre de minutes écoulées depuis minuit). C'est lié à son fonctionnement interne, ce n'est pas très pratique. Son auteur n'a pas le temps de faire évoluer, et surtout c'est un barbu qui déteste les interfaces graphiques...

J'ai donc opté pour une autre approche plus simple et plus concise qui va consister à se servir des input_datetime: de début et de fin de plage pour actionner un binary_sensor: qui passera à ON si on se trouve dans la plage.

A partir de là dans Schedy, on change la température de consigne (input_number:) de la la plage, si la plage est activée (input_boolean:) et la période active (binary_sensor:).

Et bien sur on le fait en fonction des contraintes que l'on s'impose en fonction de la situation de chacun (jour de travail, demie journée de travail, week-end ou télétravail), et tout ça pour chacune des pièces que l'on gère auxquelles correspond un thermostat (climate:) ou un groupe de thermostats.

De cette façon on continue à faire une gestion horaire qui correspondra à la majorité des usages, mais avec ce "mode" binaire on peut très bien imaginer une gestion à base de géolocalisation. Par exemple, en été, si un des membres du logement travaille à une distance de 20 Km, on peut imaginer mettre en route la climatisation s'il se rapproche à moins de 10 Km... Le chauffage (convecteurs + climatiseur) ne se gérant pas comme la climatisation (climatiseur seul) j'y reviendrait prochainement.

Le script

Pour plus de facilité on va utiliser un script afin de créer l'ensemble des entités nécessaires. Dans ce script on crée les entités nécessaires à chaque pièce et le nombre de plages que l'on veut gérer chaque jour que l'on multiplie avec le nombre de jours particuliers à gérer ( jours de semaine, le samedi qui est travaillé le matin et les dimanches et fériés par exemple). 

Pour chaque plage on crée (à chaque plage correspond un fichier qui est stocké dans les pakages) :

  • Deux input_datetime: pour le début et la fin de chaque plage,
  • Un binary_sensor: pour savoir si on est dans la plage,
  • Un input_number: pour définir la température de consigne de la plage,
  • Un input_boolean: pour activer ou désactiver la plage.

On va également créer un fichier heating_global.yaml qui va contenir :

  • Un binary_sensor: s'appuyant sur workday: pour savoir si on est un samedi travaillé,
  • Deux input_number: pour définir la température de consigne pour les plages inactives (deux ou trois car ce n'est pas pareil pour une chambre vide ou un climatiseur),
  • Deux input_boolean: un premier pour activer un mode télétravail, et un autre pour activer / désactiver le bazard.

On pense à éditer les lignes 39 pour définir les pièces et 41 pour le nombre de plages par pièces. On est pas obligé de faite tout d'un coup bien sur (et je vous conseille de commencer light).

/bin/bash
test -d /config/packages || mkdir /config/packages
cd /config/packages
cat >heating_global.yaml<<EOF
input_boolean:
  heating_enabled:
    name: Heating Global
    icon: mdi:toggle-switch
  homeoffice:
    name: Home Office
    icon: mdi:toggle-switch
input_number:
  off_temperature:
    name: Off Température
    min: 14
    max: 26
    step: 1.0
    unit_of_measurement: °C
    icon: 'mdi:thermometer-lines'
  off_temperature_ac:
    name: Off Température
    min: 14
    max: 26
    step: 1.0
    unit_of_measurement: °C
    icon: 'mdi:thermometer-lines'
binary_sensor:
  - platform: template
    sensors:
      workday_saturday_working:
        friendly_name: "Samedi travaillé"
        value_template: >
          {% if now().isoweekday() in (5,) and states.binary_sensor.workday_sensor.state == 'on' %}
            true
          {%else%}
            false
          {% endif %}
EOF
for room in hall_ac
do
for period in {1..12}
do
cat >${room}_heating_period_${period}.yaml<<EOF
input_datetime:
  ${room}_heating_period_${period}_start:
    name: "Heating Period ${period} Start Time"
    has_date: false
    has_time: true
  ${room}_heating_period_${period}_end:
    name: "Heating Period ${period} End Time"
    has_date: false
    has_time: true
binary_sensor:
  - platform: template
    sensors:
      ${room}_slot_${period}:
        entity_id: sensor.time
        friendly_name: ${room}_Slot ${period}
        value_template: >
          {% set t = states('sensor.time') %}
          {% set start = states('input_datetime.${room}_heating_period_${period}_start') [0:5] %}
          {% set stop = states('input_datetime.${room}_heating_period_${period}_end') [0:5] %}
          {{ start <= t < stop if start < stop else (start <= t or t < stop) }}
input_number:
  ${room}_heating_period_${period}_temperature:
    name: Heating Period ${period} Temperature
    min: 18
    max: 25
    step: 1
    unit_of_measurement: °C
    icon: 'mdi:thermometer-lines'
input_boolean:
  ${room}_heating_period_${period}:
    name: Heating Period ${period} Enabled
    icon: mdi:toggle-switch
EOF
done
done
exit

On teste la configuration (check configuration) et on recharge ce qui est nécessaire (reload input booleans, reload input date times, reload input numbers, reload templates entities).

Les cartes Lovelace

Ici on a deux approches possibles. Un mode normal ou un mode compact. J'ai déjà évoqué le mode normal, mais quand on 12 plages par pièces on va essayer de compacter la chose. C'est un peu plus fastidieux pour saisir les valeurs, mais en général on ne change pas ces valeurs tous les jours.

type: entities
entities:
  - entity: input_boolean.heating_enabled
    name: Activation AC mode chauffage
  - entity: binary_sensor.heating_enabled
    name: Etat global du chauffage
  - entity: binary_sensor.workday_sensor
    name: Jour de semaine
  - entity: binary_sensor.workday_saturday_working
  - entity: input_boolean.homeoffice
  - entity: input_number.off_temperature
  - entity: schedy_room.schedy_heating_hall_ac
    name: Retour Schedy AC
  - label: SEMAINE
    type: section
  - entities:
      - entity: binary_sensor.hall_ac_slot_1
        name: false
      - entity: input_number.hall_ac_heating_period_1_temperature
        name: false
        unit: °
        format: precision1
      - entity: input_datetime.hall_ac_heating_period_1_start
        name: false
        format: relative
      - entity: input_datetime.hall_ac_heating_period_1_end
        name: false
    entity: input_boolean.hall_ac_heating_period_1
    name: Plage 1
    show_state: false
    toggle: false
    icon: 'mdi:calendar-range'
    type: 'custom:multiple-entity-row'
    state_color: true
# >>> Ici les autres avec un séparateur...
show_header_toggle: false
state_color: true
theme: teal
title: Schedy AC
footer:
  type: graph
  entity: sensor.daikin_inside_temperature
  hours_to_show: 24

Et voici le résultat...

Schedy

S'agissant de la configuration de Schedy il a bien sur fallut l'adapter. Vous dire que j'ai tout compris serait un mensonge et il y a certainement moyen de simplifier, et je suis preneur d'idées. Voici donc ce que ça donne (j'ai volontairement laissé quelques commentaires).

schedy_heating:
  module: hass_apps_loader
  class: SchedyApp

  actor_type: thermostat
  actor_templates:
    default:
      send_retry_interval: 15
      send_retries: 20
      supports_hvac_modes: true
      off_temp: 17
  
  watched_entities:
  - input_boolean.homeoffice
  - binary_sensor.workday_sensor
  - binary_sensor.workday_saturday_working
  - input_boolean.heating_enabled

  schedule_prepend:
  - x: "14 if is_off('input_boolean.heating_enabled') else Next()" # Le HorsGel... Possible aussi de créer un input_number...
  
  rooms:
    hall_ac:
      allow_manual_changes: true  # On autorise le changement manuel de consigne ou le passage en off
      rescheduling_delay: 90      # Délais après lequel Schedy repassera sur les valeurs prédéfinies
      actors:
        climate.thermostat_x:
          template: default
      watched_entities:
      # COMMON
      - input_boolean.homeoffice
      - binary_sensor.workday_sensor
      - binary_sensor.workday_saturday_working
      - input_number.off_temperature
      # ROOM SPECIFIC
      - input_number.hall_ac_heating_period_1_temperature
      - input_boolean.hall_ac_heating_period_1
      - binary_sensor.hall_ac_slot_1
      - input_number.hall_ac_heating_period_2_temperature
      - input_boolean.hall_ac_heating_period_2
      - binary_sensor.hall_ac_slot_2
      - input_number.hall_ac_heating_period_3_temperature
      - input_boolean.hall_ac_heating_period_3
      - binary_sensor.hall_ac_slot_3
      - input_number.hall_ac_heating_period_4_temperature
      - input_boolean.hall_ac_heating_period_4
      - binary_sensor.hall_ac_slot_4
      schedule:
      - rules:
        # WORKDAY
        - rules:
          - x: "Next() if is_on('binary_sensor.workday_sensor') else Break()"
          - x: >
              state("input_number.hall_ac_heating_period_1_temperature")
              if (is_on("input_boolean.hall_ac_heating_period_1") and (is_on("binary_sensor.hall_ac_slot_1")))
              else Next()
          - x: >
              state("input_number.hall_ac_heating_period_2_temperature")
              if (is_on("input_boolean.hall_ac_heating_period_2") and (is_on("binary_sensor.hall_ac_slot_2")))
              else Next()
          - x: >
              state("input_number.hall_ac_heating_period_3_temperature")
              if (is_on("input_boolean.hall_ac_heating_period_3") and (is_on("binary_sensor.hall_ac_slot_3")))
              else Next()
          - x: "Break(2)"
        # WEEK-END
        - rules:
          - x: "Next() if is_off('binary_sensor.workday_sensor') else Break()"        
          - x: >
              state("input_number.hall_ac_heating_period_4_temperature")
              if (is_on("input_boolean.hall_ac_heating_period_4") and (is_on("binary_sensor.hall_ac_slot_4")))
              else Next()
          - x: "Break(2)"

      # - v: 13 # On remplace par un input_number >>> Attention : v = valeur, x = expression
      - x: state("input_number.off_temperature") # Consigne entre les plages

A suivre...

Il existe dans Schedy un système d'events qui vont permettre de créer des dérogations ponctuelles. Par exemple un bouton ou une commande vocale quand je vais aller prendre une douche qui va lancer une dérogation pour augmenter sensiblement la température de la salle de bain pendant un temps défini ou jusqu'à ce qu'on lui envoie un contre ordre. On peu aussi imaginer chauffer une chambre d'amis lorsqu'on reçoit ou le boudoir lors d'une galante visite (encore que ces temps-ci la fonction ne servirait pas à grand chose...).

Et bien sur la gestion des ouvertures est gérée pour couper le chauffage... Plus tard...

Pour en finir...

Dans cet usage Schedy n'est plus vraiment le planificateur mais un moteur qui va surveiller (re planification) les thermostats et leur donner les bons ordres en fonction des évènements, états  et ordres venus de Home Assistant. Si Schedy peut également gérer des lampes (light:) et des actionneurs (switch:) c'est sans internet, sauf peut être pour superviser la machinerie d'une piscine...

 

Home Assistant & Notifications d'état

Avant, je planifiait mon chauffage avec des automations qui s'appuyaient sur des input_date, input_time pour actionner et input_number pour sélectionner la température de consigne souhaitée et je notifiait dans un journal sur Slack, ce qui me permet un debug facile. J'en avait largement parlé ici, mais maintenant il existe un vrai scheduler et je vais changer ma façon de faire. Sauf que ce scheduler, dont je vous parlerais bientôt, ne dispose pas d'une option de notification. Ca viendra peut être, et ce travail sera peut être à jeter, bien que le principe puisse être adapté à d'autre notifications.

Le scheduler pilotant dans mon cas les thermostats, je vais donc me baser sur les changement d'était du thermostat pour notifier l'état à Slack (voire faire autre chose...). Pour cela je vais stocker les états qui ont changés dans des input_number et des input_text et m'en servir pour notifier avec les bonnes variables.

La liste des courses

J'ai essayé de simplifier en minimisant les besoins, mais il nous faut des input_number: et des input_text:

input_number
  trigger_source_notify_temp_current:
    name: Température Ambiante
    mode: box
    min: 0
    max: 30
    unit_of_measurement: "°C"

  trigger_source_notify_temp_target:
    name: Température de consigne
    mode: box
    min: 0
    max: 30
    unit_of_measurement: "°C"

input_text:
  trigger_source_notify_name:
    name: Trigger Source Name

  trigger_source_notify_hvac_mode:
    name: Trigger Source HVAC Mode

  trigger_source_notify_hvac_action:
    name: Trigger Source HVAC Action
  
  trigger_source_notify_preset_mode:
    name: Trigger Source Preset Mode

  trigger_source_notify_state:
    name: Trigger Source State

Ces "inputs" vont servir à stocker temporairement les valeurs que je vais afficher dans mes notifications.

Une seule automation

Ensuite on va avoir besoin d'une automation qui va :

  1. Se déclencher (trigger) sur les changements d'état pour lesquels on souhaite envoyer une notification. Ici les attributs de deux thermostats.
  2. Ecrire (action) les valeurs liées à la source de déclenchement dans les input_number: et input_text:
  3. Notifier (action) en se servant des valeurs écrite précédemment.
- alias: Notifications des Thermostats
  trigger:
  - platform: template
    value_template: "{{ state_attr('climate.daikin','temperature')  }}"
  - platform: template
    value_template: "{{ state_attr('climate.daikin','preset_mode')  }}"
  - platform: template
    value_template: "{{ state_attr('climate.daikin','hvac_modes')  }}"

  - platform: template
    value_template: "{{ state_attr('climate.thermostat_antoine','temperature')  }}"
  - platform: template
    value_template: "{{ state_attr('climate.thermostat_antoine','preset_mode')  }}"
  - platform: template
    value_template: "{{ state_attr('climate.thermostat_antoine','hvac_modes')  }}"

  action:
  - data_template:
      entity_id: input_number.trigger_source_notify_temp_target
      value: '{{ trigger.to_state.attributes.temperature }}'
    service: input_number.set_value
  - data_template:
      entity_id: input_number.trigger_source_notify_temp_current
      value: '{{ trigger.to_state.attributes.current_temperature }}'
    service: input_number.set_value
  - data_template:
      entity_id: input_text.trigger_source_notify_name
      value: '{{ trigger.to_state.attributes.friendly_name }}'
    service: input_text.set_value
  - data_template:
      entity_id: input_text.trigger_source_notify_hvac_action
      value: '{{ trigger.to_state.attributes.hvac_action }}'
    service: input_text.set_value
  - data_template:
      entity_id: input_text.trigger_source_notify_preset_mode
      value: '{{ trigger.to_state.attributes.preset_mode }}'
    service: input_text.set_value
  - data_template:
      entity_id: input_text.trigger_source_notify_state
      value: '{{ trigger.to_state.state }}'
    service: input_text.set_value

  - service: notify.slack_hass_canaletto
    data:
      message: "{{ states.sensor.date_time.state}} > {{ states.input_text.trigger_source_notify_name.state }} : Consigne à {{ states.input_number.trigger_source_notify_temp_target.state }}° |  
                Température ambiante : {{ states('input_number.trigger_source_notify_temp_current') }}° | 
                Etat : {{ states.input_text.trigger_source_notify_hvac_action.state }} / {{ states.input_text.trigger_source_notify_preset_mode.state }} / {{ states.input_text.trigger_source_notify_state.state }}

Et on obtient une notification dans le journal Slack

2020-12-06, 20:24 > Thermostat : Antoine : Consigne à 13.0° | Température ambiante : 17.1° | Etat : idle / away / heat

Bonus

On peut s'amuser à traduire les messages d'état et ainsi les insérer en clair et en français dans la notification... En bricolant quelque chose du genre :

  {% if is_state('input_text.trigger_source_notify_hvac_action', 'heating') %}
    Etat : Chauffe
  {%-elif is_state('input_text.trigger_source_notify_hvac_action', 'cooling') %}
    Climatise
  {%-elif is_state('input_text.trigger_source_notify_hvac_action', 'dry') %}
    Désumidifie
  {%-elif is_state('input_text.trigger_source_notify_hvac_action', 'fan_only') %}
    Ventile
  {%-elif is_state('input_text.trigger_source_notify_hvac_action', 'heat_cold') %}
    Auto
  {% else %}
    Etat : Inactif
  {% endif %}

  {% if is_state('input_text.trigger_source_notify_preset_mode', 'away') %}
    Préréglage : Absent
  {%-elif is_state('input_text.trigger_source_notify_preset_mode', 'eco') %}
    Préréglage : Eco
  {%-elif is_state('input_text.trigger_source_notify_preset_mode', 'boost') %}
    Préréglage : Boost
  {% else %}
    Préréglage : Normal
  {% endif %}

  {% if is_state('input_text.trigger_source_notify_state', 'heat') %}
    Mode : Chauffage
  {%-elif is_state('input_text.trigger_source_notify_state', 'cold') %}
    Mode : Climatisation
  {%-elif is_state('input_text.trigger_source_notify_state', 'dry') %}
    Mode : Désumidifiation
  {%-elif is_state('input_text.trigger_source_notify_state', 'fan_only') %}
    Mode : Ventilation
  {%-elif is_state('input_text.trigger_source_notify_state', 'heat_cold') %}
    Mode : Auto
  {% else %}
    Mode : Arrêt
  {% endif %}

Voilà, bien entendu tout ça est adaptable à d'autres besoins....

 

Home Assistant & Planification

ARTICLE EN COURS d'ECRITURE, N’HÉSITEZ PAS A REVENIR...

 

Comme je l'ai déjà dit une des forces de Jeedom était son agenda, ici il n'y en a pas pour l'instant. Il existe bien Schedy mais j'ai le choix de ne pas y recourir. J'avais commencé à ébaucher la chose dans l'article sur le chauffage, on va continuer ici de façon plus poussée, sachant que si je poursuit avec mes thermostats, cette partie pourra s'appliquer à d'autres choses comme l’arrosage ou la gestion d'une piscine par exemple.

Si on utilise Home Assistant tout seul et que l'on maîtrise son code, dans l'absolu il n'y a pas besoin de ce que je vais expliquer. Par contre si on déploie pour un tiers, ou si l'ont veut que toute la famille puisse ajuster le fonctionnement, il vaut mieux penser à une interface graphique.

J'ai donc commencé à dessiner cette interface et ensuite je me suis attaqué au codage correspondant. Dans ce projet j'ai plusieurs thermostats à gérer, il suffira simplement de dupliquer le premier ainsi que toutes les ressources qui lui sont nécessaire. Je vous conseille de bien finaliser le premier thermostat, de tester dans tous les sens avant de de dupliquer.

Dans le cas présent je vais travailler sur le HA de mon frère afin de remplacer son vieux Jeedom, il me faut donc à minima que le résultat final ne souffre d'aucune régression et si possible que ça apporte plus de confort et de facilité d'usage. Par exemple sous Jeedom il devait aller changer ses consignes manuellement, jouer avec l'agenda, facile pour moi mais pas vraiment à la portée de l'utilisateur final. L'objectif ici c’est de lui limiter l'accès, mais qu'il puisse pour autant faire tout ce qui a été défini lui même. En plus il m'a collé un challenge, faire en sorte que sa salle de bain soit à la bonne température quand son réveil sonne. Sauf que son réveil est un EchoShow 5 avec Alexa, qu'il change l'heure avant de se coucher et qu'il n’est pas question de payer pour la passerelle Alexa officielle... A Suivre !

On ne parlera pas ici de capteur de température, ni d'actionneur, ça a déjà été évoqué dans d'autres articles.

On va gérer 3 journée type, les jours de semaine, le samedi car il travaille le samedi matin, et le dimanche ou jour férié. L’application des conditions utilisera le sensor Workday afin de pouvoir affecter dynamiquement les jours fériés.

Liste des courses

    • des input_datetime: un START un STOP afin de définir le début et la fin d'une plage horaire.
      # input_datetime: SEMAINE - THERMOSTAT SEJOUR
       sejour_start_semaine_matin:
       has_date: false
       has_time: true
       sejour_stop_semaine_matin:
       has_date: false
       has_time: true
       sejour_start_semaine_midi:
       has_date: false
       has_time: true
       sejour_stop_semaine_midi:
       has_date: false
       has_time: true
       sejour_start_semaine_soir:
       has_date: false
       has_time: true
       sejour_stop_semaine_soir:
       has_date: false
       has_time: true
      ...
    • des input_number: un par consigne de température. Afin de simplifier je suis parti sur des consignes globales, mais il est tout à fait possible d'avoir des consignes indépendantes pour chaque thermostat à gérer. Je n'ai pas de Hors Gel car celui ci est géré statiquement au niveau de chaque thermostat. J'ai ajouté Confort+ et Boost, le mode Boost servira essentiellement à surchauffer la salle de bain, comme on le verra plus loin.
      consigne_confort_plus:
       name: Confort +
       min: 14
       max: 24
       step: 0.1
       unit_of_measurement: °C
      ...
    • des input_boolean: un par plage horaire, ils serviront de drapeau pour chaque plage horaire si on souhaite activer la consigne Confort+ ou Boost pour une plage spécifique.
      boost_sejour_semaine_matin:
      boost_sejour_semaine_midi:
      boost_sejour_semaine_soir:
      ...
    • des binary_sensor: un par plage horaire, que je vais utiliser sur les conseils d'un collègue afin de convertir une heure de début de plage horaire, les utiliser en trigger: et récupérer celui qui est la source du déclenchement afin d'y affecter un flag pour activer le mode Confort+ ou Boost à une plage spécifique. On trouve également ici workday: pour gérer les jours fériés.
      - platform: template
        sensors:
          sejour_start_semaine_matin:
          friendly_name: 'Séjour : Start Semaine Matin'
          delay_off:
            minutes: 2
          value_template: >-
            {%- if states.sensor.time.state == states.input_datetime.sejour_start_semaine_matin.state[0:5] %}
              true
            {% else %}
             false
           {%- endif %}
      ...
      - platform: workday
        country: FRA
        workdays: [mon, tue, wed, thu, fri]
        excludes: [sun, holiday]
        add_holidays:
        - '2020-02-24'
      
    • des sensor: en fait surtout time_date: que l'on va utiliser pour comparer la date et l'heure courante avec nos interactions. J'y ai ajouté Season pour éviter de chauffer en été (...joke).

      - platform: time_date
        display_options:
        - 'time'
        - 'date'
        - 'date_time'
        - 'date_time_utc'
        - 'date_time_iso'
        - 'time_date'
        - 'time_utc'
        - 'beat'
      - platform: season

Définitions des cartes

On commence par le code de la carte entities:. Ce thermostat gère 3 convecteurs dans une pièce ouverte. La carte reprend également les détecteurs d'ouverture qui serviront à désactiver le thermostat quand on aère... (j'ai volontairement coupé le code sur la partie semaine).

entities:
  - entity: climate.thermostat_sejour
  - entity: switch.ipx800_1_sejour
  - entity: switch.ipx800_5_cuisine
  - entity: switch.ipx800_4_hall
  - entity: binary_sensor.window_door_sensor
  - label: SEMAINE
    type: section
  - entities:
      - entity: input_boolean.boost_sejour_semaine_matin
        name: false
        toggle: true
      - entity: input_datetime.sejour_start_semaine_matin
        name: false
      - entity: input_datetime.sejour_stop_semaine_matin
        name: false
    entity: input_fake
    name: Matin
    show_state: false
    type: 'custom:multiple-entity-row'
  - entities:
      - entity: input_boolean.boost_sejour_semaine_midi
        name: false
        toggle: true
      - entity: input_datetime.sejour_start_semaine_midi
        name: false
      - entity: input_datetime.sejour_stop_semaine_midi
        name: false
    entity: input_fake
    name: Midi
    show_state: false
    type: 'custom:multiple-entity-row'
  - entities:
      - entity: input_boolean.boost_sejour_semaine_soir
        name: false
        toggle: true
      - entity: input_datetime.sejour_start_semaine_soir
        name: false
      - entity: input_datetime.sejour_stop_semaine_soir
        name: false
    entity: input_fake
    name: Soir
    show_state: false
    type: 'custom:multiple-entity-row'
show_header_toggle: false
state_color: true
theme: teal
title: Thermostat Séjour
type: entities

Automation

Pour gérer l'ensemble des plages (3 ici) d'une journée type il nous faut 1 automation START et une automation STOP. On pourrait bien sur utiliser un delay:, mais ce n'est vraiment pas conseillé car ça obligerait l'automation à rester active et ça résisterait mal à une coupure / redémarrage (encore que...). J'aurais pu choisir de gérer toutes les journées type dans une même automation, mais ça voudrait dire de se passer des conditions: pour tout gréer dans un monstrueux template: dans action:. Simplifions sans complexifier.

Automation Start Confort Séjour Semaine :

  • Un bloc trigger: avec 3 binary_sensor:
  • Un bloc condition: en mode and avec :
    • Un input_boolean: qui va déterminer si le chauffage est ON ou OFF dans la maison.
    • Un input_boolean: qui va déterminer le mode absent (auquel cas les thermostats sont en mode hors gel et on ne poursuit pas). Le mode absent peut être géré manuellement ou par une règle liée de géolocalisation.
    • Une condition time: pour poursuivre uniquement les jours de semaine dans le cas de cette journée type.
    • Une condition workday: afin de s'assurer que l'on n'est pas en présence d'un jour férié.
  • Un bloc action avec :
    • Un sevice: basé sur un data_emplate: pour affecter la bonne consigne de température de Confort ou Confort+ si la plage horaire comporte ce flag.
    • Un notify: basé sur un data_emplate: de notification que je redirige vers un canal Slack et qui constituera le journal de mon thermostat.
- alias: '100 : START CONFORT Séjour Semaine'
  description: 'Confort et Confort+ Séjour Semaine sauf jours fériés'
  trigger:
    - entity_id: binary_sensor.sejour_start_semaine_matin
      platform: state
      to: 'on'
    - entity_id: binary_sensor.sejour_start_semaine_midi
      platform: state
      to: 'on'
    - entity_id: binary_sensor.sejour_start_semaine_soir
      platform: state
      to: 'on'

  condition:
    condition: and
    conditions:
      - condition: state
        entity_id: input_boolean.thermostats_on_off
        state: 'on'
      - condition: state
        entity_id: input_boolean.thermostats_away
        state: 'off'

      - condition: time
        weekday:
          - mon
          - tue
          - wed
          - thu
          - fri

      - condition: state
        entity_id: binary_sensor.workday_sensor
        state: 'on'

  action:
  - service: climate.set_temperature
    entity_id: climate.thermostat_sejour
    data_template:
      temperature: '{% if trigger.entity_id == "binary_sensor.sejour_start_semaine_matin" and is_state("input_boolean.boost_sejour_semaine_matin", "on") %}
                      {{ states.input_number.consigne_confort_plus.state }}
                    {% elif trigger.entity_id == "binary_sensor.sejour_start_semaine_midi" and is_state("input_boolean.boost_sejour_semaine_midi", "on") %}
                      {{ states.input_number.consigne_confort_plus.state }}
                    {% elif trigger.entity_id == "binary_sensor.sejour_start_semaine_soir" and is_state("input_boolean.boost_sejour_semaine_soir", "on") %}
                      {{ states.input_number.consigne_confort_plus.state }}
                    {% else %}
                      {{ states.input_number.consigne_confort.state }}
                    {% endif %}'

  - service: notify.slack_hass_canaletto
    data_template:
      message: >
        {% if trigger.entity_id == "binary_sensor.sejour_start_semaine_matin" and is_state("input_boolean.boost_sejour_semaine_matin", "on") %}
          {{ states.sensor.date_time.state}} > Confort+ ({{ states.input_number.consigne_confort_plus.state }}°), Séjour : {{ states('sensor.mi_t_clock') }}°, Extérieur : {{ states('sensor.ext_temperature') }}°
        {% elif trigger.entity_id == "binary_sensor.sejour_start_semaine_midi" and is_state("input_boolean.boost_sejour_semaine_midi", "on") %}
          {{ states.sensor.date_time.state}} > Confort+ ({{ states.input_number.consigne_confort_plus.state }}°), Séjour : {{ states('sensor.mi_t_clock') }}°, Extérieur : {{ states('sensor.ext_temperature') }}°
        {% elif trigger.entity_id == "binary_sensor.sejour_start_semaine_soir" and is_state("input_boolean.boost_sejour_semaine_soir", "on") %}
          {{ states.sensor.date_time.state}} > Confort+ ({{ states.input_number.consigne_confort_plus.state }}°), Séjour : {{ states('sensor.mi_t_clock') }}°, Extérieur : {{ states('sensor.ext_temperature') }}°
        {% else %}
          {{ states.sensor.date_time.state}} > Confort ({{ states.input_number.consigne_confort.state }}°), Séjour : {{ states('sensor.mi_t_clock') }}°, Extérieur : {{ states('sensor.ext_temperature') }}°
        {% endif %}

Améliorations à envisager : EJP ou Tempo à gérer dans le template d'affection des consignes afin de réduire la température de 1° les jours rouges et de démontrer ainsi la nécessité de la domotique. Prévoir un boolean global afin d'activer ou pas cette option.

Automation Stop Confort Séjour Semaine :

  • Un bloc trigger: avec 3 templates afin de récupérer les heures STOP. Inutile de créer des binary_sensor ici car on n'a pas besoin de connaitre la source de déclenchement dans action: ou on se contenter d'affecter la consigne Eco dans tous les cas.
  • Un bloc condition: ou l'on reprend les mêmes conditions que pour START.
  • Un bloc action: avec
    • Une action ou on défini la consigne de température Eco.
    • Une action de notification pour le journal.

INSERT CODE

Autre méthode

En fait la méthode classique consiste à créer un trigger: basé sur un template qui va comparer une ou plusieurs fois l'heure locale avec l'heure de l'input_datetime:

  trigger:
  - platform: template
    value_template: '{{ states.sensor.time.state == states.input_datetime.pompe_stop_p1.state[0:5] }}'
  - platform: template
    value_template: '{{ states.sensor.time.state == states.input_datetime.pompe_stop_p2.state[0:5] }}'

Ça fonction très bien, mais imaginons que nous ayons défini plusieurs plages et qu'on décide de ne pas utiliser certaines.

Si on les laisse bêtement à 00:00 00:00 on pourrait imaginer qu'il ne se passe rien. En fait si, on se retrouve avec un ON/OFF et parfois même un OFF/ON ce qui est plus gênant. Pour y remédier, et ça m'a pris un peu de temps car je n'ai aucune notion de développement, j'ai fini par améliorer mon template en associant une condition AND, en gros, si l'heure locale est égale à l'heure définie ET si l'heure définie pour le START est différente de l'heure définie en STOP, alors TRUE...

  trigger:
  - platform: template
    value_template: '{{ (states.sensor.time.state == states.input_datetime.pompe_stop_p1.state[0:5]) and (states.input_datetime.pompe_start_p1.state != states.input_datetime.pompe_stop_p1.state) }}'
  - platform: template
    value_template: '{{ (states.sensor.time.state == states.input_datetime.pompe_stop_p2.state[0:5]) and (states.input_datetime.pompe_start_p1.state != states.input_datetime.pompe_stop_p2.state) }}'

Alternatives

Home Asssitant ne dispose toujours pas du véritable agenda qui fait la force de Jeedom. En général je préfère le faire à la main ce qui permet de réaliser exactement ce que l'on souhaite. Mais j'ai trouvé deux embryons d'agenda. Pour l'instant ça ne va pas très loin, mais ça permettra de planifier des choses simples sans se plonger dans le code...

Conclusion

Voilà, il ne vous reste plus qu'à dupliquer ça à l'infini pour gérer autant de journées type, plages horaires et thermostats. Merci à Phillip et Mathieu dans notre fil Telegram pour leurs idées et aide, notamment sur les templates qui m'ont pris pas mal de temps.

Sources