Tutorials met tips en trucs om een compleet Home Automation project in OpenHAB op te zetten.

Aan de slag met OpenHAB 2: RFXCom en MiLight

Door GENETX op woensdag 27 april 2016 11:28 - Reacties (12)
Categorie: Home Automation met OpenHAB, Views: 8.957

Een hele hele lange tijd geleden begon ik eens te stoeien met domotica, en wel met het OpenHAB platform. Later begon ik ook eens aan een blogje daarvoor, maar verder dan deze opening kwam ik niet... Onlangs ben ik overgestapt op de tweede beta van OpenHAB 2.0, iets dat goed werkt. Met een opgeschoonde config vond ik het tijd om het blog maar weer eens op te pakken! Dus hierbij, een eerste tutorial over hoe je aan de slag kan met OpenHAB 2!

OpenHAB 2, what's new?

OpenHAB 2.0 verschilt relatief weinig van OpenHAB 1.0. De structuur is in grote lijnen hetzelfde, oude rules werken nog, sitemaps zijn hetzelfde en er wordt nog steeds mooi modulair gewerkt met bindings! Wat is er dan wel nieuw? Met name een nieuwe, moderne, interface en de mogelijkheid om met 2.0-bindings ook apparatuur te detecteren. Uiteindelijk zal alles via een UI kunnen, maar deze die-hard tweaker blijft toch grotendeels bij het aanpassen van configs middels tekstbestanden ;)

OpenHAB, what's different

Alvorens we beginnen met het installeren en configureren van OpenHAB wil ik nog even kort stilstaan bij het OpenHAB platform en wat het anders maakt dan bijvoorbeeld Domoticz. Er zit een filosofie achter dat het platform erg flexibel maakt, maar daarmee de learning curve ook iets ingewikkelder maakt. Als je eenmaal gewend bent, dan zul je het nut inzien en ben je, net als mij, om ;) . OpenHAB werkt met een aantal basis-elementen:

Items: Items zijn (virtuele) schakelaars, dimmers, sensoren, variabelen en dergelijke. Op zichzelf doen ze niets, maar vormen de basis van je setup.
Things: Things zijn de daadwerkelijke apparaten. Een apparaat kan bestaan uit meerdere things, zoals meerdere losse sensoren of schakelaars. De individuele things kun je koppelen aan je virtuele items. Daarmee is het later makkelijk om een apparaat (thing) in je huis te vervangen zonder de rest aan te moeten passen.
Sitemaps: Uiteraard heb je ook een interface nodig om je huis te bedienen. Dit doe je met een sitemap, waar je items aan toe kan voegen. Sitemaps kun je helemaal naar wens aanmaken en je hoeft niet alle items toe te voegen. Dat stelt je in staat om een simpele en cleane interface te maken. Je kan ook meerdere sitemaps aanmaken, wat potentieel een positief effect op de WAF heeft ;)
Rules: Middels rules kun je de boel automatiseren. Hier horen ook de scripts bij die je kan maken. Het handige aan het rule-systeem in OpenHAB is dat het een "sensitivity"-list bevat. Je kan er voor kiezen om rules alleen bij bepaalde veranderingen (zoals een opgaande flank) te triggeren. Het lijkt daarmee een beetje op VHDL voor de kenners, iets wat een uitstekende keuze is vanwege de vele parallelle events die een domoticasysteem kan triggeren. Hier ga ik in dit blog nog niet op in.
Persistence: Middels persistence kun je waarden en updates wegschrijven naar een database. Ook hier ga ik nu niet op in.

Naast configs in tekstbestanden kun je ook via de browser alles configureren en is er ook een blocky-editor voor als je niet zo sterk bent in code. Daarvoor heb je HABMin nodig: https://github.com/cdjackson/HABmin2 .

Setup

In deze blog zal ik je helpen bij het opzetten van communicatie met een RFXCom en MiLight lampen, maar voor we starten moeten we natuurlijk een installatie hebben. Download de OpenHAB 2.0b2 Online Distro van de OpenHAB website: http://www.openhab.org/getting-started/downloads.html . Pak de bestanden uit en start het programma vanaf een commandline met start.sh (of .bat, al heb ik enkel met de Linux variant ervaring). De eerste keer zal OpenHAB nog heel wat moeten downloaden, maar na een tijdje zou je http://localhost:8080 moeten kunnen openen.

