Cela aura plusieurs avantages :

• supprimer les défaut liés à la durée de vie des cartes SD
• accélérer l’accès au système en utilisant la vitesse du SSD
• bénéficier de la vitesse de l’USB 3

Création d’un sauvegarde

Avant tout, pour ne pas à avoir à tout refaire sur home assistant, il est indispensable de faire une sauvegarde de HAOS

Démarrer sur le disque dur

Pour faire simple, j’ai déjà fait un article pour booter sur le disque dur brancher sur l’USB du Raspberry, je t’invite à lire cet article : démarrer sur un support externe.

Il te faudra simplement l’image d’HAOS que tu pourras trouver sur le git officiel, ici. Tu utilisera cette image pour créer ton disque dur.

Restaurer son installation

Lors de ton premier démarrage, tu auras le choix de créer un compte ou bien de restaurer à partir d’une sauvegarde, bien entendu, tu choisiras cette option :

Une fois que tu auras choisis ta sauvegarde (complète), il te faudra attendre quelques minutes.

Problèmes rencontrés

J’utilise la PiZigate comme passerelle pour tous mes modules Zigbee, malheureusement, il y a un soucis d’interférences connues avec le disque dur branché sur l’USB 3. Pour régler ça :

• éloigner le disque dur SSD du Raspberry
• brancher le disque dur SSD sur l’USB2

Dans les deux cas, il faut éloigner fortement le SSD. Pas de distance précise à te donner.

Conclusion

Le fonctionnement avec la PiZigate ou Zigate (vu sur les forums) n’est pas optimal avec un disque SSD. Mais si l’on arrive à supprimer les interférences, le fonctionnement de Home Assistant est bien plus efficace.

L’article Home Assistant, installation sur disque dur externe est apparu en premier sur La programmation sur le web.

Une de mes difficultés lors de la mise en place de cela a été que mon module, une fois ajouté à Home Assistant était déclaré comme une lumière. J’ai cherché sur le net (pas mal de temps) pour modifier le type du module dans ZHA.

Cet article est valable si tu utilises l’intégration ZHA et une passerelle Zigbee. Dans mon cas, avec mon Raspberry, j’utilise une PiGate.

Ce dont tu as besoin

J’imagine qu’en venant ici, soit tu as déjà ce qu’il faut, soit tu cherches, je mets de côté le Raspberry, qui peut être remplacé par une toute autre solution.

J’ai pris le module interrupteur Zigbee de Sonoff sur ce site.

Ajout du module avec ZHA

ZHA est une intégration permettant de gérer les équipements Zigbee accessible à partir d’une passerelle. Tu peux suivre ce lien.

L’intégration se fait comme tout autre équipement.

Modifier le type du module

Comme je l’ai dit au début de page, une fois installé, mon module était considéré comme une lumière. Pour mes automatisations, j’avais besoin d’interrupteur.

Dans le fichier configuration.yaml, tu ajouteras :

zha:
  device_config:
    00:12:4b:00:24:c2:03:4e-1:    
      type: "switch"

Pour l’explication, l’adresse est constituée de deux parties, la première est l’identifiant et la seconde le endpoint.

Pour trouver l’identifiant, dans Home Assistant, recherche ton appareil, dans Zigbee Info, tu trouveras IEEE (l’identifiant) :

Pour le endpoint, cliques sur Informations Zigbee, dans le popup qui s’affichera, tu trouveras le endpoint :

La dernière ligne permet d’indiquer comment Home Assistant doit utiliser le module, dans mon cas Switch.

Conclusion

Voici comment modifier le type d’un module installé.

L’article Home assistant, modifier le type d’un module est apparu en premier sur La programmation sur le web.

Dans ma commune, les déchets sont ramassés deux jours par semaine :

• le mercredi matin, ce sont les déchets non recyclables (poubelle bleue)
• le jeudi matin, il s’agit des déchets recyclacles (poubelle jaune)

Voilà, le petit script afin d’automatiser une notification sur mes enceintes Alexa la veille au soir.

