support variable length packets

src/error.rs

@@ -23,12 +23,21 @@ pub enum TransferError<SE: Debug> {
     SpiError(SE),
 }
 
+#[derive(Debug)]
+pub enum TxError<SE: Debug> {
+    // Given slice was bigger than the maximum packet size
+    TooMuchData,
+    SpiError(SE),
+}
+
 pub(crate) trait SpiErrorToOtherError<T, E: Debug> {
     fn re(self) -> Result<T, RfError<E>>
     where
         Self: Sized;
 
     fn te(self) -> Result<T, TransferError<E>>;
+
+    fn txe(self) -> Result<T, TxError<E>>;
 }
 
 impl<T, E: Debug> SpiErrorToOtherError<T, E> for Result<T, E> {
@@ -39,4 +48,8 @@ impl<T, E: Debug> SpiErrorToOtherError<T, E> for Result<T, E> {
     fn te(self) -> Result<T, TransferError<E>> {
         self.map_err(|e| TransferError::SpiError(e))
     }
+
+    fn txe(self) -> Result<T, TxError<E>> {
+        self.map_err(|e| TxError::SpiError(e))
+    }
 }

src/internal_state.rs

@@ -11,5 +11,6 @@ pub enum InternalState<const PACKET_LEN: usize> {
     Tx {
         data: [u8; PACKET_LEN],
         i: usize,
+        len: usize,
     },
 }

src/lib.rs

@@ -5,6 +5,7 @@ mod consts;
 pub mod error;
 mod internal_radio;
 mod internal_state;
+pub mod rx;
 pub(crate) mod state;
 
 use core::{convert::Infallible, fmt::Debug};
@@ -14,25 +15,26 @@ use embedded_hal::{
 };
 
 use consts::*;
-use error::{RfError, SpiErrorToOtherError, TransferError};
+use error::{RfError, SpiErrorToOtherError, TransferError, TxError};
 use internal_state::InternalState;
+use rx::RxPacket;
 use state::State;
 
 use crate::internal_radio::InternalRadio;
 
-pub struct Rf4463<const PACKET_LEN: usize, Spi, SdnPin, CsPin, Delay> {
+pub struct Rf4463<const MAX_PACKET_LEN: usize, Spi, SdnPin, CsPin, Delay> {
     radio: InternalRadio<Spi, SdnPin, CsPin, Delay>,
-    state: InternalState<PACKET_LEN>,
+    state: InternalState<MAX_PACKET_LEN>,
     rx_forever: bool,
 }
 
 impl<
-        const PACKET_LEN: usize,
+        const MAX_PACKET_LEN: usize,
         Spi: Transfer<u8>,
         SdnPin: OutputPin<Error = Infallible>,
         CsPin: OutputPin<Error = Infallible>,
         Delay: DelayUs<u16>,
-    > Rf4463<PACKET_LEN, Spi, SdnPin, CsPin, Delay>
+    > Rf4463<MAX_PACKET_LEN, Spi, SdnPin, CsPin, Delay>
 where
     Spi::Error: Debug,
 {
@@ -44,7 +46,7 @@ where
         config: &mut [u8],
     ) -> Result<Self, RfError<Spi::Error>> {
         assert!(
-            PACKET_LEN < 8192,
+            MAX_PACKET_LEN < 8192,
             "Packet length cannot be above 8191 bytes"
         );
 
@@ -78,7 +80,7 @@ where
         self.radio.clear_ph_and_modem_interrupts()?;
 
         self.state = InternalState::Rx {
-            data: [0; PACKET_LEN],
+            data: [0; MAX_PACKET_LEN],
             i: 0,
             received: false,
             rssi: None,
@@ -88,8 +90,8 @@ where
             START_RX,
             0,
             0,
-            (PACKET_LEN >> 8).try_into().unwrap(),
-            (PACKET_LEN & 0xff).try_into().unwrap(),
+            (MAX_PACKET_LEN >> 8).try_into().unwrap(),
+            (MAX_PACKET_LEN & 0xff).try_into().unwrap(),
             State::Rx.into(),
             if rx_forever {
                 State::Rx.into()
@@ -104,26 +106,26 @@ where
         Ok(())
     }
 
-    pub fn finish_rx(&mut self) -> Result<Option<([u8; PACKET_LEN], f64)>, Spi::Error> {
+    pub fn finish_rx(&mut self) -> Result<Option<RxPacket<MAX_PACKET_LEN>>, Spi::Error> {
         let pkt = match self.state {
             InternalState::Rx {
                 data,
                 received,
                 i,
                 rssi,
-            } if i == PACKET_LEN && received => {
+            } if received => {
                 let rssi = match rssi {
                     Some(x) => x,
                     None => self.get_rssi()?,
                 };
 
-                let ret = Some((data, rssi));
+                let ret = Some(RxPacket::new(data, i, rssi));
 
                 if self.rx_forever {
                     self.radio.clear_ph_and_modem_interrupts()?;
 
                     self.state = InternalState::Rx {
-                        data: [0; PACKET_LEN],
+                        data: [0; MAX_PACKET_LEN],
                         i: 0,
                         received: false,
                         rssi: None,
@@ -141,31 +143,46 @@ where
         Ok(pkt)
     }
 
-    pub fn start_tx(&mut self, mut data: [u8; PACKET_LEN]) -> Result<(), Spi::Error> {
-        self.radio.clear_fifo()?;
-        self.radio.clear_ph_and_modem_interrupts()?;
+    pub fn start_tx(&mut self, data: &[u8]) -> Result<(), TxError<Spi::Error>> {
+        let len = data.len();
+        if len > MAX_PACKET_LEN {
+            return Err(TxError::TooMuchData);
+        }
+
+        self.radio.clear_fifo().txe()?;
+        self.radio.clear_ph_and_modem_interrupts().txe()?;
 
         // 128-byte TX buffer
         let i = data.len().min(128);
+        let mut segment = [0; 128];
+        segment[..i].copy_from_slice(&data[..i]);
 
         self.radio.with_cs(|s| {
-            s.spi_transfer_byte(WRITE_TX_FIFO)?;
-            s.spi.transfer(&mut data[0..i])?;
+            s.spi_transfer_byte(WRITE_TX_FIFO).txe()?;
+            s.spi.transfer(&mut segment[..i]).txe()?;
 
             Ok(())
         })?;
 
-        self.radio.send_command::<0>(&mut [
-            START_TX,
-            0,
-            u8::from(State::Sleep) << 4,
-            (PACKET_LEN >> 8).try_into().unwrap(),
-            (PACKET_LEN & 0xff).try_into().unwrap(),
-            0,
-            0,
-        ])?;
-
-        self.state = InternalState::Tx { data, i };
+        self.radio
+            .send_command::<0>(&mut [
+                START_TX,
+                0,
+                u8::from(State::Sleep) << 4,
+                (MAX_PACKET_LEN >> 8).try_into().unwrap(),
+                (MAX_PACKET_LEN & 0xff).try_into().unwrap(),
+                0,
+                0,
+            ])
+            .txe()?;
+
+        let mut padded_data = [0; MAX_PACKET_LEN];
+        padded_data[0..len].copy_from_slice(data);
+        self.state = InternalState::Tx {
+            data: padded_data,
+            i,
+            len,
+        };
 
         Ok(())
     }
@@ -219,12 +236,12 @@ where
             _ => return Ok(()),
         };
 
-        let len: usize = self.radio.rx_fifo_len().te()?.into();
-        if len == 0 {
+        let fifo_len: usize = self.radio.rx_fifo_len().te()?.into();
+        if fifo_len == 0 {
             return Ok(());
         }
 
-        if len + *i > PACKET_LEN {
+        if fifo_len + *i > MAX_PACKET_LEN {
             return Err(TransferError::TooMuchData);
         }
 
@@ -232,7 +249,7 @@ where
             return Err(TransferError::FifoOverflow);
         }
 
-        let data = &mut data[*i..(*i + len)];
+        let data = &mut data[*i..(*i + fifo_len)];
         self.radio
             .with_cs(|s| {
                 s.spi_transfer_byte(READ_RX_FIFO)?;
@@ -246,14 +263,14 @@ where
             *rssi = Some(self.radio.get_rssi().te()?)
         }
 
-        *i += len;
+        *i += fifo_len;
 
         Ok(())
     }
 
     fn tx_step(&mut self) -> Result<(), TransferError<Spi::Error>> {
         let (data, i) = match &mut self.state {
-            InternalState::Tx { data, i, .. } => (data, i),
+            InternalState::Tx { data, i, len } => (&mut data[0..*len], i),
             _ => return Ok(()),
         };
 

src/rx.rs

+pub struct RxPacket<const N: usize> {
+    data: [u8; N],
+    i: usize,
+    rssi: f64,
+}
+
+impl<const N: usize> RxPacket<N> {
+    pub(crate) fn new(data: [u8; N], i: usize, rssi: f64) -> Self {
+        Self { data, i, rssi }
+    }
+
+    pub fn data(&self) -> &[u8] {
+        &self.data[..self.i]
+    }
+
+    pub fn rssi(&self) -> f64 {
+        self.rssi
+    }
+}