iobroker.poolcontrol 0.1.1 → 0.2.0

package/lib/helpers/debugLogHelper.js

@@ -0,0 +1,193 @@
+'use strict';
+
+/**
+ * debugLogHelper (SystemCheck-Version)
+ * - Überwacht nur einen auswählbaren Bereich (z. B. pump.*, solar.*, runtime.*)
+ * - Loggt Änderungen fortlaufend in SystemCheck.debug_logs.log
+ * - Kann per SystemCheck.debug_logs.clear geleert werden
+ * - target_area wird automatisch erkannt (dynamisch durch States-Datei)
+ */
+
+const debugLogHelper = {
+    adapter: null,
+    currentTarget: 'none',
+    subscribedTarget: null,
+    lastChange: {},
+    thresholdMs: 2000, // Mindestzeit zwischen Änderungen (ms)
+    buffer: '',
+    bufferTimer: null,
+
+    /**
+     * Initialisierung des Debug-Helpers.
+     *
+     * @param {import('iobroker').Adapter} adapter - ioBroker Adapter-Instanz
+     */
+    async init(adapter) {
+        this.adapter = adapter;
+
+        // --- SystemCheck-Ordner sicherstellen ---
+        await this.adapter.setObjectNotExistsAsync('SystemCheck', {
+            type: 'channel',
+            common: { name: 'SystemCheck (Diagnose und Tools)' },
+            native: {},
+        });
+
+        // States für clear und target_area überwachen
+        adapter.subscribeStates('SystemCheck.debug_logs.clear');
+        adapter.subscribeStates('SystemCheck.debug_logs.target_area');
+
+        // Initialwert für target_area lesen
+        const target = (await adapter.getStateAsync('SystemCheck.debug_logs.target_area'))?.val || 'none';
+        this.currentTarget = target;
+        if (target !== 'none') {
+            this._subscribeTarget(target);
+        } else {
+            adapter.log.info('[debugLogHelper] Kein Bereich ausgewählt – Logger inaktiv.');
+        }
+
+        adapter.log.info('[debugLogHelper] Initialisierung abgeschlossen');
+    },
+
+    /**
+     * Reagiert auf State-Änderungen
+     *
+     * @param {string} id - State-ID
+     * @param {ioBroker.State} state - State-Wert
+     */
+    async handleStateChange(id, state) {
+        if (!this.adapter || !state) {
+            return;
+        }
+
+        // Umschalten des überwachten Bereichs
+        if (id.endsWith('SystemCheck.debug_logs.target_area')) {
+            const newTarget = state.val || 'none';
+            await this._switchTarget(newTarget);
+            return;
+        }
+
+        // Clear-Button
+        if (id.endsWith('SystemCheck.debug_logs.clear') && state.val === true) {
+            await this._clearLog();
+            await this.adapter.setStateAsync('SystemCheck.debug_logs.clear', { val: false, ack: true });
+            return;
+        }
+
+        // Nur loggen, wenn der Bereich aktiv ist
+        if (!this.subscribedTarget || this.subscribedTarget === 'none') {
+            return;
+        }
+
+        // Nur Events aus dem überwachten Bereich aufnehmen
+        if (!id.includes(`.${this.subscribedTarget}.`)) {
+            return;
+        }
+
+        const now = Date.now();
+        const last = this.lastChange[id] || 0;
+        this.lastChange[id] = now;
+
+        if (now - last < this.thresholdMs) {
+            const msg = `[${new Date().toISOString()}] ${id} änderte sich zu schnell (${now - last} ms, val=${state.val}, ack=${state.ack})\n`;
+            await this._appendLog(msg);
+        }
+    },
+
+    /**
+     * Wechselt den aktiven Überwachungsbereich
+     *
+     * @param {string} newTarget - Name des neuen Bereichs (z.B. "pump", "solar", oder "none")
+     */
+    async _switchTarget(newTarget) {
+        if (this.subscribedTarget === newTarget) {
+            return;
+        }
+        if (this.subscribedTarget && this.subscribedTarget !== 'none') {
+            this.adapter.unsubscribeStates(`${this.subscribedTarget}.*`);
+            this.adapter.log.info(`[debugLogHelper] Überwachung für Bereich "${this.subscribedTarget}" beendet.`);
+        }
+
+        this.subscribedTarget = newTarget;
+
+        if (newTarget === 'none') {
+            this.adapter.log.info('[debugLogHelper] Kein Bereich aktiv.');
+            return;
+        }
+
+        this._subscribeTarget(newTarget);
+        this.adapter.log.info(`[debugLogHelper] Überwachung für Bereich "${newTarget}" gestartet.`);
+        await this._appendLog(
+            `\n=== Debug-Log gestartet: Bereich "${newTarget}" @ ${new Date().toLocaleString()} ===\n`,
+        );
+    },
+
+    /**
+     * Abonniert States für den angegebenen Bereich
+     *
+     * @param {string} target - Name des zu überwachenden Bereichs
+     */
+    _subscribeTarget(target) {
+        this.adapter.subscribeStates(`${target}.*`);
+        this.subscribedTarget = target;
+    },
+
+    /**
+     * Log anhängen (fortlaufend)
+     *
+     * @param {string} message - Text, der in das fortlaufende Log geschrieben wird
+     */
+    async _appendLog(message) {
+        try {
+            this.buffer += message;
+
+            // Schreibe alle 5 Sekunden oder ab 2 KB
+            if (this.buffer.length > 2000) {
+                await this._flushBuffer();
+            } else if (!this.bufferTimer) {
+                this.bufferTimer = setTimeout(() => this._flushBuffer(), 5000);
+            }
+        } catch (err) {
+            this.adapter.log.warn(`[debugLogHelper] Fehler beim Anhängen an Log: ${err.message}`);
+        }
+    },
+
+    async _flushBuffer() {
+        try {
+            if (!this.buffer) {
+                return;
+            }
+            const current = (await this.adapter.getStateAsync('SystemCheck.debug_logs.log'))?.val || '';
+            const newVal = current + this.buffer;
+            await this.adapter.setStateAsync('SystemCheck.debug_logs.log', {
+                val: newVal.slice(-60000),
+                ack: true,
+            }); // max ~60k Zeichen
+            this.buffer = '';
+            this.bufferTimer = null;
+        } catch (err) {
+            this.adapter.log.warn(`[debugLogHelper] Fehler beim Schreiben in Log: ${err.message}`);
+        }
+    },
+
+    /**
+     * Löscht das Log komplett
+     */
+    async _clearLog() {
+        try {
+            await this.adapter.setStateAsync('SystemCheck.debug_logs.log', { val: '', ack: true });
+            this.buffer = '';
+            this.adapter.log.info('[debugLogHelper] Debug-Log gelöscht');
+        } catch (err) {
+            this.adapter.log.warn(`[debugLogHelper] Fehler beim Löschen des Logs: ${err.message}`);
+        }
+    },
+
+    cleanup() {
+        if (this.bufferTimer) {
+            clearTimeout(this.bufferTimer);
+        }
+        this.adapter.log.debug('[debugLogHelper] Cleanup ausgeführt');
+    },
+};
+
+module.exports = debugLogHelper;

