Home Assistant & Wake on Lan

L'heure est aux économies d'énergies et il parait qu'il faut éteindre "la" Wi-Fi ! Ce n'est peut être pas ce qui consomme le plus et notre domotique fait certainement mieux.... Par contre nombre d'entre nous ont des PC énergivores qui mériteraient de passer en veille. Sauf que dans la pratique on laisse souvent ce PC allumé en se disant que l'on pourra en avoir besoin depuis l'extérieur... Ce que j'ai longtemps fait !

Un PC moderne avec un SSD sait sortir de veille en quelques secondes. Alors pourquoi ne pas ressortit une vieille fonctionnalité très peu utilisée, le Wake on Lan.

Sous Linux, Windows, voire même les mobiles il existe des application GUI ou CLI. Il faut tout de même savoir que Wake on Lan n'a pas été conçu à l'époque pour fonctionner à distance, et même s'il existe des possibilités ça reste compliqué. Alors pourquoi ne pas simplement utiliser Home Assistant qui lui sera toujours disponible, voire même simplement ajouter ça à un ESP existant, sous ESP Home par exemple..

La première chose pour vos tests sera de vérifier en local que le Wake on Lan fonctionne (il y a pas mal d'utilitaires et d'explications sur ce site).

Avec Home Assistant

On commence par ajouter l'intégration au fichier de configuration et on redémarre :

wake_on_lan:

Ensuite on peur créer un switch: , mais aujourd'hui on préfèrera un button: dans Lovelace qui actionnera le service correspondant :

  - action_name: 'Sleep/UnSleep'
    double_tap_action:
      action: call-service
      service: button.press
      target:
        entity_id: button.lia_monitors_off
      action: call-service
      confirmation:
        text: Etes vous sur ?
    tap_action:
      action: call-service
      service: wake_on_lan.send_magic_packet
      data:
        mac: 00-0C-29-FB-77-97
    icon: mdi:microsoft-windows
    name: 'Windows 10 PC'
    type: button

Vous remarquerez que j'ai configuré ça sur le tap_action:, le double_tap_action: étant lui configuré pour la commande de mise en veille via Home Assistant Agent.

Avec ESP Home

J'ai un client full cloud qui dispose d'une douzaine de PC, mais pas de serveur et encore moins de Home Assistant. La première solution était de laisser un PC allumé et y installer de quoi faire du Wake on Lan en remote. Il y a également des possibilités via TeamViewer et hélas pas de base dans l'UDM Pro d'Ubiquiti. On verra ce l'on utilisera mais j'ai également pensé faire ça via un simple ESP qui lui pourrait resté allumé...

Dans ESP Home on va éditer la config et simplement ajouter (attention, ici les séparateurs ne sont pas des "-" mais ":") :

web_server:    

button:
- platform: wake_on_lan
  name: "VM Annia"
  target_mac_address: 00:0C:29:FB:77:97

A partir de là il est possible de presser notre button: qui remonte dans Home Assistant, sur la page web de l'Esp, mais également via la commande curl (la doc est ici) :

curl -X POST http://192.168.210.153/button/vm_annia/press

Et comme on ne va pas demander à l'utilisateur final de faire un "curl" on va lui emballer tout ça dans une page web accessible que l'on sécurisera afin que lui seul puisse y accéder, en partant de cette base :

<HTML>
<center>

	<form name="myform" action="http://192.168.210.153/button/vm_annia/press" method="post">
  	<button>PC Annia ON</button>
	</form>

</center>
</HTML>

Infos

  • Attention, Microsoft a introduit un concept de veille moderne qui souvent demandera à être désactivé. Des infos ici et .
  • Il n'est pas possible de réveiller un PC connecté en Wi-Fi ou en Ethernet via USB.
  • A noter que la Freebox dispose d'une option permettant de laisser passer du Wake on Lan. Ce n'est pas le cas pour tous les routeurs et il faut parfois ruser avec le port 9.

Sources

 

Home Assistant & BLE Proxy

J'entend souvent parler d'esp32, je ne suis pas un crack du fer à souder, ma vue baisse et je ne me lance généralement pas dans des montages au delà de mes compétences. De plus j'aime que ce que je déploie soit maintenable le plus facilement possible par des tiers. Je reste donc dans les standards, par exemple tous mes Shelly ont leur firmware d'origine, là ou ils seraient plus simples à gérer en ESP Home...

Ceci étant, j'aime aussi bricoler et j'avais un problème à résoudre. Si les petits capteurs de température Aqara en Zigbee sont parfaits, pas mal d'utilisateurs ont une préférence pour des sondes avec afficheur. Et le marché ne nous propose quasiment que des sondes afficheur en Bluetooth (BLE), Xiaomi, Aqara, Swithboot, Goovee ou encore InkBird... En général on peut facilement les gérer avec BLE Monitor et un bon dongle Bluetooth. Mais.

Depuis la version 2022.09 Bluetooth est géré nativement dans Home Assistant, il travaillent avec le développeur de BLE Monitor, une intégration qui devrait disparaitre à terme. Dans la pratique tout n'est pour l'instant pas reconnu mais les premiers résultats avec la version intégrée sont très honorables et j'ai obtenu des meilleurs résultats en BLE Proxy qu'avec des dongles USB ou du Bluthoot de base (NUC).

Pour autant se pose toujours le problème de la porté des sondes, dans notre cas d'usage BLE est uni directionnel et l'intégration se contente d'écouter, de décoder les trames et d'intégrer ce qui est exploitable. Sauf que s'il ne reçoit rien il n'intègre rien, et tout le monde sait que la portée du Bluetooth n'est pas phénoménale.

Lors de mes débuts avec HA j'avais essayé avec des potes des passerelles BLE, l'idée était de dédier des RPI Zero judicieusement placés à cet usage. Ca c'était soldé par un échec, certainement trop débutant que nous étions.

Mais avec la release 2022.09 une nouvelle option intégrée à HA a vu le jour : BLE Proxy

L'idée géniale est de se servir d'un module ESP configuré sous ESP Home et disposant du Bluetooth afin de capter les trames et les présenter à HA qui les décode. Et bien sur ce module sera judicieusement placé là ou on a besoin (cave, dépendance, aile gauche du château, etc...), pour peu que l'endroit dispose de Wi-Fi ou à minima d'Ethernet.

Le plus basic

La méthode la plus simple consiste à acheter un ESP-WROOM-32 (ici ou encore moins cher sur Ali), de le connecter au PC en USB après avoir installé les drivers et de le configurer à partir de cette page qui en fin de configuration vous proposera de l'intégrer à Home Assistant. 

Pour ceux qui jouent déjà avec l'add-on ESP Home il est aussi possible d'intégrer directement ce module et d'ajouter le code que vous trouverez ici et qui ressemble à ça :

esphome:
  name: "esp32-ble-proxy"
esp32:
  board: esp32dev
  framework:
    type: arduino
logger:
api:
  encryption:
    key: "AnUMyESfgsfgsdfhgjfjhhjkhg1WJLcGZHTiD7NoOEog="
ota:
  password: "3fb1ee84wgfsdhgsgh46sgh869d9a4856"
wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
  ap:
    ssid: "Ss Fallback Hotspot"
    password: "ws7qfgsfgh6Bl"
captive_portal:
web_server:
dashboard_import:
  package_import_url: github://esphome/bluetooth-proxies/[email protected]
esp32_ble_tracker:
  scan_parameters:
    interval: 1100ms
    window: 1100ms
    active: true
bluetooth_proxy:
button:
- platform: safe_mode
  name: Safe Mode Boot
  entity_category: diagnostic

Une fois que le module est intégré à Home Assistant celui ci décodera les trames et vous proposera les sondes qu'il reçoit. Il est également possible de les ajouter avec leur adresse MAC.

Le plus compact

L'Atom Lite me plait bien (détails ici). D'une part il n'est pas plus gros qu'une pièce de monnaie, et d'autre part il est livré dans un petit boitier plastique ce qui sera toujours plus élégant que le précédent. De plus on peut avec un coupleur USB-A / USB-C le brancher directement sur un chargeur, à défaut un câble court fera l'affaire. On trouve l'Atom Lite sur Ali ou sur le site de son fabricant.

La mise en œuvre est identique, et en bonus on peut piloter la led multicolore qui pourra éventuellement servir à notifier visuellement des états de ce que vous voulez via HA :

light:
  - platform: fastled_clockless
    chipset: WS2812B
    pin: 27
    num_leds: 1
    rgb_order: GRB
    id: status_led
    name: Stack Light
    effects:
      - random:
      - flicker:
      - addressable_rainbow:  

Et comme il expose des ports GPIO rien n'empêche, comme pour les autres de s'en servir pour faire autre chose. Je vous conseille d'ailleurs d'aller explorer l'univers M5STACK ou vous pourrez piocher des idées, comme ce lecteur RFID par exemple....

Le plus complet

L'Olimex (qui s'achète ici) est le plus complet car il dispose en plus du Wi-Fi d'un port Ethernet ce qui permettra de le placer là ou le Wi-Fi est absent. De plus il est disponible dans une version avec antenne externe pour une meilleure réception, ainsi qu'une version industrielle garantie de -40 + 85C. Le sports GPIO sont présents mais il faudra sortit le fer à souder...

Coté configuration c'est identiques au autres. On peut commence par configurer en USB en Wi-Fi et ensuite on active le port Ethernet en mettant à jour en Wi-Fi. Il semble déconseillé d'utiliser le port USB et le port Ethernet en même temps et on ne va pas jouer... Par contre je vous conseille de figer l'adresse affectée par la résa DHCP dans les deux cas car dans le cas contraire ESP Home a un peu de mal à le retrouver via son adresse en .local qui par définition changera.

# wifi:
#   ssid: !secret wifi_ssid
#   password: !secret wifi_password
#   ap:
#     ssid: "Esp-Test Fallback Hotspot"
#     password: "MHPdiJUnJ8i8"
#   use_address: 192.168.210.69
  
ethernet:
  type: LAN8720
  mdc_pin: GPIO23
  mdio_pin: GPIO18
  clk_mode: GPIO17_OUT
  phy_addr: 0
  power_pin: GPIO12
  use_address: 192.168.210.108

Alternatives

Il existe d'autre options que je n'ai pas testé, comme le GL-Inet GL-S10, que je n'ai pas pu me procurer. Dans un petit boitier on a du Wi-FI, de l'Ethernet et une antenne externe pour $ 25.

Usages

En fait tout cela nous ouvre pas mal de portes. Imaginons que je veuille faire des relevés de température / humidité sur un site distant ou il n'y a pas de domotique. J'ai alors le choix d'un ESP du genre Atom Lite sur une prise USB qui va remonter les informations des sondes locale sou Bluetooth vers un site Home Assistant distant qui le verra dès lors que j'ai ouvert le port 6053. Mon ESP communiquera alors via l'API avec Home Assistant comme s'il était local et je pourrais le maintenir, changer sa config et le mettre à jour avec ESPHome. L'alternative consiste à monter MQTT et à le faire communiquer avec un brooker. Ca évite d'avoir un port à ouvrir, mais je ne pourrais plus le maintenir.

On peut échanger ici ou sur HACF.

Home Assistant & Entity Controler

Vous voilà content, vous pouvez allumer, gérer et éteindre votre ampoule via Home Assistant. Je suis sur que vous savez également faire ça via un bouton sans fil, par exemple via ControlerX etc... Mais on peut mieux faire et automatiser en détectant la présence dans une pièce avec quelques lignes et un capteur d'occupation genre Aqara ou Xiaomi... Et pour ça il y a plusieurs méthodes.

EDIT 25/10/2022 : Finalement le problème majeur de Entity Controler est que toute modification impose un redémarrage complet de Home Assistant. J'ai donc basculé sur AD-Automoli qui lui est sous AppDaemon, donc dynamique car les modifications sont prises en compte immédiatement. A considérer également Light Automation pour des éclairages  heures fixes.

L'option classique en YAML

- id: 'fab33b5b-b526-4f6c-a23f-ee98c300012c'
  alias: "PRESENCE : Eclairage Bureau"
  description: ''
  trigger:
    - platform: device
      type: occupied
      id: enter
      device_id: a65b2d5c507be85f0964131f26f8d31e
      entity_id: binary_sensor.motion_bureau_occupancy
      domain: binary_sensor
    - platform: device
      type: not_occupied
      id: leave
      device_id: a65b2d5c507be85f0964131f26f8d31e
      entity_id: binary_sensor.motion_bureau_occupancy
      domain: binary_sensor
  condition:
  action:
    - if:
      - condition: trigger
        id: enter
      then:
        - service: light.turn_on
          data:
            entity_id: light.shellydimmer_db2f18
    - if:
        - condition: trigger
          id: leave
      then:
        - service: light.turn_off
          data:
            entity_id: light.shellydimmer_db2f18

Alternatives

Pour les plus flémards on peu aussi faire ça avec des BluePrint's, ou même en NodeRed si on veut se compliquer la vie (je déteste mais ça vous le savez). Mais j'ai encore plus simple à vous proposer.

Entity Controler

EC pour les intimes. EC est un moteur qui va contrôler des entités (light, switch, scènes, etc...) en fonction d'informations binaires. Donc les sensor: d'entrée seront de détecteurs de présence ou de mouvement, des capteurs d'ouverture ou dans l'absolu n'importe quel binary_sensor: , et pourquoi pas ceux que vous aurez créé dans un usage détourné... A ce contrôle on va bien sur pouvoir appliquer diverses contraintes (horaires, nuit/jour) ou simplement dire que dès lors qu'une lampe s'est allumée automatiquement elle ne s'étendra que manuellement. C'est assez souple et adaptable à quasiment tous les besoins. En tous cas les miens.

Le Git est ici et la doc très complète .

Voici un exemple pour allumer une lampe pendant 180 secondes (durée par défaut) : 3 lignes

motion_light:
  sensor: binary_sensor.motion_sejour
  entity: light.shellydimmer_d3e57c

On peut bien sur régler la durée :

  delay: 320

