Struct stm32_eth::stm32::TIM10

impl TIM10

pub const PTR: const RegisterBlock = {0x40014400 as const stm32f4xx_hal::pac::tim10::RegisterBlock}

Pointer to the register block

pub const fn ptr() -> *const RegisterBlock

Return the pointer to the register block

Methods from Deref<Target = RegisterBlock>§

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

0x34 - capture/compare register

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

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

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

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

Trait Implementations§

impl Debug for TIM10

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

Formats the value using the given formatter. Read more

impl Deref for TIM10

type Target = RegisterBlock

The resulting type after dereferencing.

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

Dereferences the value.

type Bus = APB2

Bus type;

impl Reset for TIM10

fn reset(rcc: &RegisterBlock)

impl Instance for TIM10

impl Send for TIM10

Auto Trait Implementations§

impl RefUnwindSafe for TIM10

impl !Sync for TIM10

impl Unpin for TIM10

impl UnwindSafe for TIM10

Blanket Implementations§

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

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

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

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

impl<T> BusClock for Twhere 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 Twhere 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, U> Into for Twhere 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> PwmExt for TIMwhere TIM: Instance + WithPwm,

fn pwm<P, PINS, const FREQ: u32>( self, pins: PINS, time: Duration<u32, 1, FREQ>, clocks: &Clocks ) -> Pwm<TIM, P, PINS, FREQ>where PINS: Pins<TIM, P>,

fn pwm_hz<P, PINS>( self, pins: PINS, time: Rate<u32, 1, 1>, clocks: &Clocks ) -> PwmHz<TIM, P, PINS>where PINS: Pins<TIM, P>,

fn pwm_us<P, PINS>( self, pins: PINS, time: Duration<u32, 1, 1000000>, clocks: &Clocks ) -> Pwm<Self, P, PINS, 1000000>where PINS: Pins<Self, P>,

impl<TIM> TimerExt for TIMwhere 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) -> Counter<Self, 1000>

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

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

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

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

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

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

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

impl<T, U> TryFrom for Twhere 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>::Error>

Performs the conversion.

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

type Error = >::Error

The type returned in the event of a conversion error.