Merge pull request #771 from stm32-rs/monotonic-ccr

monotonics fix: CC1 instead of CC3

Author: burrbull

.github/workflows/ci.yml

@@ -46,7 +46,7 @@ jobs:
           - rust: nightly
             mcu: stm32f479
             experimental: true
-            features: usb_fs,sdio-host,can,i2s,fsmc_lcd,rtic2,rtic-tim2
+            features: usb_fs,sdio-host,can,i2s,fsmc_lcd,rtic2,rtic-tim3
 
     steps:
       - uses: actions/checkout@v4

CHANGELOG.md

@@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Changed
 
  - Use `stm32f4-staging` until `stm32f4` is released [#706]
+ - RTIC2 monotonics fix: CC1 instead of CC3
  - Allow different lengths of buffers in hal_1 SpiBus impl [#566]
 
 [#566]: https://github.com/stm32-rs/stm32f4xx-hal/pull/566

Cargo.toml

@@ -679,7 +679,7 @@ required-features = ["tim2", "rtic1"]
 
 [[example]]
 name = "rtic2-tick"
-required-features = ["rtic2", "rtic-tim2"]
+required-features = ["rtic2", "rtic-tim3"]
 
 [[example]]
 name = "rtic-usart-shell"

examples/rtic2-tick.rs

@@ -10,7 +10,7 @@ use stm32f4xx_hal::{
     pac,
     prelude::*,
 };
-type Mono = stm32f4xx_hal::timer::MonoTimerUs<pac::TIM2>;
+type Mono = stm32f4xx_hal::timer::MonoTimerUs<pac::TIM3>;
 
 // Uncomment if use SysTick as monotonic timer
 //use rtic_monotonics::systick::prelude::*;
@@ -35,8 +35,8 @@ mod app {
         let rcc = ctx.device.RCC.constrain();
         let clocks = rcc.cfgr.sysclk(48.MHz()).freeze();
 
-        // Create TIM2 monotonic and initialize timer queue
-        ctx.device.TIM2.monotonic_us(&mut ctx.core.NVIC, &clocks);
+        // Create TIM3 monotonic and initialize timer queue
+        ctx.device.TIM3.monotonic_us(&mut ctx.core.NVIC, &clocks);
 
         // Uncomment if use SysTick as monotonic timer
         //Mono::start(ctx.core.SYST, 48_000_000);

src/timer/monotonics.rs

@@ -139,7 +139,7 @@ macro_rules! __internal_create_stm32_timer_interrupt {
 }
 
 macro_rules! make_timer {
-    ($tim: ident, $timer:ident, $bits:ident, $overflow:ident, $tq:ident$(, doc: ($($doc:tt)*))?) => {
+    ($tim: ident, $timer:ident, $overflow:ident, $tq:ident$(, doc: ($($doc:tt)*))?) => {
         static $overflow: AtomicU64 = AtomicU64::new(0);
         static $tq: TimerQueue<MonoTimerBackend<pac::$timer>> = TimerQueue::new();
 
@@ -164,10 +164,14 @@ macro_rules! make_timer {
                 self.tim.dier().modify(|_, w| w.uie().set_bit());
 
                 // Configure and enable half-period interrupt
-                self.tim
-                    .ccr(2)
-                    .write(|w| w.ccr().set(($bits::MAX - ($bits::MAX >> 1)).into()));
-                self.tim.dier().modify(|_, w| w.cc3ie().set_bit());
+                self.tim.ccr1().write(|w| {
+                    w.ccr().set(
+                        (<pac::$timer as General>::Width::MAX
+                            - (<pac::$timer as General>::Width::MAX >> 1))
+                            .into(),
+                    )
+                });
+                self.tim.dier().modify(|_, w| w.cc1ie().set_bit());
 
                 // Trigger an update event to load the prescaler value to the clock.
                 self.tim.egr().write(|w| w.ug().set_bit());
@@ -206,23 +210,24 @@ macro_rules! make_timer {
             fn now() -> Self::Ticks {
                 calculate_now(
                     || $overflow.load(Ordering::Relaxed),
-                    || Self::tim().cnt().read().bits(),
+                    || Self::tim().cnt().read().cnt().bits(),
                 )
             }
 
             fn set_compare(instant: Self::Ticks) {
                 let now = Self::now();
 
                 // Since the timer may or may not overflow based on the requested compare val, we check how many ticks are left.
-                // `wrapping_sup` takes care of the u64 integer overflow special case.
-                let val = if instant.wrapping_sub(now) <= ($bits::MAX as u64) {
-                    instant as $bits
-                } else {
-                    // In the past or will overflow
-                    0
-                };
-
-                Self::tim().ccr(1).write(|r| r.ccr().set(val.into()));
+                // `wrapping_sub` takes care of the u64 integer overflow special case.
+                let val =
+                    if instant.wrapping_sub(now) <= (<pac::$timer as General>::Width::MAX as u64) {
+                        instant as <pac::$timer as General>::Width
+                    } else {
+                        // In the past or will overflow
+                        0
+                    };
+
+                Self::tim().ccr2().write(|r| r.ccr().set(val.into()));
             }
 
             fn clear_compare_flag() {
@@ -249,8 +254,8 @@ macro_rules! make_timer {
                     assert!(prev % 2 == 1, "Monotonic must have missed an interrupt!");
                 }
                 // Half period
-                if Self::tim().sr().read().cc3if().bit_is_set() {
-                    Self::tim().sr().modify(|_, w| w.cc3if().clear_bit());
+                if Self::tim().sr().read().cc1if().bit_is_set() {
+                    Self::tim().sr().modify(|_, w| w.cc1if().clear_bit());
                     let prev = $overflow.fetch_add(1, Ordering::Relaxed);
                     assert!(prev % 2 == 0, "Monotonic must have missed an interrupt!");
                 }
@@ -264,16 +269,16 @@ macro_rules! make_timer {
 }
 
 #[cfg(all(feature = "tim2", feature = "rtic-tim2"))]
-make_timer!(tim2, TIM2, u32, TIMER2_OVERFLOWS, TIMER2_TQ);
+make_timer!(tim2, TIM2, TIMER2_OVERFLOWS, TIMER2_TQ);
 
 #[cfg(all(feature = "tim3", feature = "rtic-tim3"))]
-make_timer!(tim3, TIM3, u16, TIMER3_OVERFLOWS, TIMER3_TQ);
+make_timer!(tim3, TIM3, TIMER3_OVERFLOWS, TIMER3_TQ);
 
 #[cfg(all(feature = "tim4", feature = "rtic-tim4"))]
-make_timer!(tim4, TIM4, u16, TIMER4_OVERFLOWS, TIMER4_TQ);
+make_timer!(tim4, TIM4, TIMER4_OVERFLOWS, TIMER4_TQ);
 
 #[cfg(all(feature = "tim5", feature = "rtic-tim5"))]
-make_timer!(tim5, TIM5, u16, TIMER5_OVERFLOWS, TIMER5_TQ);
+make_timer!(tim5, TIM5, TIMER5_OVERFLOWS, TIMER5_TQ);
 
 pub trait Irq {
     const IRQ: pac::Interrupt;