Hi,

ich habe vor kurzem die Ventilsteuerung meiner Fussbodenheizungssteuerung auf ioBroker umgestellt. Nachdem ich einige ANsätze, auch hier aus dem Forum nicht kapiert habe, bin ich im Homematic-Forum fündig geworden.

Basierend auf dem Skript "Fußbodenheizung - Steuerung/IR-Heizung-Steuerung" von twoxx aus dem Homematic-Forum (https://homematic-forum.de/forum/viewto … 31&t=24890) habe ich das nach ioBroker JavaScript portiert und etwas verschlankt.

Das interessante an dem Skriptansatz ist, dass es die Raumtemperatur "überwacht" und versucht die Ventile früh genug auszuschalten das die Temperatur nicht übersteuert, aber auch früh genug wieder einzuschalten. Das ganze folgt einem PWM-Ansatz im Default auf das 20 Minuten Skriptintervall und schaltet daher auch teilweise nur für ein paar Minuten ein.

Details zur Funktionsweise und der wichtigen Konfigurationsparameter am besten im Original-Thread im Homematic-Forum informieren. Die Parameternamen sind weiterstgehend die gleichen. Ich habe nur ein paar Dinge (Sicherheitsheizen bei bestimmten Außentemperaturen) weggenommen und einige Dinge so umgebaut das die Entwicklung der letzten 3 Skriptläufe (=60Min) "rollierend" betrachtet werden können.

In den Räumen an sich habe ich überall Homematic-Wandthermostate angebracht und die Ventile werden über Homematic-Schaltaktoren gesteuert. Die Skripte sind aber grundsätzlich so flexibel das problemlos auch andere Hersteller eingesetzt werden können. Keins davon steuert irgendwas an den Ventilen direkt, das macht alles dieses Skript!

Das Skript hier ist aber unabhängig von der Art wie die Thermostate und Programme ablaufen, es nimmt die Ist- und Solltemperarturen und steuert dann die Ventil-Aktoren.

Die Konfiguration besteht aus drei Teilen:

1.) Die Raum-Objekte am Anfang haben einen Eintrag pro Raum mit State-ID Definitionen. Die Namen der Räume können frei gewählt werden und sind primär für das Logging interessant. Die State-IDs wie bei "OG-Bad" zu sehen sind Pflicht. Bei EG-Wohnzimmer habe ich noch einen zweiten Heizkreis den ich nur zum hochheizen als "Unterstützung" nutze, der bleibt zum halten der Temperatur aber aus. Darüber könnte man auch ein IR-Panel oder einen Heizlüfter mit nutzen.

2.) Die 4 Werte danach definieren die Rahmenbedingungen für die Steuerung. Details siehe Homematic Forum, da ist auch eine Grafik :-)

Weiterhin kann man ausführliches Logging aktivieren.

3.) In der Funktion "initialize" werden noch einige Grundwerte eingetragen, die eher statisch sind.

In "Schaltschwelleniedertemp" und "Schaltschwellehochtemp" stehen an sich die Laufzeiten der Ventile (Auf-Zu) drin. Sind bei mir etwas mehr als 3 Minuten, sollte jeder selbst ermitteln.

In "heizunterstuetzungKelvin" ist drin ab wieviel Kelvin (=Grad) Temperaturunterschied ein pot. angegebener Unterstützungsaktor genutzt wird

Man kann all diese Object-Keys, wenn man Sie pro Raum anders braucht, auch direkt im rooms-Objekt beim Raum setzen, dann wird das genutzt.

Hier das Skript (20180101)

// Thread im ioBroker-Forum: http://forum.iobroker.net/viewtopic.php?f=21&t=10111

