Merge pull request #75 from stm32-rs/feature/pwm-dymamic-freq

PWM updates

Author: andresv

examples/adc.rs

@@ -9,7 +9,7 @@ extern crate panic_halt;
 extern crate stm32g0xx_hal as hal;
 
 use cortex_m_semihosting::hprintln;
-use hal::analog::adc::{OversamplingRatio, Precision, SampleTime, VTemp};
+use hal::analog::adc::{OversamplingRatio, Precision, SampleTime, VBat};
 use hal::prelude::*;
 use hal::stm32;
 use rt::entry;
@@ -35,14 +35,12 @@ fn main() -> ! {
 
     let mut adc_pin = gpioa.pa0.into_analog();
 
-    let mut vtemp = VTemp::new();
-    vtemp.enable(&mut adc);
+    let mut vbat = VBat::new();
+    vbat.enable(&mut adc);
 
     loop {
-        let temp: u32 = adc.read(&mut vtemp).expect("temperature read failed");
-        let u_raw: u32 = adc.read(&mut adc_pin).expect("adc read failed");
         let u_mv = adc.read_voltage(&mut adc_pin).expect("adc read failed");
-
-        hprintln!("U raw: {} | U: {} mV | t: {}°C", u_raw, u_mv, temp / 42).unwrap();
+        let u_bat = adc.read_voltage(&mut vbat).expect("adc read failed");
+        hprintln!("VBat: {}mV | PA0: {}mV", u_bat * 3, u_mv).unwrap();
     }
 }

examples/pwm.rs

@@ -20,7 +20,7 @@ fn main() -> ! {
 
     let mut rcc = dp.RCC.constrain();
     let gpioa = dp.GPIOA.split(&mut rcc);
-    let pwm = dp.TIM1.pwm(10.khz(), &mut rcc);
+    let mut pwm = dp.TIM1.pwm(10.khz(), &mut rcc);
 
     let mut pwm_ch1 = pwm.bind_pin(gpioa.pa8);
     let mut pwm_ch2 = pwm.bind_pin(gpioa.pa9);
@@ -41,6 +41,8 @@ fn main() -> ! {
     pwm_ch2.set_duty(max / 16);
     asm::bkpt();
 
+    pwm.set_freq(20.khz());
+
     loop {}
 }
 

examples/stopwatch.rs

@@ -42,28 +42,20 @@ fn main() -> ! {
     });
     hprintln!("Timer: 100 us -> {} us", elapsed_us.0).unwrap();
 
-    let elapsed_us = stopwatch.trace(|| {
-        let x = calc_something();
-        assert!(x > 0);
-    });
+    let elapsed_us = stopwatch.trace(calc_something);
     hprintln!("Calc @ 16 MHz: {} us", elapsed_us.0).unwrap();
 
     let rcc = rcc.freeze(Config::new(SysClockSrc::PLL));
     stopwatch.set_clock(rcc.clocks.apb_tim_clk);
 
-    let elapsed_us = stopwatch.trace(|| {
-        let x = calc_something();
-        assert!(x > 0);
-    });
+    let elapsed_us = stopwatch.trace(calc_something);
     hprintln!("Calc @ 64 MHz: {} us", elapsed_us.0).unwrap();
 
     loop {}
 }
 
-fn calc_something() -> u32 {
-    let mut result = 0;
-    for i in 1..1000 {
-        result = (result + i) / 3
+fn calc_something() {
+    for _ in 1..100_500 {
+        cortex_m::asm::nop();
     }
-    result
 }

src/timer/pwm.rs

@@ -8,6 +8,7 @@ use crate::timer::pins::TimerPin;
 use crate::timer::*;
 
 pub struct Pwm<TIM> {
+    clk: Hertz,
     tim: PhantomData<TIM>,
 }
 
@@ -47,24 +48,33 @@ macro_rules! pwm {
                 }
             }
 
-            fn $timX<T>(tim: $TIMX, freq: T, rcc: &mut Rcc) -> Pwm<$TIMX>
-            where
-                T: Into<Hertz>,
-            {
+            fn $timX<F: Into<Hertz>>(_tim: $TIMX, freq: F, rcc: &mut Rcc) -> Pwm<$TIMX> {
                 $TIMX::enable(rcc);
                 $TIMX::reset(rcc);
 
-                let ratio = rcc.clocks.apb_tim_clk / freq.into();
-                let psc = (ratio - 1) / 0xffff;
-                let arr = ratio / (psc + 1) - 1;
-                tim.psc.write(|w| unsafe { w.psc().bits(psc as u16) });
-                tim.arr.write(|w| unsafe { w.$arr().bits(arr as u16) });
-                $(
-                    tim.arr.modify(|_, w| unsafe { w.$arr_h().bits((arr >> 16) as u16) });
-                )*
-                tim.cr1.write(|w| w.cen().set_bit());
-                Pwm {
-                    tim: PhantomData
+                let mut pwm = Pwm::<$TIMX> {
+                    clk: rcc.clocks.apb_tim_clk,
+                    tim: PhantomData,
+                };
+                pwm.set_freq(freq);
+                pwm
+            }
+
+            impl Pwm<$TIMX> {
+                pub fn set_freq<F: Into<Hertz>>(&mut self, freq: F) {
+                    let ratio = self.clk / freq.into();
+                    let psc = (ratio - 1) / 0xffff;
+                    let arr = ratio / (psc + 1) - 1;
+
+                    unsafe {
+                        let tim = &*$TIMX::ptr();
+                        tim.psc.write(|w| w.psc().bits(psc as u16));
+                        tim.arr.write(|w| w.$arr().bits(arr as u16));
+                        $(
+                            tim.arr.modify(|_, w| w.$arr_h().bits((arr >> 16) as u16));
+                        )*
+                        tim.cr1.write(|w| w.cen().set_bit())
+                    }
                 }
             }
         )+