iobroker.poolcontrol 1.2.0 → 1.2.2

package/lib/helpers/heatHelper.js

@@ -54,11 +54,11 @@ const heatHelper = {
 
         // ggf. vorhandene Foreign-ID abonnieren
         this._refreshForeignSubscription().catch(err =>
-            this.adapter.log.warn(`[heatHelper] Foreign-Subscription Fehler: ${err.message}`),
+            this.adapter.log.warn(`[heatHelper] Foreign subscription error: ${err.message}`),
         );
 
         this._safeEvaluate('init');
-        this.adapter.log.info('[heatHelper] Initialisierung abgeschlossen.');
+        this.adapter.log.info('[heatHelper] Initialization completed.');
     },
 
     async handleStateChange(id, state) {
@@ -101,7 +101,7 @@ const heatHelper = {
                 return;
             }
         } catch (err) {
-            this.adapter.log.warn(`[heatHelper] Fehler in handleStateChange: ${err.message}`);
+            this.adapter.log.warn(`[heatHelper] Error in handleStateChange: ${err.message}`);
         }
     },
 
@@ -235,7 +235,7 @@ const heatHelper = {
         // - Pumpe aktuell AUS
         // - kein Prerun aktiv
         if (prerunMin > 0 && !pumpIsOn && !this._prerunTimer) {
-            this.adapter.log.info(`[heatHelper] Starte Pumpen-Prerun (${prerunMin} min)`);
+            this.adapter.log.info(`[heatHelper] Starting pump pre-run (${prerunMin} min)`);
 
             // Pumpe einschalten + Ownership übernehmen
             this._ownsPump = true;
@@ -317,7 +317,7 @@ const heatHelper = {
         // Pumpen-Nachlauf nur, wenn wir die Pumpe eingeschaltet hatten
         await this._startAfterrunIfNeeded(afterrunMin, reason);
 
-        this.adapter.log.info(`[heatHelper] Heizung AUS (${reason})`);
+        this.adapter.log.info(`[heatHelper] Heating OFF (${reason})`);
     },
 
     async _applyBlockedState(mode, reason, afterrunMin) {
@@ -382,7 +382,7 @@ const heatHelper = {
                 await this.adapter.setStateAsync('heat.afterrun_active', { val: false, ack: true });
             }
         } catch (err) {
-            this.adapter.log.warn(`[heatHelper] Konnte Pumpe nicht einschalten: ${err.message}`);
+            this.adapter.log.warn(`[heatHelper] Could not turn on pump: ${err.message}`);
         }
     },
 
@@ -408,12 +408,12 @@ const heatHelper = {
         await this.adapter.setStateAsync('heat.afterrun_active', { val: true, ack: true });
 
         const holdMs = Math.round(afterrunMin * 60 * 1000);
-        this.adapter.log.debug(`[heatHelper] Pumpen-Nachlauf gestartet: ${afterrunMin} min (${reason})`);
+        this.adapter.log.debug(`[heatHelper] Pump after-run started: ${afterrunMin} min (${reason})`);
 
         this._afterrunTimer = setTimeout(async () => {
             // Wenn inzwischen wieder Heizbedarf aktiv ist -> Nachlauf abbrechen
             if (this._desiredHeat === true) {
-                this.adapter.log.debug('[heatHelper] Nachlauf abgebrochen – Heizen wieder aktiv.');
+                this.adapter.log.debug('[heatHelper] After-run cancelled - heating is active again.');
                 return;
             }
             await this._stopPumpNow('afterrun_done');
@@ -424,12 +424,12 @@ const heatHelper = {
         try {
             await this.adapter.setStateAsync('pump.pump_switch', { val: false, ack: false });
         } catch (err) {
-            this.adapter.log.warn(`[heatHelper] Konnte Pumpe nicht ausschalten: ${err.message}`);
+            this.adapter.log.warn(`[heatHelper] Could not turn off pump: ${err.message}`);
         } finally {
             this._ownsPump = false;
             await this.adapter.setStateAsync('heat.afterrun_active', { val: false, ack: true });
             await this.adapter.setStateAsync('heat.prerun_active', { val: false, ack: true });
-            this.adapter.log.info(`[heatHelper] Pumpe AUS (${tag})`);
+            this.adapter.log.info(`[heatHelper] Pump OFF (${tag})`);
         }
     },
 
@@ -446,7 +446,7 @@ const heatHelper = {
         try {
             await this.adapter.setForeignStateAsync(id, { val: !!on, ack: false });
         } catch (err) {
-            this.adapter.log.warn(`[heatHelper] Konnte Heizung nicht setzen (${id}): ${err.message}`);
+            this.adapter.log.warn(`[heatHelper] Could not set heating device (${id}): ${err.message}`);
         }
     },
 
@@ -460,7 +460,7 @@ const heatHelper = {
             await this.adapter.setStateAsync('heat.heating_request', { val: !!heatingRequest, ack: true });
             await this.adapter.setStateAsync('heat.last_change', { val: Date.now(), ack: true });
         } catch (err) {
-            this.adapter.log.warn(`[heatHelper] Fehler beim Schreiben der Heat-States: ${err.message}`);
+            this.adapter.log.warn(`[heatHelper] Error while writing heat states: ${err.message}`);
         }
     },
 
@@ -477,7 +477,7 @@ const heatHelper = {
                 this.adapter.subscribeForeignStates(nextId);
                 this.adapter.log.info(`[heatHelper] Subscribed Foreign-Heat-Control: "${nextId}"`);
             } catch (err) {
-                this.adapter.log.warn(`[heatHelper] Konnte Foreign-State nicht abonnieren (${nextId}): ${err.message}`);
+                this.adapter.log.warn(`[heatHelper] Could not subscribe to foreign state (${nextId}): ${err.message}`);
             }
             this._heatControlForeignId = nextId;
         }
@@ -491,7 +491,7 @@ const heatHelper = {
         try {
             await this._evaluate(tag);
         } catch (err) {
-            this.adapter.log.warn(`[heatHelper] Evaluate-Fehler (${tag}): ${err.message}`);
+            this.adapter.log.warn(`[heatHelper] Evaluate error (${tag}): ${err.message}`);
         }
     },
 

package/lib/helpers/infoHelper.js

@@ -20,7 +20,7 @@ const infoHelper = {
      */
     init(adapter) {
         this.adapter = adapter;
-        this.adapter.log.debug('[infoHelper] Initialisiert');
+        this.adapter.log.debug('[infoHelper] Initialized');
 
         // Adapterversion setzen
         this._updateAdapterVersion();
@@ -42,7 +42,7 @@ const infoHelper = {
 
             this.adapter.setState('info.adapter_version', version, true);
         } catch (err) {
-            this.adapter.log.error(`[infoHelper] Fehler beim Lesen der Adapterversion: ${err}`);
+            this.adapter.log.error(`[infoHelper] Error while reading adapter version: ${err}`);
         }
     },
 

package/lib/helpers/migrationHelper.js

@@ -23,7 +23,7 @@ const migrationHelper = {
      */
     async init(adapter) {
         this.adapter = adapter;
-        this.adapter.log.info('[migrationHelper] Starte Migration-Check ...');
+        this.adapter.log.info('[migrationHelper] Starting migration check ...');
 
         try {
             // ------------------------------------------------------
@@ -34,12 +34,12 @@ const migrationHelper = {
             await this._fixPumpModeStates(); // NEU: PV-Automatik hinzufügen
             await this._removeInvalidResetButtons(); // NEU: Entfernt Week/Month-Reset-Buttons
 
-            this.adapter.log.debug('[migrationHelper] Migration-Checks abgeschlossen.');
+            this.adapter.log.debug('[migrationHelper] Migration checks completed.');
         } catch (err) {
-            this.adapter.log.warn(`[migrationHelper] Fehler beim Migration-Check: ${err.message}`);
+            this.adapter.log.warn(`[migrationHelper] Error during migration check: ${err.message}`);
         }
 
-        this.adapter.log.info('[migrationHelper] Migration-Helper beendet.');
+        this.adapter.log.info('[migrationHelper] Migration helper finished.');
     },
 
     // ------------------------------------------------------
@@ -55,7 +55,7 @@ const migrationHelper = {
 
             const isReadOnly = obj.common?.write === false;
             if (isReadOnly) {
-                this.adapter.log.info(`[migrationHelper] Aktualisiere Schreibrecht für ${id} → write:true`);
+                this.adapter.log.info(`[migrationHelper] Updating write permission for ${id} → write:true`);
                 await this.adapter.extendObjectAsync(id, {
                     common: {
                         write: true,
@@ -64,7 +64,7 @@ const migrationHelper = {
                 });
             }
         } catch (err) {
-            this.adapter.log.warn(`[migrationHelper] Fehler bei Prüfung von ${id}: ${err.message}`);
+            this.adapter.log.warn(`[migrationHelper] Error while checking ${id}: ${err.message}`);
         }
     },
 
@@ -81,7 +81,7 @@ const migrationHelper = {
 
             const hasPersist = obj.common?.persist === true;
             if (!hasPersist) {
-                this.adapter.log.info(`[migrationHelper] Ergänze persist:true für ${id}`);
+                this.adapter.log.info(`[migrationHelper] Adding persist:true for ${id}`);
                 await this.adapter.extendObjectAsync(id, {
                     common: {
                         persist: true,
@@ -90,7 +90,7 @@ const migrationHelper = {
                 });
             }
         } catch (err) {
-            this.adapter.log.warn(`[migrationHelper] Fehler bei Prüfung von ${id}: ${err.message}`);
+            this.adapter.log.warn(`[migrationHelper] Error while checking ${id}: ${err.message}`);
         }
     },
 
@@ -108,11 +108,11 @@ const migrationHelper = {
             const states = obj.common?.states || {};
             if (!states.auto_pv) {
                 states.auto_pv = 'Automatik (PV)';
-                this.adapter.log.info(`[migrationHelper] Ergänze neuen Modus "Automatik (PV)" in pump.mode`);
+                this.adapter.log.info('[migrationHelper] Adding new mode "Automatic (PV)" to pump.mode');
                 await this.adapter.extendObjectAsync(id, { common: { states } });
             }
         } catch (err) {
-            this.adapter.log.warn(`[migrationHelper] Fehler bei Prüfung von ${id}: ${err.message}`);
+            this.adapter.log.warn(`[migrationHelper] Error while checking ${id}: ${err.message}`);
         }
     },
 
@@ -133,27 +133,27 @@ const migrationHelper = {
                         // Erst Statewert entfernen
                         await this.adapter.delStateAsync(id);
                     } catch {
-                        this.adapter.log.debug(`[migrationHelper] Kein Statewert für ${id} vorhanden (Überspringe).`);
+                        this.adapter.log.debug(`[migrationHelper] No state value found for ${id} (skipping).`);
                     }
 
                     // Danach Objekt löschen (auch wenn persist=true)
                     try {
                         await this.adapter.delObjectAsync(id, { recursive: false });
-                        this.adapter.log.info(`[migrationHelper] Veralteter Reset-Button entfernt: ${id}`);
+                        this.adapter.log.info(`[migrationHelper] Removed obsolete reset button: ${id}`);
                         removed++;
                     } catch (err) {
-                        this.adapter.log.warn(`[migrationHelper] Konnte ${id} nicht löschen: ${err.message}`);
+                        this.adapter.log.warn(`[migrationHelper] Could not delete ${id}: ${err.message}`);
                     }
                 }
             }
 
             if (removed === 0) {
-                this.adapter.log.debug('[migrationHelper] Keine alten Reset-Buttons gefunden.');
+                this.adapter.log.debug('[migrationHelper] No old reset buttons found.');
             } else {
-                this.adapter.log.info(`[migrationHelper] Insgesamt ${removed} alte Reset-Buttons entfernt.`);
+                this.adapter.log.info(`[migrationHelper] Removed ${removed} old reset buttons in total.`);
             }
         } catch (err) {
-            this.adapter.log.warn(`[migrationHelper] Fehler beim Entfernen alter Reset-Buttons: ${err.message}`);
+            this.adapter.log.warn(`[migrationHelper] Error while removing old reset buttons: ${err.message}`);
         }
     },
 };

package/lib/helpers/photovoltaicHelper.js

@@ -28,15 +28,15 @@ const photovoltaicHelper = {
 
         if (!this.genId || !this.houseId) {
             this.adapter.log.info(
-                '[photovoltaicHelper] PV-IDs in der Instanz-Konfiguration fehlen. Überschusserkennung bleibt passiv.',
+                '[photovoltaicHelper] PV IDs are missing in the instance configuration. Surplus detection remains inactive.',
             );
         } else {
             try {
                 this.adapter.subscribeForeignStates(this.genId);
                 this.adapter.subscribeForeignStates(this.houseId);
-                this.adapter.log.info(`[photovoltaicHelper] Subscribed: PV="${this.genId}", Haus="${this.houseId}"`);
+                this.adapter.log.info(`[photovoltaicHelper] Subscribed: PV="${this.genId}", house="${this.houseId}"`);
             } catch (err) {
-                this.adapter.log.warn(`[photovoltaicHelper] Konnte Foreign-States nicht abonnieren: ${err.message}`);
+                this.adapter.log.warn(`[photovoltaicHelper] Could not subscribe to foreign states: ${err.message}`);
             }
         }
 
@@ -46,7 +46,7 @@ const photovoltaicHelper = {
         this.adapter.subscribeStates('pump.mode');
 
         this._safeRecalc('init');
-        this.adapter.log.info('[photovoltaicHelper] Initialisierung abgeschlossen.');
+        this.adapter.log.info('[photovoltaicHelper] Initialization completed.');
     },
 
     async handleStateChange(id, state) {
@@ -66,12 +66,12 @@ const photovoltaicHelper = {
             }
 
             if (id.endsWith('photovoltaic.afterrun_min')) {
-                this.adapter.log.debug(`[photovoltaicHelper] Nachlaufzeit geändert auf ${Number(state.val) || 0} min`);
+                this.adapter.log.debug(`[photovoltaicHelper] Afterrun time changed to ${Number(state.val) || 0} min`);
                 return;
             }
             if (id.endsWith('photovoltaic.ignore_on_circulation')) {
                 this.adapter.log.debug(
-                    `[photovoltaicHelper] Flag "PV ignorieren bei Umwälzung erreicht" = ${!!state.val}`,
+                    `[photovoltaicHelper] Flag "Ignore PV when circulation target reached" = ${!!state.val}`,
                 );
                 return;
             }
@@ -81,7 +81,7 @@ const photovoltaicHelper = {
                 return;
             }
         } catch (err) {
-            this.adapter.log.warn(`[photovoltaicHelper] Fehler in handleStateChange: ${err.message}`);
+            this.adapter.log.warn(`[photovoltaicHelper] Error in handleStateChange: ${err.message}`);
         }
     },
 
@@ -117,12 +117,14 @@ const photovoltaicHelper = {
             const collectorWarning = !!(await this.adapter.getStateAsync('solar.collector_warning'))?.val;
             if (collectorWarning) {
                 this.adapter.log.warn(
-                    '[photovoltaicHelper] Kollektorüberhitzung erkannt → Pumpe ZWANGSEIN (Sicherheits-Override aktiv)',
+                    '[photovoltaicHelper] Collector overheating detected → pump FORCED ON (safety override active)',
                 );
                 return this._maybeStartPump('solar_overheat_protection');
             }
         } catch (err) {
-            this.adapter.log.warn(`[photovoltaicHelper] Fehler beim Prüfen der Solarüberhitzung: ${err.message}`);
+            this.adapter.log.warn(
+                `[photovoltaicHelper] Error while checking solar overheating protection: ${err.message}`,
+            );
         }
 
         // Überschussberechnung
@@ -142,12 +144,12 @@ const photovoltaicHelper = {
 
         // Saison/Modus prüfen
         if (!seasonActive) {
-            this.adapter.log.debug('[photovoltaicHelper] Saison inaktiv → keine PV-Schaltlogik.');
+            this.adapter.log.debug('[photovoltaicHelper] Season inactive → PV switching logic disabled.');
             return this._maybeStopPump(false, 0, 'season_inactive');
         }
         if (pumpMode !== 'auto_pv') {
             this.adapter.log.debug(
-                `[photovoltaicHelper] Pumpenmodus ist '${pumpMode}' ≠ 'auto_pv' → keine PV-Schaltlogik.`,
+                `[photovoltaicHelper] Pump mode is '${pumpMode}' ≠ 'auto_pv' → PV switching logic disabled.`,
             );
             return this._maybeStopPump(false, 0, 'mode_not_auto_pv');
         }
@@ -164,7 +166,7 @@ const photovoltaicHelper = {
                     // RULE: Wenn Umwälzung bereits erfüllt → Pumpe sofort AUS (ohne Nachlauf)
                     if (remaining <= 0) {
                         this.adapter.log.info(
-                            `[photovoltaicHelper] Tagesumwälzung erreicht (daily_remaining=${remaining}) → PV-Steuerung beendet, Pumpe AUS.`,
+                            `[photovoltaicHelper] Daily circulation target reached (daily_remaining=${remaining}) → PV control stopped, pump OFF.`,
                         );
                         return this._maybeStopPump(true, 0, 'circulation_reached_force_off');
                     }
@@ -172,14 +174,12 @@ const photovoltaicHelper = {
                     // RULE: Wenn Umwälzung noch nicht erfüllt → nur dann darf bei Überschuss eingeschaltet werden
                     if (remaining > 0 && surplusActive) {
                         this.adapter.log.debug(
-                            `[photovoltaicHelper] Tagesumwälzung noch nicht erfüllt (${remaining}) → PV-Steuerung aktiv.`,
+                            `[photovoltaicHelper] Daily circulation target not yet reached (${remaining}) → PV control active.`,
                         );
                     }
                 }
             } catch (err) {
-                this.adapter.log.debug(
-                    `[photovoltaicHelper] daily_remaining konnte nicht gelesen werden: ${err.message}`,
-                );
+                this.adapter.log.debug(`[photovoltaicHelper] Could not read daily_remaining: ${err.message}`);
             }
         }
 
@@ -194,7 +194,7 @@ const photovoltaicHelper = {
                 // RULE: Einschalten nur, wenn Umwälzung noch nicht erfüllt
                 if (Number.isFinite(remaining) && remaining <= 0) {
                     this.adapter.log.info(
-                        `[photovoltaicHelper] Tagesumwälzung bereits erfüllt (${remaining}) → Pumpe bleibt AUS (kein Start trotz Überschuss).`,
+                        `[photovoltaicHelper] Daily circulation target already reached (${remaining}) → pump stays OFF (no start despite surplus).`,
                     );
                     return this._maybeStopPump(true, 0, 'circulation_already_reached');
                 }
@@ -202,7 +202,7 @@ const photovoltaicHelper = {
                 // RULE: Überschuss aktiv UND Umwälzung noch nicht erfüllt → einschalten
                 return this._maybeStartPump('pv_surplus');
             } catch (err) {
-                this.adapter.log.warn(`[photovoltaicHelper] Fehler beim Prüfen von daily_remaining: ${err.message}`);
+                this.adapter.log.warn(`[photovoltaicHelper] Error while checking daily_remaining: ${err.message}`);
                 return this._maybeStartPump('pv_surplus');
             }
         }
@@ -221,7 +221,7 @@ const photovoltaicHelper = {
             this.afterrunTimer = null;
         }
         this._pvPumpHoldUntil = 0;
-        this.adapter.log.info(`[photovoltaicHelper] Pumpe EIN (Grund: ${reason})`);
+        this.adapter.log.info(`[photovoltaicHelper] Pump ON (reason: ${reason})`);
         await this._setPumpSwitch(true);
     },
 
