Files
goodwe-addon/goodwe_controller/test_ev05.py
T
ems-agentandClaude 29480fda47
checks / unit (pull_request) Failing after 24m58s
infra-pin / fresh (pull_request) Successful in 1s
EV-05: car Solar mode (spare sun to the car, Batteries or Car first, cut first for the peak)
Solar charges the car from the signed spare sun (car + battery charge - grid
import), less the batteries' room (Batteries first) and the sun kept back,
whole amps rounded down, at most one change per 30 s and only on 1 A. It
starts after ev_start_min of enough sun, holds 6 A for ev_pause_min, then 0 A.
Auto phases through EV-04's safe sequence (4.5 kW / 3 min up, 4.0 kW / 5 min
down, one switch per 10 min). What the peak guard would ask the batteries for
is taken off the car first, at once. Every way out of Solar ends at 0 A,
written once; at shutdown before the inverters go to 0 W.

- app/carmode.py: SolarPlan (pure) and SolarWriter (ManualWriter's one write
  site, its sequence and watch); spare_w, car_target_w, amps_for.
- app/ctl_car.py: Solar inputs, the cut, the solar kWh, EV-15's grace for
  Solar's own 0 A, no "set by the car" for Solar; main.py: shutdown order.
- Home card, HA select.goodwe_car_sun_first, sensor car_today_solar_kwh,
  three options with defaults, strings EN/NL, DOCS, DECISIONS, CHANGELOG.
- test_ev05.py, test_ev05_long.py, tools/ev05_sun.py; test_ev03/ev04 checks
  that pinned "Solar is refused" / "three entities" updated.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-17 23:54:06 +01:00

1509 lines
64 KiB
Python

"""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")