Home Assistant, planification, encore...

J'ai souvent parlé de planification des convecteurs et du climatiseur. Depuis un an je tourne sur deux installations avec ce dont j'avais parlé ici en utilisant le moteur de planification Schedy. Schedy était très bien en son temps et il palliait à des lacunes de Home Assistant. Mais il y a quelques restrictions et son auteur ne le fait plus évoluer. En fait ça se comprend car on peut maintenant à peu près faire la même chose avec le mode choose: et quelques lignes de yaml, et ainsi supprimer une dépendance à un outil externe. Et plus c'est simple, moins il y a de chances de dysfonctionnements.

Je vais donc changer de moteur, par contre je vais réutiliser toutes les entités que j'avais crée pour Schedy, ce qui dans l'absolu en fait une solution réversible. Attention, cet article a été remanié, donc si vous vous étiez inspiré de la première version il sera judicieux de repartir à zéro...

Voici donc ce que j'ai fait pour le climatiseur, plus complexe qu'un simple radiateur car on va gérer les modes chauffage et refroidissement ainsi que le débrayage en manuel.

input_select:
  comfort_ac:
    name: Modes du climatiseur
    icon: mdi:form-select
    options:
      - Refroidissement
      - Chauffage
      - Manuel
      - "Off"

On va utiliser deux automations par pièce ou appareil, la première va gérer les multiples déclencheurs (trigger:), les modes (input_select:) et surtout les exclusions liées au mode de vie (absence de courte ou longue durée, sommeil, fenêtres ouvertes, etc...

Si aucune exclusion n'est validée et selon le mode en cours on lance la seconde automation dans le mode sélectionné. Si on est en mode Manuel, on ne fait rien, mais la seconde automation ne s'exécutera pas.

- id: 56ee275e-3f52-4d88-a862-5e21f5708a82
  description: Comfort - AC - Immediate
  alias: "Comfort - AC - Immediate"
  mode: restart
  trigger:
    - platform: state
      entity_id:
        - input_number.heating_ac_temperature_confort_1
        - binary_sensor.heating_ac_1
        - input_boolean.to_away
        - binary_sensor.life_windows_and_doors_delayed
        - input_boolean.to_sleep
        - binary_sensor.lionel_geo
        - input_select.comfort_ac
        - [...] ⚠️ A compléter 
  condition:
  action:
    - choose:
        - conditions: # 0 OFF
            - condition: or
              conditions:
                - "{{ is_state('binary_sensor.life_windows_and_doors_delayed', 'on') }}"
                - "{{ is_state('input_select.comfort_ac', 'Off') }}"
                - "{{ is_state('input_boolean.presence_ac', 'off') }}"
          sequence:
            - service: climate.set_hvac_mode
              data:
                hvac_mode: 'off'
              target:
                entity_id: climate.daikin

        - conditions: # 01 - COOL OFF
            - condition: or
              conditions:
                - "{{ is_state('input_boolean.thermostats_away', 'on') }}"
                - "{{ is_state('input_boolean.to_away', 'on') }}"
                - "{{ is_state('binary_sensor.lionel_geo', 'off') }}"
            - condition: 
                - "{{ is_state('input_select.comfort_ac', 'Refroidissement') }}"
          sequence:
            - service: climate.set_hvac_mode
              data:
                hvac_mode: 'off'
              target:
                entity_id: climate.daikin

        - conditions:  # 02 - COOL SLEEP
            - "{{ is_state('input_boolean.to_sleep', 'on') }}"
            - "{{ is_state('input_select.comfort_ac', 'Refroidissement') }}"
          sequence:
            - service: climate.set_hvac_mode
              data:
                hvac_mode: 'cool'
              target:
                entity_id: climate.daikin
            - service: climate.set_temperature
              data:
                temperature: "{{ states('input_number.heating_ac_temperature_eco') }}"
              target:
                entity_id: climate.daikin                

        - conditions:  # 03 - HEAT ECO
            - condition: or
              conditions:
                - "{{ is_state('input_boolean.to_away', 'on') }}"
                - "{{ is_state('input_boolean.to_sleep', 'on') }}"
                - "{{ is_state('binary_sensor.lionel_geo', 'off') }}" # input_boolean.presence_lionel_geo
            - condition: 
                - "{{ is_state('input_select.comfort_ac', 'Chauffage') }}"
          sequence:
            - service: climate.set_hvac_mode
              data:
                hvac_mode: 'heat'
              target:
                entity_id: climate.daikin
            - service: climate.set_temperature
              data:
                temperature: "{{ states('input_number.heating_ac_temperature_eco') }}"
              target:
                entity_id: climate.daikin

        - conditions: # 04 - HEAT AWAY
            - "{{ is_state('input_boolean.thermostats_away', 'on') }}"
            - "{{ is_state('input_select.comfort_ac', 'Chauffage') }}"
          sequence:
            - service: climate.set_hvac_mode
              data:
                hvac_mode: 'heat'
              target:
                entity_id: climate.daikin
            - service: climate.set_temperature
              data:
                temperature: "{{ states('input_number.heating_ac_temperature_away') }}"
              target:
                entity_id: climate.daikin

      default:
        - choose:
            - conditions: "{{ is_state('input_select.comfort_ac', 'Refroidissement') }}"
              sequence:
                - service: climate.set_hvac_mode
                  data:
                    hvac_mode: 'cool'
                  target:
                    entity_id: climate.daikin
                - service: automation.trigger
                  target:
                    entity_id: "automation.comfort_ac"

            - conditions: "{{ is_state('input_select.comfort_ac', 'Chauffage') }}"
              sequence:
                - service: climate.set_hvac_mode
                  data:
                    hvac_mode: 'heat'
                  target:
                    entity_id: climate.daikin
                - service: automation.trigger
                  target:
                    entity_id: "automation.comfort_ac"

La seconde automation sert à ajuster la température de consigne, elle est appelée par la première pour une action immédiate et se relancera également toutes les 10 minutes afin de rattraper une action non exécutée, un redémarrage ou un actionneur qui n'a pas fait son travail. Ca compense la replanification qui faisait la force de Schedy.

Qu'elle soit appelée par la première ou qu'elle s'exécute via le time_pattern: il ne se passera rien si toutes (and: par défaut) les conditions ne sont pas remplies (les contraintes gérées dans la première automation). A noter que je place les conditions après action: afin que ces conditions soient prises en compte même si cette automation est lancée manuellement.

Si aucune des conditions liées aux plages horaires actives n'est remplie (plages horaires définies par des binary_sensor: dans le précédent article), alors l'action par défaut passe le thermostat en mode ECO.

automation:
- id: 0ff7454c-4592-4479-b2ae-40eaf3043853
  description: Comfort - AC
  alias: "Comfort - AC"
  mode: restart
  trigger:
    - platform: time_pattern
      minutes: "/10"
  condition:
  action:
    - condition:
        - "{{ not states('input_select.comfort_ac') in ('Manuel', 'Off') }}"
        - "{{ is_state('binary_sensor.life_windows_and_doors_delayed', 'off') }}"
        - "{{ is_state('binary_sensor.lionel_geo', 'on') }}"
        - "{{ is_state('input_boolean.thermostats_away', 'off') }}"
        - "{{ is_state('input_boolean.presence_ac', 'on') }}"
        - "{{ is_state('input_boolean.to_away', 'off') }}"
        - "{{ is_state('input_boolean.to_sleep', 'off') }}"
    - choose:
        - conditions: "{{ is_state('binary_sensor.heating_ac_1', 'on') }}" # Plages horaires
          sequence:
            - service: climate.set_temperature
              data:
                temperature: "{{ states('input_number.heating_ac_temperature_confort_1') }}"
              target:
                entity_id: climate.daikin
        - conditions:  [...] ⚠️ A Compléter
      default:
        - choose:
            - conditions:
              sequence:
                - service: climate.set_temperature
                  data:
                    temperature: "{{ states('input_number.heating_ac_temperature_eco') }}"
                  target:
                    entity_id: climate.daikin

Et enfin l'automation qui gère le mode Manuel / Auto : Si on passe en manuel on désactive l'automation et j'ai fait le choix de passer le thermostat en off. Il est bien sur possible de le réactiver, mais il ne sera plus géré par la planification.

- id: 56dd275e-3f52-4d8ffa862-sejour
  description: Comfort - Sejour - Mode Auto
  alias: "Comfort - Sejour - Mode Auto"
  trigger:
    - platform: state
      entity_id: automation.comfort_sejour_immediate
      to: "on"
      id: "on"
    - platform: state
      entity_id: automation.comfort_sejour_immediate
      to: "off"
      id: "off"
  action:
    - choose:
        - conditions: "{{ trigger.id in ['on', 'xx'] }}"
          sequence:
            - service: automation.trigger
              target:
                entity_id: "automation.comfort_sejour_immediate"
    - choose:
        - conditions: "{{ trigger.id in ['off', 'xx'] }}"
          sequence:
            - service: climate.set_hvac_mode
              data:
                hvac_mode: "off"
              target:
                entity_id: climate.thermostat_sejour

Voilà, c'est finalement assez simple et il suffira ensuite de reproduire pour les autres pièces. Je vous conseille d'utiliser un fichier par pièce dans les packages. Les miens sont ici sur GitHub.

Un grand merci à Fabien, Mathieu et Philipp m'ont ouvert les yeux sur les possibilités offertes par choose: et leur patience quand je sèche sur les templates...

Bonus :

La carte avec tous les modes : (je sais c'est long, à dupliquer selon le nombre de convecteurs).

type: vertical-stack
cards:
  - type: custom:simple-thermostat
    entity: climate.thermostat_sejour
    layout:
      mode:
        icons: true
        headings: false
        names: true
      step: row
    hide:
      temperature: true
      state: true
    sensors:
      - entity: sensor.mi_sejour_temp
        icon: mdi:thermometer
      - entity: binary_sensor.state_openings_life
        icon: mdi:door
      - entity: sensor.sejour_puissance
        icon: mdi:lightning-bolt
    header:
      toggle:
        entity: automation.comfort_sejour_immediate
        name: Manuel/Auto
      name: Bureau
    control:
      - hvac
  - type: history-graph
    entities:
      - entity: switch.sw13_sejour_1
        name: ' '
    hours_to_show: 24
    refresh_interval: 0
  - type: conditional
    conditions:
      - entity: automation.comfort_sejour_immediate
        state: 'on'
    card:
      type: entities
      entities:
        - entities:
            - entity: input_boolean.heating_sejour_enabled_1
              name: NUIT
              toggle: true
            - entity: input_boolean.heating_sejour_enabled_2
              name: MATIN
              toggle: true
            - entity: input_boolean.heating_sejour_enabled_3
              name: MIDI
              toggle: true
            - entity: input_boolean.heating_sejour_enabled_4
              name: SOIR
              toggle: true
          entity: climate.thermostat_sejour
          name: Semaine
          show_state: false
          toggle: false
          icon: mdi:calendar-range
          type: custom:multiple-entity-row
          state_color: true
        - entities:
            - entity: input_boolean.heating_sejour_enabled_1_d
              name: NUIT
              toggle: true
            - entity: input_boolean.heating_sejour_enabled_2_d
              name: MATIN
              toggle: true
            - entity: input_boolean.heating_sejour_enabled_3_d
              name: MIDI
              toggle: true
            - entity: input_boolean.heating_sejour_enabled_4_d
              name: SOIR
              toggle: true
          entity: climate.thermostat_sejour
          name: Week-End
          show_state: false
          toggle: false
          icon: mdi:calendar-range
          type: custom:multiple-entity-row
          state_color: true
        - entities:
            - entity: input_number.heating_sejour_temperature_eco
              type: custom:numberbox-card
              icon_plus: mdi:chevron-up
              icon_minus: mdi:chevron-down
            - entity: input_number.heating_sejour_temperature_away
              type: custom:numberbox-card
              icon_plus: mdi:chevron-up
              icon_minus: mdi:chevron-down
            - entity: binary_sensor.life_windows_and_doors_delayed
            - label: Présence dans la pièce
              type: section
            - entity: input_boolean.presence_sejour
              name: Présence
              show_state: true
            - entity: input_datetime.next_sejour_start
              type: custom:multiple-entity-row
              format: datetime
              name: Arrivée
            - entity: input_datetime.next_sejour_stop
              type: custom:multiple-entity-row
              format: datetime
              name: Départ
          head:
            label: OPTIONS >
            type: section
          padding: 30
          type: custom:fold-entity-row
      title: PLANIFICATION
      show_header_toggle: false
      state_color: true
  - type: conditional
    conditions:
      - entity: input_boolean.heating_sejour_enabled_1
        state: 'on'
      - entity: automation.comfort_sejour_immediate
        state: 'on'
    card:
      type: custom:vertical-stack-in-card
      title: Séjour / Semaine / Nuit
      cards:
        - entity: input_number.heating_sejour_temperature_confort_1
          type: custom:numberbox-card
          icon_plus: mdi:chevron-up
          icon_minus: mdi:chevron-down
          name: Température de confort
          icon: false
        - type: horizontal-stack
          cards:
            - entity: input_datetime.heating_sejour_start_1
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
            - type: glance
              show_state: false
              entities:
                - binary_sensor.heating_sejour_1
            - entity: input_datetime.heating_sejour_end_1
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
  - type: conditional
    conditions:
      - entity: input_boolean.heating_sejour_enabled_2
        state: 'on'
      - entity: automation.comfort_sejour_immediate
        state: 'on'
    card:
      type: custom:vertical-stack-in-card
      title: Séjour / Semaine / Matin
      cards:
        - entity: input_number.heating_sejour_temperature_confort_2
          type: custom:numberbox-card
          icon_plus: mdi:chevron-up
          icon_minus: mdi:chevron-down
          name: Température de confort
          icon: false
        - type: horizontal-stack
          cards:
            - entity: input_datetime.heating_sejour_start_2
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
            - type: glance
              show_state: false
              entities:
                - binary_sensor.heating_sejour_2
            - entity: input_datetime.heating_sejour_end_2
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
  - type: conditional
    conditions:
      - entity: input_boolean.heating_sejour_enabled_3
        state: 'on'
      - entity: automation.comfort_sejour_immediate
        state: 'on'
    card:
      type: custom:vertical-stack-in-card
      title: Séjour / Semaine / Midi
      cards:
        - entity: input_number.heating_sejour_temperature_confort_3
          type: custom:numberbox-card
          icon_plus: mdi:chevron-up
          icon_minus: mdi:chevron-down
          name: Température de confort
          icon: false
        - type: horizontal-stack
          cards:
            - entity: input_datetime.heating_sejour_start_3
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
            - type: glance
              show_state: false
              entities:
                - binary_sensor.heating_sejour_3
            - entity: input_datetime.heating_sejour_end_3
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
  - type: conditional
    conditions:
      - entity: input_boolean.heating_sejour_enabled_4
        state: 'on'
      - entity: automation.comfort_sejour_immediate
        state: 'on'
    card:
      type: custom:vertical-stack-in-card
      title: Séjour / Semaine / Soir
      cards:
        - entity: input_number.heating_sejour_temperature_confort_4
          type: custom:numberbox-card
          icon_plus: mdi:chevron-up
          icon_minus: mdi:chevron-down
          name: Température de confort
          icon: false
        - type: horizontal-stack
          cards:
            - entity: input_datetime.heating_sejour_start_4
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
            - type: glance
              show_state: false
              entities:
                - binary_sensor.heating_sejour_4
            - entity: input_datetime.heating_sejour_end_4
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
  - type: conditional
    conditions:
      - entity: input_boolean.heating_sejour_enabled_1_d
        state: 'on'
      - entity: automation.comfort_sejour_immediate
        state: 'on'
    card:
      type: custom:vertical-stack-in-card
      title: Séjour / Week-End / Nuit
      cards:
        - entity: input_number.heating_sejour_temperature_confort_1_d
          type: custom:numberbox-card
          icon_plus: mdi:chevron-up
          icon_minus: mdi:chevron-down
          name: Température de confort
          icon: false
        - type: horizontal-stack
          cards:
            - entity: input_datetime.heating_sejour_start_1_d
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
            - type: glance
              show_state: false
              entities:
                - binary_sensor.heating_sejour_1_d
            - entity: input_datetime.heating_sejour_end_1_d
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
  - type: conditional
    conditions:
      - entity: input_boolean.heating_sejour_enabled_2_d
        state: 'on'
      - entity: automation.comfort_sejour_immediate
        state: 'on'
    card:
      type: custom:vertical-stack-in-card
      title: Séjour / Week-End / Matin
      cards:
        - entity: input_number.heating_sejour_temperature_confort_2_d
          type: custom:numberbox-card
          icon_plus: mdi:chevron-up
          icon_minus: mdi:chevron-down
          name: Température de confort
          icon: false
        - type: horizontal-stack
          cards:
            - entity: input_datetime.heating_sejour_start_2_d
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
            - type: glance
              show_state: false
              entities:
                - binary_sensor.heating_sejour_2_d
            - entity: input_datetime.heating_sejour_end_2_d
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
  - type: conditional
    conditions:
      - entity: input_boolean.heating_sejour_enabled_3_d
        state: 'on'
      - entity: automation.comfort_sejour_immediate
        state: 'on'
    card:
      type: custom:vertical-stack-in-card
      title: Séjour / Week-End / Midi
      cards:
        - entity: input_number.heating_sejour_temperature_confort_3_d
          type: custom:numberbox-card
          icon_plus: mdi:chevron-up
          icon_minus: mdi:chevron-down
          name: Température de confort
          icon: false
        - type: horizontal-stack
          cards:
            - entity: input_datetime.heating_sejour_start_3_d
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
            - type: glance
              show_state: false
              entities:
                - binary_sensor.heating_sejour_3_d
            - entity: input_datetime.heating_sejour_end_3_d
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
  - type: conditional
    conditions:
      - entity: input_boolean.heating_sejour_enabled_4_d
        state: 'on'
      - entity: automation.comfort_sejour_immediate
        state: 'on'
    card:
      type: custom:vertical-stack-in-card
      title: Séjour / Week-End / Soir
      cards:
        - entity: input_number.heating_sejour_temperature_confort_4_d
          type: custom:numberbox-card
          icon_plus: mdi:chevron-up
          icon_minus: mdi:chevron-down
          name: Température de confort
          icon: false
        - type: horizontal-stack
          cards:
            - entity: input_datetime.heating_sejour_start_4_d
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true
            - type: glance
              show_state: false
              entities:
                - binary_sensor.heating_sejour_4_d
            - entity: input_datetime.heating_sejour_end_4_d
              type: custom:time-picker-card
              layout:
                align_controls: center
                embedded: true
              hide:
                name: true
                icon: true

HEVC mon amour...

Comme chacun le sait les vidéos de vacances ça fini par prendre une place folle. Mais nous aimons tous conserver tous ce souvenirs pour les partager avec nos enfants et nos amis. Jadis sauvegardées sous la forme de fichiers .AVI, format lancé par Microsoft mais pas très optimisé et obsolète pour de la HD. Aujourd'hui c'est plus souvent le format AVC (H.264) qui est utilisé et que l'on retrouve généralement dans des fichiers .MKV, une sorte de container qui intègre l'audio, la vidéo et les sous-titres dans un seul fichier. Et ce container peut également contenir des vidéos différemment encodées, comme le HEVC (H.265) qui nous intéresse tout particulièrement. Pourquoi cet engouement, simplement parce que l'on va pouvoir facilement diviser par trois la taille des fichiers sans perte de qualité visible et tout en conservant les pistes audio et les sous titres contenus dans le fichier d'origine. Vous l'aurez compris, ceci devient particulièrement intéressant si vous filmez en 4K... (ici par exemple pour en savoir plus).

Comment s'y prendre ?

En matière de vidéo on encode un fichier brut pour réduire sa taille et le rendre transportable et lisible, ensuite on le décode, généralement sur un lecteur, qu'il soit sur un ordinateur, un lecteur de salon (Box, Android TV, Apple TV), un téléviseur moderne qui intègre ces fonctions ou encore un smartphone. Il faut donc s'assurer que le format HEVC soit disponible sur ces appareils, c'est généralement le cas et dans le cas contraire il faudra passer par un serveur, comme Plex ou Emby par exemple, qui assureront le transcodage à la volée pour adapter le flux au lecteur, mais également l'adapter au débit disponible. Bref, la 4K avec un modem 56K ça ne passera pas, et ne ressortez pas votre lecteur de DivX des années 90, ça ne fonctionnera pas non plus.

Si on assemble Décoder et Encoder on obtient Transcoder et c'est ce que nous allons faire pour convertir nos vidéo AVC en vidéos HEVC. Pour y parvenir on trouve comme toujours des logiciels commerciaux, sans intérêt et que je vous conseille vivement d'éviter, et de l'Open Source ou juste Free.

Je ne vais pas faire un tour complet de l'offre mais juste vous parler de mon expérience et de mon parcours. La majorité des solutions sont basées sur FFmpeg ou Handbrake.

  • Emby propose une option en un deux clics. C'est pratique, mais il n'y a pas de réglages fins et on perd les sous titres (il y a toutefois possibilité de les extraire à la volée sur un fichier externe). C'est long si on a pas de décodage matériel sur le serveur comme toutes les solutions logicielles.
  • FFmpeg Batch Converter est une solution intéressante, elle permet de remplacer directement les fichiers convertis, mais son maniement est assez complexe si l'on sort des préréglages. Je ne l'ai pas trouvé très performant en mode matériel.
  • Unmanic semble très bien, tout comme Tdar qui est solution distribuée que j'ai trouvé bluffante sur le papier, mais je n'ai pas de carte graphique là ou je pourrais monter ces dockers. Je n'ai donc pour l'instant pas testé.
  • HandBrake s'est par contre rapidement imposé. Son interface est relativement claire et intuitive et les performances sont au rendez-vous, notamment avec une carte graphique Intel Iris Xe que l'on trouve dans les laptop récents (2 minutes pour convertir un fichier de 4 Go). Et je suppose que l'on peut faire bien mieux avec une bonne carte graphique du genre Nvidia Quadro ou RTX. Je vais donc continuer avec HandBrake.

Mais, car il y a un mais, HandBracke ne sait pas de base exclure des fichiers, ni parcourir une arborescence récursive ou encore simplement remplacer les fichiers d'origine par les fichiers fois convertis. Afin de contourner ces restrictions il existe HandBrake CLI que l'on peut scripter. J'ai trouvé quelques scripts qui me donnaient pas vraiment envie, puis je suis tombé sur HBBatchBeast qui est un GUI pour HandBrake CLI et FFmpeg/FFprobe (Windows, macOS et Linux (+Docker image). De prime abord ça ne donne vraiment pas envie, c'est très moche et son auteur n'est assurément pas un fin designer. Mais j'ai toutefois installé et ça fait le job plutôt bien.

Je vais donc m'en servir en me basant sur les presets que j'ai adaptés à mon usage. En gros je conserve tous paramètres de la vidéo d'origine, ses pistes audio avec l'encodage d'origine et également les sous-titres.

Sous HandBrake je vais affiner ces réglages en partant sur le préréglage matériel H.265 QSV 1080p, je n'ai pas touché aux réglages proposés pour la vidéo, au niveau de l'audio je choisit d'ajouter toutes les langues proposées et le mode Auto Passthru au niveau codec et je fais de même pour les sous titres. Pour faire simple je choisit de conserver tous les caractéristiques du fichier d'origine. En vrai j'ai un peu galéré et trouvé un peu d'aide ici.

A partir de là on fait quelques tests avec HandBrake et on teste la lecture sur plusieurs appareils afin de voir si le résultat est à la hauteur, et notamment sur des appareils exigeants, un téléviseur 4K de grande taille ou un projecteur...

Et quand on est content du résultat on exporte le préréglage dans un fichier .json (vous trouverez, je ne vais pas vous tenir la main).

{
  "PresetList": [
    {
      "AlignAVStart": false,
      "AudioCopyMask": [
        "copy:aac",
        "copy:ac3",
        "copy:dtshd",
        "copy:dts",
        "copy:truehd",
        "copy:eac3"
      ],
      "AudioEncoderFallback": "none",
      "AudioLanguageList": [
        "any"
      ],
      "AudioList": [
        {
          "AudioBitrate": 160,
          "AudioCompressionLevel": 0,
          "AudioEncoder": "copy",
          "AudioMixdown": "stereo",
          "AudioNormalizeMixLevel": false,
          "AudioSamplerate": "auto",
          "AudioTrackQualityEnable": false,
          "AudioTrackQuality": -1,
          "AudioTrackGainSlider": 0,
          "AudioTrackDRCSlider": 0
        }
      ],
      "AudioSecondaryEncoderMode": true,
      "AudioTrackSelectionBehavior": "all",
      "ChapterMarkers": true,
      "ChildrenArray": [],
      "Default": true,
      "FileFormat": "av_mkv",
      "Folder": false,
      "FolderOpen": false,
      "Mp4HttpOptimize": false,
      "Mp4iPodCompatible": false,
      "PictureAutoCrop": false,
      "PictureBottomCrop": 0,
      "PictureLeftCrop": 0,
      "PictureRightCrop": 0,
      "PictureTopCrop": 0,
      "PictureDARWidth": 0,
      "PictureDeblockPreset": "off",
      "PictureDeblockTune": "medium",
      "PictureDeblockCustom": "strength=strong:thresh=20:blocksize=8",
      "PictureDeinterlaceFilter": "off",
      "PictureCombDetectPreset": "off",
      "PictureCombDetectCustom": "",
      "PictureDenoiseCustom": "",
      "PictureDenoiseFilter": "off",
      "PictureDenoisePreset": "medium",
      "PictureDenoiseTune": "none",
      "PictureSharpenCustom": "",
      "PictureSharpenFilter": "off",
      "PictureSharpenPreset": "medium",
      "PictureSharpenTune": "none",
      "PictureDetelecine": "off",
      "PictureDetelecineCustom": "",
      "PictureColorspacePreset": "off",
      "PictureColorspaceCustom": "",
      "PictureChromaSmoothPreset": "off",
      "PictureChromaSmoothTune": "none",
      "PictureChromaSmoothCustom": "",
      "PictureItuPAR": false,
      "PictureKeepRatio": true,
      "PictureLooseCrop": false,
      "PicturePAR": "auto",
      "PicturePARWidth": 0,
      "PicturePARHeight": 0,
      "PictureWidth": 1920,
      "PictureHeight": 1080,
      "PictureUseMaximumSize": true,
      "PictureAllowUpscaling": false,
      "PictureForceHeight": 0,
      "PictureForceWidth": 0,
      "PicturePadMode": "none",
      "PicturePadTop": 0,
      "PicturePadBottom": 0,
      "PicturePadLeft": 0,
      "PicturePadRight": 0,
      "PresetName": "Convert to HEVC 3",
      "Type": 1,
      "SubtitleAddCC": false,
      "SubtitleAddForeignAudioSearch": false,
      "SubtitleAddForeignAudioSubtitle": false,
      "SubtitleBurnBehavior": "none",
      "SubtitleBurnBDSub": false,
      "SubtitleBurnDVDSub": false,
      "SubtitleLanguageList": [
        "any"
      ],
      "SubtitleTrackSelectionBehavior": "all",
      "VideoAvgBitrate": 0,
      "VideoColorMatrixCode": 0,
      "VideoEncoder": "qsv_h265",
      "VideoFramerateMode": "vfr",
      "VideoGrayScale": false,
      "VideoScaler": "swscale",
      "VideoPreset": "speed",
      "VideoTune": "",
      "VideoProfile": "auto",
      "VideoLevel": "auto",
      "VideoOptionExtra": "",
      "VideoQualityType": 2,
      "VideoQualitySlider": 22,
      "VideoQSVDecode": true,
      "VideoQSVAsyncDepth": 0,
      "VideoTwoPass": false,
      "VideoTurboTwoPass": false,
      "x264UseAdvancedOptions": false,
      "PresetDisabled": false,
      "MetadataPassthrough": true
    }
  ],
  "VersionMajor": 47,
  "VersionMicro": 0,
  "VersionMinor": 0
}

A ce stade on passe sur HBBatchBeast. Oui je sais, c'est moche et déroutant, mais promis ça ne fait pas mal. Voici les réglages à renseigner à minima :

  • Source folders : la racine de l'arborescence de fichiers à convertir. Tout en haut et facilement adaptable.
  • Destination folders : la destination des conversion. On verra plus loin qu'ils peuvent êtres déplacés pour remplacer les fichiers source.
  • Choisir si on travaille avec HandBrake ou FFmpeg. On coche le premier.

Ensuite on peut choisir de travailler avec les préréglages standard de HandBarke ou de renseigner sous cette forme notre réglage personnalisé précédemment exporté :

--preset-import-file "C:\Users\Lionel.Canaletto\Documents\HBBatchBeast\HEVC3.json" -Z "Convert to HEVC 3"

On continue avec :

  • Le container : .MKV en ce qui nous concerne
  • On coche "advanced"
  • On peut ensuite exclure certains types de fichiers de part leur nom (.jpg, etc...), leur taille ou d'autres options...
  • On choisit ensuite si on veut remplacer les fichiers d'origine.

Vous verrez qu'il existe une multitude d'options qui vont permettre d'optimiser le processus, notamment l'utilisation d'un temporaire répertoire local si on travaille sur des disques distants.

Encore une fois c'est moche, mais ce qui compte c'est que ça fonctionne très bien, rapide (9.45" pour 8 fichiers de 1 Mo sur un disque distant via Internet en SMB3), et que c'est adapté à mon besoin. Et merci à ceux qui m'ont aidé ou donné des pistes.

Sources

 

Bibliothèque Sonos

L'écosystème Sonos a bien évolué au fil des années, avec du positif comme du négatif ( 1 | 2 ), mais tout en intégrant une multitude de services musicaux, Sonos a toujours délaissé, le nombre de fichiers musicaux locaux explorables. En l'état cette limite est toujours fixée à 65.000 fichiers alors même que l'évolution Sonos 2 permettrait certainement de s'en affranchir.

J'ai longtemps utilisé Subsonic (ou ses forks) qui permet de contourner cette limite. Mais d'une part Subsonic est payant, et surtout n'est plus maintenu.

Aujourd'hui il existe un nouveau fork open source, Navidrome, qui est compatible avec les clients Subsonic, mais hélas ne propose pas de compatibilité Sonos. Fort heureusement un autre développeur de génie a eu la bonne idée de mettre à disposition une interface, Bonob, via les API Sonos, qui va permettre de faire le lien entre Sonos et les fors de Subsonic, en l'occurrence ici Navidrome.

Si ces programmes sont installables sous Linux, Windows ou MacOS, je vais choisir la facilité en passant par Docker. Pour y parvenir je commence par installer une petite VM Ubuntu Serveur avec Docker installé, et comme mes fichiers musicaux sont sur mon Nas je vais le lier en créant un volume NFS.

On commence par installer les paquets NFS :

administrator@vm:~# sudo apt install nfs-common

Ensuite on crée le répertoire idoine et on le lie au Nas :

administrator@vm:~# sudo mkdir -pv /nas/Music
administrator@vm:~# sudo mount 192.168.0.241:/volume1/Music /nas/music

Et pour terminer cette partie on fige le montage NFS en éditant le fichier /etc/fstab et en y ajoutant une ligne :

administrator@vm:~# sudo nano /etc/fstab
192.168.0.22:/volume1/Music /nas/music nfs auto,nofail,noatime,nolock,intr,tcp,actimeo=1800 0 0

Navidrome

On commence par créer un répertoire de travail ou sera installé le cache :

administrator@vm:~# sudo mkdir -pv /navidrome/data/

On installe le docker Navidrome avec la commande suivante : (voir les version Docker Compose à fin).

sudo docker run -d \
  --name navidrome \
  --restart=unless-stopped \
  --user $(id -u):$(id -g) \
  -v /nas/music:/music \
  -v /data/navidrome:/data \
  -p 4533:4533 \
  -e ND_LOGLEVEL=info \
  deluan/navidrome:latest

Il est possible de ne pas indiquer le user à des fin de test et debug, mais je ne le conseille pas de fonctionner en root. On retrouve ici nos deux répertoires, /data/navidrome pour le cache et /nas/music pour les fichiers musicaux qui pointe sur le NAS. Il y a pas mal d'autres options plus ou moins intéressantes que l'on pourra ajouter ici ou dans un fichier de configuration.

Il ne reste plus qu'à se connecter sur http://ip_serveur:4533 ... Il est bien sur possible de passer en SSL avec un reverse proxy (un petit Docker de plus...), mais également de créer des comptes secondaire pour d'autres utilisateurs qui pourront également télécharger fichiers ou albums.

Bonob

C'est ici que ça devient intéressant pour Sonos. Et ça se passe également sous Docker avec à minima :

sudo docker run -d \
  --name bonob \
  --restart=unless-stopped \
  -e BNB_PORT=4534 \
  -e BNB_URL=http://192.168.0.33:4534 \
  -e BNB_SONOS_SERVICE_NAME=Canaletto \
  -e BNB_SONOS_SEED_HOST=192.168.0.57 \
  -e BNB_SONOS_AUTO_REGISTER=true \
  -e BNB_SONOS_DEVICE_DISCOVERY=true \
  -e BNB_SUBSONIC_URL=http://172.17.0.2:4533 \
  -p 4534:4534 \
  simojenki/bonob

Il y a quelques options qui méritent explication :

  • BNB_URL= l'url du service Bonob afin de le faire savoir à Sonos
  • BNB_SONOS_SERVICE_NAME= Le nom du service qui apparaitra dans Sonos

  • BNB_SONOS_SEED_HOST= L'IP (fixe) d'un équipement Sonos permanent

  • BNB_SUBSONIC_URL= L'url interne à docker de Navidrome

Pour le reste je vous renvoi au GitHub afin d'adapter votre configuration.

A ce stade il suffit d'aller dans l'interface Sonos et d'ajouter le service que l'on viens de créer

Et de s'authentifier avec le compte précédemment créé dans Navidrome et de profiter de votre bibliothèque (MP3, FLAC, etc). Navidrome va indexer la bibliothèque et servir de cache. Je trouve les temps de recherche excellents au regard des 192 217 fichiers de ma bibliothèque répartis dans 15 753 répertoires. Il est possible dans Navidrome de créer des listes de lecture et des favoris que l'on retrouvera sous Sonos, par contre il n'est pas possible d'explorer l'arborescence des fichiers comme le permet Sonos dans son service de base.

Selon l'échantillonnage et le transcodage souhaité il faudra peut être modifier la configuration de Navi drome pour s'y adapter.

EDIT 26/08/2023

Suite à une mise à jour j'ai refait en Docker Compose :

version: "3"
services:
  navidrome:
    container_name: c-navidrome
    image: deluan/navidrome:latest
    # user: 1000:1000 # should be owner of volumes
    ports:
      - "4533:4533"
    restart: unless-stopped
    environment:
      # Optional: put your config options customization here. Examples:
      ND_SCANSCHEDULE: 1h
      ND_LOGLEVEL: info  
      ND_SESSIONTIMEOUT: 24h
      ND_BASEURL: ""
    volumes:
      - "/data/navidrome:/data"
      - "/nas/music:/music:ro"
  bonob:
    container_name: c-bonob
    image: simojenki/bonob:latest
    user: 1000:1000 # should be owner of volumes
    ports:
      - "4534:4534"
    restart: unless-stopped
    environment:
      BNB_PORT: 4534
      # ip address of your machine running bonob
      BNB_URL: http://192.168.10.33:4534  
      BNB_SECRET: password
      BNB_SONOS_AUTO_REGISTER: "true"
      BNB_SONOS_DEVICE_DISCOVERY: "true"
      BNB_SONOS_SERVICE_ID: 246
      BNB_SONOS_SERVICE_NAME: "Canaletto Music"
      # ip address of one of your sonos devices
      BNB_SONOS_SEED_HOST: 192.168.10.115
      BNB_SUBSONIC_URL: http://192.168.10.33:4533

EDIT 27/08/2023

On peut également choisi d'installer tout ça dans un VPS. Ca se complique un peu mais rien d'insurmontable. Par contre il faudra ensuite configurer les service à la main sur Sonos. La configuration comporte quelques différences, notamment au niveau de la reconnaissance automatique des équipements Sonos et de l'url externe. A noter que je fais pointer Bonob vers l'url Docker interne de Navidrome.

version: "3"
services:
  navidrome:
    container_name: c-navidrome
    image: deluan/navidrome:latest
    ports:
      - "4533:4533"
    restart: unless-stopped
    environment:
      ND_SCANSCHEDULE: 1h
      ND_LOGLEVEL: info  
      ND_SESSIONTIMEOUT: 24h
      ND_BASEURL: ""
      ND_SPOTIFY_ID: "c9d4gsdfghsfdgdfsfhsdfghdsfghsh1"
      ND_SPOTIFY_SECRET: "611sdfhgdfshshsghsfgh075f"
      ND_DEFAULTLANGUAGE: "fr"
    volumes:
      - "/data/navidrome:/data"
      - "/nfs/music:/music:ro"
  bonob:
    container_name: c-bonob
    image: simojenki/bonob:latest
    user: 1000:1000 # should be owner of volumes
    ports:
      - "4534:4534"
    restart: unless-stopped
    environment:
      BNB_PORT: 4534
      BNB_URL: https://bonob.domain.tls
      BNB_SECRET: wrtl
      BNB_SONOS_AUTO_REGISTER: "false"
      BNB_SONOS_DEVICE_DISCOVERY: "false"
      BNB_SONOS_SERVICE_ID: 246
      BNB_SONOS_SERVICE_NAME: "Online Music"
      BNB_SUBSONIC_URL: http://172.19.0.3:4533
      BNB_ICON_FOREGROUND_COLOR: "#1db954"
      BNB_ICON_BACKGROUND_COLOR: "#121212"
      TZ: "Europe/Paris"

Je sécurise le tout avec HAProxy sous pfsense (SSL). On teste les deux URL :

  • https://music.domain.tld : Ici on a l'interface de Navidrome et la première chose à faire est de créer un compte d'administration et de vérifier que tout fonctionne.
  • https://bonob.domain.tld : Ici on obtient l'interface de Bonob ou on va trouver les information pour configurer notre système Sonos.

Conseil : au niveau du firewall/reverse proxy vous pouvez appliquer rune restriction par IP afin de ne pas laisser tt ça ouvert aux quatre vents...

Une fois ceci configuré et fonctionnel, on passe à sonos en commençant par repérer l'adresse IP d'un des équipements et on lance :

http://192.168.210.115:1400/customsd.htm

Et là on tombe sur une archaïque interface ou l'on va saisir les informations recueillies sur la page https://bonob.domain.tld :

Il suffit ensuite s'ajoute le service dans l'interface Sonos (je l'ai fait sous Windows, mais c'est surement possible depuis un mobile) et de se connecter avec l'identifiant Navidrome pour voir apparaitre la bibliothèque Navidrome sous Sonos :

Vous trouvez ça trop compliqué, je comprends. Vous pouvez toujours vous abonner à un service de musique en ligne, c'est ce que je fais avec Spotify et Quobuz, mais je voulais également profiter de quelques morceaux introuvables que j'ai convertit moi même ! Une autre possibilité est de passer par un serveur Plex, mais l'interface est bien plus lente et je trouve pratique Navidrome pour construire des playlist...

EDIT 27/08/2023

J'ai essayé de faire passer Bonob via Cloudflared dans un container Docker. Tout se passe bien, sauf qu'il qu'au final il est impossible de lire sur Sonos. A suivre.

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....

 

 

 

 
 

 

 

Freebox / Unifi UDM, DHCP & IPV6

De base l'UDM / UDM Pro en mode bridge sur une Freebox fonctionne en IPV4. Ca fait le job, mais parfois on peut avoir besoin d'un adressage en IPV6. J'ai lu pas mal de choses sur ce sujet, plus ou moins précises, notamment sur ce fil et sur ce site, j'ai eu quelques difficultés de mise en œuvre et je vais essayer de faire une synthèse simple.

La première chose à faire est de récupérer l'IPV6 du port WAN actif de l'UDM en s'y connectant en SSH avec la commande ip addr | grep "global dynamic" -B2 -A3 :

# ip addr | grep "global dynamic" -B2 -A3
3: eth9: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc htb state UP group default qlen 10000
    link/ether 74:ac:b9:14:2d:e2 brd ff:ff:ff:ff:ff:ff
    inet 86.66.125.69/24 scope global dynamic eth9
       valid_lft 602510sec preferred_lft 602510sec
    inet6 fe80::76ec:b9xx:fe15:2df2/64 scope link
       valid_lft forever preferred_lft forever

L'IPV6 de notre port WAN est donc : fe80::76ec:b9xx:fe15:2df2/64

On va ensuite sur la page de configuration de la Freebox, dans mon cas une Delta S connectée à l'UDM avec un câble SFP+ dans l'espoir (vain) d'obtenir les 8 Gbit/s promis en 10G EPON. Donc sur http://mafreebox.freebox.fr (Paramètres de la Freebox / Configuration IPV6) et on reporte cette adresse dans le second Next Hop (et pas le premier hein !) afin de déléguer un préfixe. Et on note le préfixe associé.

On configure le port WAN de l'UDM en client DHCPv6 avec une taille de délégation de 64 :

Maintenant on va aller configurer le LAN de l'UDM. On reporte le préfixe précédemment noté au niveau IPV6 Gateway/Subnet et si on souhaite activer le serveur DHCP on défini une IP de départ et une IP de fin. Je ne l'ai pas fait car je souhaitait utiliser le DHCP de mon contrôleur de domaine Windows (pourquoi faire simple... mais idée abandonnée.). Pensez à cocher l'option RA.

A partir de là en SSH sur l'UDM on doit pouvoir pinguer en IPV6 :

# ping6 www.ibm.com
PING www.ibm.com (2a02:26f0:2b00:383::1e89): 56 data bytes
64 bytes from 2a02:26f0:2b00:383::1e89: seq=0 ttl=52 time=11.222 ms
64 bytes from 2a02:26f0:2b00:383::1e89: seq=1 ttl=52 time=11.307 ms
64 bytes from 2a02:26f0:2b00:383::1e89: seq=2 ttl=52 time=11.511 ms

Si on a pas configuré le serveur DHCP, on peut également rapidement configurer un client Windows en statique :

PS C:\Users\Lionel.SUPTEL> ping www.google.com -6
Pinging www.google.com [2a00:1450:4007:819::2004] with 32 bytes of data:
Reply from 2a00:1450:4007:819::2004: time=11ms
Reply from 2a00:1450:4007:819::2004: time=11ms
Reply from 2a00:1450:4007:819::2004: time=11ms
Reply from 2a00:1450:4007:819::2004: time=12ms

DHCP et résilience

Il me reste à configurer le serveur DHCP v6 sous Windows Serveur. Enfin, là se pose une vrai question sur les avantages et inconvénients. Actuellement j'ai un serveur Windows (VM dans un ESXi) dans une infrastructure Active Directory répartie sur plusieurs sites. Donc ça se justifie, et c'est même obligatoire au niveau du DNS.

Par contre, imaginons que demain je ne soit plus là ou dans l'incapacité de maintenir tout ça (infra IP et IoT). Il faut que l'accès internet soit résilient et puisse se passer du host ESXi . Mon idée est donc de basculer le DHCP sur l'UDM, de faire pointer les deux premiers DNS vers des serveurs AD et les deux suivants vers des DNS publics.

Mais pour cela il faut que le DHCP de l'UDM fasse aussi bien que celui de Windows. Et là ce n'est pas gagné. La lacune principale est qu'il n'y a rient pour facilement lister les baux. Sérieux ! Un jour surement dans une nouvelle interface encore plus design. A faire du beau ils en oublient souvent le fonctionnel chez Ubiquiti.

Par contre sur le DHCP WIndows j'utilise l'option 121 (Classless Static Route Option, RFC3442) qui se configure très facilement sur Windows. Sur l'UDM c'est un peu plus compliqué (mais pas plus que sur OpenSense ou Mikrotik). Heureusement il y a ici un calculateur qui va nous permettre de créer la chaine hexa que l'on va va pouvoir entrer dans les options personnalisées dans un champ texte des paramètres DHCP de l'UDM. Pourquoi faire simple !

Bien sur il est impossible d'importer les réservations DHCP de Windows vers l'UDM. Il va donc falloir se les faire à la main en cliquant sur chaque objet. Dans cette interface on peut également figer l'AP utilisé.

Il est intéressant de noter la possibilité d'affecter une IP réservée en dehors de la plage déclarée dans le DHCP. Et ça c'est intéressant. Dans un premier temps je crée un DHCP sur l'UDM avec uniquement une IP disponible et je laisse le DHCP Windows actif qui continuera à affecter les baux. Je fige les IP sur l'UDM et quand c'est terminé je peux arrêter le DHCP Windows et élargir la plage sur l'UDM, et accessoirement faire marche arrière au besoin.

Par contre coté IPv6 il n'est pas possible à ce jour de figer les IP. Ca viendra, peut-être...

Sources

 

Home Assistant & Volets roulants

Voilà un chapitre que je n'avais pas encore abordé, et pour cause je n'(avait pas de volets roulants. J'ai donc pensé mon installation de volets roulants avec la contrainte (ou la présence) de la domotique, tout en excluant pas un fonctionnement autonome.

Dans le cadre d'une isolation par l'extérieur (ITE), j'ai fait le choix de volets roulants filaires, d'une par afin d'éviter un surcout, mais surtout afin de pouvoir les commander à ma guise. Pour la commande j'ai choisit de faire ramener tous les câbles au tableau électrique afin que les modules Shelly 2.5 soient accessibles et surtout qu'ils ne soient pas exposés à la chaleur, le froid et l'humidité s'ils étaient placés dans les caissons. Les 6 Shelly 2.5 sont montés sur des supports DIN imprimés en 3D et j'ai trouvé des câbles en 4 fils souples en 0.75, ce qui est tout de même facile pour câbler l'ensemble dans le tableau.

Vous remarquerez l'utilisation d'embout de câblage pour câble souple multibrins. Utiliser du câble souple en 0.75 est largement suffisant, mais on ne câble jamais du fil souple multibrin directement sur un module ou un disjoncteur, soit on utilise ce genre d'embouts, soit on étame.

J'ai pensé le tout afin que mon installateur (qui a joué le jeu et c'est rare pour le préciser) n'ait qu'à poser les volets et les raccorder dans les boites de dérivation qu'il a au préalable posées dans les combles. Vous l'aurez compris il n'y a pas d'inverseur sous les volets, il était hors de question de poser des baguettes en plastique dans une maison ou tout est encastré. La commande de ces volets se fera donc soit par des scénarios, soit par des télécommandes sans fil via Home Assistant.

Un mode autonome

Il faut bien sur penser à la possibilité ou Home Assistant est défaillant, ou simplement au jour ou je ne serais plus là pour le maintenir. Pour ça les Shelly 2.5 permettent le câblage d'inverseurs filaires et je vais installer 6 inverseurs au tableau (voir plus bas en bonus).

Une alternative serait de piloter les 6 Shelly 2.5 par des poussoirs sur des Shelly E3, mais on ne s'affranchit pas d'une panne de WI-FI, et tant qu'à penser une commande autonome autant qu'elle le soit à 100%.

Le mode assisté

Pour le mode sans fil je vais utiliser des télécommandes on/off de chez Ikea à 5.99 € pour les chambres et une télécommande à 5 boutons pour les pièces de vie. En Zigbee elle sont appairées sous Home Assistant avec ZHA, mais le process est identique avec Z2M ou Deconz.

Quant au contrôle de ces télécommandes je vais simplement utiliser l'excellent ControlerX sous appDaemon que j'utilise déjà avec satisfaction pour les éclairages.

Ca reste très simple et le contrôle est dynamique, voici un exemple pour la télécommande on/off Ikea, comme vous pouvez le voir, en 6 lignes c'est géré :

volet_zha_ikea_05:
  module: controllerx
  class: E1743CoverController
  controller: "8c:f6:81:ff:fe:51:d0:b4"
  integration: zha
  cover: cover.vr_marie

Attention, certaines version de cette télécommande on on problème qui conduit sous ZHA ou Zigbee2MQTT à un rapide (24 h.) vidage des piles. J'ai donc été contraint de toutes les repasser sous Deconz...

volet_rc_ikea_05:
  module: controllerx
  class: E1743CoverController
  controller: 8c:f6:81:ff:fe:51:d0:b4
  integration: 
    name: deconz
    listen_to: unique_id
  cover: cover.vr_marie

Pour la télécommande à 5 boutons on va commencer par gérer le choix du volet à commander via un input_select:, et donc créer celui ci :

input_select:
  rc_ikea_vr:
    name: Select
    icon: mdi:light-switch
    options:
      - vr_baie
      - vr_sejour
      - vr_cuisine
      - vr_antoine
      - vr_lionel
      - vr_marie

Ensuite on va créer une commande pour ControlerX qui va nous permettre de sélectionner un volet avec les touches < et >. Inconvénient ça se fait à l'aveugle, mais ça permet de tout rassembler dans une seule télécommande :

select_vr_zha:
  module: controllerx
  class: Controller
  controller: 84:2e:14:ff:fe:a9:4d:bd
  integration: zha
  mapping:
    press_257_13_0:
      service: input_select.select_previous
      data:
        entity_id: input_select.rc_ikea_vr
    press_256_13_0:
      service: input_select.select_next
      data:
        entity_id: input_select.rc_ikea_vr

Ensuite on va les commandes propres à chaque volet (voir ici pour les mappings propres à chaque source Zigbee), on y place des contraintes (la position de notre input_select) et on exclu les actions droite et gauche que l'on utilise pour le choix du volet à commander. Il faudra bien sur dupliquer cette commande en fonction du nombre de volets. :

vr_app_1_zha:
  module: controllerx
  class: CoverController
  controller: 84:2e:14:ff:fe:a9:4d:bd
  integration: zha
  cover: cover.vr_cuisine
  constrain_input_select: input_select.rc_ikea_vr,vr_cuisine
  excluded_actions: [press_257_13_0, press_256_13_0]
  mapping:
    step_with_on_off_0_43_5: toggle_open
    step_1_43_5: toggle_close

Il nous reste le bouton central de cette télécommande qui est inexploité. On va s'en servir pour ouvrir ou fermer l'ensemble des volets de la maison en créant un groupe de volets avec l'intégration Cover Group :

cover:
  - platform: group
    entities:
      - cover.vr_baie
      - cover.vr_sejour
      - cover.vr_cuisine
      - cover.vr_antoine
      - cover.vr_lionel
      - cover.vr_marie

Et on poursuit avec la commande idoine pour ControlerX, il n'y a pas de contrainte sur l'input_select car le bouton central est utilisable dans toutes les positions :

vr_app_0_zha:
  module: controllerx
  class: CoverController
  controller: 84:2e:14:ff:fe:a9:4d:bd
  integration: zha
  cover: cover.volets
  excluded_actions: [press_257_13_0, press_256_13_0]
  mapping:
    press_2_0_0 : toggle_close
    toggle: toggle_open

Commandes

Pour l'affichage je me suis simplement inspiré de de post. Merci à lui !

L'avantage c'est qu'il y a un preset à x%. On pourrait facilement faire plusieurs. Voici le code de la carte en Vertical Stack :

type: grid
cards:
  - type: button
    show_name: false
    entity: cover.volets
    show_state: true
    show_icon: true
    hold_action:
      action: none
    tap_action:
      action: more-info
    theme: teal
  - type: button
    tap_action:
      action: call-service
      service: cover.open_cover
      service_data: {}
      target:
        entity_id: cover.volets
    show_name: false
    name: Ouvrir
    icon: mdi:arrow-up-bold
  - type: button
    tap_action:
      action: call-service
      service: cover.stop_cover
      service_data: {}
      target:
        entity_id: cover.volets
    show_name: false
    name: Stop
    icon: mdi:pause
  - type: button
    tap_action:
      action: call-service
      service: cover.close_cover
      service_data: {}
      target:
        entity_id: cover.volets
    show_name: false
    name: Fermer
    icon: mdi:arrow-down-bold
  - type: button
    tap_action:
      action: call-service
      service: cover.set_cover_position
      service_data:
        position: 20
      target:
        entity_id: cover.volets
    show_name: false
    name: Soleil
    icon: mdi:weather-sunny
  - type: picture-elements
    image: /local/images/1px2.png
    elements:
      - type: state-label
        entity: cover.volets
        attribute: current_position
        suffix: '%'
        tap_action:
          action: more-info
        style:
          top: 50%
          left: 50%
          font-size: 16px
          font-weight: bold
          color: '#44739E'
    view_layout:
      position: sidebar
columns: 6
square: true

Il ne faut pas oublier une petite image de  pixel. Et la seconde partie à dupliquer par le nombre de volets :

type: grid
cards:
  - type: button
    show_name: true
    name: Baie
    show_state: false
    tap_action:
      action: more-info
    entity: cover.vr_baie
    hold_action:
      action: none
    theme: teal
  - type: button
    tap_action:
      action: call-service
      service: cover.open_cover
      service_data: {}
      target:
        entity_id: cover.vr_baie
    icon: mdi:arrow-up-bold
    name: Ouvrir
    show_icon: true
    show_name: false
  - type: button
    tap_action:
      action: call-service
      service: cover.stop_cover
      service_data: {}
      target:
        entity_id: cover.vr_baie
    icon: mdi:pause
    name: Stop
    show_name: false
  - type: button
    tap_action:
      action: call-service
      service: cover.close_cover
      service_data: {}
      target:
        entity_id: cover.vr_baie
    icon: mdi:arrow-down-bold
    name: Fermer
    show_name: false
  - type: button
    tap_action:
      action: call-service
      service: cover.set_cover_position
      service_data:
        position: 70
      target:
        entity_id: cover.vr_baie
    icon: mdi:weather-sunset-up
    name: Soleil
    show_name: false
  - type: picture-elements
    image: /local/images/1px2.png
    elements:
      - type: state-label
        entity: cover.vr_baie
        attribute: current_position
        suffix: '%'
        tap_action:
          action: more-info
        style:
          top: 50%
          left: 50%
          font-size: 16px
          font-weight: bold
          color: '#44739E'
    view_layout:
      position: sidebar
square: true
columns: 6

Optimisation

Disposer de volets roulants électriques permet également une optimisation du confort thermique. Pour résumer on peut gagner en température en gérant leurs positions en fonction de l'ensoleillement. Il existait sous d'autres solutions domotiques des "choses" permettant cette optimisation, et je sais que quelque chose se prépare sous Home Assistant, on en reparlera donc bientôt.

Sécurisation

Les volets roulants étant moins sécurisants que mes vieux volets en vrai bois, je vais installer des contacteurs filaires afin de détecter un éventuel arrachage. J'avais pensé à un détecteur de vibration, mais je pense qu'avec le Mistral cela va créer trop de faux positifs.

Je ne vais pas utiliser l'aimant fournit avec ces contacteurs magnétiques, mais un aimant fin collé sur la dernière lame du volet. Et comme j'ai déjà sur chaque fenêtre un détecteur d'ouverture Visonic qui dispose d'une entrée filaire, ça devrait être un jeu d'enfant (le fil sera noyé dans l'isolant du tableau des fenêtres). Ensuite l'information remonte dans la centrale Visonic et dans Home assistant, je pourrais ainsi allumer les projecteurs extérieurs si un malotru tente d'arracher un de mes volets...

Bonus

Toute ces automatisations et commandes à distance c'est bien beau, mais imaginez que le WI-FI déraille ou que Home Assistant, que je trouve pourtant hyper fiable, se plante ? Vous risquez de vous retrouver dans le noir car je n'ai pas mis d'interrupteur filaire sous les volets.

Il y a deux façons d'aborder la chose, j'ai d'abord pensé à installer un panneau un peu caché au centre de la maison avec ces interrupteurs, dans un placard par exemple, sauf qu'il n'y en pas et qu'il aurait fallut y emmener un multipaire connecté aux Shelly's 2.5. Le faire en WI-FI avec des modules I3 était une option qui permet de s'affranchir de Homme Assistant mais pas du WI-FI. Au final j'ai trouvé ces modules DIN de chez Schneider, 3 modules feront l'affaire pour 6 volets en configurant correctement le Shelly (ça monte ou descend et un second appui fait le stop). Attention, si le prix catalogue de ces modules est de 27 € HT, je les ai trouvé à 82.50 € chez Amazon, à environ 40 chez les boutiquiers de la domotique pour finir ici à 9.70 TTC (et pour une fois je vous mets le lien).

Un prochain article parlera de l'automatisation intégrale des volets en fonction des températures, de l'ensoleillement et des contraintes de vie de chacun. A suivre...

Home Assistant & IP's

Suite à une configuration un peu courte de la plage de mon serveur DHCP, j'ai eu des modules Shelly (et d'autres) qui ont un peu perdu les pédales... En IT je monitore avec des outils IP comme PRTG, mais l'idée m'est venue de monitorer les modules domotique dans Home Assistant.

Pour ça il y a l'intégration ping, une intégration qui doit dater des débuts de Home Assistant et qui ne remonte pas l'IP dans les attributs. Et on verra plus loin que ce serait bien !

La première solution

On commence donc par créer un fichier ping.yaml dans nos packages et d'ajouter nos sensors :

binary_sensor:
  - platform: ping
    host: 192.168.210.63
    name: "Ping : Shelly Plug S01 | Sonos SdB"
    count: 3
    scan_interval: 30
  - platform: ping
    host: 192.168.210.78
    name: "Ping : Shelly Plug S02 | Sonos Terrasse"
    count: 3
    scan_interval: 30
  - platform: ping
    host: 192.168.210.104
    name: "Ping : Shelly Plug S03 | Congellateurs"
    count: 3
    scan_interval: 30

Ensuite on crée un groupe, et comme j'en ai beaucoup j'ai cherché quelque chose pour créer un groupe en mode willcard, genre binary_sensor.ping_* . Mais il n'existe pas grand chose et j'ai juste trouvé Groups 2.0 sous AppDaemon (mais vous n'allez pas l'installer juste pour ça !). Enfin voici le code à ajouter pour ceux qui sont habitués à la chose :

###########################################################################################
#                                                                                         #
#  Rene Tode ( [email protected] )                                                            #
#  2017/11/29 Germany                                                                     #
#                                                                                         #
#  wildcard groups                                                                        #
#                                                                                         #
#  arguments:                                                                             #
#  name: your_name                                                                        #
#  device_type: sensor # or any devicetype                                                #
#  entity_part: "any_part"                                                                #
#  entities: # list of entities                                                           #
#    - sensor.any_entity                                                                  #
#  hidden: False # or True                                                                #
#  view: True # or False                                                                  #
#  assumed_state: False # or True                                                         #
#  friendly_name: Your Friendly Name                                                      #
#  nested_view: True # or False                                                           #
#                                                                                         #
###########################################################################################

import appdaemon.plugins.hass.hassapi as hass
class create_group(hass.Hass):

  def initialize(self):
    all_entities = self.get_state(self.args["device_type"])
    entitylist = []
    for entity in all_entities:
      if self.args["entity_part"] in entity:
        entitylist.append(entity.lower())
    if "entities" in self.args:
      for entity in self.args["entities"]:
        entitylist.append(entity.lower())
    hidden = self.args["hidden"]
    view = self.args["view"]
    assumed_state = self.args["assumed_state"]
    friendly_name = self.args["friendly_name"]
    name = "group." + self.args["name"]    
    if not self.args["nested_view"]:
      self.set_state(name,state="on",attributes={"view": view,"hidden": hidden,"assumed_state": assumed_state,"friendly_name": friendly_name,"entity_id": entitylist})
    else:
      self.set_state(name + "2",state="on",attributes={"view": False,"hidden": hidden,"assumed_state": assumed_state,"friendly_name": friendly_name,"entity_id": entitylist})
      self.set_state(name,state="on",attributes={"view": True,"hidden": hidden,"assumed_state": assumed_state,"friendly_name": friendly_name,"entity_id": [name + "2"]})

Et ensuite dans apps.yaml pour créer le groupe :

pings_ip:
  module: groups
  class: create_group
  name: ping_ip
  device_type: binary_sensor
  entity_part: "ping_"
  entities:
    - sensor.group_ping
  hidden: False
  view: True
  assumed_state: False
  friendly_name: Ping IP4
  nested_view: False #creates a second group inside a viewed group  

A partir de là il est possible de créer une auto_entity_card pour visualiser nos sensors :

Quant au groupe il va nous servir à envoyer des messages afin de signaler les objets inactifs. Pour ça on va créer (Merci @mathieu...) un sensor :

    - platform: template
      sensors:
        offline_ping_sensors:
          friendly_name: 'Ping Offline'
          value_template: >
            {% set unavailable_count = states
                                    | selectattr('state','in', ['off', 'disconnected'])
                                    | selectattr('entity_id','in',state_attr('group.ping_ip','entity_id'))
                                    | map(attribute='entity_id')
                                    | list
                                    | length
            %}
            {{ unavailable_count }}
          attribute_templates:
            IP Fail: >
              {% set unavailable_list = states
                                | selectattr('state','in', ['off', 'disconnected'])
                                | selectattr('entity_id','in',state_attr('group.ping_ip','entity_id'))
                                | map(attribute='entity_id')
                                | list
                                | join('\n') 
                                | replace("binary_sensor.ping", "")
                                | replace("_", " ")
                                
              %}
              {{ unavailable_list }}

Et une automation qui sera déclenchée par ce sensor et va nous envoyer une notification :

- alias: 'IP'
  id: fc48c309-63c5-4965-bd87-fbcabc026983
  initial_state: true
  # mode: single
  trigger:
    - platform: state
      entity_id: sensor.offline_ping_sensors
  condition:
    - condition: template
      value_template: "{{ trigger.to_state.state != trigger.from_state.state }}"
  action:
    - delay: 00:01:00
    - service: notify.slack_hass_canaletto 
      data_template: 
        title: "IP Fail" 
        message: "{{now().strftime('%d/%m/%Y, %H:%M')}} > IP FAIL{{ state_attr('sensor.offline_ping_sensors','IP Fail') }} Count: {{ states('sensor.offline_ping_sensors') }}"

Le résultat est basic et se borne à nous envoyer la liste des modules injoignables, c'est intéressant mais ça ne mets pas en évidence un module qui tombe à un instant t :

De plus j'aimerait bien que les notifications soient cliquables afin d'ouvrir la page web des modules Shelly. J'ai donc remis @mathieu à contribution et apres une bonne nuit de sommeil on est partit sur une autre solution complémentaire.

Le plan B

On conserve nos sensors ping, mais on les renomme afin d'y intégrer le dernier digit de l'IP dans le nom, ce qui va nous donner. On est obligé d'écrire cette IP dans le nom car on ne la retrouve pas dans les attributs du sensor :

  - platform: ping
    host: 192.168.210.58
    name: "Ping 058 : Yeelink 01 | Desk"
    count: 3
    scan_interval: 30

On remarque que l'IP 58 devient 058 afin de conserver un alignement correct dans notre auto_entity_card et on va traiter ça dans l'automation ou vois apprécierait le template du message. Cette option nous impose de lister tous nos sensors dans l'automation, en attendant de trouver une façon de faire appel à un groupe ou le fichier des sensors :

- alias: 'Ping Offline'
  id: '08b1556d-d816-4879-b911-bd83213dd150'
  initial_state: true
  mode: single
  trigger:
    - platform: state
      entity_id:
        - binary_sensor.ping_127_shelly_plug_s09_udm
        - binary_sensor.ping_058_yeelight_01_desk
  condition:
    - condition: template
      value_template: "{{ trigger.to_state.state != trigger.from_state.state }}"
  action:
    - service: notify.slack_hass_canaletto 
      data_template: 
        title: "IP Fail" 
        message: '{{now().strftime("%d/%m/%Y, %H:%M")}} > {{ trigger.to_state.state|replace("on", "IP UP")|replace("off", "IP DOWN") }} : {{ trigger.to_state.attributes.friendly_name }} : {{ trigger.entity_id | replace("_0","",1) | replace("_1","1",1) | replace("_2","2",1) | replace("binary_sensor.ping", "http://192.168.210.") | replace("_"," ",1) | truncate(24, True,"") }}'

Au passage une astuce pour récupérer une liste d'entités, vous collez ça dans Outils de développement / Templates, ça vous évitera de vous coller la liste à la main :

{% for state in states %}
{{ state.entity_id }}
{%- endfor -%}

Et le résultat est maintenant uniquement sur le module défaillant, avec son url :

Il reste quelques petites choses d'ordre cosmétique, mais ça correspond maintenant à ce que j'attendais. J'envoie ces messages dans un fil Slack qui me sert de log dynamique que je regarde quand j'ai quelque chose en panne, en opposition aux notification par SMS (urgentes) ou via l'application.

Encore merci à Mathieu qui m'a bien aidé afin de mettre en code mes idées, et à la communauté afin d'améliorer tout ça !

Utiliser un tracker NMAP

Comme me l'a rappelé un utilisateur sur HACF Il y a une autre solution qui pourrait consister à utiliser l'intégration NMAP Tracker, qui, bien que pas faite pour présente l'avantage de remonter l'adresse IP en attribut. Pour faire propre il faudra renommer les trackers ainsi crées tant au niveau de l'entity_id que du friendly_name qui de base reprennent ce que retourne le DNS, qui n'est pas toujours très lisible.

Ca donne ça et il n'est pas utile de bricoler l'IP pour créer un lien car celle ci est disponible en attribut, ainsi que d'autres informations potentielement utiles.

- alias: 'IP Track Offline'
  id: '96017908-d46d-40cc-8d95-6b7997f5a411'
  initial_state: true
  mode: single
  trigger:
    - platform: state
      entity_id:
        - device_tracker.nmap_shelly_1_01
        - binary_sensor.numero_3
        - binary_sensor.numero_4
        - binary_sensor.numero_5
  condition:
    - condition: template
      value_template: "{{ trigger.to_state.state != trigger.from_state.state }}"
  action:
    - service: notify.slack_hass_canaletto 
      data_template: 
        title: "IP Fail" 
        message: '{{now().strftime("%d/%m/%Y, %H:%M")}} > {{ trigger.to_state.state|replace("home", "IP UP")|replace("not_home", "IP DOWN") }} : {{ trigger.to_state.attributes.friendly_name }} : http://{{ trigger.to_state.attributes.ip }}'

Pour ce résultat :

Alternatives

Il est bien sur également possible d'utiliser des outils de monitirig IP de l'IT. Au delà du monde de l'IT pro, j'en ai découvert un de très sympa, Uptime Kuma, et dont l'auteur travaille à une intégration avec Home Assistant. On y reviendra.

Pour surveiller des équipement ou sites sur internet il existe UpTime Robot qui dispose d'une intégration officielle dans HA qui remonte des binary_sensor. C'est très pratique car il y a tout ce qu'il faut pour créer des notification sur mesure.

Conclusion

Aucune de ces solutions n'est parfaite et je continue à chercher... Mais pour trouver une solution au problème de base, je pense qu'il vaudrait mieux surveiller la disponibilité des entités. En effet j'ai remarqué que parfois un Shelly peut être disponible en IP et injoignable en CoIoT. Cela permettrait également de surveiller des équipements non IP, par exemple Zigbee...

Toutes les idées sont bienvenues et avec plaisir pour échanger, ici dans les commentaires ou sur le forum HACF..

 

Synology et secours à chaud

J'utilise plusieurs gros NAS Synology dont certains dans un data center. De fait pas facilement accessibles, même si chez Scaleway il existe un support de proximité ou l'on peut demander à deux heures du matin au technicien d'astreinte d'aller redémarrer une machine, débrancher un câble ou sortir un disque...

En pleine nuit je me suis retrouvé avec un RS2414RP+ injoignable. Moment d'angoisse assuré. Je demande donc au technicien de le redémarrer. Et s'il a bien démarré, c'est avec un disque en panne. C'est probablement ce redémarrage sauvage qui a provoqué cette panne sur un disque qui devait déjà être fatigué. Quant à savoir pourquoi ce NAS qui tourne depuis des années s'est planté, mystère, les logs étant peu loquaces

Sur ce NAS il y a 12 disques en RAID SHR répartis dans deux groupes de stockage. Chaque groupe utilise 5 disques (4 + 1 en parité) et sur l'ensemble je dispose de 2 disques de secours à chaud (hotspare).

Je pensais naïvement qu'en cas de panne, un des disques configurés en secours à chaud allait prendre automatiquement le relais comme cela se fait sur certains serveurs. Mais il n'en était rien. J'ai alors pensé que ce relais se ferait quand la longue vérification des volumes serait terminée, mais niet.

Le stress montant j'ai alors commencé à fouiller le net sans pour autant trouver l'information idoine. En fait la seule information trouvée étant l'explication d'un utilisateur à qui le support Synology aurait répondu que pour qu'un disque de secours prenne le relais, il faut retirer physiquement le disque du NAS. Peu pratique à distance, même si j'ai pensé un temps demander au technicien d'astreinte de le faire pour moi.

En parcourant les menus j'ai remarqué que l'on pouvait désactiver un disque et au fond d'un forum un utilisateur explique que c'est la procédure pour retirer un disque proprement. Je me suis donc dit que si le disque était désactivé logiquement, le disque de secours devrait prendre le relais. J'ai donc tenté, et c'est visiblement ce qu'il convient de faire car un de mes disques de secours a alors été affecté automatiquement à mon groupe de stockage et la reconstruction est en cours.

Synology a très certainement de bonnes raisons de faire ainsi, mais je trouve leur documentation un peu légère sur ce point et quelques lignes d'explications plus claires m'auraient permises de gagner un peu de temps et de moins stresser. Avoir le choix entre cette façon d efaire et un mode automatique serait bien sur souhaitable ! J'espère donc que ces quelques lignes en aideront certains.

 

Home Assistant & Thermostats

Sous Home Assistant le thermostat de base (climate:) est plutôt "basic", et c'est le moins que l'on puisse dire ! Fort heureusement il y a des personnes géniales qui savent coder et se sont attelées à le modifier.

Simple Thermostat

Ce premier fork reprend simplement le thermostat de base en y ajoutant les "presets" que tout le monde attendait. En gros il y a deux façons d'utiliser un thermostat, soit on modifie dynamiquement la valeur de consigne avec des automations, le Scheduler ou Schedy et c'est ce que je fais, soit on joue la carte des presets à la française avec des modes ECO, CONFORT, Etc.. Et c'est ce que fait Simple Thermostat de façon très simple. Par exemple si on se positionne en BOOST et que l'on lui indique une consigne de 22°, il la gardera en mémoire. Ensuite on pourra rappeler le preset avec une automation

service: climate.set_preset_mode
target:
  entity_id: climate.thermostat_lionel
data:
  preset_mode: boost

Ou encore via l'interface :

EDIT 04/02/2022 : à partir de la version 2022-02 le thermostat générique de base évolue. Il est maintenant possible de définir des préréglages et de les rappeler via un service. Peut être pas aussi smart que Simple Thermostat, mais ça a le mérite d'être intégré dans le core et de ne pas faire appel à un composant externe qui peut toujours être délaissé par son développeur :

climate:
  - platform: generic_thermostat
    name: "Thermostat : Hall"
    heater: switch.sw03_hall
    target_sensor: sensor.rpi_mi_t_hall
    min_temp: 12
    max_temp: 24
    ac_mode: false
    cold_tolerance: 0.3
    hot_tolerance: 0
    min_cycle_duration:
      seconds: 360
    keep_alive:
      minutes: 3
    away_temp: 10
    comfort_temp: 20
    home_temp: 21
    sleep_temp: 18
    activity_temp: 19
    precision: 0.1

Smart Thermostat

On est ici face à un thermostat intelligent (j'ai pas non plus dit AI !) qui se base sur un contrôleur PID afin de déterminer la période pendant laquelle le convecteur devra être ON afin de profiter de l'inertie de celui ci. Le capteur cible mesure la température ambiante tandis que l'interrupteur contrôle un système de chauffage ON/OFF. Le contrôleur PID calcule la durée pendant laquelle le convecteur doit rester allumé pendant la période PWM pour atteindre le point de consigne, par exemple avec PWM réglé sur 15 minutes, si la sortie est de 100 %, le réchauffeur restera allumé pendant les 15 prochaines minutes. Si la sortie PID est de 33 %, le réchauffeur sera allumé pendant 5 minutes seulement.

Vous n'avez pas tout compris ? J'avoue que moi non plus. Mais le fait est que ça fonctionne, et d'ailleurs pour preuve en voici la formule :

Plus sérieusement, ce système sera plus particulièrement efficace avec des convecteurs (ou un autre système de chauffage) avec une forte inertie. Donc exit les convecteurs du genre grille pain...

Pour ceux qui aimerait en savoir plus je vous conseille la lecture du projet ou le mainteneur nous donne pas mal d'explications ainsi que quelques liens :

Ensuite voici la configuration type. On notera qu'ici l'idée des presets est reprise, mais qu'il faut les figer dans la configuration alors qu'ils sont dynamiques dans Simple Thermostat (Adrien si tu nous suit..).

climate:
  - platform: smart_thermostat
    name: "Thermostat : Lionel"
    heater: switch.sw01_lionel
    target_sensor: sensor.mi_lionel_temp
    min_temp: 10
    max_temp: 26
    ac_mode: False
    target_temp: 19
    keep_alive:
      seconds: 60
    precision: 0.1
    away_temp: 14
    eco_temp: 18
    boost_temp: 22
    comfort_temp: 20
    home_temp: 21
    sleep_temp: 17
    activity_temp: 20
    kp : 75
    ki : 0.001
    kd : 70000
    pwm : 00:15:00

Bien sur ces réglages sont à affiner en fonction du convecteur et de la pièce à chauffer. Pour cela il existe un mode AutoTune :

    autotune: "ciancone-marlin"

Dixit son auteur ce mode n'est pas encore tout à fait sur. J'y reviendrait donc plus tard au fil de mes tests.

En attendant on peu constater que là ou le convecteur aurait été ON jusqu'à attendre la température de consigne avec le thermostat standard (la première ligne), il y a eu plusieurs interruptions avec ce thermostat (la seconde ligne). Et  vous l'aurez compris, plus les interruptions sont importantes, moins la consommation le sera, et la facture d'autant plus réduite.

Multizone Thermostat

Il existe une autre variante qui intègre ces différents modes et bien qu'utilisable par zones indépendantes permet en plus d'ajuster la température voulue sur plusieurs zones adjacentes. Je vous laisse lire la description compète sur son Git, je l'ai quand à moi installé dans mon bureau afin d'essayer de déterminer que mode sera le plus adapté entre cout et confort. et je verrais dans quelques jours si le résultat est probant.

Il propose plusieurs modes de fonctionnement :

  • ON/OFF : proche du thermostat de base mais en prenant compte des valeurs d'hystérésis. Dans ce mode il peut également gérer les modes chauffage et refroidissement.
  • Proportionnel : PID avec possibilité de compensation météo et gestion de plusieurs valves. Les possibilité sont énormes mais la mise au point sera délicate.

Autres

Ici on va trouver une autre approche que je n'ai pas explorée.

Conclusion

Ces thermostats évolués sont très intéressants sur le papier et remplacent avantageusement le thermostat de base en fonction des besoins. Par contre ils restent encore complexes à mettre au point et il faudra peut être tout l'hiver pour en tirer des conclusions...

J'y reviendrais dans les prochains jours, mais ces deux approches constituent une avancée importante pour Home Assistant et j'espère que tout cela sera un jour intégré au Core.

Echanger

Voici deux fils ou échanger sur ce sujet :