Steckdose mit variablen Ein-/Auszeiten schalten

[Detlef]

Hallo
Das sieht schon gut aus. Ich kenne deine Heizungsanlage und Steuerung nicht.
Aber in der Regel lässt sich die Zirkulation Pumpe an der Heizungssteuerung ( bei mir A1 siehe Anschlussplan) anschließen .
Damit läuft die Zirkulation Pumpe über deine Heizungsanlage.
Und nicht über eine Steckdose .
Der Vorteil ist erheblich und einfach.
1. Wenn das Legionellen Programm von der Heizungsanlage gestartet wird läuft auch die Zirkulationspumpe für ca. 1 Stunde.
2. wenn die Heizungsanlage innerhalb den 7 Tage erkennen kann, dass die WW Temperatur Öfters über 55 - 60 Grad war, wird kein Legionellen Programm gestaltet.
3. Die Heizungsanlage Steuerung startet das Legionellen Programm auch dann wenn die Heizung und WW auf Stanby geschaltet ist.
4. Die Heizungsanlage Steuerung kann Über die interne Zeit die Zirkulation Pumpe sehr gut Steuern.
Der Heizungsmonteur muss nur die Zirkulation Pumpe an der Heizungsanlage Steuerung anschließen, wenn dann möglich.

[Detlef]

Hallo
Wenn nicht über die Heizungsanlage Steuerung.

Ich hatte ein Schalter Zirkulation Dauerbetrieb und ein Schalter Automatik.
Damit konnte ich die Automatik ausschalten und Dauerbetrieb schalten. Dauerbetrieb war dann noch von der mechanischen Zeitschaltuhr geschaltet

[Scooter_0807]

Hallo Detlef,

danke für Deinen Tip, die Pumpe direkt an die Heizung anzuschließen. Das ginge auch. Allerdings habe ich nur einen Schaltausgang nach außen und der ist aktuell mit einer Alarmfunktion versehen. Sprich: Wenn die Heizung auf eine Störung läuft, dann stehen an dem Ausgang 230V an. Die greife ich mir bereits mit dem Raspberry ab (natürlich ein Schutzrelais dazwischen) und sende per Whatsapp eine Nachricht an mich raus.
Damit kann ich dann von "überall" direkt einen Fachmann anrufen, der die Heizung repariert. Trotz regelmäßiger Wartung ist das auch schonmal vorgekommen.

Eine Zeitschaltuhr hatte ich auch schon im Einsatz. Das hat sogar funktioniert. Allerdings gibt es bei mir auch längere Zeiträume, in denen ich alles ausgeschaltet lasse (auch Warmwasser), dann fällt die gesamte Wassertemparatur unter 25 Grad. Das wollte ich dann alles über einen zentralen Steuerungsmechanismus steuern und möchte das deshalb über den Raspberry/OpenHAB einsetzen, auf dem ich alles konzentriere.

Zu Steigerung der Verlässlichkeit läuft der Raspberry deshalb nicht mehr über eine SDCard, sondern vollständig mit einer SSD-"Platte".

[Detlef]

Ja OK
Welche Heizung Steuerung hast du den .
Ich habe das Wolf Smartset in Betrieb und bekomme auch E-Mail über Wolf Smartset bei einer Störung mit Fehler Nr.

[Scooter_0807]

Wir haben eine Brötje Heizung von 2008 im Einsatz. Zu der Zeit war das mit Smarthome oder Smartheating noch nicht so ausgeprägt. Deshalb sorgt die Elektronik der Therme halt für eine gute Verbrennung aber alle Smart-Funktionen muss man sich selbst basteln.

[udo1toni]

Bitte lasst der Forensoftware Zeit, ein Posting zu veröffentlichen, und falls ihr mal aus Versehen etwas doppelt postet, löscht es auch wieder raus, mit eigenen Postings darf man das

Was die Rules betrifft, so denkst Du unnötig kompliziert und auch falsch.

Ich habe das in einem anderen Thread bereits erläutert, möchte es aber hier noch mal wiederholen:

createTimer() macht exakt eine Sache, es trägt im Scheduler einen Zeitpunkt und den auszuführenden Code ein. Eine Rule wie diese:

Code: Alles auswählen

var Timer tMyTimer = null
rule "create a timer"
when
    System started
then
    tMyTimer = createTimer(now.plusSeconds(x),[|
        // irgendwelche Befehle
    ])
end

Läuft ziemlich genau eine Millisekunde und ist anschließend beendet. Nein, diese Rule hat mit dem auszuführenden Code rein gar nichts zu tun. Dieeser Codeblock:

Code: Alles auswählen

        // irgendwelche Befehle

ist lediglich ein Parameter, der an die Funktion createTimer() übergeben wird. Ausgeführt wird dieser Code durch einen Thread, den der Scheduler zum Zeitpunkt x startet.

Unnötig kompliziert... Du stellst ja über Deine Slider die ON und OFF Dauer ein. Es reicht also eine Rule und auch ein Timer:

Code: Alles auswählen

// Globale Variablen zu Beginn der Datei definieren!
var Timer tZPumpe = null                                      // Timer Zirkulationspumpe

rule "Zirkulationspumpe"
when
    Item ZPumpeAn changed or                                  // falls  An-Zeit verstellt wurde
    Item ZPumpeAus changed                                    // falls Aus-Zeit verstellt wurde
then
    tZPumpe?.cancel                                           // Timer abbrechen, falls vorhanden
    tZPumpe = createTimer(now.plusSeconds(1), [|              // Timer anlegen und gleich ausführen
        var Integer iDauer = 15                               // Default Zeit, falls was schief gegangen ist
        if(ZPumpe.state == ON) {                              // Falls Pumpe gerade eingeschaltet
            ZPumpe.sendCommand(OFF)                           // Ausschalten
            if(ZPumpeAus.state instanaceof Number)            // Falls gültiger Wert für Aus-Zeit
                iDauer = (ZPumpeAus.state as Number).intValue // übernimm diesen als Integer in die Variable
        } else {                                              // Falls Pumpe gerade nicht eingeschaltet
            ZPumpe.sendCommand(ON)                            // Einschalten
            if(ZPumpeAn.state instanaceof Number)             // Falls gültiger Wert für An-Zeit
                iDauer = (ZPumpeAn.state as Number).intValue  // übernimm diesen als Integer in die Variable
        }
        tZPumpe.reschedule(now.plusMinutes(iDauer))           // Plane den Timer mit der Länge iDauer
    ])
end

Eine Rule.

Die Rule tirggert, sobald eine der Einstellungen geändert wurde.
Die beiden Einstellungen sollten persistiert werden, mapdb mit everyChange,restoreOnStartup reicht hierfür, es geht ja nur darum, dass die letzte Einstellung beim Start automatisch geladen wird.
Der Restore zählt übrigens auch als changed, so dass die Rule zum Systemstart mutmaßlich unmittelbar hintereinander zweimal gestartet wird, eben das erste Mal für den einen Parameter, das zweite Mal für den zweiten Parameter.
Gleich zu Beginn wird ein eventuell existierender Timer abgebrochen (weshalb es auch egal ist, dass die Rule zweimal aufgerufen wird). Anschließend wird der Timer erstellt und die Rule ist fertig. Die Rule läuft einmalig, wenn Du einen der beiden Parameter anpasst bzw. die Parameter über restoreOnStartup neu eingelesen werden. Die Ausführungsdauer der Rule liegt bei unter zwei Millisekunden.

Der Scheduler startet nach einer Sekunde den übergebenen Code.
Zuerst wird eine Integer Variable definiert und mit dem Default Wert 15 gefüllt. Dies ist notwendig, um sicher zu verhindern, dass im weiteren Verlauf Fehler auftreten.
Im zweiten Schritt prüft die Rule den Zustand der Pumpe. Ist sie an, so wird sie ausgeschaltet und der eingestellte Wert für die Ausschaltdauer in unsere Variable übernommen (falls denn ein gültiger Wert vorliegt). Ist die Pumpe nicht an, so wird sie eingeschaltet und der eingestellte Wert für die Einschaltdauer in die Variable übernommen (falls gültig...)
Anschließend wird der Timer erneut eingeplant, mit der zuvor bestimmten nächsten Ausführungszeit. Ausführungsdauer des Codeblocks typisch unter 5 Millisekunden.

Ein Watchdog ist sicherlich keine schlechte Idee, immerhin geht es hier um möglichen Verschleiß und Strom- sowie Heizkosten, allerdings sehe ich so eine Funktion nicht innerhalb openHAB. Du müsstest also ein unabhängiges System betreiben, welches den Zustand der Zirkulationspumpe direkt an der Pumpe überwacht. Alle Überwachung innerhalb openHAB ist etwas sinnlos, denn Du bräuchtest dafür ja wieder einen Timer, den Du dann ebenfalls überprüfen müsstest...

[Scooter_0807]

Hallo Udo1toni
...das mehrfach-Veröffentlichen war wohl ich. Ich hatte gedacht, meine Internetleitung hat mal wieder zu viel Latenz
Danke für Deinen Tip alles über einen Timer zu machen. Ja klingt ja logisch.
Außerdem hat mir die kleine Zeile "tZPumpe?.cancel" geholfen, dass man einen Timer auch abbrechen kann.

