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.
- package/ems/modules/storage-control.js +528 -41
- package/io-package.json +9 -9
- package/package.json +3 -2
- package/www/ems-apps.html +34 -1
- package/www/ems-apps.js +114 -25
- package/www/manifest.webmanifest +2 -2
- package/www/sw.js +2 -2
|
@@ -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:
|
|
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
|
|
1938
|
-
//
|
|
1939
|
-
//
|
|
1940
|
-
|
|
1941
|
-
const
|
|
1942
|
-
|
|
1943
|
-
|
|
1944
|
-
|
|
1945
|
-
|
|
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 &&
|
|
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
|
|
1959
|
-
//
|
|
1960
|
-
//
|
|
1961
|
-
//
|
|
1962
|
-
|
|
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
|
-
|
|
1966
|
-
} else if (typeof
|
|
1967
|
-
|
|
1968
|
-
} else if (errAdjW < 0) {
|
|
1969
|
-
|
|
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
|
-
|
|
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
|
-
//
|
|
1982
|
-
//
|
|
1983
|
-
//
|
|
1984
|
-
//
|
|
1985
|
-
// Batterie-
|
|
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
|
-
|
|
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 &&
|
|
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
|
|
2089
|
-
|
|
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-
|
|
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
|
|
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.
|
|
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.
|
|
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:
|
|
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
|
|
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 =
|
|
12071
|
-
|
|
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
|
-
|
|
14368
|
+
{
|
|
14304
14369
|
/**
|
|
14305
|
-
* Code-Teil:
|
|
14306
|
-
* Zweck: Synchronisiert
|
|
14307
|
-
* Zusammenhang:
|
|
14308
|
-
*
|
|
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
|
|
14376
|
+
const _updateStorageVendorProfile = () => {
|
|
14312
14377
|
currentConfig = currentConfig || {};
|
|
14313
14378
|
currentConfig.storage = currentConfig.storage || {};
|
|
14314
|
-
const
|
|
14315
|
-
currentConfig.storage.
|
|
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 (
|
|
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 (
|
|
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
|
-
|
|
14330
|
-
els.
|
|
14331
|
-
|
|
14332
|
-
|
|
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
|
|
package/www/manifest.webmanifest
CHANGED
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:
|
|
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-
|
|
45
|
+
const CACHE_NAME = 'nexowatt-cache-v389';
|
|
46
46
|
|
|
47
47
|
const OFFLINE_URLS = [
|
|
48
48
|
'./',
|