iobroker.nexowatt-ui 0.7.13 → 0.7.14

package/ems/modules/charging-management.js

@@ -2193,6 +2193,27 @@ class ChargingManagementModule extends BaseModule {
             // ignore
         }
 
+        // Gate E – Negativpreis / Netzbezug bevorzugt:
+        // Wenn der dynamische effektive Tarif negativ ist, darf das Lade-/Lastmanagement
+        // Netzladen freigeben und PV-only nur für Auto/Global-Modi aufheben. Harte Limits
+        // (Netzanschluss, Phasen, §14a, Peak-Shaving) bleiben weiter aktiv.
+        let tariffNegativeActive = false;
+        let tariffGridImportPreferred = false;
+        try {
+            const stNeg = await this._getStateCached('tarif.negativpreisAktiv');
+            const stPref = await this._getStateCached('tarif.netzbezugBevorzugt');
+            tariffNegativeActive = stNeg ? !!stNeg.val : false;
+            tariffGridImportPreferred = stPref ? !!stPref.val : tariffNegativeActive;
+        } catch {
+            tariffNegativeActive = false;
+            tariffGridImportPreferred = false;
+        }
+
+        if (tariffGridImportPreferred) {
+            gridChargeAllowedRaw = true;
+            dischargeAllowedRaw = false;
+        }
+
         // Debounce gegen Flattern:
         // - Sperren (false) wirken sofort (Safety-first)
         // - Freigaben (true) erst nach stabiler True-Phase (hold)
@@ -2243,7 +2264,11 @@ class ChargingManagementModule extends BaseModule {
         }
 
         // Global default PV-only behaviour (same as before)
-        const pvSurplusOnlyCfg = cfg.pvSurplusOnly === true || mode === 'pvSurplus';
+        const pvSurplusOnlyCfgBase = cfg.pvSurplusOnly === true || mode === 'pvSurplus';
+        // Bei Negativpreis wird Netzbezug wirtschaftlich bevorzugt. Deshalb darf die
+        // globale PV-only-Vorgabe im Automatikpfad temporär aufgehoben werden. Explizite
+        // Wallbox-Modi wie "PV" bleiben User-Wunsch und werden weiter respektiert.
+        const pvSurplusOnlyCfg = tariffGridImportPreferred ? false : pvSurplusOnlyCfgBase;
         const forcePvSurplusOnly = !gridChargeAllowed;
 
         // Determine effective per-wallbox mode (runtime override via VIS)
