iobroker.nexowatt-ui 0.7.47 → 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.
package/io-package.json CHANGED
@@ -1,8 +1,12 @@
1
1
  {
2
2
  "common": {
3
3
  "name": "nexowatt-ui",
4
- "version": "0.7.47",
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
+ },
6
10
  "0.7.47": {
7
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.",
8
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."
@@ -1991,7 +1995,7 @@
1991
1995
  }
1992
1996
  },
1993
1997
  "instanceObjects": [],
1994
- "version": "0.7.47",
1998
+ "version": "0.7.48",
1995
1999
  "news": {
1996
2000
  "0.7.42": {
1997
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) => {
17634
- if (onlyIfMapped && !idOf(key)) return null;
17635
- return this._nwGetNumberFromCacheFresh(key, maxAgeMs, null, now);
17636
- };
17637
- const rawFresh = (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) => {
17638
17662
  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,41 +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 srcCur = String(current && current.src || '');
17731
- const missingLike = !current || srcCur === 'missing' || srcCur === 'stale-or-missing' || current.incomplete === true;
17732
- if (!missingLike) return current;
17733
- const derived = fromBalance();
17734
- if (!derived) return current;
17735
- return Object.assign({}, derived, {
17736
- src: String(derived.src || 'balanceDerived') + (current && current.incomplete ? '+missing-side' : ''),
17737
- fallbackFor: srcCur || 'missing'
17738
- });
17739
- } catch (_ePrefer) {
17740
- return current;
17741
- }
17742
- };
17743
-
17744
- // Speicherfarm already provides normalized charge/discharge totals. Keep it authoritative
17745
- // unless a signed single battery datapoint is explicitly mapped for a non-farm setup.
17746
- 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();
17747
17758
  if (sfEnabled) {
17748
- const farmCharge = fresh('storageFarm.totalChargePowerW', false);
17749
- const farmDischarge = fresh('storageFarm.totalDischargePowerW', false);
17759
+ const farmCharge = readMapped('storageFarm.totalChargePowerW', false, false);
17760
+ const farmDischarge = readMapped('storageFarm.totalDischargePowerW', false, false);
17750
17761
  if (farmCharge !== null || farmDischarge !== null) {
17751
17762
  let c = Math.max(0, Math.abs(Number(farmCharge || 0)));
17752
17763
  let d = Math.max(0, Math.abs(Number(farmDischarge || 0)));
@@ -17758,6 +17769,7 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
17758
17769
  src: inv ? 'storageFarm(inv)' : 'storageFarm',
17759
17770
  inverted: inv,
17760
17771
  fromSigned: false,
17772
+ derived: false,
17761
17773
  mirror: true,
17762
17774
  staleMs: {
17763
17775
  farmCharge: this._nwGetCacheAgeMs('storageFarm.totalChargePowerW', now),
@@ -17767,30 +17779,19 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
17767
17779
  }
17768
17780
  }
17769
17781
 
17770
- const batterySigned = batteryMapped ? rawFresh('batteryPower', true) : null;
17771
- const chargeRaw = chargeMapped ? rawFresh('storageChargePower', true) : null;
17772
- 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;
17773
17785
 
17774
- // If charge/discharge were both mapped to the same signed datapoint, keep the sign.
17775
- // 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.
17776
17787
  if (sameChargeDischargeId && chargeRaw !== null) {
17777
- return preferBalance(fromSigned(chargeRaw, 'sameChargeDischargeSigned', { mirror: true }));
17778
- }
17779
-
17780
- // Canonical single signed DP fallback: exactly like NVP signed handling.
17781
- // Use it when no separate channels are mapped, when separate channels are missing/stale,
17782
- // or when stale/legacy mirrored values would otherwise show both directions at once.
17783
- const separateAvailable = (chargeRaw !== null || dischargeRaw !== null);
17784
- const publicCharge = chargeMapped ? fresh('storageChargePower', true) : null;
17785
- const publicDischarge = dischargeMapped ? fresh('storageDischargePower', true) : null;
17786
- const bothPublicDirections = (Number(publicCharge || 0) > deadbandW && Number(publicDischarge || 0) > deadbandW);
17787
- const bothEqualish = bothPublicDirections && Math.abs(Math.abs(Number(publicCharge || 0)) - Math.abs(Number(publicDischarge || 0))) <= Math.max(2, deadbandW);
17788
-
17789
- if (batterySigned !== null && (!separateAvailable || bothEqualish || (!chargeMapped && !dischargeMapped))) {
17790
- return preferBalance(fromSigned(batterySigned, bothEqualish ? 'batterySignedOverrideDual' : 'batterySigned', { mirror: true }));
17788
+ return fromSigned(chargeRaw, 'sameChargeDischargeSigned', { mirror: true });
17791
17789
  }
17792
17790
 
17793
- 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) {
17794
17795
  let c = chargeRaw !== null ? Math.abs(Number(chargeRaw)) : 0;
17795
17796
  let d = dischargeRaw !== null ? Math.abs(Number(dischargeRaw)) : 0;
17796
17797
  if (!Number.isFinite(c)) c = 0;
@@ -17798,41 +17799,43 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
17798
17799
  if (c <= deadbandW) c = 0;
17799
17800
  if (d <= deadbandW) d = 0;
17800
17801
  if (inv) { const t = c; c = d; d = t; }
17801
- const completePair = !!(chargeMapped && dischargeMapped && chargeRaw !== null && dischargeRaw !== null && !sameChargeDischargeId);
17802
- return preferBalance({
17802
+ return {
17803
17803
  chargeW: Math.round(c),
17804
17804
  dischargeW: Math.round(d),
17805
17805
  signedW: Math.round(d - c),
17806
17806
  src: inv ? 'chargeDischarge(inv)' : 'chargeDischarge',
17807
17807
  inverted: inv,
17808
17808
  fromSigned: false,
17809
- mirror: sameChargeDischargeId || !chargeMapped || !dischargeMapped,
17810
- incomplete: !completePair,
17811
- staleMs: {
17812
- storageChargePower: this._nwGetCacheAgeMs('storageChargePower', now),
17813
- storageDischargePower: this._nwGetCacheAgeMs('storageDischargePower', now),
17814
- },
17815
- });
17809
+ derived: false,
17810
+ mirror: false,
17811
+ staleMs: ageInfo(),
17812
+ };
17816
17813
  }