@@ -231,7 +231,7 @@ const photovoltaicHelper = {
                 return;
             }
             this._desiredPump = false;
-            this.adapter.log.info(`[photovoltaicHelper] Pumpe AUS (${tag}, ohne Nachlauf)`);
+            this.adapter.log.info(`[photovoltaicHelper] Pump OFF (${tag}, no afterrun)`);
             await this._setPumpSwitch(false);
             return;
         }
@@ -244,21 +244,21 @@ const photovoltaicHelper = {
         this.afterrunTimer = setTimeout(async () => {
             const active = !!(await this.adapter.getStateAsync('photovoltaic.surplus_active'))?.val;
             if (active) {
-                this.adapter.log.debug('[photovoltaicHelper] Nachlauf abgebrochen – Überschuss wieder aktiv.');
+                this.adapter.log.debug('[photovoltaicHelper] Afterrun canceled – surplus active again.');
                 return;
             }
             this._desiredPump = false;
-            this.adapter.log.info('[photovoltaicHelper] Pumpe AUS (Nachlauf beendet)');
+            this.adapter.log.info('[photovoltaicHelper] Pump OFF (afterrun finished)');
             await this._setPumpSwitch(false);
         }, holdMs);
-        this.adapter.log.debug(`[photovoltaicHelper] Nachlauf gestartet: ${afterrunMin} min (${tag})`);
+        this.adapter.log.debug(`[photovoltaicHelper] Afterrun started: ${afterrunMin} min (${tag})`);
     },
 
     async _setPumpSwitch(on) {
         try {
             await this.adapter.setStateAsync('pump.pump_switch', { val: !!on, ack: false });
         } catch (err) {
-            this.adapter.log.warn(`[photovoltaicHelper] Konnte pump.pump_switch nicht setzen: ${err.message}`);
+            this.adapter.log.warn(`[photovoltaicHelper] Could not set pump.pump_switch: ${err.message}`);
         }
     },
 
