iobroker.poolcontrol 0.0.7

package/lib/helpers/pumpHelper.js

@@ -0,0 +1,224 @@
+'use strict';
+
+/**
+ * pumpHelper
+ * - Spiegelt aktuelle Leistung aus Fremd-State nach pump.current_power
+ * - Prüft Fehlerkriterien → setzt pump.error
+ * - Bei Überlast: Pumpe ausschalten + Modus blockieren
+ * - Leitet pump.status ab aus mode, switch, error
+ * - NEU: Synchronisiert zentralen Schalter (pump.pump_switch, boolean) mit der realen Steckdose (adapter.config.pump_switch)
+ */
+
+const pumpHelper = {
+    adapter: null,
+    deviceId: null, // Objekt-ID der echten Steckdose (aus Config)
+    currentPowerId: null, // Fremd-State für Leistung (aus Config)
+
+    init(adapter) {
+        this.adapter = adapter;
+
+        // States aus Config lesen
+        this.deviceId = (adapter.config.pump_switch || '').trim() || null;
+        this.currentPowerId = (adapter.config.pump_current_power_id || '').trim() || null;
+
+        // Relevante eigenen States beobachten
+        this.adapter.subscribeStates('pump.mode');
+        this.adapter.subscribeStates('pump.pump_switch');
+        this.adapter.subscribeStates('pump.error');
+
+        // Fremdleistung beobachten
+        if (this.currentPowerId) {
+            this.adapter.subscribeForeignStates(this.currentPowerId);
+
+            // Initialwert ziehen
+            this.adapter
+                .getForeignStateAsync(this.currentPowerId)
+                .then(s => {
+                    const val = this._parseNumber(s?.val);
+                    this.adapter.setStateAsync('pump.current_power', { val, ack: true });
+                    this.adapter.log.info(
+                        `[pumpHelper] Überwache Leistung von ${this.currentPowerId} (Startwert: ${val})`,
+                    );
+                })
+                .catch(() => {
+                    this.adapter.log.info(`[pumpHelper] Überwache Leistung von ${this.currentPowerId}`);
+                });
+        } else {
+            this.adapter.log.info('[pumpHelper] Keine Objekt-ID für aktuelle Leistung konfiguriert');
+        }
+
+        // Echte Steckdose beobachten (Status-Spiegelung)
+        if (this.deviceId) {
+            this.adapter.subscribeForeignStates(this.deviceId);
+            this.adapter.log.info(`[pumpHelper] Überwache Steckdose: ${this.deviceId}`);
+        } else {
+            this.adapter.log.info('[pumpHelper] Keine Objekt-ID für Pumpen-Steckdose konfiguriert');
+        }
+
+        this.adapter.log.info('[pumpHelper] initialisiert');
+        // Initialer Status
+        this._updateStatus().catch(err =>
+            this.adapter.log.warn(`[pumpHelper] Initiales Status-Update fehlgeschlagen: ${err.message}`),
+        );
+    },
+
+    // Hilfsfunktion: Zahlen robust parsen
+    _parseNumber(x) {
+        if (typeof x === 'number' && Number.isFinite(x)) {
+            return x;
+        }
+        const m = String(x ?? '')
+            .replace(',', '.')
+            .match(/-?\d+(\.\d+)?/);
+        return m ? Number(m[0]) : 0;
+    },
+
+    async handleStateChange(id, state) {
+        if (!state) {
+            return;
+        }
+
+        // 1) Leistung aus Fremd-State spiegeln
+        if (this.currentPowerId && id === this.currentPowerId) {
+            const val = this._parseNumber(state.val);
+            await this.adapter.setStateAsync('pump.current_power', {
+                val,
+                ack: true,
+            });
+            await this._checkErrorConditions();
+            return;
+        }
+
+        // 2) Fremde Steckdose hat sich verändert → in unseren bool-Schalter spiegeln
+        if (this.deviceId && id === this.deviceId) {
+            const val = !!state.val;
+            await this.adapter.setStateAsync('pump.pump_switch', { val, ack: true });
+            await this._updateStatus();
+            await this._checkErrorConditions();
+            return;
+        }
+
+        // 3) Eigene Pumpen-States geändert
+        if (id.endsWith('pump.mode') || id.endsWith('pump.pump_switch') || id.endsWith('pump.error')) {
+            if (id.endsWith('pump.pump_switch') && this.deviceId) {
+                await this.adapter.setForeignStateAsync(this.deviceId, {
+                    val: !!state.val,
+                    ack: false,
+                });
+            }
+
+            await this._updateStatus();
+            await this._checkErrorConditions();
+            return;
+        }
+    },
+
+    async _updateStatus() {
+        try {
+            const mode = (await this.adapter.getStateAsync('pump.mode'))?.val || 'unknown';
+            const active = (await this.adapter.getStateAsync('pump.pump_switch'))?.val;
+            const error = (await this.adapter.getStateAsync('pump.error'))?.val;
+
+            let status = 'AUS';
+            if (error) {
+                status = 'FEHLER';
+            } else if (active) {
+                switch (mode) {
+                    case 'manual':
+                        status = 'EIN (manuell)';
+                        break;
+                    case 'time':
+                        status = 'EIN (zeit)';
+                        break;
+                    case 'auto':
+                        status = 'EIN (automatik)';
+                        break;
+                    default:
+                        status = 'EIN';
+                        break;
+                }
+            }
+            await this.adapter.setStateAsync('pump.status', {
+                val: status,
+                ack: true,
+            });
+        } catch (err) {
+            this.adapter.log.warn(`[pumpHelper] Fehler beim Setzen von pump.status: ${err.message}`);
+        }
+    },
+
+    async _checkErrorConditions() {
+        try {
+            const pumpSwitchId = (this.adapter.config.pump_switch || '').trim();
+            let active = null;
+
+            if (pumpSwitchId) {
+                active = !!(await this.adapter.getForeignStateAsync(pumpSwitchId))?.val;
+            } else {
+                const v = (await this.adapter.getStateAsync('pump.pump_switch'))?.val;
+                if (typeof v === 'boolean') {
+                    active = v;
+                }
+            }
+
+            const errorOld = (await this.adapter.getStateAsync('pump.error'))?.val;
+            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);
+
+            let error = false;
+            let errorMsg = '';
+
+            if (active === true && power < 5) {
+                error = true;
+                errorMsg = 'Fehler: Pumpe EIN, aber keine Leistung!';
+            }
+
+            if (active === false && power > 10) {
+                error = true;
+                errorMsg = 'Fehler: Pumpe AUS, aber Leistung vorhanden!';
+            }
+
+            if (active === true && maxWatt > 0 && power > maxWatt) {
+                error = true;
+                errorMsg = `Überlast: ${power} W > Maximalwert ${maxWatt} W → Pumpe wird abgeschaltet!`;
+
+                if (pumpSwitchId) {
+                    await this.adapter.setForeignStateAsync(pumpSwitchId, {
+                        val: false,
+                        ack: false,
+                    });
+                }
+
+                await this.adapter.setStateAsync('pump.mode', {
+                    val: 'off',
+                    ack: true,
+                });
+            }
+
+            if (error !== errorOld) {
+                await this.adapter.setStateAsync('pump.error', {
+                    val: error,
+                    ack: true,
+                });
+                await this._updateStatus();
+
+                if (error && errorMsg) {
+                    this.adapter.log.warn(`[pumpHelper] ${errorMsg}`);
+                } else if (!error && errorOld) {
+                    this.adapter.log.info('[pumpHelper] Pumpenfehler behoben');
+                }
+            }
+        } catch (err) {
+            this.adapter.log.warn(`[pumpHelper] Fehler bei Error-Check: ${err.message}`);
+        }
+    },
+
+    cleanup() {
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+            this.checkTimer = null;
+        }
+    },
+};
+
+module.exports = pumpHelper;