17817
17814
 
17815
+ // Signed Batterie-DP ist der Fallback, wenn keine Split-DPs einen Wert liefern.
17818
17816
  if (batterySigned !== null) {
17819
- return preferBalance(fromSigned(batterySigned, 'batterySigned', { mirror: true }));
17817
+ return fromSigned(batterySigned, 'batterySigned', { mirror: true });
17818
+ }
17819
+
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;
17820
17826
  }
17821
17827
 
17822
- return preferBalance({
17828
+ return {
17823
17829
  chargeW: 0,
17824
17830
  dischargeW: 0,
17825
17831
  signedW: 0,
17826
- src: (batteryMapped || chargeMapped || dischargeMapped) ? 'stale-or-missing' : 'missing',
17832
+ src: anyStorageMapped ? 'mapped-missing' : 'missing',
17827
17833
  inverted: inv,
17828
17834
  fromSigned: false,
17829
- mirror: (!chargeMapped || !dischargeMapped),
17830
- staleMs: {
17831
- batteryPower: this._nwGetCacheAgeMs('batteryPower', now),
17832
- storageChargePower: this._nwGetCacheAgeMs('storageChargePower', now),
17833
- storageDischargePower: this._nwGetCacheAgeMs('storageDischargePower', now),
17834
- },
17835
- });
17835
+ derived: false,
17836
+ mirror: !anyStorageMapped,
17837
+ staleMs: ageInfo(),
17838
+ };
17836
17839
  }
17837
17840
 
17838
17841
  _nwResolveGridImportExportFromCache() {
@@ -18032,7 +18035,7 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
18032
18035
  // In Farm-/DC-Speicher-Setups kommt ein Teil der PV-Leistung direkt aus den Speichersystemen (DC-PV).
18033
18036
  // Diese Summe wird unter storageFarm.totalPvPowerW bereitgestellt und soll auch in der Historie/Abrechnung
18034
18037
  // zur PV-Erzeugung addiert werden (mit einfacher Double-Count-Heuristik analog zum Energiefluss-Monitor).
18035
- const sfEnabled = !!this._nwGetNumberFromCache('storageFarm.enabled');
18038
+ const sfEnabled = this._nwStorageFarmIsActiveFromCache ? this._nwStorageFarmIsActiveFromCache() : !!this._nwGetNumberFromCache('storageFarm.enabled');
18036
18039
  const pvFarmW = this._nwGetNumberFromCache('storageFarm.totalPvPowerW');
18037
18040
  if (sfEnabled && Number.isFinite(pvFarmW) && pvFarmW > 0) {
18038
18041
  const farmAbs = Math.abs(pvFarmW);
@@ -19110,7 +19113,7 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
19110
19113
  }
19111
19114
 
19112
19115
  // --- PV (DC) from Speicherfarm (optional) ---
19113
- 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);
19114
19117
  let pvDcW = 0;
