iobroker.poolcontrol 0.2.1 → 0.3.0

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 });

package/lib/helpers/solarHelper.js

@@ -33,8 +33,8 @@ const solarHelper = {
     async _checkSolar() {
         try {
             // --- NEU: Vorrangprüfung durch ControlHelper ---
-            const pumpStatus = (await this.adapter.getStateAsync('pump.status'))?.val || '';
-            if (pumpStatus.includes('controlHelper')) {
+            const activeHelper = (await this.adapter.getStateAsync('pump.active_helper'))?.val || '';
+            if (activeHelper === 'controlHelper') {
                 this.adapter.log.debug('[solarHelper] Vorrang durch ControlHelper aktiv – Solarregelung pausiert.');
                 return;
             }

package/lib/helpers/statusHelper.js

@@ -12,6 +12,7 @@ const statusHelper = {
     adapter: null,
     midnightTimer: null,
     pumpOn: null, // interner Merker für Pumpenstatus
+    _lastSummaryUpdate: 0, // FIX: Zeitstempel für Throttle-Schutz
 
     init(adapter) {
         this.adapter = adapter;
@@ -95,8 +96,23 @@ const statusHelper = {
         await this.updateSummary();
     },
 
+    // FIX: Hilfsfunktion zur sicheren Formatierung
+    safeValue(v, digits = 1) {
+        if (v == null || isNaN(v)) {
+            return '–';
+        }
+        return Number(v).toFixed(digits);
+    },
+
     async updateSummary() {
         try {
+            // FIX: Throttle - Mehrfachupdates innerhalb 1 Sekunde vermeiden
+            if (Date.now() - this._lastSummaryUpdate < 1000) {
+                this.adapter.log.debug('[statusHelper] UpdateSummary übersprungen (Throttle)');
+                return;
+            }
+            this._lastSummaryUpdate = Date.now();
+
             // Werte laden
             const pumpStatus = (await this.adapter.getStateAsync('pump.status'))?.val || 'unbekannt';
             const pumpMode = (await this.adapter.getStateAsync('pump.mode'))?.val || 'unknown';
@@ -112,32 +128,41 @@ const statusHelper = {
             // Laufzeit formatieren
             const h = Math.floor(runtimeToday / 3600);
             const m = Math.floor((runtimeToday % 3600) / 60);
-            const runtimeFormatted = `${h}h ${m}m`;
+            const runtimeFormatted = isNaN(h) || isNaN(m) ? '0h 00m' : `${h}h ${m}m`; // FIX: Schutz gegen NaN
 
             // Umwälzungsquote
             let circulationPct = 0;
             if (dailyRequired > 0) {
                 circulationPct = Math.round((dailyTotal / dailyRequired) * 100);
             }
+            if (isNaN(circulationPct)) {
+                circulationPct = 0;
+            } // FIX: NaN-Absicherung
 
             // Text bauen
             let text = `Pumpe: ${pumpStatus}`;
             if (pumpMode && pumpMode !== 'unknown') {
                 text += ` (Modus: ${pumpMode})`;
             }
+
+            const safe = this.safeValue.bind(this); // FIX: Kurzreferenz
             if (poolTemp != null) {
-                text += `. Pool: ${poolTemp.toFixed(1)} °C`;
+                text += `. Pool: ${safe(poolTemp)} °C`;
             }
             if (collectorTemp != null) {
-                text += `, Kollektor: ${collectorTemp.toFixed(1)} °C`;
+                text += `, Kollektor: ${safe(collectorTemp)} °C`;
             }
             if (outsideTemp != null) {
-                text += `, Außentemperatur: ${outsideTemp.toFixed(1)} °C`;
+                text += `, Außentemperatur: ${safe(outsideTemp)} °C`;
             }
             text += `. Tageslaufzeit: ${runtimeFormatted} (${circulationPct}% der Soll-Umwälzung).`;
 
-            // In States schreiben
-            await this.adapter.setStateAsync('status.summary', { val: text, ack: true });
+            // In States schreiben (nur bei Änderung)
+            const current = (await this.adapter.getStateAsync('status.summary'))?.val;
+            if (current !== text) {
+                await this.adapter.setStateAsync('status.summary', { val: text, ack: true });
+            }
+
             await this.adapter.setStateAsync('status.last_summary_update', {
                 val: new Date().toISOString(),
                 ack: true,
@@ -147,10 +172,10 @@ const statusHelper = {
             const json = {
                 pump: pumpStatus,
                 mode: pumpMode,
-                pool: poolTemp,
-                collector: collectorTemp,
-                outside: outsideTemp,
-                runtime_today: runtimeToday,
+                pool: poolTemp ?? null,
+                collector: collectorTemp ?? null,
+                outside: outsideTemp ?? null,
+                runtime_today: runtimeToday ?? 0,
                 runtime_formatted: runtimeFormatted,
                 circulation_pct: circulationPct,
             };