Solar charges the car from the signed spare sun (car + battery charge - grid import), less the batteries' room (Batteries first) and the sun kept back, whole amps rounded down, at most one change per 30 s and only on 1 A. It starts after ev_start_min of enough sun, holds 6 A for ev_pause_min, then 0 A. Auto phases through EV-04's safe sequence (4.5 kW / 3 min up, 4.0 kW / 5 min down, one switch per 10 min). What the peak guard would ask the batteries for is taken off the car first, at once. Every way out of Solar ends at 0 A, written once; at shutdown before the inverters go to 0 W. - app/carmode.py: SolarPlan (pure) and SolarWriter (ManualWriter's one write site, its sequence and watch); spare_w, car_target_w, amps_for. - app/ctl_car.py: Solar inputs, the cut, the solar kWh, EV-15's grace for Solar's own 0 A, no "set by the car" for Solar; main.py: shutdown order. - Home card, HA select.goodwe_car_sun_first, sensor car_today_solar_kwh, three options with defaults, strings EN/NL, DOCS, DECISIONS, CHANGELOG. - test_ev05.py, test_ev05_long.py, tools/ev05_sun.py; test_ev03/ev04 checks that pinned "Solar is refused" / "three entities" updated. Co-Authored-By: Claude <noreply@anthropic.com>
1267 lines
54 KiB
Python
1267 lines
54 KiB
Python
"""EV-03: the car charger seam, read only. `python3 -B test_ev03.py`
|
|
|
|
1. This card never writes to the charger: a full set of cycles with a charger
|
|
configured makes no write and no service call that names a charger entity,
|
|
and nothing in the add-on calls the seam's write methods.
|
|
2. The seam: entities derived by suffix, a reading believes a value only in its
|
|
own unit, mode3 is the primary car state and the display text a fallback.
|
|
3. Default off changes nothing: the same cycles with the new options at their
|
|
defaults give the same writes, status, rows and sensors as without them.
|
|
4. Options and validator: the census, the refusals, the live limit, the probe.
|
|
5. Unreachable: 30 s, one amber row, one notification after 5 minutes, one
|
|
WARNING; back again, and it is taken down.
|
|
6. The Car card: its states, the today figure and a meter reset, EN and NL.
|
|
7. The car is not the house: the House tile and the house profile, and what a
|
|
stale car reading does (not guessed).
|
|
8. The two-writer detector.
|
|
9. The MQTT sensors.
|
|
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
|
"""
|
|
|
|
import ast
|
|
import asyncio
|
|
import io
|
|
import json
|
|
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 chargers as CH, homeview, messages, mqtt, validate # noqa: E402
|
|
from app.main import Controller # noqa: E402
|
|
from app import freshness, selfconfig # noqa: E402
|
|
import chargersim # noqa: E402
|
|
from chargersim import FakeHa, SimCharger # noqa: E402
|
|
|
|
fails = []
|
|
|
|
|
|
def check(name, cond):
|
|
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
|
if not cond:
|
|
fails.append(name)
|
|
|
|
|
|
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 __init__(self):
|
|
self.values = []
|
|
|
|
def publish(self, v):
|
|
self.values.append(dict(v))
|
|
|
|
def close(self):
|
|
pass
|
|
|
|
|
|
class Site(FakeHa):
|
|
"""The charger model plus a grid, a battery and a solar entity."""
|
|
|
|
def __init__(self, charger, grid=500.0, batt=0.0, pv=2000.0):
|
|
super().__init__(charger)
|
|
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):
|
|
self.sets.append((entity_id, float(value)))
|
|
if entity_id == "number.sp":
|
|
self.batt = float(value)
|
|
return True
|
|
|
|
|
|
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="number.wallbox_power_connector_max_current_socket_1")
|
|
SET = "number.wallbox_power_connector_max_current_socket_1"
|
|
|
|
|
|
CLOCK = [1000.0]
|
|
freshness.monotonic = lambda: CLOCK[0] # one clock for the whole file
|
|
|
|
|
|
async def rin(c, t):
|
|
"""`read_inputs` at monotonic second `t`, on the file's one clock."""
|
|
CLOCK[0] = t
|
|
await c.read_inputs(now_mono=t)
|
|
|
|
|
|
def build(opts, site, store=None):
|
|
c = Controller(dict(opts), site, store or _Store(), _Pub(),
|
|
stop=asyncio.Event())
|
|
c.auto = True
|
|
c.dev_min, c.dev_max = -5000.0, 5000.0
|
|
return c
|
|
|
|
|
|
async def run_cycles(c, site, n=12, tick=1.0, sim=None):
|
|
for i in range(n):
|
|
if sim is not None:
|
|
sim.tick(tick)
|
|
await rin(c, 1000.0 + i * tick)
|
|
await c.cycle()
|
|
|
|
|
|
def now_utc():
|
|
return datetime(2026, 11, 15, 9, 30, tzinfo=timezone.utc)
|
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
print("1. THIS CARD NEVER WRITES TO THE CHARGER")
|
|
# --------------------------------------------------------------------------- #
|
|
sim = SimCharger()
|
|
sim.plug_in()
|
|
sim.set_current(10)
|
|
sim.set_phases(3)
|
|
site = Site(sim, grid=800.0)
|
|
c = build(CAR, site)
|
|
asyncio.run(run_cycles(c, site, n=40, sim=sim))
|
|
print(f" {len(site.sets)} number writes, {len(site.calls)} service calls; "
|
|
f"charger power {sim.power_w:.0f} W, state {sim.state}")
|
|
check("PRECONDITION: the charger was read (the car is charging and the card "
|
|
"knows it)", c.car.status(CLOCK[0]) == "charging"
|
|
and c.car.reading.power_w > 1000)
|
|
check("PRECONDITION: the controller did write the inverter (the cycles are "
|
|
"real)", any(e == "number.sp" for e, _v in site.sets))
|
|
check("no number write names a charger entity",
|
|
not [s for s in site.sets if "wallbox" in s[0]])
|
|
check("no service call names a charger entity",
|
|
not [x for x in site.calls if "wallbox" in json.dumps(x[2] or {})])
|
|
check("no service call of any kind is made but a notification",
|
|
all(x[0] == "persistent_notification" for x in site.calls))
|
|
check("the model's own setpoint is where it was (10 A)", sim.setpoint_a == 10)
|
|
check("charger_writes() finds nothing", site.charger_writes() == [])
|
|
|
|
|
|
def callers_of_writes():
|
|
"""(file, line, name) of every call of the seam's write methods outside
|
|
chargers.py itself."""
|
|
out = []
|
|
for root, _d, files in os.walk(os.path.join(HERE, "app")):
|
|
for f in files:
|
|
# EV-04: carmode.py is the one place that writes, and only in
|
|
# Manual (test_ev04.py grades it); chargers.py is the seam.
|
|
if not f.endswith(".py") or f in ("chargers.py", "carmode.py"):
|
|
continue
|
|
tree = ast.parse(io.open(os.path.join(root, f),
|
|
encoding="utf-8").read())
|
|
for n in ast.walk(tree):
|
|
if isinstance(n, ast.Call) and isinstance(n.func,
|
|
ast.Attribute):
|
|
if n.func.attr in ("write_current", "write_phases") or (
|
|
n.func.attr == "release"
|
|
and "charger" in ast.dump(n.func.value)):
|
|
out.append((f, n.lineno, n.func.attr))
|
|
return out
|
|
|
|
|
|
check(f"nothing in the add-on but carmode.py calls write_current, "
|
|
f"write_phases or the charger's release ({callers_of_writes()})",
|
|
not callers_of_writes())
|
|
check("the seam does define them (the next cards use them)",
|
|
all(hasattr(CH.ChargerDriver, m) for m in
|
|
("write_current", "write_phases", "release")))
|
|
_ha = FakeHa(SimCharger())
|
|
_took99 = asyncio.run(CH.AlfenHaDriver(SET, 16).bind(_ha).write_current(99))
|
|
check("the Alfen driver never sends 99 A against a 16 A limit (EV-04: a value "
|
|
"above the clamp is a software fault, not sent)",
|
|
_ha.sets == [] and _took99 is False)
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
print("\n2. THE SEAM")
|
|
# --------------------------------------------------------------------------- #
|
|
ents = CH.entities_for(SET)
|
|
check("the entities come from the setpoint by suffix",
|
|
ents["readback"] == "sensor.wallbox_main_active_max_current_socket_1"
|
|
and ents["state"] == "sensor.wallbox_mode3_state_socket_1"
|
|
and ents["login"] == "binary_sensor.wallbox_https_api_login_status"
|
|
and ents["station"] == "number.wallbox_max_station_current"
|
|
and ents["phases_set"] == "select.wallbox_installation_max_allowed_phases"
|
|
and CH.entities_for(SET.replace("wallbox", "garage_wallbox"))["power"]
|
|
== "sensor.garage_wallbox_active_power_total_socket_1")
|
|
check("a setpoint named otherwise derives nothing",
|
|
CH.entities_for("number.foo") == {} and CH.entities_for("") == {})
|
|
check("the census key is stripped and lowercase",
|
|
CH.census_key(" Number.X ") == "number.x")
|
|
|
|
|
|
def st(eid, state, unit=None):
|
|
a = {"unit_of_measurement": unit} if unit else {}
|
|
return {"entity_id": eid, "state": state, "attributes": a}
|
|
|
|
|
|
def states(**over):
|
|
s = SimCharger()
|
|
s.plug_in()
|
|
s.set_current(0) # connected, no current allowed: mode3 B
|
|
s.tick(5)
|
|
d = {r: s.states()[e] for r, e in CH.entities_for(SET).items()}
|
|
d.update(over)
|
|
return d
|
|
|
|
|
|
r = CH.reading_from_states(states())
|
|
check("a good set of states reads: available, connected, not charging (B)",
|
|
r.available and r.state == "B" and r.connected and not r.charging)
|
|
sim2 = SimCharger()
|
|
sim2.plug_in()
|
|
sim2.set_current(10)
|
|
sim2.set_phases(3)
|
|
sim2.tick(5)
|
|
d = {r_: sim2.states()[e] for r_, e in CH.entities_for(SET).items()}
|
|
rc = CH.reading_from_states(d)
|
|
check("charging: C, 6.9 kW, 3 phases of 10 A, read-back 10 A, station 16 A",
|
|
rc.charging and abs(rc.power_w - 6900) < 1 and len(rc.current_a) == 3
|
|
and abs(rc.current_a[0] - 10) < 0.1 and rc.allowed_a == 10
|
|
and rc.station_a == 16 and rc.phases_allowed == 3)
|
|
rk = CH.reading_from_states(dict(d, power=st("x", "6.9", "kW")))
|
|
check("a power in kW is believed in kW (6 900 W)", abs(rk.power_w - 6900) < 1)
|
|
rn = CH.reading_from_states(dict(d, power=st("x", "6900")))
|
|
check("a power with no unit is NOT believed: the reading is unavailable "
|
|
"(cause 'power unit'), never a guess",
|
|
rn.power_w is None and not rn.available and rn.why == "power unit")
|
|
rn = CH.reading_from_states(dict(d, power=st("x", "6900", "V")))
|
|
check("a power in the wrong unit is not believed either (unavailable)",
|
|
rn.power_w is None and not rn.available and rn.why == "power unit")
|
|
re_ = CH.reading_from_states(dict(d, energy=st("x", "4004850", "Wh")))
|
|
check("energy in Wh is believed in Wh (4004.85 kWh)",
|
|
abs(re_.energy_kwh - 4004.85) < 1e-6)
|
|
re_ = CH.reading_from_states(dict(d, energy=st("x", "4004.85", "W")))
|
|
check("energy in a power unit is absent", re_.energy_kwh is None)
|
|
ra = CH.reading_from_states(dict(d, readback=st("x", "10000", "mA")))
|
|
check("a current in mA is believed in mA (10 A)", abs(ra.allowed_a - 10) < 1e-9)
|
|
ra = CH.reading_from_states(dict(d, readback=st("x", "10")))
|
|
check("a current with no unit is absent", ra.allowed_a is None)
|
|
rf = CH.reading_from_states(dict(d, state=st("x", "unknown"),
|
|
display=st("x", "Wait Vehicle Charging")))
|
|
check("mode3 missing: the entity is not there, so the charger is not available",
|
|
not rf.available)
|
|
rf = CH.reading_from_states(dict(d, state=st("x", "STATE_A"),
|
|
display=st("x", "Charging Normal")))
|
|
check("mode3 wins over the display text (A says no car, whatever the text says)",
|
|
rf.state == "A" and rf.connected is False and rf.charging is False)
|
|
for text, want in (("Wait Vehicle Charging", "connected"),
|
|
("EV Connected", "connected"),
|
|
("Cable connected", "connected"),
|
|
("Charging Normal", "charging"),
|
|
("Available", "none"), ("Booting", None)):
|
|
check(f"display fallback: {text!r} is {want}",
|
|
CH.display_class(text) == want)
|
|
check("mode3 letters: STATE_C, C and 'State C' all read C",
|
|
CH.mode3_letter("STATE_C") == "C" and CH.mode3_letter("C") == "C"
|
|
and CH.mode3_letter("State C") == "C")
|
|
check("login off makes the charger unavailable",
|
|
not CH.reading_from_states(dict(d, login=st("x", "off"))).available)
|
|
check("an unavailable required entity makes it unavailable",
|
|
not CH.reading_from_states(dict(d, readback=st("x", "unavailable"))
|
|
).available)
|
|
check("a charger error is carried (0: No Error is none)",
|
|
CH.reading_from_states(d).error is None
|
|
and CH.reading_from_states(dict(d, error=st("x", "17: Overcurrent"))
|
|
).error == "17: Overcurrent")
|
|
check("a missing optional entity (energy) does not make it unavailable",
|
|
CH.reading_from_states(dict(d, energy=None)).available)
|
|
check("UnavailableCharger reads nothing and writes nothing",
|
|
not CH.UnavailableCharger().configured()
|
|
and not asyncio.run(CH.UnavailableCharger().read()).available
|
|
and not asyncio.run(CH.UnavailableCharger().write_current(10)))
|
|
check("build(): off and a missing entity give UnavailableCharger, alfen_ha "
|
|
"with its entity the Alfen driver",
|
|
isinstance(CH.build(BASE), CH.UnavailableCharger)
|
|
and isinstance(CH.build(dict(BASE, ev_charger="alfen_ha")),
|
|
CH.UnavailableCharger)
|
|
and isinstance(CH.build(CAR), CH.AlfenHaDriver)
|
|
and isinstance(CH.build(dict(CAR, ev_charger="nope")),
|
|
CH.UnavailableCharger))
|
|
pr = asyncio.run(CH.build(CAR).bind(FakeHa(SimCharger())).probe())
|
|
check("the probe finds every entity of the model", pr.ok and not pr.missing
|
|
and pr.station_a == 16)
|
|
pr = asyncio.run(CH.build(CAR).bind(FakeHa(SimCharger(name="other"))).probe())
|
|
check("the probe lists what it does not find, and refuses the charger",
|
|
not pr.ok and "state" in pr.required_missing)
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
print("\n3. DEFAULT OFF CHANGES NOTHING")
|
|
# --------------------------------------------------------------------------- #
|
|
DEFAULTS = dict(BASE, ev_charger="off", ev_current_entity="", ev_max_a=16,
|
|
ev_phases="auto")
|
|
|
|
|
|
def outcome(opts):
|
|
simx = SimCharger()
|
|
simx.plug_in()
|
|
simx.set_current(10)
|
|
sitex = Site(simx, grid=900.0, pv=3000.0)
|
|
cx = build(opts, sitex)
|
|
asyncio.run(run_cycles(cx, sitex, n=15, sim=simx))
|
|
p = cx.status_payload()
|
|
p.pop("events", None)
|
|
chk = cx.checks()
|
|
return {"sets": list(sitex.sets), "calls": list(sitex.calls),
|
|
"targets": cx.target, "payload_now": p.get("now"),
|
|
"car": p.get("car"),
|
|
"rows": [(x["id"], x["ok"], x["warn"]) for x in chk
|
|
if x["id"] not in ("controller",)],
|
|
"attn": [a["id"] for a in p.get("attention", [])],
|
|
"mqtt": sorted(cx.mqtt.values[-1]) if cx.mqtt.values else None,
|
|
"optional": mqtt.optional_keys(opts),
|
|
"census": validate.actuator_writers(opts),
|
|
"problems": validate.validate_startup_config(opts),
|
|
"hp": cx.house_profile is None}
|
|
|
|
|
|
a, b = outcome(BASE), outcome(DEFAULTS)
|
|
check("with the defaults (charger off) the writes are the same as without "
|
|
"the options", a["sets"] == b["sets"] and a["calls"] == b["calls"]
|
|
and a["targets"] == b["targets"])
|
|
check("...the Home `now` block, the rows and the attention list are the same",
|
|
a["payload_now"] == b["payload_now"] and a["rows"] == b["rows"]
|
|
and a["attn"] == b["attn"])
|
|
check("...there is no Car card, no charger row and no car sensor",
|
|
b["car"] is None and a["car"] is None
|
|
and not [r_ for r_ in b["rows"] if r_[0].startswith("charger")]
|
|
and b["optional"] == ("pv",)
|
|
and not any(str(k).startswith("car") for k in (b["mqtt"] or [])))
|
|
check("...the census and the validator say the same",
|
|
a["census"] == b["census"] and a["problems"] == b["problems"] == [])
|
|
check("...the House tile is grid + solar + battery, the car taken out of "
|
|
"nothing", b["payload_now"]["house_w"] is not None)
|
|
check("a Controller with the charger off holds the null charger and reads it "
|
|
"never",
|
|
isinstance(build(DEFAULTS, Site(SimCharger())).charger,
|
|
CH.UnavailableCharger))
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
print("\n4. OPTIONS AND VALIDATOR")
|
|
# --------------------------------------------------------------------------- #
|
|
check("a charger on with a good entity and 16 A is accepted",
|
|
validate.validate_startup_config(CAR) == [])
|
|
check("an unknown charger is refused, naming the setting",
|
|
any("ev_charger" in p for p in validate.validate_startup_config(
|
|
dict(CAR, ev_charger="tesla"))))
|
|
check("ev_max_a out of 6-40 A is refused (and 5 and 41)",
|
|
all(any("ev_max_a" in p for p in validate.validate_startup_config(
|
|
dict(CAR, ev_max_a=v))) for v in (5, 41, "x")))
|
|
check("ev_phases that is not 1, 3 or auto is refused",
|
|
any("ev_phases" in p for p in validate.validate_startup_config(
|
|
dict(CAR, ev_phases="2"))))
|
|
check("an inverter's setpoint named as the charger is refused (the census)",
|
|
any("ev_current_entity" in p and "number.sp" in p for p in
|
|
validate.validate_startup_config(
|
|
dict(CAR, ev_current_entity="number.sp"))))
|
|
_inv = dict(CAR, setpoint_entity="", inverters=[
|
|
{"name": "a", "setpoint_entity": SET, "max_w": 2500, "bms_soc_floor": 10}])
|
|
check("...also one that sits in the inverter list",
|
|
any("ev_current_entity" in p for p in
|
|
validate.validate_startup_config(_inv)))
|
|
check("...and the same entity with the charger OFF is not a writer, so not "
|
|
"refused", not any("ev_current_entity" in p for p in
|
|
validate.validate_startup_config(
|
|
dict(_inv, ev_charger="off"))))
|
|
check("the charger is not in the inverter census (setup-only still reads 'no "
|
|
"inverter')", SET.lower() not in validate.actuator_writers(CAR)
|
|
and CH.census_entity(CAR) == SET
|
|
and CH.census_entity(dict(CAR, ev_charger="off")) == "")
|
|
msgs = validate.validate_startup_config(dict(CAR, ev_current_entity="number.sp"))
|
|
check("the refusal is at most 30 words and names the label and the key",
|
|
all(len(p.split()) <= 30 for p in msgs)
|
|
and any("“Current setting entity” (ev_current_entity)" in p
|
|
for p in msgs))
|
|
|
|
rows = {eid: {"entity_id": eid, "state": s["state"],
|
|
"unit": s["attributes"].get("unit_of_measurement")}
|
|
for eid, s in SimCharger().states().items()}
|
|
look = validate.charger_probe_for(SET, rows)
|
|
check("the probe lists every entity found, with the limit",
|
|
look["ok"] and look["state"] == "ok" and not look["missing"]
|
|
and look["limit_a"] == 16 and len(look["found"]) == len(CH.ROLES))
|
|
gone = {k: v for k, v in rows.items() if "mode3" not in k}
|
|
look = validate.charger_probe_for(SET, gone)
|
|
check("...and what it does not find (the car state entity)",
|
|
not look["ok"] and ["state", "sensor.wallbox_mode3_state_socket_1"]
|
|
in look["missing"])
|
|
check("...nothing is read when Home Assistant did not answer",
|
|
validate.charger_probe_for(SET, None)["state"] == "unread")
|
|
check("...a setpoint named otherwise says so",
|
|
validate.charger_probe_for("number.foo", rows)["state"] == "no_name")
|
|
notes = validate.config_notes(CAR, entities=gone)
|
|
txt = [n.text for n in notes if "ev_current_entity" in n.keys]
|
|
check("the settings notes name the missing entity",
|
|
any("sensor.wallbox_mode3_state_socket_1" in t for t in txt))
|
|
notes = validate.config_notes(CAR, entities=rows)
|
|
txt = [(n.tier, n.text) for n in notes if "ev_current_entity" in n.keys]
|
|
check("...and say what was found when all is well",
|
|
any(t == "ok" and t2.startswith("Found:") and "16 A" in t2
|
|
for t, t2 in txt))
|
|
nl = [validate.note_text(n, "nl") for n in notes
|
|
if "ev_current_entity" in n.keys]
|
|
check("...in Dutch too", any(t.startswith("Gevonden:") for t in nl))
|
|
lim_notes = validate.config_notes(dict(CAR, ev_max_a=20), entities=rows)
|
|
check("an ev_max_a above the station limit is a note on the settings page",
|
|
any("ev_max_a" in n.keys and "16 A" in n.text for n in lim_notes))
|
|
|
|
# the live refusal of the limit, on the save path
|
|
problems, _unread = asyncio.run(selfconfig.problems_and_ranges(
|
|
dict(CAR, ev_max_a=20), Site(SimCharger())))
|
|
check("saving ev_max_a 20 A with a 16 A station limit is refused, naming the "
|
|
"limit", any("ev_max_a" in p and "16 A" in p for p in problems))
|
|
problems, _unread = asyncio.run(selfconfig.problems_and_ranges(
|
|
dict(CAR), Site(SimCharger())))
|
|
check("...16 A is accepted", not [p for p in problems if "ev_max_a" in p])
|
|
problems, _unread = asyncio.run(selfconfig.problems_and_ranges(
|
|
dict(CAR, ev_max_a=20), Site(SimCharger(name="none"))))
|
|
check("...a charger that cannot be read skips the check (never a guess)",
|
|
not [p for p in problems if "ev_max_a" in p])
|
|
|
|
# run-time: a missing entity refuses the CHARGER, not the add-on
|
|
sim3 = SimCharger(name="other")
|
|
site3 = Site(sim3)
|
|
c3 = build(CAR, site3)
|
|
asyncio.run(run_cycles(c3, site3, n=3, sim=sim3))
|
|
check("a charger whose entities are missing is refused and the add-on runs on "
|
|
"(the inverter is still written)",
|
|
c3.charger_refused == "not_found" and not c3.charger.configured()
|
|
and any(e == "number.sp" for e, _v in site3.sets) and not c3.refused)
|
|
p3 = c3.status_payload()
|
|
check("the Car card says 'Charger not set up', and one amber row",
|
|
p3["car"]["state"] == "setup" and p3["car"]["chip"]
|
|
== "Charger not set up" and p3["car"]["kind"] == "warn"
|
|
and [(x["id"], x["warn"], x["ok"]) for x in c3.checks()
|
|
if x["id"].startswith("charger")] == [("charger_setup", True,
|
|
False)])
|
|
simL = SimCharger(station_a=10)
|
|
siteL = Site(simL)
|
|
cL = build(CAR, siteL)
|
|
asyncio.run(run_cycles(cL, siteL, n=3, sim=simL))
|
|
check("a limit above the charger's station limit refuses the charger too",
|
|
cL.charger_refused == "limit" and cL.status_payload()["car"]["state"]
|
|
== "setup")
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
print("\n5. UNREACHABLE: 30 s, ONE ROW, ONE NOTIFICATION AFTER 5 MINUTES")
|
|
# --------------------------------------------------------------------------- #
|
|
sim = SimCharger()
|
|
sim.plug_in()
|
|
sim.set_current(10)
|
|
site = Site(sim)
|
|
logs = []
|
|
|
|
|
|
class _Cap(logging.Handler):
|
|
def emit(self, rec):
|
|
logs.append((rec.levelname, rec.getMessage()))
|
|
|
|
|
|
log = logging.getLogger("goodwe")
|
|
cap = _Cap()
|
|
log.addHandler(cap)
|
|
log.setLevel(logging.DEBUG)
|
|
c = build(CAR, site)
|
|
|
|
|
|
async def at(t):
|
|
sim.tick(1)
|
|
await rin(c, t)
|
|
await c.cycle()
|
|
|
|
|
|
def mine():
|
|
"""The calls about the charger's notification (the inverter's own clamp
|
|
notices are not what this is grading)."""
|
|
return [x for x in site.calls if (x[2] or {}).get("notification_id")
|
|
== "goodwe_charger_unreachable"]
|
|
|
|
|
|
async def story():
|
|
out = {}
|
|
t = 2000.0
|
|
for _ in range(5):
|
|
await at(t)
|
|
t += 1
|
|
out["ok_state"] = c.car.status(t - 1)
|
|
sim.go_unavailable()
|
|
for k in range(29):
|
|
await at(t)
|
|
t += 1
|
|
out["t29"] = (c.car.status(t - 1), len(mine()))
|
|
for k in range(3):
|
|
await at(t)
|
|
t += 1
|
|
out["t32"] = (c.car.status(t - 1), [x["id"] for x in c.checks()
|
|
if x["id"].startswith("charger")])
|
|
out["card32"] = c.status_payload()["car"]
|
|
out["attn32"] = [(a["id"], a["severity"]) for a in
|
|
c.status_payload()["attention"]
|
|
if a["id"].startswith("charger")]
|
|
for k in range(250):
|
|
await at(t)
|
|
t += 1
|
|
out["t282"] = len([x for x in mine() if x[1] == "create"])
|
|
for k in range(60):
|
|
await at(t)
|
|
t += 1
|
|
out["t342"] = len([x for x in mine() if x[1] == "create"])
|
|
sim.go_unavailable(False)
|
|
for k in range(3):
|
|
await at(t)
|
|
t += 1
|
|
out["back"] = (c.car.status(t - 1), [x[1] for x in mine()])
|
|
return out
|
|
|
|
|
|
S = asyncio.run(story())
|
|
log.removeHandler(cap)
|
|
check("PRECONDITION: while it answers, the car is charging (10 A allowed)",
|
|
S["ok_state"] == "charging")
|
|
check("29 s of unavailable is not yet 'not reachable' and raises nothing",
|
|
S["t29"][0] == "charging" and S["t29"][1] == 0)
|
|
check("32 s: the state is 'unreach' and there is one amber row",
|
|
S["t32"][0] == "unreach" and S["t32"][1] == ["charger"])
|
|
check("the card chip is amber 'Charger not reachable' with the Why that says "
|
|
"what the charger does meanwhile",
|
|
S["card32"]["chip"] == "Charger not reachable"
|
|
and S["card32"]["kind"] == "warn"
|
|
and "keeps its last setting, 10 A" in S["card32"]["why"]
|
|
and "Alfen" in S["card32"]["why"])
|
|
check("Needs attention lists it as a warning",
|
|
S["attn32"] == [("charger", "warning")])
|
|
check("after 4.5 minutes there is still no notification, at 5 there is "
|
|
"exactly one", S["t282"] == 0 and S["t342"] == 1)
|
|
check("...and no second one follows (one notification in all)",
|
|
S["t342"] == 1)
|
|
check("the notification is the 'Charger not reachable' warning",
|
|
any(x[0] == "persistent_notification" and x[1] == "create"
|
|
and x[2]["title"] == "Charger not reachable"
|
|
and x[2]["notification_id"] == "goodwe_charger_unreachable"
|
|
for x in site.calls))
|
|
warns = [m for lv, m in logs if lv == "WARNING" and "charger" in m.lower()]
|
|
check(f"exactly one WARNING line, with its reason code ({warns})",
|
|
len(warns) == 1 and "CHARGER_UNREACHABLE" in warns[0]
|
|
and len(warns[0].split()) <= 25)
|
|
check("when it answers again the notification is taken down and the card "
|
|
"recovers", S["back"][0] == "charging"
|
|
and S["back"][1][-1] == "dismiss")
|
|
check("nothing was written to the charger through all of it",
|
|
site.charger_writes() == [])
|
|
|
|
# the 5-minute rule on its own, with a stale clock
|
|
t = CH.CarTracker()
|
|
bad = CH.ChargerReading(available=False, why="x")
|
|
t.observe(bad, 0.0, now_utc(), "d")
|
|
check("tracker: not unreachable at 29.9 s, unreachable at 30 s, notify at "
|
|
"300 s", not t.unreachable(29.9) and t.unreachable(30.0)
|
|
and not t.notify_due(299.9) and t.notify_due(300.0))
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
print("\n6. THE CAR CARD")
|
|
# --------------------------------------------------------------------------- #
|
|
|
|
|
|
def card(setup, lang="en", **kw):
|
|
sim_ = SimCharger()
|
|
setup(sim_)
|
|
site_ = Site(sim_)
|
|
c_ = build(CAR, site_)
|
|
asyncio.run(run_cycles(c_, site_, n=kw.get("n", 8), sim=sim_))
|
|
if "after" in kw:
|
|
kw["after"](sim_, site_, c_)
|
|
return c_.status_payload(lang=lang), c_
|
|
|
|
|
|
def charging3(s):
|
|
s.plug_in()
|
|
s.set_phases(3)
|
|
s.set_current(16)
|
|
|
|
|
|
p, c6 = card(charging3)
|
|
car = p["car"]
|
|
check("charging: chip Charging, big line '11.0 kW · 16 A · 3 phases'",
|
|
car["chip"] == "Charging" and car["big"] == "11.0 kW · 16 A · 3 phases"
|
|
and car["kind"] == "ok")
|
|
check("...the mode is Off only", car["mode"] == "off")
|
|
check("...Why says the add-on leaves it alone",
|
|
"leaves it alone" in car["why"])
|
|
pn, _c = card(charging3, "nl")
|
|
check("...in Dutch: Laadt, 11,0 kW · 16 A · 3 fasen",
|
|
pn["car"]["chip"] == "Laadt" and pn["car"]["big"]
|
|
== "11,0 kW · 16 A · 3 fasen")
|
|
p, _c = card(lambda s: (s.plug_in(), s.set_current(0)))
|
|
check("connected with no current allowed: 'Connected, waiting'",
|
|
p["car"]["chip"] == "Connected, waiting"
|
|
and p["car"]["big"] == "Connected, not charging.")
|
|
p, _c = card(lambda s: None)
|
|
check("no car: 'No car connected', 'Nothing to charge.'",
|
|
p["car"]["chip"] == "No car connected"
|
|
and p["car"]["big"] == "Nothing to charge."
|
|
and p["car"]["why"] == "No car is connected.")
|
|
pn, _c = card(lambda s: None, "nl")
|
|
check("...in Dutch", pn["car"]["chip"] == "Geen auto aangesloten"
|
|
and pn["car"]["big"] == "Niets te laden.")
|
|
|
|
|
|
def full_car(s):
|
|
s.plug_in()
|
|
s.set_current(10)
|
|
s.car_full()
|
|
|
|
|
|
async def _full_story():
|
|
sim_ = SimCharger()
|
|
full_car(sim_)
|
|
site_ = Site(sim_)
|
|
c_ = build(CAR, site_)
|
|
out = []
|
|
t = 3000.0
|
|
for i in range(130):
|
|
sim_.tick(1)
|
|
await rin(c_, t)
|
|
await c_.cycle()
|
|
if i in (30, 70, 120):
|
|
out.append(c_.car.status(t))
|
|
t += 1
|
|
return out, c_
|
|
|
|
|
|
(early, mid, late), cf = asyncio.run(_full_story())
|
|
check("a car that stopped by itself (B with current allowed) reads 'Connected, "
|
|
"waiting' for 60 s, then 'Car is full'",
|
|
early == "waiting" and mid == "full" and late == "full")
|
|
check("...the card says 'Car is full'",
|
|
cf.status_payload()["car"]["chip"] == "Car is full")
|
|
|
|
|
|
def _slow_c(sim_):
|
|
sim_.plug_in()
|
|
sim_.set_current(10)
|
|
|
|
|
|
async def _c_low():
|
|
sim_ = SimCharger()
|
|
sim_.plug_in()
|
|
sim_.set_current(10)
|
|
sim_.tick(5)
|
|
site_ = Site(sim_)
|
|
c_ = build(CAR, site_)
|
|
t = 5000.0
|
|
seen = []
|
|
for i in range(700):
|
|
sim_.state = "C"
|
|
sim_.power_w = 120.0 # C, under 200 W, 10 A allowed
|
|
await rin(c_, t)
|
|
if i in (300, 650):
|
|
seen.append(c_.car.status(t))
|
|
t += 1
|
|
return seen
|
|
|
|
|
|
check("mode3 C under 200 W for 10 minutes with 6 A or more allowed is full "
|
|
"(not before)", asyncio.run(_c_low()) == ["charging", "full"])
|
|
|
|
# today's energy
|
|
t = CH.CarTracker()
|
|
D = "2026-11-15"
|
|
|
|
|
|
def rd(kwh):
|
|
return CH.ChargerReading(available=True, state="C", power_w=5000.0,
|
|
energy_kwh=kwh, allowed_a=10.0, setpoint_a=10.0)
|
|
|
|
|
|
t.observe(rd(4000.0), 1.0, now_utc(), D)
|
|
t.observe(rd(4001.5), 2.0, now_utc(), D)
|
|
t.observe(rd(4003.0), 3.0, now_utc(), D)
|
|
check("today kWh counts what the meter went up since the day began (3.0)",
|
|
abs(t.today_kwh - 3.0) < 1e-9)
|
|
t.observe(rd(0.4), 4.0, now_utc(), D)
|
|
check("a meter that resets to near zero counts from its new zero (3.4), not a "
|
|
"negative", abs(t.today_kwh - 3.4) < 1e-9)
|
|
t.observe(rd(1.4), 5.0, now_utc(), D)
|
|
check("...and goes on from there (4.4)", abs(t.today_kwh - 4.4) < 1e-9)
|
|
t.observe(rd(1.4), 6.0, now_utc(), "2026-11-16")
|
|
check("a new day starts again at 0", t.today_kwh == 0.0)
|
|
t2 = CH.CarTracker()
|
|
t2.load(t.dump())
|
|
check("it survives a restart through the store", t2.day == "2026-11-16"
|
|
and t2.today_kwh == 0.0 and t2.last_kwh == 1.4)
|
|
t3 = CH.CarTracker()
|
|
t3.observe(CH.ChargerReading(available=True, state="B", power_w=0.0,
|
|
energy_kwh=None), 1.0, now_utc(), D)
|
|
check("a charger with no energy meter has no figure (not 0)",
|
|
t3.today_kwh == 0.0 and t3.last_kwh is None)
|
|
p, c6 = card(charging3)
|
|
check("the card says how much was charged today when it knows",
|
|
p["car"]["today"] is not None and "charged today" in p["car"]["today"])
|
|
check("...and the store holds it", "car_today" in c6.store.data
|
|
and c6.store.data["car_today"]["day"])
|
|
|
|
# the states have words in both languages, and the long ones are split
|
|
with homeview.in_lang("nl"):
|
|
nlw = {k: homeview.car_state_word(k) for k in
|
|
("charging", "waiting", "none", "full", "unreach", "setup", None)}
|
|
check("every state has a Dutch chip", all(nlw.values())
|
|
and nlw["unreach"] == "Laadpaal onbereikbaar")
|
|
check("no entity id is on the card or in its words",
|
|
"wallbox" not in json.dumps(p["car"]) and "sensor." not in json.dumps(
|
|
p["car"]))
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
print("\n7. THE CAR IS NOT THE HOUSE")
|
|
# --------------------------------------------------------------------------- #
|
|
nb = homeview.now_block(grid_w=7000.0, pv_w=1000.0, batt_w=-1000.0,
|
|
has_solar=True, shadow=False)
|
|
nc = homeview.now_block(grid_w=7000.0, pv_w=1000.0, batt_w=-1000.0,
|
|
has_solar=True, shadow=False, car_w=6900.0)
|
|
check("without a charger House is grid + solar + battery (7.0 kW)",
|
|
nb["house_w"] == 7000.0)
|
|
check("with a charger the car's 6.9 kW is not in House (100 W)",
|
|
abs(nc["house_w"] - 100.0) < 1e-9)
|
|
nu = homeview.now_block(grid_w=7000.0, pv_w=1000.0, batt_w=-1000.0,
|
|
has_solar=True, shadow=False, car_unknown=True)
|
|
check("a car that cannot be read leaves House with no figure ('No reading')",
|
|
nu["house_w"] is None and nu["lines"]["house"] == "No reading")
|
|
|
|
sim = SimCharger()
|
|
sim.plug_in()
|
|
sim.set_phases(3)
|
|
sim.set_current(10)
|
|
site = Site(sim, grid=7500.0, batt=0.0, pv=500.0)
|
|
c = build(CAR, site)
|
|
asyncio.run(run_cycles(c, site, n=12, sim=sim))
|
|
n_ = c.status_payload()["now"]
|
|
car_w = c.car.reading.power_w
|
|
check(f"in the real controller House excludes the {car_w:.0f} W car "
|
|
f"(House {n_['house_w']:.0f} W)",
|
|
car_w > 5000 and abs(n_["house_w"] - (site.grid + site.pv + c.site_batt_w
|
|
- car_w)) < 1.0)
|
|
|
|
# the house profile's sample
|
|
samples = []
|
|
|
|
|
|
class _HP:
|
|
def add(self, now, w):
|
|
samples.append(w)
|
|
return False
|
|
|
|
def estimator(self):
|
|
return None
|
|
|
|
|
|
def profile_sample(setup):
|
|
del samples[:]
|
|
sim_ = SimCharger()
|
|
setup(sim_)
|
|
site_ = Site(sim_, grid=7500.0, batt=0.0, pv=500.0)
|
|
opts = dict(CAR, pv_forecast_entity="sensor.fc", battery_modes_enabled=True)
|
|
c_ = build(opts, site_)
|
|
c_.house_profile = _HP()
|
|
asyncio.run(run_cycles(c_, site_, n=12, sim=sim_))
|
|
return c_, site_, list(samples)
|
|
|
|
|
|
c_p, site_p, got = profile_sample(lambda s: (s.plug_in(), s.set_phases(3),
|
|
s.set_current(10)))
|
|
want = site_p.grid + c_p.site_batt_w - c_p.car.reading.power_w
|
|
check(f"the house profile's sample leaves the car out (last sample "
|
|
f"{got[-1]:.0f} W, want {want:.0f} W; the car is "
|
|
f"{c_p.car.reading.power_w:.0f} W)",
|
|
len(got) >= 10 and abs(got[-1] - want) < 1.0
|
|
and c_p.car.reading.power_w > 5000)
|
|
c_q, site_q, got = profile_sample(lambda s: None)
|
|
check(f"with no car the sample is the whole load, as before "
|
|
f"({got[-1]:.0f} W = grid + battery)",
|
|
abs(got[-1] - (site_q.grid + c_q.site_batt_w)) < 1.0)
|
|
# not fresh: the last good reading is long ago and the charger now fails
|
|
c_r, site_r, _g = profile_sample(lambda s: (s.plug_in(), s.set_phases(3),
|
|
s.set_current(10)))
|
|
del samples[:]
|
|
c_r.car.last_ok = 0.0
|
|
site_r.charger.go_unavailable()
|
|
|
|
|
|
async def _stale_cycle():
|
|
await rin(c_r, 1013.0)
|
|
await c_r.cycle()
|
|
|
|
|
|
asyncio.run(_stale_cycle())
|
|
check("a car reading older than stale_input_s: the House profile skips that "
|
|
"moment (None), it does not keep the last car figure",
|
|
samples and samples[-1] is None)
|
|
mono_now = c_r.car_now()
|
|
check("...and the House tile shows no reading, as the rule says "
|
|
"(freshness: the car's power counts only while the last good reading "
|
|
"is within stale_input_s, the meter's own bound)",
|
|
c_r.car.car_w(mono_now) is None and c_r.car_term() == (0.0, True)
|
|
and c_r.status_payload()["now"]["house_w"] is None)
|
|
check("the stale bound is the meter's own (15 s from stale_input_s)",
|
|
CH.CarTracker(stale_s=15.0).stale_s == 15.0
|
|
and build(dict(CAR, stale_input_s=40), Site(SimCharger())
|
|
).car.stale_s == 40.0)
|
|
tt = CH.CarTracker(stale_s=15.0)
|
|
tt.observe(rd(1.0), 100.0, now_utc(), D)
|
|
check("tracker: fresh at 15 s, not at 15.1 s",
|
|
tt.car_w(115.0) == 5000.0 and tt.car_w(115.1) is None)
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
print("\n8. THE TWO-WRITER DETECTOR")
|
|
# --------------------------------------------------------------------------- #
|
|
sim = SimCharger()
|
|
sim.plug_in()
|
|
sim.set_current(10)
|
|
site = Site(sim)
|
|
c = build(CAR, site)
|
|
|
|
|
|
async def writer_story():
|
|
t = 7000.0
|
|
out = {}
|
|
for _ in range(5):
|
|
await rin(c, t)
|
|
t += 1
|
|
out["quiet"] = [x["id"] for x in c.checks() if x["id"] == "charger_writer"]
|
|
sim.set_current(12) # the owner's automation
|
|
await rin(c, t)
|
|
t += 1
|
|
out["changed"] = [(x["id"], x["ok"], x["warn"]) for x in c.checks()
|
|
if x["id"] == "charger_writer"]
|
|
out["attn"] = [(a["id"], a["severity"], a["title"])
|
|
for a in c.status_payload()["attention"]
|
|
if a["id"] == "charger_writer"]
|
|
return out
|
|
|
|
|
|
W = asyncio.run(writer_story())
|
|
check("with nothing changing the charger there is no row", W["quiet"] == [])
|
|
check("a change of the setpoint (another writer) shows the grey info row",
|
|
W["changed"] == [("charger_writer", True, True)])
|
|
check("...in Needs attention as info, titled in plain words",
|
|
W["attn"] == [("charger_writer", "info",
|
|
"Something else changes the charger")])
|
|
check("...in Dutch too", messages.row_charger_writer().nl
|
|
== "Iets anders wijzigt de laadpaal en deze add-on leest alleen.")
|
|
tw = CH.CarTracker()
|
|
tw.observe(CH.ChargerReading(available=True, setpoint_a=10, allowed_a=10), 1,
|
|
now_utc(), D)
|
|
tw.observe(CH.ChargerReading(available=True, setpoint_a=None, allowed_a=10), 2,
|
|
now_utc(), D)
|
|
check("a reading that did not answer (None) is not a change",
|
|
tw.writer_at_utc is None)
|
|
tw.observe(CH.ChargerReading(available=True, setpoint_a=10, allowed_a=8), 3,
|
|
now_utc(), D)
|
|
check("a change of the read-back alone is another writer",
|
|
tw.writer_at_utc is not None)
|
|
check("it stays for an hour and then goes",
|
|
tw.other_writer(now_utc() + timedelta(minutes=59))
|
|
and not tw.other_writer(now_utc() + timedelta(minutes=61)))
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
print("\n9. THE MQTT SENSORS")
|
|
# --------------------------------------------------------------------------- #
|
|
check("the car sensors (EV-05: four, with today's solar kWh) are announced "
|
|
"only with a charger on",
|
|
mqtt.optional_keys(CAR) == ("pv", "car_power", "car_state",
|
|
"car_today_kwh", "car_today_solar_kwh")
|
|
and mqtt.optional_keys(BASE) == ("pv",))
|
|
pl = dict(mqtt.discovery_payloads(include=mqtt.optional_keys(CAR)))
|
|
names = sorted(k for k in pl if "_car_" in k)
|
|
check(f"discovery announces the sensors goodwe_car_power, goodwe_car_state, "
|
|
f"goodwe_car_today_kwh and (EV-05) goodwe_car_today_solar_kwh ({names})",
|
|
[pl[k]["object_id"] for k in names] == [
|
|
"goodwe_car_power", "goodwe_car_state", "goodwe_car_today_kwh",
|
|
"goodwe_car_today_solar_kwh"]
|
|
and all(k.startswith("homeassistant/sensor/") for k in names))
|
|
check("...and no command entity (no select, number or switch for the car)",
|
|
not [k for k in pl if "car" in k and not k.startswith(
|
|
"homeassistant/sensor/")])
|
|
sim = SimCharger()
|
|
sim.plug_in()
|
|
sim.set_phases(3)
|
|
sim.set_current(10)
|
|
site = Site(sim)
|
|
c = build(CAR, site)
|
|
asyncio.run(run_cycles(c, site, n=10, sim=sim))
|
|
c.publish()
|
|
sent = c.mqtt.values[-1]
|
|
check("publish() sends the three car values on their topics",
|
|
sent.get("car_state") == "Charging" and sent["car_power"] > 5000
|
|
and "car_today_kwh" in sent)
|
|
c0 = build(BASE, Site(SimCharger()))
|
|
c0.publish()
|
|
check("...and none of them without a charger",
|
|
not [k for k in c0.mqtt.values[-1] if k.startswith("car_")])
|
|
vals = c.car_values()
|
|
check("published values: state text, power in W, today kWh",
|
|
vals["car_state"] == "Charging" and vals["car_power"] > 5000
|
|
and vals["car_today_kwh"] is not None)
|
|
sim.go_unavailable()
|
|
asyncio.run(run_cycles(c, site, n=40, sim=sim))
|
|
vals = c.car_values()
|
|
check("unreachable: the state says so, power and today are not zero but "
|
|
"absent for power (HA's None payload)",
|
|
vals["car_state"] == "Charger not reachable"
|
|
and vals["car_power"] == mqtt.PAYLOAD_NONE)
|
|
check("an absent number goes out as HA's own 'None' payload, and the PV rule "
|
|
"(ABSENT_AS_UNKNOWN is one key) is not widened",
|
|
mqtt.ABSENT_AS_UNKNOWN == frozenset({"pv"}))
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
print("\n10. ROUND 2: A MISSING POWER READING IS AN UNKNOWN TERM, NEVER AN ERROR")
|
|
# --------------------------------------------------------------------------- #
|
|
import traceback # noqa: E402
|
|
from named_absence import nth # noqa: E402
|
|
|
|
|
|
def bad_power(kind):
|
|
"""A controller with one good reading, then (inside stale_s) an AVAILABLE
|
|
reading whose power is missing: `unavailable`, or in a non-power unit."""
|
|
sim_ = SimCharger()
|
|
sim_.plug_in()
|
|
sim_.set_phases(3)
|
|
sim_.set_current(10)
|
|
site_ = Site(sim_, grid=7500.0, batt=0.0, pv=500.0)
|
|
opts = dict(CAR, pv_forecast_entity="sensor.fc", battery_modes_enabled=True)
|
|
c_ = build(opts, site_)
|
|
del samples[:]
|
|
c_.house_profile = _HP()
|
|
asyncio.run(run_cycles(c_, site_, n=8, sim=sim_))
|
|
good_w = c_.car.reading.power_w
|
|
pw = f"sensor.{sim_.x}_active_power_total_socket_1"
|
|
orig = site_._all
|
|
|
|
def broken():
|
|
out = orig()
|
|
if kind == "unavailable":
|
|
out[pw] = dict(out[pw], state="unavailable")
|
|
else:
|
|
out[pw] = dict(out[pw], attributes={"unit_of_measurement": "V"})
|
|
return out
|
|
site_._all = broken
|
|
del samples[:]
|
|
res = {"good_w": good_w, "err": None}
|
|
try:
|
|
CLOCK[0] = 1000.0 + 8
|
|
asyncio.run(rin(c_, 1008.0)) # 1 s after the good one
|
|
res["fresh"] = c_.car.fresh(CLOCK[0])
|
|
res["avail"] = c_.car.reading.power_w is None
|
|
res["reachable"] = c_.car.reading.available
|
|
res["why"] = c_.car.reading.why
|
|
res["term"] = c_.car_term()
|
|
res["now"] = c_.status_payload()["now"]
|
|
res["card"] = c_.status_payload()["car"]
|
|
asyncio.run(c_.cycle()) # the trade cycle's profile step
|
|
res["sample"] = samples[-1] if samples else "none"
|
|
res["vals"] = c_.car_values()
|
|
except Exception: # noqa: BLE001
|
|
res["err"] = traceback.format_exc().strip().splitlines()[-1]
|
|
return res
|
|
|
|
|
|
for kind in ("unavailable", "wrong unit"):
|
|
r_ = bad_power(kind)
|
|
check(f"{kind}: EXPECTED BEHAVIOUR (round 4): the reading is UNAVAILABLE "
|
|
f"(not 'available without power'), so it goes down the unreachable "
|
|
f"path; its cause is {r_.get('why')!r}, and it is still inside "
|
|
f"stale_s on this first read", r_["err"] is None
|
|
and r_.get("reachable") is False and r_.get("fresh") is True
|
|
and r_.get("avail") is True
|
|
and r_.get("why") == ("power unit" if kind == "wrong unit"
|
|
else "no answer from power"))
|
|
check(f"{kind}: car_term, /status, the trade cycle and the MQTT values do "
|
|
f"not raise ({r_['err']})", r_["err"] is None)
|
|
check(f"{kind}: the term is UNKNOWN (never 0 W): House shows no reading and "
|
|
f"the profile sample is None", r_["err"] is None
|
|
and r_["term"] == (0.0, True) and r_["now"]["house_w"] is None
|
|
and r_["sample"] is None)
|
|
check(f"{kind}: the card shows no power figure and the MQTT power is the "
|
|
f"None payload", r_["err"] is None
|
|
and r_["card"]["power_w"] is None
|
|
and r_["vals"]["car_power"] == mqtt.PAYLOAD_NONE)
|
|
|
|
# E and F: the charger's own error states
|
|
for letter in ("E", "F"):
|
|
rr = CH.ChargerReading(available=True, state=letter, power_w=0.0,
|
|
allowed_a=10.0, setpoint_a=10.0)
|
|
tk = CH.CarTracker()
|
|
tk.observe(rr, 1.0, now_utc(), D)
|
|
check(f"mode3 {letter} is the defined state 'fault', not a blank",
|
|
tk.status(1.0) == "fault")
|
|
sim_f = SimCharger()
|
|
sim_f.plug_in()
|
|
sim_f.set_current(10)
|
|
site_f = Site(sim_f)
|
|
c_f = build(CAR, site_f)
|
|
asyncio.run(run_cycles(c_f, site_f, n=4, sim=sim_f))
|
|
sim_f.fault("E")
|
|
sim_f.tick(1)
|
|
asyncio.run(rin(c_f, 1010.0))
|
|
pf = c_f.status_payload()
|
|
check("fault card (EN): chip, big line, Why, amber",
|
|
pf["car"]["chip"] == "Charger fault" and pf["car"]["kind"] == "warn"
|
|
and pf["car"]["big"] == "The charger reports a fault."
|
|
and pf["car"]["why"] == "The charger reports a fault. Check it at the "
|
|
"charger itself.")
|
|
pfn = c_f.status_payload(lang="nl")
|
|
check("fault card (NL)", pfn["car"]["chip"] == "Laadpaalstoring"
|
|
and pfn["car"]["big"] == "De laadpaal meldt een storing."
|
|
and pfn["car"]["why"] == "De laadpaal meldt een storing. Controleer ze "
|
|
"aan de laadpaal zelf.")
|
|
check("the MQTT state says it too", c_f.car_values()["car_state"]
|
|
== "Charger fault")
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
print("\n11. ROUND 3: THE POWER ENTITY IS REQUIRED, AND READS IN W OR kW")
|
|
# --------------------------------------------------------------------------- #
|
|
PW = "sensor.wallbox_active_power_total_socket_1"
|
|
rows_all = {eid: {"entity_id": eid, "state": s["state"],
|
|
"unit": s["attributes"].get("unit_of_measurement")}
|
|
for eid, s in SimCharger().states().items()}
|
|
no_power = {k: v for k, v in rows_all.items() if k != PW}
|
|
look = validate.charger_probe_for(SET, no_power)
|
|
check("the probe refuses a charger with no power entity",
|
|
not look["ok"] and ["power", PW] in look["missing"])
|
|
look = validate.charger_probe_for(SET, dict(rows_all, **{PW: dict(
|
|
rows_all[PW], unit="V")}))
|
|
check("...and one whose power reads in a wrong unit (V)",
|
|
not look["ok"] and look["power_unit"] == "V")
|
|
check("...and one with no unit at all",
|
|
validate.charger_probe_for(SET, dict(rows_all, **{PW: dict(
|
|
rows_all[PW], unit=None)}))["power_unit"] == "none")
|
|
check("kW is accepted (converted), W too",
|
|
validate.charger_probe_for(SET, dict(rows_all, **{PW: dict(
|
|
rows_all[PW], unit="kW")}))["ok"]
|
|
and validate.charger_probe_for(SET, rows_all)["ok"])
|
|
look = validate.charger_probe_for(SET, dict(rows_all, **{PW: dict(
|
|
rows_all[PW], state="unavailable", unit=None)}))
|
|
check("a power entity that is UNAVAILABLE at probe time is not a refusal (it "
|
|
"is the unreachable path)", look["ok"] and not look["missing"])
|
|
nts = validate.config_notes(CAR, entities=no_power)
|
|
check("the settings note for the missing power entity says the charger is not "
|
|
"used (a warning, not info)",
|
|
any(n.tier == "warn" and PW in n.text and "not used" in n.text
|
|
for n in nts))
|
|
nts = validate.config_notes(CAR, entities=dict(rows_all, **{PW: dict(
|
|
rows_all[PW], unit="V")}))
|
|
check("...and so does a wrong unit",
|
|
any(n.tier == "warn" and "power unit" in n.text for n in nts))
|
|
|
|
|
|
class Hide(Site):
|
|
"""The site, with some of the charger's entities hidden or changed."""
|
|
|
|
def __init__(self, charger, hide=(), unit=None, **kw):
|
|
super().__init__(charger, **kw)
|
|
self.hide, self.unit = set(hide), unit
|
|
|
|
def _all(self):
|
|
out = {k: v for k, v in super()._all().items() if k not in self.hide}
|
|
if self.unit and PW in out:
|
|
out[PW] = dict(out[PW], attributes={"unit_of_measurement":
|
|
self.unit})
|
|
return out
|
|
|
|
|
|
def world(site_factory, opts, n=10):
|
|
"""(controller, the Home now block, the last profile sample)."""
|
|
del samples[:]
|
|
sim_ = SimCharger()
|
|
sim_.plug_in()
|
|
sim_.set_phases(3)
|
|
sim_.set_current(10)
|
|
site_ = site_factory(sim_)
|
|
c_ = build(dict(opts, pv_forecast_entity="sensor.fc",
|
|
battery_modes_enabled=True), site_)
|
|
c_.house_profile = _HP()
|
|
asyncio.run(run_cycles(c_, site_, n=n, sim=sim_))
|
|
return c_, c_.status_payload(), samples[-1] if samples else "none"
|
|
|
|
|
|
c_none, p_none, s_none = world(lambda s_: Site(s_, grid=7500.0, pv=500.0),
|
|
BASE)
|
|
for why, factory, want in (
|
|
("no power entity", lambda s_: Hide(s_, hide={PW}, grid=7500.0,
|
|
pv=500.0), "not_found"),
|
|
("a power entity in V", lambda s_: Hide(s_, unit="V", grid=7500.0,
|
|
pv=500.0), "unit")):
|
|
c_x, p_x, s_x = world(factory, CAR)
|
|
check(f"{why}: the charger is refused as 'not set up' ({c_x.charger_refused})",
|
|
c_x.charger_refused == want and not c_x.charger.configured()
|
|
and p_x["car"]["state"] == "setup"
|
|
and p_x["car"]["chip"] == "Charger not set up")
|
|
check(f"{why}: House and the house profile are as with no charger at all "
|
|
f"(House {p_x['now']['house_w']}, sample {s_x})",
|
|
p_x["now"] == p_none["now"] and s_x == s_none
|
|
and p_x["now"]["house_w"] is not None and s_x is not None)
|
|
check(f"{why}: the add-on still runs (the inverter is written) and one "
|
|
f"amber row says so", any(e == "number.sp" for e, _v in
|
|
c_x.hass.sets)
|
|
and [x["id"] for x in c_x.checks() if x["id"].startswith("charger")]
|
|
== ["charger_setup"])
|
|
check("the unit refusal's Why is plain and in both languages",
|
|
"no power unit" in p_x["car"]["why"]
|
|
and "geen vermogenseenheid" in c_x.status_payload(lang="nl")["car"]["why"])
|
|
# unavailable at start: NOT refused, the unreachable path
|
|
c_u, p_u, _s = world(lambda s_: Hide(s_, grid=7500.0, pv=500.0), CAR, n=3)
|
|
sim_u = SimCharger()
|
|
sim_u.plug_in()
|
|
sim_u.go_unavailable()
|
|
site_u = Site(sim_u)
|
|
c_u2 = build(CAR, site_u)
|
|
asyncio.run(run_cycles(c_u2, site_u, n=40, sim=sim_u))
|
|
check("a charger that is unavailable from the first read is not refused; it "
|
|
"is the unreachable path", c_u2.charger_refused is None
|
|
and c_u2.charger.configured()
|
|
and c_u2.status_payload()["car"]["state"] == "unreach")
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
print("\n12. ROUND 4: A POWER ENTITY THAT CANNOT BE BELIEVED IS UNREACHABLE")
|
|
# --------------------------------------------------------------------------- #
|
|
class PowerSite(Site):
|
|
"""The site, with the charger's power entity overridden: `pw` is
|
|
(state, unit) or None for the model's own."""
|
|
|
|
pw = None
|
|
|
|
def _all(self):
|
|
out = super()._all()
|
|
if self.pw is not None and PW in out:
|
|
st_, un_ = self.pw
|
|
a = {"unit_of_measurement": un_} if un_ else {}
|
|
out[PW] = dict(out[PW], state=st_, attributes=a)
|
|
return out
|
|
|
|
|
|
def story4(segments):
|
|
"""Run (pw override, cycles) segments on one controller. -> what was
|
|
visible at the END of each segment, and the controller."""
|
|
sim_ = SimCharger()
|
|
sim_.plug_in()
|
|
sim_.set_phases(3)
|
|
sim_.set_current(10)
|
|
site_ = PowerSite(sim_, grid=7500.0, batt=0.0, pv=500.0)
|
|
c_ = build(dict(CAR, pv_forecast_entity="sensor.fc",
|
|
battery_modes_enabled=True), site_)
|
|
c_.house_profile = _HP()
|
|
seen, t_ = [], [3000.0]
|
|
|
|
async def go():
|
|
for pw_, n_ in segments:
|
|
site_.pw = pw_
|
|
del samples[:]
|
|
for _ in range(n_):
|
|
sim_.tick(1)
|
|
await rin(c_, t_[0])
|
|
await c_.cycle()
|
|
t_[0] += 1
|
|
p_ = c_.status_payload()
|
|
seen.append({
|
|
"state": p_["car"]["state"], "why": p_["car"]["why"],
|
|
"house": p_["now"]["house_w"], "sample": nth(samples, -1),
|
|
"rows": [x["id"] for x in c_.checks()
|
|
if x["id"].startswith("charger")],
|
|
"car_w": c_.car.car_w(c_.car_now()),
|
|
"notes": len([x for x in site_.calls if (x[2] or {}).get(
|
|
"notification_id") == "goodwe_charger_unreachable"])})
|
|
asyncio.run(go())
|
|
return seen, c_
|
|
|
|
|
|
UNAV, V6900, NOUNIT = ("unavailable", None), ("6900", "V"), ("6900", None)
|
|
for label, bad in (("in V", V6900), ("with no unit", NOUNIT)):
|
|
seen, c4 = story4([(UNAV, 3), (bad, 35), (None, 5)])
|
|
check(f"unavailable at start-up (found, not refused), then back {label}: "
|
|
f"after 30 s the visible state is 'Charger not reachable', with the "
|
|
f"amber row, House 'No reading' and the profile sample None",
|
|
c4.charger_refused is None and nth(seen, 1)["state"] == "unreach"
|
|
and nth(seen, 1)["rows"] == ["charger"] and nth(seen, 1)["house"] is None
|
|
and nth(seen, 1)["sample"] is None and nth(seen, 1)["car_w"] is None)
|
|
check(f"...and the Why names the cause (a unit the add-on cannot use)",
|
|
"unit the add-on cannot use" in nth(seen, 1)["why"])
|
|
check(f"...and it recovers when a good unit returns (Charging, House and "
|
|
f"the profile back)", nth(seen, 2)["state"] == "charging"
|
|
and nth(seen, 2)["rows"] == [] and nth(seen, 2)["house"] is not None
|
|
and nth(seen, 2)["sample"] is not None)
|
|
seen, c4 = story4([(None, 10), (V6900, 40), (None, 5)])
|
|
check("unit changed W -> V at run time: before, Charging; after 30 s, "
|
|
"'Charger not reachable', the row, House and profile unknown",
|
|
nth(seen, 0)["state"] == "charging" and nth(seen, 1)["state"] == "unreach"
|
|
and nth(seen, 1)["rows"] == ["charger"] and nth(seen, 1)["house"] is None
|
|
and nth(seen, 1)["sample"] is None and nth(seen, 2)["state"] == "charging")
|
|
_c_nl = story4([(None, 10), (V6900, 40)])[1]
|
|
check("...and the Dutch Why names it too", "onbruikbare eenheid"
|
|
in _c_nl.status_payload(lang="nl")["car"]["why"])
|
|
seen, c4 = story4([(None, 10), (V6900, 320)])
|
|
check("...and after 5 minutes there is exactly one notification",
|
|
nth(seen, 1)["notes"] == 1)
|
|
seen, c4 = story4([(None, 6), (("6900000", "mW"), 10)])
|
|
check("W -> mW is accepted, converted exactly (6 900 000 mW is 6 900 W): "
|
|
"still Charging, no row, House excludes the car, the profile too",
|
|
nth(seen, 1)["state"] == "charging" and nth(seen, 1)["rows"] == []
|
|
and abs(nth(seen, 1)["car_w"] - 6900.0) < 1e-6 and nth(seen, 1)["house"] is not None
|
|
and nth(seen, 1)["sample"] is not None)
|
|
seen, c4 = story4([(("0.0069", "MW"), 10)])
|
|
check("MW is accepted (0.0069 MW is 6 900 W)",
|
|
abs(nth(seen, 0)["car_w"] - 6900.0) < 1e-6 and nth(seen, 0)["state"] == "charging")
|
|
seen, c4 = story4([(("6.9", "kW"), 10)])
|
|
check("kW still is (6.9 kW is 6 900 W)", abs(nth(seen, 0)["car_w"] - 6900.0) < 1e-6)
|
|
check("the start-up probe accepts every HA power unit and refuses V",
|
|
all(validate.charger_probe_for(SET, dict(rows_all, **{PW: dict(
|
|
rows_all[PW], unit=u)}))["ok"] for u in ("mW", "W", "kW", "MW"))
|
|
and not validate.charger_probe_for(SET, dict(rows_all, **{PW: dict(
|
|
rows_all[PW], unit="V")}))["ok"])
|
|
|
|
print()
|
|
if fails:
|
|
print(f"{len(fails)} FAILED")
|
|
for f_ in fails:
|
|
print(" -", f_)
|
|
sys.exit(1)
|
|
print("all passed")
|