Faire en sorte que ça ne s'allume que la nuit, avec ici un offset :

  start_time: sunset - 00:30:00
  end_time: sunrise + 00:30:00

Et appliquer des valeurs à la lampe :

  service_data:
    brightness: 255
    color_name: blue
  service_data_on: 
    transition: 5
  service_data_off: 
    transition: 10

Faire en sorte que ça ne s'éteigne pas !

  stay_mode: on

Ou applique une contrainte externe. Ici j'ai mis un input_boolean: mais ça aurait pu être l'état d'une autre lampe, voire un media_player:. A noter que l'on peu également se servir des overrides pour simplement désactiver le contrôle. J'ai par exemple un éclairage extérieur avec des projecteurs que je ne veux pas voir s'allumer quand on dine et que l'éclairage via la guirlande est amplement suffisant et plus agréable.

  overrides:
    - input_boolean.auto_motion_salon

Pareil quand on regarde un film il ne faut pas que l'éclairage se mette en route si on bouge sur le canapé. Pour ça j'ai déjà une automation qui fonctionne sur le play/pause et qui augmente lentement l'éclairage quand je fait pause et inversement (comme au cinéma). Pour l'instant ça ne fonctionne que sur Emby, il faut que je l'intègre à Android TV et EC., je métrais à jour ici quand je le ferait).

Conclusion

Un peu comme ControlerX, voilà de quoi simplifier la chose et gagner des lignes de code. A noter que sous AppDaemon il y Wasp in a Box qui est un peu moins complet ou AD-Automoli qui lui est trop complet...

On peut en discuter ici ou sur HACF.

Home Assistant & Cloudflare Zero Trust

Une fois de plus on va parler de VPN. J'avais ici évoqué Zerotier (gratuit pour 25 nodes) que j'utilise toujours notamment pour interconnecter plusieurs sites entre eux en remplacement d'IPSEC. Ca fonctionne très bien et ça se fait oublier. Entre temps on a découvert Wireguard qui est très performant et peut être utilisé en natif (faut faire le taff) ou via des intégrations comme Tailsacle (entre autres) dont la version gratuite sera suffisante pour bien des usages.

Aujourd'hui on va parler de Cloudflare Zero Trust. Au départ je voulais juste tester sous Home Assistant car cela permet de publier son Home Assistant sans ouvrir de ports sur le routeur, de la même façon que l'on peut le faire si l'on dispose d'un abonnement Nabu Casa. J'ai cet abonnement, mais je ne veux pas l'imposer aux utilisateurs que j'aide.

Si Zero Trust est basé sur Wireguard il n'a rien d'open source. Certains n'aimeront pas quelque chose qui passe par Cloudflare qui comme beaucoup d'acteurs du marché pratique la collecte de donnée. C'est le business de l'époque, d'autres font pire mais ce n'est pas le débat ici, alors épargnez moi vos digressions sur ce sujet, ce n'est pas l'objet. Si vous choisissez cette solution c'est en connaissance de cause. Il existe des alternatives, moins simples à mettre en œuvre.

Zero Trust est un VPN orienté client qui permet notamment deux approches :

  • Publier et sécuriser, sans ouvrir de ports, un (ou plusieurs) site hébergés en premise (premise = chez vous, dans votre entreprise) et le rendre accessible publiquement avec des restrictions qui assureront sa sécurité (MFA) et surtout des restrictions géographiques qui sont quasi impossibles avec les autres solutions, notamment à cause de Let'Encrypt.
  • Rendre accessible des réseaux privés (VPN) en passant par le client Warp de Cloudflare) et ainsi accéder à toutes les machines du réseau (RDP, SMB, SSH, etc...).

Ce qui fait la force de cette solution ce sont les policies qui permettent une très grande granularité. Cloudflare Zero Trust est gratuit jusqu'à 50 utilisateurs. Et dans l'absolu pour sécuriser Home Assistant on a même pas besoin du moindre utilisateur.

Home Assistant

Un Add-on est disponible ici et sa mise œuvre est 'une simplicité enfantine mais il y a une petite subtilité. En effet il y a deux façons pour gérer un tunnel :

  • En local et en CLI
  • Depuis le dashboard de Zero Trust

On part du principe que vous avez un compte Cloudflare et qu'un de vos domaines y est géré. Vous avez également activé Zero Trust. A faire avant toute chose.

Dans les deux cas on ajoute ou modifie le fichier de configuration de Home Assistant ainci :

http:
  use_x_forwarded_for: true
  trusted_proxies:
    - 172.30.33.0/24

Option 1, gestion en local

On installe l'add-on sur Home Assistant, on choisit un host pour Home Assistant, ha.domaine.com par exemple et on lance l'add-on. Il suffit simplement ensuite d'aller copier dans le log l'url de validation et de la copier dans votre navigateur.

Et ça fonctionne, installation du certificat intermédiaire comprise. On pourra ensuite sécuriser et jouer avec les options, la doc de l'add-on est ici et cette  de Zero Trust . Si vous ne pensez pas utiliser Zero Trust pour autre chose c'est la solution la plus simple.

Option 2, gestion en remote

Vu que je compte utiliser Zero Trust à d'autres fin, c'est l'option que j'ai choisit.

  • Dans la console (Access/Tunnels) je crée un nouveau tunnel que ne configure pas.
  • Je copie le token que je viens reporter dans l'add-on et je lance l'add-on
  • Je vais dans le log et je copie l'url de validation que je colle dans le navigateur afin de finaliser l'installation et valider le certificat. 
  • Dans la gestion du tunnel je vais créer un Public Hots Name qui va correspondre à mon serveur et sera exposé avec le nom de domaine choisit :

Votre Home Assistant est maintenant accessible, ici https://test-ha.canaletto.fr (sans le port).

Aller plus loin...

En premier lieu je vous conseille de définir une policie dans Access/Applications afin que votre serveur ne soit accessible que depuis votre pays et surtout pas depuis des états plein de black hat's ...

Ensuite il faut savoir que vous avez installé sur votre serveur une passerelle VPN qui va vous permettre d'accéder à tout votre réseau local en passant par le client Warp. Pour cela il faut dans la configuration du tunnel déclarer un Private Network.

Ensuite dans les SettingsGeneral on va définir le nom de (Team) :

Dans Settings/Network on va changer le mode des tunnels. De base, dès lors que le client Warp est activé, Zero Trust va faire passer tout ce qui ne ressemble pas à une adresse privée dans ses tuyaux, c-a-d tout votre trafic, probablement à des fins de collecte de donnée... On va donc remplacer le mode Exclude par le mode Include et y déclarer uniquement notre réseau privé. Ainsi seul le trafic tunnelisé transitera par Cloudflare, et comme il est dans un tunnel ce sera théoriquement incognito. Je dis théoriquement car dans cette solution ce n'est pas vous mais Cloudflare qui a les clés... Mais nous sommes dans le cadre d'un service de classe entreprise et les CGU garantissent la confidentialité des données...

