Wat historiek

Een paar jaar geleden ben ik begonnen met het automatiseren van simpele taken in mijn huis. In het prille begin nam ik een ESP8266, voegde er een 433MHz zendertje aan toe en na lang knutselen kon ik dan mijn lichten aan doen bij zonsondergang en uitdoen om 23u. Een webinterface erbij en ik kon de parameters instellen via een Internet browser.

Toen wou ik mijn rolluiken ook aansturen en besloot toen met een echt Home Automation pakket aan de slag te gaan. Ik kwam al snel bij Domoticz uit wat me wel aansprak want geschreven in C++ en dus snel genoeg voor mijn Raspberry Pi 1B, die toen al niet meer bij de nieuwste was.

Fast forward naar 2024 en ondertussen had ik ook Tado radiatorknoppen en een paar zigbee devices, maar toen bleek dat mijn hardware te oud was om Domoticz te upgraden naar de laatste versie. Een nieuwe RPi gekocht en besloten om te schakelen naar Home Assistant die een modernere interface heeft maar vooral veel meer devices out-of-the box ondersteunt.

Als anekdote wil ik wel toevoegen dat mijn ESP8266 met 433Mhz zender tot op vandaag nog in gebruik is, dus dat blijft zeker een valabele piste en uiteraard meer fun voor een die-hard nerd zoals ik.

Happy Reading,
Patrick - mei 2024

De Home Assistant Controller

Er zijn verschillende manieren om Home Assistant te installeren.

De allersimpelste is dat je een Home Assistant Device koopt (green of yellow).
Alles werkt out of the box. Ze voorzien ook ineens een SSD drive die robuuster is dan een microsd kaart.
Heb je al een Raspberry dan kan je er een voorgeconfigureerd Speciaal OS image: HassIO op zetten.
Functioneel equivalent met de vorige alleen andere hardware. Deze heeft als nadeel dat je moeilijk(er) toegang kan krijgen tot het onderliggende OS. Omdat de RPi5 superkrachtig is zou het zonde zijn deze alleen maar voor HomeAssistant te gebruiken. Een groot voordeel is wel dat het ook de 'supervisor' bevat die zorgt voor updates etc... Het neemt het onderhoudswerk dus uit je handen. Ideaal als plug-n-play oplossing.
(Mijn Keuze)Via een Docker container, een virtuele machine dus, bv. op je RPi ('Home Assistant Container').
Dit heeft als voordeel dat je de Home Assistant in een eigen omgeving draait, los van de rest van de RPi. Een update/upgrade zou geen effect mogen hebben op de werking van Home Assistant. Je mist wel enkele Home Assistant features. Zo heb je geen supervisor, addons en moet je backup-zelf configureren. Plug-n-pray dus.
Tenslotte kan je Home Assistant als Service op je RPi draaien ('Home Assistant Core').
Dit lijkt de meest logische keuze, maar heeft als nadeel dat je geen add-ons kan installeren bovenop Home Assistant. Ik heb het even nagekeken en het lijken allemaal zaken die sowieso via raspbian zelf kunnen geinstalleerd worden. Ook updates moet je zelf doen en een update van de RPi of python kan invloed hebben op de werking van Home Assistant. Nog meer plug-n-pray dus

Met de Raspberry Pi had ik al ervaring en ik ben zo niet te vinden voor 'gesloten hardware oplossingen', dus voor mij viel optie 1 en eigenlijk ook 2 af. Omdat ik naast Home Assistant de RPi voor andere zaken wou gebruiken besloot ik voor de optie Home Assistant Container te gaan.

Kies jij voor optie 1 dan kan je rechtstreeks naar de paragraaf #Onboarding Home Assistant. Kies je voor optie 2 dan is het kwestie van in de Raspberry Pi Installer onder other Operating Systems hassIO te kiezen. Ik verwijs je hiervoor graag naar de Home Assistant website voor meer info : https://www.home-assistant.io/installation/

Klaar maken van de RPi

De minimale configuratie die je nodig hebt anno 2024 is een RPi 4 met 2Gb RAM en 32Gb SD kaart. Idealiter vervang je de SD kaart door een SSD drive. Die zou robuuster zijn dan een SD kaart. Ikzelf heb een RPi 5 met 8Gb gekocht en een SD kaart van 128Gb, maar een tweedehands NUC met een SSD drive is niet alleen goedkoper maar ook zuiniger en bedrijfszekerder dan een RPi. Je kan er voor 70..100 euro vinden die volledig voorgeconfigureerd zijn met Home Assistant.

Je kan je RPi volledig 'headless', d.w.z. zonder scherm of keyboard, opzetten. Dit is wat we hier gaan doen, maar je kan het ook hier nalezen : https://www.tim-kleyersburg.de/articles/home-assistant-with-docker-2023/

Schrijf SD kaart via de raspberry pi installer

kies :

