iobroker.poolcontrol 0.1.2 → 0.2.1

package/lib/helpers/controlHelper.js

@@ -0,0 +1,340 @@
+'use strict';
+
+/**
+ * controlHelper
+ * - Steuert Wartungsmodus, Rückspülung, Energie-Reset, Saison
+ * - Führt tägliche Umwälzprüfung (z. B. 18:00 Uhr) durch
+ * - Automatisches Nachpumpen, wenn Tagesziel nicht erreicht
+ * - Sendet Statusmeldungen über speech.queue
+ * - Nutzt Vorrangsteuerung über pump.mode = "controlHelper"
+ */
+
+let adapter;
+let backwashTimer = null;
+let dailyTimer = null;
+let previousPumpMode = null;
+
+/**
+ * Initialisiert den Control-Helper.
+ *
+ * @param {import('iobroker').Adapter} a - ioBroker Adapterinstanz
+ */
+function init(a) {
+    adapter = a;
+    adapter.log.info('[controlHelper] initialisiert');
+
+    // States abonnieren
+    adapter.subscribeStates('control.season.active');
+    adapter.subscribeStates('control.pump.backwash_start');
+    adapter.subscribeStates('control.pump.maintenance_active');
+    adapter.subscribeStates('control.energy.reset');
+    adapter.subscribeStates('control.circulation.check_time');
+
+    // Täglichen Check planen
+    _scheduleDailyCheck().catch(err =>
+        adapter.log.error(`[controlHelper] Fehler bei _scheduleDailyCheck(): ${err.message}`),
+    );
+
+    adapter.log.debug('[controlHelper] Überwachung der Control-States aktiviert');
+}
+
+/**
+ * Plant den täglichen Umwälzungscheck neu.
+ */
+async function _scheduleDailyCheck() {
+    try {
+        if (dailyTimer) {
+            clearTimeout(dailyTimer);
+        }
+
+        const timeStr = (await adapter.getStateAsync('control.circulation.check_time'))?.val || '18:00';
+        const [hours, minutes] = timeStr.split(':').map(x => parseInt(x, 10));
+
+        const now = new Date();
+        const next = new Date();
+        next.setHours(hours, minutes, 0, 0);
+        if (next <= now) {
+            next.setDate(next.getDate() + 1);
+        }
+
+        const diffMs = next - now;
+        adapter.log.debug(`[controlHelper] Nächster Tages-Umwälzungscheck geplant für ${next.toLocaleTimeString()}`);
+
+        dailyTimer = setTimeout(async () => {
+            await _runDailyCirculationCheck();
+            await _scheduleDailyCheck();
+        }, diffMs);
+    } catch (err) {
+        adapter.log.error(`[controlHelper] Fehler bei _scheduleDailyCheck(): ${err.message}`);
+    }
+}
+
+/**
+ * Führt den täglichen Umwälzungsbericht und ggf. Nachpumpen aus.
+ */
+async function _runDailyCirculationCheck() {
+    try {
+        adapter.log.debug('[controlHelper] Starte Tages-Umwälzungscheck ...');
+
+        const seasonActive = (await adapter.getStateAsync('status.season_active'))?.val;
+        const mode = (await adapter.getStateAsync('control.circulation.mode'))?.val || 'off';
+        const dailyTotal = Math.round((await adapter.getStateAsync('circulation.daily_total'))?.val || 0);
+        const dailyRequired = Math.round((await adapter.getStateAsync('circulation.daily_required'))?.val || 0);
+        const collector = Number((await adapter.getStateAsync('temperature.collector.current'))?.val || 0);
+        const pool = Number((await adapter.getStateAsync('temperature.surface.current'))?.val || 0);
+
+        if (!seasonActive) {
+            adapter.log.debug('[controlHelper] Saison inaktiv – Tagesprüfung übersprungen.');
+            return;
+        }
+
+        if (!dailyRequired || dailyRequired <= 0) {
+            await _sendSpeech('Keine Zielumwälzmenge festgelegt – Tagesbericht übersprungen.');
+            return;
+        }
+
+        const percent = Math.min(100, Math.round((dailyTotal / dailyRequired) * 100));
+        const missing = Math.max(0, Math.round(dailyRequired - dailyTotal));
+        let message = '';
+
+        switch (mode) {
+            case 'notify':
+                message = `Heutige Umwälzung: ${dailyTotal} l (${percent} %). Es fehlen noch ${missing} l. Bitte ggf. manuell nachpumpen.`;
+                break;
+
+            case 'manual':
+                message = `Heutige Umwälzung: ${dailyTotal} l (${percent} %). Es fehlen noch ${missing} l. Bitte Pumpe manuell einschalten.`;
+                break;
+
+            case 'auto':
+                if (percent >= 100) {
+                    message = `Tagesumwälzung abgeschlossen: ${dailyTotal} l (${percent} %). Kein Nachpumpen erforderlich.`;
+                } else if (collector > pool) {
+                    message = `Heutige Umwälzung: ${dailyTotal} l (${percent} %). Es fehlen ${missing} l. Nachpumpen startet automatisch (Kollektor wärmer).`;
+                    await _startAutoPumping(missing);
+                    return;
+                } else {
+                    message = `Heutige Umwälzung: ${dailyTotal} l (${percent} %). Kein automatisches Nachpumpen, Kollektor kälter als Pool.`;
+                }
+                break;
+
+            default:
+                adapter.log.debug(`[controlHelper] Modus '${mode}' → keine Aktion.`);
+                return;
+        }
+
+        await _sendSpeech(message);
+        await adapter.setStateAsync('control.circulation.last_report', { val: new Date().toISOString(), ack: true });
+    } catch (err) {
+        adapter.log.error(`[controlHelper] Fehler beim Tagescheck: ${err.message}`);
+    }
+}
+
+/**
+ * Startet automatisches Nachpumpen.
+ *
+ * @param {number} missingLiter - Fehlende Umwälzmenge in Litern
+ */
+async function _startAutoPumping(missingLiter) {
+    try {
+        const notify = (await adapter.getStateAsync('control.pump.notifications_enabled'))?.val;
+
+        previousPumpMode = (await adapter.getStateAsync('pump.mode'))?.val || 'auto';
+        await adapter.setStateAsync('pump.mode', { val: 'controlHelper', ack: true });
+        await adapter.setStateAsync('pump.reason', { val: 'nachpumpen', ack: true });
+        await adapter.setStateAsync('pump.pump_switch', { val: true, ack: false });
+
+        adapter.log.info(`[controlHelper] Automatisches Nachpumpen gestartet (${missingLiter} l fehlen).`);
+        if (notify) {
+            await _sendSpeech(`Automatisches Nachpumpen gestartet. Es fehlen ${missingLiter} Liter.`);
+        }
+
+        const interval = setInterval(async () => {
+            const total = Math.round((await adapter.getStateAsync('circulation.daily_total'))?.val || 0);
+            const required = Math.round((await adapter.getStateAsync('circulation.daily_required'))?.val || 0);
+
+            if (total >= required) {
+                clearInterval(interval);
+                await adapter.setStateAsync('pump.pump_switch', { val: false, ack: false });
+                await adapter.setStateAsync('pump.mode', { val: previousPumpMode, ack: true });
+                await adapter.setStateAsync('pump.reason', { val: '', ack: true });
+                previousPumpMode = null;
+
+                adapter.log.info('[controlHelper] Nachpumpen abgeschlossen – Tagesziel erreicht.');
+                if (notify) {
+                    await _sendSpeech('Nachpumpen abgeschlossen. Tagesziel erreicht.');
+                }
+            }
+        }, 60 * 1000);
+    } catch (err) {
+        adapter.log.error(`[controlHelper] Fehler beim automatischen Nachpumpen: ${err.message}`);
+    }
+}
+
+/**
+ * Reagiert auf Änderungen der States im Bereich control.*
+ *
+ * @param {string} id - Objekt-ID des geänderten States
+ * @param {ioBroker.State} state - Neuer State-Wert
+ */
+async function handleStateChange(id, state) {
+    try {
+        if (!state || state.ack) {
+            return;
+        }
+
+        // === SAISONSTATUS ===
+        if (id.endsWith('control.season.active')) {
+            const newVal = !!state.val;
+            adapter.log.info(`[controlHelper] Poolsaison wurde ${newVal ? 'aktiviert' : 'deaktiviert'}.`);
+            await adapter.setStateAsync('status.season_active', { val: newVal, ack: true });
+        }
+
+        // === WARTUNGSMODUS ===
+        if (id.endsWith('control.pump.maintenance_active')) {
+            const active = !!state.val;
+            const notify = (await adapter.getStateAsync('control.pump.notifications_enabled'))?.val;
+
+            if (active) {
+                previousPumpMode = (await adapter.getStateAsync('pump.mode'))?.val || 'auto';
+                await adapter.setStateAsync('pump.mode', { val: 'controlHelper', ack: true });
+                await adapter.setStateAsync('pump.reason', { val: 'wartung', ack: true });
+                await adapter.setStateAsync('pump.pump_switch', { val: false, ack: false });
+                adapter.log.info('[controlHelper] Wartungsmodus aktiviert. Automatik pausiert.');
+
+                if (notify) {
+                    await _sendSpeech('Wartungsmodus aktiviert. Automatikfunktionen deaktiviert.');
+                }
+            } else {
+                await adapter.setStateAsync('pump.mode', { val: previousPumpMode, ack: true });
+                await adapter.setStateAsync('pump.reason', { val: '', ack: true });
+                previousPumpMode = null;
+
+                adapter.log.info('[controlHelper] Wartungsmodus beendet. Automatik wieder aktiv.');
+                if (notify) {
+                    await _sendSpeech('Wartungsmodus beendet. Automatikbetrieb wieder aktiv.');
+                }
+            }
+        }
+
+        // === RÜCKSPÜLUNG ===
+        if (id.endsWith('control.pump.backwash_start') && state.val === true) {
+            const duration = (await adapter.getStateAsync('control.pump.backwash_duration'))?.val || 1;
+            const notify = (await adapter.getStateAsync('control.pump.notifications_enabled'))?.val;
+            const prevMode = (await adapter.getStateAsync('pump.mode'))?.val || 'auto';
+            const active = (await adapter.getStateAsync('control.pump.backwash_active'))?.val;
+
+            if (active) {
+                adapter.log.warn('[controlHelper] Rückspülung bereits aktiv – neuer Start abgelehnt.');
+                return;
+            }
+
+            await adapter.setStateAsync('control.pump.backwash_active', { val: true, ack: true });
+            await adapter.setStateAsync('control.pump.backwash_start', { val: false, ack: true });
+            await adapter.setStateAsync('pump.mode', { val: 'controlHelper', ack: true });
+            await adapter.setStateAsync('pump.reason', { val: 'rückspülen', ack: true });
+            await adapter.setStateAsync('pump.pump_switch', { val: true, ack: false });
+
+            const durationText = duration === 1 ? 'eine Minute' : `${duration} Minuten`;
+            adapter.log.info(`[controlHelper] Rückspülung gestartet (${duration} Minuten).`);
+
+            if (notify) {
+                await _sendSpeech(`Rückspülung gestartet. Dauer ${durationText}.`);
+            }
+
+            if (backwashTimer) {
+                clearTimeout(backwashTimer);
+            }
+            backwashTimer = setTimeout(
+                async () => {
+                    try {
+                        await adapter.setStateAsync('pump.pump_switch', { val: false, ack: false });
+                        await adapter.setStateAsync('pump.mode', { val: prevMode, ack: true });
+                        await adapter.setStateAsync('pump.reason', { val: '', ack: true });
+                        await adapter.setStateAsync('control.pump.backwash_active', { val: false, ack: true });
+
+                        adapter.log.info('[controlHelper] Rückspülung beendet. Automatik wieder aktiv.');
+                        if (notify) {
+                            await _sendSpeech('Rückspülung abgeschlossen. Automatikmodus wieder aktiv.');
+                        }
+                    } catch (err) {
+                        adapter.log.warn(`[controlHelper] Fehler beim Beenden der Rückspülung: ${err.message}`);
+                    }
+                },
+                duration * 60 * 1000,
+            );
+        }
+
+        // === ENERGIEZÄHLER RESET ===
+        if (id.endsWith('control.energy.reset') && state.val === true) {
+            const now = new Date();
+            const timestamp = now.toLocaleString('de-DE');
+            const notify = (await adapter.getStateAsync('control.pump.notifications_enabled'))?.val;
+
+            adapter.log.info(`[controlHelper] Energiezähler wird vollständig zurückgesetzt (${timestamp}).`);
+
+            const consStates = [
+                'consumption.total_kwh',
+                'consumption.day_kwh',
+                'consumption.week_kwh',
+                'consumption.month_kwh',
+                'consumption.year_kwh',
+                'consumption.last_total_kwh',
+                'consumption.offset_kwh',
+                'costs.total_eur',
+                'costs.day_eur',
+                'costs.week_eur',
+                'costs.month_eur',
+                'costs.year_eur',
+            ];
+
+            for (const sid of consStates) {
+                await adapter.setStateAsync(sid, { val: 0, ack: true });
+            }
+
+            await adapter.setStateAsync('control.energy.reset', { val: false, ack: true });
+
+            const msg = `Energiezähler und Kosten wurden am ${timestamp} vollständig zurückgesetzt.`;
+            adapter.log.info(`[controlHelper] ${msg}`);
+            if (notify) {
+                await _sendSpeech(msg);
+            }
+        }
+    } catch (err) {
+        adapter.log.error(`[controlHelper] Fehler bei State-Änderung: ${err.message}`);
+    }
+}
+
+/**
+ * Sendet Text an speech.queue
+ *
+ * @param {string} text - Nachricht, die an speech.queue gesendet werden soll
+ */
+async function _sendSpeech(text) {
+    if (!text) {
+        return;
+    }
+    try {
+        await adapter.setStateAsync('speech.queue', { val: text, ack: false });
+        adapter.log.debug(`[controlHelper] Nachricht an speech.queue: ${text}`);
+    } catch (err) {
+        adapter.log.warn(`[controlHelper] Fehler beim Senden an speech.queue: ${err.message}`);
+    }
+}
+
+/**
+ * Aufräumen
+ */
+function cleanup() {
+    if (backwashTimer) {
+        clearTimeout(backwashTimer);
+        backwashTimer = null;
+    }
+    if (dailyTimer) {
+        clearTimeout(dailyTimer);
+        dailyTimer = null;
+    }
+    previousPumpMode = null;
+}
+
+module.exports = { init, handleStateChange, cleanup };

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.debug('[debugLogHelper] Kein Bereich ausgewählt – Logger inaktiv.');
+        }
+
+        adapter.log.debug('[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.debug(`[debugLogHelper] Überwachung für Bereich "${this.subscribedTarget}" beendet.`);
+        }
+
+        this.subscribedTarget = newTarget;
+
+        if (newTarget === 'none') {
+            this.adapter.log.debug('[debugLogHelper] Kein Bereich aktiv.');
+            return;
+        }
+
+        this._subscribeTarget(newTarget);
+        this.adapter.log.debug(`[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/frostHelper.js

@@ -18,7 +18,7 @@ const frostHelper = {
         // Minütlicher Check
         this._scheduleCheck();
 
-        this.adapter.log.info('[frostHelper] initialisiert (Prüfung alle 60s)');
+        this.adapter.log.debug('[frostHelper] initialisiert (Prüfung alle 60s)');
     },
 
     _scheduleCheck() {
@@ -32,6 +32,13 @@ const frostHelper = {
 
     async _checkFrost() {
         try {
+            // --- NEU: Vorrangprüfung durch ControlHelper ---
+            const pumpStatus = (await this.adapter.getStateAsync('pump.status'))?.val || '';
+            if (pumpStatus.includes('controlHelper')) {
+                this.adapter.log.debug('[frostHelper] Vorrang durch ControlHelper aktiv – Frostschutz pausiert.');
+                return;
+            }
+
             // Nur aktiv im AUTO-Modus
             const mode = (await this.adapter.getStateAsync('pump.mode'))?.val;
             if (mode !== 'auto') {
@@ -68,13 +75,22 @@ const frostHelper = {
                 shouldRun = false;
             }
 
+            // --- NEU: Sprachsignal für Frostschutz setzen ---
+            const oldVal = (await this.adapter.getStateAsync('speech.frost_active'))?.val;
+            if (oldVal !== shouldRun) {
+                await this.adapter.setStateChangedAsync('speech.frost_active', {
+                    val: shouldRun,
+                    ack: true,
+                });
+            }
+
             // Schalten nur, wenn sich etwas ändert
             if (shouldRun !== pumpActive) {
                 await this.adapter.setStateAsync('pump.pump_switch', {
                     val: shouldRun,
                     ack: false,
                 });
-                this.adapter.log.info(
+                this.adapter.log.debug(
                     `[frostHelper] Frostschutz → Pumpe ${shouldRun ? 'EIN' : 'AUS'} (Außen=${outside}°C, Grenze=${frostTemp}°C)`,
                 );
             }