Embassy STM32

https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/
Admin
Embassy STM32 is a crate within the Embassy embedded asynchronous framework, providing support and...
Tokens:192,203
Snippets:2,679
Trust Score:8.2
Update:2 months ago
Show doc for...
Tokens:
Raw
### start

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/spi/struct.RingBufferedSpiRx.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Configures and starts the DMA-backed SPI receiver.

```APIDOC
## pub fn start(&mut self)

### Description
Configure and start the DMA backed SPI receiver. This is also done automatically by the read functions if required.
```

--------------------------------

### start()

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/ringbuffered/struct.RingBufferedPwmChannel.html

Starts the ring buffer DMA operation. This must be called after initialization for the channel to function.

```APIDOC
## pub fn start(&mut self)

### Description
Starts the ring buffer operation. You must call this after creating the channel for it to work.
```

--------------------------------

### start_uart

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/usart/struct.RingBufferedUartRx.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Configures and starts the DMA-backed UART receiver.

```APIDOC
## pub fn start_uart(&mut self)

### Description
Configures and starts the DMA backed UART receiver. This is also done automatically by the read functions if required.
```

--------------------------------

### WindowWatchdog::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/wdg/struct.WindowWatchdog.html?search=u32+-%3E+bool

Creates and immediately starts the window watchdog timer.

```APIDOC
## pub fn new(_instance: Peri<'d, T>, timeout_us: u32, window_us: u32) -> Self

### Description
Creates and immediately starts the window watchdog. Once activated, the WWDG cannot be stopped without a system reset.

### Parameters
- **_instance** (Peri<'d, T>) - The peripheral instance to use.
- **timeout_us** (u32) - Total watchdog period in microseconds (counter-to-reset time).
- **window_us** (u32) - Closed-window duration in microseconds. During this initial portion of the period, petting the watchdog causes a reset. Pass 0 to disable the window restriction.
```

--------------------------------

### CanConfigurator Start Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/can/struct.CanConfigurator.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to transition the peripheral from configuration to active operating modes.

```rust
pub fn start(self, mode: OperatingMode) -> Can<'d>
```

```rust
pub fn into_normal_mode(self) -> Can<'d>
```

```rust
pub fn into_internal_loopback_mode(self) -> Can<'d>
```

```rust
pub fn into_external_loopback_mode(self) -> Can<'d>
```

--------------------------------

### Initialize WindowWatchdog

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/wdg/struct.WindowWatchdog.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates and starts the watchdog. The window_us parameter must be strictly less than timeout_us.

```rust
pub fn new(_instance: Peri<'d, T>, timeout_us: u32, window_us: u32) -> Self
```

--------------------------------

### Implementations of GeneralInstance2Channel

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/trait.GeneralInstance2Channel.html

Examples of implementing the trait for various timer instances.

```rust
impl GeneralInstance2Channel for TIM1 {
    type TriggerInterrupt = TIM1_BRK_UP_TRG_COM
}
```

```rust
impl GeneralInstance2Channel for TIM2 {
    type TriggerInterrupt = TIM2
}
```

```rust
impl GeneralInstance2Channel for TIM3 {
    type TriggerInterrupt = TIM3
}
```

```rust
impl GeneralInstance2Channel for TIM14 {
    type TriggerInterrupt = TIM14
}
```

```rust
impl GeneralInstance2Channel for TIM15 {
    type TriggerInterrupt = TIM15
}
```

```rust
impl GeneralInstance2Channel for TIM16 {
    type TriggerInterrupt = TIM16
}
```

```rust
impl GeneralInstance2Channel for TIM17 {
    type TriggerInterrupt = TIM17
}
```

--------------------------------

### CanConfigurator::start

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/can/struct.CanConfigurator.html?search=u32+-%3E+bool

Starts the CAN peripheral in the specified operating mode.

```APIDOC
## pub fn start(self, mode: OperatingMode) -> Can<'d>

### Description
Start in mode.
```

--------------------------------

### IndependentWatchdog::unleash

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/wdg/struct.IndependentWatchdog.html

Starts the watchdog timer.

```APIDOC
## pub fn unleash(&mut self)

### Description
Unleash (start) the watchdog. Once started, the timer begins counting down, and the MCU will reset if the timer expires.
```

--------------------------------

### IndependentWatchdog::unleash

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/wdg/struct.IndependentWatchdog.html?search=

Starts the watchdog timer.

```APIDOC
## pub fn unleash(&mut self)

### Description
Unleash (start) the watchdog. Once started, the timer begins counting down.
```

--------------------------------

### Initialize and use RingBufferedPwmChannel

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/ringbuffered/struct.RingBufferedPwmChannel.html?search=

Demonstrates how to convert a PWM channel into a ring-buffered channel, start the DMA transfer, and update duty cycles.

```rust
let mut channel = pwm.ch1().into_ring_buffered_channel(dma_ch, &mut buffer, Irqs);
channel.start(); // Start DMA transfer
channel.write(&[100, 200, 300]).ok(); // Update duty cycles
```

--------------------------------

### WindowWatchdog::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/wdg/struct.WindowWatchdog.html?search=

Creates and immediately starts the window watchdog. The watchdog cannot be stopped once activated without a system reset.

```APIDOC
### pub fn new(_instance: Peri<'d, T>, timeout_us: u32, window_us: u32) -> Self

Creates and immediately starts the window watchdog.

- **_instance**: The WWDG peripheral instance.
- **timeout_us**: Total watchdog period in microseconds (counter-to-reset time).
- **window_us**: Closed-window duration in microseconds. During this initial portion of the period, petting the watchdog causes a reset. Pass 0 to disable the window restriction. Must be strictly less than timeout_us.
```

--------------------------------

### RingBufferedSpiRx Implementation Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/spi/struct.RingBufferedSpiRx.html?search=std%3A%3Avec

Methods for configuring, starting, and reading from the RingBufferedSpiRx driver.

