Fibaro LUA Grundlagen

Fibaro LUA Grundlagen

13. Januar 2017 9 811 Von Bastian

Der Internet of Things (IoT) und Smart-Home-Nachrüstmarkt ist hart umkämpft, so dass fast monatlich neue Lösungen erscheinen und auf den Einsatz in unseren Haushalten warten. Bei den Herstellern ist der Druck des schnellen „Go-To-Market“ und die zu adressierende Zielgruppe offenbar so groß, dass es sich bei den meisten Neuerscheinungen um Insellösungen handelt. Sie ermöglichen die einfache Interaktion mit smarten Geräten und sind meist mit einer eigenen App ausgestattet. Interaktion mit Fremdgeräten sucht man vergeblich. Vereinfacht ausgedrückt geht es bei diesen Lösungen um das Ein- und Ausschalten von Aktoren und ggf. die Visualisierung von Sensorwerten. Nur einige wenige Lösungen bieten die Implementierung von Bedingungen und Abhängigkeiten. Hier scheint Plug-and-Play wichtiger zu sein als vollständige Integration und (nahezu) uneingeschränkte Möglichkeiten.

Für Otto-Normalverbraucher, der zur Bedienung seiner Heizthermostate oder Philips Hue Lampen das Smartphone nutzen möchte, sind diese Lösungen zielgerichtet und sicher auch „smart“ genug. Ein Smart Home wird aber erst durch die Möglichkeit der vollständigen Integration und Programmierung so richtig „smart“. Das Home Center 2 von Fibaro bietet durch die „freie“ Programmierung von Szenen die idealen Rahmenrahmenbedingungen dafür. Basierend auf der Programmiersprache LUA sind den Möglichkeiten fast keine Grenzen gesetzt. Jedoch ist LUA eine Programmiersprache und nicht jeder Besitzer eines Home Center 2 hat bisher etwas mit Programmierung zu tun gehabt. Daher möchte ich In diesem Artikel die Fibaro LUA Grundlagen vermitteln und hoffe damit helfen zu können.

Lua Grundlagen

Lua Grundlagen

„Wie lerne ich LUA?“

Die alles entscheidende Frage, wenn es um das Home Center 2 von Fibaro geht! Diese und ähnliche Fragen tauchen immer wieder in Foren und Kommentarspalten auf. Die Antworten darauf sind immer etwas zurückhaltend und meist beschränken sie sich auf den guten Hinweis sich fertige Szenen anzusehen, das gelesene zu verstehen und dann einfach ausprobieren.

So kann man sich eine Programmiersprache aneignen und genau das werden die meisten Fibaro User tun bzw. getan haben. Um aber auch komplexere Szenen entwickeln zu können und die Möglichkeiten der Smart Home Lösung auszuschöpfen bedarf es meiner Meinung nach ein bisschen mehr Theorie. Daher dieser Artikel in dem ich – zugegeben – langweilige Theorie, aber eben auch Grundlagen der Programmierung mit einer Skriptsprache vermitteln möchte. Aber keine Sorge, ich versuche die Texte möglichst praxisnah und leichtverständlich zu schreiben.

Eine kleine Anmerkung

Ich möchte hier nicht die siebenundzwanzigste Sammlung von Erklärungen der Fibaro Funktionen in einem Artikel veröffentlichen. Dazu gibt es mehr als genug Informationen im Netz. Auch wird Der Artikel bei Weitem nicht alles abdecken was mit LUA möglich ist, aber es sollte reichen um Dir zu ermöglichen komplexe Dinge mit dem HC2 zu realisieren. Über Anmerkungen, Kritik und Ergänzungen freue ich mich und arbeite diese gern in den Artikel ein.

Das Handwerkszeug

Die ersten Ideen für tolle Szenen kommen den meisten Usern kurz nach dem Kauf des Home Center 2 und so machen sich viele dran den Editor im Webinterface mit allerhand Code zu füllen. Dies ist – für den Start – eine durchaus praktikable Möglichkeit sich mit dem System vertraut zu machen. Das Ergebnis sind aber meist viele kleine und wenig robuste Insellösungen.

Für den Start der Entwicklung einer Szene empfehle ich immer Papier und Bleistift zur Hand zu nehmen. Sich also Notizen machen was die Szene bewirken soll. So ist es leichter den roten Faden während der Programmierung nicht zu verlieren und das Ziel immer vor Augen zu haben.

