iobroker.poolcontrol 1.2.0 → 1.2.1

package/lib/helpers/consumptionHelper.js

@@ -27,13 +27,13 @@ const consumptionHelper = {
         this.price = parseFloat(String(adapter.config.energy_price_eur_kwh).replace(',', '.')) || 0;
         this.lastKnownPrice = this.price;
 
-        this.adapter.log.debug(`[consumptionHelper] Strompreis: ${this.price} €/kWh`);
+        this.adapter.log.debug(`[consumptionHelper] energy price: ${this.price} €/kWh`);
 
         if (this.energyId) {
             adapter.subscribeForeignStates(this.energyId);
-            adapter.log.debug(`[consumptionHelper] Überwache externen kWh-Zähler: ${this.energyId}`);
+            adapter.log.debug(`[consumptionHelper] monitoring external kWh meter: ${this.energyId}`);
         } else {
-            adapter.log.debug('[consumptionHelper] Kein externer kWh-Zähler konfiguriert → Verbrauchslogik inaktiv.');
+            adapter.log.debug('[consumptionHelper] no external kWh meter configured -> consumption logic inactive.');
         }
 
         this._scheduleDailyReset();
@@ -53,12 +53,12 @@ const consumptionHelper = {
             this.baseTotalKwh = totalKwh;
             this.baseTotalEur = totalEur;
             this.adapter.log.debug(
-                `[consumptionHelper] Kosten-Basis geladen → ${this.baseTotalEur.toFixed(
+                `[consumptionHelper] cost baseline loaded -> ${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}`);
+            this.adapter.log.warn(`[consumptionHelper] error loading cost baseline: ${err.message}`);
         }
     },
 
@@ -83,11 +83,11 @@ const consumptionHelper = {
             if (totalNowRaw < last) {
                 if (offset === 0 && totalNowRaw < 10 && last > 10) {
                     this.adapter.log.warn(
-                        '[consumptionHelper] Überinstallationsschutz aktiv – Zählerstand kleiner, Offset bleibt unverändert.',
+                        '[consumptionHelper] reinstall protection active - meter value decreased, offset remains unchanged.',
                     );
                     totalNow = last; // kein Offset addieren
                 } else {
-                    this.adapter.log.warn('[consumptionHelper] Zähler-Reset erkannt → Offset wird angepasst');
+                    this.adapter.log.warn('[consumptionHelper] meter reset detected -> adjusting offset');
                     const newOffset = offset + last;
                     await this.adapter.setStateAsync('consumption.offset_kwh', { val: newOffset, ack: true });
                     totalNow = newOffset + totalNowRaw;
@@ -151,7 +151,7 @@ const consumptionHelper = {
             await this.adapter.setStateAsync('consumption.last_total_kwh', { val: totalNowRaw, ack: true });
             await this._saveBaselines();
         } catch (err) {
-            this.adapter.log.warn(`[consumptionHelper] Fehler bei Verbrauchsupdate: ${err.message}`);
+            this.adapter.log.warn(`[consumptionHelper] error during consumption update: ${err.message}`);
         }
     },
 
@@ -167,7 +167,7 @@ const consumptionHelper = {
         this.baselines.month = totalNow - (month || 0);
         this.baselines.year = totalNow - (year || 0);
 
-        this.adapter.log.debug(`[consumptionHelper] Baselines geladen: ${JSON.stringify(this.baselines)}`);
+        this.adapter.log.debug(`[consumptionHelper] baselines loaded: ${JSON.stringify(this.baselines)}`);
     },
 
     async _restoreBaselinesFromStates() {
@@ -183,11 +183,9 @@ const consumptionHelper = {
             this.baselines.month = totalNow - month;
             this.baselines.year = totalNow - year;
 
-            this.adapter.log.debug(`[consumptionHelper] Bestehende Verbrauchswerte wiederhergestellt.`);
+            this.adapter.log.debug('[consumptionHelper] existing consumption values restored.');
         } catch (err) {
-            this.adapter.log.warn(
-                `[consumptionHelper] Fehler beim Wiederherstellen der Verbrauchsstände: ${err.message}`,
-            );
+            this.adapter.log.warn(`[consumptionHelper] error restoring consumption values: ${err.message}`);
         }
     },
 
@@ -210,14 +208,14 @@ const consumptionHelper = {
                 ack: true,
             });
         } catch (err) {
-            this.adapter.log.warn(`[consumptionHelper] Fehler beim Speichern der Baselines: ${err.message}`);
+            this.adapter.log.warn(`[consumptionHelper] error saving baselines: ${err.message}`);
         }
     },
 
     async resetAll(adapter) {
         try {
             this.adapter = adapter;
-            adapter.log.warn('[consumptionHelper] Manueller Reset aller Verbrauchs- und Kostendaten');
+            adapter.log.warn('[consumptionHelper] manual reset of all consumption and cost data');
 
             const consumptionKeys = [
                 'day_kwh',
@@ -241,9 +239,9 @@ const consumptionHelper = {
             this.baseTotalKwh = 0;
             this.baseTotalEur = 0;
 
-            adapter.log.info('[consumptionHelper] Verbrauch und Kosten erfolgreich auf 0 gesetzt');
+            adapter.log.info('[consumptionHelper] consumption and costs successfully reset to 0');
         } catch (err) {
-            this.adapter.log.error(`[consumptionHelper] Fehler beim manuellen Reset: ${err.message}`);
+            this.adapter.log.error(`[consumptionHelper] error during manual reset: ${err.message}`);
         }
     },
 
@@ -256,12 +254,12 @@ const consumptionHelper = {
 
         this.resetTimer = setTimeout(async () => {
             try {
-                this.adapter.log.info('[consumptionHelper] Tageszähler-Reset (Mitternacht)');
+                this.adapter.log.info('[consumptionHelper] daily counter reset (midnight)');
                 await this.adapter.setStateAsync('consumption.day_kwh', { val: 0, ack: true });
                 await this.adapter.setStateAsync('costs.day_eur', { val: 0, ack: true });
                 this.baselines.day = (await this.adapter.getStateAsync('consumption.total_kwh'))?.val || 0;
             } catch (err) {
-                this.adapter.log.warn(`[consumptionHelper] Fehler beim Mitternachtsreset: ${err.message}`);
+                this.adapter.log.warn(`[consumptionHelper] error during midnight reset: ${err.message}`);
             }
             this._scheduleDailyReset(); // Timer erneut setzen
         }, msUntilMidnight);
@@ -288,13 +286,13 @@ const consumptionHelper = {
 
                 // Nur wenn heute Montag ist (0 = Sonntag, 1 = Montag)
                 if (nowCheck.getDay() === 1) {
-                    this.adapter.log.info('[consumptionHelper] Wochen-Reset (Montag 00:05)');
+                    this.adapter.log.info('[consumptionHelper] weekly reset (Monday 00:05)');
                     await this.adapter.setStateAsync('consumption.week_kwh', { val: 0, ack: true });
                     await this.adapter.setStateAsync('costs.week_eur', { val: 0, ack: true });
                     this.baselines.week = (await this.adapter.getStateAsync('consumption.total_kwh'))?.val || 0;
                 }
             } catch (err) {
-                this.adapter.log.warn(`[consumptionHelper] Fehler beim Wochenreset: ${err.message}`);
+                this.adapter.log.warn(`[consumptionHelper] error during weekly reset: ${err.message}`);
             }
 
             // Morgen wieder planen
@@ -323,13 +321,13 @@ const consumptionHelper = {
 
                 // Nur am 1. des Monats
                 if (nowCheck.getDate() === 1) {
-                    this.adapter.log.info('[consumptionHelper] Monats-Reset (1. 00:05)');
+                    this.adapter.log.info('[consumptionHelper] monthly reset (1st 00:05)');
                     await this.adapter.setStateAsync('consumption.month_kwh', { val: 0, ack: true });
                     await this.adapter.setStateAsync('costs.month_eur', { val: 0, ack: true });
                     this.baselines.month = (await this.adapter.getStateAsync('consumption.total_kwh'))?.val || 0;
                 }
             } catch (err) {
-                this.adapter.log.warn(`[consumptionHelper] Fehler beim Monatsreset: ${err.message}`);
+                this.adapter.log.warn(`[consumptionHelper] error during monthly reset: ${err.message}`);
             }
 
             // Morgen wieder planen
@@ -358,13 +356,13 @@ const consumptionHelper = {
 
                 // 👉 Nur wenn wirklich 1. Januar
                 if (nowCheck.getMonth() === 0 && nowCheck.getDate() === 1) {
-                    this.adapter.log.info('[consumptionHelper] Jahres-Reset (1. Januar 00:10)');
+                    this.adapter.log.info('[consumptionHelper] yearly reset (January 1st 00:10)');
                     await this.adapter.setStateAsync('consumption.year_kwh', { val: 0, ack: true });
                     await this.adapter.setStateAsync('costs.year_eur', { val: 0, ack: true });
                     this.baselines.year = (await this.adapter.getStateAsync('consumption.total_kwh'))?.val || 0;
                 }
             } catch (err) {
-                this.adapter.log.warn(`[consumptionHelper] Fehler beim Jahresreset: ${err.message}`);
+                this.adapter.log.warn(`[consumptionHelper] error during yearly reset: ${err.message}`);
             }
 
             // Morgen wieder prüfen

package/lib/helpers/controlHelper.js

@@ -21,7 +21,7 @@ let previousPumpMode = null;
  */
 function init(a) {
     adapter = a;
-    adapter.log.info('[controlHelper] initialisiert');
+    adapter.log.info('[controlHelper] initialized');
 
     // States abonnieren
     adapter.subscribeStates('control.season.active');
@@ -32,10 +32,10 @@ function init(a) {
 
     // Täglichen Check planen
     _scheduleDailyCheck().catch(err =>
-        adapter.log.error(`[controlHelper] Fehler bei _scheduleDailyCheck(): ${err.message}`),
+        adapter.log.error(`[controlHelper] error in _scheduleDailyCheck(): ${err.message}`),
     );
 
-    adapter.log.debug('[controlHelper] Überwachung der Control-States aktiviert');
+    adapter.log.debug('[controlHelper] monitoring of control states enabled');
 }
 
 /**
@@ -58,14 +58,14 @@ async function _scheduleDailyCheck() {
         }
 
         const diffMs = next - now;
-        adapter.log.debug(`[controlHelper] Nächster Tages-Umwälzungscheck geplant für ${next.toLocaleTimeString()}`);
+        adapter.log.debug(`[controlHelper] next daily circulation check scheduled for ${next.toLocaleTimeString()}`);
 
         dailyTimer = setTimeout(async () => {
             await _runDailyCirculationCheck();
             await _scheduleDailyCheck();
         }, diffMs);
     } catch (err) {
-        adapter.log.error(`[controlHelper] Fehler bei _scheduleDailyCheck(): ${err.message}`);
+        adapter.log.error(`[controlHelper] error in _scheduleDailyCheck(): ${err.message}`);
     }
 }
 
@@ -74,7 +74,7 @@ async function _scheduleDailyCheck() {
  */
 async function _runDailyCirculationCheck() {
     try {
-        adapter.log.debug('[controlHelper] Starte Tages-Umwälzungscheck ...');
+        adapter.log.debug('[controlHelper] starting daily circulation check ...');
 
         const seasonActive = (await adapter.getStateAsync('status.season_active'))?.val;
         const mode = (await adapter.getStateAsync('control.circulation.mode'))?.val || 'off';
@@ -84,7 +84,7 @@ async function _runDailyCirculationCheck() {
         const pool = Number((await adapter.getStateAsync('temperature.surface.current'))?.val || 0);
 
         if (!seasonActive) {
-            adapter.log.debug('[controlHelper] Saison inaktiv – Tagesprüfung übersprungen.');
+            adapter.log.debug('[controlHelper] season inactive - daily check skipped.');
             return;
         }
 
@@ -119,14 +119,14 @@ async function _runDailyCirculationCheck() {
                 break;
 
             default:
-                adapter.log.debug(`[controlHelper] Modus '${mode}' → keine Aktion.`);
+                adapter.log.debug(`[controlHelper] mode '${mode}' -> no action.`);
                 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}`);
+        adapter.log.error(`[controlHelper] error during daily check: ${err.message}`);
     }
 }
 
