Trait stm32h7xx_hal::timer::TimerExt

pub trait TimerExt<TIM> {
    type Rec: ResetEnable;
    fn timer<T>(self, timeout: T, prec: Self::Rec, clocks: &CoreClocks) -> TIM
    where
        T: Into<Hertz>;
    fn tick_timer<T>(
        self, 
        frequency: T, 
        prec: Self::Rec, 
        clocks: &CoreClocks
    ) -> TIM
    where
        T: Into<Hertz>;
}

External trait for hardware timers

Associated Types

type Rec: ResetEnable

Loading content...

Required methods

fn timer<T>(self, timeout: T, prec: Self::Rec, clocks: &CoreClocks) -> TIM where
    T: Into<Hertz>, 

Configures a periodic timer

Generates an overflow event at the timeout frequency.

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> TIM where
    T: Into<Hertz>, 

Configures the timer to count up at the given frequency

Counts from 0 to the counter’s maximum value, then repeats. Because this only uses the timer prescaler, the frequency is rounded to a multiple of the timer’s kernel clock.

Loading content...

Implementors

impl TimerExt<LpTimer<LPTIM1, Enabled>> for LPTIM1

type Rec = Lptim1

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> LpTimer<LPTIM1, Enabled> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    _frequency: T,
    _prec: Self::Rec,
    _clocks: &CoreClocks
) -> LpTimer<LPTIM1, Enabled> where
    T: Into<Hertz>, 

impl TimerExt<LpTimer<LPTIM2, Enabled>> for LPTIM2

type Rec = Lptim2

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> LpTimer<LPTIM2, Enabled> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    _frequency: T,
    _prec: Self::Rec,
    _clocks: &CoreClocks
) -> LpTimer<LPTIM2, Enabled> where
    T: Into<Hertz>, 

impl TimerExt<LpTimer<LPTIM3, Enabled>> for LPTIM3

type Rec = Lptim3

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> LpTimer<LPTIM3, Enabled> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    _frequency: T,
    _prec: Self::Rec,
    _clocks: &CoreClocks
) -> LpTimer<LPTIM3, Enabled> where
    T: Into<Hertz>, 

impl TimerExt<LpTimer<LPTIM4, Enabled>> for LPTIM4

type Rec = Lptim4

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> LpTimer<LPTIM4, Enabled> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    _frequency: T,
    _prec: Self::Rec,
    _clocks: &CoreClocks
) -> LpTimer<LPTIM4, Enabled> where
    T: Into<Hertz>, 

impl TimerExt<LpTimer<LPTIM5, Enabled>> for LPTIM5

type Rec = Lptim5

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> LpTimer<LPTIM5, Enabled> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    _frequency: T,
    _prec: Self::Rec,
    _clocks: &CoreClocks
) -> LpTimer<LPTIM5, Enabled> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM1>> for TIM1

type Rec = Tim1

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM1> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM1> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM2>> for TIM2

type Rec = Tim2

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM2> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM2> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM3>> for TIM3

type Rec = Tim3

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM3> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM3> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM4>> for TIM4

type Rec = Tim4

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM4> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM4> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM5>> for TIM5

type Rec = Tim5

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM5> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM5> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM6>> for TIM6

type Rec = Tim6

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM6> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM6> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM7>> for TIM7

type Rec = Tim7

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM7> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM7> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM8>> for TIM8

type Rec = Tim8

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM8> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM8> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM12>> for TIM12

type Rec = Tim12

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM12> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM12> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM13>> for TIM13

type Rec = Tim13

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM13> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM13> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM14>> for TIM14

type Rec = Tim14

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM14> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM14> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM15>> for TIM15

type Rec = Tim15

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM15> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM15> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM16>> for TIM16

type Rec = Tim16

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM16> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM16> where
    T: Into<Hertz>, 

impl TimerExt<Timer<TIM17>> for TIM17

type Rec = Tim17

fn timer<T>(
    self,
    timeout: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM17> where
    T: Into<Hertz>, 

fn tick_timer<T>(
    self,
    frequency: T,
    prec: Self::Rec,
    clocks: &CoreClocks
) -> Timer<TIM17> where
    T: Into<Hertz>, 

Loading content...