Sungrow modbus: reading more / correct adresses to complete counter and inverter values

packages/helpermodules/update_config.py

@@ -38,7 +38,7 @@
 
 
 class UpdateConfig:
-    DATASTORE_VERSION = 43
+    DATASTORE_VERSION = 44
     valid_topic = [
         "^openWB/bat/config/configured$",
         "^openWB/bat/set/charging_power_left$",
@@ -191,9 +191,7 @@ class UpdateConfig:
         "^openWB/general/chargemode_config/pv_charging/phases_to_use$",
         "^openWB/general/chargemode_config/pv_charging/min_bat_soc$",
         "^openWB/general/chargemode_config/pv_charging/bat_power_discharge$",
-        "^openWB/general/chargemode_config/pv_charging/bat_power_discharge_active$",
         "^openWB/general/chargemode_config/pv_charging/bat_power_reserve$",
-        "^openWB/general/chargemode_config/pv_charging/bat_power_reserve_active$",
         "^openWB/general/chargemode_config/retry_failed_phase_switches$",
         "^openWB/general/chargemode_config/scheduled_charging/phases_to_use$",
         "^openWB/general/chargemode_config/instant_charging/phases_to_use$",
@@ -419,10 +417,8 @@ class UpdateConfig:
         ("openWB/general/chargemode_config/instant_charging/phases_to_use", 3),
         ("openWB/general/chargemode_config/pv_charging/bat_mode", BatConsiderationMode.EV_MODE.value),
         ("openWB/general/chargemode_config/pv_charging/bat_power_discharge", 1000),
-        ("openWB/general/chargemode_config/pv_charging/bat_power_discharge_active", False),
         ("openWB/general/chargemode_config/pv_charging/min_bat_soc", 50),
         ("openWB/general/chargemode_config/pv_charging/bat_power_reserve", 200),
-        ("openWB/general/chargemode_config/pv_charging/bat_power_reserve_active", False),
         ("openWB/general/chargemode_config/pv_charging/control_range", [0, 230]),
         ("openWB/general/chargemode_config/pv_charging/switch_off_threshold", 50),
         ("openWB/general/chargemode_config/pv_charging/switch_off_delay", 60),
@@ -1439,3 +1435,41 @@ def upgrade(topic: str, payload) -> Optional[dict]:
                     payload) > 0}
         self._loop_all_received_topics(upgrade)
         self.__update_topic("openWB/system/datastore_version", 43)
+
+    def upgrade_datastore_43(self) -> None:
+        def upgrade(topic: str, payload) -> None:
+            if re.search("openWB/system/device/[0-9]+", topic) is not None:
+                payload = decode_payload(payload)
+                if payload.get("type") == "sungrow" and "version" not in payload["configuration"]:
+                    index = get_index(topic)
+                    version = None
+                    has_battery = False
+                    for other_topic, other_payload in self.all_received_topics.items():
+                        if re.search(f"openWB/system/device/{index}/component", other_topic) is not None:
+                            child_component_payload = decode_payload(other_payload)
+                            if child_component_payload.get("type") == "counter" and "version" in \
+                               child_component_payload["configuration"]:
+                                version = child_component_payload['configuration']['version']
+                                log.debug(f"Version {version} found at counter for sungrow device {index}")
+                            elif child_component_payload.get("type") == "bat":
+                                has_battery = True
+
+                    if has_battery or version == 0:
+                        # Assume an SH_WiNet if hybrid inverter, this is compatible to SH_LAN (but not vice versa)
+                        version = 3
+                    elif not version:
+                        # Assume an SG_WiNet version as default if no battery or version from counter found
+                        version = 2
+                    log.debug(f"Setting version {version} for sungrow device {index}")
+                    payload["configuration"].update({"version": version})
+                    Pub().pub(topic, payload)
+
+                    pub_system_message(payload, "Die Konfiguration von Sungrow Geräten wurde aktualisiert. \
+                        Bitte die Version in den Geräteeinstellungen überprüfen", MessageType.WARNING)
+                    if has_battery:
+                        pub_system_message(payload, "Das Auslesen von Sungrow Hybrid-Wechselrichtern wurde \
+                            aktualisiert. Bitte den Speicher im Lastmanagement innerhalb des zugehörigen \
+                            Hybrid-Wechselrichters anordnen", MessageType.WARNING)
+
+        self._loop_all_received_topics(upgrade)
+        Pub().pub("openWB/system/datastore_version", 44)

