Struct embassy_time::Ticker

pub struct Ticker { /* private fields */ }

Asynchronous stream that yields every Duration, indefinitely.

This stream will tick at uniform intervals, even if blocking work is performed between ticks.

For instance, consider the following code fragment.

use embassy_time::{Duration, Timer};

#[embassy_executor::task]
async fn ticker_example_0() {
    loop {
        foo();
        Timer::after(Duration::from_secs(1)).await;
    }
}

This fragment will not call foo every second. Instead, it will call it every second + the time it took to previously call foo.

Example using ticker, which will consistently call foo once a second.

use embassy_time::{Duration, Ticker};
use futures::StreamExt;

#[embassy_executor::task]
async fn ticker_example_1() {
    let mut ticker = Ticker::every(Duration::from_secs(1));
    loop {
        foo();
        ticker.next().await;
    }
}

Implementations

impl Ticker

pub fn every(duration: Duration) -> Self

Creates a new ticker that ticks at the specified duration interval.

pub fn next(&mut self) -> impl Future<Output = ()> + '_

Waits for the next tick

Trait Implementations

impl Stream for Ticker

type Item = ()

Values yielded by the stream.

fn poll_next(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl Unpin for Ticker