Struct riot_wrappers::ztimer::Clock

pub struct Clock<const HZ: u32>(/* private fields */);

Available on riot_module_ztimer only.

A clock that knows about its frequency. The pulse length is not given in core::time::Duration as that’s not yet supported by const generics, and because clock rates are often easier to express in Hertz than in multiples of 10^-n seconds.

Implementations

impl<const HZ: u32> Clock<HZ>

pub fn sleep_ticks(&self, duration: u32)

Pause the current thread for the duration of ticks in the timer’s time scale.

Wraps ztimer_sleep

pub fn spin_ticks(&self, duration: u32)

Keep the current thread in a busy loop until the duration of ticks in the timer’s tim scale has passed

Quoting the original documentation, “This blocks lower priority threads. Use only for very short delays.”.

Wraps ztimer_spin

pub fn sleep(&self, duration: Duration)

Pause the current thread for the given duration.

The duration is converted into ticks (rounding up), and overflows are caught by sleeping multiple times.

It is up to the caller to select the Clock suitable for efficiency. (Even sleeping for seconds on the microseconds timer would not overflow the timer’s interface’s u32, but the same multiple-sleeps trick may need to be employed by the implementation, and would keep the system from entering deeper sleep modes).

pub async fn sleep_async(&self, duration: Ticks<HZ>)

Similar to [sleep_ticks()], but this does not block but creates a future to be .awaited.

Note that time starts running only when this is polled, for otherwise there’s no pinned Self around.

pub fn set_during<I: FnOnce() + Send, M: FnOnce() -> R, R>( &self, callback: I, ticks: Ticks<HZ>, in_thread: M ) -> R

Set the given callback to be executed in an interrupt some ticks in the future.

Then, start the in_thread function from in the thread this is called from (as a regular function call).

After the in_thread function terminates, the callback is dropped if it has not already triggered.

Further Development:

• This could probably be done with some sort of pinning instead, thus avoiding the nested scope – but getting the Drop right is comparatively tricky, because when done naively it needs runtime state.

• The callback could be passed something extra that enables it to set the timer again and again. Granted, there’s ztimer_periodic for these cases (and it has better drifting properties), but for something like exponential retransmission it could be convenient.

  (Might make sense to do this without an extra function variant: if the callback ignores the timer argument and always returns None, that’s all in the caller type and probebly inlined right away).

impl Clock<1>

pub fn sec() -> Self

Available on riot_module_ztimer_sec only.

Get the global second ZTimer clock, ZTIMER_SEC.

This function is only available if the ztimer_sec module is built.

impl Clock<1000>

pub fn msec() -> Self

Available on riot_module_ztimer_msec only.

Get the global milliseconds ZTimer clock, ZTIMER_MSEC.

This function is only available if the ztimer_msec module is built.

impl Clock<1000000>

pub fn usec() -> Self

Available on riot_module_ztimer_usec only.

Get the global microseconds ZTimer clock, ZTIMER_USEC.

This function is only available if the ztimer_usec module is built.

Trait Implementations

impl<const HZ: u32> Clone for Clock<HZ>

fn clone(&self) -> Clock<HZ>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const F: u32> DelayNs for Clock<F>

fn delay_ns(&mut self, ns: u32)

Pauses execution for at minimum ns nanoseconds. Pause can be longer if the implementation requires it due to precision/timing issues.

fn delay_us(&mut self, us: u32)

Pauses execution for at minimum us microseconds. Pause can be longer if the implementation requires it due to precision/timing issues.

fn delay_ms(&mut self, ms: u32)

Pauses execution for at minimum ms milliseconds. Pause can be longer if the implementation requires it due to precision/timing issues.

impl DelayMs<u32> for Clock<1000>

fn delay_ms(&mut self, ms: u32)

Pauses execution for ms milliseconds

impl DelayUs<u32> for Clock<1000000>

fn delay_us(&mut self, us: u32)

Pauses execution for us microseconds

impl<const HZ: u32> Copy for Clock<HZ>