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.

L’idée de cette publication et de voir rapidement ce qu’il est possible de faire.

Nous allons voir cinq manières :

• l’armoire électrique
• Les interrupteurs connectés
• Les modules
• Les ampoules connectées

Je n’ai mis aucun lien Amazon, je reste sur de l’information et je n’ai pas testé l’ensemble de ses solutions.

L’armoire électrique

Cette solution est certainement la méthode la plus simple à utiliser et à faire évoluer.

En revanche, elle concerne surtout soit :

• les nouvelles installations dans du neuf (dès la phase de construction)
• les rénovations complètes

En effet, cette manière nécessitera d’avoir dans son armoire tous les câbles de ses interrupteurs et de ses lampes dans l’armoire électrique.

Au choix, tu pourras utiliser des modules qui se mettent sur des rails ou bien adapter des modules plus classiques.

Tous les câblages de la maison (éclairage, volet comme prise) se feront dans l’armoire, pas besoin de démonter le mur, la prise pour accéder au module en cas de défaillance ou modification.

En revanche, prévois du câble et de la gaine pour tout ramener jusqu’à l’armoire.

Les interrupteurs connectés

Les interrupteurs connectés te permettront d’intégrer ta domotique sur de l’existant avec une installation simple. Ils seront facilement mis en place dans tes boitiers d’encastrement présent.

Il en existe de différents type : tactile, à boutons, pour des scénarios.

Certains seront directement alimentés par le secteur et les ampoules seront connectés dessus, d’autres n’auront que des boutons qui devront être scénarisés.

Même un interrupteur sur lequel l’ampoule est branchée peut être scénarisé.

Ce genre d’interrupteur peut coûter plus cher surtout si tu souhaites tout homogénéiser. Mais la mise en place est facile.

Les modules connectés

Je précise dès le début de cette partie, je ne parle ici que de l’utilisation de modules connectés avec une ampoule classique, dans la dernière partie, j’aborderai le cas de l’utilisation d’un module avec une ampoule connectée.

Les modules connectés pourront être utilisés de deux manières :

• dans une armoire
• dans un boitier d’encastrement

La mise en place dans un boitier d’encastrement ne sera jamais aussi simple que ce que le constructeur de module dira. Les boitiers standards ne sont pas assez profonds pour accueillir le boitier et les câbles. De plus, il peut y avoir des modules un peu plus grand que d’autres.

Personnellement, j’utilise des boitiers encastrables avec emplacement de module, cela règle le problème d’espace (ajouter quelques euros pour le boitier).

L’avantage de cette méthode est que tu n’as pas besoin de faire de gros travaux, tu peux garder tes interrupteurs déjà présents ainsi que les ampoules.

Le second gros avantage est que tu gardes la commande physique en cas de défaillance de ton réseau.

Ton module sera alimenté par le secteur, ton interrupteur viendra commander le module (possibilité de brancher un va-et-vient), tu pourras scénariser ton module.

Il existe des modules avec deux entrées et une sortie, d’autres avec deux entrées et deux sorties …

Tu peux également utiliser le module sans brancher tes sorties et simplement les commandes pour passer par un scénario.

Les ampoules connectées

Les ampoules connectées sont une solutions à moindre coût pour ajouter un éclairage.

Il faut garder en tête qu’elle doit toujours être alimentée. Cela signifie que la mise en place d’un interrupteur physique pour la commander ou l’utilisation de la sortie d’un module est à déconseiller.

Si le circuit est ouvert donc que l’ampoule n’est plus alimentée (dans le cas d’une ampoule connectée, alimentée ne signifie pas allumée), on ne pourra plus connaître son état ni la scénariser.

Je ne suis pas un adepte des ampoules connectées à moins de seulement passer par des scénarios sans commande filaire.

De même, sans scénario, plus de commande.

Conclusion

Voici différentes solutions pour mettre en place un éclairage domotisé. Le choix se fera en fonction de l’état de votre habitation (neuf, rénovation, modification), de vos connaissances (les modules nécessiteront plus de connaissances électriques que de simples ampoules) et du coût.

L’article Home assistant, domotiser son éclairage 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.

En passant, il est possible d’utiliser Home Assistant Cloud, la configuration sera automatique et bien plus simple mais ce service coutera 5 dollars par mois.

Pour écrire cet article, j’ai suivi la documentation de Home Assistant ainsi que la documentation Haaska. Ce sera plus une traduction dans laquelle, j’incorporai des captures ainsi que des commentaires.