Dernier point, déclarer une méthode d'authentification. De base une authentification par code PIN est proposée, vous déclarez un domaine ou une adresse mail et vous revenez un code PIN à 6 chiffres qu'il suffit de rentrer... En option il est possible de configurer un SSO en utilisant une authentification que l'on exploite déjà (Azure AD, Centrify, Facebook, GitHub, Google Workspace, Google, LinkedIn, Okta, OneLogin, Saml, OpenID Connect, etc...). Plus complet, mais ça peut répondre à certains besoins en entreprise.

A partir de la on installe le client et on se connecte avec le nom que l'on a défini plus haut. On teste un RDP, SMB ou SSH sur une IP du réseau privé, et ça marche. Ca veut dire qu'à ce stade tout est ouvert dès lors que l'on a connecté le client, pourquoi pas dans le cadre d'une utilisation personnelle, mais je ne saurait trop vous conseiller de tout interdire et de n'autoriser que ce qui est utile (Gateway/Policies/Network).

Cet outil étant avant tout destiné à une utilisation en entreprise les possibilités sont immenses. Pour autant l'administration n'est pas très compliquée, avec quelques connaissance de base dans la gestion des réseaux.

Echanger

J'ai créé un sujet sur HACF, plus pratique qu'ici pour échanger.

 

Home Assistant & ECS

Mon chauffe eau électrique était géré par une automation datant de mes débuts sur Home Assistant. Ca fait le job mais je me disais que je pourrais améliorer la  chose afin de pouvoir ajuster plus facilement la plage horaire et les jours de chauffe. En effet faute d'avoir la température de l'eau (il faudrait y insérer une sonde, et comme je viens de le changer dans l'urgence je veux pas bricoler), bref, quand je suis seul dans la maison chauffer l'eau un jour sur deux est bien suffisant.

Bien sur je pourrait améliorer ça en me basant sur la présence ou non des enfants ou des invités. Mais parfois il faut savoir faire simple...

Interface

Je suis donc parti de l'interface car c'était le but premier. Pouvoir facilement et rapidement changer les heures et jours de chauffe. J'aurais pu me servir du Scheduller (moins pratique d'accès) ou de la nouvelle entité Agenda (pas encore aboutie). J'ai donc fait à ma sauce.

J'utilise quelques composants que vous allez retrouver dans le code de la carte :

type: vertical-stack
cards:
  - type: entities
    entities:
      - entities:
          - entity: automation.ecs_on
            name: false
          - entity: sensor.energy_total_yearly_1pm_ecs
            name: false
            unit: kWh
            format: precision2
          - entity: sensor.pm_ecs_power
            name: false
        entity: switch.pm_ecs
        name: ECS
        icon: mdi:waves
        show_state: false
        state_color: true
        type: custom:multiple-entity-row
  - type: horizontal-stack
    cards:
      - type: custom:button-card
        color_type: card
        entity: input_boolean.ecs_day_monday
        name: Lundi
        show_last_changed: false
        show_state: false
        tap_action:
          action: toggle
        state:
          - value: 'on'
            color: green
            icon: mdi:water-boiler
          - value: 'off'
            color: grey
            icon: mdi:water-boiler-off
        styles:
          card:
            - height: 60px
            - border-radius: 5px
            - font-size: 12px
      - type: custom:button-card
        color_type: card
        entity: input_boolean.ecs_day_tuesday
        name: Mardi
        show_last_changed: false
        show_state: false
        tap_action:
          action: toggle
        state:
          - value: 'on'
            color: green
            icon: mdi:water-boiler
          - value: 'off'
            color: grey
            icon: mdi:water-boiler-off
        styles:
          card:
            - height: 60px
            - border-radius: 5px
            - font-size: 12px
      - type: custom:button-card
        color_type: card
        entity: input_boolean.ecs_day_wednesday
        name: Mercredi
        show_last_changed: false
        show_state: false
        tap_action:
          action: toggle
        state:
          - value: 'on'
            color: green
            icon: mdi:water-boiler
          - value: 'off'
            color: grey
            icon: mdi:water-boiler-off
        styles:
          card:
            - height: 60px
            - border-radius: 5px
            - font-size: 12px
      - type: custom:button-card
        color_type: card
        entity: input_boolean.ecs_day_thursday
        name: Jeudi
        show_last_changed: false
        show_state: false
        tap_action:
          action: toggle
        state:
          - value: 'on'
            color: green
            icon: mdi:water-boiler
          - value: 'off'
            color: grey
            icon: mdi:water-boiler-off
        styles:
          card:
            - height: 60px
            - border-radius: 5px
            - font-size: 12px
      - type: custom:button-card
        color_type: card
        entity: input_boolean.ecs_day_friday
        name: Vendredi
        show_last_changed: false
        show_state: false
        tap_action:
          action: toggle
        state:
          - value: 'on'
            color: green
            icon: mdi:water-boiler
          - value: 'off'
            color: grey
            icon: mdi:water-boiler-off
        styles:
          card:
            - height: 60px
            - border-radius: 5px
            - font-size: 12px
      - type: custom:button-card
        color_type: card
        entity: input_boolean.ecs_day_saturday
        name: Samedi
        show_last_changed: false
        show_state: false
        tap_action:
          action: toggle
        state:
          - value: 'on'
            color: green
            icon: mdi:water-boiler
          - value: 'off'
            color: grey
            icon: mdi:water-boiler-off
        styles:
          card:
            - height: 60px
            - border-radius: 5px
            - font-size: 12px
      - type: custom:button-card
        color_type: card
        entity: input_boolean.ecs_day_sunday
        name: Dimanche
        show_last_changed: false
        show_state: false
        tap_action:
          action: toggle
        state:
          - value: 'on'
            color: green
            icon: mdi:water-boiler
          - value: 'off'
            color: grey
            icon: mdi:water-boiler-off
        styles:
          card:
            - height: 60px
            - border-radius: 5px
            - font-size: 12px
  - type: conditional
    conditions:
      - entity: automation.ecs_on
        state: 'on'
    card:
      type: custom:vertical-stack-in-card
      cards:
        - type: horizontal-stack
          cards:
            - type: markdown
              content: '#### <center> Heure de début'
            - type: markdown
              content: '#### <center> Chauffe Eau'
            - type: markdown
              content: '#### <center> Heure de Fin'
        - type: horizontal-stack
          cards:
            - entity: input_datetime.ecs_start
              type: custom:time-picker-card
              name: Début
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
            - type: glance
              show_state: true
              show_name: false
              entities:
                - switch.pm_ecs
            - entity: input_datetime.ecs_stop
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true

Automation

Bien plus simple que la carte Lovelace. On se base sur des input_datetime:

input_datetime:
  ecs_start:
    has_date: false
    has_time: true
  ecs_stop:
    has_date: false
    has_time: true

Et des input_boolean:

input_boolean:
  ecs_day_monday:
    name: "ECS : Lundi"
    icon: mdi:toggle-switch
  ecs_day_tuesday:
    name: "ECS : Mardi"
    icon: mdi:toggle-switch
  ecs_day_wednesday:
    name: "ECS : Mercredi"
    icon: mdi:toggle-switch
  ecs_day_thursday:
    name: "ECS : Jeudi"
    icon: mdi:toggle-switch
  ecs_day_friday:
    name: "ECS : Vendredi"
    icon: mdi:toggle-switch
  ecs_day_saturday:
    name: "ECS : Samedi"
    icon: mdi:toggle-switch
  ecs_day_sunday:
    name: "ECS : Dimanche"
    icon: mdi:toggle-switch