device = raspberry pi 5
os = raspberry pi 64 bit LITE 
settings : kies een naam (bv rpi5), username, paswoord, zet country op BE, pas locale settings aan zodat keyboard layout op BE staat
services : activeer SSH met username/paswoord

boot RPi5 en wacht een 15 tal seconden
Via SSH of putty op je PC kan je nu inloggen 'rpi5.local' poort 22 met de gekozen username & paswoord

ssh <username>@<hostname>.local

update je RPi met

sudo apt update
sudo apt full-upgrade

Gmail integratie

Effe een zijsprongetje dat niet echt met Home Assistant te maken heeft, maar ik wil mijn RPi mails laten sturen, bv. bij een reboot of eens per maand met de backup of ... Dit is niet standaard voorzien.

Zorg dat je een e-mail adres hebt bij Google waar je 2-factor authentication voor hebt aanstaan en waar je een secure app aan toegevoegd hebt. Het gegenereerde paswoord heb je nodig in het config bestand. In de loop van 2024 zal Google zijn beveiligingsmechanismes nog bijsturen, dus ik kan je alleen maar aanraden om na te lezen op de Google site hoe je dit exact opzet op het moment dat je dit artikel leest.
Installeer SSMTP

sudo apt-get install ssmtp
sudo apt-get install mailutils

Editeer de config file : sudo nano /etc/ssmtp/ssmtp.config en zorg dat dit er in staat

root=postmaster
mailhub=smtp.gmail.com:587
hostname=<je hostname>
AuthUser=<het.gmail.adres.waarvan.je.zendt>@gmail.com
AuthPass=<de.16.tekens.van.de.secure.app geen spaties, geen punten>
FromLineOverride=YES
UseSTARTTLS=YES

Test met volgende commando

echo "Hallo wereld" | mail -s "test RPi" <emailadres van de ontvanger bv. mickey.mouse@hotmail.com>

Mijn favoriete crontab : stuur 2 min. na herstarten een mail. Waarom 2 min : omdat het netwerk en zeker wifi tijd nodig heeft om op te starten.

sudo crontab -e
@reboot sleep 120 && mail "RPi5 herstart" > mail -s "RPi5 herstart" mickey.mouse@disney.com

(uiteraard niet naar mickey mouse maar naar mijn eigen mailadres)

Installatie van Docker

Alles is heel goed uitgelegd op deze site : https://www.tim-kleyersburg.de/articles/home-assistant-with-docker-2023/

Installeer docker

curl -sSL https://get.docker.com | sh

Geef jezelf rechten op docker

sudo usermod -aG docker ${USER}

Maak van docker een service die automatisch opstart bij reboot

sudo systemctl enable docker

Installatie van Home Assistant Container

Alles is heel goed uitgelegd op deze site https://www.home-assistant.io/installation/linux#install-home-assistant-container (skip 1e deel en lees vanaf 'Docker compose' ) of https://www.tim-kleyersburg.de/articles/home-assistant-with-docker-2023/

maak folderstructuur & config file aan

mkdir docker
cd docker
mkdir homeAssistant
cd homeAssistant
nano docker-compose.yml

Zet volgende gegevens in docker-compose.yml

Opmerking : voor de devices moet je via 'ls /dev/serial/by-id' de exacte schrijfwijze van je devices opzoeken en dan in onderstaande yml file toevoegen in de vorm 'echte naam:logische naam'. De logische naam kan je daarna in HomeAssistant gebruiken om de connectie te maken

version: '3'
services:
  homeassistant:
    container_name: homeassistant
    image: "ghcr.io/home-assistant/home-assistant:stable"
    volumes:
      - /home/pi/docker/homeAssistant/data:/config
      - /etc/localtime:/etc/localtime:ro
      - /run/dbus:/run/dbus:ro
    devices :
      - "/dev/serial/by-id/usb-ITead_Sonoff_Zigbee_3.0_USB_Dongle_Plus_744e845f47afed118633334e71c9e8b5-if00-port0:/dev/ttyUSB_Zigbee      
      - "/dev/serial/by-id/usb-RFXCOM_RFXtrx433XL_DO3O56NA-if00-port0:/dev/ttyUSB_RFXTRX"
    restart: unless-stopped
    privileged: true
    network_mode: host

Download de image (500Mb) & start homeassistant

sudo docker compose up -d

Je zou nu via http://<hostname>.local:8123 een werkende Home Assistant moeten hebben
Let op : http is een ONBEVEILIGDE connectie. Alles gaat dus in plain text over het netwerk, ook je paswoord ! Ideaal voor de hacker die naast je woont :-) Als je homeassistant ook openzet op internet, dan is het ook handig voor de Russen en Chinezen. Geduld, daar komen we nog toe.

Onboarding Home Assistant

Na de eerste keer opstarten kan je via de webinterface de basis instellingen doen. Dit staat uitgelegd op https://www.home-assistant.io/getting-started/onboarding/

