Heizungssteuerung Rules Problem

leupy · Beitrag von **leupy** » 30. Nov 2019 19:08

Hallo udo1toni,
ja das ist richtig.
Leider hab ich große Schwierigkeiten bei erstellen und lesen von Regeln.

Eine PWM mit anpassbaren Weiten, ist weit über dem was ich wollte und geht auch über mein momentanes Verständnis.
Aber Trotzdem vielen vielen Dank dafür.
Da ich am Heizkörper ein Ventil angebracht habe das 3 min Öffnungs/ Schließzeit hat, reicht es mir bei unterschreiten der Temperatur das Ventil mit festen Puls/Pausenzeit von ca 5-7 Min anzusteuern. Damit habe ich im Versuch das Übersteuern der Temperatur im Raum Minimiert. (Ich hatte ein Zeitrelais mit Blinker hinter einen Sonoff Switch gehängt)
Einen Regler für das Ventil aufzubauen ist wegen der Langen Öffnungs/Schließzeit Unsinn.
Es reicht mir wenn die Temp. 2 Grad tiefer wie Soll ist ein Ventil einzuschalten ohne Puls, ab 1 Grad tiefer wie Soll feste Puls / Ruhezeiten z.b 6min.

Der Vorteil von dem Ventil zu herkömmlichen Heizungsstellern sie sind lautlose, günstig und ohne Batterie.
Meines Wissens bekommen die Heizungsregler (z.B von Fritz) über einer Bridge oder Fritzbox einen Temp Wert gesendet von Openhab dieser ist doch dann nur der Sollwert den der Regler am Heizkörper übernimmt und Regelt.
Da sich bei meinen Anordnungen der Heizkörper die Temperatur an diesen Staut fährt der Regler immer zu früh runter. (Suboptimal)

Meine Ist Temp. erfasse ich Mitten im Raum die ich dann Verarbeiten wollte in der Heizungsteuerung mit dem Ventil.
Wie gesagt ich hatte das getestet mit 2 Punktreglung und Zeitrelais.

Wenn das ganze läuft stelle ich das mal vor bei den Projekten im Forum

udo1toni · Beitrag von **udo1toni** » 30. Nov 2019 20:28

2-Punkt-Regelung ist nicht PWM.

5-7 Minuten ist nicht fest

Das Ventil ist normalerweise fest verbaut, entweder im Heizkörper, oder unmittelbar davor in der Zuleitung. Das Ventil wird über einen kleinen Stift betätigt.
Ein konventioneller Thermostat nutzt ein Bimetall, um diesen Stift niederzudrücken.
Batteriegestützte Stelltriebe nutzen einen Elektromotor, um den Stift niederzudrücken, das ist die sparsamste Möglichkeit, die notwendige Kraft aufzubringen.
Die andere Möglichkeit sind thermische Stelltriebe, die wiederum genau wie ein konventioneller Thermostat mit Bimetall arbeiten. Der Stromfluss heizt das Bimetall, welches daraufhin den Stift nicht mehr niederdrückt. Ich gehe mal davon aus, dass Du das mit "Ventil" meinst.

Ja, ich bin pingelig. Nicht böse gemeint.

Mit der WPM-Steuerung kannst Du recht einfach die Heizung steuern. Temperatur zu niedrig -> PWM erhöhen. Temperatur steigt, ist aber immer noch zu niedrig -> PWM beibehalten. Temperatur zu hoch -> PWM verringern. Temperatur Sinkt, ist aber immer noch zu hoch -> PWM beibehalten. man wird halt erst mal etwas experimentieren müssen, bis das Regelverhalten auch vernünftig funktioniert.

leupy · Beitrag von **leupy** » 1. Dez 2019 13:53

Das Ventil ist eine Wachsmotor (Thermischer Stellantrieb) der anstatt des Thermostat Reglers aus die Heikörper geschraubt wird.
So ich hab mal versucht das alles in eine Regel zu packen und habe einen kleinen Regler für den Anfang in eine Regel gepackt.
Ich habe noch 2 Items als Merker angelegt.
Switch Merker_EH_Ein //Heizung ein Tag
Switch Merker_EHN_Ein // Heizung ein Nacht
Leider kommt noch ein Fehler und das ganze Konstrukt will nicht so ganz.

[ERROR] [ntime.internal.engine.RuleEngineImpl] - Rule 'Regler EZH': An error occurred during the script execution: index=1, size=1

