Solar charges the car from the signed spare sun (car + battery charge - grid import), less the batteries' room (Batteries first) and the sun kept back, whole amps rounded down, at most one change per 30 s and only on 1 A. It starts after ev_start_min of enough sun, holds 6 A for ev_pause_min, then 0 A. Auto phases through EV-04's safe sequence (4.5 kW / 3 min up, 4.0 kW / 5 min down, one switch per 10 min). What the peak guard would ask the batteries for is taken off the car first, at once. Every way out of Solar ends at 0 A, written once; at shutdown before the inverters go to 0 W. - app/carmode.py: SolarPlan (pure) and SolarWriter (ManualWriter's one write site, its sequence and watch); spare_w, car_target_w, amps_for. - app/ctl_car.py: Solar inputs, the cut, the solar kWh, EV-15's grace for Solar's own 0 A, no "set by the car" for Solar; main.py: shutdown order. - Home card, HA select.goodwe_car_sun_first, sensor car_today_solar_kwh, three options with defaults, strings EN/NL, DOCS, DECISIONS, CHANGELOG. - test_ev05.py, test_ev05_long.py, tools/ev05_sun.py; test_ev03/ev04 checks that pinned "Solar is refused" / "three entities" updated. Co-Authored-By: Claude <noreply@anthropic.com>
422 lines
18 KiB
Python
422 lines
18 KiB
Python
"""EV-05: the car's Solar mode, the long runs. `python3 -B test_ev05_long.py`
|
|
|
|
Split from test_ev05.py so CI's parallel batch stays short: the shadow-mode
|
|
twin (T39), the acceptance day (T44), the fuzz (T45), and the hour-long
|
|
"nothing else changes" comparisons (T50, T51). Same harness,
|
|
`tools/ev05_sun.py`; the rows are named by their test-plan id.
|
|
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
|
"""
|
|
|
|
import logging
|
|
import math
|
|
import os
|
|
import random
|
|
import sys
|
|
|
|
HERE = os.path.dirname(os.path.abspath(__file__))
|
|
sys.path.insert(0, os.path.join(HERE, "tools"))
|
|
|
|
import ev05_sun as S # noqa: E402
|
|
from chargersim import SimCharger # noqa: E402
|
|
|
|
logging.disable(logging.CRITICAL)
|
|
fails = []
|
|
|
|
|
|
def check(name, cond):
|
|
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
|
if not cond:
|
|
fails.append(name)
|
|
|
|
|
|
def const(w):
|
|
return lambda t: float(w)
|
|
|
|
|
|
def steps(*pairs):
|
|
def f(t):
|
|
v = pairs[0][1]
|
|
for at, w in pairs:
|
|
if t >= at:
|
|
v = w
|
|
return float(v)
|
|
return f
|
|
|
|
|
|
def cur(r):
|
|
return S.writes(r, "current")
|
|
|
|
|
|
def ph(r):
|
|
return S.writes(r, "phases")
|
|
|
|
|
|
FULL = {"a": 100.0, "b": 100.0}
|
|
ABLE = {"a": 60.0, "b": 60.0}
|
|
|
|
|
|
def quarters(r, aim):
|
|
"""(start, import average, car average) of each whole quarter."""
|
|
out = []
|
|
tr = r["trace"]
|
|
for q0 in range(0, int(tr[-1]["t"]) + 1 - 900, 900):
|
|
xs = [x for x in tr if q0 <= x["t"] < q0 + 900]
|
|
if len(xs) < 890:
|
|
continue
|
|
g = sum(max(0.0, x["grid"]) for x in xs) / len(xs)
|
|
car = sum(x["car"] for x in xs) / len(xs)
|
|
out.append((q0, g, car))
|
|
return out
|
|
|
|
|
|
def seq_ok(r):
|
|
"""Every select: a 0 A write before it, the car under 100 W or out of C or
|
|
20 s after the 0 A, then 10 s or more to the next current; no other write
|
|
in between."""
|
|
log = r["sim"].log
|
|
state = {x["t"]: x["st"] for x in r["trace"]}
|
|
bad = []
|
|
for i, x in enumerate(log):
|
|
if x[1] != "phases":
|
|
continue
|
|
prev = log[i - 1] if i else None
|
|
nxt = log[i + 1] if i + 1 < len(log) else None
|
|
if prev is None or prev[1] != "current" or prev[2] != 0.0:
|
|
bad.append(("no 0 A before", x))
|
|
continue
|
|
quiet = (x[3] < 100.0 or state.get(x[0] - 1) != "C"
|
|
or x[0] - prev[0] >= 20.0)
|
|
if not quiet or x[4] != 0.0:
|
|
bad.append(("select under load", x))
|
|
if nxt is not None and (nxt[1] != "current" or nxt[0] - x[0] < 10.0):
|
|
bad.append(("current too soon or not next", x, nxt))
|
|
return bad
|
|
|
|
|
|
def inv_sets(r):
|
|
return [x for x in r["plant"].sets if x[1].startswith("number.sp_")]
|
|
|
|
|
|
# =========================================================================== #
|
|
print("\nT39. SHADOW MODE: NOTHING WRITTEN, THE CARD SAYS WHAT IT WOULD SET (N10)")
|
|
# =========================================================================== #
|
|
|
|
|
|
def cloudy(t):
|
|
k = int(t) // 240
|
|
return 900.0 + (2600.0 if k % 3 else 400.0) + 300.0 * (k % 5)
|
|
|
|
|
|
twin = S.drive(house=const(500.0), sun=cloudy, first="car", socs=FULL,
|
|
opts={"ev_phases": "1"}, dur=3600)
|
|
for name, kw in (("on", dict(opts={"ev_phases": "1", "shadow_mode": "on"})),
|
|
("auto, control stopped",
|
|
dict(opts={"ev_phases": "1", "shadow_mode": "auto"},
|
|
events={0: lambda p, c: setattr(c, "auto", False)}))):
|
|
sh = S.drive(house=const(500.0), sun=cloudy, first="car", socs=FULL,
|
|
dur=3600, **kw)
|
|
diff = [(a["t"], a["a"], (b["would"] or (None,))[0])
|
|
for a, b in zip(twin["trace"], sh["trace"])
|
|
if b["would"] is not None and a["a"] != b["would"][0]]
|
|
check(f"T39 shadow {name}: the charger log is empty for a cloudy hour, and "
|
|
f"every second the card's 'would set' is the current of a twin run "
|
|
f"without shadow mode ({len(diff)} seconds differ: {diff[:3]})",
|
|
sh["sim"].log == [] and not diff
|
|
and len({a['a'] for a in twin['trace']}) >= 3)
|
|
|
|
|
|
# =========================================================================== #
|
|
print("\nT50, T51. NOTHING ELSE CHANGES FOR THE GUARD AND THE ZERO-GRID LOOP")
|
|
# =========================================================================== #
|
|
h50 = steps((0, 400.0), (600, 2600.0), (900, 800.0), (1800, 4200.0),
|
|
(2100, 300.0), (3000, 1500.0))
|
|
r50 = S.drive(house=h50, sun=const(0.0), plug=False, dur=3600)
|
|
r50o = S.drive(house=h50, sun=const(0.0), plug=False, dur=3600,
|
|
opts={"ev_charger": "off"})
|
|
|
|
|
|
check(f"T50: Solar with no car for an hour: the guard's floor and every battery "
|
|
f"command are identical to the run with no charger "
|
|
f"({len(inv_sets(r50))} commands)", inv_sets(r50) == inv_sets(r50o)
|
|
and [x["floor"] for x in r50["trace"]]
|
|
== [x["floor"] for x in r50o["trace"]] and cur(r50) == [])
|
|
sun51 = steps((0, 3000.0), (700, 5200.0), (1500, 2500.0))
|
|
r51 = S.drive(house=const(400.0), sun=sun51, first="car", socs=ABLE,
|
|
dur=2000)
|
|
carp = {int(x["t"]): x["car"] for x in r51["trace"]}
|
|
r51o = S.drive(house=lambda t: 400.0 + carp.get(math.ceil(t), 0.0),
|
|
sun=sun51, socs=ABLE, dur=2000, opts={"ev_charger": "off"})
|
|
check(f"T51: Car first, the zero-grid loop: the same meter series with the car "
|
|
f"as a Solar car and as house load gives the same battery commands "
|
|
f"({len(inv_sets(r51))} commands)", inv_sets(r51) == inv_sets(r51o)
|
|
and max(carp.values()) > 3000)
|
|
check("T51: the batteries charge with what the car leaves (Car first)",
|
|
-300 <= r51["plant"].batt(1999) <= 0)
|
|
# =========================================================================== #
|
|
print("\nT44. THE ACCEPTANCE DAY: 08:00-18:00, CLOUDS, HOUSE STEPS (A2)")
|
|
# =========================================================================== #
|
|
_rnd44 = random.Random(44)
|
|
CLOUDS44 = []
|
|
for _i in range(12):
|
|
a = _rnd44.randint(600, 34000)
|
|
CLOUDS44.append((a, a + _rnd44.randint(60, 480)))
|
|
STEPS44 = [(8000, 8300), (17000, 17300), (26000, 26300)]
|
|
|
|
|
|
def sun44(t):
|
|
base = max(0.0, 7500.0 * math.sin(math.pi * t / 36000.0))
|
|
return base * (0.15 if any(a <= t < b for a, b in CLOUDS44) else 1.0)
|
|
|
|
|
|
def house44(t):
|
|
w = 1450.0 + 1050.0 * math.sin(t / 1700.0)
|
|
return w + (3000.0 if any(a <= t < b for a, b in STEPS44) else 0.0)
|
|
|
|
|
|
long44 = sum(1 for a, b in CLOUDS44 if b - a > 300)
|
|
for first, race in (("batteries", False), ("car", True)):
|
|
# The batteries' levels move with their charge (A 15.36 kWh, B 20.48 kWh),
|
|
# so with Batteries first the car gets sun once they are full.
|
|
r44 = S.drive(house=house44, sun=sun44, first=first, socs={"a": 40.0,
|
|
"b": 60.0},
|
|
caps={"a": 15.36, "b": 20.48}, dur=36000, race=race)
|
|
# On the harness clock, as the trace (the model's own clock runs ahead).
|
|
w44 = [(x[0], x[2]) for x in r44["plant"].wlog if x[1] == "current"]
|
|
p44 = [(x[0], x[2]) for x in r44["plant"].wlog if x[1] == "phases"]
|
|
# A phase change's own 0 A (a select follows within 25 s) is not a pause.
|
|
seq0 = {t for t, v in w44 if v == 0.0 and any(0 < pt - t <= 25
|
|
for pt, _n in p44)}
|
|
starts, pauses, paused, pause_t = 0, 0, True, []
|
|
for t, v in w44:
|
|
if v == 0.0 and t not in seq0:
|
|
paused = True
|
|
pauses += 1
|
|
pause_t.append(t)
|
|
elif v > 0 and paused:
|
|
starts += 1
|
|
paused = False
|
|
why_at = {x["t"]: x["why"] for x in r44["trace"]}
|
|
cut_t = [t for t in pause_t if why_at.get(t) == "cut"
|
|
or why_at.get(t - 1) == "cut"]
|
|
# Car first: no hold pause from a cloud under 300 s. Batteries first: a
|
|
# battery that gave power in the cloud is under 100 % again, so its
|
|
# rating is room and the car waits for it (the brief's room rule).
|
|
short_hit = [t for t in pause_t if t not in cut_t and first == "car"
|
|
and any(a <= t <= b + 2 for a, b in CLOUDS44 if b - a <= 300)]
|
|
print(f" pauses (second, why): {[(t, why_at.get(t)) for t in pause_t]}")
|
|
# N5 on the whole day: a start 120 s or more after its pause, a hold
|
|
# pause after 300 s of holding, non-zero writes 30 s apart.
|
|
nz = [t for t, v in w44 if v > 0]
|
|
n5 = [("30 s", b) for a, b in zip(nz, nz[1:]) if b - a < 30]
|
|
last_p = None
|
|
for t, v in w44:
|
|
if v == 0.0 and t not in seq0:
|
|
last_p = t
|
|
elif v > 0 and last_p is not None:
|
|
if t - last_p < 120:
|
|
n5.append(("start", t))
|
|
last_p = None
|
|
for t in pause_t:
|
|
if why_at.get(t) == "paused":
|
|
run = 0
|
|
while why_at.get(t - 1 - run) == "hold":
|
|
run += 1
|
|
if run < 298:
|
|
n5.append(("pause", t, run))
|
|
# The loop turns at most `slew_w` per cycle, so for some 15 s after each
|
|
# current step, cloud edge and house step the grid covers the change:
|
|
# counted apart (dev report). The rest is the car on grid power while
|
|
# the loop is settled, outside the holds.
|
|
edges = [t for t, v in w44] + [e for ab in CLOUDS44 + STEPS44 for e in ab]
|
|
edges.sort()
|
|
|
|
def settling(t):
|
|
return any(0 <= t - e < 15 for e in edges)
|
|
grid_wh = sum(min(x["car"], max(0.0, x["grid"])) for x in r44["trace"]
|
|
if x["why"] not in ("hold",) and not settling(x["t"])) / 3600.0
|
|
slew_wh = sum(min(x["car"], max(0.0, x["grid"])) for x in r44["trace"]
|
|
if settling(x["t"])) / 3600.0
|
|
steps44 = edges
|
|
over44 = [(q, round(g)) for q, g, car in quarters(r44, 3400.0)
|
|
if g > 3410.0 and g - car <= 3410.0]
|
|
gaps = [b[0] - a[0] for a, b in zip(p44, p44[1:])]
|
|
check(f"T44 {first} first ({'race' if race else 'step'}): starts {starts} "
|
|
f"(<= 1 + {long44} long clouds + {len(cut_t)} peak cuts, Car first)"
|
|
f"; pauses {pauses}; N5 dwells {n5[:3]}; selects {len(p44)} "
|
|
f"(gaps >= 600 s: {gaps[:4]}); no pause from a short cloud "
|
|
f"{short_hit[:3]}; the car's grid energy outside holds {grid_wh:.1f} "
|
|
f"Wh (and {slew_wh:.1f} Wh in the loop's 15 s after "
|
|
f"{len(steps44)} steps and edges); quarters over the aim by the car "
|
|
f"{over44}",
|
|
starts >= 1 and not n5 and all(g >= 600 for g in gaps)
|
|
and (first != "car" or starts <= 1 + long44 + len(cut_t))
|
|
and not seq_ok(r44) and not short_hit and grid_wh <= 10.0
|
|
and not over44)
|
|
|
|
# =========================================================================== #
|
|
print("\nT45. THE FUZZ: 14 SITES, 16800 STEPS (N1-N10)")
|
|
# The plan asks 14 x 400 steps; a busy site rarely has the 60 s calm a start
|
|
# needs, so each site runs 1200 steps to make enough writes to judge.
|
|
# =========================================================================== #
|
|
|
|
|
|
def fuzz(seed):
|
|
rnd = random.Random(seed)
|
|
stations = [10.0, 13.0, 16.0]
|
|
st = {"sun": rnd.uniform(0, 9000), "house": rnd.uniform(200, 3000),
|
|
"n": {}, "acts": [], "undo": [], "exits": []}
|
|
|
|
def exit_check(p, c):
|
|
"""N9: Solar to Off with the charger above 0 A, reachable, taking
|
|
writes and not held by another writer: a 0 A must follow."""
|
|
ch = p.ch
|
|
if c.car_mode == "solar" and not c.car_solar.hold \
|
|
and not ch.unavailable and ch.refuse is None \
|
|
and ch.readback_a > 0.5 and not p.ha_down:
|
|
st["exits"].append(p.t)
|
|
|
|
def later(p, fn):
|
|
st["undo"].append((p.t + rnd.randint(10, 40), fn))
|
|
|
|
def ev(p, c):
|
|
for due in [u for u in st["undo"] if u[0] <= p.t]:
|
|
st["undo"].remove(due)
|
|
due[1]()
|
|
if st.get("back") is not None and p.t >= st["back"]:
|
|
st["back"] = None # the user goes back to Solar
|
|
st["acts"].append(p.t)
|
|
return c.handle_action("car_mode", value="solar")
|
|
if st.get("press") is not None and p.t >= st["press"]:
|
|
st["press"] = None # the user presses the mode
|
|
st["acts"].append(p.t)
|
|
return c.handle_action("car_mode", value=c.car_mode)
|
|
r = rnd.random()
|
|
ch = p.ch
|
|
if r < 0.012:
|
|
st["sun"] = rnd.choice([0.0, 1000.0, 2500.0, 5000.0, 8000.0,
|
|
8000.0, 6500.0])
|
|
elif r < 0.02:
|
|
st["house"] = rnd.uniform(200, 4000)
|
|
elif r < 0.08:
|
|
st["sun"] = max(0.0, st["sun"] + rnd.uniform(-600, 600))
|
|
elif r < 0.082:
|
|
if ch.state != "A":
|
|
ch.unplug()
|
|
later(p, ch.plug_in)
|
|
st["n"]["plug"] = st["n"].get("plug", 0) + 1
|
|
elif r < 0.084:
|
|
ch.go_unavailable(True)
|
|
later(p, lambda: ch.go_unavailable(False))
|
|
st["n"]["down"] = st["n"].get("down", 0) + 1
|
|
elif r < 0.087:
|
|
ch.set_current(rnd.randint(0, 16))
|
|
st["n"]["other"] = st["n"].get("other", 0) + 1
|
|
st["press"] = p.t + rnd.randint(20, 90)
|
|
elif r < 0.089:
|
|
ch.refuse = rnd.choice(["ignore", "error"])
|
|
later(p, lambda: setattr(ch, "refuse", None))
|
|
elif r < 0.091:
|
|
p.meter_on = False
|
|
later(p, lambda: setattr(p, "meter_on", True))
|
|
st["n"]["meter"] = st["n"].get("meter", 0) + 1
|
|
elif r < 0.093:
|
|
c.o["shadow_mode"] = "on"
|
|
later(p, lambda: c.o.__setitem__("shadow_mode", "off"))
|
|
st["n"]["shadow"] = st["n"].get("shadow", 0) + 1
|
|
elif r < 0.095:
|
|
c.auto = False
|
|
later(p, lambda: setattr(c, "auto", True))
|
|
st["n"]["stop"] = st["n"].get("stop", 0) + 1
|
|
elif r < 0.098:
|
|
m = rnd.choice(["solar", "solar", "solar", "off", "manual"])
|
|
st["n"]["mode"] = st["n"].get("mode", 0) + 1
|
|
st["acts"].append(p.t)
|
|
if m == "off":
|
|
exit_check(p, c)
|
|
return c.handle_action("car_mode", value=m)
|
|
elif r < 0.1:
|
|
ch.station_a = rnd.choice(stations)
|
|
elif r < 0.103 and c.car_mode == "solar" and p.ch.readback_a > 0.5 \
|
|
and st.get("back") is None:
|
|
exit_check(p, c) # leave Solar while it charges
|
|
st["acts"].append(p.t)
|
|
st["back"] = p.t + rnd.randint(30, 120)
|
|
return c.handle_action("car_mode", value="off")
|
|
elif r < 0.2 and c.car_solar.seq is not None:
|
|
st["n"]["mid"] = st["n"].get("mid", 0) + 1
|
|
exit_check(p, c)
|
|
return c.handle_action("car_mode", value="off")
|
|
ctx = []
|
|
|
|
def note(p, c, t):
|
|
ctx.append((t, c.car_mode, c.car_writing(), c.car_solar.single,
|
|
c.car_solar.hold, p.ch.station_a))
|
|
r = S.drive(house=lambda t: st["house"], sun=lambda t: st["sun"],
|
|
first="car", opts={"ev_margin_w": 0, "ev_start_min": 1,
|
|
"ev_pause_min": 1}, socs=FULL, dur=1200,
|
|
events={t: ev for t in range(1, 1200)}, on_cycle=note,
|
|
race=seed % 2 == 1, sim=SimCharger(setpoint_a=rnd.choice(
|
|
[0, 10, 16])))
|
|
bad = []
|
|
by_t = {x[0]: x for x in ctx}
|
|
log = r["plant"].wlog # on the harness clock
|
|
last_sel, last_nz = None, None
|
|
for t, what, v, power, sp in log:
|
|
# A write logged at second t comes after that second's actions.
|
|
x = by_t.get(t) or by_t.get(t - 1)
|
|
mode = x[1] if x else "?"
|
|
if what == "current" and v > min(16.0, x[5] if x else 16.0) + 1e-9:
|
|
bad.append(("N1 over the clamp", t, v))
|
|
if what == "phases":
|
|
if sp != 0.0:
|
|
bad.append(("N2 select with the setpoint up", t))
|
|
if last_sel is not None and t - last_sel < 600:
|
|
bad.append(("N2 two selects in 600 s", t))
|
|
last_sel = t
|
|
if what == "current" and mode == "off" and v > 0:
|
|
bad.append(("N10 a non-zero write in Off", t, v))
|
|
if what == "current" and x is not None and not x[2] and v > 0 \
|
|
and mode == "solar":
|
|
bad.append(("N10 a non-zero Solar write while not writing", t, v))
|
|
if what == "current" and v > 0 and mode == "solar":
|
|
near_act = any(abs(t - a) <= 3 for a in st["acts"])
|
|
if last_nz is not None and t - last_nz < 30 and not near_act:
|
|
bad.append(("N5 two non-zero writes under 30 s", t, v))
|
|
last_nz = t
|
|
for te in st["exits"]:
|
|
if not any(x[1] == "current" and x[2] == 0.0 and te <= x[0] <= te + 3
|
|
for x in log):
|
|
bad.append(("N9 Solar to Off left the current up", te))
|
|
if r["c"].charger.clamp_faults:
|
|
bad.append(("N1 clamp fault", r["c"].charger.clamp_faults))
|
|
st["n"]["exits"] = len(st["exits"])
|
|
return bad, len(log), st["n"]
|
|
|
|
|
|
fz_bad, fz_n, fz_counts = [], 0, {}
|
|
for _seed in range(14):
|
|
_b, _n, _c = fuzz(_seed)
|
|
fz_bad += _b
|
|
fz_n += _n
|
|
for k, v in _c.items():
|
|
fz_counts[k] = fz_counts.get(k, 0) + v
|
|
check(f"T45: {fz_n} charger writes over 14 random Solar sites and 16800 steps "
|
|
f"(outages, unplugs, refusals, other writers, a silent meter, shadow and "
|
|
f"Stop, mode changes, half racing): none over the clamp, no select with "
|
|
f"the setpoint up or two in 600 s, every Solar to Off at 0 A (N9), no "
|
|
f"non-zero write in Off, in shadow "
|
|
f"or stopped, none under 30 s apart ({fz_bad[:3]})",
|
|
not fz_bad and fz_n > 100)
|
|
check(f"T45: each disturbance happened ({fz_counts})",
|
|
all(fz_counts.get(k, 0) > 2 for k in ("plug", "down", "other", "meter",
|
|
"shadow", "stop", "mode",
|
|
"exits")))
|
|
|
|
print()
|
|
if fails:
|
|
print(f"{len(fails)} FAILED")
|
|
for f in fails:
|
|
print(" -", f)
|
|
sys.exit(1)
|
|
print("all passed")
|