@@ -145,7 +145,7 @@ async function _startAutoPumping(missingLiter) {
         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).`);
+        adapter.log.info(`[controlHelper] automatic pumping started (${missingLiter} l missing).`);
         if (notify) {
             await _sendSpeech(`Automatisches Nachpumpen gestartet. Es fehlen ${missingLiter} Liter.`);
         }
@@ -162,14 +162,14 @@ async function _startAutoPumping(missingLiter) {
                 await adapter.setStateAsync('pump.reason', { val: '', ack: true });
                 previousPumpMode = null;
 
-                adapter.log.info('[controlHelper] Nachpumpen abgeschlossen – Tagesziel erreicht.');
+                adapter.log.info('[controlHelper] automatic pumping finished - daily target reached.');
                 if (notify) {
                     await _sendSpeech('Nachpumpen abgeschlossen. Tagesziel erreicht.');
                 }
             }
         }, 60 * 1000);
     } catch (err) {
-        adapter.log.error(`[controlHelper] Fehler beim automatischen Nachpumpen: ${err.message}`);
+        adapter.log.error(`[controlHelper] error during automatic pumping: ${err.message}`);
     }
 }
 
@@ -188,7 +188,7 @@ async function handleStateChange(id, state) {
         // === SAISONSTATUS ===
         if (id.endsWith('control.season.active')) {
             const newVal = !!state.val;
-            adapter.log.info(`[controlHelper] Poolsaison wurde ${newVal ? 'aktiviert' : 'deaktiviert'}.`);
+            adapter.log.info(`[controlHelper] pool season ${newVal ? 'enabled' : 'disabled'}.`);
             await adapter.setStateAsync('status.season_active', { val: newVal, ack: true });
         }
 
@@ -203,7 +203,7 @@ async function handleStateChange(id, state) {
                 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.');
+                adapter.log.info('[controlHelper] maintenance mode enabled. Automation paused.');
 
                 if (notify) {
                     await _sendSpeech('Wartungsmodus aktiviert. Automatikfunktionen deaktiviert.');
@@ -214,7 +214,7 @@ async function handleStateChange(id, state) {
                 await adapter.setStateAsync('pump.reason', { val: '', ack: true });
                 previousPumpMode = null;
 
-                adapter.log.info('[controlHelper] Wartungsmodus beendet. Automatik wieder aktiv.');
+                adapter.log.info('[controlHelper] maintenance mode disabled. Automation active again.');
                 if (notify) {
                     await _sendSpeech('Wartungsmodus beendet. Automatikbetrieb wieder aktiv.');
                 }
@@ -229,7 +229,7 @@ async function handleStateChange(id, state) {
             const active = (await adapter.getStateAsync('control.pump.backwash_active'))?.val;
 
             if (active) {
-                adapter.log.warn('[controlHelper] Rückspülung bereits aktiv – neuer Start abgelehnt.');
+                adapter.log.warn('[controlHelper] backwash already active - rejecting new start.');
                 return;
             }
 
@@ -241,7 +241,7 @@ async function handleStateChange(id, state) {
             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).`);
