controller implemented and tested

README

@@ -11,10 +11,42 @@ Was needs to be done on the Raspberry pi before the tool can run.
     - pip install -r requirements.txt
 
 
-How to run the script:
+3) How to run the script for testing:
 
-- nohup python main.py > terminal_log 2>&1 &
+    nohup python main.py > terminal_log 2>&1 &
 
 For reading out the terminal_log while script is runing:
 
-- tail -f terminal_log
+    tail -f terminal_log
+
+
+4) Implement and run the ems as systemd service:
+create:
+    /etc/systemd/system/allmende_ems.service
+
+insert:
+    [Unit]
+    Description=Allmende EMS Python Script
+    After=network.target
+
+    [Service]
+    WorkingDirectory=/home/pi/projects/allmende_ems
+    ExecStart=/home/pi/allmende_ems/bin/python3.11 /home/pi/projects/allmende_ems/main.py
+    Restart=always
+    RestartSec=5
+    StandardOutput=journal
+    StandardError=journal
+
+    [Install]
+    WantedBy=multi-user.target
+
+manage the service with the following commands:
+Once:
+    sudo systemctl daemon-reload
+    sudo systemctl start allmende_ems.service
+    sudo systemctl enable allmende_ems.service
+While running:
+    sudo systemctl status allmende_ems.service
+    sudo systemctl restart allmende_ems.service
+    sudo systemctl stop allmende_ems.service
+    journalctl -u allmende_ems.service

data_base_csv.py

@@ -1,46 +0,0 @@
-import csv
-import os
-import tempfile
-import shutil
-
-class DataBaseCsv:
-    def __init__(self, filename: str):
-        self.filename = filename
-
-    def store_data(self, data: dict):
-        new_fields = list(data.keys())
-
-        # If file does not exist or is empty → create new file with header
-        if not os.path.exists(self.filename) or os.path.getsize(self.filename) == 0:
-            with open(self.filename, mode='w', newline='') as csv_file:
-                writer = csv.DictWriter(csv_file, fieldnames=new_fields)
-                writer.writeheader()
-                writer.writerow(data)
-            return
-
-        # If file exists → read existing header and data
-        with open(self.filename, mode='r', newline='') as csv_file:
-            reader = csv.DictReader(csv_file)
-            existing_fields = reader.fieldnames
-            existing_data = list(reader)
-
-        # Merge old and new fields (keep original order, add new ones)
-        all_fields = existing_fields.copy()
-        for field in new_fields:
-            if field not in all_fields:
-                all_fields.append(field)
-
-        # Write to a temporary file with updated header
-        with tempfile.NamedTemporaryFile(mode='w', delete=False, newline='', encoding='utf-8') as tmp_file:
-            writer = csv.DictWriter(tmp_file, fieldnames=all_fields)
-            writer.writeheader()
-
-            # Write old rows with updated field list
-            for row in existing_data:
-                writer.writerow({field: row.get(field, '') for field in all_fields})
-
-            # Write new data row
-            writer.writerow({field: data.get(field, '') for field in all_fields})
-
-        # Replace original file with updated temporary file
-        shutil.move(tmp_file.name, self.filename)

data_base_influx.py

@@ -0,0 +1,28 @@
+from influxdb_client import InfluxDBClient, Point, WritePrecision
+from datetime import datetime
+
+class DataBaseInflux:
+    def __init__(self, url: str, token: str, org: str, bucket: str):
+        self.url = url
+        self.token = token
+        self.org = org
+        self.bucket = bucket
+        self.client = InfluxDBClient(url=self.url, token=self.token, org=self.org)
+        self.write_api = self.client.write_api()
+
+    def store_data(self, device_name: str, data: dict):
+        measurement = device_name # Fest auf "messungen" gesetzt
+
+        point = Point(measurement)
+
+        # Alle Key/Value-Paare als Fields speichern
+        for key, value in data.items():
+            point = point.field(key, value)
+
+        # Zeitstempel automatisch auf jetzt setzen
+        point = point.time(datetime.utcnow(), WritePrecision.NS)
+
+        # Punkt in InfluxDB schreiben
+        self.write_api.write(bucket=self.bucket, org=self.org, record=point)
+
+

energysystem.py

@@ -0,0 +1,25 @@
+
+
+
+class EnergySystem():
+    def __init__(self):
+        self.components = []
+
+    def add_components(self, *args):
+        for comp in args:
+            self.components.append(comp)
+
+    def get_state_and_store_to_database(self, db):
+        state = {}
+        for comp in self.components:
+            component_state = comp.get_state()
+            state[comp.device_name] = component_state
+            db.store_data(comp.device_name, component_state)
+
+        return state
+
+    def get_component_by_name(self, name):
+        for comp in self.components:
+            if comp.device_name == name:
+                return comp
+

