/// 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.
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,
+ });
}
}
}
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: 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,
});
}
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;
}
- _ => (),
}
+ // TODO: should expire packet rx if we have not received a frame for a while
+ // otherwise we could pick up the LSF from one station and FinalFrame from another
}
pub fn ptt(&self) -> bool {
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);
}
}
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;
}
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;
}
}
+impl Default for SoftTnc {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
#[derive(Debug, PartialEq, Eq, Clone)]
pub enum SoftTncError {
General(&'static str),
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,
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,
)
};
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;
mod tests {
use super::*;
use crate::kiss::{KissCommand, PORT_STREAM};
- use crate::protocol::StreamFrame;
+ use crate::protocol::{PacketType, StreamFrame};
+
+ #[test]
+ fn tnc_receive_single_frame_packet() {
+ let lsf = LsfFrame::new_packet(
+ &Address::Callsign(Callsign(*b"VK7XT ")),
+ &Address::Broadcast,
+ );
+ let mut payload = [0u8; 25];
+ let (pt, pt_len) = PacketType::Sms.as_proto();
+ payload[0..pt_len].copy_from_slice(&pt[0..pt_len]);
+ payload[pt_len] = 0x41; // a message
+ let crc = crate::crc::m17_crc(&payload[0..=pt_len]).to_be_bytes();
+ payload[pt_len + 1] = crc[0];
+ payload[pt_len + 2] = crc[1];
+
+ let packet = PacketFrame {
+ payload,
+ counter: PacketFrameCounter::FinalFrame {
+ payload_len: pt_len + 3,
+ },
+ };
+ let mut tnc = SoftTnc::new();
+ let mut kiss = KissFrame::new_empty();
+
+ // TNC consumes LSF but has nothing to report yet
+ tnc.handle_frame(Frame::Lsf(lsf));
+ assert_eq!(tnc.read_kiss(&mut kiss.data), 0);
+
+ // TODO: when support is added for the basic packet port they could arrive in either order
+
+ tnc.handle_frame(Frame::Packet(packet));
+ kiss.len = tnc.read_kiss(&mut kiss.data);
+ assert_eq!(kiss.command().unwrap(), KissCommand::DataFrame);
+ assert_eq!(kiss.port().unwrap(), PORT_PACKET_FULL);
+
+ let mut payload_buf = [0u8; 2048];
+ let n = kiss.decode_payload(&mut payload_buf).unwrap();
+ assert_eq!(n, 30 + 1 + pt_len + 2);
+
+ // did we receive our message? (after the LSF)
+ assert_eq!(payload_buf[pt_len + 30], 0x41);
+ }
+
+ #[test]
+ fn tnc_receive_multiple_frame_packet() {
+ let lsf = LsfFrame::new_packet(
+ &Address::Callsign(Callsign(*b"VK7XT ")),
+ &Address::Broadcast,
+ );
+ let mut payload = [0x41u8; 26]; // spans two frames
+ let (pt, pt_len) = PacketType::Sms.as_proto();
+ payload[0..pt_len].copy_from_slice(&pt[0..pt_len]);
+ let crc = crate::crc::m17_crc(&payload[0..24]).to_be_bytes();
+ payload[24] = crc[0];
+ payload[25] = crc[1];
+
+ let packet1 = PacketFrame {
+ payload: payload[0..25].try_into().unwrap(),
+ counter: PacketFrameCounter::Frame { index: 0 },
+ };
+ let mut payload2 = [0u8; 25];
+ payload2[0] = payload[25];
+ let packet2 = PacketFrame {
+ payload: payload2,
+ counter: PacketFrameCounter::FinalFrame { payload_len: 1 },
+ };
- // TODO: finish all handle_frame tests as below
- // this will be much more straightforward when we have a way to create LSFs programatically
+ let mut tnc = SoftTnc::new();
+ let mut kiss = KissFrame::new_empty();
+
+ // Nothing to report until second final packet frame received
+ tnc.handle_frame(Frame::Lsf(lsf));
+ assert_eq!(tnc.read_kiss(&mut kiss.data), 0);
+ tnc.handle_frame(Frame::Packet(packet1));
+ assert_eq!(tnc.read_kiss(&mut kiss.data), 0);
+
+ tnc.handle_frame(Frame::Packet(packet2));
+ kiss.len = tnc.read_kiss(&mut kiss.data);
+ assert_eq!(kiss.command().unwrap(), KissCommand::DataFrame);
+ assert_eq!(kiss.port().unwrap(), PORT_PACKET_FULL);
- // receiving a single-frame packet
+ let mut payload_buf = [0u8; 2048];
+ let n = kiss.decode_payload(&mut payload_buf).unwrap();
+ assert_eq!(n, 30 + 26);
- // receiving a multi-frame packet
+ // did we receive our message? (after the LSF)
+ assert_eq!(payload_buf[pt_len + 30], 0x41);
+ }
- // part of one packet and then another
+ #[test]
+ fn tnc_receive_partial_packet() {
+ let lsf = LsfFrame::new_packet(
+ &Address::Callsign(Callsign(*b"VK7XT ")),
+ &Address::Broadcast,
+ );
+ let mut payload = [0x41u8; 26]; // spans two frames
+ let (pt, pt_len) = PacketType::Sms.as_proto();
+ payload[0..pt_len].copy_from_slice(&pt[0..pt_len]);
+ let crc = crate::crc::m17_crc(&payload[0..24]).to_be_bytes();
+ payload[24] = crc[0];
+ payload[25] = crc[1];
+
+ let packet1 = PacketFrame {
+ payload: payload[0..25].try_into().unwrap(),
+ counter: PacketFrameCounter::Frame { index: 0 },
+ };
+ // final frame of this transmission is dropped
+
+ let lsf2 = LsfFrame::new_packet(
+ &Address::Callsign(Callsign(*b"VK7XT ")),
+ &Address::Broadcast,
+ );
+ let mut payload = [0u8; 25];
+ let (pt, pt_len) = PacketType::Sms.as_proto();
+ payload[0..pt_len].copy_from_slice(&pt[0..pt_len]);
+ payload[pt_len] = 0x42;
+ let crc = crate::crc::m17_crc(&payload[0..=pt_len]).to_be_bytes();
+ payload[pt_len + 1] = crc[0];
+ payload[pt_len + 2] = crc[1];
+
+ let packet2 = PacketFrame {
+ payload: payload[0..25].try_into().unwrap(),
+ counter: PacketFrameCounter::FinalFrame {
+ payload_len: pt_len + 3,
+ },
+ };
+
+ let mut tnc = SoftTnc::new();
+ let mut kiss = KissFrame::new_empty();
+
+ // Nothing to report until second packet received in its entirety
+ tnc.handle_frame(Frame::Lsf(lsf));
+ assert_eq!(tnc.read_kiss(&mut kiss.data), 0);
+ tnc.handle_frame(Frame::Packet(packet1));
+ assert_eq!(tnc.read_kiss(&mut kiss.data), 0);
+ tnc.handle_frame(Frame::Lsf(lsf2));
+ assert_eq!(tnc.read_kiss(&mut kiss.data), 0);
+ tnc.handle_frame(Frame::Packet(packet2));
+
+ kiss.len = tnc.read_kiss(&mut kiss.data);
+ assert_eq!(kiss.command().unwrap(), KissCommand::DataFrame);
+ assert_eq!(kiss.port().unwrap(), PORT_PACKET_FULL);
+
+ let mut payload_buf = [0u8; 2048];
+ let n = kiss.decode_payload(&mut payload_buf).unwrap();
+ assert_eq!(n, 30 + 1 + pt_len + 2);
+ // we have received the second packet which has 0x42 in it
+ assert_eq!(payload_buf[pt_len + 30], 0x42);
+ }
#[test]
fn tnc_receive_stream() {
projects / m17rt / blobdiff