Rolladen öffnen wenn das Fenster gekippt wird

[domjo75]

Hallo,

ich habe mir eine Rule gebastelt, die den Rollo ein Stück öffnet, wenn das dazugehörige Fenster gekippt wird.
Wird das Fenster wieder geschlossen, fährt der Rollo natürlich wieder komplett runter.

Die Rule ist sicher noch verbesserungswürdig und wird umso aufwendiger, je mehr Rollos man hat.
Zum "Glück" habe ich noch nicht alle Rollos umgebaut

Ich freue mich natürlich über Anmerkungen und Verbesserungen sind jederzeit willkommen.

Code: Alles auswählen

val Number uPosKueche        = 80   // upper  Position Rolladen Küche
val Number cPosKueche        = 95   // closed  Position Rolladen Küche

val Number uPosBuero1        = 80   // upper  Position Rolladen Büro1
val Number cPosBuero1        = 95   // closed  Position Rolladen Büro1

val Number uPosBuero2        = 80   // upper  Position Rolladen Büro2
val Number cPosBuero2        = 95   // closed  Position Rolladen Büro2

val Number uPosBuero3        = 80   // upper  Position Rolladen Büro3
val Number cPosBuero3        = 95   // closed  Position Rolladen Büro3

val Number tPosALL           = 85   // tilt  Position alle Rolladen

rule "Handle Window Covers"
when
    Item KucheFenster_State changed or
    Item BuroFenster1_State changed or
    Item BuroFenster2_State changed or
    Item BuroFenster3_State changed
then
    if(KucheRollo_Level.state >= cPosKueche && KucheFenster_State.state==OPEN) {
        KucheRollo_Level.sendCommand(85)
        logInfo("Handle Window Covers", "Rollo Küche auf Tilt")
    }
    if(BuroRollo1_Level.state >= cPosBuero1 && BuroFenster1_State.state==OPEN) {
        BuroRollo1_Level.sendCommand(85)
        logInfo("Handle Window Covers", "Rollo1 Büro auf Tilt")
    }
    // if(BuroRollo2_Level.state >= cPosBuero2 && BuroFenster3_State.state==OPEN) {
    //     BuroRollo2_Level.sendCommand(85)
    //     logInfo("Handle Window Covers", "Rollo2 Büro auf Tilt")
    // }
    if(BuroRollo3_Level.state >= cPosBuero3 && BuroFenster3_State.state==OPEN) {
        BuroRollo3_Level.sendCommand(85)
        logInfo("Handle Window Covers", "Rollo3 Büro auf Tilt")
    }

    if(KucheRollo_Level.state <= cPosKueche && KucheRollo_Level.state >= uPosKueche && KucheFenster_State.state==CLOSED) {
        KucheRollo_Level.sendCommand(100)
        logInfo("Handle Window Covers", "Rollo Küche schliessen")
    }
    if(BuroRollo1_Level.state <= cPosBuero1 && BuroRollo1_Level.state >= uPosBuero1 && BuroFenster1_State.state==CLOSED) {
        BuroRollo1_Level.sendCommand(100)
        logInfo("Handle Window Covers", "Rollo1 Büro schliessen")
    }       
    // if(BuroRollo2_Level.state <= cPosBuero2 && BuroRollo2_Level.state >= uPosBuero2 && BuroFenster2_State.state==CLOSED) {
    //     BuroRollo2_Level.sendCommand(100)
    //     logInfo("Handle Window Covers", "Rollo2 Büro schliessen")
    // }
    if(BuroRollo3_Level.state <= cPosBuero3 && BuroRollo3_Level.state >= uPosBuero3 && BuroFenster3_State.state==CLOSED) {
        BuroRollo3_Level.sendCommand(100)
        logInfo("Handle Window Covers", "Rollo3 Büro schliessen")
    }
end

[udo1toni]

Die Rule schreit nach einer Optimierung

