140 lines
5.2 KiB
Python
140 lines
5.2 KiB
Python
import time
|
|
import struct
|
|
import pandas as pd
|
|
from typing import Dict, Any, List, Tuple, Optional
|
|
from pymodbus.client import ModbusTcpClient
|
|
|
|
EXCEL_PATH = "modbus_registers/pv_inverter_registers.xlsx"
|
|
|
|
# Obergrenze: bis EXKLUSIVE 40206 (d.h. max. 40205)
|
|
MAX_ADDR_EXCLUSIVE = 40121
|
|
|
|
class PvInverter:
|
|
def __init__(self, device_name: str, ip_address: str, port: int = 502, unit: int = 1):
|
|
self.device_name = device_name
|
|
self.ip = ip_address
|
|
self.port = port
|
|
self.unit = unit
|
|
self.client: Optional[ModbusTcpClient] = None
|
|
self.registers: Dict[int, Dict[str, Any]] = {} # addr -> {"desc":..., "type":...}
|
|
self.connect_to_modbus()
|
|
self.load_registers(EXCEL_PATH)
|
|
|
|
# ---------- Verbindung ----------
|
|
def connect_to_modbus(self):
|
|
self.client = ModbusTcpClient(self.ip, port=self.port, timeout=3.0, retries=3)
|
|
if not self.client.connect():
|
|
print("❌ Verbindung zu Wechselrichter fehlgeschlagen.")
|
|
raise SystemExit(1)
|
|
print("✅ Verbindung zu Wechselrichter hergestellt.")
|
|
|
|
def close(self):
|
|
if self.client:
|
|
self.client.close()
|
|
self.client = None
|
|
|
|
# ---------- Register-Liste ----------
|
|
def load_registers(self, excel_path: str):
|
|
xls = pd.ExcelFile(excel_path)
|
|
df = xls.parse()
|
|
# Passe Spaltennamen hier an, falls nötig:
|
|
cols = ["MB Adresse", "Beschreibung", "Variabel Typ"]
|
|
df = df[cols].dropna()
|
|
df["MB Adresse"] = df["MB Adresse"].astype(int)
|
|
|
|
# 1) Vorab-Filter: nur Adressen < 40206 übernehmen
|
|
df = df[df["MB Adresse"] < MAX_ADDR_EXCLUSIVE]
|
|
|
|
self.registers = {
|
|
int(row["MB Adresse"]): {
|
|
"desc": str(row["Beschreibung"]).strip(),
|
|
"type": str(row["Variabel Typ"]).strip()
|
|
}
|
|
for _, row in df.iterrows()
|
|
}
|
|
|
|
|
|
# ---------- Low-Level Lesen ----------
|
|
def _try_read(self, fn_name: str, address: int, count: int) -> Optional[List[int]]:
|
|
fn = getattr(self.client, fn_name)
|
|
# pymodbus 3.8.x hat 'slave='; Fallbacks schaden nicht
|
|
for kwargs in (dict(address=address, count=count, slave=self.unit),
|
|
dict(address=address, count=count)):
|
|
try:
|
|
res = fn(**kwargs)
|
|
if res is None or (hasattr(res, "isError") and res.isError()):
|
|
continue
|
|
return res.registers
|
|
except TypeError:
|
|
continue
|
|
return None
|
|
|
|
def _read_any(self, address: int, count: int) -> Optional[List[int]]:
|
|
regs = self._try_read("read_holding_registers", address, count)
|
|
if regs is None:
|
|
regs = self._try_read("read_input_registers", address, count)
|
|
return regs
|
|
|
|
# ---------- Decoding ----------
|
|
@staticmethod
|
|
def _to_i16(u16: int) -> int:
|
|
return struct.unpack(">h", struct.pack(">H", u16))[0]
|
|
|
|
@staticmethod
|
|
def _to_f32_from_two(u16_hi: int, u16_lo: int, msw_first: bool = True) -> float:
|
|
b = struct.pack(">HH", u16_hi, u16_lo) if msw_first else struct.pack(">HH", u16_lo, u16_hi)
|
|
return struct.unpack(">f", b)[0]
|
|
|
|
# Hilfsfunktion: wie viele 16-Bit-Register braucht dieser Typ?
|
|
@staticmethod
|
|
def _word_count_for_type(rtype: str) -> int:
|
|
rt = (rtype or "").lower()
|
|
# Passe hier an deine Excel-Typen an:
|
|
if "uint32" in rt or "real" in rt or "float" in rt or "string(32)" in rt:
|
|
return 2
|
|
# Default: 1 Wort (z.B. int16/uint16)
|
|
return 1
|
|
|
|
def read_one(self, address_excel: int, rtype: str) -> Optional[float]:
|
|
"""
|
|
Liest einen Wert nach Typ ('INT' oder 'REAL' etc.).
|
|
Es werden ausschließlich Register < 40206 gelesen.
|
|
"""
|
|
addr = int(address_excel)
|
|
words = self._word_count_for_type(rtype)
|
|
|
|
# 2) Harte Grenze prüfen: höchstes angefasstes Register muss < 40206 sein
|
|
if addr + words - 1 >= MAX_ADDR_EXCLUSIVE:
|
|
# Überspringen, da der Lesevorgang die Grenze >= 40206 berühren würde
|
|
return None
|
|
|
|
if words == 2:
|
|
regs = self._read_any(addr, 2)
|
|
if not regs or len(regs) < 2:
|
|
return None
|
|
# Deine bisherige Logik interpretiert 2 Worte als Float32:
|
|
return self._to_f32_from_two(regs[0], regs[1])
|
|
else:
|
|
regs = self._read_any(addr, 1)
|
|
if not regs:
|
|
return None
|
|
return float(self._to_i16(regs[0]))
|
|
|
|
def get_state(self) -> Dict[str, Any]:
|
|
"""
|
|
Liest ALLE Register aus self.registers und gibt dict zurück.
|
|
Achtet darauf, dass keine Adresse (inkl. Mehrwort) >= 40206 gelesen wird.
|
|
"""
|
|
data = {"Zeit": time.strftime("%Y-%m-%d %H:%M:%S")}
|
|
for address, meta in sorted(self.registers.items()):
|
|
words = self._word_count_for_type(meta["type"])
|
|
# 3) Nochmals Schutz auf Ebene der Iteration:
|
|
if address + words - 1 >= MAX_ADDR_EXCLUSIVE:
|
|
continue
|
|
val = self.read_one(address, meta["type"])
|
|
if val is None:
|
|
continue
|
|
key = f"{address} - {meta['desc']}"
|
|
data[key] = val
|
|
return data
|