retr0
30f2667589
- wallbox_client: Bei Reg-Fehler Range überspringen statt komplett abbrechen → Meter-Daten kommen weiter wenn EVSE-Block (0x0060) nicht verfügbar - wallbox_client: set_current() schreibt jetzt auch EMS_RELAIS_REG (0x00A1) mit korrekter Phasen-Bitmaske (1→0x0001, 2→0x0003, 3→0x0007) - ems_controller: phases wird an set_current() und Zwangsladen übergeben Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
122 lines
4.1 KiB
Python
122 lines
4.1 KiB
Python
import logging
|
|
import struct
|
|
import time
|
|
from typing import Dict, Optional
|
|
|
|
from pymodbus.client import ModbusTcpClient
|
|
from pymodbus.exceptions import ModbusException
|
|
|
|
from inverters import Inverter, Sensor
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
SLAVE = 0 # Kathrein: Unit-ID 0 (Broadcast)
|
|
EMS_CTRL_REG = 0x00A0
|
|
EMS_RELAIS_REG = 0x00A1
|
|
EMS_CURRENT_REG = 0x00A2
|
|
EMS_ENABLE = 0x8000
|
|
MIN_CURRENT_MA = 6000
|
|
MAX_CURRENT_MA = 32000
|
|
|
|
_PHASE_MASK = {1: 0x0001, 2: 0x0003, 3: 0x0007}
|
|
|
|
|
|
class WallboxReader:
|
|
def __init__(self, host: str, port: int = 502, timeout: float = 10.0):
|
|
self.host = host
|
|
self.port = port
|
|
self.timeout = timeout
|
|
self._client: Optional[ModbusTcpClient] = None
|
|
|
|
def _connect(self) -> bool:
|
|
if self._client and self._client.connected:
|
|
return True
|
|
self._client = ModbusTcpClient(self.host, port=self.port, timeout=self.timeout)
|
|
if not self._client.connect():
|
|
log.error("[Wallbox %s] Verbindung fehlgeschlagen", self.host)
|
|
self._client = None
|
|
return False
|
|
return True
|
|
|
|
def _disconnect(self):
|
|
if self._client:
|
|
self._client.close()
|
|
self._client = None
|
|
|
|
def read(self, inverter: Inverter) -> Optional[Dict[str, float]]:
|
|
if not self._connect():
|
|
return None
|
|
|
|
reg_cache: Dict[int, int] = {}
|
|
any_ok = False
|
|
for start, length in inverter.read_ranges:
|
|
try:
|
|
result = self._client.read_holding_registers(start, count=length, slave=SLAVE)
|
|
if result.isError():
|
|
log.warning("[Wallbox] FC03 Reg 0x%04X nicht verfügbar: %s", start, result)
|
|
continue
|
|
for i, val in enumerate(result.registers):
|
|
reg_cache[start + i] = val
|
|
any_ok = True
|
|
except ModbusException as e:
|
|
log.error("[Wallbox] Modbus Ausnahme: %s", e)
|
|
self._disconnect()
|
|
return None
|
|
|
|
return _extract(inverter.sensors, reg_cache) if any_ok else None
|
|
|
|
def enable_ems(self) -> bool:
|
|
if not self._connect():
|
|
return False
|
|
try:
|
|
r = self._client.write_register(EMS_CTRL_REG, EMS_ENABLE, slave=SLAVE)
|
|
return not r.isError()
|
|
except ModbusException as e:
|
|
log.error("[Wallbox] EMS enable Fehler: %s", e)
|
|
return False
|
|
|
|
def set_current(self, ma: int, phases: int = 3) -> bool:
|
|
"""Ladestrom setzen. ma=0 → Pause, ma=0xFFFF → Abbruch."""
|
|
if not self._connect():
|
|
return False
|
|
val = 0 if ma == 0 else max(MIN_CURRENT_MA, min(MAX_CURRENT_MA, ma))
|
|
relais = _PHASE_MASK.get(phases, 0x0007)
|
|
try:
|
|
r = self._client.write_register(EMS_RELAIS_REG, relais, slave=SLAVE)
|
|
if r.isError():
|
|
log.warning("[Wallbox] Relais-Matrix Fehler: %s", r)
|
|
r = self._client.write_register(EMS_CURRENT_REG, val, slave=SLAVE)
|
|
ok = not r.isError()
|
|
if ok:
|
|
log.info("[Wallbox] Strom gesetzt: %d mA (%d Phase(n))", val, phases)
|
|
return ok
|
|
except ModbusException as e:
|
|
log.error("[Wallbox] set_current Fehler: %s", e)
|
|
return False
|
|
|
|
def close(self):
|
|
self._disconnect()
|
|
|
|
|
|
def _extract(sensors: list, regs: Dict[int, int]) -> Dict[str, float]:
|
|
values: Dict[str, float] = {}
|
|
for s in sensors:
|
|
if s.reg not in regs:
|
|
continue
|
|
dt = getattr(s, "data_type", "uint16")
|
|
try:
|
|
if dt == "float32":
|
|
if s.reg + 1 not in regs:
|
|
continue
|
|
raw = struct.unpack(">f", struct.pack(">HH", regs[s.reg], regs[s.reg + 1]))[0]
|
|
elif dt == "uint32":
|
|
if s.reg + 1 not in regs:
|
|
continue
|
|
raw = (regs[s.reg] << 16) | regs[s.reg + 1]
|
|
else:
|
|
raw = regs[s.reg]
|
|
values[s.id] = round(float(raw) * s.scale, 3)
|
|
except Exception:
|
|
pass
|
|
return values
|