Heizungssteuerung mit openHAB und Z-Wave

Jetzt, wo der Winter doch noch kommt, steht die kalte Jahreszeit vor der Tür, und jetzt müssen wir alle definitiv wieder heizen, aber bitte smart. In diesem Artikel möchte ich euch eine einfache Heizungssteuerung mittels openHAB und Z-Wave zeigen. Als Voraussetzung setze ich eine funktionierende openHAB Installation mit Z-Wave Anbindung voraus, so wie ich es in meinem Artikel zur Basisinstallation von openHAB beschrieben habe.

Da Z-Wave ein herstellerunabhängiger Standard ist, stellt sich am Anfang die Frage nach dem „richtigen“ Heizkörperthermostat. Dazu gibt es mittlerweile eine gute Auswahl am Markt, aber nicht alle überzeugen in Optik oder Funktion.Da hätten wir zum Beispiel das StellaZ von Eurotronic, was einfach nur ein riesiger Klotz an Stelle des Heizkörperthermostates ist und sich nicht manuell einstellen lässt. Oder das Comet-Z von Eurotronic, was auch nicht sehr viel kleiner ist. Dafür sind beide recht günstig zu haben.

Anders sieht es hingegen beim Danfoss LC-13 aus, was den Formfaktor eines normalen Heizkörkerthermostat hat und sich auch manuell regeln lässt. Mit dem runden Display und den drei Tasten fällt es kaum auf, da es fast wie ein traditionelles Thermostat aussieht. Dieses Thermostat hat Devolo als Grundlage genommen und die Firmware etwas angepasst, um es als Devolo 9356 zu verkaufen. Die Devolo Version erlaubt es auch via Z-Wave das eingebaute Thermometer abfragen zu können. Die Batterielaufzeit kann sich auch sehen lassen, denn die Danfoss Version läuft bei mir bereits seit mehr als einem Jahr mit dem ersten Satz Batterien, die alle noch min. 35% voll sind. Die beiden Versionen von Danfoss und Devolo unterscheiden sich nur dadurch, dass sich bei der Devolo Version mit der Command Class „Sensor_Multilevel“ das eingebaute Thermometer abfragen lässt, wofür Devolo ca. 15€ mehr haben möchte.

<Update>

Die Firma Popp hat sich jetzt auch bei Danfoss eingekauft und vertreibt das Danfoss LC-13 als Popp Heizkörperthermostat mit den selben Firmware Features wie Devolo, aber für 4€ weniger, als Danfoss dafür haben möchte.

</Update>

Items

Nachdem die Auswahl des Z-Wave fähigen Thermostates getroffen ist, kommen wir zur Konfiguration. Da ich mich persönlich für die Danfoss / Devolo / Popp Variante entschieden haben, werde ich diese als Beispiel in diesem Artikel verwenden. Damit es nicht zu unübersichtlich wird, werde ich als Beispiel nur das Wohnzimmer und deren Items und Rules beschreiben, alle anderen Zimmer sehen eigentlich genauso aus.

Thermostate in der Items Datei:

Number	thermo_WZ_recht	          "Heizung rechts [%.1f °C]"		<heating>	(G_Living,G_SetP_liv)	{ zwave="5:command=THERMOSTAT_SETPOINT,setpoint_type=1,setpoint_scale=0" }
Number	battery_thermo_WZ_rechts  "Batterie HZ rechts  [%d %%]"		<battery>	(G_Living,G_Battery)	{ zwave="5:command=battery" }


Number	thermo_WZ_links		  "Heizung Wohnzimmer [%.1f °C]"	<heating>	(G_Living,G_SetP_liv)	{ zwave="24:command=THERMOSTAT_SETPOINT,setpoint_type=1,setpoint_scale=0" }
Number	battery_thermo_WZ_links	  "Batterie HZ WZ  [%d %%]"		<battery>	(G_Living,G_Battery)	{ zwave="24:command=battery" }
Number	temp_HZ_WZ_links	  "Temperatur Wohnzimmer [%.1f °C]"	<temperature>	(G_Living,G_Temperatur)	{ zwave="24:0:command=sensor_multilevel,sensor_type=1" }

Die Zeile für die Abfrage der Temperatur ist nur bei der Devolo Variante möglich, die Danfoss Thermostate liefern keine Temperatur zurück. Das SetPoint Verfahren sorg dafür, dass wir uns bei der Heizungssteuerung um die eigentliche Regelung der Thermostate nicht kümmern müssen, es wird nur die Zieltemperatur gesetzt und das Thermostat regelt sich selbstständig. Das spart uns viel Arbeit und Code 😉

