iobroker.nexowatt-ui 1.0.2 → 1.0.4
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/README.md +1 -1
- package/docs/STABLE_1_0_3_RELEASE_DE.md +88 -0
- package/docs/STABLE_1_0_4_RELEASE_DE.md +92 -0
- package/ems/modules/charging-management.js +132 -14
- package/ems/services/pv-surplus-allocation.js +54 -2
- package/io-package.json +11 -11
- package/lib/ts-mirrors/ems/charging-management/charging-phase-selection.js +16 -4
- package/main.js +15 -1
- package/package.json +12 -5
- package/scripts/verify-rc60-universal-auto-wallbox.js +839 -0
- package/scripts/verify-stable-1.0.2-health-heartbeat.cjs +14 -3
- package/scripts/verify-stable-1.0.3-home-appcenter-access.cjs +388 -0
- package/scripts/verify-stable-1.0.4-auto-pv-phases.cjs +238 -0
- package/scripts/verify-stable-release.cjs +56 -2
- package/www/auth.js +24 -7
- package/www/ems-apps.js +21 -6
- package/www/manifest.webmanifest +2 -2
- package/www/netoperator-appcenter.js +14 -2
- package/www/settings.html +1 -1
- package/www/sw.js +2 -2
package/README.md
CHANGED
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
|
|
3
3
|
NexoWatt EOS is the local platform for energy, charging and building control, including the responsive customer cockpit and installer workspace.
|
|
4
4
|
|
|
5
|
-
**Current stable release:** `1.0.
|
|
5
|
+
**Current stable release:** `1.0.4` (2026-09-11)
|
|
6
6
|
|
|
7
7
|
It provides live energy-flow visualization, historical analysis, SmartHome visualization, installer-controlled EMS applications, and selected customer controls for desktop, tablet, and smartphone use.
|
|
8
8
|
|
|
@@ -0,0 +1,88 @@
|
|
|
1
|
+
# NexoWatt EOS 1.0.3 – offizielle Stable-Version
|
|
2
|
+
|
|
3
|
+
**Veröffentlichungsdatum:** 2026-09-09
|
|
4
|
+
**Status:** Official Stable Patch / produktiver Verkaufsstand
|
|
5
|
+
|
|
6
|
+
## Zweck des Patches
|
|
7
|
+
|
|
8
|
+
NexoWatt EOS 1.0.3 behebt einen Lizenz-/Authentifizierungsfehler im geschützten AppCenter. Mit einer gültigen Home-Lizenz konnte sich ein Administrator korrekt anmelden und den AppCenter zunächst öffnen. Kurz danach wurde die Seite jedoch erneut gesperrt und der Login-Dialog erschien wieder.
|
|
9
|
+
|
|
10
|
+
Die Admin-Sitzung war dabei weiterhin gültig. Ursache war ein erwartbarer HTTP-403-Status eines nicht in Home enthaltenen Pro-Moduls. Der globale Frontend-Fetch-Handler behandelte bisher jeden 401- oder 403-Status pauschal als Authentifizierungsverlust. Dadurch konnte eine fachliche Lizenzantwort wie `eos_required` die gesamte geschützte Seite verriegeln.
|
|
11
|
+
|
|
12
|
+
## Korrigierter Authentifizierungsvertrag
|
|
13
|
+
|
|
14
|
+
Nach einer 401-/403-Antwort wird der Auth-Status erneut beim Adapter geprüft. Die Seite wird nur noch gesperrt, wenn mindestens einer dieser Zustände bestätigt wird:
|
|
15
|
+
|
|
16
|
+
- die Sitzung ist tatsächlich nicht mehr angemeldet;
|
|
17
|
+
- die für die aktuelle Seite erforderliche Capability fehlt;
|
|
18
|
+
- der Auth-Status ist nicht erreichbar und kann deshalb nicht sicher bestätigt werden.
|
|
19
|
+
|
|
20
|
+
Ist der Benutzer weiterhin als Admin oder Installer angemeldet und besitzt `appcenter.open`, bleibt der AppCenter geöffnet. Die fachliche API-Antwort wird unverändert an das jeweilige Modul weitergereicht.
|
|
21
|
+
|
|
22
|
+
Damit werden unter anderem folgende fachliche Antworten nicht mehr mit einem Loginverlust verwechselt:
|
|
23
|
+
|
|
24
|
+
- `eos_required`;
|
|
25
|
+
- `license_required`;
|
|
26
|
+
- `readOnly`;
|
|
27
|
+
- `customer_control_disabled`;
|
|
28
|
+
- geräte- oder funktionsbezogene 403-Antworten.
|
|
29
|
+
|
|
30
|
+
## Home-Lizenz und alte Pro-Konfiguration
|
|
31
|
+
|
|
32
|
+
Beim Wechsel von Pro auf Home können im gespeicherten Projektstand weiterhin Konfigurationen von Pro-Apps vorhanden sein. Diese Daten werden nicht ungefragt gelöscht. Für die an die Home-Oberfläche gelieferte Konfigurationskopie werden Pro-only Apps jedoch mit der bestehenden Lizenznormalisierung auf `installed=false`, `enabled=false` und `licenseBlocked=true` gesetzt.
|
|
33
|
+
|
|
34
|
+
Zusätzlich gelten im Frontend drei Schutzebenen:
|
|
35
|
+
|
|
36
|
+
1. Mesh/Microgrid, Netzbetreiber-Schnittstelle und Betriebsstrategien werden nur bei gültiger App-Lizenz als installiert bewertet.
|
|
37
|
+
2. Pro-only Komponenten werden unter Home nicht initialisiert.
|
|
38
|
+
3. Die Netzbetreiber-Komponente prüft die Edition vor dem Laden des Pro-Treiberverzeichnisses.
|
|
39
|
+
|
|
40
|
+
Dadurch kann ein alter `installed=true`-Wert keine versteckten Pro-API-Aufrufe und keine erneute Login-Sperre mehr auslösen.
|
|
41
|
+
|
|
42
|
+
## Sicherheitsverhalten bleibt fail-closed
|
|
43
|
+
|
|
44
|
+
Der Patch setzt den AppCenter nicht pauschal auf „frei“. Folgende Fälle sperren weiterhin zuverlässig:
|
|
45
|
+
|
|
46
|
+
- bestätigtes `authed=false`;
|
|
47
|
+
- fehlende Capability `appcenter.open`;
|
|
48
|
+
- nicht erreichbare Auth-Statusprüfung;
|
|
49
|
+
- echter Logout oder abgelaufene Session.
|
|
50
|
+
|
|
51
|
+
Der Hintergrund wird dabei wie bisher inert geschaltet, der Pflichtdialog kann nicht durch Außenklick oder Escape umgangen werden, und die serverseitigen Rollenprüfungen bleiben unverändert.
|
|
52
|
+
|
|
53
|
+
## Regressionstest
|
|
54
|
+
|
|
55
|
+
Der neue Stable-Test startet den realen AppCenter in Chromium mit:
|
|
56
|
+
|
|
57
|
+
- gültiger Home-Lizenz;
|
|
58
|
+
- angemeldetem Admin und Capability `*`;
|
|
59
|
+
- absichtlich verbliebenen Pro-Flags für Netzbetreiber, Mesh/Microgrid und Betriebsstrategien;
|
|
60
|
+
- einer simulierten fachlichen Antwort `403 eos_required`.
|
|
61
|
+
|
|
62
|
+
Geprüft wird:
|
|
63
|
+
|
|
64
|
+
- Home-Lizenz wird im AppCenter angezeigt;
|
|
65
|
+
- Login-Overlay bleibt geschlossen;
|
|
66
|
+
- Seite und Hintergrund bleiben entsperrt;
|
|
67
|
+
- AppCenter-DOM bleibt vollständig vorhanden;
|
|
68
|
+
- `/api/netoperator/drivers` wird unter Home nicht aufgerufen;
|
|
69
|
+
- eine manuell ausgelöste fachliche 403-Antwort verriegelt die Seite nicht;
|
|
70
|
+
- ein anschließend simulierter echter Sessionverlust mit 401 sperrt die Seite wieder fail-closed;
|
|
71
|
+
- keine Browser-Ausnahmen treten auf.
|
|
72
|
+
|
|
73
|
+
## Unveränderte Regelungsfunktionen
|
|
74
|
+
|
|
75
|
+
Der Patch betrifft ausschließlich Auth-Fehlerklassifizierung, Lizenzsichtbarkeit und Initialisierung von AppCenter-Komponenten. Unverändert bleiben insbesondere:
|
|
76
|
+
|
|
77
|
+
- NVP- und Netzanschlussregelung;
|
|
78
|
+
- Lade- und Lastmanagement;
|
|
79
|
+
- Speicher- und Speicherfarmregelung;
|
|
80
|
+
- Netzlimit, feste Einspeisebegrenzung und Nulleinspeisung;
|
|
81
|
+
- §14a, Tarife und Prognosen;
|
|
82
|
+
- Export Guard und Single-Writer-Struktur;
|
|
83
|
+
- EZA-/Parkregler-Priorität;
|
|
84
|
+
- sämtliche produktiven Hardware-Writer.
|
|
85
|
+
|
|
86
|
+
## Aktualisierung
|
|
87
|
+
|
|
88
|
+
Die Version aus einem neuen, leeren Ordner installieren, den Adapter vollständig neu starten und den Browser einmal mit `Strg+F5` neu laden. Der Service-Worker-Cache wurde auf `nexowatt-cache-v503` angehoben. Danach die Home-Lizenz aktivieren, als Admin anmelden und den AppCenter mehrfach öffnen. Er muss nach erfolgreicher Anmeldung dauerhaft geöffnet bleiben. Ein echter Logout muss die Seite anschließend wieder sperren.
|
|
@@ -0,0 +1,92 @@
|
|
|
1
|
+
# NexoWatt EOS 1.0.4 – offizielle Stable-Version
|
|
2
|
+
|
|
3
|
+
**Datum:** 2026-09-11
|
|
4
|
+
**Basis:** vollständiges Repository 1.0.3
|
|
5
|
+
|
|
6
|
+
## Verhalten
|
|
7
|
+
|
|
8
|
+
Die Kundenpriorität verteilt den physisch vorhandenen PV-Anteil zwischen Ladepunkten
|
|
9
|
+
und Speicher. Sie erzeugt weder zusätzliche PV-Leistung noch eine Netzladefreigabe.
|
|
10
|
+
Im PV-geführten Auto-Untermodus bleiben Start-/Stop-Hysterese, technische
|
|
11
|
+
Mindestleistung, gewählte Phasenart und alle Netz-/Stationsgrenzen verbindlich.
|
|
12
|
+
Unterhalb der fahrbaren Startleistung wird kein teilweiser Startanteil reserviert.
|
|
13
|
+
Der Speicher darf den kompletten ungenutzten Überschuss im Rahmen seiner Grenzen laden.
|
|
14
|
+
|
|
15
|
+
Ist im Automatikmodus Netzladen ausdrücklich freigegeben, bleibt der reguläre
|
|
16
|
+
Ladesollwert erhalten. Nur der nach anderen PV-/Min+PV-Ladepunkten noch verfügbare
|
|
17
|
+
PV-Anteil wird für den tatsächlich freigegebenen Auto-Ladebedarf reserviert.
|
|
18
|
+
Ein wartendes Fahrzeug ohne freigegebenen Sollwert blockiert keinen Auto-PV-Anteil.
|
|
19
|
+
Die Summe aller Reservierungen bleibt innerhalb des physischen PV-Budgets;
|
|
20
|
+
reines PV-Laden und Auto teilen dieselbe kundenseitige Obergrenze. Min+PV behält
|
|
21
|
+
seine netzgestützte technische Basis und den physischen PV-Zusatzanteil.
|
|
22
|
+
|
|
23
|
+
## Phasen und Übergabe
|
|
24
|
+
|
|
25
|
+
Die Runtime hat bisher individuelle Umschaltschwellen, Wartezeiten, Herstellerwerte
|
|
26
|
+
und laufende Phasen-Timer beim Aufruf der finalen TS-Phasenentscheidung verloren.
|
|
27
|
+
Diese Daten werden jetzt durchgängig weitergereicht. Fest 1p / fest 3p bleibt fest;
|
|
28
|
+
Auto 1p/3p benötigt einen passenden Schreibpfad. Während Stop/Umschaltung/Settle
|
|
29
|
+
bleiben Startreservierungen gesperrt. Bereits real fließende Leistung wird nicht
|
|
30
|
+
vorzeitig als frei angenommen. Nach Settle darf auf den aktuellen Phasen geladen
|
|
31
|
+
werden; der Cooldown verhindert nur einen weiteren Phasenwechsel.
|
|
32
|
+
|
|
33
|
+
Beim Hochschalten muss mindestens das konfigurierte 3p-Stromminimum verfügbar sein.
|
|
34
|
+
Die Strom-/Leistungsquantisierung und die gewählte aktuelle Phasenzahl werden im
|
|
35
|
+
bestehenden finalen Allocation- und Write-Plan geprüft. Ein Maximalwert unterhalb
|
|
36
|
+
der technischen Mindestleistung darf kein künstlich verkleinertes Startminimum ergeben.
|
|
37
|
+
|
|
38
|
+
Die PV-Rekonstruktion berücksichtigt auch laufende Speicherladung. Deshalb wird
|
|
39
|
+
PV-Potential nicht unsichtbar, nur weil der Speicher es vor einem EV-Start aufnimmt.
|
|
40
|
+
Frische Auto-Istleistung wird einbezogen, Netzbezug und Speicherentladung werden
|
|
41
|
+
weiterhin abgezogen. Sollwerte werden nicht als erzeugte PV-Leistung addiert.
|
|
42
|
+
|
|
43
|
+
## Diagnose
|
|
44
|
+
|
|
45
|
+
- chargingManagement.control.pvPriorityIncludesAuto
|
|
46
|
+
- chargingManagement.control.pvAutoPriorityReservedW
|
|
47
|
+
- chargingManagement.control.pvEvcsAutoPriorityMeasuredW
|
|
48
|
+
- chargingManagement.control.pvAutoPriorityJson
|
|
49
|
+
- vorhandene phaseSelectionJson / Phasenstatus / pvStartReservationW je Ladepunkt
|
|
50
|
+
|
|
51
|
+
Der alte DP pvPriorityPurePvOnly bleibt aus Kompatibilitätsgründen erhalten und ist false.
|
|
52
|
+
Keine zusätzliche unbeschränkte Historie, kein neuer schneller Poller, keine neuen
|
|
53
|
+
Produktionsabhängigkeiten. Die vorhandene begrenzte Diagnose-Publikation wird verwendet.
|
|
54
|
+
|
|
55
|
+
## Prüfumfang und Grenzen
|
|
56
|
+
|
|
57
|
+
Die Regression umfasst vollständige Regelticks mit echtem TS-Abschlussplan und
|
|
58
|
+
Executor gegen simulierte Datenpunkte, zusätzlich reine Budget-/Phasen-Pipeline-Tests.
|
|
59
|
+
Sie prüft Auto mit und ohne Netzfreigabe, feste 1p/3p, höhere Mindestströme, DC-
|
|
60
|
+
Mindestleistung, geteiltes PV-Budget, Leerlauf/Offline, Phasenwechsel und Settle.
|
|
61
|
+
Es wurde keine reale Wallbox oder reale Anlage angesteuert.
|
|
62
|
+
|
|
63
|
+
Auf der Kundenanlage müssen vor uneingeschränktem Betrieb Herstellerfreigabe für
|
|
64
|
+
Phasenwechsel, tatsächliche Phasenrückmeldung bzw. unterstützter Gerätevertrag,
|
|
65
|
+
Startgrenzen, Umschaltpause und Speicherübergabe kontrolliert überprüft werden.
|
|
66
|
+
Die Releasebezeichnung ist keine Zertifizierung und keine Aussage über einen
|
|
67
|
+
nicht durchgeführten Hardware-Dauertest.
|
|
68
|
+
|
|
69
|
+
|
|
70
|
+
## Ausgeführte Softwareprüfungen (11.09.2026)
|
|
71
|
+
|
|
72
|
+
- Node.js 22.16.0; TypeScript 5.8.3 (lokal vorhandenes Build-Werkzeug).
|
|
73
|
+
- Vollständiger `npm run build:ts`: erfolgreich, einschließlich 120 produktiver
|
|
74
|
+
Runtime-Dateien, 483 Runtime-Spiegel und TypeScript-Deklarationsbuild.
|
|
75
|
+
- Vollständiger `npm run test:all`: erfolgreich, einschließlich Browser-Regression
|
|
76
|
+
für den Home-AppCenter und der bestehenden Status-/Speicher-/Sicherheitsprüfungen.
|
|
77
|
+
- Neue Auto-/Phasen-Regression: 37 Szenariogruppen, einschließlich echter
|
|
78
|
+
Regeltick-/Executor-Codepfade mit simulierten Datenpunkten.
|
|
79
|
+
- Zusätzliche PV-Prioritäts-, zentrale Budget-, Speicherrest-, Min+PV- und
|
|
80
|
+
TS-Phasen-Regressionsprüfungen: erfolgreich.
|
|
81
|
+
- `publish:check`, `verify-publish.js`, Runtime-Start-Smoke und Stable-Release-Gate:
|
|
82
|
+
erfolgreich. Runtime-Start-Smoke prüft Syntax, lokale Imports und eine mit
|
|
83
|
+
Test-Doubles konstruierbare Startkette, keinen gestarteten Kunden-ioBroker.
|
|
84
|
+
- Paketdateien: 323 versiegelte Einträge; npm-Pakettrockenlauf: 324 Einträge.
|
|
85
|
+
|
|
86
|
+
Eine neue Online-Installation über `npm ci` konnte wegen DNS-/Registry-Zugriffsfehlern
|
|
87
|
+
(`EAI_AGAIN`) in der Prüfumgebung nicht abgeschlossen werden. Daher wurden die
|
|
88
|
+
Build-/Testwerkzeuge aus lokal vorhandenen Installationen verwendet. Produktions-
|
|
89
|
+
und Entwicklungsabhängigkeiten sind gegenüber 1.0.3 unverändert. Eine erfolgreiche
|
|
90
|
+
frische Abhängigkeitsinstallation oder ein Live-Hardware-Test wird nicht behauptet.
|
|
91
|
+
Die Versionsverfügbarkeit in npm ist vor Veröffentlichung separat zu prüfen; der
|
|
92
|
+
bestehende `prepublishOnly`-Guard führt diese Prüfung aus.
|
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
* AUTO-GENERATED RUNTIME FILE - NICHT MANUELL BEARBEITEN.
|
|
3
3
|
*
|
|
4
4
|
* Quelle: src-ts/runtime-executables/ems/modules/charging-management.ts
|
|
5
|
-
* Quell-Hash: sha256:
|
|
5
|
+
* Quell-Hash: sha256:545a9dc4df73467512fa8407e9446f7e5d20ba1aa2881e72b5783b9e02cd6429
|
|
6
6
|
* Erzeugung: npm run sync:ts-runtime-executables
|
|
7
7
|
*
|
|
8
8
|
* Zweck:
|
|
@@ -27,6 +27,7 @@ const { applySetpoint } = require('../consumers');
|
|
|
27
27
|
const { ReasonCodes } = require('../reasons');
|
|
28
28
|
const { computeChargingMinimumServicePlan, resolveAcChargingLimits } = require('../charging-budget-helpers');
|
|
29
29
|
const { recordAcceptedPowerTarget } = require('../services/accepted-power-effects');
|
|
30
|
+
const { buildAutoPvPriorityReservation } = require('../services/pv-surplus-allocation');
|
|
30
31
|
const { ChargingManagementAuditStore, finiteChargingAuditNumber, deriveChargingAuditLimiter, deriveChargingAuditGlobalLimiter, buildChargingAuditSnapshot, chargingAuditEventSignature, buildChargingAuditEvents } = require('../services/charging-management-audit');
|
|
31
32
|
const { Rc85EvcsDecisionGuard, rc85GridEnvelope, rc85OfflineReserveW, rc85IsHardReason, rc85RunIsolatedResult, rc86GridBinding } = require('../rc85-runtime-hardening');
|
|
32
33
|
const {
|
|
@@ -971,9 +972,10 @@ function computePendingPvStartIntentW({
|
|
|
971
972
|
// entsteht bewusst gar kein Pending-Intent. Der ungenutzte PV-Anteil bleibt
|
|
972
973
|
// dadurch im selben EMS-Zyklus fuer Speicher und nachgelagerte Verbraucher
|
|
973
974
|
// verfuegbar, statt als nicht fahrbare Teilreservierung liegen zu bleiben.
|
|
974
|
-
const startMinimumW = technicalW > 0
|
|
975
|
-
|
|
976
|
-
:
|
|
975
|
+
const startMinimumW = technicalW > 0 ? technicalW : Math.max(thresholdW, minW);
|
|
976
|
+
if (maxW + 1e-6 < startMinimumW) {
|
|
977
|
+
return { intentW: 0, totalDemandW: 0, reason: 'below-technical-minimum' };
|
|
978
|
+
}
|
|
977
979
|
if (!isAlreadyActive) {
|
|
978
980
|
const startAvailableW = Math.max(0, Math.min(potentialTotalW, pvAvailW));
|
|
979
981
|
if (startMinimumW > 0 && startAvailableW + 1e-6 < startMinimumW) {
|
|
@@ -3265,6 +3267,21 @@ class ChargingManagementModule extends BaseModule {
|
|
|
3265
3267
|
phaseSwitchCommandAllowed: w && w.phaseSwitchCommandAllowed,
|
|
3266
3268
|
phaseSwitchKey: w && w.phaseSwitchKey,
|
|
3267
3269
|
phaseSwitchValue: w && w.phaseSwitchValue,
|
|
3270
|
+
// Preserve the actual per-point phase contract, not only global defaults.
|
|
3271
|
+
supportsPhaseSwitch: !!(w && w.phaseSwitchKey),
|
|
3272
|
+
phaseSwitchValue1p: w && w.phaseSwitchValue1p,
|
|
3273
|
+
phaseSwitchValue3p: w && w.phaseSwitchValue3p,
|
|
3274
|
+
switchUpThresholdW: w && w.phaseSwitchUpThresholdW,
|
|
3275
|
+
switchDownThresholdW: w && w.phaseSwitchDownThresholdW,
|
|
3276
|
+
switchUpStableMs: w && w.phaseSwitchUpStableMs,
|
|
3277
|
+
switchDownStableMs: w && w.phaseSwitchDownStableMs,
|
|
3278
|
+
switchCooldownMs: w && w.phaseSwitchCooldownMs,
|
|
3279
|
+
switchSettleMs: w && w.phaseSwitchSettleMs,
|
|
3280
|
+
switchSafePowerW: w && w.phaseSwitchSafePowerW,
|
|
3281
|
+
highSinceMs: w && w.highSinceMs,
|
|
3282
|
+
lowSinceMs: w && w.lowSinceMs,
|
|
3283
|
+
cooldownUntilMs: w && w.cooldownUntilMs,
|
|
3284
|
+
settleUntilMs: w && w.settleUntilMs,
|
|
3268
3285
|
phaseSwitchReason: w && w.phaseSwitchReason,
|
|
3269
3286
|
phaseSwitchSafetyStopRequired: w && w.phaseSwitchSafetyStopRequired,
|
|
3270
3287
|
phaseSwitchCooldownRemainingMs: w && w.phaseSwitchCooldownRemainingMs,
|
|
@@ -3412,6 +3429,7 @@ class ChargingManagementModule extends BaseModule {
|
|
|
3412
3429
|
let reserveW = 0;
|
|
3413
3430
|
let pvReserveW = 0;
|
|
3414
3431
|
let pvIntentW = 0;
|
|
3432
|
+
let purePvIntentW = 0;
|
|
3415
3433
|
let activeDemandWallboxes = 0;
|
|
3416
3434
|
|
|
3417
3435
|
for (const plan of plans) {
|
|
@@ -3473,6 +3491,7 @@ class ChargingManagementModule extends BaseModule {
|
|
|
3473
3491
|
reserveW += reserveThisW;
|
|
3474
3492
|
pvReserveW += Math.min(reserveThisW, finalPvUsedW);
|
|
3475
3493
|
pvIntentW += computePvManagedDemandIntentW(effectiveMode, reserveThisW, minPowerW);
|
|
3494
|
+
if (effectiveMode === 'pv') purePvIntentW += reserveThisW;
|
|
3476
3495
|
activeDemandWallboxes += 1;
|
|
3477
3496
|
}
|
|
3478
3497
|
|
|
@@ -3482,6 +3501,7 @@ class ChargingManagementModule extends BaseModule {
|
|
|
3482
3501
|
reserveW: Math.max(0, Math.round(reserveW)),
|
|
3483
3502
|
pvReserveW: Math.max(0, Math.round(pvReserveW)),
|
|
3484
3503
|
pvIntentW: Math.max(0, Math.round(pvIntentW)),
|
|
3504
|
+
purePvIntentW: Math.max(0, Math.round(purePvIntentW)),
|
|
3485
3505
|
activeDemandWallboxes,
|
|
3486
3506
|
};
|
|
3487
3507
|
} catch (_eFinalAllocationMetrics) {
|
|
@@ -3489,6 +3509,37 @@ class ChargingManagementModule extends BaseModule {
|
|
|
3489
3509
|
}
|
|
3490
3510
|
}
|
|
3491
3511
|
|
|
3512
|
+
/** Attribute only the PV share of final, phase-checked Auto targets. */
|
|
3513
|
+
_buildAutoPvPriorityMetrics(allocationState, wbList, options) {
|
|
3514
|
+
const decision = allocationState && (allocationState.normalSourceDecision?.apply
|
|
3515
|
+
? allocationState.normalSourceDecision : allocationState.productiveDecision);
|
|
3516
|
+
const plans = decision && Array.isArray(decision.apply?.wallboxes) ? decision.apply.wallboxes : [];
|
|
3517
|
+
const bySafe = new Map((wbList || []).filter(w => w && w.safe).map(w => [String(w.safe), w]));
|
|
3518
|
+
const points = plans.map(plan => {
|
|
3519
|
+
const w = bySafe.get(String(plan.safe)) || {};
|
|
3520
|
+
const factor = Math.max(1, Number(plan.phases) || 1) * Math.max(1, Number(plan.voltageV) || 230);
|
|
3521
|
+
const basisCurrent = ['current', 'currentA'].includes(String(plan.controlBasis));
|
|
3522
|
+
const step = basisCurrent ? (Number(plan.stepA) || 0.1) : (Number(plan.stepW) || 1);
|
|
3523
|
+
const minRaw = basisCurrent ? Math.max(Number(plan.minA) || 0, (Number(plan.minPowerW) || 0) / factor)
|
|
3524
|
+
: Math.max(0, Number(plan.minPowerW) || 0);
|
|
3525
|
+
const technicalMinimumW = Math.ceil((minRaw - 1e-9) / step) * step * (basisCurrent ? factor : 1);
|
|
3526
|
+
return {
|
|
3527
|
+
safe: String(plan.safe), userMode: String(w.userMode || plan.userMode || 'auto'),
|
|
3528
|
+
effectiveMode: String(plan.effectiveMode || w.effectiveMode || ''),
|
|
3529
|
+
enabled: w.enabled !== false && plan.enabled !== false,
|
|
3530
|
+
online: w.online === true && plan.online === true,
|
|
3531
|
+
demandConfirmed: w.vehicleDemandConfirmed === true || plan.demandConfirmed === true,
|
|
3532
|
+
startProbeActive: w.vehicleStartProbeActive === true || plan.vehicleStartProbeActive === true,
|
|
3533
|
+
actualFresh: w.meterStale !== true && plan.staleAny !== true,
|
|
3534
|
+
actualW: Math.max(0, Number(w.actualPowerW) || 0),
|
|
3535
|
+
finalTargetW: Math.max(0, Number(plan.targetPowerW) || 0),
|
|
3536
|
+
technicalMinimumW,
|
|
3537
|
+
phaseTransition: plan.phaseSwitchRequired === true || plan.phaseSwitchSafetyStopRequired === true,
|
|
3538
|
+
};
|
|
3539
|
+
});
|
|
3540
|
+
return buildAutoPvPriorityReservation({ ...options, points });
|
|
3541
|
+
}
|
|
3542
|
+
|
|
3492
3543
|
/** Code-Teil: _publishChargingPhaseSelectionRuntimeStates – Übernimmt Hysterese-/Cooldown-Zustände aus der TS-Phasenwahl und veröffentlicht lesbare Diagnose pro Ladepunkt. */
|
|
3493
3544
|
async _publishChargingPhaseSelectionRuntimeStates(phasePlan, wbList) {
|
|
3494
3545
|
const decisions = phasePlan && Array.isArray(phasePlan.wallboxes) ? phasePlan.wallboxes : [];
|
|
@@ -5061,7 +5112,11 @@ class ChargingManagementModule extends BaseModule {
|
|
|
5061
5112
|
await mk('chargingManagement.control.pvCapEffectiveW', 'Pure-PV customer-priority cap after hysteresis (W)', 'number', 'value.power');
|
|
5062
5113
|
await mk('chargingManagement.control.pvPureCapW', 'Pure-PV customer-priority cap (W)', 'number', 'value.power');
|
|
5063
5114
|
await mk('chargingManagement.control.pvPhysicalCapW', 'Physical PV cap for PV and Min+PV extra power (W)', 'number', 'value.power');
|
|
5064
|
-
await mk('chargingManagement.control.pvPriorityPurePvOnly', '
|
|
5115
|
+
await mk('chargingManagement.control.pvPriorityPurePvOnly', 'Legacy indicator: PV priority restricted to pure PV', 'boolean', 'indicator');
|
|
5116
|
+
await mk('chargingManagement.control.pvPriorityIncludesAuto', 'Customer PV priority includes Auto PV share', 'boolean', 'indicator');
|
|
5117
|
+
await mk('chargingManagement.control.pvAutoPriorityReservedW', 'PV share reserved by final Auto charging targets (W)', 'number', 'value.power');
|
|
5118
|
+
await mk('chargingManagement.control.pvEvcsAutoPriorityMeasuredW', 'Fresh Auto power used in physical PV reconstruction (W)', 'number', 'value.power');
|
|
5119
|
+
await mk('chargingManagement.control.pvAutoPriorityJson', 'Auto PV share and phase-aware start diagnostics', 'string', 'json');
|
|
5065
5120
|
await mk('chargingManagement.control.pvAvailable', 'PV available (hysteresis)', 'boolean', 'indicator');
|
|
5066
5121
|
await mk('chargingManagement.control.pvAllocationMode', 'PV surplus allocation mode', 'string', 'text');
|
|
5067
5122
|
await mk('chargingManagement.control.pvAllocationEvcsSharePct', 'PV surplus EVCS share (%)', 'number', 'value.percent');
|
|
@@ -8411,6 +8466,7 @@ class ChargingManagementModule extends BaseModule {
|
|
|
8411
8466
|
let pvEvcsCmdW = 0;
|
|
8412
8467
|
let pvEvcsUsedW = 0;
|
|
8413
8468
|
let pvEvcsPhysicalPvManagedW = 0;
|
|
8469
|
+
let pvEvcsAutoPriorityMeasuredW = 0;
|
|
8414
8470
|
|
|
8415
8471
|
try {
|
|
8416
8472
|
for (const w of wbList) {
|
|
@@ -8423,12 +8479,16 @@ class ChargingManagementModule extends BaseModule {
|
|
|
8423
8479
|
pvEvcsActualW += a;
|
|
8424
8480
|
|
|
8425
8481
|
// Fuer die zentrale physikalische PV-Rekonstruktion zaehlt nur
|
|
8426
|
-
// gemessene Leistung von PV-/Min+PV-Ladepunkten.
|
|
8427
|
-
//
|
|
8428
|
-
//
|
|
8482
|
+
// gemessene Leistung von PV-/Min+PV- sowie Auto-Ladepunkten.
|
|
8483
|
+
// Auto wird danach mit seinem tatsaechlichen PV-Anteil reserviert;
|
|
8484
|
+
// Boost bleibt ausserhalb der Kundenaufteilung. Kommandowerte werden hier bewusst
|
|
8429
8485
|
// nicht verwendet; der NVP bildet den realen Leistungsfluss ab.
|
|
8430
8486
|
const effectiveMode = String(w.effectiveMode || '').trim().toLowerCase();
|
|
8431
|
-
if (effectiveMode === '
|
|
8487
|
+
if ((effectiveMode === 'normal' || effectiveMode === 'auto')
|
|
8488
|
+
&& normalizeWallboxModeOverride(w.userMode) === 'auto' && w.meterStale !== true) {
|
|
8489
|
+
pvEvcsPhysicalPvManagedW += a;
|
|
8490
|
+
pvEvcsAutoPriorityMeasuredW += a;
|
|
8491
|
+
} else if (effectiveMode === 'pv') {
|
|
8432
8492
|
pvEvcsPhysicalPvManagedW += a;
|
|
8433
8493
|
} else if (effectiveMode === 'minpv') {
|
|
8434
8494
|
// Min+PV-Grundlast kommt aus dem normalen Gesamt-/Netzbudget.
|
|
@@ -8478,6 +8538,7 @@ class ChargingManagementModule extends BaseModule {
|
|
|
8478
8538
|
await this._queueState('chargingManagement.control.pvEvcsCmdW', Math.round(pvEvcsCmdW || 0), true);
|
|
8479
8539
|
await this._queueState('chargingManagement.control.pvEvcsUsedW', Math.round(pvEvcsUsedW || 0), true);
|
|
8480
8540
|
await this._queueState('chargingManagement.control.pvEvcsPhysicalPvManagedW', Math.round(pvEvcsPhysicalPvManagedW || 0), true);
|
|
8541
|
+
await this._queueState('chargingManagement.control.pvEvcsAutoPriorityMeasuredW', Math.round(pvEvcsAutoPriorityMeasuredW || 0), true);
|
|
8481
8542
|
} catch {
|
|
8482
8543
|
// ignore
|
|
8483
8544
|
}
|
|
@@ -8789,7 +8850,8 @@ class ChargingManagementModule extends BaseModule {
|
|
|
8789
8850
|
await this._queueState('chargingManagement.control.pvCapEffectiveW', pvCapEffectiveWState || 0, true);
|
|
8790
8851
|
await this._queueState('chargingManagement.control.pvPureCapW', pvPureCapWState || 0, true);
|
|
8791
8852
|
await this._queueState('chargingManagement.control.pvPhysicalCapW', pvPhysicalCapWState || 0, true);
|
|
8792
|
-
await this._queueState('chargingManagement.control.pvPriorityPurePvOnly',
|
|
8853
|
+
await this._queueState('chargingManagement.control.pvPriorityPurePvOnly', false, true);
|
|
8854
|
+
await this._queueState('chargingManagement.control.pvPriorityIncludesAuto', true, true);
|
|
8793
8855
|
await this._queueState('chargingManagement.control.pvAvailable', !!pvAvailableState, true);
|
|
8794
8856
|
await this._queueState('chargingManagement.control.pvSurplusNoEvRawW', pvSurplusNoEvRawWState || 0, true);
|
|
8795
8857
|
await this._queueState('chargingManagement.control.pvSurplusNoEvAvg5mW', pvSurplusNoEvAvg5mWState || 0, true);
|
|
@@ -8912,7 +8974,8 @@ if (components.length) {
|
|
|
8912
8974
|
pvCapEffectiveW: (typeof pvCapEffectiveWState === 'number' && Number.isFinite(pvCapEffectiveWState)) ? pvCapEffectiveWState : null,
|
|
8913
8975
|
pvPureCapW: (typeof pvPureCapWState === 'number' && Number.isFinite(pvPureCapWState)) ? pvPureCapWState : null,
|
|
8914
8976
|
pvPhysicalCapW: (typeof pvPhysicalCapWState === 'number' && Number.isFinite(pvPhysicalCapWState)) ? pvPhysicalCapWState : null,
|
|
8915
|
-
pvPriorityPurePvOnly:
|
|
8977
|
+
pvPriorityPurePvOnly: false,
|
|
8978
|
+
pvPriorityIncludesAuto: true,
|
|
8916
8979
|
pvAvailable: !!pvAvailableState,
|
|
8917
8980
|
gridW: (typeof gridW === 'number' && Number.isFinite(gridW)) ? gridW : null,
|
|
8918
8981
|
gridImportNoEvW: (typeof gridImportNoEvW === 'number' && Number.isFinite(gridImportNoEvW)) ? gridImportNoEvW : null,
|
|
@@ -11792,9 +11855,21 @@ if (components.length) {
|
|
|
11792
11855
|
: 0;
|
|
11793
11856
|
const commandNowW = Math.max(0, Number(row.targetW) || 0);
|
|
11794
11857
|
const demandNowW = Math.max(0, Number(row.demandReserveW) || 0, actualNowW, commandNowW);
|
|
11795
|
-
|
|
11858
|
+
let technicalMinW = (w.chargerType === 'AC' && Number(w.phases || 0) === 3)
|
|
11796
11859
|
? Math.max(0, Math.max(num(w.minPW, 0), acMinPower3pW))
|
|
11797
11860
|
: Math.max(0, num(w.minPW, 0));
|
|
11861
|
+
// Reserve only a start that can actually be represented by this
|
|
11862
|
+
// charger's command step. Rounding down would hold PV for a
|
|
11863
|
+
// command which the final technical-minimum guard must stop.
|
|
11864
|
+
if (w.controlBasis === 'currentA' && w.chargerType === 'AC') {
|
|
11865
|
+
const factor = Math.max(1, num(w.phases, 3)) * Math.max(1, num(w.voltageV, 230));
|
|
11866
|
+
const stepA = num(w.stepA, 0) > 0 ? num(w.stepA, 0) : 0.1;
|
|
11867
|
+
const startA = Math.max(num(w.minA, 0), technicalMinW / factor);
|
|
11868
|
+
technicalMinW = Math.ceil((startA - 1e-9) / stepA) * stepA * factor;
|
|
11869
|
+
} else if (technicalMinW > 0) {
|
|
11870
|
+
const stepW = num(w.stepW, 0) > 0 ? num(w.stepW, 0) : 1;
|
|
11871
|
+
technicalMinW = Math.ceil((technicalMinW - 1e-9) / stepW) * stepW;
|
|
11872
|
+
}
|
|
11798
11873
|
const minPvBaseW = effMode === 'minpv'
|
|
11799
11874
|
? Math.max(
|
|
11800
11875
|
0,
|
|
@@ -11884,8 +11959,8 @@ if (components.length) {
|
|
|
11884
11959
|
let evcsControlReserveW = Math.max(0, Math.round(evcsActiveDemandReserveW));
|
|
11885
11960
|
let evcsControlPvReserveW = Math.max(0, Math.round(evcsActiveDemandPvReserveW));
|
|
11886
11961
|
let evcsControlPvIntentW = Math.max(0, Math.round(evcsActiveDemandPvIntentW));
|
|
11887
|
-
|
|
11888
|
-
|
|
11962
|
+
let evcsControlPendingPvIntentW = Math.max(0, Math.round(evcsPendingDemandPvIntentW));
|
|
11963
|
+
let evcsControlPendingDemandW = Math.max(0, Math.round(evcsPendingDemandTotalW));
|
|
11889
11964
|
let evcsControlTotalPvIntentW = Math.max(0, evcsControlPvIntentW + evcsControlPendingPvIntentW);
|
|
11890
11965
|
let evcsControlRemainingW = Number.isFinite(budgetW)
|
|
11891
11966
|
? Math.max(0, Math.round(Number(budgetW) - evcsControlReserveW))
|
|
@@ -12025,7 +12100,46 @@ if (components.length) {
|
|
|
12025
12100
|
evcsControlReserveW = finalAllocationMetrics.reserveW;
|
|
12026
12101
|
evcsControlPvReserveW = finalAllocationMetrics.pvReserveW;
|
|
12027
12102
|
evcsControlPvIntentW = finalAllocationMetrics.pvIntentW;
|
|
12103
|
+
// A tentative start was calculated before the final phase plan. It may
|
|
12104
|
+
// not reserve PV while the same plan orders stop/switch/settle.
|
|
12105
|
+
const phaseBySafe = new Map((tsAllocationState?.phasePlan?.wallboxes || []).map(p => [String(p.safe), p]));
|
|
12106
|
+
const finalDecision = tsAllocationState?.normalSourceDecision?.apply
|
|
12107
|
+
? tsAllocationState.normalSourceDecision : tsAllocationState?.productiveDecision;
|
|
12108
|
+
const finalBySafe = new Map((finalDecision?.apply?.wallboxes || []).map(p => [String(p.safe), p]));
|
|
12109
|
+
for (const row of debugAlloc) {
|
|
12110
|
+
if (!row || !(Number(row.pendingPvIntentTotalDemandW) > 0)) continue;
|
|
12111
|
+
const phase = phaseBySafe.get(String(row.safe));
|
|
12112
|
+
const final = finalBySafe.get(String(row.safe));
|
|
12113
|
+
const phaseBlocked = !!(phase && (phase.switchRequired || phase.safetyStopRequired || Number(phase.settleUntilMs) > now));
|
|
12114
|
+
// A ramp intent based on a raw command ceases to be real demand
|
|
12115
|
+
// when the final phase/technical/cap guard has rejected that start.
|
|
12116
|
+
// Preserve genuine start-minimum intents calculated from idle.
|
|
12117
|
+
const rawStartRejected = !!(final && Number(row.targetW) >= activityThresholdW
|
|
12118
|
+
&& !(Number(final.targetPowerW) > 0)
|
|
12119
|
+
&& !(row.meterStale !== true && Number(row.actualPowerW) >= activityThresholdW));
|
|
12120
|
+
if (!phaseBlocked && !rawStartRejected) continue;
|
|
12121
|
+
evcsControlPendingPvIntentW = Math.max(0, evcsControlPendingPvIntentW - (Number(row.pendingPvIntentW) || 0));
|
|
12122
|
+
evcsControlPendingDemandW = Math.max(0, evcsControlPendingDemandW - (Number(row.pendingPvIntentTotalDemandW) || 0));
|
|
12123
|
+
if (String(row.effectiveMode || '') === 'pv') {
|
|
12124
|
+
evcsPendingDemandPurePvIntentW = Math.max(0, evcsPendingDemandPurePvIntentW - (Number(row.pendingPvIntentW) || 0));
|
|
12125
|
+
}
|
|
12126
|
+
row.pendingPvIntentW = 0;
|
|
12127
|
+
row.pendingPvIntentTotalDemandW = 0;
|
|
12128
|
+
row.pendingPvIntentReason = phaseBlocked ? 'phase-transition-no-start-reservation' : 'final-plan-no-runnable-demand';
|
|
12129
|
+
const point = wbList.find(w => String(w.safe) === String(row.safe));
|
|
12130
|
+
if (point?.ch) await this._queueState(`${point.ch}.pvStartReservationW`, 0, true);
|
|
12131
|
+
}
|
|
12132
|
+
const autoPvMetrics = this._buildAutoPvPriorityMetrics(tsAllocationState, wbList, {
|
|
12133
|
+
priorityCapW: Math.max(0, Number(pvStartReadyBudgetW) || 0),
|
|
12134
|
+
physicalCapW: Math.max(0, Number(pvPhysicalCapW) || 0),
|
|
12135
|
+
otherPriorityReservedW: finalAllocationMetrics.purePvIntentW + Math.max(0, evcsPendingDemandPurePvIntentW),
|
|
12136
|
+
otherPhysicalReservedW: Math.max(evcsControlPvIntentW, evcsControlPvReserveW) + evcsControlPendingPvIntentW,
|
|
12137
|
+
});
|
|
12138
|
+
evcsControlPvReserveW += autoPvMetrics.reservedW;
|
|
12139
|
+
evcsControlPvIntentW += autoPvMetrics.reservedW;
|
|
12028
12140
|
evcsControlTotalPvIntentW = Math.max(0, evcsControlPvIntentW + evcsControlPendingPvIntentW);
|
|
12141
|
+
await this._queueState('chargingManagement.control.pvAutoPriorityReservedW', autoPvMetrics.reservedW, true);
|
|
12142
|
+
await this._queueState('chargingManagement.control.pvAutoPriorityJson', JSON.stringify(autoPvMetrics), true);
|
|
12029
12143
|
evcsControlRemainingW = Number.isFinite(budgetW)
|
|
12030
12144
|
? Math.max(0, Math.round(Number(budgetW) - evcsControlReserveW))
|
|
12031
12145
|
: 0;
|
|
@@ -12042,6 +12156,8 @@ if (components.length) {
|
|
|
12042
12156
|
budgetDebug.evcsFinalTargetPowerW = totalTargetPowerW;
|
|
12043
12157
|
budgetDebug.evcsFinalTargetCurrentA = totalTargetCurrentA;
|
|
12044
12158
|
budgetDebug.evcsFinalAllocationSource = 'ts-final-allocation-plan';
|
|
12159
|
+
budgetDebug.evcsPendingDemandPvIntentW = evcsControlPendingPvIntentW;
|
|
12160
|
+
budgetDebug.evcsPendingDemandReserveW = evcsControlPendingDemandW;
|
|
12045
12161
|
}
|
|
12046
12162
|
const budgetEntry = debugAlloc.find(a => a && a.type === 'budget');
|
|
12047
12163
|
if (budgetEntry && budgetEntry.details && typeof budgetEntry.details === 'object') {
|
|
@@ -12054,6 +12170,8 @@ if (components.length) {
|
|
|
12054
12170
|
budgetEntry.details.evcsFinalTargetPowerW = totalTargetPowerW;
|
|
12055
12171
|
budgetEntry.details.evcsFinalTargetCurrentA = totalTargetCurrentA;
|
|
12056
12172
|
budgetEntry.details.evcsFinalAllocationSource = 'ts-final-allocation-plan';
|
|
12173
|
+
budgetEntry.details.evcsPendingDemandPvIntentW = evcsControlPendingPvIntentW;
|
|
12174
|
+
budgetEntry.details.evcsPendingDemandReserveW = evcsControlPendingDemandW;
|
|
12057
12175
|
}
|
|
12058
12176
|
} catch (_eFinalAllocationDiagnostics) {
|
|
12059
12177
|
// diagnostics only
|
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
* AUTO-GENERATED RUNTIME FILE - NICHT MANUELL BEARBEITEN.
|
|
3
3
|
*
|
|
4
4
|
* Quelle: src-ts/runtime-executables/ems/services/pv-surplus-allocation.ts
|
|
5
|
-
* Quell-Hash: sha256:
|
|
5
|
+
* Quell-Hash: sha256:c40ddc55073801b8239d0ea483bcc905ff6ea37e947009d2bf67ccf155b23b88
|
|
6
6
|
* Erzeugung: npm run sync:ts-runtime-executables
|
|
7
7
|
*
|
|
8
8
|
* Zweck:
|
|
@@ -19,6 +19,7 @@
|
|
|
19
19
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
20
20
|
exports.normalizePvSurplusPriority = normalizePvSurplusPriority;
|
|
21
21
|
exports.buildPvSurplusAllocation = buildPvSurplusAllocation;
|
|
22
|
+
exports.buildAutoPvPriorityReservation = buildAutoPvPriorityReservation;
|
|
22
23
|
function clamp(value, min, max, fallback) {
|
|
23
24
|
const n = Number(value);
|
|
24
25
|
return Number.isFinite(n) ? Math.max(min, Math.min(max, n)) : fallback;
|
|
@@ -72,4 +73,55 @@ function buildPvSurplusAllocation(totalW, modeRaw, evcsSharePctRaw, options = {}
|
|
|
72
73
|
reason,
|
|
73
74
|
};
|
|
74
75
|
}
|
|
75
|
-
|
|
76
|
+
/**
|
|
77
|
+
* Attribution only: never creates a charging command or a grid permission.
|
|
78
|
+
* PV-driven Auto is already effectiveMode=pv and uses the existing phase-aware
|
|
79
|
+
* PV allocator. Grid-enabled Auto may use a partial PV share, but only after
|
|
80
|
+
* the final safety/phase/minimum guard has approved a runnable target.
|
|
81
|
+
* No provisional Auto start or rated charger power is reserved here.
|
|
82
|
+
*/
|
|
83
|
+
function buildAutoPvPriorityReservation(input) {
|
|
84
|
+
const positiveW = (v) => Math.max(0, Number.isFinite(Number(v)) ? Number(v) : 0);
|
|
85
|
+
let priorityRemainingW = Math.max(0, positiveW(input.priorityCapW) - positiveW(input.otherPriorityReservedW));
|
|
86
|
+
let physicalRemainingW = Math.max(0, positiveW(input.physicalCapW) - positiveW(input.otherPhysicalReservedW));
|
|
87
|
+
let reservedW = 0;
|
|
88
|
+
const rows = [];
|
|
89
|
+
for (const point of input.points) {
|
|
90
|
+
const mode = String(point.effectiveMode || '').toLowerCase();
|
|
91
|
+
const userMode = String(point.userMode || 'auto').toLowerCase();
|
|
92
|
+
const minimumW = positiveW(point.technicalMinimumW);
|
|
93
|
+
let claimW = 0;
|
|
94
|
+
let reason = 'not-auto-grid-mode';
|
|
95
|
+
if (userMode === 'auto' && (mode === 'auto' || mode === 'normal')) {
|
|
96
|
+
reason = 'no-runnable-demand';
|
|
97
|
+
if (point.enabled && point.online) {
|
|
98
|
+
// Real, fresh power continues to occupy PV during a controlled stop.
|
|
99
|
+
// A switch request cannot make an actually flowing load disappear.
|
|
100
|
+
const actualW = point.actualFresh ? positiveW(point.actualW) : 0;
|
|
101
|
+
const targetW = !point.phaseTransition && (point.demandConfirmed || point.startProbeActive)
|
|
102
|
+
? positiveW(point.finalTargetW) : 0;
|
|
103
|
+
const runnableTargetW = targetW > 0 && targetW + 1e-6 >= minimumW ? targetW : 0;
|
|
104
|
+
const demandW = Math.max(actualW, runnableTargetW);
|
|
105
|
+
claimW = Math.min(demandW, priorityRemainingW, physicalRemainingW);
|
|
106
|
+
if (claimW > 0)
|
|
107
|
+
reason = 'auto-pv-share-of-approved-load';
|
|
108
|
+
else if (point.phaseTransition)
|
|
109
|
+
reason = 'phase-transition-no-start-reservation';
|
|
110
|
+
else if (targetW > 0 && runnableTargetW === 0)
|
|
111
|
+
reason = 'below-technical-minimum';
|
|
112
|
+
else if (demandW > 0)
|
|
113
|
+
reason = 'no-pv-priority-remainder';
|
|
114
|
+
}
|
|
115
|
+
else
|
|
116
|
+
reason = 'not-available';
|
|
117
|
+
}
|
|
118
|
+
// Round down so neither the physical nor the customer cap can be exceeded.
|
|
119
|
+
claimW = Math.floor(Math.max(0, claimW));
|
|
120
|
+
priorityRemainingW = Math.max(0, priorityRemainingW - claimW);
|
|
121
|
+
physicalRemainingW = Math.max(0, physicalRemainingW - claimW);
|
|
122
|
+
reservedW += claimW;
|
|
123
|
+
rows.push({ safe: point.safe, reservedW: claimW, minimumW, reason });
|
|
124
|
+
}
|
|
125
|
+
return { reservedW, remainingPriorityW: priorityRemainingW, rows };
|
|
126
|
+
}
|
|
127
|
+
module.exports = { normalizePvSurplusPriority, buildPvSurplusAllocation, buildAutoPvPriorityReservation };
|
package/io-package.json
CHANGED
|
@@ -1,8 +1,18 @@
|
|
|
1
1
|
{
|
|
2
2
|
"common": {
|
|
3
3
|
"name": "nexowatt-ui",
|
|
4
|
-
"version": "1.0.
|
|
4
|
+
"version": "1.0.4",
|
|
5
5
|
"news": {
|
|
6
|
+
"1.0.4": {
|
|
7
|
+
"en": "Auto PV priority respects approved charging demand, actual phases and technical start power. Unusable PV remains available to storage. Per-point phase switch thresholds, manufacturer values and settling are preserved.",
|
|
8
|
+
"de": "PV-Priorisierung berücksichtigt Auto-Ladebedarf, tatsächliche Phasen und Startleistung. Nicht nutzbarer PV-Anteil bleibt beim Speicher. Individuelle Phasenumschaltwerte, Wartezeiten und Einschwingzeit werden durchgängig berücksichtigt.",
|
|
9
|
+
"nl": "PV-prioriteit houdt rekening met Auto-laadbehoefte, werkelijke fasen en startvermogen. Onbenutte PV blijft beschikbaar voor de batterij. Fase-instellingen en wachttijden blijven behouden."
|
|
10
|
+
},
|
|
11
|
+
"1.0.3": {
|
|
12
|
+
"de": "Stable 1.0.3 behebt die sofortige erneute AppCenter-Sperre bei einer gültigen Home-Lizenz. Fachliche 403-Antworten nicht lizenzierter Pro-Module werden nicht mehr als verlorene Anmeldung interpretiert. Alte Pro-Konfigurationsflags werden für Home vor der UI-Ausgabe maskiert und Pro-only Komponenten nicht initialisiert. Ein echter Sessionverlust oder fehlende Seitenberechtigung sperrt den AppCenter weiterhin sicher. EMS-, Netzlimit-, Lade-, Speicher-, §14a-, Tarif-, Export-Guard- und Hardware-Regelung bleiben unverändert.",
|
|
13
|
+
"en": "Stable 1.0.3 fixes the AppCenter being immediately locked again with a valid Home license. Business-level 403 responses from unlicensed Pro modules are no longer interpreted as a lost login session. Stale Pro configuration flags are masked before Home UI delivery and Pro-only components are not initialized. A genuine session loss or missing page capability still locks the AppCenter fail-closed. EMS, grid limit, charging, storage, §14a, tariff, export guard and hardware control remain unchanged.",
|
|
14
|
+
"nl": "Stable 1.0.3 verhelpt dat het AppCenter direct opnieuw werd vergrendeld bij een geldige Home-licentie. Functionele 403-antwoorden van niet-gelicentieerde Pro-modules worden niet langer als een verloren aanmelding geïnterpreteerd. Oude Pro-configuratievlaggen worden vóór de Home-UI gemaskeerd en Pro-only componenten worden niet geïnitialiseerd. Een werkelijk verlopen sessie of ontbrekende paginabevoegdheid vergrendelt het AppCenter nog steeds veilig. EMS-, netlimiet-, laad-, opslag-, §14a-, tarief-, exportguard- en hardwarebesturing blijven ongewijzigd."
|
|
15
|
+
},
|
|
6
16
|
"1.0.2": {
|
|
7
17
|
"de": "Stable 1.0.2 trennt Adapter-Erreichbarkeit, EMS-Scheduler, Regelzyklus und Diagnose-Publisher eindeutig. Unabhängige 4-Sekunden-Heartbeats verhindern die falsche Anzeige „Offline / veraltet“ bei legitimen 20–30-Sekunden-Regelzyklen. Ein über 30 Sekunden laufender Zyklus wird als Warnung „Regelzyklus überschreitet Zeitlimit“ angezeigt, während ein gestoppter Adapter oder HTTP-Dienst weiterhin zuverlässig offline wird. Netzlimit, Nulleinspeisung, Lade-, Speicher-, §14a-, Tarif-, Export-Guard- und Hardware-Regelung bleiben unverändert.",
|
|
8
18
|
"en": "Stable 1.0.2 clearly separates adapter connectivity, EMS scheduler liveness, regulation-cycle health and the diagnostic publisher. Independent four-second heartbeats prevent false Offline/Stale indications during legitimate 20–30 second control cycles. A cycle running beyond 30 seconds is shown as a regulation timeout warning, while a stopped adapter or HTTP service is still reliably reported offline. Grid limit, zero export, charging, storage, §14a, tariff, export guard and hardware control remain unchanged.",
|
|
@@ -27,16 +37,6 @@
|
|
|
27
37
|
"de": "RC91 gleicht die App-Kataloge von Browser, Adapterstart, Installer, Save und Backup vollständig ab. Energy Ledger und Mesh/Microgrid behalten ihre Installiert-/Aktiv-Zustände jetzt auch beim Speichern anderer AppCenter-Reiter; das verborgene DC-Stationsdisplay bleibt erhalten, ohne doppelte App-Karte. Zusätzlich bleibt die textstabil erzeugte main.js strikt JavaScript-kompatibel. Die produktive NVP-, Lade-, Speicher-, Tarif-, §14a- und Safety-Regelung wurde nicht verändert.",
|
|
28
38
|
"en": "RC91 fully aligns the app catalogues used by the browser, adapter startup, installer, save and backup paths. Energy Ledger and Mesh/Microgrid now preserve their installed/enabled state when unrelated App Center tabs are saved; the hidden DC station display is retained without creating a duplicate app card. The text-stable generated main.js is also kept strictly JavaScript-compatible. Productive grid, charging, storage, tariff, Section 14a and safety control logic is unchanged.",
|
|
29
39
|
"nl": "RC91 brengt de appcatalogi van browser, adapterstart, installer, opslaan en back-up volledig met elkaar in overeenstemming. Energy Ledger en Mesh/Microgrid behouden nu hun geïnstalleerde/actieve status wanneer andere AppCenter-tabbladen worden opgeslagen; het verborgen DC-stationsdisplay blijft behouden zonder dubbele appkaart. Ook blijft de tekststabiel gegenereerde main.js strikt JavaScript-compatibel. De productieve net-, laad-, opslag-, tarief-, §14a- en veiligheidsregeling is niet gewijzigd."
|
|
30
|
-
},
|
|
31
|
-
"0.8.210": {
|
|
32
|
-
"de": "RC83 erlaubt Speicher-Netzladen ausschließlich bei aktivem, frischem und günstigem dynamischen Tarif. Bei aktivem variablem Netzentgelt ist zusätzlich das konfigurierte NT-/Quartalsfenster Pflicht. Neutral, teuer, unbekannt, Tarif aus oder veraltete Preis-/Freigabedaten führen sofort zur Eigenverbrauchsoptimierung; auch gehaltene alte Tarif-/Reserve-Sollwerte werden unmittelbar vor dem Hardware-Write auf 0 W gestoppt. Das fehlende Objekt gridConstraints.exportLimit.sinkFieldProtocolJson wird vor dem ersten Write angelegt und beendet die wiederkehrende ioBroker-Warnflut.",
|
|
33
|
-
"en": "RC83 permits storage charging from the grid only with an active, fresh and cheap dynamic tariff. If variable grid fees are enabled, the configured off-peak/quarter window is an additional requirement. Neutral, expensive, unknown, disabled or stale tariff data immediately falls back to self-consumption; held legacy tariff/reserve commands are stopped at 0 W before the hardware write. The missing gridConstraints.exportLimit.sinkFieldProtocolJson object is now created before its first write, eliminating the recurring ioBroker warning flood.",
|
|
34
|
-
"nl": "RC83 staat netladen van de batterij alleen toe bij een actief, actueel en goedkoop dynamisch tarief. Bij geactiveerde variabele netkosten is bovendien het geconfigureerde dal-/kwartaalvenster verplicht. Neutraal, duur, onbekend, uitgeschakeld of verouderd tarief schakelt direct terug naar eigenverbruik; vastgehouden oude tarief-/reserveopdrachten worden vóór de hardware-write op 0 W gestopt. Het ontbrekende object gridConstraints.exportLimit.sinkFieldProtocolJson wordt vóór de eerste write aangemaakt, waardoor de terugkerende ioBroker-waarschuwingen stoppen."
|
|
35
|
-
},
|
|
36
|
-
"0.8.207": {
|
|
37
|
-
"de": "RC82 macht Netzlimits zum dauerhaft aktiven, nicht abschaltbaren Kernschutz – unabhängig von alten AppCenter-, Legacy-, Backup- oder Lizenzzuständen. Netzanschlussleistung und signierter NVP stammen ausschließlich aus Zuordnung → Allgemein; Hard-Limit = 100 %, Soft-Limit = 90 % und Reserve = exakt 10 %. Die 0-Einspeisung bleibt separat optional. Der wiederkehrende Core-Limits-Shadow-Warnlog zu total.effectiveW ist bereinigt; die interne Diagnose bleibt ohne Log-Spam erhalten.",
|
|
38
|
-
"en": "RC82 makes Grid Limits a permanently active core protection function that cannot be disabled by legacy App Center, configuration, backup or licence states. Grid connection power and signed point-of-connection measurement come exclusively from Assignment → General; hard limit is 100%, soft limit 90%, and reserve exactly 10%. Zero export remains separately optional. The recurring Core Limits shadow warning for total.effectiveW has been removed while internal diagnostics remain available without log spam.",
|
|
39
|
-
"nl": "RC82 maakt Netlimieten tot een permanent actieve kernbeveiliging die niet kan worden uitgeschakeld door oude AppCenter-, configuratie-, backup- of licentiestatussen. Netaansluitvermogen en gesigneerde NVP komen uitsluitend uit Toewijzing → Algemeen; hardlimit = 100%, softlimit = 90% en reserve exact 10%. Nulteruglevering blijft afzonderlijk optioneel. De terugkerende Core-Limits-shadowwaarschuwing voor total.effectiveW is verwijderd; interne diagnose blijft zonder logspam beschikbaar."
|
|
40
40
|
}
|
|
41
41
|
},
|
|
42
42
|
"title": "NexoWatt EOS",
|