fixed random delays in frame sending

Author: jimy-byerley

src/rawmaster.rs

@@ -67,7 +67,6 @@ pub struct RawMaster {
 	// synchronization signal for multitask reception
 	received: Notify,
 	sendable: Condvar,
-	send: Condvar,
 	sent: Notify,
 
 	// communication state
@@ -80,7 +79,7 @@ pub struct RawMaster {
 struct PduState {
 	last_start: usize,
 	last_end: usize,
-	last_time: Instant,
+	ready: bool,
 	/// send buffer, it contains one ethercat frame
 	send: [u8; MAX_ETHERCAT_FRAME],
 	/// reception destination, each containing a reception buffer and additional infos
@@ -102,13 +101,12 @@ impl RawMaster {
             socket: Box::new(socket),
             received: Notify::new(),
             sendable: Condvar::new(),
-            send: Condvar::new(),
             sent: Notify::new(),
 
             pdu_state: Mutex::new(PduState {
                 last_start: EthercatHeader::packed_size(),
                 last_end: 0,
-                last_time: Instant::now(),
+                ready: false,
                 send: [0; MAX_ETHERCAT_FRAME],
                 receive: [0; 2*MAX_ETHERCAT_PDU].map(|_| None),
                 free: (0 .. 2*MAX_ETHERCAT_PDU).collect(),
@@ -273,8 +271,8 @@ impl RawMaster {
                     + data.len() 
                     + PduHeader::packed_size() 
                     + PduFooter::packed_size(), "data too big for an ethercat frame");
+                state.ready = true;
                 self.sendable.notify_one();
-                self.send.notify_one();
                 let notification = self.sent.notified();
                 drop(state);
                 notification.await;
@@ -303,7 +301,6 @@ impl RawMaster {
                 header.pack(place).unwrap();
             }
             else {
-                state.last_time = Instant::now();
                 state.last_end = state.last_start;
             }
 
@@ -352,6 +349,13 @@ impl RawMaster {
 		state.receive[token].as_ref().unwrap().answers
 	}
 
+	/// trigger sending the buffered PDUs, they will be sent as soon as possible by [Self::send] instead of waiting for the frame to be full or for the timeout
+	fn flush(&self) {
+        let mut state = self.pdu_state.lock().unwrap();
+        state.ready = true;
+        self.sendable.notify_one();
+	}
+	
 	/// extract a received frame of PDUs and buffer each for reception by an eventual `self.pdu()` future waiting for it.
 	fn pdu_receive(&self, state: &mut PduState, frame: &[u8]) {
         let mut frame = Cursor::new(frame);
@@ -404,9 +408,16 @@ impl RawMaster {
 	/// this is the socket sending handler
 	pub fn send(&self) {
         let mut state = self.pdu_state.lock().unwrap();
-        if state.last_end == 0
+        // wait indefinitely if no data to send
+        while state.last_end == 0
             {state = self.sendable.wait(state).unwrap();}
-        state = self.send.wait_timeout(state, self.pdu_merge_time).unwrap().0;
+        // wait for more data until a timeout once data is present
+        if ! state.ready
+            {state = self.sendable.wait_timeout_while(
+                    state, 
+                    self.pdu_merge_time, 
+                    |state| ! state.ready,
+                    ).unwrap().0;}
 
         // check header
         EthercatHeader::new(
@@ -419,6 +430,7 @@ impl RawMaster {
         // we assume it is not a long operation to copy those data into the system buffer
         self.socket.send(&state.send[.. state.last_end]).unwrap();
         // reset state
+        state.ready = false;
         state.last_end = 0;
         state.last_start = EthercatHeader::packed_size();
         self.sent.notify_waiters();