Struct EventGroup 

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

A set of event flags for thread synchronization.

Event groups contain multiple event bits (typically 24 bits) that can be manipulated independently. Threads can wait for specific combinations of bits to be set, making them ideal for complex synchronization scenarios.

Examples

Basic event signaling

use osal_rs::os::{EventGroup, EventGroupFn};
use core::time::Duration;
 
const EVENT_A: u32 = 0b0001;
const EVENT_B: u32 = 0b0010;
const EVENT_C: u32 = 0b0100;
 
let events = EventGroup::new().unwrap();
 
// Set event A
events.set(EVENT_A);
 
// Check if event A is set
let current = events.get();
if current & EVENT_A != 0 {
    println!("Event A is set");
}
 
// Clear event A
events.clear(EVENT_A);

Waiting for multiple events

use osal_rs::os::{EventGroup, EventGroupFn, Thread};
use alloc::sync::Arc;
use core::time::Duration;
 
const READY: u32 = 0b0001;
const DATA_AVAILABLE: u32 = 0b0010;
const STOP: u32 = 0b0100;
 
let events = Arc::new(EventGroup::new().unwrap());
let events_clone = events.clone();
 
// Worker thread waits for events
let worker = Thread::new("worker", 2048, 5, move || {
    loop {
        // Wait for either READY or STOP
        let bits = events_clone.wait_with_to_tick(
            READY | STOP,
            Duration::from_secs(1)
        );
         
        if bits & STOP != 0 {
            println!("Stopping...");
            break;
        }
         
        if bits & READY != 0 {
            println!("Ready to work!");
        }
    }
}).unwrap();
 
worker.start().unwrap();
 
// Signal events
events.set(READY);
Duration::from_secs(2).sleep();
events.set(STOP);

State machine synchronization

use osal_rs::os::{EventGroup, EventGroupFn};
use core::time::Duration;
 
const INIT_COMPLETE: u32 = 1 << 0;
const CONFIG_LOADED: u32 = 1 << 1;
const NETWORK_UP: u32 = 1 << 2;
const READY_TO_RUN: u32 = INIT_COMPLETE | CONFIG_LOADED | NETWORK_UP;
 
let state = EventGroup::new().unwrap();
 
// Different subsystems set their bits
state.set(INIT_COMPLETE);
state.set(CONFIG_LOADED);
state.set(NETWORK_UP);
 
// Wait for all systems to be ready
let current = state.wait_with_to_tick(READY_TO_RUN, Duration::from_secs(5));
 
if (current & READY_TO_RUN) == READY_TO_RUN {
    println!("All systems ready!");
}

ISR to thread signaling

use osal_rs::os::{EventGroup, EventGroupFn, Thread};
use alloc::sync::Arc;
 
const IRQ_EVENT: u32 = 1 << 0;
 
let events = Arc::new(EventGroup::new().unwrap());
let events_isr = events.clone();
 
// In interrupt handler:
// events_isr.set_from_isr(IRQ_EVENT).ok();
 
// Handler thread
let handler = Thread::new("handler", 2048, 5, move || {
    loop {
        let bits = events.wait(IRQ_EVENT, 1000);
        if bits & IRQ_EVENT != 0 {
            println!("Handling interrupt event");
            events.clear(IRQ_EVENT);
        }
    }
}).unwrap();

Implementations

impl EventGroup

pub fn wait_with_to_tick( &self, mask: EventBits, timeout_ticks: impl ToTick, ) -> EventBits

impl EventGroup

pub fn new() -> Result<Self>

Creates a new event group.

Returns

• Ok(Self) - Successfully created event group
• Err(Error) - Creation failed (out of memory, etc.)

Examples

use osal_rs::os::{EventGroup, EventGroupFn};
 
let events = EventGroup::new().unwrap();

Trait Implementations

impl Debug for EventGroup

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

Formats the value using the given formatter.

impl Deref for EventGroup

type Target = *const c_void

The resulting type after dereferencing.

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

Dereferences the value.

impl Display for EventGroup

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

Formats the value using the given formatter.

impl Drop for EventGroup

fn drop(&mut self)

Executes the destructor for this type.

impl EventGroup for EventGroup

fn set(&self, bits: EventBits) -> EventBits

Sets the specified event bits.

fn set_from_isr(&self, bits: EventBits) -> Result<()>

Sets event bits from an interrupt service routine.

fn get(&self) -> EventBits

Gets the current value of the event bits.

fn get_from_isr(&self) -> EventBits

Gets event bits from an interrupt service routine.

fn clear(&self, bits: EventBits) -> EventBits

Clears the specified event bits.

fn clear_from_isr(&self, bits: EventBits) -> Result<()>

Clears event bits from an interrupt service routine.

fn wait(&self, mask: EventBits, timeout_ticks: TickType) -> EventBits

Waits for specific event bits to be set.

fn delete(&mut self)

Deletes the event group and frees its resources.

impl Send for EventGroup

impl Sync for EventGroup