+            adapter.log.info(`[controlHelper] backwash started (${duration} minutes).`);
 
             if (notify) {
                 await _sendSpeech(`Rückspülung gestartet. Dauer ${durationText}.`);
@@ -259,12 +259,12 @@ async function handleStateChange(id, state) {
                         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.');
+                        adapter.log.info('[controlHelper] backwash finished. Automation active again.');
                         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}`);
+                        adapter.log.warn(`[controlHelper] error while stopping backwash: ${err.message}`);
                     }
                 },
                 duration * 60 * 1000,
@@ -277,7 +277,7 @@ async function handleStateChange(id, state) {
             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}).`);
+            adapter.log.info(`[controlHelper] energy meter will be fully reset (${timestamp}).`);
 
             const consStates = [
                 'consumption.total_kwh',
@@ -301,13 +301,13 @@ async function handleStateChange(id, state) {
             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}`);
+            adapter.log.info('[controlHelper] energy meter and costs have been fully reset.');
             if (notify) {
                 await _sendSpeech(msg);
             }
         }
     } catch (err) {
-        adapter.log.error(`[controlHelper] Fehler bei State-Änderung: ${err.message}`);
+        adapter.log.error(`[controlHelper] error on state change: ${err.message}`);
     }
 }
 
@@ -322,9 +322,9 @@ async function _sendSpeech(text) {
     }
     try {
         await adapter.setStateAsync('speech.queue', { val: text, ack: false });
-        adapter.log.debug(`[controlHelper] Nachricht an speech.queue: ${text}`);
+        adapter.log.debug(`[controlHelper] message sent to speech.queue: ${text}`);
     } catch (err) {
-        adapter.log.warn(`[controlHelper] Fehler beim Senden an speech.queue: ${err.message}`);
+        adapter.log.warn(`[controlHelper] error sending to speech.queue: ${err.message}`);
     }
 }
 

package/lib/helpers/controlHelper2.js

@@ -25,14 +25,14 @@ let lastReminderDay = null; // verhindert doppelte tägliche Meldungen
  */
 function init(a) {
     adapter = a;
-    adapter.log.info('[controlHelper2] Rückspülerinnerung initialisiert (täglicher Check um 12:00 Uhr).');
+    adapter.log.info('[controlHelper2] backwash reminder initialized (daily check at 12:00).');
 
     // 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}`),
