Ankündigung

Einklappen
Keine Ankündigung bisher.

Zeit Latenzen in Rules

Einklappen
X
Einklappen
 
  • Seite von 1
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge
Vorherige template Weiter
    #1

    Zeit Latenzen in Rules

    Hi zusammen

    ich habe eine Rule datei in der ich 4 Rolladen nach Zeit steuere.
    Das heißt 4 Timer usw, also nicht gerade klein.

    Steuere ich ein Rolladen ist alles gut und die Zeiten passen.

    Starte ich nun 2 Rolladen fast gleichzeitig steht in den Logs schon etwas von 500ms.
    Der nächste Schritt läuft versetzt ab ....

    Schlimmer ist es wenn ich alle 4 gleichzeitig fahre, also nicht als Gruppe sondern alle 4 Schieberegler einzeln schnell verschiebe.

    Es passiert fast immer das dann jedes Fenster anders stopt.

    Nun zur Fehleranalyse ......

    Laut meiner Info laufen so viele Rules parallel wie man will aber warum dann die 500ms Warnung ?

    Kann es sein das die Rule datei nicht zu groß sein darf und lieber mehrere Ruledatein anlegen ?

    Ein Ordner in dem Rule Ordner wird ja ebenfalls mit in die Bearbeitung genommen.

    Könnte es Abhilfe schaffen ein Ordner zu erstellen "Rolladen" und darin für jeden Rolladen ein eigene Ruledatei pro Fenster anzulegen ?

    Variablen sind ja nicht Global sondern auf die Datei beschenkt ....

    Vielleicht liegt es ja auch an etwas ganz anderem ?

    Falls es wichtig sein könnte hier die gesamte Rule

    Code:
    var Timer RolloOGZentralsteuerung

// Variablen Rollo 01 (Büro)
var long StartZeitRollo01
var long DauerZeitRollo01
var long Rollo01ZeitAuf = 34100
var long Rollo01ZeitZu = 15000
var long Rollo01ProzentAlt = 50
var long Rollo01ProzentNeu = 50
var long Rollo01ProzentZiel = 50
var long Rollo01ProzentGefahren = 50
var boolean Rollo01Fahrtrichtungtest  //true = hoch false = runter
var Timer Rollo01Fahrt
var Timer Rollo01Nachlauf

// Variablen Rollo 02 (Schlafzimmer)
var long StartZeitRollo02
var long DauerZeitRollo02
var long Rollo02ZeitAuf = 34100
var long Rollo02ZeitZu = 35000
var long Rollo02ProzentAlt = 50
var long Rollo02ProzentNeu = 50
var long Rollo02ProzentZiel = 50
var long Rollo02ProzentGefahren = 50
var boolean Rollo02Fahrtrichtungtest  //true = hoch false = runter
var Timer Rollo02Fahrt
var Timer Rollo02Nachlauf

// Variablen Rollo 03 (KZ Steiger)
var long StartZeitRollo03
var long DauerZeitRollo03
var long Rollo03ZeitAuf = 34100
var long Rollo03ZeitZu = 35000
var long Rollo03ProzentAlt = 50
var long Rollo03ProzentNeu = 50
var long Rollo03ProzentZiel = 50
var long Rollo03ProzentGefahren = 50
var boolean Rollo03Fahrtrichtungtest  //true = hoch false = runter
var Timer Rollo03Fahrt
var Timer Rollo03Nachlauf

// Variablen Rollo 04 (KZ Treppe)
var long StartZeitRollo04
var long DauerZeitRollo04
var long Rollo04ZeitAuf = 34100
var long Rollo04ZeitZu = 35000
var long Rollo04ProzentAlt = 50
var long Rollo04ProzentNeu = 50
var long Rollo04ProzentZiel = 50
var long Rollo04ProzentGefahren = 50
var boolean Rollo04Fahrtrichtungtest  //true = hoch false = runter
var Timer Rollo04Fahrt
var Timer Rollo04Nachlauf

///////////////////////////////////////////////////////////////////////////
//Gruppensteuerung

rule "Alle Rollos im OG Auffahren"
when
    Item AlleAufOG changed to ON
