# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved. """The add-on's page (ingress): a list of devices, and per device (#, so a reload stays there) its values in sets, its channels as tiles, an inverter's power flow, sparklines of the last hour, and its controls with their protection. Plain HTML, CSS and SVG; HA's light and dark; English and German (the browser's language). Value sets: a register's "group", else its key's first word; a set of one value is a line, not a card. Registers with "bits" are under "details" unless not zero. Keys ending _ on two or more channels are a channel grid (SPM circuits). The bridge's derived values (modbus.derived) come like registers. A profile's "view": {"headline": [refs], "flow": {"pv", "grid", "load", "battery", "soc", "bypass": ref}, "energy": [refs]}; a ref is a register key or a quantity (the register that gives it). The rest of the view (card, values, channels) is for the dashboard in Home Assistant. In HA's app panel the page is in an iframe whose own address has no #: the parent's hash is read at start and kept in step. """ import html import re import time e = html.escape HIST_MIN = 60 # sparklines: the last hour, a value a minute T = { "en": {"title": "Cantabile devices", "back": "All devices", "online": "online", "offline": "offline", "ro": "read only", "sim": "simulated", "every": "every {} s", "ha": "Home Assistant", "prot_sum": "{} of {} controls protected", "no_controls": "no controls", "values": "Values", "controls": "Controls", "details": "Details", "total": "Total", "on_of": "{} of {} on", "protected": "protected", "none": "not protected", "sealed": "sealed", "lift": "Lift", "protect": "Protect", "protect_all": "Protect all", "never_off": "Off refused", "all_refused": "every command refused", "confirm": "Lift the protection of {}? Cantabile may then switch it.", "history": "Protection changes", "none_yet": "none yet", "lock": "set by Cantabile, locked", "pv": "Solar", "grid": "Grid", "load": "Output", "battery": "Battery", "inverter": "Inverter", "charging": "charging", "discharging": "discharging", "energy": "Energy", "intro": "A protected control refuses the commands that would switch it off; " "only you lift a protection, here, one control at a time. Sealed ones are set by Cantabile and locked.", "ro_note": "Read only: commands are checked and logged, never written.", "voltage": "Voltage", "circuit": "Circuit {}", "all": "All:", "bypass": "bypass", "bypass_est": "via bypass, estimated"}, "de": {"title": "Cantabile-Geräte", "back": "Alle Geräte", "online": "online", "offline": "offline", "ro": "nur lesen", "sim": "simuliert", "every": "alle {} s", "ha": "Home Assistant", "prot_sum": "{} von {} Steuerungen geschützt", "no_controls": "keine Steuerungen", "values": "Werte", "controls": "Steuerungen", "details": "Details", "total": "Gesamt", "on_of": "{} von {} an", "protected": "geschützt", "none": "nicht geschützt", "sealed": "versiegelt", "lift": "Aufheben", "protect": "Schützen", "protect_all": "Alle schützen", "never_off": "Aus wird abgelehnt", "all_refused": "jeder Befehl abgelehnt", "confirm": "Schutz von {} aufheben? Cantabile darf es dann schalten.", "history": "Änderungen am Schutz", "none_yet": "noch keine", "lock": "von Cantabile gesetzt, gesperrt", "pv": "Solar", "grid": "Netz", "load": "Ausgang", "battery": "Batterie", "inverter": "Wechselrichter", "charging": "lädt", "discharging": "entlädt", "energy": "Energie", "intro": "Eine geschützte Steuerung lehnt Befehle ab, die sie ausschalten würden; " "nur Sie heben einen Schutz auf, hier, je Steuerung. Versiegelte setzt Cantabile, sie sind gesperrt.", "ro_note": "Nur lesen: Befehle werden geprüft und protokolliert, nie geschrieben.", "voltage": "Spannung", "circuit": "Stromkreis {}", "all": "Alle:", "bypass": "Bypass", "bypass_est": "über Bypass, geschätzt"}, } CSS = """:root{--bg:#f6f8f7;--fg:#1d2a24;--card:#fff;--line:#d5ded9;--soft:#e3e9e5;--mute:#5a6b62;--acc:#2f6f55;--prot:#1f6b45;--warn:#7a4b00;--bar:#cfe3d8} @media (prefers-color-scheme:dark){:root{--bg:#111915;--fg:#e3ebe6;--card:#18221d;--line:#2b3a32;--soft:#22302a;--mute:#9fb0a6;--acc:#5fb38c;--prot:#7fd1a6;--warn:#e0a54a;--bar:#2c4a3b}} body{font-family:system-ui,sans-serif;margin:0;padding:16px;overflow-wrap:anywhere;max-width:56rem;color:var(--fg);background:var(--bg)} h2{margin:.2rem 0 1rem}h3{margin:0 0 .4rem;font-size:1rem}a{color:inherit} .card{background:var(--card);border:1px solid var(--line);border-radius:8px;padding:.7rem .8rem;margin:.5rem 0} a.card{display:block;text-decoration:none}a.card:hover{border-color:var(--acc)} .row{display:flex;flex-wrap:wrap;gap:.3rem .9rem;align-items:baseline}.grow{flex:1} .note{color:var(--mute);font-size:.88rem}.big{font-size:1.5rem;font-weight:600}.small{font-size:.82rem;color:var(--mute)} .badge{display:inline-block;font-size:.75rem;padding:.05rem .45rem;border-radius:9px;background:var(--soft);color:var(--mute)} .ok{color:var(--prot)}.bad{color:var(--warn)}.prot{background:var(--bar);color:var(--prot);font-weight:600}.lock{color:var(--warn)} .grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(10.5rem,100%),1fr));gap:.5rem} .tiles{grid-template-columns:repeat(auto-fill,minmax(min(8rem,100%),1fr))}.tiles .card{padding:.45rem .6rem} table.sparks td{border:0;padding:.15rem .4rem;vertical-align:middle}table.sparks td:first-child{width:40%} .sets{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(14rem,100%),1fr));gap:.5rem} .bar{height:6px;border-radius:3px;background:var(--soft);margin:.3rem 0}.bar i{display:block;height:100%;border-radius:3px;background:var(--acc)} table{border-collapse:collapse;width:100%}td,th{text-align:left;padding:.3rem .4rem;border-bottom:1px solid var(--soft);font-size:.9rem} td.v{text-align:right;white-space:nowrap} button{font:inherit;font-size:.82rem;padding:.2rem .7rem;border:0;border-radius:6px;background:var(--acc);color:#fff;cursor:pointer} button.off{background:var(--soft);color:var(--fg)}form{display:inline;margin:0} details summary{cursor:pointer;color:var(--mute);font-size:.88rem}pre{white-space:pre-wrap;font-size:.8rem} section.dev{display:none}section.dev:target{display:block}body:has(section.dev:target) #list{display:none} svg text{fill:var(--fg);font-size:12px}svg text.sub{font-size:9.5px}svg .mute{fill:var(--mute)}svg .ln{stroke:var(--acc);fill:none}svg .box{fill:var(--card);stroke:var(--line)} svg .soc{fill:var(--acc)}svg .spark{stroke:var(--acc);fill:none;stroke-width:1.5}""" # HA's app panel shows the page in an iframe (same origin) without the # # of its own address: take the parent's at start and keep both in # step, so a link, back and reload land on the device. Reload every 30 s. SCRIPT = """(function(){var P=null;try{if(window.parent!==window){P=window.parent;P.location.hash}}catch(x){P=null} function dev(h){return h&&h.length>1&&document.getElementById(decodeURIComponent(h.slice(1)))?h:''} if(P&&!location.hash){var h=dev(P.location.hash);if(h)location.replace(h)} if(P){window.addEventListener('hashchange',function(){try{var h=location.hash;if(P.location.hash!==h&&!(h===''&&P.location.hash==='#'))P.location.hash=h}catch(x){}}); P.addEventListener('hashchange',function(){var h=dev(P.location.hash);if(h!==location.hash&&!(h===''&&location.hash==='#'))location.hash=h})} setTimeout(function(){location.reload()},30000)})();""" def lang_of(accept): return "de" if (accept or "").lower().startswith("de") else "en" def num(s): try: return float(s) except (TypeError, ValueError): return None def fmt(v, unit): """A value for people: W to kW and Wh to kWh above 1000, sensible digits.""" x = num(v) if x is None: return "–" if v is None else e(str(v)) if unit == "Wh": return f"{x / 1000:,.1f} kWh" if abs(x) >= 1000 else f"{x:.0f} Wh" if unit == "W": return f"{x / 1000:.2f} kW" if abs(x) >= 1000 else f"{x:.0f} W" if abs(x) >= 100 or x == 0 else f"{x:.1f} W" digits = {"V": 1, "A": 2, "%": 0, "°C": 1, "Hz": 2}.get(unit, 2) s = f"{x:.{digits}f}" return f"{s} {e(unit)}" if unit else s def channel_of(key): m = re.fullmatch(r"(.+)_(\d+)", key) return (m.group(1), int(m.group(2))) if m else (None, None) def is_switch(r): return set((r.get("write") or {}).get("options") or {}) == {"0", "1"} class View: """One device's values for the page: the registers' and the derived ones (the bridge publishes both; energy comes in kWh, kept here in Wh), and their last hour.""" def __init__(self, dev, values, hist): self.dev, self.hist = dev, hist self.regs = {r["key"]: r for r in dev["registers"]} self.regs.update({d["key"]: dict(d, type="derived") for d in dev.get("derived") or []}) self.v = {k: values.get(f"{dev['id']}/{k}") for k in self.regs} for k, r in self.regs.items(): if r.get("unit") == "Wh" and num(self.v[k]) is not None: self.v[k] = num(self.v[k]) * 1000 # the view's references as register keys (a quantity: its register) by_q = {} for k, r in self.regs.items(): if r.get("quantity"): by_q.setdefault(r["quantity"], k) v = dev.get("view") or {} ref = lambda x: by_q.get(x, x) if isinstance(x, str) else x # noqa: E731 self.view = dict(v, headline=[ref(x) for x in v.get("headline") or []], energy=[ref(x) for x in v.get("energy") or []]) if v.get("flow"): self.view["flow"] = {k: ref(x) for k, x in v["flow"].items()} def series(self, key): """[value per minute] of the last hour.""" now = int(time.time() // 60) return [self.hist.get(f"{self.dev['id']}/{key}", {}).get(m) for m in range(now - HIST_MIN + 1, now + 1)] def channels(self): """{n: {base: key}} when two or more channels carry values.""" ch = {} for k, r in self.regs.items(): base, n = channel_of(k) if n is not None: ch.setdefault(n, {})[base] = k valued = {n: c for n, c in ch.items() if any(not self.regs[k].get("write") for k in c.values())} return valued if len(valued) >= 2 else {} def headline(self, t): out = [] for k in self.view.get("headline") or []: if k in self.regs: out.append((self.regs[k].get("name") or k, fmt(self.v.get(k), self.regs[k].get("unit", "")))) ch = self.channels() if not out and ch: tot = sum(num(self.v.get(c.get("power"))) or 0 for c in ch.values()) out.append((t["total"], fmt(tot, "W"))) sw = [k for k, r in self.regs.items() if is_switch(r)] if len(sw) >= 3 and not ch: on = sum(1 for k in sw if str(self.v.get(k)) == (self.regs[k]["write"]["options"]["1"])) out.append(("", t["on_of"].format(on, len(sw)))) return out def spark(vals, w=120, h=26): pts = [(i, v) for i, v in enumerate(vals) if v is not None] if len(pts) < 2: return "" lo, hi = min(v for _, v in pts), max(v for _, v in pts) span = (hi - lo) or 1 xy = " ".join(f"{i * w / (len(vals) - 1):.1f},{h - 2 - (v - lo) / span * (h - 4):.1f}" for i, v in pts) return f"" def flow(vw): """The flow's powers: pv, grid (into the inverter +), load, battery (charge +), soc, and whether the grid figure is estimated: with the bypass on the utility feeds the output directly, which no register counts (the grid register is the utility's charging power only).""" f = vw.view["flow"] p = {k: num(vw.v.get(f.get(k))) for k in ("pv", "grid", "load", "battery", "soc")} p["bypass"] = bool(num(vw.v.get(f.get("bypass")))) # the grid's value then includes the output (estimated) return p def flow_svg(vw, t): """Four nodes around the inverter: solar above, grid left, output right, battery below (its charge as a bar inside); each arrow along the flow.""" p = flow(vw) bp, soc = p["battery"], p["soc"] def width(x): return 1.5 + min(6, abs(x or 0) / 300) def line(x1, y1, x2, y2, power): """From (x1, y1) to (x2, y2) when power > 0, the other way when < 0.""" if not power or abs(power) < 1: return f"" if power < 0: x1, y1, x2, y2 = x2, y2, x1, y1 return f"" def node(cx, cy, label, value, sub=""): return (f"" f"{e(label)}" f"{value}" + (f"{e(sub)}" if sub else "")) grid_sub = t["bypass_est"] if p["bypass"] else "" bat_sub = t["charging"] if (bp or 0) >= 1 else t["discharging"] if (bp or 0) <= -1 else "" bat_label = t["battery"] + (f" · {soc:.0f} %" if soc is not None else "") socbar = "" if soc is not None: w = max(0, min(100, soc)) * 0.96 socbar = (f"") # inverter 130..230 x 124..176 (centre 180,150); nodes 46 px away from it on each side return "".join([ "", "" "", line(180, 54, 180, 124, p["pv"]), # solar -> inverter line(112, 150, 130, 150, p["grid"]), # grid -> inverter (+) line(230, 150, 248, 150, p["load"]), # inverter -> output line(180, 176, 180, 246, bp), # inverter -> battery (charge +) node(180, 28, t["pv"], fmt(p["pv"], "W")), node(56, 150, t["grid"], ("≈ " if p["bypass"] else "") + fmt(p["grid"], "W"), grid_sub), f"{t['inverter']}" + (f"{t['bypass']}" if p["bypass"] else ""), node(304, 150, t["load"], fmt(p["load"], "W")), f"" f"{e(bat_label)}" f"{fmt(abs(bp) if bp is not None else None, 'W')}" f"{e(bat_sub)}", socbar, ""]) def badge(level, refuse, t): if level == "sealed": return f"🔒 {t['sealed']}" if level == "protected": what = t["never_off"] if refuse is not None and set(refuse) == {0.0} else t["all_refused"] return f"{t['protected']} · {e(what)}" return f"{t['none']}" def toggle(dev, r, level, t): if level == "sealed": return f"{t['lock']}" name = r.get("name") or r["key"] if level == "protected": msg = t["confirm"].format(name).replace("'", "’") return (f"
" f"" f"
") return (f"
" f"" f"
") def controls(dev, vw, level_of, refuse_of, t): ctl = [r for r in dev["registers"] if r.get("write")] if not ctl: return "" prot = dev.get("protection") or {} notes = {(prot.get(r["key"]) or prot.get("*") or {}).get("note", "") for r in ctl} out = [f"

