Adapt library to pymodbus 3.10.0 (#8)

Djcd · web-flow · commit 9fe770324dd4 · 2025-08-09T12:25:44.000+02:00
diff --git a/example.py b/example.py
@@ -5,7 +5,7 @@
 
 host_ip = "192.168.1.20"
 host_port = 502
-slave = 1
+device_id = 1
 
 def test_function(mod, fun):
     """Executes the given function on the Stiebel Heatpump and prints the result."""
@@ -45,7 +45,7 @@ def main():
                           timeout=2)
     client.connect()
 
-    unit = pyse.StiebelEltronAPI(client, slave)
+    unit = pyse.StiebelEltronAPI(client, device_id)
     unit.update()
 
     execute_tests(unit)
diff --git a/pyproject.toml b/pyproject.toml
@@ -16,7 +16,7 @@ classifiers = [
 ]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "pymodbus (>=3.8.3,<3.10)",
+    "pymodbus (>=3.10.0,<4)",
 ]
 
 [build-system]
diff --git a/pystiebeleltron/__init__.py b/pystiebeleltron/__init__.py
@@ -139,7 +139,7 @@ async def get_controller_model(host, port) -> ControllerModel:
         inverter_data = await client.read_input_registers(
             address=5001,
             count=1,
-            slave=1,
+            device_id=1,
         )
         if not inverter_data.isError():
             value = client.convert_from_registers(inverter_data.registers, client.DATATYPE.UINT16)
@@ -159,10 +159,10 @@ def __init__(
         register_blocks: list[ModbusRegisterBlock],
         host: str,
         port: int = 502,
-        slave: int = 1,
+        device_id: int = 1,
     ) -> None:
         """Initialize Stiebel Eltron communication."""
-        self._slave = slave
+        self._device_id = device_id
         self._lock = asyncio.Lock()
         self._host = host
         self._client: AsyncModbusTcpClient = AsyncModbusTcpClient(host=host, port=port)
@@ -220,21 +220,21 @@ async def write_register_value(self, register: IsgRegisters, value: int | float)
         descriptor = self.get_register_descriptor(register)
         if descriptor is not None:
             async with self._lock:
-                await self._client.write_register(descriptor.address - 1, value=self.convert_value_to_modbus(value, descriptor), slave=1)
+                await self._client.write_register(descriptor.address - 1, value=self.convert_value_to_modbus(value, descriptor), device_id=1)
         else:
             raise ValueError("invalid register")
 
-    async def read_input_registers(self, slave, address, count):
+    async def read_input_registers(self, device_id, address, count):
         """Read input registers."""
-        _LOGGER.debug(f"Reading {count} input registers from {address} with slave {slave}")
+        _LOGGER.debug(f"Reading {count} input registers from {address} with device_id {device_id}")
         async with self._lock:
-            return await self._client.read_input_registers(address, count=count, slave=slave)
+            return await self._client.read_input_registers(address, count=count, device_id=device_id)
 
-    async def read_holding_registers(self, slave, address, count):
+    async def read_holding_registers(self, device_id, address, count):
         """Read holding registers."""
-        _LOGGER.debug(f"Reading {count} holding registers from {address} with slave {slave}")
+        _LOGGER.debug(f"Reading {count} holding registers from {address} with device_id {device_id}")
         async with self._lock:
-            return await self._client.read_holding_registers(address, count=count, slave=slave)
+            return await self._client.read_holding_registers(address, count=count, device_id=device_id)
 
     def convert_value_from_modbus(self, register, register_description: ModbusRegister) -> float | int | None:
         """Convert a modbus value to a python value."""
@@ -288,13 +288,13 @@ async def async_update(self):
             heat_pump_data = None
             if registerblock.register_type == RegisterType.INPUT_REGISTER:
                 heat_pump_data = await self.read_input_registers(
-                    slave=self._slave,
+                    device_id=self._device_id,
                     address=registerblock.base_address,
                     count=registerblock.count,
                 )
             elif registerblock.register_type == RegisterType.HOLDING_REGISTER:
                 heat_pump_data = await self.read_holding_registers(
-                    slave=self._slave,
+                    device_id=self._device_id,
                     address=registerblock.base_address,
                     count=registerblock.count,
                 )
