Struct RawMutexGuard 

pub struct RawMutexGuard<M: RawMutex + 'static>(/* private fields */);

All OSAL trait definitions for advanced usage. RAII guard for a 'static RawMutex implementation.

Locks the mutex on construction and unlocks it on drop, so callers only need to hold on to the guard for the duration of the critical section. This is intended for the common pattern of a module-level static mut Option<M> mutex guarding a module-level static mut resource, e.g. obtained via access_static_option!.

Examples

use osal_rs::access_static_option;
use osal_rs::os::*;

static mut MUTEX: Option<RawMutex> = None;

fn critical_section() {
    let _lock = RawMutexGuard::acquire(access_static_option!(MUTEX));
    // protected code here, lock released when `_lock` drops
}

// Initialization phase: create the mutex before anyone locks it.
unsafe { MUTEX = Some(RawMutex::new().unwrap()) };

critical_section();
critical_section(); // the previous lock was released on drop

Implementations

impl<M: RawMutex + 'static> RawMutexGuard<M>

pub fn acquire(mutex: &'static M) -> Self

Locks mutex and returns a guard that unlocks it on drop.

pub fn acquire_from_isr(mutex: &'static M) -> Self

Locks mutex via RawMutex::lock_from_isr instead of RawMutex::lock, and returns a guard that unlocks the same way on drop. Use this instead of RawMutexGuard::acquire when the calling context is (or might be) an interrupt handler.

Trait Implementations

impl<M: RawMutex + 'static> Drop for RawMutexGuard<M>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.