Merge #454

454: fix PwmExt r=therealprof a=burrbull



Co-authored-by: Andrey Zgarbul <[email protected]>

Author: bors[bot]

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+- Make `Monotonic` implementation generic for `u32` timers, fix `PwmExt` trait [#454]
 - Rename `Delay<SYST>` to SysDelay, remove old `Delay<TIM2>`
 - Extend timers to 32bit on `Delay`
 - Move `MonoTimer` from `timer` to dwt mode [#448]
@@ -65,6 +66,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 [#447]: https://github.com/stm32-rs/stm32f4xx-hal/pull/447
 [#448]: https://github.com/stm32-rs/stm32f4xx-hal/pull/448
 [#449]: https://github.com/stm32-rs/stm32f4xx-hal/pull/449
+[#454]: https://github.com/stm32-rs/stm32f4xx-hal/pull/454
 
 ### Changed
 

examples/pwm-sinus.rs

@@ -20,7 +20,7 @@ fn main() -> ! {
         let gpioa = dp.GPIOA.split();
         let channels = (gpioa.pa8.into_alternate(), gpioa.pa9.into_alternate());
 
-        let mut pwm = dp.TIM1.pwm_us(&clocks, channels, 100.micros());
+        let mut pwm = dp.TIM1.pwm_us(channels, 100.micros(), &clocks);
         let mut counter = dp.TIM2.counter_us(&clocks);
         let max_duty = pwm.get_max_duty();
 

examples/pwm.rs

@@ -18,7 +18,7 @@ fn main() -> ! {
         let gpioa = dp.GPIOA.split();
         let channels = (gpioa.pa8.into_alternate(), gpioa.pa9.into_alternate());
 
-        let pwm = dp.TIM1.pwm_hz(&clocks, channels, 20.kHz()).split();
+        let pwm = dp.TIM1.pwm_hz(channels, 20.kHz(), &clocks).split();
         let (mut ch1, _ch2) = pwm;
         let max_duty = ch1.get_max_duty();
         ch1.set_duty(max_duty / 2);

src/prelude.rs

@@ -73,7 +73,6 @@ pub use crate::spi::SpiExt as _stm32f4xx_hal_spi_SpiExt;
 pub use crate::syscfg::SysCfgExt as _stm32f4xx_hal_syscfg_SysCfgExt;
 pub use crate::time::U32Ext as _stm32f4xx_hal_time_U32Ext;
 #[cfg(feature = "rtic")]
-#[cfg(not(feature = "stm32f410"))]
 pub use crate::timer::MonoTimerExt as _stm32f4xx_hal_timer_MonoTimerExt;
 pub use crate::timer::PwmExt as _stm32f4xx_hal_timer_PwmExt;
 pub use crate::timer::SysTimerExt as _stm32f4xx_hal_timer_SysCounterExt;

src/timer.rs

@@ -22,15 +22,11 @@ mod pins;
 pub use pins::*;
 pub mod pwm;
 pub use pwm::*;
-#[cfg(not(feature = "stm32f410"))]
 pub mod pwm_input;
-#[cfg(not(feature = "stm32f410"))]
 pub use pwm_input::PwmInput;
 #[cfg(feature = "rtic")]
-#[cfg(not(feature = "stm32f410"))]
 pub mod monotonic;
 #[cfg(feature = "rtic")]
-#[cfg(not(feature = "stm32f410"))]
 pub use monotonic::*;
 
 mod hal_02;
@@ -233,6 +229,7 @@ mod sealed {
         fn get_interrupt_flag(&self) -> Event;
         fn read_count(&self) -> Self::Width;
         fn start_one_pulse(&mut self);
+        fn start_no_update(&mut self);
         fn cr1_reset(&mut self);
     }
 
@@ -353,6 +350,10 @@ macro_rules! hal {
                     self.cr1.write(|w| unsafe { w.bits(1 << 3) }.cen().set_bit());
                 }
                 #[inline(always)]
+                fn start_no_update(&mut self) {
+                    self.cr1.write(|w| w.cen().set_bit().udis().set_bit());
+                }
+                #[inline(always)]
                 fn cr1_reset(&mut self) {
                     self.cr1.reset();
                 }
@@ -726,7 +727,6 @@ impl<TIM: Instance + MasterTimer, const FREQ: u32> FTimer<TIM, FREQ> {
 pub(crate) const fn compute_arr_presc(freq: u32, clock: u32) -> (u16, u32) {
     let ticks = clock / freq;
     let psc = (ticks - 1) / (1 << 16);
-    assert!(psc <= u16::MAX as u32);
     let arr = ticks / (psc + 1) - 1;
     (psc as u16, arr)
 }

src/timer/monotonic.rs

@@ -1,5 +1,5 @@
 // RTIC Monotonic impl for the 32-bit timers
-use super::{FTimer, Instance};
+use super::{Channel, Event, FTimer, General, Instance, WithPwm};
 use crate::rcc::Clocks;
 use core::ops::{Deref, DerefMut};
 pub use fugit::{self, ExtU32};
@@ -39,64 +39,55 @@ pub trait MonoTimerExt: Sized {
     }
 }
 
-macro_rules! mono {
-    ($($TIM:ty,)+) => {
-        $(
-            impl MonoTimerExt for $TIM {
-                fn monotonic<const FREQ: u32>(self, clocks: &Clocks) -> MonoTimer<Self, FREQ> {
-                    FTimer::new(self, clocks).monotonic()
-                }
-            }
-
-            impl<const FREQ: u32> FTimer<$TIM, FREQ> {
-                pub fn monotonic(self) -> MonoTimer<$TIM, FREQ> {
-                    MonoTimer::<$TIM, FREQ>::_new(self)
-                }
-            }
+impl<TIM> MonoTimerExt for TIM
+where
+    Self: Instance + General<Width = u32> + WithPwm,
+{
+    fn monotonic<const FREQ: u32>(self, clocks: &Clocks) -> MonoTimer<Self, FREQ> {
+        FTimer::new(self, clocks).monotonic()
+    }
+}
 
-            impl<const FREQ: u32> MonoTimer<$TIM, FREQ> {
-                fn _new(timer: FTimer<$TIM, FREQ>) -> Self {
-                    timer.tim.arr.write(|w| unsafe { w.bits(u32::MAX) });
-                    timer.tim.egr.write(|w| w.ug().set_bit());
-                    timer.tim.sr.modify(|_, w| w.uif().clear_bit());
-                    timer.tim.cr1.modify(|_, w| w.cen().set_bit().udis().set_bit());
-                    Self(timer)
-                }
-            }
+impl<TIM, const FREQ: u32> FTimer<TIM, FREQ>
+where
+    TIM: Instance + General<Width = u32> + WithPwm,
+{
+    pub fn monotonic(mut self) -> MonoTimer<TIM, FREQ> {
+        unsafe {
+            self.tim.set_auto_reload_unchecked(TIM::max_auto_reload());
+        }
+        self.tim.trigger_update();
+        self.tim.start_no_update();
+        MonoTimer(self)
+    }
+}
 
-            impl<const FREQ: u32> Monotonic for MonoTimer<$TIM, FREQ> {
-                type Instant = fugit::TimerInstantU32<FREQ>;
-                type Duration = fugit::TimerDurationU32<FREQ>;
+impl<TIM, const FREQ: u32> Monotonic for MonoTimer<TIM, FREQ>
+where
+    TIM: Instance + General<Width = u32> + WithPwm,
+{
+    type Instant = fugit::TimerInstantU32<FREQ>;
+    type Duration = fugit::TimerDurationU32<FREQ>;
 
-                unsafe fn reset(&mut self) {
-                    self.tim.dier.modify(|_, w| w.cc1ie().set_bit());
-                }
+    unsafe fn reset(&mut self) {
+        self.tim.listen_interrupt(Event::C1, true);
+    }
 
-                #[inline(always)]
-                fn now(&mut self) -> Self::Instant {
-                    Self::Instant::from_ticks(self.tim.cnt.read().cnt().bits())
-                }
+    #[inline(always)]
+    fn now(&mut self) -> Self::Instant {
+        Self::Instant::from_ticks(self.tim.read_count())
+    }
 
-                fn set_compare(&mut self, instant: Self::Instant) {
-                    self.tim
-                        .ccr1
-                        .write(|w| w.ccr().bits(instant.duration_since_epoch().ticks()));
-                }
+    fn set_compare(&mut self, instant: Self::Instant) {
+        TIM::set_cc_value(Channel::C1 as u8, instant.duration_since_epoch().ticks());
+    }
 
-                fn clear_compare_flag(&mut self) {
-                    self.tim.sr.modify(|_, w| w.cc1if().clear_bit());
-                }
+    fn clear_compare_flag(&mut self) {
+        self.tim.clear_interrupt_flag(Event::C1);
+    }
 
-                #[inline(always)]
-                fn zero() -> Self::Instant {
-                    Self::Instant::from_ticks(0)
-                }
-            }
-        )+
+    #[inline(always)]
+    fn zero() -> Self::Instant {
+        Self::Instant::from_ticks(0)
     }
 }
-
-mono!(crate::pac::TIM5,);
-
-#[cfg(feature = "tim2")]
-mono!(crate::pac::TIM2,);

src/timer/pwm.rs

@@ -90,45 +90,56 @@ where
 {
 }
 
-pub trait PwmExt<P, PINS>
+pub trait PwmExt
 where
     Self: Sized + Instance + WithPwm,
-    PINS: Pins<Self, P>,
 {
-    fn pwm<const FREQ: u32>(
+    fn pwm<P, PINS, const FREQ: u32>(
         self,
-        clocks: &Clocks,
         pins: PINS,
         time: TimerDurationU32<FREQ>,
-    ) -> Pwm<Self, P, PINS, FREQ>;
+        clocks: &Clocks,
+    ) -> Pwm<Self, P, PINS, FREQ>
+    where
+        PINS: Pins<Self, P>;
 
-    fn pwm_hz(self, clocks: &Clocks, pins: PINS, freq: Hertz) -> PwmHz<Self, P, PINS>;
+    fn pwm_hz<P, PINS>(self, pins: PINS, freq: Hertz, clocks: &Clocks) -> PwmHz<Self, P, PINS>
+    where
+        PINS: Pins<Self, P>;
 
-    fn pwm_us(
+    fn pwm_us<P, PINS>(
         self,
-        clocks: &Clocks,
         pins: PINS,
         time: TimerDurationU32<1_000_000>,
-    ) -> Pwm<Self, P, PINS, 1_000_000> {
-        self.pwm::<1_000_000>(clocks, pins, time)
+        clocks: &Clocks,
+    ) -> Pwm<Self, P, PINS, 1_000_000>
+    where
+        PINS: Pins<Self, P>,
+    {
+        self.pwm::<_, _, 1_000_000>(pins, time, clocks)
     }
 }
 
-impl<TIM, P, PINS> PwmExt<P, PINS> for TIM
+impl<TIM> PwmExt for TIM
 where
     Self: Sized + Instance + WithPwm,
-    PINS: Pins<Self, P>,
 {
-    fn pwm<const FREQ: u32>(
+    fn pwm<P, PINS, const FREQ: u32>(
         self,
-        clocks: &Clocks,
         pins: PINS,
         time: TimerDurationU32<FREQ>,
-    ) -> Pwm<TIM, P, PINS, FREQ> {
+        clocks: &Clocks,
+    ) -> Pwm<TIM, P, PINS, FREQ>
+    where
+        PINS: Pins<Self, P>,
+    {
         FTimer::<Self, FREQ>::new(self, clocks).pwm(pins, time)
     }
 
-    fn pwm_hz(self, clocks: &Clocks, pins: PINS, time: Hertz) -> PwmHz<TIM, P, PINS> {
+    fn pwm_hz<P, PINS>(self, pins: PINS, time: Hertz, clocks: &Clocks) -> PwmHz<TIM, P, PINS>
+    where
+        PINS: Pins<Self, P>,
+    {
         Timer::new(self, clocks).pwm_hz(pins, time)
     }
 }