iobroker.poolcontrol 0.1.1 → 0.2.0

package/README.md

@@ -48,6 +48,18 @@ Er ermöglicht die Automatisierung von Pumpen, Temperatur- und Solarsteuerung so
   - Ausgabe über Alexa oder Telegram
   - Ansagen bei Pumpenstart/-stopp, Fehlern oder Temperaturschwellen
 
+- **Systemcheck (Diagnosebereich)**
+  Ab Version **0.2.0** enthält der Adapter einen neuen Diagnosebereich **SystemCheck**.  
+  Er bietet interne Debug-Logs, mit denen bestimmte Teilbereiche (z. B. Pumpen-, Solar- oder Temperatursteuerung) gezielt überwacht werden können.
+
+  *Funktionen:*
+  - Auswahl des zu überwachenden Bereichs
+  - Fortlaufendes Log der letzten Änderungen
+  - Manuelles Löschen des Logs möglich
+
+  Dieser Bereich dient ausschließlich der Analyse und Fehlerdiagnose.  
+  Im normalen Betrieb sollte die Überwachung deaktiviert bleiben.
+
 ---
 
 ## Installation
@@ -94,6 +106,19 @@ Funktionen können sich ändern, bitte regelmäßig den Changelog beachten.
 ## Changelog
 Auszug, vollständige Liste siehe `io-package.json`:
 
+### 0.2.0 (2025-10-06)
+- Neuer Diagnosebereich **SystemCheck** für interne Debug-Logs und Analysen.
+- Möglichkeit, einzelne Adapterbereiche (z. B. Pumpe, Solar, Temperatur) gezielt zu überwachen.
+- Fortlaufendes Textprotokoll mit manueller Löschfunktion.
+- Alle bisherigen Debug-Funktionen aus `zz_debuglogs` in `SystemCheck.debug_logs` integriert.
+- Vorbereitung für zukünftige Diagnose-Erweiterungen (Export, Systemprüfung, Plausibilitäts-Checks).
+
+
+### 0.1.2
+- Verbesserung: Beim Adapterstart werden nun die letzten bekannten Temperaturwerte aller aktiven Sensoren (z. B. Oberfläche, Kollektor, Außentemperatur usw.) automatisch übernommen.  
+- Dadurch werden auch Sensoren korrekt angezeigt, die ihren Messwert nur selten aktualisieren (z. B. Homematic oder stromsparende Funk-Sensoren).  
+- Keine Änderung am Verhalten der restlichen Logik, reine Komfort- und Stabilitätsverbesserung.
+
 ### 0.1.1
 - Fehlerbehebung: Endlosschleife zwischen `pump_switch` und externer Steckdose (`deviceId`) behoben, die bei bestimmten Smart-Steckdosen (z. B. Shelly, Tasmota, FritzDECT) auftreten konnte.  
 - Verbesserte Stabilität im `pumpHelper` durch interne Rückkopplungsprüfung.  

package/admin/jsonConfig.json

@@ -557,7 +557,7 @@
           "sm": 3,
 		  "md": 3,
 		  "lg": 3,