then
    M076R2.sendCommand(ON)
    M076R4.sendCommand(ON)
    M076R6.sendCommand(ON)
    M076R8.sendCommand(ON)
    M076R1.sendCommand(ON)
    M076R3.sendCommand(ON)
    M076R5.sendCommand(ON)
    M076R7.sendCommand(ON)
    RolloOGZentralsteuerung = createTimer(now.plusSeconds(40)) [| 
                        M076R1.sendCommand(OFF)
                        M076R3.sendCommand(OFF)
                        M076R5.sendCommand(OFF)
                        M076R7.sendCommand(OFF)
                        Rollo01Visu.postUpdate(0)
                        Rollo01ProzentNeu = 0
                        Rollo01ProzentAlt = 0
                        Rollo02Visu.postUpdate(0)
                        Rollo02ProzentNeu = 0
                        Rollo02ProzentAlt = 0
                        Rollo03Visu.postUpdate(0)
                        Rollo03ProzentNeu = 0
                        Rollo03ProzentAlt = 0
                        Rollo04Visu.postUpdate(0)
                        Rollo04ProzentNeu = 0
                        Rollo04ProzentAlt = 0
                        AlleAufOG.postUpdate(OFF)
                        ]
end

rule "Alle Rollos im OG Auffahren"
when
    Item AlleZuOG changed to ON
then
    M076R2.sendCommand(OFF)
    M076R4.sendCommand(OFF)
    M076R6.sendCommand(OFF)
    M076R8.sendCommand(OFF)
    M076R1.sendCommand(ON)
    M076R3.sendCommand(ON)
    M076R5.sendCommand(ON)
    M076R7.sendCommand(ON)
    RolloOGZentralsteuerung = createTimer(now.plusSeconds(40)) [| 
                        M076R1.sendCommand(OFF)
                        M076R3.sendCommand(OFF)
                        M076R5.sendCommand(OFF)
                        M076R7.sendCommand(OFF)
                        Rollo01Visu.postUpdate(100)
                        Rollo01ProzentNeu = 100
                        Rollo01ProzentAlt = 100
                        Rollo02Visu.postUpdate(100)
                        Rollo02ProzentNeu = 100
                        Rollo02ProzentAlt = 100
                        Rollo03Visu.postUpdate(100)
                        Rollo03ProzentNeu = 100
                        Rollo03ProzentAlt = 100
                        Rollo04Visu.postUpdate(100)
                        Rollo04ProzentNeu = 100
                        Rollo04ProzentAlt = 100
                        AlleZuOG.postUpdate(OFF)
                        ]
end

///////////////////////////////////////////////////////////////////////////
// Rollo 01 = Rolladen Büro !

rule "Reset Rollo 01 AN" 
when 
    Item Rollo01reset changed to ON
then 
    M076R1.sendCommand(ON)
    M076R2.sendCommand(ON)
    Rollo01Fahrt = createTimer(now.plusMillis(40000)) [| 
                Rollo01reset.postUpdate(OFF)
                ]
end

rule "Reset Rollo 01 AUS" 
when 
    Item Rollo01reset changed to OFF
then 
    M076R1.sendCommand(OFF)
    M076L1.sendCommand(OFF)
    Rollo01Visu.postUpdate(0)
    Rollo01ProzentNeu = 0
    Rollo01ProzentAlt = 0
end

rule "Verstellen Visu Rollo 01" 
when 
    Item Rollo01Visu changed
then 
    //Start
    if ( M076L1.state == OFF && Rollo01Visu != Rollo01ProzentAlt && M076R1.state == OFF ) {
        Rollo01ProzentZiel = (Rollo01Visu.state as DecimalType).intValue
        //Auf
        if ( Rollo01ProzentZiel < Rollo01ProzentAlt) {
            Rollo01ProzentNeu = Rollo01ProzentZiel
            M076R1.sendCommand(ON)
            M076R2.sendCommand(ON)
            }
         //Zu
         if ( Rollo01ProzentZiel > Rollo01ProzentAlt) {
            Rollo01ProzentNeu = Rollo01ProzentZiel
            M076R2.sendCommand(OFF)
            M076R1.sendCommand(ON)
            }}
end

rule "Fahren Rollo 01" 
when 
    Item M076R1 changed to ON