{t['controls']}

"] if len(notes) == 1 and next(iter(notes)): out.append(f"

{e(next(iter(notes)))}

") if dev.get("read_only"): out.append(f"

{t['ro_note']}

") levels = {r["key"]: level_of(dev, r["key"]) for r in ctl} if len(ctl) >= 8 and all(is_switch(r) for r in ctl): same = len({(levels[r["key"]], str(refuse_of(dev, r["key"]))) for r in ctl}) == 1 if same: out.append(f"

{t['all']} {badge(levels[ctl[0]['key']], refuse_of(dev, ctl[0]['key']), t)}

") out.append("
") for r in ctl: on = str(vw.v.get(r["key"])) == r["write"]["options"]["1"] out.append(f"
{e(r.get('name') or r['key'])}" f"{e(str(vw.v.get(r['key']) or '–'))}
" f"
{'' if same else badge(levels[r['key']], refuse_of(dev, r['key']), t)}" f"{toggle(dev, r, levels[r['key']], t)}
") out.append("
") else: out.append("") for r in ctl: n = (prot.get(r["key"]) or {}).get("note", "") if len(notes) > 1 else "" out.append(f"" f"") out.append("
{e(r.get('name') or r['key'])}" + (f"
{e(n)}" if n else "") + f"
{e(str(vw.v.get(r['key']) or '–'))}{badge(levels[r['key']], refuse_of(dev, r['key']), t)}{toggle(dev, r, levels[r['key']], t)}
") if sum(1 for lv in levels.values() if lv == "none") >= 2: out.append(f"