Ist erstmal ein wenig Erfahrung mit der Programmierung vorhanden kann auf den Einsatz von Papier und Bleistift gut und gerne verzichtet werden. Ich selbst mache es aber noch heute so, dass ich mir erst ein Konzept erstelle und dann mit der Programmierung beginne. So lassen sich Stolperfallen von vornherein umgehen und die Ergebnisse werden einfach deutlich besser. Aber nun zu Lua.

Was ist LUA?

LUA wurde 1993 von der Computer Graphics Technology Group der Päpstlichen Katholischen Universität von Rio de Janeiro entwickelt und ist freie Software.

Lua (portugiesisch für Mond) ist eine imperative und erweiterbare Skriptsprache zum Einbinden in Programme, um diese leichter weiterentwickeln und warten zu können. Eine der besonderen Eigenschaften von Lua ist die geringe Größe des kompilierten Skript-Interpreters.

Bitte was? Für einen Laien stecken allein in der Einleitung zum Wikipedia Artikel zu LUA mindestens fünf neue Fragen ohne auch nur eine einzige beantwortet zu haben.

Für Jemanden der „nur“ Szenen für sein HC2 entwickeln möchte ist es egal, ob die Skript-Interpreter nun groß oder klein und die Sprache leicht erweiterbar ist. Eine im Fibaro Umfeld wichtige Information steckt jedoch in dieser Einleitung. Bei LUA handelt es sich um eine Skriptsprache. In der Programmierung zeichnen sich Skriptsprachen dadurch aus, dass sie von einem Interpreter eingelesen, analysiert, ausgeführt und nicht kompiliert werden. Schon wieder diese Fachbegriffe. Ich versuche es verständlich zu erklären.

Der LUA Interpreter Deines HC2 ist ein ausführbares Programm welches die Szenen im Klartext entgegen nimmt, diese analysiert und ausführt. Die Szene selbst wird nicht erst durch einen Compiler zu einem  ausführbaren Programm, sondern wird durch den Interpreter ausgeführt. Er ist die Schnittstelle zwischen Soft- und Hardware. Für kleine Programme – und nichts Anderes sind LUA Szenen – werden oft Skriptsprachen herangezogen um die Aufwände in Programmierung und Kompilierung zu minimieren. Weitere Vorteile von LUA sind die Plattformunabhängigkeit sowie die hohe Geschwindigkeit.

Skriptsprachen zeichnen sich also dadurch aus, dass der Interpreter das ausführt was geschrieben steht. Er führt exakt aus was in den Szenen geschrieben steht. Die erste Zeile Deiner Szene wird als erstes ausgeführt und die letzte zuletzt. Die Chronologie einer Fibaro Szene ist also von „oben nach unten“.

Operatoren

Wie jede Programmiersprache braucht auch LUA Operatoren die festlegen wie bestimmte Operationen im Code zu hinterlegen sind und diese bei der Ausführung interpretiert werden. Für Fibaro Szenen sind die Operatoren für Grundrechenarten und Vergleiche die wichtigsten. Weiterhin gibt es Verknüpfungsoperatoren.

Grundrechenarten

Grundrechenart Operator Beispiel
Addition + a + b = c
Subtraktion a – b = c
Multiplikation * a * b = c
Division / a / b = c
Potenzierung ^ a ^ b = c

Vergleichsoperatoren

Vergleichsart Operator Beispiel
Ist gleich == a == b
Ist ungleich ~= a ~= b
Kleiner als < a < b
Kleiner gleich <= a <= b
Größer > a > b
Größer gleich >= a >= b

Verknüpfungen

Verknüpfung Operator Beispiel
und and a == b and c == d
oder or a == b or c == d

Variablen

In der Programmierung spielen Variablen eine wichtige Rolle. In Variablen werden Werte zwischengespeichert um diese an unterschiedlichen Stellen innerhalb des Programmes wieder verwenden zu können, ohne immer wieder denselben Wert fest im Quellcode zu verankern. Dies fördert neben der Übersichtlichkeit auch die Wartbarkeit.

Möchtest Du beispielsweise in einer Szene einen Dimmer steuern. So wird dessen ID einmal in eine Variable dimmerIDgeschrieben und ist somit an jeder beliebigen Stelle der Szene verfügbar. Soll derselbe Quellcode zum Steuern eines anderen Dimmers verwendet werden, so muss lediglich an einer einzigen Stelle die Variable geändert werden.