Wie zu sehen ist, habe ich einige Gruppen definiert, die ich später in Rules oder Sitemaps wieder verwende. Der Vollständigkeit halber also hier alle relevanten Gruppen, rund um die Heizungssteuerung:

Group			G_Living	"Wohnzimmer"					<video>		(gWh)	
Group:Number:AVG	G_SetP_liv	"Heizkoerper WZ"				<heating>	(G_Heizkoerper)
Group:Number:AVG 	G_Temperatur 	"Durchschnittstemperatur [%.1f °C]" 		<temperature> 	(gWh)
Group:Number:AVG 	G_Heizkoerper 	"Heizkoerper [%.1f °C]" 			<heating>	(gWh)
Group			gr_heat
Group			gr_swi_OpMo
Group			gr_heat_on_man
Group			gr_SetP

Und zusätzlich habe ich noch einige Hilfs Items definiert, um die Rules flexibler gestalten zu können:

Switch	heat_swi_all_off	"heat_swi_all_off"	<own_wall_switch>	(gr_heat)
Switch	heat_swi_3h_warm	"heat_swi_3h_warm"	<own_wall_switch>	(gr_heat)
Switch	heat_swi_1h_hot		"heat_swi_1h_hot"	<own_wall_switch>	(gr_heat)
Switch	heat_swi_OpMo_liv       "heat_swi_OpMo_liv"	<clock>			(gr_heat,gr_swi_OpMo)
Switch	heat_on_man_liv		"heat_off_man_liv"				(gr_heat_on_man)
Number	heat_SetP_liv		"Heizung WZ [%s °C]"	<heating>		(gr_heat,gr_SetP)

Damit ist die Grundlage für den Aufbau von flexiblen Regelwerken gelegt. Um den Automatikbetrieb und den manuellen Betrieb gegeneinander zu verriegeln, habe ich ein Switch Item heat_swi_OpMo_liv für den Automatikbetrieb und heat_on_man_liv für den manuellen Betrieb definiert, wobei der Schalter heat_on_man_liv nur durch eine Regel betätigt wird. Damit verhindere ich, dass beide Betriebsmodie gleichzeitig eingeschaltet sind.

Da ich die Heizintervalle ganz einfach nach Zeit ein- und ausschalte, hält sich der weitere Aufwand in Genzen. Auch ein Masterschalter heat_swi_all_off darf daher nicht fehlen, um alle Heizungen dauerhaft abschalten zu können (z.B. wenn man im Urlaub ist).

Rules

Die Basis Rules für die Heizungssteuerung sieht dann bei mir wie folgt aus:

  /***************/
 /*   imports   */
/***************/

import org.openhab.model.script.actions.*
import org.openhab.core.library.types.*
import org.openhab.core.persistence.*
import java.lang.Math
import org.joda.time.*



  /*****************************/
 /*   variable declarations   */
/*****************************/

var		Timer	timer_window_liv = null

var		Timer	time_3h_warm = null
var		Timer	time_1h_hot = null

var 	DateTime time_started 
var 	DateTime time_liv

var		Number	SetP_before_liv = 4
var		Number	SetP_delta_liv = 4




  /*************/
 /*   rules   */
/*************/


  /* ------------------------------------------------------------------------ */
 /*   initialization   */
/* ------------------ */
rule "heat_init"
when
	System started
then
	heat_swi_all_off.sendCommand(OFF)
	heat_swi_3h_norm.sendCommand(OFF)
	heat_swi_1h_high.sendCommand(OFF)
	gr_swi_OpMo.sendCommand(OFF)
	gr_heat_on_man.sendCommand(OFF)
	gr_SetP.sendCommand(4)
end


  /* ------------------------------------------------------------------------ */
 /*   heat central off   */
/* -------------------- */
rule "heat_all_off"
when
	Item heat_swi_all_off received command
then
	if(receivedCommand == ON)	{ gr_swi_OpMo.sendCommand(ON) }	// set all operating mode switches to "automatic"
	else		
		{
		gr_swi_OpMo.sendCommand(OFF)			// set all operating mode switches to "manual"
		gr_SetP.sendCommand(4)				// and set all SetPoints to "off"
		}						
end


  /* ------------------------------------------------------------------------ */
 /*   livingroom       */