Klik op "Create My Smart Home" en

Creer administrator account.
Specifieer waar je device zal staan (= geolocatie op de map)
HomeAssistant zal nu alle compatibele devices die het vond automatisch toevoegen aan je config.
Indien gewenst kan je de home assistant app uit de PlayStore op je mobiel zetten.
Je smartphone zal dan ook in HomeAssistant zichtbaar zijn als Device en kan je gebruiken als "presence" detector.
Voorlopig werkt de app alleen als je thuis op je wifi bent aangesloten omdat we Home Assistant nog altijd alleen vanaf het lokale netwerk kunnen benaderen. Irritant, want misschien wil je je chauffage aanzetten als je op het werk vertrekt. Geduld, geduld ... Een leuk weetje is wel dat desondanks kan je notifications naar je smartphone sturen , ook als je niet op je LAN zit (bv. als de deuren opengaan als je niet thuis bent)

Easy-Peasy

Interfaces & Devices toevoegen

Nu wordt het pas echt interessant. We gaan je lokale devices toevoegen aan Home Assistant zodat die er iets mee kan doen. Effe wat vocabulaire :

Interface : dit is eigenlijk een protocol. De meeste die op je LAN actief zijn herkent Home Assistant automatisch. Zo wist ie onmiddellijk dat ik een Google TV had, een Zigbee interface, Bluetooth devices, een Synlogogy NAS en - jawel- TADO radiatorknoppen, enz... Ik moest eigenlijk alleen maar mijn credentials invoeren om de interface te activeren
Devices : dit zijn sensoren & actuatoren die op zo'n interface zitten. Ook hier zal Home Assistant heel wat zaken al voor je herkennen. Zo herkende ie volauto-magisch dat ik een Xiaomi Plant sensor had die op bluetooth werkt. Niks moeten aan configureren
Entities : dit zijn eigenlijk de onderdelen van de devices. Zo kan Home Assistant van mijn TADO de temperatuur, vochtigheid, batterijstatus, .... van elke radiatorknop opvragen en omgekeerd kan ik er de knop aan/uit zetten of de gewenste temperatuur instellen.

Zoals gezegd, het meeste werk deed Home Assistant voor mij. Het leuke is dat elk device dat je toevoegt automatisch toegevoegd wordt aan het "Overview" Dashboard. Op den duur wat ononverzichtelijk, maar geen paniek, je kan dashboards bijmaken naar eigen voorkeur.

Tip vooraf (door scha en schande zelf ondervonden) : usb poorten worden toegekend in de volgorde dat je de devices inplugt. Bij een reboot zal het snelste device usb0 worden, het volgende USB1 enz.... Dit is niet noodzakelijk dezelfde volgorde als waarin jij ze oorspronkelijk toegevoegd hebt. Hierdoor kan je device herkenning mank lopen. Je kan ook de poorten waaraan een device hangt een vaste naam geven. Dit wordt uitgelegd op deze site : https://community.home-assistant.io/t/static-usb-ports-via-udev-rules-mapped-into-a-docker-container-via-compose-yaml-do-not-work-after-reboot/607020/3 - Zoek naar freshcoast. Die geeft de oplossing. Daarom dat in in docker-compose.yml twee devices heb toegevoegd met ID

RFXTRX433XL

Mijn rolluiken hebben Somfy RTS motoren en die werken op 433.42Mhz terwijl normaal 433.92Mhz gebruikt wordt. De RFXTRX433XL ondersteunt beide frequenties. Ik kan deze interface dus gebruiken voor zowel mijn rolluiken als lichtschakelaars op 433Mhz.
Dit is de enige interface die niet auto-magisch gedetecteert werd. Toevoegen was echter simpel : Kies 'Add Integration' en zoek naar RFX. De RFXTRX staat in de lijst. Klaar.

433 Mhz switches

Kies 'Add device" en druk op de knoppen van je afstandsbediening die de lichten aan en uit doen. Home Assistant zal zo elke schakelaar herkennen en toevoegen

Somfy RTS motoren

Dit is iets ingewikkelder. Je moet namelijk de RFXTRX433XL als extra afstandsbediening aan elk rolluik toevoegen. Klinkt ingewikkeld, maa r eigenlijk heel simpel als je deze website volgt : https://vlieshout.net/?p=323

Het komt er op neer dat je een devide ID en Unit in RFXMGR op je PC kiest, het rolluik dan in program mode zet (via de knop achteraan de originele afstandsbediening) en dan vanuit RFXMGR een "program" commando stuurt naar dat device id/unit.
Eens je dit gedaan hebt kan je in Home Assistant het device manueel toevoegen als een RFLink device met als ID 071a0000[id][unit_code]

Zigbee

Hardware : SONOFF ZigBee 3.0 USB Dongle Plus, TI CC2652P (amazon- 29 euro) werd automatisch gevonden en toegevoegd als Interface. Ik nam de CC265P variant omdat die kon samenwerken met Home Assistant. De nieuwere versie met de EFR32MG21 zou dat ondertussen ook doen. Ik nam het zekere voor het onzekere en bestelde de ZBDONGLE-P versie.

Deurcontacten

Ga naar Devices & Entities en kies de zigbee integratie
Daarin kies je "Add Device". Zigbee gaat nu zoeken naar nieuwe devices
Zet het deurcontact in pairing mode door 5 sec op de reset knop te drukken
Kies een logische naam (Voordeur) en locatie (Hall)

Smart plug met Powermeter

Toevoegen via hetzelfde proces als hierboven

Din Relais

Ik wou de stroomkring die naar mijn carport enkel activeren tussen 21u en 6u (nachttarief) en alleen als ik thuis ben. Daarom in mijn zekeringen kast een zigbee relais toegevoegd

HiveMQ (MQTT)

In de meeste handleidingen van HomeAssistant wordt Mosquitto als MQTT broker voorgesteld. Deze draait lokaal op je Raspberry Pi zodat alles netjes op je LAN blijft. Het is uiteraard ook de meest performante oplossing. Ik wou echter iets anders doen, namelijk : geen inkomend verkeer op mijn LAN enkel uitgaand verkeer. Ik heb dus geen poort open staan op mijn router, geen dynamisch DNS, enz... Toch kan ik mijn installatie thuis bedienen als ik weg ben via een omweg. Ik heb op mijn smartphone MQTT Dash geinstalleerd waarop ik HiveMQ heb geinstalleerd. HiveMQ is een cloud MQTT broker. Er is een gratis versie die tot 100 devices ondersteund. Dit lijkt me als hobbyist wel voldoende. Via deze weg laat ik home assistant een aantal sensoren publiceren naar HiveMQ en omgekeerd kan ik een aantal schakelaars via HiveMQ bedienen. In plaats van de homeassistant app te gebruiken die rechtstreeks met je RPi praat heb ik een 3 weg systeem : HomeAssistant praat met HiveMQ, MQTT Dash praat met HiveMQ. HiveMQ dient dus als 'gateway' tussen mijn thuissysteem en mijn smartphone zonder dat ik inkomend verkeer moet toelaten op mijn thuisnetwerk. De HomeAssistant App gebruik ik alleen als ik thuis ben en daardoor weet Home Assistant ook ineens of ik thuis ben of niet.

Om HiveMQ te configureren moet je eerst "advanced mode" aanzetten in de "User Settings" van jouw profiel.

Daarna moet je het certificate van HiveMQ downloaden naar je RPi. Wat ik deed was het downloaden naar mijn PC en dan met scp overkopieren naar mijn rpi : scp <lokale file> user@rpi.local:/etc/ssl/certs/isrgrootx1.pem

Configuratie :

Broker = cluster URL (bv. eenlangestring.s2.eu.hivemq.cloud)
Port = 8883
username = in hivemq onder accessmanagement best een nieuwe gebruiker aanmaken
password = bijhorend paswoord van hivemq
onder advanced options : broker cert validation = auto

Uitgaande MQTT boodschappen

Voorbeeld :

service: mqtt.publish
metadata: {}
data:
 qos: "2"
 retain: true
 topic: HA/sensor/achterdeur
 payload: Open

Inkomende MQTT verwerken

In dit voorbeeld worden alle mogelijke topics en payloads in 1 automation script behandeld

alias: MQTT Received
description: ""
trigger:
 - platform: mqtt
   topic: HA/test_topic/id1
   id: "999"
 - platform: mqtt
   topic: HA/sensor/rolluik_achter
   id: RolAchter
 - platform: mqtt
   topic: HA/sensor/rolluik_voor
   id: RolVoor
 - platform: mqtt
   topic: HA/sensor/licht_plafond
   id: Plafond
 - platform: mqtt
   topic: HA/sensor/licht_hall
   id: Hall
 - platform: mqtt
   topic: HA/sensor/licht_kerstboom
   id: KerstBoom
 - platform: mqtt
   topic: HA/sensor/laadcyclus
   id: Laadcyclus