Il y a deux parties ici, la première très grosse concerne la mise en place et configuration, la seconde, bien plus courte (si tout fonctionne) pour le test de la communication entre Home Assistant, Alexa (en gros, toute la partie Haaska, fonction et skill).

Mise en place

Les pré-requis

Afin de pouvoir mettre en place Alexa, il faut que Home Assistant soit ouvert à l’extérieur en utilisant un certificat SSL. SI ce n’est pas fait, tu peux suivre cet article : mise en place de HTTPS.

Il te faudra deux comptes (nous allons voir la création ensuite) :

• un compte développeur Amazon
• un compte des services web Amazon (AWS)

Création du compte développeur Amazon

Tout d’abord, si cela n’est pas encore fait, va te créer un compte développeur sur cette page.

Une fois l’inscription réalisée, rends toi sur cette page, c’est sur cette page que les skills Alexa seront.

Crées une nouvelle skill :

Maintenant donne un nom à ton skill (par exemple « Home Assistant ») et sélectionnes la langue par défaut :

Pour finir, tu sélectionnes « Smart Home » et « Provision your own » :

Tu peux enfin cliquer sur créer ta skill en haut à droite.

Dans la nouvelle page, assures-toi que la version « v3 » est bien cochée :

Maintenant que la base de ta skill est créée, tu peux garder la page ouverte, on y reviendra.

Création du compte des services web Amazon (AWS)

Après avoir créer ton compte AWS ici, nous allons pouvoir commencer la parties plus profonde de la préparation. Alexa Smart Home va venir déclencher notre fonction que nous allons mettre en place dans cette longue partie.

Nous allons utiliser le dépôt contenant haaska, la dernière version est disponible en suivant ce lien (que tu peux dès maintenant télécharger).

Création du rôle

Rends toi sur cette page pour la création du rôle.

Ensuite, dans la colonne de droite, cliques sur « Role » et « Créer un rôle » :

Sélectionnes « Services AWS« , « Lambda » et cliques sur « Autorisations » :

Sur la nouvelle page, dans le champs de recherche, tapes « Basic » et sélectionnes « AWSLambdaBasicExecutionRole« , pour finir, cliques sur le boutons d’étape suivante :

Sur la page des balises, tu peux directement cliquer sur « Vérifications« .

Dans la dernière page, saisie le nom du rôle « lambda_basic_execution » et cliques sur « Créer un rôle« .

Maintenant que le rôle est créé, reviens à l’accueil de AWS en cliquant sur l’icone en haut à gauche.

Sélection du langage

Voici une étape importante pour la suite, tu dois sélectionner la région « eu-west-1 » (pourquoi sélectionner celle-ci ??? Parce que Amazon le dit sur cette page) :

Configuration de la fonction AWS (partie 1)

Toujours sur la page AWS, dans la barre de recherche, tapes « calcul » et clique sur « Lambda » :

Sur la nouvelle page, cliques sur « Créer une fonction« .

Dans la nouvelle page, sélectionner « Créer à partir de zéro » ensuite complétes comme cela :

Voici les informations :

• Nom de la fonction : haaska
• Execution : Python 3.6 (à l’heure de l’ériture de cet article, la documentation du dépôt demandée cette version)
• Ensuite, utilises un rôle existant en sélectionnant « lambda_basic_execution« 

Tu peux cliquer sur « Créer une fonction« .

Configuration de la fonction AWS (partie 2)

Avant de passer à cette partie, assures toi que la région soit bien définie, si tu as un doute reviens un peu en arrière.

Nous allons configurer le déclencheur pour la fonction, pour cela, clique sur « Ajouter un déclencheur« , sur la page de ta fonction Lambda nouvellement créer :

Sur la nouvelle fenêtre, dans le premier champs, sélectionnes « Alexa Smart Home« , dans le champs Id Application, tu dois coller le Skill ID (présent sur la console développeur), l’ID est de cette forme : amzn1.ask.skill.57bc7e6f-da92-47a9-9609-6406d56886e7. Pour finir, cliques sur Ajouter :

Nous allons charger le code Haasska (que tu as déjà dû télécharger avant, re-voici ce lien). Restont sur la configuration de notre fonction, dans l’onglet Code de la fen^tre, cliques sur Charger depuis puis Fichier.zip, sélectionnes le fichier Zip que tu as téléchargé :

