Raspberry Pi als brein van je smarthome

Docker-containers

De Raspberry Pi is een populair hardwareplatform om zelf een domoticacontroller te bouwen. Naast de hardware, die in de eerste aflevering van deze reeks aan bod kwam, heb je uiteraard ook software nodig. In de tweede aflevering bespraken we een manier met geïntegreerde domoticaplatforms, zoals Home Assistant, Domoticz en openHAB. In dit artikel tonen we een andere manier: zelf domoticasoftware aan elkaar koppelen via gestandaardiseerde protocollen, zoals MQTT en/of een low-codeprogrammeeromgeving als Node-RED. Als je veel van deze domoticaprogramma’s draait, komen Docker-containers ook van pas. In de volgende (en laatste) aflevering gaan we dieper in op de beveiliging van je smarthome.

Docker-containers

Als je geen geïntegreerd domoticaplatform draait, moet je zelf allerlei diensten op je Raspberry Pi installeren. In principe kun je ze gewoon als deb-pakketten in Raspberry Pi OS installeren, maar vaak gaat de ontwikkeling zo snel dat je eerdere releases rechtstreeks van de homepage van het project moet downloaden en installeren.

Op deze manier loop je echter al snel tegen problemen aan. Een typisch scenario is: programma A heeft versie 1 van bibliotheek X nodig en programma B versie 2 van diezelfde bibliotheek. Die zijn niet compatibel en je kunt maar één versie van de bibliotheek tegelijk installeren. Doorgaans is het probleem subtieler en zit je cryptische foutmeldingen door kleine compatibiliteitsproblemen te debuggen. Vaak gaat het ook lang goed, tot je een keer een van de programma’s upgradet en alles in de soep draait. Een betrouwbaardere oplossing is dat je elke domoticadienst in een afzonderlijke Docker-container draait. Daardoor heeft elk programma zijn eigen bibliotheken en datavolume. Zo zitten ze elkaar niet in de weg. Dat is overigens ook hoe de add-ons van Home Assistant werken in Home Assistant OS en Home Assistant Supervised.

De installatie van Docker op Raspberry Pi OS is eenvoudig:

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

Eventueel geef je gebruiker 'pi' toegangsrechten tot Docker, zodat je niet elke Docker-opdracht door 'sudo' moet laten voorafgaan:

sudo usermod pi -aG docker

Reboot daarna met 'reboot'.

Containerbeheer

Hoe meer Docker-containers je draait, hoe onoverzichtelijker het wordt. Met een grafische interface voor containerbeheer zoals Portainer hou je het overzicht. Een andere optie is Docker Compose. Hiermee definieer je al je containers in één yaml-bestand. Containers aanpassen, toevoegen, verwijderen: je doet het dan allemaal in dit ene bestand, doorgaans 'docker-compose.yml' genoemd.

Veel projecten die voor domotica interessant zijn, worden ook als Docker-images verspreid. Vaak staat er in de documentatie zelfs een Docker Compose-configuratiebestand. Wil je bijvoorbeeld de MQTT-broker Mosquitto met Docker Compose draaien, dan ziet het bestand docker-compose.yml er als volgt uit:

version: '3.7' services: mosquitto: image: eclipse-mosquitto container_name: mosquitto restart: always ports: - "1883:1883" volumes: - ./containers/mosquitto/config:/mosquitto/config - ./containers/mosquitto/data:/mosquitto/data - ./containers/mosquitto/log:/mosquitto/log - /etc/localtime:/etc/localtime:ro user: "1000:1000"

Je definieert hierin onder services de container 'mosquitto', waarvan de image 'eclipse-mosquitto' is, dat van Docker Hub wordt gedownload. Je definieert er ook welke poorten naar de host (je Raspberry Pi) worden omgeleid en welke directory’s op je Raspberry Pi worden aangekoppeld op directory’s in je container.

Als je nu andere programma’s wilt toevoegen, voeg je telkens een nieuwe container onder services toe.

Als je voor de volumes van elke container een aparte directory aanmaakt en die allemaal in dezelfde directory (hier ./containers) plaatst, is het eenvoudig om een back-up van alle data te maken: je maakt dan een back-up van die hele directory. Ook je containers naar een andere machine overplaatsen met behoud van je configuratie en andere data is dan eenvoudig.