condition: []
action:
 - service: notify.mobile_app_sm_a556b
   metadata: {}
   data:
     message: Received Sjabloon:Trigger.topic = Sjabloon:Trigger.payload
 - choose:
     - conditions:
         - condition: trigger
           id:
             - RolAchter
       sequence: []
     - conditions:
         - condition: trigger
           id:
             - RolVoor
       sequence: []
     - conditions:
         - condition: trigger
           id:
             - Plafond
       sequence:
         - if:
             - condition: template
               value_template: "{{ trigger.payload > \"0\"}}"
           then:
             - type: turn_on
               device_id: 98a8f251b3e0950294276f1d396925c4
               entity_id: 0308e637ff31ed947071d735b20e75e8
               domain: switch
           else:
             - type: turn_off
               device_id: 98a8f251b3e0950294276f1d396925c4
               entity_id: 0308e637ff31ed947071d735b20e75e8
               domain: switch
     - conditions:
         - condition: trigger
           id:
             - Hall
       sequence:
         - if:
             - condition: template
               value_template: "{{ trigger.payload > \"0\"}}"
           then:
             - type: turn_on
               device_id: 77e506b00c984b62c34e11396e45e933
               entity_id: 9282043a2d2e71198d780f2657eadc8a
               domain: switch
           else:
             - type: turn_off
               device_id: 77e506b00c984b62c34e11396e45e933
               entity_id: 9282043a2d2e71198d780f2657eadc8a
               domain: switch
     - conditions:
         - condition: trigger
           id:
             - KerstBoom
       sequence:
         - if:
             - condition: template
               value_template: "{{ trigger.payload > \"0\"}}"
           then:
             - type: turn_on
               device_id: 84af653f71476618f12fbb2769c17736
               entity_id: 3a9095c35701d1f303302ee821a0a70a
               domain: switch
           else:
             - type: turn_off
               device_id: 84af653f71476618f12fbb2769c17736
               entity_id: 3a9095c35701d1f303302ee821a0a70a
               domain: switch
     - conditions:
         - condition: trigger
           id:
             - Laadcyclus
       sequence:
         - service: input_button.press
           metadata: {}
           data: {}
           target:
             entity_id: input_button.testknop
mode: single

Automations

Via Settings > Automations & Scenes kan je adhv triggers acties laten uitvoeren

Als deursensor open of dicht gaat een notification naar je smartphone sturen

trigger : Voordeur opens
action  : Notifications: Send a notification via mobile_app_sm_a556b

20 minuten voor zonsondergang een notification naar je smartphone sturen

trigger : sun - sunset offset : -00:20:00
action  : Notifications: Send a notification via mobile_app_sm_a556b

start het laden van de auto om 21u en zet lader af zodra auto volgeladen is

Hiervoor gebruik ik een 2-polig Earu relais met powermeter waarmee ik het stroomcircuit aanzet waar de lader aanhangt. De lader zelf verbruikt 5 watt. Het verbruik zal uiteraard stijgen als de auto aan het laden is en terug dalen zodra het laden klaar is. Met deze wetenschap kunnen we een conditioneel script maken dat het stroomcircuit terug uitschakelt als er geen auto aanhangt (na 1 minuut nog steeds niet meer dan 10 watt verbruik) of als het laden klaar is (check stroomverbruik elk half uur). Het script kan ook gestart worden met een knop (testknop) in mijn dashboard, vandaar de 2e trigger. Ik heb dit volledig ingericht via de UI, maar in YAML geeft dit (device id = relais, entity id = switch of power consumption).

alias: Auto Laadcyclus
description: ""
trigger:
 - platform: state
   entity_id:
     - input_button.testknop
 - platform: time
   at: "21:00:00"
condition: []
action:
 - type: turn_on
   device_id: 2124a5e7322253518061624be3f97d74
   entity_id: 877ddd2f5be9c16b0c7b0f33e5fba38c
   domain: switch
 - delay:
     hours: 0
     minutes: 1
     seconds: 0
     milliseconds: 0
 - if:
     - type: is_power
       condition: device
       device_id: 2124a5e7322253518061624be3f97d74
       entity_id: 23a261f741a4d5bde35801f07087fc24
       domain: sensor
       above: 10
   then:
     - service: notify.mobile_app_sm_a556b
       data:
         message: Laadclyclus  gestart
     - repeat:
         sequence:
           - delay:
               hours: 0
               minutes: 30
               seconds: 0
               milliseconds: 0
         until:
           - type: is_power
             condition: device
             device_id: 2124a5e7322253518061624be3f97d74
             entity_id: 23a261f741a4d5bde35801f07087fc24
             domain: sensor
             below: 10
     - service: notify.mobile_app_sm_a556b
       data:
         message: Laad cyclus beeindigd.
   else:
     - service: notify.mobile_app_sm_a556b
       data:
         message: Geen auto gekoppeld. Laadcyclus onderbroken
 - type: turn_off
   device_id: 2124a5e7322253518061624be3f97d74
   entity_id: 877ddd2f5be9c16b0c7b0f33e5fba38c
   domain: switch
mode: single

Python Scripts

Home Assistant werkt met YAML (Yet Another Markup Language) om automations te maken, maar als het wat lastiger wordt dan wil ik kunnen terug grijpen naar een volwaardige scripting taal. Gelukkig is het integreren van Python in Home Assistant relatief simpel op te zetten. Het wordt op de Home Assistant Website heel goed uitgelegd. Omdat ik Docker gebruik toch even toelichten wat ik heb moeten doen. Gelukkig is dat niet zo veel. Op diezelfde website vind je trouwens alle info over welke info je binnenkrijgt en wat je ermee kan doen. Het interessantste object is 'hass' omdat je daarmee statussen kan opvragen, events triggeren en acties starten.