package/lib/helpers/runtimeHelper.js

@@ -0,0 +1,159 @@
+'use strict';
+
+/**
+ * runtimeHelper
+ * - Zählt Pumpenlaufzeit
+ * - Berechnet tägliche Umwälzmenge
+ * - Schreibt Werte in die States (Objekte werden in runtimeStates.js angelegt)
+ * - Nutzt den zentralen Boolean pump.pump_switch
+ */
+
+const runtimeHelper = {
+    adapter: null,
+    isRunning: false,
+    lastOn: null,
+    runtimeTotal: 0, // Gesamtzeit (s)
+    runtimeToday: 0, // Tageszeit (s)
+    resetTimer: null,
+    liveTimer: null, // Timer für Live-Updates
+
+    init(adapter) {
+        this.adapter = adapter;
+
+        // Pumpenschalter überwachen
+        this.adapter.subscribeStates('pump.pump_switch');
+
+        // Tagesreset einplanen
+        this._scheduleDailyReset();
+
+        // Gleich beim Start einmal berechnen
+        this._updateStates();
+
+        this.adapter.log.info('[runtimeHelper] initialisiert');
+    },
+
+    async handleStateChange(id, state) {
+        if (!state) {
+            return;
+        }
+
+        if (id.endsWith('pump.pump_switch')) {
+            if (state.val && !this.isRunning) {
+                // Pumpe startet
+                this.isRunning = true;
+                this.lastOn = Date.now();
+
+                // Live-Timer starten (jede Minute)
+                this._startLiveTimer();
+            } else if (!state.val && this.isRunning) {
+                // Pumpe stoppt
+                const delta = Math.floor((Date.now() - this.lastOn) / 1000);
+                this.runtimeToday += delta;
+                this.runtimeTotal += delta;
+                this.isRunning = false;
+                this.lastOn = null;
+
+                // Live-Timer stoppen
+                this._stopLiveTimer();
+
+                // States final aktualisieren
+                await this._updateStates();
+            }
+        }
+    },
+
+    async _updateStates() {
+        try {
+            // Falls Pumpe läuft → temporäre Laufzeit seit lastOn einrechnen
+            let effectiveToday = this.runtimeToday;
+            if (this.isRunning && this.lastOn) {
+                const delta = Math.floor((Date.now() - this.lastOn) / 1000);
+                effectiveToday += 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,
+            });
+
+            // Umwälzmenge berechnen
+            const pumpLph = (await this.adapter.getStateAsync('pump.pump_power_lph'))?.val || 0;
+            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);
+            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,
+            });
+        } catch (err) {
+            this.adapter.log.warn(`[runtimeHelper] Fehler beim Update der States: ${err.message}`);
+        }
+    },
+
+    _formatTime(seconds) {
+        const h = Math.floor(seconds / 3600);
+        const m = Math.floor((seconds % 3600) / 60);
+        return `${h}h ${m}m`;
+    },
+
+    _scheduleDailyReset() {
+        const now = new Date();
+        const nextMidnight = new Date(now);
+        nextMidnight.setHours(24, 0, 0, 0);
+        const msUntilMidnight = nextMidnight - now;
+
+        this.resetTimer = setTimeout(() => {
+            this.runtimeToday = 0;
+            this.lastOn = this.isRunning ? Date.now() : null;
+            this._updateStates();
+            this._scheduleDailyReset();
+        }, msUntilMidnight);
+    },
+
+    _startLiveTimer() {
+        if (this.liveTimer) {
+            clearInterval(this.liveTimer);
+        }
+        this.liveTimer = setInterval(() => this._updateStates(), 60 * 1000);
+        this.adapter.log.debug('[runtimeHelper] Live-Timer gestartet (Updates jede Minute)');
+    },
+
+    _stopLiveTimer() {
+        if (this.liveTimer) {
+            clearInterval(this.liveTimer);
+            this.liveTimer = null;
+            this.adapter.log.debug('[runtimeHelper] Live-Timer gestoppt');
+        }
+    },
+
+    cleanup() {
+        if (this.resetTimer) {
+            clearTimeout(this.resetTimer);
+            this.resetTimer = null;
+        }
+        this._stopLiveTimer();
+    },
+};
+
+module.exports = runtimeHelper;

