iobroker.poolcontrol 0.2.0 → 0.2.2

package/lib/helpers/controlHelper.js

@@ -2,14 +2,17 @@
 
 /**
  * controlHelper
- * - Überwacht States im Bereich "control"
- * - Steuert manuelle Aktionen: Rückspülung, Wartungsmodus
- * - Synchronisiert mit Pumpenmodus und Sprach-/Benachrichtigungssystem
- * - Erweiterung: automatische Sprach- und Benachrichtigungs-Ausgabe bei Start/Ende
+ * - 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.
@@ -24,15 +27,156 @@ function init(a) {
     adapter.subscribeStates('control.season.active');
     adapter.subscribeStates('control.pump.backwash_start');
     adapter.subscribeStates('control.pump.maintenance_active');
-    adapter.subscribeStates('control.energy.reset'); // NEU: Energie-Reset-Button
+    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.active_helper', { 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.active_helper', { val: '', 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 - ID des geänderten States
+ * @param {string} id - Objekt-ID des geänderten States
  * @param {ioBroker.State} state - Neuer State-Wert
  */
 async function handleStateChange(id, state) {
@@ -41,39 +185,43 @@ async function handleStateChange(id, state) {
             return;
         }
 
-        // === SAISONSTATUS =====================================================
+        // === 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 ====================================================
+        // === WARTUNGSMODUS ===
         if (id.endsWith('control.pump.maintenance_active')) {
             const active = !!state.val;
             const notify = (await adapter.getStateAsync('control.pump.notifications_enabled'))?.val;
 
             if (active) {
-                await adapter.setStateAsync('pump.mode', { val: 'override', ack: true });
+                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.active_helper', { val: 'controlHelper', ack: true });
                 await adapter.setStateAsync('pump.pump_switch', { val: false, ack: false });
                 adapter.log.info('[controlHelper] Wartungsmodus aktiviert. Automatik pausiert.');
 
                 if (notify) {
-                    await sendNotification(
-                        'Wartungsmodus aktiviert. Automatikfunktionen sind vorübergehend deaktiviert.',
-                    );
+                    await _sendSpeech('Wartungsmodus aktiviert. Automatikfunktionen deaktiviert.');
                 }
             } else {
-                await adapter.setStateAsync('pump.mode', { val: 'auto', ack: true });
-                adapter.log.info('[controlHelper] Wartungsmodus beendet. Automatik wieder aktiv.');
+                await adapter.setStateAsync('pump.mode', { val: previousPumpMode, ack: true });
+                await adapter.setStateAsync('pump.active_helper', { val: '', ack: true });
+                await adapter.setStateAsync('pump.reason', { val: '', ack: true });
+                previousPumpMode = null;
 
+                adapter.log.info('[controlHelper] Wartungsmodus beendet. Automatik wieder aktiv.');
                 if (notify) {
-                    await sendNotification('Wartungsmodus beendet. Automatikbetrieb ist wieder aktiv.');
+                    await _sendSpeech('Wartungsmodus beendet. Automatikbetrieb wieder aktiv.');
                 }
             }
         }
 
-        // === RÜCKSPÜLUNG ======================================================
+        // === 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;
@@ -86,14 +234,17 @@ async function handleStateChange(id, state) {
             }
 
             await adapter.setStateAsync('control.pump.backwash_active', { val: true, ack: true });
-            await adapter.setStateAsync('pump.mode', { val: 'override', 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.active_helper', { 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 (Dauer: ${duration} Minuten).`);
+            adapter.log.info(`[controlHelper] Rückspülung gestartet (${duration} Minuten).`);
 
             if (notify) {
-                await sendNotification(`Rückspülung gestartet. Dauer ${durationText}.`);
+                await _sendSpeech(`Rückspülung gestartet. Dauer ${durationText}.`);
             }
 
             if (backwashTimer) {
@@ -104,12 +255,13 @@ async function handleStateChange(id, state) {
                     try {
                         await adapter.setStateAsync('pump.pump_switch', { val: false, ack: false });
                         await adapter.setStateAsync('pump.mode', { val: prevMode, ack: true });
+                        await adapter.setStateAsync('pump.active_helper', { val: '', 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 sendNotification('Rückspülung abgeschlossen. Automatikmodus wieder aktiv.');
+                            await _sendSpeech('Rückspülung abgeschlossen. Automatikmodus wieder aktiv.');
                         }
                     } catch (err) {
                         adapter.log.warn(`[controlHelper] Fehler beim Beenden der Rückspülung: ${err.message}`);
@@ -119,35 +271,39 @@ async function handleStateChange(id, state) {
             );
         }
 
-        // === ENERGIEZÄHLER RESET =============================================
+        // === 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-Reset ausgelöst (${timestamp})`);
+            adapter.log.info(`[controlHelper] Energiezähler wird vollständig zurückgesetzt (${timestamp}).`);
 
-            try {
-                // Den eigentlichen Reset im consumptionHelper ausführen
-                const consumptionHelper = require('../helpers/consumptionHelper');
-                if (consumptionHelper && typeof consumptionHelper.resetAll === 'function') {
-                    await consumptionHelper.resetAll(adapter);
-                } else {
-                    adapter.log.warn('[controlHelper] consumptionHelper.resetAll() nicht verfügbar');
-                }
+            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',
+            ];
 
-                // Button wieder zurücksetzen
-                await adapter.setStateAsync('control.energy.reset', { val: false, ack: true });
+            for (const sid of consStates) {
+                await adapter.setStateAsync(sid, { val: 0, ack: true });
+            }
 
-                // Log & Sprach-/Benachrichtigungsausgabe
-                const msg = `Energiezähler wurde am ${timestamp} vollständig zurückgesetzt.`;
-                adapter.log.info(`[controlHelper] ${msg}`);
+            await adapter.setStateAsync('control.energy.reset', { val: false, ack: true });
 
-                if (notify) {
-                    await sendNotification(msg);
-                }
-            } catch (err) {
-                adapter.log.error(`[controlHelper] Fehler beim Energiezähler-Reset: ${err.message}`);
+            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) {
@@ -156,32 +312,35 @@ async function handleStateChange(id, state) {
 }
 
 /**
- * Leitet Benachrichtigungen an speechHelper weiter
- * (setzt nur speech.last_text, Versand erfolgt dort)
+ * Sendet Text an speech.queue
  *
- * @param {string} text - Nachrichtentext, der gesendet werden soll
+ * @param {string} text - Nachricht, die an speech.queue gesendet werden soll
  */
-async function sendNotification(text) {
+async function _sendSpeech(text) {
     if (!text) {
         return;
     }
-
     try {
-        await adapter.setStateAsync('speech.last_text', { val: text, ack: false });
-        adapter.log.debug(`[controlHelper] Benachrichtigung an speechHelper weitergeleitet: ${text}`);
+        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 Weiterleiten der Benachrichtigung: ${err.message}`);
+        adapter.log.warn(`[controlHelper] Fehler beim Senden an speech.queue: ${err.message}`);
     }
 }
 
 /**
- * Stoppt Timer und räumt Ressourcen auf.
+ * 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/controlHelper2.js

@@ -0,0 +1,195 @@
+'use strict';
+
+/**
+ * controlHelper2
+ * ----------------------------------------------
+ * Rückspülerinnerungs-Logik (eigenständig)
+ * ----------------------------------------------
+ * - täglicher Check um 12:00 Uhr (lokale Host-Zeit)
+ * - prüft Intervall und letzte Rückspülung
+ * - erzeugt Erinnerungen (Log + speech.queue)
+ * - setzt Erinnerung automatisch zurück, wenn Rückspülung startet
+ * ----------------------------------------------
+ */
+
+// NEU: Modulvariablen
+let adapter;
+let backwashReminderTimer = null;
+let lastReminderDay = null; // verhindert doppelte tägliche Meldungen
+
+// NEU: Initialisierung
+/**
+ * Initialisiert den Rückspülerinnerungs-Helper
+ *
+ * @param {import('iobroker').Adapter} a – ioBroker-Adapterinstanz
+ */
+function init(a) {
+    adapter = a;
+    adapter.log.info('[controlHelper2] Rückspülerinnerung initialisiert (täglicher Check um 12:00 Uhr).');
+
+    // Rückspülstart abonnieren, um Erinnerung zurückzusetzen
+    adapter.subscribeStates('control.pump.backwash_start');
+
+    // Täglichen Check planen
+    _scheduleBackwashReminder().catch(err =>
+        adapter.log.error(`[controlHelper2] Fehler bei _scheduleBackwashReminder(): ${err.message}`),
+    );
+}
+
+// NEU: Plant täglichen Timer um 12:00 Uhr lokale Zeit
+async function _scheduleBackwashReminder() {
+    try {
+        if (backwashReminderTimer) {
+            clearTimeout(backwashReminderTimer);
+        }
+
+        const now = new Date();
+        const next = new Date();
+        next.setHours(12, 0, 0, 0); // 12:00 Uhr lokale Zeit
+
+        // Wenn 12:00 Uhr heute schon vorbei ist → morgen
+        if (next <= now) {
+            next.setDate(next.getDate() + 1);
+        }
+
+        const diffMs = next - now;
+        adapter.log.debug(`[controlHelper2] Nächster Rückspülerinnerungs-Check geplant für ${next.toLocaleString()}`);
+
+        backwashReminderTimer = setTimeout(async () => {
+            await _runBackwashReminderCheck();
+            await _scheduleBackwashReminder(); // neu planen
+        }, diffMs);
+    } catch (err) {
+        adapter.log.error(`[controlHelper2] Fehler bei _scheduleBackwashReminder(): ${err.message}`);
+    }
+}
+
+// NEU: Führt täglichen Erinnerungs-Check aus
+async function _runBackwashReminderCheck() {
+    try {
+        adapter.log.debug('[controlHelper2] Starte Rückspülerinnerungs-Check ...');
+
+        const reminderActive = (await adapter.getStateAsync('control.pump.backwash_reminder_active'))?.val;
+        if (!reminderActive) {
+            adapter.log.debug('[controlHelper2] Rückspülerinnerung deaktiviert – Check übersprungen.');
+            return;
+        }
+
+        const intervalDays = Number((await adapter.getStateAsync('control.pump.backwash_interval_days'))?.val || 7);
+        const lastDateStr = (await adapter.getStateAsync('control.pump.backwash_last_date'))?.val || '';
+
+        const now = new Date();
+        const todayKey = now.toISOString().split('T')[0]; // yyyy-mm-dd
+
+        // Verhindert doppelte Erinnerungen am selben Tag
+        if (lastReminderDay === todayKey) {
+            adapter.log.debug('[controlHelper2] Erinnerung für heute bereits gesendet.');
+            return;
+        }
+
+        let daysSince = null;
+        if (lastDateStr) {
+            const lastDate = new Date(lastDateStr);
+            const diffMs = now - lastDate;
+            daysSince = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+        }
+
+        if (daysSince === null) {
+            adapter.log.debug('[controlHelper2] Keine letzte Rückspülung bekannt – keine Erinnerung.');
+            return;
+        }
+
+        const notify = (await adapter.getStateAsync('control.pump.notifications_enabled'))?.val;
+        const speechEnabled = notify === true;
+
+        if (daysSince >= intervalDays) {
+            // Fällig oder überfällig
+            await adapter.setStateAsync('control.pump.backwash_required', { val: true, ack: true });
+            let text;
+
+            if (daysSince === intervalDays) {
+                text = 'Erinnerung: Rückspülung ist wieder fällig.';
+            } else {
+                const over = daysSince - intervalDays;
+                text = `Erinnerung: Rückspülung ist seit ${over} Tag${over === 1 ? '' : 'en'} überfällig.`;
+            }
+
+            adapter.log.info(`[controlHelper2] ${text}`);
+            if (speechEnabled) {
+                await _sendSpeech(text);
+            }
+
+            lastReminderDay = todayKey;
+        } else {
+            adapter.log.debug(`[controlHelper2] Rückspülung noch nicht fällig (${daysSince}/${intervalDays} Tage).`);
+        }
+    } catch (err) {
+        adapter.log.warn(`[controlHelper2] Fehler beim Erinnerungs-Check: ${err.message}`);
+    }
+}
+
+// NEU: Rücksetzung nach Rückspülstart
+/**
+ * Reagiert auf State-Änderungen (z. B. Rückspülstart).
+ *
+ * @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;
+        }
+        if (!id.endsWith('control.pump.backwash_start') || !state.val) {
+            return;
+        }
+
+        adapter.log.debug('[controlHelper2] Rückspülstart erkannt – Erinnerung wird zurückgesetzt.');
+
+        await adapter.setStateAsync('control.pump.backwash_required', { val: false, ack: true });
+        await adapter.setStateAsync('control.pump.backwash_last_date', {
+            val: new Date().toISOString(),
+            ack: true,
+        });
+
+        const notify = (await adapter.getStateAsync('control.pump.notifications_enabled'))?.val;
+        if (notify) {
+            const text = 'Rückspülerinnerung wurde zurückgesetzt. Rückspülzyklus neu gestartet.';
+            adapter.log.info(`[controlHelper2] ${text}`);
+            await _sendSpeech(text);
+        }
+    } catch (err) {
+        adapter.log.warn(`[controlHelper2] Fehler bei handleStateChange(): ${err.message}`);
+    }
+}
+
+// NEU: Sprachausgabe
+async function _sendSpeech(text) {
+    if (!text) {
+        return;
+    }
+    try {
+        await adapter.setStateAsync('speech.queue', { val: text, ack: false });
+        adapter.log.debug(`[controlHelper2] Nachricht an speech.queue: ${text}`);
+    } catch (err) {
+        adapter.log.warn(`[controlHelper2] Fehler beim Senden an speech.queue: ${err.message}`);
+    }
+}
+
+// NEU: Aufräumen
+/**
+ * Stoppt den Rückspülerinnerungs-Timer und räumt Variablen auf.
+ *
+ * @returns {void}
+ */
+function cleanup() {
+    if (backwashReminderTimer) {
+        clearTimeout(backwashReminderTimer);
+        backwashReminderTimer = null;
+    }
+    lastReminderDay = null;
+    adapter.log.debug('[controlHelper2] Cleanup ausgeführt.');
+}
+
+// NEU: Exporte
+module.exports = { init, handleStateChange, cleanup };

package/lib/helpers/debugLogHelper.js

@@ -42,10 +42,10 @@ const debugLogHelper = {
         if (target !== 'none') {
             this._subscribeTarget(target);
         } else {
-            adapter.log.info('[debugLogHelper] Kein Bereich ausgewählt – Logger inaktiv.');
+            adapter.log.debug('[debugLogHelper] Kein Bereich ausgewählt – Logger inaktiv.');
         }
 
-        adapter.log.info('[debugLogHelper] Initialisierung abgeschlossen');
+        adapter.log.debug('[debugLogHelper] Initialisierung abgeschlossen');
     },
 
     /**
@@ -104,18 +104,18 @@ const debugLogHelper = {
         }
         if (this.subscribedTarget && this.subscribedTarget !== 'none') {
             this.adapter.unsubscribeStates(`${this.subscribedTarget}.*`);
-            this.adapter.log.info(`[debugLogHelper] Überwachung für Bereich "${this.subscribedTarget}" beendet.`);
+            this.adapter.log.debug(`[debugLogHelper] Überwachung für Bereich "${this.subscribedTarget}" beendet.`);
         }
 
         this.subscribedTarget = newTarget;
 
         if (newTarget === 'none') {
-            this.adapter.log.info('[debugLogHelper] Kein Bereich aktiv.');
+            this.adapter.log.debug('[debugLogHelper] Kein Bereich aktiv.');
             return;
         }
 
         this._subscribeTarget(newTarget);
-        this.adapter.log.info(`[debugLogHelper] Überwachung für Bereich "${newTarget}" gestartet.`);
+        this.adapter.log.debug(`[debugLogHelper] Überwachung für Bereich "${newTarget}" gestartet.`);
         await this._appendLog(
             `\n=== Debug-Log gestartet: Bereich "${newTarget}" @ ${new Date().toLocaleString()} ===\n`,
         );

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 activeHelper = (await this.adapter.getStateAsync('pump.active_helper'))?.val || '';
+            if (activeHelper === '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)`,
                 );
             }