```rust
pub fn set_config(&mut self, config: &Config) -> Result<(), ()>
```

```rust
pub fn start(&mut self)
```

```rust
pub async fn read(&mut self, buf: &mut [W]) -> Result<usize, Error>
```

```rust
pub fn blocking_read(&mut self, buf: &mut [W]) -> Result<usize, Error>
```

--------------------------------

### ExtiPin Implementations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/gpio/trait.ExtiPin.html

Examples of ExtiPin implementations for various pins, each assigning a specific EXTI channel. These require the 'exti' crate feature.

```rust
impl ExtiPin for PA0 {
    type ExtiChannel = EXTI0
}
```

```rust
impl ExtiPin for PA1 {
    type ExtiChannel = EXTI1
}
```

```rust
impl ExtiPin for PA2 {
    type ExtiChannel = EXTI2
}
```

```rust
impl ExtiPin for PA3 {
    type ExtiChannel = EXTI3
}
```

```rust
impl ExtiPin for PA4 {
    type ExtiChannel = EXTI4
}
```

```rust
impl ExtiPin for PA5 {
    type ExtiChannel = EXTI5
}
```

```rust
impl ExtiPin for PA6 {
    type ExtiChannel = EXTI6
}
```

```rust
impl ExtiPin for PA7 {
    type ExtiChannel = EXTI7
}
```

```rust
impl ExtiPin for PA8 {
    type ExtiChannel = EXTI8
}
```

```rust
impl ExtiPin for PA9 {
    type ExtiChannel = EXTI9
}
```

```rust
impl ExtiPin for PA10 {
    type ExtiChannel = EXTI10
}
```

```rust
impl ExtiPin for PA11 {
    type ExtiChannel = EXTI11
}
```

```rust
impl ExtiPin for PA12 {
    type ExtiChannel = EXTI12
}
```

```rust
impl ExtiPin for PA13 {
    type ExtiChannel = EXTI13
}
```

```rust
impl ExtiPin for PA14 {
    type ExtiChannel = EXTI14
}
```

```rust
impl ExtiPin for PA15 {
    type ExtiChannel = EXTI15
}
```

```rust
impl ExtiPin for PB0 {
    type ExtiChannel = EXTI0
}
```

```rust
impl ExtiPin for PB1 {
    type ExtiChannel = EXTI1
}
```

```rust
impl ExtiPin for PB2 {
    type ExtiChannel = EXTI2
}
```

```rust
impl ExtiPin for PB3 {
    type ExtiChannel = EXTI3
}
```

```rust
impl ExtiPin for PB4 {
    type ExtiChannel = EXTI4
}
```

```rust
impl ExtiPin for PB5 {
    type ExtiChannel = EXTI5
}
```

```rust
impl ExtiPin for PB6 {
    type ExtiChannel = EXTI6
}
```

```rust
impl ExtiPin for PB7 {
    type ExtiChannel = EXTI7
}
```

```rust
impl ExtiPin for PB8 {
    type ExtiChannel = EXTI8
}
```

```rust
impl ExtiPin for PB9 {
    type ExtiChannel = EXTI9
}
```

```rust
impl ExtiPin for PC6 {
    type ExtiChannel = EXTI6
}
```

```rust
impl ExtiPin for PC14 {
    type ExtiChannel = EXTI14
}
```

```rust
impl ExtiPin for PC15 {
    type ExtiChannel = EXTI15
}
```

```rust
impl ExtiPin for PF2 {
    type ExtiChannel = EXTI2
}
```

--------------------------------

### Operating Mode Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/can/struct.CanConfigurator.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to start the CAN peripheral in specific operating modes.

```APIDOC
## Operating Mode Methods

### start(self, mode: OperatingMode) -> Can<'d>
Start in mode.

### into_normal_mode(self) -> Can<'d>
Start, entering normal mode.

### into_internal_loopback_mode(self) -> Can<'d>
Start, entering internal loopback mode.

### into_external_loopback_mode(self) -> Can<'d>
Start, entering external loopback mode.
```

--------------------------------

### Implement Instance for I2C2

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/i2c/trait.Instance.html?search=

Example implementation of the Instance trait for the I2C2 peripheral.

```rust
impl Instance for I2C2 {
    type EventInterrupt = I2C2;
    type ErrorInterrupt = I2C2;
}
```

--------------------------------

### Interrupt Implementation Examples

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/interrupt/typelevel/trait.Interrupt.html

Examples of how specific hardware interrupts implement the Interrupt trait by mapping to the corresponding enum variant.

```rust
impl Interrupt for ADC1 {
    const IRQ: Interrupt = super::Interrupt::ADC1
}
```

```rust
impl Interrupt for DMA1_CHANNEL1 {
    const IRQ: Interrupt = super::Interrupt::DMA1_CHANNEL1
}
```

```rust
impl Interrupt for DMA1_CHANNEL2_3 {
    const IRQ: Interrupt = super::Interrupt::DMA1_CHANNEL2_3
}
```

```rust
impl Interrupt for DMAMUX1_DMA1_CH4_5_6_7 {
    const IRQ: Interrupt = super::Interrupt::DMAMUX1_DMA1_CH4_5_6_7
}
```

```rust
impl Interrupt for EXTI0_1 {
    const IRQ: Interrupt = super::Interrupt::EXTI0_1
}
```

```rust
impl Interrupt for EXTI2_3 {
    const IRQ: Interrupt = super::Interrupt::EXTI2_3
}
```

```rust
impl Interrupt for EXTI4_15 {
    const IRQ: Interrupt = super::Interrupt::EXTI4_15
}
```

```rust
impl Interrupt for FDCAN1_IT0 {
    const IRQ: Interrupt = super::Interrupt::FDCAN1_IT0
}
```

```rust
impl Interrupt for FDCAN1_IT1 {
    const IRQ: Interrupt = super::Interrupt::FDCAN1_IT1
}
```