Werken met Docker Compose

Docker Compose installeer je als Python-pakket:

sudo apt install python3-pip sudo pip3 install docker-compose

Als je daarna je geconfigureerde containers wilt starten, ga je naar de directory waarin het bestand docker-compose.yml staat en voer je de volgende opdracht uit:

docker-compose up -d

De loguitvoer van de containers krijg je te zien met:

docker-compose logs -f

Al je containers weer afsluiten doe je met:

docker-compose down

Als je nu wijzigingen in je docker-compose.yml aanbrengt, zoals extra diensten toevoegen of versienummers van de images veranderen, worden de containers opnieuw aangemaakt met:

docker-compose up -d.

Bron frontpage-afbeelding en achtergrond: Getty Images/ onurdongel.

MQTT: diensten met elkaar laten communiceren

Naast een uniforme manier om smarthomediensten te draaien, heb je ook een uniforme manier nodig om ze met elkaar te laten communiceren. Een veelgebruikt protocol daarvoor is MQTT: Message Queuing Telemetry Transport, een Oasis-standaard. Centraal bij MQTT staat de broker, een server die alle communicatie regelt. De clients die met die broker zijn verbonden, hoeven elkaar niet te kennen. Ze communiceren via de broker.

Die communicatie verloopt via topics: hiërarchische namen die bestaan uit onderdelen gescheiden door een /, bijvoorbeeld: 'thuis/badkamer/temperatuur'. Een client zoals een temperatuursensor kan data publiceren op dit topic. Een andere client, zoals het dashboard van je domoticasysteem, kan zich inschrijven op dit topic en ontvangt dan telkens als een client op dit topic iets publiceert, van de broker de data.

Voorbeeld van MQTT-prototol zonder QoS

Clients communiceren met elkaar via de MQTT-broker. Bron: Simon A. Eugster, Wikimedia Commons, CC BY-SA 4.0

MQTT-topics kunnen ook wildcards hebben. Als een client bijvoorbeeld data van alle temperatuursensoren in huis wil ontvangen, schrijft die zich in op het topic 'thuis/+/temperatuur'. De + staat voor een willekeurige component in één niveau van het topic. Er is ook de wildcard # die voor een of meer niveaus staat. Wil je bijvoorbeeld alle data ontvangen van topics die met 'thuis' beginnen, dan schrijf je je in op het topic 'thuis/#'.

Er is geen algemeen geldende structuur van topics; ieder project kan zijn eigen structuur opleggen. Wel bestaan er conventies. Zo heeft Home Assistant zijn conventies die MQTT discovery mogelijk maken. Alle apparaten die deze conventies volgen, worden door Home Assistant automatisch ontdekt als ze met dezelfde MQTT-broker verbonden zijn. Een andere conventie is Homie, dat als structuur voor het topic 'homie/device/node/property' oplegt. Op de website van Homie vind je een lijst met apparaten en controllers die de Homie-conventie implementeren.

Mosquitto

De bekendste MQTT-broker is Mosquitto, een project van de Eclipse Foundation dat wordt gesponsord door Cedalo. Je kunt deze broker op diverse manieren installeren. Draai je al Home Assistant, dan is het eenvoudigste om daarin de add-on Mosquitto te installeren. Je kunt Mosquitto ook in Raspberry Pi OS installeren met de pakketbeheerder apt, maar een andere optie is via Docker. Het Docker Compose-bestand daarvoor zag je eerder al.

Dan hoef je alleen nog maar de broker te configureren met een bestand mosquitto.conf in de directory './containers/mosquitto/config'. Een eenvoudige configuratie zonder encryptie en zonder gebruikersbeheer ziet er als volgt uit:

listener 1883 persistence true persistence_location /mosquitto/data/ log_dest file /mosquitto/log/mosquitto.log allow_anonymous true

