iobroker.nexowatt-ui 0.7.46 → 0.7.48

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -565,45 +565,44 @@ class CoreLimitsModule extends BaseModule {
565
565
  return Math.max(0, this._readCacheNumber(['derived.core.pv.totalW', 'pvPower', 'productionTotal', 'storageFarm.totalPvPowerW'], 0) || 0);
566
566
  })();
567
567
 
568
- // Speicherfarm- und Einzelakku-Aliase können parallel existieren. Ein 0-W-Wert aus
569
- // storageFarm.* darf einen echten Wert aus storageChargePower/storageDischargePower
570
- // nicht verdecken, sonst sieht Gate C keine Akku-Entladung und Verbraucher halten
571
- // fälschlich Last aus dem Speicher. Darum hier bewusst den größten frischen Wert nutzen.
572
- let storageChargeW = Math.max(0, this._readCacheNumberMax(['storageFarm.totalChargePowerW', 'storageChargePower'], 0) || 0);
573
- let storageDischargeW = Math.max(0, this._readCacheNumberMax(['storageFarm.totalDischargePowerW', 'storageDischargePower'], 0) || 0);
574
- const batteryPowerW = this._readCacheNumber(['batteryPower'], null);
575
- if (isFiniteNumber(batteryPowerW)) {
576
- const flowBatteryMapped = !!(cfg.datapoints && String(cfg.datapoints.batteryPower || '').trim());
577
- const farmActive = !!this._readCacheNumber(['storageFarm.enabled'], 0);
578
- // Apply the VIS inversion only to a raw mapped batteryPower datapoint.
579
- // If batteryPower was mirrored from the already-normalized storage pair/farm,
580
- // flipping it here again would swap charge/discharge twice.
581
- const invBattery = flowBatteryMapped && !farmActive && !!(cfg.settings && cfg.settings.flowInvertBattery);
582
- const signed = Math.round(invBattery ? -batteryPowerW : batteryPowerW);
583
- if (signed < -25) {
584
- storageChargeW = Math.max(storageChargeW, Math.abs(signed));
585
- storageDischargeW = 0;
586
- } else if (signed > 25) {
587
- storageDischargeW = Math.max(storageDischargeW, signed);
588
- storageChargeW = 0;
589
- } else {
590
- storageChargeW = 0;
591
- storageDischargeW = 0;
592
- }
593
- }
594
-
595
- // Guard against ghost split-battery aliases: with no direct house-load meter,
596
- // discharge + NVP export would inflate house load and reduce the PV budget.
597
- // This keeps signed batteryPower and direct load meters authoritative, but avoids
598
- // bad powerDischarge aliases breaking Heizstab/EMS budgets.
568
+ // Speicherleistung wird zentral wie im Energiefluss aufgelöst:
569
+ // - getrennte Lade-/Entlade-DPs bleiben vollständig gültig
570
+ // - signed Batterie-DP bleibt gültig (- = Laden, + = Entladen; invertierbar)
571
+ // - nur wenn keine frische Messquelle vorhanden ist, wird rechnerisch über die Bilanz abgeleitet
572
+ let storageChargeW = 0;
573
+ let storageDischargeW = 0;
574
+ let usedCentralStorageFlow = false;
599
575
  try {
600
- const hasDirectLoad = !!(cfg.datapoints && (String(cfg.datapoints.consumptionTotal || '').trim() || String(cfg.datapoints.housePower || '').trim()));
601
- const splitBatteryConfigured = !!(cfg.datapoints && (String(cfg.datapoints.storageChargePower || '').trim() || String(cfg.datapoints.storageDischargePower || '').trim()));
602
- const signedBatteryConfigured = !!(cfg.datapoints && String(cfg.datapoints.batteryPower || '').trim());
603
- if (!hasDirectLoad && splitBatteryConfigured && !signedBatteryConfigured && gridExportW > 250 && storageDischargeW > 250 && storageChargeW <= 250) {
604
- storageDischargeW = 0;
576
+ const flow = (this.adapter && typeof this.adapter._nwResolveBatteryFlowFromCache === 'function')
577
+ ? this.adapter._nwResolveBatteryFlowFromCache({ maxAgeMs: staleMs, deadbandW: 25 })
578
+ : null;
579
+ if (flow && typeof flow === 'object') {
580
+ usedCentralStorageFlow = true;
581
+ storageChargeW = Math.max(0, Math.round(Number(flow.chargeW) || 0));
582
+ storageDischargeW = Math.max(0, Math.round(Number(flow.dischargeW) || 0));
605
583
  }
606
- } catch (_eSanitizeStorage) {}
584
+ } catch (_eFlow) {}
585
+
586
+ if (!usedCentralStorageFlow) {
587
+ // Fallback für sehr alte Laufzeiten ohne zentralen Resolver. Keine Plausibilitäts-
588
+ // Unterdrückung hier: gemappte Split-DPs sind autoritativ.
589
+ storageChargeW = Math.max(0, this._readCacheNumberMax(['storageFarm.totalChargePowerW', 'storageChargePower'], 0) || 0);
590
+ storageDischargeW = Math.max(0, this._readCacheNumberMax(['storageFarm.totalDischargePowerW', 'storageDischargePower'], 0) || 0);
591
+ const batteryPowerW = this._readCacheNumber(['batteryPower'], null);
592
+ if (isFiniteNumber(batteryPowerW)) {
593
+ const flowBatteryMapped = !!(cfg.datapoints && String(cfg.datapoints.batteryPower || '').trim());
594
+ const farmActive = !!this._readCacheNumber(['storageFarm.enabled'], 0);
595
+ const invBattery = flowBatteryMapped && !farmActive && !!(cfg.settings && cfg.settings.flowInvertBattery);
596
+ const signed = Math.round(invBattery ? -batteryPowerW : batteryPowerW);
597
+ if (signed < -25) {
598
+ storageChargeW = Math.max(storageChargeW, Math.abs(signed));
599
+ storageDischargeW = 0;
600
+ } else if (signed > 25) {
601
+ storageDischargeW = Math.max(storageDischargeW, signed);
602
+ storageChargeW = 0;
603
+ }
604
+ }
605
+ }
607
606
 
608
607
  const evcsEnabled = cfg.enableChargingManagement !== false;
609
608
  const thermalEnabled = cfg.enableThermalControl === true;
@@ -604,42 +604,47 @@ class HeatingRodControlModule extends BaseModule {
604
604
  }
605
605
 