then 
    //AUF
    if ( M076R2.state == ON  && Rollo01ProzentAlt > 0 && Rollo01reset.state == OFF ) {
            StartZeitRollo01 = now.millis
            Rollo01Fahrtrichtungtest = true
            //Manuel
            if ( M076L1.state == ON ) {
                Rollo01Fahrt = createTimer(now.plusMillis((new Float(Rollo01ProzentAlt * Rollo01ZeitAuf / 100)).intValue)) [| 
                    M076L1.sendCommand(OFF)
                    Rollo01ProzentNeu = 0
                    Rollo01Update.postUpdate((Rollo01Update.state as Number) + 1)
                    Rollo01Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R1.sendCommand(OFF)
                        ]]}
             //Automatik
             if ( M076L1.state == OFF ) {
                Rollo01Fahrt = createTimer(now.plusMillis((new Float((Rollo01ProzentAlt - Rollo01ProzentZiel) * Rollo01ZeitAuf / 100)).intValue)) [| 
                    Rollo01ProzentAlt = Rollo01ProzentNeu
                    if ( Rollo01ProzentNeu == 990) {
                        Rollo01Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R1.sendCommand(OFF)
                        Rollo01Visu.postUpdate(Rollo01ProzentZiel)
                        ]
                        }else
                            M076R1.sendCommand(OFF)
                            Rollo01Visu.postUpdate(Rollo01ProzentZiel)
                    ]}
    //ZU
    }else if ( M076R2.state == OFF  && Rollo01ProzentAlt < 100 && Rollo01reset.state == OFF ) {
            StartZeitRollo01 = now.millis
            Rollo01Fahrtrichtungtest = false
            //Manuel
            if ( M076L1.state == ON ) {
                Rollo01Fahrt = createTimer(now.plusMillis((new Float((100 - Rollo01ProzentAlt) * Rollo01ZeitZu / 100)).intValue)) [|
                     M076L1.sendCommand(OFF)
                    Rollo01ProzentNeu = 100
                    Rollo01Update.postUpdate((Rollo01Update.state as Number) + 1)
                    Rollo01Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R1.sendCommand(OFF)
                        ]]}
            //Automatik
            if ( M076L1.state == OFF ) {
                Rollo01Fahrt = createTimer(now.plusMillis((new Float((Rollo01ProzentNeu - Rollo01ProzentAlt) * Rollo01ZeitZu / 100)).intValue)) [| 
                    Rollo01ProzentAlt = Rollo01ProzentNeu
                    if ( Rollo01ProzentNeu == 99100) {
                        Rollo01Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R1.sendCommand(OFF)
                        Rollo01Visu.postUpdate(Rollo01ProzentZiel)
                        ]
                        }else
                            M076R1.sendCommand(OFF)
                            Rollo01Visu.postUpdate(Rollo01ProzentZiel)
                    ]}
    //Keine Fahrt
    }else if ( M076L1.state == ON && Rollo01reset.state == OFF ) {
            M076R1.sendCommand(OFF)
            M076L1.sendCommand(OFF)
            Rollo01Update.postUpdate((Rollo01Update.state as Number) + 1)
    }    
end

rule "Stopen Manuel Rollo 01" 
when 
    Item M076R1 changed to OFF
then 
    //AUF - Aus
    if ( M076L1.state == ON  && Rollo01Fahrtrichtungtest == true && Rollo01reset.state == OFF ) {
            Rollo01Fahrt.cancel
            M076L1.sendCommand(OFF)
            DauerZeitRollo01 = now.millis - StartZeitRollo01
            Rollo01ProzentNeu = Rollo01ProzentAlt - (DauerZeitRollo01 * 100 / Rollo01ZeitAuf)
            Rollo01Update.postUpdate((Rollo01Update.state as Number) + 1)
        // ZU - Aus
        }else if ( M076L1.state == ON  && Rollo01Fahrtrichtungtest == false && Rollo01reset.state == OFF ) {
            Rollo01Fahrt.cancel
            M076L1.sendCommand(OFF)
            DauerZeitRollo01 = now.millis - StartZeitRollo01
            Rollo01ProzentNeu = Rollo01ProzentAlt + (DauerZeitRollo01 * 100 / Rollo01ZeitZu)
            Rollo01Update.postUpdate((Rollo01Update.state as Number) + 1)
        }    
end

rule "Aktualiesierung Rollo 01" 
when 
    Item Rollo01Update changed
then 
    //R?cksetzen Rollo01Update auf 0
    if ( Rollo01Update.state > 50 ) {
            Rollo01Update.postUpdate(0)
            }
    //mehr als 100%
    if ( Rollo01ProzentNeu > 100 ) {
            Rollo01ProzentNeu = 100
            Rollo01ProzentAlt = 100
            Rollo01Visu.postUpdate(100)
            //weniger alls 0%
            }else if ( Rollo01ProzentNeu < 0 ) {
                Rollo01ProzentNeu = 0
                Rollo01ProzentAlt = 0
                Rollo01Visu.postUpdate(0)
                //Status Update
                }else if ( Rollo01ProzentNeu != Rollo01ProzentAlt ) {
                Rollo01ProzentAlt = Rollo01ProzentNeu
                Rollo01Visu.postUpdate(Rollo01ProzentNeu)
                }
end

///////////////////////////////////////////////////////////////////////////
// Rollo 02 = Rolladen Schlafzimmer !

rule "Reset Rollo 02 AN" 
when 
    Item Rollo02reset changed to ON
then 
    M076R3.sendCommand(ON)
    M076R4.sendCommand(ON)
    Rollo02Fahrt = createTimer(now.plusMillis(40000)) [| 
                Rollo02reset.postUpdate(OFF)
                ]
