iobroker.nexowatt-ui 0.8.85 → 0.8.87

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.
@@ -2,7 +2,7 @@
2
2
  * AUTO-GENERATED RUNTIME FILE - NICHT MANUELL BEARBEITEN.
3
3
  *
4
4
  * Quelle: src-ts/runtime-executables/ems/modules/storage-control.ts
5
- * Quell-Hash: sha256:4d6688025ec8401b808b944956296a857494f59dd800db4114d4a57b3989f519
5
+ * Quell-Hash: sha256:f235fd63af91d7ec1d00eda572260d74bb4026a6fd3d7c92209bccacb2a4373c
6
6
  * Erzeugung: npm run sync:ts-runtime-executables
7
7
  *
8
8
  * Zweck:
@@ -333,6 +333,13 @@ class SpeicherRegelungModule extends BaseModule {
333
333
  this._feneconAssistReleaseSinceMs = 0;
334
334
  this._feneconAssistActive = false;
335
335
 
336
+ // Sungrow Hybrid ESS Sondermodus:
337
+ // Der SH/RS/RT/MG-Hybrid fuehrt PV und Batterie intern. NexoWatt darf
338
+ // deshalb im PV-deckenden Betrieb keine Entladung gegen diese interne
339
+ // Logik anfordern, sondern setzt externe Vorgaben auf 0 und greift nur
340
+ // NVP-begrenzt bei echtem Netzbezug ohne PV-Deckung ein.
341
+ this._sungrowHybridLastMode = '';
342
+
336
343
  }
337
344
 
