iobroker.nexowatt-ui 0.7.2 → 0.7.4

package/ems/modules/charging-management.js

@@ -2622,6 +2622,11 @@ class ChargingManagementModule extends BaseModule {
         // (b) no active wallbox is in a grid-allowed mode (normal/minpv/boost).
         const capTotalBudgetByPv = (pvSurplusOnlyCfg || forcePvSurplusOnly) && !anyGridAllowedActive;
         const needPvBudget = anyPvLimitedActive || capTotalBudgetByPv;
+        // Das PV-Gate ist inzwischen ein zentrales Diagnose-/Budget-Signal für nachgelagerte Apps
+        // (z. B. Heizstab). Deshalb muss der PV-Überschuss auch dann berechnet und veröffentlicht
+        // werden, wenn gerade keine Wallbox im PV-Modus aktiv ist. Wichtig: Das beeinflusst NICHT
+        // die EVCS-Budgetbegrenzung; angewendet wird pvCapW weiterhin nur, wenn needPvBudget/capTotalBudgetByPv aktiv ist.
+        const needPvDiagnostics = true;
 
         // PV surplus / cap (used for PV-limited wallboxes; and optionally to cap total budget)
         let pvCapW = null;
@@ -2638,7 +2643,7 @@ class ChargingManagementModule extends BaseModule {
         let pvSurplusNoEvRawWState = 0;
         let pvSurplusNoEvAvg5mWState = 0;
 
-        if (needPvBudget) {
+        if (needPvBudget || needPvDiagnostics) {
             // PV-Überschuss sauber ermitteln:
             // Problem (vorher): PV-Cap wurde aus dem NVP (grid export) direkt abgeleitet.
             // Sobald die Wallbox startet, sinkt der Export (weil EVCS selbst verbraucht)
@@ -2894,7 +2899,7 @@ class ChargingManagementModule extends BaseModule {
 
         }
 
-        if (!needPvBudget) {
+        if (!needPvBudget && !needPvDiagnostics) {
             this._pvAvailable = false;
             this._pvAboveSinceMs = 0;
             this._pvBelowSinceMs = 0;

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

@@ -497,12 +497,19 @@ class HeatingRodControlModule extends BaseModule {
         for (const key of list) {
             if (!key) continue;
             try {
-                if (this.dp && this.dp.getEntry && this.dp.getEntry(key)) {
+                const hasDpEntry = !!(this.dp && this.dp.getEntry && this.dp.getEntry(key));
+                if (hasDpEntry) {
+                    // Registered datapoints carry freshness metadata. If such a datapoint is
+                    // stale, never resurrect the old value from the raw adapter cache. This is
+                    // especially important for Batterie-Entladen: an old discharge value would
+                    // otherwise block Heizstab step-up although the live NVP/PV budget is clean.
+                    if (typeof this.dp.isStale === 'function' && this.dp.isStale(key, staleMs)) continue;
                     const v = this.dp.getNumberFresh ? this.dp.getNumberFresh(key, staleMs, null) : this.dp.getNumber(key, null);
                     if (typeof v === 'number' && Number.isFinite(v)) return v;
+                    continue;
                 }
             } catch (_e) {
-                // ignore
+                // ignore and try the raw cache fallback for unregistered aliases below
             }
             const c = this._readCacheNumber(key, null);
             if (typeof c === 'number' && Number.isFinite(c)) return c;
@@ -515,13 +522,15 @@ class HeatingRodControlModule extends BaseModule {
         for (const key of list) {
             if (!key) continue;
             try {
-                if (this.dp && this.dp.getEntry && this.dp.getEntry(key)) {
+                const hasDpEntry = !!(this.dp && this.dp.getEntry && this.dp.getEntry(key));
+                if (hasDpEntry) {
                     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;
+                    continue;
                 }
             } catch (_e) {
-                // ignore
+                // ignore and try the raw cache fallback for unregistered aliases below
             }
             const raw = this._readCacheRaw(key, null);
             if (raw === null || raw === undefined) continue;
@@ -559,6 +568,7 @@ class HeatingRodControlModule extends BaseModule {
             storageDischargeHoldSec: pickNum(['storageDischargeHoldSec', 'storageDischargeTripSec', 'pvStorageDischargeHoldSec'], 15, 0, 3600),
             hardStorageDischargeW: pickNum(['hardStorageDischargeW', 'pvHardStorageDischargeW'], 1200, 0, 1000000),
             budgetSafetyReserveW: pickNum(['budgetSafetyReserveW', 'pvSafetyReserveW'], 150, 0, 1000000),
+            stageUpDelaySec: pickNum(['stageUpDelaySec', 'budgetStageUpDelaySec', 'pvStageUpDelaySec'], 10, 0, 3600),
         };
     }
 
@@ -575,8 +585,22 @@ class HeatingRodControlModule extends BaseModule {
 
         const batteryPowerW = this._readNumberAny(['batteryPower'], staleMs, null);
         if (typeof batteryPowerW === 'number' && Number.isFinite(batteryPowerW)) {
-            if (batteryPowerW < 0 && chargeW <= 0) chargeW = Math.max(0, Math.abs(batteryPowerW));
-            if (batteryPowerW > 0 && dischargeW <= 0) dischargeW = Math.max(0, Math.abs(batteryPowerW));
+            const signedW = Math.round(batteryPowerW);
+            const noiseW = 25;
+            // batteryPower is the canonical direction signal in this adapter:
+            // +W = discharge, -W = charge. Prefer that direction over separate
+            // charge/discharge aliases, because those can be delayed or vendor-specific.
+            // Otherwise a charging battery can look like discharge and block stage-up.
+            if (signedW < -noiseW) {
+                chargeW = Math.max(chargeW, Math.abs(signedW));
+                dischargeW = 0;
+            } else if (signedW > noiseW) {
+                dischargeW = Math.max(dischargeW, signedW);
+                chargeW = 0;
+            } else {
+                chargeW = 0;
+                dischargeW = 0;
+            }
         }
 
         const socPct = this._readNumberAny([
@@ -637,6 +661,13 @@ class HeatingRodControlModule extends BaseModule {
         const storageReserveW = (storageKnown && !(typeof storage.socPct === 'number' && storage.socPct >= storageTargetSocPct))
             ? storageReserveCfgW
             : 0;
+        // Speicherreserve sauber bilanzieren: Was der Speicher bereits lädt, erfüllt zuerst
+        // die Reserve. Nur die noch fehlende Reserve wird vom Heizstab-Budget abgezogen;
+        // Speicherladung oberhalb der Reserve darf als nutzbarer PV-Überschuss gelten.
+        const storageReserveMissingW = Math.max(0, storageReserveW - Math.max(0, storage.chargeW));
+        const storageChargeUsableW = storageReserveW > 0
+            ? Math.max(0, Math.max(0, storage.chargeW) - storageReserveW)
+            : Math.max(0, storage.chargeW);
 
         // 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.
@@ -678,10 +709,15 @@ class HeatingRodControlModule extends BaseModule {
             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;
+                // The EVCS PV gate reports the currently visible PV surplus. For Heizstab
+                // targeting this is a total flexible-load budget: keep the already running
+                // Heizstab stage in the budget and only reserve actual battery charging power.
+                // A storage reserve must not blindly eat visible NVP export, otherwise the rod
+                // can get stuck on stage 1 although several kW are still exported.
+                cmPvGateW = Math.max(0, best.w - evcsUsedW + currentW + storageChargeUsableW - storage.dischargeW - storageReserveMissingW - gateCfg.budgetSafetyReserveW);
+                cmPvGateSource = `${best.k}+nvp-follow`;
             } else if (cmPvAvailable === false && finite(cmPvCapEffectiveRaw)) {
-                cmPvGateW = Math.max(0, currentW - storageReserveW - gateCfg.budgetSafetyReserveW);
+                cmPvGateW = Math.max(0, currentW - storageReserveMissingW - gateCfg.budgetSafetyReserveW);
                 cmPvGateSource = 'cm.pvAvailable.false_hold_only';
             }
         }
@@ -690,10 +726,11 @@ class HeatingRodControlModule extends BaseModule {
         // 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 usableStorageChargeForNvpW = storageChargeUsableW;
         const nvpSurplusBeforeFlexW = gridKnown
-            ? Math.max(0, exportW + currentW + storage.chargeW - storage.dischargeW - importExcessW)
+            ? Math.max(0, exportW + currentW + usableStorageChargeForNvpW - storage.dischargeW - importExcessW)
             : 0;
-        const nvpAvailableW = Math.max(0, nvpSurplusBeforeFlexW - storageReserveW - gateCfg.budgetSafetyReserveW);
+        const nvpAvailableW = Math.max(0, nvpSurplusBeforeFlexW - storageReserveMissingW - gateCfg.budgetSafetyReserveW);
 
         let pvBudgetGateW = nvpAvailableW;
         let pvBudgetSource = gridKnown ? 'nvp+ownLoad+storageReserve' : 'no-fresh-nvp';
@@ -746,7 +783,11 @@ class HeatingRodControlModule extends BaseModule {
             nonPvEnergyActive,
             storageSocPct: storage.socPct,
             storageReserveW,
+            storageReserveMissingW,
+            storageChargeUsableW,
             storageTargetSocPct,
+            usableStorageChargeForNvpW,
+            stageUpDelaySec: gateCfg.stageUpDelaySec,
             nvpSurplusBeforeFlexW,
             cmAvailableW: (cmPvGateW !== null && Number.isFinite(cmPvGateW)) ? Math.max(0, cmPvGateW) : 0,
             nvpAvailableW,
@@ -1159,26 +1200,84 @@ class HeatingRodControlModule extends BaseModule {
         return prev;
     }
 
-    _computeDesiredStage(d, remainingW, currentStage) {
+    _stagePowerScale(d, observedStage = 0, measuredW = null) {
+        const st = (d && d.id && this._stageCtl && this._stageCtl.get) ? (this._stageCtl.get(d.id) || null) : null;
+        const learned = st && Number.isFinite(Number(st.stagePowerScale)) ? clamp(Number(st.stagePowerScale), 0.25, 4) : 1;
+        const obs = Math.max(0, Math.min(Math.round(Number(observedStage) || 0), d && d.stages ? d.stages.length : 0));
+        const measured = Number(measuredW);
+        if (obs <= 0 || !Number.isFinite(measured) || measured <= 50) return learned;
+        const configuredW = Math.max(0, this._sumStagePower(d, obs));
+        if (configuredW <= 50) return learned;
+        const ratio = measured / configuredW;
+        if (!Number.isFinite(ratio) || ratio <= 0) return learned;
+        // Clamp keeps a noisy meter from destroying the stage model, but still corrects
+        // common setups where the configured default says 2 kW/stage and the real rod is 1 kW/stage.
+        const scale = clamp(ratio, 0.25, 4);
+        if (d && d.id && this._stageCtl && this._stageCtl.set) {
+            const next = Object.assign({}, st || { targetStage: obs, lastIncreaseMs: 0, lastDecreaseMs: 0 }, { stagePowerScale: scale });
+            this._stageCtl.set(d.id, next);
+        }
+        return scale;
+    }
+
+    _sumStagePowerModel(d, stageCount, observedStage = 0, measuredW = null) {
+        const configuredW = this._sumStagePower(d, stageCount);
+        const scale = this._stagePowerScale(d, observedStage, measuredW);
+        return this._capDevicePower(d, Math.round(configuredW * scale));
+    }
+
+    _stageThresholdModel(d, stageIndexZeroBased, key, observedStage = 0, measuredW = null, fallbackStageCount = null) {
+        const stage = d && d.stages ? d.stages[stageIndexZeroBased] : null;
+        const scale = this._stagePowerScale(d, observedStage, measuredW);
+        const raw = stage && Number.isFinite(Number(stage[key])) ? Math.max(0, Number(stage[key])) : null;
+        if (raw !== null) return Math.round(raw * scale);
+        const cnt = fallbackStageCount !== null ? fallbackStageCount : (stageIndexZeroBased + 1);
+        return this._sumStagePowerModel(d, cnt, observedStage, measuredW);
+    }
+
+    _computeDesiredStage(d, remainingW, currentStage, measuredW = null) {
         let stage = Math.max(0, Math.min(Math.round(Number(currentStage) || 0), d.stageCount));
+        const budgetW = Math.max(0, Math.round(num(remainingW, 0)));
 
         while (stage > 0) {
-            const cfg = d.stages[stage - 1];
-            if (!cfg) break;
-            if (remainingW < Math.max(0, num(cfg.offBelowW, 0))) stage--;
+            const offBelowW = this._stageThresholdModel(d, stage - 1, 'offBelowW', currentStage, measuredW, stage);
+            if (budgetW < Math.max(0, offBelowW)) stage--;
             else break;
         }
 
         while (stage < d.stageCount) {
-            const cfg = d.stages[stage];
-            if (!cfg) break;
-            if (remainingW >= Math.max(0, num(cfg.onAboveW, 0))) stage++;
+            const thresholdCfgW = this._stageThresholdModel(d, stage, 'onAboveW', currentStage, measuredW, stage + 1);
+            const nextPowerW = this._sumStagePowerModel(d, stage + 1, currentStage, measuredW);
+            // Use the lower of the explicit threshold and the learned real cumulative power.
+            // This lets PV-Auto follow the real hardware when the default/configured stage
+            // power is too high, without breaking installers that intentionally entered
+            // higher thresholds for hysteresis.
+            const onAboveW = Math.max(0, Math.min(thresholdCfgW, nextPowerW || thresholdCfgW));
+            if (budgetW >= onAboveW) stage++;
             else break;
         }
 
         return Math.max(0, Math.min(stage, d.stageCount));
     }
 
+    _limitBudgetStageStepUp(d, desiredStage, observedStage, now) {
+        const cfg = this._getBudgetGateCfg();
+        const st = this._ensureStageCtlState(d.id, observedStage);
+        const base = Math.max(0, Math.min(Math.round(Number(st.targetStage ?? observedStage) || 0), d.stageCount));
+        let target = Math.max(0, Math.min(Math.round(Number(desiredStage) || 0), d.stageCount));
+        if (target <= base) return target;
+
+        const nextPhysical = this._nextPhysicalStageAbove(d, base);
+        if (nextPhysical > base) target = Math.min(target, nextPhysical);
+        const waitMs = Math.max(0, Math.round(num(cfg.stageUpDelaySec, 10) * 1000));
+        const lastUp = Math.max(num(st.budgetLastStepUpMs, 0), num(st.lastIncreaseMs, 0));
+        if (waitMs > 0 && lastUp > 0 && (now - lastUp) < waitMs) return base;
+
+        st.budgetLastStepUpMs = now;
+        this._stageCtl.set(d.id, st);
+        return target;
+    }
+
     _applyTiming(d, desiredStage, observedStage) {
         const st = this._ensureStageCtlState(d.id, observedStage);
         const now = nowMs();
@@ -1209,7 +1308,7 @@ class HeatingRodControlModule extends BaseModule {
         return currentStage;
     }
 
-    _applyZeroExportStageStrategy(d, desiredStage, observedStage, pvBase, zeroInfo, now) {
+    _applyZeroExportStageStrategy(d, desiredStage, observedStage, pvBase, zeroInfo, now, measuredW = null) {
         const info = zeroInfo || this._computeZeroExportInfo(pvBase);
         const cfg = (info && info.cfg) ? info.cfg : this._getZeroExportCfg();
         const st = this._ensureStageCtlState(d.id, observedStage);
@@ -1359,8 +1458,8 @@ 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);
+                const basePowerW = this._sumStagePowerModel(d, baseStage, observedStage, measuredW);
+                const nextPowerW = this._sumStagePowerModel(d, nextStage, observedStage, measuredW);
                 targetStage = Math.max(targetStage, nextStage);
                 st.zeroLastStepUpMs = now;
                 st.zeroProbe = {
@@ -1783,7 +1882,7 @@ class HeatingRodControlModule extends BaseModule {
                 continue;
             }
 
-            let desiredStage = this._computeDesiredStage(d, remainingW, observedStage);
+            let desiredStage = this._computeDesiredStage(d, remainingW, observedStage, measuredW);
             let zeroDecision = null;
 
             // Wenn der Budget-Gate-Schutz gerade einen Netzbezug/Speicherbezug beobachtet,
@@ -1791,6 +1890,8 @@ class HeatingRodControlModule extends BaseModule {
             // laufen, damit PV/FEMS sauber nachregeln kann.
             if (budgetProtection && budgetProtection.watchActive && desiredStage > observedStage) {
                 desiredStage = observedStage;
+            } else if (desiredStage > observedStage) {
+                desiredStage = this._limitBudgetStageStepUp(d, desiredStage, observedStage, now);
             }
 
             // 0-/Minus-Einspeiseanlagen verstecken PV-Überschuss am Netzpunkt, weil der
@@ -1799,7 +1900,7 @@ class HeatingRodControlModule extends BaseModule {
             // Speicher-SOC und Einspeiselimit zusammenpassen. Danach entscheidet der Netzpunkt:
             // Netzbezug oder Speicherentladung -> schnell reduzieren; stabil PV -> halten/weiter prüfen.
             if (zeroExportInfo.active) {
-                zeroDecision = this._applyZeroExportStageStrategy(d, desiredStage, observedStage, pvBase, zeroExportInfo, now);
+                zeroDecision = this._applyZeroExportStageStrategy(d, desiredStage, observedStage, pvBase, zeroExportInfo, now, measuredW);
                 desiredStage = Math.max(0, Math.min(num(zeroDecision.targetStage, desiredStage), d.stageCount));
                 await this._setStateIfChanged(`heatingRod.devices.${d.id}.zeroExportReason`, String(zeroDecision.reason || zeroExportInfo.reason || ''));
                 await this._setStateIfChanged(`heatingRod.devices.${d.id}.zeroExportNextAllowedAt`, Math.round(num(zeroDecision.nextAllowedAt, 0)));
@@ -1829,7 +1930,7 @@ class HeatingRodControlModule extends BaseModule {
             const forcePvWrite = !!(forceStorageProtectOff || forceNonPvDown || (targetStage <= 0 && ((typeof measuredW === 'number' && Number.isFinite(measuredW) && measuredW > 50) || Math.max(0, feedback.appliedPowerW || 0) > 0)));
             const res = await this._applyStageState(d, targetStage, feedback, { force: forcePvWrite });
             const effectiveTargetStage = Math.max(0, Math.min(num(res.targetStage, targetStage), d.wiredStages));
-            const targetW = this._sumStagePower(d, effectiveTargetStage);
+            const targetW = this._sumStagePowerModel(d, effectiveTargetStage, observedStage, measuredW);
             const usedW = (typeof measuredW === 'number' && Number.isFinite(measuredW) && measuredW > 0)
                 ? Math.max(0, measuredW)
                 : targetW;
@@ -1900,8 +2001,12 @@ class HeatingRodControlModule extends BaseModule {
             nonPvEnergyActive: !!pvBase.nonPvEnergyActive,
             storageSocPct: pvBase.storageSocPct,
             storageReserveW: Math.round(num(pvBase.storageReserveW, 0)),
+            storageReserveMissingW: Math.round(num(pvBase.storageReserveMissingW, 0)),
+            storageChargeUsableW: Math.round(num(pvBase.storageChargeUsableW, 0)),
             storageTargetSocPct: pvBase.storageTargetSocPct,
             nvpSurplusBeforeFlexW: Math.round(num(pvBase.nvpSurplusBeforeFlexW, 0)),
+            usableStorageChargeForNvpW: Math.round(num(pvBase.usableStorageChargeForNvpW, 0)),
+            stageUpDelaySec: Math.round(num(pvBase.stageUpDelaySec, 0)),
             nvpAvailableW: Math.round(num(pvBase.nvpAvailableW, 0)),
             cmAvailableW: Math.round(num(pvBase.cmAvailableW, 0)),
             availableW: Math.round(num(pvBase.availableW, 0)),

package/io-package.json

@@ -1,8 +1,25 @@
 {
   "common": {
     "name": "nexowatt-ui",
-    "version": "0.7.2",
+    "version": "0.7.4",
     "news": {
+      "0.7.4": {
+        "en": "Heating rod PV-Auto now follows the PV/NVP budget as a discrete budget-gate consumer: visible NVP export and usable storage charge above the reserve are used for stage targeting, running rod load is kept in the budget, and stage power can be learned from measured rod power so wrong default stage sizes no longer block higher stages. A configurable budget stage-up delay was added; charging management and storage control were not changed. The storage reserve is now evaluated as missing reserve: storage charge above the reserve is usable while missing reserve remains withheld.",
+        "de": "Heizstab-PV-Auto folgt jetzt dem PV-/NVP-Budget als diskreter Budget-Gate-Verbraucher: sichtbare NVP-Einspeisung und nutzbare Speicherladung oberhalb der Reserve fließen in die Stufenzielberechnung ein, laufende Heizstableistung bleibt im Budget, und die reale Stufenleistung kann aus der gemessenen Heizstableistung gelernt werden. Dadurch blockieren falsche Default-Stufengrößen kein Hochfahren mehr. Eine einstellbare Budget-Stufe-hoch-Wartezeit wurde ergänzt; Lade-/Lastmanagement und Speicherregelung wurden nicht geändert. Die Speicherreserve wird als fehlende Reserve bewertet: bereits vorhandene Speicherladung oberhalb der Reserve wird nutzbar, fehlende Reserve bleibt zurückgehalten."
+      },
+      "0.7.3": {
+        "en": "PV gate diagnostics are now calculated continuously for downstream apps such as heating rod control. Heating rod PV budget no longer falls back to stale raw cache values when registered datapoints are stale.",
+        "de": "PV-Gate-Diagnose wird jetzt dauerhaft für nachgelagerte Apps wie die Heizstabsteuerung berechnet. Die Heizstab-PV-Freigabe fällt bei stale registrierten Datenpunkten nicht mehr auf alte Rohcache-Werte zurück.",
+        "ru": "Диагностика PV Gate теперь рассчитывается постоянно для downstream-приложений, например управления ТЭНом. PV-бюджет ТЭНа больше не использует устаревшие значения raw cache для stale зарегистрированных datapoints.",
+        "pt": "O diagnóstico PV Gate agora é calculado continuamente para apps posteriores, como o controlo do aquecedor. O orçamento PV do aquecedor já não recorre a valores antigos do raw cache quando datapoints registados estão stale.",
+        "nl": "PV Gate-diagnose wordt nu continu berekend voor downstream apps zoals de verwarmingsstaafregeling. Het PV-budget van de verwarmingsstaaf valt bij stale geregistreerde datapunten niet meer terug op oude raw-cachewaarden.",
+        "fr": "Le diagnostic PV Gate est désormais calculé en continu pour les applications aval comme la commande de résistance chauffante. Le budget PV de la résistance ne retombe plus sur d’anciennes valeurs de cache brut quand des datapoints enregistrés sont périmés.",
+        "it": "La diagnostica PV Gate ora viene calcolata continuamente per app a valle come il controllo della resistenza. Il budget PV della resistenza non usa più vecchi valori raw cache quando datapoint registrati risultano stale.",
+        "es": "El diagnóstico PV Gate ahora se calcula continuamente para apps posteriores como el control del calentador. El presupuesto PV del calentador ya no vuelve a valores antiguos de caché bruto cuando los datapoints registrados están obsoletos.",
+        "pl": "Diagnostyka PV Gate jest teraz liczona stale dla aplikacji downstream, np. sterowania grzałką. Budżet PV grzałki nie wraca już do starych wartości raw cache, gdy zarejestrowane datapointy są stale.",
+        "uk": "Діагностика PV Gate тепер розраховується постійно для downstream-додатків, наприклад керування ТЕНом. PV-бюджет ТЕНа більше не використовує застарілі значення raw cache для stale зареєстрованих datapoints.",
+        "zh-cn": "PV Gate 诊断现在会为加热棒控制等下游应用持续计算。注册数据点过期时，加热棒 PV 预算不再回退到旧的原始缓存值。"
+      },
       "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."
@@ -1822,8 +1839,12 @@
     }
   },
   "instanceObjects": [],
-  "version": "0.7.1",
+  "version": "0.7.4",
   "news": {
+    "0.7.4": {
+      "en": "Heating rod PV-Auto now follows the PV/NVP budget as a discrete budget-gate consumer. Visible NVP export, running rod load and usable storage charge above the reserve are used for stage targeting; measured rod power can correct wrong default stage sizes. Charging management and storage control were not changed. The storage reserve is evaluated as missing reserve.",
+      "de": "Heizstab-PV-Auto folgt jetzt dem PV-/NVP-Budget als diskreter Budget-Gate-Verbraucher. Sichtbare NVP-Einspeisung, laufende Heizstableistung und nutzbare Speicherladung oberhalb der Reserve werden für die Stufenzielberechnung genutzt; gemessene Heizstableistung kann falsche Default-Stufengrößen korrigieren. Lade-/Lastmanagement und Speicherregelung wurden nicht geändert. Die Speicherreserve wird als fehlende Reserve bewertet."
+    },
     "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."

package/package.json

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

package/www/ems-apps.js

@@ -1685,6 +1685,7 @@ function _collectFlowPowerDpIsWFromUI() {
       storageDischargeHoldSec: ['storageDischargeHoldSec', 'storageDischargeTripSec'],
       hardStorageDischargeW: ['hardStorageDischargeW'],
       budgetSafetyReserveW: ['budgetSafetyReserveW', 'pvSafetyReserveW'],
+      stageUpDelaySec: ['stageUpDelaySec', 'budgetStageUpDelaySec', 'pvStageUpDelaySec'],
     };
     const hn = (key, def, min, max) => {
       let raw = h[key];
@@ -1706,6 +1707,7 @@ function _collectFlowPowerDpIsWFromUI() {
     hn('storageDischargeHoldSec', 15, 0, 3600);
     hn('hardStorageDischargeW', 1200, 0, 1000000);
     hn('budgetSafetyReserveW', 150, 0, 1000000);
+    hn('stageUpDelaySec', 10, 0, 3600);
     h.zeroExport = (h.zeroExport && typeof h.zeroExport === 'object') ? h.zeroExport : {};
     const z = h.zeroExport;
     const zn = (key, def, min, max, integer = true) => {
@@ -2121,6 +2123,7 @@ function _collectFlowPowerDpIsWFromUI() {
     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.'));
+    grpGate.body.appendChild(_mkCfgField('Stufe-hoch Wartezeit (s)', _mkCfgInput('number', cfg.stageUpDelaySec, (v) => { cfg.stageUpDelaySec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '150px' }), 'PV-Budgetfolger: erhöht maximal eine physische Heizstab-Stufe je Wartezeit. Reduzieren bleibt schnell, wenn Netzbezug/Speicherentladung dauerhaft überschritten wird.'));
     els.heatingRodDevices.appendChild(grpGate.wrap);
 
     const zeroCfg = cfg.zeroExport || {};

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-v172';
+const CACHE_NAME = 'nexowatt-cache-v174';
 
 const OFFLINE_URLS = [
   './',