Configuratie Python

Dit kan zeer eenvoudig. Ga naar de folder waarin de configuratie staat. Dit is op mijn Raspberry in de folder /home/pi/docker/homeAssistant/data. Daarin open je het bestand configuration.yaml en voegt onderaan 2 lijnen toe :

# Loads default set of integrations. Do not remove.
default_config:

# Load frontend themes from the themes folder
frontend:
 themes: !include_dir_merge_named themes

automation: !include automations.yaml
script: !include scripts.yaml
scene: !include scenes.yaml

#allow python scripts
python_script:

Herstart nu Home Assistant. Dit kan vanuit de userinterface Settings > System en dan rechtsboven de aan/uit- knop.

Folder voor de python scripts

Je maakt in diezelfde folder ook een folder aan met naam "python_scripts". In mijn geval dus : /home/pi/docker/homeAssistant/data/python_scripts. Alle bestanden eindigend op .py uit deze folder kan je als script aanroepen als actie in Home Assistant.

Voorbeeld : "hello_world.py"

name = data.get("name", "world")
logger.error("Hello {} at {}".format(name, time.time()))

Dit voorbeeldje zal een input variabele 'name' binnenkrijgen en dan een boodschap toevoegen aan het logbestand (Settings > System > Log). Ik heb hier gekozen om een error te loggen zodat je zeker een lijn extra in het logbestand ziet verschijnen.

Aanroepen van een python script

Als je een automation maakt kan je "Add Action" doen en dan onderaan bij "Other Actions..." vind je Python Scripts. Daar krijg je een lijstje van alle scripts in de folder en kan je het juiste script kiezen. Als je met variabelen wil werken moet je die actie wel bewerken in YAML (drie puntjes naast de actie en daar Edit Yaml). Als je wil kan je ook een return waarde terug krijgen en die dan gebruiken in je automation.

Vanaf hier is het internet je vriend, want er zijn al veel zaken verschenen zoals scripts om een RGB strip langzaam van kleur te laten veranderen of ... of .... of .... Ik zou zeggen zoek een aantal voorbeelden om je wegwijs te maken in python en de integratie met Home Assistant en dan kan je zelf aan de slag.

Voorbeeld 1: RGB fader Once

Dit voorbeeld gaat de kleur van de RBG strip van begin kleur tot eind kleur en stopt dan. Met de variabele 'duration' kan je instellen hoe lang het moet duren om van begin tot einde te geraken.

Python code :

# INPUT
entity_id = data.get ('entity_id') # name of the RGB light
duration = int (data.get ('duration', 60)) # in seconds
h_start = int (data.get ('hue_start', 0)) #start color 0..359
h_end = int (data.get ('hue_end', 359)) #end color 0..359
sat = int (data.get ('saturation', 50)) #saturation 0..100 

logger.info ( " Debug: entity_id: " + entity_id + " duration: " + str(duration) + " hue_start: " + 
str(h_start) +  " hue_end: " + str(h_end) + " saturation: " + str(sat)+ "\n")

h_cur = h_start
h_inc = (h_end-h_start)/duration
delay = abs(duration/(h_end - h_start))

while round(h_cur) != round(h_end) : #until we get to end levels

       data = {
           "entity_id" : entity_id,
           "hs_color" :  [ int(h_cur), sat ]
       }
       hass.services.call('light', 'turn_on', data)
       time.sleep(delay)
       h_cur = h_cur + h_inc

Action in Automation

service: python_script.rgb_fader_once
metadata: {}
data: {
 entity_id: light.zigbee_ledstrip_light,
 duration: 300,
 hue_start: 0,
 hue_end: 359,
 saturation: 100,
}

Voorbeeld 2: RGB fader Continu

Dit is een variant op voorbeeld 1. Hier gaat de ledstrip in een lus steeds van begin naar eind kleur en dan terug naar beginkleur en dan terug naar eind enzovoort. ALs de led strip door een ander proces of door de gebruiker manueel wordt afgezet detecteert dit script dat en stopt het ook. Omdat het effe duurt voordat de status in python zichtbaar wordt kan het zijn dat je 2, 3x moet proberen of de duration hoog genoeg zetten zodat er minstens 2 seconden tussen een kleurverandering gewacht wordt. Stel dat je van 0 tot 359 varieert van kleur, dan moet je lus 360x2 = 720 seconden duren. 12 minuten dus om helemaal van begin tot einde te geraken.

Python

