Domotica

De Raspberry Pi is een klein en veelzijdig computertje dat je kunt inzetten voor tal van taken. De minicomputer heeft een laag energieverbruik en is daardoor het ideale startpunt voor een eigen domoticasysteem waarmee je je huis bestuurt. Zo kan je via je pc, smartphone of tablet je verlichting aansturen, je huis op contact- en bewegingssensoren laat reageren en slimme scenario's voor je huis ontwikkelen.

De meeste domotica-controllers die in de handel verkrijgbaar zijn, kosten honderden euro's. En uiteindelijk is zo'n controller niet meer dan een minicomputer. Een Raspberry Pi is voldoende uitgerust om dezelfde taken uit te voeren.

De in de handel verkrijgbare domotica-controllers komen met software om je huis aan te sturen. Op de Raspberry Pi moet je die zelf nog installeren. Gelukkig bestaat er heel wat opensource domotica-software. Domoticz en Home Assistant behandelen we in de praktijkopdracht. Ook openHAB moet je bij je keuze zeker ook eens bekijken.

Met een browser surf je naar de domotica-controller software op jouw Raspberry Pi. Via deze webinterface stuur je de domotica-controller aan. Daarbij krijg je een overzicht van alle schakelaars, temperatuur- en vochtigheidssensoren, neerslag-, luchtdruk- en andere weersensoren, energiemeters, enz. De webinterface past zich automatisch aan je scherm aan; op mobiele apparaten krijg je een compactere weergave.

Toegang tot domotica-controllers van buiten het lokale netwerk is ook mogelijk, maar dan moet je wel eerst de beveiliging opkrikken. Gebruik gebruikersnamen en/of wachtwoorden om toegang tot de webinterface te krijgen. Gebruik versleutelde verbindingen zoals HTTPS, zodat wachtwoorden en gebruikersnamen niet leesbaar door de netwerkkabels lopen. Ook Tor netwerken zorgen voor een extra beveiligingslaag. Daarenboven moet je via een Dynamic DNS dienst zoals DuckDNS een internetnaam voor jouw netwerk instellen.

Domotica-controllers gebruiken lokalisatie-instellingen om de taal te bepalen, zonsopgang en -ondergang te berekenen. Handig om het gedrag van je schakelaars te configureren; denk aan een licht dat alleen 's nachts op een bewegingssensor reageert.

Je kunt ook waarschuwingen krijgen, bijvoorbeeld als je een raam laat openstaan wanneer je het huis verlaat. Notificaties krijg je via speciale apps op je smartphone of tablet of via een e-mail. Als je een draadloze temperatuursensor in je koelkast hebt staan, kan je een waarschuwing krijgen als de temperatuur te veel oploopt (je hebt bijvoorbeeld de koelkastdeur laten openstaan).

Je kunt schakelaars op basis van een tijdschema aansturen. Bijvoorbeeld na hoeveel tijd na zonsopgang of -ondergang of op welk tijdstip de schakelaar moet worden in- of uitgeschakeld. Je kunt daarbij weekdagen selecteren of een vaste datum. Ook kan je toeval aan het tijdstip toevoegen, wat handig is voor een realistische aanwezigheidssituatie als je inbrekers op afstand wilt houden.

Als je een aantal sensoren en schakelaars hebt geconfigureerd, toont de domotica-controller allerlei gegevens over je huis en ben je in staat om apparaten in je huis te besturen. Maar een echt domoticasysteem kan allerlei zaken automatisch besturen. Met het gebeurtenissensysteem van de domotica-controller configureer je eenvoudig allerlei complexe scenario's zonder dat je één letter programmeercode hoeft in te tikken. Stel dat je een lamp in de gang automatisch wilt laten aangaan als de voordeur opengaat, maar alleen als het donker is.

Maak een groep van diverse apparaten die je tegelijk wilt in- of uitschakelen met een timer, gebeurtenis of handmatig. Met een groep bedien je dus diverse schakelaars tegelijk als één schakelaar.

Wil je met één druk op de knop bepaalde apparaten inschakelen en andere uitschakelen, dan heb je een scène nodig. Elk apparaat die je aan een scène toevoegt, kan je een eigen opdracht geven (aan, uit, niveau van de dimmer). Een verschil met een groep is wel dat een scène niet kan worden in- of uitgeschakeld, je kunt deze alleen activeren.

Hardware

Om met domotica-apparaten te communiceren, heb je een transceiver nodig. Het voordeel van de Raspberry Pi is dat die diverse transceivers via USB of GPIO kan aansluiten om verschillende domoticaprotocollen te ondersteunen.

Z-Wave

Z-Wave ondersteun je op de Raspberry Pi met het RaZberry-dochterbordje op de GPIO-pinnen of met een usb-stick als de Aeotec Z-Stick Series 2 of raadpleeg de lijst met Z-Wave compatibele producten.

Voor je een Z-Wave apparaat kunt gebruiken, moet je het in je Z-Wave-netwerk opnemen (include). Bij het opnemen van een Z-Wave sensor in de domotica-controller heb je 20 seconden de tijd om de Z-Wave schakelaar in het Z-Wave netwerk op te nemen. De instructies daarvoor staan in de handleiding van het apparaat. Doorgaans heeft het toestel een klein knopje dat je moet indrukken. Is het opnemen gelukt, dan verschijnt het apparaat in de lijst met nodes. Indien dit niet het geval is, kijk je op de logpagina welke foutmelding je krijgt.

Controlled Comfort

Z-Wave is een tweewegssysteem: schakelaars geven feedback aan de controller over hun toestand (bijvoorbeeld aan of uit). Heb je dat niet nodig, dan is een systeem zoals COCO (Controlled Comfort, in Nederland KlikAanKlikUit of KAKU) een goedkopere oplossing. Dit stuur je op je Raspberry Pi aan met de RFX-trx433E USB 433.92 MHz Transceiver. Dat is een prijzig apparaatje, maar ondersteunt naast COCO allerlei protocollen die op 433,92 MHz werken, waaronder HomeEasy, X10 en ook allerlei sensoren van draadloze weerstations. De meerprijs voor de RFXCOM-transceiver ten opzichte van Z-Wave verdien je snel terug, doordat COCO-modules goedkoper zijn dan vergelijkbare Z-Wave-modules.

Insteon

Insteon is een volledig draadloos systeem dat communiceert via zowel RF (radio signalen) als het lichtnet. Binnen het systeem is elke module die gebruikt wordt tevens repeater, hierdoor wordt het bereik groter en de betrouwbaarheid groter. Dit principe wordt ook gebruikt door onder andere het Z-Wave protocol en wordt ook wel een "mesh netwerk" genoemd. Prijzen en producten kan je op deze webpagina terugvinden.

ZigBee

Zigbee is een open standaard voor draadloze verbindingen tussen apparaten op korte afstand. Het is bedoeld als aanvulling op Bluetooth en Wi-Fi. Het wordt gebruikt voor het doorsturen van sensorgegevens en voor het besturen van apparaten. Een Zigbee-verbinding is zeer robuust maar de bandbreedte en de transmissiesnelheid zijn in vergelijking met Bluetooth-, Wi-Fi- en andere draadloze verbindingen, gering. Zigbee is ontworpen voor toepassingen in de domotica, bijvoorbeeld om in een woning of een gebouw met minimale middelen op afstand de dimmers en de aan/uit-schakelaars van de verlichting te bedienen. Als transeiver gebruik je een USB-stick of een opsteekbordje. ZigBee producten kan je bij verschillende fabrikanten en winkels (bv. ROBBshop) vinden.

Thread

Ook Thread werkt zoals Z-Wave en ZigBee in een mesh-netwerk. Eigenlijk lijken alle drie deze smarthome protocollen veel op elkaar, maar werken ze net wat anders. Vooral bij Thread is duidelijk te zien dat er verschillen aanwezig zijn.

Z-Wave en Zigbee communiceren via hun eigen gecreëerde netwerken, maar Thread gebruikt een IP-netwerk. Hierdoor kunnen apparaten werkend via een Thread-verbinding gemakkelijker communiceren met wifi en mobiele netwerken.

Dit betekent dat het sneller en betrouwbaarder is in de communicatie tussen netwerken en je niet per se meer een speciale hub nodig hebt om je apparaten te verbinden met het internet. De Thread border router, die nodig is voor het verbinden met je wifi netwerk, is bijvoorbeeld al ingebouwd in de Apple HomePod en Apple TV 4K.

Thread laat al jouw apparaten rechtstreeks met elkaar praten. Ieder apparaat met Thread ingebouwd kan dus rechtstreeks communiceren met elkaar zonder dat hier een dienst of hub aan te pas hoeft te komen.

Op de Thread webpagina staat een lijst met Thread gecertificeerde apparaten.

Matter

Als reactie op de wirwar van domotica systemen, proberen verschillende gerenommeerde bedrijven samen een standaard te lanceren: Matter. Hoewel dit veel problemen zou oplossen, komt dit systeem maar niet van de grond. En dit ondanks de steun van verschillende grote fabrikanten die er maar niet in slagen producten op de markt te brengen die volledig met Matter bedient kunnen worden.

Open source systemen

Naast het commerciële Matter, bestaan er ook open source verbindingsstandaarden waarvoor wel producten op de markt zijn. Daar het open source standaarden zijn, kan elke fabrikant die dat wil het systeem in zijn producten opnemen.

MQTT

MQTT (Message Queuing Telemetry Transport) is een lichtgewicht netwerkprotocol dat berichten tussen apparaten transporteert. Het is gebaseerd op het "publiceer-abonneer" concept. Het protocol werkt meestal via TCP/IP, maar elk netwerkprotocol dat geordende, verliesvrije, bidirectionele verbindingen biedt, kan MQTT ondersteunen. Het is ontworpen voor verbindingen met externe locaties waar er beperkte middelen zijn en de behoefte aan snelheid beperkt is. Het protocol is een open OASIS-standaard en een ISO-aanbeveling (ISO/IEC 20922).

Tasmota

Tasmota is een open source besturingssysteem voor verschillende ESP-apparaten (sensors, schakelaars, lampen, enz.). Je kunt de Tasmota firmware zelf op compatibele apparaten zetten, wat niet altijd eenvoudig is, of apparaten kopen met Tasmota voorgeïnstalleerd (Mediarath).

ESPHome

ESPHome is een alternatief voor Tasmota. Het wordt ontworpen en onderhouden door Home Assistant.

ESPEasy

ESP Easy is zoals Tasmota een gratis en open-source MCU-firmware voor het Internet of Things (IoT) en oorspronkelijk ontwikkeld door de LetsControlIt.com-gemeenschap (voorheen bekend als ESP8266.nu-gemeenschap). Het draait op ESP8266 Wi-Fi gebaseerde MCU (MicroController Unit) platforms voor IoT van Espressif Systems. De naam "ESP Easy" verwijst standaard naar de firmware en niet naar de hardware waarop het draait. Op een laag niveau werkt de ESP Easy firmware hetzelfde als de NodeMCU firmware en biedt ook een zeer eenvoudig besturingssysteem op de ESP8266. Het belangrijkste verschil tussen ESP Easy firmware en NodeMCU firmware is dat de eerste is ontworpen als een high-level toolbox die gewoon out-of-the-box werkt voor een vooraf gedefinieerde set van sensoren en actuatoren. Gebruikers sluiten eenvoudigweg aan en lezen/besturen via eenvoudige webverzoeken zonder zelf enige code te hoeven schrijven, inclusief firmware-upgrades met behulp van OTA-updates (Over The Air).

Lichtschakelaars

Om je verlichting aan of uit te schakelen bestaan er zowel voor Z-Wave als Controlled Comfort diverse oplossingen. Een lamp met stekker, zoals een staande lamp, sluit je aan op een stekkermodule die je in het stopcontact steekt. Voor je plafondverlichting gebruik je een inbouwmodule die je achter de wandschakelaar installeert of een module die je volledige wandschakelaar vervangt. Er bestaan ook schakelaars in de vorm van een fitting. Je draait die in een standaard E27-fitting, draait de lamp erin en je kunt de lamp daarna besturen. Al deze oplossingen bestaan in een eenvoudige aan/uit-versie of als dimmer. In het laatste geval moet je lamp dimbaar zijn.

Praktijk opdracht

Hardware
Eerst hebben we wat domotica apparaten nodig. Vroeger werden domotica apparaten via kabels met de centrale domotica-controller verbonden, maar dat was een heel karwei. Vandaag wordt meestal gekozen voor draadloze verbindingen met de domotica-controller, dit is minder goed te beveiligen, maar veel eenvoudiger te installeren. Om kennis te maken met domotica maken we deze zelf en sluiten we deze aan op de GPIO pennen van de Raspberry Pi.
1. Schakel voor je begint de Raspberry Pi uit.
2. Sluit de Pi Camera aan op de Raspberry Pi.
3. We gebruiken een drukknop als sensor, prik deze op een experimenteerbord en sluit deze met draadverbindingen aan op een massa-pin (bijvoorbeeld pin 20) en GPIO8 (pen 24) van de Raspberry Pi. GPIO staat voor General Purpose Input/Output. Een extra condensator van bijvoorbeeld 0,1µF (niet verplicht) tussen de aansluitingen van de drukknop (zie afbeelding) zorgt voor het opvangen van storingen. Een interactieve (klik voor meer informatie) pinconfiguratie kan je vinden op pinout.xyz.
4. We gebruiken een LED als uitvoer. Prik op het experimenteerbord een weerstand van 270 ohm met daaraan de anode van de LED. De kathode van de LED sluit je met een draadverbinding aan op een massa-pin (bijvoorbeeld pin 34) van de Raspberry Pi. Het losse uiteinde van de weerstand sluit je met een draadverbinding aan op GPIO12 (pin 32) van de Raspberry Pi. Als de uitgang GPIO12 hoog wordt (+3,3 volt) zal de LED oplichten. De weerstand beperkt de stroom door de LED, waardoor deze niet doorbrandt en kortsluiting veroorzaakt. Als de uitgang GPIO12 laag wordt (0 volt, dezelfde spanning als massa) loopt er geen stroom door de LED en dooft deze.
Extra voor iedereen die wil werken met 1-Wire en I²C elektronica. De hier gebruikte onderdelen worden enkel als voorbeeld gebruikt, andere 1-Wire en I²C elektronica kan je op een gelijkaardige manier gebruiken. Raadpleeg echter steeds de handleidingen en/of datasheets.
1. 1-Wire temperatuursensor DS18B20.
2. I²C temperatuursensor MCP9808

Controleer nog een laatste keer de verbindingen en start de Raspberry Pi.

Controleer of de Pi Camera werkt.

Om de configuratie van de GPIO pennen weer te geven, gebruik je:

pi@raspberrypi:~ $ pinctrl
 0: ip    pu | hi // ID_SDA/GPIO0 = input
 1: ip    pu | hi // ID_SCL/GPIO1 = input
 2: no    pu | -- // GPIO2 = none
 3: no    pu | -- // GPIO3 = none
 4: no    pu | -- // GPIO4 = none
 5: no    pu | -- // GPIO5 = none
 6: no    pu | -- // GPIO6 = none
 7: no    pu | -- // GPIO7 = none
 8: no    pu | -- // GPIO8 = none
 9: no    pd | -- // GPIO9 = none
