iobroker.smartloadmanager 0.0.6 → 0.0.8

package/main.js

@@ -8,6 +8,9 @@ class ZeroFeedIn extends utils.Adapter {
             ...options,
             name: 'smartloadmanager',
         });
+        // Timeout-Limits definieren
+        this.MAX_TIMEOUT = 86400000; // 24h in ms
+        this.DEFAULT_TIMEOUT = 60000; // 60 Sekunden Fallback
         this.consumerList = [];
         this.feedInDatapoint = null;
         this.batteryControlModeDatapoint = null;
@@ -19,15 +22,40 @@ class ZeroFeedIn extends utils.Adapter {
         this.on('stateChange', this.onStateChange.bind(this));
         this.on('unload', this.onUnload.bind(this));
     }
+    name2id(pName) {
+        return (pName || '')
+            .replace(this.FORBIDDEN_CHARS, '_') // ioBroker verbotene Zeichen
+            .replace(/\s+/g, '_') // Leerzeichen → _
+            .replace(/\./g, '_') // Punkte → _
+            .replace(/[^a-zA-Z0-9\-_]/g, '_') // nur erlaubte Zeichen
+            .replace(/_+/g, '_') // mehrere Unterstriche zusammenfassen
+            .replace(/^_+|_+$/g, ''); // führende/trailing _ weg
+    }
+    // Wrapper für sichere Timer
+    safeSetTimeout(fn, ms, ...args) {
+        const safeMs = Math.min(Math.max(ms, 0), this.MAX_TIMEOUT);
+        if (ms > this.MAX_TIMEOUT) {
+            this.log.warn(`Timeout of ${ms} ms has been limited to ${this.MAX_TIMEOUT} ms!`);
+        }
+        return this.setTimeout(fn, safeMs, ...args);
+    }
+
+    safeSetInterval(fn, ms, ...args) {
+        const safeMs = Math.min(Math.max(ms, 0), this.MAX_TIMEOUT);
+        if (ms > this.MAX_TIMEOUT) {
+            this.log.warn(`Interval of ${ms} ms has been limited to ${this.MAX_TIMEOUT} ms!`);
+        }
+        return this.setInterval(fn, safeMs, ...args);
+    }
 
     async onReady() {
         try {
-            this.log.info(`=== Adapter started - PID: ${process.pid} ===`);
+            this.log.info(`Adapter started, PID: ${process.pid}`);
 
             if (!this.config.FeedInDataPoint) {
                 this.log.error('No FeedInDataPoint configured!');
-                // zusätzlich als alert melden
-                await this.sendNotification('smartloadmanager', 'alarm', '❗ Kein FeedInDataPoint konfiguriert!');
+                // additionally send alert
+                await this.sendNotification('smartloadmanager', 'alarm', 'No FeedInDataPoint configured!');
                 return;
             }
             this.feedInDatapoint = this.config.FeedInDataPoint;
@@ -58,20 +86,10 @@ class ZeroFeedIn extends utils.Adapter {
             }
 
             await this.checkConsumers();
-
-            /*  // Info beim erfolgreichen Start
-            if (!this.adapterStartedNotified) {
-                await this.sendNotification(
-                    'smartloadmanager',
-                    'info',
-                    'ℹ️ SmartLoadManager Adapter erfolgreich gestartet.',
-                );
-                this.adapterStartedNotified = true;
-            } */
         } catch (error) {
             this.log.error(`Error in onReady: ${error.message}`);
-            // Fehler zusätzlich als alert melden
-            await this.sendNotification('smartloadmanager', 'alert', `❌ Fehler in onReady: ${error.message}`);
+            // additionally send alert
+            await this.sendNotification('smartloadmanager', 'alert', `Error in onReady: ${error.message}`);
         }
     }
 
