EV-03: car charger seam, Alfen HA driver, read-only Car card
checks / unit (pull_request) Failing after 37m42s
infra-pin / fresh (pull_request) Successful in 2s

Read-only: nothing in this change writes to the charger.
- app/chargers.py: ChargerDriver, AlfenHaDriver, UnavailableCharger, ChargerReading, CarTracker
- options ev_charger/ev_current_entity/ev_max_a/ev_phases (default off), Settings group, validator, census
- Car card on Home, unreachable row and notification, two-writer info row, MQTT sensors
- car out of the House tile and the house profile
- tools/chargersim.py charger model, test_ev03.py

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
ev03-dev
2026-11-15 09:52:15 +01:00
co-authored by Claude
parent 6bf37597f8
commit 89a2eb0b74
30 changed files with 2656 additions and 23 deletions
+645
View File
@@ -0,0 +1,645 @@
"""EV-03: the car charger seam, and the Alfen driver behind Home Assistant.
SHAPED LIKE `app/drivers.py`'s `Driver` (DECISIONS/EV-03-charger-seam.md): one
actuator per site, a census key, a read, a clamped write that says whether the
charger took it, and a hand-back. A charger is a modulated actuator with a fail
state, not one of DEV-01's on/off loads.
THIS CARD NEVER WRITES TO THE CHARGER. `write_current`, `write_phases` and
`release` are defined so the seam is whole, and NOTHING in the controller calls
them: Off is the only mode. test_ev03.py greps the controller for a call and
proves a full cycle makes no service call that names a charger entity.
VALUES ARE BELIEVED ONLY IN THEIR OWN UNIT (as TEL-11 does for power): power in
a power unit, energy in a kWh unit, current in A. A reading in another unit is
absent, never converted by a guess. ABSENCE IS NEVER ZERO.
The pure half (`CarTracker`, the state words, the entity table) takes its clock
as an argument, so the checks need no sleep.
"""
from __future__ import annotations
import re
from dataclasses import dataclass
from . import pv
from .hass import BAD_STATES
from .solarfc import KWH_PER
OFF = "off"
ALFEN_HA = "alfen_ha"
#: the `ev_charger` values the options accept
SELECTABLE = (OFF, ALFEN_HA)
PHASES_CHOICES = ("1", "3", "auto")
# config.yaml's shipped defaults, mirrored (test_defaults_pin.py checks it).
EV_OPTION_DEFAULTS = {"ev_charger": "off", "ev_current_entity": "",
"ev_max_a": 16, "ev_phases": "auto"}
def max_a(opts: dict):
"""`ev_max_a` as a float, or None when it is not a number."""
raw = opts.get("ev_max_a", EV_OPTION_DEFAULTS["ev_max_a"])
if raw is None or raw == "":
raw = EV_OPTION_DEFAULTS["ev_max_a"]
try:
return float(raw)
except (TypeError, ValueError):
return None
MIN_A = 6.0 # IEC 61851: no car charges below 6 A
ENTITY_MAX_A = 40.0 # the Alfen current entity's own range
# Reachability and the car card's timers, in seconds.
UNREACHABLE_S = 30.0 # entities unavailable / login off this long
NOTIFY_S = 300.0 # then one warning notification
FULL_B_S = 60.0 # mode3 B with current allowed this long: car full
FULL_C_S = 600.0 # mode3 C under FULL_C_W this long: car full
FULL_C_W = 200.0
WRITER_HOLD_S = 3600.0 # "another controller" stays shown this long
IDLE_A = 1.0 # a phase under this draws nothing
# role -> (entity domain, suffix after `<x>_`). `current` is the setpoint, the
# one the installer names; the rest are derived by swapping its suffix.
SETPOINT_SUFFIX = "power_connector_max_current_socket_1"
ROLES = {
"current": ("number", SETPOINT_SUFFIX),
"readback": ("sensor", "main_active_max_current_socket_1"),
"state": ("sensor", "mode3_state_socket_1"),
"display": ("sensor", "display_state_socket_1"),
"power": ("sensor", "active_power_total_socket_1"),
"energy": ("sensor", "meter_reading_socket_1"),
"l1": ("sensor", "current_l1_socket_1"),
"l2": ("sensor", "current_l2_socket_1"),
"l3": ("sensor", "current_l3_socket_1"),
"station": ("number", "max_station_current"),
"station_active": ("sensor", "main_station_active_max_current_socket_1"),
"phases_set": ("select", "installation_max_allowed_phases"),
"phases_read": ("sensor", "connector_1_max_allowed_of_phases"),
"error": ("sensor", "display_error_number_socket_1"),
"login": ("binary_sensor", "https_api_login_status"),
}
#: a missing one of these refuses the charger (not the add-on)
REQUIRED = ("current", "readback", "state")
_SETPOINT_RE = re.compile(r"^number\.(?P<x>.+)_" + SETPOINT_SUFFIX + "$")
_ROLE_ORDER = tuple(ROLES)
def census_key(entity) -> str:
"""The SAFETY-28 form: stripped, lowercase."""
return str(entity or "").strip().lower()
def entities_for(setpoint) -> dict:
"""role -> entity id, derived from the setpoint entity by its suffix.
Empty when the setpoint does not end the way the Alfen integration names it."""
m = _SETPOINT_RE.match(str(setpoint or "").strip())
if not m:
return {}
x = m.group("x")
return {role: f"{dom}.{x}_{suffix}" for role, (dom, suffix) in ROLES.items()}
# --------------------------------------------------------------------------- #
# What a read gives
# --------------------------------------------------------------------------- #
@dataclass(frozen=True)
class ChargerReading:
"""One read of the charger. None means "did not answer", never zero."""
available: bool = False # the integration answers
state: str | None = None # mode3: "A", "B", "C", ... or None
connected: bool | None = None
charging: bool | None = None
power_w: float | None = None
energy_kwh: float | None = None # the meter, total increasing
current_a: tuple = () # per phase, as many as read
setpoint_a: float | None = None # the entity the installer named
allowed_a: float | None = None # read-back of the limit the charger applies
phases_allowed: int | None = None
station_a: float | None = None # the charger's own station limit
error: str | None = None # None: no error (or not read)
display: str | None = None
why: str = "" # for the log only, "" when available
def _state_obj(obj):
"""(text, unit, attributes) of a state object, or (None, "", {})."""
if not isinstance(obj, dict):
return None, "", {}
raw = str(obj.get("state", "")).strip()
attrs = obj.get("attributes") if isinstance(obj.get("attributes"), dict) else {}
unit = str(attrs.get("unit_of_measurement") or "").strip()
return (None if raw.lower() in BAD_STATES else raw), unit, attrs
def _amps(obj):
raw, unit, _ = _state_obj(obj)
if raw is None:
return None
try:
v = float(raw)
except ValueError:
return None
if v != v:
return None
if unit == "A":
return v
if unit == "mA":
return v / 1000.0
return None
def _kwh(obj):
raw, unit, _ = _state_obj(obj)
if raw is None or unit not in KWH_PER:
return None
try:
v = float(raw) * KWH_PER[unit]
except ValueError:
return None
return v if v == v and v >= 0 else None
def _phases(obj):
raw, _u, _ = _state_obj(obj)
m = re.match(r"\s*([13])\s*phase", raw or "", re.I)
return int(m.group(1)) if m else None
_MODE3 = re.compile(r"^(?:STATE[_ ]?)?([A-F])$", re.I)
def mode3_letter(text) -> str | None:
m = _MODE3.match(str(text or "").strip())
return m.group(1).upper() if m else None
def display_class(text) -> str | None:
"""The fallback when mode3 is missing: firmware wording, so only the words
the owner's automation keys on. `connected`, `charging`, `none` or None."""
t = str(text or "").lower()
if not t:
return None
if "wait vehicle" in t or "ev connected" in t or "cable connected" in t:
return "connected"
if "charging" in t:
return "charging"
if t in ("available", "ready", "idle"):
return "none"
return None
def reading_from_states(states: dict) -> ChargerReading:
"""A `ChargerReading` from `{role: state object or None}`. Pure."""
def txt(role):
return _state_obj(states.get(role))[0]
login, state_o = txt("login"), states.get("state")
# Reachable: the three entities the card cannot do without answer, and the
# login sensor is not off.
gone = [r for r in REQUIRED if txt(r) is None]
if gone or (login or "").lower() == "off":
why = ("login off" if not gone else
"no answer from " + ", ".join(gone))
return ChargerReading(available=False, why=why)
letter = mode3_letter(txt("state"))
disp = txt("display")
cls = display_class(disp)
power, _w = pv.watts(states.get("power")) if states.get("power") else (None, "")
currents = tuple(a for a in (_amps(states.get(k)) for k in ("l1", "l2", "l3"))
if a is not None)
if letter is not None:
connected, charging = letter in "BCD", letter in "CD"
elif cls is not None:
connected, charging = cls in ("connected", "charging"), cls == "charging"
else:
connected = charging = None
err = txt("error")
err_none = err is None or err.strip().startswith("0")
return ChargerReading(
available=True, state=letter, connected=connected, charging=charging,
power_w=power, energy_kwh=_kwh(states.get("energy")),
current_a=currents, setpoint_a=_amps(states.get("current")),
allowed_a=_amps(states.get("readback")),
phases_allowed=_phases(states.get("phases_read")),
station_a=_first(_amps(states.get("station_active")),
_amps(states.get("station"))),
error=None if err_none else err, display=disp)
def _first(*vals):
return next((v for v in vals if v is not None), None)
@dataclass(frozen=True)
class ChargerProbe:
"""A read-only look: which derived entities exist."""
setpoint: str = ""
found: tuple = () # ((role, entity), ...)
missing: tuple = ()
station_a: float | None = None
derived: bool = True # False: the setpoint's name does not fit
@property
def required_missing(self) -> tuple:
return tuple(r for r, _e in self.missing if r in REQUIRED)
@property
def ok(self) -> bool:
return self.derived and not self.required_missing
def probe_from(setpoint, exists) -> ChargerProbe:
"""`exists(entity) -> state object or None`. Pure; the caller reads."""
ents = entities_for(setpoint)
if not ents:
return ChargerProbe(setpoint=str(setpoint or ""), derived=False)
found, missing = [], []
for role in _ROLE_ORDER:
(found if exists(ents[role]) is not None else missing).append(
(role, ents[role]))
st = {r: exists(e) for r, e in ents.items()}
return ChargerProbe(str(setpoint), tuple(found), tuple(missing),
station_a=_first(_amps(st.get("station_active")),
_amps(st.get("station"))))
# --------------------------------------------------------------------------- #
# The seam
# --------------------------------------------------------------------------- #
class ChargerNotBound(RuntimeError):
pass
class ChargerDriver:
"""One charger's I/O. Constructed from the options with no Home Assistant;
`bind()` gives it one. Everything that talks to the world is a coroutine."""
name = ""
writer_key = "ev_current_entity"
brand = ""
words: dict = {}
@classmethod
def from_options(cls, opts: dict) -> "ChargerDriver":
raise NotImplementedError
def bind(self, hass) -> "ChargerDriver":
return self
def bind_getter(self, getter) -> "ChargerDriver":
return self
def bound(self) -> bool:
return True
def configured(self) -> bool:
raise NotImplementedError
def actuator_id(self) -> str:
raise NotImplementedError
def entities(self) -> dict:
return {}
async def limits(self) -> tuple:
"""`(min_a, max_a, phases)`; None where unread."""
raise NotImplementedError
async def read(self) -> ChargerReading:
raise NotImplementedError
# --- the write side. DEFINED, UNUSED BY THE CONTROLLER IN THIS CARD. ----
async def write_current(self, a: float) -> bool:
raise NotImplementedError
async def write_phases(self, n: int) -> bool:
raise NotImplementedError
async def release(self, mode: str) -> bool:
raise NotImplementedError
async def probe(self) -> ChargerProbe:
raise NotImplementedError
class AlfenHaDriver(ChargerDriver):
"""The Alfen behind its Home Assistant integration (`alfen_wallbox`)."""
name = ALFEN_HA
brand = "Alfen"
def __init__(self, current_entity="", limit_a=16.0):
self.current_entity = str(current_entity or "").strip()
self.max_a = float(limit_a)
self._ents = entities_for(self.current_entity)
self._hass = None
self._getter = None
@classmethod
def from_options(cls, opts: dict) -> "AlfenHaDriver":
amps = max_a(opts)
return cls(opts.get("ev_current_entity", ""),
EV_OPTION_DEFAULTS["ev_max_a"] if amps is None else amps)
@classmethod
def actuator_id_of(cls, opts: dict) -> str:
return str(opts.get("ev_current_entity") or "").strip()
def bind(self, hass):
self._hass, self._getter = hass, None
return self
def bind_getter(self, getter):
self._hass, self._getter = None, getter
return self
def bound(self) -> bool:
return self._hass is not None or self._getter is not None
def _h(self):
hass = self._getter() if self._getter is not None else self._hass
if hass is None:
raise ChargerNotBound("the charger has no Home Assistant")
return hass
def configured(self) -> bool:
return bool(self._ents)
def actuator_id(self) -> str:
return self.current_entity
def entities(self) -> dict:
return dict(self._ents)
async def _states(self, roles=_ROLE_ORDER) -> dict:
import asyncio
hass = self._h()
got = await asyncio.gather(*(hass.state(self._ents[r]) for r in roles))
return dict(zip(roles, got))
async def limits(self) -> tuple:
st = await self._states(("station", "station_active", "phases_read"))
return (MIN_A, _first(_amps(st["station_active"]), _amps(st["station"])),
_phases(st["phases_read"]))
async def read(self) -> ChargerReading:
if not self.configured():
return ChargerReading(why="not set up")
return reading_from_states(await self._states())
async def probe(self) -> ChargerProbe:
st = await self._states()
by_ent = {self._ents[r]: o for r, o in st.items()}
return probe_from(self.current_entity, by_ent.get)
# --- the write side, UNUSED in EV-03 --------------------------------------
async def write_current(self, a: float) -> bool:
a = max(0.0, min(float(a), self.max_a, ENTITY_MAX_A))
return await self._h().set_number(self.current_entity, a)
async def write_phases(self, n: int) -> bool:
if n not in (1, 3):
return False
return await self._h().call("select", "select_option", {
"entity_id": self._ents["phases_set"],
"option": "1 Phase" if n == 1 else "3 Phases"})
async def release(self, mode: str) -> bool:
return await self.write_current(0.0) if mode == "solar" else True
class UnavailableCharger(ChargerDriver):
"""No charger: `ev_charger` is off, or the charger is refused. `why` says
which, for the Car card; nothing is read and nothing is written."""
name = OFF
def __init__(self, why="off", wanted=""):
self.why = why
self.wanted = wanted
@classmethod
def from_options(cls, opts: dict):
return cls()
def configured(self) -> bool:
return False
def actuator_id(self) -> str:
return ""
async def limits(self) -> tuple:
return None, None, None
async def read(self) -> ChargerReading:
return ChargerReading(why=self.why)
async def write_current(self, a):
return False
async def write_phases(self, n):
return False
async def release(self, mode):
return False
async def probe(self) -> ChargerProbe:
return ChargerProbe()
def mode_of(opts: dict) -> str:
v = str((opts or {}).get("ev_charger") or OFF).strip()
return v if v in SELECTABLE else OFF
def build(opts: dict) -> ChargerDriver:
"""The driver the options name. Off, or a name this build lacks, is
`UnavailableCharger`; nothing here touches Home Assistant."""
which = mode_of(opts)
if which == ALFEN_HA:
drv = AlfenHaDriver.from_options(opts)
if drv.configured():
return drv
return UnavailableCharger("not set up", which)
return UnavailableCharger("off")
def census_entity(opts: dict) -> str:
"""The charger setpoint the SAFETY-28 census counts: only while a charger
is switched on (an off charger writes nothing)."""
if mode_of(opts) == OFF:
return ""
return str(opts.get("ev_current_entity") or "").strip()
# --------------------------------------------------------------------------- #
# The car's state, kept over time
# --------------------------------------------------------------------------- #
CHARGING, WAITING, NONE_, FULL, UNREACH, SETUP = (
"charging", "waiting", "none", "full", "unreach", "setup")
@dataclass
class CarTracker:
"""What the cycle learns about the car from the readings. Pure, clocked by
the caller (monotonic seconds for timers, UTC datetimes for the words).
FRESHNESS (the rule applied, and the one decision EV-03 makes about a stale
car reading): the car's power counts only while the last GOOD reading is not
older than `stale_s`, the same `stale_input_s` bound the meter reading has.
Older than that, `fresh()` is False and the House tile and the house profile
say they do not know, instead of keeping the last car figure."""
stale_s: float = 15.0
reading: ChargerReading | None = None
last_ok: float | None = None
bad_since: float | None = None
bad_since_utc: object = None
notified: bool = False
state_since_utc: object = None
last_status: str | None = None
last_good: ChargerReading | None = None
last_good_utc: object = None
b_since: float | None = None
c_low_since: float | None = None
writer_at_utc: object = None
_prev: tuple | None = None
# today's energy
day: str | None = None
today_kwh: float | None = None
last_kwh: float | None = None
persist: bool = False # set when `today` changed, for the store
def observe(self, r: ChargerReading, now: float, now_utc, day: str):
self.reading = r
usable = r.available and r.power_w is not None
if r.available:
self.bad_since = None
self.bad_since_utc = None
elif self.bad_since is None:
self.bad_since, self.bad_since_utc = now, now_utc
if usable:
self.last_ok = now
self.last_good, self.last_good_utc = r, now_utc
if r.available:
self._writer(r, now_utc)
self._energy(r, day)
self._timers(r, now)
self._status_edge(now, now_utc)
# -- reachability ----------------------------------------------------------
def unreachable(self, now: float) -> bool:
return self.bad_since is not None and now - self.bad_since >= UNREACHABLE_S
def notify_due(self, now: float) -> bool:
return (self.bad_since is not None and not self.notified
and now - self.bad_since >= NOTIFY_S)
def fresh(self, now: float) -> bool:
return self.last_ok is not None and now - self.last_ok <= self.stale_s
def car_w(self, now: float):
"""The car's power now, or None when the reading is not fresh."""
if not self.fresh(now) or self.reading is None or \
not self.reading.available:
return None
return max(0.0, float(self.reading.power_w))
# -- the two-writer detector ----------------------------------------------
def _writer(self, r, now_utc):
cur = (r.setpoint_a, r.allowed_a)
prev = self._prev
if prev is not None:
for a, b in zip(prev, cur):
if a is not None and b is not None and a != b:
self.writer_at_utc = now_utc
# keep the last known value where one read came back empty
self._prev = tuple(b if b is not None else (prev[i] if prev else None)
for i, b in enumerate(cur))
def other_writer(self, now_utc) -> bool:
t = self.writer_at_utc
return t is not None and (now_utc - t).total_seconds() <= WRITER_HOLD_S
# -- today's kWh -----------------------------------------------------------
def load(self, saved):
if isinstance(saved, dict):
try:
self.day = str(saved["day"])
self.today_kwh = float(saved["kwh"])
self.last_kwh = (None if saved.get("last") is None
else float(saved["last"]))
except (KeyError, TypeError, ValueError):
self.day = self.today_kwh = self.last_kwh = None
def dump(self) -> dict:
return {"day": self.day, "kwh": round(self.today_kwh or 0.0, 3),
"last": self.last_kwh}
def _energy(self, r, day):
e = r.energy_kwh
if self.day != day:
self.day, self.today_kwh = day, 0.0
self.last_kwh = e
self.persist = True
return
if e is None:
return
if self.last_kwh is not None:
# a meter that goes back has been reset: count from its new zero
d = e - self.last_kwh if e >= self.last_kwh else e
if d:
self.today_kwh = (self.today_kwh or 0.0) + d
self.persist = True
self.last_kwh = e
if self.today_kwh is None:
self.today_kwh = 0.0
# -- the car's state -------------------------------------------------------
def _timers(self, r, now):
allowed = r.allowed_a is not None and r.allowed_a >= MIN_A
self.b_since = (self.b_since if self.b_since is not None else now) \
if (r.state == "B" and allowed) else None
low = (r.state == "C" and allowed and r.power_w is not None
and r.power_w < FULL_C_W)
self.c_low_since = (self.c_low_since if self.c_low_since is not None
else now) if low else None
def status(self, now: float, configured: bool = True):
"""One of the state words, or None before the first reading."""
if not configured:
return SETUP
if self.unreachable(now):
return UNREACH
r = self.reading
if r is None or not r.available:
return None if self.last_good is None else self.last_status
if r.state == "A" or (r.state is None and r.connected is False):
return NONE_
if r.state in ("B", "C", "D") or r.connected:
if self.b_since is not None and now - self.b_since >= FULL_B_S:
return FULL
if self.c_low_since is not None and \
now - self.c_low_since >= FULL_C_S:
return FULL
return CHARGING if r.charging else WAITING
return None
def _status_edge(self, now, now_utc):
s = self.status(now)
if s != self.last_status and s is not None:
self.last_status, self.state_since_utc = s, now_utc
elif s is None and self.last_status is None:
pass
def phases_in_use(self) -> int | None:
r = self.reading
if r is None or not r.current_a:
return None
n = sum(1 for a in r.current_a if a >= IDLE_A)
return n or None
+23
View File
@@ -401,6 +401,29 @@ class AlarmsMixin:
await self.hass.call("persistent_notification", "dismiss",
messages.prices_back().data())
async def check_charger(self) -> None:
"""EV-03. One warning notification when the car charger has not
answered for 5 minutes, taken down when it does; the WARNING log line
is edge-logged. READ ONLY: this raises a notification and calls no
service on the charger."""
if not self.charger.configured():
return
now = self.car_now()
self.car_log_edges(now)
if self.car.notify_due(now) and not self._car_announced:
self._car_announced = True
self.car.notified = True
since = brussels(self.car.bad_since_utc)
await self.hass.call("persistent_notification", "create",
messages.charger_unreachable(
f"{since:%H:%M}",
self.charger.brand or "Alfen").data())
elif self.car.bad_since is None and self._car_announced:
self._car_announced = False
self.car.notified = False
await self.hass.call("persistent_notification", "dismiss",
messages.charger_back().data())
async def check_fixed_note(self) -> None:
"""PRICE-01 G1. First cycle only: one INFO line when `static_profile`
sits beside `price_service` (the plan's last fallback, not a fault, so
+1
View File
@@ -1047,6 +1047,7 @@ class CycleMixin:
# Not a safety check, so it is one of the cheap ones: an attribute test
# and, on a change only, one Home Assistant call.
await self.check_price_gap()
await self.check_charger()
await self.check_fixed_note()
# SAFETY-31's alarm, and its boundary is the LATCH, not a number: it
+93
View File
@@ -13,7 +13,9 @@ from . import freshness
from . import lateness
from . import messages
from . import pv as pv_read
from . import chargers
from .price import brussels, price_option, provider_configured
from .hass import OUTAGE
from .price_chain import uses_chain
from .static_tariff import static_status
from .rows import tariff_plan_row
@@ -48,6 +50,10 @@ FC_HOLD_KEY = "solar_fc_hold"
FORECAST_READ_S = 60.0
# EV-03: the car's energy today, kept so a restart does not lose it.
CAR_TODAY_KEY = "car_today"
class InputsMixin:
def _readings_late(self, standing_w):
"""SAFETY-128: update the answer gate; seconds the late verdict has
@@ -102,6 +108,89 @@ class InputsMixin:
return "input"
# -- io ------------------------------------------------------------------
# -- EV-03: the car charger, READ ONLY ----------------------------------------
@property
def car_enabled(self) -> bool:
"""`ev_charger` is on, whether or not the charger could be set up."""
return chargers.mode_of(self.o) != chargers.OFF
def car_now(self) -> float:
return freshness.monotonic()
def car_term(self) -> tuple:
"""`(car_w, unknown)`: what the House tile and the house profile take
out for the car. `(0.0, False)` with no charger, so a site without one
is exactly as before. With one, a reading older than `stale_input_s`
(the meter's own bound) is UNKNOWN, never the last figure: the tile
shows no reading and the profile leaves that moment out."""
if not self.charger.configured():
return 0.0, False
w = self.car.car_w(self.car_now())
return (0.0, True) if w is None else (w, False)
async def _read_charger(self, now_mono: float) -> None:
"""One read of the charger, and what the tracker learns from it. It
never raises (telemetry has no foot in the control path) and it only
reads: nothing here, or anywhere in this card, writes to the charger."""
now_utc = datetime.now(timezone.utc)
day = brussels(now_utc).date().isoformat()
try:
if not self._charger_probed:
pr = await asyncio.wait_for(self.charger.probe(), 5.0)
if OUTAGE.waiting():
raise RuntimeError("Home Assistant is not answering")
self._charger_probed = True
self._judge_probe(pr)
if not self.charger.configured():
return
reading = await asyncio.wait_for(self.charger.read(), 5.0)
except Exception as err: # noqa: BLE001
_LOG.debug("The charger could not be read: %s", err)
reading = chargers.ChargerReading(why="no answer")
self.car.observe(reading, now_mono, now_utc, day)
if self.car.persist:
self.car.persist = False
self.store.set(CAR_TODAY_KEY, self.car.dump())
def _judge_probe(self, pr) -> None:
"""A charger whose setpoint, read-back or state entity is missing, or
whose limit is above the station limit, is REFUSED: the add-on starts
and the Car card says so. Said once."""
why = None
if not pr.ok:
why = "not_found"
_LOG.warning("The car charger is not set up, because Home "
"Assistant has no entity it needs: CHARGER_NOT_FOUND.")
_LOG.debug("Charger entities missing: %s.",
", ".join(e for _r, e in pr.missing) or "the name")
else:
amps = chargers.max_a(self.o)
if pr.station_a is not None and amps is not None \
and amps > pr.station_a:
why = "limit"
_LOG.warning("The charger limit is above what the charger "
"allows, so the charger is not used: "
"CHARGER_LIMIT.")
_LOG.debug("ev_max_a %.0f A, station limit %.0f A.", amps,
pr.station_a)
if why is not None:
self.charger_refused = why
self.charger = chargers.UnavailableCharger(why, chargers.ALFEN_HA)
def car_log_edges(self, now_mono: float) -> None:
"""One WARNING when the charger goes unreachable, one INFO when it is
back. Edge-logged, never every cycle."""
down = self.car.unreachable(now_mono)
if down and not self._car_down_logged:
self._car_down_logged = True
_LOG.warning("The car charger does not answer, so the Car card has "
"no reading: CHARGER_UNREACHABLE.")
_LOG.debug("The charger entities read unavailable, or its login "
"is off, for %.0f s.", chargers.UNREACHABLE_S)
elif not down and self._car_down_logged and self.car.bad_since is None:
self._car_down_logged = False
_LOG.info("The car charger answers again.")
@property
def pv_roster(self) -> tuple:
"""Every configured PV production entity, or `()` (TEL-11/TEL-12). ONE
@@ -209,6 +298,10 @@ class InputsMixin:
_reads = [self._read_unit(inv, now_mono) for inv in self.inverters]
if self.pv_roster:
_reads.append(self._read_pv())
# EV-03: the charger, read only, in the same gather. Nothing is added
# without a charger, so a site with none runs exactly as before.
if self.charger.configured():
_reads.append(self._read_charger(now_mono))
# OPT-11 P4: the solar forecast, in the same gather (a slow sensor must
# not delay control), at most once per FORECAST_READ_S.
if self.fc_entity is not None and (
+44 -1
View File
@@ -15,7 +15,8 @@ from .freeze import rail_unreachable, rail_w
from .hass import OUTAGE
from .maintenance import IDLE
from .mqtt import (
announced_units, optional_keys, parse_command, unit_slugs, unit_state_key,
PAYLOAD_NONE, announced_units, optional_keys, parse_command, unit_slugs,
unit_state_key,
)
from . import peakguard
from . import pv as pv_read
@@ -135,6 +136,10 @@ class StatusMixin:
if "pv" in optional_keys(self.o):
values["pv"] = (None if self.pv_w is None
else round(self.pv_w, 1))
# EV-03: the car, only with a charger switched on (the same predicate
# that announces the three sensors). Absence is `None`, never 0.
if "car_state" in optional_keys(self.o):
values.update(self.car_values())
# ⚠️ ONLY when P1 ingestion is running: the ESP32's stale-input
# watchdog subscribes to sensor.goodwe_p1_sample_age and forces layer-1
# failsafe at max_age_s, so with meter_source off a published age would
@@ -161,6 +166,41 @@ class StatusMixin:
values.update(self.mode_values())
self.mqtt.publish(values)
# -- EV-03: the car charger ------------------------------------------------
def car_rows(self) -> list:
"""The charger's status rows: amber when it is not set up or does not
answer, grey while something else changes it."""
if not self.charger.configured():
return [{"ok": False, "warn": True, "id": "charger_setup",
"text": messages.row_charger_setup()}]
out = []
if self.car.unreachable(self.car_now()):
out.append({"ok": False, "warn": True, "id": "charger",
"text": messages.row_charger_unreach(
f"{brussels(self.car.bad_since_utc):%H:%M}")})
if self.car.other_writer(datetime.now(timezone.utc)):
out.append({"ok": True, "warn": True, "id": "charger_writer",
"text": messages.row_charger_writer()})
return out
def car_values(self) -> dict:
"""The MQTT values for the three car sensors."""
now = self.car_now()
state = self.car.status(now, self.charger.configured())
r = self.car.reading
down = state in (None, "unreach", "setup")
with homeview.in_lang("en"):
word = homeview.car_state_word(state)
return {
"car_state": word,
# `ABSENT_AS_UNKNOWN` stays the one PV key (test_pv.py): an absent
# car figure is HA's own "no value" payload, sent by name.
"car_power": (PAYLOAD_NONE if down or r is None
or r.power_w is None else round(r.power_w, 1)),
"car_today_kwh": (PAYLOAD_NONE if self.car.today_kwh is None
else round(self.car.today_kwh, 3)),
}
# -- UI ------------------------------------------------------------------
def checks(self, when: datetime | None = None) -> list:
"""The status rows. `when` is the reference time for anything billed by
@@ -613,6 +653,9 @@ class StatusMixin:
out.append({"ok": False, "warn": True, "id": "pv",
"text": messages.row_pv_stray(
_inv_list.index(ent) + 1)})
# EV-03: the car charger's rows, only with a charger switched on.
if self.car_enabled:
out.extend(self.car_rows())
return out
def status_payload(self, lang: str = "en") -> dict:
+11 -1
View File
@@ -388,8 +388,18 @@ class TradeMixin:
price_now = None
house = (None if self.grid is None or self.site_batt_w is None
else float(self.grid) + float(self.site_batt_w))
# EV-03: the car is not the house. Out of the profile that plans the
# batteries' night charge; with a charger whose reading is not fresh
# the moment is left out (None), not guessed.
# ONLY the profile's sample: `house` below stays what it was, since
# the battery decision's input is not part of this card.
house_sample = house
if house is not None:
_car_w, _car_unknown = self.car_term()
house_sample = (None if _car_unknown else max(0.0, house - _car_w)
if _car_w else house)
if self.house_profile is not None and \
self.house_profile.add(now, house):
self.house_profile.add(now, house_sample):
self.store.set(HOUSE_PROFILE_KEY, self.house_profile.dump())
targets = self.plan_targets()
if targets is None:
+105 -5
View File
@@ -72,16 +72,26 @@ def flow(w, *, shadow=False):
return "resting"
def now_block(*, grid_w, pv_w, batt_w, has_solar, shadow, settled=True):
def now_block(*, grid_w, pv_w, batt_w, has_solar, shadow, settled=True,
car_w=0.0, car_unknown=False):
"""The four tiles. `house_w` needs all three readings, so without a solar
reading it is None rather than a number that leaves the sun out."""
reading it is None rather than a number that leaves the sun out.
EV-03: `car_w` is what a car charger takes, and it is not the house, so it
is taken out of House (the Car card shows it). `car_unknown` is a charger
whose reading is not fresh: House then has no figure rather than one that
may hold the car. Both default to "no charger", the figure as before."""
house, disagree = None, False
if has_solar and None not in (grid_w, pv_w, batt_w):
house = float(grid_w) + float(pv_w) + float(batt_w)
house = float(grid_w) + float(pv_w) + float(batt_w) - float(car_w or 0.0)
if car_unknown:
house = None
# The three are read at slightly different moments, so the sum can dip
# under zero. Inside the idle band that is 0 W; beyond it the readings
# disagree and no house figure is shown.
if house < -IDLE_W:
if house is None:
pass
elif house < -IDLE_W:
house, disagree = None, True
elif house < 0.0:
house = 0.0
@@ -1070,6 +1080,7 @@ ATTN_DOCS = {
"not_keeping_up": messages.T_LOOP_BOUND,
"circulating": messages.T_CIRCULATING,
"delivery": messages.S_NOT_DELIVERING,
"charger": messages.T_CHARGER_UNREACH,
}
@@ -1187,7 +1198,10 @@ def _build(c, *, level, checks, now, held=None, waiting=False):
"sub": banner_sub(kind)},
"now": now_block(grid_w=c.grid, pv_w=c.pv_w, batt_w=c.site_batt_w,
has_solar=bool(c.pv_roster), shadow=shadow,
settled=settled),
settled=settled,
**dict(zip(("car_w", "car_unknown"),
c.car_term()))),
"car": car_block(c, now),
"batteries": rows,
"plan": plan,
"modes_on": bool(getattr(c, "modes_on", False)),
@@ -1208,6 +1222,85 @@ def _docs_url():
messages._site["ha"])
# --------------------------------------------------------------------------- #
# EV-03: the Car card. READ ONLY: Off is the only mode in this version.
# --------------------------------------------------------------------------- #
_CAR_KIND = {"charging": "ok", "full": "ok", "unreach": "warn",
"setup": "warn"}
def car_state_word(key) -> str:
return _t("car.state." + (key if key else "wait"))
def car_phases_word(n) -> str:
return _t("car.phase_one") if n == 1 else _t("car.phase_many", n=n)
def _car_big(key, c, r, good):
if key == "charging" and r is not None and r.power_w is not None:
parts = [_dec(f"{r.power_w / 1000:.1f}")
+ " kW"]
amps = (r.allowed_a if r.allowed_a is not None
else max(r.current_a) if r.current_a else None)
if amps is not None:
parts.append(f"{amps:.0f} A")
n = c.car.phases_in_use()
if n:
parts.append(car_phases_word(n))
return " · ".join(parts)
if key == "unreach":
t = c.car.last_good_utc
return (_t("car.big.seen", t=hhmm(t)) if t is not None
else _t("car.big.no_reading"))
if key == "charging": # the reading is too old
return _t("car.big.no_reading")
return _t("car.big." + (key or "wait"))
def _car_why(key, c, good):
brand = (getattr(c.charger, "brand", "") or "Alfen")
if key == "unreach":
a = None if good is None else good.setpoint_a
if a is None and good is not None:
a = good.allowed_a
if a is not None:
return _t("car.why.unreach_a", a=f"{a:.0f}", brand=brand)
return _t("car.why.unreach", brand=brand)
if key == "setup":
why = {"not_found": "not_found", "limit": "limit"}.get(
c.charger_refused or "", "name")
return _t("car.why." + why)
return _t("car.why." + (key if key else "wait"))
def car_block(c, now):
"""The Car card for `/status`, or None when no charger is switched on (the
page then draws nothing, as before)."""
if not getattr(c, "car_enabled", False):
return None
mono = c.car_now()
configured = c.charger.configured()
key = c.car.status(mono, configured)
r = c.car.reading if configured else None
good = c.car.last_good
fresh = configured and c.car.fresh(mono)
today = None
if configured and c.car.today_kwh is not None:
today = _t("car.today", kwh=_kwh(c.car.today_kwh))
return {
"state": key or "wait",
"chip": car_state_word(key),
"kind": _CAR_KIND.get(key, "muted"),
"big": _car_big(key, c, r if fresh else None, good),
"today": today,
"why": _car_why(key, c, good),
"mode": "off",
"power_w": (None if not fresh or r is None or r.power_w is None
else round(float(r.power_w), 1)),
}
# =========================================================================== #
# The words. STYLE.md: plain, short, present tense. A plan line is at most
# two sentences of at most 12 words each (UX-13 design, section 4); a title at
@@ -1715,6 +1808,13 @@ def _samples() -> list:
out += [("plan", day_note(k, pct=70, name="Battery A", at="08:15",
kwh="9.2 kWh", count="6.4 kWh"))
for k in words["day"]]
out += [("title", _t("car.state." + k)) for k in words["car"]["state"]]
out += [("plan", _t("car.big." + k, t="09:12")) for k in
words["car"]["big"]]
out += [("plan", _t("car.why." + k, a="10", brand="Alfen"))
for k in words["car"]["why"]]
out += [("plan", _t("car.today", kwh="14.2 kWh")),
("plan", "11.0 kW · 16 A · " + _t("car.phase_many", n=3))]
out += [("plan", line_no_trade(k)) for k in
("not_covered", "no_prices", "peak", "not_firm", "not_worth",
"no_level")]
+12
View File
@@ -42,6 +42,7 @@ from .arbiter import (
P_SAFETY, SET, Claim, Resolution, actuator_for, pre_resolve, resolve,
)
from . import allocator
from . import chargers
from . import dayplan
from . import modetrade
from . import packmode
@@ -564,6 +565,17 @@ class Controller(InputsMixin, WritesMixin, TradeMixin, CycleMixin, AlarmsMixin,
self._charge_latch = _load_latch(
(getattr(store, "data", None) or {}).get(CHARGE_LATCH_KEY),
datetime.now(timezone.utc))
# EV-03: the car charger, READ ONLY. Off builds `UnavailableCharger`,
# which reads nothing, so a site without a charger is unchanged.
self.charger = chargers.build(opts)
self.charger.bind_getter(lambda: self.hass)
self.car = chargers.CarTracker(
stale_s=float(opts.get("stale_input_s", 15) or 15))
self.car.load((getattr(store, "data", None) or {}).get("car_today"))
self.charger_refused = None
self._charger_probed = False
self._car_down_logged = False
self._car_announced = False
self.house_profile = None
if self.fc_entity is not None:
self.house_profile = dayplan.HouseProfile(
+53
View File
@@ -186,6 +186,8 @@ T_OUTPUT_CLAMP_NL = "Vermogensvraag te hoog"
T_PEAK_SATURATED_NL = "Belasting te hoog voor de batterij"
T_METER_FROZEN_NL = "Meter staat mogelijk vast"
TITLE_NL = {T_LOOP_BOUND: T_LOOP_BOUND_NL, T_OUTPUT_CLAMP: T_OUTPUT_CLAMP_NL}
T_CHARGER_UNREACH = "Charger not reachable"
T_CHARGER_UNREACH_NL = "Laadpaal onbereikbaar"
T_NO_PRICES = "No prices"
T_NO_PRICES_NL = "Prijzen ontbreken"
@@ -198,6 +200,7 @@ ID_NOT_DELIVERING = "goodwe_not_delivering_{slug}"
ID_METER_FROZEN = "goodwe_meter_frozen"
ID_MAINT_FAILED = "goodwe_maint_failed_{slug}"
ID_NO_PRICES = "goodwe_no_prices"
ID_CHARGER_UNREACH = "goodwe_charger_unreachable"
# PRICE-01: an earlier build raised a card with this id. Nothing raises it now;
# the add-on only dismisses it at start.
OLD_FIXED_CARD_ID = "goodwe_fixed_tariff_unused"
@@ -465,6 +468,43 @@ def row_no_prices(since=None, now=None) -> str:
"Nog geen prijzen, onderhoud wacht.")
def charger_unreachable(since_text_, brand="Alfen") -> Notice:
"""EV-03: the car charger has not answered for 5 minutes. Said once."""
en = (f"The add-on cannot reach the car charger since {since_text_}, so "
f"check the {brand} integration in Home Assistant.")
nl = (f"De add-on kan de laadpaal niet bereiken sinds {since_text_}, dus "
f"controleer de {brand}-integratie in Home Assistant.")
return Notice(ID_CHARGER_UNREACH, WARNING, T_CHARGER_UNREACH, en,
body_nl=f"{T_CHARGER_UNREACH_NL}. {nl}")
def charger_back() -> Dismiss:
"""EV-03: takes the 'Charger not reachable' notification down."""
return Dismiss(ID_CHARGER_UNREACH)
def row_charger_unreach(since_text_) -> str:
"""EV-03: the amber row while the charger does not answer."""
return Bi(f"The add-on cannot reach the charger since {since_text_}.",
f"De add-on kan de laadpaal niet bereiken sinds {since_text_}.")
def row_charger_writer() -> str:
"""EV-03: the grey row while something else sets the charger's current."""
return Bi("Something else changes the charger, and this add-on only reads "
"it.",
"Iets anders wijzigt de laadpaal en deze add-on leest alleen.")
def row_charger_setup() -> str:
"""EV-03: the amber row when the charger's entities are not found."""
return Bi("The add-on cannot find the charger, so check its entity in "
"Settings.",
"De add-on vindt de laadpaal niet, dus controleer de entiteit "
"bij Instellingen.")
def row_maint_waits(until_text: str) -> str:
"""MAINT-13: the status row while a failed cycle waits."""
return Bi(f"Waits until {until_text} after a cycle that did not finish.",
@@ -1661,6 +1701,9 @@ def status_samples() -> list:
("row_no_prices", AMBER, row_no_prices(*_SINCE_SAMPLE)),
("row_no_prices", AMBER, row_no_prices(*_SINCE_OLDER)),
("row_no_prices", AMBER, row_no_prices()),
("row_charger_unreach", AMBER, row_charger_unreach("09:12")),
("row_charger_writer", GREEN, row_charger_writer()),
("row_charger_setup", AMBER, row_charger_setup()),
]
@@ -1696,6 +1739,7 @@ def samples() -> list:
no_prices(*_SINCE_SAMPLE),
no_prices(*_SINCE_OLDER),
no_prices(),
charger_unreachable("09:12"),
]
@@ -1758,6 +1802,11 @@ LABELS = {
"solar_trust_pct": "Trust in the forecast",
"p1_phase_import_entities": "Import entities per phase",
"p1_phase_export_entities": "Export entities per phase",
# EV-03
"ev_charger": "Charger",
"ev_current_entity": "Current setting entity",
"ev_max_a": "Charger limit",
"ev_phases": "Phases",
}
@@ -1838,6 +1887,10 @@ LABELS_NL = {
"solar_trust_pct": "Vertrouwen in de prognose",
"p1_phase_import_entities": "Afname-entiteiten per fase",
"p1_phase_export_entities": "Injectie-entiteiten per fase",
"ev_charger": "Laadpaal",
"ev_current_entity": "Entiteit van de laadstroom",
"ev_max_a": "Laadpaalgrens",
"ev_phases": "Fasen",
}
# The inverter list shows two of them under a shorter name.
UNIT_LABELS_NL = {"setpoint_entity": "Setpoint-entiteit",
+10 -1
View File
@@ -139,6 +139,11 @@ SENSORS = [
# a charge-power limit, or the optimiser declining to charge.
OPTIONAL_SENSORS = [
("pv", "goodwe_pv_power", "PV power", "W", "power", "measurement", None),
# EV-03: only with a car charger switched on. Read only: there are no
# command entities in this version.
("car_power", "goodwe_car_power", "Car power", "W", "power", "measurement", "mdi:car-electric"),
("car_state", "goodwe_car_state", "Car state", None, None, None, "mdi:ev-station"),
("car_today_kwh", "goodwe_car_today_kwh", "Car energy today", "kWh", "energy", "total_increasing", "mdi:ev-station"),
]
# ⚠️ HA's OWN "this sensor has no value" PAYLOAD, and the one place this add-on
@@ -192,7 +197,11 @@ def optional_keys(opts: dict) -> tuple:
# `_load()` is the same decision for the same kind of reason. Measured, not
# assumed: move this line to module scope and test_mqtt.py part 8 dies.
from . import pv as _pv
return ("pv",) if _pv.entities(opts) else ()
from . import chargers as _ch # EV-03: same reason
out = ("pv",) if _pv.entities(opts) else ()
if _ch.census_entity(opts):
out += ("car_power", "car_state", "car_today_kwh")
return out
BASE = "goodwe_ctl"
+13 -1
View File
@@ -82,7 +82,7 @@ import os
import aiohttp
from . import messages
from . import chargers, messages
from .configui import changed_keys
from .inverter import build_roster
from .validate import validate_startup_config, validate_unit_ranges
@@ -362,6 +362,18 @@ async def problems_and_ranges(opts: dict, hass=None, notes=None):
unread = [unit.driver.actuator_id() for unit in units
if unit.driver.configured() and unit.dev_min is None
and unit.dev_max is None]
# EV-03: the charger limit may not exceed the station limit the charger
# reports. A read only; a charger that does not answer skips the check.
if hass is not None and chargers.mode_of(opts) != chargers.OFF:
drv = chargers.build(opts)
if drv.configured():
_lo, station, _ph = await drv.bind(hass).limits()
amps = chargers.max_a(opts)
if station is not None and amps is not None and amps > station:
problems.append(
f"{messages.setting('ev_max_a')} is {amps:.0f} A, but the "
f"charger allows at most {station:.0f} A. Lower it to "
f"{station:.0f} A or less.")
return problems, unread
+5
View File
@@ -272,3 +272,8 @@ table.fct th,table.fct td{padding:4px 3px;text-align:right;border-bottom:1px sol
table.fct th:first-child,table.fct td:first-child{text-align:left}
table.fct th{color:var(--muted);font-weight:600}
.ymax{position:absolute;top:-2px;left:2px;font-size:10px;color:var(--faint);pointer-events:none}
/* EV-03: the Car card */
.car-big{font-size:20px;font-weight:700;line-height:1.3;margin:8px 0 2px;font-variant-numeric:tabular-nums}
.car-lab{margin:12px 0 4px;color:var(--muted)}
.car-why{display:grid;grid-template-columns:auto 1fr;gap:10px;margin-top:12px}
+16 -1
View File
@@ -113,7 +113,8 @@
const setup = S.setup_only === true;
banner($("#home-banner"), S.level, setup ? t("setup_only.name") : S.banner, structured ? S.state.sub : setup ? t("setup_only.description") : "", S.level === "bad" ? "alert" : null);
["#c-now", "#c-plan", "#c-peak", "#c-attn"].forEach((id) => { $(id).hidden = !structured; });
if (structured) { renderNow(); renderPlan(); renderPeak(); renderAttention(); }
if (structured) { renderNow(); renderCar(); renderPlan(); renderPeak(); renderAttention(); }
else $("#c-car").hidden = true;
renderControl(structured, setup);
renderDetails(!structured && !setup);
renderBatteries(force);
@@ -145,6 +146,20 @@
h("div", { class: "small muted", style: "grid-column:1/-1" }, b.now))));
}
/* ---------------- Home: the car (read only) ---------------- */
function renderCar() {
const c = S.car;
$("#c-car").hidden = !c;
if (!c) return;
const chip = $("#car-chip");
chip.textContent = c.chip;
chip.className = "chip" + (c.kind === "warn" ? " rs" : c.kind === "ok" ? " now" : "");
$("#car-big").textContent = c.big;
$("#car-today").textContent = c.today || "";
$("#car-today").hidden = !c.today;
$("#car-why").textContent = c.why;
}
/* ---------------- Home: today's plan ---------------- */
const LEGEND = [["cheap", "background:var(--cheap)"], ["dear", "background:repeating-linear-gradient(135deg,var(--dear) 0 3px,transparent 3px 5px)"],
["grid", "background:var(--accent)"], ["give", "background:repeating-linear-gradient(135deg,var(--house) 0 3px,transparent 3px 5px)"],
+10
View File
@@ -39,6 +39,16 @@
<div id="home-batts" style="margin-top:6px"></div>
</div>
<div class="card" id="c-car" hidden>
<div class="row spread"><h2 data-t="car.name"></h2><span class="chip" id="car-chip"></span></div>
<div class="car-big" id="car-big"></div>
<div class="small muted" id="car-today"></div>
<div class="small car-lab" data-t="car.mode"></div>
<div class="seg" role="radiogroup" id="car-mode" data-t-label="car.mode"><button type="button" role="radio" aria-checked="true" data-t="car.mode_off"></button></div>
<p class="tiny muted" style="margin:6px 0 0" data-t="car.help_off"></p>
<div class="car-why small"><span class="muted" data-t="car.why"></span><span id="car-why"></span></div>
</div>
<div class="card" id="c-plan">
<div class="row spread"><h2 data-t="plan.name"></h2><span class="chip tiny muted" id="verdict"></span></div>
<div class="small" id="plan-head"></div>
+26
View File
@@ -4,6 +4,7 @@
"inverters": {"name": "Inverters and batteries", "description": "The inverters the add-on controls, and your solar."},
"tariff": {"name": "Tariff and prices", "description": "What you pay and are paid per kWh."},
"safety": {"name": "Safety limits", "description": "The peak limit, starting and stopping, and the safety stops."},
"car": {"name": "Car charger", "description": "Which charger the add-on reads, and its limits."},
"maintenance": {"name": "Maintenance", "description": "The monthly battery cycle and the log."},
"tuning": {"name": "Control tuning", "description": "For support only, because these were measured on real hardware."}
},
@@ -33,6 +34,8 @@
"fallback": {"none": "None", "fixed": "One price", "daynight": "Day and night", "custom": "Other time windows"},
"region": {"flanders": "Flanders, Fluvius Antwerpen", "own": "I enter my own figure"},
"meter_source": {"off": "One grid power entity", "ha_dsmr": "Import and export entities", "mqtt_p1": "Meter over MQTT", "ha_signed": "One net power entity", "homewizard_local": "HomeWizard meter on the network"},
"ev_charger": {"off": "None", "alfen_ha": "Alfen (Home Assistant integration)"},
"ev_phases": {"1": "1 phase", "3": "3 phases", "auto": "1 and 3"},
"meter_phases": {"1": "1 phase", "3": "3 phases"},
"shadow_mode": {"auto": "Automatic", "on": "Always on", "off": "Off"},
"price_provider": {"generic_dayahead": "Day-ahead market price", "custom_formula": "Your own price formula", "manual_csv": "A price file", "price_service": "Your own price service"},
@@ -87,6 +90,7 @@
"loading": "Loading the forecast."
},
"peak": {"name": "Peak limit", "this_month": "This month's peak", "limit": "Limit", "none": "None recorded yet", "unreadable": "Cannot be read now"},
"car": {"name": "Car", "mode": "Mode", "mode_off": "Off", "help_off": "The add-on leaves the charger alone.", "why": "Why"},
"attention": {"name": "Needs attention", "nothing": "Nothing to look at", "to_look": "to look at", "details": "Details", "alarm": "Alarm", "warning": "Warning", "info": "Info"},
"control": {"name": "Control", "stop": "Stop control", "start": "Start control", "maint_start": "Start a battery cycle now", "maint_abort": "Stop the battery cycle", "docs": "Add-on documentation", "more": "More actions"},
"details": {"name": "Details for installers", "rows": "Status rows", "checks": "Checks", "event": "Last event"},
@@ -296,6 +300,25 @@
"waiting": "Control resumes by itself when Home Assistant answers.",
"warning": "See Needs attention below."
},
"car": {
"state": {"charging": "Charging", "waiting": "Connected, waiting", "none": "No car connected", "full": "Car is full", "unreach": "Charger not reachable", "setup": "Charger not set up", "wait": "No reading yet"},
"big": {"waiting": "Connected, not charging.", "none": "Nothing to charge.", "full": "The car is full.", "seen": "Last seen at {t}.", "no_reading": "No reading.", "setup": "Not set up.", "wait": "No reading yet."},
"phase_one": "1 phase",
"phase_many": "{n} phases",
"today": "{kwh} charged today.",
"why": {
"charging": "The charger is charging the car. The add-on leaves it alone.",
"waiting": "The car is connected and not charging. The add-on leaves the charger alone.",
"none": "No car is connected.",
"full": "The car stopped charging by itself.",
"unreach_a": "The charger keeps its last setting, {a} A. Check the {brand} integration in Home Assistant.",
"unreach": "The add-on cannot read the charger. Check the {brand} integration in Home Assistant.",
"not_found": "The add-on cannot find the charger. Check the current setting entity in Settings.",
"limit": "The charger limit is above what the charger allows. Lower it in Settings.",
"name": "The current setting entity does not fit the charger. Check it in Settings.",
"wait": "Waiting for the first reading."
}
},
"tile": {
"not_set_up": "Not set up",
"no_reading": "No reading",
@@ -499,6 +522,9 @@
"estop": "Emergency stop",
"pv": "Solar reading",
"solar_forecast": "Solar forecast",
"charger": "Charger not reachable",
"charger_writer": "Something else changes the charger",
"charger_setup": "Charger not set up",
"none": "Inverter connection"
},
"months": ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
+26
View File
@@ -4,6 +4,7 @@
"inverters": {"name": "Omvormers en batterijen", "description": "De omvormers die de add-on regelt, en uw zonnepanelen."},
"tariff": {"name": "Tarief en prijzen", "description": "Wat u per kWh betaalt en terugkrijgt."},
"safety": {"name": "Veiligheidsgrenzen", "description": "De piekgrens, starten en stoppen, en de veiligheidsstops."},
"car": {"name": "Laadpaal", "description": "Welke laadpaal de add-on leest, en haar grenzen."},
"maintenance": {"name": "Onderhoud", "description": "De maandelijkse batterijcyclus en het logboek."},
"tuning": {"name": "Afstelling van de regeling", "description": "Alleen voor support, want deze zijn gemeten op echte hardware."}
},
@@ -33,6 +34,8 @@
"fallback": {"none": "Geen", "fixed": "Eén prijs", "daynight": "Dag en nacht", "custom": "Andere tijdvakken"},
"region": {"flanders": "Vlaanderen, Fluvius Antwerpen", "own": "Ik vul zelf een bedrag in"},
"meter_source": {"off": "Eén entiteit voor netvermogen", "ha_dsmr": "Entiteiten voor afname en injectie", "mqtt_p1": "Meter via MQTT", "ha_signed": "Eén entiteit voor nettovermogen", "homewizard_local": "HomeWizard-meter op het netwerk"},
"ev_charger": {"off": "Geen", "alfen_ha": "Alfen (Home Assistant-integratie)"},
"ev_phases": {"1": "1 fase", "3": "3 fasen", "auto": "1 en 3"},
"meter_phases": {"1": "1 fase", "3": "3 fasen"},
"shadow_mode": {"auto": "Automatisch", "on": "Altijd aan", "off": "Uit"},
"price_provider": {"generic_dayahead": "Day-aheadprijs van de markt", "custom_formula": "Uw eigen prijsformule", "manual_csv": "Een prijsbestand", "price_service": "Uw eigen prijsdienst"},
@@ -84,6 +87,7 @@
"loading": "De prognose wordt geladen."
},
"peak": {"name": "Piekgrens", "this_month": "Piek van deze maand", "limit": "Grens", "none": "Nog niets gemeten", "unreadable": "Nu niet leesbaar"},
"car": {"name": "Auto", "mode": "Modus", "mode_off": "Uit", "help_off": "De add-on laat de laadpaal ongemoeid.", "why": "Waarom"},
"attention": {"name": "Vraagt aandacht", "nothing": "Niets om na te kijken", "to_look": "na te kijken", "details": "Details", "alarm": "Alarm", "warning": "Waarschuwing", "info": "Info"},
"control": {"name": "Regeling", "stop": "Regeling stoppen", "start": "Regeling starten", "maint_start": "Nu een batterijcyclus starten", "maint_abort": "Batterijcyclus stoppen", "docs": "Documentatie van de add-on", "more": "Meer acties"},
"details": {"name": "Details voor installateurs", "rows": "Statusregels", "checks": "Controles", "event": "Laatste gebeurtenis"},
@@ -250,6 +254,25 @@
"verdict": {"held": "Op 0 W gehouden", "stopped": "Gestopt", "cycle": "Vandaag maandelijkse cyclus", "trade": "Handelt op prijs", "house": "Volgt het huis"},
"pill": {"running": "Actief", "shadow": "Schaduwmodus", "stopped": "Gestopt", "alarm": "Heeft u nu nodig", "waiting": "Wacht op Home Assistant", "warning": "Actief, met een waarschuwing"},
"banner_sub": {"running": "De batterijen volgen het plan hieronder.", "shadow": "De plannen hieronder tonen wat de add-on zou doen.", "stopped": "Start de regeling hieronder als u klaar bent.", "alarm": "Zie Vraagt aandacht hieronder voor wat u moet doen.", "waiting": "De regeling gaat vanzelf verder zodra Home Assistant antwoordt.", "warning": "Zie Vraagt aandacht hieronder."},
"car": {
"state": {"charging": "Laadt", "waiting": "Aangesloten, wacht", "none": "Geen auto aangesloten", "full": "Auto is vol", "unreach": "Laadpaal onbereikbaar", "setup": "Laadpaal niet ingesteld", "wait": "Nog geen meting"},
"big": {"waiting": "Aangesloten, laadt niet.", "none": "Niets te laden.", "full": "De auto is vol.", "seen": "Laatst gezien om {t}.", "no_reading": "Geen meting.", "setup": "Niet ingesteld.", "wait": "Nog geen meting."},
"phase_one": "1 fase",
"phase_many": "{n} fasen",
"today": "Vandaag {kwh} geladen.",
"why": {
"charging": "De laadpaal laadt de auto. De add-on laat haar met rust.",
"waiting": "De auto is aangesloten en laadt niet. De add-on laat de laadpaal met rust.",
"none": "Er is geen auto aangesloten.",
"full": "De auto is zelf gestopt met laden.",
"unreach_a": "De laadpaal houdt haar laatste instelling, {a} A. Controleer de {brand}-integratie in Home Assistant.",
"unreach": "De add-on kan de laadpaal niet lezen. Controleer de {brand}-integratie in Home Assistant.",
"not_found": "De add-on vindt de laadpaal niet. Controleer de entiteit van de laadstroom bij Instellingen.",
"limit": "De laadpaalgrens is hoger dan de laadpaal toestaat. Verlaag ze bij Instellingen.",
"name": "De entiteit van de laadstroom past niet bij de laadpaal. Controleer ze bij Instellingen.",
"wait": "Wacht op de eerste meting."
}
},
"tile": {"not_set_up": "Niet ingesteld", "no_reading": "Geen meting", "producing": "Produceert", "not_producing": "Produceert niet", "needs_solar": "Zonnemeting nodig", "not_adding_up": "Metingen kloppen niet", "using": "Verbruikt", "taking": "Neemt af van het net", "feeding": "Injecteert", "balanced": "In evenwicht", "giving": "Levert stroom", "charging": "Laadt", "resting": "Rust"},
"now": {
"no_reading": "Geen meting van deze batterij.",
@@ -420,6 +443,9 @@
"estop": "Noodstop",
"pv": "Meting van de zonnepanelen",
"solar_forecast": "Zonneprognose",
"charger": "Laadpaal onbereikbaar",
"charger_writer": "Iets anders wijzigt de laadpaal",
"charger_setup": "Laadpaal niet ingesteld",
"none": "Verbinding met de omvormer"
},
"months": ["januari", "februari", "maart", "april", "mei", "juni", "juli", "augustus", "september", "oktober", "november", "december"]
+12
View File
@@ -77,6 +77,7 @@ _MAINT = (("maintenance_enabled", "==", True),)
_ONE = (("inverter_count", "==", 1),)
_SEVERAL = (("inverter_count", ">", 1),)
_PHASES = (("meter_phases", ">", 1),)
_CAR = (("ev_charger", "!=", "off"),)
# One inverter stored flat has no name or capacity (uimodel._roster_encode).
_LISTED = (("inverter_shape", "!=", "flat"),)
@@ -222,6 +223,17 @@ GROUPS = (
Field("delivery_hold_s", LOCKED, "s", step=5, show=_SEVERAL),
), collapsed=True),
)),
# EV-03: the car charger, read only. Everything after the choice shows
# only while a charger is switched on.
Group("car", (
Part("", (
Field("ev_charger", CHOICE, simple=True),
Field("ev_current_entity", ENTITY, kind="number", simple=True,
show=_CAR),
Field("ev_max_a", SLIDER, "A", simple=True, show=_CAR),
Field("ev_phases", SEGMENTED, simple=True, show=_CAR),
)),
)),
Group("maintenance", (
Part("", (
Field("maintenance_enabled", TOGGLE),
+124 -1
View File
@@ -332,7 +332,7 @@ import math
import re
from typing import NamedTuple
from . import dayplan, messages, pv, solarfc
from . import chargers, dayplan, messages, pv, solarfc
from .arbitrage import enabled as arbitrage_on
from .control import SLEW_RAIL_FRAC, LOOP_TICK_S, PLANT_SETTLE_S
from . import drivers
@@ -667,6 +667,34 @@ def _labels(keys, joiner: str = "and") -> str:
return f" {joiner} ".join(S(k) for k in keys)
def _charger_problems(opts: dict, writers: dict) -> list[str]:
"""EV-03: the car charger options. A charger whose entities are missing is
refused at run time (the Car card says so), not here: it never stops the
add-on. What stops it is a setpoint that an inverter also writes."""
out: list[str] = []
raw = opts.get("ev_charger", chargers.OFF)
if raw not in (None, "") and str(raw).strip() not in chargers.SELECTABLE:
out.append(f"{S('ev_charger')} is {messages.shown(raw)}. Choose "
f"{', '.join(chargers.SELECTABLE)}.")
return out
if chargers.mode_of(opts) == chargers.OFF:
return out
ph = opts.get("ev_phases", chargers.EV_OPTION_DEFAULTS["ev_phases"])
if str(ph).strip() not in chargers.PHASES_CHOICES:
out.append(f"{S('ev_phases')} is {messages.shown(ph)}. Choose 1, 3 or "
"auto.")
amps = chargers.max_a(opts)
if amps is None or not chargers.MIN_A <= amps <= chargers.ENTITY_MAX_A:
out.append(f"{S('ev_max_a')} is {messages.shown(opts.get('ev_max_a'))}"
f". Set it from {chargers.MIN_A:.0f} to "
f"{chargers.ENTITY_MAX_A:.0f} A.")
entity = chargers.census_entity(opts)
if entity and drivers.census_key(entity) in writers:
out.append(f"{S('ev_current_entity')} is {entity}, which an inverter "
"also uses. Give the charger its own entity.")
return out
def _roster_problems(opts: dict) -> list[str]:
"""Rule 9 (CFG-04): the `inverters:` roster, refused where it cannot mean
what it says.
@@ -956,6 +984,12 @@ def validate_startup_config(opts: dict, dev_min=None, dev_max=None,
f"{actuator}: {', '.join(who)}. Give each inverter its own "
"setpoint entity.")
# --- EV-03: the car charger's setpoint is a writer too ---------------------
# Counted in the census beside the inverters', and kept apart from
# `actuator_writers()` so setup-only mode still reads "no inverter". An
# inverter's entity named as the charger is two writers on one actuator.
problems.extend(_charger_problems(opts, writers))
# --- 9. CFG-04's roster, graded BEFORE anything reads a per-unit number --
# ⚠️ FIRST, THOUGH IT IS THE NEWEST RULE. Rules 5 and 6 below now ask the
# roster what one unit may be commanded, so a roster that is nonsense has to
@@ -1921,6 +1955,7 @@ def config_notes(opts: dict, *, entities: dict | None = None,
notes: list[Note] = []
if entities is not None:
_entity_notes(notes, opts, entities)
_charger_notes(notes, opts, entities)
cap = _number(opts, "peak_cap_w", None)
if month_peak_w is not None and cap is not None and cap < month_peak_w:
_advise(notes, "warn", ("peak_cap_w",),
@@ -1932,6 +1967,94 @@ def config_notes(opts: dict, *, entities: dict | None = None,
return notes
def charger_probe_rows(opts: dict, entities: dict | None) -> dict:
"""EV-03: the settings panel's read-only look at the charger. `entities` is
Home Assistant's list by id (None: it did not answer). Nothing is written.
`{"ok", "found": [[role, entity]], "missing": [[role, entity]], "limit_a",
"state"}`; `state` is `off`, `no_name` (the setpoint is not named the way
the charger's integration names it), `unread`, `ok` or `missing`."""
if chargers.mode_of(opts) == chargers.OFF:
return {"ok": False, "found": [], "missing": [], "limit_a": None,
"state": "off"}
setpoint = str(opts.get("ev_current_entity") or "").strip()
if not chargers.entities_for(setpoint):
return {"ok": False, "found": [], "missing": [], "limit_a": None,
"state": "no_name" if setpoint else "empty"}
if entities is None:
return {"ok": False, "found": [], "missing": [], "limit_a": None,
"state": "unread"}
def state_obj(e):
row = entities.get(e)
return None if row is None else {
"state": row.get("state"),
"attributes": {"unit_of_measurement": row.get("unit")}}
pr = chargers.probe_from(setpoint, state_obj)
return {"ok": pr.ok, "found": [list(x) for x in pr.found],
"missing": [list(x) for x in pr.missing], "limit_a": pr.station_a,
"state": "ok" if pr.ok else "missing"}
# The roles the "Found:" note names, in words (EV-03).
_CHARGER_WORDS = (
("state", "car state", "autostatus"), ("power", "power", "vermogen"),
("energy", "energy", "energie"), ("readback", "read-back", "terugmelding"),
("phases_read", "phases", "fasen"),
("station", "the charger limit", "de laadpaalgrens"))
def charger_probe_for(setpoint: str, entities: dict | None) -> dict:
"""`charger_probe_rows()` for a setpoint entity typed on the page."""
return charger_probe_rows({"ev_charger": chargers.ALFEN_HA,
"ev_current_entity": setpoint}, entities)
def _charger_notes(notes, opts: dict, entities: dict) -> None:
"""EV-03: a note for each charger entity Home Assistant does not have, and
one when the limit is above the charger's own. Never a refusal."""
look = charger_probe_rows(opts, entities)
key = ("ev_current_entity",)
if look["state"] == "no_name":
_advise(notes, "warn", key,
f"{S('ev_current_entity')} must be named like the Alfen "
"integration's current setting, so the charger is not read.",
nl=f"{SN('ev_current_entity')} moet heten zoals de "
"stroominstelling van de Alfen-integratie, dus de laadpaal "
"wordt niet gelezen.")
return
if look["state"] == "empty":
_advise(notes, "warn", key,
f"{S('ev_current_entity')} is empty, so the charger is not "
"read.",
nl=f"{SN('ev_current_entity')} is leeg, dus de laadpaal wordt "
"niet gelezen.")
return
if look["state"] not in ("ok", "missing"):
return
for role, entity in look["missing"]:
required = role in chargers.REQUIRED
_advise(notes, "warn" if required else "info", key,
f"Home Assistant has no entity {entity}, which the charger "
f"needs.",
nl=f"Home Assistant kent {entity} niet, die de laadpaal "
"nodig heeft.")
lim = look["limit_a"]
if look["ok"]:
have = {r for r, _e in look["found"]}
words = [(w_en, w_nl) for r, w_en, w_nl in _CHARGER_WORDS if r in have]
tail_en = f", {lim:.0f} A" if lim is not None else ""
_advise(notes, "ok", key,
"Found: " + ", ".join(w[0] for w in words) + tail_en + ".",
nl="Gevonden: " + ", ".join(w[1] for w in words) + tail_en
+ ".")
amps = chargers.max_a(opts)
if lim is not None and amps is not None and amps > lim:
_advise(notes, "warn", ("ev_max_a",),
f"{S('ev_max_a')} is above the {lim:.0f} A the charger "
"reports, so lower it.",
nl=f"{SN('ev_max_a')} is hoger dan de {lim:.0f} A die de "
"laadpaal meldt, dus verlaag ze.")
def _entity_notes(notes, opts: dict, entities: dict, bad=()) -> None:
"""A note for each entity these options read that Home Assistant does not
have, or that reads in kW where watts are taken. A missing entity whose
+11 -1
View File
@@ -51,7 +51,8 @@ from aiohttp import web
from . import messages, price, selfconfig, uipage, uitext
from .haentities import EntityCache
from .homeview import priced_hours, region_of
from .validate import config_notes, note_text, setup_checks
from .validate import (charger_probe_for, config_notes, note_text,
setup_checks)
from .config_page import CONFIG_PAGE
from .configui import (changed_keys, field_model, hide_secrets, keep_secrets,
problems_by_field, secret_keys)
@@ -474,6 +475,14 @@ def build_app(controller, selfcfg=None) -> web.Application:
return web.json_response(await entities.reading(one))
return web.json_response(await entities.payload(kind))
async def config_charger(request):
"""EV-03: the settings page's read-only look at the car charger: which
entities Home Assistant has and which it lacks. Reads the cached entity
list and writes nothing, anywhere."""
rows, _age = await entities.get(max_age=5.0)
return web.json_response(charger_probe_for(
str(request.query.get("entity") or "")[:255], rows))
app = web.Application()
app.add_routes([
web.get("/", index),
@@ -486,6 +495,7 @@ def build_app(controller, selfcfg=None) -> web.Application:
web.post("/config/save", config_save),
web.post("/config/restart", config_restart),
web.get("/ha/entities", ha_entities),
web.get("/config/charger", config_charger),
])
return app