Code: Alles auswählen

//--------------------------------------------------- 
// Heizung Esszimmer
//--------------------------------------------------- 
// Globale Variablen werden zu Beginn der Datei definiert

var Timer tPWM = null                                            // ein Timer
var Boolean bPWM = false                                         // ON- oder OFF-Phase
var Number nPWM = 100                                             // ON-Puls in %

rule "Init Heizung"
when
    System started or 
    Time cron "0 00 21 * * ?"
then
 
    Heizung_E_Soll.postUpdate(21.0)
    Heizung_E_Soll_N.postUpdate(18.0)
end
//----------------------------------------------------
//Ezzimmer Einschaltbedingung über Zeit und Temp 
//----------------------------------------------------
rule "Heizung WZ Ist/Soll vergleich"
when
    Item Sonoff86Temp changed or                                        // Istwert Temp 
    Item Heizung_E_Soll changed or                                      // Sollwert Heizung 
    Item Heizung_E_Soll_N changed                                       // Sollwert Nacht Heizung 
then
    val Number wtsp_E = (Heizung_E_Soll.state as Number ).doubleValue     // Temperatur Soll Tag
    val Number wtspN_E = (Heizung_E_Soll_N.state as Number).doubleValue   // Temperatur Soll Nacht 
    val Number wtsi_E = (Sonoff86Temp.state as Number).doubleValue        // Temperatur Ist

    val Integer hour = now.getHourOfDay
    val Integer min = now.getMinuteOfDay
    val Integer wd = now.getDayOfWeek

    if(wd <= 5 && min > 5*60+44 && hour < 20)                           // Wochentags (Mo - Fr 5:45Uhr-20:00Uhr)
        {logInfo("heizung.rules", "HE läuft MO-FR")
        Merker_EH_Ein.sendCommand(if(wtsi_E < wtsp_E) ON else OFF)}     // Setze Merker Heizung Ein
    else if (wd >= 6 && hour > 7 &&  hour < 20)                         // Wochende (Sa - So 8:00-20:00Uhr)
        {logInfo("heizung.rules", "HE läuft SA-SO")
        Merker_EH_Ein.sendCommand(if (wtsi_E < wtsp_E) ON else OFF)}    // Setze Merker Heizung Ein
    else                                                                // Absenkung Nacht
        {logInfo("heizung.rules", "HE läuft Nachtabsenkung")
        Merker_EHN_Ein.sendCommand(if (wtsi_E < wtspN_E) ON else OFF)} // Setze Merker Nachtabsenkung
end
//------------------------------------------------------------------
//Regler Esszimmerheizung Normal temp
rule "Regler EZH"
when
 Item Merker_EH_Ein changed to ON
then
    Merker_EH_Ein.sendCommand OFF
    if (wtsi_E => wtsp_E )                                         // Ist >= Soll Temp
         { nPWM = 0 }                                              //Heizung Aus
    else if ((wtsi_E => (wtsp_E - 1)) && (wtsi_E <= (wtsp_E - 0.5)))  // Ist => Soll minus 0,5 - 1 Grad   
         { nPWM = 50 }                                             //Heizung EIN Pulsweite 5min
    else if ((wtsi_E > (wtsp_E - 0.5)) && (wtsi_E < wtsp_E))         // Ist > Soll minus 0,5 bis Soll
         { nPWM = 30 }                                             //Heizung EIN Pulsweite 3min     
    else
         { nPWM = 100 }                                            //Heizung Ein 100 %
end
//-----------------------------------------------------------------
//Regler Esszimmerheizung Nacht temp
rule "Regler EZH Nacht"
when
 Item Merker_EHN_Ein changed to ON
then
    Merker_EHN_Ein.sendCommand OFF
    if (wtsi_E => wtspN_E )                                         // Ist >= Soll Temp
         { nPWM = 0 }                                               //Heizung Aus
    else if ((wtsi_E => (wtspN_E - 1)) && (wtsi_E <= (wtspN_E - 0.5)))  // Ist => Soll minus 0,5 - 1 Grad   
         { nPWM = 50 }                                              //Heizung EIN Pulsweite 5min
    else if ((wtsi_E > (wtspN_E - 0.5)) && (wtsi_E < wtspN_E))         // Ist > Soll minus 0,5 bis Soll
         { nPWM = 30 }                                              //Heizung EIN Pulsweite 3min     
    else
         { nPWM = 100 }                                             //Heizung Ein 100 %