Variablen-Typen

Die Definition und Initialisierung einer Variable erfolgt mit LUA durch Zuweisung eines Wertes. Die Bezeichnung der Variable ist dabei (fast) frei wählbar, darf aber nur einmal vorkommen bzw. wird bei erneuter Zuweisung eines Wertes überschrieben. Ausgenommen bei der Benennung von Variablen sind Schlüsselworte der Programmiersprache selbst (if, then, else, function, etc.).


Die vier dargstellten Variablen decken die unter LUA verfügbaren Typen von Variablen ab. Wobei der Inhalt den Typ der Variable bestimmt.

  • textVariableist durch Anführungszeichen (doppelte oder einfache) begrenzter Text
  • numVariableist ein Zahlenwert
  • boolVariableist eine boolesche Variable (true oder false)
  • arrayVariable ist ein Array. Ein Array kann mehrere Werte gleichen Types beinhalten.

Arrays bzw. Tables

Ein Array bzw. in der LUA Sprache eine Table ist eine Variablen die mehrere Werte unabhängig voneinander speichern kann. Dafür wird innerhalb der Table ein sogenannter Index erstellt welcher den Zugriff auf die Einzelwerte ermöglicht. Ein Array wird durch {}-Klammern definiert.


In diesem Array sind also die Werte 77, 30 und 45 gespeichert. Innerhalb der Table wird jeder Wert einer eindeutigen Position zugeordnet, dem sogenannten Index. Index und Wert bilden dabei ein eindeutiges Paar welches der Reihenfolge der Werte in der Definition entspricht. Im Beispiel oben sind diese Pärchen also:

  • Index 1 -> Wert 77
  • Index 2 -> Wert 30
  • Index 3 -> Wert 45

Die Ausgabe einer Table im Debug ist nicht ohne weiteres möglich. Der Versuch der Debug-Ausgabe wird mit dem Hinweis quittiert, dass es sich um eine Table handelt.


Um einzelne Werte der Table auszugeben und zu verwenden muss zusätzlich zum Namen der Variable der Index des gewünschten Wartes mit angegeben werden.

Gesamte Table ausgeben

Während der Entwicklung von Szenen in denen Tables verwendet werden ist es oftmals notwendig den Inhalt dieser zu kontrollieren. Den gesamten Inhalt im Debug-Fenster auszugeben ist mit dem folgenden Code möglich:

Lokale und globale Variablen

Innerhalb von Fibaro Szenen gibt es zwei unterschiedliche Arten von Variablen. Lokale und globale Variablen. Wobei der Begriff „Globale Variable“ im Home Center 2 doppelt belegt ist. Die hier gemeinten globalen Variablen beziehen sich ausschließlich auf Variablen die innerhalb einer Szene gefüllt – und damit definiert – und verwendet werden. Zu den im Webinterface erstellbaren „Globalen Variablen“ komme ich später.

Eine in einer Szene definierte Variable – beispielsweise die oben erstellte Variable numVariable – ist grundsätzlich global. Wobei global hier bedeutet, dass sie innerhalb der Szene an jeder Stelle verfügbar ist. Eine lokale Variable hingegen ist nur innerhalb ihres Blocks bzw. ihrer Funktion verfügbar und wird mit local gekennzeichnet.

Beispiel globale und lokale Variable:


Um den Unterschied deutlich zu machen ein kleines Beispiel. Ich definiere die Variable textVariablemit dem Wert „Hallo Welt!“ und gebe diese aus (–> stellt die Ausgabe dar)


Nun erstelle ich eine Funktion in der ich einer lokalen Variable mit demselben Namen einen den Wert „Servus Welt!“ zuordne.


Obwohl innerhalb der do-Funktion der Variable textVariable ein anderen Wert zugewiesen wurde, wird dieser nicht global gespeichert, sondern hat nur innerhalb der Funktion mit dem Wert „Servus Welt!“. gibt man die Variable dort zusätzlich aus wird der Wert der lokalen – nur innerhalb der Funktion gültigen – Variable ausgegeben.

Einmal lokal, immer lokal

Der Zustand lokal und global einer Variablen bleibt erhalten. Ist eine Variable in einer Szene einmal als lokal definiert, so ändert auch eine spätere Wertzuweisung ohne den local Zusatz nichts daran.


