Halbautomatische Beschattung

[bwurst]

Hallo,

ich überlege grade, wie ich am besten vorgehen soll um eine Verschattung mit "Automatik auf Knopfdruck" hin zu bekommen.

Folgende Ausgangslage: Offene Küche/Esszimmer/Wohnzimmer. Dabei eine lange Fassade nach Westen mit drei Fenstern. Alle Fenster haben Raffstores. Wenn man abends auf dem Sofa sitzt, dann scheint je nach Jahres-/Uhrzeit durch eines der Fenster in Esszimmer oder Küche die untergehende Sonne ins Wohnzimmer. Immer alles verdunkeln ist unattaktiv, daher haben wir momentan einen 8-fach-Taster am Sofa so belegt, dass alleine drei Taster per Ein-Taster-Jalousiesteuerung für die drei in Frage kommenden Jalousien verballert werden. Das ist nicht wirklich smart und keiner kann sich wirklich merken welcher Taster für welche Jalousie ist.

Meine Idee wäre jetzt, eine Funktion in OpenHAB einzubauen, die auf Kommando ausgelöst wird (per Strommessung am Fernseher oder per Taster) und dann den Sonnenstand berechnet (Astro-Modul habe ich schon mal angetestet, es liefert auf jeden Fall mal sinnvolle Werte) und damit berechnet, welches Fenster verschattet werden muss und welcher Lamellenwinkel angebracht ist. Die passenden Winkel müssten dann vermutlich im Code fest eingetragen sein.

Hat jemand ein ähnliches Feature mal verwirklicht? Ich habe bisher noch nichtmal herausgefunden wie ich in OpenHAB überhaupt eine Funktion hinterlege, die ich dann vom KNX aus aufrufen kann, auch dafür wäre ein Link auf ein Beispiel nett...

Gruß,
Bernd

[udo1toni]

Grundsätzlich werden Automatismen in openHAB in Rules programmiert. Rules werden über Trigger ausgelöst. In Deinem Fall müsste eine Rule regelmäßig die Zeitpunkte errechnen, zu denen Deine Raffstores fahren sollen. Diese Zeitpunkte werden dann verwendet, um Timer zu starten, die wiederum die Raffstores verfahren.

Alternativ kann eine Rule in relativ kurzen Abständen überprüfen, ob sich die Sonne aktuell innerhalb des "verbotenen" Bereichs befindet und entsprechend die Raffstores verfahren.

Wenn die Automatik nur unter bestimmten Umständen wirken soll (z.B. Dein Taster), gäbe es dann eine Bedingung, die abgefragt wird, bevor die Raffstores verfahren werden.
Ein Problem bei Variante eins ist: Was passiert, wenn Dir einfällt,, dass die Automatik jetzt scharf sein soll, aber der Zeitpunkt zum Verfahren schon vorbei ist? Eventuell wäre es also am geschicktesten, ein paar Items zu definieren, die immer automatisch gesteuert werden, und falls die Automatik eingeschaltet wird, werden die Raffstores mit diesen "leeren" Items synchronisiert.

Ein Problem bei Variante zwei ist, dass die Rule mutmaßlich mindestens minütlich aufgerufen werden muss (eventuell nur innerhalb eines bestimmten Zeitfensters), die Rule also recht häufig sinnlos gestartet wird.

[bwurst]

Hallo.

Danke schonmal für die konkreten Begriffe, das hilft beim Suchen.

Gibt es keine Möglichkeit, einfach die Rule einmalig bei Tastendruck auszulösen? Also keine regelmäßige Nachführung sondern nur "Jetzt verschatten". Wenn die Sonne weiter zieht, könnte ich auf den Taster nochmal drauf drücken, aber ich denke nicht, dass das oft vorkommt, so lange schauen wir nicht fern bei Tag.

[udo1toni]

Ja, das ist kein Problem, ist dann halt keine Automatik
So etwas sieht dann ungefähr so aus:
.items:

Group gBeschattung
Switch beschattung "Beschattung ist [%s]" <rollershutter> {knx="1/1/1+<1/1/2"}
Rollershutter shutter1 "Beschattung 1 [%d %%]" (gBeschattung) {knx="1/2/1+<1/2/2,1/2/11,1/2/21+<1/2/22"}
Rollershutter shutter2 "Beschattung 2 [%d %%]" (gBeschattung) {knx="1/2/3+<1/2/4,1/2/13,1/2/23+<1/2/24"}
Rollershutter shutter3 "Beschattung 3 [%d %%]" (gBeschattung) {knx="1/2/5+<1/2/6,1/2/15,1/2/25+<1/2/26"}

Wir haben also fünf Items, das erste Item ist eine Gruppe (die Rollershutter sind in dieser Gruppe zusammengefasst), ein Item, über das der Tastendruck von knx-Seite empfangen wird und drei weitere Items für die drei Beschattungen. Die GA sind wie folgt definiert:
im Switch ist die erste GA diejenige, über die geschaltet wird. die zweite GA (mit dem +<) ist diejenige, über die der aktuelle Zustand abgefragt wird, wenn openHAB startet. Falls über diese GA eine Kommando reinkommt, wird das auch ausgewertet, openHAB wird aber nicht auf dieser Adresse Befehle an knx senden.
im Rollershutter gibt es drei Gruppen, die erste ist für Auf/Ab, die zweite für Stopp (bzw Step/Move), die dritte für die Absolutposition. Wie beim Switch ist die jeweils zweite GA einer Gruppe nur zum Empfangen der Status und das < sorgt für eine aktive Abfrage der Status beim Start von openHAB.

.rule:

rule "beschattung"
when
    Item beschattung received command                             // Die Rule triggert, wenn von knx ein Schaltsignal kommt
then
    if (receivedCommand == ON) {                                  // Wenn die Beschattung aktiviert wird
        gBeschattung?.members.forEach(m|m.sendCommand(DOWN))      // fahre alle Gruppenmitglieder abwärts
        createTimer(now.plusSeconds(15), [|                       // erzeuge einen Timer, 15 Sekunden in der Zukunft
            gBeschattung?.members.forEach(m|m.sendCommand(STOP))  // Wenn der Timer abgelaufen ist, stoppe alle Gruppenmitglieder
        ]
        )
    }
    else                                                          // wenn die Beschattung deaktiviert wird
        gBeschattung?.members.forEach(m|m.sendCommand(UP))        // fahre alle Gruppenmitglieder hoch (da kein Stoppbefehl, obere Endlage)
end

Konkret müsstest Du also ausmessen, wie lange die Jalousien nach unten fahren müssen, um wunschgemäß zu beschatten. Diese Zeit muss dann im Timer eingetragen werden. Der Code ist sehr einfach gehalten und berücksichtigt einige Dinge nicht, z.B. könntest Du unterwegs auf die Idee kommen, dass Du keine Beschattung willst. sagen wir, Du drückst nach 10 Sekunden die Taste zum 2. Mal. Die rule ändert also sofort die Fahrtrichtung, aber der Timer läuft weiter. nach 5 Sekunden kommt also ein Stoppsignal und die Jalousien bleiben stehen, obwohl sie noch nicht oben angekommen sind (natürlich kann man das abfangen ).