Nous allons modifier le gestionnaire pour le paramètre d’éxecution par « haaska.event_handler », ce cadre est disponible en dessous de la partie code :

Récupération du jeton long durée de Home Assistant

Rends toi sur ton Home assistant, cliques sur l’avatar devant ton nom, puis défile la page jusqu’à tomber sur « Jetons d’accès de longue durée« , cliques sur « Créer un jeton« , nommes-le et valides. Copies ce code, il ne sera plus visible après.

Configuration de la fonction Haaska

Dans la section code de la fonction, double-cliques sur « config.json« , remplaces l’URL par celui qui permet d’accéder à ton assistant, par exemple https://my-hass.example.com:8123 .

Ensuite, pour la variable « bearer_token« , copies le jeton longue durée que tu as récupéré plus tôt.

Toujours dans la fenêtre du code, cliques sur « File » et « Save All ».

Copie l’ARN de la fonction qui doit avoir cette forme : arn:aws:lambda:eu-west-1:4730256486332:function:haaska.

Récupération des identifiants de connexion avec Amazon

Nous allons besoin de récupérer les identifiants pour se connecter avec Amazon, pour cela, rends toi sur cette page, puis cliques sur « Afficher l’ID et le secret du client » :

Lien entre la fonction et la skill

Retournes sur la console développeur Alexa, sur la page de ta skill, colles l’ARN précédemment copiée dans le champs « Default endpoint« , sélectionnes ta région puis colles de nouveau l’ARN sur le champs correspondant, fini par cliquer sur « SAVE » :

Lien entre la Skill et la connexion Amazon

Dans la fenêtre de la Skill, cliques sur « ACCOUNT LINKING« , puis saisies les champs comme suit :

Une fois les champs mis à jour, cliques sur « SAVE« .

Copier la liste de redirection du bas de la page.

Retourner sur la page de « Login With Amazon (par ici), puis sur le profil, cliquer sur l’engrenage et choisir « Paramètre web« , ajoutes tes trois liens de retour autorisés.

Conclusion de la mise en place

Voilà que la grosse première partie est finie, nous allons maintenant procéder au test.

Test d’Haaska

Reviens (ou restes) sur la page de la fonction Lambda que tu as créé, dans l’onglet code, déroule le bouton « Test » et crées un nouveau test, nommes-le, et colle dans la partie du code ci-dessous, modifie « access-token-from-skill » par ton jeton longue durée provenant de Home Assistant et sauves :

{
  "directive": {
    "header": {
      "namespace": "Alexa.Discovery",
      "name": "Discover",
      "payloadVersion": "3",
      "messageId": "1bd5d003-31b9-476f-ad03-71d471922820"
    },
    "payload": {
      "scope": {
        "type": "BearerToken",
        "token": "access-token-from-skill"
      }
    }
  }
}

Une fois cela fait, cliques sur Deploy et lances le test, si aucun message apparaît, je suis ravi pour toi.

Cela devrait te retourner un JSON répertoriant les appareils exposés via Home Assistant.

Dans mon cas, j’ai eu plusieurs erreurs (toutes résolues) :

• Dans le fichier config.json, j’avais fait une petite erreur sur l’URL
• Toujours dans le même fichier, ma clé longue durée n’était pas correcte, je l’ai réactualisé

Conclusion du test

Si tu as tout suivi, tu n’as pas dû avoir de soucis. On va passer à l’intégration proprement dite dans Home Assistant.

Configuration finale

Activation de la Skill dans l’application Alexa

Maintenant que cette partie est effective, rends toi sur l’application Alexa de ton smartphone, puis Skill et jeux, ensuite Vos Skills. Tu devrais voir apparaître ta skill, clique dessus et active-la. Une fois activée, Alexa recherchera des appareils à connecter.

Configuration de Home Assistant

Maintenant, cela se passe dans Home assistant, avec File Editor, allez dans configuration.yaml et modifies comme suit :

alexa:
  smart_home:
    locale: fr-FR
    endpoint: https://api.amazonalexa.com/v3/events
    client_id: YOUR_SKILL_CLIENT_ID
    client_secret: YOUR_SKILL_CLIENT_SECRET

Bien entendu, remplace les éléments par les tiens, ils permettent une connexion à Amazon.

Redémarrer le serveur.

Conclusion finale

Voilà après tout ça, tout devrait fonctionner. J’ai simplement découvert un point important,le nommage des éléments de mon systèmes est super important.

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