Prérequis

Pour cet article simple, il faudra tout de même avoir les notifications sur les enceintes Alexa d’activer, si ce n’est pas le cas, tu peux te rendre sur Donner de la voix à Home Assistant avec Alexa.

Création des sensors

Une fois que tu arrives à faire parler tes enceintes, nous allons créer 2 sensors, nous pourrions faire autrement mais je trouve cette manière plus esthétique et cela permet d’appréhender les capteurs binaires avec la plateforme workday. La documentation sur Workday est disponible sur le wiki de HA.

Tout d’abord, dans le fichier configuration.yaml, j’ai ajouté cette ligne :

binary_sensor: !include binary_sensors.yaml

Le fichier binary_sensors.yaml contient l’ensemble de mes capteurs de ce type.

Nous allons créer nos deux capteurs :

• le premier pour la veille du ramassage des poubelles bleues
• le second pour la veille du ramassage des poubelles jaunes

Mon fichier contient donc cela :

# sensor pour le jour de ramassage de poubelle bleu
- platform: workday
  country: FR
  name: jour_poubelle_bleu
  workdays: [tue]

# sensor pour le jour de ramassage de poubelle jaune
- platform: workday
  country: FR
  name: jour_poubelle_jaune
  workdays: [wed]

Rien de très compliqué, il est à noter que country est obligatoire. La liste workdays contient les jours pour lesquels nous voulons que notre sensor soit à on.

Avec ce type de sensor, nous pourrions exclure des jours, des périodes (par exemple de vacances) ou des évenements déjà définis (Noël …) dans mon cas, je ne les utilise pas.

S’en est fini pour les sensors, prochaine étape, l’automatisation.

Automatisation des notifications

Maintenant, nous allons simplement créer 2 automations, une pour le mardi soir et une autre pour le mercredi soir.

# Ramassage des poubelles
- alias: rammassage_poubelle
  trigger:
    - platform: time
      at: '20:00:00'
  condition: 
    - condition: or
      conditions:
      - condition: and
        conditions:
          - condition: state
            entity_id: binary_sensor.jour_poubelle_bleu
            state: "on"
          - condition: state
            entity_id: input_boolean.vacances
            state: "off"
      - condition: and
        conditions:
          - condition: state
            entity_id: binary_sensor.jour_poubelle_jaune
            state: "on"
          - condition: state
            entity_id: input_boolean.vacances
            state: "off"
  action:
    - service: notify.alexa_media_dot_parent
      data_template:
        data:
          type: tts
        message: >-
          {% if states.binary_sensor.jour_poubelle_bleu.state == "on" %}
            "Pense à sortir la poubelle bleu"
          {% elif states.binary_sensor.jour_poubelle_jaune.state == "on" %}
            "Pense à sortir la poubelle jaune"
          {% endif %}

Il n’y a rien de compliqué, le déclencheur est l’heure (à 20h00) et il y a une des conditions imbriquées, en effet pas besoin que la notification soit émise, si personne est présent. Il y a bien moins lourd à faire sur les conditions, je reviendrai dessus plus tard.

Conclusion

Dorénavant, je n’aurai plus d’excuses pour avoir oublié de sortir les poubelles.

L’article Home assistant, automatiser une action des jours précis est apparu en premier sur La programmation sur le web.

Pour cette article, j’ai utilisé ma caméra EZVIZ modèle : C6N. Depuis quelques mois l’intégration est parfaitement compatible avec les fonctions de la caméra et Home Assistant.

Tu peux trouver cette caméra ici. Je m’étais arrêté sur ce modèle car son prix n’est pas élevé et en cas d’échec, je n’aurai pas perdu toute ma fortune. Il s’agit d’une caméra IP

La caméra C6N

Mon but n’est pas de la vendre, simplement de montrer son intégration et son utilisation, j’imagine que les autres modèles de chez EZVIZ fonctionneront.

Tout d’abord, voilà à quoi elle ressemble :

