cantabile_edge, cantabile_modbus, cantabile_eebus 0.1.650: full source
This commit is contained in:
1 parent
85edd56ec8
commit
3edd015039
20 files changed
+2021
-35
No files matched your search
@@ -0,0 +1,232 @@
|
||||
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
||||
"""A steady plan: no command for a change that does not matter (sim-munich-1
|
||||
in auto, 2026-11-03: a battery set 4.7 times an hour in steps of 50-150 W,
|
||||
its mode switched 2.9 times an hour, a heat pump's setpoint 20.5 and back to
|
||||
20.0 every quarter hour).
|
||||
|
||||
The optimiser's plan is exact to the watt and the tenth of a kelvin; every
|
||||
small difference became a command. Here, after the solve (controller.py
|
||||
make_plan), each control's plan entries are walked in time order from what
|
||||
the device is set to now, and a change is kept out of the plan (the entry
|
||||
keeps the value in force, its why says so) unless all hold:
|
||||
|
||||
deadband it changes enough: a battery's power by max(300 W, 10 % of its
|
||||
max), a setpoint by 0.5 K, an EV's current by 2 A (any change
|
||||
of on/off or mode counts: a battery's self-consumption is no
|
||||
power of its own, it follows the house)
|
||||
lasts a temperature: the plan keeps the new value for 30 minutes
|
||||
(a one-step blip is no command)
|
||||
hold the control's last change of the same kind is older than its
|
||||
hold: a mode (a battery's manual/self-consumption, a climate's
|
||||
off/heat, an EV's on/off) params.hold_mode_s (30 min), a
|
||||
setpoint params.hold_set_s (15 min); the first from the agent's
|
||||
last command (the guard's record), later ones from the plan
|
||||
gain a battery's setpoint: the energy the change moves over its
|
||||
hold, valued at the most a kWh can be worth moved in the
|
||||
horizon (its dearest import price less the lower of its
|
||||
cheapest import and feed-in price), at least
|
||||
params.min_gain_ct (1 ct): an upper bound, so only changes that
|
||||
cannot be worth a cent are kept
|
||||
|
||||
Not here, so never held back: the console's and the building's commands,
|
||||
the safe defaults, the grid operator's order (the plan is made again at
|
||||
once within its bounds; a kept value outside the bounds in force is never
|
||||
kept), the owner's own changes (the guard's hands off) and the guard's
|
||||
floors. The entry the plan made is kept in the entry as "planned".
|
||||
"""
|
||||
import math
|
||||
|
||||
MIN_BATTERY_W = 300.0
|
||||
BATTERY_SHARE = 0.10
|
||||
TEMP_K = 0.5
|
||||
EV_A = 2.0
|
||||
LASTS_S = 1800.0
|
||||
SAME_K = 0.25
|
||||
AUTO = "auto" # a battery in its own self-consumption mode (a plan entry's "auto")
|
||||
|
||||
|
||||
def _num(v):
|
||||
try:
|
||||
x = float(v)
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
return x if math.isfinite(x) else None
|
||||
|
||||
|
||||
def current(c, col):
|
||||
"""What the device is set to now, in a plan entry's terms (None:
|
||||
unknown, the plan is followed as it is)."""
|
||||
e = c.entities
|
||||
if c.kind == "battery":
|
||||
if "setpoint" not in e:
|
||||
return None
|
||||
if "mode" in e and col.state(e["mode"]) == str(c.p("auto_option")):
|
||||
return AUTO
|
||||
return _num(col.state(e["setpoint"]))
|
||||
if c.kind in ("heating", "cooling"):
|
||||
if "climate" in e:
|
||||
if col.state(e["climate"]) in ("off", None):
|
||||
return "off" if col.state(e["climate"]) == "off" else None
|
||||
return _num(col.attr(e["climate"], "temperature"))
|
||||
if "switch" in e:
|
||||
s = col.state(e["switch"])
|
||||
return s if s in ("on", "off") else None
|
||||
return None
|
||||
if c.kind == "ev":
|
||||
if col.state(e.get("switch", "")) == "off":
|
||||
return "off"
|
||||
return _num(col.state(e["current"])) if "current" in e else None
|
||||
return None
|
||||
|
||||
|
||||
def _val(c, e):
|
||||
"""A plan entry's value: its set, or a battery's AUTO."""
|
||||
return AUTO if c.kind == "battery" and e.get("auto") else e["set"]
|
||||
|
||||
|
||||
def _big(c, old, new) -> bool:
|
||||
if c.kind == "battery":
|
||||
top = max(float(c.p("max_charge_w")), float(c.p("max_discharge_w")))
|
||||
return abs(new - old) >= max(MIN_BATTERY_W, BATTERY_SHARE * top) - 1e-9
|
||||
if c.kind in ("heating", "cooling"):
|
||||
return abs(new - old) >= TEMP_K - 1e-9
|
||||
if c.kind == "ev":
|
||||
return abs(new - old) >= EV_A - 1e-9
|
||||
return True
|
||||
|
||||
|
||||
def _same(a, b) -> bool:
|
||||
if isinstance(a, str) or isinstance(b, str):
|
||||
return a == b
|
||||
return abs(a - b) < SAME_K
|
||||
|
||||
|
||||
def _lasts(c, entries, i, end) -> float:
|
||||
"""How long the plan keeps entry i's value (s)."""
|
||||
v = _val(c, entries[i])
|
||||
for e in entries[i + 1:]:
|
||||
if not _same(_val(c, e), v):
|
||||
return e["t"] - entries[i]["t"]
|
||||
return end - entries[i]["t"]
|
||||
|
||||
|
||||
def _within(bounds, v) -> bool:
|
||||
if not bounds or isinstance(v, str):
|
||||
return True
|
||||
lo, hi = bounds[0], bounds[1]
|
||||
return (lo is None or v >= lo - 1e-9) and (hi is None or v <= hi + 1e-9)
|
||||
|
||||
|
||||
def stabilise(plan: dict, state: dict, controls, col, last_set=None, now: float | None = None) -> dict:
|
||||
"""The plan with changes that do not matter kept out (module
|
||||
docstring). last_set(control id, kind "mode"|"set") -> when the agent
|
||||
last changed that (None: not known). In place; returns the plan."""
|
||||
now = plan.get("made", 0) if now is None else now
|
||||
step = plan.get("step_s", 900)
|
||||
end = plan.get("start", now) + step * state.get("steps", 192)
|
||||
prices = state.get("price_import") or []
|
||||
feed = state.get("price_export") or []
|
||||
spread = (max(prices) - min(prices + feed)) if prices else 0.0 # ct per kWh, at most
|
||||
devs = {d["id"]: d for d in state.get("devices") or []}
|
||||
kept_n = 0
|
||||
for c in controls:
|
||||
entries = (plan.get("devices") or {}).get(c.id)
|
||||
if not entries or c.kind not in ("battery", "heating", "cooling", "ev"):
|
||||
continue
|
||||
cur = current(c, col)
|
||||
if cur is None:
|
||||
continue
|
||||
p = devs.get(c.id, {}).get("params") or {}
|
||||
hold = {"mode": float(p.get("hold_mode_s", c.p("hold_mode_s"))),
|
||||
"set": float(p.get("hold_set_s", c.p("hold_set_s")))}
|
||||
min_gain = float(p.get("min_gain_ct", c.p("min_gain_ct")))
|
||||
bq = {"battery": "power_w", "heating": "temp_c", "cooling": "temp_c", "ev": "current_a"}[c.kind]
|
||||
bounds = (devs.get(c.id, {}).get("bounds") or {}).get(bq)
|
||||
changed = {}
|
||||
for k in ("mode", "set"):
|
||||
t = last_set(c.id, k) if last_set else None
|
||||
changed[k] = t if t is not None else -1e18
|
||||
raw = [dict(e) for e in entries]
|
||||
out = []
|
||||
for i, e in enumerate(raw):
|
||||
new = _val(c, e)
|
||||
if _same(cur, new):
|
||||
kind = None
|
||||
elif isinstance(cur, str) or isinstance(new, str):
|
||||
kind = "mode" # on/off, a climate's off, a battery's auto
|
||||
else:
|
||||
kind = "set"
|
||||
if kind is None:
|
||||
out.append(e)
|
||||
continue
|
||||
if kind == "mode" and c.kind in ("heating", "cooling") and "climate" not in c.entities:
|
||||
kind = "set" # a boiler's on/off is its setpoint
|
||||
t = max(e["t"], now)
|
||||
why = ""
|
||||
if not _within(bounds, cur):
|
||||
why = "" # what is set now is outside the bounds: change
|
||||
elif kind == "set" and not isinstance(new, str) and not _big(c, cur, new):
|
||||
why = f"kept: a change of {_amount(c, cur, new)} is below the deadband"
|
||||
elif c.kind in ("heating", "cooling") and _lasts(c, raw, i, end) < LASTS_S:
|
||||
why = f"kept: the plan holds {new:g} for less than {LASTS_S / 60:.0f} min" if not isinstance(new, str) \
|
||||
else f"kept: the plan is {new} for less than {LASTS_S / 60:.0f} min"
|
||||
elif t - changed[kind] < hold[kind]:
|
||||
why = f"kept: changed {int((t - changed[kind]) // 60)} min ago (hold {hold[kind] / 60:.0f} min)"
|
||||
elif c.kind == "battery" and kind == "set" and prices:
|
||||
gain = abs(new - cur) * hold["set"] / 3600 / 1000 * spread
|
||||
if gain < min_gain:
|
||||
why = f"kept: gain below {min_gain:g} ct ({gain:.2f} ct)"
|
||||
if why:
|
||||
kept_n += 1
|
||||
ke = {"t": e["t"], "set": cur, "why": why, "planned": e["set"]}
|
||||
if c.kind == "battery":
|
||||
ke["grid"] = bool(out[-1].get("grid")) if out and "grid" in out[-1] else cur != AUTO and cur > 0
|
||||
if cur == AUTO:
|
||||
ke.update(set=e["set"], auto=True)
|
||||
out.append(ke)
|
||||
continue
|
||||
out.append(e)
|
||||
cur = new
|
||||
changed[kind] = t
|
||||
if kind == "mode" and c.kind != "battery":
|
||||
changed["set"] = t
|
||||
# a plan lists changes only
|
||||
merged = []
|
||||
for e in out:
|
||||
if merged and _same(_val(c, merged[-1]), _val(c, e)) and \
|
||||
(merged[-1].get("grid") == e.get("grid") or _val(c, e) == AUTO):
|
||||
continue
|
||||
merged.append(e)
|
||||
plan["devices"][c.id] = merged
|
||||
plan["kept"] = kept_n
|
||||
return plan
|
||||
|
||||
|
||||
def _amount(c, a, b) -> str:
|
||||
unit = {"battery": "W", "heating": "K", "cooling": "K", "ev": "A"}[c.kind]
|
||||
d = abs(b - a)
|
||||
return f"{d:.0f} {unit}" if unit == "W" else f"{d:.1f} {unit}"
|
||||
|
||||
|
||||
def carry_quarter(plan: dict, old: dict | None, now: float) -> dict:
|
||||
"""A plan made in the middle of a quarter hour for no urgent reason (a
|
||||
tariff or model bundle came): the quarter under way keeps the values of
|
||||
the plan in force; the new plan decides from the next quarter on. Each
|
||||
plan reckons the quarter from its own start with the room as it is when
|
||||
it is made, and two plans in one quarter set a heat pump to 20.5 and
|
||||
back to 20.0 (sim-munich-1). In place; returns the plan."""
|
||||
if not old or old.get("start") != plan.get("start"):
|
||||
return plan
|
||||
nxt = plan["start"] + plan["step_s"]
|
||||
for cid, entries in (plan.get("devices") or {}).items():
|
||||
prev = [e for e in (old.get("devices") or {}).get(cid) or [] if e["t"] <= now]
|
||||
if not prev or not entries:
|
||||
continue
|
||||
keep = dict(prev[-1], t=plan["start"])
|
||||
rest = [e for e in entries if e["t"] >= nxt]
|
||||
if not rest or rest[0]["t"] > nxt:
|
||||
at = [e for e in entries if e["t"] < nxt]
|
||||
if at:
|
||||
rest.insert(0, dict(at[-1], t=nxt)) # the new plan's value from the next quarter
|
||||
plan["devices"][cid] = [keep] + rest
|
||||
return plan
|
||||
Reference in new issue
Block a user