iobroker.nexowatt-ui 0.7.0 → 0.7.2

package/ems/modules/heating-rod-control.js

@@ -96,6 +96,8 @@ class HeatingRodControlModule extends BaseModule {
         this._stateCache = new Map();
         /** @type {Map<string, {targetStage:number,lastIncreaseMs:number,lastDecreaseMs:number}>} */
         this._stageCtl = new Map();
+        /** @type {{importSinceMs:number, dischargeSinceMs:number}} */
+        this._budgetProtect = { importSinceMs: 0, dischargeSinceMs: 0 };
     }
 
     _isEnabled() {
@@ -362,6 +364,15 @@ class HeatingRodControlModule extends BaseModule {
         await mk('heatingRod.summary.pvAvailableW', 'PV available after thermal (W)', 'number', 'value.power', 'W');
         await mk('heatingRod.summary.appliedTotalW', 'Applied total (W)', 'number', 'value.power', 'W');
         await mk('heatingRod.summary.budgetUsedW', 'Budget used (W)', 'number', 'value.power', 'W');
+        await mk('heatingRod.summary.budgetGateTotalW', 'Budget gate total (W)', 'number', 'value.power', 'W');
+        await mk('heatingRod.summary.budgetGateRemainingW', 'Budget gate remaining after EVCS (W)', 'number', 'value.power', 'W');
+        await mk('heatingRod.summary.budgetGatePvW', 'Budget gate PV for heating rod (W)', 'number', 'value.power', 'W');
+        await mk('heatingRod.summary.budgetGateEffectiveW', 'Budget gate effective for heating rod (W)', 'number', 'value.power', 'W');
+        await mk('heatingRod.summary.budgetGateSource', 'Budget gate source', 'string', 'text');
+        await mk('heatingRod.summary.gridImportW', 'Grid import used for heating rod gate (W)', 'number', 'value.power', 'W');
+        await mk('heatingRod.summary.gridImportLimitW', 'Allowed grid import in PV auto (W)', 'number', 'value.power', 'W');
+        await mk('heatingRod.summary.gridImportExceeded', 'Grid import above heating rod limit', 'boolean', 'indicator');
+        await mk('heatingRod.summary.storageDischargeExceeded', 'Storage discharge above heating rod limit', 'boolean', 'indicator');
         await mk('heatingRod.summary.debugJson', 'Debug JSON', 'string', 'json');
         await mk('heatingRod.summary.zeroExportActive', 'Zero/minus feed-in logic active', 'boolean', 'indicator');
         await mk('heatingRod.summary.zeroExportCanProbe', 'Zero/minus feed-in probe allowed', 'boolean', 'indicator');
@@ -380,9 +391,18 @@ class HeatingRodControlModule extends BaseModule {
         try {
             const ns = String(this.adapter.namespace || '').trim();
             if (ns && this.dp) {
+                await this.dp.upsert({ key: 'hr.cm.active', objectId: `${ns}.chargingManagement.control.active`, dataType: 'boolean', direction: 'in' });
+                await this.dp.upsert({ key: 'hr.cm.budgetW', objectId: `${ns}.chargingManagement.control.budgetW`, dataType: 'number', direction: 'in', unit: 'W' });
+                await this.dp.upsert({ key: 'hr.cm.remainingW', objectId: `${ns}.chargingManagement.control.remainingW`, dataType: 'number', direction: 'in', unit: 'W' });
+                await this.dp.upsert({ key: 'hr.cm.pvCapRawW', objectId: `${ns}.chargingManagement.control.pvCapRawW`, dataType: 'number', direction: 'in', unit: 'W' });
                 await this.dp.upsert({ key: 'hr.cm.pvCapW', objectId: `${ns}.chargingManagement.control.pvCapEffectiveW`, dataType: 'number', direction: 'in', unit: 'W' });
+                await this.dp.upsert({ key: 'hr.cm.pvAvailable', objectId: `${ns}.chargingManagement.control.pvAvailable`, dataType: 'boolean', direction: 'in' });
                 await this.dp.upsert({ key: 'hr.cm.usedW', objectId: `${ns}.chargingManagement.control.usedW`, dataType: 'number', direction: 'in', unit: 'W' });
                 await this.dp.upsert({ key: 'hr.cm.pvSurplusNoEvRawW', objectId: `${ns}.chargingManagement.control.pvSurplusNoEvRawW`, dataType: 'number', direction: 'in', unit: 'W' });
+                await this.dp.upsert({ key: 'hr.cm.pvSurplusNoEvAvg5mW', objectId: `${ns}.chargingManagement.control.pvSurplusNoEvAvg5mW`, dataType: 'number', direction: 'in', unit: 'W' });
+                await this.dp.upsert({ key: 'hr.cm.gridW', objectId: `${ns}.chargingManagement.control.gridImportW`, dataType: 'number', direction: 'in', unit: 'W' });
+                await this.dp.upsert({ key: 'hr.cm.staleMeter', objectId: `${ns}.chargingManagement.control.staleMeter`, dataType: 'boolean', direction: 'in' });
+                await this.dp.upsert({ key: 'hr.cm.staleBudget', objectId: `${ns}.chargingManagement.control.staleBudget`, dataType: 'boolean', direction: 'in' });
                 for (let i = 1; i <= 10; i++) {
                     await this.dp.upsert({ key: `hr.user.c${i}.regEnabled`, objectId: `${ns}.heatingRod.user.c${i}.regEnabled`, dataType: 'boolean', direction: 'in' });
                     await this.dp.upsert({ key: `hr.user.c${i}.mode`, objectId: `${ns}.heatingRod.user.c${i}.mode`, dataType: 'string', direction: 'in' });
@@ -490,6 +510,58 @@ class HeatingRodControlModule extends BaseModule {
         return fallback;
     }
 
+    _readBooleanAny(keys, staleMs, fallback = null) {
+        const list = Array.isArray(keys) ? keys : [keys];
+        for (const key of list) {
+            if (!key) continue;
+            try {
+                if (this.dp && this.dp.getEntry && this.dp.getEntry(key)) {
+                    if (typeof this.dp.isStale === 'function' && this.dp.isStale(key, staleMs)) continue;
+                    const v = this.dp.getBoolean ? this.dp.getBoolean(key, null) : null;
+                    if (v !== null && v !== undefined) return !!v;
+                }
+            } catch (_e) {
+                // ignore
+            }
+            const raw = this._readCacheRaw(key, null);
+            if (raw === null || raw === undefined) continue;
+            if (typeof raw === 'boolean') return raw;
+            if (typeof raw === 'number') return raw !== 0;
+            if (typeof raw === 'string') {
+                const t = raw.trim().toLowerCase();
+                if (['true', '1', 'on', 'yes', 'active', 'enabled'].includes(t)) return true;
+                if (['false', '0', 'off', 'no', 'inactive', 'disabled'].includes(t)) return false;
+            }
+        }
+        return fallback;
+    }
+
+    _getBudgetGateCfg() {
+        const cfg = this._getCfg();
+        const zero = (cfg.zeroExport && typeof cfg.zeroExport === 'object') ? cfg.zeroExport : {};
+        const pickNum = (keys, def, minV = 0, maxV = 1e12) => {
+            const list = Array.isArray(keys) ? keys : [keys];
+            for (const key of list) {
+                const raw = (cfg[key] !== undefined && cfg[key] !== null && cfg[key] !== '') ? cfg[key] : zero[key];
+                if (raw === null || raw === undefined || raw === '') continue;
+                const n = Number(raw);
+                if (Number.isFinite(n)) return Math.round(clamp(n, minV, maxV));
+            }
+            return Math.round(clamp(def, minV, maxV));
+        };
+
+        return {
+            useBudgetGates: true,
+            maxGridImportW: pickNum(['maxGridImportW', 'gridImportToleranceW', 'pvMaxGridImportW', 'pvImportToleranceW', 'gridImportTripW'], 250, 0, 1000000),
+            gridImportHoldSec: pickNum(['gridImportHoldSec', 'gridImportTripSec', 'pvGridImportHoldSec'], 15, 0, 3600),
+            hardGridImportW: pickNum(['hardGridImportW', 'pvHardGridImportW'], 3000, 0, 1000000),
+            storageDischargeToleranceW: pickNum(['storageDischargeToleranceW', 'pvStorageDischargeToleranceW'], 300, 0, 1000000),
+            storageDischargeHoldSec: pickNum(['storageDischargeHoldSec', 'storageDischargeTripSec', 'pvStorageDischargeHoldSec'], 15, 0, 3600),
+            hardStorageDischargeW: pickNum(['hardStorageDischargeW', 'pvHardStorageDischargeW'], 1200, 0, 1000000),
+            budgetSafetyReserveW: pickNum(['budgetSafetyReserveW', 'pvSafetyReserveW'], 150, 0, 1000000),
+        };
+    }
+
     _readStorageSnapshot(staleMs) {
         let chargeW = Math.max(0, num(this._readNumberAny([
             'storageFarm.totalChargePowerW',
@@ -522,19 +594,38 @@ class HeatingRodControlModule extends BaseModule {
 
     _computeBasePvAvailableW(currentHeatingRodW = 0) {
         const cfg = this._getCfg();
+        const gateCfg = this._getBudgetGateCfg();
         const staleTimeoutSec = clamp(num(cfg.staleTimeoutSec, 15), 1, 3600);
         const staleMs = Math.max(1, Math.round(staleTimeoutSec * 1000));
+        const finite = (v) => (typeof v === 'number' && Number.isFinite(v));
+
+        const cmActive = this._readBooleanAny(['hr.cm.active', 'chargingManagement.control.active'], staleMs, null);
+        const cmStaleMeter = this._readBooleanAny(['hr.cm.staleMeter', 'chargingManagement.control.staleMeter'], staleMs, false);
+        const cmStaleBudget = this._readBooleanAny(['hr.cm.staleBudget', 'chargingManagement.control.staleBudget'], staleMs, false);
+
+        const cmBudgetWRaw = this._readNumberAny(['hr.cm.budgetW', 'chargingManagement.control.budgetW'], staleMs, null);
+        const cmRemainingWRaw = this._readNumberAny(['hr.cm.remainingW', 'chargingManagement.control.remainingW'], staleMs, null);
+        const cmUsedWRaw = this._readNumberAny(['hr.cm.usedW', 'chargingManagement.control.usedW'], staleMs, null);
+        const cmPvCapEffectiveRaw = this._readNumberAny(['hr.cm.pvCapW', 'chargingManagement.control.pvCapEffectiveW'], staleMs, null);
+        const cmPvCapRawRaw = this._readNumberAny(['hr.cm.pvCapRawW', 'chargingManagement.control.pvCapRawW'], staleMs, null);
+        const cmPvNoEvRaw = this._readNumberAny(['hr.cm.pvSurplusNoEvRawW', 'chargingManagement.control.pvSurplusNoEvRawW'], staleMs, null);
+        const cmPvNoEvAvg = this._readNumberAny(['hr.cm.pvSurplusNoEvAvg5mW', 'chargingManagement.control.pvSurplusNoEvAvg5mW'], staleMs, null);
+        const cmPvAvailable = this._readBooleanAny(['hr.cm.pvAvailable', 'chargingManagement.control.pvAvailable'], staleMs, null);
+
+        const pvCapW = finite(cmPvCapEffectiveRaw) ? Math.max(0, cmPvCapEffectiveRaw) : 0;
+        const evcsUsedW = finite(cmUsedWRaw) ? Math.max(0, cmUsedWRaw) : 0;
+        const currentW = Math.max(0, num(currentHeatingRodW, 0));
 
-        const pvCapWRaw = this._readNumberAny(['hr.cm.pvCapW', 'chargingManagement.control.pvCapEffectiveW'], staleMs, null);
-        const usedWRaw = this._readNumberAny(['hr.cm.usedW', 'chargingManagement.control.usedW'], staleMs, null);
-        const pvCapW = (typeof pvCapWRaw === 'number' && Number.isFinite(pvCapWRaw)) ? Math.max(0, pvCapWRaw) : 0;
-        const evcsUsedW = (typeof usedWRaw === 'number' && Number.isFinite(usedWRaw)) ? Math.max(0, usedWRaw) : 0;
-
-        const gridW = this._readNumberAny(['grid.powerRawW', 'grid.powerW', 'ps.gridPowerW'], staleMs, null);
-        const gridKnown = (typeof gridW === 'number' && Number.isFinite(gridW));
+        const gridW = this._readNumberAny([
+            'hr.cm.gridW',
+            'chargingManagement.control.gridImportW',
+            'grid.powerRawW',
+            'grid.powerW',
+            'ps.gridPowerW'
+        ], staleMs, null);
+        const gridKnown = finite(gridW);
         const exportW = gridKnown ? Math.max(0, -gridW) : 0;
         const importW = gridKnown ? Math.max(0, gridW) : 0;
-        const currentW = Math.max(0, num(currentHeatingRodW, 0));
         const storage = this._readStorageSnapshot(staleMs);
 
         const storageTargetSocPct = clamp(num(cfg.storageTargetSocPct, 90), 0, 100);
@@ -547,63 +638,168 @@ class HeatingRodControlModule extends BaseModule {
             ? storageReserveCfgW
             : 0;
 
-        // NVP-Bilanz vor flexiblen Heizstäben:
-        //   Export/Import am Netzpunkt + bereits laufende Heizstableistung + Speicherladung - Speicherentladung.
-        // Wichtig: Netzbezug muss abgezogen werden. Sonst hält eine bereits laufende Heizstableistung
-        // nachts ihren eigenen vermeintlichen PV-Überschuss künstlich am Leben.
-        // Ohne frischen Netzpunktwert darf die aktuelle Heizstableistung NICHT als Überschuss-Fallback
-        // verwendet werden; sonst schaltet ein laufender Heizstab bei Dunkelheit nie sauber aus.
+        // Gate A/T/§14a/Peak: consume the remaining central budget after EVCS.
+        // This is intentionally read-only: Heizstab does not change the load management budget engine.
+        let totalGateRemainingW = Number.POSITIVE_INFINITY;
+        let totalGateBudgetW = Number.POSITIVE_INFINITY;
+        let totalGateSource = 'unlimited';
+        const cmLooksActive = cmActive === true
+            || evcsUsedW > 0
+            || (finite(cmBudgetWRaw) && cmBudgetWRaw > 0)
+            || (finite(cmRemainingWRaw) && cmRemainingWRaw > 0);
+        if (gateCfg.useBudgetGates && cmLooksActive && !cmStaleBudget && finite(cmRemainingWRaw)) {
+            totalGateRemainingW = Math.max(0, cmRemainingWRaw);
+            totalGateBudgetW = finite(cmBudgetWRaw) ? Math.max(0, cmBudgetWRaw) : totalGateRemainingW + evcsUsedW;
+            totalGateSource = 'chargingManagement.remainingW';
+        } else {
+            try {
+                const caps = (this.adapter && this.adapter._emsCaps && typeof this.adapter._emsCaps === 'object') ? this.adapter._emsCaps : null;
+                const cap = caps && caps.evcsHighLevel ? num(caps.evcsHighLevel.capW, null) : null;
+                if (gateCfg.useBudgetGates && typeof cap === 'number' && Number.isFinite(cap) && cap > 0) {
+                    totalGateBudgetW = Math.max(0, cap);
+                    totalGateRemainingW = Math.max(0, cap - evcsUsedW);
+                    totalGateSource = `ems.core.${String(caps.evcsHighLevel.binding || 'highLevel')}`;
+                }
+            } catch (_e) {
+                // ignore core fallback
+            }
+        }
+
+        // Gate B: prefer the same PV surplus gate that EVCS uses when it is active.
+        // It is reconstructed without EVCS; therefore add the current Heizstab load back in,
+        // otherwise an already running stage would collapse its own PV budget at 0 export.
+        let cmPvGateW = null;
+        let cmPvGateSource = '';
+        if (!cmStaleMeter) {
+            const candidates = [];
+            if (finite(cmPvCapEffectiveRaw) && cmPvCapEffectiveRaw > 0) candidates.push({ k: 'cm.pvCapEffectiveW', w: cmPvCapEffectiveRaw });
+            if (finite(cmPvCapRawRaw) && cmPvCapRawRaw > 0) candidates.push({ k: 'cm.pvCapRawW', w: cmPvCapRawRaw });
+            if (finite(cmPvNoEvRaw) && cmPvNoEvRaw > 0) candidates.push({ k: 'cm.pvSurplusNoEvRawW', w: cmPvNoEvRaw });
+            if (finite(cmPvNoEvAvg) && cmPvNoEvAvg > 0) candidates.push({ k: 'cm.pvSurplusNoEvAvg5mW', w: cmPvNoEvAvg });
+            if (candidates.length) {
+                const best = candidates.reduce((a, b) => (b.w > a.w ? b : a), candidates[0]);
+                cmPvGateW = Math.max(0, best.w - evcsUsedW + currentW - storageReserveW - gateCfg.budgetSafetyReserveW);
+                cmPvGateSource = best.k;
+            } else if (cmPvAvailable === false && finite(cmPvCapEffectiveRaw)) {
+                cmPvGateW = Math.max(0, currentW - storageReserveW - gateCfg.budgetSafetyReserveW);
+                cmPvGateSource = 'cm.pvAvailable.false_hold_only';
+            }
+        }
+
+        // Fallback/second truth: NVP balance without Heizstab as flexible load.
+        // import above the configured tolerance consumes the budget; small import remains allowed
+        // to keep the stages running calmly like PV-only EV charging.
+        const importExcessW = gridKnown ? Math.max(0, importW - gateCfg.maxGridImportW) : 0;
         const nvpSurplusBeforeFlexW = gridKnown
-            ? Math.max(0, exportW - importW + currentW + storage.chargeW - storage.dischargeW)
+            ? Math.max(0, exportW + currentW + storage.chargeW - storage.dischargeW - importExcessW)
             : 0;
-        const nvpAvailableW = Math.max(0, nvpSurplusBeforeFlexW - storageReserveW);
-
-        const cmAvailableW = (pvCapW > 0) ? Math.max(0, pvCapW - evcsUsedW - storageReserveW) : 0;
-        // Wenn ein frischer Netzpunktwert vorhanden ist, ist er für Heizstäbe die härtere Wahrheit.
-        // Ohne Netzpunktwert wird ausschließlich das Charging-Management-Cap genutzt; wenn auch das
-        // fehlt, ist die sichere Vorgabe 0 W verfügbar.
-        const availableW = gridKnown ? nvpAvailableW : cmAvailableW;
-        const source = gridKnown ? 'nvp-storage-reserve' : (pvCapW > 0 ? 'cm-storage-reserve' : 'no-fresh-nvp');
-
-        // PV-Auto darf keine Netz- oder Speicherenergie nachziehen.
-        // Bei echtem Netzbezug oder Speicherentladung muss die Regelung zurücknehmen und darf
-        // nicht neu einschalten. Kleine Toleranzen verhindern Flattern durch Messrauschen um 0 W.
-        const importToleranceW = Math.max(0, Math.round(num(cfg.gridImportToleranceW ?? cfg.pvImportToleranceW ?? 50)));
-        const dischargeToleranceW = Math.max(0, Math.round(num(cfg.storageDischargeToleranceW ?? cfg.pvStorageDischargeToleranceW ?? 100)));
-        const gridImportActive = !!(gridKnown && importW > importToleranceW);
-        const storageDischargeActive = !!(storage.dischargeW > dischargeToleranceW);
+        const nvpAvailableW = Math.max(0, nvpSurplusBeforeFlexW - storageReserveW - gateCfg.budgetSafetyReserveW);
+
+        let pvBudgetGateW = nvpAvailableW;
+        let pvBudgetSource = gridKnown ? 'nvp+ownLoad+storageReserve' : 'no-fresh-nvp';
+        if (cmPvGateW !== null && Number.isFinite(cmPvGateW) && cmPvGateW > pvBudgetGateW) {
+            pvBudgetGateW = cmPvGateW;
+            pvBudgetSource = cmPvGateSource || 'cm.pvGate';
+        }
+
+        const effectiveGateW = Math.max(0, Math.min(
+            pvBudgetGateW,
+            Number.isFinite(totalGateRemainingW) ? totalGateRemainingW : Number.POSITIVE_INFINITY
+        ));
+
+        const source = `${pvBudgetSource}|${totalGateSource}`;
+        const gridImportActive = !!(gridKnown && importW > gateCfg.maxGridImportW);
+        const storageDischargeActive = !!(storage.dischargeW > gateCfg.storageDischargeToleranceW);
         const nonPvEnergyActive = !!(gridImportActive || storageDischargeActive);
-        const forceOff = availableW <= 50 && (storageDischargeActive || (gridImportActive && currentW > 0) || (!gridKnown && currentW > 0 && pvCapW <= 0));
+        const forceOff = effectiveGateW <= 50 && currentW > 0 && (importW > gateCfg.hardGridImportW || storage.dischargeW > gateCfg.hardStorageDischargeW);
 
         return {
-            pvCapW: Math.max(pvCapW, nvpSurplusBeforeFlexW),
+            pvCapW: Math.max(pvBudgetGateW, pvCapW, nvpSurplusBeforeFlexW),
             evcsUsedW,
-            availableW,
+            availableW: effectiveGateW,
             source,
+            gateCfg,
+            useBudgetGates: !!gateCfg.useBudgetGates,
+            budgetGateTotalW: Number.isFinite(totalGateBudgetW) ? Math.max(0, totalGateBudgetW) : null,
+            budgetGateRemainingW: Number.isFinite(totalGateRemainingW) ? Math.max(0, totalGateRemainingW) : null,
+            budgetGatePvW: Math.max(0, pvBudgetGateW),
+            budgetGateEffectiveW: Math.max(0, effectiveGateW),
+            budgetGateSource: source,
+            cmActive,
+            cmStaleMeter: !!cmStaleMeter,
+            cmStaleBudget: !!cmStaleBudget,
+            cmPvAvailable,
+            cmPvCapEffectiveW: pvCapW,
+            cmPvCapRawW: finite(cmPvCapRawRaw) ? Math.max(0, cmPvCapRawRaw) : 0,
+            cmPvSurplusNoEvRawW: finite(cmPvNoEvRaw) ? Math.max(0, cmPvNoEvRaw) : 0,
             gridKnown,
             gridW: gridKnown ? gridW : null,
             importW,
-            importToleranceW,
+            importToleranceW: gateCfg.maxGridImportW,
             gridImportActive,
             exportW,
             currentHeatingRodW: currentW,
             storageChargeW: storage.chargeW,
             storageDischargeW: storage.dischargeW,
-            dischargeToleranceW,
+            dischargeToleranceW: gateCfg.storageDischargeToleranceW,
             storageDischargeActive,
             nonPvEnergyActive,
             storageSocPct: storage.socPct,
             storageReserveW,
             storageTargetSocPct,
             nvpSurplusBeforeFlexW,
-            cmAvailableW,
+            cmAvailableW: (cmPvGateW !== null && Number.isFinite(cmPvGateW)) ? Math.max(0, cmPvGateW) : 0,
             nvpAvailableW,
             forceOff,
         };
     }
 
+    _updateBudgetGateProtection(pvBase, now) {
+        const cfg = (pvBase && pvBase.gateCfg) ? pvBase.gateCfg : this._getBudgetGateCfg();
+        const st = this._budgetProtect || { importSinceMs: 0, dischargeSinceMs: 0 };
+        const importActive = !!(pvBase && pvBase.gridKnown && num(pvBase.importW, 0) > cfg.maxGridImportW);
+        const dischargeActive = !!(pvBase && num(pvBase.storageDischargeW, 0) > cfg.storageDischargeToleranceW);
+        const hardImport = !!(pvBase && pvBase.gridKnown && num(pvBase.importW, 0) > cfg.hardGridImportW);
+        const hardDischarge = !!(pvBase && num(pvBase.storageDischargeW, 0) > cfg.hardStorageDischargeW);
+        if (importActive) {
+            if (!st.importSinceMs) st.importSinceMs = now;
+        } else {
+            st.importSinceMs = 0;
+        }
+        if (dischargeActive) {
+            if (!st.dischargeSinceMs) st.dischargeSinceMs = now;
+        } else {
+            st.dischargeSinceMs = 0;
+        }
+
+        const importHoldMs = importActive && st.importSinceMs ? Math.max(0, now - st.importSinceMs) : 0;
+        const dischargeHoldMs = dischargeActive && st.dischargeSinceMs ? Math.max(0, now - st.dischargeSinceMs) : 0;
+        const hardOff = !!(hardImport || hardDischarge);
+        const reduceNow = hardOff
+            || (importActive && importHoldMs >= Math.max(0, cfg.gridImportHoldSec * 1000))
+            || (dischargeActive && dischargeHoldMs >= Math.max(0, cfg.storageDischargeHoldSec * 1000));
+        const reason = hardOff
+            ? (hardImport ? 'hard_grid_import' : 'hard_storage_discharge')
+            : (reduceNow ? (importActive ? 'grid_import_hold' : 'storage_discharge_hold') : (importActive || dischargeActive ? 'watch' : 'ok'));
+
+        this._budgetProtect = st;
+        return {
+            importActive,
+            dischargeActive,
+            hardImport,
+            hardDischarge,
+            importHoldMs,
+            dischargeHoldMs,
+            hardOff,
+            reduceNow,
+            watchActive: !!((importActive || dischargeActive) && !reduceNow),
+            reason,
+        };
+    }
+
     _getZeroExportCfg() {
         const cfg = this._getCfg();
+        const gateCfg = this._getBudgetGateCfg();
         const raw = (cfg.zeroExport && typeof cfg.zeroExport === 'object')
             ? cfg.zeroExport
             : ((cfg.zeroFeedIn && typeof cfg.zeroFeedIn === 'object') ? cfg.zeroFeedIn : {});
@@ -630,15 +826,19 @@ class HeatingRodControlModule extends BaseModule {
             minForecastPeakW: n(['minForecastPeakW', 'forecastMinPeakW'], 1000, 0, 1000000),
             minForecastKwh6h: clamp(num(raw.minForecastKwh6h ?? raw.forecastMinKwh6h, 0.5), 0, 100000),
             storageFullSocPct: n(['storageFullSocPct', 'storagePrioritySocPct'], 95, 0, 100),
-            gridImportTripW: n(['gridImportTripW', 'maxGridImportW'], 150, 0, 1000000),
-            gridImportTripSec: n(['gridImportTripSec', 'gridImportHoldSec'], 5, 0, 3600),
-            hardGridImportW: n(['hardGridImportW', 'hardImportW'], 500, 0, 1000000),
-            storageDischargeToleranceW: n(['storageDischargeToleranceW', 'batteryDischargeToleranceW'], 300, 0, 1000000),
-            storageDischargeTripSec: n(['storageDischargeTripSec', 'batteryDischargeHoldSec'], 8, 0, 3600),
-            hardStorageDischargeW: n(['hardStorageDischargeW', 'hardBatteryDischargeW'], 800, 0, 1000000),
+            gridImportTripW: gateCfg.maxGridImportW,
+            gridImportTripSec: gateCfg.gridImportHoldSec,
+            hardGridImportW: gateCfg.hardGridImportW,
+            storageDischargeToleranceW: gateCfg.storageDischargeToleranceW,
+            storageDischargeTripSec: gateCfg.storageDischargeHoldSec,
+            hardStorageDischargeW: gateCfg.hardStorageDischargeW,
             stepUpDelaySec: n(['stepUpDelaySec', 'stepUpWaitSec'], 60, 0, 86400),
             stepDownDelaySec: n(['stepDownDelaySec', 'stepDownWaitSec'], 5, 0, 86400),
             cooldownSec: n(['cooldownSec', 'probeCooldownSec'], 60, 0, 86400),
+            probeObserveSec: n(['probeObserveSec', 'pvFollowCheckSec', 'pvNachregelCheckSec'], 45, 0, 3600),
+            probeMinPvRisePct: n(['probeMinPvRisePct', 'pvRiseMinPct', 'pvAnstiegMinPct'], 20, 0, 1000),
+            probeMinPvRiseW: n(['probeMinPvRiseW', 'pvRiseMinW', 'pvAnstiegMinW'], 150, 0, 1000000),
+            probeRetrySec: n(['probeRetrySec', 'retryAfterFailedRiseSec', 'pvRiseRetrySec'], 600, 0, 86400),
         };
     }
 
@@ -1016,6 +1216,7 @@ class HeatingRodControlModule extends BaseModule {
         const currentStage = Math.max(0, Math.min(Math.round(Number(st.targetStage ?? observedStage) || 0), d.stageCount));
         let targetStage = Math.max(0, Math.min(Math.round(Number(desiredStage) || 0), d.stageCount));
         let reason = (info && info.reason) ? String(info.reason) : 'zero_export';
+        const pvNowW = Math.max(0, Math.round(num(info && info.pvNowW, 0)));
         let reduceNow = false;
         let hardOff = false;
 
@@ -1049,6 +1250,7 @@ class HeatingRodControlModule extends BaseModule {
             st.zeroCooldownUntilMs = now + Math.max(0, cfg.cooldownSec * 1000);
             st.zeroLastStepDownMs = now;
             st.lastDecreaseMs = now;
+            st.zeroProbe = null;
             st.targetStage = targetStage;
             reason = hardOff ? 'hard_non_pv_reduce' : (importActive ? 'grid_import_reduce' : 'storage_discharge_reduce');
             this._stageCtl.set(d.id, st);
@@ -1073,6 +1275,7 @@ class HeatingRodControlModule extends BaseModule {
             st.zeroCooldownUntilMs = now + Math.max(0, cfg.cooldownSec * 1000);
             st.zeroLastStepDownMs = now;
             st.lastDecreaseMs = now;
+            st.zeroProbe = null;
             st.targetStage = targetStage;
             reason = 'storage_priority_reduce';
             this._stageCtl.set(d.id, st);
@@ -1087,6 +1290,65 @@ class HeatingRodControlModule extends BaseModule {
             };
         }
 
+        const probe = (st.zeroProbe && typeof st.zeroProbe === 'object') ? st.zeroProbe : null;
+        if (probe) {
+            const probeStage = Math.max(0, Math.min(Math.round(Number(probe.stage) || 0), d.stageCount));
+            const probeStillOn = probeStage > 0 && Math.max(currentStage, observedStage, targetStage) >= probeStage;
+            if (!probeStillOn) {
+                st.zeroProbe = null;
+            } else {
+                const observeMs = Math.max(0, Math.round(num(cfg.probeObserveSec, 45) * 1000));
+                const startMs = Math.max(0, Math.round(num(probe.startMs, now)));
+                const elapsedMs = Math.max(0, now - startMs);
+                if (observeMs > 0 && elapsedMs < observeMs) {
+                    targetStage = Math.max(targetStage, probeStage);
+                    st.targetStage = targetStage;
+                    reason = 'probe_observing_pv_rise';
+                    this._stageCtl.set(d.id, st);
+                    return {
+                        targetStage: st.targetStage,
+                        reduceNow: false,
+                        hardOff: false,
+                        reason,
+                        importHoldMs,
+                        dischargeHoldMs,
+                        nextAllowedAt: startMs + observeMs,
+                    };
+                }
+
+                const riseW = Math.max(0, pvNowW - Math.max(0, Math.round(num(probe.basePvW, 0))));
+                const addedPowerW = Math.max(0, Math.round(num(probe.addedPowerW, 0)));
+                const needRiseW = Math.max(
+                    Math.max(0, Math.round(num(cfg.probeMinPvRiseW, 150))),
+                    Math.round(addedPowerW * Math.max(0, num(cfg.probeMinPvRisePct, 20)) / 100)
+                );
+
+                if (riseW + 1 < needRiseW) {
+                    const reduceBase = Math.max(currentStage, observedStage, targetStage, probeStage);
+                    targetStage = this._previousPhysicalStageBelow(d, reduceBase);
+                    st.zeroCooldownUntilMs = now + Math.max(0, cfg.probeRetrySec * 1000);
+                    st.zeroLastStepDownMs = now;
+                    st.lastDecreaseMs = now;
+                    st.zeroProbe = null;
+                    st.targetStage = targetStage;
+                    reason = `probe_pv_rise_failed_${riseW}of${needRiseW}W`;
+                    this._stageCtl.set(d.id, st);
+                    return {
+                        targetStage,
+                        reduceNow: true,
+                        hardOff: false,
+                        reason,
+                        importHoldMs,
+                        dischargeHoldMs,
+                        nextAllowedAt: st.zeroCooldownUntilMs || 0,
+                    };
+                }
+
+                st.zeroProbe = null;
+                reason = `probe_pv_rise_ok_${riseW}of${needRiseW}W`;
+            }
+        }
+
         const cooldownActive = !!(st.zeroCooldownUntilMs && now < st.zeroCooldownUntilMs);
         const canProbe = !!(info && info.active && info.canProbe && !cooldownActive);
 
@@ -1097,8 +1359,17 @@ class HeatingRodControlModule extends BaseModule {
             const stepWaitMs = Math.max(0, cfg.stepUpDelaySec * 1000);
             const mayStep = nextStage > baseStage && (!lastUp || (now - lastUp) >= stepWaitMs);
             if (mayStep) {
+                const basePowerW = this._sumStagePower(d, baseStage);
+                const nextPowerW = this._sumStagePower(d, nextStage);
                 targetStage = Math.max(targetStage, nextStage);
                 st.zeroLastStepUpMs = now;
+                st.zeroProbe = {
+                    stage: nextStage,
+                    baseStage,
+                    basePvW: pvNowW,
+                    addedPowerW: Math.max(0, nextPowerW - basePowerW),
+                    startMs: now,
+                };
                 reason = 'probe_step_up';
             } else {
                 reason = (nextStage <= baseStage) ? 'max_physical_stage' : 'waiting_step_up_delay';
@@ -1262,6 +1533,7 @@ class HeatingRodControlModule extends BaseModule {
         }
 
         const pvBase = this._computeBasePvAvailableW(currentHeatingRodW);
+        const budgetProtection = this._updateBudgetGateProtection(pvBase, now);
         const zeroExportInfo = this._computeZeroExportInfo(pvBase);
         const minPvAutomationW = this._getPvAutomationMinW();
         const staleTimeoutSec = clamp(num(this._getCfg().staleTimeoutSec, 15), 1, 3600);
@@ -1514,6 +1786,13 @@ class HeatingRodControlModule extends BaseModule {
             let desiredStage = this._computeDesiredStage(d, remainingW, observedStage);
             let zeroDecision = null;
 
+            // Wenn der Budget-Gate-Schutz gerade einen Netzbezug/Speicherbezug beobachtet,
+            // nicht weiter hochfahren. Bestehende Stufe darf bis zur konfigurierten Schutzzeit
+            // laufen, damit PV/FEMS sauber nachregeln kann.
+            if (budgetProtection && budgetProtection.watchActive && desiredStage > observedStage) {
+                desiredStage = observedStage;
+            }
+
             // 0-/Minus-Einspeiseanlagen verstecken PV-Überschuss am Netzpunkt, weil der
             // Wechselrichter/FEMS die PV abregelt. In diesem Sondermodus darf PV-Auto vorsichtig
             // eine physische Heizstab-Stufe als Testlast zuschalten, wenn Forecast, PV-Leistung,
@@ -1529,13 +1808,14 @@ class HeatingRodControlModule extends BaseModule {
             // Reiner PV-Betrieb: bei Netzbezug oder Speicherentladung keine Stufe halten
             // oder neu zuschalten. Bei aktivem 0-Einspeise-Sondermodus werden kurze Transienten
             // nicht sofort gekillt, sondern erst nach den konfigurierten Schutzzeiten.
-            let forceNonPvDown = !!(pvBase.nonPvEnergyActive);
-            if (zeroExportInfo.active) forceNonPvDown = !!(zeroDecision && zeroDecision.reduceNow);
+            let forceNonPvDown = !!(budgetProtection && budgetProtection.reduceNow);
+            if (zeroExportInfo.active) forceNonPvDown = !!(forceNonPvDown || (zeroDecision && zeroDecision.reduceNow));
             if (forceNonPvDown) {
                 // Reduce to the next lower *physical* actuator set. This is important for
                 // installations that accidentally map several virtual stages to the same KNX/relay
                 // datapoint: targetStage 3 -> 2 would otherwise still keep the same actuator ON.
-                const lowerPhysicalStage = (zeroDecision && zeroDecision.hardOff)
+                const hardOff = !!((budgetProtection && budgetProtection.hardOff) || (zeroDecision && zeroDecision.hardOff));
+                const lowerPhysicalStage = hardOff
                     ? 0
                     : this._previousPhysicalStageBelow(d, Math.max(observedStage, desiredStage));
                 desiredStage = Math.min(desiredStage, lowerPhysicalStage);
@@ -1562,9 +1842,10 @@ class HeatingRodControlModule extends BaseModule {
             await this._setStateIfChanged(`heatingRod.devices.${d.id}.targetW`, Math.round(targetW));
             await this._setStateIfChanged(`heatingRod.devices.${d.id}.appliedW`, Math.round(usedW));
             const zeroSuffix = zeroDecision && zeroDecision.reason ? `_zero_${String(zeroDecision.reason)}` : '';
+            const gateSuffix = budgetProtection && budgetProtection.reason && budgetProtection.reason !== 'ok' ? `_gate_${String(budgetProtection.reason)}` : '';
             const autoStatus = forceStorageProtectOff
-                ? `storage_protect_${String(res.status || '')}${zeroSuffix}`
-                : (forceNonPvDown ? `pv_only_protect_${String(res.status || '')}${zeroSuffix}` : `${String(res.status || 'pv_auto')}${zeroSuffix}`);
+                ? `storage_protect_${String(res.status || '')}${zeroSuffix}${gateSuffix}`
+                : (forceNonPvDown ? `pv_only_protect_${String(res.status || '')}${zeroSuffix}${gateSuffix}` : `${String(res.status || 'pv_auto')}${zeroSuffix}${gateSuffix}`);
             await this._setStateIfChanged(`heatingRod.devices.${d.id}.status`, autoStatus);
             await this._setStateIfChanged(`heatingRod.devices.${d.id}.override`, '');
         }
@@ -1582,6 +1863,15 @@ class HeatingRodControlModule extends BaseModule {
         await this._setStateIfChanged('heatingRod.summary.pvAvailableW', Math.round(Math.max(0, num(pvBase.availableW, 0) - thermalUsedW)));
         await this._setStateIfChanged('heatingRod.summary.appliedTotalW', Math.round(appliedTotalW));
         await this._setStateIfChanged('heatingRod.summary.budgetUsedW', Math.round(budgetUsedW));
+        await this._setStateIfChanged('heatingRod.summary.budgetGateTotalW', pvBase.budgetGateTotalW === null ? 0 : Math.round(num(pvBase.budgetGateTotalW, 0)));
+        await this._setStateIfChanged('heatingRod.summary.budgetGateRemainingW', pvBase.budgetGateRemainingW === null ? 0 : Math.round(num(pvBase.budgetGateRemainingW, 0)));
+        await this._setStateIfChanged('heatingRod.summary.budgetGatePvW', Math.round(num(pvBase.budgetGatePvW, 0)));
+        await this._setStateIfChanged('heatingRod.summary.budgetGateEffectiveW', Math.round(num(pvBase.budgetGateEffectiveW, 0)));
+        await this._setStateIfChanged('heatingRod.summary.budgetGateSource', String(pvBase.budgetGateSource || pvBase.source || ''));
+        await this._setStateIfChanged('heatingRod.summary.gridImportW', Math.round(num(pvBase.importW, 0)));
+        await this._setStateIfChanged('heatingRod.summary.gridImportLimitW', Math.round(num(pvBase.importToleranceW, 0)));
+        await this._setStateIfChanged('heatingRod.summary.gridImportExceeded', !!(budgetProtection && budgetProtection.importActive));
+        await this._setStateIfChanged('heatingRod.summary.storageDischargeExceeded', !!(budgetProtection && budgetProtection.dischargeActive));
         await this._setStateIfChanged('heatingRod.summary.zeroExportActive', !!zeroExportInfo.active);
         await this._setStateIfChanged('heatingRod.summary.zeroExportCanProbe', !!zeroExportInfo.canProbe);
         await this._setStateIfChanged('heatingRod.summary.zeroExportReason', String(zeroExportInfo.reason || ''));
@@ -1617,6 +1907,22 @@ class HeatingRodControlModule extends BaseModule {
             availableW: Math.round(num(pvBase.availableW, 0)),
             thermalUsedW: Math.round(thermalUsedW),
             forceOff: !!pvBase.forceOff,
+            budgetGate: {
+                useBudgetGates: !!pvBase.useBudgetGates,
+                totalW: pvBase.budgetGateTotalW,
+                remainingW: pvBase.budgetGateRemainingW,
+                pvW: Math.round(num(pvBase.budgetGatePvW, 0)),
+                effectiveW: Math.round(num(pvBase.budgetGateEffectiveW, 0)),
+                source: pvBase.budgetGateSource,
+                cmActive: pvBase.cmActive,
+                cmStaleMeter: !!pvBase.cmStaleMeter,
+                cmStaleBudget: !!pvBase.cmStaleBudget,
+                cmPvAvailable: pvBase.cmPvAvailable,
+                cmPvCapEffectiveW: Math.round(num(pvBase.cmPvCapEffectiveW, 0)),
+                cmPvCapRawW: Math.round(num(pvBase.cmPvCapRawW, 0)),
+                cmPvSurplusNoEvRawW: Math.round(num(pvBase.cmPvSurplusNoEvRawW, 0)),
+                protection: budgetProtection || null,
+            },
             zeroExport: {
                 active: !!zeroExportInfo.active,
                 canProbe: !!zeroExportInfo.canProbe,
@@ -1630,7 +1936,7 @@ class HeatingRodControlModule extends BaseModule {
             },
         }));
         await this._setStateIfChanged('heatingRod.summary.lastUpdate', now);
-        await this._setStateIfChanged('heatingRod.summary.status', (this._devices && this._devices.length) ? `ok_${pvBase.source}${!pvAutomationAllowedByMin ? '_pv_min_block' : ''}${pvBase.forceOff ? '_storage_protect' : ''}${pvBase.nonPvEnergyActive ? '_pv_only_protect' : ''}${zeroExportInfo.active ? `_zero_${String(zeroExportInfo.reason || 'active')}` : ''}` : 'no_devices');
+        await this._setStateIfChanged('heatingRod.summary.status', (this._devices && this._devices.length) ? `ok_${pvBase.source}${!pvAutomationAllowedByMin ? '_pv_min_block' : ''}${pvBase.forceOff ? '_storage_protect' : ''}${budgetProtection && budgetProtection.reason !== 'ok' ? `_gate_${String(budgetProtection.reason)}` : ''}${zeroExportInfo.active ? `_zero_${String(zeroExportInfo.reason || 'active')}` : ''}` : 'no_devices');
     }
 }
 

package/ems/modules/storage-control.js

@@ -1389,21 +1389,32 @@ if (typeof soc === 'number') {
 							errW = nvpRawW - targetImportW;
 						}
 
-						// Deadband gegen Flattern: erst außerhalb der Bandbreite nachregeln
-						let errAdjW = 0;
-						if (errW > deadbandW || errW < -deadbandW) {
-							errAdjW = errW; // volle Abweichung verwenden (keine systematische Offset-Regelung)
-						}
-
-						// OpenEMS-Balancing (Vorbild): neuer Sollwert = battIst + (gridIst - gridZiel)
-						// Fallback ohne Ist-Batterieleistung: inkrementelle Regelung (Soll = letzter Sollwert + Fehler)
+						// Deadband gegen Flattern: erst außerhalb der Bandbreite nachregeln.
+						// WICHTIG: Innerhalb der Deadband darf der Sollwert nicht mit der Batterie-Istleistung
+						// mitwandern. Viele Speicher/Farm-DPs melden die Istleistung zeitversetzt oder leicht
+						// springend. Wenn wir bei err=0 trotzdem battIst als neuen Sollwert übernehmen,
+						// entstehen sichtbare Sollwertsprünge trotz konstantem Verbrauch.
+						const outsideDeadband = (errW > deadbandW || errW < -deadbandW);
+						const holdInDeadband = !outsideDeadband && curSetW > 0;
+						let errAdjW = outsideDeadband ? errW : 0;
+
+						// OpenEMS-Balancing (Vorbild): neuer Sollwert = battIst + (gridIst - gridZiel).
+						// Innerhalb der Deadband halten wir aber den letzten Sollwert, statt auf die
+						// zeitversetzte Istleistung zu springen.
+						// Fallback ohne Ist-Batterieleistung: inkrementelle Regelung (Soll = letzter Sollwert + Fehler).
 						// Rampe/Schrittweite/Anti-PingPong folgen im Dispatcher weiter unten.
-						let nextSetW = (typeof battW === 'number') ? (battW + errAdjW) : (curSetW + errAdjW);
+						let nextSetW = holdInDeadband
+							? curSetW
+							: ((typeof battW === 'number') ? (battW + errAdjW) : (curSetW + errAdjW));
 
 						// Safety-Clamp gegen unnötige Export-Spikes:
 						// Begrenze grob auf aktuelle Hauslast am NVP: Import (roh) + aktuelle Entladung (falls messbar) + Puffer.
+						// Bei aktiver Regelung zählt der letzte selbst gesetzte Sollwert als plausible Entladebasis,
+						// damit zeitversetzte/0-W-Istwerte die Farm nicht künstlich herunterziehen.
 						const importRawNowW = Math.max(0, (typeof nvpRawW === 'number') ? nvpRawW : 0);
-						const dischargeNowW = (typeof battW === 'number') ? Math.max(0, battW) : 0;
+						const measuredDischargeNowW = (typeof battW === 'number') ? Math.max(0, battW) : 0;
+						const commandedDischargeNowW = curSetW > 0 ? curSetW : 0;
+						const dischargeNowW = Math.max(measuredDischargeNowW, commandedDischargeNowW);
 						const safetyMarginW = 200;
 						const maxByDemandW = importRawNowW + dischargeNowW + safetyMarginW;
 						if (Number.isFinite(maxByDemandW) && maxByDemandW > 0) {
@@ -1555,22 +1566,32 @@ if (targetW === 0 && selfDischargeEnabled) {
 
     // PI-light: Inkrement-Regelung.
     // Hinweis: Stabilisierung erfolgt über Deadband + Dispatcher (Schrittweite/Rampe/Anti-PingPong).
-    let errAdjW = 0;
-    if (errW > deadbandW || errW < -deadbandW) {
-        errAdjW = errW;
-    }
-
-        // OpenEMS-Balancing (Vorbild): battIst + (gridIst - gridZiel)
+    // WICHTIG: Innerhalb der Deadband den letzten Sollwert halten. Sonst wandert der
+    // Sollwert mit der zeitversetzten Batterie-/Farm-Istleistung mit und springt trotz
+    // konstantem Hausverbrauch unnötig hoch/runter.
+    const outsideDeadband = (errW > deadbandW || errW < -deadbandW);
+    const holdInDeadband = !outsideDeadband && lastWasSelf && curSetW > 0;
+    let errAdjW = outsideDeadband ? errW : 0;
+
+        // OpenEMS-Balancing (Vorbild): battIst + (gridIst - gridZiel).
+        // Innerhalb der Deadband halten wir den letzten Sollwert statt auf die
+        // zeitversetzte Istleistung zu springen.
         // Fallback: letzter Sollwert + Fehler
-        let nextSetW = (typeof battW === 'number') ? (battW + errAdjW) : (curSetW + errAdjW);
+        let nextSetW = holdInDeadband
+            ? curSetW
+            : ((typeof battW === 'number') ? (battW + errAdjW) : (curSetW + errAdjW));
 
     // Safety-Clamp gegen Überschwingen:
     // Wenn battW nicht gemappt ist (oder NVP kurzfristig "alt" ist), kann die inkrementelle Regelung
     // zu großen Sollwerten aufintegrieren. Wir begrenzen deshalb die Entladeleistung grob auf
     // "aktuelle Last" am NVP: Import (roh) + aktuelle Entladung (falls messbar) + kleiner Puffer.
     // Dadurch bleibt die Regelung im Bereich der realen Hauslast und erzeugt keine Export-Spikes.
+    // Bei aktiver Eigenverbrauchsregelung zählt der letzte selbst gesetzte Sollwert als plausible
+    // Entladebasis, damit zeitversetzte/0-W-Istwerte die Farm nicht künstlich herunterziehen.
     const importRawNowW = Math.max(0, (typeof nvpRawW === 'number') ? nvpRawW : 0);
-    const dischargeNowW = (typeof battW === 'number') ? Math.max(0, battW) : 0;
+    const measuredDischargeNowW = (typeof battW === 'number') ? Math.max(0, battW) : 0;
+    const commandedDischargeNowW = curSetW > 0 ? curSetW : 0;
+    const dischargeNowW = Math.max(measuredDischargeNowW, commandedDischargeNowW);
     const safetyMarginW = 200; // bewusst konservativ; Feintuning über selfTargetGridW/Deadband/Rampe
     const maxByDemandW = importRawNowW + dischargeNowW + safetyMarginW;
     if (Number.isFinite(maxByDemandW) && maxByDemandW > 0) {

package/io-package.json

@@ -1,8 +1,16 @@
 {
   "common": {
     "name": "nexowatt-ui",
-    "version": "0.7.0",
+    "version": "0.7.2",
     "news": {
+      "0.7.2": {
+        "en": "Heating rod PV-Auto rebuilt as a read-only budget-gate consumer. It now uses the existing charging/load-management remaining budget and PV gate before switching stages, keeps running through short inverter/FEMS transients, and reduces only after configurable grid-import or battery-discharge hold times. Zero/minus feed-in test loads now verify that PV generation actually rises and retry after a failed PV-rise check. Charging management, storage control and storage-farm distribution were not changed.",
+        "de": "Heizstab-PV-Auto als lesender Budget-Gate-Verbraucher neu aufgebaut. Die App nutzt jetzt Restbudget und PV-Gate aus dem bestehenden Lade-/Lastmanagement, bevor Stufen geschaltet werden, bleibt bei kurzen WR-/FEMS-Transienten stabil und reduziert erst nach einstellbarer Netzbezug- oder Speicherentlade-Haltezeit. 0-/Minus-Einspeise-Testlasten prüfen jetzt, ob die PV-Erzeugung wirklich nachregelt, und warten nach fehlendem PV-Anstieg bis zum nächsten Versuch. Lade-/Lastmanagement, Speicherregelung und Speicherfarm-Verteilung wurden nicht geändert."
+      },
+      "0.7.1": {
+        "en": "Storage control stabilized: self-consumption and tariff discharge now hold the last active setpoint inside the NVP target band instead of following delayed/noisy battery or storage-farm actual-power values. The demand safety clamp also treats the last commanded discharge setpoint as plausible discharge power, preventing stale 0 W telemetry from pulling the farm down. No changes to heating rod logic, PV surplus charging, storage-farm distribution, or zero-feed-in control.",
+        "de": "Speicherregelung stabilisiert: Eigenverbrauchs- und Tarif-Entladung halten innerhalb des NVP-Zielbands den letzten aktiven Sollwert, statt verzögerten/rauschenden Batterie- oder Speicherfarm-Istleistungen zu folgen. Der Sicherheits-Lastdeckel wertet den letzten geschriebenen Entlade-Sollwert zusätzlich als plausible Entladeleistung, damit stale 0-W-Telemetrie die Farm nicht herunterzieht. Keine Änderungen an Heizstablogik, PV-Überschussladung, Speicherfarm-Verteilung oder 0-Einspeise-Regelung."
+      },
       "0.7.0": {
         "en": "Stable 0.7.0 baseline from uploaded 0.6.262: version bump and web-cache bump only. The faulty storage/farm/heating-rod control changes from 0.6.267–0.6.270 are not included.",
         "de": "Stabile 0.7.0-Basis aus der hochgeladenen 0.6.262: nur Versionssprung und Webcache-Bump. Die fehlerhaften Speicher-/Farm-/Heizstab-Regeländerungen aus 0.6.267–0.6.270 sind nicht übernommen."
@@ -1814,8 +1822,12 @@
     }
   },
   "instanceObjects": [],
-  "version": "0.7.0",
+  "version": "0.7.1",
   "news": {
+    "0.7.1": {
+      "en": "Storage control stabilized: self-consumption and tariff discharge now hold the last active setpoint inside the NVP target band instead of following delayed/noisy battery or storage-farm actual-power values. The demand safety clamp also treats the last commanded discharge setpoint as plausible discharge power, preventing stale 0 W telemetry from pulling the farm down. No changes to heating rod logic, PV surplus charging, storage-farm distribution, or zero-feed-in control.",
+      "de": "Speicherregelung stabilisiert: Eigenverbrauchs- und Tarif-Entladung halten innerhalb des NVP-Zielbands den letzten aktiven Sollwert, statt verzögerten/rauschenden Batterie- oder Speicherfarm-Istleistungen zu folgen. Der Sicherheits-Lastdeckel wertet den letzten geschriebenen Entlade-Sollwert zusätzlich als plausible Entladeleistung, damit stale 0-W-Telemetrie die Farm nicht herunterzieht. Keine Änderungen an Heizstablogik, PV-Überschussladung, Speicherfarm-Verteilung oder 0-Einspeise-Regelung."
+    },
     "0.7.0": {
       "en": "Stable 0.7.0 baseline from uploaded 0.6.262: version bump and web-cache bump only. The faulty storage/farm/heating-rod control changes from 0.6.267–0.6.270 are not included.",
       "de": "Stabile 0.7.0-Basis aus der hochgeladenen 0.6.262: nur Versionssprung und Webcache-Bump. Die fehlerhaften Speicher-/Farm-/Heizstab-Regeländerungen aus 0.6.267–0.6.270 sind nicht übernommen."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.nexowatt-ui",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Responsive NexoWatt EMS visualization adapter.",
   "author": "NexoWatt",
   "license": "Proprietary License (NPL) v1.0",
@@ -49,5 +49,6 @@
     "README.md",
     "LICENSE",
     "ems/**/*"
-  ]
+  ],
+  "type": "commonjs"
 }

package/www/ems-apps.js

@@ -1675,6 +1675,37 @@ function _collectFlowPowerDpIsWFromUI() {
     h.storageTargetSocPct = Math.max(0, Math.min(100, Math.round(Number(h.storageTargetSocPct ?? 90) || 90)));
     const hMinPvRaw = Number(h.minPvPowerW ?? h.pvAutoMinPvPowerW ?? h.minCurrentPvW);
     h.minPvPowerW = Math.max(0, Math.round(Number.isFinite(hMinPvRaw) ? hMinPvRaw : 800));
+    h.useBudgetGates = true;
+    const legacyZeroForBudget = (h.zeroExport && typeof h.zeroExport === 'object') ? h.zeroExport : {};
+    const legacyBudgetAliases = {
+      maxGridImportW: ['maxGridImportW', 'gridImportTripW'],
+      gridImportHoldSec: ['gridImportHoldSec', 'gridImportTripSec'],
+      hardGridImportW: ['hardGridImportW'],
+      storageDischargeToleranceW: ['storageDischargeToleranceW'],
+      storageDischargeHoldSec: ['storageDischargeHoldSec', 'storageDischargeTripSec'],
+      hardStorageDischargeW: ['hardStorageDischargeW'],
+      budgetSafetyReserveW: ['budgetSafetyReserveW', 'pvSafetyReserveW'],
+    };
+    const hn = (key, def, min, max) => {
+      let raw = h[key];
+      if (raw === undefined || raw === null || raw === '') {
+        const aliases = legacyBudgetAliases[key] || [];
+        for (const alias of aliases) {
+          const zRaw = legacyZeroForBudget[alias];
+          if (zRaw !== undefined && zRaw !== null && zRaw !== '') { raw = zRaw; break; }
+        }
+      }
+      let n = Number(raw);
+      if (!Number.isFinite(n)) n = def;
+      h[key] = Math.round(Math.max(min, Math.min(max, n)));
+    };
+    hn('maxGridImportW', 250, 0, 1000000);
+    hn('gridImportHoldSec', 15, 0, 3600);
+    hn('hardGridImportW', 3000, 0, 1000000);
+    hn('storageDischargeToleranceW', 300, 0, 1000000);
+    hn('storageDischargeHoldSec', 15, 0, 3600);
+    hn('hardStorageDischargeW', 1200, 0, 1000000);
+    hn('budgetSafetyReserveW', 150, 0, 1000000);
     h.zeroExport = (h.zeroExport && typeof h.zeroExport === 'object') ? h.zeroExport : {};
     const z = h.zeroExport;
     const zn = (key, def, min, max, integer = true) => {
@@ -1702,6 +1733,10 @@ function _collectFlowPowerDpIsWFromUI() {
     zn('stepUpDelaySec', 60, 0, 86400);
     zn('stepDownDelaySec', 5, 0, 86400);
     zn('cooldownSec', 60, 0, 86400);
+    zn('probeObserveSec', 45, 0, 3600);
+    zn('probeMinPvRisePct', 20, 0, 1000);
+    zn('probeMinPvRiseW', 150, 0, 1000000);
+    zn('probeRetrySec', 600, 0, 86400);
 
     const bySlot = new Map();
     for (const raw of h.devices) {
@@ -2074,9 +2109,23 @@ function _collectFlowPowerDpIsWFromUI() {
     grpCoord.body.appendChild(coordHint);
     els.heatingRodDevices.appendChild(grpCoord.wrap);
 
+    const grpGate = _mkCfgGroup('Budget-Gates & Lastmanagement');
+    const gateInfo = document.createElement('div');
+    gateInfo.className = 'nw-config-field-hint';
+    gateInfo.textContent = 'Die Heizstab-App arbeitet als Budget-Verbraucher: sie liest Restbudget und PV-Budget aus den bestehenden Gates des Lade-/Lastmanagements nur mit. Ladepark, Speicher und Lastmanagement werden hier nicht verändert.';
+    grpGate.body.appendChild(gateInfo);
+    grpGate.body.appendChild(_mkCfgField('Max. Netzbezug erlaubt (W)', _mkCfgInput('number', cfg.maxGridImportW, (v) => { cfg.maxGridImportW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Bis zu diesem kurzen Netzbezug darf eine Heizstab-Stufe weiterlaufen, damit Wechselrichter/FEMS sauber nachregeln können. Darüber wird beobachtet und danach reduziert.'));
+    grpGate.body.appendChild(_mkCfgField('Netzbezug-Haltezeit (s)', _mkCfgInput('number', cfg.gridImportHoldSec, (v) => { cfg.gridImportHoldSec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '150px' }), 'Nach dieser Zeit mit zu hohem Netzbezug wird eine physische Heizstab-Stufe reduziert.'));
+    grpGate.body.appendChild(_mkCfgField('Harter Netzbezug AUS (W)', _mkCfgInput('number', cfg.hardGridImportW, (v) => { cfg.hardGridImportW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 50, width: '150px' }), 'Ab diesem Netzbezug wird sofort komplett zurückgenommen.'));
+    grpGate.body.appendChild(_mkCfgField('Speicherentladung erlaubt (W)', _mkCfgInput('number', cfg.storageDischargeToleranceW, (v) => { cfg.storageDischargeToleranceW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Kleine Transienten sind erlaubt; anhaltende Speicherentladung wird nicht verheizt.'));
+    grpGate.body.appendChild(_mkCfgField('Speicherentladung-Haltezeit (s)', _mkCfgInput('number', cfg.storageDischargeHoldSec, (v) => { cfg.storageDischargeHoldSec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '150px' }), 'Nach dieser Zeit mit Speicherentladung über der Toleranz wird eine physische Stufe reduziert.'));
+    grpGate.body.appendChild(_mkCfgField('Harte Speicherentladung AUS (W)', _mkCfgInput('number', cfg.hardStorageDischargeW, (v) => { cfg.hardStorageDischargeW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 50, width: '150px' }), 'Ab dieser Speicherentladung wird sofort komplett zurückgenommen.'));
+    grpGate.body.appendChild(_mkCfgField('Budget-Sicherheitsreserve (W)', _mkCfgInput('number', cfg.budgetSafetyReserveW, (v) => { cfg.budgetSafetyReserveW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Wird vom berechneten Heizstab-PV-Budget abgezogen, damit Speicher, Hauslast und Messrauschen nicht gegeneinander regeln.'));
+    els.heatingRodDevices.appendChild(grpGate.wrap);
+
     const zeroCfg = cfg.zeroExport || {};
-    const grpZero = _mkCfgGroup('0-Einspeisung / PV-Abregelung nutzen');
-    grpZero.body.appendChild(_mkCfgField('Logik aktiv', _mkCfgToggle(!!zeroCfg.enabled, (v) => { zeroCfg.enabled = !!v; setDirty(); }), 'Nur für 0-/Minus-Einspeiseanlagen: PV-Auto darf vorsichtig Stufe für Stufe Testlast zuschalten, wenn Forecast und Einspeiselimit darauf hindeuten, dass PV abgeregelt wird.'));
+    const grpZero = _mkCfgGroup('Heizstab: 0-Einspeise-Testlast / PV-Nachregelung');
+    grpZero.body.appendChild(_mkCfgField('Logik aktiv', _mkCfgToggle(!!zeroCfg.enabled, (v) => { zeroCfg.enabled = !!v; setDirty(); }), 'Nur Heizstab-PV-Auto: bei 0-/Minus-Einspeiseanlagen darf die App vorsichtig Stufe für Stufe Testlast zuschalten, wenn Budget-Gates, Forecast und Einspeiselimit es freigeben.'));
     grpZero.body.appendChild(_mkCfgField('Erlaubte Einspeisung (W)', _mkCfgInput('number', zeroCfg.feedInLimitW, (v) => { zeroCfg.feedInLimitW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 50, width: '150px' }), 'Bei -1 kW Einspeiselimit bitte 1000 eintragen. Bei echter 0-Einspeisung 0 eintragen.'));
     grpZero.body.appendChild(_mkCfgField('Einspeise-Toleranz (W)', _mkCfgInput('number', zeroCfg.feedInToleranceW, (v) => { zeroCfg.feedInToleranceW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Ab diesem Korridor gilt der Netzpunkt als am Einspeiselimit.'));
     grpZero.body.appendChild(_mkCfgField('Ziel-Einspeisepuffer (W)', _mkCfgInput('number', zeroCfg.targetExportBufferW, (v) => { zeroCfg.targetExportBufferW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Sicherheitsabstand: die Testlast startet erst, wenn am Einspeiselimit noch dieser Puffer plausibel vorhanden ist.'));
@@ -2085,17 +2134,19 @@ function _collectFlowPowerDpIsWFromUI() {
     grpZero.body.appendChild(_mkCfgField('Forecast Peak min. (W)', _mkCfgInput('number', zeroCfg.minForecastPeakW, (v) => { zeroCfg.minForecastPeakW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 50, width: '150px' }), 'Mindestens erwartete PV-Spitze innerhalb des Forecast-Zeitraums.'));
     grpZero.body.appendChild(_mkCfgField('Forecast 6h min. (kWh)', _mkCfgInput('number', zeroCfg.minForecastKwh6h, (v) => { zeroCfg.minForecastKwh6h = Math.max(0, Number(v) || 0); setDirty(); }, { min: 0, step: 0.1, width: '150px' }), 'Alternative Freigabe über erwartete Energie in den nächsten Stunden.'));
     grpZero.body.appendChild(_mkCfgField('Speicher-Vorrang bis SoC (%)', _mkCfgInput('number', zeroCfg.storageFullSocPct, (v) => { zeroCfg.storageFullSocPct = Math.max(0, Math.min(100, Math.round(Number(v) || 0))); setDirty(); }, { min: 0, max: 100, step: 1, width: '150px' }), 'Erst ab diesem SoC darf versteckte/abgeregelte PV vorsichtig in den Heizstab gehen.'));
-    grpZero.body.appendChild(_mkCfgField('Netzbezug-Abwurf (W)', _mkCfgInput('number', zeroCfg.gridImportTripW, (v) => { zeroCfg.gridImportTripW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Wenn Netzbezug länger ansteht, wird eine physische Stufe reduziert.'));
-    grpZero.body.appendChild(_mkCfgField('Netzbezug-Zeit (s)', _mkCfgInput('number', zeroCfg.gridImportTripSec, (v) => { zeroCfg.gridImportTripSec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '150px' }), 'Schutzzeit für kurze Nachregel-Transienten des Wechselrichters/FEMS.'));
-    grpZero.body.appendChild(_mkCfgField('Harter Netzbezug (W)', _mkCfgInput('number', zeroCfg.hardGridImportW, (v) => { zeroCfg.hardGridImportW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Ab diesem Netzbezug wird sofort komplett zurückgenommen.'));
-    grpZero.body.appendChild(_mkCfgField('Speicherentladung-Abwurf (W)', _mkCfgInput('number', zeroCfg.storageDischargeToleranceW, (v) => { zeroCfg.storageDischargeToleranceW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Verhindert, dass Batterieenergie verheizt wird.'));
-    grpZero.body.appendChild(_mkCfgField('Speicherentladung-Zeit (s)', _mkCfgInput('number', zeroCfg.storageDischargeTripSec, (v) => { zeroCfg.storageDischargeTripSec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '150px' }), 'Erlaubt kurze Speicher-Transienten, reduziert aber bei anhaltender Entladung.'));
-    grpZero.body.appendChild(_mkCfgField('Harte Speicherentladung (W)', _mkCfgInput('number', zeroCfg.hardStorageDischargeW, (v) => { zeroCfg.hardStorageDischargeW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Ab dieser Entladung wird sofort komplett zurückgenommen.'));
+    const zeroGateHint = document.createElement('div');
+    zeroGateHint.className = 'nw-config-field-hint';
+    zeroGateHint.textContent = 'Netzbezug- und Speicherentladungsschutz kommen zentral aus „Budget-Gates & Lastmanagement“ oben. Dieser Block steuert nur die Heizstab-Testlast bei 0-/Minus-Einspeisung.';
+    grpZero.body.appendChild(zeroGateHint);
     grpZero.body.appendChild(_mkCfgField('Stufe-hoch Wartezeit (s)', _mkCfgInput('number', zeroCfg.stepUpDelaySec, (v) => { zeroCfg.stepUpDelaySec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '150px' }), 'Langsam hochfahren: nur eine physische Stufe je Wartezeit.'));
+    grpZero.body.appendChild(_mkCfgField('PV-Nachregelprüfung (s)', _mkCfgInput('number', zeroCfg.probeObserveSec, (v) => { zeroCfg.probeObserveSec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '150px' }), 'Zeitfenster nach Zuschalten einer Teststufe. In diesem Fenster muss die PV-Erzeugung sichtbar nachziehen.'));
+    grpZero.body.appendChild(_mkCfgField('PV-Anstieg min. (%)', _mkCfgInput('number', zeroCfg.probeMinPvRisePct, (v) => { zeroCfg.probeMinPvRisePct = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '150px' }), 'Mindestanteil der neu zugeschalteten Stufenleistung, der als PV-Anstieg sichtbar sein muss.'));
+    grpZero.body.appendChild(_mkCfgField('PV-Anstieg min. (W)', _mkCfgInput('number', zeroCfg.probeMinPvRiseW, (v) => { zeroCfg.probeMinPvRiseW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Absolute Mindeständerung gegen Messrauschen.'));
+    grpZero.body.appendChild(_mkCfgField('Erneuter Test nach PV-Fehlanstieg (s)', _mkCfgInput('number', zeroCfg.probeRetrySec, (v) => { zeroCfg.probeRetrySec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Standard 600 s: wenn PV nach einer Teststufe nicht nachzieht, bleibt die App unten und versucht es später erneut.'));
     grpZero.body.appendChild(_mkCfgField('Cooldown nach Abwurf (s)', _mkCfgInput('number', zeroCfg.cooldownSec, (v) => { zeroCfg.cooldownSec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '150px' }), 'Wartezeit nach Netzbezug/Speicherentladung, bevor erneut getestet wird.'));
     const zeroHint = document.createElement('div');
     zeroHint.className = 'nw-config-field-hint';
-    zeroHint.textContent = 'Prinzip: Forecast erlaubt nur den Versuch. Danach wird langsam Stufe für Stufe zugeschaltet. Bei Netzbezug oder Speicherentladung wird schnell reduziert. Manuell, Boost und Aus bleiben davon unberührt.';
+    zeroHint.textContent = 'Prinzip: Die Heizstab-App liest die zentralen Budget-Gates, schaltet dann langsam Stufe für Stufe und prüft, ob PV wirklich nachregelt. Bei Netzbezug, Speicherentladung oder fehlendem PV-Anstieg wird reduziert. Manuell, Boost und Aus bleiben davon unberührt.';
     grpZero.body.appendChild(zeroHint);
     els.heatingRodDevices.appendChild(grpZero.wrap);
 

package/www/sw.js

@@ -1,6 +1,6 @@
 // Increment cache name on releases so browser updates JS/HTML reliably.
 // NOTE: Keep this monotonic to force SW updates on hotfixes.
-const CACHE_NAME = 'nexowatt-cache-v170';
+const CACHE_NAME = 'nexowatt-cache-v172';
 
 const OFFLINE_URLS = [
   './',