De laatste regel is sinds Mosquitto 2.0 verplicht als je verbindingen zonder gebruikersnaam en wachtwoord wilt toelaten. Let dus op als je naar voorbeeldconfiguraties zoekt; de configuraties die in oudere bronnen van vóór Mosquitto 2.0 worden vermeld, bevatten deze regel doorgaans niet. Het gaat hier dus om een eenvoudige configuratie zonder authenticatie. Zoals gezegd gaan we in een volgend artikel dieper in op de beveiliging van je smarthome met de Raspberry Pi als centraal onderdeel.

MQTT-boodschappen bekijken

Om te testen of je MQTT-opstelling werkt, kun je diverse commandline- of grafische MQTT-clients gebruiken. Zo kun je op je Raspberry Pi zelf het pakket 'mosquitto-clients' installeren, waarna je de beschikking hebt tot de opdrachten 'mosquitto_sub' en 'mosquitto_pub'.

Met mosquitto_sub schrijf je je in op een topic, waarna de opdracht alle binnenkomende boodschappen op dat topic toont:

mosquitto_sub -t 'thuis/+/temperatuur' -v

Met de optie '-v' wordt vóór de boodschap ook het topic getoond. Je kunt deze opdracht ook op een andere Linux-computer uitvoeren, maar dan moet je met '-h HOSTNAME' verwijzen naar de hostname van de MQTT-broker.

Boodschappen publiceren op een topic doe je met 'mosquitto_pub':

mosquitto_pub -t 'thuis/slaapkamer/temperatuur' -m '21.5'

Uiteraard bestaan er ook grafische MQTT-clients, die je dan op je pc uitvoert. Twee populaire zijn MQTT.fx en MQTT Explorer. Beide bestaan voor Windows, macOS en Linux. Je kunt er ook zelf MQTT-boodschappen mee versturen.

MQTT Explorer

Met MQTT Explorer bekijk je eenvoudig alle boodschappen die je MQTT-broker verwerkt.

Bt-mqtt-gateway

Er bestaan heel wat apparaten die via bluetooth low energy aan te sturen of uit te lezen zijn. Bijna altijd worden deze producten geleverd met een mobiele app, maar met de juiste software kun je ze vaak ook met je Raspberry Pi koppelen. Een voorbeeld van dergelijke software is bt-mqtt-gateway, dat onder andere de slimme thermostaat eQ-3 ondersteunt, de Xiaomi Mi Scale, de Linak Desk, de plantensensor Xiaomi Mi Flora en tandenborstels van Oral-B. Het project biedt ook een Docker Compose-bestand aan. Merk op dat de container het hostnetwerk moet gebruiken en extra rechten 'NET_ADMIN' en 'NET_RAW' nodig heeft voor toegang tot de bluetoothadapter. Het configuratiebestand van bt-mqtt-gateway zelf moet je aanpassen aan de bluetoothapparaten die je gebruikt. De repository bevat een voorbeeldconfiguratiebestand waarin alle ondersteunde apparaten staan. Verwijder gewoon de apparaten die je niet hebt.

Als je daarna de container met bt-mqtt-gateway start, pikt die sensordata op via bluetooth en stuurt deze door naar je MQTT-broker, op topics als 'bt-mqtt-gateway/ruuvitag/slaapkamer/temperature'.

Sensoren uitlezen met rtl_433

Een goedkope oplossing om allerlei draadloze sensoren uit te lezen die op een frequentie van 433,92MHz uitzenden, is de combinatie van een RTL-SDR-transceiver en de software rtl_433. Daarmee lees je allerlei temperatuur- en weersensoren uit en publiceer je hun waarden op topics van je MQTT-broker. Het project biedt zelf geen Docker-image aan, maar verwijst naar de image hertzg/rtl_433 op Docker Hub.

Op de GitHub-pagina vind je een Docker Compose-bestand. De configuratie wordt uitgelegd in het bestand rtl_433.example.conf. Je kunt dit bestand kopiëren, aanpassen en in de container koppelen aan '/etc/rtl_433/rtl_433.conf' of je kunt de instellingen als commandlineopties toevoegen in het Docker Compose-bestand, zoals op de GitHub-pagina van de Docker-image wordt gedaan. Het belangrijkste is de optie '-Fmqtt://mosquitto:1883,retain=1', waarmee je de uitvoer naar de MQTT-broker met hostname 'mosquitto' (als de container waarin Mosquitto draait zo heet) en poort 1883 laat gaan.