338
345
  /**
@@ -481,6 +488,15 @@ class SpeicherRegelungModule extends BaseModule {
481
488
  this._feneconAssistImportSinceMs = 0;
482
489
  this._feneconAssistReleaseSinceMs = 0;
483
490
  }
491
+ if (this._isSungrowHybridControlConfigured(cfg) || this._sungrowHybridLastMode) {
492
+ await this._setSungrowHybridDiag({
493
+ active: false,
494
+ mode: 'disabled',
495
+ reason: 'Speicherregelung deaktiviert – Sungrow-Herstellerprofil in Ruhe',
496
+ writeMode: 'disabled',
497
+ });
498
+ this._sungrowHybridLastMode = 'disabled';
499
+ }
484
500
  } catch {
485
501
  // ignore
486
502
  }
@@ -504,13 +520,17 @@ class SpeicherRegelungModule extends BaseModule {
504
520
  const hasSignedTarget = this.dp ? !!this.dp.getEntry('st.targetPowerW') : false;
505
521
  const hasSplitTarget = this.dp ? (!!this.dp.getEntry('st.targetChargePowerW') && !!this.dp.getEntry('st.targetDischargePowerW')) : false;
506
522
  const hasTarget = hasSignedTarget || hasSplitTarget;
523
+ const storageVendorProfile = this._getStorageVendorProfile(cfg);
507
524
  const feneconHybridConfigured = this._isFeneconHybridControlConfigured(cfg);
525
+ const sungrowHybridConfigured = this._isSungrowHybridControlConfigured(cfg);
508
526
  // FENECON/OpenEMS ist kein Speicherfarm-Blocker mehr:
509
527
  // Der No-Write-Entscheid liegt vor _applyTargetW(). Bei Tages-/PV-Pass-through
510
528
  // wird dadurch weder ein Einzel-Sollwert noch ein Farm-Sollwert geschrieben.
511
529
  // Bei uebergeordneten Policies (MultiUse/Peak/Tarif/Reserve) oder Assist darf
512
530
  // die Speicherfarm den erzeugten Zielwert weiter wie gewohnt verteilen.
513
531
  const feneconHybridActive = !!feneconHybridConfigured;
532
+ const sungrowHybridActive = !!sungrowHybridConfigured;
533
+ await this._setIfChanged('speicher.regelung.herstellerprofil', storageVendorProfile);
514
534
  const feneconHybridBlockedByFarm = false;
515
535
 
516
536
  if (controlMode !== 'targetPower') {
@@ -713,6 +733,15 @@ class SpeicherRegelungModule extends BaseModule {
713
733
  // keine externe Vorgabe, damit Gateway selbst weiterregelt und nicht durch eine
714
734
  // stale/geschätzte NexoWatt-Vorgabe festgehalten wird.
715
735
  if (typeof gridW !== 'number') {
736
+ if (sungrowHybridActive) {
737
+ await this._setSungrowHybridDiag({
738
+ active: true,
739
+ mode: 'no-grid-zero',
740
+ reason: 'Sungrow Hybrid ESS: NVP-Messung fehlt – externe Lade-/Entladevorgaben werden sicher auf 0 gesetzt',
741
+ writeMode: 'write-zero-no-grid',
742
+ targetW: 0,
743
+ });
744
+ }
716
745
  await this._setIfChanged('speicher.regelung.requestW', 0);
717
746
  await this._setIfChanged('speicher.regelung.requestQuelle', 'aus');
718
747
  await this._setIfChanged('speicher.regelung.requestGrund', 'Netzleistung fehlt oder zu alt');
@@ -834,6 +863,21 @@ class SpeicherRegelungModule extends BaseModule {
834
863
  const importRawW = Math.max(0, nvpRawW);
835
864
  const exportRawW = Math.max(0, -nvpRawW);
836
865
 
866
+ // NVP-Balancing-Hilfswerte fuer Eigenverbrauch/PV-Laden.
867
+ // Wichtig: Bei Speicherregelung muss der naechste Sollwert immer aus
868
+ // "aktueller Batterieleistung + aktueller NVP-Abweichung" entstehen.
869
+ // Sonst bleibt bei laufender Ladung z. B. 2,9 kW Export stehen, weil nur
870
+ // der neue NVP-Export geschrieben wird statt "alte Ladung + neuer Export".
871
+ const isStorageBalanceSource = (src) => {
872
+ const x = String(src || '').toLowerCase();
873
+ return x === 'eigenverbrauch' || x === 'pv' || x === 'sungrow-hybrid' || x === 'sungrow-assist' || x === 'fenecon' || x === 'fenecon-assist';
874
+ };
875
+ const getLastStorageBalanceTargetW = () => {
876
+ const last = Number(this._lastTargetW);
877
+ if (!Number.isFinite(last)) return 0;
878
+ return isStorageBalanceSource(this._lastSource) ? last : 0;
879
+ };
880
+
837
881
  // Gateway AC: Lastreferenz für den AC-Teil des Speichers.
838
882
  // Wichtig: Die eigentliche Sollleistung wird weiter unten am NVP bilanziert,
839
883
  // damit PV-Überschuss-/EVCS-Situationen nicht zu Batterieentladung in die Einspeisung führen.
@@ -924,6 +968,10 @@ class SpeicherRegelungModule extends BaseModule {
924
968
  ? await this._buildFeneconHybridContext({ cfg, staleMs, readCacheNumber, gridW, gridRawW })
925
969
  : { active: false, configured: !!feneconHybridConfigured, farmBlocked: !!feneconHybridBlockedByFarm, mode: feneconHybridBlockedByFarm ? 'blocked-by-farm' : 'standard' };
926
970
 
971
+ const sungrowHybridCtx = sungrowHybridActive
972
+ ? await this._buildSungrowHybridContext({ cfg, staleMs, readCacheNumber, gridW, gridRawW })
973
+ : { active: false, configured: !!sungrowHybridConfigured, mode: 'standard' };
974
+
927
975
  if (feneconHybridActive) {
928
976
  await this._setFeneconHybridDiag({
929
977
  active: true,
@@ -943,6 +991,24 @@ class SpeicherRegelungModule extends BaseModule {
943
991
  });
944
992
  }
945
993
 
994
+ if (sungrowHybridActive) {
995
+ await this._setSungrowHybridDiag({
996
+ active: true,
997
+ mode: sungrowHybridCtx.mode,
998
+ reason: sungrowHybridCtx.reason,
999
+ writeMode: sungrowHybridCtx.writeMode,
1000
+ pvW: sungrowHybridCtx.pvW,
1001
+ loadW: sungrowHybridCtx.loadW,
1002
+ nvpW: sungrowHybridCtx.nvpW,
1003
+ importW: sungrowHybridCtx.importW,
1004
+ exportW: sungrowHybridCtx.exportW,
1005
+ pvCoversLoad: sungrowHybridCtx.pvCoversLoad,
1006
+ thresholdW: sungrowHybridCtx.thresholdW,
1007
+ loadCoverReserveW: sungrowHybridCtx.loadCoverReserveW,
1008
+ dischargeThresholdW: sungrowHybridCtx.dischargeThresholdW,
1009
+ });
1010
+ }
1011
+
946
1012
 
947
1013
  // ------------------------------------------------------------
948
1014
  // Phase 4: Gemeinsame Netzbezug-Caps (Grid-Constraints / Peak-Shaving / Installer)
@@ -1934,15 +2000,20 @@ if (targetW === 0 && selfDischargeEnabled) {
1934
2000
  ? this._lastTargetW
1935
2001
  : 0;
1936
2002
 
1937
- // Ist-Batterieleistung (positiv = Entladung). Falls verfügbar nutzen wir eine
1938
- // OpenEMS-ähnliche Balancing-Regelung: Soll = battIst + (gridIst - gridZiel).
1939
- // Ohne Istleistung bleibt der bisherige Fallback (inkrementell über letzten Sollwert).
1940
- const battWRaw = (battPowerTrusted && typeof battPowerW === 'number' && Number.isFinite(battPowerW)) ? Number(battPowerW) : null;
1941
- const battW = (typeof battWRaw === 'number') ? Math.max(0, battWRaw) : null;
1942
-
1943
- // Fehler: positiver Fehler => zu viel Import => mehr entladen.
1944
- // negativer Fehler => Export/zu wenig Import => Entladung reduzieren.
1945
- // NOTE: Wenn ROH bereits Export zeigt, ist nvpCtrlW ohnehin negativ – dadurch wird sofort reduziert.
2003
+ // Ist-Batterieleistung (positiv = Entladung, negativ = Beladung).
2004
+ // Fuer saubere Eigenverbrauchsoptimierung wird bidirektional am NVP bilanziert:
2005
+ // naechster Sollwert = aktuelle Batterie-Istleistung + (NVP-Ist - NVP-Ziel).
2006
+ // Dadurch werden sowohl Entladung als auch laufende PV-Beladung nachgeregelt.
2007
+ const battSignedRawW = (battPowerTrusted && typeof battPowerW === 'number' && Number.isFinite(battPowerW)) ? Number(battPowerW) : null;
2008
+ const battW = (typeof battSignedRawW === 'number') ? Math.max(0, battSignedRawW) : null;
2009
+ const battChargeW = (typeof battSignedRawW === 'number') ? Math.max(0, -battSignedRawW) : null;
2010
+ const lastBalanceW = getLastStorageBalanceTargetW();
2011
+ const lastWasPvBalance = (String(this._lastSource || '') === 'pv');
2012
+ const lastWasAnyBalance = lastWasSelf || lastWasPvBalance;
2013
+
2014
+ // Fehler: positiver Fehler => zu viel Import => mehr entladen bzw. weniger laden.
2015
+ // negativer Fehler => Export/zu wenig Import => mehr laden bzw. weniger entladen.
2016
+ // NOTE: Wenn ROH bereits Export zeigt, ist nvpCtrlW ohnehin negativ – dadurch wird sofort reduziert/geladen.
1946
2017
  const errW = (typeof nvpCtrlW === 'number') ? (nvpCtrlW - desiredNvpW) : 0;
1947
2018
 
1948
2019
  // PI-light: Inkrement-Regelung.
@@ -1951,40 +2022,41 @@ if (targetW === 0 && selfDischargeEnabled) {
1951
2022
  // Sollwert mit der zeitversetzten Batterie-/Farm-Istleistung mit und springt trotz
1952
2023
  // konstantem Hausverbrauch unnötig hoch/runter.
1953
2024
  const outsideDeadband = (errW > deadbandW || errW < -deadbandW);
1954
- const holdInDeadband = !outsideDeadband && lastWasSelf && curSetW > 0;
2025
+ const holdInDeadband = !outsideDeadband && lastWasAnyBalance && Math.abs(lastBalanceW) > 0;
1955
2026
  let errAdjW = outsideDeadband ? errW : 0;
1956
2027
 
1957
2028
  // OpenEMS-Balancing (Vorbild): battIst + (gridIst - gridZiel).
1958
- // Ohne vertrauenswürdige Batterie-Istleistung wird nicht mehr über den
1959
- // alten Sollwert hochintegriert. Der Fallback nutzt dann nur den aktuell
1960
- // sichtbaren NVP-Fehler; in der Deadband darf ein bereits stabiler Sollwert
1961
- // gehalten werden. Das schützt die Eigenverbrauchsoptimierung vor falschen
1962
- // Modbus-/Setpoint-DPs und verhindert 71-kW-Ausreißer bei nur wenigen kW Import.
1963
- let nextSetW;
2029
+ // Ohne vertrauenswürdige Batterie-Istleistung darf ein alter positiver
2030
+ // Entlade-Sollwert nicht weiter hochintegrieren (71-kW-Feldfehler). Ein
2031
+ // alter negativer Lade-Sollwert darf aber fuer PV-Export genutzt werden,
2032
+ // damit "alte Ladung + aktueller NVP-Export" zum neuen Ladeziel wird.
2033
+ let nextSignedW;
1964
2034
  if (holdInDeadband) {
1965
- nextSetW = curSetW;
1966
- } else if (typeof battW === 'number') {
1967
- nextSetW = battW + errAdjW;
1968
- } else if (errAdjW < 0) {
1969
- nextSetW = Math.max(0, curSetW + errAdjW);
2035
+ nextSignedW = (typeof battSignedRawW === 'number') ? battSignedRawW : lastBalanceW;
2036
+ } else if (typeof battSignedRawW === 'number') {
2037
+ nextSignedW = battSignedRawW + errAdjW;
2038
+ } else if (lastBalanceW < 0 || errAdjW < 0) {
2039
+ nextSignedW = lastBalanceW + errAdjW;
1970
2040
  } else {
1971
- nextSetW = errAdjW;
2041
+ nextSignedW = errAdjW;
1972
2042
  }
2043
+ let nextSetW = Math.max(0, nextSignedW);
1973
2044
 
1974
2045
  // Safety-Clamp gegen Überschwingen:
1975
- // Die Eigenverbrauchsoptimierung darf nur den aktuell am Netzpunkt sichtbaren
1976
- // Restbedarf ausregeln. Der sichere Cap ist deshalb: echter NVP-Import + echte
1977
- // gemessene Batterie-Entladung + Puffer. Abgeleitete Gebäudelasten werden hier
1978
- // bewusst NICHT als Obergrenze genutzt, weil sie bei PV-Erzeugung viel höher als
1979
- // der Netzbezug sein können und sonst wieder zu überhöhten Setpoints führen.
1980
2046
  // WICHTIGER Feldfix 0.8.81: Der letzte eigene Sollwert und derived.loadTotalW
1981
- // dürfen die Demand-Basis nicht vergrößern. Ohne vertrauenswürdige Batterie-
1982
- // Istleistung zählt nur der aktuelle NVP-Import plus kleiner Sicherheitsreserve.
1983
- // Dadurch wird auch innerhalb der Deadband kein alter Setpoint konserviert, der
1984
- // einen Kundenanschluss überlasten könnte. Stabile Haltewerte sind nur mit echter
1985
- // Batterie-Istleistung erlaubt.
2047
+ // duerfen den Entlade-Cap nicht vergroessern; nur NVP plus echte Batterie-Istleistung
2048
+ // sind fuer die harte Anschluss-Sicherheit zulaessig.
2049
+ // Die Eigenverbrauchsoptimierung darf nur den aktuell am Netzpunkt sichtbaren
2050
+ // Restbedarf ausregeln. Der sichere Entlade-Cap ist deshalb: echter NVP-Import +
2051
+ // echte gemessene Batterie-Entladung + Puffer. Fuer die Laderichtung gilt analog:
2052
+ // laufende reale/zuletzt geschriebene Ladung + aktueller NVP-Export. Genau dieser
2053
+ // zweite Teil hat vorher gefehlt und fuehrte zu stabilen Rest-Exporten/-Importen
2054
+ // (z. B. 2,9 kW Ladung + 2,9 kW Export => neuer Sollwert muss ca. 5,8 kW Ladung sein).
1986
2055
  const importRawNowW = Math.max(0, (typeof nvpRawW === 'number') ? nvpRawW : 0);
1987
2056
  const measuredDischargeNowW = (typeof battW === 'number') ? Math.max(0, battW) : 0;
2057
+ const measuredChargeNowW = (typeof battChargeW === 'number') ? Math.max(0, battChargeW) : 0;
2058
+ const lastChargeNowW = (!battPowerTrusted && lastBalanceW < 0) ? Math.max(0, -lastBalanceW) : 0;
2059
+ const currentChargeForBalancingW = (typeof battChargeW === 'number') ? measuredChargeNowW : lastChargeNowW;
1988
2060
  const safetyMarginW = 200; // bewusst konservativ; Feintuning über selfTargetGridW/Deadband/Rampe
1989
2061
  const maxByDemandW = Math.max(0, importRawNowW + measuredDischargeNowW + safetyMarginW);
1990
2062
  if (Number.isFinite(maxByDemandW) && maxByDemandW >= 0) {
@@ -1997,7 +2069,22 @@ if (targetW === 0 && selfDischargeEnabled) {
1997
2069
  nextSetW = Math.min(nextSetW, maxByDemandW);
1998
2070
  }
1999
2071
 
2000
- // Nur Entladen in diesem Block (kein Laden). Negative Werte sind hier nicht sinnvoll.
2072
+ const chargeBalanceCapW = exportRawW > 0
2073
+ ? Math.max(0, currentChargeForBalancingW + exportRawW)
2074
+ : ((typeof battChargeW === 'number' && importRawNowW > desiredNvpW)
2075
+ ? Math.max(0, currentChargeForBalancingW)
2076
+ : 0);
2077
+ if (nextSignedW < 0) {
2078
+ chargeDemandHardCapW = (typeof chargeDemandHardCapW === 'number')
2079
+ ? Math.min(chargeDemandHardCapW, chargeBalanceCapW)
2080
+ : chargeBalanceCapW;
2081
+ chargeDemandHardCapReason = (typeof battChargeW === 'number')
2082
+ ? 'Eigenverbrauch-NVP-Lade-Cap (aktuelle Ladung+NVP-Export/Import-Reduktion)'
2083
+ : 'Eigenverbrauch-NVP-Lade-Cap (letzter Ladesollwert nur bei aktuellem Export)';
2084
+ }
2085
+
2086
+ // Positive Werte in diesem Pfad sind Entladung; negative Werte reduzieren/erhoehen
2087
+ // laufende PV-Beladung. Beides bleibt NVP-gefuehrt und wird weiter unten gerampt.
2001
2088
  nextSetW = clamp(nextSetW, 0, selfMaxDischargeEff);
2002
2089
 
2003
2090
  // SoC-Hysterese: verhindert Flattern um die Untergrenze und sorgt für eine
@@ -2020,7 +2107,21 @@ if (targetW === 0 && selfDischargeEnabled) {
2020
2107
  const importNowW = Math.max(0, (typeof nvpCtrlW === 'number') ? nvpCtrlW : 0);
2021
2108
  const startCond = (importNowW >= deadbandW) || lastWasSelf;
2022
2109
 
2023
- if (allow && startCond && nextSetW > 0) {
2110
+ if (allow && nextSignedW < 0) {
2111
+ const maxChargeBySocW = (typeof soc === 'number' && soc >= selfMaxSoc) ? 0 : selfMaxChargeEff;
2112
+ const chargeW = clamp(Math.abs(nextSignedW), 0, Math.min(maxChargeBySocW, chargeBalanceCapW));
2113
+ hardChargeMaxSoc = Math.max(hardChargeMaxSoc, selfMaxSoc);
2114
+ if (chargeW > 0) {
2115
+ targetW = -chargeW;
2116
+ reason = `Eigenverbrauch: NVP-Balancing laden (${Math.round(chargeW)} W, Export ${Math.round(exportRawW)} W, laufende Ladung ${Math.round(currentChargeForBalancingW)} W)`;
2117
+ source = 'pv';
2118
+ } else if ((source === 'idle' || reason === 'Keine Aktion') && Math.abs(nextSignedW) > 0) {
2119
+ reason = (typeof soc === 'number' && soc >= selfMaxSoc)
2120
+ ? `Eigenverbrauch: Laden blockiert (SoC >= ${selfMaxSoc}%)`
2121
+ : 'Eigenverbrauch: keine NVP-Ladefreigabe';
2122
+ source = 'pv';
2123
+ }
2124
+ } else if (allow && startCond && nextSetW > 0) {
2024
2125
  targetW = nextSetW;
2025
2126
  reason = `Eigenverbrauch: entladen (${Math.round(targetW)} W${(typeof battW === 'number') ? ', Balancing' : ''})`;
2026
2127
  source = 'eigenverbrauch';
@@ -2085,13 +2186,24 @@ if (targetW === 0 && selfDischargeEnabled) {
2085
2186
  // weiterläuft. Der Zero-Export-Bias wird nur addiert, solange RAW
2086
2187
  // tatsächlich Export zeigt; bei RAW=0/Import darf er keinen Netzbezug
2087
2188
  // in die Batterie ziehen.
2088
- const exportCtrlCapW = Math.max(0, exportCtrlW + extraBias);
2089
- const exportRawCapW = exportRawW > 0 ? Math.max(0, exportRawW + extraBias) : 0;
2189
+ const measuredChargeNowW = (battPowerTrusted && typeof battPowerW === 'number' && Number.isFinite(battPowerW))
2190
+ ? Math.max(0, -Number(battPowerW))
2191
+ : 0;
2192
+ const lastBalanceWForCharge = getLastStorageBalanceTargetW();
2193
+ const lastChargeNowW = (!battPowerTrusted && lastBalanceWForCharge < 0) ? Math.max(0, -lastBalanceWForCharge) : 0;
2194
+ const currentChargeForBalancingW = battPowerTrusted ? measuredChargeNowW : lastChargeNowW;
2195
+
2196
+ // NVP-Lade-Balancing: nicht nur den aktuellen Export schreiben,
2197
+ // sondern laufende Ladung + neuen Export. Beispiel Feldfall:
2198
+ // Speicher laedt bereits 2,9 kW und am NVP bleiben weitere 2,9 kW Export
2199
+ // sichtbar => Sollwert muss auf ca. 5,8 kW Ladung steigen.
2200
+ const exportCtrlCapW = Math.max(0, currentChargeForBalancingW + exportCtrlW + extraBias);
2201
+ const exportRawCapW = exportRawW > 0 ? Math.max(0, currentChargeForBalancingW + exportRawW + extraBias) : currentChargeForBalancingW;
2090
2202
  const pvRawChargeCapW = clamp(Math.min(exportCtrlCapW, exportRawCapW), 0, chargeLimitW);
2091
2203
  chargeDemandHardCapW = pvRawChargeCapW;
2092
- chargeDemandHardCapReason = zeEnabled ? 'Nulleinspeisung-PV-Rohwert-Lade-Cap' : 'PV-Rohwert-Lade-Cap';
2204
+ chargeDemandHardCapReason = zeEnabled ? 'Nulleinspeisung-NVP-Lade-Cap (aktuelle Ladung+Export)' : 'PV-NVP-Lade-Cap (aktuelle Ladung+Export)';
2093
2205
  targetW = -pvRawChargeCapW;
2094
- reason = zeEnabled ? 'Nulleinspeisung: Export in Speicher umleiten' : 'Eigenverbrauch: PV-Überschuss laden';
2206
+ reason = zeEnabled ? 'Nulleinspeisung: Export plus laufende Ladung in Speicher umleiten' : 'Eigenverbrauch: PV-Überschuss plus laufende Ladung nutzen';
2095
2207
  source = 'pv';
2096
2208
  }
2097
2209
  }
@@ -2361,7 +2473,7 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
2361
2473
  targetW = _prevRampW + Math.sign(d) * maxDelta;
2362
2474
  reason = `${reason} (LSK‑Rampe)`;
2363
2475
  }
2364
- } else if (source === 'fenecon' || source === 'fenecon-assist' || this._lastSource === 'fenecon' || this._lastSource === 'fenecon-assist') {
2476
+ } else if (source === 'fenecon' || source === 'fenecon-assist' || source === 'sungrow-assist' || this._lastSource === 'fenecon' || this._lastSource === 'fenecon-assist' || this._lastSource === 'sungrow-assist') {
2365
2477
  // Gateway AC-Lastfolger: Lastsprünge müssen in beide Richtungen schnell übernommen werden,
2366
2478
  // sonst bleibt kurz Netzbezug stehen oder es entsteht beim Lastabwurf unnötige Einspeisung.
2367
2479
  // Deshalb hier bewusst keine zusätzliche Rampe.
@@ -2411,7 +2523,7 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
2411
2523
  // NVP-basierte Entladequellen.
2412
2524
  if (targetW > 0 && typeof dischargeDemandHardCapW === 'number' && Number.isFinite(dischargeDemandHardCapW)) {
2413
2525
  const capW = Math.max(0, dischargeDemandHardCapW);
2414
- const activeNvpDischargeSource = (source === 'eigenverbrauch' || source === 'tarif' || source === 'fenecon' || source === 'fenecon-assist' || source === 'lastspitze');
2526
+ const activeNvpDischargeSource = (source === 'eigenverbrauch' || source === 'tarif' || source === 'fenecon' || source === 'fenecon-assist' || source === 'sungrow-assist' || source === 'lastspitze');
2415
2527
  if (activeNvpDischargeSource && targetW > capW) {
2416
2528
  targetW = capW;
2417
2529
  reason = `${reason} (Demand-Cap ${Math.round(capW)} W nach Rampe)`;
@@ -2447,6 +2559,7 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
2447
2559
  // ------------------------------------------------------------
2448
2560
  let feneconNoWrite = false;
2449
2561
  let feneconWriteMode = '';
2562
+ let sungrowWriteMode = '';
2450
2563
  if (feneconHybridActive) {
2451
2564
  const ctx = feneconHybridCtx || {};
2452
2565
  const mode = String(ctx.mode || '');
@@ -2544,6 +2657,181 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
2544
2657
  });
2545
2658
  }
2546
2659
 
2660
+ // ------------------------------------------------------------
2661
+ // Sungrow Hybrid ESS Herstellerprofil
2662
+ // ------------------------------------------------------------
2663
+ if (sungrowHybridActive) {
2664
+ const ctx = sungrowHybridCtx || {};
2665
+ const srcNorm = String(source || '').toLowerCase();
2666
+ const targetImportW = Math.max(0, num(cfg.sungrowTargetGridImportW, selfTargetGridW));
2667
+ const assistBufferW = Math.max(0, num(cfg.sungrowAssistBufferW, 150));
2668
+ const dischargeOnlyOnImport = cfg.sungrowDischargeOnlyOnGridImport !== false;
2669
+ const pvPassthrough = cfg.sungrowPvPassthroughEnabled !== false;
2670
+ const zeroOnPvCoverage = cfg.sungrowZeroOnPvCoverage !== false;
2671
+ const nvpNowW = (typeof ctx.nvpW === 'number' && Number.isFinite(ctx.nvpW))
2672
+ ? Number(ctx.nvpW)
2673
+ : ((typeof gridRawW === 'number' && Number.isFinite(gridRawW)) ? Number(gridRawW) : Number(gridW || 0));
2674
+ const importNowW = Math.max(0, nvpNowW);
2675
+ const exportNowW = Math.max(0, -nvpNowW);
2676
+ const pvCoversLoad = !!ctx.pvCoversLoad;
2677
+ const pvActive = !!ctx.pvActive;
2678
+ const isStorageSelfOrPv = srcNorm === 'eigenverbrauch' || srcNorm === 'pv' || srcNorm === 'idle' || srcNorm === 'sungrow-hybrid' || srcNorm === 'sungrow-assist';
2679
+ const isCriticalPolicy = targetW !== 0 && (
2680
+ srcNorm === 'lastspitze' ||
2681
+ srcNorm === 'lastspitze_refill' ||
2682
+ srcNorm === 'reserve' ||
2683
+ srcNorm === 'tarif' ||
2684
+ srcNorm === 'evcs'
2685
+ );
2686
+
2687
+ // Sungrow-Hybrid Feldfix 0.8.87:
2688
+ // Das Herstellerprofil darf PV-/Tagesbetrieb nicht blind mit 0 W "freigeben",
2689
+ // solange der NVP sichtbar außerhalb des Zielbandes liegt. Fuehrungsgroesse ist
2690
+ // immer der Netzverknuepfungspunkt: neuer Sollwert = aktuelle Batterie-Istleistung
2691
+ // plus aktuelle NVP-Abweichung. Damit werden sowohl Rest-Netzbezug (z. B. 700 W
2692
+ // statt max. 100 W) als auch Rest-Export korrekt nachgeregelt. Beispiel Laden:
2693
+ // Batterie laedt 2,9 kW und am NVP stehen noch 2,9 kW Export -> Ziel wird ca.
2694
+ // 5,8 kW Laden, nicht erneut nur 2,9 kW oder 0 W.
2695
+ const nvpDeadbandW = Math.max(0, Number(ctx.dischargeThresholdW) || selfImportThresholdW || 100);
2696
+ const nvpErrorW = Number.isFinite(Number(nvpNowW)) ? (nvpNowW - targetImportW) : 0;
2697
+ const importBalanceNeeded = nvpErrorW > nvpDeadbandW;
2698
+ const exportBalanceNeeded = nvpErrorW < -nvpDeadbandW;
2699
+ const nvpBalanceNeeded = !!(isStorageSelfOrPv && !isCriticalPolicy && (importBalanceNeeded || exportBalanceNeeded));
2700
+ const battSignedNowW = (battPowerTrusted && typeof battPowerW === 'number' && Number.isFinite(battPowerW)) ? Number(battPowerW) : null;
2701
+ const lastSungrowBalanceW = getLastStorageBalanceTargetW();
2702
+ const balanceBaseW = (typeof battSignedNowW === 'number') ? battSignedNowW : lastSungrowBalanceW;
2703
+ let nvpBalancedTargetW = balanceBaseW + nvpErrorW;
2704
+ let sungrowBalanceBaseW = balanceBaseW;
2705
+ let sungrowNvpErrorW = nvpErrorW;
2706
+ let sungrowNvpBalancedTargetW = nvpBalancedTargetW;
2707
+
2708
+ if (nvpBalanceNeeded) {
2709
+ const currentDischargeForCapW = Math.max(0, (typeof battSignedNowW === 'number') ? battSignedNowW : Math.max(0, lastSungrowBalanceW));
2710
+ const currentChargeForCapW = Math.max(0, (typeof battSignedNowW === 'number') ? -battSignedNowW : Math.max(0, -lastSungrowBalanceW));
2711
+ const dischargeCapW = Math.max(0, importNowW + currentDischargeForCapW + assistBufferW);
2712
+ const chargeCapW = Math.max(0, exportNowW + currentChargeForCapW + assistBufferW);
2713
+
2714
+ if (nvpBalancedTargetW > 0) {
2715
+ if (dischargeOnlyOnImport && importNowW <= (targetImportW + nvpDeadbandW)) {
2716
+ targetW = 0;
2717
+ source = 'sungrow-hybrid';
2718
+ reason = `Sungrow Hybrid ESS: Entladung blockiert, NVP im Zielband (${Math.round(importNowW)} W, Ziel ${Math.round(targetImportW)} W)`;
2719
+ sungrowWriteMode = 'write-zero-no-import';
2720
+ } else {
2721
+ targetW = clamp(nvpBalancedTargetW, 0, Math.min(maxDischargeW, dischargeCapW));
2722
+ if (targetW > 0) {
2723
+ source = 'sungrow-assist';
2724
+ reason = `Sungrow Hybrid ESS: NVP-Balancing Entladung ${Math.round(targetW)} W (Batterie ${Math.round(balanceBaseW)} W + NVP-Fehler ${Math.round(nvpErrorW)} W, Ziel ${Math.round(targetImportW)} W)`;
2725
+ sungrowWriteMode = 'write-nvp-balance-discharge';
2726
+ dischargeDemandHardCapW = (typeof dischargeDemandHardCapW === 'number')
2727
+ ? Math.min(dischargeDemandHardCapW, dischargeCapW)
2728
+ : dischargeCapW;
2729
+ dischargeDemandHardCapReason = 'Sungrow-NVP-Balancing-Entlade-Cap (Ist/letzter Wert + NVP)';
2730
+ } else {
2731
+ source = 'sungrow-hybrid';
2732
+ reason = 'Sungrow Hybrid ESS: NVP-Balancing Entlade-Cap 0 W – Vorgabe 0';
2733
+ sungrowWriteMode = 'write-zero-assist-cap';
2734
+ }
2735
+ }
2736
+ } else if (nvpBalancedTargetW < 0) {
2737
+ const maxChargeBySocW = (typeof soc === 'number' && soc >= hardChargeMaxSoc) ? 0 : maxChargeW;
2738
+ const chargeW = clamp(Math.abs(nvpBalancedTargetW), 0, Math.min(maxChargeBySocW, chargeCapW));
2739
+ if (chargeW > 0) {
2740
+ targetW = -chargeW;
2741
+ source = 'sungrow-assist';
2742
+ reason = `Sungrow Hybrid ESS: NVP-Balancing Laden ${Math.round(chargeW)} W (Batterie ${Math.round(balanceBaseW)} W + NVP-Fehler ${Math.round(nvpErrorW)} W, Ziel ${Math.round(targetImportW)} W)`;
2743
+ sungrowWriteMode = 'write-nvp-balance-charge';
2744
+ chargeDemandHardCapW = (typeof chargeDemandHardCapW === 'number')
2745
+ ? Math.min(chargeDemandHardCapW, chargeCapW)
2746
+ : chargeCapW;
2747
+ chargeDemandHardCapReason = 'Sungrow-NVP-Balancing-Lade-Cap (Ist/letzter Wert + NVP)';
2748
+ } else {
2749
+ targetW = 0;
2750
+ source = 'sungrow-hybrid';
2751
+ reason = (typeof soc === 'number' && soc >= hardChargeMaxSoc)
2752
+ ? `Sungrow Hybrid ESS: NVP-Laden blockiert (SoC >= ${hardChargeMaxSoc}%)`
2753
+ : 'Sungrow Hybrid ESS: NVP-Lade-Cap 0 W – Vorgabe 0';
2754
+ sungrowWriteMode = 'write-zero-charge-cap';
2755
+ }
2756
+ } else {
2757
+ targetW = 0;
2758
+ source = 'sungrow-hybrid';
2759
+ reason = 'Sungrow Hybrid ESS: NVP-Balancing im Ziel – Vorgabe 0';
2760
+ sungrowWriteMode = 'write-zero-nvp-balanced';
2761
+ }
2762
+ } else if (pvPassthrough && zeroOnPvCoverage && pvCoversLoad && !isCriticalPolicy) {
2763
+ // Nur wenn der NVP im Zielband ist, darf Sungrow im PV-deckenden Betrieb
2764
+ // komplett intern weiterlaufen. Bei Rest-Import/-Export greift oben das
2765
+ // NVP-Balancing und schreibt nicht blind 0 W.
2766
+ targetW = 0;
2767
+ source = 'sungrow-hybrid';
2768
+ reason = `Sungrow Hybrid ESS: PV deckt Gebäudelast und NVP ist im Zielband – Lade-/Entladevorgaben 0`;
2769
+ sungrowWriteMode = 'write-zero-pv-covered';
2770
+ } else if (pvPassthrough && pvActive && srcNorm === 'pv' && targetW < 0) {
2771
+ // PV-Laden nur dann nicht extern erzwingen, wenn am NVP kein relevanter
2772
+ // Export mehr sichtbar ist. Rest-Export wird oben mit "aktuelle Ladung +
2773
+ // NVP-Export" nachgeführt.
2774
+ targetW = 0;
2775
+ source = 'sungrow-hybrid';
2776
+ reason = 'Sungrow Hybrid ESS: PV-Laden intern geführt, NVP im Zielband – externe Ladevorgabe 0';
2777
+ sungrowWriteMode = 'write-zero-pv-internal';
2778
+ } else if (targetW > 0 && (srcNorm === 'eigenverbrauch' || srcNorm === 'tarif')) {
2779
+ if (dischargeOnlyOnImport && importNowW <= Math.max(targetImportW + nvpDeadbandW, Number(ctx.dischargeThresholdW) || selfImportThresholdW)) {
2780
+ targetW = 0;
2781
+ source = 'sungrow-hybrid';
2782
+ reason = `Sungrow Hybrid ESS: Entladung blockiert, kein echter NVP-Netzbezug (${Math.round(importNowW)} W)`;
2783
+ sungrowWriteMode = 'write-zero-no-import';
2784
+ } else if (pvPassthrough && pvCoversLoad) {
2785
+ targetW = 0;
2786
+ source = 'sungrow-hybrid';
2787
+ reason = 'Sungrow Hybrid ESS: PV deckt die Last und NVP ist im Zielband – keine externe Entladung';
2788
+ sungrowWriteMode = 'write-zero-pv-covered';
2789
+ } else {
2790
+ const assistCapW = Math.max(0, importNowW - targetImportW + assistBufferW);
2791
+ targetW = Math.min(Math.max(0, targetW), assistCapW);
2792
+ if (targetW > 0) {
2793
+ source = 'sungrow-assist';
2794
+ reason = `Sungrow Hybrid ESS: NVP-Assist Entladung ${Math.round(targetW)} W gegen Netzbezug ${Math.round(importNowW)} W`;
2795
+ sungrowWriteMode = 'write-nvp-assist';
2796
+ dischargeDemandHardCapW = (typeof dischargeDemandHardCapW === 'number')
2797
+ ? Math.min(dischargeDemandHardCapW, assistCapW)
2798
+ : assistCapW;
2799
+ dischargeDemandHardCapReason = 'Sungrow-NVP-Assist-Cap';
2800
+ } else {
2801
+ source = 'sungrow-hybrid';
2802
+ reason = 'Sungrow Hybrid ESS: NVP-Assist-Cap 0 W – Vorgabe 0';
2803
+ sungrowWriteMode = 'write-zero-assist-cap';
2804
+ }
2805
+ }
2806
+ } else {
2807
+ sungrowWriteMode = 'standard';
2808
+ }
2809
+
2810
+ this._sungrowHybridLastMode = sungrowWriteMode || 'standard';
2811
+ await this._setSungrowHybridDiag({
2812
+ active: true,
2813
+ mode: (sungrowWriteMode || String(ctx.mode || 'standard')),
2814
+ reason,
2815
+ writeMode: sungrowWriteMode || 'standard',
2816
+ targetW,
2817
+ pvW: ctx.pvW,
2818
+ loadW: ctx.loadW,
2819
+ nvpW: nvpNowW,
2820
+ importW: importNowW,
2821
+ exportW: exportNowW,
2822
+ pvCoversLoad,
2823
+ thresholdW: ctx.thresholdW,
2824
+ loadCoverReserveW: ctx.loadCoverReserveW,
2825
+ dischargeThresholdW: ctx.dischargeThresholdW,
2826
+ nvpTargetW: targetImportW,
2827
+ nvpDeadbandW,
2828
+ nvpErrorW: sungrowNvpErrorW,
2829
+ nvpBalanceBaseW: sungrowBalanceBaseW,
2830
+ nvpBalanceTargetW: sungrowNvpBalancedTargetW,
2831
+ nvpBalanceNeeded,
2832
+ });
2833
+ }
2834
+
2547
2835
  // ------------------------------------------------------------
2548
2836
  // Phase 2: Dispatcher-Diagnose-Zustände schreiben
2549
2837
  // ------------------------------------------------------------
@@ -2759,6 +3047,19 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
2759
3047
 
2760
3048
 
2761
3049
  selfDischargeEnabled: storage.selfDischargeEnabled,
3050
+ // Herstellerprofile: generisch bleibt die normale Eigenverbrauchslogik,
3051
+ // FENECON/OpenEMS nutzt No-Write/Assist, Sungrow Hybrid nutzt NVP-geführte
3052
+ // 0-W-Kommandos im PV-deckenden Betrieb.
3053
+ vendorProfile: storage.vendorProfile,
3054
+ sungrowHybridEnabled: storage.sungrowHybridEnabled,
3055
+ sungrowPvPassthroughEnabled: storage.sungrowPvPassthroughEnabled,
3056
+ sungrowZeroOnPvCoverage: storage.sungrowZeroOnPvCoverage,
3057
+ sungrowDischargeOnlyOnGridImport: storage.sungrowDischargeOnlyOnGridImport,
3058
+ sungrowPvThresholdW: storage.sungrowPvThresholdW,
3059
+ sungrowLoadCoverReserveW: storage.sungrowLoadCoverReserveW,
3060
+ sungrowTargetGridImportW: storage.sungrowTargetGridImportW,
3061
+ sungrowImportThresholdW: storage.sungrowImportThresholdW,
3062
+ sungrowAssistBufferW: storage.sungrowAssistBufferW,
2762
3063
  // Legacy: feneconAcMode bleibt als Migrations-Alias erhalten.
2763
3064
  // feneconGridControlEnabled ist aus UI-/Migrationsgründen der gespeicherte
2764
3065
  // Haken, bedeutet ab 0.6.255 aber: Hybrid-/Gateway-Priorität-Gateway-Priorität.
@@ -2816,7 +3117,21 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
2816
3117
  * Zusammenhang: Hängt fachlich an Adapter-StateCache, Mapping/Datapoints und den EMS-Modulen; Änderungen können LIVE, History und Regelungslogik beeinflussen.
2817
3118
  * TypeScript-Hinweis: Beim TypeScript-Umbau Parameter, Rückgabewert und verwendete State-/Config-Struktur explizit typisieren.
2818
3119
  */
