iobroker.poolcontrol 0.2.2 → 0.3.0

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

package/lib/stateDefinitions/controlStates.js

@@ -36,7 +36,7 @@ async function createControlStates(adapter) {
             native: {},
         });
 
-        // State: control.season.active
+        // State: control.season.active (mit Persist-Schutz)
         await adapter.setObjectNotExistsAsync('control.season.active', {
             type: 'state',
             common: {
@@ -47,15 +47,21 @@ async function createControlStates(adapter) {
                 read: true,
                 write: true,
                 def: false,
+                persist: true, // dauerhaft speichern
             },
             native: {},
         });
 
-        // Initialwert aus der Instanzkonfiguration übernehmen
-        const cfgValue = !!adapter.config.season_active;
-        await adapter.setStateAsync('control.season.active', { val: cfgValue, ack: true });
-
-        adapter.log.debug(`[controlStates] State control.season.active initialisiert mit Wert: ${cfgValue}`);
+        const existingSeasonActive = await adapter.getStateAsync('control.season.active');
+        if (
+            existingSeasonActive === null ||
+            existingSeasonActive.val === null ||
+            existingSeasonActive.val === undefined
+        ) {
+            const cfgValue = !!adapter.config.season_active;
+            await adapter.setStateAsync('control.season.active', { val: cfgValue, ack: true });
+            adapter.log.debug(`[controlStates] State control.season.active initialisiert mit Wert: ${cfgValue}`);
+        }
 
         // ---------------------------------------------------------------------
         // Channel: control.pump
@@ -100,7 +106,7 @@ async function createControlStates(adapter) {
         });
         await adapter.setStateAsync('control.pump.backwash_active', { val: false, ack: true });
 