end

rule "Reset Rollo 02 AUS" 
when 
    Item Rollo02reset changed to OFF
then 
    M076R3.sendCommand(OFF)
    M076L2.sendCommand(OFF)
    Rollo02Visu.postUpdate(0)
    Rollo02ProzentNeu = 0
    Rollo02ProzentAlt = 0
end

rule "Verstellen Visu Rollo 02" 
when 
    Item Rollo02Visu changed
then 
    //Start
    if ( M076L2.state == OFF && Rollo02Visu != Rollo02ProzentAlt && M076R3.state == OFF ) {
        Rollo02ProzentZiel = (Rollo02Visu.state as DecimalType).intValue
        //Auf
        if ( Rollo02ProzentZiel < Rollo02ProzentAlt) {
            Rollo02ProzentNeu = Rollo02ProzentZiel
            M076R3.sendCommand(ON)
            M076R4.sendCommand(ON)
            }
         //Zu
         if ( Rollo02ProzentZiel > Rollo02ProzentAlt) {
            Rollo02ProzentNeu = Rollo02ProzentZiel
            M076R4.sendCommand(OFF)
            M076R3.sendCommand(ON)
            }}
end

rule "Fahren Rollo 02" 
when 
    Item M076R3 changed to ON
then 
    //AUF
    if ( M076R4.state == ON  && Rollo02ProzentAlt > 0 && Rollo02reset.state == OFF ) {
            StartZeitRollo02 = now.millis
            Rollo02Fahrtrichtungtest = true
            //Manuel
            if ( M076L2.state == ON ) {
                Rollo02Fahrt = createTimer(now.plusMillis((new Float(Rollo02ProzentAlt * Rollo02ZeitAuf / 100)).intValue)) [| 
                    M076L2.sendCommand(OFF)
                    Rollo02ProzentNeu = 0
                    Rollo02Update.postUpdate((Rollo02Update.state as Number) + 1)
                    Rollo02Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R3.sendCommand(OFF)
                        ]]}
             //Automatik
             if ( M076L2.state == OFF ) {
                Rollo02Fahrt = createTimer(now.plusMillis((new Float((Rollo02ProzentAlt - Rollo02ProzentZiel) * Rollo02ZeitAuf / 100)).intValue)) [| 
                    Rollo02ProzentAlt = Rollo02ProzentNeu
                    if ( Rollo02ProzentNeu == 990) {
                        Rollo02Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R3.sendCommand(OFF)
                        Rollo02Visu.postUpdate(Rollo02ProzentZiel)
                        ]
                        }else
                            M076R3.sendCommand(OFF)
                            Rollo02Visu.postUpdate(Rollo02ProzentZiel)
                    ]}
    //ZU
    }else if ( M076R4.state == OFF  && Rollo02ProzentAlt < 100 && Rollo02reset.state == OFF ) {
            StartZeitRollo02 = now.millis
            Rollo02Fahrtrichtungtest = false
            //Manuel
            if ( M076L2.state == ON ) {
                Rollo02Fahrt = createTimer(now.plusMillis((new Float((100 - Rollo02ProzentAlt) * Rollo02ZeitZu / 100)).intValue)) [|
                     M076L2.sendCommand(OFF)
                    Rollo02ProzentNeu = 100
                    Rollo02Update.postUpdate((Rollo02Update.state as Number) + 1)
                    Rollo02Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R3.sendCommand(OFF)
                        ]]}
            //Automatik
            if ( M076L2.state == OFF ) {
                Rollo02Fahrt = createTimer(now.plusMillis((new Float((Rollo02ProzentNeu - Rollo02ProzentAlt) * Rollo02ZeitZu / 100)).intValue)) [| 
                    Rollo02ProzentAlt = Rollo01ProzentNeu
                    if ( Rollo02ProzentNeu == 99100) {
                        Rollo02Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R3.sendCommand(OFF)
                        Rollo02Visu.postUpdate(Rollo02ProzentZiel)
                        ]
                        }else
                            M076R3.sendCommand(OFF)
                            Rollo02Visu.postUpdate(Rollo02ProzentZiel)
                    ]}
    //Keine Fahrt
    }else if ( M076L2.state == ON && Rollo02reset.state == OFF ) {
            M076R3.sendCommand(OFF)
            M076L2.sendCommand(OFF)
            Rollo02Update.postUpdate((Rollo02Update.state as Number) + 1)
    }    
end

rule "Stopen Manuel Rollo 02" 
when 
    Item M076R3 changed to OFF