3120
+ _getStorageVendorProfile(cfg = {}) {
3121
+ const raw = String((cfg && cfg.vendorProfile) || '').trim().toLowerCase();
3122
+ if (raw === 'fenecon' || raw === 'openems' || raw === 'fems' || raw === 'fenecon-openems') return 'fenecon-openems';
3123
+ if (raw === 'sungrow' || raw === 'sungrow-ess' || raw === 'sungrow-hybrid') return 'sungrow-hybrid';
3124
+ // Migration: alte FENECON-Haken bleiben als Profil erkennbar, solange kein
3125
+ // explizites anderes Herstellerprofil gespeichert wurde.
3126
+ if (!raw && cfg && (cfg.feneconGridControlEnabled === true || cfg.feneconAcMode === true)) return 'fenecon-openems';
3127
+ if (!raw && cfg && cfg.sungrowHybridEnabled === true) return 'sungrow-hybrid';
3128
+ return 'generic';
3129
+ }
3130
+
2819
3131
  _isFeneconHybridControlConfigured(cfg = {}) {
3132
+ const profile = this._getStorageVendorProfile(cfg);
3133
+ if (profile === 'fenecon-openems') return true;
3134
+ if (profile !== 'generic') return false;
2820
3135
  if (cfg && typeof cfg.feneconGridControlEnabled === 'boolean') return cfg.feneconGridControlEnabled === true;
2821
3136
  // Migration: ältere Installationen hatten nur storage.feneconAcMode.
2822
3137
  // Ab 0.6.255 bedeutet dieser alte Haken: Hybrid-/Gateway-Priorität-Sondermodus
@@ -2824,6 +3139,10 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
2824
3139
  return !!(cfg && cfg.feneconAcMode === true);
2825
3140
  }