19115
19118
  if (sfEnabled) {
19116
19119
  const dc = this._nwGetNumberFromCache('storageFarm.totalPvPowerW');
@@ -19352,27 +19355,42 @@ Technische Details: system.adapter.${c.inst}.alive=false`,
19352
19355
  }
19353
19356
  }
19354
19357
 
19355
- // 4) If storage is resolved from a signed fallback (or farm/auto values), mirror the
19356
- // normalized pair into the public keys. This is the battery equivalent of the NVP
19357
- // 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.
19358
19363
  try {
19359
19364
  const dps = (this.config && this.config.datapoints) || {};
19360
19365
  const chargeMapped = !!String(dps.storageChargePower || '').trim();
19361
19366
  const dischargeMapped = !!String(dps.storageDischargePower || '').trim();
19367
+ const batteryMapped = !!String(dps.batteryPower || '').trim();
19362
19368
  const samePair = chargeMapped && dischargeMapped && String(dps.storageChargePower || '').trim() === String(dps.storageDischargePower || '').trim();
19363
- 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));
19364
19375
  const chargeRound = Math.round(chargeW);
19365
19376
  const dischargeRound = Math.round(dischargeW);
19366
- if (shouldMirrorStorage) {
19367
- const curC = Number(this.stateCache?.storageChargePower?.value);
19368
- const curD = Number(this.stateCache?.storageDischargePower?.value);
19369
- if (!Number.isFinite(curC) || curC !== chargeRound) this.updateValue('storageChargePower', chargeRound, ts, { raw: false });
19370
- if (!Number.isFinite(curD) || curD !== dischargeRound) this.updateValue('storageDischargePower', dischargeRound, ts, { raw: false });
19371
- }
19372
- 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) {
19373
19392
  const signedRound = Math.round(dischargeW - chargeW);
19374
- const curB = Number(this.stateCache?.batteryPower?.value);
19375
- if (!Number.isFinite(curB) || curB !== signedRound) this.updateValue('batteryPower', signedRound, ts, { raw: false });
19393
+ updateLocal('batteryPower', signedRound);
19376
19394
  }
19377
19395
  } catch (_eStorageMirror) {}
19378
19396
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "iobroker.nexowatt-ui",
3
- "version": "0.7.47",
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;
@@ -2132,6 +2138,7 @@ function getNormalizedBatteryFlow() {
2132
2138
  const chargeMapped = !!chargeId;
2133
2139
  const dischargeMapped = !!dischargeId;
2134
2140
  const batteryMapped = !!batteryId;
2141
+ const anyStorageMapped = chargeMapped || dischargeMapped || batteryMapped;
2135
2142
  const samePair = !!(chargeMapped && dischargeMapped && chargeId === dischargeId);
2136
2143
 
2137
2144
  const fromSigned = (raw, src) => {
@@ -2145,59 +2152,59 @@ function getNormalizedBatteryFlow() {
2145
2152
  signedW: signed,
2146
2153
  src,
2147
2154
  inverted: inv,
2155
+ fromSigned: true,
2156
+ derived: false,
2148
2157
  };
2149
2158
  };
2150
2159
 
2151
- const sfEnabled = !!(state && state['storageFarm.enabled'] && state['storageFarm.enabled'].value);
2160
+ const sfEnabled = nwStorageFarmFeatureFromConfig(window.__nwCfg || {}, state || window.latestState || {});
2152
2161
  if (sfEnabled) {
2153
- const fc = getFreshFlowNumber('storageFarm.totalChargePowerW');
2154
- const fd = getFreshFlowNumber('storageFarm.totalDischargePowerW');
2162
+ const fc = getStableFlowNumber('storageFarm.totalChargePowerW');
2163
+ const fd = getStableFlowNumber('storageFarm.totalDischargePowerW');
2155
2164
  if (fc !== null || fd !== null) {
2156
2165
  let c = Math.max(0, Math.abs(Number(fc || 0)));
2157
2166
  let d = Math.max(0, Math.abs(Number(fd || 0)));
2158
2167
  if (inv) { const t = c; c = d; d = t; }
2159
2168
  if (c <= deadbandW) c = 0;
2160
2169
  if (d <= deadbandW) d = 0;
2161
- 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 };
2162
2171
  }
2163
2172
  }
2164
2173
 
2165
- const signedBattery = batteryMapped ? getFreshFlowNumber('batteryPower') : null;
2166
- const charge = chargeMapped ? getFreshFlowNumber('storageChargePower') : null;
2167
- const discharge = dischargeMapped ? getFreshFlowNumber('storageDischargePower') : null;
2168
-
2169
- if (samePair && signedBattery !== null) return preferBalanceDerivedBatteryFlow(fromSigned(signedBattery, 'batterySignedForSamePair'), { deadbandW });
2170
-
2171
- const separateAvailable = (charge !== null || discharge !== null);
2172
- const bothDirections = Math.abs(Number(charge || 0)) > deadbandW && Math.abs(Number(discharge || 0)) > deadbandW;
2173
- 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;
2174
2179
 
2175
- if (signedBattery !== null && (!separateAvailable || bothEqualish || (!chargeMapped && !dischargeMapped))) {
2176
- return preferBalanceDerivedBatteryFlow(fromSigned(signedBattery, bothEqualish ? 'batterySignedOverrideDual' : 'batterySigned'), { deadbandW });
2177
- }
2180
+ if (samePair && charge !== null) return fromSigned(charge, 'sameChargeDischargeSigned');
2178
2181
 
2179
- if (separateAvailable) {
2182
+ if (charge !== null || discharge !== null) {
2180
2183
  let c = Math.max(0, Math.abs(Number(charge || 0)));
2181
2184
  let d = Math.max(0, Math.abs(Number(discharge || 0)));
2182
2185
  if (c <= deadbandW) c = 0;
2183
2186
  if (d <= deadbandW) d = 0;
2184
2187
  if (inv) { const t = c; c = d; d = t; }
2185
- const completePair = !!(chargeMapped && dischargeMapped && charge !== null && discharge !== null && !samePair);
2186
- return preferBalanceDerivedBatteryFlow({ chargeW: c, dischargeW: d, signedW: d - c, src: inv ? 'chargeDischarge(inv)' : 'chargeDischarge', inverted: inv, incomplete: !completePair }, { deadbandW });
2188
+ return { chargeW: c, dischargeW: d, signedW: d - c, src: inv ? 'chargeDischarge(inv)' : 'chargeDischarge', inverted: inv, fromSigned: false, derived: false };
2187
2189
  }
2188
2190
 
2189
- if (signedBattery !== null) return preferBalanceDerivedBatteryFlow(fromSigned(signedBattery, 'batterySigned'), { deadbandW });
2191
+ if (signedBattery !== null) return fromSigned(signedBattery, 'batterySigned');
2190
2192
 
2191
- return preferBalanceDerivedBatteryFlow({ chargeW: 0, dischargeW: 0, signedW: 0, src: (batteryMapped || chargeMapped || dischargeMapped) ? 'stale-or-missing' : 'missing', inverted: inv }, { deadbandW });
2192
- }
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
+ }
2193
2198
 
2199
+ return { chargeW: 0, dischargeW: 0, signedW: 0, src: anyStorageMapped ? 'mapped-missing' : 'missing', inverted: inv, fromSigned: false, derived: false };
2200
+ }
2194
2201
  function render() {
2195
2202
  const s = state;
2196
2203
 
2197
2204
  const d = (k) => s[k]?.value;
2198
2205
 
2199
2206
  // Top ring values: map PV, Grid, Load, Bat flows to percent of max for visualization
2200
- const sfEnabled = !!(s['storageFarm.enabled']?.value);
2207
+ const sfEnabled = nwStorageFarmFeatureFromConfig(window.__nwCfg || {}, s || state || {});
2201
2208
  const pvMapped = isMappedDatapoint('pvPower') || isMappedDatapoint('productionTotal');
2202
2209
 
2203
2210
  // PV (W): primary from mapped PV datapoint; fallback to productionTotal if used as power DP.
@@ -6026,7 +6033,7 @@ function updateEnergyWeb() {
6026
6033
  const s = window.latestState || {};
6027
6034
 
6028
6035
  // Raw datapoints (1:1)
6029
- const sfEnabled = !!(s['storageFarm.enabled']?.value);
6036
+ const sfEnabled = nwStorageFarmFeatureFromConfig(window.__nwCfg || {}, s || state || {});
6030
6037
  const pvMapped = isMappedDatapoint('pvPower') || isMappedDatapoint('productionTotal');
6031
6038
 
6032
6039
  // PV (W): primary from mapped PV datapoint; fallback to productionTotal if used as power DP.
@@ -44,5 +44,5 @@
44
44
  "purpose": "maskable"
45
45
  }
46
46
  ],
47
- "version": "0.7.47"
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-v215';
3
+ const CACHE_NAME = 'nexowatt-cache-v216';
4
4
 
5
5
  const OFFLINE_URLS = [
6
6
  './',