Die Optimierung beginnt allerdings mit den Items, denn damit die Rule wirklich optimiert werden kann, müssen sich die Namen der Items voneinander ableiten lassen. Wir definieren zwei Group Items, in denen jeweils alle Kontakte und alle Rollershutter zusammengefasst werden. Weiterhin sorgen wir dafür, dass der erste Teil des Namens zwischen beiden Items korrelliert und innerhalb der Gruppe eindeutig ist.

Code: Alles auswählen

Group         gWindowContacts
Group         gRolloLevel
Contact       Kuche_Fenster_State (gWindowContacts)
Contact       Buro1_Fenster_State (gWindowContacts)
Contact       Buro2_Fenster_State (gWindowContacts)
Contact       Buro3_Fenster_State (gWindowContacts)
Rollershutter Kuche_Rollo_Level (gRolloLevel)
Rollershutter Buro1_Rollo_Level (gRolloLevel)
Rollershutter Buro2_Rollo_Level (gRolloLevel)
Rollershutter Buro3_Rollo_Level (gRolloLevel)

Es gibt also für jeden Fensterkontakt ein Rollershutteritem mit dem identischen ersten Namensteil.

Innerhalb der Rule können wir den Namen des Items splitten und die Teilstrings weiterverwenden.
Wir haben in der Rule (bzw. außerhalb der Rule) voreingestellte Grenzwerte, es bietet sich an, diese über eine Hashmap zu definieren.

Anschließend müssen wir innerhalb der Rule nur ein paar simple Berechnungen vornehmen um die Steuerung zu generalisieren. Die Rule muss nun nicht mehr angepasst werden, falls weitere Fenster hinzukommen. Lediglich die Hashmap muss ergänzt werden.

Im Gegensatz zu Deiner Variante wird jeweils nur der Rollladen gesteuert, dessen zugehöriger Fensterkontakt seinen Zustand geändert hat.

Code: Alles auswählen

val Map<String, Number> mapMin = newHashMap ( "Kuche" -> 80,
                                              "Buro1" -> 80,
                                              "Buro2" -> 80,
                                              "Buro3" -> 80
                                            )

val Map<String, Number> mapMax = newHashMap ( "Kuche" -> 95,
                                              "Buro1" -> 95,
                                              "Buro2" -> 95,
                                              "Buro3" -> 95
                                            )

val Map<String, Number> mapTilt = newHashMap ( "Kuche" -> 85,
                                               "Buro1" -> 85,
                                               "Buro2" -> 85,
                                               "Buro3" -> 85
                                             )

rule "Handle Window Covers"
when
    Member of gWindowContacts changed                                                  // Status eines Kontakts geändert
then
    val myName    = triggeringItem.name.split("_").get(1)                              // Identifikator abtrennen und sichern
    val myContact = gWindowContacts.members.filter[i|i.name.startsWith(myName)].head   // ContactItem heraussuchen (man könnte auch triggeringItem nehmen)
    val myRollo   =     gRolloLevel.members.filter[i|i.name.startsWith(myName)].head   // RollershutterItem heraussuchen
    if(myContact.state == OPEN){                                                       // Status auf OPEN geändert
        if(myRollo.state >= mapMax.get(myName))                                        // Rollladen geschlossen
            myRollo.sendCommand(mapTilt.get(myName))                                   // also auf Tilt-Position
            logInfo("windowCovers", "Rollo {} auf Tilt",myName)
    } else {                                                                           // Status auf CLOSED geändert
        if(myRollo.state <= mapMax.get(myName) && myRollo.state >= mapMin.get(myName)) // Rollladen auf Tilt-Position
            myRollo.sendCommand(100)                                                   // also Rollladen schließen
            logInfo("windowCovers", "Rollo {} schließen.",myName)
    }
end

Wichtig ist nur, dass alle Namen zueinander passen und den richtigen Gruppen zugeordnet sind.

[domjo75]

Hi,

ich habe wieder vergessen die Benachrichtigung für neue Antworten zu aktivieren.