```rust
impl Interrupt for FLASH {
    const IRQ: Interrupt = super::Interrupt::FLASH
}
```

```rust
impl Interrupt for I2C1 {
    const IRQ: Interrupt = super::Interrupt::I2C1
}
```

```rust
impl Interrupt for I2C2 {
    const IRQ: Interrupt = super::Interrupt::I2C2
}
```

```rust
impl Interrupt for RCC {
    const IRQ: Interrupt = super::Interrupt::RCC
}
```

```rust
impl Interrupt for RTC {
    const IRQ: Interrupt = super::Interrupt::RTC
}
```

```rust
impl Interrupt for SPI1 {
    const IRQ: Interrupt = super::Interrupt::SPI1
}
```

```rust
impl Interrupt for SPI2 {
    const IRQ: Interrupt = super::Interrupt::SPI2
}
```

```rust
impl Interrupt for TIM1_BRK_UP_TRG_COM {
    const IRQ: Interrupt = super::Interrupt::TIM1_BRK_UP_TRG_COM
}
```

```rust
impl Interrupt for TIM1_CC {
    const IRQ: Interrupt = super::Interrupt::TIM1_CC
}
```

```rust
impl Interrupt for TIM2 {
    const IRQ: Interrupt = super::Interrupt::TIM2
}
```

```rust
impl Interrupt for TIM3 {
    const IRQ: Interrupt = super::Interrupt::TIM3
}
```

```rust
impl Interrupt for TIM14 {
    const IRQ: Interrupt = super::Interrupt::TIM14
}
```

```rust
impl Interrupt for TIM15 {
    const IRQ: Interrupt = super::Interrupt::TIM15
}
```

```rust
impl Interrupt for TIM16 {
    const IRQ: Interrupt = super::Interrupt::TIM16
}
```

```rust
impl Interrupt for TIM17 {
    const IRQ: Interrupt = super::Interrupt::TIM17
}
```

```rust
impl Interrupt for USART1 {
    const IRQ: Interrupt = super::Interrupt::USART1
}
```

```rust
impl Interrupt for USART2 {
    const IRQ: Interrupt = super::Interrupt::USART2
}
```

```rust
impl Interrupt for USART3_4 {
    const IRQ: Interrupt = super::Interrupt::USART3_4
}
```

```rust
impl Interrupt for WWDG {
    const IRQ: Interrupt = super::Interrupt::WWDG
}
```

--------------------------------

### Implement Instance for I2C1

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/i2c/trait.Instance.html?search=

Example implementation of the Instance trait for the I2C1 peripheral.

```rust
impl Instance for I2C1 {
    type EventInterrupt = I2C1;
    type ErrorInterrupt = I2C1;
}
```

--------------------------------

### Implement Instance for USART peripherals

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/usart/trait.Instance.html

Examples of implementing the Instance trait for specific USART hardware peripherals.

```rust
impl Instance for USART1 {
    type Interrupt = USART1;
}
```

```rust
impl Instance for USART2 {
    type Interrupt = USART2;
}
```

```rust
impl Instance for USART3 {
    type Interrupt = USART3_4;
}
```

```rust
impl Instance for USART4 {
    type Interrupt = USART3_4;
}
```

--------------------------------

### Instance Implementation for FDCAN1

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/can/trait.Instance.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example implementation of the Instance trait for the FDCAN1 peripheral.

```rust
impl Instance for FDCAN1 {
    type IT0Interrupt = FDCAN1_IT0;
    type IT1Interrupt = FDCAN1_IT1;
}
```

--------------------------------

### Operating Mode Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/can/struct.CanConfigurator.html

Methods to start the FDCAN peripheral in specific operating modes.

```APIDOC
## Operating Mode Methods

### pub fn start(self, mode: OperatingMode) -> Can<'d>
Start in mode.

### pub fn into_normal_mode(self) -> Can<'d>
Start, entering normal mode.

### pub fn into_internal_loopback_mode(self) -> Can<'d>
Start, entering internal loopback mode.

### pub fn into_external_loopback_mode(self) -> Can<'d>
Start, entering external loopback mode.
```

--------------------------------

### Implementations of AdvancedInstance1Channel

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/trait.AdvancedInstance1Channel.html

Examples of trait implementation for specific timer instances like TIM1, TIM15, TIM16, and TIM17.

```rust
impl AdvancedInstance1Channel for TIM1 {
    type CommunicationInterrupt = TIM1_BRK_UP_TRG_COM;
    type BreakInputInterrupt = TIM1_BRK_UP_TRG_COM;
}
```

```rust
impl AdvancedInstance1Channel for TIM15 {
    type CommunicationInterrupt = TIM15;
    type BreakInputInterrupt = TIM15;
}
```

```rust
impl AdvancedInstance1Channel for TIM16 {
    type CommunicationInterrupt = TIM16;
    type BreakInputInterrupt = TIM16;
}
```

```rust
impl AdvancedInstance1Channel for TIM17 {
    type CommunicationInterrupt = TIM17;
    type BreakInputInterrupt = TIM17;
}
```

--------------------------------

### ReadableRingBuffer::start

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/dma/struct.ReadableRingBuffer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts the ring buffer operation. This must be called after initialization for the DMA transfer to begin.

```APIDOC
## pub fn start(&mut self)

### Description
Starts the ring buffer operation. You must call this after creating it for it to work.
```

--------------------------------

### Implement Instance for ADC1

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/adc/trait.Instance.html

Example implementation of the Instance trait for the ADC1 peripheral.

```rust
impl Instance for ADC1 {
    type Interrupt = ADC1;
}
```

--------------------------------

### Interrupt Implementation Example

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/interrupt/typelevel/trait.Interrupt.html?search=

Example of implementing the Interrupt trait for a specific peripheral, such as ADC1.

```rust
impl Interrupt for ADC1 {
    const IRQ: Interrupt = super::Interrupt::ADC1
}
```