Et ensuite deux automations, la première pour activer :

- id: '678d0e1-fcb6-4412-abvfr-99c4d37be5aa'
  alias: 'ECS ON'
  trigger:
  - platform: template
    value_template: '{{ states.sensor.time.state == states.input_datetime.ecs_start.state[0:5] }}'
  condition:
    condition: or
    conditions:
      - '{{ (now().strftime("%a") == "Mon") and is_state("input_boolean.ecs_day_monday", "on") }}'
      - '{{ (now().strftime("%a") == "Tue") and is_state("input_boolean.ecs_day_tuesday", "on") }}'
      - '{{ (now().strftime("%a") == "Wed") and is_state("input_boolean.ecs_day_wednesday", "on") }}'
      - '{{ (now().strftime("%a") == "Thu") and is_state("input_boolean.ecs_day_thursday", "on") }}'
      - '{{ (now().strftime("%a") == "Fri") and is_state("input_boolean.ecs_day_friday", "on") }}'
      - '{{ (now().strftime("%a") == "Sat") and is_state("input_boolean.ecs_day_saturday", "on") }}'
      - '{{ (now().strftime("%a") == "Sun") and is_state("input_boolean.ecs_day_sunday", "on")}}'
  action:
  - service: switch.turn_on
    entity_id: switch.pm_ecs

Et une seconde pour désactiver :

- id: 'c69csdfsef-76dd-4fdd-9d20-40bfsdq158ae'
  alias: 'ECS OFF'
  trigger:
  - platform: template
    value_template: '{{ states.sensor.time.state == states.input_datetime.ecs_stop.state[0:5] }}'
  action:
  - service: switch.turn_off
    entity_id: switch.pm_ecs

Home Assistant, ZHA & Legrand

Il existe des devices plus ou moins bien intégrés et c'est le cas du contacteur Legrand 412170 (16A) ou 412171 (20A) qui de base est configuré en HP/HC via le signal fourni par le compteur et ou rien dans l'intégration ne permet à ce jour de la passer en mode on/off.

Vous allez me dire qu'il y est très bien géré en Zigbee2MQTT, ou que je pourrais utiliser quelque chose de moins cher (120 €). Là n'est pas la question, mon client (et ami) ne veut que du Legrand dans son tableau et pour simplifier au maximum je ne veux pas de modules externes, d'où ZHA.

L'intégration du contacteur sous ZHA se fait en appuyant 5 à 8 seconde sur le petit bouton qui passe en rouge. La légende dit que les produits Legrand ne fonctionneraient que sur le canal 11, mon réseau est en 15 et d'autres l'on fait fonctionner en 25...

En cherchant sur la toile je me suis aperçu que nos collègues amateurs de Jeedom avaient réussit à changer les choses via deconz/Phoscon. J'avais donc les valeurs à changer, mais je n'ai pas réussit à les intégrer. 

{"endpoint" : 1,"cluster":64513,"attribute":0,"manufacturer":64513,"name":"Mode","type":"select","values":[{"value":3,"name":"on/off"},{"value":4,"name":"hp/hc"}]},

Sous ZHA en natif on ne peut rien faire sur les clusters à ce niveau. Avec l'excellent ZHA Toolkit il y beaucoup plus de possibilités. Encore fallait t'il bien connaitre le domaine Zigbee afin de trouver le type de valeur d'attribut à configurer. Et là je remercie mdeweerd pour sa gentillesse et sa patience (je vous laisse lire l'échange ici).

Mise en place

