• Uitstekend advies
  • Voor 16.30 uur besteld vandaag verstuurd
  • Altijd bereikbaar (+31 73 762 0 762)
  • Maandag koopavond

FIBARO LUA introductie

 FIBARO LUA | If-Then-Else we help you

In deze LUA introductie leer je de basisprincipes van de LUA programmeertaal voor de FIBARO Home Center 2 Z-Wave basisstation. Je leert de basis van het programmeren in deze taal en de ins- en outs van scènes ontdekken, alsmede de inrichting en architectuur van de FIBARO Home Center 2 (HC2).

Voor je begint: FIBARO maakt onderscheid tussen hoofd- en kleine letters! Dus wanneer je IF gebruikt dan zal dat resulteren in een foutmelding. 

 

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 scènes te kunnen programmeren klik je op ‘scenes’ en vervolgens op ‘scene toevoegen’.

Je kunt nu kiezen uit het maken van een scène op basis van grafische blokken, of op basis van LUA code. Het maken van grafische blokken zal hier niet verder behandeld worden. Een videovoorbeeld van het maken van dergelijk scène vindt je hier.

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

In LUA typ je 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 gedefiniëerd en onder '% % globals' worden de globale variabelen gedefiniëerd, beide worden verderop in deze handleiding beschreven.

 

1.2 Z-wave modules (Z-wave devices)

Om te begrijpen hoe je in LUA kunt programmeren is het belangrijk te weten wat bedoeld word met modules. In het Z-wave basisstation 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 1x2,5kw/ 1x3kw
• Dimmable_ligth - Dimbare verlichting - voorbeeld Dimmer module
• Blind - Rolluiken controllers , voorbeeld FIBARO Rolluikschakelaar
• Virtual_device – Virtuele modules aangemaakt door de gebruiker
• Thermostat_setpoint - thermostatische kranen voorbeeld Danfoss Living Connect
• Motion_sensor - bewegingssensoren, binaire sensoren
• Door_sensor - deur en raam sensoren , voorbeeld FIBARO Deur / raam Sensor
• Smoke_sensor , rook sensoren
• Water_sensor , Flood sensor , voorbeeld FIBARO Flood Sensor
• Ip_camera - IP-camera's 

Zoals weergegeven onder 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 kun je het uitgebreide individuele kenmerken van de gebruikers gebruiken om te programmeren. 

In de interface van Home Center 2 Z-wave basisstation 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 je niet zeker bent welke acties je modules kunnen uitvoeren kun je ook de parameters bekijken via de modules in de HC2 (figuur 2).

 

 Figuur 3 - Preview van modules Eigenschappen en acties

 

2. Scènes

Met behulp van de LUA programmeertaal kun je complexe scènes maken. In de volgende hoofdstukken tref je een aantal voorbeelden met uitleg aan om jouw eerste scènes op basis van LUA code te kunnen schrijven.

 

Script 1
Eerst maken we een eenvoudige scène 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 deviceID 2. Om de module in te schakelen maak je het volgende script:

1 -- [ [
2 %% properties
3 %% globals
4 -- ] ]
5
6 fibaro:call ( 2 , ' turnOn ' ); -- AAN  functie activeren

 

De scène bestaat uit een header en een standaard scènescript. 

Sla de scène op door op de knop '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 je eigen informatie. Wij raden je aan om het nodige commentaar in je eigen code toe te voegen. Voorbeeld :
 -- AAN functie activeren

Nadat je de scène hebt opgeslagen kun je deze starten door op start’ te drukken.

 

Script 2

In dit script zullen we de scène maken die het module uitzet. Om dit te doen zullen we van dezelfde soort functie gebruik maken. 

1 - [ [
2 %% properties
3 %% globals
4 -- ] ]
5
6 fibaro:call ( 2 , ' TurnOff ' ) -- UIT  functie

Nadat je op opslaan hebt gedrukt kun je de scène starten door op de startknop te drukken.

 

Script 3

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 zal worden 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 3 seconden
8 fibaro:call ( 2 , ' TurnOff ' )         --  module wordt uitgeschakeld

Wanneer we dit script opslaan en starten zal de module met ID 2 ingeschakeld worden, na 3 seconden schakelt de module weer uit.

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

 

Script 4

LUA, heeft net als de meeste programmeertalen, een debugger. Debuggen is het analyseren van je 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

In voorgaande script maakte je 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 3 seconden
10 fibaro:debug ( 'Nu ik zal het module uitschakelen ' )
11 fibaro:call ( 2 , ' TurnOff ' )                                                       -- schakelt de module uit
12 fibaro:debug ( ' Het script werd correct uitgevoerd ' )

 