--------------------------------

### start

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/adc/struct.RingBufferedAdc.html

Turns on the ADC if it is not already active and initiates a continuous DMA transfer. This method can be used to resume a scan after it has been stopped.

```APIDOC
## pub fn start(&mut self)

### Description
Turns on ADC if it is not already turned on and starts continuous DMA transfer. Can be called after stop to resume a suspended scan without repeating the full channel/DMA configuration.
```

--------------------------------

### Flex::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/gpio/struct.Flex.html?search=

Creates a new Flex instance from a peripheral pin.

```APIDOC
## pub fn new(pin: Peri<'d, impl Pin>) -> Self

### Description
Wrap the pin in a `Flex`. The pin remains disconnected. The initial output level is unspecified, but can be changed before the pin is put into output mode.
```

--------------------------------

### Qei::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/qei/struct.Qei.html

Creates a new quadrature decoder driver instance with a standard configuration.

```APIDOC
## pub fn new<CH1: QeiChannel, CH2: QeiChannel>(tim: Peri<'d, T>, ch1: Peri<'d, impl TimerPin<T, CH1>>, ch2: Peri<'d, impl TimerPin<T, CH2>>, config: Config<T>) -> Self

### Description
Initializes a new quadrature decoder driver using the specified timer peripheral, input channels, and configuration settings.
```

--------------------------------

### set_pulse_delay

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/one_pulse/struct.OnePulseChannel.html

Sets the start of the pulse in ticks from the trigger.

```APIDOC
## pub fn set_pulse_delay(&mut self, delay: u32)

### Description
Set the start of the pulse in ticks from the trigger.
```

--------------------------------

### fn init

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/fn.init.html?search=

Initializes the embassy-stm32 HAL with the provided configuration. This function must be called exactly once at startup to obtain the peripheral singletons.

```APIDOC
## fn init(config: Config) -> Peripherals

### Description
Initialize the `embassy-stm32` HAL with the provided configuration. This returns the peripheral singletons that can be used for creating drivers. This should only be called once at startup, otherwise it panics.

### Signature
`pub fn init(config: Config) -> Peripherals`

### Parameters
- **config** (Config) - Required - The configuration object used to initialize the HAL.

### Returns
- **Peripherals** - The peripheral singletons used for creating drivers.
```

--------------------------------

### pulse_delay

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/one_pulse/struct.OnePulseChannel.html

Retrieves the start of the pulse in ticks from the trigger.

```APIDOC
## pub fn pulse_delay(&mut self) -> u32

### Description
Get the start of the pulse in ticks from the trigger.
```

--------------------------------

### frequency<T>()

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/rcc/index.html?search=std%3A%3Avec

Gets the kernel clock frequency of a specific peripheral.

```APIDOC
### Function: frequency<T>()

**Description**: Get the kernel clock frequency of the peripheral `T`.

**Parameters**:
- **T**: The peripheral instance to query.

**Returns**: The frequency of the peripheral.
```

--------------------------------

### WakeGuard::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/rcc/struct.WakeGuard.html

Creates a new instance of WakeGuard.

```APIDOC
## pub fn new() -> Self

### Description
Creates a new instance of the WakeGuard structure.

### Returns
- **Self** - A new instance of WakeGuard.
```

--------------------------------

### SimplePwm::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/simple_pwm/struct.SimplePwm.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new simple PWM driver instance.

```APIDOC
## pub fn new(tim: Peri<'d, T>, ch1: Option<PwmPin<'d, T, Ch1>>, ch2: Option<PwmPin<'d, T, Ch2>>, ch3: Option<PwmPin<'d, T, Ch3>>, ch4: Option<PwmPin<'d, T, Ch4>>, freq: Hertz, counting_mode: CountingMode) -> Self

### Description
Creates a new simple PWM driver instance with the specified timer, pins, frequency, and counting mode.
```

--------------------------------

### Initialize embassy-stm32 HAL

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/fn.init.html?search=

Initializes the HAL with a configuration and returns peripheral singletons. Must be called only once at startup to avoid panics.

```rust
pub fn init(config: Config) -> Peripherals
```

--------------------------------

### Initialize PwmPin

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/simple_pwm/struct.PwmPin.html?search=

Methods for creating a new PWM pin instance, either with default settings or a specific configuration.

```rust
pub fn new(pin: Peri<'d, impl TimerPin<T, C>>, output_type: OutputType) -> Self
```

```rust
pub fn new_with_config( pin: Peri<'d, impl TimerPin<T, C>>, pin_config: PwmPinConfig, ) -> Self
```

--------------------------------

### RegularTrigger Implementations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/adc/trait.RegularTrigger.html?search=

Examples of types implementing the RegularTrigger trait for ADC1.

```rust
impl RegularTrigger<ADC1> for EXTI11_TRG
```

```rust
impl RegularTrigger<ADC1> for TIM1_CC4
```

```rust
impl RegularTrigger<ADC1> for TIM1_TRGO2
```

```rust
impl RegularTrigger<ADC1> for TIM2_TRGO
```

```rust
impl RegularTrigger<ADC1> for TIM3_TRGO
```

```rust
impl RegularTrigger<ADC1> for TIM15_TRGO
```

--------------------------------

### AdcChannel Implementations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/adc/trait.AdcChannel.html?search=

Examples of types implementing the AdcChannel trait for ADC1.

```rust
impl AdcChannel<ADC1> for Peri<'_, PA0>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PA1>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PA2>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PA3>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PA4>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PA5>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PA6>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PA7>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PA8>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PA13>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PA14>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PB0>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PB1>
```

```rust
impl AdcChannel<ADC1> for Peri<'_, PB2>
```

```rust
impl<C: SpecialChannel, T: Instance + ConverterFor<C>> AdcChannel<T> for C
```

--------------------------------

### Spi::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/spi/struct.Spi.html?search=std%3A%3Avec

