Struct stm32f4xx_hal::timer::counter::Counter

pub struct Counter<TIM, const FREQ: u32>(/* private fields */);

Periodic non-blocking timer that implements embedded_hal_02::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 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<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> CountDown for Counter<TIM, FREQ>

type Time = Duration<u32, 1, 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<TIM: Instance, const FREQ: u32> Periodic for Counter<TIM, FREQ>