diff --git a/pystiebeleltron/lwz.py b/pystiebeleltron/lwz.py
@@ -349,7 +349,7 @@ class OperatingMode(Enum):
 
 
 class LwzStiebelEltronAPI(StiebelEltronAPI):
-    def __init__(self, host: str, port: int = 502, slave: int = 1) -> None:
+    def __init__(self, host: str, port: int = 502, device_id: int = 1) -> None:
         super().__init__(
             [
                 ModbusRegisterBlock(base_address=0, count=34, name="System Values", registers=LWZ_SYSTEM_VALUES_REGISTERS, register_type=RegisterType.INPUT_REGISTER),
@@ -361,7 +361,7 @@ def __init__(self, host: str, port: int = 502, slave: int = 1) -> None:
             ],
             host,
             port,
-            slave,
+            device_id,
         )
 
     async def async_update(self):
diff --git a/pystiebeleltron/pystiebeleltron.py b/pystiebeleltron/pystiebeleltron.py
@@ -156,22 +156,23 @@
 class StiebelEltronAPI:
     """Stiebel Eltron API."""
 
-    def __init__(self, conn: ModbusClientMixin, slave=1, update_on_read=False):
+    def __init__(self, conn: ModbusClientMixin, device_id=1, update_on_read=False):
         """Initialize Stiebel Eltron communication."""
         self._conn = conn
         self._block_1_input_regs = B1_REGMAP_INPUT
         self._block_2_holding_regs = B2_REGMAP_HOLDING
         self._block_3_input_regs = B3_REGMAP_INPUT
-        self._slave = slave
+        self._device_id = device_id
         self._update_on_read = update_on_read
 
     def update(self):
         """Request current values from heat pump."""
         ret = True
         try:
-            block_1_result_input = self._conn.read_input_registers(slave=self._slave, address=B1_START_ADDR, count=len(self._block_1_input_regs)).registers
-            block_2_result_holding = self._conn.read_holding_registers(slave=self._slave, address=B2_START_ADDR, count=len(self._block_2_holding_regs)).registers
-            block_3_result_input = self._conn.read_input_registers(slave=self._slave, address=B3_START_ADDR, count=len(self._block_3_input_regs)).registers
+            block_1_result_input = self._conn.read_input_registers(device_id=self._device_id, address=B1_START_ADDR, count=len(self._block_1_input_regs)).registers
+            block_2_result_holding = self._conn.read_holding_registers(device_id=self._device_id, address=B2_START_ADDR, count=len(self._block_2_holding_regs)).registers
+            block_3_result_input = self._conn.read_input_registers(device_id=self._device_id, address=B3_START_ADDR, count=len(self._block_3_input_regs)).registers
+
         except AttributeError:
             # The unit does not reply reliably
             ret = False
@@ -224,12 +225,13 @@ def get_conv_val(self, name: str):
     #            self.update()
     #        return self._block_2_holding_regs[name]
 
-    #    def set_raw_holding_register(self, name, value):
-    #        """Write to register by name."""
-    #        self._conn.write_register(
-    #            slave=self._slave,
-    #            address=(self._holding_regs[name]['addr']),
-    #            value=value)
+#    def set_raw_holding_register(self, name, value):
+#        """Write to register by name."""
+#        self._conn.write_register(
+#            device_id=self._device_id,
+#            address=(self._holding_regs[name]['addr']),
+#            value=value)
+
 
     # Handle room temperature & humidity
 
@@ -247,7 +249,8 @@ def get_target_temp(self):
 
     def set_target_temp(self, temp: float):
         """Set the target room temperature (day)(HC1)."""
-        self._conn.write_register(slave=self._slave, address=(self._block_2_holding_regs["ROOM_TEMP_HEAT_DAY_HC1"]["addr"]), value=round(temp * 10.0))
+        self._conn.write_register(device_id=self._device_id, address=(self._block_2_holding_regs["ROOM_TEMP_HEAT_DAY_HC1"]["addr"]), value=round(temp * 10.0))
+
 
     def get_current_humidity(self):
         """Get the current room humidity."""
