Fix timing bugs and add documentation

[m17rt] / m17core / src / tnc.rs

diff --git a/m17core/src/tnc.rs b/m17core/src/tnc.rs
index a7cbc53b893dee9c6b18df2b6623678f58c9d3ec..b46958c72f2dd3f85955bef3335a928bb2e6d408 100644 (file)
--- a/m17core/src/tnc.rs
+++ b/m17core/src/tnc.rs
@@ -1,5 +1,7 @@
 use crate::address::{Address, Callsign};
 use crate::address::{Address, Callsign};

-use crate::kiss::{KissBuffer, KissFrame, PORT_PACKET_BASIC, PORT_PACKET_FULL, PORT_STREAM};
+use crate::kiss::{
+    KissBuffer, KissCommand, KissFrame, PORT_PACKET_BASIC, PORT_PACKET_FULL, PORT_STREAM,
+};

 use crate::modem::ModulatorFrame;
 use crate::protocol::{
     Frame, LichCollection, LsfFrame, Mode, PacketFrame, PacketFrameCounter, StreamFrame,
 use crate::modem::ModulatorFrame;
 use crate::protocol::{
     Frame, LichCollection, LsfFrame, Mode, PacketFrame, PacketFrameCounter, StreamFrame,


@@ -66,6 +68,12 @@ pub struct SoftTnc {
 
     /// Should PTT be on right now? Polled by external
     ptt: bool,
 
     /// Should PTT be on right now? Polled by external
     ptt: bool,

+
+    /// TxDelay raw value, number of 10ms units. We will optimistically start with default 0.
+    tx_delay: u8,
+
+    /// This is a full duplex channel so we do not need to monitor DCD or use CSMA. Default false.
+    full_duplex: bool,

 }
 
 impl SoftTnc {
 }
 
 impl SoftTnc {


@@ -87,11 +95,17 @@ impl SoftTnc {
             stream_curr: 0,
             stream_full: false,
             ptt: false,
             stream_curr: 0,
             stream_full: false,
             ptt: false,

+            tx_delay: 0,
+            full_duplex: false,

         }
     }
 
     /// Process an individual `Frame` that has been decoded by the modem.
     pub fn handle_frame(&mut self, frame: Frame) {
         }
     }
 
     /// Process an individual `Frame` that has been decoded by the modem.
     pub fn handle_frame(&mut self, frame: Frame) {

+        if self.ptt {
+            // Ignore self-decodes
+            return;
+        }

         match frame {
             Frame::Lsf(lsf) => {
                 // A new LSF implies a clean slate.
         match frame {
             Frame::Lsf(lsf) => {
                 // A new LSF implies a clean slate.


@@ -107,7 +121,10 @@ impl SoftTnc {
                     Mode::Stream => {
                         let kiss = KissFrame::new_stream_setup(&lsf.0).unwrap();
                         self.kiss_to_host(kiss);
                     Mode::Stream => {
                         let kiss = KissFrame::new_stream_setup(&lsf.0).unwrap();
                         self.kiss_to_host(kiss);

-                        self.state = State::RxStream(RxStreamState { lsf, index: 0 });
+                        self.state = State::RxStream(RxStreamState {
+                            _lsf: lsf,
+                            index: 0,
+                        });

                     }
                 }
             }
                     }
                 }
             }


@@ -129,7 +146,7 @@ impl SoftTnc {
                                 let start = 25 * rx.count;
                                 let end = start + payload_len;
                                 rx.packet[start..(start + payload_len)]
                                 let start = 25 * rx.count;
                                 let end = start + payload_len;
                                 rx.packet[start..(start + payload_len)]

-                                    .copy_from_slice(&packet.payload);
+                                    .copy_from_slice(&packet.payload[0..payload_len]);

                                 // TODO: compatible packets should be sent on port 0 too
                                 let kiss =
                                     KissFrame::new_full_packet(&rx.lsf.0, &rx.packet[0..end])
                                 // TODO: compatible packets should be sent on port 0 too
                                 let kiss =
                                     KissFrame::new_full_packet(&rx.lsf.0, &rx.packet[0..end])


@@ -176,7 +193,7 @@ impl SoftTnc {
                                 // TODO: avoid discarding the first data payload here
                                 // need a queue depth of 2 for outgoing kiss
                                 self.state = State::RxStream(RxStreamState {
                                 // TODO: avoid discarding the first data payload here
                                 // need a queue depth of 2 for outgoing kiss
                                 self.state = State::RxStream(RxStreamState {

-                                    lsf,
+                                    _lsf: lsf,

                                     index: stream.frame_number + 1,
                                 });
                             }
                                     index: stream.frame_number + 1,
                                 });
                             }


@@ -200,14 +217,13 @@ impl SoftTnc {
 
     pub fn set_now(&mut self, now_samples: u64) {
         self.now = now_samples;
 
     pub fn set_now(&mut self, now_samples: u64) {
         self.now = now_samples;

-        match self.state {
-            State::TxEndingAtTime(time) => {
-                if now_samples >= time {
-                    self.ptt = false;
-                    self.state = State::Idle;
-                }
+        // TODO: expose this to higher layer so we can schedule a precise delay
+        // rather than waiting for some soundcard I/O event
+        if let State::TxEndingAtTime(time) = self.state {
+            if now_samples >= time {
+                self.ptt = false;
+                self.state = State::Idle;

             }
             }

-            _ => (),

         }
     }
 
         }
     }
 


@@ -217,11 +233,8 @@ impl SoftTnc {
 
     pub fn set_tx_end_time(&mut self, in_samples: usize) {
         log::debug!("tnc has been told that tx will complete in {in_samples} samples");
 
     pub fn set_tx_end_time(&mut self, in_samples: usize) {
         log::debug!("tnc has been told that tx will complete in {in_samples} samples");

-        match self.state {
-            State::TxEnding => {
-                self.state = State::TxEndingAtTime(self.now + in_samples as u64);
-            }
-            _ => (),
+        if let State::TxEnding = self.state {
+            self.state = State::TxEndingAtTime(self.now + in_samples as u64);

         }
     }
 
         }
     }
 


@@ -235,30 +248,36 @@ impl SoftTnc {
                 }
 
                 // We have something we might send if the channel is free
                 }
 
                 // We have something we might send if the channel is free

-                match self.next_csma_check {
-                    None => {
-                        if self.dcd {
-                            self.next_csma_check = Some(self.now + 1920);
-                            return None;
-                        } else {
-                            // channel is idle at the moment we get a frame to send
-                            // go right ahead
-                        }
-                    }
-                    Some(at_time) => {
-                        if self.now < at_time {
-                            return None;
+
+                // TODO: Proper full duplex support
+                // A true full duplex TNC should be able to rx and tx concurrently, implying
+                // separate states.
+                if !self.full_duplex {
+                    match self.next_csma_check {
+                        None => {
+                            if self.dcd {
+                                self.next_csma_check = Some(self.now + 1920);
+                                return None;
+                            } else {
+                                // channel is idle at the moment we get a frame to send
+                                // go right ahead
+                            }

                         }
                         }

-                        // 25% chance that we'll transmit this slot.
-                        // Using self.now as random is probably fine so long as it's not being set in
-                        // a lumpy manner. m17app's soundmodem should be fine.
-                        // TODO: bring in prng to help in cases where `now` never ends in 0b11
-                        let p1_4 = (self.now & 3) == 3;
-                        if !self.dcd || !p1_4 {
-                            self.next_csma_check = Some(self.now + 1920);
-                            return None;
-                        } else {
-                            self.next_csma_check = None;
+                        Some(at_time) => {
+                            if self.now < at_time {
+                                return None;
+                            }
+                            // 25% chance that we'll transmit this slot.
+                            // Using self.now as random is probably fine so long as it's not being set in
+                            // a lumpy manner. m17app's soundmodem should be fine.
+                            // TODO: bring in prng to help in cases where `now` never ends in 0b11
+                            let p1_4 = (self.now & 3) == 3;
+                            if !self.dcd || !p1_4 {
+                                self.next_csma_check = Some(self.now + 1920);
+                                return None;
+                            } else {
+                                self.next_csma_check = None;
+                            }

                         }
                     }
                 }
                         }
                     }
                 }


@@ -269,8 +288,9 @@ impl SoftTnc {
                     self.state = State::TxPacket;
                 }
                 self.ptt = true;
                     self.state = State::TxPacket;
                 }
                 self.ptt = true;

-                // TODO: true txdelay
-                Some(ModulatorFrame::Preamble { tx_delay: 0 })
+                Some(ModulatorFrame::Preamble {
+                    tx_delay: self.tx_delay,
+                })

             }
             State::TxStream => {
                 if !self.stream_full && self.stream_next == self.stream_curr {
             }
             State::TxStream => {
                 if !self.stream_full && self.stream_next == self.stream_curr {


@@ -348,6 +368,31 @@ impl SoftTnc {
             let Ok(port) = kiss_frame.port() else {
                 continue;
             };
             let Ok(port) = kiss_frame.port() else {
                 continue;
             };

+            let Ok(command) = kiss_frame.command() else {
+                continue;
+            };
+            if port != PORT_PACKET_BASIC && port != PORT_PACKET_FULL && port != PORT_STREAM {
+                continue;
+            }
+            if command == KissCommand::TxDelay {
+                let mut new_delay = [0u8; 1];
+                if kiss_frame.decode_payload(&mut new_delay) == Ok(1) {
+                    self.tx_delay = new_delay[0];
+                }
+                continue;
+            }
+            if command == KissCommand::FullDuplex {
+                let mut new_duplex = [0u8; 1];
+                if kiss_frame.decode_payload(&mut new_duplex) == Ok(1) {
+                    self.full_duplex = new_duplex[0] != 0;
+                }
+                continue;
+            }
+            if command != KissCommand::DataFrame {
+                // Not supporting any other settings yet
+                // TODO: allow adjusting P persistence parameter for CSMA
+                continue;
+            }

             if port == PORT_PACKET_BASIC {
                 if self.packet_full {
                     continue;
             if port == PORT_PACKET_BASIC {
                 if self.packet_full {
                     continue;


@@ -362,7 +407,7 @@ impl SoftTnc {
                 pending.app_data[len..len + 2].copy_from_slice(&packet_crc.to_be_bytes());
                 pending.app_data_len = len + 2;
                 pending.lsf = Some(LsfFrame::new_packet(
                 pending.app_data[len..len + 2].copy_from_slice(&packet_crc.to_be_bytes());
                 pending.app_data_len = len + 2;
                 pending.lsf = Some(LsfFrame::new_packet(

-                    &Address::Callsign(Callsign(b"M17RT-PKT".clone())),
+                    &Address::Callsign(Callsign(*b"M17RT-PKT")),

                     &Address::Broadcast,
                 ));
                 self.packet_queue[self.packet_next] = pending;
                     &Address::Broadcast,
                 ));
                 self.packet_queue[self.packet_next] = pending;


@@ -389,7 +434,7 @@ impl SoftTnc {
                 }
                 pending.lsf = Some(lsf);
                 let app_data_len = len - 30;
                 }
                 pending.lsf = Some(lsf);
                 let app_data_len = len - 30;

-                pending.app_data[0..app_data_len].copy_from_slice(&payload[30..]);
+                pending.app_data[0..app_data_len].copy_from_slice(&payload[30..len]);

                 pending.app_data_len = app_data_len;
                 self.packet_queue[self.packet_next] = pending;
                 self.packet_next = (self.packet_next + 1) % 4;
                 pending.app_data_len = app_data_len;
                 self.packet_queue[self.packet_next] = pending;
                 self.packet_next = (self.packet_next + 1) % 4;


@@ -442,6 +487,12 @@ impl SoftTnc {
     }
 }
 
     }
 }
 

+impl Default for SoftTnc {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+

 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum SoftTncError {
     General(&'static str),
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum SoftTncError {
     General(&'static str),


@@ -453,6 +504,7 @@ struct OutgoingKiss {
     sent: usize,
 }
 
     sent: usize,
 }
 

+#[allow(clippy::large_enum_variant)]

 enum State {
     /// Nothing happening. We may have TX data queued but we won't act on it until CSMA opens up.
     Idle,
 enum State {
     /// Nothing happening. We may have TX data queued but we won't act on it until CSMA opens up.
     Idle,


@@ -489,7 +541,7 @@ struct RxAcquiringStreamState {
 
 struct RxStreamState {
     /// Track identifying information for this transmission so we can tell if it changes.
 
 struct RxStreamState {
     /// Track identifying information for this transmission so we can tell if it changes.

-    lsf: LsfFrame,
+    _lsf: LsfFrame,

 
     /// Expected next frame number. Allowed to skip values on RX, but not go backwards.
     index: u16,
 
     /// Expected next frame number. Allowed to skip values on RX, but not go backwards.
     index: u16,


@@ -552,7 +604,7 @@ impl PendingPacket {
             )
         };
         let mut payload = [0u8; 25];
             )
         };
         let mut payload = [0u8; 25];

-        payload.copy_from_slice(
+        payload[0..data_len].copy_from_slice(

             &self.app_data[self.app_data_transmitted..(self.app_data_transmitted + data_len)],
         );
         self.app_data_transmitted += data_len;
             &self.app_data[self.app_data_transmitted..(self.app_data_transmitted + data_len)],
         );
         self.app_data_transmitted += data_len;