Rolladensteuerung in FHEM mittels DOIF-Modul

Nachdem ich im letzten Artikel die Umsetzung eines Weckers mit dem FHEM DOIF-Modul dargestellt habe, kommt nun ein weiteres kleines Beispiel mit DOIF. Nachdem ich die Funktion von DOIF nun immer besser kennen gelernt und verstanden habe, werde ich wahrscheinlich noch einige andere Funktionen damit umsetzen. Die nachfolgend erläuterte Rolladensteuerung hilft euch vielleicht auch für ähnliche Ansätze mit dem DOIF-Konstrukt.

Meine aktuelle Infrastruktur

[aartikel]B007SVHYF8:left[/aartikel]Bisher habe ich die Rolladensteuerung mit unterschiedlichen Modulen (notify, at, eigene Funktionen) umgesetzt. Ziel war es nun, die gesamte Steuerung über DOIF-Konstrukte umzusetzen und zusätzlich noch um einige Funktionen zu erweitern. Hierbei werden 2 Rolladen in der Küche (Homematic), 4 Rolladen im Wohnzimmer (Somfy RTS), zwei weitere Somfy Rolladen im Erdgeschoss sowie eine Rollade im Schlafzimmer (Homematic) angesteuert.

Zusätzlich habe ich im Wohnzimmer an zwei Fenstern, im Schafzimmer und im WC im Erdgeschoß einen Fensterkontakt installiert. Im Wohnzimmer sind es noch die Magnetkontakte von Homematic, ansonsten habe ich die optischen Modelle verwendet. Diese Fensterkontakte sind jetzt u.a. auch der Grund für die Erweiterung der Rolladensteuerung. So soll im Wohnzimmer sicher gestellt werden, dass die Rolladen nicht herunter fahren, wenn die Terrassentüren offen sind und zusätzlich habe ich eine Lüftungssteuerung eingebaut. Wenn bei geschlossenen Rolladen die Fenster geöffnet werden, dann wird die entsprechende Rollade auf eine Lüftungsposition gefahren.

Die simpelste Form der Rolladen-Steuerung

Die wohl einfachste Form der Rolladensteuerung ist es, die Rolladen zu einer bestimmten Zeit hoch- bzw. runter zu fahren. Hierzu können entweder feste Uhrzeiten oder die Funktionen für Sonnenaufgang und Sonnenuntergang verwendet werden. Zur vereinfachten Ansteuerung der Rolladen nutze ich entsprechende Structure-Definitionen in denen ich die Rolladen gruppiere.

Ein mögliches DOIF-Konstrukt für die einfache Steuerung sieht dann wie folgt aus:

##Rolladen sind zwischen Sonnenuntergang und Sonnenaufgang geschlossen, sonst auf
([{sunset(-1500, "16:00", "22:00")}]-[{sunrise(+1800, "07:00", "9:00")}])
   (set Alle_Rolladen off)
DOELSE (set Alle_Rolladen on)

Die Rolladen werden also bei Sonnenuntergang herunter gefahren – aber nicht vor 16:00 Uhr, spätestens um 22:00 Uhr und bei Sonnenaufgang wieder hoch gefahren – nicht vor 7:00 Uhr und spätestens um 9:00 Uhr.

In meinem Beispiel kann man an Hand der erstellten Timer erkennt, dass der nächste „runter“ Befehl um 16:48 und der nächste „hoch“ Befehl um 8:24 Uhr ausgeführt wird.

Rolladen frühestens beim Wecken hochfahren

Nun sollen bei uns die Rolladen aber nicht immer schon bei Sonnenaufgang hochfahren, sondern erst ab der eingestellten Weckzeit. Zusätzlich sollen sie aber spätestens um 9:00 Uhr hochfahren, auch wenn kein Wecker gestellt oder die Weckzeit nach 9:00 Uhr sein sollte. Wenn die Weckzeit vor dem Sonnenaufgang liegt, dann bleiben die Rolladen zunächst unten und fahren dann bei Sonnenaufgang hoch.

Das entsprechende DOIF hierzu sieht wie folgt aus, wobei gr_Bewohner der Name für unser Residents-Modul ist.

(([{sunrise(+1800, "06:00", "09:00")} - 9:00] and (["gr_Bewohner"] ne "asleep")) or [09:00])
   (set Alle_Rolladen hoch)
DOELSEIF ([{sunset(-1500, "16:00", "22:00")}])
   (set Alle_Rolladen runter)