-        // Rückspülungsdauer
+        // Rückspülungsdauer (mit Persist-Schutz)
         await adapter.setObjectNotExistsAsync('control.pump.backwash_duration', {
             type: 'state',
             common: {
@@ -113,12 +119,20 @@ async function createControlStates(adapter) {
                 def: 1,
                 min: 1,
                 max: 60,
+                persist: true, // dauerhaft speichern
             },
             native: {},
         });
-        await adapter.setStateAsync('control.pump.backwash_duration', { val: 1, ack: true });
+        const existingBackwashDuration = await adapter.getStateAsync('control.pump.backwash_duration');
+        if (
+            existingBackwashDuration === null ||
+            existingBackwashDuration.val === null ||
+            existingBackwashDuration.val === undefined
+        ) {
+            await adapter.setStateAsync('control.pump.backwash_duration', { val: 1, ack: true });
+        }
 
-        // >>> NEU: Rückspülerinnerung
+        // Rückspülerinnerung aktiv (mit Persist-Schutz)
         await adapter.setObjectNotExistsAsync('control.pump.backwash_reminder_active', {
             type: 'state',
             common: {
@@ -129,11 +143,16 @@ async function createControlStates(adapter) {
                 read: true,
                 write: true,
                 def: false,
+                persist: true, // dauerhaft speichern
             },
             native: {},
         });
-        await adapter.setStateAsync('control.pump.backwash_reminder_active', { val: false, ack: true });
+        const existingBackwashRem = await adapter.getStateAsync('control.pump.backwash_reminder_active');
+        if (existingBackwashRem === null || existingBackwashRem.val === null || existingBackwashRem.val === undefined) {
+            await adapter.setStateAsync('control.pump.backwash_reminder_active', { val: false, ack: true });
+        }
 
+        // Rückspülintervall (mit Persist-Schutz)
         await adapter.setObjectNotExistsAsync('control.pump.backwash_interval_days', {
             type: 'state',
             common: {
@@ -147,10 +166,18 @@ async function createControlStates(adapter) {
                 def: 7,
                 min: 1,
                 max: 60,
+                persist: true, // dauerhaft speichern
             },
             native: {},
         });
-        await adapter.setStateAsync('control.pump.backwash_interval_days', { val: 7, ack: true });
+        const existingBackwashInterval = await adapter.getStateAsync('control.pump.backwash_interval_days');
+        if (
+            existingBackwashInterval === null ||
+            existingBackwashInterval.val === null ||
+            existingBackwashInterval.val === undefined
+        ) {
+            await adapter.setStateAsync('control.pump.backwash_interval_days', { val: 7, ack: true });
+        }
 
         await adapter.setObjectNotExistsAsync('control.pump.backwash_last_date', {
             type: 'state',
@@ -181,7 +208,6 @@ async function createControlStates(adapter) {
         });
         await adapter.setStateAsync('control.pump.backwash_required', { val: false, ack: true });
 
-        // ---------------------------------------------------------------------
         // Wartungsmodus aktiv
         await adapter.setObjectNotExistsAsync('control.pump.maintenance_active', {
             type: 'state',
@@ -198,7 +224,7 @@ async function createControlStates(adapter) {
         });
         await adapter.setStateAsync('control.pump.maintenance_active', { val: false, ack: true });
 
-        // Benachrichtigungen aktivieren
+        // Benachrichtigungen aktivieren (mit Persist-Schutz)
         await adapter.setObjectNotExistsAsync('control.pump.notifications_enabled', {
             type: 'state',
             common: {
@@ -209,10 +235,14 @@ async function createControlStates(adapter) {
                 read: true,
                 write: true,
                 def: true,
+                persist: true, // dauerhaft speichern
             },
             native: {},
         });
-        await adapter.setStateAsync('control.pump.notifications_enabled', { val: true, ack: true });
+        const existingNoti = await adapter.getStateAsync('control.pump.notifications_enabled');
+        if (existingNoti === null || existingNoti.val === null || existingNoti.val === undefined) {
+            await adapter.setStateAsync('control.pump.notifications_enabled', { val: true, ack: true });
+        }
 
         // ---------------------------------------------------------------------
         // Channel: control.energy
@@ -252,7 +282,7 @@ async function createControlStates(adapter) {
             native: {},
         });
 
-        // State: Modus (auto/manual/notify/off)
+        // Modus der Umwälzungsprüfung
         await adapter.setObjectNotExistsAsync('control.circulation.mode', {
             type: 'state',
             common: {
@@ -263,6 +293,7 @@ async function createControlStates(adapter) {
                 read: true,
                 write: true,
                 def: 'notify',
+                persist: true,
                 states: {
                     auto: 'Automatik',
                     manual: 'Manuell',
@@ -272,9 +303,14 @@ async function createControlStates(adapter) {
             },
             native: {},
         });
+        try {
+            await adapter.extendObjectAsync('control.circulation.mode', { common: { persist: true } });
+        } catch (err) {
+            adapter.log.warn(`[controlStates] persist-Flag für control.circulation.mode nicht gesetzt: ${err.message}`);
+        }
         await adapter.setStateAsync('control.circulation.mode', { val: 'notify', ack: true });
 
-        // State: Prüfzeitpunkt
+        // Prüfzeitpunkt (mit Persist-Schutz)
         await adapter.setObjectNotExistsAsync('control.circulation.check_time', {
             type: 'state',
             common: {
@@ -285,12 +321,16 @@ async function createControlStates(adapter) {
                 read: true,
                 write: true,
                 def: '18:00',
+                persist: true, // dauerhaft speichern
             },
             native: {},
         });
-        await adapter.setStateAsync('control.circulation.check_time', { val: '18:00', ack: true });
+        const existingCheckTime = await adapter.getStateAsync('control.circulation.check_time');
+        if (existingCheckTime === null || existingCheckTime.val === null || existingCheckTime.val === undefined) {
+            await adapter.setStateAsync('control.circulation.check_time', { val: '18:00', ack: true });
+        }
 
-        // State: letzter Bericht
+        // letzter Bericht
         await adapter.setObjectNotExistsAsync('control.circulation.last_report', {
             type: 'state',
             common: {

package/lib/stateDefinitions/pumpStates.js

@@ -98,7 +98,7 @@ async function createPumpStates(adapter) {
     });
     await adapter.setStateAsync('pump.pump_switch', { val: false, ack: true });
 
-    // Pumpenmodus
+    // Pumpenmodus (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('pump.mode', {
         type: 'state',
         common: {
@@ -107,6 +107,7 @@ async function createPumpStates(adapter) {
             role: 'state',
             read: true,
             write: true,
+            persist: true, // NEU: dauerhaft speichern
             states: {
                 auto: 'Automatik',
                 manual: 'Manuell',
@@ -116,9 +117,14 @@ async function createPumpStates(adapter) {
         },
         native: {},
     });
-    await adapter.setStateAsync('pump.mode', { val: 'auto', ack: true });
 
-    // Sicherheitslogik im manuellen Modus
+    // Prüfen, ob bereits ein Wert vorhanden ist
+    const existingPumpMode = await adapter.getStateAsync('pump.mode');
+    if (existingPumpMode === null || existingPumpMode.val === null || existingPumpMode.val === undefined) {
+        await adapter.setStateAsync('pump.mode', { val: 'auto', ack: true });
+    }
+
+    // Sicherheitslogik im manuellen Modus (mit Persist-Schutz)
     await adapter.setObjectNotExistsAsync('pump.manual_safety_enabled', {
         type: 'state',
         common: {
@@ -127,13 +133,19 @@ async function createPumpStates(adapter) {
             role: 'switch',
             read: true,
             write: true,
+            persist: true, // NEU: dauerhaft speichern
         },
         native: {},
     });
-    await adapter.setStateAsync('pump.manual_safety_enabled', {
-        val: adapter.config.manual_safety_enabled ?? true,
-        ack: true,
-    });
+
+    // Prüfen, ob bereits ein persistierter Wert vorhanden ist
+    const existingSafety = await adapter.getStateAsync('pump.manual_safety_enabled');
+    if (existingSafety === null || existingSafety.val === null || existingSafety.val === undefined) {
+        await adapter.setStateAsync('pump.manual_safety_enabled', {
+            val: adapter.config.manual_safety_enabled ?? true,
+            ack: true,
+        });
+    }
 
     // Pumpenstatus (Text)
     await adapter.setObjectNotExistsAsync('pump.status', {
@@ -196,6 +208,20 @@ async function createPumpStates(adapter) {
         native: {},
     });
     await adapter.setStateAsync('pump.current_power', { val: 0, ack: true });
+
+    await adapter.setObjectNotExistsAsync('pump.reason', {
+        type: 'state',
+        common: {
+            name: 'Grund für aktuellen Pumpenstatus',
+            desc: 'Wird intern verwendet, um den Grund des aktuellen Pumpenstatus zu speichern (z. B. Rückspülen, Wartung, Nachpumpen)',
+            type: 'string',
+            role: 'text',
+            read: true,
+            write: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.reason', { val: '', ack: true });
 }
 
 module.exports = {

package/lib/stateDefinitions/pumpStates2.js

@@ -0,0 +1,125 @@
+'use strict';
+
+/**
+ * pumpStates2.js
+ * ----------------------------------------------------------
+ * Legt die erweiterten States für Pumpen-Livewerte an.
+ *
+ * Diese Datei ergänzt die bestehenden pumpStates.js um
+ * reelle Durchflussberechnung und Leistungsdaten.
+ *
+ * Ordnerstruktur:
+ * pump.live.*
+ *  ├── current_power_w      (W)   - aktuelle Leistung
+ *  ├── flow_current_lh      (L/h) - reell berechneter Durchfluss
+ *  ├── flow_percent         (%)   - aktuelle Auslastung
+ *  ├── last_flow_lh         (L/h) - letzter bekannter Durchfluss
+ *
+ * Alle States sind persistent und bleiben über Updates erhalten.
+ * ----------------------------------------------------------
+ * Version: 1.0.0
+ */
+
+/**
+ * Erstellt die erweiterten Pumpen-Live-States.
+ *
+ * @param {import("iobroker").Adapter} adapter - Aktive ioBroker Adapterinstanz
+ * @returns {Promise<void>}
+ */
+async function createPumpStates2(adapter) {
+    // ------------------------------------------------------
+    // Root-Kanal: pump.live
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.live', {
+        type: 'channel',
+        common: {
+            name: 'Pumpen-Livewerte (aktuelle Betriebsdaten)',
+        },
+        native: {},
+    });
+
+    // ------------------------------------------------------
+    // Aktuelle Leistung (W)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.live.current_power_w', {
+        type: 'state',
+        common: {
+            name: 'Aktuelle elektrische Leistung',
+            desc: 'Momentane Leistungsaufnahme der Pumpe (Watt)',
+            type: 'number',
+            role: 'value.power',
+            unit: 'W',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.live.current_power_w', { val: 0, ack: true });
+
+    // ------------------------------------------------------
+    // Reell berechneter Durchfluss (L/h)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.live.flow_current_lh', {
+        type: 'state',
+        common: {
+            name: 'Aktueller reeller Durchfluss',
+            desc: 'Berechnete Umwälzleistung basierend auf aktueller Leistung',
+            type: 'number',
+            role: 'value.flow',
+            unit: 'l/h',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.live.flow_current_lh', { val: 0, ack: true });
+
+    // ------------------------------------------------------
+    // Prozentuale Auslastung (%)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.live.flow_percent', {
+        type: 'state',
+        common: {
+            name: 'Aktuelle Pumpenauslastung (%)',
+            desc: 'Aktuelle Pumpenleistung in Prozent der maximalen Leistung',
+            type: 'number',
+            role: 'value.percent',
+            unit: '%',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.live.flow_percent', { val: 0, ack: true });
+
+    // ------------------------------------------------------
+    // Letzter bekannter Durchfluss (L/h)
+    // ------------------------------------------------------
+    await adapter.setObjectNotExistsAsync('pump.live.last_flow_lh', {
+        type: 'state',
+        common: {
+            name: 'Letzter bekannter Durchfluss',
+            desc: 'Speichert den letzten berechneten Durchflusswert vor Pumpenstopp',
+            type: 'number',
+            role: 'value.flow',
+            unit: 'l/h',
+            read: true,
+            write: false,
+            persist: true,
+        },
+        native: {},
+    });
+    await adapter.setStateAsync('pump.live.last_flow_lh', { val: 0, ack: true });
+
+    // ------------------------------------------------------
+    // Abschluss-Logeintrag
+    // ------------------------------------------------------
+    adapter.log.debug('[pumpStates2] Live-State-Definitionen erstellt oder geprüft.');
+}
+
+module.exports = {
+    createPumpStates2,
+};