end
//------------------------------------------------------------------
// PWM Puls Weiten Modulation
rule "Heizung PWM"
when
    System started                                               // Rule wird nur zur Initialisierung benötigt
then
    tPWM?.cancel                                                 // falls Timer bereits vorhanden, entfernen
    tPWM = createTimer(now.plusMillis(100), [|                   // Timer erzeugen und nach 100Millisekunden starten
        var Integer nTime = 0                                    // Hilfsvariable Pulsweite
        var sHeiz = OFF                                          // Hilfsvariable Sollzustand
        bPWM = !bPWM                                             // zwischen ON- und OFF-Phase wechseln
        if(!(nPWM instanceof Number)) {                          // keine gültiger Wert? (keine Zahl)
            logWarn("pwm","nPWM ungültig! {}",nPWM)
            nPWM = 0                                             // setze auf 0
        } else if (nPWM < 0) {                                   // kein gültiger Wert? (kleiner 0)
            logWarn("pwm","nPWM ungültig! {} ist kleiner 0",nPWM)
            nPWM = 0                                             // setze auf 0
        } else if (nPWM > 100) {                                 // kein gültiger Wert? (größer 100)
            logWarn("pwm","nPWM ungültig! {} ist größer 100",nPWM)
            nPWM = 100                                           // setze auf 100
        }
        switch (nPWM.intValue) {                                 // unterscheide zwischen
            case 0: {                                            // 0 -> OFF
                nTime = 600                                      // fix 10 Minuten
                sHeiz = OFF                                      // Sollzustand OFF
            }
            case 100: {                                          // 100 -> ON
                nTime = 600                                      // fix 10 Minuten
                sHeiz = ON                                      // Sollzustand ON
            }
            default: {                                           // 1 bis 99 -> phasenabhängig ON oder OFF
                nTime = 6 * if(bPWM) nPWM else 100-nPWM          // falls ON-Phase normale Pulsweite, sonst invertierte Pulsweite
                sHeiz = if(bPWM) ON else OFF                     // Sollzustand phasenabhängig
            }
        }
        if(Heizung_E.state != sHeiz)                               // Falls Heizung nicht auf Sollstatus
            Heizung_E.sendCommand(sHeiz)                           // Heizung auf Sollstatus
        tPWM.reschedule(now.plusSeconds(nTime))                  // Timer erneut in nTime Sekunden ausführen
    ])
end

peter-pan · Beitrag von **peter-pan** » 1. Dez 2019 17:21

leupy hat geschrieben: ↑1. Dez 2019 13:53 [ERROR] [ntime.internal.engine.RuleEngineImpl] - Rule 'Regler EZH': An error occurred during the script execution: index=1, size=1

Hat das Rule-File das richtige Format (UTF8) ?

udo1toni · Beitrag von **udo1toni** » 2. Dez 2019 00:23

Du definierst wtsp_E, wtspN_E und wtsi_E innerhalb einer Rule, greifst aber innerhalb anderer Rules darauf zu, das funktioniert nicht. Abgesehen davon denkst Du etwas zu kompliziert und vermischst Funktionen. Z.B. die Rule Soll/Istvergleich kümmert sich zwar um den Temperaturvergleich, aber gleichzeitig auch um die Zeitsteuerunng. Andererseits verwendest Du zwei weitere Rules, um letztlich das gleiche zu tun. Besser wäre es, die Betriebsart (Komfort/Nachtabsenkung) über zwei Rules zu steuern:

Code: Alles auswählen

rule "Heizung Tag"
when
    Time cron "0 45 5 ? * MON-FRI" or // Werktags   05:45:00 Uhr
    Time cron "0 0 8 ? * SAT-SUN"     // Wochenende 08:00:00 Uhr
then
    HeizungMode.postUpdate(ON)
end

rule "Heizung Nacht"
when
    Time cron "0 0 20 * * ?"          // Täglich 20:00:00 Uhr
then
    HeizungMode.postUpdate(OFF)
end

Diese beiden Rules kümmern sich also ausschließlich um die Wahl der aktuellen Solltemperatur.

Nun kannst Du den Temperaturvergleich in einer Rule vornehmen:

Code: Alles auswählen

rule "Heizung WZ Ist/Soll vergleich"
when
    Item Sonoff86Temp changed or                                        // Istwert Temp 
    Item Heizung_E_Soll changed or                                      // Sollwert Heizung 
    Item Heizung_E_Soll_N changed or                                    // Sollwert Nacht Heizung 
    Item HeizungMode changed
