iobroker.smartloadmanager 0.1.0 → 0.2.0

package/main.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const utils = require('@iobroker/adapter-core');
+const { evaluateForecast, minimumStateTimeSatisfied, parseForecast } = require('./lib/forecast');
 
 class ZeroFeedIn extends utils.Adapter {
     constructor(options) {
@@ -18,10 +19,25 @@ class ZeroFeedIn extends utils.Adapter {
         this.batteryTimer = null;
         this.checkRunning = false;
 
+        // 🔮 Forecast (PV forecast integration)
+        this.forecastEnabled = false;
+        this.forecastJsonDatapoint = null;
+        this.forecast = {
+            power: 0,
+            surplus: 0,
+            minutes: 0,
+            lastUpdate: 0,
+            // eslint-disable-next-line jsdoc/check-tag-names
+            points: /** @type {Array<{timestamp: number, power: number, surplus: number}>} */ ([]),
+            // eslint-disable-next-line jsdoc/check-tag-names
+            unit: /** @type {'W' | 'kW' | null} */ (null),
+        };
+
         this.on('ready', this.onReady.bind(this));
         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
@@ -31,6 +47,7 @@ class ZeroFeedIn extends utils.Adapter {
             .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);
@@ -48,6 +65,9 @@ class ZeroFeedIn extends utils.Adapter {
         return this.setInterval(fn, safeMs, ...args);
     }
 
+    // =====================================================================
+    // ============================ onReady ================================
+    // =====================================================================
     async onReady() {
         try {
             this.log.info(`Adapter started, PID: ${process.pid}`);
@@ -63,6 +83,13 @@ class ZeroFeedIn extends utils.Adapter {
             this.batteryControlModeDatapoint = this.config.batteryControlModeDatapoint || null;
             this.log.info(`Configured batteryControlModeDatapoint: ${this.batteryControlModeDatapoint}`);
 
+            // 🔮 Forecast config (PV forecast integration)
+            this.forecastEnabled = !!this.config.enableForecast;
+            this.forecastJsonDatapoint = this.config.forecastJsonDatapoint || null;
+            if (this.forecastEnabled && this.forecastJsonDatapoint) {
+                this.forecast.unit = await this.detectForecastPowerUnit();
+            }
+
             this.consumerList = Array.isArray(this.config.consumer)
                 ? this.config.consumer.filter(
                       v =>
@@ -81,12 +108,25 @@ class ZeroFeedIn extends utils.Adapter {
                     v.enabled = state.val;
                     this.log.debug(`"${v.name}": Active status taken from object tree (${state.val})`);
                 }
+                const switchingState = v.datapoint
+                    ? await this.getForeignStateAsync(v.datapoint)
+                    : v.numericDatapoint
+                      ? await this.getForeignStateAsync(v.numericDatapoint)
+                      : null;
+                v.lastStateChange = switchingState?.lc || 0;
+                v.lastForecastBridgeAt = null;
             }
 
             this.log.info(`Loaded consumers: ${this.consumerList.map(v => v.name).join(', ')}`);
 
             await this.checkAndCreateConsumerObjects();
             await this.createConsumerStates();
+
+            // 🔮 Forecast states (adapter-internal)
+            if (this.forecastEnabled) {
+                await this.createForecastStates();
+            }
+
             await this.initializeConsumerStatus();
             await this.subscribeStatesAsync('*');
             await this.subscribeForeignStatesAsync(this.feedInDatapoint);
@@ -94,7 +134,14 @@ class ZeroFeedIn extends utils.Adapter {
                 await this.subscribeForeignStatesAsync(this.batteryControlModeDatapoint);
             }
 
+            // 🔮 Forecast subscribe + initial parse
+            if (this.forecastEnabled && this.forecastJsonDatapoint) {
+                await this.subscribeForeignStatesAsync(this.forecastJsonDatapoint);
+                await this.processPvforecastJson();
+            }
+
             await this.checkConsumers();
+            this.ruleTimer = this.safeSetInterval(() => this.checkConsumers(), 15000);
         } catch (error) {
             this.log.error(`Error in onReady: ${error.message}`);
             // additionally send alert
@@ -102,6 +149,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ===================== Consumer object checks ========================
+    // =====================================================================
     async checkAndCreateConsumerObjects() {
         for (const v of this.consumerList) {
             if (v.datapoint) {
@@ -119,6 +169,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ========================= createConsumerStates ======================
+    // =====================================================================
     async createConsumerStates() {
         // Übergeordnetes Device erstellen - löst "intermediate objects missing" Problem
         await this.setObjectNotExistsAsync('consumer', {
@@ -250,6 +303,47 @@ class ZeroFeedIn extends utils.Adapter {
                 native: {},
             });
 
+            // 🔮 Forecast options per consumer
+            await this.setObjectNotExistsAsync(`${channelId}.useForecast`, {
+                type: 'state',
+                common: {
+                    name: 'Use forecast',
+                    type: 'boolean',
+                    role: 'switch',
+                    read: true,
+                    write: true,
+                    def: v.useForecast || false,
+                },
+                native: {},
+            });
+
+            await this.setObjectNotExistsAsync(`${channelId}.forecastMinMinutes`, {
+                type: 'state',
+                common: {
+                    name: 'Forecast min minutes',
+                    type: 'number',
+                    role: 'value.interval',
+                    read: true,
+                    write: true,
+                    def: v.forecastMinMinutes || 0,
+                    unit: 'min',
+                },
+                native: {},
+            });
+
+            await this.setObjectNotExistsAsync(`${channelId}.forecastStatus`, {
+                type: 'state',
+                common: {
+                    name: 'Forecast status',
+                    type: 'string',
+                    role: 'text',
+                    read: true,
+                    write: false,
+                    def: '',
+                },
+                native: {},
+            });
+
             if (v.ruletype === 'battery') {
                 await this.setObjectNotExistsAsync(`${channelId}.batterySetpoint`, {
                     type: 'state',
@@ -328,11 +422,257 @@ class ZeroFeedIn extends utils.Adapter {
 
             await this.setStateAsync(`${channelId}.active`, { val: v.enabled || false, ack: true });
 
+            // 🔮 Forecast states init per consumer
+            await this.setStateAsync(`${channelId}.useForecast`, { val: v.useForecast || false, ack: true });
+            await this.setStateAsync(`${channelId}.forecastMinMinutes`, {
+                val: v.forecastMinMinutes || 0,
+                ack: true,
+            });
+            await this.setStateAsync(`${channelId}.forecastStatus`, { val: '', ack: true });
+
             v.switchOnTime = finalOnTime;
             v.switchOffTime = finalOffTime;
         }
     }
 
+    // =====================================================================
+    // ========================= Forecast states ===========================
+    // =====================================================================
+    async createForecastStates() {
+        await this.setObjectNotExistsAsync('forecast', {
+            type: 'channel',
+            common: { name: 'Forecast' },
+            native: {},
+        });
+
+        await this.setObjectNotExistsAsync('forecast.power', {
+            type: 'state',
+            common: {
+                name: 'Forecast Power',
+                type: 'number',
+                role: 'value.power',
+                read: true,
+                write: false,
+                unit: 'W',
+                def: 0,
+            },
+            native: {},
+        });
+
+        await this.setObjectNotExistsAsync('forecast.surplus', {
+            type: 'state',
+            common: {
+                name: 'Forecast Surplus',
+                type: 'number',
+                role: 'value.power',
+                read: true,
+                write: false,
+                unit: 'W',
+                def: 0,
+            },
+            native: {},
+        });
+
+        await this.setObjectNotExistsAsync('forecast.minutes', {
+            type: 'state',
+            common: {
+                name: 'Forecast Minutes',
+                type: 'number',
+                role: 'value.interval',
+                read: true,
+                write: false,
+                unit: 'min',
+                def: 0,
+            },
+            native: {},
+        });
+
+        await this.setObjectNotExistsAsync('forecast.lastUpdate', {
+            type: 'state',
+            common: {
+                name: 'Forecast Last Update',
+                type: 'number',
+                role: 'value.time',
+                read: true,
+                write: false,
+                def: 0,
+            },
+            native: {},
+        });
+    }
+
+    // =====================================================================
+    // ========================= Forecast JSON parse =======================
+    // =====================================================================
+    async processPvforecastJson() {
+        try {
+            if (!this.forecastEnabled || !this.forecastJsonDatapoint) {
+                return;
+            }
+
+            const state = await this.getForeignStateAsync(this.forecastJsonDatapoint);
+            if (!state || !state.val) {
+                return;
+            }
+
+            try {
+                this.forecast.points = parseForecast(String(state.val), {
+                    unit: this.forecast.unit,
+                    baseload: this.config.baseload || 0,
+                });
+            } catch (error) {
+                this.forecast.points = [];
+                this.log.warn(`[Forecast] Invalid pvforecast JSON: ${error.message}`);
+                return;
+            }
+
+            const best = this.forecast.points[0];
+            if (!best) {
+                return;
+            }
+            const power = best.power;
+            const minutes = Math.max(0, Math.round((best.timestamp - Date.now()) / 60000));
+
+            this.forecast.power = power;
+            this.forecast.surplus = best.surplus;
+            this.forecast.minutes = minutes;
+            this.forecast.lastUpdate = Date.now();
+
+            await this.setStateAsync(`${this.namespace}.forecast.power`, { val: power, ack: true });
+            await this.setStateAsync(`${this.namespace}.forecast.surplus`, {
+                val: this.forecast.surplus,
+                ack: true,
+            });
+            await this.setStateAsync(`${this.namespace}.forecast.minutes`, { val: minutes, ack: true });
+            await this.setStateAsync(`${this.namespace}.forecast.lastUpdate`, {
+                val: this.forecast.lastUpdate,
+                ack: true,
+            });
+
+            this.log.debug(
+                `[Forecast] ${this.forecast.points.length} values parsed (${this.forecast.unit || 'auto'}) - next: ${power}W in ${minutes}min`,
+            );
+        } catch (error) {
+            this.log.error(`[Forecast] Error processing pvforecast JSON: ${error.message}`);
+        }
+    }
+
+    /**
+     * Detect the power unit used by pvforecast.
+     *
+     * @returns {Promise<'W'|'kW'|null>} Detected unit or null for value-based detection.
+     */
+    async detectForecastPowerUnit() {
+        const configured = this.config.forecastPowerUnit;
+        if (configured === 'W' || configured === 'kW') {
+            return configured;
+        }
+        try {
+            const summaryPowerId = (this.forecastJsonDatapoint || '').replace(/\.JSONData$/, '.power.now');
+            const object = await this.getForeignObjectAsync(summaryPowerId);
+            const unit = object?.common?.unit;
+            if (unit === 'W' || unit === 'kW') {
+                return unit;
+            }
+        } catch (error) {
+            this.log.debug(`[Forecast] Unit detection failed: ${error.message}`);
+        }
+        return null;
+    }
+
+    // =====================================================================
+    // ========================= Forecast helpers ==========================
+    // =====================================================================
+    getForecastPower(_v) {
+        return this.forecast?.power || 0;
+    }
+
+    getForecastMinutes(_v) {
+        return this.forecast?.minutes || 0;
+    }
+
+    getForecastDecision(v, requiredPower) {
+        const maxStartMinutes =
+            this.config.forecastMaxStartMinutes === undefined ? 30 : Number(this.config.forecastMaxStartMinutes);
+        return evaluateForecast(this.forecast.points, {
+            requiredPower,
+            safetyFactor: (Number(this.config.forecastSafetyPercent) || 80) / 100,
+            minDurationMinutes: Number(v.forecastMinMinutes) || Number(this.config.forecastDefaultMinMinutes) || 30,
+            maxStartMinutes,
+        });
+    }
+
+    isForecastAllowingSwitchOn(v, currentSurplus) {
+        if (!this.forecastEnabled || !v.useForecast) {
+            return false;
+        }
+        const requiredPower = Number(v.performance) || 0;
+        const minimumCurrentPercent =
+            this.config.forecastMinCurrentPercent === undefined ? 50 : Number(this.config.forecastMinCurrentPercent);
+        const minimumCurrent = requiredPower * (minimumCurrentPercent / 100);
+        if (currentSurplus < minimumCurrent) {
+            return false;
+        }
+        const minimumOffMinutes = v.minimumOffMinutes === undefined ? 5 : Number(v.minimumOffMinutes);
+        if (!minimumStateTimeSatisfied(v.lastStateChange, minimumOffMinutes)) {
+            return false;
+        }
+        return this.getForecastDecision(v, requiredPower).available;
+    }
+
+    isForecastDelayingSwitchOff(v, currentSurplus, requiredPower) {
+        if (!this.forecastEnabled || !v.useForecast) {
+            return false;
+        }
+        const bridgeMinutes =
+            this.config.forecastBridgeMinutes === undefined ? 5 : Number(this.config.forecastBridgeMinutes);
+        const maxGridImport = Math.max(
+            0,
+            this.config.forecastMaxGridImport === undefined ? 100 : Number(this.config.forecastMaxGridImport),
+        );
+        if (currentSurplus < -maxGridImport) {
+            return false;
+        }
+        const decision = this.getForecastDecision(
+            v,
+            Number(requiredPower) || Number(v.switchOnPoint) || Number(v.performance) || 0,
+        );
+        if (!decision.available || decision.startMinutes === null || decision.startMinutes > bridgeMinutes) {
+            return false;
+        }
+        v.lastForecastBridgeAt ||= Date.now();
+        return Date.now() - v.lastForecastBridgeAt <= bridgeMinutes * 60000;
+    }
+
+    async setForecastState(v, idx, active, reason, power, minutes) {
+        try {
+            const safeName = this.name2id(v.name);
+            const channelId = `consumer.${idx}_${safeName}`;
+            const text = active
+                ? `${reason || 'forecast'} (${power || this.forecast.power || 0}W / ${minutes || this.forecast.minutes || 0}min)`
+                : '';
+            await this.setStateAsync(`${this.namespace}.${channelId}.forecastStatus`, {
+                val: text,
+                ack: true,
+            });
+        } catch (err) {
+            this.log.warn(`[Forecast] Failed to set forecastStatus: ${err.message}`);
+        }
+    }
+
+    async sendForecastNotification(type, message) {
+        try {
+            if (this.config.notifyForecast) {
+                await this.sendNotification('smartloadmanager', 'notify', message);
+            }
+        } catch (err) {
+            this.log.warn(`[Forecast] Failed to send forecast notification: ${err.message}`);
+        }
+    }
+
+    // =====================================================================
+    // ========================= Time window helper ========================
+    // =====================================================================
     timeWithinWindow(onTime, offTime, name) {
         if (!onTime || !offTime) {
             return true;
@@ -343,7 +683,11 @@ class ZeroFeedIn extends utils.Adapter {
         const onMinutes = this.parseTimeToMinutes(onTime);
         const offMinutes = this.parseTimeToMinutes(offTime);
 
-        const within = currentMinutes >= onMinutes && currentMinutes < offMinutes;
+        const within =
+            onMinutes === offMinutes ||
+            (onMinutes < offMinutes
+                ? currentMinutes >= onMinutes && currentMinutes < offMinutes
+                : currentMinutes >= onMinutes || currentMinutes < offMinutes);
 
         if (name) {
             this.log.debug(
@@ -356,11 +700,23 @@ class ZeroFeedIn extends utils.Adapter {
         return within;
     }
 
+    // =====================================================================
+    // ========================= onStateChange =============================
+    // =====================================================================
     async onStateChange(id, state) {
         if (!state) {
             return;
         }
 
+        // 🔮 Forecast JSON datapoint changed
+        if (this.forecastEnabled && this.forecastJsonDatapoint && id === this.forecastJsonDatapoint) {
+            if (state.ack === true) {
+                await this.processPvforecastJson();
+                await this.checkConsumers();
+            }
+            return;
+        }
+
         // FeedIn Datapoint - fremder State, nur bei ack=true reagieren
         if (id === this.feedInDatapoint) {
             // Nur verarbeiten wenn der Wert vom anderen Adapter bestätigt wurde
@@ -368,40 +724,7 @@ class ZeroFeedIn extends utils.Adapter {
                 this.log.debug(`Feed-in value updated: ${state.val} (ack=${state.ack})`);
                 await this.checkConsumers();
 
-                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 = 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 || this.DEFAULT_TIMEOUT / 1000) * 1000,
-                );
+                this.scheduleRegulation();
             } else {
                 this.log.debug(`Feed-in value change ignored (ack=${state.ack}) - waiting for confirmed value`);
             }
@@ -419,6 +742,16 @@ class ZeroFeedIn extends utils.Adapter {
                 const v = this.consumerList[index];
                 if (v) {
                     v.enabled = state.val;
+                    if (!v.enabled && v.timer) {
+                        clearTimeout(v.timer);
+                        v.timer = null;
+                        v.timerEnd = null;
+                        v.pendingAction = null;
+                        if (v.timerTick) {
+                            clearInterval(v.timerTick);
+                            v.timerTick = null;
+                        }
+                    }
                     this.log.info(`Consumer "${v.name}" became ${state.val ? 'activated' : 'deactivated'}.`);
                     await this.setStateAsync(id, { val: state.val, ack: true });
                 }
@@ -432,10 +765,29 @@ class ZeroFeedIn extends utils.Adapter {
                 const mode = state.val;
                 const v = this.consumerList[index];
 
-                if (mode === 0) {
-                    await this.switchConsumerWithDelay(v, false);
-                } else if (mode === 1) {
-                    await this.switchConsumerWithDelay(v, true);
+                if (!v || ![0, 1, 2].includes(mode)) {
+                    return;
+                }
+                await this.setStateAsync(id, { val: mode, ack: true });
+                if (v.timer) {
+                    clearTimeout(v.timer);
+                    v.timer = null;
+                    v.timerEnd = null;
+                    v.pendingAction = null;
+                }
+                if (mode === 2) {
+                    await this.checkConsumers();
+                } else if (v.ruletype === 'percent') {
+                    await this.setForeignStateAsync(v.datapoint, { val: mode === 1 ? 100 : 0, ack: false });
+                } else if (v.ruletype === 'battery') {
+                    if (v.batterySetpoint) {
+                        await this.setForeignStateAsync(v.batterySetpoint, {
+                            val: mode === 1 ? v.performance || 1000 : 0,
+                            ack: false,
+                        });
+                    }
+                } else {
+                    await this.switchConsumerWithDelay(v, mode === 1, 0);
                 }
             }
 
@@ -450,6 +802,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ============================ checkConsumers =========================
+    // =====================================================================
     async checkConsumers() {
         if (this.checkRunning) {
             this.checkQueued = true;
@@ -525,13 +880,18 @@ class ZeroFeedIn extends utils.Adapter {
                 }
 
                 this.log.debug(`"${v.name}" Status: isOn=${isOn}`);
+                const minimumOffSatisfied = minimumStateTimeSatisfied(
+                    v.lastStateChange,
+                    v.minimumOffMinutes === undefined ? 5 : Number(v.minimumOffMinutes),
+                );
 
                 // Zusatz-Checks heating
                 if (v.ruletype === 'heating' && withinWindow && !isOn) {
                     const tempState = v.temperatureDatapoint
                         ? await this.getForeignStateAsync(v.temperatureDatapoint)
                         : null;
-                    const currentTemp = tempState?.val !== undefined ? Number(tempState.val) : null;
+                    const currentTemp =
+                        tempState?.val !== undefined && tempState.val !== null ? Number(tempState.val) : null;
 
                     if (currentTemp !== null && v.maxTemperature !== undefined && currentTemp >= v.maxTemperature) {
                         this.log.warn(
@@ -581,7 +941,12 @@ class ZeroFeedIn extends utils.Adapter {
                 }
 
                 if (withinWindow) {
-                    if (!gridUsage && v.performance <= feedIn - baseload && !isOn) {
+                    if (
+                        !gridUsage &&
+                        Math.max(v.performance, Number(v.switchOnPoint) || 0) <= feedIn - baseload &&
+                        !isOn &&
+                        minimumOffSatisfied
+                    ) {
                         this.log.debug(
                             `Switch-on possible: surplus ${
                                 feedIn - baseload
@@ -590,11 +955,27 @@ class ZeroFeedIn extends utils.Adapter {
                         await this.switchConsumerWithDelay(v, true, v.switchOnDelay || 0);
                         feedIn -= v.performance;
                         this.log.debug(`Remaining surplus after switch-on: ${feedIn - baseload} W`);
+                        await this.setForecastState(v, idx, false, '', null, null);
+                    } else if (!gridUsage && !isOn && this.isForecastAllowingSwitchOn(v, feedIn - baseload)) {
+                        const forecastPower = this.getForecastPower(v);
+                        const minutes = this.getForecastMinutes(v);
+                        this.log.debug(
+                            `[Forecast] Early switch-on allowed for "${v.name}": ${forecastPower} W in ${minutes} min.`,
+                        );
+                        await this.setForecastState(v, idx, true, 'forecastSwitchOn', forecastPower, minutes);
+                        await this.sendForecastNotification(
+                            v.ruletype === 'percent' ? 'percent' : 'binary',
+                            `🔮 Forecast: "${v.name}" will be switched on in ${minutes} minutes (${forecastPower} W expected).`,
+                        );
+                        await this.switchConsumerWithDelay(v, true, v.switchOnDelay || 0);
+                        feedIn -= v.performance;
                     } else if (gridUsage && !isOn) {
                         this.log.debug(`Not switched on: grid usage active.`);
                     } else if (!isOn) {
                         this.log.debug(
-                            `Not switched on: surplus too low (${feedIn - baseload} W < ${v.performance} W).`,
+                            minimumOffSatisfied
+                                ? `Not switched on: surplus too low (${feedIn - baseload} W < ${v.performance} W).`
+                                : `Not switched on: minimum off time (${v.minimumOffMinutes === undefined ? 5 : Number(v.minimumOffMinutes)} min) is active.`,
                         );
                     } else {
                         this.log.debug(`"${v.name}" is already switched on – no action needed.`);
@@ -703,8 +1084,12 @@ class ZeroFeedIn extends utils.Adapter {
                     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) {
+                    const currentTemp =
+                        tempState?.val !== undefined && tempState.val !== null ? Number(tempState.val) : null;
+                    if (
+                        (v.temperatureDatapoint && (currentTemp === null || !Number.isFinite(currentTemp))) ||
+                        (currentTemp !== null && currentTemp >= v.maxTemperature)
+                    ) {
                         this.log.warn(
                             `"${v.name}" switched off due to maxTemperature reached: ${currentTemp}°C >= ${v.maxTemperature}°C`,
                         );
@@ -715,7 +1100,14 @@ class ZeroFeedIn extends utils.Adapter {
 
                 // Timer-Abbruch bei wegfallender Bedingung (Ausschalten)
                 const surplus = feedIn - baseload;
-                if (v.timer && v.timerEnd && v.pendingAction === false && withinWindow && surplus >= v.switchOffPoint) {
+                if (
+                    v.timer &&
+                    v.timerEnd &&
+                    v.pendingAction === false &&
+                    withinWindow &&
+                    !gridUsage &&
+                    surplus >= v.switchOffPoint
+                ) {
                     clearTimeout(v.timer);
                     v.timer = null;
                     v.timerEnd = null;
@@ -731,8 +1123,42 @@ class ZeroFeedIn extends utils.Adapter {
                 // - Netzbezug aktiv ODER
                 // - Überschuss < switchOffPoint
                 const shouldSwitchOff = !withinWindow || gridUsage || surplus < v.switchOffPoint;
+                if (!shouldSwitchOff) {
+                    v.lastForecastBridgeAt = null;
+                }
 
                 if (!v.alwaysOffAtTime && shouldSwitchOff) {
+                    const maxGridImport = Math.max(
+                        0,
+                        this.config.forecastMaxGridImport === undefined
+                            ? 100
+                            : Number(this.config.forecastMaxGridImport),
+                    );
+                    const minimumOnMinutes = v.minimumOnMinutes === undefined ? 10 : Number(v.minimumOnMinutes);
+                    const hardGridImport = surplus < -maxGridImport;
+                    if (
+                        withinWindow &&
+                        !hardGridImport &&
+                        !minimumStateTimeSatisfied(v.lastStateChange, minimumOnMinutes)
+                    ) {
+                        this.log.debug(`"${v.name}" remains on: minimum run time (${minimumOnMinutes} min) is active.`);
+                        continue;
+                    }
+                    // 🔮 Forecast delay switch-off (PV forecast integration)
+                    if (this.isForecastDelayingSwitchOff(v, surplus)) {
+                        const forecastPower = this.getForecastPower(v);
+                        const minutes = this.getForecastMinutes(v);
+                        this.log.debug(
+                            `[Forecast] Switch-off delayed for "${v.name}": ${forecastPower} W in ${minutes} min.`,
+                        );
+                        await this.setForecastState(v, idx, true, 'forecastDelayOff', forecastPower, minutes);
+                        await this.sendForecastNotification(
+                            v.ruletype === 'percent' ? 'percent' : 'binary',
+                            `🔮 Forecast: "${v.name}" remains active (${forecastPower} W expected in ${minutes} min).`,
+                        );
+                        continue;
+                    }
+
                     if (v.timer && v.timerEnd && v.pendingAction === false) {
                         const remaining = Math.max(0, Math.round((v.timerEnd - Date.now()) / 1000));
                         this.log.debug(`Active timer for ${v.name}: ${remaining}s remaining`);
@@ -741,19 +1167,13 @@ class ZeroFeedIn extends utils.Adapter {
                             `Switching off: "${v.name}" - surplus ${surplus}W < switchOffPoint ${v.switchOffPoint}W, offDelay ${v.switchOffDelay || 0}s.`,
                         );
                         await this.switchConsumerWithDelay(v, false, v.switchOffDelay || 0);
+                        await this.setForecastState(v, idx, false, '', null, null);
                     }
                 }
             }
 
             // --- Batterie unverändert ---
-            const batteryConsumers = this.consumerList.filter(c => c.ruletype === 'battery');
-            for (const v of batteryConsumers) {
-                if (!v.enabled) {
-                    this.log.debug(`"${v.name}" is deactivated – battery control skipped.`);
-                    continue;
-                }
-                await this.controlBattery(v, feedIn);
-            }
+            this.scheduleRegulation();
 
             const runningTimers = this.consumerList
                 .filter(c => c.timer && c.timerEnd)
@@ -778,8 +1198,58 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ========================= controlPercentConsumer ====================
+    // =====================================================================
+    scheduleRegulation() {
+        if (!this.percentTimer && this.consumerList.some(v => v.ruletype === 'percent')) {
+            this.percentTimer = this.safeSetTimeout(
+                async () => {
+                    for (const v of this.consumerList.filter(v => v.ruletype === 'percent')) {
+                        await this.controlPercentConsumer(v);
+                    }
+                    this.percentTimer = null;
+                },
+                Math.max(0, Number(this.config.delaySecondsProzent) || 0) * 1000,
+            );
+        }
+
+        if (!this.batteryTimer && this.consumerList.some(v => v.ruletype === 'battery')) {
+            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;
+                },
+                Math.max(0, Number(this.config.batteryDelaySeconds) || 0) * 1000,
+            );
+        }
+    }
+
+    async isAutomaticConsumer(v) {
+        if (!v.enabled) {
+            return false;
+        }
+        const idx = this.consumerList.indexOf(v);
+        const mode = await this.getStateAsync(`${this.namespace}.consumer.${idx}_${this.name2id(v.name)}.controlMode`);
+        return mode?.val === 2;
+    }
+
     async controlPercentConsumer(v) {
         try {
+            if (!(await this.isAutomaticConsumer(v))) {
+                return;
+            }
             const withinWindow = this.timeWithinWindow(v.switchOnTime, v.switchOffTime);
             if (!withinWindow) {
                 this.log.debug(`[Percent] ${v.name} outside time window, set to 0%`);
@@ -796,25 +1266,32 @@ class ZeroFeedIn extends utils.Adapter {
 
             const feedInValue = Number(feedInState?.val) || 0;
 
-            let surplus = this.config.feedinNegativ
-                ? feedInValue < 0
-                    ? -feedInValue
-                    : 0
-                : feedInValue > 0
-                  ? feedInValue
-                  : 0;
+            let surplus = this.config.feedinNegativ ? -feedInValue : feedInValue;
 
             surplus -= this.config.baseload || 0;
+            const currentSurplus = surplus;
             if (surplus < 0) {
                 surplus = 0;
             }
 
             const maxPerformance = v.maxPerformance || v.performance || 1000;
-            let newPercent = Math.round((surplus / maxPerformance) * 100);
-            newPercent = Math.min(100, Math.max(newPercent, v.minPercentStart || 0));
-
             const state = await this.getForeignStateAsync(v.datapoint);
             const currentPercent = Number(state?.val) || 0;
+            const currentPower = (currentPercent / 100) * maxPerformance;
+            let newPercent = Math.min(
+                100,
+                Math.max(0, Math.round(((currentPower + currentSurplus) / maxPerformance) * 100)),
+            );
+            if (newPercent < (Number(v.minPercentStart) || 0)) {
+                newPercent = 0;
+            }
+            if (newPercent >= currentPercent) {
+                v.lastForecastBridgeAt = null;
+            }
+            if (newPercent < currentPercent && this.isForecastDelayingSwitchOff(v, currentSurplus, currentPower)) {
+                newPercent = currentPercent;
+                this.log.debug(`[Forecast] ${v.name}: holding ${currentPercent}% during a short forecast-backed dip`);
+            }
 
             if (newPercent !== currentPercent) {
                 await this.setForeignStateAsync(v.datapoint, newPercent);
@@ -840,8 +1317,14 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // =============================== controlBattery ======================
+    // =====================================================================
     async controlBattery(v, feedIn) {
         try {
+            if (!(await this.isAutomaticConsumer(v))) {
+                return;
+            }
             this.log.debug(`[Battery] Checking for ${v.name}`);
 
             const withinWindow = this.timeWithinWindow(v.switchOnTime, v.switchOffTime);
@@ -850,13 +1333,13 @@ class ZeroFeedIn extends utils.Adapter {
                 if (v.batterySetpoint) {
                     await this.setForeignStateAsync(v.batterySetpoint, {
                         val: 0,
-                        ack: true,
+                        ack: false,
                     });
                 }
                 if (this.batteryControlModeDatapoint) {
                     await this.setForeignStateAsync(this.batteryControlModeDatapoint, {
                         val: 0,
-                        ack: true,
+                        ack: false,
                     });
                 }
                 return;
@@ -867,7 +1350,7 @@ class ZeroFeedIn extends utils.Adapter {
                 if (this.batteryControlModeDatapoint) {
                     await this.setForeignStateAsync(this.batteryControlModeDatapoint, {
                         val: 0,
-                        ack: true,
+                        ack: false,
                     });
                 }
                 return;
@@ -875,34 +1358,60 @@ class ZeroFeedIn extends utils.Adapter {
 
             let soc = null;
             let targetSoc = null;
+            let invalidSoc = false;
             if (v.batterySOC && v.batteryTargetSOC) {
                 const socState = await this.getForeignStateAsync(v.batterySOC);
                 const targetSocState = await this.getForeignStateAsync(v.batteryTargetSOC);
                 soc = Number(socState?.val);
                 targetSoc = Number(targetSocState?.val);
-                if (isNaN(soc) || isNaN(targetSoc)) {
+                if (
+                    !socState ||
+                    socState.val === null ||
+                    !targetSocState ||
+                    targetSocState.val === null ||
+                    !Number.isFinite(soc) ||
+                    !Number.isFinite(targetSoc)
+                ) {
                     this.log.warn(`[Battery] ${v.name}: invalid SOC or targetSOC`);
                     soc = null;
                     targetSoc = null;
+                    invalidSoc = true;
                 }
             }
 
-            const surplus = (this.config.feedinNegativ ? -feedIn : feedIn) - (this.config.baseload || 0);
+            // Callers provide feed-in normalized to positive export.
+            const surplus = feedIn - (this.config.baseload || 0);
+            const oldPower = Number((await this.getForeignStateAsync(v.batterySetpoint))?.val) || 0;
             let powerToSet = 0;
             let modeToSet = 0;
 
-            if (surplus <= 0) {
+            const availablePower = Math.max(0, oldPower + surplus);
+            if (availablePower <= 0 || invalidSoc) {
                 powerToSet = 0;
                 modeToSet = 0;
             } else if (soc !== null && targetSoc !== null && soc >= targetSoc) {
                 powerToSet = 0;
                 modeToSet = 1;
             } else {
-                powerToSet = Math.min(surplus, v.performance || 1000);
+                powerToSet = Math.min(availablePower, v.performance || 1000);
                 modeToSet = 2;
             }
 
-            const oldPower = Number((await this.getForeignStateAsync(v.batterySetpoint))?.val) || 0;
+            if (powerToSet >= oldPower) {
+                v.lastForecastBridgeAt = null;
+            }
+
+            if (
+                powerToSet < oldPower &&
+                !invalidSoc &&
+                (soc === null || targetSoc === null || soc < targetSoc) &&
+                this.isForecastDelayingSwitchOff(v, surplus, oldPower)
+            ) {
+                powerToSet = Math.min(oldPower, v.performance || oldPower);
+                modeToSet = 2;
+                this.log.debug(`[Forecast] ${v.name}: holding ${powerToSet}W charging power during a short dip`);
+            }
+
             const oldMode = this.batteryControlModeDatapoint
                 ? Number((await this.getForeignStateAsync(this.batteryControlModeDatapoint))?.val) || 0
                 : -1;
@@ -910,7 +1419,7 @@ class ZeroFeedIn extends utils.Adapter {
             if (powerToSet !== oldPower) {
                 await this.setForeignStateAsync(v.batterySetpoint, {
                     val: powerToSet,
-                    ack: true,
+                    ack: false,
                 });
                 this.log.info(`Battery ${v.name}: charging power set to ${powerToSet}W`);
                 if (this.config.notifyBattery) {
@@ -927,7 +1436,7 @@ class ZeroFeedIn extends utils.Adapter {
             if (this.batteryControlModeDatapoint && modeToSet !== oldMode) {
                 await this.setForeignStateAsync(this.batteryControlModeDatapoint, {
                     val: modeToSet,
-                    ack: true,
+                    ack: false,
                 });
                 this.log.debug(`[Battery] ${v.name} mode changed from ${oldMode} to ${modeToSet}`);
                 if (this.config.notifyBattery) {
@@ -963,11 +1472,6 @@ class ZeroFeedIn extends utils.Adapter {
                 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,
-            });
         }
 
         if (consumer.numericDatapoint) {
@@ -976,13 +1480,12 @@ class ZeroFeedIn extends utils.Adapter {
                 val: numVal,
                 ack: false,
             });
-            await this.setForeignStateAsync(consumer.numericDatapoint, {
-                val: numVal,
-                ack: true,
-            });
             this.log.debug(`Numeric datapoint for "${consumer.name}" set to ${numVal}`);
         }
 
+        consumer.lastStateChange = Date.now();
+        consumer.lastForecastBridgeAt = null;
+
         const msg = `${consumer.name} wurde ${targetState ? 'eingeschaltet' : 'ausgeschaltet'}`;
 
         if (consumer.ruletype === 'heating') {
@@ -996,6 +1499,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ========================= switchConsumerWithDelay ===================
+    // =====================================================================
     async switchConsumerWithDelay(consumer, turnOn, delaySeconds) {
         const delay =
             delaySeconds !== undefined
@@ -1051,12 +1557,57 @@ class ZeroFeedIn extends utils.Adapter {
         };
 
         const doSwitch = async () => {
+            if (!consumer.enabled) {
+                consumer.timer = null;
+                consumer.timerEnd = null;
+                consumer.pendingAction = null;
+                await stopTimerTicker();
+                return;
+            }
+            if (delay > 0 && turnOn) {
+                const mode = await this.getStateAsync(`${this.namespace}.${channelId}.controlMode`);
+                if (mode?.val === 2) {
+                    const meter = this.feedInDatapoint ? await this.getForeignStateAsync(this.feedInDatapoint) : null;
+                    const rawPower = Number(meter?.val);
+                    const surplus = (this.config.feedinNegativ ? -rawPower : rawPower) - (this.config.baseload || 0);
+                    const withinWindow = this.timeWithinWindow(consumer.switchOnTime, consumer.switchOffTime);
+                    const required = Math.max(Number(consumer.performance) || 0, Number(consumer.switchOnPoint) || 0);
+                    if (
+                        !meter ||
+                        meter.val === null ||
+                        !Number.isFinite(surplus) ||
+                        !withinWindow ||
+                        (surplus < required && !this.isForecastAllowingSwitchOn(consumer, surplus))
+                    ) {
+                        consumer.timer = null;
+                        consumer.timerEnd = null;
+                        consumer.pendingAction = null;
+                        await stopTimerTicker();
+                        return;
+                    }
+                } else if (mode?.val !== 1) {
+                    consumer.timer = null;
+                    consumer.timerEnd = null;
+                    consumer.pendingAction = null;
+                    await stopTimerTicker();
+                    return;
+                }
+            }
             // nur bei heating: zusätzliche Sicherheitschecks
             if (consumer.ruletype === 'heating' && turnOn) {
                 const tempState = consumer.temperatureDatapoint
                     ? await this.getForeignStateAsync(consumer.temperatureDatapoint)
                     : null;
-                const currentTemp = tempState?.val !== undefined ? Number(tempState.val) : null;
+                const currentTemp =
+                    tempState?.val !== undefined && tempState.val !== null ? Number(tempState.val) : null;
+
+                if (consumer.temperatureDatapoint && (currentTemp === null || !Number.isFinite(currentTemp))) {
+                    consumer.timer = null;
+                    consumer.timerEnd = null;
+                    consumer.pendingAction = null;
+                    await stopTimerTicker();
+                    return;
+                }
 
                 if (
                     currentTemp !== null &&
@@ -1160,6 +1711,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ========================= sendNotification ==========================
+    // =====================================================================
     // Zentrale, einheitliche Notification-Funktion
     // Aufruf: await this.sendNotification('smartloadmanager', 'info'|'notify'|'alert', 'Nachricht');
     async sendNotification(scope, category, message) {
@@ -1286,6 +1840,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ========================= initializeConsumerStatus ==================
+    // =====================================================================
     async initializeConsumerStatus() {
         // Initiale Status-Updates
         for (const v of this.consumerList) {
@@ -1316,8 +1873,15 @@ class ZeroFeedIn extends utils.Adapter {
         return h * 60 + m;
     }
 
+    // =====================================================================
+    // =============================== onUnload ============================
+    // =====================================================================
     async onUnload(callback) {
         try {
+            if (this.ruleTimer) {
+                clearInterval(this.ruleTimer);
+                this.ruleTimer = null;
+            }
             if (this.percentTimer) {
                 clearTimeout(this.percentTimer);
             }
@@ -1325,6 +1889,10 @@ class ZeroFeedIn extends utils.Adapter {
                 clearTimeout(this.batteryTimer);
             }
             for (const v of this.consumerList) {
+                if (v.timerTick) {
+                    clearInterval(v.timerTick);
+                    v.timerTick = null;
+                }
                 if (v.timer) {
                     clearTimeout(v.timer);
                     v.timer = null;