rtc: add methods to read alarms

Author: newAM

CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+### Added
+- Added `Rtc::alarm_{a,b}` to get the alarm value.
+- Added `impl From<Alarm> for chrono::NaiveTime`.
+
 ## [0.5.0] - 2022-05-08
 ### Added
 - Added `set_sleep_clock` to GPIO ports to enable and disable clocks during sleep.

hal/src/rtc/alarm.rs

@@ -55,6 +55,16 @@ impl From<chrono::NaiveTime> for Alarm {
     }
 }
 
+impl From<Alarm> for chrono::NaiveTime {
+    fn from(alarm: Alarm) -> Self {
+        Self::from_hms(
+            alarm.hours().into(),
+            alarm.minutes().into(),
+            alarm.seconds().into(),
+        )
+    }
+}
+
 const fn const_min(a: u8, b: u8) -> u32 {
     if a < b {
         a as u32
@@ -506,3 +516,19 @@ impl Alarm {
         self.ss_mask
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Alarm;
+    use chrono::NaiveTime;
+
+    #[test]
+    fn chrono_convert() {
+        let ndt: NaiveTime = NaiveTime::from_hms(12, 34, 56);
+        let alarm: Alarm = ndt.into();
+        assert_eq!(alarm.hours(), 12);
+        assert_eq!(alarm.minutes(), 34);
+        assert_eq!(alarm.seconds(), 56);
+        assert_eq!(NaiveTime::from(alarm), ndt);
+    }
+}

hal/src/rtc/mod.rs

@@ -547,6 +547,21 @@ impl Rtc {
         self.rtc.alrabinr.write(|w| w.ss().bits(alarm.ss));
     }
 
+    /// Get the value of alarm A.
+    ///
+    /// Returns `None` if the alarm is not set.
+    pub fn alarm_a(&self) -> Option<Alarm> {
+        if self.rtc.cr.read().alrae().is_disabled() {
+            None
+        } else {
+            Some(Alarm {
+                val: self.rtc.alrmar.read().bits(),
+                ss: self.rtc.alrabinr.read().ss().bits(),
+                ss_mask: self.rtc.alrmassr.read().maskss().bits(),
+            })
+        }
+    }
+
     /// Set the alarm A enable, and alarm A interrupt enable.
     #[inline]
     pub fn set_alarm_a_en(&mut self, en: bool, irq_en: bool) {
@@ -568,6 +583,21 @@ impl Rtc {
         self.rtc.alrbbinr.write(|w| w.ss().bits(alarm.ss));
     }
 
+    /// Get the value of alarm B.
+    ///
+    /// Returns `None` if the alarm is not set.
+    pub fn alarm_b(&self) -> Option<Alarm> {
+        if self.rtc.cr.read().alrbe().is_disabled() {
+            None
+        } else {
+            Some(Alarm {
+                val: self.rtc.alrmbr.read().bits(),
+                ss: self.rtc.alrbbinr.read().ss().bits(),
+                ss_mask: self.rtc.alrmbssr.read().maskss().bits(),
+            })
+        }
+    }
+
     /// Set the alarm B enable, and alarm B interrupt enable.
     #[inline]
     pub fn set_alarm_b_en(&mut self, en: bool, irq_en: bool) {

testsuite/src/aes.rs

@@ -1732,9 +1732,9 @@ mod tests {
             let start: u32 = DWT::cycle_count();
             let cipher = aes_gcm::Aes128Gcm::new(key.as_ref().into());
             let nonce = Nonce::from_slice(iv.as_ref().into());
-            let result_tag = cipher
+            let result_tag = unwrap!(cipher
                 .encrypt_in_place_detached(nonce, &gcm.aad, &mut buf[..gcm.pt.len()])
-                .unwrap();
+                .ok());
             total_elapsed += DWT::cycle_count().wrapping_sub(start);
 
             let result_tag: [u8; 16] = unwrap!(result_tag.try_into());

testsuite/src/rtc.rs

@@ -198,6 +198,8 @@ mod tests {
         while ta.rcc.bdcr.read().lserdy().is_not_ready() {}
         let mut rtc: Rtc = test_set_date_time_with_clk(rtc::Clk::Lse);
 
+        defmt::assert_eq!(rtc.alarm_a(), None);
+
         let alarm: Alarm = Alarm::from(unwrap!(rtc.time()) + Duration::seconds(1))
             .set_days_mask(true)
             .set_hours_mask(true)
@@ -214,11 +216,13 @@ mod tests {
                 defmt::info!("elapsed: {=u32:us}", elapsed_micros);
                 // 100ms tolerance
                 defmt::assert!(elapsed_micros > 900_000 && elapsed_micros < 1_100_000);
-                return;
+                break;
             } else if elapsed_micros > 2 * 1000 * 1000 {
                 defmt::info!("{:08X}", Rtc::status().bits());
                 defmt::panic!("Timeout! Elapsed: {=u32:us}", elapsed_micros);
             }
         }
+
+        defmt::assert_eq!(rtc.alarm_a(), Some(alarm));
     }
 }