then 
    //AUF - Aus
    if ( M076L2.state == ON  && Rollo02Fahrtrichtungtest == true && Rollo02reset.state == OFF ) {
            Rollo02Fahrt.cancel
            M076L2.sendCommand(OFF)
            DauerZeitRollo02 = now.millis - StartZeitRollo02
            Rollo02ProzentNeu = Rollo02ProzentAlt - (DauerZeitRollo02 * 100 / Rollo02ZeitAuf)
            Rollo02Update.postUpdate((Rollo02Update.state as Number) + 1)
        // ZU - Aus
        }else if ( M076L2.state == ON  && Rollo02Fahrtrichtungtest == false && Rollo02reset.state == OFF ) {
            Rollo02Fahrt.cancel
            M076L2.sendCommand(OFF)
            DauerZeitRollo02 = now.millis - StartZeitRollo02
            Rollo02ProzentNeu = Rollo02ProzentAlt + (DauerZeitRollo02 * 100 / Rollo02ZeitZu)
            Rollo02Update.postUpdate((Rollo02Update.state as Number) + 1)
        }    
end

rule "Aktualiesierung Rollo 02" 
when 
    Item Rollo02Update changed
then 
    //R?cksetzen Rollo02Update auf 0
    if ( Rollo02Update.state > 50 ) {
            Rollo02Update.postUpdate(0)
            }
    //mehr als 100%
    if ( Rollo02ProzentNeu > 100 ) {
            Rollo02ProzentNeu = 100
            Rollo02ProzentAlt = 100
            Rollo02Visu.postUpdate(100)
            //weniger alls 0%
            }else if ( Rollo02ProzentNeu < 0 ) {
                Rollo02ProzentNeu = 0
                Rollo02ProzentAlt = 0
                Rollo02Visu.postUpdate(0)
                //Status Update
                }else if ( Rollo02ProzentNeu != Rollo02ProzentAlt ) {
                Rollo02ProzentAlt = Rollo02ProzentNeu
                Rollo02Visu.postUpdate(Rollo02ProzentNeu)
                }
end

///////////////////////////////////////////////////////////////////////////
// Rollo 03 = Rolladen Kinderzimmer Steiger !

rule "Reset Rollo 03 AN" 
when 
    Item Rollo03reset changed to ON
then 
    M076R5.sendCommand(ON)
    M076R6.sendCommand(ON)
    Rollo03Fahrt = createTimer(now.plusMillis(40000)) [| 
                Rollo03reset.postUpdate(OFF)
                ]
end

rule "Reset Rollo 03 AUS" 
when 
    Item Rollo03reset changed to OFF
then 
    M076R5.sendCommand(OFF)
    M076L3.sendCommand(OFF)
    Rollo03Visu.postUpdate(0)
    Rollo03ProzentNeu = 0
    Rollo03ProzentAlt = 0
end

rule "Verstellen Visu Rollo 03" 
when 
    Item Rollo03Visu changed
then 
    //Start
    if ( M076L3.state == OFF && Rollo03Visu != Rollo03ProzentAlt && M076R5.state == OFF ) {
        Rollo03ProzentZiel = (Rollo03Visu.state as DecimalType).intValue
        //Auf
        if ( Rollo03ProzentZiel < Rollo03ProzentAlt) {
            Rollo03ProzentNeu = Rollo03ProzentZiel
            M076R5.sendCommand(ON)
            M076R6.sendCommand(ON)
            }
         //Zu
         if ( Rollo03ProzentZiel > Rollo03ProzentAlt) {
            Rollo03ProzentNeu = Rollo03ProzentZiel
            M076R6.sendCommand(OFF)
            M076R5.sendCommand(ON)
            }}
end

rule "Fahren Rollo 03" 
when 
    Item M076R5 changed to ON