Son gabarit est un peu élevé. Donc, on ne le choisira pour rester discret.

Elle dispose des fonctions suivantes :

• full HD
• Vision nocturne
• Motorisée dans les deux axes
• Détection de mouvements
• Suivi intelligent
• Conversation bidirectionnelle

IL y a bien d’autres fonctions, je te laisse la page de la caméra sur le site : EZVIZ.

Si tu veux l’acquérir, tu peux la trouver sur le site Amazon.

Installation sur mobile

Je ne vais pas détailler l’installation sur l’application et la création du compte. Mais cette étape est indispensable, il s’agit d’une solution on cloud.

Mais tu peux mettre dès maintenant le mot de passe de la caméra de côté, tu en auras besoin pour l’installation de la caméra.

L’application est disponible :

• Play store sur cette page : EZVIZ App pour android.
• Sur le Apple Store sur celle-ci : EZVIZ pour iphone.

Installation sur Home Assistant

EZVIZ possède une intégration officielle, rends-toi dans Configuration puis Intégrations et cliques sur Ajouter une intégration.

Recherches EZVIZ et installes la :

Une fois que tu te seras connecté avec ton identifiant et ton mot de passe EZVIZ, tu auras le droit à une nouvelle intégration que tu devras configurer et ta caméra sera découverte.

La caméra n’est pas encore fonctionnelle, lors de la configuration, tu devras saisir le mot de passe correspondant à ta caméra. Le mot de passe est présent sur la boite ou bien en allant sur l’application et en allant chercher les informations de ta caméra.

Maintenant, ta caméra est bien disponible dans Home Assistant :

Pour donner une idée du nombre d’entité utilisable :

type: entities
entities:
  - entity: switch.camera_salon_alarm_light
    name: Alarm_Light
  - entity: switch.camera_salon_alarm_light_relevance
    name: Alarm_Light_Relevance
  - entity: switch.camera_salon_alarm_tone
    name: Alarm_Tone
  - entity: switch.camera_salon_all_day_video
    name: All_Day_Video
  - entity: switch.camera_salon_auto_sleep
    name: Auto_Sleep
  - entity: switch.camera_salon_cruise_tracking
    name: Cruise_Tracking
  - entity: switch.camera_salon_feature_tracking
    name: Feature_Tracking
  - entity: switch.camera_salon_human_intelligent_detection
    name: Human_Intelligent_Detection
  - entity: switch.camera_salon_infrared_light
    name: Infrared_Light
  - entity: switch.camera_salon_light
    name: Light
  - entity: switch.camera_salon_light_flicker
    name: Light_Flicker
  - entity: switch.camera_salon_mobile_tracking
    name: Mobile_Tracking
  - entity: switch.camera_salon_partial_image_optimize
    name: Partial_Image_Optimize
  - entity: switch.camera_salon_privacy
    name: Privacy
  - entity: switch.camera_salon_sleep
    name: Sleep
  - entity: switch.camera_salon_sound
    name: Sound
  - entity: switch.camera_salon_sound_localization
    name: Sound_Localization
  - entity: switch.camera_salon_stream_adaptive
    name: Stream_Adaptive
  - entity: switch.camera_salon_tracking
    name: Tracking
title: Caméra salon

On possède tous les contrôles disponibles sur l’application via son interface Home Assistant.

L’article Home Assistant, ajouter une caméra EZVIZ est apparu en premier sur La programmation sur le web.

Si tu recherches à piloter à la voix tes équipements, tu peux suivre Lier Alexa avec Home Assistant.

Les prérequis

Bien entendu, je ne vais pas te dire d’avoir une installation fonctionnelle d’Home Assistant mais, sait-on jamais, si tu as besoin d’en installer une, je t’invite à suivre ce lien : Installer Home Assistant.

Tu auras besoin d’avoir HACS (pour Home Assistant Community Store), son installation est disponible ici, Installer HACS.

Téléchargement d’Alexa Media Player

