cantabile_edge, cantabile_modbus, cantabile_eebus 0.1.650: full source

This commit is contained in:
Setti Solutions S.R.L committed 2026-11-04 03:22:07 +02:00
1 parent 85edd56ec8
commit 3edd015039
20 files changed
+2021 -35

No files matched your search

+232
View File
@@ -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