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

Versions-Historie:

20171228:

• initiale Version

20180101:

• Fix weil teilweise Timouts doppelt entstehen konnten. Sollte jetzt nicht mehr vorkommen.

Dann schau Dir das vllt noch an: Eine weitere Funktionalität zur Voraussteuerung und Aufheizzeitmessung gibt es unter http://forum.iobroker.net/viewtopic.php … 89#p107689

Naja, so schwierig ist das nicht. Meistens ist es so das die FBH-Wandthermostate (z.B. von Jung oder so) auch gleichzeitig den "Schaltaktor = Relais" drin haben. Damit: Die FBH-Wandthermostate ausbauen einen HM-Schaltaktor in die UP-Dose und oben drüber ein HM-Thermostat. Lässt sich Problemlos später zurückbauen. Also mal schauen. Wenn da 230V ankommen und durchgeschaltet werden dann go. Aber selbst wenn es keine 230V sind (was eher ungewöhnlich wäre) sondern ggf was potentialfreies ist das auch mit HM Mitteln machbar denke ich.

Das einzige was dabei blöd ist (weil bei mir passiert), dass du einen weiteren Raum-Temperatursensor brauchst, weil der HM-Aktor direkt "unter" dem HM-Thermostat wenn er aktiv ist durchaus wärme abstrahlt und damit die gemessene Temperatur am Thermostat verfälscht …

Skript in Beitrag #1 aktualisiert, siehe auch Changelog im zweiten Beitrag:

Fix weil teilweise Timouts doppelt entstehen konnten. Sollte jetzt nicht mehr vorkommen.

Welche Datenpunkte hat denn so ein 12/7er Channel bei eurer. Schick mal Screenshot

Aber haben angeblich „timerfunktion“ ?! Ich baue heute Abend mal was ein

Das sollte Problemlos gehen. Dazu ggf auch mal in dem Homematic-Forum Thread lesen.

Das Skript schaut sich aktuell alle 20 Minuten die Temperaturentwicklung an und entscheidet dann was zu tun ist. Wenn also der kaminofen in der zeit gut geheizt hat dann wird das Skript im Zweifel sagen "uuii das ging ja fix, ich rehne mal hoch wie die Temperatur bei der Entwicklung in 20 Minuten ist … oohh zu warm dann höre ich mal auf zu heizen" oder so

Das ist diese Idee von dem Skript das es 20-60 Minuten der Vergangenheit nutzt um hochzurechnen was wie passiert in der Zukunft und daraus abzuleiten was jetzt getan werden muss.

Versuch es mal.

@0018:

ich werde es mal testen und berichten

EDIT: Aktuell habe ich ja die Ventile mit meinen HM Wandthermostaten direkt über die CCU2 verknüpft um die Ventile zu steuern. Muss ich diese Verknüpfung jetzt löschen oder kann dieses als "Notlauf" aktiv bleiben? `

Musst Du testen. Meine Erkenntnisse waren das die Wandthermostate sicherstellen das es so ist wie Sie es wollen. Also wenn Sie denken es soll aus sein und Du schaltest gesondert (direkt oder per Skript) ein dann haben die kurz drauf ausgeschaltet … Also bei mir hat es parallel nicht geklappt. kannST du ja aber mal manuell testen

@RobS:

Moin Apollon,

hast du rausfinden können, ob mit ner Timerfunktion der Wired-Aktoren was machbar ist oder sonst vielleicht eine Idee, wie ich das ohne „.on_time“ regeln könnte?

Habe die FBH-Steierung jetzt fast ne Woche im Betrieb und muss sagen, dass es trotz des fehlenden Datenpunktes ziemlich gut funktioniert. `

Sobald ich mal Zeit und Ruhe finde will ich das umbauen das es auch ohne on_time geht. Bissl geduld bitte

Am Ende heizt er jetzt ggf zuviel weil er immer nur 20 Minuten-Zeitscheiben heizen kann. Also ggf wirst du es ein bissl "zu warm" haben