Struct stm32f3xx_hal::timer::Timer

pub struct Timer<TIM> { /* private fields */ }

Hardware timers

Implementations

impl<TIM> Timer<TIM>where TIM: Instance,

pub fn new(tim: TIM, clocks: Clocks, apb: &mut <TIM as RccBus>::Bus) -> Self

Configures a TIM peripheral as a periodic count down timer

pub fn stop(&mut self)

Stops the timer

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

Enable or disable the interrupt for the specified Event.

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

Enable or disable the interrupt for the specified Event.

pub fn interrupt(&self) -> <TIM as InterruptNumber>::Interrupt

Obtain the associated interupt number for the serial peripheral.

Used to unmask / enable the interrupt with cortex_m::peripheral::NVIC::unmask(). This is useful for all cortex_m::peripheral::INTERRUPT functions.

Note

This is the easier alternative to obatain the interrupt for:

use cortex_m::peripheral::INTERRUPT;
use stm32f3xx_hal::pac::TIM1;
use stm32f3xx_hal::interrupts::InterruptNumber;

const INTERRUPT: Interrupt = <TIM2 as InterruptNumber>::INTERRUPT;

though this function can not be used in a const context.

pub fn configure_interrupt(&mut self, event: Event, enable: bool)

Enable or disable the interrupt for the specified Event.

pub fn configure_interrupts(&mut self, events: EnumSet<Event>)

Enable or disable interrupt for the specified Events.

Like Timer::configure_interrupt, but instead using an enumset. The corresponding interrupt for every Event in the set will be enabled, every other interrupt will be disabled.

pub fn is_interrupt_configured(&self, event: Event) -> bool

Check if an interrupt is configured for the Event

pub fn configured_interrupts(&mut self) -> EnumSet<Event>

Check which interrupts are enabled for all Events

pub fn is_event_triggered(&self, event: Event) -> bool

Check if an interrupt event happened.

pub fn triggered_events(&self) -> EnumSet<Event>

Get an EnumSet of all fired interrupt events.

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

Clear the given interrupt event flag.

pub fn clear_events(&mut self)

Clear all interrupt events.

pub unsafe fn peripheral(&mut self) -> &mut TIM

Get access to the underlying register block.

Safety

This function is not memory unsafe per se, but does not guarantee anything about assumptions of invariants made in this implementation.

Changing specific options can lead to un-expected behavior and nothing is guaranteed.

pub fn free(self) -> TIM

Releases the TIM peripheral

Trait Implementations

impl<TIM> Cancel for Timer<TIM>where TIM: Instance,

type Error = AlreadyCancled

Error returned when a countdown can’t be canceled.

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

Tries to cancel this countdown.

impl<TIM: Debug> Debug for Timer<TIM>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<TIM> CountDown for Timer<TIM>where TIM: Instance,

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

Wait until Event::Update / the timer has elapsed and than clear the event.

type Time = Generic<u32>

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

impl<TIM> Periodic for Timer<TIM>where TIM: Instance,