-		  "xl": 3,
+		  "xl": 3
         },
         "time2_end": {
           "type": "text",
@@ -958,6 +958,8 @@
 		  "type": "number",
 		  "label": "Strompreis (€ / kWh)",
 		  "default": 0.35,
+          "min": 0,
+          "step": 0.01,
 		  "xs": 12,
           "sm": 3,
 		  "md": 3,

package/io-package.json

@@ -1,8 +1,34 @@
 {
   "common": {
     "name": "poolcontrol",
-    "version": "0.1.1",
+    "version": "0.2.0",
     "news": {
+      "0.2.0": {
+       "en": "New diagnostic area 'SystemCheck' for internal debug logs and future analysis tools.",
+       "de": "Neuer Diagnosebereich 'SystemCheck' für interne Debug-Logs und künftige Analysefunktionen.",
+       "ru": "Новая диагностическая область 'SystemCheck' для внутренних журналов отладки и будущих инструментов анализа.",
+       "pt": "Nova área de diagnóstico 'SystemCheck' para logs de depuração internos e futuras ferramentas de análise.",
+       "nl": "Nieuw diagnostisch gebied 'SystemCheck' voor interne foutopsporingslogboeken en toekomstige analysetools.",
+       "fr": "Nouvelle zone de diagnostic 'SystemCheck' pour les journaux de débogage internes et les futurs outils d'analyse.",
+       "it": "Nuova area diagnostica 'SystemCheck' per i log di debug interni e futuri strumenti di analisi.",
+       "es": "Nueva área de diagnóstico 'SystemCheck' para registros internos de depuración y futuras herramientas de análisis.",
+       "pl": "Nowy obszar diagnostyczny 'SystemCheck' dla wewnętrznych dzienników debugowania i przyszłych narzędzi analitycznych.",
+       "uk": "Нова діагностична область 'SystemCheck' для внутрішніх журналів налагодження та майбутніх інструментів аналізу.",
+       "zh-cn": "新的诊断区域“SystemCheck”，用于内部调试日志和未来的分析工具。"
+      },
+      "0.1.2": {
+       "en": "Improved: The last known temperature values of all active sensors are now read at adapter start. Sensors that report rarely are now displayed correctly.",
+       "de": "Verbesserung: Beim Adapterstart werden nun die letzten bekannten Temperaturwerte aller aktiven Sensoren übernommen. Sensoren, die nur selten Werte senden, werden jetzt korrekt angezeigt.",
+       "ru": "Улучшение: При запуске адаптера теперь считываются последние известные значения температуры всех активных датчиков.",
+       "pt": "Melhoria: Os últimos valores de temperatura conhecidos de todos os sensores ativos agora são lidos ao iniciar o adaptador.",
+       "nl": "Verbetering: Bij het starten van de adapter worden nu de laatst bekende temperatuurwaarden van alle actieve sensoren opgehaald.",
+       "fr": "Amélioration : les dernières valeurs de température connues de tous les capteurs actifs sont désormais lues au démarrage de l’adaptateur.",
+       "it": "Miglioramento: all'avvio dell'adattatore vengono ora letti gli ultimi valori di temperatura noti di tutti i sensori attivi.",
+       "es": "Mejora: ahora se leen al iniciar el adaptador los últimos valores de temperatura conocidos de todos los sensores activos.",
+       "pl": "Ulepszenie: podczas uruchamiania adaptera odczytywane są ostatnie znane wartości temperatury wszystkich aktywnych czujników.",
+       "uk": "Покращення: під час запуску адаптера тепер зчитуються останні відомі значення температури всіх активних датчиків.",
+       "zh-cn": "改进：适配器启动时现在会读取所有活动传感器的最后已知温度值。"
+      },
       "0.1.1": {
        "en": "Fixed endless loop between pump_switch and deviceId for some smart sockets",
        "de": "Endlosschleife zwischen pump_switch und Steckdose (deviceId) behoben",

package/lib/helpers/consumptionHelper.js

@@ -4,21 +4,32 @@
  * consumptionHelper
  * - Nutzt externen kWh-Zähler (objectId aus Config)
  * - Berechnet Periodenwerte (Tag/Woche/Monat/Jahr)
- * - Berechnet Kosten anhand Strompreis (€/kWh)
+ * - Berechnet Kosten anhand Strompreis (€/kWh) mit additiver Logik über Neustarts
  * - Offset-Mechanismus: summiert alte Werte bei Zählerwechsel/Reset auf
+ * - NEU: Erhält Tages-/Wochen-/Monats-/Jahreswerte über Neustarts (keine Datenpunkte neu!)
  */
 
 const consumptionHelper = {
     adapter: null,
-    energyId: null, // Objekt-ID des externen kWh-Zählers
-    price: 0, // Strompreis €/kWh
-    baselines: {}, // { day, week, month, year }
+    energyId: null,
+    price: 0,
+    baselines: {},
     resetTimer: null,
 
+    // interne Speicher für additive Berechnung
+    lastKnownPrice: 0,
+    baseTotalKwh: 0,
+    baseTotalEur: 0,
+
     init(adapter) {
         this.adapter = adapter;
         this.energyId = adapter.config.external_energy_total_id || null;
-        this.price = adapter.config.energy_price_eur_kwh || 0;
+
+        // Komma/Punkt tolerant interpretieren
+        this.price = parseFloat(String(adapter.config.energy_price_eur_kwh).replace(',', '.')) || 0;
+        this.lastKnownPrice = this.price;
+
+        this.adapter.log.info(`[consumptionHelper] Strompreis: ${this.price} €/kWh`);
 
         if (this.energyId) {
             adapter.subscribeForeignStates(this.energyId);
@@ -27,15 +38,31 @@ const consumptionHelper = {
             adapter.log.info('[consumptionHelper] Kein externer kWh-Zähler konfiguriert → Verbrauchslogik inaktiv.');
         }
 
-        // Reset-Timer für Mitternacht
         this._scheduleDailyReset();
+        this._loadCostBaselines(); // Basiswerte laden
+        this._restoreBaselinesFromStates(); // <-- NEU: Baselines aus bestehenden States wiederherstellen
     },
 
-    async handleStateChange(id, state) {
-        if (!state) {
-            return;
+    async _loadCostBaselines() {
+        try {
+            const totalKwh = (await this.adapter.getStateAsync('consumption.total_kwh'))?.val || 0;
+            const totalEur = (await this.adapter.getStateAsync('costs.total_eur'))?.val || 0;
+
+            this.baseTotalKwh = totalKwh;
+            this.baseTotalEur = totalEur;
+
+            this.adapter.log.info(
+                `[consumptionHelper] Kosten-Basis geladen → ${this.baseTotalEur.toFixed(
+                    2,
+                )} € bei ${this.baseTotalKwh.toFixed(3)} kWh`,
+            );
+        } catch (err) {
+            this.adapter.log.warn(`[consumptionHelper] Fehler beim Laden der Kosten-Basis: ${err.message}`);
         }
-        if (id !== this.energyId) {
+    },
+
+    async handleStateChange(id, state) {
+        if (!state || id !== this.energyId) {
             return;
         }
 
@@ -49,37 +76,27 @@ const consumptionHelper = {
 
     async _updateConsumption(totalNowRaw) {
         try {
-            // Offset laden
             const offset = (await this.adapter.getStateAsync('consumption.offset_kwh'))?.val || 0;
             const last = (await this.adapter.getStateAsync('consumption.last_total_kwh'))?.val || 0;
-
             let totalNow = totalNowRaw;
 
-            // Prüfen: Reset oder neues Gerät?
+            // Reset-Erkennung
             if (totalNowRaw < last) {
                 this.adapter.log.warn('[consumptionHelper] Zähler-Reset erkannt → Offset wird angepasst');
                 const newOffset = offset + last;
-                await this.adapter.setStateAsync('consumption.offset_kwh', {
-                    val: newOffset,
-                    ack: true,
-                });
+                await this.adapter.setStateAsync('consumption.offset_kwh', { val: newOffset, ack: true });
                 totalNow = newOffset + totalNowRaw;
             } else {
                 totalNow = offset + totalNowRaw;
             }
 
-            // Aktuellen Gesamtwert setzen
-            await this.adapter.setStateAsync('consumption.total_kwh', {
-                val: totalNow,
-                ack: true,
-            });
+            await this.adapter.setStateAsync('consumption.total_kwh', { val: totalNow, ack: true });
 
             // Baselines laden (falls leer)
             if (Object.keys(this.baselines).length === 0) {
                 await this._loadBaselines(totalNow);
             }
 
-            // Differenzen berechnen
             const values = {
                 day: totalNow - (this.baselines.day ?? totalNow),
                 week: totalNow - (this.baselines.week ?? totalNow),
@@ -87,7 +104,7 @@ const consumptionHelper = {
                 year: totalNow - (this.baselines.year ?? totalNow),
             };
 
-            // Negative Werte abfangen (bei Reset)
+            // Negative Werte vermeiden
             for (const key of Object.keys(values)) {
                 if (values[key] < 0) {
                     this.baselines[key] = totalNow;
@@ -95,11 +112,19 @@ const consumptionHelper = {
                 }
             }
 
-            // In States schreiben
-            await this.adapter.setStateAsync('consumption.day_kwh', {
-                val: Number(values.day.toFixed(3)),
-                ack: true,
-            });
+            // === Additive Kostenberechnung über Neustarts ===
+            const deltaKwh = Math.max(0, totalNow - this.baseTotalKwh);
+            const deltaEur = deltaKwh * this.price;
+            const totalCost = this.baseTotalEur + deltaEur;
+
+            // Tages-/Wochen-/Monats-/Jahreskosten berechnen (nur Momentansicht)
+            const dayCost = values.day * this.price;
+            const weekCost = values.week * this.price;
+            const monthCost = values.month * this.price;
+            const yearCost = values.year * this.price;
+
+            // States schreiben
+            await this.adapter.setStateAsync('consumption.day_kwh', { val: Number(values.day.toFixed(3)), ack: true });
             await this.adapter.setStateAsync('consumption.week_kwh', {
                 val: Number(values.week.toFixed(3)),
                 ack: true,
@@ -113,40 +138,25 @@ const consumptionHelper = {
                 ack: true,
             });
 
-            // Kosten berechnen
             if (this.price > 0) {
-                await this.adapter.setStateAsync('costs.day_eur', {
-                    val: Number((values.day * this.price).toFixed(2)),
-                    ack: true,
-                });
-                await this.adapter.setStateAsync('costs.week_eur', {
-                    val: Number((values.week * this.price).toFixed(2)),
-                    ack: true,
-                });
-                await this.adapter.setStateAsync('costs.month_eur', {
-                    val: Number((values.month * this.price).toFixed(2)),
-                    ack: true,
-                });
-                await this.adapter.setStateAsync('costs.year_eur', {
-                    val: Number((values.year * this.price).toFixed(2)),
-                    ack: true,
-                });
-                await this.adapter.setStateAsync('costs.total_eur', {
-                    val: Number((totalNow * this.price).toFixed(2)),
-                    ack: true,
-                });
+                await this.adapter.setStateAsync('costs.day_eur', { val: Number(dayCost.toFixed(2)), ack: true });
+                await this.adapter.setStateAsync('costs.week_eur', { val: Number(weekCost.toFixed(2)), ack: true });
+                await this.adapter.setStateAsync('costs.month_eur', { val: Number(monthCost.toFixed(2)), ack: true });
+                await this.adapter.setStateAsync('costs.year_eur', { val: Number(yearCost.toFixed(2)), ack: true });
+                await this.adapter.setStateAsync('costs.total_eur', { val: Number(totalCost.toFixed(2)), ack: true });
             }
 
-            // Letzten Stand des externen Zählers merken
-            await this.adapter.setStateAsync('consumption.last_total_kwh', {
-                val: totalNowRaw,
-                ack: true,
-            });
+            // Letzten Zählerwert speichern
+            await this.adapter.setStateAsync('consumption.last_total_kwh', { val: totalNowRaw, ack: true });
+
+            // NEU: aktuelle Baselines persistent sichern
+            await this._saveBaselines();
         } catch (err) {
             this.adapter.log.warn(`[consumptionHelper] Fehler bei Verbrauchsupdate: ${err.message}`);
         }
     },
 
+    // Lädt Baselines beim Start, wenn im Speicher leer
     async _loadBaselines(totalNow) {
         this.baselines = {};
         const day = (await this.adapter.getStateAsync('consumption.day_kwh'))?.val;
@@ -162,6 +172,89 @@ const consumptionHelper = {
         this.adapter.log.info(`[consumptionHelper] Baselines geladen: ${JSON.stringify(this.baselines)}`);
     },
 
+    // NEU: Baselines aus States rekonstruieren (beim Adapterstart)
+    async _restoreBaselinesFromStates() {
+        try {
+            const totalNow = (await this.adapter.getStateAsync('consumption.total_kwh'))?.val || 0;
+            const day = (await this.adapter.getStateAsync('consumption.day_kwh'))?.val || 0;
+            const week = (await this.adapter.getStateAsync('consumption.week_kwh'))?.val || 0;
+            const month = (await this.adapter.getStateAsync('consumption.month_kwh'))?.val || 0;
+            const year = (await this.adapter.getStateAsync('consumption.year_kwh'))?.val || 0;
+
+            this.baselines.day = totalNow - day;
+            this.baselines.week = totalNow - week;
+            this.baselines.month = totalNow - month;
+            this.baselines.year = totalNow - year;
+
+            this.adapter.log.info(`[consumptionHelper] Bestehende Verbrauchswerte wiederhergestellt.`);
+        } catch (err) {
+            this.adapter.log.warn(
+                `[consumptionHelper] Fehler beim Wiederherstellen der Verbrauchsstände: ${err.message}`,
+            );
+        }
+    },
+
+    // NEU: Aktuelle Baselines speichern (persistente Sicherung)
+    async _saveBaselines() {
+        try {
+            await this.adapter.setStateAsync('consumption.day_kwh', {
+                val: (await this.adapter.getStateAsync('consumption.day_kwh'))?.val,
+                ack: true,
+            });
+            await this.adapter.setStateAsync('consumption.week_kwh', {
+                val: (await this.adapter.getStateAsync('consumption.week_kwh'))?.val,
+                ack: true,
+            });
+            await this.adapter.setStateAsync('consumption.month_kwh', {
+                val: (await this.adapter.getStateAsync('consumption.month_kwh'))?.val,
+                ack: true,
+            });
+            await this.adapter.setStateAsync('consumption.year_kwh', {
+                val: (await this.adapter.getStateAsync('consumption.year_kwh'))?.val,
+                ack: true,
+            });
+        } catch (err) {
+            this.adapter.log.warn(`[consumptionHelper] Fehler beim Speichern der Baselines: ${err.message}`);
+        }
+    },
+
+    // === NEU: Manueller Gesamreset für Verbrauch & Kosten ====================
+    async resetAll(adapter) {
+        try {
+            this.adapter = adapter;
+            adapter.log.warn('[consumptionHelper] Manueller Reset aller Verbrauchs- und Kostendaten');
+
+            // Verbrauchswerte nullen
+            const consumptionKeys = [
+                'day_kwh',
+                'week_kwh',
+                'month_kwh',
+                'year_kwh',
+                'total_kwh',
+                'offset_kwh',
+                'last_total_kwh',
+            ];
+            for (const key of consumptionKeys) {
+                await adapter.setStateAsync(`consumption.${key}`, { val: 0, ack: true });
+            }
+
+            // Kostenwerte nullen
+            const costKeys = ['day_eur', 'week_eur', 'month_eur', 'year_eur', 'total_eur'];
+            for (const key of costKeys) {
+                await adapter.setStateAsync(`costs.${key}`, { val: 0, ack: true });
+            }
+
+            // interne Speicher ebenfalls zurücksetzen
+            this.baselines = {};
+            this.baseTotalKwh = 0;
+            this.baseTotalEur = 0;
+
+            adapter.log.info('[consumptionHelper] Verbrauch und Kosten erfolgreich auf 0 gesetzt');
+        } catch (err) {
+            this.adapter.log.error(`[consumptionHelper] Fehler beim manuellen Reset: ${err.message}`);
+        }
+    },
+
     _scheduleDailyReset() {
         const now = new Date();
         const nextMidnight = new Date(now);

package/lib/helpers/controlHelper.js

@@ -0,0 +1,187 @@
+'use strict';
+
+/**
+ * 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
+ */
+
+let adapter;
+let backwashTimer = 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'); // NEU: Energie-Reset-Button
+
+    adapter.log.debug('[controlHelper] Überwachung der Control-States aktiviert');
+}
+
+/**
+ * Reagiert auf Änderungen der States im Bereich control.*
+ *
+ * @param {string} id - 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) {
+                await adapter.setStateAsync('pump.mode', { val: 'override', 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.',
+                    );
+                }
+            } else {
+                await adapter.setStateAsync('pump.mode', { val: 'auto', ack: true });
+                adapter.log.info('[controlHelper] Wartungsmodus beendet. Automatik wieder aktiv.');
+
+                if (notify) {
+                    await sendNotification('Wartungsmodus beendet. Automatikbetrieb ist 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('pump.mode', { val: 'override', 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).`);
+
+            if (notify) {
+                await sendNotification(`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('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.');
+                        }
+                    } 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-Reset ausgelöst (${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');
+                }
+
+                // Button wieder zurücksetzen
+                await adapter.setStateAsync('control.energy.reset', { val: false, ack: true });
+
+                // Log & Sprach-/Benachrichtigungsausgabe
+                const msg = `Energiezähler wurde am ${timestamp} vollständig zurückgesetzt.`;
+                adapter.log.info(`[controlHelper] ${msg}`);
+
+                if (notify) {
+                    await sendNotification(msg);
+                }
+            } catch (err) {
+                adapter.log.error(`[controlHelper] Fehler beim Energiezähler-Reset: ${err.message}`);
+            }
+        }
+    } catch (err) {
+        adapter.log.error(`[controlHelper] Fehler bei State-Änderung: ${err.message}`);
+    }
+}
+
+/**
+ * Leitet Benachrichtigungen an speechHelper weiter
+ * (setzt nur speech.last_text, Versand erfolgt dort)
+ *
+ * @param {string} text - Nachrichtentext, der gesendet werden soll
+ */
+async function sendNotification(text) {
+    if (!text) {
+        return;
+    }
+
+    try {
+        await adapter.setStateAsync('speech.last_text', { val: text, ack: false });
+        adapter.log.debug(`[controlHelper] Benachrichtigung an speechHelper weitergeleitet: ${text}`);
+    } catch (err) {
+        adapter.log.warn(`[controlHelper] Fehler beim Weiterleiten der Benachrichtigung: ${err.message}`);
+    }
+}
+
+/**
+ * Stoppt Timer und räumt Ressourcen auf.
+ */
+function cleanup() {
+    if (backwashTimer) {
+        clearTimeout(backwashTimer);
+        backwashTimer = null;
+    }
+}
+
+module.exports = { init, handleStateChange, cleanup };