Struct Timer 

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

Software timer types for periodic and one-shot callbacks. A software timer backed by a POSIX timer_create/SIGALRM timer and a dedicated background thread that waits for the signal and invokes the user callback. Freely Clone-able - every clone shares the same underlying timer. See Timer::new for a complete, testable example.

Fields

handle: TimerHandle

Raw handle to the underlying timer_t, exposed for diagnostics (Debug/Display). null until Timer::new successfully calls timer_create.

Implementations

impl Timer

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,

Same as Timer::new, but accepts any ToTick period (e.g. a core::time::Duration) instead of a raw tick count. See the module-level docs above for a complete example.

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

Same as TimerFn::start, but accepts any ToTick value (e.g. a core::time::Duration) instead of a raw tick count.

Examples

use osal_rs::os::*;
use std::sync::Arc;
use core::time::Duration;

let timer = Timer::new_with_to_tick("t", Duration::from_millis(50), false, None, |_t, _p| Ok(Arc::new(()))).unwrap();
assert_eq!(timer.start_with_to_tick(Duration::from_millis(10)), osal_rs::utils::OsalRsBool::True);

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

Same as TimerFn::stop, but accepts any ToTick value instead of a raw tick count.

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

Same as TimerFn::reset, but accepts any ToTick value instead of a raw tick count.

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

Same as TimerFn::change_period, but accepts any ToTick values instead of raw tick counts.

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

Same as TimerFn::delete, but accepts any ToTick value instead of a raw tick count.

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 timer named name, firing callback every timer_period_in_ticks ticks if auto_reload (one-shot otherwise). param is handed to the first callback invocation; each invocation can return an updated value for the next one. The timer is created stopped - call TimerFn::start to arm it.

Examples

use osal_rs::os::*;
use std::sync::Arc;

let timer = Timer::new("t", 50, false, None, |_timer, _param| Ok(Arc::new(()))).unwrap();
assert!(!timer.is_null());

Trait Implementations

impl Clone for Timer

fn clone(&self) -> Timer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Timer

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

Formats the value using the given formatter.

impl Deref for Timer

type Target = *mut c_void

The resulting type after dereferencing.

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

Dereferences the value.

impl Display for Timer

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

Formats the value using the given formatter.

impl Drop for Timer

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.

impl Send for Timer

impl Sync for Timer

impl Timer for Timer

fn is_null(&self) -> bool

Returns true if this timer has been TimerFn::deleted (or the underlying kernel timer failed to create).

Examples

use osal_rs::os::*;
use std::sync::Arc;

let mut timer = Timer::new("t", 50, false, None, |_t, _p| Ok(Arc::new(()))).unwrap();
assert!(!timer.is_null());

timer.delete(0);
assert!(timer.is_null());

fn start(&self, _ticks_to_wait: TickType) -> OsalRsBool

Arms the timer to fire after its configured period. See the module-level docs above for a complete example.

fn stop(&self, _ticks_to_wait: TickType) -> OsalRsBool

Disarms the timer; a no-op if it isn’t currently running.

Examples

use osal_rs::os::*;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};

static FIRED: AtomicBool = AtomicBool::new(false);

let timer = Timer::new("t", 20, false, None, |_t, _p| {
    FIRED.store(true, Ordering::SeqCst);
    Ok(Arc::new(()))
}).unwrap();

timer.start(0);
timer.stop(0); // cancels before it can fire

System::delay(50);
assert!(!FIRED.load(Ordering::SeqCst));

fn reset(&self, ticks_to_wait: TickType) -> OsalRsBool

Restarts the countdown from now, using the current period - equivalent to calling TimerFn::start again, whether the timer was previously running or stopped.

fn change_period( &self, new_period_in_ticks: TickType, ticks_to_wait: TickType, ) -> OsalRsBool

Updates the timer’s period and immediately (re)arms it with the new value.

Examples

use osal_rs::os::*;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};

static FIRED: AtomicBool = AtomicBool::new(false);

let timer = Timer::new("t", 10_000, false, None, |_t, _p| {
    FIRED.store(true, Ordering::SeqCst);
    Ok(Arc::new(()))
}).unwrap();

// Original 10s period would never fire in time; shrink it to 10ms.
timer.change_period(10, 0);

System::delay(50);
assert!(FIRED.load(Ordering::SeqCst));

fn delete(&mut self, _ticks_to_wait: TickType) -> OsalRsBool

Destroys the underlying kernel timer and its background thread, resetting this Timer to its “null” state. See TimerFn::is_null for a complete example.