var rooms= {
    'DG-Luca': {
        stateIdHeizungAktor: "hm-rpc.0.LEQ0282183.3.STATE",
        stateIdHeizungAktorOnTime: "hm-rpc.0.LEQ0282183.3.ON_TIME",
        stateIdSollTemperatur: "hm-rpc.0.NEQ0072178.2.SET_TEMPERATURE",
        stateIdIstTemperatur: "hm-rpc.0.NEQ0072178.1.TEMPERATURE"
    },
    'DG-Jana': {
        stateIdHeizungAktor: "hm-rpc.0.LEQ0282183.2.STATE",
        stateIdHeizungAktorOnTime: "hm-rpc.0.LEQ0282183.2.ON_TIME",
        stateIdSollTemperatur: "hm-rpc.0.NEQ0072437.2.SET_TEMPERATURE",
        stateIdIstTemperatur: "hm-rpc.0.NEQ0072437.1.TEMPERATURE"
    },
    'DG-Duschbad': {
        stateIdHeizungAktor: "hm-rpc.0.LEQ0282183.1.STATE",
        stateIdHeizungAktorOnTime: "hm-rpc.0.LEQ0282183.1.ON_TIME",
        stateIdSollTemperatur: "hm-rpc.0.NEQ0071913.2.SET_TEMPERATURE",
        stateIdIstTemperatur: "hm-rpc.0.NEQ0071913.1.TEMPERATURE"
    },
    'OG-Bad': {
        stateIdHeizungAktor: "hm-rpc.0.NEQ1503796.1.STATE",
        stateIdHeizungAktorOnTime: "hm-rpc.0.NEQ1503796.1.ON_TIME",
        stateIdSollTemperatur: "hm-rpc.0.NEQ0124378.2.SET_TEMPERATURE",
        stateIdIstTemperatur: "hm-rpc.0.NEQ0071913.1.TEMPERATURE"
    },
    'EG-Wohnzimmer': {
        stateIdHeizungAktor: "hm-rpc.0.OEQ0653582.1.STATE",
        stateIdHeizungAktorOnTime: "hm-rpc.0.OEQ0653582.1.ON_TIME",
        stateIdHeizungUnterstuetzungAktor: "hm-rpc.0.MEQ0361527.1.STATE",
        stateIdHeizungUnterstuetzungAktorOnTime: "hm-rpc.0.MEQ0361527.1.ON_TIME",
        stateIdSollTemperatur: "hm-rpc.0.OEQ0987006.2.SET_TEMPERATURE",
        stateIdIstTemperatur: "hm-rpc.0.JEQ0122620.1.TEMPERATURE"
    }
};
var hochtempAufschlag = 0.5; // hochtemp = solltemperatur + hochtempAufschlag
var niedertempAbschlag = 1; // niedertemp = solltemperatur - niedertempAbschlag
var hochstillAufschlag = 0.1; // hochstill = solltemperatur + hochstillAufschlag
var niederstillAbschlag = 0.2; // niederstill = solltemperatur - niederstillAbschlag

var debug = true;

initialize();

function initialize() {
    for (var room in rooms) {
        if (!rooms[room].Sicherheitsheizzeit) rooms[room].Sicherheitsheizzeit = 240; // Heizzeit, falls errechnete Heizzeit im Minus
        if (!rooms[room].Schaltschwelleniedertemp) rooms[room].Schaltschwelleniedertemp = 190; // Sofern errechnete Schaltzeit kleiner, dann nicht einschalten
        if (!rooms[room].Schaltschwellehochtemp) rooms[room].Schaltschwellehochtemp = 190; // Sofern errechnete Schaltzeit kleiner, dann nicht einschalten
        if (!rooms[room].skriptZyklus) rooms[room].skriptZyklus = 20;
        if (!rooms[room].heizunterstuetzungKelvin) rooms[room].heizunterstuetzungKelvin = 1;  // Wenn Temperaturunterschied größer als diese ANzahl Kelvon dann wird Unterstützung verwendet

        if (!rooms[room].FBStartTemperatur) rooms[room].FBStartTemperatur = [];
        if (!rooms[room].StartHeizzeit) rooms[room].StartHeizzeit = [new Date().getTime()-1000*60];
        if (!rooms[room].FBVergleichTemp) rooms[room].FBVergleichTemp = 0;

        if (rooms[room].hochtempAufschlag === undefined) rooms[room].hochtempAufschlag = hochtempAufschlag;
        if (rooms[room].niedertempAbschlag === undefined) rooms[room].niedertempAbschlag = niedertempAbschlag;
        if (rooms[room].hochstillAufschlag === undefined) rooms[room].hochstillAufschlag = hochstillAufschlag;
        if (rooms[room].niederstillAbschlag === undefined) rooms[room].niederstillAbschlag = niederstillAbschlag;

        rooms[room].letztesEIN = 0;
        rooms[room].skriptTimeout = null;

        if (getState(rooms[room].stateIdHeizungAktor).val) {
            if (debug) {console.log('    ' + room + ': Aktor eingeschaltet');}
            rooms[room].letztesEIN = new Date().getTime();
        }

        initializeSubscribes(room);

        if (debug) {console.log('Ventillogik für Raum ' + room + ' initialisiert');}
        ventilLogik(room);
    }
}

