RTC: Use RTCCLK for Wakeup timer when period is <32s

This allows a minimum time of 122µs and a maximum time of 32s, with a
resolution of 61µs

Author: X-yl

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
  - add trait bound `RegisterBlockImpl` to type `RegisterBlock` associated with `serial::Instance` [#732]
  - remove unneeded trait bound for methods that take in a `serial::Instance` and use the associated `RegisterBlock`
  - bump `sdio-host` to 0.9.0, refactor SDIO initialization [#734]
+ - use RTCCLK for RTC wakeup timer for short durations [#746]
 
 ### Fixed
 

examples/rtc_alarm.rs

@@ -42,7 +42,7 @@ fn main() -> ! {
     // Set alarm A for 1 minute
     rtc.set_alarm(Alarm::AlarmA, today, time!(21:58:32))
         .unwrap();
-    rtc.enable_wakeup(8.secs());
+    rtc.enable_wakeup(8.secs().into());
     rtc.listen(&mut p.EXTI, Event::AlarmA);
     rtc.listen(&mut p.EXTI, Event::Wakeup);
 

src/rtc.rs

@@ -6,9 +6,9 @@ use crate::bb;
 use crate::pac::rtc::{dr, tr, DR, TR};
 use crate::pac::{self, rcc::RegisterBlock, PWR, RCC, RTC};
 use crate::rcc::Enable;
-use core::convert::{TryFrom, TryInto};
 use core::fmt;
 use core::marker::PhantomData;
+use fugit::{Duration, ExtU32, Rate, RateExtU32};
 use time::{Date, PrimitiveDateTime, Time, Weekday};
 
 /// Invalid input error
@@ -67,8 +67,24 @@ pub struct Lse;
 /// RTC clock source LSI oscillator clock (type state)
 pub struct Lsi;
 
+pub trait FrequencySource {
+    fn frequency() -> fugit::Hertz<u32>;
+}
+
+impl FrequencySource for Lse {
+    fn frequency() -> fugit::Hertz<u32> {
+        32_768u32.Hz()
+    }
+}
+
+impl FrequencySource for Lsi {
+    fn frequency() -> fugit::Hertz<u32> {
+        32_000u32.Hz()
+    }
+}
+
 /// Real Time Clock peripheral
-pub struct Rtc<CS = Lse> {
+pub struct Rtc<CS: FrequencySource = Lse> {
     /// RTC Peripheral register
     pub regs: RTC,
     _clock_source: PhantomData<CS>,
@@ -239,7 +255,7 @@ impl Rtc<Lsi> {
     }
 }
 
-impl<CS> Rtc<CS> {
+impl<CS: FrequencySource> Rtc<CS> {
     fn unlock(&mut self, rcc: &RegisterBlock, pwr: &mut PWR) {
         // Enable the backup interface
         // Set APB1 - Bit 28 (PWREN)
@@ -530,23 +546,50 @@ impl<CS> Rtc<CS> {
     /// # Panics
     ///
     /// Panics if interval is greater than 2¹⁷-1.
-    pub fn enable_wakeup(&mut self, interval: fugit::SecsDurationU32) {
-        let interval = interval.ticks();
+    pub fn enable_wakeup(&mut self, interval: fugit::MicrosDurationU64) {
         self.modify(false, |regs| {
             regs.cr.modify(|_, w| w.wute().clear_bit());
             regs.isr.modify(|_, w| w.wutf().clear_bit());
             while regs.isr.read().wutwf().bit_is_clear() {}
 
-            if interval > 1 << 16 {
-                regs.cr.modify(|_, w| unsafe { w.wucksel().bits(0b110) });
-                let interval = u16::try_from(interval - (1 << 16) - 1)
-                    .expect("Interval was too large for wakeup timer");
+            if interval < 32u32.secs::<1, 1_000_000>() {
+                // Use RTCCLK as the wakeup timer clock source
+                let frequency: Rate<u64, 1, 1> = (CS::frequency() / 2).into();
+                let freq_duration: Duration<u64, 1, 1000000> = frequency.into_duration();
+                let ticks_per_interval = interval / freq_duration;
+
+                let mut prescaler = 0;
+                while ticks_per_interval >> prescaler > 1 << 16 {
+                    prescaler += 1;
+                }
+
+                let prescaler_bits = match prescaler {
+                    0 => 0b11, // RTCCLK/2
+                    1 => 0b10, // RTCCLK/4
+                    2 => 0b01, // RTCCLK/8
+                    3 => 0b00, // RTCCLK/16
+                    _ => unreachable!("Longer durations should use ck_spre"),
+                };
+
+                let interval = u16::try_from((ticks_per_interval >> prescaler) - 1).unwrap();
+
+                regs.cr
+                    .modify(|_, w| unsafe { w.wucksel().bits(prescaler_bits) });
                 regs.wutr.write(|w| w.wut().bits(interval));
             } else {
-                regs.cr.modify(|_, w| unsafe { w.wucksel().bits(0b100) });
-                let interval =
-                    u16::try_from(interval - 1).expect("Interval was too large for wakeup timer");
-                regs.wutr.write(|w| w.wut().bits(interval));
+                // Use ck_spre (1Hz) as the wakeup timer clock source
+                let interval = interval.to_secs();
+                if interval > 1 << 16 {
+                    regs.cr.modify(|_, w| unsafe { w.wucksel().bits(0b110) });
+                    let interval = u16::try_from(interval - (1 << 16) - 1)
+                        .expect("Interval was too large for wakeup timer");
+                    regs.wutr.write(|w| w.wut().bits(interval));
+                } else {
+                    regs.cr.modify(|_, w| unsafe { w.wucksel().bits(0b100) });
+                    let interval = u16::try_from(interval - 1)
+                        .expect("Interval was too large for wakeup timer");
+                    regs.wutr.write(|w| w.wut().bits(interval));
+                }
             }
 
             regs.cr.modify(|_, w| w.wute().set_bit());