Struct Queue 

pub struct Queue(/* private fields */);

A FIFO queue for byte-based message passing.

Provides a thread-safe queue implementation for sending and receiving raw byte slices between threads. Supports both blocking and ISR-safe operations.

Examples

Basic queue usage

use osal_rs::os::{Queue, QueueFn};
use core::time::Duration;
 
// Create a queue with 10 slots, each 32 bytes
let queue = Queue::new(10, 32).unwrap();
 
// Send data
let data = [1u8, 2, 3, 4];
queue.post_with_to_tick(&data, Duration::from_millis(100)).unwrap();
 
// Receive data
let mut buffer = [0u8; 4];
queue.fetch_with_to_tick(&mut buffer, Duration::from_millis(100)).unwrap();
assert_eq!(buffer, [1, 2, 3, 4]);

Producer-consumer pattern

use osal_rs::os::{Queue, QueueFn, Thread};
use alloc::sync::Arc;
use core::time::Duration;
 
let queue = Arc::new(Queue::new(5, 4).unwrap());
let queue_clone = queue.clone();
 
// Consumer thread
let consumer = Thread::new("consumer", 2048, 5, move || {
    let mut buffer = [0u8; 4];
    loop {
        if queue_clone.fetch(&mut buffer, 1000).is_ok() {
            println!("Received: {:?}", buffer);
        }
    }
}).unwrap();
 
consumer.start().unwrap();
 
// Producer
let data = [0xAA, 0xBB, 0xCC, 0xDD];
queue.post(&data, 1000).unwrap();

Implementations

impl Queue

pub fn fetch_with_to_tick( &self, buffer: &mut [u8], time: impl ToTick, ) -> Result<()>

pub fn post_with_to_tick(&self, item: &[u8], time: impl ToTick) -> Result<()>

Trait Implementations

impl Debug for Queue

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

Formats the value using the given formatter.

impl Deref for Queue

type Target = *const c_void

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for Queue

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

Formats the value using the given formatter.

impl Drop for Queue

fn drop(&mut self)

Executes the destructor for this type.

impl Queue for Queue

fn new(size: UBaseType, message_size: UBaseType) -> Result<Self>

fn fetch(&self, buffer: &mut [u8], time: TickType) -> Result<()>

fn fetch_from_isr(&self, buffer: &mut [u8]) -> Result<()>

fn post(&self, item: &[u8], time: TickType) -> Result<()>

fn post_from_isr(&self, item: &[u8]) -> Result<()>

fn delete(&mut self)

impl Send for Queue

impl Sync for Queue