@@ -266,21 +266,21 @@ const photovoltaicHelper = {
         try {
             await this.adapter.setStateAsync(id, { val: Number(val) || 0, ack: true });
         } catch (e) {
-            this.adapter.log.warn(`[photovoltaicHelper] setNumber ${id} fehlgeschlagen: ${e.message}`);
+            this.adapter.log.warn(`[photovoltaicHelper] setNumber ${id} failed: ${e.message}`);
         }
     },
     async _updateBoolState(id, val) {
         try {
             await this.adapter.setStateAsync(id, { val: !!val, ack: true });
         } catch (e) {
-            this.adapter.log.warn(`[photovoltaicHelper] setBool ${id} fehlgeschlagen: ${e.message}`);
+            this.adapter.log.warn(`[photovoltaicHelper] setBool ${id} failed: ${e.message}`);
         }
     },
     async _updateStringState(id, val) {
         try {
             await this.adapter.setStateAsync(id, { val: String(val ?? ''), ack: true });
         } catch (e) {
-            this.adapter.log.warn(`[photovoltaicHelper] setString ${id} fehlgeschlagen: ${e.message}`);
+            this.adapter.log.warn(`[photovoltaicHelper] setString ${id} failed: ${e.message}`);
         }
     },
 
@@ -288,7 +288,7 @@ const photovoltaicHelper = {
         try {
             await this._recalc(tag);
         } catch (err) {
-            this.adapter.log.warn(`[photovoltaicHelper] Recalc-Fehler (${tag}): ${err.message}`);
+            this.adapter.log.warn(`[photovoltaicHelper] Recalc error (${tag}): ${err.message}`);
         }
     },
 

