Struct esb::buffer::EsbBuffer

pub struct EsbBuffer<OutgoingLen, IncomingLen> where
    OutgoingLen: ArrayLength<u8>,
    IncomingLen: ArrayLength<u8>,  {
    pub app_to_radio_buf: BBBuffer<OutgoingLen>,
    pub radio_to_app_buf: BBBuffer<IncomingLen>,
    pub timer_flag: AtomicBool,
}

This is the backing structure for the ESB interface

It is intended to live at 'static scope, and provides storage for the EsbApp and EsbIrq interfaces

Creating at static scope

Currently due to lacking const generics, the UX for this isn't great. You'll probably want something like this:

NOTE

Although the members of this struct are public, due to const generic limitations, they are not intended to be used directly, outside of static creation.

This could cause unintended, though not undefined, behavior.

TL;DR: It's not unsafe, but it's also not going to work correctly.

// This creates an ESB storage structure with room for
// 512 bytes of outgoing packets (including headers),
// and 256 bytes of incoming packets (including
// headers).
static BUFFER: EsbBuffer<U512, U256> = EsbBuffer {
    app_to_radio_buf: BBBuffer( ConstBBBuffer::new() ),
    radio_to_app_buf: BBBuffer( ConstBBBuffer::new() ),
    timer_flag: AtomicBool::new(false),
};

Fields

app_to_radio_buf: BBBuffer<OutgoingLen>

radio_to_app_buf: BBBuffer<IncomingLen>

timer_flag: AtomicBool

Implementations

impl<OutgoingLen, IncomingLen> EsbBuffer<OutgoingLen, IncomingLen> where
    OutgoingLen: ArrayLength<u8>,
    IncomingLen: ArrayLength<u8>, 

pub fn try_split<T: EsbTimer>(
    &'static self,
    timer: T,
    radio: RADIO,
    addresses: Addresses,
    config: Config
) -> Result<(EsbApp<OutgoingLen, IncomingLen>, EsbIrq<OutgoingLen, IncomingLen, T, Disabled>, IrqTimer<T>), Error>

Attempt to split the static buffer into handles for Interrupt and App context

This function will only succeed once. If the underlying buffers have also been split directly, this function will also fail.

Upon splitting, the Radio will be initialized and set to IdleTx.