Wenn Du ohnehin knx einsetzt, könnte eine andere Herangehensweise einfacher sein, und zwar könntest Du Beschattungsszenen definieren (die werden direkt in den Aktoren gespeichert), wenn Du einen Aktor mit Positionsrückmeldung hast, musst Du von openHAB aus nur noch die gewünschte Szene aufrufen, das ginge auch per rule sehr einfach (Du könntest mit einem Taster durch die verschiedenen Szenen blättern, also Tastendruck -> Szene 1, Tastendruck -> Szene 2, Tastendruck -> Szene 3, Tastendruck -> Szene 4, Tastendruck -> Szene 1...

[bwurst]

Hallo.

Herzlichen Dank für die konkreten Codebeispiele!!

Ja, mit KNX kann ich entweder mit Szenen oder (was ich jetzt spontan bevorzugen würde) mit absoluten Positionen arbeiten. Also die Jalousie die gemäß Berechnung benötigt wird dann auf einen festen Wert fahren. Das denke ich kann ich per trial&error herausfinden.

Jetzt hab ich mal einiges an Input und kann mich da mal dran setzen, vielen Dank!

[bwurst]

So, ich habe jetzt eine ähnliche Regel in OpenHAB eingebaut. War sogar einfacher als gedacht.

Idee ist: Ein Knopf sendet ein "ON" bei jedem Tastendruck und ein "OFF" bei langem Tastendruck. Immer wenn ich Verschattung haben will, dann wird die erste Regel angestoßen, wenn ich sie nicht mehr haben will, die zweite. Die lässt dann alle Rollos hoch, die auf der Position der ersten Regel angefahren wurden.

Die Regel verschattet den Esstisch, d.h. wenn man sich tagsüber an den Esstisch setzen möchte und die Sonne prall scheint, dann wird der Knopf gedrückt und die jeweils passende Jalousie wird auf einen absoluten Wert gefahren. Die Azimuth-Werte sind für unsere Ausrichtung und damit die jeweils passenden Winkel für die beteiligten Fenster.

rule "Verschattung Esstisch"
when
    Item Szene_Verschattung_Esstisch received command ON
then
    var int azimuth = (Azimuth.state as DecimalType).intValue
    var int elevation = (Elevation.state as DecimalType).intValue
    var int lamellen = 60
    if (elevation < 40) {
        lamellen = 70
    }
    if (elevation < 25) {
        lamellen = 80
    }
    if (elevation < 10) {
        lamellen = 90
    }
    if (elevation < 5) {
        lamellen = 100
    }
    if (azimuth > 80 && azimuth < 130 && elevation > 0) {
        sendCommand(Jal_Wohnzimmer_Lamellen, lamellen)
        sendCommand(Jal_Wohnzimmer, 90)
        // Wohnzimmer-Fenster
    }
    if (azimuth > 100 && azimuth < 210 && elevation > 0) {
        sendCommand(Jal_Esszi_S_Lamellen, lamellen)
        sendCommand(Jal_Esszi_S, 90)
        // Esszimmer Süd
    }
    if (azimuth > 185 && azimuth < 290 && elevation > 0) {
        sendCommand(Jal_Esszi_W_Lamellen, lamellen)
        sendCommand(Jal_Esszi_W, 90)
        // Esszimmer Fenster West
    }
    if (azimuth > 260 && azimuth < 350 && elevation > 0) {
        sendCommand(Jal_Esszi_Tuer_Lamellen, lamellen)
        sendCommand(Jal_Esszi_Tuer, 90)
        // Esszimmer Tür
    }
end

rule "Verschattung Esstisch beenden"
when
    Item Szene_Verschattung_Esstisch received command OFF
then
    if (Jal_Wohnzimmer.state > 86 || Jal_Wohnzimmer.state < 94) {
        sendCommand(Jal_Wohnzimmer_Lamellen, 0)
        sendCommand(Jal_Wohnzimmer, 0)
        // Wohnzimmer-Fenster
    }
    if (Jal_Esszi_S.state > 86 || Jal_Esszi_S.state < 94) {
        sendCommand(Jal_Esszi_S_Lamellen, 0)
        sendCommand(Jal_Esszi_S, 0)
        // Esszimmer Süd
    }
    if (Jal_Esszi_W.state > 86 || Jal_Esszi_W.state < 94) {
        sendCommand(Jal_Esszi_W_Lamellen, 0)
        sendCommand(Jal_Esszi_W, 0)
        // Esszimmer Fenster West
    }
    if (Jal_Esszi_Tuer.state > 86 || Jal_Esszi_Tuer.state < 94) {
        sendCommand(Jal_Esszi_Tuer_Lamellen, 0)
        sendCommand(Jal_Esszi_Tuer, 0)
        // Esszimmer Tür
    }
end

Mit der Verwaltung der Lamellenführung als separates Rollershutter-Objekt bin ich ziemlich unzufrieden, aber in dem Fall ist es dafür benutzbar.