[−][src]Trait esp32_hal::prelude::CountDown

pub trait CountDown {
    type Time;
    fn start<T>(&mut self, count: T)
    where
        T: Into<Self::Time>;

    fn wait(&mut self) -> Result<(), Error<Void>>;
}

A count down timer

Contract

  • self.start(count); block!(self.wait()); MUST block for AT LEAST the time specified by count.

Note that the implementer doesn't necessarily have to be a downcounting timer; it could also be an upcounting timer as long as the above contract is upheld.

Examples

You can use this timer to create delays

extern crate embedded_hal as hal;
#[macro_use(block)]
extern crate nb;

use hal::prelude::*;

fn main() {
    let mut led: Led = {
        // ..
    };
    let mut timer: Timer6 = {
        // ..
    };

    Led.on();
    timer.start(1.s());
    block!(timer.wait()); // blocks for 1 second
    Led.off();
}

Associated Types

type Time

The unit of time used by this timer

Loading content...

Required methods

fn start<T>(&mut self, count: T) where
    T: Into<Self::Time>, 

Starts a new count down

fn wait(&mut self) -> Result<(), Error<Void>>

Non-blockingly "waits" until the count down finishes

Contract

  • If Self: Periodic, the timer will start a new count down right after the last one finishes.
  • Otherwise the behavior of calling wait after the last call returned Ok is UNSPECIFIED. Implementers are suggested to panic on this scenario to signal a programmer error.
Loading content...

Implementors

impl<TIMG: TimerGroup> CountDown for Timer<TIMG, Timer0>[src]

type Time = NanoSecondsU64

fn start<T: Into<Self::Time>>(&mut self, timeout: T)[src]

Start timer

fn wait(&mut self) -> Result<(), Void>[src]

Wait for timer to finish

Note: if the timeout is handled via an interrupt, this will never return.

impl<TIMG: TimerGroup> CountDown for Timer<TIMG, Timer1>[src]

type Time = NanoSecondsU64

fn start<T: Into<Self::Time>>(&mut self, timeout: T)[src]

Start timer

fn wait(&mut self) -> Result<(), Void>[src]

Wait for timer to finish

Note: if the timeout is handled via an interrupt, this will never return.

impl<TIMG: TimerGroup> CountDown for Timer<TIMG, TimerLact>[src]

type Time = NanoSecondsU64

fn start<T: Into<Self::Time>>(&mut self, timeout: T)[src]

Start timer

fn wait(&mut self) -> Result<(), Void>[src]

Wait for timer to finish

Note: if the timeout is handled via an interrupt, this will never return.

Loading content...