M1 the writer ignores a reading taken before its latest confirmed write. M2 a refused phase select gives the current back and stops after 3 tries (amber row). M3 Off, shadow mode or a control/safety stop before the select undoes the change. M4 the restore on shutdown (and the undo) is clamped. M5 the car's power reaches the alarm path only while the charger's energy meter agrees with it. L1 fuzz other-writer branch reachable and shown to run. L2 one wording. L3 Batteries-help-off text. Co-Authored-By: Claude <noreply@anthropic.com>
314 lines
14 KiB
Python
314 lines
14 KiB
Python
"""EV-04: the Controller's side of the car's Manual mode.
|
|
|
|
The writes themselves are `carmode.ManualWriter`'s; this mixin owns the state
|
|
(mode, current, phases: runtime state in the store, like OPT-11's modes), the
|
|
actions, the background step that never holds up a control cycle, and what the
|
|
car means for the peak guard's ALARM PATH. DECISIONS/EV-04-manual-mode.md.
|
|
"""
|
|
|
|
import asyncio
|
|
import dataclasses
|
|
import logging
|
|
from datetime import timezone
|
|
|
|
from . import carmode, chargers, messages, peakguard
|
|
from .tariff import QUARTER_S
|
|
|
|
_LOG = logging.getLogger("goodwe")
|
|
|
|
CAR_PEAK_KEY = "car_peak_q" # {quarter start iso: the car's average W}
|
|
CAR_PEAK_MIN_W = 50.0 # a quarter the car hardly touched is not kept
|
|
CAR_PEAK_KEEP = 3200 # about a month of quarters
|
|
OVER_HOLD_S = peakguard.ALARM_HOLD_S
|
|
|
|
|
|
class CarMixin:
|
|
# ------------------------------------------------------------------ state
|
|
def car_init(self, opts, store) -> None:
|
|
"""Mode, current and phases from the store; `ev_mode_start` says what a
|
|
restart does with the mode. A site with no charger keeps defaults and
|
|
writes nothing."""
|
|
data = getattr(store, "data", None) or {}
|
|
self.car_mode = carmode.start_mode(opts, data.get(carmode.KEY_MODE))
|
|
if carmode.start_mode(opts, carmode.MANUAL) == carmode.OFF \
|
|
and data.get(carmode.KEY_MODE) not in (None, carmode.OFF):
|
|
store.set(carmode.KEY_MODE, carmode.OFF)
|
|
clamp = carmode.clamp_for(opts, None)
|
|
a = carmode.value_a(data.get(carmode.KEY_A, carmode.DEFAULT_A), clamp)
|
|
self.car_a = carmode.DEFAULT_A if a is None else a
|
|
n = data.get(carmode.KEY_PHASES, carmode.DEFAULT_PHASES)
|
|
ok = carmode.allowed_phases(opts)
|
|
self.car_n = n if n in ok else ok[0]
|
|
self.car_rev = 0
|
|
self.car_writer = carmode.ManualWriter()
|
|
self._car_task = None
|
|
self._car_step_failed = False
|
|
self.car_explains = False # the car alone explains the excess
|
|
self.car_over = False # ... held: the card and row say so
|
|
self._car_over_since = None
|
|
self._car_over_notified = None # the session a notice was raised for
|
|
self._car_session = 0
|
|
self._car_prev_state = None
|
|
self._carq = {"key": None, "ws": 0.0, "mono": None}
|
|
self._peak_proj_real = None
|
|
saved = data.get(CAR_PEAK_KEY)
|
|
self.car_peak_q = dict(saved) if isinstance(saved, dict) else {}
|
|
|
|
@property
|
|
def car_cover(self) -> bool:
|
|
"""Decision 1: do the batteries help cover the car down to the peak
|
|
reserve? Default yes."""
|
|
v = self.o.get("ev_batt_cover")
|
|
return bool(chargers.EV_OPTION_DEFAULTS["ev_batt_cover"]
|
|
if v is None else v)
|
|
|
|
def car_manual(self) -> bool:
|
|
return (self.charger.configured()
|
|
and self.car_mode == carmode.MANUAL)
|
|
|
|
def car_clamp(self):
|
|
return carmode.clamp_for(self.o, self.car.reading)
|
|
|
|
def car_writing(self) -> bool:
|
|
"""May the add-on write to the charger now? Control runs, shadow mode is
|
|
off, no safety stop is latched and the add-on is not shutting down. Shadow mode gates charger
|
|
writes exactly as it gates inverter writes."""
|
|
latched = (any(i.sign_wd.tripped for i in self.inverters)
|
|
or self.site_sign_wd.tripped or self.circ_wd.tripped)
|
|
return bool(self.auto and not self.shadow and not latched
|
|
and not getattr(self, "stopping", False))
|
|
|
|
# ---------------------------------------------------------------- actions
|
|
def _car_action(self, what, value, now) -> dict:
|
|
"""The mode, the current or the phases, from the page or from Home
|
|
Assistant. Store state, applied by the next step with no restart."""
|
|
if not self.charger.configured():
|
|
return {"error": messages.car_refused("off")}
|
|
if what == "car_mode":
|
|
if value not in carmode.MODES:
|
|
return {"error": messages.car_refused("value")}
|
|
self.car_mode = value
|
|
self.store.set(carmode.KEY_MODE, value)
|
|
elif what == "car_current":
|
|
clamp = self.car_clamp()
|
|
if isinstance(value, bool):
|
|
return {"error": messages.car_refused("value")}
|
|
a = carmode.value_a(value, clamp)
|
|
try:
|
|
inside = a is not None and abs(float(value) - a) < 0.5
|
|
except (TypeError, ValueError):
|
|
inside = False
|
|
if not inside:
|
|
return {"error": messages.car_refused("value")}
|
|
self.car_a = a
|
|
self.store.set(carmode.KEY_A, a)
|
|
else:
|
|
if value not in (1, 3) or isinstance(value, bool):
|
|
return {"error": messages.car_refused("value")}
|
|
if value not in carmode.allowed_phases(self.o):
|
|
return {"error": messages.car_refused("phases")}
|
|
self.car_n = value
|
|
self.store.set(carmode.KEY_PHASES, value)
|
|
self.car_rev += 1
|
|
self.car_writer.user_changed()
|
|
self.log_event(f"car {what[4:]} set to {value} by operator",
|
|
hint=messages.hint(what))
|
|
return {"mode": self.car_mode, "current": self.car_a,
|
|
"phases": self.car_n}
|
|
|
|
def car_command_values(self) -> dict:
|
|
"""The MQTT state of the three car entities."""
|
|
return {"car_mode": carmode.MODE_LABELS[self.car_mode],
|
|
"car_current": round(self.car_a),
|
|
"car_phases": str(self.car_n)}
|
|
|
|
# ------------------------------------------------------------- the writer
|
|
def car_kick(self) -> None:
|
|
"""Start one writer step in the background, unless one is running. A
|
|
write waits up to 10 s for the charger's read-back, and a control cycle
|
|
never waits for the charger."""
|
|
if not self.charger.configured():
|
|
return
|
|
t = self._car_task
|
|
if t is not None and not t.done():
|
|
return
|
|
self._car_task = asyncio.ensure_future(self._car_run())
|
|
|
|
async def car_settle(self) -> None:
|
|
"""Wait for the writer step in flight (the checks use it)."""
|
|
t = self._car_task
|
|
if t is not None:
|
|
await asyncio.gather(t, return_exceptions=True)
|
|
|
|
async def _car_run(self) -> None:
|
|
try:
|
|
await self.car_step()
|
|
except asyncio.CancelledError:
|
|
raise
|
|
except Exception: # noqa: BLE001
|
|
# Once at WARNING-and-above, then quietly: a step that fails
|
|
# fails every second.
|
|
if not self._car_step_failed:
|
|
self._car_step_failed = True
|
|
_LOG.exception("The car charger step failed")
|
|
else:
|
|
_LOG.debug("The car charger step failed again", exc_info=True)
|
|
else:
|
|
self._car_step_failed = False
|
|
|
|
async def car_shutdown(self) -> None:
|
|
"""The add-on stops: no new write, and a phase change in the middle is
|
|
undone by giving the car its current back. The current stands
|
|
otherwise (Manual's fail state)."""
|
|
t, self._car_task = getattr(self, "_car_task", None), None
|
|
if t is not None and not t.done():
|
|
t.cancel()
|
|
await asyncio.gather(t, return_exceptions=True)
|
|
if not self.charger.configured() \
|
|
or getattr(self, "car_writer", None) is None \
|
|
or self.car_writer.seq is None:
|
|
return
|
|
try:
|
|
await asyncio.wait_for(self.car_writer.abandon(
|
|
self.charger, self.car_now(), self.car, self.car_clamp()),
|
|
15.0)
|
|
except Exception: # noqa: BLE001
|
|
_LOG.warning("The car could not be given its current back "
|
|
"before the add-on stopped: CHARGER_RESTORE.")
|
|
|
|
async def car_step(self) -> None:
|
|
"""One step of Manual. Reads nothing from the world (the cycle's read
|
|
did) and writes only through `carmode.ManualWriter`."""
|
|
if not self.charger.configured():
|
|
return
|
|
now = self.car_now()
|
|
await self.car_writer.step(
|
|
self.charger, self.car.reading, mode=self.car_mode,
|
|
want_a=self.car_a, want_phases=self.car_n, rev=self.car_rev,
|
|
clamp=self.car_clamp(), now=now, tracker=self.car,
|
|
writing=self.car_writing(), shadow=bool(self.shadow),
|
|
status=self.car.status(now, True), clock=self.car_now)
|
|
|
|
# ------------------------------------------- the car and the peak guard
|
|
def car_alarm_w(self):
|
|
"""The car's power for the guard's alarm path: Manual only, fresh, not
|
|
stuck (`CarTracker.car_w_trusted`), and never above what the read-back
|
|
allows. None otherwise, and then the normal alarms stand."""
|
|
if not self.car_manual():
|
|
return None
|
|
return self.car.car_w_trusted(self.car_now())
|
|
|
|
def _car_quarter(self, proj, w, mono) -> None:
|
|
"""The car's energy in the open quarter, for the average the guard's
|
|
house leaves out and for the peak line."""
|
|
q = self._carq
|
|
key = None if proj is None else proj.block_start
|
|
last = q["mono"]
|
|
if key != q["key"]:
|
|
self._car_bank(q)
|
|
q["key"], q["ws"] = key, 0.0
|
|
if key is not None and w is not None and last is not None:
|
|
q["ws"] += float(w) * min(max(mono - last, 0.0), 5.0)
|
|
q["mono"] = mono
|
|
|
|
def _car_bank(self, q) -> None:
|
|
"""A closed quarter in which the car drew its share goes on the list."""
|
|
key = q["key"]
|
|
if key is None:
|
|
return
|
|
avg = q["ws"] / QUARTER_S
|
|
if avg < CAR_PEAK_MIN_W:
|
|
return
|
|
self.car_peak_q[key.astimezone(timezone.utc).isoformat()] = round(avg)
|
|
if len(self.car_peak_q) > CAR_PEAK_KEEP:
|
|
for k in sorted(self.car_peak_q)[:-CAR_PEAK_KEEP]:
|
|
del self.car_peak_q[k]
|
|
self.store.set(CAR_PEAK_KEY, dict(self.car_peak_q))
|
|
|
|
def car_avg_w(self, proj, w) -> float:
|
|
"""The car's average over the whole open quarter: what it drew so far
|
|
and `w` for the rest."""
|
|
if proj is None or w is None:
|
|
return 0.0
|
|
left = max(0.0, QUARTER_S - float(proj.elapsed_s))
|
|
so_far = self._carq["ws"] if self._carq["key"] == proj.block_start \
|
|
else 0.0
|
|
return (so_far + float(w) * left) / QUARTER_S
|
|
|
|
def car_exclude(self, proj, w):
|
|
"""Decision 1 off: the projection the guard sees without the car
|
|
(`house - car_w`). Unchanged without a fresh car reading."""
|
|
if proj is None or w is None or proj.block_start is None:
|
|
return proj
|
|
avg = self.car_avg_w(proj, w)
|
|
return dataclasses.replace(
|
|
proj, projected_w=max(0.0, float(proj.projected_w) - avg),
|
|
held_w=max(0.0, float(proj.held_w) - float(w)))
|
|
|
|
def car_cycle(self, real_proj, guard, target_w, now_utc) -> None:
|
|
"""After the guard has decided: does the car alone explain the excess?
|
|
`real_proj` is the projection WITH the car, whatever the guard saw."""
|
|
mono = self.car_now()
|
|
w = self.car_alarm_w()
|
|
self._car_quarter(real_proj, w, mono)
|
|
self._car_session_tick(mono)
|
|
explains = over = False
|
|
if w is not None and real_proj is not None and target_w is not None \
|
|
and real_proj.block_start is not None:
|
|
# The car explains the excess when the house alone would land the
|
|
# period under the aim: what the car takes over the whole period
|
|
# (`car_avg_w`) is at least how far the projection is over it.
|
|
ex = float(real_proj.projected_w) - float(target_w)
|
|
beyond = ex > 0.0 and self.car_avg_w(real_proj, w) >= ex
|
|
if self.car_cover:
|
|
explains = bool(
|
|
beyond and guard is not None
|
|
and (guard.saturated or guard.floor_limited))
|
|
over = explains
|
|
else:
|
|
over = beyond
|
|
self.car_explains = explains
|
|
if over:
|
|
if self._car_over_since is None:
|
|
self._car_over_since = mono
|
|
held = mono - self._car_over_since >= OVER_HOLD_S
|
|
else:
|
|
self._car_over_since, held = None, False
|
|
self.car_over = held
|
|
|
|
def _car_session_tick(self, mono) -> None:
|
|
"""A charging session is a plug-in: the state goes from no car to a
|
|
car. The notice is raised once per session."""
|
|
s = self.car.status(mono, True)
|
|
if s in (chargers.NONE_,) and self._car_prev_state not in (
|
|
None, chargers.NONE_):
|
|
self._car_over_notified = None
|
|
if s not in (chargers.NONE_, None) and self._car_prev_state in (
|
|
chargers.NONE_, None):
|
|
self._car_session += 1
|
|
self._car_prev_state = s
|
|
|
|
async def check_car_over(self) -> None:
|
|
"""One grey notice per charging session: the charge you set takes the
|
|
15-minute period over the peak limit. Raised nowhere else."""
|
|
if not self.car_over or self._car_over_notified == self._car_session:
|
|
return
|
|
self._car_over_notified = self._car_session
|
|
_LOG.info("The car charge you set takes this 15-minute period over "
|
|
"the peak limit: CAR_OVER_PEAK.")
|
|
await self.hass.call("persistent_notification", "create",
|
|
messages.car_over(f"{self.car_a:.0f}").data())
|
|
|
|
def car_peak_by_car(self, reading, now):
|
|
"""`(True, local time)` when the month's peak quarter was one the car
|
|
mostly made (it drew half the peak or more), else `(False, None)`."""
|
|
if reading is None or not getattr(reading, "is_observed", False) \
|
|
or reading.quarter_start is None or not self.car_peak_q:
|
|
return False, None
|
|
avg = self.car_peak_q.get(
|
|
reading.quarter_start.astimezone(timezone.utc).isoformat())
|
|
if avg is None or reading.peak_w is None \
|
|
or 2.0 * float(avg) < float(reading.peak_w):
|
|
return False, None
|
|
return True, reading.quarter_start
|