package/lib/helpers/pumpHelper.js

@@ -39,20 +39,20 @@ const pumpHelper = {
                     const val = this._parseNumber(s?.val);
                     this.adapter.setStateAsync('pump.current_power', { val, ack: true });
                     this.adapter.log.debug(
-                        `[pumpHelper] Überwache Leistung von ${this.currentPowerId} (Startwert: ${val})`,
+                        `[pumpHelper] Monitoring power from ${this.currentPowerId} (initial value: ${val})`,
                     );
                 })
                 .catch(() => {
-                    this.adapter.log.debug(`[pumpHelper] Überwache Leistung von ${this.currentPowerId}`);
+                    this.adapter.log.debug(`[pumpHelper] Monitoring power from ${this.currentPowerId}`);
                 });
         } else {
-            this.adapter.log.debug('[pumpHelper] Keine Objekt-ID für aktuelle Leistung konfiguriert');
+            this.adapter.log.debug('[pumpHelper] No object ID configured for current power');
         }
 
         // Echte Steckdose beobachten (Status-Spiegelung)
         if (this.deviceId) {
             this.adapter.subscribeForeignStates(this.deviceId);
-            this.adapter.log.debug(`[pumpHelper] Überwache Steckdose: ${this.deviceId}`);
+            this.adapter.log.debug(`[pumpHelper] Monitoring socket: ${this.deviceId}`);
 
             // NEU: Initialwert übernehmen
             this.adapter
@@ -61,20 +61,18 @@ const pumpHelper = {
                     if (s) {
                         const val = !!s.val;
                         this.adapter.setStateAsync('pump.pump_switch', { val, ack: true });
-                        this.adapter.log.debug(`[pumpHelper] Initialer Pumpenstatus von Steckdose übernommen: ${val}`);
+                        this.adapter.log.debug(`[pumpHelper] Initial pump state adopted from socket: ${val}`);
                     }
                 })