Zum Glück habe ich noch nicht so viele Rollos bzw. Rollo-Fensterkontakt Kombinationen. Das macht die Umbenennerei nicht so aufwendig.
Wenn ich das richtig verstehe, ist es erstmal nur wichtig wie der erste Teil des Fensterkontaktes heisst. Findet er einen passenden Rolloschutter dazu, reagiert er.
Interessant wird die Geschichte nämlich dann, wenn ich unser Wohnzimmer/Esszimmer mit Rollos ausstatte. Hier haben wir insgesamt 4 Doppelflügelfenster und eine Terrassentür. Ob ich tatsächlich jeden Flügel mit einem Fenstersensor ausrüste, weiss ich noch nicht.
Meine Namenskonvention habe ich dementsprechend nun so aufgebaut:

Code: Alles auswählen

// Contact Wohnzimmer1_Fenster1_State "Wohnzimmer Fenster1" <contact> (Wohnzimmer) [Status,Opening] {channel="homematic:HM-Sec-SCo:3014F711A0001F9:1#STATE"}
// Contact Wohnzimmer1_Fenster2_State "Wohnzimmer Fenster2" <contact> (Wohnzimmer) [Status,Opening] {channel="homematic:HM-Sec-SCo:3014F711A0001F9:1#STATE"}
Contact Wohnzimmer2_Fenster1_State "Wohnzimmer Fenster3" <contact> (Wohnzimmer) [Status,Opening] {channel="homematic:HM-Sec-SCo:3014F711A0001F9:1#STATE"}
// Contact Wohnzimmer2_Fenster2_State "Wohnzimmer Fenster4" <contact> (Wohnzimmer) [Status,Opening] {channel="homematic:HM-Sec-SCo:3014F711A0001F9:1#STATE"}
Contact WohnzimmerT_Terrassentuer1_State "Wohnzimmer Terrassentür" <contact> (Wohnzimmer) [Status,Opening] {channel="homematic:HM-Sec-SCo:3014F711A0001F9:1#STATE"}

Die passenden Rollo würden dann irgendwann so heissen:

Code: Alles auswählen

Rollershutter Wohnzimmer1_Rollo_Level "Wohnzimmer Rollo 1" <blinds> (gRolloLevel,Wohnzimmer) [Control,Level] {channel="homematic:HM-LC-Bl1PBU-FM:3014F711A0001F9:1#LEVEL"}
Rollershutter Wohnzimmer2_Rollo_Level "Wohnzimmer Rollo 2" <blinds> (gRolloLevel,Wohnzimmer) [Control,Level] {channel="homematic:HM-LC-Bl1PBU-FM:3014F711A0001F9:1#LEVEL"}
Rollershutter WohnzimmerT_Rollo_Level "Wohnzimmer Terrassentür" <blinds> (gRolloLevel,Wohnzimmer) [Control,Level] {channel="homematic:HM-LC-Bl1PBU-FM:3014F711A0001F9:1#LEVEL"}

An der Terassentür käme sogar noch ein 2.Sensor dran, der dann auslöst, wenn die Tür komplett offen ist. Ich möchte ungern, dass mich OH aussperrt, wenn ich abends am Grill stehe und die Sonne geht unter

Alle anderen Rollo´s die nicht mit Fenstersensoren bzw. Fenstersensoren, die nicht mit Rollos verknüpft sind, lasse ich einfach aus den Gruppen "gWindowContacts" und "gRolloLevel" draussen?!

[domjo75]

Ich habe es mal "schnell" umgebaut (also die Namen angepasst).
Leider bekomme ich einen Fehler im LOG

Code: Alles auswählen

2021-02-10 16:18:20.760 [INFO ] [el.core.internal.ModelRepositoryImpl] - Validation issues found in configuration model 'test.rules', using it anyway:
The field Tmp_testRules.mapMax refers to the missing type Object
The field Tmp_testRules.mapTilt refers to the missing type Object
The field Tmp_testRules.mapMax refers to the missing type Object
The field Tmp_testRules.mapMin refers to the missing type Object

Ich habe das Mapping der Rules angepasst (Namen jetzt mit UE) und ich habe im Büro nur 2 Rollos die über Fenstersensoren getriggert werden.

Code: Alles auswählen

