diff --git a/.gitea/ci/run-tests.sh b/.gitea/ci/run-tests.sh
index 82ba2ef..89bb3f7 100755
--- a/.gitea/ci/run-tests.sh
+++ b/.gitea/ci/run-tests.sh
@@ -49,10 +49,11 @@ SERIAL="test_loop.py test_freeze.py test_safety87.py"
# safety119 704, opt34 515, safety126 402, safety125 388, safety126b 364,
# modes_p3 377, safety94 360, modes_p4c 291, modes_p4b 238, tariff24_weather 235,
# modes_p4d 196, price_run_fixes 197, safety103 189, safety90 185, safety97 163.
+# EV-05: ev05_long ~500 and ev05 ~375 alone (the Solar simulations).
# CI-18 split test_modes_p4, test_safety126 and test_safety125 so no one file
# is much over 400 s; test_opt34 and test_opt36 already fan out inside, and
# test_safety119 part 4 is one coupled block, so those three stay whole.
-HEAVY="test_opt36.py test_safety119.py test_opt34.py test_safety126.py test_safety125.py test_safety126b.py test_modes_p3.py test_safety94.py test_modes_p4c.py test_modes_p4b.py test_tariff24_weather.py test_modes_p4d.py test_safety125b.py test_price_run_fixes.py test_safety103.py test_safety90.py test_safety97.py test_peakguard.py test_opt20.py test_safety81.py"
+HEAVY="test_opt36.py test_safety119.py test_ev05_long.py test_opt34.py test_ev05.py test_safety126.py test_safety125.py test_safety126b.py test_modes_p3.py test_safety94.py test_modes_p4c.py test_modes_p4b.py test_tariff24_weather.py test_modes_p4d.py test_safety125b.py test_price_run_fixes.py test_safety103.py test_safety90.py test_safety97.py test_peakguard.py test_opt20.py test_safety81.py"
#
JOBS=${CI_JOBS:-10}
cd "${TESTS_DIR:-/w/goodwe-addon/goodwe_controller}"
diff --git a/goodwe_controller/CHANGELOG.md b/goodwe_controller/CHANGELOG.md
index 0d68c33..b9000cd 100644
--- a/goodwe_controller/CHANGELOG.md
+++ b/goodwe_controller/CHANGELOG.md
@@ -3,6 +3,7 @@
### Not in a release yet
- When the add-on changes the car's phases while the batteries are at the peak reserve, there is no longer a false "Battery stopped limiting the peak" for a moment ([[EV-15]]).
+- The car can charge from spare sun only (Solar mode), with the batteries or the car first, and it is cut first when the 15-minute period heads over the peak limit. Three new options with defaults ([[EV-05]]).
## 0.24.0
diff --git a/goodwe_controller/DECISIONS/EV-05-solar-mode.md b/goodwe_controller/DECISIONS/EV-05-solar-mode.md
new file mode 100644
index 0000000..1bc86de
--- /dev/null
+++ b/goodwe_controller/DECISIONS/EV-05-solar-mode.md
@@ -0,0 +1,54 @@
+# EV-05 — Solar mode: spare sun to the car
+
+The design is `reports/EV-01-design-report.md` (sections 2 to 5, decisions 2 and
+5) and the EV-05 brief v3 (owner answers Q1 and Q4, 2026-11-17). This record
+keeps what the code had to decide.
+
+## Where it lives
+
+`carmode.SolarPlan` decides (pure, monotonic clock): what current, on what
+phases. `carmode.SolarWriter` makes the charger match it. It is a subclass of
+`ManualWriter`, so the write, the read-back, the phase sequence and the
+other-writer watch are Manual's and there is still one `write_current` and one
+`write_phases` call in `app/` (test_ev04.py's AST check). `ctl_car` builds the
+inputs (`car_sun_inputs`) and runs the writer in the same background task.
+
+## The rules the brief left open
+
+- **Entering Solar starts at 0 A.** Choosing Solar, a restart in Solar, the
+ charger or Home Assistant coming back, a charger error or a stuck reading
+ clearing, and control starting again all reset the plan: 0 A if the charger
+ shows more, then the start rule. Switching from Manual to Solar therefore
+ pauses a Manual charge for the start dwell. Simple and on the safe side.
+- **The peak cut is what the guard would ask the batteries for.** The excess is
+ taken off the car only when the guard is engaged and wants a discharge
+ (`wanted_w > 0`), and by `min(excess, wanted)`. Batteries that only stop
+ charging in a cloud's first seconds are not "asked", so a cloud does not cut
+ the car. A partial cut caps the car for the rest of that 15-minute period.
+- **The 4.0 to 4.14 kW band on 3 phases.** 3 phases need 4.14 kW at 6 A, the
+ switch back to 1 phase is under 4.0 kW. Inside that band the car holds 6 A on
+ 3 phases with no pause count (the hysteresis the design chose). Under 4.0 kW
+ the down-switch comes after 5 minutes; if the 10-minute gap blocks it, the
+ pause rule does instead.
+- **A phase switch also waits for the 30 s write rule**, so the current set
+ after a switch is never sooner than 30 s after the one before it.
+- **The meter's age.** The spare is not computed from a meter reading older
+ than `stale_input_s`, also when `meter_max_age_s` (P1) is longer.
+- **A stale, stuck or not corroborated charging car makes the spare unknown**:
+ hold, then 0 A after *Pause after*. A paused or idle car with a fresh reading
+ counts 0 W (`car_w_trusted` is None outside mode3 C).
+- **A stuck reading's 0 A is written whatever the frozen read-back says**, since
+ that read-back means nothing then. Every other exit skips the write when the
+ charger already shows 0 A, and never writes over another writer.
+- **The guard's alarm path** uses the Solar car like Manual's
+ (`car_alarm_w`), and Solar's own 0 A (pause, cut, phase change) gets EV-15's
+ bounded grace (`_car_solar_pause`). A Solar quarter is never banked as "set
+ by the car", and Solar shows no *Car over the peak limit*.
+- **Shadow mode** runs the plan without writing, so the card says what it would
+ set; the charger got its one 0 A when shadow mode came on.
+
+## Solar kWh
+
+Per cycle in Solar: `min(car power, max(0, spare - room))` Batteries first,
+`min(car power, max(0, spare))` Car first; never above today's kWh; reset at the
+day change; kept in the store (`car_sun`).
diff --git a/goodwe_controller/DOCS.md b/goodwe_controller/DOCS.md
index 1d358f7..3bbfcb1 100644
--- a/goodwe_controller/DOCS.md
+++ b/goodwe_controller/DOCS.md
@@ -256,7 +256,10 @@ The label and description each setting shows on the Configuration tab, in tab or
| Car charger | Charger limit (A) | `ev_max_a` | The most current the charger may ever be asked for. Never above what the charger reports. Lower it for a weaker fuse or cable. |
| Car charger | Phases | `ev_phases` | How many phases the charger may use: 1, 3, or 1 and 3 (auto). |
| Car charger | Batteries help with the peak | `ev_batt_cover` | While the car charges. On: the batteries cover it down to the peak reserve. Off: the peak guard leaves the car out, so the car alone can set the peak. |
-| Car charger | Mode after a restart | `ev_mode_start` | Keep the last mode, or start in Off. A restart never changes the charger's current. |
+| Car charger | Mode after a restart | `ev_mode_start` | Keep the last mode, or start in Off. In Solar a restart sets the charger to 0 A first, other modes leave its current. |
+| Car charger | Sun kept back (W) | `ev_margin_w` | Solar: this much spare sun is never given to the car. |
+| Car charger | Start after (minutes) | `ev_start_min` | Solar: the car starts after this long with enough spare sun. |
+| Car charger | Pause after (minutes) | `ev_pause_min` | Solar: with too little sun the car holds 6 A this long, then pauses. |
| Advanced | Start control on boot | `auto_start` | Off by default. Leave it off until the site is commissioned, so someone presses Start after each restart. |
| Advanced | Control gain | `gain` | How much of the remaining error control corrects each cycle. Measured on real hardware, do not raise it. |
| Advanced | Largest change per cycle (W) | `slew_w` | How far the command may move in one cycle. 0 follows “Inverter rating” and is recommended. |
@@ -3278,9 +3281,10 @@ it.
### Car charger
The add-on can drive your car charger and shows it on **Home**, on a *Car* card.
-The card has two modes in this version: **Off** (the add-on only reads the
-charger and writes nothing) and **Manual** (the add-on sets the current and the
-phases you choose). Solar and Night modes come in later versions.
+The card has three modes in this version: **Off** (the add-on only reads the
+charger and writes nothing), **Manual** (the add-on sets the current and the
+phases you choose) and **Solar** (the car charges from spare sun only). Night
+mode comes in a later version.
| option | meaning |
|---|---|
@@ -3290,6 +3294,9 @@ phases you choose). Solar and Night modes come in later versions.
| `ev_phases` | `1`, `3` or `auto` (1 and 3). |
| `ev_batt_cover` | On (the default): the batteries help cover the car down to the peak reserve. Off: the car is left out of what the peak guard protects. |
| `ev_mode_start` | `keep` (the default) or `off`: the mode after a restart. |
+| `ev_margin_w` | Solar: spare sun never given to the car, 0 to 1000 W (default 100). |
+| `ev_start_min` | Solar: minutes of enough sun before the car starts, 1 to 30 (default 2). |
+| `ev_pause_min` | Solar: minutes the car holds 6 A with too little sun before it pauses, 1 to 30 (default 5). |
**What the Car card shows.** The state (Charging, Connected waiting, No car
connected, Car is full, Charger not reachable), the power and current, and the
@@ -3320,7 +3327,46 @@ checks within 10 seconds that the charger took it.
current again only if the charger shows a different one.
- Off writes nothing, ever.
-**The car is never slowed for the peak limit.** A Manual charge goes on whatever
+**Solar mode.** Choose *Solar* on Home (or `Solar` on `select.goodwe_car_mode`)
+and where spare sun goes first: **Batteries** or **Car** (`select.goodwe_car_sun_first`).
+Both apply at once, with no restart.
+
+- *Spare sun* is solar production less the house, measured without a solar
+ sensor: the car's power, plus what the batteries charge, less what the grid
+ gives. A grid charge of the batteries, or batteries giving more than the house
+ uses, is never spare sun.
+- *Batteries first*: the car gets what is left after the full rating of every
+ battery that may still charge (switched on, not refusing, not full), less
+ *Sun kept back*. So the car gets sun only when the batteries charge at full
+ power or are full. *Car first*: the car gets the spare sun less *Sun kept
+ back*, and the batteries charge with what it leaves.
+- The current is whole amps, rounded down, from 6 A to the charger limit. It
+ changes at most once per 30 seconds, and only by 1 A or more.
+- The car starts after *Start after* (2 minutes) of sun for at least 7 A. With
+ too little sun it holds 6 A for *Pause after* (5 minutes), from the batteries
+ where they can, then pauses at 0 A: the card says *Waiting for sun*.
+- With `ev_phases` `auto` a start goes on 1 phase. It moves to 3 phases after
+ 3 minutes at 4.5 kW or more, and back to 1 phase after 5 minutes under 4 kW,
+ at most once per 10 minutes, always through the safe phase steps above. A car
+ that draws one phase while three are allowed is counted on one phase.
+- **The car is cut first for the peak limit.** When the 15-minute period heads
+ over the limit and the peak guard would ask the batteries for power, that is
+ taken off the car first, down to 0 A at once. A Solar charge never sets the
+ month's peak.
+- **Every way out of Solar leaves the charger at 0 A**, written once: a stop or
+ restart of the add-on (before the inverters go to 0 W), stopping control, a
+ safety stop, shadow mode turned on, choosing Off, an unplugged car, a charger
+ error or a stuck reading. After the charger or Home Assistant was away, the
+ add-on first sets 0 A, then starts again by the rules. A meter that stops
+ gives a hold for *Pause after*, then 0 A. Choosing Manual leaves it to Manual.
+- Another writer stops the add-on's writes after 30 seconds, with an amber row
+ and a warning, until you press the mode again or the charger shows the
+ add-on's value again.
+- The card shows *{kWh} charged today, {kWh} from the sun*, also as
+ `sensor.goodwe_car_today_solar_kwh`. Only the sun the car could take counts,
+ not the battery or grid share of a hold, and not Manual.
+
+**The car is never slowed for the peak limit in Manual.** A Manual charge goes on whatever
the 15-minute peak does. With the default `ev_batt_cover` on, the batteries help
cover it down to the peak reserve; a 3-phase 16 A charge (11 kW) can empty two
batteries to the reserve in about 1.5 hours, and the month's peak then rises by
@@ -3364,9 +3410,10 @@ charger* shows for an hour after a change. That is expected while you migrate.
automation **off** (do not delete it). On the card choose **Manual** with the
current your helper held (`input_number.ev_manual_current`). Plug in and check
the current on the card and on the charger's display.
-3. On the next sunny day, choose Solar, with *spare sun goes first to* set as
- your priority switch was. (Solar comes in a later version; until then keep
- Manual or Off.)
+3. On the next sunny day, choose **Solar**, with *Spare sun goes first to* set
+ as your priority switch was (*Batteries* or *Car*), and *Sun kept back* as
+ your automation's margin. Watch the card's *Why* through a cloud: the car
+ holds 6 A for 5 minutes, then waits for the sun.
4. Keep your Home Assistant helpers for a week. To go back, set the add-on mode
to Off and switch the automation on. After that you can delete the helpers and
the automation.
@@ -3377,8 +3424,8 @@ off before you choose Manual, and the add-on off (mode Off) before you turn the
automation on.
**Home Assistant entities.** With MQTT the add-on adds the sensors
-`goodwe_car_power`, `goodwe_car_state` and `goodwe_car_today_kwh`, and the three
-controls named above. A saved ("retained") command is never applied, so a
+`goodwe_car_power`, `goodwe_car_state`, `goodwe_car_today_kwh` and
+`goodwe_car_today_solar_kwh`, and the four controls named above. A saved ("retained") command is never applied, so a
restart of Home Assistant cannot change the charger.
### Site
@@ -3516,6 +3563,13 @@ their full power. The add-on never slows the car, so this is information, not an
alarm. It is raised once per charging session. To stay under the limit, lower the
current.
+### Charger error, car paused
+
+In Solar mode the charger reports an error, so the add-on set the car to 0 A
+and writes nothing more until the error clears. Then the car starts again by
+the Solar rules. Check the charger itself. The notification goes by itself when
+the error clears.
+
### For installers: notifications
A fixed tariff beside the price service raises no notification: it is the
diff --git a/goodwe_controller/app/carmode.py b/goodwe_controller/app/carmode.py
index 39bf326..febd847 100644
--- a/goodwe_controller/app/carmode.py
+++ b/goodwe_controller/app/carmode.py
@@ -1,4 +1,5 @@
-"""EV-04: the car charger's Manual mode, the one place the add-on WRITES to it.
+"""EV-04 and EV-05: the car charger's Manual and Solar modes, the one place the
+add-on WRITES to it.
Pure but for the driver it is handed: no clock of its own (`now` is monotonic
seconds from the caller), no Home Assistant, no store. DECISIONS/EV-04-manual-
@@ -24,21 +25,38 @@ THE RULES, each tested in test_ev04.py:
mode or a value again.
* A charger that comes back after being unavailable gets the setting again only
if its read-back differs.
+
+EV-05, SOLAR (`SolarPlan` decides, `SolarWriter` writes; test_ev05.py,
+DECISIONS/EV-05-solar-mode.md): the car gets the spare sun, `spare = car +
+battery charge - grid import`, less the batteries' room (Batteries first) and
+the margin. Whole amps rounded down, at most one write per 30 s and only on a
+1 A change. Start after `ev_start_min` of enough sun, hold 6 A for
+`ev_pause_min` below it, then 0 A. The peak guard's excess is taken off the
+car first, at once. Every way out of Solar leaves the charger at 0 A, written
+once. Both writers share `ManualWriter._write`, so there is still one
+`write_current` and one `write_phases` call in the add-on.
"""
from __future__ import annotations
import logging
+import math
from . import chargers as CH
_LOG = logging.getLogger("goodwe")
-OFF, MANUAL = "off", "manual"
-#: the modes this card offers. Solar and Night are later cards (EV-05, EV-02).
-MODES = (OFF, MANUAL)
+OFF, MANUAL, SOLAR = "off", "manual", "solar"
+#: the modes offered. Night is a later card (EV-02).
+MODES = (OFF, MANUAL, SOLAR)
#: Home Assistant's select labels, English and pinned.
-MODE_LABELS = {OFF: "Off", MANUAL: "Manual"}
+MODE_LABELS = {OFF: "Off", MANUAL: "Manual", SOLAR: "Solar"}
+#: EV-05: where the spare sun goes first (`select.goodwe_car_sun_first`).
+KEY_FIRST = "car_sun_first"
+FIRST_BATT, FIRST_CAR = "batteries", "car"
+FIRSTS = (FIRST_BATT, FIRST_CAR)
+FIRST_LABELS = {FIRST_BATT: "Batteries", FIRST_CAR: "Car"}
+DEFAULT_FIRST = FIRST_BATT
START_KEEP, START_OFF = "keep", "off"
KEY_MODE, KEY_A, KEY_PHASES = "car_mode", "car_current", "car_phases"
@@ -378,3 +396,485 @@ class ManualWriter:
self.rev_applied = None
return
q["t1"] = now - SETTLE_S + 5.0 # again in 5 s
+
+
+# =========================================================================== #
+# EV-05: Solar. `SolarPlan` decides what the car should get, `SolarWriter`
+# makes the charger match it through ManualWriter's one write site.
+# =========================================================================== #
+MIN_A = CH.MIN_A
+VOLTS = 230.0 # per phase: the amps a figure in watts is worth
+SOLAR_WRITE_S = 30.0 # at most one current change per this
+SOLAR_STEP_A = 1.0 # ... and only on a change of this or more
+UP_W, UP_S = 4500.0, 180.0 # auto phases: to 3 at this for this long
+DOWN_W, DOWN_S = 4000.0, 300.0 # ... back to 1 under this for this long
+ONE_PHASE_S = 10.0 # one phase drawing while 3 are allowed this long
+ONE_PHASE_MIN_W = 500.0 # ... with the car drawing at least this
+
+
+def _num(v):
+ try:
+ f = float(v)
+ except (TypeError, ValueError):
+ return None
+ return f if math.isfinite(f) else None
+
+
+def spare_w(car_w, batt_w, grid_w):
+ """The spare sun, signed and not clipped: what the car takes, plus what the
+ batteries charge, less what the grid gives. `batt_w` is the add-on's own
+ battery figure (discharge positive) and `grid_w` the meter (import
+ positive), so this is `car - batt - grid` = solar production less the
+ house. A grid charge of the batteries, or batteries giving more than the
+ house uses, is never spare sun. None when a figure is missing or not a
+ number."""
+ c, b, g = _num(car_w), _num(batt_w), _num(grid_w)
+ if c is None or b is None or g is None:
+ return None
+ return c - b - g
+
+
+def car_target_w(spare, room_w, margin_w, first):
+ """What the car may take: Batteries first `spare - room - margin`, Car
+ first `spare - margin`. None while the spare is unknown."""
+ s = _num(spare)
+ if s is None:
+ return None
+ room = float(room_w or 0.0) if first == FIRST_BATT else 0.0
+ return s - room - float(margin_w)
+
+
+def amps_for(car_w, n, clamp=None):
+ """Whole amps for `car_w` on `n` phases, ROUNDED DOWN, never above the
+ clamp. None for a figure that is not a number."""
+ w = _num(car_w)
+ if w is None or n not in (1, 3):
+ return None
+ a = math.floor(w / (VOLTS * n) + 1e-9)
+ hi = CH.ENTITY_MAX_A if _num(clamp) is None else float(clamp)
+ return float(max(0, min(a, math.floor(hi))))
+
+
+def solar_option(opts: dict, key: str) -> float:
+ """`ev_margin_w`, `ev_pause_min` or `ev_start_min` as a number, the shipped
+ default when it is not one (the validator refuses it anyway)."""
+ v = _num((opts or {}).get(key))
+ return float(CH.EV_OPTION_DEFAULTS[key]) if v is None else v
+
+
+class SunInputs:
+ """One cycle's inputs for Solar, built by the Controller."""
+
+ def __init__(self, target_w=None, hold=False, cut_w=0.0, car_w=None,
+ key=None, auto=True, fixed_n=1, start_s=120.0,
+ pause_s=300.0, spare_w=None, room_w=0.0, margin_w=100.0,
+ first=DEFAULT_FIRST):
+ self.target_w, self.hold, self.cut_w = target_w, hold, cut_w
+ self.car_w, self.key, self.auto, self.fixed_n = car_w, key, auto, \
+ fixed_n
+ self.start_s, self.pause_s = start_s, pause_s
+ self.spare_w, self.room_w, self.margin_w = spare_w, room_w, margin_w
+ self.first = first
+
+
+class SolarPlan:
+ """What Solar wants set, one `step()` per cycle. Pure: monotonic `now` from
+ the caller and no driver, so in shadow mode it runs the same and the card
+ says what it would set. `a` is the current wanted (0: paused), `n` the
+ phases it is meant for."""
+
+ def __init__(self, n=1):
+ self.reset(n)
+
+ def reset(self, n=1, why="paused"):
+ self.a = 0.0
+ self.n = n if n in (1, 3) else 1
+ self.set_at = None # when `a` last changed (the 30 s rule)
+ self.ok_since = None # enough sun to start, since
+ self.low_since = None # under 6 A worth, holding 6 A, since
+ self.unknown_since = None # the spare cannot be measured, since
+ self.up_since = self.down_since = None
+ self.cap_a = self.cap_key = None # the peak cut, for this period
+ self.why = self.pause_why = why
+ self.target_w = None
+
+ def _pause(self, why):
+ self.a, self.set_at = 0.0, None
+ self.ok_since = self.low_since = self.unknown_since = None
+ self.up_since = self.down_since = None
+ self.why = self.pause_why = why
+
+ def _gate(self, now) -> bool:
+ return self.set_at is None or now - self.set_at >= SOLAR_WRITE_S
+
+ def _switch(self, n, target_w, now, clamp):
+ self.n = n
+ a = amps_for(target_w, n, clamp) or 0.0
+ if a >= MIN_A:
+ self.low_since = None
+ elif self.low_since is None:
+ self.low_since = now
+ a = max(a, MIN_A)
+ if self.cap_a is not None:
+ a = max(MIN_A, min(a, self.cap_a))
+ self.a, self.set_at = a, now
+ self.up_since = self.down_since = None
+ self.why = "running"
+
+ def step(self, now, *, target_w, n_calc, auto, fixed_n, clamp,
+ start_s, pause_s, hold=False, cut_w=0.0, car_w=None, key=None,
+ gap_ok=True):
+ if key != self.cap_key:
+ self.cap_a = self.cap_key = None
+ if hold: # readings late, under the stale bound
+ return
+ self.target_w = target_w
+ # The peak guard's excess comes off the car first, at once (no 30 s
+ # rule, no hold). Nothing starts while the period heads over the aim.
+ if cut_w and cut_w > 0.0:
+ self.ok_since = None
+ if self.a > 0.0:
+ base = self.a * VOLTS * n_calc
+ cw = _num(car_w)
+ if cw is not None:
+ base = min(base, cw)
+ new = amps_for(base - float(cut_w), n_calc, clamp)
+ if new is None or new < MIN_A:
+ self._pause("cut")
+ elif new < self.a:
+ self.a, self.set_at, self.why = new, now, "cut"
+ self.cap_a, self.cap_key = new, key
+ return
+ if target_w is None: # the sun cannot be measured: hold, then 0 A
+ self.ok_since = None
+ if self.a > 0.0:
+ if self.unknown_since is None:
+ self.unknown_since = now
+ if now - self.unknown_since >= pause_s:
+ self._pause("unknown")
+ else:
+ self.why = "unknown"
+ return
+ self.unknown_since = None
+ hi = None if _num(clamp) is None else math.floor(float(clamp))
+ if self.a <= 0.0: # paused: the start rule
+ n0 = 1 if auto else fixed_n
+ if target_w >= (MIN_A + 1.0) * VOLTS * n0:
+ if self.ok_since is None:
+ self.ok_since = now
+ self.why = "start"
+ if now - self.ok_since >= start_s:
+ a = amps_for(target_w, n0, clamp)
+ if a is not None and self.cap_a is not None:
+ a = min(a, self.cap_a)
+ if a is not None and a >= MIN_A:
+ self.a, self.n, self.set_at = a, n0, now
+ self.ok_since = self.low_since = None
+ self.up_since = self.down_since = None
+ self.why = "running"
+ else:
+ self.ok_since = None
+ self.why = self.pause_why
+ return
+ if hi is not None and self.a > hi: # the clamp came down
+ if hi < MIN_A:
+ self._pause("paused")
+ return
+ self.a, self.set_at = float(hi), now
+ if auto: # auto phases, by their own dwells
+ if self.n == 1:
+ self.down_since = None
+ if target_w >= UP_W:
+ self.up_since = self.up_since if self.up_since is not None \
+ else now
+ else:
+ self.up_since = None
+ if self.up_since is not None and now - self.up_since >= UP_S \
+ and gap_ok and self._gate(now):
+ self._switch(3, target_w, now, clamp)
+ return
+ else:
+ self.up_since = None
+ if target_w < DOWN_W:
+ self.down_since = self.down_since \
+ if self.down_since is not None else now
+ else:
+ self.down_since = None
+ if self.down_since is not None \
+ and now - self.down_since >= DOWN_S and gap_ok and self._gate(now):
+ self._switch(1, target_w, now, clamp)
+ return
+ want = amps_for(target_w, n_calc, clamp)
+ if want is not None and want >= MIN_A:
+ self.low_since = None
+ if self.cap_a is not None:
+ want = min(want, self.cap_a)
+ self.why = "running"
+ if abs(want - self.a) >= SOLAR_STEP_A and self._gate(now):
+ self.a, self.set_at = want, now
+ return
+ if auto and self.n == 3 and target_w >= DOWN_W:
+ # Inside the phase hysteresis (4.0 kW to 6 A x 690 W): 3 phases at
+ # 6 A stand, as the switch rule says; no pause count.
+ self.low_since = None
+ self.why = "running"
+ if self.a != MIN_A and self._gate(now):
+ self.a, self.set_at = MIN_A, now
+ return
+ if self.low_since is None:
+ self.low_since = now
+ self.why = "hold"
+ if now - self.low_since >= pause_s:
+ self._pause("paused")
+ return
+ if self.a != MIN_A and self._gate(now):
+ self.a, self.set_at = MIN_A, now
+
+
+class SolarWriter(ManualWriter):
+ """What Solar does to the charger, one `step()` per cycle. It shares
+ ManualWriter's write, phase sequence and other-writer watch; what differs
+ is that every way out ends at 0 A, written once, and that an interrupted
+ phase change is never undone to the old current."""
+
+ def __init__(self):
+ super().__init__()
+ self.plan = SolarPlan()
+ self.engaged = False # Solar has run since it was chosen
+ self.reinit = True # start again from 0 A and the start rule
+ self.out = False # not writing: the 0 A has been tried
+ self.stand = False # no car: the standing 0 A has been tried
+ self.fault = None # "error" | "stuck" while it holds
+ self.fault_done = False
+ self.warned = False # the charger error warning, once
+ self.single = False # a one-phase car on a 3-phase allowance
+ self._one_since = None
+ self.zero_at = None # EV-15: our own latest 0 A, sent then
+ self.sent_a = None # the current we last decided to write
+
+ # ------------------------------------------------------------------ help
+ def _mark(self, r, now) -> None:
+ """A car that draws one phase while 3 are allowed is a one-phase car
+ for the session: the sun arithmetic then uses 1 phase."""
+ if r.state == "A":
+ self.single, self._one_since = False, None
+ return
+ drawing = [x for x in (r.current_a or ()) if x >= CH.IDLE_A]
+ one = (r.phases_allowed == 3 and r.charging is True
+ and r.power_w is not None and r.power_w >= ONE_PHASE_MIN_W
+ and len(r.current_a or ()) >= 3 and len(drawing) == 1)
+ if not one:
+ self._one_since = None
+ return
+ if self._one_since is None:
+ self._one_since = now
+ if now - self._one_since >= ONE_PHASE_S and not self.single:
+ self.single = True
+ _LOG.info("The car draws one phase while three are allowed, so "
+ "the add-on counts one phase for this charge.")
+
+ def _watch(self, cur, now) -> None:
+ """As Manual's, and in Solar the hold is a warning: the add-on stops
+ writing until you press the mode or the read-back matches again."""
+ was = self.hold
+ super()._watch(cur, now)
+ if self.hold and not was:
+ _LOG.warning("Something else changes the charger, so the add-on "
+ "stops writing to it: CHARGER_OTHER.")
+
+ @property
+ def n_calc(self) -> int:
+ return 1 if self.single else self.plan.n
+
+ def amps_out(self, clamp) -> float:
+ """The plan's current, never above the clamp; 0 when under 6 A."""
+ a = float(self.plan.a)
+ if _num(clamp) is not None:
+ a = min(a, float(math.floor(float(clamp))))
+ return a if a >= CH.MIN_A else 0.0
+
+ def user_changed(self) -> None:
+ """As Manual's, and Solar says its current again (another writer's
+ hold is lifted by pressing the mode)."""
+ super().user_changed()
+ self.sent_a = None
+
+ async def _zero_once(self, drv, cur, now, tracker, force=False) -> None:
+ """One try of 0 A on the way out. Never over another writer, and not
+ when the charger already shows 0 A (unless the reading is stuck, so
+ its 0 A means nothing: `force`)."""
+ if self.hold or (not force and cur is not None and cur <= TOL_A):
+ return
+ self.zero_at, self.sent_a = now, 0.0
+ await self._write(drv, 0.0, cur, now, tracker)
+
+ def _leave(self) -> None:
+ self.engaged, self.seq, self.would = False, None, None
+ self.out = self.stand = False
+ self.fault, self.fault_done = None, False
+ self.reinit = True
+ self.sent_a = None
+ self.plan.reset(self.plan.n)
+
+ def _plan_step(self, sun, now, clamp) -> None:
+ gap = self.last_switch is None or now - self.last_switch >= PHASE_GAP_S
+ self.plan.step(
+ now, target_w=sun.target_w, hold=sun.hold, n_calc=self.n_calc,
+ auto=sun.auto and not self.single,
+ fixed_n=1 if self.single else sun.fixed_n, clamp=clamp,
+ cut_w=sun.cut_w, car_w=sun.car_w, key=sun.key,
+ start_s=sun.start_s, pause_s=sun.pause_s,
+ gap_ok=gap and not self.phases_gave_up)
+
+ # ------------------------------------------------------------------ step
+ async def step(self, drv, r, *, mode, sun, clamp, now, tracker, writing,
+ status, clock=None):
+ """One cycle. `sun` is `SunInputs`; `writing` is False in shadow mode,
+ while control is stopped, under a safety stop and while stopping."""
+ self._clock = clock or (lambda: now)
+ if r is None or not r.available:
+ self.was_available = False # nothing is tried while it is down
+ return
+ if self.last_done is not None and tracker is not None \
+ and tracker.obs_at is not None \
+ and tracker.obs_at <= self.last_done:
+ return
+ self._mark(r, now)
+ if not self.was_available:
+ self.was_available = True
+ self.reinit = True # back: 0 A first, then the rules
+ cur = r.allowed_a if r.allowed_a is not None else r.setpoint_a
+ if mode != SOLAR:
+ self.would = None
+ if not self.engaged:
+ return
+ if mode != MANUAL: # Off: 0 A once, then nothing
+ self.seq = None
+ await self._zero_once(drv, cur, now, tracker)
+ self._leave() # Manual writes its own current
+ return
+ self.engaged = True
+ if sun is None:
+ return
+ if not writing:
+ # Shadow, Stop, a safety stop, stopping: 0 A once, then nothing.
+ # The plan goes on, so the card says what it would set.
+ self.seq = None
+ if not self.out:
+ self.out = True
+ await self._zero_once(drv, cur, now, tracker)
+ self._plan_step(sun, now, clamp)
+ self.would = (self.amps_out(clamp), self.n_calc)
+ self.reinit = True
+ return
+ self.out = False
+ self.would = None
+ fault = ("error" if (r.error or r.state in ("E", "F")) else
+ "stuck" if tracker is not None and tracker.stuck(now)
+ else None)
+ if fault is not None:
+ # 0 A once, then no write until it clears; then the start rule.
+ self.seq = None
+ if self.fault != fault:
+ self.fault, self.fault_done = fault, False
+ if fault == "error" and not self.warned:
+ self.warned = True
+ _LOG.warning("The charger reports an error, so the add-on "
+ "sets the car to 0 A: CHARGER_ERROR.")
+ if not self.fault_done:
+ self.fault_done = True
+ await self._zero_once(drv, cur, now, tracker,
+ force=fault == "stuck")
+ self.plan.reset(self.plan.n, why=fault)
+ self.reinit = True
+ return
+ if self.fault is not None:
+ self.fault, self.fault_done = None, False
+ self.warned = False
+ if r.state == "A" or status == CH.NONE_:
+ # No car: the standing current is 0 A, written once.
+ self.seq = None
+ if not self.stand:
+ self.stand = True
+ await self._zero_once(drv, cur, now, tracker)
+ self.plan.reset(self.plan.n, why="none")
+ self.reinit = False
+ return
+ self.stand = False
+ if self.reinit:
+ self.reinit = False
+ self.seq = None
+ self.mismatch_since = None
+ self.sent_a = None
+ n = r.phases_allowed if r.phases_allowed in (1, 3) else self.plan.n
+ self.plan.reset(n)
+ if status == CH.FULL: # the car is full: nothing written
+ self.plan.why = "full"
+ return
+ if self.seq is None:
+ self._watch(cur, now)
+ if self.hold:
+ return
+ self._plan_step(sun, now, clamp)
+ if self.seq is not None:
+ q = self.seq
+ if self.plan.a < CH.MIN_A:
+ self.seq = None # paused or cut: it stays at 0 A
+ return
+ pf = self.phase_fails
+ await self._advance(drv, r, cur, now, tracker, self.amps_out(clamp)
+ or CH.MIN_A, clamp, None)
+ if self.phase_fails > pf and q.get("from") in (1, 3):
+ self.plan.n = q["from"] # the select was not taken
+ if self.seq is None:
+ self.sent_a = self.last_a
+ return
+ want = self.amps_out(clamp)
+ if want >= CH.MIN_A and not self.single and not self.phases_gave_up \
+ and r.phases_allowed in (1, 3) \
+ and r.phases_allowed != self.plan.n:
+ if self.last_switch is not None \
+ and now - self.last_switch < PHASE_GAP_S:
+ self.blocked = True
+ return
+ self.blocked = False
+ self.zero_at, self.sent_a = now, 0.0
+ await self._begin(drv, r, cur, self.plan.n, now, tracker)
+ if self.seq is not None:
+ self.seq["from"] = r.phases_allowed
+ return
+ if self.sent_a is not None and abs(self.sent_a - want) <= TOL_A \
+ and self.fail_at is None:
+ return # nothing new: a read-back that differs is `_watch`'s
+ if cur is not None and abs(cur - want) <= TOL_A:
+ self.sent_a = want
+ self.fails, self.fail_at = 0, None
+ if self.last_a is None or abs(self.last_a - cur) > TOL_A:
+ self.last_a = cur
+ return
+ if self.gave_up or (self.fail_at is not None
+ and now - self.fail_at < RETRY_S):
+ return
+ if want <= 0.0:
+ self.zero_at = now
+ self.sent_a = want
+ if await self._write(drv, want, cur, now, tracker):
+ self.fails, self.fail_at = 0, None
+ else:
+ self._failed(now)
+
+ async def release(self, drv, r, now, tracker) -> None:
+ """The add-on stops in Solar: 0 A, once, before the inverters go to
+ 0 W. A phase change in the middle is not undone to the old current."""
+ self.seq = None
+ if r is not None and r.available:
+ cur = r.allowed_a if r.allowed_a is not None else r.setpoint_a
+ else:
+ cur = None
+ if self.last_done is not None and tracker is not None \
+ and tracker.obs_at is not None \
+ and tracker.obs_at <= self.last_done:
+ cur = self.last_a # the reading predates our own write
+ self._clock = self._clock or (lambda: now)
+ await self._zero_once(drv, cur, now, tracker)
+ self.out = True
diff --git a/goodwe_controller/app/chargers.py b/goodwe_controller/app/chargers.py
index caa6618..c4207ed 100644
--- a/goodwe_controller/app/chargers.py
+++ b/goodwe_controller/app/chargers.py
@@ -5,8 +5,8 @@ actuator per site, a census key, a read, a clamped write that says whether the
charger took it, and a hand-back. A charger is a modulated actuator with a fail
state, not one of DEV-01's on/off loads.
-EV-04 IS THE FIRST CARD THAT WRITES TO THE CHARGER, and only in Manual
-(`app/carmode.py` is the one caller). `write_current` is clamped to
+EV-04 IS THE FIRST CARD THAT WRITES TO THE CHARGER, in Manual and (EV-05) in
+Solar (`app/carmode.py` is the one caller). `write_current` is clamped to
`min(ev_max_a, the station limit the charger reports, the entity's own range)`
and a value above that is NEVER SENT: it is a software fault, logged in the
OUTPUT_CLAMP shape. It says True only when the charger's read-back followed
@@ -42,7 +42,13 @@ PHASES_CHOICES = ("1", "3", "auto")
# config.yaml's shipped defaults, mirrored (test_defaults_pin.py checks it).
EV_OPTION_DEFAULTS = {"ev_charger": "off", "ev_current_entity": "",
"ev_max_a": 16, "ev_phases": "auto",
- "ev_batt_cover": True, "ev_mode_start": "keep"}
+ "ev_batt_cover": True, "ev_mode_start": "keep",
+ # EV-05, Solar: the sun kept back, and the two dwells
+ "ev_margin_w": 100, "ev_pause_min": 5,
+ "ev_start_min": 2}
+#: EV-05: the ranges config.yaml's schema and the validator both hold.
+SOLAR_RANGES = {"ev_margin_w": (0, 1000), "ev_pause_min": (1, 30),
+ "ev_start_min": (1, 30)}
def max_a(opts: dict):
@@ -553,7 +559,9 @@ class AlfenHaDriver(ChargerDriver):
async def release(self, mode: str) -> bool:
"""The mode's fail state. Manual and Off keep the current (the charger
- is a stand-alone device and the current is the user's setting)."""
+ is a stand-alone device and the current is the user's setting). Solar's
+ 0 A goes through `carmode` (`SolarWriter.release`), the one write
+ site, so nothing is written here."""
return True
diff --git a/goodwe_controller/app/ctl_car.py b/goodwe_controller/app/ctl_car.py
index 41615da..e17620c 100644
--- a/goodwe_controller/app/ctl_car.py
+++ b/goodwe_controller/app/ctl_car.py
@@ -1,17 +1,21 @@
-"""EV-04: the Controller's side of the car's Manual mode.
+"""EV-04 and EV-05: the Controller's side of the car's Manual and Solar modes.
The writes themselves are `carmode.ManualWriter`'s; this mixin owns the state
(mode, current, phases: runtime state in the store, like OPT-11's modes), the
actions, the background step that never holds up a control cycle, and what the
car means for the peak guard's ALARM PATH. DECISIONS/EV-04-manual-mode.md.
+EV-05 (DECISIONS/EV-05-solar-mode.md): Solar's inputs (`car_sun_inputs`), the
+peak guard's excess taken off the car first (`car_cycle`), the 0 A at shutdown
+before the inverters, and the solar kWh of today.
"""
import asyncio
import dataclasses
import logging
+import math
from datetime import timezone
-from . import carmode, chargers, messages, peakguard
+from . import carmode, chargers, messages, packmode, packshare, peakguard
from .tariff import QUARTER_S
_LOG = logging.getLogger("goodwe")
@@ -31,6 +35,10 @@ OVER_OFF_HOLD_S = 180.0
OWN_PAUSE_MAX_S = (carmode.ZERO_WAIT_S + carmode.SETTLE_S
+ carmode.MAX_TRIES * 15.0 + 10.0)
OWN_PAUSE_TAIL_S = chargers.CORR_WINDOW_S
+CAR_SUN_KEY = "car_sun" # EV-05: {day, kwh} charged from the sun today
+# EV-05: at shutdown the charger's 0 A waits at most this long, then the
+# inverters are released whatever the charger did.
+RELEASE_WAIT_S = 15.0
class CarMixin:
@@ -52,6 +60,25 @@ class CarMixin:
self.car_n = n if n in ok else ok[0]
self.car_rev = 0
self.car_writer = carmode.ManualWriter()
+ self.car_solar = carmode.SolarWriter() # EV-05
+ first = data.get(carmode.KEY_FIRST)
+ self.car_first = first if first in carmode.FIRSTS \
+ else carmode.DEFAULT_FIRST
+ self.car_cut_w = 0.0
+ self._car_key = None
+ self._car_late_s = None
+ self._car_sun_last = None
+ self._car_error_notified = False
+ sun = data.get(CAR_SUN_KEY)
+ self.car_sun = {"day": None, "kwh": 0.0}
+ if isinstance(sun, dict):
+ try:
+ self.car_sun = {"day": sun.get("day"),
+ "kwh": max(0.0, float(sun.get("kwh") or 0.0))}
+ except (TypeError, ValueError):
+ pass
+ self._car_sun_mono = None
+ self._car_sun_saved = round(self.car_sun["kwh"], 2)
self._car_task = None
self._car_step_failed = False
self.car_explains = False # the car alone explains the excess
@@ -81,6 +108,12 @@ class CarMixin:
return (self.charger.configured()
and self.car_mode == carmode.MANUAL)
+ def car_solar_mode(self) -> bool:
+ """EV-05: a charger is set up and the mode is Solar."""
+ ch = getattr(self, "charger", None)
+ return bool(ch is not None and ch.configured()
+ and getattr(self, "car_mode", None) == carmode.SOLAR)
+
def car_clamp(self):
return carmode.clamp_for(self.o, self.car.reading)
@@ -104,6 +137,17 @@ class CarMixin:
return {"error": messages.car_refused("value")}
self.car_mode = value
self.store.set(carmode.KEY_MODE, value)
+ elif what == "car_sun_first":
+ # EV-05: arithmetic only, from the next cycle; not a user change of
+ # the writers (the 30 s rule and the other-writer hold stand).
+ if value not in carmode.FIRSTS:
+ return {"error": messages.car_refused("value")}
+ self.car_first = value
+ self.store.set(carmode.KEY_FIRST, value)
+ self.log_event(f"car sun first set to {value} by operator",
+ hint=messages.hint("car_sun_first"))
+ return {"mode": self.car_mode, "current": self.car_a,
+ "phases": self.car_n, "sun_first": self.car_first}
elif what == "car_current":
clamp = self.car_clamp()
if isinstance(value, bool):
@@ -126,6 +170,7 @@ class CarMixin:
self.store.set(carmode.KEY_PHASES, value)
self.car_rev += 1
self.car_writer.user_changed()
+ self.car_solar.user_changed()
self.log_event(f"car {what[4:]} set to {value} by operator",
hint=messages.hint(what))
return {"mode": self.car_mode, "current": self.car_a,
@@ -135,7 +180,8 @@ class CarMixin:
"""The MQTT state of the three car entities."""
return {"car_mode": carmode.MODE_LABELS[self.car_mode],
"car_current": round(self.car_a),
- "car_phases": str(self.car_n)}
+ "car_phases": str(self.car_n),
+ "car_sun_first": carmode.FIRST_LABELS[self.car_first]}
# ------------------------------------------------------------- the writer
def car_kick(self) -> None:
@@ -149,6 +195,15 @@ class CarMixin:
return
self._car_task = asyncio.ensure_future(self._car_run())
+ def _car_hold_kick(self) -> None:
+ """EV-05: a cycle that holds for a missing or late reading returns
+ before `car_kick()`. Solar still steps (it holds, counts its dwell from
+ the first missing reading, and an exit still writes its 0 A); Manual is
+ left exactly as it was."""
+ if self.car_solar_engaged():
+ self.car_cut_w = 0.0
+ self.car_kick()
+
async def car_settle(self) -> None:
"""Wait for the writer step in flight (the checks use it)."""
t = self._car_task
@@ -171,14 +226,30 @@ class CarMixin:
else:
self._car_step_failed = False
+ def car_solar_engaged(self) -> bool:
+ """EV-05: Solar is the mode, or its 0 A on the way out is still due."""
+ w = getattr(self, "car_solar", None)
+ return bool(self.charger.configured() and w is not None
+ and (self.car_mode == carmode.SOLAR or w.engaged))
+
async def car_shutdown(self) -> None:
- """The add-on stops: no new write, and a phase change in the middle is
- undone by giving the car its current back. The current stands
- otherwise (Manual's fail state)."""
+ """The add-on stops: no new write. Manual: a phase change in the middle
+ is undone by giving the car its current back, the current stands
+ otherwise. Solar (EV-05): 0 A, once, waited for at most
+ `RELEASE_WAIT_S` (`Controller.shutdown` calls this first in Solar)."""
t, self._car_task = getattr(self, "_car_task", None), None
if t is not None and not t.done():
t.cancel()
await asyncio.gather(t, return_exceptions=True)
+ if self.car_solar_engaged():
+ try:
+ await asyncio.wait_for(self.car_solar.release(
+ self.charger, self.car.reading, self.car_now(), self.car),
+ RELEASE_WAIT_S)
+ except Exception: # noqa: BLE001
+ _LOG.warning("The car charger could not be set to 0 A before "
+ "the add-on stopped: CHARGER_RELEASE.")
+ return
if not self.charger.configured() \
or getattr(self, "car_writer", None) is None \
or self.car_writer.seq is None:
@@ -197,19 +268,144 @@ class CarMixin:
if not self.charger.configured():
return
now = self.car_now()
- await self.car_writer.step(
- self.charger, self.car.reading, mode=self.car_mode,
- want_a=self.car_a, want_phases=self.car_n, rev=self.car_rev,
- clamp=self.car_clamp(), now=now, tracker=self.car,
- writing=self.car_writing(), shadow=bool(self.shadow),
- status=self.car.status(now, True), clock=self.car_now)
+ if self.car_mode != carmode.SOLAR:
+ await self.car_writer.step(
+ self.charger, self.car.reading, mode=self.car_mode,
+ want_a=self.car_a, want_phases=self.car_n, rev=self.car_rev,
+ clamp=self.car_clamp(), now=now, tracker=self.car,
+ writing=self.car_writing(), shadow=bool(self.shadow),
+ status=self.car.status(now, True), clock=self.car_now)
+ w = self.car_solar
+ if self.car_mode == carmode.SOLAR or w.engaged:
+ await w.step(
+ self.charger, self.car.reading, mode=self.car_mode,
+ sun=(self.car_sun_inputs(now)
+ if self.car_mode == carmode.SOLAR else None),
+ clamp=self.car_clamp(), now=now, tracker=self.car,
+ writing=self.car_writing(), status=self.car.status(now, True),
+ clock=self.car_now)
+
+ # ------------------------------------------------------- EV-05: Solar
+ def car_may_charge(self, inv) -> bool:
+ """May this battery take the sun? On (battery modes), not refusing a
+ charge, its level read and under full."""
+ if self.modes_on and not self.pack_mode(inv).use:
+ return False
+ if (inv.refused or 0) < 0 or inv.sign_wd.tripped:
+ return False
+ if len(self.inverters) == 1 and (self.batt_refused or 0) < 0:
+ return False
+ return inv.soc is not None and float(inv.soc) < packshare.FULL_PCT
+
+ def car_room_w(self) -> float:
+ """Batteries first: the RATINGS of the batteries that may charge."""
+ return float(sum(inv.rating_w() for inv in self.inverters
+ if self.car_may_charge(inv)))
+
+ def car_spare_w(self, mono):
+ """The signed spare sun now, or None when it cannot be measured: a
+ missing meter or battery figure, readings late past the stale bound,
+ or a charging car whose figure is stale, stuck or not corroborated. A
+ paused or idle car with a fresh reading counts as 0 W."""
+ if not self.inputs_ok:
+ return None
+ stale = float(self.o.get("stale_input_s", 15))
+ late = self._car_late_s
+ if late is not None and late >= stale:
+ return None
+ if self.p1_enabled:
+ # The meter's own bound (`meter_max_age_s`) may be longer than
+ # `stale_input_s`; a car write never comes from an older reading.
+ age = self.p1.age_s()
+ if age is None or age > stale:
+ return None
+ r = self.car.reading
+ if r is None or not r.available or not self.car.fresh(mono):
+ return None
+ if r.charging is True:
+ car = self.car.car_w_trusted(mono)
+ else:
+ car = 0.0
+ return carmode.spare_w(car, self.site_batt_w, self.grid)
+
+ def car_sun_inputs(self, mono) -> "carmode.SunInputs":
+ o = self.o
+ spare = self.car_spare_w(mono)
+ late = self._car_late_s
+ hold = late is not None and late < float(o.get("stale_input_s", 15))
+ room = self.car_room_w()
+ margin = carmode.solar_option(o, "ev_margin_w")
+ ph = str(o.get("ev_phases", chargers.EV_OPTION_DEFAULTS["ev_phases"]))
+ self._car_sun_last = carmode.SunInputs(
+ target_w=carmode.car_target_w(spare, room, margin,
+ self.car_first),
+ hold=hold, cut_w=self.car_cut_w,
+ car_w=self.car.car_w(mono), key=self._car_key,
+ auto=ph not in ("1", "3"), fixed_n=3 if ph == "3" else 1,
+ start_s=60.0 * carmode.solar_option(o, "ev_start_min"),
+ pause_s=60.0 * carmode.solar_option(o, "ev_pause_min"),
+ spare_w=spare, room_w=room, margin_w=margin,
+ first=self.car_first)
+ return self._car_sun_last
+
+ def _car_sun_tick(self, mono) -> None:
+ """Solar kWh: per cycle, in Solar only, the car's power up to the sun
+ it may take (`spare - room` Batteries first, `spare` Car first). The
+ hold's battery or grid share and Manual do not count."""
+ if not self.car_solar_mode():
+ self._car_sun_mono = None
+ return
+ day = self.car.day
+ if day is not None and self.car_sun.get("day") != day:
+ self.car_sun = {"day": day, "kwh": 0.0}
+ self.store.set(CAR_SUN_KEY, dict(self.car_sun))
+ self._car_sun_saved = 0.0
+ last, self._car_sun_mono = self._car_sun_mono, mono
+ if last is None:
+ return
+ dt = min(max(mono - last, 0.0), 5.0)
+ p = self.car.car_w(mono)
+ spare = self.car_spare_w(mono)
+ if p is None or spare is None or dt <= 0.0:
+ return
+ sun = spare - (self.car_room_w() if self.car_first == carmode.FIRST_BATT
+ else 0.0)
+ share = min(float(p), max(0.0, sun))
+ if share <= 0.0:
+ return
+ self.car_sun["kwh"] += share * dt / 3.6e6
+ if round(self.car_sun["kwh"], 2) != self._car_sun_saved:
+ self._car_sun_saved = round(self.car_sun["kwh"], 2)
+ self.store.set(CAR_SUN_KEY, {"day": self.car_sun["day"],
+ "kwh": round(self.car_sun["kwh"], 4)})
+
+ def car_sun_kwh(self):
+ """Today's kWh from the sun, never above today's kWh; None without a
+ reading of today."""
+ if self.car.today_kwh is None or self.car_sun.get("day") != self.car.day:
+ return None if self.car.today_kwh is None else 0.0
+ return max(0.0, min(float(self.car_sun["kwh"]),
+ float(self.car.today_kwh)))
+
+ async def check_car_error(self) -> None:
+ """EV-05: in Solar a charger error sets the car to 0 A and raises one
+ warning notification; it is taken down when the error clears."""
+ bad = self.car_solar_mode() and self.car_solar.fault == "error"
+ if bad and not self._car_error_notified:
+ self._car_error_notified = True
+ await self.hass.call("persistent_notification", "create",
+ messages.charger_error().data())
+ elif not bad and self._car_error_notified:
+ self._car_error_notified = False
+ await self.hass.call("persistent_notification", "dismiss",
+ messages.charger_error_gone().data())
# ------------------------------------------- the car and the peak guard
def car_alarm_w(self):
- """The car's power for the guard's alarm path: Manual only, fresh, not
- stuck (`CarTracker.car_w_trusted`), and never above what the read-back
- allows. None otherwise, and then the normal alarms stand."""
- if not self.car_manual():
+ """The car's power for the guard's alarm path: Manual and Solar, fresh,
+ not stuck (`CarTracker.car_w_trusted`), and never above what the
+ read-back allows. None otherwise, and then the normal alarms stand."""
+ if not (self.car_manual() or self.car_solar_mode()):
return None
return self.car.car_w_trusted(self.car_now())
@@ -219,6 +415,8 @@ class CarMixin:
until the current is set again, then at most one corroboration window.
No when it was aborted (Off, Stop, shadow, unplug, another writer), a
write was refused, or it ran past its own maximum."""
+ if self.car_solar_mode():
+ return self._car_solar_pause(mono)
wr = getattr(self, "car_writer", None)
if wr is None or (wr.seq is None and wr.phase_done_at is None
and wr.zero_sent_at is None) or wr.hold:
@@ -235,6 +433,28 @@ class CarMixin:
<= OWN_PAUSE_MAX_S
return 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S
+ def _car_solar_pause(self, mono) -> bool:
+ """EV-05: Solar's own 0 A (a pause, the peak cut, the phase change)
+ gets EV-15's grace, bounded the same way: from the moment it is sent,
+ at most `OWN_PAUSE_MAX_S`; a phase change as in Manual. None for Stop,
+ shadow, an unplugged car or another writer."""
+ wr = getattr(self, "car_solar", None)
+ r = self.car.reading
+ if wr is None or wr.hold or not self.car_writing() or r is None \
+ or not r.available or r.state == "A":
+ return False
+ q = wr.seq
+ if q is not None:
+ return not q.get("failed") and 0.0 <= mono - q["t0"] \
+ <= OWN_PAUSE_MAX_S
+ if wr.zero_sent_at is not None:
+ return 0.0 <= mono - wr.zero_sent_at <= OWN_PAUSE_MAX_S
+ if wr.zero_at is not None and 0.0 <= mono - wr.zero_at \
+ <= OWN_PAUSE_MAX_S:
+ return True
+ return wr.phase_done_at is not None \
+ and 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S
+
def _car_quarter(self, proj, w, mono, wg=None) -> None:
"""The car's energy in the open quarter, for the average the guard's
house leaves out and for the peak line. `wg` (EV-15) is the figure for
@@ -245,11 +465,15 @@ class CarMixin:
last = q["mono"]
if key != q["key"]:
self._car_bank(q)
- q["key"], q["ws"], q["ws_p"] = key, 0.0, 0.0
+ q["key"], q["ws"], q["ws_p"], q["ws_b"] = key, 0.0, 0.0, 0.0
if key is not None and last is not None:
dt = min(max(mono - last, 0.0), 5.0)
if w is not None:
q["ws"] += float(w) * dt
+ if not self.car_solar_mode():
+ # EV-05: only a charge you set can be "set by the car";
+ # a Solar charge runs on spare sun and is cut first.
+ q["ws_b"] = q.get("ws_b", 0.0) + float(w) * dt
elif wg is not None:
q["ws_p"] = q.get("ws_p", 0.0) + float(wg) * dt
q["mono"] = mono
@@ -259,7 +483,7 @@ class CarMixin:
key = q["key"]
if key is None:
return
- avg = q["ws"] / QUARTER_S
+ avg = q.get("ws_b", q["ws"]) / QUARTER_S
if avg < CAR_PEAK_MIN_W:
return
self.car_peak_q[key.astimezone(timezone.utc).isoformat()] = round(avg)
@@ -317,6 +541,22 @@ class CarMixin:
"""After the guard has decided: does the car alone explain the excess?
`real_proj` is the projection WITH the car, whatever the guard saw."""
mono = self.car_now()
+ # EV-05: the period's own key, and the excess Solar takes off the car
+ # first (the writer step that follows this cycle acts on it at once).
+ self._car_key = None if real_proj is None else real_proj.block_start
+ self.car_cut_w = 0.0
+ # What the guard would ASK the batteries to give (`wanted_w`, its floor
+ # before the rating) is taken off the car instead, up to the excess:
+ # batteries that only stop charging are not asked for anything.
+ if self.car_solar_mode() and real_proj is not None \
+ and target_w is not None and real_proj.block_start is not None \
+ and guard is not None and guard.engaged and guard.blind is None:
+ ex = peakguard.excess_w(real_proj, target_w)
+ want = guard.wanted_w
+ if ex is not None and want is not None and math.isfinite(ex) \
+ and math.isfinite(want) and ex > 0.0 and want > 0.0:
+ self.car_cut_w = float(min(ex, want))
+ self._car_sun_tick(mono)
w = self.car_alarm_w()
# EV-15: the figure for grading only. Our own phase change holds the
# car at 0 A and the energy meter cannot corroborate it then, so for
@@ -331,7 +571,11 @@ class CarMixin:
and real_proj.block_start is not None:
# EV-10: every cycle, so the latches do not depend on the option.
graded = self._car_explains_alarm(real_proj, guard, target_w, wg)
- if self.car_cover:
+ if self.car_solar_mode():
+ # EV-05: Solar is cut first, so it is never "over"; its own
+ # 0 A must not leave the house's alarm graded with the car.
+ explains = graded
+ elif self.car_cover:
explains = over = graded
elif w is not None:
ex = float(real_proj.projected_w) - float(target_w)
diff --git a/goodwe_controller/app/ctl_cycle.py b/goodwe_controller/app/ctl_cycle.py
index 82c0bab..1f9cdc0 100644
--- a/goodwe_controller/app/ctl_cycle.py
+++ b/goodwe_controller/app/ctl_cycle.py
@@ -253,6 +253,7 @@ class CycleMixin:
stale_after = float(self.o.get("stale_input_s", 15))
late_s = self._readings_late(site_standing) # SAFETY-128
+ self._car_late_s = late_s # EV-05: Solar holds, then the stale rule
self._late_zero = late_s is not None and late_s >= stale_after
# ⚠️ `any`, NOT the sole unit's. The hold exists so a single missed
# poll does not become a fault; a LATCHED inverter must still reach the
@@ -272,6 +273,7 @@ class CycleMixin:
# this cycle's. (DECISIONS/MAIN-orchestration-archive.md)
self.why_words = messages.why_waiting(bad_for)
self._why_waiting_since = now - timedelta(seconds=bad_for)
+ self._car_hold_kick() # EV-05: Solar counts from now
return
if late_s is not None and late_s < stale_after and self.inputs_ok \
and (self.auto or self.shadow) \
@@ -279,6 +281,7 @@ class CycleMixin:
and not (n_units > 1 and self.site_sign_wd.tripped):
self.reason = f"readings late {late_s:.0f}s" # SAFETY-128: hold
self.why_words = messages.why_late()
+ self._car_hold_kick() # EV-05: Solar holds its current
return
claims = []
@@ -1065,7 +1068,8 @@ class CycleMixin:
await self.check_price_gap()
await self.check_charger()
await self.check_car_over()
- self.car_kick() # EV-04: Manual, in the background
+ await self.check_car_error() # EV-05: Solar's charger error
+ self.car_kick() # EV-04/05: in the background
await self.check_fixed_note()
# SAFETY-31's alarm, and its boundary is the LATCH, not a number: it
diff --git a/goodwe_controller/app/ctl_status.py b/goodwe_controller/app/ctl_status.py
index 4dda3ec..19ad5ae 100644
--- a/goodwe_controller/app/ctl_status.py
+++ b/goodwe_controller/app/ctl_status.py
@@ -205,7 +205,20 @@ class StatusMixin:
"text": messages.row_charger_unreach(
f"{brussels(self.car.bad_since_utc):%H:%M}")})
w = self.car_writer
- if self.car_mode == "manual":
+ sw = self.car_solar
+ if self.car_mode == "solar":
+ # EV-05: in Solar another writer stops the add-on's writes: amber,
+ # the same words as in Manual.
+ if sw.other:
+ out.append({"ok": False, "warn": True, "id": "charger_other",
+ "text": messages.row_charger_other()})
+ if sw.gave_up:
+ out.append({"ok": False, "warn": True, "id": "charger_refused",
+ "text": messages.row_charger_refused()})
+ if sw.phases_gave_up:
+ out.append({"ok": False, "warn": True, "id": "charger_phases",
+ "text": messages.row_charger_phases()})
+ elif self.car_mode == "manual":
# EV-04: in Manual the add-on's own writes are not "another
# writer"; its own detector (a read-back that differs from the
# last write for 30 s) says so, in grey.
@@ -250,6 +263,8 @@ class StatusMixin:
or r.power_w is None else round(r.power_w, 1)),
"car_today_kwh": (PAYLOAD_NONE if self.car.today_kwh is None
else round(self.car.today_kwh, 3)),
+ "car_today_solar_kwh": (PAYLOAD_NONE if self.car_sun_kwh() is None
+ else round(self.car_sun_kwh(), 3)),
}
# -- UI ------------------------------------------------------------------
@@ -922,7 +937,7 @@ class StatusMixin:
now = datetime.now(timezone.utc)
if what in ("pack_use", "pack_mode", "pack_sell"):
return self._pack_action(what, unit, value, now)
- if what in ("car_mode", "car_current", "car_phases"):
+ if what in ("car_mode", "car_current", "car_phases", "car_sun_first"):
return self._car_action(what, value, now)
if what == "auto_toggle":
self.auto = not self.auto
diff --git a/goodwe_controller/app/homeview.py b/goodwe_controller/app/homeview.py
index 941e941..5e4b775 100644
--- a/goodwe_controller/app/homeview.py
+++ b/goodwe_controller/app/homeview.py
@@ -1147,7 +1147,8 @@ def month_peak(c, now):
# set the month's peak. Both empty without a charger in Manual.
out["car_line"] = out["set_by"] = ""
if getattr(c, "car_enabled", False) and c.charger.configured():
- w = c.car_alarm_w()
+ # EV-05: Manual only. A Solar charge is cut first for the peak.
+ w = c.car_alarm_w() if c.car_manual() else None
if pg is not None and w is not None and w >= 500.0 \
and out["period_w"] is not None and (pg.engaged or c.car_over):
out["car_line"] = _t("peak.car", kw=_kw(out["period_w"]),
@@ -1330,6 +1331,64 @@ def _car_manual_why(c, key):
return _t("car.why.manual_set", a=a, phases=car_phases_word(c.car_n))
+def _names(invs) -> str:
+ names = [str(i.name) for i in invs]
+ return " " .join(names[:1]) if len(names) == 1 else \
+ ", ".join(names[:-1]) + " " + _t("car.and") + " " + names[-1]
+
+
+def _car_solar_why(c, key):
+ """EV-05: the Why of Solar, from what the plan did this cycle. Plan
+ lines: two sentences of at most 12 words."""
+ w = c.car_solar
+ p = w.plan
+ o = getattr(c, "o", {}) or {}
+ if w.other:
+ return _t("car.why.solar_other")
+ if c.shadow:
+ a, n = w.would if w.would is not None else (0.0, p.n)
+ if a and a >= 6:
+ return _t("car.why.manual_would", a=f"{float(a):.0f}",
+ phases=car_phases_word(n))
+ return _t("car.why.solar_would")
+ if not c.auto or not c.car_writing():
+ return _t("car.why.solar_stopped")
+ if w.fault in ("error", "stuck"):
+ return _t("car.why.solar_" + w.fault)
+ if key in ("none", "full"):
+ return _t("car.why." + key)
+ why = p.why
+ if why == "running":
+ sun = getattr(c, "_car_sun_last", None)
+ if sun is None or sun.spare_w is None:
+ return _t("car.why.solar_unknown")
+ if sun.first == carmode.FIRST_CAR:
+ return _t("car.why.solar_car",
+ kw=_kw(max(0.0, sun.spare_w - sun.margin_w)),
+ phases=car_phases_word(w.n_calc))
+ room = [i for i in c.inverters if c.car_may_charge(i)]
+ full = [i for i in c.inverters if not c.car_may_charge(i)
+ and i.soc is not None and float(i.soc) >= 100.0]
+ left = _kw(max(0.0, sun.spare_w - sun.room_w))
+ m = watts_text(sun.margin_w)
+ if room and full:
+ return _t("car.why.solar_batt", a=_names(room), b=_names(full),
+ kw=left, m=m)
+ if room:
+ return _t("car.why.solar_batt_room", a=_names(room), kw=left,
+ m=m)
+ return _t("car.why.solar_batt_full", kw=left, m=m)
+ mins = {"hold": "ev_pause_min"}.get(why, "ev_start_min")
+ s = f"{carmode.solar_option(o, mins):.0f}"
+ if why in ("hold", "start", "cut", "unknown"):
+ return _t("car.why.solar_" + why, s=s)
+ return _t("car.why.solar_paused", s=s)
+
+
+def watts_text(w) -> str:
+ return f"{float(w):.0f} W"
+
+
def car_block(c, now):
"""The Car card for `/status`, or None when no charger is switched on (the
page then draws nothing, as before)."""
@@ -1342,12 +1401,22 @@ def car_block(c, now):
good = c.car.last_good
fresh = configured and c.car.fresh(mono)
today = None
- if configured and c.car.today_kwh is not None:
- today = _t("car.today", kwh=_kwh(c.car.today_kwh))
mode = getattr(c, "car_mode", "off") if configured else "off"
+ if configured and c.car.today_kwh is not None:
+ sun = c.car_sun_kwh() if hasattr(c, "car_sun_kwh") else None
+ today = (_t("car.today_sun", kwh=_kwh(c.car.today_kwh),
+ sun=_kwh(sun))
+ if mode == "solar" and sun is not None
+ else _t("car.today", kwh=_kwh(c.car.today_kwh)))
why = _car_why(key, c, good)
if mode == "manual" and key in ("charging", "waiting", "none", "full"):
why = _car_manual_why(c, key)
+ if mode == "solar" and key in ("charging", "waiting", "none", "full",
+ "fault"):
+ why = _car_solar_why(c, key)
+ # EV-05: a car Solar holds at 0 A is waiting for the sun.
+ if key == "waiting" and c.car_solar.plan.a <= 0.0:
+ key = "paused"
out = {
"state": key or "wait",
"chip": car_state_word(key),
@@ -1360,11 +1429,13 @@ def car_block(c, now):
else round(float(r.power_w), 1)),
}
if configured:
- # EV-04: what the page can set. Off and Manual only (Solar and Night
- # are later cards, so they are not offered).
+ # EV-04: what the page can set. EV-05 adds Solar and where its spare
+ # sun goes first (Night is a later card, so it is not offered).
clamp = c.car_clamp()
hi = int(clamp) if clamp is not None and clamp >= 6 else 6
- out["modes"] = ["off", "manual"]
+ out["modes"] = list(carmode.MODES)
+ out["first"] = {"value": getattr(c, "car_first", carmode.DEFAULT_FIRST),
+ "choices": list(carmode.FIRSTS)}
out["current"] = {"value": round(float(c.car_a)), "min": 6,
"max": hi}
out["phases"] = {"value": c.car_n,
@@ -1883,8 +1954,12 @@ def _samples() -> list:
out += [("plan", _t("car.big." + k, t="09:12")) for k in
words["car"]["big"]]
out += [("plan", _t("car.why." + k, a="10", brand="Alfen", kw="8.6 kW",
- pct="20 %", phases=car_phases_word(3)))
+ pct="20 %", phases=car_phases_word(3),
+ b="inverter-b", m="100 W", s="5"))
for k in words["car"]["why"]]
+ out += [("plan", _t("car.why.solar_batt", a="inverter-a",
+ b="inverter-b", kw="2.0 kW", m="100 W")),
+ ("plan", _t("car.today_sun", kwh="14.2 kWh", sun="3.1 kWh"))]
out += [("plan", _t("peak.car", kw="12.1 kW", car="11.0 kW",
cov="8.6 kW")),
("plan", _t("peak.set_by_car", t="19:45"))]
diff --git a/goodwe_controller/app/main.py b/goodwe_controller/app/main.py
index 8b622c9..c35c1b5 100644
--- a/goodwe_controller/app/main.py
+++ b/goodwe_controller/app/main.py
@@ -1040,8 +1040,14 @@ class Controller(InputsMixin, WritesMixin, TradeMixin, CycleMixin, AlarmsMixin,
self.stopping = True
_LOG.info(handback.log_shutdown(handback.current())
or "shutting down - commanding 0 W on every inverter")
- await self.command_site_release()
- await self.car_shutdown() # EV-04: undo a phase change half way
+ if self.car_solar_engaged():
+ # EV-05: Solar's fail state is 0 A, and it goes out BEFORE the
+ # inverters go to 0 W (bounded by `ctl_car.RELEASE_WAIT_S`).
+ await self.car_shutdown()
+ await self.command_site_release()
+ else:
+ await self.command_site_release()
+ await self.car_shutdown() # EV-04: undo a phase change half way
self.mqtt.close()
diff --git a/goodwe_controller/app/messages.py b/goodwe_controller/app/messages.py
index 33ae65e..5d5a1b9 100644
--- a/goodwe_controller/app/messages.py
+++ b/goodwe_controller/app/messages.py
@@ -190,6 +190,8 @@ T_CHARGER_UNREACH = "Charger not reachable"
T_CHARGER_UNREACH_NL = "Laadpaal onbereikbaar"
T_CAR_OVER = "Car over the peak limit"
T_CAR_OVER_NL = "Auto boven de piekgrens"
+T_CHARGER_ERROR = "Charger error, car paused"
+T_CHARGER_ERROR_NL = "Laadpaalfout, auto gepauzeerd"
T_NO_PRICES = "No prices"
T_NO_PRICES_NL = "Prijzen ontbreken"
@@ -204,6 +206,7 @@ ID_MAINT_FAILED = "goodwe_maint_failed_{slug}"
ID_NO_PRICES = "goodwe_no_prices"
ID_CHARGER_UNREACH = "goodwe_charger_unreachable"
ID_CAR_OVER = "goodwe_car_over"
+ID_CHARGER_ERROR = "goodwe_charger_error"
# PRICE-01: an earlier build raised a card with this id. Nothing raises it now;
# the add-on only dismisses it at start.
OLD_FIXED_CARD_ID = "goodwe_fixed_tariff_unused"
@@ -510,6 +513,22 @@ def car_over(a_text) -> Notice:
body_nl=f"{T_CAR_OVER_NL}. {nl}")
+def charger_error() -> Notice:
+ """EV-05: in Solar the charger reports an error, so the add-on set the car
+ to 0 A. Said once per error, taken down when it clears."""
+ en = ("The charger reports an error, so the add-on paused the car until "
+ "it clears.")
+ nl = ("De laadpaal meldt een fout, dus de add-on pauzeert de auto tot die "
+ "verdwijnt.")
+ return Notice(ID_CHARGER_ERROR, WARNING, T_CHARGER_ERROR, en,
+ body_nl=f"{T_CHARGER_ERROR_NL}. {nl}")
+
+
+def charger_error_gone() -> Dismiss:
+ """EV-05: takes the 'Charger error, car paused' notification down."""
+ return Dismiss(ID_CHARGER_ERROR)
+
+
def row_car_over() -> str:
"""EV-04: the grey row while the car charge you set is over the peak limit."""
return Bi("The car charge you set takes this 15-minute period over the "
@@ -1484,6 +1503,7 @@ HINTS = {
"car_mode": "Car mode set",
"car_current": "Car current set",
"car_phases": "Car phases set",
+ "car_sun_first": "Where spare sun goes first set",
"settings_saved": "Settings saved, they apply after a restart",
"restart_requested": "Restart requested from the settings page",
"setup_only": "In setup, nothing is sent to any inverter",
@@ -1822,6 +1842,7 @@ def samples() -> list:
no_prices(),
charger_unreachable("09:12"),
car_over("16"),
+ charger_error(),
]
@@ -1891,6 +1912,9 @@ LABELS = {
"ev_batt_cover": "Batteries help with the peak",
"ev_mode_start": "Mode after a restart",
"ev_phases": "Phases",
+ "ev_margin_w": "Sun kept back",
+ "ev_pause_min": "Pause after",
+ "ev_start_min": "Start after",
}
@@ -1977,6 +2001,9 @@ LABELS_NL = {
"ev_batt_cover": "Batterijen helpen met de piek",
"ev_mode_start": "Modus na een herstart",
"ev_phases": "Fasen",
+ "ev_margin_w": "Zon achtergehouden",
+ "ev_pause_min": "Pauzeren na",
+ "ev_start_min": "Starten na",
}
# The inverter list shows two of them under a shorter name.
UNIT_LABELS_NL = {"setpoint_entity": "Setpoint-entiteit",
diff --git a/goodwe_controller/app/mqtt.py b/goodwe_controller/app/mqtt.py
index be471be..2f0e54a 100644
--- a/goodwe_controller/app/mqtt.py
+++ b/goodwe_controller/app/mqtt.py
@@ -144,6 +144,8 @@ OPTIONAL_SENSORS = [
("car_power", "goodwe_car_power", "Car power", "W", "power", "measurement", "mdi:car-electric"),
("car_state", "goodwe_car_state", "Car state", None, None, None, "mdi:ev-station"),
("car_today_kwh", "goodwe_car_today_kwh", "Car energy today", "kWh", "energy", "total_increasing", "mdi:ev-station"),
+ # EV-05: what of today's charge came from the sun (Solar mode only).
+ ("car_today_solar_kwh", "goodwe_car_today_solar_kwh", "Car solar energy today", "kWh", "energy", "total_increasing", "mdi:solar-power"),
]
# ⚠️ HA's OWN "this sensor has no value" PAYLOAD, and the one place this add-on
@@ -200,7 +202,8 @@ def optional_keys(opts: dict) -> tuple:
from . import chargers as _ch # EV-03: same reason
out = ("pv",) if _pv.entities(opts) else ()
if _ch.census_entity(opts):
- out += ("car_power", "car_state", "car_today_kwh")
+ out += ("car_power", "car_state", "car_today_kwh",
+ "car_today_solar_kwh")
return out
@@ -524,18 +527,24 @@ def mode_payloads(units, modes) -> list:
# --- EV-04: the car's mode, current and phases, as HA entities ----------------
# Announced only with a charger switched on, after every other row. A command
# goes through Controller.handle_action(); a retained one is dropped.
-CAR_MODE_LABELS = {"off": "Off", "manual": "Manual"} # English, pinned
+CAR_MODE_LABELS = {"off": "Off", "manual": "Manual", # English, pinned
+ "solar": "Solar"} # EV-05
+# EV-05: where spare sun goes first; mirrors carmode.FIRST_LABELS (this module
+# imports nothing from the package, test_ev05.py checks the two agree).
+CAR_FIRST_LABELS = {"batteries": "Batteries", "car": "Car"}
CAR_MODES = tuple(CAR_MODE_LABELS)
CAR_CONFIGS_KEY = "mqtt_car_configs"
CAR_MIN_A = 6
-_CAR_CMD_RE = re.compile(rf"{BASE}/car/(mode|current|phases)/set")
+_CAR_CMD_RE = re.compile(rf"{BASE}/car/(mode|current|phases|sun_first)/set")
_CAR_CONFIG_RE = re.compile(
- rf"homeassistant/(select|number)/{BASE}_car_(mode|current|phases)/config")
+ rf"homeassistant/(select|number)/{BASE}_car_(mode|current|phases|sun_first)"
+ rf"/config")
# (key, component, name, icon)
CAR_ENTITIES = [
("mode", "select", "Car mode", "mdi:car-electric"),
("current", "number", "Car current", "mdi:current-ac"),
("phases", "select", "Car phases", "mdi:sine-wave"),
+ ("sun_first", "select", "Car spare sun first", "mdi:solar-power"), # EV-05
]
@@ -560,6 +569,8 @@ def car_payloads(car) -> list:
cfg["options"] = list(CAR_MODE_LABELS.values())
elif key == "phases":
cfg["options"] = [str(n) for n in phases]
+ elif key == "sun_first":
+ cfg["options"] = list(CAR_FIRST_LABELS.values())
else:
cfg.update({"min": CAR_MIN_A, "max": int(max_a), "step": 1,
"unit_of_measurement": "A", "device_class": "current",
@@ -607,6 +618,9 @@ def parse_car_command(topic, payload, retained):
None)
elif key == "phases":
value = {"1": 1, "3": 3}.get(text)
+ elif key == "sun_first":
+ value = next((k for k, v in CAR_FIRST_LABELS.items() if v == text),
+ None)
else:
try:
f = float(text)
diff --git a/goodwe_controller/app/static/app.js b/goodwe_controller/app/static/app.js
index 82bae51..14617ad 100644
--- a/goodwe_controller/app/static/app.js
+++ b/goodwe_controller/app/static/app.js
@@ -160,8 +160,9 @@
$("#car-why").textContent = c.why;
renderCarControls(c);
}
- // EV-04: Off and Manual. The mode and the phases send at once; the current
- // sends after two seconds of rest. A slider being dragged is left alone.
+ // EV-04: Off and Manual; EV-05: Solar and where its spare sun goes first.
+ // The mode, the phases and the choice send at once; the current sends after
+ // two seconds of rest. A slider being dragged is left alone.
let carTouch = 0, carTimer = null, carBusy = false;
async function carAct(what, value) {
if (carBusy) return;
@@ -182,6 +183,13 @@
type: "button", role: "radio", "aria-checked": String(c.mode === m),
onclick: () => carAct("car_mode", m) }, t("car.mode_" + m))));
$("#car-help").textContent = t("car.help_" + c.mode + ".description") || "";
+ const sol = c.mode === "solar" && !!c.first;
+ $("#car-solar").hidden = !sol;
+ if (sol) {
+ $("#car-first").replaceChildren(...c.first.choices.map((f) => h("button", {
+ type: "button", role: "radio", "aria-checked": String(c.first.value === f),
+ onclick: () => carAct("car_sun_first", f) }, t("car.first_" + f))));
+ }
const on = c.mode === "manual" && !!c.current;
$("#car-manual").hidden = !on;
if (!on) return;
diff --git a/goodwe_controller/app/static/index.html b/goodwe_controller/app/static/index.html
index fa2a6fa..78dca29 100644
--- a/goodwe_controller/app/static/index.html
+++ b/goodwe_controller/app/static/index.html
@@ -52,6 +52,11 @@
+
diff --git a/goodwe_controller/app/ui_text/en.json b/goodwe_controller/app/ui_text/en.json
index 0cf0be9..2afce87 100644
--- a/goodwe_controller/app/ui_text/en.json
+++ b/goodwe_controller/app/ui_text/en.json
@@ -91,7 +91,7 @@
"loading": "Loading the forecast."
},
"peak": {"name": "Peak limit", "this_month": "This month's peak", "limit": "Limit", "none": "None recorded yet", "unreadable": "Cannot be read now"},
- "car": {"name": "Car", "mode": "Mode", "mode_off": "Off", "mode_manual": "Manual", "help_off": {"description": "The add-on leaves the charger alone."}, "help_manual": {"description": "Charges at the current you set, whatever the sun or the peak limit do."}, "current": "Current", "phases": "Phases", "phases_1": "1 phase", "phases_3": "3 phases", "why": "Why"},
+ "car": {"name": "Car", "mode": "Mode", "mode_off": "Off", "mode_manual": "Manual", "help_off": {"description": "The add-on leaves the charger alone."}, "help_manual": {"description": "Charges at the current you set, whatever the sun or the peak limit do."}, "current": "Current", "phases": "Phases", "phases_1": "1 phase", "phases_3": "3 phases", "why": "Why", "mode_solar": "Solar", "help_solar": {"description": "Charges only from spare sun and pauses when there is too little."}, "first": "Spare sun goes first to", "first_batteries": "Batteries", "first_car": "Car", "first_help": {"description": "Batteries: the car gets sun only when the batteries charge at full power or are full."}},
"attention": {"name": "Needs attention", "nothing": "Nothing to look at", "to_look": "to look at", "details": "Details", "alarm": "Alarm", "warning": "Warning", "info": "Info"},
"control": {"name": "Control", "stop": "Stop control", "start": "Start control", "maint_start": "Start a battery cycle now", "maint_abort": "Stop the battery cycle", "docs": "Add-on documentation", "more": "More actions"},
"details": {"name": "Details for installers", "rows": "Status rows", "checks": "Checks", "event": "Last event"},
@@ -302,11 +302,11 @@
"warning": "See Needs attention below."
},
"car": {
- "state": {"charging": "Charging", "waiting": "Connected, waiting", "none": "No car connected", "full": "Car is full", "unreach": "Charger not reachable", "setup": "Charger not set up", "fault": "Charger fault", "wait": "No reading yet"},
- "big": {"waiting": "Connected, not charging.", "none": "Nothing to charge.", "full": "The car is full.", "seen": "Last seen at {t}.", "no_reading": "No reading.", "setup": "Not set up.", "fault": "The charger reports a fault.", "wait": "No reading yet."},
+ "state": {"charging": "Charging", "waiting": "Connected, waiting", "none": "No car connected", "full": "Car is full", "unreach": "Charger not reachable", "setup": "Charger not set up", "fault": "Charger fault", "wait": "No reading yet", "paused": "Waiting for sun"},
+ "big": {"waiting": "Connected, not charging.", "none": "Nothing to charge.", "full": "The car is full.", "seen": "Last seen at {t}.", "no_reading": "No reading.", "setup": "Not set up.", "fault": "The charger reports a fault.", "wait": "No reading yet.", "paused": "Waiting for spare sun."},
"phase_one": "1 phase",
"phase_many": "{n} phases",
- "today": "{kwh} charged today.",
+ "today": "{kwh} charged today.", "today_sun": "{kwh} charged today, {sun} from the sun.", "and": "and",
"why": {
"charging": "The charger is charging the car. The add-on leaves it alone.",
"waiting": "The car is connected and not charging. The add-on leaves the charger alone.",
@@ -329,7 +329,21 @@
"manual_wait": "You set {a} A. It is set when a car is connected.",
"manual_would": "Shadow mode: the add-on would set {a} A, {phases}.",
"manual_stopped": "Control is stopped. The charger keeps its last setting.",
- "manual_blocked": "The phases change once per 10 minutes at most. This waits."
+ "manual_blocked": "The phases change once per 10 minutes at most. This waits.",
+ "solar_batt": "Batteries first: {a} at full power, {b} is full. The car gets the {kw} left, less {m} kept back.",
+ "solar_batt_room": "Batteries first: {a} at full power. The car gets the {kw} left, less {m} kept back.",
+ "solar_batt_full": "Batteries first, and the batteries are full. The car gets the {kw} left, less {m} kept back.",
+ "solar_car": "Car first: the car takes {kw} on {phases}. The batteries get the rest of the sun.",
+ "solar_hold": "Too little spare sun, so the car holds 6 A for now. It pauses after {s} minutes like this.",
+ "solar_paused": "Too little spare sun for the car's minimum of 6 A. It starts after {s} minutes of enough sun.",
+ "solar_start": "There is enough spare sun now. The car starts after {s} minutes of it.",
+ "solar_cut": "The car was cut first to stay under the peak limit. It starts again after {s} minutes of enough sun.",
+ "solar_unknown": "The add-on cannot measure the spare sun now. The car pauses if this lasts.",
+ "solar_would": "Shadow mode: the add-on would keep the car paused.",
+ "solar_stopped": "Control is stopped, so the add-on paused the car.",
+ "solar_error": "The charger reports an error, so the add-on paused the car.",
+ "solar_stuck": "The charger reading may be stuck, so the add-on paused the car.",
+ "solar_other": "Something else changes the charger, so the add-on leaves it alone."
}
},
"peak": {
diff --git a/goodwe_controller/app/ui_text/nl.json b/goodwe_controller/app/ui_text/nl.json
index 975e3dd..4f9b678 100644
--- a/goodwe_controller/app/ui_text/nl.json
+++ b/goodwe_controller/app/ui_text/nl.json
@@ -88,7 +88,7 @@
"loading": "De prognose wordt geladen."
},
"peak": {"name": "Piekgrens", "this_month": "Piek van deze maand", "limit": "Grens", "none": "Nog niets gemeten", "unreadable": "Nu niet leesbaar"},
- "car": {"name": "Auto", "mode": "Modus", "mode_off": "Uit", "mode_manual": "Handmatig", "help_off": {"description": "De add-on laat de laadpaal met rust."}, "help_manual": {"description": "Laadt met de stroom die u instelt, wat de zon of de piekgrens ook doen."}, "current": "Stroom", "phases": "Fasen", "phases_1": "1 fase", "phases_3": "3 fasen", "why": "Waarom"},
+ "car": {"name": "Auto", "mode": "Modus", "mode_off": "Uit", "mode_manual": "Handmatig", "help_off": {"description": "De add-on laat de laadpaal met rust."}, "help_manual": {"description": "Laadt met de stroom die u instelt, wat de zon of de piekgrens ook doen."}, "current": "Stroom", "phases": "Fasen", "phases_1": "1 fase", "phases_3": "3 fasen", "why": "Waarom", "mode_solar": "Zon", "help_solar": {"description": "Laadt alleen met zonne-overschot en pauzeert als er te weinig is."}, "first": "Zonne-overschot gaat eerst naar", "first_batteries": "Batterijen", "first_car": "Auto", "first_help": {"description": "Batterijen: de auto krijgt pas zon als de batterijen op vol vermogen laden of vol zijn."}},
"attention": {"name": "Vraagt aandacht", "nothing": "Niets om na te kijken", "to_look": "na te kijken", "details": "Details", "alarm": "Alarm", "warning": "Waarschuwing", "info": "Info"},
"control": {"name": "Regeling", "stop": "Regeling stoppen", "start": "Regeling starten", "maint_start": "Nu een batterijcyclus starten", "maint_abort": "Batterijcyclus stoppen", "docs": "Documentatie van de add-on", "more": "Meer acties"},
"details": {"name": "Details voor installateurs", "rows": "Statusregels", "checks": "Controles", "event": "Laatste gebeurtenis"},
@@ -256,11 +256,11 @@
"pill": {"running": "Actief", "shadow": "Schaduwmodus", "stopped": "Gestopt", "alarm": "Heeft u nu nodig", "waiting": "Wacht op Home Assistant", "warning": "Actief, met een waarschuwing"},
"banner_sub": {"running": "De batterijen volgen het plan hieronder.", "shadow": "De plannen hieronder tonen wat de add-on zou doen.", "stopped": "Start de regeling hieronder als u klaar bent.", "alarm": "Zie Vraagt aandacht hieronder voor wat u moet doen.", "waiting": "De regeling gaat vanzelf verder zodra Home Assistant antwoordt.", "warning": "Zie Vraagt aandacht hieronder."},
"car": {
- "state": {"charging": "Laadt", "waiting": "Aangesloten, wacht", "none": "Geen auto aangesloten", "full": "Auto is vol", "unreach": "Laadpaal onbereikbaar", "setup": "Laadpaal niet ingesteld", "fault": "Laadpaalstoring", "wait": "Nog geen meting"},
- "big": {"waiting": "Aangesloten, laadt niet.", "none": "Niets te laden.", "full": "De auto is vol.", "seen": "Laatst gezien om {t}.", "no_reading": "Geen meting.", "setup": "Niet ingesteld.", "fault": "De laadpaal meldt een storing.", "wait": "Nog geen meting."},
+ "state": {"charging": "Laadt", "waiting": "Aangesloten, wacht", "none": "Geen auto aangesloten", "full": "Auto is vol", "unreach": "Laadpaal onbereikbaar", "setup": "Laadpaal niet ingesteld", "fault": "Laadpaalstoring", "wait": "Nog geen meting", "paused": "Wacht op zon"},
+ "big": {"waiting": "Aangesloten, laadt niet.", "none": "Niets te laden.", "full": "De auto is vol.", "seen": "Laatst gezien om {t}.", "no_reading": "Geen meting.", "setup": "Niet ingesteld.", "fault": "De laadpaal meldt een storing.", "wait": "Nog geen meting.", "paused": "Wacht op zonne-overschot."},
"phase_one": "1 fase",
"phase_many": "{n} fasen",
- "today": "Vandaag {kwh} geladen.",
+ "today": "Vandaag {kwh} geladen.", "today_sun": "Vandaag {kwh} geladen, {sun} van de zon.", "and": "en",
"why": {
"charging": "De laadpaal laadt de auto. De add-on laat haar met rust.",
"waiting": "De auto is aangesloten en laadt niet. De add-on laat de laadpaal met rust.",
@@ -283,7 +283,21 @@
"manual_wait": "U stelde {a} A in. Het wordt ingesteld zodra een auto is aangesloten.",
"manual_would": "Schaduwmodus: de add-on zou {a} A instellen, {phases}.",
"manual_stopped": "De regeling is gestopt. De laadpaal houdt haar laatste instelling.",
- "manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht."
+ "manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht.",
+ "solar_batt": "Eerst de batterijen: {a} op vol vermogen, {b} is vol. De auto krijgt de {kw} die overblijft, min {m} marge.",
+ "solar_batt_room": "Eerst de batterijen: {a} op vol vermogen. De auto krijgt de {kw} die overblijft, min {m} marge.",
+ "solar_batt_full": "Eerst de batterijen, en die zijn vol. De auto krijgt de {kw} die overblijft, min {m} marge.",
+ "solar_car": "Eerst de auto: die neemt {kw} op {phases}. De batterijen krijgen de rest van de zon.",
+ "solar_hold": "Te weinig zonne-overschot, dus de auto houdt nu 6 A. Na {s} minuten zo pauzeert ze.",
+ "solar_paused": "Te weinig zonne-overschot voor het minimum van de auto, 6 A. Ze start na {s} minuten genoeg zon.",
+ "solar_start": "Er is nu genoeg zonne-overschot. De auto start na {s} minuten daarvan.",
+ "solar_cut": "De auto werd eerst teruggeschroefd voor de piekgrens. Ze start weer na {s} minuten genoeg zon.",
+ "solar_unknown": "De add-on kan het zonne-overschot nu niet meten. De auto pauzeert als dit duurt.",
+ "solar_would": "Schaduwmodus: de add-on zou de auto gepauzeerd houden.",
+ "solar_stopped": "De regeling is gestopt, dus de add-on pauzeert de auto.",
+ "solar_error": "De laadpaal meldt een fout, dus de add-on pauzeert de auto.",
+ "solar_stuck": "De laadpaal meet mogelijk niet meer, dus de add-on pauzeert de auto.",
+ "solar_other": "Iets anders wijzigt de laadpaal, dus de add-on laat haar met rust."
}
},
"peak": {
diff --git a/goodwe_controller/app/uilayout.py b/goodwe_controller/app/uilayout.py
index 0bb138a..bedcbc5 100644
--- a/goodwe_controller/app/uilayout.py
+++ b/goodwe_controller/app/uilayout.py
@@ -234,6 +234,9 @@ GROUPS = (
Field("ev_phases", SEGMENTED, simple=True, show=_CAR),
Field("ev_batt_cover", TOGGLE, simple=True, show=_CAR),
Field("ev_mode_start", SEGMENTED, simple=True, show=_CAR),
+ Field("ev_margin_w", SLIDER, "W", step=10, show=_CAR),
+ Field("ev_start_min", SLIDER, "min", show=_CAR),
+ Field("ev_pause_min", SLIDER, "min", show=_CAR),
)),
)),
Group("maintenance", (
diff --git a/goodwe_controller/app/validate.py b/goodwe_controller/app/validate.py
index 58833ac..c814a7b 100644
--- a/goodwe_controller/app/validate.py
+++ b/goodwe_controller/app/validate.py
@@ -688,6 +688,17 @@ def _charger_problems(opts: dict, writers: dict) -> list[str]:
out.append(f"{S('ev_max_a')} is {messages.shown(opts.get('ev_max_a'))}"
f". Set it from {chargers.MIN_A:.0f} to "
f"{chargers.ENTITY_MAX_A:.0f} A.")
+ # EV-05: Solar's sun kept back and its two dwells, each in its range.
+ for key, (lo, hi) in chargers.SOLAR_RANGES.items():
+ raw = opts.get(key, chargers.EV_OPTION_DEFAULTS[key])
+ try:
+ v = float(raw)
+ ok = not isinstance(raw, bool) and v == v and lo <= v <= hi
+ except (TypeError, ValueError):
+ ok = False
+ if not ok:
+ out.append(f"{S(key)} is {messages.shown(raw)}. Set it from {lo} "
+ f"to {hi}.")
entity = chargers.census_entity(opts)
if entity and drivers.census_key(entity) in writers:
out.append(f"{S('ev_current_entity')} is {entity}, which an inverter "
diff --git a/goodwe_controller/app/web.py b/goodwe_controller/app/web.py
index 3a17a94..81b4745 100644
--- a/goodwe_controller/app/web.py
+++ b/goodwe_controller/app/web.py
@@ -62,7 +62,7 @@ _LOG = logging.getLogger("goodwe.web")
# OPT-11: the per-battery actions, which name a battery and a value.
PACK_ACTIONS = ("pack_use", "pack_mode", "pack_sell")
-CAR_ACTIONS = ("car_mode", "car_current", "car_phases")
+CAR_ACTIONS = ("car_mode", "car_current", "car_phases", "car_sun_first")
# MAINT-11: start or stop one battery's maintenance cycle (the unit is optional).
MAINT_ACTIONS = ("maint_start", "maint_abort")
diff --git a/goodwe_controller/config.yaml b/goodwe_controller/config.yaml
index 90cae0d..f1ccdfd 100644
--- a/goodwe_controller/config.yaml
+++ b/goodwe_controller/config.yaml
@@ -873,20 +873,25 @@ options:
shadow_mode: "auto"
# ==========================================================================
- # CAR CHARGER (EV-03 reads it, EV-04 adds Manual)
+ # CAR CHARGER (EV-03 reads it, EV-04 adds Manual, EV-05 Solar)
# ==========================================================================
# `off` is the shipped value and means NO CHANGE AT ALL: nothing is read,
# shown or announced, and the House tile and the house profile are as before.
# `alfen_ha` drives the charger through its Home Assistant integration. The
- # mode (Off or Manual), the current and the phases are runtime state in the
- # store, not options. `ev_batt_cover`: the batteries help with the peak while
- # the car charges. `ev_mode_start`: the mode after a restart.
+ # mode (Off, Manual or Solar), the current, the phases and where spare sun
+ # goes first are runtime state in the store, not options. `ev_batt_cover`:
+ # the batteries help with the peak while the car charges. `ev_mode_start`:
+ # the mode after a restart. Solar: `ev_margin_w` sun kept back, and the car
+ # starts after `ev_start_min` of enough sun and pauses after `ev_pause_min`.
ev_charger: "off"
ev_current_entity: ""
ev_max_a: 16
ev_phases: "auto"
ev_batt_cover: true
ev_mode_start: "keep"
+ ev_margin_w: 100
+ ev_start_min: 2
+ ev_pause_min: 5
# ==========================================================================
# ADVANCED - the control law and diagnostics
@@ -1266,7 +1271,7 @@ schema:
shadow_mode: list(auto|on|off)
# ==========================================================================
- # CAR CHARGER (EV-03 reads it, EV-04 adds Manual)
+ # CAR CHARGER (EV-03 reads it, EV-04 adds Manual, EV-05 Solar)
# ==========================================================================
# `ev_current_entity` is the charger's current setpoint; the other entities
# are found from its name. `ev_max_a` may not exceed the charger's own station
@@ -1277,6 +1282,9 @@ schema:
ev_phases: list(1|3|auto)
ev_batt_cover: bool
ev_mode_start: list(keep|off)
+ ev_margin_w: int(0,1000)
+ ev_start_min: int(1,30)
+ ev_pause_min: int(1,30)
# ==========================================================================
# ADVANCED - the control law and diagnostics
diff --git a/goodwe_controller/test_ev03.py b/goodwe_controller/test_ev03.py
index 905ece4..9292284 100644
--- a/goodwe_controller/test_ev03.py
+++ b/goodwe_controller/test_ev03.py
@@ -905,16 +905,18 @@ check("it stays for an hour and then goes",
# --------------------------------------------------------------------------- #
print("\n9. THE MQTT SENSORS")
# --------------------------------------------------------------------------- #
-check("the three car sensors are announced only with a charger on",
+check("the car sensors (EV-05: four, with today's solar kWh) are announced "
+ "only with a charger on",
mqtt.optional_keys(CAR) == ("pv", "car_power", "car_state",
- "car_today_kwh")
+ "car_today_kwh", "car_today_solar_kwh")
and mqtt.optional_keys(BASE) == ("pv",))
pl = dict(mqtt.discovery_payloads(include=mqtt.optional_keys(CAR)))
names = sorted(k for k in pl if "_car_" in k)
-check(f"discovery announces three sensors, goodwe_car_power, "
- f"goodwe_car_state and goodwe_car_today_kwh ({names})",
+check(f"discovery announces the sensors goodwe_car_power, goodwe_car_state, "
+ f"goodwe_car_today_kwh and (EV-05) goodwe_car_today_solar_kwh ({names})",
[pl[k]["object_id"] for k in names] == [
- "goodwe_car_power", "goodwe_car_state", "goodwe_car_today_kwh"]
+ "goodwe_car_power", "goodwe_car_state", "goodwe_car_today_kwh",
+ "goodwe_car_today_solar_kwh"]
and all(k.startswith("homeassistant/sensor/") for k in names))
check("...and no command entity (no select, number or switch for the car)",
not [k for k in pl if "car" in k and not k.startswith(
diff --git a/goodwe_controller/test_ev04.py b/goodwe_controller/test_ev04.py
index 1b28031..15490a0 100644
--- a/goodwe_controller/test_ev04.py
+++ b/goodwe_controller/test_ev04.py
@@ -248,7 +248,7 @@ async def part2():
w = World()
out = {}
out["manual"] = await w.act("car_mode", "manual")
- out["bad_mode"] = await w.act("car_mode", "solar") # not in this card
+ out["bad_mode"] = await w.act("car_mode", "bogus") # EV-05 accepts Solar
out["night"] = await w.act("car_mode", "night")
out["a12"] = await w.act("car_current", 12)
out["a5"] = await w.act("car_current", 5)
@@ -266,7 +266,7 @@ w2, o2 = run(part2())
check("Manual is chosen at once, no restart", o2["manual"] == {
"mode": "manual", "current": 6.0, "phases": 1} and w2.c.car_mode == "manual"
or w2.c.car_mode == "manual")
-check("Solar and Night are not accepted (EV-05, EV-02)",
+check("Night (EV-02) and an unknown mode are not accepted",
"error" in o2["bad_mode"] and "error" in o2["night"]
and w2.c.car_mode == "manual")
check("a current between 6 A and the clamp is accepted and stored",
@@ -307,7 +307,7 @@ check("ev_phases 1: 3 phases cannot be chosen, 1 can",
async def part2c():
out = {}
for start, stored in (("keep", "manual"), ("off", "manual"),
- ("keep", None), ("keep", "solar")):
+ ("keep", None), ("keep", "night")):
st = _Store()
if stored:
st.data["car_mode"] = stored
@@ -322,7 +322,7 @@ check("ev_mode_start keep: a restart keeps Manual",
check("ev_mode_start off: a restart starts in Off and the store says so",
o2c[("off", "manual")] == ("off", "off"))
check("no stored mode, or one this build does not know, is Off",
- o2c[("keep", None)][0] == "off" and o2c[("keep", "solar")][0] == "off")
+ o2c[("keep", None)][0] == "off" and o2c[("keep", "night")][0] == "off")
# =========================================================================== #
print("\n3. MANUAL WRITES THE CURRENT ONCE PER USER CHANGE")
@@ -1606,13 +1606,14 @@ pl = dict(mqtt.car_payloads((16, (1, 3))))
sel = pl["homeassistant/select/goodwe_ctl_car_mode/config"]
num = pl["homeassistant/number/goodwe_ctl_car_current/config"]
ph = pl["homeassistant/select/goodwe_ctl_car_phases/config"]
-check("three entities: select.goodwe_car_mode, number.goodwe_car_current, "
- "select.goodwe_car_phases", len(pl) == 3
+check("four entities: select.goodwe_car_mode, number.goodwe_car_current, "
+ "select.goodwe_car_phases and (EV-05) select.goodwe_car_sun_first",
+ len(pl) == 4
and sel["object_id"] == "goodwe_car_mode"
and num["object_id"] == "goodwe_car_current"
and ph["object_id"] == "goodwe_car_phases")
-check("the mode's labels are English and pinned: Off, Manual (Solar and Night "
- "are not offered)", sel["options"] == ["Off", "Manual"])
+check("the mode's labels are English and pinned: Off, Manual, Solar (EV-05; "
+ "Night is not offered)", sel["options"] == ["Off", "Manual", "Solar"])
check("the current is 6 A to the clamp, whole amps", num["min"] == 6
and num["max"] == 16 and num["step"] == 1
and num["unit_of_measurement"] == "A")
@@ -1629,7 +1630,7 @@ check("nothing is announced without a charger (and the default announcement "
"is as it was)", mqtt.car_payloads(None) == []
and mqtt.discovery_payloads() == mqtt.discovery_payloads(car=None))
check("the car entities come after every other row",
- [t for t, _ in mqtt.discovery_payloads(car=(16, (1, 3)))][-3:]
+ [t for t, _ in mqtt.discovery_payloads(car=(16, (1, 3)))][-4:]
== [t for t, _ in mqtt.car_payloads((16, (1, 3)))])
cmd = mqtt.parse_car_command
check("a command parses: mode, current, phases",
@@ -1641,8 +1642,8 @@ check("a command parses: mode, current, phases",
== ("car_phases", 3, None))
check("a retained command is dropped",
cmd("goodwe_ctl/car/mode/set", b"Manual", True)[2] == "retained")
-check("Solar, Night, junk and a long payload are refused",
- cmd("goodwe_ctl/car/mode/set", b"Solar", False)[1] is None
+check("Night, an unknown mode, junk and a long payload are refused",
+ cmd("goodwe_ctl/car/mode/set", b"Bogus", False)[1] is None
and cmd("goodwe_ctl/car/mode/set", b"Night", False)[1] is None
and cmd("goodwe_ctl/car/current/set", b"abc", False)[1] is None
and cmd("goodwe_ctl/car/phases/set", b"2", False)[1] is None
@@ -1660,7 +1661,7 @@ async def ha_story():
out = {"mode": w.c.car_mode, "a": w.c.car_a, "rb": w.sim.readback_a,
"pub": list(w.c.mqtt.values)[-1]}
await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Off", True) # retained
- await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Solar", False)
+ await w.c.mqtt_command("goodwe_ctl/car/mode/set", b"Night", False)
await w.c.mqtt_command("goodwe_ctl/car/current/set", b"99", False)
await w.c.mqtt_command("goodwe_ctl/car/phases/set", b"2", False)
await w.step(5)
@@ -1678,8 +1679,8 @@ check("HA commands go through handle_action(): Manual and 13 A are applied "
"and written, and the new state is published",
ha["mode"] == "manual" and ha["a"] == 13.0 and ha["rb"] == 13
and ha["pub"] == {"car_mode": "Manual", "car_current": 13,
- "car_phases": "1"})
-check("a retained command, Solar, 99 A and 2 phases change nothing",
+ "car_phases": "1", "car_sun_first": "Batteries"})
+check("a retained command, Night, 99 A and 2 phases change nothing",
ha["after"] == ("manual", 13.0, 1))
check("the three states are in the published values",
ha["state"].get("car_mode") == "Manual"
@@ -1700,11 +1701,11 @@ st_ = _S()
car_, retract_ = _main.car_announcement(CAR, st_)
check("with a charger the entities are announced and their topics kept",
car_ == (16.0, (1, 3)) and not retract_ and len(
- st_.data["mqtt_car_configs"]) == 3)
+ st_.data["mqtt_car_configs"]) == 4)
car2, retract2 = _main.car_announcement(BASE, st_)
check("turning the charger off removes exactly those entities",
car2 is None and sorted(retract2) == sorted(st_.data["mqtt_car_configs"])
- and len(retract2) == 3)
+ and len(retract2) == 4)
st2 = _S()
check("a site that never had a charger publishes nothing and its store is "
"not written",
@@ -1734,7 +1735,7 @@ async def web_story():
("manual", {"action": "car_mode", "value": "manual"}),
("a", {"action": "car_current", "value": 12}),
("n", {"action": "car_phases", "value": 3}),
- ("solar", {"action": "car_mode", "value": "solar"}),
+ ("solar", {"action": "car_mode", "value": "night"}),
("big", {"action": "car_current", "value": 40})):
async with s.post(root + "action", json=body) as r:
out[key] = (r.status, await r.json(content_type=None))
@@ -1753,21 +1754,22 @@ check("POST /action car_mode, car_current and car_phases store and answer",
web["manual"] == (200, {"ok": True, "result": {
"mode": "manual", "current": 6.0, "phases": 1}})
and web["a"][0] == 200 and web["n"][0] == 200)
-check("...Solar and 40 A (above the clamp) are a 400 with a plain reason",
+check("...Night and 40 A (above the clamp) are a 400 with a plain reason",
web["solar"][0] == 400 and web["solar"][1]["ok"] is False
and web["solar"][1]["error"] == messages.car_refused("value")
and web["big"][0] == 400)
car_s = web["status_en"]["car"]
-check("/status gives the page what it needs: the mode, the modes offered (Off "
- "and Manual only), the current's range, the phases",
- car_s["mode"] == "manual" and car_s["modes"] == ["off", "manual"]
+check("/status gives the page what it needs: the mode, the modes offered (Off, "
+ "Manual and, EV-05, Solar), the current's range, the phases",
+ car_s["mode"] == "manual"
+ and car_s["modes"] == ["off", "manual", "solar"]
and car_s["current"] == {"value": 12, "min": 6, "max": 16}
and car_s["phases"] == {"value": 3, "choices": [1, 3]})
check("/status in Dutch has the Dutch Why",
web["status_nl"]["car"]["why"].startswith("U stelde 12 A in"))
-check("the page has the controls and no Solar or Night button",
+check("the page has the controls and no Night button (EV-05 adds Solar)",
'id="car-manual"' in web["page"] and 'id="car-a"' in web["page"]
- and "mode_solar" not in web["page"] and "mode_night" not in web["page"])
+ and "mode_night" not in web["page"])
check("the page names the Manual strings in both languages",
"Handmatig" in web["page"] and "Manual" in web["page"])
diff --git a/goodwe_controller/test_ev05.py b/goodwe_controller/test_ev05.py
new file mode 100644
index 0000000..e18088c
--- /dev/null
+++ b/goodwe_controller/test_ev05.py
@@ -0,0 +1,1508 @@
+"""EV-05: the car's Solar mode. `python3 -B test_ev05.py`
+
+Spare sun to the car (signed, `car + battery charge - grid`), Batteries or Car
+first, whole amps rounded down, the 30 s and 1 A write rule, the start and pause
+dwells, auto phases through the safe sequence, the peak guard's excess taken
+off the car first, and every way out of Solar ending at 0 A, written once.
+The real Controller runs on `tools/ev05_sun.py` (N batteries, P1 meter, the
+charger model) at a 1 s cycle. Each test row of reports/EV-05-test-plan.md is
+named here by its id (T1 to T53, N1 to N12).
+Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
+"""
+
+import ast
+import asyncio
+import io
+import json
+import logging
+import math
+import os
+import random
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(HERE, "tools"))
+
+from app import carmode, chargers as CH, ctl_car, homeview, messages # noqa: E402
+from app import mqtt, validate # noqa: E402
+import ev05_sun as S # noqa: E402
+from chargersim import SimCharger # noqa: E402
+
+fails = []
+
+
+def check(name, cond):
+ print(f" {'ok ' if cond else 'FAIL'} {name}")
+ if not cond:
+ fails.append(name)
+
+
+class _Log(logging.Handler):
+ def __init__(self):
+ super().__init__(logging.DEBUG)
+ self.rec = []
+
+ def emit(self, r):
+ self.rec.append((r.levelname, r.getMessage()))
+
+ def count(self, level, part):
+ return sum(1 for lv, m in self.rec if lv == level and part in m)
+
+
+LOG = _Log()
+logging.getLogger("goodwe").addHandler(LOG)
+logging.getLogger("goodwe").setLevel(logging.DEBUG)
+for _h in list(logging.getLogger().handlers):
+ logging.getLogger().removeHandler(_h)
+
+
+def const(w):
+ return lambda t: float(w)
+
+
+def step(before, after, at):
+ return lambda t: float(before if t < at else after)
+
+
+def steps(*pairs):
+ """`steps((0, w0), (t1, w1), ...)`: the value of the last pair at or before t."""
+ def f(t):
+ v = pairs[0][1]
+ for at, w in pairs:
+ if t >= at:
+ v = w
+ return float(v)
+ return f
+
+
+def cur(r):
+ return S.writes(r, "current")
+
+
+def ph(r):
+ return S.writes(r, "phases")
+
+
+def nonzero(r):
+ return [(t, v) for t, v in cur(r) if v > 0]
+
+
+def act(what, value):
+ return lambda p, c: c.handle_action(what, value=value)
+
+
+def seq(*fns):
+ def f(p, c):
+ outs = [fn(p, c) for fn in fns]
+ co = [o for o in outs if asyncio.iscoroutine(o)]
+ if co:
+ async def all_():
+ for x in co:
+ await x
+ return all_()
+ return f
+
+
+CAR0 = {"ev_margin_w": 0} # Car first, margin 0: target = sun - house
+# Both batteries full: they take nothing, so the spare is exactly the sun and
+# the timing rows are not moved by a battery ramping (meter/battery skew).
+FULL = {"a": 100.0, "b": 100.0}
+
+
+def solar(sun, dur, **kw):
+ """Car first, margin 0, batteries full, house 0: the car target is `sun`."""
+ kw.setdefault("opts", CAR0)
+ return S.drive(house=const(0.0), sun=sun, first="car", socs=FULL,
+ dur=dur, **kw)
+
+
+def after_first_write(delay, holder, value):
+ """An on_cycle hook: `delay` s after the first current write, set
+ `holder["w"] = value` (a sun function reads it)."""
+ st = {}
+
+ def f(plant, c, t):
+ w = plant.ch.writes("current")
+ if w and "at" not in st:
+ st["at"] = w[0][0] + delay
+ if "at" in st and t + 1 >= st["at"] and not st.get("done"):
+ st["done"] = True
+ holder["w"] = value
+ return f
+SC2 = dict(house=const(900.0), sun=const(7900.0), socs={"a": 71.0, "b": 100.0})
+
+# =========================================================================== #
+print("T3. THE SPARE SUN IS SIGNED (N12)")
+# =========================================================================== #
+# The add-on's battery figure is discharge positive: a charge of 5000 W is -5000.
+T3 = {"a": (0.0, -5000.0, -2000.0, 7000.0),
+ "b": (0.0, -6000.0, 6900.0, -900.0),
+ "c": (1380.0, 9600.0, -5220.0, -3000.0),
+ "d": (1380.0, 9600.0, -7220.0, -1000.0),
+ "e": (0.0, 0.0, -3000.0, 3000.0)}
+got3 = {k: carmode.spare_w(c_, b_, g_) for k, (c_, b_, g_, _w) in T3.items()}
+check(f"T3 (a)-(e): 7000, -900, -3000, -1000, 3000 W within 1 W ({got3})",
+ all(abs(got3[k] - T3[k][3]) <= 1.0 for k in T3))
+check("T3/N12: a grid charge (b) and batteries giving more than the house (c) "
+ "are never sun", got3["b"] < 0 and got3["c"] < 0 and got3["d"] < 0)
+
+
+def _clipped(c_, b_, g_): # what a clipped formula would give
+ return c_ + max(-b_, 0.0) - max(g_, 0.0)
+
+
+check("T3: a clipped formula would fail (a) and (e): this table catches it",
+ abs(_clipped(*T3["a"][:3]) - 7000) > 1 and
+ abs(_clipped(*T3["e"][:3]) - 3000) > 1)
+check("T3/T4: a NaN, None or text figure gives no spare",
+ carmode.spare_w(0, float("nan"), 0) is None
+ and carmode.spare_w(0, None, 0) is None
+ and carmode.spare_w(0, 0, "unavailable") is None
+ and carmode.spare_w(None, 0, 0) is None)
+
+# =========================================================================== #
+print("\nT9, T10. THE MARGIN, AND WHOLE AMPS ROUNDED DOWN (N1)")
+# =========================================================================== #
+t9 = {m: carmode.car_target_w(2400.0, 5000.0, m, carmode.FIRST_CAR)
+ for m in (0, 100, 300, 1000)}
+a9 = {m: carmode.amps_for(t9[m], 1, 16) for m in t9}
+# The plan says "a hold" for margin 1000; 1400 W / 230 = 6.09, which is 6 A,
+# the minimum, so it charges at 6 A (dev report: plan arithmetic). 1379 W holds.
+check(f"T9: Car first, spare 2400 W, margin 0/100/300/1000: {t9} -> {a9} "
+ "(10, 10, 9 and 6 A; 1379 W would be under 6 A)",
+ t9 == {0: 2400.0, 100: 2300.0, 300: 2100.0, 1000: 1400.0}
+ and a9[0] == 10 and a9[100] == 10 and a9[300] == 9 and a9[1000] == 6
+ and carmode.amps_for(1379, 1) < 6)
+check("T9: Batteries first takes the room AND the margin, once",
+ carmode.car_target_w(7000.0, 5000.0, 100, carmode.FIRST_BATT) == 1900.0)
+t10 = (carmode.amps_for(1900, 1), carmode.amps_for(2299, 1),
+ carmode.amps_for(6900, 3), carmode.amps_for(6899, 3))
+check(f"T10: 1900 W/1 = 8, 2299 W/1 = 9 (not 10), 6900/3 = 10, 6899/3 = 9 "
+ f"({t10})", t10 == (8.0, 9.0, 10.0, 9.0))
+check("T10: ev_max_a 10 with 6.9 kW on 1 phase gives 10 A; a station limit of "
+ "13 A gives at most 13",
+ carmode.amps_for(6900, 1, carmode.clamp_for({"ev_max_a": 10}, None))
+ == 10.0 and carmode.amps_for(
+ 6900, 1, carmode.clamp_for({"ev_max_a": 16},
+ CH.ChargerReading(station_a=13.0))) == 13)
+_rnd = random.Random(10)
+_bad = []
+for _i in range(1000):
+ w = _rnd.choice([float("nan"), -500.0, 1e9, _rnd.uniform(-5000, 30000)])
+ n = _rnd.choice([1, 3])
+ cl = _rnd.choice([None, 6.0, 10.0, 13.0, 16.0, 32.0])
+ a = carmode.amps_for(w, n, cl)
+ if w != w:
+ if a is not None:
+ _bad.append((w, a))
+ continue
+ hi = 40.0 if cl is None else cl
+ want = max(0, min(math.floor(w / (230.0 * n) + 1e-9), math.floor(hi)))
+ if a != want or a > hi:
+ _bad.append((w, n, cl, a))
+check(f"T10 property: 1000 random spares (NaN, negative, 1e9): every answer is "
+ f"floor(W / (230 x n)) within [0, clamp], NaN gives none ({_bad[:3]})",
+ not _bad)
+
+# =========================================================================== #
+print("\nT6. SCENARIO 2, BATTERIES FIRST, CLEAR SKY (A1)")
+# =========================================================================== #
+r6 = S.drive(dur=600, first="batteries", on_cycle="rows", **SC2)
+c6 = r6["c"]
+w6 = cur(r6)
+tr6 = r6["trace"]
+check(f"T6: one write, 8 A on 1 phase, after the 120 s start dwell ({w6}, "
+ f"phases {ph(r6)})", len(w6) == 1 and w6[0][1] == 8.0
+ and 120 <= w6[0][0] <= 123 and ph(r6) == [] and r6["sim"].phases_allowed == 1)
+last = tr6[-1]
+check(f"T6: steady: A charges 5000 +-100 W ({r6['plant'].batt_of('a', 599):.0f})"
+ f", export about 160 W ({last['grid']:.0f}), B full takes nothing",
+ abs(r6["plant"].batt_of("a", 599) + 5000) <= 100
+ and -260 <= last["grid"] <= -60 and r6["plant"].batt_of("b", 599) == 0)
+_sp6 = tr6[-1]["spare"]
+check(f"T6: the spare stays 7000 W while the car charges, no drift ({_sp6})",
+ _sp6 is not None and abs(_sp6 - 7000) <= 60)
+check(f"T6: the room is A's rating only (5000 W): {c6.car_room_w()}",
+ c6.car_room_w() == 5000.0)
+why6 = homeview.car_block(c6, None)["why"]
+check(f"T6: Why = solar_batt: A at full power, B is full, 2.0 kW, 100 W "
+ f"({why6!r})", "inverter-a at full power" in why6
+ and "inverter-b is full" in why6 and "2.0 kW" in why6
+ and "100 W" in why6)
+check("T6: the v1 formula (room = rating - charge now) would give 16 A here",
+ carmode.amps_for(7000 - (5000 - 5000) - 100, 1, 16) == 16.0)
+check("T5 (i): the paused car counted as 0 W (car_w_trusted was None then) "
+ "and the start happened", w6 and w6[0][1] == 8.0)
+
+# =========================================================================== #
+print("\nT7. SCENARIO 2, CAR FIRST")
+# =========================================================================== #
+r7 = S.drive(dur=700, first="car", **SC2)
+w7, p7 = cur(r7), ph(r7)
+check(f"T7: the start goes on 1 phase at the clamp, 16 A ({w7[:1]})",
+ w7 and w7[0][1] == 16.0 and 120 <= w7[0][0] <= 123)
+check(f"T7: 180 s at >= 4.5 kW later the safe sequence moves it to 3 phases "
+ f"at 10 A ({w7}, {p7})", len(p7) == 1 and p7[0][1] == 3
+ and [v for _t, v in w7] == [16.0, 0.0, 10.0]
+ and 180 <= w7[1][0] - w7[0][0] <= 183)
+check(f"T7: the batteries then charge about 100 W "
+ f"({r7['plant'].batt(699):.0f} W)", -150 <= r7["plant"].batt(699) <= -50)
+check("T7: Why = solar_car", "Car first" in homeview.car_block(
+ r7["c"], None)["why"])
+
+# =========================================================================== #
+print("\nT8. BATTERIES FIRST: THE ROOM")
+# =========================================================================== #
+r8a = S.drive(house=const(900.0), sun=const(4900.0), socs={"a": 71.0, "b": 100.0},
+ dur=500)
+check(f"T8 (a): spare 4000, A may charge: 4000 - 5000 - 100 < 0, the car "
+ f"gets no sun ({cur(r8a)})", nonzero(r8a) == [])
+r8b = S.drive(house=const(900.0), sun=const(3900.0),
+ socs={"a": 100.0, "b": 100.0}, dur=300)
+check(f"T8 (b): both full, room 0: 2900 W gives 12 A ({cur(r8b)})",
+ [v for _t, v in cur(r8b)] == [12.0])
+r8c = S.drive(house=const(900.0), sun=const(7900.0),
+ socs={"a": 100.0, "b": 60.0}, dur=300)
+check(f"T8 (c): A at its ceiling, B may charge (4600): 2300 W gives 10 A "
+ f"({cur(r8c)})", [v for _t, v in cur(r8c)] == [10.0])
+_st8 = S.rig._Store()
+_st8.data["unit/inverter-a/pack_use"] = False
+
+
+def _a_off(p, c):
+ c.store.data["unit/inverter-a/pack_use"] = False
+
+
+r8o = S.drive(house=const(900.0), sun=const(7900.0), socs={"a": 60.0, "b": 60.0},
+ dur=300, events={0: _a_off})
+check(f"T8 (c): A switched Off, B may charge: room 4600, 10 A ({cur(r8o)})",
+ [v for _t, v in cur(r8o)] == [10.0])
+_inv = r8o["c"].inverters
+_inv[1].refused = -1
+check("T8 (c): a battery refusing a charge is not room either",
+ r8o["c"].car_room_w() == 0.0)
+_inv[1].refused = 0
+r8d = S.drive(house=const(900.0), sun=steps((0, 7900.0), (300, 1600.0)),
+ socs={"a": 71.0, "b": 100.0}, dur=700)
+w8d = cur(r8d)
+check(f"T8 (d): a cloud in scenario 2 (spare 700): 6 A held, then 0 A 300 s "
+ f"after it came ({w8d})", [v for _t, v in w8d] == [8.0, 6.0, 0.0]
+ and 300 <= w8d[2][0] - 300 <= 303)
+
+# =========================================================================== #
+print("\nT11. AT MOST ONE WRITE PER 30 s, ONLY ON A 1 A CHANGE (N5)")
+# =========================================================================== #
+# Car first, margin 0: 1840 W = 8 A, 2300 W = 10 A, 2047 W = 8.9 A
+for race in (False, True):
+ h11 = {"w": 1840.0}
+ r11 = solar(lambda t, h=h11: h["w"], 260, race=race,
+ on_cycle=after_first_write(5, h11, 2300.0))
+ w11 = cur(r11)
+ check(f"T11 (a) {'race' if race else 'step'}: 8 A at t, the spare moves to "
+ f"10 A worth 5 s later: 10 A comes 30 s after the first write "
+ f"({w11})", [v for _t, v in w11] == [8.0, 10.0]
+ and 30 <= w11[1][0] - w11[0][0] <= 31)
+r11b = solar(steps((0, 1840.0), (200, 2047.0)), 800)
+check(f"T11 (b): 8.9 A worth for 600 s writes nothing more ({cur(r11b)})",
+ [v for _t, v in cur(r11b)] == [8.0])
+
+# =========================================================================== #
+print("\nT13. THE START THRESHOLD (N5)")
+# =========================================================================== #
+r13a = solar(steps((0, 0.0), (30, 1609.0)), 930)
+check(f"T13 (a): 1609 W for 900 s: no write ({cur(r13a)})", cur(r13a) == [])
+for race in (False, True):
+ r13b = solar(steps((0, 0.0), (30, 1610.0)), 200, race=race)
+ w = cur(r13b)
+ check(f"T13 (b) {'race' if race else 'step'}: 1610 W (7 x 230) gives 7 A "
+ f"120 s after the sun is seen, not at 119 s ({w})",
+ [v for _t, v in w] == [7.0] and 150 <= w[0][0] <= 152)
+r13c = solar(steps((0, 0.0), (30, 1610.0), (91, 1500.0), (92, 1610.0)), 300)
+w = cur(r13c)
+check(f"T13 (c): a 1-cycle dip at 60 s starts the count again: written about "
+ f"181 s after the sun came ({w})", [v for _t, v in w] == [7.0]
+ and 211 <= w[0][0] <= 214)
+r13d = solar(steps((0, 0.0), (30, 6900.0)), 400, phases=1)
+w, p = cur(r13d), ph(r13d)
+check(f"T13 (d): auto phases, 6900 W: the start goes on 1 phase with no select "
+ f"before the first current write; the switch comes only by its dwell "
+ f"({w}, {p})", w and w[0][1] == 16.0 and (not p or p[0][0] > w[0][0])
+ and (not p or p[0][0] - w[0][0] >= 180))
+for sun_w, want in ((4829.0, []), (4830.0, [7.0])):
+ r13e = solar(steps((0, 0.0), (30, sun_w)), 500 if want else 930,
+ opts=dict(CAR0, ev_phases="3"), phases=3)
+ w = cur(r13e)
+ check(f"T13 (e): ev_phases 3, {sun_w:.0f} W: {want} at 120 s ({w})",
+ [v for _t, v in w] == want and (not w or 150 <= w[0][0] <= 152))
+
+# =========================================================================== #
+print("\nT14. UNDER 6 A: HOLD 6 A FOR 5 MINUTES, THEN 0 A (N3, N5)")
+# =========================================================================== #
+for race in (False, True):
+ h14 = {"w": 1840.0}
+ r14 = solar(lambda t, h=h14: h["w"], 600, race=race,
+ on_cycle=after_first_write(40, h14, 1200.0))
+ w14 = cur(r14)
+ t_drop = w14[0][0] + 40
+ check(f"T14 (a) {'race' if race else 'step'}: 8 A, the spare drops to "
+ f"5.2 A worth: 6 A is written, then 0 A once, 300 s after the drop "
+ f"is seen and not at 299 s ({w14}, drop at {t_drop:.0f})",
+ [v for _t, v in w14] == [8.0, 6.0, 0.0]
+ and 300 <= w14[2][0] - t_drop <= 302)
+b14 = homeview.car_block(r14["c"], None)
+check(f"T14: the card then says Waiting for sun and Why = solar_paused "
+ f"({b14['chip']!r}, {b14['why']!r})", b14["chip"] == "Waiting for sun"
+ and b14["why"].startswith("Too little spare sun for the car's minimum"))
+h14b = {"w": 1840.0}
+st14 = {}
+
+
+def _dip14(plant, c, t):
+ w = plant.ch.writes("current")
+ if w and "t0" not in st14:
+ st14["t0"] = w[0][0] + 40
+ if "t0" in st14:
+ dt = t + 1 - st14["t0"]
+ h14b["w"] = (1840.0 if dt < 0 else 1200.0 if dt < 299 else
+ 1840.0 if dt < 340 else 1200.0)
+
+
+r14b = solar(lambda t: h14b["w"], 1000, on_cycle=_dip14)
+w14b = cur(r14b)
+z14b = [t for t, v in w14b if v == 0.0]
+check(f"T14 (b): back to 6 A worth at 299 s, then down again: no 0 A until a "
+ f"fresh 300 s ({w14b}, second dip at {st14['t0'] + 340:.0f})",
+ z14b and z14b[0] - (st14["t0"] + 340) >= 299)
+
+# =========================================================================== #
+print("\nT15. THE HOLD WITH THE BATTERIES THAT CANNOT GIVE (N3)")
+# =========================================================================== #
+# "At the reserve" for the zero-grid loop is the batteries' own cut-out level
+# (10 %): the peak reserve binds the peak guard only (SAFETY-25), so a battery
+# at 20 % still covers a hold. Cut-out: the grid covers it for 300 s at most.
+for name, socs, gmax in (("(a) both at the cut-out", {"a": 10.0, "b": 10.0},
+ 116.0),
+ ("(b) A at the cut-out, B at 60 %",
+ {"a": 10.0, "b": 60.0}, 10.0)):
+ h15 = {"w": 1840.0}
+ r15 = S.drive(house=const(0.0), sun=lambda t, h=h15: h["w"], first="car",
+ opts=dict(CAR0, peak_cap_w=9000), socs=socs, dur=700,
+ on_cycle=after_first_write(40, h15, 1000.0))
+ w15 = cur(r15)
+ t0 = w15[0][0] + 40
+ wh = sum(max(0.0, x["grid"]) for x in r15["trace"]
+ if x["t"] >= t0) / 3600.0
+ check(f"T15 {name}: the hold lasts 300 s and the grid gives the car "
+ f"{wh:.0f} Wh (at most {gmax:.0f} Wh: 1380 W x 302 s) ({w15})",
+ [v for _t, v in w15][-1] == 0.0 and wh <= gmax
+ and 300 <= w15[-1][0] - t0 <= 302)
+
+# =========================================================================== #
+print("\nT16. THE WALL CLOCK JUMPS; THE DWELLS COUNT MONOTONIC SECONDS")
+# =========================================================================== #
+for jump in (3600.0, -3600.0):
+ def _j(p, c, j=jump):
+ p.utc_off = j
+ r16 = solar(steps((0, 0.0), (30, 1610.0)), 200, events={90: _j})
+ w16 = cur(r16)
+ h16 = {"w": 1840.0}
+ r16b = solar(lambda t, h=h16: h["w"], 600, events={200: _j},
+ on_cycle=after_first_write(40, h16, 1200.0))
+ w16b = cur(r16b)
+ check(f"T16 UTC {jump:+.0f} s: the start still comes 120 s after the sun "
+ f"({w16}) and the pause 300 s after the drop ({w16b})",
+ w16 and 150 <= w16[0][0] <= 152 and [v for _t, v in w16b]
+ == [8.0, 6.0, 0.0] and 300 <= w16b[2][0] - (w16b[0][0] + 40) <= 302)
+
+# =========================================================================== #
+print("\nT17, T18. AUTO PHASES: 4.5 kW FOR 3 MIN UP, UNDER 4.0 kW FOR 5 MIN "
+ "DOWN, ONE SWITCH PER 10 MIN (N2)")
+# =========================================================================== #
+
+
+def up_run(level, dur):
+ """1 phase at 3000 W, then `level` from 5 s after the first write."""
+ h = {"w": 3000.0}
+ r = solar(lambda t, h=h: h["w"], dur, on_cycle=after_first_write(5, h,
+ level))
+ return r, cur(r)[0][0] + 5
+
+
+r17, t17 = up_run(4500.0, 500)
+z17 = [t for t, v in cur(r17) if v == 0.0]
+check(f"T17: 4500 W for 180 s: the sequence starts (its 0 A) 180 s after, not "
+ f"179 s ({cur(r17)}, from {t17:.0f})", z17
+ and 180 <= z17[0] - t17 <= 182 and ph(r17) and ph(r17)[0][1] == 3)
+r17b, _t = up_run(4499.0, 3700)
+check(f"T17: 4499 W for 1 h never switches ({ph(r17b)})", ph(r17b) == [])
+# Down: from 3 phases (Car first 6900 W, then the level)
+
+
+def down_run(level, dur):
+ h = {"w": 6900.0}
+ st = {}
+
+ def f(plant, c, t):
+ p = plant.ch.writes("phases")
+ if p and "at" not in st:
+ st["at"] = p[0][0] + 60
+ if "at" in st and t + 1 >= st["at"]:
+ h["w"] = level
+ r = solar(lambda t: h["w"], dur, on_cycle=f)
+ return r, st.get("at")
+
+
+r17c, t17c = down_run(3999.0, 1200)
+p17c = ph(r17c)
+z17c = [t for t, v in cur(r17c) if v == 0.0 and t > t17c]
+check(f"T17: 3999 W on 3 phases switches to 1 phase 300 s later ({p17c}, "
+ f"0 A at {z17c[:1]}, from {t17c})", len(p17c) == 2 and p17c[1][1] == 1
+ and z17c and 300 <= z17c[0] - t17c <= 302)
+r17d, _t = down_run(4000.0, 3900)
+check(f"T17: 4000 W on 3 phases for 1 h never switches ({ph(r17d)})",
+ len(ph(r17d)) == 1)
+r17e, _t = down_run(4250.0, 3900)
+r17f, _t = up_run(4250.0, 3700)
+check(f"T17: the 4.0-4.5 kW band for 1 h never switches, from 3 or from 1 "
+ f"({ph(r17e)}, {ph(r17f)})", len(ph(r17e)) == 1 and ph(r17f) == [])
+h18 = {"w": 3000.0}
+st18 = {}
+
+
+def _f18(plant, c, t):
+ w = plant.ch.writes("current")
+ if w and "t0" not in st18:
+ st18["t0"] = w[0][0]
+ if "t0" in st18:
+ dt = t + 1 - st18["t0"]
+ h18["w"] = 5000.0 if dt < 200 else 3000.0 if dt < 1100 else 5000.0
+
+
+r18 = solar(lambda t: h18["w"], 2000, on_cycle=_f18)
+p18 = ph(r18)
+gaps18 = [b[0] - a[0] for a, b in zip(p18, p18[1:])]
+check(f"T18: over 4.5, under 4.0, over 4.5 kW: at most one select per 600 s, "
+ f"each later one waits for the 600 s ({p18}, gaps {gaps18})",
+ len(p18) >= 3 and all(g >= 600 for g in gaps18)
+ and [n for _t, n in p18][:3] == [3, 1, 3])
+
+# =========================================================================== #
+print("\nT19. EVERY SOLAR PHASE CHANGE IS THE SAFE SEQUENCE (N2)")
+# =========================================================================== #
+
+
+def seq_ok(r):
+ """Every select: a 0 A write before it, the car under 100 W or out of C or
+ 20 s after the 0 A, then 10 s or more to the next current, which is
+ floor(car_w / (230 x n)); no other write in between."""
+ log = r["sim"].log
+ state = {x["t"]: x["st"] for x in r["trace"]}
+ bad = []
+ for i, x in enumerate(log):
+ if x[1] != "phases":
+ continue
+ prev = log[i - 1] if i else None
+ nxt = log[i + 1] if i + 1 < len(log) else None
+ if prev is None or prev[1] != "current" or prev[2] != 0.0:
+ bad.append(("no 0 A before", x))
+ continue
+ quiet = (x[3] < 100.0 or state.get(x[0] - 1) != "C"
+ or x[0] - prev[0] >= 20.0)
+ if not quiet or x[4] != 0.0:
+ bad.append(("select under load", x))
+ if nxt is not None and (nxt[1] != "current" or nxt[0] - x[0] < 10.0):
+ bad.append(("current too soon or not next", x, nxt))
+ return bad
+
+
+r19 = solar(const(6900.0), 700, sim=SimCharger(setpoint_a=0))
+_s19 = SimCharger(setpoint_a=0)
+_s19.stop_delay_s = 15.0
+_s19.ramp_w_s = 200.0
+r19s = solar(const(6900.0), 700, sim=_s19)
+check(f"T19: 1 -> 3 with a normal and with a slow car (stop delay 15 s): 0 A, "
+ f"the select only with the car quiet (or 20 s), 10 s, then 10 A "
+ f"({seq_ok(r19)}, {seq_ok(r19s)}, {cur(r19s)})",
+ not seq_ok(r19) and not seq_ok(r19s) and ph(r19s)
+ and [v for _t, v in cur(r19s)][-2:] == [0.0, 10.0])
+r19a = solar(const(6900.0), 1900, opts=dict(CAR0, ev_phases="1"))
+check(f"T19: ev_phases 1 with 6.9 kW for 30 min: no select, 16 A "
+ f"({cur(r19a)}, {ph(r19a)})", ph(r19a) == []
+ and [v for _t, v in cur(r19a)] == [16.0])
+r19b = solar(steps((0, 6000.0), (300, 3000.0)), 800,
+ opts=dict(CAR0, ev_phases="3"), phases=3)
+check(f"T19: ev_phases 3 with 3 kW: no select, hold, then pause "
+ f"({cur(r19b)}, {ph(r19b)})", ph(r19b) == []
+ and [v for _t, v in cur(r19b)] == [8.0, 6.0, 0.0])
+
+# =========================================================================== #
+print("\nT20. A ONE-PHASE CAR ON A 3-PHASE ALLOWANCE")
+# =========================================================================== #
+st20 = {}
+
+
+def _f20(plant, c, t):
+ if c.car_solar.single and "marked" not in st20:
+ st20["marked"] = t
+ if t == 400:
+ plant.ch.unplug()
+ if t == 405:
+ st20["after_unplug"] = c.car_solar.single
+ plant.ch.plug_in(car_phases=3)
+
+
+r20 = S.drive(house=const(0.0), sun=steps((0, 6000.0), (250, 3000.0)),
+ first="car", socs=FULL, opts=dict(ev_phases="3"), phases=3,
+ car_phases=1, dur=800, on_cycle=_f20)
+w20 = cur(r20)
+draw20 = next((x["t"] for x in r20["trace"] if x["car"] > 500), None)
+check(f"T20: marked one-phase within 30 s of drawing (draws at {draw20}, "
+ f"marked at {st20.get('marked')})", st20.get("marked") is not None
+ and st20["marked"] - draw20 <= 30)
+check(f"T20: then 1-phase arithmetic: 16 A from 5.9 kW, and 12 A (2900 W / "
+ f"230) with spare 3000 W, no pause from the 4.2 A 3-phase figure "
+ f"({w20})", 16.0 in [v for _t, v in w20]
+ and [v for t, v in w20 if 250 < t < 400] == [12.0])
+check("T20: the mark clears on unplug, and a 3-phase car after it is never "
+ "marked", st20.get("after_unplug") is False and not r20["c"].car_solar.single)
+r20g = S.drive(house=const(0.0), sun=const(6000.0), first="car", socs=FULL,
+ opts=dict(ev_phases="3"), phases=3, car_phases=3, dur=400)
+check("T20 guard: a balanced 3-phase car is never marked",
+ not any(x["single"] for x in r20g["trace"]))
+
+# =========================================================================== #
+print("\nT21-T25. THE PEAK: THE CAR IS CUT FIRST (N4, N7)")
+# =========================================================================== #
+ABLE = {"a": 60.0, "b": 60.0}
+CUTOUT = {"a": 10.0, "b": 10.0} # the batteries' own cut-out: no giving
+
+
+def first_cut(r, after):
+ return next((x for x in r["trace"] if x["t"] >= after and x["cut"] > 0),
+ None)
+
+
+# Car first, house 500 W, sun 2900 W: 2300 W = 10 A on 1 phase.
+# The step: 500 -> 6000 W early in the period, about 800 W over the aim.
+r21 = S.drive(house=steps((0, 500.0), (200, 6000.0)), sun=const(2900.0),
+ first="car", socs=ABLE, dur=260)
+x21 = first_cut(r21, 200)
+w21 = [(t, v) for t, v in cur(r21) if t >= 200]
+lim21 = None if x21 is None else math.floor((2300.0 - x21["cut"]) / 230.0)
+check(f"T21: a house step takes the period over the aim with the batteries "
+ f"able: the car is cut within 1 cycle, to at most floor((2300 - cut) / "
+ f"230) A (cut {None if x21 is None else round(x21['cut'])} W at "
+ f"{None if x21 is None else x21['t']}, writes {w21})",
+ x21 is not None and x21["t"] <= 202 and w21
+ and w21[0][0] <= x21["t"] + 1 and w21[0][1] <= max(lim21, 0))
+_after = [x for x in r21["trace"] if x21 and x["t"] == x21["t"] + 5]
+check(f"T21: 5 s later, what must still come off the meter is at most the "
+ f"excess less the cut ({[round(x['excess'] or 0) for x in _after]})",
+ _after and (_after[0]["excess"] or 0.0) <= max(
+ 0.0, (x21["excess"] or 0.0) - x21["cut"]) + 60.0)
+r22 = S.drive(house=steps((0, 500.0), (200, 7500.0), (260, 500.0)),
+ sun=const(2900.0), first="car", socs=ABLE, dur=600)
+x22 = first_cut(r22, 200)
+w22 = [(t, v) for t, v in cur(r22) if t >= 200]
+last_cut22 = max((x["t"] for x in r22["trace"] if x["cut"] > 0), default=None)
+check(f"T22: an excess of 920 W or more: 0 A at once, no 5-min hold "
+ f"({w22}, cut {None if x22 is None else round(x22['cut'])})",
+ x22 is not None and w22 and w22[0] == (w22[0][0], 0.0)
+ and w22[0][0] <= x22["t"] + 1)
+check(f"T22: no restart before the period is under the aim (last cut "
+ f"{last_cut22}) and the 120 s start rule has run",
+ last_cut22 is not None and len(w22) >= 2
+ and w22[1][0] - last_cut22 >= 120)
+# T23: the house alone over the aim, the batteries at their cut-out, the car
+# at 6 A (started at 1700 W, then sun 2000, house 500, margin 100: 1400 W).
+SUN23 = steps((0, 2300.0), (180, 2000.0))
+r23 = S.drive(house=steps((0, 500.0), (300, 9000.0)), sun=SUN23,
+ first="car", socs=CUTOUT, dur=420)
+r23o = S.drive(house=steps((0, 500.0), (300, 9000.0)), sun=SUN23,
+ first="car", socs=CUTOUT, dur=420, mode="off")
+al23, al23o = S.ids(r23, *S.ALARMS), S.ids(r23o, *S.ALARMS)
+w23 = [(t, v) for t, v in cur(r23) if t >= 300]
+check(f"T23: the car at 6 A is cut to 0 A at once ({cur(r23)})",
+ [v for t_, v in cur(r23) if t_ < 300][-1:] == [6.0]
+ and w23 and w23[0][1] == 0.0
+ and w23[0][0] <= 302)
+check(f"T23/N7: the house's own alarm is not silenced: "
+ f"goodwe_peak_soc_floor at the same second as the twin with the car "
+ f"Off (+2 s) ({al23} vs {al23o})",
+ al23o and al23 and al23[0][1] == al23o[0][1]
+ and abs(al23[0][0] - al23o[0][0]) <= 2)
+# T24 (a): a cut late in the old period; the new one projects under. So late
+# only a large load moves a period's average (the meter reads up to 50 kW), so
+# the step is 45 kW for 15 s at :13:40.
+r24 = S.drive(house=steps((0, 500.0), (820, 45000.0), (835, 500.0)),
+ sun=const(2900.0), first="car", socs=CUTOUT, dur=1150)
+cuts24 = [x["t"] for x in r24["trace"] if x["cut"] > 0]
+w24 = [(t, v) for t, v in cur(r24) if t >= 820]
+check(f"T24 (a): cut at :13:4x ({cuts24[:3]}), no further cut from :15:00, "
+ f"and the restart only by the start rule ({w24})",
+ cuts24 and all(t < 900 for t in cuts24) and w24 and w24[0][1] == 0.0
+ and len(w24) >= 2 and w24[1][0] - max(cuts24) >= 120)
+r24b = S.drive(house=steps((0, 500.0), (900, 6500.0)), sun=const(2900.0),
+ first="car", socs=CUTOUT, dur=960)
+c24b = first_cut(r24b, 899)
+check(f"T24 (b): the new period heads over from its first second (N=2, "
+ f"next_quarter): the cut comes in its first cycles "
+ f"({None if c24b is None else c24b['t']}, {cur(r24b)[-1:]})",
+ c24b is not None and c24b["t"] <= 902 and cur(r24b)[-1][1] == 0.0)
+
+
+def quarters(r, aim):
+ """(start, import average, car average) of each whole quarter."""
+ out = []
+ tr = r["trace"]
+ for q0 in range(0, int(tr[-1]["t"]) + 1 - 900, 900):
+ xs = [x for x in tr if q0 <= x["t"] < q0 + 900]
+ if len(xs) < 890:
+ continue
+ g = sum(max(0.0, x["grid"]) for x in xs) / len(xs)
+ car = sum(x["car"] for x in xs) / len(xs)
+ out.append((q0, g, car))
+ return out
+
+
+def day25(t):
+ """Clouds and house steps, 2 hours."""
+ clouds = [(400, 520), (1500, 1530), (2600, 3100), (4000, 4060),
+ (5200, 5800)]
+ sun = 6500.0
+ for a, b in clouds:
+ if a <= t < b:
+ sun = 900.0
+ return sun
+
+
+def house25(t):
+ for a, b, w in ((1000, 1300, 3500.0), (3300, 3360, 4500.0),
+ (6000, 6600, 2500.0)):
+ if a <= t < b:
+ return w
+ return 600.0
+
+
+def _res25(p, c):
+ p.socs.update({"a": 10.0, "b": 10.0}) # the reserve, then a hold
+
+
+r25 = S.drive(house=house25, sun=lambda t: 1800.0 if 5900 <= t < 7000
+ else day25(t), first="car", socs=ABLE, dur=7200,
+ events={5800: _res25})
+q25 = quarters(r25, 3400.0)
+over25 = [(q, round(g), round(car)) for q, g, car in q25 if g > 3410.0
+ and g - car <= 3410.0]
+check(f"T25: a Solar day with clouds, house steps and a hold at the cut-out: "
+ f"no quarter over the aim that the car took there ({over25}; "
+ f"{len(q25)} quarters)", len(q25) >= 7 and not over25)
+check(f"T25/N4: no quarter is banked as the car's ({r25['c'].car_peak_q}), "
+ f"so the month peak is never 'set by the car'",
+ r25["c"].car_peak_q == {})
+hold25 = [x for x in r25["trace"] if 6000 <= x["t"] < 6600]
+check("T25: the hold at the reserve (house 2500 + car 6 A over the aim) is "
+ "ended by the cut at once: the car draws 0 W in that house step",
+ hold25 and max(x["car"] for x in hold25[5:]) == 0.0)
+
+# =========================================================================== #
+print("\nT49. EV-15'S SHAPES IN SOLAR: OUR OWN 0 A RAISES NO ALARM (N6, N7)")
+# =========================================================================== #
+for name, cap, house in (("EV-10 shape: house 3 kW, aim 6 kW", 6050.0, 3000.0),
+ ("EV-10b shape: a 9411 W limit", 9461.0, 2000.0)):
+ # 1 -> 3 at 180 s after the start, 3 -> 1 after the sun drops, at the
+ # reserve (19 %): the Solar sequence twice, and a hold then a pause.
+ sun49 = steps((0, house + 9000.0), (600, house + 2900.0),
+ (1300, house + 700.0))
+ r49 = S.drive(house=const(house), sun=sun49, first="car", cap=cap,
+ margin=50, socs={"a": 19.0, "b": 19.0}, dur=1700,
+ on_cycle="rows")
+ red49 = [x for x in r49["trace"] if x["red"]]
+ check(f"T49 {name}: the Solar sequences ({ph(r49)}) and the 0 A pause "
+ f"({[x for x in cur(r49) if x[1] == 0.0]}) raise no alarm, no "
+ f"goodwe_peak_soc_floor ({S.ids(r49, *S.ALARMS)}) and no red row "
+ f"({len(red49)} seconds)",
+ len(ph(r49)) >= 2 and any(v == 0.0 for _t, v in cur(r49))
+ and S.ids(r49, *S.ALARMS) == [] and not red49)
+st49 = {}
+
+
+def _ov49(plant, c, t):
+ if c.car_solar.seq is not None and "t" not in st49:
+ st49["t"] = t + 6
+
+
+def _ovh(t):
+ return 25000.0 if "t" in st49 and t >= st49["t"] else 3000.0
+
+
+r49o = S.drive(house=_ovh, sun=const(12000.0), first="car", cap=6050.0,
+ margin=50, socs={"a": 19.0, "b": 19.0}, dur=500, on_cycle=_ov49)
+t49 = st49.get("t", 10 ** 6)
+r49t = S.drive(house=lambda t: 25000.0 if t >= t49 else 3000.0,
+ sun=const(12000.0), first="car", cap=6050.0, margin=50,
+ socs={"a": 19.0, "b": 19.0}, dur=500, mode="off")
+a49, a49t = S.ids(r49o, *S.ALARMS), S.ids(r49t, *S.ALARMS)
+check(f"T49/N7: a 25 kW house overload 6 s into a Solar sequence (at {t49}) "
+ f"alarms at the same second as with the car Off ({a49} vs {a49t})",
+ a49 and a49t and abs(a49[0][0] - a49t[0][0]) <= 2)
+
+# =========================================================================== #
+print("\nT26-T37, T53. EVERY WAY OUT OF SOLAR ENDS AT 0 A, WRITTEN ONCE (N9, N10)")
+# =========================================================================== #
+RUN10 = dict(house=const(500.0), sun=const(2900.0), first="car", socs=FULL)
+
+
+def after(r, t0, t1=1e9):
+ return [(t, v) for t, v in cur(r) if t0 <= t < t1]
+
+
+def shutdown_at(rec):
+ async def f(p, c):
+ rec["n0"] = len(p.sets)
+ rec["mono0"] = c.car_now()
+ await c.shutdown()
+ rec["mono1"] = c.car_now()
+ rec["sets"] = p.sets[rec["n0"]:]
+ return f
+
+
+rec26 = {}
+r26 = S.drive(dur=301, events={300: shutdown_at(rec26)}, **RUN10)
+s26 = rec26["sets"]
+ch26 = [i for i, x in enumerate(s26) if x[1] == S.SET]
+inv26 = [i for i, x in enumerate(s26) if x[1].startswith("number.sp_")]
+check(f"T26: shutdown in Solar at 10 A: exactly one 0 A, before the first "
+ f"inverter 0 W ({s26})", [s26[i][2] for i in ch26] == [0.0]
+ and inv26 and ch26[0] < inv26[0]
+ and all(s26[i][2] == 0.0 for i in inv26))
+rec26m = {}
+r26m = S.drive(dur=301, mode="manual", setpoint=10,
+ events={300: shutdown_at(rec26m)}, **{k: v for k, v in
+ RUN10.items()})
+s26m = rec26m["sets"]
+check(f"T26 guard: in Manual the order is as before (inverters first, the "
+ f"current stands) ({s26m})", s26m and all(
+ x[1].startswith("number.sp_") for x in s26m))
+_sim26 = r26["sim"]
+_t26 = _sim26.t
+r26k = S.drive(dur=200, plug=False, sim=_sim26, store=r26["store"], **RUN10)
+nz26 = [(t, v) for t, v in cur(r26k) if t > _t26 and v > 0]
+check(f"T26: restart with ev_mode_start keep: Solar, and no non-zero write for "
+ f"120 s ({r26k['c'].car_mode}, {nz26})",
+ r26k["c"].car_mode == "solar" and nz26 and nz26[0][0] - _t26 >= 120)
+_t26b = _sim26.t
+r26o = S.drive(dur=200, plug=False, sim=_sim26, store=r26["store"],
+ opts={"ev_mode_start": "off"}, **RUN10)
+check(f"T26: restart with ev_mode_start off: Off, nothing written "
+ f"({r26o['c'].car_mode}, {after(r26o, _t26b + 0.5)})",
+ r26o["c"].car_mode == "off" and after(r26o, _t26b + 0.5) == [])
+rec26u = {}
+r26u = S.drive(dur=301, events={299: lambda p, c: p.ch.go_unavailable(),
+ 300: shutdown_at(rec26u)}, **RUN10)
+check(f"T26: the charger unreachable at shutdown: the inverters are released "
+ f"after at most 15 s ({rec26u['mono1'] - rec26u['mono0']:.0f} s)",
+ rec26u["mono1"] - rec26u["mono0"] <= 15.0 and any(
+ x[1].startswith("number.sp_") for x in rec26u["sets"]))
+rec26h = {}
+
+
+async def _hang(a):
+ await asyncio.Event().wait()
+
+
+def _hang_shut(p, c):
+ c.charger.write_current = _hang
+ ctl_car.RELEASE_WAIT_S = 0.2
+ return shutdown_at(rec26h)(p, c)
+
+
+_wait = ctl_car.RELEASE_WAIT_S
+r26h = S.drive(dur=301, events={300: _hang_shut}, **RUN10)
+ctl_car.RELEASE_WAIT_S = _wait
+check("T26: a charger write that never returns does not hold up the inverters' "
+ "release (bounded wait)", any(x[1].startswith("number.sp_")
+ for x in rec26h["sets"]))
+rec27 = {}
+
+
+async def _die(p, c):
+ from app import main as M
+
+ async def boom():
+ raise RuntimeError("control task died")
+ t = asyncio.ensure_future(boom())
+ await asyncio.gather(t, return_exceptions=True)
+ stop = asyncio.Event()
+ M.control_task_done(t, controller=c, stop=stop, died=[])
+ rec27["stop"] = stop.is_set()
+ await shutdown_at(rec27)(p, c)
+
+
+r27 = S.drive(dur=301, events={300: _die}, **RUN10)
+s27 = rec27["sets"]
+check(f"T27: the control task dies, then the wind-down: 0 A once, before the "
+ f"inverters' 0 W ({s27})", rec27["stop"]
+ and [x[2] for x in s27 if x[1] == S.SET] == [0.0]
+ and s27[0][1] == S.SET)
+
+
+def solar_exit(trigger, at=300, dur=700, **kw):
+ ev = {at: trigger}
+ ev.update(kw.pop("events", {}))
+ args = dict(RUN10)
+ args.update(kw)
+ return S.drive(dur=dur, events=ev, **args)
+
+
+r28 = solar_exit(act("auto_toggle", None), opts={"shadow_mode": "off"},
+ events={600: act("auto_toggle", None)}, dur=800)
+check(f"T28: Stop (shadow_mode off): 0 A once within 1 cycle, nothing else "
+ f"while stopped; after Start only the start rule ({after(r28, 300)})",
+ after(r28, 300, 600) == [(after(r28, 300)[0][0], 0.0)]
+ and after(r28, 300)[0][0] <= 302
+ and after(r28, 600) and after(r28, 600)[0][0] >= 720)
+r28a = solar_exit(act("auto_toggle", None), opts={"shadow_mode": "auto"})
+check(f"T28: Stop with the shipped shadow_mode auto: the same ({after(r28a, 300)})",
+ [v for _t, v in after(r28a, 300)] == [0.0]
+ and after(r28a, 300)[0][0] <= 302)
+for name, fn in (("sign_wd", lambda p, c: setattr(c.inverters[0].sign_wd,
+ "tripped", True)),
+ ("site_sign_wd", lambda p, c: setattr(c.site_sign_wd,
+ "tripped", True)),
+ ("circ_wd", lambda p, c: setattr(c.circ_wd, "tripped",
+ True))):
+ r29 = solar_exit(fn)
+ check(f"T29: safety stop {name}: 0 A once, nothing else while it stands "
+ f"({after(r29, 300)})", [v for _t, v in after(r29, 300)] == [0.0]
+ and after(r29, 300)[0][0] <= 302)
+n_err = LOG.count("WARNING", "CHARGER_ERROR")
+whys30 = {}
+
+
+def _why30(p, c, t):
+ if t == 450:
+ whys30["why"] = homeview.car_block(c, None)["why"]
+ whys30["rows"] = [x["id"] for x in c.checks()]
+
+
+def _err_on(p, c):
+ p.ch.error = "12: Socket fault"
+
+
+def _err_off(p, c):
+ p.ch.error = "0: No Error"
+
+
+r30 = solar_exit(_err_on, events={600: _err_off}, dur=800, on_cycle=_why30)
+check(f"T30: charger error: 0 A once, no write during the error, the start "
+ f"rule after it clears ({after(r30, 300)})",
+ [v for _t, v in after(r30, 300, 600)] == [0.0]
+ and after(r30, 300)[0][0] <= 302 and after(r30, 600)
+ and after(r30, 600)[0][0] >= 720)
+check(f"T30: one warning, in the log and as a notification, taken down when it "
+ f"clears; the card says it ({whys30.get('why')!r})",
+ LOG.count("WARNING", "CHARGER_ERROR") - n_err == 1
+ and [n for _t, n in r30["raised"]].count("goodwe_charger_error") == 1
+ and any(n == "goodwe_charger_error" for _t, n in r30["plant"].dismissed)
+ and "error" in whys30.get("why", "")
+ and "charger_error" in whys30.get("rows", []))
+
+
+def _fault_e(p, c):
+ p.ch.fault("E")
+
+
+def _fault_off(p, c):
+ p.ch.state = "B"
+
+
+r30e = solar_exit(_fault_e, events={600: _fault_off}, dur=800)
+check(f"T30: mode3 E: the same ({after(r30e, 300)})",
+ [v for _t, v in after(r30e, 300, 600)] == [0.0]
+ and after(r30e, 600) and after(r30e, 600)[0][0] >= 720)
+st31 = {}
+
+
+def _freeze31(p, c, t):
+ ok = c.car_solar.plan.ok_since
+ if ok is not None and t == ok + 118 and "fz" not in st31:
+ st31["fz"] = t
+ p.ch.freeze() # every reading sticks now
+ if "fz" in st31 and t == st31["fz"] + 400:
+ p.ch.freeze(False)
+ if "fz" in st31 and t == st31["fz"] + 200:
+ st31["rows"] = [x["id"] for x in c.checks()]
+
+
+r31 = S.drive(dur=900, on_cycle=_freeze31, **RUN10)
+w31 = cur(r31)
+fz = st31.get("fz", 0)
+check(f"T31: a stuck reading after a write that moved the setpoint: 0 A once "
+ f"about 60 s after that write (+10 s read-back), the amber row, no "
+ f"write until a reading moves, then the start rule ({w31}, frozen at "
+ f"{fz})", [v for t, v in w31 if t < fz + 400].count(0.0) == 1
+ and any(v == 0.0 and 60 <= t - w31[0][0] <= 75 for t, v in w31)
+ and "charger_stuck" in st31.get("rows", [])
+ and all(t >= fz + 400 + 120 for t, v in w31 if v > 0 and t > fz + 100))
+r32 = solar_exit(lambda p, c: p.ch.go_unavailable(),
+ events={420: lambda p, c: p.ch.go_unavailable(False)})
+check(f"T32: unavailable 120 s at 10 A: nothing tried while down, then 0 A "
+ f"within 1 cycle of its return, then the start rule ({after(r32, 300)})",
+ after(r32, 300, 420) == [] and after(r32, 420)
+ and after(r32, 420)[0] == (after(r32, 420)[0][0], 0.0)
+ and after(r32, 420)[0][0] <= 422
+ and all(t >= after(r32, 420)[0][0] + 120 for t, v in after(r32, 420)
+ if v > 0))
+
+
+def _ha(on):
+ def f(p, c):
+ p.ha_down = not on
+ if not on:
+ return c.mqtt_command("goodwe_ctl/car/current/set", b"12", False)
+ return f
+
+
+r33 = solar_exit(_ha(False), events={420: _ha(True)})
+check(f"T33: Home Assistant not answering for 120 s: nothing written (a lost "
+ f"command changes no current); back: 0 A first, then the rules "
+ f"({after(r33, 300)})", after(r33, 300, 420) == [] and after(r33, 420)
+ and after(r33, 420)[0][1] == 0.0
+ and all(t >= after(r33, 420)[0][0] + 120 for t, v in after(r33, 420)
+ if v > 0))
+
+
+def _meter(on):
+ def f(p, c):
+ p.meter_on = on
+ return f
+
+
+r34 = solar_exit(_meter(False), dur=800)
+w34 = after(r34, 300)
+check(f"T34 (a): the meter stops at 10 A for 400 s: no write until 15 + 300 s, "
+ f"then 0 A once (+2 s) ({w34})", [v for _t, v in w34] == [0.0]
+ and 315 <= w34[0][0] - 300 <= 318)
+r34b = solar_exit(_meter(False), events={500: _meter(True)})
+check(f"T34 (b): back at 200 s: no 0 A ({after(r34b, 300)})",
+ 0.0 not in [v for _t, v in after(r34b, 300)])
+
+
+def _late(fn):
+ def f(p, c):
+ c._readings_late = lambda standing, p=p: fn(p.t)
+ return f
+
+
+r35 = solar_exit(_late(lambda t: 10.0 if t < 330 else None))
+check(f"T35 (a): readings late 10 s, then on time: the current is held and "
+ f"nothing is written ({after(r35, 300)})", after(r35, 300) == [])
+r35b = solar_exit(_late(lambda t: t - 300.0 if t < 700 else None), dur=720)
+w35 = after(r35b, 300)
+check(f"T35 (b): late past stale_input_s: the hold ends at 15 s and the stale "
+ f"rule runs: 0 A once by 15 + 300 + 2 s ({w35})",
+ [v for _t, v in w35] == [0.0] and 300 + 315 <= w35[0][0] <= 300 + 317)
+
+
+def seq_stop(trigger, stage):
+ """1 -> 3 with a slow car; `trigger` when the sequence is in `stage`."""
+ st = {}
+ sim = SimCharger(setpoint_a=0)
+ sim.stop_delay_s, sim.ramp_w_s = 15.0, 200.0
+
+ def f(plant, c, t):
+ q = c.car_solar.seq
+ if q is not None and "t0" not in st and q["stage"] == stage:
+ st["t0"] = t
+ st["n0"] = len(plant.ch.log)
+ st["zeros"] = [x for x in plant.ch.log if x[1] == "current"
+ and x[2] == 0.0]
+ out = trigger(plant, c)
+ if asyncio.iscoroutine(out):
+ st["co"] = out
+ ev = {}
+
+ def kick(p, c):
+ co = st.pop("co", None)
+ return co
+ r = solar(const(6900.0), 520, sim=sim, on_cycle=f,
+ events={t: kick for t in range(300, 520)})
+ log = r["sim"].log[st.get("n0", 0):] if "t0" in st else None
+ return r, st, log
+
+
+TRIG36 = (("Off", lambda p, c: c.handle_action("car_mode", value="off")),
+ ("shadow", lambda p, c: c.o.__setitem__("shadow_mode", "on")),
+ ("Stop", lambda p, c: c.handle_action("auto_toggle")),
+ ("safety stop", lambda p, c: setattr(c.circ_wd, "tripped", True)),
+ ("shutdown", lambda p, c: c.shutdown()),
+ ("unplug", lambda p, c: p.ch.unplug()))
+for stage in ("zero", "settle"):
+ for name, trig in TRIG36:
+ r36, st36, log36 = seq_stop(trig, stage)
+ zeros = [x for x in r36["sim"].log if x[1] == "current"
+ and x[2] == 0.0]
+ check(f"T36 {name} at stage {stage}: no select after it, no restore, "
+ f"the charger ends at 0 A and one 0 A in all "
+ f"({log36})", log36 is not None
+ and not [x for x in log36 if x[1] == "phases"]
+ and not [x for x in log36 if x[1] == "current" and x[2] > 0]
+ and r36["sim"].setpoint_a == 0.0 and len(zeros) == 1)
+r37 = solar_exit(lambda p, c: p.ch.unplug(), events={
+ 3920: lambda p, c: p.ch.plug_in()}, dur=4200)
+w37 = after(r37, 300)
+check(f"T37: unplug at 10 A: one 0 A within 1 cycle, nothing for 3600 s; "
+ f"replug: nothing before the start rule ({w37})",
+ w37 and w37[0][1] == 0.0 and w37[0][0] <= 302
+ and after(r37, 303, 3920) == []
+ and all(t >= 3920 + 120 for t, v in after(r37, 3920)))
+r37m = S.drive(dur=600, mode="manual", setpoint=10,
+ events={300: lambda p, c: p.ch.unplug()}, **RUN10)
+check(f"T37 guard: an unplug in Manual writes nothing ({after(r37m, 300)})",
+ after(r37m, 300) == [])
+# T12: each 0 A comes within 1 cycle, also 2 s after a normal write
+st12 = {}
+
+
+def t12(trigger):
+ st = {}
+ h = {"w": 2900.0}
+
+ def f(plant, c, t):
+ w = plant.ch.writes("current")
+ if w and "first" not in st:
+ st["first"] = w[0][0]
+ if "first" in st and t == st["first"] + 40:
+ h["w"] = 3600.0 # a normal write 30 s+ later
+ nz = [x for x in w if x[2] > 0]
+ if len(nz) >= 2 and "t2" not in st:
+ st["t2"] = nz[1][0] + 2
+ if "t2" in st and t + 1 == st["t2"]:
+ st["co"] = trigger(plant, c)
+
+ def kick(p, c):
+ return st.pop("co", None)
+ hs = {"w": 500.0}
+ r = S.drive(house=lambda t: hs["w"] if trigger is not None else 500.0,
+ sun=lambda t: h["w"], first="car", socs=FULL, dur=400,
+ on_cycle=f, events={t: kick for t in range(100, 400)})
+ return r, st
+
+
+for name, trig in (("Off", lambda p, c: c.handle_action("car_mode",
+ value="off")),
+ ("Stop", lambda p, c: c.handle_action("auto_toggle")),
+ ("unplug", lambda p, c: p.ch.unplug()),
+ ("charger error", lambda p, c: setattr(p.ch, "error",
+ "5: fault"))):
+ r12, s12 = t12(trig)
+ z12 = [t for t, v in cur(r12) if v == 0.0]
+ check(f"T12 {name} 2 s after a normal write: the 0 A goes out within 1 "
+ f"cycle, the 30 s rule does not delay it ({cur(r12)})",
+ "t2" in s12 and z12 and s12["t2"] <= z12[0] <= s12["t2"] + 1)
+r12c = S.drive(house=steps((0, 500.0), (154, 7500.0)), sun=steps(
+ (0, 2900.0), (150, 3600.0)), first="car", socs=ABLE, dur=260)
+_nz12 = [t for t, v in cur(r12c) if v > 0]
+_z12 = [t for t, v in cur(r12c) if v == 0.0]
+check(f"T12 the peak cut 2 s after a normal write: 0 A within 1 cycle "
+ f"({cur(r12c)})", len(_nz12) >= 2 and _z12
+ and _z12[0] - _nz12[1] <= 4)
+for name, trig, zero_after in (
+ ("(a) Solar to Off, then a current and phases set while Off",
+ seq(act("car_mode", "off")), True),
+ ("(b) shadow on by the option",
+ lambda p, c: c.o.__setitem__("shadow_mode", "on"), True),
+ ("(b) shadow on by shadow_mode auto and Stop",
+ act("auto_toggle", None), True)):
+ r53 = solar_exit(trig, dur=900, events={
+ 310: seq(act("car_current", 14), act("car_phases", 3))})
+ w53 = after(r53, 300)
+ check(f"T53 {name}: exactly one 0 A within 1 cycle, then nothing for "
+ f"600 s ({w53})", [v for _t, v in w53] == [0.0]
+ and w53[0][0] <= 302)
+st53 = {}
+
+
+def _would53(p, c, t):
+ if t == 500:
+ st53["why"] = homeview.car_block(c, None)["why"]
+
+
+solar_exit(lambda p, c: c.o.__setitem__("shadow_mode", "on"),
+ on_cycle=_would53)
+check(f"T53 (b): in shadow mode the card says what it would set "
+ f"({st53.get('why')!r})", "would set 10 A" in st53.get("why", ""))
+for name, trig in (("Off", act("car_mode", "off")),
+ ("shadow", lambda p, c: c.o.__setitem__("shadow_mode",
+ "on"))):
+ r53c = S.drive(house=const(500.0), sun=steps((0, 2900.0), (100, 0.0)),
+ first="car", socs=FULL, dur=900, events={700: trig})
+ check(f"T53 (c) Solar paused at 0 A, then {name}: no write "
+ f"({after(r53c, 700)})", after(r53c, 700) == [])
+for name, trig in (("(d) Manual to Off", act("car_mode", "off")),
+ ("(e) shadow on in Manual",
+ lambda p, c: c.o.__setitem__("shadow_mode", "on"))):
+ r53d = S.drive(dur=600, mode="manual", setpoint=10, events={300: trig},
+ **RUN10)
+ check(f"T53 {name}: no write, as in EV-04 ({after(r53d, 300)})",
+ after(r53d, 300) == [])
+r53f = solar_exit(act("car_mode", "manual"), dur=600)
+check(f"T53 (f) Solar to Manual: no Solar 0 A; Manual writes its own current "
+ f"once ({after(r53f, 300)})", [v for _t, v in after(r53f, 300)]
+ == [float(r53f["c"].car_a)] and 0.0 not in
+ [v for _t, v in after(r53f, 300)])
+
+# =========================================================================== #
+print("\nT1, T2. THE MODE AND WHERE SPARE SUN GOES FIRST: RUNTIME STATE")
+# =========================================================================== #
+st1 = {}
+
+
+async def _t1(p, c):
+ st1["page"] = await c.handle_action("car_mode", value="solar")
+ st1["stored"] = c.store.data.get("car_mode")
+ await c.handle_action("car_mode", value="off")
+ await c.mqtt_command("goodwe_ctl/car/mode/set", b"Solar", False)
+ st1["mqtt"] = c.car_mode
+ st1["night"] = await c.handle_action("car_mode", value="night")
+ st1["bogus"] = await c.handle_action("car_mode", value="Bogus")
+ await c.mqtt_command("goodwe_ctl/car/mode/set", b"Night", False)
+ st1["after"] = c.car_mode
+
+
+r1 = S.drive(mode="off", dur=200, events={5: _t1}, **SC2)
+check(f"T1: Solar from the page's action and from MQTT; stored, run by the next "
+ f"step with no restart ({st1.get('page')}, {cur(r1)})",
+ st1.get("stored") == "solar" and st1.get("mqtt") == "solar"
+ and r1["c"].car_solar.engaged and [v for _t, v in cur(r1)] == [8.0])
+check("T1: Night and Bogus are refused and change nothing",
+ "error" in st1["night"] and "error" in st1["bogus"]
+ and st1["after"] == "solar")
+_pl = dict(mqtt.car_payloads((16, (1, 3))))
+check("T1: select.goodwe_car_mode offers exactly Off, Manual, Solar",
+ _pl["homeassistant/select/goodwe_ctl_car_mode/config"]["options"]
+ == ["Off", "Manual", "Solar"] and "car_sun_first" in __import__(
+ "app.web", fromlist=["CAR_ACTIONS"]).CAR_ACTIONS)
+st2 = {}
+
+
+async def _t2(p, c):
+ st2["t"] = p.t
+ st2["r"] = await c.handle_action("car_sun_first", value="car")
+ await c.mqtt_command("goodwe_ctl/car/sun_first/set", b"Batteries", True)
+ st2["retained"] = c.car_first
+ st2["unknown"] = await c.handle_action("car_sun_first", value="Both")
+ st2["mqtt_bad"] = mqtt.parse_car_command(
+ "goodwe_ctl/car/sun_first/set", b"Both", False)[1]
+
+
+r2 = S.drive(dur=300, events={150: _t2}, **SC2)
+w2 = cur(r2)
+check(f"T2: Batteries -> Car: the next write follows the new arithmetic (16 A) "
+ f"and still the 30 s rule ({w2})", [v for _t, v in w2][:2] == [8.0, 16.0]
+ and w2[1][0] - w2[0][0] >= 30)
+check("T2: a retained command is dropped, an unknown label refused",
+ st2["retained"] == "car" and "error" in st2["unknown"]
+ and st2["mqtt_bad"] is None)
+check("T2: the choice is in the store and survives a rebuild (below)",
+ r2["store"].data.get("car_sun_first") == "car")
+_s2 = S.rig._Store()
+_s2.data["car_sun_first"] = "car"
+from app.main import Controller as _C # noqa: E402
+check("T2: a Controller built on that store starts with Car first",
+ _C(S.rig._options(1, {"ev_charger": "alfen_ha",
+ "ev_current_entity": S.SET}), S.SunPlant(
+ const(0), const(0), {"a": 5000.0}, {"a": 50.0}, SimCharger()),
+ _s2, S.rig._Pub(), stop=asyncio.Event()).car_first == "car")
+check("T2: the HA labels mirror carmode's", mqtt.CAR_FIRST_LABELS
+ == carmode.FIRST_LABELS and mqtt.CAR_MODE_LABELS == carmode.MODE_LABELS)
+
+# =========================================================================== #
+print("\nT4, T5. NO SPARE FROM A BAD FIGURE (N8)")
+# =========================================================================== #
+for name, bad in (("None", None), ("NaN", "nan")):
+ def _nan(on, bad=bad):
+ def f(p, c):
+ if on:
+ p.batt_nan.add("a")
+ else:
+ p.batt_nan.discard("a")
+ return f
+ r4 = solar_exit(_nan(True), at=200, dur=650,
+ events={201: _nan(False), 300: _nan(True)})
+ w4 = after(r4, 200)
+ check(f"T4 battery figure {name}: one cycle writes nothing; 350 s: the "
+ f"current is held, then 0 A once at 300 s (+2) ({w4})",
+ [v for _t, v in w4] == [0.0] and 300 <= w4[0][0] - 300 <= 302)
+st5 = {}
+
+
+def _stop5(p, c):
+ p.ch.stop_delay_s = 1e9 # mode3 stays C: the car really
+ p.ch.car_full() # stops, the power sticks
+ p.ch.freeze_power()
+
+
+r5 = solar_exit(_stop5, dur=800)
+w5 = after(r5, 300)
+# In its first minute the frozen figure is still believed (EV-04's
+# corroboration window), so a write may follow it then; after that, no
+# non-zero write, and the 0 A by 110 + 300 + 2 s.
+z5 = [t for t, v in w5 if v == 0.0]
+check(f"T5 (iii): a frozen figure after the car really stopped: once "
+ f"corroboration fails (<= 110 s) it no longer counts: hold, then 0 A by "
+ f"110 + 300 + 2 s ({w5})", z5 and 300 + 300 <= z5[0] <= 300 + 412
+ and not [t for t, v in w5 if v > 0 and t > 300 + 110])
+r5b = solar_exit(lambda p, c: p.ch.go_unavailable(), dur=800)
+check(f"T5 (iv): a charger reading older than 15 s: no spare is computed "
+ f"(an unreachable charger is also not written to; 0 A on its return, "
+ f"T32) ({after(r5b, 300)})", after(r5b, 300) == [])
+
+# =========================================================================== #
+print("\nT38. A FULL CAR")
+# =========================================================================== #
+
+
+class LowCar(SimCharger):
+ low = False
+
+ def target_w(self):
+ t = super().target_w()
+ return min(t, 150.0) if self.low and t > 0 else t
+
+
+st38 = {}
+
+
+def _st38(p, c, t):
+ st38[t] = c.car.status(c.car_now(), True)
+
+
+r38 = solar_exit(lambda p, c: p.ch.car_full(), dur=700, on_cycle=_st38)
+check(f"T38 (a): mode3 B with 6 A or more allowed for 60 s: Car is full, "
+ f"nothing written ({after(r38, 300)}, {st38.get(362)})",
+ after(r38, 300) == [] and st38.get(362) == "full"
+ and homeview.car_block(r38["c"], None)["chip"] == "Car is full")
+st38b = {}
+_low = LowCar(setpoint_a=0)
+
+
+def _low_on(p, c):
+ p.ch.low = True
+
+
+def _low_off(p, c):
+ p.ch.low = False
+
+
+def _st38b(p, c, t):
+ st38b[t] = (c.car.status(c.car_now(), True), c.car_solar.plan.why)
+
+
+r38b = solar_exit(_low_on, dur=1100, sim=_low, on_cycle=_st38b,
+ events={1000: _low_off})
+full_at = min((t for t, v in st38b.items() if v[0] == "full"), default=None)
+check(f"T38 (b): C under 200 W at 6 A or more for 600 s: full at 600 s, not "
+ f"599 ({full_at})", full_at is not None and 599 <= full_at - 301 <= 602)
+check(f"T38 (b): when it draws again Solar recomputes ({st38b.get(1050)})",
+ st38b.get(1050, ("", ""))[0] == "charging"
+ and st38b.get(1050)[1] == "running" and after(r38b, 300, 1000) == [])
+
+# =========================================================================== #
+print("\nT40. ANOTHER WRITER (N10)")
+# =========================================================================== #
+n_other = LOG.count("WARNING", "CHARGER_OTHER")
+check("T40 guard: the add-on's own 0 A pauses and phase sequences above were "
+ "never taken for another writer", n_other == 0)
+st40 = {}
+
+
+def _st40(p, c, t):
+ st40[t] = (c.car_solar.hold, [x for x in c.checks()
+ if x["id"] == "charger_other"])
+
+
+r40 = solar_exit(lambda p, c: p.ch.set_current(13), dur=900,
+ events={700: act("car_mode", "solar")}, on_cycle=_st40)
+check(f"T40: the add-on stops writing at 30 s, not 29 s, with the amber row "
+ f"and one warning ({st40.get(328)[0]}, {st40.get(331)[0]}, "
+ f"{after(r40, 300, 700)})",
+ not st40[328][0] and st40[331][0] and after(r40, 300, 700) == []
+ and st40[331][1] and st40[331][1][0]["ok"] is False
+ and st40[331][1][0]["warn"] is True
+ and LOG.count("WARNING", "CHARGER_OTHER") - n_other == 1)
+check(f"T40: pressing the mode lifts it: the add-on says its current again "
+ f"({after(r40, 700)})", after(r40, 700)[:1] == [(after(r40, 700)[0][0],
+ 10.0)])
+check("T40: the row says 'Something else changes the charger', EN and NL",
+ "Something else changes the charger" in str(messages.row_charger_other())
+ and "Iets anders wijzigt de laadpaal" in messages.row_charger_other().nl)
+
+# =========================================================================== #
+print("\nT41. TODAY'S kWh FROM THE SUN")
+# =========================================================================== #
+
+
+def sun_kwh(r):
+ return r["c"].car_sun_kwh()
+
+
+def car_wh(r, t0, t1, cap=None):
+ out = 0.0
+ for x in r["trace"]:
+ if t0 <= x["t"] < t1:
+ out += x["car"] if cap is None else min(x["car"], cap)
+ return out / 3.6e6
+
+
+r41a = S.drive(house=const(0.0), sun=const(3000.0), first="car", socs=FULL,
+ dur=3600)
+r41b = S.drive(dur=3600, **SC2)
+for name, r, cap in (("(a) Car first, spare 3000, 12 A", r41a, 3000.0),
+ ("(b) Batteries first, scenario 2", r41b, 2000.0)):
+ want = car_wh(r, 0, 3600, cap)
+ check(f"T41 {name}: the sun share is all of the car's energy "
+ f"({sun_kwh(r):.3f} kWh, the car {want:.3f} kWh, within 10 Wh)",
+ sun_kwh(r) is not None and abs(sun_kwh(r) - want) <= 0.010
+ and want > 1.5)
+r41c = S.drive(house=const(0.0), sun=steps((0, 2000.0), (300, 1000.0)),
+ first="car", socs=FULL, opts={"ev_pause_min": 30}, dur=1800)
+want_c = car_wh(r41c, 0, 300, 2000.0) + car_wh(r41c, 300, 1800, 1000.0)
+tot_c = car_wh(r41c, 0, 1800)
+check(f"T41 (c): a hold (spare 1000 W, car 6 A): only 1000 W of the 1380 W "
+ f"counts ({sun_kwh(r41c):.3f} of {tot_c:.3f} kWh, expected "
+ f"{want_c:.3f})", abs(sun_kwh(r41c) - want_c) <= 0.010
+ and sun_kwh(r41c) < tot_c - 0.1)
+r41d = S.drive(house=const(500.0), sun=const(0.0), first="car", socs=FULL,
+ dur=900)
+r41e = S.drive(house=const(0.0), sun=const(5300.0), first="car", socs=FULL,
+ mode="manual", setpoint=10, dur=900)
+check(f"T41 (d) spare -500 and (e) Manual at 10 A with 3 kW export: 0 kWh from "
+ f"the sun ({sun_kwh(r41d)}, {sun_kwh(r41e)})",
+ not sun_kwh(r41d) and not sun_kwh(r41e)
+ and (r41e["c"].car.today_kwh or 0) > 0.3)
+c41 = r41a["c"]
+vals41 = c41.car_values()
+blk41 = homeview.car_block(c41, None)
+check(f"T41: 0 <= sun <= today; the MQTT value and the card show the same "
+ f"figures ({vals41['car_today_solar_kwh']}, {blk41['today']!r})",
+ 0 <= sun_kwh(r41a) <= c41.car.today_kwh
+ and vals41["car_today_solar_kwh"] == round(sun_kwh(r41a), 3)
+ and blk41["today"] == homeview._t(
+ "car.today_sun", kwh=homeview._kwh(c41.car.today_kwh),
+ sun=homeview._kwh(sun_kwh(r41a))))
+c41.car.day = "2099-01-01"
+c41._car_sun_tick(c41.car_now() + 1)
+check("T41 (f): a new day starts at 0", c41.car_sun["kwh"] == 0.0)
+
+# =========================================================================== #
+print("\nT42, T43. STRINGS, DOCS AND THE OPTIONS")
+# =========================================================================== #
+_en = json.load(io.open(os.path.join(HERE, "app", "ui_text", "en.json"),
+ encoding="utf-8"))
+_nl = json.load(io.open(os.path.join(HERE, "app", "ui_text", "nl.json"),
+ encoding="utf-8"))
+_keys = [("home_words", "car", "why", k) for k in
+ ("solar_batt", "solar_car", "solar_paused")] + [
+ ("home", "car", "help_solar", "description"), ("home", "car", "first"),
+ ("home", "car", "first_help", "description"),
+ ("home_words", "car", "today_sun")]
+
+
+def _get(d, path):
+ for k in path:
+ d = d[k]
+ return d
+
+
+check("T42: why.solar_batt/car/paused, help.solar, first, first.help and the "
+ "kWh line exist in English and Dutch, and differ",
+ all(_get(_en, k) and _get(_nl, k) and _get(_en, k) != _get(_nl, k)
+ for k in _keys))
+_docs = io.open(os.path.join(HERE, "DOCS.md"), encoding="utf-8").read()
+check("T42: DOCS has the Solar section and cut-over step 3; DECISIONS/EV-05 "
+ "and a CHANGELOG line exist",
+ "**Solar mode.**" in _docs and "3. On the next sunny day, choose "
+ "**Solar**" in _docs and os.path.exists(os.path.join(
+ HERE, "DECISIONS", "EV-05-solar-mode.md"))
+ and "[[EV-05]]" in io.open(os.path.join(HERE, "CHANGELOG.md"),
+ encoding="utf-8").read().split("## 0.24")[0])
+check("T42: the defaults: ev_margin_w 100, ev_pause_min 5, ev_start_min 2",
+ (CH.EV_OPTION_DEFAULTS["ev_margin_w"], CH.EV_OPTION_DEFAULTS[
+ "ev_pause_min"], CH.EV_OPTION_DEFAULTS["ev_start_min"]) == (100, 5, 2))
+_cy = io.open(os.path.join(HERE, "config.yaml"), encoding="utf-8").read()
+check("T43: config.yaml's schema has the same ranges as the validator",
+ all(f"{k}: int({lo},{hi})" in _cy for k, (lo, hi) in
+ CH.SOLAR_RANGES.items()))
+_base43 = {"ev_charger": "alfen_ha", "ev_current_entity": S.SET}
+bad43, good43 = [], []
+for k, vals in (("ev_margin_w", (-1, 1001)), ("ev_pause_min", (0, 31)),
+ ("ev_start_min", (0, 31))):
+ for v in vals:
+ msgs = validate._charger_problems(dict(_base43, **{k: v}), {})
+ if not any(f"({k})" in m for m in msgs):
+ bad43.append((k, v, msgs))
+for k, vals in (("ev_margin_w", (0, 1000, 100)), ("ev_pause_min", (1, 30, 5)),
+ ("ev_start_min", (1, 30, 2))):
+ for v in vals:
+ if validate._charger_problems(dict(_base43, **{k: v}), {}):
+ good43.append((k, v))
+check(f"T43: -1/1001, 0/31, 0/31 are refused naming the setting; the edges and "
+ f"the defaults pass ({bad43[:2]}, {good43[:2]})", not bad43 and not good43)
+
+# =========================================================================== #
+print("\nT46-T48, T50-T52. WHAT MUST NOT CHANGE")
+# =========================================================================== #
+
+
+def seam_callers():
+ out = []
+ for f in sorted(os.listdir(os.path.join(HERE, "app"))):
+ if not f.endswith(".py") or f == "chargers.py":
+ continue
+ tree = ast.parse(io.open(os.path.join(HERE, "app", f),
+ encoding="utf-8").read())
+ for n in ast.walk(tree):
+ if isinstance(n, ast.Call) and isinstance(n.func, ast.Attribute) \
+ and (n.func.attr in ("write_current", "write_phases")
+ or (n.func.attr == "release"
+ and "charger" in ast.dump(n.func.value))):
+ out.append((f, n.func.attr))
+ return sorted(out)
+
+
+_ch_src = io.open(os.path.join(HERE, "app", "chargers.py"),
+ encoding="utf-8").read()
+_rel = _ch_src.split("async def release(self, mode: str) -> bool:")[2]
+check(f"T46: the write sites are still exactly one write_current and one "
+ f"write_phases, in carmode.py ({seam_callers()}); the driver's release "
+ f"writes nothing", seam_callers() == [("carmode.py", "write_current"),
+ ("carmode.py", "write_phases")]
+ and "write_current" not in _rel.split("class ")[0])
+check("T47: start_mode still maps a mode it does not know to Off",
+ carmode.start_mode({}, "night") == "off"
+ and carmode.start_mode({}, "bogus") == "off"
+ and carmode.start_mode({}, "solar") == "solar")
+r48 = S.drive(mode="manual", setpoint=10, first="car", dur=60,
+ opts={"ev_margin_w": 1000, "ev_start_min": 30,
+ "ev_pause_min": 1}, house=const(0.0), sun=const(0.0),
+ socs=FULL)
+check(f"T48: Manual ignores where spare sun goes, the margin and the dwells: "
+ f"it writes its own current at once ({cur(r48)})",
+ [v for _t, v in cur(r48)] == [float(r48["c"].car_a)]
+ and cur(r48)[0][0] <= 5)
+_c52 = r41a["c"]
+check(f"T52: in Solar the House tile and the house profile still leave the car "
+ f"out: car_term gives the car's own power ({_c52.car_term()})",
+ _c52.car_term()[1] is False and _c52.car_term()[0] > 2000)
+
+print("\n(T39, T44, T45, T50 and T51, the long runs, are in test_ev05_long.py)")
+
+print()
+if fails:
+ print(f"{len(fails)} FAILED")
+ for f in fails:
+ print(" -", f)
+ sys.exit(1)
+print("all passed")
diff --git a/goodwe_controller/test_ev05_long.py b/goodwe_controller/test_ev05_long.py
new file mode 100644
index 0000000..8fbefff
--- /dev/null
+++ b/goodwe_controller/test_ev05_long.py
@@ -0,0 +1,421 @@
+"""EV-05: the car's Solar mode, the long runs. `python3 -B test_ev05_long.py`
+
+Split from test_ev05.py so CI's parallel batch stays short: the shadow-mode
+twin (T39), the acceptance day (T44), the fuzz (T45), and the hour-long
+"nothing else changes" comparisons (T50, T51). Same harness,
+`tools/ev05_sun.py`; the rows are named by their test-plan id.
+Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
+"""
+
+import logging
+import math
+import os
+import random
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(HERE, "tools"))
+
+import ev05_sun as S # noqa: E402
+from chargersim import SimCharger # noqa: E402
+
+logging.disable(logging.CRITICAL)
+fails = []
+
+
+def check(name, cond):
+ print(f" {'ok ' if cond else 'FAIL'} {name}")
+ if not cond:
+ fails.append(name)
+
+
+def const(w):
+ return lambda t: float(w)
+
+
+def steps(*pairs):
+ def f(t):
+ v = pairs[0][1]
+ for at, w in pairs:
+ if t >= at:
+ v = w
+ return float(v)
+ return f
+
+
+def cur(r):
+ return S.writes(r, "current")
+
+
+def ph(r):
+ return S.writes(r, "phases")
+
+
+FULL = {"a": 100.0, "b": 100.0}
+ABLE = {"a": 60.0, "b": 60.0}
+
+
+def quarters(r, aim):
+ """(start, import average, car average) of each whole quarter."""
+ out = []
+ tr = r["trace"]
+ for q0 in range(0, int(tr[-1]["t"]) + 1 - 900, 900):
+ xs = [x for x in tr if q0 <= x["t"] < q0 + 900]
+ if len(xs) < 890:
+ continue
+ g = sum(max(0.0, x["grid"]) for x in xs) / len(xs)
+ car = sum(x["car"] for x in xs) / len(xs)
+ out.append((q0, g, car))
+ return out
+
+
+def seq_ok(r):
+ """Every select: a 0 A write before it, the car under 100 W or out of C or
+ 20 s after the 0 A, then 10 s or more to the next current; no other write
+ in between."""
+ log = r["sim"].log
+ state = {x["t"]: x["st"] for x in r["trace"]}
+ bad = []
+ for i, x in enumerate(log):
+ if x[1] != "phases":
+ continue
+ prev = log[i - 1] if i else None
+ nxt = log[i + 1] if i + 1 < len(log) else None
+ if prev is None or prev[1] != "current" or prev[2] != 0.0:
+ bad.append(("no 0 A before", x))
+ continue
+ quiet = (x[3] < 100.0 or state.get(x[0] - 1) != "C"
+ or x[0] - prev[0] >= 20.0)
+ if not quiet or x[4] != 0.0:
+ bad.append(("select under load", x))
+ if nxt is not None and (nxt[1] != "current" or nxt[0] - x[0] < 10.0):
+ bad.append(("current too soon or not next", x, nxt))
+ return bad
+
+
+def inv_sets(r):
+ return [x for x in r["plant"].sets if x[1].startswith("number.sp_")]
+
+
+# =========================================================================== #
+print("\nT39. SHADOW MODE: NOTHING WRITTEN, THE CARD SAYS WHAT IT WOULD SET (N10)")
+# =========================================================================== #
+
+
+def cloudy(t):
+ k = int(t) // 240
+ return 900.0 + (2600.0 if k % 3 else 400.0) + 300.0 * (k % 5)
+
+
+twin = S.drive(house=const(500.0), sun=cloudy, first="car", socs=FULL,
+ opts={"ev_phases": "1"}, dur=3600)
+for name, kw in (("on", dict(opts={"ev_phases": "1", "shadow_mode": "on"})),
+ ("auto, control stopped",
+ dict(opts={"ev_phases": "1", "shadow_mode": "auto"},
+ events={0: lambda p, c: setattr(c, "auto", False)}))):
+ sh = S.drive(house=const(500.0), sun=cloudy, first="car", socs=FULL,
+ dur=3600, **kw)
+ diff = [(a["t"], a["a"], (b["would"] or (None,))[0])
+ for a, b in zip(twin["trace"], sh["trace"])
+ if b["would"] is not None and a["a"] != b["would"][0]]
+ check(f"T39 shadow {name}: the charger log is empty for a cloudy hour, and "
+ f"every second the card's 'would set' is the current of a twin run "
+ f"without shadow mode ({len(diff)} seconds differ: {diff[:3]})",
+ sh["sim"].log == [] and not diff
+ and len({a['a'] for a in twin['trace']}) >= 3)
+
+
+# =========================================================================== #
+print("\nT50, T51. NOTHING ELSE CHANGES FOR THE GUARD AND THE ZERO-GRID LOOP")
+# =========================================================================== #
+h50 = steps((0, 400.0), (600, 2600.0), (900, 800.0), (1800, 4200.0),
+ (2100, 300.0), (3000, 1500.0))
+r50 = S.drive(house=h50, sun=const(0.0), plug=False, dur=3600)
+r50o = S.drive(house=h50, sun=const(0.0), plug=False, dur=3600,
+ opts={"ev_charger": "off"})
+
+
+check(f"T50: Solar with no car for an hour: the guard's floor and every battery "
+ f"command are identical to the run with no charger "
+ f"({len(inv_sets(r50))} commands)", inv_sets(r50) == inv_sets(r50o)
+ and [x["floor"] for x in r50["trace"]]
+ == [x["floor"] for x in r50o["trace"]] and cur(r50) == [])
+sun51 = steps((0, 3000.0), (700, 5200.0), (1500, 2500.0))
+r51 = S.drive(house=const(400.0), sun=sun51, first="car", socs=ABLE,
+ dur=2000)
+carp = {int(x["t"]): x["car"] for x in r51["trace"]}
+r51o = S.drive(house=lambda t: 400.0 + carp.get(math.ceil(t), 0.0),
+ sun=sun51, socs=ABLE, dur=2000, opts={"ev_charger": "off"})
+check(f"T51: Car first, the zero-grid loop: the same meter series with the car "
+ f"as a Solar car and as house load gives the same battery commands "
+ f"({len(inv_sets(r51))} commands)", inv_sets(r51) == inv_sets(r51o)
+ and max(carp.values()) > 3000)
+check("T51: the batteries charge with what the car leaves (Car first)",
+ -300 <= r51["plant"].batt(1999) <= 0)
+# =========================================================================== #
+print("\nT44. THE ACCEPTANCE DAY: 08:00-18:00, CLOUDS, HOUSE STEPS (A2)")
+# =========================================================================== #
+_rnd44 = random.Random(44)
+CLOUDS44 = []
+for _i in range(12):
+ a = _rnd44.randint(600, 34000)
+ CLOUDS44.append((a, a + _rnd44.randint(60, 480)))
+STEPS44 = [(8000, 8300), (17000, 17300), (26000, 26300)]
+
+
+def sun44(t):
+ base = max(0.0, 7500.0 * math.sin(math.pi * t / 36000.0))
+ return base * (0.15 if any(a <= t < b for a, b in CLOUDS44) else 1.0)
+
+
+def house44(t):
+ w = 1450.0 + 1050.0 * math.sin(t / 1700.0)
+ return w + (3000.0 if any(a <= t < b for a, b in STEPS44) else 0.0)
+
+
+long44 = sum(1 for a, b in CLOUDS44 if b - a > 300)
+for first, race in (("batteries", False), ("car", True)):
+ # The batteries' levels move with their charge (A 15.36 kWh, B 20.48 kWh),
+ # so with Batteries first the car gets sun once they are full.
+ r44 = S.drive(house=house44, sun=sun44, first=first, socs={"a": 40.0,
+ "b": 60.0},
+ caps={"a": 15.36, "b": 20.48}, dur=36000, race=race)
+ # On the harness clock, as the trace (the model's own clock runs ahead).
+ w44 = [(x[0], x[2]) for x in r44["plant"].wlog if x[1] == "current"]
+ p44 = [(x[0], x[2]) for x in r44["plant"].wlog if x[1] == "phases"]
+ # A phase change's own 0 A (a select follows within 25 s) is not a pause.
+ seq0 = {t for t, v in w44 if v == 0.0 and any(0 < pt - t <= 25
+ for pt, _n in p44)}
+ starts, pauses, paused, pause_t = 0, 0, True, []
+ for t, v in w44:
+ if v == 0.0 and t not in seq0:
+ paused = True
+ pauses += 1
+ pause_t.append(t)
+ elif v > 0 and paused:
+ starts += 1
+ paused = False
+ why_at = {x["t"]: x["why"] for x in r44["trace"]}
+ cut_t = [t for t in pause_t if why_at.get(t) == "cut"
+ or why_at.get(t - 1) == "cut"]
+ # Car first: no hold pause from a cloud under 300 s. Batteries first: a
+ # battery that gave power in the cloud is under 100 % again, so its
+ # rating is room and the car waits for it (the brief's room rule).
+ short_hit = [t for t in pause_t if t not in cut_t and first == "car"
+ and any(a <= t <= b + 2 for a, b in CLOUDS44 if b - a <= 300)]
+ print(f" pauses (second, why): {[(t, why_at.get(t)) for t in pause_t]}")
+ # N5 on the whole day: a start 120 s or more after its pause, a hold
+ # pause after 300 s of holding, non-zero writes 30 s apart.
+ nz = [t for t, v in w44 if v > 0]
+ n5 = [("30 s", b) for a, b in zip(nz, nz[1:]) if b - a < 30]
+ last_p = None
+ for t, v in w44:
+ if v == 0.0 and t not in seq0:
+ last_p = t
+ elif v > 0 and last_p is not None:
+ if t - last_p < 120:
+ n5.append(("start", t))
+ last_p = None
+ for t in pause_t:
+ if why_at.get(t) == "paused":
+ run = 0
+ while why_at.get(t - 1 - run) == "hold":
+ run += 1
+ if run < 298:
+ n5.append(("pause", t, run))
+ # The loop turns at most `slew_w` per cycle, so for some 15 s after each
+ # current step, cloud edge and house step the grid covers the change:
+ # counted apart (dev report). The rest is the car on grid power while
+ # the loop is settled, outside the holds.
+ edges = [t for t, v in w44] + [e for ab in CLOUDS44 + STEPS44 for e in ab]
+ edges.sort()
+
+ def settling(t):
+ return any(0 <= t - e < 15 for e in edges)
+ grid_wh = sum(min(x["car"], max(0.0, x["grid"])) for x in r44["trace"]
+ if x["why"] not in ("hold",) and not settling(x["t"])) / 3600.0
+ slew_wh = sum(min(x["car"], max(0.0, x["grid"])) for x in r44["trace"]
+ if settling(x["t"])) / 3600.0
+ steps44 = edges
+ over44 = [(q, round(g)) for q, g, car in quarters(r44, 3400.0)
+ if g > 3410.0 and g - car <= 3410.0]
+ gaps = [b[0] - a[0] for a, b in zip(p44, p44[1:])]
+ check(f"T44 {first} first ({'race' if race else 'step'}): starts {starts} "
+ f"(<= 1 + {long44} long clouds + {len(cut_t)} peak cuts, Car first)"
+ f"; pauses {pauses}; N5 dwells {n5[:3]}; selects {len(p44)} "
+ f"(gaps >= 600 s: {gaps[:4]}); no pause from a short cloud "
+ f"{short_hit[:3]}; the car's grid energy outside holds {grid_wh:.1f} "
+ f"Wh (and {slew_wh:.1f} Wh in the loop's 15 s after "
+ f"{len(steps44)} steps and edges); quarters over the aim by the car "
+ f"{over44}",
+ starts >= 1 and not n5 and all(g >= 600 for g in gaps)
+ and (first != "car" or starts <= 1 + long44 + len(cut_t))
+ and not seq_ok(r44) and not short_hit and grid_wh <= 10.0
+ and not over44)
+
+# =========================================================================== #
+print("\nT45. THE FUZZ: 14 SITES, 16800 STEPS (N1-N10)")
+# The plan asks 14 x 400 steps; a busy site rarely has the 60 s calm a start
+# needs, so each site runs 1200 steps to make enough writes to judge.
+# =========================================================================== #
+
+
+def fuzz(seed):
+ rnd = random.Random(seed)
+ stations = [10.0, 13.0, 16.0]
+ st = {"sun": rnd.uniform(0, 9000), "house": rnd.uniform(200, 3000),
+ "n": {}, "acts": [], "undo": [], "exits": []}
+
+ def exit_check(p, c):
+ """N9: Solar to Off with the charger above 0 A, reachable, taking
+ writes and not held by another writer: a 0 A must follow."""
+ ch = p.ch
+ if c.car_mode == "solar" and not c.car_solar.hold \
+ and not ch.unavailable and ch.refuse is None \
+ and ch.readback_a > 0.5 and not p.ha_down:
+ st["exits"].append(p.t)
+
+ def later(p, fn):
+ st["undo"].append((p.t + rnd.randint(10, 40), fn))
+
+ def ev(p, c):
+ for due in [u for u in st["undo"] if u[0] <= p.t]:
+ st["undo"].remove(due)
+ due[1]()
+ if st.get("back") is not None and p.t >= st["back"]:
+ st["back"] = None # the user goes back to Solar
+ st["acts"].append(p.t)
+ return c.handle_action("car_mode", value="solar")
+ if st.get("press") is not None and p.t >= st["press"]:
+ st["press"] = None # the user presses the mode
+ st["acts"].append(p.t)
+ return c.handle_action("car_mode", value=c.car_mode)
+ r = rnd.random()
+ ch = p.ch
+ if r < 0.012:
+ st["sun"] = rnd.choice([0.0, 1000.0, 2500.0, 5000.0, 8000.0,
+ 8000.0, 6500.0])
+ elif r < 0.02:
+ st["house"] = rnd.uniform(200, 4000)
+ elif r < 0.08:
+ st["sun"] = max(0.0, st["sun"] + rnd.uniform(-600, 600))
+ elif r < 0.082:
+ if ch.state != "A":
+ ch.unplug()
+ later(p, ch.plug_in)
+ st["n"]["plug"] = st["n"].get("plug", 0) + 1
+ elif r < 0.084:
+ ch.go_unavailable(True)
+ later(p, lambda: ch.go_unavailable(False))
+ st["n"]["down"] = st["n"].get("down", 0) + 1
+ elif r < 0.087:
+ ch.set_current(rnd.randint(0, 16))
+ st["n"]["other"] = st["n"].get("other", 0) + 1
+ st["press"] = p.t + rnd.randint(20, 90)
+ elif r < 0.089:
+ ch.refuse = rnd.choice(["ignore", "error"])
+ later(p, lambda: setattr(ch, "refuse", None))
+ elif r < 0.091:
+ p.meter_on = False
+ later(p, lambda: setattr(p, "meter_on", True))
+ st["n"]["meter"] = st["n"].get("meter", 0) + 1
+ elif r < 0.093:
+ c.o["shadow_mode"] = "on"
+ later(p, lambda: c.o.__setitem__("shadow_mode", "off"))
+ st["n"]["shadow"] = st["n"].get("shadow", 0) + 1
+ elif r < 0.095:
+ c.auto = False
+ later(p, lambda: setattr(c, "auto", True))
+ st["n"]["stop"] = st["n"].get("stop", 0) + 1
+ elif r < 0.098:
+ m = rnd.choice(["solar", "solar", "solar", "off", "manual"])
+ st["n"]["mode"] = st["n"].get("mode", 0) + 1
+ st["acts"].append(p.t)
+ if m == "off":
+ exit_check(p, c)
+ return c.handle_action("car_mode", value=m)
+ elif r < 0.1:
+ ch.station_a = rnd.choice(stations)
+ elif r < 0.103 and c.car_mode == "solar" and p.ch.readback_a > 0.5 \
+ and st.get("back") is None:
+ exit_check(p, c) # leave Solar while it charges
+ st["acts"].append(p.t)
+ st["back"] = p.t + rnd.randint(30, 120)
+ return c.handle_action("car_mode", value="off")
+ elif r < 0.2 and c.car_solar.seq is not None:
+ st["n"]["mid"] = st["n"].get("mid", 0) + 1
+ exit_check(p, c)
+ return c.handle_action("car_mode", value="off")
+ ctx = []
+
+ def note(p, c, t):
+ ctx.append((t, c.car_mode, c.car_writing(), c.car_solar.single,
+ c.car_solar.hold, p.ch.station_a))
+ r = S.drive(house=lambda t: st["house"], sun=lambda t: st["sun"],
+ first="car", opts={"ev_margin_w": 0, "ev_start_min": 1,
+ "ev_pause_min": 1}, socs=FULL, dur=1200,
+ events={t: ev for t in range(1, 1200)}, on_cycle=note,
+ race=seed % 2 == 1, sim=SimCharger(setpoint_a=rnd.choice(
+ [0, 10, 16])))
+ bad = []
+ by_t = {x[0]: x for x in ctx}
+ log = r["plant"].wlog # on the harness clock
+ last_sel, last_nz = None, None
+ for t, what, v, power, sp in log:
+ # A write logged at second t comes after that second's actions.
+ x = by_t.get(t) or by_t.get(t - 1)
+ mode = x[1] if x else "?"
+ if what == "current" and v > min(16.0, x[5] if x else 16.0) + 1e-9:
+ bad.append(("N1 over the clamp", t, v))
+ if what == "phases":
+ if sp != 0.0:
+ bad.append(("N2 select with the setpoint up", t))
+ if last_sel is not None and t - last_sel < 600:
+ bad.append(("N2 two selects in 600 s", t))
+ last_sel = t
+ if what == "current" and mode == "off" and v > 0:
+ bad.append(("N10 a non-zero write in Off", t, v))
+ if what == "current" and x is not None and not x[2] and v > 0 \
+ and mode == "solar":
+ bad.append(("N10 a non-zero Solar write while not writing", t, v))
+ if what == "current" and v > 0 and mode == "solar":
+ near_act = any(abs(t - a) <= 3 for a in st["acts"])
+ if last_nz is not None and t - last_nz < 30 and not near_act:
+ bad.append(("N5 two non-zero writes under 30 s", t, v))
+ last_nz = t
+ for te in st["exits"]:
+ if not any(x[1] == "current" and x[2] == 0.0 and te <= x[0] <= te + 3
+ for x in log):
+ bad.append(("N9 Solar to Off left the current up", te))
+ if r["c"].charger.clamp_faults:
+ bad.append(("N1 clamp fault", r["c"].charger.clamp_faults))
+ st["n"]["exits"] = len(st["exits"])
+ return bad, len(log), st["n"]
+
+
+fz_bad, fz_n, fz_counts = [], 0, {}
+for _seed in range(14):
+ _b, _n, _c = fuzz(_seed)
+ fz_bad += _b
+ fz_n += _n
+ for k, v in _c.items():
+ fz_counts[k] = fz_counts.get(k, 0) + v
+check(f"T45: {fz_n} charger writes over 14 random Solar sites and 16800 steps "
+ f"(outages, unplugs, refusals, other writers, a silent meter, shadow and "
+ f"Stop, mode changes, half racing): none over the clamp, no select with "
+ f"the setpoint up or two in 600 s, every Solar to Off at 0 A (N9), no "
+ f"non-zero write in Off, in shadow "
+ f"or stopped, none under 30 s apart ({fz_bad[:3]})",
+ not fz_bad and fz_n > 100)
+check(f"T45: each disturbance happened ({fz_counts})",
+ all(fz_counts.get(k, 0) > 2 for k in ("plug", "down", "other", "meter",
+ "shadow", "stop", "mode",
+ "exits")))
+
+print()
+if fails:
+ print(f"{len(fails)} FAILED")
+ for f in fails:
+ print(" -", f)
+ sys.exit(1)
+print("all passed")
diff --git a/goodwe_controller/tools/ev05_sun.py b/goodwe_controller/tools/ev05_sun.py
new file mode 100644
index 0000000..01bed34
--- /dev/null
+++ b/goodwe_controller/tools/ev05_sun.py
@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""EV-05: the real Controller on a sunny plant with N batteries and a car.
+
+ python3 tools/ev05_sun.py # mock-up scenario 2, both priorities
+
+A 1 s cycle, a P1 meter that publishes 0.3 s before each cycle, N batteries
+each with ITS OWN rating and level (switched On, so the zero-grid loop charges
+them from the export), and `chargersim.SimCharger` behind the same Home
+Assistant. The meter sees `house + car - sun - batteries` (battery discharge
+positive), so the spare sun the add-on computes is `sun - house` whatever it
+does. A battery at 100 % takes no charge. `events` is `{second: fn(plant, c)}`,
+run before that cycle. `race=True` uses the production order (read, the writer
+task settles, then the cycle), as test_ev04.py's `World.step_race`.
+
+Used by test_ev05.py and, later, by the rig test."""
+
+import asyncio
+import logging
+import os
+import sys
+import tempfile
+from datetime import timedelta
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+import opt11_identity as rig # noqa: E402
+import main_files # noqa: E402
+from app import packmode # noqa: E402
+from app.main import Controller # noqa: E402
+from app.p1 import make_sample, split_signed # noqa: E402
+from app.store import unit_key # noqa: E402
+from chargersim import SimCharger # noqa: E402
+from app import p1 as _p1 # noqa: E402
+
+SET = "number.wallbox_power_connector_max_current_socket_1"
+PHASES = "select.wallbox_installation_max_allowed_phases"
+ALARMS = ("goodwe_peak_saturated", "goodwe_peak_soc_floor")
+RESPONSE_S = 0.5 # a battery reaches its new command this much later
+SAMPLE_LEAD_S = 0.3
+
+
+class SunPlant:
+ """The house, the sun, N batteries and the charger on one meter."""
+
+ def __init__(self, house, sun, ratings, socs, charger):
+ self.house, self.sun = house, sun
+ self.ratings, self.socs = dict(ratings), dict(socs)
+ self.ch = charger
+ self.t = 0.0
+ self.hists = {u: [(-1e9, 0.0)] for u in self.ratings}
+ self.notes = [] # (t, notification id) raised
+ self.dismissed = []
+ self.sets = [] # (t, entity, value): every number write
+ # Every charger write the model took, as `SimCharger.log` has it but
+ # on THIS clock (the model's own runs ahead while a write waits).
+ self.wlog = []
+ self.meter = 0.0
+ self.meter_on = True # False: the meter stops publishing
+ self.batt_nan = set() # units whose battery figure reads None
+ self.utc_off = 0.0 # the wall clock jumps, the model clock not
+ self.ha_down = False # Home Assistant answers nothing (SAFETY-112)
+
+ def batt_of(self, u, at):
+ w = 0.0
+ for when, v in self.hists[u]:
+ if when <= at:
+ w = v
+ r = self.ratings[u]
+ w = max(-r, min(r, float(round(w))))
+ if self.socs[u] >= 100.0 and w < 0.0:
+ w = 0.0 # a full battery takes no charge
+ return w
+
+ def batt(self, at):
+ return sum(self.batt_of(u, at) for u in self.ratings)
+
+ def grid(self, at):
+ return self.house(at) + self.ch.power_w - self.sun(at) - self.batt(at)
+
+ # -- Home Assistant -----------------------------------------------------
+ async def limits(self, e):
+ return (-5000.0, 5000.0, 1.0)
+
+ async def state(self, entity_id):
+ if self.ha_down:
+ return None
+ return self.ch.states().get(entity_id)
+
+ async def states(self):
+ if self.ha_down:
+ return []
+ return list(self.ch.states().values())
+
+ async def call(self, domain, service, data=None):
+ if self.ha_down:
+ return False
+ if service == "create":
+ self.notes.append((self.t, (data or {}).get("notification_id")))
+ if service == "dismiss":
+ self.dismissed.append((self.t, (data or {}).get("notification_id")))
+ if domain == "select" and service == "select_option":
+ n = 3 if "3" in str((data or {}).get("option")) else 1
+ return self._logged("phases", n, self.ch.request_phases)
+ return True
+
+ def _logged(self, what, v, fn):
+ n0, row = len(self.ch.log), (self.t, what, v, self.ch.power_w,
+ self.ch.setpoint_a)
+ ok = fn(v)
+ if len(self.ch.log) > n0:
+ self.wlog.append(row)
+ return ok
+
+ async def number(self, e, invert=False):
+ if self.ha_down:
+ return None
+ for u in self.ratings:
+ if e == "sensor.soc_" + u:
+ return self.socs[u]
+ if e == "sensor.batt_" + u:
+ return None if u in self.batt_nan else self.batt_of(u, self.t)
+ if e in ("sensor.grid", "sensor.net"):
+ return self.meter
+ return None
+
+ async def set_number(self, e, v):
+ if self.ha_down:
+ return False
+ self.sets.append((self.t, e, float(v)))
+ if e == SET:
+ return self._logged("current", float(v), self.ch.request_current)
+ if e.startswith("number.sp_"):
+ self.hists[e[-1]].append((self.t + RESPONSE_S, float(v)))
+ return True
+
+
+def drive(house, sun, *, dur=600.0, ratings=None, socs=None, cap=3500.0,
+ margin=100, opts=None, plug=True, setpoint=0, phases=1, mode="solar",
+ first="batteries", events=None, sim=None, store=None, race=False,
+ on_cycle=None, car_phases=3, t0=0.0, caps=None):
+ """Run it. Returns a dict: plant, controller, charger, notifications with
+ their second, and a per-second trace. `caps` ({unit: kWh}) lets each
+ battery's level move with what it charges or gives; without it the
+ levels stand still."""
+ ratings = ratings or {"a": 5000.0, "b": 4600.0}
+ socs = socs or {u: 50.0 for u in ratings}
+ sim = sim or SimCharger(setpoint_a=setpoint)
+ if plug:
+ sim.plug_in(car_phases=car_phases)
+ sim.phases_allowed = phases
+ units = sorted(ratings)
+ o = rig._options(len(units), dict({
+ "meter_source": "ha_signed", "p1_net_entity": "sensor.net",
+ "meter_phases": 1, "peak_cap_w": cap, "peak_margin_w": margin,
+ "battery_modes_enabled": True,
+ "ev_charger": "alfen_ha", "ev_max_a": 16, "ev_phases": "auto",
+ "ev_current_entity": SET}, **(opts or {})))
+ if len(units) == 1:
+ o["max_w"] = ratings[units[0]]
+ else:
+ o["inverters"] = [dict(x, max_w=ratings[x["name"][-1]])
+ for x in o["inverters"]]
+ store = store or rig._Store()
+ store.data["car_mode"] = mode
+ store.data["car_sun_first"] = first
+ for u in units:
+ store.data[unit_key("inverter-" + u, packmode.USE_KEY)] = True
+ db = os.path.join(tempfile.mkdtemp(prefix="ev5-"), "tariff.db")
+ out = {}
+ events_in = events or {}
+
+ async def go():
+ plant = SunPlant(house, sun, ratings, socs, sim)
+ c = Controller(o, plant, store, rig._Pub(), stop=asyncio.Event(),
+ peak_db_path=db)
+ for i in c.inverters:
+ r = ratings[i.name[-1]] if len(units) > 1 else ratings[units[0]]
+ i.dev_min, i.dev_max = -r, r
+ c.auto = True
+ clock = [t0]
+ c.car_now = lambda: clock[0]
+ real_time = _p1.time
+
+ class _Time:
+ """The meter's age on the model clock, so a silent meter goes
+ stale in model seconds."""
+ def __getattr__(self, k):
+ return getattr(real_time, k)
+
+ @staticmethod
+ def monotonic():
+ return clock[0]
+ _p1.time = _Time()
+ if hasattr(c.charger, "_sleep"):
+ async def sleep(s):
+ sim.tick(s)
+ clock[0] += s
+ c.charger._sleep = sleep
+ c.charger._clock = lambda: clock[0]
+ real_dt = main_files.live.datetime
+
+ class _DT(real_dt):
+ @classmethod
+ def now(cls, tz=None):
+ return rig.BASE + timedelta(seconds=clock[0] + plant.utc_off)
+ main_files.live.datetime = _DT
+ trace = []
+ try:
+ t = t0
+ while t < t0 + dur:
+ plant.t = clock[0] = t
+ fn = events_in.get(int(t)) if t == int(t) else None
+ if fn is not None:
+ r = fn(plant, c)
+ if asyncio.iscoroutine(r):
+ await r
+ sim.tick(1.0)
+ ts = t - SAMPLE_LEAD_S
+ if plant.meter_on and not plant.ha_down:
+ plant.meter = plant.grid(ts)
+ imp, exp = split_signed(plant.meter)
+ c.p1.submit(make_sample(
+ "ha_signed", imp, exp, phases=1,
+ ingest_ts=rig.BASE + timedelta(seconds=ts),
+ ingest_mono=ts))
+ await c.read_inputs(now_mono=t)
+ if race:
+ await c.car_settle()
+ await c.cycle()
+ else:
+ await c.cycle()
+ await c.car_settle()
+ w = c.car_solar
+ g = c.peak_guard
+ trace.append(dict(
+ t=t, a=w.plan.a, why=w.plan.why, n=w.plan.n,
+ sp=sim.setpoint_a, rb=sim.readback_a,
+ ph=sim.phases_allowed, car=sim.power_w, st=sim.state,
+ grid=plant.grid(t), batt=plant.batt(t),
+ house=plant.house(t), sun=plant.sun(t),
+ cut=c.car_cut_w, explains=c.car_explains,
+ lim=bool(g is not None and (g.floor_limited
+ or g.saturated)),
+ floor=(None if g is None else g.floor_w),
+ excess=(None if g is None else g.excess_w),
+ proj=(None if g is None else g.projected_w),
+ target=(None if g is None else g.target_w),
+ would=w.would, single=w.single,
+ spare=c.car_spare_w(t), ok=w.plan.ok_since,
+ red=[x["id"] for x in c.checks()
+ if x["ok"] is False and not x["warn"]]
+ if on_cycle == "rows" else []))
+ if callable(on_cycle):
+ on_cycle(plant, c, t)
+ for u, kwh in (caps or {}).items():
+ lv = plant.socs[u] - plant.batt_of(u, t) / 36.0 / kwh
+ plant.socs[u] = max(0.0, min(100.0, lv))
+ t += 1.0
+ await c.car_settle()
+ finally:
+ main_files.live.datetime = real_dt
+ _p1.time = real_time
+ out.update(plant=plant, c=c, sim=sim, trace=trace, store=store,
+ raised=list(plant.notes))
+ asyncio.run(go())
+ return out
+
+
+def ids(out, *wanted):
+ return [(t, n) for t, n in out["raised"] if n in wanted]
+
+
+def writes(out, what="current"):
+ """(t, value) of every charger write of that kind, in model seconds."""
+ return [(x[0], x[2]) for x in out["sim"].writes(what)]
+
+
+def const(w):
+ return lambda t: float(w)
+
+
+if __name__ == "__main__":
+ logging.disable(logging.CRITICAL)
+ for first in ("batteries", "car"):
+ r = drive(const(900.0), const(7900.0), dur=600, first=first,
+ socs={"a": 71.0, "b": 100.0})
+ print(f"scenario 2, {first} first: writes {writes(r)} phases "
+ f"{writes(r, 'phases')} batteries {r['plant'].batt(599):.0f} W "
+ f"grid {r['plant'].grid(599):.0f} W")
diff --git a/goodwe_controller/translations/en.yaml b/goodwe_controller/translations/en.yaml
index 6ba1f20..1643264 100644
--- a/goodwe_controller/translations/en.yaml
+++ b/goodwe_controller/translations/en.yaml
@@ -300,7 +300,16 @@ configuration:
description: "While the car charges. On: the batteries cover it down to the peak reserve. Off: the peak guard leaves the car out, so the car alone can set the peak."
ev_mode_start:
name: "Car charger · Mode after a restart"
- description: "Keep the last mode, or start in Off. A restart never changes the charger's current."
+ description: "Keep the last mode, or start in Off. In Solar a restart sets the charger to 0 A first, other modes leave its current."
+ ev_margin_w:
+ name: "Car charger · Sun kept back (W)"
+ description: "Solar: this much spare sun is never given to the car."
+ ev_start_min:
+ name: "Car charger · Start after (minutes)"
+ description: "Solar: the car starts after this long with enough spare sun."
+ ev_pause_min:
+ name: "Car charger · Pause after (minutes)"
+ description: "Solar: with too little sun the car holds 6 A this long, then pauses."
auto_start:
name: "Advanced · Start control on boot"
description: "Off by default. Leave it off until the site is commissioned, so someone presses Start after each restart."
diff --git a/goodwe_controller/translations/nl.yaml b/goodwe_controller/translations/nl.yaml
index 064fd31..1b8fb00 100644
--- a/goodwe_controller/translations/nl.yaml
+++ b/goodwe_controller/translations/nl.yaml
@@ -281,7 +281,16 @@ configuration:
description: "Terwijl de auto laadt. Aan: de batterijen dekken ze tot de piekreserve. Uit: de piekbewaking laat de auto buiten beschouwing, dus de auto alleen kan de piek bepalen."
ev_mode_start:
name: "Laadpaal · Modus na een herstart"
- description: "De laatste modus houden, of starten in Uit. Een herstart verandert de stroom van de laadpaal nooit."
+ description: "De laatste modus houden, of starten in Uit. In Zon zet een herstart de laadpaal eerst op 0 A, andere modi laten haar stroom."
+ ev_margin_w:
+ name: "Laadpaal · Zon achtergehouden (W)"
+ description: "Zon: zoveel zonne-overschot krijgt de auto nooit."
+ ev_start_min:
+ name: "Laadpaal · Starten na (minuten)"
+ description: "Zon: de auto start na zo lang genoeg zonne-overschot."
+ ev_pause_min:
+ name: "Laadpaal · Pauzeren na (minuten)"
+ description: "Zon: met te weinig zon houdt de auto zo lang 6 A en pauzeert dan."
auto_start:
name: "Geavanceerd · Regeling starten bij opstarten"
description: "Staat standaard uit. Laat het uit tot de installatie in dienst is, zodat iemand na elke herstart op Start drukt."