Struct stm32wlxx_hal::lptim::LpTim3

pub struct LpTim3 { /* private fields */ }

Low-power timer 3 driver.

Implementations

impl LpTim3

pub fn new_trigger_pin( &mut self, pin: A11, filter: Filter, pol: TrgPol, cs: &CriticalSection ) -> LpTim3Trg

Setup a new pin trigger.

Panics

• (debug) timer is enabled.

Example

Setup a one-shot timer that starts after a transition on pin A11.

use stm32wlxx_hal::{
    cortex_m,
    embedded_hal::timer::CountDown,
    gpio::PortA,
    lptim::{self, Filter, LpTim, LpTim3, LpTim3Trg, Prescaler::Div1, TrgPol},
    pac,
};

let mut dp: pac::Peripherals = pac::Peripherals::take().unwrap();

// enable the HSI16 source clock
dp.RCC.cr.modify(|_, w| w.hsion().set_bit());
while dp.RCC.cr.read().hsirdy().is_not_ready() {}

let pa: PortA = PortA::split(dp.GPIOA, &mut dp.RCC);
let mut lptim3: LpTim3 = LpTim3::new(dp.LPTIM3, lptim::Clk::Hsi16, Div1, &mut dp.RCC);
let lptim3trg: LpTim3Trg = cortex_m::interrupt::free(|cs| {
    lptim3.new_trigger_pin(pa.a11, Filter::Any, TrgPol::Both, cs)
});
lptim3.start(12_345_u16);
// timer will only start after any transition on pin A11
nb::block!(lptim3.wait());

pub fn free_trigger_pin(&mut self, pin: LpTim3Trg) -> A11

Free the trigger pin previously created with new_trigger_pin.

This is will the trigger source to a software trigger.

Panics

• (debug) timer is enabled.

Example

Setup a one-shot timer that starts after a transition on pin A11.

use stm32wlxx_hal::{
    embedded_hal::timer::CountDown,
    gpio::PortA,
    lptim::{self, Filter, LpTim, LpTim3, LpTim3Trg, Prescaler::Div1, TrgPol},
    pac,
};

let mut dp: pac::Peripherals = pac::Peripherals::take().unwrap();

// enable the HSI16 source clock
dp.RCC.cr.modify(|_, w| w.hsion().set_bit());
while dp.RCC.cr.read().hsirdy().is_not_ready() {}

let pa: PortA = PortA::split(dp.GPIOA, &mut dp.RCC);
let mut lptim3: LpTim3 = LpTim3::new(dp.LPTIM3, lptim::Clk::Hsi16, Div1, &mut dp.RCC);
let lptim3trg: LpTim3Trg = cortex_m::interrupt::free(|cs| {
    lptim3.new_trigger_pin(pa.a11, Filter::Any, TrgPol::Both, cs)
});
lptim3.start(12_345_u16);
// timer will only start after any transition on pin A11
nb::block!(lptim3.wait());

// free the pin
let a11 = lptim3.free_trigger_pin(lptim3trg);

impl LpTim3

pub fn new_output_pin(&mut self, pin: A1, cs: &CriticalSection) -> LpTim3OutPin

Setup a new output pin.

pub fn free_output_pin(&mut self, pin: LpTim3OutPin) -> A1

Free the output pin previously created with new_output_pin.

Trait Implementations

impl Debug for LpTim3

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

Formats the value using the given formatter.

impl LpTim for LpTim3

type TrgSel = TrgSel3

Trigger selection options.

fn new(tim: Self::Pac, clk: Clk, pre: Prescaler, rcc: &mut RCC) -> Self

Create a new LPTIM driver.

fn free(self) -> Self::Pac

Free the LPTIM registers from the driver.

unsafe fn pulse_reset(rcc: &mut RCC)

Reset the LPTIM peripheral.

fn enable_clock(rcc: &mut RCC)

Enable clocks for the LPTIM peripheral.

unsafe fn disable_clock(rcc: &mut RCC)

Disable the LPTIM peripheral clock.

fn clk(rcc: &RCC) -> Clk

Get the clock source.

fn hz(&self) -> &Ratio<u32>

Get the clock speed in hertz.

fn cnt() -> u16

Get the timer count.

fn isr() -> u32

Get the interrupt status.

fn set_ier(&mut self, ier: u32)

Enable and disable interrupts.

unsafe fn set_icr(&mut self, icr: u32)

Clear interrupts.

fn is_enabled(&self) -> bool

Returns true if the timer is enabled.

fn setup_trigger(&mut self, filter: Filter, pol: TrgPol, sel: Self::TrgSel)

Setup a non-pin trigger.

fn set_max_duty(&mut self, duty: u16)

Set the maximum duty cycle (autoreload value).

impl PwmPin for LpTim3

type Duty = u16

Type for the duty methods

fn disable(&mut self)

Disables a PWM channel

fn enable(&mut self)

Enables a PWM channel

fn get_duty(&self) -> Self::Duty

Returns the current duty cycle

fn get_max_duty(&self) -> Self::Duty

Returns the maximum duty cycle value

fn set_duty(&mut self, duty: Self::Duty)

Sets a new duty cycle

impl CountDown for LpTim3

type Time = u16

The unit of time used by this timer

fn start<T>(&mut self, count: T)where T: Into<Self::Time>,

Starts a new count down

fn wait(&mut self) -> Result<(), Void>

Non-blockingly “waits” until the count down finishes