@@ -93,20 +111,30 @@ class ZeroFeedIn extends utils.Adapter {
     }
 
     async createConsumerStates() {
+        // Übergeordnetes Device erstellen - löst "intermediate objects missing" Problem
+        await this.setObjectNotExistsAsync('consumer', {
+            type: 'device',
+            common: {
+                name: 'Consumer Management',
+            },
+            native: {},
+        });
+
         for (let i = 0; i < this.consumerList.length; i++) {
             const v = this.consumerList[i];
-            const channelId = `consumer.${i}_${v.name.replace(/\s+/g, '_')}`;
+            const safeName = this.name2id(v.name);
+            const channelId = `consumer.${i}_${safeName}`;
 
             await this.setObjectNotExistsAsync(channelId, {
                 type: 'channel',
-                common: { name: v.name },
+                common: { name: v.name }, // Channel selbst darf Klartext-Nutzername behalten
                 native: {},
             });
 
             await this.setObjectNotExistsAsync(`${channelId}.controlMode`, {
                 type: 'state',
                 common: {
-                    name: `${v.name} Control Mode`,
+                    name: 'controlMode',
                     type: 'number',
                     role: 'level.mode',
                     read: true,
@@ -117,12 +145,13 @@ class ZeroFeedIn extends utils.Adapter {
                 native: {},
             });
 
+            // KORRIGIERT: switchOnTime und switchOffTime als text statt value.time
             await this.setObjectNotExistsAsync(`${channelId}.switchOnTime`, {
                 type: 'state',
                 common: {
-                    name: `${v.name} Switch On Time (HH:MM)`,
+                    name: 'switchOnTime',
                     type: 'string',
-                    role: 'value.time',
+                    role: 'text', // GEÄNDERT von 'value.time' zu 'text'
                     read: true,
                     write: true,
                     def: '',
@@ -133,9 +162,9 @@ class ZeroFeedIn extends utils.Adapter {
             await this.setObjectNotExistsAsync(`${channelId}.switchOffTime`, {
                 type: 'state',
                 common: {
-                    name: `${v.name} Switch Off Time (HH:MM)`,
+                    name: 'switchOffTime',
                     type: 'string',
-                    role: 'value.time',
+                    role: 'text', // GEÄNDERT von 'value.time' zu 'text'
                     read: true,
                     write: true,
                     def: '',
@@ -146,7 +175,7 @@ class ZeroFeedIn extends utils.Adapter {
             await this.setObjectNotExistsAsync(`${channelId}.alwaysOffAtTime`, {
                 type: 'state',
                 common: {
-                    name: `${v.name} Ausschalten nur zur Ausschaltzeit`,
+                    name: 'alwaysOffAtTime',
                     type: 'boolean',
                     role: 'switch',
                     read: true,
@@ -159,9 +188,9 @@ class ZeroFeedIn extends utils.Adapter {
             await this.setObjectNotExistsAsync(`${channelId}.performance`, {
                 type: 'state',
                 common: {
-                    name: `${v.name} Gesamtleistung (Watt)`,
+                    name: 'performance',
                     type: 'number',
-                    role: 'value.power.consumption',
+                    role: 'value.power', // GEÄNDERT von 'value.power.consumption' zu 'value.power'
                     read: true,
                     write: false,
                     def: v.performance || 0,
@@ -173,7 +202,7 @@ class ZeroFeedIn extends utils.Adapter {
             await this.setObjectNotExistsAsync(`${channelId}.switchOnPoint`, {
                 type: 'state',
                 common: {
-                    name: `${v.name} Einschaltpunkt (Watt)`,
+                    name: 'switchOnPoint',
                     type: 'number',
                     role: 'value.power',
                     read: true,
@@ -187,7 +216,7 @@ class ZeroFeedIn extends utils.Adapter {
             await this.setObjectNotExistsAsync(`${channelId}.switchOffPoint`, {
                 type: 'state',
                 common: {
-                    name: `${v.name} Abschaltpunkt (Watt)`,
+                    name: 'switchOffPoint',
                     type: 'number',
                     role: 'value.power',
                     read: true,
@@ -202,9 +231,9 @@ class ZeroFeedIn extends utils.Adapter {
                 await this.setObjectNotExistsAsync(`${channelId}.batterySetpoint`, {
                     type: 'state',
                     common: {
-                        name: `${v.name} Batterie Ladeleistungs-Datenpunkt`,
+                        name: 'batterySetpoint',
                         type: 'string',
-                        role: 'value',
+                        role: 'text', // GEÄNDERT von 'value' zu 'text' (spezifischer)
                         read: true,
                         write: true,
                         def: v.batterySetpoint || '',
@@ -213,12 +242,13 @@ class ZeroFeedIn extends utils.Adapter {
                 });
             }
 
+            // KORRIGIERT: value.duration ist korrekt für Timer
             await this.setObjectNotExistsAsync(`${channelId}.onTimerRemaining`, {
                 type: 'state',
                 common: {
-                    name: `${v.name} Einschalt-Timer Restzeit (s)`,
+                    name: 'onTimerRemaining',
                     type: 'number',
-                    role: 'value.duration',
+                    role: 'value.interval', // GEÄNDERT von 'value.duration' zu 'value.interval'
                     read: true,
                     write: false,
                     def: 0,
@@ -230,9 +260,9 @@ class ZeroFeedIn extends utils.Adapter {
             await this.setObjectNotExistsAsync(`${channelId}.offTimerRemaining`, {
                 type: 'state',
                 common: {
-                    name: `${v.name} Ausschalt-Timer Restzeit (s)`,
+                    name: 'offTimerRemaining',
                     type: 'number',
-                    role: 'value.duration',
+                    role: 'value.interval', // GEÄNDERT von 'value.duration' zu 'value.interval'
                     read: true,
                     write: false,
                     def: 0,
@@ -241,11 +271,18 @@ class ZeroFeedIn extends utils.Adapter {
                 native: {},
             });
 
+            // States initialisieren
             const finalOnTime = v.switchOnTime || '';
             const finalOffTime = v.switchOffTime || '';
 
-            await this.setStateAsync(`${this.namespace}.${channelId}.switchOnTime`, { val: finalOnTime, ack: true });
-            await this.setStateAsync(`${this.namespace}.${channelId}.switchOffTime`, { val: finalOffTime, ack: true });
+            await this.setStateAsync(`${this.namespace}.${channelId}.switchOnTime`, {
+                val: finalOnTime,
+                ack: true,
+            });
+            await this.setStateAsync(`${this.namespace}.${channelId}.switchOffTime`, {
+                val: finalOffTime,
+                ack: true,
+            });
             await this.setStateAsync(`${this.namespace}.${channelId}.alwaysOffAtTime`, {
                 val: v.alwaysOffAtTime || false,
                 ack: true,
@@ -285,7 +322,9 @@ class ZeroFeedIn extends utils.Adapter {
 
         if (name) {
             this.log.debug(
-                `🕒 ${name}: Zeitfenster ${onTime}–${offTime}, aktuell ${now.toTimeString().slice(0, 5)} (${currentMinutes} min) → innerhalb? ${within}`,
+                `${name}: Time window ${onTime}–${offTime}, current  ${now
+                    .toTimeString()
+                    .slice(0, 5)} (${currentMinutes} min), within? ${within}`,
             );
         }
 
@@ -297,52 +336,58 @@ class ZeroFeedIn extends utils.Adapter {
             return;
         }
 
-        // FeedIn soll immer reagieren, egal ob ack true/false
+        // FeedIn Datapoint - fremder State, nur bei ack=true reagieren
         if (id === this.feedInDatapoint) {
-            this.log.debug(`📊 FeedIn-Wert aktualisiert: ${state.val} (ack=${state.ack})`);
-            await this.checkConsumers();
+            // Nur verarbeiten wenn der Wert vom anderen Adapter bestätigt wurde
+            if (state.ack === true) {
+                this.log.debug(`Feed-in value updated: ${state.val} (ack=${state.ack})`);
+                await this.checkConsumers();
 
-            if (this.percentTimer) {
-                clearTimeout(this.percentTimer);
-            }
-            this.percentTimer = setTimeout(
-                async () => {
-                    for (const v of this.consumerList.filter(v => v.ruletype === 'percent')) {
-                        await this.controlPercentConsumer(v);
-                    }
-                    this.percentTimer = null;
-                },
-                (this.config.delaySecondsProzent || 60) * 1000,
-            );
+                if (this.percentTimer) {
+                    clearTimeout(this.percentTimer);
+                }
+                this.percentTimer = this.safeSetTimeout(
+                    async () => {
+                        for (const v of this.consumerList.filter(v => v.ruletype === 'percent')) {
+                            await this.controlPercentConsumer(v);
+                        }
+                        this.percentTimer = null;
+                    },
+                    (this.config.delaySecondsProzent || this.DEFAULT_TIMEOUT / 1000) * 1000,
+                );
 
-            if (this.batteryTimer) {
-                clearTimeout(this.batteryTimer);
-            }
-            this.batteryTimer = setTimeout(
-                async () => {
-                    if (!this.feedInDatapoint) {
-                        return;
-                    }
-                    const feedInState = await this.getForeignStateAsync(this.feedInDatapoint);
-                    let feedIn = Number(feedInState?.val) || 0;
-                    if (this.config.feedinNegativ) {
-                        feedIn = -feedIn;
-                    }
+                if (this.batteryTimer) {
+                    clearTimeout(this.batteryTimer);
+                }
+                this.batteryTimer = this.safeSetTimeout(
+                    async () => {
+                        if (!this.feedInDatapoint) {
+                            return;
+                        }
+                        const feedInState = await this.getForeignStateAsync(this.feedInDatapoint);
+                        let feedIn = Number(feedInState?.val) || 0;
+                        if (this.config.feedinNegativ) {
+                            feedIn = -feedIn;
+                        }
 
-                    for (const v of this.consumerList.filter(v => v.ruletype === 'battery')) {
-                        await this.controlBattery(v, feedIn);
-                    }
-                    this.batteryTimer = null;
-                },
-                (this.config.batteryDelaySeconds || 60) * 1000,
-            );
-            return; // WICHTIG: damit nicht auch der !state.ack-Teil ausgeführt wird
+                        for (const v of this.consumerList.filter(v => v.ruletype === 'battery')) {
+                            await this.controlBattery(v, feedIn);
+                        }
+                        this.batteryTimer = null;
+                    },
+                    (this.config.batteryDelaySeconds || this.DEFAULT_TIMEOUT / 1000) * 1000,
+                );
+            } else {
+                this.log.debug(`Feed-in value change ignored (ack=${state.ack}) - waiting for confirmed value`);
+            }
+            return;
         }
 
-        // Rest bleibt wie gehabt (nur bei ack=false)
+        // Eigene States - nur bei ack=false verarbeiten (Commands/Befehle)
         if (state && !state.ack) {
             this.log.debug(`State changed: ${id} => ${state.val}`);
 
+            // ControlMode Änderungen
             const match = id.match(/consumer\.(\d+)_.*?\.controlMode/);
             if (match) {
                 const index = parseInt(match[1]);
@@ -356,6 +401,7 @@ class ZeroFeedIn extends utils.Adapter {
                 }
             }
 
+            // Time Änderungen
             const timeMatch = id.match(/consumer\.(\d+)_.*?\.(switchOnTime|switchOffTime)/);
             if (timeMatch) {
                 const index = parseInt(timeMatch[1]);
@@ -376,7 +422,7 @@ class ZeroFeedIn extends utils.Adapter {
 
         try {
             if (!this.feedInDatapoint) {
-                this.log.warn('❗ Kein FeedIn-Datenpunkt gesetzt – checkConsumers() wird übersprungen.');
+                this.log.warn('No FeedIn datapoint set – skipping checkConsumers()');
                 await this.sendNotification(
                     'smartloadmanager',
                     'alert',
@@ -398,7 +444,7 @@ class ZeroFeedIn extends utils.Adapter {
             const baseload = this.config.baseload || 0;
             const gridUsage = feedIn <= baseload;
 
-            this.log.debug(`📊 FeedIn: ${feedIn} W, Baseload: ${baseload} W, GridUsage: ${gridUsage}`);
+            this.log.debug(`FeedIn: ${feedIn} W, Baseload: ${baseload} W, GridUsage: ${gridUsage}`);
 
             // ----------------------------------
             // Einschalten binary + heating
@@ -407,17 +453,18 @@ class ZeroFeedIn extends utils.Adapter {
                 .filter(v => v.ruletype === 'binary' || v.ruletype === 'heating')
                 .sort((a, b) => (a.priority || 1) - (b.priority || 1));
 
-            this.log.debug(`🔍 Einschalt-Prüfung für ${sortedOn.length} binary/heating-Verbraucher.`);
+            this.log.debug(`Switch-on check for ${sortedOn.length} binary/heating-consumers.`);
 
             for (const v of sortedOn) {
                 const idx = this.consumerList.indexOf(v);
-                const id = `${this.namespace}.consumer.${idx}_${v.name.replace(/\s+/g, '_')}`;
+                const safeName = this.name2id(v.name);
+                const id = `${this.namespace}.consumer.${idx}_${safeName}`;
                 const mode = await this.getStateAsync(`${id}.controlMode`);
 
-                this.log.debug(`➡️ Prüfe "${v.name}" (Prio ${v.priority}, ${v.performance} W, Typ=${v.ruletype})`);
+                this.log.debug(`Checking "${v.name}" (priority ${v.priority}, ${v.performance} W, Type=${v.ruletype})`);
 
                 if (!mode || mode.val !== 2) {
-                    this.log.debug(`⏭️ Manueller Modus aktiv, Überspringe.`);
+                    this.log.debug(`Manual mode active, skipping.`);
                     continue;
                 }
 
@@ -435,10 +482,10 @@ class ZeroFeedIn extends utils.Adapter {
                     if (numVal === 1) {
                         isOn = true;
                     }
-                    this.log.debug(`🔢 NumericDatapoint für "${v.name}": ${v.numericDatapoint} = ${numVal}`);
+                    this.log.debug(`NumericDatapoint für "${v.name}": ${v.numericDatapoint} = ${numVal}`);
                 }
 
-                this.log.debug(`💡 "${v.name}" Status: isOn=${isOn}`);
+                this.log.debug(`"${v.name}" Status: isOn=${isOn}`);
 
                 // Zusatz-Checks heating
                 if (v.ruletype === 'heating' && withinWindow && !isOn) {
@@ -449,13 +496,13 @@ class ZeroFeedIn extends utils.Adapter {
 
                     if (currentTemp !== null && v.maxTemperature !== undefined && currentTemp >= v.maxTemperature) {
                         this.log.warn(
-                            `🔥 "${v.name}" NICHT eingeschaltet – Temperatur ${currentTemp}°C >= MaxTemp ${v.maxTemperature}°C`,
+                            `"${v.name}" not switched on, temperature ${currentTemp}°C >= MaxTemp ${v.maxTemperature}°C`,
                         );
                         continue;
                     }
                     if (currentTemp !== null && v.minTemperature !== undefined && currentTemp < v.minTemperature) {
                         this.log.debug(
-                            `🌡️ "${v.name}" noch nicht einschalten – Temperatur ${currentTemp}°C < MinTemp ${v.minTemperature}°C`,
+                            `"${v.name}" not switched on yet, temperature ${currentTemp}°C < MinTemp ${v.minTemperature}°C`,
                         );
                         continue;
                     }
@@ -463,7 +510,7 @@ class ZeroFeedIn extends utils.Adapter {
                     if (v.enableDatapoint) {
                         const enableState = await this.getForeignStateAsync(v.enableDatapoint);
                         if (!enableState?.val) {
-                            this.log.debug(`🔒 "${v.name}" NICHT eingeschaltet – Hardwarefreigabe fehlt.`);
+                            this.log.debug(`"${v.name}" NICHT eingeschaltet – Hardware release missing.`);
                             continue;
                         }
                     }
@@ -471,7 +518,7 @@ class ZeroFeedIn extends utils.Adapter {
                     if (v.heartbeatDatapoint) {
                         const hbState = await this.getForeignStateAsync(v.heartbeatDatapoint);
                         if (!hbState?.val) {
-                            this.log.warn(`💔 "${v.name}" NICHT eingeschaltet – Heartbeat fehlt.`);
+                            this.log.warn(`"${v.name}" not switched on – hardware approval missing.`);
                             continue;
                         }
                     }
@@ -488,28 +535,30 @@ class ZeroFeedIn extends utils.Adapter {
                     v.timer = null;
                     v.timerEnd = null;
                     v.pendingAction = null;
-                    const channelId = `consumer.${idx}_${v.name.replace(/\s+/g, '_')}`;
+                    const channelId = `consumer.${idx}_${safeName}`;
                     await this.setStateAsync(`${this.namespace}.${channelId}.onTimerRemaining`, { val: 0, ack: true });
                     await this.setStateAsync(`${this.namespace}.${channelId}.offTimerRemaining`, { val: 0, ack: true });
-                    this.log.debug(`⏹️ Einschalt-Timer für "${v.name}" abgebrochen (Bedingung entfallen).`);
+                    this.log.debug(`Switch-on timer for "${v.name}" canceled (condition no longer valid).`);
                 }
 
                 if (withinWindow) {
                     if (!gridUsage && v.performance <= feedIn - baseload && !isOn) {
                         this.log.debug(
-                            `✅ Einschalten möglich: Überschuss ${feedIn - baseload} W, innerhalb Zeitfenster (onDelay ${v.switchOnDelay || 0}s).`,
+                            `Switch-on possible: surplus ${
+                                feedIn - baseload
+                            } W, within time window (onDelay ${v.switchOnDelay || 0}s).`,
                         );
                         await this.switchConsumerWithDelay(v, true, v.switchOnDelay || 0);
                         feedIn -= v.performance;
-                        this.log.debug(`🔄 Verbleibender Überschuss nach Zuschaltung: ${feedIn - baseload} W`);
+                        this.log.debug(`Remaining surplus after switch-on: ${feedIn - baseload} W`);
                     } else if (gridUsage && !isOn) {
-                        this.log.debug(`🚫 Nicht eingeschaltet: Netzbezug aktiv.`);
+                        this.log.debug(`Not switched on: grid usage active.`);
                     } else if (!isOn) {
                         this.log.debug(
-                            `⚠️ Nicht eingeschaltet: Überschuss zu gering (${feedIn - baseload} W < ${v.performance} W).`,
+                            `Not switched on: surplus too low (${feedIn - baseload} W < ${v.performance} W).`,
                         );
                     } else {
-                        this.log.debug(`ℹ️ "${v.name}" ist bereits eingeschaltet – keine Aktion nötig.`);
+                        this.log.debug(`"${v.name}" is already switched on – no action needed.`);
                     }
                 }
             }
@@ -521,11 +570,12 @@ class ZeroFeedIn extends utils.Adapter {
                 .filter(v => v.ruletype === 'binary' || v.ruletype === 'heating')
                 .sort((a, b) => (b.priority || 1) - (a.priority || 1));
 
-            this.log.debug(`🔍 Ausschalt-Prüfung für ${sortedOff.length} binary/heating-Verbraucher.`);
+            this.log.debug(`Switch-off check for ${sortedOff.length} binary/heating-consumers.`);
 
             for (const v of sortedOff) {
                 const idx = this.consumerList.indexOf(v);
-                const id = `${this.namespace}.consumer.${idx}_${v.name.replace(/\s+/g, '_')}`;
+                const safeName = this.name2id(v.name);
+                const id = `${this.namespace}.consumer.${idx}_${safeName}`;
                 const mode = await this.getStateAsync(`${id}.controlMode`);
                 if (!mode || mode.val !== 2) {
                     continue;
@@ -552,13 +602,13 @@ class ZeroFeedIn extends utils.Adapter {
                 if (v.alwaysOffAtTime && !withinWindow && isOn) {
                     if (v.timer && v.timerEnd && v.pendingAction === false) {
                         const remaining = Math.max(0, Math.round((v.timerEnd - Date.now()) / 1000));
-                        this.log.debug(`📋 Aktive Timer → ${v.name}: noch ${remaining}s`);
+                        this.log.debug(`Active timer for ${v.name}: ${remaining}s remaining`);
                     } else if (v.timer && v.timerEnd && v.pendingAction === true) {
                         clearTimeout(v.timer);
                         v.timer = null;
                         v.timerEnd = null;
                         v.pendingAction = null;
-                        const channelId = `consumer.${idx}_${v.name.replace(/\s+/g, '_')}`;
+                        const channelId = `consumer.${idx}_${safeName}`;
                         await this.setStateAsync(`${this.namespace}.${channelId}.onTimerRemaining`, {
                             val: 0,
                             ack: true,
@@ -567,14 +617,14 @@ class ZeroFeedIn extends utils.Adapter {
                             val: 0,
                             ack: true,
                         });
-                        this.log.debug(`⏹️ Einschalt-Timer für "${v.name}" abgebrochen (AlwaysOff aktiv).`);
+                        this.log.debug(`Switch-on timer for "${v.name}" canceled (AlwaysOff active).`);
                         this.log.debug(
-                            `⏳ AlwaysOff aktiv: "${v.name}" - Zeitfenster vorbei, offDelay ${v.switchOffDelay || 0}s.`,
+                            `AlwaysOff active: "${v.name}" - time window expired, offDelay ${v.switchOffDelay || 0}s.`,
                         );
                         await this.switchConsumerWithDelay(v, false, v.switchOffDelay || 0);
                     } else {
                         this.log.debug(
-                            `⏳ AlwaysOff aktiv: "${v.name}" - Zeitfenster vorbei, offDelay ${v.switchOffDelay || 0}s.`,
+                            `AlwaysOff activ: "${v.name}" - time window expired, offDelay ${v.switchOffDelay || 0}s.`,
                         );
                         await this.switchConsumerWithDelay(v, false, v.switchOffDelay || 0);
                     }
@@ -585,7 +635,7 @@ class ZeroFeedIn extends utils.Adapter {
                     if (v.enableDatapoint) {
                         const enableState = await this.getForeignStateAsync(v.enableDatapoint);
                         if (!enableState?.val) {
-                            this.log.warn(`🔒 "${v.name}" wird abgeschaltet – Hardwarefreigabe fehlt.`);
+                            this.log.warn(`"${v.name}" is being switched off - hardware approval missing.`);
                             await this.switchConsumerWithDelay(v, false, 0);
                             continue;
                         }
@@ -593,7 +643,7 @@ class ZeroFeedIn extends utils.Adapter {
                     if (v.heartbeatDatapoint) {
                         const hbState = await this.getForeignStateAsync(v.heartbeatDatapoint);
                         if (!hbState?.val) {
-                            this.log.warn(`💔 "${v.name}" wird abgeschaltet – Heartbeat fehlt.`);
+                            this.log.warn(`"${v.name}" is being switched off - heartbeat missing.`);
                             await this.switchConsumerWithDelay(v, false, 0);
                             continue;
                         }
@@ -604,30 +654,54 @@ class ZeroFeedIn extends utils.Adapter {
                     continue;
                 }
 
+                // Temperatur-basierte Ausschaltung für heating
+                if (v.ruletype === 'heating' && v.maxTemperature !== undefined && isOn) {
+                    const tempState = v.temperatureDatapoint
+                        ? await this.getForeignStateAsync(v.temperatureDatapoint)
+                        : null;
+                    const currentTemp = tempState?.val !== undefined ? Number(tempState.val) : null;
+                    if (currentTemp !== null && currentTemp >= v.maxTemperature) {
+                        this.log.warn(
+                            `"${v.name}" switched off due to maxTemperature reached: ${currentTemp}°C >= ${v.maxTemperature}°C`,
+                        );
+                        await this.switchConsumerWithDelay(v, false, 0);
+                        continue; // weiter zum nächsten Verbraucher
+                    }
+                }
+
                 // Timer-Abbruch bei wegfallender Bedingung (Ausschalten)
-                if (v.timer && v.timerEnd && v.pendingAction === false && withinWindow && !gridUsage) {
+                const surplus = feedIn - baseload;
+                if (v.timer && v.timerEnd && v.pendingAction === false && withinWindow && surplus >= v.switchOffPoint) {
                     clearTimeout(v.timer);
                     v.timer = null;
                     v.timerEnd = null;
                     v.pendingAction = null;
-                    const channelId = `consumer.${idx}_${v.name.replace(/\s+/g, '_')}`;
+                    const channelId = `consumer.${idx}_${safeName}`;
                     await this.setStateAsync(`${this.namespace}.${channelId}.onTimerRemaining`, { val: 0, ack: true });
                     await this.setStateAsync(`${this.namespace}.${channelId}.offTimerRemaining`, { val: 0, ack: true });
-                    this.log.debug(`⏹️ Ausschalt-Timer für "${v.name}" abgebrochen (Bedingung entfallen).`);
+                    this.log.debug(`Switch-off timer for "${v.name}" canceled (condition no longer valid).`);
                 }
 
-                if (!v.alwaysOffAtTime && (!withinWindow || gridUsage)) {
+                // Ausschalten, wenn:
+                // - Zeitfenster verlassen ODER
+                // - Netzbezug aktiv ODER
+                // - Überschuss < switchOffPoint
+                const shouldSwitchOff = !withinWindow || gridUsage || surplus < v.switchOffPoint;
+
+                if (!v.alwaysOffAtTime && shouldSwitchOff) {
                     if (v.timer && v.timerEnd && v.pendingAction === false) {
                         const remaining = Math.max(0, Math.round((v.timerEnd - Date.now()) / 1000));
-                        this.log.debug(`📋 Aktive Timer → ${v.name}: noch ${remaining}s`);
+                        this.log.debug(`Active timer for ${v.name}: ${remaining}s remaining`);
                     } else {
-                        this.log.debug(`⏳ Ausschalten: "${v.name}" - offDelay ${v.switchOffDelay || 0}s.`);
+                        this.log.debug(
+                            `Switching off: "${v.name}" - surplus ${surplus}W < switchOffPoint ${v.switchOffPoint}W, offDelay ${v.switchOffDelay || 0}s.`,
+                        );
                         await this.switchConsumerWithDelay(v, false, v.switchOffDelay || 0);
                     }
                 }
             }
 
-            // --- Batterie bleibt unverändert ---
+            // --- Batterie unverändert ---
             const batteryConsumers = this.consumerList.filter(c => c.ruletype === 'battery');
             for (const v of batteryConsumers) {
                 await this.controlBattery(v, feedIn);
@@ -641,9 +715,9 @@ class ZeroFeedIn extends utils.Adapter {
                 });
 
             if (runningTimers.length > 0) {
-                this.log.debug(`📋 Aktive Timer → ${runningTimers.join(' | ')}`);
+                this.log.debug(`Active timers: ${runningTimers.join(' | ')}`);
             } else {
-                this.log.debug('📋 Keine aktiven Timer.');
+                this.log.debug('No active timers.');
             }
         } catch (err) {
             this.log.error(`Error in checkConsumers: ${err.message}`);
@@ -660,13 +734,13 @@ class ZeroFeedIn extends utils.Adapter {
         try {
             const withinWindow = this.timeWithinWindow(v.switchOnTime, v.switchOffTime);
             if (!withinWindow) {
-                this.log.debug(`[Percent] ${v.name} außerhalb Zeitfenster – auf 0% setzen`);
+                this.log.debug(`[Percent] ${v.name} outside time window, set to 0%`);
                 await this.setForeignStateAsync(v.datapoint, 0);
                 return;
             }
 
             if (!this.feedInDatapoint) {
-                this.log.error('❌ feedInDatapoint ist nicht gesetzt!');
+                this.log.error('feedInDatapoint not set!');
                 await this.sendNotification('smartloadmanager', 'alert', '❌ feedInDatapoint ist nicht gesetzt!');
                 return;
             }
@@ -696,7 +770,7 @@ class ZeroFeedIn extends utils.Adapter {
 
             if (newPercent !== currentPercent) {
                 await this.setForeignStateAsync(v.datapoint, newPercent);
-                this.log.info(`🔁 ${v.name} wurde auf ${newPercent}% geregelt`);
+                this.log.info(`${v.name} set to ${newPercent}%`);
 
                 if (this.config.notifyPercent) {
                     await this.sendNotification(
@@ -706,10 +780,10 @@ class ZeroFeedIn extends utils.Adapter {
                     );
                 }
             } else {
-                this.log.debug(`[Percent] ${v.name} bleibt bei ${currentPercent}%`);
+                this.log.debug(`[Percent] ${v.name} remains at ${currentPercent}%`);
             }
         } catch (error) {
-            this.log.error(`❌ Fehler in controlPercentConsumer: ${error.message}`);
+            this.log.error(`Error in controlPercentConsumer: ${error.message}`);
             await this.sendNotification(
                 'smartloadmanager',
                 'alert',
@@ -720,24 +794,33 @@ class ZeroFeedIn extends utils.Adapter {
 
     async controlBattery(v, feedIn) {
         try {
-            this.log.debug(`[Battery] Prüfung für ${v.name}`);
+            this.log.debug(`[Battery] Checking for ${v.name}`);
 
             const withinWindow = this.timeWithinWindow(v.switchOnTime, v.switchOffTime);
             if (!withinWindow) {
-                this.log.debug(`[Battery] ${v.name} außerhalb Zeitfenster – auf 0`);
+                this.log.debug(`[Battery] ${v.name} outside time window, set to 0`);
                 if (v.batterySetpoint) {
-                    await this.setForeignStateAsync(v.batterySetpoint, { val: 0, ack: true });
+                    await this.setForeignStateAsync(v.batterySetpoint, {
+                        val: 0,
+                        ack: true,
+                    });
                 }
-                if (v.batteryControlModeDatapoint) {
-                    await this.setForeignStateAsync(v.batteryControlModeDatapoint, { val: 0, ack: true });
+                if (this.batteryControlModeDatapoint) {
+                    await this.setForeignStateAsync(this.batteryControlModeDatapoint, {
+                        val: 0,
+                        ack: true,
+                    });
                 }
                 return;
             }
 
             if (!v.batterySetpoint) {
-                this.log.warn(`[Battery] ${v.name} hat keinen batterySetpoint`);
-                if (v.batteryControlModeDatapoint) {
-                    await this.setForeignStateAsync(v.batteryControlModeDatapoint, { val: 0, ack: true });
+                this.log.warn(`[Battery] ${v.name} has no batterySetpoint`);
+                if (this.batteryControlModeDatapoint) {
+                    await this.setForeignStateAsync(this.batteryControlModeDatapoint, {
+                        val: 0,
+                        ack: true,
+                    });
                 }
                 return;
             }
@@ -750,7 +833,7 @@ class ZeroFeedIn extends utils.Adapter {
                 soc = Number(socState?.val);
                 targetSoc = Number(targetSocState?.val);
                 if (isNaN(soc) || isNaN(targetSoc)) {
-                    this.log.warn(`[Battery] ${v.name}: Ungültiger SOC oder targetSOC`);
+                    this.log.warn(`[Battery] ${v.name}: invalid SOC or targetSOC`);
                     soc = null;
                     targetSoc = null;
                 }
@@ -777,8 +860,11 @@ class ZeroFeedIn extends utils.Adapter {
                 : -1;
 
             if (powerToSet !== oldPower) {
-                await this.setForeignStateAsync(v.batterySetpoint, { val: powerToSet, ack: true });
-                this.log.info(`🔁 Batterie ${v.name}: Ladeleistung auf ${powerToSet}W gesetzt`);
+                await this.setForeignStateAsync(v.batterySetpoint, {
+                    val: powerToSet,
+                    ack: true,
+                });
+                this.log.info(`Battery ${v.name}: charging power set to ${powerToSet}W`);
                 if (this.config.notifyBattery) {
                     await this.sendNotification(
                         'smartloadmanager',
@@ -787,12 +873,15 @@ class ZeroFeedIn extends utils.Adapter {
                     );
                 }
             } else {
-                this.log.debug(`[Battery] ${v.name} Ladeleistung bleibt bei ${oldPower}W`);
+                this.log.debug(`[Battery] ${v.name} charging power remains at ${oldPower}W`);
             }
 
             if (this.batteryControlModeDatapoint && modeToSet !== oldMode) {
-                await this.setForeignStateAsync(this.batteryControlModeDatapoint, { val: modeToSet, ack: true });
-                this.log.debug(`[Battery] ${v.name} Modus geändert: ${oldMode} → ${modeToSet}`);
+                await this.setForeignStateAsync(this.batteryControlModeDatapoint, {
+                    val: modeToSet,
+                    ack: true,
+                });
+                this.log.debug(`[Battery] ${v.name} mode changed from ${oldMode} to ${modeToSet}`);
                 if (this.config.notifyBattery) {
                     await this.sendNotification(
                         'smartloadmanager',
@@ -802,7 +891,7 @@ class ZeroFeedIn extends utils.Adapter {
                 }
             }
         } catch (error) {
-            this.log.error(`[Battery] Fehler für ${v.name}: ${error.message}`);
+            this.log.error(`[Battery] Error for ${v.name}: ${error.message}`);
             await this.sendNotification(
                 'smartloadmanager',
                 'alert',
@@ -822,16 +911,28 @@ class ZeroFeedIn extends utils.Adapter {
 
         if (consumer.datapoint) {
             // Erst setzen
-            await this.setForeignStateAsync(consumer.datapoint, { val: targetState, ack: false });
+            await this.setForeignStateAsync(consumer.datapoint, {
+                val: targetState,
+                ack: false,
+            });
             // Danach sofort bestätigen (falls keine Rückmeldung vom Gerät kommt)
-            await this.setForeignStateAsync(consumer.datapoint, { val: targetState, ack: true });
+            await this.setForeignStateAsync(consumer.datapoint, {
+                val: targetState,
+                ack: true,
+            });
         }
 
         if (consumer.numericDatapoint) {
             const numVal = targetState ? 1 : 0;
-            await this.setForeignStateAsync(consumer.numericDatapoint, { val: numVal, ack: false });
-            await this.setForeignStateAsync(consumer.numericDatapoint, { val: numVal, ack: true });
-            this.log.debug(`🔢 NumericDatapoint für "${consumer.name}" gesetzt auf ${numVal}`);
+            await this.setForeignStateAsync(consumer.numericDatapoint, {
+                val: numVal,
+                ack: false,
+            });
+            await this.setForeignStateAsync(consumer.numericDatapoint, {
+                val: numVal,
+                ack: true,
+            });
+            this.log.debug(`Numeric datapoint for "${consumer.name}" set to ${numVal}`);
         }
 
         const msg = `${consumer.name} wurde ${targetState ? 'eingeschaltet' : 'ausgeschaltet'}`;
@@ -856,7 +957,8 @@ class ZeroFeedIn extends utils.Adapter {
                   : consumer.switchOffDelay || 0;
 
         const idx = this.consumerList.indexOf(consumer);
-        const channelId = `consumer.${idx}_${consumer.name.replace(/\s+/g, '_')}`;
+        const safeName = this.name2id(consumer.name);
+        const channelId = `consumer.${idx}_${safeName}`;
         const onTimerState = `${this.namespace}.${channelId}.onTimerRemaining`;
         const offTimerState = `${this.namespace}.${channelId}.offTimerRemaining`;
 
@@ -885,7 +987,10 @@ class ZeroFeedIn extends utils.Adapter {
                     await this.setStateAsync(onTimerState, { val: remaining, ack: true });
                     await this.setStateAsync(offTimerState, { val: 0, ack: true });
                 } else {
-                    await this.setStateAsync(offTimerState, { val: remaining, ack: true });
+                    await this.setStateAsync(offTimerState, {
+                        val: remaining,
+                        ack: true,
+                    });
                     await this.setStateAsync(onTimerState, { val: 0, ack: true });
                 }
             };
@@ -894,7 +999,7 @@ class ZeroFeedIn extends utils.Adapter {
                 clearInterval(consumer.timerTick);
                 consumer.timerTick = null;
             }
-            consumer.timerTick = setInterval(tick, 1000);
+            consumer.timerTick = this.safeSetInterval(tick, 1000);
         };
 
         const doSwitch = async () => {
@@ -962,8 +1067,7 @@ class ZeroFeedIn extends utils.Adapter {
             await stopTimerTicker();
         };
 
-        // 🟢 Hier ist der Fix:
-        // Falls Timer läuft, aber Bedingung sich geändert hat → Timer abbrechen
+        // Falls Timer läuft, aber Bedingung sich geändert hat → Timer abbrechen / anpassen
         if (consumer.timer) {
             // wenn Einschalt-Timer läuft, aber turnOn nicht mehr gilt → abbrechen
             if (consumer.pendingAction === true && !turnOn) {
@@ -990,7 +1094,7 @@ class ZeroFeedIn extends utils.Adapter {
                 return;
             }
 
-            // ansonsten Timer neu setzen
+            // ansonsten Timer neu setzen (älteren abbrechen)
             clearTimeout(consumer.timer);
             consumer.timer = null;
             consumer.timerEnd = null;
@@ -1001,7 +1105,7 @@ class ZeroFeedIn extends utils.Adapter {
         if (delay > 0) {
             consumer.timerEnd = Date.now() + delay * 1000;
             consumer.pendingAction = turnOn;
-            consumer.timer = setTimeout(doSwitch, delay * 1000);
+            consumer.timer = this.safeSetTimeout(doSwitch, delay * 1000);
             await startTimerTicker();
         } else {
             await doSwitch();
@@ -1017,7 +1121,7 @@ class ZeroFeedIn extends utils.Adapter {
             // 1) Controller-Notification (nur wenn Option aktiv ist)
             if (cfg.enableNotificationManager) {
                 await this.registerNotification(scope, category, message);
-                this.log.debug(`📨 Controller-Notification [${scope}/${category}]: ${message}`);
+                this.log.debug(`Controller-Notification [${scope}/${category}]: ${message}`);
             }
 
             // 2) Messenger-Nachrichten
@@ -1031,11 +1135,11 @@ class ZeroFeedIn extends utils.Adapter {
                 if (recipients.length > 0) {
                     recipients.forEach(user => {
                         this.sendTo(cfg.telegramInstance, { text: message, user });
-                        this.log.debug(`📨 Telegram → ${cfg.telegramInstance}/${user}: ${message}`);
+                        this.log.debug(`Telegram → ${cfg.telegramInstance}/${user}: ${message}`);
                     });
                 } else {
                     this.sendTo(cfg.telegramInstance, message);
-                    this.log.debug(`📨 Telegram → ${cfg.telegramInstance}: ${message}`);
+                    this.log.debug(`Telegram → ${cfg.telegramInstance}: ${message}`);
                 }
             }
 
@@ -1045,7 +1149,7 @@ class ZeroFeedIn extends utils.Adapter {
                     title: 'SmartLoadManager',
                     message: message,
                 });
-                this.log.debug(`📨 Gotify → ${cfg.gotifyInstance}: ${message}`);
+                this.log.debug(`Gotify → ${cfg.gotifyInstance}: ${message}`);
             }
 
             // E-Mail
@@ -1061,14 +1165,14 @@ class ZeroFeedIn extends utils.Adapter {
                             text: message,
                             subject: 'SmartLoadManager',
                         });
-                        this.log.debug(`📨 Email → ${cfg.emailInstance}/${to}: ${message}`);
+                        this.log.debug(`Email → ${cfg.emailInstance}/${to}: ${message}`);
                     });
                 } else {
                     this.sendTo(cfg.emailInstance, {
                         text: message,
                         subject: 'SmartLoadManager',
                     });
-                    this.log.debug(`📨 Email → ${cfg.emailInstance}: ${message}`);
+                    this.log.debug(`Email → ${cfg.emailInstance}: ${message}`);
                 }
             }
 
@@ -1081,11 +1185,11 @@ class ZeroFeedIn extends utils.Adapter {
                 if (recipients.length > 0) {
                     recipients.forEach(user => {
                         this.sendTo(cfg.whatsappInstance, { text: message, user });
-                        this.log.debug(`📨 WhatsApp → ${cfg.whatsappInstance}/${user}: ${message}`);
+                        this.log.debug(`WhatsApp → ${cfg.whatsappInstance}/${user}: ${message}`);
                     });
                 } else {
                     this.sendTo(cfg.whatsappInstance, { text: message });
-                    this.log.debug(`📨 WhatsApp → ${cfg.whatsappInstance}: ${message}`);
+                    this.log.debug(`WhatsApp → ${cfg.whatsappInstance}: ${message}`);
                 }
             }
 
@@ -1098,11 +1202,11 @@ class ZeroFeedIn extends utils.Adapter {
                 if (recipients.length > 0) {
                     recipients.forEach(user => {
                         this.sendTo(cfg.signalInstance, { text: message, user });
-                        this.log.debug(`📨 Signal → ${cfg.signalInstance}/${user}: ${message}`);
+                        this.log.debug(`Signal → ${cfg.signalInstance}/${user}: ${message}`);
                     });
                 } else {
                     this.sendTo(cfg.signalInstance, { text: message });
-                    this.log.debug(`📨 Signal → ${cfg.signalInstance}: ${message}`);
+                    this.log.debug(`Signal → ${cfg.signalInstance}: ${message}`);
                 }
             }
 
@@ -1119,25 +1223,26 @@ class ZeroFeedIn extends utils.Adapter {
                             title: 'SmartLoadManager',
                             user,
                         });
-                        this.log.debug(`📨 Pushover → ${cfg.pushoverInstance}/${user}: ${message}`);
+                        this.log.debug(`Pushover → ${cfg.pushoverInstance}/${user}: ${message}`);
                     });
                 } else {
                     this.sendTo(cfg.pushoverInstance, {
                         message: message,
                         title: 'SmartLoadManager',
                     });
-                    this.log.debug(`📨 Pushover → ${cfg.pushoverInstance}: ${message}`);
+                    this.log.debug(`Pushover → ${cfg.pushoverInstance}: ${message}`);
                 }
             }
         } catch (e) {
-            this.log.warn(`❗ Fehler beim Senden der Notification: ${e.message}`);
+            this.log.warn(`Error sending notification: ${e.message}`);
         }
     }
 
     async initializeConsumerStatus() {
         // Initiale Status-Updates
         for (const v of this.consumerList) {
-            const channelId = `consumer.${this.consumerList.indexOf(v)}_${v.name.replace(/\s+/g, '_')}`;
+            const safeName = this.name2id(v.name);
+            const channelId = `consumer.${this.consumerList.indexOf(v)}_${safeName}`;
             const modeState = await this.getStateAsync(`${this.namespace}.${channelId}.controlMode`);
             if (!modeState) {
                 await this.setStateAsync(`${this.namespace}.${channelId}.controlMode`, {
@@ -1149,7 +1254,7 @@ class ZeroFeedIn extends utils.Adapter {
     }
 
     sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
+        return new Promise(resolve => this.safeSetTimeout(resolve, ms, 'sleep'));
     }
 
     parseTimeToMinutes(timeStr) {