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.
@@ -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:4d2234db2a1c6d62fe65d90a3934f90c4e63de05764335f660e735b93542b93d
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
- // Effektive Aktivierung bewusst nur über Speicherregelungs-App, Tarif-Automatik
412
- // oder MultiUse (MultiUse setzt enableStorageControl beim Speichern selbst).
413
- // Die Speicherfarm ist hier KEIN eigener Auto-Start mehr: sie ist der Verteil-/
414
- // Schreibpfad, sobald die Speicherregelung oder MultiUse einen Sollwert erzeugt.
415
- // So bleibt die Rollenverteilung sauber:
416
- // - Speicherregelung aktiv => normale Eigenverbrauchsoptimierung erzeugt Sollwerte.
417
- // - MultiUse aktiv => MultiUse schreibt SoC-Zonen und aktiviert die Speicherregelung.
418
- // - Speicherfarm aktiv => verteilt den erzeugten Sollwert auf mehrere Speicher.
419
- const enabled = cfgEnabled || autoTarifEnabled;
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 = (this.adapter && this.adapter.config && this.adapter.config.installerConfig && typeof this.adapter.config.installerConfig === 'object')
1061
- ? this.adapter.config.installerConfig
1062
- : {};
1063
- const storageMultiUseCfg = (installerCfgForMultiUse.storageMultiUse && typeof installerCfgForMultiUse.storageMultiUse === 'object')
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
- // Notstrom-Reserve: harte Untergrenze für Entladen
1071
- const reserveEnabled = ignoreStaleMultiUsePolicy ? false : !!cfg.reserveEnabled;
1072
- const reserveMin = clamp(num(ignoreStaleMultiUsePolicy ? undefined : cfg.reserveMinSocPct, 20), 0, 100);
1073
- const reserveTarget = clamp(num(ignoreStaleMultiUsePolicy ? undefined : cfg.reserveTargetSocPct, reserveMin), 0, 100);
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 (Peak-Shaving über Speicher)
1092
- const lskEnabledCfg = ignoreStaleMultiUsePolicy ? true : (cfg.lskEnabled !== false); // Default: an (damit bestehende Installationen unverändert bleiben)
1093
- const lskMinSoc = clamp(num(ignoreStaleMultiUsePolicy ? undefined : cfg.lskMinSocPct, reserveMin), 0, 100);
1094
- const lskMaxSoc = clamp(num(ignoreStaleMultiUsePolicy ? undefined : cfg.lskMaxSocPct, 100), 0, 100);
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 && !ignoreStaleMultiUsePolicy;
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(ignoreStaleMultiUsePolicy ? undefined : cfg.selfMinSocPct, reserveMin), 0, 100);
1123
- const selfMaxSoc = clamp(num(ignoreStaleMultiUsePolicy ? undefined : cfg.selfMaxSocPct, 100), 0, 100);
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
- const selfTargetGridW = Math.max(0, num(ignoreStaleMultiUsePolicy ? undefined : cfg.selfTargetGridImportW, 50));
1131
- const selfImportThresholdW = Math.max(0, num(ignoreStaleMultiUsePolicy ? undefined : cfg.selfImportThresholdW, 50));
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' : 'speicherregelung');
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 && lskEnabledCfg && (cfg.lskDischargeEnabled !== false)) {
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
- // sofern keine Lastspitzenkappung aktiv ist.
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
- // EVCS-Unterstützung ist "komfort" – wenn Reserve wieder aufgefüllt werden soll, blockieren wir das.
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 (SoC unter Minimum)';
1309
+ reason = 'EVCS-Unterstützung blockiert (MultiUse nicht aktiv; Speicherregelung = Eigenverbrauch pur)';
1265
1310
  source = 'evcs';
1266
1311
  } else {
1267
- targetW = clamp(assistW, 0, maxDischargeW);
1268
- reason = `EVCS-Unterstützung: entladen (${Math.round(assistW)} W angefordert)`;
1269
- source = 'evcs';
1270
- hardDischargeMinSoc = Math.max(hardDischargeMinSoc, Math.max(reserveMinEff, selfMinSoc));
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
- targetW = -Math.max(0, chargeW);
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
- // - der letzte Sollwert (Fallback: inkrementelle Regelung), falls keine Istleistung verfügbar ist.
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
- // Innerhalb der Deadband halten wir aber den letzten Sollwert, statt auf die
1670
- // zeitversetzte Istleistung zu springen.
1671
- // Fallback ohne Ist-Batterieleistung: inkrementelle Regelung (Soll = letzter Sollwert + Fehler).
1672
- // Rampe/Schrittweite/Anti-PingPong folgen im Dispatcher weiter unten.
1673
- let nextSetW = holdInDeadband
1674
- ? curSetW
1675
- : ((typeof battW === 'number') ? (battW + errAdjW) : (curSetW + errAdjW));
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 grob auf aktuelle Hauslast am NVP: Import (roh) + aktuelle Entladung (falls messbar) + Puffer.
1679
- // Bei aktiver Regelung zählt der letzte selbst gesetzte Sollwert als plausible Entladebasis,
1680
- // damit zeitversetzte/0-W-Istwerte die Farm nicht künstlich herunterziehen.
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 maxByDemandW = importRawNowW + dischargeNowW + safetyMarginW;
1687
- if (Number.isFinite(maxByDemandW) && maxByDemandW > 0) {
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
- // Innerhalb der Deadband halten wir den letzten Sollwert statt auf die
1848
- // zeitversetzte Istleistung zu springen.
1849
- // Fallback: letzter Sollwert + Fehler
1850
- let nextSetW = holdInDeadband
1851
- ? curSetW
1852
- : ((typeof battW === 'number') ? (battW + errAdjW) : (curSetW + errAdjW));
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
- // Wenn battW nicht gemappt ist (oder NVP kurzfristig "alt" ist), kann die inkrementelle Regelung
1856
- // zu großen Sollwerten aufintegrieren. Wir begrenzen deshalb die Entladeleistung grob auf
1857
- // "aktuelle Last" am NVP: Import (roh) + aktuelle Entladung (falls messbar) + kleiner Puffer.
1858
- // Dadurch bleibt die Regelung im Bereich der realen Hauslast und erzeugt keine Export-Spikes.
1859
- // Bei aktiver Eigenverbrauchsregelung zählt der letzte selbst gesetzte Sollwert als plausible
1860
- // Entladebasis, damit zeitversetzte/0-W-Istwerte die Farm nicht künstlich herunterziehen.
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 + dischargeNowW + safetyMarginW;
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 = 'Eigenverbrauch-NVP-Demand-Cap';
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 = (cfg.lskChargeEnabled !== false) ? lskMaxSoc : selfMaxSoc;
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
- targetW = -clamp(exportCtrlW + extraBias, 0, chargeLimitW);
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
- lskEnabledCfg &&
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
- lskEnabledCfg &&
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
- // PV-Überschuss-Laden: schneller hochfahren (mehr Laden), aber schnell zurücknehmen (sicher gegen Netzbezug)
2194
- if (source === 'pv' && targetW < 0) {
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
- if ((source === 'eigenverbrauch' || source === 'tarif' || source === 'fenecon') && targetW > capW) {
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' : 'speicherregelung',
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', 'speicherregelung');
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.78",
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:6aa512c54a159430a7268d42c8806a1ca2b711cb2cf17ec845f4406a730b04aa
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 (signedId) considerTs(await getState(signedId));
5464
- if (chgId) considerTs(await getState(chgId));
5465
- if (dchgId) considerTs(await getState(dchgId));
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 (signedId) {
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 && chgId) {
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 && dchgId) {
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
- const ignoreInactiveMultiUseZones = !!(mu && !multiUsePolicyActive);
5951
-
5952
- // Speicherfarm verteilt nur den Zielwert. Die SoC-Floors kommen entweder aus
5953
- // aktiver MultiUse-Policy oder aus normaler Speicherregelung. Ist MultiUse deaktiviert,
5954
- // dürfen alte MultiUse-Floors nicht als zusätzliche Sperre wirken.
5955
- const reserveEnabled = ignoreInactiveMultiUseZones ? false : !!storageCfg.reserveEnabled;
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 && !ignoreInactiveMultiUseZones;
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(ignoreInactiveMultiUseZones ? 20 : storageCfg.selfMinSocPct);
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 = ignoreInactiveMultiUseZones ? true : ((storageCfg.lskDischargeEnabled !== false) && (storageCfg.lskEnabled !== false));
5968
- const lskMin = Number(ignoreInactiveMultiUseZones ? 20 : storageCfg.lskMinSocPct);
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.78",
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",
@@ -44,6 +44,6 @@
44
44
  "purpose": "maskable"
45
45
  }
46
46
  ],
47
- "version": "0.8.78",
48
- "appVersion": "0.8.78"
47
+ "version": "0.8.81",
48
+ "appVersion": "0.8.81"
49
49
  }
package/www/sw.js CHANGED
@@ -2,7 +2,7 @@
2
2
  * AUTO-GENERATED RUNTIME FILE - NICHT MANUELL BEARBEITEN.
3
3
  *
4
4
  * Quelle: src-ts/runtime-executables/www/sw.ts
5
- * Quell-Hash: sha256:450c858958cff245c1b3d728b5ff1b52f959e52c53adab637eca05db8532e30f
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-v379';
45
+ const CACHE_NAME = 'nexowatt-cache-v383';
46
46
 
47
47
  const OFFLINE_URLS = [
48
48
  './',