+        adapter.log.error(`[controlHelper2] error in _scheduleBackwashReminder(): ${err.message}`),
     );
 }
 
@@ -53,25 +53,25 @@ async function _scheduleBackwashReminder() {
         }
 
         const diffMs = next - now;
-        adapter.log.debug(`[controlHelper2] Nächster Rückspülerinnerungs-Check geplant für ${next.toLocaleString()}`);
+        adapter.log.debug(`[controlHelper2] next backwash reminder check scheduled for ${next.toLocaleString()}`);
 
         backwashReminderTimer = setTimeout(async () => {
             await _runBackwashReminderCheck();
             await _scheduleBackwashReminder(); // neu planen
         }, diffMs);
     } catch (err) {
-        adapter.log.error(`[controlHelper2] Fehler bei _scheduleBackwashReminder(): ${err.message}`);
+        adapter.log.error(`[controlHelper2] error in _scheduleBackwashReminder(): ${err.message}`);
     }
 }
 
 // NEU: Führt täglichen Erinnerungs-Check aus
 async function _runBackwashReminderCheck() {
     try {
-        adapter.log.debug('[controlHelper2] Starte Rückspülerinnerungs-Check ...');
+        adapter.log.debug('[controlHelper2] starting backwash reminder check ...');
 
         const reminderActive = (await adapter.getStateAsync('control.pump.backwash_reminder_active'))?.val;
         if (!reminderActive) {
-            adapter.log.debug('[controlHelper2] Rückspülerinnerung deaktiviert – Check übersprungen.');
+            adapter.log.debug('[controlHelper2] backwash reminder disabled - check skipped.');
             return;
         }
 
@@ -83,7 +83,7 @@ async function _runBackwashReminderCheck() {
 
         // Verhindert doppelte Erinnerungen am selben Tag
         if (lastReminderDay === todayKey) {
-            adapter.log.debug('[controlHelper2] Erinnerung für heute bereits gesendet.');
+            adapter.log.debug('[controlHelper2] reminder already sent for today.');
             return;
         }
 
@@ -95,7 +95,7 @@ async function _runBackwashReminderCheck() {
         }
 
         if (daysSince === null) {
-            adapter.log.debug('[controlHelper2] Keine letzte Rückspülung bekannt – keine Erinnerung.');
+            adapter.log.debug('[controlHelper2] no last backwash date known - no reminder.');
             return;
         }
 
@@ -114,17 +114,17 @@ async function _runBackwashReminderCheck() {
                 text = `Erinnerung: Rückspülung ist seit ${over} Tag${over === 1 ? '' : 'en'} überfällig.`;
             }
 
-            adapter.log.info(`[controlHelper2] ${text}`);
+            adapter.log.info('[controlHelper2] backwash reminder triggered.');
             if (speechEnabled) {
                 await _sendSpeech(text);
             }
 
             lastReminderDay = todayKey;
         } else {
-            adapter.log.debug(`[controlHelper2] Rückspülung noch nicht fällig (${daysSince}/${intervalDays} Tage).`);
+            adapter.log.debug(`[controlHelper2] backwash not due yet (${daysSince}/${intervalDays} days).`);
         }
     } catch (err) {
-        adapter.log.warn(`[controlHelper2] Fehler beim Erinnerungs-Check: ${err.message}`);
+        adapter.log.warn(`[controlHelper2] error during reminder check: ${err.message}`);
     }
 }
 
