Struct Timer

Source

pub struct Timer {
    pub handle: TimerHandle,
    /* private fields */
}

Expand description

A software timer that executes a callback at regular intervals.

Timers can be configured as:

One-shot: Executes once after the specified period
Auto-reload: Executes repeatedly at the specified interval

Timer callbacks execute in the context of the timer daemon task, not in interrupt context. This means they can call most RTOS functions safely.

§Important Notes

Timer callbacks should complete quickly to avoid delaying other timers
Callbacks must not block indefinitely
Requires configUSE_TIMERS = 1 in FreeRTOSConfig.h

§Examples

§One-shot timer

use osal_rs::os::{Timer, TimerFn};
use core::time::Duration;
 
let timer = Timer::new_with_to_tick(
    "oneshot",
    Duration::from_secs(1),
    false,  // Not auto-reload (one-shot)
    None,
    |timer, param| {
        println!("Timer fired once!");
        Ok(param)
    }
).unwrap();
 
timer.start_with_to_tick(Duration::from_millis(10)).unwrap();

§Periodic timer

use osal_rs::os::{Timer, TimerFn};
use core::time::Duration;
 
let timer = Timer::new_with_to_tick(
    "periodic",
    Duration::from_millis(500),
    true,  // Auto-reload (periodic)
    None,
    |timer, param| {
        println!("Tick every 500ms");
        Ok(param)
    }
).unwrap();
 
timer.start_with_to_tick(Duration::from_millis(10)).unwrap();
 
// Stop after some time
Duration::from_secs(5).sleep();
timer.stop_with_to_tick(Duration::from_millis(10));

§Timer with custom parameters

use osal_rs::os::{Timer, TimerFn, TimerParam};
use alloc::sync::Arc;
use core::time::Duration;
 
struct CounterData {
    count: u32,
}
 
let data = Arc::new(CounterData { count: 0 });
let param: TimerParam = data.clone();
 
let timer = Timer::new_with_to_tick(
    "counter",
    Duration::from_secs(1),
    true,
    Some(param),
    |timer, param| {
        if let Some(param_arc) = param {
            if let Some(data) = param_arc.downcast_ref::<CounterData>() {
                println!("Counter: {}", data.count);
            }
        }
        Ok(None)
    }
).unwrap();
 
timer.start_with_to_tick(Duration::from_millis(10));

§Changing timer period

use osal_rs::os::{Timer, TimerFn};
use core::time::Duration;
 
let timer = Timer::new_with_to_tick(
    "adjustable",
    Duration::from_millis(100),
    true,
    None,
    |_, _| { println!("Tick"); Ok(None) }
).unwrap();
 
timer.start_with_to_tick(Duration::from_millis(10));
 
// Change period to 500ms
Duration::from_secs(2).sleep();
timer.change_period_with_to_tick(
    Duration::from_millis(500),
    Duration::from_millis(10)
);

§Resetting a timer

use osal_rs::os::{Timer, TimerFn};
use core::time::Duration;
 
let timer = Timer::new_with_to_tick(
    "watchdog",
    Duration::from_secs(5),
    false,
    None,
    |_, _| { println!("Timeout!"); Ok(None) }
).unwrap();
 
timer.start_with_to_tick(Duration::from_millis(10));
 
// Reset timer before it expires (like a watchdog)
Duration::from_secs(2).sleep();
timer.reset_with_to_tick(Duration::from_millis(10));  // Restart the 5s countdown

Fields§

§handle: TimerHandle

FreeRTOS timer handle

Implementations§

Source §

impl Timer

Source

pub fn new_with_to_tick<F>( name: &str, timer_period_in_ticks: impl ToTick, auto_reload: bool, param: Option<TimerParam>, callback: F, ) -> Result<Self>
where F: Fn(Box<dyn TimerFn>, Option<TimerParam>) -> Result<TimerParam> + Send + Sync + Clone + 'static,

Source

pub fn change_period_with_to_tick( &self, new_period_in_ticks: impl ToTick, new_period_ticks: impl ToTick, ) -> OsalRsBool

Source

pub fn delete_with_to_tick(&mut self, ticks_to_wait: impl ToTick) -> OsalRsBool

Source §

impl Timer

Source

pub fn new<F>( name: &str, timer_period_in_ticks: TickType, auto_reload: bool, param: Option<TimerParam>, callback: F, ) -> Result<Self>
where F: Fn(Box<dyn TimerFn>, Option<TimerParam>) -> Result<TimerParam> + Send + Sync + Clone + 'static,

Creates a new software timer.

§Parameters

name - Timer name for debugging
timer_period_in_ticks - Timer period in ticks
auto_reload - true for periodic, false for one-shot
param - Optional parameter passed to callback
callback - Function called when timer expires

§Returns

Ok(Self) - Successfully created timer
Err(Error) - Creation failed

§Examples

use osal_rs::os::{Timer, TimerFn};
 
let timer = Timer::new(
    "my_timer",
    1000,
    false,
    None,
    |_timer, _param| Ok(None)
).unwrap();
``