then
    val Number wtsi_E = (Sonoff86Temp.state as Number).doubleValue      // Temperatur Ist
    var Number nSoll = (Heizung_E_Soll_N.state as Number).doubleValue   // erstmal Temperatur Soll Nacht setzen

    if(HeizungMode.state == ON) {
        logInfo("heizung", "Komfort")
        nSoll = (Heizung_E_Soll.state as Number ).doubleValue           // Falls Komfort, Temperatur Soll Tag setzen
    }
    nPWM = 0                                                            // erst mal PWM 0
    if(wtsi_E < nSoll)       nPWM = 30                                  // Ist > Soll minus 0,5 bis Soll
    if(wtsi_E < nSoll - 0.5) nPWM = 50                                  // Ist => Soll minus 0,5 - 1 Grad
    if(wtsi_E < nSoll -1 )   nPWM = 100                                 // ansonsten
end

Durch die Reihenfolge der if-Anweiseungen reicht die einfache Bedingung aus, nur falls man die Reihenfolge der Bedingungen ändert, müssen mehrere Vergleiche angestellt werden. Es darf in diesem Fall kein else verwendet werden.

leupy · Beitrag von **leupy** » 2. Dez 2019 18:26

Ich blick das einfach nicht, dein Vorschlag ist um weitest einfacher wie meine Idee.
Ich hab das jetzt alles mal angepasst. Es funktioniert so weit das jetzt Zeitabhängig die Soll Temperaturen angewählt werden.
Im Log steht auch der Mode aber das Item für das Ventil "Heizung_E" wird nie auf On bzw Off gesetzt von der PWM.
Kann mann in die PWM ein Log einbauen das ich sehe wie die PWN läuft und unter welcher Pulsweite ? (zur besseren Fehlersuche)

Heizung.PNG

Code: Alles auswählen

//--------------------------------------------------- 
// Heizung Esszimmer
//--------------------------------------------------- 
// Globale Variablen werden zu Beginn der Datei definiert

var Timer tPWM = null                                            // ein Timer
var Boolean bPWM = false                                         // ON- oder OFF-Phase
var Number nPWM = 100                                            // ON-Puls in %

rule "Init Heizung"
when
    System started or 
    Time cron "0 00 21 * * ?"
then
 
    Heizung_E_Soll.postUpdate(21.0)
    Heizung_E_Soll_N.postUpdate(18.0)
end
//----------------------------------------------------
//Essimmer Einschaltbedingung über Zeit 
//----------------------------------------------------
rule "Heizung Tag"
when
    Time cron "0 45 5 ? * MON-FRI" or // Werktags   05:45:00 Uhr
    Time cron "0 0 8 ? * SAT-SUN"     // Wochenende 08:00:00 Uhr
then
    HeizungMode.postUpdate(ON)          //Heizung Tag an wenn ON
end

rule "Heizung Nacht"
when
    Time cron "0 0 20 * * ?"            // Täglich 20:00:00 Uhr
then
    HeizungMode.postUpdate(OFF)         //Heizung Nacht an wenn OFF
end
//----------------------------------------------------
//Esszimmer Soll/ist Vergleich Temperatur und setzen von Puls Variablen
//----------------------------------------------------
rule "Heizung WZ Ist/Soll vergleich"
when
    Item Sonoff86Temp changed or                                        // Istwert Temp 
    Item Heizung_E_Soll changed or                                      // Sollwert Heizung 
    Item Heizung_E_Soll_N changed or                                    // Sollwert Nacht Heizung 
    Item HeizungMode changed
then
    val Number wtsi_E = (Sonoff86Temp.state as Number).doubleValue      // Temperatur Ist
    var Number nSoll = (Heizung_E_Soll_N.state as Number).doubleValue   // erstmal Temperatur Soll Nacht setzen

    if(HeizungMode.state == ON) {
        logInfo("heizung", "Komfort")
        nSoll = (Heizung_E_Soll.state as Number ).doubleValue           // Falls Komfort, Temperatur Soll Tag setzen
    }
    nPWM = 0                                                            // erst mal PWM 0
    if(wtsi_E < nSoll)       nPWM = 30                                  // Ist > Soll minus 0,5 bis Soll
    if(wtsi_E < nSoll - 0.5) nPWM = 50                                  // Ist => Soll minus 0,5 - 1 Grad
    if(wtsi_E < nSoll -1 )   nPWM = 100                                 // ansonsten