Creates a new SPI driver instance.

```APIDOC
## pub fn new<T: Instance, D1: TxDma<T>, D2: RxDma<T>>(peri: Peri<'d, T>, sck: Peri<'d, impl SckPin<T>>, mosi: Peri<'d, impl MosiPin<T>>, miso: Peri<'d, impl MisoPin<T>>, tx_dma: Peri<'d, D1>, rx_dma: Peri<'d, D2>, _irq: impl Binding<D1::Interrupt, InterruptHandler<D1>> + Binding<D2::Interrupt, InterruptHandler<D2>> + 'd, config: Config) -> Self

### Description
Initializes a new SPI driver in full-duplex mode using DMA for data transfer.
```

--------------------------------

### Mco::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/rcc/struct.Mco.html

Creates a new instance of the MCO peripheral.

```APIDOC
## pub fn new(peri: Peri<'d, T>, pin: Peri<'d, impl McoPin<T>>, source: T::Source, config: McoConfig) -> Self

### Description
Creates a new MCO instance using the provided peripheral, pin, clock source, and configuration.

### Parameters
- **peri** (Peri<'d, T>) - The MCO peripheral instance.
- **pin** (Peri<'d, impl McoPin<T>>) - The pin assigned to the MCO output.
- **source** (T::Source) - The clock source for the MCO.
- **config** (McoConfig) - The configuration settings for the MCO.
```

--------------------------------

### ComplementaryPwmPin Constructor Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/complementary_pwm/struct.ComplementaryPwmPin.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for initializing a new complementary PWM pin instance, with or without specific configuration.

```rust
pub fn new( pin: Peri<'d, impl TimerComplementaryPin<T, C>>, output_type: OutputType, ) -> Self
```

```rust
pub fn new_with_config( pin: Peri<'d, impl TimerComplementaryPin<T, C>>, pin_config: PwmPinConfig, ) -> Self
```

--------------------------------

### PwmPin::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/simple_pwm/struct.PwmPin.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new PWM pin instance.

```APIDOC
## pub fn new(pin: Peri<'d, impl TimerPin<T, C>>, output_type: OutputType) -> Self

### Description
Creates a new PWM pin instance using the provided pin and output type.

### Parameters
- **pin** (Peri<'d, impl TimerPin<T, C>>) - The pin to be used for PWM.
- **output_type** (OutputType) - The configuration for the output type.
```

--------------------------------

### Control Timer State

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/low_level/struct.Timer.html?search=std%3A%3Avec

Methods to start, stop, reset, or trigger updates on the timer.

```rust
pub fn start(&self)
```

```rust
pub fn generate_update_event(&self)
```

```rust
pub fn stop(&self)
```

```rust
pub fn reset(&self)
```

--------------------------------

### Configure AfType instances

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/gpio/struct.AfType.html?search=

Methods for creating AfType configurations for input and output modes.

```rust
pub const fn input(pull: Pull) -> Self
```

```rust
pub const fn output(output_type: OutputType, speed: Speed) -> Self
```

```rust
pub const fn output_pull( output_type: OutputType, speed: Speed, pull: Pull, ) -> Self
```

--------------------------------

### enable

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/complementary_pwm/struct.ComplementaryPwm.html

Enable the specified PWM channel.

```APIDOC
pub fn enable(&mut self, channel: Channel)
```

--------------------------------

### From Implementation

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/peripherals/struct.PC15.html?search=std%3A%3Avec

Converts the PC15 peripheral into an AnyPin type.

```rust
fn from(val: PC15) -> Self
```

--------------------------------

### Output::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/gpio/struct.Output.html

Creates a new GPIO output driver for a specified pin with an initial level and speed configuration.

```APIDOC
### pub fn new(pin: Peri<'d, impl Pin>, initial_output: Level, speed: Speed) -> Self

Creates a new GPIO output driver for a Pin with the provided Level and Speed configuration.
```

--------------------------------

### Pulse Configuration Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/one_pulse/struct.OnePulse.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to get or set pulse timing and trigger behavior.

```rust
pub fn pulse_end(&self) -> u32
```

```rust
pub fn set_pulse_end(&mut self, ticks: u32)
```

```rust
pub fn set_reset_on_trigger(&mut self, reset: bool)
```

--------------------------------

### InputCapture::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/input_capture/struct.InputCapture.html?search=std%3A%3Avec

Creates a new input capture driver instance.

```APIDOC
## InputCapture::new

### Description
Creates a new input capture driver instance for the specified timer peripheral.

### Signature
`pub fn new(tim: Peri<'d, T>, ch1: Option<CaptureInput<'d, T, Ch1>>, ch2: Option<CaptureInput<'d, T, Ch2>>, ch3: Option<CaptureInput<'d, T, Ch3>>, ch4: Option<CaptureInput<'d, T, Ch4>>, _irq: impl Binding<T::CaptureCompareInterrupt, CaptureCompareInterruptHandler<T>> + 'd, freq: Hertz, counting_mode: CountingMode) -> Self`
```

--------------------------------

### I2S Driver Control Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/i2s/struct.I2S.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to start, stop, and reset the I2S driver state.

```rust
pub fn start(&mut self)
```

```rust
pub fn clear(&mut self)
```

```rust
pub async fn stop(&mut self)
```

--------------------------------

### PwmPin::new_with_config

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/simple_pwm/struct.PwmPin.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new PWM pin instance with a specific configuration.

```APIDOC
## pub fn new_with_config(pin: Peri<'d, impl TimerPin<T, C>>, pin_config: PwmPinConfig) -> Self

### Description
Creates a new PWM pin instance with a specific configuration provided via PwmPinConfig.

### Parameters
- **pin** (Peri<'d, impl TimerPin<T, C>>) - The pin to be used for PWM.
- **pin_config** (PwmPinConfig) - The specific configuration for the PWM pin.
```

--------------------------------