Hoe werkt het?

Het script zal regel voor regel uitgevoerd worden. Eerst zal de header code gecontroleerd worden 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 3000 ms. 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

In de volgende stap leer je hoe je waarde toekent aan een functie. Naast de aan/uit en dimmer modules, die je nu via LUA kunt bedienen, zijn er meerdere z-wave modules in je 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 commando's 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 de volgende modules in onze FIBARO HC basisstation:
•  z-wave inbouw Schakelaar (met deviceID 2)
•  z-wave Dimmer (met deviceID 5 
•  z-wave Rolluik schakelaar (met deviceID 10)

Laten we dit 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 ( 'Licht 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 je nu niet alleen modules aan en uit kunt zetten, je kunt er nu zelfs ook waardes naar toe sturen .

 

Script 7

In het volgende script leer je 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?). Je kunt dus de status van een deursensor uitlezen (staat de deur open of niet?) en/of bijvoorbeeld het lichtniveau van de dimmer afstemmen. Je 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 creëren 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 scène 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 de 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 inschakelen'  );
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 ; De if-functie

Een ander belangrijk element van LUA programmeren is de if – then functie. Met deze functie kun je voorwaarden definiëren waaronder een scène bepaalde taken uit dient te voeren. Voorbeeld: je wilt dat als de deursensor open gaat dan ook direct het licht aan gaat. Het kan allemaal: 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’ ) -- schakelt module  2 aan
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 zal de variable uitgelezen worden en toegekent worden aan myVariable. In de if statement zal worden gecontroleerd of myvariable gelijk is aan 1, dan schakelt het systeem module 3 in (aan). Als er niet aan de voorwaarde van myVariable == '1 '  voldoet, dan zal module 3 niet ingeschakeld worden.

Ben je er nog? Dan gaan we nog even door....

 

Script 9

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 " parameter geïnteresseerd. 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 scène 10


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 gebruiken we de volgende voorwaarde - als de deur wordt geopend dan zal de schakelaar omgezet worden van uit naar aan of van aan naar uit.

 

Script 10

De voorgaande scripts hebben 1 ding gemeen, ze moesten allemaal handmatig utigevoerd worden. Ze werken dus alleen wanneer we op de startknop drukken. Voor sommige scènes is dat prima, maar vaak willen we dat een scène start door een gebeurtenis (trigger).

Een trigger is dus een gebeurtenis die een scène start.

Je 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 scène die gaat aan het licht ( deviceID 3 ) wanneer motion_sensor ( deviceID 50 ) de beweging zal sens creëren. Het script zal eenvoudig zijn :

Een scène 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 scène start als er beweging is
De trigger heeft de volgende syntaxis : [ deviceID ] [ eigendom ] 

We nemen deze 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 scène werkt als volgt:


1) Declareer de variabelen. DeviceID 50 is aangegeven als trigger voor de scène. Wanneer de waarde van DeviceID 50 veranderd, start de trigger.
2) Declareren van de variabele, deze krijgt later de waarde van de bewegingsmelder
3) if- voorwaarde om te kijken of de deur open is; dan zal de lamp aangezet worden.

 

De scène is eenvoudig aan te passen om ervoor te zorgen dat de lamp uitgaat wanneer de deur weer gesloten zal worden.

 

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 kun je commando's uit laten voeren NA een bepaalde pauze. Als voorbeeld hebben wij de volgende scène gemaakt in FIBARO: 

Figuur 5 : Voorbeeld van een Grafische Blok Scene

De scène zal worden 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 dan na 2 seconden (dus 22 seconden na starten scène) later wisselt de wandlamp van status.
Maar dat is dus niet het geval.... het is een weetje, maar wel belangrijk :)

  

Wij hopen dat je na het lezen van deze LUA introductie wat wijzer bent geworden met het maken van LUA scènes in de FIBARO Home Center 2. Mocht je toch nog vragen hebben dan kun je altijd contact met ons opnemen. Uiteraard mag je ook altijd tips of verbeterpunten aan ons doorgeven.

Meer informatie over de FIBARO commando's, kijk dan op de FIBARO LUA functies pagina

 

Team ROBBshop

 
Klantenservice telefoonnummer

+31737620762
ma-vrij: 10:00-17:00 en za 10:00-15:00

 
Adres

Gasstraat Oost 14A 5349 AV Oss Nederland

Google maps