then 
    //AUF
    if ( M076R6.state == ON  && Rollo03ProzentAlt > 0 && Rollo03reset.state == OFF ) {
            StartZeitRollo03 = now.millis
            Rollo03Fahrtrichtungtest = true
            //Manuel
            if ( M076L3.state == ON ) {
                Rollo03Fahrt = createTimer(now.plusMillis((new Float(Rollo03ProzentAlt * Rollo03ZeitAuf / 100)).intValue)) [| 
                    M076L3.sendCommand(OFF)
                    Rollo03ProzentNeu = 0
                    Rollo03Update.postUpdate((Rollo03Update.state as Number) + 1)
                    Rollo03Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R5.sendCommand(OFF)
                        ]]}
             //Automatik
             if ( M076L3.state == OFF ) {
                Rollo03Fahrt = createTimer(now.plusMillis((new Float((Rollo03ProzentAlt - Rollo03ProzentZiel) * Rollo03ZeitAuf / 100)).intValue)) [| 
                    Rollo03ProzentAlt = Rollo03ProzentNeu
                    if ( Rollo03ProzentNeu == 990) {
                        Rollo03Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R5.sendCommand(OFF)
                        Rollo03Visu.postUpdate(Rollo03ProzentZiel)
                        ]
                        }else
                            M076R5.sendCommand(OFF)
                            Rollo03Visu.postUpdate(Rollo03ProzentZiel)
                    ]}
    //ZU
    }else if ( M076R6.state == OFF  && Rollo03ProzentAlt < 100 && Rollo03reset.state == OFF ) {
            StartZeitRollo03 = now.millis
            Rollo03Fahrtrichtungtest = false
            //Manuel
            if ( M076L3.state == ON ) {
                Rollo03Fahrt = createTimer(now.plusMillis((new Float((100 - Rollo03ProzentAlt) * Rollo03ZeitZu / 100)).intValue)) [|
                     M076L3.sendCommand(OFF)
                    Rollo03ProzentNeu = 100
                    Rollo03Update.postUpdate((Rollo03Update.state as Number) + 1)
                    Rollo03Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R5.sendCommand(OFF)
                        ]]}
            //Automatik
            if ( M076L3.state == OFF ) {
                Rollo03Fahrt = createTimer(now.plusMillis((new Float((Rollo03ProzentNeu - Rollo03ProzentAlt) * Rollo03ZeitZu / 100)).intValue)) [| 
                    Rollo03ProzentAlt = Rollo03ProzentNeu
                    if ( Rollo03ProzentNeu == 99100) {
                        Rollo03Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R5.sendCommand(OFF)
                        Rollo03Visu.postUpdate(Rollo03ProzentZiel)
                        ]
                        }else
                            M076R5.sendCommand(OFF)
                            Rollo03Visu.postUpdate(Rollo03ProzentZiel)
                    ]}
    //Keine Fahrt
    }else if ( M076L3.state == ON && Rollo03reset.state == OFF ) {
            M076R5.sendCommand(OFF)
            M076L3.sendCommand(OFF)
            Rollo03Update.postUpdate((Rollo03Update.state as Number) + 1)
    }    
end

rule "Stopen Manuel Rollo 03" 
when 
    Item M076R5 changed to OFF
then 
    //AUF - Aus
    if ( M076L3.state == ON  && Rollo03Fahrtrichtungtest == true && Rollo03reset.state == OFF ) {
            Rollo03Fahrt.cancel
            M076L3.sendCommand(OFF)
            DauerZeitRollo03 = now.millis - StartZeitRollo03
            Rollo03ProzentNeu = Rollo03ProzentAlt - (DauerZeitRollo03 * 100 / Rollo03ZeitAuf)
            Rollo03Update.postUpdate((Rollo03Update.state as Number) + 1)
        // ZU - Aus
        }else if ( M076L3.state == ON  && Rollo03Fahrtrichtungtest == false && Rollo03reset.state == OFF ) {
            Rollo03Fahrt.cancel
            M076L3.sendCommand(OFF)
            DauerZeitRollo03 = now.millis - StartZeitRollo03
            Rollo03ProzentNeu = Rollo03ProzentAlt + (DauerZeitRollo03 * 100 / Rollo03ZeitZu)
            Rollo03Update.postUpdate((Rollo03Update.state as Number) + 1)
        }    
end

rule "Aktualiesierung Rollo 03" 
when 
    Item Rollo03Update changed
then 
    //R?cksetzen Rollo03Update auf 0
    if ( Rollo03Update.state > 50 ) {
            Rollo03Update.postUpdate(0)
            }
    //mehr als 100%
    if ( Rollo03ProzentNeu > 100 ) {
            Rollo03ProzentNeu = 100
            Rollo03ProzentAlt = 100
            Rollo03Visu.postUpdate(100)
            //weniger alls 0%
            }else if ( Rollo03ProzentNeu < 0 ) {
                Rollo03ProzentNeu = 0
                Rollo03ProzentAlt = 0
                Rollo03Visu.postUpdate(0)
                //Status Update
                }else if ( Rollo03ProzentNeu != Rollo03ProzentAlt ) {
                Rollo03ProzentAlt = Rollo03ProzentNeu
                Rollo03Visu.postUpdate(Rollo03ProzentNeu)
                }
end

///////////////////////////////////////////////////////////////////////////
// Rollo 04 = Rolladen Kinderzimmer Treppe !

rule "Reset Rollo 04 AN" 
when 
    Item Rollo04reset changed to ON
then 
    M076R7.sendCommand(ON)
    M076R8.sendCommand(ON)
    Rollo04Fahrt = createTimer(now.plusMillis(40000)) [| 
                Rollo04reset.postUpdate(OFF)
                ]
