Domotica
Start dit hoofdstuk met een nieuwe reservekopie van de Basisimage.
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. openHAB en Domoticz behandelen we in de praktijkopdracht. Hoewel Home Assistant de populairste Domotica-controller voor de Raspberry Pi is, behandel ik deze niet meer in de cursus. Dit zijn mijn redenen:
- Het wordt steeds moeilijker om Home Assistant in het Raspberry Pi OS besturingssysteem te installeren. Zo wordt Home Assistant Core niet verder ontwikkeld. Enkel via een Docker container kan je Home Assistant nog in Raspberry PI OS installeren. Dit zorgt voor een extra belasting, schijfruimte, complexiteit, enz.
- Wel kan je Home Assistant (wordt aangeraden) met een eigen image (Home Assistant OS) op een Raspberry Pi installeren. In Home Assistant OS kan je echter geen extra software toevoegen om naast Home Assistant nog extra diensten aan te bieden. Denk aan NAS, media server, WiFi Access Point, enz. Je kunt er ook geen GPIO hardware op aansluiten. M.a.w. je gebruikt je Raspberry Pi exclusief voor Home Assistant, jammer toch.
- Home Assistant werd opgesplitst in twee onderdelen: een open source onderdeel (Home Assistant) die de software ontwikkelt en een commercieel onderdeel (Nabu Casa) dat hardware, cloudabonnementen en stemherkenning verkoopt. Een deel van de ontwikkelaars aan Home Assistant wordt betaald door Nabu Casa en dat merk je.
Toch moet je bij je keuze zeker ook eens naar Home Assistant kijken.
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. OpenHAB biedt daarvoor een gratis service aan: myopenHAB.
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 7 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.- Schakel voor je begint de Raspberry Pi uit.
- Sluit de Pi Camera aan op de Raspberry Pi.
- 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.
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 I2C elektronica.
De hier gebruikte onderdelen worden enkel als voorbeeld gebruikt, andere 1-Wire en I2C elektronica kan je op een gelijkaardige manier gebruiken.
Raadpleeg echter steeds de handleidingen en/of datasheets.
- 1-Wire temperatuursensor DS18B20.
- I2C temperatuursensor MCP9808
- 1-Wire temperatuursensor DS18B20.
- 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:~ $
Je merkt dat GPIO12 niet geconfigureerd is (pinctrl0: 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_SDAnone). De LED zal licht geven, als je de GPIO12 als uitgang hoog (binair 1) maakt. Je maakt van GPIO12 een uitgang (op- OutPut) met binaire waarde 1 (dh- Drive High):pi@raspberrypi:~ $
Controleer dit.pinctrl set 12 op dh - De LED doof je door de GPIO 12 uitgang laag (
dl- Drive Low) 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:~ $
Daarna kunnen we de status van de drukknop opvragen:pinctrl set 8 ip pupi@raspberrypi:~ $
Druk nu op de drukknop terwijl je de volgende opdracht uitvoert:pinctrl get 88: ip pu | hi // GPIO8 = inputpi@raspberrypi:~ $
Als de drukknop niet ingedrukt is, wordtpinctrl get 88: ip pu | lo // GPIO8 = inputhiweergegeven, met een ingedrukte knop wordtloweergegeven. - 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.
Maak deze aan met de opdracht
pi@raspberrypi:~ $
Met de inhoud:nano 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
doneSla de programmacode op met de sneltoets Ctrl+x, daarna j, gevolgd door Return.
Voor je dit script kunt uitvoeren, moet je het uitvoerbaar maken met de opdracht:pi@raspberrypi:~ $
Voer dit script uit metchmod +x lichtschakelaar.shpi@raspberrypi:~ $
Als dit script uitgevoerd wordt, wat moet je dan doen om de LED te laten oplichten? .....bash lichtschakelaar.shOm het script te beëindigen druk je Ctrl+c.
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:~ $
Python liefhebbers kunnen ook gebruik maken van Python stuurprogramma's, deze worden meestal geleverd door de leverancier. Bijvoorbeeld Adafruit voor DS18B20 en MCP9808.nano /boot/overlays/README- 1-Wire (DS18B20)
- Eerst activeren we 1-Wire door in de bootconfiguratie /boot/firmware/config.txt:
pi@raspberrypi:~ $
De volgende regel op het einde toe te voegen:sudo nano /boot/firmware/config.txt
Deze regel werkt echter niet op een Raspberry Pi 5, daar gebruik je:dtoverlay=w1-gpiodtoverlay=w1-gpio-pi5 - Daarna kunnen we de drivers activeren om onze temperatuursensor uit te lezen door in de stuurprogrammaconfiguratie /etc/modules:
pi@raspberrypi:~ $
De volgende twee regels met stuurprogramma's toe te voegen:sudo nano /etc/modulesw1-gpio w1-therm - Herstart de Raspberry Pi om de aanpassingen te activeren.
- 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 pupi@raspberrypi:~ $pinctrl get 44: ip pu | hi // GPIO4 = input - De temperatuur kan je nu uitlezen via het bestand /sys/bus/w1/devices/28-*/w1_slave met de opdracht:
pi@raspberrypi:~ $
Het sterretje (*) in de mapnaam zorgt dat je alle mappen die beginnen metcat /sys/bus/w1/devices/28-*/temperature2506228-bekijkt. Elke sensor heeft namelijk zijn eigen map (vb: /sys/bus/w1/devices/28-030297943884/temperature). Dit laat toe meerdere 1-Wire sensoren op dezelfde GPIO pin aan te sluiten.
De temperatuur wordt in de uitvoer weergegeven (25062) wat overeenkomt met 25,062 °C (dus steeds met drie cijfers na de komma, die je zelf moet plaatsen). Of m.a.w. in m°C (milligraden Celsius).
- Eerst activeren we 1-Wire door in de bootconfiguratie /boot/firmware/config.txt:
- I2C (MCP9808)
- Eerst activeren we I2C en de driver door in de bootconfiguratie /boot/firmware/config.txt:
pi@raspberrypi:~ $
Voeg na deze regelsudo nano /boot/firmware/config.txt#dtparam=i2c_arm=onDe volgende twee regels toe:
De eerste regel activeert de I2C bus en de tweede regel het stuurprogramma voor de MCP9808.dtparam=i2c_arm=on dtoverlay=i2c-sensor,jc42 - Herstart de Raspberry Pi om de aanpassingen te activeren.
- 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:~ $
De temperatuur wordt opnieuw weergegeven (cat /sys/bus/i2c/devices/1-0018/hwmon/hwmon3/temp1_input3268732687) in m°C, wat overeenkomt met 32,687 °C. De afwijking 32,687 (MCP9808 meting) ten opzichte van 25,062 °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.
- Eerst activeren we I2C en de driver door in de bootconfiguratie /boot/firmware/config.txt:
- 1-Wire (DS18B20)
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).
- 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.
- Surf met een browser met het HTTP protocol naar het gevonden IP adres (vb: http://192.168.129.74/). Op de weergeven webpagina kan je het Tasmota apparaat dan bedienen.
- 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:~ $
De schakelaar inschakelen met:wget -qO- http://192.168.129.74/cm?cmnd=Power{"POWER":"OFF"}pi@raspberrypi:~ $
De schakelaar uitschakelen met:wget -qO- http://192.168.129.74/cm?cmnd=Power%20On{"POWER":"ON"}pi@raspberrypi:~ $
De schakelaar omschakelen met:wget -qO- http://192.168.129.74/cm?cmnd=Power%20Off{"POWER":"OFF"}pi@raspberrypi:~ $
Zelfs het bijwerken van de Tasmota firmware zelf is mogelijk. Alle opdrachten kan je vinden op de webpagina Commands.wget -qO- http://192.168.129.74/cm?cmnd=Power%20Toggle{"POWER":"ON"}
MQTT
Om de gegevens van sensoren naar een domotica-controller te sturen, gaan we gebruik maken van MQTT. Daar MQTT een standaard is, ondersteunen zeer veel domotica (ook draadloze) sensoren, schakelaars, enz. MQTT. Al deze MQTT compatibele apparaten hebben een MQTT server (Broker) nodig om hun gegevens naar toe te sturen.MQTT server installeren
Installeer de Mosquito MQTT server met de volgende opdracht:pi@raspberrypi:~ $
sudo apt install -y mosquitto mosquitto-clientsPakketlijsten 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 2 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 (6.004 kB/s) Voorheen niet geselecteerd pakket libdlt2:arm64 wordt geselecteerd. (Database wordt ingelezen ... 151626 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+deb12u12) ...- Met de volgende opdracht zorgen we dat de MQTT server automatisch start:
pi@raspberrypi:~ $
sudo systemctl enable mosquitto.serviceSynchronizing 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 scripts sturen we de gegevens van onze sensors door naar de MQTT server. Deze scripts plaatsen we in een map, die we aanmaken met:pi@raspberrypi:~ $
mkdir binMQTT Drukknop
- Maak met de teksteditor nano het script voor de drukknop aan:
pi@raspberrypi:~ $
Met de volgende inhoud:nano bin/mqtt_drukknop.sh#!/bin/bash
# Stuur gpio 8 data (drukknop) naar de MQTT broker
# Bij het opstarten is de drukknop niet actief
power="OFF"
# Drukknop aangelsoten op GPIO8
gpio=8
# Initialiseer de drukknop GPIO als input met standaard hoog (pull up)
pinctrl set $gpio ip pu
# Oneindig lang gaan we de stand van de drukknop opvragen
# Breek het programma af met Ctrl+c
while :
do
# Wacht tot de drukknop wordt ingedrukt
while :
do
pinctrl get $gpio | grep -q " lo "
if [ $? -eq 0 ]; then
# Omschakelen
if [ $power == "OFF" ]; then
power="ON"
else
power="OFF"
fi
# Drukknop werd ingedrukt, verandering doorsturen naar MQTT Broker
mosquitto_pub -h localhost -t stat/drukknop/POWER -m $power
break;
fi
sleep 1
done
# Wacht tot de drukknop terug wordt losgelaten
while :
do
pinctrl get $gpio | grep -q " hi "
if [ $? -eq 0 ]; then
break;
fi
sleep 1
done
done - Na het opslaan en afsluiten van nano, maken we het script uitvoerbaar met:
pi@raspberrypi:~ $
chmod +x bin/mqtt_drukknop.sh - Om MQTT scripts te testen, heb je een tweede terminal nodig.
Start een tweede terminal en voer de opdracht uit om alle ontvangen MQTT berichten weer te geven:
pi@raspberrypi:~ $
mosquitto_sub -h localhost -v -t "#" - In de eerste terminal start je het pas aangemaakte script:
pi@raspberrypi:~ $
bin/mqtt_drukknop.sh - Druk op de drukknop en in de tweede terminal verschijnt:
stat/drukknop/POWER ON
Let wel dat je de drukknop soms een tijdje moet indrukken, vanwege de sleep opdrachten. Deze sleep opdrachten zorgen ervoor dat de Raspberry Pi niet wordt overbelast bij het aftasten van de drukknop status. - Laat de drukknop los en druk nogmaals op de drukknop.
In de tweede terminal verschijnt:
stat/drukknop/POWER OFF
Hoewel we een drukcontact schakelaar (moment schakelaar) gebruiken, zorgt het script ervoor dat deze als een omschakelaar werkt. - Om het drukknop script in de eerste terminal te stoppen, activeer je de eerste terminal en druk je op Ctrl+c. Stop ook het script in de tweede terminal.
- Maak met de teksteditor nano het script voor de drukknop aan:
MQTT LED
Voor de LED hebben we een MQTT ontvanger nodig die reageert op berichten van de domotica-controller. De LED moet namelijk oplichten/doven via deze domotica berichten.- Maak met de teksteditor nano het script voor de LED aan:
pi@raspberrypi:~ $
Met de volgende inhoud:nano bin/mqtt_led.sh#!/bin/bash
# LED aangesloten op GPIO12
gpio=12
# Alleen luisteren naar berichten met het topic
topic_name="stat/led/POWER/#"
# Blijf constant luisteren
while read message
do
# De volgende twee regels activeren om te testen
timestamp=$(date)
echo "$timestamp: $message"
# Reageer op geldige berichten
if [ $message == "ON" ]; then
# LED laten oplichten
pinctrl set $gpio op dh
fi
if [ $message == "OFF" ]; then
# LED doven
pinctrl set $gpio op dl
fi
# naar de MQTT berichten
done < <(mosquitto_sub -t $topic_name) - Na het opslaan en afsluiten van nano, maken we het script uitvoerbaar met:
pi@raspberrypi:~ $
chmod +x bin/mqtt_led.sh - Om dit script te testen hebben we opnieuw twee terminals nodig.
In de eerste terminal starten we het te testen script:
pi@raspberrypi:~ $
bin/mqtt_led.sh - In de tweede terminal sturen we MQTT berichten waarop het te testen script moet reageren.
De LED laat je oplichten met de MQTT bericht opdracht:
pi@raspberrypi:~ $
In de eerste terminal verschijnt een bericht:mosquitto_pub -h localhost -t stat/led/POWER -m ONdi 22 jul 2025 18:10:56 CEST: ON
En de LED licht op. - De LED kan je doven met de MQTT bericht opdracht:
pi@raspberrypi:~ $
In de eerste terminal verschijnt het bericht:mosquitto_pub -h localhost -t stat/led/POWER -m OFFdi 22 jul 2025 18:11:04 CEST: OFF
- Om het LED script in de eerste terminal te stoppen, activeer je de eerste terminal en druk je op Ctrl+c.
- Als het script naar behoren werkt, moeten de berichten in de terminal niet langer worden weergegeven.
Deze dienen enkel om te zien script of het script goed werkt.
Schakel de twee volgende regels uit door er commentaar regels van te maken:
timestamp=$(date)
M.a.w. zet er een # voor:
echo "$timestamp: $message"# timestamp=$(date)
# echo "$timestamp: $message" - Om zeker te zijn, test je het script nogmaals. Nu mag alleen de LED zichtbaar reageren op de MQTT berichten.
- Maak met de teksteditor nano het script voor de LED aan:
MQTT mcp9808
Maak op een gelijkaardige manier het script om de temperatuur van de mcp9808 sensor uit te lezen en naar de MQTT broker te sturen.- Het script noemen we mqtt_mcp9808.sh en maken we aan met nano:
pi@raspberrypi:~ $
nano bin/mqtt_mcp9808.shMet de volgende inhoud:
#!/bin/bash
# Stuur mcp9808 data naar de MQTT broker
#
while :
do
# 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"
sleep 6
done - Na het opslaan en afsluiten van nano, maken we het script uitvoerbaar met:
pi@raspberrypi:~ $
chmod +x bin/mqtt_mcp9808.sh - Dit is terug een sensor.
Met andere woorden test het nieuwe script zoals je dit deed bij de drukknop.
Om de zes seconden, ontvangt de MQTT server een temperatuur bericht:
mcp9808/temp 32.5
- Als dit werkt, kunnen we het doorsturen van de temperatuur tussen twee metingen verlengen tot 1 minuut of 60 seconden.
M.a.w. pas de volgende regel
sleep 6
aan naarsleep 60
Om zeker te zijn dat de aanpassing werkt, test je het script opnieuw.
- Het script noemen we mqtt_mcp9808.sh en maken we aan met nano:
MQTT DS18B20
-
Maak op een gelijkaardige manier het script om de temperatuur van de ds18b20 sensor uit te lezen en naar de MQTT broker te sturen.
pi@raspberrypi:~ $
Met de volgende inhoud:nano bin/mqtt_ds18b20.sh#!/bin/bash
# Stuur ds18b20 data naar de MQTT broker
#
# Initialiseer GPIO4
pinctrl set 4 ip pu
sleep 5
while :
do
# De temperatuur ophalen
temp=$(cat /sys/bus/w1/devices/28-*/temperature)
# 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"
sleep 60
done - Maak het script uitvoerbaar en test het.
ds18b20/temp 25.1
-
Maak op een gelijkaardige manier het script om de temperatuur van de ds18b20 sensor uit te lezen en naar de MQTT broker te sturen.
MQTT Tasmota
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:~ $
De volgende regels achteraan toe te voegen:sudo nano /etc/mosquitto/mosquitto.conflistener 1883 0.0.0.0 allow_anonymous true - Na het opslaan en afsluiten van nano, herstarten we de Mosquito MQTT server:
pi@raspberrypi:~ $
sudo systemctl restart mosquitto.service - Je kunt naar alle MQTT berichten luisteren, met de volgende opdracht:
pi@raspberrypi:~ $
mosquitto_sub -h localhost -v -t "#"tele/tasmota_15D8A8/LWT Online tasmota/discovery/F4CFA215D8A8/config {"ip":"192.168.129.74","dn":"Tasmota","fn":["Tasmota",null,null,null,null,null,null,null],"hn":"tasmota-15D8A8-6312","mac":"F4CFA215D8A8","md":"Sonoff Basic","ty":0,"if":0,"cam":0,"ofln":"Offline","onln":"Online","state":["OFF","ON","TOGGLE","HOLD"],"sw":"15.0.1","t":"tasmota_15D8A8","ft":"%prefix%/%topic%/","tp":["cmnd","stat","tele"],"rl":[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"swc":[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],"swn":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"btn":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"so":{"4":0,"11":0,"13":0,"17":0,"20":0,"30":0,"68":0,"73":0,"82":0,"114":0,"117":0},"lk":0,"lt_st":0,"bat":0,"dslp":0,"sho":[],"sht":[],"ver":1} tasmota/discovery/F4CFA215D8A8/sensors {"sn":{"Time":"2025-07-25T16:59:10"},"ver":1} - 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.
- Om een Tasmota schakelaar aan onze MQTT Broker te koppelen, surf je naar de webpagina van de Tasmota schakelaar
- Klik op de knop .
- Daarna op de knop .
- Plaats een vinkje bij de optie MQTT enable.
- Klik op de knop Save en laat de Tasmota schakelaar herstarten.
- Klik op de 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.
Opgelet: bij het (her)starten van een Tasmota apparaat kan het zeer lang duren (tot 24 uur) voor deze terug aan de WiFi van je router wordt gekoppeld. Blijkbaar reageren vooral moderne routers (Vb: Proximus-Box 4 - glasvezel) slecht op de aanvraag van stroombesparende IOT apparaten. Uiteindelijk krijgen ze wel een verbinding.
De LED op het Tasmota apparaat blijft knipperen (foutmelding) zolang de WiFi verbinding niet is hersteld, maar ook tot de MQTT server correct reageert.
M.a.w. controleer via een webbrowser de WiFi verbinding naar het Tasmota apparaat, zorg dat de MQTT server gestart is en correct werkt. Indien aan deze twee voorwaarden voldaan is en de LED blijft knipperen, controleer dan de MQTT instellingen van het Tasmota apparaat en de MQTT Broker. Herstart voor de zekerheid ook de Raspberry Pi.
- We geven de toestemming door in het configuratiebestand met nano:
MQTT MP3 speler
Het geluidssysteem van de Raspberry Pi werkt enkel voor de gewone gebruiker (standaard en dus meestal pi). Waardoor de meeste domotica software met een eigen gebruiker geen audio kunnen afspelen. Software die werkt met verschillende gebruikers is namelijk veel veiliger. We moeten dus alle geluidsopdrachten laten uitvoeren door de gewone gebruiker.- Zorg dat er geluid kan afgespeeld worden via de Raspberry Pi: zie het hoofdstuk Musicbox.
- Moderne besturingssystemen starten het geluidssysteem en bijhorende hardware pas op als er geluid is.
Dit is efficiënt naar energiegebruik en systeembelasting, maar zorgt wel voor het wegvallen van het eerste stukje geluid.
M.a.w. zorg voor een wat langer geluidsfragment, liefst beginnend met een aanzwellend geluidsvolume.
Een MP3 bestand met een alarmsignaal downloaden en naar de map $HOME/Music verplaatsen kan je met bijvoorbeeld de volgende opdracht:
pi@raspberrypi:~ $
wget --output-document=$HOME/Music/burglar.mp3 https://partofthething.com/thoughts/wp-content/uploads/2016/08/burglar.mp3--2025-08-09 15:52:52-- 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: ‘/home/pi/Music/burglar.mp3’ /home/pi/Music/burglar.mp3 100%[==============================================>] 2,37M 1,93MB/s in 1,2s 2025-08-09 15:52:54 (1,93 MB/s) - '‘/home/pi/Music/burglar.mp3’' opgeslagen [2489578/2489578] - Maak het volgende script om een MP3 bestand af te spelen:
pi@raspberrypi:~ $
nano bin/mqtt_mp3.shMet de volgende inhoud:
#!/bin/bash
# MP3 bestand afspelen
# Alleen luisteren naar berichten met het topic
topic_name="sound/play/MP3/#"
# Blijf constant luisteren
while read message
do
# De volgende twee regels activeren om te testen
timestamp=$(date)
echo "$timestamp: $message"
# Reageer op geldige berichten
if test -f $message; then
# Speel het bestand af
paplay $message
fi
# naar de MQTT berichten
done < <(mosquitto_sub -t $topic_name) - Maak het uitvoerbaar:
pi@raspberrypi:~ $
chmod +x bin/mqtt_mp3.sh
MQTT autostart
Het enige wat ons nu nog te doen staat is het automatisch starten van de MQTT scripts bij het opstarten van de Raspberry Pi.- Om het te laten uitvoeren door de gebruiker pi, maak je de volgende autostart map aan:
pi@raspberrypi:~ $
mkdir -p ~/.config/systemd/user/ - Om de MQTT scripts op de achtergrond als server (service) uit te voeren, maken we het volgende systeembestand aan:
pi@raspberrypi:~ $
nano ~/.config/systemd/user/mqtt_autostart_@.serviceMet de volgende inhoud:
[Unit]
Description=Running Bash MQTT Scripts for %I
After=mosquitto.service
StartLimitIntervalSec=60
StartLimitBurst=5
[Service]
Type=simple
ExecStart=/home/pi/bin/mqtt_%i.sh
Restart=on-failure
[Install]
WantedBy=default.target - Elk MQTT script kunnen we nu starten met een systemd start opdracht.
De volgende systemd opdracht start ons MQTT drukknop script:
pi@raspberrypi:~ $
systemctl --user start mqtt_autostart_@drukknop.serviceOm het drukknop MQTT script met de bestandsnaam mqtt_drukknop.sh te starten, heeft de systemd service enkel het gedeelte drukknop uit de bestandsnaam nodig. De rest is voor de systemd service reeds bekend: pad (map): /home/pi/bin/ (pas pi aan als je niet de standaard gebruiker hebt ingesteld), bestandsnaam begint met mqtt_ en eindigt op .sh (zie regel ExecStart=/usr/sbin/mqtt_%i.sh). M.a.w. drukknop is het enige wat ontbreekt en geven we mee na het @-teken.
Controleer met de volgende opdracht of het MQTT script goed gestart is.
pi@raspberrypi:~ $
systemctl --user status mqtt_autostart_@drukknop.service
● mqtt_autostart_@drukknop.service - Running Bash MQTT Scripts for drukknop
Loaded: loaded (/home/pi/.config/systemd/user/mqtt_autostart_@.service; disabled; preset: enabled)
Active: active (running) since Sat 2025-08-09 16:26:15 CEST; 2min 15s ago
Main PID: 13433 (mqtt_drukknop.s)
Tasks: 2 (limit: 4761)
CPU: 497ms
CGroup: /user.slice/user-1000.slice/user@1000.service/app.slice/app-mqtt_autostart_.slice/mqtt_autostart_@drukknop.service
├─13433 /bin/bash /usr/sbin/mqtt_drukknop.sh
└─13862 sleep 1
aug 09 16:26:15 raspberrypi systemd[992]: Started mqtt_autostart_@drukknop.service - Running Bash MQTT Scripts for drukknop.Breek deze opdracht indien nodig af met de toets q (Quit) en start de Mosquito opdracht om te ontvangen berichten te controleren. Test of het indrukken van de drukknop de gewenste MQTT berichten aflevert.
Als alles werkt, kan je het script automatisch starten bij het starten van de Raspberry Pi:
pi@raspberrypi:~ $
systemctl --user enable mqtt_autostart_@drukknop.serviceCreated symlink /home/pi/.config/systemd/user/default.target.wants/mqtt_autostart_@drukknop.service → /home/pi/.config/systemd/user/mqtt_autostart_@.service.Als laatste test herstart je de Raspberry Pi en test je of het indrukken van de drukknop de gewenste MQTT berichten aflevert.
- Zorg dat ook de MQTT script voor de led, mcp9808 en ds18b20 automatisch opstarten.
pi@raspberrypi:~ $
systemctl --user enable mqtt_autostart_@led.serviceCreated symlink /home/pi/.config/systemd/user/default.target.wants/mqtt_autostart_@led.service → /home/pi/.config/systemd/user/mqtt_autostart_@.service. pi@raspberrypi:~ $systemctl --user enable mqtt_autostart_@mcp9808.serviceCreated symlink /home/pi/.config/systemd/user/default.target.wants/mqtt_autostart_@mcp9808.service → /home/pi/.config/systemd/user/mqtt_autostart_@.service. pi@raspberrypi:~ $systemctl --user enable mqtt_autostart_@ds18b20.serviceCreated symlink /home/pi/.config/systemd/user/default.target.wants/mqtt_autostart_@ds18b20.service → /home/pi/.config/systemd/user/mqtt_autostart_@.service. - Enkel de MQTT MP3 speler moeten we nog testen.
Start de systemd MQTT MP3 dienst:
pi@raspberrypi:~ $
systemctl --user start mqtt_autostart_@mp3.serviceTest de MQTT MP3 ontvanger door het volgende MQTT bericht te sturen:
pi@raspberrypi:~ $
mosquitto_pub -h localhost -t sound/play/MP3 -m $HOME/Music/burglar.mp3Het alarmsignaal moet nu te horen zijn. Je kunt het afspelen onderbreken met de opdracht:
pi@raspberrypi:~ $
killall paplayAls dit werkt, mag de MQTT MP3 ontvanger automatisch starten:
pi@raspberrypi:~ $
Test na het herstarten of alle MQTT scripts goed werken.systemctl --user enable mqtt_autostart_@mp3.serviceCreated symlink /home/pi/.config/systemd/user/default.target.wants/mqtt_autostart_@mp3.service → /home/pi/.config/systemd/user/mqtt_autostart_@.service.
- Om het te laten uitvoeren door de gebruiker pi, maak je de volgende autostart map aan:
OpenHAB
OpenHAB installeren
OpenHAB is geschreven in JAVA. We moeten dus eerst zorgen dat we JAVA programma's kunnen uitvoeren. Daarvoor installeer je een Java Runtime Environment (JRE). De standaard JRE van Raspberry Pi OS (Debian Bookworm) installeer je metpi@raspberrypi:~ $
Uit de meldingen die voorbij flitsen, kan je afleiden dat openjdk-17-jre werd geïnstalleerd. Maar als je de vereisten (Requirements) voor openHAB 5 in de online installatie handleiding leest, heb je minstens Java 21 nodig. Geen paniek, oudere (Archived) versies (openHAB 4.3 gebruikt Java 17) kan je blijven installeren. Debian Trixie bevat standaard Java 21 maar is nog niet in Raspberry Pi OS opgenomen. M.a.w. hou de Raspberry Pi OS versies in het oog.sudo apt install default-jrePakketlijsten worden ingelezen... Klaar Boom van vereisten wordt opgebouwd... Klaar De statusinformatie wordt gelezen... Klaar Het volgende pakket is automatisch geïnstalleerd en is niet langer nodig: python3-v4l2 Gebruik 'sudo apt autoremove' om het te verwijderen. De volgende extra pakketten zullen geïnstalleerd worden: ca-certificates-java default-jre-headless fonts-dejavu-extra java-common libatk-wrapper-java libatk-wrapper-java-jni libxxf86dga1 openjdk-17-jre openjdk-17-jre-headless x11-utils Voorgestelde pakketten: fonts-ipafont-gothic fonts-ipafont-mincho fonts-wqy-microhei | fonts-wqy-zenhei fonts-indic mesa-utils De volgende NIEUWE pakketten zullen geïnstalleerd worden: ca-certificates-java default-jre default-jre-headless fonts-dejavu-extra java-common libatk-wrapper-java libatk-wrapper-java-jni libxxf86dga1 openjdk-17-jre openjdk-17-jre-headless x11-utils 0 opgewaardeerd, 11 nieuw geïnstalleerd, 0 te verwijderen en 0 niet opgewaardeerd. Er moeten 45,3 MB aan archieven opgehaald worden. Na deze bewerking zal er 203 MB extra schijfruimte gebruikt worden. Wilt u doorgaan? [J/n] Ophalen:1 http://deb.debian.org/debian bookworm/main arm64 ca-certificates-java all 20230710~deb12u1 [11,9 kB] Ophalen:2 http://deb.debian.org/debian bookworm/main arm64 java-common all 0.74 [6.388 B] Ophalen:3 http://deb.debian.org/debian-security bookworm-security/main arm64 openjdk-17-jre-headless arm64 17.0.16+8-1~deb12u1 [42,8 MB] ... Ophalen:9 http://deb.debian.org/debian bookworm/main arm64 x11-utils arm64 7.7+5 [196 kB] Ophalen:10 http://deb.debian.org/debian bookworm/main arm64 libatk-wrapper-java all 0.40.0-3 [63,4 kB] Ophalen:11 http://deb.debian.org/debian bookworm/main arm64 libatk-wrapper-java-jni arm64 0.40.0-3 [49,4 kB] 45,3 MB opgehaald in 5s (8.424 kB/s) Voorheen niet geselecteerd pakket ca-certificates-java wordt geselecteerd. (Database wordt ingelezen ... 149902 bestanden en mappen momenteel geïnstalleerd.) Uitpakken van .../00-ca-certificates-java_20230710~deb12u1_all.deb wordt voorbereid... Bezig met uitpakken van ca-certificates-java (20230710~deb12u1) ... ... Voorheen niet geselecteerd pakket libatk-wrapper-java-jni:arm64 wordt geselecteerd. Uitpakken van .../10-libatk-wrapper-java-jni_0.40.0-3_arm64.deb wordt voorbereid... Bezig met uitpakken van libatk-wrapper-java-jni:arm64 (0.40.0-3) ... Instellen van java-common (0.74) ... Instellen van libxxf86dga1:arm64 (2:1.1.5-1) ... Instellen van fonts-dejavu-extra (2.37-6) ... Instellen van x11-utils (7.7+5) ... Instellen van libatk-wrapper-java (0.40.0-3) ... Instellen van ca-certificates-java (20230710~deb12u1) ... No JRE found. Skipping Java certificates setup. Instellen van libatk-wrapper-java-jni:arm64 (0.40.0-3) ... Instellen van openjdk-17-jre-headless:arm64 (17.0.16+8-1~deb12u1) ... update-alternatives: /usr/lib/jvm/java-17-openjdk-arm64/bin/java wordt gebruikt om in de automatische modus in /usr/bin/java (java) te voorzien update-alternatives: /usr/lib/jvm/java-17-openjdk-arm64/bin/jpackage wordt gebruikt om in de automatische modus in /usr/bin/jpackage (jpackage) te voorzien update-alternatives: /usr/lib/jvm/java-17-openjdk-arm64/bin/keytool wordt gebruikt om in de automatische modus in /usr/bin/keytool (keytool) te voorzien update-alternatives: /usr/lib/jvm/java-17-openjdk-arm64/bin/rmiregistry wordt gebruikt om in de automatische modus in /usr/bin/rmiregistry (rmiregistry) te voorzien update-alternatives: /usr/lib/jvm/java-17-openjdk-arm64/lib/jexec wordt gebruikt om in de automatische modus in /usr/bin/jexec (jexec) te voorzien Bezig met afhandelen van triggers voor hicolor-icon-theme (0.17-2) ... Bezig met afhandelen van triggers voor gnome-menus (3.36.0-1.1) ... Bezig met afhandelen van triggers voor libc-bin (2.36-9+rpt2+deb12u12) ... ... Bezig met afhandelen van triggers voor fontconfig (2.14.1-4) ... Bezig met afhandelen van triggers voor desktop-file-utils (0.26-1) ... Bezig met afhandelen van triggers voor ca-certificates-java (20230710~deb12u1) ... Adding debian:ACCVRAIZ1.pem Adding debian:AC_RAIZ_FNMT-RCM.pem Adding debian:AC_RAIZ_FNMT-RCM_SERVIDORES_SEGUROS.pem ... Adding debian:vTrus_ECC_Root_CA.pem Adding debian:vTrus_Root_CA.pem Adding debian:XRamp_Global_CA_Root.pem done. Instellen van openjdk-17-jre:arm64 (17.0.16+8-1~deb12u1) ... Instellen van default-jre-headless (2:1.17-74) ... Instellen van default-jre (2:1.17-74) ...openHAB wordt aangeboden in een speciaal daarvoor ingerichte softwarebron die je aan Raspberry Pi OS moet toevoegen. Eerst halen we de beveiligingssleutel op:
pi@raspberrypi:~ $
Deze nemen we op in het Raspberry Pi OS besturingssysteem met de volgende drie opdrachten:curl -fsSL "https://openhab.jfrog.io/artifactory/api/gpg/key/public" | gpg --dearmor > openhab.gpgpi@raspberrypi:~ $
De eerste opdracht mislukte omdat de map reeds bestond. Ik volg de handleiding, waarin dit ook vermeld staat.sudo mkdir /usr/share/keyringsmkdir: kan map ‘/usr/share/keyrings’ niet aanmaken: Bestand bestaat al pi@raspberrypi:~ $sudo mv openhab.gpg /usr/share/keyringspi@raspberrypi:~ $sudo chmod u=rw,g=r,o=r /usr/share/keyrings/openhab.gpgDan kunnen we nu de stabiele (Official/Stable) openHAB softwarebron activeren:
pi@raspberrypi:~ $
Vervolgens synchroniseren we de beschikbare lijst met softwarepakketten:echo 'deb [signed-by=/usr/share/keyrings/openhab.gpg] https://openhab.jfrog.io/artifactory/openhab-linuxpkg stable main' | sudo tee /etc/apt/sources.list.d/openhab.listdeb [signed-by=/usr/share/keyrings/openhab.gpg] https://openhab.jfrog.io/artifactory/openhab-linuxpkg stable mainpi@raspberrypi:~ $
En kunnen we een lijst met stabiele openHAB versies opvragen:sudo apt-get updateGeraakt:1 http://deb.debian.org/debian bookworm InRelease Geraakt:2 http://deb.debian.org/debian-security bookworm-security InRelease Geraakt:3 http://deb.debian.org/debian bookworm-updates InRelease Ophalen:4 http://archive.raspberrypi.com/debian bookworm InRelease [55,0 kB] Ophalen:5 http://archive.raspberrypi.com/debian bookworm/main armhf Packages [555 kB] Ophalen:6 https://openhab.jfrog.io/artifactory/openhab-linuxpkg stable InRelease [12,8 kB] Ophalen:7 https://openhab.jfrog.io/artifactory/openhab-linuxpkg stable/main armhf Packages [7.413 B] Ophalen:8 https://openhab.jfrog.io/artifactory/openhab-linuxpkg stable/main arm64 Packages [7.413 B] 637 kB opgehaald in 1s (715 kB/s) Pakketlijsten worden ingelezen... Klaarpi@raspberrypi:~ $
Daaruit blijkt dat de laatste versie van openHAB die nog werkt op Raspberry Pi OS Bookworm, versie 4.3.6-1 is. Deze openHAB versie installeer je met:apt list -a openhab
Bezig met oplijsten... Klaar
openhab/stable,stable 5.0.0-1 all
openhab/stable,stable 4.3.6-1 all
openhab/stable,stable 4.3.5-1 all
...
openhab/stable,stable 3.0.2-1 all
openhab/stable,stable 3.0.1-2 all
openhab/stable,stable 3.0.0-1 allpi@raspberrypi:~ $
Om te voorkomen dat bij elke upgrade openHAB naar een hogere versie wordt opgewaardeerd (zal toch telkens mislukken), kan je dit indien gewenst (maar niet verplicht) blokkeren met:sudo apt install openhab=4.3.6-1
Pakketlijsten worden ingelezen... Klaar
Boom van vereisten wordt opgebouwd... Klaar
De statusinformatie wordt gelezen... Klaar
Het volgende pakket is automatisch geïnstalleerd en is niet langer nodig:
python3-v4l2
Gebruik 'sudo apt autoremove' om het te verwijderen.
De volgende NIEUWE pakketten zullen geïnstalleerd worden:
openhab
0 opgewaardeerd, 1 nieuw geïnstalleerd, 0 te verwijderen en 0 niet opgewaardeerd.
Er moeten 111 MB aan archieven opgehaald worden.
Na deze bewerking zal er 123 MB extra schijfruimte gebruikt worden.
Ophalen:1 https://openhab.jfrog.io/artifactory/openhab-linuxpkg stable/main arm64 openhab all 4.3.6-1 [111 MB]
111 MB opgehaald in 13s (8.291 kB/s)
Voorheen niet geselecteerd pakket openhab wordt geselecteerd.
(Database wordt ingelezen ... 150339 bestanden en mappen momenteel geïnstalleerd.)
Uitpakken van .../openhab_4.3.6-1_all.deb wordt voorbereid...
Bezig met uitpakken van openhab (4.3.6-1) ...
Instellen van openhab (4.3.6-1) ...
[openHAB] Please use the following commands to launch openHAB on a system restart.
sudo /bin/systemctl daemon-reload
sudo /bin/systemctl enable openhab.service
[openHAB] You can start openHAB manually by executing the command:
sudo /bin/systemctl start openhab.servicepi@raspberrypi:~ $
sudo apt-mark hold openhabopenhab is ingesteld op te handhaven.Handig om te weten:Heb je bij het leren werken met openHAB teveel onherstelbare fouten gemaakt (al doende leer je, ook van de fouten), begin dan helemaal opnieuw door openHAB te resetten. Je kunt openHAB resetten door de volgende pakketten te verwijderen:
pi@raspberrypi:~ $
En openHAB opnieuw te installeren:sudo apt purge openhab openhab-addonspi@raspberrypi:~ $
sudo apt install openhab=4.3.6-1Start openHAB met de opdracht:
pi@raspberrypi:~ $
Controleer of openHAB goed werkt:sudo /bin/systemctl start openhab.servicepi@raspberrypi:~ $
Breek de opdracht af met de q toets.sudo systemctl status openhab.service
● openhab.service - openHAB - empowering the smart home
Loaded: loaded (/lib/systemd/system/openhab.service; disabled; preset: enabled)
Active: active (running) since Sat 2025-07-26 18:15:02 CEST; 5min ago
Docs: https://www.openhab.org/docs/
https://community.openhab.org
Main PID: 22169 (java)
Tasks: 117 (limit: 4761)
CPU: 1min 22.479s
CGroup: /system.slice/openhab.service
└─22169 /usr/bin/java -XX:-UsePerfData -Dopenhab.home=/usr/share/openhab -Dopenhab.conf=/etc/openhab ->
jul 26 18:15:02 raspberrypi systemd[1]: Started openhab.service - openHAB - empowering the smart home.
Activeer het automatisch opstarten van openHAB bij het opstarten van de Raspberry Pi:pi@raspberrypi:~ $
sudo systemctl enable openhab.serviceCreated symlink /etc/systemd/system/multi-user.target.wants/openhab.service → /lib/systemd/system/openhab.service.- Zodra openHAB is geïnstalleerd en gestart, start je de gebruikersinterface door naar http://localhost:8080 te surfen.
Vanaf een andere computer vervang je localhost door het adres of de hostnaam van de Raspberry Pi (vb: http://raspberrypi.local:8080).
Eerst maak je een administrator account aan (zorg dat je de gebruikersnaam en bijhorende wachtwoord straks nog weet):
Nadat je een beheerdersgebruiker hebt aangemaakt, wordt je stapsgewijs door de eerste configuratie geleid. Begin met het instellen van jouw taal, regio en tijdzone.
Klik op de knopJe kunt nu jouw locatie instellen, of deze stap overslaan en later voltooien.
De locatie gegevens zijn o.a. nodig voor het berekenen van de zonsopgang en -ondergang. De breedtegraad (Latitude) en lengtegraad (Longitude) zijn de coördinaten van jouw woonplaats die je via een kaart (Map) kunt instellen. Na het instellen van de locatie verschijnt de knop waarop je klikt om door te gaan.openHAB stelt voor om de Persistence uitbreidingen (add-ons) te installeren. Lees de getoonde informatie en beslis of je de add-on wenst.
Laten we deze installeren.Je hebt nu de mogelijkheid om nog meer openHAB-add-ons te installeren. Het openHAB-systeem voert een automatische scan uit om domotica-apparatuur en -software op jouw Raspberry Pi en thuisnetwerk (LAN) te detecteren. Op basis van het scanresultaat worden aanbevolen add-ons voorgesteld om te installeren. Je kunt de lijst met add-ons aanpassen. Doe dit echter alleen als je al weet dat je specifieke add-ons nodig hebt (bijvoorbeeld als je een upgrade uitvoert vanaf een ouder openHAB-systeem). Of sla deze stap over als je de add-ons liever later afzonderlijk installeert. Je kunt add-ons altijd later installeren/verwijderen, zodat je jouw systeem in de loop van de tijd kunt aanpassen en verbeteren.
Hoewel we straks de MQTT Binding nodig hebben, schakel je deze nu uit. Later tonen we hoe je een add-on kunt toevoegen. Klik op de knop .Wacht tot de add-ons geïnstalleerd zijn. Klaar. Klik op de koppeling Aan de slag.
openHAB MQTT
Daarstraks hebben we de MQTT Bindings niet geïnstalleerd, hoewel we die nodig hebben om onze sensoren en actuatoren aan openHAB te koppelen. Op de volgende manier voeg je de MQTT Bindings add-on (of andere) toe aan openHAB.Open in het linker paneel de categorie Instellingen en activeer het onderdeel Things.
Elk domoticasysteem gebruikt een eigen woordenschat om zaken aan te duiden. Lees de informatie om te achterhalen wat Things in openHAB betekend. Klik onderaan rechts op ronde blauwe knop om de MQTT service toe te voegen.
Klik op de knop .Opnieuw wordt een automatische scan uitgevoerd. Indien de MQTT Binding add-on niet wordt voorgesteld, vul je in het Search bindings tekstvak mqtt in.
Klik op de knop van de gevonden MQTT Binding add-on. Indien dit niet werkt, vernieuw je de webpagina (opnieuw laden met F5). Webbrowsers werken met een cache om sneller te werken, maar dit geeft als nadeel dat aanpassingen niet altijd werken.
Installeer de MQTT Binding ().Soms lijkt het dat de installatie blijft duren (draaiend pictogram), is deze na een tijdje klaar. Zichtbaar in de categorie Add-on Winkel. Dit is opnieuw te wijten aan de browser cache.
Ga terug naar de pagina om een Thing toe te voegen (Instellingen > Things > + knop onderaan rechts).
Om de MQTT Bindings te activeren, klik je op de Binding MQTT Binding.
Om onze MQTT Broker met openHAB te verbinden, klik je op de knop van de MQTT Broker.Begin met het ingeven van een unieke ID (MQTTBroker) in één woord. Dit kan achteraf niet meer gewijzigd worden. Het label wordt automatisch aangevuld, hoewel je dit zelf kunt aanpassen. Daar we een MQTT Broker gebruiken zonder gebruiker en bijhorend wachtwoord moet je de optie Show advanced niet activeren. Nu nog enkel het MQTT Broker Hostname/IP veld invullen (localhost = MQTT Broker werkt op hetzelfde apparaat als openHAB).
Klik op de knop Create Thing.Indien alle gegevens correct werden ingevoerd, verschijnt er een nieuw Thing met de naam MQTT Broker en deze moet ONLINE zijn, m.a.w. de MQTT Broker is verbonden met openHAB.
openHAB LED
Nu openHAB een verbinding heeft met de MQTT Broker kunnen ze berichten uitwisselen. We beginnen met het aansturen van de LED. M.a.w. openHAB stuurt berichten naar de MQTT Broker waardoor ze door ons script wordt verwerkt.Klik op de Things pagina op de + knop.
Klik op de Binding MQTT Binding.
Klik op het toe te voegen Thing Generic MQTT Thing (generic = zelf in te stellen).Geef de LED een uniek Thing ID (één woord): MQTTLED en een herkenbaar Label: MQTT LED.
Klik op de Bridge en activeer de daarstraks gedefinieerde MQTT Broker (mqtt:broker:MQTTBoker).
Klik op de knop .De MQTT LED verschijnt ONLINE op de Things pagina.
Klik op MQTT LED Thing om deze in te stellen.Activeer het tabblad Channels.
Klik op de knop Add Channel.Geef de Channel een uniek ID: MQTTLED en een herkenbaar Label: MQTT LED. Een beschrijving kan ook handig zijn, maar is niet verplicht.
Het Channel type is in ons geval een On/Off Switch, het MQTT LED script schakelt de LED namelijk in of uit.
Daar ons eenvoudig MQTT LED script geen toestand naar de MQTT Broker kan sturen, laten we de tekstveld MQTT State Topic leeg (lees ook steeds de begeleidende informatie bij de in te vullen velden).
De MQTT Command topic is in ons geval (zie MQTT LED script) stat/led/POWER. Je kunt de nodige MQTT berichten ook nagaan via de opdrachtmosquitto_sub -h localhost -v -t "#"waarmee je alle ontvangen MQTT berichten kunt weergeven.
Het tekstveld Custom On/Open Value geef je de waarde ON en Custom Off/Closed Value de waarde OFF (zie MQTT LED script).
Klik op de knop .De MQTT LED channel verschijnt op de pagina. Klik op de MQTT LED channel.
Klik op Add Link to item....Activeer de optie Create a new Item.
Geef het Item een unieke Name: MQTTLED en een herkenbaar Label: MQTT LED.
Het type blijft Switch en als Category geef je (selecteer je) light. Het gaat hier namelijk om een lichtschakelaar. Dit bepaalt ook het pictogram.
Het gaat nog steeds om een lichtschakelaar, waardoor je voor de Semantic Class de Switch en voor de Semantic Property een Light selecteert.
Klik helemaal onderaan op de knop .De MQTT LED met lamp pictogram verschijnt op de pagina.
Je kunt nu het MQTT LED Item testen. Klik daarvoor op het item MQTT LED.
Klik op de weergave van de schakelaar (grijs met onderaan een witte bol) om de LED te laten oplichten.
De schakelaar krijgt een oranje kleur en het pictogram van de lamp een gele kleur.
Test eveneens of je de LED ook terug kunt uitschakelen. Indien dit niet werkt, controleer je naast de openHAB MQTT LED instellingen ook de status van onze mqtt_autostart_@led.service dienst:pi@raspberrypi:~ $
Desnoods herstart je de Raspberry Pi.systemctl --user status mqtt_autostart_@led.serviceopenHAB drukknop
Een drukknop is een sensor (invoer-apparaat) met twee toestanden (binair: aan of uit). Om deze aan openHAB toe te voegen, ga je als volgt te werk.Activeer de Things pagina en klik op de + knop om een Thing toe te voegen.
Aangezien de drukknop eveneens via de MQTT Broker werkt, klik je op de MQTT Binding.
Ga verder naar Generic MQTT Thing.
Geef het drukknop Thing een uniek ID: MQTTDrukknop, een Label: MQTT Drukknop en selecteer als Bridge de MQTT Broker. Klik tenslotte op .
Klik op de Things pagina op de MQTT Drukknop en activeer het tabblad Channels. Klik op de knop Add Channel.
Geef het drukknop Channel een uniek ID: MQTTDrukknop en Label: MQTT Drukknop. Het Channel type wordt opnieuw een On/Off Switch waarbij het veld MQTT State Topic: stat/drukknop/POWER (ontvanger) wordt. De Custom On/Open Value is ON en Custom Off/Closed krijgt de waarde OFF. Klik op de knop .
Open de MQTT Drukknop Channel en klik op Add Link to Item....
Activeer de optie Create a new item. Geef het item de Name: MQTTDrukknop, het Label: MQTT Drukknop. Als Category geef (selecteer) je in switch. De Semantic Class wordt eveneens Switch. De Semantic Property blijft op None staan. Klik onderaan op de knop .
Test de werking van de drukknop.
openHAB mcp9808
De MCP9808 meet de temperatuur, dus ook een sensor zoals de drukknop.
Probeer zelf een MQTT MCP9808 item aan te maken en hou rekening met:Aangezien we van de MQTT Broker een getal terug krijgen, wordt het Channel Type een Number Value. Op de Link Channel to item pagina, kan je bij Dimension (eenheden) Temperature (°C) selecteren.
Na het aanmaken van de Link, moet na een tijdje (slechts 1 meting per minuut) een getal verschijnen (temperatuur).openHAB DS18B20
Herhaal de werkwijze om de 1-wire DS18B20 temperatuur sensor toe te voegen.openHAB Tasmota
De volgende video toont hoe je te werk moet gaan om een Tasmota schakelaar toe te voegen. De video start pas bij de uitleg om de Tasmota schakelaar toe te voegen, maar kan wel teruggespoeld worden.
openHAB Model
Nu we verschillende sensors en actuatoren aan openHAB hebben toegevoegd, is het tijd om deze in groepen in te delen. Dit zorgt ook voor een gebruiksvriendelijker overzicht. In openHAB gebeurt dit via Model. Hoewel er verschillende methoden zijn om items in een Model te plaatsen (zie onderstaande video), toon ik er hier één van.
Activeer bij de Instellingen het onderdeel Model. Nu worden alle items onder elkaar weergegeven.
Eerst zorgen we voor een functionele indeling, bijvoorbeeld op basis van plaatsen in het huis. Zorg dat er geen enkel item geselecteerd is (klik op vrij gedeelte). Klik daarna in het rechter paneel op Add Location.Er verschijnt in het overzicht (middenpaneel) een (New Item) en in het rechter paneel een formulier. Geef het item een Name: Klaslokaal en een Label: Klaslokaal. Geef (en/of selecteer) bij Category: groundfloor.
Scroll wat naar beneden en klik op de knop .Daar veel van de in dit voorbeeld gebruikte items op onze Raspberry Pi zijn aangesloten, gaan we in de locatie Klaslokaal een sublocatie aanmaken. Zorg dat Klaslokaal geselecteerd is.
En klik op Add LocationGeef het item een Name: Raspberrypi en een Label: Raspberry Pi. We laten de Category leeg, m.a.w. je hoeft niet altijd een Category te selecteren. OpenHab laat ook toe om nieuwe Categorieën aan te maken. Let ook op keuzelijst Parent Groups, daar staat Klaslokaal, want we hadden deze locatie op voorhand geselecteerd. De Parent Groups zorgt ervoor dat dit item in de locatie Klaslokaal zal terecht komen.
Klik op de knop . Klik op de driehoek voor de locatie Klaslokaal om de onderliggende locaties weer te geven.Om de sensors, actuators en andere items naar een locatie te verplaatsen, selecteer je een item, bijvoorbeeld MQTT Drukknop.
Klik in het rechter paneel op ⌄ Edit.
Scroll in het rechter paneel wat naar beneden en klik bij Parent Groups op Select.Selecteer de locatie waarin je het item wilt plaatsen: Raspberry Pi.
Klik rechts bovenaan op Sluiten (rood woord).Nu je een Parents Groups hebt toegewezen, verschijnt onderaan een Save knop.
Klik op de knop .Plaats de items MQTT DS18B20, MQTT LED en MQTT MCP9808 in de locatie Raspberry Pi.
MQTT Tasmota plaats je in de locatie Klaslokaal. Dit wordt het resultaat:
Om het uiteindelijke resultaat te bewonderen, klik je in het linker paneel bovenaan op het openHAB logo. Je komt nu terecht in het lege Overzicht. Activeer onderaan de categorie Locaties
Mocht je geen of niet alle locaties zien, vergeet dan niet de webpagina eens te vernieuwen (opnieuw laden met F5). Webbrowsers werken met een cache om sneller te werken, maar dit geeft als nadeel dat aanpassingen niet altijd worden weergegeven. Klik op de locatie Raspberry Pi om alle items in deze locatie weer te geven.
De de toestand van de sensoren op deze locatie kan je hier bekijken, maar ook de aanwezige actuatoren (MQTT LED) bedienen.Deze locatie sluit je bovenaan rechts met de x knop. Onderstaande video toont hoe je met het onderdeel Model in openHAB werkt.
Je kunt nog veel verder gaan in het opmaken van de structuur en lay-out. Maar neem zeker in het begin niet teveel hooi op de vork. Ter info: de volgende video:
openHAB Rules
Tot nu toe hebben we openHAB via Things met apparaten verbonden, de apparaten met Items gemodelleerd en hoe je een display kunt bouwen om je huis te bedienen. Maar dat alles komt neer op huisbediening, niet op automatisering. Om huisautomatisering te creëren, moeten we gedragingen definiëren. In openHAB worden gedragingen gedefinieerd met behulp van Rules (regels). Bijna alles wat je maar kunt bedenken, kan worden gedaan, zolang je maar een relevante gebeurtenis hebt om het te starten en toegang hebt tot de gegevens die nodig zijn om te beslissen wat er moet gebeuren.openHAB is een gebeurtenisgestuurd (events) systeem. Dat betekent dat wanneer er een gebeurtenis plaatsvindt, delen van openHAB die op die gebeurtenis letten, kunnen reageren. Sommige regels worden geactiveerd wanneer een gebeurtenis waarbij een item verandert plaatsvindt, om bepaald gedrag te creëren.
Het gewenste gedrag is bijvoorbeeld dat een lamp (in ons voorbeeld weergegeven door het item MQTT LED) wordt ingeschakeld wanneer er op een knop wordt gedrukt (in ons voorbeeld weergegeven door het item MQTT Drukknop). Om dit gedrag te creëren, kunnen we een regel maken die wordt geactiveerd wanneer het item MQTT Drukknop omschakelt van OFF naar ON, waarna het commando ON naar het item MQTT LED wordt verzonden.
Activeer bij de Instellingen het onderdeel Rules. Klik rechts onderaan op de om een regel toe te voegen. Geef de regel een unieke Rule ID: LichtAan en een veelzeggend Label: Licht Aan.
Klik op Add Trigger (gebeurtenis waarop gereageerd moet worden).Onze drukknop is een Item, m.a.w. klik op Item Event. Open de locatie Klaslokaal en daarna Raspberry Pi (zie Model). Selecteer het item MQTT Drukknop.
Klik bovenaan rechts op Pick.Activeer de optie changed en geef het invulveld from state de waarde OFF. Het invulveld to state krijgt de waarde ON. M.a.w. als de toestand van de drukknop verandert van OFF naar ON, moet er iets gebeuren.
Klik rechts bovenaan op Save.Klik op Add Action (wat moet er dan gebeuren). Onze lamp (LED) is een Item, m.a.w. klik op Item Action. Open de locatie Klaslokaal en daarna Raspberry Pi. Selecteer het item MQTT LED.
Klik bovenaan rechts op Pick. Activeer de optie send a command en activeer de optie ON.
Klik rechts bovenaan op Save.Dit is het resultaat:
Klik rechts bovenaan op Save (Ctrl-S) om de regel aan te maken.
Je kunt actie testen door op de blauwe holle pijl te klikken. De LED moet nu oplichten. De regel zelf test je door pagina met Locaties (via openHAB logo links bovenaan) te activeren. Open de locatie Raspberry Pi. Schakel de MQTT LED uit en zorg dat de MQTT Drukknop op OFF staat. Druk nu op de drukknop tot de waarde van de drukknop naar ON verandert. De regel zal ervoor zorgen dat daardoor de LED automatisch oplicht.
Een tweede regel is nodig om MQTT LED met de MQTT Drukknop terug uit te schakelen. Maak deze regel nu zelf aan. Dit wordt het.
Test de nieuwe regel en pas deze desnoods aan tot ze werkt Let daarbij goed op de toestand van de MQTT Drukknop (ON/OFF) en de MQTT LED.openHAB Scripts
Om energie te besparen, worden lampen soms automatisch na een bepaalde tijd uitgeschakeld (denk aan de verlichting in de traphal van een appartement). Om dit in openHAB te verwezenlijken, gaan we een script schrijven.
Activeer bij de Instellingen het onderdeel Scripts. Klik rechts onderaan op de om een script toe te voegen. Geef het script een uniek Script ID: LichtTraphal en een veelzeggend Label: Licht Traphal. Activeer de optie Design with Blockly.
Klik helemaal onderaan de pagina op de knop .Na een tijdje verschijnt een grafische programmeeromgeving.
De grafische programmeeromgeving is bedoeld om het zo eenvoudig mogelijk te houden, maar dit maakt het allemaal nogal omslachtig. Sleep vanuit de groep Items & Things de send command ... to ... structuur naar het rechter paneel.Pas de value aan naar ON.
Pas het item Myitem aan naar MQTTLED.Sleep vanuit de groep Timers & Delay het blok wait for .... ms naar het rechter paneel tot juist onder de send command ON to MQTTLED structuur. Deze groep klikt vast aan de send command structuur.
Voeg daaronder terug een send command .... to .... toe en pas deze aan om de MQTTLED uit te schakelen.
Klik rechts bovenaan op Save (Ctrl-S). Om het script te testen, kan je onderaan klikken op Run Now (Ctrl-R). De LED licht dan 1 seconde (= 1000 ms) op.Als het script werkt, kan je de duurtijd aanpassen naar 3 minuten (3 * 60 * 1000 = 180000 ms). Vergeet niet op te slaan.
Dit script moet uitgevoerd worden als er op de drukknop wordt gedrukt. Activeer daarvoor het onderdeel Rules
Klik op de regel Licht Aan.
Klik op de actie send command ON to MQTTLED.
Klik op Then (staat nu uiterst rechts op verstuur een commando).
Activeer de optie uitvoeren van scènes, scripts & rules.
Klik op Scenes, scripts & rules.
Activeer het script Licht Traphal en klik rechts bovenaan op Sluiten.
Klik rechts bovenaan op Save.
Sla de aangepaste regel op door rechts bovenaan te klikken op Save (Ctrl-S). En test de werking van de aangepaste regel.Je zult merken, dat je bij het drukken op de drukknop binnen de 3 minuten van het script de LED dooft door de regel LED Uit. Daarenboven blijft de toestand van de drukknop op ON staan, waardoor je tweemaal op de drukknop moet drukken om het licht opnieuw aan te zetten. M.a.w. de drukknop die nu werkt als een Aan/Uit schakelaar moet werken als een contact schakelaar. M.a.w. elke druk op de drukknop moet zorgen dat het licht 3 minuten blijft branden, daarna moet de drukknop terug de toestand OFF krijgen.
Eerst schakel je in het onderdeel Rules de regel Licht Uit door op de pauze knop (Disable (Ctrl-D)) te klikken.
Vergeet niet op te slaan. Je kunt ook ongebruikte regels verwijderen, maar doe dit pas als je zeker weet dat de nieuwe automatisatie goed werkt. Gepauzeerde regels kan je later terug activeren, als je de oude automatisatie opnieuw wilt gebruiken. Na de testperiode mag je niet vergeten de niet langer noodzakelijke regels te verwijderen. Zo hou je een beter overzicht.Om van de drukknop een contact schakelaar te maken, voeg je de regel Licht Aan een trigger toe waardoor het licht ook wordt ingeschakeld bij het veranderen van de drukknop toestand van ON naar OFF.
Bij het testen kan je in het logboek volgen wat er in openHAB gebeurt. Om de meldingen in het logboek te volgen, start je in het Onwikkelgereedschap de Log Viewer.
We waarderen onze drukknop op naar een alarmschakelaar. Vanzelfsprekend zou je de drukknop kunnen vervangen door een bewegingssensor (PIR) of een andere inbraakdetectieschakelaar. Daarbij moet een alarmsignaal afgaan. We gebruiken daarvoor een MP3 bestand die we eerder gedownload hebben om de MQTT MP3 speler te maken.
Activeer de Things pagina en klik op de + knop om een Thing toe te voegen.
Aangezien de MP3 speler eveneens via de MQTT Broker werkt, klik je op de MQTT Binding.
Ga verder naar Generic MQTT Thing.
Geef de MP3 speler Thing een uniek ID: MQTTPlayMP3, een Label: MQTT Play MP3 en selecteer als Bridge de MQTT Broker. Klik tenslotte op .
Klik op de Things pagina op de MQTT Play MP3 en activeer het tabblad Channels. Klik op de knop Add Channel.
Geef het MQTT Play MP3 Channel een uniek ID: MQTTPlayMP3 en Label: MQTT Play MP3. Het Channel type wordt Text Value (sturen in tekstvorm een pad en bestandsnaam) waarbij het veld MQTT Command Topic: sound/play/MP3 (zender) wordt. Klik op de knop .
Open de MQTT Play MP3 Channel en klik op Add Link to Item....
Activeer de optie Create a new item. Geef het item de Name: MQTTPlayMP3, het Label: MQTT Play MP3. Als Category geef (selecteer) je in Alarm. De Semantic Class wordt eveneens Alarm. De Semantic Property mag Noise worden. De Direct Parent Groups wordt Raspberrypi, het geluid wordt door de Raspberry Pi afgespeeld. Klik onderaan op de knop .
Zorg dat je het script Licht Traphal kunt aanpassen. Pas het script aan tot:
Sla de aanpassing op en test deze. Je kunt het volume regelen via de volumeregelaar in het systeemvak van de Raspberry Pi.- OpenHAB lijkt in het begin moeilijk, maar is zeer veelzijdig. Door zijn populariteit vind je 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 openHAB zelf. Veel succes.
Domoticz
Tijd voor een andere domotica-controller. Hoewel ze ongeveer gelijktijdig ontstonden Domoticz in 2012 en openHAB in 2011 verschillen ze door de gebruikte programmeertaal zowel qua vormgeving als qua techniek. Op het eerste zicht lijkt Domoticz 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.- Domoticz installeren:
- Voor we van start gaan met Domoticz stoppen we openHAB met de opdracht:
pi@raspberrypi:~ $
sudo systemctl stop openhab.service - openHAB schakel je bij het opstarten van de Raspberry Pi uit met:
pi@raspberrypi:~ $
sudo systemctl disable openhab.serviceRemoved "/etc/systemd/system/multi-user.target.wants/openhab.service". - Download en installeer de software:
pi@raspberrypi:~ $
sudo bash -c "$(curl -sSfL https://install.domoticz.com)" - Volg de richtlijnen van de installatie-assistent, gebruik daarbij de standaard voorgestelde instellingen.
- Voor we van start gaan met Domoticz stoppen we openHAB met de opdracht:
- Domoticz bedien en configureer je met een webpagina.
- Surf op de Raspberry Pi naar http://localhost:8080 of http://127.0.0.1:8080 of vanaf een ander apparaat naar
http://raspberrypi.local:8080. Je moet je aanmelden met de standaard gebruikersnaamadminmet het wachtwoorddomoticz. Automatisch wordt je doorgestuurd naar het Dashboard van Domoticz. Dit is een startpagina die je zelf kunt samenstellen. - 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.
- 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.
- Verander de taal (Language) naar Nederlands (Dutch).
- 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.
- 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.
- Surf op de Raspberry Pi naar http://localhost:8080 of http://127.0.0.1:8080 of vanaf een ander apparaat naar
- Laten we ook nu weer beginnen met het aansturen de LED via MQTT berichten.
We beginnen met het koppelen van de Mosquito (zie Mosquito server installeren) MQTT server aan Domoticz:
- Activeer bij Instellingen de pagina Hardware.
- We voegen de Mosquito Broker toe met als
Naam: MQTT Broker
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 . Deze wordt dan bovenaan de pagina in de hardwarelijst weergeven van waaruit je geselecteerde hardware kunt aanpassen en verwijderen.
Type: MQTT Client Gateway with LAN interface
Remote address:: 127.0.0.1
Onderwerp IN voorvoegsel: domoticz/in
Onderwerp UIT voorvoegsel: domoticz/out
- 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)
- Nu kunnen we voor het LED MQTT bericht een virtuele sensor aanmaken.
Klik bij de MQTT Dummy Hardware op de knop .
Geef de virtuele sensor de Naam
MQTT LEDen gebruik als Sensor TypeSchakelaar. - Activeer bij Instellingen de pagina Apparaten.
- Om te achterhalen welk MQTT bericht Domoticz stuurt als je het licht in- of uitschakelt, voer je de volgende opdracht uit:
pi@raspberrypi:~ $
Om het licht om te schakelen, klik je in Domoticz op de pagina met de Apparaten op het lamp pictogram van de regel MQTT LED. Bij het inschakelen verschijnt bij de mosquito_sub opdracht:mosquitto_sub -h localhost -v -t "domoticz/#"domoticz/out { "Battery" : 255, "LastUpdate" : "2025-08-11 17:50:39", "RSSI" : 12, "description" : "", "dtype" : "Light/Switch", "hwid" : "3", "id" : "00014051", "idx" : 1, "name" : "MQTT LED", "nvalue" : 1, "org_hwid" : "3", "stype" : "Switch", "svalue1" : "0", "switchType" : "On/Off", "unit" : 1 }En bij het uitschakelen:domoticz/out { "Battery" : 255, "LastUpdate" : "2025-08-11 17:50:41", "RSSI" : 12, "description" : "", "dtype" : "Light/Switch", "hwid" : "3", "id" : "00014051", "idx" : 1, "name" : "MQTT LED", "nvalue" : 0, "org_hwid" : "3", "stype" : "Switch", "svalue1" : "0", "switchType" : "On/Off", "unit" : 1 }Domoticz gebruikt voor MQTT communicatie JSON, een courante methode om gegevens te transporteren. Het enige verschil in de bovenstaande JSON berichten is de waarde "nvalue" : 0, of "nvalue" : 1,. Druk Ctrl+c om de mosquito_sub opdracht af te breken. - Daarmee weten we genoeg om een MQTT ontvanger script voor Domoticz te schrijven:
pi@raspberrypi:~ $
Met de volgende inhoud:nano bin/mqtt_domoticz.sh#!/bin/bash
# LED aangesloten op GPIO12
gpio=12
# Alleen luisteren naar berichten van Domoticz
topic_name="domoticz/out/#"
# Blijf constant luisteren
while read message
do
# Activeer de volgende twee regels om te testen
# timestamp=$(date)
# echo "$timestamp: $message"
if [ "$message" == "{" ]; then
# initialiseer JSON bericht
json=$message
else # Vul JSON bericht verder aan
json+=$message
if [ "$message" == "}" ]; then
# Einde JSON bericht: verwerken
# Tekstwaarde van name opzoeken
name=$(echo $json | grep -o '"name" : "[^"]*' | grep -o '[^"]*$')
if [ "$name" == "MQTT LED" ]; then
# Numerieke waarde van nvalue opzoeken
nvalue=$(echo $json | grep -o '"nvalue" : [^,]*' | grep -Eo '[0-9]+$')
if [ $nvalue == "1" ]; then
# LED laten oplichten
pinctrl set $gpio op dh
elif [ $nvalue == "0" ]; then
# LED doven
pinctrl set $gpio op dl
fi
fi
fi
fi
# naar de MQTT berichten
done < <(mosquitto_sub -t $topic_name)Maak het script uitvoerbaar:
pi@raspberrypi:~ $
chmod +x bin/mqtt_domoticz.shTest het script met de opdracht:
pi@raspberrypi:~ $
bin/mqtt_domoticz.shSchakel in Domoticz het licht aan en terug uit en controleer of de LED oplicht en terug dooft. Breek het mqtt_domoticz.sh script af met Ctrl+c.
Start het mqtt_domoticz.sh automatisch met de opdracht:
pi@raspberrypi:~ $
systemctl --user enable --now mqtt_autostart_@domoticz.serviceCreated symlink /home/pi/.config/systemd/user/default.target.wants/mqtt_autostart_@domoticz.service → /home/pi/.config/systemd/user/mqtt_autostart_@.service.Dankzij de optie
--nowwerd het script ook gestart. Test dit door opnieuw in Domotizc de LED om te schakelen.
- Om de drukknop aan Domoticz toe te voegen, gaan we op dezelfde manier te werk:
- Activeer via Instellingen de Hardware pagina.
- Klik op de knop van de MQTT hardware:
Naam: MQTT Drukknop
Sensor Type: Schakelaar - Activeer bij Instellingen de pagina Apparaten.
- Je kunt de werking testen door de volgende opdracht uit te voeren, zorg er wel voor dat
idxwaarde overeenkomt met de waarde in de Domoticz tabel (zie afbeelding):pi@raspberrypi:~ $
In de Data kolom van de MQTT Drukknop moet On verschijnen. Dit kan je ook waarnemen op de pagina met de Schakelaars.mosquitto_pub -h localhost -t "domoticz/in" -m '{"command": "switchlight", "idx": 2, "switchcmd": "On" }'
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" }' - De volgende stap bestaat uit het aanpassen van ons mqtt_drukknop.sh script om de drukknop toestand ook naar Domoticz te sturen:
pi@raspberrypi:~ $
Dit wordt het aangepaste script:nano bin/mqtt_drukknop.sh#!/bin/bash
# Stuur gpio 8 data (drukknop) naar de MQTT broker
# Bij het opstarten is de drukknop niet actief
power="OFF"
# Drukknop aangelsoten op GPIO8
gpio=8
# Initialiseer de drukknop GPIO als input met standaard hoog (pull up)
pinctrl set $gpio ip pu
# Domoticz Apparaat Idx waarde
idx=2
# Oneindig lang gaan we de stand van de drukknop opvragen
# Breek het programma af met Ctrl+c
while :
do
# Wacht tot de drukknop wordt ingedrukt
while :
do
pinctrl get $gpio | grep -q " lo "
if [ $? -eq 0 ]; then
# Omschakelen
if [ $power == "OFF" ]; then
power="ON"
mosquitto_pub -h localhost -t "domoticz/in" -m '{"command": "switchlight", "idx": '$idx', "switchcmd": "On" }'
else
power="OFF"
mosquitto_pub -h localhost -t "domoticz/in" -m '{"command": "switchlight", "idx": '$idx', "switchcmd": "Off" }'
fi
# Drukknop werd ingedrukt, verandering doorsturen naar MQTT Broker
mosquitto_pub -h localhost -t stat/drukknop/POWER -m $power
break;
fi
sleep 1
done
# Wacht tot de drukknop terug wordt losgelaten
while :
do
pinctrl get $gpio | grep -q " hi "
if [ $? -eq 0 ]; then
break;
fi
sleep 1
done
doneHerstart het aangepaste script om deze te activeren:
pi@raspberrypi:~ $
systemctl --user restart mqtt_autostart_@drukknop.serviceControleer of Domoticz reageert op het indrukken van de drukknop.
- 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 .
- 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 indien de drukknop is uitgeschakeld. Wanneer de drukknop is ingeschakeld, heeft die bij mij de toestand Closed.
- 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).
- Maak een nieuwe gebeurtenis ( tabbladknop) van het type (scripttaal) Blockly.
- Activeer de optie met de Aan knop.
- Geef de gebeurtenis een naam: LED aan.
- 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.
- 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.
- 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).
- We moeten de toestand van de drukknop nagaan. Sleep uit de groep Devices > Switches het M-R pictogram naar het eerste gaatje van de vergelijking. Zorg dat Drukknop achter M-R staat (vervolgkeuzelijst).
- 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 Closed.
- Voor het Do gedeelte van de If Do structuur ga je op dezelfde manier te werk.
Het volledige script wordt:
- In mensentaal: als de drukknop wordt ingeschakeld, moet de LED ingeschakeld worden. Klik op de knop Opslaan om het script op te slaan.
- Druk op de drukknop om het script te testen (afhankelijk van de begintoestand van de drukknop, moet je soms een tweede keer drukken), de LED moet oplichten.
- Herhaal deze werkwijze om de LED uit te schakelen als de drukknop wordt uitgeschakeld.
- Test de aanpassingen.
- Pas het script LED Aan als volgt aan:
- Dit aanpaste script zorgt dat de LED 10 minuten oplicht en dan automatisch terug wordt uitgeschakeld. Bij het testen is het handiger met 1 minuut vertraging te werken. Al vlug merk je dat je daarna de drukknop tweemaal moet indrukken om de LED te doen oplichten, de drukknop toestand blijft namelijk op Closed staan. Om de LED bij elke omschakeling 10 minuten te laten oplichten, moet je ook het script LED uit aanpassen om de LED 10 minuten te laten oplichten.
- We beginnen met de voorbereidingen in Domoticz:
- Activeer bij Instellingen de pagina Hardware.
- We beginnen met een Tasmota schakelaar door bij de MTTQ Dummy Hardware te klikken op de knop .
Geef de virtuele sensor de Naam
Tasmotaen gebruik als Sensor TypeSchakelaar. - Maak een tweede virtuele sensor voor de I2C temperatuursensor met de Naam
I2C Temperatuuren als TypeTemperatuur. - De laatste viruele sensor die je aanmaakt is voor de 1-Wire temperatuursensor en geef je de Naam
1-Wire Temperatuuren het TypeTemperatuur. - 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.
- Tijd om de sensoren, de Tasmota schakelaar en Domoticz via onze MQTT Broker te koppelen:
- Klik op de webpagina van de Tasmota schakelaar op de knop .
- Indien de knop niet aanwezig is, voer je de volgende bewerkingen uit:
- Daarna op de knop .
- Plaats een vinkje bij de optie MQTT enable.
- Klik op de knop Save en laat de Tasmota schakelaar herstarten.
- 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.
- 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 .
- Om de I2C en 1-Wire temperatuursensor via MQTT aan Domoticz te koppelen, breiden we het script die we voor Home Assistant gebruikten uit.
- We breiden de MQTT scripts voor Home Assistant (zie Gegevens ophalen en doorsturen naar de MQTT server) uit voor Domoticz:
pi@raspberrypi:~ $
En passen het script aan tot:nano bin/mqtt_mcp9808.sh#!/bin/bash
# Stuur mcp9808 data naar de MQTT broker
#
# Domoticz Apparaat Idx waarde
idx=4
while :
do
# 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"
# Temperatuur doorsturen naar Domoticz
mosquitto_pub -h localhost -t domoticz/in -m '{"idx":'$idx',"nvalue":0,"svalue":"'$temp'"}'
sleep 60
doneHerstart het mqtt_mcp9808.sh:
pi@raspberrypi:~ $
En voor de 1-Wire temperatuur sensor:systemctl --user restart mqtt_autostart_@mcp9808.servicepi@raspberrypi:~ $
Passen we het script aan tot:nano bin/mqtt_ds18b20.sh#!/bin/bash
# Stuur ds18b20 data naar de MQTT broker
#
# Domoticz Apparaat Idx waarde
idx=5
# Initialiseer GPIO4
pinctrl set 4 ip pu
sleep 6
while :
do
# De temperatuur ophalen
temp=$(cat /sys/bus/w1/devices/28-*/temperature)
# 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"
# Temperatuur doorsturen naar Domoticz
mosquitto_pub -h localhost -t domoticz/in -m '{"idx":'$idx',"nvalue":0,"svalue":"'$temp'"}'
sleep 60
doneHerstart het mqtt_ds18b20.sh:
pi@raspberrypi:~ $
Bij desystemctl --user restart mqtt_autostart_@ds18b20.servicemosquitto_pubmet het onderwerp (topic)domoticz/inmoet de"idx":5waarde overeenkomen met de Idx bij Apparaten in Domoticz. Meer info kan je vinden op de Domoticz MQTT webpagina. - Na het opslaan zien we de temperaturen na een tijdje in Domoticz verschijnen.
- We breiden de MQTT scripts voor Home Assistant (zie Gegevens ophalen en doorsturen naar de MQTT server) uit voor Domoticz:
- Activeer daarvoor de pagina Schakelaars.
- Domoticz meldt hier de toestand van de schakelaars. Klik in het LED paneel op het picogram met de lamp om de LED aan en terug uit te zetten. Via de -knop kom je te weten wanneer de LED heeft gebrand. Met de knop keer je terug naar de pagina met de lampen.
- Met de knop kan je de werking van de LED aanpassen.
- Met de knop kan je bepalen wanneer de lamp in- en uitgeschakeld wordt (bijvoorbeeld voor tuinverlichting).
- Met de knop kan je meldingen instellen bij het in- of uitschakelen van de LED.
- 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.
- Op dezelfde manier kan je via de pagina Temperatuur de twee temperatuurmetingen op het Dashboard weergeven.
- Na het plaatsen van alle onderdelen op het Dashboard (activeren van de sterren), krijg je het volgende Dashboard:
