cantabile_edge, cantabile_modbus, cantabile_eebus 0.1.629: full source
This commit is contained in:
1 parent
d5fbcacaa4
commit
85edd56ec8
46 files changed
+3511
-260
No files matched your search
@@ -22,7 +22,7 @@ Settings → Add-ons → Add-on store → ⋮ → Repositories, add
|
|||||||
`https://git.setti.solutions/Daniel/cantabile-ha-addons`, then install the
|
`https://git.setti.solutions/Daniel/cantabile-ha-addons`, then install the
|
||||||
add-on. The Supervisor pulls the prebuilt images
|
add-on. The Supervisor pulls the prebuilt images
|
||||||
(`git.setti.solutions/daniel/cantabile-ha-<edge|modbus|eebus>-<arch>:<version>`,
|
(`git.setti.solutions/daniel/cantabile-ha-<edge|modbus|eebus>-<arch>:<version>`,
|
||||||
named by `image:` in each `config.yaml`); this version: `0.1.400`, arch amd64.
|
named by `image:` in each `config.yaml`); this version: `0.1.629`, arch amd64.
|
||||||
|
|
||||||
## Layout
|
## Layout
|
||||||
|
|
||||||
|
|||||||
@@ -6,6 +6,22 @@ names the commit; the agent inside is the Edge Agent image of that commit.
|
|||||||
|
|
||||||
## 0.1.x
|
## 0.1.x
|
||||||
|
|
||||||
|
- The Devices page is clearer: the devices you use with Cantabile are a
|
||||||
|
short list, each with its state in words ("In use · reading on · control
|
||||||
|
on" or "Added · reading off"), its main values now ("21.5 °C, set to
|
||||||
|
22 °C, heating") and whether it is protected. Open a device to change it:
|
||||||
|
reading and control switch at once, what it reads is said in plain words
|
||||||
|
("room temperature (Living room), setpoint, heating/cooling state"), and
|
||||||
|
heating or cooling, room and window, indoor or outdoor and protection
|
||||||
|
each save on their own (Save shows once you change something). Removing
|
||||||
|
asks you to confirm. "Untested" profiles are marked with a small badge and
|
||||||
|
an "i" that explains it. Devices you can still add are listed apart,
|
||||||
|
below; a device in use is never offered again.
|
||||||
|
- Heat is shown as heat: a heat meter's or heat pump's heat is "Heat from
|
||||||
|
the building (thermal)" or "Heat delivered (thermal)", in kW and kWh, in
|
||||||
|
its own band below solar, home, grid and battery, never added to the
|
||||||
|
electricity. With your own heat pump its electric power and its COP are
|
||||||
|
shown beside the heat.
|
||||||
- Blinds, curtains, shutters and awnings: the Devices page offers any of
|
- Blinds, curtains, shutters and awnings: the Devices page offers any of
|
||||||
Home Assistant's covers (never a garage door, gate, door, damper or
|
Home Assistant's covers (never a garage door, gate, door, damper or
|
||||||
window). You set the room it shades and which way the window faces.
|
window). You set the room it shades and which way the window faces.
|
||||||
|
|||||||
@@ -3,7 +3,7 @@
|
|||||||
# the Hub's, wrapped by addon-run (Dockerfile). The image is prebuilt,
|
# the Hub's, wrapped by addon-run (Dockerfile). The image is prebuilt,
|
||||||
# per arch (README.md: building it from src/).
|
# per arch (README.md: building it from src/).
|
||||||
name: Cantabile Edge Agent
|
name: Cantabile Edge Agent
|
||||||
version: "0.1.400"
|
version: "0.1.629"
|
||||||
slug: cantabile_edge
|
slug: cantabile_edge
|
||||||
description: Plans your home's energy with Cantabile and, with your consent, runs the devices you choose.
|
description: Plans your home's energy with Cantabile and, with your consent, runs the devices you choose.
|
||||||
url: https://cantabile.cloud
|
url: https://cantabile.cloud
|
||||||
|
|||||||
@@ -4,7 +4,7 @@
|
|||||||
# Assistant that isn't a Cantabile Hub. Devices are paired on its page
|
# Assistant that isn't a Cantabile Hub. Devices are paired on its page
|
||||||
# (ingress), by their SKI.
|
# (ingress), by their SKI.
|
||||||
name: Cantabile EEBUS
|
name: Cantabile EEBUS
|
||||||
version: "0.1.400"
|
version: "0.1.629"
|
||||||
slug: cantabile_eebus
|
slug: cantabile_eebus
|
||||||
description: Pairs with EEBUS devices (the grid operator's control box, heat pumps, wallboxes, inverters), shows them in Home Assistant under Cantabile's names and hands the grid operator's §14a limit to the Cantabile agent; every control with its protection.
|
description: Pairs with EEBUS devices (the grid operator's control box, heat pumps, wallboxes, inverters), shows them in Home Assistant under Cantabile's names and hands the grid operator's §14a limit to the Cantabile agent; every control with its protection.
|
||||||
url: https://cantabile.cloud
|
url: https://cantabile.cloud
|
||||||
|
|||||||
@@ -4,7 +4,7 @@
|
|||||||
# Home Assistant that isn't a Cantabile Hub. Devices come from the options;
|
# Home Assistant that isn't a Cantabile Hub. Devices come from the options;
|
||||||
# the page (ingress) shows them and each control's protection.
|
# the page (ingress) shows them and each control's protection.
|
||||||
name: Cantabile Modbus bridge
|
name: Cantabile Modbus bridge
|
||||||
version: "0.1.400"
|
version: "0.1.629"
|
||||||
slug: cantabile_modbus
|
slug: cantabile_modbus
|
||||||
description: Reads inverters, meters, relays and circuits by Cantabile's device profiles (Modbus, or Home Assistant's own entities) and shows them in Home Assistant, each control with its protection.
|
description: Reads inverters, meters, relays and circuits by Cantabile's device profiles (Modbus, or Home Assistant's own entities) and shows them in Home Assistant, each control with its protection.
|
||||||
url: https://cantabile.cloud
|
url: https://cantabile.cloud
|
||||||
|
|||||||
@@ -21,6 +21,7 @@ from .consent import Consent
|
|||||||
from .controller import Controller
|
from .controller import Controller
|
||||||
from .inventory import Inventory
|
from .inventory import Inventory
|
||||||
from .dashboards import Dashboards
|
from .dashboards import Dashboards
|
||||||
|
from .gridorder import GridOrders
|
||||||
from .devpage import App, Devices
|
from .devpage import App, Devices
|
||||||
from .joinpage import Fleet
|
from .joinpage import Fleet
|
||||||
from .mapping import Mapping, convert, scaled, value_of
|
from .mapping import Mapping, convert, scaled, value_of
|
||||||
@@ -61,9 +62,14 @@ class Agent:
|
|||||||
self.control = Controller(cfg, mapping, self.consent, sink) if mapping.controls else None
|
self.control = Controller(cfg, mapping, self.consent, sink) if mapping.controls else None
|
||||||
if self.control is not None and hasattr(sink, "on_command"):
|
if self.control is not None and hasattr(sink, "on_command"):
|
||||||
sink.on_command = self.control.command
|
sink.on_command = self.control.command
|
||||||
|
# the grid operator's orders (EEBUS LPC, gridorder.py): the controller's,
|
||||||
|
# or, on a site without controls, checked and told to the cloud only
|
||||||
|
self.gridorders = self.control.gridorders if self.control is not None else GridOrders(cfg.state_dir)
|
||||||
# the devices' specs for the cloud (inventory.py)
|
# the devices' specs for the cloud (inventory.py)
|
||||||
self.inventory = Inventory(cfg, mapping, self.consent, sink,
|
self.inventory = Inventory(cfg, mapping, self.consent, sink,
|
||||||
self.control.policy if self.control is not None else None)
|
self.control.policy if self.control is not None else None)
|
||||||
|
if self.control is not None:
|
||||||
|
self.inventory.ev_phases = self.control.ev_phases
|
||||||
self.client = None
|
self.client = None
|
||||||
self.exit_code = 0 # RESTART: start again (restart())
|
self.exit_code = 0 # RESTART: start again (restart())
|
||||||
# A mapping for a site without one (propose.py): the HA add-on
|
# A mapping for a site without one (propose.py): the HA add-on
|
||||||
@@ -234,10 +240,10 @@ class Agent:
|
|||||||
|
|
||||||
async def inventory_loop(self):
|
async def inventory_loop(self):
|
||||||
"""The inventory at connecting, then every 30 minutes if it changed
|
"""The inventory at connecting, then every 30 minutes if it changed
|
||||||
(and once a day anyway)."""
|
(and once a day anyway); every minute while the link is not connected."""
|
||||||
while not self.stop.is_set():
|
while not self.stop.is_set():
|
||||||
try:
|
try:
|
||||||
await asyncio.wait_for(self.inventory_now.wait(), 1800)
|
await asyncio.wait_for(self.inventory_now.wait(), 60 if self.inventory.waiting else 1800)
|
||||||
except asyncio.TimeoutError:
|
except asyncio.TimeoutError:
|
||||||
pass
|
pass
|
||||||
self.inventory_now.clear()
|
self.inventory_now.clear()
|
||||||
@@ -263,6 +269,27 @@ class Agent:
|
|||||||
time.strftime("%H:%M", time.gmtime(start)), seq, len(records),
|
time.strftime("%H:%M", time.gmtime(start)), seq, len(records),
|
||||||
self.queue.depth(), self.queue.dropped())
|
self.queue.depth(), self.queue.dropped())
|
||||||
|
|
||||||
|
async def grid_order(self, payload) -> bool:
|
||||||
|
"""A message on cantabile-eebus/gridorder (announce.py): the
|
||||||
|
controller's when there is one (limits and a plan within them);
|
||||||
|
otherwise only checked and told to the cloud (nothing to limit)."""
|
||||||
|
if self.control is not None:
|
||||||
|
return await self.control.grid_order(payload)
|
||||||
|
changed, _ = self.gridorders.take(payload)
|
||||||
|
await self.grid_report()
|
||||||
|
return changed
|
||||||
|
|
||||||
|
async def grid_report(self):
|
||||||
|
"""The grid operator's order to the cloud as an action per
|
||||||
|
quarter-hour (gridorder.py action()): fleet's market ledger exempts
|
||||||
|
those slots."""
|
||||||
|
if self.control is not None:
|
||||||
|
return await self.control.grid_report()
|
||||||
|
a = self.gridorders.action()
|
||||||
|
pub = getattr(self.sink, "publish", None)
|
||||||
|
if a is not None and pub is not None:
|
||||||
|
await pub("action", a)
|
||||||
|
|
||||||
async def ticker(self):
|
async def ticker(self):
|
||||||
i = self.cfg.interval_s
|
i = self.cfg.interval_s
|
||||||
while not self.stop.is_set():
|
while not self.stop.is_set():
|
||||||
@@ -271,6 +298,11 @@ class Agent:
|
|||||||
await asyncio.wait_for(self.stop.wait(), max(0.0, end - time.time()))
|
await asyncio.wait_for(self.stop.wait(), max(0.0, end - time.time()))
|
||||||
except asyncio.TimeoutError:
|
except asyncio.TimeoutError:
|
||||||
self.close_window(end)
|
self.close_window(end)
|
||||||
|
if self.control is None: # the controller's own loop reports otherwise
|
||||||
|
try:
|
||||||
|
await self.grid_report()
|
||||||
|
except Exception as e:
|
||||||
|
log.warning("grid order report: %s", e)
|
||||||
|
|
||||||
async def uploader(self):
|
async def uploader(self):
|
||||||
wait = 1.0
|
wait = 1.0
|
||||||
|
|||||||
@@ -27,6 +27,15 @@ building and the home, and what the agent does to each device):
|
|||||||
sensor set_<control> per control: the value the agent wants it at now
|
sensor set_<control> per control: the value the agent wants it at now
|
||||||
and from whom (plan, cloud, building, owner, safe
|
and from whom (plan, cloud, building, owner, safe
|
||||||
default), whether it acts, the limits per level
|
default), whether it acts, the limits per level
|
||||||
|
sensor market_<contract>, market_position[_building], market_price, market_actuator_<device>
|
||||||
|
the shadow market (market.json, a signed `market`
|
||||||
|
bundle): per contract the exchange with its
|
||||||
|
counterpart (kW in the last settled quarter-hour,
|
||||||
|
a sentence in plain words, the period), the net
|
||||||
|
position, the shared energy's price, per border
|
||||||
|
actuator its contract target vs its state now;
|
||||||
|
sensors only, unavailable when the bundle is
|
||||||
|
stale (cantabile/<site>/market/availability)
|
||||||
On a building's own box (flats.json, a signed `flats` bundle from the
|
On a building's own box (flats.json, a signed `flats` bundle from the
|
||||||
cloud: bundles.py) each flat is a device of its own ("Flat", via the
|
cloud: bundles.py) each flat is a device of its own ("Flat", via the
|
||||||
building's Cantabile device, area "Flats"): its grid power, its
|
building's Cantabile device, area "Flats"): its grid power, its
|
||||||
@@ -229,6 +238,162 @@ class Announcer:
|
|||||||
"json_attributes_template": "{{ {'commands': value_json.commands} | tojson }}", **common}
|
"json_attributes_template": "{{ {'commands': value_json.commands} | tojson }}", **common}
|
||||||
return out
|
return out
|
||||||
|
|
||||||
|
# -- the shadow market (a `market` bundle: bundles.py) -------------------
|
||||||
|
def _market_avail(self) -> dict:
|
||||||
|
"""Unavailable when the agent is offline or the bundle is stale."""
|
||||||
|
return {"availability": [{"topic": f"{self.base}/availability"}, {"topic": f"{self.base}/market/availability"}],
|
||||||
|
"availability_mode": "all"}
|
||||||
|
|
||||||
|
@staticmethod
|
||||||
|
def _party(c: dict, lang: str) -> str:
|
||||||
|
p = c.get("counterpart") or {}
|
||||||
|
if p.get("type") == "homes":
|
||||||
|
return names.name("mk_flats", lang, p.get("count") or "")
|
||||||
|
return p.get("name") or p.get("type") or "?"
|
||||||
|
|
||||||
|
def _market_objects(self, m: dict | None) -> dict:
|
||||||
|
"""Per contract the exchange with its counterpart, the net position
|
||||||
|
of each of the box's nodes, the shared energy's price, per border
|
||||||
|
actuator its contract target: sensors only (never a control: the
|
||||||
|
actuators keep their own entities and protection)."""
|
||||||
|
ctl = getattr(self.agent, "control", None)
|
||||||
|
if m is None or (ctl is not None and ctl.mode() == "off"):
|
||||||
|
return {}
|
||||||
|
dev, out, lang = self._device(), {}, self.lang
|
||||||
|
common = {"state_topic": f"{self.base}/market", "json_attributes_topic": f"{self.base}/market",
|
||||||
|
**self._market_avail(), "device": dev}
|
||||||
|
for c in m.get("contracts") or []:
|
||||||
|
k = _slug(c["id"])
|
||||||
|
out[("sensor", f"market_{k}")] = {
|
||||||
|
"name": names.name("market_exchange", lang, self._party(c, lang)), "unique_id": f"{self.uid}_market_{k}",
|
||||||
|
"unit_of_measurement": "kW", "device_class": "power", "state_class": "measurement", "icon": "mdi:swap-horizontal",
|
||||||
|
"value_template": "{%% set v = value_json.contracts['%s'].kw %%}{{ v if v is not none else none }}" % k,
|
||||||
|
"json_attributes_template": "{{ value_json.contracts['%s'] | tojson }}" % k, **common}
|
||||||
|
nodes = {n.get("id"): n.get("name") for n in m.get("nodes") or []}
|
||||||
|
for p in m.get("positions") or []:
|
||||||
|
kind = str(p.get("node", "")).split(":")[0]
|
||||||
|
obj = "market_position" if kind == "site" else f"market_position_{_slug(kind)}"
|
||||||
|
out[("sensor", obj)] = {
|
||||||
|
"name": names.name("market_position", lang) if kind == "site" else
|
||||||
|
names.name("market_position_of", lang, nodes.get(p.get("node")) or kind),
|
||||||
|
"unique_id": f"{self.uid}_{obj}", "unit_of_measurement": "kWh", "state_class": "measurement",
|
||||||
|
"icon": "mdi:scale-balance",
|
||||||
|
"value_template": "{{ value_json.positions['%s'].net_kwh }}" % obj,
|
||||||
|
"json_attributes_template": "{{ value_json.positions['%s'] | tojson }}" % obj, **common}
|
||||||
|
if m.get("contracts"):
|
||||||
|
out[("sensor", "market_price")] = {
|
||||||
|
"name": names.name("market_price", lang), "unique_id": f"{self.uid}_market_price",
|
||||||
|
"unit_of_measurement": "EUR/kWh", "suggested_display_precision": 3, "state_class": "measurement",
|
||||||
|
"icon": "mdi:cash-multiple",
|
||||||
|
"value_template": "{% set v = value_json.price.now %}{{ (v / 100) | round(4) if v is not none else none }}",
|
||||||
|
"json_attributes_template": "{{ value_json.price | tojson }}", **common}
|
||||||
|
for a in m.get("actuators") or []:
|
||||||
|
k = _slug(a["device"])
|
||||||
|
out[("sensor", f"market_actuator_{k}")] = {
|
||||||
|
"name": names.name("market_actuator", lang, a.get("name") or a["device"]),
|
||||||
|
"unique_id": f"{self.uid}_market_actuator_{k}", "icon": "mdi:electric-switch",
|
||||||
|
"value_template": "{{ value_json.actuators['%s'].target }}" % k,
|
||||||
|
"json_attributes_template": "{{ value_json.actuators['%s'] | tojson }}" % k, **common}
|
||||||
|
return out
|
||||||
|
|
||||||
|
def _actual(self, device: str):
|
||||||
|
"""A border actuator's state in HA now, from the agent's own view of
|
||||||
|
the device's controls (None: not one the agent watches)."""
|
||||||
|
ctl = getattr(self.agent, "control", None)
|
||||||
|
col = getattr(ctl, "col", None)
|
||||||
|
if ctl is None or col is None:
|
||||||
|
return None
|
||||||
|
for c in ctl.controls:
|
||||||
|
if getattr(c, "device", "") == device:
|
||||||
|
for eid in (c.entities or {}).values():
|
||||||
|
st = col.state(eid)
|
||||||
|
if st is not None:
|
||||||
|
return st
|
||||||
|
return None
|
||||||
|
|
||||||
|
def market_state(self, m: dict) -> dict:
|
||||||
|
"""The market's values for HA: per contract (kW in the last settled
|
||||||
|
quarter-hour, a sentence in plain words, the details), positions,
|
||||||
|
the price now, the actuators' target and actual state."""
|
||||||
|
lang = self.lang
|
||||||
|
num = names.number
|
||||||
|
out = {"contracts": {}, "positions": {}, "actuators": {}, "price": {}, "shadow": True, "stale": bool(m.get("stale")),
|
||||||
|
"note": names.name("mk_shadow_note", lang), "issued": m.get("issued"), "slot": m.get("slot")}
|
||||||
|
links = {lk.get("id"): lk for lk in m.get("links") or []}
|
||||||
|
prices, applying = {}, []
|
||||||
|
for c in m.get("contracts") or []:
|
||||||
|
k = _slug(c["id"])
|
||||||
|
last, slot, per = c.get("last") or None, c.get("slot") or {}, c.get("period") or {}
|
||||||
|
party = self._party(c, lang)
|
||||||
|
head = names.name("mk_sells" if c["direction"] == "sells" else "mk_buys", lang, party)
|
||||||
|
kw = None
|
||||||
|
if last and last.get("measured"):
|
||||||
|
d = float(last.get("delivered_kwh") or 0)
|
||||||
|
kw = round(d * 4, 3)
|
||||||
|
amount = float(last.get("max_kwh") or 0) or float(last.get("guaranteed_kwh") or 0)
|
||||||
|
part = names.name("mk_slot", lang, num(d, lang, 2), num(amount, lang, 2)) if amount > 0 else \
|
||||||
|
names.name("mk_slot_open", lang, num(d, lang, 2))
|
||||||
|
else:
|
||||||
|
part = names.name("mk_no_value", lang)
|
||||||
|
price = slot.get("price_ct")
|
||||||
|
bits = [f"{head}: {part}"]
|
||||||
|
if price is not None:
|
||||||
|
bits.append(f"{num(float(price), lang)} ct/kWh")
|
||||||
|
prices[k] = price
|
||||||
|
if slot.get("applies"):
|
||||||
|
applying.append(float(price))
|
||||||
|
if not slot.get("applies"):
|
||||||
|
bits.append(names.name("mk_not_now", lang))
|
||||||
|
bits.append(names.name("mk_shadow", lang))
|
||||||
|
details = []
|
||||||
|
if last and last.get("kind") and last.get("deviation_kwh"):
|
||||||
|
dev = num(abs(float(last["deviation_kwh"])), lang, 2)
|
||||||
|
details.append(names.name("mk_deviation_self" if last.get("cause") == "self" else "mk_deviation_other", lang, dev))
|
||||||
|
if last.get("exempt"):
|
||||||
|
details.append(names.name("mk_exempt", lang, last.get("exempt_why") or ""))
|
||||||
|
pname = names.name("mk_" + (per.get("period") or "month"), lang) if ("mk_" + (per.get("period") or "month")) in names.NAMES \
|
||||||
|
else per.get("period", "")
|
||||||
|
period = names.name("mk_period", lang, pname, num(float(per.get("delivered_kwh") or 0), lang),
|
||||||
|
num(float(per.get("amount_eur") or 0), lang, 2))
|
||||||
|
if per.get("penalties_paid_eur") or per.get("penalties_received_eur"):
|
||||||
|
period += " · " + names.name("mk_penalties", lang, num(float(per.get("penalties_paid_eur") or 0), lang, 2),
|
||||||
|
num(float(per.get("penalties_received_eur") or 0), lang, 2))
|
||||||
|
meas = (links.get(c.get("link")) or {}).get("measurement") or {}
|
||||||
|
out["contracts"][k] = {
|
||||||
|
"kw": kw, "summary": " · ".join(bits), "details": "; ".join(details), "period_words": period,
|
||||||
|
"contract": c["id"], "name": c.get("name", ""), "direction": c["direction"], "counterpart": party,
|
||||||
|
"counterpart_type": (c.get("counterpart") or {}).get("type", ""), "link_kind": c.get("link_kind", ""),
|
||||||
|
"slot": slot, "last": last, "period": per, "kwh_period": per.get("delivered_kwh"), "price_ct": price,
|
||||||
|
"penalty_last_eur": (last or {}).get("penalty_eur"), "measurement": meas.get("kind", ""),
|
||||||
|
"trust": meas.get("trust", ""), "shadow": True}
|
||||||
|
out["price"] = {"now": round(sum(applying) / len(applying), 3) if applying else None, "unit": "ct/kWh",
|
||||||
|
"per_contract": prices}
|
||||||
|
for p in m.get("positions") or []:
|
||||||
|
kind = str(p.get("node", "")).split(":")[0]
|
||||||
|
obj = "market_position" if kind == "site" else f"market_position_{_slug(kind)}"
|
||||||
|
out["positions"][obj] = dict(p)
|
||||||
|
for a in m.get("actuators") or []:
|
||||||
|
k = _slug(a["device"])
|
||||||
|
tgt = a.get("target") or {}
|
||||||
|
actual = self._actual(a["device"])
|
||||||
|
if actual is None and a.get("last"):
|
||||||
|
actual = a["last"].get("value")
|
||||||
|
|
||||||
|
def say(x):
|
||||||
|
return names.name(f"mk_state_{x}", lang) if f"mk_state_{x}" in names.NAMES else \
|
||||||
|
(str(x) if x not in (None, "") else names.name("mk_unknown", lang))
|
||||||
|
kwb = f" ({num(float(tgt['kw']), lang)} kW)" if tgt.get("kw") is not None else ""
|
||||||
|
words = (f"{names.name('mk_target', lang)}: **{say(tgt.get('state'))}**{kwb} · {names.name('mk_actual', lang)}: "
|
||||||
|
f"**{say(actual)}** · {names.name('mk_protection', lang, a.get('protection') or 'none')} · "
|
||||||
|
+ names.name("mk_default", lang, say(a.get("default_state")), int((a.get("fallback_s") or 0) // 60)))
|
||||||
|
out["actuators"][k] = {"target": tgt.get("state"), "target_kw": tgt.get("kw"), "why": tgt.get("why", ""),
|
||||||
|
"actual": actual, "agrees": actual is not None and str(actual) == str(tgt.get("state")),
|
||||||
|
"words": words, "device": a["device"], "name": a.get("name", ""), "link": a.get("link"),
|
||||||
|
"protection": a.get("protection"), "default_state": a.get("default_state"),
|
||||||
|
"default_set": a.get("default_set"), "fallback_s": a.get("fallback_s"),
|
||||||
|
"last": a.get("last"), "shadow": True}
|
||||||
|
return out
|
||||||
|
|
||||||
def objects(self) -> dict:
|
def objects(self) -> dict:
|
||||||
"""Every discovery config HA should have now: (node, component,
|
"""Every discovery config HA should have now: (node, component,
|
||||||
object) -> config; node is the site's or a flat's."""
|
object) -> config; node is the site's or a flat's."""
|
||||||
@@ -236,7 +401,8 @@ class Announcer:
|
|||||||
tariff, model = self.bundles.tariff_now(now), self.bundles.model_info()
|
tariff, model = self.bundles.tariff_now(now), self.bundles.model_info()
|
||||||
out = {}
|
out = {}
|
||||||
for (comp, obj), conf in {**self._configs(), **self._plan_objects(),
|
for (comp, obj), conf in {**self._configs(), **self._plan_objects(),
|
||||||
**self._exchange_objects(tariff, model)}.items():
|
**self._exchange_objects(tariff, model),
|
||||||
|
**self._market_objects(self.bundles.market_now(now))}.items():
|
||||||
out[(self.uid, comp, obj)] = conf
|
out[(self.uid, comp, obj)] = conf
|
||||||
out.update(self._flat_objects(self.bundles.flat_list()))
|
out.update(self._flat_objects(self.bundles.flat_list()))
|
||||||
# The entity ids themselves (HA 2025.10+): without them HA makes them
|
# The entity ids themselves (HA 2025.10+): without them HA makes them
|
||||||
@@ -332,6 +498,10 @@ class Announcer:
|
|||||||
if ctl is not None and ctl.received:
|
if ctl is not None and ctl.received:
|
||||||
# kept (retained) across restarts until new ones come
|
# kept (retained) across restarts until new ones come
|
||||||
await c.publish(f"{self.base}/received", json.dumps({"commands": self.received_list(ctl)}), retain=True)
|
await c.publish(f"{self.base}/received", json.dumps({"commands": self.received_list(ctl)}), retain=True)
|
||||||
|
market = self.bundles.market_now(now)
|
||||||
|
if market is not None:
|
||||||
|
await c.publish(f"{self.base}/market/availability", "offline" if market["stale"] else "online", retain=True)
|
||||||
|
await c.publish(f"{self.base}/market", json.dumps(self.market_state(market), default=str), retain=True)
|
||||||
for f in self.bundles.flat_list()[:MAX_FLATS]:
|
for f in self.bundles.flat_list()[:MAX_FLATS]:
|
||||||
await c.publish(f"{self.base}/flat/{_slug(f['id'])}", json.dumps(self.flat_state(f, now)), retain=True)
|
await c.publish(f"{self.base}/flat/{_slug(f['id'])}", json.dumps(self.flat_state(f, now)), retain=True)
|
||||||
|
|
||||||
@@ -371,13 +541,13 @@ class Announcer:
|
|||||||
async def _grid_orders(self, c):
|
async def _grid_orders(self, c):
|
||||||
"""The EEBUS bridge's grid order (gridorder.py), to the
|
"""The EEBUS bridge's grid order (gridorder.py), to the
|
||||||
controller: the grid operator's limit as a higher-rank decision."""
|
controller: the grid operator's limit as a higher-rank decision."""
|
||||||
ctl = getattr(self.agent, "control", None)
|
take = getattr(self.agent, "grid_order", None)
|
||||||
if ctl is None:
|
if take is None:
|
||||||
return
|
return
|
||||||
|
|
||||||
def on(topic, payload):
|
def on(topic, payload):
|
||||||
if topic == gridorder.TOPIC and payload:
|
if topic == gridorder.TOPIC and payload:
|
||||||
asyncio.ensure_future(ctl.grid_order(payload))
|
asyncio.ensure_future(take(payload))
|
||||||
c.on_message = on
|
c.on_message = on
|
||||||
try:
|
try:
|
||||||
await c.subscribe(gridorder.TOPIC)
|
await c.subscribe(gridorder.TOPIC)
|
||||||
|
|||||||
@@ -1,5 +1,6 @@
|
|||||||
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
||||||
"""Data bundles the optimiser reads: tariffs and the forecast model.
|
"""Data bundles the optimiser reads: tariffs and the forecast model (and,
|
||||||
|
for Home Assistant only, a building's flats and the shadow market).
|
||||||
|
|
||||||
Both arrive as signed commands; the link checks the signature with the
|
Both arrive as signed commands; the link checks the signature with the
|
||||||
bundle key, the kind, site and expiry, keeps only the newest, and writes the
|
bundle key, the kind, site and expiry, keeps only the newest, and writes the
|
||||||
@@ -24,10 +25,35 @@ Model v1 (the forecasts' data; the ML in ml/ is a placeholder, 2026-10-28):
|
|||||||
hour_of_week = weekday (Monday 0) * 24 + hour, in the site's time zone.
|
hour_of_week = weekday (Monday 0) * 24 + hour, in the site's time zone.
|
||||||
Without a model (or a series): the same quarter hour yesterday from the
|
Without a model (or a series): the same quarter hour yesterday from the
|
||||||
agent's own history (inputs.History), else 0.
|
agent's own history (inputs.History), else 0.
|
||||||
|
Optional (2026-10-30; an older agent ignores them):
|
||||||
|
- per series "series": {"start": <unix, a quarter hour>, "step_s": 900,
|
||||||
|
"values": [at most 400 numbers]}: the cloud's trained forecast (W) for
|
||||||
|
the next ~48 h; where it covers a step it is taken, elsewhere the
|
||||||
|
hour_of_week profile.
|
||||||
|
- "rooms": {"<key>": {"r_k_per_kw": 0.5-200, "c_kwh_per_k": 0.1-100,
|
||||||
|
"power": "thermal"|"electric" (default thermal), ...}}: a room's R and C
|
||||||
|
identified in the cloud from its history (electric: fitted against the
|
||||||
|
heating's electric power; inputs.model_state converts with the cop).
|
||||||
|
Only from a model for this site (not "*"). A heating or cooling control
|
||||||
|
takes its room by its id, its id without _heating/_cooling/_heat/_cool,
|
||||||
|
its area, or, as the site's only such control, the model's only room
|
||||||
|
(room_rc). The mapping's own r_k_per_kw/c_kwh_per_k win.
|
||||||
|
- forecasts "base_load_w" (2026-11-03, Finding A2-a): the load without the
|
||||||
|
devices the box plans (load.power less heatpump.power, ac.power and
|
||||||
|
ev.power where the site has those controls); the plan's load. A model
|
||||||
|
without it: its load_w only where the box has no meter of a planned
|
||||||
|
device inside the load (inputs.model_state), else the box's history.
|
||||||
|
- per room "gain_w" (a constant internal gain, W of heat, or 24 values by
|
||||||
|
local hour) and "solar_w_per_kw" (W of heat per kW/m² of global
|
||||||
|
irradiance) (2026-11-03, Finding B6-a): the fit's other terms, taken
|
||||||
|
into the room's model with R and C (room_rc). Absent: 0, as before.
|
||||||
|
A malformed series or room refuses the whole bundle.
|
||||||
"""
|
"""
|
||||||
import json
|
import json
|
||||||
import logging
|
import logging
|
||||||
|
import math
|
||||||
import os
|
import os
|
||||||
|
import re
|
||||||
import time
|
import time
|
||||||
from dataclasses import dataclass
|
from dataclasses import dataclass
|
||||||
from datetime import datetime, timezone
|
from datetime import datetime, timezone
|
||||||
@@ -85,14 +111,60 @@ def _check_tariff(d: dict):
|
|||||||
raise ValueError("no import price")
|
raise ValueError("no import price")
|
||||||
|
|
||||||
|
|
||||||
|
SERIES_MAX = 400 # a model's series: steps of 900 s (~4 days)
|
||||||
|
ROOM_R = (0.5, 200.0) # K/kW
|
||||||
|
ROOM_C = (0.1, 100.0) # kWh/K
|
||||||
|
ROOM_SUFFIX = re.compile(r"_(heating|cooling|heat|cool)$")
|
||||||
|
# a room's fitted gains (Finding B6-a), as the planner takes them: outside
|
||||||
|
# these the fit's artefact (a negative sun, a gain above any home's) is cut
|
||||||
|
ROOM_GAIN_W = (-2000.0, 5000.0) # W of heat, internal (people, appliances)
|
||||||
|
ROOM_SOLAR_M2 = (0.0, 50.0) # W of heat per W/m² of global irradiance
|
||||||
|
|
||||||
|
|
||||||
|
def _clip(x: float, lo_hi) -> float:
|
||||||
|
return min(max(float(x), lo_hi[0]), lo_hi[1])
|
||||||
|
|
||||||
|
|
||||||
|
def _finite(x) -> bool:
|
||||||
|
return isinstance(x, (int, float)) and not isinstance(x, bool) and math.isfinite(x)
|
||||||
|
|
||||||
|
|
||||||
def _check_model(d: dict):
|
def _check_model(d: dict):
|
||||||
if d.get("v") != 1 or d.get("kind") != "model":
|
if d.get("v") != 1 or d.get("kind") != "model":
|
||||||
raise ValueError("not a v1 model")
|
raise ValueError("not a v1 model")
|
||||||
for name, f in (d.get("forecasts") or {}).items():
|
for name, f in (d.get("forecasts") or {}).items():
|
||||||
if f.get("profile") != "hour_of_week" or len(f.get("values") or []) != 168:
|
if not isinstance(f, dict) or f.get("profile") != "hour_of_week" or len(f.get("values") or []) != 168:
|
||||||
raise ValueError(f"{name}: an hour_of_week profile of 168 values")
|
raise ValueError(f"{name}: an hour_of_week profile of 168 values")
|
||||||
if not all(isinstance(x, (int, float)) for x in f["values"]):
|
if not all(isinstance(x, (int, float)) for x in f["values"]):
|
||||||
raise ValueError(f"{name}: numbers")
|
raise ValueError(f"{name}: numbers")
|
||||||
|
s = f.get("series")
|
||||||
|
if s is None:
|
||||||
|
continue
|
||||||
|
if not isinstance(s, dict) or s.get("step_s") != 900 or not _finite(s.get("start")) or s["start"] % 900:
|
||||||
|
raise ValueError(f"{name}: a series in steps of 900 s from a quarter hour")
|
||||||
|
v = s.get("values")
|
||||||
|
if not isinstance(v, list) or len(v) > SERIES_MAX or not all(_finite(x) for x in v):
|
||||||
|
raise ValueError(f"{name}: a series of at most {SERIES_MAX} numbers")
|
||||||
|
rooms = d.get("rooms")
|
||||||
|
if rooms is None:
|
||||||
|
return
|
||||||
|
if not isinstance(rooms, dict):
|
||||||
|
raise ValueError("rooms: an object")
|
||||||
|
for key, r in rooms.items():
|
||||||
|
if not isinstance(r, dict):
|
||||||
|
raise ValueError(f"room {key}: an object")
|
||||||
|
rk, ck = r.get("r_k_per_kw"), r.get("c_kwh_per_k")
|
||||||
|
if not _finite(rk) or not ROOM_R[0] <= rk <= ROOM_R[1]:
|
||||||
|
raise ValueError(f"room {key}: r_k_per_kw {ROOM_R[0]}-{ROOM_R[1]}")
|
||||||
|
if not _finite(ck) or not ROOM_C[0] <= ck <= ROOM_C[1]:
|
||||||
|
raise ValueError(f"room {key}: c_kwh_per_k {ROOM_C[0]}-{ROOM_C[1]}")
|
||||||
|
if r.get("power", "thermal") not in ("thermal", "electric"):
|
||||||
|
raise ValueError(f"room {key}: power thermal or electric")
|
||||||
|
g = r.get("gain_w")
|
||||||
|
if g is not None and not (_finite(g) or (isinstance(g, list) and len(g) == 24 and all(_finite(x) for x in g))):
|
||||||
|
raise ValueError(f"room {key}: gain_w a number or 24 numbers (by local hour)")
|
||||||
|
if r.get("solar_m2") is not None and not _finite(r["solar_m2"]):
|
||||||
|
raise ValueError(f"room {key}: solar_m2 a number")
|
||||||
|
|
||||||
|
|
||||||
def _check_flats(d: dict):
|
def _check_flats(d: dict):
|
||||||
@@ -108,6 +180,32 @@ def _check_flats(d: dict):
|
|||||||
raise ValueError("flat label: a string")
|
raise ValueError("flat label: a string")
|
||||||
|
|
||||||
|
|
||||||
|
MARKET_STALE_S = 4 * 900 # without stale_after_s in the bundle: four slots
|
||||||
|
|
||||||
|
|
||||||
|
def _check_market(d: dict):
|
||||||
|
"""The shadow market's values for this box's own nodes (fleet's
|
||||||
|
marketbundle.go, the market's step 1.5). Written by the link from a
|
||||||
|
signed `market` bundle; shown in HA (announce.py, dashboards.py), never
|
||||||
|
acted on: a bundle that is not marked shadow-only is refused."""
|
||||||
|
if d.get("v") != 1 or d.get("kind") != "market":
|
||||||
|
raise ValueError("not a v1 market bundle")
|
||||||
|
if d.get("shadow") is not True or d.get("commands") != "none":
|
||||||
|
raise ValueError("a market bundle is shadow only (commands: none)")
|
||||||
|
for key, most in (("contracts", 200), ("links", 200), ("actuators", 100), ("positions", 10), ("nodes", 10)):
|
||||||
|
v = d.get(key) or []
|
||||||
|
if not isinstance(v, list) or len(v) > most:
|
||||||
|
raise ValueError(f"{key}: a list of at most {most}")
|
||||||
|
for c in d.get("contracts") or []:
|
||||||
|
if not isinstance(c.get("id"), str) or not c["id"] or len(c["id"]) > 80:
|
||||||
|
raise ValueError("contract id: a string")
|
||||||
|
if c.get("direction") not in ("sells", "buys"):
|
||||||
|
raise ValueError("contract direction: sells or buys")
|
||||||
|
for a in d.get("actuators") or []:
|
||||||
|
if not isinstance(a.get("device"), str) or not a["device"] or len(a["device"]) > 80:
|
||||||
|
raise ValueError("actuator device: a string")
|
||||||
|
|
||||||
|
|
||||||
@dataclass
|
@dataclass
|
||||||
class Prices:
|
class Prices:
|
||||||
import_ct: list[float]
|
import_ct: list[float]
|
||||||
@@ -115,12 +213,49 @@ class Prices:
|
|||||||
note: str # what the prices are ("tariff <id>", "flat fallback ...")
|
note: str # what the prices are ("tariff <id>", "flat fallback ...")
|
||||||
|
|
||||||
|
|
||||||
|
def _ahead_terms(ah, start: int, step_s: int, steps: int, terms) -> list | None:
|
||||||
|
"""A contract's coming slots (fleet marketbundle.go "ahead": windows of
|
||||||
|
slot indices with their amounts, the price as [count, ct] runs) as the
|
||||||
|
plan's steps: per step None (outside its windows or the slots told) or
|
||||||
|
terms(price, guaranteed_kwh, minimum_kwh, max_kwh). None when the
|
||||||
|
contract has no usable "ahead" (the caller then holds its slot's terms)."""
|
||||||
|
if not isinstance(ah, dict):
|
||||||
|
return None
|
||||||
|
try:
|
||||||
|
a0, astep, n = int(ah["start"]), int(ah.get("step_s") or 900), int(ah.get("slots") or 0)
|
||||||
|
prices = []
|
||||||
|
for cnt, ct in ah.get("price_ct") or []:
|
||||||
|
prices += [float(ct)] * int(cnt)
|
||||||
|
wins = [(int(w["from"]), int(w["to"]), w) for w in ah.get("windows") or []]
|
||||||
|
except (KeyError, TypeError, ValueError):
|
||||||
|
return None
|
||||||
|
if astep <= 0 or n <= 0 or n > 2000 or len(prices) < n:
|
||||||
|
return None
|
||||||
|
by_slot: dict[int, dict] = {}
|
||||||
|
for f, t, w in wins:
|
||||||
|
for i in range(max(0, f), min(n, t)):
|
||||||
|
by_slot[i] = w
|
||||||
|
out = []
|
||||||
|
for k in range(steps):
|
||||||
|
i = (start + k * step_s - a0) // astep
|
||||||
|
w = by_slot.get(i) if 0 <= i < n else None
|
||||||
|
if w is None:
|
||||||
|
out.append(None)
|
||||||
|
continue
|
||||||
|
try:
|
||||||
|
out.append(terms(prices[i], w.get("guaranteed_kwh"), w.get("minimum_kwh"), w.get("max_kwh")))
|
||||||
|
except (TypeError, ValueError):
|
||||||
|
out.append(None)
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
class Bundles:
|
class Bundles:
|
||||||
def __init__(self, state_dir: str, site: str, default_price_ct: float = 30.0):
|
def __init__(self, state_dir: str, site: str, default_price_ct: float = 30.0):
|
||||||
self.site, self.default = site, default_price_ct
|
self.site, self.default = site, default_price_ct
|
||||||
self.tariff = _File(os.path.join(state_dir, "tariff.json"), _check_tariff)
|
self.tariff = _File(os.path.join(state_dir, "tariff.json"), _check_tariff)
|
||||||
self.model = _File(os.path.join(state_dir, "model.json"), _check_model)
|
self.model = _File(os.path.join(state_dir, "model.json"), _check_model)
|
||||||
self.flats = _File(os.path.join(state_dir, "flats.json"), _check_flats)
|
self.flats = _File(os.path.join(state_dir, "flats.json"), _check_flats)
|
||||||
|
self.market = _File(os.path.join(state_dir, "market.json"), _check_market)
|
||||||
self.flat: float | None = None # the last known tariff's mean import price
|
self.flat: float | None = None # the last known tariff's mean import price
|
||||||
|
|
||||||
def stamps(self):
|
def stamps(self):
|
||||||
@@ -136,16 +271,19 @@ class Bundles:
|
|||||||
imp = [x for x in t["import"] if x is not None]
|
imp = [x for x in t["import"] if x is not None]
|
||||||
self.flat = sum(imp) / len(imp)
|
self.flat = sum(imp) / len(imp)
|
||||||
flat = self.flat if self.flat is not None else self.default
|
flat = self.flat if self.flat is not None else self.default
|
||||||
|
# feed-in without a price is counted at 0 ct: the plan then values PV
|
||||||
|
# export at nothing (it may curtail or self-consume more), so its note says so
|
||||||
if t is None:
|
if t is None:
|
||||||
note = "no tariff yet: default price" if self.flat is None else "no tariff: last known flat price"
|
note = "no tariff yet: default price" if self.flat is None else "no tariff: last known flat price"
|
||||||
return Prices([flat] * steps, [0.0] * steps, note)
|
return Prices([flat] * steps, [0.0] * steps, note + "; feed-in at 0 ct/kWh")
|
||||||
expired = now >= t.get("expires", 0)
|
expired = now >= t.get("expires", 0)
|
||||||
out_i, out_e, outside = [], [], 0
|
out_i, out_e, outside, no_export = [], [], 0, 0
|
||||||
for k in range(steps):
|
for k in range(steps):
|
||||||
i = (start + k * step_s - t["start"]) // 900
|
i = (start + k * step_s - t["start"]) // 900
|
||||||
pi = t["import"][i] if not expired and 0 <= i < len(t["import"]) else None
|
pi = t["import"][i] if not expired and 0 <= i < len(t["import"]) else None
|
||||||
pe = (t.get("export") or [])[i] if not expired and 0 <= i < len(t.get("export") or []) else None
|
pe = (t.get("export") or [])[i] if not expired and 0 <= i < len(t.get("export") or []) else None
|
||||||
outside += pi is None
|
outside += pi is None
|
||||||
|
no_export += pe is None
|
||||||
out_i.append(pi if pi is not None else flat)
|
out_i.append(pi if pi is not None else flat)
|
||||||
out_e.append(pe if pe is not None else 0.0)
|
out_e.append(pe if pe is not None else 0.0)
|
||||||
if expired:
|
if expired:
|
||||||
@@ -154,6 +292,10 @@ class Bundles:
|
|||||||
note = f"tariff {t.get('id')}; {outside} of {steps} steps at the flat {flat:.1f} ct/kWh"
|
note = f"tariff {t.get('id')}; {outside} of {steps} steps at the flat {flat:.1f} ct/kWh"
|
||||||
else:
|
else:
|
||||||
note = f"tariff {t.get('id')}"
|
note = f"tariff {t.get('id')}"
|
||||||
|
if no_export == steps:
|
||||||
|
note += "; feed-in at 0 ct/kWh"
|
||||||
|
elif no_export:
|
||||||
|
note += f"; feed-in at 0 ct/kWh in {no_export} of {steps} steps (no export price)"
|
||||||
return Prices(out_i, out_e, note)
|
return Prices(out_i, out_e, note)
|
||||||
|
|
||||||
def tariff_now(self, now: float) -> dict | None:
|
def tariff_now(self, now: float) -> dict | None:
|
||||||
@@ -178,7 +320,8 @@ class Bundles:
|
|||||||
if m is None or m.get("site") not in (self.site, "*"):
|
if m is None or m.get("site") not in (self.site, "*"):
|
||||||
return None
|
return None
|
||||||
return {"id": m.get("id"), "source": m.get("source") or m.get("id"), "issued": m.get("issued"),
|
return {"id": m.get("id"), "source": m.get("source") or m.get("id"), "issued": m.get("issued"),
|
||||||
"expires": m.get("expires"), "series": sorted((m.get("forecasts") or {}))}
|
"expires": m.get("expires"), "series": sorted((m.get("forecasts") or {})),
|
||||||
|
"rooms": sorted(m.get("rooms") or {}) if m.get("site") == self.site else []}
|
||||||
|
|
||||||
def flat_list(self) -> list[dict]:
|
def flat_list(self) -> list[dict]:
|
||||||
d = self.flats.get()
|
d = self.flats.get()
|
||||||
@@ -188,6 +331,69 @@ class Bundles:
|
|||||||
return []
|
return []
|
||||||
return list(d.get("flats") or [])
|
return list(d.get("flats") or [])
|
||||||
|
|
||||||
|
def market_now(self, now: float) -> dict | None:
|
||||||
|
"""The market bundle for HA, or None (none, another site's, expired,
|
||||||
|
or nothing in it). "stale": older than its stale_after_s (the
|
||||||
|
entities go unavailable then)."""
|
||||||
|
d = self.market.get()
|
||||||
|
if d is None or d.get("site") not in (self.site,) or (d.get("expires") and d["expires"] <= now):
|
||||||
|
return None
|
||||||
|
if not (d.get("contracts") or d.get("actuators")):
|
||||||
|
return None
|
||||||
|
age = now - max(d.get("issued") or 0, d.get("slot") or 0)
|
||||||
|
return dict(d, stale=age > float(d.get("stale_after_s") or MARKET_STALE_S), age_s=int(age))
|
||||||
|
|
||||||
|
def market_for_model(self, start: int, step_s: int, steps: int, now: float) -> list[dict]:
|
||||||
|
"""The contracts in force as energy sources and sinks for the plan
|
||||||
|
(the market's step 2; shadow: the plan only, no commands). Per
|
||||||
|
contract: id, name, direction (buys: an import source, sells: an
|
||||||
|
export sink), price_ct, guaranteed_w (firm), minimum_wh (take-or-pay,
|
||||||
|
per step), max_w (0: none), from_step, to_step (the plan's steps it
|
||||||
|
applies in) and, from a bundle with the coming slots, terms: per plan
|
||||||
|
step None (it does not apply) or {price_ct, guaranteed_w, minimum_wh,
|
||||||
|
max_w}; the scalars are then those of its first step.
|
||||||
|
|
||||||
|
The coming slots (a contract's "ahead", fleet marketbundle.go since
|
||||||
|
market-polish): each step gets its own slot's terms (window, amounts,
|
||||||
|
price) as far as the bundle tells them, while the bundle is fresh.
|
||||||
|
A bundle without them (an older fleet) carries one slot's terms; they
|
||||||
|
are held for the steps while the bundle is fresh (its slot .. slot +
|
||||||
|
stale_after_s), nothing beyond: the plan never assumes a contract it
|
||||||
|
hasn't been told of."""
|
||||||
|
d = self.market_now(now)
|
||||||
|
if d is None or d.get("stale"):
|
||||||
|
return []
|
||||||
|
slot = int(d.get("slot") or 0)
|
||||||
|
h = int(d.get("step_s") or 900) / 3600.0 # the bundle's slot in hours: kWh per slot -> W
|
||||||
|
|
||||||
|
def terms(price, g_kwh, min_kwh, max_kwh):
|
||||||
|
return {"price_ct": float(price),
|
||||||
|
"guaranteed_w": max(0.0, float(g_kwh or 0)) * 1000.0 / h,
|
||||||
|
"minimum_wh": max(0.0, float(min_kwh or 0)) * 1000.0 * (step_s / 3600.0) / h,
|
||||||
|
"max_w": max(0.0, float(max_kwh or 0)) * 1000.0 / h}
|
||||||
|
|
||||||
|
until = slot + int(float(d.get("stale_after_s") or MARKET_STALE_S))
|
||||||
|
a = max(0, -(-(slot - start) // step_s))
|
||||||
|
b = min(steps, -(-(until - start) // step_s))
|
||||||
|
out = []
|
||||||
|
for c in d.get("contracts") or []:
|
||||||
|
head = {"id": c["id"], "name": str(c.get("name") or "")[:200], "direction": c["direction"]}
|
||||||
|
per = _ahead_terms(c.get("ahead"), start, step_s, steps, terms)
|
||||||
|
if per is not None:
|
||||||
|
on = [t for t, x in enumerate(per) if x is not None]
|
||||||
|
if on:
|
||||||
|
out.append({**head, **per[on[0]], "from_step": on[0], "to_step": on[-1] + 1, "terms": per})
|
||||||
|
continue
|
||||||
|
sl = c.get("slot") or {}
|
||||||
|
if b <= a or not sl.get("applies"):
|
||||||
|
continue
|
||||||
|
try:
|
||||||
|
x = terms(sl.get("price_ct"), sl.get("guaranteed_kwh"), sl.get("minimum_kwh"), sl.get("max_kwh"))
|
||||||
|
except (TypeError, ValueError):
|
||||||
|
continue
|
||||||
|
out.append({**head, **x, "from_step": a, "to_step": b})
|
||||||
|
return out
|
||||||
|
|
||||||
def forecast(self, name: str, start: int, step_s: int, steps: int, tz: str) -> list[float] | None:
|
def forecast(self, name: str, start: int, step_s: int, steps: int, tz: str) -> list[float] | None:
|
||||||
"""A model series for the horizon, or None (no model or no such
|
"""A model series for the horizon, or None (no model or no such
|
||||||
series: the caller falls back to history)."""
|
series: the caller falls back to history)."""
|
||||||
@@ -198,12 +404,47 @@ class Bundles:
|
|||||||
if f is None:
|
if f is None:
|
||||||
return None
|
return None
|
||||||
zone = ZoneInfo(tz or "UTC")
|
zone = ZoneInfo(tz or "UTC")
|
||||||
|
ser = f.get("series") or {}
|
||||||
|
s0, sv = ser.get("start"), ser.get("values") or []
|
||||||
out = []
|
out = []
|
||||||
for k in range(steps):
|
for k in range(steps):
|
||||||
d = datetime.fromtimestamp(start + k * step_s, timezone.utc).astimezone(zone)
|
t = start + k * step_s
|
||||||
|
i = int((t - s0) // 900) if sv else -1
|
||||||
|
if 0 <= i < len(sv):
|
||||||
|
out.append(float(sv[i])) # the trained series where it covers
|
||||||
|
continue
|
||||||
|
d = datetime.fromtimestamp(t, timezone.utc).astimezone(zone)
|
||||||
out.append(float(f["values"][d.weekday() * 24 + d.hour]))
|
out.append(float(f["values"][d.weekday() * 24 + d.hour]))
|
||||||
return out
|
return out
|
||||||
|
|
||||||
|
def room_rc(self, control_id: str, area: str = "", only_one: bool = False,
|
||||||
|
now: float | None = None) -> dict | None:
|
||||||
|
"""A heating or cooling control's room in the model (R and C fitted
|
||||||
|
in the cloud): by its id, its id without _heating/_cooling/_heat/
|
||||||
|
_cool, its area; else, when the caller says it is the site's only
|
||||||
|
such control (only_one), the model's only room. None without a
|
||||||
|
model for this site (a shared "*" model has no rooms), expired, or
|
||||||
|
no match. {"r_k_per_kw", "c_kwh_per_k", "power", "gain_w" (W, a
|
||||||
|
number or 24 by local hour; 0 when the model has none),
|
||||||
|
"solar_m2"}."""
|
||||||
|
m = self.model.get()
|
||||||
|
now = time.time() if now is None else now
|
||||||
|
if m is None or m.get("site") != self.site or (m.get("expires") and m["expires"] <= now):
|
||||||
|
return None
|
||||||
|
rooms = m.get("rooms") or {}
|
||||||
|
key = next((k for k in (control_id, ROOM_SUFFIX.sub("", control_id or ""), area or "")
|
||||||
|
if k and k in rooms), None)
|
||||||
|
if key is None and only_one and len(rooms) == 1:
|
||||||
|
key = next(iter(rooms))
|
||||||
|
if key is None:
|
||||||
|
return None
|
||||||
|
r = rooms[key]
|
||||||
|
g = r.get("gain_w") or 0.0
|
||||||
|
return {"r_k_per_kw": float(r["r_k_per_kw"]), "c_kwh_per_k": float(r["c_kwh_per_k"]),
|
||||||
|
"power": r.get("power") or "thermal",
|
||||||
|
"gain_w": [_clip(x, ROOM_GAIN_W) for x in g] if isinstance(g, list) else _clip(g, ROOM_GAIN_W),
|
||||||
|
"solar_m2": _clip(r.get("solar_m2") or 0.0, ROOM_SOLAR_M2)}
|
||||||
|
|
||||||
def model_id(self) -> str:
|
def model_id(self) -> str:
|
||||||
m = self.model.get()
|
m = self.model.get()
|
||||||
return m.get("id", "") if m else ""
|
return m.get("id", "") if m else ""
|
||||||
@@ -55,6 +55,10 @@ class Config:
|
|||||||
solve_timeout_s: float = 60.0 # the optimiser's subprocess is killed after this
|
solve_timeout_s: float = 60.0 # the optimiser's subprocess is killed after this
|
||||||
plan_stale_s: int = 1800 # older plans: the safe defaults
|
plan_stale_s: int = 1800 # older plans: the safe defaults
|
||||||
default_price_ct: float = 30.0 # ct/kWh when no tariff ever came
|
default_price_ct: float = 30.0 # ct/kWh when no tariff ever came
|
||||||
|
# The site's grid connection (W): the plan's import and export are at most
|
||||||
|
# this. 3 x 230 V x 63 A, a German house connection's usual main fuse;
|
||||||
|
# a site with a smaller fuse (or a building's larger one) sets its own.
|
||||||
|
grid_max_w: float = 43470.0
|
||||||
override_hold_s: int = 7200 # hands off a control the owner changed by hand
|
override_hold_s: int = 7200 # hands off a control the owner changed by hand
|
||||||
min_switch_s: int = 600 # anti-cycling: a switch stays on/off at least this long
|
min_switch_s: int = 600 # anti-cycling: a switch stays on/off at least this long
|
||||||
max_actions_per_hour: int = 12 # per control
|
max_actions_per_hour: int = 12 # per control
|
||||||
|
|||||||
@@ -35,6 +35,7 @@ import time
|
|||||||
from . import inputs as inputs_mod
|
from . import inputs as inputs_mod
|
||||||
from .building import Building
|
from .building import Building
|
||||||
from .bundles import Bundles
|
from .bundles import Bundles
|
||||||
|
from .evphases import EvPhases
|
||||||
from .executor import Executor, building_msg
|
from .executor import Executor, building_msg
|
||||||
from .gridorder import GridOrders
|
from .gridorder import GridOrders
|
||||||
from .guard import Guard
|
from .guard import Guard
|
||||||
@@ -81,6 +82,7 @@ class Controller:
|
|||||||
min_switch_s=cfg.min_switch_s, max_actions_per_hour=cfg.max_actions_per_hour, clock=clock)
|
min_switch_s=cfg.min_switch_s, max_actions_per_hour=cfg.max_actions_per_hour, clock=clock)
|
||||||
self.saved_limits = self._load_limits() # the console's (limits.json)
|
self.saved_limits = self._load_limits() # the console's (limits.json)
|
||||||
self.gridorders = GridOrders(cfg.state_dir, clock) # the grid operator's, from the EEBUS bridge (3q)
|
self.gridorders = GridOrders(cfg.state_dir, clock) # the grid operator's, from the EEBUS bridge (3q)
|
||||||
|
self.evphases = EvPhases(cfg.state_dir) # each charger's phase count and its source
|
||||||
self.guard.extra_limits = self.saved_limits
|
self.guard.extra_limits = self.saved_limits
|
||||||
self.policy = Policy(cfg.state_dir, cfg.site_id, clock)
|
self.policy = Policy(cfg.state_dir, cfg.site_id, clock)
|
||||||
self.guard.policy = self.policy
|
self.guard.policy = self.policy
|
||||||
@@ -180,6 +182,7 @@ class Controller:
|
|||||||
lat, lon = (cfg or {}).get("latitude"), (cfg or {}).get("longitude")
|
lat, lon = (cfg or {}).get("latitude"), (cfg or {}).get("longitude")
|
||||||
if isinstance(lat, (int, float)) and isinstance(lon, (int, float)):
|
if isinstance(lat, (int, float)) and isinstance(lon, (int, float)):
|
||||||
self.location = {"latitude": float(lat), "longitude": float(lon)}
|
self.location = {"latitude": float(lat), "longitude": float(lon)}
|
||||||
|
write_cell(self.cfg.state_dir, float(lat), float(lon))
|
||||||
except Exception as e:
|
except Exception as e:
|
||||||
log.warning("get_config: %s", e)
|
log.warning("get_config: %s", e)
|
||||||
ids = self.entities()
|
ids = self.entities()
|
||||||
@@ -222,7 +225,9 @@ class Controller:
|
|||||||
self.history, self.tz, self.forecast, self.guard.extra_limits,
|
self.history, self.tz, self.forecast, self.guard.extra_limits,
|
||||||
building=self.building.for_model(start, inputs_mod.STEP_S, inputs_mod.STEPS),
|
building=self.building.for_model(start, inputs_mod.STEP_S, inputs_mod.STEPS),
|
||||||
location=self.location, shade_ctx=self.shade_ctx(),
|
location=self.location, shade_ctx=self.shade_ctx(),
|
||||||
grid_order=self.gridorders.for_model(start, inputs_mod.STEP_S, inputs_mod.STEPS))
|
grid_order=self.gridorders.for_model(start, inputs_mod.STEP_S, inputs_mod.STEPS),
|
||||||
|
grid_max_w=getattr(self.cfg, "grid_max_w", None),
|
||||||
|
ev_phases=self.ev_phases())
|
||||||
|
|
||||||
async def make_plan(self) -> dict | None:
|
async def make_plan(self) -> dict | None:
|
||||||
self.forecast = []
|
self.forecast = []
|
||||||
@@ -261,15 +266,20 @@ class Controller:
|
|||||||
"prices": plan.get("price_note", ""), "model": plan.get("model", ""),
|
"prices": plan.get("price_note", ""), "model": plan.get("model", ""),
|
||||||
"sources": plan.get("sources", {}),
|
"sources": plan.get("sources", {}),
|
||||||
# for the building (shed_w/grid_w per step, 24 h): absent from older agents
|
# for the building (shed_w/grid_w per step, 24 h): absent from older agents
|
||||||
"flex": plan.get("flex", {})}
|
"flex": plan.get("flex", {}),
|
||||||
|
# the market's contracts in the plan (shadow): planned kWh and saving vs the grid
|
||||||
|
"market": plan.get("market", [])}
|
||||||
|
|
||||||
def inputs_fresh(self) -> bool:
|
def inputs_fresh(self) -> bool:
|
||||||
"""The plan's room temperatures and the battery's state are not older
|
"""The plan's room temperatures and the battery's state have a value
|
||||||
than an hour (a sensor that stopped must not steer)."""
|
(a sensor that stopped must not steer). HA marks a device that went
|
||||||
now = self.clock()
|
away unavailable; a value that holds steady is not stale (the clone,
|
||||||
|
2026-10-30: a room at 23.5 °C for hours and a full battery held every
|
||||||
|
control at its safe default), and HA sends no update for an
|
||||||
|
unchanged value, so its age says nothing."""
|
||||||
for c in self.controls:
|
for c in self.controls:
|
||||||
for role in ("temp", "soc"):
|
for role in ("temp", "soc"):
|
||||||
if role in c.entities and self.col.age(c.entities[role], now) > 3600:
|
if role in c.entities and self.col.value(c.entities[role]) is None:
|
||||||
return False
|
return False
|
||||||
return True
|
return True
|
||||||
|
|
||||||
@@ -378,8 +388,10 @@ class Controller:
|
|||||||
async def _actor(self, stop):
|
async def _actor(self, stop):
|
||||||
while not stop.is_set():
|
while not stop.is_set():
|
||||||
now = self.clock()
|
now = self.clock()
|
||||||
self.history.add("load_w", self.col.total(self.inputs.load_power), now)
|
self.history.add("load_w", inputs_mod.base_load(self.col, self.inputs), now)
|
||||||
self.history.add("pv_w", self.col.total(self.inputs.pv_power), now)
|
self.history.add("pv_w", self.col.total(self.inputs.pv_power), now)
|
||||||
|
if self.sample_ev_phases(now) and self.gridorders.active():
|
||||||
|
self._merge_limits() # a learned count: the order's current bound again
|
||||||
if int(now) % 900 < 60:
|
if int(now) % 900 < 60:
|
||||||
try:
|
try:
|
||||||
self.history.save(now)
|
self.history.save(now)
|
||||||
@@ -387,6 +399,10 @@ class Controller:
|
|||||||
log.warning("history: %s", e)
|
log.warning("history: %s", e)
|
||||||
self.executor.inputs_ok = self.inputs_fresh()
|
self.executor.inputs_ok = self.inputs_fresh()
|
||||||
self.grid_tick()
|
self.grid_tick()
|
||||||
|
try:
|
||||||
|
await self.grid_report()
|
||||||
|
except Exception as e:
|
||||||
|
log.warning("grid order report: %s", e)
|
||||||
if self.switch_sides():
|
if self.switch_sides():
|
||||||
self.wake.set() # heating <-> cooling: a plan for the new side
|
self.wake.set() # heating <-> cooling: a plan for the new side
|
||||||
try:
|
try:
|
||||||
@@ -506,12 +522,34 @@ class Controller:
|
|||||||
os.replace(p + ".tmp", p)
|
os.replace(p + ".tmp", p)
|
||||||
|
|
||||||
|
|
||||||
|
# -- the chargers' phases (evphases.py) ------------------------------------
|
||||||
|
def ev_phases(self) -> dict:
|
||||||
|
"""{control id: {"phases", "source", "plan", "order"}} for the EV controls."""
|
||||||
|
return self.evphases.all(self.controls, self.col)
|
||||||
|
|
||||||
|
def sample_ev_phases(self, now: float) -> bool:
|
||||||
|
"""A reading per charger for learning its phases: its power (its own
|
||||||
|
`power` sensor, else the site's ev.power where it is the only
|
||||||
|
charger) and current (measured, else its setpoint). True when a
|
||||||
|
learned count changed."""
|
||||||
|
evs = [c for c in self.controls if c.kind == "ev"]
|
||||||
|
site_ev = self.mapping.by_asset.get("ev.power") if len(evs) == 1 and hasattr(self.mapping, "by_asset") else None
|
||||||
|
changed = False
|
||||||
|
for c in evs:
|
||||||
|
pw = c.entities.get("power") or (site_ev.entity if site_ev else "")
|
||||||
|
cur = c.entities.get("current_measured") or c.entities.get("current") or ""
|
||||||
|
p = inputs_mod.watts(self.col, pw) if pw else None
|
||||||
|
a = self.col.value(cur) if cur else None
|
||||||
|
changed |= self.evphases.sample(c.id, p, a, float(c.p("voltage")), now)
|
||||||
|
return changed
|
||||||
|
|
||||||
# -- the grid operator's limit (EEBUS LPC, gridorder.py) -----------------
|
# -- the grid operator's limit (EEBUS LPC, gridorder.py) -----------------
|
||||||
def _merge_limits(self):
|
def _merge_limits(self):
|
||||||
"""The guard's limits: the console's, and over them the grid order's
|
"""The guard's limits: the console's, and over them the grid order's
|
||||||
at level grid (the lower limit of the two holds)."""
|
at level grid (the lower limit of the two holds)."""
|
||||||
merged = {c: {q: dict(lv) for q, lv in qs.items()} for c, qs in self.saved_limits.items()}
|
merged = {c: {q: dict(lv) for q, lv in qs.items()} for c, qs in self.saved_limits.items()}
|
||||||
for cid, qs in self.gridorders.limits(self.controls).items():
|
phases = {cid: v["phases"] for cid, v in self.ev_phases().items()}
|
||||||
|
for cid, qs in self.gridorders.limits(self.controls, phases).items():
|
||||||
for q, (f, lim) in qs.items():
|
for q, (f, lim) in qs.items():
|
||||||
per = merged.setdefault(cid, {}).setdefault(q, {})
|
per = merged.setdefault(cid, {}).setdefault(q, {})
|
||||||
old = per.get("grid")
|
old = per.get("grid")
|
||||||
@@ -538,10 +576,18 @@ class Controller:
|
|||||||
args.update(value="", state="normal")
|
args.update(value="", state="normal")
|
||||||
log.info("grid operator's limit ended")
|
log.info("grid operator's limit ended")
|
||||||
await self._received("grid", args, "grid", True, "limited" if o else "ended")
|
await self._received("grid", args, "grid", True, "limited" if o else "ended")
|
||||||
|
await self.grid_report()
|
||||||
self.wake.set()
|
self.wake.set()
|
||||||
self.act_now.set()
|
self.act_now.set()
|
||||||
return True
|
return True
|
||||||
|
|
||||||
|
async def grid_report(self):
|
||||||
|
"""The order to the cloud as an action (gridorder.py action()): each
|
||||||
|
quarter-hour it holds, and its end."""
|
||||||
|
a = self.gridorders.action()
|
||||||
|
if a is not None:
|
||||||
|
await self._publish("action", a)
|
||||||
|
|
||||||
def grid_tick(self):
|
def grid_tick(self):
|
||||||
"""An order that went stale or ended takes its limits away."""
|
"""An order that went stale or ended takes its limits away."""
|
||||||
if self.gridorders.order and not self.gridorders.active() and any(
|
if self.gridorders.order and not self.gridorders.active() and any(
|
||||||
@@ -562,6 +608,29 @@ def sender(cmd: str, args: dict) -> str:
|
|||||||
return "cloud"
|
return "cloud"
|
||||||
|
|
||||||
|
|
||||||
|
def write_cell(state_dir: str, lat: float, lon: float) -> bool:
|
||||||
|
"""The site's weather cell (0.1°, ~10 km) for the link: site_cell.json
|
||||||
|
in the state directory; the heartbeat carries it to the cloud only with
|
||||||
|
the owner's share consent (edge/link). Written when it changed."""
|
||||||
|
cell = {"lat": round(lat, 1), "lon": round(lon, 1)}
|
||||||
|
path = os.path.join(state_dir, "site_cell.json")
|
||||||
|
try:
|
||||||
|
with open(path) as f:
|
||||||
|
if json.load(f) == cell:
|
||||||
|
return False
|
||||||
|
except (OSError, ValueError):
|
||||||
|
pass
|
||||||
|
try:
|
||||||
|
tmp = path + ".tmp"
|
||||||
|
with open(tmp, "w") as f:
|
||||||
|
json.dump(cell, f)
|
||||||
|
os.replace(tmp, path)
|
||||||
|
except OSError as e:
|
||||||
|
log.warning("site cell: %s", e)
|
||||||
|
return False
|
||||||
|
return True
|
||||||
|
|
||||||
|
|
||||||
SECRET_ARGS = ("proof", "sig", "bundle", "token", "password")
|
SECRET_ARGS = ("proof", "sig", "bundle", "token", "password")
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -67,6 +67,7 @@ from dataclasses import dataclass, field
|
|||||||
|
|
||||||
from . import limits as limits_mod
|
from . import limits as limits_mod
|
||||||
from . import switchover as switchover_mod
|
from . import switchover as switchover_mod
|
||||||
|
from .evphases import ASSUMED
|
||||||
|
|
||||||
log = logging.getLogger(__name__)
|
log = logging.getLogger(__name__)
|
||||||
|
|
||||||
@@ -78,7 +79,9 @@ ENTITIES = {
|
|||||||
"cooling": {"climate": ("climate",), "temp": ("sensor",)},
|
"cooling": {"climate": ("climate",), "temp": ("sensor",)},
|
||||||
"ev": {"switch": ("switch", "input_boolean"), "current": ("number", "input_number"),
|
"ev": {"switch": ("switch", "input_boolean"), "current": ("number", "input_number"),
|
||||||
"connected": ("binary_sensor", "input_boolean"), "soc": ("sensor", "input_number"),
|
"connected": ("binary_sensor", "input_boolean"), "soc": ("sensor", "input_number"),
|
||||||
"energy_needed": ("sensor",), "departure": ("sensor", "input_datetime")},
|
"energy_needed": ("sensor",), "departure": ("sensor", "input_datetime"),
|
||||||
|
# read only, for its phase count (evphases.py): reported, or learned from power and current
|
||||||
|
"phases": ("sensor",), "power": ("sensor",), "current_measured": ("sensor",)},
|
||||||
"cover": {"cover": ("cover",)},
|
"cover": {"cover": ("cover",)},
|
||||||
}
|
}
|
||||||
WRITES = {"charge_from_grid", "setpoint", "mode", "climate", "switch", "current", "cover"}
|
WRITES = {"charge_from_grid", "setpoint", "mode", "climate", "switch", "current", "cover"}
|
||||||
@@ -91,15 +94,31 @@ PARAMS = {
|
|||||||
"manual_option": "manual", "auto_option": "self-consumption", "min_switch_s": 0.0},
|
"manual_option": "manual", "auto_option": "self-consumption", "min_switch_s": 0.0},
|
||||||
"heating": {"r_k_per_kw": 10.0, "c_kwh_per_k": 3.0, "max_power_w": 2000.0, "comfort_c": 21.0,
|
"heating": {"r_k_per_kw": 10.0, "c_kwh_per_k": 3.0, "max_power_w": 2000.0, "comfort_c": 21.0,
|
||||||
"setback_c": 17.0, "cop": 1.0, # cop 1: electric; a heat pump ~3
|
"setback_c": 17.0, "cop": 1.0, # cop 1: electric; a heat pump ~3
|
||||||
"min_switch_s": 600.0},
|
"min_switch_s": 600.0,
|
||||||
|
# the room's other heat (W; the model's fit, inputs._room_rc): internal
|
||||||
|
# (a number, or 24 by local hour) and the sun's per W/m² of irradiance
|
||||||
|
"internal_gain_w": 0.0, "solar_m2": 0.0},
|
||||||
"cooling": {"r_k_per_kw": 10.0, "c_kwh_per_k": 3.0, "max_power_w": 1500.0, "comfort_c": 25.0,
|
"cooling": {"r_k_per_kw": 10.0, "c_kwh_per_k": 3.0, "max_power_w": 1500.0, "comfort_c": 25.0,
|
||||||
"setup_c": 28.0, "cop": 3.0, "min_switch_s": 600.0},
|
"setup_c": 28.0, "cop": 3.0, "min_switch_s": 600.0, "internal_gain_w": 0.0, "solar_m2": 0.0},
|
||||||
"ev": {"need_wh": 10000.0, "departure": "07:00", "min_current_a": 6.0, "max_current_a": 16.0,
|
"ev": {"need_wh": 10000.0, "departure": "07:00", "min_current_a": 6.0, "max_current_a": 16.0,
|
||||||
"phases": 1.0, "voltage": 230.0, "min_switch_s": 0.0},
|
"phases": None, "voltage": 230.0, "min_switch_s": 0.0}, # phases: None, not said (evphases.py)
|
||||||
"cover": {"room": "", "gain_w": 800.0, "min_switch_s": 0.0, "area": "", "facing": -1.0,
|
"cover": {"room": "", "gain_w": 800.0, "min_switch_s": 0.0, "area": "", "facing": -1.0,
|
||||||
"open_pct": 100.0, "shade_pct": 30.0, "closed_pct": 0.0, "quiet_from": "22:00", "quiet_to": "07:00",
|
"open_pct": 100.0, "shade_pct": 30.0, "closed_pct": 0.0, "quiet_from": "22:00", "quiet_to": "07:00",
|
||||||
"night_moves": 0.0, "min_move_s": 1800.0, "override_hold_s": 14400.0},
|
"night_moves": 0.0, "min_move_s": 1800.0, "override_hold_s": 14400.0},
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
def ev_volts(params: dict, purpose: str) -> float:
|
||||||
|
"""A charger's volts x phases (W per A) for a purpose: "plan" (the
|
||||||
|
plan's power per A) or "order" (the grid order's current bound,
|
||||||
|
gridorder.limits). params["phases"]: the count from the best evidence
|
||||||
|
(evphases.py: mapping, device, learned); without it each purpose takes
|
||||||
|
its own safe side (evphases.ASSUMED: the order 3, the plan 1)."""
|
||||||
|
|
||||||
|
v = float(params.get("voltage") or PARAMS["ev"]["voltage"])
|
||||||
|
return v * float(params.get("phases") or ASSUMED[purpose])
|
||||||
|
|
||||||
|
|
||||||
HHMM_RE = re.compile(r"^([01][0-9]|2[0-3]):[0-5][0-9]$")
|
HHMM_RE = re.compile(r"^([01][0-9]|2[0-3]):[0-5][0-9]$")
|
||||||
# each kind's device range per quantity (firmware's; limits.effective)
|
# each kind's device range per quantity (firmware's; limits.effective)
|
||||||
RANGE = {
|
RANGE = {
|
||||||
@@ -254,16 +273,22 @@ class Inputs:
|
|||||||
load_power: str | list = "" # sensor W: the house's load (history fallback)
|
load_power: str | list = "" # sensor W: the house's load (history fallback)
|
||||||
pv_power: str | list = "" # sensor W: PV (history fallback); a list: their sum
|
pv_power: str | list = "" # sensor W: PV (history fallback); a list: their sum
|
||||||
humidity: list[str] = field(default_factory=list)
|
humidity: list[str] = field(default_factory=list)
|
||||||
|
# sensors W of the planned devices' own draw inside load_power (heat pump,
|
||||||
|
# A/C, charger): taken off it, so the plan's base load is the house
|
||||||
|
# without the devices it plans itself (inputs.base_load). None: from the
|
||||||
|
# mapping's assets (mapping.controlled_power); an empty list: load_power
|
||||||
|
# has none of them in it.
|
||||||
|
controlled_power: list[str] | None = None
|
||||||
|
|
||||||
def entities(self) -> list[str]:
|
def entities(self) -> list[str]:
|
||||||
one = [self.outside_temp, self.weather, self.sun]
|
one = [self.outside_temp, self.weather, self.sun]
|
||||||
summed = [e for x in (self.load_power, self.pv_power) for e in ([x] if isinstance(x, str) else x)]
|
summed = [e for x in (self.load_power, self.pv_power) for e in ([x] if isinstance(x, str) else x)]
|
||||||
return [e for e in self.presence + self.humidity + one + summed if e]
|
return [e for e in self.presence + self.humidity + one + summed + list(self.controlled_power or []) if e]
|
||||||
|
|
||||||
|
|
||||||
def parse_inputs(raw: dict | None) -> Inputs:
|
def parse_inputs(raw: dict | None) -> Inputs:
|
||||||
raw = dict(raw or {})
|
raw = dict(raw or {})
|
||||||
for k in ("presence", "humidity"):
|
for k in ("presence", "humidity", "controlled_power"):
|
||||||
if isinstance(raw.get(k), str):
|
if isinstance(raw.get(k), str):
|
||||||
raw[k] = [raw[k]]
|
raw[k] = [raw[k]]
|
||||||
unknown = set(raw) - set(Inputs.__dataclass_fields__)
|
unknown = set(raw) - set(Inputs.__dataclass_fields__)
|
||||||
|
|||||||
@@ -32,7 +32,10 @@
|
|||||||
and dearest hour of the next 24; the coming actions by
|
and dearest hour of the next 24; the coming actions by
|
||||||
the controls' names or "nothing planned", the prices of 48 h
|
the controls' names or "nothing planned", the prices of 48 h
|
||||||
as a table, what Cantabile sets in words: only in auto, the
|
as a table, what Cantabile sets in words: only in auto, the
|
||||||
commands received: only when there are any); the building
|
commands received: only when there are any); the market
|
||||||
|
(shadow; only when the site has contracts: positions, the
|
||||||
|
price, a card per contract in plain words, the border
|
||||||
|
actuators' contract target against their state); the building
|
||||||
the home is in or asked to join
|
the home is in or asked to join
|
||||||
energy power and price over time, energy per day and month (if mapped)
|
energy power and price over time, energy per day and month (if mapped)
|
||||||
climate rooms, thermostats, heat pump (if mapped)
|
climate rooms, thermostats, heat pump (if mapped)
|
||||||
@@ -81,8 +84,9 @@ class Home:
|
|||||||
def __init__(self, mapping, uid: str, ours: dict[str, str], flats: list[dict], lang: str,
|
def __init__(self, mapping, uid: str, ours: dict[str, str], flats: list[dict], lang: str,
|
||||||
mode: str = "shadow", reg: dict | None = None, states: list[dict] | None = None,
|
mode: str = "shadow", reg: dict | None = None, states: list[dict] | None = None,
|
||||||
links: dict[str, str] | None = None, joining: dict | None = None,
|
links: dict[str, str] | None = None, joining: dict | None = None,
|
||||||
profiles: list[dict] | None = None):
|
profiles: list[dict] | None = None, market: dict | None = None):
|
||||||
self.m, self.uid, self.ours, self.flats, self.lang = mapping, uid, ours, flats, lang
|
self.m, self.uid, self.ours, self.flats, self.lang = mapping, uid, ours, flats, lang
|
||||||
|
self.market = market # the shadow market's bundle (bundles.market_now), or None
|
||||||
self.mode, self.links, self.joining, self.profiles = mode, links or {}, joining, profiles or []
|
self.mode, self.links, self.joining, self.profiles = mode, links or {}, joining, profiles or []
|
||||||
self._views: dict[str, devview.DeviceView] = {}
|
self._views: dict[str, devview.DeviceView] = {}
|
||||||
self.assets = {a.asset: a for a in mapping.assets}
|
self.assets = {a.asset: a for a in mapping.assets}
|
||||||
@@ -146,6 +150,17 @@ class Home:
|
|||||||
return [a.entity for a in self.m.assets
|
return [a.entity for a in self.m.assets
|
||||||
if a.kind == "counter" and a.asset.startswith(prefix) and self.alive(a.entity)]
|
if a.kind == "counter" and a.asset.startswith(prefix) and self.alive(a.entity)]
|
||||||
|
|
||||||
|
def thermal(self) -> set[str]:
|
||||||
|
"""The entities of heat (heat.power, heat.energy and their parts):
|
||||||
|
thermal, never shown or summed as electricity."""
|
||||||
|
return {a.entity for a in self.m.assets
|
||||||
|
if a.asset.split(".")[0] == "heat" and a.asset.rsplit(".", 1)[-1] in ("power", "energy")}
|
||||||
|
|
||||||
|
def heat_label(self) -> str:
|
||||||
|
"""Heat delivered by a heat pump of this site, else heat from the
|
||||||
|
building (a heat meter: district heat, the building's heat pump)."""
|
||||||
|
return self.n("heat_delivered" if self.each("heatpump.power") else "heat_building")
|
||||||
|
|
||||||
def our(self, suffix: str) -> str | None:
|
def our(self, suffix: str) -> str | None:
|
||||||
return self.ours.get(f"{self.uid}_{suffix}")
|
return self.ours.get(f"{self.uid}_{suffix}")
|
||||||
|
|
||||||
@@ -300,6 +315,48 @@ def energy_now(h: "Home") -> list[dict]:
|
|||||||
return now
|
return now
|
||||||
|
|
||||||
|
|
||||||
|
def _kilo(e: str, unit: str, dec: str) -> str:
|
||||||
|
"""A jinja expression of a heat sensor in kW or kWh (from W/Wh too)."""
|
||||||
|
return ("{% set u = state_attr('" + e + "', 'unit_of_measurement') %}{% set v = states('" + e + "') | float(none) %}"
|
||||||
|
"{% if v is none %}–{% else %}{{ ('%.1f' | format(v / 1000 if u in ['W', 'Wh'] else v))"
|
||||||
|
" | replace('.', '" + dec + "') }} " + unit + "{% endif %}")
|
||||||
|
|
||||||
|
|
||||||
|
def _thermal(h: "Home", e: str, label: str, cols=6, value: bool = False) -> dict:
|
||||||
|
"""A heat value (thermal) as its label and kW or kWh: never a tile that
|
||||||
|
could pass for electricity. value: one of a device's values."""
|
||||||
|
a = next((a for a in h.m.assets if a.entity == e), None)
|
||||||
|
unit = "kWh" if a is not None and a.kind == "counter" else "kW"
|
||||||
|
dec = "," if h.lang.split("-")[0] in DECIMAL_COMMA else "."
|
||||||
|
c = {"type": "markdown", "text_only": True, "grid_options": {"columns": cols}, "entity_id": e,
|
||||||
|
"content": f"<ha-icon icon=\"mdi:radiator\"></ha-icon> {label} \n**{_kilo(e, unit, dec)}**"}
|
||||||
|
return dict(c, _value=True) if value else c
|
||||||
|
|
||||||
|
|
||||||
|
def heat_band(h: "Home") -> list[dict]:
|
||||||
|
"""Heat now and today, thermal, in a band of its own below the
|
||||||
|
electricity: from the building (district heat, a heat meter) or
|
||||||
|
delivered by the site's heat pump, then with its electric power and the
|
||||||
|
COP (heat ÷ electricity). Never summed with electric power."""
|
||||||
|
heat, hp = h.each("heat.power"), h.each("heatpump.power")
|
||||||
|
if not heat and not h.each("heat.energy"):
|
||||||
|
return []
|
||||||
|
label = h.heat_label()
|
||||||
|
out = [_thermal(h, e, f"{label} {n}".strip()) for n, e in heat]
|
||||||
|
out += [_today(e, f"{h.n('heat_today')} {n}".strip(), "mdi:radiator") for n, e in h.each("heat.energy")]
|
||||||
|
if hp:
|
||||||
|
out += [_tile(e, f"{h.n('heat_pump_electric')} {n}".strip(), "mdi:heat-pump", "deep-purple")
|
||||||
|
for n, e in hp]
|
||||||
|
if len(heat) == 1 and len(hp) == 1:
|
||||||
|
q, w = heat[0][1], hp[0][1]
|
||||||
|
dec = "," if h.lang.split("-")[0] in DECIMAL_COMMA else "."
|
||||||
|
out.append(_md("{% set q = states('" + q + "') | float(none) %}{% set w = states('" + w + "') | float(none) %}"
|
||||||
|
+ h.n("cop") + " \n**{% if q is not none and w %}{{ ('%.1f' | format(q / w)) | replace('.', '"
|
||||||
|
+ dec + "') }}{% else %}–{% endif %}**", 6, text_only=True))
|
||||||
|
out.append(_md("<small>ⓘ " + h.n("heat_not_electric") + "</small>", text_only=True))
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
def _label(h: "Home", c) -> str:
|
def _label(h: "Home", c) -> str:
|
||||||
"""A control as people call it: the mapping's name, else the name HA
|
"""A control as people call it: the mapping's name, else the name HA
|
||||||
shows for its device's main entity, else its id in words."""
|
shows for its device's main entity, else its id in words."""
|
||||||
@@ -408,6 +465,46 @@ def plan_cards(h: "Home") -> list[dict]:
|
|||||||
return out[:1 if price else 0] + _fill(out[1 if price else 0:])
|
return out[:1 if price else 0] + _fill(out[1 if price else 0:])
|
||||||
|
|
||||||
|
|
||||||
|
def market_band(h: "Home") -> dict | None:
|
||||||
|
"""The shadow market, only when the site has contracts (a `market`
|
||||||
|
bundle): the net position(s) and the shared energy's price (quarters),
|
||||||
|
per contract a card in plain words (halves: "Sells to Home B: 1.2 kWh
|
||||||
|
last quarter-hour (contract 1.5) · 16.4 ct/kWh · shadow", the period
|
||||||
|
below), the border actuators' contract target against their state now,
|
||||||
|
and what shadow means. HA's core cards only."""
|
||||||
|
m = h.market
|
||||||
|
if not m or not m.get("contracts"):
|
||||||
|
return None
|
||||||
|
top = []
|
||||||
|
for p in m.get("positions") or []:
|
||||||
|
kind = str(p.get("node", "")).split(":")[0]
|
||||||
|
top.append(_tile(h.our("market_position" if kind == "site" else f"market_position_{_slug(kind)}"),
|
||||||
|
icon="mdi:scale-balance", cols=6))
|
||||||
|
top.append(_tile(h.our("market_price"), h.n("market_price"), "mdi:cash-multiple", cols=6))
|
||||||
|
stale = "<small>" + h.n("mk_stale") + "</small>"
|
||||||
|
deals = []
|
||||||
|
for c in m.get("contracts") or []:
|
||||||
|
e = h.our(f"market_{_slug(c['id'])}")
|
||||||
|
if not e:
|
||||||
|
continue
|
||||||
|
deals.append(_md(
|
||||||
|
"{% set e = '" + e + "' %}{% if states(e) == 'unavailable' or not state_attr(e, 'summary') %}" + stale
|
||||||
|
+ "{% else %}**{{ state_attr(e, 'summary') }}**{% set d = state_attr(e, 'details') %}"
|
||||||
|
"{% if d %} \n<small>{{ d }}</small>{% endif %} \n<small>{{ state_attr(e, 'period_words') }}</small>{% endif %}",
|
||||||
|
12))
|
||||||
|
rows = []
|
||||||
|
for a in m.get("actuators") or []:
|
||||||
|
e = h.our(f"market_actuator_{_slug(a['device'])}")
|
||||||
|
if e:
|
||||||
|
rows.append("**" + (a.get("name") or a["device"]).replace("*", "") + "**: {% set e = '" + e + "' %}"
|
||||||
|
"{% if states(e) == 'unavailable' %}" + stale + "{% else %}{{ state_attr(e, 'words') }}{% endif %}")
|
||||||
|
acts = _md(" \n".join(rows)) if rows else None
|
||||||
|
if not deals and not acts:
|
||||||
|
return None
|
||||||
|
note = _md("<small>ⓘ " + h.n("mk_shadow_note") + "</small>")
|
||||||
|
return _band(*_fill([c for c in top if c]), *_fill(deals), acts, note, heading=h.n("card_market"), icon="mdi:handshake-outline")
|
||||||
|
|
||||||
|
|
||||||
# -- the views ----------------------------------------------------------------------
|
# -- the views ----------------------------------------------------------------------
|
||||||
|
|
||||||
def view_overview(h: Home) -> dict | None:
|
def view_overview(h: Home) -> dict | None:
|
||||||
@@ -444,10 +541,11 @@ def view_overview(h: Home) -> dict | None:
|
|||||||
|
|
||||||
return _view(h.n("dash_main"), "overview", "mdi:leaf",
|
return _view(h.n("dash_main"), "overview", "mdi:leaf",
|
||||||
_band(*status), _band(*now),
|
_band(*status), _band(*now),
|
||||||
|
_band(*_fill(heat_band(h)), heading=h.n("heat"), icon="mdi:radiator"),
|
||||||
devices_heading(h, bool(devices)), *devices,
|
devices_heading(h, bool(devices)), *devices,
|
||||||
_band(*today, heading=h.n("today"), icon="mdi:calendar-today"),
|
_band(*today, heading=h.n("today"), icon="mdi:calendar-today"),
|
||||||
_band(*plan_cards(h), heading=h.n("card_plan"), icon="mdi:chart-timeline-variant"),
|
_band(*plan_cards(h), heading=h.n("card_plan"), icon="mdi:chart-timeline-variant"),
|
||||||
building_section(h), columns=WIDE)
|
market_band(h), building_section(h), columns=WIDE)
|
||||||
|
|
||||||
|
|
||||||
def view_energy(h: Home) -> dict | None:
|
def view_energy(h: Home) -> dict | None:
|
||||||
@@ -475,9 +573,13 @@ def view_climate(h: Home) -> dict | None:
|
|||||||
for e in dict.fromkeys(c.entities["climate"] for c in rooms if "climate" in c.entities)],
|
for e in dict.fromkeys(c.entities["climate"] for c in rooms if "climate" in c.entities)],
|
||||||
_history(h.n("card_rooms"), list(dict.fromkeys(e for e in temps if e))
|
_history(h.n("card_rooms"), list(dict.fromkeys(e for e in temps if e))
|
||||||
+ [h.our(f"set_{c.id}") for c in rooms] + [h.asset("outside.temp")])),
|
+ [h.our(f"set_{c.id}") for c in rooms] + [h.asset("outside.temp")])),
|
||||||
|
# electric and thermal apart, never in one graph
|
||||||
_section(_heading(h.n("heat_pump"), "mdi:heat-pump"),
|
_section(_heading(h.n("heat_pump"), "mdi:heat-pump"),
|
||||||
_history(h.n("card_power"), h.all("heatpump.power", "heat.power")),
|
_history(h.n("electric_power"), h.all("heatpump.power")),
|
||||||
_stats(h.n("card_daily"), h.all("heatpump.energy", "heat.energy"))))
|
_stats(h.n("card_daily"), h.all("heatpump.energy"))),
|
||||||
|
_section(_heading(h.n("heat"), "mdi:radiator"),
|
||||||
|
_history(h.heat_label(), h.all("heat.power")),
|
||||||
|
_stats(h.n("heat_today"), h.all("heat.energy"))))
|
||||||
|
|
||||||
|
|
||||||
def _short(name: str, device: str) -> str:
|
def _short(name: str, device: str) -> str:
|
||||||
@@ -560,9 +662,15 @@ def device_cards(h: Home, d: dict, detail: bool = False) -> list[dict]:
|
|||||||
|
|
||||||
cards, used = [], set()
|
cards, used = [], set()
|
||||||
|
|
||||||
|
thermal = h.thermal()
|
||||||
|
|
||||||
def tile(eid, trend=None, cols=6):
|
def tile(eid, trend=None, cols=6):
|
||||||
if eid and eid not in used:
|
if eid and eid not in used:
|
||||||
used.add(eid)
|
used.add(eid)
|
||||||
|
if eid in thermal: # heat: thermal, never like electricity
|
||||||
|
label = h.heat_label() if eid in h.all("heat.power") else h.n("heat_today")
|
||||||
|
cards.append(_thermal(h, eid, label, cols))
|
||||||
|
return
|
||||||
cards.append(_tile(eid, nm(eid), trend=power(eid) if trend is None else trend, cols=cols))
|
cards.append(_tile(eid, nm(eid), trend=power(eid) if trend is None else trend, cols=cols))
|
||||||
soc = dv.flow.get("soc") or next((e for e in dv.headline if st(e).get("device_class") == "battery"), None)
|
soc = dv.flow.get("soc") or next((e for e in dv.headline if st(e).get("device_class") == "battery"), None)
|
||||||
if dv.card in ("flow", "gauge") and soc:
|
if dv.card in ("flow", "gauge") and soc:
|
||||||
@@ -592,7 +700,7 @@ def device_cards(h: Home, d: dict, detail: bool = False) -> list[dict]:
|
|||||||
for e in dv.headline:
|
for e in dv.headline:
|
||||||
tile(e, None if dv.card in ("flow", "meter", "charger") or detail else False)
|
tile(e, None if dv.card in ("flow", "meter", "charger") or detail else False)
|
||||||
if dv.channels:
|
if dv.channels:
|
||||||
power_ch = [c for c in dv.channels if c.get("power")]
|
power_ch = [c for c in dv.channels if c.get("power") and c["power"] not in thermal] # never heat
|
||||||
if power_ch:
|
if power_ch:
|
||||||
cards.append(_sum(h.n("total"), [c["power"] for c in power_ch]))
|
cards.append(_sum(h.n("total"), [c["power"] for c in power_ch]))
|
||||||
cards.append({"type": "distribution", "grid_options": {"columns": "full"},
|
cards.append({"type": "distribution", "grid_options": {"columns": "full"},
|
||||||
@@ -735,10 +843,13 @@ def device_card(h: Home, d: dict, skip: set[str] = frozenset()) -> dict | None:
|
|||||||
picked.append(e)
|
picked.append(e)
|
||||||
picked = picked[:HEADLINE]
|
picked = picked[:HEADLINE]
|
||||||
used |= set(picked)
|
used |= set(picked)
|
||||||
cards += [{"type": "tile", "entity": e, "name": nm(e), "_value": True,
|
thermal = h.thermal()
|
||||||
|
cards += [_thermal(h, e, h.heat_label() if e in h.all("heat.power") else h.n("heat_today"), value=True)
|
||||||
|
if e in thermal else
|
||||||
|
{"type": "tile", "entity": e, "name": nm(e), "_value": True,
|
||||||
**({"icon_tap_action": {"action": "more-info"}}
|
**({"icon_tap_action": {"action": "more-info"}}
|
||||||
if e.split(".")[0] in ("switch", "light", "fan", "input_boolean") else {})} for e in picked]
|
if e.split(".")[0] in ("switch", "light", "fan", "input_boolean") else {})} for e in picked]
|
||||||
power_ch = [c for c in dv.channels if c.get("power") and c["power"] not in skip]
|
power_ch = [c for c in dv.channels if c.get("power") and c["power"] not in skip and c["power"] not in thermal]
|
||||||
if power_ch:
|
if power_ch:
|
||||||
cards.append({"type": "markdown", "text_only": True, "content":
|
cards.append({"type": "markdown", "text_only": True, "content":
|
||||||
"{% set e = " + json.dumps([c["power"] for c in power_ch]) + " %}" + h.n("total")
|
"{% set e = " + json.dumps([c["power"] for c in power_ch]) + " %}" + h.n("total")
|
||||||
@@ -798,18 +909,22 @@ def device_subview(h: Home, d: dict) -> dict | None:
|
|||||||
value it has (not diagnostic), and its power over the last day."""
|
value it has (not diagnostic), and its power over the last day."""
|
||||||
dv = h.view(d)
|
dv = h.view(d)
|
||||||
cards = device_cards(h, d, detail=True)
|
cards = device_cards(h, d, detail=True)
|
||||||
shown = {x if isinstance(x, str) else x.get("entity") for c in cards for x in [c, *(c.get("entities") or [])]}
|
shown = {x if isinstance(x, str) else x.get("entity") or x.get("entity_id")
|
||||||
|
for c in cards for x in [c, *(c.get("entities") or [])]}
|
||||||
shown |= set(dv.switches)
|
shown |= set(dv.switches)
|
||||||
|
thermal = h.thermal()
|
||||||
rest = [e["entity_id"] for e in h.ents_of(d) if not e.get("entity_category") and e["entity_id"] not in shown
|
rest = [e["entity_id"] for e in h.ents_of(d) if not e.get("entity_category") and e["entity_id"] not in shown
|
||||||
and e["entity_id"].split(".")[0] in VALUES and h.alive(e["entity_id"])]
|
and e["entity_id"].split(".")[0] in VALUES and h.alive(e["entity_id"])]
|
||||||
powers = [e for e in dv.entities() | set(rest) if (((h.states or {}).get(e) or {}).get("attributes") or {})
|
powers = [e for e in dv.entities() | set(rest) if (((h.states or {}).get(e) or {}).get("attributes") or {})
|
||||||
.get("device_class") == "power"]
|
.get("device_class") == "power" and e not in thermal]
|
||||||
|
heat = sorted(e for e in dv.entities() | set(rest) | shown if e in thermal and e in h.all("heat.power"))
|
||||||
return {"type": "sections", "title": _name(d), "path": _subpath(d), "subview": True,
|
return {"type": "sections", "title": _name(d), "path": _subpath(d), "subview": True,
|
||||||
"back_path": f"/{URL}/overview", "max_columns": 3, "sections": [x for x in (
|
"back_path": f"/{URL}/overview", "max_columns": 3, "sections": [x for x in (
|
||||||
_section(_heading(_name(d), "mdi:information-outline"), *cards),
|
_section(_heading(_name(d), "mdi:information-outline"), *cards),
|
||||||
_section(_heading(h.n("values"), "mdi:format-list-bulleted"),
|
_section(_heading(h.n("values"), "mdi:format-list-bulleted"),
|
||||||
{"type": "entities", "entities": rest, "grid_options": {"columns": "full"}} if rest else None),
|
{"type": "entities", "entities": rest, "grid_options": {"columns": "full"}} if rest else None),
|
||||||
_section(_heading(h.n("card_power"), "mdi:flash"), _history(h.n("card_power"), sorted(powers))))
|
_section(_heading(h.n("card_power"), "mdi:flash"), _history(h.n("card_power"), sorted(powers))),
|
||||||
|
_section(_heading(h.n("heat"), "mdi:radiator"), _history(h.heat_label(), heat)))
|
||||||
if x]}
|
if x]}
|
||||||
|
|
||||||
|
|
||||||
@@ -858,15 +973,19 @@ def dashboard(h: Home) -> dict | None:
|
|||||||
|
|
||||||
def energy_prefs(h: Home) -> dict | None:
|
def energy_prefs(h: Home) -> dict | None:
|
||||||
"""HA's Energy preferences from the mapping, or None (nothing to show).
|
"""HA's Energy preferences from the mapping, or None (nothing to show).
|
||||||
Parts (two inverters, two batteries) are each a source of their own."""
|
Parts (two inverters, two batteries) are each a source of their own.
|
||||||
|
The grid in HA's current form (energy storage 1.3, in HA 2026.10): a
|
||||||
|
source per grid connection with its import and export meter side by
|
||||||
|
side (parts paired in order); legacy_grid() gives the older form."""
|
||||||
src = []
|
src = []
|
||||||
imp, exp = h.all("grid.import_energy"), h.all("grid.export_energy")
|
imp, exp = h.all("grid.import_energy"), h.all("grid.export_energy")
|
||||||
if imp or exp:
|
for i in range(max(len(imp), len(exp))):
|
||||||
|
e_in, e_out = (imp[i] if i < len(imp) else None), (exp[i] if i < len(exp) else None)
|
||||||
src.append({"type": "grid", "cost_adjustment_day": 0,
|
src.append({"type": "grid", "cost_adjustment_day": 0,
|
||||||
"flow_from": [{"stat_energy_from": e, "stat_cost": None, "number_energy_price": None,
|
"stat_energy_from": e_in, "stat_cost": None, "number_energy_price": None,
|
||||||
"entity_energy_price": h.our("price_import_now")} for e in imp],
|
"entity_energy_price": h.our("price_import_now") if e_in else None,
|
||||||
"flow_to": [{"stat_energy_to": e, "stat_compensation": None, "number_energy_price": None,
|
"stat_energy_to": e_out, "stat_compensation": None, "number_energy_price_export": None,
|
||||||
"entity_energy_price": h.our("price_export_now")} for e in exp]})
|
"entity_energy_price_export": h.our("price_export_now") if e_out else None})
|
||||||
for e in h.all("pv.energy"):
|
for e in h.all("pv.energy"):
|
||||||
src.append({"type": "solar", "stat_energy_from": e, "config_entry_solar_forecast": None})
|
src.append({"type": "solar", "stat_energy_from": e, "config_entry_solar_forecast": None})
|
||||||
ins, outs = dict(h.each("battery.charge_energy")), dict(h.each("battery.discharge_energy"))
|
ins, outs = dict(h.each("battery.charge_energy")), dict(h.each("battery.discharge_energy"))
|
||||||
@@ -883,6 +1002,23 @@ def energy_prefs(h: Home) -> dict | None:
|
|||||||
return {"energy_sources": src, "device_consumption": devices}
|
return {"energy_sources": src, "device_consumption": devices}
|
||||||
|
|
||||||
|
|
||||||
|
def legacy_grid(prefs: dict) -> dict:
|
||||||
|
"""The preferences in HA's older grid form (energy storage before 1.3):
|
||||||
|
one grid source, its import and export meters in flow_from / flow_to.
|
||||||
|
The same dict when there is no grid."""
|
||||||
|
grids = [s for s in prefs["energy_sources"] if s["type"] == "grid"]
|
||||||
|
if not grids:
|
||||||
|
return prefs
|
||||||
|
one = {"type": "grid", "cost_adjustment_day": 0,
|
||||||
|
"flow_from": [{"stat_energy_from": g["stat_energy_from"], "stat_cost": None, "number_energy_price": None,
|
||||||
|
"entity_energy_price": g["entity_energy_price"]}
|
||||||
|
for g in grids if g["stat_energy_from"]],
|
||||||
|
"flow_to": [{"stat_energy_to": g["stat_energy_to"], "stat_compensation": None, "number_energy_price": None,
|
||||||
|
"entity_energy_price": g["entity_energy_price_export"]}
|
||||||
|
for g in grids if g["stat_energy_to"]]}
|
||||||
|
return dict(prefs, energy_sources=[one] + [s for s in prefs["energy_sources"] if s["type"] != "grid"])
|
||||||
|
|
||||||
|
|
||||||
class Dashboards:
|
class Dashboards:
|
||||||
def __init__(self, agent):
|
def __init__(self, agent):
|
||||||
self.agent = agent
|
self.agent = agent
|
||||||
@@ -918,9 +1054,10 @@ class Dashboards:
|
|||||||
links: dict[str, str] | None = None) -> Home:
|
links: dict[str, str] | None = None) -> Home:
|
||||||
ctl = getattr(self.agent, "control", None)
|
ctl = getattr(self.agent, "control", None)
|
||||||
flats = ctl.bundles.flat_list() if ctl is not None else []
|
flats = ctl.bundles.flat_list() if ctl is not None else []
|
||||||
|
market = ctl.bundles.market_now(time.time()) if ctl is not None else None
|
||||||
return Home(self.agent.mapping, f"cantabile_{self.agent.cfg.site_id}", ours, flats,
|
return Home(self.agent.mapping, f"cantabile_{self.agent.cfg.site_id}", ours, flats,
|
||||||
getattr(self.agent, "ha_language", "en"), self.mode(), reg, states, links,
|
getattr(self.agent, "ha_language", "en"), self.mode(), reg, states, links,
|
||||||
self.joining() if self.agent.cfg.join_page_port else None, self.profiles)
|
self.joining() if self.agent.cfg.join_page_port else None, self.profiles, market)
|
||||||
|
|
||||||
@staticmethod
|
@staticmethod
|
||||||
async def links(client, devices: list[dict]) -> dict[str, str]:
|
async def links(client, devices: list[dict]) -> dict[str, str]:
|
||||||
@@ -985,8 +1122,20 @@ class Dashboards:
|
|||||||
if prefs and (prefs.get("energy_sources") or prefs.get("device_consumption")):
|
if prefs and (prefs.get("energy_sources") or prefs.get("device_consumption")):
|
||||||
return # the owner's: never overwritten
|
return # the owner's: never overwritten
|
||||||
want = energy_prefs(h)
|
want = energy_prefs(h)
|
||||||
if want is not None:
|
if want is None:
|
||||||
|
return
|
||||||
|
try:
|
||||||
await client.dashboard("energy/save_prefs", **want)
|
await client.dashboard("energy/save_prefs", **want)
|
||||||
|
except HAError as e:
|
||||||
|
# an HA from before the unified grid (energy storage 1.3) takes
|
||||||
|
# only flow_from / flow_to: the same preferences in that form
|
||||||
|
old = legacy_grid(want)
|
||||||
|
if old is want or "invalid_format" not in str(e):
|
||||||
|
raise
|
||||||
|
await client.dashboard("energy/save_prefs", **old)
|
||||||
|
log.info("HA's Energy dashboard set up from the mapping (HA %s: the older grid form)",
|
||||||
|
getattr(client, "version", None))
|
||||||
|
return
|
||||||
log.info("HA's Energy dashboard set up from the mapping")
|
log.info("HA's Energy dashboard set up from the mapping")
|
||||||
|
|
||||||
async def run(self, stop: asyncio.Event):
|
async def run(self, stop: asyncio.Event):
|
||||||
|
|||||||
+327
-122
@@ -66,16 +66,67 @@ SWITCHOVER_WORDS = {"heating": M("Heating"), "cooling": M("Cooling"),
|
|||||||
"outdoor": M("By outdoor temperature")}
|
"outdoor": M("By outdoor temperature")}
|
||||||
CUSTODIAN_WORDS = {"building_operator": M("the building's operator"), "grid_operator": M("the grid operator"),
|
CUSTODIAN_WORDS = {"building_operator": M("the building's operator"), "grid_operator": M("the grid operator"),
|
||||||
"metering_operator": M("the metering operator"), "community_operator": M("the energy community's operator")}
|
"metering_operator": M("the metering operator"), "community_operator": M("the energy community's operator")}
|
||||||
PROFILE_STATUS = {"verified": M("Checked on a device"),
|
PROFILE_STATUS = {"verified": (M("checked"), "ok", M("Checked on a device: its values are known to be right.")),
|
||||||
"documented": M("From the maker's documentation, not yet checked on a device"),
|
"documented": (M("untested"), "quiet", M("Made from the maker's documentation, not yet checked on a "
|
||||||
"draft": M("Draft: check the values before you turn reading on")}
|
"device. Look at its values before you turn reading on.")),
|
||||||
|
"draft": (M("draft"), "warn", M("A draft profile: check the values before you turn reading on."))}
|
||||||
CONTROL_WORDS = {"battery": M("battery"), "heating": M("heating"), "cooling": M("cooling"), "ev": M("charging"),
|
CONTROL_WORDS = {"battery": M("battery"), "heating": M("heating"), "cooling": M("cooling"), "ev": M("charging"),
|
||||||
"cover": M("blinds and curtains")}
|
"cover": M("blinds and curtains")}
|
||||||
|
# What a device reads, by meaning (the devices tool gives the keys:
|
||||||
|
# devprofiles.reads); never the asset ids.
|
||||||
|
QUANTITY_WORDS = {
|
||||||
|
"room.temp": M("room temperature"), "room.humidity": M("humidity"), "room.setpoint": M("setpoint"),
|
||||||
|
"room.setpoint_range": M("heat/cool range"), "heating_cooling.state": M("heating/cooling state"),
|
||||||
|
"heating.state": M("heating state"), "cooling.state": M("cooling state"),
|
||||||
|
"room.setpoint_low": M("heat/cool range"), "room.setpoint_high": M("heat/cool range"),
|
||||||
|
"room.shade_position": M("position"), "room.shade_tilt": M("tilt"),
|
||||||
|
"pv.power": M("solar power"), "pv.energy": M("solar energy"), "grid.power": M("grid power"),
|
||||||
|
"grid.import_power": M("power from the grid"), "grid.export_power": M("power to the grid"),
|
||||||
|
"grid.import_energy": M("energy from the grid"), "grid.export_energy": M("energy to the grid"),
|
||||||
|
"battery.power": M("battery power"), "battery.soc": M("battery charge"),
|
||||||
|
"battery.charge_energy": M("energy charged"), "battery.discharge_energy": M("energy discharged"),
|
||||||
|
"load.power": M("home consumption"), "load.energy": M("home energy"),
|
||||||
|
"heatpump.power": M("heat pump power"), "heatpump.energy": M("heat pump energy"),
|
||||||
|
"heat.power": M("heat delivered (thermal)"), "heat.energy": M("heat energy (thermal)"), "heatpump.flow_temp": M("flow temperature"),
|
||||||
|
"heatpump.dhw_temp": M("hot water temperature"), "outside.temp": M("outdoor temperature"),
|
||||||
|
"outside.humidity": M("outdoor humidity"), "gas.energy": M("gas"), "ev.power": M("charging power"),
|
||||||
|
"ev.energy": M("energy charged"), "circuit.power": M("power"), "circuit.energy": M("energy")}
|
||||||
|
# A device's main values now (devprofiles.live) on the list.
|
||||||
|
LIVE_WORDS = {"room.setpoint": M("set to {v}"), "room.setpoint_range": M("set to {low}–{high}"),
|
||||||
|
"pv.power": M("solar {v}"), "battery.soc": M("battery {v}"), "battery.power": M("battery {v}"),
|
||||||
|
"grid.power": M("grid {v}"), "load.power": M("home {v}"), "ev.power": M("charging {v}"),
|
||||||
|
"heatpump.power": M("heat pump {v}"), "heat.power": M("heat {v} (thermal)"), "heatpump.flow_temp": M("flow {v}"),
|
||||||
|
"outside.temp": M("outside {v}"), "room.humidity": M("humidity {v}"), "room.shade_position": M("{v} open")}
|
||||||
|
HVAC_WORDS = {"heating": M("heating"), "cooling": M("cooling"), "idle": M("idle")}
|
||||||
|
LIVE_UNITS = {"room.temp": "°C", "room.setpoint": "°C", "room.setpoint_range": "°C", "heatpump.flow_temp": "°C",
|
||||||
|
"outside.temp": "°C", "battery.soc": "%", "room.humidity": "%", "room.shade_position": "%"}
|
||||||
MORE_CSS = """nav{display:flex;gap:1rem;margin:0 0 1rem;border-bottom:1px solid #d5ded9;padding-bottom:.5rem}
|
MORE_CSS = """nav{display:flex;gap:1rem;margin:0 0 1rem;border-bottom:1px solid #d5ded9;padding-bottom:.5rem}
|
||||||
nav a{color:inherit;text-decoration:none}nav a.on{font-weight:600;border-bottom:2px solid #2f6f55}
|
nav a{color:inherit;text-decoration:none}nav a.on{font-weight:600;border-bottom:2px solid #2f6f55}
|
||||||
.badge{display:inline-block;font-size:.8rem;padding:.05rem .45rem;border-radius:4px;background:#e2e9e5;margin-left:.3rem}
|
a{color:#2f6f55}.muted,.model{color:#5a6b62;font-size:.85rem}
|
||||||
ul.plain{margin:.3rem 0;padding-left:1.2rem}form.inline{display:inline}form.inline button{margin:0 0 0 .4rem;padding:.2rem .6rem}
|
.badge{display:inline-block;font-size:.75rem;padding:0 .45rem;border-radius:1rem;background:#e2e9e5;margin-left:.3rem;vertical-align:.1em}
|
||||||
@media (prefers-color-scheme:dark){nav{border-color:#2b3a32}.badge{background:#2b3a32}}"""
|
.badge.quiet{background:none;box-shadow:inset 0 0 0 1px #d5ded9;color:#5a6b62}.badge.warn{background:#fbe9c9;color:#7a4b00}
|
||||||
|
ul.plain{list-style:none;margin:.3rem 0;padding:0}input[type=radio]{width:auto}select{font:inherit;padding:.45rem .6rem;border-radius:6px;width:100%}
|
||||||
|
a.box.dev{display:flex;gap:.8rem;align-items:center;color:inherit;text-decoration:none}a.box.dev:hover{border-color:#2f6f55}
|
||||||
|
.grow{flex:1;min-width:0}.grow>span{display:block}.grow>span.name{display:inline;font-weight:600}.grow>span.badge{display:inline-block}
|
||||||
|
.chev{color:#5a6b62;font-size:1.4rem}.state{font-size:.9rem}.values{font-size:1.05rem;font-weight:600}.box.now>span{display:block}
|
||||||
|
.dot{display:inline-block;width:.55rem;height:.55rem;border-radius:50%;margin-right:.45rem;background:#9fb0a6}.dot.on{background:#2f9e6e}
|
||||||
|
.offer .top{display:flex;gap:.8rem;align-items:center}.offer .top form{margin:0}.offer .top button{margin:0;white-space:nowrap}.offer p.note{margin:.4rem 0 0;font-size:.9rem}
|
||||||
|
.add{margin-top:2rem;border-top:2px solid #d5ded9}a.back{text-decoration:none;font-size:.9rem}.model.head{margin:-.6rem 0 .6rem}
|
||||||
|
section.set{border-top:1px solid #d5ded9;margin-top:1rem}section.set h3{margin:.9rem 0 .4rem}section.set p{margin:.35rem 0}
|
||||||
|
.switch{display:flex;align-items:center;justify-content:space-between;gap:.8rem;padding:.3rem 0}.switch form{margin:0}.switch button{margin:0;white-space:nowrap}
|
||||||
|
.pill{display:inline-block;font-size:.75rem;padding:0 .5rem;border-radius:1rem;background:#e2e9e5;color:#5a6b62;font-weight:600}.pill.on{background:#e3f4ea;color:#1f5d3a}
|
||||||
|
.row{display:flex;gap:.6rem}.row>div{flex:1}.right{text-align:right}
|
||||||
|
details.remove summary{color:#b3261e;cursor:pointer;padding:.8rem 0 .2rem}button.danger{background:none;color:#b3261e;box-shadow:inset 0 0 0 2px #b3261e}
|
||||||
|
details.more summary{cursor:pointer;margin:.6rem 0}
|
||||||
|
details.info{display:inline;position:relative}details.info>summary{display:inline-flex;align-items:center;justify-content:center;width:1.2rem;height:1.2rem;margin:0 .35rem;vertical-align:.1em;list-style:none;border:1px solid #5a6b62;border-radius:50%;color:#5a6b62;font:italic 600 .72rem/1 Georgia,serif;cursor:pointer}
|
||||||
|
details.info>summary::-webkit-details-marker{display:none}details.info>.info-body{position:absolute;left:0;z-index:3;width:min(22rem,80vw);margin-top:.4rem;padding:.7rem .9rem;background:#fff;color:#1d2a24;border:1px solid #d5ded9;border-radius:8px;box-shadow:0 6px 24px rgba(0,0,0,.18);font-size:.9rem;font-weight:normal}
|
||||||
|
@supports selector(:has(a)){form.changes .save{display:none}form.changes:has(input:default:not(:checked),input:checked:not(:default),option:checked:not(:default),input[value=outdoor]:checked) .save{display:inline-block}
|
||||||
|
form.changes:not(:has(input[value=outdoor]:checked)) .outdoor{display:none}}
|
||||||
|
@media (prefers-color-scheme:dark){nav{border-color:#2b3a32}a{color:#5cc493}.badge,.pill{background:#2b3a32}.muted,.model,.chev{color:#9fb0a6}
|
||||||
|
.badge.quiet{background:none;box-shadow:inset 0 0 0 1px #2b3a32;color:#9fb0a6}.badge.warn{background:#3a2c12;color:#f3c77e}.pill.on{background:#19302a;color:#a6e0bf}
|
||||||
|
.dot.on{background:#5cc493}.add,section.set{border-color:#2b3a32}a.box.dev:hover{border-color:#5cc493}select{background:#18221d;color:#e3ebe6;border:1px solid #3a4b42}
|
||||||
|
details.remove summary{color:#f08a80}button.danger{background:none;color:#f08a80;box-shadow:inset 0 0 0 2px #f08a80}
|
||||||
|
details.info>.info-body{background:#18221d;color:#e3ebe6;border-color:#2b3a32}details.info>summary{border-color:#9fb0a6;color:#9fb0a6}}"""
|
||||||
# HA's hash (#devices, #building: Cantabile's dashboard) to this page's ?p=
|
# HA's hash (#devices, #building: Cantabile's dashboard) to this page's ?p=
|
||||||
HASH_SCRIPT = ("(function(){try{var P=window.parent;if(P===window)return;var m=/^#(devices|building)$/.exec(P.location.hash||'');"
|
HASH_SCRIPT = ("(function(){try{var P=window.parent;if(P===window)return;var m=/^#(devices|building)$/.exec(P.location.hash||'');"
|
||||||
"if(m&&location.search.indexOf('p=')<0&&location.search.indexOf('code=')<0)location.replace('?p='+m[1])}"
|
"if(m&&location.search.indexOf('p=')<0&&location.search.indexOf('code=')<0)location.replace('?p='+m[1])}"
|
||||||
@@ -101,10 +152,6 @@ def _write_json(path: str, data, mode: int = 0o644):
|
|||||||
os.replace(tmp, path)
|
os.replace(tmp, path)
|
||||||
|
|
||||||
|
|
||||||
def quantity_words(q: str) -> str:
|
|
||||||
return q.replace("_", " ").replace(".", ": ", 1)
|
|
||||||
|
|
||||||
|
|
||||||
def with_attrs(ents: list[dict], states: dict) -> list[dict]:
|
def with_attrs(ents: list[dict], states: dict) -> list[dict]:
|
||||||
"""Registry entries with HA's attributes now (where the state is known:
|
"""Registry entries with HA's attributes now (where the state is known:
|
||||||
the profiles' conditions on attributes, as the Hub's registry has them)."""
|
the profiles' conditions on attributes, as the Hub's registry has them)."""
|
||||||
@@ -235,19 +282,25 @@ class Devices:
|
|||||||
"""The page's data: the devices used here, HA's devices with a
|
"""The page's data: the devices used here, HA's devices with a
|
||||||
profile (and what each would give), the rest, or HA's error."""
|
profile (and what each would give), the rest, or HA's error."""
|
||||||
devs, policy = self.load(), self.policy()
|
devs, policy = self.load(), self.policy()
|
||||||
|
try:
|
||||||
|
reg, states = await self.snapshot()
|
||||||
|
ha_error = ""
|
||||||
|
except Exception as e:
|
||||||
|
reg, states, ha_error = {}, {}, str(e)
|
||||||
used = []
|
used = []
|
||||||
for d in sorted(devs.values(), key=lambda d: d.get("added", 0)):
|
for d in sorted(devs.values(), key=lambda d: d.get("added", 0)):
|
||||||
frag, p = self.frag(d["id"]), self.profile(d["profile"]) or {}
|
frag, p = self.frag(d["id"]), self.profile(d["profile"]) or {}
|
||||||
targets = dp.device_targets(d, frag, self.local())
|
targets = dp.device_targets(d, frag, self.local())
|
||||||
|
assets = frag.get("assets", [])
|
||||||
used.append(dict(d, manufacturer=p.get("manufacturer", ""), model=p.get("name", d["profile"]),
|
used.append(dict(d, manufacturer=p.get("manufacturer", ""), model=p.get("name", d["profile"]),
|
||||||
status=p.get("status", ""), assets=frag.get("assets", []), controls=frag.get("controls", []),
|
status=p.get("status", ""), generic=bool(p) and dp.fallback(p), assets=assets,
|
||||||
|
controls=frag.get("controls", []), reads=dp.reads(assets), live=dp.live(assets, states),
|
||||||
|
assumed=dp.reads([a for a in assets if a.get("assumed")]), lacks=dp.lacks(d.get("missing")),
|
||||||
switchover=dp.switchover_of(frag), shade=dp.shade_of(frag), place=dp.place_of(frag),
|
switchover=dp.switchover_of(frag), shade=dp.shade_of(frag), place=dp.place_of(frag),
|
||||||
weather=dp.weather_of(frag), policy={t: policy[t] for t in targets if t in policy},
|
weather=dp.weather_of(frag), policy={t: policy[t] for t in targets if t in policy},
|
||||||
protection=dp.level_of(policy, [f"device:{d['id']}"])[0]))
|
protection=dp.level_of(policy, [f"device:{d['id']}"])[0]))
|
||||||
try:
|
if ha_error:
|
||||||
reg, states = await self.snapshot()
|
return {"devices": used, "offers": [], "rest": [], "ha_error": ha_error, "site": self.site(), "rooms": []}
|
||||||
except Exception as e:
|
|
||||||
return {"devices": used, "offers": [], "rest": [], "ha_error": str(e), "site": self.site(), "rooms": []}
|
|
||||||
main = self.main()
|
main = self.main()
|
||||||
src = main.get("source")
|
src = main.get("source")
|
||||||
mapped = {}
|
mapped = {}
|
||||||
@@ -445,8 +498,9 @@ def custodian(e: dict | None) -> str:
|
|||||||
|
|
||||||
# ---- the page -----------------------------------------------------------------------------
|
# ---- the page -----------------------------------------------------------------------------
|
||||||
|
|
||||||
def form(do: str, inner: str, button: str, cls: str = "", inline: bool = False) -> str:
|
def form(do: str, inner: str, button: str, cls: str = "", inline: bool = False, form_cls: str = "") -> str:
|
||||||
return (f'<form method="post" action=""{" class=" + chr(34) + "inline" + chr(34) if inline else ""}>'
|
fc = " ".join(x for x in ("inline" if inline else "", form_cls) if x)
|
||||||
|
return (f'<form method="post" action=""{" class=" + chr(34) + fc + chr(34) if fc else ""}>'
|
||||||
f'<input type="hidden" name="do" value="{E(do)}">{inner}'
|
f'<input type="hidden" name="do" value="{E(do)}">{inner}'
|
||||||
f'<button{" class=" + chr(34) + cls + chr(34) if cls else ""}>{E(button)}</button></form>')
|
f'<button{" class=" + chr(34) + cls + chr(34) if cls else ""}>{E(button)}</button></form>')
|
||||||
|
|
||||||
@@ -455,55 +509,163 @@ def hidden(**kw) -> str:
|
|||||||
return "".join(f'<input type="hidden" name="{E(k)}" value="{E(str(v))}">' for k, v in kw.items())
|
return "".join(f'<input type="hidden" name="{E(k)}" value="{E(str(v))}">' for k, v in kw.items())
|
||||||
|
|
||||||
|
|
||||||
def what_lines(assets: list, controls: list, would: bool) -> str:
|
def info(body: str) -> str:
|
||||||
reads = ", ".join(quantity_words(a["asset"]) for a in assets) or T("nothing")
|
"""An "i": its explanation (escaped HTML) opens below on a click or tap."""
|
||||||
kinds = ", ".join(dict.fromkeys(T(CONTROL_WORDS.get(c["kind"], c["kind"])) for c in controls))
|
name = E(T("More information"))
|
||||||
if would:
|
return (f'<details class="info"><summary title="{name}" aria-label="{name}">i</summary>'
|
||||||
out = T("Cantabile would read: {values}.", values=reads)
|
f'<div class="info-body">{body}</div></details>')
|
||||||
if kinds:
|
|
||||||
out += " " + T("It could control: {controls}.", controls=kinds)
|
|
||||||
else:
|
|
||||||
out = T("Cantabile reads: {values}.", values=reads)
|
|
||||||
if kinds:
|
|
||||||
out += " " + T("It may control: {controls}.", controls=kinds)
|
|
||||||
return f'<p class="note">{E(out)}</p>'
|
|
||||||
|
|
||||||
|
|
||||||
def notes(d: dict) -> str:
|
def quantity_words(q: str) -> str:
|
||||||
|
"""A quantity without words of its own: room.living_room.x -> room: living room.x."""
|
||||||
|
return q.replace("_", " ").replace(".", ": ", 1)
|
||||||
|
|
||||||
|
|
||||||
|
def room_name(place: str, rooms) -> str:
|
||||||
|
"""An asset's place (an area's slug) as HA names it: living_room -> Living room."""
|
||||||
|
return next((r for r in rooms or [] if dp.slug(r) == place), place.replace("_", " ").capitalize())
|
||||||
|
|
||||||
|
|
||||||
|
def reads_words(keys, rooms=()) -> str:
|
||||||
|
"""[(key, place)] (devprofiles.reads) in words: room temperature
|
||||||
|
(Living room), setpoint, heating/cooling state; a room named once."""
|
||||||
|
named, out = set(), []
|
||||||
|
for k, place in keys or []:
|
||||||
|
w = T(QUANTITY_WORDS[k]) if k in QUANTITY_WORDS else quantity_words(k)
|
||||||
|
if place and place not in named:
|
||||||
|
named.add(place)
|
||||||
|
w = T("{what} ({room})", what=w, room=room_name(place, rooms))
|
||||||
|
out.append(w)
|
||||||
|
return ", ".join(dict.fromkeys(out))
|
||||||
|
|
||||||
|
|
||||||
|
def ids_words(ids, rooms=()) -> str:
|
||||||
|
return reads_words(dp.reads(list(ids)), rooms)
|
||||||
|
|
||||||
|
|
||||||
|
def control_words(controls) -> str:
|
||||||
|
return ", ".join(dict.fromkeys(T(CONTROL_WORDS.get(c["kind"], c["kind"])) for c in controls or []))
|
||||||
|
|
||||||
|
|
||||||
|
def _num(v, digits: int = 1) -> str:
|
||||||
|
v = round(float(v), digits)
|
||||||
|
return i18n.number(int(v) if v == int(v) else v)
|
||||||
|
|
||||||
|
|
||||||
|
def live_words(k: str, v) -> str:
|
||||||
|
"""One of a device's values now (devprofiles.live): 21.5 °C, set to 22 °C, heating."""
|
||||||
|
if k == dp.HVAC:
|
||||||
|
return T(HVAC_WORDS.get(v, HVAC_WORDS["idle"]))
|
||||||
|
if k in ("heating.state", "cooling.state"):
|
||||||
|
return T(HVAC_WORDS[k.split(".")[0] if v else "idle"])
|
||||||
|
if k == dp.RANGE:
|
||||||
|
return T(LIVE_WORDS[k], low=_num(v[0]), high=_num(v[1])) + " °C"
|
||||||
|
unit = LIVE_UNITS.get(k)
|
||||||
|
s = f"{_num(v)} {unit}" if unit else f"{_num(v / 1000)} kW" if abs(v) >= 1000 or k == "heat.power" else f"{_num(v, 0)} W"
|
||||||
|
return T(LIVE_WORDS[k], v=s) if k in LIVE_WORDS else s
|
||||||
|
|
||||||
|
|
||||||
|
def device_values(d: dict) -> str:
|
||||||
|
return ", ".join(live_words(k, v) for k, v in d.get("live") or [])
|
||||||
|
|
||||||
|
|
||||||
|
def device_state(d: dict) -> str:
|
||||||
|
"""In use · reading on · control off / Added · reading off, with a dot."""
|
||||||
|
on = bool(d.get("read"))
|
||||||
|
parts = [T("In use"), T("reading on")] if on else [T("Added"), T("reading off")]
|
||||||
|
if d.get("controls"):
|
||||||
|
parts.append(T("control on") if d.get("control") else T("control off"))
|
||||||
|
return f'<span class="dot{" on" if on else ""}" aria-hidden="true"></span>' + E(" · ".join(parts))
|
||||||
|
|
||||||
|
|
||||||
|
def model_line(d: dict) -> str:
|
||||||
|
if d.get("generic"):
|
||||||
|
return E(d.get("model", "").split(" (")[0]) + f' · <span class="muted">{E(T("generic profile"))}</span>'
|
||||||
|
return E(f"{d.get('manufacturer', '')} {d.get('model', '')}".strip())
|
||||||
|
|
||||||
|
|
||||||
|
def status_badge(status, explain: bool = True) -> str:
|
||||||
|
"""A profile's status as a small badge, its explanation behind an "i"."""
|
||||||
|
if status not in PROFILE_STATUS:
|
||||||
|
return ""
|
||||||
|
word, cls, why = PROFILE_STATUS[status]
|
||||||
|
return f'<span class="badge {cls}">{E(T(word))}</span>' + (info(E(T(why))) if explain else "")
|
||||||
|
|
||||||
|
|
||||||
|
def protection_badge(d: dict) -> str:
|
||||||
|
if d.get("protection") == "sealed":
|
||||||
|
return f'<span class="badge warn">{E(T("sealed"))}</span>'
|
||||||
|
if any((e or {}).get("level") == "protected" for e in (d.get("policy") or {}).values()):
|
||||||
|
return f'<span class="badge">{E(T("protected"))}</span>'
|
||||||
|
return ""
|
||||||
|
|
||||||
|
|
||||||
|
def section(title: str, body: str, extra: str = "") -> str:
|
||||||
|
return f'<section class="set"><h3>{E(title)}{extra}</h3>{body}</section>'
|
||||||
|
|
||||||
|
|
||||||
|
def save_button() -> str:
|
||||||
|
"""Save, shown only once something changed (by CSS)."""
|
||||||
|
return f'<div class="right"><button class="save">{E(T("Save"))}</button></div>'
|
||||||
|
|
||||||
|
|
||||||
|
def notes(d: dict, rooms=(), values: bool = True) -> str:
|
||||||
|
"""What a device lacks or leaves to others, in words (quietly); the
|
||||||
|
values it does not report only on its own page (values)."""
|
||||||
out = []
|
out = []
|
||||||
if d.get("missing"):
|
lacks = dp.lacks(d.get("missing"))
|
||||||
out.append(T("Not found in Home Assistant: {entities}.", entities=", ".join(d["missing"])))
|
if lacks["values"] and values:
|
||||||
gone = d.get("left_out") or {}
|
out.append(T("This device does not report: {values}.", values=reads_words([(k, "") for k in lacks["values"]])))
|
||||||
if gone.get("values"):
|
gone = [T("{control} control", control=T(CONTROL_WORDS.get(k, k))) for k in lacks["controls"]] + lacks["other"]
|
||||||
|
if gone:
|
||||||
|
out.append(T("Not found in Home Assistant: {entities}.", entities=", ".join(gone)))
|
||||||
|
left = d.get("left_out") or {}
|
||||||
|
if left.get("values"):
|
||||||
out.append(T("Read by your own mapping already, so left out here: {values}.",
|
out.append(T("Read by your own mapping already, so left out here: {values}.",
|
||||||
values=", ".join(quantity_words(q) for q in gone["values"])))
|
values=ids_words(left["values"], rooms)))
|
||||||
if gone.get("controls"):
|
if left.get("controls"):
|
||||||
out.append(T("Another control writes to this device already, so Cantabile leaves out: {controls}.",
|
out.append(T("Another control writes to this device already, so Cantabile leaves out: {controls}.",
|
||||||
controls=", ".join(T(CONTROL_WORDS.get(k, k)) for k in gone["controls"])))
|
controls=", ".join(T(CONTROL_WORDS.get(k, k)) for k in left["controls"])))
|
||||||
assumed = [a["asset"] for a in d.get("assets") or [] if a.get("assumed")]
|
assumed = d.get("assumed") if "assumed" in d else dp.reads([a for a in d.get("assets") or [] if a.get("assumed")])
|
||||||
if assumed:
|
if assumed:
|
||||||
out.append(T("Assumed, not measured: {values}. This device does not report back (infrared): Cantabile shows "
|
out.append(T("Assumed, not measured: {values}. This device does not report back (infrared): Cantabile shows "
|
||||||
"what was last sent to it and never takes it as feedback.",
|
"what was last sent to it and never takes it as feedback.", values=reads_words(assumed)))
|
||||||
values=", ".join(quantity_words(q) for q in assumed)))
|
|
||||||
return "".join(f'<p class="note">{E(x)}</p>' for x in out)
|
return "".join(f'<p class="note">{E(x)}</p>' for x in out)
|
||||||
|
|
||||||
|
|
||||||
def consent_html(d: dict, site: dict) -> str:
|
def consent_html(d: dict, site: dict) -> str:
|
||||||
"""Reading and control, the owner's per device, as on the Hub's Devices
|
"""Reading and control, each a switch that takes effect at once, as on
|
||||||
page; only with the site's consent (the add-on's configuration)."""
|
the Hub's Devices page; only with the site's consent (the add-on's
|
||||||
kinds = ", ".join(dict.fromkeys(T(CONTROL_WORDS.get(c["kind"], c["kind"])) for c in d.get("controls") or []))
|
configuration)."""
|
||||||
|
kinds = control_words(d.get("controls"))
|
||||||
if not site.get("share"):
|
if not site.get("share"):
|
||||||
return ('<p class="note">' + E(T("Reading and control are off. To switch them on, first give your consent in the "
|
return section(T("Reading and control"), '<p class="note">' + E(T(
|
||||||
"add-on's configuration (Settings, Add-ons, Cantabile Edge Agent, Configuration)."))
|
"Reading and control are off. To switch them on, first give your consent in the add-on's configuration "
|
||||||
+ "</p>")
|
"(Settings, Add-ons, Cantabile Edge Agent, Configuration).")) + "</p>")
|
||||||
ctl = ('<label class="check"><input type="checkbox" name="control" value="1"' + (" checked" if d.get("control") else "")
|
read, control = bool(d.get("read")), bool(d.get("control"))
|
||||||
+ "><span>" + E(T("Cantabile may control it ({controls}), within your limits", controls=kinds))
|
|
||||||
+ "</span></label>") if kinds else ""
|
def row(title, note, on, values):
|
||||||
note = ('<p class="note">' + E(T("Control also needs your consent to control devices in the add-on's configuration."))
|
pill = f'<span class="pill{" on" if on else ""}">{E(T("On") if on else T("Off"))}</span>'
|
||||||
+ "</p>") if kinds and not site.get("control") else ""
|
inner = hidden(id=d["id"]) + "".join(f'<input type="hidden" name="{k}" value="{"1" if v else ""}">'
|
||||||
return form("consent", hidden(id=d["id"]) + '<label class="check"><input type="checkbox" name="read" value="1"'
|
for k, v in values.items())
|
||||||
+ (" checked" if d.get("read") else "") + "><span>" + E(T("Cantabile may read these values"))
|
return (f'<div class="switch"><div><b>{E(title)}</b> {pill}<br><span class="note">{E(note)}</span></div>'
|
||||||
+ f"</span></label>{ctl}", T("Save")) + note
|
+ form("consent", inner, T("Turn off") if on else T("Turn on"), "secondary") + "</div>")
|
||||||
|
rows = row(T("Reading"), T("Cantabile may read these values."), read, {"read": not read, "control": control and not read})
|
||||||
|
if kinds:
|
||||||
|
rows += row(T("Control"), T("Cantabile may control it ({controls}), within your limits.", controls=kinds), control,
|
||||||
|
{"read": read or not control, "control": not control})
|
||||||
|
if not site.get("control"):
|
||||||
|
rows += '<p class="note">' + E(T("Control also needs your consent to control devices in the add-on's "
|
||||||
|
"configuration.")) + "</p>"
|
||||||
|
return section(T("Reading and control"), rows)
|
||||||
|
|
||||||
|
|
||||||
|
def reads_html(d: dict, rooms=()) -> str:
|
||||||
|
lines = [f'<p>{E(T("Reads: {values}", values=reads_words(d.get("reads"), rooms) or T("nothing")))}</p>']
|
||||||
|
kinds = control_words(d.get("controls"))
|
||||||
|
if kinds:
|
||||||
|
lines.append(f'<p>{E(T("Controls: {controls}", controls=kinds))}</p>')
|
||||||
|
return section(T("What Cantabile reads"), "".join(lines) + notes(d, rooms))
|
||||||
|
|
||||||
|
|
||||||
def switchover_html(d: dict) -> str:
|
def switchover_html(d: dict) -> str:
|
||||||
@@ -514,14 +676,14 @@ def switchover_html(d: dict) -> str:
|
|||||||
lo, hi = sw.get("heat_below_c", 15), sw.get("cool_above_c", 22)
|
lo, hi = sw.get("heat_below_c", 15), sw.get("cool_above_c", 22)
|
||||||
radios = "".join(f'<label class="check"><input type="radio" name="mode" value="{k}"{" checked" if k == mode else ""}>'
|
radios = "".join(f'<label class="check"><input type="radio" name="mode" value="{k}"{" checked" if k == mode else ""}>'
|
||||||
f"<span>{E(T(w))}</span></label>" for k, w in SWITCHOVER_WORDS.items())
|
f"<span>{E(T(w))}</span></label>" for k, w in SWITCHOVER_WORDS.items())
|
||||||
inner = (hidden(id=d["id"]) + f'<p class="note">{E(T("This thermostat can heat and cool. Cantabile uses one at a time; the other is never touched."))}</p>'
|
inner = (hidden(id=d["id"]) + radios + '<div class="outdoor row">'
|
||||||
+ radios
|
f'<div><label for="lo-{E(d["id"])}">{E(T("Heat below (°C)"))}</label>'
|
||||||
+ f'<label for="lo-{E(d["id"])}">{E(T("By outdoor temperature: heat below (°C)"))}</label>'
|
f'<input id="lo-{E(d["id"])}" type="number" step="0.5" name="heat_below_c" value="{E(f"{lo:g}")}"></div>'
|
||||||
f'<input id="lo-{E(d["id"])}" type="number" step="0.5" name="heat_below_c" value="{E(f"{lo:g}")}">'
|
f'<div><label for="hi-{E(d["id"])}">{E(T("Cool above (°C)"))}</label>'
|
||||||
f'<label for="hi-{E(d["id"])}">{E(T("cool above (°C)"))}</label>'
|
f'<input id="hi-{E(d["id"])}" type="number" step="0.5" name="cool_above_c" value="{E(f"{hi:g}")}"></div></div>'
|
||||||
f'<input id="hi-{E(d["id"])}" type="number" step="0.5" name="cool_above_c" value="{E(f"{hi:g}")}">'
|
f'<p class="note outdoor">{E(T("Between the two it stays as it is, so it does not switch back and forth on a mild day."))}</p>')
|
||||||
f'<p class="note">{E(T("Between the two it stays as it is, so it does not switch back and forth on a mild day."))}</p>')
|
about = info(E(T("This thermostat can heat and cool. Cantabile uses one at a time; the other is never touched.")))
|
||||||
return f"<details><summary>{E(T('Heating or cooling'))}</summary>{form('switchover', inner, T('Save'))}</details>"
|
return section(T("Heating or cooling"), form("switchover", inner, T("Save"), "save", form_cls="changes"), about)
|
||||||
|
|
||||||
|
|
||||||
FACING_WORDS = {"": M("Not known"), "N": M("North"), "NE": M("North-east"), "E": M("East"), "SE": M("South-east"),
|
FACING_WORDS = {"": M("Not known"), "N": M("North"), "NE": M("North-east"), "E": M("East"), "SE": M("South-east"),
|
||||||
@@ -532,7 +694,7 @@ def _room_options(rooms, current: str) -> str:
|
|||||||
names = list(rooms)
|
names = list(rooms)
|
||||||
if current and current not in {dp.slug(r) for r in names}:
|
if current and current not in {dp.slug(r) for r in names}:
|
||||||
names.append(current)
|
names.append(current)
|
||||||
return f'<option value="">{E(T("No room"))}</option>' + "".join(
|
return f'<option value=""{"" if current else " selected"}>{E(T("No room"))}</option>' + "".join(
|
||||||
f'<option value="{E(r)}"{" selected" if dp.slug(r) == current else ""}>{E(r)}</option>' for r in names)
|
f'<option value="{E(r)}"{" selected" if dp.slug(r) == current else ""}>{E(r)}</option>' for r in names)
|
||||||
|
|
||||||
|
|
||||||
@@ -546,15 +708,16 @@ def shade_html(d: dict, rooms) -> str:
|
|||||||
opts = "".join(f'<option value="{k}"{" selected" if k == cur else ""}>{E(T(w))}</option>' for k, w in FACING_WORDS.items())
|
opts = "".join(f'<option value="{k}"{" selected" if k == cur else ""}>{E(T(w))}</option>' for k, w in FACING_WORDS.items())
|
||||||
if cur is None:
|
if cur is None:
|
||||||
opts += f'<option value="{face:g}" selected>{face:g}°</option>'
|
opts += f'<option value="{face:g}" selected>{face:g}°</option>'
|
||||||
inner = (hidden(id=d["id"]) + '<p class="note">' + E(T(
|
inner = (hidden(id=d["id"]) + '<div class="row">'
|
||||||
|
f'<div><label for="area-{E(d["id"])}">{E(T("Room it shades"))}</label><select id="area-{E(d["id"])}" name="area">'
|
||||||
|
f'{_room_options(rooms, sh.get("area") or "")}</select></div>'
|
||||||
|
f'<div><label for="face-{E(d["id"])}">{E(T("The window faces"))}</label><select id="face-{E(d["id"])}" name="facing">{opts}</select></div></div>'
|
||||||
|
'<p class="note">' + E(T("Without the window's direction Cantabile only closes it at night in winter.")) + "</p>")
|
||||||
|
about = info(E(T(
|
||||||
"Cantabile moves it by the sun: in summer it closes it while the sun is on the window and the room is warm; in "
|
"Cantabile moves it by the sun: in summer it closes it while the sun is on the window and the room is warm; in "
|
||||||
"winter it opens it for the sun's warmth and closes it at night. Never between 22:00 and 07:00, and after you "
|
"winter it opens it for the sun's warmth and closes it at night. Never between 22:00 and 07:00, and after you "
|
||||||
"move it by hand it waits 4 hours.")) + "</p>"
|
"move it by hand it waits 4 hours.")))
|
||||||
f'<label for="area-{E(d["id"])}">{E(T("Room it shades"))}</label><select id="area-{E(d["id"])}" name="area">'
|
return section(T("Room and window"), form("shade", inner, T("Save"), "save", form_cls="changes"), about)
|
||||||
f'{_room_options(rooms, sh.get("area") or "")}</select>'
|
|
||||||
f'<label for="face-{E(d["id"])}">{E(T("The window faces"))}</label><select id="face-{E(d["id"])}" name="facing">{opts}</select>'
|
|
||||||
'<p class="note">' + E(T("Without the window's direction Cantabile only closes it at night in winter.")) + "</p>")
|
|
||||||
return f"<details><summary>{E(T('Room and window'))}</summary>{form('shade', inner, T('Save'))}</details>"
|
|
||||||
|
|
||||||
|
|
||||||
def place_html(d: dict, rooms) -> str:
|
def place_html(d: dict, rooms) -> str:
|
||||||
@@ -566,9 +729,9 @@ def place_html(d: dict, rooms) -> str:
|
|||||||
inner = (hidden(id=d["id"])
|
inner = (hidden(id=d["id"])
|
||||||
+ f'<label class="check"><input type="radio" name="place" value="indoor"{chk("indoor")}><span>{E(T("Indoor, in the room:"))}</span></label>'
|
+ f'<label class="check"><input type="radio" name="place" value="indoor"{chk("indoor")}><span>{E(T("Indoor, in the room:"))}</span></label>'
|
||||||
+ f'<select name="area" aria-label="{E(T("Room"))}">{_room_options(rooms, pl.get("area") or "")}</select>'
|
+ f'<select name="area" aria-label="{E(T("Room"))}">{_room_options(rooms, pl.get("area") or "")}</select>'
|
||||||
+ f'<label class="check"><input type="radio" name="place" value="outdoor"{chk("outdoor")}><span>{E(T("Outdoor: Cantabile's outside temperature"))}</span></label>'
|
+ f'<label class="check"><input type="radio" name="place" value="outdoor"{chk("outdoor")}><span>{E(T("Outdoor: Cantabile's outside temperature"))}</span></label>')
|
||||||
+ '<p class="note">' + E(T("An outdoor sensor counts before the weather service's temperature.")) + "</p>")
|
about = info(E(T("An outdoor sensor counts before the weather service's temperature.")))
|
||||||
return f"<details><summary>{E(T('Indoor or outdoor'))}</summary>{form('place', inner, T('Save'))}</details>"
|
return section(T("Indoor or outdoor"), form("place", inner, T("Save"), "save", form_cls="changes"), about)
|
||||||
|
|
||||||
|
|
||||||
def weather_html(d: dict) -> str:
|
def weather_html(d: dict) -> str:
|
||||||
@@ -577,9 +740,11 @@ def weather_html(d: dict) -> str:
|
|||||||
if not w:
|
if not w:
|
||||||
return ""
|
return ""
|
||||||
if w.get("active"):
|
if w.get("active"):
|
||||||
return '<p class="note">' + E(T("Cantabile plans with this forecast: solar, heating, cooling and the shades.")) + "</p>"
|
return section(T("Forecast"), '<p class="note">' + E(T(
|
||||||
return ('<p class="note">' + E(T("Not used for planning: Cantabile plans with one weather forecast, another one's."))
|
"Cantabile plans with this forecast: solar, heating, cooling and the shades.")) + "</p>")
|
||||||
+ "</p>" + form("weather", hidden(id=d["id"]), T("Plan with this forecast"), "secondary"))
|
return section(T("Forecast"), '<p class="note">' + E(T(
|
||||||
|
"Not used for planning: Cantabile plans with one weather forecast, another one's.")) + "</p>"
|
||||||
|
+ form("weather", hidden(id=d["id"]), T("Plan with this forecast"), "secondary"))
|
||||||
|
|
||||||
|
|
||||||
def protection_html(d: dict) -> str:
|
def protection_html(d: dict) -> str:
|
||||||
@@ -589,11 +754,15 @@ def protection_html(d: dict) -> str:
|
|||||||
targets = [f"device:{d['id']}"] + [f"control:{c['id']}" for c in d.get("controls") or [] if c.get("id")]
|
targets = [f"device:{d['id']}"] + [f"control:{c['id']}" for c in d.get("controls") or [] if c.get("id")]
|
||||||
targets += [t for t in pol if t not in targets]
|
targets += [t for t in pol if t not in targets]
|
||||||
seal = (pol.get(f"device:{d['id']}") or {}) if d.get("protection") == "sealed" else None
|
seal = (pol.get(f"device:{d['id']}") or {}) if d.get("protection") == "sealed" else None
|
||||||
|
profile_name = f"{d.get('manufacturer', '')} {d.get('model', '')}".strip()
|
||||||
rows = []
|
rows = []
|
||||||
covers = {f"control:{c['id']}" for c in d.get("controls") or [] if c.get("kind") == "cover" and c.get("id")}
|
kinds = {f"control:{c['id']}": c.get("kind") for c in d.get("controls") or [] if c.get("id")}
|
||||||
|
covers = {t for t, k in kinds.items() if k == "cover"}
|
||||||
for t in targets:
|
for t in targets:
|
||||||
e = pol.get(t) or {}
|
e = pol.get(t) or {}
|
||||||
kind, _, name = t.partition(":")
|
kind, _, name = t.partition(":")
|
||||||
|
if kind == "control" and kinds.get(t) in CONTROL_WORDS:
|
||||||
|
name = T(CONTROL_WORDS[kinds[t]])
|
||||||
what = {"device": T("The whole device"), "control": T("Control {name}", name=name)}.get(kind, name)
|
what = {"device": T("The whole device"), "control": T("Control {name}", name=name)}.get(kind, name)
|
||||||
lift = T("Allow Cantabile to move it") if t in covers else T("Allow switching off")
|
lift = T("Allow Cantabile to move it") if t in covers else T("Allow switching off")
|
||||||
lvl = "sealed" if seal else e.get("level", "none")
|
lvl = "sealed" if seal else e.get("level", "none")
|
||||||
@@ -602,54 +771,61 @@ def protection_html(d: dict) -> str:
|
|||||||
rows.append(f'<li>{E(what)}: <b>{E(T("Sealed"))}</b> · {E(T("only {who} can change it", who=custodian(seal or e)))}'
|
rows.append(f'<li>{E(what)}: <b>{E(T("Sealed"))}</b> · {E(T("only {who} can change it", who=custodian(seal or e)))}'
|
||||||
f'{": " + E(why) if why else ""}</li>')
|
f'{": " + E(why) if why else ""}</li>')
|
||||||
continue
|
continue
|
||||||
why = f" ({E(e['why'])})" if e.get("why") and lvl == "protected" else ""
|
# the profile's default says only the profile's name: not repeated
|
||||||
|
why = f" ({E(e['why'])})" if e.get("why") and e["why"] != profile_name and lvl == "protected" else ""
|
||||||
state = f"<b>{E(T('protected'))}</b>" if lvl == "protected" else E(T("not protected"))
|
state = f"<b>{E(T('protected'))}</b>" if lvl == "protected" else E(T("not protected"))
|
||||||
rows.append(f"<li>{E(what)}: {state}{why} "
|
rows.append(f'<li class="switch"><span>{E(what)}: {state}{why}</span>'
|
||||||
+ form("protect", hidden(id=d["id"], target=t, level="none" if lvl == "protected" else "protected"),
|
+ form("protect", hidden(id=d["id"], target=t, level="none" if lvl == "protected" else "protected"),
|
||||||
lift if lvl == "protected" else T("Protect"), "secondary", inline=True)
|
lift if lvl == "protected" else T("Protect"), "secondary")
|
||||||
+ "</li>")
|
+ "</li>")
|
||||||
return (f"<details><summary>{E(T('Protection'))}</summary><p class=\"note\">"
|
about = E(T("Protected: Cantabile never switches it off or cuts it; you still can, by hand. Sealed: only its "
|
||||||
+ E(T("Protected: Cantabile never switches it off or cuts it; you still can, by hand. Sealed: only its "
|
"custodian can change it.") + ("" if not covers else " " + T(
|
||||||
"custodian can change it.")) + ("" if not covers else " " + E(T(
|
|
||||||
"A protected blind or curtain is not moved by Cantabile at all.")))
|
"A protected blind or curtain is not moved by Cantabile at all.")))
|
||||||
+ f'</p><ul class="plain">{"".join(rows)}</ul></details>')
|
return section(T("Protection"), f'<ul class="plain">{"".join(rows)}</ul>', info(about))
|
||||||
|
|
||||||
|
|
||||||
def badges(d: dict) -> str:
|
def remove_html(d: dict) -> str:
|
||||||
st = PROFILE_STATUS.get(d.get("status"))
|
return ('<section class="set"><details class="remove"><summary>' + E(T("Remove from Cantabile")) + "</summary>"
|
||||||
out = f'<span class="badge">{E(d.get("manufacturer", ""))} {E(d.get("model", ""))}</span>'
|
+ '<p class="note">' + E(T("Cantabile stops using it. Home Assistant keeps the device as it is.")) + "</p>"
|
||||||
if d.get("generic"):
|
+ form("remove", hidden(id=d["id"]), T("Yes, remove it"), "danger") + "</details></section>")
|
||||||
out += f'<span class="badge">{E(T("generic profile"))}</span>'
|
|
||||||
if st:
|
|
||||||
out += f'<span class="badge">{E(T(st))}</span>'
|
|
||||||
return out
|
|
||||||
|
|
||||||
|
|
||||||
def device_card(d: dict, site: dict, rooms=()) -> str:
|
def device_row(d: dict) -> str:
|
||||||
return (f'<div class="box"><b>{E(d["name"])}</b>{badges(d)}{what_lines(d.get("assets") or [], d.get("controls") or [], False)}'
|
"""A device in use on the list: name, state in words, main values now,
|
||||||
f'{notes(d)}{consent_html(d, site)}{switchover_html(d)}{shade_html(d, rooms)}{place_html(d, rooms)}'
|
protection; its settings on its own page."""
|
||||||
f'{weather_html(d)}{protection_html(d)}'
|
vals = device_values(d)
|
||||||
f"<details><summary>{E(T('Remove'))}</summary><p class=\"note\">"
|
return (f'<a class="box dev" href="?p=devices&d={urllib.parse.quote(d["id"])}"><span class="grow">'
|
||||||
+ E(T("Cantabile stops using it. Home Assistant keeps the device as it is."))
|
f'<span class="name">{E(d["name"])}</span> {protection_badge(d)}'
|
||||||
+ "</p>" + form("remove", hidden(id=d["id"]), T("Stop using it with Cantabile"), "secondary") + "</details></div>")
|
f'<span class="model">{model_line(d)}</span><span class="state">{device_state(d)}</span>'
|
||||||
|
+ (f'<span class="values">{E(vals)}</span>' if vals else "")
|
||||||
|
+ '</span><span class="chev" aria-hidden="true">›</span></a>')
|
||||||
|
|
||||||
|
|
||||||
def offer_card(h: dict) -> str:
|
def offer_card(h: dict, rooms=()) -> str:
|
||||||
|
"""A device HA has that a profile knows, not used yet: what it would
|
||||||
|
give, "Use with Cantabile"."""
|
||||||
p = h["profile"]
|
p = h["profile"]
|
||||||
name = h["name"] or h["model"]
|
name = h["name"] or h["model"]
|
||||||
|
generic = f' · <span class="muted">{E(T("generic profile"))}</span>' if h.get("generic") else ""
|
||||||
|
would = T("Cantabile would read: {values}.", values=reads_words(dp.reads(h["assets"]), rooms) or T("nothing"))
|
||||||
|
kinds = control_words(h["controls"])
|
||||||
|
if kinds:
|
||||||
|
would += " " + T("It could control: {controls}.", controls=kinds)
|
||||||
proposed = ""
|
proposed = ""
|
||||||
if h.get("in_mapping"):
|
if h.get("in_mapping"):
|
||||||
ids = ", ".join(quantity_words(i) for i in h["in_mapping"])
|
ids = ids_words(h["in_mapping"], rooms)
|
||||||
proposed = '<p class="note">' + E(
|
proposed = '<p class="note">' + E(
|
||||||
T("Proposed by Cantabile (not checked yet): {values}. Use it with Cantabile to confirm it as this profile "
|
T("Proposed by Cantabile (not checked yet): {values}. Use it with Cantabile to confirm it as this profile "
|
||||||
"sees it.", values=ids) if h.get("mapping_source") in ("proposed", "imported")
|
"sees it.", values=ids) if h.get("mapping_source") in ("proposed", "imported")
|
||||||
else T("In your own mapping: {values}. Those stay as they are.", values=ids)) + "</p>"
|
else T("In your own mapping: {values}. Those stay as they are.", values=ids)) + "</p>"
|
||||||
body = what_lines(h["assets"], h["controls"], True) + notes(h) + proposed
|
head = (f'<span class="grow"><span class="name">{E(name)}</span> {status_badge(p.get("status"), False)}'
|
||||||
view = dict(h, status=p.get("status"))
|
f'<span class="model">{E((h.get("manufacturer", "") + " " + h.get("model", "")).strip())}{generic}</span></span>')
|
||||||
|
body = f'<p class="note">{E(would)}</p>' + notes(h, rooms, False) + proposed
|
||||||
if not h["assets"] and not h["controls"]:
|
if not h["assets"] and not h["controls"]:
|
||||||
return f'<div class="box"><b>{E(name)}</b>{badges(view)}{body}</div>'
|
return f'<div class="box offer"><div class="top">{head}</div>{body}</div>'
|
||||||
return (f'<div class="box"><b>{E(name)}</b>{badges(view)}{body}'
|
return (f'<div class="box offer"><div class="top">{head}'
|
||||||
+ form("use", hidden(ha_device=h["id"], profile=p["id"], name=name), T("Use with Cantabile")) + "</div>")
|
+ form("use", hidden(ha_device=h["id"], profile=p["id"], name=name), T("Use with Cantabile"), "secondary")
|
||||||
|
+ f"</div>{body}</div>")
|
||||||
|
|
||||||
|
|
||||||
def nav(page: str) -> str:
|
def nav(page: str) -> str:
|
||||||
@@ -664,32 +840,55 @@ def html(title: str, body: str, page: str) -> str:
|
|||||||
f"<script>{HASH_SCRIPT}</script></head><body>{nav(page)}{body}</body></html>")
|
f"<script>{HASH_SCRIPT}</script></head><body>{nav(page)}{body}</body></html>")
|
||||||
|
|
||||||
|
|
||||||
|
def messages(msg: str, err: str) -> str:
|
||||||
|
return (f'<div class="box ok">{E(msg)}</div>' if msg else "") + (f'<div class="box err">{E(err)}</div>' if err else "")
|
||||||
|
|
||||||
|
|
||||||
def page_devices(v: dict, msg: str = "", err: str = "") -> str:
|
def page_devices(v: dict, msg: str = "", err: str = "") -> str:
|
||||||
body = [f"<h2>{E(T('Devices'))}</h2><p class=\"note\">"
|
about = E(T("Home Assistant's devices that a Cantabile device profile knows. Use one with Cantabile to see it on "
|
||||||
+ E(T("Home Assistant's devices that a Cantabile device profile knows. Use one with Cantabile to see it on "
|
"Cantabile's dashboard and to let Cantabile read it once you have given your consent."))
|
||||||
"Cantabile's dashboard and to let Cantabile read it once you have given your consent.")) + "</p>"]
|
body = [f"<h2>{E(T('Devices'))}{info(about)}</h2>" + messages(msg, err)]
|
||||||
if msg:
|
rooms = v.get("rooms") or []
|
||||||
body.append(f'<div class="box ok">{E(msg)}</div>')
|
|
||||||
if err:
|
|
||||||
body.append(f'<div class="box err">{E(err)}</div>')
|
|
||||||
if v.get("devices"):
|
if v.get("devices"):
|
||||||
body.append(f"<h3>{E(T('Used with Cantabile'))}</h3>")
|
n = len(v["devices"])
|
||||||
body += [device_card(d, v.get("site") or {}, v.get("rooms") or []) for d in v["devices"]]
|
body.append(f"<h3>{E(TN('{n} device in use with Cantabile', '{n} devices in use with Cantabile', n))}</h3>")
|
||||||
|
body += [device_row(dict(d, rooms=rooms)) for d in v["devices"]]
|
||||||
|
elif not v.get("ha_error"):
|
||||||
|
body.append('<p class="note">' + E(T("No device is used with Cantabile yet. Add one below.")) + "</p>")
|
||||||
|
body.append(f'<div class="add"><h2>{E(T("Add a device"))}</h2>')
|
||||||
if v.get("offers"):
|
if v.get("offers"):
|
||||||
body.append(f"<h3>{E(T('In Home Assistant, with a profile'))}</h3>")
|
body.append(f"<h3>{E(T('Devices in Home Assistant you can add'))}</h3>")
|
||||||
body += [offer_card(h) for h in v["offers"]]
|
body += [offer_card(h, rooms) for h in v["offers"]]
|
||||||
elif not v.get("ha_error") and not v.get("devices"):
|
elif not v.get("ha_error"):
|
||||||
body.append('<p class="note">' + E(T("No device in Home Assistant fits a Cantabile profile yet.")) + "</p>")
|
body.append('<p class="note">' + E(T("No other device in Home Assistant fits a Cantabile profile.")) + "</p>")
|
||||||
if v.get("rest"):
|
if v.get("rest"):
|
||||||
n = len(v["rest"])
|
n = len(v["rest"])
|
||||||
body.append(f"<details><summary>{E(TN('{n} more in Home Assistant without a profile (not used by Cantabile)', '{n} more in Home Assistant without a profile (not used by Cantabile)', n))}</summary><ul class=\"plain\">"
|
body.append(f"<details class=\"more\"><summary class=\"note\">{E(TN('{n} more in Home Assistant without a profile (not used by Cantabile)', '{n} more in Home Assistant without a profile (not used by Cantabile)', n))}</summary><ul class=\"plain\">"
|
||||||
+ "".join(f"<li>{E(h['name'] or h['model'])} <small>{E(h['manufacturer'])} {E(h['model'])}</small></li>"
|
+ "".join(f"<li>{E(h['name'] or h['model'])} <small class=\"muted\">{E(h['manufacturer'])} {E(h['model'])}</small></li>"
|
||||||
for h in v["rest"]) + "</ul></details>")
|
for h in v["rest"]) + "</ul></details>")
|
||||||
if v.get("ha_error"):
|
if v.get("ha_error"):
|
||||||
body.append('<p class="note">' + E(T("Home Assistant's devices could not be read: {error}", error=v["ha_error"])) + "</p>")
|
body.append('<p class="note">' + E(T("Home Assistant's devices could not be read: {error}", error=v["ha_error"])) + "</p>")
|
||||||
|
body.append("</div>")
|
||||||
return html(T("Cantabile: devices"), "".join(body), "devices")
|
return html(T("Cantabile: devices"), "".join(body), "devices")
|
||||||
|
|
||||||
|
|
||||||
|
def page_device(v: dict, dev_id: str, msg: str = "", err: str = "") -> str:
|
||||||
|
"""One device in use: its state and values, then its settings, each
|
||||||
|
section saving on its own. The list when there is no such device."""
|
||||||
|
d = next((x for x in v.get("devices") or [] if x["id"] == dev_id), None)
|
||||||
|
if not d:
|
||||||
|
return page_devices(v, msg, err)
|
||||||
|
rooms = v.get("rooms") or []
|
||||||
|
vals = device_values(d)
|
||||||
|
body = (f'<a class="back" href="?p=devices">‹ {E(T("Devices"))}</a><h2>{E(d["name"])}</h2>'
|
||||||
|
f'<div class="model head">{model_line(d)} {status_badge(d.get("status"))}</div>{messages(msg, err)}'
|
||||||
|
f'<div class="box now"><span class="state">{device_state(d)}</span>'
|
||||||
|
+ (f'<span class="values">{E(vals)}</span>' if vals else "") + "</div>"
|
||||||
|
+ consent_html(d, v.get("site") or {}) + reads_html(d, rooms) + switchover_html(d) + shade_html(d, rooms)
|
||||||
|
+ place_html(d, rooms) + weather_html(d) + protection_html(d) + remove_html(d))
|
||||||
|
return html(f'Cantabile: {d["name"]}', body, "devices")
|
||||||
|
|
||||||
|
|
||||||
def page_refused(why: str, page: str = "devices") -> str:
|
def page_refused(why: str, page: str = "devices") -> str:
|
||||||
head = T("Devices") if page == "devices" else T("Building or community")
|
head = T("Devices") if page == "devices" else T("Building or community")
|
||||||
return html("Cantabile", f"<h2>{E(head)}</h2><div class=\"box err\">{E(why)}</div>", page)
|
return html("Cantabile", f"<h2>{E(head)}</h2><div class=\"box err\">{E(why)}</div>", page)
|
||||||
@@ -733,8 +932,10 @@ class App(JoinPage):
|
|||||||
return status, out
|
return status, out
|
||||||
if url.path not in ("/", "") or method not in ("GET", "POST"):
|
if url.path not in ("/", "") or method not in ("GET", "POST"):
|
||||||
return 404, T("Not found")
|
return 404, T("Not found")
|
||||||
|
dev_id = (q.get("d") or [""])[0]
|
||||||
if method == "GET":
|
if method == "GET":
|
||||||
return 200, page_devices(await self.devices.view())
|
v = await self.devices.view()
|
||||||
|
return 200, page_device(v, dev_id) if dev_id else page_devices(v)
|
||||||
f = {k: v[0] for k, v in urllib.parse.parse_qs(data.decode("utf-8", "replace")).items()}
|
f = {k: v[0] for k, v in urllib.parse.parse_qs(data.decode("utf-8", "replace")).items()}
|
||||||
by = hdr.get("x-remote-user-display-name") or hdr.get("x-remote-user-name") or "owner"
|
by = hdr.get("x-remote-user-display-name") or hdr.get("x-remote-user-name") or "owner"
|
||||||
return 200, await self.post_devices(f, by)
|
return 200, await self.post_devices(f, by)
|
||||||
@@ -747,6 +948,7 @@ class App(JoinPage):
|
|||||||
msg = T("{name} is used with Cantabile now. It is on Cantabile's dashboard; reading and control are off "
|
msg = T("{name} is used with Cantabile now. It is on Cantabile's dashboard; reading and control are off "
|
||||||
"until you switch them on below.",
|
"until you switch them on below.",
|
||||||
name=d["name"])
|
name=d["name"])
|
||||||
|
return page_device(await dv.view(), d["id"], msg)
|
||||||
elif do == "remove":
|
elif do == "remove":
|
||||||
await dv.remove(f.get("id", ""))
|
await dv.remove(f.get("id", ""))
|
||||||
msg = T("Cantabile no longer uses it.")
|
msg = T("Cantabile no longer uses it.")
|
||||||
@@ -773,4 +975,7 @@ class App(JoinPage):
|
|||||||
msg = T("Saved. Cantabile starts again to apply it (a few seconds).")
|
msg = T("Saved. Cantabile starts again to apply it (a few seconds).")
|
||||||
except dp.Fail as e:
|
except dp.Fail as e:
|
||||||
err = str(e)
|
err = str(e)
|
||||||
|
# a device's setting: back to its page (removed: the list)
|
||||||
|
if do in ("use", "remove") or not f.get("id"):
|
||||||
return page_devices(await dv.view(), msg, err)
|
return page_devices(await dv.view(), msg, err)
|
||||||
|
return page_device(await dv.view(), f["id"], msg, err)
|
||||||
@@ -695,3 +695,102 @@ def one_weather(frag: dict, others) -> None:
|
|||||||
frag["weather_entity"] = ent
|
frag["weather_entity"] = ent
|
||||||
if any((o.get("inputs") or {}).get("weather") for o in others):
|
if any((o.get("inputs") or {}).get("weather") for o in others):
|
||||||
frag.pop("inputs", None)
|
frag.pop("inputs", None)
|
||||||
|
|
||||||
|
|
||||||
|
# --- what a device reads, in the pages' words (both Devices pages) -------------------------
|
||||||
|
# The Hub panel and the add-on's page show a device's values by their
|
||||||
|
# meaning, never by asset id: room.living_room.setpoint_low and _high are
|
||||||
|
# one "heat/cool range", heating.state and cooling.state one "heating/
|
||||||
|
# cooling state". Here only the keys and values; each page has its words
|
||||||
|
# (its own catalogue) for each key.
|
||||||
|
RANGE, HVAC = "room.setpoint_range", "heating_cooling.state"
|
||||||
|
# A device's main values on the list, in this order (at most a few).
|
||||||
|
HEADLINE = ("room.temp", "room.setpoint", RANGE, HVAC, "heating.state", "cooling.state", "pv.power", "battery.soc",
|
||||||
|
"battery.power", "grid.power", "load.power", "ev.power", "heatpump.power", "heat.power",
|
||||||
|
"heatpump.flow_temp", "outside.temp", "room.humidity", "room.shade_position", "circuit.power")
|
||||||
|
|
||||||
|
|
||||||
|
def base_quantity(q: str) -> tuple[str, str]:
|
||||||
|
"""(quantity, place) of an asset id or a profile's value: room.living_room.temp
|
||||||
|
-> ("room.temp", "living_room"), room.{area}.humidity -> ("room.humidity", ""),
|
||||||
|
pv.2.power -> ("pv.power", ""), room.kitchen.temp_2 -> ("room.temp", "kitchen")."""
|
||||||
|
head, _, rest = q.partition(".")
|
||||||
|
if head in PER_PLACE and "." in rest:
|
||||||
|
place, _, last = rest.rpartition(".")
|
||||||
|
base = f"{head}.{last}"
|
||||||
|
if base not in QUANTITIES:
|
||||||
|
base = f"{head}.{re.sub(r'_[0-9]+$', '', last)}"
|
||||||
|
return base, ("" if place.startswith("{") else place)
|
||||||
|
part = part_of(q)
|
||||||
|
if part:
|
||||||
|
return part[0], ""
|
||||||
|
return (q if q in QUANTITIES else re.sub(r"_[0-9]+$", "", q)), ""
|
||||||
|
|
||||||
|
|
||||||
|
def reads(assets) -> list:
|
||||||
|
"""What a device reads: [(key, place)] in its order, each once; a
|
||||||
|
setpoint's low and high as RANGE, heating and cooling state as HVAC."""
|
||||||
|
keys = [base_quantity(a["asset"] if isinstance(a, dict) else a) for a in assets or []]
|
||||||
|
have = {k for k, _ in keys}
|
||||||
|
out = []
|
||||||
|
for k, place in keys:
|
||||||
|
if k in ("room.setpoint_low", "room.setpoint_high"):
|
||||||
|
k = RANGE
|
||||||
|
elif k in ("heating.state", "cooling.state") and {"heating.state", "cooling.state"} <= have:
|
||||||
|
k = HVAC
|
||||||
|
if [k, place] not in out:
|
||||||
|
out.append([k, place])
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
|
def lacks(missing) -> dict:
|
||||||
|
"""mapping_for's missing in parts: the values a device does not give
|
||||||
|
(keys, as reads()), the controls not found (kinds), anything else."""
|
||||||
|
out = {"values": [], "controls": [], "other": []}
|
||||||
|
for m in missing or []:
|
||||||
|
m = str(m)
|
||||||
|
if re.fullmatch(r"[a-z_]+ control \(.*\)", m):
|
||||||
|
out["controls"].append(m.split(" ", 1)[0])
|
||||||
|
elif quantity_of(m) or quantity_of(base_quantity(m)[0]):
|
||||||
|
k = [x for x, _ in reads([m])][0]
|
||||||
|
if k not in out["values"]:
|
||||||
|
out["values"].append(k)
|
||||||
|
else:
|
||||||
|
out["other"].append(m)
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
|
def asset_value(a: dict, states: dict):
|
||||||
|
"""One value now from HA's states ({entity_id: {"state", "attributes"}}):
|
||||||
|
a number (scaled), True/False (an "equals"), or None (not known)."""
|
||||||
|
s = (states or {}).get(a.get("entity"))
|
||||||
|
if not s:
|
||||||
|
return None
|
||||||
|
raw = (s.get("attributes") or {}).get(a["attribute"]) if a.get("attribute") else s.get("state")
|
||||||
|
if raw is None or raw in ("unavailable", "unknown", ""):
|
||||||
|
return None
|
||||||
|
if a.get("equals") is not None:
|
||||||
|
return str(raw) == str(a["equals"])
|
||||||
|
try:
|
||||||
|
return float(raw) * float(a.get("scale", 1))
|
||||||
|
except (TypeError, ValueError):
|
||||||
|
return None
|
||||||
|
|
||||||
|
|
||||||
|
def live(assets, states, limit: int = 3) -> list:
|
||||||
|
"""A device's main values now: [(key, value)] in HEADLINE's order, at
|
||||||
|
most limit; RANGE's value [low, high], HVAC's "heating", "cooling" or
|
||||||
|
"idle"; values not known left out."""
|
||||||
|
now = {}
|
||||||
|
for a in assets or []:
|
||||||
|
k = base_quantity(a["asset"])[0]
|
||||||
|
if k not in now:
|
||||||
|
v = asset_value(a, states)
|
||||||
|
if v is not None:
|
||||||
|
now[k] = v
|
||||||
|
if now.get("room.setpoint") is None and now.get("room.setpoint_low") is not None \
|
||||||
|
and now.get("room.setpoint_high") is not None:
|
||||||
|
now[RANGE] = [now["room.setpoint_low"], now["room.setpoint_high"]]
|
||||||
|
if "heating.state" in now and "cooling.state" in now:
|
||||||
|
now[HVAC] = "heating" if now.pop("heating.state") else "cooling" if now.pop("cooling.state") else "idle"
|
||||||
|
return [[k, now[k]] for k in HEADLINE if k in now][:limit]
|
||||||
@@ -0,0 +1,165 @@
|
|||||||
|
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
||||||
|
"""How many phases a charger charges on (docs/methods.md, finding A8-a): one
|
||||||
|
or three, never one fixed default. Per EV control, from the best evidence,
|
||||||
|
with where it came from:
|
||||||
|
|
||||||
|
mapping the control's `phases` (the installer's, or the device profile's)
|
||||||
|
device the charger reports it: the control's `phases` entity (the
|
||||||
|
EEBUS bridge's "phases" value; a sensor 1..3)
|
||||||
|
learned seen by the box while the car charged steadily: power / (volts
|
||||||
|
x current) is about 1, 2 or 3 (within 0.3) over ~10 minutes of
|
||||||
|
samples with more than 1 kW and more than 5 A, the power within
|
||||||
|
10 % and the current within 0.5 A. Kept in <state>/ev_phases.json
|
||||||
|
(phases, n: the times seen, at); learned again when the next
|
||||||
|
readings disagree CONFIRM times in a row
|
||||||
|
assumed nothing known: each use takes its own safe side
|
||||||
|
(ASSUMED): the §14a order's current bound 3 phases (a 3-phase
|
||||||
|
charger then never draws above the ordered power), the plan 1
|
||||||
|
phase (it reckons with a slower charger: starts earlier and
|
||||||
|
still meets the departure)
|
||||||
|
|
||||||
|
The current in the ratio is the charger's measured current (the control's
|
||||||
|
`current_measured` sensor) where mapped, else its setpoint (`current`); a
|
||||||
|
car that draws less than the setpoint gives a ratio between the steps,
|
||||||
|
which decides nothing, or a wrong one, which the next sessions put right.
|
||||||
|
"""
|
||||||
|
import json
|
||||||
|
import logging
|
||||||
|
import os
|
||||||
|
|
||||||
|
log = logging.getLogger(__name__)
|
||||||
|
|
||||||
|
ASSUMED = {"order": 3.0, "plan": 1.0}
|
||||||
|
WINDOW_S = 600.0 # ~10 minutes of samples decide
|
||||||
|
MIN_SPAN_S = 540.0
|
||||||
|
MIN_SAMPLES = 5
|
||||||
|
MIN_POWER_W = 1000.0
|
||||||
|
MIN_CURRENT_A = 5.0
|
||||||
|
POWER_STEADY = 0.10 # (max - min) / mean
|
||||||
|
CURRENT_STEADY_A = 0.5
|
||||||
|
TOLERANCE = 0.3
|
||||||
|
CONFIRM = 3 # disagreeing decisions in a row before the learned count changes
|
||||||
|
|
||||||
|
|
||||||
|
def ratio_phases(power_w: float, volts: float, current_a: float) -> int | None:
|
||||||
|
"""1, 2 or 3 when power / (volts x current) is within TOLERANCE of it."""
|
||||||
|
if volts <= 0 or current_a <= 0:
|
||||||
|
return None
|
||||||
|
r = power_w / (volts * current_a)
|
||||||
|
k = round(r)
|
||||||
|
return int(k) if 1 <= k <= 3 and abs(r - k) <= TOLERANCE else None
|
||||||
|
|
||||||
|
|
||||||
|
def steady(samples: list[tuple[float, float, float]]) -> tuple[float, float] | None:
|
||||||
|
"""(mean power, mean current) of samples (t, W, A) that are steady
|
||||||
|
charging over the window, else None."""
|
||||||
|
if len(samples) < MIN_SAMPLES or samples[-1][0] - samples[0][0] < MIN_SPAN_S:
|
||||||
|
return None
|
||||||
|
ps, cs = [s[1] for s in samples], [s[2] for s in samples]
|
||||||
|
if min(ps) <= MIN_POWER_W or min(cs) <= MIN_CURRENT_A:
|
||||||
|
return None
|
||||||
|
mp = sum(ps) / len(ps)
|
||||||
|
if (max(ps) - min(ps)) / mp > POWER_STEADY or max(cs) - min(cs) > CURRENT_STEADY_A:
|
||||||
|
return None
|
||||||
|
return mp, sum(cs) / len(cs)
|
||||||
|
|
||||||
|
|
||||||
|
class EvPhases:
|
||||||
|
def __init__(self, state_dir: str):
|
||||||
|
self.path = os.path.join(state_dir, "ev_phases.json")
|
||||||
|
self.learned: dict[str, dict] = {}
|
||||||
|
self.window: dict[str, list] = {}
|
||||||
|
try:
|
||||||
|
with open(self.path) as f:
|
||||||
|
raw = json.load(f)
|
||||||
|
self.learned = {k: v for k, v in raw.items() if isinstance(v, dict) and v.get("phases") in (1, 2, 3)}
|
||||||
|
except (OSError, ValueError, AttributeError):
|
||||||
|
pass
|
||||||
|
|
||||||
|
def _save(self):
|
||||||
|
tmp = self.path + ".tmp"
|
||||||
|
try:
|
||||||
|
with open(tmp, "w") as f:
|
||||||
|
json.dump(self.learned, f)
|
||||||
|
os.replace(tmp, self.path)
|
||||||
|
except OSError as e:
|
||||||
|
log.warning("ev phases: %s", e)
|
||||||
|
|
||||||
|
def sample(self, cid: str, power_w: float | None, current_a: float | None, volts: float, now: float) -> bool:
|
||||||
|
"""One reading while it charges (or not); True when the learned
|
||||||
|
phase count changed."""
|
||||||
|
w = self.window.setdefault(cid, [])
|
||||||
|
if power_w is None or current_a is None or power_w <= MIN_POWER_W or current_a <= MIN_CURRENT_A:
|
||||||
|
w.clear() # not charging steadily: start again
|
||||||
|
return False
|
||||||
|
w.append((now, float(power_w), float(current_a)))
|
||||||
|
while w and now - w[0][0] > WINDOW_S:
|
||||||
|
w.pop(0)
|
||||||
|
st = steady(w)
|
||||||
|
if st is None:
|
||||||
|
return False
|
||||||
|
k = ratio_phases(st[0], volts, st[1])
|
||||||
|
if k is None:
|
||||||
|
if w[-1][0] - w[0][0] >= WINDOW_S - 1:
|
||||||
|
w.pop(0) # a steady but odd ratio: slide on
|
||||||
|
return False
|
||||||
|
w.clear()
|
||||||
|
return self.decide(cid, k, now)
|
||||||
|
|
||||||
|
def decide(self, cid: str, k: int, now: float) -> bool:
|
||||||
|
cur = self.learned.get(cid)
|
||||||
|
if cur is None:
|
||||||
|
self.learned[cid] = {"phases": k, "n": 1, "at": int(now)}
|
||||||
|
log.info("ev %s: %d phase(s), learned", cid, k)
|
||||||
|
self._save()
|
||||||
|
return True
|
||||||
|
if cur["phases"] == k:
|
||||||
|
cur.update(n=int(cur.get("n", 0)) + 1, at=int(now))
|
||||||
|
cur.pop("against", None)
|
||||||
|
self._save()
|
||||||
|
return False
|
||||||
|
against = cur.get("against") or {}
|
||||||
|
n = int(against.get("n", 0)) + 1 if against.get("phases") == k else 1
|
||||||
|
if n >= CONFIRM:
|
||||||
|
self.learned[cid] = {"phases": k, "n": n, "at": int(now)}
|
||||||
|
log.info("ev %s: %d phase(s) now, learned again (was %d)", cid, k, cur["phases"])
|
||||||
|
self._save()
|
||||||
|
return True
|
||||||
|
cur["against"] = {"phases": k, "n": n}
|
||||||
|
self._save()
|
||||||
|
return False
|
||||||
|
|
||||||
|
def resolve(self, c, col=None) -> tuple[float | None, str]:
|
||||||
|
"""A control's phase count and its source (module docstring); None
|
||||||
|
and "assumed" when nothing says."""
|
||||||
|
p = c.params.get("phases")
|
||||||
|
if p:
|
||||||
|
return float(p), "mapping"
|
||||||
|
ent = c.entities.get("phases")
|
||||||
|
if ent and col is not None:
|
||||||
|
v = col.value(ent)
|
||||||
|
if v is not None and 1 <= round(v) <= 3:
|
||||||
|
return float(round(v)), "device"
|
||||||
|
got = self.learned.get(c.id)
|
||||||
|
if got:
|
||||||
|
return float(got["phases"]), "learned"
|
||||||
|
return None, "assumed"
|
||||||
|
|
||||||
|
def all(self, controls, col=None) -> dict[str, dict]:
|
||||||
|
"""{control id: {"phases": n or None, "source", "plan", "order"}}
|
||||||
|
for the EV controls (plan and order: the count each use takes)."""
|
||||||
|
out = {}
|
||||||
|
for c in controls:
|
||||||
|
if c.kind != "ev":
|
||||||
|
continue
|
||||||
|
n, src = self.resolve(c, col)
|
||||||
|
out[c.id] = {"phases": n, "source": src, "plan": n or ASSUMED["plan"], "order": n or ASSUMED["order"]}
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
|
def words(info: dict) -> str:
|
||||||
|
"""'1 phase, learned', '3 phases, assumed for the grid order (1 for the plan)'."""
|
||||||
|
n, src = info.get("phases"), info.get("source", "")
|
||||||
|
if n:
|
||||||
|
return f"{int(n)} phase{'s' if n != 1 else ''}, {src}"
|
||||||
|
return f"phases unknown: {int(ASSUMED['order'])} assumed for the grid order, {int(ASSUMED['plan'])} for the plan"
|
||||||
@@ -44,13 +44,18 @@ import base64
|
|||||||
import hashlib
|
import hashlib
|
||||||
import json
|
import json
|
||||||
import logging
|
import logging
|
||||||
|
import math
|
||||||
import os
|
import os
|
||||||
import time
|
import time
|
||||||
|
|
||||||
|
from .controls import ev_volts
|
||||||
|
|
||||||
log = logging.getLogger(__name__)
|
log = logging.getLogger(__name__)
|
||||||
|
|
||||||
TOPIC = "cantabile-eebus/gridorder"
|
TOPIC = "cantabile-eebus/gridorder"
|
||||||
STALE_S = 300
|
STALE_S = 300
|
||||||
|
SLOT_S = 900 # the cloud's ledger slots (fleet marketrun.go)
|
||||||
|
ACTION_ENTITY, ACTION_SERVICE = "grid:eebus-lpc", "grid.load_limit"
|
||||||
PENALTY_EUR_KWH = 500.0 # like a relayed emergency (building.py): nobody overrides it
|
PENALTY_EUR_KWH = 500.0 # like a relayed emergency (building.py): nobody overrides it
|
||||||
|
|
||||||
# -- Ed25519 verification (RFC 8032, 5.1.7), pure Python ----------------------
|
# -- Ed25519 verification (RFC 8032, 5.1.7), pure Python ----------------------
|
||||||
@@ -136,6 +141,7 @@ class GridOrders:
|
|||||||
self.order: dict | None = None # the last good order
|
self.order: dict | None = None # the last good order
|
||||||
self.received = 0.0
|
self.received = 0.0
|
||||||
self.error = ""
|
self.error = ""
|
||||||
|
self.reported = None # (order id, limit, slot) last told to the cloud
|
||||||
|
|
||||||
def pinned(self) -> str:
|
def pinned(self) -> str:
|
||||||
try:
|
try:
|
||||||
@@ -198,6 +204,30 @@ class GridOrders:
|
|||||||
o = self.active()
|
o = self.active()
|
||||||
return f"verified:eebus-lpc:{o['control_box']['ski']}:{o['id']}" if o else ""
|
return f"verified:eebus-lpc:{o['control_box']['ski']}:{o['id']}" if o else ""
|
||||||
|
|
||||||
|
def action(self) -> dict | None:
|
||||||
|
"""What the cloud records of the order (an `action`, kind grid
|
||||||
|
limit): once per quarter-hour while it holds (and when it changes),
|
||||||
|
once when it ends. Fleet's market ledger takes a slot with one as
|
||||||
|
under a grid operator's order (higher rank: the contracts' deviations
|
||||||
|
in it are exempt). None: nothing new to tell."""
|
||||||
|
o, now = self.active(), self.clock()
|
||||||
|
if o:
|
||||||
|
key = (o["id"], o.get("limit_w"), int(now) // SLOT_S)
|
||||||
|
if key == self.reported:
|
||||||
|
return None
|
||||||
|
self.reported = key
|
||||||
|
cb = o.get("control_box") or {}
|
||||||
|
until = f", until {time.strftime('%H:%M', time.gmtime(o['until']))} UTC" if o.get("until") else ""
|
||||||
|
return {"v": 1, "at": int(now), "asset": "", "entity": ACTION_ENTITY, "service": ACTION_SERVICE,
|
||||||
|
"value": str(float(o["limit_w"])), "result": "done",
|
||||||
|
"why": f"a grid operator's order: EEBUS LPC {o.get('state', 'limited')}, {float(o['limit_w']):.0f} W, "
|
||||||
|
f"control box {cb.get('ski', '')}, order {o['id']}{until}"[:500]}
|
||||||
|
if self.reported is None:
|
||||||
|
return None
|
||||||
|
self.reported = None
|
||||||
|
return {"v": 1, "at": int(now), "asset": "", "entity": ACTION_ENTITY, "service": ACTION_SERVICE, "value": "",
|
||||||
|
"result": "done", "why": "the grid operator's order ended"}
|
||||||
|
|
||||||
def for_model(self, start: int, step_s: int, steps: int) -> dict:
|
def for_model(self, start: int, step_s: int, steps: int) -> dict:
|
||||||
"""The optimiser's constraint: the controllable consumers' draw from
|
"""The optimiser's constraint: the controllable consumers' draw from
|
||||||
the grid at most limit_w (state["grid_order"])."""
|
the grid at most limit_w (state["grid_order"])."""
|
||||||
@@ -212,11 +242,12 @@ class GridOrders:
|
|||||||
return {"limit_w": float(o["limit_w"]), "from_step": int(a), "to_step": int(b), "penalty": PENALTY_EUR_KWH,
|
return {"limit_w": float(o["limit_w"]), "from_step": int(a), "to_step": int(b), "penalty": PENALTY_EUR_KWH,
|
||||||
"id": o["id"], "proof": self.proof(), "state": o.get("state", "")}
|
"id": o["id"], "proof": self.proof(), "state": o.get("state", "")}
|
||||||
|
|
||||||
def limits(self, controls) -> dict:
|
def limits(self, controls, phases: dict | None = None) -> dict:
|
||||||
"""Grid-level bounds per controllable device (§14a: chargers,
|
"""Grid-level bounds per controllable device (§14a: chargers,
|
||||||
batteries' charging; heat pumps are held by the bridge itself): no
|
batteries' charging; heat pumps are held by the bridge itself): no
|
||||||
single one above the whole limit. {control id: {quantity: (floor,
|
single one above the whole limit. phases: {control id: count} from
|
||||||
limit)}}."""
|
evphases (else the mapping's; unknown: 3, never above the ordered
|
||||||
|
power). {control id: {quantity: (floor, limit)}}."""
|
||||||
o = self.active()
|
o = self.active()
|
||||||
if not o:
|
if not o:
|
||||||
return {}
|
return {}
|
||||||
@@ -224,8 +255,10 @@ class GridOrders:
|
|||||||
out = {}
|
out = {}
|
||||||
for c in controls:
|
for c in controls:
|
||||||
if c.kind == "ev":
|
if c.kind == "ev":
|
||||||
volts = float(c.params.get("voltage", 230)) * float(c.params.get("phases", 3))
|
n = (phases or {}).get(c.id) or c.params.get("phases")
|
||||||
out[c.id] = {"current_a": (None, round(w / volts, 1))}
|
volts = ev_volts({**c.params, "phases": n}, "order")
|
||||||
|
# down to 0.1 A: never above the ordered power (6.1 A x 690 V = 4209 W)
|
||||||
|
out[c.id] = {"current_a": (None, math.floor(w / volts * 10 + 1e-9) / 10)}
|
||||||
elif c.kind == "battery":
|
elif c.kind == "battery":
|
||||||
out[c.id] = {"power_w": (None, w)}
|
out[c.id] = {"power_w": (None, w)}
|
||||||
return out
|
return out
|
||||||
@@ -201,10 +201,6 @@ MESSAGES = {
|
|||||||
"dashboard and to let Cantabile read it once you have given your consent.":
|
"dashboard and to let Cantabile read it once you have given your consent.":
|
||||||
"Geräte aus Home Assistant, die ein Geräteprofil von Cantabile kennt. Nutzen Sie eines mit Cantabile, um es im "
|
"Geräte aus Home Assistant, die ein Geräteprofil von Cantabile kennt. Nutzen Sie eines mit Cantabile, um es im "
|
||||||
"Dashboard von Cantabile zu sehen und, sobald Sie eingewilligt haben, von Cantabile auslesen zu lassen.",
|
"Dashboard von Cantabile zu sehen und, sobald Sie eingewilligt haben, von Cantabile auslesen zu lassen.",
|
||||||
"Used with Cantabile": "Mit Cantabile genutzt",
|
|
||||||
"In Home Assistant, with a profile": "In Home Assistant, mit Profil",
|
|
||||||
"No device in Home Assistant fits a Cantabile profile yet.":
|
|
||||||
"Noch passt kein Gerät in Home Assistant zu einem Profil von Cantabile.",
|
|
||||||
("{n} more in Home Assistant without a profile (not used by Cantabile)",
|
("{n} more in Home Assistant without a profile (not used by Cantabile)",
|
||||||
"{n} more in Home Assistant without a profile (not used by Cantabile)"):
|
"{n} more in Home Assistant without a profile (not used by Cantabile)"):
|
||||||
("{n} weiteres Gerät in Home Assistant ohne Profil (von Cantabile nicht genutzt)",
|
("{n} weiteres Gerät in Home Assistant ohne Profil (von Cantabile nicht genutzt)",
|
||||||
@@ -212,10 +208,6 @@ MESSAGES = {
|
|||||||
"Home Assistant's devices could not be read: {error}": "Die Geräte von Home Assistant konnten nicht gelesen werden: {error}",
|
"Home Assistant's devices could not be read: {error}": "Die Geräte von Home Assistant konnten nicht gelesen werden: {error}",
|
||||||
"Use with Cantabile": "Mit Cantabile nutzen",
|
"Use with Cantabile": "Mit Cantabile nutzen",
|
||||||
"generic profile": "allgemeines Profil",
|
"generic profile": "allgemeines Profil",
|
||||||
"Checked on a device": "An einem Gerät geprüft",
|
|
||||||
"From the maker's documentation, not yet checked on a device":
|
|
||||||
"Aus der Dokumentation des Herstellers, noch nicht an einem Gerät geprüft",
|
|
||||||
"Draft: check the values before you turn reading on": "Entwurf: Prüfen Sie die Werte, bevor Sie das Auslesen einschalten",
|
|
||||||
"nothing": "nichts",
|
"nothing": "nichts",
|
||||||
"battery": "Batterie",
|
"battery": "Batterie",
|
||||||
"heating": "Heizen",
|
"heating": "Heizen",
|
||||||
@@ -259,8 +251,6 @@ MESSAGES = {
|
|||||||
"Eine geschützte Jalousie oder ein geschützter Vorhang wird von Cantabile gar nicht bewegt.",
|
"Eine geschützte Jalousie oder ein geschützter Vorhang wird von Cantabile gar nicht bewegt.",
|
||||||
"Cantabile would read: {values}.": "Cantabile würde auslesen: {values}.",
|
"Cantabile would read: {values}.": "Cantabile würde auslesen: {values}.",
|
||||||
"It could control: {controls}.": "Steuern könnte es: {controls}.",
|
"It could control: {controls}.": "Steuern könnte es: {controls}.",
|
||||||
"Cantabile reads: {values}.": "Cantabile liest aus: {values}.",
|
|
||||||
"It may control: {controls}.": "Steuern darf es: {controls}.",
|
|
||||||
"Not found in Home Assistant: {entities}.": "In Home Assistant nicht gefunden: {entities}.",
|
"Not found in Home Assistant: {entities}.": "In Home Assistant nicht gefunden: {entities}.",
|
||||||
"Read by your own mapping already, so left out here: {values}.":
|
"Read by your own mapping already, so left out here: {values}.":
|
||||||
"Schon von Ihrer eigenen Zuordnung ausgelesen, daher hier weggelassen: {values}.",
|
"Schon von Ihrer eigenen Zuordnung ausgelesen, daher hier weggelassen: {values}.",
|
||||||
@@ -274,7 +264,6 @@ MESSAGES = {
|
|||||||
"Von Cantabile vorgeschlagen (noch nicht geprüft): {values}. Nutzen Sie es mit Cantabile, um es so zu bestätigen, "
|
"Von Cantabile vorgeschlagen (noch nicht geprüft): {values}. Nutzen Sie es mit Cantabile, um es so zu bestätigen, "
|
||||||
"wie dieses Profil es sieht.",
|
"wie dieses Profil es sieht.",
|
||||||
"In your own mapping: {values}. Those stay as they are.": "In Ihrer eigenen Zuordnung: {values}. Diese bleiben, wie sie sind.",
|
"In your own mapping: {values}. Those stay as they are.": "In Ihrer eigenen Zuordnung: {values}. Diese bleiben, wie sie sind.",
|
||||||
"Cantabile may read these values": "Cantabile darf diese Werte auslesen",
|
|
||||||
"Save": "Speichern",
|
"Save": "Speichern",
|
||||||
"Saved.": "Gespeichert.",
|
"Saved.": "Gespeichert.",
|
||||||
"Heating or cooling": "Heizen oder Kühlen",
|
"Heating or cooling": "Heizen oder Kühlen",
|
||||||
@@ -285,8 +274,6 @@ MESSAGES = {
|
|||||||
"By outdoor temperature": "Nach Außentemperatur",
|
"By outdoor temperature": "Nach Außentemperatur",
|
||||||
"This thermostat can heat and cool. Cantabile uses one at a time; the other is never touched.":
|
"This thermostat can heat and cool. Cantabile uses one at a time; the other is never touched.":
|
||||||
"Dieses Thermostat kann heizen und kühlen. Cantabile nutzt immer nur eines; das andere bleibt unberührt.",
|
"Dieses Thermostat kann heizen und kühlen. Cantabile nutzt immer nur eines; das andere bleibt unberührt.",
|
||||||
"By outdoor temperature: heat below (°C)": "Nach Außentemperatur: heizen unter (°C)",
|
|
||||||
"cool above (°C)": "kühlen über (°C)",
|
|
||||||
"Between the two it stays as it is, so it does not switch back and forth on a mild day.":
|
"Between the two it stays as it is, so it does not switch back and forth on a mild day.":
|
||||||
"Dazwischen bleibt es, wie es ist, damit es an einem milden Tag nicht hin und her schaltet.",
|
"Dazwischen bleibt es, wie es ist, damit es an einem milden Tag nicht hin und her schaltet.",
|
||||||
"Protection": "Schutz",
|
"Protection": "Schutz",
|
||||||
@@ -307,10 +294,8 @@ MESSAGES = {
|
|||||||
"the grid operator": "der Netzbetreiber",
|
"the grid operator": "der Netzbetreiber",
|
||||||
"the metering operator": "der Messstellenbetreiber",
|
"the metering operator": "der Messstellenbetreiber",
|
||||||
"the energy community's operator": "der Betreiber der Energiegemeinschaft",
|
"the energy community's operator": "der Betreiber der Energiegemeinschaft",
|
||||||
"Remove": "Entfernen",
|
|
||||||
"Cantabile stops using it. Home Assistant keeps the device as it is.":
|
"Cantabile stops using it. Home Assistant keeps the device as it is.":
|
||||||
"Cantabile nutzt es nicht mehr. Home Assistant behält das Gerät, wie es ist.",
|
"Cantabile nutzt es nicht mehr. Home Assistant behält das Gerät, wie es ist.",
|
||||||
"Stop using it with Cantabile": "Nicht mehr mit Cantabile nutzen",
|
|
||||||
"Cantabile no longer uses it.": "Cantabile nutzt es nicht mehr.",
|
"Cantabile no longer uses it.": "Cantabile nutzt es nicht mehr.",
|
||||||
"Cantabile could not ask Home Assistant who you are ({error}).":
|
"Cantabile could not ask Home Assistant who you are ({error}).":
|
||||||
"Cantabile konnte Home Assistant nicht fragen, wer Sie sind ({error}).",
|
"Cantabile konnte Home Assistant nicht fragen, wer Sie sind ({error}).",
|
||||||
@@ -335,8 +320,6 @@ MESSAGES = {
|
|||||||
"First give your consent in the add-on's configuration (Settings, Add-ons, Cantabile Edge Agent, Configuration).":
|
"First give your consent in the add-on's configuration (Settings, Add-ons, Cantabile Edge Agent, Configuration).":
|
||||||
"Geben Sie zuerst Ihre Einwilligung in der Konfiguration des Add-ons (Einstellungen, Add-ons, Cantabile Edge "
|
"Geben Sie zuerst Ihre Einwilligung in der Konfiguration des Add-ons (Einstellungen, Add-ons, Cantabile Edge "
|
||||||
"Agent, Konfiguration).",
|
"Agent, Konfiguration).",
|
||||||
"Cantabile may control it ({controls}), within your limits":
|
|
||||||
"Cantabile darf es steuern ({controls}), innerhalb Ihrer Grenzen",
|
|
||||||
"Control also needs your consent to control devices in the add-on's configuration.":
|
"Control also needs your consent to control devices in the add-on's configuration.":
|
||||||
"Zum Steuern braucht es außerdem Ihre Einwilligung zum Steuern von Geräten in der Konfiguration des Add-ons.",
|
"Zum Steuern braucht es außerdem Ihre Einwilligung zum Steuern von Geräten in der Konfiguration des Add-ons.",
|
||||||
"Saved. Cantabile starts again to apply it (a few seconds).":
|
"Saved. Cantabile starts again to apply it (a few seconds).":
|
||||||
@@ -347,4 +330,98 @@ MESSAGES = {
|
|||||||
"bis Sie sie unten einschalten.",
|
"bis Sie sie unten einschalten.",
|
||||||
"Only an administrator of Home Assistant can use this page.":
|
"Only an administrator of Home Assistant can use this page.":
|
||||||
"Nur ein Administrator von Home Assistant kann diese Seite nutzen.",
|
"Nur ein Administrator von Home Assistant kann diese Seite nutzen.",
|
||||||
|
'room temperature': 'Raumtemperatur',
|
||||||
|
'humidity': 'Luftfeuchte',
|
||||||
|
'setpoint': 'Solltemperatur',
|
||||||
|
'heat/cool range': 'Heiz-/Kühlbereich',
|
||||||
|
'heating/cooling state': 'Heiz-/Kühlzustand',
|
||||||
|
'heating state': 'Heizzustand',
|
||||||
|
'cooling state': 'Kühlzustand',
|
||||||
|
'position': 'Stellung',
|
||||||
|
'tilt': 'Neigung',
|
||||||
|
'solar power': 'Solarleistung',
|
||||||
|
'solar energy': 'Solarertrag',
|
||||||
|
'grid power': 'Netzleistung',
|
||||||
|
'power from the grid': 'Bezug aus dem Netz',
|
||||||
|
'power to the grid': 'Einspeisung ins Netz',
|
||||||
|
'energy from the grid': 'Energie aus dem Netz',
|
||||||
|
'energy to the grid': 'Energie ins Netz',
|
||||||
|
'battery power': 'Batterieleistung',
|
||||||
|
'battery charge': 'Batterieladestand',
|
||||||
|
'energy charged': 'geladene Energie',
|
||||||
|
'energy discharged': 'entladene Energie',
|
||||||
|
'home consumption': 'Hausverbrauch',
|
||||||
|
'home energy': 'Hausenergie',
|
||||||
|
'heat pump power': 'Leistung der Wärmepumpe',
|
||||||
|
'heat pump energy': 'Energie der Wärmepumpe',
|
||||||
|
'flow temperature': 'Vorlauftemperatur',
|
||||||
|
'hot water temperature': 'Warmwassertemperatur',
|
||||||
|
'outdoor temperature': 'Außentemperatur',
|
||||||
|
'outdoor humidity': 'Außenluftfeuchte',
|
||||||
|
'gas': 'Gas',
|
||||||
|
'charging power': 'Ladeleistung',
|
||||||
|
'power': 'Leistung',
|
||||||
|
'energy': 'Energie',
|
||||||
|
'set to {v}': 'eingestellt auf {v}',
|
||||||
|
'set to {low}–{high}': 'eingestellt auf {low}–{high}',
|
||||||
|
'solar {v}': 'Solar {v}',
|
||||||
|
'battery {v}': 'Batterie {v}',
|
||||||
|
'grid {v}': 'Netz {v}',
|
||||||
|
'home {v}': 'Haus {v}',
|
||||||
|
'charging {v}': 'lädt mit {v}',
|
||||||
|
'heat pump {v}': 'Wärmepumpe {v}',
|
||||||
|
'flow {v}': 'Vorlauf {v}',
|
||||||
|
'outside {v}': 'außen {v}',
|
||||||
|
'humidity {v}': 'Luftfeuchte {v}',
|
||||||
|
'{v} open': '{v} offen',
|
||||||
|
'idle': 'in Ruhe',
|
||||||
|
'checked': 'geprüft',
|
||||||
|
'Checked on a device: its values are known to be right.':
|
||||||
|
'An einem Gerät geprüft: Seine Werte stimmen nachweislich.',
|
||||||
|
'untested': 'ungeprüft',
|
||||||
|
"Made from the maker's documentation, not yet checked on a device. Look at its values before you turn reading on.":
|
||||||
|
'Nach der Dokumentation des Herstellers erstellt, noch nicht an einem Gerät geprüft. Sehen Sie sich seine Werte an, bevor Sie das Auslesen einschalten.',
|
||||||
|
'draft': 'Entwurf',
|
||||||
|
'A draft profile: check the values before you turn reading on.':
|
||||||
|
'Ein Profil im Entwurf: Prüfen Sie die Werte, bevor Sie das Auslesen einschalten.',
|
||||||
|
'Reading': 'Auslesen',
|
||||||
|
'Cantabile may read these values.': 'Cantabile darf diese Werte auslesen.',
|
||||||
|
'Reading and control': 'Auslesen und Steuern',
|
||||||
|
'What Cantabile reads': 'Was Cantabile ausliest',
|
||||||
|
'Forecast': 'Wettervorhersage',
|
||||||
|
'{what} ({room})': '{what} ({room})',
|
||||||
|
'In use': 'In Betrieb',
|
||||||
|
'reading on': 'Auslesen an',
|
||||||
|
'Added': 'Hinzugefügt',
|
||||||
|
'reading off': 'Auslesen aus',
|
||||||
|
'Control': 'Steuern',
|
||||||
|
'Cantabile may control it ({controls}), within your limits.':
|
||||||
|
'Cantabile darf es steuern ({controls}), innerhalb Ihrer Grenzen.',
|
||||||
|
'{control} control': 'Steuerung {control}',
|
||||||
|
'control on': 'Steuern an',
|
||||||
|
'control off': 'Steuern aus',
|
||||||
|
'sealed': 'versiegelt',
|
||||||
|
'Add a device': 'Ein Gerät hinzufügen',
|
||||||
|
'On': 'An',
|
||||||
|
'Off': 'Aus',
|
||||||
|
'Heat below (°C)': 'Heizen unter (°C)',
|
||||||
|
'Cool above (°C)': 'Kühlen über (°C)',
|
||||||
|
'Devices in Home Assistant you can add': 'Geräte in Home Assistant, die Sie hinzufügen können',
|
||||||
|
'This device does not report: {values}.': 'Dieses Gerät meldet nicht: {values}.',
|
||||||
|
'Remove from Cantabile': 'Aus Cantabile entfernen',
|
||||||
|
'Yes, remove it': 'Ja, entfernen',
|
||||||
|
'No device is used with Cantabile yet. Add one below.':
|
||||||
|
'Noch kein Gerät wird mit Cantabile genutzt. Fügen Sie unten eines hinzu.',
|
||||||
|
'Turn off': 'Ausschalten',
|
||||||
|
'Turn on': 'Einschalten',
|
||||||
|
('{n} device in use with Cantabile', '{n} devices in use with Cantabile'):
|
||||||
|
('{n} Gerät mit Cantabile in Betrieb', '{n} Geräte mit Cantabile in Betrieb'),
|
||||||
|
'More information': 'Mehr Informationen',
|
||||||
|
'No other device in Home Assistant fits a Cantabile profile.':
|
||||||
|
'Kein weiteres Gerät in Home Assistant passt zu einem Cantabile-Profil.',
|
||||||
|
'Reads: {values}': 'Liest: {values}',
|
||||||
|
'Controls: {controls}': 'Steuert: {controls}',
|
||||||
|
'heat delivered (thermal)': 'gelieferte Wärme (thermisch)',
|
||||||
|
'heat energy (thermal)': 'Wärmemenge (thermisch)',
|
||||||
|
'heat {v} (thermal)': 'Wärme {v} (thermisch)',
|
||||||
}
|
}
|
||||||
@@ -2,7 +2,9 @@
|
|||||||
"""Inputs for the optimiser: the latest states of the controls' and the
|
"""Inputs for the optimiser: the latest states of the controls' and the
|
||||||
inputs' entities (presence, temperatures, humidity, outside temperature,
|
inputs' entities (presence, temperatures, humidity, outside temperature,
|
||||||
sun, weather), a short local history of load and PV (the fallback when no
|
sun, weather), a short local history of load and PV (the fallback when no
|
||||||
model bundle says), and the 15-minute model state for the horizon.
|
model bundle says), and the 15-minute model state for the horizon. A
|
||||||
|
room's R and C: the mapping's, else the model bundle's (its rooms), else
|
||||||
|
the defaults; sources.rooms says which per control.
|
||||||
|
|
||||||
None of this leaves the site; only the plan does (controller.py).
|
None of this leaves the site; only the plan does (controller.py).
|
||||||
|
|
||||||
@@ -138,10 +140,36 @@ def _hourly(forecast: list[dict], key: str, start: int, steps: int) -> list[floa
|
|||||||
return out
|
return out
|
||||||
|
|
||||||
|
|
||||||
def _series(name, start, bundles, history, tz, now_value, default):
|
def watts(col: Collector, eid: str) -> float | None:
|
||||||
s = bundles.forecast(name, start, STEP_S, STEPS, tz) if bundles else None
|
"""A power sensor's value in W (HA's kW converted)."""
|
||||||
|
v = col.value(eid)
|
||||||
|
if v is not None and col.attr(eid, "unit_of_measurement") == "kW":
|
||||||
|
v *= 1000.0
|
||||||
|
return v
|
||||||
|
|
||||||
|
|
||||||
|
def base_load(col: Collector, inputs) -> float | None:
|
||||||
|
"""The house's load without the devices the plan plans itself (Finding
|
||||||
|
A2-a): load_power less the planned devices' own meters
|
||||||
|
(inputs.controlled_power: heat pump, A/C, charger), never below 0. A
|
||||||
|
device meter without a value counts 0 (a charger's sensor goes
|
||||||
|
unavailable while idle). None while the load has none."""
|
||||||
|
eids = [inputs.load_power] if isinstance(inputs.load_power, str) else list(inputs.load_power or [])
|
||||||
|
vals = [watts(col, e) for e in eids if e]
|
||||||
|
if not vals or None in vals:
|
||||||
|
return None
|
||||||
|
ctl = sum(watts(col, e) or 0.0 for e in getattr(inputs, "controlled_power", None) or [])
|
||||||
|
return max(0.0, sum(vals) - ctl)
|
||||||
|
|
||||||
|
|
||||||
|
def _series(name, start, bundles, history, tz, now_value, default, model_names=None):
|
||||||
|
"""A series for the horizon: the model bundle's (the first of
|
||||||
|
model_names it has, default name), else the same quarter hour 1 or 2
|
||||||
|
days back, else the value now, else the default."""
|
||||||
|
for m in (model_names if model_names is not None else (name,)):
|
||||||
|
s = bundles.forecast(m, start, STEP_S, STEPS, tz) if bundles else None
|
||||||
if s is not None:
|
if s is not None:
|
||||||
return s, "model"
|
return s, "model" if m == name else f"model ({m})"
|
||||||
out, have = [], 0
|
out, have = [], 0
|
||||||
for k in range(STEPS):
|
for k in range(STEPS):
|
||||||
t = start + k * STEP_S
|
t = start + k * STEP_S
|
||||||
@@ -228,15 +256,28 @@ def cover_position(col: Collector, ent: str) -> float | None:
|
|||||||
def model_state(now: float, controls, inputs, col: Collector, bundles, history, tz: str,
|
def model_state(now: float, controls, inputs, col: Collector, bundles, history, tz: str,
|
||||||
weather_forecast: list[dict] | None, extra_limits: dict | None = None,
|
weather_forecast: list[dict] | None, extra_limits: dict | None = None,
|
||||||
occupied_hours=(6, 22), building: dict | None = None, location: dict | None = None,
|
occupied_hours=(6, 22), building: dict | None = None, location: dict | None = None,
|
||||||
shade_ctx: dict | None = None, grid_order: dict | None = None) -> dict:
|
shade_ctx: dict | None = None, grid_order: dict | None = None,
|
||||||
|
grid_max_w: float | None = None, ev_phases: dict | None = None) -> dict:
|
||||||
"""The 48 h, 15-minute input for the optimiser (JSON: it runs in a
|
"""The 48 h, 15-minute input for the optimiser (JSON: it runs in a
|
||||||
subprocess). location: the site's latitude and longitude (HA's
|
subprocess). location: the site's latitude and longitude (HA's
|
||||||
configuration); shade_ctx: per cover control its room (temp_c,
|
configuration); shade_ctx: per cover control its room (temp_c,
|
||||||
setpoint_c, season: shades.py)."""
|
setpoint_c, season: shades.py); grid_max_w: the site's connection (W,
|
||||||
|
config; the optimiser's default without it); ev_phases: per EV control
|
||||||
|
its phase count and source (evphases.EvPhases.all), else the mapping's."""
|
||||||
start = int(now // STEP_S * STEP_S)
|
start = int(now // STEP_S * STEP_S)
|
||||||
zone = ZoneInfo(tz or "UTC")
|
zone = ZoneInfo(tz or "UTC")
|
||||||
prices = bundles.prices(start, STEP_S, STEPS, now)
|
prices = bundles.prices(start, STEP_S, STEPS, now)
|
||||||
load, load_src = _series("load_w", start, bundles, history, tz, col.total(inputs.load_power), 500.0)
|
# the base load: the house without the planned devices (Finding A2-a), so
|
||||||
|
# the plan, the building's shift and the grid order's base (optimizer)
|
||||||
|
# do not count them twice. The model's base_load_w is that; its load_w
|
||||||
|
# (load.power as metered) is too only where no planned device has a meter
|
||||||
|
# inside it, else the history of the base load stands in.
|
||||||
|
ctl = getattr(inputs, "controlled_power", None) or []
|
||||||
|
load, load_src = _series("load_w", start, bundles, history, tz, base_load(col, inputs), 500.0,
|
||||||
|
("base_load_w",) if ctl else ("base_load_w", "load_w"))
|
||||||
|
if ctl and not load_src.startswith("model") and bundles and \
|
||||||
|
bundles.forecast("load_w", start, STEP_S, 1, tz) is not None:
|
||||||
|
load_src += " (the model's load_w includes the planned devices: not used)"
|
||||||
pv, pv_src = _series("pv_w", start, bundles, history, tz, None, 0.0)
|
pv, pv_src = _series("pv_w", start, bundles, history, tz, None, 0.0)
|
||||||
t_out = _hourly(weather_forecast or [], "temperature", start, STEPS)
|
t_out = _hourly(weather_forecast or [], "temperature", start, STEPS)
|
||||||
t_src = "weather forecast"
|
t_src = "weather forecast"
|
||||||
@@ -270,7 +311,8 @@ def model_state(now: float, controls, inputs, col: Collector, bundles, history,
|
|||||||
continue
|
continue
|
||||||
h = datetime.fromtimestamp(start + k * STEP_S, timezone.utc).astimezone(zone).hour
|
h = datetime.fromtimestamp(start + k * STEP_S, timezone.utc).astimezone(zone).hour
|
||||||
occupied.append(1 if occupied_hours[0] <= h < occupied_hours[1] else 0)
|
occupied.append(1 if occupied_hours[0] <= h < occupied_hours[1] else 0)
|
||||||
devices = []
|
devices, rooms_src, phases_src = [], {}, {}
|
||||||
|
one_room = sum(c.kind in ("heating", "cooling") for c in controls) == 1
|
||||||
for c in controls:
|
for c in controls:
|
||||||
if hasattr(c, "learn_range"):
|
if hasattr(c, "learn_range"):
|
||||||
c.learn_range(col) # a climate's own min_temp..max_temp
|
c.learn_range(col) # a climate's own min_temp..max_temp
|
||||||
@@ -278,18 +320,34 @@ def model_state(now: float, controls, inputs, col: Collector, bundles, history,
|
|||||||
for q in _quantities(c):
|
for q in _quantities(c):
|
||||||
b = c.bounds(q, (extra_limits or {}).get(c.id))
|
b = c.bounds(q, (extra_limits or {}).get(c.id))
|
||||||
bounds[q] = [b.lo, b.hi, b.lo_by, b.hi_by]
|
bounds[q] = [b.lo, b.hi, b.lo_by, b.hi_by]
|
||||||
devices.append({"id": c.id, "kind": c.kind, "params": {k: c.p(k) for k in _param_names(c)},
|
params = {k: c.p(k) for k in _param_names(c)}
|
||||||
|
if c.kind == "ev":
|
||||||
|
# the count from the best evidence (evphases.py); None: the plan assumes 1
|
||||||
|
info = (ev_phases or {}).get(c.id) or \
|
||||||
|
({"phases": float(c.params["phases"]), "source": "mapping"} if c.params.get("phases") else
|
||||||
|
{"phases": None, "source": "assumed"})
|
||||||
|
params["phases"] = info["phases"]
|
||||||
|
phases_src[c.id] = {"phases": info["phases"], "source": info["source"]}
|
||||||
|
if c.kind in ("heating", "cooling"):
|
||||||
|
rooms_src[c.id] = _room_rc(c, params, bundles, one_room, now)
|
||||||
|
devices.append({"id": c.id, "kind": c.kind, "params": params,
|
||||||
"state": device_state(c, col, now), "bounds": bounds,
|
"state": device_state(c, col, now), "bounds": bounds,
|
||||||
"channels": sorted(c.writable())})
|
"channels": sorted(c.writable())})
|
||||||
clouds = _hourly(weather_forecast or [], "cloud_coverage", start, STEPS)
|
clouds = _hourly(weather_forecast or [], "cloud_coverage", start, STEPS)
|
||||||
sky = [max(0.0, min(1.0, 1 - c / 100.0)) for c in clouds] if clouds else [1.0] * STEPS
|
sky = [max(0.0, min(1.0, 1 - c / 100.0)) for c in clouds] if clouds else [1.0] * STEPS
|
||||||
|
ghi, ghi_src = irradiance(start, location, sky, sun if peak > 100 else None)
|
||||||
out = {"v": 1, "start": start, "step_s": STEP_S, "steps": STEPS, "tz": tz,
|
out = {"v": 1, "start": start, "step_s": STEP_S, "steps": STEPS, "tz": tz,
|
||||||
"price_import": prices.import_ct, "price_export": prices.export_ct, "price_note": prices.note,
|
"price_import": prices.import_ct, "price_export": prices.export_ct, "price_note": prices.note,
|
||||||
"load_w": load, "pv_w": pv, "t_out": t_out, "sun": sun, "occupied": occupied, "sky": sky,
|
"load_w": load, "pv_w": pv, "t_out": t_out, "sun": sun, "occupied": occupied, "sky": sky,
|
||||||
"location": location or {},
|
"ghi_w_m2": ghi, "location": location or {},
|
||||||
"sources": {"load": load_src, "pv": pv_src, "t_out": t_src, "model": bundles.model_id(),
|
"sources": {"load": load_src, "pv": pv_src, "t_out": t_src, "model": bundles.model_id(),
|
||||||
"sky": "weather forecast" if clouds else "clear"},
|
"sky": "weather forecast" if clouds else "clear", "rooms": rooms_src, "ghi": ghi_src,
|
||||||
"devices": devices, "building": building or {}, "grid_order": grid_order or {}}
|
"ev_phases": phases_src},
|
||||||
|
"devices": devices, "building": building or {}, "grid_order": grid_order or {},
|
||||||
|
# the market's contracts in force as sources and sinks (shadow, the market's step 2)
|
||||||
|
"market": bundles.market_for_model(start, STEP_S, STEPS, now) if hasattr(bundles, "market_for_model") else []}
|
||||||
|
if grid_max_w:
|
||||||
|
out["grid_max_w"] = float(grid_max_w)
|
||||||
# a shade's moves by rules on the sun and its room (shades.py); the
|
# a shade's moves by rules on the sun and its room (shades.py); the
|
||||||
# optimiser takes them as they are
|
# optimiser takes them as they are
|
||||||
from . import shades
|
from . import shades
|
||||||
@@ -299,6 +357,58 @@ def model_state(now: float, controls, inputs, col: Collector, bundles, history,
|
|||||||
return out
|
return out
|
||||||
|
|
||||||
|
|
||||||
|
def irradiance(start: int, location: dict | None, sky: list[float],
|
||||||
|
pv_sun: list[float] | None) -> tuple[list[float], str]:
|
||||||
|
"""Global irradiance per step (W/m²) for a room's fitted sun
|
||||||
|
(solar_m2): Haurwitz's clear sky, 1098 cos z exp(-0.057 / cos z), at
|
||||||
|
the step's middle where the site's location is known, times the sky
|
||||||
|
(1 - the forecast's cloud cover); else the PV forecast scaled to its
|
||||||
|
peak (pv_sun, A1.2) times 1000 W/m², a rough stand-in; else none (the
|
||||||
|
sun's elevation now, held, would shine all night)."""
|
||||||
|
from .shades import sun_position
|
||||||
|
lat, lon = (location or {}).get("latitude"), (location or {}).get("longitude")
|
||||||
|
if lat is None or lon is None:
|
||||||
|
if pv_sun is None:
|
||||||
|
return [0.0] * STEPS, "none (no location, no PV forecast)"
|
||||||
|
return [1000.0 * max(0.0, x) for x in pv_sun], "PV forecast"
|
||||||
|
out = []
|
||||||
|
for k in range(STEPS):
|
||||||
|
elev, _ = sun_position(start + k * STEP_S + STEP_S / 2, float(lat), float(lon))
|
||||||
|
cz = math.sin(math.radians(elev))
|
||||||
|
clear = 1098.0 * cz * math.exp(-0.057 / cz) if cz > 0.01 else 0.0
|
||||||
|
out.append(round(clear * max(0.0, min(1.0, sky[k] if k < len(sky) else 1.0)), 1))
|
||||||
|
return out, "clear sky x the sky"
|
||||||
|
|
||||||
|
|
||||||
|
def _room_rc(c, params: dict, bundles, only_one: bool, now: float) -> str:
|
||||||
|
"""A heating or cooling control's R and C: the mapping's own, else the
|
||||||
|
model's room (bundles.room_rc), else the defaults. A room fitted against
|
||||||
|
the electric power: C * cop and R / cop (the same RC; the optimiser's
|
||||||
|
heat is cop * P). Into params; where they came from."""
|
||||||
|
if "r_k_per_kw" in c.params or "c_kwh_per_k" in c.params:
|
||||||
|
return "mapping"
|
||||||
|
get = getattr(bundles, "room_rc", None)
|
||||||
|
rc = get(c.id, str(c.params.get("area") or ""), only_one, now) if get else None
|
||||||
|
if rc is None:
|
||||||
|
return "defaults"
|
||||||
|
r, cap = rc["r_k_per_kw"], rc["c_kwh_per_k"]
|
||||||
|
gain, solar = rc.get("gain_w") or 0.0, rc.get("solar_m2") or 0.0
|
||||||
|
cop = number(params.get("cop")) or 1.0
|
||||||
|
if rc.get("power") == "electric" and cop > 0:
|
||||||
|
# fitted in electric equivalents: the heat is cop times (like C)
|
||||||
|
r, cap = r / cop, cap * cop
|
||||||
|
gain = [g * cop for g in gain] if isinstance(gain, list) else gain * cop
|
||||||
|
solar *= cop
|
||||||
|
params["r_k_per_kw"], params["c_kwh_per_k"] = r, cap
|
||||||
|
# the fit's internal gain and sun (Finding B6-a): R and C were fitted
|
||||||
|
# with them; the mapping's own, where it sets them, win
|
||||||
|
if "internal_gain_w" not in c.params:
|
||||||
|
params["internal_gain_w"] = gain
|
||||||
|
if "solar_m2" not in c.params:
|
||||||
|
params["solar_m2"] = solar
|
||||||
|
return "model"
|
||||||
|
|
||||||
|
|
||||||
def _quantities(c) -> list[str]:
|
def _quantities(c) -> list[str]:
|
||||||
return {"battery": ["soc_pct", "power_w"], "heating": ["temp_c"], "cooling": ["temp_c"],
|
return {"battery": ["soc_pct", "power_w"], "heating": ["temp_c"], "cooling": ["temp_c"],
|
||||||
"ev": ["current_a"], "cover": ["position_pct"]}[c.kind]
|
"ev": ["current_a"], "cover": ["position_pct"]}[c.kind]
|
||||||
|
|||||||
@@ -53,7 +53,27 @@ def _hash(eid: str) -> str:
|
|||||||
return "h" + hashlib.sha256(eid.encode()).hexdigest()[:12]
|
return "h" + hashlib.sha256(eid.encode()).hexdigest()[:12]
|
||||||
|
|
||||||
|
|
||||||
def build(mapping, registries: dict, specs: dict, policy: dict, now: float) -> dict:
|
def battery_ratings(controls) -> dict:
|
||||||
|
"""A mapping's battery's ratings (an installer's mapping, an HA add-on
|
||||||
|
site: no devices tool's specs): the capacity and power its control's
|
||||||
|
params state (battery_kwh, battery_kw), never the defaults (a guess is
|
||||||
|
no rating). The cloud's planners (tenant power, Energy Sharing) read
|
||||||
|
them."""
|
||||||
|
kwh = kw = 0.0
|
||||||
|
for c in {c.id: c for c in controls if c.kind == "battery"}.values():
|
||||||
|
if "capacity_wh" in c.params:
|
||||||
|
kwh += float(c.params["capacity_wh"]) / 1000
|
||||||
|
if "max_charge_w" in c.params or "max_discharge_w" in c.params:
|
||||||
|
kw += max(float(c.p("max_charge_w")), float(c.p("max_discharge_w"))) / 1000
|
||||||
|
out = {"battery_kwh": round(kwh, 3)} if kwh > 0 else {}
|
||||||
|
if out and kw > 0:
|
||||||
|
out["battery_kw"] = round(kw, 3)
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
|
def build(mapping, registries: dict, specs: dict, policy: dict, now: float, ev_phases: dict | None = None) -> dict:
|
||||||
|
"""ev_phases: per EV control its phase count and source (evphases.py),
|
||||||
|
told on the device of the control ("1 phase, learned" in the console)."""
|
||||||
ents = {e["entity_id"]: e for e in registries.get("entities") or []}
|
ents = {e["entity_id"]: e for e in registries.get("entities") or []}
|
||||||
devs = {d["id"]: d for d in registries.get("devices") or []}
|
devs = {d["id"]: d for d in registries.get("devices") or []}
|
||||||
asset_of = {a.entity: a.asset for a in mapping.assets}
|
asset_of = {a.entity: a.asset for a in mapping.assets}
|
||||||
@@ -65,6 +85,7 @@ def build(mapping, registries: dict, specs: dict, policy: dict, now: float) -> d
|
|||||||
"""The readings that are assumed, not measured (mapping.py)."""
|
"""The readings that are assumed, not measured (mapping.py)."""
|
||||||
return sorted({a.asset for e in eids for a in of_entity.get(e, []) if getattr(a, "assumed", False)})
|
return sorted({a.asset for e in eids for a in of_entity.get(e, []) if getattr(a, "assumed", False)})
|
||||||
control_of = {}
|
control_of = {}
|
||||||
|
controls = {c.id: c for c in mapping.controls}
|
||||||
for c in mapping.controls:
|
for c in mapping.controls:
|
||||||
for e in c.entities.values():
|
for e in c.entities.values():
|
||||||
control_of.setdefault(e, c.id)
|
control_of.setdefault(e, c.id)
|
||||||
@@ -102,13 +123,18 @@ def build(mapping, registries: dict, specs: dict, policy: dict, now: float) -> d
|
|||||||
continue
|
continue
|
||||||
d = (ents.get(eid) or {}).get("device_id")
|
d = (ents.get(eid) or {}).get("device_id")
|
||||||
groups.setdefault(d or "", []).append(eid)
|
groups.setdefault(d or "", []).append(eid)
|
||||||
for d, eids in sorted(groups.items()):
|
# a control's ratings once (on its first device); not where the devices tool's spec has it (its own ratings)
|
||||||
|
rated: set[str] = {c for s in (specs.get("devices") or {}).values() for c in s.get("controls") or []}
|
||||||
|
for d, eids in sorted(groups.items(), key=lambda kv: (not kv[0], kv[0])):
|
||||||
hd = devs.get(d) or {}
|
hd = devs.get(d) or {}
|
||||||
if not d:
|
mine = {control_of[e] for e in eids if e in control_of}
|
||||||
continue # entities without a device: nothing to tell
|
ratings = battery_ratings([controls[i] for i in sorted(mine - rated)])
|
||||||
out.append({"id": "ha:" + hashlib.sha256(d.encode()).hexdigest()[:12], "source": "ha",
|
rated |= mine
|
||||||
|
if not d and not ratings:
|
||||||
|
continue # entities without a device: nothing to tell but a battery's ratings
|
||||||
|
out.append({"id": "ha:" + (hashlib.sha256(d.encode()).hexdigest()[:12] if d else "mapping"), "source": "ha",
|
||||||
**{k: hd.get(k) or "" for k in VERSION_KEYS}, **_eebus(hd),
|
**{k: hd.get(k) or "" for k in VERSION_KEYS}, **_eebus(hd),
|
||||||
"category": "", "profile": "", "profile_version": "", "ratings": {},
|
"category": "", "profile": "", "profile_version": "", "ratings": ratings,
|
||||||
"assets": sorted({asset_of[e] for e in eids if e in asset_of}),
|
"assets": sorted({asset_of[e] for e in eids if e in asset_of}),
|
||||||
"assumed": assumed_of(eids),
|
"assumed": assumed_of(eids),
|
||||||
"controls": sorted({control_of[e] for e in eids if e in control_of}),
|
"controls": sorted({control_of[e] for e in eids if e in control_of}),
|
||||||
@@ -121,6 +147,11 @@ def build(mapping, registries: dict, specs: dict, policy: dict, now: float) -> d
|
|||||||
if kind == "entity":
|
if kind == "entity":
|
||||||
t = f"asset:{asset_of[name]}" if name in asset_of else f"entity:{_hash(name)}"
|
t = f"asset:{asset_of[name]}" if name in asset_of else f"entity:{_hash(name)}"
|
||||||
prot.append({"target": t, **{k: e.get(k) for k in ("level", "custodian", "source", "set_by", "role", "at", "why")}})
|
prot.append({"target": t, **{k: e.get(k) for k in ("level", "custodian", "source", "set_by", "role", "at", "why")}})
|
||||||
|
for d in out:
|
||||||
|
ph = {c: {"phases": ev_phases[c]["phases"], "source": ev_phases[c]["source"]}
|
||||||
|
for c in d.get("controls") or [] if c in (ev_phases or {})}
|
||||||
|
if ph:
|
||||||
|
d["ev_phases"] = ph
|
||||||
return {"v": 1, "made": int(now), "devices": out, "protection": prot}
|
return {"v": 1, "made": int(now), "devices": out, "protection": prot}
|
||||||
|
|
||||||
|
|
||||||
@@ -132,6 +163,8 @@ class Inventory:
|
|||||||
self.policy = policy or Policy(cfg.state_dir, cfg.site_id, clock)
|
self.policy = policy or Policy(cfg.state_dir, cfg.site_id, clock)
|
||||||
self.specs_path = os.path.join(cfg.state_dir, "devices-specs.json")
|
self.specs_path = os.path.join(cfg.state_dir, "devices-specs.json")
|
||||||
self.sent_digest, self.sent_at = "", 0.0
|
self.sent_digest, self.sent_at = "", 0.0
|
||||||
|
self.waiting = False # the link was not connected: try again soon (agent.inventory_loop)
|
||||||
|
self.ev_phases = None # () -> per EV control its phases and source (the controller's; agent.py)
|
||||||
|
|
||||||
def specs(self) -> dict:
|
def specs(self) -> dict:
|
||||||
try:
|
try:
|
||||||
@@ -147,6 +180,12 @@ class Inventory:
|
|||||||
pub = getattr(self.sink, "publish", None)
|
pub = getattr(self.sink, "publish", None)
|
||||||
if pub is None or client is None:
|
if pub is None or client is None:
|
||||||
return False
|
return False
|
||||||
|
# The link drops what comes before its NATS connection is up (at
|
||||||
|
# start the agent reaches HA first): not sent then, tried again.
|
||||||
|
cloud = getattr(self.sink, "cloud", None)
|
||||||
|
self.waiting = cloud is not None and not await cloud()
|
||||||
|
if self.waiting:
|
||||||
|
return False
|
||||||
try:
|
try:
|
||||||
reg = await client.registries()
|
reg = await client.registries()
|
||||||
except Exception as e:
|
except Exception as e:
|
||||||
@@ -155,7 +194,8 @@ class Inventory:
|
|||||||
now = self.clock()
|
now = self.clock()
|
||||||
if self.sent_at and now - self.sent_at < MIN_GAP_S:
|
if self.sent_at and now - self.sent_at < MIN_GAP_S:
|
||||||
return False
|
return False
|
||||||
inv = build(self.mapping, reg, self.specs(), self.policy.entries(), now)
|
inv = build(self.mapping, reg, self.specs(), self.policy.entries(), now,
|
||||||
|
self.ev_phases() if self.ev_phases else None)
|
||||||
body = {k: v for k, v in inv.items() if k != "made"}
|
body = {k: v for k, v in inv.items() if k != "made"}
|
||||||
digest = hashlib.sha256(json.dumps(body, sort_keys=True).encode()).hexdigest()
|
digest = hashlib.sha256(json.dumps(body, sort_keys=True).encode()).hexdigest()
|
||||||
if digest == self.sent_digest and now - self.sent_at < RESEND_S:
|
if digest == self.sent_digest and now - self.sent_at < RESEND_S:
|
||||||
|
|||||||
@@ -127,6 +127,8 @@ class Mapping:
|
|||||||
for key, total in (("pv_power", "pv.power"), ("load_power", "load.power")):
|
for key, total in (("pv_power", "pv.power"), ("load_power", "load.power")):
|
||||||
if not getattr(self.inputs, key) and total in self.totals:
|
if not getattr(self.inputs, key) and total in self.totals:
|
||||||
setattr(self.inputs, key, list(self.totals[total].entities))
|
setattr(self.inputs, key, list(self.totals[total].entities))
|
||||||
|
if self.inputs.controlled_power is None:
|
||||||
|
self.inputs.controlled_power = controlled_power(self)
|
||||||
|
|
||||||
@classmethod
|
@classmethod
|
||||||
def load(cls, path: str) -> "Mapping":
|
def load(cls, path: str) -> "Mapping":
|
||||||
@@ -334,3 +336,32 @@ def suggest(states: list[dict], registries: dict) -> dict:
|
|||||||
out.append({"entity": eid, "asset": asset, "kind": "counter" if counter else "gauge",
|
out.append({"entity": eid, "asset": asset, "kind": "counter" if counter else "gauge",
|
||||||
"unit": target, "consent": False})
|
"unit": target, "consent": False})
|
||||||
return {"version": 1, "assets": out}
|
return {"version": 1, "assets": out}
|
||||||
|
|
||||||
|
|
||||||
|
# The metered draw of the devices the plan plans itself, per control kind
|
||||||
|
# (Finding A2-a): a site's load.power (an inverter's "house load", the sim's)
|
||||||
|
# is the whole house with them; the plan adds them as decisions, so their
|
||||||
|
# own meters come off the load (inputs.base_load). Not the battery: a house
|
||||||
|
# load never includes its charging.
|
||||||
|
CONTROLLED_POWER = {"heating": ("heatpump.power", "heating.power"), "cooling": ("ac.power", "cooling.power"),
|
||||||
|
"ev": ("ev.power",)}
|
||||||
|
|
||||||
|
|
||||||
|
def controlled_power(m: "Mapping") -> list[str]:
|
||||||
|
"""The entities of the planned devices' own power assets: for each kind
|
||||||
|
of control the mapping has, its assets (or their parts: ev.1.power, ...),
|
||||||
|
once each (a heat pump that heats and cools is one meter)."""
|
||||||
|
kinds = {c.kind for c in m.controls}
|
||||||
|
out = []
|
||||||
|
for kind, names in CONTROLLED_POWER.items():
|
||||||
|
if kind not in kinds:
|
||||||
|
continue
|
||||||
|
for name in names:
|
||||||
|
if name in m.by_asset:
|
||||||
|
ents = [m.by_asset[name].entity]
|
||||||
|
elif name in m.totals:
|
||||||
|
ents = list(m.totals[name].entities)
|
||||||
|
else:
|
||||||
|
ents = []
|
||||||
|
out += [e for e in ents if e not in out]
|
||||||
|
return out
|
||||||
@@ -36,6 +36,44 @@ NAMES = {
|
|||||||
"flat_flex": {"en": "Flexibility", "de": "Flexibilität"},
|
"flat_flex": {"en": "Flexibility", "de": "Flexibilität"},
|
||||||
"flat_request": {"en": "Building's request", "de": "Anfrage des Gebäudes"},
|
"flat_request": {"en": "Building's request", "de": "Anfrage des Gebäudes"},
|
||||||
"flat_state": {"en": "State", "de": "Zustand"},
|
"flat_state": {"en": "State", "de": "Zustand"},
|
||||||
|
# the shadow market (a `market` bundle; announce.py, dashboards.py)
|
||||||
|
"market_exchange": {"en": "Exchange with {0}", "de": "Austausch mit {0}"},
|
||||||
|
"market_position": {"en": "Market net position", "de": "Markt: Nettoposition"},
|
||||||
|
"market_position_of": {"en": "{0}: market net position", "de": "{0}: Markt-Nettoposition"},
|
||||||
|
"market_price": {"en": "Shared energy price", "de": "Preis geteilter Energie"},
|
||||||
|
"market_actuator": {"en": "{0}: contract target", "de": "{0}: Vertragsvorgabe"},
|
||||||
|
"card_market": {"en": "Market (shadow)", "de": "Markt (Schattenbetrieb)"},
|
||||||
|
"mk_sells": {"en": "Sells to {0}", "de": "Verkauft an {0}"},
|
||||||
|
"mk_buys": {"en": "Buys from {0}", "de": "Kauft von {0}"},
|
||||||
|
"mk_flats": {"en": "{0} flats, summed", "de": "{0} Wohnungen, summiert"},
|
||||||
|
"mk_slot": {"en": "{0} kWh last quarter-hour (contract {1})", "de": "{0} kWh letzte Viertelstunde (Vertrag {1})"},
|
||||||
|
"mk_slot_open": {"en": "{0} kWh last quarter-hour", "de": "{0} kWh letzte Viertelstunde"},
|
||||||
|
"mk_no_value": {"en": "no metered value yet", "de": "noch kein Messwert"},
|
||||||
|
"mk_not_now": {"en": "not in force this quarter-hour", "de": "in dieser Viertelstunde nicht gültig"},
|
||||||
|
"mk_shadow": {"en": "shadow", "de": "Schattenbetrieb"},
|
||||||
|
"mk_period": {"en": "So far this {0}: {1} kWh · {2} €", "de": "Bisher in diesem {0}: {1} kWh · {2} €"},
|
||||||
|
"mk_month": {"en": "month", "de": "Monat"},
|
||||||
|
"mk_quarter": {"en": "quarter", "de": "Quartal"},
|
||||||
|
"mk_year": {"en": "year", "de": "Jahr"},
|
||||||
|
"mk_penalties": {"en": "penalties {0} € paid, {1} € received", "de": "Vertragsstrafen {0} € gezahlt, {1} € erhalten"},
|
||||||
|
"mk_deviation_self": {"en": "deviation {0} kWh, caused here", "de": "Abweichung {0} kWh, hier verursacht"},
|
||||||
|
"mk_deviation_other": {"en": "deviation {0} kWh, caused by the other side", "de": "Abweichung {0} kWh, von der Gegenseite verursacht"},
|
||||||
|
"mk_exempt": {"en": "exempt: {0}", "de": "ausgenommen: {0}"},
|
||||||
|
"mk_state_on": {"en": "on", "de": "ein"},
|
||||||
|
"mk_state_off": {"en": "off", "de": "aus"},
|
||||||
|
"mk_state_hold": {"en": "hold", "de": "halten"},
|
||||||
|
"mk_target": {"en": "contract", "de": "Vertrag"},
|
||||||
|
"mk_actual": {"en": "now", "de": "jetzt"},
|
||||||
|
"mk_unknown": {"en": "unknown", "de": "unbekannt"},
|
||||||
|
"mk_default": {"en": "falls back to {0} after {1} min", "de": "fällt nach {1} min auf {0} zurück"},
|
||||||
|
"mk_protection": {"en": "protection: {0}", "de": "Schutz: {0}"},
|
||||||
|
"mk_net_bought": {"en": "Net bought this month", "de": "Netto gekauft diesen Monat"},
|
||||||
|
"mk_shadow_note": {"en": "Shadow market: computed and shown only. Nothing is switched by it, no money moves; "
|
||||||
|
"your devices keep their own settings and protection.",
|
||||||
|
"de": "Schattenmarkt: nur berechnet und angezeigt. Nichts wird dadurch geschaltet, kein Geld "
|
||||||
|
"fließt; Ihre Geräte behalten ihre eigenen Einstellungen und ihren Schutz."},
|
||||||
|
"mk_stale": {"en": "The market's values are out of date (no new values from Cantabile Cloud).",
|
||||||
|
"de": "Die Marktwerte sind veraltet (keine neuen Werte von der Cantabile Cloud)."},
|
||||||
# dashboards (dashboards.py)
|
# dashboards (dashboards.py)
|
||||||
"dash_main": {"en": "Cantabile"},
|
"dash_main": {"en": "Cantabile"},
|
||||||
"dash_climate": {"en": "Heating & cooling", "de": "Heizung & Kühlung"},
|
"dash_climate": {"en": "Heating & cooling", "de": "Heizung & Kühlung"},
|
||||||
@@ -82,6 +120,16 @@ NAMES = {
|
|||||||
"from_grid": {"en": "From the grid", "de": "Aus dem Netz"},
|
"from_grid": {"en": "From the grid", "de": "Aus dem Netz"},
|
||||||
"to_grid": {"en": "To the grid", "de": "Ins Netz"},
|
"to_grid": {"en": "To the grid", "de": "Ins Netz"},
|
||||||
"heat_pump": {"en": "Heat pump", "de": "Wärmepumpe"},
|
"heat_pump": {"en": "Heat pump", "de": "Wärmepumpe"},
|
||||||
|
# heat (heat.power, heat.energy) is thermal: never shown as electricity
|
||||||
|
"heat": {"en": "Heat (thermal)", "de": "Wärme (thermisch)"},
|
||||||
|
"heat_building": {"en": "Heat from the building (thermal)", "de": "Wärme aus dem Gebäude (thermisch)"},
|
||||||
|
"heat_delivered": {"en": "Heat delivered (thermal)", "de": "Gelieferte Wärme (thermisch)"},
|
||||||
|
"heat_today": {"en": "Heat today (thermal)", "de": "Wärme heute (thermisch)"},
|
||||||
|
"heat_pump_electric": {"en": "Heat pump, electric", "de": "Wärmepumpe, elektrisch"},
|
||||||
|
"cop": {"en": "COP (heat ÷ electricity)", "de": "COP (Wärme ÷ Strom)"},
|
||||||
|
"electric_power": {"en": "Electric power", "de": "Elektrische Leistung"},
|
||||||
|
"heat_not_electric": {"en": "Heat, not electricity: not part of solar, home or grid above.",
|
||||||
|
"de": "Wärme, kein Strom: nicht Teil von Solar, Haus oder Netz oben."},
|
||||||
"ev": {"en": "Car", "de": "Auto"},
|
"ev": {"en": "Car", "de": "Auto"},
|
||||||
"circuits": {"en": "Circuits", "de": "Stromkreise"},
|
"circuits": {"en": "Circuits", "de": "Stromkreise"},
|
||||||
"of": {"en": "of", "de": "von"},
|
"of": {"en": "of", "de": "von"},
|
||||||
@@ -126,6 +174,15 @@ NAMES = {
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
COMMA = ("de", "fr", "it", "es", "nl", "ro", "ru", "pt", "pl", "cs", "da", "sv", "nb", "fi", "tr", "uk")
|
||||||
|
|
||||||
|
|
||||||
|
def number(v: float, language: str | None, digits: int = 1) -> str:
|
||||||
|
"""A number with the language's decimal mark (1.5 / 1,5)."""
|
||||||
|
s = f"{v:.{digits}f}"
|
||||||
|
return s.replace(".", ",") if lang(language) in COMMA else s
|
||||||
|
|
||||||
|
|
||||||
def lang(code: str | None) -> str:
|
def lang(code: str | None) -> str:
|
||||||
"""HA's language ("de", "de-CH", "pt-BR") as our two-letter key."""
|
"""HA's language ("de", "de-CH", "pt-BR") as our two-letter key."""
|
||||||
return (code or "en").split("-")[0].split("_")[0].lower() or "en"
|
return (code or "en").split("-")[0].split("_")[0].lower() or "en"
|
||||||
|
|||||||
@@ -14,9 +14,12 @@ Device models (one function each, small and replaceable):
|
|||||||
battery state of charge (estimated from params.soc_pct when no sensor),
|
battery state of charge (estimated from params.soc_pct when no sensor),
|
||||||
charge/discharge power, efficiency, never both at once (binary)
|
charge/discharge power, efficiency, never both at once (binary)
|
||||||
heating a room's first-order thermal model (R in K/kW, C in kWh/K, the
|
heating a room's first-order thermal model (R in K/kW, C in kWh/K, the
|
||||||
cooling outside temperature, heat from the device and from the sun
|
cooling outside temperature, heat from the device, from the sun
|
||||||
through the room's covers); comfort target when occupied,
|
through the room's covers, and the fit's internal gain and sun
|
||||||
setback/setup otherwise; a switched boiler is on/off (binary)
|
(internal_gain_w, solar_m2 x the irradiance; the sun's only
|
||||||
|
where the room has no cover in the plan, which carries it));
|
||||||
|
comfort target when occupied, setback/setup otherwise; a
|
||||||
|
switched boiler is on/off (binary)
|
||||||
ev the energy needed by the departure time, between min and max
|
ev the energy needed by the departure time, between min and max
|
||||||
current (binary), only while connected
|
current (binary), only while connected
|
||||||
cover the share of the sun's heat into its room (0 closed .. 1 open);
|
cover the share of the sun's heat into its room (0 closed .. 1 open);
|
||||||
@@ -31,6 +34,16 @@ limit_w from the grid beyond the household's own net load, i.e. the import
|
|||||||
at most max(0, load - pv) + limit_w per step, with a penalty far above any
|
at most max(0, load - pv) + limit_w per step, with a penalty far above any
|
||||||
building request (nobody overrides it).
|
building request (nobody overrides it).
|
||||||
|
|
||||||
|
The market's contracts in force (state["market"], from the market bundle;
|
||||||
|
the market's step 2, minimal, shadow: the plan only, no commands): a contract
|
||||||
|
the home buys on is an import source at its price, one it sells on an
|
||||||
|
export sink, through the same meter as the grid (which keeps the tariff's
|
||||||
|
import and feed-in prices), so the plan exchanges where the contract beats
|
||||||
|
the grid. Each step uses its own slot's terms (window, amounts, price) when
|
||||||
|
the bundle carries the coming slots (a contract's "terms", term_at). The
|
||||||
|
plan's "market" lists per contract the planned kWh and the saving against
|
||||||
|
the grid (vs_grid_eur).
|
||||||
|
|
||||||
The building's requests (building.py, state["building"]): a load limit on
|
The building's requests (building.py, state["building"]): a load limit on
|
||||||
the grid import and a thermostat cap are constraints with a penalty (binding
|
the grid import and a thermostat cap are constraints with a penalty (binding
|
||||||
far above any price, flexible with a price), a shift request a soft target
|
far above any price, flexible with a price), a shift request a soft target
|
||||||
@@ -46,6 +59,9 @@ from zoneinfo import ZoneInfo
|
|||||||
import highspy
|
import highspy
|
||||||
from highspy.highs import highs_linear_expression as Lin
|
from highspy.highs import highs_linear_expression as Lin
|
||||||
|
|
||||||
|
from .controls import ev_volts
|
||||||
|
from .evphases import words as phase_words
|
||||||
|
|
||||||
PENALTY_LIMIT = 5.0 # EUR per unit and step across a floor or limit (K, % of a battery, kWh)
|
PENALTY_LIMIT = 5.0 # EUR per unit and step across a floor or limit (K, % of a battery, kWh)
|
||||||
COMFORT_EUR_KH = 2.0 # EUR per K and hour below (heating) or above (cooling) the comfort target
|
COMFORT_EUR_KH = 2.0 # EUR per K and hour below (heating) or above (cooling) the comfort target
|
||||||
# while someone is home: above any price (0.30 let a room cool by 1.3 K
|
# while someone is home: above any price (0.30 let a room cool by 1.3 K
|
||||||
@@ -56,6 +72,10 @@ CHANGE_EUR_KW = 0.002 # EUR per kW a device's power changes from one step to
|
|||||||
# plans (equal prices would otherwise give any order, and a charger or
|
# plans (equal prices would otherwise give any order, and a charger or
|
||||||
# boiler must not be switched back and forth)
|
# boiler must not be switched back and forth)
|
||||||
CLOSED_EUR = 0.00002 # EUR per step for a closed cover: open when nothing is at stake
|
CLOSED_EUR = 0.00002 # EUR per step for a closed cover: open when nothing is at stake
|
||||||
|
MARKET_MAX_W = 100000.0 # W: a contract without a maximum, and the meter's import/export switch
|
||||||
|
GRID_MAX_W = 43470.0 # W: the site's connection when the state does not say (state["grid_max_w"],
|
||||||
|
# config grid_max_w): a German house connection's usual 63 A main fuse,
|
||||||
|
# 3 x 230 V x 63 A
|
||||||
|
|
||||||
|
|
||||||
class Model:
|
class Model:
|
||||||
@@ -89,31 +109,112 @@ class Model:
|
|||||||
|
|
||||||
# -- the house -------------------------------------------------------
|
# -- the house -------------------------------------------------------
|
||||||
def grid(self):
|
def grid(self):
|
||||||
|
"""Import and export through the meter, each at most the site's
|
||||||
|
connection (grid_max_w; never below the house's own net load or
|
||||||
|
surplus, so there is always a plan). The meter either imports or
|
||||||
|
exports in a step: a binary where the feed-in pays at least the
|
||||||
|
import price (else importing to export at once would earn money and
|
||||||
|
the plan would run to the bound). Elsewhere none is needed: doing
|
||||||
|
both costs more than doing less of each, which keeps the balance and
|
||||||
|
only loosens every other constraint on the import (all are upper
|
||||||
|
bounds: the building's, the grid order's); steps with a market
|
||||||
|
contract have their own switch (market)."""
|
||||||
s = self.s
|
s = self.s
|
||||||
self.gin, self.gout = [], []
|
cap = float(s.get("grid_max_w") or GRID_MAX_W)
|
||||||
|
self.gin, self.gout, self.gcap = [], [], []
|
||||||
for t in range(self.T):
|
for t in range(self.T):
|
||||||
gi = self.var(cost=self.eur_wh(t, s["price_import"][t]))
|
net = s["load_w"][t] - s["pv_w"][t]
|
||||||
go = self.var(cost=-self.eur_wh(t, s["price_export"][t]))
|
hi_in, hi_out = max(cap, net), max(cap, -net)
|
||||||
|
gi = self.var(0.0, hi_in, cost=self.eur_wh(t, s["price_import"][t]))
|
||||||
|
go = self.var(0.0, hi_out, cost=-self.eur_wh(t, s["price_export"][t]))
|
||||||
spill = self.var(0.0, max(0.0, s["pv_w"][t]))
|
spill = self.var(0.0, max(0.0, s["pv_w"][t]))
|
||||||
self.gin.append(gi)
|
self.gin.append(gi)
|
||||||
self.gout.append(go)
|
self.gout.append(go)
|
||||||
|
self.gcap.append((hi_in, hi_out))
|
||||||
self.flows[t] += [(1, gi), (-1, go), (-1, spill)]
|
self.flows[t] += [(1, gi), (-1, go), (-1, spill)]
|
||||||
|
|
||||||
|
def grid_switch(self, skip):
|
||||||
|
"""The meter's import/export switch where the feed-in pays at least
|
||||||
|
the import price (grid), outside the steps in skip (market's own)."""
|
||||||
|
s = self.s
|
||||||
|
for t in range(self.T):
|
||||||
|
if t in skip or s["price_export"][t] < s["price_import"][t]:
|
||||||
|
continue
|
||||||
|
hi_in, hi_out = self.gcap[t]
|
||||||
|
imp = self.var(0.0, 1.0, integer=True)
|
||||||
|
self.h.addConstr(self.gin[t] - hi_in * imp <= 0)
|
||||||
|
self.h.addConstr(self.gout[t] + hi_out * imp <= hi_out)
|
||||||
|
|
||||||
|
def market(self):
|
||||||
|
"""The market's contracts in force (state["market"], bundles.py
|
||||||
|
market_for_model; shadow, the market's step 2): a contract the home
|
||||||
|
buys on is an import source at its price, one it sells on an export
|
||||||
|
sink, both through the same meter as the grid. Bounds per step: the
|
||||||
|
best-effort maximum; a firm amount (bought: at least that much; sold:
|
||||||
|
a shortfall costs the contract's price again, a stand-in for its
|
||||||
|
penalty); take-or-pay (the minimum is paid whether used or not). The
|
||||||
|
meter either imports or exports in a step (a binary where a contract
|
||||||
|
applies), so nothing bought is resold."""
|
||||||
|
self.buy = [[] for _ in range(self.T)] # contract import vars per step
|
||||||
|
self.sell = [[] for _ in range(self.T)]
|
||||||
|
self.contracts = [] # (contract, {step: var}, {step: paid var})
|
||||||
|
steps = set()
|
||||||
|
for c in self.s.get("market") or []:
|
||||||
|
vars_, paid_ = {}, {}
|
||||||
|
for t in range(max(0, c["from_step"]), min(self.T, c["to_step"])):
|
||||||
|
k = term_at(c, t) # this step's terms (the coming slots), else the contract's
|
||||||
|
if k is None:
|
||||||
|
continue
|
||||||
|
hi = k["max_w"] if k.get("max_w") else MARKET_MAX_W
|
||||||
|
eur = self.eur_wh(t, k["price_ct"])
|
||||||
|
if c["direction"] == "buys":
|
||||||
|
lo = min(k.get("guaranteed_w") or 0.0, hi)
|
||||||
|
mwh = k.get("minimum_wh") or 0.0
|
||||||
|
if mwh > 0: # take-or-pay: what is paid covers at least the minimum
|
||||||
|
v = self.var(lo, hi)
|
||||||
|
paid = self.var(mwh / self.dt, cost=eur)
|
||||||
|
self.h.addConstr(paid - v >= 0)
|
||||||
|
paid_[t] = paid
|
||||||
|
else:
|
||||||
|
v = self.var(lo, hi, cost=eur)
|
||||||
|
self.buy[t].append(v)
|
||||||
|
self.flows[t].append((1, v))
|
||||||
|
else:
|
||||||
|
v = self.var(0.0, hi, cost=-eur)
|
||||||
|
g = min(k.get("guaranteed_w") or 0.0, hi)
|
||||||
|
if g > 0:
|
||||||
|
short = self.var(cost=eur)
|
||||||
|
self.h.addConstr(v + short >= g)
|
||||||
|
self.sell[t].append(v)
|
||||||
|
self.flows[t].append((-1, v))
|
||||||
|
vars_[t] = v
|
||||||
|
steps.add(t)
|
||||||
|
self.contracts.append((c, vars_, paid_))
|
||||||
|
for t in steps:
|
||||||
|
imp = self.var(0.0, 1.0, integer=True)
|
||||||
|
self.h.addConstr(sum(self.buy[t], start=Lin()) + self.gin[t] - MARKET_MAX_W * imp <= 0)
|
||||||
|
self.h.addConstr(sum(self.sell[t], start=Lin()) + self.gout[t] + MARKET_MAX_W * imp <= MARKET_MAX_W)
|
||||||
|
self.grid_switch(steps)
|
||||||
|
|
||||||
|
def meter_in(self, t):
|
||||||
|
"""The meter's import in step t: the grid's and the contracts' bought."""
|
||||||
|
return self.gin[t] + sum(self.buy[t], start=Lin()) if self.buy[t] else self.gin[t]
|
||||||
|
|
||||||
def building(self):
|
def building(self):
|
||||||
"""The building's load limit and shift request (on the grid import)."""
|
"""The building's load limit and shift request (on the meter's import)."""
|
||||||
req = self.s.get("building") or {}
|
req = self.s.get("building") or {}
|
||||||
lim = req.get("load_limit")
|
lim = req.get("load_limit")
|
||||||
if lim:
|
if lim:
|
||||||
for t in range(lim["from_step"], lim["to_step"]):
|
for t in range(lim["from_step"], lim["to_step"]):
|
||||||
over = self.var(cost=lim["penalty"] * self.dt / 1000.0)
|
over = self.var(cost=lim["penalty"] * self.dt / 1000.0)
|
||||||
self.h.addConstr(self.gin[t] - over <= lim["value"])
|
self.h.addConstr(self.meter_in(t) - over <= lim["value"])
|
||||||
sh = req.get("shift_request")
|
sh = req.get("shift_request")
|
||||||
if sh:
|
if sh:
|
||||||
a, b = sh["from_step"], sh["to_step"]
|
a, b = sh["from_step"], sh["to_step"]
|
||||||
base = sum(max(0.0, self.s["load_w"][t] - self.s["pv_w"][t]) * self.dt for t in range(a, b))
|
base = sum(max(0.0, self.s["load_w"][t] - self.s["pv_w"][t]) * self.dt for t in range(a, b))
|
||||||
target = max(0.0, base - sh["value"] * 1000.0)
|
target = max(0.0, base - sh["value"] * 1000.0)
|
||||||
miss = self.var(cost=sh["penalty"] / 1000.0)
|
miss = self.var(cost=sh["penalty"] / 1000.0)
|
||||||
imp = sum((self.dt * self.gin[t] for t in range(a, b)), start=Lin())
|
imp = sum((self.dt * self.meter_in(t) for t in range(a, b)), start=Lin())
|
||||||
self.h.addConstr(imp - miss <= target)
|
self.h.addConstr(imp - miss <= target)
|
||||||
|
|
||||||
def grid_order(self):
|
def grid_order(self):
|
||||||
@@ -124,7 +225,7 @@ class Model:
|
|||||||
for t in range(o["from_step"], min(o["to_step"], self.T)):
|
for t in range(o["from_step"], min(o["to_step"], self.T)):
|
||||||
base = max(0.0, self.s["load_w"][t] - self.s["pv_w"][t])
|
base = max(0.0, self.s["load_w"][t] - self.s["pv_w"][t])
|
||||||
over = self.var(cost=o["penalty"] * self.dt / 1000.0)
|
over = self.var(cost=o["penalty"] * self.dt / 1000.0)
|
||||||
self.h.addConstr(self.gin[t] - over <= base + o["limit_w"])
|
self.h.addConstr(self.meter_in(t) - over <= base + o["limit_w"])
|
||||||
|
|
||||||
def balance(self):
|
def balance(self):
|
||||||
s = self.s
|
s = self.s
|
||||||
@@ -180,6 +281,9 @@ class Model:
|
|||||||
switched = not cooling and "switch" in d["channels"] and "climate" not in d["channels"]
|
switched = not cooling and "switch" in d["channels"] and "climate" not in d["channels"]
|
||||||
temps, powers, prev = [], [], t0
|
temps, powers, prev = [], [], t0
|
||||||
a = self.dt / (r * c)
|
a = self.dt / (r * c)
|
||||||
|
internal = self.hourly(p.get("internal_gain_w") or 0.0)
|
||||||
|
solar = float(p.get("solar_m2") or 0.0)
|
||||||
|
ghi = self.s.get("ghi_w_m2") or [0.0] * self.T
|
||||||
for t in range(self.T):
|
for t in range(self.T):
|
||||||
if switched:
|
if switched:
|
||||||
u = self.var(0.0, 1.0, integer=True)
|
u = self.var(0.0, 1.0, integer=True)
|
||||||
@@ -190,10 +294,13 @@ class Model:
|
|||||||
self.flows[t].append((-1, pw))
|
self.flows[t].append((-1, pw))
|
||||||
tt = self.var(-50.0, 80.0)
|
tt = self.var(-50.0, 80.0)
|
||||||
sign = -1.0 if cooling else 1.0
|
sign = -1.0 if cooling else 1.0
|
||||||
gain = sum((g * gx for g, gx in gains(t)), start=Lin())
|
covers = gains(t)
|
||||||
# T[t+1] = T[t] (1 - a) + a T_out + dt/C (± cop P/1000 + sun gain/1000)
|
gain = sum((g * gx for g, gx in covers), start=Lin())
|
||||||
|
# the fit's (B6): its internal gain, and its sun where no cover carries it
|
||||||
|
fixed = internal[t] + (solar * ghi[t] if not covers and t < len(ghi) else 0.0)
|
||||||
|
# T[t+1] = T[t] (1 - a) + a T_out + dt/C (± cop P/1000 + sun gain/1000 + fixed gains/1000)
|
||||||
self.h.addConstr(tt - (1 - a) * prev - sign * self.dt / c * cop / 1000.0 * pw
|
self.h.addConstr(tt - (1 - a) * prev - sign * self.dt / c * cop / 1000.0 * pw
|
||||||
- self.dt / c / 1000.0 * gain == a * self.s["t_out"][t])
|
- self.dt / c / 1000.0 * gain == a * self.s["t_out"][t] + self.dt / c / 1000.0 * fixed)
|
||||||
occ = self.s["occupied"][t + 1] if t + 1 < self.T else self.s["occupied"][t]
|
occ = self.s["occupied"][t + 1] if t + 1 < self.T else self.s["occupied"][t]
|
||||||
target = min(max(comfort if occ else other, lo), hi)
|
target = min(max(comfort if occ else other, lo), hi)
|
||||||
miss = self.var(cost=COMFORT_EUR_KH * self.dt)
|
miss = self.var(cost=COMFORT_EUR_KH * self.dt)
|
||||||
@@ -219,12 +326,21 @@ class Model:
|
|||||||
self.devices[d["id"]] = ("cooling" if cooling else "heating",
|
self.devices[d["id"]] = ("cooling" if cooling else "heating",
|
||||||
{"temp": temps, "power": powers, "pmax": pmax, "switched": switched})
|
{"temp": temps, "power": powers, "pmax": pmax, "switched": switched})
|
||||||
|
|
||||||
|
def hourly(self, v) -> list[float]:
|
||||||
|
"""A number, or 24 by local hour, per step."""
|
||||||
|
if not isinstance(v, list):
|
||||||
|
return [float(v)] * self.T
|
||||||
|
zone = ZoneInfo(self.s.get("tz") or "UTC")
|
||||||
|
start, step = self.s["start"], self.s["step_s"]
|
||||||
|
return [float(v[datetime.fromtimestamp(start + t * step, timezone.utc).astimezone(zone).hour % len(v)])
|
||||||
|
for t in range(self.T)]
|
||||||
|
|
||||||
def ev(self, d):
|
def ev(self, d):
|
||||||
p, st, b = d["params"], d["state"], d["bounds"]
|
p, st, b = d["params"], d["state"], d["bounds"]
|
||||||
if not st.get("connected"):
|
if not st.get("connected"):
|
||||||
self.devices[d["id"]] = ("ev", None)
|
self.devices[d["id"]] = ("ev", None)
|
||||||
return
|
return
|
||||||
volts = float(p["voltage"]) * float(p["phases"])
|
volts = ev_volts(p, "plan")
|
||||||
imax = min(float(p["max_current_a"]), b["current_a"][1])
|
imax = min(float(p["max_current_a"]), b["current_a"][1])
|
||||||
imin = max(float(p["min_current_a"]), b["current_a"][0])
|
imin = max(float(p["min_current_a"]), b["current_a"][0])
|
||||||
dep = departure_step(self.s, str(st.get("departure") or p["departure"]))
|
dep = departure_step(self.s, str(st.get("departure") or p["departure"]))
|
||||||
@@ -279,6 +395,7 @@ class Model:
|
|||||||
def solve(self, time_limit: float):
|
def solve(self, time_limit: float):
|
||||||
s = self.s
|
s = self.s
|
||||||
self.grid()
|
self.grid()
|
||||||
|
self.market()
|
||||||
covers = [d for d in s["devices"] if d["kind"] == "cover"]
|
covers = [d for d in s["devices"] if d["kind"] == "cover"]
|
||||||
rooms = {d["id"] for d in s["devices"] if d["kind"] in ("heating", "cooling")}
|
rooms = {d["id"] for d in s["devices"] if d["kind"] in ("heating", "cooling")}
|
||||||
for d in covers:
|
for d in covers:
|
||||||
@@ -349,10 +466,59 @@ def plan(s: dict, time_limit: float = 30.0) -> dict:
|
|||||||
devices[d["id"]] = entries
|
devices[d["id"]] = entries
|
||||||
energy = sum(m.eur_wh(t, pi[t]) * x(m.gin[t]) - m.eur_wh(t, s["price_export"][t]) * x(m.gout[t])
|
energy = sum(m.eur_wh(t, pi[t]) * x(m.gin[t]) - m.eur_wh(t, s["price_export"][t]) * x(m.gout[t])
|
||||||
for t in range(T))
|
for t in range(T))
|
||||||
return {"v": 1, "made": int(time.time()), "start": start, "step_s": step, "status": status,
|
market = market_plan(s, m, x)
|
||||||
|
energy += sum(c["cost_eur"] for c in market)
|
||||||
|
out = {"v": 1, "made": int(time.time()), "start": start, "step_s": step, "status": status,
|
||||||
"solve_s": round(time.time() - t0, 2), "devices": devices, "flex": flexibility(m, x),
|
"solve_s": round(time.time() - t0, 2), "devices": devices, "flex": flexibility(m, x),
|
||||||
"cost_eur": round(energy, 2), "baseline_eur": round(baseline(s, m, x), 2),
|
"cost_eur": round(energy, 2), "baseline_eur": round(baseline(s, m, x), 2),
|
||||||
"price_note": s.get("price_note", ""), "sources": s.get("sources", {})}
|
"price_note": s.get("price_note", ""), "sources": s.get("sources", {})}
|
||||||
|
if market:
|
||||||
|
out["market"] = market
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
|
def term_at(c: dict, t: int) -> dict | None:
|
||||||
|
"""A market contract's terms in plan step t: its per-step terms when the
|
||||||
|
bundle told the coming slots (None: it does not apply then), else the
|
||||||
|
contract's own (held over from_step .. to_step)."""
|
||||||
|
per = c.get("terms")
|
||||||
|
if per is None:
|
||||||
|
return c
|
||||||
|
return per[t] if 0 <= t < len(per) else None
|
||||||
|
|
||||||
|
|
||||||
|
def market_plan(s, m, x) -> list[dict]:
|
||||||
|
"""Per contract in the plan (shadow): the planned energy per step and in
|
||||||
|
all (kWh), what is paid, and what it saves against the grid: bought,
|
||||||
|
import price x kWh used - contract price x kWh paid; sold, (contract
|
||||||
|
price - feed-in) x kWh (EUR; < 0: dearer than the grid). A take-or-pay
|
||||||
|
contract's paid energy is at least its minimum, used or not (what the
|
||||||
|
optimisation pays). Fields: id, name, direction, price_ct, steps [{t,
|
||||||
|
kwh, paid_kwh}] (steps with energy used or paid only), planned_kwh,
|
||||||
|
paid_kwh, cost_eur (> 0 paid, < 0 received), vs_grid_eur."""
|
||||||
|
out = []
|
||||||
|
pi, pe = s["price_import"], s["price_export"]
|
||||||
|
for c, vars_, paid_ in getattr(m, "contracts", []):
|
||||||
|
steps, kwh, paid_kwh, cost, vs = [], 0.0, 0.0, 0.0, 0.0
|
||||||
|
for t, v in sorted(vars_.items()):
|
||||||
|
e = max(x(v), 0.0) * m.dt / 1000.0
|
||||||
|
pay = max(x(paid_[t]) * m.dt / 1000.0, e) if t in paid_ else e
|
||||||
|
if pay < 1e-6:
|
||||||
|
continue
|
||||||
|
price = (term_at(c, t) or c)["price_ct"]
|
||||||
|
steps.append({"t": s["start"] + t * s["step_s"], "kwh": round(e, 4), "paid_kwh": round(pay, 4)})
|
||||||
|
kwh += e
|
||||||
|
paid_kwh += pay
|
||||||
|
if c["direction"] == "buys":
|
||||||
|
cost += pay * price / 100.0
|
||||||
|
vs += (e * pi[t] - pay * price) / 100.0
|
||||||
|
else:
|
||||||
|
cost -= e * price / 100.0
|
||||||
|
vs += e * (price - pe[t]) / 100.0
|
||||||
|
out.append({"id": c["id"], "name": c.get("name", ""), "direction": c["direction"], "price_ct": c["price_ct"],
|
||||||
|
"steps": steps, "planned_kwh": round(kwh, 4), "paid_kwh": round(paid_kwh, 4),
|
||||||
|
"cost_eur": round(cost, 4), "vs_grid_eur": round(vs, 4)})
|
||||||
|
return out
|
||||||
|
|
||||||
|
|
||||||
FLEX_STEPS = 96 # 24 h at 15 min: what a building plans with
|
FLEX_STEPS = 96 # 24 h at 15 min: what a building plans with
|
||||||
@@ -432,9 +598,11 @@ def _entry(d, kind, v, t, x, s, pi):
|
|||||||
if p is None:
|
if p is None:
|
||||||
return {"set": "off", "why": "after departure"}
|
return {"set": "off", "why": "after departure"}
|
||||||
amps = round(x(p) / v["volts"])
|
amps = round(x(p) / v["volts"])
|
||||||
|
ph = ((s.get("sources") or {}).get("ev_phases") or {}).get(d["id"])
|
||||||
|
ph = f"; {phase_words(ph)}" if ph else ""
|
||||||
if amps < 1:
|
if amps < 1:
|
||||||
return {"set": "off", "why": "wait for cheaper hours"}
|
return {"set": "off", "why": "wait for cheaper hours" + ph}
|
||||||
return {"set": amps, "why": f"cheapest hours before departure ({pi[t]:.1f} ct)"}
|
return {"set": amps, "why": f"cheapest hours before departure ({pi[t]:.1f} ct){ph}"}
|
||||||
if kind == "cover" and v.get("schedule"):
|
if kind == "cover" and v.get("schedule"):
|
||||||
sch = v["schedule"]
|
sch = v["schedule"]
|
||||||
return {"set": sch["set"][t], "why": sch["why"][t] if sch["set"][t] is not None else ""}
|
return {"set": sch["set"][t], "why": sch["why"][t] if sch["set"][t] is not None else ""}
|
||||||
|
|||||||
@@ -4,8 +4,10 @@ package main
|
|||||||
|
|
||||||
// Data bundles for the agent (data only, never code that runs):
|
// Data bundles for the agent (data only, never code that runs):
|
||||||
// tariffs (prices for the next 48 h), models (the forecasts' data), a
|
// tariffs (prices for the next 48 h), models (the forecasts' data), a
|
||||||
// building box's flats and the devices' protection (acl: it
|
// building box's flats, the devices' protection (acl: it
|
||||||
// never expires; a newer one replaces it). Fleet
|
// never expires; a newer one replaces it) and the shadow market's values
|
||||||
|
// for the box's own nodes (market, the market's step 1.5: shown in HA, never
|
||||||
|
// a command). Fleet
|
||||||
// sends one as a signed command, `tariff` or `model`, with args
|
// sends one as a signed command, `tariff` or `model`, with args
|
||||||
// {"bundle": base64 of the bundle's JSON bytes, "sig": base64 of their
|
// {"bundle": base64 of the bundle's JSON bytes, "sig": base64 of their
|
||||||
// signature with the BUNDLE key}. The command itself is checked with the
|
// signature with the BUNDLE key}. The command itself is checked with the
|
||||||
@@ -84,7 +86,7 @@ func checkBundle(key crypto.PublicKey, kind, site string, args map[string]string
|
|||||||
return data, h, nil
|
return data, h, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
// bundleCmd: a `tariff`, `model` or `flats` command (already checked as a
|
// bundleCmd: a `tariff`, `model`, `flats`, `acl` or `market` command (already checked as a
|
||||||
// command); flats: a building's own box gets its flats for Home Assistant.
|
// command); flats: a building's own box gets its flats for Home Assistant.
|
||||||
func (l *link) bundleCmd(c command, now time.Time) (bool, string) {
|
func (l *link) bundleCmd(c command, now time.Time) (bool, string) {
|
||||||
key, err := l.bundleCert()
|
key, err := l.bundleCert()
|
||||||
|
|||||||
@@ -118,6 +118,30 @@ func TestBundles(t *testing.T) {
|
|||||||
if ok, _ := l.bundleCmd(cmd("acl", bundleArgs(t, k, acl)), now); ok {
|
if ok, _ := l.bundleCmd(cmd("acl", bundleArgs(t, k, acl)), now); ok {
|
||||||
t.Error("another site's acl stored")
|
t.Error("another site's acl stored")
|
||||||
}
|
}
|
||||||
|
// the shadow market (step 1.5): for this site only, signed with the bundle key, newest kept
|
||||||
|
market := func(id string, issued int64, site string) map[string]any {
|
||||||
|
return map[string]any{"v": 1, "kind": "market", "id": id, "site": site, "issued": issued, "expires": now.Add(6 * time.Hour).Unix(),
|
||||||
|
"shadow": true, "commands": "none", "contracts": []map[string]any{{"id": "k1", "direction": "sells"}}}
|
||||||
|
}
|
||||||
|
if ok, msg := l.bundleCmd(cmd("market", bundleArgs(t, k, market("mk2", now.Unix(), site))), now); !ok {
|
||||||
|
t.Errorf("market: %s", msg)
|
||||||
|
}
|
||||||
|
if b, _ := os.ReadFile(filepath.Join(l.cfg.AgentState, "market.json")); !strings.Contains(string(b), `"id":"mk2"`) {
|
||||||
|
t.Errorf("market.json: %s", b)
|
||||||
|
}
|
||||||
|
for name, c := range map[string]struct {
|
||||||
|
args map[string]string
|
||||||
|
want string
|
||||||
|
}{
|
||||||
|
"other site": {bundleArgs(t, k, market("mk3", now.Unix()+1, strings.Repeat("cd", 16))), "not for this site"},
|
||||||
|
"other key": {bundleArgs(t, other, market("mk4", now.Unix()+1, site)), "bad bundle signature"},
|
||||||
|
"older": {bundleArgs(t, k, market("mk1", now.Add(-time.Hour).Unix(), site)), "older than the one the agent has (mk2)"},
|
||||||
|
"every site": {bundleArgs(t, k, market("mk5", now.Unix()+1, "*")), "not for this site"},
|
||||||
|
} {
|
||||||
|
if ok, msg := l.bundleCmd(cmd("market", c.args), now); ok || !strings.HasSuffix(msg, c.want) {
|
||||||
|
t.Errorf("market %s: %v %q", name, ok, msg)
|
||||||
|
}
|
||||||
|
}
|
||||||
// no certificate on the box: refused, not crashed
|
// no certificate on the box: refused, not crashed
|
||||||
l.cfg.BundleCert = filepath.Join(t.TempDir(), "missing.pem")
|
l.cfg.BundleCert = filepath.Join(t.TempDir(), "missing.pem")
|
||||||
if ok, msg := l.bundleCmd(cmd("tariff", bundleArgs(t, k, tariff("t7", now.Unix()))), now); ok || !strings.HasPrefix(msg, "no bundle certificate") {
|
if ok, msg := l.bundleCmd(cmd("tariff", bundleArgs(t, k, tariff("t7", now.Unix()))), now); ok || !strings.HasPrefix(msg, "no bundle certificate") {
|
||||||
|
|||||||
@@ -123,6 +123,27 @@ func setupDone(path string) bool {
|
|||||||
return done
|
return done
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// boxLocation: the site's country and postcode as the owner gave them in
|
||||||
|
// the panel's Location (config.json "location"), and when they last
|
||||||
|
// changed ("at", Unix seconds: fleet keeps the newer of the box's and the
|
||||||
|
// console's). Never the latitude and longitude. nil without a country.
|
||||||
|
func boxLocation(path string) map[string]any {
|
||||||
|
loc, _ := jsonFile(path)["location"].(map[string]any)
|
||||||
|
country, _ := loc["country"].(string)
|
||||||
|
if len(country) != 2 {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
code, _ := loc["postal_code"].(string)
|
||||||
|
if len(code) > 16 {
|
||||||
|
code = code[:16]
|
||||||
|
}
|
||||||
|
out := map[string]any{"country": country, "postal_code": code}
|
||||||
|
if at, ok := loc["at"].(float64); ok && at > 0 {
|
||||||
|
out["at"] = int64(at)
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
// updateState: cantabile-update's state and the release the channel offers
|
// updateState: cantabile-update's state and the release the channel offers
|
||||||
// (update.json in /run). Until its first check after a boot (the timer:
|
// (update.json in /run). Until its first check after a boot (the timer:
|
||||||
// 2 minutes) there is no file: "not-checked", not null (dev.20's first
|
// 2 minutes) there is no file: "not-checked", not null (dev.20's first
|
||||||
@@ -238,6 +259,8 @@ func (l *link) status() map[string]any {
|
|||||||
return map[string]any{"v": 1, "version": osVersion(), "link": version, "slot": slot(), "uptime_s": uptime(),
|
return map[string]any{"v": 1, "version": osVersion(), "link": version, "slot": slot(), "uptime_s": uptime(),
|
||||||
"load": load, "cpu_pct": cpuPct, "ram_pct": ram, "temp_c": temperature(), "cpu_mhz": mhz, "disk": disk,
|
"load": load, "cpu_pct": cpuPct, "ram_pct": ram, "temp_c": temperature(), "cpu_mhz": mhz, "disk": disk,
|
||||||
"wifi": wifiState(), "addons": addons, "channel": ch,
|
"wifi": wifiState(), "addons": addons, "channel": ch,
|
||||||
|
// its interfaces and addresses, an IPv4 default route (netstate.go)
|
||||||
|
"net": netState(), "route4": defaultRoute4(read("/proc/net/route")),
|
||||||
"update": map[string]any{"state": ust, "available": uav},
|
"update": map[string]any{"state": ust, "available": uav},
|
||||||
// SMART on the box's own disk, as cantabile-status read it (null
|
// SMART on the box's own disk, as cantabile-status read it (null
|
||||||
// until its first run); fleet's hardware view counts the bad ones.
|
// until its first run); fleet's hardware view counts the bad ones.
|
||||||
|
|||||||
@@ -23,3 +23,24 @@ func TestSetupDone(t *testing.T) {
|
|||||||
t.Fatal("not a bool")
|
t.Fatal("not a bool")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// The heartbeat's location: country and postcode (never lat/lon), "at".
|
||||||
|
func TestBoxLocation(t *testing.T) {
|
||||||
|
p := filepath.Join(t.TempDir(), "config.json")
|
||||||
|
if boxLocation(p) != nil {
|
||||||
|
t.Fatal("no file: none")
|
||||||
|
}
|
||||||
|
os.WriteFile(p, []byte(`{"location": {"country": "DE", "postal_code": "10115", "latitude": 52.53, "longitude": 13.38, "at": 1761800000}}`), 0o600)
|
||||||
|
l := boxLocation(p)
|
||||||
|
if l["country"] != "DE" || l["postal_code"] != "10115" || l["at"] != int64(1761800000) || l["latitude"] != nil || len(l) != 3 {
|
||||||
|
t.Fatalf("%v", l)
|
||||||
|
}
|
||||||
|
os.WriteFile(p, []byte(`{"location": {"country": "AT"}}`), 0o600)
|
||||||
|
if l := boxLocation(p); l["country"] != "AT" || l["postal_code"] != "" || l["at"] != nil {
|
||||||
|
t.Fatalf("%v", l)
|
||||||
|
}
|
||||||
|
os.WriteFile(p, []byte(`{"location": {"latitude": 1}}`), 0o600)
|
||||||
|
if boxLocation(p) != nil {
|
||||||
|
t.Fatal("no country: none")
|
||||||
|
}
|
||||||
|
}
|
||||||
+33
-2
@@ -30,6 +30,7 @@ import (
|
|||||||
"fmt"
|
"fmt"
|
||||||
"io"
|
"io"
|
||||||
"log/slog"
|
"log/slog"
|
||||||
|
"math"
|
||||||
"math/bits"
|
"math/bits"
|
||||||
"math/rand"
|
"math/rand"
|
||||||
"net/http"
|
"net/http"
|
||||||
@@ -755,11 +756,41 @@ func (l *link) heartbeat() map[string]any {
|
|||||||
if p := l.pathInfo(); p != nil {
|
if p := l.pathInfo(); p != nil {
|
||||||
hb["path"] = p
|
hb["path"] = p
|
||||||
}
|
}
|
||||||
hb["consents"] = consents(env("CANTABILE_CONSENT_FILE",
|
c := consents(env("CANTABILE_CONSENT_FILE",
|
||||||
map[bool]string{true: "/data/cantabile/edge/consent.json", false: "/data/state/consent.json"}[isHub()]))
|
map[bool]string{true: "/data/cantabile/edge/consent.json", false: "/data/state/consent.json"}[isHub()]))
|
||||||
|
hb["consents"] = c
|
||||||
|
// the site's weather cell (0.1°), for the cloud's weather: only with
|
||||||
|
// the owner's share consent
|
||||||
|
if c["share"] == true {
|
||||||
|
if cell := siteCell(filepath.Join(l.cfg.AgentState, "site_cell.json")); cell != nil {
|
||||||
|
hb["cell"] = cell
|
||||||
|
}
|
||||||
|
// the Hub's country and postcode (the panel's Location; tariffs,
|
||||||
|
// Mieterstrom and energy sharing go by them): with the same consent
|
||||||
|
if isHub() {
|
||||||
|
if loc := boxLocation(boxConfig); loc != nil {
|
||||||
|
hb["location"] = loc
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
return hb
|
return hb
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// siteCell: [lat, lon] rounded to 0.1° from the agent's site_cell.json
|
||||||
|
// (written from HA's configuration), or nil (none, malformed, out of range).
|
||||||
|
func siteCell(path string) []float64 {
|
||||||
|
var c struct{ Lat, Lon *float64 }
|
||||||
|
b, err := os.ReadFile(path)
|
||||||
|
if err != nil || json.Unmarshal(b, &c) != nil || c.Lat == nil || c.Lon == nil {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
lat, lon := math.Round(*c.Lat*10)/10, math.Round(*c.Lon*10)/10
|
||||||
|
if math.Abs(lat) > 90 || math.Abs(lon) > 180 {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
return []float64{lat, lon}
|
||||||
|
}
|
||||||
|
|
||||||
// consents: the owner's consents as fleet keeps them (per
|
// consents: the owner's consents as fleet keeps them (per
|
||||||
// recipient; nothing goes to a recipient without its yes): share (with
|
// recipient; nothing goes to a recipient without its yes): share (with
|
||||||
// Cantabile), control, and the recipients granted (building, grid,
|
// Cantabile), control, and the recipients granted (building, grid,
|
||||||
@@ -900,7 +931,7 @@ func (l *link) do(c command) (bool, string, func()) {
|
|||||||
case "refresh":
|
case "refresh":
|
||||||
l.publish("hb", l.heartbeat())
|
l.publish("hb", l.heartbeat())
|
||||||
return true, "heartbeat sent", nil
|
return true, "heartbeat sent", nil
|
||||||
case "tariff", "model", "flats", "acl": // data bundles: checked here, read by the agent (bundles.go; flats: a building's box; acl: the devices' protection)
|
case "tariff", "model", "flats", "acl", "market": // data bundles: checked here, read by the agent (bundles.go; flats: a building's box; acl: the devices' protection; market: the shadow market's values)
|
||||||
ok, msg := l.bundleCmd(c, time.Now())
|
ok, msg := l.bundleCmd(c, time.Now())
|
||||||
if ok && c.Cmd == "acl" && isHub() {
|
if ok && c.Cmd == "acl" && isHub() {
|
||||||
devicesPolicy() // the policy in force for add-ons and the Modbus bridge (/usr/lib/cantabile/devices)
|
devicesPolicy() // the policy in force for add-ons and the Modbus bridge (/usr/lib/cantabile/devices)
|
||||||
|
|||||||
@@ -253,3 +253,37 @@ func TestConsentsCarrySourceAndVersion(t *testing.T) {
|
|||||||
t.Fatalf("no file: %v", c)
|
t.Fatalf("no file: %v", c)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// The site's weather cell (the agent's site_cell.json) goes into the
|
||||||
|
// heartbeat only with the share consent, rounded to 0.1°, on a Hub too;
|
||||||
|
// a missing or bad file: no cell.
|
||||||
|
func TestHeartbeatCell(t *testing.T) {
|
||||||
|
for _, hub := range []string{"0", "1"} {
|
||||||
|
t.Setenv("CANTABILE_HUB", hub)
|
||||||
|
dir := t.TempDir()
|
||||||
|
cons := filepath.Join(dir, "consent.json")
|
||||||
|
t.Setenv("CANTABILE_CONSENT_FILE", cons)
|
||||||
|
l := &link{cfg: config{AgentState: dir}, loc: &local{}}
|
||||||
|
cell := filepath.Join(dir, "site_cell.json")
|
||||||
|
os.WriteFile(cell, []byte(`{"lat": 47.0234, "lon": 28.86}`), 0o644)
|
||||||
|
os.WriteFile(cons, []byte(`{"share": true}`), 0o600)
|
||||||
|
if c, ok := l.heartbeat()["cell"].([]float64); !ok || len(c) != 2 || c[0] != 47.0 || c[1] != 28.9 {
|
||||||
|
t.Fatalf("hub %s, shared: %v", hub, l.heartbeat()["cell"])
|
||||||
|
}
|
||||||
|
os.WriteFile(cons, []byte(`{"share": false, "control": true}`), 0o600)
|
||||||
|
if c, ok := l.heartbeat()["cell"]; ok {
|
||||||
|
t.Fatalf("hub %s, not shared: %v", hub, c)
|
||||||
|
}
|
||||||
|
os.WriteFile(cons, []byte(`{"share": true}`), 0o600)
|
||||||
|
for _, bad := range []string{`not json`, `{"lat": 47.0}`, `{"lat": 95, "lon": 28}`, `{"lat": 47, "lon": -181}`, `{"lat": "47", "lon": 28}`} {
|
||||||
|
os.WriteFile(cell, []byte(bad), 0o644)
|
||||||
|
if c, ok := l.heartbeat()["cell"]; ok {
|
||||||
|
t.Fatalf("hub %s, %s: %v", hub, bad, c)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
os.Remove(cell)
|
||||||
|
if c, ok := l.heartbeat()["cell"]; ok {
|
||||||
|
t.Fatalf("hub %s, no file: %v", hub, c)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,86 @@
|
|||||||
|
// Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
||||||
|
|
||||||
|
package main
|
||||||
|
|
||||||
|
// The box's own network in its status report: a new
|
||||||
|
// Hub whose Wi-Fi chip was not recognised enrolled over Ethernet, and its
|
||||||
|
// owner could not find its panel on the LAN. Support sees in the console
|
||||||
|
// which interfaces the box has, their MAC, link and addresses, and whether
|
||||||
|
// it has an IPv4 default route ("no IPv4"), next to the hardware report's
|
||||||
|
// Wi-Fi chip and driver. Box-level operations data (no network names, no
|
||||||
|
// other devices on the LAN); sent also before the owner claims the box
|
||||||
|
// (fleet unclaimed.go).
|
||||||
|
|
||||||
|
import (
|
||||||
|
"net"
|
||||||
|
"net/netip"
|
||||||
|
"os"
|
||||||
|
"path/filepath"
|
||||||
|
"strings"
|
||||||
|
)
|
||||||
|
|
||||||
|
// ifaceInfo: one interface as the kernel reports it.
|
||||||
|
type ifaceInfo struct {
|
||||||
|
Name, MAC string
|
||||||
|
Addrs []string // CIDR
|
||||||
|
}
|
||||||
|
|
||||||
|
// netState: the physical interfaces (the box's own adapters: those with
|
||||||
|
// /sys/class/net/<if>/device; not containers' or loopback).
|
||||||
|
func netState() []map[string]any {
|
||||||
|
ifs, _ := net.Interfaces()
|
||||||
|
var in []ifaceInfo
|
||||||
|
for _, i := range ifs {
|
||||||
|
x := ifaceInfo{Name: i.Name, MAC: i.HardwareAddr.String()}
|
||||||
|
addrs, _ := i.Addrs()
|
||||||
|
for _, a := range addrs {
|
||||||
|
x.Addrs = append(x.Addrs, a.String())
|
||||||
|
}
|
||||||
|
in = append(in, x)
|
||||||
|
}
|
||||||
|
return netEntries("/sys/class/net", in)
|
||||||
|
}
|
||||||
|
|
||||||
|
// netEntries: the report's entries for these interfaces (sys: the sysfs
|
||||||
|
// net directory).
|
||||||
|
func netEntries(sys string, ifs []ifaceInfo) []map[string]any {
|
||||||
|
out := []map[string]any{}
|
||||||
|
for _, i := range ifs {
|
||||||
|
p := filepath.Join(sys, i.Name)
|
||||||
|
if _, err := os.Stat(p + "/device"); err != nil {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
kind := "ethernet"
|
||||||
|
if _, err := os.Stat(p + "/wireless"); err == nil {
|
||||||
|
kind = "wifi"
|
||||||
|
}
|
||||||
|
v4, v6 := []string{}, []string{}
|
||||||
|
for _, a := range i.Addrs {
|
||||||
|
pfx, err := netip.ParsePrefix(a)
|
||||||
|
if err != nil {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
switch ad := pfx.Addr(); {
|
||||||
|
case ad.Is4():
|
||||||
|
v4 = append(v4, pfx.String())
|
||||||
|
case ad.IsGlobalUnicast(): // global and unique local; not link-local
|
||||||
|
v6 = append(v6, pfx.String())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
out = append(out, map[string]any{"interface": i.Name, "kind": kind, "mac": i.MAC,
|
||||||
|
"link": read(p + "/operstate"), "ipv4": v4, "ipv6": v6})
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
// defaultRoute4: /proc/net/route has an IPv4 default route (destination
|
||||||
|
// 00000000) that is up.
|
||||||
|
func defaultRoute4(table string) bool {
|
||||||
|
for _, ln := range strings.Split(table, "\n")[1:] {
|
||||||
|
f := strings.Fields(ln)
|
||||||
|
if len(f) >= 4 && f[1] == "00000000" {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
@@ -0,0 +1,42 @@
|
|||||||
|
// Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
||||||
|
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"os"
|
||||||
|
"path/filepath"
|
||||||
|
"reflect"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
// TestNetEntries: the box's own adapters only, Wi-Fi told apart, IPv4 and
|
||||||
|
// routable IPv6 (not link-local).
|
||||||
|
func TestNetEntries(t *testing.T) {
|
||||||
|
sys := t.TempDir()
|
||||||
|
for _, d := range []string{"enp1s0/device", "wlp2s0/device", "wlp2s0/wireless", "veth1234", "lo"} {
|
||||||
|
os.MkdirAll(filepath.Join(sys, d), 0o755)
|
||||||
|
}
|
||||||
|
os.WriteFile(filepath.Join(sys, "enp1s0", "operstate"), []byte("up\n"), 0o644)
|
||||||
|
got := netEntries(sys, []ifaceInfo{
|
||||||
|
{Name: "lo", Addrs: []string{"127.0.0.1/8"}},
|
||||||
|
{Name: "enp1s0", MAC: "00:11:22:33:44:55", Addrs: []string{"192.0.2.23/24", "fe80::1/64", "2001:db8::23/64"}},
|
||||||
|
{Name: "wlp2s0", MAC: "66:77:88:99:aa:bb"},
|
||||||
|
{Name: "veth1234", Addrs: []string{"198.51.100.1/16"}},
|
||||||
|
})
|
||||||
|
want := []map[string]any{
|
||||||
|
{"interface": "enp1s0", "kind": "ethernet", "mac": "00:11:22:33:44:55", "link": "up",
|
||||||
|
"ipv4": []string{"192.0.2.23/24"}, "ipv6": []string{"2001:db8::23/64"}},
|
||||||
|
{"interface": "wlp2s0", "kind": "wifi", "mac": "66:77:88:99:aa:bb", "link": "", "ipv4": []string{}, "ipv6": []string{}},
|
||||||
|
}
|
||||||
|
if !reflect.DeepEqual(got, want) {
|
||||||
|
t.Fatalf("got %v", got)
|
||||||
|
}
|
||||||
|
table := "Iface\tDestination\tGateway \tFlags\tRefCnt\tUse\tMetric\tMask\t\tMTU\tWindow\tIRTT\n" +
|
||||||
|
"enp1s0\t0001A8C0\t00000000\t0001\t0\t0\t100\t00FFFFFF\t0\t0\t0\n"
|
||||||
|
if defaultRoute4(table) {
|
||||||
|
t.Error("a LAN route is no default route")
|
||||||
|
}
|
||||||
|
if !defaultRoute4(table+"enp1s0\t00000000\t0101A8C0\t0003\t0\t0\t100\t00000000\t0\t0\t0\n") || defaultRoute4("") {
|
||||||
|
t.Error("default route")
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -197,3 +197,28 @@ def test_restart_for_a_devices_consent(tmp_path, monkeypatch):
|
|||||||
assert a.exit_code == agent_mod.RESTART and not a.stop.is_set() # the page answers first
|
assert a.exit_code == agent_mod.RESTART and not a.stop.is_set() # the page answers first
|
||||||
await asyncio.wait_for(a.stop.wait(), 1)
|
await asyncio.wait_for(a.stop.wait(), 1)
|
||||||
asyncio.run(go())
|
asyncio.run(go())
|
||||||
|
|
||||||
|
|
||||||
|
def test_a_site_without_controls_still_tells_the_cloud_of_a_grid_order(tmp_path):
|
||||||
|
"""No controls, nothing to limit: the grid operator's order (EEBUS LPC)
|
||||||
|
is still checked and told to the cloud (fleet's ledger exempts the slot)."""
|
||||||
|
import time
|
||||||
|
from test_gridorder import message
|
||||||
|
|
||||||
|
class Sink(FlakySink):
|
||||||
|
def __init__(self):
|
||||||
|
super().__init__()
|
||||||
|
self.published = []
|
||||||
|
|
||||||
|
async def publish(self, kind, data):
|
||||||
|
self.published.append((kind, data))
|
||||||
|
sink = Sink()
|
||||||
|
a = make_agent(tmp_path, sink)
|
||||||
|
assert a.control is None
|
||||||
|
now = int(time.time())
|
||||||
|
assert asyncio.run(a.grid_order(message(**{"from": now, "until": now + 900}).encode()))
|
||||||
|
assert [(k, d["service"], d["value"]) for k, d in sink.published] == [("action", "grid.load_limit", "4200.0")]
|
||||||
|
asyncio.run(a.grid_report()) # the same quarter-hour: told already
|
||||||
|
assert len(sink.published) == 1
|
||||||
|
# a forged one changes nothing
|
||||||
|
assert not asyncio.run(a.grid_order(b'{"order": "{}", "sig": "", "key": ""}'))
|
||||||
@@ -0,0 +1,185 @@
|
|||||||
|
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
||||||
|
"""The plan's base load (Finding A2-a) and a room's fitted gains (Finding
|
||||||
|
B6-a), from the mapping and the model bundle through the model state into
|
||||||
|
the plan."""
|
||||||
|
import json
|
||||||
|
|
||||||
|
import pytest
|
||||||
|
import yaml
|
||||||
|
|
||||||
|
from cantabile_edge.bundles import Bundles
|
||||||
|
from cantabile_edge.controls import Control
|
||||||
|
from cantabile_edge.inputs import Collector, base_load, model_state
|
||||||
|
from cantabile_edge.mapping import Mapping
|
||||||
|
|
||||||
|
from test_control_parts import SITE
|
||||||
|
|
||||||
|
START = 1_800_000_000 // 3600 * 3600 # a Friday, on the hour (UTC)
|
||||||
|
|
||||||
|
|
||||||
|
def gauge(entity, asset):
|
||||||
|
return {"entity": entity, "asset": asset, "kind": "gauge", "unit": "W", "consent": True}
|
||||||
|
|
||||||
|
|
||||||
|
def heater(cid="living"):
|
||||||
|
return {"id": cid, "kind": "heating", "consent": True,
|
||||||
|
"entities": {"climate": f"climate.{cid}", "temp": f"sensor.{cid}_temp"}}
|
||||||
|
|
||||||
|
|
||||||
|
def site_mapping(tmp_path, assets, controls, inputs=None):
|
||||||
|
m = {"version": 3, "assets": [gauge("sensor.load", "load.power")] + assets,
|
||||||
|
"inputs": dict({"load_power": "sensor.load"}, **(inputs or {})), "controls": controls}
|
||||||
|
p = tmp_path / "mapping.yaml"
|
||||||
|
p.write_text(yaml.safe_dump(m))
|
||||||
|
return Mapping.load(str(p))
|
||||||
|
|
||||||
|
|
||||||
|
def watts(col, **vals):
|
||||||
|
col.on_entities({"a": {e.replace("__", "."): {"s": str(v), "a": {"unit_of_measurement": "W"}}
|
||||||
|
for e, v in vals.items()}})
|
||||||
|
|
||||||
|
|
||||||
|
# -- which meters come off the load -------------------------------------------------
|
||||||
|
def test_mapping_names_the_planned_devices_meters(tmp_path):
|
||||||
|
ev = {"id": "car", "kind": "ev", "consent": True, "entities": {"switch": "switch.ev"}}
|
||||||
|
m = site_mapping(tmp_path, [gauge("sensor.hp", "heatpump.power"), gauge("sensor.ac", "ac.power"),
|
||||||
|
gauge("sensor.wb1", "ev.1.power"), gauge("sensor.wb2", "ev.2.power")],
|
||||||
|
[heater(), ev])
|
||||||
|
# the heat pump and both chargers; not the A/C: no cooling control plans it, it stays in the base
|
||||||
|
assert m.inputs.controlled_power == ["sensor.hp", "sensor.wb1", "sensor.wb2"]
|
||||||
|
assert {"sensor.hp", "sensor.wb1", "sensor.wb2"} <= set(m.inputs.entities()) # watched
|
||||||
|
# the mapping's own list wins (an empty one: the load has none of them in it)
|
||||||
|
m = site_mapping(tmp_path, [gauge("sensor.hp", "heatpump.power")], [heater()], {"controlled_power": []})
|
||||||
|
assert m.inputs.controlled_power == []
|
||||||
|
m = site_mapping(tmp_path, [], [heater()], {"controlled_power": "sensor.heater_plug"})
|
||||||
|
assert m.inputs.controlled_power == ["sensor.heater_plug"]
|
||||||
|
|
||||||
|
|
||||||
|
def test_base_load_is_the_house_without_them(tmp_path):
|
||||||
|
m = site_mapping(tmp_path, [gauge("sensor.hp", "heatpump.power")], [heater()])
|
||||||
|
col = Collector()
|
||||||
|
assert base_load(col, m.inputs) is None # no load yet
|
||||||
|
watts(col, sensor__load=6400)
|
||||||
|
assert base_load(col, m.inputs) == 6400.0 # the heat pump's meter not there yet: 0
|
||||||
|
watts(col, sensor__hp=4000)
|
||||||
|
assert base_load(col, m.inputs) == 2400.0
|
||||||
|
col.on_entities({"a": {"sensor.hp": {"s": "4.5", "a": {"unit_of_measurement": "kW"}}}})
|
||||||
|
assert base_load(col, m.inputs) == 1900.0 # kW read as W
|
||||||
|
watts(col, sensor__hp=7000)
|
||||||
|
assert base_load(col, m.inputs) == 0.0 # never below 0 (meters out of step)
|
||||||
|
|
||||||
|
|
||||||
|
def test_model_state_plans_on_the_base_load(tmp_path):
|
||||||
|
"""The measured case of A2-a: the house meters 6400 W with its 4 kW
|
||||||
|
heater running; the plan's load is 2400 W, so the heater at 4 kW makes
|
||||||
|
6400 W of import, not 10 400 W; the grid order's base is 2400 W too."""
|
||||||
|
pytest.importorskip("highspy")
|
||||||
|
from cantabile_edge import optimizer
|
||||||
|
m = site_mapping(tmp_path, [gauge("sensor.hp", "heatpump.power")], [heater()])
|
||||||
|
col = Collector()
|
||||||
|
watts(col, sensor__load=6400, sensor__hp=4000, sensor__living_temp=15)
|
||||||
|
ctl = [Control("living", "heating", {"climate": "climate.living", "temp": "sensor.living_temp"}, True,
|
||||||
|
{"max_power_w": 4000.0, "comfort_c": 22.0, "setback_c": 22.0})]
|
||||||
|
b = Bundles(str(tmp_path / "none"), SITE)
|
||||||
|
s = model_state(START, ctl, m.inputs, col, b, None, "UTC", None)
|
||||||
|
assert s["load_w"] == [2400.0] * len(s["load_w"]) and s["sources"]["load"] == "now"
|
||||||
|
s["steps"] = 8
|
||||||
|
for k in ("load_w", "pv_w", "t_out", "sun", "occupied", "sky", "price_import", "price_export", "ghi_w_m2"):
|
||||||
|
s[k] = s[k][:8]
|
||||||
|
s["t_out"] = [-5.0] * 8
|
||||||
|
s["grid_order"] = {"limit_w": 4200.0, "from_step": 0, "to_step": 8, "penalty": 500.0}
|
||||||
|
mod = optimizer.Model(s)
|
||||||
|
mod.solve(10)
|
||||||
|
val = mod.h.getSolution().col_value
|
||||||
|
gin = val[mod.gin[0].index]
|
||||||
|
assert gin == pytest.approx(2400.0 + 4000.0, abs=1.0) # cold room: the heater full on
|
||||||
|
assert gin <= 2400.0 + 4200.0 + 1e-6 # the order's base is the base load
|
||||||
|
|
||||||
|
|
||||||
|
def model(**forecasts):
|
||||||
|
return {"v": 1, "kind": "model", "id": "m1", "site": SITE, "issued": 1,
|
||||||
|
"forecasts": {k: {"profile": "hour_of_week", "values": [v] * 168} for k, v in forecasts.items()}}
|
||||||
|
|
||||||
|
|
||||||
|
def test_which_model_series_is_the_base(tmp_path):
|
||||||
|
(tmp_path / "model.json").write_text(json.dumps(model(load_w=6000.0)))
|
||||||
|
b = Bundles(str(tmp_path), SITE)
|
||||||
|
col = Collector()
|
||||||
|
watts(col, sensor__load=6400, sensor__hp=4000)
|
||||||
|
with_hp = site_mapping(tmp_path, [gauge("sensor.hp", "heatpump.power")], [heater()])
|
||||||
|
s = model_state(START, [], with_hp.inputs, col, b, None, "UTC", None)
|
||||||
|
# the model's load_w is load.power with the heat pump in it: not the plan's load here
|
||||||
|
assert s["load_w"][0] == 2400.0 and "not used" in s["sources"]["load"]
|
||||||
|
without = site_mapping(tmp_path, [], [heater()]) # no meter of a planned device in the load
|
||||||
|
s = model_state(START, [], without.inputs, col, b, None, "UTC", None)
|
||||||
|
assert s["load_w"][0] == 6000.0 and s["sources"]["load"] == "model"
|
||||||
|
(tmp_path / "model.json").write_text(json.dumps(model(load_w=6000.0, base_load_w=1800.0)))
|
||||||
|
s = model_state(START, [], with_hp.inputs, col, Bundles(str(tmp_path), SITE), None, "UTC", None)
|
||||||
|
assert s["load_w"][0] == 1800.0 and s["sources"]["load"] == "model (base_load_w)"
|
||||||
|
|
||||||
|
|
||||||
|
# -- a room's fitted gains (B6-a) --------------------------------------------------
|
||||||
|
def room_model(tmp_path, **room):
|
||||||
|
m = model(load_w=500.0)
|
||||||
|
m["rooms"] = {"living": dict({"r_k_per_kw": 6.0, "c_kwh_per_k": 5.0}, **room)}
|
||||||
|
(tmp_path / "model.json").write_text(json.dumps(m))
|
||||||
|
return Bundles(str(tmp_path), SITE)
|
||||||
|
|
||||||
|
|
||||||
|
def test_bundle_carries_the_gains(tmp_path):
|
||||||
|
b = room_model(tmp_path, gain_w=300.0, solar_m2=4.0)
|
||||||
|
rc = b.room_rc("living")
|
||||||
|
assert (rc["gain_w"], rc["solar_m2"]) == (300.0, 4.0)
|
||||||
|
assert room_model(tmp_path, gain_w=[100.0] * 24).room_rc("living")["gain_w"] == [100.0] * 24
|
||||||
|
assert room_model(tmp_path, solar_m2=-3.0).room_rc("living")["solar_m2"] == 0.0 # a fit's artefact: cut
|
||||||
|
assert room_model(tmp_path).room_rc("living")["gain_w"] == 0.0 # an older bundle: none
|
||||||
|
bad = room_model(tmp_path, gain_w=[1.0] * 5)
|
||||||
|
assert bad.room_rc("living") is None and "gain_w" in bad.model.error
|
||||||
|
# into the model state: an electric fit's heat is cop times, like C
|
||||||
|
hp = Control("living", "heating", {"climate": "climate.living"}, True, {"cop": 3.0})
|
||||||
|
b = room_model(tmp_path, gain_w=100.0, solar_m2=2.0, power="electric")
|
||||||
|
s = model_state(START, [hp], site_mapping(tmp_path, [], []).inputs, Collector(), b, None, "UTC", None,
|
||||||
|
location={"latitude": 52.5, "longitude": 13.4})
|
||||||
|
p = s["devices"][0]["params"]
|
||||||
|
assert (p["internal_gain_w"], p["solar_m2"]) == (300.0, 6.0) and s["sources"]["rooms"]["living"] == "model"
|
||||||
|
# the irradiance for the sun: by day only (Berlin: 11:00 UTC near noon, 00:00 UTC night)
|
||||||
|
ghi = s["ghi_w_m2"]
|
||||||
|
noon = [ghi[k] for k in range(len(ghi)) if (START + k * 900) % 86400 == 11 * 3600]
|
||||||
|
night = [ghi[k] for k in range(len(ghi)) if (START + k * 900) % 86400 == 0]
|
||||||
|
assert min(noon) > 100 and max(night) == 0.0 and s["sources"]["ghi"] == "clear sky x the sky"
|
||||||
|
|
||||||
|
|
||||||
|
def test_planner_uses_the_gains():
|
||||||
|
"""With the fit's gains the room needs less heating, and with the
|
||||||
|
heating off it follows the fit's equation."""
|
||||||
|
pytest.importorskip("highspy")
|
||||||
|
from cantabile_edge import optimizer
|
||||||
|
from test_optimizer import heating, house
|
||||||
|
|
||||||
|
def heat_kwh(**gains):
|
||||||
|
d = heating(temp=21.0)
|
||||||
|
d["params"].update(gains)
|
||||||
|
s = house([d], steps=96)
|
||||||
|
s["ghi_w_m2"] = [500.0] * 96
|
||||||
|
s["occupied"], s["t_out"] = [1] * 96, [-10.0] * 96 # the heater always on, part load
|
||||||
|
m = optimizer.Model(s)
|
||||||
|
m.solve(20)
|
||||||
|
val = m.h.getSolution().col_value
|
||||||
|
return sum(val[v.index] for v in m.devices["heating"][1]["power"]) * 0.25 / 1000, m, val
|
||||||
|
none, _, _ = heat_kwh()
|
||||||
|
inner, _, _ = heat_kwh(internal_gain_w=500.0)
|
||||||
|
sun, _, _ = heat_kwh(solar_m2=1.0)
|
||||||
|
assert inner == pytest.approx(none - 0.5 * 24, abs=1.0) # 500 W for 24 h less to buy
|
||||||
|
assert sun == pytest.approx(none - 0.5 * 24, abs=1.0) # 1 m² x 500 W/m²
|
||||||
|
# the room's step with the heater off: (1 - a) T + a T_out + dt/C x gains
|
||||||
|
d = heating(temp=21.0, power=0)
|
||||||
|
d["params"].update(internal_gain_w=[0.0] * 12 + [1000.0] * 12) # by local hour
|
||||||
|
s = house([d], steps=8)
|
||||||
|
m = optimizer.Model(s)
|
||||||
|
m.solve(10)
|
||||||
|
val = m.h.getSolution().col_value
|
||||||
|
temps = [val[v.index] for v in m.devices["heating"][1]["temp"]]
|
||||||
|
a = 0.25 / 30
|
||||||
|
# START 00:00 UTC = 01:00 Berlin: hours 0..11 local, no gain
|
||||||
|
assert temps[0] == pytest.approx(21.0 * (1 - a) + a * 5.0, abs=1e-6)
|
||||||
|
assert m.hourly(list(range(24)))[:5] == [1.0, 1.0, 1.0, 1.0, 2.0] # 24 values: by the local hour
|
||||||
@@ -132,6 +132,27 @@ def test_tariff_and_fallbacks(tmp_path):
|
|||||||
assert b.prices(start, 900, 1, start).note.startswith("no tariff")
|
assert b.prices(start, 900, 1, start).note.startswith("no tariff")
|
||||||
|
|
||||||
|
|
||||||
|
def test_feed_in_at_zero_is_said(tmp_path):
|
||||||
|
"""Finding A1-a: where no export price is known the feed-in is 0 ct, and
|
||||||
|
the plan's note says so (no tariff, expired, no or a short export series)."""
|
||||||
|
b = Bundles(str(tmp_path), SITE, default_price_ct=33)
|
||||||
|
start = 1_800_000_000 // 900 * 900
|
||||||
|
p = b.prices(start, 900, 4, start)
|
||||||
|
assert p.export_ct == [0.0] * 4 and "feed-in at 0 ct/kWh" in p.note
|
||||||
|
t = {"v": 1, "kind": "tariff", "id": "t1", "site": SITE, "issued": start, "start": start, "step_s": 900,
|
||||||
|
"steps": 4, "expires": start + 7200, "currency": "EUR", "unit": "ct/kWh",
|
||||||
|
"import": [10, 10, 10, 10], "export": [5, 5, 5, 5]}
|
||||||
|
(tmp_path / "tariff.json").write_text(json.dumps(t))
|
||||||
|
assert b.prices(start, 900, 4, start).note == "tariff t1" # all priced: nothing to say
|
||||||
|
assert "feed-in at 0 ct/kWh" in b.prices(start, 900, 2, start + 7200).note # expired
|
||||||
|
t["export"] = [5, None, None, None]
|
||||||
|
(tmp_path / "tariff.json").write_text(json.dumps(t))
|
||||||
|
assert "feed-in at 0 ct/kWh in 3 of 4 steps" in b.prices(start, 900, 4, start).note
|
||||||
|
del t["export"]
|
||||||
|
(tmp_path / "tariff.json").write_text(json.dumps(t))
|
||||||
|
assert b.prices(start, 900, 4, start).note == "tariff t1; feed-in at 0 ct/kWh"
|
||||||
|
|
||||||
|
|
||||||
def test_model_bundle(tmp_path):
|
def test_model_bundle(tmp_path):
|
||||||
b = Bundles(str(tmp_path), SITE)
|
b = Bundles(str(tmp_path), SITE)
|
||||||
m = {"v": 1, "kind": "model", "id": "m1", "site": "*", "issued": 1,
|
m = {"v": 1, "kind": "model", "id": "m1", "site": "*", "issued": 1,
|
||||||
|
|||||||
@@ -0,0 +1,74 @@
|
|||||||
|
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
||||||
|
"""Heat is thermal (dashboards.py): a flat on district heat whose heat meter
|
||||||
|
shows 2200 W while its electricity is PV 37 W + grid 68 W = home 105 W. The
|
||||||
|
heat shows as heat from the building (thermal) in kW, in a band of its own
|
||||||
|
below the electricity, never in the electricity tiles or summed with them;
|
||||||
|
with a heat pump of the site, its electric power and the COP beside it."""
|
||||||
|
import json
|
||||||
|
|
||||||
|
import yaml
|
||||||
|
|
||||||
|
from cantabile_edge import dashboards as db
|
||||||
|
from cantabile_edge.mapping import Mapping
|
||||||
|
|
||||||
|
|
||||||
|
def st(eid, state, **attrs):
|
||||||
|
return {"entity_id": eid, "state": state, "attributes": attrs}
|
||||||
|
|
||||||
|
|
||||||
|
def home(tmp_path, heat_pump=False, lang="en"):
|
||||||
|
assets = [{"entity": "sensor.pv", "asset": "pv.power", "kind": "gauge", "unit": "W", "consent": True},
|
||||||
|
{"entity": "sensor.grid", "asset": "grid.power", "kind": "gauge", "unit": "W", "consent": True},
|
||||||
|
{"entity": "sensor.load", "asset": "load.power", "kind": "gauge", "unit": "W", "consent": True},
|
||||||
|
{"entity": "sensor.heat_power", "asset": "heat.power", "kind": "gauge", "unit": "W", "consent": True},
|
||||||
|
{"entity": "sensor.heat_energy", "asset": "heat.energy", "kind": "counter", "unit": "Wh", "consent": True}]
|
||||||
|
states = [st("sensor.pv", "37", unit_of_measurement="W", device_class="power"),
|
||||||
|
st("sensor.grid", "68", unit_of_measurement="W", device_class="power"),
|
||||||
|
st("sensor.load", "105", unit_of_measurement="W", device_class="power"),
|
||||||
|
st("sensor.heat_power", "2200", unit_of_measurement="W", device_class="power", friendly_name="Heat meter Heat power"),
|
||||||
|
st("sensor.heat_energy", "5120", unit_of_measurement="kWh", device_class="energy")]
|
||||||
|
if heat_pump:
|
||||||
|
assets.append({"entity": "sensor.hp", "asset": "heatpump.power", "kind": "gauge", "unit": "W", "consent": True})
|
||||||
|
states.append(st("sensor.hp", "550", unit_of_measurement="W", device_class="power"))
|
||||||
|
p = tmp_path / "m.yaml"
|
||||||
|
p.write_text(yaml.safe_dump({"version": 3, "assets": assets}))
|
||||||
|
reg = {"devices": [{"id": "hm", "name": "Heat meter", "manufacturer": "Sim", "model": "Heat meter"}],
|
||||||
|
"entities": [{"entity_id": e, "device_id": "hm", "platform": "mqtt", "unique_id": e}
|
||||||
|
for e in ("sensor.heat_power", "sensor.heat_energy")], "areas": []}
|
||||||
|
return db.Home(Mapping.load(str(p)), "cantabile_x", {}, [], lang, reg=reg, states=states)
|
||||||
|
|
||||||
|
|
||||||
|
def test_heat_is_thermal_and_apart(tmp_path):
|
||||||
|
h = home(tmp_path)
|
||||||
|
now = db.energy_now(h)
|
||||||
|
assert "sensor.heat_power" not in json.dumps(now) # not with solar, home, grid
|
||||||
|
band = db.heat_band(h)
|
||||||
|
text = json.dumps(band, ensure_ascii=False)
|
||||||
|
assert "Heat from the building (thermal)" in text and " kW" in text and "Heat today (thermal)" in text
|
||||||
|
assert "not part of solar, home or grid" in text and "COP" not in text
|
||||||
|
assert not any(c.get("type") == "tile" and c.get("entity") == "sensor.heat_power" for c in band)
|
||||||
|
ov = json.dumps(db.view_overview(h), ensure_ascii=False)
|
||||||
|
assert ov.index("Heat (thermal)") > ov.index("sensor.load") # its own band, below the electricity
|
||||||
|
# the heat meter's card: heat in kW, never a W tile
|
||||||
|
card = db.device_card(h, h.devices[0])
|
||||||
|
assert card and not any(c.get("entity") == "sensor.heat_power" for c in card["cards"])
|
||||||
|
assert "Heat from the building (thermal)" in json.dumps(card, ensure_ascii=False)
|
||||||
|
# the climate view: never electric and thermal in one graph
|
||||||
|
for sec in db.view_climate(h)["sections"]:
|
||||||
|
for c in sec["cards"]:
|
||||||
|
if c.get("type") == "history-graph":
|
||||||
|
assert not ({"sensor.heat_power"} & set(c["entities"]) and {"sensor.hp"} & set(c["entities"]))
|
||||||
|
|
||||||
|
|
||||||
|
def test_heat_pump_heat_and_cop(tmp_path):
|
||||||
|
h = home(tmp_path, heat_pump=True)
|
||||||
|
text = json.dumps(db.heat_band(h), ensure_ascii=False)
|
||||||
|
assert "Heat delivered (thermal)" in text and "Heat pump, electric" in text and "COP (heat ÷ electricity)" in text
|
||||||
|
graphs = [c for s in db.view_climate(h)["sections"] for c in s["cards"] if c.get("type") == "history-graph"]
|
||||||
|
assert ["sensor.hp"] in [g["entities"] for g in graphs] and ["sensor.heat_power"] in [g["entities"] for g in graphs]
|
||||||
|
|
||||||
|
|
||||||
|
def test_heat_in_german(tmp_path):
|
||||||
|
text = json.dumps(db.heat_band(home(tmp_path, lang="de")), ensure_ascii=False)
|
||||||
|
assert "Wärme aus dem Gebäude (thermisch)" in text and "Wärme heute (thermisch)" in text
|
||||||
|
assert "replace('.', ',')" in text
|
||||||
@@ -203,7 +203,7 @@ def test_flat_with_only_a_meter():
|
|||||||
assert "sensor.meter_rssi" not in str(v[sub]) # not diagnostics
|
assert "sensor.meter_rssi" not in str(v[sub]) # not diagnostics
|
||||||
assert h.view(r.devices[0]).profile == "shelly-pro-3em"
|
assert h.view(r.devices[0]).profile == "shelly-pro-3em"
|
||||||
assert "Grid" in str(b["now"])
|
assert "Grid" in str(b["now"])
|
||||||
assert energy_prefs(h)["energy_sources"][0]["flow_from"][0]["stat_energy_from"] == "sensor.meter_energy"
|
assert energy_prefs(h)["energy_sources"][0]["stat_energy_from"] == "sensor.meter_energy"
|
||||||
|
|
||||||
|
|
||||||
def villa() -> Reg:
|
def villa() -> Reg:
|
||||||
|
|||||||
@@ -10,7 +10,7 @@ import yaml
|
|||||||
|
|
||||||
from cantabile_edge import agent as agent_mod
|
from cantabile_edge import agent as agent_mod
|
||||||
from cantabile_edge.config import Config
|
from cantabile_edge.config import Config
|
||||||
from cantabile_edge.dashboards import dashboard, energy_prefs
|
from cantabile_edge.dashboards import dashboard, energy_prefs, legacy_grid
|
||||||
from cantabile_edge.ha import HAClient, HAError
|
from cantabile_edge.ha import HAClient, HAError
|
||||||
from cantabile_edge.mapping import Mapping
|
from cantabile_edge.mapping import Mapping
|
||||||
from cantabile_edge.store import Queue
|
from cantabile_edge.store import Queue
|
||||||
@@ -30,8 +30,10 @@ ASSETS = [
|
|||||||
class FakeHA(HAClient):
|
class FakeHA(HAClient):
|
||||||
"""HAClient with HA's answers in memory (its own checks stay)."""
|
"""HAClient with HA's answers in memory (its own checks stay)."""
|
||||||
|
|
||||||
def __init__(self, prefs=None, boards_=None, devices=(), entities=(), areas=(), states=None, panels=("app",)):
|
def __init__(self, prefs=None, boards_=None, devices=(), entities=(), areas=(), states=None, panels=("app",),
|
||||||
|
grid_form="unified"):
|
||||||
super().__init__("ws://fake", "t")
|
super().__init__("ws://fake", "t")
|
||||||
|
self.grid_form = grid_form
|
||||||
self.prefs, self.boards, self.sent, self.configs = prefs, boards_ or [], [], {}
|
self.prefs, self.boards, self.sent, self.configs = prefs, boards_ or [], [], {}
|
||||||
self.devices, self.entities, self.areas, self.states = list(devices), list(entities), list(areas), states
|
self.devices, self.entities, self.areas, self.states = list(devices), list(entities), list(areas), states
|
||||||
self.panels = {p: {} for p in panels}
|
self.panels = {p: {} for p in panels}
|
||||||
@@ -55,6 +57,13 @@ class FakeHA(HAClient):
|
|||||||
raise HAError("not_found")
|
raise HAError("not_found")
|
||||||
return self.prefs
|
return self.prefs
|
||||||
if type_ == "energy/save_prefs":
|
if type_ == "energy/save_prefs":
|
||||||
|
grids = [s for s in f.get("energy_sources", []) if s["type"] == "grid"]
|
||||||
|
# HA's check of the grid's form: 2026.10 (energy storage 1.3) a
|
||||||
|
# source per connection, earlier one with flow_from / flow_to
|
||||||
|
wrong = "stat_energy_from" if self.grid_form == "legacy" else "flow_from"
|
||||||
|
if any(wrong in g for g in grids) or (self.grid_form == "legacy" and len(grids) > 1):
|
||||||
|
raise HAError(str({"code": "invalid_format",
|
||||||
|
"message": f"not a valid option at 'energy_sources[0].{wrong}'"}))
|
||||||
self.prefs = f
|
self.prefs = f
|
||||||
return f
|
return f
|
||||||
if type_ == "lovelace/dashboards/list":
|
if type_ == "lovelace/dashboards/list":
|
||||||
@@ -121,10 +130,13 @@ def test_one_dashboard_with_views_from_what_the_home_has(tmp_path):
|
|||||||
assert all(len(s["cards"]) > 1 or s["cards"][0]["type"] != "heading" for s in view["sections"])
|
assert all(len(s["cards"]) > 1 or s["cards"][0]["type"] != "heading" for s in view["sections"])
|
||||||
assert {s["column_span"] for s in v["overview"]["sections"]} == {2} # bands: the whole width
|
assert {s["column_span"] for s in v["overview"]["sections"]} == {2} # bands: the whole width
|
||||||
# HA's Energy: grid with our price sensors
|
# HA's Energy: grid with our price sensors
|
||||||
grid = ha.prefs["energy_sources"][0]
|
assert ha.prefs["energy_sources"] == [{
|
||||||
assert grid["flow_from"][0] == {"stat_energy_from": "sensor.grid_in", "stat_cost": None,
|
"type": "grid", "cost_adjustment_day": 0,
|
||||||
"number_energy_price": None, "entity_energy_price": "sensor.c_price_import_now"}
|
"stat_energy_from": "sensor.grid_in", "stat_cost": None, "number_energy_price": None,
|
||||||
assert grid["flow_to"][0]["entity_energy_price"] == "sensor.c_price_export_now"
|
"entity_energy_price": "sensor.c_price_import_now",
|
||||||
|
"stat_energy_to": "sensor.grid_out", "stat_compensation": None, "number_energy_price_export": None,
|
||||||
|
"entity_energy_price_export": "sensor.c_price_export_now"}]
|
||||||
|
assert len([s for s in ha.sent if s[0] == "energy/save_prefs"]) == 1
|
||||||
# nothing changed: nothing saved again
|
# nothing changed: nothing saved again
|
||||||
n = len([s for s in ha.sent if s[0] == "lovelace/config/save"])
|
n = len([s for s in ha.sent if s[0] == "lovelace/config/save"])
|
||||||
asyncio.run(a.dashboards.ensure(ha))
|
asyncio.run(a.dashboards.ensure(ha))
|
||||||
@@ -263,6 +275,58 @@ def test_owner_energy_prefs_kept_and_other_boards_untouched(tmp_path):
|
|||||||
assert {"x", "inv"} <= ids and "old" not in ids # our retired one removed, others kept
|
assert {"x", "inv"} <= ids and "old" not in ids # our retired one removed, others kept
|
||||||
|
|
||||||
|
|
||||||
|
def test_energy_prefs_in_the_older_grid_form_for_an_older_ha(tmp_path):
|
||||||
|
"""HA before energy storage 1.3 refuses the unified grid: the agent
|
||||||
|
saves the same preferences with flow_from / flow_to instead."""
|
||||||
|
a = make(tmp_path)
|
||||||
|
ha = FakeHA(grid_form="legacy")
|
||||||
|
asyncio.run(a.dashboards.ensure(ha))
|
||||||
|
assert [s[0] for s in ha.sent].count("energy/save_prefs") == 2
|
||||||
|
assert ha.prefs["energy_sources"] == [{
|
||||||
|
"type": "grid", "cost_adjustment_day": 0,
|
||||||
|
"flow_from": [{"stat_energy_from": "sensor.grid_in", "stat_cost": None, "number_energy_price": None,
|
||||||
|
"entity_energy_price": "sensor.c_price_import_now"}],
|
||||||
|
"flow_to": [{"stat_energy_to": "sensor.grid_out", "stat_compensation": None, "number_energy_price": None,
|
||||||
|
"entity_energy_price": "sensor.c_price_export_now"}]}]
|
||||||
|
asyncio.run(a.dashboards.ensure(ha)) # saved: not again
|
||||||
|
assert [s[0] for s in ha.sent].count("energy/save_prefs") == 2
|
||||||
|
|
||||||
|
|
||||||
|
def test_energy_prefs_two_grid_meters_a_source_each_and_one_legacy_source():
|
||||||
|
want = {"energy_sources": [
|
||||||
|
{"type": "grid", "cost_adjustment_day": 0, "stat_energy_from": "sensor.a_in", "stat_cost": None,
|
||||||
|
"number_energy_price": None, "entity_energy_price": "sensor.p_in", "stat_energy_to": "sensor.a_out",
|
||||||
|
"stat_compensation": None, "number_energy_price_export": None, "entity_energy_price_export": "sensor.p_out"},
|
||||||
|
{"type": "grid", "cost_adjustment_day": 0, "stat_energy_from": "sensor.b_in", "stat_cost": None,
|
||||||
|
"number_energy_price": None, "entity_energy_price": "sensor.p_in", "stat_energy_to": None,
|
||||||
|
"stat_compensation": None, "number_energy_price_export": None, "entity_energy_price_export": None},
|
||||||
|
{"type": "solar", "stat_energy_from": "sensor.pv", "config_entry_solar_forecast": None}],
|
||||||
|
"device_consumption": []}
|
||||||
|
old = legacy_grid(want)
|
||||||
|
assert [s["type"] for s in old["energy_sources"]] == ["grid", "solar"]
|
||||||
|
g = old["energy_sources"][0]
|
||||||
|
assert [x["stat_energy_from"] for x in g["flow_from"]] == ["sensor.a_in", "sensor.b_in"]
|
||||||
|
assert g["flow_to"] == [{"stat_energy_to": "sensor.a_out", "stat_compensation": None,
|
||||||
|
"number_energy_price": None, "entity_energy_price": "sensor.p_out"}]
|
||||||
|
no_grid = {"energy_sources": want["energy_sources"][2:], "device_consumption": []}
|
||||||
|
assert legacy_grid(no_grid) is no_grid
|
||||||
|
|
||||||
|
|
||||||
|
def test_energy_prefs_other_errors_not_retried(tmp_path):
|
||||||
|
a = make(tmp_path)
|
||||||
|
ha = FakeHA()
|
||||||
|
|
||||||
|
async def refuse(type_, timeout=60, _events=None, **f):
|
||||||
|
if type_ == "energy/save_prefs":
|
||||||
|
ha.sent.append((type_, f))
|
||||||
|
raise HAError("unauthorized")
|
||||||
|
return await FakeHA._send(ha, type_, timeout, _events, **f)
|
||||||
|
ha._send = refuse
|
||||||
|
with pytest.raises(HAError):
|
||||||
|
asyncio.run(a.dashboards._energy(ha, a.dashboards.home({})))
|
||||||
|
assert [s[0] for s in ha.sent].count("energy/save_prefs") == 1
|
||||||
|
|
||||||
|
|
||||||
def test_client_refuses_other_dashboards():
|
def test_client_refuses_other_dashboards():
|
||||||
ha = FakeHA()
|
ha = FakeHA()
|
||||||
with pytest.raises(HAError):
|
with pytest.raises(HAError):
|
||||||
|
|||||||
@@ -111,20 +111,22 @@ class Site:
|
|||||||
def test_page_shows_ha_devices_with_their_profile_and_what_they_would_give(tmp_path):
|
def test_page_shows_ha_devices_with_their_profile_and_what_they_would_give(tmp_path):
|
||||||
s = Site(tmp_path)
|
s = Site(tmp_path)
|
||||||
out = s.req()
|
out = s.req()
|
||||||
assert "<nav>" in out and "?p=building" in out and "Devices</h2>" in out
|
assert "<nav>" in out and "?p=building" in out and "Devices<details" in out
|
||||||
assert out.count("Use with Cantabile</button>") == 2 # the inverter and the A/C
|
assert out.count("Use with Cantabile</button>") == 2 # the inverter and the A/C
|
||||||
assert "Cantabile would read: pv: power" in out and "battery: soc" in out
|
assert "Cantabile would read: solar power" in out and "battery charge" in out
|
||||||
assert "It could control: heating, cooling." in out and "generic profile" in out
|
assert "It could control: heating, cooling." in out and "generic profile" in out
|
||||||
assert "room: living room.temp" in out
|
assert "room temperature (Living room), setpoint, heating/cooling state" in out # words, never asset ids
|
||||||
|
assert "room: " not in out and "Devices in Home Assistant you can add" in out
|
||||||
assert "Proposed by Cantabile (not checked yet)" in out # the install's proposal
|
assert "Proposed by Cantabile (not checked yet)" in out # the install's proposal
|
||||||
assert "1 more in Home Assistant without a profile" in out and "Lamp" in out
|
assert "1 more in Home Assistant without a profile" in out and "Lamp" in out
|
||||||
assert "Used with Cantabile" not in out
|
assert "in use with Cantabile" not in out
|
||||||
|
|
||||||
|
|
||||||
def test_use_with_cantabile_writes_the_fragment_consent_off(tmp_path):
|
def test_use_with_cantabile_writes_the_fragment_consent_off(tmp_path):
|
||||||
s = Site(tmp_path)
|
s = Site(tmp_path)
|
||||||
out = s.post(do="use", ha_device=AC, profile="ha-thermostat", name="Living room A/C")
|
out = s.post(do="use", ha_device=AC, profile="ha-thermostat", name="Living room A/C")
|
||||||
assert "is used with Cantabile now" in out and s.changes == 1
|
assert "is used with Cantabile now" in out and s.changes == 1
|
||||||
|
assert "Reading and control" in out and "‹ Devices" in out # its own page
|
||||||
dev = next(iter(s.devices().values()))
|
dev = next(iter(s.devices().values()))
|
||||||
assert dev["ha_device"] == AC and dev["profile"] == "ha-thermostat" and not dev["read"] and not dev["control"]
|
assert dev["ha_device"] == AC and dev["profile"] == "ha-thermostat" and not dev["read"] and not dev["control"]
|
||||||
frag = s.frag(dev["id"])
|
frag = s.frag(dev["id"])
|
||||||
@@ -140,11 +142,14 @@ def test_use_with_cantabile_writes_the_fragment_consent_off(tmp_path):
|
|||||||
assert {t for t, e in prot.items() if e["level"] == "protected"} == {f"control:{c['id']}" for c in frag["controls"]}
|
assert {t for t, e in prot.items() if e["level"] == "protected"} == {f"control:{c['id']}" for c in frag["controls"]}
|
||||||
specs = json.loads((s.state / "devices-specs.json").read_text())["devices"]
|
specs = json.loads((s.state / "devices-specs.json").read_text())["devices"]
|
||||||
assert specs[dev["id"]]["profile"] == "ha-thermostat" and specs[dev["id"]]["ha_device"] == AC
|
assert specs[dev["id"]]["profile"] == "ha-thermostat" and specs[dev["id"]]["ha_device"] == AC
|
||||||
# the page: used, reading off, no second offer for it
|
# the list: in use, reading off, in words, no second offer for it
|
||||||
out = s.req()
|
out = s.req()
|
||||||
assert "Used with Cantabile" in out and "first give your consent in the add-on's configuration" in out
|
assert "1 device in use with Cantabile" in out and "Added · reading off · control off" in out
|
||||||
assert 'name="read"' not in out
|
assert f'href="?p=devices&d={dev["id"]}"' in out and "21.5 °C, set to 22 °C, idle" in out
|
||||||
assert out.count("Use with Cantabile</button>") == 1
|
assert out.count("Use with Cantabile</button>") == 1
|
||||||
|
out = s.req(query=f"p=devices&d={dev['id']}")
|
||||||
|
assert "first give your consent in the add-on's configuration" in out and 'name="read"' not in out
|
||||||
|
assert '<span class="badge quiet">untested</span>' in out
|
||||||
assert "This device is used with Cantabile already." in s.post(do="use", ha_device=AC, profile="ha-thermostat")
|
assert "This device is used with Cantabile already." in s.post(do="use", ha_device=AC, profile="ha-thermostat")
|
||||||
assert len(s.devices()) == 1
|
assert len(s.devices()) == 1
|
||||||
# the agent loads it: values and both controls, nothing consented
|
# the agent loads it: values and both controls, nothing consented
|
||||||
@@ -182,10 +187,10 @@ def test_a_hand_written_mapping_wins_and_one_writer_per_entity(tmp_path):
|
|||||||
"controls": [{"id": "heating", "kind": "heating", "consent": False, "entities": {"climate": "climate.living_ac"}}]}
|
"controls": [{"id": "heating", "kind": "heating", "consent": False, "entities": {"climate": "climate.living_ac"}}]}
|
||||||
s = Site(tmp_path, mapping=hand)
|
s = Site(tmp_path, mapping=hand)
|
||||||
out = s.req()
|
out = s.req()
|
||||||
assert "In your own mapping: room: living.temp. Those stay as they are." in out
|
assert "In your own mapping: room temperature (Living). Those stay as they are." in out
|
||||||
# the climate entity is the hand mapping's (read and written there):
|
# the climate entity is the hand mapping's (read and written there):
|
||||||
# nothing is left for the thermostat's fragment, and the page says why
|
# nothing is left for the thermostat's fragment, and the page says why
|
||||||
assert "Read by your own mapping already, so left out here: room: living room.temp" in out
|
assert "Read by your own mapping already, so left out here: room temperature (Living room)" in out
|
||||||
assert "Another control writes to this device already, so Cantabile leaves out: heating, cooling." in out
|
assert "Another control writes to this device already, so Cantabile leaves out: heating, cooling." in out
|
||||||
out = s.post(do="use", ha_device=AC, profile="ha-thermostat")
|
out = s.post(do="use", ha_device=AC, profile="ha-thermostat")
|
||||||
assert "or your mapping has them all already" in out and not (tmp_path / "state" / "devices.json").exists()
|
assert "or your mapping has them all already" in out and not (tmp_path / "state" / "devices.json").exists()
|
||||||
@@ -207,12 +212,12 @@ def test_reading_and_control_need_the_site_consent(tmp_path):
|
|||||||
assert not any(a["consent"] for a in s.frag(dev_id)["assets"]) and s.restarts == 0
|
assert not any(a["consent"] for a in s.frag(dev_id)["assets"]) and s.restarts == 0
|
||||||
# with it: the switches, as on the Hub's Devices page
|
# with it: the switches, as on the Hub's Devices page
|
||||||
s.give_consent(share=True, control=False)
|
s.give_consent(share=True, control=False)
|
||||||
out = s.req()
|
out = s.req(query=f"p=devices&d={dev_id}")
|
||||||
assert 'name="read"' in out and 'name="control"' in out
|
assert 'name="read"' in out and 'name="control"' in out
|
||||||
assert "Cantabile may control it (heating, cooling), within your limits" in out
|
assert "Cantabile may control it (heating, cooling), within your limits" in out
|
||||||
assert "Control also needs your consent to control devices" in out
|
assert "Control also needs your consent to control devices" in out
|
||||||
out = s.post(do="consent", id=dev_id, read="1")
|
out = s.post(do="consent", id=dev_id, read="1")
|
||||||
assert "Cantabile starts again" in out and s.restarts == 1
|
assert "Cantabile starts again" in out and s.restarts == 1 and "In use · reading on · control off" in out
|
||||||
assert s.devices()[dev_id]["read"] and not s.devices()[dev_id]["control"]
|
assert s.devices()[dev_id]["read"] and not s.devices()[dev_id]["control"]
|
||||||
frag = s.frag(dev_id)
|
frag = s.frag(dev_id)
|
||||||
assert all(a["consent"] for a in frag["assets"]) and not any(c["consent"] for c in frag["controls"])
|
assert all(a["consent"] for a in frag["assets"]) and not any(c["consent"] for c in frag["controls"])
|
||||||
@@ -232,7 +237,7 @@ def test_protection_and_heating_or_cooling(tmp_path):
|
|||||||
s.post(do="use", ha_device=AC, profile="ha-thermostat")
|
s.post(do="use", ha_device=AC, profile="ha-thermostat")
|
||||||
dev_id = next(iter(s.devices()))
|
dev_id = next(iter(s.devices()))
|
||||||
heat = next(c["id"] for c in s.frag(dev_id)["controls"] if c["kind"] == "heating")
|
heat = next(c["id"] for c in s.frag(dev_id)["controls"] if c["kind"] == "heating")
|
||||||
out = s.req()
|
out = s.req(query=f"p=devices&d={dev_id}")
|
||||||
assert "Allow switching off" in out
|
assert "Allow switching off" in out
|
||||||
out = s.req("POST", "p=devices", {"do": "protect", "id": dev_id, "target": f"control:{heat}", "level": "none"},
|
out = s.req("POST", "p=devices", {"do": "protect", "id": dev_id, "target": f"control:{heat}", "level": "none"},
|
||||||
hdr={"x-remote-user-display-name": "Ana"})
|
hdr={"x-remote-user-display-name": "Ana"})
|
||||||
@@ -242,7 +247,7 @@ def test_protection_and_heating_or_cooling(tmp_path):
|
|||||||
# a seal from the cloud: shown locked, nothing to lift, not removable
|
# a seal from the cloud: shown locked, nothing to lift, not removable
|
||||||
(s.state / "acl.json").write_text(json.dumps({"v": 1, "kind": "acl", "site": "ab" * 16, "entries": [
|
(s.state / "acl.json").write_text(json.dumps({"v": 1, "kind": "acl", "site": "ab" * 16, "entries": [
|
||||||
{"target": f"device:{dev_id}", "level": "sealed", "custodian": "grid_operator", "at": 1}]}))
|
{"target": f"device:{dev_id}", "level": "sealed", "custodian": "grid_operator", "at": 1}]}))
|
||||||
out = s.req()
|
out = s.req(query=f"p=devices&d={dev_id}")
|
||||||
assert "Sealed" in out and "only the grid operator can change it" in out
|
assert "Sealed" in out and "only the grid operator can change it" in out
|
||||||
assert "only they can change it" in s.post(do="protect", id=dev_id, target=f"device:{dev_id}", level="none")
|
assert "only they can change it" in s.post(do="protect", id=dev_id, target=f"device:{dev_id}", level="none")
|
||||||
assert "Sealed: only the grid operator can remove it." in s.post(do="remove", id=dev_id)
|
assert "Sealed: only the grid operator can remove it." in s.post(do="remove", id=dev_id)
|
||||||
@@ -291,7 +296,8 @@ def test_german(tmp_path):
|
|||||||
return s.req()
|
return s.req()
|
||||||
import contextvars
|
import contextvars
|
||||||
out = contextvars.copy_context().run(run)
|
out = contextvars.copy_context().run(run)
|
||||||
assert '<html lang="de">' in out and "Geräte</h2>" in out and "Mit Cantabile nutzen" in out
|
assert '<html lang="de">' in out and "Geräte<details" in out and "Mit Cantabile nutzen" in out
|
||||||
|
assert "Raumtemperatur (Living room)" in out and "Geräte in Home Assistant, die Sie hinzufügen können" in out
|
||||||
assert "Cantabile würde auslesen" in out and "Steuern könnte es: Heizen, Kühlen." in out
|
assert "Cantabile würde auslesen" in out and "Steuern könnte es: Heizen, Kühlen." in out
|
||||||
assert "Use with Cantabile" not in out
|
assert "Use with Cantabile" not in out
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,184 @@
|
|||||||
|
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
||||||
|
"""A charger's phases from the best evidence (evphases.py, Finding A8-a):
|
||||||
|
the mapping, the device, learned from power and current, else each use's
|
||||||
|
safe side (the grid order 3, the plan 1)."""
|
||||||
|
import asyncio
|
||||||
|
import json
|
||||||
|
import random
|
||||||
|
|
||||||
|
import pytest
|
||||||
|
import yaml
|
||||||
|
|
||||||
|
from cantabile_edge import evphases
|
||||||
|
from cantabile_edge.controls import Control, ev_volts
|
||||||
|
from cantabile_edge.evphases import EvPhases
|
||||||
|
from cantabile_edge.gridorder import GridOrders
|
||||||
|
from cantabile_edge.inputs import Collector
|
||||||
|
|
||||||
|
from test_gridorder import NOW, message
|
||||||
|
|
||||||
|
V = 230.0
|
||||||
|
|
||||||
|
|
||||||
|
def ev(cid="car", entities=None, **params):
|
||||||
|
return Control(cid, "ev", dict({"switch": "switch.wb"}, **(entities or {})), True, params)
|
||||||
|
|
||||||
|
|
||||||
|
def charge(store, cid, watts, amps, minutes=10, every=60, start=NOW, jitter=0.0, seed=1):
|
||||||
|
"""Samples of a charging car, every `every` s for `minutes`; True when a
|
||||||
|
learned count changed."""
|
||||||
|
rnd = random.Random(seed)
|
||||||
|
changed = False
|
||||||
|
for k in range(int(minutes * 60 / every) + 1):
|
||||||
|
w = watts * (1 + rnd.uniform(-jitter, jitter))
|
||||||
|
changed |= store.sample(cid, w, amps, V, start + k * every)
|
||||||
|
return changed
|
||||||
|
|
||||||
|
|
||||||
|
# -- the sources ----------------------------------------------------------------
|
||||||
|
def test_each_source(tmp_path):
|
||||||
|
col = Collector()
|
||||||
|
store = EvPhases(str(tmp_path))
|
||||||
|
assert store.resolve(ev(phases=1), col) == (1.0, "mapping")
|
||||||
|
dev = ev(entities={"phases": "sensor.wb_phases"})
|
||||||
|
assert store.resolve(dev, col) == (None, "assumed") # the sensor has no value yet
|
||||||
|
col.on_entities({"a": {"sensor.wb_phases": {"s": "1", "a": {}}}})
|
||||||
|
assert store.resolve(dev, col) == (1.0, "device")
|
||||||
|
assert store.resolve(ev(entities={"phases": "sensor.wb_phases"}, phases=3), col) == (3.0, "mapping") # mapping first
|
||||||
|
store.learned["car"] = {"phases": 1, "n": 1, "at": NOW}
|
||||||
|
assert store.resolve(ev(), col) == (1.0, "learned")
|
||||||
|
assert store.resolve(ev("other"), col) == (None, "assumed")
|
||||||
|
a = store.all([ev("other"), Control("bat", "battery", {"setpoint": "number.b"}, True, {})], col)
|
||||||
|
assert a == {"other": {"phases": None, "source": "assumed", "plan": 1.0, "order": 3.0}}
|
||||||
|
assert evphases.words(a["other"]).startswith("phases unknown: 3 assumed for the grid order, 1 for the plan")
|
||||||
|
assert evphases.words({"phases": 1.0, "source": "learned"}) == "1 phase, learned"
|
||||||
|
# each use's safe side
|
||||||
|
assert ev_volts({}, "order") == 690.0 and ev_volts({}, "plan") == 230.0
|
||||||
|
assert ev_volts({"phases": 3}, "plan") == 690.0 and ev_volts({"phases": 1}, "order") == 230.0
|
||||||
|
|
||||||
|
|
||||||
|
# -- learning ---------------------------------------------------------------------
|
||||||
|
def test_learns_one_and_three_phases(tmp_path):
|
||||||
|
store = EvPhases(str(tmp_path))
|
||||||
|
assert charge(store, "one", 16 * V * 0.98, 16.0, jitter=0.02) # 1 phase, 16 A: about 3.6 kW
|
||||||
|
assert charge(store, "three", 16 * V * 3 * 0.97, 16.0, jitter=0.02) # 3 phases, 16 A: about 10.7 kW
|
||||||
|
assert store.learned["one"]["phases"] == 1 and store.learned["three"]["phases"] == 3
|
||||||
|
# kept across a restart
|
||||||
|
again = EvPhases(str(tmp_path))
|
||||||
|
assert again.resolve(ev("one")) == (1.0, "learned") and again.resolve(ev("three")) == (3.0, "learned")
|
||||||
|
assert json.loads((tmp_path / "ev_phases.json").read_text())["one"]["n"] == 1
|
||||||
|
|
||||||
|
|
||||||
|
def test_unsteady_or_short_samples_decide_nothing(tmp_path):
|
||||||
|
store = EvPhases(str(tmp_path))
|
||||||
|
assert not charge(store, "car", 3 * 16 * V, 16.0, minutes=5) # too short
|
||||||
|
assert not charge(store, "car", 3 * 16 * V, 16.0, jitter=0.25, start=NOW + 3600) # power swings
|
||||||
|
assert not charge(store, "car", 800.0, 16.0, start=NOW + 7200) # below 1 kW
|
||||||
|
assert not charge(store, "car", 2.5 * 16 * V, 16.0, start=NOW + 9000) # ratio 2.5: between the steps
|
||||||
|
assert not charge(store, "car", 3 * 4 * V, 4.0, start=NOW + 12000) # 4 A: too little current
|
||||||
|
# a pause in the middle starts the window again
|
||||||
|
for k in range(6):
|
||||||
|
store.sample("car", 3 * 16 * V, 16.0, V, NOW + 20000 + k * 60)
|
||||||
|
store.sample("car", None, None, V, NOW + 20360)
|
||||||
|
for k in range(6):
|
||||||
|
assert not store.sample("car", 3 * 16 * V, 16.0, V, NOW + 20420 + k * 60)
|
||||||
|
assert "car" not in store.learned
|
||||||
|
|
||||||
|
|
||||||
|
def test_learned_again_when_readings_keep_disagreeing(tmp_path):
|
||||||
|
store = EvPhases(str(tmp_path))
|
||||||
|
charge(store, "car", 3 * 16 * V, 16.0)
|
||||||
|
assert store.learned["car"]["phases"] == 3
|
||||||
|
# a 1-phase car on the same charger: once is not enough
|
||||||
|
assert not charge(store, "car", 16 * V, 16.0, start=NOW + 3600)
|
||||||
|
assert store.learned["car"]["phases"] == 3 and store.learned["car"]["against"] == {"phases": 1, "n": 1}
|
||||||
|
charge(store, "car", 3 * 16 * V, 16.0, start=NOW + 7200) # agrees again: reset
|
||||||
|
assert "against" not in store.learned["car"] and store.learned["car"]["n"] == 2
|
||||||
|
for i in range(evphases.CONFIRM):
|
||||||
|
changed = charge(store, "car", 16 * V, 16.0, start=NOW + 10000 + i * 3600)
|
||||||
|
assert changed and store.learned["car"]["phases"] == 1
|
||||||
|
assert EvPhases(str(tmp_path)).learned["car"]["phases"] == 1
|
||||||
|
|
||||||
|
|
||||||
|
# -- the grid order ------------------------------------------------------------------
|
||||||
|
class C:
|
||||||
|
def __init__(self, id, params):
|
||||||
|
self.id, self.kind, self.params = id, "ev", params
|
||||||
|
|
||||||
|
|
||||||
|
def test_order_bound_never_above_the_order(tmp_path):
|
||||||
|
g = GridOrders(str(tmp_path), clock=lambda: NOW)
|
||||||
|
g.take(message()) # 4200 W
|
||||||
|
lim = g.limits([C("unknown", {}), C("three", {"phases": 3})], {"unknown": None})
|
||||||
|
for cid in ("unknown", "three"):
|
||||||
|
amps = lim[cid]["current_a"][1]
|
||||||
|
assert amps == 6.0 and amps * 3 * V <= 4200.0 # a 3-phase charger: never above 4.2 kW
|
||||||
|
# a 1-phase charger learned as one: 4200 / 230 = 18.26, down to 18.2 A (4186 W)
|
||||||
|
lim = g.limits([C("one", {})], {"one": 1.0})
|
||||||
|
assert lim["one"]["current_a"][1] == 18.2 and 18.2 * V <= 4200.0
|
||||||
|
|
||||||
|
|
||||||
|
def test_controller_learns_and_the_order_follows(tmp_path):
|
||||||
|
"""Through the controller: an order while the phases are unknown gives
|
||||||
|
6.0 A; the car charges on one phase for ten minutes (the charger's own
|
||||||
|
power sensor, its setpoint); the order's bound becomes 18.2 A, the plan
|
||||||
|
and the inventory say "1 phase, learned"."""
|
||||||
|
from cantabile_edge.config import Config
|
||||||
|
from cantabile_edge.consent import Consent
|
||||||
|
from cantabile_edge.controller import Controller
|
||||||
|
from cantabile_edge.inventory import build
|
||||||
|
from cantabile_edge.mapping import Mapping
|
||||||
|
m = tmp_path / "mapping.yaml"
|
||||||
|
m.write_text(yaml.safe_dump({"version": 3, "assets": [
|
||||||
|
{"entity": "sensor.wb_power", "asset": "ev.power", "kind": "gauge", "unit": "W", "consent": True}],
|
||||||
|
"controls": [{"id": "car", "kind": "ev", "consent": True,
|
||||||
|
"entities": {"switch": "switch.wb", "current": "number.wb_amps"}}]}))
|
||||||
|
t = [NOW]
|
||||||
|
mp = Mapping.load(str(m))
|
||||||
|
ctl = Controller(Config(site_id="ab" * 16, mapping=str(m), state_dir=str(tmp_path)), mp,
|
||||||
|
Consent(str(tmp_path)), sink=None, clock=lambda: t[0])
|
||||||
|
assert asyncio.run(ctl.grid_order(message(until=NOW + 7200).encode()))
|
||||||
|
assert ctl.guard.extra_limits["car"]["current_a"]["grid"] == (None, 6.0)
|
||||||
|
assert ctl.ev_phases()["car"]["source"] == "assumed"
|
||||||
|
ctl.col.on_entities({"a": {"number.wb_amps": {"s": "16", "a": {}}}})
|
||||||
|
changed = False
|
||||||
|
for k in range(11):
|
||||||
|
t[0] = NOW + k * 60
|
||||||
|
ctl.gridorders.received = t[0] # the bridge repeats its order every 15 s
|
||||||
|
ctl.col.on_entities({"a": {"sensor.wb_power": {"s": str(3650 + 10 * (k % 2)), "a": {"unit_of_measurement": "W"}}}})
|
||||||
|
if ctl.sample_ev_phases(t[0]):
|
||||||
|
changed = True
|
||||||
|
ctl._merge_limits()
|
||||||
|
assert changed and ctl.ev_phases()["car"] == {"phases": 1.0, "source": "learned", "plan": 1.0, "order": 1.0}
|
||||||
|
assert ctl.guard.extra_limits["car"]["current_a"]["grid"] == (None, 18.2)
|
||||||
|
st = ctl.model_state()
|
||||||
|
assert st["sources"]["ev_phases"]["car"] == {"phases": 1.0, "source": "learned"}
|
||||||
|
assert next(d for d in st["devices"] if d["id"] == "car")["params"]["phases"] == 1.0
|
||||||
|
reg = {"entities": [{"entity_id": e, "device_id": "wb"} for e in ("switch.wb", "number.wb_amps", "sensor.wb_power")],
|
||||||
|
"devices": [{"id": "wb", "manufacturer": "go-e", "model": "HOME"}]}
|
||||||
|
inv = build(mp, reg, {}, {}, t[0], ctl.ev_phases())
|
||||||
|
told = [d["ev_phases"] for d in inv["devices"] if d.get("ev_phases")]
|
||||||
|
assert told == [{"car": {"phases": 1.0, "source": "learned"}}]
|
||||||
|
|
||||||
|
|
||||||
|
def test_plan_takes_the_count_and_says_it():
|
||||||
|
"""The plan: unknown phases are planned at 1 (230 V per A), a learned
|
||||||
|
3 at 690 V per A; the EV's entries say which and why."""
|
||||||
|
pytest.importorskip("highspy")
|
||||||
|
from cantabile_edge import optimizer
|
||||||
|
from cantabile_edge.controls import PARAMS
|
||||||
|
from test_optimizer import house
|
||||||
|
|
||||||
|
def plan(phases, source):
|
||||||
|
d = {"id": "ev", "kind": "ev", "channels": ["switch", "current"],
|
||||||
|
"params": dict(PARAMS["ev"], need_wh=5000, phases=phases),
|
||||||
|
"state": {"connected": True}, "bounds": {"current_a": [0, 16, "device", "device"]}}
|
||||||
|
s = house([d])
|
||||||
|
s["sources"] = {"ev_phases": {"ev": {"phases": phases, "source": source}}}
|
||||||
|
m = optimizer.Model(s)
|
||||||
|
m.solve(20)
|
||||||
|
return m.devices["ev"][1]["volts"], optimizer.plan(s, 20)["devices"]["ev"]
|
||||||
|
volts, entries = plan(None, "assumed")
|
||||||
|
assert volts == 230.0 and any("1 for the plan" in e["why"] for e in entries)
|
||||||
|
volts, entries = plan(3.0, "learned")
|
||||||
|
assert volts == 690.0 and any("3 phases, learned" in e["why"] for e in entries)
|
||||||
@@ -115,7 +115,7 @@ def test_model_constraint_and_limits(tmp_path):
|
|||||||
def __init__(self, id, kind, params):
|
def __init__(self, id, kind, params):
|
||||||
self.id, self.kind, self.params = id, kind, params
|
self.id, self.kind, self.params = id, kind, params
|
||||||
lim = g.limits([C("ev", "ev", {"phases": 3, "voltage": 230}), C("bat", "battery", {}), C("room", "heating", {})])
|
lim = g.limits([C("ev", "ev", {"phases": 3, "voltage": 230}), C("bat", "battery", {}), C("room", "heating", {})])
|
||||||
assert lim == {"ev": {"current_a": (None, 6.1)}, "bat": {"power_w": (None, 4200.0)}}
|
assert lim == {"ev": {"current_a": (None, 6.0)}, "bat": {"power_w": (None, 4200.0)}}
|
||||||
|
|
||||||
|
|
||||||
highspy = pytest.importorskip("highspy")
|
highspy = pytest.importorskip("highspy")
|
||||||
@@ -160,7 +160,7 @@ def test_controller_takes_an_order(tmp_path):
|
|||||||
got = []
|
got = []
|
||||||
ctl.on_received.append(lambda ev: _append(got, ev))
|
ctl.on_received.append(lambda ev: _append(got, ev))
|
||||||
assert asyncio.run(ctl.grid_order(message().encode()))
|
assert asyncio.run(ctl.grid_order(message().encode()))
|
||||||
assert ctl.guard.extra_limits["car"]["current_a"] == {"cloud": (None, 10.0), "grid": (None, 6.1)}
|
assert ctl.guard.extra_limits["car"]["current_a"] == {"cloud": (None, 10.0), "grid": (None, 6.0)}
|
||||||
assert got and got[0]["by"] == "grid" and got[0]["args"]["level"] == "emergency" and "proof" not in got[0]["args"]
|
assert got and got[0]["by"] == "grid" and got[0]["args"]["level"] == "emergency" and "proof" not in got[0]["args"]
|
||||||
st = ctl.gridorders.for_model(NOW, 900, 192)
|
st = ctl.gridorders.for_model(NOW, 900, 192)
|
||||||
assert st["limit_w"] == 4200.0
|
assert st["limit_w"] == 4200.0
|
||||||
@@ -181,3 +181,47 @@ def test_inventory_carries_the_eebus_ski():
|
|||||||
# anything but a SKI is left out (the platform would refuse the inventory)
|
# anything but a SKI is left out (the platform would refuse the inventory)
|
||||||
assert _eebus({"identifiers": [["mqtt", "cantabile_eebus_cb_c0b05c"]], "serial_number": "c0b05c0a"}) == {}
|
assert _eebus({"identifiers": [["mqtt", "cantabile_eebus_cb_c0b05c"]], "serial_number": "c0b05c0a"}) == {}
|
||||||
assert _eebus({"identifiers": [["mqtt", "cantabile_modbus_x"]], "serial_number": "1"}) == {}
|
assert _eebus({"identifiers": [["mqtt", "cantabile_modbus_x"]], "serial_number": "1"}) == {}
|
||||||
|
|
||||||
|
|
||||||
|
def test_the_order_reaches_the_cloud_once_per_quarter_hour(tmp_path):
|
||||||
|
"""An action per ledger slot while the order holds (and on a change),
|
||||||
|
one when it ends: fleet's market ledger exempts those slots."""
|
||||||
|
t = [NOW]
|
||||||
|
g = GridOrders(str(tmp_path), clock=lambda: t[0])
|
||||||
|
assert g.action() is None # no order: nothing
|
||||||
|
g.take(message(until=NOW + 1800))
|
||||||
|
a = g.action()
|
||||||
|
assert (a["entity"], a["service"], a["value"], a["result"]) == ("grid:eebus-lpc", "grid.load_limit", "4200.0", "done")
|
||||||
|
assert "grid operator's order" in a["why"] and "cb01" in a["why"] and len(a["why"]) <= 500
|
||||||
|
assert g.action() is None # the same slot: told already
|
||||||
|
t[0] = (NOW // gridorder.SLOT_S + 1) * gridorder.SLOT_S + 5 # the next quarter-hour
|
||||||
|
assert g.action()["at"] == t[0]
|
||||||
|
g.take(message(until=NOW + 1800, limit_w=3000.0)) # a new limit in the same slot
|
||||||
|
assert g.action()["value"] == "3000.0"
|
||||||
|
t[0] = NOW + 1801 # over
|
||||||
|
end = g.action()
|
||||||
|
assert end["value"] == "" and "ended" in end["why"]
|
||||||
|
assert g.action() is None
|
||||||
|
|
||||||
|
|
||||||
|
def test_controller_publishes_the_order_as_an_action(tmp_path):
|
||||||
|
import yaml
|
||||||
|
from cantabile_edge.config import Config
|
||||||
|
from cantabile_edge.consent import Consent
|
||||||
|
from cantabile_edge.controller import Controller
|
||||||
|
from cantabile_edge.mapping import Mapping
|
||||||
|
m = tmp_path / "mapping.yaml"
|
||||||
|
m.write_text(yaml.safe_dump({"version": 3, "assets": [], "controls": []}))
|
||||||
|
|
||||||
|
class Sink:
|
||||||
|
def __init__(self):
|
||||||
|
self.sent = []
|
||||||
|
|
||||||
|
async def publish(self, kind, data):
|
||||||
|
self.sent.append((kind, data))
|
||||||
|
sink = Sink()
|
||||||
|
ctl = Controller(Config(site_id="ab" * 16, mapping=str(m), state_dir=str(tmp_path)), Mapping.load(str(m)),
|
||||||
|
Consent(str(tmp_path)), sink=sink, clock=lambda: NOW)
|
||||||
|
assert asyncio.run(ctl.grid_order(message().encode()))
|
||||||
|
assert [k for k, _ in sink.sent].count("action") == 1
|
||||||
|
assert [d for k, d in sink.sent if k == "action"][0]["service"] == "grid.load_limit"
|
||||||
@@ -0,0 +1,25 @@
|
|||||||
|
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
||||||
|
"""Inputs the plan steers by count as fresh while they have a value: a room
|
||||||
|
that holds 23.5 °C for hours or a full battery is not a stopped sensor (the
|
||||||
|
clone, 2026-10-30); unavailable is."""
|
||||||
|
from types import SimpleNamespace
|
||||||
|
|
||||||
|
from cantabile_edge.controller import Controller
|
||||||
|
from cantabile_edge.inputs import Collector
|
||||||
|
|
||||||
|
|
||||||
|
def fresh(states: dict) -> bool:
|
||||||
|
col = Collector()
|
||||||
|
col.on_entities({"a": {e: {"s": s, "lc": 1_000_000} for e, s in states.items()}}, now=1_000_000)
|
||||||
|
ctl = SimpleNamespace(col=col, clock=lambda: 1_000_000 + 6 * 3600,
|
||||||
|
controls=[SimpleNamespace(entities={"temp": "sensor.room", "soc": "sensor.soc"})])
|
||||||
|
return Controller.inputs_fresh(ctl)
|
||||||
|
|
||||||
|
|
||||||
|
def test_steady_values_are_fresh():
|
||||||
|
assert fresh({"sensor.room": "23.5", "sensor.soc": "100"})
|
||||||
|
|
||||||
|
|
||||||
|
def test_unavailable_is_not():
|
||||||
|
assert not fresh({"sensor.room": "unavailable", "sensor.soc": "100"})
|
||||||
|
assert not fresh({"sensor.room": "23.5"})
|
||||||
@@ -0,0 +1,184 @@
|
|||||||
|
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
||||||
|
"""The shadow market's bundle as fleet makes it (platform/services/fleet/
|
||||||
|
marketbundle.go; the market's step 1.5): read by the agent (bundles.py),
|
||||||
|
shown in HA as sensors only (announce.py: the exchange per contract, the
|
||||||
|
net position, the shared energy's price, the border actuators' contract
|
||||||
|
target against their state), unavailable when stale, and as the
|
||||||
|
dashboard's Market band (dashboards.py), in English and German."""
|
||||||
|
import asyncio
|
||||||
|
import json
|
||||||
|
import time
|
||||||
|
|
||||||
|
from cantabile_edge import names
|
||||||
|
from cantabile_edge.bundles import Bundles
|
||||||
|
from cantabile_edge.dashboards import Home, dashboard, market_band
|
||||||
|
|
||||||
|
from test_announce import make, put
|
||||||
|
from test_control_parts import SITE
|
||||||
|
from test_dashboards import FakeHA, make as make_agent, views, cards
|
||||||
|
|
||||||
|
UID = f"cantabile_{SITE}"
|
||||||
|
K1 = "0243f0a0-8c1f-4fae-8e7f-9d2e75cd86f4"
|
||||||
|
|
||||||
|
|
||||||
|
def bundle(now, **kw):
|
||||||
|
slot = int(now // 900 * 900)
|
||||||
|
return {"v": 1, "kind": "market", "id": "mb1", "site": SITE, "issued": int(now), "expires": int(now) + 6 * 3600,
|
||||||
|
"shadow": True, "commands": "none", "note": "Shadow market", "slot": slot, "step_s": 900, "stale_after_s": 3600,
|
||||||
|
"nodes": [{"id": f"site:{SITE}", "kind": "site", "name": "Haus Rose"}],
|
||||||
|
"contracts": [{"id": K1, "name": "Rose to Linde", "template": "neighbour_pv_share", "node": f"site:{SITE}",
|
||||||
|
"direction": "sells", "counterpart": {"name": "Home B", "type": "home"}, "link": "L1",
|
||||||
|
"link_kind": "direct_line", "version": 1,
|
||||||
|
"slot": {"applies": True, "guaranteed_kwh": 0, "minimum_kwh": 0, "max_kwh": 1.5, "price_ct": 16.4},
|
||||||
|
"last": {"slot": slot - 900, "measured": True, "metered_kwh": 1.2, "guaranteed_kwh": 0, "max_kwh": 1.5,
|
||||||
|
"delivered_kwh": 1.2, "deviation_kwh": 0, "kind": "", "cause": "", "exempt": False,
|
||||||
|
"exempt_why": "", "price_ct": 16.4, "penalty_eur": 0},
|
||||||
|
"period": {"period": "month", "start": slot - 86400, "slots": 96, "unmeasured": 0, "exempt_slots": 0,
|
||||||
|
"guaranteed_kwh": 0, "delivered_kwh": 31.5, "amount_eur": 5.17,
|
||||||
|
"penalties_paid_eur": 0, "penalties_received_eur": 0}},
|
||||||
|
{"id": "flats:b1:sells", "name": "Flats, summed", "node": "building:b1", "direction": "sells",
|
||||||
|
"counterpart": {"name": "3 flat(s)", "type": "homes", "count": 3}, "link": "", "link_kind": "building_internal",
|
||||||
|
"slot": {"applies": False, "price_ct": 24}, "last": None,
|
||||||
|
"period": {"period": "quarter", "delivered_kwh": 2, "amount_eur": 0.48}}],
|
||||||
|
"links": [{"id": "L1", "kind": "direct_line", "node": f"site:{SITE}", "counterpart": {"name": "Home B", "type": "home"},
|
||||||
|
"measurement": {"kind": "meter", "trust": "high", "at": "self", "kwh": 1.2}, "contracts": [K1]}],
|
||||||
|
"actuators": [{"link": "L1", "device": "relay-1", "name": "Shelly Pro 1PM", "controls": ["boiler"], "protection": "protected",
|
||||||
|
"default_state": "off", "default_set": True, "fallback_s": 600,
|
||||||
|
"target": {"state": "on", "kw": 6, "why": "contract in this slot: Rose to Linde"},
|
||||||
|
"last": {"value": "on", "at": slot - 600, "result": "done"}}],
|
||||||
|
"positions": [{"node": f"site:{SITE}", "period": "month", "start": slot - 86400, "sold_kwh": 31.5, "bought_kwh": 0,
|
||||||
|
"net_kwh": -31.5, "receives_eur": 5.17, "pays_eur": 0, "penalties_paid_eur": 0,
|
||||||
|
"penalties_received_eur": 0, "net_eur": 5.17}], **kw}
|
||||||
|
|
||||||
|
|
||||||
|
def test_read_refused_and_stale(tmp_path):
|
||||||
|
now = time.time()
|
||||||
|
b = Bundles(str(tmp_path), SITE)
|
||||||
|
put(tmp_path / "market.json", bundle(now))
|
||||||
|
m = b.market_now(now)
|
||||||
|
assert m is not None and not m["stale"] and m["contracts"][0]["id"] == K1
|
||||||
|
assert b.market_now(now + 3 * 900)["stale"] is False
|
||||||
|
assert b.market_now(now + 5 * 900)["stale"] is True # older than stale_after_s: four slots
|
||||||
|
assert b.market_now(now + 7 * 3600) is None # expired
|
||||||
|
put(tmp_path / "market.json", bundle(now, site="00" * 16)) # another site's
|
||||||
|
assert b.market_now(now) is None
|
||||||
|
put(tmp_path / "market.json", bundle(now, commands="load_limit")) # not shadow only: refused
|
||||||
|
assert b.market_now(now) is None and "shadow only" in b.market.error
|
||||||
|
put(tmp_path / "market.json", bundle(now, shadow=False))
|
||||||
|
assert b.market_now(now) is None
|
||||||
|
put(tmp_path / "market.json", bundle(now, contracts=[], actuators=[])) # nothing in it: nothing shown
|
||||||
|
assert b.market_now(now) is None
|
||||||
|
|
||||||
|
|
||||||
|
def test_entities_and_state(tmp_path):
|
||||||
|
a, ann = make(tmp_path)
|
||||||
|
for c in a.control.controls:
|
||||||
|
if c.id == "boiler":
|
||||||
|
c.device = "relay-1" # the box's device it came with (a mapping fragment's)
|
||||||
|
now = time.time()
|
||||||
|
put(tmp_path / "market.json", bundle(now))
|
||||||
|
objs = ann.objects()
|
||||||
|
k = K1.replace("-", "_")
|
||||||
|
ex = objs[(UID, "sensor", f"market_{k}")]
|
||||||
|
assert ex["name"] == "Exchange with Home B" and ex["unit_of_measurement"] == "kW" and ex["device_class"] == "power"
|
||||||
|
assert ex["availability_mode"] == "all" and {x["topic"] for x in ex["availability"]} == {
|
||||||
|
f"cantabile/{SITE}/availability", f"cantabile/{SITE}/market/availability"}
|
||||||
|
assert "availability_topic" not in ex
|
||||||
|
assert objs[(UID, "sensor", "market_flats_b1_sells")]["name"] == "Exchange with 3 flats, summed"
|
||||||
|
assert objs[(UID, "sensor", "market_position")]["unit_of_measurement"] == "kWh"
|
||||||
|
assert objs[(UID, "sensor", "market_price")]["unit_of_measurement"] == "EUR/kWh"
|
||||||
|
act = objs[(UID, "sensor", "market_actuator_relay_1")]
|
||||||
|
assert act["name"] == "Shelly Pro 1PM: contract target"
|
||||||
|
# sensors only: no switch, number, select or button of the market
|
||||||
|
assert not [o for (_, comp, o) in objs if o.startswith("market") and comp != "sensor"]
|
||||||
|
assert ex["default_entity_id"] == f"sensor.cantabile_market_{k}"
|
||||||
|
|
||||||
|
# the state: kW of the last quarter-hour, the sentence, the actuator against HA's own state
|
||||||
|
a.control.col.on_entities({"a": {"switch.boiler": {"s": "off"}}}, now)
|
||||||
|
st = ann.market_state(a.control.bundles.market_now(now))
|
||||||
|
c = st["contracts"][k]
|
||||||
|
assert c["kw"] == 4.8 and c["kwh_period"] == 31.5 and c["trust"] == "high" and c["shadow"] is True
|
||||||
|
assert c["summary"] == "Sells to Home B: 1.20 kWh last quarter-hour (contract 1.50) · 16.4 ct/kWh · shadow"
|
||||||
|
assert "So far this month: 31.5 kWh · 5.17 €" == c["period_words"]
|
||||||
|
flats = st["contracts"]["flats_b1_sells"]
|
||||||
|
assert flats["kw"] is None and "not in force" in flats["summary"] and "quarter" in flats["period_words"]
|
||||||
|
assert st["price"]["now"] == 16.4 # the contracts in force this slot
|
||||||
|
r = st["actuators"]["relay_1"]
|
||||||
|
assert r["target"] == "on" and r["actual"] == "off" and r["agrees"] is False
|
||||||
|
assert "contract: **on** (6.0 kW) · now: **off**" in r["words"] and "falls back to off after 10 min" in r["words"]
|
||||||
|
assert st["positions"]["market_position"]["net_kwh"] == -31.5
|
||||||
|
|
||||||
|
# German
|
||||||
|
a.ha_language = "de"
|
||||||
|
objs = ann.objects()
|
||||||
|
assert objs[(UID, "sensor", f"market_{k}")]["name"] == "Austausch mit Home B"
|
||||||
|
assert objs[(UID, "sensor", "market_actuator_relay_1")]["name"] == "Shelly Pro 1PM: Vertragsvorgabe"
|
||||||
|
c = ann.market_state(a.control.bundles.market_now(now))["contracts"][k]
|
||||||
|
assert c["summary"] == "Verkauft an Home B: 1,20 kWh letzte Viertelstunde (Vertrag 1,50) · 16,4 ct/kWh · Schattenbetrieb"
|
||||||
|
|
||||||
|
# off: nothing of the market in HA; no bundle: nothing either
|
||||||
|
put(tmp_path / "market.json", bundle(now, site="00" * 16))
|
||||||
|
assert not [o for (_, _, o) in ann.objects() if o.startswith("market")]
|
||||||
|
|
||||||
|
|
||||||
|
def test_stale_goes_unavailable(tmp_path):
|
||||||
|
a, ann = make(tmp_path)
|
||||||
|
now = time.time()
|
||||||
|
put(tmp_path / "market.json", bundle(now - 2 * 3600, expires=int(now) + 3600))
|
||||||
|
|
||||||
|
class Pub:
|
||||||
|
def __init__(self):
|
||||||
|
self.out = {}
|
||||||
|
|
||||||
|
async def publish(self, topic, payload, retain=False):
|
||||||
|
self.out[topic] = payload
|
||||||
|
p = Pub()
|
||||||
|
ann.client = p
|
||||||
|
|
||||||
|
async def cloud():
|
||||||
|
return True
|
||||||
|
a.cloud = cloud
|
||||||
|
asyncio.run(ann._states())
|
||||||
|
assert p.out[f"cantabile/{SITE}/market/availability"] == "offline"
|
||||||
|
assert json.loads(p.out[f"cantabile/{SITE}/market"])["stale"] is True
|
||||||
|
put(tmp_path / "market.json", bundle(now))
|
||||||
|
asyncio.run(ann._states())
|
||||||
|
assert p.out[f"cantabile/{SITE}/market/availability"] == "online"
|
||||||
|
|
||||||
|
|
||||||
|
def test_dashboard_band(tmp_path):
|
||||||
|
now = time.time()
|
||||||
|
k = K1.replace("-", "_")
|
||||||
|
ents = [{"platform": "mqtt", "unique_id": f"{UID}_{s}", "entity_id": f"sensor.c_{s}"}
|
||||||
|
for s in (f"market_{k}", "market_flats_b1_sells", "market_position", "market_price", "market_actuator_relay_1")]
|
||||||
|
ha = FakeHA(entities=ents)
|
||||||
|
a = make_agent(tmp_path)
|
||||||
|
put(tmp_path / "market.json", bundle(now))
|
||||||
|
from cantabile_edge.dashboards import Dashboards
|
||||||
|
asyncio.run(Dashboards(a).ensure(ha))
|
||||||
|
over = views(ha)["overview"]
|
||||||
|
band = [s for s in over["sections"] if s["cards"] and s["cards"][0].get("heading") == "Market (shadow)"]
|
||||||
|
assert len(band) == 1 and band[0]["column_span"] == 2
|
||||||
|
cs = band[0]["cards"][1:]
|
||||||
|
widths = [c["grid_options"]["columns"] for c in cs]
|
||||||
|
assert widths[:2] == [12, 12] # the position and the price: halves of the row (no hole)
|
||||||
|
assert widths[2:4] == [12, 12] # a card per contract: halves
|
||||||
|
assert all(c["type"] in ("tile", "markdown") for c in cs)
|
||||||
|
text = json.dumps(cs, ensure_ascii=False)
|
||||||
|
assert "state_attr(e, 'summary')" in text and "sensor.c_market_actuator_relay_1" in text and "ⓘ" in text
|
||||||
|
# no contracts: no band
|
||||||
|
put(tmp_path / "market.json", bundle(now, contracts=[]))
|
||||||
|
h = Home(a.mapping, UID, {e["unique_id"]: e["entity_id"] for e in ents}, [], "en",
|
||||||
|
market=a.control.bundles.market_now(now))
|
||||||
|
assert market_band(h) is None
|
||||||
|
# German heading
|
||||||
|
h = Home(a.mapping, UID, {e["unique_id"]: e["entity_id"] for e in ents}, [], "de", market=bundle(now))
|
||||||
|
assert market_band(h)["cards"][0]["heading"] == "Markt (Schattenbetrieb)"
|
||||||
|
assert dashboard(h) is not None
|
||||||
|
|
||||||
|
|
||||||
|
def test_names_have_german():
|
||||||
|
for key in [k for k in names.NAMES if k.startswith(("market_", "mk_")) or k == "card_market"]:
|
||||||
|
assert names.NAMES[key].get("de") and names.NAMES[key].get("en"), key
|
||||||
|
en, de = names.NAMES[key]["en"], names.NAMES[key]["de"]
|
||||||
|
assert sorted(x for x in en if x in "0123456789") == sorted(x for x in de if x in "0123456789"), key # the same {n}s
|
||||||
@@ -0,0 +1,221 @@
|
|||||||
|
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
||||||
|
"""The market's contracts in the plan (step 2, minimal; shadow):
|
||||||
|
a contract is an import source or an export sink at its price, next to the
|
||||||
|
grid; the plan uses it where it beats the grid, within its bounds."""
|
||||||
|
import json
|
||||||
|
import time
|
||||||
|
|
||||||
|
import pytest
|
||||||
|
|
||||||
|
highspy = pytest.importorskip("highspy")
|
||||||
|
|
||||||
|
from cantabile_edge import optimizer # noqa: E402
|
||||||
|
from cantabile_edge.bundles import Bundles # noqa: E402
|
||||||
|
|
||||||
|
START = 1793232000
|
||||||
|
STEPS = 16
|
||||||
|
|
||||||
|
|
||||||
|
def house(market=None, load=1000.0, pv=0.0, imp=30.0, exp=8.0):
|
||||||
|
s = {"v": 1, "start": START, "step_s": 900, "steps": STEPS, "tz": "Europe/Berlin",
|
||||||
|
"price_import": [imp] * STEPS, "price_export": [exp] * STEPS, "price_note": "test",
|
||||||
|
"load_w": [load] * STEPS, "pv_w": [pv] * STEPS, "t_out": [5.0] * STEPS,
|
||||||
|
"sun": [0.0] * STEPS, "occupied": [1] * STEPS, "devices": []}
|
||||||
|
if market is not None:
|
||||||
|
s["market"] = market
|
||||||
|
return s
|
||||||
|
|
||||||
|
|
||||||
|
def contract(direction, price, max_w=0.0, guaranteed_w=0.0, minimum_wh=0.0, a=0, b=8, cid="c1"):
|
||||||
|
return {"id": cid, "name": cid, "direction": direction, "price_ct": price, "max_w": max_w,
|
||||||
|
"guaranteed_w": guaranteed_w, "minimum_wh": minimum_wh, "from_step": a, "to_step": b}
|
||||||
|
|
||||||
|
|
||||||
|
def kwh(p, cid="c1"):
|
||||||
|
return next(c for c in p["market"] if c["id"] == cid)["planned_kwh"]
|
||||||
|
|
||||||
|
|
||||||
|
def test_cheaper_contract_replaces_grid_import():
|
||||||
|
p = optimizer.plan(house([contract("buys", 20.0, max_w=600)]), 10)
|
||||||
|
# 8 steps x 600 W x 0.25 h = 1.2 kWh, the rest from the grid
|
||||||
|
assert kwh(p) == pytest.approx(1.2, abs=1e-3)
|
||||||
|
assert p["market"][0]["vs_grid_eur"] == pytest.approx(1.2 * (30 - 20) / 100, abs=1e-3)
|
||||||
|
assert p["cost_eur"] < optimizer.plan(house(), 10)["cost_eur"]
|
||||||
|
|
||||||
|
|
||||||
|
def test_dearer_contract_not_used():
|
||||||
|
p = optimizer.plan(house([contract("buys", 35.0, max_w=600)]), 10)
|
||||||
|
assert kwh(p) == pytest.approx(0.0, abs=1e-6)
|
||||||
|
|
||||||
|
|
||||||
|
def test_export_to_a_contract_above_feed_in():
|
||||||
|
# PV surplus 2 kW: the contract (15 ct) beats the feed-in (8 ct), up to its 1.5 kW
|
||||||
|
p = optimizer.plan(house([contract("sells", 15.0, max_w=1500)], load=500.0, pv=2500.0), 10)
|
||||||
|
assert kwh(p) == pytest.approx(8 * 1.5 * 0.25, abs=1e-3)
|
||||||
|
assert p["market"][0]["vs_grid_eur"] == pytest.approx(3.0 * (15 - 8) / 100, abs=1e-3)
|
||||||
|
# below the feed-in: not used
|
||||||
|
p = optimizer.plan(house([contract("sells", 5.0, max_w=1500)], load=500.0, pv=2500.0), 10)
|
||||||
|
assert kwh(p) == pytest.approx(0.0, abs=1e-6)
|
||||||
|
|
||||||
|
|
||||||
|
def test_bounds_firm_and_only_in_its_steps():
|
||||||
|
# firm 800 W bought even when dearer than the grid; only in steps 2..5
|
||||||
|
p = optimizer.plan(house([contract("buys", 40.0, max_w=1000, guaranteed_w=800, a=2, b=6)]), 10)
|
||||||
|
c = p["market"][0]
|
||||||
|
assert {s["t"] for s in c["steps"]} == {START + t * 900 for t in range(2, 6)}
|
||||||
|
assert c["planned_kwh"] == pytest.approx(4 * 0.8 * 0.25, abs=1e-3)
|
||||||
|
# nothing bought on a contract is resold to the grid, even far below the feed-in
|
||||||
|
p = optimizer.plan(house([contract("buys", 1.0, max_w=5000)], load=300.0, exp=8.0), 10)
|
||||||
|
assert kwh(p) == pytest.approx(8 * 0.3 * 0.25, abs=1e-3)
|
||||||
|
|
||||||
|
|
||||||
|
def test_take_or_pay_minimum_is_paid():
|
||||||
|
# the minimum (100 Wh per step) is paid even when dearer: so it is used
|
||||||
|
p = optimizer.plan(house([contract("buys", 40.0, max_w=1000, minimum_wh=100.0)]), 10)
|
||||||
|
assert kwh(p) == pytest.approx(8 * 0.1, abs=1e-3)
|
||||||
|
|
||||||
|
|
||||||
|
def test_no_market_unchanged_plan():
|
||||||
|
a, b = optimizer.plan(house(), 10), optimizer.plan(house([]), 10)
|
||||||
|
assert "market" not in a and "market" not in b
|
||||||
|
assert a["cost_eur"] == b["cost_eur"] and a["flex"] == b["flex"]
|
||||||
|
|
||||||
|
|
||||||
|
def test_bundle_to_model(tmp_path):
|
||||||
|
now = time.time()
|
||||||
|
slot = int(now // 900 * 900)
|
||||||
|
b = Bundles(str(tmp_path), "site1")
|
||||||
|
assert b.market_for_model(slot, 900, 192, now) == [] # no market.json
|
||||||
|
d = {"v": 1, "kind": "market", "site": "site1", "shadow": True, "commands": "none", "slot": slot, "step_s": 900,
|
||||||
|
"stale_after_s": 3600, "issued": slot, "expires": slot + 86400,
|
||||||
|
"contracts": [{"id": "k1", "name": "PV share", "direction": "buys",
|
||||||
|
"slot": {"applies": True, "guaranteed_kwh": 0.1, "minimum_kwh": 0, "max_kwh": 0.5, "price_ct": 22.0}},
|
||||||
|
{"id": "k2", "name": "off now", "direction": "sells", "slot": {"applies": False, "price_ct": 10.0}}]}
|
||||||
|
(tmp_path / "market.json").write_text(json.dumps(d))
|
||||||
|
m = b.market_for_model(slot, 900, 192, now)
|
||||||
|
assert len(m) == 1 and m[0]["id"] == "k1" and m[0]["direction"] == "buys"
|
||||||
|
assert m[0]["max_w"] == pytest.approx(2000.0) and m[0]["guaranteed_w"] == pytest.approx(400.0)
|
||||||
|
assert (m[0]["from_step"], m[0]["to_step"]) == (0, 4) # held while fresh: 4 slots
|
||||||
|
|
||||||
|
|
||||||
|
def ahead_bundle(slot, contracts, stale_after_s=3600):
|
||||||
|
return {"v": 1, "kind": "market", "site": "site1", "shadow": True, "commands": "none", "slot": slot, "step_s": 900,
|
||||||
|
"stale_after_s": stale_after_s, "issued": slot, "expires": slot + 6 * 3600, "contracts": contracts}
|
||||||
|
|
||||||
|
|
||||||
|
def test_bundle_coming_slots_to_model(tmp_path):
|
||||||
|
"""A bundle with the coming slots (fleet "ahead"): each plan step gets
|
||||||
|
its own slot's window, amounts and price, beyond the bundle's freshness
|
||||||
|
window and its current slot; a contract without them as before."""
|
||||||
|
now = time.time()
|
||||||
|
slot = int(now // 900 * 900)
|
||||||
|
b = Bundles(str(tmp_path), "site1")
|
||||||
|
ahead = {"start": slot, "step_s": 900, "slots": 192,
|
||||||
|
"windows": [{"from": 8, "to": 12, "guaranteed_kwh": 0.1, "minimum_kwh": 0, "max_kwh": 0.5},
|
||||||
|
{"from": 100, "to": 104, "guaranteed_kwh": 0, "minimum_kwh": 0.05, "max_kwh": 1.0}],
|
||||||
|
"price_ct": [[10, 20.0], [182, 25.0]]}
|
||||||
|
d = ahead_bundle(slot, [
|
||||||
|
# not applying in the current slot, but later: still planned
|
||||||
|
{"id": "k1", "name": "later", "direction": "buys", "slot": {"applies": False, "price_ct": 20.0}, "ahead": ahead},
|
||||||
|
# an ahead with no window: nothing to plan, though its current slot applies
|
||||||
|
{"id": "k2", "name": "none", "direction": "sells", "slot": {"applies": True, "price_ct": 9.0, "max_kwh": 1},
|
||||||
|
"ahead": {"start": slot, "step_s": 900, "slots": 192, "windows": [], "price_ct": [[192, 9.0]]}},
|
||||||
|
# an older fleet's contract without ahead: held while fresh, as before
|
||||||
|
{"id": "k3", "name": "old", "direction": "buys", "slot": {"applies": True, "max_kwh": 0.25, "price_ct": 21.0}}])
|
||||||
|
(tmp_path / "market.json").write_text(json.dumps(d))
|
||||||
|
m = {c["id"]: c for c in b.market_for_model(slot, 900, 192, now)}
|
||||||
|
assert set(m) == {"k1", "k3"}
|
||||||
|
k1 = m["k1"]
|
||||||
|
assert (k1["from_step"], k1["to_step"]) == (8, 104) and len(k1["terms"]) == 192
|
||||||
|
on = [t for t, x in enumerate(k1["terms"]) if x is not None]
|
||||||
|
assert on == [8, 9, 10, 11, 100, 101, 102, 103]
|
||||||
|
assert [k1["terms"][t]["price_ct"] for t in (8, 9, 10, 11)] == [20.0, 20.0, 25.0, 25.0]
|
||||||
|
assert k1["terms"][8]["max_w"] == pytest.approx(2000.0) and k1["terms"][8]["guaranteed_w"] == pytest.approx(400.0)
|
||||||
|
assert k1["terms"][100]["max_w"] == pytest.approx(4000.0) and k1["terms"][100]["minimum_wh"] == pytest.approx(50.0)
|
||||||
|
assert k1["price_ct"] == 20.0 and k1["max_w"] == pytest.approx(2000.0) # the first step's, for the shown plan
|
||||||
|
assert (m["k3"]["from_step"], m["k3"]["to_step"]) == (0, 4) and "terms" not in m["k3"]
|
||||||
|
# a plan starting two slots later: the slots shift with it
|
||||||
|
m = {c["id"]: c for c in b.market_for_model(slot + 1800, 900, 192, now)}
|
||||||
|
assert m["k1"]["from_step"] == 6 and m["k1"]["terms"][5] is None and m["k1"]["terms"][6] is not None
|
||||||
|
# stale: nothing at all
|
||||||
|
d["issued"] = d["slot"] = slot - 7200
|
||||||
|
d["contracts"][0]["ahead"]["start"] = slot - 7200
|
||||||
|
(tmp_path / "market.json").write_text(json.dumps(d))
|
||||||
|
assert Bundles(str(tmp_path), "site1").market_for_model(slot, 900, 192, now) == [] # a new reader: same size, same second
|
||||||
|
|
||||||
|
|
||||||
|
def test_bundle_bad_ahead_falls_back_to_the_slot(tmp_path):
|
||||||
|
now = time.time()
|
||||||
|
slot = int(now // 900 * 900)
|
||||||
|
b = Bundles(str(tmp_path), "site1")
|
||||||
|
d = ahead_bundle(slot, [{"id": "k1", "name": "x", "direction": "buys", "slot": {"applies": True, "max_kwh": 0.5, "price_ct": 22.0},
|
||||||
|
"ahead": {"start": slot, "slots": 192, "windows": [{"from": 0, "to": 4}], "price_ct": [[3, 1.0]]}}])
|
||||||
|
(tmp_path / "market.json").write_text(json.dumps(d))
|
||||||
|
m = b.market_for_model(slot, 900, 192, now)
|
||||||
|
assert len(m) == 1 and "terms" not in m[0] and (m[0]["from_step"], m[0]["to_step"]) == (0, 4)
|
||||||
|
|
||||||
|
|
||||||
|
def per_step(on, price, max_w=0.0):
|
||||||
|
return [{"price_ct": price(t), "max_w": max_w, "guaranteed_w": 0.0, "minimum_wh": 0.0} if t in on else None
|
||||||
|
for t in range(STEPS)]
|
||||||
|
|
||||||
|
|
||||||
|
def test_plan_uses_each_steps_terms():
|
||||||
|
# cheaper than the grid (30 ct) only in steps 2..3 (20 ct); dearer in 4..5 (35 ct); outside its windows not at all
|
||||||
|
terms = per_step({2, 3, 4, 5, 10}, lambda t: 20.0 if t < 4 else 35.0, max_w=600)
|
||||||
|
c = {**contract("buys", 20.0, max_w=600, a=2, b=11), "terms": terms}
|
||||||
|
got = optimizer.plan(house([c]), 10)["market"][0]
|
||||||
|
assert {s["t"] for s in got["steps"]} == {START + t * 900 for t in (2, 3)}
|
||||||
|
assert got["planned_kwh"] == pytest.approx(2 * 0.6 * 0.25, abs=1e-3)
|
||||||
|
assert got["cost_eur"] == pytest.approx(0.3 * 20 / 100, abs=1e-4)
|
||||||
|
assert got["vs_grid_eur"] == pytest.approx(0.3 * (30 - 20) / 100, abs=1e-4)
|
||||||
|
|
||||||
|
|
||||||
|
def test_plan_firm_amount_per_step():
|
||||||
|
# a firm 800 W in step 6 only (dearer than the grid): bought there and nowhere else
|
||||||
|
terms = per_step({6, 7}, lambda t: 40.0, max_w=1000)
|
||||||
|
terms[6]["guaranteed_w"] = 800.0
|
||||||
|
c = {**contract("buys", 40.0, max_w=1000, a=6, b=8), "terms": terms}
|
||||||
|
got = optimizer.plan(house([c]), 10)["market"][0]
|
||||||
|
assert [s["t"] for s in got["steps"]] == [START + 6 * 900]
|
||||||
|
assert got["planned_kwh"] == pytest.approx(0.8 * 0.25, abs=1e-3)
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
def test_second_order_contract_effective_price(tmp_path):
|
||||||
|
"""A contract through a middle node (fleet contracts-v2): fleet already
|
||||||
|
puts the buyer's effective price (energy + the middle node's fee, per kWh
|
||||||
|
that arrives) in price_ct and the ahead runs; the agent plans with it and
|
||||||
|
ignores the extra "via" and "parts" (it computes no price itself)."""
|
||||||
|
now = time.time()
|
||||||
|
slot = int(now // 900 * 900)
|
||||||
|
b = Bundles(str(tmp_path), "site1")
|
||||||
|
d = {"v": 1, "kind": "market", "site": "site1", "shadow": True, "commands": "none", "slot": slot, "step_s": 900,
|
||||||
|
"stale_after_s": 3600, "issued": slot, "expires": slot + 86400,
|
||||||
|
"contracts": [{"id": "k1", "name": "A to B via pool", "direction": "buys", "via": {"name": "Pool", "type": "pool"},
|
||||||
|
"slot": {"applies": True, "guaranteed_kwh": 0, "minimum_kwh": 0, "max_kwh": 0.45, "price_ct": 24.444,
|
||||||
|
"parts": {"energy_ct": 20, "transfer_ct": 2, "loss_pct": 10}},
|
||||||
|
"ahead": {"start": slot, "step_s": 900, "slots": 8,
|
||||||
|
"windows": [{"from": 0, "to": 8, "guaranteed_kwh": 0, "minimum_kwh": 0, "max_kwh": 0.45}],
|
||||||
|
"price_ct": [[4, 24.444], [4, 13.333]]}}]}
|
||||||
|
(tmp_path / "market.json").write_text(json.dumps(d))
|
||||||
|
m = b.market_for_model(slot, 900, 8, now)
|
||||||
|
assert len(m) == 1 and m[0]["price_ct"] == pytest.approx(24.444)
|
||||||
|
assert [x["price_ct"] for x in m[0]["terms"]] == pytest.approx([24.444] * 4 + [13.333] * 4)
|
||||||
|
assert m[0]["max_w"] == pytest.approx(1800.0)
|
||||||
|
|
||||||
|
|
||||||
|
def test_take_or_pay_cost_is_the_paid_minimum():
|
||||||
|
"""Finding A2-c: a take-or-pay contract used below its minimum costs the
|
||||||
|
minimum in cost_eur and its line, as in the optimisation."""
|
||||||
|
# load 300 W = 75 Wh per step, all of it from the contract (20 ct < 30 ct);
|
||||||
|
# the minimum is 100 Wh per step: 8 x 0.1 kWh paid at 20 ct
|
||||||
|
p = optimizer.plan(house([contract("buys", 20.0, max_w=1000, minimum_wh=100.0)], load=300.0), 10)
|
||||||
|
c = p["market"][0]
|
||||||
|
assert c["planned_kwh"] == pytest.approx(8 * 0.075, abs=1e-3)
|
||||||
|
assert c["paid_kwh"] == pytest.approx(8 * 0.1, abs=1e-3)
|
||||||
|
assert c["cost_eur"] == pytest.approx(0.8 * 0.20, abs=1e-3)
|
||||||
|
assert c["vs_grid_eur"] == pytest.approx(0.6 * 0.30 - 0.8 * 0.20, abs=1e-3)
|
||||||
|
grid = 8 * 0.075 * 0.30 # steps 8..15 from the grid
|
||||||
|
assert p["cost_eur"] == pytest.approx(grid + 0.16, abs=0.006)
|
||||||
|
assert all(st["paid_kwh"] == pytest.approx(0.1, abs=1e-4) for st in c["steps"])
|
||||||
@@ -0,0 +1,199 @@
|
|||||||
|
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
|
||||||
|
"""The model bundle's trained series and rooms (bundles.py, Model v1's
|
||||||
|
optional keys), a room's R and C in the model state (inputs.py), and the
|
||||||
|
site's weather cell for the link (controller.py)."""
|
||||||
|
import asyncio
|
||||||
|
import json
|
||||||
|
import math
|
||||||
|
from types import SimpleNamespace
|
||||||
|
|
||||||
|
import pytest
|
||||||
|
|
||||||
|
from cantabile_edge.bundles import Bundles
|
||||||
|
from cantabile_edge.config import Config
|
||||||
|
from cantabile_edge.controller import Controller, write_cell
|
||||||
|
from cantabile_edge.controls import PARAMS, Control
|
||||||
|
from cantabile_edge.inputs import Collector, model_state
|
||||||
|
from cantabile_edge.mapping import Mapping
|
||||||
|
|
||||||
|
from test_control_parts import SITE, Clock, consent # noqa: F401
|
||||||
|
|
||||||
|
START = 1_800_000_000 // 3600 * 3600 # a Friday, on the hour (UTC)
|
||||||
|
HOW = list(range(168)) # hour-of-week profile: its index
|
||||||
|
|
||||||
|
|
||||||
|
def model(**kw):
|
||||||
|
m = {"v": 1, "kind": "model", "id": "m1", "site": SITE, "issued": 1,
|
||||||
|
"forecasts": {"load_w": {"profile": "hour_of_week", "values": HOW}}}
|
||||||
|
m.update(kw)
|
||||||
|
return m
|
||||||
|
|
||||||
|
|
||||||
|
def put(tmp_path, m):
|
||||||
|
(tmp_path / "model.json").write_text(json.dumps(m))
|
||||||
|
return Bundles(str(tmp_path), SITE)
|
||||||
|
|
||||||
|
|
||||||
|
def hour(t):
|
||||||
|
from datetime import datetime, timezone
|
||||||
|
d = datetime.fromtimestamp(t, timezone.utc)
|
||||||
|
return float(d.weekday() * 24 + d.hour)
|
||||||
|
|
||||||
|
|
||||||
|
# -- the series ---------------------------------------------------------------
|
||||||
|
def test_series_where_it_covers_profile_elsewhere(tmp_path):
|
||||||
|
m = model()
|
||||||
|
m["forecasts"]["load_w"]["series"] = {"start": START + 2 * 900, "step_s": 900, "values": [1000, 2000, 3000]}
|
||||||
|
s = put(tmp_path, m).forecast("load_w", START, 900, 8, "UTC")
|
||||||
|
assert s[2:5] == [1000.0, 2000.0, 3000.0]
|
||||||
|
assert s[:2] == [hour(START)] * 2 and s[5:] == [hour(START + k * 900) for k in range(5, 8)]
|
||||||
|
# a series that began before the horizon: its later values
|
||||||
|
m["forecasts"]["load_w"]["series"] = {"start": START - 900, "step_s": 900, "values": [5, 6]}
|
||||||
|
assert put(tmp_path, m).forecast("load_w", START, 900, 3, "UTC") == [6.0, hour(START), hour(START)]
|
||||||
|
# without a series: the profile as before
|
||||||
|
assert put(tmp_path, model()).forecast("load_w", START, 900, 2, "UTC") == [hour(START)] * 2
|
||||||
|
|
||||||
|
|
||||||
|
def test_expired_model_is_not_used(tmp_path):
|
||||||
|
m = model(expires=START, rooms={"living_room": {"r_k_per_kw": 8, "c_kwh_per_k": 4}})
|
||||||
|
m["forecasts"]["load_w"]["series"] = {"start": START, "step_s": 900, "values": [1000] * 8}
|
||||||
|
b = put(tmp_path, m)
|
||||||
|
assert b.forecast("load_w", START, 900, 8, "UTC") is None # the agent's history then
|
||||||
|
assert b.room_rc("living_room", now=START) is None
|
||||||
|
assert b.room_rc("living_room", now=START - 1) is not None
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.mark.parametrize("series,rooms", [
|
||||||
|
({"start": START, "step_s": 600, "values": [1]}, None),
|
||||||
|
({"start": START + 60, "step_s": 900, "values": [1]}, None),
|
||||||
|
({"start": "x", "step_s": 900, "values": [1]}, None),
|
||||||
|
({"start": START, "step_s": 900, "values": [1] * 401}, None),
|
||||||
|
({"start": START, "step_s": 900, "values": [1, "2"]}, None),
|
||||||
|
({"start": START, "step_s": 900, "values": [1, True]}, None),
|
||||||
|
({"start": START, "step_s": 900, "values": [1, float("nan")]}, None),
|
||||||
|
({"start": START, "step_s": 900, "values": [float("inf")]}, None),
|
||||||
|
({"start": START, "step_s": 900, "values": None}, None),
|
||||||
|
([1, 2, 3], None),
|
||||||
|
(None, {"r": {"r_k_per_kw": 0.4, "c_kwh_per_k": 3}}),
|
||||||
|
(None, {"r": {"r_k_per_kw": 201, "c_kwh_per_k": 3}}),
|
||||||
|
(None, {"r": {"r_k_per_kw": 10, "c_kwh_per_k": 0.05}}),
|
||||||
|
(None, {"r": {"r_k_per_kw": 10, "c_kwh_per_k": 101}}),
|
||||||
|
(None, {"r": {"r_k_per_kw": 10}}),
|
||||||
|
(None, {"r": {"r_k_per_kw": "10", "c_kwh_per_k": 3}}),
|
||||||
|
(None, {"r": {"r_k_per_kw": 10, "c_kwh_per_k": 3, "power": "gas"}}),
|
||||||
|
(None, {"r": [10, 3]}),
|
||||||
|
(None, [{"r_k_per_kw": 10, "c_kwh_per_k": 3}]),
|
||||||
|
])
|
||||||
|
def test_malformed_series_or_room_refuses_the_bundle(tmp_path, series, rooms):
|
||||||
|
m = model()
|
||||||
|
if series is not None:
|
||||||
|
m["forecasts"]["load_w"]["series"] = series
|
||||||
|
if rooms is not None:
|
||||||
|
m["rooms"] = rooms
|
||||||
|
b = put(tmp_path, m)
|
||||||
|
assert b.forecast("load_w", START, 900, 2, "UTC") is None and b.model_id() == ""
|
||||||
|
assert b.model.error
|
||||||
|
|
||||||
|
|
||||||
|
def test_good_series_and_rooms_pass(tmp_path):
|
||||||
|
m = model(rooms={"a": {"r_k_per_kw": 0.5, "c_kwh_per_k": 100, "power": "electric", "rmse_k": 0.3, "days": 21},
|
||||||
|
"b": {"r_k_per_kw": 200, "c_kwh_per_k": 0.1}})
|
||||||
|
m["forecasts"]["load_w"]["series"] = {"start": START, "step_s": 900, "values": [1.5] * 400}
|
||||||
|
b = put(tmp_path, m)
|
||||||
|
assert b.model_id() == "m1" and b.model_info()["rooms"] == ["a", "b"]
|
||||||
|
|
||||||
|
|
||||||
|
# -- rooms --------------------------------------------------------------------
|
||||||
|
def test_room_matching(tmp_path):
|
||||||
|
rooms = {"living_room": {"r_k_per_kw": 8, "c_kwh_per_k": 4, "power": "thermal"},
|
||||||
|
"bedroom": {"r_k_per_kw": 12, "c_kwh_per_k": 2},
|
||||||
|
"studio_cooling": {"r_k_per_kw": 20, "c_kwh_per_k": 1, "power": "electric"}}
|
||||||
|
b = put(tmp_path, model(rooms=rooms))
|
||||||
|
rc = b.room_rc("bedroom")
|
||||||
|
assert rc == {"r_k_per_kw": 12.0, "c_kwh_per_k": 2.0, "power": "thermal",
|
||||||
|
"gain_w": 0.0, "solar_m2": 0.0} # a model without the gains: none
|
||||||
|
for cid in ("living_room_heating", "living_room_cooling", "living_room_heat", "living_room_cool"):
|
||||||
|
assert b.room_rc(cid)["r_k_per_kw"] == 8.0, cid
|
||||||
|
assert b.room_rc("studio_cooling")["power"] == "electric" # its own id first
|
||||||
|
assert b.room_rc("heat_pump", area="bedroom")["r_k_per_kw"] == 12.0 # by its area
|
||||||
|
assert b.room_rc("heat_pump") is None
|
||||||
|
assert b.room_rc("heat_pump", only_one=True) is None # more than one room
|
||||||
|
one = put(tmp_path, model(rooms={"flat": {"r_k_per_kw": 9, "c_kwh_per_k": 5}}))
|
||||||
|
assert one.room_rc("heat_pump", only_one=True)["r_k_per_kw"] == 9.0
|
||||||
|
assert one.room_rc("heat_pump") is None
|
||||||
|
# a shared model or another site's: no rooms
|
||||||
|
assert put(tmp_path, model(site="*", rooms=rooms)).room_rc("bedroom") is None
|
||||||
|
assert put(tmp_path, model(site="cd" * 16, rooms=rooms)).room_rc("bedroom") is None
|
||||||
|
assert put(tmp_path, model()).room_rc("bedroom") is None
|
||||||
|
|
||||||
|
|
||||||
|
INPUTS = SimpleNamespace(load_power="", outside_temp="", weather="", sun="", presence=[])
|
||||||
|
|
||||||
|
|
||||||
|
def heating(cid, **params):
|
||||||
|
return Control(cid, "heating", {"climate": f"climate.{cid}"}, True, params)
|
||||||
|
|
||||||
|
|
||||||
|
def state(b, controls):
|
||||||
|
s = model_state(START, controls, INPUTS, Collector(), b, None, "UTC", None)
|
||||||
|
return {d["id"]: d["params"] for d in s["devices"]}, s["sources"]
|
||||||
|
|
||||||
|
|
||||||
|
def test_model_state_takes_the_rooms(tmp_path):
|
||||||
|
rooms = {"living_room": {"r_k_per_kw": 8, "c_kwh_per_k": 4},
|
||||||
|
"bedroom": {"r_k_per_kw": 6, "c_kwh_per_k": 2, "power": "electric"}}
|
||||||
|
b = put(tmp_path, model(rooms=rooms))
|
||||||
|
controls = [heating("living_room_heating"),
|
||||||
|
heating("bedroom", cop=3.0), # a heat pump, fitted on electric power
|
||||||
|
heating("office", r_k_per_kw=15.0), # the mapping's own: wins
|
||||||
|
heating("bath")] # no room: defaults
|
||||||
|
p, src = state(b, controls)
|
||||||
|
assert (p["living_room_heating"]["r_k_per_kw"], p["living_room_heating"]["c_kwh_per_k"]) == (8.0, 4.0)
|
||||||
|
r, c = p["bedroom"]["r_k_per_kw"], p["bedroom"]["c_kwh_per_k"]
|
||||||
|
assert math.isclose(r, 2.0) and math.isclose(c, 6.0) and math.isclose(r * c, 6 * 2) # tau kept
|
||||||
|
assert p["office"]["r_k_per_kw"] == 15.0 and p["office"]["c_kwh_per_k"] == PARAMS["heating"]["c_kwh_per_k"]
|
||||||
|
assert p["bath"]["r_k_per_kw"] == PARAMS["heating"]["r_k_per_kw"]
|
||||||
|
assert src["rooms"] == {"living_room_heating": "model", "bedroom": "model", "office": "mapping", "bath": "defaults"}
|
||||||
|
assert src["model"] == "m1"
|
||||||
|
# the mapping's C alone also wins over the model
|
||||||
|
p, src = state(b, [heating("living_room", c_kwh_per_k=7.0)])
|
||||||
|
assert p["living_room"]["r_k_per_kw"] == PARAMS["heating"]["r_k_per_kw"] and src["rooms"]["living_room"] == "mapping"
|
||||||
|
|
||||||
|
|
||||||
|
def test_model_state_only_room_and_no_model(tmp_path):
|
||||||
|
b = put(tmp_path, model(rooms={"flat": {"r_k_per_kw": 9, "c_kwh_per_k": 5, "power": "electric"}}))
|
||||||
|
p, src = state(b, [heating("boiler")]) # cop 1: as fitted
|
||||||
|
assert (p["boiler"]["r_k_per_kw"], p["boiler"]["c_kwh_per_k"]) == (9.0, 5.0) and src["rooms"] == {"boiler": "model"}
|
||||||
|
cool = Control("ac", "cooling", {"climate": "climate.ac"}, True, {})
|
||||||
|
p, src = state(b, [heating("boiler"), cool]) # two: no guess
|
||||||
|
assert src["rooms"] == {"boiler": "defaults", "ac": "defaults"}
|
||||||
|
p, src = state(Bundles(str(tmp_path / "none"), SITE), [heating("boiler")])
|
||||||
|
assert src["rooms"] == {"boiler": "defaults"} and src["model"] == ""
|
||||||
|
|
||||||
|
|
||||||
|
# -- the weather cell -----------------------------------------------------------
|
||||||
|
def test_write_cell(tmp_path):
|
||||||
|
p = tmp_path / "site_cell.json"
|
||||||
|
assert write_cell(str(tmp_path), 47.0234, 28.8361) is True
|
||||||
|
assert json.loads(p.read_text()) == {"lat": 47.0, "lon": 28.8}
|
||||||
|
st = p.stat().st_mtime_ns
|
||||||
|
assert write_cell(str(tmp_path), 46.98, 28.79) is False and p.stat().st_mtime_ns == st # the same cell
|
||||||
|
assert write_cell(str(tmp_path), 52.52, 13.405) is True and json.loads(p.read_text()) == {"lat": 52.5, "lon": 13.4}
|
||||||
|
assert not (tmp_path / "site_cell.json.tmp").exists()
|
||||||
|
assert write_cell(str(tmp_path / "missing"), 1.0, 2.0) is False # only logged
|
||||||
|
|
||||||
|
|
||||||
|
def test_on_connect_writes_the_cell(tmp_path, consent): # noqa: F811
|
||||||
|
(tmp_path / "mapping.yaml").write_text(json.dumps({"version": 3, "assets": [], "controls": []}))
|
||||||
|
m = Mapping.load(str(tmp_path / "mapping.yaml"))
|
||||||
|
ctl = Controller(Config(site_id=SITE, mapping="", state_dir=str(tmp_path)), m, consent, None, clock=Clock())
|
||||||
|
|
||||||
|
class Client:
|
||||||
|
async def send(self, *a, **kw):
|
||||||
|
return {"time_zone": "Europe/Chisinau", "latitude": 47.0105, "longitude": 28.8638}
|
||||||
|
|
||||||
|
async def subscribe_entities(self, *a, **kw):
|
||||||
|
pass
|
||||||
|
asyncio.run(ctl.on_connect(Client()))
|
||||||
|
assert json.loads((tmp_path / "site_cell.json").read_text()) == {"lat": 47.0, "lon": 28.9}
|
||||||
|
assert ctl.location == {"latitude": 47.0105, "longitude": 28.8638}
|
||||||
@@ -112,3 +112,38 @@ def test_cover_shades_a_cooled_room_in_the_sun():
|
|||||||
blind = p["devices"]["blind"]
|
blind = p["devices"]["blind"]
|
||||||
assert at(blind, START + 12 * 3600)["set"] < 100, blind # the sun on it: shaded
|
assert at(blind, START + 12 * 3600)["set"] < 100, blind # the sun on it: shaded
|
||||||
assert at(blind, START + 3 * 3600)["set"] == 100, blind # night, nothing at stake: open
|
assert at(blind, START + 3 * 3600)["set"] == 100, blind # night, nothing at stake: open
|
||||||
|
|
||||||
|
|
||||||
|
def test_feed_in_above_import_still_plans():
|
||||||
|
"""Finding A2-b: a step where the feed-in pays more than the import
|
||||||
|
(a negative day-ahead price, a hand-typed feed-in) made the MILP
|
||||||
|
unbounded; import and export are now bounded by the connection and
|
||||||
|
exclusive in such a step."""
|
||||||
|
s = house([battery()], steps=16)
|
||||||
|
s["price_import"][5], s["price_export"][5] = 5.0, 8.0
|
||||||
|
s["price_import"][6], s["price_export"][6] = -10.0, 0.0 # paid to import, nothing for feed-in
|
||||||
|
s["grid_max_w"] = 20000.0
|
||||||
|
m = optimizer.Model(s)
|
||||||
|
m.solve(20)
|
||||||
|
val = m.h.getSolution().col_value
|
||||||
|
gin, gout = [val[v.index] for v in m.gin], [val[v.index] for v in m.gout]
|
||||||
|
for t in range(16):
|
||||||
|
assert min(gin[t], gout[t]) < 1e-6, (t, gin[t], gout[t]) # never both at once
|
||||||
|
assert gin[t] <= 20000.0 + 1e-6 and gout[t] <= 20000.0 + 1e-6
|
||||||
|
p = optimizer.plan(s, 20)
|
||||||
|
assert p["status"] and p["devices"]["battery"]
|
||||||
|
# without the connection in the state: the default bound, still a plan
|
||||||
|
del s["grid_max_w"]
|
||||||
|
assert optimizer.plan(s, 20)["status"]
|
||||||
|
|
||||||
|
|
||||||
|
def test_grid_bound_never_below_the_house():
|
||||||
|
"""The connection bound never makes a plan infeasible: a forecast load
|
||||||
|
above it is still imported."""
|
||||||
|
s = house([], steps=8)
|
||||||
|
s["load_w"] = [30000.0] * 8
|
||||||
|
s["grid_max_w"] = 10000.0
|
||||||
|
m = optimizer.Model(s)
|
||||||
|
m.solve(10)
|
||||||
|
val = m.h.getSolution().col_value
|
||||||
|
assert val[m.gin[0].index] == pytest.approx(30000.0)
|
||||||
@@ -135,6 +135,19 @@ def test_inventory_build(mapping, tmp_path):
|
|||||||
assert "asset:load.power" in targets and "control:x" not in targets
|
assert "asset:load.power" in targets and "control:x" not in targets
|
||||||
|
|
||||||
|
|
||||||
|
def test_inventory_mapping_battery_ratings(mapping):
|
||||||
|
"""An installer's mapping (no devices tool): the battery's rated kWh and
|
||||||
|
kW from its control's params, once (on the first device of its
|
||||||
|
entities); without a device in HA on an entry of the mapping's own."""
|
||||||
|
inv = build(mapping, REG, {}, {}, 100)
|
||||||
|
rated = [(d["id"], d["ratings"]) for d in inv["devices"] if d["ratings"]]
|
||||||
|
assert len(rated) == 1 and rated[0][1] == {"battery_kwh": 10.0, "battery_kw": 3.0}
|
||||||
|
assert rated[0][0] != "ha:mapping" # on the Victron (d1)
|
||||||
|
inv = build(mapping, {"devices": [], "entities": []}, {}, {}, 100)
|
||||||
|
assert [(d["id"], d["ratings"]) for d in inv["devices"]] == [("ha:mapping", {"battery_kwh": 10.0, "battery_kw": 3.0})]
|
||||||
|
assert "sensor." not in json.dumps(inv)
|
||||||
|
|
||||||
|
|
||||||
def test_inventory_sent_with_consent_when_changed(mapping, consent, tmp_path):
|
def test_inventory_sent_with_consent_when_changed(mapping, consent, tmp_path):
|
||||||
cfg = Config(site_id=SITE, mapping="", state_dir=str(tmp_path))
|
cfg = Config(site_id=SITE, mapping="", state_dir=str(tmp_path))
|
||||||
clock = Clock()
|
clock = Clock()
|
||||||
@@ -153,3 +166,20 @@ def test_inventory_sent_with_consent_when_changed(mapping, consent, tmp_path):
|
|||||||
consent.set(False, "test")
|
consent.set(False, "test")
|
||||||
clock.t += 1000
|
clock.t += 1000
|
||||||
assert not run(inv.maybe_send(client))
|
assert not run(inv.maybe_send(client))
|
||||||
|
|
||||||
|
|
||||||
|
def test_inventory_waits_for_the_link(mapping, consent, tmp_path):
|
||||||
|
"""Before the link's NATS connection is up the link drops it: not sent
|
||||||
|
(nor counted as sent), tried again once the link is connected."""
|
||||||
|
cfg = Config(site_id=SITE, mapping="", state_dir=str(tmp_path))
|
||||||
|
sink = Sink()
|
||||||
|
up = [False]
|
||||||
|
|
||||||
|
async def cloud():
|
||||||
|
return up[0]
|
||||||
|
sink.cloud = cloud
|
||||||
|
inv = Inventory(cfg, mapping, consent, sink, clock=Clock())
|
||||||
|
client = FakeClient(REG)
|
||||||
|
assert not asyncio.run(inv.maybe_send(client)) and inv.waiting and not sink.sent
|
||||||
|
up[0] = True
|
||||||
|
assert asyncio.run(inv.maybe_send(client)) and not inv.waiting and sink.sent[0][0] == "inventory"
|
||||||
@@ -421,9 +421,9 @@ def test_addon_devices_page_shade(tmp_path):
|
|||||||
assert 'name="ha_device" value="rbs"' in out and 'name="ha_device" value="garage"' not in out
|
assert 'name="ha_device" value="rbs"' in out and 'name="ha_device" value="garage"' not in out
|
||||||
s.post(do="use", ha_device="rbs", profile="ha-cover", name="Left curtain")
|
s.post(do="use", ha_device="rbs", profile="ha-cover", name="Left curtain")
|
||||||
dev_id = next(i for i, d in s.devices().items() if d["profile"] == "ha-cover")
|
dev_id = next(i for i, d in s.devices().items() if d["profile"] == "ha-cover")
|
||||||
out = s.req()
|
out = s.req(query=f"p=devices&d={dev_id}")
|
||||||
assert "Room and window" in out and '<option value="Bedroom" selected>Bedroom</option>' in out
|
assert "Room and window" in out and '<option value="Bedroom" selected>Bedroom</option>' in out
|
||||||
assert "It may control: blinds and curtains." in out and "Allow Cantabile to move it" in out
|
assert "Controls: blinds and curtains" in out and "Allow Cantabile to move it" in out
|
||||||
s.post(do="use", ha_device="dev-ac", profile="ha-thermostat") # the living room's A/C
|
s.post(do="use", ha_device="dev-ac", profile="ha-thermostat") # the living room's A/C
|
||||||
ac = next(i for i, d in s.devices().items() if d["profile"] == "ha-thermostat")
|
ac = next(i for i, d in s.devices().items() if d["profile"] == "ha-thermostat")
|
||||||
s.post(do="shade", id=dev_id, area="Living room", facing="SE")
|
s.post(do="shade", id=dev_id, area="Living room", facing="SE")
|
||||||
@@ -436,6 +436,6 @@ def test_addon_devices_page_shade(tmp_path):
|
|||||||
|
|
||||||
def run():
|
def run():
|
||||||
i18n.use("de")
|
i18n.use("de")
|
||||||
return s.req()
|
return s.req(query=f"p=devices&d={dev_id}")
|
||||||
de = contextvars.copy_context().run(run)
|
de = contextvars.copy_context().run(run)
|
||||||
assert "Raum und Fenster" in de and "Südosten" in de and "Bewegen durch Cantabile erlauben" in de
|
assert "Raum und Fenster" in de and "Südosten" in de and "Bewegen durch Cantabile erlauben" in de
|
||||||
Reference in new issue
Block a user