#########################################################
def change_color (entity_id, hue, sat) :
       data = {
           "entity_id" : entity_id,
           "hs_color" : [int(hue), int(sat)]
       }
       if hass.states.get(entity_id).state == 'on' :
           hass.services.call('light', 'turn_on', data)
           logger.debug ("> Light {} : hue={}, saturation = {}".format(entity_id, hue, sat))       
       return
 
#########################################################

# INPUT
entity_id = data.get ('entity_id') # name of the RGB light
duration = int (data.get ('duration', 60)) # in secods
h_start = int (data.get ('hue_start', 0)) #start color 0..359
h_end = int (data.get ('hue_end', 359)) #end color 0..359
sat = int (data.get ('saturation', 50)) #saturation 0..100

logger.info ( " Debug: entity_id: " + entity_id + " duration: " + str(duration) + " hue_start: " + str(h_start) +  " hue_end: " str(h_end))

h_min = min (abs(h_start), abs(h_end))
h_max = max (abs(h_start), abs(h_end))

h_cur =  h_min
h_inc = (h_max-h_min)/duration
delay = abs(duration/(h_max - h_min))

change_color (entity_id, h_min, sat) 

while hass.states.get(entity_id).state == 'on' :
    # change the color
    h_cur = h_cur + h_inc
    change_color (entity_id, min (max(h_cur, h_min), h_max), sat)

    # wait a bit
    time.sleep(delay)

    # reverse direction at the edges
    if  round(h_cur) >= round (h_max) :
       h_inc = -abs(h_inc)
    if  round(h_cur) <= round (h_min) :
       h_inc = abs (h_inc)

############################################################################

Action in Automation

alias: Fade Led Strip
description: ""
trigger:
 - platform: state
   entity_id:
     - light.zigbee_ledstrip_light
   from: "off"
   to: "on"
condition: []
action:
 - service: python_script.rgb_fader_continu
   data:
     entity_id: light.zigbee_ledstrip_light
     duration: 720
     hue_start: 0
     hue_end: 359
     saturation: 100
mode: single

Happy Coding !

Let's Encrypt

(In mijn configuratie heb ik geen inkomend verkeer van buitenaf, dus voor mij is deze sectie niet relevant)
Veiligheid moeten we ernstig nemen. Als jij van overal ter wereld aan Home Assistant wil kunnen om bv. je chauffage aan te zetten, dan kan iedereen ter wereld dat proberen. Voor mij zijn er 2 no-no's in dit scenario. Een simpele paswoord beveiliging is te makkelijk te hacken en met HTTP als protocol stuurt alles in plain-text door, ook je paswoord. Laten we die 2 zaken even aanpakken zodat je gerust je app kan openstellen naar je HomeAssistant installatie en vanop cafe effe je rolluiken naar beneden doen.

Two-Factor Authentication (2FA) van je Pi :
Iedereen is het er over eens : Een paswoord is té gemakkelijk om te hacken, zelfs een zg. complex paswoord, daarom dat ik aanraad om zeker de accounts die admin rechten hebben te beveiligen met 2FA. Gelukkig is dit relatief simpel te realiseren. Alles staat nejes uitgelegd op deze website : https://www.raspberrypi.com/news/setting-up-two-factor-authentication-on-your-raspberry-pi/
Ik gebruik 'Timebased One Time Passwords' (TOTP). Klinkt ingewikkeld, maar betekent gewoon dat je Home Assistant toevoegt aan de Google Authenticator app op je smartphone en daarna bij login naast je paswoord ook de 6 cijfers moet ingeven die je in de app ziet. Omslachtig ? Eerlijk gezegd vind ik dat alle kritische applicaties zo zouden moeten beveiligd zijn.
Two-Factor Authentication (2FA) van Home Assistant
Alles staat netjes uitgelegd op deze website : https://www.home-assistant.io/docs/authentication/multi-factor-auth/
HTTPS secure sockets
Met HTTP gaat alle info in clear-text over internet. Als je TOTP gebruikt dan kan je alvast gerust zijn dat men niet zo maar op je server geraakt, zelfs al zou men je paswoord gevonden hebben, maar toch. Het opzetten van HTTPS is wel omslachtiger en bestaat eigenlijk uit volgende stappen :
- Het opzetten van dynamische DNS
- Het aanvragen van certificaten
- Het forwarden van je URL en HTTPS poort naar Home Assistant
- De juiste config in je app ingeven

Dit staat uitgelegd op deze website : https://www.home-assistant.io/blog/2015/12/13/setup-encryption-using-lets-encrypt/ maar daar gaat men er van uit dat je HASSIO gebruikt of dat je een Green/Yellow box hebt.
toe te voegen

Backups

Via een Home Assistant applicance kan je backup/restore out-of-the-box toevoegen, maar doordat ik een docker image gebruik is het wat lastiger. Ik gebruik een 2 staps aanpak voor backups

maken van de backup via Home Assistant.
Hiervoor heb ik een automation die ik telkens op de 15e van de maand laat lopen om middernacht