### Get hardware channel identifier

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/adc/struct.BorrowedAdcChannel.html?search=

Retrieves the hardware channel identifier for the borrowed ADC channel.

```rust
pub fn get_hw_channel(&self) -> u8
```

--------------------------------

### Uart Initialization Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/usart/struct.Uart.html

Methods for creating new blocking Uart instances with various pin configurations.

```APIDOC
## new_blocking
Creates a new blocking bidirectional UART.

## new_blocking_with_rtscts
Creates a new bidirectional UART with request-to-send and clear-to-send pins.

## new_blocking_with_de
Creates a new bidirectional UART with a driver-enable pin.

## new_blocking_half_duplex
Creates a single-wire half-duplex Uart transceiver on a single Tx pin.

## new_blocking_half_duplex_on_rx
Creates a single-wire half-duplex Uart transceiver on a single Rx pin.
```

--------------------------------

### Crc::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/crc/struct.Crc.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Instantiates the CRC32 peripheral and initializes it to default values.

```APIDOC
## pub fn new(peripheral: Peri<'d, CRC>, config: Config) -> Self

### Description
Instantiates the CRC32 peripheral and initializes it to default values.
```

--------------------------------

### Async UartTx Initialization and Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/usart/struct.UartTx.html?search=u32+-%3E+bool

Methods for initializing and using an asynchronous transmit-only UART driver.

```rust
pub fn new<T: Instance, D: TxDma<T>>( peri: Peri<'d, T>, tx: Peri<'d, impl TxPin<T>>, tx_dma: Peri<'d, D>, _irq: impl Binding<D::Interrupt, InterruptHandler<D>> + 'd, config: Config, ) -> Result<Self, ConfigError>
```

```rust
pub fn new_with_cts<T: Instance, D: TxDma<T>>( peri: Peri<'d, T>, tx: Peri<'d, impl TxPin<T>>, cts: Peri<'d, impl CtsPin<T>>, tx_dma: Peri<'d, D>, _irq: impl Binding<D::Interrupt, InterruptHandler<D>> + 'd, config: Config, ) -> Result<Self, ConfigError>
```

```rust
pub async fn write(&mut self, buffer: &[u8]) -> Result<(), Error>
```

```rust
pub async fn flush(&mut self, buffer: &[u8]) -> Result<(), Error>
```

--------------------------------

### Get peripheral frequency

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/rcc/fn.frequency.html

Retrieves the kernel clock frequency for the specified peripheral. Panics if the clock is not active.

```rust
pub fn frequency<T: RccPeripheral>() -> Hertz
```

--------------------------------

### setup_ring_buffer

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/low_level/struct.Timer.html?search=

Configures a ring buffer for a specific timer channel using DMA.

```APIDOC
## setup_ring_buffer

### Description
Sets up a ring buffer for the specified timer channel to facilitate DMA-based data handling.

### Signature
`pub fn setup_ring_buffer<'a, W: Word + Into<T::Word>, D: UpDma<T>>( &mut self, dma: Peri<'a, D>, irq: impl Binding<D::Interrupt, InterruptHandler<D>> + 'a, channel: Channel, dma_buf: &'a mut [W], ) -> WritableRingBuffer<'a, W>`
```

--------------------------------

### Qei::new_advanced

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/qei/struct.Qei.html

Creates a new quadrature decoder driver instance with extended encoder configuration options.

```APIDOC
## pub fn new_advanced<CH1: QeiChannel, CH2: QeiChannel>(tim: Peri<'d, T>, ch1: Peri<'d, impl TimerPin<T, CH1>>, ch2: Peri<'d, impl TimerPin<T, CH2>>, config: AdvancedConfig<T>) -> Self

### Description
Initializes a new quadrature decoder driver with advanced encoder options for more complex hardware setups.
```

--------------------------------

### I2S Control and Data Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/i2s/struct.I2S.html

Methods for starting, stopping, reading, writing, and managing the I2S driver state.

```rust
pub fn start(&mut self)
```

```rust
pub fn clear(&mut self)
```

```rust
pub async fn stop(&mut self)
```

```rust
pub fn split<'s>( &'s mut self, ) -> Result<(Reader<'s, 'd, W>, Writer<'s, 'd, W>), Error>
```

```rust
pub async fn read(&mut self, data: &mut [W]) -> Result<(), Error>
```

```rust
pub async fn write(&mut self, data: &[W]) -> Result<(), Error>
```

```rust
pub fn tx_write_pos(&self) -> Option<usize>
```

```rust
pub fn write_immediate(&mut self, data: &[W]) -> Result<(usize, usize), Error>
```

--------------------------------

### FlashSector Struct Definition

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.FlashSector.html

The structure definition for FlashSector, containing fields for bank, index, start address, and size.

```rust
pub struct FlashSector {
    pub bank: FlashBank,
    pub index_in_bank: u8,
    pub start: u32,
    pub size: u32,
}
```

--------------------------------

### Initialize and Read from RingBufferedAdc

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/adc/struct.RingBufferedAdc.html

Demonstrates initializing a RingBufferedAdc with a DMA buffer and reading measurements in an asynchronous loop.

```rust
const DMA_BUF_LEN: usize = 120;
use embassy_stm32::adc::{Adc, AdcChannel}

let mut adc = Adc::new(p.ADC1);
let adc_dma_buf = [0u16; DMA_BUF_LEN];

let mut ring_buffered_adc: RingBufferedAdc<embassy_stm32::peripherals::ADC1> = adc.into_ring_buffered(
    p.DMA2_CH0,
     adc_dma_buf, [
        (p.PA0.reborrow_adc(), SampleTime::CYCLES160_5),
        (p.PA1.reborrow_adc(), SampleTime::CYCLES160_5),
    ].into_iter());


