diff --git a/goodwe_controller/CHANGELOG.md b/goodwe_controller/CHANGELOG.md index 45fac1e..93c0a05 100644 --- a/goodwe_controller/CHANGELOG.md +++ b/goodwe_controller/CHANGELOG.md @@ -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 diff --git a/goodwe_controller/DECISIONS/EV-04-manual-mode.md b/goodwe_controller/DECISIONS/EV-04-manual-mode.md index c9585bc..9b099a2 100644 --- a/goodwe_controller/DECISIONS/EV-04-manual-mode.md +++ b/goodwe_controller/DECISIONS/EV-04-manual-mode.md @@ -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 diff --git a/goodwe_controller/app/carmode.py b/goodwe_controller/app/carmode.py index 347988f..0284b15 100644 --- a/goodwe_controller/app/carmode.py +++ b/goodwe_controller/app/carmode.py @@ -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 diff --git a/goodwe_controller/app/chargers.py b/goodwe_controller/app/chargers.py index f02a573..ed62829 100644 --- a/goodwe_controller/app/chargers.py +++ b/goodwe_controller/app/chargers.py @@ -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 diff --git a/goodwe_controller/app/ctl_car.py b/goodwe_controller/app/ctl_car.py index 52587a6..b9c0cab 100644 --- a/goodwe_controller/app/ctl_car.py +++ b/goodwe_controller/app/ctl_car.py @@ -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 diff --git a/goodwe_controller/test_ev10.py b/goodwe_controller/test_ev10.py new file mode 100644 index 0000000..eaea080 --- /dev/null +++ b/goodwe_controller/test_ev10.py @@ -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)