RTU broadcast waits for reply

[fpagliughi]

When I use an RTU client and send a broadcast message (slave=0) the library seems to wait for a reply and then return a timeout error.

I'm thinking that the library should just send the broadcast and return immediately with a success. Well, at least the functions in the Writer trait. I'm not sure the best thing for the Reader functions when using the broadcast ID. Just error? Put the bytes on the wire?

Anyway, at least for the write functions, is there a way to do this without a wait and timeout. I'm not seeing it in the docs.

Thanks much.

[mickem]

First off: I am not an expert on neither modbus nor tokio or the framing helper used... so I likely missunderstand how this works.

But from what I understand broadcasting via slave id 0 is pretty common.
The library does not support this however and it seems like expecting a response is built-in to the design.

As I was using call I started to add a quick function called broadcast which did only the send part. This did not use proper frame spacing so I also had to add a "delay" (I picked a random time of 100ms). Unfortunately from what I can understand the library does not support adding a frame delay instead it relies on waiting for the response to generate the frame delay. This complicates adding support for broadcasting.
From what I understand the frame delay should be based on the baud rate and correspond to how long time it takes to send like 3-4 characters.

In addition to this the optional response would be required on many write related functions such as write_single_coil and write_multiple_coils etc. And duplicating them with broadcast_write_single_coil seems like a bad idea. So I ended up instead change so the send function check the slave id and ignores the response if it is 0. This is a breaking change and has some unintended side effects as the return type has to be changed a bit. So not 100% sure how to do this smoothly...

So I think some input from the maintainers in how this can best be added is required.
I can happily submit a PR adding support for this if we get some guidance on how best to implement it...

For what it is worth here is how I added broadcast (only on RTU)

diff --git a/src/client/mod.rs b/src/client/mod.rs
index 79e6bf0..3a19ab8 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -261,6 +261,9 @@ impl Writer for Context {
                         debug_assert_eq!(addr, rsp_addr);
                         debug_assert_eq!(coil, rsp_coil);
                     }
+                    Response::Broadcast => {
+                        // Broadcast write, no response expected
+                    }
                     _ => unreachable!("call() should reject mismatching responses"),
                 })
             })
diff --git a/src/codec/mod.rs b/src/codec/mod.rs
index b51754f..b8d2c9e 100644
--- a/src/codec/mod.rs
+++ b/src/codec/mod.rs
@@ -175,7 +175,8 @@ fn encode_response_pdu(buf: &mut crate::bytes::BytesMut, response: &Response) {
         }
         Custom(_, custom_data) => {
             buf.put_slice(custom_data);
-        }
+        },
+        Broadcast => {}
     }
 }
 
diff --git a/src/frame/mod.rs b/src/frame/mod.rs
index b04f104..15d0421 100644
--- a/src/frame/mod.rs
+++ b/src/frame/mod.rs
@@ -396,6 +396,10 @@ pub enum Response {
     /// The first parameter contains the returned Modbus function code
     /// The second parameter contains the bytes read following the function code
     Custom(u8, Bytes),
+
+    /// Response to a Modbus request which was sent to slave id 0 as a broadcast.
+    /// This response contains no data
+    Broadcast,
 }
 
 impl Response {
@@ -426,6 +430,7 @@ impl Response {
             ReadDeviceIdentification(_) => FunctionCode::EncapsulatedInterfaceTransport,
 
             Custom(code, _) => FunctionCode::Custom(*code),
+            Broadcast => todo!(),
         }
     }
 }
diff --git a/src/service/rtu.rs b/src/service/rtu.rs
index 82bc63d..306e84f 100644
--- a/src/service/rtu.rs
+++ b/src/service/rtu.rs
@@ -4,7 +4,9 @@
 use std::io;
 
 use futures_util::{SinkExt as _, StreamExt as _};
+use std::time::Duration;
 use tokio::io::{AsyncRead, AsyncWrite};
+use tokio::time::sleep;
 use tokio_util::codec::Framed;
 
 use crate::{
@@ -65,6 +67,11 @@ where
         framed.read_buffer_mut().clear();
         framed.send(req_adu).await?;
 
+        if req_hdr.slave_id == 0 {
+            sleep(Duration::from_millis(100)).await;
+            return Ok(Ok(Response::Broadcast));
+        }
+
         let res_adu = framed
             .next()
             .await