@@ -144,7 +144,7 @@ async function handleStateChange(id, state) {
             return;
         }
 
-        adapter.log.debug('[controlHelper2] Rückspülstart erkannt – Erinnerung wird zurückgesetzt.');
+        adapter.log.debug('[controlHelper2] backwash start detected - resetting reminder.');
 
         await adapter.setStateAsync('control.pump.backwash_required', { val: false, ack: true });
         await adapter.setStateAsync('control.pump.backwash_last_date', {
@@ -155,11 +155,11 @@ async function handleStateChange(id, state) {
         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}`);
+            adapter.log.info('[controlHelper2] backwash reminder has been reset.');
             await _sendSpeech(text);
         }
     } catch (err) {
-        adapter.log.warn(`[controlHelper2] Fehler bei handleStateChange(): ${err.message}`);
+        adapter.log.warn(`[controlHelper2] error in handleStateChange(): ${err.message}`);
     }
 }
 
@@ -170,9 +170,9 @@ async function _sendSpeech(text) {
     }
     try {
         await adapter.setStateAsync('speech.queue', { val: text, ack: false });
-        adapter.log.debug(`[controlHelper2] Nachricht an speech.queue: ${text}`);
+        adapter.log.debug(`[controlHelper2] message sent to speech.queue: ${text}`);
     } catch (err) {
-        adapter.log.warn(`[controlHelper2] Fehler beim Senden an speech.queue: ${err.message}`);
+        adapter.log.warn(`[controlHelper2] error sending to speech.queue: ${err.message}`);
     }
 }
 
@@ -188,7 +188,7 @@ function cleanup() {
         backwashReminderTimer = null;
     }
     lastReminderDay = null;
-    adapter.log.debug('[controlHelper2] Cleanup ausgeführt.');
+    adapter.log.debug('[controlHelper2] cleanup done.');
 }
 
 // NEU: Exporte

package/lib/helpers/debugLogHelper.js

@@ -42,10 +42,10 @@ const debugLogHelper = {
         if (target !== 'none') {
             this._subscribeTarget(target);
         } else {
-            adapter.log.debug('[debugLogHelper] Kein Bereich ausgewählt – Logger inaktiv.');
+            adapter.log.debug('[debugLogHelper] No area selected - logger inactive.');
         }
 
-        adapter.log.debug('[debugLogHelper] Initialisierung abgeschlossen');
+        adapter.log.debug('[debugLogHelper] Initialization completed');
     },
 
     /**
@@ -88,7 +88,7 @@ const debugLogHelper = {
         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`;
+            const msg = `[${new Date().toISOString()}] ${id} changed too fast (${now - last} ms, val=${state.val}, ack=${state.ack})\n`;
             await this._appendLog(msg);
         }
     },