-                .catch(err =>
-                    this.adapter.log.warn(`[pumpHelper] Konnte initialen Pumpenstatus nicht laden: ${err.message}`),
-                );
+                .catch(err => this.adapter.log.warn(`[pumpHelper] Could not load initial pump state: ${err.message}`));
         } else {
-            this.adapter.log.debug('[pumpHelper] Keine Objekt-ID für Pumpen-Steckdose konfiguriert');
+            this.adapter.log.debug('[pumpHelper] No object ID configured for pump socket');
         }
 
-        this.adapter.log.debug('[pumpHelper] initialisiert');
+        this.adapter.log.debug('[pumpHelper] initialized');
         // Initialer Status
         this._updateStatus().catch(err =>
-            this.adapter.log.warn(`[pumpHelper] Initiales Status-Update fehlgeschlagen: ${err.message}`),
+            this.adapter.log.warn(`[pumpHelper] Initial status update failed: ${err.message}`),
         );
     },
 
@@ -98,7 +96,7 @@ const pumpHelper = {
         const season = (await this.adapter.getStateAsync('status.season_active'))?.val;
         if (!season) {
             this.adapter.log.debug(
-                '[pumpHelper] Saison inaktiv – Pumpenlogik übersprungen (Frostschutz läuft separat)',
+                '[pumpHelper] Season inactive – skipping pump logic (frost protection runs separately)',
             );
             return;
         }
@@ -121,7 +119,7 @@ const pumpHelper = {
 
             // NEU: Filter gegen zyklische Fremdmeldungen ohne echten Zustandswechsel
             if (current === val) {
-                this.adapter.log.debug('[pumpHelper] Fremd-State meldet identischen Wert – ignoriert.');
+                this.adapter.log.debug('[pumpHelper] Foreign state reported identical value – ignored.');
                 return;
             }
 
@@ -230,7 +228,7 @@ const pumpHelper = {
                 ack: true,
             });
         } catch (err) {
-            this.adapter.log.warn(`[pumpHelper] Fehler beim Setzen von pump.status: ${err.message}`);
+            this.adapter.log.warn(`[pumpHelper] Error while setting pump.status: ${err.message}`);
         }
     },
 
