Schleife in Rules

[BO80]

Hallo Zusammen,

ich bin noch Anfänger was die Rules angeht, der Aktuelle Stand funktioniert auch soweit.
Ziel ist dies Solarpumpe bei zu hoher Speichertemperatur nachts laufen zu lassen um den Speicher bis zu einer bestimmten Temperatur runter zu kühlen.
Deshalb würde ich die aktuelle Rule in einer Schleife laufen lassen bis eine bestimmte Temperatur unterschritten ist.
Könnt ihr mir da weiterhelfen?

Gruß Benjamin

Code: Alles auswählen

rule "Solar_Kuehlprogramm"

when
    

 Time cron "0 0 1 ? * 1-7"      // Montag-Sonntag 1 Uhr

then
    
    var Temp_unter_ruecklauf = (Speichertemperatur9.state as Number).floatValue
    var Timer Zyklus1 = null

    if (Solarkuehlung.state==ON && Temp_unter_ruecklauf>=60  ) {
     
     channel5.sendCommand (ON)                                      //Solarpumpe
     Zyklus1?.cancel
     Zyklus1 = createTimer(now.plusMinutes(1), [ |
     Solarkuehlung.sendCommand (OFF)
     channel5.sendCommand (OFF)])  //Virtueller Schalter  und Solarpumpe aus


  }
   
    end 

[udo1toni]

Bitte nicht! openHAB ist ein eventbezogenes System, es gibt keinen Grund, die Rule so zu vergewaltigen.

Gesendet von meinem SM-G973F mit Tapatalk

[BO80]

Ok, wie könnte ich es dann umsetzen?

Die Pumpe soll intervallmäßig laufen, 10min an 30min die bis eine Temperatur Grenzwert unterschritten wird





Gesendet von meinem ELE-L29 mit Tapatalk

[udo1toni]

Hab gerade mal den Rechner angeschmissen, das geht besser als vom Handy.
Was Du willst, ist eher so was:

Code: Alles auswählen

rule "Solar_Kuehlprogramm"
when
    Time cron "0 0 1 * * ?" or                                           // täglich um 1 Uhr
    Item Speichertemperatur9 changed                                     // Temperatur geändert
then
    var Number nSolarRLTemp = 55                                         // Default Wert, falls Sensorausfall
    if(Speichertemperatur9.state instanceof Number)                      // Sensor liefert Wert
        nSolarRLTemp = (Speichertemperatur9.state as Number).floatValue  // also Sensortwert übernehmen
    if(now.getHourOfDay != 1) {                                          // Falls außerhalb des Zeitfensters 1 Uhr bis 2 Uhr
        logInfo("solarCooling","Solartemperatur beträgt {} aber außerhalb des Kühlzeitfensters!",Speichertemperatur9.state)
        return;                                                          // Rule abbrechen
    }
    var String strSoll = "OFF"                                           // Default für Pumpe: OFF
    if (Solarkuehlung.state==ON && nSolarRLTemp >= 60)                   // Falls Kühlung aktiviert und Temperatur übeschritten
        strSoll = "ON"                                                   // Sollwert auf ON ändern
    if(channel5.state.toString != strSoll)                               // Falls Pumpenzustand vom Soll abweicht
        channel5.sendCommand(strSoll)                                    // Pumpe ansteuern
end

Die Rule triggert um 1 Uhr und bei Temperaturänderung.
Zunächst wird ein Default Sensorwert festgelegt (55). Anschließend wird der echte Sensorwert übernommen, falls der Sensor einen Wert liefert. Dieses Vorgehen verhindert eine Nullpointerexception bei ausgefallenem Sensor. Natürlich wäre es sinnvoll, noch ein else mit einer Warnung einzubauen
Nun prüft die Rule, ob es zwischen 1 und 2 Uhr ist. Ist das nicht der Fall, so bricht sie die Ausführung ab. Falls das Zeitfenster größer sein muss, kann man auch Unter- und Obergrenze festlegen.
Passt das Zeitfenster, so wird ein Sollwert für die Pumpe festgelegt ("OFF"). Anschließend werden die eigentlichen Bedingungen geprüft (Temperatur über 60 und Kühlautomatik aktiv) und gegebenenfalls der Sollwert auf "ON" angepasst.
Zum Abschluss prüft die Rule, ob die Pumpe dem Soll entspricht und schaltet gegebenenfalls um.

