Home Control

De opzet

Er is natuurlijk al van alles te krijgen om je huis te automatiseren (Home Control, ofwel 'Domotica'). Maar, vaak duur, lastig op te zetten, en niet altijd energiezuinig (bovendien, 1 Watt continue kost ongeveer €2.50, een 100 Watt PC in de gangkast kost dus zo'n €250 per jaar aan stroom). En, zelf doen is veel leuker... Vandaar dat ik zelf wat aan het hobbyen ben geslagen, gebaseerd op een energiezuinige Raspberry (3).

Langzaam begint er toch een echt home control netwerkje te ontstaan, voor de meer nuttige taken. Hierbij wordt niet alles direct door het centrale brein (de Raspberry) bestuurd, maar heb ik 'lokale intelligentie'; bijvoorbeeld slimme kleine nodes gebaseerd op de AVR ATtiny. Deze hangen dan via een 3-draads seriële bus aan de Raspberry (Ethernet is veel te 'zwaar' voor dit doel). Je kan het het best vergelijken met hoe een lichaam werkt: de Raspberry is het centrale brein, maar een heleboel taken worden lokaal door reflexen afgehandeld, en de zintuigen zijn daarmee verbonden. Voordeel is dat deze reflexen doorlopen ook als het brein tijdelijk met iets anders bezig is, of om wat voor reden dan ook plat ligt...

Een voorbeeld hiervan is de afzuiging in de douche: een ATtiny is een lokale node, met daarop als zintuig een I2C temperatuursensor aan de warmwatertoevoer (handiger dan via de lamp). Als er gedoucht wordt wordt de leiding warm, en schakelt de ATtiny zelfstandig de afzuiger aan via een solid state schakelaar: de reflexreactie van de ATtiny. De ATtiny regelt ook de nalooptijd: hoe lang moet de ventilator doorlopen als er gestopt is met douchen. Maar, dit alles wordt ook doorgegeven aan het brein, en dat kan bijvoorbeeld besluiten de reflex te onderdrukken, of de nalooptijd aan te passen afhankelijk van de tijd of het seizoen. Ook is het geheugen in het centrale brein: de temperatuur wordt hier gelogd en via een lokale webserver leesbaar gemaakt.

Daarnaast heb ik ook WiFi nodes, bijvoorbeeld gebaseerd op de ESP8266 processor, als te vinden in de 220V-schakelaars van Sonoff, en in veel kleine hobby-printjes. Deze hangen in het draadloze netwerk van mijn huis. Nadeel is dat dit wel minder energie-zuinig is, voordeel is dat er geen netwerkkabeltje naar toe hoeft te lopen. Ideaal bijvoorbeeld voor de tijdschakelaar van de kerstboom.

Home Control: MQTT data uitwisseling
MQTT op de Raspberry, als hart van de besturing en data-uitwisseling

Hoe komen alle gegevens bij elkaar (en dan bedoel ik niet 'via de draadjes')? Dit kan het handigst via een 'data broker', waar sensoren de gegevens kunnen publiceren, en toepassingen zich op gegevens kunnen abonneren. De distributie wordt dan automatisch via de broker gedaan. Ik gebruik hiervoor MQTT, en wel de mosquitto (open source MQTT message broker) MQTT server. mosquitto implementeerd het standaard "Message Queuing Telemetry Transport" protocol, dat door veel systemen ondersteund wordt. Zie voor installatie bijvoorbeeld de Youtube MQTT basics video.

Er zijn ook bijvoorbeeld Android app's om de data te bekijken/te wijzigen (bijvoorbeeld MQTT Dash), zodat ik ook een makkelijke user interface heb (in plaats van mijn oude en simpele lighttpd web interface). Het geheel is alleen vanaf mijn lokale netwerk te benaderen (tenzij ik op afstand inlog op mijn VPN), dus minder risico voor 'inbraak'. Meer info: zie mijn MQTT op de Raspberry pagina.

Ik heb een tijd geleden een lezing gehouden over de opbouw van het systeem en het netwerk, op 20 augustus 2013 bij EmSE (Embedded Systems Eindhoven, een lokale hobby-club); hier de (nu verouderd, want alleen over het bedrade gedeelte) Home Control presentatie (pdf).

De 'brains'

De intelligentie van het systeem wordt geregeld door een Raspberry Pi. Deze zit via Ethernet ook aan het internet, en vormt zo ook de link naar de buitenwereld. Bovendien staat deze toch al aan, omdat er ook allerlei andere services op draaien, zoals de file server en de SSH toegang, en hier van belang: de MQTT server (data broker). De Raspberry zorgt voor gedetaileerde besturing, data logging, het maken van grafiekjes, en zo voort.

De 'ruggengraat' (netwerk)

Het netwerk wordt gevormd door een seriële bus op 9600 bits per seconde. Traag, maar kan wel grote afstanden overbruggen. Aan de kant van de Raspberry is deze optisch gekoppeld, zodat een stoorpiek (b.v. door blikseminslag in de buurt) niet ook de Raspberry opblaast. In principe kan de bus (en de optische koppeling) hogere snelheden aan, maar dat is tot nu toe niet nodig.

De bus bestaat uit drie draden; een voor 'aarde', een voor de +5 Volt voeding, en een voor de communicatie (zogeheten multi-drop/wired-or: alle nodes hangen voor zowel lezen als schrijven aan dezelfde lijn). Er gaat een simpel protocol overheen, waarbij de Raspberry als master een commando verstuurd, en de geaddresseerde node een antwoord geeft, beiden volgens het onderstaande formaat:

<1:type,len><1:address><N:message><1:checkbyte>

Er zijn ook 'broadcast commando's die naar alle nodes gaan, zoals eens per dag een tijdscommando om alle klokken weer gelijk te laten lopen.

De reflexen

Naast de centrale intelligentie zijn er de 'slimme' nodes gebaseerd op de AVR ATtiny, direct aangesloten op het seriële netwerk. Zou ook via een optische koppeling kunnen, maar ach, ze zijn zo goedkoop. Ze hebben een beetje gevoel voor tijd, en doen de simpele klusjes. Wel zijn dit vaak essentiële taken, dus op deATtiny is ook veel foutcontrole toegepast, zoals een 'watchdog timer' die de zaak automatisch reset als de processor door een stoorpiek op tilt gaat. Ja, dat gebeurt echt nu en dan, en je wilt niet dat dan bijvoorbeeld de afzuiger maar door blijft gaan (of niet aan gaat). Gebeurt uiteraard niet heel vaak, maar als iets 24 uur per dag aanstaat, en er wordt een 220V motor in de buurt geschakeld...

Maar, daarnaast ook WiFi nodes, zie hier onderaan bij implementatie. Handig voor verplaatsbare apparaten, of als er geen home control bus in de buurt is. Wel meer stroomgebruik vergeleken met de ATtiny modules.

De zintuigen

En aan de nodes zitten de 'zintuigen', meestal via I²C. Dit zijn bijvoorbeeld de LM75 I²C temperatuursensoren zoals al beschreven op mijn Raspberry hardware pagina. Ook zitten hier de 'spieren', actuatoren, aan die het resultaat weer naar de buitenwereld teruggeven. Een voorbeeld is het solid state relais om de afzuiging aan te schakelen (ook optisch gescheiden, je wilt geen 220 Volt op je netwerk).

De User Interface

Nu nog de mosquitto (open source MQTT message broker/server) er op, zodat ik ook een makkelijker user interface heb (op dit moment is het een simpele lighttpd web interface). Implementeert het standaard "Message Queuing Telemetry Transport" protocol, dat door veel systemen ondersteund wordt.

Toepassingen

Als voorbeeld van enkele toepassingen die al draaien:

  • Badkamerafzuiging: via een I2C temperatuursensor op de warmwaterleiding wordt gezien dat er gedoucht wordt, en wordt de afzuiger aangezet. Via een timer in software draait deze nog een instelbare tijd door na het douchen. Loopt volledig autonoom, maar de Raspberry kan wel de uitlooptijd instellen en de temperaturen monitoren.
  • C.V. pomp van de vloerverwarming: hier heb ik de 'domme' pomp (draaide altijd) vervangen door een slimme node, met temperatuursensoren op de aan- en afvoer-leidingen. Een slim algoritme zet aan de hand van de temperaturen (via een optisch gekoppeld solid state relais) de pomp aan. Ook zorgt deze er voor dat de pomp elke dag in ieder geval even draait zodat deze niet vast gaat zitten, ook als er die dag geen warmtevraag was (zet dan de pomp even 10 minuten aan). Ook weer autonoom, maar de Raspberry kan de zaak in de gaten houden en bijregelen.
  • Logging van de 'slimme' elektriciteitsmeter (en de temperaturen van bovenstaande toepassingen), kan ik mooi het verband zien tussen bijvoorbeeld temperatuur en energiegebruik.
  • De luchtkwaliteitsmeting, met de CO2 sensor, luchtvochtigheidssensor, en display
  • WiFi nodes, zoals de kerstboom-timer en mijn IoT-lampje.

De toepassingen op de slimme nodes zijn vrij autonoom: als de Raspberry om wat voor reden zou crashen, gaat bijvoorbeeld de vloerverwarming gewoon door, hoogstens wat minder slim (en de logging op de Raspberry stopt).

De implementatie

De nodes - ATtiny

Op de nodes loopt een simpele interrupt-gestuurde communicatiestack, die de seriële berichten opvangt en verstuurd. In het hoofdprogramma draait een vaste tijdsgesynchroniseerde programmalus, die de binnenkomende taken afhandelt en de resultaten weer terugstuurt, en ook de verdere administratie doet (zoals het gerust stellen van de watchdog). Onderstaande tekst moet nog verder worden uitgewerkt...

'Kernel' interrupt gestuurd voor korte taken, met als belangrijkste 3 interrupts (watchdog doet geen interrupt, maar een echte reset):

  • Serial Rx interrupt
    • Wake-up processor bij compleet bericht
    • Filtering op adres al in interrupt (state machine)
  • Serial Tx interrupt
    • Verstuurt reply-message
  • Timer interrupt (1 kHz)
    • Real-time clock (½ Hz), time-outs

Free running main program control loop

  • Taakafhandeling uit binnenkomende berichten
  • I2C afhandeling indien nodig
  • Foutcontrole en nood-acties (b.v. bij kapotte sensor: motor laten draaien)
  • Slapen als er niets te doen is (wake-up @ irq)

Complete framework in 'C' (lege app) ~ 1 kByte Flash; maar een typisch systeem met applicatie heeft het 2 kByte programmageheugen haast helemaal vol...

De nodes - Sonoff en Wimos

Voor het slimmere werk, of als er geen kabeltje in de buurt is, gebruik ik de WiFi-gebaseerde WEMOS D1 mini en Sonoff modules, beiden gebaseerd op de ESP8266 WiFi chips. Gekoppeld aan de MQTT server op de Raspberry is hiermee ook van alles te besturen en te meten. De Sonoff is vergelijkbaar met de Wimos, maar zit in een mooi doosje met voeding en 220V relais, dus als het ware een slimme schakelaar.

Meten is Weten

Gasgebruik als functie van de buitentemperatuur
Rode lijnen met de hand er in gezet: daalt de temperatuur
buiten overdag onder de 18° dan gaat de kachel blijkbaar aan...

Een voorbeeld daarvan is het uitlezen van de 'slimme energiemeter', zodat je je energiegebruik goed in de gaten kunt houden. Je kan dit natuurlijk 'uitbesteden', maar ik wil eigenlijk niet dat anderen mij in de gaten kunnen houden. Bovendien is zelf doen leuker en leerzamer. Ik heb mijn slimme energiemeter met zijn P1-poort via een serieel-naar-USB kabeltje aangesloten op de Raspberry. Daar komt nu elke 10 seconden een datagram volgens de DSMR (Dutch Smart Meter Requirements) 4.2 standaard met de gebruiksgegevens van elektra en gas binnen [hier een overzicht voor diverse smart meters, onderaan pagina]. Op de Raspberry loopt een klein 'servertje', die deze gegevens opvangt. Via UDP kan nu elke computer op mijn netwerk dit weer opvragen. Op dezelfde Raspberry loopt ook mijn logging, zodat ik 'mooie' overzichten krijg, geeft best inzicht in waar je elektriciteit en gas blijft.

Gas Water Elektra 2017
Energiegebruik

Zo is op het grafiekje rechts het energiegebruik van 2017 per naamd te zien.

  • De groene lijn is het gasgebruik, in de winter duidelijk hoger dan in de zomer. Maar, in de zomer toch niet helemaal 0: we koken op gas, en voor de douche is warm water nodig: ook gas. Toch, het is duidelijk dat het meeste op gaat aan de verwarming, dit is waar werkelijk het gasgebruik zit.
  • De gele lijn is de elektra, en deze gaat in de zomer onder de nul door: we hebben zonnepanelen, en in die periode leveren we terug aan het net, 'de meter loopt de andere kant op' (al hebben wij geen mechanische meter meer). Het meergebruik in de winter is ongeveer gelijk aan de overproductie in de zomer: eind van het jaar staat de meter ongeveer op nul.

Zo kan je goed je energiegebruik zien, en aanpassen. In de grafiek per dag is te zien dat het huis al vrij zuinig is qua elektra: nachtgebruik is duidelijk onder de 100 Watt per uur, mooi laag. In de jaargrafieken (niet op deze pagina) is te zien dat de energiebesparende stappen van de laatste 6 jaar (sinds we in het huis zijn getrokken) helpen, elk jaar is het gasgebruik een beetje lager. Of ligt dat gewoon aan de globale opwarming, de winters steeds minder koud?

Ping

Een van de taken van mijn home server is ook home control en automation (domotica). Maar, voor je wilt controleren: meten is weten... Vandaar mijn interesse om ook bijvoorbeeld I²C sensoren (als een temperatuursensor in de huiskamer) aan te kunnen sluiten, zie mijn Raspberry Pi hardware pagina. Een simpel voorbeeld van meten: hoe vaak en lang staat mijn PC eigenlijk aan? En mijn TV (met internet)? Geen sensoren voor nodig; je kan dit gewoon met het ping-commando: als je een antwoord terug krijgt (in $?, 0=OK) staat het apparaat aan. Ik test dit een keer per 10 minuten in een script, en schrijf de resultaten naar file. Een simpele variant van dat script, dat ik start met sudo nice bash -c '/home/kees/scripts/TraceTV.sh > /tmp/TraceTV.log' & (let op: '0' is aan):

#!/bin/bash
while true; do
    # Only try once, with a one-second timeout; approx every 10 minutes
    ping -c 1 -W 1 192.168.1.143 >/dev/null
    echo "$?"
    sleep 600
done