Merke: Jede einmal als lokal definierte Variable bleibt eine lokale Variable! Bei der Erstellung von Fibaro Szenen ist es im Normalfall nicht notwendig lokale Variablen zu erstellen. Gerade am Anfang ist es sinnvoll ausschließlich globale Variablen zu definieren um die Verwendung der gespeicherten Werte nicht unnötig kompliziert zu machen.

If-Then-Else Bedingungen

Die ersten eigenen Szenen werden sich darauf beschränken Geräte ein- und auszuschalten. Das ist auch gut so, jedoch gelangt man schnell an den Punkt Aktionen in Abhängigkeit von Bedingungen realisieren zu wollen. Beispielsweise ist es wenig sinnvoll das Licht einzuschalten während die Sonne Dich blendet. Um in einer Szene auf Entscheidungen basierend reagieren gibt das If-then-else (Wenn-Dann-Sonst) Konstrukt.

Neben wir an, das Licht im Badezimmer soll nur eingeschaltet werden, wenn die Helligkeit (Lux) im Raum unter 100 Lux ist. Diese Bedingung wird mit If-Then-Else abgebildet:


Zuerst werden die IDs der beteiligten Geräte in Variablen geschrieben. Hier luxID und switchID. In die Variable luxValue wird der aktuelle Helligkeitswert des Fibaro Motion Sensors geschrieben. Wie weiter oben beschrieben stehen uns diese Werte damit an jeder Stelle der Szene zur Verfügung.

In Zeile 5 nun die Bedingung. Intern ist das Ergebnis der Prüfung (Lux Wert kleiner 100) immer ein boolescher Wert, also true oder false. Ist der Lux Wert kleiner 100 ist die Bedingung erfüllt (also true). Das Licht wird eingeschaltet und die Meldung „Licht eingeschaltet“ ausgegeben. Ist zum Zeitpunkt der Prüfung Lux größer als 100, wird die Bedingung nicht erfüllt (also false) und es wird nur die Meldung „Er ist hell genug“ ausgegeben.

If-then-else Bedingungen beinhalten also immer (mindestens) eine Prüfung deren Ergebnis true oder false ist. Das Ergebnis dieser entscheidet dann den weiteren Ablauf der Szene. Für die Bedingungen können alle Vergleichsoperatoren (siehe oben) genutzt werden.

Beispiele:

Weitere Prüfungen

Es gibt noch weitere Möglichkeiten Bedingungen einzusetzen. So lassen sich Bedingungen verknüpfen, verschachteln und auch ein If-Then-Elseif-Konstrukt erstellen.

Verknüpfte Bedingungen

Manchmal reicht eine Bedingung nicht aus. Wenn beispielsweise ein zweiter Lux-Sensor in die Prüfung einbezogen werden soll müssen Bedingungen miteinander verknüpft werden.


Beide Lux Wert werden mit der Verknüpfung and verknüpft und geprüft. Die Bedingung ist also nur wahr, wenn beide Lux Werte kleiner 100 sind. Neben der and können Bedingungen auch mit or verknüpft werden und das Licht eingeschaltet werden, wenn einer der beiden Sensoren einen Wert kleiner 100 liefert.

Verschachtelungen

Nicht immer reicht eine Bedingung aus um das gewünschte Ergebnis zu erreichen. In unserem Badezimmer könnte es ja sein, dass das Licht nicht eingeschaltet werden muss, da es bereits eingeschaltet ist. Für derartige Fälle kann man If-Bedingungen verschachteln.

If-Then-Elseif-Else

Die Prüfung mehrerer Bedingungen lässt sich weiterhin mit If-Then-Elseif Bedingungen abfragen. Angenommen das Badezimmer verfügt über eine zweite Lampe. Diese soll eingeschaltet werden, wenn es trotz eingeschalteter erster Lampe nicht hell genug im Bad ist.

Boolesche Variable

Zu guter Letzt lassen sich auch boolesche Variablen als Bedingung verwenden. Hier ist jedoch Vorsicht geboten.


Wenn die Variable a den Wert true hat, ist diese einfache Bedingung wahr und es wir „a ist true“ ausgegeben. Wobei dies nur die halbe Wahrheit ist. Die oben erwähnte Einfachheit der Definition von Variablen zwingt uns hier aufmerksam zu sein. Die Variable a kann per Definition jeden Wert enthalten. Also Text, eine Zahl oder eben true/false. Die hier dargestellte Prüfung ist immer wahr, solange a definiert ist, also irgendeinen Wert enthält.

