iobroker.smartloadmanager 0.0.8 → 0.1.2

package/main.js

@@ -18,10 +18,21 @@ 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,
+        };
+
         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 +42,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 +60,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,21 +78,40 @@ 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;
+
             this.consumerList = Array.isArray(this.config.consumer)
                 ? this.config.consumer.filter(
                       v =>
-                          v &&
-                          v.enabled &&
-                          (v.ruletype === 'battery' || ((v.datapoint || v.numericDatapoint) && v.performance > 0)),
+                          v && (v.ruletype === 'battery' || ((v.datapoint || v.numericDatapoint) && v.performance > 0)),
                   )
                 : [];
 
             this.consumerList.forEach(v => (v.processingLockSwitch = false));
 
+            for (let i = 0; i < this.consumerList.length; i++) {
+                const v = this.consumerList[i];
+                const safeName = this.name2id(v.name);
+                const id = `${this.namespace}.consumer.${i}_${safeName}.active`;
+                const state = await this.getStateAsync(id);
+                if (state && state.val !== null) {
+                    v.enabled = state.val;
+                    this.log.debug(`"${v.name}": Active status taken from object tree (${state.val})`);
+                }
+            }
+
             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);
@@ -85,6 +119,12 @@ 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();
         } catch (error) {
             this.log.error(`Error in onReady: ${error.message}`);
@@ -93,6 +133,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ===================== Consumer object checks ========================
+    // =====================================================================
     async checkAndCreateConsumerObjects() {
         for (const v of this.consumerList) {
             if (v.datapoint) {
@@ -110,6 +153,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ========================= createConsumerStates ======================
+    // =====================================================================
     async createConsumerStates() {
         // Übergeordnetes Device erstellen - löst "intermediate objects missing" Problem
         await this.setObjectNotExistsAsync('consumer', {
@@ -227,6 +273,61 @@ class ZeroFeedIn extends utils.Adapter {
                 native: {},
             });
 
+            // === NEUER STATE: Aktiv-Status ============================
+            await this.setObjectNotExistsAsync(`${channelId}.active`, {
+                type: 'state',
+                common: {
+                    name: `${v.name} aktiv`,
+                    type: 'boolean',
+                    role: 'switch',
+                    read: true,
+                    write: true,
+                    def: v.enabled || false,
+                },
+                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',
@@ -303,11 +404,228 @@ class ZeroFeedIn extends utils.Adapter {
             await this.setStateAsync(`${this.namespace}.${channelId}.onTimerRemaining`, { val: 0, ack: true });
             await this.setStateAsync(`${this.namespace}.${channelId}.offTimerRemaining`, { val: 0, ack: true });
 
+            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;
+            }
+
+            let data;
+            try {
+                data = typeof state.val === 'string' ? JSON.parse(state.val) : state.val;
+            } catch {
+                this.log.warn('[Forecast] Invalid JSON in pvforecast datapoint');
+                return;
+            }
+
+            if (!Array.isArray(data) || data.length === 0) {
+                return;
+            }
+
+            const now = Date.now();
+            let best = null;
+
+            for (const entry of data) {
+                if (!entry || typeof entry.t !== 'number' || typeof entry.y !== 'number') {
+                    continue;
+                }
+                if (entry.t < now) {
+                    continue;
+                }
+                best = entry;
+                break;
+            }
+
+            if (!best) {
+                return;
+            }
+
+            // pvforecast liefert kW → wir rechnen auf W
+            const power = Math.round(best.y * 1000);
+            const minutes = Math.max(0, Math.round((best.t - now) / 60000));
+            const surplus = power - (this.config.baseload || 0);
+
+            this.forecast.power = power;
+            this.forecast.surplus = surplus > 0 ? surplus : 0;
+            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] JSON parsed → power=${power}W, surplus=${this.forecast.surplus}W, minutes=${minutes}`,
+            );
+        } catch (error) {
+            this.log.error(`[Forecast] Error processing pvforecast JSON: ${error.message}`);
+        }
+    }
+
+    // =====================================================================
+    // ========================= Forecast helpers ==========================
+    // =====================================================================
+    getForecastPower(_v) {
+        return this.forecast?.power || 0;
+    }
+
+    getForecastMinutes(_v) {
+        return this.forecast?.minutes || 0;
+    }
+
+    isForecastAllowingSwitchOn(v) {
+        if (!this.forecastEnabled || !v.useForecast) {
+            return false;
+        }
+        const minMinutes = v.forecastMinMinutes || 0;
+        if (this.forecast.minutes > minMinutes) {
+            return false;
+        }
+        if (this.forecast.surplus >= v.performance) {
+            return true;
+        }
+        return false;
+    }
+
+    isForecastDelayingSwitchOff(v, _currentSurplus) {
+        if (!this.forecastEnabled || !v.useForecast) {
+            return false;
+        }
+        const minMinutes = v.forecastMinMinutes || 0;
+        if (this.forecast.minutes > minMinutes) {
+            return false;
+        }
+        if (this.forecast.surplus >= v.switchOnPoint) {
+            return true;
+        }
+        return false;
+    }
+
+    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;
@@ -331,11 +649,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
@@ -387,6 +717,19 @@ class ZeroFeedIn extends utils.Adapter {
         if (state && !state.ack) {
             this.log.debug(`State changed: ${id} => ${state.val}`);
 
+            // --- Aktiv-Status manuell umschalten ---------------------------------
+            if (id.match(/consumer\.(\d+)_.*?\.active/)) {
+                const match = id.match(/consumer\.(\d+)_.*?\.active/);
+                const index = parseInt(match[1]);
+                const v = this.consumerList[index];
+                if (v) {
+                    v.enabled = state.val;
+                    this.log.info(`Consumer "${v.name}" became ${state.val ? 'activated' : 'deactivated'}.`);
+                    await this.setStateAsync(id, { val: state.val, ack: true });
+                }
+                return;
+            }
+
             // ControlMode Änderungen
             const match = id.match(/consumer\.(\d+)_.*?\.controlMode/);
             if (match) {
@@ -412,6 +755,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ============================ checkConsumers =========================
+    // =====================================================================
     async checkConsumers() {
         if (this.checkRunning) {
             this.checkQueued = true;
@@ -423,11 +769,7 @@ class ZeroFeedIn extends utils.Adapter {
         try {
             if (!this.feedInDatapoint) {
                 this.log.warn('No FeedIn datapoint set – skipping checkConsumers()');
-                await this.sendNotification(
-                    'smartloadmanager',
-                    'alert',
-                    '❗ Kein FeedIn-Datenpunkt gesetzt – Regelung übersprungen.',
-                );
+                await this.sendNotification('smartloadmanager', 'alert', '❗ No FeedIn data point set – rule skipped.');
                 this.checkRunning = false;
                 if (this.checkQueued) {
                     await this.checkConsumers();
@@ -456,6 +798,11 @@ class ZeroFeedIn extends utils.Adapter {
             this.log.debug(`Switch-on check for ${sortedOn.length} binary/heating-consumers.`);
 
             for (const v of sortedOn) {
+                // Überspringe deaktivierte Verbraucher
+                if (!v.enabled) {
+                    this.log.debug(`"${v.name}" is deactivated – skipped (power-on check).`);
+                    continue;
+                }
                 const idx = this.consumerList.indexOf(v);
                 const safeName = this.name2id(v.name);
                 const id = `${this.namespace}.consumer.${idx}_${safeName}`;
@@ -510,7 +857,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 – Hardware release missing.`);
+                            this.log.debug(`"${v.name}" NOT switched on – Hardware release missing.`);
                             continue;
                         }
                     }
@@ -551,6 +898,20 @@ 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)) {
+                        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) {
@@ -577,6 +938,11 @@ class ZeroFeedIn extends utils.Adapter {
                 const safeName = this.name2id(v.name);
                 const id = `${this.namespace}.consumer.${idx}_${safeName}`;
                 const mode = await this.getStateAsync(`${id}.controlMode`);
+                // Überspringe deaktivierte Verbraucher
+                if (!v.enabled) {
+                    this.log.debug(`"${v.name}" is deactivated – will be skipped (power-off check).`);
+                    continue;
+                }
                 if (!mode || mode.val !== 2) {
                     continue;
                 }
@@ -689,6 +1055,21 @@ class ZeroFeedIn extends utils.Adapter {
                 const shouldSwitchOff = !withinWindow || gridUsage || surplus < v.switchOffPoint;
 
                 if (!v.alwaysOffAtTime && shouldSwitchOff) {
+                    // 🔮 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`);
@@ -697,6 +1078,7 @@ 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);
                     }
                 }
             }
@@ -704,6 +1086,10 @@ class ZeroFeedIn extends utils.Adapter {
             // --- 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);
             }
 
@@ -730,6 +1116,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ========================= controlPercentConsumer ====================
+    // =====================================================================
     async controlPercentConsumer(v) {
         try {
             const withinWindow = this.timeWithinWindow(v.switchOnTime, v.switchOffTime);
@@ -792,6 +1181,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // =============================== controlBattery ======================
+    // =====================================================================
     async controlBattery(v, feedIn) {
         try {
             this.log.debug(`[Battery] Checking for ${v.name}`);
@@ -948,6 +1340,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ========================= switchConsumerWithDelay ===================
+    // =====================================================================
     async switchConsumerWithDelay(consumer, turnOn, delaySeconds) {
         const delay =
             delaySeconds !== undefined
@@ -1112,6 +1507,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) {
@@ -1238,6 +1636,9 @@ class ZeroFeedIn extends utils.Adapter {
         }
     }
 
+    // =====================================================================
+    // ========================= initializeConsumerStatus ==================
+    // =====================================================================
     async initializeConsumerStatus() {
         // Initiale Status-Updates
         for (const v of this.consumerList) {
@@ -1268,6 +1669,9 @@ class ZeroFeedIn extends utils.Adapter {
         return h * 60 + m;
     }
 
+    // =====================================================================
+    // =============================== onUnload ============================
+    // =====================================================================
     async onUnload(callback) {
         try {
             if (this.percentTimer) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.smartloadmanager",
-  "version": "0.0.8",
+  "version": "0.1.2",
   "description": "This adapter allows devices to be controlled via PV surplus and thus achieve zero feed-in.",
   "author": {
     "name": "quorle",
@@ -28,16 +28,16 @@
     "translate": "^3.0.1"
   },
   "devDependencies": {
-    "@alcalzone/release-script": "^3.8.0",
-    "@alcalzone/release-script-plugin-iobroker": "^3.7.2",
-    "@alcalzone/release-script-plugin-license": "^3.7.0",
-    "@alcalzone/release-script-plugin-manual-review": "^3.7.0",
-    "@iobroker/adapter-dev": "^1.4.0",
-    "@iobroker/eslint-config": "^2.1.0",
-    "@iobroker/testing": "^5.1.1",
-    "@tsconfig/node20": "^20.1.6",
-    "@types/node": "^24.3.1",
-    "typescript": "~5.0.4"
+    "@alcalzone/release-script": "^5.1.1",
+    "@alcalzone/release-script-plugin-iobroker": "^5.1.2",
+    "@alcalzone/release-script-plugin-license": "^5.1.1",
+    "@alcalzone/release-script-plugin-manual-review": "^5.1.1",
+    "@iobroker/adapter-dev": "^1.5.0",
+    "@iobroker/eslint-config": "^2.2.0",
+    "@iobroker/testing": "^5.2.2",
+    "@tsconfig/node20": "^20.1.9",
+    "@types/node": "^25.6.0",
+    "typescript": "~6.0.2"
   },
   "main": "main.js",
   "files": [