Files
goodwe-addon/goodwe_controller/test_ev05.py
T
ems-agentandClaude 69f58181bc
checks / unit (pull_request) Successful in 24m24s
infra-pin / fresh (pull_request) Successful in 2s
EV-05 round 5: headroom counts only the batteries that can give
Review of 8818768: the headroom test compared the output with the site
rating, which still counted a battery refusing to give (SAFETY-73) or under
a safety stop, so the 15 s wait ran at the real maximum (N4). Now only the
units that can give (above their cut-out, not refusing, not stopped,
switched on) count, in what they give and in their ratings.

Tests: R5a (A refuses, B at full rating, against a car-Off twin: the cut at
910, period 3361 W), R5b (headroom and a slow battery: the cut at exactly
15 s), R5c (floor-limited alone decides: cut at once). DOCS wrapped to 79.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-18 17:27:17 +01:00

1820 lines
79 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 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 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.
# Round 2 (owner 2026-11-18): while a battery can still give, the cut waits
# until the guard has wanted power for 15 s in a row (CUT_WAIT_S).
# T21b: a step the batteries catch within 15 s (500 -> 6000 W): no cut.
r21b = S.drive(house=steps((0, 500.0), (200, 6000.0)), sun=const(2900.0),
first="car", socs=ABLE, dur=400)
want21b = [x["t"] for x in r21b["trace"] if x["since"] is not None]
# The step also takes the sun from the car, so the normal hold (6 A) follows.
check(f"T21b: a house step the batteries catch within 15 s: the guard wanted "
f"power for {len(want21b)} s, no cut, no pause; only the hold's 6 A "
f"({cur(r21b)})",
0 < len(want21b) < 15 and not first_cut(r21b, 0)
and [v for _t, v in cur(r21b)] == [10.0, 6.0])
# A cloud edge with the car at high power on 3 phases (sun 13 kW -> 3 kW for
# 120 s, house 500 W), 10 s into a period so the 10 kW import does head over
# the aim: the guard wants power until the batteries ramp; at the shipped
# `slew_w` 0 they catch it within 15 s, so the car is not cut and not paused
# (owner 2026-11-18).
r21c = S.drive(house=const(500.0), sun=steps((0, 13000.0), (910, 3000.0),
(1030, 13000.0)),
first="car", socs=ABLE, dur=1150, opts={"slew_w": 0})
w21c = [(t, v) for t, v in cur(r21c) if 900 <= t < 1150]
want21c = [x["t"] for x in r21c["trace"] if x["since"] is not None
and 905 <= x["t"] <= 960]
check(f"T21b: a cloud edge the batteries catch within 15 s gives no cut and "
f"no pause: the guard wanted power for {len(want21c)} s (writes {w21c}, "
f"phases {ph(r21c)})",
0 < len(want21c) < 15
and not first_cut(r21c, 900) and 0.0 not in [v for _t, v in w21c]
and nonzero(r21c) and nonzero(r21c)[-1][1] >= 6.0)
# T21: a step the batteries cannot catch (500 -> 15500 W for 90 s). Round 4
# (brief v5): the batteries have no headroom (the guard is saturated), so the
# cut does not wait 15 s; it comes at once.
r21 = S.drive(house=steps((0, 500.0), (200, 15500.0), (290, 500.0)),
sun=const(2900.0), first="car", socs=ABLE, dur=920)
x21 = first_cut(r21, 200)
since21 = next((x["since"] for x in r21["trace"] if x["since"] is not None),
None)
w21 = [] if x21 is None else [(t, v) for t, v in cur(r21) if t >= x21["t"]]
lim21 = None if x21 is None else math.floor((2300.0 - x21["cut"]) / 230.0)
check(f"T21: a house step beyond the batteries (no headroom): the car is cut "
f"at once, within 1 cycle, to at most "
f"floor((2300 - cut) / 230) A (wants from {since21}, cut "
f"{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 since21 is not None
and 0 <= x21["t"] - since21 <= 1 and w21
and w21[0][0] <= x21["t"] + 2 and w21[0][1] <= max(lim21, 0))
q21 = [g for q, g, _c in quarters(r21, 3400.0) if q == 0]
check(f"T21: the period still lands under the aim ({[round(g) for g in q21]} "
f"W against 3400 W)", q21 and q21[0] <= 3410.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, 17500.0), (290, 500.0)),
sun=const(2900.0), first="car", socs=ABLE, dur=700)
# (a hold's 6 A may come first: the step also takes the car's sun)
x22 = first_cut(r22, 200)
since22 = next((x["since"] for x in r22["trace"] if x["since"] is not None),
None)
w22 = [] if x22 is None else [(t, v) for t, v in cur(r22) if t >= x22["t"]]
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, no headroom: 0 A at once, no 5-min "
f"hold ({w22}, wants from {since22}, cut "
f"{None if x22 is None else round(x22['cut'])})",
x22 is not None and since22 is not None
and 0 <= x22["t"] - since22 <= 1 and w22
and w22[0][1] == 0.0 and w22[0][0] <= x22["t"] + 2)
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][1] > 0
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)
# T24 (c): batteries able, 85 s before the period's end a step whose import,
# held, takes the period over the aim: inside CUT_NEAR_END_S (120 s) the cut
# comes at once, and the period lands under the aim.
r24c = S.drive(house=steps((0, 500.0), (815, 49000.0), (830, 500.0)),
sun=const(2900.0), first="car", socs=ABLE, dur=920)
c24c = first_cut(r24c, 815)
q24c = [g for q, g, _c in quarters(r24c, 3400.0) if q == 0]
check(f"T24 (c): late in the period with the batteries able the cut does not "
f"wait ({None if c24c is None else c24c['t']}, {cur(r24c)[-2:]}), and "
f"the period lands under the aim ({[round(g) for g in q24c]} W)",
c24c is not None and c24c["t"] <= 817 and q24c and q24c[0] <= 3410.0
and ctl_car.CUT_NEAR_END_S >= 120.0)
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 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})", 1 <= [v for t, v in w31 if t < fz + 400].count(0.0) <= 3
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)
# Batteries at their cut-out: nothing can give, so the cut does not wait.
r12c = S.drive(house=steps((0, 500.0), (154, 7500.0)), sun=steps(
(0, 2900.0), (150, 3600.0)), first="car", socs=CUTOUT, 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("\nROUND 3. A REFUSED WAY-OUT 0 A IS TRIED AGAIN; ONE CUT PER EXCESS (N9)")
# =========================================================================== #
def refusing(kind):
def f(p, c):
p.ch.refuse = kind
return f
def zlog(r, t0):
"""(second, A, taken) of each current write of the Solar writer."""
return [(round(t), v, ok) for k, v, t, ok in r["c"].car_solar.log
if k == "current" and t >= t0]
def _err(p, c):
p.ch.error = "12: Socket fault"
EXITS3 = (("Stop", act("auto_toggle", None), {"shadow_mode": "off"}),
("Off", act("car_mode", "off"), {}),
("shadow on", lambda p, c: c.o.__setitem__("shadow_mode", "on"),
{}),
("safety stop", lambda p, c: setattr(c.circ_wd, "tripped", True),
{}),
("charger error", _err, {}),
("unplug", lambda p, c: p.ch.unplug(), {}))
for name, trig, opts3 in EXITS3:
for kind in ("error", "ignore"):
r3 = solar_exit(trig, dur=600, opts=opts3, events={
299: refusing(kind), 305: refusing(None)})
z3 = zlog(r3, 299)
taken = [x for x in z3 if x[1] == 0.0 and x[2]]
check(f"R3/N9 {name}, the first 0 A refused ({kind}): tried again "
f"60 s later and taken once, the charger ends at 0 A ({z3})",
z3 and z3[0][1] == 0.0 and z3[0][0] <= 302 and not z3[0][2]
and len(taken) == 1 and taken[0][0] - z3[0][0] >= 60
and taken[0][0] - z3[0][0] <= 75 and len(z3) <= 3
and not [x for x in z3 if x[1] > 0]
and r3["sim"].setpoint_a == 0.0 and r3["sim"].power_w == 0.0)
n_ref3 = LOG.count("WARNING", "CHARGER_REFUSED")
st3 = {}
def _st3(p, c, t):
if t == 599:
st3["rows"] = [x["id"] for x in c.checks()]
st3["why"] = homeview.car_block(c, None)["why"]
r3g = solar_exit(act("auto_toggle", None), dur=600,
opts={"shadow_mode": "off"},
events={299: refusing("error")}, on_cycle=_st3)
z3g = zlog(r3g, 299)
check(f"R3: a 0 A the charger never takes: 3 tries 60 s apart, then the "
f"gave-up row and one warning, and the card does not say paused "
f"({z3g}, {st3.get('why')!r})",
[x[1] for x in z3g] == [0.0, 0.0, 0.0]
and all(b[0] - a[0] >= 60 for a, b in zip(z3g, z3g[1:]))
and "charger_refused" in st3.get("rows", [])
and LOG.count("WARNING", "CHARGER_REFUSED") - n_ref3 == 1
and "paused" not in st3.get("why", "paused")
and r3g["c"].car_solar.gave_up)
r3o = solar_exit(act("car_mode", "off"), dur=600,
events={299: refusing("error")}, on_cycle=_st3)
check(f"R3: the same after Solar to Off: 3 tries, then the gave-up row "
f"({zlog(r3o, 299)})", [x[1] for x in zlog(r3o, 299)] == [0.0] * 3
and "charger_refused" in st3.get("rows", []))
# The shutdown cancels a start write while it waits for its read-back (lag
# 3 s): the 0 A must still go out (the earlier confirmed 0 A says nothing).
rec3 = {}
def _gate3(p, c):
gate = asyncio.Event()
async def sleep(_s):
gate.clear()
await gate.wait()
async def settle():
gate.set()
for _ in range(5):
await asyncio.sleep(0)
c.charger._sleep = sleep
c.car_settle = settle
def _shut3(p, c, t):
w = [x for x in p.wlog if x[1] == "current" and x[2] > 0]
if w and "t" not in rec3:
rec3["t"] = t
rec3["co"] = shutdown_at(rec3)(p, c)
def _kick3(p, c):
return rec3.pop("co", None)
_s3 = SimCharger(setpoint_a=10)
_s3.lag_s = 3.0
r3s = S.drive(dur=140, sim=_s3, on_cycle=_shut3,
events={t: (_gate3 if t == 50 else _kick3)
for t in range(50, 140)},
**RUN10)
s3s = rec3.get("sets", [])
check(f"R3: shutdown while a start write waits for its read-back: the 0 A "
f"still goes out before the inverters' 0 W ({s3s[:3]}, setpoint at the "
f"end {r3s['sim'].setpoint_a})",
any(x[1] == S.SET and x[2] == 0.0 for x in s3s)
and s3s and s3s[0][1] == S.SET and r3s["sim"].setpoint_a == 0.0)
# Major: one excess, one cut, from a car well above 6 A that is slow to show
# it: a 700 W/s ramp (about 4 s), and also a 3 s read-back lag (about 7 s).
# Batteries at the cut-out, so the cut is at once. Later writes in the period
# are the spare rule (the step also takes the sun), not cuts.
for lag in (0.0, 3.0):
_s3c = SimCharger(setpoint_a=0)
_s3c.ramp_w_s = 700.0
r3c = S.drive(sim=_s3c, house=steps((0, 500.0), (910, 7900.0),
(970, 500.0)),
sun=const(13000.0), first="car", socs=CUTOUT, dur=1000,
opts={"slew_w": 0},
events={900: lambda p, c, lag=lag: setattr(p.ch, "lag_s",
lag)})
x3c = first_cut(r3c, 905)
w3c = [(t, v) for t, v in S.writes(r3c) if 905 <= t < 940]
want3c = (None if x3c is None else
math.floor((16 * 690.0 - x3c["cut"]) / 690.0 + 1e-9))
check(f"R3 cut, car 16 A on 3 phases, ramp 700 W/s, read-back lag "
f"{lag:.0f} s:"
f" one excess ({None if x3c is None else round(x3c['cut'])} W) "
f"takes one cut, to {want3c} A, and no more ({w3c})",
x3c is not None and len(w3c) == 1 and w3c[0][1] == want3c
and want3c >= 11)
# =========================================================================== #
print("\nROUND 4. NO HEADROOM, NO WAIT: N4 AGAINST A CAR-OFF TWIN")
# =========================================================================== #
# The review's repro: N=2 at 60 %, Car first, sun 13 kW, the car at 16 A on
# 3 phases; at t=905 the house steps to H and stays. The batteries give their
# full rating, the guard is saturated: the cut must not wait 15 s.
for H in (25900.0, 25950.0):
hh = steps((0, 500.0), (905, H))
r4 = S.drive(house=hh, sun=const(13000.0), first="car", socs=ABLE,
dur=1810)
r4o = S.drive(house=hh, sun=const(13000.0), first="car", socs=ABLE,
dur=1810, mode="off")
q4 = {q: g for q, g, _c in quarters(r4, 3400.0)}
q4o = {q: g for q, g, _c in quarters(r4o, 3400.0)}
cut4 = first_cut(r4, 905)
since4 = next((x["since"] for x in r4["trace"] if x["since"] is not None
and x["t"] >= 905), None)
check(f"R4/N4 house to {H:.0f} W at 905: the cut comes at once "
f"(wants from {since4}, cut at {None if cut4 is None else cut4['t']})"
f" and the period lands under the aim like the car-Off twin "
f"({round(q4.get(900, -1))} W vs {round(q4o.get(900, -1))} W, aim "
f"3400 W)",
cut4 is not None and since4 is not None
and cut4["t"] - since4 <= 1 and 900 in q4 and 900 in q4o
and q4[900] <= 3400.0 and q4o[900] <= 3400.0)
# =========================================================================== #
print("\nROUND 5. HEADROOM COUNTS ONLY BATTERIES THAT CAN GIVE; EACH CLAUSE DECIDES")
# =========================================================================== #
def headroom_at(store):
def f(p, c, t):
g = c.peak_guard
store[t] = (c._car_batt_headroom(g), c.site_batt_w,
None if g is None else (g.saturated, g.floor_limited))
return f
def since_cut(r, t0):
since = next((x["since"] for x in r["trace"] if x["since"] is not None
and x["t"] >= t0), None)
cut = first_cut(r, t0)
return since, (None if cut is None else cut["t"])
# R5a (review round 4 repro): A refuses to give from 850 (SAFETY-73), B gives
# its full 4600 W; the house steps to 8000 W at 905 and 20 950 W at 908. Only
# the full-rating clause, counted over the units that can give, decides: the
# guard is neither saturated (its rating still counts A) nor at the reserve.
def _refuse_a(p, c):
if not getattr(p, "_a_held", False):
p._a_held = True
orig = p.batt_of
p.batt_of = lambda u, at, _o=orig: (min(_o(u, at), 0.0) if u == "a"
else _o(u, at))
[i for i in c.inverters if i.name.endswith("a")][0].refused = 1
hh5 = steps((0, 500.0), (905, 8000.0), (908, 20950.0))
EV5 = {t: _refuse_a for t in range(850, 1810)}
hr5 = {}
r5a = S.drive(house=hh5, sun=const(13000.0), first="car", socs=ABLE,
dur=1810, opts={"slew_w": 0}, events=dict(EV5),
on_cycle=headroom_at(hr5))
r5ao = S.drive(house=hh5, sun=const(13000.0), first="car", socs=ABLE,
dur=1810, opts={"slew_w": 0}, events=dict(EV5), mode="off")
q5 = {q: g for q, g, _c in quarters(r5a, 3400.0)}
q5o = {q: g for q, g, _c in quarters(r5ao, 3400.0)}
s5, c5 = since_cut(r5a, 905)
# B can still raise its output for a few seconds after the first step; the
# moment it gives its full rating there is no headroom, and the cut must come
# then, not 15 s after the guard first wanted power.
nohead5 = next((t for t in sorted(hr5) if t >= 905 and not hr5[t][0]), None)
sat5 = None if nohead5 is None else hr5[nohead5][2]
check(f"R5a/N4 battery A refuses to give, B at its full 4600 W: headroom ends "
f"at {nohead5} (guard (saturated, floor-limited) {sat5}), the cut comes "
f"then, not 15 s after the guard first wanted power (wants from {s5}, "
f"cut at {c5}), and the period lands under the aim like the car-Off "
f"twin ({round(q5.get(900, -1))} W vs {round(q5o.get(900, -1))} W)",
s5 is not None and c5 is not None and nohead5 is not None
and c5 <= nohead5 + 1 and c5 - s5 < 15 and sat5 == (False, False)
and q5.get(900, 1e9) <= 3400.0 and q5o.get(900, 1e9) <= 3400.0)
# R5b: the wait itself. The batteries have headroom but answer slowly (20 s),
# so the guard wants power for more than 15 s: the cut comes at 15 s, not
# earlier and not never.
def _slow(p, c):
p.response_s = 20.0
hr5b = {}
r5b = S.drive(house=steps((0, 500.0), (910, 6000.0)), sun=const(2900.0),
first="car", socs=ABLE, dur=960, events={900: _slow},
on_cycle=headroom_at(hr5b))
s5b, c5b = since_cut(r5b, 905)
check(f"R5b: the batteries keep their headroom while the guard wants power "
f"(wants from {s5b}, headroom {[hr5b[t][0] for t in (912, 920, 925) if t in hr5b]}"
f"): the cut comes 15 s later, not sooner and not never (cut at {c5b})",
s5b is not None and c5b is not None and 15 <= c5b - s5b <= 16
and all(hr5b[t][0] for t in range(int(s5b), int(c5b)) if t in hr5b))
# R5c: the peak reserve alone decides: both batteries at 19 % (above their
# 10 % cut-out, under the 20 % peak reserve), the car at 6 A, the house to
# 9 kW. The guard is floor-limited, not saturated, and the batteries' output
# is still under their rating: the cut comes at once.
hr5c = {}
r5c = S.drive(house=steps((0, 500.0), (300, 9000.0)),
sun=steps((0, 2300.0), (180, 2000.0)), first="car",
socs={"a": 19.0, "b": 19.0}, dur=420,
on_cycle=headroom_at(hr5c))
s5c, c5c = since_cut(r5c, 290)
st5c = hr5c.get(c5c) if c5c is not None else None
check(f"R5c: floor-limited alone decides (guard (saturated, floor-limited) "
f"{None if st5c is None else st5c[2]}, batteries giving "
f"{None if st5c is None or st5c[1] is None else round(st5c[1])} W): the "
f"cut comes at once (wants from {s5c}, cut at {c5c})",
s5c is not None and c5c is not None and c5c - s5c <= 1
and st5c is not None and st5c[2] == (False, True)
and st5c[1] is not None and st5c[1] < 9600.0 - 100.0)
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")