package/lib/helpers/pumpHelper.js

@@ -13,6 +13,8 @@ const pumpHelper = {
     adapter: null,
     deviceId: null, // Objekt-ID der echten Steckdose (aus Config)
     currentPowerId: null, // Fremd-State für Leistung (aus Config)
+    _lastPumpStart: null, // Zeitstempel letzter Start
+    _lastPumpStop: null, // Zeitstempel letzter Stopp
 
     init(adapter) {
         this.adapter = adapter;
@@ -134,6 +136,13 @@ const pumpHelper = {
                         ack: false,
                     });
                 }
+
+                // Zeitstempel für Kulanzzeiten setzen
+                if (state.val === true) {
+                    this._lastPumpStart = Date.now();
+                } else {
+                    this._lastPumpStop = Date.now();
+                }
             }
 
             await this._updateStatus();
@@ -194,6 +203,22 @@ const pumpHelper = {
             const power = this._parseNumber((await this.adapter.getStateAsync('pump.current_power'))?.val);
             const maxWatt = this._parseNumber((await this.adapter.getStateAsync('pump.pump_max_watt'))?.val);
 
+            // --- NEU: Kulanzzeiten für Start/Stop ---
+            const graceOnMs = 5000; // 5 Sekunden nach Start ignorieren
+            const graceOffMs = 5000; // 5 Sekunden nach Stop ignorieren
+            const now = Date.now();
+
+            if (active === true && this._lastPumpStart && now - this._lastPumpStart < graceOnMs) {
+                this.adapter.log.debug('[pumpHelper] Innerhalb der Start-Kulanzzeit – Fehlerprüfung übersprungen');
+                return;
+            }
+
+            if (active === false && this._lastPumpStop && now - this._lastPumpStop < graceOffMs) {
+                this.adapter.log.debug('[pumpHelper] Innerhalb der Stopp-Kulanzzeit – Fehlerprüfung übersprungen');
+                return;
+            }
+            // --- Ende Kulanzzeiten ---
+
             let error = false;
             let errorMsg = '';
 

package/lib/helpers/runtimeHelper.js

@@ -6,6 +6,7 @@
  * - Berechnet tägliche Umwälzmenge
  * - Schreibt Werte in die States (Objekte werden in runtimeStates.js angelegt)
  * - Nutzt den zentralen Boolean pump.pump_switch
+ * - NEU: zählt Starts, aktuelle Laufzeit, Saisonlaufzeit
  */
 
 const runtimeHelper = {
@@ -14,6 +15,8 @@ const runtimeHelper = {
     lastOn: null,
     runtimeTotal: 0, // Gesamtzeit (s)
     runtimeToday: 0, // Tageszeit (s)
+    runtimeSeason: 0, // Laufzeit der aktuellen Saison (s)
+    startCountToday: 0, // Anzahl Starts heute
     resetTimer: null,
     liveTimer: null, // Timer für Live-Updates
 
@@ -43,15 +46,16 @@ const runtimeHelper = {
     },
 
     async _restoreFromStates() {
-        const total = Number((await this.adapter.getStateAsync('runtime.total'))?.val);
-        const today = Number((await this.adapter.getStateAsync('runtime.today'))?.val);
+        const totalRaw = (await this.adapter.getStateAsync('runtime.total'))?.val;
+        const todayRaw = (await this.adapter.getStateAsync('runtime.today'))?.val;
+        const seasonRaw = (await this.adapter.getStateAsync('runtime.season_total'))?.val;
+        const countRaw = (await this.adapter.getStateAsync('runtime.start_count_today'))?.val;
 
-        if (Number.isFinite(total)) {
-            this.runtimeTotal = total;
-        }
-        if (Number.isFinite(today)) {
-            this.runtimeToday = today;
-        }
+        // Alle formatierten Werte werden intern wieder auf 0 gesetzt, Laufzeiten starten neu
+        this.runtimeTotal = Number(totalRaw) || 0;
+        this.runtimeToday = Number(todayRaw) || 0;
+        this.runtimeSeason = Number(seasonRaw) || 0;
+        this.startCountToday = Number(countRaw) || 0;
 
         // Falls Pumpe gerade läuft → Status wiederherstellen
         const active = !!(await this.adapter.getStateAsync('pump.pump_switch'))?.val;
@@ -72,14 +76,25 @@ const runtimeHelper = {
                 // 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;
+                }
+
                 this.isRunning = false;
                 this.lastOn = null;
 
@@ -96,24 +111,27 @@ const runtimeHelper = {
         try {
             // Falls Pumpe läuft → temporäre Laufzeit seit lastOn einrechnen
             let effectiveToday = this.runtimeToday;
+            let effectiveSeason = this.runtimeSeason;
+            let currentSessionSeconds = 0;
+
             if (this.isRunning && this.lastOn) {
                 const delta = Math.floor((Date.now() - this.lastOn) / 1000);
                 effectiveToday += delta;
+                effectiveSeason += delta;
+                currentSessionSeconds = delta;
             }
 
-            // Laufzeit-States setzen
-            await this.adapter.setStateAsync('runtime.total', {
-                val: this.runtimeTotal,
-                ack: true,
-            });
-            await this.adapter.setStateAsync('runtime.today', {
-                val: effectiveToday,
-                ack: true,
-            });
-            await this.adapter.setStateAsync('runtime.formatted', {
-                val: this._formatTime(effectiveToday),
-                ack: true,
-            });
+            // Formatiert schreiben
+            const formattedToday = this._formatTime(effectiveToday);
+            const formattedTotal = this._formatTime(this.runtimeTotal);
+            const formattedSeason = this._formatTime(effectiveSeason);
+            const formattedCurrent = this._formatTime(currentSessionSeconds);
+
+            await this.adapter.setStateAsync('runtime.total', { val: formattedTotal, ack: true });
+            await this.adapter.setStateAsync('runtime.today', { val: formattedToday, ack: true });
+            await this.adapter.setStateAsync('runtime.current_session', { val: formattedCurrent, ack: true });
+            await this.adapter.setStateAsync('runtime.season_total', { val: formattedSeason, ack: true });
+            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;
@@ -124,27 +142,20 @@ const runtimeHelper = {
             const dailyRequired = Math.round(poolSize * minCirc);
             const dailyRemaining = Math.max(dailyRequired - dailyTotal, 0);
 
-            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,
-            });
+            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 });
         } catch (err) {
             this.adapter.log.warn(`[runtimeHelper] Fehler beim Update der States: ${err.message}`);
         }
     },
 
     _formatTime(seconds) {
+        seconds = Math.max(0, Math.floor(seconds));
         const h = Math.floor(seconds / 3600);
         const m = Math.floor((seconds % 3600) / 60);
-        return `${h}h ${m}m`;
+        const s = seconds % 60;
+        return `${h}h ${m}m ${s}s`;
     },
 
     _scheduleDailyReset() {
@@ -155,6 +166,7 @@ const runtimeHelper = {
 
         this.resetTimer = setTimeout(() => {
             this.runtimeToday = 0;
+            this.startCountToday = 0;
             this.lastOn = this.isRunning ? Date.now() : null;
             this._updateStates();
             this._scheduleDailyReset();

package/lib/helpers/speechHelper.js

@@ -8,6 +8,8 @@
 
 const speechHelper = {
     adapter: null,
+    lastTempNotify: {}, // Cooldown-Speicher pro Sensor
+    lastPumpState: null, // interner Speicher für letzten Pumpenzustand
 
     init(adapter) {
         this.adapter = adapter;
@@ -18,6 +20,10 @@ const speechHelper = {
         this.adapter.subscribeStates('speech.texts.*');
         this.adapter.subscribeStates('pump.error'); // Fehleransagen
         this.adapter.subscribeStates('temperature.*.current'); // Temp-Trigger
+        this.adapter.subscribeStates('pump.pump_switch'); // wichtig für Flankenerkennung
+
+        // NEU: auch speech.last_text überwachen (z. B. von controlHelper gesendet)
+        this.adapter.subscribeStates('speech.last_text');
 
         this.adapter.log.info('[speechHelper] initialisiert');
     },
@@ -33,6 +39,15 @@ const speechHelper = {
             return;
         }
 
+        // NEU: Direktnachricht von controlHelper über speech.last_text
+        if (id.endsWith('speech.last_text') && state.ack === false) {
+            const txt = String(state.val || '').trim();
+            if (txt) {
+                await this._speak(txt);
+                return;
+            }
+        }
+
         // Fehleransagen
         if (id.endsWith('pump.error') && state.val) {
             const includeErrors = this.adapter.config.speech_include_errors;
@@ -42,16 +57,26 @@ const speechHelper = {
             return;
         }
 
-        // Beispiel: Pumpenstart / -stop
+        // === Pumpenstart / -stop nur bei Zustandswechsel ===
         if (id.endsWith('pump.pump_switch')) {
-            if (state.val) {
-                const txt =
-                    (await this.adapter.getStateAsync('speech.start_text'))?.val || 'Die Poolpumpe wurde gestartet.';
-                await this._speak(txt);
+            const newVal = !!state.val;
+
+            // Nur wenn sich der Zustand wirklich geändert hat
+            if (this.lastPumpState !== newVal) {
+                this.lastPumpState = newVal;
+
+                if (newVal) {
+                    const txt =
+                        (await this.adapter.getStateAsync('speech.start_text'))?.val ||
+                        'Die Poolpumpe wurde gestartet.';
+                    await this._speak(txt);
+                } else {
+                    const txt =
+                        (await this.adapter.getStateAsync('speech.end_text'))?.val || 'Die Poolpumpe wurde gestoppt.';
+                    await this._speak(txt);
+                }
             } else {
-                const txt =
-                    (await this.adapter.getStateAsync('speech.end_text'))?.val || 'Die Poolpumpe wurde gestoppt.';
-                await this._speak(txt);
+                this.adapter.log.debug('[speechHelper] Ignoriere Pumpenmeldung – kein Zustandswechsel.');
             }
             return;
         }
@@ -61,7 +86,16 @@ const speechHelper = {
             const threshold = this.adapter.config.speech_temp_threshold || 0;
             const val = Number(state.val);
             if (val >= threshold && threshold > 0) {
-                await this._speak(`Der Pool hat ${val} Grad erreicht.`);
+                const now = Date.now();
+                const last = this.lastTempNotify[id] || 0;
+
+                // Nur einmal pro Stunde pro Sensor
+                if (now - last > 60 * 60 * 1000) {
+                    await this._speak(`Der Pool hat ${val} Grad erreicht.`);
+                    this.lastTempNotify[id] = now;
+                } else {
+                    this.adapter.log.debug(`[speechHelper] Temperaturansage für ${id} unterdrückt (Cooldown aktiv).`);
+                }
             }
             return;
         }
@@ -74,10 +108,7 @@ const speechHelper = {
             }
 
             // Letzten Text speichern
-            await this.adapter.setStateAsync('speech.last_text', {
-                val: text,
-                ack: true,
-            });
+            await this.adapter.setStateAsync('speech.last_text', { val: text, ack: true });
 
             // Alexa-Ausgabe
             if (this.adapter.config.speech_alexa_enabled && this.adapter.config.speech_alexa_device) {
@@ -85,33 +116,34 @@ const speechHelper = {
                 this.adapter.log.info(`[speechHelper] Alexa sagt: ${text}`);
             }
 
-            // Telegram-Ausgabe
+            // Telegram-Ausgabe (modern über sendTo)
             if (this.adapter.config.speech_telegram_enabled && this.adapter.config.speech_telegram_instance) {
                 const instance = this.adapter.config.speech_telegram_instance;
-                const sendState = `${instance}.communicate.sendMessage`;
-                await this.adapter.setForeignStateAsync(sendState, {
-                    val: text,
-                    ack: false,
-                });
-                this.adapter.log.info(`[speechHelper] Telegram sendet: ${text}`);
+                try {
+                    this.adapter.sendTo(instance, { text, parse_mode: 'Markdown' });
+                    this.adapter.log.info(`[speechHelper] Telegram sendet: ${text}`);
+                } catch (err) {
+                    this.adapter.log.warn(
+                        `[speechHelper] Telegram-Versand fehlgeschlagen (${instance}): ${err.message}`,
+                    );
+                }
             }
 
-            // E-Mail-Ausgabe
+            // E-Mail-Ausgabe (modern über sendTo)
             if (this.adapter.config.speech_email_enabled && this.adapter.config.speech_email_instance) {
-                const instance = this.adapter.config.speech_email_instance;
-                const sendState = `${instance}.mail`;
-
-                await this.adapter.setForeignStateAsync(sendState, {
-                    val: {
+                const instance = this.adapter.config.speech_email_instance; // z. B. "email.0"
+                try {
+                    this.adapter.sendTo(instance, {
                         to: this.adapter.config.speech_email_recipient,
                         subject: this.adapter.config.speech_email_subject || 'PoolControl Nachricht',
-                        text: text,
-                    },
-                    ack: false,
-                });
-                this.adapter.log.info(
-                    `[speechHelper] E-Mail gesendet an ${this.adapter.config.speech_email_recipient}: ${text}`,
-                );
+                        text,
+                    });
+                    this.adapter.log.info(
+                        `[speechHelper] E-Mail gesendet über ${instance} an ${this.adapter.config.speech_email_recipient}: ${text}`,
+                    );
+                } catch (err) {
+                    this.adapter.log.warn(`[speechHelper] E-Mail-Versand fehlgeschlagen (${instance}): ${err.message}`);
+                }
             }
         } catch (err) {
             this.adapter.log.warn(`[speechHelper] Fehler beim Sprechen: ${err.message}`);

package/lib/helpers/temperatureHelper.js

@@ -30,6 +30,35 @@ const temperatureHelper = {
             adapter.subscribeForeignStates(id);
         }
 
+        // >>> NEU: Initialwerte aller aktiven Sensoren einlesen
+        (async () => {
+            for (const [key, id] of Object.entries(this.sensors)) {
+                try {
+                    const state = await adapter.getForeignStateAsync(id);
+                    if (state && state.val !== null && state.val !== undefined && !isNaN(Number(state.val))) {
+                        const val = Number(state.val);
+                        this.values[key] = val;
+                        await this._setCurrentValue(key, val);
+                        await this._updateMinMax(key, val);
+                        adapter.log.debug(`[temperatureHelper] Initialwert für ${key}: ${val} °C`);
+                    } else {
+                        adapter.log.debug(`[temperatureHelper] Kein gültiger Initialwert für ${key}`);
+                    }
+                } catch (err) {
+                    adapter.log.warn(`[temperatureHelper] Fehler beim Initial-Read ${key}: ${err.message}`);
+                }
+            }
+
+            // Nach Setzen der ersten Werte gleich Deltas prüfen
+            await this._maybeWriteDelta(
+                'temperature.delta.collector_outside',
+                this.values.collector,
+                this.values.outside,
+            );
+            await this._maybeWriteDelta('temperature.delta.surface_ground', this.values.surface, this.values.ground);
+            await this._maybeWriteDelta('temperature.delta.flow_return', this.values.flow, this.values.return);
+        })();
+
         // >>> NEU: Alte Min/Max-Werte wiederherstellen
         this._restoreMinMaxFromStates().catch(err =>
             this.adapter.log.warn(`[temperatureHelper] Restore Min/Max fehlgeschlagen: ${err.message}`),