alias: Backup Maken
description: ""
trigger:
 - platform: time
   at: "00:00:00"
condition:
 - condition: template
   value_template: "Sjabloon:Now().day == 15"
action:
 - service: backup.create
   metadata: {}
   data: {}
 - service: notify.mobile_app_sm_a556b
   metadata: {}
   data:
     message: Nieuwe backup gemaakt.
mode: single

Het verzenden van de backup via gmail
Bovenstaande automation maakt elke maand een 'tar' file bij in de backup folder. In mijn geval is dat in /home/pi/docker/homeAssistant/data/backups. Wat ik nu gemaakt heb is een bash-script dat 1x per maand via crontab wordt opgestart en de bestanden die nieuw zijn doorstuurt via mail naar mezelf. In onderstaand script stuur ik zowel de nieuwe backups als de python scripts die sinds vorige keer werden aangemaakt of aangepast.

#!/bin/sh

STAMP="/home/pi/docker/homeAssistant/data/backups/lastupdate" 

for tarfile in /home/pi/docker/homeAssistant/data/backups/*.tar ; do
        [ "${tarfile}" -nt "$STAMP" ] && stat -c %y "${tarfile}" | mail -s "Backup Home Assistant" -A "${tarfile}"  mickey.mouse@disney.com
done

for pyfile in /home/pi/docker/homeAssistant/data/python_scripts/*.py ; do
       [ "${pyfile}" -nt "$STAMP" ] && stat -c %y "${pyfile}" | mail -s "Backup Python Scripts" -A "${pyfile}"  mickey.mouse@disney.com
done

touch "$STAMP"

Dit script checkt alle bestanden in de backup folder en als ze nieuwer zijn dan de STAMP dan wordt dat bestand via mail doorgestuurd naar Mickey Mouse. Tenslotte wordt de STAMP nog eens 'getouched' zodat volgende keer alleen de nieuwere bestanden gemaild worden.

Tenslotte nog effe mijn crontab aanpassen met

0 7 16 * *      ~/scripts/mail_backup.sh

Een restore heb ik nog niet geprobeerd, dus "fingers crossed"

Tips & Tricks

YAML : Je kan in Home Assistant heel wat via de UI aanmaken, maar soms wil je een geavanceerd feature hebben, nu ja geavanceerd, iets dat niet via de UI kan en moet je overgaan naar de scripting taal van Home Assistant, YAML genaamd, "Yet Another Markup Language". Dit kan je eenvoudig bereiken door op de plaats waar je iets wil aanpassen in het hamburger menu (3 puntjes rechts) "Edit in YAML" te kiezen. De meeste info die je op internet vindt is trouwens in YAML formaat
Gmail notificaties : We hebben eerder een gmail integratie opgezet. Wel, die kan je nu gebruiken om je HomeAssistant mails te laten sturen. https://www.home-assistant.io/integrations/smtp/ (onderaan)
Random delay : Je wil niet dat een actie altijd op exact hetzelfde moment gebeurd. Je kan daarom in de acties een delay toevoegen. In de UI kan je alleen uren:minuten:seconden ingeven als delay (bv. 00:05:00 = 5 minuten delay), maar via YAML kan je python code toevoegen. Volgende code is een delay die tussen de 2 en 5 minuten duurt

delay:
 hours: 0
 minutes: "{{ range(2, 5)|random|int }}"
 seconds: 0
 milliseconds: 0

Je ziet dat de minuten geen echte getal zijn maar een formule die een willekeurige integer tussen de 2 en 5 terug geeft.

NOG TOE TE VOEGEN

EspHome integratie
Zelf Dashboards maken
Grafieken met stroomverbruik
Sunset vs dusk en Sunrise vs dawn

Mijn devices

RFXTRX
- Rolluik voor = RFLink - Id A 0A 01 / Unit 1 = 071a00000A0A0101
- Rolluik achter = RFLink - Id A 0A 01 / Unit 2 = 071a00000A0A0102
- Licht Plafond = 2A60C00 - 2 (makkelijkste door op afstandsbediening te drukken)
- Licht Hall = 2A60C00 - 4 (makkelijkste door op afstandsbediening te drukken)
- Licht Kerstboom = 2A60C00 - 3 (makkelijkste door op afstandsbediening te drukken)
Zigbee
- Voordeur = Manufacturer TZ3000_au1rjicn - model TS0203
- Achterdeur = Manufacturer TZ3000_au1rjicn - model TS0203
- Smartplug 1 = Manufacturer TZ3000_xzhnra8x - model TS011F
- Carport relais = EARU Circuit Breaker EAYCMD-Z-2P
- LIDL plafondlamp =Manufacturer _TZ3210_p9ao60da - model TS0505B
- RGB Ledstrip = Manufacturer _TZ3210_0zabbfax - model TS0503B