end
//------------------------------------------------------------------
// PWM Puls Weiten Modulation
rule "Heizung PWM"
when
    System started                                               // Rule wird nur zur Initialisierung benötigt
then
    tPWM?.cancel                                                 // falls Timer bereits vorhanden, entfernen
    tPWM = createTimer(now.plusMillis(100), [|                   // Timer erzeugen und nach 100Millisekunden starten
        var Integer nTime = 0                                    // Hilfsvariable Pulsweite
        var sHeiz = OFF                                          // Hilfsvariable Sollzustand
        bPWM = !bPWM                                             // zwischen ON- und OFF-Phase wechseln
        if(!(nPWM instanceof Number)) {                          // keine gültiger Wert? (keine Zahl)
            logWarn("pwm","nPWM ungültig! {}",nPWM)
            nPWM = 0                                             // setze auf 0
        } else if (nPWM < 0) {                                   // kein gültiger Wert? (kleiner 0)
            logWarn("pwm","nPWM ungültig! {} ist kleiner 0",nPWM)
            nPWM = 0                                             // setze auf 0
        } else if (nPWM > 100) {                                 // kein gültiger Wert? (größer 100)
            logWarn("pwm","nPWM ungültig! {} ist größer 100",nPWM)
            nPWM = 100                                           // setze auf 100
        }
        switch (nPWM.intValue) {                                 // unterscheide zwischen
            case 0: {                                            // 0 -> OFF
                nTime = 600                                      // fix 10 Minuten
                sHeiz = OFF                                      // Sollzustand OFF
            }
            case 100: {                                          // 100 -> ON
                nTime = 600                                      // fix 10 Minuten
                sHeiz = ON                                      // Sollzustand ON
            }
            default: {                                           // 1 bis 99 -> phasenabhängig ON oder OFF
                nTime = 6 * if(bPWM) nPWM else 100-nPWM          // falls ON-Phase normale Pulsweite, sonst invertierte Pulsweite
                sHeiz = if(bPWM) ON else OFF                     // Sollzustand phasenabhängig
            }
        }
        if(Heizung_E.state != sHeiz)                               // Falls Heizung nicht auf Sollstatus
            Heizung_E.sendCommand(sHeiz)                           // Heizung auf Sollstatus
        tPWM.reschedule(now.plusSeconds(nTime))                    // Timer erneut in nTime Sekunden ausführen
    ])
end

Diese Meldung taucht noch im Log auf

Code: Alles auswählen

