Inleiding tot Fibaro LUA programmering

Inleiding tot Fibaro LUA programmering in de Fibaro HC-2 Z-wave controller.

Voor een overzicht van alle Fibaro LUA functies klik HIER.

In deze introductie leert u de basisprincipes van de LUA -programmeertaal voor de Fibaro HomeCenter 2 z-wave controller. U leert de basis van het programmeren in deze taal en de ins en outs van scenes ontdekken, alsmede de inrichting en architectuur van de Fibaro Home Center 2 (HC2).

Voor u begint : Fibaro maakt onderscheid tussen HOOFD en kleine letters! Dus wanneer u IF gebruikt dan zal dat resulteren in een foutmelding. gebruik altijd kleine letters

1.1 Het maken van een nieuwe LUA scéne

De interface van de HC2 (vanaf versie 3) biedt een nieuwe functionaliteit;  LUA scéne programmering. Om in LUA scenes te kunnen programmeren klikt u op ‘scenes’ en vervolgens op ‘scene toevoegen’.

U kunt nu kiezen uit het maken van een scene op basis van grafische blokken, of op basis van LUA code. Het maken van grafische blokken word hier niet verder behandeld,

De LUA code voor de nieuwe scene kan in het code invoer venster worden getypt (zie figuur hieronder):

In LUA typt u de opdrachten , net als in andere programmeertalen, in regels onder elkaar.
Elke scéne geschreven in LUA begint altijd met de header:

1 — [ [
2 %% properties
3 %% globals
4 – -] ]

De header is absoluut essentieel voor elke scéne . Onder ‘% % properties’ worden de triggers gedefinieerd en onder ‘% % globals’  worden de globale variabelen gedefinieerd, beide worden verderop in deze handleiding beschreven.

1.2 Z-wave modules (Z-wave devices)

Om te begrijpen hoe u in LUA kunt programmeren is het belangrijk te weten wat bedoeld word met modules. In de Z-wave controller van Fibaro onderscheiden we verschillende typen modules. Hieronder een overzicht welke typen modules er bestaan binnen een z-wave netwerk:

Figuur 2 : Typen modules in een z-wave netwerk

• • Bij het toevoegen van een Z-wave module in de Fibaro Home Center 2 wordt het als een bepaald type module weergegeven
  • Binary_light – Relais Schakelaars, voorbeeld Fibaro inbouwmodules 1×2,5kw/ 1x3kw

Zoals weergegeven Figuur 2 is er ook een HC_user module. Dit is een van de belangrijkste veranderingen in de 3.x -interface – gebruikers zijn toegevoegd aan modules – Met deze toevoeging kunt u het uitgebreide individuele kenmerken van de gebruikers  gebruiken om te programmeren .

In de interface van Home Center 2 z-wave controller worden alle beschikbare modules gekenmerkt door:
– deviceID – uniek module nummer in Home Center 2 database
– type – het type van het module ( voorbeeld binary_light of rook_melder . )
– properties – ( voorbeeld Value , dead . ) – geeft de huidige stand van het module aan, de eigenschappen van het module zijn alleen-lezen, en kunnen dus niet gewijzigd worden.
– actions – ( voorbeeld TurnON ( ) , TurnOFF ( ) ) – Geeft aan welke acties de z-wave module uit kan voeren. Bijvoorbeeld als we een Fibaro inbouw module bekijken dan kunnen we deze aanzetten – TurnON ( )  –  of uitschakelen  – TurnOFF ( ) -.  Dimbare modules kunnen we inschakelen, op een bepaalde waarde instellen ( bijvoorbeeld 50 % ) ,door actie setValue ( ) en uitschakelen.

TIP :
Wanneer u niet zeker bent welke acties uw modules kunnen uitvoeren kunt u ook de parameters bekijken via de modules in de HC2 (figuur2 ) .

Figuur 2 – Preview van modules Eigenschappen en acties

2 . Scenes