Rends toi dans HACS puis dans Intégrations et cliques Explorer et ajouter des dépôts :

Dans le champs de recherche, saisis Alexa et choisis Alexa Media Player :

Dans la fenêtre nouvellement ouverte, cliques sur Installer ce dépôt dans HACS puis sur Télécharger.

Redémarres Home Assistant et vide le cache.

Installation d’Alexa Media Player

Une fois Home Assistant redémarré et le cache du navigateur vidé, ajoutes l’intégration en passant par Configuration puis Intégrations et Ajouter l’intégration :

Cliques sur l’intégration, l’installation prend un peu de temps, patientes.

Une fois qu’on te donne la possibilité, saisis les informations demandées :

Saisis ton compte et ton mot de passe et changes le Domaine de la région en plaçant amazon.fr (si tu as un compte français). En bas, cliques sur Soumettre.

Une demande d’authentification te sera demandée.

Ton installation est finalisée, tu verras tout tes appareils listés :

Cliques sur Terminer en bas de la page, tu verras tes appareils ainsi que les entités correspondantes :

Faire apparaître les appareils sur le tableau de bord

Sur ton tableau de bord, ajoutes une carte Contrôle des médias :

Puis choisis l’entité (l’appareil) que tu souhaites voir apparaître et cliques sur Enregistrer :

Voilà ce que cela donne :

Faire parler son enceinte

Nous allons faire parler notre enceinte, pour cela, rends toi dans Outils de développement puis dans Service,.

Dans service, choisis : notify.TON_APPAREIL, puis en mode YAML, saisie ce qui suit :

Dans Actions (tout en bas de la page), choisir Appeler un service, ce sera une notification sur l’appareil désiré :

service: notify.alexa_media_dot_parent
data:
  data:
    type: tts
  message: bonjour
  

Finis par cliquer Appeler le service.

Conclusion

Tu as maintenant un système de notification utilisant tes belles enceintes Alexa.

L’article Home Assistant, ajouter les enceintes Alexa est apparu en premier sur La programmation sur le web.

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.

L’article Home Assistant, gestion avancée du chauffage est apparu en premier sur La programmation sur le web.

• la journée
• le week-end
• au réveil
• en soirée
• la nuit
• en cas d’absence prolongé

Ce qui est super avec Home Assistant, c’est qu’il y a déjà plein d’outils pour réaliser cela.

Dans cet article, je ne vais pas détailler la mise ne place complète de toutes les règles mais seulement le fonctionnement du thermostat générique présent dans Home Assistant. Je choisis de procéder en plusieurs articles tout simplement pour que la mise en place soit clair et que l’article ne mélange pas trop de concept. Beaucoup d’articles sur le net (même des très bons) fournissent beaucoup d’informations qui peuvent être difficiles d’appréhender pour un néophyte (tu peux jetter un oeil ici).

Les prérequis

Je me répète mais tout d’abord, il te faudra un système opérationnel, si tu pars de zéro, je t’invite à suivre ce lien : Installation d’Home Assistant sur un Raspberry.

Ensuite, tu auras besoin d’un système de chauffe et d’un thermomètre, bien sûr que tout devra être connecté.

Je ne parlerai pas de thermostat connecté, je n’en ai pas, 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.

Configuration

Je n’aborderai pas l’installation d’un nouvel appareil, nous allons directement attaquer la mise en place du thermostat pour ce couple prise chauffage et capteur de température.

Home Assistant a mis à disposition un thermostat générique avec lequel, nous allons pouvoir définir les plages de température, le chauffage et le capteur.

Nous allons donc utiliser l’intégration Climate intégrée à HA et la plateforme generic_thermostat.

Dans le fichier configuration.yaml, on va ajouter un lien vers un dossier climate qui contiendra notre configuration :

climate: !include_dir_merge_list climate/

Avec File Editor (pour l’installer, rends toi sur Les Add-ons indispensables), nous allons ajouter dans config le dossier climate.