http://static.tweakers.net/ext/f/98LsJVvYwgQVQ2MXbN5TZmRw/full.png

Je krijgt dan 4 opties voor je neus geschoteld: De Paper UI, Basic UI, Classic UI en REST API. Wij gaan aan de slag met de eerste 2 opties. Als je op Basic UI klikt zou je een demo te zien moeten krijgen (dat is de demo.sitemap). De Basic UI laat je dus de sitemaps zien. De Paper UI is er voor de configuratie in de browser. Mooi, alles werkt, dus kunnen we aan de slag!

Opbouwen van de items

We beginnen in deze blog met het koppelen van een schakelaar middels de RFXCom en een MiLight RGBWW-lamp. Daarvoor zullen we eerst een aantal items aan moeten maken die we later gaan koppelen aan de fysieke apparaten.

De schakelaar zal van het Switch-type zijn en de MiLight lamp is opgebouwd uit een Color-item, een Switch-item (om hem naar white-mode te kunnen resetten) en een Number-item (die laatste kunnen we aan een slider koppelen). Maak een bestand met de naam "verlichting.items" aan in de conf/items/-map. De inhoud is als volgt:

code:
1
2
3
4
5
6
7
Group   LIGHT   (All)

Switch  Lamp_RFXCom         "RFXCom"        <light>         (LIGHT) 

Dimmer  Lamp_MiLight        "MiLight"       <slider>        (LIGHT)     
Switch  Lamp_MiLight_White  "MiLight wit"   <light>         (LIGHT)
Color   Lamp_MiLight_Colour "MiLight kleur" <colorwheel>    (LIGHT)



Mogelijk dat het er een beetje cryptisch uitziet, maar dat is gewenning. Ik zal vandaag niet ingaan op de Groups (al zijn ze wel erg handig, dus heb ze alvast toegevoegd). De opbouw van een item is als volgt:

code:
1
Type Identifier "Omschriving voor interface" <icoon> (Groep1, Groep2) { commando's }


Over de commando's verderop meer. De beschikbare icons kun je hier vinden. Meer informatie over beschikbare items staat hier.

Interface maken

Met deze items alleen kunnen we nog niet zo heel veel, Dus laten we ze eerst toevoegen aan een sitemap. Ga naar de conf/sitemaps-map en voeg daar "example.sitemap" toe. Deze gaan we vullen met de zojuist gemaaktde items:

code:
1
2
3
4
5
6
7
8
9
sitemap example label="Huis"
{   
    Frame label="Verlichting" {
        Switch item=Lamp_RFXCom
        Slider item=Lamp_MiLight
        Switch item=Lamp_MiLight_White mappings=[ON=RESET]
        Colorpicker item=Lamp_MiLight_Colour
    }
}


Zie hier hoe alle zojuist aangemaakte items terugkomen in een frame. Binnen een sitemap het ook mogelijk om icons, labels en opties te overschrijven. Meer informatie over beschikbare controls en trucs kun je hier vinden.

Je kan het zo complex maken met meerdere lagen (zie maar eens in mijn code, link staat onderaan). Wat ook belangrijk is is de eerste regel. We definiŽren dus een sitemap met de naam "example". Die laatste hoeft niet identiek te zijn aan de bestandsnaam, maar aangeraden wordt het wel. Hoe dan ook, dit hebben we nodig om de pagina te openen. Standaard gaat de basic UI namelijk naar de demo sitemap die met OpenHAB werd geÔnstalleerd. De zojuist aangemaakte sitemap kun je vinden op:
http://localhost:8080/basicui/app?sitemap=example

Dan zou je dit te zien moeten krijgen:
http://static.tweakers.net/ext/f/LY7YUl82nbTTXeTN36zVdC3C/full.png

We kunnen echter de eigen sitemap ook als default instellen zodat je deze altijd krijgt als je op Basic UI klikt. Ga daarvoor naar http://localhost:8080 en kies voor de Paper UI. Ga naar Configuration -> Services. Klik vervolgens op "configure" bij Basic UI en type "example" bij de default sitemap. Klik op save en nu zou de knop Basic UI je direct naar de zojuist gemaakte sitemap moeten leiden.

De RFXCom toevoegen

Nu de basis staat, is het tijd om het eerste apparaat te koppelen, namelijk de RFXCom. Daarvoor hebben we eerst de RFXCom binding nodig. Ga daarvoor naar de Paper UI -> Extensions -> Bindings en zoek naar RFXCom en druk op Install. Normaliter zou nu alles nu correct moeten staan, ware het niet dat de default RFXCom 2.0 binding nog een fouten bevat. We gaan een nieuwere build nodig hebben. Pak de terminal er bij en voer de volgende commando's door:

code:
1
2
3
4
bundle:stop org.openhab.binding.rfxcom
bundle:uninstall org.openhab.binding.rfxcom
bundle:install https://openhab.ci.cloudbees.com/job/openHAB2-Addons/lastSuccessfulBuild/artifact/addons/binding/org.openhab.binding.rfxcom/target/org.openhab.binding.rfxcom-2.0.0-SNAPSHOT.jar
bundle:start org.openhab.binding.rfxcom



De RFXCom binding is een native 2.0 binding en kun je dus geheel via de Paper UI configureren. Dat geldt ook voor bijvoorbeeld Philips Hue lampen en als je de Network Binding installeert dan zul je ook al snel alle apparaten die in je netwerk hangen zien op basis van het IP-adres.

Dat zelflerende van RFXCom is helaas niet altijd helemaal van toepassing. Zo heb ik een Elro-set thuis (AB400D) waarvan de remote het Lighting4-commando gebruikt, maar de schakelaars reageren op Lighting1-commando's. Hiervoor werkt de zelflerende modus dus niet en moet je handmatig configureren. Daar ga ik verderop op in.

Ik zal eerst door de UI-stappen gaan. Voor alle duidelijkheid, ik ga er vanuit dat je, als je Linux draait, de juiste rechten hebt toegekend zodat je de RFXCom kan benaderen. Daar zijn zat tutorials voor te vinden (of als je lazy bent, draai OpenHAB als root voor nu om te spelen):
UI Based toevoegen van de RFXCom
Note: Deze beschrijving is mogelijk niet helemaal accuraat omdat ik een handgeschreven config gebruik
Stap 1: Ga terug naar de Paper UI en dan Setup Wizard. Klik op de blauwe knop met plus-teken bovenin en kies voor RFXCom. Mogelijk dat de RFXCom Bridge al gedetecteerd is. Klik anders op "Add manually" onderaan de pagina. Klik op de RFXCom USB Tranceiver die je hebt, geef het een naam en druk op de knop met het vinkje.

[bStap 2:[/b] Ga nu naar de Things-sectie in de Paper UI en klik op het zojuist aangemaakte RFXCom "thing" en vervolgens op het potloodje bovenin voor bewerking. Vul de serial port in waar de RFXCom is aangesloten. Voor de meesten zal dat "/dev/ttyUSB0 zijn. Druk weer op het vinkje om te bevestigen.

Stap 3: Ga terug naar de Setup wizard pagina. Hierin komen alle apparaten te staan die gedetecteerd worden. Druk nu op de afstandsbediening knop van de schakelaar die je wilt koppelen. Een nieuw apparaat zou moeten verschijnen. Klik er op en geef het een duidelijke naam. Vervolgens druk je op "add as Thing".

http://static.tweakers.net/ext/f/I37oejJuUAFDdKENT4BrEjrL/full.png

Stap 4: Ga vervolgens weer naar de Things-pagina en zoek het apparaat op. Klik er op zodat we een item aan de fysieke schakelaar kunnen koppelen. Druk op het blauwe rondje bij "Command" en selecteer het Lamp_RFXCom item. Druk op link en klaar ben je. Als het goed is moet je nu je eerste schakelaar via OpenHAB kunnen schakelen. Ga naar de Basic UI en probeer het!

http://static.tweakers.net/ext/f/uZ0OVRe6BHMXRK4Bd5rXhBxc/full.png

Werkt het niet? Wellicht heb je net als mij een Elro setje. Kijk eens naar de guide hieronder, de documentatie van de RFXCom binding, de input die je in Domoticz/RFXCom manager gebruikt, om handmatig de config goed te krijgen. Werkt het niet? Vraag ons in het OpenHAB Topic!
Handmatig toevoegen van de RFXCom
Zoals gezegd, het werkt niet altijd goed... Gelukkig kun je nog meer opties handmatig en met behulp van de binding-documentatie opzetten. Allereerst, de documentatie kun je hier vinden:
https://github.com/openha...rg.openhab.binding.rfxcom

Maar die is, zoals je kan zien, heel spartaans. De 1.x-binding documentatie geeft nog iets meer details en hints. Let wel op dat de 2.0 binding nog veel ondersteuning mist zoals bijvoorbeeld mijn deurbel... Helaas is de 1.x-binding niet compatible met OpenHAB 2.
https://github.com/openhab/openhab/wiki/RFXCOM-Binding

Na wat gepuzzel het gebruiken van de RFXCom manager onder Windows en het doorlezen van de source-code kon ik mijn Elro afstandsbediening aan de praat krijgen. Ik geef alleen de config, omdat we per case beter kunnen uitzoeken hoe het werkt.

De volgende config zet je in conf/things/ onder de naam rfxcom.things.

code:
1
2
3
Bridge rfxcom:bridge:usb0 [ serialPort="/dev/ttyUSB0" ] {
    Thing lighting1 Schakelaar  [ deviceId="L.10", subType="AB400D" ]
}


Uiteraard hangt het Thing af van je apparaat. Let op, je kunt hiermee stap 1 t/m 3 van de beschrijving hierboven overslaan. Enkel het koppelen met een item zoals in stap 4 staat beschreven is nu nog nodig.

MiLight toevoegen

De MiLight-binding is nog wel een pure 1.x-binding en moet dus wel grotendeels handmatig. Allereerst, de documentatie is hier te vinden:
https://github.com/openhab/openhab/wiki/Milight-Binding

De binding toevoegen gaat weer wel via de Paper UI. Ga wederom naar de Extensions-pagina en zoek naar de MiLight-binding en druk op installeren.

De volgende stap is om de config aan te maken in conf/services/. Voorheen (in OpenHAB 1.x) was er ťťn config.cfg bestand, nu zijn het losse configs met de naam van de binding. Er is nog een verschil: Je maakt geen gebruik meer van de binding-naam in de config. Op die punten is OpenHAB 2 anders en daar moet je mee opletten bij het lezen van 1.x-documentatie. Verder wordt er soms een template bestand aangemaakt. Indien "milight.cfg" niet bestaat maak je deze aan. De volgende inhoud moet er in komen:

code:
1
2
milight1.host=192.168.1.6
milight1.port=8899


Uiteraard zelf de juiste poort en IP invullen. Je kan ook meerderer bridges toevoegen, dan herhaal je de code, maar geef je de bridge de naam "milight2" ipv "milight1". Let op, zoals je kan zien is de config dus net iets anders dan de documentatie. Daarin had ik "milight.milight1.host=192.168.1.6" moeten gebruiken. Dit klopt dus voor 2.0!

De volgende stap is om de items te koppelen aan de fysieke lamp. Hiervoor moeten we de items-config aanpassen. Open nog eens conf/items/verlichting.items en pas deze aan door het commando toe te voegen aan de juiste items:

code:
1
2
3
4
5
6
7
Group   LIGHT   (All)

Switch  Lamp_RFXCom         "RFXCom"        <light>         (LIGHT)     

Dimmer  Lamp_MiLight        "MiLight"       <slider>        (LIGHT)     {milight="milight1;7;brightness;27"}    
Switch  Lamp_MiLight_White  "MiLight wit"   <light>         (LIGHT)     {milight="milight1;7;whiteMode"}
Color   Lamp_MiLight_Colour "MiLight kleur" <colorwheel>    (LIGHT)     {milight="milight1;7;rgb"}


Het stuk tussen accolades is de Binding config (zoals je onderaan deze pagina kan lezen). We binden het item dus aan de milight-binding (het stuk "{milight="). Het stuk tussen de quotes is dus de milight-specifieke config. In dit geval koppel ik dus de items aan de bridge "milight1" (zoals in de config), vervolgens aan kanaal 7 (wat dus groep 1 voor RGB-leds is, zie hieronder) en dan het juiste commando. Pas dus met name het kanaal aan op je eigen setup!

Het kanaal hangt af van het type lamp, zoals ook in de documentatie staat:
The channelNumber corresponds to the bulbs/channels on your bridge, where 0 reflects all white bulbs, 1-4 white bulb channels and 5 all rgb bulbs. For the new RGBW bulbs use channel number 6 (all RGBW bulbs), 7-10 (RGBW channels 1 to 4)
Als je alles goed hebt gedaan zou je nu ook de milight-lamp moeten kunnen bedienen!

gouden tips

Nog een belangrijke tip voor debuggen is de log. Hierin kun je zien of alles correct gaat. Tijdens het testen/configureren/spelen is het handig om dus OpenHAB zelf te starten in een terminal. Dan kun je namelijk hetvolgende commando gebruiken om te zien wat OpenHAB aan het doen is:

code:
1
log:tail



Het log sluiten doe je overigens met Ctrl-C. Ctrl-D laat OpenHAB stoppen!

Meer info

Als je nog verder wilt, dan kun je natuurlijk altijd terecht in het OpenHAB Topic en door mijn configs sneupen op https://github.com/GENETX/openhab2 . Daar staan ook nog wat meer 433MHz RFXCom apparaten in. Rest mij enkel nog deze blog af te ronden met een screenshot van mijn huidige interface :P

http://static.tweakers.net/ext/f/nVsQZaCqie3AGCp7LqyUlOa3/medium.png

Domotica met OpenHAB - Proloog

Door GENETX op dinsdag 30 december 2014 13:26 - Reacties (3)
Categorie: Home Automation met OpenHAB, Views: 3.872

Dit is de start van Domoticablog #zoveel. Dat is niet vreemd. Domotica is hip en hot. Zie naar de successen van Homey op kickstarter, een subforum dat binnen no-time geŽxplodeerd is, de irritante reclamespotjes van Gira en geweldige opensource projecten zoals Domoticz en pilight. Talloze blogs over dat alles te vinden, en toch start ook ik er eentje, deze over OpenHAB.

In deze serie blogs ga je lezen hoe je een aantal zaken kan automatiseren. Uiteraard uitgewerkt in OpenHAB, maar de gedachtegang en ideeŽn zijn ook voor anderen met een domoticasysteem mogelijk interessant. Daarbij ondersteund OpenHAB diverse apparaten en domoticaoplossingen. Onder andere RFCOM en pilight worden ondersteund. Het is geschreven in Java en draait daarmee eigenlijk op ieder platform. Apps voor Android en iOS zijn ook beschikbaar.
De eerste stapjes
Een aantal jaar geleden kwam ik al wat in aanraking met domotica tijdens de studie. Wat spelen met een systeem genaamd Echelon en een docent die zijn huis vol had hangen met Plugwise schakelaars. Reuze interessant en ooit zou ook mijn huis er aan moeten geloven.

Nadat ik mijn studentenkamer had ingeruild voor een huisje, zag ik deze zomer een goedkoop setje van 3 Elro AB440 schakelaars in een aanbiedingenbak liggen bij de Mediamarkt. Een impulsaankoop dus. Ja, ik had wat lastig te bereiken lampschakelaars, maar dit was toch ook overkill eigenlijk. Het toppunt van luiheid, of toch niet? Ik had al gelezen over Domoticz en pilight. Met de aanschaf van dat setje was de drang naat het automatiseren niet meer te stoppen. No way back! Het huis zou en moest slim worden :)

De 433MHz transmitter en receiver werden bij CurlyMo, de geestelijke vader van pilight, besteld. De Raspberry Pi werd ontdaan van zijn stof en gereanimeerd. Een eerste prototype werd opgezet en de schakelaar werd bediend met pilight en Pimatic. Over die laatste combinatie was ik echter niet tevreden. De mogelijkheden tot het opstellen van automatiseringsregels was te beperkend voor de regels die ik voor ogen had.
OpenHAB
In mijn zoektocht naar een geavanceerd framework voor domotica stuitte ik op de Open Home Automation Bus, ofwel OpenHAB. Een opensource framework dat onderdeel is van de AllSeen alliantie voor domotica met een solide basis en zeer veel plugins. Het doel van het project is om een open en universeel platform te maken waarin apparatuur van diverse domoticafabrikanten samen komt. Zo heb je geen vendor lock-in. De basis van OpenHAB zit nu ook in het Eclipse Smarthome platform, dat nu ook door andere domoticabouwers wordt gebruikt.

OpenHAB heeft wel als nadeel dat het relatief zwaar is. Ik draai het op mijn servertje en dan gaat het prima. Op een Raspberry Pi is het niet aan te raden. OpenHAB 2 wordt echter lichter en lijkt grotendeels compatible te blijven. Mijn setup draait echter versie nummertje 1.6.1. De scripttaal is een stuk uitgebreider, maar daardoor ook lastiger te leren. Het doel van dit blog is dan ook om voorbeelden te geven om dat nadeel wat te verzachten.

Het grootste voordeel was wel dat sfinx destijds net een plugin had gemaakt om OpenHAB en pilight te koppelen. Dat maakt de keuze nogal makkelijk, want mijn hardware had daarmee geen aanpassing nodig in tegenstelling tot alle andere domotica systemen.
Het huidige systeem
Inmiddels zijn er een aantal maanden verder en is het eerste deel van het systeem in OpenHAB dan ook af. Zo'n hobby stopt en verveelt niet snel, dus het kan altijd mooier en beter. Maar op dit punt heb ik wel iets gemaakt waar ik tevreden over ben en iets dat ik graag met jullie deel via dit blog. De basis van de setup is als volgt:

Ik gebruik nog altijd pilight op de Raspberry Pi om de commando's naar de hardware door te sturen. OpenHAB draait op mijn servertje (1.6GHz ondergeklokte Celeron G1610, 4GB RAM) en bevat alle logica om slimme beslissingen te maken. Middels de OpenHAB pilight binding worden de acties doorgestuurd naar pilight om de schakelaars te schakelen. Aangezien ik nog wat meer sensoren wil toevoegen heb ik tot nu toe slechts een prototype op een breadboard met de 433 transmitter en receiver en een DHT22 temperatuursensor:

Hradware

Wat betreft hardware heb ik op het moment 9 Elro AB440 afstandsbedieningen, een network connected Pioneer VSX-923 receiver, een Honeywell Round Connected thermostaat en Kodi op mijn server. Dit zit, samen met mijn telefoon, computers en tablet in mijn domotica-systeem verwerkt en aan elkaar gekoppeld. De user interface ziet er nu zo uit:

http://tweakers.net/ext/f/4tJQFAHYROJomXfM5nUtIaKe/medium.jpg

http://tweakers.net/ext/f/LBcbch6SBaWBBhiDIJHN18KU/medium.jpg

In de komende blogs leg ik uit hoe je onder andere:

- verlichting automatisch aan laat gaan als de zon onder gaat;
- je kan detecteren of er iemand thuis is, en daarmee standby verbruik kan verlagen;
- Kodi op pauze zet en je receiver op mute als je aan het bellen bent;
- een Honeywell Round Modulation Connected in je domotica opneemt;
- nutteloze remotes hergebruikt om oa Kodi op pauze te zetten;
- een hele interface maakt om meterstanden bij te houden en graaddagen berekend;
- je receiver automatisch aanzet als je muziek of een film start met Kodi;
- en vast nog meer :)

Verder hoeft domotica niet duur te zijn. Een setje van 2 of drie schakelaars heb je al tussen de 10-20 euro (afhankelijk of je ze bij de Action haalt, compatible met pilight). Een pi haal je voor 35 euro en een paar 433MHz voor 12,50 bij pilight. SD kaartje er bij, USB voeding en voor zo'n 75 euro zou je zelf ook kunnen spelen met domotica :)

In het volgende blog zal ik het hebben over de integratie met pilight en de basis om een user interface te maken en schakelaars te schakelen. Voor wie niet kan wachten, meer informatie is beschikbaar in het OpenHAB topic op GoT: Het Grote OpenHAB topic - deel 1. Tevens zijn mijn scripts opensource, dus neem een kijkje op:
https://github.com/GENETX/openhab

Voor wie al OpenHAB draait en ook mijn eigen gemodificeerde skin wil, zie deze post: http://gathering.tweakers...message/43472881#43472881