inverter and meter seems to run

solaredge_meter.py

@@ -0,0 +1,134 @@
+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)
+MIN_ADDR_INCLUSIVE = 40121
+ADDRESS_SHIFT = 50
+
+class SolaredgeMeter:
+    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 Zähler fehlgeschlagen.")
+            raise SystemExit(1)
+        print("✅ Verbindung zu Zähler 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"] >= MIN_ADDR_INCLUSIVE]
+
+        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
+        shifted_addr = address + ADDRESS_SHIFT
+        for kwargs in (dict(address=shifted_addr, count=count, slave=self.unit),
+                       dict(address=shifted_addr, 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)
+
+        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"])
+
+            val = self.read_one(address, meta["type"])
+            if val is None:
+                continue
+            key = f"{address} - {meta['desc']}"
+            data[key] = val
+        return data