end

rule "Reset Rollo 04 AUS" 
when 
    Item Rollo04reset changed to OFF
then 
    M076R7.sendCommand(OFF)
    M076L4.sendCommand(OFF)
    Rollo04Visu.postUpdate(0)
    Rollo04ProzentNeu = 0
    Rollo04ProzentAlt = 0
end

rule "Verstellen Visu Rollo 04" 
when 
    Item Rollo04Visu changed
then 
    //Start
    if ( M076L4.state == OFF && Rollo04Visu != Rollo04ProzentAlt && M076R7.state == OFF ) {
        Rollo04ProzentZiel = (Rollo04Visu.state as DecimalType).intValue
        //Auf
        if ( Rollo04ProzentZiel < Rollo04ProzentAlt) {
            Rollo04ProzentNeu = Rollo04ProzentZiel
            M076R7.sendCommand(ON)
            M076R8.sendCommand(ON)
            }
         //Zu
         if ( Rollo04ProzentZiel > Rollo04ProzentAlt) {
            Rollo04ProzentNeu = Rollo04ProzentZiel
            M076R8.sendCommand(OFF)
            M076R7.sendCommand(ON)
            }}
end

rule "Fahren Rollo 04" 
when 
    Item M076R7 changed to ON
then 
    //AUF
    if ( M076R8.state == ON  && Rollo04ProzentAlt > 0 && Rollo04reset.state == OFF ) {
            StartZeitRollo04 = now.millis
            Rollo04Fahrtrichtungtest = true
            //Manuel
            if ( M076L4.state == ON ) {
                Rollo04Fahrt = createTimer(now.plusMillis((new Float(Rollo04ProzentAlt * Rollo04ZeitAuf / 100)).intValue)) [| 
                    M076L4.sendCommand(OFF)
                    Rollo04ProzentNeu = 0
                    Rollo04Update.postUpdate((Rollo04Update.state as Number) + 1)
                    Rollo04Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R7.sendCommand(OFF)
                        ]]}
             //Automatik
             if ( M076L4.state == OFF ) {
                Rollo04Fahrt = createTimer(now.plusMillis((new Float((Rollo04ProzentAlt - Rollo04ProzentZiel) * Rollo04ZeitAuf / 100)).intValue)) [| 
                    Rollo04ProzentAlt = Rollo04ProzentNeu
                    if ( Rollo04ProzentNeu == 990) {
                        Rollo04Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R7.sendCommand(OFF)
                        Rollo04Visu.postUpdate(Rollo04ProzentZiel)
                        ]
                        }else
                            M076R7.sendCommand(OFF)
                            Rollo04Visu.postUpdate(Rollo04ProzentZiel)
                    ]}
    //ZU
    }else if ( M076R8.state == OFF  && Rollo04ProzentAlt < 100 && Rollo04reset.state == OFF ) {
            StartZeitRollo04 = now.millis
            Rollo04Fahrtrichtungtest = false
            //Manuel
            if ( M076L4.state == ON ) {
                Rollo04Fahrt = createTimer(now.plusMillis((new Float((100 - Rollo04ProzentAlt) * Rollo04ZeitZu / 100)).intValue)) [|
                     M076L4.sendCommand(OFF)
                    Rollo04ProzentNeu = 99100
                    Rollo04Update.postUpdate((Rollo04Update.state as Number) + 1)
                    Rollo04Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R7.sendCommand(OFF)
                        ]]}
            //Automatik
            if ( M076L4.state == OFF ) {
                Rollo04Fahrt = createTimer(now.plusMillis((new Float((Rollo04ProzentNeu - Rollo04ProzentAlt) * Rollo04ZeitZu / 100)).intValue)) [| 
                    Rollo04ProzentAlt = Rollo04ProzentNeu
                    if ( Rollo04ProzentNeu == 100) {
                        Rollo04Nachlauf = createTimer(now.plusSeconds(3)) [| 
                        M076R7.sendCommand(OFF)
                        Rollo04Visu.postUpdate(Rollo04ProzentZiel)
                        ]
                        }else
                            M076R7.sendCommand(OFF)
                            Rollo04Visu.postUpdate(Rollo04ProzentZiel)
                    ]}
    //Keine Fahrt
    }else if ( M076L4.state == ON && Rollo04reset.state == OFF ) {
            M076R7.sendCommand(OFF)
            M076L4.sendCommand(OFF)
            Rollo04Update.postUpdate((Rollo04Update.state as Number) + 1)
    }    
end

rule "Stopen Manuel Rollo 04" 
when 
    Item M076R7 changed to OFF