Aussperrschutz beim Herunterfahren der Rolladen

[aartikel]B00LFLHZZ6:right[/aartikel]Für die beiden Rolladen im Wohnzimmer, die zu den Terrassentüren gehören, gibt es einen Sonderfall beim Herunterfahren. Dies darf nicht automatisch passieren, wenn die Türen offen sein sollten. Denn dann könnte es sein, dass Personen im Garten ausgesperrt werden.

Zunächst habe ich daher zwei verschiedene Structure-Definitionen angelegt. Die Gruppe „Standard_Rolladen“ umfasst alle Rolladen, bei denen es beim Hoch- oder Runterfahren keine Besonderheiten gibt (hier Aussperrschutz). Für alle anderen Rolladen habe ich eigene DOIF-Anweisungen für das Runterfahren erstellt. Hochgefahren werden alle Rolladen mit der zentralen Rolladensteuerung aus der vorherigen Beschreibung, wobei „set Alle_Rolladen runter“ durch „set Standard_Rolladen runter“ ersetzt wurde.

Das DOIF-Konstrukt muss nun also noch um die Abfrage des Fensterkontakts erweitert werden und sieht dann wie folgt aus:

## 1 Rollade runter, wenn RolladeStatus runter und Fenster geschlossen
([duRolladenStatus] eq "runter" and [wzKontaktSchiebetuer] eq "closed")
   (set wzSchiebetuer_Rollade runter)
##2 Rollade öffnen, wenn Fenster geschlossen wird und die Rolladen alle oben sind
DOELSEIF ([wzKontaktSchiebetuer] eq "closed" and [?duRolladenStatus] eq "hoch")
   (set wzSchiebetuer_Rollade hoch)

Bei der Abfrage des Rolladenstatus in Aktion 2 habe ich das Triggern durch den Rolladenstatus mit einem „?“ ausgeschaltet. Da die allgemeine Rolladensteuerung diesen Status setzt würde die Rollade sonst zweimal das Signal zum Hochfahren bekommen.

Steuerung der Lüftungsfunktion

[aartikel]B00TYM0WGC:left[/aartikel]Bei den Rolladen, die zu einem Fenster mit Fensterkontakt gehören, besteht die Möglichkeit auch noch eine Lüftungsfunktion zu implementieren. Diese wird immer ausgelöst, wenn das Fenster geöffnet wird und die Rollade bereits herunter gefahren ist. Beim Schließen des Fensters wird die Rollade dann wieder runter gefahren oder wenn dies zu einem Zeitpunkt passiert, an dem alle Rolladen bereits hochgefahren sind, wird auch diese Rollade dann hochgefahren.

Das entsprechende Konstrukt ist nachfolgend beschrieben. Zusätzlich habe ich einen Dummy verwendet, der bei der normalen Aktionssteuerung zum Hochfahren der Rolladen auf „hoch“ gesetzt wird und beim Runterfahren auf „runter“. Mit diesem Dummy kann ich dann immer feststellen, welchen Status die Rolladen eigentlich aktuell haben sollten. In der allgemeinen Rolladensteuerung muss also jeweils noch ein „set duRolladenStatus hoch“ bzw. „set RolladenStatus runter“ eingebaut werden.

## 3 Rollade auf lüften stellen, wenn Fenster aufgemacht wird und Rollade runter ist
DOELSEIF ([wzSchiebetuer_Rollade] eq "runter" and [wzKontaktSchiebetuer] eq "open")
(set wzSchiebetuer_Rollade lueften)

Der oben aufgeführte Code wird in das vorhergehende DOIF eingebaut, welches ich für den Aussperrschutz verwendet habe.

Sonderfall Schlafzimmer – Schutz vor Auskühlen

Im Schlafzimmer haben wir dann noch diverse Sonderfunktionen, die es umzusetzen galt. So wird diese Rollade nie automatisch hochgefahren (weil meine Frau meist länger schläft als ich 😉 ). Da dies die einzige Rollade im Obergeschoß ist, habe ich nochmals eine neue Struktur „EG_Rolladen“ angelegt und diese nun in der allgemeinen Steuerung zum Hochfahren verwendet. Die Schlafzimmerollade ist also komplett getrennt von irgendeiner allgemeinen Steuerung.

