iobroker.poolcontrol 0.2.2 → 0.3.0

package/README.md

@@ -121,6 +121,24 @@ Funktionen können sich ändern – bitte regelmäßig den Changelog beachten.
 ## Changelog
 ### **WORK IN PROGRESS**
 
+### 0.3.0 (12.10.2025)
+**Neu:** Intelligentes Pumpen-Monitoring & Lernsystem
+
+- Hinzugefügt: **Reelle Durchflussberechnung** auf Basis der tatsächlichen Leistungsaufnahme.  
+- Neuer Bereich **`pump.live`** zur Live-Überwachung von Leistung, Durchfluss und prozentualer Auslastung.  
+- Die **tägliche Umwälzberechnung** verwendet nun den realen Durchflusswert anstelle eines Fixwerts.  
+- Neuer Lernbereich **`pump.learning`**:
+  - Lernt automatisch die durchschnittlichen Leistungs- und Durchflusswerte.  
+  - Bestimmt daraus einen dynamischen **Normalbereich (± 15 %)**.  
+  - Berechnet prozentuale Abweichungen und erstellt **textbasierte Statusmeldungen**.  
+  - Alle Lernwerte werden **persistent** gespeichert und bleiben auch nach Neustart erhalten.  
+- Vollständig **ereignisgesteuerte Logik** ohne zusätzliche Timer oder Polling-Zyklen.  
+
+> Mit dieser Version beginnt die lernfähige Phase des PoolControl-Adapters:  
+> Deine Pumpe weiß jetzt selbst, was für sie „normal“ ist.
+
+---
+
 ### 0.2.2 (2025-10-08)
 - Einführung einer **automatischen Rückspülerinnerung** (neuer Bereich im ControlHelper2)
 - Erinnerung mit Intervall in Tagen und automatischer Rücksetzung nach erfolgter Rückspülung

package/io-package.json