@@ -267,7 +270,7 @@ def get_operation(self):
 
     def set_operation(self, mode: str):
         """Set the operation mode."""
-        self._conn.write_register(slave=self._slave, address=(self._block_2_holding_regs["OPERATING_MODE"]["addr"]), value=B2_OPERATING_MODE_WRITE.get(mode))
+        self._conn.write_register(device_id=self._device_id, address=(self._block_2_holding_regs["OPERATING_MODE"]["addr"]), value=B2_OPERATING_MODE_WRITE.get(mode))
 
     # Handle device status
 
diff --git a/pystiebeleltron/wpm.py b/pystiebeleltron/wpm.py
@@ -874,7 +874,7 @@ class WpmEnergyDataRegisters(IsgRegisters):
 
 
 class WpmStiebelEltronAPI(StiebelEltronAPI):
-    def __init__(self, host: str, port: int = 502, slave: int = 1) -> None:
+    def __init__(self, host: str, port: int = 502, device_id: int = 1) -> None:
         super().__init__(
             [
                 ModbusRegisterBlock(base_address=500, count=110, name="System Values", registers=WPM_SYSTEM_VALUES_REGISTERS, register_type=RegisterType.INPUT_REGISTER),
@@ -886,7 +886,7 @@ def __init__(self, host: str, port: int = 502, slave: int = 1) -> None:
             ],
             host,
             port,
-            slave,
+            device_id,
         )
 
     async def async_update(self):
diff --git a/scripts/templates/lwztemplate.j2 b/scripts/templates/lwztemplate.j2
@@ -42,14 +42,14 @@ class OperatingMode(Enum):
 
 class {{heatpump_type}}StiebelEltronAPI(StiebelEltronAPI):
 
-    def __init__(self, host: str, port: int = 502, slave: int = 1) -> None:
+    def __init__(self, host: str, port: int = 502, device_id: int = 1) -> None:
         super().__init__([
             {% for registerblock in registers %}
                 ModbusRegisterBlock(base_address={{registerblock["base_address"]}}, count={{registerblock["count"]}}, name="{{registerblock["name"]}}", registers={{heatpump_type.upper()}}_{{python_name(registerblock["name"]).upper()}}_REGISTERS, register_type={{registerblock["register_type"]}}),{% endfor %}
                 ModbusRegisterBlock(base_address=4000, count=3, name="Energy Management Settings", registers=ENERGY_MANAGEMENT_SETTINGS_REGISTERS, register_type=RegisterType.HOLDING_REGISTER),
                 ModbusRegisterBlock(base_address=5000, count=2, name="Energy System Information", registers=ENERGY_SYSTEM_INFORMATION_REGISTERS, register_type=RegisterType.INPUT_REGISTER),
             ],
-            host, port, slave)
+            host, port, device_id)
 
     async def async_update(self):
         """Request current values from heat pump."""
diff --git a/scripts/templates/wpmtemplate.j2 b/scripts/templates/wpmtemplate.j2
@@ -21,14 +21,14 @@ class {{heatpump_type}}{{python_class_name(registerblock["name"])}}Registers(Isg
 
 class {{heatpump_type}}StiebelEltronAPI(StiebelEltronAPI):
 
-    def __init__(self, host: str, port: int = 502, slave: int = 1) -> None:
+    def __init__(self, host: str, port: int = 502, device_id: int = 1) -> None:
         super().__init__([
             {% for registerblock in registers %}
                 ModbusRegisterBlock(base_address={{registerblock["base_address"]}}, count={{registerblock["count"]}}, name="{{registerblock["name"]}}", registers={{heatpump_type.upper()}}_{{python_name(registerblock["name"]).upper()}}_REGISTERS, register_type={{registerblock["register_type"]}}),{% endfor %}
                 ModbusRegisterBlock(base_address=4000, count=3, name="Energy Management Settings", registers=ENERGY_MANAGEMENT_SETTINGS_REGISTERS, register_type=RegisterType.HOLDING_REGISTER),
                 ModbusRegisterBlock(base_address=5000, count=2, name="Energy System Information", registers=ENERGY_SYSTEM_INFORMATION_REGISTERS, register_type=RegisterType.INPUT_REGISTER),
             ],
-            host, port, slave)
+            host, port, device_id)
 
     async def async_update(self):
         """Request current values from heat pump."""
