Add no_response_expected argument to requests (#2385)

Co-authored-by: jan iversen <jancasacondor@gmail.com>

Author: matesh

doc/source/_static/examples.tgz

@@ -199,14 +199,12 @@ The logical devices represented by the device is addressed with the :mod:`slave=
 With **Serial**, the comm port is defined when creating the object.
 The physical devices are addressed with the :mod:`slave=` parameter.
 
-:mod:`slave=0` is used as broadcast in order to address all devices.
-However experience shows that modern devices do not allow broadcast, mostly because it is
-inheriently dangerous. With :mod:`slave=0` the application can get upto 254 responses on a single request,
-and this is not handled with the normal API calls!
+:mod:`slave=0` is defined as broadcast in the modbus standard, but pymodbus treats is a normal device.
 
-The simple request calls (mixin) do NOT support broadcast, if an application wants to use broadcast
-it must call :mod:`client.execute` and deal with the responses.
+If an application is expecting multiple responses to a broadcast request, it must call :mod:`client.execute` and deal with the responses.
 
+If no response is expected to a request, the :mod:`no_response_expected=True` argument can be used
+in the normal API calls, this will cause the call to return imidiatble with :mod:`None`
 
 
 Client response handling
@@ -235,6 +233,7 @@ And in case of read retrieve the data depending on type of request
 - :mod:`rr.bits` is set for coils / input_register requests
 - :mod:`rr.registers` is set for other requests
 
+Remark if using :mod:`no_response_expected=True` rr will always be None.
 
 Client interface classes
 ------------------------

doc/source/_static/examples.zip

@@ -128,12 +128,12 @@ async def main(host="localhost", port=5020):
         client.register(CustomModbusPDU)
         slave=1
         request = CustomRequest(32, slave=slave)
-        result = await client.execute(request)
+        result = await client.execute(False, request)
         print(result)
 
         # inherited request
         request = Read16CoilsRequest(32, slave)
-        result = await client.execute(request)
+        result = await client.execute(False, request)
         print(result)
 
 

doc/source/client.rst

@@ -83,20 +83,16 @@ def close(self) -> None:
         """Close connection."""
         self.ctx.close()
 
-    def execute(self, request: ModbusPDU):
+    def execute(self, no_response_expected: bool, request: ModbusPDU):
         """Execute request and get response (call **sync/async**).
 
-        :param request: The request to process
-        :returns: The result of the request execution
-        :raises ConnectionException: Check exception text.
-
         :meta private:
         """
         if not self.ctx.transport:
             raise ConnectionException(f"Not connected[{self!s}]")
-        return self.async_execute(request)
+        return self.async_execute(no_response_expected, request)
 
-    async def async_execute(self, request) -> ModbusPDU:
+    async def async_execute(self, no_response_expected: bool, request) -> ModbusPDU | None:
         """Execute requests asynchronously.
 
         :meta private:
@@ -109,6 +105,9 @@ async def async_execute(self, request) -> ModbusPDU:
             async with self._lock:
                 req = self.build_response(request)
                 self.ctx.send(packet)
+                if no_response_expected:
+                    resp = None
+                    break
                 try:
                     resp = await asyncio.wait_for(
                         req, timeout=self.ctx.comm_params.timeout_connect
@@ -225,9 +224,10 @@ def idle_time(self) -> float:
             return 0
         return self.last_frame_end + self.silent_interval
 
-    def execute(self, request: ModbusPDU) -> ModbusPDU:
+    def execute(self, no_response_expected: bool, request: ModbusPDU) -> ModbusPDU:
         """Execute request and get response (call **sync/async**).
 
+        :param no_response_expected: The client will not expect a response to the request
         :param request: The request to process
         :returns: The result of the request execution
         :raises ConnectionException: Check exception text.
@@ -236,7 +236,7 @@ def execute(self, request: ModbusPDU) -> ModbusPDU:
         """
         if not self.connect():
             raise ConnectionException(f"Failed to connect[{self!s}]")
-        return self.transaction.execute(request)
+        return self.transaction.execute(no_response_expected, request)
 
     # ----------------------------------------------------------------------- #
     # Internal methods