Struct FTimer

pub struct FTimer<TIM, const FREQ: u32> { /* private fields */ }

Timer wrapper for fixed precision timers.

Uses fugit::TimerDurationU32 for most of operations

Implementations

impl<TIM: Instance + WithPwm + Split, const FREQ: u32> FTimer<TIM, FREQ>

pub fn pwm( self, time: TimerDurationU32<FREQ>, ) -> (PwmManager<TIM, FREQ>, TIM::Channels)

impl<TIM, const FREQ: u32> FTimer<TIM, FREQ>

where TIM: Instance + General<Width = u32> + WithPwm,

pub fn monotonic(self) -> MonoTimer<TIM, FREQ>

impl<TIM, const FREQ: u32> FTimer<TIM, FREQ>

where TIM: Instance + General + WithPwm,

pub fn monotonic64(self) -> MonoTimer64<TIM, FREQ>

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

pub fn new(tim: TIM, clocks: &Clocks) -> Self

Initialize timer

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

Calculate prescaler depending on Clocks state

pub fn counter(self) -> Counter<TIM, FREQ>

Creates Counter that implements embedded_hal_02::timer::CountDown

pub fn delay(self) -> Delay<TIM, FREQ>

Creates Delay that implements embedded_hal_02::blocking::delay traits

pub fn release(self) -> TIM

Releases the TIM peripheral

impl<TIM: Instance + MasterTimer, const FREQ: u32> FTimer<TIM, FREQ>

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

Trait Implementations

impl<TIM: Instance, const FREQ: u32> ClearFlags for FTimer<TIM, FREQ>

type Flag = Flag

Enum of manually clearable flags

fn clear_flags(&mut self, event: impl Into<BitFlags<Flag>>)

Clear interrupts flags with Self::Flagss

fn clear_all_flags(&mut self)

Clears all interrupts flags

impl<TIM: Instance, const FREQ: u32> Listen for FTimer<TIM, FREQ>

type Event = Event

Enum of bit flags associated with events

fn listen(&mut self, event: impl Into<BitFlags<Event>>)

Start listening for Events

fn listen_only(&mut self, event: impl Into<BitFlags<Event>>)

Start listening for Events, stop all other

fn unlisten(&mut self, event: impl Into<BitFlags<Event>>)

Stop listening for Events

fn listen_all(&mut self)

Start listening all Events

fn unlisten_all(&mut self)

Stop listening all Events

impl<TIM: Instance, const FREQ: u32> ReadFlags for FTimer<TIM, FREQ>

type Flag = Flag

Enum of bit flags

fn flags(&self) -> BitFlags<Flag>

Get all interrupts flags a once.