@@ -258,12 +256,12 @@ const pumpHelper = {
             const now = Date.now();
 
             if (active === true && this._lastPumpStart && now - this._lastPumpStart < graceOnMs) {
-                this.adapter.log.debug('[pumpHelper] Innerhalb der Start-Kulanzzeit – Fehlerprüfung übersprungen');
+                this.adapter.log.debug('[pumpHelper] Within start grace period – skipping error check');
                 return;
             }
 
             if (active === false && this._lastPumpStop && now - this._lastPumpStop < graceOffMs) {
-                this.adapter.log.debug('[pumpHelper] Innerhalb der Stopp-Kulanzzeit – Fehlerprüfung übersprungen');
+                this.adapter.log.debug('[pumpHelper] Within stop grace period – skipping error check');
                 return;
             }
             // --- Ende Kulanzzeiten ---
@@ -318,11 +316,11 @@ const pumpHelper = {
                 if (error && errorMsg) {
                     this.adapter.log.warn(`[pumpHelper] ${errorMsg}`);
                 } else if (!error && errorOld) {
-                    this.adapter.log.info('[pumpHelper] Pumpenfehler behoben');
+                    this.adapter.log.info('[pumpHelper] Pump error resolved');
                 }
             }
         } catch (err) {
-            this.adapter.log.warn(`[pumpHelper] Fehler bei Error-Check: ${err.message}`);
+            this.adapter.log.warn(`[pumpHelper] Error during error check: ${err.message}`);
         }
     },
 