@@ -2339,7 +2364,8 @@ class ChargingManagementModule extends BaseModule {
 
                         let allowGrid = true;
                         if (active) {
-                            if (state === 'teuer') allowGrid = false;
+                            if (p < -1e-9) allowGrid = true;
+                            else if (state === 'teuer') allowGrid = false;
                             else if (state === 'guenstig') allowGrid = !!allowEvcsCheap;
                             else allowGrid = true;
                         }
@@ -2559,13 +2585,15 @@ class ChargingManagementModule extends BaseModule {
                 // (Hard limits like §14a / Grid caps / Phase caps still apply later in the pipeline.)
                 eff = 'boost';
             } else if (override === 'pv') {
-                eff = 'pv';
+                // Gate E: Bei negativem dynamischem Tarif wird Netzbezug bewusst bevorzugt.
+                // Dann heben wir auch den PV-Modus temporär auf, damit die Ladepunkte
+                // wirtschaftlich Netzstrom abnehmen können. Harte Netz-/Phasen-/§14a-
+                // Grenzen bleiben weiter aktiv.
+                eff = tariffGridImportPreferred ? 'normal' : 'pv';
             } else if (override === 'minpv') {
-                // "Min+PV" is an explicit user mode:
-                // - always keep the minimum charging power active (even if PV=0)
-                // - additional power beyond the technical minimum is still limited by PV surplus
-                // Therefore we do NOT force it to pure PV mode, even when tariff policy blocks grid-charging.
-                eff = 'minpv';
+                // "Min+PV" hält normalerweise die Mindestladung und begrenzt Mehrleistung auf PV.
+                // Bei Negativpreis wird daraus temporär ein normaler netzfreigegebener Modus.
+                eff = tariffGridImportPreferred ? 'normal' : 'minpv';
             } else {
                 // auto: follow global defaults
                 eff = (forcePvForW || pvSurplusOnlyCfg) ? 'pv' : 'normal';
@@ -3008,6 +3036,9 @@ if (components.length) {
                 engine: true,
                 mode,
                 pvSurplusOnlyCfg,
+                pvSurplusOnlyCfgBase,
+                tariffNegativeActive,
+                tariffGridImportPreferred,
                 forcePvSurplusOnly,
                 gridChargeAllowed,
                 dischargeAllowed,

package/ems/modules/core-limits.js

@@ -220,6 +220,12 @@ class CoreLimitsModule extends BaseModule {
             native: {},
         });
 
+        await this.adapter.setObjectNotExistsAsync('ems.budget.tariff', {
+            type: 'channel',
+            common: { name: 'Budget Gate E - Tarif / Negativpreis' },
+            native: {},
+        });
+
         const mk = async (id, name, type, role, unit = undefined, write = false) => {
             await this.adapter.setObjectNotExistsAsync(id, {
                 type: 'state',
@@ -307,6 +313,24 @@ class CoreLimitsModule extends BaseModule {
         await mk('ems.budget.forecast.source', 'PV forecast source', 'string', 'text');
         await mk('ems.budget.forecast.snapshotJson', 'PV forecast gate snapshot (JSON)', 'string', 'json');
 
+        // Gate E - Tarif / Negativpreis. Advisory + permission gate for price-aware control.
+        // It does not bypass hard grid/phase/§14a/peak limits; it only tells apps that
+        // grid import is economically preferred during negative effective prices.
+        await mk('ems.budget.tariff.active', 'Tariff gate active', 'boolean', 'indicator');
+        await mk('ems.budget.tariff.state', 'Tariff state', 'string', 'text');
+        await mk('ems.budget.tariff.currentPriceEurKwh', 'Current tariff price (€/kWh)', 'number', 'value');
+        await mk('ems.budget.tariff.negativeActive', 'Negative price active', 'boolean', 'indicator');
+        await mk('ems.budget.tariff.gridImportPreferred', 'Grid import preferred', 'boolean', 'indicator');
+        await mk('ems.budget.tariff.storageGridChargeAllowed', 'Storage grid charge allowed by tariff', 'boolean', 'indicator');
+        await mk('ems.budget.tariff.evcsGridChargeAllowed', 'EVCS grid charge allowed by tariff', 'boolean', 'indicator');
+        await mk('ems.budget.tariff.dischargeAllowed', 'Discharge allowed by tariff', 'boolean', 'indicator');
+        await mk('ems.budget.tariff.pvCurtailRecommended', 'PV curtailment recommended by tariff', 'boolean', 'indicator');
+        await mk('ems.budget.tariff.negativeMinPriceEurKwh', 'Minimum negative price in horizon (€/kWh)', 'number', 'value');
+        await mk('ems.budget.tariff.nextNegativeFrom', 'Next negative price window from (ISO)', 'string', 'text');
+        await mk('ems.budget.tariff.nextNegativeTo', 'Next negative price window to (ISO)', 'string', 'text');
+        await mk('ems.budget.tariff.status', 'Tariff gate status', 'string', 'text');
+        await mk('ems.budget.tariff.snapshotJson', 'Tariff gate snapshot (JSON)', 'string', 'json');
+
         // Per-consumer diagnostics for currently supported app families.
         for (const key of ['evcs', 'thermal', 'heatingRod', 'generic']) {
             await this.adapter.setObjectNotExistsAsync(`ems.budget.consumers.${key}`, {
@@ -577,6 +601,25 @@ class CoreLimitsModule extends BaseModule {
         // provider JSON separately. It does not alter instantaneous PV budget here.
         const forecastGate = this._makeForecastGate(now);
 
+        // Gate E: tariff/negative-price gate. This is advisory for all apps and
+        // permission-like for modules that already consume tariff flags.
+        const tSrc = (coreSnapshot && coreSnapshot.tariff && typeof coreSnapshot.tariff === 'object') ? coreSnapshot.tariff : {};
+        const tariffGate = {
+            active: !!tSrc.active,
+            state: String(tSrc.state || ''),
+            currentPriceEurKwh: isFiniteNumber(tSrc.currentPriceEurKwh) ? Number(tSrc.currentPriceEurKwh) : null,
+            negativeActive: !!tSrc.negativeActive,
+            gridImportPreferred: !!tSrc.gridImportPreferred,
+            storageGridChargeAllowed: !!tSrc.storageGridChargeAllowed,
+            evcsGridChargeAllowed: !!tSrc.evcsGridChargeAllowed,
+            dischargeAllowed: tSrc.dischargeAllowed !== false,
+            pvCurtailRecommended: !!tSrc.pvCurtailRecommended,
+            negativeMinPriceEurKwh: isFiniteNumber(tSrc.negativeMinPriceEurKwh) ? Number(tSrc.negativeMinPriceEurKwh) : null,
+            nextNegativeFrom: String(tSrc.nextNegativeFrom || ''),
+            nextNegativeTo: String(tSrc.nextNegativeTo || ''),
+            status: String(tSrc.status || (tSrc.gridImportPreferred ? 'grid_import_preferred' : (tSrc.active ? 'active' : 'inactive'))),
+        };
+
         return {
             ts: now,
             active: true,
@@ -614,6 +657,7 @@ class CoreLimitsModule extends BaseModule {
                     dischargeW: roundW(storageDischargeW),
                 },
                 forecast: forecastGate,
+                tariff: tariffGate,
                 total: {
                     effectiveW: Number.isFinite(totalBudgetW) ? roundW(totalBudgetW) : null,
                     binding: bindings.join('+'),
@@ -708,6 +752,16 @@ class CoreLimitsModule extends BaseModule {
         const gridChargeAllowed = await readStateBool(this.adapter, 'tarif.netzLadenErlaubt', true);
         const dischargeAllowed = await readStateBool(this.adapter, 'tarif.entladenErlaubt', true);
 
+        const tariffActive = await readStateBool(this.adapter, 'tarif.aktiv', false);
+        const tariffState = await readStateString(this.adapter, 'tarif.state', '');
+        const tariffCurrentPrice = await readStateNumber(this.adapter, 'tarif.preisAktuellEurProKwh', null);
+        const tariffNegativeActive = await readStateBool(this.adapter, 'tarif.negativpreisAktiv', false);
+        const tariffGridImportPreferred = await readStateBool(this.adapter, 'tarif.netzbezugBevorzugt', tariffNegativeActive);
+        const tariffNegativeMinPrice = await readStateNumber(this.adapter, 'tarif.negativPreisMinEurProKwh', null);
+        const tariffNextNegativeFrom = await readStateString(this.adapter, 'tarif.naechstesNegativVon', '');
+        const tariffNextNegativeTo = await readStateString(this.adapter, 'tarif.naechstesNegativBis', '');
+        const tariffStatus = await readStateString(this.adapter, 'tarif.negativpreisStatus', '');
+
         const p14a = (this.adapter && this.adapter._para14a && typeof this.adapter._para14a === 'object') ? this.adapter._para14a : null;
 
         let para14aActive = false;
@@ -771,6 +825,18 @@ class CoreLimitsModule extends BaseModule {
                 budgetW: (typeof tariffBudgetW === 'number') ? tariffBudgetW : null,
                 gridChargeAllowed: !!gridChargeAllowed,
                 dischargeAllowed: !!dischargeAllowed,
+                active: !!tariffActive,
+                state: tariffState || '',
+                currentPriceEurKwh: isFiniteNumber(tariffCurrentPrice) ? Number(tariffCurrentPrice) : null,
+                negativeActive: !!tariffNegativeActive,
+                gridImportPreferred: !!tariffGridImportPreferred,
+                storageGridChargeAllowed: !!(tariffGridImportPreferred && gridChargeAllowed),
+                evcsGridChargeAllowed: !!(tariffGridImportPreferred && gridChargeAllowed),
+                pvCurtailRecommended: !!tariffGridImportPreferred,
+                negativeMinPriceEurKwh: isFiniteNumber(tariffNegativeMinPrice) ? Number(tariffNegativeMinPrice) : null,
+                nextNegativeFrom: tariffNextNegativeFrom || '',
+                nextNegativeTo: tariffNextNegativeTo || '',
+                status: tariffStatus || (tariffGridImportPreferred ? 'active_grid_import_preferred' : (tariffNegativeActive ? 'negative_detected' : 'inactive')),
             },
             para14a: {
                 active: !!para14aActive,
@@ -790,6 +856,7 @@ class CoreLimitsModule extends BaseModule {
             this.adapter._emsCaps = snapshot;
             this.adapter._emsBudget = budgetRuntime;
             this.adapter._emsForecastGate = budgetSnapshot && budgetSnapshot.gates ? budgetSnapshot.gates.forecast : null;
+            this.adapter._emsTariffGate = budgetSnapshot && budgetSnapshot.gates ? budgetSnapshot.gates.tariff : null;
         } catch {
             // ignore
         }
@@ -862,6 +929,22 @@ class CoreLimitsModule extends BaseModule {
             await this.adapter.setStateAsync('ems.budget.forecast.source', String(fg.source || ''), true);
             await this.adapter.setStateAsync('ems.budget.forecast.snapshotJson', JSON.stringify(fg), true);
 
+            const tg = (b.gates && b.gates.tariff) ? b.gates.tariff : {};
+            await this.adapter.setStateAsync('ems.budget.tariff.active', !!tg.active, true);
+            await this.adapter.setStateAsync('ems.budget.tariff.state', String(tg.state || ''), true);
+            await this.adapter.setStateAsync('ems.budget.tariff.currentPriceEurKwh', tg.currentPriceEurKwh === null || tg.currentPriceEurKwh === undefined ? null : Number(tg.currentPriceEurKwh), true);
+            await this.adapter.setStateAsync('ems.budget.tariff.negativeActive', !!tg.negativeActive, true);
+            await this.adapter.setStateAsync('ems.budget.tariff.gridImportPreferred', !!tg.gridImportPreferred, true);
+            await this.adapter.setStateAsync('ems.budget.tariff.storageGridChargeAllowed', !!tg.storageGridChargeAllowed, true);
+            await this.adapter.setStateAsync('ems.budget.tariff.evcsGridChargeAllowed', !!tg.evcsGridChargeAllowed, true);
+            await this.adapter.setStateAsync('ems.budget.tariff.dischargeAllowed', tg.dischargeAllowed !== false, true);
+            await this.adapter.setStateAsync('ems.budget.tariff.pvCurtailRecommended', !!tg.pvCurtailRecommended, true);
+            await this.adapter.setStateAsync('ems.budget.tariff.negativeMinPriceEurKwh', tg.negativeMinPriceEurKwh === null || tg.negativeMinPriceEurKwh === undefined ? null : Number(tg.negativeMinPriceEurKwh), true);
+            await this.adapter.setStateAsync('ems.budget.tariff.nextNegativeFrom', String(tg.nextNegativeFrom || ''), true);
+            await this.adapter.setStateAsync('ems.budget.tariff.nextNegativeTo', String(tg.nextNegativeTo || ''), true);
+            await this.adapter.setStateAsync('ems.budget.tariff.status', String(tg.status || ''), true);
+            await this.adapter.setStateAsync('ems.budget.tariff.snapshotJson', JSON.stringify(tg), true);
+
             for (const key of ['evcs', 'thermal', 'heatingRod']) {
                 const c = b.consumers[key] || {};
                 await this.adapter.setStateAsync(`ems.budget.consumers.${key}.usedW`, roundW(c.usedW), true);
@@ -883,6 +966,12 @@ class CoreLimitsModule extends BaseModule {
                     this.adapter.updateValue('ems.budget.forecast.kwhNext6h', Number.isFinite(Number(b.gates.forecast.kwhNext6h)) ? Number(b.gates.forecast.kwhNext6h) : 0, now);
                     this.adapter.updateValue('ems.budget.forecast.usable', !!b.gates.forecast.usable, now);
                 }
+                if (b.gates && b.gates.tariff) {
+                    this.adapter.updateValue('ems.budget.tariff.negativeActive', !!b.gates.tariff.negativeActive, now);
+                    this.adapter.updateValue('ems.budget.tariff.gridImportPreferred', !!b.gates.tariff.gridImportPreferred, now);
+                    this.adapter.updateValue('ems.budget.tariff.currentPriceEurKwh', b.gates.tariff.currentPriceEurKwh, now);
+                    this.adapter.updateValue('ems.budget.tariff.status', String(b.gates.tariff.status || ''), now);
+                }
             }
         } catch {
             // ignore

package/ems/modules/grid-constraints.js

@@ -58,6 +58,17 @@ class GridConstraintsModule extends BaseModule {
         return Math.min(Math.max(n, minV), maxV);
     }
 
+    async _isTariffGridImportPreferred() {
+        try {
+            const tv = (this.adapter && this.adapter._tarifVis) ? this.adapter._tarifVis : null;
+            if (tv && (tv.gridImportPreferred || tv.netzbezugBevorzugt || tv.negativeActive)) return true;
+            const st = await this.adapter.getStateAsync('tarif.netzbezugBevorzugt');
+            return !!(st && st.val);
+        } catch {
+            return false;
+        }
+    }
+
     async init() {
         if (!this._isEnabled()) return;
 
@@ -263,7 +274,10 @@ class GridConstraintsModule extends BaseModule {
         const enabled = !!cfg.zeroExportEnabled;
         const inv = this._normalizeInvList(cfg.pvCurtailInvertersZero);
 
-        const biasW = Math.max(0, this._num(cfg.zeroExportBiasW, 80));
+        const tariffGridImportPreferred = await this._isTariffGridImportPreferred();
+        const baseBiasW = Math.max(0, this._num(cfg.zeroExportBiasW, 80));
+        const negativeBiasW = tariffGridImportPreferred ? Math.max(0, this._num(cfg.zeroExportNegativePriceImportBiasW, 1000)) : 0;
+        const biasW = tariffGridImportPreferred ? Math.max(baseBiasW, negativeBiasW) : baseBiasW;
         const deadbandW = Math.max(0, this._num(cfg.zeroExportDeadbandW, 50));
 
         await this.adapter.setStateAsync('gridConstraints.zeroExport.enabled', enabled, true);
@@ -356,7 +370,7 @@ class GridConstraintsModule extends BaseModule {
             applied = applied || (ok1 === true || ok1 === null) || (ok2 === true || ok2 === null) || (ok3 === true || ok3 === null);
         }
 
-        await this.adapter.setStateAsync('gridConstraints.zeroExport.action', fastTrip ? 'group_fast' : 'group', true);
+        await this.adapter.setStateAsync('gridConstraints.zeroExport.action', tariffGridImportPreferred ? (fastTrip ? 'tariff_negative_group_fast' : 'tariff_negative_group') : (fastTrip ? 'group_fast' : 'group'), true);
         await this.adapter.setStateAsync('gridConstraints.pvCurtail.applied', applied, true);
         await this.adapter.setStateAsync('gridConstraints.pvCurtail.setpointW', Math.round(next), true);
         await this.adapter.setStateAsync('gridConstraints.pvCurtail.setpointPct', Math.round(pct * 10) / 10, true);
@@ -461,7 +475,10 @@ class GridConstraintsModule extends BaseModule {
     async _tickZeroExport(nowMs, gridW, cfg, gridStale) {
         const enabled = !!cfg.zeroExportEnabled;
 
-        const biasW = Math.max(0, this._num(cfg.zeroExportBiasW, 80));
+        const tariffGridImportPreferred = await this._isTariffGridImportPreferred();
+        const baseBiasW = Math.max(0, this._num(cfg.zeroExportBiasW, 80));
+        const negativeBiasW = tariffGridImportPreferred ? Math.max(0, this._num(cfg.zeroExportNegativePriceImportBiasW, 1000)) : 0;
+        const biasW = tariffGridImportPreferred ? Math.max(baseBiasW, negativeBiasW) : baseBiasW;
         const deadbandW = Math.max(0, this._num(cfg.zeroExportDeadbandW, 50));
 
         await this.adapter.setStateAsync('gridConstraints.zeroExport.enabled', enabled, true);
@@ -542,7 +559,7 @@ class GridConstraintsModule extends BaseModule {
 
             const ok = await this.dp.writeNumber('pv.limitW', next, false);
 
-            await this.adapter.setStateAsync('gridConstraints.zeroExport.action', fastTrip ? 'pvLimitW_fast' : 'pvLimitW', true);
+            await this.adapter.setStateAsync('gridConstraints.zeroExport.action', tariffGridImportPreferred ? (fastTrip ? 'tariff_negative_pvLimitW_fast' : 'tariff_negative_pvLimitW') : (fastTrip ? 'pvLimitW_fast' : 'pvLimitW'), true);
             await this.adapter.setStateAsync('gridConstraints.pvCurtail.applied', ok === true || ok === null, true);
             await this.adapter.setStateAsync('gridConstraints.pvCurtail.setpointW', Math.round(next), true);
             await this.adapter.setStateAsync('gridConstraints.pvCurtail.setpointPct', 0, true);
@@ -579,7 +596,7 @@ class GridConstraintsModule extends BaseModule {
 
             const ok = await this.dp.writeNumber('pv.limitPct', next, false);
 
-            await this.adapter.setStateAsync('gridConstraints.zeroExport.action', fastTrip ? 'pvLimitPct_fast' : 'pvLimitPct', true);
+            await this.adapter.setStateAsync('gridConstraints.zeroExport.action', tariffGridImportPreferred ? (fastTrip ? 'tariff_negative_pvLimitPct_fast' : 'tariff_negative_pvLimitPct') : (fastTrip ? 'pvLimitPct_fast' : 'pvLimitPct'), true);
             await this.adapter.setStateAsync('gridConstraints.pvCurtail.applied', ok === true || ok === null, true);
             await this.adapter.setStateAsync('gridConstraints.pvCurtail.setpointW', 0, true);
             await this.adapter.setStateAsync('gridConstraints.pvCurtail.setpointPct', Math.round(next * 10) / 10, true);

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

@@ -775,6 +775,16 @@ class HeatingRodControlModule extends BaseModule {
                     pvBudgetSource = 'ems.budget.remainingPvW+ownAutoLoad';
                     pvBudgetFromCentral = true;
                 }
+
+                const tariffGate = snap.gates && snap.gates.tariff ? snap.gates.tariff : null;
+                const tariffImportPreferred = !!(tariffGate && tariffGate.gridImportPreferred);
+                if (tariffImportPreferred && Number.isFinite(remTotal) && remTotal >= 0) {
+                    // Gate E: Bei Negativpreis darf der Heizstab als aktivierter flexibler
+                    // Verbraucher Netzbudget nutzen. Gate A/A2/Peak bleiben über remTotal aktiv.
+                    pvBudgetGateW = Math.max(0, remTotal + currentW - gateCfg.budgetSafetyReserveW);
+                    pvBudgetSource = 'ems.budget.tariffNegative.remainingTotalW+ownAutoLoad';
+                    pvBudgetFromCentral = true;
+                }
             }
         } catch (_e) {
             // legacy NVP/CM fallback remains active
@@ -804,6 +814,7 @@ class HeatingRodControlModule extends BaseModule {
             budgetGateEffectiveW: Math.max(0, effectiveGateW),
             budgetGateSource: source,
             pvBudgetFromCentral: !!pvBudgetFromCentral,
+            tariffGridImportPreferred: String(pvBudgetSource || '').includes('tariffNegative'),
             cmActive,
             cmStaleMeter: !!cmStaleMeter,
             cmStaleBudget: !!cmStaleBudget,
@@ -840,7 +851,8 @@ class HeatingRodControlModule extends BaseModule {
     _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 tariffImportPreferred = !!(pvBase && pvBase.tariffGridImportPreferred);
+        const importActive = !!(!tariffImportPreferred && 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);
@@ -2072,7 +2084,7 @@ class HeatingRodControlModule extends BaseModule {
             // Global PV-Auto minimum: this is now only a start/step-up gate.
             // It must not be a hard OFF, because small cloud/PV transients would otherwise
             // kill a stable stage and external KNX/manual switching would feel broken.
-            const pvMinBlocksStepUp = !!(pvAutomationActive && !pvAutomationAllowedByMin);
+            const pvMinBlocksStepUp = !!(pvAutomationActive && !pvBase.tariffGridImportPreferred && !pvAutomationAllowedByMin);
 
             if (d.wiredStages < 1) {
                 const usedW = (typeof measuredW === 'number' && Number.isFinite(measuredW) && measuredW > 0)
@@ -2179,6 +2191,7 @@ class HeatingRodControlModule extends BaseModule {
             const rt = this.adapter && this.adapter._emsBudget;
             if (rt && typeof rt.reserve === 'function') {
                 const used = Math.max(0, Math.round(budgetUsedW || 0));
+                const tariffImportPreferred = !!(pvBase && pvBase.tariffGridImportPreferred);
                 rt.reserve({
                     key: 'heatingRod',
                     app: 'heatingRodControl',
@@ -2186,10 +2199,10 @@ class HeatingRodControlModule extends BaseModule {
                     priority: 300,
                     requestedW: used,
                     reserveW: used,
-                    pvReserveW: used,
+                    pvReserveW: tariffImportPreferred ? 0 : used,
                     actualW: Math.max(0, Math.round(currentHeatingRodW || appliedTotalW || used || 0)),
-                    pvOnly: true,
-                    mode: 'pvAuto',
+                    pvOnly: !tariffImportPreferred,
+                    mode: tariffImportPreferred ? 'tariffNegative' : 'pvAuto',
                 });
             }
         } catch (_e) {
@@ -2266,6 +2279,7 @@ class HeatingRodControlModule extends BaseModule {
                 effectiveW: Math.round(num(pvBase.budgetGateEffectiveW, 0)),
                 source: pvBase.budgetGateSource,
                 pvBudgetFromCentral: !!pvBase.pvBudgetFromCentral,
+                tariffGridImportPreferred: !!pvBase.tariffGridImportPreferred,
                 cmActive: pvBase.cmActive,
                 cmStaleMeter: !!pvBase.cmStaleMeter,
                 cmStaleBudget: !!pvBase.cmStaleBudget,

package/ems/modules/storage-control.js

@@ -1015,6 +1015,7 @@ if (typeof soc === 'number') {
 		if (targetW === 0) {
 			const tv = (this.adapter && this.adapter._tarifVis) ? this.adapter._tarifVis : null;
 			const tvAktiv = !!(tv && tv.aktiv);
+			const tariffNegativeImportPreferred = !!(tv && (tv.negativeActive || tv.gridImportPreferred || tv.netzbezugBevorzugt));
 			tarifState = (tvAktiv && typeof tv.state === 'string') ? tv.state : null;
 
 			if (tvAktiv) {
@@ -1065,7 +1066,7 @@ if (typeof soc === 'number') {
 						// Nicht gegen Einspeisung "anladen" – PV-Überschuss wird unten behandelt.
 						// Hinweis: Dadurch wird bei Einspeisung kein zusätzliches Netzladen erzwungen.
 						// (Bewusstes Design: PV-Überschuss-Laden übernimmt dann die Regelung.)
-						if (nvpNowW < 0) {
+						if (nvpNowW < 0 && !tariffNegativeImportPreferred) {
 							chargeW = 0;
 						}
 
@@ -1089,7 +1090,7 @@ if (typeof soc === 'number') {
 						let pvDebug = null;
 						try {
 						  const pf = (this.adapter && this.adapter._pvForecast) ? this.adapter._pvForecast : null;
-						  const pvReserveEnabled = (cfg.tariffPvReserveEnabled !== false); // default: ON
+						  const pvReserveEnabled = (cfg.tariffPvReserveEnabled !== false) && !tariffNegativeImportPreferred; // default: ON, bei Negativpreis bewusst aus
 						  if (pvReserveEnabled && pf && pf.valid && Array.isArray(pf.curve) && pf.curve.length) {
 						    // Bei sehr alten Forecasts lieber keine PV‑Reserve erzwingen.
 						    const maxAgeMs = 24 * 3600000;
@@ -1347,6 +1348,8 @@ if (typeof soc === 'number') {
 						targetW = -Math.max(0, chargeW);
 						if (pvBlockGridCharge) {
 							reason = pvBlockReason || 'Tarif: günstig – PV Forecast -> Netzladen gesperrt';
+						} else if (tariffNegativeImportPreferred) {
+							reason = (targetW === 0) ? 'Tarif: Negativpreis – Netzladen nicht möglich' : 'Tarif: Negativpreis – Netzladen bevorzugt';
 						} else {
 							reason = (targetW === 0) ? 'Tarif: günstig – Netzladen nicht möglich' : 'Tarif: günstig – Netzladen';
 						}

package/ems/modules/tarif-vis.js

@@ -78,6 +78,15 @@ class TarifVisModule extends BaseModule {
         await mk('tarif.statusText', 'Tarif Status (VIS)', 'string', 'text');
         await mk('tarif.netFeeEnabled', 'Zeitvariables Netzentgelt aktiv (VIS)', 'boolean', 'indicator');
         await mk('tarif.netFeeMode', 'Netzentgelt Modus (NT/Standard/HT)', 'string', 'text');
+
+        // Gate E – Negativpreis / Tarif-Gewinnoptimierung
+        await mk('tarif.negativpreisAktiv', 'Negativpreis aktiv', 'boolean', 'indicator');
+        await mk('tarif.netzbezugBevorzugt', 'Netzbezug bevorzugt bei Negativpreis', 'boolean', 'indicator');
+        await mk('tarif.negativPreisAktuellEurProKwh', 'Negativpreis aktuell (€/kWh)', 'number', 'value');
+        await mk('tarif.negativPreisMinEurProKwh', 'Negativpreis Minimum (€/kWh, Horizon)', 'number', 'value');
+        await mk('tarif.naechstesNegativVon', 'Nächstes Negativpreis-Fenster ab (ISO)', 'string', 'text');
+        await mk('tarif.naechstesNegativBis', 'Nächstes Negativpreis-Fenster bis (ISO)', 'string', 'text');
+        await mk('tarif.negativpreisStatus', 'Negativpreis Status', 'string', 'text');
         // VIS-Settings als Datenpunkte registrieren (nur wenn dp-Registry vorhanden ist)
         if (this.dp && typeof this.dp.upsert === 'function') {
             const visInst = this._getVisInstance();
@@ -710,6 +719,17 @@ class TarifVisModule extends BaseModule {
             let nextCheapToIso = null;
             let horizonCurve = null;
 
+            // Gate E – Negativpreis: Wenn der effektive dynamische Preis < 0 ist,
+            // soll Netzbezug bewusst bevorzugt werden. Today+Tomorrow werden als
+            // Planungs-/Diagnosehorizont ausgewertet, der aktuelle Preis bleibt
+            // aber die harte Live-Freigabe.
+            let negativeActive = false;
+            let negativeWindowNow = false;
+            let negativeCurrentPrice = null;
+            let negativeMinPrice = null;
+            let nextNegativeFromIso = null;
+            let nextNegativeToIso = null;
+
             if (aktivEff && modusInt === 2) {
                 const rawToday = (this.dp && typeof this.dp.getEntry === 'function' && this.dp.getEntry('tarif.pricesTodayJson'))
                     ? this.dp.getRaw('tarif.pricesTodayJson')
@@ -736,6 +756,50 @@ class TarifVisModule extends BaseModule {
                 }
             }
 
+            // Negativpreis-Fenster aus Today+Tomorrow-Forecast ermitteln.
+            if (aktivEff) {
+                const negEps = 1e-9;
+
+                if (preisAktuellOk && preisAktuell < -negEps) {
+                    negativeActive = true;
+                    negativeCurrentPrice = preisAktuell;
+                }
+
+                if (Array.isArray(horizonCurve) && horizonCurve.length > 0) {
+                    const negAll = horizonCurve
+                        .filter(x => x && Number.isFinite(x.startMs) && Number.isFinite(x.endMs) && Number.isFinite(x.priceEurKwh))
+                        .filter(x => x.endMs > nowMs && x.priceEurKwh < -negEps)
+                        .sort((a, b) => a.startMs - b.startMs);
+
+                    if (negAll.length > 0) {
+                        negativeMinPrice = Math.min(...negAll.map(x => x.priceEurKwh));
+
+                        const activeSeg = negAll.find(x => x.startMs <= nowMs && x.endMs > nowMs);
+                        if (activeSeg) {
+                            negativeActive = true;
+                            negativeWindowNow = true;
+                            negativeCurrentPrice = activeSeg.priceEurKwh;
+                        }
+
+                        const first = negAll[0];
+                        let winStart = first.startMs;
+                        let winEnd = first.endMs;
+                        for (let i = 1; i < negAll.length; i++) {
+                            const it = negAll[i];
+                            if (it.startMs <= (winEnd + 1000)) {
+                                winEnd = Math.max(winEnd, it.endMs);
+                            } else {
+                                break;
+                            }
+                        }
+                        nextNegativeFromIso = new Date(winStart).toISOString();
+                        nextNegativeToIso = new Date(winEnd).toISOString();
+                    }
+                }
+            }
+
+            const gridImportPreferred = !!(aktivEff && negativeActive);
+
             const preisDurchschnittEff = preisDurchschnittOk ? preisDurchschnitt
                 : (Number.isFinite(preisDurchschnittCalc) ? preisDurchschnittCalc : null);
             const preisDurchschnittEffOk = (typeof preisDurchschnittEff === 'number' && Number.isFinite(preisDurchschnittEff));
@@ -867,10 +931,20 @@ class TarifVisModule extends BaseModule {
                 tarifState = next;
             }
 
+            // Negativpreis ist ein Sonderfall von "günstig", aber mit stärkerer
+            // Wirkung: Netzbezug wird bevorzugt, Speicherentladung wird gesperrt und
+            // die Speicher-Netzlade-Zeitfenster/PV-Reserve dürfen nicht blockieren.
+            if (gridImportPreferred) {
+                tarifState = 'guenstig';
+                this._tarifLastState = 'guenstig';
+            }
+
             // --- Priorität ---
             // 1 = Speicher | 2 = Auto | 3 = Ladestation
             const allowStorageCheap = (prioritaet === 1 || prioritaet === 2);
             const allowEvcsCheap = (prioritaet === 2 || prioritaet === 3);
+            const allowStorageCheapEff = gridImportPreferred ? true : allowStorageCheap;
+            const allowEvcsCheapEff = gridImportPreferred ? true : allowEvcsCheap;
 
             // Speicher-SoC (optional)
             //
@@ -956,15 +1030,16 @@ class TarifVisModule extends BaseModule {
 	                // Q1/Q4: 18:00–06:00 | Q2/Q3: 21:00–06:00
 	                // Ausnahme: Wenn zeitvariables Netzentgelt im NT ist, darf geladen werden.
 	                const storageTimeOk = !!storageChargeWindowOk;
-	                const cheapWanted = (tarifState === 'guenstig' && allowStorageCheap);
+	                const cheapWanted = ((tarifState === 'guenstig' && allowStorageCheapEff) || gridImportPreferred);
 	                // Im Netzentgelt‑NT gilt das Zeitfenster als "kosten-günstig" genug,
 	                // damit Speicher‑Netzladung überhaupt erlaubt ist (abhängig von Priorität + SoC‑Latch).
 	                // Dadurch funktioniert NT auch dann, wenn der Stromtarif selbst nur neutral/teuer ist.
-	                const cheapOrNtWanted = (cheapWanted || (netFeeIsNt && allowStorageCheap));
+	                const cheapOrNtWanted = (cheapWanted || (netFeeIsNt && allowStorageCheapEff));
 	                // Speicher darf laden, wenn (Tarif günstig ODER Netzentgelt‑NT) UND Zeitfenster ok.
-	                // Ausnahme zur Zeitfenster‑Policy: Wenn Netzentgelt im NT ist, darf auch außerhalb
-	                // des Zeitfensters geladen werden.
-	                const chargeAllowed = (cheapOrNtWanted && (storageTimeOk || netFeeIsNt));
+	                // Ausnahmen zur Zeitfenster‑Policy:
+	                // - Netzentgelt im NT
+	                // - Negativpreis: Netzbezug ist wirtschaftlich erwünscht und darf tagsüber laden.
+	                const chargeAllowed = (cheapOrNtWanted && (storageTimeOk || netFeeIsNt || gridImportPreferred));
 
 	                if (netFeeIsHt) {
                     // In HT: Speicher soll NICHT durch Tarif entladen/geladen werden → Eigenverbrauch
@@ -1032,10 +1107,12 @@ class TarifVisModule extends BaseModule {
 
             // 1) Basis: dynamischer Tarif (falls aktiv)
             if (aktivEff) {
-                if (tarifState === 'teuer') {
+                if (gridImportPreferred) {
+                    gridChargeAllowed = true;
+                } else if (tarifState === 'teuer') {
                     gridChargeAllowed = false;
                 } else if (tarifState === 'guenstig') {
-                    gridChargeAllowed = allowEvcsCheap ? true : false;
+                    gridChargeAllowed = allowEvcsCheapEff ? true : false;
                 } else {
                     gridChargeAllowed = true;
                 }
@@ -1054,6 +1131,13 @@ class TarifVisModule extends BaseModule {
                 // Standard (ST): kein Override
             }
 
+            // Negativpreis hat als wirtschaftliches Signal Vorrang vor PV-only-/HT-Sperren:
+            // Netzbezug erlauben, Speicherentladung vermeiden. Harte Netz-/§14a-/Peak-Grenzen
+            // werden später weiterhin durch die Gates begrenzt.
+            if (gridImportPreferred) {
+                gridChargeAllowed = true;
+            }
+
             // Entladen-Freigabe (für Speicher-/Assist-Logik):
             //
             // Ziel (Bugfix + bessere Praxis):
@@ -1075,7 +1159,10 @@ class TarifVisModule extends BaseModule {
                 const storageChargingPlanned = Number.isFinite(speicherSollW) && speicherSollW < 0;
                 const forceSelfConsumption = !!storageChargeBlockedByTime || netFeeIsHt;
 
-                if (forceSelfConsumption) {
+                if (gridImportPreferred) {
+                    // Bei Negativpreis soll der Speicher nicht gegen den gewünschten Netzbezug entladen.
+                    dischargeAllowed = false;
+                } else if (forceSelfConsumption) {
                     // Eigenverbrauch-Modus (tagsüber Policy oder HT): Entladen erlaubt.
                     dischargeAllowed = true;
                 } else if (netFeeIsNt) {
@@ -1097,7 +1184,7 @@ class TarifVisModule extends BaseModule {
 
             // Ladepark-Limit: Standard = baseW; Reservierung wenn Speicher im Tarif-Fenster lädt
             let limitW = baseW;
-            if (((aktivEff && (tarifState === 'guenstig')) || (netFeeEff && netFeeMode === 'NT')) && speicherSollW < 0 && baseW > 0) {
+            if (!gridImportPreferred && ((aktivEff && (tarifState === 'guenstig')) || (netFeeEff && netFeeMode === 'NT')) && speicherSollW < 0 && baseW > 0) {
                 const reserveW = Math.max(0, -speicherSollW);
                 const storageShare = (prioritaet === 1) ? 1.0 : (prioritaet === 3) ? 0.0 : 0.5;
                 limitW = Math.max(0, Math.round(baseW - (reserveW * storageShare)));
@@ -1131,6 +1218,14 @@ class TarifVisModule extends BaseModule {
             await this._setIfChanged('tarif.netFeeEnabled', netFeeEff);
             await this._setIfChanged('tarif.netFeeMode', netFeeMode);
 
+            await this._setIfChanged('tarif.negativpreisAktiv', !!negativeActive);
+            await this._setIfChanged('tarif.netzbezugBevorzugt', !!gridImportPreferred);
+            await this._setIfChanged('tarif.negativPreisAktuellEurProKwh', (negativeActive && typeof negativeCurrentPrice === 'number' && Number.isFinite(negativeCurrentPrice)) ? negativeCurrentPrice : null);
+            await this._setIfChanged('tarif.negativPreisMinEurProKwh', (typeof negativeMinPrice === 'number' && Number.isFinite(negativeMinPrice)) ? negativeMinPrice : null);
+            await this._setIfChanged('tarif.naechstesNegativVon', nextNegativeFromIso || null);
+            await this._setIfChanged('tarif.naechstesNegativBis', nextNegativeToIso || null);
+            await this._setIfChanged('tarif.negativpreisStatus', gridImportPreferred ? 'active_grid_import_preferred' : (nextNegativeFromIso ? 'scheduled' : 'inactive'));
+
             
 // Kurz-Status für die VIS (Live-Ansicht)
 // Ziel: Kunde sieht sofort, ob Tarif gerade Laden/Entladen triggert.
@@ -1170,7 +1265,15 @@ if (aktivEff || netFeeActive) {
   // - Standard (ST): keine Sperre/Erzwingung → dynamischer Tarif wie bisher
   const base = netFeeActive ? `Netzentgelt ${netFeeMode} | ${baseTarif}` : baseTarif;
 
-  if (netFeeOverlayUi) {
+  if (gridImportPreferred) {
+    const parts = [];
+    parts.push('Negativpreis aktiv');
+    if (storageCharging) parts.push('Speicher Netzladen');
+    else if (storageFullHold) parts.push('Speicher voll (ruht)');
+    parts.push('EVCS/Verbraucher Netzbezug freigegeben');
+    parts.push('Speicherentladung gesperrt');
+    statusText = `${base}: ${parts.join(' + ')}`;
+  } else if (netFeeOverlayUi) {
     if (netFeeMode === 'NT') {
       const parts = [];
       if (storageCharging) parts.push('Speicher lädt');
@@ -1247,6 +1350,14 @@ await this._setIfChanged('tarif.statusText', statusText);
                 preisSchwelleGuensig: (typeof preisSchwelleGuensig === 'number' && Number.isFinite(preisSchwelleGuensig)) ? preisSchwelleGuensig : null,
                 nextCheapFromIso: nextCheapFromIso || null,
                 nextCheapToIso: nextCheapToIso || null,
+                negativeActive: !!negativeActive,
+                negativeWindowNow: !!negativeWindowNow,
+                gridImportPreferred: !!gridImportPreferred,
+                netzbezugBevorzugt: !!gridImportPreferred,
+                negativeCurrentPrice: (negativeActive && typeof negativeCurrentPrice === 'number' && Number.isFinite(negativeCurrentPrice)) ? negativeCurrentPrice : null,
+                negativeMinPrice: (typeof negativeMinPrice === 'number' && Number.isFinite(negativeMinPrice)) ? negativeMinPrice : null,
+                nextNegativeFromIso: nextNegativeFromIso || null,
+                nextNegativeToIso: nextNegativeToIso || null,
                 autoBandEur: (typeof autoBandEur === 'number' && Number.isFinite(autoBandEur)) ? autoBandEur : null,
                 horizonHours: (typeof horizonHours === 'number' && Number.isFinite(horizonHours)) ? horizonHours : null,
                 preisRef: (preisRef !== null && preisRef !== undefined && Number.isFinite(preisRef)) ? preisRef : null,

package/ems/modules/thermal-control.js

@@ -476,14 +476,20 @@ const mk = async (id, name, type, role, unit = undefined) => {
             if (snap && age <= staleMs) {
                 const pvTotalW = snap.gates && snap.gates.pv ? Number(snap.gates.pv.effectiveW) : 0;
                 const remainingPvW = Number(snap.remainingPvW);
+                const tariffGate = snap.gates && snap.gates.tariff ? snap.gates.tariff : null;
+                const tariffImportPreferred = !!(tariffGate && tariffGate.gridImportPreferred);
+                const remainingTotalW = Number(snap.remainingTotalW);
                 if (Number.isFinite(remainingPvW) && remainingPvW >= 0) {
                     const evcs = snap.consumers && snap.consumers.evcs ? snap.consumers.evcs : null;
                     const evcsUsedW = evcs && Number.isFinite(Number(evcs.reserveW)) ? Math.max(0, Number(evcs.reserveW)) : 0;
+                    const availableByTariffW = (tariffImportPreferred && Number.isFinite(remainingTotalW) && remainingTotalW >= 0)
+                        ? Math.max(0, remainingTotalW)
+                        : null;
                     return {
                         pvCapW: Math.max(0, Number.isFinite(pvTotalW) ? pvTotalW : remainingPvW),
                         evcsUsedW,
-                        availableW: Math.max(0, remainingPvW),
-                        source: 'ems.budget',
+                        availableW: availableByTariffW !== null ? availableByTariffW : Math.max(0, remainingPvW),
+                        source: availableByTariffW !== null ? 'ems.budget.tariffNegative' : 'ems.budget',
                     };
                 }
             }
@@ -902,6 +908,7 @@ const mk = async (id, name, type, role, unit = undefined) => {
             const rt = this.adapter && this.adapter._emsBudget;
             if (rt && typeof rt.reserve === 'function') {
                 const used = Math.max(0, Math.round(budgetUsedW || 0));
+                const tariffImportPreferred = String(pv.source || '').includes('tariffNegative');
                 rt.reserve({
                     key: 'thermal',
                     app: 'thermalControl',
@@ -909,9 +916,9 @@ const mk = async (id, name, type, role, unit = undefined) => {
                     priority: 200,
                     requestedW: used,
                     reserveW: used,
-                    pvReserveW: used,
-                    pvOnly: true,
-                    mode: 'pvAuto',
+                    pvReserveW: tariffImportPreferred ? 0 : used,
+                    pvOnly: !tariffImportPreferred,
+                    mode: tariffImportPreferred ? 'tariffNegative' : 'pvAuto',
                 });
             }
         } catch (_e) {

package/io-package.json

@@ -1,8 +1,12 @@
 {
   "common": {
     "name": "nexowatt-ui",
-    "version": "0.7.13",
+    "version": "0.7.14",
     "news": {
+      "0.7.14": {
+        "en": "Added Gate E for negative dynamic electricity prices. When the effective tariff/forecast price is below zero, grid import is preferred: tariff flags allow storage grid charging and EVCS grid charging, block tariff-based storage discharge, publish ems.budget.tariff.*, and recommend PV curtailment. Hard grid, phase, §14a and peak-shaving limits remain active. Heating rod and thermal budget followers can use total budget in negative-price windows without consuming PV budget; MultiUse and peak-shaving behavior remains unchanged.",
+        "de": "Gate E für negative dynamische Strompreise ergänzt. Wenn der effektive Tarif-/Forecastpreis unter 0 liegt, wird Netzbezug bevorzugt: Tarif-Flags geben Speicher-Netzladen und EVCS-Netzladen frei, sperren tarifbasierte Speicherentladung, veröffentlichen ems.budget.tariff.* und empfehlen PV-Abregelung. Harte Netz-, Phasen-, §14a- und Peakshaving-Grenzen bleiben aktiv. Heizstab- und Thermik-Budgetfolger können in Negativpreisfenstern Gesamtbudget nutzen, ohne PV-Budget zu verbrauchen; MultiUse und Peakshaving bleiben unverändert."
+      },
       "0.7.13": {
         "en": "Heating rod PV-auto now treats fresh central EMS remaining PV budget as already priority-adjusted, so thermal budget is not subtracted twice. This fixes blocked auto-start and missing stage-up when the central Gates already deducted higher-priority consumers.",
         "de": "Heizstab-PV-Auto nutzt frisches zentrales EMS-Rest-PV-Budget jetzt als bereits prioritätsbereinigt. Thermik wird dabei nicht mehr doppelt abgezogen. Das behebt blockierten Auto-Start und fehlendes Hochstufen, wenn die zentralen Gates Verbraucher höherer Priorität bereits abgezogen haben."
@@ -1871,8 +1875,12 @@
     }
   },
   "instanceObjects": [],
-  "version": "0.7.13",
+  "version": "0.7.14",
   "news": {
+    "0.7.14": {
+      "en": "Gate E - Tariff/negative price added. Negative dynamic tariff prices now prefer grid import, allow storage and EVCS grid charging, block storage discharge from tariff logic, expose ems.budget.tariff.* diagnostics and let PV curtailment/zero-export logic bias toward import while hard safety limits stay active. Thermal and heating-rod budget followers can use total budget in negative-price windows. MultiUse and peak-shaving unchanged. Web cache bumped.",
+      "de": "Gate E - Tarif/Negativpreis ergänzt. Negative dynamische Tarifpreise bevorzugen jetzt Netzbezug, erlauben Speicher- und EVCS-Netzladen, sperren tarifbasierte Speicherentladung, stellen ems.budget.tariff.* als Diagnose bereit und lassen PV-Abregelung/0-Einspeisung in Richtung Import-Bias arbeiten, während harte Schutzgrenzen aktiv bleiben. Thermik- und Heizstab-Budgetfolger können in Negativpreisfenstern Gesamtbudget nutzen. MultiUse und Peakshaving unverändert. Webcache erhöht."
+    },
     "0.7.13": {
       "en": "Heating rod PV-Auto now treats fresh central ems.budget.remainingPvW as already prioritized, so higher-priority thermal reservations are no longer subtracted a second time. This fixes PV-Auto start/step-up blocking where the rod only started after manual stage 1 and then stayed there. Legacy fallback budgets still keep the local thermal deduction. Web cache version bumped.",
       "de": "Heizstab PV-Auto nutzt frisches zentrales ems.budget.remainingPvW jetzt als bereits priorisiertes Restbudget, sodass Thermik-Reservierungen mit höherer Priorität nicht noch einmal lokal abgezogen werden. Das behebt Start-/Hochschaltblockaden, bei denen der Heizstab erst nach manueller Stufe 1 lief und dann dort hängen blieb. Legacy-Fallback-Budgets behalten den lokalen Thermik-Abzug. Webcache erhöht."

package/main.js

@@ -10873,6 +10873,21 @@ app.get('/api/smarthome/type-detect', requireInstaller, async (req, res) => {
           emsForecastKwhNext24h: await getOwn('ems.budget.forecast.kwhNext24h'),
           emsForecastStatus: await getOwn('ems.budget.forecast.status'),
           emsForecastSource: await getOwn('ems.budget.forecast.source'),
+
+          // Gate E - Tarif / Negativpreis
+          emsTariffActive: await getOwn('ems.budget.tariff.active'),
+          emsTariffState: await getOwn('ems.budget.tariff.state'),
+          emsTariffCurrentPriceEurKwh: await getOwn('ems.budget.tariff.currentPriceEurKwh'),
+          emsTariffNegativeActive: await getOwn('ems.budget.tariff.negativeActive'),
+          emsTariffGridImportPreferred: await getOwn('ems.budget.tariff.gridImportPreferred'),
+          emsTariffStorageGridChargeAllowed: await getOwn('ems.budget.tariff.storageGridChargeAllowed'),
+          emsTariffEvcsGridChargeAllowed: await getOwn('ems.budget.tariff.evcsGridChargeAllowed'),
+          emsTariffDischargeAllowed: await getOwn('ems.budget.tariff.dischargeAllowed'),
+          emsTariffPvCurtailRecommended: await getOwn('ems.budget.tariff.pvCurtailRecommended'),
+          emsTariffNegativeMinPriceEurKwh: await getOwn('ems.budget.tariff.negativeMinPriceEurKwh'),
+          emsTariffNextNegativeFrom: await getOwn('ems.budget.tariff.nextNegativeFrom'),
+          emsTariffNextNegativeTo: await getOwn('ems.budget.tariff.nextNegativeTo'),
+          emsTariffStatus: await getOwn('ems.budget.tariff.status'),
         };
 
         const summary = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.nexowatt-ui",
-  "version": "0.7.13",
+  "version": "0.7.14",
   "description": "Responsive NexoWatt EMS visualization adapter.",
   "author": "NexoWatt",
   "license": "Proprietary License (NPL) v1.0",

package/www/ems-apps.js

@@ -7536,6 +7536,20 @@ function _collectFlowPowerDpIsWFromUI() {
     return n.toFixed(n >= 10 ? 1 : 2) + ' kWh';
   }
 
+  function _fmtEurKwh(v) {
+    const n = Number(v);
+    if (!Number.isFinite(n)) return '—';
+    return n.toFixed(4) + ' €/kWh';
+  }
+
+  function _fmtIsoShort(v) {
+    const s = String(v || '').trim();
+    if (!s) return '—';
+    const d = new Date(s);
+    if (!Number.isFinite(d.getTime())) return s;
+    return d.toLocaleString();
+  }
+
   function _fmtPct(v) {
     const n = Number(v);
     if (!Number.isFinite(n)) return '—';
@@ -7759,6 +7773,23 @@ function _collectFlowPowerDpIsWFromUI() {
         { label: 'Status', value: String(ctrl.emsForecastStatus || '') },
       ], fcKind));
 
+      const tariffNeg = b(ctrl.emsTariffNegativeActive);
+      const tariffPref = b(ctrl.emsTariffGridImportPreferred);
+      const tariffKind = tariffPref ? 'ok' : (b(ctrl.emsTariffActive) ? '' : 'warn');
+      els.chargingBudget.appendChild(mkCard('Gate E – Tarif / Negativpreis', [
+        { label: 'Tarif aktiv', value: _fmtBool(b(ctrl.emsTariffActive), 'JA', 'NEIN') },
+        { label: 'Status', value: String(ctrl.emsTariffStatus || ctrl.emsTariffState || '') },
+        { label: 'Aktueller Preis', value: _fmtEurKwh(n(ctrl.emsTariffCurrentPriceEurKwh)) },
+        { label: 'Negativpreis aktiv', value: _fmtBool(tariffNeg, 'JA', 'NEIN') },
+        { label: 'Netzbezug bevorzugt', value: _fmtBool(tariffPref, 'JA', 'NEIN') },
+        { label: 'Speicher Netzladen', value: _fmtBool(b(ctrl.emsTariffStorageGridChargeAllowed), 'JA', 'NEIN') },
+        { label: 'EVCS Netzladen', value: _fmtBool(b(ctrl.emsTariffEvcsGridChargeAllowed), 'JA', 'NEIN') },
+        { label: 'Speicher Entladen', value: _fmtBool(b(ctrl.emsTariffDischargeAllowed), 'JA', 'NEIN') },
+        { label: 'PV-Abregelung empfohlen', value: _fmtBool(b(ctrl.emsTariffPvCurtailRecommended), 'JA', 'NEIN') },
+        { label: 'Min. negativ im Forecast', value: _fmtEurKwh(n(ctrl.emsTariffNegativeMinPriceEurKwh)) },
+        { label: 'Nächstes Negativfenster', value: `${_fmtIsoShort(ctrl.emsTariffNextNegativeFrom)} → ${_fmtIsoShort(ctrl.emsTariffNextNegativeTo)}` },
+      ], tariffKind));
+
       try {
         const consumers = JSON.parse(String(ctrl.emsBudgetConsumersJson || '[]'));
         if (Array.isArray(consumers) && consumers.length) {

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