diff --git a/test/mock_modbus_server.py b/test/mock_modbus_server.py
@@ -12,9 +12,9 @@
 # --------------------------------------------------------------------------- #
 from pymodbus.server import StartTcpServer, ServerStop
 
-from pymodbus.device import ModbusDeviceIdentification
+from pymodbus.pdu.device import ModbusDeviceIdentification
 from pymodbus.datastore import ModbusSequentialDataBlock
-from pymodbus.datastore import ModbusSlaveContext, ModbusServerContext
+from pymodbus.datastore import ModbusDeviceContext, ModbusServerContext
 
 
 class MockModbusServer(object):
@@ -51,42 +51,42 @@ def run_async_server(self):
         # or simply do not pass them to have them initialized to 0x00 on the full
         # address range::
         #
-        #     store = ModbusSlaveContext(di = ModbusSequentialDataBlock.create())
-        #     store = ModbusSlaveContext()
+        #     store = ModbusDeviceContext(di = ModbusSequentialDataBlock.create())
+        #     store = ModbusDeviceContext()
         #
         # Finally, you are allowed to use the same DataBlock reference for every
         # table or you you may use a seperate DataBlock for each table.
         # This depends if you would like functions to be able to access and modify
         # the same data or not::
         #
         #     block = ModbusSequentialDataBlock(0x00, [0]*0xff)
-        #     store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block)
+        #     store = ModbusDeviceContext(di=block, co=block, hr=block, ir=block)
         #
         # The server then makes use of a server context that allows the server to
-        # respond with different slave contexts for different unit ids. By default
+        # respond with different device_id contexts for different unit ids. By default
         # it will return the same context for every unit id supplied (broadcast
         # mode).
         # However, this can be overloaded by setting the single flag to False
         # and then supplying a dictionary of unit id to context mapping::
         #
-        #     slaves  = {
-        #         0x01: ModbusSlaveContext(...),
-        #         0x02: ModbusSlaveContext(...),
-        #         0x03: ModbusSlaveContext(...),
+        #     device_ids  = {
+        #         0x01: ModbusDeviceContext(...),
+        #         0x02: ModbusDeviceContext(...),
+        #         0x03: ModbusDeviceContext(...),
         #     }
-        #     context = ModbusServerContext(slaves=slaves, single=False)
+        #     context = ModbusServerContext(device_ids=device_ids, single=False)
         #
-        # The slave context can also be initialized in zero_mode which means that a
+        # The device_id context can also be initialized in zero_mode which means that a
         # request to address(0-7) will map to the address (0-7). The default is
         # False which is based on section 4.4 of the specification, so address(0-7)
         # will map to (1-8)::
         #
-        #     store = ModbusSlaveContext(..., zero_mode=True)
+        #     store = ModbusDeviceContext(..., zero_mode=True)
         # ----------------------------------------------------------------------- #
-        store = ModbusSlaveContext(
+        store = ModbusDeviceContext(
             hr=ModbusSequentialDataBlock(0, [0]*3000),
             ir=ModbusSequentialDataBlock(0, [0]*3000))
-        self.context = ModbusServerContext(slaves=store, single=True)
+        self.context = ModbusServerContext(devices=store, single=True)
 
         # ----------------------------------------------------------------------- #
         # initialize the server information
@@ -122,12 +122,12 @@ def update_context(self, register, address, values):
         :param values: List of values
         """
         assert register == 3 or register == 4
-        slave_id = 0x00
-        old_values = self.context[slave_id].getValues(register,
+        device_id = 0x00
+        old_values = self.context[device_id].getValues(register,
                                                       address, count=1)
         self.log.debug("Change value at address {} from {} to {}".format(
             address, old_values, values))
-        self.context[slave_id].setValues(register, address, values)
+        self.context[device_id].setValues(register, address, values)
 
     def update_holding_register(self, address, value):
         """ Update value of a holding register.
diff --git a/test/test_pystiebeleltron.py b/test/test_pystiebeleltron.py
@@ -14,7 +14,7 @@
 # Modbus server connection details
 host_ip = "127.0.0.1" #"192.168.1.20"
 host_port = 5020 #502
-slave = 1
+device_id = 1
 
 
 class TestStiebelEltronApi:
@@ -49,7 +49,7 @@ def fin():
     def pyse_api(self, request, pymb_s):
         # parameter pymb_s leads to call of fixture
         mb_c = ModbusClient(host=host_ip, port=host_port, timeout=2)
-        api = pyse.StiebelEltronAPI(mb_c, slave, update_on_read=True)
+        api = pyse.StiebelEltronAPI(mb_c, device_id, update_on_read=True)
 
         # Cleanup after last test (will run as well, if setup fails).
         def fin():
diff --git a/test/test_stiebel_eltron.py b/test/test_stiebel_eltron.py
@@ -6,7 +6,7 @@
 )
 
 
