generic impl od monotonic

Author: burrbull

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
 

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();
                 }

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,);