Dans le dossier climate, on va créer un fichier generic_thermostat.yaml. L’arborescence doit ressembler à ça : /config/climate/generic_thermostat.yaml.

Maintenant, nous allons écrire ce qui suit dans ce nouveau fichier :

- platform: generic_thermostat
  # Nom de notre thermostat
  name: Chauffage de la chambre des parents
  # entité du chauffage
  heater: switch.prise_chauffage_parent_on_off
  # entité du capteur de température
  target_sensor: sensor.temperature_parent_temperature
  # la température réglable minimum du thermostat
  min_temp: 16
  # la température réglable maximum du thermostat
  max_temp: 20
  # mode de fonctionnement du système "heater"
  ac_mode: false
  # la température cible
  target_temp: 18
  # il s'agit de la tolérance de température basse pour l'activation de la chauffe
  cold_tolerance: 0
  # tolérance de la température avant que la chauffe ne soit activer
  hot_tolerance: 0.3
  # il s'agit du mode dans lequel le thermostat démarre la première fois
  initial_hvac_mode: "off"
  # température en cas de mode absent
  away_temp: 16
  # Il s'agit de la précision pour le réglage de la température
  precision: 0.1
  # le temps minimum d'un cycle de fonctionnement
  min_cycle_duration:
    seconds: 5
  " maintient en chauffe au moins 3 minutes si le thermostat ne reçoit pas de commande
  keep_alive:
    minutes: 3

Voilà pour la configuration de l’intégration climate.

Dans notre cas, cold_tolerance et hot_tolerance ne sont pas réellement utiles, ils sont indispensable si ac_mode est true, ce qui signifie que l’on fonctionne en climatisation.

Visualisation sur le tableau de bord

Pour être sûr que le thermostat soit bien pris en compte, redémarres Home Assistant et efface le cache du navigateur.

Nous allons créer deux cartes qui permettront de bien visualiser notre thermostat, ce qui donnera cela :

Pour la première carte, nous allons créer une carte entité en intégrant nos deux entités :

• le capteur
• le chauffage

Sélectionnes tes deux entités, cliques sur Continuer puis sur Ajouter au tableau de bord.

Pour la seconde carte, ajoutes une nouvelle carte en recherchant thermostat :

Dans la nouvelle fenêtre, sélectionnes l’entité qui correspond à la configuration du thermostat (de la première partie) puis enregistres.

Conclusion

Te voilà maintenant un thermostat basique gérer dans Home Assistant.

Reviens dans quelques jours, il devrait y avoir une gestion plus précise du thermostat.

L’article Home assistant, utiliser le thermostat générique est apparu en premier sur La programmation sur le web.

HACS pour Home Assistant Community Store est une intégration qui te permettra d’ajouter un nombre très important de modules non officiels.

Les prérequis

De base, tu auras besoin d’avoir un Home Assistant d’installer et fonctionnel, tu peux suivre cet article pour l’avoir : Installer Home Assistant sur un Raspberry.

Une fois cela fait, il est indispensable d’avoir un compte GitHub. L’inscription et l’utilisation que tu vas en faire ici sont entièrement gratuites

Tu devras avoir accès aux fichiers de ton installation, Samba Share et File Editor, le premier permet le transfert de fichiers sur ta configuration et le second permet d’écrire dans les fichiers. Pour leur installation, tu peux lire cette page : Installer les add-ons indispensables.

Une fois tout cela disponible, on peut commencer.

Récupération de HACS

Commences par te rendre sur le GitHub de Hacs pour télécharger la dernière version, HACS.

Cliques sur Code et sur Download ZIP.

Uns fois téléchargé, décompresses le dossier.

Créer le fichier custom_components

Si ce n’est pas déjà fait, avec File Editor, crées un dossier custom_components dans le dossier config.

Copie des dossiers de HACS

Dans le dossier que tu as téléchargé, il y a un dossier custom_components. A l’intérieur, il y a le dossier hacs que tu copies et que tu colles dans le dossier précédemment créé.

Tu peux le placer à l’intérieur avec l’intégration Samba Share.