Ich habe die Skripte zwar in Javascript aber das fummel ich mir raus.

Das Persistieren mache ich im Augenblick komplett mit der rrd4j. Das ist zwar nicht sooo schön aber durch die SSD-Platte funktioniert es.

Mit dem Watchdog meinte ich nicht direkt die Überwachung der Pumpe, sondern eine Überwachung ob überhaupt ein Timer läuft.
Ich werde aber jetzt erst einmal die beiden Rules in eine zusammendampfen und berichten

[udo1toni]

Das Problem mit JacaScript ist an dieser Stelle, dass man keine globale Variable verwenden kann. Eventuell hat inzwischen jemand rausgefunden, wie das korrekt umgesetzt werden kann, ich kenne aber keinen Weg. Sprich, eventuell ist diese Lösung DSL-only (und zwingend als *.rules Datei)

Was die Überwachung der Timer betrifft, kannst Du nur prüfen, ob die Timer-Variable gesetzt ist, und falls das der Fall ist, kannst Du prüfen, ob der Code gerade ausgeführt wird (tMyTimer.isRunning oder so ähnlich...) oder ob der Code ausgeführt wurde (tMyTimer.hasTerminated wenn ich mich nicht irre). Beide Werte beziehen sich aber nicht darauf, ob der Scheduler Task in der Zukunft liegt. isRunning ist also auch nur wenige Millisekunden true, eben während der Code in einem Thread abgearbeitet wird, hasTerminated sollte dagegen so lange auf true sitzen, bis der Timer neu gestartet wurde. Es könnte also sein, dass die Prüfung auf tMyTimer !== null und im Anschluss auf tMyTimer .isRunning und tMyTimer.hasTerminated hinreichend ist, sicher bin ich mir da aber nicht. Mit ist keine Option bekannt, alle Scheduled Tasks anzeigen zu lassen.

[Scooter_0807]

Hallo zusammen,
ich glaube ich konnte anhand Eures Feedbacks das Problem lösen.
1. Ich habe jetzt nur noch eine Rule, über die die Pumpe ein- und ausgeschaltet wird.
2. Die wesentlichen Trigger sind

• Änderungen am Item für die Zirkulationspumpe

• System Startup

• Ein Scheduler, quasi der Watchdog

Dass ich hier noch 2 Itens "Sparmodus" und "Nachtabsenkung" berücksichtige lass ich einmal beiseite.

Nach dem erfolgreichen Startup wird die Rule das erst Mal aufgerufen. Der Timer "PumpenTimer" ist dabei noch "null". Dementsprechend wir die die Pumpe gestartet und der Timer "PumpenTimer" mit der Funktion "AktivPumpExpired" gestartet.
Durch das Starten der Pumpe (Veränderung des Items "FehmarnHeizungZirkulationspumpe") wird die Rule erneut aufgerufen.
Da die Rule den Zustand des Timers "PumpenTimer" prüft und dieser in diesem Moment != null ist wird nur eine Info geloggt und die Rule beendet.

Zwischendurch triggert der Scheduler aber bei laufendem Timer wird die Rule gleich beendet.

Wenn der Timer jetzt abgelaufen ist wird in der Function "AktivPumpExpired " die Pumpe abgeschaltet, indem das Item "FehmarnHeizungZirkulationspumpe" auf OFF gesetzt wird.
Dies löst wiederum ein Event aus, auf dem diese Rule reagiert, der Timer nicht aktiv ist und der Timer wieder gestartet wird. Diesmal jedoch mit der Function "InAktivPumpExpired". ist der Timer abgelaufen wird in dieser Function die Pumpe abgeschaltet, ein Event wird ausgelöst und die Rule erneut durchlaufen....

Das läuft seit 24h ziemlich stabil.

Ich nutze einen Timer, der aber 2 unterschiedliche Funktionen aufruft. Das mache ich nur, weil ich den Code besser lesen kann.

Die beiden zusätzlichen Items für Nachtabsenkung und Sparmodus steuern die Nachttemperatur, respektive das "Herunterfahren" der Heizungsanlage, wenn wir mal in den Ferien sind.

Seht es mir nach, dass mein Logeinträge so lang sind. So kann ich im Log schneller finden wohin welche Meldung gehört. I.d.R. schalte ich Loginfos ab, wenn eine Rule stabil läuft

Grüße
Scooter

Code: Alles auswählen