function initializeSubscribes(room) {
    on({id: rooms[room].stateIdHeizungAktor, change: 'any'}, function(state) {
        if (debug) {console.log('Änderung Status Aktor FBH ' + room + ': ' + state.oldState.val + '--> ' + state.state.val + ' (ack=' + state.state.ack + ', from=' + state.state.from + ')');}
        if (state.state.ack && state.state.val) {
            rooms[room].letztesEIN = new Date().getTime();
        }
    });

    on({id: rooms[room].stateIdSollTemperatur, change: 'ne'}, function(state) {
        if (debug) {console.log('Änderung Solltemperatur ' + room + ': --> ' + state.state.val + ' (ack=' + state.state.ack + ', from=' + state.state.from + ')');}
        ventilLogik(room);
    });
}

onStop(function (callback) {
    for (var room in rooms) {
        if (getState(rooms[room].stateIdHeizungAktor).val) {
            controlFBHAktor(room, false); // Alle ausschalten wenn Skript aus geht
            if (rooms[room].skriptTimeout) {
                clearTimeout(rooms[room].skriptTimeout);
                rooms[room].skriptTimeout = null;
            }
        }
    }
    setTimeout(callback, 1000);
}, 3000);

function ventilLogik(roomName) {
    if (rooms[roomName].skriptTimeout) {
        clearTimeout(rooms[roomName].skriptTimeout);
        rooms[roomName].skriptTimeout = null;
    }
    // Temperaturen feststellen
    var isttemperatur = getState(rooms[roomName].stateIdIstTemperatur).val;
    var solltemperatur = getState(rooms[roomName].stateIdSollTemperatur).val;
    var schaltzustand = getState(rooms[roomName].stateIdHeizungAktor).val;
    var aktivSeit = 0;
    if (schaltzustand && rooms[roomName].letztesEIN) aktivSeit = (new Date().getTime() - rooms[roomName].letztesEIN) / 1000 / 60;
    if (debug) {console.log('Start Ventillogik ' + roomName + ': IstTemp=' + isttemperatur + ', VergleichTemp=' + rooms[roomName].FBVergleichTemp + ', SollTemp=' + solltemperatur + ', Aktor=' + schaltzustand + ' (seit ' + aktivSeit + 'm)');}

    // GrenzTemperaturen berechnen
    var hochtemp = solltemperatur + rooms[roomName].hochtempAufschlag;
    var niedertemp = solltemperatur - rooms[roomName].niedertempAbschlag;
    var hochstill = solltemperatur + rooms[roomName].hochstillAufschlag;
    var niederstill = solltemperatur - rooms[roomName].niederstillAbschlag;
    var toleranz = hochtemp - niedertemp;

    // rooms[roomName].StartHeizzeit in Systemvariable schreiben
    rooms[roomName].FBStartTemperatur.push(isttemperatur);
    if (rooms[roomName].FBStartTemperatur.length > 3) rooms[roomName].FBStartTemperatur.shift();
    if (debug) {console.log("    Start FBStartTemp=" + rooms[roomName].FBStartTemperatur[0]);}

    // Differenz Starttemperatur und Endtemperatur ausrechnen
    var FBTempDiff = isttemperatur - rooms[roomName].FBStartTemperatur[0];
    if (FBTempDiff <= 0) {
        if (debug) {console.log("    TempDiff <= 0: " + FBTempDiff + " --> 0.01");}
        FBTempDiff = 0.01;
    }
    else {
        if (debug) {console.log("    TempfDiff > 0: " + FBTempDiff);}
    }

    // Endheizzeit in Systemvariable, Isttemperatur in Systemvariable schreiben, Differenz heizzeit u Temp errechnen
    var EndHeizzeit = new Date().getTime();

    // Heizzeit Differenz für Tempvorausrechnung errechnen
    var DiffStartEndHeizzeit = (EndHeizzeit - rooms[roomName].StartHeizzeit[0]) / 1000 / 60;

    // Heizzeit Differenz für automatische Errechnung Scriptintervall errechnen
    var Scriptintervall = rooms[roomName].skriptZyklus;

    // Steuerung Fussbodenheizung
    var heizleistung;
    var heizzeit;
    var heizzeit1;
    var einschaltzeitvergleichtemp;
    var tempdifferenzkalkreal;
    var reduzierungszeit;
    var neueheizzeit;
    // Einschaltzeit berechnen -----------------
    if (isttemperatur <= solltemperatur) {
        if (debug) {console.log("    Isttemperatur <= Solltemperatur");}
        heizleistung = ((solltemperatur + 0.2 - isttemperatur) / toleranz) * 100;
        heizzeit1 = (Scriptintervall * heizleistung) / 100;
        einschaltzeitvergleichtemp = (FBTempDiff * heizzeit1) / DiffStartEndHeizzeit;
        if (((toleranz * heizleistung) / 100) >= einschaltzeitvergleichtemp) {
            if (debug) {console.log("        heizzeit im original übernommen (heizleistung=" + heizleistung + ", Scriptintervall=" + Scriptintervall + ")");}
            heizzeit = heizzeit1 * 60;
        }
        else {
            if (debug) {console.log("        reduzierte heizzeit übernommen");}
            tempdifferenzkalkreal = einschaltzeitvergleichtemp - ((toleranz * heizleistung) / 100);
            reduzierungszeit = (tempdifferenzkalkreal * Scriptintervall) / FBTempDiff;
            neueheizzeit = heizzeit1 - reduzierungszeit;
            if (neueheizzeit <= 0) {
                heizzeit = rooms[roomName].Sicherheitsheizzeit;
                if (debug) {console.log("        sicherheitshalber 4 Minuten heizen");}
            }
            else {
                heizzeit = neueheizzeit * 60;
                if (debug) {console.log("        neueheizzeit übernommen");}
            }
        }
    }
    else {
        if (debug) {console.log("    Isttemperatur > solltemperatur");}
        heizleistung = ((hochtemp - isttemperatur) / toleranz) * 100;
        heizzeit1 = (Scriptintervall * heizleistung) / 100;
        einschaltzeitvergleichtemp = FBTempDiff * heizzeit1 / DiffStartEndHeizzeit;
        if (((toleranz * heizleistung) / 100) >= einschaltzeitvergleichtemp) {
            if (debug) {console.log("        heizzeit im original übernommen (heizleistung=" + heizleistung + ", Scriptintervall=" + Scriptintervall + ")");}
            heizzeit = heizzeit1 * 60;
        }
        else {
            if (debug) {console.log("        reduzierte heizzeit übernommen");}
            tempdifferenzkalkreal = einschaltzeitvergleichtemp - ((toleranz * heizleistung) / 100);
            reduzierungszeit = (tempdifferenzkalkreal * Scriptintervall) / FBTempDiff;
            neueheizzeit = heizzeit1 - reduzierungszeit;
            if (neueheizzeit <= 0) {
                heizzeit = rooms[roomName].Sicherheitsheizzeit;
                if (debug) {console.log("        sicherheitshalber 4 Minuten heizen??");}
            }
            else {
                heizzeit = neueheizzeit * 60;
                if (debug) {console.log("        neueheizzeit übernommen");}
            }
        }
    }

    // Künftige Temperatur bei doppelter Schaltzeit vorausrechnen
    var tempvorausrechnung = FBTempDiff * (Scriptintervall * 2) / DiffStartEndHeizzeit;
    var Neueisttemperatur = isttemperatur + tempvorausrechnung;

    if (debug) {console.log('    Errechnete Heizzeit=' + heizzeit + ' --> Neue-Ist-Temp=' + Neueisttemperatur + ' (+' + tempvorausrechnung + ')');}

    // Schaltungen ausführen
    if ((isttemperatur < hochtemp) && (isttemperatur > niedertemp)) {
        if ((rooms[roomName].FBVergleichTemp === isttemperatur) && (isttemperatur > solltemperatur)) {
            if (debug) {console.log("    Ist = Vergleichstemperatur");}
            if (schaltzustand) {
                if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                controlFBHAktor(roomName, false);
            }
            else {
                if (debug) {console.log("        ist ausgeschaltet und soll ausgeschaltet sein");}
            }
        }
        else {
            if (debug) {console.log("    innerhalb toleranz");}
            if ((isttemperatur <= hochstill) && (isttemperatur >= niederstill)) {
                if (debug) {console.log("    innerhalb stille");}
                if (schaltzustand) {
                    if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                    controlFBHAktor(roomName, false);
                }
                else {
                    if (debug) {console.log("        ist ausgeschaltet und soll ausgeschaltet sein");}
                }
            }
            else {
                if (debug) {console.log("    ausserhalb stille");}
                if (isttemperatur < niederstill) {
                    if (heizzeit < rooms[roomName].Schaltschwelleniedertemp) {
                        if (debug) {console.log("    Schaltzeit zu klein");}
                        if (schaltzustand) {
                            if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                            controlFBHAktor(roomName, false);
                        }
                        else {
                            if (debug) {console.log("        ist ausgeschaltet und soll ausgeschaltet sein");}
                        }
                    }
                    else {
                        if (debug) {console.log("    kleiner niederstill");}
                        controlFBHAktor(roomName, true, heizzeit);
                    }
                }
                else {
                    if (rooms[roomName].FBVergleichTemp < isttemperatur) {
                        if (debug) {console.log("    über hochstill gestiegen");}
                        if (schaltzustand) {
                            if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                            controlFBHAktor(roomName, false);
                        }
                        else {
                            if (debug) {console.log("        ist ausgeschaltet und soll ausgeschaltet sein");}
                        }
                    }
                    else {
                        if (heizzeit < rooms[roomName].Schaltschwellehochtemp) {
                            if (debug) {console.log("    Schaltzeit zu klein");}
                            if (schaltzustand) {
                                if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                                controlFBHAktor(roomName, false);
                            }
                            else {
                                if (debug) {console.log("        ist ausgeschaltet und soll ausgeschaltet sein");}
                            }
                        }
                        else {
                            if (debug) {console.log("    größer als hochstill");}
                            controlFBHAktor(roomName, true, heizzeit);
                        }
                    }
                }
            }
        }
    }
    else {
        if (isttemperatur >= hochtemp) {
            if (debug) {console.log("    Isttemperatur größer als hochtemp");}
            if (schaltzustand) {
                if (Neueisttemperatur <= solltemperatur) {
                    if (debug) {console.log("        Neue Isttemp kleiner gleich Solltemperatur");}
                    if (debug) {console.log("        ist eingeschaltet und soll eingeschaltet sein");}
                }
                else {
                    if (debug) {console.log("        Neue Isttemp grösser Solltemperatur");}
                    if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                    controlFBHAktor(roomName, false);
                }
            }
            else {
                if (Neueisttemperatur <= solltemperatur) {
                    if (debug) {console.log("        Neue Isttemp kleiner gleich Solltemperatur");}
                    if (debug) {console.log("        ist ausgeschaltet und soll eingeschaltet sein");}
                    controlFBHAktor(roomName, true, 36000);
                }
                else {
                    if (debug) {console.log("        Neue Isttemp grösser Solltemperatur");}
                    if (debug) {console.log("        ist ausgeschaltet und soll ausgeschaltet sein");}
                }
            }
        }
        else {
            if (isttemperatur == niedertemp) {
                if (schaltzustand) {
                    if (Neueisttemperatur >= niederstill) {
                        if (debug) {console.log("        Neue Isttemp größer gleich Niederstill");}
                        if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                        controlFBHAktor(roomName, false);
                    }
                    else {
                        if (debug) {console.log("        Neue Isttemp kleiner Niederstill");}
                        if (debug) {console.log("        ist eingeschaltet und soll eingeschaltet sein");}
                    }
                }
                else {
                    if (Neueisttemperatur >= niederstill) {
                        if (debug) {console.log("        Neue Isttemp größer gleich Niederstill");}
                        if (debug) {console.log("        ist ausgeschaltet und soll eingeschaltet sein");}
                    }
                    else {
                        if (debug) {console.log("        Neue Isttemp kleiner Niederstill");}
                        if (debug) {console.log("        ist ausgeschaltet und soll eingeschaltet sein");}
                        controlFBHAktor(roomName, true, 36000);
                    }
                }
            }
            else {
                if (debug) {console.log("    Isttemperatur ist kleiner als niedertemp");}
                if (schaltzustand) {
                    if (Neueisttemperatur >= niederstill) {
                        if (debug) {console.log("        Neue Isttemp größer gleich Niederstill");}
                        if (debug) {console.log("        ist eingeschaltet und soll ausgeschaltet sein");}
                        controlFBHAktor(roomName, false);
                    }
                    else {
                        if (debug) {console.log("        Neue Isttemp kleiner Niederstill");}
                        if (debug) {console.log("        ist eingeschaltet und soll eingeschaltet sein");}
                    }
                }
                else {
                    if (Neueisttemperatur >= niederstill) {
                        if (debug) {console.log("        Neue Isttemp größer gleich Niederstill");}
                        if (debug) {console.log("        ist ausgeschaltet und soll eingeschaltet sein");}
                    }
                    else {
                        if (debug) {console.log("        Neue Isttemp kleiner Niederstill");}
                        if (debug) {console.log("        ist ausgeschaltet und soll eingeschaltet sein");}
                        controlFBHAktor(roomName, true, 36000);
                    }
                }
            }
        }
    }
    rooms[roomName].FBVergleichTemp = isttemperatur;

    rooms[roomName].StartHeizzeit.push(new Date().getTime());
    if (rooms[roomName].StartHeizzeit.length > 3) rooms[roomName].StartHeizzeit.shift();

    rooms[roomName].skriptTimeout = setTimeout(function() {
        //if (debug) {console.log('Timeout ausgelöst ' + roomName);}
        rooms[roomName].skriptTimeout = null;
        ventilLogik(roomName);
    }, rooms[roomName].skriptZyklus*60*1000);
    if (debug) {console.log("Ende " + roomName + ', Nächster Lauf in ' + (rooms[roomName].skriptZyklus) + 'm');}
}