val Map<String, Number> mapMin = newHashMap ( "Kueche" -> 80,
                                              "Buero1" -> 80,
                                              "Buero3" -> 80
                                            )

val Map<String, Number> mapMax = newHashMap ( "Kueche" -> 95,
                                              "Buero1" -> 95,
                                              "Buero3" -> 95
                                            )

val Map<String, Number> mapTilt = newHashMap ( "Kueche" -> 85,
                                               "Buero1" -> 85,
                                               "Buero3" -> 85
                                             )

Die Rollos und Fenstersensoren sind so definiert

Code: Alles auswählen

Contact Buero1_Fenster_State                "Büro Fenster1"             <contact> (gWindowContacts,Buero)   [Status,Opening] {channel="homematic:HM-Sec-SCo:3014F711A0001F9A499D:1#STATE"}
Contact Buero3_Fenster_State                "Büro Fenster3"             <contact> (gWindowContacts,Buero)   [Status,Opening] {channel="homematic:HM-Sec-SCo:3014F711A0001F9A499D:1#STATE"}
Contact Kueche_Fenster_State                "Küche Fenster"             <contact> (gWindowContacts,Kueche)  [Status,Opening] {channel="homematic:HM-Sec-SCo:3014F711A0001F9A499D:1#STATE"}

Code: Alles auswählen

Rollershutter Buero1_Rollo_Level "Büro Rollo 1"                 <blinds>    (gRolloLevel,Buero)         [Control,Level] {channel="homematic:HM-LC-Bl1PBU-FM:3014F711A0001F9A4:1#LEVEL"}
Rollershutter Buero3_Rollo_Level "Büro Rollo 3"                 <blinds>    (gRolloLevel,Buero)         [Control,Level] {channel="homematic:HM-LC-Bl1PBU-FM:3014F711A0001F9A4:1#LEVEL"}

Rollershutter Kueche_Rollo_Level "Küche Rollo"                  <blinds>    (gRolloLevel,Buero)         [Control,Level] {channel="homematic:HM-LC-Bl1PBU-FM:3014F711A0001F9A4:1#LEVEL"}

[sonic]

Ich habe das ganze für meine Rolladen rustikal gelöst:

Fenstersensoren sind Aqara

Rolladenaktoren sind mit Tasmota geflashte Sonoff Dual 2ch.

Code: Alles auswählen

rule "Bürofenster AUF"
when
    Item M_BuerofensterDataOpen changed to OPEN
then
        if (AlamanlageStatus.state == "5" && MBueroRolladen.state == 100) {
            MBueroRolladen.sendCommand(70)
        }
end

rule "Bürofenster ZU"
when
    Item M_BuerofensterDataOpen changed to CLOSED
then
        if (AlamanlageStatus.state == "5" && MBueroRolladen.state == 70) {
            MBueroRolladen.sendCommand(100)
        }
end

funktioniert ebenfalls tadellos

[udo1toni]

Hmm... es kann sein, dass man die hashMap importieren muss...

Du müsstest dazu noch vor dem Part mit val Map... die Zeile

Code: Alles auswählen

import java.util.HashMap

einfügen.

[domjo75]

Moin moin,
hat leider nichts gebracht. Im Prinzip können wir die Werte min, max und tilt auch für alle Rollos gleich setzen.
Es sei denn dein Ehrgeiz ist geweckt

[udo1toni]

Ähm... peinlich... ich hab Map geschrieben, aber es muss natürlich HashMap heißen.... also so:

Code: Alles auswählen

import java.util.HashMap

val HashMap<String, Number> mapMin = newHashMap ( "Kueche" -> 80,
                                                  "Buero1" -> 80,
                                                  "Buero3" -> 80
                                                )

val HashMap<String, Number> mapMax = newHashMap ( "Kueche" -> 95,
                                                  "Buero1" -> 95,
                                                  "Buero3" -> 95
                                                )

val HashMap<String, Number> mapTilt = newHashMap ( "Kueche" -> 85,
                                                   "Buero1" -> 85,
                                                   "Buero3" -> 85
                                                 )

