async datastore in modbus server

examples/server_callback.py

@@ -31,15 +31,15 @@ def __init__(self, queue, addr, values):
         self.queue = queue
         super().__init__(addr, values)
 
-    def setValues(self, address, value):
+    async def async_setValues(self, address, value):
         """Set the requested values of the datastore."""
-        super().setValues(address, value)
+        await super().async_setValues(address, value)
         txt = f"Callback from setValues with address {address}, value {value}"
         _logger.debug(txt)
 
-    def getValues(self, address, count=1):
+    async def async_getValues(self, address, count=1):
         """Return the requested values from the datastore."""
-        result = super().getValues(address, count=count)
+        result = await super().async_getValues(address, count=count)
         txt = f"Callback from getValues with address {address}, count {count}, data {result}"
         _logger.debug(txt)
         return result
@@ -56,7 +56,7 @@ async def run_callback_server(cmdline=None):
     """Define datastore callback for server and do setup."""
     queue = asyncio.Queue()
     block = CallbackDataBlock(queue, 0x00, [17] * 100)
-    block.setValues(1, 15)
+    await block.async_setValues(1, 15)
     store = ModbusSlaveContext(di=block, co=block, hr=block, ir=block)
     context = ModbusServerContext(slaves=store, single=True)
     run_args = server_async.setup_server(

examples/server_updating.py

@@ -61,9 +61,9 @@ async def updating_task(context):
     count = 6
 
     # set values to zero
-    values = context[slave_id].getValues(fc_as_hex, address, count=count)
+    values = await context[slave_id].async_getValues(fc_as_hex, address, count=count)
     values = [0 for v in values]
-    context[slave_id].setValues(fc_as_hex, address, values)
+    await context[slave_id].async_setValues(fc_as_hex, address, values)
 
     txt = (
         f"updating_task: started: initialised values: {values!s} at address {address!s}"
@@ -75,9 +75,11 @@ async def updating_task(context):
     while True:
         await asyncio.sleep(2)
 
-        values = context[slave_id].getValues(fc_as_hex, address, count=count)
+        values = await context[slave_id].async_getValues(
+            fc_as_hex, address, count=count
+        )
         values = [v + 1 for v in values]
-        context[slave_id].setValues(fc_as_hex, address, values)
+        await context[slave_id].async_setValues(fc_as_hex, address, values)
 
         txt = f"updating_task: incremented values: {values!s} at address {address!s}"
         print(txt)

pymodbus/bit_read_message.py

@@ -155,7 +155,7 @@ def __init__(self, address=None, count=None, slave=0, **kwargs):
         """
         ReadBitsRequestBase.__init__(self, address, count, slave, **kwargs)
 
-    def execute(self, context):
+    async def execute(self, context):
         """Run a read coils request against a datastore.
 
         Before running the request, we make sure that the request is in
@@ -169,7 +169,9 @@ def execute(self, context):
             return self.doException(merror.IllegalValue)
         if not context.validate(self.function_code, self.address, self.count):
             return self.doException(merror.IllegalAddress)
-        values = context.getValues(self.function_code, self.address, self.count)
+        values = await context.async_getValues(
+            self.function_code, self.address, self.count
+        )
         if isinstance(values, ExceptionResponse):
             return values
         return ReadCoilsResponse(values)
@@ -223,7 +225,7 @@ def __init__(self, address=None, count=None, slave=0, **kwargs):
         """
         ReadBitsRequestBase.__init__(self, address, count, slave, **kwargs)
 
-    def execute(self, context):
+    async def execute(self, context):
         """Run a read discrete input request against a datastore.
 
         Before running the request, we make sure that the request is in
@@ -237,7 +239,9 @@ def execute(self, context):
             return self.doException(merror.IllegalValue)
         if not context.validate(self.function_code, self.address, self.count):
             return self.doException(merror.IllegalAddress)
-        values = context.getValues(self.function_code, self.address, self.count)
+        values = await context.async_getValues(
+            self.function_code, self.address, self.count
+        )
         if isinstance(values, ExceptionResponse):
             return values
         return ReadDiscreteInputsResponse(values)

pymodbus/bit_write_message.py

@@ -79,7 +79,7 @@ def decode(self, data):
         self.address, value = struct.unpack(">HH", data)
         self.value = value == ModbusStatus.ON
 
-    def execute(self, context):
+    async def execute(self, context):
         """Run a write coil request against a datastore.
 
         :param context: The datastore to request from
@@ -90,10 +90,12 @@ def execute(self, context):
         if not context.validate(self.function_code, self.address, 1):
             return self.doException(merror.IllegalAddress)
 
-        result = context.setValues(self.function_code, self.address, [self.value])
+        result = await context.async_setValues(
+            self.function_code, self.address, [self.value]
+        )
         if isinstance(result, ExceptionResponse):
             return result
-        values = context.getValues(self.function_code, self.address, 1)
+        values = await context.async_getValues(self.function_code, self.address, 1)
         if isinstance(values, ExceptionResponse):
             return values
         return WriteSingleCoilResponse(self.address, values[0])
@@ -212,7 +214,7 @@ def decode(self, data):
         values = unpack_bitstring(data[5:])
         self.values = values[:count]
 
-    def execute(self, context):
+    async def execute(self, context):
         """Run a write coils request against a datastore.
 
         :param context: The datastore to request from
@@ -226,7 +228,9 @@ def execute(self, context):
         if not context.validate(self.function_code, self.address, count):
             return self.doException(merror.IllegalAddress)
 
-        result = context.setValues(self.function_code, self.address, self.values)
+        result = await context.async_setValues(
+            self.function_code, self.address, self.values
+        )
         if isinstance(result, ExceptionResponse):
             return result
         return WriteMultipleCoilsResponse(self.address, count)

pymodbus/datastore/context.py

@@ -1,18 +1,19 @@
 """Context for datastore."""
+
 # pylint: disable=missing-type-doc
 from pymodbus.datastore.store import ModbusSequentialDataBlock
 from pymodbus.exceptions import NoSuchSlaveException
 from pymodbus.logging import Log
 
 
-class ModbusBaseSlaveContext:  # pylint: disable=too-few-public-methods
+class ModbusBaseSlaveContext:
     """Interface for a modbus slave data context.
 
     Derived classes must implemented the following methods:
             reset(self)
             validate(self, fx, address, count=1)
-            getValues(self, fx, address, count=1)
-            setValues(self, fx, address, values)
+            getValues(self, fc_as_hex, address, count=1) or async_getValues(self, fc_as_hex, address, count=1)
+            setValues(self, fc_as_hex, address, values) or async_setValues(self, fc_as_hex, address, values)
     """
 
     _fx_mapper = {2: "d", 4: "i"}
@@ -27,6 +28,45 @@ def decode(self, fx):
         """
         return self._fx_mapper[fx]
 
+    async def async_getValues(self, fc_as_hex, address, count=1):
+        """Get `count` values from datastore.
+
+        :param fc_as_hex: The function we are working with
+        :param address: The starting address
+        :param count: The number of values to retrieve
+        :returns: The requested values from a:a+c
+        """
+        return self.getValues(fc_as_hex, address, count)
+
+    async def async_setValues(self, fc_as_hex, address, values):
+        """Set the datastore with the supplied values.
+
+        :param fc_as_hex: The function we are working with
+        :param address: The starting address
+        :param values: The new values to be set
+        """
+        return self.setValues(fc_as_hex, address, values)
+
+    def getValues(self, fc_as_hex, address, count=1):
+        """Get `count` values from datastore.
+
+        :param fc_as_hex: The function we are working with
+        :param address: The starting address
+        :param count: The number of values to retrieve
+        :returns: The requested values from a:a+c
+        """
+        del fc_as_hex, address, count
+        return []
+
+    def setValues(self, fc_as_hex, address, values):
+        """Set the datastore with the supplied values.
+
+        :param fc_as_hex: The function we are working with
+        :param address: The starting address
+        :param values: The new values to be set
+        """
+        del fc_as_hex, address, values
+
 
 # ---------------------------------------------------------------------------#
 #  Slave Contexts

pymodbus/datastore/remote.py

@@ -1,4 +1,5 @@
 """Remote datastore."""
+
 from pymodbus.datastore import ModbusBaseSlaveContext
 from pymodbus.exceptions import NotImplementedException
 from pymodbus.logging import Log
@@ -38,25 +39,37 @@ def validate(self, _fc_as_hex, _address, _count):
         """
         return True
 
-    def getValues(self, fc_as_hex, _address, _count=1):
+    async def async_getValues(self, fc_as_hex, address, count=1):
         """Get values from real call in validate."""
         if fc_as_hex in self._write_fc:
             return [0]
         group_fx = self.decode(fc_as_hex)
         func_fc = self.__get_callbacks[group_fx]
-        self.result = func_fc(_address, _count)
+        kwargs = {}
+        if self.slave:
+            kwargs["slave"] = self.slave
+        self.result = await getattr(self._client, func_fc)(address, count, **kwargs)
         return self.__extract_result(self.decode(fc_as_hex), self.result)
 
-    def setValues(self, fc_as_hex, address, values):
+    async def async_setValues(self, fc_as_hex, address, values):
         """Set the datastore with the supplied values."""
         group_fx = self.decode(fc_as_hex)
         if fc_as_hex not in self._write_fc:
-            raise ValueError(f"setValues() called with an non-write function code {fc_as_hex}")
+            raise ValueError(
+                f"setValues() called with an non-write function code {fc_as_hex}"
+            )
         func_fc = self.__set_callbacks[f"{group_fx}{fc_as_hex}"]
+        kwargs = {}
+        if self.slave:
+            kwargs["slave"] = self.slave
         if fc_as_hex in {0x0F, 0x10}:  # Write Multiple Coils, Write Multiple Registers
-            self.result = func_fc(address, values)
+            self.result = await getattr(self._client, func_fc)(
+                address, values, **kwargs
+            )
         else:
-            self.result = func_fc(address, values[0])
+            self.result = await getattr(self._client, func_fc)(
+                address, values[0], **kwargs
+            )
         if self.result.isError():
             return self.result
         return None
@@ -74,44 +87,20 @@ def __build_mapping(self):
         if self.slave:
             kwargs["slave"] = self.slave
         self.__get_callbacks = {
-            "d": lambda a, c: self._client.read_discrete_inputs(
-                a, c, **kwargs
-            ),
-            "c": lambda a, c: self._client.read_coils(
-                a, c, **kwargs
-            ),
-            "h": lambda a, c: self._client.read_holding_registers(
-                a, c, **kwargs
-            ),
-            "i": lambda a, c: self._client.read_input_registers(
-                a, c, **kwargs
-            ),
+            "d": "read_discrete_inputs",
+            "c": "read_coils",
+            "h": "read_holding_registers",
+            "i": "read_input_registers",
         }
         self.__set_callbacks = {
-            "d5": lambda a, v: self._client.write_coil(
-                a, v, **kwargs
-            ),
-            "d15": lambda a, v: self._client.write_coils(
-                a, v, **kwargs
-            ),
-            "c5": lambda a, v: self._client.write_coil(
-                a, v, **kwargs
-            ),
-            "c15": lambda a, v: self._client.write_coils(
-                a, v, **kwargs
-            ),
-            "h6": lambda a, v: self._client.write_register(
-                a, v, **kwargs
-            ),
-            "h16": lambda a, v: self._client.write_registers(
-                a, v, **kwargs
-            ),
-            "i6": lambda a, v: self._client.write_register(
-                a, v, **kwargs
-            ),
-            "i16": lambda a, v: self._client.write_registers(
-                a, v, **kwargs
-            ),
+            "d5": "write_coil",
+            "d15": "write_coils",
+            "c5": "write_coil",
+            "c15": "write_coils",
+            "h6": "write_register",
+            "h16": "write_registers",
+            "i6": "write_register",
+            "i16": "write_registers",
         }
         self._write_fc = (0x05, 0x06, 0x0F, 0x10)
 

pymodbus/datastore/simulator.py

@@ -577,6 +577,13 @@ def validate(self, func_code, address, count=1):
         fx_write = func_code in self._write_func_code
         return self.loop_validate(real_address, real_address + count, fx_write)
 
+    async def async_getValues(self, func_code, address, count=1):
+        """Return the requested values of the datastore.
+
+        :meta private:
+        """
+        return self.getValues(func_code, address, count)
+
     def getValues(self, func_code, address, count=1):
         """Return the requested values of the datastore.
 
@@ -611,6 +618,13 @@ def getValues(self, func_code, address, count=1):
                 bit_index = 0
         return result
 
+    async def async_setValues(self, func_code, address, values):
+        """Set the requested values of the datastore.
+
+        :meta private:
+        """
+        return self.setValues(func_code, address, values)
+
     def setValues(self, func_code, address, values):
         """Set the requested values of the datastore.
 

pymodbus/datastore/store.py

@@ -72,6 +72,10 @@ class BaseModbusDataBlock(ABC, Generic[V]):
             getValues(self, address, count=1)
             setValues(self, address, values)
             reset(self)
+
+    Derived classes can implemented the following async methods:
+            async_getValues(self, address, count=1)
+            async_setValues(self, address, values)
     """
 
     values: V
@@ -87,6 +91,15 @@ def validate(self, address:int, count=1) -> bool:
         :raises TypeError:
         """
 
+    async def async_getValues(self, address: int, count=1) -> Iterable:
+        """Return the requested values from the datastore.
+
+        :param address: The starting address
+        :param count: The number of values to retrieve
+        :raises TypeError:
+        """
+        return self.getValues(address, count)
+
     @abstractmethod
     def getValues(self, address:int, count=1) -> Iterable:
         """Return the requested values from the datastore.
@@ -96,6 +109,15 @@ def getValues(self, address:int, count=1) -> Iterable:
         :raises TypeError:
         """
 
+    async def async_setValues(self, address: int, values):
+        """Return the requested values from the datastore.
+
+        :param address: The starting address
+        :param values: The values to store
+        :raises TypeError:
+        """
+        return self.setValues(address, values)
+
     @abstractmethod
     def setValues(self, address:int, values) -> None:
         """Return the requested values from the datastore.