stm32f4xx_hal::pac

Struct TIM1

pub struct TIM1 { /* private fields */ }

Expand description

Advanced-timers

See peripheral structure

Implementations§

impl TIM1

pub const PTR: const RegisterBlock = {0x40010000 as const stm32f4_staging::stm32f429::tim1::RegisterBlock}

Pointer to the register block

pub const fn ptr() -> *const RegisterBlock

Return the pointer to the register block

pub unsafe fn steal() -> TIM1

Steal an instance of this peripheral

§Safety

Ensure that the new instance of the peripheral cannot be used in a way that may race with any existing instances, for example by only accessing read-only or write-only registers, or by consuming the original peripheral and using critical sections to coordinate access between multiple new instances.

Additionally, other software such as HALs may rely on only one peripheral instance existing to ensure memory safety; ensure no stolen instances are passed to such software.

Methods from Deref<Target = RegisterBlock>§

pub fn cr1(&self) -> &Reg<CR1rs>

0x00 - control register 1

pub fn cr2(&self) -> &Reg<CR2rs>

0x04 - control register 2

pub fn smcr(&self) -> &Reg<SMCRrs>

0x08 - slave mode control register

pub fn dier(&self) -> &Reg<DIERrs>

0x0c - DMA/Interrupt enable register

pub fn sr(&self) -> &Reg<SRrs>

0x10 - status register

pub fn egr(&self) -> &Reg<EGRrs>

0x14 - event generation register

pub fn ccmr1_input(&self) -> &Reg<CCMR1_INPUTrs>

0x18 - capture/compare mode register 1 (input mode)

pub fn ccmr1_output(&self) -> &Reg<CCMR1_OUTPUTrs>

0x18 - capture/compare mode register 1 (output mode)

pub fn ccmr2_input(&self) -> &Reg<CCMR2_INPUTrs>

0x1c - capture/compare mode register 2 (input mode)

pub fn ccmr2_output(&self) -> &Reg<CCMR2_OUTPUTrs>

0x1c - capture/compare mode register 2 (output mode)

pub fn ccer(&self) -> &Reg<CCERrs>

0x20 - capture/compare enable register

pub fn cnt(&self) -> &Reg<CNTrs>

0x24 - counter

pub fn psc(&self) -> &Reg<PSCrs>

0x28 - prescaler

pub fn arr(&self) -> &Reg<ARRrs>

0x2c - auto-reload register

pub fn rcr(&self) -> &Reg<RCRrs>

0x30 - repetition counter register

pub fn ccr(&self, n: usize) -> &Reg<CCRrs>

0x34..0x44 - capture/compare register

pub fn ccr_iter(&self) -> impl Iterator<Item = &Reg<CCRrs>>

Iterator for array of: 0x34..0x44 - capture/compare register

pub fn ccr1(&self) -> &Reg<CCRrs>

0x34 - capture/compare register

pub fn ccr2(&self) -> &Reg<CCRrs>

0x38 - capture/compare register

pub fn ccr3(&self) -> &Reg<CCRrs>

0x3c - capture/compare register

pub fn ccr4(&self) -> &Reg<CCRrs>

0x40 - capture/compare register

pub fn bdtr(&self) -> &Reg<BDTRrs>

0x44 - break and dead-time register

pub fn dcr(&self) -> &Reg<DCRrs>

0x48 - DMA control register

pub fn dmar(&self) -> &Reg<DMARrs>

0x4c - DMA address for full transfer

Trait Implementations§

impl Debug for TIM1

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

Formats the value using the given formatter. Read more

impl Deref for TIM1

type Target = RegisterBlock

The resulting type after dereferencing.

fn deref(&self) -> &<TIM1 as Deref>::Target

Dereferences the value.

impl Enable for TIM1

fn enable(rcc: &RccRB)

Enables peripheral

fn disable(rcc: &RccRB)

Disables peripheral

fn is_enabled() -> bool

Check if peripheral enabled

fn is_disabled() -> bool

Check if peripheral disabled

unsafe fn enable_unchecked()

Safety Read more

unsafe fn disable_unchecked()

Safety Read more

impl Instance for TIM1

fn setup_qei(&mut self)

fn read_direction(&self) -> bool

impl LPEnable for TIM1

fn enable_in_low_power(rcc: &RccRB)

Enables peripheral in low power mode

fn disable_in_low_power(rcc: &RccRB)

Disables peripheral in low power mode

fn is_enabled_in_low_power() -> bool

Check if peripheral enabled in low power mode

fn is_disabled_in_low_power() -> bool

Check if peripheral disabled in low power mode

unsafe fn enable_in_low_power_unchecked()

