EV-03: car charger seam, Alfen HA driver, read-only Car card
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:
@@ -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
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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 (
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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")]
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -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}
|
||||
|
||||
@@ -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)"],
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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"]
|
||||
|
||||
@@ -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"]
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
Reference in New Issue
Block a user