244 lines
7.9 KiB
Python
244 lines
7.9 KiB
Python
"""Modbus command journal helpers pro control export."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import json
|
|
import logging
|
|
from collections import defaultdict
|
|
|
|
import asyncpg
|
|
|
|
from services.control.deye_helpers import DEYE_REGISTER_NAMES, _deye_reg178_verify_match
|
|
from services.modbus_client import get_modbus_client
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
async def _fetch_written_deye_clock_commands(
|
|
site_id: int,
|
|
asset_id: int,
|
|
host: str,
|
|
port: int,
|
|
unit_id: int,
|
|
db: asyncpg.Connection,
|
|
) -> list[asyncpg.Record]:
|
|
"""Všechny řádky journalu 62-64 ve stavu written pro daný invertor/endpoint."""
|
|
rows = await db.fetch(
|
|
"""
|
|
SELECT * FROM ems.modbus_command
|
|
WHERE site_id = $1
|
|
AND asset_type = 'inverter'
|
|
AND asset_id = $2
|
|
AND device_host = $3
|
|
AND device_port = $4
|
|
AND device_unit_id = $5
|
|
AND register IN (62, 63, 64)
|
|
AND status = 'written'
|
|
ORDER BY register
|
|
""",
|
|
site_id,
|
|
asset_id,
|
|
host,
|
|
port,
|
|
unit_id,
|
|
)
|
|
return list(rows)
|
|
|
|
|
|
async def _fetch_last_verified_inverter_registers(
|
|
site_id: int, inverter_asset_id: int, db: asyncpg.Connection
|
|
) -> dict[int, int]:
|
|
"""
|
|
Poslední hodnota na zařízení podle journalu (jen status verified).
|
|
Slouží k přeskočení duplicitního zápisu stejné hodnoty.
|
|
"""
|
|
raw = await db.fetchval(
|
|
"""
|
|
select ems.fn_modbus_last_verified_map($1::int, $2::int)
|
|
""",
|
|
site_id,
|
|
inverter_asset_id,
|
|
)
|
|
data = raw if isinstance(raw, dict) else json.loads(raw)
|
|
return {int(k): int(v) for k, v in data.items()}
|
|
|
|
|
|
def _drop_registers_matching_last_verified(
|
|
registers: list[tuple[int, str, int]],
|
|
last_verified: dict[int, int],
|
|
) -> tuple[list[tuple[int, str, int]], list[int]]:
|
|
"""Vynechá položky s hodnotou shodnou s posledním ověřeným stavem."""
|
|
out: list[tuple[int, str, int]] = []
|
|
skipped: list[int] = []
|
|
for reg, meta, val in registers:
|
|
lv = last_verified.get(int(reg))
|
|
if lv is not None:
|
|
if int(reg) == 178 and _deye_reg178_verify_match(int(val), int(lv)):
|
|
skipped.append(int(reg))
|
|
continue
|
|
if int(lv) == int(val):
|
|
skipped.append(int(reg))
|
|
continue
|
|
out.append((reg, meta, val))
|
|
return out, skipped
|
|
|
|
|
|
async def create_modbus_commands(
|
|
site_id: int,
|
|
planning_run_id: int | None,
|
|
asset_type: str,
|
|
asset_id: int,
|
|
asset_code: str,
|
|
host: str,
|
|
port: int,
|
|
unit_id: int,
|
|
registers: list[tuple[int, str, int]],
|
|
db: asyncpg.Connection,
|
|
deye_physical_mode: str | None = None,
|
|
) -> list[int]:
|
|
"""
|
|
Vytvoří záznamy v modbus_command pro sadu zápisů.
|
|
Vrátí list command IDs.
|
|
"""
|
|
ids: list[int] = []
|
|
for reg, _ignored_name, val in registers:
|
|
register_name = DEYE_REGISTER_NAMES.get(reg, f"reg_{reg}")
|
|
cmd_id = await db.fetchval(
|
|
"""
|
|
INSERT INTO ems.modbus_command
|
|
(site_id, asset_type, asset_id, asset_code,
|
|
device_host, device_port, device_unit_id,
|
|
register, register_name, value_to_write,
|
|
planning_run_id, status, deye_physical_mode)
|
|
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,'pending',$12)
|
|
RETURNING id
|
|
""",
|
|
site_id,
|
|
asset_type,
|
|
asset_id,
|
|
asset_code,
|
|
host,
|
|
port,
|
|
unit_id,
|
|
reg,
|
|
register_name,
|
|
val,
|
|
planning_run_id,
|
|
deye_physical_mode,
|
|
)
|
|
if cmd_id is not None:
|
|
ids.append(int(cmd_id))
|
|
return ids
|
|
|
|
|
|
def _modbus_command_contiguous_runs(cmds: list[asyncpg.Record]) -> list[list[asyncpg.Record]]:
|
|
"""Seřadí podle adresy registru a rozdělí na souvislé úseky pro FC 0x10 / FC 3."""
|
|
if not cmds:
|
|
return []
|
|
sorted_cmds = sorted(cmds, key=lambda c: int(c["register"]))
|
|
runs: list[list[asyncpg.Record]] = []
|
|
cur: list[asyncpg.Record] = [sorted_cmds[0]]
|
|
for c in sorted_cmds[1:]:
|
|
if int(c["register"]) == int(cur[-1]["register"]) + 1:
|
|
cur.append(c)
|
|
else:
|
|
runs.append(cur)
|
|
cur = [c]
|
|
runs.append(cur)
|
|
return runs
|
|
|
|
|
|
async def execute_modbus_commands(
|
|
command_ids: list[int],
|
|
db: asyncpg.Connection,
|
|
) -> bool:
|
|
"""
|
|
Zapíše příkazy z modbus_command do zařízení (FC 0x10 po souvislých blocích).
|
|
Aktualizuje status na 'written' nebo 'failed'.
|
|
"""
|
|
max_retries = 3
|
|
retry_delay = 0.5
|
|
|
|
rows: list[asyncpg.Record] = []
|
|
for cmd_id in command_ids:
|
|
cmd = await db.fetchrow(
|
|
"SELECT * FROM ems.modbus_command WHERE id=$1", cmd_id
|
|
)
|
|
if cmd is not None:
|
|
rows.append(cmd)
|
|
|
|
if not rows:
|
|
return True
|
|
|
|
by_gw: dict[tuple[str, int, int], list[asyncpg.Record]] = defaultdict(list)
|
|
for cmd in rows:
|
|
by_gw[
|
|
(cmd["device_host"], int(cmd["device_port"]), int(cmd["device_unit_id"]))
|
|
].append(cmd)
|
|
|
|
all_ok = True
|
|
for (host, port, unit), group in by_gw.items():
|
|
client = await get_modbus_client(host, port)
|
|
for run in _modbus_command_contiguous_runs(group):
|
|
start_reg = int(run[0]["register"])
|
|
values = [int(c["value_to_write"]) for c in run]
|
|
for attempt in range(max_retries):
|
|
try:
|
|
await client.write_registers(start_reg, values, unit)
|
|
for cmd, val in zip(run, values):
|
|
cid = int(cmd["id"])
|
|
await db.execute(
|
|
"""
|
|
UPDATE ems.modbus_command
|
|
SET status='written', value_written=$1, written_at=now(),
|
|
attempt_count=attempt_count+1, error_msg=NULL
|
|
WHERE id=$2
|
|
""",
|
|
val,
|
|
cid,
|
|
)
|
|
logger.info(
|
|
"[cmd %s] %s 0x%04X=%s OK batch@%s (attempt %s)",
|
|
cid,
|
|
cmd["asset_code"],
|
|
int(cmd["register"]),
|
|
val,
|
|
start_reg,
|
|
attempt + 1,
|
|
)
|
|
break
|
|
except Exception as e:
|
|
if attempt < max_retries - 1:
|
|
logger.warning(
|
|
"Modbus batch write 0x%04X count=%s attempt %s failed: %s, retrying...",
|
|
start_reg,
|
|
len(values),
|
|
attempt + 1,
|
|
e,
|
|
)
|
|
await asyncio.sleep(retry_delay)
|
|
await client.force_disconnect()
|
|
else:
|
|
for cmd in run:
|
|
await db.execute(
|
|
"""
|
|
UPDATE ems.modbus_command
|
|
SET status='failed', error_msg=$1,
|
|
attempt_count=attempt_count+1
|
|
WHERE id=$2
|
|
""",
|
|
str(e),
|
|
int(cmd["id"]),
|
|
)
|
|
logger.error(
|
|
"Modbus batch 0x%04X count=%s all %s attempts failed: %s",
|
|
start_reg,
|
|
len(values),
|
|
max_retries,
|
|
e,
|
|
)
|
|
all_ok = False
|
|
|
|
return all_ok
|