automatische Heizregeln mit OpenHAB und semantischen Gruppen

const { rules, triggers, items, actions, time } = require('openhab');

// --- Globale Konstanten & Variablen ---
const FALLBACK_TEMP = 16.0;
const FROSTSAVE_TEMP = 8.0;
const DECALC_TEMP = 40.0;

// Map zum Speichern der Sollwerte (um doppelte Befehle zu vermeiden)
// Key: ItemName, Value: String (z.B. "20 °C")
let setpointsMap = new Map();

/**
 * it is possible, that the signal gets lost. So try it again, till the not commanded item reacts to a change
 * yes, i could set the "noautoupdate"-option. But alexa then will answer wrong temperature, when i ask... so: duplicate item
 */
function setRadiator(radiatorItem, setpointStr) {
	// when setpoint is changed, send it multiple times because sometimes the zigbee-signal gets lost
	const igName = radiatorItem.groupNames.find(g => g.startsWith("ig"));
	if (!igName) return;

	const igItem = items.getItem(igName);

	const setpointROitem = igItem.members.find(i => i.tags.includes("Measurement") && i.tags.includes("SetpointRO"));
	const valveStateitem = igItem.members.find(i => i.tags.includes("Measurement") && i.tags.includes("ValveState"));

	// Prüfen: Wenn es eine Entkalkung ist ODER sich das Ventil in den letzten 10 Tagen nicht bewegt hat
	const valveChangedRecently = valveStateitem.persistence.changedSince(time.toZDT().minusDays(10));

	// if this is a regular setpoint or a necessary decalcification: do it
	if (setpointStr !== DECALC_TEMP || !valveChangedRecently) {
		setpointsMap.set(radiatorItem.name, setpointStr);

		// Initialer Versuch
		startRetryLoop(radiatorItem, setpointROitem, setpointStr, 2000, 0);
	}
}

/**
 * Rekursive Funktion für das wiederholte Senden (ersetzt die Thread::sleep Schleife)
 */
function startRetryLoop(radiator, checkItem, targetVal, delayMs, attempt) {
	// Wenn wir 10 Versuche durch haben, abbrechen
	if (attempt >= 10) return;

	// Aktuellen Status prüfen
	const currentVal = checkItem.state; // String status
	const targetStored = setpointsMap.get(radiator.name);

	if (currentVal !== "NULL" && currentVal !== "UNDEF" && targetStored === targetVal) {
		if (checkItem.quantityState && checkItem.quantityState.toUnit("°C").float == targetVal) {
			return; // Erfolg, aufhören.
		}
	} else if (targetStored !== targetVal) {
		return; // Ziel hat sich geändert, diese Loop ist veraltet.
	}

	radiator.sendCommand(targetVal);

	// Timer für nächsten Versuch (Exponential Backoff)
	actions.ScriptExecution.createTimer(time.toZDT(delayMs), () => {
		startRetryLoop(radiator, checkItem, targetVal, delayMs * 2, attempt + 1);
	});
}

// --- Regel 1: Start Decalcification ---
rules.JSRule({
	name: "start decalcification",
	description: "Startet Entkalkungsfahrt am Montag um 11:00",
	triggers: [triggers.GenericCronTrigger("0 0 11 ? * MON *")],
	execute: () => {
		items.getItem("siDecalcification").sendCommand("ON");
	}
});

// --- Regel 2: Stop Decalcification ---
rules.JSRule({
	name: "ensure to stop decalcification",
	triggers: [
		triggers.GenericCronTrigger("0 0/2 11 ? * MON *"),
		triggers.GenericCronTrigger("0 0 * ? * MON *"),
		triggers.GenericCronTrigger("0 0 12 ? * * *")
	],
	execute: () => {
		const siDecalc = items.getItem("siDecalcification");
		if (siDecalc.state === "ON") {
			siDecalc.sendCommand("OFF");
		}
	}
});

// --- Regel 3: Thermostat Calibration ---
rules.JSRule({
  name: "set thermostat temperature_calibration based on room thermostat",
  triggers: [triggers.GenericCronTrigger("0 0/12 * ? * * *")],
  execute: () => {
    // Alle Raumthermostate holen
    const roomThermostats = items.getItems().filter(i => i.tags.includes("Measurement") && i.tags.includes("Temperature"));

    roomThermostats.forEach(roomSensor => {
      // ItemGroup (ig) finden
      const igName = roomSensor.groupNames.find(g => g.startsWith("ig"));
      if (!igName) return;

      const igRoomThermostat = items.getItem(igName);
      
      // Hat sich Raumtemperatur in den letzten 15 min geändert?
      const roomChanged = roomSensor.persistence.changedSince(time.toZDT().minusMinutes(15));

      // SemanticGroup (sg) finden
      const sgName = igRoomThermostat.groupNames.find(g => g.startsWith("sg"));
      if (!sgName) return;

      // Im JS Script iterieren wir über die Liste (im Original war es newArrayList(sgName))
      const room = items.getItem(sgName);
      
      // Radiator Controls im Raum finden
      const radiatorControls = room.members.filter(m => m.tags.includes("RadiatorControl"));

      radiatorControls.forEach(radControl => {
        const radSensor = radControl.members.find(m => m.tags.includes("Measurement") && m.tags.includes("TempThermostat"));
        const currentCalItem = radControl.members.find(m => m.tags.includes("Setpoint") && m.tags.includes("Calibration"));

        if (radSensor && currentCalItem) {
            // Berechnungen mit Quantity Types
            // Wir nutzen hier .quantityState, das gibt ein Quantity-Objekt zurück, mit dem man rechnen kann.
            const roomVal = roomSensor.quantityState.toUnit("°C").float;
            const radVal = radSensor.quantityState.toUnit("°C").float;
            const curCalVal = currentCalItem.quantityState.toUnit("°C").float;

            // Formel: radiator_measurement = radiator_temp_value - current_calibration_value
            const radMeasurement = radVal - curCalVal;
            // Formel: target_calibration_value = room_temp_value - radiator_measurement
            const targetCalVal = roomVal - radMeasurement;
            
            const calDiff = curCalVal - targetCalVal;

            if (roomChanged) {
                if (Math.abs(calDiff) > 1.0) {
                    // Neuen Wert setzen (als Number/Int senden, wie im Original)
                    currentCalItem.sendCommand(targetCalVal); 
                }
            } else {
                // Fallback Logic (Durchschnitte)
                let avgCal = currentCalItem.persistence.averageSince(time.toZDT().minusHours(48)).numericState;
                if (avgCal === null) avgCal = currentCalItem.persistence.averageSince(time.toZDT().minusHours(24)).numericState;
                if (avgCal === null) avgCal = currentCalItem.persistence.averageSince(time.toZDT().minusHours(6)).numericState;
                
                
                let targetAvg = 0;
                if(avgCal !== null) targetAvg = avgCal;

                // Differenz prüfen (Manuell, da avgCal oft nur number ist)
                // Wir holen den aktuellen Wert als float
                const currentFloat = curCalVal.toUnit("°C").float;
                const diffAvg = Math.abs(currentFloat - targetAvg);

                if (diffAvg > 1) {
                    console.log(`Calibration Fallback: ${radControl.name} -> ${targetAvg}`);
                    currentCalItem.sendCommand(targetAvg);
                }
            }
        } else {
            console.warn(`Calibration Item oder Sensor fehlt für: ${radControl.name}`);
        }
      });
    });
  }
});


// --- Regel 4: Heating Logic ---
rules.JSRule({
	name: "heating",
	description: "Hauptheizungslogik basierend auf Events",
	triggers: [
		triggers.GroupStateChangeTrigger("tgHeatingEvents"),
		triggers.GroupStateChangeTrigger("tgWindow"),
		triggers.GroupStateChangeTrigger("tgHausAus"),
		triggers.GroupStateChangeTrigger("tgWatchdogEvents")
	],
	execute: (event) => {
		const triggeringItem = items.getItem(event.itemName);
		const triggerName = triggeringItem.name;
		const newState = event.newState; // String state

		// 1. Haus Aus Knopf?
		const hausAusKnopf = (triggerName === "SmartButton1_DimmerSwitch" || triggerName === "SmartButton1_manual");

		// 2. Betroffene Räume finden
		let roomList = [];

		if (hausAusKnopf) {
			// WatchdogAffected ohne Bedroom
			roomList = items.getItemsByTag("WatchdogAffected")
							.filter(i => !i.tags.includes("Bedroom"));
		} else if (triggerName === "WatchdogManual") {
			// Alle WatchdogAffected
			roomList = items.getItemsByTag("WatchdogAffected");
		} else {
			// Logik um Raum über Gruppen zu finden
			const igName = triggeringItem.groupNames.find(g => g.startsWith("ig"));
			let sgNames = [];

			if (igName) {
				const igItem = items.getItem(igName);
				sgNames = igItem.groupNames.filter(g => g.startsWith("sg"));
			} else {
				sgNames = triggeringItem.groupNames.filter(g => g.startsWith("sg"));
			}
			
			roomList = sgNames.map(name => items.getItem(name));
		}

		// 3. Global "All Off" Bedingungen prüfen
		const watchdogManual = items.getItem("WatchdogManual");
		const presence = items.getItem("KalenderWatchdog_CurrentEventPresence");
		const titleS = items.getItem("KalenderWatchdog_CurrentEventTitleS");
		const maxTemp = items.getItem("siFC_MAX_Temp");

		let all_off = false;
		
		// Check Watchdog
		if (watchdogManual.state === "ON") all_off = true;
		
		// Check Calendar
		if (presence.state === "ON" && titleS.state !== "nightly") all_off = true;

		// Check Temperature (Vergleich Quantity)
		if (maxTemp.quantityState && maxTemp.quantityState.toUnit("°C").float > 22.0) all_off = true;


		// 4. Räume durchgehen
		roomList.forEach(room => {
			// Fenster Status prüfen
			let windowOpen = false;
			// Filtern nach Tags Window, FrontDoor, BackDoor
			const windowSensors = room.members.filter(m => m.tags.includes("Window") || m.tags.includes("FrontDoor") || m.tags.includes("BackDoor"));
			
			windowSensors.forEach(sensor => {
				// Prüfung: State != NULL und Wert > 0 (für Contact oft OPEN/CLOSED, hier Logik aus DSL übernommen -> number check)
				// DSL: (thing.state as Number).intValue > 0. 
				// Bei ContactItem ist OPEN=OpenClosedType.OPEN. Wenn es NumberItems sind (Dimmer/Rollershutter als Fenster?):
				if (sensor.state !== "NULL" && sensor.state !== "UNDEF") {
					if (sensor.type === "Contact" && sensor.state === "OPEN") windowOpen = true;
					else if (sensor.numericState > 0) windowOpen = true; 
				}
			});

			// Kalender Setpoint prüfen
			let calendarSetpoint = "0 °C"; // String als Quantity Ersatz
			// Suche WebService -> HeatingProfile
			const heatingProfiles = room.members.filter(m => m.tags.includes("WebService") && m.tags.includes("HeatingProfile"));
			heatingProfiles.forEach(gItem => {
				const setpointItems = gItem.members.filter(i => i.tags.includes("Setpoint") && i.tags.includes("Temperature"));
				setpointItems.forEach(item => {
					if (item.state !== "UNDEF") {
						// Prüfen ob >= Frostschutz (Quantity Vergleich)
						if (item.quantityState && item.quantityState.toUnit("°C").float >= FROSTSAVE_TEMP) {
							calendarSetpoint = item.state;
						} else {
							calendarSetpoint = FALLBACK_TEMP;
						}
					}
				});
			});

			// Gäste Anwesenheit
			const guestPresenceItem = room.members.find(m => m.tags.includes("GuestPresence"));
			
			// Heizkörper steuern
			const radiatorControls = room.members.filter(m => m.tags.includes("RadiatorControl"));
			
			radiatorControls.forEach(gItem => {
				const radiators = gItem.members.filter(r => r.tags.includes("Setpoint") && r.tags.includes("Temperature"));
				
				radiators.forEach(radiator => {
					// Entscheidungshierarchie
					
					if (windowOpen) {
						setRadiator(radiator, FROSTSAVE_TEMP);
					}
					else if (triggerName === "siDecalcification" && newState === "ON") {
						setRadiator(radiator, DECALC_TEMP);
					}
					else if (guestPresenceItem && guestPresenceItem.state === "OFF") {
						setRadiator(radiator, FROSTSAVE_TEMP);
					}
					else if (all_off) {
						setRadiator(radiator, FROSTSAVE_TEMP);
					}
					else if (hausAusKnopf) {
						// Prüfen ob aktueller Wert größer als Fallback ist
						if (radiator.quantityState && radiator.quantityState.toUnit("°C").float > FALLBACK_TEMP) {
							setRadiator(radiator, FALLBACK_TEMP);
						}
					}
					else if (items.getItem("siDecalcification").state === "ON") { 
					   // Edge case: Wenn Decalcification läuft, aber Regel durch anderen Trigger aufgerufen wurde
					   // Im Originalcode nicht explizit drin, aber durch "newState == ON" oben abgedeckt.
					   // Hier ignorieren wir es, falls nicht explizit getriggert.
					}
					else {
						// Kalender oder Fallback
						// Wir müssen Quantity Strings vergleichen
						const calQty = (calendarSetpoint === "0 °C") ? 0 : 1; // Vereinfacht

						if (calQty > 0) { // Eigentlich: if calendarSetpoint > 0°C
							 setRadiator(radiator, calendarSetpoint);
						}
						else {
							// Default Check
							 if (radiator.quantityState && radiator.quantityState.toUnit("°C").float > FALLBACK_TEMP) {
								 setRadiator(radiator, FALLBACK_TEMP);
							 }
						}
					}
				});
			});

		});
	}
});