Struct Stack 

pub struct Stack<'a> { /* private fields */ }

Cheap (Copy) handle to a Stack. Pass to user tasks; clone freely.

Implementations

impl<'a> Stack<'a>

pub fn new<TRX, const N_RX: usize>( trx: TRX, address: Address, resources: &'a mut StackResources<N_RX>, timing: MacTiming, ) -> (Stack<'a>, Runner<'a, TRX>)

Splits caller-allocated resources into a Stack handle and a Runner that owns the radio. After this call the resources are pinned in place via the returned references.

pub fn address(&self) -> Address

The local address this Stack was constructed with.

pub fn link_state(&self) -> LinkState

Current snapshot of the radio link state. See module-level docs for the transition rules.

pub fn is_link_up(&self) -> bool

true iff Stack::link_state is LinkState::Up.

pub async fn wait_link_up(&self)

Resolves when the link state is (or becomes) LinkState::Up. Returns immediately if already up.

Only one task may hold this future at a time; running it in two tasks concurrently is undefined (one will be woken on the next transition, the other can stay parked).

pub async fn wait_link_down(&self)

Resolves when the link state is (or becomes) LinkState::Down. Returns immediately if already down. Same single-waiter caveat as Stack::wait_link_up.

pub async fn send( &self, dst: Address, flags: Flags, data: &[u8], ) -> Result<(), TxError>

Send data to dst with the given flags. Serialized across all concurrent callers via an internal mutex (the radio is half-duplex, so only one TX flies at a time anyway).

The order under the lock is lock → reset response → enqueue request → await response, in that order. Resetting under the lock is the cancellation-safety invariant: a previously-cancelled caller may have left a stale value in the Signal, and clearing it before posting our own request makes sure we wait for the response to our TX, not the dead one’s. See the module-level docs.

pub async fn recv(&self) -> Packet

Wait for the next packet addressed to this Stack (Unicast match) or to Address::Broadcast. Other unicasts are filtered out by the Runner before they reach the queue.

Trait Implementations

impl<'a> Clone for Stack<'a>

fn clone(&self) -> Stack<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for Stack<'a>