Je moet ook nog je Docker-container toegang geven tot de USB-bus om de RTL-SDR te kunnen inlezen. Sluit de RTL-SDR aan en bekijk de uitvoer van lsusb. Je ziet dan iets als het volgende voor de RTL-SDR-stick:

Bus 001 Device 004: ID 0bda:2838 Realtek Semiconductor Corp. RTL2838 DVB-T

Dit is dus apparaat 4 op bus 1. Je geeft dan je Docker-container toegang door in het Docker Compose-bestand bij devices het apparaat '/dev/bus/usb/001/004' te zetten.

Geef dan de gebruiker pi nog de juiste permissies tot het USB-apparaat:

echo 'SUBSYSTEM=="usb", ATTRS{idVendor}=="0bda", ATTRS{idProduct}=="2838", OWNER="pi", MODE="0660"'|sudo tee /etc/udev/rules.d/20.rtl-sdr.rules

Vul hier het vendor-ID en product-ID in dat je in de uitvoer van lsusb zag. Herlaad de udev-regels nu:

sudo udevadm control --reload-rules

Haal tot slot je RTL-SDR uit de USB-poort en steek die er terug in. Als je nu de container start, zie je allerlei sensordata binnenkomen op je MQTT-broker onder het topic 'rtl_433'. Vaak zijn het ook sensoren van je buren of bandenspanningsmeters van auto’s in de buurt, omdat de signalen op 433MHz ver reiken.

Zigbee2MQTT

Voor Zigbee is Zigbee2MQTT een populair project. Het ondersteunt talloze Zigbee-transceivers en meer dan 1700 app araten van bijna 250 fabrikanten. De gemakkelijkste manier om Zigbee2MQTT te gebruiken, is samen met 'Zigbee2MqttAssistant', dat een webinterface voor het project aanbiedt. Beide projecten hebben een officiële Docker-image. De documentatie van Zigbee2MQTT toont je een Docker Compose-bestand. Het aankoppelen van '/run/udev' en de 'privileged' modus zijn alleen nodig om de juiste poort van de transceiver automatisch te detecteren.

Gebruik van het netwerk van de host is ook niet nodig als de container van Mosquitto zich in hetzelfde Docker-netwerk bevindt als Zigbee2MQTT. In de repository van Zigbee2MqttAssistant vind je ook een voorbeeld van een Docker Compose-bestand. Je vult daar de hostname van de MQTT-broker in de omgevingsvariabele 'Z2MA_SETTINGS__MQTTSERVER' in. Dat is de enige benodigde configuratie; Zigbee2MqttAssistant communiceert uitsluitend via MQTT met Zigbee2MQTT.

De configuratie van Zigbee2MQTT gebeurt in een bestand 'configuration.yaml'. Het gemakkelijkste is dat je gewoon de container start met 'docker-compose up -d' en dan weer stopt met 'docker-compose stop zigbee2mqtt'. Zigbee2MQTT maakt immers bij de eerste start van de container het configuratiebestand aan. Daarna kun je dit op de host aanpassen. Het bestand heeft talloze configuratieopties, maar de belangrijkste vind je vooraan voor de MQTT-broker. Voeg in de sectie 'advanced' het best 'network_key: Generate' toe om te voorkomen dat je de standaardsleutel gebruikt voor de encryptie van het Zigbee-netwerk. Na het aanpassen van de configuratie start je de container weer met:

docker-compose start zigbee2mqtt

Surf nu naar het IP-adres van Zigbee2MqttAssistant op http://IP:8880 met het IP-adres van je Raspberry Pi. Zie je de melding 'Devices are currently allowed to join network', dan kun je je Zigbee-apparaten koppelen. Hoe dat gebeurt, hangt af van het product. In de documentatie van Zigbee2MQTT over het specifieke apparaat vind je doorgaans de instructies. Daarna verschijnt het apparaat in de lijst en zul je ook MQTT-boodschappen zien verschijnen. De structuur van de topics en boodschappen is uitgebreid gedocumenteerd.

zigbee2mqttassistant

Zigbee2MqttAssistant biedt een grafische interface voor Zigbee2MQTT.

Node-RED: nodes verbinden in een flow

