x

backend/services/control_exporter.py

@@ -0,0 +1,425 @@
+"""Export plánovaných setpointů na Modbus (Deye, EV, TČ) a HTTP do Loxone."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from dataclasses import dataclass
+from datetime import datetime, timezone
+import asyncpg
+import httpx
+
+from app.config import get_settings
+from services.telemetry_collector import ModbusDevice
+
+logger = logging.getLogger(__name__)
+
+
+def watts_to_amps(power_w: int | None, phases: int = 3, voltage: int = 230) -> int:
+    if not power_w or power_w <= 0:
+        return 0
+    return min(32, max(0, int(power_w / (phases * voltage))))
+
+
+@dataclass
+class ControlSetpoints:
+    battery_w: int | None
+    grid_export_limit: int
+    ev1_current_a: int
+    ev2_current_a: int
+    heat_pump_enable: bool
+    grid_setpoint_w: int
+    ev1_power_w: int
+    ev2_power_w: int
+
+
+@dataclass
+class OperatingModeInfo:
+    mode_code: str
+    battery_mode: str
+    grid_mode: str
+    ev_enabled: bool
+    heat_pump_enabled_def: bool
+    loxone_mode_value: int
+
+
+def _clamp_u16(value: int) -> int:
+    return max(0, min(65535, int(value)))
+
+
+async def _fetch_operating_mode(site_id: int, db: asyncpg.Connection) -> OperatingModeInfo | None:
+    sql = """
+        SELECT som.mode_code, omd.battery_mode, omd.grid_mode,
+               omd.ev_enabled, omd.heat_pump_enabled, omd.loxone_mode_value,
+               som.valid_until
+        FROM ems.site_operating_mode som
+        JOIN ems.operating_mode_def omd ON omd.code = som.mode_code
+        WHERE som.site_id = $1
+        """
+    row = await db.fetchrow(sql, site_id)
+    if row is None:
+        return None
+    vu = row["valid_until"]
+    if vu is not None:
+        now_utc = datetime.now(timezone.utc)
+        if vu.tzinfo is None:
+            vu = vu.replace(tzinfo=timezone.utc)
+        if vu <= now_utc:
+            await db.execute("SELECT ems.fn_expire_modes()")
+            row = await db.fetchrow(sql, site_id)
+            if row is None:
+                return None
+    return OperatingModeInfo(
+        mode_code=row["mode_code"],
+        battery_mode=row["battery_mode"],
+        grid_mode=row["grid_mode"],
+        ev_enabled=bool(row["ev_enabled"]),
+        heat_pump_enabled_def=bool(row["heat_pump_enabled"]),
+        loxone_mode_value=int(row["loxone_mode_value"]),
+    )
+
+
+async def _fetch_current_slot_plan_row(site_id: int, db: asyncpg.Connection) -> asyncpg.Record | None:
+    """Řádek plánu pro následující 15min slot (export ~1 min před hranicí, např. 14:29 → 14:30–14:45)."""
+    return await db.fetchrow(
+        """
+        SELECT pi.* FROM ems.planning_interval pi
+        JOIN ems.planning_run pr ON pr.id = pi.run_id
+        WHERE pr.site_id = $1 AND pr.status = 'active'
+          AND pi.interval_start = (
+            SELECT MIN(pi2.interval_start) FROM ems.planning_interval pi2
+            JOIN ems.planning_run pr2 ON pr2.id = pi2.run_id
+            WHERE pr2.site_id = $1 AND pr2.status = 'active'
+              AND pi2.interval_start >= date_trunc('hour', now())
+                  + INTERVAL '15 min' * FLOOR(EXTRACT(MINUTE FROM now()) / 15)
+                  + INTERVAL '15 minutes'
+          )
+        LIMIT 1
+        """,
+        site_id,
+    )
+
+
+async def _fetch_max_charge_power_w(site_id: int, db: asyncpg.Connection) -> int:
+    v = await db.fetchval(
+        """
+        SELECT ai.max_charge_power_w
+        FROM ems.asset_inverter ai
+        WHERE ai.site_id = $1 AND ai.controllable = true AND ai.active = true
+        ORDER BY ai.id
+        LIMIT 1
+        """,
+        site_id,
+    )
+    if v is None:
+        return 0
+    return int(v)
+
+
+def _build_setpoints(mode: OperatingModeInfo, pi: asyncpg.Record | None) -> ControlSetpoints | None:
+    code = mode.mode_code
+    if code == "MANUAL":
+        return None
+
+    if code == "AUTO":
+        if pi is None:
+            return None
+        grid_sp = int(pi["grid_setpoint_w"] or 0)
+        ev1_w = int(pi["ev1_setpoint_w"] or 0) if "ev1_setpoint_w" in pi else 0
+        ev2_w = int(pi["ev2_setpoint_w"] or 0) if "ev2_setpoint_w" in pi else 0
+        hp_en = bool(pi["heat_pump_enabled"])
+        return ControlSetpoints(
+            battery_w=int(pi["battery_setpoint_w"] or 0),
+            grid_export_limit=abs(min(grid_sp, 0)),
+            ev1_current_a=watts_to_amps(ev1_w, phases=3),
+            ev2_current_a=watts_to_amps(ev2_w, phases=1),
+            heat_pump_enable=hp_en,
+            grid_setpoint_w=grid_sp,
+            ev1_power_w=ev1_w,
+            ev2_power_w=ev2_w,
+        )
+
+    if code == "SELF_SUSTAIN":
+        return ControlSetpoints(
+            battery_w=None,
+            grid_export_limit=0,
+            ev1_current_a=0,
+            ev2_current_a=0,
+            heat_pump_enable=False,
+            grid_setpoint_w=0,
+            ev1_power_w=0,
+            ev2_power_w=0,
+        )
+
+    if code == "CHARGE_CHEAP":
+        # max_charge doplníme v export_setpoints z DB
+        return ControlSetpoints(
+            battery_w=0,
+            grid_export_limit=0,
+            ev1_current_a=0,
+            ev2_current_a=0,
+            heat_pump_enable=False,
+            grid_setpoint_w=0,
+            ev1_power_w=0,
+            ev2_power_w=0,
+        )
+
+    if code == "PRESERVE":
+        return ControlSetpoints(
+            battery_w=0,
+            grid_export_limit=0,
+            ev1_current_a=0,
+            ev2_current_a=0,
+            heat_pump_enable=False,
+            grid_setpoint_w=0,
+            ev1_power_w=0,
+            ev2_power_w=0,
+        )
+
+    logger.warning("Unknown mode_code %s for site export, skipping", code)
+    return None
+
+
+async def write_inverter_setpoints(site_id: int, setpoints: ControlSetpoints, db: asyncpg.Connection) -> str:
+    if setpoints.battery_w is None:
+        return "OK inverter: skipped (battery_w=None, Deye unchanged)"
+
+    rows = await db.fetch(
+        """
+        SELECT ai.code, se.host, se.port, se.unit_id
+        FROM ems.asset_inverter ai
+        JOIN ems.site_endpoint se ON se.id = ai.endpoint_id
+        WHERE ai.site_id = $1
+          AND ai.controllable = true
+          AND ai.active = true
+          AND se.enabled = true
+          AND se.endpoint_type = 'modbus_tcp'
+        """,
+        site_id,
+    )
+    if not rows:
+        return "FAIL inverter: no controllable Modbus endpoint"
+
+    bw = setpoints.battery_w
+    gex = _clamp_u16(setpoints.grid_export_limit)
+    chg = _clamp_u16(bw) if bw >= 0 else 0
+    dis = _clamp_u16(abs(bw)) if bw < 0 else 0
+
+    errors: list[str] = []
+    for row in rows:
+        code = row["code"]
+        host = row["host"]
+        port = int(row["port"] or 502)
+        unit_id = int(row["unit_id"] if row["unit_id"] is not None else 1)
+        dev = ModbusDevice(host, port, unit_id, f"inverter-write:{code}")
+        try:
+            if bw >= 0:
+                ok1 = await dev.write_register(0x00F3, chg)
+                ok2 = await dev.write_register(0x00F4, 0)
+            else:
+                ok1 = await dev.write_register(0x00F3, 0)
+                ok2 = await dev.write_register(0x00F4, dis)
+            ok3 = await dev.write_register(0x00F6, gex)
+            if not (ok1 and ok2 and ok3):
+                errors.append(f"{code}: Modbus write failed")
+        except Exception as e:
+            errors.append(f"{code}: {e}")
+        finally:
+            await dev.close()
+
+    if errors:
+        return "FAIL inverter: " + "; ".join(errors)
+    return f"OK inverter: batt_w={bw} export_limit_w={gex}"
+
+
+def _current_limit_for_charger(charger_code: str, sp: ControlSetpoints) -> int:
+    c = (charger_code or "").strip().lower()
+    if c == "ev-charger-1":
+        a = sp.ev1_current_a
+    elif c == "ev-charger-2":
+        a = sp.ev2_current_a
+    elif c.endswith("-1") or c == "ev1":
+        a = sp.ev1_current_a
+    elif c.endswith("-2") or c == "ev2":
+        a = sp.ev2_current_a
+    else:
+        a = 0
+    if a < 6:
+        a = 0
+    return a
+
+
+async def write_ev_setpoints(site_id: int, setpoints: ControlSetpoints, db: asyncpg.Connection) -> str:
+    rows = await db.fetch(
+        """
+        SELECT ec.code, se.host, se.port, se.unit_id
+        FROM ems.asset_ev_charger ec
+        JOIN ems.site_endpoint se ON se.id = ec.endpoint_id
+        WHERE ec.site_id = $1
+          AND ec.schedulable = true
+          AND se.enabled = true
+          AND se.endpoint_type = 'modbus_tcp'
+        ORDER BY ec.code
+        """,
+        site_id,
+    )
+    if not rows:
+        return "OK EV: no schedulable chargers"
+
+    for row in rows:
+        code = row["code"]
+        current_a = _current_limit_for_charger(code, setpoints)
+        logger.info(
+            "EV setpoint [%s]: %sA (TODO: Modbus registers)",
+            code,
+            current_a,
+        )
+    return f"OK EV: logged {len(rows)} charger(s) (Modbus TODO)"
+
+
+async def write_heat_pump_setpoint(site_id: int, setpoints: ControlSetpoints, db: asyncpg.Connection) -> str:
+    rows = await db.fetch(
+        """
+        SELECT hp.code, se.host, se.port, se.unit_id
+        FROM ems.asset_heat_pump hp
+        JOIN ems.site_endpoint se ON se.id = hp.endpoint_id
+        WHERE hp.site_id = $1
+          AND hp.schedulable = true
+          AND se.enabled = true
+          AND se.endpoint_type = 'modbus_tcp'
+        """,
+        site_id,
+    )
+    if not rows:
+        return "OK heat pump: no schedulable unit"
+    for row in rows:
+        logger.info(
+            "HP setpoint [%s]: enable=%s (TODO: Modbus registers)",
+            row["code"],
+            setpoints.heat_pump_enable,
+        )
+    return "OK heat pump: logged (Modbus TODO)"
+
+
+async def send_loxone_setpoints(
+    site_id: int,
+    setpoints: ControlSetpoints,
+    mode: OperatingModeInfo,
+    db: asyncpg.Connection,
+) -> str:
+    endpoint = await db.fetchrow(
+        """
+        SELECT host, port, protocol
+        FROM ems.site_endpoint
+        WHERE site_id = $1 AND endpoint_type = 'loxone_http' AND enabled = true
+        ORDER BY id
+        LIMIT 1
+        """,
+        site_id,
+    )
+    if not endpoint:
+        return "OK Loxone: no endpoint, skipped"
+
+    proto = (endpoint["protocol"] or "http").lower()
+    if proto not in ("http", "https"):
+        proto = "http"
+    host = endpoint["host"]
+    port = int(endpoint["port"] or (443 if proto == "https" else 80))
+    base = f"{proto}://{host}:{port}/dev/sps/io"
+
+    settings = get_settings()
+    user = settings.loxone_user or os.getenv("LOXONE_USER") or ""
+    password = settings.loxone_password or os.getenv("LOXONE_PASSWORD") or ""
+    auth = (user, password) if user else None
+
+    batt_display = 0 if setpoints.battery_w is None else int(setpoints.battery_w)
+
+    paths: list[tuple[str, int]] = [
+        (f"{base}/EMS_Mode/{mode.loxone_mode_value}", mode.loxone_mode_value),
+        (f"{base}/EMS_Battery_Setpoint_W/{batt_display}", batt_display),
+        (f"{base}/EMS_Grid_Setpoint_W/{setpoints.grid_setpoint_w}", setpoints.grid_setpoint_w),
+        (f"{base}/EMS_EV1_Power_W/{setpoints.ev1_power_w}", setpoints.ev1_power_w),
+        (f"{base}/EMS_EV2_Power_W/{setpoints.ev2_power_w}", setpoints.ev2_power_w),
+        (f"{base}/EMS_HeatPump_Enable/{1 if setpoints.heat_pump_enable else 0}", 1 if setpoints.heat_pump_enable else 0),
+    ]
+
+    errs: list[str] = []
+    try:
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            for url, _ in paths:
+                try:
+                    r = await client.get(url, auth=auth)
+                    r.raise_for_status()
+                except Exception as e:
+                    errs.append(f"{url!s}: {e}")
+    except Exception as e:
+        return f"FAIL Loxone: client {e}"
+
+    if errs:
+        return "FAIL Loxone: " + "; ".join(errs[:3])
+    return "OK Loxone: all virtual inputs updated"
+
+
+async def export_setpoints(site_id: int, db: asyncpg.Connection) -> None:
+    mode = await _fetch_operating_mode(site_id, db)
+    if mode is None:
+        logger.warning("control export site=%s: no operating mode row", site_id)
+        return
+
+    if mode.mode_code == "MANUAL":
+        logger.info("control export site=%s: MANUAL, skip writes", site_id)
+        return
+
+    pi = await _fetch_current_slot_plan_row(site_id, db)
+    sp = _build_setpoints(mode, pi)
+
+    if mode.mode_code == "AUTO" and sp is None:
+        if pi is None:
+            logger.warning(
+                "control export site=%s: AUTO but no planning_interval for current slot, skip",
+                site_id,
+            )
+        return
+
+    if sp is None:
+        logger.warning(
+            "control export site=%s: no setpoints for mode %s, skip",
+            site_id,
+            mode.mode_code,
+        )
+        return
+
+    if mode.mode_code == "CHARGE_CHEAP":
+        max_ch = await _fetch_max_charge_power_w(site_id, db)
+        sp = ControlSetpoints(
+            battery_w=max_ch,
+            grid_export_limit=0,
+            ev1_current_a=0,
+            ev2_current_a=0,
+            heat_pump_enable=False,
+            grid_setpoint_w=0,
+            ev1_power_w=0,
+            ev2_power_w=0,
+        )
+
+    results = list(
+        zip(
+            ("inverter", "ev", "heat_pump", "loxone"),
+            await asyncio.gather(
+                write_inverter_setpoints(site_id, sp, db),
+                write_ev_setpoints(site_id, sp, db),
+                write_heat_pump_setpoint(site_id, sp, db),
+                send_loxone_setpoints(site_id, sp, mode, db),
+                return_exceptions=True,
+            ),
+        )
+    )
+
+    for name, res in results:
+        if isinstance(res, Exception):
+            logger.error("control export site=%s %s: FAIL %s", site_id, name, res)
+        elif isinstance(res, str) and res.startswith("FAIL"):
+            logger.error("control export site=%s %s: %s", site_id, name, res)
+        else:
+            logger.info("control export site=%s %s: %s", site_id, name, res)