[BO80]

Danke für die super schnelle Antwort, ich werde mal versuchen ob ich das nachvollziehen kann.

Wenn ich das richtig verstehe, läuft die Pumpe so konstant bis die Solltemp. unterschritten ist?
Ich brauche aber eine gewisse Stillstandzeit dazwischen, damit das Wasser in den Kollektoren abkühlen kann, lässt sich das integrieren?

[udo1toni]

Ah. Ja, da müsste man noch mal drüber nachdenken... sollte aber auch kein Problem sein.

Gesendet von meinem SM-G973F mit Tapatalk

[BO80]

Deinen Code habe ich soweit verstanden! Leider fällt es mir nicht so leicht wie dir, so einen Code zu schreiben bzw. zu erweitern mit den benötigten Eigenschaften.
Gibt es noch andere Quellen zur Rule Syntax außer der offiziellen openhab docs?

[udo1toni]

Es gibt in den verschiedenen Foren zehntausende Codebeispiele von simpel bis Kopf explodiert
Ein anderer Ansatz läuft ähnlich, wie Deine ursprüngliche Rule:

Code: Alles auswählen

// globale Variablen werden zu Beginn der Datei definiert!
var Timer tKuehlung = null

rule "Solar_Kuehlprogramm"
when
    Time cron "0 0 1 * * ?"      // Montag-Sonntag 1 Uhr
then
    tKuehlung?.cancel
    logInfo("solarCooling","Kühlzyklus wird gestartet")
    tKuehlung = createTimer(now,[|
        var Number nSolarRLTemp = 55                                         // Default Wert, falls Sensorausfall
        if(Speichertemperatur9.state instanceof Number)                      // Sensor liefert Wert
            nSolarRLTemp = (Speichertemperatur9.state as Number).floatValue  // also Sensortwert übernehmen
        else
            logWarn("solarCooling","Temperaturfühler liefert ungültigen Wert! ({})",Speichertemperatur9.state)
        if(nSolarRLTemp < 60) {                                              // Temperatur unter 60, also Ende
            channel5.sendCommand(OFF)                                        // Pumpe (endgültig) aus
            logInfo("solarCooling","Kühlzyklus wird beendet. Temperatur {}",Speichertemperatur9.state)
            tKuehlung = null                                                 // Timer deinitialisieren
        } else {                                                             // Temperatur 60 oder größer
            if(channel5.state == OFF) {                                      // Falls Pumpe aus
                channel5.sendCommand(ON)                                     // Pumpe an
                logInfo("solarCooling","Kühlzyklus: Pumpe starten")
                tKuehlung.reschedule(now.plusSeconds(90))                    // und nach 90 Sekunden Timer erneut ausführen
            } else {                                                         // Falls Pumpe an
                channel5.sendCommand(OFF)                                    // Pumpe aus
                logInfo("solarCooling","Kühlzyklus: Pumpe stoppen")
                tKuehlung.reschedule(now.plusSeconds(180))                   // und nach 180 Sekunden Timer erneut ausführen
            }
        }
    ])
end

Die Rule wird über Time cron getriggert und erstellt einen Timer, der unmittelbar ausgeführt wird.
Im Timer wird die Temperatur geprüft (wie gehabt...) und gegebenenfalls eine Warnmeldung bei Sensorausfall ausgegeben.
Liefert der Sensor einen Wert über (oder gleich) 60, so prüft die Rlue, ob die Pumpe läuft. Falls nicht wird sie gestartet und nach der festgelegten Zeit wir der Timer erneut ausgeführt. Falls die Pumpe läuft, wird sie gestoppt und nach der festgelegten Zeit wir der Timer erneut ausgeführt.
Die Rule ist so konzipiert, dass es unterschiedliche ON/OFF Zykluszeiten gibt. Die Zeiten musst Du halt entsprechend anpassen. Es gibt auch plusMillis(int), plusMinutes(int), plusHours(int),... falls die Zeiten etwas extremer sein sollten. Sobald die Speichertemperatur unter 60 gesunken ist, wird die Pumpe beim nächsten Timerdurchlauf gestoppt und der Timer nicht erneut ausgeführt.

[BO80]

Danke für die schnelle Hilfe, damit komme ich zurrecht!
Schade das es keine Literatur gibt, dann muss ich mich eben weiter durch die Forenbeiträge kämpfen.