package/lib/helpers/solarHelper.js

@@ -0,0 +1,138 @@
+'use strict';
+
+/**
+ * solarHelper
+ * - Prüft Kollektor-Temperaturen und schaltet Pumpe entsprechend
+ * - Nutzt States aus solarStates.js und temperatureStates.js
+ * - Setzt Warnung bei Übertemperatur (mit automatischer Rücksetzung bei 10 % darunter)
+ * - Schaltet über den zentralen Bool-State pump.pump_switch
+ */
+
+const solarHelper = {
+    adapter: null,
+    checkTimer: null,
+
+    init(adapter) {
+        this.adapter = adapter;
+
+        // Minütlicher Check
+        this._scheduleCheck();
+
+        this.adapter.log.info('[solarHelper] initialisiert (Prüfung alle 60s)');
+    },
+
+    _scheduleCheck() {
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+        }
+        this.checkTimer = setInterval(() => this._checkSolar(), 60 * 1000);
+        // Beim Start sofort prüfen
+        this._checkSolar();
+    },
+
+    async _checkSolar() {
+        try {
+            // Solarsteuerung aktiv?
+            const active = (await this.adapter.getStateAsync('solar.solar_control_active'))?.val;
+            if (!active) {
+                return;
+            }
+
+            // Pumpenmodus muss AUTO sein
+            const mode = (await this.adapter.getStateAsync('pump.mode'))?.val;
+            if (mode !== 'auto') {
+                return;
+            }
+
+            // Grenzwerte laden
+            const tempOn = (await this.adapter.getStateAsync('solar.temp_on'))?.val;
+            const tempOff = (await this.adapter.getStateAsync('solar.temp_off'))?.val;
+            const hysteresis = (await this.adapter.getStateAsync('solar.hysteresis_active'))?.val;
+
+            // Temperaturen laden
+            const collector = (await this.adapter.getStateAsync('temperature.collector.current'))?.val;
+            const pool = (await this.adapter.getStateAsync('temperature.surface.current'))?.val; // Oberfläche = Pooltemp
+
+            if (collector == null || pool == null) {
+                this.adapter.log.debug('[solarHelper] Keine gültigen Temperaturen verfügbar');
+                return;
+            }
+
+            let shouldRun = false;
+            const delta = collector - pool;
+
+            // Logik: Einschalten, wenn Collector > tempOn und Delta > 0
+            if (collector >= tempOn && delta > 0) {
+                shouldRun = true;
+            }
+
+            // Ausschalten, wenn Collector < tempOff oder Delta <= 0
+            if (collector <= tempOff || delta <= 0) {
+                shouldRun = false;
+            }
+
+            // Optional Hysterese (kann später erweitert werden)
+            if (hysteresis) {
+                // z. B. Ausschaltgrenze etwas absenken
+            }
+
+            // ZENTRAL: Pumpe über Bool-Schalter setzen
+            await this.adapter.setStateAsync('pump.pump_switch', {
+                val: shouldRun,
+                ack: false,
+            });
+            this.adapter.log.debug(
+                `[solarHelper] Solarregelung → Pumpe ${shouldRun ? 'EIN' : 'AUS'} (Collector=${collector}°C, Pool=${pool}°C, Delta=${delta}°C)`,
+            );
+
+            // --- Kollektor-Warnung ---
+            const warnActive = (await this.adapter.getStateAsync('solar.warn_active'))?.val;
+            if (warnActive) {
+                const warnTemp = Number((await this.adapter.getStateAsync('solar.warn_temp'))?.val) || 0;
+                const speechEnabled = (await this.adapter.getStateAsync('solar.warn_speech'))?.val;
+                const currentWarning = (await this.adapter.getStateAsync('solar.collector_warning'))?.val || false;
+
+                // Neue Warnung, wenn Collector >= warnTemp
+                if (collector >= warnTemp && !currentWarning) {
+                    await this.adapter.setStateAsync('solar.collector_warning', {
+                        val: true,
+                        ack: true,
+                    });
+                    this.adapter.log.warn(
+                        `[solarHelper] WARNUNG: Kollektortemperatur ${collector}°C >= ${warnTemp}°C!`,
+                    );
+
+                    // Sprachausgabe bei Aktivierung
+                    if (speechEnabled) {
+                        await this.adapter.setStateAsync('speech.last_text', {
+                            val: `Warnung: Kollektortemperatur ${collector} Grad erreicht.`,
+                            ack: true,
+                        });
+                    }
+                }
+
+                // Warnung zurücksetzen, wenn Collector <= 90 % von warnTemp
+                if (collector <= warnTemp * 0.9 && currentWarning) {
+                    await this.adapter.setStateAsync('solar.collector_warning', {
+                        val: false,
+                        ack: true,
+                    });
+                    this.adapter.log.info(
+                        `[solarHelper] Kollektorwarnung zurückgesetzt: ${collector}°C <= ${warnTemp * 0.9}°C`,
+                    );
+                }
+            }
+        } catch (err) {
+            this.adapter.log.warn(`[solarHelper] Fehler im Check: ${err.message}`);
+        }
+    },
+
+    cleanup() {
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+            this.checkTimer = null;
+        }
+    },
+};
+
+module.exports = solarHelper;

