Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
83f114fe08 | ||
|
|
4eba2d9acf | ||
|
|
af374026b1 | ||
|
|
00b116e5b2 | ||
|
|
91cbdf2f43 | ||
|
|
c707eb4776 | ||
|
|
b662d7171b | ||
|
|
3b1189cdbf | ||
|
|
8150608317 | ||
|
|
77684ecfad | ||
|
|
c2bb32ec93 | ||
|
|
4950a2374f | ||
|
|
43b0db73d2 |
+1
-1
@@ -1,2 +1,2 @@
|
||||
# The admin/goodwe commit CI tests against. Bump: set to the full SHA of admin/goodwe release/1.0 HEAD (README.md, "CI and the infra pin").
|
||||
3b4ff84757f9c2c5b63a4b4a53e593ccaeafb847
|
||||
f88461234f3a7d53c025a68beda4cb6e4384cebf
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
|
||||
### Not in a release yet
|
||||
|
||||
- The add-on no longer changes the car's phases while the car still draws: it waits until the charger reads under 100 W, and if the car is still drawing after 20 s it gives the current back and tries again after 10 minutes ([[EV-28]]).
|
||||
- When the add-on changes the car's phases while the batteries are at the peak reserve, there is no longer a false "Battery stopped limiting the peak" for a moment ([[EV-15]]).
|
||||
|
||||
## 0.24.0
|
||||
|
||||
@@ -30,9 +30,11 @@ code had to decide that the design left open.
|
||||
|
||||
## The phase sequence
|
||||
|
||||
0 A, wait until the charger reports under 100 W or mode3 leaves C (20 s at most),
|
||||
select the phases, wait 10 s, write the current. One switch per 10 minutes. A
|
||||
charger that does not take the 0 A never gets the phases select. A sequence that
|
||||
0 A, wait until the charger reports under 100 W (mode3 leaving C counts only
|
||||
when there is no power reading; 20 s at most), select the phases, wait 10 s, write the current. One switch per 10 minutes. A
|
||||
charger that does not take the 0 A never gets the phases select. A car still
|
||||
drawing after 20 s gets no select: its current comes back and it counts as a
|
||||
failed try (EV-28). A sequence that
|
||||
has begun is finished whatever the mode, because it leaves the car at 0 A
|
||||
otherwise; a stop of the add-on in the middle gives the car its current back
|
||||
(`car_shutdown`).
|
||||
@@ -152,6 +154,17 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
|
||||
whole window and fell short; an unknown reading is no contradiction) grades
|
||||
no alarm to the quarter's end; the guard's input keeps it. After a restart
|
||||
or a gap the car's earlier energy is not known, so it counts as house.
|
||||
- **A battery rise the meter has not shown is not house yet** (EV-19, EV-15
|
||||
rig F-B). At the reserve inverter-b goes on following the house, so its
|
||||
output rises; the reading shows it one cycle before P1 does, and the house
|
||||
figure (meter + battery) counted that power as house. `_car_need_house`
|
||||
latched and the alarm stood. Now, while the meter's house side (held - car)
|
||||
moved no more than `RISE_STILL_W` since the last cycle, a reading above both
|
||||
earlier ones counts only up to the higher of them. A meter that moved shows
|
||||
the rise (an honest step with a battery burst alarms at once, as before). A
|
||||
rise the meter does not move with at all is graded as F-B: the one case the
|
||||
readings cannot tell apart. The credit stays the lower of the last two
|
||||
readings; `_car_over_now` is unchanged.
|
||||
- **Our own write is ours until its mute ends** (EV-12). The mute of the tracker's
|
||||
own detector opens before the write and runs 15 s from when it returns, because
|
||||
the read-back reaches the cycle while the write still waits for it.
|
||||
|
||||
@@ -15,8 +15,9 @@ THE RULES, each tested in test_ev04.py:
|
||||
reports, the entity's own range)`. The driver refuses anything above it; this
|
||||
module never asks for more.
|
||||
* Phases change only through the SAFE SEQUENCE: 0 A, wait until the charger
|
||||
reports under `QUIET_W` or mode3 leaves C (at most `ZERO_WAIT_S`), select the
|
||||
phases, wait `SETTLE_S`, write the current again. At most one switch per
|
||||
reports under `QUIET_W` (mode3 leaving C only without a power reading; at
|
||||
most `ZERO_WAIT_S`, then the current comes back and it counts as a failed
|
||||
try), select the phases, wait `SETTLE_S`, write the current again. At most one switch per
|
||||
`PHASE_GAP_S`. A sequence that has begun is always finished, because it
|
||||
leaves the car at 0 A otherwise.
|
||||
* A read-back that differs from the add-on's own last write for `WRITER_S` is
|
||||
@@ -333,11 +334,29 @@ class ManualWriter:
|
||||
"phase change, so the phases were not touched.")
|
||||
return
|
||||
if q["stage"] == "zero":
|
||||
quiet = ((r.power_w is not None and r.power_w < QUIET_W)
|
||||
or (r.state is not None and r.state != "C"))
|
||||
if not quiet and now - q["t0"] < ZERO_WAIT_S:
|
||||
return
|
||||
q["stage"] = "select"
|
||||
# A power reading decides; only without one does mode3 (not C,
|
||||
# not D) say the car is quiet. Still drawing at the timeout: no
|
||||
# select, the current comes back (EV-28).
|
||||
if r.power_w is not None:
|
||||
quiet = r.power_w < QUIET_W
|
||||
else:
|
||||
quiet = r.state is not None and r.state not in ("C", "D")
|
||||
if not quiet:
|
||||
if now - q["t0"] < ZERO_WAIT_S:
|
||||
return
|
||||
self.last_switch = now
|
||||
self.phase_fails += 1
|
||||
q["failed"] = True # EV-15: no grace for the alarm
|
||||
q["stage"], q["t1"] = "settle", now - SETTLE_S # restore now
|
||||
_LOG.warning("The car kept drawing, so the phases were not "
|
||||
"changed.")
|
||||
if self.phase_fails >= MAX_TRIES:
|
||||
self.phases_gave_up = True
|
||||
_LOG.warning("The charger did not take the phases, so the "
|
||||
"add-on stops trying until you change "
|
||||
"something: CHARGER_PHASES.")
|
||||
else:
|
||||
q["stage"] = "select"
|
||||
if q["stage"] == "select":
|
||||
ok = await drv.write_phases(q["n"])
|
||||
self._stamp(now)
|
||||
|
||||
@@ -31,6 +31,9 @@ OVER_OFF_HOLD_S = 180.0
|
||||
OWN_PAUSE_MAX_S = (carmode.ZERO_WAIT_S + carmode.SETTLE_S
|
||||
+ carmode.MAX_TRIES * 15.0 + 10.0)
|
||||
OWN_PAUSE_TAIL_S = chargers.CORR_WINDOW_S
|
||||
# EV-19: the meter's house side (held - car) moved no more than this since the
|
||||
# last cycle: it has not shown a battery rise the reading already shows.
|
||||
RISE_STILL_W = 50.0
|
||||
|
||||
|
||||
class CarMixin:
|
||||
@@ -58,7 +61,10 @@ class CarMixin:
|
||||
self.car_over = False # ... held: the card and row say so
|
||||
self._car_over_since = None
|
||||
self._car_over_gone = None
|
||||
self._car_batt_prev = None
|
||||
self._car_why_rec = None # EV-16: [shown over, since, episode]
|
||||
self._car_over_ep = 0 # EV-16: bumped when car_over ends
|
||||
self._car_batt_prev = self._car_batt_prev2 = None
|
||||
self._car_hx_prev = None # EV-19: last cycle's (held, car W)
|
||||
self._car_need_real = self._car_need_excl = False # EV-10 latches
|
||||
self._car_need_house = self._car_over_now = False # EV-18 latches
|
||||
self._car_latch_block = None
|
||||
@@ -394,7 +400,34 @@ class CarMixin:
|
||||
self._car_over_gone = mono
|
||||
if mono - self._car_over_gone >= OVER_OFF_HOLD_S:
|
||||
self.car_over, self._car_over_since = False, None
|
||||
self._car_over_ep += 1 # EV-16: an episode ends
|
||||
self._car_over_gone = None
|
||||
self._car_why_tick(guard, mono)
|
||||
|
||||
def _car_why_tick(self, guard, mono) -> None:
|
||||
"""EV-16, display only: control writes `_car_why_rec`, never reads it.
|
||||
The Car Why text ("are at" / "give all they can") is held: it changes
|
||||
only when the other state has stood for `OVER_OFF_HOLD_S` of THIS
|
||||
cycle's clock (so reads of /status do not matter). State: floor-limited
|
||||
with the SoC read; a guard of None, or unread SoC, never counts as
|
||||
floor. Cleared when car_over is off or the cover is off."""
|
||||
if not (self.car_over and self.car_cover):
|
||||
self._car_why_rec = None
|
||||
return
|
||||
cand = None if guard is None else bool(
|
||||
getattr(guard, "floor_limited", False)
|
||||
and getattr(guard, "soc", None) is not None)
|
||||
ep = self._car_over_ep
|
||||
r = self._car_why_rec
|
||||
if r is None or r[2] != ep:
|
||||
self._car_why_rec = [bool(cand), None, ep]
|
||||
elif cand is None or cand == r[0]:
|
||||
r[1] = None
|
||||
else:
|
||||
if r[1] is None:
|
||||
r[1] = mono
|
||||
if mono - r[1] >= OVER_OFF_HOLD_S:
|
||||
self._car_why_rec = [cand, None, ep]
|
||||
|
||||
def _car_explains_alarm(self, real_proj, guard, target_w, w) -> bool:
|
||||
"""EV-10: is the alarm's own test true with the car and false without
|
||||
@@ -414,6 +447,7 @@ class CarMixin:
|
||||
when the guard no longer wants power, whatever the cover option says
|
||||
(this runs every cycle). DECISIONS/EV-04-manual-mode.md (EV-18)."""
|
||||
now, prev = self.site_batt_w, self._car_batt_prev
|
||||
prev2, self._car_batt_prev2 = self._car_batt_prev2, prev
|
||||
self._car_batt_prev = now
|
||||
wants = bool(guard is not None and guard.engaged
|
||||
and guard.blind is None
|
||||
@@ -426,6 +460,23 @@ class CarMixin:
|
||||
if batt is not None and prev is not None:
|
||||
batt = min(float(batt), float(prev))
|
||||
excl = self.car_exclude_alarm(real_proj, w)
|
||||
# EV-19: the reading can show a rise one cycle before the meter does
|
||||
# (the batteries pick up the house at the reserve). While the meter's
|
||||
# house side (held - car; held alone when a car figure is unknown) has
|
||||
# not moved, a reading above both earlier ones is not yet counted as
|
||||
# house; a meter that moved shows it (no discount).
|
||||
held = float(real_proj.held_w)
|
||||
hp, self._car_hx_prev = self._car_hx_prev, (held, w)
|
||||
still = False
|
||||
if hp is not None:
|
||||
moved = held - hp[0]
|
||||
if w is not None and hp[1] is not None:
|
||||
moved -= float(w) - float(hp[1])
|
||||
still = abs(moved) <= RISE_STILL_W
|
||||
seen = now
|
||||
if still and now is not None and prev is not None \
|
||||
and prev2 is not None:
|
||||
seen = min(float(now), max(float(prev), float(prev2)))
|
||||
if wants and batt is not None:
|
||||
self._car_need_real = self._car_need_real or \
|
||||
peakguard.misses_aim(real_proj, batt_w=batt,
|
||||
@@ -436,7 +487,7 @@ class CarMixin:
|
||||
self._car_need_excl = self._car_need_excl or \
|
||||
peakguard.misses_aim(excl, batt_w=batt, target_w=target_w)
|
||||
self._car_need_house = self._car_need_house or \
|
||||
self._car_lands_over(excl, now, batt, target_w)
|
||||
self._car_lands_over(excl, seen, batt, target_w)
|
||||
if w is None or batt is None or not wants \
|
||||
or not (guard.saturated or guard.floor_limited):
|
||||
return False
|
||||
@@ -475,6 +526,7 @@ class CarMixin:
|
||||
# The session is over: that is a real end, with no hold.
|
||||
self.car_over = False
|
||||
self._car_over_since = self._car_over_gone = None
|
||||
self._car_over_ep += 1 # EV-16: an episode ends
|
||||
if s not in (chargers.NONE_, None) and self._car_prev_state in (
|
||||
chargers.NONE_, None):
|
||||
self._car_session += 1
|
||||
|
||||
@@ -1301,6 +1301,23 @@ def _car_why(key, c, good):
|
||||
return _t("car.why." + (key if key else "wait"))
|
||||
|
||||
|
||||
# EV-16: the Why of "car over the limit" follows the guard's floor flag, which
|
||||
# toggles cycle by cycle at the reserve. The text is held, on the control
|
||||
# cycle's clock (`ctl_car.CarMixin._car_why_tick`, display only: control writes
|
||||
# `_car_why_rec`, never reads it). The Why only reads it.
|
||||
WHY_HOLD_S = 180.0 # = ctl_car.OVER_OFF_HOLD_S (tested)
|
||||
|
||||
|
||||
def _over_why_is_floor(c, pg) -> bool:
|
||||
"""True: "are at {pct}"; False: "give all they can". With no valid held
|
||||
record (not yet ticked, or of an ended episode) the live state, written
|
||||
nowhere."""
|
||||
rec = getattr(c, "_car_why_rec", None)
|
||||
if rec is not None and rec[2] == getattr(c, "_car_over_ep", 0):
|
||||
return rec[0]
|
||||
return bool(pg is not None and pg.floor_limited and pg.soc is not None)
|
||||
|
||||
|
||||
def _car_manual_why(c, key):
|
||||
"""The Why of Manual: what you set, and what the peak limit does about it.
|
||||
Plan lines: two sentences of at most 12 words."""
|
||||
@@ -1312,7 +1329,7 @@ def _car_manual_why(c, key):
|
||||
pg = getattr(c, "peak_guard", None)
|
||||
if not c.car_cover:
|
||||
return _t("car.why.manual_nocover", a=a)
|
||||
return _t("car.why.manual_over" if pg is not None and pg.floor_limited
|
||||
return _t("car.why.manual_over" if _over_why_is_floor(c, pg)
|
||||
else "car.why.manual_full", a=a, pct=pct)
|
||||
if c.shadow:
|
||||
t, n = w.would if w.would is not None else (c.car_a, c.car_n)
|
||||
|
||||
@@ -613,10 +613,15 @@ async def slow_stop():
|
||||
|
||||
w5s, n05s = run(slow_stop())
|
||||
seq5s = w5s.writes()[n05s:]
|
||||
check("a car that is slow to stop: the phases are selected after 20 s at most "
|
||||
f"({seq5s[1][0] - seq5s[0][0]:.0f} s after the 0 A)",
|
||||
[x[1] for x in seq5s][:2] == ["current", "phases"]
|
||||
and 19.0 <= seq5s[1][0] - seq5s[0][0] <= 22.0)
|
||||
# EV-28: a car still drawing at 20 s gets no select; the current comes back
|
||||
rest5s = [x for x in seq5s if x[1] == "current" and x[2] == 10.0]
|
||||
check("a car that is slow to stop (about 1300 W after 20 s): the phases are "
|
||||
"NOT selected, the add-on gives up at 20 s, the 10 A come back at once "
|
||||
f"({[(x[1], x[2]) for x in seq5s]}), one failed try",
|
||||
[x[1] for x in seq5s].count("phases") == 0
|
||||
and [x[2] for x in seq5s if x[1] == "current"][:2] == [0.0, 10.0]
|
||||
and rest5s and 20.0 <= rest5s[0][0] - seq5s[0][0] <= 21.0
|
||||
and w5s.sim.phases_allowed == 1 and w5s.c.car_writer.phase_fails == 1)
|
||||
|
||||
|
||||
async def zero_refused():
|
||||
@@ -890,9 +895,11 @@ check("the write paths are exactly these (all in carmode.py): the current "
|
||||
("carmode.py", "write_phases")])
|
||||
|
||||
|
||||
async def fuzz(seed):
|
||||
async def fuzz(seed, slow=False):
|
||||
rnd = random.Random(seed)
|
||||
w = World(setpoint=rnd.choice([6, 10, 16]), phases=rnd.choice([1, 3]))
|
||||
if slow: # EV-28: the car's power ramps down slowly
|
||||
w.sim.ramp_w_s, w.sim.stop_delay_s = 200.0, float(seed % 2)
|
||||
w.sim.lag_s = rnd.choice([0.0, 0.0, 3.0, 12.0])
|
||||
race = seed % 2 == 1 # half the sites run read -> settle -> cycle
|
||||
bad, seen, others, holds, undos = [], 0, 0, 0, 0
|
||||
@@ -961,6 +968,9 @@ async def fuzz(seed):
|
||||
bad.append((seed, step, "phases selected outside Manual"))
|
||||
if sp != 0.0:
|
||||
bad.append((seed, step, "phases with the setpoint up", sp))
|
||||
if power >= carmode.QUIET_W: # EV-28 (N1)
|
||||
bad.append((seed, step, "phases selected under load",
|
||||
power))
|
||||
if last_switch is not None and t - last_switch < 600.0:
|
||||
bad.append((seed, step, "two switches inside 10 min",
|
||||
t - last_switch))
|
||||
@@ -977,7 +987,15 @@ for _seed in range(14):
|
||||
fz_o += _o
|
||||
fz_h += _h
|
||||
fz_u += _u
|
||||
check(f"fuzz: {fz_n} charger writes over 14 random sites and 5600 steps of "
|
||||
for _seed in range(100, 104): # EV-28: ramp 200 W/s, B after 0 or 1 s
|
||||
_b, _n, _o, _h, _u = run(fuzz(_seed, slow=True))
|
||||
fz_bad += _b
|
||||
fz_n += _n
|
||||
fz_o += _o
|
||||
fz_h += _h
|
||||
fz_u += _u
|
||||
check(f"fuzz: {fz_n} charger writes over 18 random sites (4 of them with a "
|
||||
f"car that stops at 200 W/s) and 7200 steps of "
|
||||
f"random user changes, outages, unplugs, refusals, shadow and control "
|
||||
f"stops, in both cycle orders: none over the clamp, none outside "
|
||||
f"Manual, none with control stopped, in shadow mode or with no car, the "
|
||||
|
||||
@@ -0,0 +1,538 @@
|
||||
"""EV-16: the Car Why does not alternate between "are at {pct}" and "give all
|
||||
they can" while the car-over row holds and the guard's floor flag toggles.
|
||||
`python3 -B test_ev16.py`
|
||||
|
||||
Display only: the text is held by `ctl_car._car_why_tick` on the control
|
||||
cycle's clock (control writes `_car_why_rec`, never reads it; /status reads do
|
||||
not move it). `c._car_over_ep` is bumped when car_over ends; a record of
|
||||
another episode is never used.
|
||||
Mutant: pick the text from the live `floor_limited` again (T1, T2, T7, T8, T9
|
||||
go red).
|
||||
Mutating a module this file grades? Read MUTATION.md first.
|
||||
"""
|
||||
|
||||
import dataclasses
|
||||
import hashlib
|
||||
import os
|
||||
import sys
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import ctl_car, homeview, chargers as CH # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
OVER = "are at"
|
||||
FULL = "give all they can"
|
||||
Q = 900.0
|
||||
STEP = 5.0
|
||||
|
||||
|
||||
@dataclasses.dataclass
|
||||
class G:
|
||||
floor_limited: bool = True
|
||||
soc: object = 20.0
|
||||
saturated: bool = False
|
||||
floor_w: float = 0.0
|
||||
able_w: object = None
|
||||
ceiling_w: float = 4500.0
|
||||
engaged: bool = True
|
||||
blind: object = None
|
||||
wanted_w: float = 300.0
|
||||
within_aim: bool = False
|
||||
|
||||
|
||||
class Proj:
|
||||
projected_w = 14500.0
|
||||
held_w = 14500.0
|
||||
elapsed_s = 400.0
|
||||
block_start = None
|
||||
|
||||
|
||||
class S(ctl_car.CarMixin):
|
||||
def __init__(self, cover=True):
|
||||
self.o = {"ev_batt_cover": cover}
|
||||
self._now = 0.0
|
||||
self.w = 11000.0
|
||||
self.site_batt_w, self.site_rating_w = 8100.0, 9600.0
|
||||
self.shadow, self.auto, self.peak_guard = False, True, None
|
||||
self.state = "charging"
|
||||
self.car_init({}, type("St", (), {"data": {}, "set": lambda s, k, v: 0})())
|
||||
self.car_over = True
|
||||
|
||||
def car_now(self):
|
||||
return self._now
|
||||
|
||||
def car_alarm_w(self):
|
||||
return self.w
|
||||
|
||||
@property
|
||||
def car(self):
|
||||
me = self
|
||||
|
||||
class _C:
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return me.state
|
||||
return _C
|
||||
|
||||
|
||||
def why(c):
|
||||
return homeview._car_manual_why(c, "charging")
|
||||
|
||||
|
||||
def kind(t):
|
||||
return "over" if OVER in t else "full" if FULL in t else t
|
||||
|
||||
|
||||
def tick(c, g, t):
|
||||
"""One control cycle's display tick (what car_cycle ends with)."""
|
||||
c._now = t
|
||||
c.peak_guard = g
|
||||
c._car_why_tick(g, t)
|
||||
|
||||
|
||||
def run(c, secs, g_of, t0=0.0):
|
||||
"""Read the Why once per 5 s cycle; returns [(t, kind)]."""
|
||||
out = []
|
||||
t = t0
|
||||
while t < t0 + secs:
|
||||
tick(c, g_of(t - t0), t)
|
||||
out.append((t, kind(why(c))))
|
||||
t += STEP
|
||||
return out
|
||||
|
||||
|
||||
def changes(seq):
|
||||
return [i for i in range(1, len(seq)) if seq[i][1] != seq[i - 1][1]]
|
||||
|
||||
|
||||
def toggle(period, first=True):
|
||||
return lambda t: G(floor_limited=(int(t // period) % 2 == 0) == first)
|
||||
|
||||
|
||||
HOUSE = s81.constant(1100.0)
|
||||
|
||||
|
||||
def real_run(read, eventful=True):
|
||||
"""The T1 shape through the real controller: the batteries toggle across
|
||||
the reserve every 10 s. Returns the control digest, the per-cycle rows and
|
||||
flags, and the Why texts read (if `read`)."""
|
||||
texts, rows, flags = [], [], []
|
||||
|
||||
def ev(plant, c):
|
||||
plant.soc = 19.0 if int(plant.t // 10) % 2 == 0 else 60.0
|
||||
pg = c.peak_guard
|
||||
flags.append(None if pg is None else pg.floor_limited)
|
||||
rows.append(tuple((x["id"], x["ok"], x["warn"]) for x in c.checks()
|
||||
if x["id"] in ("peak_guard", "car_over")))
|
||||
if read and c.car_over:
|
||||
texts.append(homeview.car_block(c, None)["why"])
|
||||
r = P.drive(HOUSE, dur=900, events={k: ev for k in range(0, 900)},
|
||||
cap=3500.0)
|
||||
ctl = ([s[1:] for s in r["snaps"]], list(r["raised"]),
|
||||
r["sim"].writes(), r["sim"].setpoint_a)
|
||||
return ctl, rows, flags, texts
|
||||
|
||||
|
||||
def digest(x):
|
||||
return hashlib.sha256(repr(x).encode()).hexdigest()[:16]
|
||||
|
||||
|
||||
if "--digest" in sys.argv:
|
||||
ctl, rows, flags, _t = real_run(False)
|
||||
print("DIGEST control", digest(ctl), "rows", digest(rows),
|
||||
"flags", digest(flags))
|
||||
sys.exit(0)
|
||||
|
||||
print("1. the hold: a toggling flag shows one text")
|
||||
c = S()
|
||||
a = run(c, Q, toggle(10.0, True))
|
||||
check("T1 quarter starts floor-limited, toggles every 10 s: one distinct text",
|
||||
len({k for _, k in a}) == 1 and a[0][1] == "over")
|
||||
for per in (20.0, 30.0, 10.0):
|
||||
c = S()
|
||||
a = run(c, Q, toggle(per, False))
|
||||
check(f"T2 starts not limited, toggles every {per:.0f} s: at most one "
|
||||
f"change, none back", len(changes(a)) <= 1)
|
||||
c = S()
|
||||
a = run(c, Q, lambda t: G(floor_limited=False, soc=38.0))
|
||||
check("T3 never limited: 'give all they can' every cycle, never 'are at'",
|
||||
{k for _, k in a} == {"full"})
|
||||
c = S()
|
||||
a = run(c, Q, lambda t: G())
|
||||
check("T4 limited and steady: 'are at' 20 % from the first cycle",
|
||||
{k for _, k in a} == {"over"}
|
||||
and "20 %" in why(c))
|
||||
|
||||
print("\n2. real changes still show")
|
||||
c = S()
|
||||
a = run(c, 300.0, lambda t: G(floor_limited=False, soc=30.0))
|
||||
a += run(c, 600.0, lambda t: G(), t0=300.0)
|
||||
ch = changes(a)
|
||||
check("T5 full for 300 s then steady limited: one change, full -> over, "
|
||||
"within 185 s", len(ch) == 1 and a[ch[0]][1] == "over"
|
||||
and a[ch[0]][0] - 300.0 <= 185.0)
|
||||
c = S()
|
||||
a = run(c, 300.0, lambda t: G())
|
||||
a += run(c, 600.0, lambda t: G(floor_limited=False, soc=30.0), t0=300.0)
|
||||
ch = changes(a)
|
||||
check("T6 limited for 300 s then steady not limited: one change back to "
|
||||
"'give all they can' within 185 s", len(ch) == 1
|
||||
and a[ch[0]][1] == "full" and a[ch[0]][0] - 300.0 <= 185.0)
|
||||
for steady_false in (True, False):
|
||||
c = S()
|
||||
a = run(c, Q, toggle(10.0, True))
|
||||
a += run(c, Q, (lambda t: G(floor_limited=False, soc=30.0))
|
||||
if steady_false else (lambda t: G()), t0=Q)
|
||||
ch = changes(a)
|
||||
first_q = {k for t, k in a if t < Q}
|
||||
check(f"T7 toggling across the edge, new quarter steady "
|
||||
f"{'False' if steady_false else 'True'}: nothing before the edge, "
|
||||
f"at most one change near it, to the new state",
|
||||
len(first_q) == 1 and len(ch) <= 1
|
||||
and all(a[i][0] >= Q for i in ch)
|
||||
and len(a) > 0 and a[-1][1] == ("full" if steady_false else "over"))
|
||||
near = [i for i in ch if abs(a[i][0] - Q) <= 60.0]
|
||||
check("T7 (cont.) at most one change in the 60 s around the edge",
|
||||
len(near) <= 1)
|
||||
|
||||
print("\n3. failure modes")
|
||||
c = S()
|
||||
a = run(c, Q, lambda t: G(soc=None))
|
||||
check("T8 SoC unread, guard limited: never 'are at', one text",
|
||||
{k for _, k in a} == {"full"})
|
||||
c = S()
|
||||
a = run(c, Q, lambda t: G(soc=None if int(t // 10) % 2 == 0 else 20.0))
|
||||
check("T8 SoC toggling None / 20 % every 10 s, starting unread: one text, "
|
||||
"never 'are at'", {k for _, k in a} == {"full"})
|
||||
c = S()
|
||||
seq = []
|
||||
for t in range(0, 900, 5):
|
||||
tick(c, None if 400 <= t < 410 else G(floor_limited=(t // 10) % 2
|
||||
== 0), float(t))
|
||||
try:
|
||||
seq.append((t, kind(why(c))))
|
||||
except Exception as e: # noqa: BLE001
|
||||
seq.append((t, "TRACE " + repr(e)))
|
||||
check("T9 guard None for a cycle: no Traceback, one text through it",
|
||||
not any("TRACE" in k for _, k in seq) and len({k for _, k in seq}) == 1)
|
||||
c = S()
|
||||
tick(c, None, 0.0)
|
||||
check("T9 (cont.) guard None from the very first read: a text, no Traceback",
|
||||
kind(why(c)) in ("full", "over"))
|
||||
|
||||
# T10: the car stops, car_over drops after 180 s, a later episode
|
||||
c = S()
|
||||
run(c, 100.0, lambda t: G())
|
||||
check("T10 held 'are at' to start", kind(why(c)) == "over")
|
||||
for k in range(0, 200):
|
||||
c._now = 100.0 + k
|
||||
c.w = None
|
||||
c.car_cycle(Proj(), G(), 14000.0, None)
|
||||
check("T10 car_over dropped after the stop", c.car_over is False)
|
||||
check("T10 the Why left the over wording", OVER not in why(c)
|
||||
and FULL not in why(c))
|
||||
c.car_over = True # a new episode, later, SoC 60 %
|
||||
tick(c, G(floor_limited=False, soc=60.0), 5000.0)
|
||||
check("T10 the new episode shows 'give all they can' from its first cycle",
|
||||
kind(why(c)) == "full")
|
||||
|
||||
# T10b: no read between the drop and the new episode (the hold is cleared at
|
||||
# the drop, not at a read)
|
||||
c = S()
|
||||
run(c, 100.0, lambda t: G())
|
||||
for k in range(0, 200):
|
||||
c._now = 100.0 + k
|
||||
c.w = None
|
||||
c.car_cycle(Proj(), G(), 14000.0, None)
|
||||
c.car_over = True
|
||||
c.peak_guard = G(floor_limited=False, soc=60.0)
|
||||
c._now = 9000.0
|
||||
check("T10 no /status between the drop and the new episode: still 'full'",
|
||||
kind(why(c)) == "full")
|
||||
|
||||
# T11: unplug
|
||||
c = S()
|
||||
run(c, 100.0, lambda t: G())
|
||||
c._car_prev_state = "charging"
|
||||
c.state = CH.NONE_
|
||||
c._now = 105.0
|
||||
c.car_cycle(Proj(), G(), 14000.0, None)
|
||||
c.car_over = False
|
||||
check("T11 after the unplug cycle there is no over wording",
|
||||
OVER not in homeview._car_manual_why(c, "none")
|
||||
and FULL not in homeview._car_manual_why(c, "none")
|
||||
and "set when a car is connected" in homeview._car_manual_why(c, "none"))
|
||||
c.state = "charging"
|
||||
c.car_over = True
|
||||
tick(c, G(floor_limited=False, soc=60.0), 400.0)
|
||||
check("T11 a replug starts with no held text", kind(why(c)) == "full")
|
||||
# the hold is also gone when the unplug itself ends car_over (no read between)
|
||||
c = S()
|
||||
run(c, 100.0, lambda t: G())
|
||||
c._car_prev_state = "charging"
|
||||
c.state = CH.NONE_
|
||||
c._now = 105.0
|
||||
ep_before = c._car_over_ep
|
||||
c.car_cycle(Proj(), G(), 14000.0, None)
|
||||
check("T11 (cont.) the unplug ends the episode (control bumps it)",
|
||||
c.car_over is False and c._car_over_ep > ep_before)
|
||||
|
||||
# T12: cover off while car_over holds
|
||||
c = S()
|
||||
run(c, 100.0, lambda t: G())
|
||||
c.o["ev_batt_cover"] = False
|
||||
tick(c, G(), 105.0)
|
||||
check("T12 cover off: 'ignores the car' at the next read",
|
||||
"ignores the car" in why(c))
|
||||
c.o["ev_batt_cover"] = True
|
||||
tick(c, G(floor_limited=False, soc=60.0), 110.0)
|
||||
check("T12 cover on again, steady not limited: 'give all they can', not "
|
||||
"the old 'are at'", kind(why(c)) == "full")
|
||||
|
||||
# T13: restart
|
||||
c = S()
|
||||
a = run(c, 450.0, toggle(10.0, True))
|
||||
c2 = S()
|
||||
b = run(c2, 450.0, toggle(10.0, True), t0=450.0)
|
||||
check("T13 restart mid-quarter: no Traceback, a text, at most one change "
|
||||
"after", kind(why(c2)) in ("full", "over") and len(changes(b)) <= 1)
|
||||
|
||||
print("\n4. control unchanged; the rows follow the live flag")
|
||||
ctl1, rows1, flags1, sts = real_run(True)
|
||||
ctl0, rows0, flags0, _t = real_run(False)
|
||||
check("T14 reading the Why every cycle changes no command, alarm or row",
|
||||
ctl1 == ctl0 and rows1 == rows0 and flags1 == flags0)
|
||||
shown = [t for t in sts if OVER in t or FULL in t]
|
||||
flips = sum(1 for a, b in zip(flags1, flags1[1:]) if a != b)
|
||||
BASE_8150608 = ("e6034b0c78f23776", "5ffb80fa428cd6ee", "689a5b0e4bf7c897")
|
||||
check("T14/T15 commands, alarms, charger writes and the peak_guard/car_over "
|
||||
"rows equal those of base 8150608 (digests taken there with --digest)",
|
||||
(digest(ctl1), digest(rows1), digest(flags1)) == BASE_8150608)
|
||||
check("PRECONDITION: the real guard's floor flag toggles many times and "
|
||||
"car_over is on for most of the run", flips > 20 and len(shown) > 200)
|
||||
check("T1/T2 through the real guard: at most one Why change in the quarter",
|
||||
sum(1 for a, b in zip(shown, shown[1:]) if a != b) <= 1)
|
||||
check("T15 the peak_guard row follows the live flag (it changes as often as "
|
||||
"the flag), the hold is only in the Why",
|
||||
sum(1 for a, b in zip(rows1, rows1[1:]) if a != b) >= 1
|
||||
and len({r for r in rows1 if r}) >= 1)
|
||||
print(" DIGEST control", digest(ctl1), "rows", digest(rows1),
|
||||
"flags", digest(flags1))
|
||||
|
||||
print("\n5. text, hold and wiring")
|
||||
check("the hold equals the car_over row's own off hold",
|
||||
homeview.WHY_HOLD_S == ctl_car.OVER_OFF_HOLD_S)
|
||||
src = open(os.path.join(HERE, "app", "homeview.py")).read()
|
||||
check("the live flag is read only by the hold helper, not by the Why branch",
|
||||
'pg.floor_limited else' not in src)
|
||||
import json
|
||||
for lang, over, full in (
|
||||
("en", "You set {a} A. The batteries are at {pct}, so this charge "
|
||||
"sets the peak.",
|
||||
"You set {a} A. The batteries give all they can, so this charge "
|
||||
"sets the peak."),
|
||||
("nl", "U stelde {a} A in. De batterijen staan op {pct}, dus deze "
|
||||
"lading bepaalt de piek.",
|
||||
"U stelde {a} A in. De batterijen geven alles, dus deze lading "
|
||||
"bepaalt de piek.")):
|
||||
d = json.load(open(os.path.join(HERE, "app", "ui_text", lang + ".json")))
|
||||
d = d["home_words"]["car"]["why"]
|
||||
check(f"T17 {lang}.json wording of manual_over / manual_full unchanged",
|
||||
d["manual_over"] == over and d["manual_full"] == full)
|
||||
check("a held peak_guard row is not touched: the module still has no hold "
|
||||
"in ctl_status", "_car_why_rec" not in open(os.path.join(
|
||||
HERE, "app", "ctl_status.py")).read())
|
||||
|
||||
print("\n6. EV-16 review round 1: the race, T16, T18, the N-ids")
|
||||
# the race: a read takes the hold, control ends the episode, the read writes
|
||||
# its old hold back; the next episode must not show it
|
||||
c = S()
|
||||
run(c, 100.0, lambda t: G())
|
||||
stale = c._car_why_rec
|
||||
check("race: the read holds 'are at' before the end", kind(why(c)) == "over")
|
||||
for k in range(0, 200):
|
||||
c._now = 100.0 + k
|
||||
c.w = None
|
||||
c.car_cycle(Proj(), G(), 14000.0, None)
|
||||
c._car_why_rec = stale # the late write-back
|
||||
c.car_over = True
|
||||
c._now = 6000.0
|
||||
c.peak_guard = G(floor_limited=False, soc=60.0)
|
||||
check("N4 race: a read interleaved with the clear cannot bring the old "
|
||||
"'are at' into the next episode", kind(why(c)) == "full")
|
||||
c = S()
|
||||
run(c, 100.0, lambda t: G())
|
||||
stale = c._car_why_rec
|
||||
c._car_prev_state = "charging"
|
||||
c.state = CH.NONE_
|
||||
c._now = 105.0
|
||||
c.car_cycle(Proj(), G(), 14000.0, None)
|
||||
c._car_why_rec = stale # write-back after an unplug
|
||||
c.state = "charging"
|
||||
c.car_over = True
|
||||
c.peak_guard = G(floor_limited=False, soc=60.0)
|
||||
c._now = 110.0
|
||||
check("N4 race (unplug): a stale write-back after the unplug is not used",
|
||||
kind(why(c)) == "full")
|
||||
|
||||
# T16: the existing checks this one must leave alone are present and run in CI
|
||||
for f in ("test_ev04.py", "test_ev10.py", "test_ev10b.py", "test_ev18.py",
|
||||
"test_ev19.py", "test_home.py", "test_named_absence.py",
|
||||
"test_bytecode.py"):
|
||||
check(f"T16 {f} exists (run unchanged by CI's run-tests.sh)",
|
||||
os.path.exists(os.path.join(HERE, f)))
|
||||
t04 = open(os.path.join(HERE, "test_ev04.py")).read()
|
||||
check("T16 test_ev04's Manual Why assertion 'batteries give all they can' "
|
||||
"is still there", 'batteries give all they can" in cardwhy' in t04)
|
||||
|
||||
# T18: the mutant, in process: the live flag picks the text again
|
||||
real = homeview._over_why_is_floor
|
||||
homeview._over_why_is_floor = lambda c, pg: bool(
|
||||
pg is not None and pg.floor_limited)
|
||||
try:
|
||||
m = run(S(), Q, toggle(10.0, True))
|
||||
m8 = run(S(), Q, lambda t: G(soc=None))
|
||||
finally:
|
||||
homeview._over_why_is_floor = real
|
||||
check("T18 mutant (live flag): T1 shape alternates and T8 shows 'are at', so "
|
||||
"T1, T2, T7 and T8 would go red", len(changes(m)) > 20
|
||||
and any(k == "over" for _, k in m8))
|
||||
|
||||
# the N-ids, by name
|
||||
a = run(S(), Q, toggle(10.0, True))
|
||||
check("N1 control: batteries, charger writes and setpoint equal base "
|
||||
"(digests, section 4)", (digest(ctl1), digest(rows1), digest(flags1))
|
||||
== BASE_8150608)
|
||||
check("N2 `floor_limited`, `car_explains`, `car_over`, the peak_guard row "
|
||||
"are not changed by the hold: the guard flag toggles as in base "
|
||||
"(flags digest) and the rows digest equals base",
|
||||
digest(flags1) == BASE_8150608[2] and digest(rows1) == BASE_8150608[1])
|
||||
n3 = run(S(), Q, lambda t: G(soc=None)) + run(
|
||||
S(), Q, lambda t: G(floor_limited=False, soc=40.0))
|
||||
check("N3 never 'are at' with SoC unread or with the guard never limited",
|
||||
{k for _, k in n3} == {"full"})
|
||||
c = S()
|
||||
run(c, 100.0, lambda t: G())
|
||||
c.car_over = False
|
||||
n4 = homeview._car_manual_why(c, "charging")
|
||||
check("N4 no over wording once car_over is off", OVER not in n4
|
||||
and FULL not in n4)
|
||||
check("N5 at most one Why change in a quarter while the guard toggles",
|
||||
len(changes(a)) <= 1)
|
||||
try:
|
||||
for g in (None, G(soc=None), G(), G(floor_limited=False, soc=1.0)):
|
||||
c = S()
|
||||
c.peak_guard = g
|
||||
why(c)
|
||||
n6 = True
|
||||
except Exception: # noqa: BLE001
|
||||
n6 = False
|
||||
check("N6 no Traceback for a guard of None, SoC unread, limited, not "
|
||||
"limited", n6)
|
||||
en = open(os.path.join(HERE, "app", "ui_text", "en.json")).read()
|
||||
nl = open(os.path.join(HERE, "app", "ui_text", "nl.json")).read()
|
||||
check("N7 wording unchanged: the four texts are in the files verbatim",
|
||||
"The batteries are at {pct}, so this charge sets the peak." in en
|
||||
and "The batteries give all they can, so this charge sets the peak."
|
||||
in en and "De batterijen staan op {pct}, dus deze lading bepaalt de "
|
||||
"piek." in nl and "De batterijen geven alles, dus deze lading bepaalt "
|
||||
"de piek." in nl)
|
||||
|
||||
print("\n7. EV-16 review round 2: the hold runs on the control clock")
|
||||
|
||||
|
||||
def gap_run(c, g_of, read_at, end=2300.0):
|
||||
"""Control cycles every 5 s; the Why is read only at the `read_at` times."""
|
||||
out = []
|
||||
t = 0.0
|
||||
while t < end:
|
||||
tick(c, g_of(t), t)
|
||||
if any(a <= t < b for a, b in read_at):
|
||||
out.append((t, kind(why(c))))
|
||||
t += STEP
|
||||
return out
|
||||
|
||||
|
||||
pages = ((0, 60), (2000, 2300))
|
||||
c = S()
|
||||
r = gap_run(c, lambda t: G(floor_limited=t >= 300.0, soc=20.0), pages)
|
||||
late = [(t, k) for t, k in r if t >= 2000]
|
||||
check("review A: drained to the reserve while the page was closed: the "
|
||||
"first read at t=2000 already shows 'are at'",
|
||||
len(late) > 0 and late[0][1] == "over" and {k for _, k in late} == {"over"})
|
||||
c = S()
|
||||
r = gap_run(c, lambda t: G(floor_limited=t < 300.0,
|
||||
soc=20.0 if t < 300.0 else 45.0), pages)
|
||||
late = [(t, k) for t, k in r if t >= 2000]
|
||||
check("review B: off the reserve while the page was closed: the first "
|
||||
"read at t=2000 shows 'give all they can', never a false 'are at'",
|
||||
len(late) > 0 and late[0][1] == "full" and {k for _, k in late} == {"full"})
|
||||
c = S()
|
||||
r = []
|
||||
for t in range(0, 400, 5):
|
||||
cov = not (100 <= t < 200)
|
||||
c.o["ev_batt_cover"] = cov
|
||||
tick(c, G(floor_limited=t < 100, soc=20.0 if t < 100 else 45.0),
|
||||
float(t))
|
||||
if t in (95, 205):
|
||||
r.append(kind(why(c)))
|
||||
check("review: cover off and on with no read between: back on, the state "
|
||||
"now not limited shows 'give all they can' at the first read",
|
||||
r == ["over", "full"])
|
||||
# lower bound of the hold: a real change is NOT shown before the hold ends
|
||||
c = S()
|
||||
r = []
|
||||
for t in range(0, 600, 5):
|
||||
tick(c, G(floor_limited=t >= 300.0, soc=20.0), float(t))
|
||||
r.append((t, kind(why(c))))
|
||||
check("review: a real change is held for the full 180 s: still the old "
|
||||
"text 170 s after it, the new one by 185 s",
|
||||
dict(r)[470] == "full" and dict(r)[485] == "over")
|
||||
# M7: guard None for 180 s or more under car_over
|
||||
for steady, want in ((True, "over"), (False, "full")):
|
||||
c = S()
|
||||
seq = []
|
||||
for t in range(0, 1200, 5):
|
||||
g = G(floor_limited=steady, soc=20.0 if steady else 45.0) \
|
||||
if t < 100 else None
|
||||
tick(c, g, float(t))
|
||||
seq.append(kind(why(c)))
|
||||
check(f"T9 (long) guard None for 1100 s after a steady "
|
||||
f"{'limited' if steady else 'not limited'} state: the text stays "
|
||||
f"'{want}', no flip", set(seq) == {want})
|
||||
c = S()
|
||||
seq = []
|
||||
for t in range(0, 1200, 5):
|
||||
tick(c, None, float(t))
|
||||
seq.append(kind(why(c)))
|
||||
check("T9 (long) guard None from the start for 1200 s: one text, 'full'",
|
||||
set(seq) == {"full"})
|
||||
# review round 2: the live fallback (no record yet, or one of an ended
|
||||
# episode) keeps the unread-SoC rule too
|
||||
for label, rec in (("no record yet", None),
|
||||
("a record of an ended episode", [True, None, -1])):
|
||||
c = S()
|
||||
c._now = 0.0
|
||||
c._car_why_rec = rec
|
||||
c.peak_guard = G(soc=None)
|
||||
check(f"N3 {label}: limited with SoC unread is not 'are at'",
|
||||
kind(why(c)) == "full")
|
||||
c.peak_guard = G()
|
||||
check(f"N3 {label}: limited with SoC read shows 'are at' (live state)",
|
||||
kind(why(c)) == "over")
|
||||
|
||||
print()
|
||||
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
||||
sys.exit(1 if fails else 0)
|
||||
@@ -0,0 +1,654 @@
|
||||
"""EV-19: no floor alarm when the batteries first reach the peak reserve early
|
||||
in a Manual car session (EV-15 rig F-B). `python3 -B test_ev19.py`
|
||||
|
||||
The rig: one PEAK_GUARD_FLOOR_LIMITED ERROR, one `goodwe_peak_soc_floor` and
|
||||
one red sample the moment the batteries reached the reserve, while the excess
|
||||
was smaller than the car. Reproduced (T1): at the reserve inverter-b goes on
|
||||
following the house, so its output RISES in that cycle. The battery reading
|
||||
shows the rise one cycle before the P1 sample does, and EV-18's "house"
|
||||
(meter + what the batteries give now) counted the new battery power as house
|
||||
load. That latched `_car_need_house` for the quarter: the alarm stood until
|
||||
the guard stopped wanting power. Now a rise the reading shows above both
|
||||
earlier readings is not counted as house until a second reading confirms it.
|
||||
The credit stays the lower of the last two readings.
|
||||
|
||||
T-ids are the test plan's (reports/EV-19-test-plan.md). "base" is 43b0db7.
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import ctl_car, tariff # noqa: E402
|
||||
from named_absence import first, nth, present # noqa: E402
|
||||
import ev19_reserve as V # noqa: E402
|
||||
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
AIM = V.AIM
|
||||
CAR = V.CAR
|
||||
|
||||
# =========================================================================== #
|
||||
print("1. UNIT: car_cycle in the reserve cycle (a real `_carq`)")
|
||||
# =========================================================================== #
|
||||
BS = datetime(2026, 11, 20, 20, 30, tzinfo=timezone.utc) # a quarter edge
|
||||
|
||||
|
||||
class _Car(ctl_car.CarMixin):
|
||||
def __init__(self):
|
||||
self.o = {"ev_batt_cover": True}
|
||||
self.w = CAR
|
||||
self._now = 0.0
|
||||
self.site_batt_w, self.site_rating_w = 0.0, 9600.0
|
||||
self.store = type("S", (), {"data": {}, "set": lambda s, k, v: 0})()
|
||||
self.car_init({}, self.store)
|
||||
|
||||
def car_now(self):
|
||||
return self._now
|
||||
|
||||
def car_alarm_w(self):
|
||||
return self.w
|
||||
|
||||
class car: # noqa: N801
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
class _G:
|
||||
"""Floor-limited, the floor leaves nothing (floor_w 0), wants power."""
|
||||
floor_limited, saturated = True, False
|
||||
floor_w, able_w, ceiling_w = 0.0, None, AIM + 50.0
|
||||
engaged, blind, wanted_w, within_aim = True, None, 300.0, False
|
||||
|
||||
|
||||
def urun(secs, grid, batt, w=lambda t: CAR):
|
||||
"""`car_cycle` once per second of `secs` (seconds from the edge). `grid(t)`
|
||||
is the meter, `batt(t)` the site battery reading. {t: car_explains}."""
|
||||
c = _Car()
|
||||
done, out = {}, {}
|
||||
for t in secs:
|
||||
q = t // 900
|
||||
bs, el = BS + timedelta(seconds=900 * q), t - 900 * q
|
||||
g = float(grid(t))
|
||||
d = done.get(bs, g * el)
|
||||
p = tariff.Projection(
|
||||
projected_w=(d + g * (900 - el)) / 900.0,
|
||||
elapsed_w=(d / el if el else g), elapsed_s=float(el),
|
||||
covered_frac=1.0, complete=False, block_start=bs, held_w=g)
|
||||
done[bs] = d + g
|
||||
c._now = 10000.0 + t
|
||||
c.w, c.site_batt_w = w(t), batt(t)
|
||||
c.car_cycle(p, _G(), AIM, None)
|
||||
out[t] = c.car_explains
|
||||
return out
|
||||
|
||||
|
||||
def run_of(d, t0, t1):
|
||||
return [d[t] for t in sorted(d) if t0 <= t <= t1]
|
||||
|
||||
|
||||
def rise(at, lo, hi):
|
||||
"""A battery reading that steps from `lo` to `hi` at `at`."""
|
||||
return lambda t: lo if t < at else hi
|
||||
|
||||
|
||||
def meter(house, b, lag=1):
|
||||
"""The P1 figure: house + car - what the batteries gave `lag` cycles ago
|
||||
(the reading leads the meter by that much)."""
|
||||
return lambda t: house + CAR - b(t - lag)
|
||||
|
||||
|
||||
HB = AIM + 520.0 - CAR # F-B: house + car at batteries 0 W = aim + 520
|
||||
b2 = rise(1, 0.0, 4600.0)
|
||||
u2 = urun(range(-5, 61), meter(HB, b2), b2)
|
||||
print(f" T2 unit E-1..E+3: {run_of(u2, -1, 3)}")
|
||||
check("T2 unit: b starts following the house at the reserve (0 -> 4 600 W) "
|
||||
"and the reading shows it one cycle before the meter: the car explains "
|
||||
"every cycle, the rise cycle E+1 among them (base: not from E+1)",
|
||||
all(run_of(u2, 0, 60)) and len(run_of(u2, 0, 60)) == 61)
|
||||
u2s = urun(range(-5, 61), meter(HB, b2, lag=0), b2)
|
||||
check("T2 unit: the same rise with the meter in step: explained every cycle",
|
||||
all(run_of(u2s, 0, 60)) and len(run_of(u2s, 0, 60)) == 61)
|
||||
|
||||
# T4: the landing without the car at aim + 9 / + 11 W in the rise cycle. The
|
||||
# rise is at the edge, so with the lower reading credited (0 W) the house
|
||||
# alone lands at exactly `house`.
|
||||
b4 = rise(0, 0.0, 800.0)
|
||||
u409 = urun(range(-3, 10), meter(AIM + 9.0, b4), b4)
|
||||
u411 = urun(range(-3, 10), meter(AIM + 11.0, b4), b4)
|
||||
print(f" T4 unit +9 {run_of(u409, 0, 3)} +11 {run_of(u411, 0, 3)}")
|
||||
check("T4 unit: the house alone at aim + 9 W in the rise cycle: the car "
|
||||
"explains from E+0 (base: no)", all(run_of(u409, 0, 9))
|
||||
and len(run_of(u409, 0, 9)) == 10)
|
||||
check("T4 unit: at aim + 11 W it does not, from E+0 (as base)",
|
||||
not any(run_of(u411, 0, 9)) and len(run_of(u411, 0, 9)) == 10)
|
||||
|
||||
# N6 / T7(a): an unknown reading credits nothing; the lower reading is
|
||||
# credited, not the higher or the last known one.
|
||||
b7 = lambda t: None if t == 1 else b2(t) # noqa: E731
|
||||
u7 = urun(range(-5, 30), meter(HB, b2), b7)
|
||||
check("T7(a) unit: the battery reading unknown in the rise cycle: nothing "
|
||||
"explained in that cycle (no last-known W), explained from the next",
|
||||
u7.get(1) is False and u7.get(0) is True and all(run_of(u7, 2, 29)))
|
||||
u6 = urun(range(-5, 30), meter(AIM + 11.0 + 400.0, lambda t: 400.0, lag=0),
|
||||
lambda t: 800.0 if t == 3 else 400.0)
|
||||
check("N6 unit: b at 400 W, the house alone with it at aim + 11 W, one "
|
||||
"reading of 800 W at E+3: not explained in any cycle",
|
||||
not any(run_of(u6, 0, 29)))
|
||||
# A house step that comes with a battery rise: b steps to 800 W and the
|
||||
# meter, one cycle late, shows a house of aim + 811 W, so with b's 800 W the
|
||||
# house alone misses by 11 W. The meter moved, so nothing is discounted.
|
||||
b8 = rise(5, 0.0, 800.0)
|
||||
u8 = urun(range(0, 30), lambda t: (AIM - 500.0 if t < 5 else AIM + 811.0)
|
||||
+ CAR - b8(t - 1), b8)
|
||||
print(f" N6 unit house step with a rise E+4..E+8: {run_of(u8, 4, 8)}")
|
||||
check("N6 unit: a house step that comes with a battery rise is latched in "
|
||||
"the rise cycle (E+5, as base), and stays latched",
|
||||
all(run_of(u8, 0, 4)) and not any(run_of(u8, 5, 29)))
|
||||
|
||||
# Review round 1 (Major): an honest house step at E+5 answered by ONE reading
|
||||
# of battery power, the meter in step (it shows the burst too) or one cycle
|
||||
# late. Not explained from E+5, the step's own cycle, as base.
|
||||
for H, burst, lag in ((2000.0, 4600.0, 0), (1900.0, 3000.0, 0),
|
||||
(5000.0, 4600.0, 0), (2000.0, 4600.0, 1),
|
||||
(1900.0, 3000.0, 1)):
|
||||
hs = (lambda t, H=H: AIM - 500.0 if t < 5 else AIM + H)
|
||||
bb = (lambda t, burst=burst: burst if t == 5 else 0.0)
|
||||
ub = urun(range(0, 15), lambda t, hs=hs, bb=bb, lag=lag:
|
||||
hs(t) + CAR - bb(t - lag), bb)
|
||||
check(f"RB unit: house -> aim + {H:.0f} W at E+5 with one {burst:.0f} W "
|
||||
f"reading, meter {'in step' if lag == 0 else 'one cycle late'}: "
|
||||
f"explained to E+4, not from E+5 (base: the same)",
|
||||
ub.get(4) is True and not any(run_of(ub, 5, 14))
|
||||
and len(run_of(ub, 5, 14)) == 10)
|
||||
|
||||
# The discount needs a still meter: the F-B rise (T2 unit) with the house
|
||||
# side of the meter moving by RISE_STILL_W -/+ 10 W in the rise cycle.
|
||||
STILL = getattr(ctl_car, "RISE_STILL_W", 50.0) # 43b0db7 has none
|
||||
for d, want in ((STILL - 10.0, True), (STILL + 10.0, False)):
|
||||
ud = urun(range(-5, 10), lambda t, d=d: HB + (d if t >= 1 else 0.0)
|
||||
+ CAR - b2(t - 1), b2)
|
||||
check(f"RISE_STILL_W: the meter's house side moves {d:.0f} W in the rise "
|
||||
f"cycle: {'still, the rise is not yet house (explained)' if want else 'moved, the rise counts as house (not explained, as base)'}",
|
||||
ud.get(1) is want and ud.get(0) is True)
|
||||
|
||||
# Review round 2: the blind band in absolute W (the owner's 50 W; change this
|
||||
# check with the owner). An honest step at E+5 (house aim - 500 -> aim + 1 900
|
||||
# W, more than the car) with one burst that leaves the meter's house side
|
||||
# moving d W: at |d| = 60 the alarm cycle is base's (E+5); inside the band
|
||||
# (d = 0) the car explains at most the step's own cycle, never from E+6.
|
||||
for dd in (60.0, -60.0, 0.0):
|
||||
hb = (lambda t: AIM - 500.0 if t < 5 else AIM + 1900.0)
|
||||
bd = (lambda t, B=2400.0 - dd: B if t == 5 else 0.0)
|
||||
ubd = urun(range(0, 15), lambda t, hb=hb, bd=bd: hb(t) + CAR - bd(t), bd)
|
||||
print(f" band d={dd:+.0f} W E+4..E+8: {run_of(ubd, 4, 8)}")
|
||||
t0 = 5 if dd else 6
|
||||
check(f"band: an honest step whose burst moves the meter's house side "
|
||||
f"{dd:+.0f} W: not explained from E+{t0}",
|
||||
ubd.get(4) is True and not any(run_of(ubd, t0, 14))
|
||||
and len(run_of(ubd, t0, 14)) == 15 - t0)
|
||||
|
||||
# Review round 2: the stillness test uses the house side (held - car). The car
|
||||
# steps 1 380 -> 2 760 W, the house aim - 500 -> aim + 3 000 W (more than the
|
||||
# car) and b gives one reading of 4 880 W, all at E+5, meter in step: the
|
||||
# meter's total stays, its house side drops 1 380 W, so nothing is discounted.
|
||||
hc = (lambda t: AIM - 500.0 if t < 5 else AIM + 3000.0)
|
||||
wc = (lambda t: CAR if t < 5 else 2 * CAR)
|
||||
bc5 = (lambda t: 4880.0 if t == 5 else 0.0)
|
||||
ucw = urun(range(0, 15), lambda t: hc(t) + wc(t) - bc5(t), bc5, w=wc)
|
||||
check("car term: the car steps up with the house and a burst, the meter's "
|
||||
"total still: not explained from E+5 (as base)",
|
||||
ucw.get(4) is True and not any(run_of(ucw, 5, 14))
|
||||
and len(run_of(ucw, 5, 14)) == 10)
|
||||
|
||||
# Review round 1 (mC): EV-18's `_car_over_now` keeps the reading as it is. b
|
||||
# gives 2 000 W, the house alone with it lands under the aim and the period
|
||||
# with the car too, so nothing explains; b rises to 4 000 W at E+5 one cycle
|
||||
# before the meter: the period with the car on the reading as it is lands
|
||||
# over, so the car explains from E+5.
|
||||
bc = rise(5, 2000.0, 4000.0)
|
||||
uc = urun(range(0, 15), lambda t: AIM + 500.0 + CAR - bc(t - 1), bc)
|
||||
print(f" over_now unit E+3..E+7: {run_of(uc, 3, 7)}")
|
||||
check("over_now unit: `_car_over_now` grades the undiscounted reading: not "
|
||||
"explained E+0..E+4, explained from the rise cycle E+5",
|
||||
not any(run_of(uc, 0, 4)) and all(run_of(uc, 5, 14))
|
||||
and len(run_of(uc, 5, 14)) == 10)
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n2. THE REAL CONTROLLER AT THE RESERVE (N=2, tools/ev19_reserve.py)")
|
||||
# =========================================================================== #
|
||||
JOBS = V.jobs()
|
||||
RES = V.run_many(JOBS)
|
||||
|
||||
|
||||
def res(name):
|
||||
return RES[name]
|
||||
|
||||
|
||||
def trusted(x):
|
||||
return x["w"] is not None and x["w"] > 0.0 and not x["contra"]
|
||||
|
||||
|
||||
def bad(x):
|
||||
return bool(x["alarm"] or x["red"] or x["err"])
|
||||
|
||||
|
||||
def hits(r, t0=-10, t1=60):
|
||||
"""T1's reproduction: an alarm, red sample or ERROR in R-10..R+60 in a
|
||||
cycle where the car figure is trusted (every T1 shape lands under the aim
|
||||
without the car, so the car explains there)."""
|
||||
return [int(x["t"] - r.R) for x in r.win(t0, t1) if bad(x) and trusted(x)]
|
||||
|
||||
|
||||
def show(name):
|
||||
r = res(name)
|
||||
print(f" {name}: alarms {r.rel_alarms()} edges {r.edges()} errors "
|
||||
f"{r.errors()} red {len(r.red())} s cmd {r.cmd}")
|
||||
|
||||
|
||||
# Measured on base 43b0db7 with this file's own runs: the seconds from R of
|
||||
# goodwe_peak_soc_floor in the honest shapes, which must not come later now.
|
||||
BASE_ALARMS = {
|
||||
"T4 +11 manual": [0, 857], "T5 t1 manual": [2], "T5 t4 manual": [11],
|
||||
"T5 tau5 manual": [2], "T6 step R+0 manual": [2],
|
||||
"T6 step R+1 manual": [2], "T6 step R+5 manual": [6],
|
||||
"T7(a) T5": [2], "T7(b) T5": [2], "T8(c) frozen, the car stops": [2],
|
||||
"T9(a) T5 b lost at R": [2], "T9(a) T5 b lost at R-1": [2],
|
||||
"T9(b) T5 P1 5 s late at R": [5], "T10 T5 twin": [2],
|
||||
"T10 T5 restart R-2": [2], "T10 T5 restart R+2": [2],
|
||||
"T10 T5 restart R-1": [2], "T10 T5 restart R+0": [2],
|
||||
"T10 T2 restart R+0": [1],
|
||||
"T11 T5 R=E-1": [2], "T11 T5 R=E+0": [0, 2], "T11 T5 R=E+1": [0, 2],
|
||||
"T11 T5 R=E+43": [2], "T12 T5 1->3 at R-15": [2],
|
||||
"T12 T5 1->3 at R+5": [2], "T13(a) draws 100 W manual": [0, 857],
|
||||
"T14(c) N=1 T5": [2], "T15 honest manual": [13],
|
||||
"T16 x10 T5 manual": [20], "T16 x10 T6 manual": [20],
|
||||
"T16 mono1 T5 manual": [20], "T16 mono1 T6 manual": [20],
|
||||
"T16 x10 T11 T5 R=E-10": [20], "T16 x10 T11 T5 R=E+0": [0, 20],
|
||||
"T16 x10 T11 T5 R=E+10": [0, 20], "T16 x10 T11 T5 R=E+40": [20],
|
||||
"T16 mono1 T11 T5 R=E-10": [20], "T16 mono1 T11 T5 R=E+0": [0, 20],
|
||||
"T16 mono1 T11 T5 R=E+10": [0, 20], "T16 mono1 T11 T5 R=E+40": [20],
|
||||
"T16 mono1 T3 t1 bw=0": [600], "T16 mono1 T3 t1 bw=2000": [700],
|
||||
"T16 mono1 T3 t1 bw=4250": [800], "T16 mono1 T3 t4 bw=0": [600],
|
||||
"T16 mono1 T3 t4 bw=2000": [700], "T16 mono1 T3 t4 bw=4250": [800],
|
||||
}
|
||||
# The T1 cells that reproduce F-B on base (G0): b following the house from R.
|
||||
BASE_REPRO = [f"T1 core bw={bw} t2 rp={rp}" for bw in (0, 400, 800)
|
||||
for rp in (30, 100, 110, 180, 600)] + [
|
||||
"T1 d: x10 wall+mono t2 bw=1200", "T1 d: x10 wall, mono x1 t2 bw=1200"]
|
||||
|
||||
|
||||
def as_base(k):
|
||||
"""The same alarm seconds as base."""
|
||||
return res(k).rel_alarms() == BASE_ALARMS[k]
|
||||
|
||||
# --- T1: the reproduction grid ------------------------------------------------ #
|
||||
T1 = sorted(k for k in JOBS if k.startswith("T1 "))
|
||||
C5 = [k for k in T1 if k.startswith("T1 b: energy")]
|
||||
rep = {k: hits(res(k)) for k in T1}
|
||||
print(f" T1 cells {len(T1)}; reproducing on this tree: "
|
||||
f"{sorted(k for k in T1 if rep[k])}")
|
||||
check("T1: no grid cell reproduces F-B: no notice, ERROR or red sample in "
|
||||
"R-10..R+60 while the car figure is trusted (base: the "
|
||||
f"{len(BASE_REPRO)} tau2 cells with b at 0-800 W at R)",
|
||||
not [k for k in T1 if rep[k]])
|
||||
for k in C5:
|
||||
show(k)
|
||||
check("T1 C5 cells (the energy meter late or never stepping): the figure is "
|
||||
"untrusted (contradicted or unknown) wherever the alarm stands, as EV-18 "
|
||||
"Expected 5 wants", all(not trusted(x) for k in C5
|
||||
for x in res(k).win(-10, 60) if bad(x)))
|
||||
|
||||
# --- T2: THE red-before test -------------------------------------------------- #
|
||||
T2 = BASE_REPRO
|
||||
for k in T2:
|
||||
r = res(k)
|
||||
lim = [x for x in r.win(0, 60) if x["floor_lim"]]
|
||||
check(f"T2 {k[3:]}: no notice, no ERROR, no red sample R-60..R+900; the "
|
||||
f"car explains every floor-limited cycle of R..R+60",
|
||||
r.quiet(-60, 900) and bool(lim) and all(x["explains"] for x in lim))
|
||||
check("T2 PRECONDITION: every reproducing cell is in the grid (b at 0, 400, "
|
||||
"800 W x 5 plug-in times; x10 and mono x1 with b at 1 200 W)",
|
||||
len(T2) == 17 and all(k in RES for k in T2))
|
||||
r2 = res("T1 core bw=0 t2 rp=180")
|
||||
x1 = r2.at(1)
|
||||
check("T2 PRECONDITION: in the rise cycle the reading shows b's 4 600 W, the "
|
||||
"guard is floor-limited and wants power",
|
||||
present(x1) and x1["batt"] == 4600.0 and x1["floor_lim"]
|
||||
and x1["wants"])
|
||||
|
||||
# --- T3: the battery W sweep --------------------------------------------------- #
|
||||
T3 = sorted(k for k in JOBS if k.startswith("T3 "))
|
||||
loud = [k for k in T3 if not res(k).quiet(-60, 900)]
|
||||
print(f" T3 cells {len(T3)}, with an alarm or red sample: {loud}")
|
||||
check("T3: tau1 and tau2, b at R 0..4 600 W in 200 W steps and 9 600 W "
|
||||
"(tau5): no alarm and no red sample in any cell", loud == [])
|
||||
|
||||
# --- T4 controller ------------------------------------------------------------- #
|
||||
for k in ("T4 +9 manual", "T4 +11 manual", "T4 +11 off"):
|
||||
show(k)
|
||||
check("T4: the house alone at aim + 9 W, b following the house from R: no "
|
||||
"alarm (base: R+1)", res("T4 +9 manual").quiet(-60, 900))
|
||||
check("T4: at aim + 11 W the alarm in the same cycle as base and as Off "
|
||||
"(R+0)", as_base("T4 +11 manual")
|
||||
and res("T4 +11 manual").rel_alarms()[:1]
|
||||
== res("T4 +11 off").rel_alarms()[:1] == [0])
|
||||
|
||||
|
||||
# --- T5 / T6: honest alarms ---------------------------------------------------- #
|
||||
def same_as_off(k):
|
||||
on, off = res(f"{k} manual"), res(f"{k} off")
|
||||
show(f"{k} manual")
|
||||
show(f"{k} off")
|
||||
a = on.rel_alarms()
|
||||
return (bool(a) and a == off.rel_alarms()
|
||||
and on.errors() == off.errors())
|
||||
|
||||
|
||||
for k in ("T5 t1", "T5 t4", "T5 tau5"):
|
||||
check(f"{k}: the excess is more than the car: PEAK_GUARD_FLOOR_LIMITED, "
|
||||
f"the ERROR and the notice at the same second as Off and as base",
|
||||
same_as_off(k) and as_base(f"{k} manual"))
|
||||
check(f"{k}: the car explains no cycle",
|
||||
not any(x["explains"] for x in res(f"{k} manual").tr))
|
||||
for n in (0, 1, 5):
|
||||
k = f"T6 step R+{n}"
|
||||
show(f"{k} manual")
|
||||
check(f"{k}: the house steps to aim + 1 900 W at R+{n}: the alarm and "
|
||||
f"the ERROR at the same second as base, R+{BASE_ALARMS[k + ' manual'][0]}"
|
||||
f" (no grace, no hold; Off alarms from R+0, where the car explains)",
|
||||
as_base(f"{k} manual") and res(f"{k} manual").errors()
|
||||
== BASE_ALARMS[f"{k} manual"])
|
||||
|
||||
|
||||
# --- T7: unknown values -------------------------------------------------------- #
|
||||
def only_while_unknown(r, t0=-60, t1=900):
|
||||
"""Every alarm / red cycle has an untrusted car figure in it or in the
|
||||
cycle before (the alarm clears within 1 cycle of the first trusted one)."""
|
||||
prev = None
|
||||
for x in r.win(t0, t1):
|
||||
if bad(x) and trusted(x) and (prev is None or trusted(prev)):
|
||||
return False
|
||||
prev = x
|
||||
return True
|
||||
|
||||
|
||||
show("T7(a) T2")
|
||||
check("T7(a) T2: inverter-a's reading unknown at R and R+1: no alarm",
|
||||
res("T7(a) T2").quiet(-60, 900))
|
||||
check("T7(a) T5: the alarm at the same second as base and as Off (the "
|
||||
"guard grades nothing without the reading)", as_base("T7(a) T5")
|
||||
and res("T7(a) T5").rel_alarms() == res("T7(a) T5 off").rel_alarms())
|
||||
show("T7(b) T2")
|
||||
check("T7(b) T2: the charger unavailable at R: an alarm only while the "
|
||||
"figure is unknown, cleared within 1 cycle of the first trusted one",
|
||||
only_while_unknown(res("T7(b) T2")))
|
||||
check("T7(b) T5: the alarm at the same second as base and as Off",
|
||||
as_base("T7(b) T5")
|
||||
and res("T7(b) T5").rel_alarms() == res("T7(b) T5 off").rel_alarms())
|
||||
|
||||
# --- T8: a stale car figure ---------------------------------------------------- #
|
||||
r8a = res("T8(a) Off 120 s, Manual R-5")
|
||||
show("T8(a) Off 120 s, Manual R-5")
|
||||
check("T8(a): nothing before Manual is trusted (car_alarm_w None)",
|
||||
all(x["w"] is None for x in r8a.tr if x["t"] < r8a.R - 5))
|
||||
check("T8(a): after Manual, as T2: no alarm R-60..R+900",
|
||||
r8a.quiet(-60, 900))
|
||||
r8b = res("T8(b) stale R-5..R+20")
|
||||
show("T8(b) stale R-5..R+20")
|
||||
check("T8(b) PRECONDITION: the figure goes untrusted (older than 15 s)",
|
||||
any(x["w"] is None for x in r8b.win(0, 25)))
|
||||
check("T8(b): the alarm only while the figure is stale, cleared within 1 "
|
||||
"cycle of the first fresh one", only_while_unknown(r8b))
|
||||
r8c, r8co = res("T8(c) frozen, the car stops"), res("T8(c) off")
|
||||
show("T8(c) frozen, the car stops")
|
||||
a8 = nth(r8c.rel_alarms(), 0)
|
||||
untr = first(int(x["t"] - r8c.R) for x in r8c.tr
|
||||
if x["t"] >= r8c.R - 30 and not trusted(x))
|
||||
check("T8(c): the alarm at base's second, as Off, within 114 s of the stop",
|
||||
present(a8) and a8 <= -30 + 114
|
||||
and as_base("T8(c) frozen, the car stops")
|
||||
and r8c.rel_alarms() == r8co.rel_alarms())
|
||||
check("T8(c): never explained after the figure goes untrusted",
|
||||
present(untr) and not any(x["explains"] for x in r8c.tr
|
||||
if x["t"] >= r8c.R + untr))
|
||||
|
||||
# --- T9: comms ------------------------------------------------------------------ #
|
||||
for nm in ("T2", "T5"):
|
||||
for k in (f"T9(a) {nm} b lost at R", f"T9(a) {nm} b lost at R-1",
|
||||
f"T9(b) {nm} P1 5 s late at R"):
|
||||
show(k)
|
||||
r = res(k)
|
||||
if nm == "T2":
|
||||
check(f"{k}: no alarm edge", r.edges() == [])
|
||||
else:
|
||||
check(f"{k}: the alarm at the base second "
|
||||
f"(R+{BASE_ALARMS[k][0]})", as_base(k))
|
||||
|
||||
# --- T10: a restart ------------------------------------------------------------ #
|
||||
for nm in ("T2", "T5"):
|
||||
tw = res(f"T10 {nm} twin")
|
||||
for k in (-2, -1, 0, 2):
|
||||
r = res(f"T10 {nm} restart R{k:+d}")
|
||||
show(f"T10 {nm} restart R{k:+d}")
|
||||
if nm == "T2" and k == 0:
|
||||
# the rise cycle R+1 has no reading from two cycles back: nothing
|
||||
# is discounted (the old behaviour), so the alarm is base's
|
||||
check("T10 T2 restart at R+0: no reading two cycles back in the "
|
||||
"rise cycle, so no discount: the alarm as base (R+1)",
|
||||
as_base("T10 T2 restart R+0"))
|
||||
elif nm == "T2":
|
||||
check(f"T10 T2 restart at R{k:+d}: no notice, no red sample, as "
|
||||
f"the unrestarted twin", r.quiet(-60, 900)
|
||||
and tw.quiet(-60, 900))
|
||||
else:
|
||||
check(f"T10 T5 restart at R{k:+d}: the alarm at the base second "
|
||||
f"and the twin's, red as the twin",
|
||||
as_base(f"T10 T5 restart R{k:+d}") and as_base("T10 T5 twin")
|
||||
and len(r.red()) == len(tw.red()))
|
||||
|
||||
# --- Review round 1 (Major), controller: the T6 step with a one-cycle burst ---- #
|
||||
for k in (5, 30):
|
||||
for hi in (1900, 2500):
|
||||
for burst in ("3000", "4600"):
|
||||
nm = f"RB step R+{k} aim+{hi} burst {burst} manual"
|
||||
r = res(nm)
|
||||
show(nm)
|
||||
check(f"{nm[:-7]}: P1 and the reading both show the burst: the "
|
||||
f"notice, the ERROR and the first red sample at the step, "
|
||||
f"R+{k}, as base", r.rel_alarms() == [k]
|
||||
and r.errors() == [k] and r.red()[:1] == [k])
|
||||
|
||||
# --- T11: the quarter edge ------------------------------------------------------ #
|
||||
for rr in (-1, 0, 1, 43):
|
||||
r = res(f"T11 T2 R=E{rr:+d}")
|
||||
show(f"T11 T2 R=E{rr:+d}")
|
||||
wa = [(int(x["t"] - r.E), x["within_aim"]) for x in r.tr
|
||||
if r.E - 1 <= x["t"] <= r.E]
|
||||
print(f" T11 T2 R=E{rr:+d}: within_aim at E-1/E+0 {wa} (F1, not "
|
||||
f"asserted)")
|
||||
check(f"T11 T2 R=E{rr:+d}: no alarm across the edge", r.quiet(-60, 900))
|
||||
check(f"T11 T5 R=E{rr:+d}: the alarm at the same seconds as base and "
|
||||
f"as Off", as_base(f"T11 T5 R=E{rr:+d}")
|
||||
and res(f"T11 T5 R=E{rr:+d}").rel_alarms()
|
||||
== res(f"T11 T5 R=E{rr:+d} off").rel_alarms())
|
||||
pre = res("T11 C4 T2 R=E+1")
|
||||
show("T11 C4 T2 R=E+1")
|
||||
wa = [(int(x["t"] - pre.E), x["within_aim"]) for x in pre.tr
|
||||
if pre.E - 1 <= x["t"] <= pre.E]
|
||||
print(f" T11 C4: within_aim at E-1/E+0 {wa} (F1, not asserted)")
|
||||
check("T11 C4 PRECONDITION: the guard wants power in the last 60 s of the "
|
||||
"old quarter (house 13 350 W all along, car 1 380 W)",
|
||||
all(x["wants"] for x in pre.tr if pre.E - 60 <= x["t"] < pre.E))
|
||||
sat = [x for x in pre.win(-60, -1) if x["red"]]
|
||||
print(f" T11 C4: red before R {[int(x['t'] - pre.R) for x in sat]} (near "
|
||||
f"the old quarter's end, the guard saturated: SAFETY-81's row)")
|
||||
check("T11 C4: SAFETY-126's latch carried over the edge, the reserve at "
|
||||
"E+1: no floor notice or ERROR R-60..R+900, no red sample from R; "
|
||||
"before R red only where the guard is saturated (not the floor alarm)",
|
||||
pre.quiet(0, 900) and not [t for t in pre.rel_alarms() if t >= -60]
|
||||
and all(x["lim"] and not x["floor_lim"] and not x["alarm"]
|
||||
for x in sat))
|
||||
|
||||
# --- T12: our own phase change -------------------------------------------------- #
|
||||
for k in (-15, 5):
|
||||
r = res(f"T12 T2 1->3 at R{k:+d}")
|
||||
show(f"T12 T2 1->3 at R{k:+d}")
|
||||
check(f"T12 T2, 1->3 at R{k:+d}: no alarm during our own pause or after",
|
||||
r.quiet(-60, 900))
|
||||
on, off = res(f"T12 T5 1->3 at R{k:+d}"), res(f"T12 T5 1->3 at R{k:+d} off")
|
||||
show(f"T12 T5 1->3 at R{k:+d}")
|
||||
a, ao = nth(on.rel_alarms(), 0), nth(off.rel_alarms(), 0)
|
||||
check(f"T12 T5, 1->3 at R{k:+d}: the alarm at base's second, no later "
|
||||
f"than Off's and within OWN_PAUSE_MAX_S "
|
||||
f"({ctl_car.OWN_PAUSE_MAX_S:.0f} s) of the request",
|
||||
present(a, ao) and a <= ao and as_base(f"T12 T5 1->3 at R{k:+d}")
|
||||
and a <= max(k, 0) + ctl_car.OWN_PAUSE_MAX_S)
|
||||
|
||||
# --- T13: a wrong charger reply ------------------------------------------------- #
|
||||
r13 = res("T13(a) draws 400 W manual")
|
||||
show("T13(a) draws 400 W manual")
|
||||
check("T13(a) 400 W: the energy meter never contradicts a 1 380 W figure "
|
||||
"when 400 W is drawn (CORR_RATIO 0.5 and its slack; EV-18 T9(b)), so "
|
||||
"nothing is uncorroborated and the figure explains; base's R+1 alarm "
|
||||
"was F-B", not any(x["contra"] for x in r13.tr)
|
||||
and all(x["w"] == CAR for x in r13.win(-60, 60)))
|
||||
r13c = res("T13(a) draws 100 W manual")
|
||||
show("T13(a) draws 100 W manual")
|
||||
show("T13(a) draws 100 W off")
|
||||
c0 = first(x["t"] for x in r13c.tr if x["contra"])
|
||||
a13 = nth(r13c.rel_alarms(), 0)
|
||||
check("T13(a) 100 W PRECONDITION: the energy meter contradicts the figure "
|
||||
"within 104 + 10 s of the plug-in (R-180)",
|
||||
present(c0) and c0 <= r13c.R - 180 + 114)
|
||||
check("T13(a) 100 W: the alarm at base's second and Off's, and never "
|
||||
"explained after the contradiction in that quarter",
|
||||
present(a13) and as_base("T13(a) draws 100 W manual")
|
||||
and r13c.rel_alarms() == res("T13(a) draws 100 W off").rel_alarms()
|
||||
and not any(x["explains"] for x in r13c.tr
|
||||
if present(c0) and x["t"] >= c0
|
||||
and x["block"] == r13c.at(0)["block"]))
|
||||
for k in ("T13(b) the write ignored, 0 A", "T14(a) 0 W in C",
|
||||
"T14(a) idle B"):
|
||||
show(f"{k} manual")
|
||||
check(f"{k}: the car at 0 W explains nothing: the alarm as Off",
|
||||
same_as_off(k) and not any(
|
||||
x["explains"] for x in res(f"{k} manual").tr))
|
||||
|
||||
# --- T14: configuration -------------------------------------------------------- #
|
||||
show("T14(b) ev_charger off")
|
||||
check("T14(b) ev_charger off: no explanation, the alarm as Off",
|
||||
res("T14(b) ev_charger off").rel_alarms()
|
||||
== res("T14(b) off").rel_alarms() != []
|
||||
and not any(x["explains"] for x in res("T14(b) ev_charger off").tr))
|
||||
for tj in ("t1", "t4"):
|
||||
show(f"T14(c) N=1 anchor {tj}")
|
||||
check(f"T14(c) N=1 anchor {tj}: no alarm",
|
||||
res(f"T14(c) N=1 anchor {tj}").quiet(-60, 900))
|
||||
check("T14(c) N=1 T5: the alarm at the same second as base and as Off",
|
||||
as_base("T14(c) N=1 T5") and res("T14(c) N=1 T5").rel_alarms()
|
||||
== res("T14(c) N=1 T5 off").rel_alarms())
|
||||
|
||||
# --- T15: one battery first ----------------------------------------------------- #
|
||||
for k in ("T15 anchor manual", "T15 honest manual", "T15 honest off"):
|
||||
show(k)
|
||||
check("T15 anchor: a at the reserve at R, b at R+360: no alarm",
|
||||
res("T15 anchor manual").quiet(-60, 900))
|
||||
check("T15 honest (house 19 000 W): the alarm after ALARM_HOLD_S at the "
|
||||
"base second (R+13; Off R+11, as base)", as_base("T15 honest manual"))
|
||||
|
||||
# --- T16: x10 -------------------------------------------------------------------- #
|
||||
for xn in ("x10", "mono1"):
|
||||
r = res(f"T16 {xn} T2")
|
||||
show(f"T16 {xn} T2")
|
||||
check(f"T16 {xn} T2 PRECONDITION: the rise cycle reads b's 4 600 W",
|
||||
present(r.at(10)) and r.at(10)["batt"] == 4600.0)
|
||||
check(f"T16 {xn} T2: no alarm (base: R+10, 10 red cycles)",
|
||||
r.quiet(-60, 900))
|
||||
t3 = sorted(k for k in JOBS if k.startswith(f"T16 {xn} T3 "))
|
||||
print(f" T16 {xn} T3 alarms "
|
||||
f"{[(k[10:], res(k).rel_alarms()) for k in t3]}")
|
||||
check(f"T16 {xn} T3 ({len(t3)} cells): no alarm R-60..R+300",
|
||||
all(res(k).quiet(-60, 300) for k in t3))
|
||||
# mono x1 / wall x10: the car's energy is counted on the monotonic clock,
|
||||
# a tenth of the wall's, so its share of the quarter is short and the
|
||||
# house latch sets late in the quarter (EV-18 F2, out of scope), as base.
|
||||
check(f"T16 {xn} T3: any later alarm at base's second (EV-18 F2)",
|
||||
all(as_base(k) if k in BASE_ALARMS else res(k).quiet(-60, 900)
|
||||
for k in t3))
|
||||
for k in ("T5", "T6"):
|
||||
show(f"T16 {xn} {k} manual")
|
||||
check(f"T16 {xn} {k}: the alarm at the base second",
|
||||
as_base(f"T16 {xn} {k} manual"))
|
||||
check(f"T16 {xn} T7(b) T2: an alarm only while the figure is unknown",
|
||||
only_while_unknown(res(f"T16 {xn} T7(b) T2")))
|
||||
for rr in (-10, 0, 10, 40):
|
||||
check(f"T16 {xn} T11 T2 R=E{rr:+d}: no alarm",
|
||||
res(f"T16 {xn} T11 T2 R=E{rr:+d}").quiet(-60, 900))
|
||||
check(f"T16 {xn} T11 T5 R=E{rr:+d}: the alarm at the base seconds",
|
||||
as_base(f"T16 {xn} T11 T5 R=E{rr:+d}"))
|
||||
|
||||
# --- T17: no flicker -------------------------------------------------------------- #
|
||||
r17 = res("T17 flicker")
|
||||
print(f" T17 alarm edges per quarter {r17.edges_per_quarter()}")
|
||||
check("T17: the house alone straddles aim + 10 W, the batteries cross the "
|
||||
"reserve 3 times: at most one alarm edge per quarter",
|
||||
all(v <= 1 for v in r17.edges_per_quarter().values()))
|
||||
|
||||
# --- N2: the car explains only with a trusted, non-zero figure ----------------- #
|
||||
bad2 = sorted(k for k, r in RES.items()
|
||||
if any(x["explains"] and not trusted(x) for x in r.tr))
|
||||
check(f"N2: car_explains never True with car_alarm_w None, 0 W or "
|
||||
f"contradicted, in any of the {len(RES)} runs: {bad2}", bad2 == [])
|
||||
|
||||
for k in ("N2 no energy entity", "N2 reports 11 kW at 6 A"):
|
||||
show(f"{k} manual")
|
||||
check(f"{k}: the figure is not trusted for the alarm (no corroboration, "
|
||||
f"or capped by the read-back): nothing explained, the alarm as Off",
|
||||
same_as_off(k) and not any(
|
||||
x["explains"] for x in res(f"{k} manual").tr))
|
||||
check("N2 PRECONDITION: the charger without an energy entity reports a "
|
||||
"fresh 1 380 W", all(x["car_raw"] == CAR for x in
|
||||
res("N2 no energy entity manual").win(-60, 60)))
|
||||
|
||||
# --- N4 / T20: no control change --------------------------------------------- #
|
||||
for nm in ("T2", "T5"):
|
||||
a = res("T1 core bw=0 t2 rp=180") if nm == "T2" else res("T10 T5 twin")
|
||||
check(f"N4 {nm}: the claim, the floor, the setpoints and the charger "
|
||||
f"writes are those of the same run with the car never explaining",
|
||||
a.cmd == res(f"N4 {nm} explain off").cmd)
|
||||
|
||||
# --- N5: at most one floor-alarm edge per quarter ------------------------------ #
|
||||
# Base 43b0db7 has 2 edges in the first quarter of these runs: the guard lets
|
||||
# go for one cycle at R+1 (the battery reads 0 W, the meter does not show it
|
||||
# yet), in Off and in the C5 cells too. Not EV-19's; head must not add one.
|
||||
BASE_TWO = ["T1 b: energy first step late", "T1 b: energy never steps",
|
||||
"T11 T5 R=E+0", "T11 T5 R=E+0 off", "T11 T5 R=E+1",
|
||||
"T11 T5 R=E+1 off", "T16 mono1 T11 T5 R=E+0",
|
||||
"T16 mono1 T11 T5 R=E+10", "T16 mono1 T6 off",
|
||||
"T16 x10 T11 T5 R=E+0", "T16 x10 T11 T5 R=E+10", "T16 x10 T6 off",
|
||||
"T6 step R+0 off", "T6 step R+1 off", "T6 step R+5 off"] + [
|
||||
f"RB step R+{k} aim+{hi} burst {b} off" for k in (5, 30)
|
||||
for hi in (1900, 2500) for b in (3000, 4600)]
|
||||
many = sorted(k for k, r in RES.items()
|
||||
if any(v > (2 if k in BASE_TWO and q == 0 else 1)
|
||||
for q, v in r.edges_per_quarter().items()))
|
||||
check(f"N5: at most one floor-alarm edge per quarter in every run, and no "
|
||||
f"more than base where base has two ({len(RES)} runs): {many}",
|
||||
many == [])
|
||||
|
||||
print()
|
||||
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
||||
sys.exit(1 if fails else 0)
|
||||
@@ -0,0 +1,936 @@
|
||||
"""EV-28: the phases are never selected while the car still draws.
|
||||
`python3 -B test_ev28.py`
|
||||
|
||||
The stage "zero" of the phase sequence counted mode3 B as quiet whatever the
|
||||
power, and selected anyway after ZERO_WAIT_S. Now: a power reading decides
|
||||
(under QUIET_W); mode3 (not C, not D) only without one; a car still drawing at
|
||||
the timeout gets NO select, its current back at once, and one failed try.
|
||||
|
||||
U = the ManualWriter on a stub driver (exact seconds). W = the real Controller
|
||||
on the charger model (`chargersim`, power ramps down at `ramp_w_s`).
|
||||
|
||||
1. U: what counts as quiet (T1, T3, T4, T6, T7, T8).
|
||||
2. W: the rig shapes (T2, T5, T9, T10, T16, T17).
|
||||
3. W: tries, the amber row, the log (T11, T12, T13).
|
||||
4. W: the other ends of a sequence and the alarm (T14, T15, T18-T21).
|
||||
5. W: the digests of the quiet shapes, from 4eba2d9 (T22).
|
||||
6. Docs and the module docstring (T25). T23 is in test_ev04 (slow_stop), T24
|
||||
its fuzz. Mutants (T26): see the dev report.
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import hashlib
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime
|
||||
|
||||
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 # noqa: E402
|
||||
from app.carmode import ManualWriter, QUIET_W, ZERO_WAIT_S # noqa: E402
|
||||
from app.carmode import SETTLE_S, PHASE_GAP_S, MAX_TRIES # noqa: E402
|
||||
from app.main import Controller # noqa: E402
|
||||
from app import freshness # noqa: E402
|
||||
from named_absence import nth # noqa: E402
|
||||
from chargersim import FakeHa, SimCharger # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
class _Cap(logging.Handler):
|
||||
def __init__(self):
|
||||
super().__init__(logging.DEBUG)
|
||||
self.rec = []
|
||||
|
||||
def emit(self, r):
|
||||
self.rec.append((r.levelno, r.getMessage()))
|
||||
|
||||
def loud(self, since=0):
|
||||
"""INFO and above from `since` on."""
|
||||
return [m for lv, m in self.rec[since:] if lv >= logging.INFO]
|
||||
|
||||
|
||||
CAP = _Cap()
|
||||
logging.getLogger("goodwe").addHandler(CAP)
|
||||
logging.getLogger("goodwe").setLevel(logging.DEBUG)
|
||||
|
||||
|
||||
def run(coro):
|
||||
return asyncio.run(coro)
|
||||
|
||||
|
||||
# =========================================================================== #
|
||||
# U: the writer on a stub driver
|
||||
# =========================================================================== #
|
||||
class Drv:
|
||||
def __init__(self, phases=1, a=10.0, ok_phases=True):
|
||||
self.log, self.now, self.phases, self.a = [], 0.0, phases, a
|
||||
self.ok_phases = ok_phases
|
||||
|
||||
async def write_current(self, a):
|
||||
self.log.append((self.now, "current", float(a)))
|
||||
self.a = float(a)
|
||||
return True
|
||||
|
||||
async def write_phases(self, n):
|
||||
self.log.append((self.now, "phases", n))
|
||||
if self.ok_phases:
|
||||
self.phases = n
|
||||
return self.ok_phases
|
||||
|
||||
|
||||
class Trk:
|
||||
obs_at = None
|
||||
|
||||
def begin_write(self):
|
||||
pass
|
||||
|
||||
def end_write(self, *_a):
|
||||
pass
|
||||
|
||||
def note_write(self, *_a):
|
||||
pass
|
||||
|
||||
|
||||
async def unit(fn, times=None, want_phases=3, want_a=10.0, clamp_fn=None,
|
||||
n_phases=1, a0=10.0, ok_phases=True):
|
||||
"""0 A is written at t=0. `fn(dt)` is (mode3, power_w) `dt` s later, or None
|
||||
(unavailable). Returns (writer, driver, abandon time or None)."""
|
||||
w, d = ManualWriter(), Drv(phases=n_phases, a=a0, ok_phases=ok_phases)
|
||||
trk = Trk()
|
||||
|
||||
async def step(t, state, power):
|
||||
d.now = float(t)
|
||||
a = d.a
|
||||
r = CH.ChargerReading(available=state is not None, state=state,
|
||||
power_w=power, setpoint_a=a, allowed_a=a,
|
||||
phases_allowed=d.phases)
|
||||
await w.step(d, r, mode="manual", want_a=want_a,
|
||||
want_phases=want_phases, rev=1,
|
||||
clamp=clamp_fn(t) if clamp_fn else 16.0, now=float(t),
|
||||
tracker=trk, writing=True, status="charging",
|
||||
clock=lambda: float(t))
|
||||
await step(0.0, "C", 2300.0)
|
||||
aband = None
|
||||
for t in (times if times is not None else range(1, 41)):
|
||||
x = fn(t)
|
||||
if x is None:
|
||||
await step(t, None, None)
|
||||
else:
|
||||
await step(t, x[0], x[1])
|
||||
if aband is None and w.seq is not None \
|
||||
and w.seq["stage"] == "settle" and w.seq.get("failed") \
|
||||
and not d.log[-1][1] == "phases":
|
||||
aband = t
|
||||
if aband is None and w.seq is None and w.phase_fails:
|
||||
aband = t
|
||||
return w, d, aband
|
||||
|
||||
|
||||
def phases_at(d):
|
||||
return [x for x in d.log if x[1] == "phases"]
|
||||
|
||||
|
||||
print("1. U: WHAT COUNTS AS QUIET")
|
||||
for p in (600.0, 1200.0, 2152.0, 2200.0):
|
||||
w, d, ab = run(unit(lambda t, p=p: ("B", p), range(1, 20)))
|
||||
check(f"T1: B with {p:.0f} W for 19 s: no select ({d.log})",
|
||||
not phases_at(d) and w.seq is not None
|
||||
and w.seq["stage"] == "zero")
|
||||
|
||||
w, d, ab = run(unit(lambda t: ("B", 40.0 if t >= 10 else 2152.0),
|
||||
range(1, 15)))
|
||||
sel = [x[0] for x in phases_at(d)]
|
||||
check(f"T3: the live Alfen shape (B, 2152 W to t0+9, 40 W at t0+10): select "
|
||||
f"at t0+10 and not before ({sel})", sel == [10.0])
|
||||
|
||||
w, d, ab = run(unit(lambda t: ("B", 100.0), range(1, 20)))
|
||||
check("T4: exactly 100.0 W with B: not quiet, no select (strict <)",
|
||||
not phases_at(d))
|
||||
for p, st in ((99.9, "C"), (0.0, "B"), (-5.0, "C")):
|
||||
w, d, ab = run(unit(lambda t, p=p, st=st: (st, p), range(1, 4)))
|
||||
check(f"T4: {p} W with {st}: select on the first step ({d.log})",
|
||||
[x[0] for x in phases_at(d)] == [1.0])
|
||||
|
||||
w, d, ab = run(unit(lambda t: ("B", 30.0) if t >= 20 else ("C", 2000.0),
|
||||
[19.9, 20.0, 21.0]))
|
||||
check(f"T6: quiet first seen at exactly t0+20: select at 20 ({d.log})",
|
||||
[x[0] for x in phases_at(d)] == [20.0])
|
||||
w, d, ab = run(unit(lambda t: ("B", 500.0), [19.9, 20.0, 21.0]))
|
||||
check("T6: still drawing at 19.9: waits; at 20.0: no select, abandoned "
|
||||
f"({d.log}, abandon {ab})",
|
||||
not phases_at(d) and ab == 20.0 and w.phase_fails == 1
|
||||
and d.log[-1] == (20.0, "current", 10.0))
|
||||
w, d, ab = run(unit(lambda t: ("B", 500.0), [19.9]))
|
||||
check("T6: at 19.9 s the sequence still waits",
|
||||
w.seq is not None and w.seq["stage"] == "zero" and w.phase_fails == 0)
|
||||
|
||||
w, d, ab = run(unit(lambda t: ("B", None), range(1, 4)))
|
||||
check("T7: no power reading and B: select on the first step, as before",
|
||||
[x[0] for x in phases_at(d)] == [1.0])
|
||||
w, d, ab = run(unit(lambda t: ("D", None), range(1, 30)))
|
||||
check("T7/Expected 2: no power reading and D (charging with ventilation) is "
|
||||
"not quiet: no select", not phases_at(d))
|
||||
# state None needs an available reading with state None: own helper
|
||||
async def unit_blind(state):
|
||||
w, d = ManualWriter(), Drv()
|
||||
trk = Trk()
|
||||
for t in range(0, 26):
|
||||
d.now = float(t)
|
||||
a = d.a
|
||||
r = CH.ChargerReading(available=True, state=("C" if t == 0 else state),
|
||||
power_w=2300.0 if t == 0 else None,
|
||||
setpoint_a=a, allowed_a=a,
|
||||
phases_allowed=d.phases)
|
||||
await w.step(d, r, mode="manual", want_a=10.0, want_phases=3, rev=1,
|
||||
clamp=16.0, now=float(t), tracker=trk, writing=True,
|
||||
status="charging", clock=lambda: float(t))
|
||||
return w, d
|
||||
|
||||
|
||||
for st in ("C", None):
|
||||
w, d = run(unit_blind(st))
|
||||
check(f"T8: no power reading, state {st}: no select ever, abandon at "
|
||||
f"t0+20, one restore, one failed try ({d.log})",
|
||||
not phases_at(d) and w.phase_fails == 1 and w.seq is None
|
||||
and d.log == [(0.0, "current", 0.0), (20.0, "current", 10.0)])
|
||||
|
||||
# the abandon is immediate: no SETTLE_S wait (brief answer 1)
|
||||
w, d, ab = run(unit(lambda t: ("C", 900.0), range(1, 26)))
|
||||
check(f"Expected 3: the current comes back at the abandon step itself, not "
|
||||
f"after SETTLE_S ({d.log})",
|
||||
d.log == [(0.0, "current", 0.0), (20.0, "current", 10.0)]
|
||||
and w.last_switch == 20.0)
|
||||
w, d, ab = run(unit(lambda t: ("C", 900.0), range(1, 26),
|
||||
clamp_fn=lambda t: 16.0 if t < 10 else 8.0, want_a=16.0))
|
||||
check(f"N2: the restore is clamped at the abandon ({d.log[-1]})",
|
||||
d.log[-1] == (20.0, "current", 8.0))
|
||||
|
||||
# =========================================================================== #
|
||||
# W: the real Controller on the charger model
|
||||
# =========================================================================== #
|
||||
freshness.monotonic = lambda: CLOCK[0]
|
||||
CLOCK = [1000.0]
|
||||
SET = "number.wallbox_power_connector_max_current_socket_1"
|
||||
BASE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
|
||||
"soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
|
||||
"meter_source": "off", "max_w": 5000, "gain": 0.6, "slew_w": 500,
|
||||
"deadband_w": 15, "target_grid_w": 0, "step_w": 10, "heartbeat_s": 10,
|
||||
"stale_input_s": 15, "shadow_mode": "off", "peak_cap_w": 3500,
|
||||
"pv_entities": ["sensor.pv"]}
|
||||
CAR = dict(BASE, ev_charger="alfen_ha", ev_max_a=16, ev_phases="auto",
|
||||
ev_current_entity=SET)
|
||||
|
||||
|
||||
class _Store:
|
||||
def __init__(self):
|
||||
self.data = {}
|
||||
|
||||
def set(self, k, v):
|
||||
self.data[k] = v
|
||||
|
||||
def get(self, k, d=None):
|
||||
return self.data.get(k, d)
|
||||
|
||||
def set_time(self, k, v):
|
||||
self.data[k] = v.isoformat()
|
||||
|
||||
def get_time(self, k):
|
||||
v = self.data.get(k)
|
||||
return None if v is None else datetime.fromisoformat(v)
|
||||
|
||||
|
||||
class _Pub:
|
||||
enabled = False
|
||||
|
||||
def publish(self, v):
|
||||
pass
|
||||
|
||||
def close(self):
|
||||
pass
|
||||
|
||||
|
||||
class Site(FakeHa):
|
||||
def __init__(self, charger, grid=500.0, batt=0.0, pv=2000.0):
|
||||
super().__init__(charger, None)
|
||||
self.grid, self.batt, self.pv = grid, batt, pv
|
||||
|
||||
async def limits(self, _e):
|
||||
return (-5000.0, 5000.0, 1.0)
|
||||
|
||||
def _all(self):
|
||||
out = super()._all()
|
||||
for eid, val, unit_ in (("sensor.grid", self.grid, "W"),
|
||||
("sensor.soc", 50.0, "%"),
|
||||
("sensor.batt", self.batt, "W"),
|
||||
("sensor.pv", self.pv, "W")):
|
||||
out[eid] = {"entity_id": eid, "state": str(val),
|
||||
"attributes": {"unit_of_measurement": unit_}}
|
||||
return out
|
||||
|
||||
async def number(self, entity_id, invert=False):
|
||||
s = self._all().get(entity_id)
|
||||
try:
|
||||
v = float(s["state"])
|
||||
except (TypeError, ValueError, KeyError):
|
||||
return None
|
||||
return -v if invert else v
|
||||
|
||||
async def set_number(self, entity_id, value):
|
||||
if entity_id == "number.sp":
|
||||
self.sets.append((entity_id, float(value)))
|
||||
self.batt = float(value)
|
||||
return True
|
||||
return await super().set_number(entity_id, float(value))
|
||||
|
||||
|
||||
class World:
|
||||
def __init__(self, opts=CAR, sim=None, store=None, setpoint=10, grid=800.0,
|
||||
phases=1):
|
||||
self.sim = sim or SimCharger(setpoint_a=setpoint)
|
||||
self.sim.plug_in()
|
||||
self.sim.phases_allowed = phases
|
||||
self.site = Site(self.sim, grid=grid)
|
||||
self.store = store or _Store()
|
||||
self.t = 1000.0
|
||||
CLOCK[0] = self.t
|
||||
self.make(opts)
|
||||
|
||||
def make(self, opts):
|
||||
self.opts = dict(opts)
|
||||
self.c = Controller(dict(opts), self.site, self.store, _Pub(),
|
||||
stop=asyncio.Event())
|
||||
self.c.auto = True
|
||||
self.c.dev_min, self.c.dev_max = -5000.0, 5000.0
|
||||
self.drv = self.c.charger
|
||||
if hasattr(self.drv, "_sleep"):
|
||||
self.drv._sleep = self.sleep
|
||||
self.drv._clock = lambda: CLOCK[0]
|
||||
|
||||
async def sleep(self, s):
|
||||
self.sim.tick(s)
|
||||
self.t += s
|
||||
CLOCK[0] = self.t
|
||||
|
||||
async def step(self, n=1, dt=1.0):
|
||||
for _ in range(n):
|
||||
self.sim.tick(dt)
|
||||
self.t += dt
|
||||
CLOCK[0] = self.t
|
||||
await self.c.read_inputs(now_mono=self.t)
|
||||
await self.c.cycle()
|
||||
await self.c.car_settle()
|
||||
|
||||
async def step_race(self, n=1, dt=1.0):
|
||||
for _ in range(n):
|
||||
self.sim.tick(dt)
|
||||
self.t += dt
|
||||
CLOCK[0] = self.t
|
||||
await self.c.read_inputs(now_mono=self.t)
|
||||
await self.c.car_settle()
|
||||
await self.c.cycle()
|
||||
|
||||
async def act(self, what, value):
|
||||
return await self.c.handle_action(what, value=value)
|
||||
|
||||
def writes(self, what=None):
|
||||
return self.sim.writes(what)
|
||||
|
||||
def rows(self):
|
||||
return {r["id"]: r for r in self.c.checks()}
|
||||
|
||||
@property
|
||||
def wr(self):
|
||||
return self.c.car_writer
|
||||
|
||||
|
||||
async def ready(phases=1, a=10, to=3, ramp=200.0, delay=1.0, opts=CAR,
|
||||
station=None):
|
||||
"""The car draws `a` A on `phases`; the add-on is in Manual at `a`; the
|
||||
sim's power then falls at `ramp` W/s and B comes `delay` s after 0 A."""
|
||||
w = World(opts, setpoint=a, phases=phases)
|
||||
if station:
|
||||
w.sim.station_a = float(station)
|
||||
await w.step(8)
|
||||
await w.act("car_phases", phases) # the wish is what the car has
|
||||
await w.act("car_mode", "manual")
|
||||
await w.act("car_current", a)
|
||||
await w.step(8)
|
||||
w.sim.ramp_w_s, w.sim.stop_delay_s = ramp, delay
|
||||
w.n0 = len(w.writes())
|
||||
MARK[0] = len(CAP.rec)
|
||||
await w.act("car_phases", to)
|
||||
return w
|
||||
|
||||
|
||||
def t_zero(w):
|
||||
z = [x for x in w.writes("current")[w.n0 // 1:] if x[2] == 0.0]
|
||||
z = [x for x in w.writes("current") if x[2] == 0.0]
|
||||
return z[-1][0] if z else None
|
||||
|
||||
|
||||
def seqw(w):
|
||||
return [(x[1], x[2]) for x in w.writes()[w.n0:]]
|
||||
|
||||
|
||||
print("\n2. W: THE RIG SHAPES")
|
||||
|
||||
|
||||
MARK = [0]
|
||||
|
||||
|
||||
async def t2():
|
||||
w = await ready(1, 10, 3)
|
||||
await w.step(60)
|
||||
return w
|
||||
|
||||
|
||||
w = run(t2())
|
||||
t0 = t_zero(w)
|
||||
ph = w.writes("phases")
|
||||
check(f"T2: 1 ph 10 A at 2300 W -> 3 ph: writes are exactly [0, phases 3, "
|
||||
f"10] ({seqw(w)})", seqw(w) == [("current", 0.0), ("phases", 3),
|
||||
("current", 10.0)])
|
||||
check(f"T2: select with power under 100 W ({ph[0][3]:.0f}) and the setpoint "
|
||||
f"at 0 A, at t0+{ph[0][0] - t0:.0f} s",
|
||||
ph[0][3] < QUIET_W and ph[0][4] == 0.0 and 11 <= ph[0][0] - t0 <= 15)
|
||||
check("T2: ends on 3 phases, 10 A, the car draws",
|
||||
w.sim.phases_allowed == 3 and w.sim.readback_a == 10
|
||||
and w.sim.power_w > 6000)
|
||||
check(f"T13: a clean change logs nothing at INFO or above ({CAP.loud(MARK[0])})",
|
||||
CAP.loud(MARK[0]) == [])
|
||||
|
||||
|
||||
async def t5a():
|
||||
w = await ready(1, 16, 3)
|
||||
await w.step(60)
|
||||
return w
|
||||
|
||||
|
||||
w = run(t5a())
|
||||
t0, ph = t_zero(w), w.writes("phases")
|
||||
check(f"T5a: 1 ph 16 A 3680 W -> 3 ph: select at t0+{ph[0][0] - t0:.0f} s "
|
||||
f"with {ph[0][3]:.0f} W, then 16 A ({seqw(w)})",
|
||||
17 <= ph[0][0] - t0 <= 20 and ph[0][3] < QUIET_W
|
||||
and seqw(w)[-1] == ("current", 16.0) and w.sim.phases_allowed == 3)
|
||||
|
||||
|
||||
async def t5b():
|
||||
w = await ready(3, 6, 1)
|
||||
await w.step(60)
|
||||
return w
|
||||
|
||||
|
||||
w = run(t5b())
|
||||
t0 = t_zero(w)
|
||||
rest = [x for x in w.writes("current") if x[2] == 6.0 and x[0] > t0]
|
||||
check(f"T5b: 3 ph 6 A 4140 W -> 1 ph: still 140 W at t0+20: no select, "
|
||||
f"abandon at t0+{nth(rest)[0] - t0:.0f}, restore to 6 A",
|
||||
not w.writes("phases") and 20 <= nth(rest)[0] - t0 <= 21
|
||||
and w.sim.readback_a == 6 and w.wr.phase_fails == 1)
|
||||
|
||||
|
||||
async def t9(extra=None, steps=70, **kw):
|
||||
w = await ready(3, 16, 1, **kw)
|
||||
await w.step(steps)
|
||||
return w
|
||||
|
||||
|
||||
w9 = run(t9())
|
||||
t0 = t_zero(w9)
|
||||
cw = [x for x in w9.writes("current")]
|
||||
rest = [x for x in cw if x[0] > t0]
|
||||
check(f"T9: 3 ph 16 A -> 1 ph, car still ~7 kW at t0+20: no phases write, "
|
||||
f"abandon at t0+{nth(rest)[0] - t0:.0f}, one restore of 16 A "
|
||||
f"({seqw(w9)})",
|
||||
not w9.writes("phases") and 20 <= nth(rest)[0] - t0 <= 21
|
||||
and seqw(w9) == [("current", 0.0), ("current", 16.0)]
|
||||
and nth(rest)[0] <= t0 + 20 + SETTLE_S + 2)
|
||||
check("T9: phases stay 3, the car draws again, one failed try, not given up, "
|
||||
"no amber row, sequence over",
|
||||
w9.sim.phases_allowed == 3 and w9.sim.power_w > 6000
|
||||
and w9.wr.phase_fails == 1 and not w9.wr.phases_gave_up
|
||||
and "charger_phases" not in w9.rows() and w9.wr.seq is None)
|
||||
check("Expected 3: the next try counts PHASE_GAP_S from the abandon",
|
||||
w9.wr.last_switch is not None
|
||||
and abs(w9.wr.last_switch - (nth(rest)[0] + w9.t - w9.sim.t)) <= 1.5)
|
||||
|
||||
|
||||
async def t10():
|
||||
w = await ready(3, 16, 1)
|
||||
await w.step(10)
|
||||
w.sim.station_a = 10.0
|
||||
await w.step(60)
|
||||
return w
|
||||
|
||||
|
||||
w = run(t10())
|
||||
t0 = t_zero(w)
|
||||
after = [x for x in w.writes("current") if x[0] > t0]
|
||||
check(f"T10/N2: the station limit drops to 10 A during zero: the restore is "
|
||||
f"10 A and nothing above it ({[x[2] for x in after]})",
|
||||
after and after[0][2] == 10.0 and all(x[2] <= 10.0 for x in after)
|
||||
and not w.writes("phases"))
|
||||
|
||||
|
||||
async def t16():
|
||||
w = await ready(1, 10, 3)
|
||||
await w.step(1) # 0 A is written, the car at 2300 W
|
||||
w.sim.freeze_power()
|
||||
await w.step(60)
|
||||
return w
|
||||
|
||||
|
||||
w = run(t16())
|
||||
t0 = t_zero(w)
|
||||
rest = [x for x in w.writes("current") if x[0] > t0]
|
||||
check(f"T16/N5: the power sensor stuck at 2300 W while the car stops: no "
|
||||
f"select, abandon at t0+{nth(rest)[0] - t0:.0f}, restore 10 A",
|
||||
not w.writes("phases") and 20 <= nth(rest)[0] - t0 <= 21
|
||||
and nth(rest)[2] == 10.0 and w.wr.phase_fails == 1)
|
||||
|
||||
|
||||
async def t17(ramp):
|
||||
w = await ready(1, 10, 3, ramp=ramp, delay=1.0)
|
||||
await w.step(1)
|
||||
w.sim.go_unavailable()
|
||||
n = len(w.sim.log)
|
||||
await w.step(28) # t0+2 .. t0+30
|
||||
during = len(w.sim.log) - n
|
||||
w.sim.go_unavailable(False)
|
||||
n1 = len(w.writes())
|
||||
await w.step(3)
|
||||
first = w.writes()[n1:]
|
||||
await w.step(40)
|
||||
return w, during, first
|
||||
|
||||
|
||||
w, during, first = run(t17(50.0))
|
||||
check(f"T17a: back after 30 s at ~800 W: no write while unavailable, no "
|
||||
f"select, then the restore ({[x[1:3] for x in first]})",
|
||||
during == 0 and not w.writes("phases") and w.sim.readback_a == 10
|
||||
and w.wr.phase_fails == 1)
|
||||
w, during, first = run(t17(200.0))
|
||||
ph = w.writes("phases")
|
||||
check(f"T17b: back at 0 W: the select at the first available step "
|
||||
f"({first[0][1:3] if first else None}), power {ph[0][3]:.0f} W",
|
||||
during == 0 and first and first[0][1] == "phases"
|
||||
and ph[0][3] < QUIET_W and w.sim.phases_allowed == 3)
|
||||
|
||||
print("\n3. W: TRIES, THE AMBER ROW, THE LOG")
|
||||
|
||||
|
||||
async def t11():
|
||||
w = await ready(3, 16, 1)
|
||||
mark = len(CAP.rec)
|
||||
await w.step(1900)
|
||||
zeros = [x[0] for x in w.writes("current") if x[2] == 0.0]
|
||||
rests = [x[0] for x in w.writes("current") if x[2] == 16.0
|
||||
and x[0] > nth(zeros)]
|
||||
out = dict(zeros=zeros, rests=rests, ph=len(w.writes("phases")),
|
||||
gave=w.wr.phases_gave_up, row=w.rows().get("charger_phases"),
|
||||
loud=CAP.loud(mark), w=w)
|
||||
await w.step(1200)
|
||||
out["more"] = len([x for x in w.writes("current") if x[2] == 0.0])
|
||||
n = len([x for x in w.writes("current") if x[2] == 0.0])
|
||||
await w.act("car_phases", 1) # same wish, a user change
|
||||
await w.act("car_phases", 3)
|
||||
await w.act("car_phases", 1)
|
||||
await w.step(60)
|
||||
out["after_user"] = len([x for x in w.writes("current")
|
||||
if x[2] == 0.0]) - n
|
||||
return out
|
||||
|
||||
|
||||
o = run(t11())
|
||||
z, rs = o["zeros"], o["rests"]
|
||||
check(f"T11: 3 zero writes, 0 phases writes, 3 restores ({len(z)}, {o['ph']},"
|
||||
f" {len(rs)})", len(z) == 3 and o["ph"] == 0 and len(rs) == 3)
|
||||
check("T11: the 2nd and 3rd 0 A come PHASE_GAP_S after the abandon of the "
|
||||
"one before",
|
||||
len(z) == 3 and len(rs) == 3 and all(z[i] - z[i - 1] >= PHASE_GAP_S
|
||||
and z[i] <= rs[i - 1] + PHASE_GAP_S + SETTLE_S + 2
|
||||
for i in (1, 2)))
|
||||
check("T11: after the 3rd the add-on gives up: amber row, no 4th 0 A in "
|
||||
"1200 s", o["gave"] and o["row"] is not None and o["row"]["ok"] is False
|
||||
and o["row"]["warn"] is True and o["more"] == 3)
|
||||
check("T11: a user change after the give-up tries again at once (one 0 A)",
|
||||
o["after_user"] == 1)
|
||||
check(f"T13: one 'kept drawing' line per abandon (3) plus the one "
|
||||
f"CHARGER_PHASES warning, nothing else, no ERROR ({o['loud']})",
|
||||
len(o["loud"]) == 4 and sum("CHARGER_PHASES" in m for m in o["loud"]) == 1
|
||||
and not [1 for lv, _m in CAP.rec if lv >= logging.ERROR])
|
||||
|
||||
|
||||
async def t12():
|
||||
w = await ready(3, 16, 1)
|
||||
await w.step(40) # try 1: abandoned
|
||||
real = w.sim.request_phases
|
||||
w.sim.ramp_w_s = 3000.0
|
||||
w.sim.request_phases = lambda n: False # refused select
|
||||
await w.step(int(PHASE_GAP_S) + 60) # try 2
|
||||
mid = w.wr.phase_fails
|
||||
w.sim.request_phases = real
|
||||
w.sim.ramp_w_s = 200.0
|
||||
await w.step(int(PHASE_GAP_S) + 60) # try 3: abandoned
|
||||
n = len(w.writes("current"))
|
||||
await w.step(1500)
|
||||
return w, mid, len(w.writes("current")) - n
|
||||
|
||||
|
||||
w, mid, extra = run(t12())
|
||||
check(f"T12: abandon, refused select, abandon share one count: 2 after try 2 "
|
||||
f"({mid}), given up after try 3, amber row, no 4th try",
|
||||
mid == 2 and w.wr.phases_gave_up and w.wr.phase_fails == 3
|
||||
and "charger_phases" in w.rows() and extra == 0)
|
||||
|
||||
print("\n4. W: THE OTHER ENDS OF A SEQUENCE, THE ALARM")
|
||||
|
||||
|
||||
async def t18():
|
||||
w = await ready(3, 16, 1)
|
||||
await w.step(5)
|
||||
await w.c.car_shutdown()
|
||||
n = len(w.writes())
|
||||
mark = w.writes()[w.n0:]
|
||||
st = (w.wr.seq, w.wr.phase_fails, w.sim.readback_a)
|
||||
w.make(w.opts)
|
||||
await w.step(60)
|
||||
return w, st, mark, w.writes()[n:]
|
||||
|
||||
|
||||
w, st, mark, later = run(t18())
|
||||
check(f"T18: shutdown at t0+5 with the car drawing: one clamped restore (16 "
|
||||
f"A), no select, sequence over, no failed try ({mark})",
|
||||
[(x[1], x[2]) for x in mark] == [("current", 0.0), ("current", 16.0)]
|
||||
and st == (None, 0, 16.0))
|
||||
ok = True
|
||||
for i, x in enumerate(later):
|
||||
if x[1] == "phases":
|
||||
ok = ok and any(y[1] == "current" and y[2] == 0.0
|
||||
for y in later[:i]) and x[3] < QUIET_W
|
||||
check(f"T18: after the restart no select unless a new 0 A came first and the "
|
||||
f"car was quiet ({[x[1:3] for x in later]})", ok)
|
||||
|
||||
|
||||
async def t19(how):
|
||||
w = await ready(3, 16, 1)
|
||||
await w.step(5)
|
||||
n = len(w.writes())
|
||||
mark = len(CAP.rec)
|
||||
if how == "off":
|
||||
await w.act("car_mode", "off")
|
||||
elif how == "stop":
|
||||
w.c.auto = False
|
||||
else:
|
||||
w.c.o["shadow_mode"] = "on"
|
||||
await w.step(80)
|
||||
return w, w.writes()[n:], CAP.loud(mark)
|
||||
|
||||
|
||||
for how in ("off", "stop", "shadow"):
|
||||
w, after, loud = run(t19(how))
|
||||
check(f"T19: {how} at t0+5 with the car drawing: `_undo` as before: one "
|
||||
f"restore, no select, nothing after it, not a failed try "
|
||||
f"({[x[1:3] for x in after]})",
|
||||
[(x[1], x[2]) for x in after] == [("current", 16.0)]
|
||||
and not w.writes("phases") and w.wr.phase_fails == 0
|
||||
and not [m for m in loud if "drawing" in m.lower()])
|
||||
|
||||
|
||||
async def t20():
|
||||
w = await ready(3, 16, 1)
|
||||
await w.step(5)
|
||||
mark = len(CAP.rec)
|
||||
n = len(w.writes())
|
||||
w.sim.set_current(9)
|
||||
await w.step(80)
|
||||
return w, w.writes()[n:], CAP.loud(mark)
|
||||
|
||||
|
||||
w, after, loud = run(t20())
|
||||
check(f"T20: another writer sets 9 A at t0+5: hold, grey row, no select, no "
|
||||
f"restore by the add-on, no failed try, no abandon line ({after})",
|
||||
not w.writes("phases") and after == [] and w.wr.hold
|
||||
and "charger_other" in w.rows() and w.wr.phase_fails == 0
|
||||
and not [m for m in loud if "drawing" in m.lower()])
|
||||
|
||||
|
||||
async def t21():
|
||||
w = await ready(3, 16, 1)
|
||||
await w.step(5)
|
||||
await w.act("car_phases", 3) # back to what the car has
|
||||
await w.act("car_current", 12)
|
||||
await w.step(80)
|
||||
return w
|
||||
|
||||
|
||||
w = run(t21())
|
||||
bad = [x for x in w.writes("phases") if x[3] >= QUIET_W]
|
||||
check(f"T21: the user changes phases back and the current at t0+5: no select "
|
||||
f"under load, the new current ends up, nothing above the clamp "
|
||||
f"({seqw(w)})",
|
||||
not bad and w.sim.readback_a == 12 and w.sim.phases_allowed == 3
|
||||
and all(x[2] <= 16.0 for x in w.writes("current")) and w.wr.seq is None)
|
||||
|
||||
|
||||
async def t15():
|
||||
w = await ready(3, 16, 1)
|
||||
calls = []
|
||||
real = w.drv.write_current
|
||||
|
||||
async def spy(a):
|
||||
r = await real(a)
|
||||
calls.append((w.sim.t, a, r))
|
||||
return r
|
||||
w.drv.write_current = spy
|
||||
await w.step(19)
|
||||
w.sim.refuse = "error"
|
||||
await w.step(40)
|
||||
mid = (list(calls), w.wr.seq is None, bool(w.writes("phases")))
|
||||
w.sim.refuse = None
|
||||
await w.step(int(carmode.RETRY_S) + 10)
|
||||
return w, mid
|
||||
|
||||
|
||||
w, (calls, over, anyph) = run(t15())
|
||||
tries = [c for c in calls if c[1] == 16.0]
|
||||
gaps = [round(b[0] - a[0]) for a, b in zip(tries, tries[1:])]
|
||||
check(f"T15: the restore is refused: tried {len(tries)} times ~5 s apart "
|
||||
f"({gaps}), no select, sequence ends",
|
||||
len(tries) == MAX_TRIES and all(4 <= g <= 6 for g in gaps) and over
|
||||
and not anyph and not w.writes("phases"))
|
||||
check("T15: after the refusal ends the current is back at 16 A, never a "
|
||||
"select", w.sim.readback_a == 16 and not w.writes("phases"))
|
||||
|
||||
|
||||
# --- T14: the controller level (the EV-15 harness) ------------------------- #
|
||||
def ctl(extra=None, t_sw=600, new=1):
|
||||
tr = []
|
||||
|
||||
def note(plant, c):
|
||||
tr.append((plant.t, c._car_own_pause(c.car_now()), c.car_explains,
|
||||
c.car_writer.phase_done_at, plant.ch.power_w,
|
||||
c.car_writer.phase_fails))
|
||||
|
||||
def reserve(plant, c):
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda t: 3000.0 + plant.ch.power_w
|
||||
|
||||
def switch(plant, c):
|
||||
asyncio.get_event_loop().create_task(
|
||||
c.handle_action("car_phases", value=new))
|
||||
ev = {t: note for t in range(0, 720)}
|
||||
ev[300] = lambda p, c: (reserve(p, c), note(p, c))
|
||||
ev[t_sw] = lambda p, c: (switch(p, c), note(p, c))
|
||||
for t, fn in (extra or {}).items():
|
||||
prev = ev.get(t, note)
|
||||
ev[t] = (lambda p, c, prev=prev, fn=fn: (fn(p, c), prev(p, c)))
|
||||
sim = SimCharger(setpoint_a=16)
|
||||
sim.ramp_w_s, sim.stop_delay_s = 200.0, 1.0
|
||||
r = P.drive(s81.constant(3000.0), dur=720, rating=12000.0, soc=60.0,
|
||||
cap=6050.0, phases=3, user_a=16, setpoint=16, mode="manual",
|
||||
events=ev, sim=sim)
|
||||
return r, tr, P.ids(r, *P.ALARMS)
|
||||
|
||||
|
||||
logging.disable(logging.CRITICAL)
|
||||
r, tr, al = ctl()
|
||||
logging.disable(logging.NOTSET)
|
||||
ab = [x[0] for x in tr if x[0] > 600 and x[5] == 1]
|
||||
a0 = ab[0] if ab else None
|
||||
check(f"T14: the car keeps drawing: abandon at {a0}; the own-pause grace is "
|
||||
f"on before it and off from the abandon step on, phase_done_at stays "
|
||||
f"None", a0 is not None and any(x[1] for x in tr if 602 <= x[0] < a0)
|
||||
and not any(x[1] for x in tr if x[0] >= a0)
|
||||
and all(x[3] is None for x in tr) and not r["sim"].writes("phases"))
|
||||
|
||||
|
||||
def overload(plant, c):
|
||||
plant.load = lambda t: 25000.0 + plant.ch.power_w
|
||||
|
||||
|
||||
logging.disable(logging.CRITICAL)
|
||||
r2, tr2, al2 = ctl(extra={640: overload})
|
||||
r3, tr3, al3 = ctl(extra={640: overload}, t_sw=900) # no phase change
|
||||
logging.disable(logging.NOTSET)
|
||||
check(f"T14: a house overload after the abandon alarms, as with no car "
|
||||
f"change ({[t for t, _ in al2]} vs {[t for t, _ in al3]}), and the car "
|
||||
f"does not explain it",
|
||||
bool(al2) and bool(al3) and al2[0][0] == al3[0][0]
|
||||
and not any(x[2] for x in tr2 if x[0] >= 642))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n5. W: THE DIGESTS OF THE QUIET SHAPES, PINNED FROM 4eba2d9")
|
||||
# =========================================================================== #
|
||||
|
||||
|
||||
async def d_story(lag=0.0, race=False):
|
||||
w = World(setpoint=10, phases=1)
|
||||
w.sim.lag_s = lag
|
||||
await w.step(8)
|
||||
await w.act("car_mode", "manual")
|
||||
await w.act("car_current", 10)
|
||||
await w.step(5)
|
||||
await w.act("car_phases", 3)
|
||||
await (w.step_race(60) if race else w.step(60))
|
||||
return w
|
||||
|
||||
|
||||
async def d_gap():
|
||||
w = await d_story()
|
||||
await w.act("car_phases", 1)
|
||||
await w.step(620)
|
||||
return w
|
||||
|
||||
|
||||
async def d_zero_refused():
|
||||
w = World(setpoint=10, phases=1)
|
||||
await w.step(8)
|
||||
await w.act("car_mode", "manual")
|
||||
await w.act("car_current", 10)
|
||||
await w.step(3)
|
||||
w.sim.refuse = "ignore"
|
||||
await w.act("car_phases", 3)
|
||||
await w.step(80)
|
||||
return w
|
||||
|
||||
|
||||
async def d_m2():
|
||||
w = World(setpoint=10, phases=1)
|
||||
await w.step(8)
|
||||
await w.act("car_mode", "manual")
|
||||
await w.act("car_current", 10)
|
||||
await w.step(5)
|
||||
sim = w.sim
|
||||
|
||||
def deaf(n):
|
||||
sim.log.append((sim.t, "phases", n, sim.power_w, sim.setpoint_a))
|
||||
return True
|
||||
sim.request_phases = deaf
|
||||
await w.act("car_phases", 3)
|
||||
await w.step(3700)
|
||||
return w
|
||||
|
||||
|
||||
async def d_l4():
|
||||
w = World(setpoint=10, phases=1)
|
||||
await w.step(8)
|
||||
await w.act("car_mode", "manual")
|
||||
await w.act("car_current", 10)
|
||||
await w.step(5)
|
||||
sim = w.sim
|
||||
|
||||
def slow(n):
|
||||
sim.log.append((sim.t, "phases", n, sim.power_w, sim.setpoint_a))
|
||||
sim._pending.append((sim.t + 12.0, "phases", n))
|
||||
return True
|
||||
sim.request_phases = slow
|
||||
await w.act("car_phases", 3)
|
||||
await w.step(60)
|
||||
return w
|
||||
|
||||
|
||||
async def d_mid(kind):
|
||||
"""The slow-stop car (ramp 50 W/s, C held 40 s) cut short before 20 s."""
|
||||
w = World(dict(CAR, shadow_mode="auto"), setpoint=10, phases=1)
|
||||
w.sim.ramp_w_s, w.sim.stop_delay_s = 50.0, 40.0
|
||||
await w.step(60)
|
||||
await w.act("car_mode", "manual")
|
||||
await w.act("car_current", 10)
|
||||
await w.step(3)
|
||||
await w.act("car_phases", 3)
|
||||
await w.step(3)
|
||||
if kind == "off":
|
||||
await w.act("car_mode", "off")
|
||||
elif kind == "shadow":
|
||||
w.c.o["shadow_mode"] = "on"
|
||||
elif kind == "stop":
|
||||
await w.c.handle_action("auto_toggle")
|
||||
elif kind == "shutdown":
|
||||
await w.c.car_shutdown()
|
||||
elif kind == "other":
|
||||
w.sim.set_current(9)
|
||||
await w.step(80)
|
||||
return w
|
||||
|
||||
|
||||
async def d_off():
|
||||
w = World(setpoint=10, phases=1)
|
||||
await w.step(5)
|
||||
await w.act("car_phases", 3)
|
||||
await w.step(60)
|
||||
return w
|
||||
|
||||
|
||||
def digest(w):
|
||||
s = repr([(x[0], x[1], x[2]) for x in w.sim.log])
|
||||
return hashlib.sha256(s.encode()).hexdigest()[:12]
|
||||
|
||||
|
||||
SHAPES = [("phase_story", lambda: d_story()),
|
||||
("phase_story lag 3", lambda: d_story(lag=3.0)),
|
||||
("m1 race", lambda: d_story(race=True)),
|
||||
("phase_gap", d_gap), ("zero_refused", d_zero_refused),
|
||||
("m2_refused", d_m2), ("l4_late", d_l4), ("phases_in_off", d_off)] \
|
||||
+ [(f"mid {k}", (lambda k=k: d_mid(k)))
|
||||
for k in ("off", "shadow", "stop", "shutdown", "other")]
|
||||
# Pinned from 4eba2d9 (python3 -B on the base tree). Two shapes CHANGE by
|
||||
# design, because the base selected under load in them: `phase_gap` (second
|
||||
# switch: base selected at t0+1 with 3900 W, now t0+3 under 100 W, the same
|
||||
# writes otherwise) and `mid shutdown` (the restarted sequence met a car at
|
||||
# 1250 W: base selected at the timeout, now abandons and restores). Their pins
|
||||
# are the new digests; the facts are asserted below.
|
||||
PINS = {"phase_story": "9e7d818e1304", "phase_story lag 3": "13bba7ca8427",
|
||||
"m1 race": "0f845c466111", "phase_gap": "467fad0b4ebe",
|
||||
"zero_refused": "041e96466f8e", "m2_refused": "5ea1b28f8c3a",
|
||||
"l4_late": "50248d297e1d", "phases_in_off": "4f53cda18c2b",
|
||||
"mid off": "b62df7ce65eb", "mid shadow": "b62df7ce65eb",
|
||||
"mid stop": "b62df7ce65eb", "mid shutdown": "5cae419f3e9f",
|
||||
"mid other": "0f43ad8a061a"}
|
||||
got = {name: digest(run(fn())) for name, fn in SHAPES}
|
||||
_g = run(d_gap())
|
||||
_p = _g.writes("phases")
|
||||
check("T22: the changed shapes are changed only where base selected under "
|
||||
f"load: phase_gap's 2nd select is under 100 W ({_p[1][3]:.0f} W)",
|
||||
len(_p) == 2 and _p[1][3] < QUIET_W)
|
||||
check("T22: digests: " + ", ".join(f"{k}={v}" for k, v in got.items()),
|
||||
all(PINS.get(k) == v for k, v in got.items()) and set(PINS) == set(got))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n6. DOCS (T25)")
|
||||
# =========================================================================== #
|
||||
doc = open(os.path.join(HERE, "DECISIONS", "EV-04-manual-mode.md"),
|
||||
encoding="utf-8").read()
|
||||
phase = doc.split("## The phase sequence")[1].split("\n## ")[0]
|
||||
flat = " ".join(phase.split())
|
||||
check("T25: DECISIONS says: under 100 W with a power reading, mode3 leaving C "
|
||||
"only without one, still drawing at 20 s gives the current back and "
|
||||
"counts as a failed try",
|
||||
"under 100 W" in flat and "no power reading" in flat
|
||||
and "failed try" in flat and "current comes back" in flat
|
||||
and "or mode3 leaves C (20 s at most)" not in flat)
|
||||
src = carmode.__doc__
|
||||
check("T25: the module docstring matches (power reading first, then mode3, "
|
||||
"then the failed try)",
|
||||
"without a power reading" in " ".join(src.split())
|
||||
and "failed" in src and "or mode3 leaves C" not in src)
|
||||
|
||||
print()
|
||||
if fails:
|
||||
print(f"FAIL: {len(fails)} check(s)")
|
||||
for f in fails:
|
||||
print(" -", f)
|
||||
sys.exit(1)
|
||||
print("ok: EV-28")
|
||||
@@ -0,0 +1,779 @@
|
||||
"""EV-19: the real Controller, N=2, when the batteries first reach the peak
|
||||
reserve `R` early in a Manual car session (EV-15 F-B). Used by test_ev19.py.
|
||||
|
||||
python3 tools/ev19_reserve.py # the T1 grid, one row per cell
|
||||
|
||||
The units stand at 21 % and give `bw` W (`force`) until `R`, where both read
|
||||
19 %; after `R` they follow the trajectory `traj`. The house is set so that
|
||||
house + car with the batteries at 0 W lands at aim + `over` W (F-B: +520 W,
|
||||
less than the 1 380 W car). Manual is set, then the car plugs in, `rp` s
|
||||
before `R`. The run starts `E` s before a quarter edge (rig.BASE moved back),
|
||||
so `R = E + r_rel`. One dict per cycle, taken after it.
|
||||
|
||||
Trajectories after R: t1 both 0 W; t2 a 0 W, b follows the house (the loop
|
||||
below the reserve covers house + car, up to b's rating); t3 both ramp to 0 W
|
||||
over 3 cycles; t4 as t1, but every battery reading is 10 s old (the rig reads
|
||||
battery W every 10 fake s, P1 every 5) while P1 is fresh; t4r as t1, but P1
|
||||
is 5 s late while the battery reading is fresh.
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
import os
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, HERE)
|
||||
|
||||
import ev04_peak as P # noqa: E402
|
||||
import ev18_peak as H # noqa: E402
|
||||
import opt11_identity as rig # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
from app import peakguard # noqa: E402
|
||||
from chargersim import SimCharger # noqa: E402
|
||||
|
||||
AIM = H.AIM
|
||||
CAR = 1380.0
|
||||
FLOOR = H.FLOOR
|
||||
RATE = {"a": 5000.0, "b": 4600.0}
|
||||
OPTS = H.OPTS
|
||||
OPTS1 = {"peak_soc_floor": 20, "inverters": [OPTS["inverters"][0]]}
|
||||
|
||||
|
||||
class Meter(SimCharger):
|
||||
"""A charger whose energy meter shows no 10 Wh step until `hold_until`
|
||||
(sim seconds; None: always live, float('inf'): never)."""
|
||||
|
||||
hold_until = None
|
||||
_held = None
|
||||
|
||||
def _build(self):
|
||||
if self.hold_until is None or self.t >= self.hold_until:
|
||||
self._held = None
|
||||
return super()._build()
|
||||
if self._held is None:
|
||||
self._held = self.kwh
|
||||
keep, self.kwh = self.kwh, self._held
|
||||
try:
|
||||
return super()._build()
|
||||
finally:
|
||||
self.kwh = keep
|
||||
|
||||
|
||||
class Draw(Meter):
|
||||
"""A charger that draws `real_w` while charging and reports `say_w`
|
||||
(as test_ev18's). `c_at_0`: it stays in mode3 C while drawing 0 W."""
|
||||
|
||||
def __init__(self, real_w, say_w, c_at_0=False, **kw):
|
||||
super().__init__(**kw)
|
||||
self.real_w, self.say_w, self.c_at_0 = real_w, say_w, c_at_0
|
||||
|
||||
def target_w(self):
|
||||
if super().target_w() <= 0.0:
|
||||
return 0.0
|
||||
return self.real_w
|
||||
|
||||
def tick(self, seconds=1.0):
|
||||
super().tick(seconds)
|
||||
if self.c_at_0 and self.state == "B" and not self.full:
|
||||
self.state = "C"
|
||||
|
||||
def _build(self):
|
||||
keep, self._frozen_w = self._frozen_w, self.say_w
|
||||
try:
|
||||
return super()._build()
|
||||
finally:
|
||||
self._frozen_w = keep
|
||||
|
||||
|
||||
class Plant(H.Plant):
|
||||
"""`batt_lag`: every battery reading is that many s old. `p1_lag` with
|
||||
`p1_from`: P1 that many s late from that second on."""
|
||||
|
||||
batt_lag = 0.0
|
||||
p1_lag = 0.0
|
||||
p1_from = 0.0
|
||||
house = None
|
||||
|
||||
def batt_of(self, u, at):
|
||||
f = self.force.get(u)
|
||||
if f is not None:
|
||||
return float(f(at, self))
|
||||
return P.CarPlantN.batt_of(self, u, at)
|
||||
|
||||
def grid(self, at):
|
||||
if self.p1_lag and at >= self.p1_from:
|
||||
at = at - self.p1_lag
|
||||
return super().grid(at)
|
||||
|
||||
async def number(self, e, invert=False):
|
||||
for u, secs in self.lost.items():
|
||||
if e == "sensor.batt_" + u and int(self.t) in secs:
|
||||
return None
|
||||
if self.batt_lag and e.startswith("sensor.batt_") \
|
||||
and e[-1] in self.socs:
|
||||
return self.batt_of(e[-1], self.t - self.batt_lag)
|
||||
return await P.CarPlantN.number(self, e, invert)
|
||||
|
||||
|
||||
def split(bw, units="ab"):
|
||||
"""`bw` over the units, each capped at its rating."""
|
||||
if len(units) == 1:
|
||||
return {units: min(bw, RATE[units])}
|
||||
a = min(RATE["a"], bw / 2.0)
|
||||
b = min(RATE["b"], bw - a)
|
||||
a = min(RATE["a"], bw - b)
|
||||
return {"a": a, "b": b}
|
||||
|
||||
|
||||
def traj_fn(u, traj, before, R, house, step=1):
|
||||
"""Unit `u`'s W at time `at`: `before` until the first cycle after R
|
||||
(R + `step`), then the trajectory. P1 is sampled 0.3 s before each cycle,
|
||||
so the battery reading shows a change one cycle before the meter does."""
|
||||
def f(at, plant):
|
||||
if at < R + step:
|
||||
return before
|
||||
if traj in ("t1", "t4", "t4r"):
|
||||
return 0.0
|
||||
if traj == "t2":
|
||||
if u == "a":
|
||||
return 0.0
|
||||
return min(RATE["b"], house(at) + plant.ch.power_w)
|
||||
if traj == "t3":
|
||||
k = int((at - R) // step)
|
||||
return before * max(0.0, (3 - k) / 3.0)
|
||||
if traj == "keep":
|
||||
return before
|
||||
raise ValueError(traj)
|
||||
return f
|
||||
|
||||
|
||||
def run(*, bw=4250.0, traj="t1", rp=180, r_rel=43, order="manual",
|
||||
energy="ok", x=1, mono_x=None, aim=AIM, over=520.0, house_w=None,
|
||||
house_fn=None, car_a=6, n=2, extra=None, rel=None, lost=None,
|
||||
after=900,
|
||||
soc_after=None, soc0=21.0, mode="manual", sim=None,
|
||||
explain_off=False, latch_off=False, force=None, plug_at=None,
|
||||
man_at=None, opts=None, pre_w=H.PRE_W):
|
||||
"""One run; returns (run, trace, meta). `over`: house + car at batteries
|
||||
0 W lands at aim + `over` W (ignored with `house_w`). `order`: 'manual'
|
||||
(Manual at plug-in - 3 s), 'plug' (plug-in at R-185, Manual at R-180),
|
||||
'off120' (plug-in and charging in Off from R-180, Manual at R-60).
|
||||
`energy`: 'ok', 'late' (first 10 Wh step at plug-in + 150 s), 'never'.
|
||||
`mode`: 'manual' or 'off' (Off throughout: the base for honest alarms).
|
||||
`house_fn`: fn(t, R) for the house after the step. `extra`: events at
|
||||
run seconds, `rel`: at seconds from R. `lost`: {unit: seconds from R}.
|
||||
`plug_at` / `man_at`: plug-in / Manual at these seconds from R (override
|
||||
`order`). `force`: {unit: fn(at, plant) or None (the unit obeys)}.
|
||||
`opts`: added to the options. `pre_w`: the house before its step."""
|
||||
units = "ab" if n == 2 else "a"
|
||||
step = int(x)
|
||||
if order == "plug":
|
||||
lead = 185
|
||||
elif order == "off120":
|
||||
lead = 180
|
||||
else:
|
||||
lead = rp + 3
|
||||
if plug_at is not None or man_at is not None:
|
||||
lead = -min(v for v in (plug_at, man_at) if v is not None)
|
||||
E = 150
|
||||
while E + r_rel - lead - 2 * step < 10:
|
||||
E += 150
|
||||
E = int(-(-E // step) * step)
|
||||
R = E + r_rel
|
||||
if x != 1:
|
||||
R = int(-(-R // step) * step)
|
||||
hw = (aim + over - CAR) if house_w is None else house_w
|
||||
t_house = min(E - 120, R - lead - step)
|
||||
if x != 1:
|
||||
t_house = int(t_house // step * step)
|
||||
|
||||
def house(t):
|
||||
if t < t_house:
|
||||
return pre_w
|
||||
if house_fn is not None:
|
||||
return house_fn(t, R)
|
||||
return hw
|
||||
|
||||
sp = split(bw, units)
|
||||
frc = {u: traj_fn(u, traj, sp[u], R, house, step) for u in units}
|
||||
frc.update(force or {})
|
||||
soc_after = soc_after or {u: 19.0 for u in units}
|
||||
lagb = 10.0 if traj == "t4" else 0.0
|
||||
cls = type("Plant", (Plant,), {
|
||||
"force": frc, "batt_lag": lagb, "R": R,
|
||||
"lost": {u: {R + k for k in v} for u, v in (lost or {}).items()},
|
||||
"p1_lag": 5.0 if traj == "t4r" else 0.0, "p1_from": float(R)})
|
||||
|
||||
s = sim or Meter(setpoint_a=car_a)
|
||||
if energy == "never":
|
||||
s.hold_until = float("inf")
|
||||
if x != 1:
|
||||
tick = s.tick
|
||||
s.tick = lambda secs=1.0: tick(secs * x)
|
||||
|
||||
if order == "plug":
|
||||
t_plug, t_man = R - 185, R - 180
|
||||
elif order == "off120":
|
||||
t_plug, t_man = R - 180, R - 60
|
||||
else:
|
||||
t_plug, t_man = R - rp, R - rp - 3
|
||||
if plug_at is not None:
|
||||
t_plug = R + plug_at
|
||||
if man_at is not None:
|
||||
t_man = R + man_at
|
||||
if x != 1:
|
||||
t_plug = int(t_plug // step * step)
|
||||
t_man = int(t_man // step * step)
|
||||
if t_man == t_plug and order != "plug":
|
||||
t_man -= step
|
||||
|
||||
tr = []
|
||||
n_err = [len(H.ERR.rec)]
|
||||
|
||||
def hook(plant, c):
|
||||
orig = c.car_settle
|
||||
if explain_off:
|
||||
c._car_explains_alarm = lambda *a_, **k_: False
|
||||
if latch_off:
|
||||
c._car_contradicted = lambda *a_, **k_: False
|
||||
if mono_x is not None and mono_x != x:
|
||||
c.car_now = (lambda f=c.car_now: f() * mono_x / x)
|
||||
|
||||
async def settle():
|
||||
await orig()
|
||||
g = c.peak_guard
|
||||
red = [r_["id"] for r_ in c.checks()
|
||||
if r_["ok"] is False and not r_["warn"]
|
||||
and r_["id"] == "peak_guard"]
|
||||
errs = [m for m in H.ERR.rec[n_err[0]:]
|
||||
if "may not draw the battery lower" in m]
|
||||
n_err[0] = len(H.ERR.rec)
|
||||
cl = peakguard.claim(g) if g is not None else None
|
||||
mono = c.car_now()
|
||||
tr.append({
|
||||
"t": plant.t, "explains": c.car_explains,
|
||||
"lim": bool(g is not None and (g.floor_limited
|
||||
or g.saturated)),
|
||||
"floor_lim": bool(g is not None and g.floor_limited),
|
||||
"within_aim": bool(g is not None and g.within_aim),
|
||||
"wants": bool(g is not None and g.engaged
|
||||
and (g.wanted_w or 0.0) > 0.0),
|
||||
"wanted": None if g is None else g.wanted_w,
|
||||
"target": None if g is None else g.target_w,
|
||||
"alarm": c._peak_floor_limited, "red": red, "err": errs,
|
||||
"w": c.car_alarm_w(), "car_raw": c.car.car_w(mono),
|
||||
"batt": c.site_batt_w,
|
||||
"true_batt": plant.batt(plant.t),
|
||||
"need_real": c._car_need_real, "need_excl": c._car_need_excl,
|
||||
"need_house": c._car_need_house, "over_now": c._car_over_now,
|
||||
"contra": c._car_contra_block is not None and (
|
||||
c._peak_proj_real is not None
|
||||
and c._car_contra_block
|
||||
== c._peak_proj_real.block_start),
|
||||
"idle": c._car_idle(mono), "peak_needed": c._peak_needed,
|
||||
"key": c._carq["key"],
|
||||
"block": (c._peak_proj_real.block_start
|
||||
if c._peak_proj_real is not None else None),
|
||||
"floor_w": g.floor_w if g is not None else None,
|
||||
"lo": getattr(cl, "lo", None),
|
||||
"sp": tuple(i.last_write for i in c.inverters)})
|
||||
c.car_settle = settle
|
||||
|
||||
def set_manual(p, c):
|
||||
c._car_action("car_mode", "manual", c.car_now())
|
||||
|
||||
def plug(p, c):
|
||||
p.ch.plug_in()
|
||||
if energy == "late":
|
||||
p.ch.hold_until = p.ch.t + 150.0
|
||||
|
||||
def reserve(p, c):
|
||||
p.socs.update(soc_after)
|
||||
|
||||
ev = {}
|
||||
|
||||
def add(t, fn):
|
||||
t = int(t)
|
||||
old = ev.get(t)
|
||||
ev[t] = fn if old is None else (
|
||||
lambda p, c, a_=old, b_=fn: (a_(p, c), b_(p, c)))
|
||||
|
||||
add(0, hook)
|
||||
add(t_plug, plug)
|
||||
if mode == "manual":
|
||||
add(t_man, set_manual)
|
||||
add(R, reserve)
|
||||
for t, fn in (extra or {}).items():
|
||||
add(t, fn)
|
||||
for t, fn in (rel or {}).items():
|
||||
add(R + t, fn)
|
||||
base, tick0 = rig.BASE, s81.TICK
|
||||
rig.BASE, s81.TICK = base - timedelta(seconds=E), float(x)
|
||||
o = dict(OPTS if n == 2 else OPTS1, **(opts or {}))
|
||||
try:
|
||||
r = P.drive(house, dur=R + after + step, rating=5000.0,
|
||||
soc={u: soc0 for u in units}, cap=aim + H.MARGIN,
|
||||
phases=1, n=n, plant_cls=cls, opts=o, dev_w=5000.0,
|
||||
setpoint=car_a, user_a=car_a, mode="off", events=ev,
|
||||
sim=s, plug=False)
|
||||
finally:
|
||||
rig.BASE, s81.TICK = base, tick0
|
||||
meta = {"E": E, "R": R, "t_plug": t_plug, "t_man": t_man,
|
||||
"t_house": t_house, "house_w": hw, "step": step}
|
||||
return r, tr, meta
|
||||
|
||||
|
||||
# ---------------------------------------------------------- event helpers
|
||||
# For `rel` (seconds from R) or `extra` (run seconds).
|
||||
def p1_gap(t0, secs):
|
||||
"""No P1 sample reaches the add-on for `secs` from `t0` (it is late)."""
|
||||
def off(p, c):
|
||||
c.p1._ev19_submit = c.p1.submit
|
||||
c.p1.submit = lambda *a, **k: None
|
||||
|
||||
def on(p, c):
|
||||
c.p1.submit = c.p1._ev19_submit
|
||||
return {t0: off, t0 + secs: on}
|
||||
|
||||
|
||||
def stale(t0, t1):
|
||||
"""The charger's readings stop reaching the car tracker from t0 to t1:
|
||||
its figure ages past `stale_s`."""
|
||||
def off(p, c):
|
||||
c.car._ev19_observe = c.car.observe
|
||||
c.car.observe = lambda *a, **k: None
|
||||
|
||||
def on(p, c):
|
||||
c.car.observe = c.car._ev19_observe
|
||||
return {t0: off, t1: on}
|
||||
|
||||
|
||||
def unavailable(t0, t1):
|
||||
return {t0: lambda p, c: p.ch.go_unavailable(True),
|
||||
t1: lambda p, c: p.ch.go_unavailable(False)}
|
||||
|
||||
|
||||
def restart(t0):
|
||||
return {t0: lambda p, c: H.restart(c)}
|
||||
|
||||
|
||||
def phases(t0, n=3):
|
||||
"""The user asks for `n` phases (the add-on's own 0 A pause follows)."""
|
||||
return {t0: lambda p, c: c._car_action("car_phases", n, c.car_now())}
|
||||
|
||||
|
||||
def socs(t0, **s):
|
||||
return {t0: lambda p, c: p.socs.update(s)}
|
||||
|
||||
|
||||
def merge(*evs):
|
||||
out = {}
|
||||
for e in evs:
|
||||
for t, fn in e.items():
|
||||
old = out.get(t)
|
||||
out[t] = fn if old is None else (
|
||||
lambda p, c, a_=old, b_=fn: (a_(p, c), b_(p, c)))
|
||||
return out
|
||||
|
||||
|
||||
# --------------------------------------------------------------- grading
|
||||
def window(tr, t0, t1):
|
||||
return [x for x in tr if t0 <= x["t"] <= t1]
|
||||
|
||||
|
||||
def alarms(r):
|
||||
return H.alarms(r)
|
||||
|
||||
|
||||
def edges(tr):
|
||||
return H.edges(tr)
|
||||
|
||||
|
||||
def bad(x):
|
||||
"""An alarm, red sample or ERROR in this cycle."""
|
||||
return bool(x["alarm"] or x["red"] or x["err"])
|
||||
|
||||
|
||||
def repro(r, tr, meta, t0=-10, t1=60):
|
||||
"""T1's definition: a floor notice, ERROR or red sample in R-10..R+60 in
|
||||
a cycle where the car figure is trusted (the shape lands under the aim
|
||||
without the car, so the car explains). Returns (cycles, C5-only cycles)."""
|
||||
R = meta["R"]
|
||||
w = window(tr, R + t0, R + t1)
|
||||
notes = [t for t in alarms(r) if R + t0 <= t <= R + t1]
|
||||
hit = [x["t"] for x in w if bad(x) and x["w"] is not None
|
||||
and x["w"] > 0.0]
|
||||
c5 = [x["t"] for x in w if bad(x) and not (x["w"] is not None
|
||||
and x["w"] > 0.0)]
|
||||
return hit, c5, notes
|
||||
|
||||
|
||||
def quiet(r, tr, t0, t1):
|
||||
return (not [t for t in alarms(r) if t0 <= t <= t1]
|
||||
and not any(bad(x) for x in window(tr, t0, t1)))
|
||||
|
||||
|
||||
def commands(r, tr):
|
||||
h = hashlib.sha256()
|
||||
for u in sorted(r["plant"].hists):
|
||||
h.update(repr((u, r["plant"].hists[u])).encode())
|
||||
h.update(repr(r["sim"].writes()).encode())
|
||||
h.update(repr([(x["t"], x["floor_w"], x["lo"], x["sp"])
|
||||
for x in tr]).encode())
|
||||
return h.hexdigest()[:16]
|
||||
|
||||
|
||||
def row(name, r, tr, meta):
|
||||
hit, c5, notes = repro(r, tr, meta)
|
||||
R = meta["R"]
|
||||
first = hit[:1]
|
||||
cause = ""
|
||||
if first:
|
||||
x = next(y for y in tr if y["t"] == first[0])
|
||||
cause = (f"w={x['w']:.0f} batt={x['batt']} true={x['true_batt']:.0f}"
|
||||
f" real={x['need_real']:d} excl={x['need_excl']:d} "
|
||||
f"house={x['need_house']:d} over={x['over_now']:d} "
|
||||
f"contra={x['contra']:d} pn={x['peak_needed']:d} "
|
||||
f"wa={x['within_aim']:d} wanted={x['wanted']:.0f}")
|
||||
return (f"{name:42s} R={R:5d} notes {[t - R for t in notes]} "
|
||||
f"hit {[t - R for t in hit][:6]}{'...' if len(hit) > 6 else ''}"
|
||||
f" n={len(hit)} c5 {len(c5)} err "
|
||||
f"{len([x for x in window(tr, R - 10, R + 60) if x['err']])} "
|
||||
f"red900 {len([x for x in window(tr, R - 60, R + 900) if x['red']])}"
|
||||
f" {cause}")
|
||||
|
||||
|
||||
def t2_shape(**kw):
|
||||
"""The reproducing shape (T2): b follows the house from R, 0 W before."""
|
||||
return dict(dict(bw=0.0, traj="t2"), **kw)
|
||||
|
||||
|
||||
def t5_shape(**kw):
|
||||
"""The honest shape (T5): the house alone misses the aim by 1 680 W, more
|
||||
than the 1 380 W car; the batteries give 4 250 W until R."""
|
||||
return dict(dict(bw=4250.0, traj="t1", house_w=AIM + 1680.0), **kw)
|
||||
|
||||
|
||||
def flicker_force(bw=2000.0):
|
||||
"""T17: each unit gives bw/2 above its reserve and ramps to 0 W over 3
|
||||
cycles once at it (tau3); back above it, it gives bw/2 again at once."""
|
||||
def mk(u):
|
||||
st = {"since": None}
|
||||
|
||||
def f(at, plant):
|
||||
if plant.socs[u] >= 20.0:
|
||||
st["since"] = None
|
||||
return bw / 2.0
|
||||
if st["since"] is None:
|
||||
st["since"] = at
|
||||
k = int(at - st["since"])
|
||||
return bw / 2.0 * max(0.0, (3 - k) / 3.0)
|
||||
return f
|
||||
return {"a": mk("a"), "b": mk("b")}
|
||||
|
||||
|
||||
def _step_house(k, lo=AIM + 520.0 - CAR, hi=AIM + 1900.0):
|
||||
return lambda t, R: lo if t < R + k else hi
|
||||
|
||||
|
||||
def _burst(k, w):
|
||||
"""Inverter-b: 2 125 W until R+1, then `w` for 0.5 s before the cycle at
|
||||
R+k (P1, sampled 0.3 s before it, and the reading both show it), else
|
||||
0 W."""
|
||||
def f(at, plant):
|
||||
if at < plant.R + 1:
|
||||
return 4250.0 / 2.0
|
||||
return w if plant.R + k - 0.5 <= at <= plant.R + k else 0.0
|
||||
return f
|
||||
|
||||
|
||||
def _ignoring():
|
||||
"""The charger accepts the 6 A write and ignores it: the car stays at
|
||||
0 A."""
|
||||
s = Meter(setpoint_a=0)
|
||||
s.refuse = "ignore"
|
||||
return s
|
||||
|
||||
|
||||
def _full_at_plug(p, c):
|
||||
"""The car is full (after the plug-in at R-180): mode3 B, 0 W."""
|
||||
p.ch.car_full()
|
||||
|
||||
|
||||
def _no_energy(p, c):
|
||||
"""The charger has no energy entity."""
|
||||
p.ch.no_energy = True
|
||||
|
||||
|
||||
def _freeze_stop(p, c):
|
||||
p.ch.freeze()
|
||||
p.ch.car_full()
|
||||
|
||||
|
||||
def jobs():
|
||||
"""Every controller run test_ev19.py grades: {name: kwargs}."""
|
||||
j = {}
|
||||
for name, kw in grid():
|
||||
j["T1 " + name] = kw
|
||||
# T3: the battery W sweep
|
||||
for tj in ("t1", "t2"):
|
||||
for bw in range(0, 4601, 200):
|
||||
j[f"T3 {tj} bw={bw}"] = dict(bw=float(bw), traj=tj)
|
||||
j[f"T3 {tj} tau5"] = dict(bw=9600.0, traj=tj, aim=6000.0,
|
||||
house_w=5200.0)
|
||||
# T4: the landing without the car at aim + 9 / + 11 W
|
||||
for d in (9, 11):
|
||||
for md in ("manual", "off"):
|
||||
j[f"T4 +{d} {md}"] = t2_shape(house_w=AIM + d, mode=md)
|
||||
# T5: honest at the reserve
|
||||
for tj in ("t1", "t4"):
|
||||
for md in ("manual", "off"):
|
||||
j[f"T5 {tj} {md}"] = t5_shape(traj=tj, mode=md)
|
||||
for md in ("manual", "off"):
|
||||
j[f"T5 tau5 {md}"] = dict(bw=9600.0, traj="t1", aim=6000.0,
|
||||
house_w=7700.0, mode=md)
|
||||
# T6: the honest step in the reserve cycle
|
||||
for k in (0, 1, 5):
|
||||
for md in ("manual", "off"):
|
||||
j[f"T6 step R+{k} {md}"] = dict(bw=4250.0, traj="t1", mode=md,
|
||||
house_fn=_step_house(k))
|
||||
# T7: unknown values
|
||||
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
|
||||
j[f"T7(a) {nm}"] = sh(lost={"a": {0, 1}})
|
||||
j[f"T7(b) {nm}"] = sh(rel=unavailable(0, 1))
|
||||
j["T7(a) T5 off"] = t5_shape(lost={"a": {0, 1}}, mode="off")
|
||||
j["T7(b) T5 off"] = t5_shape(rel=unavailable(0, 1), mode="off")
|
||||
# T8: a stale car figure
|
||||
j["T8(a) Off 120 s, Manual R-5"] = t2_shape(plug_at=-125, man_at=-5)
|
||||
j["T8(b) stale R-5..R+20"] = t2_shape(rel=stale(-5, 20))
|
||||
j["T8(c) frozen, the car stops"] = t5_shape(rel={-30: _freeze_stop})
|
||||
j["T8(c) off"] = t5_shape(rel={-30: _freeze_stop}, mode="off")
|
||||
# T9: comms
|
||||
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
|
||||
j[f"T9(a) {nm} b lost at R"] = sh(lost={"b": {0}})
|
||||
j[f"T9(a) {nm} b lost at R-1"] = sh(lost={"b": {-1}})
|
||||
j[f"T9(b) {nm} P1 5 s late at R"] = sh(rel=p1_gap(0, 5))
|
||||
# T10: a restart
|
||||
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
|
||||
j[f"T10 {nm} twin"] = sh()
|
||||
for k in (-2, 2):
|
||||
j[f"T10 {nm} restart R{k:+d}"] = sh(rel=restart(k))
|
||||
# T11: the quarter edge
|
||||
for rr in (-1, 0, 1, 43):
|
||||
j[f"T11 T2 R=E{rr:+d}"] = t2_shape(r_rel=rr)
|
||||
j[f"T11 T5 R=E{rr:+d}"] = t5_shape(r_rel=rr)
|
||||
j[f"T11 T5 R=E{rr:+d} off"] = t5_shape(r_rel=rr, mode="off")
|
||||
# C4: the old quarter heads over the aim (the house high all along), so the
|
||||
# guard wants power in its last 60 s and SAFETY-126's latch is carried
|
||||
j["T11 C4 T2 R=E+1"] = t2_shape(r_rel=1, house_w=13350.0, pre_w=13350.0)
|
||||
# T12: our own phase change
|
||||
for k in (-15, 5):
|
||||
j[f"T12 T2 1->3 at R{k:+d}"] = t2_shape(rel=phases(k))
|
||||
j[f"T12 T5 1->3 at R{k:+d}"] = t5_shape(rel=phases(k))
|
||||
j[f"T12 T5 1->3 at R{k:+d} off"] = t5_shape(rel=phases(k),
|
||||
mode="off")
|
||||
# T13: a wrong charger reply
|
||||
# (a): the house + the 400 W it really draws lands at aim + 520 W, so the
|
||||
# house alone misses by 120 W; (b) and T14(a): the car draws 0 W and the
|
||||
# house alone lands at aim + 520 W. An alarm is due in each.
|
||||
for md in ("manual", "off"):
|
||||
j[f"T13(a) draws 400 W {md}"] = t2_shape(
|
||||
sim=Draw(400.0, CAR, setpoint_a=6), house_w=AIM + 120.0, mode=md)
|
||||
j[f"T13(a) draws 100 W {md}"] = t2_shape(
|
||||
sim=Draw(100.0, CAR, setpoint_a=6), house_w=AIM + 420.0, mode=md)
|
||||
j[f"T13(b) the write ignored, 0 A {md}"] = t2_shape(
|
||||
sim=_ignoring(), house_w=AIM + 520.0, mode=md)
|
||||
# T14: configuration
|
||||
j[f"T14(a) 0 W in C {md}"] = t2_shape(
|
||||
sim=Draw(0.0, 0.0, c_at_0=True, setpoint_a=6),
|
||||
house_w=AIM + 520.0, mode=md)
|
||||
j[f"T14(a) idle B {md}"] = t2_shape(
|
||||
house_w=AIM + 520.0, mode=md, rel={-179: _full_at_plug})
|
||||
j["T14(b) ev_charger off"] = t2_shape(opts={"ev_charger": "off"})
|
||||
j["T14(b) off"] = t2_shape(mode="off")
|
||||
for tj in ("t1", "t4"):
|
||||
j[f"T14(c) N=1 anchor {tj}"] = dict(n=1, bw=4250.0, traj=tj)
|
||||
j["T14(c) N=1 T5"] = t5_shape(n=1)
|
||||
j["T14(c) N=1 T5 off"] = t5_shape(n=1, mode="off")
|
||||
# T15: one battery first (SAFETY-87)
|
||||
for nm, hw in (("anchor", AIM + 520.0 - CAR), ("honest", 19000.0)):
|
||||
for md in ("manual", "off"):
|
||||
j[f"T15 {nm} {md}"] = dict(
|
||||
bw=4250.0, traj="t1", house_w=hw, mode=md,
|
||||
force={"b": None}, soc_after={"a": 19.0, "b": 35.0},
|
||||
rel=socs(360, b=19.0))
|
||||
# T16: x10 (wall and mono), and mono x1 / wall x10
|
||||
for xn, xk in (("x10", dict(x=10)), ("mono1", dict(x=10, mono_x=1))):
|
||||
xk = dict(xk, r_rel=40)
|
||||
# x10: b at 1 200 W before R (at 0 W, which the forced unit holds
|
||||
# against the guard's floor, SAFETY-37's gate reads it as frozen)
|
||||
xk2 = dict(xk, bw=1200.0)
|
||||
j[f"T16 {xn} T2"] = t2_shape(**xk2)
|
||||
for tj in ("t1", "t4"):
|
||||
for bw in (0.0, 2000.0, 4250.0):
|
||||
j[f"T16 {xn} T3 {tj} bw={bw:.0f}"] = dict(bw=bw, traj=tj,
|
||||
**xk)
|
||||
for md in ("manual", "off"):
|
||||
j[f"T16 {xn} T5 {md}"] = t5_shape(mode=md, **xk)
|
||||
j[f"T16 {xn} T6 {md}"] = dict(bw=4250.0, traj="t1", mode=md,
|
||||
house_fn=_step_house(0), **xk)
|
||||
j[f"T16 {xn} T7(b) T2"] = t2_shape(rel=unavailable(0, 10), **xk2)
|
||||
for rr in (-10, 0, 10, 40):
|
||||
j[f"T16 {xn} T11 T2 R=E{rr:+d}"] = t2_shape(
|
||||
**dict(xk2, r_rel=rr))
|
||||
j[f"T16 {xn} T11 T5 R=E{rr:+d}"] = t5_shape(**dict(xk, r_rel=rr))
|
||||
# T17: no flicker
|
||||
j["T17 flicker"] = dict(
|
||||
force=flicker_force(), after=1200,
|
||||
rel=merge(socs(300, a=21.0, b=21.0), socs(600, a=19.0, b=19.0)),
|
||||
house_fn=lambda t, R: AIM + 10.0 + (40.0 if int(t // 7) % 2
|
||||
else -40.0))
|
||||
# N2: figures only `car_w_trusted` keeps out of the alarm path: no energy
|
||||
# entity (never corroborated, never contradicted) and 11 kW reported at
|
||||
# a 6 A read-back (capped at 1 518 W; the house alone misses by 1 680 W)
|
||||
for md in ("manual", "off"):
|
||||
j[f"N2 no energy entity {md}"] = t2_shape(extra={0: _no_energy},
|
||||
mode=md)
|
||||
j[f"N2 reports 11 kW at 6 A {md}"] = t5_shape(
|
||||
sim=Draw(CAR, 11000.0, setpoint_a=6), mode=md)
|
||||
# Review round 1: an honest house step answered by ONE cycle of inverter-b
|
||||
# power that P1 and the reading both show (the meter in step), after the
|
||||
# T6 shape (4 250 W until R, then 0 W).
|
||||
for k in (5, 30):
|
||||
for hi in (1900, 2500):
|
||||
for burst in (3000.0, 4600.0):
|
||||
for md in ("manual", "off"):
|
||||
j[f"RB step R+{k} aim+{hi} burst {burst:.0f} {md}"] = dict(
|
||||
bw=4250.0, traj="t1", mode=md,
|
||||
house_fn=_step_house(k - 0.5, hi=AIM + hi),
|
||||
force={"b": _burst(k, burst)})
|
||||
# T10 (mE): restarts at R-1 and R, so the rise cycle has no reading from
|
||||
# two cycles back
|
||||
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
|
||||
for k in (-1, 0):
|
||||
j[f"T10 {nm} restart R{k:+d}"] = sh(rel=restart(k))
|
||||
# T20 / N4: the same runs with the car never explaining
|
||||
j["N4 T2 explain off"] = t2_shape(explain_off=True)
|
||||
j["N4 T5 explain off"] = t5_shape(explain_off=True)
|
||||
return j
|
||||
|
||||
|
||||
def grid():
|
||||
"""The T1 cells: (name, kwargs)."""
|
||||
cells = []
|
||||
for bw in (0.0, 400.0, 800.0, 2000.0, 4250.0, 9600.0):
|
||||
for tj in ("t1", "t2", "t3", "t4", "t4r"):
|
||||
for rp in (30, 100, 110, 180, 600):
|
||||
kw = dict(bw=bw, traj=tj, rp=rp)
|
||||
if bw == 9600.0:
|
||||
kw.update(aim=6000.0, house_w=5200.0)
|
||||
cells.append((f"core bw={bw:.0f} {tj} rp={rp}", kw))
|
||||
cells.append(("a: plug R-185, Manual R-180", dict(order="plug")))
|
||||
cells.append(("a: Off 120 s, Manual R-60", dict(order="off120")))
|
||||
cells.append(("b: energy first step late", dict(energy="late")))
|
||||
cells.append(("b: energy never steps", dict(energy="never")))
|
||||
for rr in (-60, 0, 1, 43, 450, 890):
|
||||
cells.append((f"c: R=E{rr:+d}", dict(r_rel=rr)))
|
||||
cells.append(("d: x10 wall+mono", dict(x=10, r_rel=40)))
|
||||
cells.append(("d: x10 wall, mono x1", dict(x=10, mono_x=1, r_rel=40)))
|
||||
for tj, bw in (("t4", 4250.0), ("t2", 4250.0), ("t2", 1200.0)):
|
||||
cells.append((f"d: x10 wall+mono {tj} bw={bw:.0f}",
|
||||
dict(x=10, r_rel=40, traj=tj, bw=bw)))
|
||||
cells.append((f"d: x10 wall, mono x1 {tj} bw={bw:.0f}",
|
||||
dict(x=10, mono_x=1, r_rel=40, traj=tj, bw=bw)))
|
||||
return cells
|
||||
|
||||
|
||||
class Res:
|
||||
"""What a check needs from one run, picklable: the notices (`raised`,
|
||||
seconds and ids), the trace, the command digest and the run's times."""
|
||||
|
||||
def __init__(self, r, tr, meta):
|
||||
self.raised = list(r["raised"])
|
||||
self.tr, self.meta = tr, meta
|
||||
self.cmd = commands(r, tr)
|
||||
self.R, self.E = meta["R"], meta["E"]
|
||||
|
||||
def alarms(self):
|
||||
return [t for t, n in self.raised if n == FLOOR]
|
||||
|
||||
def rel_alarms(self):
|
||||
return [int(t - self.R) for t in self.alarms()]
|
||||
|
||||
def edges(self):
|
||||
return [int(t - self.R) for t in edges(self.tr)]
|
||||
|
||||
def errors(self):
|
||||
return [int(x["t"] - self.R) for x in self.tr if x["err"]]
|
||||
|
||||
def red(self, t0=-60, t1=900):
|
||||
return [int(x["t"] - self.R) for x in
|
||||
window(self.tr, self.R + t0, self.R + t1) if x["red"]]
|
||||
|
||||
def at(self, k):
|
||||
return next((x for x in self.tr if x["t"] == self.R + k), None)
|
||||
|
||||
def win(self, t0, t1):
|
||||
return window(self.tr, self.R + t0, self.R + t1)
|
||||
|
||||
def quiet(self, t0=-60, t1=900):
|
||||
return quiet({"raised": self.raised}, self.tr,
|
||||
self.R + t0, self.R + t1)
|
||||
|
||||
def edges_per_quarter(self):
|
||||
"""False -> True edges of the floor alarm per quarter (N5)."""
|
||||
out = {}
|
||||
for t in edges(self.tr):
|
||||
q = int((t - self.E) // 900)
|
||||
out[q] = out.get(q, 0) + 1
|
||||
return out
|
||||
|
||||
def summary(self):
|
||||
return {"alarms": self.rel_alarms(), "edges": self.edges(),
|
||||
"errors": self.errors(), "red": len(self.red()),
|
||||
"cmd": self.cmd}
|
||||
|
||||
|
||||
_JOBS = {}
|
||||
|
||||
|
||||
def _job(name):
|
||||
import logging
|
||||
logging.disable(logging.WARNING)
|
||||
return name, Res(*run(**_JOBS[name]))
|
||||
|
||||
|
||||
def run_many(jobs, procs=None):
|
||||
"""{name: kwargs} -> {name: Res}, `procs` runs at a time (fork: the
|
||||
kwargs may hold functions)."""
|
||||
import multiprocessing
|
||||
_JOBS.clear()
|
||||
_JOBS.update(jobs)
|
||||
procs = procs or int(os.environ.get("EV19_JOBS", "0")) \
|
||||
or min(8, os.cpu_count() or 1)
|
||||
ctx = multiprocessing.get_context("fork")
|
||||
with ctx.Pool(procs) as pool:
|
||||
return dict(pool.imap_unordered(_job, list(jobs), chunksize=1))
|
||||
|
||||
|
||||
def _one(cell):
|
||||
import logging
|
||||
logging.disable(logging.WARNING)
|
||||
name, kw = cell
|
||||
try:
|
||||
r, tr, meta = run(**kw)
|
||||
except Exception as e: # noqa: BLE001
|
||||
import traceback
|
||||
return name, f"{name:42s} Traceback {e!r}\n{traceback.format_exc()}"
|
||||
return name, row(name, r, tr, meta)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import multiprocessing
|
||||
cells = grid()
|
||||
if len(sys.argv) > 1:
|
||||
cells = [c for c in cells if any(a in c[0] for a in sys.argv[1:])]
|
||||
with multiprocessing.Pool(int(os.environ.get("EV19_JOBS", "8"))) as pool:
|
||||
for _name, line in pool.imap(_one, cells):
|
||||
print(line, flush=True)
|
||||
Reference in New Issue
Block a user