iobroker.poolcontrol 0.3.0 → 0.4.0-alpha

package/lib/helpers/runtimeHelper.js

@@ -21,9 +21,24 @@ const runtimeHelper = {
     resetTimer: null,
     liveTimer: null, // Timer für Live-Updates
 
-    init(adapter) {
+    /**
+     * Initialisiert den Runtime-Helper.
+     * Führt eine kurze Startverzögerung ein, um sicherzustellen,
+     * dass persistente States nach einer Überinstallation korrekt geladen werden.
+     *
+     * @param {ioBroker.Adapter} adapter - Aktive ioBroker-Adapterinstanz.
+     * @returns {Promise<void>}
+     */
+    async init(adapter) {
         this.adapter = adapter;
 
+        // ------------------------------------------------------
+        // NEU: Kurze Startverzögerung, damit ioBroker persistente States
+        //      vollständig aus der Datenbank laden kann (Überinstallationsschutz)
+        // ------------------------------------------------------
+        this.adapter.log.debug('[runtimeHelper] Warte 3 Sekunden, um persistente States zu laden ...');
+        await new Promise(resolve => setTimeout(resolve, 3000));
+
         // Pumpenschalter überwachen
         this.adapter.subscribeStates('pump.pump_switch');
 
@@ -52,6 +67,13 @@ const runtimeHelper = {
         const seasonRaw = (await this.adapter.getStateAsync('runtime.season_total'))?.val;
         const countRaw = (await this.adapter.getStateAsync('runtime.start_count_today'))?.val;
 
+        // FIX: Falls States leer oder neu angelegt sind, Warnhinweis ausgeben und Werte nicht überschreiben
+        if (!totalRaw && !seasonRaw) {
+            this.adapter.log.info(
+                '[runtimeHelper] Keine gespeicherten Laufzeiten gefunden – möglicherweise neue oder überinstallierte Instanz. Laufzeiten starten bei 0.',
+            );
+        }
+
         // >>> NEU: Formatierten Text (z. B. "3h 12m 5s") in Sekunden umwandeln
         this.runtimeTotal = this._parseFormattedTimeToSeconds(totalRaw);
         this.runtimeToday = this._parseFormattedTimeToSeconds(todayRaw);
@@ -72,38 +94,72 @@ const runtimeHelper = {
             return;
         }
 
+        // FIX: Robuste Start-/Stop-Logik für pump.pump_switch
         if (id.endsWith('pump.pump_switch')) {
-            if (state.val && !this.isRunning) {
-                // Pumpe startet
-                this.isRunning = true;
-                this.lastOn = Date.now();
-                this.startCountToday += 1;
-
-                // Live-Timer starten (jede Minute)
-                this._startLiveTimer();
-
-                // Start sofort in State schreiben
-                await this.adapter.setStateAsync('runtime.start_count_today', { val: this.startCountToday, ack: true });
-            } else if (!state.val && this.isRunning) {
-                // Pumpe stoppt
-                const delta = Math.floor((Date.now() - this.lastOn) / 1000);
-                this.runtimeToday += delta;
-                this.runtimeTotal += delta;
-
-                // Saisonlaufzeit nur zählen, wenn aktiv
-                const seasonActive = !!(await this.adapter.getStateAsync('control.season.active'))?.val;
-                if (seasonActive) {
-                    this.runtimeSeason += delta;
+            if (state.val) {
+                // FIX: Immer starten, wenn Pumpe an ist (egal welcher Helper)
+                if (!this.isRunning || !this.lastOn) {
+                    this.isRunning = true;
+                    this.lastOn = Date.now();
+                    this.startCountToday += 1;
+
+                    // Live-Timer starten (jede Minute)
+                    this._startLiveTimer();
+
+                    // Start sofort in State schreiben
+                    await this.adapter.setStateAsync('runtime.start_count_today', {
+                        val: this.startCountToday,
+                        ack: true,
+                    });
+
+                    // ------------------------------------------------------
+                    // Statuswerte bei Pumpenstart setzen
+                    // ------------------------------------------------------
+                    const nowStr = new Date().toLocaleString();
+                    await this.adapter.setStateAsync('status.pump_last_start', { val: nowStr, ack: true });
+                    await this.adapter.setStateAsync('status.pump_today_count', {
+                        val: this.startCountToday,
+                        ack: true,
+                    });
+                    await this.adapter.setStateAsync('status.pump_was_on_today', { val: true, ack: true });
+                    // ------------------------------------------------------
+                    this.adapter.log.debug('[runtimeHelper] Pumpenlaufzeit gestartet.');
+                }
+            } else {
+                // FIX: Immer sauber stoppen, wenn Pumpe aus ist
+                if (this.isRunning && this.lastOn) {
+                    const delta = Math.floor((Date.now() - this.lastOn) / 1000);
+                    this.runtimeToday += delta;
+                    this.runtimeTotal += delta;
+
+                    // Saisonlaufzeit nur zählen, wenn aktiv
+                    const seasonActive = !!(await this.adapter.getStateAsync('control.season.active'))?.val;
+                    if (seasonActive) {
+                        this.runtimeSeason += delta;
+                    }
+
+                    this.isRunning = false;
+                    this.lastOn = null;
+
+                    // Live-Timer stoppen
+                    this._stopLiveTimer();
+
+                    // States final aktualisieren
+                    await this._updateStates();
+
+                    // ------------------------------------------------------
+                    // Statuswert bei Pumpenstopp setzen
+                    // ------------------------------------------------------
+                    const nowStr = new Date().toLocaleString();
+                    await this.adapter.setStateAsync('status.pump_last_stop', { val: nowStr, ack: true });
+                    // ------------------------------------------------------
+                    this.adapter.log.debug('[runtimeHelper] Pumpenlaufzeit gestoppt.');
+                } else {
+                    // FIX: Falls Pumpe aus, aber kein aktiver Lauf (z. B. Neustart) → nur Timer sicher stoppen
+                    this._stopLiveTimer();
+                    this.isRunning = false;
+                    this.lastOn = null;
                 }
-
-                this.isRunning = false;
-                this.lastOn = null;
-
-                // Live-Timer stoppen
-                this._stopLiveTimer();
-
-                // States final aktualisieren
-                await this._updateStates();
             }
         }
     },
@@ -134,6 +190,16 @@ const runtimeHelper = {
             await this.adapter.setStateAsync('runtime.season_total', { val: formattedSeason, ack: true });
             await this.adapter.setStateAsync('runtime.start_count_today', { val: this.startCountToday, ack: true });
 
+            // Poolparameter laden (vor Durchflussprüfung!)
+            const poolSize = (await this.adapter.getStateAsync('general.pool_size'))?.val || 0;
+            const minCirc = (await this.adapter.getStateAsync('general.min_circulation_per_day'))?.val || 1;
+
+            // daily_required immer direkt setzen – auch ohne Durchfluss
+            const dailyRequired = Math.round(poolSize * minCirc);
+            if (dailyRequired > 0) {
+                await this.adapter.setStateAsync('circulation.daily_required', { val: dailyRequired, ack: true });
+            }
+
             // Umwälzmenge berechnen
             // Reeller Durchflusswert aus pump.live.flow_current_lh
             const liveFlowLh = (await this.adapter.getStateAsync('pump.live.flow_current_lh'))?.val || 0;
@@ -143,19 +209,26 @@ const runtimeHelper = {
                 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;
-
             // 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 });
+            // Bestehende Werte für Total/Remaining laden
+            const oldTotal = (await this.adapter.getStateAsync('circulation.daily_total'))?.val || 0;
+            const oldRemaining = (await this.adapter.getStateAsync('circulation.daily_remaining'))?.val || 0;
+
+            // Nur schreiben, wenn tatsächlich sinnvolle Livewerte vorliegen
+            if (liveFlowLh > 0 && dailyTotal > 0) {
+                await this.adapter.setStateAsync('circulation.daily_total', { val: dailyTotal, ack: true });
+                await this.adapter.setStateAsync('circulation.daily_remaining', { val: dailyRemaining, ack: true });
+                this.adapter.log.debug(
+                    `[runtimeHelper] Circulation-Werte aktualisiert (Total=${dailyTotal}, Required=${dailyRequired}, Remaining=${dailyRemaining})`,
+                );
+            } else {
+                this.adapter.log.debug(
+                    `[runtimeHelper] Keine gültigen Live-Daten – bestehende Werte bleiben erhalten (Total=${oldTotal}, Required=${dailyRequired}, Remaining=${oldRemaining})`,
+                );
+            }
         } catch (err) {
             this.adapter.log.warn(`[runtimeHelper] Fehler beim Update der States: ${err.message}`);
         }
@@ -204,12 +277,37 @@ const runtimeHelper = {
         nextMidnight.setHours(24, 0, 0, 0);
         const msUntilMidnight = nextMidnight - now;
 
-        this.resetTimer = setTimeout(() => {
+        this.resetTimer = setTimeout(async () => {
             this.runtimeToday = 0;
             this.startCountToday = 0;
             this.lastOn = this.isRunning ? Date.now() : null;
+
+            // Laufzeiten zurücksetzen
             this._updateStates();
+
+            // --- NEU: Circulation-Werte um Mitternacht zurücksetzen ---
+            await this.adapter.setStateAsync('circulation.daily_total', { val: 0, ack: true });
+
+            // daily_required neu berechnen (optional, falls sich Poolgröße geändert hat)
+            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 dailyRequired = Math.round(poolSize * minCirc);
+            await this.adapter.setStateAsync('circulation.daily_required', { val: dailyRequired, ack: true });
+
+            // 👉 daily_remaining neue berechnen auf Grundlage von daily_required
+            await this.adapter.setStateAsync('circulation.daily_remaining', { val: dailyRequired, ack: true });
+
+            // ------------------------------------------------------
+            // NEU: Pumpenstatuswerte um Mitternacht zurücksetzen
+            // ------------------------------------------------------
+            await this.adapter.setStateAsync('status.pump_today_count', { val: 0, ack: true });
+            await this.adapter.setStateAsync('status.pump_was_on_today', { val: false, ack: true });
+            // ------------------------------------------------------
+
+            // Nächsten Reset planen
             this._scheduleDailyReset();
+
+            this.adapter.log.debug('[runtimeHelper] Tagesreset (Runtime + Circulation) ausgeführt.');
         }, msUntilMidnight);
     },
 
@@ -217,8 +315,8 @@ const runtimeHelper = {
         if (this.liveTimer) {
             clearInterval(this.liveTimer);
         }
-        this.liveTimer = setInterval(() => this._updateStates(), 60 * 1000);
-        this.adapter.log.debug('[runtimeHelper] Live-Timer gestartet (Updates jede Minute)');
+        this.liveTimer = setInterval(() => this._updateStates(), 10 * 1000);
+        this.adapter.log.debug('[runtimeHelper] Live-Timer gestartet (Updates alle 10 Sekunden)');
     },
 
     _stopLiveTimer() {