2826
3141
 
3142
+ _isSungrowHybridControlConfigured(cfg = {}) {
3143
+ return this._getStorageVendorProfile(cfg) === 'sungrow-hybrid';
3144
+ }
3145
+
2827
3146
  // Legacy-Alias für ältere interne Aufrufe.
2828
3147
  /**
2829
3148
  * Code-Teil: Methode `_isFeneconGridControlConfigured`
@@ -2834,6 +3153,168 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
2834
3153
  _isFeneconGridControlConfigured(cfg = {}) {
2835
3154
  return this._isFeneconHybridControlConfigured(cfg);
2836
3155
  }
3156
+ async _buildSungrowHybridContext({ cfg = {}, staleMs = 15000, readCacheNumber = null, gridW = null, gridRawW = null } = {}) {
3157
+ const thresholdW = Math.max(0, num(cfg.sungrowPvThresholdW, 300));
3158
+ const loadCoverReserveW = Math.max(0, num(cfg.sungrowLoadCoverReserveW, 300));
3159
+ const dischargeThresholdW = Math.max(0, num(cfg.sungrowImportThresholdW, num(cfg.selfImportThresholdW, 100)));
3160
+ const targetGridImportW = Math.max(0, num(cfg.sungrowTargetGridImportW, num(cfg.selfTargetGridImportW, 100)));
3161
+ const now = Date.now();
3162
+
3163
+ /**
3164
+ * Code-Teil: readCache
3165
+ * Zweck: Liest frische Mapping-/Derived-Werte fuer das Sungrow-Herstellerprofil.
3166
+ * Zusammenhang: Sungrow Hybrid ESS wird nicht ueber Gebaeudelast blind gefuehrt;
3167
+ * diese Werte dienen nur zur Entscheidung, ob PV die Last bereits deckt.
3168
+ */
3169
+ const readCache = (key) => {
3170
+ const sid = String(key || '').trim();
3171
+ if (!sid) return null;
3172
+ try {
3173
+ if (typeof readCacheNumber === 'function') {
3174
+ const n = readCacheNumber(sid, null);
3175
+ if (typeof n === 'number' && Number.isFinite(n)) return n;
3176
+ }
3177
+ } catch {
3178
+ // ignore
3179
+ }
3180
+ return null;
3181
+ };
3182
+
3183
+ const candidates = [];
3184
+ const pushCandidate = (value, source) => {
3185
+ const n = Number(value);
3186
+ if (Number.isFinite(n)) candidates.push({ w: Math.max(0, Math.abs(n)), source });
3187
+ };
3188
+
3189
+ // Bei Sungrow DC-/Hybrid-Anlagen ist der separate DC-/Hybrid-PV-DP die beste
3190
+ // Quelle. Falls er fehlt, nutzen wir die zentralen Core-/PV-Mirrors als Kontext.
3191
+ if (this.dp && String(cfg.coupling || 'ac').trim().toLowerCase() === 'dc' && String(cfg.dcPvPowerObjectId || '').trim()) {
3192
+ pushCandidate(this.dp.getNumberFresh('st.dcPvPowerW', staleMs, null), 'st.dcPvPowerW');
3193
+ }
3194
+ pushCandidate(readCache('derived.core.pv.totalW'), 'derived.core.pv.totalW');
3195
+ pushCandidate(readCache('derived.core.pv.dcW'), 'derived.core.pv.dcW');
3196
+ pushCandidate(readCache('pvPower'), 'pvPower');
3197
+ pushCandidate(readCache('productionTotal'), 'productionTotal');
3198
+ if (this.dp) pushCandidate(this.dp.getNumberFresh('ps.pvW', staleMs, null), 'ps.pvW');
3199
+
3200
+ let pvW = 0;
3201
+ let pvSource = 'missing';
3202
+ for (const c of candidates) {
3203
+ if (c.w >= pvW) {
3204
+ pvW = c.w;
3205
+ pvSource = c.source;
3206
+ }
3207
+ }
3208
+
3209
+ let loadW = 0;
3210
+ let loadSource = 'missing';
3211
+ const loadTotalDerivedW = readCache('derived.core.building.loadTotalW');
3212
+ if (typeof loadTotalDerivedW === 'number' && Number.isFinite(loadTotalDerivedW) && loadTotalDerivedW >= 0) {
3213
+ loadW = Math.max(0, loadTotalDerivedW);
3214
+ loadSource = 'derived.core.building.loadTotalW';
3215
+ } else {
3216
+ const loadTotalMappedW = readCache('consumptionTotal');
3217
+ if (typeof loadTotalMappedW === 'number' && Number.isFinite(loadTotalMappedW) && loadTotalMappedW >= 0) {
3218
+ loadW = Math.max(0, loadTotalMappedW);
3219
+ loadSource = 'consumptionTotal';
3220
+ } else {
3221
+ const loadRestDerivedW = readCache('derived.core.building.loadRestW');
3222
+ if (typeof loadRestDerivedW === 'number' && Number.isFinite(loadRestDerivedW) && loadRestDerivedW >= 0) {
3223
+ const evTotalW = Math.max(0, Math.abs(num(readCache('evcs.totalPowerW'), 0)));
3224
+ let consumersTotalW = 0;
3225
+ for (let i = 1; i <= 10; i++) {
3226
+ const c = readCache(`consumer${i}Power`);
3227
+ if (typeof c === 'number' && Number.isFinite(c)) consumersTotalW += Math.abs(c);
3228
+ }
3229
+ loadW = Math.max(0, loadRestDerivedW + evTotalW + consumersTotalW);
3230
+ loadSource = 'derived.core.building.loadRestW+slots';
3231
+ }
3232
+ }
3233
+ }
3234
+
3235
+ const nvpW = (typeof gridRawW === 'number' && Number.isFinite(gridRawW))
3236
+ ? Number(gridRawW)
3237
+ : ((typeof gridW === 'number' && Number.isFinite(gridW)) ? Number(gridW) : null);
3238
+ const importW = (typeof nvpW === 'number') ? Math.max(0, nvpW) : 0;
3239
+ const exportW = (typeof nvpW === 'number') ? Math.max(0, -nvpW) : 0;
3240
+ const pvActive = pvW >= thresholdW;
3241
+
3242
+ // PV deckt Last: Nur dann blocken wir die externe Entladung hart. Falls kein
3243
+ // Lastwert vorliegt, gilt NVP nahe Zielbezug als Deckungsersatz; bei echtem
3244
+ // Import ohne Lastkontext bleibt der NVP-Assist moeglich.
3245
+ const loadKnown = loadW > 0;
3246
+ const pvCoversLoad = !!(pvActive && (
3247
+ (loadKnown && pvW >= (loadW + loadCoverReserveW)) ||
3248
+ (!loadKnown && importW <= Math.max(targetGridImportW, dischargeThresholdW))
3249
+ ));
3250
+
3251
+ let mode = 'nvp-control';
3252
+ let writeMode = 'standard';
3253
+ let reason = 'Sungrow Hybrid ESS: NVP-geführte Standardregelung';
3254
+ if (pvCoversLoad) {
3255
+ mode = 'pv-covered-zero';
3256
+ writeMode = 'write-zero-pv-covered';
3257
+ reason = 'Sungrow Hybrid ESS: PV deckt Gebäudelast – externe Speicheranforderung auf 0';
3258
+ } else if (pvActive) {
3259
+ mode = 'pv-active-nvp-assist';
3260
+ writeMode = 'nvp-assist-if-import';
3261
+ reason = 'Sungrow Hybrid ESS: PV aktiv, NVP entscheidet über Assist';
3262
+ }
3263
+
3264
+ return {
3265
+ active: true,
3266
+ configured: true,
3267
+ mode,
3268
+ writeMode,
3269
+ reason,
3270
+ pvW,
3271
+ pvSource,
3272
+ thresholdW,
3273
+ loadW,
3274
+ loadSource,
3275
+ loadCoverReserveW,
3276
+ loadKnown,
3277
+ pvActive,
3278
+ pvCoversLoad,
3279
+ targetGridImportW,
3280
+ dischargeThresholdW,
3281
+ nvpW,
3282
+ importW,
3283
+ exportW,
3284
+ };
3285
+ }
3286
+
3287
+ /**
3288
+ * Code-Teil: Methode `_setSungrowHybridDiag`
3289
+ * Zweck: schreibt Diagnosewerte fuer das Sungrow-Herstellerprofil.
3290
+ * Zusammenhang: Macht im Feld sichtbar, ob NexoWatt externe Vorgaben auf 0
3291
+ * setzt, weil PV die Last deckt, oder ob ein NVP-begrenzter Assist aktiv ist.
3292
+ */
3293
+ async _setSungrowHybridDiag(ctx = {}) {
3294
+ const active = !!ctx.active;
3295
+ const n = (v, fallback = null) => Number.isFinite(Number(v)) ? Math.round(Number(v)) : fallback;
3296
+ await this._setIfChanged('speicher.regelung.sungrowHybridAktiv', active);
3297
+ await this._setIfChanged('speicher.regelung.sungrowHybridModus', String(ctx.mode || ''));
3298
+ await this._setIfChanged('speicher.regelung.sungrowHybridGrund', String(ctx.reason || ''));
3299
+ await this._setIfChanged('speicher.regelung.sungrowHybridSchreibmodus', String(ctx.writeMode || ''));
3300
+ await this._setIfChanged('speicher.regelung.sungrowHybridSollW', n(ctx.targetW, 0));
3301
+ await this._setIfChanged('speicher.regelung.sungrowHybridPvW', n(ctx.pvW, 0));
3302
+ await this._setIfChanged('speicher.regelung.sungrowHybridLastW', n(ctx.loadW, 0));
3303
+ await this._setIfChanged('speicher.regelung.sungrowHybridNvpW', n(ctx.nvpW));
3304
+ await this._setIfChanged('speicher.regelung.sungrowHybridImportW', n(ctx.importW, 0));
3305
+ await this._setIfChanged('speicher.regelung.sungrowHybridExportW', n(ctx.exportW, 0));
3306
+ await this._setIfChanged('speicher.regelung.sungrowHybridPvDecktLast', !!ctx.pvCoversLoad);
3307
+ await this._setIfChanged('speicher.regelung.sungrowHybridSchwelleW', n(ctx.thresholdW, 300));
3308
+ await this._setIfChanged('speicher.regelung.sungrowHybridLastReserveW', n(ctx.loadCoverReserveW, 300));
3309
+ await this._setIfChanged('speicher.regelung.sungrowHybridImportSchwelleW', n(ctx.dischargeThresholdW, 100));
3310
+ await this._setIfChanged('speicher.regelung.sungrowHybridNvpZielW', n(ctx.nvpTargetW, 100));
3311
+ await this._setIfChanged('speicher.regelung.sungrowHybridNvpDeadbandW', n(ctx.nvpDeadbandW, 100));
3312
+ await this._setIfChanged('speicher.regelung.sungrowHybridNvpFehlerW', n(ctx.nvpErrorW, 0));
3313
+ await this._setIfChanged('speicher.regelung.sungrowHybridNvpBalanceBasisW', n(ctx.nvpBalanceBaseW, 0));
3314
+ await this._setIfChanged('speicher.regelung.sungrowHybridNvpBalanceZielW', n(ctx.nvpBalanceTargetW, 0));
3315
+ await this._setIfChanged('speicher.regelung.sungrowHybridNvpBalanceAktiv', !!ctx.nvpBalanceNeeded);
3316
+ }
3317
+
2837
3318
  async _buildFeneconHybridContext({ cfg = {}, staleMs = 15000, readCacheNumber = null, gridW = null, gridRawW = null } = {}) {
2838
3319
  const thresholdW = Math.max(0, num(cfg.feneconPvPassthroughThresholdW, 300));
2839
3320
  const additionalThresholdW = Math.max(0, num(cfg.feneconAdditionalPvThresholdW, 100));
@@ -3542,6 +4023,12 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
3542
4023
  await mk('speicher.regelung.selfTargetGridImportW', 'Eigenverbrauch Ziel-Netzbezug (W)', 'number', 'value.power', 0);
3543
4024
  await mk('speicher.regelung.selfImportThresholdW', 'Eigenverbrauch Deadband (W)', 'number', 'value.power', 0);
3544
4025
  await mk('speicher.regelung.selfEntladenAktiviert', 'Eigenverbrauch-Entladen aktiviert', 'boolean', 'indicator', false);
4026
+ await mk('speicher.regelung.sungrowHybridNvpZielW', 'Sungrow NVP Zielbezug (W)', 'number', 'value.power', 0);
4027
+ await mk('speicher.regelung.sungrowHybridNvpDeadbandW', 'Sungrow NVP Deadband (W)', 'number', 'value.power', 0);
4028
+ await mk('speicher.regelung.sungrowHybridNvpFehlerW', 'Sungrow NVP Regelfehler (W)', 'number', 'value.power', 0);
4029
+ await mk('speicher.regelung.sungrowHybridNvpBalanceBasisW', 'Sungrow NVP Balancing Basis/Ist (W)', 'number', 'value.power', 0);
4030
+ await mk('speicher.regelung.sungrowHybridNvpBalanceZielW', 'Sungrow NVP Balancing Ziel (W)', 'number', 'value.power', 0);
4031
+ await mk('speicher.regelung.sungrowHybridNvpBalanceAktiv', 'Sungrow NVP Balancing aktiv', 'boolean', 'indicator', false);
3545
4032
  await mk('speicher.regelung.policyMode', 'Speicher-Policy-Modus', 'string', 'text', 'eigenverbrauch');
3546
4033
  await mk('speicher.regelung.policyLayerStorageOnly', 'Policy-Schicht reine Eigenverbrauchsoptimierung', 'boolean', 'indicator', true);
3547
4034
  await mk('speicher.regelung.multiUsePolicyActive', 'MultiUse-Policy aktiv', 'boolean', 'indicator', false);
package/io-package.json CHANGED
@@ -1,8 +1,16 @@
1
1
  {
2
2
  "common": {
3
3
  "name": "nexowatt-ui",
4
- "version": "0.8.85",
4
+ "version": "0.8.87",
5
5
  "news": {
6
+ "0.8.87": {
7
+ "de": "Version 0.8.87: Korrigiert das Sungrow-Hybrid-ESS-NVP-Balancing. Die Speicherregelung verrechnet jetzt laufende Be-/Entladung mit der aktuellen NVP-Abweichung, damit Rest-Netzbezug über dem Zielband und Rest-Export nachgeregelt werden. PV-deckender Sungrow-Betrieb schreibt nur noch 0 W, wenn der NVP wirklich im Zielband liegt.",
8
+ "en": "Version 0.8.87: Fixes Sungrow Hybrid ESS NVP balancing. Storage control now combines the current charge/discharge power with the live NVP deviation so residual grid import above the target band and residual export are corrected. PV-covering Sungrow operation only writes 0 W when the NVP is actually within the target band."
9
+ },
10
+ "0.8.86": {
11
+ "de": "Version 0.8.86: Ergänzt Herstellerprofile in der Einzel-Speicherregelung und einen Sungrow-Hybrid-ESS-Modus. Sungrow-Anlagen setzen bei PV-deckender Leistung externe Lade-/Entladevorgaben auf 0 und entladen nur noch NVP-begrenzt bei echtem Netzbezug; FENECON/OpenEMS bleibt getrennt. Diagnosewerte für Sungrow-Hybrid wurden ergänzt.",
12
+ "en": "Version 0.8.86: Adds manufacturer profiles to single-storage control and a Sungrow Hybrid ESS mode. Sungrow systems now zero external charge/discharge setpoints when PV covers building load and only discharge with an NVP-capped assist on real grid import; FENECON/OpenEMS remains separate. Sungrow hybrid diagnostics were added."
13
+ },
6
14
  "0.8.85": {
7
15
  "de": "Version 0.8.85: Bindet den Speicherfarm-Menüpunkt strikt an AppCenter installiert+aktiv und echte Speicherfarm-Datenpunkte. Alte storageFarm-Runtime-States oder Legacy-Flags können den Kundenmenüpunkt nicht mehr sichtbar machen; Runtime-Hydration rettet nur noch Zeilen, aktiviert die App aber nicht automatisch.",
8
16
  "en": "Version 0.8.85: Strictly gates the storage farm menu entry on the App Center app being installed+enabled and real storage-farm datapoints. Stale storageFarm runtime states or legacy flags can no longer expose the customer menu item; runtime hydration only recovers rows and no longer auto-enables the app."
@@ -22,14 +30,6 @@
22
30
  "0.8.81": {
23
31
  "de": "Version 0.8.81: Speicherlogik fachlich neu abgesichert. Speicherregelung bleibt reine Eigenverbrauchsoptimierung, MultiUse führt Reserve/LSK/EVCS-Zonen, Speicherfarm verteilt nur Sollwerte; Entlade-Caps verhindern alte Sollwert-/Last-Rückkopplungen für Eigenverbrauch, Tarif und LSK.",
24
32
  "en": "Version 0.8.81: Hardens the storage control policy routing. Storage control stays pure self-consumption, MultiUse owns reserve/peak/EVCS zones, the storage farm only dispatches targets; discharge caps prevent stale setpoint/load feedback for self-consumption, tariff and peak shaving."
25
- },
26
- "0.8.80": {
27
- "de": "Version 0.8.80: Härtet zusätzlich die Speicher-Beladung. Alte negative Ladesollwerte laufen nicht mehr über die Rampe weiter, wenn PV-Export, Netz-Headroom oder die aktuelle Ladeanforderung auf weniger/0 W fallen; neue Diagnosewerte zeigen den Lade-Cap.",
28
- "en": "Version 0.8.80: Also hardens storage charging. Old negative charge setpoints no longer continue through ramping when PV export, grid headroom or the active charge request drop to less/0 W; new diagnostics expose the charge cap."
29
- },
30
- "0.8.79": {
31
- "de": "Version 0.8.79: Härtet die Speicher-Entladeregelung gegen Sollwert-Rückkopplung. Der letzte Entlade-Sollwert wird nicht mehr als echte Ist-Entladung für den NVP-Demand-Cap genutzt; Tarif- und Eigenverbrauchsmodus werden nach der Rampe hart auf die plausible Last begrenzt. Speicherfarm-Istleistungs-DPs, die auf Steuer-/Setpoint-DPs zeigen, werden ignoriert und diagnostiziert.",
32
- "en": "Version 0.8.79: Hardens storage discharge control against setpoint feedback. The last discharge setpoint is no longer used as real measured discharge for the NVP demand cap; tariff and self-consumption modes are hard-capped after ramping to plausible load. Storage-farm feedback power datapoints that point to control/setpoint datapoints are ignored and diagnosed."
33
33
  }
34
34
  },
35
35
  "title": "NexoWatt UI",
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "iobroker.nexowatt-ui",
3
- "version": "0.8.85",
3
+ "version": "0.8.87",
4
4
  "description": "Responsive NexoWatt EMS visualization adapter.",
5
5
  "author": "NexoWatt",
6
6
  "license": "UNLICENSED",
@@ -294,7 +294,8 @@
294
294
  "test:storage-policy-runtime": "node scripts/verify-storage-policy-runtime.js",
295
295
  "test:storage-single-tab-coupling": "node scripts/verify-storage-single-tab-coupling.js",
296
296
  "test:heating-rod-zero-export-budget": "node scripts/verify-heating-rod-zero-export-budget.js",
297
- "test:storagefarm-menu-appcenter-gate": "node scripts/verify-storagefarm-menu-appcenter-gate.js"
297
+ "test:storagefarm-menu-appcenter-gate": "node scripts/verify-storagefarm-menu-appcenter-gate.js",
298
+ "test:storage-sungrow-hybrid-profile": "node scripts/verify-storage-sungrow-hybrid-profile.js"
298
299
  },
299
300
  "dependencies": {
300
301
  "@iobroker/adapter-core": "^3.4.1",
package/www/ems-apps.html CHANGED
@@ -801,6 +801,19 @@
801
801
  </div>
802
802
  </div>
803
803
  </div>
804
+ <div class="nw-config-field-row">
805
+ <div class="nw-config-field-label">Herstellerprofil</div>
806
+ <div class="nw-config-field-control nw-config-field-control--stack">
807
+ <select id="storageVendorProfile" class="nw-config-input">
808
+ <option value="generic">Generic / Standard-Speicher</option>
809
+ <option value="fenecon-openems">FENECON / OpenEMS / FEMS</option>
810
+ <option value="sungrow-hybrid">Sungrow Hybrid ESS</option>
811
+ </select>
812
+ <div class="nw-config-help" style="margin-top:4px; opacity:0.85;">
813
+ Herstellerprofile ändern nur den Schreibpfad und die Schutzlogik der Einzel-Speicherregelung. Grundlogik, NVP-Messung, SoC und Budget bleiben weiterhin zentral geführt.
814
+ </div>
815
+ </div>
816
+ </div>
804
817
  <div class="nw-config-field-row" id="storageDcPvHintRow" style="display:none;">
805
818
  <div class="nw-config-field-label">DC-/Hybrid-PV Leistung</div>
806
819
  <div class="nw-config-field-control nw-config-field-control--stack">
@@ -828,7 +841,7 @@
828
841
  </div>
829
842
  </div>
830
843
  </div>
831
- <div class="nw-config-field-row">
844
+ <div class="nw-config-field-row" id="storageFeneconOptionsRow">
832
845
  <div class="nw-config-field-label">FENECON / OpenEMS</div>
833
846
  <div class="nw-config-field-control nw-config-field-control--stack">
834
847
  <label class="nw-config-checklabel" for="storageFeneconAcMode">
@@ -848,6 +861,26 @@
848
861
  </div>
849
862
  </div>
850
863
  </div>
864
+ <div class="nw-config-field-row" id="storageSungrowOptionsRow" style="display:none;">
865
+ <div class="nw-config-field-label">Sungrow Hybrid ESS</div>
866
+ <div class="nw-config-field-control nw-config-field-control--stack">
867
+ <label class="nw-config-checklabel" for="storageSungrowPvPassthrough">
868
+ <input id="storageSungrowPvPassthrough" class="nw-config-checkbox" type="checkbox" />
869
+ <span>PV-/Tagesbetrieb durch Sungrow intern priorisieren</span>
870
+ </label>
871
+ <label class="nw-config-checklabel" for="storageSungrowZeroOnPvCoverage">
872
+ <input id="storageSungrowZeroOnPvCoverage" class="nw-config-checkbox" type="checkbox" />
873
+ <span>Bei PV-deckender Leistung Lade-/Entladevorgaben auf 0 setzen</span>
874
+ </label>
875
+ <label class="nw-config-checklabel" for="storageSungrowDischargeOnlyOnImport">
876
+ <input id="storageSungrowDischargeOnlyOnImport" class="nw-config-checkbox" type="checkbox" />
877
+ <span>Entladen nur bei echtem NVP-Netzbezug erlauben</span>
878
+ </label>
879
+ <div class="nw-config-help" style="margin-top:4px; opacity:0.85;">
880
+ Für Sungrow SH/RS/RT/MG-Hybrid-ESS: NexoWatt nutzt den NVP als Führungsgröße. Wenn PV den Gebäudeverbrauch deckt, werden externe Lade-/Entladevorgaben auf 0 gesetzt, damit Sungrow seine interne PV-/Batterielogik nicht durch einen Entlade-Sollwert übersteuert. Erst bei echtem Netzbezug ohne ausreichende PV-Deckung wird ein NVP-begrenzter Entlade-Assist geschrieben.
881
+ </div>
882
+ </div>
883
+ </div>
851
884
  <div id="storageTable" class="nw-config-list" style="margin-top:6px;"></div>
852
885
  </div>
853
886
  </div>
package/www/ems-apps.js CHANGED
@@ -2,7 +2,7 @@
2
2
  * AUTO-GENERATED RUNTIME FILE - NICHT MANUELL BEARBEITEN.
3
3
  *
4
4
  * Quelle: src-ts/runtime-executables/www/ems-apps.ts
5
- * Quell-Hash: sha256:d677b139dd049b04e30ecafaf1d8aca44208c817008e34f4fcfecd4e40fb8481
5
+ * Quell-Hash: sha256:0dfb0307c7a9f3719b56986c236be29e911a9bb53c92b270e1f797f7fa6fb9f0
6
6
  * Erzeugung: npm run sync:ts-runtime-executables
7
7
  *
8
8
  * Zweck:
@@ -107,9 +107,15 @@
107
107
  storageCapacityKWh: document.getElementById('storageCapacityKWh'),
108
108
  storageCouplingMode: document.getElementById('storageCouplingMode'),
109
109
  storageDcPvHintRow: document.getElementById('storageDcPvHintRow'),
110
+ storageVendorProfile: document.getElementById('storageVendorProfile'),
111
+ storageFeneconOptionsRow: document.getElementById('storageFeneconOptionsRow'),
110
112
  storageFeneconAcMode: document.getElementById('storageFeneconAcMode'),
111
113
  storageFeneconDayNoWrite: document.getElementById('storageFeneconDayNoWrite'),
112
114
  storageFeneconAssist: document.getElementById('storageFeneconAssist'),
115
+ storageSungrowOptionsRow: document.getElementById('storageSungrowOptionsRow'),
116
+ storageSungrowPvPassthrough: document.getElementById('storageSungrowPvPassthrough'),
117
+ storageSungrowZeroOnPvCoverage: document.getElementById('storageSungrowZeroOnPvCoverage'),
118
+ storageSungrowDischargeOnlyOnImport: document.getElementById('storageSungrowDischargeOnlyOnImport'),
113
119
 
114
120
  // Speicherfarm
115
121
  storageFarmMode: document.getElementById('storageFarmMode'),
@@ -8401,6 +8407,30 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
8401
8407
  return v === 'dc' ? 'dc' : 'ac';
8402
8408
  }
8403
8409
 
8410
+ /**
8411
+ * Code-Teil: normalizeStorageVendorProfile
8412
+ * Zweck: Normalisiert die herstellerspezifische Speicher-Auswahl auf stabile Config-Werte.
8413
+ * Zusammenhang: Herstellerprofile duerfen die Grundlogik nicht ersetzen, sondern nur
8414
+ * den Schreibpfad und Sonderguards fuer Hybrid-/Gateway-Speicher anpassen.
8415
+ */
8416
+ function normalizeStorageVendorProfile(v) {
8417
+ const s = String(v || '').trim().toLowerCase();
8418
+ if (s === 'fenecon' || s === 'openems' || s === 'fems' || s === 'fenecon-openems') return 'fenecon-openems';
8419
+ if (s === 'sungrow' || s === 'sungrow-ess' || s === 'sungrow-hybrid') return 'sungrow-hybrid';
8420
+ return 'generic';
8421
+ }
8422
+
8423
+ /**
8424
+ * Code-Teil: getStorageVendorProfile
8425
+ * Zweck: Liest das ausgewaehlte Herstellerprofil im Speicher-Reiter.
8426
+ * Zusammenhang: Das Profil bestimmt, ob FENECON-No-Write oder Sungrow-NVP-Assist
8427
+ * aktiv wird; Generic bleibt die unveraenderte Eigenverbrauchsoptimierung.
8428
+ */
8429
+ function getStorageVendorProfile() {
8430
+ const v = (els.storageVendorProfile && els.storageVendorProfile.value) ? String(els.storageVendorProfile.value) : 'generic';
8431
+ return normalizeStorageVendorProfile(v);
8432
+ }
8433
+
8404
8434
  /**
8405
8435
  * Code-Teil: updateStorageCouplingUi
8406
8436
  * Zweck: Blendet DC-/Hybrid-Hinweise und die passenden Speicher-DP-Felder ein.
@@ -8411,6 +8441,18 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
8411
8441
  const coupling = getStorageCoupling();
8412
8442
  if (els.storageDcPvHintRow) els.storageDcPvHintRow.style.display = (coupling === 'dc') ? '' : 'none';
8413
8443
  }
8444
+
8445
+ /**
8446
+ * Code-Teil: updateStorageVendorProfileUi
8447
+ * Zweck: Zeigt nur die Optionen des aktiven Herstellerprofils.
8448
+ * Zusammenhang: FENECON/OpenEMS und Sungrow Hybrid nutzen unterschiedliche
8449
+ * Schreibstrategien und duerfen nicht ueber denselben Haken vermischt werden.
8450
+ */
8451
+ function updateStorageVendorProfileUi() {
8452
+ const profile = getStorageVendorProfile();
8453
+ if (els.storageFeneconOptionsRow) els.storageFeneconOptionsRow.style.display = (profile === 'fenecon-openems') ? '' : 'none';
8454
+ if (els.storageSungrowOptionsRow) els.storageSungrowOptionsRow.style.display = (profile === 'sungrow-hybrid') ? '' : 'none';
8455
+ }
8414
8456
  /**
8415
8457
  * Code-Teil: rebuildStorageTable
8416
8458
  * Zweck: Verarbeitet Speicherwerte; signed DP, Split-DPs und Fallbacks müssen konsistent bleiben.
@@ -10647,9 +10689,15 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
10647
10689
  els.storageCapacityKWh.value = (Number.isFinite(cap) && cap > 0) ? String(cap) : '';
10648
10690
  }
10649
10691
  const stF = (currentConfig.storage && typeof currentConfig.storage === 'object') ? currentConfig.storage : {};
10650
- const feneconModeActive = (typeof stF.feneconGridControlEnabled === 'boolean')
10692
+ const legacyFeneconModeActive = (typeof stF.feneconGridControlEnabled === 'boolean')
10651
10693
  ? !!stF.feneconGridControlEnabled
10652
10694
  : !!stF.feneconAcMode;
10695
+ const vendorProfile = normalizeStorageVendorProfile(stF.vendorProfile || (legacyFeneconModeActive ? 'fenecon-openems' : (stF.sungrowHybridEnabled ? 'sungrow-hybrid' : 'generic')));
10696
+ if (els.storageVendorProfile) els.storageVendorProfile.value = vendorProfile;
10697
+ updateStorageVendorProfileUi();
10698
+
10699
+ const feneconModeActive = vendorProfile === 'fenecon-openems';
10700
+ const sungrowModeActive = vendorProfile === 'sungrow-hybrid';
10653
10701
  if (els.storageFeneconAcMode) {
10654
10702
  els.storageFeneconAcMode.checked = feneconModeActive;
10655
10703
  }
@@ -10665,6 +10713,15 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
10665
10713
  // trotz interner Freigabe und ausreichend SoC dauerhaft Netzbezug stehen bleibt.
10666
10714
  els.storageFeneconAssist.checked = feneconModeActive && (stF.feneconAssistEnabled !== false);
10667
10715
  }
10716
+ if (els.storageSungrowPvPassthrough) {
10717
+ els.storageSungrowPvPassthrough.checked = sungrowModeActive && (stF.sungrowPvPassthroughEnabled !== false);
10718
+ }
10719
+ if (els.storageSungrowZeroOnPvCoverage) {
10720
+ els.storageSungrowZeroOnPvCoverage.checked = sungrowModeActive && (stF.sungrowZeroOnPvCoverage !== false);
10721
+ }
10722
+ if (els.storageSungrowDischargeOnlyOnImport) {
10723
+ els.storageSungrowDischargeOnlyOnImport.checked = sungrowModeActive && (stF.sungrowDischargeOnlyOnGridImport !== false);
10724
+ }
10668
10725
  rebuildStorageTable();
10669
10726
  try { buildStorageFarmUI(); } catch (_e) {}
10670
10727
  try { buildStorageMultiUseUI(); } catch (_e) {}
@@ -12066,13 +12123,21 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
12066
12123
  patch.storage = deepMerge({}, currentConfig.storage || {});
12067
12124
  patch.storage.controlMode = getStorageMode();
12068
12125
  patch.storage.coupling = getStorageCoupling();
12126
+ patch.storage.vendorProfile = getStorageVendorProfile();
12069
12127
  patch.storage.datapoints = deepMerge({}, (currentConfig.storage && currentConfig.storage.datapoints) ? currentConfig.storage.datapoints : {});
12070
- patch.storage.feneconGridControlEnabled = !!(els.storageFeneconAcMode && els.storageFeneconAcMode.checked);
12071
- // FENECON/OpenEMS/FEMS: Der Haupt-Haken aktiviert den herstellerspezifischen
12128
+ patch.storage.feneconGridControlEnabled = patch.storage.vendorProfile === 'fenecon-openems';
12129
+ patch.storage.sungrowHybridEnabled = patch.storage.vendorProfile === 'sungrow-hybrid';
12130
+ // FENECON/OpenEMS/FEMS: Der Herstellerprofil-Haken aktiviert den
12072
12131
  // Gateway-Modus. Die Zusatz-Haken steuern, ob NexoWatt tagsueber gar nicht
12073
12132
  // schreibt und ob ein zeitverzoegerter NVP-Assist erlaubt ist.
12074
12133
  patch.storage.feneconDayNoWriteEnabled = !!(els.storageFeneconDayNoWrite && els.storageFeneconDayNoWrite.checked);
12075
12134
  patch.storage.feneconAssistEnabled = !!(els.storageFeneconAssist && els.storageFeneconAssist.checked);
12135
+ // Sungrow Hybrid ESS: NexoWatt arbeitet NVP-gefuehrt und setzt im PV-deckenden
12136
+ // Tagesbetrieb die externen Lade-/Entladevorgaben auf 0, damit die interne
12137
+ // Sungrow-PV-/Batterielogik nicht durch eine Fremdvorgabe uebersteuert wird.
12138
+ patch.storage.sungrowPvPassthroughEnabled = !!(els.storageSungrowPvPassthrough && els.storageSungrowPvPassthrough.checked);
12139
+ patch.storage.sungrowZeroOnPvCoverage = !!(els.storageSungrowZeroOnPvCoverage && els.storageSungrowZeroOnPvCoverage.checked);
12140
+ patch.storage.sungrowDischargeOnlyOnGridImport = !!(els.storageSungrowDischargeOnlyOnImport && els.storageSungrowDischargeOnlyOnImport.checked);
12076
12141
  // Der Haken bedeutet ab 0.6.255: Hybrid-/Gateway-Priorität.
12077
12142
  // SetGridActivePower wird nicht mehr verwendet; ein eventuell vorhandener Legacy-DP wird entfernt.
12078
12143
  try {
@@ -14300,44 +14365,68 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
14300
14365
  els.storageCapacityKWh.addEventListener('input', _update);
14301
14366
  }
14302
14367
 
14303
- if (els.storageFeneconAcMode) {
14368
+ {
14304
14369
  /**
14305
- * Code-Teil: _update
14306
- * Zweck: Synchronisiert die FENECON/OpenEMS-Haken direkt in currentConfig.
14307
- * Zusammenhang: Diese Werte steuern den Speicher-Schreibpfad: normaler
14308
- * Generic-Sollwert oder tagsueber No-Write mit optionalem NVP-Assist.
14370
+ * Code-Teil: _updateStorageVendorProfile
14371
+ * Zweck: Synchronisiert Herstellerprofil-Optionen direkt in currentConfig.
14372
+ * Zusammenhang: FENECON/OpenEMS nutzt No-Write/Assist; Sungrow Hybrid nutzt
14373
+ * NVP-geführte 0-W-Kommandos im PV-deckenden Betrieb.
14309
14374
  * TypeScript: DOM-Checkboxen spaeter als HTMLInputElement typisieren.
14310
14375
  */
14311
- const _update = () => {
14376
+ const _updateStorageVendorProfile = () => {
14312
14377
  currentConfig = currentConfig || {};
14313
14378
  currentConfig.storage = currentConfig.storage || {};
14314
- const active = !!els.storageFeneconAcMode.checked;
14315
- currentConfig.storage.feneconGridControlEnabled = active;
14379
+ const profile = getStorageVendorProfile();
14380
+ currentConfig.storage.vendorProfile = profile;
14381
+ currentConfig.storage.feneconGridControlEnabled = profile === 'fenecon-openems';
14382
+ currentConfig.storage.sungrowHybridEnabled = profile === 'sungrow-hybrid';
14383
+
14384
+ if (els.storageFeneconAcMode) els.storageFeneconAcMode.checked = profile === 'fenecon-openems';
14316
14385
  if (els.storageFeneconDayNoWrite) {
14317
- if (active && !els.storageFeneconDayNoWrite.checked && currentConfig.storage.feneconDayNoWriteEnabled === undefined) {
14386
+ if (profile === 'fenecon-openems' && !els.storageFeneconDayNoWrite.checked && currentConfig.storage.feneconDayNoWriteEnabled === undefined) {
14318
14387
  els.storageFeneconDayNoWrite.checked = true;
14319
14388
  }
14320
14389
  currentConfig.storage.feneconDayNoWriteEnabled = !!els.storageFeneconDayNoWrite.checked;
14321
14390
  }
14322
14391
  if (els.storageFeneconAssist) {
14323
- if (active && !els.storageFeneconAssist.checked && currentConfig.storage.feneconAssistEnabled === undefined) {
14392
+ if (profile === 'fenecon-openems' && !els.storageFeneconAssist.checked && currentConfig.storage.feneconAssistEnabled === undefined) {
14324
14393
  els.storageFeneconAssist.checked = true;
14325
14394
  }
14326
14395
  currentConfig.storage.feneconAssistEnabled = !!els.storageFeneconAssist.checked;
14327
14396
  }
14397
+
14398
+ if (els.storageSungrowPvPassthrough) {
14399
+ if (profile === 'sungrow-hybrid' && !els.storageSungrowPvPassthrough.checked && currentConfig.storage.sungrowPvPassthroughEnabled === undefined) {
14400
+ els.storageSungrowPvPassthrough.checked = true;
14401
+ }
14402
+ currentConfig.storage.sungrowPvPassthroughEnabled = !!els.storageSungrowPvPassthrough.checked;
14403
+ }
14404
+ if (els.storageSungrowZeroOnPvCoverage) {
14405
+ if (profile === 'sungrow-hybrid' && !els.storageSungrowZeroOnPvCoverage.checked && currentConfig.storage.sungrowZeroOnPvCoverage === undefined) {
14406
+ els.storageSungrowZeroOnPvCoverage.checked = true;
14407
+ }
14408
+ currentConfig.storage.sungrowZeroOnPvCoverage = !!els.storageSungrowZeroOnPvCoverage.checked;
14409
+ }
14410
+ if (els.storageSungrowDischargeOnlyOnImport) {
14411
+ if (profile === 'sungrow-hybrid' && !els.storageSungrowDischargeOnlyOnImport.checked && currentConfig.storage.sungrowDischargeOnlyOnGridImport === undefined) {
14412
+ els.storageSungrowDischargeOnlyOnImport.checked = true;
14413
+ }
14414
+ currentConfig.storage.sungrowDischargeOnlyOnGridImport = !!els.storageSungrowDischargeOnlyOnImport.checked;
14415
+ }
14416
+ updateStorageVendorProfileUi();
14417
+ scheduleValidation(200);
14328
14418
  };
14329
- // Ereignis-Kommentar: Bindet das UI-Ereignis 'change' an els.storageFeneconAcMode. Beim Umbau prüfen, welche DOM-Elemente/States dadurch geändert werden.
14330
- els.storageFeneconAcMode.addEventListener('change', _update);
14331
- // Ereignis-Kommentar: Bindet das UI-Ereignis 'input' an els.storageFeneconAcMode. Beim Umbau prüfen, welche DOM-Elemente/States dadurch geändert werden.
14332
- els.storageFeneconAcMode.addEventListener('input', _update);
14333
- if (els.storageFeneconDayNoWrite) {
14334
- els.storageFeneconDayNoWrite.addEventListener('change', _update);
14335
- els.storageFeneconDayNoWrite.addEventListener('input', _update);
14336
- }
14337
- if (els.storageFeneconAssist) {
14338
- els.storageFeneconAssist.addEventListener('change', _update);
14339
- els.storageFeneconAssist.addEventListener('input', _update);
14419
+
14420
+ if (els.storageVendorProfile) {
14421
+ els.storageVendorProfile.addEventListener('change', _updateStorageVendorProfile);
14422
+ els.storageVendorProfile.addEventListener('input', _updateStorageVendorProfile);
14340
14423
  }
14424
+ [els.storageFeneconAcMode, els.storageFeneconDayNoWrite, els.storageFeneconAssist, els.storageSungrowPvPassthrough, els.storageSungrowZeroOnPvCoverage, els.storageSungrowDischargeOnlyOnImport]
14425
+ .filter(Boolean)
14426
+ .forEach((el) => {
14427
+ el.addEventListener('change', _updateStorageVendorProfile);
14428
+ el.addEventListener('input', _updateStorageVendorProfile);
14429
+ });
14341
14430
  }
14342
14431
 
14343
14432
 
@@ -44,6 +44,6 @@
44
44
  "purpose": "maskable"
45
45
  }
46
46
  ],
47
- "version": "0.8.85",
48
- "appVersion": "0.8.85"
47
+ "version": "0.8.87",
48
+ "appVersion": "0.8.87"
49
49
  }
package/www/sw.js CHANGED
@@ -2,7 +2,7 @@
2
2
  * AUTO-GENERATED RUNTIME FILE - NICHT MANUELL BEARBEITEN.
3
3
  *
4
4
  * Quelle: src-ts/runtime-executables/www/sw.ts
5
- * Quell-Hash: sha256:a34ff686432a468831f420579e55d16a117299ee553b24c28032bb4c90fe9314
5
+ * Quell-Hash: sha256:3c6eacb21ddcd6aef4ea448442be2e23368b2585a2a23ff671c046fbdef42501
6
6
  * Erzeugung: npm run sync:ts-runtime-executables
7
7
  *
8
8
  * Zweck:
@@ -42,7 +42,7 @@
42
42
 
43
43
  // Increment cache name on releases so browser updates JS/HTML reliably.
44
44
  // NOTE: Keep this monotonic to force SW updates on hotfixes.
45
- const CACHE_NAME = 'nexowatt-cache-v387';
45
+ const CACHE_NAME = 'nexowatt-cache-v389';
46
46
 
47
47
  const OFFLINE_URLS = [
48
48
  './',