Struct Packet 

pub struct Packet<'a, const N: usize> { /* private fields */ }

N is the maximum packet size we can handle Panics if N >= 8191

Implementations

impl<'a, const N: usize> Packet<'a, N>

pub fn new(buf: &'a mut [u8; N]) -> Self

pub fn clone_backing<'b>(&self, buf: &'b mut [u8; N]) -> Packet<'b, N>

pub fn decode(buf: Buffer<'a, N>) -> Result<Self, DecodeError>

Expects bytes in the buf buf is used as the backing buffer for the Packet

pub fn encode(&self) -> &[u8]

pub fn semi_encode(self) -> Result<Buffer<'a, N>, (EncodeError, Self)>

Directly after the CRC block in The Pipeline

pub fn semi_decode(buf: Buffer<'a, N>) -> Result<Self, DecodeError>

Directly after the CRC block in The Pipeline Expects bytes in the buf buf is used as the backing buffer for the Packet

pub fn fully_encode<const M: usize>( self, out: &mut Buffer<'_, M>, ) -> Result<(), EncodeError>

Encodes packet for transmission on the air. Includes the data length L, but does not include the preamble or sync word.

pub fn fully_decode( data: &[u8], buf: &'a mut [u8; N], ) -> Result<Self, DecodeError>

Decodes packet that was received over the air. Packet shouldn’t have preamble, sync word, or data langth L. Expects bytes in data buf is used as the backing buffer for the Packet

pub fn fully_decode_soft<const M: usize, T: DecodeFrom>( data: &mut [T], buf: &'a mut [u8; N], ) -> Result<Self, DecodeError>

Expects soft bits in data. Bits should be LLR, with positive numbers more likely to be 0. Returns DecodeError::Overflow if M is less than data.len().

pub fn iter(&self) -> ValidatedWhiskerIter<'_>

pub fn identification(&self) -> Option<Identification>

pub fn add_identification( &mut self, w: Identification, ) -> Result<(), EncodeError>

pub fn clear_identification(&mut self)

pub fn timestamp(&self) -> Option<Timestamp>

pub fn add_timestamp(&mut self, w: Timestamp) -> Result<(), EncodeError>

pub fn clear_timestamp(&mut self)

pub fn gps(&self) -> Option<Gps>

pub fn add_gps(&mut self, w: Gps) -> Result<(), EncodeError>

pub fn clear_gps(&mut self)

pub fn route(&self) -> Option<Route>

pub fn add_route(&mut self, w: Route) -> Result<(), EncodeError>

pub fn clear_route(&mut self)

pub fn node_info(&self) -> Option<NodeInfo>

pub fn add_node_info(&mut self, w: NodeInfo) -> Result<(), EncodeError>

pub fn clear_node_info(&mut self)

pub fn destination_iter( &self, ) -> FilterMap<ValidatedWhiskerIter<'_>, fn(Whisker) -> Option<Destination>>

pub fn add_destination(&mut self, w: Destination) -> Result<(), EncodeError>

pub fn clear_destination(&mut self)

pub fn arbitrary_iter( &self, ) -> FilterMap<ValidatedWhiskerIter<'_>, fn(Whisker) -> Option<Arbitrary>>

pub fn add_arbitrary(&mut self, w: Arbitrary) -> Result<(), EncodeError>

pub fn clear_arbitrary(&mut self)

pub fn comment<'b>(&self, buf: &'b mut [u8]) -> Result<&'b str, CommentError>

pub fn add_comment(&mut self, comment: &str) -> Result<(), EncodeError>

pub fn clear_comment(&mut self)

pub fn should_digipeat( &self, identity: Identity<'_>, ) -> Result<(), DigipeatError>

Given the callsign and ssid of a node, should it digipeat this packet? Takes into account things such as if we’ve digipeated it already, the max hops, etc.

pub fn append_to_route( &mut self, callsign: &str, ssid: u8, rssi: Option<f64>, ) -> Result<(), PacketRouteAppendError>

Note that if this fails due to a CATS overflow, it will wipe the route off of the packet

Trait Implementations

impl<const N: usize> Debug for Packet<'_, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.