Tu dois respecter cet arborescence : /config/custom_components/hacs.

Redémarres ton système et vides le cache de ton navigateur.

Je t’invite à vider le cache de ton navigateur à chaque fois que tu installes une nouvelle intégration.

Installation et configuration

Une fois que ton système a redémarré, sur Home Assistant, rends toi dans Configuration puis Intégrations.

Pour ajouter une nouvelle intégration, cliques sur le plus en bas de la page :

Dans le champs de recherche, saisis HACS :

Cliques sur HACS et suit les étapes de connexion.

Redémarres ton système et vides le cache. Le premier démarrage de HACS peut être longue.

Conclusion

Tu peux désormais profiter de la bibliothèque très bien fournie par la communauté de Home Assistant.

L’article Home Assistant, installer HACS est apparu en premier sur La programmation sur le web.

Je vais te montrer la syntaxe de base d’un groupe ainsi que sont utilisation.

Je pars du principe que tu as une installation avec Home Assistant prête si ce n’est pas le cas, tu peux suivre lire cet article.

Emplacement du groupe

Les groupes sont à définir dans la configurations, en théorie, tu as un include dans le fichier configurations.yaml, comme cela :

group: !include groups.yaml

Il faudra donc écrire (définir) les groupes dans le fichier groups.yaml.

Syntaxe d’écriture d’un groupe

On va simplement voir la création d’un groupe :

chambre:
  name: chambre
  view: yes
  entities:
    - light.chambre

La première ligne est le nom du groupe, à ne pas confondre avec la seconde ligne qui correspond au nom usuel, celui qui apparaîtra.

La ligne view permet de définir si le groupe est visible ou pas.

Enfin, entities permet de lister les entités qui font parties du groupes.

Utilisation des groupes

Voici un petit exemple, je vais créer un groupe qui contiendra des groupes de lumière, cela permettra de ne pas avoir à modifier plusieurs scripts si j’ajoute ou retire une lumière :

lumiere_chambre_fille:
  name: 'Lumière de la chambre de la fille'
  icon: mdi:lightbulb
  entities:
    - light.lampe_rgb_fille_level_light_color_on_off

    
lumiere_chambre_garcon:
  name: 'Lumière de la chambre de garçon'
  icon: mdi:lightbulb
  entities:
    - light.lampe_rgb_garcon_level_light_color_on_off

lumieres:
  name: 'Toutes les lumières'
  icon: mdi:lightbulb
  entities:
    - gtoup.lumiere_chambre_fille
    - group.lumiere_chambre_garcon

Conclusion

Voilà un petit exemple d’utilisation de groupe, bin sûr, cet article est plus un moyen de montrer l’utilisation des groupes.

L’article Home Assistant, utiliser les groupes est apparu en premier sur La programmation sur le web.

La première question à laquelle je vais répondre est : « Pourquoi créer son Blueprint ? »

La réponse est des plus simple, j’ai fait un exemple pour allumer une lampe après la détection d’un mouvement entre deux heures, j’imagine qu’il n’y a pas qu’une lampe chez toi, le blueprint va te permettre de mettre tes automatisation en place plus rapidement, que ce soit pour des lampes, des capteurs, des interrupteurs …

Pour cet article, je vais reprendre l’exemple de l’automatisation créée précédemment :

- id: Light-with-mvt 
  alias: Lumière avec mouvement 
  trigger:
  - platform: state
    entity_id: binary_sensor.lumi_lumi_sensor_motion_81807f04_ias_zone
    from: 'off'
    to: 'on'
  condition:
  - condition: time
    after: "19:00:00"
    before: "07:00:00"
  action:
  - service: light.turn_on
    target:
      entity_id: light.lumi_lumi_light_aqcn02_c4865d04_level_light_color_on_off
    data:
      color_temp: 200
      brightness_pct: 25
  - wait_for_trigger:
      platform: state
      entity_id: binary_sensor.lumi_lumi_sensor_motion_81807f04_ias_zone
      from: "on"
      to: "off"
  - delay:
      seconds: 60
  - service: light.turn_off
    target:
      entity_id: light.lumi_lumi_light_aqcn02_c4865d04_level_light_color_on_off
  mode: restart
  max_exceeded: silent

