Struct Queue 

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

Queue types for inter-task communication. 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 new(size: UBaseType, message_size: UBaseType) -> Result<Self>

Creates a new queue.

Parameters

• size - Maximum number of messages the queue can hold
• message_size - Size in bytes of each message

Returns

• Ok(Self) - Successfully created queue
• Err(Error) - Creation failed (insufficient memory, etc.)

Examples

use osal_rs::os::{Queue, QueueFn};
 
// Queue for 5 messages of 16 bytes each
let queue = Queue::new(5, 16).unwrap();

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

Receives data from the queue with a convertible timeout.

This is a convenience method that accepts any type implementing ToTick (like Duration) and converts it to ticks before calling fetch().

Arguments

• buffer - Mutable slice to receive data into
• time - Timeout value (e.g., Duration::from_millis(100))

Returns

• Ok(()) - Data successfully received
• Err(Error::Timeout) - No data available within timeout

Examples

use osal_rs::os::{Queue, QueueFn};
use core::time::Duration;
 
let queue = Queue::new(5, 16).unwrap();
let mut buffer = [0u8; 16];
queue.fetch_with_to_tick(&mut buffer, Duration::from_millis(100))?;

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

Sends data to the queue with a convertible timeout.

This is a convenience method that accepts any type implementing ToTick (like Duration) and converts it to ticks before calling post().

Arguments

• item - Slice of data to send
• time - Timeout value (e.g., Duration::from_millis(100))

Returns

• Ok(()) - Data successfully sent
• Err(Error::Timeout) - Queue full, could not send within timeout

Examples

use osal_rs::os::{Queue, QueueFn};
use core::time::Duration;
 
let queue = Queue::new(5, 16).unwrap();
let data = [1u8, 2, 3, 4];
queue.post_with_to_tick(&data, Duration::from_millis(100))?;

Trait Implementations

impl Debug for Queue

Formats the queue for debugging purposes.

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

Formats the value using the given formatter.

impl Deref for Queue

Allows dereferencing to the underlying FreeRTOS queue handle.

type Target = *const c_void

The resulting type after dereferencing.

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

Dereferences the value.

impl Display for Queue

Formats the queue for display purposes.

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

Formats the value using the given formatter.

impl Drop for Queue

Automatically deletes the queue when it goes out of scope.

This ensures proper cleanup of FreeRTOS resources.

fn drop(&mut self)

Executes the destructor for this type.

impl Queue for Queue

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

Receives data from the queue, blocking until data is available or timeout.

This function blocks the calling thread until data is available or the specified timeout expires.

Arguments

• buffer - Mutable byte slice to receive data into
• time - Timeout in system ticks (0 = no wait, MAX = wait forever)

Returns

• Ok(()) - Data successfully received into buffer
• Err(Error::Timeout) - No data available within timeout period

Examples

use osal_rs::os::{Queue, QueueFn};
 
let queue = Queue::new(5, 16).unwrap();
let mut buffer = [0u8; 16];
 
// Wait up to 1000 ticks for data
match queue.fetch(&mut buffer, 1000) {
    Ok(()) => println!("Received data: {:?}", buffer),
    Err(_) => println!("Timeout"),
}

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

Receives data from the queue in an interrupt service routine (ISR).

This is the ISR-safe version of fetch(). It does not block and will trigger a context switch if a higher priority task is woken.

Arguments

• buffer - Mutable byte slice to receive data into

Returns

• Ok(()) - Data successfully received
• Err(Error::Timeout) - Queue is empty

Safety

Must only be called from ISR context.

Examples

// In interrupt handler
use osal_rs::os::{Queue, QueueFn};
 
fn irq_handler(queue: &Queue) {
    let mut buffer = [0u8; 16];
    if queue.fetch_from_isr(&mut buffer).is_ok() {
        // Process received data
    }
}

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

Sends data to the back of the queue, blocking until space is available.

This function blocks the calling thread until space becomes available or the timeout expires.

Arguments

• item - Byte slice to send
• time - Timeout in system ticks (0 = no wait, MAX = wait forever)

Returns

• Ok(()) - Data successfully sent
• Err(Error::Timeout) - Queue full, could not send within timeout

Examples

use osal_rs::os::{Queue, QueueFn};
 
let queue = Queue::new(5, 16).unwrap();
let data = [0xAA, 0xBB, 0xCC, 0xDD];
 
// Wait up to 1000 ticks to send
queue.post(&data, 1000)?;

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

Sends data to the queue from an interrupt service routine (ISR).

This is the ISR-safe version of post(). It does not block and will trigger a context switch if a higher priority task is woken.

Arguments

• item - Byte slice to send

Returns

• Ok(()) - Data successfully sent
• Err(Error::Timeout) - Queue is full

Safety

Must only be called from ISR context.

Examples

// In interrupt handler
use osal_rs::os::{Queue, QueueFn};
 
fn irq_handler(queue: &Queue) {
    let data = [0x01, 0x02, 0x03];
    queue.post_from_isr(&data).ok();
}

fn delete(&mut self)

Deletes the queue and frees its resources.

This function destroys the queue and releases any memory allocated for it. After calling this, the queue should not be used. The handle is set to null.

Safety

Ensure no threads are waiting on this queue before deleting it.

Examples

use osal_rs::os::{Queue, QueueFn};
 
let mut queue = Queue::new(5, 16).unwrap();
// Use the queue...
queue.delete();

impl Send for Queue

impl Sync for Queue