then 
    //AUF - Aus
    if ( M076L4.state == ON  && Rollo04Fahrtrichtungtest == true && Rollo04reset.state == OFF ) {
            Rollo04Fahrt.cancel
            M076L4.sendCommand(OFF)
            DauerZeitRollo04 = now.millis - StartZeitRollo04
            Rollo04ProzentNeu = Rollo04ProzentAlt - (DauerZeitRollo04 * 100 / Rollo04ZeitAuf)
            Rollo04Update.postUpdate((Rollo04Update.state as Number) + 1)
        // ZU - Aus
        }else if ( M076L4.state == ON  && Rollo04Fahrtrichtungtest == false && Rollo04reset.state == OFF ) {
            Rollo04Fahrt.cancel
            M076L4.sendCommand(OFF)
            DauerZeitRollo04 = now.millis - StartZeitRollo04
            Rollo04ProzentNeu = Rollo04ProzentAlt + (DauerZeitRollo04 * 100 / Rollo04ZeitZu)
            Rollo04Update.postUpdate((Rollo04Update.state as Number) + 1)
        }    
end

rule "Aktualiesierung Rollo 04" 
when 
    Item Rollo04Update changed
then 
    //R?cksetzen Rollo04Update auf 0
    if ( Rollo04Update.state > 50 ) {
            Rollo04Update.postUpdate(0)
            }
    //mehr als 100%
    if ( Rollo04ProzentNeu > 100 ) {
            Rollo04ProzentNeu = 100
            Rollo04ProzentAlt = 100
            Rollo04Visu.postUpdate(100)
            //weniger alls 0%
            }else if ( Rollo04ProzentNeu < 0 ) {
                Rollo04ProzentNeu = 0
                Rollo04ProzentAlt = 0
                Rollo04Visu.postUpdate(0)
                //Status Update
                }else if ( Rollo04ProzentNeu != Rollo04ProzentAlt ) {
                Rollo04ProzentAlt = Rollo04ProzentNeu
                Rollo04Visu.postUpdate(Rollo04ProzentNeu)
                }
end
    MfG
    Stichworte: -
    #2
    Ein Fehler springt mir direkt ins Auge, nämlich, dass die erste und die zweite Rule den gleichen Namen haben, das ist nicht gut. Das wird aber vermutlich nicht der Grund für die Timing-Probleme sein.
    Eher ist es so, dass Du die Rule Engine da an ihre Grenzen bringst. Es ist ja auch nicht so, dass eine Rule ausgeführt wird, wenn ein Laden fährt, sondern das Verfahren des Ladens löst eine ganze Kaskade an Rules aus, teilweise könnte sogar dieselbe Rule mehrfach getrigert werden, wohlgemerkt, bei einer einzigen Fahrt eines Ladens.
    Das eine wäre also der Versuch, die Positionsbestimmung wesentlich schlanker zu gestalten. das zweite wäre, die Rules so umzuformulieren, dass Du mit Gruppen arbeiten kannst, um mit einer einzigen Rule (oder zumindest einm Satz Rules) alle Läden individuell zu steuern und deren Position zu bestimmen.

    Welche Hardware verwendest Du für openHAB?

    Eine Alternative wäre, JSR223 Scripting zu verwenden. Ich hab mich bisher noch nicht damit beschäftigt, aber es gibt Aussagen, dass diese Rules Engine gegenüber dem DSL um den Faktor 50 schneller ist.

    Kommentar

      #3
      Es ist ein 64bit 2.2 GHz 2 Kerne mit 4 GB RAM.

      Oh dann ist dort wohl beim Kopieren ein Fehler reingenommen .....

      Trotz 3 mal durchgehen

      also ich bin schon froh das ich das hinbekommen habe ....

      Mit Gruppen usw. Habe ich keine wirklichen Plan
      und mit Scripten .... oh oh

      MfG

      Kommentar

      Vorherige template Weiter
      Lädt...
      X

      Wir verarbeiten personenbezogene Daten über die Nutzer unserer Website mithilfe von Cookies und anderen Technologien, um unsere Dienste bereitzustellen. Weitere Informationen findest Du in unserer Datenschutzerklärung.

      Indem Du unten auf "ICH stimme zu" klickst, stimmst Du unserer Datenschutzerklärung und unseren persönlichen Datenverarbeitungs- und Cookie-Praktiken zu, wie darin beschrieben. Du erkennst außerdem an, dass dieses Forum möglicherweise außerhalb Deines Landes gehostet wird und bist damit einverstanden, dass Deine Daten in dem Land, in dem dieses Forum gehostet wird, gesammelt, gespeichert und verarbeitet werden.

      Ich stimme zu