Die zusätzliche Sonderfunktion habe ich für das morgendliche Lüften des Schlafzimmers eingebaut. Da wir beim Frühstück immer wieder vergessen, dass das Schlafzimmerfenster noch offen ist, kann es im Winter schon mal etwas kühler werden. Man hätte nun eine Sprachansage in die Haussteuerung einbauen können, damit man an das Schließen des Fensters erinnert wird aber ich möchte eigentlich soviel Automatisierung wie möglich nutzen. Daher wird nun nach 5 Minuten die Rollade auf eine Lüftungsposition gefahren. Wenn dann das Fenster wieder geschlossen wird, fährt die Rollade automatisch hoch.

Darüber hinaus habe ich eine Funktion integriert, die beim Öffnen des Fensters dafür sorgt, dass die Rollade am Morgen automatisch hochfährt. Ach ja und der Schutz vor dem Auskühlen darf natürlich nur dann aktiviert werden, wenn das Fenster kurz nach dem Wecken zu Lüftungszwecken geöffnet wurde. Diese Ergänzung ist mir auch erst eingefallen, als meine Frau gefragt hat, was denn passiert, wenn sie das Fenster längere Zeit zum Putzen geöffnet hat 😉 .

## 1 Rollade wird nur im Urlaub bei Sonnenaufgang hoch gefahren (sonst manuell oder durch Fensterkontakt)
([duUrlaub] eq "ja" and [{sunrise(0, "06:00", "09:00")}]
   ## oder Fenster wird nach dem Wecken geöffnet dann Rolladen automatisch hoch
   or ([szKontakt] eq "open" and [gr_Bewohner] ne "asleep" and [szRollade] eq "runter")
   ## wenn das Fenster morgens nach dem Lüften geschlossen wird, Rollade hoch fahren
   or ([szKontakt] eq "closed" and [szRollade] eq "lueften" and [06:00 - {sunset(0,"16:00","22:00")}]))
   (set szRollade hoch)
## 2 Wenn das Fenster länger als 5 Minuten offen ist und die Temperatur ist unter 10 Grad auf Lüftung einstellen
DOELSEIF ([06:00-09:00] and [netatmo_aussen:temperature] < 10 and [szKontakt] eq "open" and [szRollade] eq "hoch")
   (set szRollade lueften)
## 3 Wenn das Fenster geschlossen wird und es ist nach Sonnenuntergang Rollade runter fahren
DOELSEIF ([szKontakt] eq "closed" and [{sunset_abs(0,"16:00","22:00")}-{sunrise(0, "06:00", "09:00")}])
   (set szRollade runter) 

Damit die Rollade 5 Minuten nach Öffnen des Fensters auf die Lüftungsposition fährt, wird noch das Attribut „wait“ benötigt. Mit diesem Attribut wird gesteuert, mit welcher Verzögerung jede einzelne Aktion gestartet wird. Das Attribut wird also auf 0:300:0 gesetzt. Damit wird die erste und dritte Aktion sofort ausgeführt und die zweite Aktion nach einer Wartezeit von 300 Sekunden. Wie man dem Code ansonsten entnehmen kann, wird die Aktion bei mir nur ausgeführt, wenn die Außentemperatur unter 10 Grad liegt.

Zusätzliche Hinweise

Mit den oben vorgestellten Steuerungen sollte man im Prinzip alle denkbaren Varianten abdecken können und sich leicht seine eigenen Zusatzfunktionen einbauen können. Interessant wäre jetzt vielleicht noch eine „Beschattungsfunktion“. Diese könnte man z.B. über die Temperatur regeln.

Bei den Steuerungen sollte man noch darauf achten, dass man ggf. das Attribut „do always“ setzen muss. Insbesondere bei den Schaltungen, wo in einem DOIF nur eine Richtung programmiert wurde. Da kann es dann nämlich passieren, dass diese in einem Status „hängen“ bleibt und auch wenn die definierten Bedingungen zutreffen, sonst nicht nochmal ausgeführt werden.

Weiterhin wäre es evtl. noch sinnvoll bei den Rolladen abzufragen, ob sie sich gerade in Bewegung befinden. Bei den Somfy-Rolladen könnte man das mit dem internen Registerwert „move“ steuern. Bei mir habe ich nur festgestellt, dass dieser aktuell nicht immer den Status „stop“ anzeigt, wenn der Motor sich abschaltet. Die Abfrage könnte dann so aussehen: [RolladeXY:&move] eq „.*stop.*“ (das & nicht vergessen!)

Ansonsten wünsche ich viel Spaß beim Nachbauen und wenn Fragen sind, einfach die Kommentare nutzen.