let mut measurements = [0u16; DMA_BUF_LEN / 2];
loop {
    match ring_buffered_adc.read(&mut measurements).await {
        Ok(_) => {
            defmt::info!("adc1: {}", measurements);
        }
        Err(e) => {
            defmt::warn!("Error: {:?}", e);
        }
    }
}
```

--------------------------------

### Channel::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/dma/struct.Channel.html

Creates a new DMA channel driver instance.

```APIDOC
## pub fn new<T: ChannelInstance>( _ch: Peri<'d, T>, _irq: impl Binding<T::Interrupt, InterruptHandler<T>> + 'd ) -> Self

### Description
Creates a new DMA channel driver instance using the provided peripheral and interrupt binding.
```

--------------------------------

### Get maximum reading value for resolution

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/adc/fn.resolution_to_max_count.html

Calculates the maximum possible ADC value based on the provided resolution.

```rust
pub const fn resolution_to_max_count(res: Resolution) -> u32
```

--------------------------------

### PwmInput::new_ch1

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/pwm_input/struct.PwmInput.html?search=

Creates a new PWM input driver instance for channel 1.

```APIDOC
## pub fn new_ch1(tim: Peri<'d, T>, pin: Peri<'d, impl TimerPin<T, Ch1>>, _irq: impl Binding<T::CaptureCompareInterrupt, CaptureCompareInterruptHandler<T>> + 'd, pull: Pull, freq: Hertz) -> Self

### Description
Creates a new PWM input driver for channel 1 of the specified timer peripheral.

