Struct CounterHz 

pub struct CounterHz<TIM>(/* private fields */);

Hardware timers

Implementations

impl<TIM: Instance> CounterHz<TIM>

pub fn release(self) -> Timer<TIM>

Releases the TIM peripheral

impl<TIM: Instance> CounterHz<TIM>

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

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

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

pub fn start_raw(&mut self, psc: u16, arr: u16)

Restarts the timer in count down mode with user-defined prescaler and auto-reload register

pub fn psc(&self) -> u16

Retrieves the content of the prescaler register. The real prescaler is this value + 1.

pub fn arr(&self) -> u16

Retrieves the value of the auto-reload register.

pub fn reset(&mut self)

Resets the counter

pub fn now(&self) -> MicrosDurationU32

Returns the number of microseconds since the last update event. NOTE: This method is not a very good candidate to keep track of time, because it is very easy to lose an update event.

Methods from Deref<Target = Timer<T>>

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

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 stop_in_debug(&mut self, dbg: &mut DBG, state: bool)

Stopping timer in debug mode can cause troubles when sampling the signal

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

Trait Implementations

impl<TIM: Instance> Cancel for CounterHz<TIM>

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> Deref for CounterHz<T>

type Target = Timer<T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for CounterHz<T>

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

Mutably dereferences the value.

impl<TIM: Instance> CountDown for CounterHz<TIM>

type Time = Rate<u32, 1, 1>

The unit of time used by this timer

fn start<T>(&mut self, timeout: T)

where T: Into<Hertz>,

Starts a new count down

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

Non-blockingly “waits” until the count down finishes

impl<TIM> Periodic for CounterHz<TIM>