606
606
  _readStorageSnapshot(staleMs) {
607
- // Speicherfarm- und Einzelakku-Aliase können beide im Cache stehen. Ein 0-W-Wert
608
- // aus storageFarm.* darf einen echten Entlade-/Ladewert aus den Basis-Aliasen nicht
609
- // verdecken. Sonst erkennt der Heizstab keine Akku-Entladung und hält zu hohe Stufen.
610
- let chargeW = Math.max(0, num(this._readNumberMaxAny([
611
- 'storageFarm.totalChargePowerW',
612
- 'storageChargePower'
613
- ], staleMs, null), 0));
614
-
615
- let dischargeW = Math.max(0, num(this._readNumberMaxAny([
616
- 'storageFarm.totalDischargePowerW',
617
- 'storageDischargePower'
618
- ], staleMs, null), 0));
619
-
620
- const batteryPowerW = this._readNumberAny(['batteryPower'], staleMs, null);
621
- if (typeof batteryPowerW === 'number' && Number.isFinite(batteryPowerW)) {
622
- const cfg = (this.adapter && this.adapter.config) ? this.adapter.config : {};
623
- const flowBatteryMapped = !!(cfg.datapoints && String(cfg.datapoints.batteryPower || '').trim());
624
- const farmActive = !!this._readCacheNumber('storageFarm.enabled', 0);
625
- // Apply the VIS inversion only to a raw mapped batteryPower datapoint.
626
- // Mirrored batteryPower values are already normalized by the main flow engine.
627
- const invBattery = flowBatteryMapped && !farmActive && !!(cfg.settings && cfg.settings.flowInvertBattery);
628
- const signedW = Math.round(invBattery ? -batteryPowerW : batteryPowerW);
629
- const noiseW = 25;
630
- // batteryPower is the canonical direction signal in this adapter:
631
- // +W = discharge, -W = charge. Prefer that direction over separate
632
- // charge/discharge aliases, because those can be delayed or vendor-specific.
633
- // Otherwise a charging battery can look like discharge and block stage-up.
634
- if (signedW < -noiseW) {
635
- chargeW = Math.max(chargeW, Math.abs(signedW));
636
- dischargeW = 0;
637
- } else if (signedW > noiseW) {
638
- dischargeW = Math.max(dischargeW, signedW);
639
- chargeW = 0;
640
- } else {
641
- chargeW = 0;
642
- dischargeW = 0;
607
+ let chargeW = 0;
608
+ let dischargeW = 0;
609
+ let usedCentralStorageFlow = false;
610
+ try {
611
+ const flow = (this.adapter && typeof this.adapter._nwResolveBatteryFlowFromCache === 'function')
612
+ ? this.adapter._nwResolveBatteryFlowFromCache({ maxAgeMs: staleMs, deadbandW: 25 })
613
+ : null;
614
+ if (flow && typeof flow === 'object') {
615
+ usedCentralStorageFlow = true;
616
+ chargeW = Math.max(0, Math.round(Number(flow.chargeW) || 0));
617
+ dischargeW = Math.max(0, Math.round(Number(flow.dischargeW) || 0));
618
+ }
619
+ } catch (_eFlow) {}
620
+
621
+ if (!usedCentralStorageFlow) {
622
+ // Fallback für ältere Laufzeiten: Split-DPs und signed DP bleiben wie bisher erlaubt.
623
+ chargeW = Math.max(0, num(this._readNumberMaxAny([
624
+ 'storageFarm.totalChargePowerW',
625
+ 'storageChargePower'
626
+ ], staleMs, null), 0));
627
+
628
+ dischargeW = Math.max(0, num(this._readNumberMaxAny([
629
+ 'storageFarm.totalDischargePowerW',
630
+ 'storageDischargePower'
631
+ ], staleMs, null), 0));
632
+
633
+ const batteryPowerW = this._readNumberAny(['batteryPower'], staleMs, null);
634
+ if (typeof batteryPowerW === 'number' && Number.isFinite(batteryPowerW)) {
635
+ const cfg = (this.adapter && this.adapter.config) ? this.adapter.config : {};
636
+ const flowBatteryMapped = !!(cfg.datapoints && String(cfg.datapoints.batteryPower || '').trim());
637
+ const farmActive = !!this._readCacheNumber('storageFarm.enabled', 0);
638
+ const invBattery = flowBatteryMapped && !farmActive && !!(cfg.settings && cfg.settings.flowInvertBattery);
639
+ const signedW = Math.round(invBattery ? -batteryPowerW : batteryPowerW);
640
+ const noiseW = 25;
641
+ if (signedW < -noiseW) {
642
+ chargeW = Math.max(chargeW, Math.abs(signedW));
643
+ dischargeW = 0;
644
+ } else if (signedW > noiseW) {
645
+ dischargeW = Math.max(dischargeW, signedW);
646
+ chargeW = 0;
647
+ }
643
648
  }
644
649
  }
645
650
 
@@ -691,17 +696,6 @@ class HeatingRodControlModule extends BaseModule {
691
696
  const exportW = gridKnown ? Math.max(0, -gridW) : 0;
692
697
  const importW = gridKnown ? Math.max(0, gridW) : 0;
693
698
  const storage = this._readStorageSnapshot(staleMs);
694
- try {
695
- const appCfg = (this.adapter && this.adapter.config) ? this.adapter.config : {};
696
- const hasDirectLoad = !!(appCfg.datapoints && (String(appCfg.datapoints.consumptionTotal || '').trim() || String(appCfg.datapoints.housePower || '').trim()));
697
- const splitBatteryConfigured = !!(appCfg.datapoints && (String(appCfg.datapoints.storageChargePower || '').trim() || String(appCfg.datapoints.storageDischargePower || '').trim()));
698
- const signedBatteryConfigured = !!(appCfg.datapoints && String(appCfg.datapoints.batteryPower || '').trim());
699
- if (!hasDirectLoad && splitBatteryConfigured && !signedBatteryConfigured && exportW > 250 && storage.dischargeW > 250 && storage.chargeW <= 250) {
700
- storage.dischargeW = 0;
701
- storage.sanitizedExportDischarge = true;
702
- }
703
- } catch (_eSanitizeStorage) {}
704
-
705
699
  const storageTargetSocPct = clamp(num(cfg.storageTargetSocPct, 90), 0, 100);
706
700
  const storageReserveCfgW = Math.max(0, Math.round(num(cfg.storageReserveW, 1000)));
707
701
  const storageKnown = storage.chargeW > 0
package/io-package.json CHANGED
@@ -1,8 +1,16 @@
1
1
  {
2
2
  "common": {
3
3
  "name": "nexowatt-ui",
4
- "version": "0.7.46",
4
+ "version": "0.7.48",
5
5
  "news": {
6
+ "0.7.48": {
7
+ "en": "Hotfix: core energy-flow datapoints are no longer discarded as stale, storage split/signed DPs remain authoritative, and balance-derived battery values are only used when no storage DP is configured.",
8
+ "de": "Hotfix: Kern-Datenpunkte im Energiefluss werden nicht mehr wegen altem Zeitstempel verworfen, getrennte/signed Speicher-DPs bleiben autoritativ und berechnete Speicherwerte werden nur genutzt, wenn kein Speicher-DP konfiguriert ist."
9
+ },
10
+ "0.7.47": {
11
+ "en": "Energy-flow datapoint resolver fixed: split charge/discharge datapoints and signed battery power are supported consistently again; calculated fallback is only used when a fresh measurement source is missing. Heating-rod reserve inputs are flushed before save.",
12
+ "de": "Energiefluss-Datenpunktauflösung korrigiert: getrennte Lade-/Entlade-Datenpunkte und signed Batterie-Leistung werden wieder konsistent unterstützt; der rechnerische Fallback greift nur, wenn keine frische Messquelle vorhanden ist. Heizstab-Reservefelder werden vor dem Speichern direkt übernommen."
13
+ },
6
14
  "0.7.42": {
7
15
  "en": "Feature-dependent visibility fixed: EVCS/charging station and storage farm are only shown in the customer frontend when they are actually configured. Default/legacy placeholders no longer enable wallbox UI; AI Advisor suppresses EV/wallbox hints when no wallbox is available.",
8
16
  "de": "Anlagenabhängige Sichtbarkeit korrigiert: EVCS/Ladestation und Speicherfarm erscheinen im Kunden-Frontend nur noch, wenn sie wirklich konfiguriert sind. Default-/Legacy-Placeholder aktivieren keine Wallbox-Anzeige mehr; KI-Empfehlungen verzichten ohne Wallbox auf EV-/Wallbox-Hinweise."
@@ -1987,7 +1995,7 @@
1987
1995
  }
1988
1996
  },
1989
1997
  "instanceObjects": [],
1990
- "version": "0.7.46",
1998
+ "version": "0.7.48",
1991
1999
  "news": {
1992
2000
  "0.7.42": {
1993
2001
  "en": "Feature-dependent visibility fixed: EVCS/charging station and storage farm are only shown in the customer frontend when they are actually configured. Default/legacy placeholders no longer enable wallbox UI; AI Advisor suppresses EV/wallbox hints when no wallbox is available.",
package/main.js CHANGED
@@ -17617,28 +17617,60 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
17617
17617
  }
17618
17618
  }
17619
17619
 
17620
+ _nwStorageFarmIsActiveFromCache() {
17621
+ try {
17622
+ const cfg = this.config || {};
17623
+ const sf = (cfg.storageFarm && typeof cfg.storageFarm === 'object') ? cfg.storageFarm : {};
17624
+ const rows = Array.isArray(sf.storages) ? sf.storages : [];
17625
+ const configured = rows.some(r => r && typeof r === 'object' && r.enabled !== false);
17626
+ if (!cfg.enableStorageFarm || !configured) return false;
17627
+
17628
+ const rec = this.stateCache && this.stateCache['storageFarm.enabled'];
17629
+ if (rec && rec.value === false) return false;
17630
+
17631
+ const totalRec = this.stateCache && this.stateCache['storageFarm.storagesTotal'];
17632
+ if (totalRec && totalRec.value !== undefined && totalRec.value !== null) {
17633
+ const total = Number(totalRec.value);
17634
+ if (Number.isFinite(total) && total <= 0) return false;
17635
+ }
17636
+ return true;
17637
+ } catch (_e) {
17638
+ return false;
17639
+ }
17640
+ }
17641
+
17620
17642
  _nwResolveBatteryFlowFromCache(opts = {}) {
17621
17643
  const now = Number.isFinite(Number(opts.now)) ? Number(opts.now) : Date.now();
17622
17644
  const maxAgeMs = opts.maxAgeMs === undefined ? this._nwLiveInputMaxAgeMs() : opts.maxAgeMs;
17623
17645
  const deadbandW = Number.isFinite(Number(opts.deadbandW)) ? Math.max(0, Number(opts.deadbandW)) : 25;
17646
+ const strictStale = opts.strictStale === true;
17624
17647
 
17625
17648
  const dps = (this.config && this.config.datapoints && typeof this.config.datapoints === 'object') ? this.config.datapoints : {};
17626
17649
  const idOf = (key) => String(dps[key] || '').trim();
17627
17650
  const chargeMapped = !!idOf('storageChargePower');
17628
17651
  const dischargeMapped = !!idOf('storageDischargePower');
17629
17652
  const batteryMapped = !!idOf('batteryPower');
17653
+ const anyStorageMapped = chargeMapped || dischargeMapped || batteryMapped;
17630
17654
  const sameChargeDischargeId = !!(chargeMapped && dischargeMapped && idOf('storageChargePower') === idOf('storageDischargePower'));
17631
17655
  const inv = this._nwIsBatterySignInverted();
17632
17656
 
17633
- const fresh = (key, onlyIfMapped) => {
17657
+ // Wichtig: Gemappte Kern-DPs werden als Quelle der Wahrheit behandelt, auch wenn
17658
+ // sich der Wert lange nicht geändert hat. Viele ioBroker-Adapter aktualisieren bei
17659
+ // konstant 0 W nur lc/ts selten oder gar nicht. Diese 0-Werte dürfen deshalb nicht
17660
+ // als "fehlend" verworfen und durch eine Bilanzrechnung ersetzt werden.
17661
+ const readMapped = (key, onlyIfMapped, raw = false) => {
17634
17662
  if (onlyIfMapped && !idOf(key)) return null;
17635
- return this._nwGetNumberFromCacheFresh(key, maxAgeMs, null, now);
17636
- };
17637
- const rawFresh = (key, onlyIfMapped) => {
17638
- if (onlyIfMapped && !idOf(key)) return null;
17639
- return this._nwGetRawNumberFromCache(key, maxAgeMs, null, now);
17663
+ return raw
17664
+ ? this._nwGetRawNumberFromCache(key, strictStale ? maxAgeMs : null, null, now)
17665
+ : this._nwGetNumberFromCacheFresh(key, strictStale ? maxAgeMs : null, null, now);
17640
17666
  };
17641
17667
 
17668
+ const ageInfo = () => ({
17669
+ batteryPower: this._nwGetCacheAgeMs('batteryPower', now),
17670
+ storageChargePower: this._nwGetCacheAgeMs('storageChargePower', now),
17671
+ storageDischargePower: this._nwGetCacheAgeMs('storageDischargePower', now),
17672
+ });
17673
+
17642
17674
  const fromSigned = (signedRaw, src, opts2 = {}) => {
17643
17675
  let signed = Number(signedRaw);
17644
17676
  if (!Number.isFinite(signed)) signed = 0;
@@ -17654,24 +17686,22 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
17654
17686
  inverted: inv,
17655
17687
  fromSigned: true,
17656
17688
  mirror: opts2.mirror !== false,
17657
- staleMs: {
17658
- batteryPower: this._nwGetCacheAgeMs('batteryPower', now),
17659
- storageChargePower: this._nwGetCacheAgeMs('storageChargePower', now),
17660
- storageDischargePower: this._nwGetCacheAgeMs('storageDischargePower', now),
17661
- },
17689
+ derived: false,
17690
+ staleMs: ageInfo(),
17662
17691
  };
17663
17692
  };
17664
17693
 
17665
17694
  const fromBalance = () => {
17666
17695
  try {
17667
17696
  const balanceDeadbandW = Math.max(180, deadbandW);
17668
- if (this.stateCache && this.stateCache['storageFarm.enabled'] && this.stateCache['storageFarm.enabled'].value) return null;
17697
+ if (this._nwStorageFarmIsActiveFromCache && this._nwStorageFarmIsActiveFromCache()) return null;
17669
17698
 
17670
17699
  const soc = this._nwGetNumberFromCache('storageSoc');
17671
17700
  if (!Number.isFinite(Number(soc))) return null;
17672
17701
 
17673
- // Nur mit direkt gemessenem Hausverbrauch ableiten. Ohne Direktmessung wäre
17674
- // consumptionTotal evtl. schon aus derselben Bilanz berechnet und damit zirkulär.
17702
+ // Nur wenn eine echte Verbrauchsleistung als DP gemappt ist, kann Speicherleistung
17703
+ // zuverlässig aus der Bilanz abgeleitet werden. Sonst wäre consumptionTotal ggf.
17704
+ // bereits aus derselben Bilanz erzeugt und die Rechnung zirkulär.
17675
17705
  const hasDirectLoad = this._nwHasMappedDatapoint('consumptionTotal') || this._nwHasMappedDatapoint('housePower');
17676
17706
  if (!hasDirectLoad) return null;
17677
17707
 
@@ -17712,64 +17742,22 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
17712
17742
  src: 'balanceDerived',
17713
17743
  inverted: false,
17714
17744
  fromSigned: false,
17745
+ derived: true,
17715
17746
  mirror: true,
17716
- staleMs: {
17717
- balance: 0,
17718
- batteryPower: this._nwGetCacheAgeMs('batteryPower', now),
17719
- storageChargePower: this._nwGetCacheAgeMs('storageChargePower', now),
17720
- storageDischargePower: this._nwGetCacheAgeMs('storageDischargePower', now),
17721
- },
17747
+ staleMs: Object.assign({ balance: 0 }, ageInfo()),
17722
17748
  };
17723
17749
  } catch (_eBalance) {
17724
17750
  return null;
17725
17751
  }
17726
17752
  };
17727
17753
 
17728
- const preferBalance = (current) => {
17729
- try {
17730
- const measured = Math.max(0, Math.abs(Number(current && current.chargeW) || 0) + Math.abs(Number(current && current.dischargeW) || 0));
17731
- const srcCur = String(current && current.src || '');
17732
- const missingLike = !current || srcCur === 'missing' || srcCur === 'stale-or-missing';
17733
- const derived = fromBalance();
17734
- if (!derived) return current;
17735
- if (missingLike || measured <= Math.max(180, deadbandW)) return derived;
17736
- return current;
17737
- } catch (_ePrefer) {
17738
- return current;
17739
- }
17740
- };
17741
-
17742
- const sanitizeSeparateBatteryFlow = (flow) => {
17743
- try {
17744
- if (!flow || String(flow.src || '').indexOf('chargeDischarge') < 0) return flow;
17745
- const hasDirectLoad = this._nwHasMappedDatapoint('consumptionTotal') || this._nwHasMappedDatapoint('housePower');
17746
- if (hasDirectLoad) return flow;
17747
- const grid = this._nwResolveGridImportExportFromCache ? this._nwResolveGridImportExportFromCache() : null;
17748
- const sellW = Math.max(0, Number(grid && grid.gridSellW) || 0);
17749
- const dischargeW = Math.max(0, Number(flow.dischargeW) || 0);
17750
- const chargeW = Math.max(0, Number(flow.chargeW) || 0);
17751
- const limitW = Math.max(250, deadbandW * 10);
17752
- if (sellW > limitW && dischargeW > limitW && chargeW <= limitW) {
17753
- return Object.assign({}, flow, {
17754
- chargeW: 0,
17755
- dischargeW: 0,
17756
- signedW: 0,
17757
- src: String(flow.src || 'chargeDischarge') + '+sanitized-export-discharge',
17758
- rejectedDischargeW: Math.round(dischargeW),
17759
- sanitized: true,
17760
- mirror: true
17761
- });
17762
- }
17763
- } catch (_eSanitize) {}
17764
- return flow;
17765
- };
17766
-
17767
- // Speicherfarm already provides normalized charge/discharge totals. Keep it authoritative
17768
- // unless a signed single battery datapoint is explicitly mapped for a non-farm setup.
17769
- const sfEnabled = !!(this.stateCache && this.stateCache['storageFarm.enabled'] && this.stateCache['storageFarm.enabled'].value);
17754
+ // Speicherfarm nur dann als Quelle verwenden, wenn sie in der Admin-Konfiguration
17755
+ // wirklich aktiv ist und konfigurierte Speicher enthält. Ein alter stateCache-Wert
17756
+ // "storageFarm.enabled=true" darf normale Einzelanlagen nicht übernehmen.
17757
+ const sfEnabled = this._nwStorageFarmIsActiveFromCache && this._nwStorageFarmIsActiveFromCache();
17770
17758
  if (sfEnabled) {
17771
- const farmCharge = fresh('storageFarm.totalChargePowerW', false);
17772
- const farmDischarge = fresh('storageFarm.totalDischargePowerW', false);
17759
+ const farmCharge = readMapped('storageFarm.totalChargePowerW', false, false);
17760
+ const farmDischarge = readMapped('storageFarm.totalDischargePowerW', false, false);
17773
17761
  if (farmCharge !== null || farmDischarge !== null) {
17774
17762
  let c = Math.max(0, Math.abs(Number(farmCharge || 0)));
17775
17763
  let d = Math.max(0, Math.abs(Number(farmDischarge || 0)));
@@ -17781,6 +17769,7 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
17781
17769
  src: inv ? 'storageFarm(inv)' : 'storageFarm',
17782
17770
  inverted: inv,
17783
17771
  fromSigned: false,
17772
+ derived: false,
17784
17773
  mirror: true,
17785
17774
  staleMs: {
17786
17775
  farmCharge: this._nwGetCacheAgeMs('storageFarm.totalChargePowerW', now),
@@ -17790,30 +17779,19 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
17790
17779
  }
17791
17780
  }
17792
17781
 
17793
- const batterySigned = batteryMapped ? rawFresh('batteryPower', true) : null;
17794
- const chargeRaw = chargeMapped ? rawFresh('storageChargePower', true) : null;
17795
- const dischargeRaw = dischargeMapped ? rawFresh('storageDischargePower', true) : null;
17782
+ const batterySigned = batteryMapped ? readMapped('batteryPower', true, true) : null;
17783
+ const chargeRaw = chargeMapped ? readMapped('storageChargePower', true, true) : null;
17784
+ const dischargeRaw = dischargeMapped ? readMapped('storageDischargePower', true, true) : null;
17796
17785
 
17797
- // If charge/discharge were both mapped to the same signed datapoint, keep the sign.
17798
- // updateValue() normalizes their public state values to magnitudes, so the private raw cache is used here.
17786
+ // Beide Split-Felder auf denselben DP gemappt = tatsächlich ein signed DP.
17799
17787
  if (sameChargeDischargeId && chargeRaw !== null) {
17800
- return preferBalance(fromSigned(chargeRaw, 'sameChargeDischargeSigned', { mirror: true }));
17788
+ return fromSigned(chargeRaw, 'sameChargeDischargeSigned', { mirror: true });
17801
17789
  }
17802
17790
 
17803
- // Canonical single signed DP fallback: exactly like NVP signed handling.
17804
- // Use it when no separate channels are mapped, when separate channels are missing/stale,
17805
- // or when stale/legacy mirrored values would otherwise show both directions at once.
17806
- const separateAvailable = (chargeRaw !== null || dischargeRaw !== null);
17807
- const publicCharge = chargeMapped ? fresh('storageChargePower', true) : null;
17808
- const publicDischarge = dischargeMapped ? fresh('storageDischargePower', true) : null;
17809
- const bothPublicDirections = (Number(publicCharge || 0) > deadbandW && Number(publicDischarge || 0) > deadbandW);
17810
- const bothEqualish = bothPublicDirections && Math.abs(Math.abs(Number(publicCharge || 0)) - Math.abs(Number(publicDischarge || 0))) <= Math.max(2, deadbandW);
17811
-
17812
- if (batterySigned !== null && (!separateAvailable || bothEqualish || (!chargeMapped && !dischargeMapped))) {
17813
- return preferBalance(fromSigned(batterySigned, bothEqualish ? 'batterySignedOverrideDual' : 'batterySigned', { mirror: true }));
17814
- }
17815
-
17816
- if (separateAvailable) {
17791
+ // Getrennte Lade-/Entlade-DPs sind autoritativ. Eine fehlende Seite wird als 0 W
17792
+ // behandelt; sie wird nicht durch Bilanzwerte ersetzt. Das schützt Historie und
17793
+ // Regelung vor verfälschten Speicherwerten bei konstantem/stalem 0-Wert.
17794
+ if (chargeRaw !== null || dischargeRaw !== null) {
17817
17795
  let c = chargeRaw !== null ? Math.abs(Number(chargeRaw)) : 0;
17818
17796
  let d = dischargeRaw !== null ? Math.abs(Number(dischargeRaw)) : 0;
17819
17797
  if (!Number.isFinite(c)) c = 0;
@@ -17821,39 +17799,43 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
17821
17799
  if (c <= deadbandW) c = 0;
17822
17800
  if (d <= deadbandW) d = 0;
17823
17801
  if (inv) { const t = c; c = d; d = t; }
17824
- return preferBalance(sanitizeSeparateBatteryFlow({
17802
+ return {
17825
17803
  chargeW: Math.round(c),
17826
17804
  dischargeW: Math.round(d),
17827
17805
  signedW: Math.round(d - c),
17828
17806
  src: inv ? 'chargeDischarge(inv)' : 'chargeDischarge',
17829
17807
  inverted: inv,
17830
17808
  fromSigned: false,
17831
- mirror: sameChargeDischargeId || !chargeMapped || !dischargeMapped,
17832
- staleMs: {
17833
- storageChargePower: this._nwGetCacheAgeMs('storageChargePower', now),
17834
- storageDischargePower: this._nwGetCacheAgeMs('storageDischargePower', now),
17835
- },
17836
- }));
17809
+ derived: false,
17810
+ mirror: false,
17811
+ staleMs: ageInfo(),
17812
+ };
17837
17813
  }
17838
17814
 
17815
+ // Signed Batterie-DP ist der Fallback, wenn keine Split-DPs einen Wert liefern.
17839
17816
  if (batterySigned !== null) {
17840
- return preferBalance(fromSigned(batterySigned, 'batterySigned', { mirror: true }));
17817
+ return fromSigned(batterySigned, 'batterySigned', { mirror: true });
17841
17818
  }
17842
17819
 
17843
- return preferBalance({
17820
+ // Rechen-Fallback nur, wenn überhaupt kein Speicher-DP konfiguriert ist.
17821
+ // Wenn ein Speicher-DP konfiguriert, aber aktuell nicht lesbar ist, zeigen wir keinen
17822
+ // geratenen Wert, damit Historie/Regelung nicht verfälscht werden.
17823
+ if (!anyStorageMapped) {
17824
+ const derived = fromBalance();
17825
+ if (derived) return derived;
17826
+ }
17827
+
17828
+ return {
17844
17829
  chargeW: 0,
17845
17830
  dischargeW: 0,
17846
17831
  signedW: 0,
17847
- src: (batteryMapped || chargeMapped || dischargeMapped) ? 'stale-or-missing' : 'missing',
17832
+ src: anyStorageMapped ? 'mapped-missing' : 'missing',
17848
17833
  inverted: inv,
17849
17834
  fromSigned: false,
17850
- mirror: (!chargeMapped || !dischargeMapped),
17851
- staleMs: {
17852
- batteryPower: this._nwGetCacheAgeMs('batteryPower', now),
17853
- storageChargePower: this._nwGetCacheAgeMs('storageChargePower', now),
17854
- storageDischargePower: this._nwGetCacheAgeMs('storageDischargePower', now),
17855
- },
17856
- });
17835
+ derived: false,
17836
+ mirror: !anyStorageMapped,
17837
+ staleMs: ageInfo(),
17838
+ };
17857
17839
  }
17858
17840
 
17859
17841
  _nwResolveGridImportExportFromCache() {
@@ -18053,7 +18035,7 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
18053
18035
  // In Farm-/DC-Speicher-Setups kommt ein Teil der PV-Leistung direkt aus den Speichersystemen (DC-PV).
18054
18036
  // Diese Summe wird unter storageFarm.totalPvPowerW bereitgestellt und soll auch in der Historie/Abrechnung
18055
18037
  // zur PV-Erzeugung addiert werden (mit einfacher Double-Count-Heuristik analog zum Energiefluss-Monitor).
18056
- const sfEnabled = !!this._nwGetNumberFromCache('storageFarm.enabled');
18038
+ const sfEnabled = this._nwStorageFarmIsActiveFromCache ? this._nwStorageFarmIsActiveFromCache() : !!this._nwGetNumberFromCache('storageFarm.enabled');
18057
18039
  const pvFarmW = this._nwGetNumberFromCache('storageFarm.totalPvPowerW');
18058
18040
  if (sfEnabled && Number.isFinite(pvFarmW) && pvFarmW > 0) {
18059
18041
  const farmAbs = Math.abs(pvFarmW);
@@ -19131,7 +19113,7 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
19131
19113
  }
19132
19114
 
19133
19115
  // --- PV (DC) from Speicherfarm (optional) ---
19134
- const sfEnabled = !!(this.stateCache?.['storageFarm.enabled'] && this.stateCache['storageFarm.enabled'].value);
19116
+ const sfEnabled = this._nwStorageFarmIsActiveFromCache ? this._nwStorageFarmIsActiveFromCache() : !!(this.stateCache?.['storageFarm.enabled'] && this.stateCache['storageFarm.enabled'].value);
19135
19117
  let pvDcW = 0;
19136
19118
  if (sfEnabled) {
19137
19119
  const dc = this._nwGetNumberFromCache('storageFarm.totalPvPowerW');
@@ -19373,27 +19355,42 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
19373
19355
  }
19374
19356
  }
19375
19357
 
19376
- // 4) If storage is resolved from a signed fallback (or farm/auto values), mirror the
19377
- // normalized pair into the public keys. This is the battery equivalent of the NVP
19378
- // import/export fallback and keeps tiles, history and downstream modules aligned.
19358
+ // 4) Mirror normalized storage values only where it is safe:
19359
+ // - signed DP -> public split states (when split DPs are not mapped)
19360
+ // - storage farm / calculated fallback -> public states (when no real split DP owns them)
19361
+ // - same DP in charge+discharge fields -> overwrite both with the normalized split
19362
+ // Real separate charge/discharge DPs are never overwritten by a fallback calculation.
19379
19363
  try {
19380
19364
  const dps = (this.config && this.config.datapoints) || {};
19381
19365
  const chargeMapped = !!String(dps.storageChargePower || '').trim();
19382
19366
  const dischargeMapped = !!String(dps.storageDischargePower || '').trim();
19367
+ const batteryMapped = !!String(dps.batteryPower || '').trim();
19383
19368
  const samePair = chargeMapped && dischargeMapped && String(dps.storageChargePower || '').trim() === String(dps.storageDischargePower || '').trim();
19384
- const shouldMirrorStorage = !!(storageFlow && (storageFlow.mirror || samePair || !chargeMapped || !dischargeMapped));
19369
+ const src = String(storageFlow && storageFlow.src || '');
19370
+ const fromSignedOnly = !!(storageFlow && storageFlow.fromSigned && !chargeMapped && !dischargeMapped);
19371
+ const fromFarmOrBalance = !!(storageFlow && (src.indexOf('storageFarm') === 0 || src.indexOf('balanceDerived') === 0));
19372
+ const noSplitMapped = !chargeMapped && !dischargeMapped;
19373
+ const shouldMirrorBoth = !!(samePair || fromSignedOnly || (noSplitMapped && fromFarmOrBalance));
19374
+ const shouldZeroMissingSide = !!(storageFlow && !storageFlow.derived && (chargeMapped !== dischargeMapped));
19385
19375
  const chargeRound = Math.round(chargeW);
19386
19376
  const dischargeRound = Math.round(dischargeW);
19387
- if (shouldMirrorStorage) {
19388
- const curC = Number(this.stateCache?.storageChargePower?.value);
19389
- const curD = Number(this.stateCache?.storageDischargePower?.value);
19390
- if (!Number.isFinite(curC) || curC !== chargeRound) this.updateValue('storageChargePower', chargeRound, ts, { raw: false });
19391
- if (!Number.isFinite(curD) || curD !== dischargeRound) this.updateValue('storageDischargePower', dischargeRound, ts, { raw: false });
19392
- }
19393
- if (!this._nwHasMappedDatapoint('batteryPower') || (storageFlow && storageFlow.src === 'balanceDerived')) {
19377
+ const updateLocal = (k, v) => {
19378
+ const cur = Number(this.stateCache?.[k]?.value);
19379
+ if (!Number.isFinite(cur) || cur !== v) this.updateValue(k, v, ts, { raw: false });
19380
+ };
19381
+ if (shouldMirrorBoth) {
19382
+ updateLocal('storageChargePower', chargeRound);
19383
+ updateLocal('storageDischargePower', dischargeRound);
19384
+ } else if (shouldZeroMissingSide) {
19385
+ if (!chargeMapped) updateLocal('storageChargePower', chargeRound);
19386
+ if (!dischargeMapped) updateLocal('storageDischargePower', dischargeRound);
19387
+ }
19388
+ // batteryPower is an internal signed convenience value when no signed DP is mapped.
19389
+ // It may be derived from valid split DPs, farm totals or a calculated fallback, but
19390
+ // it must never overwrite a configured signed battery DP.
19391
+ if (!batteryMapped) {
19394
19392
  const signedRound = Math.round(dischargeW - chargeW);
19395
- const curB = Number(this.stateCache?.batteryPower?.value);
19396
- if (!Number.isFinite(curB) || curB !== signedRound) this.updateValue('batteryPower', signedRound, ts, { raw: false });
19393
+ updateLocal('batteryPower', signedRound);
19397
19394
  }
19398
19395
  } catch (_eStorageMirror) {}
19399
19396
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "iobroker.nexowatt-ui",
3
- "version": "0.7.46",
3
+ "version": "0.7.48",
4
4
  "description": "Responsive NexoWatt EMS visualization adapter.",
5
5
  "author": "NexoWatt",
6
6
  "license": "Proprietary License (NPL) v1.0",
package/www/app.js CHANGED
@@ -2040,6 +2040,12 @@ function getFreshFlowNumber(key, opts = {}) {
2040
2040
  return n;
2041
2041
  }
2042
2042
 
2043
+ function getStableFlowNumber(key, opts = {}) {
2044
+ // Kern-Energiefluss-DPs dürfen nicht als fehlend gelten, nur weil ein konstanter
2045
+ // Wert (typisch 0 W bei Speicher Laden/Entladen) lange nicht geändert wurde.
2046
+ return getFreshFlowNumber(key, Object.assign({}, opts, { maxAgeMs: null }));
2047
+ }
2048
+
2043
2049
  function getConfiguredDatapointId(key) {
2044
2050
  try {
2045
2051
  const cfg = window.__nwCfg || {};
@@ -2057,7 +2063,7 @@ function getBalanceDerivedBatteryFlow(opts = {}) {
2057
2063
  const read = (k) => st && st[k] ? st[k].value : undefined;
2058
2064
 
2059
2065
  // In Speicherfarm-Anlagen sind die Farm-Summen die Quelle der Wahrheit.
2060
- if (nwAsBool(read('storageFarm.enabled'), false)) return null;
2066
+ if (nwStorageFarmFeatureFromConfig(window.__nwCfg || {}, st)) return null;
2061
2067
 
2062
2068
  const soc = coerceNumber(read('storageSoc') ?? read('batterySOC'));
2063
2069
  if (soc === null) return null;
@@ -2109,13 +2115,15 @@ function getBalanceDerivedBatteryFlow(opts = {}) {
2109
2115
  function preferBalanceDerivedBatteryFlow(current, opts = {}) {
2110
2116
  try {
2111
2117
  const deadbandW = Number.isFinite(Number(opts.deadbandW)) ? Math.max(180, Number(opts.deadbandW)) : 180;
2112
- const measured = Math.max(0, Math.abs(Number(current && current.chargeW) || 0) + Math.abs(Number(current && current.dischargeW) || 0));
2113
2118
  const src = String(current && current.src || '');
2114
- const missingLike = !current || src === 'missing' || src === 'stale-or-missing';
2119
+ const missingLike = !current || src === 'missing' || src === 'stale-or-missing' || current.incomplete === true;
2120
+ if (!missingLike) return current;
2115
2121
  const derived = getBalanceDerivedBatteryFlow({ deadbandW });
2116
2122
  if (!derived) return current;
2117
- if (missingLike || measured <= deadbandW) return derived;
2118
- return current;
2123
+ return Object.assign({}, derived, {
2124
+ src: String(derived.src || 'balanceDerived') + (current && current.incomplete ? '+missing-side' : ''),
2125
+ fallbackFor: src || 'missing'
2126
+ });
2119
2127
  } catch (_e) {
2120
2128
  return current;
2121
2129
  }
@@ -2130,6 +2138,7 @@ function getNormalizedBatteryFlow() {
2130
2138
  const chargeMapped = !!chargeId;
2131
2139
  const dischargeMapped = !!dischargeId;
2132
2140
  const batteryMapped = !!batteryId;
2141
+ const anyStorageMapped = chargeMapped || dischargeMapped || batteryMapped;
2133
2142
  const samePair = !!(chargeMapped && dischargeMapped && chargeId === dischargeId);
2134
2143
 
2135
2144
  const fromSigned = (raw, src) => {
@@ -2143,88 +2152,59 @@ function getNormalizedBatteryFlow() {
2143
2152
  signedW: signed,
2144
2153
  src,
2145
2154
  inverted: inv,
2155
+ fromSigned: true,
2156
+ derived: false,
2146
2157
  };
2147
2158
  };
2148
2159
 
2149
- const sanitizeSeparateBatteryFlow = (flow) => {
2150
- try {
2151
- if (!flow || String(flow.src || '').indexOf('chargeDischarge') < 0) return flow;
2152
- // In a normal AC-coupled house setup a storage discharge while the NVP is
2153
- // exporting and no direct house-load meter is configured is almost always a
2154
- // vendor-/alias-side ghost value (seen with some nexowatt-devices powerDischarge aliases).
2155
- // Without a direct load meter this value would inflate the building load and
2156
- // eat the PV budget. Keep true signed batteryPower authoritative, but guard
2157
- // the separate charge/discharge pair.
2158
- const hasDirectLoad = isMappedDatapoint('consumptionTotal') || isMappedDatapoint('housePower');
2159
- if (hasDirectLoad) return flow;
2160
- const grid = getGridImportExport((k) => state && state[k] ? state[k].value : undefined);
2161
- const sellW = Math.max(0, Number(grid && grid.sell) || 0);
2162
- const dischargeW = Math.max(0, Number(flow.dischargeW) || 0);
2163
- const chargeW = Math.max(0, Number(flow.chargeW) || 0);
2164
- const limitW = Math.max(250, deadbandW * 10);
2165
- if (sellW > limitW && dischargeW > limitW && chargeW <= limitW) {
2166
- return Object.assign({}, flow, {
2167
- chargeW: 0,
2168
- dischargeW: 0,
2169
- signedW: 0,
2170
- src: String(flow.src || 'chargeDischarge') + '+sanitized-export-discharge',
2171
- rejectedDischargeW: Math.round(dischargeW),
2172
- sanitized: true,
2173
- });
2174
- }
2175
- } catch (_e) {}
2176
- return flow;
2177
- };
2178
-
2179
- const sfEnabled = !!(state && state['storageFarm.enabled'] && state['storageFarm.enabled'].value);
2160
+ const sfEnabled = nwStorageFarmFeatureFromConfig(window.__nwCfg || {}, state || window.latestState || {});
2180
2161
  if (sfEnabled) {
2181
- const fc = getFreshFlowNumber('storageFarm.totalChargePowerW');
2182
- const fd = getFreshFlowNumber('storageFarm.totalDischargePowerW');
2162
+ const fc = getStableFlowNumber('storageFarm.totalChargePowerW');
2163
+ const fd = getStableFlowNumber('storageFarm.totalDischargePowerW');
2183
2164
  if (fc !== null || fd !== null) {
2184
2165
  let c = Math.max(0, Math.abs(Number(fc || 0)));
2185
2166
  let d = Math.max(0, Math.abs(Number(fd || 0)));
2186
2167
  if (inv) { const t = c; c = d; d = t; }
2187
2168
  if (c <= deadbandW) c = 0;
2188
2169
  if (d <= deadbandW) d = 0;
2189
- return { chargeW: c, dischargeW: d, signedW: d - c, src: inv ? 'storageFarm(inv)' : 'storageFarm', inverted: inv };
2170
+ return { chargeW: c, dischargeW: d, signedW: d - c, src: inv ? 'storageFarm(inv)' : 'storageFarm', inverted: inv, fromSigned: false, derived: false };
2190
2171
  }
2191
2172
  }
2192
2173
 
2193
- const signedBattery = batteryMapped ? getFreshFlowNumber('batteryPower') : null;
2194
- const charge = chargeMapped ? getFreshFlowNumber('storageChargePower') : null;
2195
- const discharge = dischargeMapped ? getFreshFlowNumber('storageDischargePower') : null;
2196
-
2197
- if (samePair && signedBattery !== null) return preferBalanceDerivedBatteryFlow(fromSigned(signedBattery, 'batterySignedForSamePair'), { deadbandW });
2198
-
2199
- const separateAvailable = (charge !== null || discharge !== null);
2200
- const bothDirections = Math.abs(Number(charge || 0)) > deadbandW && Math.abs(Number(discharge || 0)) > deadbandW;
2201
- const bothEqualish = bothDirections && Math.abs(Math.abs(Number(charge || 0)) - Math.abs(Number(discharge || 0))) <= Math.max(2, deadbandW);
2174
+ // Gemappte Speicher-DPs stabil lesen: ein unveränderter 0-Wert darf nicht wegen
2175
+ // seines Alters verworfen und durch eine Bilanzrechnung ersetzt werden.
2176
+ const signedBattery = batteryMapped ? getStableFlowNumber('batteryPower') : null;
2177
+ const charge = chargeMapped ? getStableFlowNumber('storageChargePower') : null;
2178
+ const discharge = dischargeMapped ? getStableFlowNumber('storageDischargePower') : null;
2202
2179
 
2203
- if (signedBattery !== null && (!separateAvailable || bothEqualish || (!chargeMapped && !dischargeMapped))) {
2204
- return preferBalanceDerivedBatteryFlow(fromSigned(signedBattery, bothEqualish ? 'batterySignedOverrideDual' : 'batterySigned'), { deadbandW });
2205
- }
2180
+ if (samePair && charge !== null) return fromSigned(charge, 'sameChargeDischargeSigned');
2206
2181
 
2207
- if (separateAvailable) {
2182
+ if (charge !== null || discharge !== null) {
2208
2183
  let c = Math.max(0, Math.abs(Number(charge || 0)));
2209
2184
  let d = Math.max(0, Math.abs(Number(discharge || 0)));
2210
2185
  if (c <= deadbandW) c = 0;
2211
2186
  if (d <= deadbandW) d = 0;
2212
2187
  if (inv) { const t = c; c = d; d = t; }
2213
- return preferBalanceDerivedBatteryFlow(sanitizeSeparateBatteryFlow({ chargeW: c, dischargeW: d, signedW: d - c, src: inv ? 'chargeDischarge(inv)' : 'chargeDischarge', inverted: inv }), { deadbandW });
2188
+ return { chargeW: c, dischargeW: d, signedW: d - c, src: inv ? 'chargeDischarge(inv)' : 'chargeDischarge', inverted: inv, fromSigned: false, derived: false };
2214
2189
  }
2215
2190
 
2216
- if (signedBattery !== null) return preferBalanceDerivedBatteryFlow(fromSigned(signedBattery, 'batterySigned'), { deadbandW });
2191
+ if (signedBattery !== null) return fromSigned(signedBattery, 'batterySigned');
2217
2192
 
2218
- return preferBalanceDerivedBatteryFlow({ chargeW: 0, dischargeW: 0, signedW: 0, src: (batteryMapped || chargeMapped || dischargeMapped) ? 'stale-or-missing' : 'missing', inverted: inv }, { deadbandW });
2219
- }
2193
+ // Rechen-Fallback nur bei wirklich nicht konfiguriertem Speicher-DP.
2194
+ if (!anyStorageMapped) {
2195
+ const derived = getBalanceDerivedBatteryFlow({ deadbandW: Math.max(180, deadbandW) });
2196
+ if (derived) return derived;
2197
+ }
2220
2198
 
2199
+ return { chargeW: 0, dischargeW: 0, signedW: 0, src: anyStorageMapped ? 'mapped-missing' : 'missing', inverted: inv, fromSigned: false, derived: false };
2200
+ }
2221
2201
  function render() {
2222
2202
  const s = state;
2223
2203
 
2224
2204
  const d = (k) => s[k]?.value;
2225
2205
 
2226
2206
  // Top ring values: map PV, Grid, Load, Bat flows to percent of max for visualization
2227
- const sfEnabled = !!(s['storageFarm.enabled']?.value);
2207
+ const sfEnabled = nwStorageFarmFeatureFromConfig(window.__nwCfg || {}, s || state || {});
2228
2208
  const pvMapped = isMappedDatapoint('pvPower') || isMappedDatapoint('productionTotal');
2229
2209
 
2230
2210
  // PV (W): primary from mapped PV datapoint; fallback to productionTotal if used as power DP.
@@ -6053,7 +6033,7 @@ function updateEnergyWeb() {
6053
6033
  const s = window.latestState || {};
6054
6034
 
6055
6035
  // Raw datapoints (1:1)
6056
- const sfEnabled = !!(s['storageFarm.enabled']?.value);
6036
+ const sfEnabled = nwStorageFarmFeatureFromConfig(window.__nwCfg || {}, s || state || {});
6057
6037
  const pvMapped = isMappedDatapoint('pvPower') || isMappedDatapoint('productionTotal');
6058
6038
 
6059
6039
  // PV (W): primary from mapped PV datapoint; fallback to productionTotal if used as power DP.
package/www/ems-apps.js CHANGED
@@ -2701,6 +2701,36 @@ function _collectFlowPowerDpIsWFromUI() {
2701
2701
  return inp;
2702
2702
  }
2703
2703
 
2704
+ function _mkHeatingRodNumberInput(key, value, onChange, opts = {}) {
2705
+ const inp = _mkCfgInput('number', value, onChange, opts);
2706
+ inp.dataset.heatingRodCfgKey = String(key || '');
2707
+ inp.id = `heatingRod_${String(key || '').replace(/[^a-zA-Z0-9_-]/g, '_')}`;
2708
+ return inp;
2709
+ }
2710
+
2711
+ function flushHeatingRodConfigFromDom() {
2712
+ try {
2713
+ if (!document || !document.querySelectorAll) return;
2714
+ currentConfig = currentConfig || {};
2715
+ currentConfig.heatingRod = (currentConfig.heatingRod && typeof currentConfig.heatingRod === 'object') ? currentConfig.heatingRod : {};
2716
+ const h = currentConfig.heatingRod;
2717
+ const numericKeys = new Set([
2718
+ 'storageReserveW', 'storageTargetSocPct', 'minPvPowerW', 'budgetSafetyReserveW',
2719
+ 'stageUpDelaySec', 'minStageRunSec', 'cooldownAfterOffSec', 'maxGridImportW',
2720
+ 'gridImportHoldSec', 'storageDischargeToleranceW', 'storageDischargeHoldSec'
2721
+ ]);
2722
+ document.querySelectorAll('[data-heating-rod-cfg-key]').forEach((el) => {
2723
+ const key = String(el.dataset.heatingRodCfgKey || '').trim();
2724
+ if (!key || !numericKeys.has(key)) return;
2725
+ const n = Number(el.value);
2726
+ if (!Number.isFinite(n)) return;
2727
+ if (key === 'storageTargetSocPct') h[key] = Math.max(0, Math.min(100, Math.round(n)));
2728
+ else h[key] = Math.max(0, Math.round(n));
2729
+ });
2730
+ } catch (_e) {}
2731
+ }
2732
+
2733
+
2704
2734
  function _mkCfgSelect(value, options, onChange, opts = {}) {
2705
2735
  const sel = document.createElement('select');
2706
2736
  sel.className = opts.className || 'nw-config-select';
@@ -3038,10 +3068,10 @@ function _collectFlowPowerDpIsWFromUI() {
3038
3068
  autoInfo.style.flexBasis = '100%';
3039
3069
  autoInfo.textContent = 'Zentrale EMS-Budget-Gates lesen, PV/NVP-Überschuss verfolgen und eigene PV-Auto-Stufen halten. Externe KNX-/Relais-Schaltungen werden nur beobachtet.';
3040
3070
  grpAuto.body.appendChild(autoInfo);
3041
- grpAuto.body.appendChild(_mkCfgField('Speicher-Reserve (W)', _mkCfgInput('number', cfg.storageReserveW, (v) => { cfg.storageReserveW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 50, width: '150px' }), 'Bleibt für Speicherladung frei, solange der Speicher unter dem Ziel-SoC liegt.'));
3042
- grpAuto.body.appendChild(_mkCfgField('Reserve bis SoC (%)', _mkCfgInput('number', cfg.storageTargetSocPct, (v) => { cfg.storageTargetSocPct = Math.max(0, Math.min(100, Math.round(Number(v) || 0))); setDirty(); }, { min: 0, max: 100, step: 1, width: '130px' }), 'Ab diesem SoC darf der Heizstab den Überschuss ohne Speicherreserve nutzen.'));
3043
- grpAuto.body.appendChild(_mkCfgField('PV-Auto ab PV (W)', _mkCfgInput('number', cfg.minPvPowerW, (v) => { cfg.minPvPowerW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 50, width: '150px' }), 'Start-/Hochschaltgrenze. Unterhalb wird nicht neu zugeschaltet, laufende Auto-Stufen werden aber über Netz-/Speichergates stabil gehalten.'));
3044
- grpAuto.body.appendChild(_mkCfgField('Sicherheitsreserve (W)', _mkCfgInput('number', cfg.budgetSafetyReserveW, (v) => { cfg.budgetSafetyReserveW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Abzug vom Heizstab-Budget gegen Messrauschen.'));
3071
+ grpAuto.body.appendChild(_mkCfgField('Speicher-Reserve (W)', _mkHeatingRodNumberInput('storageReserveW', cfg.storageReserveW, (v) => { cfg.storageReserveW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 50, width: '150px' }), 'Bleibt für Speicherladung frei, solange der Speicher unter dem Ziel-SoC liegt.'));
3072
+ grpAuto.body.appendChild(_mkCfgField('Reserve bis SoC (%)', _mkHeatingRodNumberInput('storageTargetSocPct', cfg.storageTargetSocPct, (v) => { cfg.storageTargetSocPct = Math.max(0, Math.min(100, Math.round(Number(v) || 0))); setDirty(); }, { min: 0, max: 100, step: 1, width: '130px' }), 'Ab diesem SoC darf der Heizstab den Überschuss ohne Speicherreserve nutzen.'));
3073
+ grpAuto.body.appendChild(_mkCfgField('PV-Auto ab PV (W)', _mkHeatingRodNumberInput('minPvPowerW', cfg.minPvPowerW, (v) => { cfg.minPvPowerW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 50, width: '150px' }), 'Start-/Hochschaltgrenze. Unterhalb wird nicht neu zugeschaltet, laufende Auto-Stufen werden aber über Netz-/Speichergates stabil gehalten.'));
3074
+ grpAuto.body.appendChild(_mkCfgField('Sicherheitsreserve (W)', _mkHeatingRodNumberInput('budgetSafetyReserveW', cfg.budgetSafetyReserveW, (v) => { cfg.budgetSafetyReserveW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Abzug vom Heizstab-Budget gegen Messrauschen.'));
3045
3075
  els.heatingRodDevices.appendChild(grpAuto.wrap);
3046
3076
 
3047
3077
  const grpSwitch = _mkCfgGroup('Robustes Schalten');
@@ -3050,13 +3080,13 @@ function _collectFlowPowerDpIsWFromUI() {
3050
3080
  switchInfo.style.flexBasis = '100%';
3051
3081
  switchInfo.textContent = 'Hysterese gegen Netz- und WR-Schwankungen: erst stabil hochfahren, bei kleinem Netzbezug halten und nur nach Haltezeit reduzieren.';
3052
3082
  grpSwitch.body.appendChild(switchInfo);
3053
- grpSwitch.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' }), 'Maximal eine physische Stufe pro Wartezeit.'));
3054
- grpSwitch.body.appendChild(_mkCfgField('Min. Laufzeit Auto-Stufe (s)', _mkCfgInput('number', cfg.minStageRunSec, (v) => { cfg.minStageRunSec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '170px' }), 'Verhindert nervöses Runterschalten bei kurzen Budget-Dellen.'));
3055
- grpSwitch.body.appendChild(_mkCfgField('Cooldown nach Abwurf (s)', _mkCfgInput('number', cfg.cooldownAfterOffSec, (v) => { cfg.cooldownAfterOffSec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '170px' }), 'Wartezeit bevor nach komplettem AUS wieder gestartet wird.'));
3056
- grpSwitch.body.appendChild(_mkCfgField('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' }), 'Kleiner erlaubter Bezug, damit der Heizstab bei NVP-Schwankungen an bleibt.'));
3057
- grpSwitch.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: '160px' }), 'Erst wenn der Bezug so lange überschritten ist, wird eine Auto-Stufe reduziert.'));
3058
- grpSwitch.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: '170px' }), 'Akku-Schutz: kurze Messdellen sind erlaubt, dauerhafte Entladung reduziert Auto-Stufen.'));
3059
- grpSwitch.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: '190px' }), 'Dauer bis zur Reduzierung bei Akku-Entladung.'));
3083
+ grpSwitch.body.appendChild(_mkCfgField('Stufe-hoch Wartezeit (s)', _mkHeatingRodNumberInput('stageUpDelaySec', cfg.stageUpDelaySec, (v) => { cfg.stageUpDelaySec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '150px' }), 'Maximal eine physische Stufe pro Wartezeit.'));
3084
+ grpSwitch.body.appendChild(_mkCfgField('Min. Laufzeit Auto-Stufe (s)', _mkHeatingRodNumberInput('minStageRunSec', cfg.minStageRunSec, (v) => { cfg.minStageRunSec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '170px' }), 'Verhindert nervöses Runterschalten bei kurzen Budget-Dellen.'));
3085
+ grpSwitch.body.appendChild(_mkCfgField('Cooldown nach Abwurf (s)', _mkHeatingRodNumberInput('cooldownAfterOffSec', cfg.cooldownAfterOffSec, (v) => { cfg.cooldownAfterOffSec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '170px' }), 'Wartezeit bevor nach komplettem AUS wieder gestartet wird.'));
3086
+ grpSwitch.body.appendChild(_mkCfgField('Netzbezug erlaubt (W)', _mkHeatingRodNumberInput('maxGridImportW', cfg.maxGridImportW, (v) => { cfg.maxGridImportW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Kleiner erlaubter Bezug, damit der Heizstab bei NVP-Schwankungen an bleibt.'));
3087
+ grpSwitch.body.appendChild(_mkCfgField('Netzbezug Haltezeit (s)', _mkHeatingRodNumberInput('gridImportHoldSec', cfg.gridImportHoldSec, (v) => { cfg.gridImportHoldSec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '160px' }), 'Erst wenn der Bezug so lange überschritten ist, wird eine Auto-Stufe reduziert.'));
3088
+ grpSwitch.body.appendChild(_mkCfgField('Speicherentladung erlaubt (W)', _mkHeatingRodNumberInput('storageDischargeToleranceW', cfg.storageDischargeToleranceW, (v) => { cfg.storageDischargeToleranceW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '170px' }), 'Akku-Schutz: kurze Messdellen sind erlaubt, dauerhafte Entladung reduziert Auto-Stufen.'));
3089
+ grpSwitch.body.appendChild(_mkCfgField('Speicherentladung Haltezeit (s)', _mkHeatingRodNumberInput('storageDischargeHoldSec', cfg.storageDischargeHoldSec, (v) => { cfg.storageDischargeHoldSec = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 1, width: '190px' }), 'Dauer bis zur Reduzierung bei Akku-Entladung.'));
3060
3090
  els.heatingRodDevices.appendChild(grpSwitch.wrap);
3061
3091
 
3062
3092
  const grpProtect = _mkCfgDetailsGroup('Erweitert: harte Schutzgrenzen', false);
@@ -8135,6 +8165,7 @@ function _collectFlowPowerDpIsWFromUI() {
8135
8165
  }
8136
8166
 
8137
8167
  // Thermik / Heizstab (PV‑Auto für Verbraucher‑Slots)
8168
+ try { flushHeatingRodConfigFromDom(); } catch (_e) {}
8138
8169
  patch.thermal = deepMerge({}, currentConfig.thermal || {});
8139
8170
  patch.heatingRod = deepMerge({}, currentConfig.heatingRod || {});
8140
8171
  patch.bhkw = deepMerge({}, currentConfig.bhkw || {});
@@ -44,5 +44,5 @@
44
44
  "purpose": "maskable"
45
45
  }
46
46
  ],
47
- "version": "0.7.46"
47
+ "version": "0.7.48"
48
48
  }
package/www/sw.js CHANGED
@@ -1,6 +1,6 @@
1
1
  // Increment cache name on releases so browser updates JS/HTML reliably.
2
2
  // NOTE: Keep this monotonic to force SW updates on hotfixes.
3
- const CACHE_NAME = 'nexowatt-cache-v214';
3
+ const CACHE_NAME = 'nexowatt-cache-v216';
4
4
 
5
5
  const OFFLINE_URLS = [
6
6
  './',