Struct embedded_async_timer::AsyncTimer

pub struct AsyncTimer<T: Timer>(_);

A wrapped timer that can asynchronously wake up for concurrent deadlines.

The capacity of this timer is determined by the internal PriorityQueue.

Implementations

impl<T: Timer> AsyncTimer<T>

pub fn new(timer: T) -> Self

pub fn reset(&self)

pub fn now(&self) -> T::Instant

pub unsafe fn get_inner<U>(&self, f: impl FnOnce(&mut T) -> U) -> U

pub fn awaken(&self)

Awaken all timers for which the deadline has passed compared to the time.

Will re-arm the inner RTC with the earliest deadline, if there is one.

Note: call this in the appropriate interrupt handler.

pub fn wait<'a>(
    &'a self,
    dur: T::Duration
) -> Result<Delay<'a, T>, CapacityError>

Wait at least for a specific duration.

pub async fn wait_until<'a>(
    &'a self,
    deadline: T::Instant
) -> Result<(), CapacityError>

Wait until some time after a specific deadline.

Will immediately return (and never yield) if the deadline has already passed.

pub fn wait_until_always<'a>(
    &'a self,
    deadline: T::Instant
) -> Result<Delay<'a, T>, CapacityError>

Wait until some time after a specific deadline.

Will at least yield once, even if the deadline has already passed.