Met behulp van de LUA programmeertaal kunt u complexe scenes maken. In de volgende hoofdstukken treft u een aantal voorbeelden met uitleg om uw eerste scenes op basis van LUA code te kunnen schrijven.

Script 1: Het inschakelen van een z-wave module
Script 2: Het uitschakelen van een z-wave module
Script 3: Een lamp die inschakelt en na 3 seconden weer uitschakelt
Script 4: Debuggen is het analyseren van uw code om mogelijk fouten op te sporen
Script 5: Geavanceerd voorbeeld fibaro:debug()
Script 6: Hoe u waarde toekent aan een functie
Script 7: Een waarde lezen van een z-wave module
Script 8: if – then functie: als een deursensor word geopend dan moet het licht aan
Script 9: Een deur/raam sensor te gebruiken om een schakelaar in te schakelen
Script 10: Een scene niet handmatig starten maar door een trigger

Script 1 Het inschakelen van een z-wave module

Eerst maken we een eenvoudige scene voor het inschakelen van een z-wave module.
Voor het inschakelen van de module word de fibaro:call() functie gebruikt. Dit is de meest elementaire lua functie. Deze functie stuurt een verzoek om een actie uit te voeren naar een z-wave module .
De functie bevat minstens twee argumenten :
– deviceID – het genoemde module-ID
– actionname – De actie die de module moet uitvoeren (bijv. TurnON ,TurnOFF , SetValue )
Stel je hebt een systeem met een z-wave inbouwmodule met 2 deviceID’s. Om de module in te schakelen maakt u het volgende script:
1 — [ [
2 %% properties
3 %% globals
4 — ] ] 5
6 fibaro:call ( 2 , ‘ TurnON ‘ ); — AAN  functie activeren

De scene bestaat uit een header en een standaard scenescript.
Sla de scene op door op de  opslaan te drukken.
OPMERKING
twee streepjes voor de tekst geven aan dat het commentaar is, hier zal de HC2 niets mee doen, het is puur voor uw eigen informatie. Het word aangeraden om het nodige commentaar in uw code toe te voegen. Voorbeeld :
— AAN functie activeren

Nadat u de scene heeft opgeslagen kunt u hem starten door op ‘start’ te drukken.

Script 2 Het uitschakelen van een z-wave module

In dit script zullen we de scéne maken die het module uitzet . Om dit te doen zullen we van zelfde soort functie gebruik maken.
1 – [ [
2 %% properties
3 %% globals
4 — ] ] 5
6 fibaro:call ( 2 , ‘ TurnOFF ‘ ) — UIT  functie
Nadat u op  opslaan heeft gedrukt kunt u de scene starten door op de startknop te drukken.

Script 3 Een lamp die inschakelt en na 3 seconden weer uitschakelt

In dit script zullen we de scéne maken die de lamp inschakelt en na 3 seconden weer uitschakelt. Voor het in -en uitschakelen kunnen we gebruikenmaken van de fibaro:call ( )-functie.
Voor de vertraging zullen we gebruik maken van de functie fibaro:sleep ( ) . De tijd word uitgedrukt in milliseconden, dus fibaro:sleep(3000) is 3 seconden vertraging
1 – [ [
2 %% properties
3 %% globals
4 — ] ] 5
6 fibaro:call ( 2 , ‘ TurnON ‘ )          — module wordt ingeschakeld
7 fibaro:sleep ( 3000 )                    — wacht 3seconden
8 fibaro:call ( 2 , ‘ TurnOFF ‘ )        —  module wordt uitgeschakeld
Wanneer we dit script opslaan en starten zal de module met ID 2 ingeschakeld worden, 3 seconden schakelt de module weer uit.

TIP:
De fibaro:sleep functie is een krachtige functie.

Script 4 Debuggen is het analyseren van uw code om mogelijk fouten op te sporen