configuration: {}
triggers:
  - id: "3"
    configuration:
      itemName: FehmarnHeizungZirkulationspumpe
    type: core.ItemStateUpdateTrigger
  - id: "2"
    configuration:
      cronExpression: 0 0/1 * * * ? *
    type: timer.GenericCronTrigger
  - id: "4"
    configuration:
      itemName: FehmarnNachtabsenkung
    type: core.ItemStateChangeTrigger
  - id: "5"
    configuration:
      startlevel: 100
    type: core.SystemStartlevelTrigger
conditions: []
actions:
  - inputs: {}
    id: "1"
    configuration:
      type: application/javascript
      script: >-
        // Logging einschalten
        logger = Java.type('org.slf4j.LoggerFactory').getLogger('org.openhab.rule.' + ctx.ruleUID);
        // ScriptExecution.createTimer
        //Hier gefunden: https://community.openhab.org/t/openhab-3-0-my-getting-started-notes-rules/107203
        // Variablen definieren
        var lv_ZeitraumZirkulationAktiv_num;				// Zeitraum in dem die Zirkulationspumpe aktiv sein soll
        var lv_ZeitraumZirkulationAktiv_item;				// Name des Items
        var lv_ZeitraumZirkulationInAktiv_num;				// Zeitraum in dem die Zirkulationspumpe inaktiv sein soll
        var lv_ZeitraumZirkulationInAktiv_item;				// Name des Items für Inaktivität
        var lv_FehmarnHeizungZirkulationspumpe_state;		// Status des Items
        var lv_FehmarnHeizungZirkulationspumpe_item			// Name des Items
        var lv_FehmarnNachabsenkung_item			        // Name für die Nachtabsenkung
        var lv_FehmarnNachabsenkung_state			        // Status der Nachabsenkung
        var lv_FehmarnHeizungSparmodus_item			        // Name für den Sparmodus
        var lv_FehmarnHeizungSparmodus_state			    // Status des Sparmodus

        var ScriptExecution = Java.type("org.openhab.core.model.script.actions.ScriptExecution");
        var ZonedDateTime = Java.type("java.time.ZonedDateTime");
        var now = ZonedDateTime.now();

        var PumpenTimer;
        // ****************************************************************
        // Variablen setzen 
        // ****************************************************************

        lv_ZeitraumZirkulationAktiv_item = 'FehmarnZirkulationspumpeZeitAktiv';
        lv_FehmarnHeizungZirkulationspumpe_item = 'FehmarnHeizungZirkulationspumpe';		// Name des Items für Aktivitätszeitraum
        lv_ZeitraumZirkulationInAktiv_item = 'FehmarnZirkulationspumpeZeitInAktiv';         // Name des Items für Inaktivitätszeitraum
        lv_FehmarnNachabsenkung_item = 'FehmarnNachtabsenkung';                             // Name des Items für Nachtabsenkung
        lv_FehmarnHeizungSparmodus_item = 'FehmarnGPIOBindung_FehmarnHeizungaufSparmodus';  // Name des Sparmodus


        var AktivPumpExpired = function()  { 
                                logger.info("Rule 'Fehmarn: Zirkulationspumpe Warmwasser ein-/ausschalten': Timer abgelaufen, die Zirkulationspumpe wird abgschaltet");
                                // Das Einschalten der Pumpe ist das Event, das die Regel für Inaktivität der Pumpe auslöst
                                events.sendCommand(lv_FehmarnHeizungZirkulationspumpe_item, "OFF");
                              }

        var InAktivPumpExpired = function()  { 
        						// Schaltzustand der Pumpe abfragen
                                lv_FehmarnHeizungZirkulationspumpe_state = itemRegistry.getItem(lv_FehmarnHeizungZirkulationspumpe_item).getState();
        						// Prüfen ob die Nachtabsenkung aktiv ist
        						lv_FehmarnNachabsenkung_state = itemRegistry.getItem(lv_FehmarnNachabsenkung_item).getState();
        						
                                lv_FehmarnHeizungSparmodus_state = itemRegistry.getItem(lv_FehmarnHeizungSparmodus_item).getState();
        						// Die Pumpe nur einschalten, wenn die Nachtabsenkung und der Sparmodus nicht aktiv ist
                                if (lv_FehmarnNachabsenkung_state != "ON" && lv_FehmarnHeizungSparmodus_state != "ON")	{
        							logger.info("Rule 'Fehmarn: Zirkulationspumpe Warmwasser ein-/ausschalten': Timer abgelaufen, die Zirkulationspumpe wird eingeschaltet");
        							events.sendCommand(lv_FehmarnHeizungZirkulationspumpe_item, "ON");
        						}
                              }

        // logger.info("Rule 'Fehmarn: Zirkulationspumpe Warmwasser ein-/ausschalten': Prüfen wie die Zirkulationspumpe geschaltet werden muss.");
        // ****************************************************************
        // Status auslesen 
        // ****************************************************************

        // Zeitdauer für die aktive Pumpe auslesen
        lv_ZeitraumZirkulationAktiv_num = itemRegistry.getItem(lv_ZeitraumZirkulationAktiv_item).getState();
        //Zeitraum in Sekunden umrechnen
        lv_ZeitraumZirkulationAktiv_num = lv_ZeitraumZirkulationAktiv_num * 60;	

        // Zeitdauer für die inaktive Pumpe auslesen
        lv_ZeitraumZirkulationInAktiv_num = itemRegistry.getItem(lv_ZeitraumZirkulationInAktiv_item).getState();
        //Zeitraum in Sekunden umrechnen
        lv_ZeitraumZirkulationInAktiv_num = lv_ZeitraumZirkulationInAktiv_num * 60;

        // ****************************************************************
        // Aktuellen Schaltzustände ermittlen
        // ****************************************************************
        lv_FehmarnHeizungZirkulationspumpe_state = itemRegistry.getItem(lv_FehmarnHeizungZirkulationspumpe_item).getState();

        // Aktuellen Status der Nachtabsenkung ermittlen
        lv_FehmarnNachabsenkung_state = itemRegistry.getItem(lv_FehmarnNachabsenkung_item).getState();      

        // Aktuellen Status des Sparmodus ermittlen
        lv_FehmarnHeizungSparmodus_state = itemRegistry.getItem(lv_FehmarnHeizungSparmodus_item).getState();

        if (PumpenTimer == null)	{
          // Aktuellen Zustand der Pumpe ermitteln
          lv_FehmarnHeizungZirkulationspumpe_state = itemRegistry.getItem(lv_FehmarnHeizungZirkulationspumpe_item).getState();
          // Zustand der Nachtabsenkung prüfen
          lv_FehmarnNachabsenkung_state = itemRegistry.getItem('FehmarnNachtabsenkung').getState();

          // Prüfen ob die Pumpe eingeschaltet werden soll
          if (lv_FehmarnHeizungZirkulationspumpe_state != "ON" && lv_FehmarnNachabsenkung_state != "ON" && lv_FehmarnHeizungSparmodus_state != "ON") {
                  logger.info("Rule 'Fehmarn: Zirkulationspumpe Warmwasser ein-/ausschalten': Die Zirkulationspumpe, Nachtabsenkung und Sparmodus sind nicht aktiv. Pumpe wird eingeschaltet.");
                  // Pumpe einschalten
                  events.sendCommand(lv_FehmarnHeizungZirkulationspumpe_item, "ON");
                  // Timer für die aktive Pumpe starten
                  var PumpenTimer = ScriptExecution.createTimer(now.plusSeconds(lv_ZeitraumZirkulationAktiv_num), AktivPumpExpired);
          }	
          // Prüfen ob die Pumpe ausgeschaltet werden soll
          if (lv_FehmarnHeizungZirkulationspumpe_state != "OFF" || lv_FehmarnNachabsenkung_state == "ON" || lv_FehmarnHeizungSparmodus_state == "ON") {
                  logger.info("Rule 'Fehmarn: Zirkulationspumpe Warmwasser ein-/ausschalten': Die Zirkulationspumpe ist aktiv oder Nachtabsenkung/Sparmodus sind aktiv. Pumpe wird ausgeschaltet.");
                  // Pumpe ausschalten
                  events.sendCommand(lv_FehmarnHeizungZirkulationspumpe_item, "OFF"); 
                  // Timer für die inaktive Pumpe starten
                  var PumpenTimer = ScriptExecution.createTimer(now.plusSeconds(lv_ZeitraumZirkulationAktiv_num), InAktivPumpExpired);
          }	
        }  else {
          logger.info("Rule 'Fehmarn: Zirkulationspumpe Warmwasser ein-/ausschalten': Rule wurde aufgerufen aber der Timer ist noch aktiv");
        }
    type: script.ScriptAction

[udo1toni]

Ohne jetzt die Rule genauer angeschaut zu haben, denke ich, kann man anhand der schieren Menge an Text erahnen, was nun mehr Arbeit macht...



Was aber das Logging betrifft: Du weißt, dass Du auch noch eine Loggerstufe debug zur Verfügung hast? Und dass Du zur Laufzeit des Systems alle debug-Meldungen rulespezifisch ein- und ausschalten kannst, ganz ohne Kommentarzeichen?