/* ------------------ */
rule "heat_autm_on_liv"
when
	Time cron "0 0 16 ? * MON-FRI *" or			// 'ON' at weekdays:	16:00 
	Time cron "0 0 9 ? * SAT-SUN *" 			// 'ON' at weekend:		 9:00
then	
	if(	heat_swi_OpMo_liv.state == ON && contact_sensor_WZ_window.state == CLOSED)	{ heat_SetP_liv.sendCommand(22) }
end

/* ------------------- */
rule "heat_autm_off_liv"
when
	Time cron "0 0 22 ? * MON-FRI *" or			// 'OFF' at weekdays:	22:00 
	Time cron "0 55 23 ? * SAT-SUN *"			// 'OFF' at weekend:	23:55
then	
	if(	heat_swi_OpMo_liv.state == ON)	{ heat_SetP_liv.sendCommand(18) }
end

/* --------------------- */
rule "heat_swi_on_man_liv"
when
	Item heat_swi_all_off received command or
	Item heat_swi_OpMo_liv received command
then
	if(heat_swi_all_off.state == ON && heat_swi_OpMo_liv.state == OFF)	{ heat_on_man_liv.sendCommand(ON) }
	else	{ heat_on_man_liv.sendCommand(OFF) }
end

/* ------------------- */
rule "heat_set_SetP_liv"
when
	Item heat_SetP_liv received update
then	
	if(G_SetP_liv.state != heat_SetP_liv.state)	
		{ 
		SetP_delta_liv = heat_SetP_liv.state as DecimalType
		SetP_delta_liv = (SetP_delta_liv - 0.5)
		thermo_WZ_links.sendCommand(SetP_delta_liv)
		SetP_delta_liv = (SetP_delta_liv + 1)
		thermo_WZ_rechts.sendCommand(SetP_delta_liv)
		}
end

Mit diesen Rules habe ich via cron die automatischen Heizphasen implementiert und auch den Handbetrieb, sowie den Masterschalter realisiert.

Allgemein kann ich den Rat geben, selbst zu testen, wie lange es dauert, um ein Zimmer bzw. die Wohnung hoch zu heizen, um die Vorlaufzeiten ideal wählen zu können. So hat sich bei mir herausgestellt, dass ich im Wohnzimmer die zwei Heizkörper mit unterschiedlichen Temperaturen konfigurieren muss, wobei der rechte große Heizkörper 1°C höher sein muss als der kleine linke Heizkörper. Bei den Tests hat sich herausgestellt, dass das Thermostat des großen Heizkörpers schneller die Zieltemperatur misst und damit runter regelt, als bei dem kleinen Heizkörper, was dazu führt, dass der große Heizkörper nur noch Handwarm und der kleine voll aufgedreht ist und es nicht schafft den Raum warm zu halten. Daher lässt sich auch keine pauschale Empfehlung für die Zieltemperaturen oder Zeiten geben, da es bei jedem anders sein kann.

Nun kommt es ja auch in der kalten Jahreszeit vor, dass man mal lüften muss und nicht die Umwelt heizen möchte. Die Danfoss / Devolo / Popp Thermostate haben eine Erkennung eingebaut, die ein offenes Fenster anhand des Temperaturabfalls im Raum erkennt und dann das Ventil schließt. Das klingt erstmal toll und verlockend, sich darauf zu verlassen, aber der Fehler liegt im Detail. Das Thermostat regelt nur 30 Minuten runter und dreht dann wieder auf die ursprüngliche Temperatur auf, egal, ob das Fenster noch offen ist, oder nicht. Aus diesem Grund habe ich alle Fenster mit entsprechenden Kontakten ausgestattet, um erkennen zu können, ob die Fenster geöffnet sind. Dazu verwende ich entweder Fibaro’s Fensterkontakte FIBEFGK-101-ZW5, die es in unterschiedlichen Farben gibt und die man nachträglich mit Temperatursensoren (FIB_DS-001) ausstatten kann. Oder, wenn es unsichtbar sein soll, die Sensative Stripes, die in den Fensterrahmen geklebt werden und damit nicht zu sehen sind. Damit kann sichergestellt werden, dass die Heizungssteuerung alle Heizkörper abschaltet, solange ein Fenster offen ist.

Die entsprechende Regel dazu sieht dann so aus:

/* -------------------------- */
rule "heat_off_time_window_liv"
when
	Item contact_sensor_WZ_window changed