LUA, heeft net als de meeste programmeertalen, een debugger. Debuggen is het analyseren van uw code om mogelijk fouten op te sporen. In LUA heet deze functie fibaro:debug( )
Deze functie geeft gewenste waardes op het scherm weer. Ze worden weergegeven in het debug venster.
Een script dat gebruik maakt van de debug functie kan er als volgt uitzien:
1 – [ [
2 %% properties
3 %% globals
4 — ] ] 5
6 fibaro:debug ( ‘ Hallo wereld! ‘ )
In feite doet deze functie niets anders dan het weergeven van de tekst Hallo wereld! In het debugvenster.

Script 5 Geavanceerd voorbeeld fibaro:debug()

In voorgaande script maakte u kennis met  de functie fibaro:debug(). Laten we de functie gebruiken in een meer geavanceerd voorbeeld:
1 – [ [
2 %% properties
3 %% globals
4 — ] ] 5
6 fibaro:call ( 2 , ‘ TurnON ‘ )                                                         — module wordt ingeschakeld
7 fibaro:debug ( ‘ ! Module met DeviceID 2 is ingeschakeld ‘ )
8 fibaro:debug ( ‘ wacht 3 seconden ‘ )
9 fibaro:Sleep ( 3000 )                                                                    — wacht 3seconden
10 fibaro:debug ( ‘Nu ik zal het module uitschakelen ‘ )
11 fibaro:call ( 2 , ‘ TurnOFF ‘ )                                                      — schakelt het module
12 fibaro:debug ( ‘ Het script werd correct uitgevoerd ‘ )

Hoe werkt het?
Het script word regel voor regel uitgevoerd. Eerst word de header code gecontroleerd en vervolgens draait het script op de HC2. In de volgende stap toont de debugger het bericht ‘Module met DeviceID 2 wordt ingeschakeld ! ‘ en ‘ wacht 3 seconden ‘ . Daarna begint de fibaro:sleep() functie met 3000ms. Na deze pauze wordt het script uitgevoerd die fibaro:debug() functie met bericht ‘ Nu ik zal het module uitschakelen ‘ . Dan start de fibaro:cal() functie . In de laatste regel print de debugger het bericht ‘ Het script werd correct uitgevoerd ‘ af op het scherm.

Waar kunnen we het gebruiken ?
Bij meer geavanceerde scripts kan de debug functie van pas komen om de waardes van variabalen te controleren.

Script 6 Hoe u waarde toekent aan een functie

In de volgende stap leert u hoe u waarde toekent aan een functie. Naast de aan/uit en dimmer modules, die u nu via LUA kunt bedienen, zijn er meerdere z-wave modules in uw z-wave systeem aanwezig. Denk aan z-wave bewegingsmelders, z-wave deur en raam sensoren, e.d. Deze kunnen opdrachten ontvangen vanuit de LUA code. Voor dergelijke z-wave commandos maken we opnieuw gebruik van de functie:  Fibaro:call(deviceID,instructie)
Een z-wave Dimmer of z-wave Rolluik module heeft extra parameter die ‘ setValue ‘ wordt genoemd . De Syntax is als volgt :
Fibaro:call ( 10 , ‘ setValue ‘ , ’50 ‘ )
Stel : we hebben volgende modules in onze fibaro HC controller :
– z-wave inbouw Schakelaar ( met deviceID 2 )
– z-wave Dimmer ( met deviceID 5 )
– z-wave Rolluik schakelaar( met deviceID 10 )
Laten we te maken met bijvoorbeeld meer geavanceerde waarden :