Je ne vais pas revenir dessus, tu peux retrouver les informations sur cette page. D’ailleurs, je te conseille d’aller jeter un petit coup d’oeil, je me concentrerai seulement sur la partie de blueprint.

Explication

Je commence par fournir le blueprint, que je viendrai expliquer :

blueprint:
  name: Lumière activée par le mouvement entre 2 heures
  description: Allume la lumière quand un mouvement est détecté entre deux heures.
  domain: automation
  input:
    motion_entity:
      name: Capteur de mouvement
      selector:
        entity:
          domain: binary_sensor
          device_class: motion
    light_target:
      name: Light
      selector:
        target:
          entity:
            domain: light
    no_motion_wait:
      name: "Temps d'attente"
      description: Temps après le dernier mouvement pour éteindre la lumière.
      default: 120
      selector:
        number:
          min: 0
          max: 3600
          unit_of_measurement: seconds
	time_after:
	  name: "Heure du début"
	  description: "Heure à laquelle commence l'allumage de la lumière"
	  selector:
	    time:
	time_before:
	  name: "Heure de fin"
	  description: "Heure à laquelle se termine le déclenchement l'allumage de la lumière"
	  selector:
	    time:

mode: restart
max_exceeded: silent

trigger:
  platform: state
  entity_id: !input motion_entity
  from: "off"
  to: "on"

condition:
  - condition: time
  after: !input time_after
  before: !input time_before

action:
  - service: light.turn_on
    target: !input light_target
  - wait_for_trigger:
      platform: state
      entity_id: !input motion_entity
      from: "on"
      to: "off"
  - delay: !input no_motion_wait
  - service: light.turn_off
    target: !input light_target

Le fichier doit commencer par blueprint, afin de clairement faire comprendre à Home Assistant ce qu’il est. Ensuite, on lui donne un nom (name), une description (description) et un domaine (domain) :

blueprint:
  name: Lumière activée par le mouvement entre 2 heures
  description: Allume la lumière quand un mouvement est détecté entre deux heures.
  domain: automation

Dans la seconde partie, tu devras indiquer les entrées. Les entrées sont ce que tu devras saisir pour la mise en place de ton automatisation (capteur, zone, équipement, heure…). Pour chaque entrée, il faudra lui donner un nom (qui sera utilisé pour récupérer l’entrée), un sélecteur (selector) qui permet de définir ce qui sera affiché sur la création de l’automatisation pour cette entrée et les options de ce selector. Dans cette partie, nous ne renseignons pas les entités ou groupes :

input:
    motion_entity:
      name: Capteur de mouvement
      selector:
        entity:
          domain: binary_sensor
          device_class: motion
    light_target:
      name: Light
      selector:
        target:
          entity:
            domain: light
    no_motion_wait:
      name: "Temps d'attente"
      description: Temps après le dernier mouvement pour éteindre la lumière.
      default: 120
      selector:
        number:
          min: 0
          max: 3600
          unit_of_measurement: seconds
	time_after:
	  name: "Heure du début"
	  description: "Heure à laquelle commence l'allumage de la lumière"
	  selector:
	    time:

Dans la seconde partie du code, nous retrouvons nos déclencheurs, nos actions et nos conditions, les informations qui sont habituellement saisie sont remplacées par une phrase de ce type : !input no_wait_motion. Cela permet de signifier que cette entité sera l’entrée avec se nom (dans notre cas no_wait_motion).

Conclusion

La création d’un blueprint n’est pas plus compliqué que la création d’une automatisation, elle est à privilégier surtout si l’on sait que plusieurs automatisations y feront référence.

L’article Home Assistant, création d’un Blueprint est apparu en premier sur La programmation sur le web.