Home Control

Home Control System, pagina in opbouw...

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. Helaas, door tijdsgebrek ligt het voornamelijk stil.

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'; 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.

Hoe komen alle gegevens bij elkaar? 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 de mosquitto (open source MQTT message broker) 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, zodat ik ook een makkelijker user interface heb (in plaats van mijn oude en simpele lighttpd web interface). Hetgeheel is wel alleen vanaf mijn lokale netwerk te benaderen, dus minder risico voor 'inbraak'.

Ik heb over de opbouw van het systeem en het netwerk een lezing gehouden op 20 augustus 2013 bij EmSE (Embedded Systems Eindhoven, een lokale hobby-club); hier de 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 'ruggegraat' (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 essentiele 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 geschakelt...

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). Implementeerd 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 gedouched 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 Smart meter (en de temperaturen van bovenstaande toepassingen), kan ik mooi het verband zien tussen bijvoorbeeld temperatuur en energiegebruik.

De toepassingen op de slimme nodes zijn dus 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 afhandeld 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 nodd-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
Geel is elektra,
groen is gas

Langzaam begint er ook een écht home control netwerk te ontstaan. Hierbij wordt niet alles direct door de Raspberry bestuurd, maar heb ik 'lokale intelligentie'; slimme kleine nodes gebaseerd op de AVR ATtiny (zou ook met b.v. Arduino Nano kunnen). 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 plat ligt). Ook hier weer een klein servertje die de afhandelng van de seriële verbinding doet, en via UDP vanaf het hele lokale netwerk commando's kan krijgen.

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. Ook is het geheugen in het brein: de temperatuur wordt hier weer gelogd (en nu en dan centraal opgevraagd).

Oud

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