2019-12-02 18:34:29.342 [ERROR] [org.quartz.core.ErrorLogger         ] - Job (DEFAULT.2019-12-02T18:24:29.194+01:00: Proxy for org.eclipse.xtext.xbase.lib.Procedures$Procedure0: [ | {

  var nTime

  var sHeiz

  <null>.bPWM = <XUnaryOperationImplCustom>

  org.eclipse.xtext.xbase.impl.XIfExpressionImpl@1df5181

  org.eclipse.xtext.xbase.impl.XSwitchExpressionImpl@131c68b

  org.eclipse.xtext.xbase.impl.XIfExpressionImpl@3a8f6c

  <XFeatureCallImplCustom>.reschedule(<XMemberFeatureCallImplCustom>)

} ] threw an exception.

org.quartz.SchedulerException: Job threw an unhandled exception.

	at org.quartz.core.JobRunShell.run(JobRunShell.java:213) [107:org.eclipse.smarthome.core.scheduler:0.10.0.oh240]

	at org.quartz.simpl.SimpleThreadPool$WorkerThread.run(SimpleThreadPool.java:573) [107:org.eclipse.smarthome.core.scheduler:0.10.0.oh240]

Caused by: java.lang.NullPointerException

	at org.eclipse.smarthome.model.script.engine.ScriptError.<init>(ScriptError.java:66) ~[?:?]

	at org.eclipse.smarthome.model.script.interpreter.ScriptInterpreter.invokeFeature(ScriptInterpreter.java:140) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.XbaseInterpreter._doEvaluate(XbaseInterpreter.java:902) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.XbaseInterpreter._doEvaluate(XbaseInterpreter.java:865) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.XbaseInterpreter.doEvaluate(XbaseInterpreter.java:224) ~[?:?]

	at org.eclipse.smarthome.model.script.interpreter.ScriptInterpreter.doEvaluate(ScriptInterpreter.java:226) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.XbaseInterpreter.internalEvaluate(XbaseInterpreter.java:204) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.XbaseInterpreter._doEvaluate(XbaseInterpreter.java:827) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.XbaseInterpreter.doEvaluate(XbaseInterpreter.java:264) ~[?:?]

	at org.eclipse.smarthome.model.script.interpreter.ScriptInterpreter.doEvaluate(ScriptInterpreter.java:226) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.XbaseInterpreter.internalEvaluate(XbaseInterpreter.java:204) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.XbaseInterpreter._doEvaluate(XbaseInterpreter.java:447) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.XbaseInterpreter.doEvaluate(XbaseInterpreter.java:228) ~[?:?]

	at org.eclipse.smarthome.model.script.interpreter.ScriptInterpreter.doEvaluate(ScriptInterpreter.java:226) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.XbaseInterpreter.internalEvaluate(XbaseInterpreter.java:204) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.XbaseInterpreter.evaluate(XbaseInterpreter.java:190) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.ClosureInvocationHandler.doInvoke(ClosureInvocationHandler.java:46) ~[?:?]

	at org.eclipse.xtext.xbase.interpreter.impl.AbstractClosureInvocationHandler.invoke(AbstractClosureInvocationHandler.java:29) ~[?:?]

	at com.sun.proxy.$Proxy151.apply(Unknown Source) ~[?:?]

	at org.eclipse.smarthome.model.script.internal.actions.TimerExecutionJob.execute(TimerExecutionJob.java:49) ~[?:?]

	at org.quartz.core.JobRunShell.run(JobRunShell.java:202) ~[?:?]

	... 1 more

udo1toni · Beitrag von **udo1toni** » 2. Dez 2019 23:49

Die Fehlermeldung ist einigermaßen seltsam. Hier mal die pwm-Rule mit etwas zusätzlichem Logging:

Code: Alles auswählen

rule "Heizung PWM"
when
    System started                                               // Rule wird nur zur Initialisierung benötigt
then
    tPWM?.cancel                                                 // falls Timer bereits vorhanden, entfernen
    tPWM = createTimer(now.plusMillis(100), [|                   // Timer erzeugen und nach 100Millisekunden starten
        logInfo("pwm","Timer wird ausgeführt!")
        var Integer nTime = 0                                    // Hilfsvariable Pulsweite
        var sHeiz = OFF                                          // Hilfsvariable Sollzustand
        bPWM = !bPWM                                             // zwischen ON- und OFF-Phase wechseln
        logInfo("pwm","Pulsphase: {}",bPWM)
        if(!(nPWM instanceof Number)) {                          // keine gültiger Wert? (keine Zahl)
            logWarn("pwm","nPWM ungültig! {}",nPWM)
            nPWM = 0                                             // setze auf 0
        } else if (nPWM < 0) {                                   // kein gültiger Wert? (kleiner 0)
            logWarn("pwm","nPWM ungültig! {} ist kleiner 0",nPWM)
            nPWM = 0                                             // setze auf 0
        } else if (nPWM > 100) {                                 // kein gültiger Wert? (größer 100)
            logWarn("pwm","nPWM ungültig! {} ist größer 100",nPWM)
            nPWM = 100                                           // setze auf 100
        }
        logInfo("pwm","Pulslänge: {}",nPWM)
        switch (nPWM.intValue) {                                 // unterscheide zwischen
            case 0: {                                            // 0 -> OFF
                nTime = 600                                      // fix 10 Minuten
                sHeiz = OFF                                      // Sollzustand OFF
            }
            case 100: {                                          // 100 -> ON
                nTime = 600                                      // fix 10 Minuten
                sHeiz = ON                                      // Sollzustand ON
            }
            default: {                                           // 1 bis 99 -> phasenabhängig ON oder OFF
                nTime = 6 * if(bPWM) nPWM else 100-nPWM          // falls ON-Phase normale Pulsweite, sonst invertierte Pulsweite
                sHeiz = if(bPWM) ON else OFF                     // Sollzustand phasenabhängig
            }
        }
        logInfo("pwm","Heizphase: {}",sHeiz)
        if(Heizung_E.state != sHeiz)                               // Falls Heizung nicht auf Sollstatus
            Heizung_E.sendCommand(sHeiz)                           // Heizung auf Sollstatus
        tPWM.reschedule(now.plusSeconds(nTime))                    // Timer erneut in nTime Sekunden ausführen
    ])
end

Es wäre interessant, zu sehen, an welcher Stelle des Timers der Fehler auftritt. (konkret, ob, und wenn ja, welche logMeldungen vor dem Fehler auftreten).

leupy · Beitrag von **leupy** » 3. Dez 2019 18:30

Hallo, so sieht das aus wenn der Fehler aufläuft.

Code: Alles auswählen

2019-12-03 17:57:31.254 [INFO ] [g.eclipse.smarthome.model.script.pwm] - Timer wird ausgeführt!

2019-12-03 17:57:31.265 [INFO ] [g.eclipse.smarthome.model.script.pwm] - Pulsphase: false

2019-12-03 17:57:31.277 [INFO ] [g.eclipse.smarthome.model.script.pwm] - Pulslänge: 50

2019-12-03 17:57:31.290 [INFO ] [g.eclipse.smarthome.model.script.pwm] - Heizphase: OFF

2019-12-03 17:57:31.299 [ERROR] [org.quartz.core.JobRunShell         ] - Job DEFAULT.2019-12-03T17:47:31.224+01:00: Proxy for org.eclipse.xtext.xbase.lib.Procedures$Procedure0: [ | {

  logInfo(<XStringLiteralImpl>,<XStringLiteralImpl>)

  var nTime

  var sHeiz

  <null>.bPWM = <XUnaryOperationImplCustom>

udo1toni · Beitrag von **udo1toni** » 4. Dez 2019 00:27

Eventuell sollte da ein zusätzliches Klammernpaar stehen

(um den ternären Operator)

Code: Alles auswählen

            default: {                                           // 1 bis 99 -> phasenabhängig ON oder OFF
                nTime = 6 * (if(bPWM) nPWM else 100-nPWM)        // falls ON-Phase normale Pulsweite, sonst invertierte Pulsweite
                sHeiz = if(bPWM) ON else OFF                     // Sollzustand phasenabhängig
            }

leupy · Beitrag von **leupy** » 5. Dez 2019 17:26

Hallo udo1toni ich habe das geändert erste Pulsphase lief ohne Probleme 10 MIN

Code: Alles auswählen

2019-12-05 17:03:13.827 [INFO ] [g.eclipse.smarthome.model.script.pwm] - Timer wird ausgeführt!
2019-12-05 17:03:13.832 [INFO ] [g.eclipse.smarthome.model.script.pwm] - Pulsphase: true
2019-12-05 17:03:13.845 [INFO ] [g.eclipse.smarthome.model.script.pwm] - Pulslänge: 100
2019-12-05 17:03:13.850 [INFO ] [g.eclipse.smarthome.model.script.pwm] - Heizphase: ON

2019-12-05 17:03:13.860 [ome.event.ItemCommandEvent] - Item 'Heizung_E' received command ON

dann auf Wechsel auf kleinere Pulslänge kommt wieder ein Fehler

Code: Alles auswählen

2019-12-05 17:13:13.864 [INFO ] [g.eclipse.smarthome.model.script.pwm] - Timer wird ausgeführt!
2019-12-05 17:13:13.873 [INFO ] [g.eclipse.smarthome.model.script.pwm] - Pulsphase: false
2019-12-05 17:13:13.885 [INFO ] [g.eclipse.smarthome.model.script.pwm] - Pulslänge: 30
2019-12-05 17:13:13.899 [INFO ] [g.eclipse.smarthome.model.script.pwm] - Heizphase: OFF
2019-12-05 17:13:13.911 [ome.event.ItemCommandEvent] - Item 'Heizung_E' received command OFF

2019-12-05 17:13:13.911 [ERROR] [org.quartz.core.JobRunShell         ] - Job DEFAULT.2019-12-05T17:03:13.824+01:00: Proxy for org.eclipse.xtext.xbase.lib.Procedures$Procedure0: [ | {

hast du da noch eine Idee

Heizungssteuerung Rules Problem

Re: Heizungssteuerung Rules Problem

Re: Heizungssteuerung Rules Problem

Re: Heizungssteuerung Rules Problem

Re: Heizungssteuerung Rules Problem

Re: Heizungssteuerung Rules Problem

Re: Heizungssteuerung Rules Problem

Re: Heizungssteuerung Rules Problem

Re: Heizungssteuerung Rules Problem

Re: Heizungssteuerung Rules Problem

Re: Heizungssteuerung Rules Problem