iobroker.nexowatt-ui 0.8.75 → 0.8.78
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/heating-rod-control.js +108 -33
- package/ems/modules/storage-control.js +65 -13
- package/io-package.json +13 -13
- package/main.js +81 -24
- package/package.json +3 -2
- package/www/app.js +13 -10
- package/www/ems-apps.js +86 -15
- 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/heating-rod-control.ts
|
|
5
|
-
* Quell-Hash: sha256:
|
|
5
|
+
* Quell-Hash: sha256:91ca00f069c17ba10cefec4128b240bd73ba20bb7ef20647f344831da010b4a0
|
|
6
6
|
* Erzeugung: npm run sync:ts-runtime-executables
|
|
7
7
|
*
|
|
8
8
|
* Zweck:
|
|
@@ -169,6 +169,23 @@ function normalizeUserMode(raw) {
|
|
|
169
169
|
if (s === 'off' || s === 'aus' || s === '0') return 'off';
|
|
170
170
|
return 'inherit';
|
|
171
171
|
}
|
|
172
|
+
/**
|
|
173
|
+
* Code-Teil: normalizeHeatingRodAutoMode
|
|
174
|
+
* Zweck: Normalisiert die Betriebsart, die hinter dem einen sichtbaren Auto-Button liegt.
|
|
175
|
+
* Zusammenhang: `pvAuto` bleibt der Kundenmodus im Frontend; diese Auswahl entscheidet intern,
|
|
176
|
+
* ob Auto nach gemessenem PV-Überschuss am NVP oder nach 0-W-Einspeisung/Forecast regelt.
|
|
177
|
+
* TypeScript: Beim späteren Ausbau als Union-Typ `'pvSurplus' | 'zeroExportForecast'` führen.
|
|
178
|
+
*/
|
|
179
|
+
function normalizeHeatingRodAutoMode(raw) {
|
|
180
|
+
const s = String(raw || '').trim().toLowerCase();
|
|
181
|
+
if (s === 'zeroexportforecast' || s === 'zero-export-forecast' || s === 'zero_export_forecast'
|
|
182
|
+
|| s === 'zeroexport' || s === 'zero-export' || s === 'zero_export'
|
|
183
|
+
|| s === 'zerofeedin' || s === 'zero-feed-in' || s === 'zero_feed_in'
|
|
184
|
+
|| s === 'zero' || s === '0w' || s === '0-w' || s === '0_w'
|
|
185
|
+
|| s === '0einspeisung' || s === '0-einspeisung' || s === '0_einspeisung'
|
|
186
|
+
|| s === 'zeroeinspeisung' || s === 'forecast') return 'zeroExportForecast';
|
|
187
|
+
return 'pvSurplus';
|
|
188
|
+
}
|
|
172
189
|
/**
|
|
173
190
|
* Code-Teil: normalizeConsumerType
|
|
174
191
|
* Zweck: Kapselt einen lokalen Verarbeitungsschritt, damit Aufrufer nicht direkt in Detaildaten eingreifen.
|
|
@@ -598,7 +615,7 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
598
615
|
def: 'inherit',
|
|
599
616
|
states: {
|
|
600
617
|
inherit: 'System',
|
|
601
|
-
pvAuto: 'Auto
|
|
618
|
+
pvAuto: 'Auto',
|
|
602
619
|
manual1: 'Manuell Stufe 1',
|
|
603
620
|
manual2: 'Manuell Stufe 2',
|
|
604
621
|
manual3: 'Manuell Stufe 3',
|
|
@@ -669,6 +686,7 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
669
686
|
await mk('heatingRod.summary.tsLegacyFinalCleanupJson', 'TypeScript Heizstab Legacy-JS-Final-Cleanup (JSON)', 'string', 'json');
|
|
670
687
|
await mk('heatingRod.summary.tsLegacyNormalDiagnosticsJson', 'TypeScript Heizstab Legacy-JS-Normaldiagnose entfernt (JSON)', 'string', 'json');
|
|
671
688
|
await mk('heatingRod.summary.legacyJsReferenceJson', 'Heizstab Legacy-JS-Referenzdiagnose Alias (JSON)', 'string', 'json');
|
|
689
|
+
await mk('heatingRod.summary.autoMode', 'Heizstab Auto-Betriebsart', 'string', 'text');
|
|
672
690
|
await mk('heatingRod.summary.zeroExportActive', 'Zero/minus feed-in logic active', 'boolean', 'indicator');
|
|
673
691
|
await mk('heatingRod.summary.zeroExportCanProbe', 'Zero/minus feed-in probe allowed', 'boolean', 'indicator');
|
|
674
692
|
await mk('heatingRod.summary.zeroExportReason', 'Zero/minus feed-in reason', 'string', 'text');
|
|
@@ -735,6 +753,7 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
735
753
|
await mk(`heatingRod.devices.${d.id}.appliedW`, 'Applied power (W)', 'number', 'value.power', 'W');
|
|
736
754
|
await mk(`heatingRod.devices.${d.id}.measuredW`, 'Measured (W)', 'number', 'value.power', 'W');
|
|
737
755
|
await mk(`heatingRod.devices.${d.id}.status`, 'Status', 'string', 'text');
|
|
756
|
+
await mk(`heatingRod.devices.${d.id}.autoMode`, 'Auto-Betriebsart', 'string', 'text');
|
|
738
757
|
await mk(`heatingRod.devices.${d.id}.zeroExportActive`, 'Zero/minus feed-in active', 'boolean', 'indicator');
|
|
739
758
|
await mk(`heatingRod.devices.${d.id}.zeroExportReason`, 'Zero/minus feed-in reason', 'string', 'text');
|
|
740
759
|
await mk(`heatingRod.devices.${d.id}.zeroExportCanProbe`, 'Zero/minus feed-in probe allowed', 'boolean', 'indicator');
|
|
@@ -1397,8 +1416,17 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
1397
1416
|
return Math.round(clamp(def, minV, maxV));
|
|
1398
1417
|
};
|
|
1399
1418
|
|
|
1419
|
+
// Betriebsart des einen Auto-Buttons: neue Konfiguration (`cfg.autoMode`) hat Vorrang.
|
|
1420
|
+
// Alte Installationen mit `zeroExport.enabled=true` werden nur dann automatisch migriert,
|
|
1421
|
+
// wenn noch keine explizite Betriebsart gespeichert wurde. So kann ein späteres Zurückstellen
|
|
1422
|
+
// auf PV-Überschuss nicht durch ein altes Detail-Flag wieder überschrieben werden.
|
|
1423
|
+
const explicitAutoMode = cfg.autoMode ?? cfg.automationMode ?? raw.autoMode ?? raw.mode;
|
|
1424
|
+
const legacyZeroEnabled = !!(raw.enabled || raw.active);
|
|
1425
|
+
const autoMode = normalizeHeatingRodAutoMode(explicitAutoMode || (legacyZeroEnabled ? 'zeroExportForecast' : 'pvSurplus'));
|
|
1426
|
+
|
|
1400
1427
|
return {
|
|
1401
|
-
|
|
1428
|
+
autoMode,
|
|
1429
|
+
enabled: autoMode === 'zeroExportForecast',
|
|
1402
1430
|
feedInLimitW: n(['feedInLimitW', 'allowedExportW', 'exportLimitW'], 1000, 0, 1000000),
|
|
1403
1431
|
feedInToleranceW: n(['feedInToleranceW', 'exportToleranceW'], 150, 0, 100000),
|
|
1404
1432
|
targetExportBufferW: n(['targetExportBufferW', 'exportBufferW'], 100, 0, 100000),
|
|
@@ -1623,7 +1651,7 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
1623
1651
|
_computeZeroExportInfo(pvBase) {
|
|
1624
1652
|
const cfg = this._getZeroExportCfg();
|
|
1625
1653
|
if (!cfg.enabled) {
|
|
1626
|
-
return { active: false, canProbe: false, reason: '
|
|
1654
|
+
return { active: false, canProbe: false, reason: 'auto_mode_pv_surplus', cfg };
|
|
1627
1655
|
}
|
|
1628
1656
|
if (!pvBase || !pvBase.gridKnown) {
|
|
1629
1657
|
return { active: true, canProbe: false, reason: 'grid_unknown', cfg };
|
|
@@ -2323,12 +2351,12 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
2323
2351
|
};
|
|
2324
2352
|
}
|
|
2325
2353
|
|
|
2326
|
-
//
|
|
2327
|
-
//
|
|
2328
|
-
//
|
|
2329
|
-
//
|
|
2330
|
-
if (info && info.active && info.storageReady === false &&
|
|
2331
|
-
const reduceBase = Math.max(currentStage, observedStage);
|
|
2354
|
+
// In der Betriebsart 0-W/Forecast ersetzt diese Strategie den normalen
|
|
2355
|
+
// PV-Überschuss-Start. Speicher-Vorrang reduziert deshalb auch laufende
|
|
2356
|
+
// Auto-Stufen stufenweise, damit der Heizstab keinen Akku leerzieht, wenn
|
|
2357
|
+
// die versteckte PV-Leistung noch nicht belastbar bestätigt ist.
|
|
2358
|
+
if (info && info.active && info.storageReady === false && Math.max(currentStage, observedStage, targetStage) > 0) {
|
|
2359
|
+
const reduceBase = Math.max(currentStage, observedStage, targetStage);
|
|
2332
2360
|
targetStage = Math.min(targetStage, this._previousPhysicalStageBelow(d, reduceBase));
|
|
2333
2361
|
st.zeroCooldownUntilMs = now + Math.max(0, cfg.cooldownSec * 1000);
|
|
2334
2362
|
st.zeroLastStepDownMs = now;
|
|
@@ -2348,6 +2376,30 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
2348
2376
|
};
|
|
2349
2377
|
}
|
|
2350
2378
|
|
|
2379
|
+
// Ohne Netzpunktmessung fehlt der harte 0-W-Schutz. In dieser Situation
|
|
2380
|
+
// hält die 0-W-/Forecast-Betriebsart keine Auto-Stufe fest, sondern reduziert
|
|
2381
|
+
// kontrolliert, bis wieder belastbare NVP-Daten vorliegen.
|
|
2382
|
+
if (info && info.active && String(info.reason || '') === 'grid_unknown' && Math.max(currentStage, observedStage, targetStage) > 0) {
|
|
2383
|
+
const reduceBase = Math.max(currentStage, observedStage, targetStage);
|
|
2384
|
+
targetStage = this._previousPhysicalStageBelow(d, reduceBase);
|
|
2385
|
+
st.zeroCooldownUntilMs = now + Math.max(0, cfg.cooldownSec * 1000);
|
|
2386
|
+
st.zeroLastStepDownMs = now;
|
|
2387
|
+
st.lastDecreaseMs = now;
|
|
2388
|
+
st.zeroProbe = null;
|
|
2389
|
+
st.targetStage = targetStage;
|
|
2390
|
+
reason = 'grid_unknown_reduce';
|
|
2391
|
+
this._stageCtl.set(d.id, st);
|
|
2392
|
+
return {
|
|
2393
|
+
targetStage,
|
|
2394
|
+
reduceNow: true,
|
|
2395
|
+
hardOff: false,
|
|
2396
|
+
reason,
|
|
2397
|
+
importHoldMs,
|
|
2398
|
+
dischargeHoldMs,
|
|
2399
|
+
nextAllowedAt: st.zeroCooldownUntilMs || 0,
|
|
2400
|
+
};
|
|
2401
|
+
}
|
|
2402
|
+
|
|
2351
2403
|
const probe = (st.zeroProbe && typeof st.zeroProbe === 'object') ? st.zeroProbe : null;
|
|
2352
2404
|
if (probe) {
|
|
2353
2405
|
const probeStage = Math.max(0, Math.min(Math.round(Number(probe.stage) || 0), d.stageCount));
|
|
@@ -3917,6 +3969,13 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
3917
3969
|
...extra,
|
|
3918
3970
|
};
|
|
3919
3971
|
};
|
|
3972
|
+
// Der TS-Spiegel modelliert den normalen PV-/Budgetpfad. Die 0-W-/Forecast-
|
|
3973
|
+
// Strategie arbeitet bewusst mit Probe-Stufen und Live-Netzpunktwächter und
|
|
3974
|
+
// bleibt deshalb hier JS-autoritativer Pfad, damit TS den Probe-Zielwert nicht
|
|
3975
|
+
// mit einem klassischen Überschussziel überschreibt.
|
|
3976
|
+
if (entry && entry.zeroExportActive) {
|
|
3977
|
+
return fallback('zero-export-forecast-js-strategy', { zeroExportActive: true });
|
|
3978
|
+
}
|
|
3920
3979
|
if (!evaluate) return fallback('missing-ts-mirror');
|
|
3921
3980
|
try {
|
|
3922
3981
|
const d = entry && entry.device || {};
|
|
@@ -4071,6 +4130,10 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
4071
4130
|
const pvBase = this._computeBasePvAvailableW(currentAutoHeatingRodW);
|
|
4072
4131
|
const budgetProtection = this._updateBudgetGateProtection(pvBase, now);
|
|
4073
4132
|
const zeroExportInfo = this._computeZeroExportInfo(pvBase);
|
|
4133
|
+
// Diese Betriebsart bestimmt nur die interne Auto-Strategie. Im Kunden-UI bleibt
|
|
4134
|
+
// weiterhin genau ein Auto-Button (`pvAuto`) sichtbar.
|
|
4135
|
+
const heatingRodAutoMode = normalizeHeatingRodAutoMode(zeroExportInfo && zeroExportInfo.cfg && zeroExportInfo.cfg.autoMode);
|
|
4136
|
+
const zeroExportStrategyActive = heatingRodAutoMode === 'zeroExportForecast' && !!zeroExportInfo.active;
|
|
4074
4137
|
const minPvAutomationW = this._getPvAutomationMinW();
|
|
4075
4138
|
const pvNowForAutomationW = this._readPvNowW(staleMs);
|
|
4076
4139
|
const pvAutomationAllowedByMin = minPvAutomationW <= 0 || pvNowForAutomationW >= minPvAutomationW;
|
|
@@ -4100,8 +4163,9 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
4100
4163
|
await this._setStateIfChanged(`heatingRod.devices.${d.id}.maxPowerW`, Math.round(num(d.maxPowerW, 0)));
|
|
4101
4164
|
await this._setStateIfChanged(`heatingRod.devices.${d.id}.stageCount`, d.stageCount);
|
|
4102
4165
|
await this._setStateIfChanged(`heatingRod.devices.${d.id}.wiredStages`, d.wiredStages);
|
|
4103
|
-
await this._setStateIfChanged(`heatingRod.devices.${d.id}.
|
|
4104
|
-
await this._setStateIfChanged(`heatingRod.devices.${d.id}.
|
|
4166
|
+
await this._setStateIfChanged(`heatingRod.devices.${d.id}.autoMode`, heatingRodAutoMode);
|
|
4167
|
+
await this._setStateIfChanged(`heatingRod.devices.${d.id}.zeroExportActive`, !!zeroExportStrategyActive);
|
|
4168
|
+
await this._setStateIfChanged(`heatingRod.devices.${d.id}.zeroExportCanProbe`, !!(zeroExportStrategyActive && zeroExportInfo.canProbe));
|
|
4105
4169
|
await this._setStateIfChanged(`heatingRod.devices.${d.id}.zeroExportReason`, String(zeroExportInfo.reason || ''));
|
|
4106
4170
|
await this._setStateIfChanged(`heatingRod.devices.${d.id}.zeroExportNextAllowedAt`, Math.round(num((this._stageCtl.get(d.id) || {}).zeroCooldownUntilMs, 0)));
|
|
4107
4171
|
|
|
@@ -4322,27 +4386,32 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
4322
4386
|
continue;
|
|
4323
4387
|
}
|
|
4324
4388
|
|
|
4325
|
-
let desiredStage =
|
|
4389
|
+
let desiredStage = 0;
|
|
4326
4390
|
let zeroDecision = null;
|
|
4327
|
-
let budgetDecision =
|
|
4328
|
-
|
|
4329
|
-
//
|
|
4330
|
-
//
|
|
4331
|
-
//
|
|
4332
|
-
|
|
4333
|
-
|
|
4334
|
-
|
|
4391
|
+
let budgetDecision = null;
|
|
4392
|
+
// Die globale Betriebsart ersetzt nur den Algorithmus hinter `pvAuto`;
|
|
4393
|
+
// die Kundenbedienung bleibt ein einzelner Auto-Button. Im 0-W-/Forecast-Modus
|
|
4394
|
+
// darf der sichtbare NVP-Überschuss NICHT als Startbudget dienen, weil WR/Speicher
|
|
4395
|
+
// ihn bei 0-Einspeisung absichtlich auf 0 W halten.
|
|
4396
|
+
if (zeroExportStrategyActive) {
|
|
4397
|
+
const st = this._ensureStageCtlState(d.id, observedStage);
|
|
4398
|
+
desiredStage = Math.max(0, Math.min(Math.round(Number(st.targetStage ?? observedStage) || 0), d.stageCount));
|
|
4399
|
+
budgetDecision = { targetStage: desiredStage, reduceNow: false, hardOff: false, reason: 'zero_export_replaces_pv_surplus' };
|
|
4335
4400
|
zeroDecision = this._applyZeroExportStageStrategy(d, desiredStage, observedStage, pvBase, zeroExportInfo, now, measuredW);
|
|
4336
4401
|
desiredStage = Math.max(0, Math.min(num(zeroDecision.targetStage, desiredStage), d.stageCount));
|
|
4337
4402
|
await this._setStateIfChanged(`heatingRod.devices.${d.id}.zeroExportReason`, String(zeroDecision.reason || zeroExportInfo.reason || ''));
|
|
4338
4403
|
await this._setStateIfChanged(`heatingRod.devices.${d.id}.zeroExportNextAllowedAt`, Math.round(num(zeroDecision.nextAllowedAt, 0)));
|
|
4404
|
+
} else {
|
|
4405
|
+
desiredStage = this._computeDesiredStage(d, remainingW, observedStage, measuredW);
|
|
4406
|
+
budgetDecision = this._applyBudgetFollowerStageStrategy(d, desiredStage, observedStage, pvBase, budgetProtection, now, !pvMinBlocksStepUp);
|
|
4407
|
+
desiredStage = Math.max(0, Math.min(num(budgetDecision.targetStage, desiredStage), d.stageCount));
|
|
4339
4408
|
}
|
|
4340
4409
|
|
|
4341
4410
|
// Reiner PV-Betrieb: bei Netzbezug oder Speicherentladung keine Stufe halten
|
|
4342
4411
|
// oder neu zuschalten. Bei aktivem 0-Einspeise-Sondermodus werden kurze Transienten
|
|
4343
4412
|
// nicht sofort gekillt, sondern erst nach den konfigurierten Schutzzeiten.
|
|
4344
4413
|
let forceNonPvDown = !!((budgetDecision && budgetDecision.reduceNow) || (budgetProtection && budgetProtection.reduceNow));
|
|
4345
|
-
if (
|
|
4414
|
+
if (zeroExportStrategyActive) forceNonPvDown = !!(forceNonPvDown || (zeroDecision && zeroDecision.reduceNow));
|
|
4346
4415
|
if (forceNonPvDown) {
|
|
4347
4416
|
// Reduce to the next lower *physical* actuator set. This is important for
|
|
4348
4417
|
// installations that accidentally map several virtual stages to the same KNX/relay
|
|
@@ -4354,7 +4423,7 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
4354
4423
|
desiredStage = Math.min(desiredStage, lowerPhysicalStage);
|
|
4355
4424
|
}
|
|
4356
4425
|
|
|
4357
|
-
const forceStorageProtectOff = !!(pvBase.forceOff && desiredStage <= 0 && !(
|
|
4426
|
+
const forceStorageProtectOff = !!(pvBase.forceOff && desiredStage <= 0 && !(zeroExportStrategyActive && zeroDecision && !zeroDecision.reduceNow));
|
|
4358
4427
|
let targetStage = forceStorageProtectOff
|
|
4359
4428
|
? 0
|
|
4360
4429
|
: (forceNonPvDown ? desiredStage : this._applyTiming(d, desiredStage, observedStage));
|
|
@@ -4367,7 +4436,8 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
4367
4436
|
deviceId: d.id,
|
|
4368
4437
|
jsTargetStage: jsTargetStageBeforeTs,
|
|
4369
4438
|
jsTargetW: jsTargetWBeforeTs,
|
|
4370
|
-
jsStatus: forceStorageProtectOff ? 'storage_protect' : (forceNonPvDown ? 'pv_only_protect' : 'pv_auto'),
|
|
4439
|
+
jsStatus: zeroExportStrategyActive ? 'zero_export_forecast_auto' : (forceStorageProtectOff ? 'storage_protect' : (forceNonPvDown ? 'pv_only_protect' : 'pv_auto')),
|
|
4440
|
+
zeroExportActive: !!zeroExportStrategyActive,
|
|
4371
4441
|
effectiveMode,
|
|
4372
4442
|
availablePvW: Math.max(0, Number(pvBase && pvBase.availableW) || 0),
|
|
4373
4443
|
availableTotalW: pvBase && pvBase.budgetGateEffectiveW !== null && pvBase.budgetGateEffectiveW !== undefined ? Math.max(0, Number(pvBase.budgetGateEffectiveW) || 0) : Math.max(0, Number(pvBase && pvBase.availableW) || 0),
|
|
@@ -4419,7 +4489,7 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
4419
4489
|
const forcePvWrite = !!(forceStorageProtectOff || forceNonPvDown || (targetStage <= 0 && mayWriteOff && offWouldTouchLoad));
|
|
4420
4490
|
const res = await this._applyStageState(d, targetStage, feedback, { force: forcePvWrite });
|
|
4421
4491
|
const effectiveTargetStage = Math.max(0, Math.min(num(res.targetStage, targetStage), d.wiredStages));
|
|
4422
|
-
this._markAutoOwnership(d, effectiveTargetStage > 0, effectiveTargetStage, 'pvAuto');
|
|
4492
|
+
this._markAutoOwnership(d, effectiveTargetStage > 0, effectiveTargetStage, zeroExportStrategyActive ? 'zeroExportForecast' : 'pvAuto');
|
|
4423
4493
|
const targetW = this._sumStagePowerModel(d, effectiveTargetStage, observedStage, measuredW);
|
|
4424
4494
|
const measuredUsedW = (typeof measuredW === 'number' && Number.isFinite(measuredW) && measuredW > 0)
|
|
4425
4495
|
? Math.max(0, measuredW)
|
|
@@ -4593,7 +4663,10 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
4593
4663
|
pvReserveW: tariffImportPreferred ? 0 : used,
|
|
4594
4664
|
actualW: Math.max(0, Math.round(currentHeatingRodW || appliedTotalW || used || 0)),
|
|
4595
4665
|
pvOnly: !tariffImportPreferred,
|
|
4596
|
-
|
|
4666
|
+
// Budget-Diagnose: bei gleichem Frontend-Auto-Button sichtbar machen,
|
|
4667
|
+
// ob der Heizstab gerade klassisch nach NVP-Überschuss oder per
|
|
4668
|
+
// 0-W-/Forecast-Strategie geführt wird.
|
|
4669
|
+
mode: tariffImportPreferred ? 'tariffNegative' : (zeroExportStrategyActive ? 'zeroExportForecast' : 'pvAuto'),
|
|
4597
4670
|
});
|
|
4598
4671
|
}
|
|
4599
4672
|
} catch (_e) {
|
|
@@ -4620,12 +4693,13 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
4620
4693
|
await this._setStateIfChanged('heatingRod.summary.gridImportLimitW', Math.round(num(pvBase.importToleranceW, 0)));
|
|
4621
4694
|
await this._setStateIfChanged('heatingRod.summary.gridImportExceeded', !!(budgetProtection && budgetProtection.importActive));
|
|
4622
4695
|
await this._setStateIfChanged('heatingRod.summary.storageDischargeExceeded', !!(budgetProtection && budgetProtection.dischargeActive));
|
|
4623
|
-
await this._setStateIfChanged('heatingRod.summary.
|
|
4624
|
-
await this._setStateIfChanged('heatingRod.summary.
|
|
4696
|
+
await this._setStateIfChanged('heatingRod.summary.autoMode', heatingRodAutoMode);
|
|
4697
|
+
await this._setStateIfChanged('heatingRod.summary.zeroExportActive', !!zeroExportStrategyActive);
|
|
4698
|
+
await this._setStateIfChanged('heatingRod.summary.zeroExportCanProbe', !!(zeroExportStrategyActive && zeroExportInfo.canProbe));
|
|
4625
4699
|
await this._setStateIfChanged('heatingRod.summary.zeroExportReason', String(zeroExportInfo.reason || ''));
|
|
4626
4700
|
await this._setStateIfChanged('heatingRod.summary.zeroExportPvNowW', Math.round(num(zeroExportInfo.pvNowW, 0)));
|
|
4627
|
-
await this._setStateIfChanged('heatingRod.summary.zeroExportForecastOk', !!zeroExportInfo.forecastOk);
|
|
4628
|
-
await this._setStateIfChanged('heatingRod.summary.zeroExportFeedInAtLimit', !!zeroExportInfo.feedInAtLimit);
|
|
4701
|
+
await this._setStateIfChanged('heatingRod.summary.zeroExportForecastOk', !!(zeroExportStrategyActive && zeroExportInfo.forecastOk));
|
|
4702
|
+
await this._setStateIfChanged('heatingRod.summary.zeroExportFeedInAtLimit', !!(zeroExportStrategyActive && zeroExportInfo.feedInAtLimit));
|
|
4629
4703
|
await this._setStateIfChanged('heatingRod.summary.pvAutomationMinW', Math.round(num(minPvAutomationW, 0)));
|
|
4630
4704
|
await this._setStateIfChanged('heatingRod.summary.pvAutomationPvNowW', Math.round(num(pvNowForAutomationW, 0)));
|
|
4631
4705
|
await this._setStateIfChanged('heatingRod.summary.pvAutomationAllowed', !!pvAutomationAllowedByMin);
|
|
@@ -4712,8 +4786,9 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
4712
4786
|
protection: budgetProtection || null,
|
|
4713
4787
|
},
|
|
4714
4788
|
zeroExport: {
|
|
4715
|
-
|
|
4716
|
-
|
|
4789
|
+
autoMode: heatingRodAutoMode,
|
|
4790
|
+
active: !!zeroExportStrategyActive,
|
|
4791
|
+
canProbe: !!(zeroExportStrategyActive && zeroExportInfo.canProbe),
|
|
4717
4792
|
reason: zeroExportInfo.reason,
|
|
4718
4793
|
pvNowW: Math.round(num(zeroExportInfo.pvNowW, 0)),
|
|
4719
4794
|
feedInAtLimit: !!zeroExportInfo.feedInAtLimit,
|
|
@@ -4724,7 +4799,7 @@ class HeatingRodControlModule extends BaseModule {
|
|
|
4724
4799
|
},
|
|
4725
4800
|
}));
|
|
4726
4801
|
await this._setStateIfChanged('heatingRod.summary.lastUpdate', now);
|
|
4727
|
-
await this._setStateIfChanged('heatingRod.summary.status', (this._devices && this._devices.length) ? `ok_${pvBase.source}${!pvAutomationAllowedByMin ? '_pv_min_block' : ''}${pvBase.forceOff ? '_storage_protect' : ''}${budgetProtection && budgetProtection.reason !== 'ok' ? `_gate_${String(budgetProtection.reason)}` : ''}${
|
|
4802
|
+
await this._setStateIfChanged('heatingRod.summary.status', (this._devices && this._devices.length) ? `ok_${pvBase.source}${!pvAutomationAllowedByMin ? '_pv_min_block' : ''}${pvBase.forceOff ? '_storage_protect' : ''}${budgetProtection && budgetProtection.reason !== 'ok' ? `_gate_${String(budgetProtection.reason)}` : ''}${zeroExportStrategyActive ? `_zero_${String(zeroExportInfo.reason || 'active')}` : ''}` : 'no_devices');
|
|
4728
4803
|
}
|
|
4729
4804
|
}
|
|
4730
4805
|
|
|
@@ -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:4d2234db2a1c6d62fe65d90a3934f90c4e63de05764335f660e735b93542b93d
|
|
6
6
|
* Erzeugung: npm run sync:ts-runtime-executables
|
|
7
7
|
*
|
|
8
8
|
* Zweck:
|
|
@@ -408,6 +408,14 @@ 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.
|
|
411
419
|
const enabled = cfgEnabled || autoTarifEnabled;
|
|
412
420
|
|
|
413
421
|
// SoC-Hysterese optional aus Konfig lesen (falls später im Admin ergänzt).
|
|
@@ -418,6 +426,7 @@ class SpeicherRegelungModule extends BaseModule {
|
|
|
418
426
|
await this._setIfChanged('speicher.regelung.aktiv', enabled);
|
|
419
427
|
await this._setIfChanged('speicher.regelung.aktivKonfig', cfgEnabled);
|
|
420
428
|
await this._setIfChanged('speicher.regelung.aktivAutoTarif', autoTarifEnabled);
|
|
429
|
+
await this._setIfChanged('speicher.regelung.aktivAutoSpeicherfarm', false);
|
|
421
430
|
|
|
422
431
|
// Wenn effektiv deaktiviert: nur Diagnose aktualisieren – KEINE Setpoints schreiben.
|
|
423
432
|
// (Wichtig, damit keine "0" als externe Vorgabe an ein Speichersystem gesendet wird.)
|
|
@@ -465,7 +474,10 @@ class SpeicherRegelungModule extends BaseModule {
|
|
|
465
474
|
const farmCfg = (this.adapter && this.adapter.config && this.adapter.config.storageFarm) ? this.adapter.config.storageFarm : {};
|
|
466
475
|
const farmEnabled = !!(this.adapter && this.adapter.config && this.adapter.config.enableStorageFarm);
|
|
467
476
|
const farmRows = Array.isArray(farmCfg.storages) ? farmCfg.storages : [];
|
|
477
|
+
// Speicherfarm ist ein Ziel-/Verteilpfad, kein eigener Regler-Start. Wenn die
|
|
478
|
+
// Speicherregelung aktiv ist, reicht ein Farm-Sollwert-DP als beschreibbares Ziel.
|
|
468
479
|
const hasFarmSetpoints = farmEnabled && farmRows.some(r => r && r.enabled !== false && (String(r.setSignedPowerId||'').trim() || String(r.setChargePowerId||'').trim() || String(r.setDischargePowerId||'').trim()));
|
|
480
|
+
await this._setIfChanged('speicher.regelung.aktivSpeicherfarm', !!hasFarmSetpoints);
|
|
469
481
|
|
|
470
482
|
const hasSignedTarget = this.dp ? !!this.dp.getEntry('st.targetPowerW') : false;
|
|
471
483
|
const hasSplitTarget = this.dp ? (!!this.dp.getEntry('st.targetChargePowerW') && !!this.dp.getEntry('st.targetDischargePowerW')) : false;
|
|
@@ -1039,10 +1051,26 @@ if (typeof soc === 'number') {
|
|
|
1039
1051
|
// ------------------------------------------------------------
|
|
1040
1052
|
// Gate E: Multiuse-Speicherstrategie (SoC-Zonen)
|
|
1041
1053
|
// ------------------------------------------------------------
|
|
1054
|
+
// MultiUse schreibt seine SoC-Zonen in storage.* und darf nur führen,
|
|
1055
|
+
// wenn die MultiUse-App wirklich aktiv ist. Ist MultiUse deaktiviert, läuft
|
|
1056
|
+
// die Speicherregelungs-App wieder mit der normalen Eigenverbrauchslogik.
|
|
1057
|
+
// Alte MultiUse-Werte wie selfDischargeEnabled=false dürfen dann keine
|
|
1058
|
+
// dauerhafte 0-W-Sperre mehr verursachen; echte 0-W-Sollwerte auf den
|
|
1059
|
+
// 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);
|
|
1068
|
+
const ignoreStaleMultiUsePolicy = !!(multiUsePolicyConfigured && !multiUsePolicyActive);
|
|
1069
|
+
|
|
1042
1070
|
// Notstrom-Reserve: harte Untergrenze für Entladen
|
|
1043
|
-
const reserveEnabled = !!cfg.reserveEnabled;
|
|
1044
|
-
const reserveMin = clamp(num(cfg.reserveMinSocPct, 20), 0, 100);
|
|
1045
|
-
const reserveTarget = clamp(num(cfg.reserveTargetSocPct, reserveMin), 0, 100);
|
|
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);
|
|
1046
1074
|
|
|
1047
1075
|
const reserveActive = reserveEnabled && (typeof soc === 'number') && (soc <= reserveMin);
|
|
1048
1076
|
|
|
@@ -1061,9 +1089,9 @@ if (typeof soc === 'number') {
|
|
|
1061
1089
|
await this._setIfChanged('speicher.regelung.reserveZielSocPct', reserveTarget);
|
|
1062
1090
|
|
|
1063
1091
|
// LSK (Peak-Shaving über Speicher)
|
|
1064
|
-
const lskEnabledCfg = cfg.lskEnabled !== false; // Default: an (damit bestehende Installationen unverändert bleiben)
|
|
1065
|
-
const lskMinSoc = clamp(num(cfg.lskMinSocPct, reserveMin), 0, 100);
|
|
1066
|
-
const lskMaxSoc = clamp(num(cfg.lskMaxSocPct, 100), 0, 100);
|
|
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);
|
|
1067
1095
|
|
|
1068
1096
|
// Eigenverbrauch (Entladen optional)
|
|
1069
1097
|
// Hybrid-/Gateway-Priorität ab 0.6.255:
|
|
@@ -1072,7 +1100,11 @@ if (typeof soc === 'number') {
|
|
|
1072
1100
|
// Bei wenig/keiner PV darf NexoWatt wieder über den normalen Sollleistungs-DP
|
|
1073
1101
|
// arbeiten, damit dynamische Tariflogik, Reserve und LSK nutzbar bleiben.
|
|
1074
1102
|
const feneconAcModeConfigured = !!feneconHybridConfigured;
|
|
1075
|
-
|
|
1103
|
+
// Nur aktive MultiUse-Policies dürfen selfDischargeEnabled=false als harte Sperre setzen.
|
|
1104
|
+
// Ist MultiUse deaktiviert, wird ein alter gespeicherter false-Wert ignoriert, damit die
|
|
1105
|
+
// normale Eigenverbrauchsregelung bei SoC + Netzbezug weiter arbeiten kann.
|
|
1106
|
+
const hasStoredSelfFlag = (cfg.selfDischargeEnabled === true || cfg.selfDischargeEnabled === false);
|
|
1107
|
+
const hasExplicitSelfFlag = hasStoredSelfFlag && !ignoreStaleMultiUsePolicy;
|
|
1076
1108
|
const feneconAcMode = false;
|
|
1077
1109
|
// Farm-Verhalten bewusst unverändert lassen: ältere Farm-Setups, die den alten
|
|
1078
1110
|
// Haken nur als implizite Eigenverbrauchs-Freigabe genutzt haben, behalten diesen
|
|
@@ -1087,16 +1119,16 @@ if (typeof soc === 'number') {
|
|
|
1087
1119
|
const selfDischargeEnabled = hasExplicitSelfFlag
|
|
1088
1120
|
? (cfg.selfDischargeEnabled === true)
|
|
1089
1121
|
: (farmSelfDischargeFallback || feneconLowPvSelfDischargeFallback || genericSelfDischargeDefault);
|
|
1090
|
-
const selfMinSoc = clamp(num(cfg.selfMinSocPct, reserveMin), 0, 100);
|
|
1091
|
-
const selfMaxSoc = clamp(num(cfg.selfMaxSocPct, 100), 0, 100);
|
|
1122
|
+
const selfMinSoc = clamp(num(ignoreStaleMultiUsePolicy ? undefined : cfg.selfMinSocPct, reserveMin), 0, 100);
|
|
1123
|
+
const selfMaxSoc = clamp(num(ignoreStaleMultiUsePolicy ? undefined : cfg.selfMaxSocPct, 100), 0, 100);
|
|
1092
1124
|
// Eigenverbrauchs-Optimierung: Ziel-Netzbezug am NVP.
|
|
1093
1125
|
// Praxis: ein kleiner Bezug (z. B. 50–150 W) ist oft stabiler als exakt 0 W
|
|
1094
1126
|
// (Messrauschen, Totzeiten, Geräte-Rampen).
|
|
1095
1127
|
// Standard-Eigenverbrauch bleibt herstellerunabhängig bei kleinem Ziel-Import.
|
|
1096
1128
|
// Hybrid-/Gateway-Priorität entscheidet später pro Tick: Gateway-No-Write, Zusatz-PV-Laden
|
|
1097
1129
|
// oder normale externe Vorgabe bei wenig/keiner interner PV.
|
|
1098
|
-
const selfTargetGridW = Math.max(0, num(cfg.selfTargetGridImportW, 50));
|
|
1099
|
-
const selfImportThresholdW = Math.max(0, num(cfg.selfImportThresholdW, 50));
|
|
1130
|
+
const selfTargetGridW = Math.max(0, num(ignoreStaleMultiUsePolicy ? undefined : cfg.selfTargetGridImportW, 50));
|
|
1131
|
+
const selfImportThresholdW = Math.max(0, num(ignoreStaleMultiUsePolicy ? undefined : cfg.selfImportThresholdW, 50));
|
|
1100
1132
|
|
|
1101
1133
|
await this._setIfChanged('speicher.regelung.lskMinSocPct', lskMinSoc);
|
|
1102
1134
|
await this._setIfChanged('speicher.regelung.lskMaxSocPct', lskMaxSoc);
|
|
@@ -1105,6 +1137,9 @@ if (typeof soc === 'number') {
|
|
|
1105
1137
|
await this._setIfChanged('speicher.regelung.selfTargetGridImportW', selfTargetGridW);
|
|
1106
1138
|
await this._setIfChanged('speicher.regelung.selfImportThresholdW', selfImportThresholdW);
|
|
1107
1139
|
await this._setIfChanged('speicher.regelung.selfEntladenAktiviert', !!selfDischargeEnabled);
|
|
1140
|
+
await this._setIfChanged('speicher.regelung.multiUsePolicyActive', !!multiUsePolicyActive);
|
|
1141
|
+
await this._setIfChanged('speicher.regelung.multiUsePolicyIgnored', !!ignoreStaleMultiUsePolicy);
|
|
1142
|
+
await this._setIfChanged('speicher.regelung.policyMode', multiUsePolicyActive ? 'multiuse' : 'speicherregelung');
|
|
1108
1143
|
|
|
1109
1144
|
// Grenzen / Glättung
|
|
1110
1145
|
// maxChargeW/maxDischargeW sind *optionale* Software-Clamps.
|
|
@@ -1825,8 +1860,13 @@ if (targetW === 0 && selfDischargeEnabled) {
|
|
|
1825
1860
|
// Entladebasis, damit zeitversetzte/0-W-Istwerte die Farm nicht künstlich herunterziehen.
|
|
1826
1861
|
const importRawNowW = Math.max(0, (typeof nvpRawW === 'number') ? nvpRawW : 0);
|
|
1827
1862
|
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);
|
|
1828
1868
|
const safetyMarginW = 200; // bewusst konservativ; Feintuning über selfTargetGridW/Deadband/Rampe
|
|
1829
|
-
const maxByDemandW = importRawNowW +
|
|
1869
|
+
const maxByDemandW = importRawNowW + dischargeNowW + safetyMarginW;
|
|
1830
1870
|
if (Number.isFinite(maxByDemandW) && maxByDemandW >= 0) {
|
|
1831
1871
|
dischargeDemandHardCapW = (typeof dischargeDemandHardCapW === 'number')
|
|
1832
1872
|
? Math.min(dischargeDemandHardCapW, maxByDemandW)
|
|
@@ -2368,6 +2408,13 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
|
|
|
2368
2408
|
importLimitW: (typeof importLimitW === 'number' && Number.isFinite(importLimitW)) ? Math.round(importLimitW) : null,
|
|
2369
2409
|
importHeadroomW: (typeof importHeadroomEffW === 'number' && Number.isFinite(importHeadroomEffW)) ? Math.round(importHeadroomEffW) : null,
|
|
2370
2410
|
},
|
|
2411
|
+
appPolicy: {
|
|
2412
|
+
mode: multiUsePolicyActive ? 'multiuse' : 'speicherregelung',
|
|
2413
|
+
storageControlActive: !!cfgEnabled,
|
|
2414
|
+
multiUseActive: !!multiUsePolicyActive,
|
|
2415
|
+
inactiveMultiUseZonesIgnored: !!ignoreStaleMultiUsePolicy,
|
|
2416
|
+
storageFarmDistribution: !!hasFarmSetpoints,
|
|
2417
|
+
},
|
|
2371
2418
|
reserve: {
|
|
2372
2419
|
active: !!reserveActive,
|
|
2373
2420
|
chargeWanted: !!reserveChargeWanted,
|
|
@@ -3032,6 +3079,8 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
|
|
|
3032
3079
|
await mk('speicher.regelung.aktiv', 'Speicher-Regelung aktiv (effektiv)', 'boolean', 'indicator', false);
|
|
3033
3080
|
await mk('speicher.regelung.aktivKonfig', 'Speicher-Regelung aktiv (Konfiguration)', 'boolean', 'indicator', false);
|
|
3034
3081
|
await mk('speicher.regelung.aktivAutoTarif', 'Auto-Aktivierung durch Tarif', 'boolean', 'indicator', false);
|
|
3082
|
+
await mk('speicher.regelung.aktivSpeicherfarm', 'Speicherfarm-Verteilpfad verfügbar', 'boolean', 'indicator', false);
|
|
3083
|
+
await mk('speicher.regelung.aktivAutoSpeicherfarm', 'Auto-Aktivierung durch Speicherfarm (deaktiviert)', 'boolean', 'indicator', false);
|
|
3035
3084
|
|
|
3036
3085
|
// Phase 2: Dispatcher-Diagnose
|
|
3037
3086
|
await mk('speicher.regelung.dispatcherVersion', 'Dispatcher-Version', 'string', 'text', '2.0');
|
|
@@ -3110,6 +3159,9 @@ const _prevRampW = (typeof this._lastTargetW === 'number' && Number.isFinite(thi
|
|
|
3110
3159
|
await mk('speicher.regelung.selfTargetGridImportW', 'Eigenverbrauch Ziel-Netzbezug (W)', 'number', 'value.power', 0);
|
|
3111
3160
|
await mk('speicher.regelung.selfImportThresholdW', 'Eigenverbrauch Deadband (W)', 'number', 'value.power', 0);
|
|
3112
3161
|
await mk('speicher.regelung.selfEntladenAktiviert', 'Eigenverbrauch-Entladen aktiviert', 'boolean', 'indicator', false);
|
|
3162
|
+
await mk('speicher.regelung.policyMode', 'Speicher-Policy-Modus', 'string', 'text', 'speicherregelung');
|
|
3163
|
+
await mk('speicher.regelung.multiUsePolicyActive', 'MultiUse-Policy aktiv', 'boolean', 'indicator', false);
|
|
3164
|
+
await mk('speicher.regelung.multiUsePolicyIgnored', 'Inaktive MultiUse-Policy ignoriert', 'boolean', 'indicator', false);
|
|
3113
3165
|
|
|
3114
3166
|
await mk('speicher.regelung.maxChargeW', 'Max Ladeleistung (W)', 'number', 'value.power', 0);
|
|
3115
3167
|
await mk('speicher.regelung.maxDischargeW', 'Max Entladeleistung (W)', 'number', 'value.power', 0);
|
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.78",
|
|
5
5
|
"news": {
|
|
6
|
+
"0.8.78": {
|
|
7
|
+
"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
|
+
"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."
|
|
9
|
+
},
|
|
10
|
+
"0.8.77": {
|
|
11
|
+
"de": "Version 0.8.77: Korrigiert die Speichersteuerung für Speicherfarm-/MultiUse-Setups. Speicherfarm-Sollwerte laufen nun auch ohne aktive MultiUse-App; alte MultiUse-SoC-Zonen blockieren Eigenverbrauch nicht mehr und 0-W-Farm-Limits bedeuten unbegrenzt statt Sperre.",
|
|
12
|
+
"en": "Version 0.8.77: Fixes storage control for storage-farm/MultiUse setups. Storage-farm setpoints now run without the MultiUse app; stale MultiUse SoC zones no longer block self-consumption and 0-W farm limits mean unlimited instead of blocked."
|
|
13
|
+
},
|
|
14
|
+
"0.8.76": {
|
|
15
|
+
"de": "Version 0.8.76: Ergänzt die Heizstab-Betriebsart für den bestehenden Auto-Button. Im Heizstab-AppCenter kann jetzt zwischen PV-Überschuss am NVP und 0-W-Einspeisung/Forecast gewählt werden; die alte separate Testlast-Aktivierung wurde bereinigt.",
|
|
16
|
+
"en": "Version 0.8.76: Adds a heating-rod operating mode behind the existing Auto button. The heating-rod App Center can now select PV surplus at the grid connection point or zero-export/forecast control; the old separate test-load activation was cleaned up."
|
|
17
|
+
},
|
|
6
18
|
"0.8.75": {
|
|
7
19
|
"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.",
|
|
8
20
|
"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."
|
|
@@ -18,18 +30,6 @@
|
|
|
18
30
|
"0.8.72": {
|
|
19
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.",
|
|
20
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."
|
|
21
|
-
},
|
|
22
|
-
"0.8.71": {
|
|
23
|
-
"de": "Version 0.8.71: Speicherregelung gegen überschießende Eigenverbrauchs-Entlade-Sollwerte gehärtet. Ist-Leistung wird nicht mehr aus Steuer-/Setpoint-DPs fürs Balancing genutzt; Demand-Cap wird nach der Rampe erneut hart angewendet.",
|
|
24
|
-
"en": "Version 0.8.71: Hardens storage control against excessive self-consumption discharge setpoints. Battery actual power is no longer taken from control/setpoint datapoints for balancing; demand cap is enforced again after ramp limiting."
|
|
25
|
-
},
|
|
26
|
-
"0.8.70": {
|
|
27
|
-
"de": "Version 0.8.70: Speicher-Einstellungen herstellerneutral bereinigt. Sichtbare FENECON-/Sungrow-Texte wurden durch allgemeine DP-Zuordnungs- und Gateway-Beschreibungen ersetzt; Legacy-IDs bleiben intern kompatibel.",
|
|
28
|
-
"en": "Version 0.8.70: Cleans up storage settings to be vendor-neutral. Visible FENECON/Sungrow wording was replaced by generic datapoint-mapping and gateway descriptions; legacy IDs remain internally compatible."
|
|
29
|
-
},
|
|
30
|
-
"0.8.69": {
|
|
31
|
-
"de": "Version 0.8.69: Speicherregelung herstelleroffener: getrennte Lade-/Entlade-Sollwert-DPs und optionaler Run-DP für Einzel-Speicher ergänzt. Eigenverbrauchs-Entladung ist für generische Speicher nun standardmäßig aktiv, solange keine Reserve-/Tarifsperre greift.",
|
|
32
|
-
"en": "Version 0.8.69: Storage control is more vendor-open: adds separate charge/discharge target datapoints and an optional run datapoint for single storages. Self-consumption discharge is now enabled by default for generic storages unless reserve/tariff gates block it."
|
|
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:6aa512c54a159430a7268d42c8806a1ca2b711cb2cf17ec845f4406a730b04aa
|
|
6
6
|
* Erzeugung: npm run sync:ts-runtime-executables
|
|
7
7
|
*
|
|
8
8
|
* Zweck:
|
|
@@ -3856,7 +3856,10 @@ class NexoWattVis extends utils.Adapter {
|
|
|
3856
3856
|
// ignore
|
|
3857
3857
|
}
|
|
3858
3858
|
|
|
3859
|
-
// Apply installer-only MultiUse (storage SoC zones) policy
|
|
3859
|
+
// Apply installer-only MultiUse (storage SoC zones) policy.
|
|
3860
|
+
// Die Policy schreibt nur dann in die Speicherregelung, wenn MultiUse aktiv ist.
|
|
3861
|
+
// Ist MultiUse deaktiviert, bleibt die Speicherregelungs-App der führende Regler;
|
|
3862
|
+
// alte MultiUse-Zonen werden im Storage-Tick erkannt und ignoriert.
|
|
3860
3863
|
try {
|
|
3861
3864
|
this.nwApplyStorageMultiUsePolicy(n);
|
|
3862
3865
|
} catch (_e) {
|
|
@@ -3911,16 +3914,26 @@ class NexoWattVis extends utils.Adapter {
|
|
|
3911
3914
|
const mu = (ic && typeof ic.storageMultiUse === 'object') ? ic.storageMultiUse : null;
|
|
3912
3915
|
if (!mu) return nativeObj;
|
|
3913
3916
|
|
|
3917
|
+
nativeObj.storage = (nativeObj.storage && typeof nativeObj.storage === 'object') ? nativeObj.storage : {};
|
|
3918
|
+
const st = nativeObj.storage;
|
|
3919
|
+
|
|
3920
|
+
// MultiUse darf nur führen, wenn sowohl die App als auch die Speicher-MultiUse-Policy
|
|
3921
|
+
// aktiv sind. Bei deaktiviertem MultiUse löschen wir keine normalen Speicherwerte,
|
|
3922
|
+
// sondern markieren nur den Zustand. Die Speicherregelung nutzt dann wieder ihre
|
|
3923
|
+
// normale Eigenverbrauchsoptimierung und ignoriert alte MultiUse-Zonen im Tick.
|
|
3924
|
+
if (!nativeObj.enableMultiUse || mu.enabled !== true) {
|
|
3925
|
+
st.multiUsePolicyActive = false;
|
|
3926
|
+
return nativeObj;
|
|
3927
|
+
}
|
|
3928
|
+
|
|
3914
3929
|
// Only apply when the MultiUse app itself is enabled.
|
|
3915
3930
|
// If MultiUse is enabled, storage-control must be active, otherwise the SoC zones have no effect.
|
|
3916
3931
|
// We therefore implicitly enable storage-control at runtime when MultiUse is active.
|
|
3917
|
-
if (!nativeObj.enableMultiUse) return nativeObj;
|
|
3918
|
-
|
|
3919
|
-
if (mu.enabled !== true) return nativeObj;
|
|
3920
|
-
|
|
3921
3932
|
if (!nativeObj.enableStorageControl) {
|
|
3922
3933
|
nativeObj.enableStorageControl = true;
|
|
3923
3934
|
}
|
|
3935
|
+
st.multiUsePolicyActive = true;
|
|
3936
|
+
st.multiUsePolicyApplied = true;
|
|
3924
3937
|
/**
|
|
3925
3938
|
* Code-Teil: clampInt
|
|
3926
3939
|
* Zweck: Kapselt einen lokalen Verarbeitungsschritt, damit Aufrufer nicht direkt in Detaildaten eingreifen.
|
|
@@ -3960,9 +3973,6 @@ class NexoWattVis extends utils.Adapter {
|
|
|
3960
3973
|
const selfMin = clampInt(mu.selfMinSocPct, selfBaseMin, 100, selfBaseMin);
|
|
3961
3974
|
const selfMax = clampInt(mu.selfMaxSocPct, selfMin, 100, legacySelfTo);
|
|
3962
3975
|
|
|
3963
|
-
nativeObj.storage = (nativeObj.storage && typeof nativeObj.storage === 'object') ? nativeObj.storage : {};
|
|
3964
|
-
const st = nativeObj.storage;
|
|
3965
|
-
|
|
3966
3976
|
// Notstrom / Reserve: blocks discharge below reserveMin. Optionaler Refill bis reserveTarget.
|
|
3967
3977
|
st.reserveEnabled = reserveEnabled;
|
|
3968
3978
|
st.reserveMinSocPct = reserveMin;
|
|
@@ -5527,8 +5537,8 @@ class NexoWattVis extends utils.Adapter {
|
|
|
5527
5537
|
*/
|
|
5528
5538
|
const normalizeLimitW = (v) => {
|
|
5529
5539
|
// Leer / nicht gesetzt bedeutet: keine harte Begrenzung.
|
|
5530
|
-
//
|
|
5531
|
-
//
|
|
5540
|
+
// Eine bewusst eingetragene 0-W-Vorgabe sperrt diese Richtung, bis der
|
|
5541
|
+
// Installateur wieder ein positives Limit oder leer (= unbegrenzt) setzt.
|
|
5532
5542
|
if (v === undefined || v === null) return null;
|
|
5533
5543
|
if (typeof v === 'string' && v.trim() === '') return null;
|
|
5534
5544
|
const n = Number(String(v).replace(',', '.'));
|
|
@@ -5934,19 +5944,28 @@ try {
|
|
|
5934
5944
|
const storageCfg = (this.config && this.config.storage && typeof this.config.storage === 'object') ? this.config.storage : {};
|
|
5935
5945
|
const src = String(source || '').toLowerCase().trim();
|
|
5936
5946
|
|
|
5937
|
-
const
|
|
5938
|
-
const
|
|
5947
|
+
const ic = (this.config && this.config.installerConfig && typeof this.config.installerConfig === 'object') ? this.config.installerConfig : {};
|
|
5948
|
+
const mu = (ic.storageMultiUse && typeof ic.storageMultiUse === 'object') ? ic.storageMultiUse : null;
|
|
5949
|
+
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);
|
|
5939
5957
|
const reserveFloor = (reserveEnabled && Number.isFinite(reserveMin)) ? reserveMin : 0;
|
|
5940
5958
|
|
|
5941
5959
|
const farmEnabled = !!(this.config && this.config.enableStorageFarm);
|
|
5942
|
-
const
|
|
5943
|
-
|
|
5944
|
-
const
|
|
5945
|
-
const
|
|
5946
|
-
const
|
|
5947
|
-
|
|
5948
|
-
|
|
5949
|
-
const
|
|
5960
|
+
const hasStoredSelfFlag = (storageCfg.selfDischargeEnabled === true || storageCfg.selfDischargeEnabled === false);
|
|
5961
|
+
const hasEffectiveSelfFlag = hasStoredSelfFlag && !ignoreInactiveMultiUseZones;
|
|
5962
|
+
const feneconFarmFallback = !!(farmEnabled && storageCfg.feneconAcMode === true && !hasEffectiveSelfFlag);
|
|
5963
|
+
const selfEnabled = hasEffectiveSelfFlag ? storageCfg.selfDischargeEnabled === true : (feneconFarmFallback || true);
|
|
5964
|
+
const selfMinRaw = Number(ignoreInactiveMultiUseZones ? 20 : storageCfg.selfMinSocPct);
|
|
5965
|
+
const selfFloor = (selfEnabled && Number.isFinite(selfMinRaw)) ? Math.max(0, Math.min(100, selfMinRaw)) : 0;
|
|
5966
|
+
|
|
5967
|
+
const lskEnabled = ignoreInactiveMultiUseZones ? true : ((storageCfg.lskDischargeEnabled !== false) && (storageCfg.lskEnabled !== false));
|
|
5968
|
+
const lskMin = Number(ignoreInactiveMultiUseZones ? 20 : storageCfg.lskMinSocPct);
|
|
5950
5969
|
const lskFloor = (lskEnabled && Number.isFinite(lskMin)) ? lskMin : 0;
|
|
5951
5970
|
|
|
5952
5971
|
if (src === 'eigenverbrauch' || src === 'evcs' || src === 'tarif') return Math.max(0, Math.min(100, Math.max(reserveFloor, selfFloor)));
|
|
@@ -6101,7 +6120,8 @@ try {
|
|
|
6101
6120
|
* TypeScript: Parameter, Rückgabewert und verwendete Config-/State-Objekte später explizit typisieren.
|
|
6102
6121
|
*/
|
|
6103
6122
|
const finiteLimitOrNull = (v) => {
|
|
6104
|
-
// Leer / null / undefined = unlimitiert.
|
|
6123
|
+
// Leer / null / undefined = unlimitiert. 0 ist eine bewusste 0-W-Sperre
|
|
6124
|
+
// fuer die jeweilige Richtung und wird deshalb als echtes Limit beibehalten.
|
|
6105
6125
|
if (v === undefined || v === null) return null;
|
|
6106
6126
|
if (typeof v === 'string' && v.trim() === '') return null;
|
|
6107
6127
|
const n = Number(String(v).replace(',', '.'));
|
|
@@ -6155,7 +6175,8 @@ try {
|
|
|
6155
6175
|
*/
|
|
6156
6176
|
const getLimitW = (storage, dir) => {
|
|
6157
6177
|
const raw = (dir === 'charge') ? (storage && storage.maxChargeW) : (storage && storage.maxDischargeW);
|
|
6158
|
-
// Leer / null / undefined = unlimitiert. 0 ist
|
|
6178
|
+
// Leer / null / undefined = unlimitiert. Eine 0-W-Vorgabe ist dagegen
|
|
6179
|
+
// eine gewollte Sperre für diese Richtung und muss die Farm-Verteilung stoppen.
|
|
6159
6180
|
if (raw === undefined || raw === null) return Number.POSITIVE_INFINITY;
|
|
6160
6181
|
if (typeof raw === 'string' && raw.trim() === '') return Number.POSITIVE_INFINITY;
|
|
6161
6182
|
const v = Number(String(raw).replace(',', '.'));
|
|
@@ -21360,6 +21381,27 @@ settingsConfig: {
|
|
|
21360
21381
|
const cfgEnabled = (typeof dev.enabled === 'boolean') ? !!dev.enabled : false;
|
|
21361
21382
|
const modeRaw = String(dev.mode || 'pvAuto').trim().toLowerCase();
|
|
21362
21383
|
const cfgMode = (modeRaw === 'manual' || modeRaw === 'off') ? modeRaw : 'pvAuto';
|
|
21384
|
+
const hCfg = (cfg.heatingRod && typeof cfg.heatingRod === 'object') ? cfg.heatingRod : {};
|
|
21385
|
+
const zeroCfg = (hCfg.zeroExport && typeof hCfg.zeroExport === 'object') ? hCfg.zeroExport : {};
|
|
21386
|
+
/**
|
|
21387
|
+
* Code-Teil: normalizeHeatingRodAutoModeLocal
|
|
21388
|
+
* Zweck: Meldet der Schnellsteuerung, welche Regelstrategie hinter dem einen Auto-Button aktiv ist.
|
|
21389
|
+
* Zusammenhang: Gleiche Normalisierung wie AppCenter/Heizstab-Runtime; bei neuen Betriebsarten alle drei Stellen gemeinsam ändern.
|
|
21390
|
+
* TypeScript: Später als geteilte Hilfsfunktion/Union-Typ auslagern.
|
|
21391
|
+
*/
|
|
21392
|
+
const normalizeHeatingRodAutoModeLocal = (raw) => {
|
|
21393
|
+
const s = String(raw || '').trim().toLowerCase();
|
|
21394
|
+
if (s === 'zeroexportforecast' || s === 'zero-export-forecast' || s === 'zero_export_forecast'
|
|
21395
|
+
|| s === 'zeroexport' || s === 'zero-export' || s === 'zero_export'
|
|
21396
|
+
|| s === 'zerofeedin' || s === 'zero-feed-in' || s === 'zero_feed_in'
|
|
21397
|
+
|| s === 'zero' || s === '0w' || s === '0-w' || s === '0_w'
|
|
21398
|
+
|| s === '0einspeisung' || s === '0-einspeisung' || s === '0_einspeisung'
|
|
21399
|
+
|| s === 'zeroeinspeisung' || s === 'forecast') return 'zeroExportForecast';
|
|
21400
|
+
return 'pvSurplus';
|
|
21401
|
+
};
|
|
21402
|
+
const legacyZeroModeActive = !!(zeroCfg.enabled || zeroCfg.active);
|
|
21403
|
+
const autoMode = normalizeHeatingRodAutoModeLocal(hCfg.autoMode || hCfg.automationMode || zeroCfg.autoMode || zeroCfg.mode || (legacyZeroModeActive ? 'zeroExportForecast' : 'pvSurplus'));
|
|
21404
|
+
const autoModeLabel = autoMode === 'zeroExportForecast' ? '0-W / Forecast' : 'PV-Überschuss';
|
|
21363
21405
|
|
|
21364
21406
|
let userEnabled = true;
|
|
21365
21407
|
let userMode = 'inherit';
|
|
@@ -21406,6 +21448,8 @@ settingsConfig: {
|
|
|
21406
21448
|
|
|
21407
21449
|
let currentStage = 0;
|
|
21408
21450
|
let targetStage = 0;
|
|
21451
|
+
let zeroExportReason = '';
|
|
21452
|
+
let zeroExportCanProbe = false;
|
|
21409
21453
|
let stageCount = Math.max(1, Math.round(Number(dev.stageCount ?? 1) || 1));
|
|
21410
21454
|
let wiredStages = 0;
|
|
21411
21455
|
let maxPowerW = Math.max(0, Math.round(Number(dev.maxPowerW ?? 0) || 0));
|
|
@@ -21426,6 +21470,14 @@ settingsConfig: {
|
|
|
21426
21470
|
const s = await this.getStateAsync(`heatingRod.devices.c${idx}.effectiveMode`);
|
|
21427
21471
|
if (s && s.val !== undefined && s.val !== null) effectiveMode = String(s.val || '').trim() || effectiveMode;
|
|
21428
21472
|
} catch (_e) {}
|
|
21473
|
+
try {
|
|
21474
|
+
const s = await this.getStateAsync(`heatingRod.devices.c${idx}.zeroExportReason`);
|
|
21475
|
+
if (s && s.val !== undefined && s.val !== null) zeroExportReason = String(s.val || '').trim();
|
|
21476
|
+
} catch (_e) {}
|
|
21477
|
+
try {
|
|
21478
|
+
const s = await this.getStateAsync(`heatingRod.devices.c${idx}.zeroExportCanProbe`);
|
|
21479
|
+
if (s && s.val !== undefined && s.val !== null) zeroExportCanProbe = !!s.val;
|
|
21480
|
+
} catch (_e) {}
|
|
21429
21481
|
|
|
21430
21482
|
const stages = Array.isArray(dev.stages) ? dev.stages : [];
|
|
21431
21483
|
const configuredStagePowerSumW = stages.reduce((sum, st) => sum + Math.max(0, Math.round(Number(st && st.powerW) || 0)), 0);
|
|
@@ -21449,6 +21501,11 @@ settingsConfig: {
|
|
|
21449
21501
|
userMode,
|
|
21450
21502
|
effectiveEnabled,
|
|
21451
21503
|
effectiveMode,
|
|
21504
|
+
autoMode,
|
|
21505
|
+
autoModeLabel,
|
|
21506
|
+
zeroExportActive: autoMode === 'zeroExportForecast',
|
|
21507
|
+
zeroExportCanProbe,
|
|
21508
|
+
zeroExportReason,
|
|
21452
21509
|
currentStage,
|
|
21453
21510
|
targetStage,
|
|
21454
21511
|
stageCount,
|
|
@@ -21464,7 +21521,7 @@ settingsConfig: {
|
|
|
21464
21521
|
boostUntil: out.boostUntil || 0,
|
|
21465
21522
|
boostRemainingMin: out.boostRemainingMin || 0,
|
|
21466
21523
|
modes: [
|
|
21467
|
-
{ value: 'pvAuto', label: 'Auto
|
|
21524
|
+
{ value: 'pvAuto', label: 'Auto' },
|
|
21468
21525
|
{ value: 'manual1', label: 'Stufe 1' },
|
|
21469
21526
|
{ value: 'manual2', label: 'Stufe 2' },
|
|
21470
21527
|
{ value: 'manual3', label: 'Stufe 3' },
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "iobroker.nexowatt-ui",
|
|
3
|
-
"version": "0.8.
|
|
3
|
+
"version": "0.8.78",
|
|
4
4
|
"description": "Responsive NexoWatt EMS visualization adapter.",
|
|
5
5
|
"author": "NexoWatt",
|
|
6
6
|
"license": "UNLICENSED",
|
|
@@ -282,7 +282,8 @@
|
|
|
282
282
|
"test:charging-active-demand-reserve": "node scripts/verify-charging-active-demand-reserve.js",
|
|
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
|
-
"test:evcs-hover-state": "node scripts/verify-evcs-hover-state.js"
|
|
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
287
|
},
|
|
287
288
|
"dependencies": {
|
|
288
289
|
"@iobroker/adapter-core": "^3.4.1",
|
package/www/app.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/app.ts
|
|
5
|
-
* Quell-Hash: sha256:
|
|
5
|
+
* Quell-Hash: sha256:deabeb3a0c1a72baafed3920d675b79984515ae7381c22e6203d46a222b5e5d1
|
|
6
6
|
* Erzeugung: npm run sync:ts-runtime-executables
|
|
7
7
|
*
|
|
8
8
|
* Zweck:
|
|
@@ -8229,7 +8229,7 @@ function _labelThermalMode(mode){
|
|
|
8229
8229
|
const k = m.toLowerCase();
|
|
8230
8230
|
if (!m) return '—';
|
|
8231
8231
|
if (k === 'inherit') return 'Auto';
|
|
8232
|
-
if (k === 'pvauto') return '
|
|
8232
|
+
if (k === 'pvauto') return 'Auto';
|
|
8233
8233
|
if (k === 'sgready') return 'SG‑Ready';
|
|
8234
8234
|
if (k === 'manual') return 'Manuell';
|
|
8235
8235
|
if (k === 'manual1') return 'Stufe 1';
|
|
@@ -10099,7 +10099,7 @@ function openFlowQc(kind, idx){
|
|
|
10099
10099
|
const s = String(m || '').trim();
|
|
10100
10100
|
const k = s.toLowerCase();
|
|
10101
10101
|
if (k === 'inherit' || k === 'system') return 'System';
|
|
10102
|
-
if (k === 'pvauto' || k === 'auto' || k === 'pv') return 'Auto
|
|
10102
|
+
if (k === 'pvauto' || k === 'auto' || k === 'pv') return 'Auto';
|
|
10103
10103
|
if (k === 'manual' || k === 'manuell') return 'Manuell';
|
|
10104
10104
|
if (k === 'manual1') return 'Stufe 1';
|
|
10105
10105
|
if (k === 'manual2') return 'Stufe 2';
|
|
@@ -10319,8 +10319,8 @@ function openFlowQc(kind, idx){
|
|
|
10319
10319
|
if (regHint) {
|
|
10320
10320
|
regHint.textContent = isRod
|
|
10321
10321
|
? (uEn
|
|
10322
|
-
?
|
|
10323
|
-
: '
|
|
10322
|
+
? `Regelung aktiv. Auto nutzt: ${String(ctl.autoModeLabel || 'PV-Überschuss')}. Manuelle Stufen und Boost bleiben zusätzlich verfügbar.`
|
|
10323
|
+
: 'Regelung aus. Der Adapter greift nicht automatisch ein; Stufen, Boost und Aus bleiben händisch verfügbar.')
|
|
10324
10324
|
: (uEn
|
|
10325
10325
|
? 'Automatik aktiv. Manuelle Bedienung bleibt möglich.'
|
|
10326
10326
|
: 'Regelung deaktiviert – manuelle Bedienung bleibt möglich.');
|
|
@@ -10336,13 +10336,16 @@ function openFlowQc(kind, idx){
|
|
|
10336
10336
|
const maxPowerInfo = Number(ctl.maxPowerW || 0) > 0 ? ` • max. ${formatPower(Number(ctl.maxPowerW || 0))}` : '';
|
|
10337
10337
|
const dupInfo = Array.isArray(ctl.duplicateWriteIds) && ctl.duplicateWriteIds.length ? ' • DP doppelt' : '';
|
|
10338
10338
|
const stageInfo = stageMax > 0 ? ` • ${Number(ctl.currentStage || 0)}/${stageMax} Stufen${maxPowerInfo}${dupInfo}` : maxPowerInfo;
|
|
10339
|
+
const autoModeLabel = String(ctl.autoModeLabel || 'PV-Überschuss');
|
|
10340
|
+
const zeroReason = (String(ctl.autoMode || '') === 'zeroExportForecast' && ctl.zeroExportReason) ? ` · ${String(ctl.zeroExportReason)}` : '';
|
|
10341
|
+
const strategyInfo = ` • Auto-Betriebsart: ${autoModeLabel}${zeroReason}`;
|
|
10339
10342
|
const backMode = (rawUserMode && rawUserMode !== 'inherit') ? rawUserMode : (String(ctl.cfgMode || 'pvAuto'));
|
|
10340
10343
|
if (ctl.boostActive) {
|
|
10341
|
-
modeHint.textContent = `Boost aktiv (${Number(ctl.boostRemainingMin || 0)} min) – danach ${modeLabel(backMode)}${stageInfo}`;
|
|
10344
|
+
modeHint.textContent = `Boost aktiv (${Number(ctl.boostRemainingMin || 0)} min) – danach ${modeLabel(backMode)}${stageInfo}${strategyInfo}`;
|
|
10342
10345
|
} else if (rawUserMode === 'inherit') {
|
|
10343
|
-
modeHint.textContent = `System: ${modeLabel(ctl.cfgMode)} (aktiv: ${modeLabel(effMode)})${stageInfo}`;
|
|
10346
|
+
modeHint.textContent = `System: ${modeLabel(ctl.cfgMode)} (aktiv: ${modeLabel(effMode)})${stageInfo}${strategyInfo}`;
|
|
10344
10347
|
} else {
|
|
10345
|
-
modeHint.textContent = `Aktiv: ${modeLabel(effMode)}${stageInfo}`;
|
|
10348
|
+
modeHint.textContent = `Aktiv: ${modeLabel(effMode)}${stageInfo}${strategyInfo}`;
|
|
10346
10349
|
}
|
|
10347
10350
|
} else {
|
|
10348
10351
|
if (String(rawUserMode || '').toLowerCase() === 'inherit') {
|
|
@@ -10575,7 +10578,7 @@ function openFlowQc(kind, idx){
|
|
|
10575
10578
|
if (modeHint) modeHint.textContent = '';
|
|
10576
10579
|
if (qc.controlKind === 'heatingRod') {
|
|
10577
10580
|
renderModeButtons([
|
|
10578
|
-
{ value: 'pvAuto', label: 'Auto
|
|
10581
|
+
{ value: 'pvAuto', label: 'Auto' },
|
|
10579
10582
|
{ value: 'manual1', label: 'Stufe 1' },
|
|
10580
10583
|
{ value: 'manual2', label: 'Stufe 2' },
|
|
10581
10584
|
{ value: 'manual3', label: 'Stufe 3' },
|
|
@@ -10583,7 +10586,7 @@ function openFlowQc(kind, idx){
|
|
|
10583
10586
|
], 'pvAuto');
|
|
10584
10587
|
} else {
|
|
10585
10588
|
renderModeButtons([
|
|
10586
|
-
{ value: 'pvAuto', label: 'Auto
|
|
10589
|
+
{ value: 'pvAuto', label: 'Auto' },
|
|
10587
10590
|
{ value: 'manual', label: 'Manuell' },
|
|
10588
10591
|
{ value: 'off', label: 'Aus' },
|
|
10589
10592
|
{ value: 'inherit', label: 'System' },
|
package/www/ems-apps.js
CHANGED
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
* AUTO-GENERATED RUNTIME FILE - NICHT MANUELL BEARBEITEN.
|
|
3
3
|
*
|
|
4
4
|
* Quelle: src-ts/runtime-executables/www/ems-apps.ts
|
|
5
|
-
* Quell-Hash: sha256:
|
|
5
|
+
* Quell-Hash: sha256:277900cdec5c47dd668a929b3e9c43ccb04d827e0a06e7b8dc0bd2b7e1bb862d
|
|
6
6
|
* Erzeugung: npm run sync:ts-runtime-executables
|
|
7
7
|
*
|
|
8
8
|
* Zweck:
|
|
@@ -4292,6 +4292,36 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
|
|
|
4292
4292
|
t.devices = out;
|
|
4293
4293
|
return t;
|
|
4294
4294
|
}
|
|
4295
|
+
/**
|
|
4296
|
+
* Code-Teil: _normalizeHeatingRodAutoMode
|
|
4297
|
+
* Zweck: Normalisiert die Betriebsart hinter dem einen Frontend-Auto-Button der Heizstab-App.
|
|
4298
|
+
* Zusammenhang: Das Dropdown speichert nur die Auto-Strategie; Kunden bedienen weiter `Auto`,
|
|
4299
|
+
* während die Runtime entweder NVP-PV-Überschuss oder 0-W/Forecast nutzt.
|
|
4300
|
+
* TypeScript: Beim späteren Umbau als Union-Typ `'pvSurplus' | 'zeroExportForecast'` führen.
|
|
4301
|
+
*/
|
|
4302
|
+
function _normalizeHeatingRodAutoMode(raw) {
|
|
4303
|
+
const s = String(raw || '').trim().toLowerCase();
|
|
4304
|
+
if (s === 'zeroexportforecast' || s === 'zero-export-forecast' || s === 'zero_export_forecast'
|
|
4305
|
+
|| s === 'zeroexport' || s === 'zero-export' || s === 'zero_export'
|
|
4306
|
+
|| s === 'zerofeedin' || s === 'zero-feed-in' || s === 'zero_feed_in'
|
|
4307
|
+
|| s === 'zero' || s === '0w' || s === '0-w' || s === '0_w'
|
|
4308
|
+
|| s === '0einspeisung' || s === '0-einspeisung' || s === '0_einspeisung'
|
|
4309
|
+
|| s === 'zeroeinspeisung' || s === 'forecast') return 'zeroExportForecast';
|
|
4310
|
+
return 'pvSurplus';
|
|
4311
|
+
}
|
|
4312
|
+
|
|
4313
|
+
/**
|
|
4314
|
+
* Code-Teil: _heatingRodAutoModeLabel
|
|
4315
|
+
* Zweck: Liefert kurze, konsistente UI-Texte zur Heizstab-Betriebsart.
|
|
4316
|
+
* Zusammenhang: Wird im AppCenter und in Status-/Hinweistexten genutzt; bei neuen
|
|
4317
|
+
* Betriebsarten immer gemeinsam mit Runtime und Schnellsteuerung erweitern.
|
|
4318
|
+
*/
|
|
4319
|
+
function _heatingRodAutoModeLabel(mode) {
|
|
4320
|
+
return _normalizeHeatingRodAutoMode(mode) === 'zeroExportForecast'
|
|
4321
|
+
? '0-W-Einspeisung / Forecast'
|
|
4322
|
+
: 'PV-Überschuss am NVP';
|
|
4323
|
+
}
|
|
4324
|
+
|
|
4295
4325
|
/**
|
|
4296
4326
|
* Code-Teil: _ensureHeatingRodCfg
|
|
4297
4327
|
* Zweck: Kapselt einen lokalen Verarbeitungsschritt, damit Aufrufer nicht direkt in Detaildaten eingreifen.
|
|
@@ -4311,6 +4341,13 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
|
|
|
4311
4341
|
h.minPvPowerW = Math.max(0, Math.round(Number.isFinite(hMinPvRaw) ? hMinPvRaw : 800));
|
|
4312
4342
|
h.useBudgetGates = true;
|
|
4313
4343
|
const legacyZeroForBudget = (h.zeroExport && typeof h.zeroExport === 'object') ? h.zeroExport : {};
|
|
4344
|
+
// Das alte Detail-Flag `zeroExport.enabled` wird nur zur Migration verwendet.
|
|
4345
|
+
// Danach steuert ausschließlich `h.autoMode`, welche Regelstrategie der normale
|
|
4346
|
+
// Auto-Button nutzt; so gibt es keine zweite, widersprüchliche Aktivierung mehr.
|
|
4347
|
+
const legacyZeroModeActive = !!(legacyZeroForBudget.enabled || legacyZeroForBudget.active);
|
|
4348
|
+
h.autoMode = _normalizeHeatingRodAutoMode(
|
|
4349
|
+
h.autoMode || h.automationMode || legacyZeroForBudget.autoMode || legacyZeroForBudget.mode || (legacyZeroModeActive ? 'zeroExportForecast' : 'pvSurplus')
|
|
4350
|
+
);
|
|
4314
4351
|
const legacyBudgetAliases = {
|
|
4315
4352
|
maxGridImportW: ['maxGridImportW', 'gridImportTripW'],
|
|
4316
4353
|
gridImportHoldSec: ['gridImportHoldSec', 'gridImportTripSec'],
|
|
@@ -4373,7 +4410,8 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
|
|
|
4373
4410
|
n = Math.max(min, Math.min(max, n));
|
|
4374
4411
|
z[key] = integer ? Math.round(n) : n;
|
|
4375
4412
|
};
|
|
4376
|
-
z.enabled =
|
|
4413
|
+
z.enabled = h.autoMode === 'zeroExportForecast';
|
|
4414
|
+
z.autoMode = h.autoMode;
|
|
4377
4415
|
zn('feedInLimitW', 1000, 0, 1000000);
|
|
4378
4416
|
zn('feedInToleranceW', 150, 0, 100000);
|
|
4379
4417
|
zn('targetExportBufferW', 100, 0, 100000);
|
|
@@ -4791,7 +4829,7 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
|
|
|
4791
4829
|
els.thermalDevices.innerHTML = '';
|
|
4792
4830
|
|
|
4793
4831
|
const modeOptions = [
|
|
4794
|
-
{ value: 'pvAuto', label: '
|
|
4832
|
+
{ value: 'pvAuto', label: 'Auto' },
|
|
4795
4833
|
{ value: 'manual', label: 'Manuell' },
|
|
4796
4834
|
{ value: 'off', label: 'Aus' },
|
|
4797
4835
|
];
|
|
@@ -4967,21 +5005,50 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
|
|
|
4967
5005
|
}
|
|
4968
5006
|
|
|
4969
5007
|
const modeOptions = [
|
|
4970
|
-
{ value: 'pvAuto', label: '
|
|
5008
|
+
{ value: 'pvAuto', label: 'Auto' },
|
|
4971
5009
|
{ value: 'manual', label: 'Manuell' },
|
|
4972
5010
|
{ value: 'off', label: 'Aus' },
|
|
4973
5011
|
];
|
|
4974
5012
|
const stageCountOptions = Array.from({ length: 12 }, (_, i) => ({ value: String(i + 1), label: `${i + 1}` }));
|
|
4975
5013
|
|
|
4976
|
-
const
|
|
5014
|
+
const grpMode = _mkCfgGroup('Betriebsart');
|
|
5015
|
+
const modeInfo = document.createElement('div');
|
|
5016
|
+
modeInfo.className = 'nw-config-field-hint';
|
|
5017
|
+
modeInfo.style.flexBasis = '100%';
|
|
5018
|
+
modeInfo.textContent = 'Diese Einstellung entscheidet, welche Regelstrategie der normale Auto-Button verwendet. Es wird bewusst kein zweiter Auto-Button erzeugt.';
|
|
5019
|
+
grpMode.body.appendChild(modeInfo);
|
|
5020
|
+
const autoModeSelect = _mkCfgSelect(cfg.autoMode || 'pvSurplus', [
|
|
5021
|
+
{ value: 'pvSurplus', label: 'PV-Überschuss am NVP' },
|
|
5022
|
+
{ value: 'zeroExportForecast', label: '0-W-Einspeisung / Forecast' },
|
|
5023
|
+
], (v) => {
|
|
5024
|
+
cfg.autoMode = _normalizeHeatingRodAutoMode(v);
|
|
5025
|
+
cfg.zeroExport = (cfg.zeroExport && typeof cfg.zeroExport === 'object') ? cfg.zeroExport : {};
|
|
5026
|
+
cfg.zeroExport.enabled = cfg.autoMode === 'zeroExportForecast';
|
|
5027
|
+
cfg.zeroExport.autoMode = cfg.autoMode;
|
|
5028
|
+
rebuildHeatingRodUIStable('heatingrod-auto-mode');
|
|
5029
|
+
setDirty();
|
|
5030
|
+
}, { width: '260px' });
|
|
5031
|
+
grpMode.body.appendChild(_mkCfgField('Automatik-Regelung', autoModeSelect, cfg.autoMode === 'zeroExportForecast'
|
|
5032
|
+
? 'Auto nutzt Forecast, Teststufen und Live-Netzpunkt-/Speicher-Schutz für Anlagen mit 0-W-Einspeisung.'
|
|
5033
|
+
: 'Auto nutzt den gemessenen PV-Überschuss am Netzverknüpfungspunkt.'));
|
|
5034
|
+
const modeStatus = document.createElement('div');
|
|
5035
|
+
modeStatus.className = 'nw-config-field-hint';
|
|
5036
|
+
modeStatus.style.flexBasis = '100%';
|
|
5037
|
+
modeStatus.textContent = `Auto-Button verwendet aktuell: ${_heatingRodAutoModeLabel(cfg.autoMode)}`;
|
|
5038
|
+
grpMode.body.appendChild(modeStatus);
|
|
5039
|
+
els.heatingRodDevices.appendChild(grpMode.wrap);
|
|
5040
|
+
|
|
5041
|
+
const grpAuto = _mkCfgGroup('Auto – Budget & Speicher');
|
|
4977
5042
|
const autoInfo = document.createElement('div');
|
|
4978
5043
|
autoInfo.className = 'nw-config-field-hint';
|
|
4979
5044
|
autoInfo.style.flexBasis = '100%';
|
|
4980
|
-
autoInfo.textContent =
|
|
5045
|
+
autoInfo.textContent = cfg.autoMode === 'zeroExportForecast'
|
|
5046
|
+
? 'Auto arbeitet im 0-W-/Forecast-Modus: Forecast gibt frei, Probe-Stufen testen PV-Nachregelung, Netzpunkt und Speicher schützen live.'
|
|
5047
|
+
: 'Auto arbeitet im klassischen PV-Überschussmodus: Zentrale EMS-Budget-Gates lesen, NVP-Überschuss verfolgen und eigene Auto-Stufen halten. Externe KNX-/Relais-Schaltungen werden nur beobachtet.';
|
|
4981
5048
|
grpAuto.body.appendChild(autoInfo);
|
|
4982
5049
|
grpAuto.body.appendChild(_mkCfgField('Speicher-Reserve (W)', _mkHeatingRodNumberInput('storageReserveW', cfg.storageReserveW, (v) => { cfg.storageReserveW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 50, width: '150px' }), 'Bleibt für Speicherladung frei, solange der Speicher unter dem Ziel-SoC liegt.'));
|
|
4983
5050
|
grpAuto.body.appendChild(_mkCfgField('Reserve bis SoC (%)', _mkHeatingRodNumberInput('storageTargetSocPct', cfg.storageTargetSocPct, (v) => { cfg.storageTargetSocPct = Math.max(0, Math.min(100, Math.round(Number(v) || 0))); setDirty(); }, { min: 0, max: 100, step: 1, width: '130px' }), 'Ab diesem SoC darf der Heizstab den Überschuss ohne Speicherreserve nutzen.'));
|
|
4984
|
-
grpAuto.body.appendChild(_mkCfgField('
|
|
5051
|
+
grpAuto.body.appendChild(_mkCfgField('Auto ab PV (W)', _mkHeatingRodNumberInput('minPvPowerW', cfg.minPvPowerW, (v) => { cfg.minPvPowerW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 50, width: '150px' }), 'Start-/Hochschaltgrenze. Unterhalb wird nicht neu zugeschaltet, laufende Auto-Stufen werden aber über Netz-/Speichergates stabil gehalten.'));
|
|
4985
5052
|
grpAuto.body.appendChild(_mkCfgField('Sicherheitsreserve (W)', _mkHeatingRodNumberInput('budgetSafetyReserveW', cfg.budgetSafetyReserveW, (v) => { cfg.budgetSafetyReserveW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 10, width: '150px' }), 'Abzug vom Heizstab-Budget gegen Messrauschen.'));
|
|
4986
5053
|
els.heatingRodDevices.appendChild(grpAuto.wrap);
|
|
4987
5054
|
|
|
@@ -5006,13 +5073,17 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
|
|
|
5006
5073
|
els.heatingRodDevices.appendChild(grpProtect.wrap);
|
|
5007
5074
|
|
|
5008
5075
|
const zeroCfg = cfg.zeroExport || {};
|
|
5009
|
-
const
|
|
5076
|
+
const zeroModeActive = cfg.autoMode === 'zeroExportForecast';
|
|
5077
|
+
zeroCfg.enabled = zeroModeActive;
|
|
5078
|
+
zeroCfg.autoMode = cfg.autoMode;
|
|
5079
|
+
const grpZero = _mkCfgDetailsGroup('Details: 0-W-Einspeisung / Forecast', zeroModeActive);
|
|
5010
5080
|
const zeroInfo = document.createElement('div');
|
|
5011
5081
|
zeroInfo.className = 'nw-config-field-hint';
|
|
5012
5082
|
zeroInfo.style.flexBasis = '100%';
|
|
5013
|
-
zeroInfo.textContent =
|
|
5083
|
+
zeroInfo.textContent = zeroModeActive
|
|
5084
|
+
? 'Diese Detailwerte konfigurieren die aktive 0-W-/Forecast-Betriebsart. Die Aktivierung erfolgt ausschließlich oben über „Betriebsart“.'
|
|
5085
|
+
: 'Die Detailwerte bleiben gespeichert. Aktiv wird diese Logik erst, wenn oben als Betriebsart „0-W-Einspeisung / Forecast“ gewählt ist.';
|
|
5014
5086
|
grpZero.body.appendChild(zeroInfo);
|
|
5015
|
-
grpZero.body.appendChild(_mkCfgField('Testlast aktiv', _mkCfgToggle(!!zeroCfg.enabled, (v) => { zeroCfg.enabled = !!v; setDirty(); }), 'Nur Heizstab-PV-Auto; kein Eingriff in Ladepark oder Speicher.'));
|
|
5016
5087
|
grpZero.body.appendChild(_mkCfgField('Erlaubte Einspeisung (W)', _mkCfgInput('number', zeroCfg.feedInLimitW, (v) => { zeroCfg.feedInLimitW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 50, width: '150px' }), '0 bei echter 0-Einspeisung, 1000 bei -1 kW Limit.'));
|
|
5017
5088
|
grpZero.body.appendChild(_mkCfgField('Mindest-PV Testlast (W)', _mkCfgInput('number', zeroCfg.minPvPowerW, (v) => { zeroCfg.minPvPowerW = Math.max(0, Math.round(Number(v) || 0)); setDirty(); }, { min: 0, step: 50, width: '150px' }), 'Zusätzliche Freigabe für Testlasten.'));
|
|
5018
5089
|
grpZero.body.appendChild(_mkCfgField('Forecast erforderlich', _mkCfgToggle(zeroCfg.requireForecast !== false, (v) => { zeroCfg.requireForecast = !!v; setDirty(); }), 'Forecast nur als Plausibilität; Netzpunkt entscheidet danach.'));
|
|
@@ -5093,9 +5164,9 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
|
|
|
5093
5164
|
right.appendChild(info);
|
|
5094
5165
|
|
|
5095
5166
|
const grpBasic = _mkCfgGroup('Grunddaten');
|
|
5096
|
-
grpBasic.body.appendChild(_mkCfgField('
|
|
5167
|
+
grpBasic.body.appendChild(_mkCfgField('Auto aktiv', _mkCfgToggle(dev.enabled, (v) => { dev.enabled = !!v; setDirty(); }), 'Aktiviert die native Heizstab-Automatik für diesen Slot. Die Betriebsart kommt aus dem Dropdown oben.'));
|
|
5097
5168
|
grpBasic.body.appendChild(_mkCfgField('Name (optional)', _mkCfgInput('text', dev.name || '', (v) => { dev.name = String(v || '').trim(); setDirty(); }, { width: '220px', placeholder: 'Anzeige-Name' }), 'Leer lassen = Name aus Energiefluss-Slot.'));
|
|
5098
|
-
grpBasic.body.appendChild(_mkCfgField('Modus', _mkCfgSelect(dev.mode || 'pvAuto', modeOptions, (v) => { dev.mode = v; setDirty(); }, { width: '160px' }), '
|
|
5169
|
+
grpBasic.body.appendChild(_mkCfgField('Modus', _mkCfgSelect(dev.mode || 'pvAuto', modeOptions, (v) => { dev.mode = v; setDirty(); }, { width: '160px' }), 'Auto = native Stufenregelung mit der oben gewählten Betriebsart; Manuell = nur bilanzieren; Aus = alles aus.'));
|
|
5099
5170
|
grpBasic.body.appendChild(_mkCfgField('Priorität', _mkCfgInput('number', dev.priority, (v) => { dev.priority = _clampInt(v, 1, 999, 200 + slot); setDirty(); }, { min: 1, max: 999, step: 1, width: '110px' }), 'Kleinere Zahl = wird früher aus PV versorgt.'));
|
|
5100
5171
|
grpBasic.body.appendChild(_mkCfgField('Max. Leistung (W)', _mkCfgInput('number', dev.maxPowerW, (v) => { dev.maxPowerW = Math.max(0, Math.round(Number(v) || 0)); _syncHeatingRodDeviceStages(dev); rebuildHeatingRodUIStable('heatingrod-max-power'); setDirty(); }, { min: 0, step: 10, width: '150px', commitOnInput: false }), 'Gesamtleistung des Heizstabs / Verbunds.'));
|
|
5101
5172
|
grpBasic.body.appendChild(_mkCfgField('Stufen', _mkCfgSelect(String(dev.stageCount || 1), stageCountOptions, (v) => { dev.stageCount = _clampInt(v, 1, 12, 1); _syncHeatingRodDeviceStages(dev); rebuildHeatingRodUIStable('heatingrod-stage-count'); setDirty(); }, { width: '110px' }), 'Anzahl nativer Heizstab-Stufen.'));
|
|
@@ -8841,9 +8912,9 @@ http://mesh-peer.local:8188" ${isEos ? '' : 'disabled'}>${_meshHtmlEscape(Array.
|
|
|
8841
8912
|
|
|
8842
8913
|
// Feste Leistungsgrenzen
|
|
8843
8914
|
grid.appendChild(mkGridDivider('Feste Leistungsgrenzen (direkte Eingabe)'));
|
|
8844
|
-
grid.appendChild(mkGridHelp('Diese Werte begrenzen die Farm-Verteilung pro Speicher. Leer = unbegrenzt, 0 = diese Richtung sperren.
|
|
8845
|
-
grid.appendChild(mkNumField('Max. Beladen (W)', `sf_${idx}_maxChargeW`, s.maxChargeW, (v) => { const sf2 = _ensureStorageFarmCfg(); sf2.storages[i].maxChargeW = v; }, '
|
|
8846
|
-
grid.appendChild(mkNumField('Max. Entladen (W)', `sf_${idx}_maxDischargeW`, s.maxDischargeW, (v) => { const sf2 = _ensureStorageFarmCfg(); sf2.storages[i].maxDischargeW = v; }, '
|
|
8915
|
+
grid.appendChild(mkGridHelp('Diese Werte begrenzen die Farm-Verteilung pro Speicher. Leer = unbegrenzt, 0 W = diese Richtung sperren.'));
|
|
8916
|
+
grid.appendChild(mkNumField('Max. Beladen (W)', `sf_${idx}_maxChargeW`, s.maxChargeW, (v) => { const sf2 = _ensureStorageFarmCfg(); sf2.storages[i].maxChargeW = v; }, 'leer = unbegrenzt, 0 = sperren'));
|
|
8917
|
+
grid.appendChild(mkNumField('Max. Entladen (W)', `sf_${idx}_maxDischargeW`, s.maxDischargeW, (v) => { const sf2 = _ensureStorageFarmCfg(); sf2.storages[i].maxDischargeW = v; }, 'leer = unbegrenzt, 0 = sperren'));
|
|
8847
8918
|
|
|
8848
8919
|
// Verfügbarkeit & Freigaben
|
|
8849
8920
|
grid.appendChild(mkGridDivider('Verfügbarkeit & Freigaben'));
|
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:450c858958cff245c1b3d728b5ff1b52f959e52c53adab637eca05db8532e30f
|
|
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-v379';
|
|
46
46
|
|
|
47
47
|
const OFFLINE_URLS = [
|
|
48
48
|
'./',
|