Review of b4a222f, brief v6 Expected 11 (owner 2026-11-18):
- Solar keeps watching for another writer while it is not writing (Stop,
shadow, safety stop), so hold is true for every reader: the exit, the
shutdown, the peak alarms, and Start afterwards.
- car_solar_can_cut() also needs Solar to be writing: the peak alarms stand
as in Off and the quarter is banked.
- A start or restart in Solar with shadow on writes nothing (the
not-writing 0 A is owed only when Solar had the charger before).
- Once that exit 0 A is taken, nothing more is written, shutdown included.
Tests: alarm rows for Stop, shadow on and safety stop against an Off twin;
shutdown after another writer in shadow and Stop; a start in shadow with the
car already charging; Start after a stop; two variants inside the 30 s watch.
Co-Authored-By: Claude <noreply@anthropic.com>
2095 lines
93 KiB
Python
2095 lines
93 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("\nROUND 6. ONLY A CAR SOLAR CAN CUT IS GRADED OUT; REFUSALS AT EVERY N")
|
|
# =========================================================================== #
|
|
from app import peakguard as _pg # noqa: E402
|
|
from app import packmode as _pm # noqa: E402
|
|
from app.store import unit_key as _uk # noqa: E402
|
|
|
|
CUT10 = {"a": 10.0, "b": 10.0}
|
|
ALARMS6 = ("goodwe_peak_soc_floor", "goodwe_peak_saturated")
|
|
|
|
|
|
def first_alarm(r, t0):
|
|
return next((t for t, n in r["raised"] if n in ALARMS6 and t >= t0), None)
|
|
|
|
|
|
def solar_vs_off(events, house, label):
|
|
"""The review's p_silent shape: N=2 at their cut-out, ev_phases 3, sun
|
|
7 kW. Solar runs at 9 A on 3 phases; the twin is Off with the car at the
|
|
same 9 A (another writer's setting), so the load is the same."""
|
|
rs = S.drive(house=house, sun=const(7000.0), first="car", socs=CUT10,
|
|
dur=1810, opts={"ev_phases": "3", "slew_w": 0}, phases=3,
|
|
events=dict(events))
|
|
ro = S.drive(house=house, sun=const(7000.0), first="car", socs=CUT10,
|
|
dur=1810, opts={"ev_phases": "3", "slew_w": 0}, phases=3,
|
|
events=dict(events), mode="off", sim=SimCharger(setpoint_a=9))
|
|
a_s, a_o = first_alarm(rs, 900), first_alarm(ro, 900)
|
|
qs = {q: g for q, g, _c in quarters(rs, 3400.0)}
|
|
check(f"R6 {label}: Solar cannot cut the car, so the peak alarm stands as "
|
|
f"in Off (+2 s) ({a_s} vs {a_o}), the quarter over the aim "
|
|
f"({round(qs.get(900, -1))} W) is banked as the car's "
|
|
f"({sorted(rs['c'].car_peak_q)[:2]}), and no explaining "
|
|
f"({rs['c'].car_explains})",
|
|
a_o is not None and a_s is not None and abs(a_s - a_o) <= 2
|
|
and qs.get(900, 0) > 3400.0 and len(rs["c"].car_peak_q) >= 1
|
|
and not rs["c"].car_explains)
|
|
return rs, ro
|
|
|
|
|
|
def _other16(p, c):
|
|
p.ch.set_current(16)
|
|
|
|
|
|
def _refuse_err(p, c):
|
|
p.ch.refuse = "error"
|
|
|
|
|
|
def _fault_refused(p, c):
|
|
p.ch.error = "12: Socket fault"
|
|
p.ch.refuse = "error"
|
|
|
|
|
|
# 1. another writer holds the charger (review repro p_silent "other")
|
|
solar_vs_off({600: _other16}, steps((0, 500.0), (1000, 3000.0)),
|
|
"another writer sets 16 A")
|
|
# 2. a cut write the charger refuses, and 3. a charger fault whose 0 A is
|
|
# refused: the house goes to 6 kW, so the car must be cut and cannot be
|
|
solar_vs_off({990: _refuse_err}, steps((0, 500.0), (1000, 6000.0)),
|
|
"the cut write is refused")
|
|
solar_vs_off({990: _fault_refused}, steps((0, 500.0), (1000, 6000.0)),
|
|
"a charger fault whose 0 A is refused")
|
|
|
|
|
|
# N=1: the only battery refuses to give (SAFETY-52 keeps it in
|
|
# Controller.batt_refused), car 16 A on 1 phase; review repro p_n1, H 16380 W.
|
|
def _refuse_n1(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)
|
|
c.batt_refused = 1
|
|
if c.batt_refused_at is None:
|
|
c.batt_refused_at = p.t
|
|
|
|
|
|
hn1 = steps((0, 500.0), (905, 16380.0))
|
|
KW1 = dict(first="car", ratings={"a": 5000.0}, socs={"a": 60.0}, dur=1810,
|
|
opts={"slew_w": 0, "ev_phases": "1"},
|
|
events={t: _refuse_n1 for t in range(850, 1810)})
|
|
r6n = S.drive(hn1, const(13000.0), **KW1)
|
|
r6no = S.drive(hn1, const(13000.0), mode="off", **KW1)
|
|
q6n = {q: g for q, g, _c in quarters(r6n, 3400.0)}
|
|
q6no = {q: g for q, g, _c in quarters(r6no, 3400.0)}
|
|
s6n, c6n = since_cut(r6n, 905)
|
|
check(f"R6/N4 N=1, the only battery refuses to give: no headroom, the cut "
|
|
f"comes at once (wants from {s6n}, cut at {c6n}) and the period lands "
|
|
f"under the aim like the car-Off twin ({round(q6n.get(900, -1))} W vs "
|
|
f"{round(q6no.get(900, -1))} W)",
|
|
s6n is not None and c6n is not None and c6n - s6n <= 1
|
|
and q6n.get(900, 1e9) <= 3400.0 and q6no.get(900, 1e9) <= 3400.0)
|
|
|
|
|
|
# N10 on the way out: another writer holds the charger, then each exit.
|
|
def _err12(p, c):
|
|
p.ch.error = "12: Socket fault"
|
|
|
|
|
|
for name, trig, opts6 in (
|
|
("Stop", act("auto_toggle", None), {"shadow_mode": "off"}),
|
|
("shadow on", lambda p, c: c.o.__setitem__("shadow_mode", "on"), {}),
|
|
("safety stop", lambda p, c: setattr(c.circ_wd, "tripped", True), {}),
|
|
("Off", act("car_mode", "off"), {}),
|
|
("charger error", _err12, {})):
|
|
r6h = solar_exit(trig, at=700, dur=900, opts=opts6,
|
|
events={600: _other16})
|
|
held = r6h["c"].car_solar.hold
|
|
check(f"R6/N10 {name} while another writer holds the charger: nothing is "
|
|
f"written over it ({after(r6h, 600)}, hold {held}, setpoint "
|
|
f"{r6h['sim'].setpoint_a})",
|
|
after(r6h, 600) == [] and r6h["sim"].setpoint_a == 16.0)
|
|
|
|
|
|
for name, trig in (("Manual's current set", act("car_current", 12)),
|
|
("Manual's phases set", act("car_phases", 3))):
|
|
r6v = solar_exit(trig, at=700, dur=900, events={600: _other16})
|
|
check(f"R6/N10 {name} while Solar is held by another writer: Solar still "
|
|
f"writes nothing over it ({after(r6v, 600)}, hold "
|
|
f"{r6v['c'].car_solar.hold})",
|
|
after(r6v, 600) == [] and r6v["c"].car_solar.hold
|
|
and r6v["sim"].setpoint_a == 16.0)
|
|
|
|
|
|
# The guard's `able_w` caps the headroom: a real Controller after a run, two
|
|
# batteries above their cut-out giving 2500 W each (5000 W of 9600 W), and a
|
|
# guard that names able_w 4600 W (one battery held at the peak reserve, the
|
|
# guard not yet floor-limited). In a whole run the guard is floor-limited in
|
|
# that first cycle, so this clause is pinned on the method itself.
|
|
c6h = S.drive(house=const(500.0), sun=const(2900.0),
|
|
first="car", socs=ABLE, dur=5)["c"]
|
|
for _i in c6h.inverters:
|
|
_i.batt, _i.refused = 2500.0, 0
|
|
c6h.batt_refused = 0
|
|
g6 = _pg.PeakDecision(engaged=True, floor_w=3000.0, ceiling_w=3500.0,
|
|
ceiling_from="peak_cap_w", able_w=4600.0)
|
|
g6n = _pg.PeakDecision(engaged=True, floor_w=3000.0, ceiling_w=3500.0,
|
|
ceiling_from="peak_cap_w", able_w=None)
|
|
check(f"R6 able_w: 5000 W given of 9600 W is headroom "
|
|
f"({c6h._car_batt_headroom(g6n)}), but not when the guard can draw on "
|
|
f"4600 W only ({c6h._car_batt_headroom(g6)})",
|
|
c6h._car_batt_headroom(g6n) is True and c6h._car_batt_headroom(g6) is False)
|
|
|
|
|
|
# Batteries switched Off still count: the guard draws on them (round 4
|
|
# review). Both Off, a cloud edge the guard catches: no cut, no pause.
|
|
def _both_off(p, c):
|
|
for u in "ab":
|
|
c.store.data[_uk("inverter-" + u, _pm.USE_KEY)] = False
|
|
|
|
|
|
r6o = 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},
|
|
events={5: _both_off})
|
|
want6o = [x["t"] for x in r6o["trace"] if x["since"] is not None
|
|
and 905 <= x["t"] <= 960]
|
|
w6o = [(t, v) for t, v in cur(r6o) if 900 <= t < 1150]
|
|
check(f"R6 both batteries switched Off: the guard catches the cloud edge with "
|
|
f"them (wanted {len(want6o)} s), so no cut and no pause ({w6o})",
|
|
0 < len(want6o) < 15 and not first_cut(r6o, 900)
|
|
and 0.0 not in [v for _t, v in w6o])
|
|
# =========================================================================== #
|
|
print("\nROUND 7. NOT WRITING: SOLAR WATCHES, THE ALARMS STAND, NOTHING OVER OTHERS")
|
|
# =========================================================================== #
|
|
OUT7 = (("Stop (shadow_mode auto)", act("auto_toggle", None),
|
|
{"shadow_mode": "auto"}),
|
|
("shadow on", lambda p, c: c.o.__setitem__("shadow_mode", "on"), {}),
|
|
("safety stop", lambda p, c: setattr(c.circ_wd, "tripped", True), {}))
|
|
# 1. The review's p_out: Solar wrote its one 0 A at 500 s, another writer
|
|
# sets 16 A at 600 s, the house steps at 1000 s. As in Off: the alarm, the
|
|
# quarter banked, the car never explained away.
|
|
for name, trig, opts7 in OUT7:
|
|
o7 = dict({"ev_phases": "3", "slew_w": 0}, **opts7)
|
|
ev7 = {500: trig, 600: _other16}
|
|
r7 = S.drive(house=steps((0, 500.0), (1000, 3000.0)), sun=const(7000.0),
|
|
first="car", socs=CUT10, dur=1810, opts=o7, phases=3,
|
|
events=dict(ev7))
|
|
r7o = S.drive(house=steps((0, 500.0), (1000, 3000.0)), sun=const(7000.0),
|
|
first="car", socs=CUT10, dur=1810, opts=o7, phases=3,
|
|
events=dict(ev7), mode="off", sim=SimCharger(setpoint_a=9))
|
|
a7, a7o = first_alarm(r7, 900), first_alarm(r7o, 900)
|
|
ex7 = sum(1 for x in r7["trace"] if 900 <= x["t"] < 1800 and x["explains"])
|
|
q7 = {q: g for q, g, _c in quarters(r7, 3400.0)}
|
|
check(f"R7 {name}, then another writer at a peak: the alarm stands as in "
|
|
f"Off (+2 s) ({a7} vs {a7o}), the quarter ({round(q7.get(900, -1))} "
|
|
f"W) is banked ({len(r7['c'].car_peak_q)}), the car is never "
|
|
f"explained away ({ex7} cycles), and Solar writes nothing over the "
|
|
f"other writer ({after(r7, 600)})",
|
|
a7 is not None and a7o is not None and abs(a7 - a7o) <= 2
|
|
and q7.get(900, 0) > 3400.0 and len(r7["c"].car_peak_q) >= 1
|
|
and ex7 == 0 and after(r7, 600) == [])
|
|
|
|
|
|
# 2. Shutdown after the exit 0 A was taken, in shadow or Stop, with another
|
|
# writer at 16 A since 400 s: nothing is written (T53 (b), T28, N10).
|
|
def shut_rec7(rec):
|
|
async def f(p, c):
|
|
rec["n0"] = len(p.sets)
|
|
await c.shutdown()
|
|
rec["sets"] = [x for x in p.sets[rec["n0"]:] if x[1] == S.SET]
|
|
rec["sp"] = p.ch.setpoint_a
|
|
return f
|
|
|
|
|
|
for name, trig, opts7 in (
|
|
("shadow on", lambda p, c: c.o.__setitem__("shadow_mode", "on"), {}),
|
|
("Stop (shadow_mode auto)", act("auto_toggle", None),
|
|
{"shadow_mode": "auto"}),
|
|
("Stop (shadow_mode off)", act("auto_toggle", None),
|
|
{"shadow_mode": "off"})):
|
|
rec7 = {}
|
|
r7s = S.drive(house=const(500.0), sun=const(2900.0), first="car",
|
|
socs=FULL, dur=601, opts=opts7, events={
|
|
300: trig, 400: _other16, 600: shut_rec7(rec7)})
|
|
check(f"R7 {name}, another writer at 16 A, then shutdown: no write at "
|
|
f"shutdown ({rec7.get('sets')}), the charger stays at 16 A; the only "
|
|
f"0 A was the exit's ({after(r7s, 300)})",
|
|
rec7.get("sets") == [] and rec7.get("sp") == 16.0
|
|
and [v for _t, v in after(r7s, 300)] == [0.0])
|
|
# Inside the first 30 s, before the watch can call it another writer, each
|
|
# clause decides on its own: the alarm (Solar is not writing) and the
|
|
# shutdown (the exit 0 A was taken).
|
|
o7s = {"ev_phases": "3", "slew_w": 0, "shadow_mode": "auto"}
|
|
ev7s = {500: act("auto_toggle", None), 890: _other16}
|
|
r7e = S.drive(house=steps((0, 500.0), (895, 3000.0)), sun=const(7000.0),
|
|
first="car", socs=CUT10, dur=1810, opts=o7s, phases=3,
|
|
events=dict(ev7s))
|
|
r7eo = S.drive(house=steps((0, 500.0), (895, 3000.0)), sun=const(7000.0),
|
|
first="car", socs=CUT10, dur=1810, opts=o7s, phases=3,
|
|
events=dict(ev7s), mode="off", sim=SimCharger(setpoint_a=0))
|
|
a7e, a7eo = first_alarm(r7e, 895), first_alarm(r7eo, 895)
|
|
check(f"R7 Stop, another writer 10 s before the period (no hold yet): the "
|
|
f"alarm stands as in Off (+2 s) ({a7e} vs {a7eo})",
|
|
a7e is not None and a7eo is not None and abs(a7e - a7eo) <= 2)
|
|
rec7e = {}
|
|
r7f = S.drive(house=const(500.0), sun=const(2900.0), first="car", socs=FULL,
|
|
dur=601, opts={"shadow_mode": "on"},
|
|
events={300: lambda p, c: c.o.__setitem__("shadow_mode", "on"),
|
|
590: _other16, 600: shut_rec7(rec7e)})
|
|
check(f"R7 shadow on, another writer 10 s before the shutdown (no hold yet): "
|
|
f"no write at shutdown ({rec7e.get('sets')}), the charger stays at 16 A",
|
|
rec7e.get("sets") == [] and rec7e.get("sp") == 16.0)
|
|
# 3. Brief v6, Expected 11: a start in Solar with shadow on writes nothing,
|
|
# even with a car already charging under another writer.
|
|
for name, opts7, ev7 in (("shadow on", {"shadow_mode": "on"}, {}),
|
|
("shipped auto, control stopped",
|
|
{"shadow_mode": "auto"},
|
|
{0: lambda p, c: setattr(c, "auto", False)})):
|
|
r7t = S.drive(house=const(500.0), sun=const(2900.0), first="car",
|
|
socs=FULL, dur=300, setpoint=16, opts=opts7, events=ev7)
|
|
check(f"R7 start in Solar with {name}, the car charging at 16 A set by "
|
|
f"another writer: nothing is written ({cur(r7t)}), the charger stays "
|
|
f"at 16 A, the card says what it would set "
|
|
f"({r7t['c'].car_solar.would})",
|
|
cur(r7t) == [] and r7t["sim"].setpoint_a == 16.0
|
|
and r7t["c"].car_solar.would is not None)
|
|
# 4. The root: Solar keeps watching while it is not writing. Stop at 300 s
|
|
# (its 0 A), another writer sets 16 A at 400 s, Start at 600 s: Solar holds
|
|
# off, writes nothing over it, and shows the row.
|
|
st7 = {}
|
|
|
|
|
|
def _rows7(p, c, t):
|
|
if t == 620:
|
|
st7["rows"] = [x["id"] for x in c.checks()]
|
|
|
|
|
|
r7r = solar_exit(act("auto_toggle", None), dur=800,
|
|
opts={"shadow_mode": "off"},
|
|
events={400: _other16, 600: act("auto_toggle", None)},
|
|
on_cycle=_rows7)
|
|
check(f"R7 Start after a stop during which another writer took the charger: "
|
|
f"Solar holds off (writes after 400 s {after(r7r, 400)}, hold "
|
|
f"{r7r['c'].car_solar.hold}, row {'charger_other' in st7.get('rows', [])})",
|
|
after(r7r, 400) == [] and r7r["c"].car_solar.hold
|
|
and "charger_other" in st7.get("rows", [])
|
|
and r7r["sim"].setpoint_a == 16.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")
|