@@ -104,21 +104,19 @@ const debugLogHelper = {
         }
         if (this.subscribedTarget && this.subscribedTarget !== 'none') {
             this.adapter.unsubscribeStates(`${this.subscribedTarget}.*`);
-            this.adapter.log.debug(`[debugLogHelper] Überwachung für Bereich "${this.subscribedTarget}" beendet.`);
+            this.adapter.log.debug(`[debugLogHelper] Monitoring stopped for area "${this.subscribedTarget}".`);
         }
 
         this.subscribedTarget = newTarget;
 
         if (newTarget === 'none') {
-            this.adapter.log.debug('[debugLogHelper] Kein Bereich aktiv.');
+            this.adapter.log.debug('[debugLogHelper] No area active.');
             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`,
-        );
+        this.adapter.log.debug(`[debugLogHelper] Monitoring started for area "${newTarget}".`);
+        await this._appendLog(`\n=== Debug log started: area "${newTarget}" @ ${new Date().toLocaleString()} ===\n`);
     },
 
     /**
@@ -147,7 +145,7 @@ const debugLogHelper = {
                 this.bufferTimer = setTimeout(() => this._flushBuffer(), 5000);
             }
         } catch (err) {
-            this.adapter.log.warn(`[debugLogHelper] Fehler beim Anhängen an Log: ${err.message}`);
+            this.adapter.log.warn(`[debugLogHelper] Error while appending to log: ${err.message}`);
         }
     },
 
@@ -165,7 +163,7 @@ const debugLogHelper = {
             this.buffer = '';
             this.bufferTimer = null;
         } catch (err) {
-            this.adapter.log.warn(`[debugLogHelper] Fehler beim Schreiben in Log: ${err.message}`);
+            this.adapter.log.warn(`[debugLogHelper] Error while writing to log: ${err.message}`);
         }
     },
 
@@ -176,9 +174,9 @@ const debugLogHelper = {
         try {
             await this.adapter.setStateAsync('SystemCheck.debug_logs.log', { val: '', ack: true });
             this.buffer = '';
-            this.adapter.log.info('[debugLogHelper] Debug-Log gelöscht');
+            this.adapter.log.info('[debugLogHelper] Debug log cleared');
         } catch (err) {
-            this.adapter.log.warn(`[debugLogHelper] Fehler beim Löschen des Logs: ${err.message}`);
+            this.adapter.log.warn(`[debugLogHelper] Error while clearing the log: ${err.message}`);
         }
     },
 
@@ -186,7 +184,7 @@ const debugLogHelper = {
         if (this.bufferTimer) {
             clearTimeout(this.bufferTimer);
         }
-        this.adapter.log.debug('[debugLogHelper] Cleanup ausgeführt');
+        this.adapter.log.debug('[debugLogHelper] Cleanup done');
     },
 };
 

package/lib/helpers/frostHelper.js

@@ -22,7 +22,7 @@ const frostHelper = {
         // Minütlicher Check
         this._scheduleCheck();
 
-        this.adapter.log.debug('[frostHelper] initialisiert (Prüfung alle 60s)');
+        this.adapter.log.debug('[frostHelper] initialized (check every 60s)');
     },
 
     _scheduleCheck() {
@@ -39,13 +39,13 @@ const frostHelper = {
             // --- 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.');
+                this.adapter.log.debug('[frostHelper] Priority by ControlHelper active - frost protection paused.');
                 return;
             }
 
             // --- NEU: Vorrangprüfung durch TimeHelper ---
             if (activeHelper === 'timeHelper') {
-                this.adapter.log.debug('[frostHelper] Vorrang durch TimeHelper aktiv – Frostschutz pausiert.');
+                this.adapter.log.debug('[frostHelper] Priority by TimeHelper active - frost protection paused.');
                 return;
             }
 
@@ -64,7 +64,7 @@ const frostHelper = {
             // Außentemperatur laden
             const outside = (await this.adapter.getStateAsync('temperature.outside.current'))?.val;
             if (outside == null) {
-                this.adapter.log.debug('[frostHelper] Keine Außentemperatur verfügbar');
+                this.adapter.log.debug('[frostHelper] No outside temperature available');
                 return;
             }
 
@@ -124,11 +124,11 @@ const frostHelper = {
                     ack: false,
                 });
                 this.adapter.log.info(
-                    `[frostHelper] Frostschutz → Pumpe ${shouldRun ? 'EIN' : 'AUS'} (Außen=${outside}°C, Grenze=${frostTemp}°C)`,
+                    `[frostHelper] Frost protection -> pump ${shouldRun ? 'ON' : 'OFF'} (outside=${outside}°C, limit=${frostTemp}°C)`,
                 );
             }
         } catch (err) {
-            this.adapter.log.warn(`[frostHelper] Fehler im Check: ${err.message}`);
+            this.adapter.log.warn(`[frostHelper] Error in check: ${err.message}`);
         }
     },