¶ Rules
De rules in openHAB kan je best vergelijken met de logica van System Manager.
Rules en logica werken volgens hetzelfde principe. Eerst geef je een voorwaarde op en als aan die voorwaarde voldaan is moet er een actie volgen.
In System Manager ALS ... DAN ...
In openHAB when ... then ...
Je kan op 2 manieren rules aanmaken. De eerste manier, via de GUI is de eenvoudigste, de tweede manier, via bestanden is iets ingewikkelder.
Voordeel GUI: eenvoudig.
Voordeel bestanden: uitgebreider.
¶ Rules via GUI
Het aanmaken van een nieuwe rule gebeurt op dezelfde manier als het aanmaken van things, ... Door rechtsonder te klikken op het + teken:
Hier zien we meteen al hoe een rule wordt opgebouwd:
Unique ID, Name en Description kan je ook weer overal in openHAB terugvinden. Ook hier.
In principe kan je via de GUI de Unique ID steeds ongewijzigd laten.
Voor het Name veld is het van belang om een vanzelfsprekende naam te kiezen voor uw Rule.
Eventueel kan je een korte omschrijving toevoegen.
Hieronder de typische definitie van een Ruler:
When
Then
But only if
Laat ons beginnen met When:
Hier hebben we een aantal keuze's. Om via de uitgangen van Qbus iets te laten triggeren moeten we het Item Event gebruiken.
Met Time Event kan je vergelijken met de kloktijden van System Manager.
System Event kan je bv gebruiken ALS Qbus online komt DAN ...
We gaan een rule maken dat als je een bistabiel uitgang van Qbus AAN zet dat een dimmer uitgang van Qbus naar een bepaald percentage zal gaan.
We klikken dus op Item Event:
Hier zien we een lijst van Items die in ons Model zitten. We kiezen de Bistabiele uitgang Toggle Bureau:
Hier kunnen we onze voorwaarde invullen. We hebbn de keuze tussen:
received a command: Zal enkel uitgevoerd worden als er een update komt via Qbus
was updated: Zal enkel uitgevoerd worden als er een update komt uit openHAB
changed: Zal voor beide uitgevoerd worden
We kiezen hier voor changed.
From state to state. Hier kunnen we instellen dat de Rule enkel zal uitgevoerd worden als de status van OFF naar ON gaat.
Then: wat moet gebeuren als aan bovenstaande voorwaarden voldaan is.
Opnieuw hebben we een aantal keuze's:
Item Action: Hiermee kunnen we een actie sturen naar een Item.
Run Script: Deze keuze kan een script uitvoeren. Een script kan bv een python of shell programmatje zijn...
Other Rules: Andere rules kunnen getriggered worden.
Audio & Voice: Hiermee kan je bv een mp3 bestand laten afspelen op een Audio toestel.
Voor ons voorbeeld willen we de status van een Dimmer wijzigen. Dit is een Item, dus kiezen we Item Action.
We kiezen onze dimbare uitgang.
Hier opnieuw een aantal keuze's:
Send a command to: Dit zal een commando sturen naar Qbus.
Update state of: Dit zal enkel de status updaten in openHAB.
We willen een dimmer in Qbus wijzigen, dus kiezen we voor send a command.
En Command to send is onze waarde dat we naar de dimmer willen sturen.
Merk even op dat we de Staus van de Dimmer in openHAB niet wijzigen (Update state of), als we een commando sturen naar Qbus zal Qbus terug antwoorden met de status update. Deze komt binnen in openHAB en de Dimmerwaarde in openHAB zal aangepast worden.
En hier nog een overzichtje van onze rule.
¶ Rules via bestanden
We hebben in de GUI gezien dat je via enkele klikken een rule kan opbouwen. Dit heeft als voordeel dat dit eenvoudig is, zo hoef je bv de definitie van een rule niet te kennen, De GUI toont je die.
De methode die we nu gaan zien is iets moeilijker, maar heeft als grote voordeel dat die eenvoudig te kopieren zijn. Als je via de GUI bv de rule aanmaakt van Bistabiel naar Dimmer kan je die 1x gebruiken. Wil je een tweede, gelijkaardige rule maar met anderde uitgangen, dan moet je deze opnieuw maken.
Bij onderstaande methode maak je 1 rule en kopieer je die zo veel je wil, en je kan dan enkel de uitgangen aanpassen.
Hiervoor openen we Visual Studio Code.
Voor deze oefening heb ik volgende regels toegevoegd in mij items bestand:
// Opleiding
Group Opleiding "Opleiding" ["Floor"]
Dimmer opl_dimmer_bureau1 "Dimmer Bureau 1" (Opleiding) ["Light"]
Switch opl_toggle_bureau1 "Toggle Bureau 1" (Opleiding) ["Switch"]
Dimmer opl_dimmer_bureau2 "Dimmer Bureau 2" (Opleiding) ["Light"]
Switch opl_toggle_bureau2 "Toggle Bureau 2" (Opleiding) ["Switch"]
Dimmer opl_dimmer_bureau3 "Dimmer Bureau 3" (Opleiding) ["Light"]
Switch opl_toggle_bureau3 "Toggle Bureau 3" (Opleiding) ["Switch"]
Om te beginnen maken we in het 'rules' mapje een nieuw bestand aan (rechtermuisklik - new file).
We geven ons bestand een naam met de extentie rules. opleiding.rules
Als je logging aan staat, zie je meteen dat openHAB het bestand heeft geladen:
10:31:30.665 [WARN ] [del.core.internal.ModelRepositoryImpl] - Configuration model 'opleiding.rules' is either empty or cannot be parsed correctly!
We voeren onderstaande tekst in:
rule "Bistabiel 1 naar Dimmer 1"
when
Item opl_toggle_bureau1 changed from OFF to ON
then
sendCommand(opl_dimmer_bureau1, 80)
end
Een rule bestand kan meerdere rules bevatten. Elke rule begint mer het woordje 'rule', gevolgd door een korte naam/beschrijving van die rule.
Dan hebben we de when
Een tab, een Item (omdat we de status van een Item willen monitorren) en 'changed from OFF to ON' omdat we iets willen uitvoeren als de waarde van OFF naar ON gaat.
Gevolgd door de then
Een tab, sendCommand (omdat we een commando willen sturen naar Qbus) tussen haakjes staat eerst het Item waar we een waarde willen naar sturen, een komma en de waarde.
En een rule sluit met af met end.
Als we dit bestand bewaren, zien we in de loggin dit:
Loading model 'opleiding.rules'
Geen fouten, dus onze rule werd correct opgenomen door openHAB.
In de GUI zien we ook onze rule:
Hier echter met een slotje achter de naam om erop te wijzen dat dit een rule is, aangemaakt via een bestand. En bijgevolg in de GUI niet gewijzigd kan worden.
Nu kunnen we bovenstaande rule kopieren en onder de eerste plakken:
rule "Bistabiel 1 naar Dimmer 1"
when
Item opl_toggle_bureau1 changed from OFF to ON
then
sendCommand(opl_dimmer_bureau1, 80)
end
rule "Bistabiel 2 naar Dimmer 2"
when
Item opl_toggle_bureau2 changed from OFF to ON
then
sendCommand(opl_dimmer_bureau2, 80)
end
We passen de naam van de rule en de uitgagen snel aan en we hebben een tweede rule in geen tijd.
Deze rule zou je ook als template kunnen kopieren naar je pc, zo heb je deze al voor een volgend project en hoef je niet meer te denken 'Hoe was dat ook al weer...?'
De rules die je via bestanden aanmaakt zijn in feite kleine stukjes java code. Dit brengt met zich mee dat je als het ware kan programmeren in java, in een rules betand. Om u een idee te geven van de mogelijkheden:
Als eerste een rule die een RGB LED strip aanstuurt in de keuekn. In Qbus heb ik 3 dimmers op een DMX module liggen.
In openHAB ondertaand 'fictief' Item:
Color Keuken_ColorHSB "Keuken Kleur" <color> (Keuken) ["Point"]
var Keuken_redSaved = 0
var Keuken_greenSaved = 0
var Keuken_blueSaved = 0
rule "Keuken RGB ->HSB"
when
Item o_O_Keuken_R changed or
Item o_O_Keuken_G changed or
Item o_O_Keuken_B changed
then
if (KeukenHSB === true){
return
}
KeukenRGB = true
var red = (o_O_Keuken_R.state as Number)
var red1 = (red * 2.55).intValue
var green = (o_O_Keuken_G.state as Number)
var green1 = (green * 2.55).intValue
var blue = (o_O_Keuken_B.state as Number)
var blue1 = (blue * 2.55).intValue
val color = HSBType.fromRGB(red1, green1, blue1)
var HSBType KeukenHSBValue = new HSBType(color.toString)
Keuken_ColorHSB.sendCommand(KeukenHSBValue as Number)
Thread::sleep(500)
KeukenRGB = false
end
rule "Keuken HSB ->RGB"
when
Item Keuken_ColorHSB received command
then
if (KeukenRGB === true){
return;
}
KeukenHSB = true
val red = Math::round((receivedCommand as HSBType).red.intValue)
val green = Math::round((receivedCommand as HSBType).green.intValue)
val blue = Math::round((receivedCommand as HSBType).blue.intValue)
o_O_Keuken_R.sendCommand(red)
o_O_Keuken_G.sendCommand(green)
o_O_Keuken_B.sendCommand(blue)
Keuken_redSaved = red
Keuken_greenSaved = green
Keuken_blueSaved = blue
Thread::sleep(500)
KeukenHSB = false
end
Tijdsturingen via rules verlopen via zogenaamde Cron jobs.
Deze site helpt u om een cron te definiëren: https://www.freeformatter.com/cron-expression-generator-quartz.html
rule "Verwarming Ma-Vrij 6:00 => 20°C"
when
Time cron "0 0 6 ? * MON,TUE,WED,THU,FRI *"
then
sendCommand(Thermostat_Target_temperature, 20)
end
rule "Verwarming Ma-Vrij 8:00 => 17°C"
when
Time cron "0 0 8 ? * MON,TUE,WED,THU,FRI *"
then
sendCommand(Thermostat_Target_temperature, 17)
end
Sonos aansturen via rules:
val thewave = "The Wave Relaxing Radio"
rule "Sonos Favoriet"
when
Item o_OH_Sonos_Zitpl changed
then
if (o_OH_Sonos_Zitpl.state == ON){
sendCommand(Sonos_Favorite, thewave)
sendCommand(Sonos_Controller, PLAY)
} else if (o_OH_Sonos_Zitpl.state == OFF){
sendCommand(Sonos_Controller, PAUSE)
}
end
rule "PowerButton"
when
Item QSonos_Power changed
then
if (QSonos_Power.state==OFF) {
Sonos_Controller.sendCommand("PAUSE")
} else if (QSonos_Power.state==ON){
Sonos_Controller.sendCommand("PLAY")
}
end
rule "VolumeDN"
when
Item Sonos_VolDN changed from OFF to ON or
Item Sonos_VolDN changed from NULL to ON
then
//logWarn("myLog", "Rule VolDN executed")
sendCommand(Sonos_VolDN, OFF)
var Number V = Sonos_Volume.state as DecimalType
var Number H = V - 10
logWarn("myLog", "Volume: " + H)
Sonos_Volume.sendCommand(H)
end
rule "VolumeUP"
when
Item Sonos_VolUP changed from OFF to ON or
Item Sonos_VolUP changed from NULL to ON
then
sendCommand(Sonos_VolUP, OFF)
var Number V = Sonos_Volume.state as DecimalType
var Number H = V + 10
if (H>65) H = 65
Sonos_Volume.sendCommand(H)
end