v.1.1.8 (#194)

* Start of miggration to pymodbus 3.11.1

* modbus.py: Replace pymodbus.payload

* modbus.py: Remove comment about BOM in _encode_value

* Remove unused import of Endian from pymodbus.constants

* Implement pymodbus version compatibility handling and update method calls to use 'device_id' for version 3.10+

* Refactor power calculation logic in SigenergyCalculations class to streamline input validation and remove unused variables

* Bump version to 1.1.8 in manifest.json

---------

Co-authored-by: Sam Reed <[email protected]>

Author: TypQxQ

custom_components/sigen/calculated_sensor.py

@@ -331,82 +331,40 @@ def calculate_plant_consumed_power(
 
         total_ac_charger_power = 0.0
         ac_chargers: dict[str, Any] = coordinator_data.get("ac_chargers", {})
-        # _LOGGER.debug("AC Chargers data: %s", ac_chargers)
         for _, ac_charger_data in ac_chargers.items():
             ac_power = safe_float(ac_charger_data.get("ac_charger_charging_power"))
             if ac_power is not None:
                 total_ac_charger_power += ac_power
 
-        total_dc_charger_power = 0.0
-        dc_chargers: dict[str, Any] = coordinator_data.get("dc_chargers", {})
-        # _LOGGER.debug("DC Chargers data: %s", dc_chargers)
-        for _, dc_charger_data in dc_chargers.items():
-            dc_power = safe_float(dc_charger_data.get("dc_charger_output_power"))
-            if dc_power is not None:
-                total_dc_charger_power += dc_power
-
-        # Use the correct calculation for total PV power
-        pv_power = SigenergyCalculations.calculate_total_pv_power(
-            None, coordinator_data=coordinator_data
-        )
-
+        plant_power = plant_data.get("plant_active_power")
         grid_power = plant_data.get("plant_grid_sensor_active_power")
-
-        # Get battery power
-        battery_power = plant_data.get("plant_ess_power")
+        third_party_pv_power = plant_data.get("plant_third_party_photovoltaic_power")
 
         # Validate inputs
-        if pv_power is None or grid_power is None or battery_power is None:
+        if plant_power is None or grid_power is None or third_party_pv_power is None:
             return None
 
         # Validate input types
-        if not isinstance(pv_power, (int, float)):
-            _LOGGER.warning(
-                "[CS][Plant Consumed] PV power is not a number: %s (type: %s)",
-                pv_power,
-                type(pv_power).__name__,
-            )
-            return None
-        if not isinstance(grid_power, (int, float)):
-            _LOGGER.warning(
-                "[CS][Plant Consumed] Grid power is not a number: %s (type: %s)",
-                grid_power,
-                type(grid_power).__name__,
-            )
-            return None
-        if not isinstance(battery_power, (int, float)):
-            _LOGGER.warning(
-                "[CS][Plant Consumed] Battery power is not a number: %s (type: %s)",
-                battery_power,
-                type(battery_power).__name__,
-            )
-            return None
+        def are_numbers(*values):
+            for x in values:
+                if not isinstance(x, (int, float)):
+                    try:
+                        float(x)
+                    except (ValueError, TypeError):
+                        _LOGGER.warning(
+                            "[CS][Plant Consumed] Value is not a number: %s (type: %s)",
+                            x,
+                            type(x).__name__,
+                        )
+                        return False
+            return True
 
-        # Calculate grid import and export power
-        # Grid power is positive when importing, negative when exporting
-        grid_import = max(0, grid_power)
-        grid_export = max(0, -grid_power)
+        if not are_numbers(grid_power, plant_power, third_party_pv_power):
+            return None
 
         # Calculate plant consumed power
-        # Note: battery_power is positive when charging, negative when discharging
         try:
-            # The household consumption should include the power used by the EV chargers.
-            # The chargers are loads within the household.
-            consumed_power = pv_power + grid_import - grid_export - battery_power
-
-            # Sanity check
-            if consumed_power < 0:
-                _LOGGER.debug(
-                    "[CS][Plant Consumed] Calculated power is negative.\n" \
-                    "consumed_power = pv_power + grid_import - grid_export - battery_power:\n" \
-                    "%s kW = %s + %s - %s - %s",
-                    consumed_power,
-                    pv_power,
-                    grid_import,
-                    grid_export,
-                    battery_power
-                )
-                # Keep the negative value as it might be valid in some scenarios
+            consumed_power = max(0, float(plant_power) + float(grid_power) + float(third_party_pv_power) - total_ac_charger_power)
 
         except Exception as ex:  # pylint: disable=broad-exception-caught
             _LOGGER.error(

custom_components/sigen/manifest.json

@@ -21,5 +21,5 @@
   "loggers": ["custom_components.sigen"],
   "quality_scale": "custom",
   "requirements": ["pymodbus>=3.8.3"],
-  "version": "1.1.7"
+  "version": "1.1.8"
 }

custom_components/sigen/modbus.py

@@ -12,9 +12,7 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from pymodbus.client import AsyncModbusTcpClient
-from pymodbus.constants import Endian
 from pymodbus.exceptions import ConnectionException, ModbusException
-from pymodbus.payload import BinaryPayloadBuilder
 from pymodbus.client.mixin import ModbusClientMixin
 from pymodbus import __version__ as pymodbus_version
 
@@ -43,15 +41,91 @@
     DC_CHARGER_RUNNING_INFO_REGISTERS,
     DC_CHARGER_PARAMETER_REGISTERS,
 )
-from homeassistant.helpers.entity_registry import async_get as async_get_entity_registry
-from .common import generate_device_id
-from .const import DOMAIN
-from homeassistant.helpers.entity_registry import async_get as async_get_entity_registry
-from .common import generate_device_id
-from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
+# Pymodbus version compatibility handling
+def _get_pymodbus_version_info():
+    """Get pymodbus version information for compatibility handling."""
+    try:
+        # Parse version string like "3.6.8" or "3.10.0"
+        version_parts = pymodbus_version.split('.')
+        major = int(version_parts[0])
+        minor = int(version_parts[1])
+        return major, minor
+    except (ValueError, IndexError):
+        # Fallback to assuming older version if parsing fails
+        _LOGGER.warning("Could not parse pymodbus version '%s', assuming < 3.10", pymodbus_version)
+        return 3, 0
+
+# Check if we need to use 'device_id' instead of 'slave'
+_PYMODBUS_MAJOR, _PYMODBUS_MINOR = _get_pymodbus_version_info()
+_USE_DEVICE_ID = (_PYMODBUS_MAJOR > 3) or (_PYMODBUS_MAJOR == 3 and _PYMODBUS_MINOR >= 10)
+
+def _call_modbus_method_safe(client_method, *args, **kwargs):
+    """
+    Call a pymodbus client method with version-compatible parameter handling.
+
+    This function handles the parameter name change from 'slave' to 'device_id'
+    that occurred in pymodbus 3.10+.
+
+    Args:
+        client_method: The pymodbus client method to call
+        *args: Positional arguments
+        **kwargs: Keyword arguments, including 'slave' or 'device_id'
+
+    Returns:
+        The result of the client method call
+
+    Raises:
+        TypeError: If the method call fails due to parameter incompatibility
+        Other exceptions from the underlying method
+    """
+    if _USE_DEVICE_ID:
+        # For pymodbus >= 3.10, use 'device_id' parameter
+        if 'slave' in kwargs:
+            kwargs['device_id'] = kwargs.pop('slave')
+
+        try:
+            return client_method(*args, **kwargs)
+        except TypeError as e:
+            if 'device_id' in str(e):
+                # If device_id also fails, try falling back to positional args
+                _LOGGER.debug("device_id parameter failed, trying positional arguments")
+                # Remove device_id and try with positional args if possible
+                kwargs_copy = kwargs.copy()
+                if 'device_id' in kwargs_copy:
+                    device_id = kwargs_copy.pop('device_id')
+                    # Try calling with device_id as positional argument
+                    try:
+                        return client_method(*args, device_id, **kwargs_copy)
+                    except TypeError as inner_e:
+                        # If positional also fails, re-raise original error
+                        raise e from inner_e
+                else:
+                    raise e
+            else:
+                raise e
+    else:
+        # For pymodbus < 3.10, use 'slave' parameter
+        try:
+            return client_method(*args, **kwargs)
+        except TypeError as e:
+            if 'slave' in str(e):
+                # If slave fails, try falling back to positional args
+                _LOGGER.debug("slave parameter failed, trying positional arguments")
+                kwargs_copy = kwargs.copy()
+                if 'slave' in kwargs_copy:
+                    slave = kwargs_copy.pop('slave')
+                    try:
+                        return client_method(*args, slave, **kwargs_copy)
+                    except TypeError as inner_e:
+                        raise e from inner_e
+                else:
+                    raise e
+            else:
+                raise e
+
 @dataclass
 class ModbusConnectionConfig:
     """Configuration for a Modbus connection."""
@@ -295,13 +369,15 @@ async def _probe_single_register(
 
         with _suppress_pymodbus_logging(really_suppress= False if _LOGGER.isEnabledFor(logging.DEBUG) else True):
             if register.register_type == RegisterType.READ_ONLY:
-                result = await client.read_input_registers(
+                result = await _call_modbus_method_safe(
+                    client.read_input_registers,
                     address=register.address,
                     count=register.count,
                     slave=slave_id
                 )
             elif register.register_type == RegisterType.HOLDING:
-                result = await client.read_holding_registers(
+                result = await _call_modbus_method_safe(
+                    client.read_holding_registers,
                     address=register.address,
                     count=register.count,
                     slave=slave_id
@@ -365,7 +441,6 @@ async def async_probe_registers(
             _LOGGER.debug("No registers need probing for %s.", device_info_log)
             # If no probing is needed, still generate intervals from already known registers
             # This handles the case where probing was already done in a previous run.
-            pass
         else:
             _LOGGER.debug("Probing %d registers concurrently for %s...", len(tasks), device_info_log)
 
@@ -503,10 +578,8 @@ async def async_read_registers(
 
             async with self._locks[key]:
                 with _suppress_pymodbus_logging(really_suppress= False if _LOGGER.isEnabledFor(logging.DEBUG) else True):
-                    result = await client.read_input_registers(
-                        address=address, count=count, slave=slave_id
-                    ) if register_type == RegisterType.READ_ONLY \
-                        else await client.read_holding_registers(
+                    result = await _call_modbus_method_safe(
+                        client.read_input_registers if register_type == RegisterType.READ_ONLY else client.read_holding_registers,
                         address=address, count=count, slave=slave_id
                     )
 
@@ -592,13 +665,15 @@ async def async_write_register(
                             )
 
                             if approach["function"] == "write_registers":
-                                result = await client.write_registers(
+                                result = await _call_modbus_method_safe(
+                                    client.write_registers,
                                     address=approach["address"],
                                     values=approach["values"],
                                     slave=slave_id
                                 )
                             else:  # write_register
-                                result = await client.write_register(
+                                result = await _call_modbus_method_safe(
+                                    client.write_register,
                                     address=approach["address"],
                                     value=approach["value"],
                                     slave=slave_id
@@ -753,36 +828,43 @@ def _encode_value(
     ) -> List[int]:
         """Encode value to register values based on data type."""
         # For simple U16 values like 0 or 1, just return the value directly
-        # This bypasses potential byte order issues with the BinaryPayloadBuilder
         if data_type == DataType.U16 and isinstance(value, int) and 0 <= value <= 255:
             _LOGGER.debug("Using direct value encoding for simple U16 value: %s", value)
             return [value]
 
-        # For other cases, use the BinaryPayloadBuilder
-        builder = BinaryPayloadBuilder(byteorder=Endian.BIG, wordorder=Endian.BIG)
-
         # Apply gain for numeric values
         if isinstance(value, (int, float)) and gain != 1 and data_type != DataType.STRING:
             value = int(value * gain)
 
         _LOGGER.debug("Encoding value %s with data_type %s", value, data_type)
 
         if data_type == DataType.U16:
-            builder.add_16bit_uint(int(value))
+            registers = ModbusClientMixin.convert_to_registers(
+                value, data_type=ModbusClientMixin.DATATYPE.UINT16
+            )
         elif data_type == DataType.S16:
-            builder.add_16bit_int(int(value))
+            registers = ModbusClientMixin.convert_to_registers(
+                value, data_type=ModbusClientMixin.DATATYPE.INT16
+            )
         elif data_type == DataType.U32:
-            builder.add_32bit_uint(int(value))
+            registers = ModbusClientMixin.convert_to_registers(
+                value, data_type=ModbusClientMixin.DATATYPE.UINT32
+            )
         elif data_type == DataType.S32:
-            builder.add_32bit_int(int(value))
+            registers = ModbusClientMixin.convert_to_registers(
+                value, data_type=ModbusClientMixin.DATATYPE.INT32
+            )
         elif data_type == DataType.U64:
-            builder.add_64bit_uint(int(value))
+            registers = ModbusClientMixin.convert_to_registers(
+                value, data_type=ModbusClientMixin.DATATYPE.UINT64
+            )
         elif data_type == DataType.STRING:
-            builder.add_string(str(value))
+            registers = ModbusClientMixin.convert_to_registers(
+                str(value), data_type=ModbusClientMixin.DATATYPE.STRING
+            )
         else:
             raise SigenergyModbusError(f"Unsupported data type: {data_type}")
 
-        registers = builder.to_registers()
         _LOGGER.debug("Encoded registers: %s", registers)
         return registers
 
@@ -1203,4 +1285,4 @@ async def async_write_parameter(
         except SigenergyModbusError as ex:
             _LOGGER.error("Failed to write %s parameter '%s' (device: %s): %s",
                           device_type, register_name, device_identifier or 'plant', ex)
-            raise # Re-raise the specific error
+            raise # Re-raise the specific error