1 – [ [
2 %% properties
3 %% globals
4 — ] ] 5
6 fibaro:debug ( ‘Start het programma ” )
7 fibaro:debug ( ‘ Inschakelen van het module met deviceID = 2 ‘ )
8 fibaro:call( 2 , ‘TurnON‘ ) — Zet het module aan
9 fibaro:debug ( ‘ Ik wacht 5 seconden ‘ )
10 fibaro:sleep ( 5000 ) — wacht 5 seconden
11 fibaro:debug ( ‘Ik heb 5 seconden gewacht , nu rolluik schakelaar zonwering op 50 % zetten‘ )
12 fibaro:call ( 10 , ‘ setValue ‘ , ’50 ‘ ) — opent rolluiken
13 fibaro:debug ( ‘Rolluiken geopend , zet nu licht op 75 % ‘ )
14 fibaro:debug ( ‘ ik wacht 5 seconden ‘ )
15 fibaro:sleep ( 5000 ) — wacht 5 seconden
16 fibaro:call ( 5 , ‘ setValue ‘ , ’75 ‘ ) — zet licht op 75%
17 fibaro:debug ( ‘Light ingesteld ‘ )
18 fibaro:debug ( ‘ Zet de lampen uit‘)
19 fibaro:call ( 2 , ‘ TurnOFF ‘ )
20 fibaro:call ( 5 , ‘ TurnOFF ‘ )
21 fibaro:debug ( ‘ Sluit de rolluiken‘)
22 fibaro:call ( 10 , ‘ TurnOFF ‘ ) — sluit de rolluiken
23 fibaro:debug ( ‘Modules werden uitgeschakeld code werd correct uitgevoerd‘ )
Hieruit blijkt dat u niet alleen modules aan en uit kunt zetten, u kunt er ook waardes naar toe sturen .

Script 7 Een waarde lezen van een z-wave module

In het volgende script leert u een zeer belangrijke functionaliteit: Een waarde lezen van een z-wave module. Naast het uitvoeren van een actie is het ook mogelijk om een parameter uit te lezen van een module. Denk bijvoorbeeld aan de status (is de module aan of uit).  Of u kunt de status van een deursensor uitlezen (staat de deur open of niet). Of het lichtniveau van de dimmer. U kunt van vele parameters de waarden opvragen.

Voorbeeld
Uitgaande van een z-wave inbouw schakelaar (DeviceID 2). Dit is een binaire schakelaar, en kan een aantal eigenschappen hebben. Een van de belangrijkste is de parameter ‘Value’. Dit is de status van de schakelaar (aan of uit). 0 betekent uit, 1 betekent aan.
Om de waarde uit te lezen gebruiken we de volgende functie() : getValue ( deviceID , propertyName ) .
Een heel belangrijk element bij programmeren is de variabele. Een variabele bevat een waarde en er kan mee gerekend worden. Een variabele heeft 3 eigenschappen: type, naam en waarde.

Om een variabele te creeren in LUA doen we het volgende:
1 local MyValue    — declareren van de variabele
2 MyValue = 10     — toekennen van een waarde

Om een waarde van een module toe te kennen aan een variabele gaan we als volgt te werk
1 local MyValue = fibaro : getValue ( 2 , ‘Value’ )

Als de scene start dan zal de status van DeviceID 2 worden toegekent aan de variabele MyValue. Als de lamp aan is zal de waarde 0 zijn en wanneer hij aan staat 1
1 — [ [
2 %% properties
3 %% globals
4 — ] ] 5
6 Local myVariable — declareren van variabele myVariable
7
8 fibaro:debug (‘Zet het device met deviceID = 2 aan‘ );
9 fibaro:call ( 2 , ‘TurnON‘ ); — schakelt het module aan
10 myVariable = fibaro:getValue ( 2 , ‘value‘ );
11 fibaro:debug ( ‘ myVariable is = ‘ .. myVariable );
12 fibaro:debug ( ‘Het module uitschakelen ‘ )
13 fibaro:debug ( ‘ Wacht 3 seconden ‘ );
14 fibaro:sleep ( 3000 );
15
16 fibaro:call ( 2 , ‘ TurnOFF ‘);
17 fibaro:debug ( ‘Ik heb het module uitgeschakeld ‘ );
18 fibaro:sleep ( 3000 );
19 myVariable = fibaro:getValue ( 2 , ‘value‘ );
20 fibaro:debug ( ‘ MijnVariabele is nu = ‘ .. myVariable );
21
22 fibaro:debug ( ‘ Nu zal deviceID = 2‘ );
23 fibaro:call ( 2 , ‘TurnON‘ );
24 fibaro:sleep ( 3000 );
25 myVariable = fibaro:getValue ( 2 , Value );
26 fibaro:debug ( ‘ Nu is mijn variabele = ‘ .. MyValue );