Schleifen

Es gibt zwei unterschiedliche Arten von Schleifen in LUA. Die while- und die for-Schleife.

while-Schleifen

Eine while-Schleife wiederholt eine Anweisung solange bis eine definierte Bedingung erfüllt ist. Im folgenden Beispiel wird für jeden Durchlauf der Schleife ein Wert ausgegeben und anschließend eine 1 addiert.


Ausgabe der Schleife


a  wird also hochgezählt und ausgegeben solange a  kleiner als 10 ist.

Der Einsatz derartiger Schleifen ist sinnvoll, wenn Aktionen (hier a) solange ausgeführt werden sollen bis eine Bedingung erfüllt ist. Ein kleines Beispiel:


Diese Schleife gibt einmal die Sekunde den Text „Die Lampe 1 im Badezimmer ist eingeschaltet“ aus, bis die Bedingung nicht mehr wahr ist. Also die Lampe ausgeschaltet wurde.

for-Schleife

In Fibaro Szenen weitaus häufiger verwendet wird die for-Schleife. Im Gegensatz zur while-Schleife ist hier vorher bekannt, wie viele Durchläufe stattfinden.


Ausgabe der Schleife


for-Schleifen benötigen 2 (+ 1 optionalen) Parameter bzw. Variablen um zu funktionieren.

  • Startwert: a = 1
  • Zielwert: 10
  • (Optional: Inkrement)

Beim ersten Durchlauf der Schleife ist a = 1, beim zweiten ist a = 2, usw. Diese Variable – auch Index genannt – steht innerhalb der for-Schleife zur Verfügung und dient unter Anderem dem Zugriff auf dem Inhalt von Tables.
Der dritte Parameter bestimmt den zur Startvariable zu addierenden Wert. Wird er nicht angegeben ist er stets 1 was in Szenen meist der Fall ist.

Zum Einsatz kommen for-Schleifen wenn wiederkehrende Aktionen für eine definierte Anzahl Objekte bzw. Aktoren durchgeführt werden sollen. Ein kleines Beispiel:


#switchIDs beinhaltet die Anzahl der Objekte im Array #switchIDs. In diesem Fall also 2, da das Array die IDs 96 und 178 umfasst. Die for-Schleife schaltet beide Aktoren nacheinander aus.

Verwendung von Schleifen

Bisher sind in unserem Badezimmer nur einzelne Aktionen durchgeführt worden. Es sewurden Lichter eingeschaltet, wenn entsprechende Bedingungen erfüllt waren. Alle Operationen der Szenen wurden – wie in der Einleitung beschrieben von „oben nach unten“ – genau einmal ausgeführt.

Nun soll das Licht im Badezimmer nach 60 Sekunden wieder ausgeschaltet werden. Die erste Idee dies zu tun ist vermutlich die Szene nach dem Einschalten des Lichtes 60 Sekunden pausieren zu lassen und dann die Aktionen zum Ausschalten auszuführen.


Da während des andauernden „Schlafes“ der Szene (Sleep) keine weiteren Aktionen durchgeführt werden können und somit der Status der Szene auf den ersten Blick nicht zu erkennen ist, liefert diese Lösung zwar den gewünschten Effekt, ist aber nicht sonderlich smart. Deutlich smarter ist hier die Verwendung von Schleifen. Denn, wie oben beschrieben, ist der Einsatz von Schleifen immer dann sinnvoll, wenn es wiederkehrende Dinge zu tun gib. In diesem konkreten Fall soll sechzig mal eine Sekunde gewartet werden bevor die Lampen im Badezimmer wieder ausgeschaltet werden. Um dies zu realisieren wird eine while-Schleife für die Bestimmung der 60 Sekunden sowie eine for-Schleife zum Ausschalten der Lampen benötigt.

while-Schleife mit Timer

Um das Licht 60 Sekunden eingeschaltet zu lassen wird eine while-Schleife benutzt.


Die Schleife erzeugt bei jedem Durchlauf eine Debug-Meldung, addiert 1 zur Variable a und wartet anschließend 1000 Millisekunden. Sobald a den Wert 60 erreicht, ist die Bedingung erfüllt und die Schleife wird beendet. Hier die Ausgabe der while-Schleife:


Im Gegensatz zur 60 sekündigen Pause haben wir bei dieser Variante des Timers stets einen Überblick über den Verlauf der Szene.

for-Schleife zum Ausschalten des Lichtes

Die benötigte for-Schleife wird zum ausschalten des Lichtes verwendet und soll nach Ablauf der definierten 60 Sekunden ausgeführt werden.

Badezimmer-Licht-Steuerung mit Schleifen und Timer

In unsere Badezimmer-Licht-Steuerung integriert sieht es dann so aus:


Wird die Szene gestartet und der Lux-Wert liegt unterhalb von 100 werden die Lampen (IDs 96 und 178) mit der ersten for-Schleife eingeschaltet. Mit der while-Schleife wird der 60 Sekunden-Timer gestartet nach dessen Ablauf die zweite for-Schleife beide Lampen wieder ausschaltet.

Funktionen

Um Code innerhalb einer Szene wiederverwendbar zu machen lassen sich in LUA Szenen Funktionen erstellen. Funktionen sind sozusagen kleine Programmteile die – ähnlich der Variablen – vor ihrer Verwendung definiert werden und dadurch an (fast) jeder Stelle der Szene wiederverwendet werden können. Weiterhin können Variablen an Funktionen übergeben werden um diese innerhalb der Szene verwenden zu können. Neben der Wiederverwendung von Code fördern Funktionen die Übersichtlichkeit und Wartbarkeit von Szenen.

Funktion definieren

Um zu verdeutlichen wie sinnvoll der Einsatz von Funktionen ist, ein kleines Beispiel mit Bezug zur Badezimmer Szene. Mit der folgenden Funktion werden alle Lampen im Badezimmer geschaltet. Und zwar abhängig vom Inhalt der Variable turn ein oder aus:


Mit dem Schlüsselwort function wird eine Funktion mit dem Namen switchLights definiert. Die Funktion nimmt die Variablen IDsund turn entgegen um diese innerhalb der Funktion verwenden zu können. In unserem Beispiel die Table mit den IDs der Lampen (96 und 178) sowie die durchzuführende Aktion („turnOn“ oder „turnOff“). An Funktionen übergebene Variablen behalten ihre Gattung (Text, Nummer, Bool oder Table).

Wichtig ist die Positionierung der Funktionen innerhalb der Szene. Sie müssen vor (also oberhalb) ihrem Aufruf definiert sein, damit sie verwendet werden können.

Funktionsaufruf

Der Aufruf einer Funktion erfolgt über den definierten Namen unter Berücksichtigung der von der Funktion erwarteten Variablen Im Beispiel also IDs und turn.


Der Code zum Schalten der Aktoren ist deutlich kürzer geworden und sollten sich einmal Änderungen ergeben ist diese nur innerhalb der Funktion durchzuführen.

Integration in Szenen

Richtig deutlich wird die Vereinfachung des Quellcodes innerhalb der kompletten Szene.

Fibaro Funktionen

Das Home Center 2 stellt eine ganze Reihe von Funktionen für die Interaktion mit Z-Wave Modulen und virtuellen Geräten zur Verfügung.

Eine sehr gute Übersicht über diese Funktionen ist auf der Fibaro UK Seite zu finden.

Szenen starten

Das Home Center bietet unterschiedliche Möglichkeiten Szenen zu starten. Diese können manuell, automatisch und durch die Veränderung von Geräte-Eigenschaften und globalen Variablen gestartet werden.

Die Kopfzeile

Im oberen Teil einer jeden LUA Szene befindet sich der sogenannte Head. In diesem wird definiert zu welchen Gegebenheiten eine Szene gestartet werden soll. Dieser besteht aus einzelnen oder allen der folgenden Zeilen:

Manuelles Starten von Szenen

Fibaro LUA Szenen lassen sich im Webinterface, per LUA sowie aus den Apps für mobile Geräte manuell starten. Hierfür einfach den Play- bzw. Run-Button in den unterschiedlichen Interfaces bedienen.

Autostart Szenen

Um mit Hilfe von Szenen einmalige Schritte und/oder Konfigurationen – beispielsweise das Füllen einer globalen Home Center Variable – zeitgesteuert auszuführen sind diese mit der Autostart Funktion zu versehen:


Durch diesen Eintrag werden Szenen beim Speichern und Systemstart automatisch gestartet. Zeitgesteuerte Szenen sind so programmiert, dass sie in einer Dauerschleife laufen. Mit Hilfe einer If-Bedingung wird bei jedem Durchlauf die aktuelle Systemzeit mit der innerhalb der Szene definierten Startzeit verglichen. Ist die Uhrzeit erreicht wird die Aktion durchgeführt. Nach Durchführung der gewünschten Aktionen bleibt die Szene in der Dauerschleife und wartet erneut auf das Erreichen der Startzeit.


In diesem Beispiel wird Tag um 10:35 Uhr der Text „Startzeit erreicht. Es ist 10:35 Uhr“ im Debug-Fenster der Szene ausgegeben. Zur Erstellung einer solchen zeitgesteuerten Szene werden zwei Funktionen benötigt. Die Funktion timerFunction() überprüft das Erreichen der Startzeit. Diese und die daraus folgenden Aktionen können frei definiert werden. Die zweite zu verwendende Funktion setTimeout() wird vom HC2 zur Verfügung gestellt und sorgt dafür, dass die Funktion timerFunction() alle 60 Sekunden (Also 60 * 10000 Millisekunden) ausgerufen wird.

Start durch Geräte-Eigenschaften

Jeder Sensor und jeder Aktor im Fibaro Home Center hat eine ganze Reihe von Eigenschaften. Diese beinhalten neben den statischen Werten wie Hersteller, Version, ParentID, etc. auch Eigenschaften die den aktuellen Zustand wiedergeben. So verfügt ein Thermostat über die Eigenschaft Temperatur, ein Dimmer über ein Ein/Aus-Eigenschaft und ein Motion Sensor hat eine Eigenschaft in der die Erkennung von Bewegung signalisiert wird.

Die Änderung solcher Eigenschaften wird Auslöser sog. Trigger für Szenen verwendet. Dies sieht bei einem Motion Sensor (ID 59) in der Kopfzeile einer Szene folgendermaßen aus:


Unter dem Punkt properties wird die Gerät-ID sowie die sich ändernde Eigenschaft angegeben. In diesem Fall wird also die Eigenschaft „value“ des Motion Sensors mit der ID 59 überwacht. Die Eigenschaft „value“ kennt die Werte 1 (Bewegung erkannt) sowie 0 (keine Bewegung erkannt).

Der Trigger in die Badezimmer-Szene integriert haben wir eine Lichtsteuerung welche das Licht bei Bewegung für 60 Sekunden einschaltet.


Beim Betreten des Badezimmers und der damit verbundenen Auslösung des Motion Sensors wird die Szene gestartet und schaltet in Abhängigkeit von der Helligkeit im Raum das Licht ein und nach 60 Sekunden wieder aus.

Badezimmer Lichtszene komplett

Die entstandene Szene für das Badezimmer ist noch nicht wirklich smart. Das Licht schaltet sich unabhängig davon ob die Bewegung andauert oder nicht nach 60 Sekunden ab. Mit einer weiteren Prüfung des Bewegungsmelders wird dies verhindert. Dafür wird der 60 Sekunden Timer bei erneuter Bewegung zurückgesetzt.

Feedback und weitere Artikel

Das war es fürs Erste. Der Artikel ist doch länger etwas länger geworden und sicher sind nicht alle Aspekte der LUA Entwicklung eingeflossen. Gern ergänze ich den Artikel oder schreibe weitere, wenn noch etwas fehlt. Dafür und für jede Form der Kritik und Anregung bitte die Kommentarfunktion verwenden.

Der Autor

Moin, ich heiße Bastian und bin Autor dieser kleinen bescheidenen Seite. Zwanghaft, ja fast schon neurotisch beschäftige ich mich seit Jahren mit jedem erdenklichen technischen Schnick-Schnack. Nichts, was einen Stecker hat ist vor mir sicher. So war es klar, dass ich eines Tages das Haus auf den Kopf stellen und alles vernetzen würde.

Da ich bei meinem Vorhaben sehr viel Hilfe und Unterstützung in diversen Foren, Blogs und Boards erfahren habe, möchte ich diesen Blog zum sammeln meiner Smarthome- und Technikerrungenschaften nutzen um der Community zumindest ein klein wenig was zurückgeben zu können.

Artikel teilen