Struct RawMutex 

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

Mutex types and guards for mutual exclusion. Low-level recursive mutex wrapper for FreeRTOS.

This is the underlying implementation of the mutex that directly interfaces with FreeRTOS semaphore APIs. It’s recursive, meaning the same thread can lock it multiple times.

Note

Users should typically use Mutex<T> instead, which provides type-safe data protection. This type is exposed for advanced use cases.

Implementations

impl RawMutex

pub fn new() -> Result<Self>

Creates a new raw recursive mutex.

Returns

• Ok(RawMutex) - Successfully created
• Err(Error::OutOf Memory) - Failed to allocate mutex resources

Trait Implementations

impl Debug for RawMutex

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

Formats the value using the given formatter.

impl Deref for RawMutex

Allows dereferencing to the underlying FreeRTOS mutex handle.

type Target = *const c_void

The resulting type after dereferencing.

fn deref(&self) -> &MutexHandle

Dereferences the value.

impl Display for RawMutex

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

Formats the value using the given formatter.

impl Drop for RawMutex

Automatically deletes the mutex when it goes out of scope.

This ensures proper cleanup of FreeRTOS resources.

fn drop(&mut self)

Executes the destructor for this type.

impl RawMutex for RawMutex

fn lock(&self) -> OsalRsBool

Attempts to acquire the mutex, blocking until it becomes available.

This function will block the calling thread until the mutex can be acquired. Since this is a recursive mutex, the same thread can lock it multiple times.

Returns

• OsalRsBool::True - Successfully acquired the mutex
• OsalRsBool::False - Failed to acquire (should not happen with MAX_DELAY)

Examples

use osal_rs::os::RawMutex;
use osal_rs::traits::RawMutexFn;
 
let mutex = RawMutex::new().unwrap();
if mutex.lock() == OsalRsBool::True {
    // Critical section
    mutex.unlock();
}

fn lock_from_isr(&self) -> OsalRsBool

Attempts to acquire the mutex from an interrupt service routine (ISR).

This is the ISR-safe version of lock(). It attempts to acquire the mutex without blocking. If a higher priority task is woken, a context switch is triggered.

Returns

• OsalRsBool::True - Successfully acquired the mutex
• OsalRsBool::False - Mutex is already locked

Safety

Must only be called from ISR context.

Examples

// In interrupt handler
use osal_rs::os::RawMutex;
use osal_rs::traits::RawMutexFn;
 
fn irq_handler(mutex: &RawMutex) {
    if mutex.lock_from_isr() == OsalRsBool::True {
        // Critical section
        mutex.unlock_from_isr();
    }
}

fn unlock(&self) -> OsalRsBool

Releases the mutex.

For recursive mutexes, this must be called as many times as lock() was called to fully release the mutex.

Returns

• OsalRsBool::True - Successfully released the mutex
• OsalRsBool::False - Failed to release (e.g., not locked by current thread)

Examples

use osal_rs::os::RawMutex;
use osal_rs::traits::RawMutexFn;
 
let mutex = RawMutex::new().unwrap();
mutex.lock();
// Critical section
mutex.unlock();

fn unlock_from_isr(&self) -> OsalRsBool

Releases the mutex from an interrupt service routine (ISR).

This is the ISR-safe version of unlock(). If a higher priority task is woken by releasing the mutex, a context switch is triggered.

Returns

• OsalRsBool::True - Successfully released the mutex
• OsalRsBool::False - Failed to release

Safety

Must only be called from ISR context.

Examples

// In interrupt handler
use osal_rs::os::RawMutex;
use osal_rs::traits::RawMutexFn;
 
fn irq_handler(mutex: &RawMutex) {
    if mutex.lock_from_isr() == OsalRsBool::True {
        // Critical section
        mutex.unlock_from_isr();
    }
}

fn delete(&mut self)

Deletes the mutex and frees its resources.

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

Safety

Ensure no threads are waiting on or holding this mutex before deleting it.

Examples

use osal_rs::os::RawMutex;
use osal_rs::traits::RawMutexFn;
 
let mut mutex = RawMutex::new().unwrap();
// Use the mutex...
mutex.delete();

impl Send for RawMutex

impl Sync for RawMutex