10: no    pd | -- // GPIO10 = none
11: no    pd | -- // GPIO11 = none
12: no    pd | -- // GPIO12 = none
13: no    pd | -- // GPIO13 = none
14: no    pd | -- // GPIO14 = none
15: no    pd | -- // GPIO15 = none
16: no    pd | -- // GPIO16 = none
17: no    pd | -- // GPIO17 = none
18: no    pd | -- // GPIO18 = none
19: no    pd | -- // GPIO19 = none
20: no    pd | -- // GPIO20 = none
21: no    pd | -- // GPIO21 = none
22: no    pd | -- // GPIO22 = none
23: no    pd | -- // GPIO23 = none
24: no    pd | -- // GPIO24 = none
25: no    pd | -- // GPIO25 = none
26: no    pd | -- // GPIO26 = none
27: no    pd | -- // GPIO27 = none
28: ip    pd | lo // PCIE_RP1_WAKE/GPIO28 = input
29: no    pu | hi // FAN_TACH/GPIO29 = none
30: no    pu | -- // HOST_SDA/GPIO30 = none
31: no    pu | -- // HOST_SCL/GPIO31 = none
32: op dh pd | hi // ETH_RST_N/GPIO32 = output
33: no    pd | lo // GPIO33 = none
34: op dl pd | lo // CD0_IO0_MICCLK/GPIO34 = output
35: no    pd | lo // CD0_IO0_MICDAT0/GPIO35 = none
36: no    pd | lo // RP1_PCIE_CLKREQ_N/GPIO36 = none
37: no    pd | lo // GPIO37 = none
38: ip    pd | hi // CD0_SDA/GPIO38 = input
39: ip    pd | hi // CD0_SCL/GPIO39 = input
40: a2    pu | hi // CD1_SDA/GPIO40 = SDA4
41: a2    pu | hi // CD1_SCL/GPIO41 = SCL4
42: a2    pd | hi // USB_VBUS_EN/GPIO42 = VBUS_EN1
43: a2    pu | hi // USB_OC_N/GPIO43 = VBUS_OC1
44: op dh pd | hi // RP1_STAT_LED/GPIO44 = output
45: op dl pd | lo // FAN_PWM/GPIO45 = output
46: op dl pd | lo // CD1_IO0_MICCLK/GPIO46 = output
47: no    pd | lo // 2712_WAKE/GPIO47 = none
48: no    pd | lo // CD1_IO1_MICDAT1/GPIO48 = none
49: op dh pd | hi // EN_MAX_USB_CUR/GPIO49 = output
50: no    pd | -- // GPIO50 = none
51: no    pd | -- // GPIO51 = none
52: no    pu | -- // GPIO52 = none
53: no    pu | hi // GPIO53 = none
100: ip    pd | lo // GPIO0 = input
101: op dh pu | hi // 2712_BOOT_CS_N/GPIO1 = output
102: a6    pn | hi // 2712_BOOT_MISO/GPIO2 = VC_SPI0_MISO
103: a5    pn | hi // 2712_BOOT_MOSI/GPIO3 = VC_SPI0_MOSI
104: a6    pn | lo // 2712_BOOT_SCLK/GPIO4 = VC_SPI0_SCLK
105: ip    pd | lo // GPIO5 = input
106: ip    pd | lo // GPIO6 = input
107: ip    pd | lo // GPIO7 = input
108: ip    pd | lo // GPIO8 = input
109: ip    pd | lo // GPIO9 = input
110: ip    pd | lo // GPIO10 = input
111: ip    pd | lo // GPIO11 = input
112: ip    pd | lo // GPIO12 = input
113: ip    pd | lo // GPIO13 = input
114: a1    pd | lo // PCIE_SDA/GPIO14 = SPI_S_MOSI_OR_BSC_S_SDA
115: a1    pd | lo // PCIE_SCL/GPIO15 = SPI_S_SCK_OR_BSC_S_SCL
116: ip    pd | lo // GPIO16 = input
117: ip    pd | lo // GPIO17 = input
118: ip    pd | lo // GPIO18 = input
119: ip    pd | lo // GPIO19 = input
120: ip    pu | hi // PWR_GPIO/GPIO20 = input
121: ip    pd | lo // 2712_G21_FS/GPIO21 = input
122: ip    pd | lo // GPIO22 = input
123: ip    pd | lo // GPIO23 = input
124: a3    pn | lo // BT_RTS/GPIO24 = UART_RTS_0
125: a4    pu | lo // BT_CTS/GPIO25 = UART_CTS_0
126: a4    pn | hi // BT_TXD/GPIO26 = UART_TXD_0
127: a4    pu | hi // BT_RXD/GPIO27 = UART_RXD_0
128: op dh pd | hi // WL_ON/GPIO28 = output
129: op dh pd | hi // BT_ON/GPIO29 = output
130: a4    pn | lo // WIFI_SDIO_CLK/GPIO30 = SD2_CLK
131: a4    pu | hi // WIFI_SDIO_CMD/GPIO31 = SD2_CMD
132: a4    pd | hi // WIFI_SDIO_D0/GPIO32 = SD2_DAT0
133: a3    pu | hi // WIFI_SDIO_D1/GPIO33 = SD2_DAT1
134: a4    pn | hi // WIFI_SDIO_D2/GPIO34 = SD2_DAT2
135: a3    pn | hi // WIFI_SDIO_D3/GPIO35 = SD2_DAT3
200: ip    pd | hi // RP1_SDA/AON_GPIO0 = input
201: ip    pd | hi // RP1_SCL/AON_GPIO1 = input
202: op dh pd | hi // RP1_RUN/AON_GPIO2 = output
203: op dl pd | lo // SD_IOVDD_SEL/AON_GPIO3 = output
204: op dh pd | hi // SD_PWR_ON/AON_GPIO4 = output
205: a6    pu | lo // SD_CDET_N/AON_GPIO5 = SD_CARD_PRES_G
206: ip    pd | hi // SD_FLG_N/AON_GPIO6 = input
207: ip    pd | lo // AON_GPIO7 = input
208: ip    pd | lo // 2712_WAKE/AON_GPIO8 = input
209: op dh pd | hi // 2712_STAT_LED/AON_GPIO9 = output
210: ip    pd | lo // AON_GPIO10 = input
211: ip    pd | lo // AON_GPIO11 = input
212: ip    pd | lo // PMIC_INT/AON_GPIO12 = input
213: a3    pu | hi // UART_TX_FS/AON_GPIO13 = VC_TXD0
214: a3    pu | hi // UART_RX_FS/AON_GPIO14 = VC_RXD0
215: ip    pd | lo // AON_GPIO15 = input
216: ip    pu | hi // AON_GPIO16 = input
232: a1    -- | hi // HDMI0_SCL/AON_SGPIO0 = HDMI_TX0_BSC_SCL
233: a1    -- | hi // HDMI0_SDA/AON_SGPIO1 = HDMI_TX0_BSC_SDA
234: a1    -- | hi // HDMI1_SCL/AON_SGPIO2 = HDMI_TX1_BSC_SCL
235: a1    -- | hi // HDMI1_SDA/AON_SGPIO3 = HDMI_TX1_BSC_SDA
236: a2    -- | hi // PMIC_SCL/AON_SGPIO4 = BSC_M2_SCL
237: a2    -- | hi // PMIC_SDA/AON_SGPIO5 = BSC_M2_SDA

Je merkt dat GPIO12 niet geconfigureerd is (none). De LED zal licht geven, als je de GPIO12 als uitgang hoog (binair 1) maakt: Je maakt van GPIO12 een uitgang (op) met binaire waarde 1 (dh):

pi@raspberrypi:~ $ pinctrl set 12 op dh

Controleer dit.

De LED doof je door de GPIO 12 uitgang laag (dl) te maken:
```
pi@raspberrypi:~ $ pinctrl set 12 op dl
```
De werking van de drukknop kan je controleren door: GPIO 8 als ingang (Input, ip) met standaard hoge uitgang (Pull Up, pu) te configureren:
```
pi@raspberrypi:~ $ pinctrl set 8 ip pu
```
Daarna kunnen we de status van de drukknop opvragen:
```
pi@raspberrypi:~ $ pinctrl get 8
  8: ip    pu | hi // GPIO8 = input
```
Druk nu op de drukknop terwijl je de volgende opdracht uitvoert:
```
pi@raspberrypi:~ $ pinctrl get 8
 8: ip    pu | lo // GPIO8 = input
```
Als de drukknop niet ingedrukt is, wordt hi weergegeven, met een ingedrukte knop wordt lo weergegeven.
Als één van de domotica apparaten (Pi Camera, LED of drukknop) niet werkt, schakel je de Raspberry Pi uit en controleer je de bedrading. M.a.w. zorg dat alles werkt voor je verder gaat.
Een andere test is het script lichtschakelaar.sh:
#!/bin/bash
# Eerst definiëren we enkele functies
# Functie waarmee je wacht tot de drukknop niet wordt ingedrukt:
wait_for_release () {
  while :
  do
    pinctrl get 8 | grep -q " hi "
    if [ $? -eq 0 ]; then
      break
    fi
    sleep 1
  done
}
# Functie waarmee je wacht tot de drukknop wordt ingedrukt:
wait_for_press () {
  while :
  do
    pinctrl get 8 | grep -q " lo "
    if [ $? -eq 0 ]; then
      break
    fi
    sleep 1
  done
}
# Hier begint ons programma
# Initialiseer GPIO 8 als input met standaard hoog (pull up)
pinctrl set 8 ip pu
# Oneindig lang gaat de LED bij het drukken op de drukknop oplichten
# Breek het programma af met Ctrl+c
while :
do
  wait_for_press
  pinctrl set 12 op dh
  wait_for_release
  pinctrl set 12 op dl
Voor je dit script kunt uitvoeren, moet je het uitvoerbaar maken met de opdracht:
```
pi@raspberrypi:~ $ chmod +x lichtschakelaar.sh
```
Als dit script uitgevoerd wordt, wat moet je dan doen om de LED te laten oplichten? .....

1-Wire en I²C
Het Raspberry Pi OS bevat zeer veel stuurprogramma's (drivers), maar je moet ze wel activeren. Dit kan in het /boot/firmware/config.txt bestand. De gebruiksaanwijzing kan je online of lokaal op de Raspberry Pi raadplegen met de opdracht:
```
pi@raspberrypi:~ $ nano /boot/overlays/README
```
Python liefhebbers kunnen ook gebruik maken van Python stuurprogramma's, deze worden meestal geleverd door de leverancier. Bijvoorbeeld Adafruit voor DS18B20 en MCP9808.
1. 1-Wire (DS18B20)
  1. Eerst activeren we 1-Wire door in de bootconfiguratie /boot/firmware/config.txt:
```
pi@raspberrypi:~ $ sudo nano /boot/firmware/config.txt
```
    De volgende regel op het einde toe te voegen:
```
dtoverlay=w1-gpio
```
    Deze regel werkt echter niet op een Raspberry Pi 5, daar gebruik je:
```
dtoverlay=w1-gpio-pi5
```
  2. Daarna kunnen we de drivers activeren om onze temperatuursensor uit te lezen door in de stuurprogrammaconfiguratie /etc/modules:
```
pi@raspberrypi:~ $ sudo nano /etc/modules
```
    De volgende twee regels met stuurprogramma's toe te voegen:
```
w1-gpio
w1-therm
```
  3. Herstart de Raspberry Pi om de aanpassingen te activeren.
  4. Nu moet je GPIO 4 als ingang met Pull Up configureren (waarschijnlijk is dit een fout in de drivers en is dit dus in de toekomst niet meer nodig):
```
pi@raspberrypi:~ $ pinctrl set 4 ip pu
pi@raspberrypi:~ $ pinctrl get 4
 4: ip    pu | hi // GPIO4 = input
```
  5. De temperatuur kan je nu uitlezen via het bestand /sys/bus/w1/devices/28-*/w1_slave met de opdracht:
```
pi@raspberrypi:~ $ cat /sys/bus/w1/devices/28-*/w1_slave 
28 01 55 05 7f a5 a5 66 f0 : crc=f0 YES
28 01 55 05 7f a5 a5 66 f0 t=18500
```
    Het sterretje (*) in de mapnaam zorgt dat je alle mappen die beginnen met 28- bekijkt. Elke sensor heeft namelijk zijn eigen map (vb: /sys/bus/w1/devices/28-030297943884/w1_slave). Dit laat toe meerdere 1-Wire sensoren op dezelfde GPIO pin aan te sluiten.
    De temperatuur wordt in de tweede regel weergegeven (t=18500) wat overeenkomt met 18,500 °C (dus steeds met drie cijfers na de komma, die je zelf moet plaatsen). Of m.a.w. in m°C (milligraden Celsius).
2. I²C (MCP9808)
  1. Eerst activeren we I²C en de driver door in de bootconfiguratie /boot/firmware/config.txt:
```
pi@raspberrypi:~ $ sudo nano /boot/firmware/config.txt
```
    Voeg na deze regel
```
#dtparam=i2c_arm=on
```
    De volgende twee regels toe:
```
dtparam=i2c_arm=on
dtoverlay=i2c-sensor,jc42
```
    De eerste regel activeert de I²C bus en de tweede regel het stuurprogramma voor de MCP9808.
  2. Herstart de Raspberry Pi om de aanpassingen te activeren.
  3. De temperatuur kan je nu uitlezen via het bestand /sys/bus/i2c/devices/1-0018/hwmon/hwmon3/temp1_input met de opdracht. De mappenstructuur kan iets afwijken naargelang het gebruikte MCP9808 bordje, de leverancier, enz.
```
pi@raspberrypi:~ $ cat /sys/bus/i2c/devices/1-0018/hwmon/hwmon3/temp1_input 
26125
```
    De temperatuur wordt opnieuw weergegeven (26125) in m°C, wat overeenkomt met 26,125 °C. De afwijking 26,125 (MCP9808 meting) ten opzichte van 18,500 °C (DS18B20 meting) is te wijten aan het feit dat de MCP9808 op een HAT-bord geplaatst werd, juist boven de Raspberry Pi die warmte afgeeft.
Tasmota