then
	logInfo("Heizung", "WZ Heizung Timer Fenster START")
	if(contact_sensor_WZ_window.state == OPEN && heat_swi_OpMo_liv.state == ON && G_SetP_liv.state != 4)
		{
		time_liv = now
		logInfo("Heizung", "WZ Heizung Timer Fenster ENDE")
		timer_window_liv = createTimer(now.plusMinutes(15)) [ heat_SetP_liv.sendCommand(4) ]
		}
	else				
		{
		logInfo("Heizung", "WZ Heizung Timer Fenster ABBRUCH")
		if(timer_window_liv != null)
			{
			timer_window_liv.cancel
			timer_window_liv = null
			}
		heat_SetP_liv.sendCommand(heat_SetP_liv.historicState(time_liv).state))	
		}
end

Dabei ist eine Zeitverzögerung von 15 Minuten eingebaut, weil es sich beim kurzen Lüften bewährt hat, die Heizung auf Zieltemperatur zu belassen. Dabei schlägt dann die eingebaute Erkennung zu und schließt das Ventil.

Da die Frau es manchmal spontan warm haben möchte, habe ich zwei sogenannte Boost Modi eingebaut, die für eine beschränkte Zeit alle Heizkörper aufdrehen und danach wieder auf die Ausgangswerte zurück geht. Die entsprechende Regel sieht bei mir dann so aus:

  /* ------------------------------------------------------------------------ */
 /*   heat 3h warm (liv, bed, bat)   */
/* -------------------------------- */
rule "heat_3h_warm"
when
	Item heat_swi_3h_warm received command
then
	if(receivedCommand == ON)	
		{
		logInfo("Heizung", "Warm Modus, 3 Stunden, WZ-SZ-Bad - AN")
		time_started = now
		heat_swi_OpMo_liv.sendCommand(OFF)
		heat_swi_OpMo_bed.sendCommand(OFF)
		heat_swi_OpMo_bat.sendCommand(OFF)
		heat_SetP_liv.sendCommand(22)
		heat_SetP_bed.sendCommand(22)
		heat_SetP_bat.sendCommand(22)
		time_3h_warm = createTimer(now.plusMinutes(180)) [|
			logInfo("Heizung", "Warm Modus, 3 Stunden, WZ-SZ-Bad - AUS")
			heat_swi_3h_warm.sendCommand(OFF)
			heat_SetP_liv.sendCommand(heat_SetP_liv.historicState(time_started).state)
			heat_SetP_bed.sendCommand(heat_SetP_bed.historicState(time_started).state)
			heat_SetP_bat.sendCommand(heat_SetP_bat.historicState(time_started).state)
			heat_swi_OpMo_liv.sendCommand(heat_swi_OpMo_liv.historicState(time_started).state)
			heat_swi_OpMo_bed.sendCommand(heat_swi_OpMo_bed.historicState(time_started).state)
			heat_swi_OpMo_bat.sendCommand(heat_swi_OpMo_bat.historicState(time_started).state)
			]
		}	
	else
		{
		logInfo("Heizung", "Warm Modus, 3 Stunden, WZ-SZ-Bad - ABBRUCH")
		if(time_3h_warm != null)
			{
			time_3h_warm.cancel	
			time_3h_warm = null
			}	
		heat_SetP_liv.sendCommand(heat_SetP_liv.historicState(time_started).state)
		heat_SetP_bed.sendCommand(heat_SetP_bed.historicState(time_started).state)
		heat_SetP_bat.sendCommand(heat_SetP_bat.historicState(time_started).state)
		heat_swi_OpMo_liv.sendCommand(heat_swi_OpMo_liv.historicState(time_started).state)
		heat_swi_OpMo_bed.sendCommand(heat_swi_OpMo_bed.historicState(time_started).state)
		heat_swi_OpMo_bat.sendCommand(heat_swi_OpMo_bat.historicState(time_started).state)
		}
end


  /* ------------------------------------------------------------------------ */
 /*   heat 1h hot (liv, bed, bat)  */
/* ------------------------------ */
rule "heat_1h_all_hot"
when
	Item heat_swi_1h_hot received command
then
	if(receivedCommand == ON)	
		{
		logInfo("Heizung", "BOOST Modus, 1 Stunde, WZ-SZ-Bad - AN")
		time_started = now
		heat_swi_OpMo_liv.sendCommand(OFF)
		heat_swi_OpMo_bed.sendCommand(OFF)
		heat_swi_OpMo_bat.sendCommand(OFF)
		heat_SetP_liv.sendCommand(26)
		heat_SetP_bed.sendCommand(26)
		heat_SetP_bat.sendCommand(26)
		time_1h_hot = createTimer(now.plusMinutes(60)) [|
			logInfo("Heizung", "BOOST Modus, 1 Stunde, WZ-SZ-Bad - AUS")	
			heat_swi_1h_hot.sendCommand(OFF)
			heat_SetP_liv.sendCommand(heat_SetP_liv.historicState(time_started).state)
			heat_SetP_bed.sendCommand(heat_SetP_bed.historicState(time_started).state)
			heat_SetP_bat.sendCommand(heat_SetP_bat.historicState(time_started).state)
			heat_swi_OpMo_liv.sendCommand(heat_swi_OpMo_liv.historicState(time_started).state)
			heat_swi_OpMo_bed.sendCommand(heat_swi_OpMo_bed.historicState(time_started).state)
			heat_swi_OpMo_bat.sendCommand(heat_swi_OpMo_bat.historicState(time_started).state)
			]
		}	
	else
		{
		logInfo("Heizung", "BOOST Modus, 1 Stunde, WZ-SZ-Bad - ABBRUCH")
		if(time_1h_hot != null)
			{
			time_1h_hot.cancel
			time_1h_hot = null
			}	
		heat_SetP_liv.sendCommand(heat_SetP_liv.historicState(time_started).state)
		heat_SetP_bed.sendCommand(heat_SetP_bed.historicState(time_started).state)
		heat_SetP_bat.sendCommand(heat_SetP_bat.historicState(time_started).state)
		heat_swi_OpMo_liv.sendCommand(heat_swi_OpMo_liv.historicState(time_started).state)
		heat_swi_OpMo_bed.sendCommand(heat_swi_OpMo_bed.historicState(time_started).state)
		heat_swi_OpMo_bat.sendCommand(heat_swi_OpMo_bat.historicState(time_started).state)
		}
end

Sitemap

Damit die Heizungssteuerung noch gut bediehnt werden kann benötigen wir noch eine Sitemap. Da das sehr individuell aussehen kann hier nur als Orientierung, wie so eine Sitemap aussehen kann:

sitemap heizung label="Heizung"
{
	
	Frame			label="Allgemein"
	{
		Switch		item=heat_swi_all_off				label="Heizung aktivieren:"			
		Text		item=G_Temperatur				label="Wohnungstemp.: [%.1f °C]"							valuecolor=[>30="red",>25="orange",>20="lime",>15="yellow",<=15="aqua"]
		Switch		item=heat_swi_3h_warm				label="3h 'warm':"
		Switch		item=heat_swi_1h_hot				label="1h 'heiß':"
	}
	Frame			label="Räume"
	{		
		Group			item=G_SetP_liv				label="Wohnzimmer [(%.1f °C)]"		
			{
			Text		item=contact_sensor_WZ_window		label="Fenster: [MAP(de.map):%s]"	valuecolor=[OPEN="orange",CLOSED="lime"]
			Text		item=temp_sensor_WZ_window		label="Temp. Fenster: [%.1f °C]"	valuecolor=[>30="red",>25="orange",>20="lime",>15="yellow",<=15="aqua"]
			Switch		item=heat_swi_OpMo_liv			label="Betriebsart:"				mappings=[OFF='HAND', ON='AUTM']						visibility=[heat_swi_all_off == ON]	
			Switch	 	item=heat_SetP_liv			label="Heizung:" 					mappings=[4='aus', 18='eco', 22='warm', 26='hot']		visibility=[heat_on_man_liv == ON]			
			}
		
	}	
	
	Frame 			label="Wohnzimmer" 
	{
		Switch		item=heat_swi_OpMo_liv				label="Betriebsart:"				mappings=[OFF='HAND', ON='AUTM']						visibility=[heat_swi_all_off == ON]	
		Selection 	item=heat_SetP_liv				label="Heizung:" 					mappings=[4='aus', 18='eco', 22='warm', 26='hot']		visibility=[heat_on_man_liv == ON]	
	}	
	
}

So das soll es erstmal zum Thema Heizungssteuerung gewesen sein. Ich hoffe an der ein oder anderen Stelle für etwas Inspiration und Anregung gesort zu haben.

Diese Konfiguration hat leider nur ein großen defizit, die Zeiten der Heizphasen lassen sich nur im Code der entsprechenden Regel ändern, was nicht für jeden Nutzer praktikabel ist. Daher werde ich im nächsten Artikel erläutern, wie man ein Heizplan anhand einer CalDav Anbindung realisiert.