Struct stm32f4xx_hal::timer::counter::Counter

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

Periodic non-blocking timer that imlements embedded_hal::timer::CountDown

Implementations

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

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

Releases the TIM peripheral

pub fn now(&self) -> TimerInstantU32<FREQ>

pub fn start(&mut self, timeout: TimerDurationU32<FREQ>) -> Result<(), Error>

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

pub fn cancel(&mut self) -> Result<(), Error>

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> Cancel for Counter<TIM, FREQ>

type Error = Error

Error returned when a countdown can’t be canceled.

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to cancel this countdown.

impl<TIM: Instance, const FREQ: u32> CountDown for Counter<TIM, FREQ>

type Time = Duration<u32, 1_u32, FREQ>

The unit of time used by this timer

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

Starts a new count down

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

Non-blockingly “waits” until the count down finishes

impl<T, const FREQ: u32> Deref for Counter<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 Counter<T, FREQ>

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

Mutably dereferences the value.

impl<TIM: Instance, const FREQ: u32> Timer<FREQ> for Counter<TIM, FREQ>

type Error = Error

An error that might happen during waiting

fn now(&mut self) -> TimerInstantU32<FREQ>

Return current time Instant

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

Start timer with a duration

fn cancel(&mut self) -> Result<(), Self::Error>

Tries to stop this timer. An error will be returned if the timer has already been canceled or was never started. An error is also returned if the timer is not Periodic and has already expired.

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

Wait until timer duration has expired. Must return nb::Error::WouldBlock if timer duration is not yet over. Must return OK(()) as soon as timer duration has expired.

impl<TIM: Instance, const FREQ: u32> Periodic for Counter<TIM, FREQ>