iobroker.poolcontrol 0.8.2 → 0.9.1

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,34 @@
 {
   "common": {
     "name": "poolcontrol",
-    "version": "0.8.2",
+    "version": "0.9.1",
     "news": {
+       "0.9.1": {
+         "en": "Extended heating / heat pump control (heatHelper) with configurable pump pre-run before heating start. The pump can now be started a defined time before the heater is activated to ensure sufficient water flow and pressure (e.g. for heat pumps). Includes new states for pre-run timing and status, fully integrated into the existing priority, ownership, and safety logic.",
+         "de": "Erweiterte Heizungs- / Wärmepumpensteuerung (heatHelper) um eine konfigurierbare Pumpen-Vorlaufzeit vor Heizstart. Die Pumpe kann nun für eine definierte Zeit vor dem Einschalten der Heizung gestartet werden, um ausreichend Wasserdurchfluss und Druck sicherzustellen (z. B. bei Wärmepumpen). Enthält neue Datenpunkte für Vorlaufzeit und Vorlaufstatus, vollständig integriert in die bestehende Vorrangs-, Ownership- und Sicherheitslogik.",
+         "ru": "Расширенная система управления отоплением / тепловым насосом (heatHelper) с настраиваемым предварительным запуском насоса перед началом нагрева. Насос может запускаться за заданное время до включения отопления для обеспечения достаточного потока и давления воды (например, для тепловых насосов). Добавлены новые состояния для времени предварительного запуска и его статуса, полностью интегрированные в существующую логику приоритетов, владения и безопасности.",
+         "pt": "Controlo de aquecimento / bomba de calor (heatHelper) alargado com pré-funcionamento configurável da bomba antes do início do aquecimento. A bomba pode agora ser ligada durante um período definido antes da ativação do aquecedor para garantir caudal e pressão de água suficientes (por exemplo, em bombas de calor). Inclui novos estados para tempo e estado do pré-funcionamento, totalmente integrados na lógica existente de prioridades, propriedade e segurança.",
+         "nl": "Uitgebreide verwarmings- / warmtepompregeling (heatHelper) met configureerbare pomp-voorloop vóór de start van de verwarming. De pomp kan nu een ingestelde tijd vóór het inschakelen van de verwarming worden gestart om voldoende waterdoorstroming en druk te garanderen (bijv. voor warmtepompen). Bevat nieuwe states voor voorlooptijd en -status, volledig geïntegreerd in de bestaande prioriteits-, eigendoms- en veiligheidslogica.",
+         "fr": "Extension du contrôle de chauffage / pompe à chaleur (heatHelper) avec un préfonctionnement configurable de la pompe avant le démarrage du chauffage. La pompe peut désormais être démarrée un temps défini avant l’activation du chauffage afin d’assurer un débit et une pression d’eau suffisants (par ex. pour les pompes à chaleur). Ajout de nouveaux états pour la durée et le statut du préfonctionnement, entièrement intégrés à la logique existante de priorité, de propriété et de sécurité.",
+         "it": "Controllo di riscaldamento / pompa di calore (heatHelper) esteso con pre-avviamento configurabile della pompa prima dell’inizio del riscaldamento. La pompa può ora essere avviata per un periodo definito prima dell’attivazione del riscaldamento per garantire un flusso e una pressione dell’acqua sufficienti (ad es. per le pompe di calore). Include nuovi stati per il tempo e lo stato del pre-avviamento, completamente integrati nella logica esistente di priorità, proprietà e sicurezza.",
+         "es": "Control de calefacción / bomba de calor (heatHelper) ampliado con prefuncionamiento configurable de la bomba antes del inicio de la calefacción. La bomba puede iniciarse ahora durante un tiempo definido antes de activar la calefacción para garantizar un caudal y una presión de agua suficientes (p. ej., para bombas de calor). Incluye nuevos estados para el tiempo y el estado del prefuncionamiento, totalmente integrados en la lógica existente de prioridades, propiedad y seguridad.",
+         "pl": "Rozszerzony system sterowania ogrzewaniem / pompą ciepła (heatHelper) o konfigurowalny wstępny bieg pompy przed rozpoczęciem grzania. Pompa może być uruchamiana na określony czas przed włączeniem ogrzewania w celu zapewnienia odpowiedniego przepływu i ciśnienia wody (np. dla pomp ciepła). Dodano nowe stany dla czasu i statusu biegu wstępnego, w pełni zintegrowane z istniejącą logiką priorytetów, własności i bezpieczeństwa.",
+         "uk": "Розширене керування опаленням / тепловим насосом (heatHelper) з налаштовуваним попереднім запуском насоса перед початком нагріву. Насос може запускатися за визначений час до увімкнення опалення для забезпечення достатнього потоку та тиску води (наприклад, для теплових насосів). Додано нові стани для часу та статусу попереднього запуску, повністю інтегровані в існуючу логіку пріоритетів, володіння та безпеки.",
+         "zh-cn": "扩展了加热 / 热泵控制功能（heatHelper），新增可配置的加热前水泵预运行时间。水泵可在加热设备启动前提前运行一段时间，以确保足够的水流和水压（例如用于热泵）。新增了预运行时间和状态的数据点，已完全集成到现有的优先级、所有权和安全逻辑中。"
+       },
+       "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.",
@@ -67,32 +93,6 @@
          "pl": "Poprawka pozdrowień sezonowych: życzenia świąteczne pojawiają się teraz prawidłowo tylko między 20 a 27 grudnia. Błędna przedwczesna aktywacja została naprawiona.",
          "uk": "Виправлено сезонні вітання: Різдвяне привітання тепер з’являється лише з 20 по 27 грудня. Помилкове передчасне спрацьовування виправлено.",
          "zh-cn": "修复季节性问候：圣诞问候现在仅在 12 月 20 日至 27 日之间显示。已修复错误的提前触发问题。"
-       },
-       "0.7.2": {
-         "en": "Added new info system: The adapter now writes seasonal greetings and the installed adapter version to info.* states. Includes automatic daily refresh at 00:01 and full Easter date calculation.",
-         "de": "Neues Info-System hinzugefügt: Der Adapter schreibt nun saisonale Grüße und die installierte Adapterversion in die info.* States. Enthält eine automatische tägliche Aktualisierung um 00:01 sowie eine vollständige Oster-Berechnung.",
-         "ru": "Добавлена новая информационная система: адаптер теперь записывает сезонные поздравления и установленную версию адаптера в состояния info.*. Включает ежедневное обновление в 00:01 и полный расчёт даты Пасхи.",
-         "pt": "Novo sistema de informações adicionado: o adaptador agora grava saudações sazonais e a versão instalada do adaptador nos estados info.*. Inclui atualização diária automática às 00:01 e cálculo completo da data da Páscoa.",
-         "nl": "Nieuw infosysteem toegevoegd: de adapter schrijft nu seizoensgroeten en de geïnstalleerde adapterversie naar info.*-states. Inclusief automatische dagelijkse update om 00:01 en volledige berekening van Pasen.",
-         "fr": "Nouveau système d'informations ajouté : l'adaptateur écrit désormais des messages saisonniers et la version installée dans les états info.*. Comprend une mise à jour quotidienne automatique à 00:01 et un calcul complet de la date de Pâques.",
-         "it": "Aggiunto nuovo sistema informativo: l'adattatore ora scrive i saluti stagionali e la versione installata negli stati info.*. Include aggiornamento giornaliero automatico alle 00:01 e calcolo completo della data di Pasqua.",
-         "es": "Nuevo sistema de información añadido: el adaptador ahora escribe saludos estacionales y la versión instalada en los estados info.*. Incluye actualización automática diaria a las 00:01 y cálculo completo de la fecha de Pascua.",
-         "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,513 @@
+'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,
+    _prerunTimer: null, // NEU: Pumpen-Vorlauf vor Heizstart
+
+    // 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');
+        this.adapter.subscribeStates('heat.pump_prerun_minutes'); // NEU
+
+        // 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') ||
+                id.endsWith('heat.pump_prerun_minutes')
+            ) {
+                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;
+        }
+
+        // -------------------------------------------------
+        // NEU: Pumpen-Prerun vor Heizstart
+        // -------------------------------------------------
+        const prerunMin = Math.max(
+            0,
+            Number((await this.adapter.getStateAsync('heat.pump_prerun_minutes'))?.val ?? 0) || 0,
+        );
+
+        const pumpState = await this.adapter.getStateAsync('pump.pump_switch');
+        const pumpIsOn = !!pumpState?.val;
+
+        // Prerun nur, wenn:
+        // - Zeit > 0
+        // - Pumpe aktuell AUS
+        // - kein Prerun aktiv
+        if (prerunMin > 0 && !pumpIsOn && !this._prerunTimer) {
+            this.adapter.log.info(`[heatHelper] Starte Pumpen-Prerun (${prerunMin} min)`);
+
+            // Pumpe einschalten + Ownership übernehmen
+            this._ownsPump = true;
+            await this.adapter.setStateAsync('pump.pump_switch', { val: true, ack: false });
+
+            // Prerun-Status setzen
+            await this.adapter.setStateAsync('heat.prerun_active', { val: true, ack: true });
+
+            const holdMs = Math.round(prerunMin * 60 * 1000);
+
+            this._prerunTimer = setTimeout(async () => {
+                this._prerunTimer = null;
+
+                await this.adapter.setStateAsync('heat.prerun_active', { val: false, ack: true });
+
+                // Nach Prerun erneut bewerten → Heizung darf jetzt starten
+                await this._safeEvaluate('prerun_done');
+            }, holdMs);
+
+            // WICHTIG: Heizung JETZT noch NICHT einschalten
+            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) {
+        // NEU: laufenden Prerun abbrechen
+        if (this._prerunTimer) {
+            clearTimeout(this._prerunTimer);
+            this._prerunTimer = null;
+            await this.adapter.setStateAsync('heat.prerun_active', { val: false, ack: true });
+        }
+
+        // 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) {
+        // NEU: laufenden Prerun abbrechen
+        if (this._prerunTimer) {
+            clearTimeout(this._prerunTimer);
+            this._prerunTimer = null;
+            await this.adapter.setStateAsync('heat.prerun_active', { val: false, ack: true });
+        }
+
+        // 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 });
+            await this.adapter.setStateAsync('heat.prerun_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;
+        }
+        if (this._prerunTimer) {
+            clearTimeout(this._prerunTimer);
+            this._prerunTimer = 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/generalStates.js

@@ -9,6 +9,15 @@
  * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
  */
 async function createGeneralStates(adapter) {
+    // Channel: Allgemein
+    await adapter.setObjectNotExistsAsync('general', {
+        type: 'channel',
+        common: {
+            name: 'Allgemeine Einstellungen',
+        },
+        native: {},
+    });
+
     // Poolname
     await adapter.setObjectNotExistsAsync('general.pool_name', {
         type: 'state',

package/lib/stateDefinitions/heatStates.js

@@ -0,0 +1,296 @@
+'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,
+        });
+    }
+
+    // --- NEU: Pumpen-Vorlaufzeit vor Heizstart ---
+    await adapter.setObjectNotExistsAsync(`${channelId}.pump_prerun_minutes`, {
+        type: 'state',
+        common: {
+            name: 'Pumpen-Vorlaufzeit vor Heizung',
+            type: 'number',
+            role: 'value.interval',
+            unit: 'min',
+            read: true,
+            write: true,
+            persist: true,
+        },
+        native: {},
+    });
+    const existingPrerun = await adapter.getStateAsync(`${channelId}.pump_prerun_minutes`);
+    if (existingPrerun === null || existingPrerun.val === null || existingPrerun.val === undefined) {
+        await adapter.setStateAsync(`${channelId}.pump_prerun_minutes`, {
+            val: 0,
+            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: {},
+    });
+
+    // --- NEU: Pumpen-Vorlauf aktiv ---
+    await adapter.setObjectNotExistsAsync(`${channelId}.prerun_active`, {
+        type: 'state',
+        common: {
+            name: 'Pumpen-Vorlauf aktiv',
+            type: 'boolean',
+            role: 'indicator.working',
+            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/lib/stateDefinitions/pumpStates.js

@@ -13,6 +13,15 @@
  * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
  */
 async function createPumpStates(adapter) {
+    // Channel: Pumpe
+    await adapter.setObjectNotExistsAsync('pump', {
+        type: 'channel',
+        common: {
+            name: 'Pumpe',
+        },
+        native: {},
+    });
+
     // Max. Pumpenleistung (W)
     await adapter.setObjectNotExistsAsync('pump.pump_max_watt', {
         type: 'state',

package/lib/stateDefinitions/solarStates.js

@@ -14,6 +14,15 @@
  * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
  */
 async function createSolarStates(adapter) {
+    // Channel: Solar
+    await adapter.setObjectNotExistsAsync('solar', {
+        type: 'channel',
+        common: {
+            name: 'Solar',
+        },
+        native: {},
+    });
+
     // Solarsteuerung aktiv (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('solar.solar_control_active', {
         type: 'state',

package/lib/stateDefinitions/timeStates.js

@@ -9,6 +9,15 @@
  * @param {import("iobroker").Adapter} adapter - ioBroker Adapter-Instanz
  */
 async function createTimeStates(adapter) {
+    // Channel: Zeitsteuerung
+    await adapter.setObjectNotExistsAsync('timecontrol', {
+        type: 'channel',
+        common: {
+            name: 'Zeitsteuerung',
+        },
+        native: {},
+    });
+
     async function createTimeWindow(prefix, label) {
         // Aktiv
         await adapter.setObjectNotExistsAsync(`timecontrol.${prefix}_active`, {

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.1",
   "description": "Steuerung & Automatisierung für den Pool (Pumpe, Heizung, Ventile, Sensoren).",
   "author": "DasBo1975 <dasbo1975@outlook.de>",
   "homepage": "https://github.com/DasBo1975/ioBroker.poolcontrol",