Eerst hebben we de variabele MyVariable gedeclareerd zodat we deze kunnen gebruiken. Daarna hebben we de module aangezet en de waarde van de module uitgelezen. Vervolgens hebben we de waarde weergegeven in het debug scherm.
Daarna is de module uitgezet (na 3 seconden pauze) en is de waarde wederom uitgelezen uit de module en weergegeven in het debug venster.

Script 8 if – then functie: als een deursensor word geopend dan moet het licht aan

Een ander belangrijk element van LUA programmeren is de if — then functie. Met deze functie kunt u voorwaarden definiëren waaronder een scene bepaalde taken uit dient te voeren. Voorbeeld als een deursensor word geopend dan moet het licht aan. We gebruiken hierbij de volgende syntax

1 if (voorwaarde ) then
2
3 instructie
4
5 end

Voorbeeld van een eenvoudige LUA if-then functie:
1 — [ [
2 %% properties
3 %% globals
4 — ] ] 5 local myVariable — declaratie van de variabele
6
7 fibaro:call ( 2 , ‘TurnON‘ ) — turnsON module = 2
8 myVariable = fibaro:getValue ( 2 , ‘Value‘ );
9
10 if ( myVariable == ‘1 ‘ ) then
11 fibaro:call( 3 , ‘TurnON‘ );
12 end
13
In de eerste stap declareren we de variabele genaamd myVariable . Dan schakelt het systeem module 2 in (aan). Dan word de variable uitgelezen en toegekent aan myVariable. In de if statement word gecontroleerd of myvariable gelijk is aan 1 dan schakelt het systeem module 3 in (aan). Als er niet aan de voorwaarde van myVariable == ‘1 ‘ dan zal module 3 niet ingeschakeld worden.

Script 9 Een deur/raam sensor te gebruiken om een schakelaar in te schakelen

De volgende stap is om een deur/raam sensor te gebruiken om een schakelaar in te schakelen. We gaan uit van een deur/raam sensor met DeviceID 145. Het type van dit module is sensor. Dit type z-wave module heeft een aantal typische eigenschappen, zoals batterijniveau, armed/bypass, etc. In dit stadium zijn we alleen in Value geinteresseerd.
In dit stadium , zijn we alleen in ” value ” parameter geinteresseerd. Als de sensor is geopend krijgt deze de waarde 1, als de z-wave sensor is gesloten dan krijgt hij de waarde 0.
Om de waarde uit te kunnen lezen maken we wederom gebruik van de functie: fibaro:getValue().
De functie ziet er als volgt uit:
1 fibaro : getValue ( 145 , ‘Value‘ );
Om te controleren of de sensor armed is dan kunnen we de volgende parameter gebruiken: 1 fibaro:getValue ( 145 , ‘ armed ‘ ) .

1 — [ [
2 %% properties
3 %% globals
4 — ] ] 5
6 local myVar1 = fibaro:getValue ( 145 , ‘value‘ ) — stand van de sensor
7 fibaro:debug ( ‘ value = ‘ .. myVar1 ) — afdrukken waarde van variabele1
8 local myVar2 = fibaro:getValue ( 2 , ‘value‘ ) — stand van de aan / uit
9 fibaro:debug ( ‘ value = ‘ .. myVar2 ) — afdrukken waarde van variabele2
10
11 if ( myVar1 == ‘1 ‘ ) then
12 if ( myVar2 == ‘0 ‘) then
13 fibaro:call( 2 , ‘TurnON’ );
14 else
15 fibaro:call ( 2 , ‘TurnOFF’ );
16  end
17 end

Uitleg van scene 9
1 ) myVar1 krijgt de waarde van de sensor
2 ) fibaro:debug print waarde van myVar1
3 ) myVar2 krijgt de waarde van de sensor
4 ) fibaro:debug print waarde van myVar2
5 ) Script controleert de staat van myVar1 = 1 , dus of de deur raam sensor is geopend
6 ) In de volgende stap gebruikten we volgende voorwaarde – als de deur wordt geopend dan word de schakelaar in omgezet van uit naar aan of van aan naar uit .