Safety Read more

unsafe fn disable_in_low_power_unchecked()

Safety Read more

impl RccBus for TIM1

type Bus = APB2

Bus type;

impl Reset for TIM1

fn reset(rcc: &RccRB)

Resets peripheral

unsafe fn reset_unchecked()

Safety Read more

impl Steal for TIM1

unsafe fn steal() -> Self

Steal an instance of this peripheral Read more

impl TimBkin for TIM1

type Bkin = Bkin

impl TimCPin<0> for TIM1

type Ch<Otype> = Ch1<Otype>

impl TimCPin<1> for TIM1

type Ch<Otype> = Ch2<Otype>

impl TimCPin<2> for TIM1

type Ch<Otype> = Ch3<Otype>

impl TimCPin<3> for TIM1

type Ch<Otype> = Ch4<Otype>

impl TimEtr for TIM1

type Etr = Etr

impl TimNCPin<0> for TIM1

type ChN<Otype> = Ch1N<Otype>

impl TimNCPin<1> for TIM1

type ChN<Otype> = Ch2N<Otype>

impl TimNCPin<2> for TIM1

type ChN<Otype> = Ch3N<Otype>

impl Instance for TIM1

impl Send for TIM1

Auto Trait Implementations§

impl Freeze for TIM1

impl RefUnwindSafe for TIM1

impl !Sync for TIM1

impl Unpin for TIM1

impl UnwindSafe for TIM1

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> BusClock for T
where T: RccBus, <T as RccBus>::Bus: BusClock,

fn clock(clocks: &Clocks) -> Rate<u32, 1, 1>

Calculates frequency depending on Clock state

impl<T> BusTimerClock for T
where T: RccBus, <T as RccBus>::Bus: BusTimerClock,

fn timer_clock(clocks: &Clocks) -> Rate<u32, 1, 1>

Calculates base frequency of timer depending on Clock state

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> I2sFreq for T
where T: RccBus, <T as RccBus>::Bus: I2sFreq,

fn try_i2s_freq(clocks: &Clocks) -> Option<Rate<u32, 1, 1>>

fn i2s_freq(clocks: &Clocks) -> Hertz

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<TIM> MonoTimer64Ext for TIM
where TIM: Instance + General + WithPwm,

fn monotonic64<const FREQ: u32>(self, clocks: &Clocks) -> MonoTimer64<TIM, FREQ>

fn monotonic64_us(self, clocks: &Clocks) -> MonoTimer64<Self, 1_000_000>

impl<TIM> PwmExt for TIM
where TIM: Instance + WithPwm + Split,

fn pwm<const FREQ: u32>( self, time: Duration<u32, 1, FREQ>, clocks: &Clocks, ) -> (PwmManager<TIM, FREQ>, <TIM as Split>::Channels)

fn pwm_hz( self, time: Rate<u32, 1, 1>, clocks: &Clocks, ) -> (PwmHzManager<TIM>, <TIM as Split>::Channels)

fn pwm_us( self, time: TimerDurationU32<1_000_000>, clocks: &Clocks, ) -> (PwmManager<Self, 1_000_000>, Self::Channels)

impl<TIM> QeiExt for TIM
where TIM: Instance,

fn qei( self, pins: (impl Into<<TIM as TimCPin<0>>::Ch<PushPull>>, impl Into<<TIM as TimCPin<1>>::Ch<PushPull>>), ) -> Qei<TIM>

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)

The target type on which the method may be called.

impl<TIM> TimerExt for TIM
where TIM: Instance,

fn counter<const FREQ: u32>(self, clocks: &Clocks) -> Counter<TIM, FREQ>

Non-blocking Counter with custom fixed precision

fn counter_hz(self, clocks: &Clocks) -> CounterHz<TIM>

Non-blocking Counter with dynamic precision which uses Hertz as Duration units

fn delay<const FREQ: u32>(self, clocks: &Clocks) -> Delay<TIM, FREQ>

Blocking Delay with custom fixed precision

fn counter_ms(self, clocks: &Clocks) -> CounterMs<Self>

Non-blocking Counter with fixed precision of 1 ms (1 kHz sampling) Read more

fn counter_us(self, clocks: &Clocks) -> CounterUs<Self>

Non-blocking Counter with fixed precision of 1 μs (1 MHz sampling) Read more

fn delay_ms(self, clocks: &Clocks) -> DelayMs<Self>

Blocking Delay with fixed precision of 1 ms (1 kHz sampling) Read more

fn delay_us(self, clocks: &Clocks) -> DelayUs<Self>

Blocking Delay with fixed precision of 1 μs (1 MHz sampling) Read more

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.