### Parameters
- **tim** (Peri<'d, T>) - The timer peripheral instance.
- **pin** (Peri<'d, impl TimerPin<T, Ch1>>) - The pin associated with channel 1.
- **_irq** (impl Binding<T::CaptureCompareInterrupt, CaptureCompareInterruptHandler<T>> + 'd) - The interrupt binding for the timer.
- **pull** (Pull) - The pull configuration for the pin.
- **freq** (Hertz) - The frequency for the timer.
```

--------------------------------

### ComplementaryPwmPin::new_with_config

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/complementary_pwm/struct.ComplementaryPwmPin.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new PWM pin instance with specific configuration.

```APIDOC
## pub fn new_with_config(pin: Peri<'d, impl TimerComplementaryPin<T, C>>, pin_config: PwmPinConfig) -> Self

### Description
Creates a new PWM pin instance with the provided configuration.

### Parameters
- **pin** (Peri<'d, impl TimerComplementaryPin<T, C>>) - The pin to be used for PWM.
- **pin_config** (PwmPinConfig) - The configuration settings for the PWM pin.
```

--------------------------------

### Adc::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/adc/struct.Adc.html

Creates a new ADC driver instance.

```APIDOC
## pub fn new(adc: Peri<'d, T>, resolution: Resolution) -> Self

### Description
Create a new ADC driver instance for the specified peripheral.

### Parameters
- **adc** (Peri<'d, T>) - Required - The ADC peripheral instance.
- **resolution** (Resolution) - Required - The desired ADC resolution.
```

--------------------------------

### Get flash regions signature

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/fn.get_flash_regions.html

Returns a static slice of FlashRegion references representing the available flash memory regions.

```rust
pub fn get_flash_regions() -> &'static [&'static FlashRegion]
```

--------------------------------

### BufferedUart Initialization Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/usart/struct.BufferedUart.html?search=std%3A%3Avec

Methods to initialize the BufferedUart driver with various pin configurations and operational modes.

```APIDOC
## BufferedUart::new

### Description
Creates a new bidirectional buffered UART driver.

## BufferedUart::new_with_rtscts

### Description
Creates a new bidirectional buffered UART driver with request-to-send and clear-to-send pins.

## BufferedUart::new_with_de

### Description
Creates a new bidirectional buffered UART driver with a driver-enable pin.

## BufferedUart::new_half_duplex

### Description
Creates a single-wire half-duplex Uart transceiver on a single Tx pin.
```

--------------------------------

### Create Basic SlaveAddrConfig

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/i2c/struct.SlaveAddrConfig.html?search=u32+-%3E+bool

Initializes a new configuration with 7-bit mode and general call disabled.

```rust
pub fn basic(addr: u8) -> Self
```

--------------------------------

### Implement ChannelInstance for DMA Channels

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/dma/trait.ChannelInstance.html

Examples of implementing the ChannelInstance trait for various DMA channels, specifying their respective interrupt types.

```rust
impl ChannelInstance for DMA1_CH1 {
    type Interrupt = DMA1_CHANNEL1
}
```

```rust
impl ChannelInstance for DMA1_CH2 {
    type Interrupt = DMA1_CHANNEL2_3
}
```

```rust
impl ChannelInstance for DMA1_CH3 {
    type Interrupt = DMA1_CHANNEL2_3
}
```

```rust
impl ChannelInstance for DMA1_CH4 {
    type Interrupt = DMAMUX1_DMA1_CH4_5_6_7
}
```

```rust
impl ChannelInstance for DMA1_CH5 {
    type Interrupt = DMAMUX1_DMA1_CH4_5_6_7
}
```

```rust
impl ChannelInstance for DMA1_CH6 {
    type Interrupt = DMAMUX1_DMA1_CH4_5_6_7
}
```

```rust
impl ChannelInstance for DMA1_CH7 {
    type Interrupt = DMAMUX1_DMA1_CH4_5_6_7
}
```

--------------------------------

### setup_update_dma

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/low_level/struct.Timer.html?search=

Generates a sequence of PWM waveforms using the TIMx_UP DMA channel.

```APIDOC
## setup_update_dma

### Description
Generates a sequence of PWM waveforms. Requires the corresponding TIMx_UP DMA channel.

### Signature
`pub fn setup_update_dma<'a, W: Word + Into<T::Word>, D: UpDma<T>>( &mut self, dma: Peri<'a, D>, irq: impl Binding<D::Interrupt, InterruptHandler<D>> + 'a, channel: Channel, duty: &'a [W], ) -> Transfer<'a>`
```

--------------------------------

### Get device unique ID as hex string

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/uid/fn.uid_hex.html

Returns the 96-bit unique ID of the device formatted as a 24-character hexadecimal string.

```rust
pub fn uid_hex() -> &'static str
```

--------------------------------

### Blocking Flash Operations

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/flash/struct.Flash.html?search=

Methods for performing flash operations in blocking mode. Note that offsets are relative to the flash start, not absolute memory addresses.

```rust
pub fn new_blocking(p: Peri<'d, FLASH>) -> Self
```

```rust
pub fn into_blocking_regions(self) -> FlashLayout<'d, Blocking>
```

```rust
pub fn blocking_read( &mut self, offset: u32, bytes: &mut [u8], ) -> Result<(), Error>
```

```rust
pub fn blocking_write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Error>
```

```rust
pub fn blocking_erase(&mut self, from: u32, to: u32) -> Result<(), Error>
```

--------------------------------

### Get device unique ID as hex bytes

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/uid/fn.uid_hex_bytes.html

Retrieves the 96-bit unique ID of the device, returning it as a static reference to a 24-byte array of hexadecimal ASCII characters.

```rust
pub fn uid_hex_bytes() -> &'static [u8; 24]
```

--------------------------------

### Initialize Timer

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/low_level/struct.Timer.html?search=std%3A%3Avec

Create a new instance of the timer driver.

```rust
pub fn new(tim: Peri<'d, T>) -> Self
```

--------------------------------

### I2C Driver Initialization

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/i2c/struct.I2c.html?search=std%3A%3Avec

Methods for creating new I2C driver instances with or without DMA support.

```APIDOC
## I2c::new

### Description
Creates a new asynchronous I2C driver with DMA support.

## I2c::new_no_dma

### Description
Creates a new asynchronous I2C driver without DMA support.

## I2c::new_blocking

### Description
Creates a new blocking I2C driver.
```

--------------------------------

### Rtc::new

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/rtc/struct.Rtc.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new instance of the RTC driver.

```APIDOC
## pub fn new(_rtc: Peri<'static, RTC>, rtc_config: RtcConfig) -> (Self, RtcTimeProvider)

### Description
Creates a new RTC instance using the provided peripheral and configuration.

### Parameters
- **_rtc** (Peri<'static, RTC>) - The RTC peripheral instance.
- **rtc_config** (RtcConfig) - The configuration settings for the RTC.
```

--------------------------------

### Qei Driver Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/qei/struct.Qei.html?search=

Methods available for the Qei quadrature decoder driver.

```APIDOC
## Qei::new

### Description
Creates a new quadrature decoder driver with a standard configuration.

### Signature
`pub fn new<CH1: QeiChannel, CH2: QeiChannel>(tim: Peri<'d, T>, ch1: Peri<'d, impl TimerPin<T, CH1>>, ch2: Peri<'d, impl TimerPin<T, CH2>>, config: Config<T>) -> Self`

## Qei::new_advanced

### Description
Creates a new quadrature decoder driver with extended encoder options.

### Signature
`pub fn new_advanced<CH1: QeiChannel, CH2: QeiChannel>(tim: Peri<'d, T>, ch1: Peri<'d, impl TimerPin<T, CH1>>, ch2: Peri<'d, impl TimerPin<T, CH2>>, config: AdvancedConfig<T>) -> Self`

## Qei::read_direction

### Description
Retrieves the current direction of the encoder.

### Signature
`pub fn read_direction(&self) -> Direction`

## Qei::count

### Description
Retrieves the current encoder count.

### Signature
`pub fn count(&self) -> u32`

## Qei::reset

### Description
Resets the encoder count to zero.

### Signature
`pub fn reset(&mut self)`
```

--------------------------------

### Flex GPIO Methods

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/gpio/struct.Flex.html?search=u32+-%3E+bool

Methods for configuring and interacting with a flexible GPIO pin.

```APIDOC
## Flex Methods

### new(pin: Peri<'d, impl Pin>) -> Self
Creates a new Flex instance from a pin. The pin starts in a disconnected state.

### set_as_input(&mut self, pull: Pull)
Configures the pin as an input with optional internal pull-up or pull-down resistors.

### set_as_output(&mut self, speed: Speed)
Configures the pin as a push-pull output.

### set_as_input_output(&mut self, speed: Speed)
Configures the pin as an input and open-drain output.

### set_as_analog(&mut self)
Configures the pin for analog mode, typically used by ADC or COMP peripherals.

### is_high(&self) -> bool
Returns true if the current input level is high.

### is_low(&self) -> bool
Returns true if the current input level is low.

### set_high(&mut self)
Sets the output level to high.

### set_low(&mut self)
Sets the output level to low.

### toggle(&mut self)
Inverts the current output level.
```

--------------------------------

### Implementations of GeneralInstance1Channel

Source: https://docs.embassy.dev/embassy-stm32/git/stm32c092kb/timer/trait.GeneralInstance1Channel.html?search=

Implementations for various timer instances including their respective interrupt types.

```rust
impl GeneralInstance1Channel for TIM1 {
    type CaptureCompareInterrupt = TIM1_CC
}
```

```rust
impl GeneralInstance1Channel for TIM2 {
    type CaptureCompareInterrupt = TIM2
}
```

```rust
impl GeneralInstance1Channel for TIM3 {
    type CaptureCompareInterrupt = TIM3
}
```

```rust
impl GeneralInstance1Channel for TIM14 {
    type CaptureCompareInterrupt = TIM14
}
```

```rust
impl GeneralInstance1Channel for TIM15 {
    type CaptureCompareInterrupt = TIM15
}
```

```rust
impl GeneralInstance1Channel for TIM16 {
    type CaptureCompareInterrupt = TIM16
}
```

```rust
impl GeneralInstance1Channel for TIM17 {
    type CaptureCompareInterrupt = TIM17
}
```
Tokens:
Raw