Crate heapless

static friendly data structures that don't require dynamic memory allocation

Examples

Vec

use heapless::Vec;

let mut xs: Vec<u8, [u8; 4]> = Vec::new();

assert!(xs.push(0).is_ok());
assert!(xs.push(1).is_ok());
assert!(xs.push(2).is_ok());
assert!(xs.push(3).is_ok());
assert!(xs.push(4).is_err()); // full

assert_eq!(xs.pop(), Some(3));

RingBuffer

use heapless::RingBuffer;

let mut rb: RingBuffer<u8, [u8; 4]> = RingBuffer::new();

assert!(rb.enqueue(0).is_ok());
assert!(rb.enqueue(1).is_ok());
assert!(rb.enqueue(2).is_ok());
assert!(rb.enqueue(3).is_err()); // full

assert_eq!(rb.dequeue(), Some(0));

Single producer single consumer mode

use heapless::RingBuffer;

static mut RB: RingBuffer<Event, [Event; 4]> = RingBuffer::new();

enum Event { A, B }

fn main() {
    // NOTE(unsafe) beware of aliasing the `consumer` end point
    let mut consumer = unsafe { RB.split().1 };

    loop {
        // `dequeue` is a lockless operation
        match consumer.dequeue() {
            Some(Event::A) => { /* .. */ },
            Some(Event::B) => { /* .. */ },
            None => { /* sleep */},
        }
    }
}

// this is a different execution context that can preempt `main`
fn interrupt_handler() {
    // NOTE(unsafe) beware of aliasing the `producer` end point
    let mut producer = unsafe { RB.split().0 };

    // ..

    if condition {
        producer.enqueue(Event::A).unwrap();
    } else {
        producer.enqueue(Event::B).unwrap();
    }

    // ..
}

Reexports

pub use ring_buffer::RingBuffer;

Modules

ring_buffer

Ring buffer

Structs

BufferFullError	Error raised when the buffer is full
Vec	A Vec, vector, backed by a fixed size array