-async def read_registers(client, address: int, *, count: int = 1, slave: int = 0, no_response_expected: bool = False) -> ReadInputRegistersResponse:
+async def read_registers(client, address: int, *, count: int = 1, device_id: int = 0, no_response_expected: bool = False) -> ReadInputRegistersResponse:
     """Read a slice from the input register."""
     return ReadInputRegistersResponse(address=address, count=count, registers=list(range(count)))
 
diff --git a/uv.lock b/uv.lock

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ classifiers = [`
`16`	`16`	`]`
`17`	`17`	`requires-python = ">=3.10,<3.14"`
`18`	`18`	`dependencies = [`
`19`		`- "pymodbus (>=3.8.3,<3.10)",`
	`19`	`+ "pymodbus (>=3.10.0,<4)",`
`20`	`20`	`]`
`21`	`21`
`22`	`22`	`[build-system]`
Original file line number	Diff line number	Diff line change
`@@ -349,7 +349,7 @@ class OperatingMode(Enum):`
`349`	`349`
`350`	`350`
`351`	`351`	`class LwzStiebelEltronAPI(StiebelEltronAPI):`
`352`		`- def __init__(self, host: str, port: int = 502, slave: int = 1) -> None:`
	`352`	`+ def __init__(self, host: str, port: int = 502, device_id: int = 1) -> None:`
`353`	`353`	`super().__init__(`
`354`	`354`	`[`
`355`	`355`	`ModbusRegisterBlock(base_address=0, count=34, name="System Values", registers=LWZ_SYSTEM_VALUES_REGISTERS, register_type=RegisterType.INPUT_REGISTER),`
`@@ -361,7 +361,7 @@ def __init__(self, host: str, port: int = 502, slave: int = 1) -> None:`
`361`	`361`	`],`
`362`	`362`	`host,`
`363`	`363`	`port,`
`364`		`- slave,`
	`364`	`+ device_id,`
`365`	`365`	`)`
`366`	`366`
`367`	`367`	`async def async_update(self):`
Original file line number	Diff line number	Diff line change
`@@ -874,7 +874,7 @@ class WpmEnergyDataRegisters(IsgRegisters):`
`874`	`874`
`875`	`875`
`876`	`876`	`class WpmStiebelEltronAPI(StiebelEltronAPI):`
`877`		`- def __init__(self, host: str, port: int = 502, slave: int = 1) -> None:`
	`877`	`+ def __init__(self, host: str, port: int = 502, device_id: int = 1) -> None:`
`878`	`878`	`super().__init__(`
`879`	`879`	`[`
`880`	`880`	`ModbusRegisterBlock(base_address=500, count=110, name="System Values", registers=WPM_SYSTEM_VALUES_REGISTERS, register_type=RegisterType.INPUT_REGISTER),`
`@@ -886,7 +886,7 @@ def __init__(self, host: str, port: int = 502, slave: int = 1) -> None:`
`886`	`886`	`],`
`887`	`887`	`host,`
`888`	`888`	`port,`
`889`		`- slave,`
	`889`	`+ device_id,`
`890`	`890`	`)`
`891`	`891`
`892`	`892`	`async def async_update(self):`