EV-10, EV-11, EV-12: car-alone peak alarm, steady car-over row, own write is not another writer #258

Merged
admin merged 5 commits from EV-10 into release/1.0 2026-11-16 20:54:31 +01:00
6 changed files with 691 additions and 17 deletions
+1
View File
@@ -3,6 +3,7 @@
### Not in a release yet
- The *Car* card can now charge: choose **Manual** and set the current (6 A up to the charger limit) and 1 or 3 phases, on Home or from Home Assistant. The car is never slowed for the peak limit, the add-on says so instead of raising false peak alarms, and the batteries help cover it unless you switch that off. Off still writes nothing ([[EV-04]]).
- Car charger fixes: when the car alone takes the batteries to the peak reserve, the add-on no longer raises "Battery stopped limiting the peak" (the grey "Car over the peak limit" note says it instead); that note and the Car card's reason stay steady instead of flickering; and switching to Off right after the add-on's own change no longer shows "Something else changes the charger".
## 0.23.0
@@ -84,6 +84,34 @@ about 0.8 kW (40 Wh over the 180 s kept) the figure is believed; it cannot hide
an overload that matters. (Round 2 had a 15 Wh slack that cancelled the 50 % rule
up to 1.8 kW; the 40 Wh floor fixes that.)
## EV-10, EV-11, EV-12: the rig's three findings (EV-04 test F-1 to F-3)
- **The car is the cause when the alarm's own test says so, on the same
landing** (EV-10). `car_cycle` (`_car_explains_alarm`) runs the alarm's test on
the period as it is and on the period without the car's fresh, corroborated
average (`car_exclude`): the car explains the alarm only if it is true with the
car and false without it. A saturated guard, and a floor with other batteries
left, use `load_too_high` on the landing (the batteries give only what they
still can). A floor that leaves nothing uses SAFETY-126's `misses_aim` (the
batteries at 0 W from now on), which is latched for the quarter; the add-on keeps
that latch twice, with and without the car, from the same readings. Both reset
at a new quarter and when the guard stops wanting power, and they run every
cycle, so the cover option does not touch them. This holds with the projection
still under the aim (rig: 5888 W against 6000 W). A car of 0 W makes the two the
same, so it explains nothing; a stale, stuck or uncorroborated figure is `None`,
sets the latch without the car, and the normal alarms stand. There is no minimum
car power: the comparison itself is what separates car from house.
- **Steady row, no hold on the alarm** (EV-11). Cause: after the car's own quarter
became the month peak, the aim sat on the grid it made (14.04 kW +-40 W), so
the test crossed the aim every few seconds. `car_over` (row, card, notice) now
stays on until the test has been false for `OVER_OFF_HOLD_S` = 180 s (longer than
the gaps seen on the rig, 150 to 250 s at 50 s sampling, and shorter than a
quarter) and a gap does not restart the 10 s
on-count. `car_explains`, which the alarms read, has no hold.
- **Our own write is ours until its mute ends** (EV-12). The mute of the tracker's
own detector opens before the write and runs 15 s from when it returns, because
the read-back reaches the cycle while the write still waits for it.
## The one write shadow mode allows
When the add-on has paused the car (0 A) for a phase change and has not yet
+7 -2
View File
@@ -248,9 +248,14 @@ class ManualWriter:
"to it until you change it.", cur, known[0])
async def _write(self, drv, a, was, now, tracker) -> bool:
ok = await drv.write_current(a)
self._stamp(now)
tracker.begin_write() # EV-12: the read-back is ours
try:
ok = await drv.write_current(a)
finally:
self._stamp(now)
tracker.end_write(self.last_done)
tracker.note_write(now, was, a)
tracker.end_write(self.last_done)
self.log.append(("current", a, now, ok))
if ok:
self.last_a = a
+11
View File
@@ -716,6 +716,17 @@ class CarTracker:
return None
# -- EV-04: the stuck-reading rule -------------------------------------------
def begin_write(self) -> None:
"""EV-12: a write of ours is in flight. Its read-back can reach the
tracker before `note_write` runs (the write waits for it), so the mute
is open until `end_write`."""
self.mute_until = float("inf")
def end_write(self, now: float) -> None:
"""EV-12: the write returned (or failed). The mute runs
`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
+82 -15
View File
@@ -20,6 +20,10 @@ CAR_PEAK_KEY = "car_peak_q" # {quarter start iso: the car's average W}
CAR_PEAK_MIN_W = 50.0 # a quarter the car hardly touched is not kept
CAR_PEAK_KEEP = 3200 # about a month of quarters
OVER_HOLD_S = peakguard.ALARM_HOLD_S
# EV-11: the card, the row and Why stay on this long after the car stops being
# the cause: longer than the gaps seen on the rig (150 to 250 s at 50 s
# sampling) and shorter than a quarter, or until the session really ends.
OVER_OFF_HOLD_S = 180.0
class CarMixin:
@@ -46,6 +50,10 @@ class CarMixin:
self.car_explains = False # the car alone explains the excess
self.car_over = False # ... held: the card and row say so
self._car_over_since = None
self._car_over_gone = None
self._car_batt_prev = None
self._car_need_real = self._car_need_excl = False # EV-10 latches
self._car_latch_block = None
self._car_over_notified = None # the session a notice was raised for
self._car_session = 0
self._car_prev_state = None
@@ -253,28 +261,84 @@ class CarMixin:
self._car_quarter(real_proj, w, mono)
self._car_session_tick(mono)
explains = over = False
if w is not None and real_proj is not None and target_w is not None \
if real_proj is not None and target_w is not None \
and real_proj.block_start is not None:
# The car explains the excess when the house alone would land the
# period under the aim: what the car takes over the whole period
# (`car_avg_w`) is at least how far the projection is over it.
ex = float(real_proj.projected_w) - float(target_w)
beyond = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex
# EV-10: every cycle, so the latches do not depend on the option.
graded = self._car_explains_alarm(real_proj, guard, target_w, w)
if self.car_cover:
explains = bool(
beyond and guard is not None
and (guard.saturated or guard.floor_limited))
over = explains
else:
over = beyond
explains = over = graded
elif w is not None:
ex = float(real_proj.projected_w) - float(target_w)
over = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex
self.car_explains = explains
# EV-11: on once the condition has stood for OVER_HOLD_S, a short gap
# in it not starting that count again; off only after it has been gone
# for OVER_OFF_HOLD_S. `car_explains` (the alarm decision) has no hold.
if over:
self._car_over_gone = None
if self._car_over_since is None:
self._car_over_since = mono
held = mono - self._car_over_since >= OVER_HOLD_S
if mono - self._car_over_since >= OVER_HOLD_S:
self.car_over = True
else:
self._car_over_since, held = None, False
self.car_over = held
if self._car_over_gone is None:
self._car_over_gone = mono
if mono - self._car_over_gone >= OVER_OFF_HOLD_S:
self.car_over, self._car_over_since = False, None
self._car_over_gone = None
def _car_explains_alarm(self, real_proj, guard, target_w, w) -> bool:
"""EV-10: is the alarm's own test true with the car and false without
its fresh, corroborated share (`car_exclude`), on the same landing? The
tests are the alarms': a saturated guard and a floor with other
batteries left are graded by `load_too_high` on where the period lands
(SAFETY-81 / 87); a floor that leaves nothing is graded by SAFETY-126's
`misses_aim` (the batteries at 0 W from now on), latched for the
quarter. That latch is kept here twice, on the period as it is
(`_car_need_real`) and without the car (`_car_need_excl`), from the
same `misses_aim` and the same batteries reading. Both reset at a new
quarter and when the guard no longer wants power, whatever the cover
option says (this runs every cycle). A car that is 0 W, or untrusted
(`w` None sets the second latch), makes the two equal and explains
nothing."""
batt, prev = self.site_batt_w, self._car_batt_prev
self._car_batt_prev = batt
wants = bool(guard is not None and guard.engaged
and guard.blind is None
and (guard.wanted_w or 0.0) > 0.0)
if real_proj.block_start != self._car_latch_block:
self._car_latch_block = real_proj.block_start
self._car_need_real = self._car_need_excl = False
if not wants:
self._car_need_real = self._car_need_excl = False
if batt is not None and prev is not None:
batt = min(float(batt), float(prev))
excl = self.car_exclude(real_proj, w)
if wants:
if batt is None:
self._car_need_real = self._car_need_excl = True
else:
self._car_need_real = self._car_need_real or \
peakguard.misses_aim(real_proj, batt_w=batt,
target_w=target_w)
self._car_need_excl = self._car_need_excl or w is None or \
peakguard.misses_aim(excl, batt_w=batt, target_w=target_w)
if w is None or batt is None or not wants \
or not (guard.saturated or guard.floor_limited):
return False
if guard.saturated:
rating = self.site_rating_w
elif (guard.floor_w or 0.0) > 0.0 and guard.able_w is not None:
rating = guard.able_w
else:
return bool(not guard.within_aim and self._car_need_real
and not self._car_need_excl)
def high(p):
return peakguard.load_too_high(
p, batt_w=batt, ceiling_w=guard.ceiling_w,
achievable_w=rating)
return bool(high(real_proj) and not high(excl))
def _car_session_tick(self, mono) -> None:
"""A charging session is a plug-in: the state goes from no car to a
@@ -283,6 +347,9 @@ class CarMixin:
if s in (chargers.NONE_,) and self._car_prev_state not in (
None, chargers.NONE_):
self._car_over_notified = None
# The session is over: that is a real end, with no hold.
self.car_over = False
self._car_over_since = self._car_over_gone = None
if s not in (chargers.NONE_, None) and self._car_prev_state in (
chargers.NONE_, None):
self._car_session += 1
+562
View File
@@ -0,0 +1,562 @@
"""EV-10, EV-11, EV-12: three rig findings of EV-04's test (F-1, F-2, F-3).
`python3 -B test_ev10.py`
1. EV-10: the car alone takes the batteries to the peak reserve while the period
is still projected UNDER the aim: no alarm, one grey notice. A stuck car
figure with a house overload, and a house-only drain, still alarm. Mutant:
an uncorroborated car figure in the "period without the car" test.
2. EV-11: the grey row and the Car Why do not flicker while the car keeps the
period over the limit; a real end clears them after OVER_OFF_HOLD_S. The
alarm decision (`car_explains`) has no hold.
3. EV-12: the add-on's own write, and Off within 15 s of it, is never "another
writer"; a real outside change afterwards still shows the row.
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
"""
import asyncio
import dataclasses
import logging
import os
import sys
from datetime import datetime, timedelta, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "tools"))
from app import ctl_car, homeview, chargers as CH # noqa: E402
from app.main import Controller # noqa: E402
from app import freshness # noqa: E402
from chargersim import FakeHa, SimCharger # noqa: E402
import ev04_peak as P # noqa: E402
import safety81_sim as s81 # noqa: E402
import opt11_identity as rig # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
class _Log(logging.Handler):
def __init__(self):
super().__init__(logging.DEBUG)
self.rec = []
def emit(self, r):
self.rec.append((r.levelname, r.getMessage()))
LOG = _Log()
_lg = logging.getLogger("goodwe")
_lg.addHandler(LOG)
_lg.setLevel(logging.DEBUG)
_lg.propagate = False
# =========================================================================== #
print("1. EV-10: THE CAR ALONE TAKES THE BATTERIES TO THE RESERVE (F-1)")
# =========================================================================== #
CAP = 4500.0 # the aim is 4450 W (50 W margin)
HOUSE = 1100.0
def at_reserve(plant, c):
"""The batteries reach the peak reserve late in the period, and the house
eases a little: the period is still projected UNDER the aim."""
plant.soc = 19.0
plant.load = lambda at: 780.0 + plant.ch.power_w
def alarms(r):
return P.ids(r, *P.ALARMS)
UNDER = [] # (second, projected W, aim W) while floor-limited
def watch(first, fn):
"""Events for seconds 840 to 894: `fn` at `first`, and a note of every
cycle in which the guard is floor-limited."""
def note(plant, c):
g = c.peak_guard
if g is not None and g.floor_limited:
UNDER.append((plant.t, g.projected_w, g.target_w))
ev = {t: note for t in range(first - 10, 895)}
ev[first] = lambda plant, c: (fn(plant, c), note(plant, c))
return ev
LOG.rec.clear()
r10 = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, events=watch(850, at_reserve))
ERR10 = [m for lv, m in LOG.rec if lv in ("ERROR", "WARNING")]
check("PRECONDITION: the guard was floor-limited with the projection UNDER "
"the aim (the rig's 5888 W against 6000 W)",
any(p < a for _t, p, a in UNDER))
check("the car alone: no 'Load too high', no 'Battery stopped limiting the "
"peak'", alarms(r10) == [])
rows10 = {x["id"]: x for x in r10["c"].checks()}
check("...no red row; the grey 'Car over the peak limit' row says it",
rows10["peak_guard"]["ok"] is True
and not [x for x in r10["c"].checks()
if x["ok"] is False and not x["warn"]]
and rows10.get("car_over", {}).get("ok") is True)
check("...one grey notice for the session", len(P.ids(r10, P.OVER)) == 1)
check("...no ERROR (or WARNING) line was logged for it", ERR10 == [])
def house_stuck(plant, c):
at_reserve(plant, c)
plant.ch.freeze() # the reading stops moving
plant.ch.unplug() # the car really goes
plant.load = lambda at: 9000.0 + plant.ch.power_w
asyncio.get_event_loop().create_task(c.handle_action("car_current",
value=10))
r10s = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, events=watch(850, house_stuck))
check("a stuck car figure and a house overload at the reserve: the normal "
"alarm still fires",
[n for _t, n in alarms(r10s)]
and all(n in P.ALARMS for _t, n in alarms(r10s)))
def house_drain(plant, c):
plant.soc = 19.0
plant.load = lambda at: 12000.0 + plant.ch.power_w
r10h = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, user_a=6, setpoint=6,
events=watch(600, house_drain))
check("a house-only drain to the reserve with the car charging little: the "
"normal alarm still fires",
alarms(r10h) != [] and not r10h["c"].car_explains)
def plug_late(plant, c):
plant.ch.plug_in()
def house_reserve(plant, c):
plant.soc = 19.0
plant.load = lambda at: 3075.0 + plant.ch.power_w
def swapped_events():
ev = watch(850, house_reserve)
ev[800] = plug_late
return ev
def swapped(mode):
return P.drive(s81.constant(6000.0), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, user_a=6, setpoint=6, mode=mode,
plug=False, events=swapped_events())
r10x = swapped("manual")
r10xo = swapped("off")
check("PRECONDITION (review): a 6 kW HOUSE drains the batteries, the car "
"plugs in late (a small share); the projection is under the aim at the "
"reserve, and Off raises the alarm", alarms(r10xo) != []
and any(p < a for _t, p, a in UNDER))
check("the house drains the batteries and a small car is plugged in: the "
"normal alarm still fires in Manual", alarms(r10x) != [])
r10off = P.drive(s81.constant(HOUSE), dur=895, rating=12000.0, soc=60.0,
cap=CAP, phases=1, mode="off", events=watch(850, at_reserve))
check("PRECONDITION: Off, the same case raises the normal alarm (the false "
"alarm Manual must not make)", alarms(r10off) != [])
# a direct unit of the rule: the car's average, the period without it
class _Car(ctl_car.CarMixin):
def __init__(self, cover=True, w=3700.0):
self.o = {"ev_batt_cover": cover}
self.w = w
self._now = 0.0
self.site_batt_w, self.site_rating_w = 300.0, 5000.0
self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})())
def car_now(self):
return self._now
def car_alarm_w(self):
return self.w
class car: # noqa: N801
@staticmethod
def status(*_a):
return "charging"
@dataclasses.dataclass
class _Proj:
projected_w: float
elapsed_s: float = 850.0
held_w: float = 0.0
block_start: object = datetime(2026, 11, 16, 20, 0, tzinfo=timezone.utc)
def __post_init__(self):
self.held_w = self.projected_w
class _G:
def __init__(self, floor=True, sat=False, within_aim=False):
self.floor_limited, self.saturated = floor, sat
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, 4500.0
self.engaged, self.blind, self.wanted_w = True, None, 300.0
self.within_aim = within_aim
def explains(proj_w, car_w, *, floor=True, cover=True, car_so_far_w=None,
within_aim=False, earlier=(), block=0, c=None, at=0.0):
"""One cycle of `car_cycle` on a stub; `earlier` are projections of
cycles before it in the same quarter (they latch SAFETY-126's test)."""
c = c or _Car(cover, car_w)
c.w = car_w
for k, e in enumerate(tuple(earlier) + (proj_w,)):
p = _Proj(e)
p.block_start = p.block_start + timedelta(minutes=15 * block)
c._now = at - len(earlier) + k
c._carq = {"key": p.block_start,
"ws": ((car_w or 0.0) if car_so_far_w is None else car_so_far_w)
* p.elapsed_s, "mono": c._now}
c.car_cycle(p, _G(floor, within_aim=within_aim), 4450.0, None)
return c.car_explains
check("rule: the alarm's test is true with the car (4468 W, the batteries "
"at 0 W land 4485 W) and false without it (768 W): the car explains it, "
"with the projection under the aim", explains(4468.0, 3700.0))
check("rule: under the aim, the quarter's test latched by the car's share "
"(4600 W earlier), the car explains the alarm (the positive under-aim "
"case; a single 4300 W cycle has no landing miss to explain, so it "
"needs the earlier cycle)", explains(4300.0, 3700.0, earlier=(4600.0,)))
check("rule: where the alarm would not fire anyway nothing is explained",
not explains(4300.0, 3700.0, within_aim=True))
check("rule: without the car it is still over the aim: the car does not "
"explain it", not explains(9000.0, 3700.0))
check("rule: no car power, no explanation", not explains(4300.0, 0.0))
check("rule: ...also when the test was latched earlier in the quarter",
not explains(4300.0, 0.0, earlier=(4600.0,))
and not explains(9000.0, 0.0))
check("rule: an untrusted car figure (None) explains nothing",
not explains(4300.0, None, earlier=(4600.0,)))
# the latches: per quarter, and independent of the cover option
c4 = _Car(True, 3700.0)
explains(9000.0, 3700.0, c=c4, block=0) # the house needs it: latched
check("latch: in the same quarter the house need stays latched, so the car "
"does not explain", not explains(4300.0, 3700.0, c=c4, block=0, at=10.0))
check("latch: a new quarter starts clean: the car alone explains it again",
explains(4300.0, 3700.0, c=c4, block=1, at=1000.0,
earlier=(4600.0,)))
c5 = _Car(False, 3700.0) # cover OFF
explains(9000.0, 3700.0, c=c5, block=0) # the house needs it
c5.o["ev_batt_cover"] = True # ... and the option flips
check("latch: the option flipping to ON does not lose a house need seen "
"while it was off", not explains(4300.0, 3700.0, c=c5, block=0, at=10.0))
c6 = _Car(True, 3700.0)
explains(9000.0, 3700.0, c=c6, block=0)
c6.o["ev_batt_cover"] = False
explains(4300.0, 3700.0, c=c6, block=0, at=10.0)
c6.o["ev_batt_cover"] = True
check("latch: ... nor does flipping it off and on again",
not explains(4300.0, 3700.0, c=c6, block=0, at=20.0))
check("rule: the guard is not floor-limited or saturated: nothing to explain",
not explains(4300.0, 3700.0, floor=False))
# =========================================================================== #
print("\n2. EV-11: THE 'CAR OVER THE PEAK LIMIT' ROW DOES NOT FLICKER (F-2)")
# =========================================================================== #
# The cause (rig p7off 21:18 to 21:45, plant.csv): after 21:15 the car's own
# quarter (14.0 kW) was the month peak, so the aim was that quarter's average
# and the grid of the next ones (14.04 kW, +-40 W of noise) sat ON it. The
# projection crossed the aim every few seconds, `ex > 0` came and went, and
# `car_over` followed it with no hold on the way off.
def over_run(c, secs, proj_of, w_of=lambda t: 11000.0, t0=0.0, target=14000.0,
cover=False):
"""Run `car_cycle` once a second; returns (car_over, car_explains) per second."""
out = []
for k in range(secs):
t = t0 + k
c._now = t
c.w = w_of(t)
p = _Proj(proj_of(t), elapsed_s=300.0 + (t % 400))
c._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s,
"mono": t}
c.car_cycle(p, _G(True), target, None)
out.append((c.car_over, c.car_explains))
return out
def noisy(t):
"""The projection straddles the aim: +-40 W, a new value every 7 s."""
return 14000.0 + (40.0 if int(t // 7) % 2 else -40.0) * (1 + (int(t) % 3))
c11 = _Car(cover=False)
o11 = over_run(c11, 1200, noisy)
flips = sum(1 for a, b in zip(o11, o11[1:]) if a[0] != b[0])
check("while the car keeps the period at the limit the row stays on: one "
"switch on in 20 minutes, none off", flips == 1 and len(o11) == 1200 and o11[-1][0] is True)
check("it turns on after the existing 10 s hold, not later than the first "
"10 s the condition has stood (a gap does not restart the count)",
next((i for i, x in enumerate(o11) if x[0]), 10**6) <= 25)
# the condition on its own, for the PRECONDITION: the same input flips
c11o = _Car(cover=False)
raw = []
for k in range(1200):
c11o._now = float(k)
p = _Proj(noisy(k), elapsed_s=300.0 + (k % 400))
c11o._carq = {"key": p.block_start, "ws": 11000.0 * p.elapsed_s, "mono": k}
ex = p.projected_w - 14000.0
raw.append(ex > 0.0 and c11o.car_avg_w(p, 11000.0) >= ex)
raw_flips = sum(1 for a, b in zip(raw, raw[1:]) if a != b)
check("PRECONDITION: the condition itself flips many times in those 20 "
"minutes", raw_flips > 20)
# a real end: the car stops (no trusted power) after 600 s
c11e = _Car(cover=False)
o11e = over_run(c11e, 1000, lambda t: 14500.0,
w_of=lambda t: 11000.0 if t < 600 else None)
off_at = next((i for i, x in enumerate(o11e) if i > 600 and not x[0]), -1)
check("a real end: the row stays for OVER_OFF_HOLD_S (180 s) and then goes",
off_at == 600 + int(ctl_car.OVER_OFF_HOLD_S)
and not any(x[0] for x in o11e[off_at:]))
o11r = over_run(c11e, 100, lambda t: 14500.0, t0=1000.0)
check("it comes back after the usual 10 s if the condition returns after "
"it went", len(o11r) == 100 and o11r[9][0] is False and o11r[10][0] is True)
# the alarm decision has no hold: a real house overload is never delayed
c11a = _Car(cover=True)
o11a = over_run(c11a, 60, lambda t: 4300.0, target=4450.0)
check("decision 1 on: the car explains it at once (no hold)",
len(o11a) == 60 and o11a[0][1] is True)
c11a.w = None # the figure is not trusted
c11a._now = 61.0
c11a.car_cycle(_Proj(4300.0), _G(True), 4450.0, None)
check("...and the moment the car figure is not trusted it explains nothing, "
"so the normal alarms stand at once (the grey row may stay)",
c11a.car_explains is False)
# the whole thing on the real controller: the Why does not flicker either
def p7_like(plant, c):
plant.load = lambda at: 3000.0 + plant.ch.power_w
r11 = P.drive(s81.constant(HOUSE), dur=700, rating=2000.0, soc=60.0, cap=CAP,
phases=3, opts={"ev_batt_cover": False})
ov = [s[2] for s in r11["snaps"]]
check("real controller, cover off, an 11 kW car: the flag is steady once on",
sum(1 for a, b in zip(ov, ov[1:]) if a != b) <= 1 and ov[-1] is True)
# =========================================================================== #
print("\n3. EV-12: OUR OWN WRITE IS NOT ANOTHER WRITER (F-3)")
# =========================================================================== #
CLOCK = [1000.0]
freshness.monotonic = lambda: CLOCK[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"], "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):
super().__init__(charger, None)
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", 800.0, "W"),
("sensor.soc", 50.0, "%"),
("sensor.batt", 0.0, "W"),
("sensor.pv", 2000.0, "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):
return await super().set_number(entity_id, float(value))
class World:
"""A real Controller on the charger model. While a write waits for its
read-back, the controller's own reading goes on (as in production, where
the cycle runs while the writer task waits): that is how the read-back of
our own write reaches the tracker BEFORE the write returns."""
def __init__(self, setpoint=10):
self.sim = SimCharger(setpoint_a=setpoint)
self.sim.plug_in()
self.sim.lag_s = 2.0 # the rig's read-back lag
self.sim.phases_allowed = 1
self.t = 1000.0
CLOCK[0] = self.t
self.c = Controller(dict(BASE), Site(self.sim), _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
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
await self.c.read_inputs(now_mono=self.t) # the cycle reads on
async def step(self, n=1):
for _ in range(n):
self.sim.tick(1.0)
self.t += 1.0
CLOCK[0] = self.t
await self.c.read_inputs(now_mono=self.t)
await self.c.cycle()
await self.c.car_settle()
def rows(self):
return {r["id"]: r for r in self.c.checks()}
async def own_then_off(wait):
w = World()
await w.step(3)
await w.c.handle_action("car_mode", value="manual")
await w.c.handle_action("car_current", value=12)
await w.step(wait)
await w.c.handle_action("car_mode", value="off")
await w.step(40)
return w
w12 = asyncio.run(own_then_off(2))
check("PRECONDITION: the add-on wrote 12 A and the charger took it",
w12.sim.readback_a == 12 and len(w12.sim.writes("current")) == 1)
check("our own write, then Off 2 s later: no 'Something else changes the "
"charger'", "charger_writer" not in w12.rows()
and w12.c.car.writer_at_utc is None)
w12b = asyncio.run(own_then_off(14))
check("...and 14 s later (inside the 15 s)", "charger_writer" not in
w12b.rows() and w12b.c.car.writer_at_utc is None)
async def own_then_outside():
w = await own_then_off(2)
w.sim.set_current(7) # somebody else, afterwards
await w.step(3)
early = "charger_writer" in w.rows()
await w.step(30)
return early, "charger_writer" in w.rows()
early12, late12 = asyncio.run(own_then_outside())
check("an outside change after that still shows the row (within 30 s)",
late12 is True)
async def manual_own():
w = World()
await w.step(3)
await w.c.handle_action("car_mode", value="manual")
await w.c.handle_action("car_current", value=12)
await w.step(60)
await w.c.handle_action("car_current", value=8)
await w.step(20)
return w
wm = asyncio.run(manual_own())
check("Manual: two writes of ours, never 'another writer' in the tracker",
wm.c.car.writer_at_utc is None and "charger_other" not in wm.rows())
async def failed_write_then_outside(how):
"""A write that RAISES or returns FAILURE must still close the self-mute:
it ends 15 s after the write returned, and a later outside change shows
the row."""
w = World()
await w.step(3)
await w.c.handle_action("car_mode", value="manual")
ret = []
async def bad(a):
await w.sleep(1.0)
ret.append(w.t) # when the write came back
if how == "raise":
raise RuntimeError("the charger link broke")
return False
w.drv.write_current = bad
await w.c.handle_action("car_current", value=12)
await w.step(3) # the write is tried
closed = (bool(ret) and w.c.car.mute_until <= ret[-1] + 15.0 + 1e-6)
await w.c.handle_action("car_mode", value="off")
await w.step(20) # past the 15 s mute
w.sim.set_current(7) # somebody else
await w.step(3)
return w, closed
for how in ("raise", "fail"):
wf, closed = asyncio.run(failed_write_then_outside(how))
check(f"a write that {'raises' if how == 'raise' else 'returns failure'}"
": the mute ends within 15 s of the write's return, and a later "
"outside change shows the row",
closed and "charger_writer" in wf.rows())
print()
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
sys.exit(1 if fails else 0)