package/lib/helpers/pumpHelper2.js

@@ -34,7 +34,7 @@ const pumpHelper2 = {
      */
     async init(adapter) {
         this.adapter = adapter;
-        this.adapter.log.info('[pumpHelper2] Initialisierung gestartet');
+        this.adapter.log.info('[pumpHelper2] Initialization started');
 
         // Relevante States überwachen
         this.adapter.subscribeStates('pump.current_power');
@@ -43,7 +43,7 @@ const pumpHelper2 = {
         // Initialwerte berechnen
         await this._updateLiveValues();
 
-        this.adapter.log.info('[pumpHelper2] Erfolgreich initialisiert');
+        this.adapter.log.info('[pumpHelper2] Successfully initialized');
     },
 
     /**
@@ -70,11 +70,9 @@ const pumpHelper2 = {
                 const flowBeforeStop = this.lastKnownFlow;
                 if (flowBeforeStop > 0) {
                     await this._setIfChanged('pump.live.last_flow_lh', flowBeforeStop);
-                    this.adapter.log.debug(
-                        `[pumpHelper2] FIX: Letzter Durchflusswert gesichert: ${flowBeforeStop} l/h`,
-                    );
+                    this.adapter.log.debug(`[pumpHelper2] FIX: Last flow value stored: ${flowBeforeStop} l/h`);
                 } else {
-                    this.adapter.log.debug('[pumpHelper2] Kein gespeicherter Durchflusswert vorhanden.');
+                    this.adapter.log.debug('[pumpHelper2] No stored flow value available.');
                 }
             }
         }
@@ -94,7 +92,7 @@ const pumpHelper2 = {
 
             // Schutz gegen ungültige Werte
             if (maxPower <= 0 || nominalFlow <= 0) {
-                this.adapter.log.debug('[pumpHelper2] Ungültige Basiswerte, Berechnung übersprungen');
+                this.adapter.log.debug('[pumpHelper2] Invalid base values, calculation skipped');
                 return;
             }
 
@@ -115,10 +113,10 @@ const pumpHelper2 = {
             await this._setIfChanged('pump.live.flow_percent', flowPercent);
 
             this.adapter.log.debug(
-                `[pumpHelper2] Reeller Durchfluss aktualisiert: ${flowCurrentLh} l/h (${flowPercent.toFixed(1)}%)`,
+                `[pumpHelper2] Actual flow updated: ${flowCurrentLh} l/h (${flowPercent.toFixed(1)}%)`,
             );
         } catch (err) {
-            this.adapter.log.warn(`[pumpHelper2] Fehler bei _updateLiveValues: ${err.message}`);
+            this.adapter.log.warn(`[pumpHelper2] Error in _updateLiveValues: ${err.message}`);
         }
     },
 
@@ -155,7 +153,7 @@ const pumpHelper2 = {
     cleanup() {
         // Derzeit keine Timer oder Intervalle vorhanden
         // Platzhalter für zukünftige Erweiterungen
-        this.adapter?.log.debug('[pumpHelper2] Cleanup ausgeführt.');
+        this.adapter?.log.debug('[pumpHelper2] Cleanup executed.');
     },
 };