Script 10 Een scene niet handmatig starten maar door een trigger

De voorgaande script hebben 1 ding gemeen, ze moesten allemaal handmatig utigevoerd worden. Ze werkten alleen wanneer we op de startknop drukken. Voor sommige scenes is dat prima, maar vaak willen we dat een scene start door een gebeurtenis (trigger).
Een trigger is dus een gebeurtenis die een scene start.
U schakelt de stand automatisch moeten we TRIGGER verklaren. Triggers zijn gebeurtenissen die het toneel voor uitvoering van het script te bellen. Laten we zeggen dat we willen de scene die gaat aan het licht ( deviceID 3 ) wanneer motion_sensor ( deviceID 50 ) de beweging zal sens creeren. Het script zal eenvoudig zijn :
Een scene die het licht (DeviceID 3) aanzet als de bewegingsmelder getriggerd is ziet er als volgt uit :
1 local myVariable — declareren van myVariable
3 myVariable = fibaro:getValue ( 50 , ‘Value‘ );
4 if ( myVariable == ‘1 ‘ ) then
5 fibaro:Call ( 3 , ‘TurnON‘ );
6 end

Nu willen we vervolgens dat deze scene start als er beweging is
De trigger heeft de volgende syntaxis : [ deviceID ] [ eigendom ]
We nemen hem als volgt op in de scene
1 — [ [
2 %% properties
3 50 value
4 %% globals
5 — ] ] Telkens als de waarde voor trigger met DeviceID 50 wijzigt zal de scene het script uitvoeren

1 – -[ [
2 % % properties
3 50 value
4 %% globals
5 — ] ] 6 local myVariable — declareren van myVariable
7
8 myVariable = fibaro : getValue ( 50 , ‘Value‘ );
9 if ( myVariable == ‘1 ‘ ) then
10 fibaro:call( 3 , ‘TurnON’ );
11 end

De scene werkt als volgt:
1) Declareer de variabelen. DeviceID 50 is aangegeven als trigger voor de scene. Wanneer de waarde van DeviceID 50 verandert start de trigger.
2) Declareren van de variabele, deze krijg later de waarde van de bewegingsmelder
3) if- voorwaarde om te kijken of de deur open is; dan zal de lamp aangezet worden.

De scene is eenvoudig aan te passen om ervoor te zorgen dat de lamp uitgaat wanneer de deur weer gesloten word

1 — [ [
2 %% properties
3 50 value
4 %% globals
5 — ] ] 6 local myVariable — declareren van myVariable
7
8 myVariable = fibaro:getValue ( 50 , value )
9 if ( myVariable == ‘1 ‘ ) then
10  fibaro:call( 3 , ‘TurnON‘ );
11 else
12  fibaro:Call( 3 , ‘TurnOFF‘ );
13 end

LUA Programmeertips

fibaro:sleep commando

Met dit commando kunt u commandos uit laten voeren NA een bepaalde pauze. Als voorbeeld hebben wij de volgende scene gemaakt in de Fibaro:

De scene word getriggerd door het aanzetten van de led verlichting. Vervolgens gebeurd er het volgende:
Na 2 seconden wisselt de wandlamp van status en na 20 seconden wisselt de eetkamerlamp van status.
Wat je zou verwachtten is het volgende:
De Eetkamer wisselt van status na 20 seconden en 2 seconden (dus 22 seconden na starten scene) later wisselt de wandlamp van status.
Maar dat is dus niet het geval…. het is een weetje, maar wel belangrijk 🙂

Wij hopen dat u na het lezen van deze LUA introductie enigszins bekent bent geworden met het maken van LUA scenes in de Fibaro HomeCenter 2.

Meer informatie over de fibaro commandos in lua kijkt u op de Fibaro LUA functies pagina.