Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9987a32424 | ||
|
|
b66ce68d4d | ||
|
|
d0285470cb | ||
|
|
c8f529273f | ||
|
|
6cd775788d | ||
|
|
57a9f56a64 | ||
|
|
0774d1efd5 | ||
|
|
5ebd830966 | ||
|
|
1b39f1698a | ||
|
|
c3903b796b | ||
|
|
c25877fea4 | ||
|
|
76f4de23c7 | ||
|
|
4b4a4c1053 | ||
|
|
83f114fe08 | ||
|
|
4eba2d9acf | ||
|
|
af374026b1 | ||
|
|
00b116e5b2 |
+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,8 @@
|
||||
|
||||
### Not in a release yet
|
||||
|
||||
- When the car charger does not take a current setting but is plainly working, you now see one amber row ("did not take the setting"), not a second "reading may be stuck" ([[EV-13]]).
|
||||
- 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,12 +30,14 @@ 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
|
||||
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`).
|
||||
0 A, wait until the charger reports under 100 W (mode3 leaving C and D 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`).
|
||||
|
||||
## Another writer
|
||||
|
||||
@@ -62,6 +64,16 @@ stops holding late in a period that the car already pushed over, because
|
||||
`excess_w` grows as the seconds run out; the average form does not, and it is the
|
||||
same test for a steady car.
|
||||
|
||||
**A refused write arms the stuck check only when the charger shows no life
|
||||
(EV-13).** A charger that ignores a write keeps its old read-back, so the
|
||||
check would read it as stuck 60 s later and show a second amber row beside
|
||||
"did not take the setting". A refused write now arms only if, within `TOOK_S`
|
||||
of the send, the energy, a phase current or the power changed in a sample taken
|
||||
after the send, against the last value before (`CarTracker.note_write`,
|
||||
`_alive`). Unchanged, absent before, or taken before the send is no life. No
|
||||
life arms as before, dated the send. A write that raised, or was accepted, is
|
||||
unchanged. A frozen charger (every write looks refused) still arms.
|
||||
|
||||
**A stale, stuck or frozen car figure must never hide a real overload.** Only
|
||||
`CarTracker.car_w_trusted` is used: fresh (the EV-03 rules, which also make an
|
||||
unavailable reading None at once), not stuck after a write (SAFETY-37's shape),
|
||||
|
||||
@@ -15,10 +15,11 @@ 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
|
||||
`PHASE_GAP_S`. A sequence that has begun is always finished, because it
|
||||
leaves the car at 0 A otherwise.
|
||||
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
|
||||
ANOTHER WRITER: an info row, and no write over it until the user changes the
|
||||
mode or a value again.
|
||||
@@ -256,7 +257,7 @@ class ManualWriter:
|
||||
finally:
|
||||
self._stamp(now)
|
||||
tracker.end_write(self.last_done)
|
||||
tracker.note_write(now, was, a)
|
||||
tracker.note_write(now, was, a, ok, getattr(drv, "polls", ()))
|
||||
tracker.end_write(self.last_done)
|
||||
self.log.append(("current", a, now, ok))
|
||||
if ok:
|
||||
@@ -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)
|
||||
|
||||
@@ -70,6 +70,7 @@ TOOK_S = 10.0 # a write is "taken" when the read-back follows by t
|
||||
TOOK_TOL_A = 0.5 # ... to within this
|
||||
STUCK_S = 60.0 # EV-04: power and read-back unchanged after a write
|
||||
STUCK_MIN_A = 1.0 # ... that moved the setpoint by at least this
|
||||
LIFE_KEEP_S = 40.0 # EV-13: samples kept to date a refused write's life
|
||||
OWN_WRITE_MUTE_S = 15.0 # the tracker's two-writer detector ignores our own
|
||||
# Volts used to bound a car figure by what the read-back allows (a physical
|
||||
# ceiling for the alarm path, never a setpoint).
|
||||
@@ -120,6 +121,7 @@ REQUIRED = ("current", "readback", "state", "power")
|
||||
_SETPOINT_RE = re.compile(r"^number\.(?P<x>.+)_" + SETPOINT_SUFFIX + "$")
|
||||
|
||||
_ROLE_ORDER = tuple(ROLES)
|
||||
_LIFE_ROLES = ("power", "energy", "l1", "l2", "l3") # EV-13
|
||||
#: power unit -> W. The probe and the reading both use this one table.
|
||||
_W_PER = {"mW": 0.001, "W": 1.0, "kW": 1000.0, "MW": 1000000.0}
|
||||
POWER_UNITS = tuple(_W_PER)
|
||||
@@ -161,6 +163,10 @@ class ChargerReading:
|
||||
error: str | None = None # None: no error (or not read)
|
||||
display: str | None = None
|
||||
why: str = "" # for the log only, "" when available
|
||||
# EV-13: when the sample was TAKEN, on the tracker's clock. None: the
|
||||
# caller's `now` (in the cycle that is the read's start, `now_mono`).
|
||||
taken_at: float | None = None
|
||||
phase_a: tuple = () # EV-13: L1, L2, L3 each, None if not read
|
||||
|
||||
|
||||
def _state_obj(obj):
|
||||
@@ -280,6 +286,7 @@ def reading_from_states(states: dict) -> ChargerReading:
|
||||
available=True, state=letter, connected=connected, charging=charging,
|
||||
power_w=power, energy_kwh=_kwh(states.get("energy")),
|
||||
current_a=currents, setpoint_a=_amps(states.get("current")),
|
||||
phase_a=tuple(_amps(states.get(k)) for k in ("l1", "l2", "l3")),
|
||||
allowed_a=_amps(states.get("readback")),
|
||||
phases_allowed=_phases(states.get("phases_read")),
|
||||
station_a=_first(_amps(states.get("station_active")),
|
||||
@@ -420,6 +427,9 @@ class AlfenHaDriver(ChargerDriver):
|
||||
self._clock = time.monotonic
|
||||
self.clamp_faults = [] # (asked, clamp), newest last, for the log
|
||||
self.sent = [] # every number value actually sent
|
||||
# EV-13: what the latest write saw while it waited for the read-back,
|
||||
# [(time, ChargerReading)]: the cycle's reads do not run inside it.
|
||||
self.polls = []
|
||||
|
||||
@classmethod
|
||||
def from_options(cls, opts: dict) -> "AlfenHaDriver":
|
||||
@@ -498,6 +508,7 @@ class AlfenHaDriver(ChargerDriver):
|
||||
read-back followed within `TOOK_S`. A value above `clamp_a()` is a
|
||||
SOFTWARE FAULT: nothing is sent, it is logged (the clamp watchdog's
|
||||
shape) and the answer is False."""
|
||||
self.polls = []
|
||||
try:
|
||||
a = float(a)
|
||||
except (TypeError, ValueError):
|
||||
@@ -522,7 +533,8 @@ class AlfenHaDriver(ChargerDriver):
|
||||
"""Did the read-back follow the write, within `TOOK_S`?"""
|
||||
t0 = self._clock()
|
||||
while True:
|
||||
st = await self._states(("readback", "current"))
|
||||
st = await self._states(("readback", "current") + _LIFE_ROLES)
|
||||
self._poll(st)
|
||||
seen = _first(_amps(st["readback"]), _amps(st["current"]))
|
||||
if seen is not None and abs(seen - a) <= TOOK_TOL_A:
|
||||
return True
|
||||
@@ -530,6 +542,17 @@ class AlfenHaDriver(ChargerDriver):
|
||||
return False
|
||||
await self._sleep(1.0)
|
||||
|
||||
def _poll(self, st: dict) -> None:
|
||||
"""EV-13: keep what this wait saw of energy, power and phase currents
|
||||
(never raises: a write does not depend on it)."""
|
||||
try:
|
||||
self.polls.append((self._clock(), ChargerReading(
|
||||
available=True, power_w=_watts(st.get("power")),
|
||||
energy_kwh=_kwh(st.get("energy")),
|
||||
phase_a=tuple(_amps(st.get(k)) for k in ("l1", "l2", "l3")))))
|
||||
except Exception: # noqa: BLE001
|
||||
pass
|
||||
|
||||
async def write_phases(self, n: int) -> bool:
|
||||
"""Select 1 or 3 phases. ONLY THROUGH `carmode`'s safe sequence: the
|
||||
setting moves the contactors, so it is touched with the car paused."""
|
||||
@@ -631,6 +654,31 @@ CHARGING, WAITING, NONE_, FULL, UNREACH, SETUP, FAULT = (
|
||||
"charging", "waiting", "none", "full", "unreach", "setup", "fault")
|
||||
|
||||
|
||||
def _life_vals(r) -> tuple:
|
||||
"""EV-13: what shows a charger is alive: energy, power, three phase
|
||||
currents. None is "not read"."""
|
||||
cur = tuple(r.phase_a or ())
|
||||
if len(cur) != 3:
|
||||
# Only `current_a`, which leaves out a phase that is not read: which
|
||||
# phase is which is then known only when all three are there.
|
||||
cur = tuple(r.current_a or ())
|
||||
cur = cur if len(cur) == 3 else (None,) * 3
|
||||
return (r.energy_kwh, r.power_w) + cur
|
||||
|
||||
|
||||
def _alive(vals: tuple, pre: list) -> bool:
|
||||
"""A value that is present now, was present before the write, and differs
|
||||
from every value before it. Present but unchanged, or not there before, is
|
||||
no life."""
|
||||
for i, v in enumerate(vals):
|
||||
if v is None:
|
||||
continue
|
||||
old = [p[i] for p in pre if p[i] is not None]
|
||||
if old and all(v != o for o in old):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
@dataclass
|
||||
class CarTracker:
|
||||
"""What the cycle learns about the car from the readings. Pure, clocked by
|
||||
@@ -663,6 +711,9 @@ class CarTracker:
|
||||
sig: tuple | None = None
|
||||
stuck_now: bool = False
|
||||
obs_at: float | None = None # monotonic second of the latest reading
|
||||
# EV-13: a REFUSED write waits to see if the charger shows life (below)
|
||||
_pend: dict | None = None
|
||||
_ring: list = field(default_factory=list) # (taken-at, life values)
|
||||
_hist: list = field(default_factory=list) # (t, power W, energy Wh)
|
||||
# today's energy
|
||||
day: str | None = None
|
||||
@@ -683,7 +734,10 @@ class CarTracker:
|
||||
if usable:
|
||||
self.last_ok = now
|
||||
self.last_good, self.last_good_utc = r, now_utc
|
||||
if not r.available:
|
||||
self._pend_lapse(now)
|
||||
if r.available:
|
||||
self._life(r, now)
|
||||
self._sig(r, now)
|
||||
self._writer(r, now_utc, now)
|
||||
self._energy(r, day)
|
||||
@@ -727,19 +781,78 @@ class CarTracker:
|
||||
`OWN_WRITE_MUTE_S` from now, not from before the write."""
|
||||
self.mute_until = now + OWN_WRITE_MUTE_S
|
||||
|
||||
def note_write(self, now: float, was_a, to_a) -> None:
|
||||
"""The add-on wrote the current. Its own change is not "another
|
||||
writer" for `OWN_WRITE_MUTE_S`, and a write that moved the setpoint by
|
||||
`STUCK_MIN_A` or more arms the stuck check: power and read-back that
|
||||
have not changed `STUCK_S` later are a stuck reading, not a car."""
|
||||
def note_write(self, now: float, was_a, to_a, ok: bool = True,
|
||||
polls=()) -> None:
|
||||
"""The add-on wrote the current at `now`. Its own change is not
|
||||
"another writer" for `OWN_WRITE_MUTE_S`, and a write that moved the
|
||||
setpoint by `STUCK_MIN_A` or more arms the stuck check: power and
|
||||
read-back that have not changed `STUCK_S` later are a stuck reading,
|
||||
not a car.
|
||||
|
||||
EV-13: a write the charger REFUSED (`ok` False) arms it only when the
|
||||
charger shows no life: the energy, a phase current or the power
|
||||
changed in a sample taken after `now` and within `TOOK_S` of it,
|
||||
against the last values before. A refused write on a charger that is
|
||||
plainly alive is not a stuck reading. `polls` are the samples the
|
||||
write itself saw while it waited, `[(time, ChargerReading)]`."""
|
||||
self.mute_until = now + OWN_WRITE_MUTE_S
|
||||
try:
|
||||
moved = was_a is None or abs(float(to_a) - float(was_a)) \
|
||||
>= STUCK_MIN_A
|
||||
except (TypeError, ValueError):
|
||||
moved = False
|
||||
if moved and self.armed_at is None:
|
||||
if self._pend is not None and now > self._pend["t"] + TOOK_S:
|
||||
self._pend_arm() # the old window ran out
|
||||
if not moved or self.armed_at is not None:
|
||||
return
|
||||
if ok:
|
||||
self._pend = None
|
||||
self.armed_at, self.armed_sig = now, self.sig
|
||||
return
|
||||
if self._pend is not None:
|
||||
return # an earlier refusal's window
|
||||
before = [x for x in self._ring if x[0] <= now]
|
||||
pre = [max(before, key=lambda x: x[0])[1]] if before else []
|
||||
self._pend = {"t": now, "pre": pre, "sig": self.sig}
|
||||
later = [(t, _life_vals(r)) for t, r in polls]
|
||||
later += [(t, v) for t, v in self._ring if t > now]
|
||||
for t, v in sorted(later, key=lambda x: x[0]):
|
||||
self._pend_feed(t, v, t)
|
||||
|
||||
def _life(self, r, now: float) -> None:
|
||||
"""EV-13: file this sample (by when it was TAKEN) and let a refused
|
||||
write's open window look at it."""
|
||||
t = now if r.taken_at is None else r.taken_at
|
||||
v = _life_vals(r)
|
||||
self._ring.append((t, v))
|
||||
top = max(x[0] for x in self._ring)
|
||||
self._ring = [x for x in self._ring if top - x[0] <= LIFE_KEEP_S]
|
||||
self._pend_feed(t, v, now)
|
||||
|
||||
def _pend_feed(self, t: float, vals: tuple, arrival: float) -> None:
|
||||
p = self._pend
|
||||
if p is None:
|
||||
return
|
||||
if t <= p["t"]:
|
||||
p["pre"] = (p["pre"] + [vals])[-8:] # taken before the send
|
||||
elif t <= p["t"] + TOOK_S and _alive(vals, p["pre"]):
|
||||
self._pend = None # life: nothing to arm
|
||||
return
|
||||
if max(t, arrival) > p["t"] + TOOK_S:
|
||||
self._pend_arm()
|
||||
|
||||
def _pend_lapse(self, now: float) -> None:
|
||||
"""A reading that did not answer shows no life either: once the window
|
||||
has run out the refusal arms, dated the send, as it did before."""
|
||||
p = self._pend
|
||||
if p is not None and now > p["t"] + TOOK_S:
|
||||
self._pend_arm()
|
||||
|
||||
def _pend_arm(self) -> None:
|
||||
"""No life in the window: arm as the write would have, dated its send."""
|
||||
p, self._pend = self._pend, None
|
||||
if p is not None and self.armed_at is None:
|
||||
self.armed_at, self.armed_sig = p["t"], p["sig"]
|
||||
|
||||
def _sig(self, r, now: float) -> None:
|
||||
sig = (r.power_w, r.allowed_a)
|
||||
|
||||
@@ -1318,14 +1318,34 @@ def _over_why_is_floor(c, pg) -> bool:
|
||||
return bool(pg is not None and pg.floor_limited and pg.soc is not None)
|
||||
|
||||
|
||||
def _real_phases(c):
|
||||
"""EV-14: the phases the charger reports (1 or 3), or None: no fresh
|
||||
reading, or none read. Reads only; unknown is never a difference."""
|
||||
car = getattr(c, "car", None)
|
||||
r = getattr(car, "reading", None)
|
||||
fresh = getattr(car, "fresh", None)
|
||||
if r is None or fresh is None or not getattr(r, "available", False):
|
||||
return None
|
||||
if not fresh(c.car_now()):
|
||||
return None
|
||||
n = getattr(r, "phases_allowed", None)
|
||||
return n if n in (1, 3) else 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."""
|
||||
Plan lines: two sentences of at most 12 words. EV-14: in shadow mode it
|
||||
says what the add-on would set; after a phase change that did not happen
|
||||
it says what the charger does."""
|
||||
a = f"{float(c.car_a):.0f}"
|
||||
w = c.car_writer
|
||||
pct = _pct(c.o.get("peak_soc_floor", peakguard.PEAK_OPTION_DEFAULTS[
|
||||
"peak_soc_floor"]))
|
||||
if c.car_over:
|
||||
if c.shadow:
|
||||
t, n = w.would if w.would is not None else (c.car_a, c.car_n)
|
||||
return _t("car.why.manual_shadow_over", a=f"{float(t):.0f}",
|
||||
phases=car_phases_word(n))
|
||||
pg = getattr(c, "peak_guard", None)
|
||||
if not c.car_cover:
|
||||
return _t("car.why.manual_nocover", a=a)
|
||||
@@ -1337,6 +1357,8 @@ def _car_manual_why(c, key):
|
||||
phases=car_phases_word(n))
|
||||
if not c.auto:
|
||||
return _t("car.why.manual_stopped")
|
||||
if w.hold:
|
||||
return _t("car.why.manual_other")
|
||||
if key in ("none", "full"):
|
||||
return _t("car.why.manual_wait", a=a)
|
||||
if w.blocked:
|
||||
@@ -1344,6 +1366,11 @@ def _car_manual_why(c, key):
|
||||
if c.car_cover and peak_engaged(c):
|
||||
giving = max(0.0, float(c.site_batt_w or 0.0))
|
||||
return _t("car.why.manual_cover", a=a, kw=_kw(giving), pct=pct)
|
||||
real = _real_phases(c)
|
||||
if real is not None and real != c.car_n and w.seq is None:
|
||||
return _t("car.why.manual_phases", a=a,
|
||||
phases=car_phases_word(c.car_n),
|
||||
real=car_phases_word(real))
|
||||
return _t("car.why.manual_set", a=a, phases=car_phases_word(c.car_n))
|
||||
|
||||
|
||||
@@ -1900,7 +1927,8 @@ def _samples() -> list:
|
||||
out += [("plan", _t("car.big." + k, t="09:12")) for k in
|
||||
words["car"]["big"]]
|
||||
out += [("plan", _t("car.why." + k, a="10", brand="Alfen", kw="8.6 kW",
|
||||
pct="20 %", phases=car_phases_word(3)))
|
||||
pct="20 %", phases=car_phases_word(3),
|
||||
real=car_phases_word(1)))
|
||||
for k in words["car"]["why"]]
|
||||
out += [("plan", _t("peak.car", kw="12.1 kW", car="11.0 kW",
|
||||
cov="8.6 kW")),
|
||||
|
||||
@@ -329,6 +329,9 @@
|
||||
"manual_wait": "You set {a} A. It is set when a car is connected.",
|
||||
"manual_would": "Shadow mode: the add-on would set {a} A, {phases}.",
|
||||
"manual_stopped": "Control is stopped. The charger keeps its last setting.",
|
||||
"manual_shadow_over": "Shadow mode: the add-on would set {a} A, {phases}. This charge would set the peak.",
|
||||
"manual_phases": "You set {a} A, {phases}. The charger stays on {real}.",
|
||||
"manual_other": "Something else set the charger. The add-on leaves it until you change something.",
|
||||
"manual_blocked": "The phases change once per 10 minutes at most. This waits."
|
||||
}
|
||||
},
|
||||
|
||||
@@ -283,6 +283,9 @@
|
||||
"manual_wait": "U stelde {a} A in. Het wordt ingesteld zodra een auto is aangesloten.",
|
||||
"manual_would": "Schaduwmodus: de add-on zou {a} A instellen, {phases}.",
|
||||
"manual_stopped": "De regeling is gestopt. De laadpaal houdt haar laatste instelling.",
|
||||
"manual_shadow_over": "Schaduwmodus: de add-on zou {a} A instellen, {phases}. Deze lading zou de piek bepalen.",
|
||||
"manual_phases": "U stelde {a} A in, {phases}. De laadpaal blijft op {real}.",
|
||||
"manual_other": "Iets anders heeft de laadpaal ingesteld. De add-on laat dit zo tot u iets wijzigt.",
|
||||
"manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht."
|
||||
}
|
||||
},
|
||||
|
||||
@@ -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 "
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,832 @@
|
||||
"""EV-14: the Car Why says what happens, not only what the user set.
|
||||
`python3 -B test_ev14.py`
|
||||
|
||||
Display only (homeview._car_manual_why, ui_text en/nl):
|
||||
E1 shadow mode: no Why says "You set"; with the car over the limit it says
|
||||
what the add-on WOULD set and that this charge would set the peak.
|
||||
E2 a phase change that did not happen (read phases differ from the setting):
|
||||
"The charger stays on {real}", never "keeps it".
|
||||
E3 the writer holds for another writer: "Something else set the charger".
|
||||
E4 phases equal or unknown, no hold: exactly as before.
|
||||
E5 texts in en and nl, same keys, UX-08 limits.
|
||||
N2 the render writes nothing; N3 it never sends to the charger.
|
||||
Mutants: see the dev report (M1-M14).
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import copy
|
||||
import dataclasses
|
||||
import itertools
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
from datetime import datetime, timezone
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import carmode, chargers as CH, ctl_car, homeview, uitext # noqa: E402
|
||||
from app.carmode import PHASE_GAP_S, ManualWriter # noqa: E402
|
||||
from app.main import Controller # noqa: E402
|
||||
from app import freshness # noqa: E402
|
||||
from chargersim import FakeHa, SimCharger # noqa: E402
|
||||
from named_absence import nth, present # noqa: E402
|
||||
|
||||
fails = []
|
||||
logging.getLogger("goodwe").setLevel(logging.CRITICAL)
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
def run(coro):
|
||||
return asyncio.run(coro)
|
||||
|
||||
|
||||
# =========================================================================== #
|
||||
# The texts the test holds the page to, written out (T34: base is byte-equal).
|
||||
# =========================================================================== #
|
||||
BASE_EN = {
|
||||
"manual_set": "You set {a} A, {phases}. The charger keeps it, whatever the peak limit does.",
|
||||
"manual_cover": "You set {a} A. The batteries give {kw} and help down to {pct}.",
|
||||
"manual_over": "You set {a} A. The batteries are at {pct}, so this charge sets the peak.",
|
||||
"manual_full": "You set {a} A. The batteries give all they can, so this charge sets the peak.",
|
||||
"manual_nocover": "You set {a} A. The guard ignores the car, so this charge can set the peak.",
|
||||
"manual_wait": "You set {a} A. It is set when a car is connected.",
|
||||
"manual_would": "Shadow mode: the add-on would set {a} A, {phases}.",
|
||||
"manual_stopped": "Control is stopped. The charger keeps its last setting.",
|
||||
"manual_blocked": "The phases change once per 10 minutes at most. This waits.",
|
||||
}
|
||||
BASE_NL = {
|
||||
"manual_set": "U stelde {a} A in, {phases}. De laadpaal houdt dit aan, wat de piekgrens ook doet.",
|
||||
"manual_cover": "U stelde {a} A in. De batterijen leveren {kw} en helpen tot {pct}.",
|
||||
"manual_over": "U stelde {a} A in. De batterijen staan op {pct}, dus deze lading bepaalt de piek.",
|
||||
"manual_full": "U stelde {a} A in. De batterijen geven alles, dus deze lading bepaalt de piek.",
|
||||
"manual_nocover": "U stelde {a} A in. De bewaking negeert de auto, dus deze lading kan de piek bepalen.",
|
||||
"manual_wait": "U stelde {a} A in. Het wordt ingesteld zodra een auto is aangesloten.",
|
||||
"manual_would": "Schaduwmodus: de add-on zou {a} A instellen, {phases}.",
|
||||
"manual_stopped": "De regeling is gestopt. De laadpaal houdt haar laatste instelling.",
|
||||
"manual_blocked": "De fasen wisselen hooguit eens per 10 minuten. Dit wacht.",
|
||||
}
|
||||
NEW_KEYS = ("manual_shadow_over", "manual_phases", "manual_other")
|
||||
LANGS = ("en", "nl")
|
||||
YOU = {"en": "You set", "nl": "U stelde"}
|
||||
KEEPS = {"en": "The charger keeps it,", "nl": "De laadpaal houdt dit aan"}
|
||||
WOULD = {"en": "would set", "nl": "zou"}
|
||||
PEAK = {"en": "would set the peak", "nl": "zou de piek bepalen"}
|
||||
STAYS = {"en": "stays on", "nl": "blijft op"}
|
||||
OTHER = {"en": "Something else set the charger.", "nl": "Iets anders heeft de laadpaal ingesteld."}
|
||||
|
||||
|
||||
def jwords(lang):
|
||||
return uitext.words(lang)["home_words"]["car"]["why"]
|
||||
|
||||
|
||||
def tx(lang, key, **kw):
|
||||
"""Render a car.why text the way the page does (a missing key is a text
|
||||
of its own, so a check on it is a FAIL, not a crash)."""
|
||||
homeview._LANG[0] = uitext.lang_of(lang)
|
||||
try:
|
||||
return homeview._t("car.why." + key, **kw)
|
||||
except Exception as e: # noqa: BLE001
|
||||
return f"<EXC {type(e).__name__} {key}>"
|
||||
finally:
|
||||
homeview._LANG[0] = "en"
|
||||
|
||||
|
||||
def pw(n):
|
||||
homeview._LANG[0] = "en"
|
||||
return homeview.car_phases_word(n)
|
||||
|
||||
|
||||
def pw_l(lang, n):
|
||||
homeview._LANG[0] = uitext.lang_of(lang)
|
||||
try:
|
||||
return homeview.car_phases_word(n)
|
||||
finally:
|
||||
homeview._LANG[0] = "en"
|
||||
|
||||
|
||||
# =========================================================================== #
|
||||
# A stub site for the unit rows: what _car_manual_why reads, nothing else.
|
||||
# =========================================================================== #
|
||||
@dataclasses.dataclass
|
||||
class G:
|
||||
floor_limited: bool = True
|
||||
soc: object = 19.0
|
||||
saturated: bool = False
|
||||
floor_w: float = 300.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 Car:
|
||||
def __init__(self, reading, fresh, last_good=None):
|
||||
self.reading, self._fresh, self.last_good = reading, fresh, last_good
|
||||
|
||||
def fresh(self, _now):
|
||||
return self._fresh
|
||||
|
||||
def status(self, *_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
class U(ctl_car.CarMixin):
|
||||
"""The attributes `_car_manual_why` and `_car_why_tick` read."""
|
||||
|
||||
def __init__(self, **kw):
|
||||
self.o = {"ev_batt_cover": kw.get("cover", True)}
|
||||
self._now = 0.0
|
||||
self.w = 11000.0
|
||||
self.site_batt_w, self.site_rating_w = 8100.0, 9600.0
|
||||
self.shadow = kw.get("shadow", False)
|
||||
self.auto = kw.get("auto", True)
|
||||
self.peak_guard = kw.get("pg", G(
|
||||
floor_limited=kw.get("floor", True),
|
||||
floor_w=300.0 if kw.get("eng") else 0.0))
|
||||
self.state = "charging"
|
||||
self.car_init({}, type("St", (), {"data": {}, "set": lambda s, k, v: 0})())
|
||||
self.car_a = kw.get("a", 10.0)
|
||||
self.car_n = kw.get("n", 3)
|
||||
self.car_over = kw.get("over", False)
|
||||
wr = self.car_writer
|
||||
wr.hold = wr.other = kw.get("hold", False)
|
||||
wr.blocked = kw.get("blocked", False)
|
||||
wr.seq = kw.get("seq", None)
|
||||
wr.would = kw.get("would", None)
|
||||
wr.phases_gave_up = kw.get("gave_up", False)
|
||||
if "car" in kw:
|
||||
self.car = kw["car"]
|
||||
else:
|
||||
real = kw.get("real", None)
|
||||
rd = CH.ChargerReading(available=True, state="C", power_w=2300.0,
|
||||
setpoint_a=10.0, allowed_a=10.0,
|
||||
phases_allowed=real)
|
||||
self.car = Car(rd, kw.get("fresh", True))
|
||||
|
||||
def car_now(self):
|
||||
return self._now
|
||||
|
||||
|
||||
def snap(c):
|
||||
"""Everything N2 says a render must not move."""
|
||||
keep = {k: v for k, v in vars(c).items()
|
||||
if k.startswith(("car_", "_car")) and k != "car"}
|
||||
car = getattr(c, "car", None)
|
||||
return repr((vars(c.car_writer), vars(car) if hasattr(car, "__dict__")
|
||||
else None, keep, c.shadow, c.auto))
|
||||
|
||||
|
||||
N2_BAD = []
|
||||
EXC = []
|
||||
|
||||
|
||||
def why(c, lang="en", key="charging"):
|
||||
"""The Why text; an exception becomes a text; N2 is checked on every call."""
|
||||
before = snap(c)
|
||||
homeview._LANG[0] = uitext.lang_of(lang)
|
||||
try:
|
||||
out = homeview._car_manual_why(c, key)
|
||||
except Exception as e: # noqa: BLE001
|
||||
EXC.append(repr(e))
|
||||
out = f"<EXC {type(e).__name__} {e}>"
|
||||
finally:
|
||||
homeview._LANG[0] = "en"
|
||||
if snap(c) != before:
|
||||
N2_BAD.append(out)
|
||||
return out
|
||||
|
||||
|
||||
def exp(lang, key, **kw):
|
||||
return tx(lang, key, **kw)
|
||||
|
||||
|
||||
def a_(c):
|
||||
return f"{float(c.car_a):.0f}"
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
print("1. E1: shadow mode says what the add-on WOULD set")
|
||||
# --------------------------------------------------------------------------- #
|
||||
SHADOW_BAD_CASES = {
|
||||
"T1 floor": dict(floor=True, cover=True),
|
||||
"T2 full": dict(floor=False, cover=True),
|
||||
"T3 cover off": dict(floor=True, cover=False),
|
||||
}
|
||||
for label, kw in SHADOW_BAD_CASES.items():
|
||||
for lang in LANGS:
|
||||
c = U(shadow=True, over=True, a=16.0, n=3, would=(10.0, 3), **kw)
|
||||
t = why(c, lang)
|
||||
check(f"{label} ({lang}): would set 10 A and would set the peak; no "
|
||||
f"'You set', no 16 A: {t!r}",
|
||||
present(t) and WOULD[lang] in t and "10 A" in t
|
||||
and PEAK[lang] in t and YOU[lang] not in t and "16 A" not in t)
|
||||
check(f"{label} ({lang}): exactly the shadow-over text",
|
||||
t == exp(lang, "manual_shadow_over", a="10",
|
||||
phases=pw_l(lang, 3)))
|
||||
|
||||
for lang in LANGS:
|
||||
c = U(shadow=True, over=True, a=12.0, n=3, would=None)
|
||||
t = why(c, lang)
|
||||
check(f"T4 ({lang}): writer not stepped: falls back to (car_a, car_n), "
|
||||
f"12 A, 3 phases, no 'You set': {t!r}",
|
||||
t == exp(lang, "manual_shadow_over", a="12", phases=pw_l(lang, 3))
|
||||
and YOU[lang] not in t)
|
||||
# Review: the phases word is the writer's `would`, as manual_would's.
|
||||
c = U(shadow=True, over=True, a=16.0, n=1, would=(10.0, 3))
|
||||
check(f"T1 phases ({lang}): the phases come from would, not car_n",
|
||||
why(c, lang) == exp(lang, "manual_shadow_over", a="10",
|
||||
phases=pw_l(lang, 3)))
|
||||
c = U(shadow=True, over=False, a=16.0, n=3, would=(10.0, 3))
|
||||
check(f"T5 ({lang}): shadow, not over: exactly today's manual_would",
|
||||
why(c, lang) == BASE_EN["manual_would"].format(
|
||||
a="10", phases="3 phases") if lang == "en" else
|
||||
why(c, lang) == BASE_NL["manual_would"].format(
|
||||
a="10", phases="3 fasen"))
|
||||
|
||||
# T6/T7: the EV-16 episode, 5 s cycles, floor flipping every 10 s.
|
||||
STEP = 5.0
|
||||
|
||||
|
||||
def tick(c, g, t, shadow=None):
|
||||
c._now = t
|
||||
c.peak_guard = g
|
||||
if shadow is not None:
|
||||
c.shadow = shadow
|
||||
c._car_why_tick(g, t)
|
||||
|
||||
|
||||
def episode(c, secs, flip=10.0, shadow_off_at=None):
|
||||
out, t = [], 0.0
|
||||
while t < secs:
|
||||
g = G(floor_limited=(int(t // flip) % 2 == 0))
|
||||
off = shadow_off_at is not None and t >= shadow_off_at
|
||||
tick(c, g, t, shadow=False if off else None)
|
||||
out.append((t, why(c)))
|
||||
t += STEP
|
||||
return out
|
||||
|
||||
|
||||
c = U(shadow=True, over=True, a=16.0, would=(10.0, 3))
|
||||
ep = episode(c, 180.0)
|
||||
texts = {t for _, t in ep}
|
||||
check(f"T6: shadow over, floor flips for 180 s: one constant text, 0 changes "
|
||||
f"({len(ep)} cycles)", len(ep) == 36 and len(texts) == 1
|
||||
and all(PEAK["en"] in t for t in texts))
|
||||
c = U(shadow=True, over=True, a=16.0, would=(10.0, 3))
|
||||
ep = episode(c, 180.0, flip=1000.0, shadow_off_at=90.0)
|
||||
first = [t for tt, t in ep if tt < 90.0]
|
||||
later = [t for tt, t in ep if tt >= 90.0]
|
||||
check("T7: shadow switched off mid-episode with the floor held: the shadow "
|
||||
"text, then exactly today's manual_over (EV-16 hold)",
|
||||
len(first) == 18 and len(later) == 18 and len(set(first)) == 1
|
||||
and PEAK["en"] in nth(first)
|
||||
and set(later) == {BASE_EN["manual_over"].format(a="16", pct=homeview._pct(
|
||||
c.o.get("peak_soc_floor", 20)))})
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
print("\n2. E2 / E3: units")
|
||||
# --------------------------------------------------------------------------- #
|
||||
for lang in LANGS:
|
||||
c = U(real=1, n=3, a=10.0)
|
||||
t = why(c, lang)
|
||||
check(f"T9 ({lang}): 3 set, charger on 1: 'stays on 1 phase', not 'keeps "
|
||||
f"it': {t!r}",
|
||||
t == exp(lang, "manual_phases", a="10", phases=pw_l(lang, 3),
|
||||
real=pw_l(lang, 1))
|
||||
and STAYS[lang] in t and KEEPS[lang] not in t
|
||||
and pw_l(lang, 1) in t)
|
||||
c = U(real=3, n=1, a=10.0)
|
||||
t = why(c, lang)
|
||||
check(f"T10 ({lang}): 1 set, charger on 3: 'stays on 3 phases': {t!r}",
|
||||
t == exp(lang, "manual_phases", a="10", phases=pw_l(lang, 1),
|
||||
real=pw_l(lang, 3)) and pw_l(lang, 3) in t.split(". ")[-1]
|
||||
and KEEPS[lang] not in t)
|
||||
check("T9: the words are the brief's (EN and NL)",
|
||||
why(U(real=1, n=3)) == "You set 10 A, 3 phases. The charger stays on 1 phase."
|
||||
and why(U(real=1, n=3), "nl") ==
|
||||
"U stelde 10 A in, 3 fasen. De laadpaal blijft op 1 fase.")
|
||||
|
||||
|
||||
def sett(lang, c):
|
||||
return exp(lang, "manual_set", a=a_(c), phases=pw_l(lang, c.car_n))
|
||||
|
||||
|
||||
for lang in LANGS:
|
||||
c = U(real=1, n=3, auto=False)
|
||||
check(f"T13a ({lang}): phases differ, control stopped: manual_stopped",
|
||||
why(c, lang) == exp(lang, "manual_stopped"))
|
||||
c = U(real=1, n=3, shadow=True, would=(10.0, 3))
|
||||
check(f"T13b ({lang}): phases differ, shadow: manual_would",
|
||||
why(c, lang) == exp(lang, "manual_would", a="10",
|
||||
phases=pw_l(lang, 3)))
|
||||
for stage in ("zero", "settle"):
|
||||
c = U(real=1, n=3, seq={"stage": stage})
|
||||
check(f"T14 ({lang}): phases differ, sequence at {stage}: manual_set",
|
||||
why(c, lang) == sett(lang, c))
|
||||
c = U(real=1, n=3, blocked=True)
|
||||
check(f"T15 ({lang}): phases differ, blocked: manual_blocked",
|
||||
why(c, lang) == exp(lang, "manual_blocked"))
|
||||
for key in ("none", "full"):
|
||||
c = U(real=1, n=3)
|
||||
check(f"T16 ({lang}): phases differ, key {key}: manual_wait",
|
||||
why(c, lang, key) == exp(lang, "manual_wait", a="10"))
|
||||
c = U(real=1, n=3, eng=True)
|
||||
giving = max(0.0, float(c.site_batt_w))
|
||||
homeview._LANG[0] = uitext.lang_of(lang)
|
||||
kw_ = homeview._kw(giving)
|
||||
pct_ = homeview._pct(20)
|
||||
homeview._LANG[0] = "en"
|
||||
check(f"T17 ({lang}): phases differ, cover engaged, not over: manual_cover",
|
||||
why(c, lang) == exp(lang, "manual_cover", a="10", kw=kw_, pct=pct_))
|
||||
for label, kw in (("floor", dict(floor=True)), ("full", dict(floor=False)),
|
||||
("nocover", dict(cover=False))):
|
||||
c = U(real=1, n=3, over=True, **kw)
|
||||
want = ("manual_nocover" if label == "nocover" else
|
||||
"manual_over" if label == "floor" else "manual_full")
|
||||
check(f"T18 ({lang}): phases differ, car over ({label}): {want}",
|
||||
why(c, lang) == exp(lang, want, a="10", pct=pct_))
|
||||
|
||||
# T19/T20 are in the World section. T21-T26: the hold, units.
|
||||
for lang in LANGS:
|
||||
c = U(hold=True, real=1, n=3)
|
||||
t = why(c, lang)
|
||||
check(f"T21 ({lang}): hold, phases differ, not given up: the hold text "
|
||||
f"{t!r}", t == exp(lang, "manual_other") and OTHER[lang] in t
|
||||
and STAYS[lang] not in t and YOU[lang] not in t)
|
||||
for key in ("none", "full"):
|
||||
c = U(hold=True, real=3, n=3)
|
||||
check(f"T22 ({lang}): hold, key {key}: the hold text, not 'set when a "
|
||||
f"car is connected'",
|
||||
why(c, lang, key) == exp(lang, "manual_other"))
|
||||
c = U(hold=True, blocked=True, real=3, n=3)
|
||||
check(f"T23a ({lang}): hold with a stale blocked: the hold text",
|
||||
why(c, lang) == exp(lang, "manual_other"))
|
||||
c = U(hold=True, real=3, n=3, eng=True)
|
||||
check(f"T23b ({lang}): hold with the cover engaged: the hold text",
|
||||
why(c, lang) == exp(lang, "manual_other"))
|
||||
for label, kw in (("floor", dict(floor=True)), ("full", dict(floor=False)),
|
||||
("nocover", dict(cover=False))):
|
||||
c = U(hold=True, over=True, real=3, n=3, **kw)
|
||||
want = ("manual_nocover" if label == "nocover" else
|
||||
"manual_over" if label == "floor" else "manual_full")
|
||||
check(f"T24 ({lang}): hold and car over ({label}): {want}, no hold "
|
||||
f"text", why(c, lang) == exp(lang, want, a="10", pct=pct_)
|
||||
and OTHER[lang] not in why(c, lang))
|
||||
for key in ("charging", "none"):
|
||||
c = U(hold=True, auto=False, real=3, n=3)
|
||||
check(f"T25 ({lang}): hold, control stopped, key {key}: manual_stopped",
|
||||
why(c, lang, key) == exp(lang, "manual_stopped"))
|
||||
c = U(hold=True, shadow=True, over=False, would=(10.0, 3))
|
||||
check(f"T26a ({lang}): hold, shadow, not over: manual_would",
|
||||
why(c, lang) == exp(lang, "manual_would", a="10",
|
||||
phases=pw_l(lang, 3)))
|
||||
c = U(hold=True, shadow=True, over=True, would=(10.0, 3))
|
||||
check(f"T26b ({lang}): hold, shadow, over: the shadow-over text",
|
||||
why(c, lang) == exp(lang, "manual_shadow_over", a="10",
|
||||
phases=pw_l(lang, 3)))
|
||||
|
||||
# T29-T32: E4.
|
||||
for lang in LANGS:
|
||||
for n in (1, 3):
|
||||
c = U(real=n, n=n, would=(10.0, 3))
|
||||
want = (BASE_EN if lang == "en" else BASE_NL)["manual_set"].format(
|
||||
a="10", phases=pw_l(lang, n))
|
||||
check(f"T29 ({lang}): {n}/{n} phases: byte-identical manual_set",
|
||||
why(c, lang) == want)
|
||||
c = U(real=None, n=3)
|
||||
check(f"T30 ({lang}): phases_allowed None: manual_set, no exception",
|
||||
why(c, lang) == sett(lang, c))
|
||||
c = U(real=3, n=1, fresh=False)
|
||||
check(f"T32 ({lang}): reading not fresh: manual_set (stale is unknown)",
|
||||
why(c, lang) == sett(lang, c))
|
||||
c = U(car=Car(None, True))
|
||||
check("T31a: reading None: today's text, no exception",
|
||||
why(c) == sett("en", c))
|
||||
rd = CH.ChargerReading(available=False, phases_allowed=1)
|
||||
c = U(car=Car(rd, True, last_good=None), n=3)
|
||||
check("T31b: reading unavailable (phases 1 vs 3): today's text",
|
||||
why(c) == sett("en", c))
|
||||
c = U(real=1, n=3, pg=None)
|
||||
check("T31c: peak_guard None: no exception, the E2 text",
|
||||
why(c) == exp("en", "manual_phases", a="10", phases="3 phases",
|
||||
real="1 phase"))
|
||||
c = U(real=1, n=3)
|
||||
del c.car
|
||||
check("T31d: no car object at all: no exception, today's text",
|
||||
why(c) == sett("en", c))
|
||||
check("T31: no exception from any of the above", not EXC)
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
print("\n3. E5: the texts")
|
||||
# --------------------------------------------------------------------------- #
|
||||
PH = re.compile(r"\{(\w+)\}")
|
||||
JARGON = {
|
||||
"en": r"controllers?|control loop|setpoints?|SoC|state of charge|BMS|PV|"
|
||||
r"failsafe|trip(?:ped)?|parked|discharg\w*|P1 feed|quarter-hour|"
|
||||
r"payload|endpoint|JSON|API|timeout|boolean|config|commands?|"
|
||||
r"charge level|ceiling|billed quarter|quarters?|banked|soft limit|"
|
||||
r"open block|actuator|ESP32|master|meter source|circulating|"
|
||||
r"sign disagreement|rail",
|
||||
"nl": r"setpoints?|setpunt\w*|SoC|laadtoestand|BMS|PV|failsafe|regelaar|"
|
||||
r"regellus|controller|latch|ontlad\w*|payload|endpoint|JSON|API|"
|
||||
r"time-?out|boolean|config|kwartuur\w*|commando\w*|geparkeerd|"
|
||||
r"ESP32|master",
|
||||
}
|
||||
JARGON = {k: re.compile(r"\b(?:" + v + r")\b", re.I) for k, v in JARGON.items()}
|
||||
samples = {lang: [t for k, t in homeview.text_samples(lang) if k == "plan"]
|
||||
for lang in LANGS}
|
||||
for key in NEW_KEYS:
|
||||
en_t = uitext.raw("en")["home_words"]["car"]["why"].get(key)
|
||||
nl_t = uitext.raw("nl")["home_words"]["car"]["why"].get(key)
|
||||
check(f"T33 {key}: in en.json and nl.json with the same placeholders",
|
||||
isinstance(en_t, str) and isinstance(nl_t, str)
|
||||
and set(PH.findall(en_t)) == set(PH.findall(nl_t)))
|
||||
for lang in LANGS:
|
||||
raw = jwords(lang).get(key, "")
|
||||
vals = {k: "10" for k in PH.findall(raw)}
|
||||
vals.update(phases=pw_l(lang, 3), real=pw_l(lang, 1))
|
||||
shown = tx(lang, key, **vals)
|
||||
sents = re.split(r"(?<=[.!?])\s+", shown)
|
||||
nwords = [len(s.split()) for s in sents]
|
||||
check(f"T33 {key} ({lang}): in text_samples as a plan line, no '{{', "
|
||||
f"<=2 sentences of <=12 words ({nwords}), no jargon: {shown!r}",
|
||||
shown in samples[lang] and "{" not in shown
|
||||
and len(sents) <= 2 and max(nwords) <= 12
|
||||
and not JARGON[lang].search(PH.sub("X", shown)))
|
||||
for lang in LANGS:
|
||||
base = BASE_EN if lang == "en" else BASE_NL
|
||||
words = jwords(lang)
|
||||
check(f"T34 ({lang}): the 9 existing manual_* texts are byte-identical",
|
||||
all(words.get(k) == v for k, v in base.items()) and len(base) == 9)
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
print("\n4. T35: the property sweep (both languages)")
|
||||
# --------------------------------------------------------------------------- #
|
||||
n_calls = 0
|
||||
viol = {"i": [], "ii": [], "iii": [], "iv": []}
|
||||
for (sh, ov, cv, fl, hd, au, bl, eg, sq, key, pa, cn, fr) in itertools.product(
|
||||
(0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1), (0, 1),
|
||||
(None, {"stage": "zero"}), ("charging", "waiting", "none", "full"),
|
||||
(None, 1, 3), (1, 3), (0, 1)):
|
||||
for lang in LANGS:
|
||||
c = U(shadow=bool(sh), over=bool(ov), cover=bool(cv), floor=bool(fl),
|
||||
hold=bool(hd), auto=bool(au), blocked=bool(bl), eng=bool(eg),
|
||||
seq=sq, real=pa,
|
||||
n=cn, fresh=bool(fr), would=(10.0, 3))
|
||||
t = why(c, lang, key)
|
||||
n_calls += 1
|
||||
if sh and YOU[lang] in t:
|
||||
viol["i"].append((lang, t))
|
||||
known = pa is not None and fr
|
||||
if (not sh and au and not ov
|
||||
and (hd or (known and pa != cn and sq is None))
|
||||
and KEEPS[lang] in t):
|
||||
viol["ii"].append((lang, t))
|
||||
if "{" in t or "<EXC" in t:
|
||||
viol["iii"].append((lang, t))
|
||||
sents = re.split(r"(?<=[.!?])\s+", t)
|
||||
if len(sents) > 2 or max(len(s.split()) for s in sents) > 12:
|
||||
viol["iv"].append((lang, t))
|
||||
check(f"T35 (i): shadow mode, no 'You set' anywhere ({n_calls} calls)",
|
||||
n_calls == 2 * 24576 and not viol["i"])
|
||||
check("T35 (ii): no 'keeps it' under hold or a known, fresh phase difference",
|
||||
not viol["ii"])
|
||||
check("T35 (iii): no '{' left, no exception", not viol["iii"] and not EXC)
|
||||
check("T35 (iv): at most 2 sentences of 12 words (the new texts' share)",
|
||||
not [v for v in viol["iv"]
|
||||
if any(k in v[1] for k in ("stays on", "blijft op", "Something else",
|
||||
"Iets anders", "would set the peak",
|
||||
"zou de piek"))])
|
||||
check("T35 (vi)/N2: no render changed the writer, the car or the controller "
|
||||
f"({len(N2_BAD)} did)", not N2_BAD)
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n5. Integration: a real Controller on the charger model")
|
||||
# =========================================================================== #
|
||||
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)
|
||||
CLOCK = [1000.0]
|
||||
freshness.monotonic = lambda: CLOCK[0]
|
||||
|
||||
|
||||
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, setpoint=10, grid=800.0, phases=1):
|
||||
self.sim = SimCharger(setpoint_a=setpoint)
|
||||
self.sim.plug_in()
|
||||
self.sim.phases_allowed = phases
|
||||
self.site = Site(self.sim, grid=grid)
|
||||
self.t = 1000.0
|
||||
CLOCK[0] = self.t
|
||||
self.c = Controller(dict(opts), self.site, _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 act(self, what, value):
|
||||
return await self.c.handle_action(what, value=value)
|
||||
|
||||
def writes(self, what=None):
|
||||
return self.sim.writes(what)
|
||||
|
||||
@property
|
||||
def wr(self):
|
||||
return self.c.car_writer
|
||||
|
||||
|
||||
W_BAD = []
|
||||
|
||||
|
||||
def block_why(w, lang="en"):
|
||||
"""car_block's Why, with N2 and N3 held across the call."""
|
||||
c = w.c
|
||||
before = (snap(c), len(w.sim.log), list(w.drv.sent),
|
||||
len(w.site.charger_writes()))
|
||||
homeview._LANG[0] = uitext.lang_of(lang)
|
||||
try:
|
||||
out = homeview.car_block(c, datetime.now(timezone.utc))
|
||||
t = out["why"] if out else "<no block>"
|
||||
except Exception as e: # noqa: BLE001
|
||||
t = f"<EXC {type(e).__name__} {e}>"
|
||||
finally:
|
||||
homeview._LANG[0] = "en"
|
||||
after = (snap(c), len(w.sim.log), list(w.drv.sent),
|
||||
len(w.site.charger_writes()))
|
||||
if before != after:
|
||||
W_BAD.append(t)
|
||||
return t
|
||||
|
||||
|
||||
def set_text(w, lang="en"):
|
||||
return exp(lang, "manual_set", a=f"{float(w.c.car_a):.0f}",
|
||||
phases=pw_l(lang, w.c.car_n))
|
||||
|
||||
|
||||
async def ready(phases, a, to, ramp=200.0, delay=1.0, shadow="off"):
|
||||
w = World(dict(CAR, shadow_mode=shadow), setpoint=a, phases=phases)
|
||||
await w.step(8)
|
||||
await w.act("car_phases", phases)
|
||||
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
|
||||
await w.act("car_phases", to)
|
||||
return w
|
||||
|
||||
|
||||
async def t8():
|
||||
w = World(dict(CAR, shadow_mode="on"), setpoint=10, phases=3)
|
||||
await w.step(8)
|
||||
await w.act("car_phases", 3)
|
||||
await w.act("car_mode", "manual")
|
||||
await w.act("car_current", 16)
|
||||
await w.step(80)
|
||||
w.c.car_over = True
|
||||
w.c.peak_guard = G(floor_limited=True)
|
||||
return w, {lg: block_why(w, lg) for lg in LANGS}
|
||||
|
||||
|
||||
w8, t8w = run(t8())
|
||||
would_a = nth(w8.wr.would) if w8.wr.would else None
|
||||
check("T8: shadow world, Manual 16 A, car over: shadow-over text in en and "
|
||||
f"nl, no 'You set': {t8w}",
|
||||
w8.c.shadow and present(would_a) and w8.wr.would is not None
|
||||
and all(PEAK[lg] in t8w[lg] and YOU[lg] not in t8w[lg] for lg in LANGS)
|
||||
and t8w["en"] == exp("en", "manual_shadow_over",
|
||||
a=f"{float(w8.wr.would[0]):.0f}",
|
||||
phases=pw(w8.wr.would[1])))
|
||||
check("T8/N3: shadow world: no simulator log, no driver send, no charger "
|
||||
"write", w8.sim.log == [] and w8.drv.sent == []
|
||||
and w8.site.charger_writes() == [])
|
||||
|
||||
|
||||
async def gave_up(refuse_select):
|
||||
# 3 phases wanted -> the sim is on 1; or the other way, as EV-28's T11.
|
||||
w = await ready(3, 16, 1, ramp=(3000.0 if refuse_select else 200.0))
|
||||
if refuse_select:
|
||||
w.sim.request_phases = lambda n: False
|
||||
texts = {}
|
||||
await w.step(40)
|
||||
texts["try1"] = (w.wr.phases_gave_up, w.wr.phase_fails, block_why(w))
|
||||
await w.step(int(PHASE_GAP_S) + 60)
|
||||
await w.step(int(PHASE_GAP_S) + 60)
|
||||
texts["end"] = (w.wr.phases_gave_up, w.wr.phase_fails, block_why(w),
|
||||
block_why(w, "nl"))
|
||||
return w, texts
|
||||
|
||||
|
||||
for label, refuse in (("T11 the car keeps drawing", False),
|
||||
("T12 the select is refused", True)):
|
||||
w_, tt = run(gave_up(refuse))
|
||||
g1, f1, why1 = tt["try1"]
|
||||
ge, fe, whye, whyn = tt["end"]
|
||||
want = exp("en", "manual_phases", a="16", phases="1 phase",
|
||||
real="3 phases")
|
||||
check(f"{label}: after the 3rd failed try the Why is the E2 text "
|
||||
f"{whye!r}", ge and fe == 3 and whye == want
|
||||
and whyn == exp("nl", "manual_phases", a="16",
|
||||
phases=pw_l("nl", 1), real=pw_l("nl", 3))
|
||||
and w_.sim.phases_allowed == 3 and KEEPS["en"] not in whye)
|
||||
check(f"{label}: before the give-up (gap wait) it is manual_blocked "
|
||||
f"{why1!r}", not g1 and f1 >= 1
|
||||
and why1 == exp("en", "manual_blocked"))
|
||||
|
||||
# T19: another writer raises the current during a phase change.
|
||||
|
||||
|
||||
async def other_in_seq():
|
||||
w = World(CAR, 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)
|
||||
mid = (w.wr.seq is not None, block_why(w))
|
||||
w.sim.set_current(9)
|
||||
got = None
|
||||
for _ in range(60):
|
||||
await w.step(1)
|
||||
if w.wr.other:
|
||||
got = (block_why(w), block_why(w, "nl"))
|
||||
break
|
||||
return w, mid, got
|
||||
|
||||
|
||||
w19, mid19, got19 = run(other_in_seq())
|
||||
check("T19: during the sequence the Why is today's manual_set "
|
||||
f"{mid19[1]!r}", mid19[0] and mid19[1] == set_text(w19))
|
||||
check("T19: the first car_block after w.other turns True is the hold text "
|
||||
f"(en and nl): {got19!r}",
|
||||
got19 is not None and got19[0] == exp("en", "manual_other")
|
||||
and got19[1] == exp("nl", "manual_other")
|
||||
and YOU["en"] not in got19[0] and KEEPS["en"] not in got19[0]
|
||||
and STAYS["en"] not in got19[0])
|
||||
|
||||
|
||||
async def t27():
|
||||
w, _m, _g = await other_in_seq()
|
||||
await w.act("car_current", 12)
|
||||
await w.step(5)
|
||||
return w, block_why(w)
|
||||
|
||||
|
||||
w27, why27 = run(t27())
|
||||
okset = {set_text(w27), exp("en", "manual_blocked"),
|
||||
exp("en", "manual_phases", a="12", phases="3 phases",
|
||||
real="1 phase")}
|
||||
check(f"T27: the user changes the current: the hold is lifted and the hold "
|
||||
f"text is gone ({why27!r})", not w27.wr.hold
|
||||
and why27 != exp("en", "manual_other") and why27 in okset)
|
||||
|
||||
# T20 / T28: the other writer on equal phases.
|
||||
|
||||
|
||||
async def other_equal():
|
||||
w = World(CAR, setpoint=10, phases=1)
|
||||
await w.step(8)
|
||||
await w.act("car_phases", 1)
|
||||
await w.act("car_mode", "manual")
|
||||
await w.act("car_current", 10)
|
||||
await w.step(10)
|
||||
pre = block_why(w)
|
||||
t0 = w.t
|
||||
w.sim.set_current(8)
|
||||
before, first, secs = [], None, None
|
||||
for _ in range(60):
|
||||
await w.step(1)
|
||||
if w.wr.other:
|
||||
first, secs = block_why(w), w.t - t0
|
||||
break
|
||||
before.append(block_why(w))
|
||||
held_for = None
|
||||
w.sim.set_current(10)
|
||||
after = []
|
||||
for _ in range(40):
|
||||
await w.step(1)
|
||||
after.append((w.wr.hold, block_why(w)))
|
||||
if not w.wr.hold:
|
||||
break
|
||||
return w, pre, before, first, secs, after
|
||||
|
||||
|
||||
w20, pre20, before20, first20, secs20, after20 = run(other_equal())
|
||||
check("T20: before the hold the Why is today's manual_set, every step "
|
||||
f"({len(before20)} steps)", pre20 == set_text(w20) and before20
|
||||
and all(t == set_text(w20) for t in before20))
|
||||
check(f"T20: the hold text from the first call after w.other turns True, "
|
||||
f"{secs20} s after the write (<= WRITER_S + 5 = 35)",
|
||||
first20 == exp("en", "manual_other") and secs20 is not None
|
||||
and secs20 <= carmode.WRITER_S + 5.0)
|
||||
check("T28: the other writer puts the current back: the hold clears and the "
|
||||
"Why is manual_set in the same step",
|
||||
len(after20) >= 1 and not after20[-1][0]
|
||||
and after20[-1][1] == set_text(w20) and len(after20) <= 5)
|
||||
|
||||
# N2/N3 over every World call above.
|
||||
check(f"N2/N3: every car_block call in the World rows changed nothing and "
|
||||
f"sent nothing ({len(W_BAD)} did)", not W_BAD)
|
||||
|
||||
print()
|
||||
if fails:
|
||||
print(f"{len(fails)} FAILED")
|
||||
sys.exit(1)
|
||||
print("all ok")
|
||||
@@ -0,0 +1,939 @@
|
||||
"""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, the restore on the first available step "
|
||||
f"({[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
|
||||
and [x[1:3] for x in first][:1] == [("current", 10.0)])
|
||||
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 and w.wr.fails == 1,
|
||||
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, one failed write counted",
|
||||
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")
|
||||
Reference in New Issue
Block a user