heat_pump.py

@@ -3,15 +3,17 @@ import pandas as pd
 import time
 
 class HeatPump:
-    def __init__(self, ip_address: str):
+    def __init__(self, device_name: str, ip_address: str, port: int=502):
+        self.device_name = device_name
         self.ip = ip_address
+        self.port = port
         self.client = None
         self.connect_to_modbus()
         self.registers = None
         self.get_registers()
 
     def connect_to_modbus(self):
-        port = 502
+        port = self.port
         self.client = ModbusTcpClient(self.ip, port=port)
         try:
             if not self.client.connect():
@@ -25,7 +27,7 @@ class HeatPump:
 
     def get_registers(self):
         # Excel-Datei mit den Input-Registerinformationen
-        excel_path = "data/ModBus TCPIP 1.17(1).xlsx"
+        excel_path = "modbus_registers/heat_pump_registers.xlsx"
         xls = pd.ExcelFile(excel_path)
         df_input_registers = xls.parse('04 Input Register')
 
@@ -42,7 +44,7 @@ class HeatPump:
             for _, row in df_clean.iterrows()
         }
 
-    def get_data(self):
+    def get_state(self):
         data = {}
         data['Zeit'] = time.strftime('%Y-%m-%d %H:%M:%S')
         for address, info in self.registers.items():

main.py

@@ -1,17 +1,40 @@
 import time
 from datetime import datetime
-from data_base_csv import DataBaseCsv
+from data_base_influx import DataBaseInflux
 from heat_pump import HeatPump
+from pv_inverter import PvInverter
+from solaredge_meter import SolaredgeMeter
+from shelly_pro_3m import ShellyPro3m
+from energysystem import EnergySystem
+from sg_ready_controller import SgReadyController
 
-interval = 10  # z.B. alle 10 Sekunden
+# For dev-System run in terminal: ssh -N -L 127.0.0.1:8111:10.0.0.10:502 pi@192.168.1.146
+# For productive-System change IP-adress in heatpump to '10.0.0.10' and port to 502
 
-db = DataBaseCsv('modbus_log.csv')
+interval_seconds = 10
-hp = HeatPump(ip_address='10.0.0.10')
+
+es = EnergySystem()
+
+db = DataBaseInflux(
+    url="http://192.168.1.146:8086",
+    token="Cw_naEZyvJ3isiAh1P4Eq3TsjcHmzzDFS7SlbKDsS6ZWL04fMEYixWqtNxGThDdG27S9aW5g7FP9eiq5z1rsGA==",
+    org="allmende",
+    bucket="allmende_db"
+)
+
+hp = HeatPump(device_name='hp_master', ip_address='10.0.0.10', port=502)
+shelly = ShellyPro3m(device_name='wohnung_2_6', ip_address='192.168.1.121')
+wr = PvInverter(device_name='solaredge_master', ip_address='192.168.1.112')
+meter = SolaredgeMeter(device_name='solaredge_meter', ip_address='192.168.1.112')
+
+es.add_components(hp, shelly, wr, meter)
+controller = SgReadyController(es)
 
 while True:
     now = datetime.now()
-    if now.second % interval == 0 and now.microsecond < 100_000:
+    if now.second % interval_seconds == 0 and now.microsecond < 100_000:
-       db.store_data(hp.get_data())
+       state = es.get_state_and_store_to_database(db)
+       controller.perform_action(heat_pump_name='hp_master', meter_name='solaredge_meter', state=state)
 
     time.sleep(0.1)
 

modbus_registers/.~lock.heat_pump_registers.xlsx#

@@ -0,0 +1 @@
+,nils,nils-ThinkPad-P52,25.09.2025 17:32,file:///home/nils/.config/libreoffice/4;

pv_inverter.py

@@ -0,0 +1,139 @@
+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

requirements.txt

@@ -1,3 +1,4 @@
 pymodbus~=3.8.6
 pandas
 openpyxl
+sshtunnel

sg_ready_controller.py