Uiteraard heb je nog meer van dit soort projecten die een specifiek type smarthomeapparaten met MQTT koppelen, maar we kunnen ze in dit artikel niet allemaal behandelen. Uiteindelijk versturen dan al je apparaten boodschappen naar MQTT-topics en kun je zelf ook je apparaten aansturen door boodschappen naar MQTT-topics te sturen. Maar hoe automatiseer je dat nu? Een handig project daarvoor is Node-RED, dat je ook als Docker-container op je Raspberry Pi kunt draaien. In de documentatie vind je een Docker Compose-bestand, maar het kan al eenvoudiger met:

services: node-red: image: nodered/node-red container_name: node-red restart: always volumes: - ./containers/node-red:/data - /etc/localtime:/etc/localtime:ro ports: - "1880:1880"

Nadat je de container hebt gestart, is de webinterface van Node-RED beschikbaar op http://IP:1880.

Node-RED is een low-codeprogrammeeromgeving waarmee je allerlei api’s en diensten aan elkaar koppelt. Je schrijft geen code, maar verbindt ‘nodes’ in een ‘flow’. In de zijbalk links vind je alle beschikbare nodes, waarvan er standaard al veel zijn.

MQTT-nodes

Zo vind je onder 'network' de node 'mqtt in', waarmee je op een MQTT-topic inschrijft en de binnenkomende boodschappen verwerkt. Als je zo’n node naar je canvas versleept en de eigenschappen ervan bewerkt, klik dan bij 'Server' naast de optie 'Add new mqtt-broker…' op het potlood. Hier vul je de hostname en andere verbindingsparameters van je MQTT-broker in. Zodra de brokerconfiguratie is toegevoegd, kun je in de eigenschappen van de node het topic invullen waarnaar deze node luistert.

Op dezelfde manier kun je een node 'mqtt out' toevoegen, die zijn invoer als boodschap naar een ingesteld MQTT-topic stuurt. Zo kun je ook opdrachten naar smarthomeapparaten sturen via MQTT en zaken automatiseren.

node-red-mqtt

In Node-RED lees je eenvoudig MQTT-boodschappen in.

MQTT-dashboard

Node-RED is ook handig om een eenvoudig dashboard voor je apparaten te maken. Daarvoor moet je eerst de extra node node-red-dashboard installeren vanuit het hamburgermenu en dan 'Manage palette'. Je maakt dan een mqtt in-node aan die naar een topic als 'bt-mqtt-gateway/ruuvitag/slaapkamer/temperature' verwijst, en aan die node koppel je bijvoorbeeld een node 'gauge' uit de collectie 'dashboard'. In de eigenschappen van het metertje voeg je dan een dashboardgroep toe, die verschillende dashboardwidgets groepeert, en een tab.

Je kunt allerlei instellingen van de gaugenode aanpassen, zoals label, eenheden, bereik en kleurgradiënt. Nadat je zo allerlei gauges hebt toegevoegd, klik je op 'Deploy' bovenaan in Node-RED en krijg je je dashboard te zien op http://IP:1880/ui/. De metertjes in het dashboard worden continu bijgewerkt met de nieuwste sensorwaardes die via MQTT worden ontvangen.

Noder-RED dashboard

Een eenvoudig dashboard voor je MQTT-boodschappen is in Node-RED snel gemaakt.

Conclusie

Door allerlei domoticadiensten in Docker-containers te draaien op een Raspberry Pi, houd je het beheer ervan eenvoudig en flexibel, en zitten ze elkaar niet in de weg. Laat je ze allemaal via MQTT met elkaar communiceren, dan heb je ook één protocol om je apparaten op dezelfde manier aan te spreken. Bovendien hoeven al die diensten niet op dezelfde Raspberry Pi te draaien, zolang ze maar via dezelfde MQTT-broker communiceren.

Voor een dashboard en automatisering moet je dan wel zelf nog al die systemen aan elkaar knopen. Node-RED is daarvoor een krachtige oplossing. Dat is wat meer werk dan bij een geïntegreerd systeem als Home Assistant, maar je hebt wel meer flexibiliteit. In het volgende en laatste artikel van deze reeks gaan we in op de beveiliging van je smarthome.