Fußbodenheizung - Steuerung/Infrarotheizung-Steuerung

[twoxx]

Durch die Unterstützung des Forums hab ich jetzt nach 6 Wochen "Ausprobierens und Rumprogrammierens"
meine Lösung zur Fussbodenheizungssteuerung gebastelt.

Zusätzlich muß ich nun aus eigener Erfahrung sagen, dass auch die Steuerung von IR-Heizungspaneelen gut mit dieser Lösung funktioniert (sofern die Paneele die PWM vertragen).
Diese Beschreibung kann auch dafür verwendet werden - einfach beim Lesen das Wort "Stellantrieb" durch "IR-Paneele" ersetzen.

Vielleicht hilfts ja dem Einen oder Anderen, der
auch dieses Vorhaben umsetzen möchte:

Da ich in meiner Wohnung nur Kurzzeitmieter unterbringe und deshalb stets neue
Personenen mit unterschiedlichstem "Heizverhalten", "Temperaturempfinden" etc. darin verweilen,
ist es für mich wichtig, dass die Fussbodenheizung so energieeffizient, nach einem Zeitplan, aber auch
so flexibel wie möglich "reagiert".

Man kann sich natürlich darüber streiten, was "energieeffizient" und "flexibel" eigentlich heisst, aber für mich bedeutet
dies in erster Linie:

- DIE TRÄGHEIT DER FUSSBODENHEIZUNG ZU KOMPENSIEREN
- so gut wie möglich die Vermeidung des "Überheizens und Unterheizens" in der Heizkurve bei der Zweipunktregelung per Thermostat
da Fussbodenheizung sehr träge reagiert, das
soll heissen:

* wenn Ist-Temperatur weit unter Solltemperatur ist, dann soll dauerhaft geheizt werden
* wenn zu kühle Ist-Temperatur langsam bis zur Solltemperatur ansteigt, soll das Heizen frühzeitig abgeschaltet werden, damit
nicht aufgrund Trägheit der Fussbodenheizung über die Solltemperatur weit hinausgeheizt wird
* wenn Ist-Temperatur weit über Solltemperatur ist, dann soll dauerhaft nicht-geheizt werden
* wenn zu warme Ist-Temperatur langsam in Richtung Solltemperatur absinkt, soll frühzeitig mit dem Heizen begonnen werden, damit
die Solltemperatur aufgrund Trägheit der Fussbodenheizung nicht zu weit unterschritten wird.
* die obigen Vorgaben sollen innerhalb von festlegbaren Hysterese-Werten gesteuert werden können
* die Heizung soll auch die aktuelle Aufheizung durch anwesende Personen oder Sonneneinstrahlung bei der
künftigen Entwicklung der Raumtemperatur berücksichtigen und das Heizverhalten entsprechend anpassen.

- Das Wasser in den Fußbodenschleifen soll nicht zu stark auskühlen, sofern die Stellantriebe schon längere Zeit nicht mehr eingeschaltet waren.
- an Werktagen soll auch innerhalb des Nachmittags eine Absenkung der bzw. ein Aussetzen der Heizung erfolgen, da
niemand in der Wohnung ist - gleichzeitg soll die Wohnung aber abends wieder kuschelig sein, wenn die Leute von der Arbeit kommen
- an Wochenenden soll das Heizverhalten natürlich anders gestaltet sein, als an Werktagen, da hier die Leute meistens
die Wohnung nicht verlassen
- grundsätzlich soll deshalb das Heizen an einem Zeitplan hängen, dennoch sollen die Leute selbst auch die Solltemperatur in ihren
Räumen noch innerhalb festgelegter Parameter anpassen können (sofern dies erforderlich ist, weil beispielsweise
erfahrungsgemäß Leute aus den südlichen Regionen gerne ihr südliches Klima mit in ihre Räume mitnehmen wollen.
- wenn es aus irgendwelchen Gründen erforderlich ist, dann soll ein Zimmer auch ausserhalb des "Wochenplans"
auf "manuelle Solltemperatur" beheizt werden können.
- ich möchte auf die Einzelraumregelung Einfluß nehmen können, ohne das ich die Wohnung betreten muß.

Zur genauen Funktionsweise des "Zeitplans" der Wandthermostate, siehe folgender Post in diesem Thread:
viewtopic.php?f=31&t=24890&start=20#p330622

Hier sieht man wie die Ist-Temperatur nach der Nachtabsenkung mit meinem System entlang der Soll-Temperatur geführt wird:

Ich habe mich deshalb für das Homematic-System entschieden. Nach meinen Informationen gibt es jetzt für Homematic IP eine Fussbodenheizungssteuerung
- ich wollte jedoch nicht warten und hab das mittels des bereits bisher vorhandenen Angebots von Homematic umgesetzt. Ich habe mich dabei an dem von Contronics
angebotenen Gesamtsystem orientiert, allerdings auf Homeputer-Software oder CUXD oder ähnliches verzichtet, da ich gewährleisten möchte das das Ganze so stabil wie
möglich läuft und deshalb direkt alles als CCU2-Script realisiert. So wird nur mit der Original-Firmware und -Software der CCU2 gearbeitet.
Mögliche Unterschiede zu einer CUXD-Lösung habe ich hier in einem Post formuliert : http://homematic-forum.de/forum/viewtop ... 40#p338050

Mittlerweiel kann ich hinzufügen, dass meine Lösung auch mit Homematic-IP-Komponenten umgesetzt werden kann (Beispielsweise mit HMIP-Wandthermostaten,
die an der CCU2 angelernt sind). Jedoch nicht mit dem HMIP-Fussbodenheizungs-Aktor.

[twoxx]

Ich verwende an Hardware:
- CCU2
- Thermometer für Aussentemperatur : HM-WDS30-T-O
- zur Steuerung der Fussbodenheizung-Stellantriebe (230V - stromlos geschlossen, thermoelektrisch): 4-fach Schaltaktor HM-LC-Sw4-SM ( ursprünglich als ich noch 4 Stellantriebe betrieben habe)
mittlerweile verwende ich zusätzlich den 8-fach-Schaltakor HM-MOD-RE-8 gekoppelt an 8-fach 230V- Schaltrelais-Board (kann gegoogelt werden) (da ich nun insgesamt 9 Stellantriebe betreibe)
- in sämtlichen Räumen mit Fussbodenheizung oder mit Heizkörper: Wandthermostate HM-TC-IT-WM-W-EU (Es kann aber auch die HMIP-Version verwendet werden).
- in sämtlichen Räumen für Fenster und Türen: Optische Tür-/Fensterkontakte HM-Sec-SCo

Als Software verwende ich die Firmware der CCU2 und die darin möglichen "Programme" und "Scripte".

Zusätzlich muß ich nun sagen, das auch die Steuerung von IR-Heizungs-Panelen mit meiner Lösung gut funktioniert.

Achtung!!! Ich muß hier natürlich erwähnen, dass sämtliche Installationen der Hardware durch einen Fachmann durchgeführt werden müssen.


4-fach-Aktor:

4-fach.jpg (15.66 KiB) 19574 mal betrachtet

8-fach-Aktor:

[twoxx]

Da ich wie bereits erwähnt, mit der Heizkurve und dem Über- und Unterheizen bei Zweipunktregelung nicht zufrieden
bin, nutze ich als "Feinsteuerung" Programme und Scripte in der CCU2,die pro Stellantrieb alle 20 Minuten ausgeführt werden (Wert ist individuell anpassbar).

Sobald die Differenz zwischen Ist-Temperatur und Soll-Temperatur innerhalb eines gewissen Rahmens liegt
(der hier "Toleranz" genannt wird und der sich von einer "Hysterese" unterscheidet, diese wird zusätzlich noch berücksichtigt), soll vom "Dauerheizen" oder
auch "Dauer-NICHT-Heizen" in eine simulierte "Pulsweiten Modulation" gewechselt werden, womit die Trägheit der Fussbodenheizung ausgeglichen wird.
Hierzu ist wichtig, zu wissen, wie lange es dauert bis der Stellantrieb komplett geöffnet hat und wie lange es dauert, bis er wieder komplett geschlossen ist.
(habe ich mit Stoppuhr ermittelt). Dies ist wichtig, da das Script beim Wechsel von "Dauer-Heizen/Dauer-Nichtheizen" auf bestimmte berechnete "Heizzeiten"
wechselt. Sofern diese Heizzeiten kürzer sind als die Reaktionszeiten der Stellantriebe entfällt zur Stromersparnis das Schalten der Stellantriebe und das Heizen.

Beispiel: Errechnete Heizzeit wäre 2 Minuten - das Öffnen und Schliessen des Stellantriebes würde aber 5 Minuten benötigen. Diesen Heizimpuls kann man sich sparen.

Der Rahmen innerhalb dessen die Stellantriebe nur für bestimmte errechnete Heizzeiten geschaltet werden, liegt im Script zwischen "Niedertemp" und "Hochtemp" und
wird an der Solltemperatur orientiert mittels Zu- und Abschlägen definiert (bei mir Solltemperatur + 0,5 Grad "hochtempEGBuro" und - 0,8 Grad "toleranzniederEGBuro" ). Diesen Wertebereich rund um die
Solltemperatur nenne ich "Toleranz" "toleranzEGBuro".

Der Wertebereich der einer "Hysterese" gleichkommt wird im Script dann zwischen "Niederstill" und "Hochstill" definiert (bei mir Solltemperatur + 0,1 Grad und - 0,2 Grad),
innerhalb dieses bereichs macht das Script gar nichts, die Stellantriebe sind abgeschaltet.

Die Heizzeit für den Heizimpuls errechnet sich wiefolgt (beispielsweise Solltemperatur 19 Grad):

Niedertemp (18,2 Grad) bedeutet 100% Heizleistung für die nächsten 20 Minuten - Stellantrieb komplett offen für die nächsten 20 Minuten
Hochtemp (19,5 Grad) bedeutet 0 % Heizleistung für die nächsten 20 Minuten - Stellantrieb komplett geschlossen für die nächsten 20 Minuten
Wenn die Isttemperatur gleich der Solltemperatur wäre, dann würd das 10 Minuten heizen bedeuten (Stellantrieb offen) und dann 10 Minuten nicht-heizen bedeuten (Stellantrieb geschlossen),
(aber hier regelt das Script dann sowieso an anderer Stelle, dass kein heizen mehr erfolgt, das sich die IST-Temperatur ja hier innerhalb der "Hysterese" befindet)

Wenn also aufgrund Dauerheizen die Raumtemperatur nur noch 0,5 Grad unterhalb der Solltemperatur liegt (beispielsweise Soll: 19 Grad - Isttemperatur: 18,5 Grad), dann
wird der Heizimpuls wiefolgt auf nächsten 20 Minuten aufgeteilt:

Hochtemp (19,5 Grad) - Isttemperatur (18,5 Grad) = 1 Grad.
Die Toleranz und damit volle Heizleistung wären 1,3 Grad (Hochtemp - Niedertemp) für 20 Minuten.

1 Grad entspricht deshalb einer Heizleistung von 15 Minuten heizen und 5 Minuten - Nicht-heizen.

Nach diesem Heizimpuls wird dann das Script wieder ausgeführt und die Isttemperatur neu festgestellt, sofern sie sich verändert hat, wird dann vielleicht nur noch 12 Minuten geheizt und 8 Minuten - nicht-geheizt.
Das passiert solange bis die Solltemperatur bzw. die Hysterese zwischen Niederstill und Hochstill erreicht ist.

Natürlich ist das nur eine "theoretische" Heizleistung, die tatsächliche Heizleistung könnte man nur mittels "aktueller Vorlauftemperatur", "aktueller Aussentemperatur", "akuteller Sonneneinstrahlung" und
aktueller Anzahl von Personen im Raum ermitteln. All dies erspare ich mir, indem das Script einfach die tatsächliche Temperaturentwicklung der letzten 20, 40 oder 60 Minuten "mitspeichert" und daraus noch eine
"Vergleichstemperatur" für die nächsten 20 Minuten errechnet. Das Script stellt somit auch fest, wie sich die Raumtemperatur wohl aufgrund der aktuellen Gegebenheiten (Personen, Sonne etc.)
entwickeln wird und ändert die Heizzeit auch entsprechend ab.

Dadurch dass innerhalb dieses Temperaturrahmens der "Toleranz" die Fussbodenheizung nicht mehr "ständig heizt", sondern
nur noch anteilig aktiv ist, wird einem zu starken "Überheizen" über die Solltemperatur hinaus entgegengewirkt.

Für die Fälle in denen die Isttemperatur höher ist als die Solltemperatur, würde dann die Heizleistung im umgekehrten Bereich liegen, beispielsweise bei 4 Minuten Heizen und 16 Minuten - Nicht-heizen.
Die Heizzeit würde immer mehr ansteigen, sofern die Isttemperatur immer mehr in Richtung Solltemperatur fällt womit dann einem zu starken "Unterheizen" unter die Solltemperatur entgegengewirkt wird, weil
die Fussbodenheizung ja schon vorher "langsam aktiviert wird". Damit bei einem Ansteigen der Temperatur über die Solltemperatur hinaus nicht weiter in Richtung "hochtemp" geheizt wird, sondern wirklich nur
wenn die Termperatur in Richtung Solltemperatur abfällt, wurde im Script auch eine entsprechende Logik eingebaut.

[twoxx]

JEWEILS PRO STELLANTRIEB:

0. Dieses Programm unterscheidet, ob die Aussentemperatur größer oder kleiner als 4 Grad beträgt

1. Dieses Programm schreibt die letzte Heizzeit in eine Variable:

Das Script:

Code: Alles auswählen

!-------------- Letzte Einschaltzeit in Systemvariable schreiben

dom.GetObject("EGBuroletztesEIN").State((((system.Date("%H").ToInteger()) * 60) + (system.Date("%M").ToInteger())
));

2. Dieses Programm schaltet den Stellantrieb für 240 Sekunden ein, um die Wassertemperatur in der Fussbodenschleife abhängig von Aussentemperatur und
Zeitraum seitdem der Stellantrieb das letzte mal in der Vergangenheit eingeschaltet war, nach Möglichkeit nicht zu stark abfallen zu lassen:

Die genaue Funktionsweise des Programms und auch der ähnlichen Funktion, die zudem im Script 4 implementiert ist,
habe ich in diesem Post beschrieben: http://homematic-forum.de/forum/viewtop ... 40#p337083


3.Dieses Programm wird alle 20 Minuten ausgeführt.
Man könnte es auch einfacher gestalten, aber wie gesagt, ich habe viel "herumprobiert" und es ist "aus der Historie gewachsen".
Aufgrund der ständigen Überarbeitung der Scripte sind jetzt nur noch Script 1, 4 und 5 erforderlich.

Script 1:

Code: Alles auswählen

        ! Endheizzeit in Systemvariable, Isttemperatur in Systemvariable schreiben, Differenz heizzeit u Temp errechnen

    !---- Raumregler festlegen
    string RaumreglerEGBuro = "BidCos-RF.XXXXXXXXXXX";

    !-------------- Endheizzeit in Systemvariable schreiben

    dom.GetObject("EGBuroEndHeizzeit").State((((system.Date("%H").ToInteger()) * 60) + (system.Date("%M").ToInteger())));


    !----- Isttemperatur in Systemvariable schreiben und Differenz Heizzeit errechnen


    !---------- Heizzeit Differenz für Tempvorausrechnung errechnen


    if ((dom.GetObject("EGBuroEndHeizzeit").Value()) < (dom.GetObject("EGBuroStartHeizzeit").Value()))
    {
    dom.GetObject("EGBuroDiffStartEndHeizzeit").State(((1440 - (dom.GetObject("EGBuroStartHeizzeit").Value())) + (dom.GetObject("EGBuroEndHeizzeit").Value())));
    }
    else
    {
    dom.GetObject("EGBuroDiffStartEndHeizzeit").State(((dom.GetObject("EGBuroEndHeizzeit").Value()) - dom.GetObject("EGBuroStartHeizzeit").Value()));
    }

!---------- Heizzeit Differenz für automatische Errechnung Scriptintervall errechnen


    if ((dom.GetObject("EGBuroEndHeizzeit").Value()) < (dom.GetObject("EGBuroStartHeizzeit1").Value()))
    {
    dom.GetObject("ScriptintervallEGBuro").State(((1440 - (dom.GetObject("EGBuroStartHeizzeit1").Value())) + (dom.GetObject("EGBuroEndHeizzeit").Value())));
    }
    else
    {
    dom.GetObject("ScriptintervallEGBuro").State(((dom.GetObject("EGBuroEndHeizzeit").Value()) - dom.GetObject("EGBuroStartHeizzeit1").Value()));
    }

    !---------- Ist-Temperatur Wandthermostat in Systemvariable schreiben

    dom.GetObject("EGBuroFBEndTemperatur").State((0.0000 + dom.GetObject(RaumreglerEGBuro#":2.ACTUAL_TEMPERATURE").Value()));

    !----------- Differenz Starttemperatur und Endtemperatur ausrechnen

    dom.GetObject("EGBuroFBTempDiff").State((dom.GetObject("EGBuroFBEndTemperatur").Value()) - (dom.GetObject("EGBuroFBStartTemperatur").Value()));

Script 2:

Code: Alles auswählen

!---------- Wird nicht mehr benötigt

Script 3:

Code: Alles auswählen

!-----------Wird nicht mehr benötigt

Script 4:

Code: Alles auswählen

!--------Steuerung Fussbodenheizung
!----- RaumreglerEGBuro und Aktor identifizieren
string RaumreglerEGBuro = "BidCos-RF.XXXXXXXXXXX";
string AktorEGBuro = "BidCos-RF.XXXXXXXXXXXX";
string AktorkanalEGBuro ="XXX";
!----Ausführintervall Script und diverses festlegen
dom.GetObject("SicherheitsheizzeitEGBuro").State(240.000); !---- Heizzeit, falls errechnete Heizzeit im Minus
dom.GetObject("SchaltschwelleniedertempEGBuro").State(190.000); !--- Sofern errechnete Schaltzeit kleiner, dann nicht einschalten
dom.GetObject("SchaltschwellehochtempEGBuro").State(190.000); !---- Sofern errechnete Schaltzeit kleiner, dann nicht einschalten
dom.GetObject("ScriptwiederholungEGBuromax").State(5.0); !-----------Wiederholung des Scripts bis Wärmeerhaltung
dom.GetObject("ScriptwiederholungEGBuroHeizzeit").State(241.0); !---- Heizzeit bei Wärmeerhaltung
!----- Temperaturen feststellen
dom.GetObject("isttemperaturEGBuro").State((0.0000 + dom.GetObject(RaumreglerEGBuro#":2.ACTUAL_TEMPERATURE").Value()));
dom.GetObject("solltemperaturEGBuro").State((0.0000 + dom.GetObject(RaumreglerEGBuro#":2.SET_TEMPERATURE").Value()));
var schaltzustandEGBuro = dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").Value();
!------ GrenzTemperaturen berechnen
dom.GetObject("hochtempEGBuro").State((0.000 + dom.GetObject("solltemperaturEGBuro").Value() + 0.5));
dom.GetObject("toleranzniederEGBuro").State(1.0);
dom.GetObject("niedertempEGBuro").State((0.000 + dom.GetObject("solltemperaturEGBuro").Value() - dom.GetObject("toleranzniederEGBuro").Value()));
dom.GetObject("hochstillEGBuro").State((0.000 + dom.GetObject("solltemperaturEGBuro").Value() + 0.1));
dom.GetObject("niederstillEGBuro").State((0.000 + dom.GetObject("solltemperaturEGBuro").Value() - 0.2));
dom.GetObject("toleranzEGBuro").State((0.000 + dom.GetObject("hochtempEGBuro").Value() - dom.GetObject("niedertempEGBuro").Value()));
dom.GetObject("EGBuroFBTempDiff2").State(dom.GetObject("EGBuroFBTempDiff").Value());
if ((dom.GetObject("EGBuroFBTempDiff").Value()) <= 0.000)
{
dom.GetObject("EGBuroFBTempDiff").State(0.010);
WriteLine("TempDiff kleiner gleich 0"); WriteLine(dom.GetObject("EGBuroFBTempDiff").Value());
}
else
{
WriteLine ("TempfDiff größer 0"); WriteLine(dom.GetObject("EGBuroFBTempDiff").Value());
}
!---------------------- Einschaltzeit berechnen -----------------
if ((dom.GetObject("isttemperaturEGBuro").Value()) <= (dom.GetObject("solltemperaturEGBuro").Value()))
{
WriteLine("Isttemperatur kleinergleich solltemperatur");
dom.GetObject("heizleistungEGBuro").State((0.0000 + ((((dom.GetObject("solltemperaturEGBuro").Value() + 0.2000) - dom.GetObject("isttemperaturEGBuro").Value()) / dom.GetObject("toleranzEGBuro").Value()) * 100.0000)));
dom.GetObject("heizzeit1EGBuro").State((0.0000 + ((dom.GetObject("ScriptintervallEGBuro").Value() * dom.GetObject("heizleistungEGBuro").Value()) / 100.0000)));
dom.GetObject("einschaltzeitvergleichtempEGBuro").State((0.0000 + ((dom.GetObject("EGBuroFBTempDiff").Value() * dom.GetObject("heizzeit1EGBuro").Value()) / dom.GetObject("EGBuroDiffStartEndHeizzeit").Value()))) 
dom.GetObject("OrigHeizEGBuro").State(dom.GetObject("heizzeit1EGBuro").Value());
if (((dom.GetObject("toleranzEGBuro").Value() * dom.GetObject("heizleistungEGBuro").Value()) / 100.0000) >= dom.GetObject("einschaltzeitvergleichtempEGBuro").Value())
{
WriteLine("heizzeit im original übernommen"); dom.GetObject("heizzeitEGBuro").State((dom.GetObject("heizzeit1EGBuro").Value() * 60.0000));
}
else
{
WriteLine("reduzierte heizzeit übernommen"); 
dom.GetObject("tempdifferenzkalkrealEGBuro").State((0.0000 + (dom.GetObject("einschaltzeitvergleichtempEGBuro").Value() - ((dom.GetObject("toleranzEGBuro").Value() * dom.GetObject("heizleistungEGBuro").Value()) / 100.0000))));
dom.GetObject("reduzierungszeitEGBuro").State(0.0000 + ((dom.GetObject("tempdifferenzkalkrealEGBuro").Value() * dom.GetObject("EGBuroDiffStartEndHeizzeit").Value()) / dom.GetObject("EGBuroFBTempDiff").Value()));
dom.GetObject("neueheizzeitEGBuro").State((0.0000 + (dom.GetObject("heizzeit1EGBuro").Value() - dom.GetObject("reduzierungszeitEGBuro").Value())));
if (dom.GetObject("neueheizzeitEGBuro").Value() <= 0.0000)
{
dom.GetObject("heizzeitEGBuro").State((0.0000 + dom.GetObject("SicherheitsheizzeitEGBuro").Value())); WriteLine("sicherheitshalber 4 Minuten heizen");
}
else
{
dom.GetObject("heizzeitEGBuro").State((0.0000 + (dom.GetObject("neueheizzeitEGBuro").Value() * 60.0000))); WriteLine("neueheizzeit übernommen");
}
}
}
else
{
WriteLine("Isttemperatur größer solltemperatur");
dom.GetObject("heizleistungEGBuro").State((0.0000 + (((dom.GetObject("hochtempEGBuro").Value() - dom.GetObject("isttemperaturEGBuro").Value()) / dom.GetObject("toleranzEGBuro").Value()) * 100.0000)));
dom.GetObject("heizzeit1EGBuro").State((0.0000 + ((dom.GetObject("ScriptintervallEGBuro").Value() * dom.GetObject("heizleistungEGBuro").Value()) / 100.0000)));
dom.GetObject("einschaltzeitvergleichtempEGBuro").State((0.0000 + (dom.GetObject("EGBuroFBTempDiff").Value() * dom.GetObject("heizzeit1EGBuro").Value() / dom.GetObject("EGBuroDiffStartEndHeizzeit").Value())));
dom.GetObject("OrigHeizEGBuro").State(dom.GetObject("heizzeit1EGBuro").Value());
if (((dom.GetObject("toleranzEGBuro").Value() * dom.GetObject("heizleistungEGBuro").Value()) / 100.0000) >= dom.GetObject("einschaltzeitvergleichtempEGBuro").Value())
{
WriteLine("heizzeit im original übernommen"); dom.GetObject("heizzeitEGBuro").State((dom.GetObject("heizzeit1EGBuro").Value() * 60));
}
else
{
WriteLine("reduzierte heizzeit übernommen"); 
dom.GetObject("tempdifferenzkalkrealEGBuro").State(0.0000 + (dom.GetObject("einschaltzeitvergleichtempEGBuro").Value() - ((dom.GetObject("toleranzEGBuro").Value() * dom.GetObject("heizleistungEGBuro").Value()) / 100.0000)));
dom.GetObject("reduzierungszeitEGBuro").State(0.0000 + ((dom.GetObject("tempdifferenzkalkrealEGBuro").Value() * dom.GetObject("EGBuroDiffStartEndHeizzeit").Value()) / dom.GetObject("EGBuroFBTempDiff").Value()));
dom.GetObject("neueheizzeitEGBuro").State(0.0000 + (dom.GetObject("heizzeit1EGBuro").Value() - dom.GetObject("reduzierungszeitEGBuro").Value()));
if (dom.GetObject("neueheizzeitEGBuro").Value() <= 0.0000)
{
dom.GetObject("heizzeitEGBuro").State(0.0000 + dom.GetObject("SicherheitsheizzeitEGBuro").Value()); WriteLine("sicherheitshalber 4 Minuten heizen");
}
else
{
dom.GetObject("heizzeitEGBuro").State(0.0000 + (dom.GetObject("neueheizzeitEGBuro").Value() * 60.0000)); WriteLine("neueheizzeit übernommen");
}
}
}
!-----------------------Heizzeit in Systemvariable schreiben
dom.GetObject("EGBuroFBEinschaltzeit").State(dom.GetObject("heizzeitEGBuro").Value());
dom.GetObject("EGBuroFBeinschaltzeitvergleichtemp").State(dom.GetObject("einschaltzeitvergleichtempEGBuro").Value());

!------------------- Künftige Temperatur bei doppelter Schaltzeit vorausrechnen
dom.GetObject("tempvorausrechnungEGBuro").State(0.0000 + ((dom.GetObject("EGBuroFBTempDiff2").Value() * (dom.GetObject("ScriptintervallEGBuro").Value() * 2.000) / dom.GetObject("EGBuroDiffStartEndHeizzeit").Value())));
dom.GetObject("NeueisttemperaturEGBuro").State(0.0000 + dom.GetObject("isttemperaturEGBuro").Value() + dom.GetObject("tempvorausrechnungEGBuro").Value());
!--------------TEST Temperaturen anzeigen
!----- Schaltungen ausführen
if ((dom.GetObject("isttemperaturEGBuro").Value() < dom.GetObject("hochtempEGBuro").Value()) && (dom.GetObject("isttemperaturEGBuro").Value() > dom.GetObject("niedertempEGBuro").Value())) 
 {
if ((dom.GetObject("EGBuroFBVergleichTemp").Value() == dom.GetObject("isttemperaturEGBuro").Value()) && (dom.GetObject("isttemperaturEGBuro").Value() > dom.GetObject("solltemperaturEGBuro").Value()))
{
dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value()); WriteLine("Ist = Vergleichstemperatur");
if (schaltzustandEGBuro == "true")
   {
    WriteLine("ist eingeschaltet und soll ausgeschaltet sein"); dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(0); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
    }
    else
    {
     WriteLine("ist ausgeschaltet und soll ausgeschaltet sein"); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
}
else
{
 WriteLine("innerhalb toleranz"); dom.GetObject("EGBuroFBTempIstinToleranz").State(true);
  if ((dom.GetObject("isttemperaturEGBuro").Value() <= dom.GetObject("hochstillEGBuro").Value()) && (dom.GetObject("isttemperaturEGBuro").Value() >= dom.GetObject("niederstillEGBuro").Value()))
  {
   WriteLine("innerhalb stille");
    if (schaltzustandEGBuro == "true")
   {
    WriteLine("ist eingeschaltet und soll ausgeschaltet sein"); dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(0); dom.GetObject("EGBuroFBTempIstinToleranz").State(true); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
    }
    else
    {
     WriteLine("ist ausgeschaltet und soll ausgeschaltet sein"); dom.GetObject("EGBuroFBTempIstinToleranz").State(true); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
   }
   else
   {
   WriteLine("ausserhalb stille");
   if (dom.GetObject("isttemperaturEGBuro").Value() < dom.GetObject("niederstillEGBuro").Value())
   {
    if (dom.GetObject("heizzeitEGBuro").Value() < dom.GetObject("SchaltschwelleniedertempEGBuro").Value())
    {
    WriteLine("Schaltzeit zu klein");dom.GetObject("EGBuroFBTempIstinToleranz").State(true);
    if (schaltzustandEGBuro == "true")
    {
    WriteLine("ist eingeschaltet und soll ausgeschaltet sein"); dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(0); dom.GetObject("EGBuroFBTempIstinToleranz").State(true); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value()); 
    }
    else
    {
     WriteLine("ist ausgeschaltet und soll ausgeschaltet sein"); dom.GetObject("EGBuroFBTempIstinToleranz").State(true); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
    }
    else
    {
    WriteLine("kleiner niederstill"); dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".ON_TIME").State(dom.GetObject("heizzeitEGBuro").Value()); dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(1); dom.GetObject("EGBuroFBTempIstinToleranz").State(true); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value()); 
    }
   }
    else
    {
    if (dom.GetObject("EGBuroFBVergleichTemp").Value() < dom.GetObject("isttemperaturEGBuro").Value())
    {
    dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value()); WriteLine("über hochstill gestiegen"); 
    if (schaltzustandEGBuro == "true")
    {
    WriteLine("ist eingeschaltet und soll ausgeschaltet sein"); dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(0); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
    }
    else
    {
     WriteLine("ist ausgeschaltet und soll ausgeschaltet sein"); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
     }
    else
    {
    if (dom.GetObject("heizzeitEGBuro").Value() < dom.GetObject("SchaltschwellehochtempEGBuro").Value())
    {
    WriteLine("Schaltzeit zu klein"); dom.GetObject("EGBuroFBTempIstinToleranz").State(true);
    if (schaltzustandEGBuro == "true")
   {
    WriteLine("ist eingeschaltet und soll ausgeschaltet sein"); dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(0); dom.GetObject("EGBuroFBTempIstinToleranz").State(true); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
    }
    else
    {
     WriteLine("ist ausgeschaltet und soll ausgeschaltet sein"); dom.GetObject("EGBuroFBTempIstinToleranz").State(true); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
    }
    else
    {
     WriteLine("größer als hochstill"); dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".ON_TIME").State(dom.GetObject("heizzeitEGBuro").Value()); dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(1); dom.GetObject("EGBuroFBTempIstinToleranz").State(true); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
     }
   }
  }
}
}
else
  {
  if (dom.GetObject("isttemperaturEGBuro").Value() >= dom.GetObject("hochtempEGBuro").Value())
  {
  WriteLine("Isttemperatur größer als hochtemp");
  if (schaltzustandEGBuro == "true")
   {
    if (dom.GetObject("NeueisttemperaturEGBuro").Value() <= dom.GetObject("solltemperaturEGBuro").Value())
    {
     WriteLine("Neue Isttemp kleiner gleich Solltemperatur");
     WriteLine("ist eingeschaltet und soll eingeschaltet sein");
     dom.GetObject("EGBuroFBTempIstinToleranz").State(false); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
     else
     {
     WriteLine("Neue Isttemp grösser Solltemperatur");
     WriteLine("ist eingeschaltet und soll ausgeschaltet sein"); dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(0); dom.GetObject("EGBuroFBTempIstinToleranz").State(false); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
    }
    else
    {
    if (dom.GetObject("NeueisttemperaturEGBuro").Value() <= dom.GetObject("solltemperaturEGBuro").Value())
    {
     WriteLine("Neue Isttemp kleiner gleich Solltemperatur");
     WriteLine("ist ausgeschaltet und soll eingeschaltet sein");
dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".ON_TIME").State(36000); 
     dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(1); dom.GetObject("EGBuroFBTempIstinToleranz").State(false); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
dom.GetObject("EGBuroFBEinschaltzeit").State(888);
     }
     else
     {
     WriteLine("Neue Isttemp grösser Solltemperatur");
     WriteLine("ist ausgeschaltet und soll ausgeschaltet sein"); dom.GetObject("EGBuroFBTempIstinToleranz").State(false); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
     }
  }
  else
  {
   if (dom.GetObject("isttemperaturEGBuro").Value() == dom.GetObject("niedertempEGBuro").Value())
  {
   if (schaltzustandEGBuro == "true")
   {
    if (dom.GetObject("NeueisttemperaturEGBuro").Value() >= dom.GetObject("niederstillEGBuro").Value())
    {
     WriteLine("Neue Isttemp größer gleich Niederstill");
     WriteLine("ist eingeschaltet und soll ausgeschaltet sein");
     dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(0); dom.GetObject("EGBuroFBTempIstinToleranz").State(false); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
     else
     {
     WriteLine("Neue Isttemp kleiner Niederstill");
     WriteLine("ist eingeschaltet und soll eingeschaltet sein");
     dom.GetObject("EGBuroFBTempIstinToleranz").State(false); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
    }
    else
    {
     if (dom.GetObject("NeueisttemperaturEGBuro").Value() >= dom.GetObject("niederstillEGBuro").Value())
    {
     WriteLine("Neue Isttemp größer gleich Niederstill");
     WriteLine("ist ausgeschaltet und soll eingeschaltet sein"); dom.GetObject("EGBuroFBTempIstinToleranz").State(false); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
     else
     {
     WriteLine("Neue Isttemp kleiner Niederstill");
     WriteLine("ist ausgeschaltet und soll eingeschaltet sein");
dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".ON_TIME").State(36000);  dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(1);dom.GetObject("EGBuroFBTempIstinToleranz").State(false); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
dom.GetObject("EGBuroFBEinschaltzeit").State(888);
     }
     }
    }
   else
   {
   WriteLine("Isttemperatur ist kleiner als niedertemp"); 
   if (schaltzustandEGBuro == "true")
   {
    if (dom.GetObject("NeueisttemperaturEGBuro").Value() >= dom.GetObject("niederstillEGBuro").Value())
    {
     WriteLine("Neue Isttemp größer gleich Niederstill");
     WriteLine("ist eingeschaltet und soll ausgeschaltet sein");
     dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(0); dom.GetObject("EGBuroFBTempIstinToleranz").State(false); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
     else
     {
     WriteLine("Neue Isttemp kleiner Niederstill");
     WriteLine("ist eingeschaltet und soll eingeschaltet sein");
     dom.GetObject("EGBuroFBTempIstinToleranz").State(false); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
    }
    else
    {
     if (dom.GetObject("NeueisttemperaturEGBuro").Value() >= dom.GetObject("niederstillEGBuro").Value())
    {
     WriteLine("Neue Isttemp größer gleich Niederstill");
     WriteLine("ist ausgeschaltet und soll eingeschaltet sein"); dom.GetObject("EGBuroFBTempIstinToleranz").State(false); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
     }
     else
     {
     WriteLine("Neue Isttemp kleiner Niederstill");
     WriteLine("ist ausgeschaltet und soll eingeschaltet sein");
dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".ON_TIME").State(36000); 
dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(1); dom.GetObject("EGBuroFBTempIstinToleranz").State(false); dom.GetObject("EGBuroFBVergleichTemp").State(dom.GetObject("isttemperaturEGBuro").Value());
dom.GetObject("EGBuroFBEinschaltzeit").State(888);
     }
     }
   }
  }
}
if ((dom.GetObject("solltemperaturEGBuro").Value() < 5.600) && (dom.GetObject("ScriptwiederholungEGBuromax").Value() == dom.GetObject("ScriptwiederholungEGBuro").Value()) && (dom.GetObject("Aussentemp").Value() == 2.0))
{
dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".ON_TIME").State(dom.GetObject("ScriptwiederholungEGBuroHeizzeit").Value()); dom.GetObject(AktorEGBuro#":"#AktorkanalEGBuro#".STATE").State(1); dom.GetObject("ScriptwiederholungEGBuro").State(0.0);
dom.GetObject("EGBuroFBEinschaltzeit").State(999);
}
else
{
WriteLine("nix");
dom.GetObject("ScriptwiederholungEGBuro").State(dom.GetObject("ScriptwiederholungEGBuro").Value() + 1.0);
if (dom.GetObject("ScriptwiederholungEGBuro").Value() > dom.GetObject("ScriptwiederholungEGBuromax").Value())
{
dom.GetObject("ScriptwiederholungEGBuro").State(0.0); 
}
else
{
dom.GetObject("ScriptwiederholungEGBuro").State(dom.GetObject("ScriptwiederholungEGBuro").Value());
}
}
WriteLine("Ende");

Script 5:

Code: Alles auswählen

    !---- StartHeizzeit in Systemvariable schreiben

    !----- RaumreglerEGBuro identifizieren
    string RaumreglerEGBuro = "BidCos-RF.XXXXXXXXXXX";


    !---- StartHeizzeit für Tempvorausrechnung in Systemvariable schreiben

    if ((dom.GetObject("EGBuroZahli").Value()) == 0.0)
    {
    WriteLine("Zaehler kleiner 1");
    dom.GetObject("EGBuroStartHeizzeit").State((((system.Date("%H").ToInteger()) * 60) + (system.Date("%M").ToInteger())));
    dom.GetObject("EGBuroZahli").State((dom.GetObject("EGBuroZahli").Value())+1.0);
    WriteLine(dom.GetObject("EGBuroZahli").Value());
    WriteLine(dom.GetObject("EGBuroStartHeizzeit").Value());
    }
    else
    {
    dom.GetObject("EGBuroZahli").State((dom.GetObject("EGBuroZahli").Value())+1.0);
    if ((dom.GetObject("EGBuroZahli").Value()) > 2.0)
    {
    WriteLine("Zaehler groesser Max");
    dom.GetObject("EGBuroZahli").State(0.0);
    WriteLine("Zaehler null");
    WriteLine(dom.GetObject("EGBuroZahli").Value());
    }
    else
    {
    WriteLine("nix");
    WriteLine(dom.GetObject("EGBuroZahli").Value());
    }
    }

!---- StartHeizzeit1 für Scriptintervallberechnung in Systemvariable schreiben

    
    dom.GetObject("EGBuroStartHeizzeit1").State((((system.Date("%H").ToInteger()) * 60) + (system.Date("%M").ToInteger())));

    !--------- Startheiztemperatur in Systemvariable schreiben


    !-----Aktion durchführen

    if ((dom.GetObject("EGBuroZahli").Value()) == 0.0)
    {
    WriteLine("Zaehler kleiner null");
    dom.GetObject("EGBuroFBStartTemperatur").State(dom.GetObject(RaumreglerEGBuro#":2.ACTUAL_TEMPERATURE").Value());
    WriteLine(dom.GetObject("EGBuroFBStartTemperatur").Value());
    }
    else
    {
    WriteLine("nix");
    }


    !---------- Differenz zur Einschaltzeit errechnen

    if ((dom.GetObject("EGBuroEndHeizzeit").Value()) < (dom.GetObject("EGBuroletztesEIN").Value()))
    {
    dom.GetObject("EGBuroleEINDIFF").State(((1440 - (dom.GetObject("EGBuroletztesEIN").Value())) + (dom.GetObject("EGBuroEndHeizzeit").Value())));
    }
    else
    {
    dom.GetObject("EGBuroleEINDIFF").State(((dom.GetObject("EGBuroEndHeizzeit").Value()) - dom.GetObject("EGBuroletztesEIN").Value()));
    }

Script 6:

Code: Alles auswählen

!--------- Wird nicht mehr benötigt

Script 7:

Code: Alles auswählen

!---------- Wird nicht mehr benötigt

Ergänzung:

Die hier dargestellte Lösung ermittelt aufgrund der Ausführzeiten des Programm Nr. 3 automatisch das Zeitintervall zur Berechnung der Pulsweitenmodulation.
Das bedeutet, dass das Programm 3 sich bei der Berechnung an dem im Programm eingestellten CCU2-Zeitplan orientiert.
Sofern das Programm 3 desöfteren aus irgendwelchen individuellen Gründen (beispielsweise zusätzliche Steuerung einer Wärmepumpe etc. ) auch zwischen den im Zeitplan definierten
Zeitpunkten ausgeführt werden soll, ist es günstiger, das Zeitintervall für die Berechnungen FEST zu definieren und nicht dynamisch aus den Ausführungzeitpunkten ermitteln zu lassen.

Dies bedeutet, dass folgende Script-Zeile unter "!----Ausführintervall Script und diverses festlegen" von Script 4 des Programm Nr. 3 einzutragen ist:

Code: Alles auswählen

dom.GetObject("ScriptintervallEGBuro").State(20.00);

Hier im Beispiel der Wert "20.00" für das Zeitintervall "20 Minuten".

Nähere Erklärung hierzu in folgendem Post:
http://homematic-forum.de/forum/viewtop ... 60#p343452

[twoxx]

Erforderliche Systemvariablen (Pro Stellantrieb):
Achtung! Im nachfolgenden Post habe ich Scripte hinterlegt, mit denen die hier aufgelisteten Systemvariablen
AUTOMATISCH angelegt werden können. Es ist also nicht notwendig die Systemvariablen einzeln manuell in der CCU2
anzulegen.
(Da die Firmware auf einer CCU2 insgesamt maximal nur 200 Script-Variablen zulässt, habe ich mein Projekt zur Schonung der Ressourcen der CCU2 nur
mit Systemvariablen umgesetzt).

EGBuroAutoManuWeiter / Werteliste Auto;Manuell;Weitere
EGBuroDiffStartEndHeizzeit / Zahl
EGBuroEndHeizzeit / Zahl
EGBuroFBeinschaltzeitvergleichtemp / Zahl
EGBuroFBEndTemperatur / Zahl
EGBuroFBStartTemperatur / Zahl
EGBuroFBTempDiff / Zahl
EGBuroFBTempDiff2 / Zahl
EGBuroFBTempIstinToleranz / Logikwert wahr = ist wahr
EGBuroFBEinschaltzeit / Zahl
EGBuroFBVergleichTemp / Zahl
EGBuroleEINDIFF / Zahl
EGBuroletztesEIN / Zahl
EGBuroStartHeizzeit / Zahl
EGBuroZahli / Zahl
einschaltzeitvergleichtempEGBuro / Zahl
heizleistungEGBuro / Zahl
heizzeit1EGBuro / Zahl
heizzeitEGBuro / Zahl
hochstillEGBuro / Zahl
hochtempEGBuro / Zahl
isttemperaturEGBuro / Zahl
neueheizzeitEGBuro / Zahl
NeueisttemperaturEGBuro / Zahl
niederstillEGBuro / Zahl
niedertempEGBuro / Zahl
OrigHeizEGBuro / Zahl
reduzierungszeitEGBuro / Zahl
SchaltschwellehochtempEGBuro / Zahl
SchaltschwelleniedertempEGBuro / Zahl
ScriptintervallEGBuro / Zahl
ScriptwiederholungEGBuro / Zahl
ScriptwiederholungEGBuromax / Zahl
ScriptwiederholungEGBuroHeizzeit / Zahl
SicherheitsheizzeitEGBuro / Zahl
solltemperaturEGBuro / Zahl
tempdifferenzkalkrealEGBuro / Zahl
tempvorausrechnungEGBuro / Zahl
toleranzEGBuro / Zahl
toleranzniederEGBuro / Zahl
Aussentemp / Zahl
EGBuroStartHeizzeit1/ Zahl


Erklärung der wichtigsten Variablen:

AutoManuWeiter = Wenn Systemvariable auf "AUTO" gesetzt, dann wird das Programm zur Steuerung der Fussbodenheizung ausgeführt (bspw. im Winter)
wenn Systemvariable auf "Manu" oder "Weiter" gesetzt, dann wird das Steuerungsprogramm nicht mehr ausgefühfrt (bswp. im Sommer).
Den Wandthermostat auf "OFF" bzw. 4,5 Grad zu stellen genügt nicht um die Heizung komplett abzuschalten, da hier die Wärmeerhaltung in der
Schleife aktiv wird.
EndHeizzeit = Tageszeit an dem der letzte Heizzyklus geendet hat (Start des Programms Nr. 3)
StartHeizzeit = Tageszeit an dem der nächste Heizzyklus beginnt (Programm Nr. 3 ist komplett abgearbeitet)
DiffStartEndHeizzeit = Differenz der Tageszeiten (Zeitraum zwischen den beiden Programmaufrufen von Programm Nr. 3)
FBEndTemperatur = Isttemperatur bei Start des Programms (Temperatur nachdem der letzte Heizzyklus durchlaufen wurde)
FBStartTemperatur = Isttemperatur nachdem das Programm komplett abgearbeitet wurde (Starttemperatur des nächsten Heizzyklus)
FBeinschaltzeitvergleichtemp = Vom Script errechnete Temperatur, die erreicht wird, wenn Heizimpuls im Heizzyklus komplett gemäß errechneter Heizzeit durchlaufen wurde
FBTempDiff = Differenz der aktuellen Isttemperatur im Vergleich zur Isttemperatur, wie sie beim vorausgegangenen Programmaufruf von Programm Nr. 3 war
FBTempIstinToleranz = Anzeige, ob die Isttemperatur aktuell innerhalb der Toleranz liegt (danach entscheidet sich, ob komplett durchgeheizt wird, oder ob Heizimpulse mit Heizzeiten ausgeführt werden)
FBEinschaltzeit = Errechnete Heizzeit für Heizimpuls wenn Isttemperatur innerhalb der Toleranz liegt
FBVergleichTemp = Errechnete Vergleichstemperatur zur Prüfung, wie sich die Raumtemperatur in 20,40,60 Minuten (Zeitraum abhängig von Variable "OGBurozahli") entwickeln wird (danach entscheidet das Script ob aufgrund Trägheit der Fussbodenheizung nicht sofort geheizt oder nicht mehr geheizt werden soll.
leEINDIFF = So viele Minuten war der Stellantrieb nicht mehr eingeschaltet (bei starken Minustemperaturen wird so ein zu starkes Auskühlen der Fussbodenschleife verhindert)
ScriptwiederholungEGBuromax = Maximale Anzahl der Ausführungen des Scripts bei Solltemperatur unterhalb 5,6 Grad bis dann der Stellantrieb eingeschaltet wird um ein zu starkes
Auskühlen der Fussbodenschleife zu verhindern (Wärmeerhaltung in der Fussbodenschleife)
ScriptwiederholungEGBuroHeizzeit = Einschaltzeit des Stellantriebs in Sekunden die zur Wärmeerhaltung in der Fussbodenschleife dient.
SchaltschwellehochtempEGBuro = Hier den mittels Stoppuhr ermittelten Wert in Sekunden eintragen, den der Stellantrieb benötigt um komplett zu öffnen
SchaltschwelleniedertempEGBuro = Hier den mittels Stoppuhr ermittelten Wert in Sekunden eintragen, den der Stellantrieb benötigt um komplett zu öffnen


Da ich das Script nicht nur bei einem Stellantrieb verwende, sonder bei 9, habe ich je Stellantrieb in den Scripten und variablen jeweils immer ein "OGBuro" zur Unterscheidung hinzugefügt.
Die Scripte meiner weitern Stellantriebe lauten dann beispielsweise auf "OGWohn", "OGBad" etc.


Das Heizverhalten des Stellantriebs kann im Script 4 an folgender Stelle komplett auf die eigene Situation angepasst werden:

Code: Alles auswählen

!----Ausführintervall Script und diverses festlegen

dom.GetObject("SicherheitsheizzeitEGBuro").State(240.000); !---- Heizzeit, falls errechnete Heizzeit im Minus
dom.GetObject("SchaltschwelleniedertempEGBuro").State(190.000); !--- Sofern errechnete Schaltzeit kleiner, dann nicht einschalten
dom.GetObject("SchaltschwellehochtempEGBuro").State(190.000); !---- Sofern errechnete Schaltzeit kleiner, dann nicht einschalten
dom.GetObject("ScriptwiederholungEGBuromax").State(5.0); !-----------Wiederholung des Scripts bis Wärmeerhaltung
dom.GetObject("ScriptwiederholungEGBuroHeizzeit").State(241.0); !---- Heizzeit bei Wärmeerhaltung

und hier:

Code: Alles auswählen

!------ GrenzTemperaturen und Hysterese berechnen
dom.GetObject("hochtempEGBuro").State((0.000 + dom.GetObject("solltemperaturEGBuro").Value() + 0.5)); ! --- Heizzeitberechnung bis 0,5 Grad über Solltemperatur, darüber Stellantrieb dauerhaft aus
dom.GetObject("toleranzniederEGBuro").State(0.8); ! --- Heizzeitberechnung bis 0,8 Grad unter Solltemperatur - darunter dauerhaft Stellantrieb ein
dom.GetObject("niedertempEGBuro").State((0.000 + dom.GetObject("solltemperaturEGBuro").Value() - dom.GetObject("toleranzniederEGBuro").Value()));
dom.GetObject("hochstillEGBuro").State((0.000 + dom.GetObject("solltemperaturEGBuro").Value() + 0.1)); ! --- Hysterese  bis 0,1 Grad über Solltemperatur keine Aktion durchführen
dom.GetObject("niederstillEGBuro").State((0.000 + dom.GetObject("solltemperaturEGBuro").Value() - 0.2)); ! --- Hysterese bis 0,2 Grad unter Solltemperatur keine Aktion durchführen
dom.GetObject("toleranzEGBuro").State((0.000 + dom.GetObject("hochtempEGBuro").Value() - dom.GetObject("niedertempEGBuro").Value()));

- Sofern der der Zuschlag bei hochtempEGBuro (im Beispiel +0,5°) zu groß gewählt wird und die aktuelle IST-Temperatur ÜBER der Solltemperatur liegt, kann es vorkommen, dass die Ist-Temperatur weit
oberhalb der Soll-Temperatur gehalten wird und nie den Bereich innerhalb der Hysterese erreicht. --> Der Raum bleibt viel zu warm und kann nicht abkühlen.

- Sofern der Abschlag toleranzniederEGBuro (im Beispiel 0,8°) zu groß gewählt wird und die aktuelle IST-Temperatur UNTER der Solltemperatur liegt, kann es vorkommen, dass die IST-Temperatur
weit unterhalb der Soll-Temperatur bleibt und die Raumtemperatung nie den Bereich der Hysterese oder die Solltemperatur erreicht. --> Der Raum bleibt zu kalt.

Die beiden Werte müssen individuell durch Ausprobieren im jeweiligen Raum ermittelt werden. Als Startwerte zum Ausprobieren eigenen sich die im Beispielscript hinterlegten Werte auf jeden Fall.
Hierbei wird davon ausgegangen, dass die Einstellungen der Vorlauftemperatur der Heizung bereits VOR Umsetzung der hier dar gestellten Lösung im entsprechend für die jeweilige Heizung
erforderlichen normalen Rahmen liegen.

[twoxx]

Wie oben bereits geschrieben, habe ich hier Scripte hinterlegt mit denen die obigen Systemvariablen AUTOMATISCH
pro Stellantrieb in der CCU2 angelegt werden können.
ACHTUNG!!! VOR VERWENDUNG DER SCRIPTE IST ZWINGEND EINE SYSTEMSICHERUNG DER CCU2 DURCHZUFUEHREN.
DIE NUTZUNG DIESER SCRIPTE ZUR ANLAGE DER SYSTEMVARIABLEN ERFOLGT AUF EIGENE VERANTWORTUNG!!!

Die Original-Scripte zur Anlage der Systemvariablen stammen von BadenPower, der mir dankenswerterweise erlaubt hat sein Script entsprechend
abzuwandeln und hier zu posten.

Hier der Link zu seinem Thread: http://homematic-forum.de/forum/viewtop ... 31&t=35020


Die Scripte zur Anlage der Systemvariablen enthalten eine Zeile in der man den Namenszusatz zur Unterscheidung der jeweiligen Stellantriebe/Heizkreise eintragen kann.

Dieser Namenszusatz wird dann an die jeweilige Systemvariable angehängt. Im Beispiel lautet dieser Zusatz "EGBuro".
Der Zusatz ist sowohl in den Systemvariablen, als auch in den Scripten zur Steuerung der Heizung pro Stellantrieb abzuändern.

Das Ausführen des jeweiligen Scripts dauert ca. 10 - 15 Minuten, wenn die CCU2 bereits mit vielen anderen Projekten schon eingespannt ist.
Bei einer relativ unbelasteten CCU2 laufen die Scripte auch auf 20 Sekunden durch.
Deshalb ist die Anlage der Variablen auch in 5 Scripte aufgeteilt.

Bitte sämtliche Systemvariablen anhand der obigen Liste prüfen, ob wirklich alle Variablen richtig angelegt wurden.

Nachdem man den Namenszusatz für einen neuen Stellantrieb in den Scripten abgeändert hat und man nun prüfen möchte, ob alle in den Scripten genannten
Systemvariablen auch in der CCU2 existieren, kann man man dies pro Variable mit folgendem Script durchführen (Original stammt ebenfalls von Badenpower):

Code: Alles auswählen

boolean lDebug = true;
    object lObj = (dom.GetObject(ID_SYSTEM_VARIABLES)).Get("Name_der_Systemvariable_die_im_Script_genannt_wird_eintragen");
    if (lObj)
    {
      WriteLine("Systemvariable im Script stimmt mit Systemvariable in der CCU2 überein");
    }
    else
    {
      if(lDebug)
      {
        WriteLine("Debug: Im Script genannte Systemvariable ist NICHT in der CCU2 vorhanden!");
      }
    }

[twoxx]

Noch weitere aktuelle Hinweise:

1)
Bei meinem aktuellen Firmware-Update der Wandthermostate auf Version 1.3 kam es vor, dass aufgrund der Direktverknüpfung die Stellantriebe alle 4 Minuten ein- und ausgeschaltet wurden.
Allerdings trat dieses Phänomen nicht bei allen Wandthermostaten auf. Meine Fussbodenheizungs-Lösung funktioniert auch ohne die Direktverknüpfungen.
Weshalb die aktuelle Version meiner Umsetzung nun ohne Direktverknüpfung zwischen Schaltaktor und Wandthermostat ausgeführt wird.

2) der nun folgende hinweis kommt wahrscheinlich nur zum tragen falls man (wie ich) neben der fussbodenheizung noch diverseste andere geräte der ccu2 "aufbürdet" und deshalb eine menge scripte am laufen sind:
Die CCU2 hat nur einen begrenzten Variablen-Speicher für "Script-Variable" (nicht Systemvariable) -> Es sind insgesamt nur 200 Script-Variablen möglich..
Leider gibt die CCU2 nach Bearbeitung eines Scripts den verwendeten Variablenspeicher nicht frei (das haben die Entwickler so festgelegt, warum auch immer!!!).

Wenn zuviele "Script-Variablen" verwendet werden, dann führt CCU2 dann einfach irgendein Programm nicht mehr aus.
Nach einem Neustart funktioniert das eine Zeit lang wieder, bis der Speicher wieder volläuft. Irgendein anderes zufälliges Programm wird dann später nicht merh ausgeführt.

Die Lösung hierzu ist, die Scripte zu "straffen" und so wenig wie möglich Script-Variable zu verwenden.

Aus diesem Grund sind fast alle Variablen in den Scripten System-Variablen.

3) Hier im Forum habe ich lediglich das Programm und das Script für einen der Stellantriebe dargestellt.
Bei Verwendung mehrerer Stellantriebe und Wandthermostate empfiehlt es sich, die Ausführung des jeweiligen Programms / Scripts zeitlich von den jeweils anderen Stellantrieben versetzt durchzuführen.

Meine Stellantriebe werden jeweils zeitlich um 5 Minuten versetzt gesteuert, damit kein "Funksalat" entsteht und die CCU2 keine Konflikte bei der Gerätekommunikation hat. (Falls sie wie bei mir noch diverseste andere geräte mit der ccu2 kommunizieren müssen). Der Duty-Cycle der CCU2 wird so etwas geschont und gleichzeizit dient das versetzte Starten der Stellantrieb-Programme auch
dazu die Last im Heizkreisverteiler etwas zu verteilen. Es handelt sich hier nicht um eine komplette Lastverteilung, aber zumindest im Ansatz.

4) Wer sich für eine Fußbodenheizungsteuerung per Homematic entscheidet, kann mittlerweile auch die fertigen Fußbodenheizungsaktoren
von Homematic IP verwenden (HMIP-FAL XXX). Diese Aktoren nutzen ebenfall noch die bisherigen thermoelektrischen Stellantrieb, welche
nur komplett geöffnet oder geschlossen werden können. Als Kompensation wird hier ebenfalls eine Pulsweitenmodulation verwendet,
ähnlich wie ich es in meinem Projekt anwende.

Um die Trägheit einer Fußbodenheizung besser zu kompensieren gäbe es auch die Möglichkeit elektromotorische Stellantriebe zu verwenden,
die es ermöglichen, die Heizkreise - genau wie bei einem Heizkörperthermostat - nur zu 20%, 40% 60% 80% oder 100% zu öffnen oder zu schliessen.
Dies ermöglicht mittlerweile der neue Homematic Fußbodenheizungsaktor HMIP-FALMOT. Es ist vor Beginn des Projekts auf jeden Fall wert,
einen Blick auf diese neue Technik zu werfen.
Wenn es mir damals in 2015 programmiertechnisch bereits möglich gewesen wäre, so eine Lösung zu programmieren, dann hätte ich das damals
getan. Nun kann man sie direkt bei Homematic kaufen.

[paul53]

Sobald die Differenz zwischen Ist-Temperatur und Soll-Temperatur innerhalb eines gewissen Rahmens liegt, soll vom "Dauerheizen" oder auch "Dauer-NICHT-Heizen" in eine simulierte "Pulsweiten Modulation" gewechselt werden, womit die Trägheit der Fussbodenheizung ausgeglichen wird.

Das macht auch ein PI-Regler mit PWM-Ausgang wie er mittlerweile (ab Version 0.66) im CUxD Thermostat Device enthalten ist.

[Helikiller]

Erforderliche Systemvariablen:
EndHeizzeit = Tageszeit an dem der letzte Heizzyklus geendet hat (Start des Programms)
StartHeizzeit = Tageszeit an dem der nächste Heizzyklus beginnt (Programm ist komplett abgearbeitet)
DiffStartEndHeizzeit = Differenz der Tageszeiten (Zeitraum zwischen den beiden Programmaufrufen)
FBEndTemperatur = Isttemperatur bei Start des Programms (Temperatur nachdem der letzte Heizzyklus durchlaufen wurde)
FBStartTemperatur = Isttemperatur nachdem das Programm komplett abgearbeitet wurde (Starttemperatur des nächsten Heizzyklus)
FBeinschaltzeitvergleichtemp = Vom Script errechnete Temperatur, die erreicht wird, wenn Heizimpuls im Heizzyklus komplett gemäß errechneter Heizzeit durchlaufen wurde
WohnFBTempDiff = Differenz der aktuellen Isttemperatur im Vergleich zur Isttemperatur, wie sie beim vorausgegangenen Programmaufruf war
FBTempIstinToleranz = Anzeige, ob die Isttemperatur aktuell innerhalb der Toleranz liegt (danach entscheidet sich, ob komplett durchgeheizt wird, oder ob Heizimpulse mit Heizzeiten ausgeführt werden)
FBWohnzimmerEinschaltzeit = Errechnete Heizzeit für Heizimpuls wenn Isttemperatur innerhalb der Toleranz liegt
FBWohnzimmerVergleichTemp = Errechnete Vergleichstemperatur zur Prüfung, wie sich die Raumtemperatur in 40 Minuten entwickeln wird (danach entscheidet das Script ob aufgrund Trägheit der Fussbodenheizung nicht sofort geheizt oder nicht mehr geheizt werden soll.


Da ich das Script nicht nur bei einem Stellantrieb verwende, sonder bei 4 habe ich je Stellantrieb in den Scripten und variablen jeweils immer ein "OGWohn" etc. zur Unterscheidung hinzugefügt.

Hi twoxx

Wie sind die Systemvariablen gesetzt?

EndHeizzeit = Zahl
StartHeizzeit = Zahl
DiffStartEndHeizzeit = Zahl
FBEndTemperatur = Zahl
FBStartTemperatur = Zahl
FBeinschaltzeitvergleichtemp = Zahl
WohnFBTempDiff = Zahl
FBTempIstinToleranz = Logik
FBWohnzimmerEinschaltzeit = Zahl
FBWohnzimmerVergleichTemp = Zahl

[twoxx]

Alle Systemvariablen sind Zahlen (ausser die variable "fbtempistintoleranz" ..diese ist ein logikwert mit "true" oder "false")



....Achtung nach Aktualisierung bitte neue Variablen-Liste beachten......

Achtung!! Systemvariablen können nun mit den obigen Scripten auch automatisch angelegt werden, eine manuelle Anlage in der CCU2 ist nicht mehr notwendig.