@@ -1,8 +1,20 @@
 {
   "common": {
     "name": "poolcontrol",
-    "version": "0.2.2",
+    "version": "0.3.0",
     "news": {
+      "0.3.0": {
+        "en": "Added real pump flow calculation, live monitoring, and self-learning normal range system for pump analysis.",
+        "de": "Reelle Durchflussberechnung, Liveüberwachung und selbstlernendes Normalbereich-System zur Pumpenanalyse hinzugefügt.",
+        "ru": "Добавлен расчет реального расхода насоса, живой мониторинг и самообучающаяся система нормальных диапазонов для анализа насоса.",
+        "pt": "Adicionada cálculo de fluxo real da bomba, monitoramento ao vivo e sistema autoaprendente de faixa normal para análise da bomba.",
+        "nl": "Reële pompdebietberekening, livebewaking en zelflerend normaalbereiksysteem voor pompanalyse toegevoegd.",
+        "fr": "Ajout du calcul du débit réel de la pompe, de la surveillance en direct et d’un système de plage normale auto-apprenant pour l’analyse de la pompe.",
+        "it": "Aggiunto calcolo del flusso reale della pompa, monitoraggio live e sistema autoapprendente di intervallo normale per l'analisi della pompa.",
+        "es": "Se añadió el cálculo del caudal real de la bomba, la monitorización en vivo y un sistema de rango normal autoaprendente para el análisis de la bomba.",
+        "pl": "Dodano obliczanie rzeczywistego przepływu pompy, monitorowanie na żywo i samouczący się system normalnego zakresu do analizy pompy.",
+        "zh-cn": "添加了实际泵流量计算、实时监控以及用于泵分析的自学习正常范围系统。"
+        },
       "0.2.2": {
         "en": "Added automatic backwash reminder with speech and log notifications.",
         "de": "Automatische Rückspülerinnerung mit Sprach- und Log-Benachrichtigung hinzugefügt.",
@@ -40,33 +52,7 @@
        "pl": "Nowy obszar diagnostyczny 'SystemCheck' dla wewnętrznych dzienników debugowania i przyszłych narzędzi analitycznych.",
        "uk": "Нова діагностична область 'SystemCheck' для внутрішніх журналів налагодження та майбутніх інструментів аналізу.",
        "zh-cn": "新的诊断区域“SystemCheck”，用于内部调试日志和未来的分析工具。"
-      },
-      "0.1.2": {
-       "en": "Improved: The last known temperature values of all active sensors are now read at adapter start. Sensors that report rarely are now displayed correctly.",
-       "de": "Verbesserung: Beim Adapterstart werden nun die letzten bekannten Temperaturwerte aller aktiven Sensoren übernommen. Sensoren, die nur selten Werte senden, werden jetzt korrekt angezeigt.",
-       "ru": "Улучшение: При запуске адаптера теперь считываются последние известные значения температуры всех активных датчиков.",
-       "pt": "Melhoria: Os últimos valores de temperatura conhecidos de todos os sensores ativos agora são lidos ao iniciar o adaptador.",
-       "nl": "Verbetering: Bij het starten van de adapter worden nu de laatst bekende temperatuurwaarden van alle actieve sensoren opgehaald.",
-       "fr": "Amélioration : les dernières valeurs de température connues de tous les capteurs actifs sont désormais lues au démarrage de l’adaptateur.",
-       "it": "Miglioramento: all'avvio dell'adattatore vengono ora letti gli ultimi valori di temperatura noti di tutti i sensori attivi.",
-       "es": "Mejora: ahora se leen al iniciar el adaptador los últimos valores de temperatura conocidos de todos los sensores activos.",
-       "pl": "Ulepszenie: podczas uruchamiania adaptera odczytywane są ostatnie znane wartości temperatury wszystkich aktywnych czujników.",
-       "uk": "Покращення: під час запуску адаптера тепер зчитуються останні відомі значення температури всіх активних датчиків.",
-       "zh-cn": "改进：适配器启动时现在会读取所有活动传感器的最后已知温度值。"
-      },
-      "0.1.1": {
-       "en": "Fixed endless loop between pump_switch and deviceId for some smart sockets",
-       "de": "Endlosschleife zwischen pump_switch und Steckdose (deviceId) behoben",
-       "ru": "Исправлен бесконечный цикл между pump_switch и deviceId для некоторых умных розеток",
-       "pt": "Corrigido loop infinito entre pump_switch e deviceId em algumas tomadas inteligentes",
-       "nl": "Eindeloze lus tussen pump_switch en deviceId voor sommige slimme stopcontacten opgelost",
-       "fr": "Correction d'une boucle infinie entre pump_switch et deviceId pour certaines prises intelligentes",
-       "it": "Corretto loop infinito tra pump_switch e deviceId per alcune prese intelligenti",
-       "es": "Corregido bucle infinito entre pump_switch y deviceId en algunos enchufes inteligentes",
-       "pl": "Naprawiono nieskończoną pętlę między pump_switch a deviceId dla niektórych inteligentnych gniazdek",
-       "uk": "Виправлено нескінченний цикл між pump_switch і deviceId для деяких розумних розеток",
-       "zh-cn": "修复了某些智能插座中 pump_switch 与 deviceId 之间的无限循环"
-	   }
+      }
 	},
     "titleLang": {
       "en": "PoolControl",

package/lib/helpers/migrationHelper.js

@@ -0,0 +1,117 @@
+'use strict';
+
+/**
+ * migrationHelper
+ * --------------------------------------------------
+ * Führt nachträgliche Struktur- oder State-Anpassungen
+ * für bestehende Installationen durch.
+ *
+ * - Wird beim Adapterstart einmalig ausgeführt.
+ * - Korrigiert veraltete Definitionen (z. B. Schreibrechte, persist-Flags, etc.)
+ *
+ * Version: 1.0.1
+ */
+
+const migrationHelper = {
+    adapter: null,
+
+    /**
+     * Initialisiert den Migration-Helper.
+     * Wird einmalig beim Adapterstart aufgerufen.
+     *
+     * @param {ioBroker.Adapter} adapter - Die aktive Adapterinstanz
+     */
+    async init(adapter) {
+        this.adapter = adapter;
+        this.adapter.log.info('[migrationHelper] Starte Migration-Check ...');
+
+        try {
+            // ------------------------------------------------------
+            // Hier alle Migrationsroutinen nacheinander aufrufen
+            // ------------------------------------------------------
+            await this._fixSpeechQueue();
+            await this._fixSolarWarnActivePersist();
+
+            // Weitere Routinen folgen hier später:
+            // await this._ensurePumpReason();
+            // await this._cleanupOldStates();
+
+            this.adapter.log.debug('[migrationHelper] Migration-Checks abgeschlossen.');
+        } catch (err) {
+            this.adapter.log.warn(`[migrationHelper] Fehler beim Migration-Check: ${err.message}`);
+        }
+
+        this.adapter.log.info('[migrationHelper] Migration-Helper beendet.');
+    },
+
+    // ------------------------------------------------------
+    // Migration: Schreibrecht für speech.queue korrigieren
+    // ------------------------------------------------------
+
+    /**
+     * Prüft und korrigiert den State "speech.queue", falls er noch write:false gesetzt hat.
+     * Dadurch verschwinden Warnungen beim Schreiben (Read-only state ... written without ack).
+     */
+    async _fixSpeechQueue() {
+        const id = 'speech.queue';
+        try {
+            const obj = await this.adapter.getObjectAsync(id);
+            if (!obj) {
+                this.adapter.log.debug(`[migrationHelper] ${id} existiert nicht – keine Anpassung nötig.`);
+                return;
+            }
+
+            const isReadOnly = obj.common?.write === false;
+            if (isReadOnly) {
+                this.adapter.log.info(`[migrationHelper] Aktualisiere Schreibrecht für ${id} → write:true`);
+                await this.adapter.extendObjectAsync(id, {
+                    common: {
+                        write: true,
+                        desc: 'Nur intern durch den Adapter beschreibbar (nicht manuell ändern!)',
+                    },
+                });
+            } else {
+                this.adapter.log.debug(`[migrationHelper] ${id} ist bereits korrekt konfiguriert.`);
+            }
+        } catch (err) {
+            this.adapter.log.warn(`[migrationHelper] Fehler bei Prüfung von ${id}: ${err.message}`);
+        }
+    },
+
+    // ------------------------------------------------------
+    // Migration: persist-Flag für solar.warn_active ergänzen
+    // ------------------------------------------------------
+
+    /**
+     * Ergänzt persist:true bei solar.warn_active,
+     * damit die Einstellung (Warnfunktion aktivieren/deaktivieren)
+     * nach einem Neustart erhalten bleibt.
+     */
+    async _fixSolarWarnActivePersist() {
+        const id = 'solar.warn_active';
+        try {
+            const obj = await this.adapter.getObjectAsync(id);
+            if (!obj) {
+                this.adapter.log.debug(`[migrationHelper] ${id} existiert nicht – keine Anpassung nötig.`);
+                return;
+            }
+
+            const hasPersist = obj.common?.persist === true;
+            if (!hasPersist) {
+                this.adapter.log.info(`[migrationHelper] Ergänze persist:true für ${id}`);
+                await this.adapter.extendObjectAsync(id, {
+                    common: {
+                        persist: true,
+                        desc: `${obj.common?.desc || ''} (automatisch per Migration persistiert)`,
+                    },
+                });
+            } else {
+                this.adapter.log.debug(`[migrationHelper] ${id} ist bereits mit persist:true versehen.`);
+            }
+        } catch (err) {
+            this.adapter.log.warn(`[migrationHelper] Fehler bei Prüfung von ${id}: ${err.message}`);
+        }
+    },
+};
+
+module.exports = migrationHelper;

package/lib/helpers/pumpHelper2.js

@@ -0,0 +1,160 @@
+'use strict';
+
+/**
+ * pumpHelper2.js
+ * ----------------------------------------------------------
+ * Ergänzende Berechnungslogik für Pumpen-Livewerte
+ * (reeller Durchfluss, Prozentleistung, letzter Durchflusswert).
+ *
+ * Verwendet vorhandene States:
+ *  - pump.current_power
+ *  - pump.pump_max_watt
+ *  - pump.pump_power_lph
+ *  - pump.pump_switch
+ *
+ * Schreibt neue Werte in:
+ *  - pump.live.current_power_w
+ *  - pump.live.flow_current_lh
+ *  - pump.live.flow_percent
+ *  - pump.live.last_flow_lh
+ *
+ * Alle Zielstates sind persistent (siehe pumpStates2.js).
+ * ----------------------------------------------------------
+ * Version: 1.0.0
+ */
+
+const pumpHelper2 = {
+    adapter: null,
+
+    /**
+     * Initialisiert den PumpHelper2
+     *
+     * @param {ioBroker.Adapter} adapter - Aktive ioBroker Adapterinstanz
+     */
+    async init(adapter) {
+        this.adapter = adapter;
+        this.adapter.log.info('[pumpHelper2] Initialisierung gestartet');
+
+        // Relevante States überwachen
+        this.adapter.subscribeStates('pump.current_power');
+        this.adapter.subscribeStates('pump.pump_switch');
+
+        // Initialwerte berechnen
+        await this._updateLiveValues();
+
+        this.adapter.log.info('[pumpHelper2] Erfolgreich initialisiert');
+    },
+
+    /**
+     * StateChange-Verarbeitung
+     *
+     * @param {string} id - State-ID
+     * @param {ioBroker.State | null | undefined} state - Neuer Statewert
+     */
+    async handleStateChange(id, state) {
+        if (!state || state.ack === false) {
+            return;
+        }
+
+        // Leistungsänderung → reelle Durchflusswerte aktualisieren
+        if (id.endsWith('pump.current_power')) {
+            await this._updateLiveValues();
+        }
+
+        // Pumpenstatus-Änderung → ggf. letzten Durchflusswert speichern
+        if (id.endsWith('pump.pump_switch')) {
+            const pumpOn = state.val === true;
+            if (!pumpOn) {
+                await this._storeLastFlowValue();
+            }
+        }
+    },
+
+    /**
+     * Führt die Berechnung der Livewerte durch.
+     * (Nur wenn gültige Basiswerte vorhanden sind.)
+     */
+    async _updateLiveValues() {
+        try {
+            const [currentPower, maxPower, nominalFlow] = await Promise.all([
+                this._getNumber('pump.current_power'),
+                this._getNumber('pump.pump_max_watt'),
+                this._getNumber('pump.pump_power_lph'),
+            ]);
+
+            // Schutz gegen ungültige Werte
+            if (maxPower <= 0 || nominalFlow <= 0) {
+                this.adapter.log.debug('[pumpHelper2] Ungültige Basiswerte, Berechnung übersprungen');
+                return;
+            }
+
+            // Prozentuale Auslastung
+            const flowPercent = Math.min(Math.max((currentPower / maxPower) * 100, 0), 100);
+
+            // Reeller Durchfluss
+            const flowCurrentLh = Math.round(nominalFlow * (currentPower / maxPower) * 10) / 10; // 1 Nachkommastelle
+
+            // In States schreiben
+            await this._setIfChanged('pump.live.current_power_w', currentPower);
+            await this._setIfChanged('pump.live.flow_current_lh', flowCurrentLh);
+            await this._setIfChanged('pump.live.flow_percent', flowPercent);
+
+            this.adapter.log.debug(
+                `[pumpHelper2] Reeller Durchfluss aktualisiert: ${flowCurrentLh} l/h (${flowPercent.toFixed(1)}%)`,
+            );
+        } catch (err) {
+            this.adapter.log.warn(`[pumpHelper2] Fehler bei _updateLiveValues: ${err.message}`);
+        }
+    },
+
+    /**
+     * Speichert den letzten bekannten Durchflusswert beim Pumpen-Stopp.
+     */
+    async _storeLastFlowValue() {
+        try {
+            const currentFlow = await this._getNumber('pump.live.flow_current_lh');
+            await this._setIfChanged('pump.live.last_flow_lh', currentFlow);
+            this.adapter.log.debug(`[pumpHelper2] Letzter Durchflusswert gespeichert: ${currentFlow} l/h`);
+        } catch (err) {
+            this.adapter.log.warn(`[pumpHelper2] Fehler bei _storeLastFlowValue: ${err.message}`);
+        }
+    },
+
+    /**
+     * Liest einen numerischen Statewert (oder 0 bei Fehler).
+     *
+     * @param {string} id - Objekt-ID des zu lesenden States
+     * @returns {Promise<number>} - Aktueller numerischer Wert oder 0
+     */
+    async _getNumber(id) {
+        const state = await this.adapter.getStateAsync(id);
+        const val = Number(state?.val);
+        return isNaN(val) ? 0 : val;
+    },
+
+    /**
+     * Schreibt neuen Wert nur, wenn er sich geändert hat.
+     *
+     * @param {string} id - Objekt-ID des zu schreibenden States
+     * @param {number} newVal - Neuer Wert, des gesetzt werden soll
+     */
+    async _setIfChanged(id, newVal) {
+        const current = await this.adapter.getStateAsync(id);
+        if (current && Number(current.val) === newVal) {
+            return;
+        }
+        await this.adapter.setStateAsync(id, { val: newVal, ack: true });
+    },
+
+    /**
+     * Cleanup bei Adapter-Unload
+     * Wird aktuell nur als Platzhalter verwendet.
+     */
+    cleanup() {
+        // Derzeit keine Timer oder Intervalle vorhanden
+        // Platzhalter für zukünftige Erweiterungen
+        this.adapter?.log.debug('[pumpHelper2] Cleanup ausgeführt.');
+    },
+};
+
+module.exports = pumpHelper2;

package/lib/helpers/pumpHelper3.js

@@ -0,0 +1,259 @@
+'use strict';
+
+/**
+ * pumpHelper3.js
+ * ----------------------------------------------------------
+ * Lern- und Analysemodul für die Pumpe
+ * - Ermittelt Durchschnitts- und Normalwerte aus realen Laufzyklen
+ * - Berechnet Abweichungen (Leistung & Durchfluss)
+ * - Liefert textbasierte Statusbewertung ("im Normalbereich" etc.)
+ * - Keine Sprach- oder Queue-Ausgabe
+ *
+ * Verwaltet:
+ *   pump.learning.*
+ *
+ * Abhängigkeiten:
+ *   - pump.live.current_power_w
+ *   - pump.live.flow_current_lh
+ *   - pump.pump_switch
+ *
+ * Version: 1.0.0
+ */
+
+const pumpHelper3 = {
+    adapter: null,
+
+    /** interner Speicher */
+    currentSessionValues: {
+        power: [],
+        flow: [],
+    },
+
+    /**
+     * Initialisiert den Helper
+     *
+     * @param {ioBroker.Adapter} adapter - aktive Adapterinstanz
+     */
+    async init(adapter) {
+        this.adapter = adapter;
+        this.adapter.log.info('[pumpHelper3] Initialisierung gestartet');
+
+        // Relevante States überwachen
+        this.adapter.subscribeStates('pump.pump_switch');
+        this.adapter.subscribeStates('pump.live.current_power_w');
+        this.adapter.subscribeStates('pump.live.flow_current_lh');
+
+        this.adapter.log.info('[pumpHelper3] Erfolgreich initialisiert');
+    },
+
+    /**
+     * Verarbeitet State-Änderungen
+     *
+     * @param {string} id - State-ID
+     * @param {ioBroker.State} state - neuer Statewert
+     */
+    async handleStateChange(id, state) {
+        if (!state || state.ack === false) {
+            return;
+        }
+
+        try {
+            if (id.endsWith('pump.pump_switch')) {
+                const isOn = state.val === true;
+                if (isOn) {
+                    // Pumpe startet → neue Sitzung
+                    this.currentSessionValues.power = [];
+                    this.currentSessionValues.flow = [];
+                    this.adapter.log.debug('[pumpHelper3] Neue Lern-Session gestartet');
+                } else {
+                    // Pumpe stoppt → Lernwerte aktualisieren
+                    await this._finalizeLearningCycle();
+                }
+            }
+
+            // Wenn Pumpe läuft, aktuelle Werte sammeln
+            const pumpRunning = !!(await this.adapter.getStateAsync('pump.pump_switch'))?.val;
+            if (pumpRunning) {
+                if (id.endsWith('pump.live.current_power_w')) {
+                    this._pushValue('power', state.val);
+                }
+                if (id.endsWith('pump.live.flow_current_lh')) {
+                    this._pushValue('flow', state.val);
+                }
+            }
+
+            // Bei jeder Änderung der Livewerte aktuelle Abweichung bewerten
+            await this._updateDeviationAndStatus();
+        } catch (err) {
+            this.adapter.log.warn(`[pumpHelper3] Fehler bei handleStateChange: ${err.message}`);
+        }
+    },
+
+    /**
+     * Fügt einen neuen Wert in den temporären Speicher ein.
+     *
+     * @param {"power"|"flow"} type - Art des Wertes
+     * @param {number} value - neuer Messwert
+     */
+    _pushValue(type, value) {
+        if (!this.currentSessionValues[type]) {
+            this.currentSessionValues[type] = [];
+        }
+        if (typeof value === 'number' && value > 0) {
+            this.currentSessionValues[type].push(value);
+        }
+    },
+
+    /**
+     * Wird aufgerufen, wenn ein Pumpenlauf endet.
+     * Berechnet Durchschnittswerte des Laufs und aktualisiert Lernfelder.
+     */
+    async _finalizeLearningCycle() {
+        try {
+            const { power, flow } = this.currentSessionValues;
+            if (power.length === 0 || flow.length === 0) {
+                this.adapter.log.debug('[pumpHelper3] Keine Werte zum Lernen vorhanden, Zyklus übersprungen');
+                return;
+            }
+
+            const avgPower = this._average(power);
+            const avgFlow = this._average(flow);
+
+            // Vorhandene Lernwerte lesen
+            const learnedPower = (await this._getNumber('pump.learning.learned_avg_power_w')) || 0;
+            const learnedFlow = (await this._getNumber('pump.learning.learned_avg_flow_lh')) || 0;
+            const cycles = (await this._getNumber('pump.learning.learning_cycles_total')) || 0;
+
+            // Gleitenden Durchschnitt berechnen
+            const newCycles = cycles + 1;
+            const newAvgPower = (learnedPower * cycles + avgPower) / newCycles;
+            const newAvgFlow = (learnedFlow * cycles + avgFlow) / newCycles;
+
+            // Normalbereiche ±15 %
+            const rangePowerLow = Math.round(newAvgPower * 0.85);
+            const rangePowerHigh = Math.round(newAvgPower * 1.15);
+            const rangeFlowLow = Math.round(newAvgFlow * 0.85);
+            const rangeFlowHigh = Math.round(newAvgFlow * 1.15);
+
+            // States schreiben
+            await this.adapter.setStateAsync('pump.learning.learned_avg_power_w', {
+                val: Math.round(newAvgPower),
+                ack: true,
+            });
+            await this.adapter.setStateAsync('pump.learning.learned_avg_flow_lh', {
+                val: Math.round(newAvgFlow),
+                ack: true,
+            });
+            await this.adapter.setStateAsync('pump.learning.normal_range_power_low', { val: rangePowerLow, ack: true });
+            await this.adapter.setStateAsync('pump.learning.normal_range_power_high', {
+                val: rangePowerHigh,
+                ack: true,
+            });
+            await this.adapter.setStateAsync('pump.learning.normal_range_flow_low', { val: rangeFlowLow, ack: true });
+            await this.adapter.setStateAsync('pump.learning.normal_range_flow_high', { val: rangeFlowHigh, ack: true });
+            await this.adapter.setStateAsync('pump.learning.learning_cycles_total', { val: newCycles, ack: true });
+
+            this.adapter.log.debug(
+                `[pumpHelper3] Lernzyklus #${newCycles} abgeschlossen (Power Ø${avgPower}W, Flow Ø${avgFlow}l/h)`,
+            );
+
+            // Speicher leeren
+            this.currentSessionValues.power = [];
+            this.currentSessionValues.flow = [];
+        } catch (err) {
+            this.adapter.log.warn(`[pumpHelper3] Fehler bei _finalizeLearningCycle: ${err.message}`);
+        }
+    },
+
+    /**
+     * Bewertet aktuelle Abweichungen und schreibt Status.
+     */
+    async _updateDeviationAndStatus() {
+        try {
+            const currentPower = await this._getNumber('pump.live.current_power_w');
+            const currentFlow = await this._getNumber('pump.live.flow_current_lh');
+            const avgPower = await this._getNumber('pump.learning.learned_avg_power_w');
+            const avgFlow = await this._getNumber('pump.learning.learned_avg_flow_lh');
+
+            if (avgPower <= 0 || avgFlow <= 0) {
+                return;
+            } // Noch kein Lernwert vorhanden
+
+            // Prozentuale Abweichungen
+            const deviationPower = ((currentPower - avgPower) / avgPower) * 100;
+            const deviationFlow = ((currentFlow - avgFlow) / avgFlow) * 100;
+
+            await this.adapter.setStateAsync('pump.learning.deviation_power_percent', {
+                val: Math.round(deviationPower * 10) / 10,
+                ack: true,
+            });
+            await this.adapter.setStateAsync('pump.learning.deviation_flow_percent', {
+                val: Math.round(deviationFlow * 10) / 10,
+                ack: true,
+            });
+
+            // Bewertung
+            const statusText = this._getStatusText(deviationPower, deviationFlow);
+            await this.adapter.setStateAsync('pump.learning.status_text', { val: statusText, ack: true });
+        } catch (err) {
+            this.adapter.log.warn(`[pumpHelper3] Fehler bei _updateDeviationAndStatus: ${err.message}`);
+        }
+    },
+
+    /**
+     * Liefert textbasierte Bewertung anhand der Abweichung.
+     *
+     * @param devPower - Aktuelle Abweichung der Leistung (W)
+     * @param devFlow - Aktuelle Abweichung des Durchflusses (L/H)
+     */
+    _getStatusText(devPower, devFlow) {
+        const absPower = Math.abs(devPower);
+        const absFlow = Math.abs(devFlow);
+
+        if (absPower <= 15 && absFlow <= 15) {
+            return 'Pumpe läuft im Normalbereich';
+        }
+        if (devPower < -15 || devFlow < -15) {
+            return 'Pumpe läuft unterhalb des Normalbereichs (möglicher Filterdruck)';
+        }
+        if (devPower > 15 || devFlow > 15) {
+            return 'Pumpe läuft oberhalb des Normalbereichs (möglicher Luftstau)';
+        }
+        return 'Pumpe außerhalb des bekannten Bereichs';
+    },
+
+    /**
+     * Erzeugt Durchschnittswerte aus einem Array numerischer Werte.
+     *
+     * @param {number[]} arr - Wertearray
+     * @returns {number} - Durchschnittswert
+     */
+    _average(arr) {
+        if (!arr || arr.length === 0) {
+            return 0;
+        }
+        return arr.reduce((a, b) => a + b, 0) / arr.length;
+    },
+
+    /**
+     * Liest einen numerischen Statewert oder 0 bei Fehler.
+     *
+     * @param {string} id - Objekt-ID
+     * @returns {Promise<number>} - Gelesener Wert oder 0
+     */
+    async _getNumber(id) {
+        const state = await this.adapter.getStateAsync(id);
+        const val = Number(state?.val);
+        return isNaN(val) ? 0 : val;
+    },
+
+    /**
+     * Cleanup bei Adapter-Unload
+     */
+    cleanup() {
+        this.currentSessionValues = { power: [], flow: [] };
+        this.adapter?.log.debug('[pumpHelper3] Cleanup ausgeführt.');
+    },
+};
+
+module.exports = pumpHelper3;

package/lib/helpers/runtimeHelper.js

@@ -135,14 +135,24 @@ const runtimeHelper = {
             await this.adapter.setStateAsync('runtime.start_count_today', { val: this.startCountToday, ack: true });
 
             // Umwälzmenge berechnen
-            const pumpLph = (await this.adapter.getStateAsync('pump.pump_power_lph'))?.val || 0;
+            // Reeller Durchflusswert aus pump.live.flow_current_lh
+            const liveFlowLh = (await this.adapter.getStateAsync('pump.live.flow_current_lh'))?.val || 0;
+
+            if (liveFlowLh <= 0) {
+                this.adapter.log.debug('[runtimeHelper] Kein Live-Durchflusswert vorhanden, Berechnung übersprungen');
+                return;
+            }
+
+            // Poolparameter laden
             const poolSize = (await this.adapter.getStateAsync('general.pool_size'))?.val || 0;
             const minCirc = (await this.adapter.getStateAsync('general.min_circulation_per_day'))?.val || 1;
 
-            const dailyTotal = Math.round((effectiveToday / 3600) * pumpLph);
+            // Berechnung der realen Tagesumwälzung (Liter)
+            const dailyTotal = Math.round((effectiveToday / 3600) * liveFlowLh);
             const dailyRequired = Math.round(poolSize * minCirc);
             const dailyRemaining = Math.max(dailyRequired - dailyTotal, 0);
 
+            // Werte schreiben
             await this.adapter.setStateAsync('circulation.daily_total', { val: dailyTotal, ack: true });
             await this.adapter.setStateAsync('circulation.daily_required', { val: dailyRequired, ack: true });
             await this.adapter.setStateAsync('circulation.daily_remaining', { val: dailyRemaining, ack: true });