Struct stm32f4xx_hal::timer::delay::Delay

pub struct Delay<TIM, const FREQ: u32>(_);

Periodic non-blocking timer that imlements embedded_hal::blocking::delay traits.

Example: Millisecond precision

To instantiate this with the TIM2 timer and millisecond precision:

let mut delay = dp.TIM2.delay_ms(&clocks);
delay.delay_ms(320_u32);

With millisecond precision, you can wait from 2 ms to 49 days.

Example: Microsecond precision

To instantiate this with the TIM5 timer and microsecond precision:

let delay = dp.TIM5.delay_us(&clocks);
delay.delay_us(30_u32);
delay.delay_ms(5_u32);
delay.delay(5.millis());
delay.delay(3.secs());

With microsecond precision, you can wait from 2 µs to 71 min.

Implementations

impl<TIM: Instance, const FREQ: u32> Delay<TIM, FREQ>

pub fn delay(&mut self, time: TimerDurationU32<FREQ>)

Sleep for given time

pub fn max_delay(&self) -> TimerDurationU32<FREQ>

pub fn release(self) -> FTimer<TIM, FREQ>

Releases the TIM peripheral

Methods from Deref<Target = FTimer<T, FREQ>>

pub fn configure(&mut self, clocks: &Clocks)

Calculate prescaler depending on Clocks state

pub fn listen(&mut self, event: Event)

Starts listening for an event

Note, you will also have to enable the TIM2 interrupt in the NVIC to start receiving events.

pub fn clear_interrupt(&mut self, event: Event)

Clears interrupt associated with event.

If the interrupt is not cleared, it will immediately retrigger after the ISR has finished.

pub fn get_interrupt(&mut self) -> Event

pub fn unlisten(&mut self, event: Event)

Stops listening for an event

pub fn set_master_mode(&mut self, mode: TIM::Mms)

Trait Implementations

impl<TIM: Instance, const FREQ: u32> Delay<FREQ> for Delay<TIM, FREQ>

type Error = Infallible

An error that might happen during waiting

fn delay(&mut self, duration: TimerDurationU32<FREQ>) -> Result<(), Self::Error>

Wait until timer duration has expired.

impl<TIM: Instance, const FREQ: u32> DelayMs<u16> for Delay<TIM, FREQ>

fn delay_ms(&mut self, ms: u16)

Sleep for ms milliseconds

impl<TIM: Instance, const FREQ: u32> DelayMs<u32> for Delay<TIM, FREQ>

fn delay_ms(&mut self, ms: u32)

Sleep for ms milliseconds

impl<TIM: Instance, const FREQ: u32> DelayMs<u8> for Delay<TIM, FREQ>

fn delay_ms(&mut self, ms: u8)

Sleep for ms milliseconds

impl<TIM: Instance, const FREQ: u32> DelayUs<u16> for Delay<TIM, FREQ>

fn delay_us(&mut self, us: u16)

Sleep for us microseconds

impl<TIM: Instance, const FREQ: u32> DelayUs<u32> for Delay<TIM, FREQ>

fn delay_us(&mut self, us: u32)

Sleep for us microseconds

impl<TIM: Instance, const FREQ: u32> DelayUs<u8> for Delay<TIM, FREQ>

fn delay_us(&mut self, us: u8)

Sleep for us microseconds

impl<TIM: Instance, const FREQ: u32> DelayUs for Delay<TIM, FREQ>

type Error = Error

Enumeration of DelayUs errors

fn delay_us(&mut self, us: u32) -> Result<(), Self::Error>

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) -> Result<(), Self::Error>

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

impl<T, const FREQ: u32> Deref for Delay<T, FREQ>

type Target = FTimer<T, FREQ>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, const FREQ: u32> DerefMut for Delay<T, FREQ>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.