"""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): the cut # comes 15 s after the guard first wants power, not sooner. 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 cut in the first 15 s the " f"guard wants power, then the car is cut 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 15 <= x21["t"] - since21 <= 16 and w21 and w21[0][0] <= x21["t"] + 2 and w21[0][1] <= max(lim21, 0) and not [t for t, v in cur(r21) if 200 <= t < x21["t"] and v == 0.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: 0 A, no 5-min hold, after the 15 s " f"wait and not sooner ({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 15 <= x22["t"] - since22 <= 16 and w22 and w22[0][1] == 0.0 and w22[0][0] <= x22["t"] + 2 and not [t for t, v in cur(r22) if 200 <= t < x22["t"] and v == 0.0]) 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("\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")