" f"" f"

") out.append("
") return "".join(out) def value_sets(vw, skip, t): """The values not shown elsewhere, in sets; one value: a line.""" groups, bits = {}, [] for k, r in vw.regs.items(): if r.get("write") or k in skip or r.get("type") == "string": continue if r.get("bits"): x = num(vw.v.get(k)) if not x: bits.append((r, vw.v.get(k))) continue groups.setdefault(r.get("group") or k.split("_")[0].capitalize(), []).append(r) cards, lines = [], [] for g, rs in groups.items(): if len(rs) == 1: r = rs[0] lines.append(f"
{e(r.get('name') or r['key'])}{fmt(vw.v.get(r['key']), r.get('unit', ''))}
") continue rows = "".join(f"{e(r.get('name') or r['key'])}{fmt(vw.v.get(r['key']), r.get('unit', ''))}" + (f"
{spark(vw.series(r['key']), 80, 18)}" if r.get("unit") == "W" else "") + "" for r in rs) cards.append(f"

{e(g)}

{rows}
") out = "" if cards: out += f"
{''.join(cards)}
" if lines: out += f"
{''.join(lines)}
" if bits: out += (f"
{t['details']}" + "".join(f"" for r, v in bits) + "
{e(r.get('name') or r['key'])}{e(str(v if v is not None else '–'))}
") return out def channel_grid(vw, t): ch = vw.channels() pw = {n: num(vw.v.get(c.get("power"))) for n, c in ch.items()} total = sum(x or 0 for x in pw.values()) volts = [num(vw.v.get(c.get("voltage"))) for c in ch.values() if c.get("voltage")] volts = [x for x in volts if x is not None] one_v = volts and max(volts) - min(volts) <= 5 head = (f"
{t['total']}{fmt(total, 'W')}" f"{spark([sum(x or 0 for x in s) if any(x is not None for x in s) else None for s in zip(*[vw.series(c['power']) for c in ch.values() if c.get('power')])])}
" + (f"
{t['voltage']} {fmt(sum(volts) / len(volts), 'V')}
" if one_v else "") + "
") tiles = [] for n in sorted(ch): c = ch[n] sw = c.get("circuit") or next((k for k in c.values() if vw.regs[k].get("write")), None) name = (vw.regs[sw].get("name") if sw else None) or t["circuit"].format(n) state = f" {e(str(vw.v.get(sw) or '–'))}" if sw else "" share = (pw[n] or 0) / total * 100 if total else 0 small = [fmt(vw.v.get(c[b]), vw.regs[c[b]].get("unit", "")) for b in ("current", "energy") if c.get(b)] if c.get("voltage") and not one_v: small.append(fmt(vw.v.get(c["voltage"]), "V")) tiles.append(f"
{e(name)}{state}
" f"
{fmt(pw[n], 'W')}
" f"
{' · '.join(small)}
") return head + f"
{''.join(tiles)}
", {k for c in ch.values() for k in c.values()} def device_view(dev, vw, status, level_of, refuse_of, t): out = [f"

← {t['back']}

", f"

{e(dev['name'])}

{e(dev['manufacturer'])} {e(dev['model'])} · {where(dev, t)} · " f"{t['every'].format(dev.get('poll_s', 10))} {state_badges(dev, status, t)}

"] skip = set() if vw.view.get("flow"): f = vw.view["flow"] skip |= {f.get(k) for k in ("pv", "grid", "load", "battery", "soc", "bypass")} for d in vw.dev.get("derived") or []: skip |= set(d.get("product") or []) sparks = "" + "".join( f"" for k in (f.get("pv"), f.get("load"), f.get("battery"), f.get("grid")) if k in vw.regs) + "
{e(vw.regs[k].get('name') or k)}{fmt(vw.v.get(k), 'W')}{spark(vw.series(k), 160, 32)}
" energy = " · ".join(f"{e(vw.regs[k].get('name') or k)} {fmt(vw.v.get(k), 'Wh')}" for k in vw.view.get("energy") or [] if k in vw.regs) skip |= set(vw.view.get("energy") or []) out.append(f"
{flow_svg(vw, t)}{sparks}" + (f"

{t['energy']}: {energy}

" if energy else "") + "
") if vw.channels(): grid, used = channel_grid(vw, t) out.append(grid) skip |= used out.append(value_sets(vw, skip, t)) out.append(controls(dev, vw, level_of, refuse_of, t)) out.append("
") return "".join(out) def where(dev, t): if dev.get("source") == "ha": return f"{t['ha']} ({e(dev.get('device', ''))})" return f"{e(dev['host'])}:{dev['port']} · unit {dev['unit_id']}" def state_badges(dev, status, t): b = [f"{t['online'] if status == 'online' else t['offline']}"] \ if status else [] if dev.get("read_only"): b.append(f"{t['ro']}") if dev.get("simulated"): b.append(f"{t['sim']}") return " ".join(b) def render(devs, values, statuses, hist, level_of, refuse_of, lang="en", plog=()): t = T.get(lang, T["en"]) out = [f"" f"{t['title']}

{t['title']}

{t['intro']}

"] views = {d["id"]: View(d, values, hist) for d in devs} for d in devs: vw = views[d["id"]] ctl = [r for r in d["registers"] if r.get("write")] n_prot = sum(1 for r in ctl if level_of(d, r["key"]) in ("protected", "sealed")) heads = " · ".join((f"{e(k)} {v}" if k else f"{v}") for k, v in vw.headline(t)) summary = t["prot_sum"].format(n_prot, len(ctl)) if ctl else t["no_controls"] out.append(f"

{e(d['name'])}

" f"{state_badges(d, statuses.get(d['id']), t)}
" f"
{e(d['model'])} · {where(d, t)}
" + (f"
{heads}
" if heads else "") + f"
{summary}
") out.append(f"
{t['history']}
{e(chr(10).join(plog)) or t['none_yet']}
") for d in devs: out.append(device_view(d, views[d["id"]], statuses.get(d["id"]), level_of, refuse_of, t)) out.append("") return "".join(out).encode()