package/lib/helpers/speechHelper.js

@@ -0,0 +1,108 @@
+'use strict';
+
+/**
+ * speechHelper
+ * - Sendet Texte an Alexa und/oder Telegram
+ * - Verwendet Config (jsonConfig) + States aus speechStates.js
+ */
+
+const speechHelper = {
+    adapter: null,
+
+    init(adapter) {
+        this.adapter = adapter;
+
+        // States überwachen, die Textänderungen triggern
+        this.adapter.subscribeStates('speech.start_text');
+        this.adapter.subscribeStates('speech.end_text');
+        this.adapter.subscribeStates('speech.texts.*');
+        this.adapter.subscribeStates('pump.error'); // Fehleransagen
+        this.adapter.subscribeStates('temperature.*.current'); // Temp-Trigger
+
+        this.adapter.log.info('[speechHelper] initialisiert');
+    },
+
+    async handleStateChange(id, state) {
+        if (!state) {
+            return;
+        }
+
+        // Globale Aktivierung prüfen
+        const active = (await this.adapter.getStateAsync('speech.active'))?.val;
+        if (!active) {
+            return;
+        }
+
+        // Fehleransagen
+        if (id.endsWith('pump.error') && state.val) {
+            const includeErrors = this.adapter.config.speech_include_errors;
+            if (includeErrors) {
+                await this._speak('Achtung: Pumpenfehler erkannt!');
+            }
+            return;
+        }
+
+        // Beispiel: Pumpenstart / -stop
+        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);
+            } else {
+                const txt =
+                    (await this.adapter.getStateAsync('speech.end_text'))?.val || 'Die Poolpumpe wurde gestoppt.';
+                await this._speak(txt);
+            }
+            return;
+        }
+
+        // Temperatur-Trigger: über Config-Schwelle
+        if (id.includes('.temperature.') && id.endsWith('.current')) {
+            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.`);
+            }
+            return;
+        }
+    },
+
+    async _speak(text) {
+        try {
+            if (!text) {
+                return;
+            }
+
+            // Letzten Text speichern
+            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) {
+                await this.adapter.setForeignStateAsync(this.adapter.config.speech_alexa_device, text);
+                this.adapter.log.info(`[speechHelper] Alexa sagt: ${text}`);
+            }
+
+            // Telegram-Ausgabe
+            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}`);
+            }
+        } catch (err) {
+            this.adapter.log.warn(`[speechHelper] Fehler beim Sprechen: ${err.message}`);
+        }
+    },
+
+    cleanup() {
+        // nichts nötig bisher
+    },
+};
+
+module.exports = speechHelper;