Fix #673

Author: pkubanek

pymodbus/client/mixin.py

@@ -157,11 +157,12 @@ def write_registers(self, address, values, **kwargs):
         request = WriteMultipleRegistersRequest(address, values, **kwargs)
         return self.execute(request)  # pylint: disable=no-member
 
-    def read_holding_registers(self, address, count=1, **kwargs):
+    def read_holding_registers(self, address, count=1, unit=0, **kwargs):
         """Read holding registers.
 
         :param address: The starting address to read from
         :param count: The number of registers to read
+        :param unit: Modbus slave unit ID
         :param kwargs:
         :returns: A deferred response handle
         """

pymodbus/pdu.py

@@ -30,7 +30,7 @@ class ModbusPDU:
        This is a constant set at 0 to indicate Modbus.  It is
        put here for ease of expansion.
 
-    .. attribute:: unit_id
+    .. attribute:: unit
 
        This is used to route the request to the correct child. In
        the TCP modbus, it is used for routing (or not used at all. However,
@@ -51,11 +51,11 @@ class ModbusPDU:
        of encoding it again.
     """
 
-    def __init__(self, **kwargs):
+    def __init__(self, unit=Defaults.UnitId, **kwargs):
         """Initialize the base data for a modbus request."""
         self.transaction_id = kwargs.get("transaction", Defaults.TransactionId)
         self.protocol_id = kwargs.get("protocol", Defaults.ProtocolId)
-        self.unit_id = kwargs.get("unit", Defaults.UnitId)
+        self.unit_id = unit
         self.skip_encode = kwargs.get("skip_encode", False)
         self.check = 0x0000
 

pymodbus/repl/client/mclient.py

@@ -96,7 +96,7 @@ def _process_exception(resp, **kwargs):
                 }
         return err
 
-    def read_coils(self, address, count=1, **kwargs):
+    def read_coils(self, address, count=1, unit=0, **kwargs):
         """Read `count` coils from a given slave starting at `address`.
 
         :param address: The starting address to read from
@@ -109,107 +109,114 @@ def read_coils(self, address, count=1, **kwargs):
             return {"function_code": resp.function_code, "bits": resp.bits}
         return ExtendedRequestSupport._process_exception(resp)
 
-    def read_discrete_inputs(self, address, count=1, **kwargs):
+    def read_discrete_inputs(self, address, count=1, unit=0, **kwargs):
         """Read `count` number of discrete inputs starting at offset `address`.
 
         :param address: The starting address to read from
         :param count: The number of coils to read
+        :param unit: Modbus slave unit ID
         :param kwargs:
         :return: List of bits
         """
         resp = super().read_discrete_inputs(  # pylint: disable=no-member
-            address, count, **kwargs
+            address, count, unit, **kwargs
         )
         if not resp.isError():
             return {"function_code": resp.function_code, "bits": resp.bits}
         return ExtendedRequestSupport._process_exception(resp)
 
     @handle_brodcast
-    def write_coil(self, address, value, **kwargs):
+    def write_coil(self, address, value, unit=0, **kwargs):
         """Write `value` to coil at `address`.
 
         :param address: coil offset to write to
         :param value: bit value to write
+        :param unit: Modbus slave unit ID
         :param kwargs:
         :return:
         """
-        resp = super().write_coil(address, value, **kwargs)  # pylint: disable=no-member
+        resp = super().write_coil(address, value, unit, **kwargs)  # pylint: disable=no-member
         return resp
 
     @handle_brodcast
-    def write_coils(self, address, values, **kwargs):
+    def write_coils(self, address, values, unit=0, **kwargs):
         """Write `value` to coil at `address`.
 
         :param address: coil offset to write to
         :param values: list of bit values to write (comma separated)
+        :param unit: Modbus slave unit ID
         :param kwargs:
         :return:
         """
         resp = super().write_coils(  # pylint: disable=no-member
-            address, values, **kwargs
+            address, values, unit, **kwargs
         )
         return resp
 
     @handle_brodcast
-    def write_register(self, address, value, **kwargs):
+    def write_register(self, address, value, unit=0, **kwargs):
         """Write `value` to register at `address`.
 
         :param address: register offset to write to
         :param value: register value to write
+        :param unit: Modbus slave unit ID
         :param kwargs:
         :return:
         """
         resp = super().write_register(  # pylint: disable=no-member
-            address, value, **kwargs
+            address, value, unit, **kwargs
         )
         return resp
 
     @handle_brodcast
-    def write_registers(self, address, values, **kwargs):
+    def write_registers(self, address, values, unit=0, **kwargs):
         """Write list of `values` to registers starting at `address`.
 
         :param address: register offset to write to
         :param values: list of register value to write (comma separated)
+        :param unit: Modbus slave unit ID
         :param kwargs:
         :return:
         """
         resp = super().write_registers(  # pylint: disable=no-member
-            address, values, **kwargs
+            address, values, unit, **kwargs
         )
         return resp
 
-    def read_holding_registers(self, address, count=1, **kwargs):
+    def read_holding_registers(self, address, count=1, unit=0, **kwargs):
         """Read `count` number of holding registers starting at `address`.
 
         :param address: starting register offset to read from
         :param count: Number of registers to read
+        :param unit: Modbus slave unit ID
         :param kwargs:
         :return:
         """
         resp = super().read_holding_registers(  # pylint: disable=no-member
-            address, count, **kwargs
+            address, count, unit, **kwargs
         )
         if not resp.isError():
             return {"function_code": resp.function_code, "registers": resp.registers}
         return ExtendedRequestSupport._process_exception(resp)
 
-    def read_input_registers(self, address, count=1, **kwargs):
+    def read_input_registers(self, address, count=1, unit=0, **kwargs):
         """Read `count` number of input registers starting at `address`.
 
         :param address: starting register offset to read from to
         :param count: Number of registers to read
+        :param unit: Modbus slave unit ID
         :param kwargs:
         :return:
         """
         resp = super().read_input_registers(  # pylint: disable=no-member
-            address, count, **kwargs
+            address, count, unit, **kwargs
         )
         if not resp.isError():
             return {"function_code": resp.function_code, "registers": resp.registers}
         return ExtendedRequestSupport._process_exception(resp)
 
     def readwrite_registers(
-        self, read_address, read_count, write_address, write_registers, **kwargs
+        self, read_address, read_count, write_address, write_registers, unit=0, **kwargs
     ):
         """Read `read_count` number of holding registers.
 
@@ -220,6 +227,7 @@ def readwrite_registers(
         :param read_count: Number of registers to read
         :param write_address: register offset to write to
         :param write_registers: List of register values to write (comma separated)
+        :param unit: Modbus slave unit ID
         :param kwargs:
         :return:
         """
@@ -228,25 +236,27 @@ def readwrite_registers(
             read_count=read_count,
             write_address=write_address,
             write_registers=write_registers,
+            unit=unit,
             **kwargs,
         )
         if not resp.isError():
             return {"function_code": resp.function_code, "registers": resp.registers}
         return ExtendedRequestSupport._process_exception(resp)
 
     def mask_write_register(
-        self, address=0x0000, and_mask=0xFFFF, or_mask=0x0000, **kwargs
+        self, address=0x0000, and_mask=0xFFFF, or_mask=0x0000, unit=0, **kwargs
     ):
         """Mask content of holding register at `address` with `and_mask` and `or_mask`.
 
         :param address: Reference address of register
         :param and_mask: And Mask
         :param or_mask: OR Mask
+        :param unit: Modbus slave unit ID
         :param kwargs:
         :return:
         """
         resp = super().mask_write_register(  # pylint: disable=no-member
-            address=address, and_mask=and_mask, or_mask=or_mask, **kwargs
+            address=address, and_mask=and_mask, or_mask=or_mask, unit=unit, **kwargs
         )
         if not resp.isError():
             return {
@@ -279,13 +289,14 @@ def read_device_information(self, read_code=None, object_id=0x00, **kwargs):
             }
         return ExtendedRequestSupport._process_exception(resp)
 
-    def report_slave_id(self, **kwargs):
+    def report_slave_id(self, unit=0, **kwargs):
         """Report information about remote slave ID.
 
+        :param unit: Modbus slave unit ID
         :param kwargs:
         :return:
         """
-        request = ReportSlaveIdRequest(**kwargs)
+        request = ReportSlaveIdRequest(unit, **kwargs)
         resp = self.execute(request)  # pylint: disable=no-member
         if not resp.isError():
             return {