@@ -0,0 +1,61 @@
+from pymodbus.client import ModbusTcpClient
+
+class SgReadyController():
+    def __init__(self, es):
+        self.es = es
+
+    def perform_action(self, heat_pump_name, meter_name, state):
+        hp = self.es.get_component_by_name(heat_pump_name)
+        meter_values = state[meter_name]
+
+        power_to_grid = meter_values['40206 - M_AC_Power'] * 10 ** meter_values['40210 - M_AC_Power_SF']
+
+        if power_to_grid > 10000:
+            self.switch_sg_ready_mode(hp.ip, hp.port, 'mode2')
+        elif power_to_grid < 0:
+            self.switch_sg_ready_mode(hp.ip, hp.port, 'mode1')
+
+    def switch_sg_ready_mode(self, ip, port, mode):
+        """
+        Register 300: 1=BUS 0= Hardware Kontakte
+        Register 301 & 302:
+            0-0= Kein Offset
+            0-1 Boiler und Heizung Offset
+            1-1 Boiler Offset + E-Einsatz Sollwert Erhöht
+            1-0 SG EVU Sperre
+        :param ip:
+        :param mode:
+        'mode1' = [True, False, False] => SG Ready deactivated
+        'mode2' = [True, False, True] => SG ready activated for heatpump only
+        'mode3' = [True, True, True] => SG ready activated for heatpump and heat rod
+        :return:
+        """
+        client = ModbusTcpClient(ip, port=port)
+        if not client.connect():
+            print("Verbindung zur Wärmepumpe fehlgeschlagen.")
+            return
+
+        mode_code = None
+        if mode == 'mode1':
+            mode_code = [True, False, False]
+        elif mode == 'mode2':
+            mode_code = [True, False, True]
+        elif mode == 'mode3':
+            mode_code = [True, True, True]
+        else:
+            print('Uncorrect or no string for mode!')
+
+        try:
+            response_300 = client.write_coil(300, mode_code[0])
+            response_301 = client.write_coil(301, mode_code[1])
+            response_302 = client.write_coil(302, mode_code[2])
+
+            # Optional: Rückmeldungen prüfen
+            for addr, resp in zip([300, 301, 302], [response_300, response_301, response_302]):
+                if resp.isError():
+                    print(f"Fehler beim Schreiben von Coil {addr}: {resp}")
+                else:
+                    print(f"Coil {addr} erfolgreich geschrieben.")
+
+        finally:
+            client.close()

shelly_pro_3m.py

@@ -0,0 +1,64 @@
+import struct
+
+from pymodbus.client import ModbusTcpClient
+import pandas as pd
+import time
+
+class ShellyPro3m:
+    def __init__(self, device_name: str, ip_address: str, port: int=502):
+        self.device_name = device_name
+        self.ip = ip_address
+        self.port = port
+        self.client = None
+        self.connect_to_modbus()
+        self.registers = None
+        self.get_registers()
+
+    def connect_to_modbus(self):
+        port = self.port
+        self.client = ModbusTcpClient(self.ip, port=port)
+        try:
+            if not self.client.connect():
+                print("Verbindung zum Shelly-Logger fehlgeschlagen.")
+                exit(1)
+            print("Verbindung zum Shelly-Logger erfolgreich.")
+        except KeyboardInterrupt:
+            print("Beendet durch Benutzer (Ctrl+C).")
+        finally:
+            self.client.close()
+
+    def get_registers(self):
+        # Excel-Datei mit den Input-Registerinformationen
+        excel_path = "modbus_registers/shelly_pro_3m_registers.xlsx"
+        xls = pd.ExcelFile(excel_path)
+        df_input_registers = xls.parse()
+
+        # Relevante Spalten bereinigen
+        df_clean = df_input_registers[['MB Adresse', 'Beschreibung', 'Variabel Typ']].dropna()
+        df_clean['MB Adresse'] = df_clean['MB Adresse'].astype(int)
+
+        # Dictionary aus Excel erzeugen
+        self.registers = {
+            row['MB Adresse']: {
+                'desc': row['Beschreibung'],
+                'type': 'REAL' if row['Variabel Typ'] == 'REAL' else 'INT'
+            }
+            for _, row in df_clean.iterrows()
+        }
+
+    def get_state(self):
+        data = {}
+        data['Zeit'] = time.strftime('%Y-%m-%d %H:%M:%S')
+        for address, info in self.registers.items():
+            reg_type = info['type']
+            result = self.client.read_input_registers(address, count=2 if reg_type == 'REAL' else 1)
+            if result.isError():
+                print(f"Fehler beim Lesen von Adresse {address}: {result}")
+                continue
+
+            packed = struct.pack(">HH", result.registers[1], result.registers[0])
+            value = round(struct.unpack(">f", packed)[0], 2)
+
+            print(f"Adresse {address} - {info['desc']}: {value}")
+            data[f"{address} - {info['desc']}"] = value
+        return data

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