Hi,

beim definieren von Heizplänen muss man normalerweise immer berücksichtigen wie lange der Raum braucht um auf die gewünschte Temperatur hoch zu heizen und muss das von der Zeit wann man es eigentlich warm haben will immer abziehen. Inzwischen ist es aber auch so, dass die Vorlauftemperatur von Heizungen (egal ob Fussbodenheizung oder normale Heizkörper) oft auch von der Aussentemperatur und/oder anderen Faktoren abhängt. Damit kann die nötige Zeit zum hochheizen durchaus variieren über die Zeit.

Bei Fussbodenheizungen kommt hinzu das diese teilweise sehr träge sind und damit solche Zeiten lang werden können.

Daher habe ich das mal als Skripte umgesetzt, die ich hier gern vorstellen möchte. Es sind zwei getrennte Skripte die zusammen die Funktionalität bereitstellen das die Aufheizzeit gemessen und gespeichert wird (in Minuten pro Kelvin) und basierend darauf und der Info zur nächsten Schaltzeit und Solltemperatur des Heizungsthermostatsskripts (aus http://forum.iobroker.net/viewtopic.php?f=21&t=10096) diese Temperatur frühzeitig schon manuell beim Thermostat setzt.

Skript Nummer 1: Aufheizmessung.js (20180103)

Diese Skript überwacht wann geheizt wird und merkt sich die Temperaturentwicklung. Daraus wird ein Mittelwert errechnet, der dann als Aufheizzeit gespeichert wird. Dadurch das dieses Skript immer läuft "lernt" es mit und die Zeiten entwickeln sich über die Zeit.

Im Raum-Objekt sind pro Raum die State-IDs des Aktors und die der Ist-Temperatur definiert die genutzt werden. Weiterhin in "heizungStatusIstAktor" die Info ob die "stateIdHeizungStatus" ein Aktor (Ein/Aus) ist (Wert true) oder ein Ventil (0%-100% VALVE_STATE) ist (Wert false).

Weitere Einstellungen sind im Skript dokumentiert.

Pro Raum werden unter "stateBaseId" zwei States angelegt. Einmal mit der aktuell errechneten Aufheizzeit und einmal mit den letzten 10 Messwerten (die für die Mittelwertbildung herangezogen werden).

Das Skript sollte man ein paar Tage laufen lassen bis es sinnvolle Erfahrungswerte pro Raum gibt.

`var rooms= {
    'OG-Bad': {
        stateIdHeizungStatus: "hm-rpc.0.NEQ1503796.1.STATE", // Status des Heizungsaktors zur Erkennung wann geheizt wird und wann nicht
        heizungStatusIstAktor: true, // Status-State ist Aktor (=true) oder Stellventil (=false)
        stateIdIstTemperatur: "hm-rpc.0.JEQ0122686.1.TEMPERATURE" // Ist-Temperatur
    },
    'EG-Wohnzimmer': {
        stateIdHeizungStatus: "hm-rpc.0.OEQ0653582.1.STATE", // Status des Heizungsaktors zur Erkennung wann geheizt wird und wann nicht
        heizungStatusIstAktor: true, // Status-State ist Aktor (=true) oder Stellventil (=false)
        stateIdIstTemperatur: "hm-rpc.0.JEQ0122620.1.TEMPERATURE" // Ist-Temperatur
    }
};
var stateBaseId = "javascript.0.Heizung.Aufheizzeit.";
var ventilOeffnungHeizen = 80; // Wenn State ein Ventil ist ab welchem Ventil-Öffnungsstand wird es als "Heizen" betrachtet. 80-90% empfohlen, alles darunter ist eher "warm halten"!
var erkennungAusVerzoegerung = 190; // Zeit in Sekunden wann der Aktor als "Aus" akzeptiert wird, kann auch pro Raum definier werden
var maxIncrease1K = 400; // Maximale 1K-Zeit die akzeptiert wird (alles darüber wird als ungültig verworfen)
var minIncrease1K = 30; // Minimale 1K-Zeit die akzeptiert wird (alles darunter wird als ungültig verworfen)
var debug = true; // Ausführliches Debug-Logging

initialize();

function initialize() {
    for (var room in rooms) {
        rooms[room].letztesEin = 0;
        rooms[room].letztesEinTemp = 0;
        rooms[room].letzteTemp = 0;
        rooms[room].skriptTimeout = null;
        rooms[room].aufheizzeiten = [];
        rooms[room].status = getState(rooms[room].stateIdHeizungStatus).val;
        if (!rooms[room].heizungStatusIstAktor) {
            if (rooms[room].status > rooms[room].ventilOeffnungHeizen) rooms[room].status = true;
              else rooms[room].status = false;
        }

        if (! rooms[room].erkennungAusVerzoegerung) rooms[room].erkennungAusVerzoegerung = erkennungAusVerzoegerung;
        if (! rooms[room].maxIncrease1K) rooms[room].maxIncrease1K = maxIncrease1K;
        if (! rooms[room].minIncrease1K) rooms[room].minIncrease1K = minIncrease1K;
        if (! rooms[room].ventilOeffnungHeizen) rooms[room].ventilOeffnungHeizen = ventilOeffnungHeizen;
        rooms[room].ausTimeout = null;

        if (rooms[room].status) {
            rooms[room].letztesEin = new Date().getTime();
            rooms[room].letztesEinTemp = getState(rooms[room].stateIdIstTemperatur).val;
            rooms[room].letzteTemp = rooms[room].letztesEinTemp;
            if (debug) {console.log('    ' + room + ': Aktor eingeschaltet, starte Aufheizmessung jetzt (' + rooms[room].letztesEinTemp + ')');}
        }

        initializeSubscribes(room);

        if (debug) {console.log('Raum ' + room + ' initialisiert, status=' + rooms[room].status);}
    }
}

function initializeSubscribes(room) {
    createState(stateBaseId + room, {'type': 'number', 'read': true, 'write': true, 'role': 'value', 'unit': 'm'}, function() {
        createState(stateBaseId + room + '-Data', {'type': 'string', 'read': true, 'write': true, 'role': 'value', 'unit': '', def: ''}, function() {
            var storedData = getState(stateBaseId + room + '-Data').val;
            var error = false;
            if (storedData) {
                try {
                    rooms[room].aufheizzeiten = JSON.parse(storedData);
                }
                catch (e) {
                    console.log('Error reading old Data: ' + e);
                    error = true;
                }
            }
            if (!storedData || error) {
                rooms[room].aufheizzeiten = [];
                var storedAvg = getState(stateBaseId + room).val;
                if (storedAvg) {
                    rooms[room].aufheizzeiten.push(storedAvg);
                }
                setState(stateBaseId + room + '-Data', JSON.stringify(rooms[room].aufheizzeiten), true);
                if (debug) {console.log('    Initialize Data ' + room + ': ' + JSON.stringify(rooms[room].aufheizzeiten));}
            }
        });
    });

    on({id: rooms[room].stateIdHeizungStatus, change: 'any'}, function(state) {
        console.log('Änderung Status Aktor FBH ' + room + ': ' + state.oldState.val + '--> ' + state.state.val + ' (ack=' + state.state.ack + ', from=' + state.state.from + ') status bisher=' + rooms[room].status);
        if (!state.state.ack) return;
        if (rooms[room].ausTimeout) {
            clearTimeout(rooms[room].ausTimeout);
            rooms[room].ausTimeout = null;
        }
        var verzoegerung = state.state.val ? 0 : (rooms[room].erkennungAusVerzoegerung * 1000);
        var val = state.state.val;
        if (!rooms[room].heizungStatusIstAktor) {
            if (state.state.val > rooms[room].ventilOeffnungHeizen) val = true;
              else val = false;
        }

        rooms[room].ausTimeout = setTimeout(function() {
            aktualisiereAktorStatus(room, val);
        }, verzoegerung);
    });
}

function aktualisiereAktorStatus(room, stateVal) {
    rooms[room].ausTimeout = null;
    if (rooms[room].status === stateVal) return;
    rooms[room].status = stateVal;
    if (stateVal && rooms[room].letztesEin === 0) {
        rooms[room].letztesEin = new Date().getTime();
        rooms[room].letztesEinTemp = getState(rooms[room].stateIdIstTemperatur).val;
        rooms[room].letzteTemp = rooms[room].letztesEinTemp;
        pruefeAufheizzeit(room, true);
    }
    else if (rooms[room].letztesEin !== 0) {
        pruefeAufheizzeit(room, false);
        rooms[room].letztesEin = 0;
        rooms[room].letzteTemp = 0;
    }
}

function pruefeAufheizzeit(room, restart) {
    if (rooms[room].skriptTimeout) {
        clearTimeout(rooms[room].skriptTimeout);
        rooms[room].skriptTimeout = null;
    }

    var timeDiff = new Date().getTime();
    if (! restart) timeDiff -= (rooms[room].erkennungAusVerzoegerung * 1000);
    timeDiff = Math.round((timeDiff - rooms[room].letztesEin) / 1000 / 60);
    console.log(room + " timeDiff=" + timeDiff);
    if (timeDiff > 30) {
        var invalid = false;
        var tempDiff = getState(rooms[room].stateIdIstTemperatur).val - rooms[room].letztesEinTemp;
        var increase1K = Math.round((1 / tempDiff) * timeDiff);
        var finalInfo = restart ? "" : "FINALE ";
        if (increase1K < rooms[room].minIncrease1K || increase1K > rooms[room].maxIncrease1K) {
            finalInfo = "INVALID ";
            invalid = true;
        }
        var tempDiffLetztes = getState(rooms[room].stateIdIstTemperatur).val - rooms[room].letzteTemp;
        if (tempDiffLetztes < 0) {
            finalInfo = "TEMP-KLEINER ";
            invalid = true;
        }
        var avg = -1;
        if (!invalid) {
            rooms[room].aufheizzeiten.push(increase1K);
            avg = 0;
            for (var i = 0; i < rooms[room].aufheizzeiten.length; i++) {
                avg += rooms[room].aufheizzeiten[i];
            }

            avg = Math.round(avg/rooms[room].aufheizzeiten.length);
            setState(stateBaseId + room, avg, true);
            if (rooms[room].aufheizzeiten.length > 10) {
                rooms[room].aufheizzeiten.shift();
            }
            setState(stateBaseId + room + '-Data', JSON.stringify(rooms[room].aufheizzeiten), true);
        }
        else if (tempDiffLetztes < 0) {
            rooms[room].letztesEin = new Date().getTime();
            rooms[room].letztesEinTemp = getState(rooms[room].stateIdIstTemperatur).val;
            rooms[room].letzteTemp = rooms[room].letztesEinTemp;
        }
        rooms[room].letzteTemp = getState(rooms[room].stateIdIstTemperatur).val;
        if (debug) {console.log(finalInfo + 'Aufheizzeit ' + room + ': timeDiff=' + timeDiff + ', tempDiff=' + tempDiff + ', 1K=' + increase1K + 'm / avg=' + avg + 'm');}
    }

    if (restart) {
        rooms[room].skriptTimeout = setTimeout(function() {
            rooms[room].skriptTimeout = null;
            pruefeAufheizzeit(room, true);
        }, 30*60*1000);
    }
}` 

**~~[b]~~Skript Nummer 2: Voraussteuerung.js (20180103)[/b]**

Dieses Skript nutzt die vom ersten Skript errechnete Aufheiztemperatur. Zusätzlich braucht es die Info wann die nächste Temperaturänderung gewünscht ist und auf welche Temperatur. Ich nutze die States "Source_Schedule" und "Source_NextTemp" vom Heizungsthermostatskript 2.0 von looxer01 aus [http://forum.iobroker.net/viewtopic.php?f=21&amp;t=10096](http://forum.iobroker.net/viewtopic.php?f=21&amp;t=10096).

Sobald Zeit oder nächste Zieltemperatur geändert werden prüft das Skript auf Basis der Ist-Temperatur wie lange man vorab die Heizung einschalten muss, damit zur gewünschten Zeit die Temperatur idealerweise erreicht ist. Zur Steuerung wird einfach die nächste Solltemperatur zur errechneten früheren Zeit schon gesetzt. Ich setze es direkt bei den Thermostaten. Das hat dann den Vorteil das das Heizungsthermostatskript 2.0 dies als manuelle Änderung sieht und auch bei sich vermerkt. Somit ist der View und alles immer "in sync". Falls jemand ein Fenster aufmacht wird es wieder überschrieben.

Im Raum-Objekt sind pro Raum die State-ID der nötigen States enthalten. Siehe im Skript dokumentiert.

In "minimaleTemperaturdifferenz" kann man angeben ab welcher minimalen Temperaturdifferenz überhaupt eine Voraussteuerung passieren soll.

`~~[code]~~var rooms= {
    'OG-Bad': {
        stateIdSchedule: "javascript.0.Heizung.Heizplan.OG-Bad.Source_Schedule", // Nächter Schaltzeitpunkt
        stateIdNextTemperatur: "javascript.0.Heizung.Heizplan.OG-Bad.Source_NextTemp", // Nächste Wunschtemperatur
        stateIdAufheizzeit: "javascript.0.Heizung.Aufheizzeit.OG-Bad", // Aufheizzeit für diesen Raum (min pro K)
        stateIdSollTemperatur: "hm-rpc.0.NEQ0124378.2.SET_TEMPERATURE", // State zum Setzen der Solltemperatur
        stateIdIstTemperatur: "hm-rpc.0.JEQ0122686.1.TEMPERATURE" // Ist-Temperatur
    },
    'EG-Wohnzimmer': {
        stateIdSchedule: "javascript.0.Heizung.Heizplan.EG-Wohnzimmer.Source_Schedule", // Nächter Schaltzeitpunkt
        stateIdNextTemperatur: "javascript.0.Heizung.Heizplan.EG-Wohnzimmer.Source_NextTemp", // Nächste Wunschtemperatur
        stateIdAufheizzeit: "javascript.0.Heizung.Aufheizzeit.EG-Wohnzimmer", // Aufheizzeit für diesen Raum (min pro K)
        stateIdSollTemperatur: "hm-rpc.0.OEQ0987006.2.SET_TEMPERATURE", // State zum Setzen der Solltemperatur
        stateIdIstTemperatur: "hm-rpc.0.JEQ0122620.1.TEMPERATURE" // Ist-Temperatur
    }
};
var minimaleTemperaturdifferenz = 0.5; // wenn Temperaturdifferenz Ist zu Soll weniger als diese Angabe ist dann erfolgt keine Voraussteuerung
var maxIncrease1K = 150; // Falls der Wert für die Aufheizzeit größer als dieser Wert ist wird es auf diesen zurückgesetzt
var debug = true; // Ausführliches Debug-Logging

initialize();

function initialize() {
    for (var room in rooms) {
        rooms[room].vorausTimeout = null;
        if (! rooms[room].maxIncrease1K) rooms[room].maxIncrease1K = maxIncrease1K;

        handleRoom(room);

        initializeSubscribes(room);
    }
}

function initializeSubscribes(room) {
    on({id: rooms[room].stateIdIstTemperatur, change: 'ne'}, function() {
        handleRoom(room);
    });
}

function handleRoom(room) {
    if (rooms[room].vorausTimeout) {
        clearTimeout(rooms[room].vorausTimeout);
        rooms[room].vorausTimeout = null;
    }

    var isttemperatur = getState(rooms[room].stateIdIstTemperatur).val;
    var nexttemperatur = getState(rooms[room].stateIdNextTemperatur).val;
    var solltemperatur = getState(rooms[room].stateIdSollTemperatur).val;
    if (nexttemperatur > isttemperatur && nexttemperatur !== solltemperatur) {
        var tempdiff = nexttemperatur - isttemperatur;

        if (tempdiff > minimaleTemperaturdifferenz) {
            var aufheizzeit = getState(rooms[room].stateIdAufheizzeit).val;
            if (rooms[room].maxIncrease1K < aufheizzeit) {
                if (debug) {console.log('Aufheizzeit von ' + aufheizzeit + ' runtergesetzt auf ' + rooms[room].maxIncrease1K);}
                aufheizzeit = rooms[room].maxIncrease1K;
            }
            if (aufheizzeit === null || aufheizzeit < 20) return;
            var vorlaufzeit = Math.round(aufheizzeit * tempdiff * 60 * 1000);
            if (debug) {console.log('ermittelte Vorlaufzeit ' + room + ': ' + isttemperatur + ' -> ' + nexttemperatur + ': ' + (vorlaufzeit/1000/60) + 'm (' + aufheizzeit + 'm/K)');}

            var schedArr = getState(rooms[room].stateIdSchedule).val.split("_"); // [0]=Mo, [1]=00:00:00
            var timepoint = strToDate(schedArr[1]);
            if (schedArr[1] === "00:00:00") {
                timepoint += 24 * 60 * 60 * 1000;
            }
            var timeout = timepoint - new Date().getTime() - vorlaufzeit;

            if (timeout < 0) {
                timeout = 0;
            }
            rooms[room].vorausTimeout = setTimeout(function() {
                rooms[room].vorausTimeout = null;
                setState(rooms[room].stateIdSollTemperatur, nexttemperatur, false);
                console.log('Voraussteuerung Thermostat ' + room + ' aktiviert auf ' + nexttemperatur);
            }, timeout);
        }
        else {
            if (debug) {console.log('Voraussteuerung ignoriert  ' + room + ' . Temperaturdifferenz zu klein (' + tempdiff + ' <= 0.5)');}
        }
    }
}

function strToDate(strTime) {
    var time = strTime.split(':');
    var d = new Date();
    d.setHours(parseInt(time[0], 10));
    d.setMinutes(parseInt(time[1], 10));
    d.setSeconds(parseInt(time[2], 10));
    d.setMilliseconds(0);
    return d;
} // Ende Funktion
[/code]`

Viel Spass damit. bei Fragen hier Fragen.

Eine Ventilsteuerung für FBH u.ä. gibt es unter [http://forum.iobroker.net/viewtopic.php?f=21&amp;t=10111](http://forum.iobroker.net/viewtopic.php?f=21&amp;t=10111)[/i]

Versionshistorie:

20171228:

• initiale Version

20180103:

• Unterstützung für Ventile zur Aufheizmessung hinzugefügt

• Optimierungen und einige weitere Parameter konfigurierbar gemacht in beiden Skripten

Hier in Karlsruhe nicht anders, aber am Ende habe ich keinen sinnvollen zusammenhang der ganzen Werte. Ich habe mit einigen Dingen experimentiert, allerdings waren die Ergebnisse alle fragwürdig weil es einfach zu viele Faktoren gibt. Und die sind auch noch bei jedem anders. Das generischste und am Ende sinnvollste war das einfache messen der Temperaturänderungen und das ganze über die letzten 10 Messungen zu „glätten“. Die Näherung der Methode hat bei mir die letzte Zeit gut funktioniert.

Am besten schalte mal Debug auf true (bzw so war es im Standard) und dann schau im logfile mit dem Scriptnamen. Dann siehst du was er tut. Es gibt ein paar Fälle wo er Werte ignoriert wie wenn Temperaturen fallen oder die errechnete Zeit zu hoch ist. Vllt ist ja so etwas passiert?!

Dann hast du noch mehr Logs. Versuchs. Gar nichts im log sollte aber eher nicht sein. Aber er loggt nur wenn der Aktor aktiv ist.

@Dirk: er fängt erst an zu rechnen wenn der aktor mind. 31 Minuten an war. Alles kürzere ist nicht aussagekräftig. Von daher misst er am ehesten wenn man nach der Nacht den Raum „hoch heizt“ und er misst eher nicht wenn man die temperatur hält und dazu kurz misst. Der Eintrag mit „timediff=2“ sagt das dr aktor nur 2 Minuten an war.

@eric2905: eine super frage das Skript ist aktuell am ehesten für „Aktoren“ ausgelegt die ein und ausgeschaltet werden. Ein normales heizungsventil was zu 20% offen ist hat ja nie die volle Heizleistung. Man könnte versuchen mit einem Mini Skript einen js Datenpunkt mit true/false anzulegen der auf Änderungen der Ventilsteuerung reagiert und das als State im Skript nutzen. Ich würde aber dann das nur auf true setzen wenn ventilstellung 90% (oder 80% maximalst) ist. Du willst ja ermitteln wie lange er auf „Maximum“ heizen müsste um eine solltenperatur zu erreichen. Wäre mal ein interessantes Experiment ob da was sinnvolles rauskommt. Dann kann ich gern Support dafür später einbauen offiziell

Ja aber die Frage durchaus du dann misst… eine Idee wäre eher sich abzusehen wenn es aus geht und direkt danach wieder an dann das „aus“ zu ignorieren.

Am mal grundsätzlich: soooo gut für die Stellmotoren ist das aber auch nicht oder?!

@dirk: je länger ich nachdenke desto mehr Sinn macht es die fahrzeitbasiert Ventile zu berücksichtigen. Ich baue später mal was ein was ein „aus“ erst dann als aus nimmt wenn mindestens x sekunden aus alsbzustand war. Meine fbh Ventile brauchen 3 min zum auf oder zu fahren. Wenn also vor in 3 min wieder ein „auf“ kommt waren sie effektiv nicht wirklich zu, also kann er weiter messen.

Wie weit liegen bei deinem hm ip System die zu/auf auseinander wenn er wirklich gerade heizen muss?

@eric2905: super, bin gespannt ob das gemessene mir deinen Erfahrungswerten übereinstimmt