packages/modules/devices/sungrow/bat.py

@@ -9,25 +9,23 @@
 from modules.common.modbus import ModbusDataType
 from modules.common.simcount import SimCounter
 from modules.common.store import get_bat_value_store
-from modules.devices.sungrow.config import SungrowBatSetup
+from modules.devices.sungrow.config import SungrowBatSetup, Sungrow
 
 
 class SungrowBat:
     def __init__(self,
-                 device_id: int,
-                 device_modbus_id: int,
+                 device_config: Union[Dict, Sungrow],
                  component_config: Union[Dict, SungrowBatSetup],
                  tcp_client: modbus.ModbusTcpClient_) -> None:
-        self.__device_id = device_id
-        self.__device_modbus_id = device_modbus_id
+        self.device_config = device_config
         self.component_config = dataclass_from_dict(SungrowBatSetup, component_config)
         self.__tcp_client = tcp_client
-        self.sim_counter = SimCounter(self.__device_id, self.component_config.id, prefix="speicher")
+        self.sim_counter = SimCounter(self.device_config.id, self.component_config.id, prefix="speicher")
         self.store = get_bat_value_store(self.component_config.id)
         self.fault_state = FaultState(ComponentInfo.from_component_config(self.component_config))
 
     def update(self) -> None:
-        unit = self.__device_modbus_id
+        unit = self.device_config.configuration.modbus_id
         soc = int(self.__tcp_client.read_input_registers(13022, ModbusDataType.INT_16, unit=unit) / 10)
         resp = self.__tcp_client._delegate.read_input_registers(13000, 1, unit=unit)
         binary = bin(resp.registers[0])[2:].zfill(8)

packages/modules/devices/sungrow/config.py

@@ -1,13 +1,19 @@
 from typing import Optional
 
 from modules.common.component_setup import ComponentSetup
+from modules.devices.sungrow.version import Version
 
 
 class SungrowConfiguration:
-    def __init__(self, ip_address: Optional[str] = None, port: int = 502, modbus_id: int = 1):
+    def __init__(self,
+                 ip_address: Optional[str] = None,
+                 port: int = 502,
+                 modbus_id: int = 1,
+                 version: Version = Version.SG):
         self.ip_address = ip_address
         self.port = port
         self.modbus_id = modbus_id
+        self.version = version
 
 
 class Sungrow:
@@ -37,8 +43,8 @@ def __init__(self,
 
 
 class SungrowCounterConfiguration:
-    def __init__(self, version=1):
-        self.version = version
+    def __init__(self):
+        pass
 
 
 class SungrowCounterSetup(ComponentSetup[SungrowCounterConfiguration]):

packages/modules/devices/sungrow/counter.py

@@ -9,60 +9,67 @@
 from modules.common.modbus import ModbusDataType, Endian
 from modules.common.simcount import SimCounter
 from modules.common.store import get_counter_value_store
-from modules.devices.sungrow.config import SungrowCounterSetup
+from modules.devices.sungrow.config import SungrowCounterSetup, Sungrow
 from modules.devices.sungrow.version import Version
 
 
 class SungrowCounter:
     def __init__(self,
-                 device_id: int,
-                 device_modbus_id: int,
+                 device_config: Union[Dict, Sungrow],
                  component_config: Union[Dict, SungrowCounterSetup],
                  tcp_client: modbus.ModbusTcpClient_) -> None:
-        self.__device_id = device_id
-        self.__device_modbus_id = device_modbus_id
+        self.device_config = device_config
         self.component_config = dataclass_from_dict(SungrowCounterSetup, component_config)
         self.__tcp_client = tcp_client
-        self.sim_counter = SimCounter(self.__device_id, self.component_config.id, prefix="bezug")
+        self.sim_counter = SimCounter(self.device_config.id, self.component_config.id, prefix="bezug")
         self.store = get_counter_value_store(self.component_config.id)
         self.fault_state = FaultState(ComponentInfo.from_component_config(self.component_config))
 
     def update(self, pv_power: float):
-        unit = self.__device_modbus_id
-        if self.component_config.configuration.version == Version.SH:
+        unit = self.device_config.configuration.modbus_id
+        if self.device_config.configuration.version in (Version.SH, Version.SH_winet_dongle):
             power = self.__tcp_client.read_input_registers(13009, ModbusDataType.INT_32,
                                                            wordorder=Endian.Little, unit=unit) * -1
-            # no valid data for powers per phase
-            # powers = self.__tcp_client.read_input_registers(5084, [ModbusDataType.INT_16] * 3,
-            #                                                 wordorder=Endian.Little, unit=unit)
-            # powers = [power / 10 for power in powers]
-            # log.info("power: " + str(power) + " powers?: " + str(powers))
+            powers = self.__tcp_client.read_input_registers(5602, [ModbusDataType.INT_32] * 3,
+                                                            wordorder=Endian.Little, unit=unit)
         else:
             if pv_power != 0:
                 power = self.__tcp_client.read_input_registers(5082, ModbusDataType.INT_32,
                                                                wordorder=Endian.Little, unit=unit)
             else:
                 power = self.__tcp_client.read_input_registers(5090, ModbusDataType.INT_32,
                                                                wordorder=Endian.Little, unit=unit)
+            powers = self.__tcp_client.read_input_registers(5084, [ModbusDataType.INT_32] * 3,
+                                                            wordorder=Endian.Little, unit=unit)
 
-            # no valid data for powers per phase
-            # powers = self.__tcp_client.read_input_registers(5084, [ModbusDataType.UINT_16] * 3,
-            #                                                 wordorder=Endian.Little, unit=unit)
-            # powers = [power / 10 for power in powers]
-            # log.info("power: " + str(power) + " powers?: " + str(powers))
         frequency = self.__tcp_client.read_input_registers(5035, ModbusDataType.UINT_16, unit=unit) / 10
-        voltages = self.__tcp_client.read_input_registers(5018, [ModbusDataType.UINT_16] * 3,
-                                                          wordorder=Endian.Little, unit=unit)
-        voltages = [voltage / 10 for voltage in voltages]
+        if self.device_config.configuration.version == Version.SH_winet_dongle:
+            # On WiNet-S, the frequency accuracy is higher by one place
+            frequency /= 10
+
+        power_factor = self.__tcp_client.read_input_registers(5034, ModbusDataType.INT_16, unit=unit) / 1000
+
+        if self.device_config.configuration.version == Version.SH:
+            # SH (LAN) provides accurate values from meter
+            voltages = self.__tcp_client.read_input_registers(5740, [ModbusDataType.UINT_16] * 3,
+                                                              wordorder=Endian.Little, unit=unit)
+        else:
+            # These are actually output voltages of the inverter:
+            voltages = self.__tcp_client.read_input_registers(5018, [ModbusDataType.UINT_16] * 3,
+                                                              wordorder=Endian.Little, unit=unit)
+
+        voltages = [value / 10 for value in voltages]
 
         imported, exported = self.sim_counter.sim_count(power)
 
         counter_state = CounterState(
             imported=imported,
             exported=exported,
             power=power,
+            powers=powers,
             voltages=voltages,
-            frequency=frequency
+            frequency=frequency,
+            power_factors=[power_factor] * 3
         )
         self.store.set(counter_state)
 

packages/modules/devices/sungrow/device.py

@@ -46,7 +46,7 @@ def add_component(self,
             COMPONENT_TYPE_TO_MODULE[component_type].component_descriptor.configuration_factory, component_config)
         if component_type in self.COMPONENT_TYPE_TO_CLASS:
             self.components["component" + str(component_config.id)] = (self.COMPONENT_TYPE_TO_CLASS[component_type](
-                self.device_config.id, self.device_config.configuration.modbus_id, component_config, self.client))
+                self.device_config, component_config, self.client))
         else:
             raise Exception(
                 "illegal component type " + component_type + ". Allowed values: " +
@@ -84,23 +84,25 @@ def update(self) -> None:
 def read_legacy(ip_address: str,
                 port: int,
                 modbus_id: int,
+                version: int,
                 component_config: dict):
     device_config = Sungrow()
     device_config.configuration.ip_address = ip_address
     device_config.configuration.port = port
     device_config.configuration.modbus_id = modbus_id
+    device_config.configuration.version = Version(version)
     dev = Device(device_config)
     dev.add_component(component_config)
     dev.update()
 
 
-def read_legacy_bat(ip_address: str, port: int, modbus_id: int):
-    read_legacy(ip_address, port, modbus_id, bat.component_descriptor.configuration_factory(id=None))
+def read_legacy_bat(ip_address: str, port: int, modbus_id: int, version: int):
+    read_legacy(ip_address, port, modbus_id, version, bat.component_descriptor.configuration_factory(id=None))
 
 
 def read_legacy_counter(ip_address: str, port: int, modbus_id: int, version: int):
-    read_legacy(ip_address, port, modbus_id, counter.component_descriptor.configuration_factory(
-        id=None, configuration=SungrowCounterConfiguration(version=Version(version))))
+    read_legacy(ip_address, port, modbus_id, version, counter.component_descriptor.configuration_factory(
+        id=None, configuration=SungrowCounterConfiguration()))
 
 
 def read_legacy_inverter(ip_address: str,
@@ -113,11 +115,12 @@ def read_legacy_inverter(ip_address: str,
     device_config.configuration.ip_address = ip_address
     device_config.configuration.port = port
     device_config.configuration.modbus_id = modbus_id
+    device_config.configuration.version = Version(version)
     dev = Device(device_config)
     dev.add_component(inverter.component_descriptor.configuration_factory(id=num))
     if read_counter == 1:
         dev.add_component(counter.component_descriptor.configuration_factory(
-            id=None, configuration=SungrowCounterConfiguration(version=Version(version))))
+            id=None, configuration=SungrowCounterConfiguration()))
     dev.update()
 
 

packages/modules/devices/sungrow/inverter.py

@@ -9,29 +9,31 @@
 from modules.common.modbus import ModbusDataType, Endian
 from modules.common.simcount import SimCounter
 from modules.common.store import get_inverter_value_store
-from modules.devices.sungrow.config import SungrowInverterSetup
+from modules.devices.sungrow.config import SungrowInverterSetup, Sungrow
+from modules.devices.sungrow.version import Version
 
 
 class SungrowInverter:
     def __init__(self,
-                 device_id: int,
-                 device_modbus_id: int,
+                 device_config: Union[Dict, Sungrow],
                  component_config: Union[Dict, SungrowInverterSetup],
                  tcp_client: modbus.ModbusTcpClient_) -> None:
-        self.__device_id = device_id
-        self.__device_modbus_id = device_modbus_id
+        self.device_config = device_config
         self.component_config = dataclass_from_dict(SungrowInverterSetup, component_config)
         self.__tcp_client = tcp_client
-        self.sim_counter = SimCounter(self.__device_id, self.component_config.id, prefix="pv")
+        self.sim_counter = SimCounter(self.device_config.id, self.component_config.id, prefix="pv")
         self.store = get_inverter_value_store(self.component_config.id)
         self.fault_state = FaultState(ComponentInfo.from_component_config(self.component_config))
 
     def update(self) -> float:
-        unit = self.__device_modbus_id
-        power = self.__tcp_client.read_input_registers(5016,
-                                                       ModbusDataType.UINT_32,
-                                                       wordorder=Endian.Little,
-                                                       unit=unit) * -1
+        unit = self.device_config.configuration.modbus_id
+
+        if self.device_config.configuration.version in (Version.SH, Version.SH_winet_dongle):
+            power = self.__tcp_client.read_input_registers(13033, ModbusDataType.INT_32,
+                                                           wordorder=Endian.Little, unit=unit) * -1
+        else:
+            power = self.__tcp_client.read_input_registers(5030, ModbusDataType.INT_32,
+                                                           wordorder=Endian.Little, unit=unit) * -1
 
         _, exported = self.sim_counter.sim_count(power)