iobroker.nexowatt-ui 0.8.78 → 0.8.81
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 +280 -105
- package/io-package.json +13 -13
- package/main.js +46 -22
- package/package.json +9 -2
- 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:2283b89c99f9ffe25d330808c0d26278a5b1fefe24df7168f4ab30a78e39ffb9
|
|
6
6
|
* Erzeugung: npm run sync:ts-runtime-executables
|
|
7
7
|
*
|
|
8
8
|
* Zweck:
|
|
@@ -408,15 +408,24 @@ class SpeicherRegelungModule extends BaseModule {
|
|
|
408
408
|
autoTarifEnabled = false;
|
|
409
409
|
}
|
|
410
410
|
|
|
411
|
-
//
|
|
412
|
-
//
|
|
413
|
-
//
|
|
414
|
-
//
|
|
415
|
-
//
|
|
416
|
-
// -
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
411
|
+
// Policy-Router: Speicherregelung, MultiUse und Speicherfarm haben getrennte Rollen.
|
|
412
|
+
// - Speicherregelungs-App: startet die reine Eigenverbrauchsoptimierung als Basis.
|
|
413
|
+
// - MultiUse-App: startet/fuehrt zusaetzlich Reserve-, LSK- und SoC-Zonen.
|
|
414
|
+
// - Speicherfarm: verteilt nur den fertigen Sollwert und startet keine Regelung allein.
|
|
415
|
+
// Diese fruehe Erkennung verhindert, dass eine aktive MultiUse-Policy wegen eines
|
|
416
|
+
// fehlenden enableStorageControl-Hakens wirkungslos bleibt.
|
|
417
|
+
const installerCfgForMultiUseEarly = (this.adapter && this.adapter.config && this.adapter.config.installerConfig && typeof this.adapter.config.installerConfig === 'object')
|
|
418
|
+
? this.adapter.config.installerConfig
|
|
419
|
+
: {};
|
|
420
|
+
const storageMultiUseCfgEarly = (installerCfgForMultiUseEarly.storageMultiUse && typeof installerCfgForMultiUseEarly.storageMultiUse === 'object')
|
|
421
|
+
? installerCfgForMultiUseEarly.storageMultiUse
|
|
422
|
+
: null;
|
|
423
|
+
const multiUsePolicyConfiguredEarly = !!storageMultiUseCfgEarly;
|
|
424
|
+
const multiUseAppPolicyActive = !!(this.adapter && this.adapter.config && this.adapter.config.enableMultiUse && storageMultiUseCfgEarly && storageMultiUseCfgEarly.enabled === true);
|
|
425
|
+
|
|
426
|
+
// Effektive Aktivierung bewusst nur ueber Speicherregelungs-App, Tarif-Automatik
|
|
427
|
+
// oder aktive MultiUse-Policy. Die Speicherfarm ist hier KEIN eigener Auto-Start.
|
|
428
|
+
const enabled = cfgEnabled || autoTarifEnabled || multiUseAppPolicyActive;
|
|
420
429
|
|
|
421
430
|
// SoC-Hysterese optional aus Konfig lesen (falls später im Admin ergänzt).
|
|
422
431
|
// Default bleibt 0.5 %-Punkte.
|
|
@@ -426,6 +435,7 @@ class SpeicherRegelungModule extends BaseModule {
|
|
|
426
435
|
await this._setIfChanged('speicher.regelung.aktiv', enabled);
|
|
427
436
|
await this._setIfChanged('speicher.regelung.aktivKonfig', cfgEnabled);
|
|
428
437
|
await this._setIfChanged('speicher.regelung.aktivAutoTarif', autoTarifEnabled);
|
|
438
|
+
await this._setIfChanged('speicher.regelung.aktivAutoMultiUse', multiUseAppPolicyActive);
|
|
429
439
|
await this._setIfChanged('speicher.regelung.aktivAutoSpeicherfarm', false);
|
|
430
440
|
|
|
431
441
|
// Wenn effektiv deaktiviert: nur Diagnose aktualisieren – KEINE Setpoints schreiben.
|
|
@@ -801,6 +811,13 @@ class SpeicherRegelungModule extends BaseModule {
|
|
|
801
811
|
let dischargeDemandHardCapW = null;
|
|
802
812
|
let dischargeDemandHardCapReason = '';
|
|
803
813
|
|
|
814
|
+
// Harte Lade-Demand-Cap für PV-/Tarif-/Reserve-Laden.
|
|
815
|
+
// Hintergrund: Auch beim Laden darf die Rampe keinen alten negativen Sollwert weiter
|
|
816
|
+
// halten, wenn PV-Export, Netz-Headroom oder die aktuelle Ladeanforderung bereits
|
|
817
|
+
// kleiner/0 W geworden sind. 0 W heißt dabei bewusst: diese Richtung jetzt stoppen.
|
|
818
|
+
let chargeDemandHardCapW = null;
|
|
819
|
+
let chargeDemandHardCapReason = '';
|
|
820
|
+
|
|
804
821
|
const exportW = Math.max(0, -gridW); // negative Netzleistung = Einspeisung (geglättet)
|
|
805
822
|
const importW = Math.max(0, gridW); // positive Netzleistung = Bezug (geglättet)
|
|
806
823
|
const nvpRawW = (typeof gridRawW === 'number') ? gridRawW : gridW; // Import + / Export -
|
|
@@ -1057,20 +1074,27 @@ if (typeof soc === 'number') {
|
|
|
1057
1074
|
// Alte MultiUse-Werte wie selfDischargeEnabled=false dürfen dann keine
|
|
1058
1075
|
// dauerhafte 0-W-Sperre mehr verursachen; echte 0-W-Sollwerte auf den
|
|
1059
1076
|
// Ziel-DPs bleiben davon unberührt und stoppen den Speicher weiterhin.
|
|
1060
|
-
const installerCfgForMultiUse =
|
|
1061
|
-
|
|
1062
|
-
|
|
1063
|
-
const
|
|
1064
|
-
? installerCfgForMultiUse.storageMultiUse
|
|
1065
|
-
: null;
|
|
1066
|
-
const multiUsePolicyConfigured = !!storageMultiUseCfg;
|
|
1067
|
-
const multiUsePolicyActive = !!(this.adapter && this.adapter.config && this.adapter.config.enableMultiUse && storageMultiUseCfg && storageMultiUseCfg.enabled === true);
|
|
1077
|
+
const installerCfgForMultiUse = installerCfgForMultiUseEarly;
|
|
1078
|
+
const storageMultiUseCfg = storageMultiUseCfgEarly;
|
|
1079
|
+
const multiUsePolicyConfigured = !!multiUsePolicyConfiguredEarly;
|
|
1080
|
+
const multiUsePolicyActive = !!multiUseAppPolicyActive;
|
|
1068
1081
|
const ignoreStaleMultiUsePolicy = !!(multiUsePolicyConfigured && !multiUsePolicyActive);
|
|
1069
|
-
|
|
1070
|
-
|
|
1071
|
-
|
|
1072
|
-
|
|
1073
|
-
|
|
1082
|
+
const storageOnlyPolicyActive = !multiUsePolicyActive;
|
|
1083
|
+
|
|
1084
|
+
// Rollenmodell Speicherregelung:
|
|
1085
|
+
// Ohne aktive MultiUse-App ist die Speicherregelungs-App bewusst eine
|
|
1086
|
+
// reine Eigenverbrauchsoptimierung: PV-Überschuss laden und Netzbezug
|
|
1087
|
+
// am NVP reduzieren. SoC-Zonen für Notstrom/Reserve und LSK gehören
|
|
1088
|
+
// erst zur aktiven MultiUse-Policy, damit alte MultiUse-Werte die
|
|
1089
|
+
// normale Speicherregelung nicht versteckt sperren oder verschieben.
|
|
1090
|
+
const multiUseOwnsZones = !!multiUsePolicyActive;
|
|
1091
|
+
|
|
1092
|
+
// Notstrom-Reserve: harte Untergrenze nur als aktive MultiUse-Zone.
|
|
1093
|
+
// Die reine Eigenverbrauchsoptimierung nutzt unten selfMinSoc als
|
|
1094
|
+
// Sicherheits-Minimum, aber keine separate Reserve-/Refill-Policy.
|
|
1095
|
+
const reserveEnabled = multiUseOwnsZones && !!cfg.reserveEnabled;
|
|
1096
|
+
const reserveMin = clamp(num(multiUseOwnsZones ? cfg.reserveMinSocPct : undefined, 20), 0, 100);
|
|
1097
|
+
const reserveTarget = clamp(num(multiUseOwnsZones ? cfg.reserveTargetSocPct : undefined, reserveMin), 0, 100);
|
|
1074
1098
|
|
|
1075
1099
|
const reserveActive = reserveEnabled && (typeof soc === 'number') && (soc <= reserveMin);
|
|
1076
1100
|
|
|
@@ -1088,10 +1112,16 @@ if (typeof soc === 'number') {
|
|
|
1088
1112
|
await this._setIfChanged('speicher.regelung.reserveMinSocPct', reserveMin);
|
|
1089
1113
|
await this._setIfChanged('speicher.regelung.reserveZielSocPct', reserveTarget);
|
|
1090
1114
|
|
|
1091
|
-
// LSK
|
|
1092
|
-
|
|
1093
|
-
|
|
1094
|
-
const
|
|
1115
|
+
// LSK/Peak-Shaving über den Speicher ist eine MultiUse-Funktion.
|
|
1116
|
+
// Ohne MultiUse bleibt die Speicher-App bei reiner Eigenverbrauchslogik;
|
|
1117
|
+
// Peak-Shaving kann dann nicht heimlich über alte SoC-Zonen eingreifen.
|
|
1118
|
+
const lskEnabledCfg = multiUseOwnsZones && (cfg.lskEnabled !== false);
|
|
1119
|
+
// Richtungs-Freigaben getrennt halten: Entladen kappt Peaks, Laden füllt die
|
|
1120
|
+
// LSK-Zone wieder auf. Beide dürfen nur wirken, wenn MultiUse die Policy führt.
|
|
1121
|
+
const lskDischargeEnabledCfg = !!(lskEnabledCfg && cfg.lskDischargeEnabled !== false);
|
|
1122
|
+
const lskChargeEnabledCfg = !!(lskEnabledCfg && cfg.lskChargeEnabled !== false);
|
|
1123
|
+
const lskMinSoc = clamp(num(multiUseOwnsZones ? cfg.lskMinSocPct : undefined, reserveMin), 0, 100);
|
|
1124
|
+
const lskMaxSoc = clamp(num(multiUseOwnsZones ? cfg.lskMaxSocPct : undefined, 100), 0, 100);
|
|
1095
1125
|
|
|
1096
1126
|
// Eigenverbrauch (Entladen optional)
|
|
1097
1127
|
// Hybrid-/Gateway-Priorität ab 0.6.255:
|
|
@@ -1104,7 +1134,7 @@ if (typeof soc === 'number') {
|
|
|
1104
1134
|
// Ist MultiUse deaktiviert, wird ein alter gespeicherter false-Wert ignoriert, damit die
|
|
1105
1135
|
// normale Eigenverbrauchsregelung bei SoC + Netzbezug weiter arbeiten kann.
|
|
1106
1136
|
const hasStoredSelfFlag = (cfg.selfDischargeEnabled === true || cfg.selfDischargeEnabled === false);
|
|
1107
|
-
const hasExplicitSelfFlag = hasStoredSelfFlag && !
|
|
1137
|
+
const hasExplicitSelfFlag = hasStoredSelfFlag && (!multiUsePolicyConfigured || multiUseOwnsZones);
|
|
1108
1138
|
const feneconAcMode = false;
|
|
1109
1139
|
// Farm-Verhalten bewusst unverändert lassen: ältere Farm-Setups, die den alten
|
|
1110
1140
|
// Haken nur als implizite Eigenverbrauchs-Freigabe genutzt haben, behalten diesen
|
|
@@ -1119,16 +1149,18 @@ if (typeof soc === 'number') {
|
|
|
1119
1149
|
const selfDischargeEnabled = hasExplicitSelfFlag
|
|
1120
1150
|
? (cfg.selfDischargeEnabled === true)
|
|
1121
1151
|
: (farmSelfDischargeFallback || feneconLowPvSelfDischargeFallback || genericSelfDischargeDefault);
|
|
1122
|
-
const selfMinSoc = clamp(num(
|
|
1123
|
-
const selfMaxSoc = clamp(num(
|
|
1152
|
+
const selfMinSoc = clamp(num((multiUseOwnsZones || !multiUsePolicyConfigured) ? cfg.selfMinSocPct : undefined, reserveMin), 0, 100);
|
|
1153
|
+
const selfMaxSoc = clamp(num((multiUseOwnsZones || !multiUsePolicyConfigured) ? cfg.selfMaxSocPct : undefined, 100), 0, 100);
|
|
1124
1154
|
// Eigenverbrauchs-Optimierung: Ziel-Netzbezug am NVP.
|
|
1125
1155
|
// Praxis: ein kleiner Bezug (z. B. 50–150 W) ist oft stabiler als exakt 0 W
|
|
1126
1156
|
// (Messrauschen, Totzeiten, Geräte-Rampen).
|
|
1127
1157
|
// Standard-Eigenverbrauch bleibt herstellerunabhängig bei kleinem Ziel-Import.
|
|
1128
1158
|
// Hybrid-/Gateway-Priorität entscheidet später pro Tick: Gateway-No-Write, Zusatz-PV-Laden
|
|
1129
1159
|
// oder normale externe Vorgabe bei wenig/keiner interner PV.
|
|
1130
|
-
|
|
1131
|
-
|
|
1160
|
+
// Zielwert/Deadband sind Tuningwerte der Eigenverbrauchsregelung und
|
|
1161
|
+
// dürfen auch ohne MultiUse genutzt werden. Sie bilden keine SoC-Zonen.
|
|
1162
|
+
const selfTargetGridW = Math.max(0, num(cfg.selfTargetGridImportW, 50));
|
|
1163
|
+
const selfImportThresholdW = Math.max(0, num(cfg.selfImportThresholdW, 50));
|
|
1132
1164
|
|
|
1133
1165
|
await this._setIfChanged('speicher.regelung.lskMinSocPct', lskMinSoc);
|
|
1134
1166
|
await this._setIfChanged('speicher.regelung.lskMaxSocPct', lskMaxSoc);
|
|
@@ -1137,9 +1169,13 @@ if (typeof soc === 'number') {
|
|
|
1137
1169
|
await this._setIfChanged('speicher.regelung.selfTargetGridImportW', selfTargetGridW);
|
|
1138
1170
|
await this._setIfChanged('speicher.regelung.selfImportThresholdW', selfImportThresholdW);
|
|
1139
1171
|
await this._setIfChanged('speicher.regelung.selfEntladenAktiviert', !!selfDischargeEnabled);
|
|
1172
|
+
await this._setIfChanged('speicher.regelung.lskPolicyAktiv', !!lskEnabledCfg);
|
|
1173
|
+
await this._setIfChanged('speicher.regelung.lskEntladenAktiviert', !!lskDischargeEnabledCfg);
|
|
1174
|
+
await this._setIfChanged('speicher.regelung.lskLadenAktiviert', !!lskChargeEnabledCfg);
|
|
1140
1175
|
await this._setIfChanged('speicher.regelung.multiUsePolicyActive', !!multiUsePolicyActive);
|
|
1141
1176
|
await this._setIfChanged('speicher.regelung.multiUsePolicyIgnored', !!ignoreStaleMultiUsePolicy);
|
|
1142
|
-
await this._setIfChanged('speicher.regelung.policyMode', multiUsePolicyActive ? 'multiuse' : '
|
|
1177
|
+
await this._setIfChanged('speicher.regelung.policyMode', multiUsePolicyActive ? 'multiuse' : 'eigenverbrauch');
|
|
1178
|
+
await this._setIfChanged('speicher.regelung.policyLayerStorageOnly', !!storageOnlyPolicyActive);
|
|
1143
1179
|
|
|
1144
1180
|
// Grenzen / Glättung
|
|
1145
1181
|
// maxChargeW/maxDischargeW sind *optionale* Software-Clamps.
|
|
@@ -1168,7 +1204,7 @@ if (typeof soc === 'number') {
|
|
|
1168
1204
|
// Wichtig: Diese Logik darf den Netzanschluss NICHT überlasten. Daher wird hier nicht "absolut" auf
|
|
1169
1205
|
// (Import - Limit) gesetzt (das führt zu einem Fixpunkt), sondern als Delta/Integrator auf die bestehende
|
|
1170
1206
|
// Sollleistung aufaddiert. Dadurch erreicht der Speicher das Ziel (Import <= Limit) zuverlässig.
|
|
1171
|
-
if (peakEnabled &&
|
|
1207
|
+
if (peakEnabled && lskDischargeEnabledCfg) {
|
|
1172
1208
|
const limitW = (typeof psLimitW === 'number' && psLimitW > 0) ? psLimitW : null;
|
|
1173
1209
|
|
|
1174
1210
|
// Für die Schutzfunktion immer den Rohwert am Netzanschlusspunkt verwenden (keine Mittelwert-Schönung).
|
|
@@ -1227,6 +1263,27 @@ if (typeof soc === 'number') {
|
|
|
1227
1263
|
: ((typeof psOverW === 'number' && psOverW > 0) ? psOverW : 0);
|
|
1228
1264
|
if (needW > 0 && nextSetW < needW) nextSetW = clamp(needW, 0, lskMaxDischargeEff);
|
|
1229
1265
|
|
|
1266
|
+
// Feldschutz 0.8.81: Lastspitzenkappung darf nicht über den sichtbaren
|
|
1267
|
+
// Peak-Bedarf hinaus hochintegrieren. Der sichere Bedarf ist hier:
|
|
1268
|
+
// echte Überschreitung am NVP + echte Batterie-Istentladung + Puffer.
|
|
1269
|
+
// Der letzte Sollwert zählt bewusst NICHT als Demand-Basis. Wenn die
|
|
1270
|
+
// Batterie-Istleistung fehlt, bleibt der Regler NVP-basiert konservativ;
|
|
1271
|
+
// dadurch kann ein falscher Modbus-/Setpoint-DP keinen Industrieanschluss
|
|
1272
|
+
// mit einem zu hohen Entladesollwert gefährden.
|
|
1273
|
+
const lskOverLimitW = Math.max(0, importNowW - limitW);
|
|
1274
|
+
const lskMeasuredDischargeW = (battPowerTrusted && typeof battPowerW === 'number' && Number.isFinite(battPowerW))
|
|
1275
|
+
? Math.max(0, battPowerW)
|
|
1276
|
+
: 0;
|
|
1277
|
+
const lskSafetyMarginW = 200;
|
|
1278
|
+
const lskDemandCapW = Math.max(0, lskOverLimitW + lskMeasuredDischargeW + lskSafetyMarginW);
|
|
1279
|
+
dischargeDemandHardCapW = (typeof dischargeDemandHardCapW === 'number')
|
|
1280
|
+
? Math.min(dischargeDemandHardCapW, lskDemandCapW)
|
|
1281
|
+
: lskDemandCapW;
|
|
1282
|
+
dischargeDemandHardCapReason = (battPowerTrusted && typeof battPowerW === 'number')
|
|
1283
|
+
? 'LSK-NVP-Demand-Cap (Peak-Überlast+Batterie)'
|
|
1284
|
+
: 'LSK-NVP-Demand-Cap (Peak-Überlast ohne Batterie-Istleistung)';
|
|
1285
|
+
nextSetW = Math.min(nextSetW, lskDemandCapW);
|
|
1286
|
+
|
|
1230
1287
|
targetW = nextSetW;
|
|
1231
1288
|
reason = `Lastspitzenkappung: entladen (Import ${Math.round(importNowW)} W > Limit ${Math.round(limitW)} W)`;
|
|
1232
1289
|
source = 'lastspitze';
|
|
@@ -1238,36 +1295,46 @@ if (typeof soc === 'number') {
|
|
|
1238
1295
|
}
|
|
1239
1296
|
}
|
|
1240
1297
|
|
|
1241
|
-
// 2) Gate C: Ladepark-Unterstützung (EVCS Boost/Auto) via Speicher-Entladung
|
|
1242
|
-
//
|
|
1298
|
+
// 2) Gate C: Ladepark-Unterstützung (EVCS Boost/Auto) via Speicher-Entladung.
|
|
1299
|
+
// Rollenmodell 0.8.81: Diese Kopplung gehört zu MultiUse. Die reine
|
|
1300
|
+
// Speicherregelungs-App bleibt Eigenverbrauchsoptimierung und darf keine
|
|
1301
|
+
// Ladepark-/Komfortentladung aus alten States starten.
|
|
1302
|
+
const evcsStorageAssistPolicyAllowed = !!multiUsePolicyActive;
|
|
1243
1303
|
if (targetW === 0 && !feneconAcMode) {
|
|
1244
1304
|
const assistW = await this._readOwnNumber('chargingManagement.control.storageAssistW');
|
|
1245
1305
|
evcsAssistReqW = (typeof assistW === 'number' && Number.isFinite(assistW)) ? assistW : 0;
|
|
1246
1306
|
if (typeof assistW === 'number' && assistW > 0) {
|
|
1247
|
-
|
|
1248
|
-
const reserveMinEff = reserveEnabled ? reserveMin : 0;
|
|
1249
|
-
const socOk = (typeof soc !== 'number') ? true : (soc > Math.max(reserveMinEff, selfMinSoc));
|
|
1250
|
-
if (typeof dischargeAllowed === 'boolean' && dischargeAllowed === false) {
|
|
1251
|
-
targetW = 0;
|
|
1252
|
-
reason = 'EVCS-Unterstützung blockiert (Tarif: Entladen gesperrt)';
|
|
1253
|
-
source = 'evcs';
|
|
1254
|
-
} else if (reserveActive) {
|
|
1255
|
-
targetW = 0;
|
|
1256
|
-
reason = 'EVCS-Unterstützung nötig, aber Notstrom-Reserve aktiv';
|
|
1257
|
-
source = 'evcs';
|
|
1258
|
-
} else if (reserveChargeWanted) {
|
|
1259
|
-
targetW = 0;
|
|
1260
|
-
reason = 'EVCS-Unterstützung blockiert (Reserve soll aufgefüllt werden)';
|
|
1261
|
-
source = 'evcs';
|
|
1262
|
-
} else if (!socOk) {
|
|
1307
|
+
if (!evcsStorageAssistPolicyAllowed) {
|
|
1263
1308
|
targetW = 0;
|
|
1264
|
-
reason = 'EVCS-Unterstützung blockiert (
|
|
1309
|
+
reason = 'EVCS-Unterstützung blockiert (MultiUse nicht aktiv; Speicherregelung = Eigenverbrauch pur)';
|
|
1265
1310
|
source = 'evcs';
|
|
1266
1311
|
} else {
|
|
1267
|
-
|
|
1268
|
-
|
|
1269
|
-
|
|
1270
|
-
|
|
1312
|
+
// EVCS-Unterstützung ist MultiUse-Komfort – wenn Reserve wieder aufgefüllt
|
|
1313
|
+
// werden soll, blockieren wir das bewusst.
|
|
1314
|
+
const reserveMinEff = reserveEnabled ? reserveMin : 0;
|
|
1315
|
+
const socOk = (typeof soc !== 'number') ? true : (soc > Math.max(reserveMinEff, selfMinSoc));
|
|
1316
|
+
if (typeof dischargeAllowed === 'boolean' && dischargeAllowed === false) {
|
|
1317
|
+
targetW = 0;
|
|
1318
|
+
reason = 'EVCS-Unterstützung blockiert (Tarif: Entladen gesperrt)';
|
|
1319
|
+
source = 'evcs';
|
|
1320
|
+
} else if (reserveActive) {
|
|
1321
|
+
targetW = 0;
|
|
1322
|
+
reason = 'EVCS-Unterstützung nötig, aber Notstrom-Reserve aktiv';
|
|
1323
|
+
source = 'evcs';
|
|
1324
|
+
} else if (reserveChargeWanted) {
|
|
1325
|
+
targetW = 0;
|
|
1326
|
+
reason = 'EVCS-Unterstützung blockiert (Reserve soll aufgefüllt werden)';
|
|
1327
|
+
source = 'evcs';
|
|
1328
|
+
} else if (!socOk) {
|
|
1329
|
+
targetW = 0;
|
|
1330
|
+
reason = 'EVCS-Unterstützung blockiert (SoC unter Minimum)';
|
|
1331
|
+
source = 'evcs';
|
|
1332
|
+
} else {
|
|
1333
|
+
targetW = clamp(assistW, 0, maxDischargeW);
|
|
1334
|
+
reason = `EVCS-Unterstützung: entladen (${Math.round(assistW)} W angefordert)`;
|
|
1335
|
+
source = 'evcs';
|
|
1336
|
+
hardDischargeMinSoc = Math.max(hardDischargeMinSoc, Math.max(reserveMinEff, selfMinSoc));
|
|
1337
|
+
}
|
|
1271
1338
|
}
|
|
1272
1339
|
}
|
|
1273
1340
|
}
|
|
@@ -1609,7 +1676,14 @@ if (typeof soc === 'number') {
|
|
|
1609
1676
|
if (pvBlockGridCharge) {
|
|
1610
1677
|
chargeW = 0;
|
|
1611
1678
|
}
|
|
1612
|
-
|
|
1679
|
+
chargeW = Math.max(0, chargeW);
|
|
1680
|
+
// Lade-Cap 0.8.80: Der nach Headroom, Importlimit und PV-Reserve erlaubte
|
|
1681
|
+
// Netzlade-Wert wird nach der Rampe erneut hart angewendet. Dadurch kann
|
|
1682
|
+
// ein alter hoher Lade-Sollwert nicht weiterlaufen, wenn der Tarif-/Headroom
|
|
1683
|
+
// Regler im aktuellen Tick nur noch wenig oder 0 W Laden erlaubt.
|
|
1684
|
+
chargeDemandHardCapW = chargeW;
|
|
1685
|
+
chargeDemandHardCapReason = pvBlockGridCharge ? 'Tarif-PV-Reserve-Lade-Cap' : 'Tarif-Netzlade-Headroom-Cap';
|
|
1686
|
+
targetW = -chargeW;
|
|
1613
1687
|
if (pvBlockGridCharge) {
|
|
1614
1688
|
reason = pvBlockReason || 'Tarif: günstig – PV Forecast -> Netzladen gesperrt';
|
|
1615
1689
|
} else if (tariffNegativeImportPreferred) {
|
|
@@ -1644,10 +1718,12 @@ if (typeof soc === 'number') {
|
|
|
1644
1718
|
const nvpCtrlW = (typeof nvpRawW === 'number') ? nvpRawW : gridW;
|
|
1645
1719
|
|
|
1646
1720
|
// Basis ist entweder:
|
|
1647
|
-
// - die Ist-Batterieleistung (OpenEMS-Balancing: batt + (grid-target)) oder
|
|
1648
|
-
// -
|
|
1721
|
+
// - die echte, frische Ist-Batterieleistung (OpenEMS-Balancing: batt + (grid-target)) oder
|
|
1722
|
+
// - ein konservativer NVP-Fallback ohne Integrator, wenn keine vertrauenswürdige Istleistung vorliegt.
|
|
1723
|
+
// Wichtig: Der letzte Sollwert darf ohne echte Rückmeldung nicht als Istleistung zählen,
|
|
1724
|
+
// weil sonst ein Setpoint-/Modbus-Fehler bis in gefährliche Leistungsbereiche hochlaufen kann.
|
|
1649
1725
|
const curSetW = (typeof this._lastTargetW === 'number' && this._lastTargetW > 0) ? this._lastTargetW : 0;
|
|
1650
|
-
const battWRaw = (typeof battPowerW === 'number' && Number.isFinite(battPowerW)) ? Number(battPowerW) : null;
|
|
1726
|
+
const battWRaw = (battPowerTrusted && typeof battPowerW === 'number' && Number.isFinite(battPowerW)) ? Number(battPowerW) : null;
|
|
1651
1727
|
const battW = (typeof battWRaw === 'number') ? Math.max(0, battWRaw) : null;
|
|
1652
1728
|
|
|
1653
1729
|
let errW = (typeof nvpCtrlW === 'number') ? (nvpCtrlW - targetImportW) : 0;
|
|
@@ -1666,25 +1742,44 @@ if (typeof soc === 'number') {
|
|
|
1666
1742
|
let errAdjW = outsideDeadband ? errW : 0;
|
|
1667
1743
|
|
|
1668
1744
|
// OpenEMS-Balancing (Vorbild): neuer Sollwert = battIst + (gridIst - gridZiel).
|
|
1669
|
-
//
|
|
1670
|
-
//
|
|
1671
|
-
//
|
|
1672
|
-
//
|
|
1673
|
-
|
|
1674
|
-
|
|
1675
|
-
|
|
1745
|
+
// Ohne vertrauenswürdige Batterie-Istleistung arbeiten wir bewusst konservativ:
|
|
1746
|
+
// - innerhalb der Deadband darf ein bestehender Sollwert gehalten werden,
|
|
1747
|
+
// - außerhalb der Deadband wird NICHT mehr über den alten Sollwert hochintegriert,
|
|
1748
|
+
// sondern nur der aktuell sichtbare NVP-Fehler kommandiert.
|
|
1749
|
+
// Dadurch bleibt die Tarif-Entladung auch bei falschem Modbus-/Setpoint-Mapping sicher.
|
|
1750
|
+
let nextSetW;
|
|
1751
|
+
if (holdInDeadband) {
|
|
1752
|
+
nextSetW = curSetW;
|
|
1753
|
+
} else if (typeof battW === 'number') {
|
|
1754
|
+
nextSetW = battW + errAdjW;
|
|
1755
|
+
} else if (errAdjW < 0) {
|
|
1756
|
+
nextSetW = Math.max(0, curSetW + errAdjW);
|
|
1757
|
+
} else {
|
|
1758
|
+
nextSetW = errAdjW;
|
|
1759
|
+
}
|
|
1676
1760
|
|
|
1677
1761
|
// Safety-Clamp gegen unnötige Export-Spikes:
|
|
1678
|
-
// Begrenze
|
|
1679
|
-
//
|
|
1680
|
-
//
|
|
1762
|
+
// Begrenze die Entladung auf den aktuell am NVP belegbaren Bedarf:
|
|
1763
|
+
// echter Import + echte gemessene Batterie-Entladung + kleiner Puffer.
|
|
1764
|
+
// WICHTIGER Feldfix 0.8.81: Abgeleitete Gebäudelasten (z. B. derived.loadTotalW)
|
|
1765
|
+
// dürfen diesen Cap NICHT vergrößern. Bei gleichzeitiger PV-Erzeugung kann die
|
|
1766
|
+
// Gebäudelast deutlich größer als der Netzbezug sein; würde man sie als Cap nutzen,
|
|
1767
|
+
// könnte der Speicher trotz nur 2-3 kW Import wieder auf zweistellige kW-Werte laufen.
|
|
1681
1768
|
const importRawNowW = Math.max(0, (typeof nvpRawW === 'number') ? nvpRawW : 0);
|
|
1682
1769
|
const measuredDischargeNowW = (typeof battW === 'number') ? Math.max(0, battW) : 0;
|
|
1683
|
-
const commandedDischargeNowW = curSetW > 0 ? curSetW : 0;
|
|
1684
|
-
const dischargeNowW = Math.max(measuredDischargeNowW, commandedDischargeNowW);
|
|
1685
1770
|
const safetyMarginW = 200;
|
|
1686
|
-
const
|
|
1687
|
-
|
|
1771
|
+
const measuredDemandCapW = Math.max(0, importRawNowW + measuredDischargeNowW + safetyMarginW);
|
|
1772
|
+
// Ohne vertrauenswürdige Batterie-Istleistung darf der letzte Sollwert auch in
|
|
1773
|
+
// der Deadband nicht als harte Obergrenze weiterleben. Sonst kann ein alter
|
|
1774
|
+
// hoher Entladebefehl nach der Rampe erneut durchrutschen.
|
|
1775
|
+
const maxByDemandW = measuredDemandCapW;
|
|
1776
|
+
if (Number.isFinite(maxByDemandW) && maxByDemandW >= 0) {
|
|
1777
|
+
dischargeDemandHardCapW = (typeof dischargeDemandHardCapW === 'number')
|
|
1778
|
+
? Math.min(dischargeDemandHardCapW, maxByDemandW)
|
|
1779
|
+
: maxByDemandW;
|
|
1780
|
+
dischargeDemandHardCapReason = (typeof battW === 'number')
|
|
1781
|
+
? 'Tarif-NVP-Demand-Cap (NVP+gemessene Batterie)'
|
|
1782
|
+
: 'Tarif-NVP-Demand-Cap (konservativ ohne Batterie-Istleistung)';
|
|
1688
1783
|
nextSetW = Math.min(nextSetW, maxByDemandW);
|
|
1689
1784
|
}
|
|
1690
1785
|
|
|
@@ -1844,34 +1939,45 @@ if (targetW === 0 && selfDischargeEnabled) {
|
|
|
1844
1939
|
let errAdjW = outsideDeadband ? errW : 0;
|
|
1845
1940
|
|
|
1846
1941
|
// OpenEMS-Balancing (Vorbild): battIst + (gridIst - gridZiel).
|
|
1847
|
-
//
|
|
1848
|
-
//
|
|
1849
|
-
//
|
|
1850
|
-
|
|
1851
|
-
|
|
1852
|
-
|
|
1942
|
+
// Ohne vertrauenswürdige Batterie-Istleistung wird nicht mehr über den
|
|
1943
|
+
// alten Sollwert hochintegriert. Der Fallback nutzt dann nur den aktuell
|
|
1944
|
+
// sichtbaren NVP-Fehler; in der Deadband darf ein bereits stabiler Sollwert
|
|
1945
|
+
// gehalten werden. Das schützt die Eigenverbrauchsoptimierung vor falschen
|
|
1946
|
+
// Modbus-/Setpoint-DPs und verhindert 71-kW-Ausreißer bei nur wenigen kW Import.
|
|
1947
|
+
let nextSetW;
|
|
1948
|
+
if (holdInDeadband) {
|
|
1949
|
+
nextSetW = curSetW;
|
|
1950
|
+
} else if (typeof battW === 'number') {
|
|
1951
|
+
nextSetW = battW + errAdjW;
|
|
1952
|
+
} else if (errAdjW < 0) {
|
|
1953
|
+
nextSetW = Math.max(0, curSetW + errAdjW);
|
|
1954
|
+
} else {
|
|
1955
|
+
nextSetW = errAdjW;
|
|
1956
|
+
}
|
|
1853
1957
|
|
|
1854
1958
|
// Safety-Clamp gegen Überschwingen:
|
|
1855
|
-
//
|
|
1856
|
-
//
|
|
1857
|
-
//
|
|
1858
|
-
//
|
|
1859
|
-
//
|
|
1860
|
-
//
|
|
1959
|
+
// Die Eigenverbrauchsoptimierung darf nur den aktuell am Netzpunkt sichtbaren
|
|
1960
|
+
// Restbedarf ausregeln. Der sichere Cap ist deshalb: echter NVP-Import + echte
|
|
1961
|
+
// gemessene Batterie-Entladung + Puffer. Abgeleitete Gebäudelasten werden hier
|
|
1962
|
+
// bewusst NICHT als Obergrenze genutzt, weil sie bei PV-Erzeugung viel höher als
|
|
1963
|
+
// der Netzbezug sein können und sonst wieder zu überhöhten Setpoints führen.
|
|
1964
|
+
// WICHTIGER Feldfix 0.8.81: Der letzte eigene Sollwert und derived.loadTotalW
|
|
1965
|
+
// dürfen die Demand-Basis nicht vergrößern. Ohne vertrauenswürdige Batterie-
|
|
1966
|
+
// Istleistung zählt nur der aktuelle NVP-Import plus kleiner Sicherheitsreserve.
|
|
1967
|
+
// Dadurch wird auch innerhalb der Deadband kein alter Setpoint konserviert, der
|
|
1968
|
+
// einen Kundenanschluss überlasten könnte. Stabile Haltewerte sind nur mit echter
|
|
1969
|
+
// Batterie-Istleistung erlaubt.
|
|
1861
1970
|
const importRawNowW = Math.max(0, (typeof nvpRawW === 'number') ? nvpRawW : 0);
|
|
1862
1971
|
const measuredDischargeNowW = (typeof battW === 'number') ? Math.max(0, battW) : 0;
|
|
1863
|
-
// Wenn Farm-/Gateway-Istwerte 0 W oder zeitversetzt liefern, darf der Demand-Cap
|
|
1864
|
-
// die laufende Eigenverbrauchs-Entladung nicht künstlich auf Import+Puffer drücken.
|
|
1865
|
-
// Der letzte eigene Sollwert zählt deshalb als plausible aktuelle Entladebasis.
|
|
1866
|
-
const commandedDischargeNowW = curSetW > 0 ? curSetW : 0;
|
|
1867
|
-
const dischargeNowW = Math.max(measuredDischargeNowW, commandedDischargeNowW);
|
|
1868
1972
|
const safetyMarginW = 200; // bewusst konservativ; Feintuning über selfTargetGridW/Deadband/Rampe
|
|
1869
|
-
const maxByDemandW = importRawNowW +
|
|
1973
|
+
const maxByDemandW = Math.max(0, importRawNowW + measuredDischargeNowW + safetyMarginW);
|
|
1870
1974
|
if (Number.isFinite(maxByDemandW) && maxByDemandW >= 0) {
|
|
1871
1975
|
dischargeDemandHardCapW = (typeof dischargeDemandHardCapW === 'number')
|
|
1872
1976
|
? Math.min(dischargeDemandHardCapW, maxByDemandW)
|
|
1873
1977
|
: maxByDemandW;
|
|
1874
|
-
dischargeDemandHardCapReason = '
|
|
1978
|
+
dischargeDemandHardCapReason = (typeof battW === 'number')
|
|
1979
|
+
? 'Eigenverbrauch-NVP-Demand-Cap (NVP+gemessene Batterie)'
|
|
1980
|
+
: 'Eigenverbrauch-NVP-Demand-Cap (konservativ ohne Batterie-Istleistung)';
|
|
1875
1981
|
nextSetW = Math.min(nextSetW, maxByDemandW);
|
|
1876
1982
|
}
|
|
1877
1983
|
|
|
@@ -1920,7 +2026,7 @@ if (targetW === 0 && selfDischargeEnabled) {
|
|
|
1920
2026
|
const thr = zeEnabled ? Math.min(thrBase, zeDeadband) : thrBase;
|
|
1921
2027
|
|
|
1922
2028
|
// Max-SoC für Laden: größter Bereich (Self/LSK/Reserve-Ziel)
|
|
1923
|
-
const lskMaxSocForCharge =
|
|
2029
|
+
const lskMaxSocForCharge = lskChargeEnabledCfg ? lskMaxSoc : selfMaxSoc;
|
|
1924
2030
|
const maxSocForCharge = clamp(Math.max(selfMaxSoc, lskMaxSocForCharge, reserveTarget), 0, 100);
|
|
1925
2031
|
hardChargeMaxSoc = maxSocForCharge;
|
|
1926
2032
|
|
|
@@ -1941,6 +2047,10 @@ if (targetW === 0 && selfDischargeEnabled) {
|
|
|
1941
2047
|
const pvChargeWouldBeActive = exportRawW >= thr && canChargeBySoc && chargeLimitW > 0;
|
|
1942
2048
|
if (pvChargeWouldBeActive && evPriorityBlockStorageCharge) {
|
|
1943
2049
|
targetW = 0;
|
|
2050
|
+
// Lade-Cap 0.8.80: Wenn EV-Priorität den Speicher blockiert, darf ein
|
|
2051
|
+
// alter PV-Ladesollwert nicht durch die Rampe weiterlaufen.
|
|
2052
|
+
chargeDemandHardCapW = 0;
|
|
2053
|
+
chargeDemandHardCapReason = 'EV-Priorität-Lade-Cap';
|
|
1944
2054
|
reason = evPriorityStarvedW > 0
|
|
1945
2055
|
? `EV-Priorität: PV zuerst an Ladepunkte (${Math.round(evPriorityStarvedW)} W offen)`
|
|
1946
2056
|
: 'EV-Priorität: PV zuerst an Ladepunkte';
|
|
@@ -1950,7 +2060,21 @@ if (targetW === 0 && selfDischargeEnabled) {
|
|
|
1950
2060
|
// damit die Ladeleistung bei wolkigem Himmel nicht "zittert".
|
|
1951
2061
|
const exportCtrlW = (typeof exportW === 'number') ? exportW : exportRawW;
|
|
1952
2062
|
const extraBias = (zeEnabled && gridChargeAllowed) ? zeBias : 0;
|
|
1953
|
-
|
|
2063
|
+
// Der harte Sicherheits-Cap nutzt bewusst den RAW-Export am NVP.
|
|
2064
|
+
// Wenn der Export in diesem Tick wegbricht, wird nach der Rampe sofort
|
|
2065
|
+
// auf diesen Rohwert begrenzt und nicht erst langsam heruntergefahren.
|
|
2066
|
+
// Feldschutz 0.8.81: Der geglättete Export darf nur als ruhiger
|
|
2067
|
+
// Regelwunsch dienen. Die aktuelle RAW-Messung bleibt die harte
|
|
2068
|
+
// Obergrenze, damit ein alter PV-Ladesollwert bei Netzbezug nicht
|
|
2069
|
+
// weiterläuft. Der Zero-Export-Bias wird nur addiert, solange RAW
|
|
2070
|
+
// tatsächlich Export zeigt; bei RAW=0/Import darf er keinen Netzbezug
|
|
2071
|
+
// in die Batterie ziehen.
|
|
2072
|
+
const exportCtrlCapW = Math.max(0, exportCtrlW + extraBias);
|
|
2073
|
+
const exportRawCapW = exportRawW > 0 ? Math.max(0, exportRawW + extraBias) : 0;
|
|
2074
|
+
const pvRawChargeCapW = clamp(Math.min(exportCtrlCapW, exportRawCapW), 0, chargeLimitW);
|
|
2075
|
+
chargeDemandHardCapW = pvRawChargeCapW;
|
|
2076
|
+
chargeDemandHardCapReason = zeEnabled ? 'Nulleinspeisung-PV-Rohwert-Lade-Cap' : 'PV-Rohwert-Lade-Cap';
|
|
2077
|
+
targetW = -pvRawChargeCapW;
|
|
1954
2078
|
reason = zeEnabled ? 'Nulleinspeisung: Export in Speicher umleiten' : 'Eigenverbrauch: PV-Überschuss laden';
|
|
1955
2079
|
source = 'pv';
|
|
1956
2080
|
}
|
|
@@ -1973,6 +2097,11 @@ if (targetW === 0 && selfDischargeEnabled) {
|
|
|
1973
2097
|
wantW = Math.min(wantW, psHeadroomW);
|
|
1974
2098
|
}
|
|
1975
2099
|
|
|
2100
|
+
// Lade-Cap 0.8.80: Die Reserve-Nachladung darf nach der Rampe nie
|
|
2101
|
+
// stärker bleiben als der aktuelle Headroom-/Reserve-Wunsch.
|
|
2102
|
+
chargeDemandHardCapW = Math.max(0, wantW);
|
|
2103
|
+
chargeDemandHardCapReason = 'Notstrom-Reserve-Lade-Cap';
|
|
2104
|
+
|
|
1976
2105
|
if (wantW > 0) {
|
|
1977
2106
|
targetW = -wantW;
|
|
1978
2107
|
reason = 'Notstrom: Reserve über Netz laden';
|
|
@@ -2001,8 +2130,7 @@ if (targetW === 0 && selfDischargeEnabled) {
|
|
|
2001
2130
|
if (
|
|
2002
2131
|
targetW === 0 &&
|
|
2003
2132
|
peakEnabled &&
|
|
2004
|
-
|
|
2005
|
-
(cfg.lskChargeEnabled !== false) &&
|
|
2133
|
+
lskChargeEnabledCfg &&
|
|
2006
2134
|
(typeof psHeadroomEffW === 'number' && psHeadroomEffW > 0) &&
|
|
2007
2135
|
(gridW >= 0)
|
|
2008
2136
|
) {
|
|
@@ -2059,6 +2187,11 @@ if (targetW === 0 && selfDischargeEnabled) {
|
|
|
2059
2187
|
|
|
2060
2188
|
wantW = (typeof this._lskRefillHoldW === 'number') ? this._lskRefillHoldW : wantW;
|
|
2061
2189
|
|
|
2190
|
+
// Lade-Cap 0.8.80: Auch LSK-Refill darf nach der Rampe nicht über dem
|
|
2191
|
+
// aktuellen Peak-/Import-Headroom weiterlaufen.
|
|
2192
|
+
chargeDemandHardCapW = Math.max(0, wantW);
|
|
2193
|
+
chargeDemandHardCapReason = 'LSK-Refill-Lade-Cap';
|
|
2194
|
+
|
|
2062
2195
|
if (wantW > 0) {
|
|
2063
2196
|
targetW = -wantW;
|
|
2064
2197
|
reason = `LSK: Reserve über Netz nachladen (${Math.round(psHeadroomEffW)} W frei)`;
|
|
@@ -2074,8 +2207,7 @@ if (targetW === 0 && selfDischargeEnabled) {
|
|
|
2074
2207
|
if (
|
|
2075
2208
|
targetW === 0 &&
|
|
2076
2209
|
peakEnabled &&
|
|
2077
|
-
|
|
2078
|
-
(cfg.lskChargeEnabled !== false) &&
|
|
2210
|
+
lskChargeEnabledCfg &&
|
|
2079
2211
|
(gridW >= 0) &&
|
|
2080
2212
|
(typeof soc === 'number') && (this._socLskRefillEnabled === true)
|
|
2081
2213
|
) {
|
|
@@ -2190,8 +2322,13 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
|
|
|
2190
2322
|
{
|
|
2191
2323
|
const d = targetW - _prevRampW;
|
|
2192
2324
|
|
|
2193
|
-
//
|
|
2194
|
-
|
|
2325
|
+
// Lade-Sicherheitsrücknahme: Wenn ein Speicher im letzten Tick geladen hat
|
|
2326
|
+
// (negativer Sollwert) und die aktuelle Policy weniger laden oder auf 0 gehen will,
|
|
2327
|
+
// darf die Standardrampe den alten Lade-Sollwert nicht künstlich halten.
|
|
2328
|
+
// Das ist sicherheitsrelevant für PV-Wolken, wegfallenden Netz-Headroom und EV-Priorität.
|
|
2329
|
+
if (_prevRampW < 0 && targetW >= _prevRampW) {
|
|
2330
|
+
// Weniger laden / Richtung 0 -> bewusst ohne Rampe.
|
|
2331
|
+
} else if (source === 'pv' && targetW < 0) {
|
|
2195
2332
|
const pvMaxDelta = (pvMaxDeltaCfg > 0) ? pvMaxDeltaCfg : maxDelta;
|
|
2196
2333
|
|
|
2197
2334
|
if (pvMaxDelta > 0 && d < 0 && Math.abs(d) > pvMaxDelta) {
|
|
@@ -2223,6 +2360,33 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
|
|
|
2223
2360
|
|
|
2224
2361
|
const _rampW = targetW;
|
|
2225
2362
|
|
|
2363
|
+
// Harte Lade-Cap NACH der Rampenbegrenzung.
|
|
2364
|
+
// Der Entlade-Feldfix aus 0.8.79 braucht die gleiche Absicherung für negative
|
|
2365
|
+
// Ladesollwerte: Wenn die aktuelle Policy 0 W oder weniger Ladeleistung fordert,
|
|
2366
|
+
// darf ein alter Lade-Sollwert nicht langsam über die Standardrampe auslaufen.
|
|
2367
|
+
if (targetW < 0 || (_prevRampW < 0 && _reqW >= 0)) {
|
|
2368
|
+
let capW = (typeof chargeDemandHardCapW === 'number' && Number.isFinite(chargeDemandHardCapW))
|
|
2369
|
+
? Math.max(0, chargeDemandHardCapW)
|
|
2370
|
+
: null;
|
|
2371
|
+
if (_reqW >= 0) {
|
|
2372
|
+
// Keine aktuelle Ladeanforderung: 0 W stoppt die Laderichtung sofort.
|
|
2373
|
+
capW = 0;
|
|
2374
|
+
if (!chargeDemandHardCapReason) chargeDemandHardCapReason = 'Keine aktuelle Ladeanforderung';
|
|
2375
|
+
} else if (capW === null && _reqW < 0) {
|
|
2376
|
+
// Fallback: Aktueller Policy-Wunsch ist die Obergrenze. Dadurch kann die
|
|
2377
|
+
// Rampe einen alten höheren Ladesollwert nicht über den neuen Wunsch ziehen.
|
|
2378
|
+
capW = Math.max(0, -_reqW);
|
|
2379
|
+
chargeDemandHardCapReason = 'Aktuelle Ladeanforderung-Cap';
|
|
2380
|
+
}
|
|
2381
|
+
if (typeof capW === 'number' && targetW < -capW) {
|
|
2382
|
+
targetW = -capW;
|
|
2383
|
+
reason = `${reason} (Lade-Cap ${Math.round(capW)} W nach Rampe)`;
|
|
2384
|
+
}
|
|
2385
|
+
}
|
|
2386
|
+
await this._setIfChanged('speicher.regelung.chargeDemandCapW',
|
|
2387
|
+
(typeof chargeDemandHardCapW === 'number' && Number.isFinite(chargeDemandHardCapW)) ? Math.round(chargeDemandHardCapW) : 0);
|
|
2388
|
+
await this._setIfChanged('speicher.regelung.chargeDemandCapReason', String(chargeDemandHardCapReason || ''));
|
|
2389
|
+
|
|
2226
2390
|
// Harte Demand-Cap NACH der Rampenbegrenzung.
|
|
2227
2391
|
// Der vorherige Code konnte einen korrekt auf ca. Netzbezug begrenzten Sollwert
|
|
2228
2392
|
// durch die Rampe wieder in Richtung altem, zu hohem Sollwert ziehen. Beispiel aus
|
|
@@ -2231,7 +2395,8 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
|
|
|
2231
2395
|
// NVP-basierte Entladequellen.
|
|
2232
2396
|
if (targetW > 0 && typeof dischargeDemandHardCapW === 'number' && Number.isFinite(dischargeDemandHardCapW)) {
|
|
2233
2397
|
const capW = Math.max(0, dischargeDemandHardCapW);
|
|
2234
|
-
|
|
2398
|
+
const activeNvpDischargeSource = (source === 'eigenverbrauch' || source === 'tarif' || source === 'fenecon' || source === 'lastspitze');
|
|
2399
|
+
if (activeNvpDischargeSource && targetW > capW) {
|
|
2235
2400
|
targetW = capW;
|
|
2236
2401
|
reason = `${reason} (Demand-Cap ${Math.round(capW)} W nach Rampe)`;
|
|
2237
2402
|
}
|
|
@@ -2409,11 +2574,14 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
|
|
|
2409
2574
|
importHeadroomW: (typeof importHeadroomEffW === 'number' && Number.isFinite(importHeadroomEffW)) ? Math.round(importHeadroomEffW) : null,
|
|
2410
2575
|
},
|
|
2411
2576
|
appPolicy: {
|
|
2412
|
-
mode: multiUsePolicyActive ? 'multiuse' : '
|
|
2577
|
+
mode: multiUsePolicyActive ? 'multiuse' : 'eigenverbrauch',
|
|
2413
2578
|
storageControlActive: !!cfgEnabled,
|
|
2579
|
+
autoTariffActive: !!autoTarifEnabled,
|
|
2414
2580
|
multiUseActive: !!multiUsePolicyActive,
|
|
2415
2581
|
inactiveMultiUseZonesIgnored: !!ignoreStaleMultiUsePolicy,
|
|
2582
|
+
pureSelfConsumptionWithoutMultiUse: !multiUsePolicyActive,
|
|
2416
2583
|
storageFarmDistribution: !!hasFarmSetpoints,
|
|
2584
|
+
storageFarmAutoStart: false,
|
|
2417
2585
|
},
|
|
2418
2586
|
reserve: {
|
|
2419
2587
|
active: !!reserveActive,
|
|
@@ -3079,6 +3247,7 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
|
|
|
3079
3247
|
await mk('speicher.regelung.aktiv', 'Speicher-Regelung aktiv (effektiv)', 'boolean', 'indicator', false);
|
|
3080
3248
|
await mk('speicher.regelung.aktivKonfig', 'Speicher-Regelung aktiv (Konfiguration)', 'boolean', 'indicator', false);
|
|
3081
3249
|
await mk('speicher.regelung.aktivAutoTarif', 'Auto-Aktivierung durch Tarif', 'boolean', 'indicator', false);
|
|
3250
|
+
await mk('speicher.regelung.aktivAutoMultiUse', 'Auto-Aktivierung durch MultiUse-Policy', 'boolean', 'indicator', false);
|
|
3082
3251
|
await mk('speicher.regelung.aktivSpeicherfarm', 'Speicherfarm-Verteilpfad verfügbar', 'boolean', 'indicator', false);
|
|
3083
3252
|
await mk('speicher.regelung.aktivAutoSpeicherfarm', 'Auto-Aktivierung durch Speicherfarm (deaktiviert)', 'boolean', 'indicator', false);
|
|
3084
3253
|
|
|
@@ -3104,6 +3273,8 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
|
|
|
3104
3273
|
await mk('speicher.regelung.batteryPowerIgnoredReason', 'Ignorierte Ist-Leistung Grund', 'string', 'text', '');
|
|
3105
3274
|
await mk('speicher.regelung.dischargeDemandCapW', 'Entlade-Demand-Cap nach Netzbezug (W)', 'number', 'value.power', 0);
|
|
3106
3275
|
await mk('speicher.regelung.dischargeDemandCapReason', 'Entlade-Demand-Cap Grund', 'string', 'text', '');
|
|
3276
|
+
await mk('speicher.regelung.chargeDemandCapW', 'Lade-Demand-Cap nach Headroom/PV (W)', 'number', 'value.power', 0);
|
|
3277
|
+
await mk('speicher.regelung.chargeDemandCapReason', 'Lade-Demand-Cap Grund', 'string', 'text', '');
|
|
3107
3278
|
|
|
3108
3279
|
await mk('speicher.regelung.feneconGridAktiv', 'Legacy Netzpunktführung aktiv (nicht genutzt)', 'boolean', 'indicator', false);
|
|
3109
3280
|
await mk('speicher.regelung.feneconGridSollW', 'Legacy Netzpunkt-Sollwert (nicht genutzt)', 'number', 'value.power', 0);
|
|
@@ -3154,12 +3325,16 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
|
|
|
3154
3325
|
|
|
3155
3326
|
await mk('speicher.regelung.lskMinSocPct', 'LSK Min-SoC (%)', 'number', 'value', 0);
|
|
3156
3327
|
await mk('speicher.regelung.lskMaxSocPct', 'LSK Max-SoC (%)', 'number', 'value', 0);
|
|
3328
|
+
await mk('speicher.regelung.lskPolicyAktiv', 'LSK-Policy aktiv', 'boolean', 'indicator', false);
|
|
3329
|
+
await mk('speicher.regelung.lskEntladenAktiviert', 'LSK-Entladen aktiviert', 'boolean', 'indicator', false);
|
|
3330
|
+
await mk('speicher.regelung.lskLadenAktiviert', 'LSK-Laden aktiviert', 'boolean', 'indicator', false);
|
|
3157
3331
|
await mk('speicher.regelung.selfMinSocPct', 'Eigenverbrauch Min-SoC (%)', 'number', 'value', 0);
|
|
3158
3332
|
await mk('speicher.regelung.selfMaxSocPct', 'Eigenverbrauch Max-SoC (%)', 'number', 'value', 0);
|
|
3159
3333
|
await mk('speicher.regelung.selfTargetGridImportW', 'Eigenverbrauch Ziel-Netzbezug (W)', 'number', 'value.power', 0);
|
|
3160
3334
|
await mk('speicher.regelung.selfImportThresholdW', 'Eigenverbrauch Deadband (W)', 'number', 'value.power', 0);
|
|
3161
3335
|
await mk('speicher.regelung.selfEntladenAktiviert', 'Eigenverbrauch-Entladen aktiviert', 'boolean', 'indicator', false);
|
|
3162
|
-
await mk('speicher.regelung.policyMode', 'Speicher-Policy-Modus', 'string', 'text', '
|
|
3336
|
+
await mk('speicher.regelung.policyMode', 'Speicher-Policy-Modus', 'string', 'text', 'eigenverbrauch');
|
|
3337
|
+
await mk('speicher.regelung.policyLayerStorageOnly', 'Policy-Schicht reine Eigenverbrauchsoptimierung', 'boolean', 'indicator', true);
|
|
3163
3338
|
await mk('speicher.regelung.multiUsePolicyActive', 'MultiUse-Policy aktiv', 'boolean', 'indicator', false);
|
|
3164
3339
|
await mk('speicher.regelung.multiUsePolicyIgnored', 'Inaktive MultiUse-Policy ignoriert', 'boolean', 'indicator', false);
|
|
3165
3340
|
|
package/io-package.json
CHANGED
|
@@ -1,8 +1,20 @@
|
|
|
1
1
|
{
|
|
2
2
|
"common": {
|
|
3
3
|
"name": "nexowatt-ui",
|
|
4
|
-
"version": "0.8.
|
|
4
|
+
"version": "0.8.81",
|
|
5
5
|
"news": {
|
|
6
|
+
"0.8.81": {
|
|
7
|
+
"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.",
|
|
8
|
+
"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."
|
|
9
|
+
},
|
|
10
|
+
"0.8.80": {
|
|
11
|
+
"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.",
|
|
12
|
+
"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."
|
|
13
|
+
},
|
|
14
|
+
"0.8.79": {
|
|
15
|
+
"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.",
|
|
16
|
+
"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."
|
|
17
|
+
},
|
|
6
18
|
"0.8.78": {
|
|
7
19
|
"de": "Version 0.8.78: Korrigiert die Speicher-App-Trennung. Speicherregelung steuert wieder die normale Eigenverbrauchsoptimierung, MultiUse greift nur aktiv als SoC-Zonen-Policy, Speicherfarm verteilt nur Sollwerte und 0-W-Farm-Limits sperren wieder bewusst die jeweilige Richtung.",
|
|
8
20
|
"en": "Version 0.8.78: Fixes storage app separation. Storage control again handles normal self-consumption optimization, MultiUse only applies as an active SoC-zone policy, the storage farm only distributes setpoints, and 0-W farm limits intentionally block the respective direction again."
|
|
@@ -18,18 +30,6 @@
|
|
|
18
30
|
"0.8.75": {
|
|
19
31
|
"de": "Version 0.8.75: Entfernt den Passwortschutz aus dem Kunden-/LIVE-Frontend. Schnellsteuerung, EVCS, SmartHome, RFID und Kundeneinstellungen sind ohne Admin-/Installer-Login bedienbar; App-Center, Simulation, Mapping und Lizenz bleiben geschützt.",
|
|
20
32
|
"en": "Version 0.8.75: Removes the password gate from the customer/LIVE frontend. Quick controls, EVCS, SmartHome, RFID and customer settings are operable without admin/installer login; App Center, simulation, mapping and license remain protected."
|
|
21
|
-
},
|
|
22
|
-
"0.8.74": {
|
|
23
|
-
"de": "Version 0.8.74: History-Verbraucherfarben stärker getrennt. Speicherfarm erscheint im Kundenmenü nur, wenn die App im App-Center aktiv ist und eine echte Farm-Konfiguration vorhanden ist.",
|
|
24
|
-
"en": "Version 0.8.74: History extra-consumer colors are more distinct. Storage Farm appears in the customer menu only when the app is active in the App Center and a real farm configuration exists."
|
|
25
|
-
},
|
|
26
|
-
"0.8.73": {
|
|
27
|
-
"de": "Version 0.8.73: EVCS-Kacheln flackern beim Hover nicht mehr. Hover bleibt auf der Ladepunktseite neutral; grüne Umrandung/Leuchten erscheint nur bei echter aktiver Ladung.",
|
|
28
|
-
"en": "Version 0.8.73: EVCS tiles no longer flicker on hover. Hover remains neutral on the chargepoint page; green border/glow is shown only for real active charging."
|
|
29
|
-
},
|
|
30
|
-
"0.8.72": {
|
|
31
|
-
"de": "Version 0.8.72: App-Center-Heizstab-Eingaben stabilisiert. Stufenwerte lösen beim Tippen keinen vollständigen Rebuild mehr aus; notwendige Strukturänderungen erhalten Scrollposition und Fokus.",
|
|
32
|
-
"en": "Version 0.8.72: Stabilizes App Center heating-rod inputs. Stage values no longer trigger a full rebuild while typing; required structural updates preserve scroll position and focus."
|
|
33
33
|
}
|
|
34
34
|
},
|
|
35
35
|
"title": "NexoWatt UI",
|
package/main.js
CHANGED
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
* AUTO-GENERATED RUNTIME FILE - NICHT MANUELL BEARBEITEN.
|
|
3
3
|
*
|
|
4
4
|
* Quelle: src-ts/runtime-executables/main.ts
|
|
5
|
-
* Quell-Hash: sha256:
|
|
5
|
+
* Quell-Hash: sha256:b1d4e1f7d0d1826d1392530c3814badef891097f3ce2ad24d97ae693345f266c
|
|
6
6
|
* Erzeugung: npm run sync:ts-runtime-executables
|
|
7
7
|
*
|
|
8
8
|
* Zweck:
|
|
@@ -5343,6 +5343,31 @@ class NexoWattVis extends utils.Adapter {
|
|
|
5343
5343
|
const hasDischargeSetpoint = !!(setSignedPowerId || setDischargePowerId);
|
|
5344
5344
|
const hasAnySetpoint = !!(setSignedPowerId || setChargePowerId || setDischargePowerId);
|
|
5345
5345
|
|
|
5346
|
+
// Feldschutz 0.8.79: Ist-Leistungs-DPs der Speicherfarm dürfen niemals
|
|
5347
|
+
// auf Steuer-/Sollwert-DPs zeigen. Sonst liest die Farm ihre eigene
|
|
5348
|
+
// dischargePowerW-/powerSetpointW-Vorgabe als echte Entladung zurück;
|
|
5349
|
+
// die NVP-Regelung sieht dann eine künstlich hohe Batterie-Istleistung
|
|
5350
|
+
// und kann bis zu absurden Sollwerten hochintegrieren.
|
|
5351
|
+
const targetPowerIds = [setSignedPowerId, setChargePowerId, setDischargePowerId].filter(Boolean);
|
|
5352
|
+
const looksLikeSetpointPowerId = (id) => {
|
|
5353
|
+
const sid = String(id || '').trim();
|
|
5354
|
+
if (!sid) return false;
|
|
5355
|
+
const lower = sid.toLowerCase();
|
|
5356
|
+
return targetPowerIds.includes(sid) ||
|
|
5357
|
+
lower.includes('.aliases.ctrl.') ||
|
|
5358
|
+
lower.includes('.ctrl.') ||
|
|
5359
|
+
lower.includes('powersetpoint') ||
|
|
5360
|
+
lower.includes('setpoint');
|
|
5361
|
+
};
|
|
5362
|
+
const signedFeedbackUsable = !!signedId && !looksLikeSetpointPowerId(signedId);
|
|
5363
|
+
const chargeFeedbackUsable = !!chgId && !looksLikeSetpointPowerId(chgId);
|
|
5364
|
+
const dischargeFeedbackUsable = !!dchgId && !looksLikeSetpointPowerId(dchgId);
|
|
5365
|
+
const ignoredPowerFeedback = [];
|
|
5366
|
+
if (signedId && !signedFeedbackUsable) ignoredPowerFeedback.push('signedPowerId wirkt wie Sollwert-DP');
|
|
5367
|
+
if (chgId && !chargeFeedbackUsable) ignoredPowerFeedback.push('chargePowerId wirkt wie Sollwert-DP');
|
|
5368
|
+
if (dchgId && !dischargeFeedbackUsable) ignoredPowerFeedback.push('dischargePowerId wirkt wie Sollwert-DP');
|
|
5369
|
+
if (ignoredPowerFeedback.length) status.powerFeedbackIgnoredReason = ignoredPowerFeedback.join('; ');
|
|
5370
|
+
|
|
5346
5371
|
// Ab v0.6.258 sind die Leistungsgrenzen bewusst feste Eingaben in der Farm-Konfiguration.
|
|
5347
5372
|
// Dynamische Max-Leistungs-DPs werden in der harten Dispatch-Logik nicht mehr verwendet,
|
|
5348
5373
|
// damit die Speicherfarm auch mit einfachen Signed-DP-Systemen herstellerneutral läuft.
|
|
@@ -5384,9 +5409,9 @@ class NexoWattVis extends utils.Adapter {
|
|
|
5384
5409
|
};
|
|
5385
5410
|
|
|
5386
5411
|
addBases(socId);
|
|
5387
|
-
addBases(signedId);
|
|
5388
|
-
addBases(chgId);
|
|
5389
|
-
addBases(dchgId);
|
|
5412
|
+
if (signedFeedbackUsable) addBases(signedId);
|
|
5413
|
+
if (chargeFeedbackUsable) addBases(chgId);
|
|
5414
|
+
if (dischargeFeedbackUsable) addBases(dchgId);
|
|
5390
5415
|
addBases(pvId);
|
|
5391
5416
|
addBases(availableId);
|
|
5392
5417
|
addBases(faultId);
|
|
@@ -5460,9 +5485,9 @@ class NexoWattVis extends utils.Adapter {
|
|
|
5460
5485
|
considerTs(stConn);
|
|
5461
5486
|
considerTs(stOff);
|
|
5462
5487
|
considerTs(stErr);
|
|
5463
|
-
if (
|
|
5464
|
-
if (
|
|
5465
|
-
if (
|
|
5488
|
+
if (signedFeedbackUsable) considerTs(await getState(signedId));
|
|
5489
|
+
if (chargeFeedbackUsable) considerTs(await getState(chgId));
|
|
5490
|
+
if (dischargeFeedbackUsable) considerTs(await getState(dchgId));
|
|
5466
5491
|
if (pvId) considerTs(await getState(pvId));
|
|
5467
5492
|
if (availableId) considerTs(await getState(availableId));
|
|
5468
5493
|
if (faultId) considerTs(await getState(faultId));
|
|
@@ -5476,7 +5501,7 @@ class NexoWattVis extends utils.Adapter {
|
|
|
5476
5501
|
// Do we have any feedback values configured/available?
|
|
5477
5502
|
// Setpoint-DPs alone are enough for dispatch, but they are not treated as real feedback.
|
|
5478
5503
|
let hasFeedbackValue = false;
|
|
5479
|
-
for (const id of [signedId, chgId, dchgId, pvId, socId, availableId, faultId, chargeAllowedId, dischargeAllowedId]) {
|
|
5504
|
+
for (const id of [signedFeedbackUsable ? signedId : '', chargeFeedbackUsable ? chgId : '', dischargeFeedbackUsable ? dchgId : '', pvId, socId, availableId, faultId, chargeAllowedId, dischargeAllowedId]) {
|
|
5480
5505
|
if (!id) continue;
|
|
5481
5506
|
const st = await getState(id);
|
|
5482
5507
|
if (st && st.val !== undefined && st.val !== null) { hasFeedbackValue = true; break; }
|
|
@@ -5718,7 +5743,7 @@ class NexoWattVis extends utils.Adapter {
|
|
|
5718
5743
|
|
|
5719
5744
|
let usedSigned = false;
|
|
5720
5745
|
|
|
5721
|
-
if (
|
|
5746
|
+
if (signedFeedbackUsable) {
|
|
5722
5747
|
const v = await readNumber(signedId, 'power', { allowStale: true });
|
|
5723
5748
|
if (Number.isFinite(v)) {
|
|
5724
5749
|
let vv = invSigned ? -v : v;
|
|
@@ -5738,7 +5763,7 @@ class NexoWattVis extends utils.Adapter {
|
|
|
5738
5763
|
}
|
|
5739
5764
|
|
|
5740
5765
|
// Fallback: getrennte Messwerte
|
|
5741
|
-
if (!usedSigned &&
|
|
5766
|
+
if (!usedSigned && chargeFeedbackUsable) {
|
|
5742
5767
|
const v = await readNumber(chgId, 'power', { allowStale: true });
|
|
5743
5768
|
if (Number.isFinite(v)) {
|
|
5744
5769
|
let vv = invChg ? -v : v;
|
|
@@ -5749,7 +5774,7 @@ class NexoWattVis extends utils.Adapter {
|
|
|
5749
5774
|
}
|
|
5750
5775
|
}
|
|
5751
5776
|
|
|
5752
|
-
if (!usedSigned &&
|
|
5777
|
+
if (!usedSigned && dischargeFeedbackUsable) {
|
|
5753
5778
|
const v = await readNumber(dchgId, 'power', { allowStale: true });
|
|
5754
5779
|
if (Number.isFinite(v)) {
|
|
5755
5780
|
let vv = invDchg ? -v : v;
|
|
@@ -5947,25 +5972,24 @@ try {
|
|
|
5947
5972
|
const ic = (this.config && this.config.installerConfig && typeof this.config.installerConfig === 'object') ? this.config.installerConfig : {};
|
|
5948
5973
|
const mu = (ic.storageMultiUse && typeof ic.storageMultiUse === 'object') ? ic.storageMultiUse : null;
|
|
5949
5974
|
const multiUsePolicyActive = !!(this.config && this.config.enableMultiUse && mu && mu.enabled === true);
|
|
5950
|
-
|
|
5951
|
-
|
|
5952
|
-
//
|
|
5953
|
-
//
|
|
5954
|
-
|
|
5955
|
-
const
|
|
5956
|
-
const reserveMin = Number(ignoreInactiveMultiUseZones ? NaN : storageCfg.reserveMinSocPct);
|
|
5975
|
+
// Speicherfarm verteilt nur den fertigen Zielwert. SoC-Floors dürfen deshalb
|
|
5976
|
+
// keine eigene Policy starten: Reserve/LSK gelten nur, wenn MultiUse aktiv führt.
|
|
5977
|
+
// Ist MultiUse deaktiviert, ignoriert die Farm alte MultiUse-Zonen und nutzt für
|
|
5978
|
+
// Eigenverbrauch/Tarif nur den Eigenverbrauchs-Min-SoC der Speicherregelung.
|
|
5979
|
+
const reserveEnabled = multiUsePolicyActive && !!storageCfg.reserveEnabled;
|
|
5980
|
+
const reserveMin = Number(multiUsePolicyActive ? storageCfg.reserveMinSocPct : NaN);
|
|
5957
5981
|
const reserveFloor = (reserveEnabled && Number.isFinite(reserveMin)) ? reserveMin : 0;
|
|
5958
5982
|
|
|
5959
5983
|
const farmEnabled = !!(this.config && this.config.enableStorageFarm);
|
|
5960
5984
|
const hasStoredSelfFlag = (storageCfg.selfDischargeEnabled === true || storageCfg.selfDischargeEnabled === false);
|
|
5961
|
-
const hasEffectiveSelfFlag = hasStoredSelfFlag && !
|
|
5985
|
+
const hasEffectiveSelfFlag = hasStoredSelfFlag && (!mu || multiUsePolicyActive);
|
|
5962
5986
|
const feneconFarmFallback = !!(farmEnabled && storageCfg.feneconAcMode === true && !hasEffectiveSelfFlag);
|
|
5963
5987
|
const selfEnabled = hasEffectiveSelfFlag ? storageCfg.selfDischargeEnabled === true : (feneconFarmFallback || true);
|
|
5964
|
-
const selfMinRaw = Number(
|
|
5988
|
+
const selfMinRaw = Number((multiUsePolicyActive || !mu) ? storageCfg.selfMinSocPct : 20);
|
|
5965
5989
|
const selfFloor = (selfEnabled && Number.isFinite(selfMinRaw)) ? Math.max(0, Math.min(100, selfMinRaw)) : 0;
|
|
5966
5990
|
|
|
5967
|
-
const lskEnabled =
|
|
5968
|
-
const lskMin = Number(
|
|
5991
|
+
const lskEnabled = !!(multiUsePolicyActive && storageCfg.lskDischargeEnabled !== false && storageCfg.lskEnabled !== false);
|
|
5992
|
+
const lskMin = Number(multiUsePolicyActive ? storageCfg.lskMinSocPct : NaN);
|
|
5969
5993
|
const lskFloor = (lskEnabled && Number.isFinite(lskMin)) ? lskMin : 0;
|
|
5970
5994
|
|
|
5971
5995
|
if (src === 'eigenverbrauch' || src === 'evcs' || src === 'tarif') return Math.max(0, Math.min(100, Math.max(reserveFloor, selfFloor)));
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "iobroker.nexowatt-ui",
|
|
3
|
-
"version": "0.8.
|
|
3
|
+
"version": "0.8.81",
|
|
4
4
|
"description": "Responsive NexoWatt EMS visualization adapter.",
|
|
5
5
|
"author": "NexoWatt",
|
|
6
6
|
"license": "UNLICENSED",
|
|
@@ -283,7 +283,14 @@
|
|
|
283
283
|
"test:evcs-online-id-depth": "node scripts/verify-evcs-online-id-depth.js",
|
|
284
284
|
"test:evcs-tile-hover": "node scripts/verify-evcs-tile-hover.js",
|
|
285
285
|
"test:evcs-hover-state": "node scripts/verify-evcs-hover-state.js",
|
|
286
|
-
"test:storage-control-app-separation": "node scripts/verify-storage-control-app-separation.js"
|
|
286
|
+
"test:storage-control-app-separation": "node scripts/verify-storage-control-app-separation.js",
|
|
287
|
+
"test:storage-discharge-demand-cap": "node scripts/verify-storage-discharge-demand-cap.js",
|
|
288
|
+
"test:storage-charge-demand-cap": "node scripts/verify-storage-charge-demand-cap.js",
|
|
289
|
+
"test:storage-policy-core-cleanup": "node scripts/verify-storage-policy-core-cleanup.js",
|
|
290
|
+
"test:storage-control-runtime-scenarios": "node scripts/verify-storage-control-runtime-scenarios.js",
|
|
291
|
+
"test:storage-policy-baseline": "node scripts/verify-storage-policy-baseline.js",
|
|
292
|
+
"test:storage-control-functional-safety": "node scripts/verify-storage-control-functional-safety.js",
|
|
293
|
+
"test:storage-policy-runtime": "node scripts/verify-storage-policy-runtime.js"
|
|
287
294
|
},
|
|
288
295
|
"dependencies": {
|
|
289
296
|
"@iobroker/adapter-core": "^3.4.1",
|
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:37e8b68aef7ce965e71a096594fb27a50aa5752400df9d85b67c0c4a2b0623cd
|
|
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-v383';
|
|
46
46
|
|
|
47
47
|
const OFFLINE_URLS = [
|
|
48
48
|
'./',
|