function controlFBHAktor(roomName, enabled, time) {
    var useSupport = false;
    if (rooms[roomName].stateIdHeizungUnterstuetzungAktor) {
        var isttemperatur = getState(rooms[roomName].stateIdIstTemperatur).val;
        var solltemperatur = getState(rooms[roomName].stateIdSollTemperatur).val;
        if (enabled && solltemperatur - isttemperatur > rooms[roomName].heizunterstuetzungKelvin) {
            if (debug) {console.log('    Steuern UnterstützungsAktor FBH ' + roomName + ' --> ' + enabled + ' (time=' + time + ')');}
            useSupport = true;
        }
        else if (!enabled || getState(rooms[roomName].stateIdHeizungUnterstuetzungAktor).val) useSupport = true;
    }

    if (enabled && time) {
        time = Math.round(time);
        setState(rooms[roomName].stateIdHeizungAktorOnTime, time, false, function() {
            if (debug) {console.log('    Steuern Aktor FBH ' + roomName + ' --> ' + enabled + ' (time=' + time + ')');}
            setState(rooms[roomName].stateIdHeizungAktor, true, false);
            if (useSupport) {
                setState(rooms[roomName].stateIdHeizungUnterstuetzungAktorOnTime, time, false, function() {
                    if (debug) {console.log('    Steuern UnterstützungsAktor FBH ' + roomName + ' --> ' + enabled + ' (time=' + time + ', tempDiff=' + (solltemperatur - isttemperatur) + ')');}
                    setState(rooms[roomName].stateIdHeizungUnterstuetzungAktor, true, false);
                });
            }
        });
    }
    else {
        if (debug) {console.log('    Steuern Aktor FBH ' + roomName + '--> ' + enabled);}
        setState(rooms[roomName].stateIdHeizungAktor, enabled, false);
        if (useSupport) {
            if (debug) {console.log('    Steuern UnterstützungsAktor FBH ' + roomName + '--> ' + enabled);}
            setState(rooms[roomName].stateIdHeizungUnterstuetzungAktor, enabled, false);
        }
    }
}

Viel Spass bei der Nutzung. Klappt bei mir recht gut und die Räume übersteuern fast nicht …

Eine weitere Funktionalität zur Voraussteuerung und Aufheizzeitmessung gibt es unter http://forum.iobroker.net/viewtopic.php ... 89#p107689

Ingo