Wie de Tasmota firmware zelf op een compatibele sensor of schakelaar wil installeren kan de handleiding op de website van Tasmota vinden. Tasmota sensors en schakelaars werken via het WiFi netwerk en moet je dus koppelen (handleiding).
1. Daarna bepaal je via jouw router wat het IP adres van het Tasmota apparaat is. Reserveer op de router dan meteen het IP adres voor dit Tasmota apparaat, waardoor het Tasmota apparaat steeds hetzelfde IP adres van de router krijgt.
2. Surf met een browser met het HTTP protocol naar het gevonden IP adres (vb: http://192.168.129.40/). Op de weergeven webpagina kan je het Tasmota apparaat dan bedienen.
3. Domotica controllers maken gebruik van MQTT of http URL's met opdrachten om het Tasmota apparaat te bedienen. Zo kan je de status van een Tasmota schakelaar opvragen met de opdracht:
```
pi@raspberrypi:~ $ wget -qO- http://192.168.129.40/cm?cmnd=Power
{"POWER":"OFF"}
```
  De schakelaar inschakelen met:
```
pi@raspberrypi:~ $ wget -qO- http://192.168.129.40/cm?cmnd=Power%20On
{"POWER":"ON"}
```
  De schakelaar uitschakelen met:
```
pi@raspberrypi:~ $ wget -qO- http://192.168.129.40/cm?cmnd=Power%20Off
{"POWER":"OFF"}
```
  De schakelaar omschakelen met:
```
pi@raspberrypi:~ $ wget -qO- http://192.168.129.40/cm?cmnd=Power%20Toggle
{"POWER":"ON"}
```
  Zelfs het bijwerken van de Tasmota firmware zelf is mogelijk. Alle opdrachten kan je vinden op de webpagina Commands.
Home Assistant
Tijd om een domotica-controller te installeren. Home Assistant is een jong project, met een nogal eigenwijze manier van configureren. Daar tegenover staat een modern design met ongelooflijk veel mogelijkheden. Home Assistant is een open source Python programma, waaraan iedereen die dat wil eraan kan meewerken.
1. Voor je de installatie start, ga je naar goede gewoonte het systeem upgraden.
2. De installatiehandleiding voor de Raspberry Pi vind je op de webpagina van HomeAssistant. Wie de installatie niet zelf wenst uit te voeren, kan een kant en klaar image downloaden en op de micro-SD kaart zetten. Kant en klare images zijn zeer eenvoudig te gebruiken, maar hebben het nadeel dat ze minder flexibel zijn, minder eenvoudig te onderhouden zijn en je afhankelijk bent van de maker van het image. Om HomeAssistant manueel op de Raspberry Pi te installeren, installeer je de volgende pakketten die nodig zijn om HomeAssistant te bouwen (compileren) en te gebruiken:
```
pi@raspberrypi:~ $ sudo apt install -y python3 python3-dev python3-venv python3-pip bluez libffi-dev libssl-dev libjpeg-dev zlib1g-dev autoconf build-essential libopenjp2-7 libtiff6 libturbojpeg0-dev tzdata ffmpeg liblapack3 liblapack-dev libatlas-base-dev
Pakketlijsten worden ingelezen... Klaar
Boom van vereisten wordt opgebouwd... Klaar
De statusinformatie wordt gelezen... Klaar 
python3 is reeds de nieuwste versie (3.11.2-1+b1).
python3 staat ingesteld op handmatig geïnstalleerd.
python3-dev is reeds de nieuwste versie (3.11.2-1+b1).
python3-dev staat ingesteld op handmatig geïnstalleerd.
python3-venv is reeds de nieuwste versie (3.11.2-1+b1).
python3-pip is reeds de nieuwste versie (23.0.1+dfsg-1+rpt1).
bluez is reeds de nieuwste versie (5.66-1+rpt1+deb12u1).
bluez staat ingesteld op handmatig geïnstalleerd.
zlib1g-dev is reeds de nieuwste versie (1:1.2.13.dfsg-1).
zlib1g-dev staat ingesteld op handmatig geïnstalleerd.
build-essential is reeds de nieuwste versie (12.9).
libopenjp2-7 is reeds de nieuwste versie (2.5.0-2).
libopenjp2-7 staat ingesteld op handmatig geïnstalleerd.
libtiff6 is reeds de nieuwste versie (4.5.0-6+deb12u1).
libtiff6 staat ingesteld op handmatig geïnstalleerd.
tzdata is reeds de nieuwste versie (2024a-0+deb12u1).
ffmpeg is reeds de nieuwste versie (8:5.1.5-0+rpt1+deb12u1).
liblapack3 is reeds de nieuwste versie (3.11.0-2).
liblapack3 staat ingesteld op handmatig geïnstalleerd.
De volgende extra pakketten zullen geïnstalleerd worden:
  automake autotools-dev libatlas3-base libjpeg62-turbo-dev m4
Voorgestelde pakketten:
  autoconf-archive gnu-standards autoconf-doc libtool gettext libatlas-doc liblapack-doc libssl-doc m4-doc
De volgende NIEUWE pakketten zullen geïnstalleerd worden:
  autoconf automake autotools-dev libatlas-base-dev libatlas3-base libffi-dev libjpeg-dev libjpeg62-turbo-dev
  liblapack-dev libssl-dev libturbojpeg0-dev m4
0 opgewaardeerd, 12 nieuw geïnstalleerd, 0 te verwijderen en 1 niet opgewaardeerd.
Er moeten 12,7 MB aan archieven opgehaald worden.
Na deze bewerking zal er 72,1 MB extra schijfruimte gebruikt worden.
Ophalen:1 http://deb.debian.org/debian bookworm/main arm64 m4 arm64 1.4.19-3 [276 kB]
Ophalen:2 http://archive.raspberrypi.com/debian bookworm/main arm64 libssl-dev arm64 3.0.13-1~deb12u1+rpt1 [2.310 kB]
Ophalen:3 http://deb.debian.org/debian bookworm/main arm64 autoconf all 2.71-3 [332 kB]
...
Ophalen:10 http://deb.debian.org/debian bookworm/main arm64 libjpeg-dev arm64 1:2.1.5-2 [71,8 kB]
Ophalen:11 http://deb.debian.org/debian bookworm/main arm64 liblapack-dev arm64 3.11.0-2 [3.065 kB]
Ophalen:12 http://deb.debian.org/debian bookworm/main arm64 libturbojpeg0-dev arm64 1:2.1.5-2 [234 kB]
12,7 MB opgehaald in 2s (8.019 kB/s)         
Voorheen niet geselecteerd pakket m4 wordt geselecteerd.
(Database wordt ingelezen ... 148711 bestanden en mappen momenteel geïnstalleerd.)
Uitpakken van .../00-m4_1.4.19-3_arm64.deb wordt voorbereid...
Bezig met uitpakken van m4 (1.4.19-3) ...
...
Voorheen niet geselecteerd pakket libturbojpeg0-dev:arm64 wordt geselecteerd.
Uitpakken van .../11-libturbojpeg0-dev_1%3a2.1.5-2_arm64.deb wordt voorbereid...
Bezig met uitpakken van libturbojpeg0-dev:arm64 (1:2.1.5-2) ...
Instellen van libatlas3-base:arm64 (3.10.3-13) ...
update-alternatives: /usr/lib/aarch64-linux-gnu/atlas/libblas.so.3 wordt gebruikt om in de automatische modus in /usr/lib/aarch64-linux-gnu/libblas.so.3 (libblas.so.3-aarch64-linux-gnu) te voorzien
update-alternatives: /usr/lib/aarch64-linux-gnu/atlas/liblapack.so.3 wordt gebruikt om in de automatische modus in /usr/lib/aarch64-linux-gnu/liblapack.so.3 (liblapack.so.3-aarch64-linux-gnu) te voorzien
Instellen van m4 (1.4.19-3) ...
Instellen van libffi-dev:arm64 (3.4.4-1) ...
Instellen van libatlas-base-dev:arm64 (3.10.3-13) ...
update-alternatives: /usr/lib/aarch64-linux-gnu/atlas/libblas.so wordt gebruikt om in de automatische modus in /usr/lib/aarch64-linux-gnu/libblas.so (libblas.so-aarch64-linux-gnu) te voorzien
update-alternatives: /usr/lib/aarch64-linux-gnu/atlas/liblapack.so wordt gebruikt om in de automatische modus in /usr/lib/aarch64-linux-gnu/liblapack.so (liblapack.so-aarch64-linux-gnu) te voorzien
Instellen van libturbojpeg0-dev:arm64 (1:2.1.5-2) ...
Instellen van autotools-dev (20220109.1) ...
Instellen van libjpeg62-turbo-dev:arm64 (1:2.1.5-2) ...
...
Instellen van automake (1:1.16.5-1.3) ...
update-alternatives: /usr/bin/automake-1.16 wordt gebruikt om in de automatische modus in /usr/bin/automake (automake) te voorzien
Instellen van libjpeg-dev:arm64 (1:2.1.5-2) ...
Bezig met afhandelen van triggers voor libc-bin (2.36-9+rpt2+deb12u7) ...
Bezig met afhandelen van triggers voor man-db (2.11.2-2) ...
```
3. Voor de veiligheid van het Domoticasysteem wordt er naast de standaard gebruiker de gebruiker homeassistant aangemaakt, enkel en alleen om HomeAssistant te draaien. Deze gebruiker geven we enkel de rechten die nodig zijn voor HomeAssistant. Zo voegen we de homeassistant gebruiker toe aan de groep dialout (waardoor je Z-Wave en Zigbee controllers kunt gebruiken) en aan de groep gpio (waardoor je de GPIO aansluitingen van de Raspberry Pi kunt gebruiken).
```
pi@raspberrypi:~ $ sudo useradd -rm homeassistant -G dialout,gpio,i2c
```
4. Daarna maken we een map aan waarin HomeAssistant mag werken:
```
pi@raspberrypi:~ $ cd /srv
pi@raspberrypi:/srv $ sudo mkdir homeassistant
pi@raspberrypi:/srv $ sudo chown homeassistant:homeassistant homeassistant
```
5. Om nog veiliger te werken, creëren we voor HomeAssitant een virtuele omgeving waarbinnen Homeassistant kan en moet werken:
```
pi@raspberrypi:/srv $ sudo -u homeassistant -H -s
homeassistant@raspberrypi:/srv $ cd /srv/homeassistant
homeassistant@raspberrypi:/srv/homeassistant $ python3 -m venv .
homeassistant@raspberrypi:/srv/homeassistant $ source bin/activate
```
6. Je merkt aan de verandering van de prompt, dat je nu in een virtuele omgeving werkt. Voor we de installatie van HomeAssistant zelf starten, hebben me nog één python onderdeel nodig:
  (homeassistant) homeassistant@raspberrypi:/srv/homeassistant $ python3 -m pip install wheel
  Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple
  Collecting wheel
  Downloading https://www.piwheels.org/simple/wheel/wheel-0.44.0-py3-none-any.whl (67 kB)
  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 67.1/67.1 kB 205.7 kB/s eta 0:00:00
  Installing collected packages: wheel
  Successfully installed wheel-0.44.0
7. Nu kunnen we HomeAssistant installeren:
  (homeassistant) homeassistant@raspberrypi:/srv/homeassistant $ pip3 install homeassistant
  Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple
  Collecting homeassistant
  Downloading https://www.piwheels.org/simple/homeassistant/homeassistant-2024.3.3-py3-none-any.whl (35.4 MB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 35.4/35.4 MB 2.9 MB/s eta 0:00:00
  Collecting aiohttp==3.9.3
  Downloading aiohttp-3.9.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (1.3 MB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.3/1.3 MB 6.1 MB/s eta 0:00:00
  Collecting aiohttp-cors==0.7.0
  Downloading https://www.piwheels.org/simple/aiohttp-cors/aiohttp_cors-0.7.0-py3-none-any.whl (27 kB)
  Collecting aiohttp-fast-url-dispatcher==0.3.0
  Downloading https://www.piwheels.org/simple/aiohttp-fast-url-dispatcher/aiohttp_fast_url_dispatcher-0.3.0-py3-none
  -any.whl (8.9 kB)
  Collecting aiohttp-zlib-ng==0.3.1
  Downloading https://www.piwheels.org/simple/aiohttp-zlib-ng/aiohttp_zlib_ng-0.3.1-py3-none-any.whl (8.1 kB)
  Collecting astral==2.2
  Downloading https://www.piwheels.org/simple/astral/astral-2.2-py2.py3-none-any.whl (30 kB)
  Collecting async-interrupt==1.1.1
  Downloading https://www.piwheels.org/simple/async-interrupt/async_interrupt-1.1.1-py3-none-any.whl (8.9 kB)
  Collecting attrs==23.2.0
  Downloading https://www.piwheels.org/simple/attrs/attrs-23.2.0-py3-none-any.whl (60 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 60.8/60.8 kB 367.2 kB/s eta 0:00:00
  Collecting atomicwrites-homeassistant==1.4.1
  Downloading https://www.piwheels.org/simple/atomicwrites-homeassistant/atomicwrites_homeassistant-1.4.1-py2.py3-no
  ne-any.whl (7.1 kB)
  Collecting awesomeversion==24.2.0
  Downloading https://www.piwheels.org/simple/awesomeversion/awesomeversion-24.2.0-py3-none-any.whl (14 kB)
  Collecting bcrypt==4.1.2
  Downloading bcrypt-4.1.2-cp39-abi3-manylinux_2_28_aarch64.whl (695 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 695.8/695.8 kB 6.1 MB/s eta 0:00:00
  Collecting certifi>=2021.5.30
  Downloading https://www.piwheels.org/simple/certifi/certifi-2024.7.4-py3-none-any.whl (162 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 163.0/163.0 kB 556.2 kB/s eta 0:00:00
  Collecting ciso8601==2.3.1
  Downloading ciso8601-2.3.1.tar.gz (31 kB)
  Installing build dependencies ... done
  Getting requirements to build wheel ... done
  Preparing metadata (pyproject.toml) ... done
  Collecting hass-nabucasa==0.78.0
  Downloading https://www.piwheels.org/simple/hass-nabucasa/hass_nabucasa-0.78.0-py3-none-any.whl (52 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 52.5/52.5 kB 1.2 MB/s eta 0:00:00
  Collecting httpx==0.27.0
  Downloading https://www.piwheels.org/simple/httpx/httpx-0.27.0-py3-none-any.whl (75 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 75.6/75.6 kB 1.8 MB/s eta 0:00:00
  Collecting home-assistant-bluetooth==1.12.0
  Downloading https://www.piwheels.org/simple/home-assistant-bluetooth/home_assistant_bluetooth-1.12.0-py3-none-any.
  whl (7.9 kB)
  Collecting ifaddr==0.2.0
  Downloading https://www.piwheels.org/simple/ifaddr/ifaddr-0.2.0-py3-none-any.whl (12 kB)
  Collecting Jinja2==3.1.3
  Downloading https://www.piwheels.org/simple/jinja2/Jinja2-3.1.3-py3-none-any.whl (133 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 133.2/133.2 kB 2.4 MB/s eta 0:00:00
  Collecting lru-dict==1.3.0
  Downloading lru_dict-1.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (31 kB)
  Collecting PyJWT==2.8.0
  Downloading https://www.piwheels.org/simple/pyjwt/PyJWT-2.8.0-py3-none-any.whl (22 kB)
  Collecting cryptography==42.0.5
  Downloading cryptography-42.0.5-cp39-abi3-manylinux_2_28_aarch64.whl (4.4 MB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.4/4.4 MB 6.0 MB/s eta 0:00:00
  Collecting pyOpenSSL==24.0.0
  Downloading https://www.piwheels.org/simple/pyopenssl/pyOpenSSL-24.0.0-py3-none-any.whl (58 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 58.6/58.6 kB 1.2 MB/s eta 0:00:00
  Collecting orjson==3.9.15
  Downloading orjson-3.9.15-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (144 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 144.4/144.4 kB 4.1 MB/s eta 0:00:00
  Collecting packaging>=23.1
  Downloading https://www.piwheels.org/simple/packaging/packaging-24.1-py3-none-any.whl (53 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 54.0/54.0 kB 1.2 MB/s eta 0:00:00
  Requirement already satisfied: pip>=21.3.1 in ./lib/python3.11/site-packages (from homeassistant) (23.0.1)
  Collecting python-slugify==8.0.4
  Downloading https://www.piwheels.org/simple/python-slugify/python_slugify-8.0.4-py3-none-any.whl (10 kB)
  Collecting PyYAML==6.0.1
  Downloading PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (732 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 732.2/732.2 kB 6.3 MB/s eta 0:00:00
  Collecting requests==2.31.0
  Downloading https://www.piwheels.org/simple/requests/requests-2.31.0-py3-none-any.whl (62 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 62.6/62.6 kB 1.4 MB/s eta 0:00:00
  Collecting typing-extensions<5.0,>=4.10.0
  Downloading https://www.piwheels.org/simple/typing-extensions/typing_extensions-4.12.2-py3-none-any.whl (37 kB)
  Collecting ulid-transform==0.9.0
  Downloading ulid_transform-0.9.0.tar.gz (14 kB)
  Installing build dependencies ... done
  Getting requirements to build wheel ... done
  Preparing metadata (pyproject.toml) ... done
  Collecting urllib3<2,>=1.26.5
  Downloading https://www.piwheels.org/simple/urllib3/urllib3-1.26.19-py2.py3-none-any.whl (143 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 143.9/143.9 kB 336.7 kB/s eta 0:00:00
  Collecting voluptuous==0.13.1
  Downloading https://www.piwheels.org/simple/voluptuous/voluptuous-0.13.1-py3-none-any.whl (35 kB)
  Collecting voluptuous-serialize==2.6.0
  Downloading https://www.piwheels.org/simple/voluptuous-serialize/voluptuous_serialize-2.6.0-py3-none-any.whl (6.8
  kB)
  Collecting yarl==1.9.4
  Downloading yarl-1.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (324 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 324.2/324.2 kB 4.4 MB/s eta 0:00:00
  Collecting aiosignal>=1.1.2
  Downloading https://www.piwheels.org/simple/aiosignal/aiosignal-1.3.1-py3-none-any.whl (7.6 kB)
  Collecting frozenlist>=1.1.1
  Downloading frozenlist-1.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (273 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 273.3/273.3 kB 4.7 MB/s eta 0:00:00
  Collecting multidict<7.0,>=4.5
  Downloading multidict-6.0.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (130 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 130.8/130.8 kB 2.9 MB/s eta 0:00:00
  Collecting zlib-ng>=0.3.0
  Downloading zlib_ng-0.4.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (98 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 98.5/98.5 kB 2.2 MB/s eta 0:00:00
  Collecting pytz
  Downloading https://www.piwheels.org/simple/pytz/pytz-2024.1-py3-none-any.whl (505 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 505.5/505.5 kB 910.7 kB/s eta 0:00:00
  Collecting cffi>=1.12
  Downloading cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (466 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 466.6/466.6 kB 5.9 MB/s eta 0:00:00
  Collecting pycognito==2023.5.0
  Downloading https://www.piwheels.org/simple/pycognito/pycognito-2023.5.0-py3-none-any.whl (24 kB)
  Collecting snitun==0.36.2
  Downloading https://www.piwheels.org/simple/snitun/snitun-0.36.2-py3-none-any.whl (36 kB)
  Collecting acme==2.8.0
  Downloading https://www.piwheels.org/simple/acme/acme-2.8.0-py3-none-any.whl (95 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 95.8/95.8 kB 2.2 MB/s eta 0:00:00
  Collecting habluetooth>=0.11.0
  Downloading habluetooth-3.2.0.tar.gz (33 kB)
  Installing build dependencies ... done
  Getting requirements to build wheel ... done
  Preparing metadata (pyproject.toml) ... done
  Collecting anyio
  Downloading https://www.piwheels.org/simple/anyio/anyio-4.4.0-py3-none-any.whl (86 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 86.8/86.8 kB 1.1 MB/s eta 0:00:00
  Collecting httpcore==1.*
  Downloading https://www.piwheels.org/simple/httpcore/httpcore-1.0.5-py3-none-any.whl (77 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 77.9/77.9 kB 1.5 MB/s eta 0:00:00
  Collecting idna
  Downloading https://www.piwheels.org/simple/idna/idna-3.7-py3-none-any.whl (66 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 66.8/66.8 kB 2.2 MB/s eta 0:00:00
  Collecting sniffio
  Downloading https://www.piwheels.org/simple/sniffio/sniffio-1.3.1-py3-none-any.whl (10 kB)
  Collecting MarkupSafe>=2.0
  Downloading MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (29 kB)
  Collecting text-unidecode>=1.3
  Downloading https://www.piwheels.org/simple/text-unidecode/text_unidecode-1.3-py2.py3-none-any.whl (78 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 78.2/78.2 kB 2.5 MB/s eta 0:00:00
  Collecting charset-normalizer<4,>=2
  Downloading charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (136 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 136.6/136.6 kB 4.4 MB/s eta 0:00:00
  Collecting josepy>=1.13.0
  Downloading https://www.piwheels.org/simple/josepy/josepy-1.14.0-py3-none-any.whl (32 kB)
  Collecting pyrfc3339
  Downloading https://www.piwheels.org/simple/pyrfc3339/pyRFC3339-1.1-py2.py3-none-any.whl (5.7 kB)
  Requirement already satisfied: setuptools>=41.6.0 in ./lib/python3.11/site-packages (from acme==2.8.0->hass-nabucasa
  ==0.78.0->homeassistant) (66.1.1)
  Collecting h11<0.15,>=0.13
  Downloading https://www.piwheels.org/simple/h11/h11-0.14.0-py3-none-any.whl (58 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 58.3/58.3 kB 1.9 MB/s eta 0:00:00
  Collecting boto3>=1.10.49
  Downloading https://www.piwheels.org/simple/boto3/boto3-1.34.154-py3-none-any.whl (136 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 136.5/136.5 kB 2.1 MB/s eta 0:00:00
  Collecting envs>=1.3
  Downloading https://www.piwheels.org/simple/envs/envs-1.4-py3-none-any.whl (10 kB)
  Collecting python-jose[cryptography]>=3.2.0
  Downloading https://www.piwheels.org/simple/python-jose/python_jose-3.3.0-py2.py3-none-any.whl (33 kB)
  Collecting async-timeout>=3.0.1
  Downloading https://www.piwheels.org/simple/async-timeout/async_timeout-4.0.3-py3-none-any.whl (5.7 kB)
  Collecting pycparser
  Downloading https://www.piwheels.org/simple/pycparser/pycparser-2.22-py3-none-any.whl (117 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 117.6/117.6 kB 3.1 MB/s eta 0:00:00
  Collecting bleak>=0.21.1
  Downloading https://www.piwheels.org/simple/bleak/bleak-0.22.2-py3-none-any.whl (142 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 142.6/142.6 kB 3.6 MB/s eta 0:00:00
  Collecting bleak-retry-connector>=3.3.0
  Downloading https://www.piwheels.org/simple/bleak-retry-connector/bleak_retry_connector-3.5.0-py3-none-any.whl (15
  kB)
  Collecting bluetooth-adapters>=0.16.1
  Downloading https://www.piwheels.org/simple/bluetooth-adapters/bluetooth_adapters-0.19.3-py3-none-any.whl (19 kB)
  Collecting bluetooth-auto-recovery>=1.2.3
  Downloading https://www.piwheels.org/simple/bluetooth-auto-recovery/bluetooth_auto_recovery-1.4.2-py3-none-any.whl
  (10 kB)
  Collecting bluetooth-data-tools>=1.16.0
  Downloading bluetooth_data_tools-1.19.4.tar.gz (16 kB)
  Installing build dependencies ... done
  Getting requirements to build wheel ... done
  Preparing metadata (pyproject.toml) ... done
  Collecting dbus-fast<3,>=1.83.0
  Downloading dbus_fast-2.22.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl (5.4 MB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 5.4/5.4 MB 3.5 MB/s eta 0:00:00
  Collecting aiooui>=0.1.1
  Downloading aiooui-0.1.6-py3-none-any.whl (379 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 380.0/380.0 kB 5.1 MB/s eta 0:00:00
  Collecting uart-devices>=0.1.0
  Downloading https://www.piwheels.org/simple/uart-devices/uart_devices-0.1.0-py3-none-any.whl (4.8 kB)
  Collecting usb-devices>=0.4.5
  Downloading https://www.piwheels.org/simple/usb-devices/usb_devices-0.4.5-py3-none-any.whl (5.3 kB)
  Collecting PyRIC>=0.1.6.3
  Downloading https://www.piwheels.org/simple/pyric/PyRIC-0.1.6.3-py2.py3-none-any.whl (408 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 408.8/408.8 kB 720.7 kB/s eta 0:00:00
  Collecting btsocket>=0.2.0
  Downloading https://www.piwheels.org/simple/btsocket/btsocket-0.3.0-py2.py3-none-any.whl (14 kB)
  Collecting botocore<1.35.0,>=1.34.154
  Downloading https://www.piwheels.org/simple/botocore/botocore-1.34.154-py3-none-any.whl (12.4 MB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 12.4/12.4 MB 2.9 MB/s eta 0:00:00
  Collecting jmespath<2.0.0,>=0.7.1
  Downloading https://www.piwheels.org/simple/jmespath/jmespath-1.0.1-py3-none-any.whl (20 kB)
  Collecting s3transfer<0.11.0,>=0.10.0
  Downloading https://www.piwheels.org/simple/s3transfer/s3transfer-0.10.2-py3-none-any.whl (82 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 82.7/82.7 kB 1.5 MB/s eta 0:00:00
  Collecting ecdsa!=0.15
  Downloading https://www.piwheels.org/simple/ecdsa/ecdsa-0.19.0-py2.py3-none-any.whl (146 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 146.6/146.6 kB 2.6 MB/s eta 0:00:00
  Collecting rsa
  Downloading https://www.piwheels.org/simple/rsa/rsa-4.9-py3-none-any.whl (34 kB)
  Collecting pyasn1
  Downloading https://www.piwheels.org/simple/pyasn1/pyasn1-0.6.0-py2.py3-none-any.whl (85 kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 85.3/85.3 kB 1.9 MB/s eta 0:00:00
  Collecting python-dateutil<3.0.0,>=2.1
  Downloading https://www.piwheels.org/simple/python-dateutil/python_dateutil-2.9.0.post0-py2.py3-none-any.whl (229
  kB)
      ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 229.9/229.9 kB 4.5 MB/s eta 0:00:00
  Collecting six>=1.9.0
  Downloading https://www.piwheels.org/simple/six/six-1.16.0-py2.py3-none-any.whl (11 kB)
  Building wheels for collected packages: ciso8601, ulid-transform, habluetooth, bluetooth-data-tools
  Building wheel for ciso8601 (pyproject.toml) ... done
  Created wheel for ciso8601: filename=ciso8601-2.3.1-cp311-cp311-linux_aarch64.whl size=38488 sha256=29270c369b9565
  f076d203393adab5dd5d0e0365dad33e554597fa12ebbeade3
  Stored in directory: /home/homeassistant/.cache/pip/wheels/96/da/1d/01f630ad60642fa1cb8db43e482bf1627954be8e37d14d
  fe6f
  Building wheel for ulid-transform (pyproject.toml) ... done
  Created wheel for ulid-transform: filename=ulid_transform-0.9.0-cp311-cp311-manylinux_2_36_aarch64.whl size=172500
  sha256=60dd9348d32f9317204d976270d156ed5461f495de693c7c66de6d028bfd6be2
  Stored in directory: /home/homeassistant/.cache/pip/wheels/d6/66/ab/d998d6676d2a06033db82433a9c2324b236b160ec8352b
  82d4
  Building wheel for habluetooth (pyproject.toml) ... done
  Created wheel for habluetooth: filename=habluetooth-3.2.0-cp311-cp311-manylinux_2_36_aarch64.whl size=2282440 sha2
  56=f00d6c2b298ae05400065d21a99498138098842d6c3a36aa7d6dee6a7284ff58
  Stored in directory: /home/homeassistant/.cache/pip/wheels/28/a9/c5/08332b0ab473e3c6a3038ff83ebb6d00677eca7f499e46
  7291
  Building wheel for bluetooth-data-tools (pyproject.toml) ... done
  Created wheel for bluetooth-data-tools: filename=bluetooth_data_tools-1.19.4-cp311-cp311-manylinux_2_36_aarch64.wh
  l size=508976 sha256=4ea775da6ef3ed9c26b7d60c161d8549fc7eb6e4f784738bf400a27cbff71a68
  Stored in directory: /home/homeassistant/.cache/pip/wheels/f0/42/c8/b431b01889d0388ae4c9f6edc4132982b0c9d2fabed581
  2f94
  Successfully built ciso8601 ulid-transform habluetooth bluetooth-data-tools
  Installing collected packages: voluptuous, text-unidecode, pytz, PyRIC, ifaddr, ciso8601, btsocket, zlib-ng, voluptu
  ous-serialize, usb-devices, urllib3, ulid-transform, uart-devices, typing-extensions, sniffio, six, PyYAML, python-s
  lugify, pyrfc3339, PyJWT, pycparser, pyasn1, packaging, orjson, multidict, MarkupSafe, lru-dict, jmespath, idna, h11
  , frozenlist, envs, dbus-fast, charset-normalizer, certifi, bcrypt, awesomeversion, attrs, atomicwrites-homeassistan
  t, async-timeout, async-interrupt, astral, aiooui, yarl, rsa, requests, python-dateutil, Jinja2, httpcore, ecdsa, cf
  fi, bleak, anyio, aiosignal, python-jose, httpx, cryptography, botocore, bluetooth-adapters, aiohttp, snitun, s3tran
  sfer, pyOpenSSL, bluetooth-data-tools, bluetooth-auto-recovery, bleak-retry-connector, aiohttp-zlib-ng, aiohttp-fast
  -url-dispatcher, aiohttp-cors, josepy, habluetooth, boto3, pycognito, home-assistant-bluetooth, acme, hass-nabucasa,
  homeassistant
  Successfully installed Jinja2-3.1.3 MarkupSafe-2.1.5 PyJWT-2.8.0 PyRIC-0.1.6.3 PyYAML-6.0.1 acme-2.8.0 aiohttp-3.9.3
  aiohttp-cors-0.7.0 aiohttp-fast-url-dispatcher-0.3.0 aiohttp-zlib-ng-0.3.1 aiooui-0.1.6 aiosignal-1.3.1 anyio-4.4.0
  astral-2.2 async-interrupt-1.1.1 async-timeout-4.0.3 atomicwrites-homeassistant-1.4.1 attrs-23.2.0 awesomeversion-2
  4.2.0 bcrypt-4.1.2 bleak-0.22.2 bleak-retry-connector-3.5.0 bluetooth-adapters-0.19.3 bluetooth-auto-recovery-1.4.2
  bluetooth-data-tools-1.19.4 boto3-1.34.154 botocore-1.34.154 btsocket-0.3.0 certifi-2024.7.4 cffi-1.16.0 charset-nor
  malizer-3.3.2 ciso8601-2.3.1 cryptography-42.0.5 dbus-fast-2.22.1 ecdsa-0.19.0 envs-1.4 frozenlist-1.4.1 h11-0.14.0
  habluetooth-3.2.0 hass-nabucasa-0.78.0 home-assistant-bluetooth-1.12.0 homeassistant-2024.3.3 httpcore-1.0.5 httpx-0
  .27.0 idna-3.7 ifaddr-0.2.0 jmespath-1.0.1 josepy-1.14.0 lru-dict-1.3.0 multidict-6.0.5 orjson-3.9.15 packaging-24.1
  pyOpenSSL-24.0.0 pyasn1-0.6.0 pycognito-2023.5.0 pycparser-2.22 pyrfc3339-1.1 python-dateutil-2.9.0.post0 python-jo
  se-3.3.0 python-slugify-8.0.4 pytz-2024.1 requests-2.31.0 rsa-4.9 s3transfer-0.10.2 six-1.16.0 sniffio-1.3.1 snitun-
  0.36.2 text-unidecode-1.3 typing-extensions-4.12.2 uart-devices-0.1.0 ulid-transform-0.9.0 urllib3-1.26.19 usb-devic
  es-0.4.5 voluptuous-0.13.1 voluptuous-serialize-2.6.0 yarl-1.9.4 zlib-ng-0.4.3
8. Bij de eerste start van HomeAssistant worden afhankelijke (voor HomeAssistant noodzakelijke) pakketten geïnstalleeerd en wordt een basisconfiguratie aangemaakt. Dit kan tot 10 minuten duren.
```
(homeassistant) homeassistant@raspberrypi:/srv/homeassistant $ hass
Unable to find configuration. Creating default one in /home/homeassistant/.homeassistant
```
9. Je kunt HomeAssistant nu bereiken door met een browser te surfen naar http://raspberrypi.local:8123, waarbij je raspberrypi vervangt door de netwerknaam van jouw Raspberry Pi. Als dit niet werkt, gebruik je http://ipadres:8123, waarbij ipadres overeenkomt met het IP adres van jouw Raspberry Pi.
10. Klik op de knop CREËER MIJN SMART HOME.
11. De eerste stap bestaat uit het aanmaken van een HomeAssistant gebruikersaccount. Vul de nodige gegevens in (en zorg dat je deze onthoudt of opschrijft) en maak een HomeAssistant gebruikersaccount aan.
12. Zorg voor een correcte locatie en lees en bevestig de volgende dialoogvensters.
13. Ondertussen verscheen in de terminal een WARNING:
```
2024-08-06 16:02:18.397 WARNING (MainThread) [homeassistant.bootstrap] Support for the running Python version 3.11.2 is deprecated and will be removed in Home Assistant 2024.4; Please upgrade Python to 3.12
```
  M.a.w. als Raspberry Pi OS geen upgrade naar Python 3.12 uitvoert, zal de volgende Homeassistant versie niet meer werken. Of je moet manueel upgraden naar Python 3.12, wat niet zo eenvoudig en complex is.
14. Om Home Assistant terug af te sluiten, druk je in de terminal waar je Home Assistant hebt opgestart op Ctrl+C. In het browservenster verschijnt de melding Verbinding verbroken. Opnieuw verbinden….
Nu Home Assistant werkt, kunnen we Home Assistant automatisch laten starten.
1. Daarvoor verlaten we de beveiligde HomeAssistant virtuele omgeving met de volgende opdrachten:
```
(homeassistant) homeassistant@raspberrypi:/srv/homeassistant $ deactivate
homeassistant@raspberrypi:/srv/homeassistant $ exit
exit
pi@raspberrypi:/srv $ cd
pi@raspberrypi:~ $
```
2. Start als systeembeheerder de teksteditor nano met het opstartscript /etc/systemd/system/home-assistant@homeassistant.service.
```
pi@raspberrypi:~ $ sudo nano /etc/systemd/system/home-assistant@homeassistant.service
```
  Plaats daarin het volgende opstartscript:
```
[Unit]
Description=Home Assistant
After=network-online.target

[Service]
# Activeer de volgende regel om de start van HomeAssistant 30 seconden uit te stellen
#ExecStartPre=/usr/bin/sleep 30
Type=simple
User=%i
WorkingDirectory=/home/%i/.homeassistant
ExecStart=/srv/homeassistant/bin/hass -c "/home/%i/.homeassistant"
RestartForceExitStatus=100

[Install]
WantedBy=multi-user.target
```
3. Breng het opstartsysteem op de hoogte van het nieuwe script:
```
pi@raspberrypi:~ $ sudo systemctl --system daemon-reload
```
4. Activeer ons opstartscript:
```
pi@raspberrypi:~ $ sudo systemctl enable home-assistant@homeassistant
Created symlink /etc/systemd/system/multi-user.target.wants/home-assistant@homeassistant.service → /etc/systemd/system/home-assistant@homeassistant.service.
```
5. Start het opstartscript zonder de Raspberry Pi te herstarten:
6. Deze keer verschijnt er geen uitvoer op het scherm. Deze kan je wel opvragen met:
  pi@raspberrypi:~ $ sudo systemctl status home-assistant@homeassistant
  ● home-assistant@homeassistant.service - Home Assistant
      Loaded: loaded (/etc/systemd/system/home-assistant@homeassistant.service; enabled; preset: enabled)
      Active: active (running) since Tue 2024-08-06 16:24:14 CEST; 16s ago
    Main PID: 4363 (hass)
       Tasks: 13 (limit: 4444)
         CPU: 2.979s
      CGroup: /system.slice/system-home\x2dassistant.slice/home-assistant@homeassistant.service
              └─4363 /srv/homeassistant/bin/python3 /srv/homeassistant/bin/hass -c /home/homeassistant/.homeassistant
  
  aug 06 16:24:14 raspberrypi systemd[1]: Started home-assistant@homeassistant.service - Home Assistant.
  aug 06 16:24:17 raspberrypi hass[4363]: 2024-08-06 16:24:17.347 WARNING (MainThread) [homeassistant.bootstrap] Supp>
  lines 1-11/11 (END)
  Druk op de toets q om deze opdracht af te sluiten.
7. Herstart de Raspberry Pi. Home Assistant moet nu automatisch starten. Controleer of Home Assistant correct is opgestart. Mocht dit niet het geval zijn, probeer dan de opstart van Home Assistant 30 seconden te vertragen door de regel ExecStartPre=/usr/bin/sleep 30 in het opstartscript te activeren (hekje vooraan verwijderen).

Om gebruik te kunnen maken van de GPIO pinnen van de Raspberry Pi moeten we Home Assistant uitbreiden met een aantal scripts. Aangezien we Home Assistant uitbreiden, moeten we ons aanmelden als homeassistant gebruiker en werken in zijn home map. Dit kan met de volgende twee opdrachten:

pi@raspberrypi:~ $ sudo -u homeassistant -H -s
homeassistant@raspberrypi:/home/pi $ cd

Download de scripts van de GitHub pagina van de ontwikkelaar met de opdracht:

homeassistant@raspberrypi:~ $ wget https://github.com/jdeneef/ha_gpiod/archive/refs/heads/main.zip
--2024-08-10 16:14:12--  https://github.com/jdeneef/ha_gpiod/archive/refs/heads/main.zip
Herleiden van github.com (github.com)... 140.82.121.3
Verbinding maken met github.com (github.com)|140.82.121.3|:443... verbonden.
HTTP-verzoek is verzonden; wachten op antwoord... 302 Found
Locatie: https://codeload.github.com/jdeneef/ha_gpiod/zip/refs/heads/main [volgen...]
--2024-08-10 16:14:13--  https://codeload.github.com/jdeneef/ha_gpiod/zip/refs/heads/main
Herleiden van codeload.github.com (codeload.github.com)... 140.82.121.10
Verbinding maken met codeload.github.com (codeload.github.com)|140.82.121.10|:443... verbonden.
HTTP-verzoek is verzonden; wachten op antwoord... 200 OK
Lengte: niet-opgegeven [application/zip]
Wordt opgeslagen als: ‘main.zip’

main.zip                       [ <=>                                           ]  14,59K  --.-KB/s    in 0,01s   

2024-08-10 16:14:13 (1,33 MB/s) - '‘main.zip’' opgeslagen [14941]

Pak het gedownloade ZIP archief uit met:

homeassistant@raspberrypi:~ $ unzip main.zip
Archive:  main.zip
86dc22854db6e64090b16f220c6e1ea7618a0b34
   creating: ha_gpiod-main/
   creating: ha_gpiod-main/.github/
   creating: ha_gpiod-main/.github/workflows/
  inflating: ha_gpiod-main/.github/workflows/hacs.yml  
  inflating: ha_gpiod-main/.github/workflows/hassfest.yml  
  inflating: ha_gpiod-main/.gitignore  
  inflating: ha_gpiod-main/LICENSE   
  inflating: ha_gpiod-main/README-DEV.md  
  inflating: ha_gpiod-main/README.md  
  inflating: ha_gpiod-main/TODO.md   
   creating: ha_gpiod-main/config/
  inflating: ha_gpiod-main/config/configuration-example.yaml  
   creating: ha_gpiod-main/custom_components/
   creating: ha_gpiod-main/custom_components/gpiod/
  inflating: ha_gpiod-main/custom_components/gpiod/__init__.py  
  inflating: ha_gpiod-main/custom_components/gpiod/binary_sensor.py  
 extracting: ha_gpiod-main/custom_components/gpiod/const.py  
  inflating: ha_gpiod-main/custom_components/gpiod/cover.py  
  inflating: ha_gpiod-main/custom_components/gpiod/hub.py  
  inflating: ha_gpiod-main/custom_components/gpiod/manifest.json  
  inflating: ha_gpiod-main/custom_components/gpiod/switch.py  
  inflating: ha_gpiod-main/hacs.json  
 extracting: ha_gpiod-main/requirements.txt

En kopieer de map met de scripts naar Home Assistant:

homeassistant@raspberrypi:~ $ cp -r ha_gpiod-main/custom_components .homeassistant/

Om de uitbreiding in Home Assistant op te nemen, herstarten we Home Assistant met de volgende opdrachten:

homeassistant@raspberrypi:~ $ exit
exit
pi@raspberrypi:~ $ sudo systemctl restart home-assistant@homeassistant
pi@raspberrypi:~ $ sudo -u homeassistant -H -s
homeassistant@raspberrypi:/home/pi $ cd

Het configuratiebestand van Home Assistant gebruikt een structuur die lijkt op HTML en XML, namelijk Yet Another Markup Language (YAML).
1. Met een teksteditor kan je de configuratie ~/.homeassistant/configuration.yaml aanpassen.
```
homeassistant@raspberrypi:~ $ nano ~/.homeassistant/configuration.yaml
```
  Voeg de volgende regels toe om de LED in en uit te schakelen (schakelen doe je met een switch):
  switch:
  - platform: gpiod
     switches:
       - name: "Led"
         port: 12
  De LED is namelijk verbonden met BCM12 (port: 12) via de Rasprberry Pi GPIO pennen (gpiod). De naam Led mag je vrij kiezen en verschijnt in het onderdeel Toestanden op de webpagina van Home Assistant (zie volgende punt). De regels die je nodig hebt voor een bepaald domotica apparaat of dienst staan beschreven op de webpagina Available components.
2. Om een nieuwe configuratie te kunnen testen op fouten, activeer je in de categorie Ontwikkelhulpmiddelen het onderdeel YAML-configuratie. Klik op de knop Configuratie controleren om de configuratiebestanden te testen. Bij fouten in de configuratiebestanden, krijg je Meldingen en kan je een beschrijving terugvinden in het Logboek.
3. Om de aanpassingen toe te passen, moet je Home Assistant herstarten. Dit doe je op de webpagina van Home Assistant via Ontwikkelhulpmiddelen/YAML-configuratie.
4. Activeer op de webpagina het onderdeel Overzicht. Er is een extra paneel verschenen met alle Schakelaars (switch) met daarin de Led schakelaar. Klik op het knopje om de LED te laten oplichten. De schakelaar wordt blauw om aan te duiden dat de schakelaar is ingeschakeld en de LED oplicht.
5. Schakel de LED terug uit.
6. Klik je op de naam van de schakelaar (Led) of zijn pictogram en de Led krijgt een eigen venster. Een knopje bovenaan rechts in dit venster toont de Geschiedenis van de schakelaar. In technische termen noemen we dit het logboek.
7. Sluit het log-venster door ernaast te klikken.
Tijd om de drukknop in Home Assistant op te nemen.
1. Een drukknop is een sensor (invoer-apparaat) met twee toestanden (binair: aan of uit). Voeg de volgende regels toe aan het configuratiebestand van Home Assistant:
  binary_sensor:
  - platform: gpiod
     sensors:
     - name: "Drukknop"
       port: 8
       active_low: true
  De binaire sensor is verbonden met de Raspberry Pi GPIO pennen (gpiod) op BCM8 en krijgt als naam Drukknop. De optie active_low: true zorgt ervoor dat de BCM8 hoog is indien de schakelaar open is. Bij een gesloten schakelaar wordt BCM8 door de schakelaar verbonden met de massa en dus laag getrokken.
2. Na het aanpassen van het configuratiebestand zorg je dat Home Assistant de nieuwe instellingen gebruikt.
3. Je ziet nu in het onderdeel Overzicht op de webpagina van Home Assistant in het paneel Binaire sensor een pictogram met de naam Drukknop staan. Door het drukken op de drukknop moet de toestand veranderen (vinkje/geen vinkje).
4. Indien dit niet correct werkt, is dit te wijten aan dender waarbij de schakelaar niet eenduidig hoog of laag doorgeeft. Dit kan je oplossen door het signaal dat van de schakelaar als volgt te verbeteren:
  1. Softwarematig: voeg aan de configuratie van de binary_sensor de eigenschap debounce met een hogere waarde toe. Let bij het ingeven van nieuwe instellingen steeds op het correct inspringen van de regels, de volgende regel begint met zes spaties.
    debounce: 200
    Standaard heeft deze de waarde 50 ms. Alle configuratie opties kan je terugvinden op de GitHub pagina van de HomeAssistant GPIO ontwikkelaar.
  2. Hardwarematig: hoewel de Raspberry Pi GPIO ingangen reeds voorzien zijn van inschakelbare pull-up weerstanden (50k ohm), kan je het signaal verbeteren door zelf een 5k ohm tussen de GPIO-ingang en de 3,3 volt power pin te monteren. De drukknoppen leveren een nog beter signaal als je er een 0,1 µF condensator over plaatst (parallel) (zie Avoiding False Hits with RPI.GPIO Edge Detection). Door tussen de drukknop en de GPIO pennen een elektronisch circuit, zoals bij goede domotica sensors het geval is, te plaatsen wordt het signaal nog beter.
  3. Een combinatie van software en hardware oplossingen.
Pas echt leuk wordt het als je de LED kunt bedienen met de drukknop en via Home Assistant. We moeten dus zorgen dat Home Assistant de LED laat branden als de toestand van de drukknop verandert.
1. Open het Automatisatie configuratiebestand met:
```
homeassistant@raspberrypi:~ $ nano ~/.homeassistant/automations.yaml
```
2. Vervang alle inhoud van het automations.yaml configuratiebestand door:
  - alias: Schakel Led aan
  trigger:
  - entity_id: binary_sensor.gpiod_gpiod_8_drukknop
     from: 'off'
     platform: state
     to: 'on'
  action:
  - service: switch.turn_on
     entity_id: switch.gpiod_gpiod_12_led
  Het configuratiebestand automations.yaml bevat alle taken die automatisch uitgevoerd moeten worden. Het - teken duidt de start van de eerste automatisatie taak aan. De alias is de naam van de taak. De trigger is de gebeurtenis die de taak in gang zet, hier wordt de toestand (state) van de sensor binary_sensor.gpiod_gpiod_8_drukknop gecontroleerd. Als deze de toestand 'on' (ingeschakeld) is, wordt de actie (action) uitgevoerd. De actie (action) die bij het voorkomen van de gebeurtenis (trigger) wordt uitgevoerd, is het inschakelen (switch.turn_on) van de schakelaar switch.gpiod_gpiod_12_led. De entity_id's en state van de verschillende domotica apparaten kan je terugvinden bij de Ontwikkelhulpmiddelen op het tabblad Statussen. In ons geval gaat het om de schakelaar switch.gpiod_gpiod_12_led.
3. Test of je de LED nog kunt in- en uitschakelen via het Switch paneel. Raadpleeg bij problemen het Logboek.
4. Test of je een uitgeschakelde LED kunt inschakelen door op de drukknop te drukken. Zoals je merkt werkt dit alleen als de Drukknop toestand overgaat van niet uitgeschakeld naar ingeschakeld. Om de LED via de drukknop uit te schakelen, moet je de volgende regels in het automations.yaml configuratiebestand toevoegen:
  - alias: Schakel Led uit
  trigger:
  - entity_id: binary_sensor.gpiod_gpiod_8_drukknop
     from: 'on'
     platform: state
     to: 'off'
  action:
  - service: switch.turn_off
     entity_id: switch.gpiod_gpiod_12_led
Bij het testen blijkt al vlug dat een "Momentary" schakelaar (enkel contact bij het indrukken) niet geschikt is als gewone schakelaar (omschakelaar). Voor de volgende toepassing is een contactschakelaar dan weer ideaal.
Om energie te besparen, worden lampen soms automatisch na een bepaalde tijd uitgeschakeld (denk aan de verlichting in de traphal van een appartement). Dit kan in het scripts.yaml configuratiebestand:
```
homeassistant@raspberrypi:~ $ nano ~/.homeassistant/scripts.yaml
```
Voor onze tijdschakelaar voer je de volgende regels aan het scripts.yaml configuratiebestand van Home Assistant toe (let ook hier weer op het correct inspringen, zeker bij de eerste regel die begint met twee spaties):
timed_led:
   alias: "LED laten branden en timer starten"
   sequence:
     # Eventuele oude timer resetten
     - service: script.turn_off
       data:
          entity_id: script.timer_off
     - service: switch.turn_on
       data:
         entity_id: switch.gpiod_gpiod_12_led
     # Nieuwe timer starten
     - service: script.turn_on
       data:
         entity_id: script.timer_off

timer_off:
   alias: "Schakel de LED na 10 minuten uit"
   sequence:
     - delay:
         minutes: 10
     - service: switch.turn_off
       data:
         entity_id: switch.gpiod_gpiod_12_led
We gebruiken twee scripts. Het script timed_led zorgt voor het resetten van een vorige timer (iemand heeft binnen de 10 minuten nogmaals op de drukknop geduwd), schakelt daarna de LED in en start de timer. Het script timer_off wacht (delay) 10 minuten en schakelt daarna de led uit. Om dit script te testen, zorg je voor 1 minuut vertraging. Daarenboven moet je de actie bij het inschakelen van de drukknop aanpassen naar:
action:
- service: homeassistant.turn_on
   entity_id: script.timed_led
Waardoor het script timed_led wordt uitgevoerd bij het inschakelen van de drukknop. Zorg echter ook voor het uitschakelen van de automatisatie Schakel Led uit:
#- alias: Schakel Led uit
# trigger:
# - entity_id: binary_sensor.gpiod_gpiod_8_drukknop
#    from: 'on'
#    platform: state
#    to: 'off'
# action:
# - service: switch.turn_off
#    entity_id: switch.gpiod_gpiod_12_led

We waarderen onze drukknop op naar een alarmschakelaar.

Daarbij moet een alarmsignaal afgaan. We gebruiken daarvoor een MP3 bestand dat we downloaden:

homeassistant@raspberrypi:~ $ wget https://partofthething.com/thoughts/wp-content/uploads/2016/08/burglar.mp3
--2024-08-14 15:22:18--  https://partofthething.com/thoughts/wp-content/uploads/2016/08/burglar.mp3
Herleiden van partofthething.com (partofthething.com)... 198.199.93.72
Verbinding maken met partofthething.com (partofthething.com)|198.199.93.72|:443... verbonden.
HTTP-verzoek is verzonden; wachten op antwoord... 200 OK
Lengte: 2489578 (2,4M) [audio/mpeg]
Wordt opgeslagen als: ‘burglar.mp3’

burglar.mp3                  100%[==============================================>]   2,37M  1,54MB/s    in 1,5s    

2024-08-14 15:22:20 (1,54 MB/s) - '‘burglar.mp3’' opgeslagen [2489578/2489578]

Nog leuker wordt het als je zelf een MP3 bestand in elkaar zet (bijvoorbeeld met een gevaarlijk blaffende hond).

De homeassistant gebruiker kan het MP3 bestand enkel afspelen, als deze lid is van de groep audio (toegang heeft tot de audio hardware van de Raspberry Pi):
```
homeassistant@raspberrypi:~ $ exit
exit
pi@raspberrypi:~ $ sudo usermod -a -G audio homeassistant
```

Daarenboven heb je voor het afspelen van MP3 bestanden speciale software nodig. Voor WAV bestanden niet. Ons burglar MP3 bestand zet je om naar een WAV bestand met de volgende opdracht:

pi@raspberrypi:~ $ sudo -u homeassistant -H -s
homeassistant@raspberrypi:/home/pi $ cd
homeassistant@raspberrypi:~ $ ffmpeg  -hide_banner -i burglar.mp3 burglar.wav
Input #0, mp3, from 'burglar.mp3':
  Metadata:
    title           : burglar alarm
  Duration: 00:01:45.64, start: 0.025057, bitrate: 188 kb/s
  Stream #0:0: Audio: mp3, 44100 Hz, stereo, fltp, 188 kb/s
    Metadata:
      encoder         : LAME3.99r
Stream mapping:
  Stream #0:0 -> #0:0 (mp3 (mp3float) -> pcm_s16le (native))
Press [q] to stop, [?] for help
Output #0, wav, to 'burglar.wav':
  Metadata:
    INAM            : burglar alarm
    ISFT            : Lavf59.27.100
  Stream #0:0: Audio: pcm_s16le ([1][0][0][0] / 0x0001), 44100 Hz, stereo, s16, 1411 kb/s
    Metadata:
      encoder         : Lavc59.37.100 pcm_s16le
size=   18190kB time=00:01:45.59 bitrate=1411.2kbits/s speed= 186x    
video:0kB audio:18190kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 0.000537%

Eerst gaan we na welke audio uitvoer apparaten we kunnen gebruiken:

homeassistant@raspberrypi:~ $ aplay -l
**** List of PLAYBACK Hardware Devices ****
card 0: vc4hdmi0 [vc4-hdmi-0], device 0: MAI PCM i2s-hifi-0 [MAI PCM i2s-hifi-0]
  Subdevices: 1/1
  Subdevice #0: subdevice #0
card 1: vc4hdmi1 [vc4-hdmi-1], device 0: MAI PCM i2s-hifi-0 [MAI PCM i2s-hifi-0]
  Subdevices: 1/1
  Subdevice #0: subdevice #0
card 2: SoundBar [Dell AC511 USB SoundBar], device 0: USB Audio [USB Audio]
  Subdevices: 1/1
  Subdevice #0: subdevice #0

Opmerking: Bluetooth apparaten worden niet weergegeven en zijn moeilijk om te activeren voor toepassingen zoals Homeassistant.

In het voorbeeld gebruiken we een USB luidspreker (SoundBar). Test het afspelen van het WAV bestand door de homeassistant gebruiker en regel tegelijkertijd het volume af:
```
homeassistant@raspberrypi:~ $ aplay --device hw:CARD=SoundBar,DEV=0 burglar.wav
Playing WAVE 'burglar.wav' : Signed 16 bit Little Endian, Rate 44100 Hz, Stereo
^CAborted by signal Onderbroken...
```
Ik heb het afspelen van het WAV bestand afgebroken met Ctrl+c.

Bovenstaande opdracht gebruikt de USB audio uitgang van de Raspberry Pi. Een uitgebreider overzicht van de op de Raspberry Pi aanwezige audio apparaten, geef je weer met de opdracht:

homeassistant@raspberrypi:~ $ aplay -L
null
    Discard all samples (playback) or generate zero samples (capture)
default
    Default Audio Device
sysdefault
    Default Audio Device
lavrate
    Rate Converter Plugin Using Libav/FFmpeg Library
samplerate
    Rate Converter Plugin Using Samplerate Library
speexrate
    Rate Converter Plugin Using Speex Resampler
jack
    JACK Audio Connection Kit
oss
    Open Sound System
pulse
    PulseAudio Sound Server
speex
    Plugin using Speex DSP (resample, agc, denoise, echo, dereverb)
upmix
    Plugin for channel upmix (4,6,8)
vdownmix
    Plugin for channel downmix (stereo) with a simple spacialization
hw:CARD=vc4hdmi0,DEV=0
    vc4-hdmi-0, MAI PCM i2s-hifi-0
    Direct hardware device without any conversions
plughw:CARD=vc4hdmi0,DEV=0
    vc4-hdmi-0, MAI PCM i2s-hifi-0
    Hardware device with all software conversions
default:CARD=vc4hdmi0
    vc4-hdmi-0, MAI PCM i2s-hifi-0
    Default Audio Device
sysdefault:CARD=vc4hdmi0
    vc4-hdmi-0, MAI PCM i2s-hifi-0
    Default Audio Device
hdmi:CARD=vc4hdmi0,DEV=0
    vc4-hdmi-0, MAI PCM i2s-hifi-0
    HDMI Audio Output
dmix:CARD=vc4hdmi0,DEV=0
    vc4-hdmi-0, MAI PCM i2s-hifi-0
    Direct sample mixing device
usbstream:CARD=vc4hdmi0
    vc4-hdmi-0
    USB Stream Output
hw:CARD=vc4hdmi1,DEV=0
    vc4-hdmi-1, MAI PCM i2s-hifi-0
    Direct hardware device without any conversions
plughw:CARD=vc4hdmi1,DEV=0
    vc4-hdmi-1, MAI PCM i2s-hifi-0
    Hardware device with all software conversions
default:CARD=vc4hdmi1
    vc4-hdmi-1, MAI PCM i2s-hifi-0
    Default Audio Device
sysdefault:CARD=vc4hdmi1
    vc4-hdmi-1, MAI PCM i2s-hifi-0
    Default Audio Device
hdmi:CARD=vc4hdmi1,DEV=0
    vc4-hdmi-1, MAI PCM i2s-hifi-0
    HDMI Audio Output
dmix:CARD=vc4hdmi1,DEV=0
    vc4-hdmi-1, MAI PCM i2s-hifi-0
    Direct sample mixing device
usbstream:CARD=vc4hdmi1
    vc4-hdmi-1
    USB Stream Output
hw:CARD=SoundBar,DEV=0
    Dell AC511 USB SoundBar, USB Audio
    Direct hardware device without any conversions
plughw:CARD=SoundBar,DEV=0
    Dell AC511 USB SoundBar, USB Audio
    Hardware device with all software conversions
default:CARD=SoundBar
    Dell AC511 USB SoundBar, USB Audio
    Default Audio Device
sysdefault:CARD=SoundBar
    Dell AC511 USB SoundBar, USB Audio
    Default Audio Device
front:CARD=SoundBar,DEV=0
    Dell AC511 USB SoundBar, USB Audio
    Front output / input
surround21:CARD=SoundBar,DEV=0
    Dell AC511 USB SoundBar, USB Audio
    2.1 Surround output to Front and Subwoofer speakers
surround40:CARD=SoundBar,DEV=0
    Dell AC511 USB SoundBar, USB Audio
    4.0 Surround output to Front and Rear speakers
surround41:CARD=SoundBar,DEV=0
    Dell AC511 USB SoundBar, USB Audio
    4.1 Surround output to Front, Rear and Subwoofer speakers
surround50:CARD=SoundBar,DEV=0
    Dell AC511 USB SoundBar, USB Audio
    5.0 Surround output to Front, Center and Rear speakers
surround51:CARD=SoundBar,DEV=0
    Dell AC511 USB SoundBar, USB Audio
    5.1 Surround output to Front, Center, Rear and Subwoofer speakers
surround71:CARD=SoundBar,DEV=0
    Dell AC511 USB SoundBar, USB Audio
    7.1 Surround output to Front, Center, Side, Rear and Woofer speakers
iec958:CARD=SoundBar,DEV=0
    Dell AC511 USB SoundBar, USB Audio
    IEC958 (S/PDIF) Digital Audio Output
dmix:CARD=SoundBar,DEV=0
    Dell AC511 USB SoundBar, USB Audio
    Direct sample mixing device
usbstream:CARD=SoundBar
    Dell AC511 USB SoundBar
    USB Stream Output

Open het scripts configuratiebestand van Home Assistant en voeg de volgende stap (sequence) toe aan het script timed_led:
     # Inbraakalarm
     - service: script.turn_on
       data:
         entity_id: script.burglar
Dit start het script burglar als je de drukknop indrukt. Vanzelfsprekend zou je de drukknop kunnen vervangen door een bewegingssensor (PIR) of een andere inbraakdetectieschakelaar.
Voeg aan de scripts configuratiebestand het burglar script toe:
burglar:
   alias: Inbraakalarm
   sequence:
     - service: shell_command.intruder_music
Dit script voert een terminalopdracht (shell command) uit dat beschreven wordt in de intruder_music opdracht.
Voeg in het configuratiebestand (configuration.yaml) de shell_command sectie toe met de intruder_music opdracht:
shell_command:
intruder_music: aplay --device hw:CARD=SoundBar,DEV=0 /home/homeassistant/burglar.wav
Test het inbraakalarm door Home Assistant te herstarten en op de drukknop te drukken.
Onderbreek het afspelen van het WAV bestand in de terminal:
```
homeassistant@raspberrypi:~ $ killall aplay
```

We breiden ons inbraakalarm uit met momentopnames, met andere woorden bij het detecteren van een inbraakalarm nemen we een aantal foto's via de Pi Camera (beveiligingscamera):
1. Gelijkaardig als bij het afspelen van geluid, kan de homeassistant gebruiker enkel foto's nemen als deze lid is van de groep video (toegang heeft tot de Pi Camera van de Raspberry Pi):
```
homeassistant@raspberrypi:~ $ exit
exit
pi@raspberrypi:~ $ sudo usermod -a -G video homeassistant
```
2. Om Home Assistant verder te configureren, moet je je terug als homeassistant gebruiker aanmelden:
```
pi@raspberrypi:~ $ sudo -u homeassistant -H -s
homeassistant@raspberrypi:/home/pi $ cd
```
3. Nu pas je het inbraakalarmscript van Home Assistant aan zodat er voor het afgaan van het alarmsignaal een foto wordt genomen:
  burglar:
     alias: Inbraakalarm
     sequence:
       - service: shell_command.snapshot
         data:
             filename: /home/homeassistant/snapshot.jpg
       - delay:
             seconds: 1
       - service: shell_command.intruder_music
  Na het maken van de foto, wordt nog één seconde gewacht (delay) om het alarmsignaal af te spelen. Dit zorgt ervoor dat de inbreker niet weet wanneer en hoe die werd betrapt.
4. Zoals je merkt wordt in het inbraakalarmscript een nieuwe terminal opdracht uitgevoerd, m.a.w. vul de sectie shell_command (in configuration.yaml) aan met de snapshot opdracht:
  snapshot: rpicam-still --nopreview -o {{filename}}
5. Test het inbraakalarm in Homeassistant en controleer of de nieuwe instelling werkt. Bijvoorbeeld met de volgende opdracht:
  homeassistant@raspberrypi:~ $ ls -l snapshot.jpg
  -rw-r--r-- 1 homeassistant homeassistant 634113 14 aug 16:34 snapshot.jpg
  Kijk daarbij vooral naar het tijdstip, dit moet overeenkomen met het activeren van het inbraakalarm.
Nu we een foto hebben, kunnen we die doormailen. Zo worden we verwittigd dat het inbraakalarm is afgegaan en zien we wat er gebeurde. Zijn er echte inbrekers aan het werk of komen de buren de planten water geven. Daarnaast hebben we een foto in handen, zelfs als ons alarmsysteem vakkundig wordt gemolesteerd:
1. Eerst voeren we de e-mail gegevens in het configuratiebestand (configuration.yaml) in met een sectie (vervang daarbij de fictieve gegevens door jouw eigen email-gegevens):
  notify:
  name: emailer
  platform: smtp
  server: smtp-mail.outlook.com
  # port: 587
  sender: voor.naam@outlook.com
  encryption: starttls
  username: voor.naam@outlook.com
  password: sterkwachtwoord
  recipient: voor.naam@outlook.com
  
  homeassistant:
  allowlist_external_dirs:
  - "/home/homeassistant"
  De server is de computer die de mail moet verwerken (Proximus: relay.proximus.be, Telenet: smtp.telenet.be). De instelling sender bevat het e-mail adres van degene die de mail verzendt. De recipient is het e-mail adres van de persoon die de e-mail zal ontvangen. De regels die beginnen met een # zijn uitgeschakeld en enkel noodzakelijk als de e-mail provider dit vereist.
  Met de laatste drie regels maken we bestanden in de map /home/homeassistant beschikbaar voor verwerking door Home Assistant, m.a.w. de aangemaakte foto.
2. Om effectief een e-mail te versturen, voeg je na de 1 seconde wachttijd en voor het afspelen van het geluidsbestand een notificatie toe aan het burglar inbraakalarmscript:
       - service: notify.emailer
         data:
             title: 'Inbraakalarm'
             message: 'Er wordt in het appartement ingebroken!!'
             data:
                 images:
                     - /home/homeassistant/snapshot.jpg
3. Test het inbraakalarm en controleer of je een e-mail met een foto kreeg.
4. Raadpleeg de documentatie van HomeAssistant en bepaal hoe je e-mail kunt sturen naar een GMail adres. GMail is een veelzijdig en veel gebruikte dienst en is dan ook extra beveiligd waardoor je zonder aanpassingen in GMail zelf geen geautomatiseerde mails kunt versturen.
Om het alarmsignaal overtuigend te laten overkomen, sluit je de Raspberry Pi aan op jouw stereo installatie en zorg je dat er bij een inbraakalarm de stereo installatie wordt ingeschakeld en het volume luid staat voor je het alarmsignaal ten gehore brengt. Maar dit is voor een andere keer.

MQTT

Home Assistant ondersteunt geen i2c apparaten, we gaan deze keer een MQTT server opzetten om data afkomstig van i2c apparaten naar Home Assistant te sturen. Daar MQTT een standaard is, ondersteunen zeer veel domotica (ook draadloze) sensoren, schakelaars, enz. MQTT. Al deze MQTT compatibele apparaten hebben een MQTT server nodig om hun gegevens naar toe te sturen.

MQTT server installeren

Om de MQTT server te kunnen installeren, melden we de homeassistant gebruiker af:

homeassistant@raspberrypi:~ $ exit
exit

Installeer de Mosquito MQTT server met de volgende opdracht:

pi@raspberrypi:~ $ sudo apt install -y mosquitto mosquitto-clients
Pakketlijsten worden ingelezen... Klaar
Boom van vereisten wordt opgebouwd... Klaar
De statusinformatie wordt gelezen... Klaar 
De volgende extra pakketten zullen geïnstalleerd worden:
  libdlt2 libmosquitto1
De volgende NIEUWE pakketten zullen geïnstalleerd worden:
  libdlt2 libmosquitto1 mosquitto mosquitto-clients
0 opgewaardeerd, 4 nieuw geïnstalleerd, 0 te verwijderen en 21 niet opgewaardeerd.
Er moeten 633 kB aan archieven opgehaald worden.
Na deze bewerking zal er 1.883 kB extra schijfruimte gebruikt worden.
Ophalen:1 http://deb.debian.org/debian bookworm/main arm64 libdlt2 arm64 2.18.8-6 [54,4 kB]
Ophalen:2 http://deb.debian.org/debian bookworm/main arm64 libmosquitto1 arm64 2.0.11-1.2+deb12u1 [85,9 kB]
Ophalen:3 http://deb.debian.org/debian bookworm/main arm64 mosquitto arm64 2.0.11-1.2+deb12u1 [384 kB]
Ophalen:4 http://deb.debian.org/debian bookworm/main arm64 mosquitto-clients arm64 2.0.11-1.2+deb12u1 [109 kB]
633 kB opgehaald in 0s (5.773 kB/s)        
Voorheen niet geselecteerd pakket libdlt2:arm64 wordt geselecteerd.
(Database wordt ingelezen ... 149455 bestanden en mappen momenteel geïnstalleerd.)
Uitpakken van .../libdlt2_2.18.8-6_arm64.deb wordt voorbereid...
Bezig met uitpakken van libdlt2:arm64 (2.18.8-6) ...
Voorheen niet geselecteerd pakket libmosquitto1:arm64 wordt geselecteerd.
Uitpakken van .../libmosquitto1_2.0.11-1.2+deb12u1_arm64.deb wordt voorbereid...
Bezig met uitpakken van libmosquitto1:arm64 (2.0.11-1.2+deb12u1) ...
Voorheen niet geselecteerd pakket mosquitto wordt geselecteerd.
Uitpakken van .../mosquitto_2.0.11-1.2+deb12u1_arm64.deb wordt voorbereid...
Bezig met uitpakken van mosquitto (2.0.11-1.2+deb12u1) ...
Voorheen niet geselecteerd pakket mosquitto-clients wordt geselecteerd.
Uitpakken van .../mosquitto-clients_2.0.11-1.2+deb12u1_arm64.deb wordt voorbereid...
Bezig met uitpakken van mosquitto-clients (2.0.11-1.2+deb12u1) ...
Instellen van libmosquitto1:arm64 (2.0.11-1.2+deb12u1) ...
Instellen van mosquitto-clients (2.0.11-1.2+deb12u1) ...
Instellen van libdlt2:arm64 (2.18.8-6) ...
Instellen van mosquitto (2.0.11-1.2+deb12u1) ...
Created symlink /etc/systemd/system/multi-user.target.wants/mosquitto.service → /lib/systemd/system/mosquitto.service.
Bezig met afhandelen van triggers voor man-db (2.11.2-2) ...
Bezig met afhandelen van triggers voor libc-bin (2.36-9+rpt2+deb12u7) ...

Met de volgende opdracht zorgen we dat de MQTT server automatisch start:

pi@raspberrypi:~ $ sudo systemctl enable mosquitto.service
Synchronizing state of mosquitto.service with SysV service script with /lib/systemd/systemd-sysv-install.
Executing: /lib/systemd/systemd-sysv-install enable mosquitto

Gegevens ophalen en doorsturen naar de MQTT server

Met behulp van een script sturen we de temperatuur van onze MCP9808 sensor door naar de MQTT server. Maak met de teksteditor nano het script aan:

pi@raspberrypi:~ $ sudo nano /usr/sbin/mcp9808_mqtt.sh

Met de volgende inhoud:

#!/bin/bash
# mcp9808_mqtt.sh - send mcp9808 data to MQTT broker
#

# De temperatuur ophalen
temp=$(cat /sys/bus/i2c/devices/1-0018/hwmon/hwmon3/temp1_input)
# Omrekenen naar van m°C naar °C met 1 cijfer na de komma
temp=$(echo "scale=1; $temp / 1000" | bc)
# Temperatuur doorsturen naar MQTT Broker
mosquitto_pub -h localhost -t mcp9808/temp -m "$temp"

Na het opslaan en afsluiten van nano, maken we het script uitvoerbaar met:
```
pi@raspberrypi:~ $ sudo chmod +x /usr/sbin/mcp9808_mqtt.sh
```

Om dit script op de achtergrond als server (service) uit te voeren, maken we het volgende systeembestand aan:

pi@raspberrypi:~ $ sudo nano /etc/systemd/system/mcp9808_mqtt.service

Met de volgende inhoud:

[Unit]
Description=Send MCP9808 temp to MQTT Broker
[Service]
Type=simple
ExecStart=/usr/sbin/mcp9808_mqtt.sh

Om met deze service elke minuut een temperatuur door te sturen, maken we een timer aan met:

pi@raspberrypi:~ $ sudo nano /etc/systemd/system/mcp9808_mqtt.timer

Met de volgende inhoud:

[Unit]
Description=Run mcp9808_mqtt every minute

[Timer]
OnCalendar=*-*-* *:*:00
Unit=mcp9808_mqtt.service

[Install]
WantedBy=timers.target

Nu we alle onderdelen hebben, kunnen we de timer automatisch laten starten bij het opstarten van de Raspberry Pi:

pi@raspberrypi:~ $ sudo systemctl enable mcp9808_mqtt.timer 
Created symlink /etc/systemd/system/timers.target.wants/mcp9808_mqtt.timer → /etc/systemd/system/mcp9808_mqtt.timer.

Je kunt de timer ook manueel starten met:

pi@raspberrypi:~ $ sudo systemctl start mcp9808_mqtt.timer

Je kunt het doorgeven van de MCP9808 temperatuurmeting aan MQTT testen met:
```
pi@raspberrypi:~ $ mosquitto_sub -h localhost -v -t mcp9808/temp
mcp9808/temp 32.6
```
Indien alles werkt zoals het hoort, krijg je elke minuut een waarde op het scherm. Breek de opdracht af met de sneltoets Ctrl+c.
MQTT sensorwaarden in Home Assistant integreren
Eerst koppelen we Home Assistant aan de MQTT server. We gebruiken daarvoor de Home Assistant webpagina.
Activeer in Home Assistant het onderdeel Instellingen.
Open het onderdeel Apparaten & diensten.
Klik op de knop .
Zoek naar mqtt.
Open de categorie MQTT.
Ga door naar MQTT.
Uiteindelijk krijg je het MQTT dialoogvenster. Het enige wat je hier moet invullen is de hostnaam of het IP-adres van de Broker. In ons geval localhost (hetzelfde apparaat).
Klik op de knop VERZENDEN.
Klik op de knop VOLTOOIEN.
Klik nu bij Geconfigureerd op het paneel MQTT.
Klik in het paneel Integratie-items op de koppeling CONFIGUREREN.
Vul in het paneel Luisteren naar 'onderwerp' bij Onderwerp om op te abonneren ons onderwerp (topic) in: mcp9808/temp.
Klik op de koppeling BEGIN MET LUISTEREN. Daaronder moet nu elke minuut een temperatuurmeting verschijnen.
Om de temperatuurmetingen in het Overzicht weer te geven en Home Assistant ermee aan de slag te laten gaan, moeten we opnieuw het configuratiebestand aanpassen. Dat kunnen we enkel door ons aan te melden als homeassistant gebruiker:
```
pi@raspberrypi:~ $ sudo -u homeassistant -H -s
homeassistant@raspberrypi:/home/pi $ cd
```

We passen de configuratie aan met nano:

homeassistant@raspberrypi:~ $ nano ~/.homeassistant/configuration.yaml

En voegen de volgende regels toe:

mqtt:
  sensor:
    - name: "Temperatuur Raspberry Pi"
      state_topic: "mcp9808/temp"
      device_class: temperature
      unit_of_measurement: "°C"

Sla de aanpassing op, controleer de configuratie en herstart Home Assistant om de sensor in het Overzicht weer te geven.
Daar we klaar zijn met het configureren van Home Assistant, kunnen we terug afmelden:
```
homeassistant@raspberrypi:~ $ exit
exit
```

Om de 1-Wire temperatuursensor DS18B20 aan Home Assistant toevoegen gebruiken we eveneens MQTT:
1. Met behulp van een script sturen we de temperatuur van onze DS18B20 sensor door naar de MQTT server. Maak met de teksteditor nano het script aan:
```
pi@raspberrypi:~ $ sudo nano /usr/sbin/ds18b20_mqtt.sh
```
  Met de volgende inhoud:
  # ds18b20_mqtt.sh - send DS18B20 data to MQTT broker
  #
  
  # De temperatuur ophalen
  pinctrl set 4 ip pu
  temp=$(cat /sys/bus/w1/devices/28-*/w1_slave | tail -1 | awk -F 't=' '{ print$2 }')
  # Omrekenen naar van m°C naar °C met 1 cijfer na de komma
  temp=$(echo "scale=1; $temp / 1000" | bc)
  # Temperatuur doorsturen naar MQTT Broker
  mosquitto_pub -h localhost -t ds18b20/temp -m "$temp"
2. Na het opslaan en afsluiten van nano, maken we het script uitvoerbaar met:
```
pi@raspberrypi:~ $ sudo chmod +x /usr/sbin/ds18b20_mqtt.sh
```
3. Om dit script op de achtergrond als server (service) uit te voeren, maken we het volgende systeembestand aan:
```
pi@raspberrypi:~ $ sudo nano /etc/systemd/system/ds18b20_mqtt.service
```
  Met de volgende inhoud:
```
[Unit]
Description=Send DS18B20 temp to MQTT Broker
[Service]
Type=simple
ExecStart=/usr/sbin/ds18b20_mqtt.sh
```
4. Om met deze service elke minuut een temperatuur door te sturen, maken we een timer aan met:
```
pi@raspberrypi:~ $ sudo nano /etc/systemd/system/ds18b20_mqtt.timer
```
  Met de volgende inhoud:
```
[Unit]
Description=Run ds18b20_mqtt every minute

[Timer]
OnCalendar=*-*-* *:*:00
Unit=ds18b20_mqtt.service

[Install]
WantedBy=timers.target
```
5. Nu we alle onderdelen hebben, kunnen we de timer automatisch laten starten bij het opstarten van de Raspberry Pi:
```
pi@raspberrypi:~ $ sudo systemctl enable ds18b20_mqtt.timer 
Created symlink /etc/systemd/system/timers.target.wants/ds18b20_mqtt.timer → /etc/systemd/system/ds18b20_mqtt.timer.
```
6. Je kunt de timer ook manueel starten met:
```
pi@raspberrypi:~ $ sudo systemctl start ds18b20_mqtt.timer
```
7. Je kunt het doorgeven van de DS18B20 temperatuurmeting aan MQTT testen met:
```
pi@raspberrypi:~ $ mosquitto_sub -h localhost -v -t ds18b20/temp
ds18b20/temp 25.3
```
  Indien alles werkt zoals het hoort, krijg je elke minuut een waarde op het scherm. Breek de opdracht af met de sneltoets Ctrl+c.
8. Nu kunnen we de DS18B20 temperatuursensor toevoegen aan Home Assistant. We gebruiken daarvoor de Home Assistant webpagina.
9. Activeer in Home Assistant het onderdeel Instellingen.
10. Open het onderdeel Apparaten & diensten.
11. Klik bij Geconfigureerd op het paneel MQTT.
12. Klik in het paneel Integratie-items op de koppeling CONFIGUREREN.
13. Vul in het paneel Luisteren naar 'onderwerp' bij Onderwerp om op te abonneren ons onderwerp (topic) in: ds18b20/temp.
14. Klik op de koppeling BEGIN MET LUISTEREN. Daaronder moet nu elke minuut een temperatuurmeting verschijnen.
15. Om de temperatuurmetingen in het Overzicht weer te geven en Home Assistant ermee aan de slag te laten gaan, moeten we opnieuw het configuratiebestand aanpassen. Dat kunnen we enkel door ons aan te melden als homeassistant gebruiker:
```
pi@raspberrypi:~ $ sudo -u homeassistant -H -s
homeassistant@raspberrypi:/home/pi $ cd
```
16. We passen de configuratie aan met nano:
```
homeassistant@raspberrypi:~ $ nano ~/.homeassistant/configuration.yaml
```
  En voegen de volgende regels onder de eerste MQTT sensor toe:
```
  sensor:
    - name: "Kamertemperatuur"
      state_topic: "ds18b20/temp"
      device_class: temperature
      unit_of_measurement: "°C"
```
17. Sla de aanpassing op, controleer de configuratie en herstart Home Assistant om de sensor in het Overzicht weer te geven.
18. Daar we klaar zijn met het configureren van Home Assistant, kunnen we terug afmelden:
```
homeassistant@raspberrypi:~ $ exit
exit
```
Tasmota WiFi schakelaar toevoegen aan Home Assistant.
1. Daarvoor gebruiken we terug MQTT. Externe apparaten (zoals draadloze schakelaars en sensoren) kunnen uit veiligheidsoverwegingen standaard geen contact maken met onze Mosquito MQTT server. We geven de toestemming door in het configuratiebestand met nano:
```
pi@raspberrypi:~ $ sudo nano /etc/mosquitto/mosquitto.conf
```
  De volgende regels achteraan toe te voegen:
```
listener 1883 0.0.0.0
allow_anonymous true
```
2. Na het opslaan en afsluiten van nano, herstarten we de Mosquito MQTT server:
```
pi@raspberrypi:~ $ sudo systemctl restart mosquitto.service
```
3. Je kunt naar alle MQTT berichten luisteren, met de volgende opdracht:
```
pi@raspberrypi:~ $ mosquitto_sub -h localhost -v -t "#"
tele/tasmota_15D8A8/LWT Online
cmnd/tasmota_15D8A8/POWER (null)
tele/tasmota_15D8A8/INFO1 {"Info1":{"Module":"Sonoff Basic","Version":"14.1.0(release-tasmota)","FallbackTopic":"cmnd/DVES_15D8A8_fb/","GroupTopic":"cmnd/tasmotas/"}}
tele/tasmota_15D8A8/INFO2 {"Info2":{"WebServerMode":"Admin","Hostname":"tasmota-15D8A8-6312","IPAddress":"192.168.129.40"}}
tele/tasmota_15D8A8/INFO3 {"Info3":{"RestartReason":"Software/System restart","BootCount":29}}
stat/tasmota_15D8A8/RESULT {"POWER":"OFF"}
stat/tasmota_15D8A8/POWER OFF
domoticz/in {"idx":3,"nvalue":0,"svalue":"","Battery":100,"RSSI":10}
mcp9808/temp 31.4
ds18b20/temp 24.0
tele/tasmota_15D8A8/STATE {"Time":"2024-08-17T15:56:04","Uptime":"0T00:00:10","UptimeSec":10,"Heap":26,"SleepMode":"Dynamic","Sleep":50,"LoadAvg":25,"MqttCount":1,"POWER":"OFF","Wifi":{"AP":1,"SSId":"Proximus-Home-388355","BSSId":"F0:4D:D4:0A:B6:D6","Channel":11,"Mode":"11n","RSSI":100,"Signal":-28,"LinkCount":1,"Downtime":"0T00:00:04"}}
```
4. En als je een Tasmota (of ander apparaat) aan de Mosquito MQTT server (broker) op de Raspberry Pi hebt gekoppeld, verschijnen alle berichten op het scherm.
5. Om een Tasmota schakelaar aan onze MQTT Broker te koppelen, surf je naar de webpagina van de Tasmota schakelaar
  1. Klik op de knop .
  2. Daarna op de knop .
  3. Plaats een vinkje bij de optie MQTT enable.
  4. Klik op de knop Save en laat de Tasmota schakelaar herstarten.
  5. Klik op de knop .
  6. Daarna op de knop .
  7. Bij Host() vul je het IP adres van onze Mosquito MQTT Broker in (onze Raspberry Pi).
  8. Aangezien we geen MQTT gebruiker en wachtwoord hebben ingesteld, mag je de velden User en Password wissen.
  9. Klik op de knop waardoor het Tasmota apparaat herstart om de aangepaste instellingen te activeren.
6. Het enige wat ons nu nog te doen staat is het toevoegen van de Tasmota schakelaar aan Home Assistant. Activeer daarvoor op de Home Assistant webpagina het onderdeel Instellingen.
7. Open het onderdeel Apparaten & diensten.
8. Klik op de knop .
9. Zoek naar tasmota.
10. Klik op het item Tasmota.
11. Klik in de lijst Ontdekt op het item Tasmota.
12. Klik in het dialoogvenster met de vraag Wil je Tasmota instellen? op de knop .
13. Klik in het dialoogvenster met Gelukt! op de knop .
14. In het onderdeel Overzicht vind je nu de Tasmota schakelaar en kan je hem bedienen.
Zoals alle software en systemen, moet je HomeAssistant regelmatig opwaarderen (updaten). Let op dit kan lang duren en heeft veel schijfruimte nodig (zeker niet uitvoeren op een SD-kaart van 8GB):
```
sudo -u homeassistant -H -s
source /srv/homeassistant/bin/activate
pip3 install --upgrade homeassistant
```
Home Assistant lijkt in het begin moeilijk, maar is zeer veelzijdig. Door zijn hoge populariteit vind je enorm veel instructie video's op het internet. Daarnaast bestaan er ook veel geschreven stap voor stap handleiding. En misschien de belangrijkste bron van informatie kan je vinden op de webpagina van Home Assistant zelf. Veel succes.
Domoticz
Tijd voor een andere domotica-controller. Home Assistant is een modern voorbeeld, zowel qua vormgeving als qua techniek. Domoticz is een conservatiever voorbeeld. Domoticz bestaat al veel langer dan Home Assistant en is dus volwassener. Op het eerste zicht lijkt Domotics eenvoudiger om mee te werken, maar hoe meer je wilt, hoe complexer het wordt. Dit is vooral te wijten aan de mengelmoes van gebruikte technieken.
1. Voor we van start gaan met Domoticz stoppen we Home Assistant met de opdracht:
```
pi@raspberrypi:~ $ sudo systemctl stop home-assistant@homeassistant.service
```
2. Home Assistant schakel je bij het opstarten van de Raspberry Pi uit met:
```
pi@raspberrypi:~ $ sudo systemctl disable home-assistant@homeassistant.service
Removed "/etc/systemd/system/multi-user.target.wants/home-assistant@homeassistant.service".
```
  Je kunt Home Assistant volledig van de SD kaart verwijderen met de opdracht:
```
pi@raspberrypi:~ $ sudo rm -r /home/homeassistant
```
3. Download en installeer de software:
```
pi@raspberrypi:~ $ sudo bash -c "$(curl -sSfL https://install.domoticz.com)"
```
4. Volg de richtlijnen van de installatie-assistent.
Domoticz bedien en configureer je met een webpagina.
1. Surf op de Raspberry Pi naar http://localhost:8080 of vanaf een ander apparaat naar http://raspberrypi.local:8080. Je moet je aanmelden met de standaard gebruikersnaam admin met het wachtwoord domoticz. Automatisch wordt je doorgestuurd naar het Dashboard van Domoticz. Dit is een startpagina die je zelf kunt samenstellen.
2. Bovenaan rechts op de webpagina staan menuknoppen met pictogrammen. Indien deze knoppen geen tekst bevatten, maak je het venster breder om de knopnamen zichtbaar te maken.
3. We beginnen met de instellingen die je kunt bereiken via het menu Setup met het pictogram met een moersleutel en schroevendraaier. Selecteer in het vervolgmenu Settings.
4. Verander de taal (Language) naar Nederlands (Dutch).
5. De locatie gegevens zijn nodig voor het berekenen van de zonsopgang en -ondergang. De breedtegraad (Latitude) en lengtegraad (Longitude) zijn de coördinaten van uw woonplaats de je via een dialoogvenster (koppeling Here) kunt bepalen. Bepaal de locatie van uw woonplaats en vul deze in. Om de instellingen toe te passen, klik je op de knop Apply Settings.
6. Om het wachtwoord aan te passen open je het vervolgmenu Instellingen en selecteer je Mijn profiel. Geef het oude (standaard) wachtwoord in en tweemaal het nieuwe wachtwoord. Dit moet je zeker doen als je van plan bent Domoticz te gebruiken. Als je Domoticz ook buiten jouw eigen lokale netwerk wilt bedienen, bijvoorbeeld via het internet op verplaatsing, heb je een MyDomoticz account nodig.
Laten we ook nu weer beginnen met de LED. Daarvoor maken we scripts om de Led via Domoticz in en uit te schakelen.
1. Om de Led in te schakelen, maak je het script ledon.sh aan in de Domotics map met scripts:
```
pi@raspberrypi:~ $ nano domoticz/scripts/ledon.sh
```
  Met de volgende inhoud:
  #!/bin/bash
  pinctrl set 12 op dh
  
  Na het opslaan van het script en het afsluiten van nano, maak je het script uitvoerbaar:
```
pi@raspberrypi:~ $ nano domoticz/scripts/ledon.sh
```
2. Herhaal deze werkwijze om de Led uit te schakelen door het script domoticz/scripts/ledoff.sh aan te maken met de inhoud:
  #!/bin/bash
  pinctrl set 12 op dl
  Vergeet niet het script uitvoerbaar te maken.
3. Daarna moeten we Domoticz vertellen welke domotica hardware we gebruiken. Daar we zelf scripts (stuurprogramma's) hebben aangemaakt, voegen we als volgt Dummy hardware toe aan Domoticz. Open het menu Instellingen en activeer je de pagina Hardware.
4. Geef de toe te voegen hardware een Naam (bijvoorbeeld: GPIO Raspberry Pi). Het Type hardware wordt in ons geval Dummy (Does nothing, use for virtual switches only). De Gegevens Timeout is voor onze toepassing van geen belang.
5. Voeg de pas ingestelde hardware toe door op de knop Toevoegen te klikken. Deze wordt dan in de hardwarelijst weergeven van waaruit je geselecteerde hardware kunt aanpassen en verwijderen.
6. Nu kan je de LED aangesloten op GPIO12 in Domoticz aansturen. Om onze LED toe te voegen, klik je in de regel met de Dummy hardware op de knop .
7. Geef de Viruele Sensor de Naam LED en het Sensor Type Schakelaar.
8. Klik op de knop om de LED schakelaar aan de pagina met lampen toe te voegen.
9. Activeer de pagina Schakelaars.
10. Om de scripts aan de LED schakelaar te koppelen, klik in het LED paneel op knop .
11. Geef de Aan actie optie de waarde script://ledon.sh.
12. Geef de Uit actie optie de waarde script://ledoff.sh.
13. Klik op de knop .
14. Domoticz meldt dat de LED Uit staat. Klik in het LED paneel op het picogram met de lamp om de LED aan en terug uit te zetten. Via de Log-knop kom je te weten wanneer de LED heeft gebrand. Met de knop Terug keer je terug naar de pagina met de lampen.
15. Met de knop Timers kan je bepalen wanneer de lamp in- en uitgeschakeld wordt (bijvoorbeeld voor tuinverlichting).
16. Met de knop Notificaties kan je meldingen instellen bij het in- of uitschakelen van de LED.
17. Door op het ster pictogram te klikken, voeg je de LED toe aan de Dashboard pagina waardoor je deze van daaruit kunt bedienen. Doen en testen.
Dan is het nu de beurt aan onze drukknop. Daar Domoticz de GPIO functies van de Raspberry Pi niet ondersteunt gaan we de status van de drukknop via MQTT berichten doorgeven. We beginnen met het koppelen van de Mosquito (zie Mosquito server installeren) MQTT server aan Domoticz:
1. Activeer bij Instellingen de pagina Hardware.
2. We voegen de Mosquito Broker toe met als
  
  Naam: Mosquito
  Type: MQTT Client Gateway with LAN interface
  Remote address:: 127.0.0.1
  Onderwerp IN voorvoegsel: domoticz/in
  Onderwerp UIT voorvoegsel: domoticz/out
  De rest van de instellingen mag je standaard laten staan. De Onderwerp IN en UIT voorvoegsels staan normaal ook al goed. Klik op de knop .
3. Daarna maken we om MQTT berichten te verwerken op dezelfde manier MQTT Hardware toe met als
  Naam: MQTT
  Type: Dummy (Does nothing, use for virtual switches only)
4. Nu kunnen we voor het drukknop MQTT bericht een virtuele sensor aanmaken. Klik bij de MQTT Dummy Hardware op de knop . Geef de virtuele sensor de Naam Drukknop en gebruik als Sensor Type Schakelaar.
5. Activeer bij Instellingen de pagina Apparaten.
6. Je kunt de werking testen door de volgende opdracht uit te voeren, zorg er wel voor dat idx waarde overeenkomt met de waarde in de Domoticz tabel (zie afbeelding):
```
pi@raspberrypi:~ $ mosquitto_pub -h localhost -t "domoticz/in" -m '{"command": "switchlight", "idx": 2, "switchcmd": "On" }'
```
  In de Data kolom van de MQTT Drukknop moet On verschijnen. Dit kan je ook waarnemen op de pagina met de Schakelaars. De opdracht met het MQTT bericht om de drukknop uit te schakelen is:
```
pi@raspberrypi:~ $ mosquitto_pub -h localhost -t "domoticz/in" -m '{"command": "switchlight", "idx": 2, "switchcmd": "Off" }'
```
7. De volgende stap bestaat uit het aanmaken van een script om constant GPIO 8 in de gaten te houden en veranderingen via een MQTT bericht aan Domoticz te melden. Maak het script aan:
```
pi@raspberrypi:~ $ nano drukknop.sh
```
  Met de volgende inhoud:
  #!/bin/bash
  # GPIO input naar MQTT bericht voor Domoticz
  # Pas indien nodig de volgende parameters aan
  GPIO=8
  Idx=2
  # Initialiseer GPIO 8 als input met standaard hoog (pull up)
  pinctrl set $GPIO ip pu
  # Oneindig lang worden veranderingen gemeld
  # Breek het programma af met Ctrl+c
  while :
  do
  # Wacht op het indrukken van de drukknop
  while :
  do
     pir=$(pinctrl get $GPIO)
     if [[ $pir == *"lo"* ]]; then
       break
     fi
     sleep 1
  done
  echo "Drukknop is ingedrukt."
  mosquitto_pub -h localhost -t "domoticz/in" -m '{"command": "switchlight", "idx": '$Idx', "switchcmd": "On" }'
  
  # Wacht tot de drukknop niet meer wordt ingedrukt
  while :
  do
     pir=$(pinctrl get $GPIO)
     if [[ $pir == *"hi"* ]]; then
       break
     fi
     sleep 1
  done
  echo "Drukknop is niet ingedrukt."
  mosquitto_pub -h localhost -t "domoticz/in" -m '{"command": "switchlight", "idx": '$Idx', "switchcmd": "Off" }'
  done
8. Maak het script uitvoerbaar:
```
pi@raspberrypi:~ $ chmod +x drukknop.sh
```
9. Test het script:
```
pi@raspberrypi:~ $ ./drukknop.sh 
Drukknop is ingedrukt.
Drukknop is niet ingedrukt.
^C
```
  Controleer daarbij of Domoticz reageert op het indrukken van de drukknop. Breek de opdracht af door de sneltoets Ctrl+c te drukken.
10. Nu we zeker zijn dat het script werkt, gaan we het automatisch laten starten. Verplaats daarvoor het script naar een veilige systeemmap:
```
pi@raspberrypi:~ $ sudo mv drukknop.sh /usr/sbin/drukknop.sh
```
11. Maak een startscript aan:
```
pi@raspberrypi:~ $ sudo nano /etc/systemd/system/drukknop.service
```
  Met de volgende inhoud:
  [Unit]
  Description=Drukknop Domoticz MQTT
  After=network-online.target
  
  [Service]
  # Activeer de volgende regel om de start van deze dienst 30 seconden uit te stellen
  #ExecStartPre=/usr/bin/sleep 30
  Type=simple
  ExecStart=/usr/sbin/drukknop.sh
  Restart=always
  
  [Install]
  WantedBy=multi-user.target
12. We brengen het systeem op de hoogte van de aanpassing:
```
pi@raspberrypi:~ $ sudo systemctl --system daemon-reload
```
13. En voeren een test uit:
```
pi@raspberrypi:~ $ sudo systemctl start drukknop.service
```
14. Indien Domoticz reageert op het indrukken van de drukknop, kunnen we het script opnemen in de startprocudre van het systeem:
```
pi@raspberrypi:~ $ sudo systemctl enable drukknop.service
Created symlink /etc/systemd/system/multi-user.target.wants/drukknop.service → /etc/systemd/system/drukknop.service.
```
15. Met de volgende opdracht kunnen we meldingen van het script opvragen:
  pi@raspberrypi:~ $ sudo systemctl status drukknop.service
  ● drukknop.service - Drukknop Domoticz MQTT
      Loaded: loaded (/etc/systemd/system/drukknop.service; disabled; preset: enabled)
      Active: active (running) since Tue 2024-08-27 18:37:18 CEST; 38s ago
    Main PID: 3163 (drukknop.sh)
       Tasks: 2 (limit: 4444)
         CPU: 108ms
      CGroup: /system.slice/drukknop.service
              ├─3163 /bin/bash /usr/sbin/drukknop.sh
              └─3252 sleep 1
  
  aug 27 18:37:18 raspberrypi systemd[1]: Started drukknop.service - Drukknop Domoticz MQTT.
  aug 27 18:37:29 raspberrypi drukknop.sh[3163]: Drukknop is ingedrukt.
  aug 27 18:37:30 raspberrypi drukknop.sh[3163]: Drukknop is niet ingedrukt.
16. Je kunt het script stoppen met:
```
pi@raspberrypi:~ $ sudo systemctl stop drukknop.service
```
17. Zorg dat het drukknop MQTT script draait (werkt).
18. Je kunt op de pagina Schakelaars de Drukknop een ander pictogram geven via de knop . Pas de optie Schakelaar type bijvoorbeeld aan naar Contact. En bevestig de aanpassing met de knop .
Nu willen we natuurlijk dat als we de drukknop indrukken, de LED oplicht.
1. Eerst moeten we de verschillende toestanden (states) van de drukknop nagaan. Dit kan via het menu Instellingen op de pagina Apparaten. De toestand kan je vinden in de kolom Data van de Drukknop. Bij mij krijgt de Drukknop de toestand Open bij het indrukken van de drukknop. Wanneer de drukknop niet wordt ingedrukt, heeft die bij mij de toestand Closed.
2. Daarna selecteer je in het menu Instellingen in het submenu Meer opties de pagina Gebeurtenissen. Op deze pagina kan je scripts schrijven die een actie uitvoeren bij het voorkomen van een gebeurtenis (event).
3. Maak een nieuwe gebeurtenis ( tabbladknop) van het type (scripttaal) Blockly.
4. Activeer de optie met de Aan knop.
5. Geef de gebeurtenis een naam: LED aan.
6. Bij Trigger (webpagina desnoods breder maken om alle onderdelen zichtbaar te maken) selecteer je de soort gebeurtenis waarop gereageerd moet worden, in ons geval een gebeurtenis afkomstig van het domotica apparaat (Device) Drukknop.
7. De grafische programmeeromgeving is bedoeld om het zo eenvoudig mogelijk te houden, maar dit maakt het allemaal nogal omslachtig. Sleep vanuit de groep Control de Als-Dan (bovenste If Do) structuur naar het middelste paneel.
8. Vanuit de groep Logic sleep je het onderdeel om twee onderdelen te vergelijken (bovenste pictogram) tot het past in het If gedeelte (je hoort een klik als het past).
9. We moeten de toestand van de drukknop nagaan. Sleep uit de groep Devices > Switches het A-F pictogram naar het eerste gaatje van de vergelijking. Zorg dat Drukknop achter A-F staat (vervolgkeuzelijst).
10. Sleep uit de groep Logic het derde pictogram met de toestand On naar het tweede gaatje van de vergelijking. Verander met de vervolgkeuzelijst de toestand On naar Open. De toestand waarin de drukknop zich bevindt, kan je weergeven door terwijl je op de drukknop drukt op de knop Show current states te klikken.
11. Voor het Do gedeelte van de If Do structuur ga je op dezelfde manier te werk. Het volledige script wordt:
12. In mensentaal: als de drukknop ingedrukt wordt, moet de LED ingeschakeld worden. Klik op de knop Opslaan om het script op te slaan.
13. Druk op de drukknop om het script te testen, de LED moet oplichten.
14. Herhaal deze werkwijze om de LED uit te schakelen als je niet op de drukknop drukt.
15. Test uw aanpassingen.
Nu willen we de LED na 10 minuten automatisch uitschakelen (traphal situatie).
1. Pas het script LED Aan als volgt aan:
2. Dit aanpaste script zorgt dat de LED 10 minuten oplicht en dan automatisch terug wordt uitgeschakeld. Bij het testen (handiger met 1 minuut vertraging) merk je al vlug dat dit niet werkt. De LED wordt direct bij het loslaten van de drukknop uitgeschakeld. Dit komt door het script dat je schreef voor het uitschakelen van de LED. Met andere woorden, deactiveer dit script met de knop en het script LED Aan werkt perfect.
De Tasmota schakelaar, 1-Wire en I²C temperatuursensor gaan we via MQTT aan Domoticz toevoegen:
1. We beginnen met de voorbereidingen in Domoticz:
  1. Activeer bij Instellingen de pagina Hardware.
  2. We beginnen met een Tasmota schakelaar door bij de MTTQ Dummy Hardware te klikken op de knop . Geef de virtuele sensor de Naam Tasmota en gebruik als Sensor Type Schakelaar.
  3. Maak een tweede virtuele sensor voor de I²C temperatuursensor met de Naam I2C Temperatuur en als Type Temperatuur.
  4. De laatste viruele sensor die je aanmaakt is voor de 1-Wire temperatuursensor en geef je de Naam 1-Wire Temperatuur en het Type Temperatuur.
  5. Controleer de aangemaakte virtuele sensoren bij Instellingen op de pagina Apparaten.
    
    Let op: De kolom Data zal pas van waarden voorzien worden na het koppelen van de sensoren en de Tasmota schakelaar aan onze Mosquito MQTT Broker.
2. Tijd om de sensoren, de Tasmota schakelaar en Domoticz via onze MQTT Broker te koppelen:
  1. Klik op de webpagina van de Tasmota schakelaar op de knop .
  2. Indien de knop niet aanwezig is, voer je de volgende bewerkingen uit:
  3. Klik op knop . Daarna op de knop . Bij Host() vul je het IP adres van onze Mosquito MQTT Broker in (onze Raspberry Pi). Aangezien we geen MQTT gebruiker en wachtwoord hebben ingesteld, mag je de velden User en Password wissen. Klik op de knop waardoor het Tasmota apparaat herstart om de aangepaste instellingen te activeren.
  4. Ga opnieuw naar en klik op . Voor een Tasmota schakelaar vul je bovenaan bij Idx 1 het Idx getal in dat je kunt terugvinden op de Apparaten pagina bij de Tasmota virtuele sensor in de derde kolom (3 in mijn voorbeeld, zie afbeelding). Klik op de knop .
3. Om de I²C en 1-Wire temperatuursensor via MQTT aan Domoticz te koppelen, breiden we het script die we voor Home Assistant gebruikten uit.
  1. We breiden de MQTT scripts voor Home Assistant (zie Gegevens ophalen en doorsturen naar de MQTT server) uit voor Domoticz:
```
pi@raspberrypi:~ $ sudo nano /usr/sbin/mcp9808_mqtt.sh
```
    En passen het script aan tot:
    #!/bin/bash
    # mcp9808_mqtt.sh - send mcp9808 data to MQTT broker
    #
    
    # De temperatuur ophalen
    temp=$(cat /sys/bus/i2c/devices/1-0018/hwmon/hwmon3/temp1_input)
    # Omrekenen naar van m°C naar °C met 1 cijfer na de komma
    temp=$(echo "scale=1; $temp / 1000" | bc)
    # Temperatuur doorsturen naar MQTT Broker
    mosquitto_pub -h localhost -t mcp9808/temp -m "$temp"
    mosquitto_pub -h localhost -t domoticz/in -m '{"idx":4,"nvalue":0,"svalue":"'$temp'"}'
    En voor de 1-Wire temperatuur sensor:
```
pi@raspberrypi:~ $ sudo nano /usr/sbin/ds18b20_mqtt.sh
```
    Passen we het script aan tot:
    #!/bin/bash
    # ds18b20_mqtt.sh - send DS18B20 data to MQTT broker
    #
    
    # De temperatuur ophalen
    pinctrl set 4 ip pu
    temp=$(cat /sys/bus/w1/devices/28-*/w1_slave | tail -1 | awk -F 't=' '{ print$2 }')
    # Omrekenen naar van m°C naar °C met 1 cijfer na de komma
    temp=$(echo "scale=1; $temp / 1000" | bc)
    # Temperatuur doorsturen naar MQTT Broker
    mosquitto_pub -h localhost -t ds18b20/temp -m "$temp"
    mosquitto_pub -h localhost -t domoticz/in -m '{"idx":5,"nvalue":0,"svalue":"'$temp'"}'
    Bij de mosquitto_pub met het onderwerp (topic) domoticz/in moet de "idx":5 waarde overeenkomen met de Idx bij Apparaten in Domoticz. Meer info kan je vinden bij Domoticz MQTT webpagina.
  2. Na het opslaan zien we de temperaturen na een tijdje in Domoticz verschijnen.
Na het plaatsen van alle onderdelen op het Dashboard (activeren van de sterren), krijg je het volgende Dashboard:
Afsluitende video over Domoticz: