iobroker.poolcontrol 0.8.2 → 0.9.0

package/README.md

@@ -35,6 +35,29 @@ Er ermöglicht die Automatisierung von Pumpen-, Temperatur- und Solarsteuerung s
   - Kollektor-Warnung (mit automatischer Rücksetzung bei 10 % unter der Schwelle)
   - Optionale Sprachausgabe bei Warnung
 
+- **Heizungs- / Wärmepumpensteuerung (neu, Testphase)**
+  - Automatische Steuerung von Heizstab oder Wärmepumpe auf Basis der Pooltemperatur
+  - Zieltemperatur und maximale Sicherheitstemperatur konfigurierbar
+  - Aktiv nur bei:
+    - aktiver Poolsaison
+    - Pumpenmodus **Automatik**
+    - nicht aktivem Wartungsmodus
+  - Vorranglogik:
+    - Wartungsmodus blockiert die Heizungssteuerung vollständig
+    - Heizung greift nicht in manuelle oder zeitgesteuerte Pumpenmodi ein
+  - Pumpen-Nachlaufzeit nach Heizende konfigurierbar
+  - Ownership-Schutz:
+    - Die Pumpe wird nur dann ausgeschaltet, wenn sie zuvor vom heatHelper selbst eingeschaltet wurde
+  - Unterstützt:
+    - schaltbare Steckdosen **oder**
+    - boolesche Steuer-States externer Heizungen
+  - Interner Status- und Diagnosebereich unter `heat.*`
+  - Rein steuernd, **keine Chemie- oder Solarlogik**
+  
+  **Hinweis:**  
+  Diese Funktion befindet sich aktuell in einer **Testphase**.  
+  Die Logik ist vollständig implementiert, sollte aber zunächst nur mit interessierten Test-Usern eingesetzt werden.
+
 - **Photovoltaiksteuerung (seit v0.6.0)**
   - Automatische Pumpensteuerung auf Basis von PV-Erzeugung und Hausverbrauchs
   - Einschaltlogik: Überschuss ≥ (Pumpen-Nennleistung + Sicherheitsaufschlag)
@@ -151,8 +174,6 @@ Die Konfiguration erfolgt über Tabs im Admin-Interface:
 - Erweiterte PV- und Solar-Effizienzanalyse (COP-Berechnung, Tagesnutzen, Wetterintegration)
 - Statistik-Exportfunktion (CSV/Excel)
 - Diagnostic-Helper zur automatischen Systemprüfung
-- Erweiterung der Heizungs-/Wärmepumpenlogik (`heatHelper`)
-- Zweite Pumpe (z. B. Wärmetauscher oder Wärmepumpe)
 - Eigene Widgets für VIS/VIS2 (grafische Pool- und Solarvisualisierung)
 - Steuerung von Poolbeleuchtung, Ventilen und Gegenstromanlagen
 - Integration zusätzlicher Sensorboxen (z. B. TempBox, PressureBox, LevelBox)
@@ -176,6 +197,22 @@ Neue Funktionen werden regelmäßig ergänzt – bitte den Changelog beachten.
 ## Changelog
 ### **WORK IN PROGRESS**
 
+## v0.9.0 (WORK IN PROGRESS)
+- Einführung der Heizungs- / Wärmepumpensteuerung (`heatHelper`)
+- Automatische Heizanforderung basierend auf Pooltemperatur
+- Ziel- und Maximaltemperatur konfigurierbar
+- Unterstützung von:
+  - schaltbaren Steckdosen
+  - booleschen Steuer-States
+- Pumpen-Nachlaufzeit nach Heizende
+- Vorrangsystem:
+  - Wartungsmodus blockiert Heizungssteuerung
+  - Aktiv nur im Automatikmodus
+  - Berücksichtigung des Saisonstatus
+- Ownership-Schutz für Pumpensteuerung
+- Neuer interner State `heat.heating_request` für externe Auswertung
+
+
 ## v0.8.2 (2025-12-25)
 - Neues KI-Modul **Chemie-Hilfe** (`aiChemistryHelpHelper`)
 - Rein informatives Hilfesystem zur Poolwasserchemie
@@ -242,17 +279,8 @@ Neue Funktionen werden regelmäßig ergänzt – bitte den Changelog beachten.
 - Telegram-Benutzerwahl hinzugefügt
 
 ## v0.5.2 (2025-10-30)
-- Erweitertes Helper-Vorrangssystem: Konflikte zwischen Zeit- und Solarsteuerung behoben
-- Frostschutz pausiert während Zeitfenster. Nun stabiles Pumpenverhalten und Verbesserte
-  Koordination zwischen den Helpern
 
 ## v0.5.0 (2025-10-28)
-- Erweiterung der Temperaturstatistik um Wochen- und Monatsauswertung  
-  (`analytics.statistics.temperature.week` / `.month`)
-- Eigenständige, eventbasierte Helper für Woche und Monat
-- Persistente Datenpunkte mit automatischen JSON- und HTML-Zusammenfassungen
-- Vorbereitung für zukünftige Erweiterungen (Saison- und Jahresstatistik)
-
 
 ### **0.4.0 (26.10.2025)**
 

package/admin/jsonConfig.json

@@ -421,7 +421,7 @@
     },
     "solar": {
       "type": "panel",
-      "label": "Solarverwaltung",
+      "label": "Solar/Heizungsverwaltung",
       "items": {
         "solar_control_active_header": {
           "type": "header",
@@ -539,7 +539,91 @@
           "md": 12,
           "lg": 12,
           "xl": 12
-		}
+		},
+        "heat_control_header": {
+          "type": "header",
+          "text": "Heizung / Wärmepumpe",
+          "size": 4,
+          "newLine": true,
+          "xs": 12,
+          "sm": 12,
+          "md": 12,
+          "lg": 12,
+          "xl": 12
+        },
+
+        "heat_control_active": {
+          "type": "checkbox",
+          "label": "Heizungssteuerung aktivieren",
+          "default": false,
+          "xs": 12,
+          "sm": 3,
+          "md": 3,
+          "lg": 3,
+          "xl": 3,
+          "newLine": true
+        },
+
+        "heat_control_type": {
+          "type": "select",
+          "label": "Art der Heizungssteuerung",
+          "options": [
+            { "label": "Messsteckdose schalten (Ein / Aus)", "value": "socket" },
+            { "label": "Logischer Steuer-State (true / false)", "value": "boolean" }
+          ],
+          "default": "socket",
+          "xs": 12,
+          "sm": 4,
+          "md": 4,
+          "lg": 4,
+          "xl": 4,
+          "newLine": true
+        },
+
+        "heat_control_object_id": {
+          "type": "objectId",
+          "label": "Objekt-ID Heizung / Wärmepumpe",
+          "default": "",
+          "xs": 12,
+          "sm": 6,
+          "md": 6,
+          "lg": 6,
+          "xl": 6
+        },
+
+        "heat_temp_target": {
+          "type": "number",
+          "label": "Zieltemperatur Pool (°C)",
+          "default": 26,
+          "xs": 12,
+          "sm": 3,
+          "md": 3,
+          "lg": 3,
+          "xl": 3,
+          "newLine": true
+        },
+
+        "heat_temp_max": {
+          "type": "number",
+          "label": "Maximale Pooltemperatur (°C – Sicherheitsabschaltung)",
+          "default": 30,
+          "xs": 12,
+          "sm": 3,
+          "md": 3,
+          "lg": 3,
+          "xl": 3
+        },
+
+        "heat_control_hint": {
+          "type": "staticText",
+          "text": "Hinweis: Die Heizungssteuerung arbeitet temperaturgeführt und nur, wenn die Poolsaison aktiv ist. Je nach ausgewählter Steuerungsart wird entweder eine Messsteckdose geschaltet oder ein logischer Steuer-State (true/false) gesetzt.",
+          "newLine": true,
+          "xs": 12,
+          "sm": 12,
+          "md": 12,
+          "lg": 12,
+          "xl": 12
+        }
       }
     },
     "timecontrol": {

package/io-package.json

@@ -1,8 +1,21 @@
 {
   "common": {
     "name": "poolcontrol",
-    "version": "0.8.2",
+    "version": "0.9.0",
     "news": {
+       "0.9.0": {
+         "en": "New heating / heat pump control (heatHelper). Automatic control based on pool temperature with configurable target and maximum temperature, pump after-run time, and full priority handling (e.g. maintenance mode). Works only in automatic pump mode and respects season status. Supports both switchable sockets and boolean control states. Includes ownership protection to avoid interfering with other pump controllers.",
+         "de": "Neue Heizungs- / Wärmepumpensteuerung (heatHelper). Automatische Regelung basierend auf der Pooltemperatur mit konfigurierbarer Ziel- und Maximaltemperatur, Pumpen-Nachlaufzeit sowie vollständiger Vorranglogik (z. B. Wartungsmodus). Arbeitet ausschließlich im Automatikmodus der Pumpe und berücksichtigt den Saisonstatus. Unterstützt schaltbare Steckdosen und boolesche Steuer-States. Enthält Ownership-Schutz, um Konflikte mit anderen Pumpensteuerungen zu vermeiden.",
+         "ru": "Новая система управления отоплением / тепловым насосом (heatHelper). Автоматическое управление на основе температуры воды с настраиваемой целевой и максимальной температурой, временем добега насоса и полной системой приоритетов (например, режим обслуживания). Работает только в автоматическом режиме насоса и учитывает сезонный статус. Поддерживает как переключаемые розетки, так и булевы управляющие состояния. Включает защиту владения для предотвращения конфликтов с другими контроллерами насоса.",
+         "pt": "Novo controlo de aquecimento / bomba de calor (heatHelper). Controlo automático baseado na temperatura da piscina com temperatura alvo e máxima configuráveis, tempo de pós-funcionamento da bomba e lógica completa de prioridades (por exemplo, modo de manutenção). Funciona apenas no modo automático da bomba e respeita o estado da época. Suporta tomadas comutáveis e estados de controlo booleanos. Inclui proteção de propriedade para evitar conflitos com outros controladores da bomba.",
+         "nl": "Nieuwe verwarmings- / warmtepompregeling (heatHelper). Automatische regeling op basis van de zwembadtemperatuur met instelbare doel- en maximumtemperatuur, pomp-nalooptijd en volledige prioriteitslogica (bijv. onderhoudsmodus). Werkt uitsluitend in de automatische pompmodus en houdt rekening met de seizoensstatus. Ondersteunt zowel schakelbare stopcontacten als booleaanse besturingsstates. Bevat eigendomsbescherming om conflicten met andere pompcontrollers te voorkomen.",
+         "fr": "Nouveau contrôle de chauffage / pompe à chaleur (heatHelper). Régulation automatique basée sur la température de la piscine avec températures cible et maximale configurables, temps de post-fonctionnement de la pompe et gestion complète des priorités (par ex. mode maintenance). Fonctionne uniquement en mode automatique de la pompe et respecte le statut de saison. Prend en charge les prises commutables et les états de commande booléens. Inclut une protection de propriété afin d’éviter les conflits avec d’autres contrôleurs de pompe.",
+         "it": "Nuovo controllo di riscaldamento / pompa di calore (heatHelper). Controllo automatico basato sulla temperatura della piscina con temperatura obiettivo e massima configurabili, tempo di post-funzionamento della pompa e gestione completa delle priorità (ad es. modalità manutenzione). Funziona solo in modalità automatica della pompa e tiene conto dello stato stagionale. Supporta prese commutabili e stati di controllo booleani. Include una protezione di proprietà per evitare conflitti con altri controllori della pompa.",
+         "es": "Nuevo control de calefacción / bomba de calor (heatHelper). Control automático basado en la temperatura de la piscina con temperatura objetivo y máxima configurables, tiempo de posfuncionamiento de la bomba y gestión completa de prioridades (p. ej., modo de mantenimiento). Funciona únicamente en modo automático de la bomba y respeta el estado de la temporada. Compatible con enchufes conmutables y estados de control booleanos. Incluye protección de propiedad para evitar conflictos con otros controladores de la bomba.",
+         "pl": "Nowy system sterowania ogrzewaniem / pompą ciepła (heatHelper). Automatyczne sterowanie na podstawie temperatury basenu z konfigurowalną temperaturą docelową i maksymalną, czasem dobiegu pompy oraz pełną obsługą priorytetów (np. tryb konserwacji). Działa wyłącznie w trybie automatycznym pompy i uwzględnia status sezonu. Obsługuje przełączalne gniazda oraz binarne stany sterujące. Zawiera ochronę własności, aby zapobiec konfliktom z innymi kontrolerami pompy.",
+         "uk": "Нова система керування опаленням / тепловим насосом (heatHelper). Автоматичне керування на основі температури басейну з налаштовуваною цільовою та максимальною температурою, часом післяроботи насоса та повною системою пріоритетів (наприклад, режим обслуговування). Працює лише в автоматичному режимі насоса та враховує сезонний статус. Підтримує комутовані розетки та булеві стани керування. Містить захист володіння для запобігання конфліктам з іншими контролерами насоса.",
+         "zh-cn": "新增加热 / 热泵控制功能（heatHelper）。基于泳池水温的自动控制，支持可配置的目标温度和最高温度、泵后运行时间以及完整的优先级处理（例如维护模式）。仅在泵的自动模式下工作，并考虑季节状态。支持可开关插座和布尔控制状态。包含所有权保护机制，避免与其他泵控制逻辑发生冲突。"
+       },
        "0.8.2": {
          "en": "New AI chemistry help module. Provides an interactive, purely informational help system for common pool water issues (e.g. pH too high/low, chlorine ineffective, green or cloudy water). Generates understandable explanations and solution directions without automatic dosing, product recommendations, device control or speech output.",
          "de": "Neues KI-Chemie-Hilfesystem. Bietet eine interaktive, rein informative Unterstützung bei typischen Poolwasserproblemen (z. B. pH zu hoch/niedrig, Chlor wirkt nicht, grünes oder trübes Wasser). Erzeugt verständliche Ursachen- und Lösungshinweise ohne automatische Dosierung, Produktempfehlungen, Geräte­steuerung oder Sprachausgabe.",
@@ -80,19 +93,6 @@
          "pl": "Dodano nowy system informacji: adapter zapisuje teraz sezonowe pozdrowienia oraz zainstalowaną wersję adaptera w stanach info.*. Zawiera automatyczne codzienne odświeżanie o 00:01 oraz pełne wyliczenie daty Wielkanocy.",
          "uk": "Додано нову інформаційну систему: адаптер тепер записує сезонні привітання та встановлену версію адаптера в стани info.*. Містить щоденне автоматичне оновлення о 00:01 і повний розрахунок дати Великодня.",
          "zh-cn": "新增信息系统：适配器现在会将季节性问候和已安装的适配器版本写入 info.* 状态。包括每天 00:01 的自动刷新和完整的复活节日期计算。"
-       },
-       "0.7.1": {
-         "en": "Fix for pressure sensor initialization: The adapter now correctly recognizes the configured sensor ID in pumpHelper4. Additionally improved handling of missing / invalid values.",
-         "de": "Fehlerbehebung bei der Drucksensor-Initialisierung: Der Adapter erkennt nun die konfigurierte Sensor-ID in pumpHelper4 korrekt. Außerdem wurde die Verarbeitung fehlender oder ungültiger Werte verbessert.",
-         "ru": "Исправление инициализации датчика давления: адаптер теперь корректно распознаёт настроенный идентификатор датчика в pumpHelper4. Улучшена обработка отсутствующих и недопустимых значений.",
-         "pt": "Correção na inicialização do sensor de pressão: o adaptador agora reconhece corretamente o ID configurado do sensor em pumpHelper4. Manipulação aprimorada de valores ausentes ou inválidos.",
-         "nl": "Foutoplossing voor de druksensor-initialisatie: de adapter herkent nu correct de geconfigureerde sensor-ID in pumpHelper4. Verbeterde verwerking van ontbrekende of ongeldige waarden.",
-         "fr": "Correction de l'initialisation du capteur de pression : l'adaptateur reconnaît désormais correctement l'ID du capteur configuré dans pumpHelper4. Amélioration du traitement des valeurs manquantes ou invalides.",
-         "it": "Correzione dell'inizializzazione del sensore di pressione: l'adattatore ora riconosce correttamente l'ID configurato del sensore in pumpHelper4. Migliorata anche la gestione dei valori mancanti o non validi.",
-         "es": "Corrección en la inicialización del sensor de presión: el adaptador ahora reconoce correctamente la ID del sensor configurado en pumpHelper4. Manejo mejorado de valores faltantes o inválidos.",
-         "pl": "Poprawka inicjalizacji czujnika ciśnienia: adapter poprawnie rozpoznaje teraz skonfigurowany identyfikator czujnika w pumpHelper4. Ulepszono również obsługę brakujących lub nieprawidłowych wartości.",
-         "uk": "Виправлення ініціалізації датчика тиску: адаптер тепер правильно розпізнає налаштований ID датчика в pumpHelper4. Покращено обробку відсутніх або некоректних значень.",
-         "zh-cn": "修复压力传感器初始化：适配器现在可以正确识别 pumpHelper4 中配置的传感器 ID，并改进了对缺失或无效数值的处理。"
        }
 	},
     "titleLang": {

package/lib/helpers/heatHelper.js

@@ -0,0 +1,450 @@
+'use strict';
+
+/**
+ * heatHelper
+ * -------------------------------------------------------------
+ * - Steuert Heizung/Wärmepumpe basierend auf Pooltemperatur
+ * - Respektiert:
+ *   - status.season_active
+ *   - control.pump.maintenance_active (Vorrang / Block)
+ *   - pump.mode (nur im Automatikbetrieb)
+ * - Kann entweder:
+ *   - eine schaltbare Steckdose (socket) oder
+ *   - einen bool Steuer-State (boolean) bedienen
+ * - Erzeugt zusätzlich ein internes Signal:
+ *   - heat.heating_request (read-only) => kann extern ausgewertet werden
+ * - Pumpen-Nachlaufzeit (min) wird berücksichtigt
+ * - Ownership-Schutz: Pumpe wird nur ausgeschaltet, wenn heatHelper sie vorher selbst eingeschaltet hat
+ * -------------------------------------------------------------
+ */
+
+const heatHelper = {
+    adapter: null,
+
+    // dynamische Steuer-ID (foreign)
+    _heatControlForeignId: '',
+    _afterrunTimer: null,
+
+    // Ownership / Merker
+    _ownsPump: false,
+    _desiredHeat: null,
+    _lastEval: 0,
+
+    init(adapter) {
+        this.adapter = adapter;
+
+        // lokale States überwachen
+        this.adapter.subscribeStates('heat.control_active');
+        this.adapter.subscribeStates('heat.control_type');
+        this.adapter.subscribeStates('heat.control_object_id');
+        this.adapter.subscribeStates('heat.target_temperature');
+        this.adapter.subscribeStates('heat.max_temperature');
+        this.adapter.subscribeStates('heat.pump_afterrun_minutes');
+
+        // Abhängigkeiten
+        this.adapter.subscribeStates('status.season_active');
+        this.adapter.subscribeStates('pump.mode');
+        this.adapter.subscribeStates('pump.pump_switch');
+        this.adapter.subscribeStates('temperature.surface.current');
+
+        // Vorrangschaltung / Wartung
+        this.adapter.subscribeStates('control.pump.maintenance_active');
+
+        // ggf. vorhandene Foreign-ID abonnieren
+        this._refreshForeignSubscription().catch(err =>
+            this.adapter.log.warn(`[heatHelper] Foreign-Subscription Fehler: ${err.message}`),
+        );
+
+        this._safeEvaluate('init');
+        this.adapter.log.info('[heatHelper] Initialisierung abgeschlossen.');
+    },
+
+    async handleStateChange(id, state) {
+        if (!state) {
+            return;
+        }
+
+        try {
+            // Wenn die Ziel-Objekt-ID geändert wurde: Foreign subscription anpassen
+            if (id.endsWith('heat.control_object_id') || id.endsWith('heat.control_type')) {
+                await this._refreshForeignSubscription();
+                await this._safeEvaluate('control_target_changed');
+                return;
+            }
+
+            // Alles andere: neu bewerten
+            if (
+                id.endsWith('heat.control_active') ||
+                id.endsWith('heat.target_temperature') ||
+                id.endsWith('heat.max_temperature') ||
+                id.endsWith('heat.pump_afterrun_minutes') ||
+                id.endsWith('status.season_active') ||
+                id.endsWith('pump.mode') ||
+                id.endsWith('temperature.surface.current') ||
+                id.endsWith('control.pump.maintenance_active')
+            ) {
+                await this._safeEvaluate('state_change');
+                return;
+            }
+
+            // Wenn jemand die Pumpe extern schaltet: Ownership ggf. zurücknehmen
+            if (id.endsWith('pump.pump_switch')) {
+                const pumpOn = !!state.val;
+                if (!pumpOn && this._ownsPump) {
+                    // wenn Pumpe aus geht obwohl wir "ownen", Ownership verlieren
+                    this._ownsPump = false;
+                }
+                await this._safeEvaluate('pump_switch_changed');
+                return;
+            }
+        } catch (err) {
+            this.adapter.log.warn(`[heatHelper] Fehler in handleStateChange: ${err.message}`);
+        }
+    },
+
+    // -------------------------------------------------------------
+    // Core
+    // -------------------------------------------------------------
+    async _evaluate(_sourceTag = '') {
+        const now = Date.now();
+        if (now - this._lastEval < 250) {
+            return;
+        }
+        this._lastEval = now;
+
+        const seasonActive = !!(await this.adapter.getStateAsync('status.season_active'))?.val;
+        const maintenanceActive = !!(await this.adapter.getStateAsync('control.pump.maintenance_active'))?.val;
+
+        const pumpMode = (await this.adapter.getStateAsync('pump.mode'))?.val || 'auto';
+        const heatEnabled = !!(await this.adapter.getStateAsync('heat.control_active'))?.val;
+
+        const poolTempRaw = (await this.adapter.getStateAsync('temperature.surface.current'))?.val;
+        const poolTemp = Number(poolTempRaw);
+
+        const targetTemp = Number((await this.adapter.getStateAsync('heat.target_temperature'))?.val ?? 26);
+        const maxTemp = Number((await this.adapter.getStateAsync('heat.max_temperature'))?.val ?? 30);
+
+        const afterrunMin = Math.max(
+            0,
+            Number((await this.adapter.getStateAsync('heat.pump_afterrun_minutes'))?.val ?? 0) || 0,
+        );
+
+        const controlType = (await this.adapter.getStateAsync('heat.control_type'))?.val || 'socket';
+        const controlObjectId = (await this.adapter.getStateAsync('heat.control_object_id'))?.val || '';
+
+        // --- Hard conditions / Blocker ---
+        if (!seasonActive) {
+            return this._applyBlockedState('season_inactive', 'Poolsaison ist inaktiv', afterrunMin);
+        }
+
+        // Vorrangschaltung: Wartung blockiert IMMER
+        if (maintenanceActive) {
+            return this._applyBlockedState(
+                'maintenance_active',
+                'Wartungsmodus aktiv (Control hat Vorrang)',
+                afterrunMin,
+            );
+        }
+
+        // Heizungssteuerung deaktiviert
+        if (!heatEnabled) {
+            return this._applyOffState('heat_disabled', 'Heizungssteuerung deaktiviert', afterrunMin);
+        }
+
+        // Pumpenmodus: nur Automatik
+        if (pumpMode !== 'auto') {
+            return this._applyBlockedState(
+                'mode_not_auto',
+                `Pumpenmodus ist '${pumpMode}' (Heizung arbeitet nur in Automatik)`,
+                afterrunMin,
+            );
+        }
+
+        // Sensor plausibel?
+        if (!Number.isFinite(poolTemp)) {
+            return this._applyBlockedState(
+                'no_pool_temp',
+                'Keine gültige Pooltemperatur (temperature.surface.current)',
+                afterrunMin,
+            );
+        }
+
+        // Sicherheitsabschaltung: MaxTemp überschritten
+        if (poolTemp >= maxTemp) {
+            return this._applyOffState(
+                'max_temp_reached',
+                `Max-Temperatur erreicht (${poolTemp.toFixed(1)} °C ≥ ${maxTemp} °C)`,
+                afterrunMin,
+            );
+        }
+
+        // --- Heating logic (simple hysteresis-free) ---
+        // Einschalten: unter Zieltemperatur
+        // Ausschalten: bei Zieltemperatur erreicht/überschritten
+        const shouldHeat = poolTemp < targetTemp;
+
+        if (shouldHeat) {
+            return this._startHeating({
+                reason: `Heizen: Pool ${poolTemp.toFixed(1)} °C < Ziel ${targetTemp} °C`,
+                controlType,
+                controlObjectId,
+            });
+        }
+
+        return this._stopHeating({
+            reason: `Ziel erreicht: Pool ${poolTemp.toFixed(1)} °C ≥ Ziel ${targetTemp} °C`,
+            controlType,
+            controlObjectId,
+            afterrunMin,
+        });
+    },
+
+    // -------------------------------------------------------------
+    // State transitions
+    // -------------------------------------------------------------
+    async _startHeating({ reason, controlType, controlObjectId }) {
+        if (this._desiredHeat === true) {
+            // nur Status/Reason ggf. aktualisieren
+            await this._setHeatStates({
+                active: true,
+                blocked: false,
+                mode: 'heating',
+                reason,
+                info: `control_type=${controlType}, target=${controlObjectId || '(leer)'}`,
+                heatingRequest: true,
+            });
+            return;
+        }
+
+        this._desiredHeat = true;
+
+        // Nachlauf ggf. abbrechen
+        if (this._afterrunTimer) {
+            clearTimeout(this._afterrunTimer);
+            this._afterrunTimer = null;
+        }
+
+        // Heizung einschalten (wenn ID gesetzt)
+        await this._setHeatingDevice(true, controlObjectId);
+
+        // Pumpe einschalten (ownership)
+        await this._ensurePumpOn();
+
+        await this._setHeatStates({
+            active: true,
+            blocked: false,
+            mode: 'heating',
+            reason,
+            info: `Heizung EIN | control_type=${controlType}`,
+            heatingRequest: true,
+        });
+
+        this.adapter.log.info(`[heatHelper] Heizung EIN (${reason})`);
+    },
+
+    async _stopHeating({ reason, controlType, controlObjectId, afterrunMin }) {
+        if (this._desiredHeat === false) {
+            // nur Status/Reason ggf. aktualisieren
+            await this._setHeatStates({
+                active: false,
+                blocked: false,
+                mode: 'off',
+                reason,
+                info: `control_type=${controlType}`,
+                heatingRequest: false,
+            });
+            return;
+        }
+
+        this._desiredHeat = false;
+
+        // Heizung aus
+        await this._setHeatingDevice(false, controlObjectId);
+
+        // Signal für andere Systeme
+        await this._setHeatStates({
+            active: false,
+            blocked: false,
+            mode: 'afterrun',
+            reason,
+            info: `Heizung AUS | Nachlauf=${afterrunMin} min | control_type=${controlType}`,
+            heatingRequest: false,
+        });
+
+        // Pumpen-Nachlauf nur, wenn wir die Pumpe eingeschaltet hatten
+        await this._startAfterrunIfNeeded(afterrunMin, reason);
+
+        this.adapter.log.info(`[heatHelper] Heizung AUS (${reason})`);
+    },
+
+    async _applyBlockedState(mode, reason, afterrunMin) {
+        // blockiert => Heizung aus, Request false
+        await this._setHeatingDevice(false, (await this.adapter.getStateAsync('heat.control_object_id'))?.val || '');
+
+        await this._setHeatStates({
+            active: false,
+            blocked: true,
+            mode,
+            reason,
+            info: 'Heizung blockiert',
+            heatingRequest: false,
+        });
+
+        // Nachlauf ggf. (nur wenn wir ownen)
+        await this._startAfterrunIfNeeded(afterrunMin, reason);
+    },
+
+    async _applyOffState(mode, reason, afterrunMin) {
+        // off => Heizung aus, Request false
+        await this._setHeatingDevice(false, (await this.adapter.getStateAsync('heat.control_object_id'))?.val || '');
+
+        await this._setHeatStates({
+            active: false,
+            blocked: false,
+            mode,
+            reason,
+            info: 'Heizung AUS',
+            heatingRequest: false,
+        });
+
+        await this._startAfterrunIfNeeded(afterrunMin, reason);
+    },
+
+    // -------------------------------------------------------------
+    // Pump handling (ownership protected)
+    // -------------------------------------------------------------
+    async _ensurePumpOn() {
+        try {
+            const pumpState = await this.adapter.getStateAsync('pump.pump_switch');
+            const isOn = !!pumpState?.val;
+
+            if (!isOn) {
+                // wir schalten sie ein => ownership true
+                this._ownsPump = true;
+                await this.adapter.setStateAsync('pump.pump_switch', { val: true, ack: false });
+                await this.adapter.setStateAsync('heat.afterrun_active', { val: false, ack: true });
+            }
+        } catch (err) {
+            this.adapter.log.warn(`[heatHelper] Konnte Pumpe nicht einschalten: ${err.message}`);
+        }
+    },
+
+    async _startAfterrunIfNeeded(afterrunMin, reason) {
+        // nur wenn wir die Pumpe vorher selbst eingeschaltet haben
+        if (!this._ownsPump) {
+            await this.adapter.setStateAsync('heat.afterrun_active', { val: false, ack: true });
+            return;
+        }
+
+        // wenn keine Nachlaufzeit: sofort aus
+        if (!afterrunMin || afterrunMin <= 0) {
+            await this._stopPumpNow('no_afterrun');
+            return;
+        }
+
+        // Timer neu starten
+        if (this._afterrunTimer) {
+            clearTimeout(this._afterrunTimer);
+            this._afterrunTimer = null;
+        }
+
+        await this.adapter.setStateAsync('heat.afterrun_active', { val: true, ack: true });
+
+        const holdMs = Math.round(afterrunMin * 60 * 1000);
+        this.adapter.log.debug(`[heatHelper] Pumpen-Nachlauf gestartet: ${afterrunMin} min (${reason})`);
+
+        this._afterrunTimer = setTimeout(async () => {
+            // Wenn inzwischen wieder Heizbedarf aktiv ist -> Nachlauf abbrechen
+            if (this._desiredHeat === true) {
+                this.adapter.log.debug('[heatHelper] Nachlauf abgebrochen – Heizen wieder aktiv.');
+                return;
+            }
+            await this._stopPumpNow('afterrun_done');
+        }, holdMs);
+    },
+
+    async _stopPumpNow(tag) {
+        try {
+            await this.adapter.setStateAsync('pump.pump_switch', { val: false, ack: false });
+        } catch (err) {
+            this.adapter.log.warn(`[heatHelper] Konnte Pumpe nicht ausschalten: ${err.message}`);
+        } finally {
+            this._ownsPump = false;
+            await this.adapter.setStateAsync('heat.afterrun_active', { val: false, ack: true });
+            this.adapter.log.info(`[heatHelper] Pumpe AUS (${tag})`);
+        }
+    },
+
+    // -------------------------------------------------------------
+    // Heating device control (foreign state)
+    // -------------------------------------------------------------
+    async _setHeatingDevice(on, foreignId) {
+        const id = String(foreignId || '').trim();
+        if (!id) {
+            // Kein Ziel => nur internes heating_request als Signal
+            return;
+        }
+
+        try {
+            await this.adapter.setForeignStateAsync(id, { val: !!on, ack: false });
+        } catch (err) {
+            this.adapter.log.warn(`[heatHelper] Konnte Heizung nicht setzen (${id}): ${err.message}`);
+        }
+    },
+
+    async _setHeatStates({ active, blocked, mode, reason, info, heatingRequest }) {
+        try {
+            await this.adapter.setStateAsync('heat.active', { val: !!active, ack: true });
+            await this.adapter.setStateAsync('heat.blocked', { val: !!blocked, ack: true });
+            await this.adapter.setStateAsync('heat.mode', { val: String(mode ?? ''), ack: true });
+            await this.adapter.setStateAsync('heat.reason', { val: String(reason ?? ''), ack: true });
+            await this.adapter.setStateAsync('heat.info', { val: String(info ?? ''), ack: true });
+            await this.adapter.setStateAsync('heat.heating_request', { val: !!heatingRequest, ack: true });
+            await this.adapter.setStateAsync('heat.last_change', { val: Date.now(), ack: true });
+        } catch (err) {
+            this.adapter.log.warn(`[heatHelper] Fehler beim Schreiben der Heat-States: ${err.message}`);
+        }
+    },
+
+    // -------------------------------------------------------------
+    // Foreign subscribe handling
+    // -------------------------------------------------------------
+    async _refreshForeignSubscription() {
+        const id = (await this.adapter.getStateAsync('heat.control_object_id'))?.val || '';
+        const nextId = String(id).trim();
+
+        if (nextId && nextId !== this._heatControlForeignId) {
+            // neue ID abonnieren
+            try {
+                this.adapter.subscribeForeignStates(nextId);
+                this.adapter.log.info(`[heatHelper] Subscribed Foreign-Heat-Control: "${nextId}"`);
+            } catch (err) {
+                this.adapter.log.warn(`[heatHelper] Konnte Foreign-State nicht abonnieren (${nextId}): ${err.message}`);
+            }
+            this._heatControlForeignId = nextId;
+        }
+
+        if (!nextId) {
+            this._heatControlForeignId = '';
+        }
+    },
+
+    async _safeEvaluate(tag) {
+        try {
+            await this._evaluate(tag);
+        } catch (err) {
+            this.adapter.log.warn(`[heatHelper] Evaluate-Fehler (${tag}): ${err.message}`);
+        }
+    },
+
+    cleanup() {
+        if (this._afterrunTimer) {
+            clearTimeout(this._afterrunTimer);
+            this._afterrunTimer = null;
+        }
+        this._ownsPump = false;
+        this._desiredHeat = null;
+    },
+};
+
+module.exports = heatHelper;

package/lib/helpers/pumpHelper.js

@@ -214,6 +214,15 @@ const pumpHelper = {
                             status = 'EIN (Zeitsteuerung)';
                         }
                         break;
+
+                    case 'heatHelper':
+                        try {
+                            const reason = (await this.adapter.getStateAsync('pump.reason'))?.val || '';
+                            status = reason ? `EIN (${reason})` : 'EIN (Heizung)';
+                        } catch {
+                            status = 'EIN (Heizung)';
+                        }
+                        break;
                 }
             }
             await this.adapter.setStateChangedAsync('pump.status', {

package/lib/stateDefinitions/heatStates.js

@@ -0,0 +1,261 @@
+'use strict';
+
+/**
+ * Legt alle States für die Heizungs- / Wärmepumpensteuerung an
+ *
+ * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
+ */
+async function createHeatStates(adapter) {
+    const channelId = 'heat';
+
+    // ---------------------------------------------------------
+    // Channel
+    // ---------------------------------------------------------
+    await adapter.setObjectNotExistsAsync(channelId, {
+        type: 'channel',
+        common: {
+            name: 'Heizung / Wärmepumpe',
+        },
+        native: {},
+    });
+
+    // ---------------------------------------------------------
+    // Steuerung / Konfiguration (write = true, persistent)
+    // ---------------------------------------------------------
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.control_active`, {
+        type: 'state',
+        common: {
+            name: 'Heizungssteuerung aktiv',
+            type: 'boolean',
+            role: 'switch',
+            read: true,
+            write: true,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingControlActive = await adapter.getStateAsync(`${channelId}.control_active`);
+    if (
+        existingControlActive === null ||
+        existingControlActive.val === null ||
+        existingControlActive.val === undefined
+    ) {
+        await adapter.setStateAsync(`${channelId}.control_active`, {
+            val: adapter.config.heat_control_active ?? false,
+            ack: true,
+        });
+    }
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.control_type`, {
+        type: 'state',
+        common: {
+            name: 'Art der Heizungssteuerung',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: true,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingControlType = await adapter.getStateAsync(`${channelId}.control_type`);
+    if (existingControlType === null || existingControlType.val === null || existingControlType.val === undefined) {
+        await adapter.setStateAsync(`${channelId}.control_type`, {
+            val: adapter.config.heat_control_type ?? 'socket',
+            ack: true,
+        });
+    }
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.control_object_id`, {
+        type: 'state',
+        common: {
+            name: 'Steuer-Objekt-ID Heizung',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: true,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingObjectId = await adapter.getStateAsync(`${channelId}.control_object_id`);
+    if (existingObjectId === null || existingObjectId.val === null || existingObjectId.val === undefined) {
+        await adapter.setStateAsync(`${channelId}.control_object_id`, {
+            val: adapter.config.heat_control_object_id ?? '',
+            ack: true,
+        });
+    }
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.target_temperature`, {
+        type: 'state',
+        common: {
+            name: 'Zieltemperatur Pool',
+            type: 'number',
+            role: 'value.temperature',
+            unit: '°C',
+            read: true,
+            write: true,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingTargetTemp = await adapter.getStateAsync(`${channelId}.target_temperature`);
+    if (existingTargetTemp === null || existingTargetTemp.val === null || existingTargetTemp.val === undefined) {
+        await adapter.setStateAsync(`${channelId}.target_temperature`, {
+            val: adapter.config.heat_temp_target ?? 26,
+            ack: true,
+        });
+    }
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.max_temperature`, {
+        type: 'state',
+        common: {
+            name: 'Maximale Pooltemperatur (Sicherheit)',
+            type: 'number',
+            role: 'value.temperature',
+            unit: '°C',
+            read: true,
+            write: true,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingMaxTemp = await adapter.getStateAsync(`${channelId}.max_temperature`);
+    if (existingMaxTemp === null || existingMaxTemp.val === null || existingMaxTemp.val === undefined) {
+        await adapter.setStateAsync(`${channelId}.max_temperature`, {
+            val: adapter.config.heat_temp_max ?? 30,
+            ack: true,
+        });
+    }
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.pump_afterrun_minutes`, {
+        type: 'state',
+        common: {
+            name: 'Pumpen-Nachlaufzeit nach Heizung',
+            type: 'number',
+            role: 'value.interval',
+            unit: 'min',
+            read: true,
+            write: true,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingAfterrun = await adapter.getStateAsync(`${channelId}.pump_afterrun_minutes`);
+    if (existingAfterrun === null || existingAfterrun.val === null || existingAfterrun.val === undefined) {
+        await adapter.setStateAsync(`${channelId}.pump_afterrun_minutes`, {
+            val: 5,
+            ack: true,
+        });
+    }
+
+    // ---------------------------------------------------------
+    // Betriebsstatus (write = false)
+    // ---------------------------------------------------------
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.active`, {
+        type: 'state',
+        common: {
+            name: 'Heizung aktiv',
+            type: 'boolean',
+            role: 'indicator.working',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.mode`, {
+        type: 'state',
+        common: {
+            name: 'Heizungsmodus',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.blocked`, {
+        type: 'state',
+        common: {
+            name: 'Heizung blockiert',
+            type: 'boolean',
+            role: 'indicator.blocked',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.afterrun_active`, {
+        type: 'state',
+        common: {
+            name: 'Pumpen-Nachlauf aktiv',
+            type: 'boolean',
+            role: 'indicator.working',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.last_change`, {
+        type: 'state',
+        common: {
+            name: 'Letzte Statusänderung Heizung',
+            type: 'number',
+            role: 'value.time',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.heating_request`, {
+        type: 'state',
+        common: {
+            name: 'Heizanforderung (PoolControl)',
+            type: 'boolean',
+            role: 'indicator.request',
+            read: true,
+            write: false,
+            def: false,
+        },
+        native: {},
+    });
+
+    // ---------------------------------------------------------
+    // Transparenz / Diagnose
+    // ---------------------------------------------------------
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.reason`, {
+        type: 'state',
+        common: {
+            name: 'Grund für Heizungsstatus',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+
+    await adapter.setObjectNotExistsAsync(`${channelId}.info`, {
+        type: 'state',
+        common: {
+            name: 'Heizungs-Info',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: false,
+        },
+        native: {},
+    });
+}
+
+module.exports = {
+    createHeatStates,
+};

package/main.js

@@ -30,6 +30,7 @@ const debugLogHelper = require('./lib/helpers/debugLogHelper');
 const speechTextHelper = require('./lib/helpers/speechTextHelper');
 const migrationHelper = require('./lib/helpers/migrationHelper');
 const infoHelper = require('./lib/helpers/infoHelper');
+const heatHelper = require('./lib/helpers/heatHelper');
 const { createTemperatureStates } = require('./lib/stateDefinitions/temperatureStates');
 const { createPumpStates } = require('./lib/stateDefinitions/pumpStates');
 const { createPumpStates2 } = require('./lib/stateDefinitions/pumpStates2');
@@ -49,6 +50,7 @@ const { createDebugLogStates } = require('./lib/stateDefinitions/debugLogStates'
 const { createInfoStates } = require('./lib/stateDefinitions/infoStates');
 const { createAiStates } = require('./lib/stateDefinitions/aiStates'); // NEU: KI-States
 const { createAiChemistryHelpStates } = require('./lib/stateDefinitions/aiChemistryHelpStates'); // NEU: KI-Chemie-Hilfe
+const { createHeatStates } = require('./lib/stateDefinitions/heatStates');
 
 class Poolcontrol extends utils.Adapter {
     constructor(options) {
@@ -79,6 +81,9 @@ class Poolcontrol extends utils.Adapter {
         // --- Solarverwaltung ---
         await createSolarStates(this);
 
+        // --- Heizung / Wärmepumpe ---
+        await createHeatStates(this);
+
         // --- Photovoltaik ---
         await createPhotovoltaicStates(this);
 
@@ -136,6 +141,7 @@ class Poolcontrol extends utils.Adapter {
         speechHelper.init(this);
         consumptionHelper.init(this);
         solarHelper.init(this);
+        heatHelper.init(this); // ← NEU
         photovoltaicHelper.init(this);
         aiHelper.init(this);
         aiForecastHelper.init(this);
@@ -196,6 +202,9 @@ class Poolcontrol extends utils.Adapter {
             if (controlHelper2.cleanup) {
                 controlHelper2.cleanup();
             }
+            if (heatHelper.cleanup) {
+                heatHelper.cleanup();
+            }
             if (speechTextHelper.cleanup) {
                 speechTextHelper.cleanup();
             }
@@ -279,6 +288,11 @@ class Poolcontrol extends utils.Adapter {
         } catch (e) {
             this.log.warn(`[photovoltaicHelper] Fehler in handleStateChange: ${e.message}`);
         }
+        try {
+            heatHelper.handleStateChange(id, state);
+        } catch (e) {
+            this.log.warn(`[heatHelper] Fehler in handleStateChange: ${e.message}`);
+        }
         // --- AI-Helper ---
         try {
             aiHelper.handleStateChange(id, state);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.poolcontrol",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "Steuerung & Automatisierung für den Pool (Pumpe, Heizung, Ventile, Sensoren).",
   "author": "DasBo1975 <dasbo1975@outlook.de>",
   "homepage": "https://github.com/DasBo1975/ioBroker.poolcontrol",