rule "Handle Window Covers"
when
    Member of gWindowContacts changed                                                  // Status eines Kontakts geändert
then
    val myName    = triggeringItem.name.split("_").get(1)                              // Identifikator abtrennen und sichern
    val myContact = gWindowContacts.members.filter[i|i.name.startsWith(myName)].head   // ContactItem heraussuchen (man könnte auch triggeringItem nehmen)
    val myRollo   =     gRolloLevel.members.filter[i|i.name.startsWith(myName)].head   // RollershutterItem heraussuchen
    if(myContact.state == OPEN){                                                       // Status auf OPEN geändert
        if(myRollo.state >= mapMax.get(myName))                                        // Rollladen geschlossen
            myRollo.sendCommand(mapTilt.get(myName))                                   // also auf Tilt-Position
            logInfo("windowCovers", "Rollo {} auf Tilt",myName)
    } else {                                                                           // Status auf CLOSED geändert
        if(myRollo.state <= mapMax.get(myName) && myRollo.state >= mapMin.get(myName)) // Rollladen auf Tilt-Position
            myRollo.sendCommand(100)                                                   // also Rollladen schließen
            logInfo("windowCovers", "Rollo {} schließen.",myName)
    }
end

Die Einrückungen dienen (gerade bei der HashMap) natürlich nur der Lesbarkeit...
Du kannst die Wertepaare (also Identifikator und Zahl) ruhig schon rein schreiben, also für alle Läden, wo Du diese Funktion nutzen willst, auch wenn die Läden noch nicht integriert sind. Erst wenn die entsprechenden Items in die Gruppen aufgenommen werden, wird die Rule die entsprechenden Werte auch abfragen, vorher sind es halt Werte, die keine Berücksichtigung finden. Das ganze Konstrukt ist für Defaultwerte im Zusammenhang mit generalisierten Rules (also solche, die über Gruppierungen mit beliebigen Items ihre Aufgabe erfüllen können) die sauberste Möglichkeit. Entsprechend lohnt es sich schon, das so einzubauen, wenn man schon Grenzwerte nutzt.

Das Problem mit dem doppelten Kontakt erfordert natürlich noch etwas zusätzlichen Aufwand. Wenn es nur um diese eine Tür geht, könnte man noch so etwas wie "Falls der Name des Kontaktes blah lautet, frage zusätzlich noch Kontakt Blub ab" einbauen.
Andererseits handelt es sich dabei eindeutig um eine andere Funktion.
Die Läden fahren ja nur dann auf Lüftungsposition, wenn sie geschlossen sind. Wenn die Tür komplett offen ist, sollte der Laden auch offen sein.
Entsprechend dürfte der Laden auch nicht herunter fahren, selbst wenn der Kontakt für Tilt ebenfalls aktiv wäre.

Es sollte also ausreichen, eine weitere Rule anzulegen, die sich nur um das Schließen des Rollladens der Tür kümmert. Empfängt der Rollladen den Befehl zum Schließen, triggert die Rule und prüft, ob die Tür offen ist. Ist das der Fall, sendet sie umgehend den Befehl zum Öffnen des Ladens (alternativ den Stopp Befehl).
Die Rule sollte natürlich auch Positionsbefehle auswerten, also falls Befehl vom Typ Number, prüfe, ob der Befehl größer 0 ist. Ist das der Fall, prüfe, ob die Tür offen ist. Ist das der Fall, sende den Befehl 0 an den Rollladen. sieht dann so aus:

Code: Alles auswählen

rule "Tür offen"
when
    Item TuerShutter received command
then
    if(TuerOffenKontakt.state != OPEN) // Tür nicht offen, Rule muss nichts tun
        return;

    if(receivedCommand instanceof Number) {
        if((receivedCommand as Number)> 0)
            TuerShutter.sendCommand(0)
    } else if(receivedCommand == DOWN)
            TuerShutter.sendCommand(0) // oder alternativ UP oder STOP
end

Schlimmstenfalls fährt der Rollladen einen Sekundenbruchteil abwärts und anschließend wieder hoch.