Très simple !

  1. On commence par installer ZHA Toolkit
  2. Ensuite il n'y a qu'à lancer cette séquence dans les outils de développement (et on replace la valeur de l'attribut à 4 si on veut revenir au mode HP/HC)
service: zha_toolkit.attr_write
data:
  ieee: 00:04:74:00:00:83:f4:f6
  endpoint: 1
  cluster: 64513
  attribute: 0
  attr_val: [3, 0]
  attr_type: 0x09  # Devrait être facultatif si la lecture précède l'écriture.
  # manf: 4129     # Ne pas définir le fabricant car cela ne semble pas nécessaire dans le cas présent.
  event_done: legrand_done
  write_if_equal: false

Bonus

Sur le même principe il est possible de configurer le comportement de la Led. Ca ne m'a pas intéressé mais voici les valeurs.

    {"endpoint" : 1,"cluster":64513,"attribute":1,"manufacturer":64513,"name":"Led dark","type":"select","values":[{"value":0,"name":"Off"},{"value":1,"name":"On"}]}
    {"endpoint" : 1,"cluster":64513,"attribute":2,"manufacturer":64513,"name":"Led if on","type":"select","values":[{"value":0,"name":"Off"},{"value":1,"name":"On"}]}

Consommation

Pour l'instant l'intégration ne présente que la puissance en W ou A (encore que je n'ai pas testé). Je vais voir quand j'aurais du temps si on peut ajouter le cumul en kWh, mais c'ets toujours possible sous HA avec Reiman ou Powercalc.

J'ai passé pas mal de temps (trop car j'ai aussi un job...) sur cette affaire, mais ça m'a permis d'explorer un peu les possibilité de ZHA Toolkit et comprendre qu'il est possible d'intégrer des objets ou des fonctions non reconnues.

Liens

En vrac, mes sources :

 

Home Assistant, boost ponctuel du chauffage

Ceux qui avaient lu mes articles précédents consacrés à Schedy ont du remarquer que j'avais introduit un mode BOOST qui permettait de débrayer la planification pendant n minutes et ainsi forcer le thermostat d'une pièce pensant x minutes à une température choisie. Dans la pratique on s'aperçoit que ce mode n'a d'intérêt que dans la salle de bain si l'on déroge aux horaires habituel. Et c'est particulièrement mon cas car je n'ai pas d'horaires figés et je peux très bien avoir envie de me doucher à 3 heures du mat avant de me coucher après avoir végété sur mon canapé face au dernier épisode de la série du moment...

Ma salle de bain est donc toujours en ECO et j'ai créé une automation basée sur un timer: qui va faire le déroulé dès lors qu'il sera lancé. Je démarre le timer directement avec un bouton de télécommande via ControllerX, mais il est également possible de configurer ça dans la liste des triggers. La durée du boost est contenue dans un input_nuber: 

aqara_button:
  module: controllerx
  class: WXKG11LMRemoteLightController
  controller: 00:15:8d:00:01:e7:d5:24
  integration: 
    name: deconz
    listen_to: unique_id
  light: light.off
  mapping:
    1002:
      service: timer.finish
      entity_id: timer.shower    
    1004:
      service: timer.start
      data:
        duration: "{{ states('input_number.sdb_boost_time') | int * 60 }}"
        entity_id: timer.shower

Ensuite la liste des courses...

timer:
  shower:
    name: Boost SdB

input_number:
  sdb_boost_good:
    name: Boost Good
    min: 20
    max: 25
    step: 0.5
    unit_of_measurement: °C
  sdb_boost_max:
    name: Boost Max
    min: 23
    max: 28
    step: 0.5
    unit_of_measurement: °C
  sdb_boost_time:
    name: Boost Time
    min: 15
    max: 90
    step: 5

Et ensuite l'automation avec un choose: avec des actions conditionnées par les id: des trigger:, avec pour objectif de :

  • Au démarrage du timer on passe le thermostat du sèche serviette sur BOOST et on allume le radiateur soufflant et on l'annonce.
  • Si le timer est démarré et que la température de confort est atteinte on l'annonce sur une enceinte Sonos. A la douche !
  • Si la durée du timer est terminée ou que la température maximum est atteinte on éteint le radiateur soufflant et on repasse le sèche serviette en mode ECO.
- id : 'c88f056d-8bbc-40ff-a044-a3b1b733e3c8'
  alias: "RC : Boost SdB"
  description: "Boost SdB by chooser"
  trigger:
    - platform: numeric_state
      entity_id: sensor.rpi_mi_t_sdb
      above: input_number.sdb_boost_good
      id: "t_good"
    - platform: numeric_state
      entity_id: sensor.rpi_mi_t_sdb
      above: input_number.sdb_boost_max
      id: "tmax"
    - platform: event
      event_type: timer.finished
      event_data:
        entity_id: timer.shower
      id: "timer.finished"
    - platform: event
      event_type: timer.started
      event_data:
        entity_id: timer.shower
      id: "timer.started"
  condition: []
  action:
    - choose:
        - conditions: # Condition n°1
            - condition: trigger
              id: "timer.started"
          sequence:
            - service: climate.set_preset_mode
              data:
                preset_mode: boost
              target:
                entity_id: climate.thermostat_salle_de_bain
            - service: switch.turn_on
              entity_id: switch.plug_bw_01
            - service: tts.cloud_say
              entity_id: media_player.sonos_cloud_hall
              data_template:
                message: "Préparation de la salle de bain. Je vous dirait quand vous pourrez vous doucher !"
                cache: 'false'
        - conditions: # Condition n°2
            - condition: and
              conditions:
                - condition: trigger
                  id: "timer.started"
                - condition: trigger
                  id: "t_good" # On annonce que la température de confort+ est atteinte
          sequence:
            - service: tts.cloud_say
              entity_id: media_player.sonos_cloud_hall
              data_template:
                message: "La température de la salle de bain est de {{states('sensor.rpi_mi_t_sdb')}}°, vous pouvez vous doucher !"
                cache: 'false'
        - conditions: # Condition n°3
            - condition: or
              conditions:
                - condition: trigger
                  id: "timer.finished" # On arrete de chauffage à la fin du timer
                - condition: trigger
                  id: "t_max"          # On arrete le chauffage si la température max est atteinte.
          sequence:
            - service: switch.turn_off
              entity_id: switch.plug_bw_01
            - service: climate.set_preset_mode
              data:
                preset_mode: eco
              target:
                entity_id: climate.thermostat_salle_de_bain
            - service: tts.cloud_say
              entity_id: media_player.sonos_cloud_hall
              data_template:
                message: "Fin du chauffage de la salle de bain. A bientôt !"
                cache: 'false'
      default:

Rien d'extraordinaire et tout ça reste à affiner selon les besoin de chacun. On peut également ajouter une condition à cette automation pour qu'elle ne s'exécute qu'en hiver en se basant que l'intégration Season. En même temps les saisons ça ne veut plus dire grand chose, donc dans la pratique il vaudra mieux avoir quelque part un input_boolean: qui globalement autorisera ou non les fonctions liés au chauffage. Pour l'anecdote (vécue) ça évitera, que comme la semaine dernière (fin mai), la condition 2 n'annonce à la femme de ménage qu'elle peut se doucher...

A noter que si comme moi vous comptez remplacer Schedy par une automation du genre de ce dont j'ai parlé ici, il faudra prévoir de débrayer l'automatisme en le passant en manuel dans la condition 1 et en automatique dans la condition 3.

- service: input_select.set_options
  data:
    options: Automatique
  target:
    entity_id: input_select.comfort_sdb

Voilà !

 

Home Assistant, nommage, Energy & SAV.

Sous Home Assistant le module Energy est très pratique, mais il est encore un peu jeune. L'objectif ici est de ne pas perdre la continuité des informations si on doit changer un module ou une prise.

Prenons le cas de mon lave linge. Il est branché sur une prise commandée, ce qui me permet de remonter sa consommation. Pas de chance, le relais de cette prise a lâchée et il me faut la changer. Et je ne veux pas perdre la continuité des informations de consommation du module Energy.

Le nommage

Quand on installe une prise ou un module on peut lui donner un nom personnalisé. Chacun sa méthode, mais idéalement, et avec du recul, je conseillerais de donner aux équipements un nom générique lié au matériel et non un nom lié à la fonction. Ainsi au lieu d'avoir switch.lave_linge je vais nommer ma prise Plug BW 03 et ainsi avoir switch.plug_bw_03, sensor.plug_bw_03_energy, etc. Dans certains cas il faudra renommer les entités manuellement mais cela permettra d'avoir une installation propre.

De plus je conseille de maintenir un tableau d'affection des équipements, inutile sur une toute petite installation, mais indispensable quand on a plusieurs douzaines d'équipements. On y renseignera les IP, MAC, Tokens, Key, etc...

Energy

Pour utiliser le module Energy je préconise de passer par des utility_meter:. Dans la pratique ce sont des compteurs. Cette intégration va enregistrer les cumuls de consommation et c'est celui ci que l'on va déclarer dans le module Energy. Avant cela se faisait via le fichier de configuration en yaml. Depuis quelques releases on peut créer des UM depuis l'interface GUI et même modifier ensuite le Friendly Name (celui apparaitra dans Lovelace ou le module Energy) et même la source.

Je vais donc nommer mon compteur sensor.energy_total_yearly_plug_bw_03, avec comme Frienly Name Lave Linge et l'ajouter au module Energy. Et surtout il y restera, faute de quoi le module Energy perdrait l'historique des données.

En cas de problème avec une source de consommation, il est maintenant possible de changer celle ci en cliquant sur le bouton options. Ca n'a pas toujours été le cas, notamment en yaml ou il m'est arrivé de perdre des données.

Pour être sur d'assurer la continuité quand on doit remplacer un équipement, le plus simple est de supprimer l'ancien (ou le renommer) avant d'appairer le nouveau. Et ensuite de vérifier que le nouveau a bien toutes les entités avec le même nommage que le précédent, en ajustant le cas échéant.

Parfois il sera impossible de supprimer un module dans Home Assistant et il faudra taper dans le dur (fichiers cachés...), comme par exemple ce qui remonte de Deconz ou même en supprimant un module dans Phoscon celui-ci ne disparait pas toujours de HA tant que l'on aura pas supprimé l'intégration... (il y a un contournement qui consiste à appairer le module en ZHA, le supprimer de ZHA, ce qui le supprimera de ZHA et Deconz, et ensuite le réappairer. Tordu, mais ça fonctionne).

 

Home Assistant, timers & choose

Il y a bientôt deux ans, peu après mes débuts sous Home Assistant, j'ai mis en place un scénario de confort pour la douche. En gros la salle de bain est toujours en mode ECO et quand je souhaite prendre une douche j'appuie sur un bouton, ça lance le chauffage et un radiateur soufflant et ça l'éteint au bout d'un moment.

Aujourd'hui j'ai voulut l'améliorer afin de le lancer quand je dois me lever à une heure fixe, ce qui heureusement est plutôt rare. J'ai donc fait une automation qui se déclenche à partir d'un input_datetime: qui va chauffer la salle de bain, lancer la clim en mode chauffage via un script de dérogation de Schedy, éclairer quelques lampes et ouvrir quelques volets. Rien d'extraordinaire à ce stade et il faudrait y ajouter de la musique et allumer la bouilloire pour le thé....

automation:
- id: 'fab3sdfty-bgg6-4ddc-a23f-ee589300012c'
  alias: "RC : Réveil + douche"
  description: ''
  trigger:
    platform: time
    at: input_datetime.alarm_clock_date_time
  condition:
  action:
  - service: timer.start              # On lance le chauffage de la SdB
    data:
      duration: 00:25:30
    target:
      entity_id: timer.shower
  - service: input_boolean.turn_off   # On passe en mode jour (utile pour le chauffage)
    target:
      entity_id: input_boolean.to_sleep 
  - service: script.heating_ac_boost
  - delay: 00:10:00                   # On se prélasse encore un peu au lit...
  - service: cover.set_cover_position # On entreouvre le volet de la chambre
    data:
      position: 22
    target:
      entity_id:
        - cover.vr_lionel
  - service: cover.set_cover_position # On ouvre le volet de la cuisine
    data:
      position: 60
    target:
      entity_id:
        - cover.vr_cuisine      
  - service: light.turn_on            # On allume quelques lampes
    data:
      color_name: yellowgreen
    target:
      entity_id: light.groupe_d_ampoules_led

Là ou ça va devenir intéressant c'est que j'ai refondu mes automations de douche en une seule qui va utiliser un timer: et la fonction choose:. Je n'avais jamais utilisé de timer et encore moins le chooser, j'ai donc un peu galéré, mais voici le résultat, largement simplifié avec les trigger_id:, ce qui évite des templates...

automation:
- id : 'c88f056d-8bbc-40ff-a044-a3b1b733e3c8'
  alias: "RC : Boost SdB"
  description: "Boost SdB by chooser"
  trigger:
    - platform: numeric_state
      entity_id: sensor.rpi_mi_t_sdb
      above: input_number.sdb_boost_good
      id: "t_good"
    - platform: numeric_state
      entity_id: sensor.rpi_mi_t_sdb
      above: input_number.sdb_boost_max
      id: "tmax"
    - platform: event
      event_type: timer.finished
      event_data:
        entity_id: timer.shower
      id: "timer.finished"
    - platform: event
      event_type: timer.started
      event_data:
        entity_id: timer.shower
      id: "timer.started"
  condition: []
  action:
    - choose:
        - conditions:
            - condition: trigger
              id: "timer.started" # Mode ON sur la base su timer qui est lancé depuis une télécommande ou une autre automation
          sequence:
            - service: climate.set_preset_mode
              data:
                preset_mode: boost
              target:
                entity_id: climate.thermostat_salle_de_bain
            - service: switch.turn_on
              entity_id: switch.plug_bw_01
            - service: notify.slack_hass_canaletto
              data:
                message: "{{now().strftime('%d/%m/%Y, %H:%M')}} > BOOST | START | Salle de bain | Température : {{ states('sensor.rpi_mi_t_sdb') }}°"
            - service: tts.cloud_say
              entity_id: media_player.sonos_cloud_hall
              data_template:
                message: "Préparation de la salle de bain. Je vous dirait quand vous pourrez vous doucher !"
                cache: 'false'
        - conditions:
            - condition: trigger
              id: "t_good" # On annonce que la température de confort+ est atteinte
          sequence:
            - service: tts.cloud_say
              entity_id: media_player.sonos_cloud_hall
              data_template:
                message: "La température de la salle de bain est de {{states('sensor.rpi_mi_t_sdb')}}°, vous pouvez vous doucher !"
                cache: 'false'
            - service: notify.slack_hass_canaletto
              data:
                message: "{{now().strftime('%d/%m/%Y, %H:%M')}} > BOOST | READY | Salle de bain | Température : {{ states('sensor.rpi_mi_t_sdb') }}°"
        - conditions:
            - condition: or
              conditions:
                - condition: trigger
                  id: "timer.finished" # On arrete de chauffage à la fin du timer
                - condition: trigger
                  id: "t_max"          # On arrete le chauffage si la température max est atteinte.
          sequence:
            - service: switch.turn_off
              entity_id: switch.plug_bw_01
            - service: climate.set_preset_mode
              data:
                preset_mode: eco
              target:
                entity_id: climate.thermostat_salle_de_bain
            - service: notify.slack_hass_canaletto    
              data:
                message: "{{now().strftime('%d/%m/%Y, %H:%M')}} > BOOST | END | Salle de bain | Température : {{ states('sensor.rpi_mi_t_sdb') }}°"
            - service: tts.cloud_say
              entity_id: media_player.sonos_cloud_hall
              data_template:
                message: "Fin du chauffage de la salle de bain. A bientôt !"
                cache: 'false'
      default:

Le log dans Slack me sert au debug. Le TTS via l'intégration Sonos Cloud permet de baisser la musique et de la réactiver une fois l'annonce terminée.

On notera également que par défaut les conditions du chooser son and et qu'il est possible de les passer en or.

Si aucun trigger n'est utilisé on peut également définir une action par défaut. J'ai fait le choix de ne pas l'utiliser et d'activer ou désactiver le chauffage en lançant le timer pour une certaine durée, depuis un bouton (via ControlerX ou un BluePrint) ou l'automation du réveil : 

  - service: timer.start
    data:
      duration: 00:25:30
    target:
      entity_id: timer.shower

ou en forçant sa fin...

  - service: timer.finish
    target:
      entity_id: timer.shower

Et pour paramétrer une ligne sur Lovelace, à noter que j'ai oublié d'intégrer un template pour la durée dans les commandes ci dessus.

 

Home Assistant & Keypad

Notre serveur domotique préféré inclus un système de sécurité intrusion, communément appelé alarme. Attention, c'est du DIY, ça fait le job, mais ça ne répond pas aux normes en vigueur :

Les systèmes d'alarmes sont évalués en fonction de divers critères donnant lieu à l'attribution d'une certification appelée "norme alarme". En France, les alarmes sont certifiées par le CNPP, qui leur attribue des normes : NFA2P bouclier 1, NFA2P bouclier 2, NFA2P bouclier 3, suivant le degré de sécurité. Au niveau européen, il existe également une norme alarme : la norme EN 50131.

Ceci étant posé, rappelons de Home Assistant intègre un panneau d'alarme basic que l'intégration Alarmo vient avantageusement compléter, et dans l'absolu ça fait mieux que beaucoup de produit du marché.

Pour une bonne efficacité on part du principe que l'installation Home Assistant est fiable et secourue par un UPS.

Dans cet article je ne vais pas détailler le fonctionnement de cette alarme mais m'intéresser aux différentes façons de l'activer / désactiver :

  • Via l'application mobile : facile, mais fastidieux à l'usage. Tous les occupants ne disposent pas nécessairement de l'application mobile Home Assistant.
  • Avec un bouton ou une télécommande : facile, mais il faut transporter l'objet et les distribuer.
  • Avec un badge ou tag RFID sur un lecteur : lecteur esp32 à configurer, il faut transporter l'objet. Facile à distribuer et à révoquer.
  • Avec un badge et un téléphone mobile : facile et sécurisé, il faut enregistrer au préalable les mobiles qui devront disposer de l'application Home Assistant..
  • Avec un clavier numérique : le mode classique et universel, changement des codes faciles, encore faut t'il trouver un clavier, et c'est l'objet de cet article.

Un keypad Zigbee compatible

Il y a quelques jours j'ai vu passer une vidéo qui parle d'un kit alarme Linkind qui utlise Zigbee. Ce kit est composé d'une sirène qui est en fait un hub Zigbee qui se connecte au cloud du fabricant chinois pour gérer l'ensemble, d'un clavier et de quelques détecteurs. L'auteur de la vidéo à utilisé zigbee2mqtt et Node Red (je n'aime pas) pour l'intégrer à Home Assistant, moi je vais essayer de faire ça via ZHA.

J'ai commandé ce kit chez Amazon (28 €) en me disant qu'au pire ce serait un retour de plus, mon idée étant d'utiliser le clavier. Il y a des travaux en cours sur le Hub / Sirène mais c'est loin d'être aboutit. En ce qui concerne les capteurs il est possible de les associer via ZHA (ou z2m et Deconz).

Premier problème que je n'ai pas résolu, le code (1234 par défaut) qui se change via l'application du constructeur. Sauf que quand on l'intègre avec ZHA ça passe par un reset et on se retrouve avec le code par défaut. Bref un clavier avec comme code 1234 ça ne servirait pas à grand chose. Mais il y a une astuce, et la voici : (et une info à la fin de cet article)

Quand on entre une information sur le clavier, celle ci est envoyée à Home Assistant via ZHA (ça doit fonctionner à l'identique avec Deconz, sauf que pour l'instant il n'est pas reconnu) et on peut la récupérer via les "events". Voici un exemple si je saisit Disarm + 1234 + Valid sur ce clavier :

{
    "event_type": "zha_event",
    "data": {
        "device_ieee": "69:0a:x2:ff:fe:xa:x8:22",
        "unique_id": "69:0a:e2:xf:xe:xa:88:2x:1:0x05xx",
        "device_id": "c036fgqd qfdqs56hshs56shsdd06152267ab",
        "endpoint_id": 1,
        "cluster_id": 1281,
        "command": "arm",
        "args": {
            "arm_mode": 0,
            "arm_mode_description": "Disarm",
            "code": "1111",
            "zone_id": 0
        }
    },
    "origin": "LOCAL",
    "time_fired": "2022-02-21T23:27:45.169891+00:00",
    "context": {
        "id": "edada8770ddfd7045b1835acb0888bad",
        "parent_id": null,
        "user_id": null
    }
}

A partir de là il est facilement possible de traiter cette information dans une automation et de générer une action, ici un message :

automation:
- alias: Keypad Test
  description: 'Triggers an Event When code 1111 is entered into any keypad.
  trigger:
    - platform: event
      event_type: zha_event
      event_data:
        command: 'arm'
        args:
          arm_mode: 0
          arm_mode_description: 'Disarm'
          code: '1111'
          zone_id: 0
  condition: []
  action:
    - service: notify.slack_hass_canaletto
      data:
        message: "{{now().strftime('%d/%m/%Y, %H:%M:%S')}} > ENTER HOME | Code 1111 | State : {{ states.alarm_control_panel.alarmo.state }}"

Et là ou ça devient intéressant, c'est que l'on peut saisir n'importe quoi et que ça sera toujours remonté via un event. A partir de là on peu faire passer tous les codes possibles via 2 pseudos modes d’armement, voire même le disarm.

  • Arm_All_Zones
  • Arm_Day_Home_Only

Bon c’est un peu du bricolage… mais ça fait le taff. Dans la pratique, de base le désarmement demande le code enregistré dans le clavier (1234 par défaut) on peu armer les deux modes à la volée avec n'importe quel code, par exemple :

Touche Arm Home + 4444 + Valid va envoyer un event avec :

"args": {
            "arm_mode": 1,
            "arm_mode_description": "Arm_Day_Home_Only",
            "code": "4444",
            "zone_id": 0

Touche Arm Away + 5555 + Valid va envoyer un event avec :

"args": {
            "arm_mode": 3,
            "arm_mode_description": "Arm_All_Zones",
            "code": "5555",
            "zone_id": 0

A partir de là on interprète le code avec une automation et on lui fait faire ce que l’on veut très simplement.

automation:
  alias: Keypad Test
  description: 'Triggers an Event When code 1111 is entered into any keypad.'
  trigger:
    - platform: event
      event_type: zha_event
      event_data:
        command: 'arm'
        args:
          arm_mode: 0
          arm_mode_description: 'Disarm'
          code: '1111'
          zone_id: 0
  condition: []
  action:
  - service: alarm_control_panel.alarm_disarm
    data:
      code: !secret alarm_code
    entity_id: alarm_control_panel.alarmo
  - service: alarm_control_panel.alarm_disarm
    data:
      code: !secret alarm_code_visonic
    entity_id: alarm_control_panel.visonic_alarm
  - service: notify.slack_hass_canaletto
    data:
      message: "{{now().strftime('%d/%m/%Y, %H:%M:%S')}} > ENTER HOME | DISARM ALARM's | State : {{ states.alarm_control_panel.alarmo.state }}" 

Bonus

Rester appuyé 3 secondes sur SOS, ça active le Panel alarme Linkind dans HA et on peut traiter l'information.

Edit 05/07/2022

Je ne m'étais pas repenché sur la question de ce code 1234 par défaut depuis l'écriture de cet article. Mais Aurel RV a creusé un peu plus et à découvert par hasard que ZHA sait gérer ce code par défaut. Depuis quand je ne sais pas.

Le clavier étant vu comme un panneau de contrôle d'alarme, on pourra interagir avec Alarmo ou continuer à se servir des autres codes vie les events pour commander d'autres actions...

Conclusion

Ce résultat n'est pas totalement satisfaisant (mais qui le devient depuis que ZHA gère ce code), mais ça permet de faire passer les bons codes à Alarmo et c'est utilisable. De plus on peut utiliser d'autres codes pour déclencher d'autres actions, ouvrir un portail, allumer des projecteurs, etc....