From 5e114a64ec085bc2cd602a958e9f5dec607f316c Mon Sep 17 00:00:00 2001
From: Albin Hedman <albin9604@gmail.com>
Date: Mon, 5 Jun 2023 19:48:17 +0200
Subject: [PATCH 1/8] impl defmt::Format for Time and Date

---
 src/time.rs | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/time.rs b/src/time.rs
index 98a44a31..fed25b09 100644
--- a/src/time.rs
+++ b/src/time.rs
@@ -52,6 +52,18 @@ impl Time {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for Time {
+    fn format(&self, f: defmt::Formatter) {
+        // format the bitfields of the register as struct fields
+        defmt::write!(
+           f,
+           "{:02}:{:02}:{:02}",
+           self.hours, self.minutes, self.seconds
+        )
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Date {
     pub day: u32,
@@ -69,6 +81,18 @@ impl Date {
     }
 }
 
+#[cfg(feature = "defmt")]
+impl defmt::Format for Date {
+    fn format(&self, f: defmt::Formatter) {
+        // format the bitfields of the register as struct fields
+        defmt::write!(
+           f,
+           "{:04}-{:02}-{:02}",
+           self.year, self.month, self.day
+        )
+    }
+}
+
 pub trait U32Ext {
     /// Wrap in `Bps`
     fn bps(self) -> Bps;

From b649c3dfc16c3f95d8646919c62a334ab8ab6ea1 Mon Sep 17 00:00:00 2001
From: Albin Hedman <albin9604@gmail.com>
Date: Sun, 21 May 2023 00:25:05 +0200
Subject: [PATCH 2/8] Add slightly modified src/rtc.rs from stm32g0xx-hal

---
 src/lib.rs        |   1 +
 src/rcc/config.rs |  10 ++
 src/rcc/mod.rs    |  42 ++++-
 src/rtc.rs        | 397 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 449 insertions(+), 1 deletion(-)
 create mode 100644 src/rtc.rs

diff --git a/src/lib.rs b/src/lib.rs
index 5441692a..7814d7d7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -88,6 +88,7 @@ pub mod pwm;
 pub mod pwr;
 // pub mod qei;
 pub mod rcc;
+pub mod rtc;
 // pub mod rng;
 pub mod serial;
 pub mod signature;
diff --git a/src/rcc/config.rs b/src/rcc/config.rs
index b53a280a..74997acb 100644
--- a/src/rcc/config.rs
+++ b/src/rcc/config.rs
@@ -46,6 +46,16 @@ pub enum PLLSrc {
     HSE_BYPASS(Hertz),
 }
 
+/// RTC clock input source
+#[derive(Clone, Copy)]
+pub enum RTCSrc {
+    LSE,
+    LSE_BYPASS,
+    LSI,
+    HSE,
+    HSE_BYPASS,
+}
+
 /// Divider for the PLL clock input (M)
 /// This must be set based on the input clock to keep the PLL input frequency within the limits
 /// specified in the datasheet.
diff --git a/src/rcc/mod.rs b/src/rcc/mod.rs
index e209a1d4..e07733cd 100644
--- a/src/rcc/mod.rs
+++ b/src/rcc/mod.rs
@@ -231,7 +231,7 @@ impl Rcc {
         }
     }
 
-    pub fn unlock_rtc(&mut self) {
+    pub fn unlock_rtc_old(&mut self) {
         self.rb.apb1enr1.modify(|_, w| w.pwren().set_bit());
         let pwr = unsafe { &(*PWR::ptr()) };
         pwr.cr1.modify(|_, w| w.dbp().set_bit());
@@ -457,6 +457,46 @@ impl Rcc {
     pub fn clear_reset_reason(&mut self) {
         self.rb.csr.modify(|_, w| w.rmvf().set_bit());
     }
+
+    pub(crate) fn unlock_rtc(&self) {
+        self.rb.apb1enr1.modify(|_, w| w.pwren().set_bit());
+        let pwr = unsafe { &(*PWR::ptr()) };
+        pwr.cr1.modify(|_, w| w.dbp().set_bit());
+        while pwr.cr1.read().dbp().bit_is_clear() {}
+    }
+
+    pub(crate) fn enable_rtc(&self, src: RTCSrc) {
+        self.unlock_rtc();
+        self.rb
+            .apb1enr1
+            .modify(|_, w| w.rtcapben().set_bit().pwren().set_bit());
+        self.rb.apb1smenr1.modify(|_, w| w.rtcapbsmen().set_bit());
+        self.rb.bdcr.modify(|_, w| w.bdrst().set_bit());
+
+        let rtc_sel = match src {
+            RTCSrc::LSE | RTCSrc::LSE_BYPASS => 0b01,
+            RTCSrc::LSI => 0b10,
+            RTCSrc::HSE | RTCSrc::HSE_BYPASS => 0b11,
+        };
+
+        self.rb.bdcr.modify(|_, w| {
+            w.rtcsel()
+                .bits(rtc_sel)
+                .rtcen()
+                .set_bit()
+                .bdrst()
+                .clear_bit()
+        });
+
+        self.unlock_rtc();
+        match src {
+            RTCSrc::LSE => self.enable_lse(false),
+            RTCSrc::LSE_BYPASS => self.enable_lse(true),
+            RTCSrc::LSI => self.enable_lsi(),
+            RTCSrc::HSE => self.enable_hse(false),
+            RTCSrc::HSE_BYPASS => self.enable_hse(true),
+        };
+    }
 }
 
 pub struct ResetReason {
diff --git a/src/rtc.rs b/src/rtc.rs
new file mode 100644
index 00000000..2a644c7e
--- /dev/null
+++ b/src/rtc.rs
@@ -0,0 +1,397 @@
+//! Real Time Clock
+use crate::rcc::{RTCSrc, Rcc};
+use crate::stm32::RTC;
+use crate::time::*;
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum RtcHourFormat {
+    H24,
+    H12,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum RtcCalibrationFrequency {
+    F1Hz,
+    F512Hz,
+}
+
+pub enum Event {
+    WakeupTimer,
+    AlarmA,
+    AlarmB,
+    Timestamp,
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct Alarm {
+    day: Option<u32>,
+    hours: Option<u32>,
+    minutes: Option<u32>,
+    seconds: Option<u32>,
+    subseconds: u16,
+    subseconds_mask_bits: u8,
+    use_weekday: bool,
+}
+
+impl Alarm {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn set_month_day(mut self, day: u32) -> Self {
+        self.use_weekday = false;
+        self.day = Some(day);
+        self
+    }
+
+    pub fn set_week_day(mut self, day: u32) -> Self {
+        self.use_weekday = true;
+        self.day = Some(day);
+        self
+    }
+
+    pub fn set_hours(mut self, val: u32) -> Self {
+        self.hours = Some(val);
+        self
+    }
+
+    pub fn set_minutes(mut self, val: u32) -> Self {
+        self.minutes = Some(val);
+        self
+    }
+
+    pub fn set_seconds(mut self, val: u32) -> Self {
+        self.seconds = Some(val);
+        self
+    }
+
+    pub fn set_subseconds(mut self, subseconds: u16, mask_bits: u8) -> Self {
+        self.subseconds_mask_bits = mask_bits;
+        self.subseconds = subseconds;
+        self
+    }
+
+    pub fn mask_day(mut self) -> Self {
+        self.day = None;
+        self
+    }
+
+    pub fn mask_hours(mut self) -> Self {
+        self.hours = None;
+        self
+    }
+
+    pub fn mask_minutes(mut self) -> Self {
+        self.minutes = None;
+        self
+    }
+
+    pub fn mask_seconds(mut self) -> Self {
+        self.seconds = None;
+        self
+    }
+}
+
+impl From<Time> for Alarm {
+    fn from(time: Time) -> Self {
+        Self::default()
+            .set_hours(time.hours)
+            .set_minutes(time.minutes)
+            .set_seconds(time.seconds)
+    }
+}
+
+pub struct Rtc {
+    rb: RTC,
+}
+
+impl Rtc {
+    pub fn new(rtc: RTC, src: RTCSrc, rcc: &mut Rcc) -> Self {
+        rcc.enable_rtc(src);
+        Rtc { rb: rtc }
+    }
+
+    pub fn set_hour_format(&mut self, fmt: RtcHourFormat) {
+        self.modify(|rb| {
+            rb.cr.modify(|_, w| w.fmt().bit(fmt == RtcHourFormat::H12));
+        });
+    }
+
+    pub fn set_date(&mut self, date: &Date) {
+        let (yt, yu) = bcd2_encode(date.year - 1970);
+        let (mt, mu) = bcd2_encode(date.month);
+        let (dt, du) = bcd2_encode(date.day);
+
+        self.modify(|rb| {
+            rb.dr.write(|w| unsafe {
+                w.dt()
+                    .bits(dt)
+                    .du()
+                    .bits(du)
+                    .mt()
+                    .bit(mt > 0)
+                    .mu()
+                    .bits(mu)
+                    .yt()
+                    .bits(yt)
+                    .yu()
+                    .bits(yu)
+                    .wdu()
+                    .bits(date.day as u8)
+            });
+        });
+    }
+
+    pub fn set_time(&mut self, time: &Time) {
+        let (ht, hu) = bcd2_encode(time.hours);
+        let (mnt, mnu) = bcd2_encode(time.minutes);
+        let (st, su) = bcd2_encode(time.seconds);
+        self.modify(|rb| {
+            rb.tr.write(|w| unsafe {
+                w.ht()
+                    .bits(ht)
+                    .hu()
+                    .bits(hu)
+                    .mnt()
+                    .bits(mnt)
+                    .mnu()
+                    .bits(mnu)
+                    .st()
+                    .bits(st)
+                    .su()
+                    .bits(su)
+                    .pm()
+                    .clear_bit()
+            });
+            rb.cr.modify(|_, w| w.fmt().bit(time.daylight_savings));
+        });
+    }
+
+    pub fn get_time(&self) -> Time {
+        let timer = self.rb.tr.read();
+        Time::new(
+            bcd2_decode(timer.ht().bits(), timer.hu().bits()).hours(),
+            bcd2_decode(timer.mnt().bits(), timer.mnu().bits()).minutes(),
+            bcd2_decode(timer.st().bits(), timer.su().bits()).secs(),
+            self.rb.cr.read().fmt().bit(),
+        )
+    }
+
+    pub fn get_date(&self) -> Date {
+        let date = self.rb.dr.read();
+        Date::new(
+            (bcd2_decode(date.yt().bits(), date.yu().bits()) + 1970).year(),
+            bcd2_decode(date.mt().bit() as u8, date.mu().bits()).month(),
+            bcd2_decode(date.dt().bits(), date.du().bits()).day(),
+        )
+    }
+
+    pub fn get_week_day(&self) -> u8 {
+        self.rb.dr.read().wdu().bits()
+    }
+
+    pub fn set_alarm_a(&mut self, alarm: impl Into<Alarm>) {
+        let alarm = alarm.into();
+        let (dt, du) = bcd2_encode(alarm.day.unwrap_or_default() as u32);
+        let (ht, hu) = bcd2_encode(alarm.hours.unwrap_or_default() as u32);
+        let (mt, mu) = bcd2_encode(alarm.minutes.unwrap_or_default() as u32);
+        let (st, su) = bcd2_encode(alarm.seconds.unwrap_or_default() as u32);
+
+        self.modify(|rb| {
+            rb.alrmassr.write(|w| unsafe {
+                w.maskss()
+                    .bits(alarm.subseconds_mask_bits)
+                    .ss()
+                    .bits(alarm.subseconds)
+            });
+            rb.alrmar.write(|w| unsafe {
+                w.wdsel().bit(alarm.use_weekday);
+                w.msk1().bit(alarm.seconds.is_none());
+                w.msk2().bit(alarm.minutes.is_none());
+                w.msk3().bit(alarm.hours.is_none());
+                w.msk4().bit(alarm.day.is_none());
+                w.dt().bits(dt);
+                w.du().bits(du);
+                w.ht().bits(ht);
+                w.hu().bits(hu);
+                w.mnt().bits(mt);
+                w.mnu().bits(mu);
+                w.st().bits(st);
+                w.su().bits(su)
+            });
+
+            rb.cr.modify(|_, w| w.alrae().set_bit());
+        });
+    }
+
+    pub fn set_alarm_b(&mut self, alarm: Alarm) {
+        let (dt, du) = bcd2_encode(alarm.day.unwrap_or_default() as u32);
+        let (ht, hu) = bcd2_encode(alarm.hours.unwrap_or_default() as u32);
+        let (mt, mu) = bcd2_encode(alarm.minutes.unwrap_or_default() as u32);
+        let (st, su) = bcd2_encode(alarm.seconds.unwrap_or_default() as u32);
+
+        self.modify(|rb| {
+            rb.alrmbssr.write(|w| unsafe {
+                w.maskss()
+                    .bits(alarm.subseconds_mask_bits)
+                    .ss()
+                    .bits(alarm.subseconds)
+            });
+            rb.alrmbr.write(|w| unsafe {
+                w.wdsel().bit(alarm.use_weekday);
+                w.msk1().bit(alarm.seconds.is_none());
+                w.msk2().bit(alarm.minutes.is_none());
+                w.msk3().bit(alarm.hours.is_none());
+                w.msk4().bit(alarm.day.is_none());
+                w.dt().bits(dt);
+                w.du().bits(du);
+                w.ht().bits(ht);
+                w.hu().bits(hu);
+                w.mnt().bits(mt);
+                w.mnu().bits(mu);
+                w.st().bits(st);
+                w.su().bits(su)
+            });
+
+            rb.cr.modify(|_, w| w.alrbe().set_bit());
+        });
+    }
+
+    pub fn listen(&mut self, ev: Event) {
+        self.modify(|rb| match ev {
+            Event::WakeupTimer => rb.cr.modify(|_, w| w.wutie().set_bit()),
+            Event::AlarmA => rb.cr.modify(|_, w| w.alraie().set_bit()),
+            Event::AlarmB => rb.cr.modify(|_, w| w.alrbie().set_bit()),
+            Event::Timestamp => rb.cr.modify(|_, w| w.tsie().set_bit()),
+        })
+    }
+
+    pub fn unlisten(&mut self, ev: Event) {
+        self.modify(|rb| match ev {
+            Event::WakeupTimer => rb.cr.modify(|_, w| w.wutie().clear_bit()),
+            Event::AlarmA => rb.cr.modify(|_, w| w.alraie().clear_bit()),
+            Event::AlarmB => rb.cr.modify(|_, w| w.alrbie().clear_bit()),
+            Event::Timestamp => rb.cr.modify(|_, w| w.tsie().clear_bit()),
+        })
+    }
+
+    pub fn is_pending(&self, ev: Event) -> bool {
+        match ev {
+            Event::WakeupTimer => self.rb.sr.read().wutf().bit_is_set(),
+            Event::AlarmA => self.rb.sr.read().alraf().bit_is_set(),
+            Event::AlarmB => self.rb.sr.read().alrbf().bit_is_set(),
+            Event::Timestamp => self.rb.sr.read().tsf().bit_is_set(),
+        }
+    }
+
+    pub fn unpend(&mut self, ev: Event) {
+        self.modify(|rb| match ev {
+            Event::WakeupTimer => rb.scr.write(|w| w.cwutf().set_bit()),
+            Event::AlarmA => rb.scr.write(|w| w.calraf().set_bit()),
+            Event::AlarmB => rb.scr.write(|w| w.calrbf().set_bit()),
+            Event::Timestamp => rb.scr.write(|w| w.ctsf().set_bit()),
+        });
+    }
+
+    pub fn enable_calibration_output<PIN: RtcOutputPin>(
+        &mut self,
+        pin: PIN,
+        freq: RtcCalibrationFrequency,
+    ) {
+        pin.setup();
+        self.modify(|rb| {
+            rb.cr.modify(|_, w| unsafe {
+                w.osel()
+                    .bits(0b0)
+                    .out2en()
+                    .bit(pin.channel())
+                    .cosel()
+                    .bit(freq == RtcCalibrationFrequency::F1Hz)
+                    .tampoe()
+                    .clear_bit()
+                    .coe()
+                    .set_bit()
+            });
+        });
+    }
+
+    fn modify<F>(&mut self, mut closure: F)
+    where
+        F: FnMut(&mut RTC),
+    {
+        // Disable write protection
+        self.rb.wpr.write(|w| unsafe { w.bits(0xCA) });
+        self.rb.wpr.write(|w| unsafe { w.bits(0x53) });
+        // Enter init mode
+        let isr = self.rb.icsr.read();
+        if isr.initf().bit_is_clear() {
+            self.rb.icsr.write(|w| w.init().set_bit());
+            self.rb.icsr.write(|w| unsafe { w.bits(0xFFFF_FFFF) });
+            while self.rb.icsr.read().initf().bit_is_clear() {}
+        }
+        // Invoke closure
+        closure(&mut self.rb);
+        // Exit init mode
+        self.rb.icsr.write(|w| w.init().clear_bit());
+        // Enable_write_protection
+        self.rb.wpr.write(|w| unsafe { w.bits(0xFF) });
+    }
+}
+
+pub trait RtcExt {
+    fn constrain(self, rcc: &mut Rcc) -> Rtc;
+}
+
+impl RtcExt for RTC {
+    fn constrain(self, rcc: &mut Rcc) -> Rtc {
+        Rtc::new(self, RTCSrc::LSI, rcc)
+    }
+}
+
+pub trait RtcOutputPin {
+    fn setup(&self);
+    fn channel(&self) -> bool;
+    fn release(self) -> Self;
+}
+
+/*macro_rules! rtc_out_pins {
+    ($($pin:ty: ($af_mode:expr, $ch:expr),)+) => {
+        $(
+            impl RtcOutputPin for $pin {
+                fn setup(&self) {
+                    self.set_alt_mode($af_mode);
+                }
+
+                fn channel(&self) -> bool {
+                    $ch
+                }
+
+                fn release(self) -> Self {
+                    self.into_analog()
+                }
+            }
+        )+
+    }
+}
+
+rtc_out_pins! {
+    PA4<DefaultMode>: (AltFunction::AF3, true),
+    PC13<DefaultMode>: (AltFunction::AF3, false),
+}*/
+
+fn bcd2_encode(word: u32) -> (u8, u8) {
+    let mut value = word as u8;
+    let mut bcd_high: u8 = 0;
+    while value >= 10 {
+        bcd_high += 1;
+        value -= 10;
+    }
+    let bcd_low = ((bcd_high << 4) | value) as u8;
+    (bcd_high, bcd_low)
+}
+
+fn bcd2_decode(fst: u8, snd: u8) -> u32 {
+    let value = snd | fst << 4;
+    let value = (value & 0x0F) + ((value & 0xF0) >> 4) * 10;
+    value as u32
+}

From 2f36ec2ae3fcdba17144df708d458f694c8dfe82 Mon Sep 17 00:00:00 2001
From: Albin Hedman <albin9604@gmail.com>
Date: Mon, 5 Jun 2023 19:49:48 +0200
Subject: [PATCH 3/8] Simple rtc example using the very inaccurate LSI clock
 source for the rtc

---
 examples/rtc.rs | 50 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 examples/rtc.rs

diff --git a/examples/rtc.rs b/examples/rtc.rs
new file mode 100644
index 00000000..a9b70189
--- /dev/null
+++ b/examples/rtc.rs
@@ -0,0 +1,50 @@
+#![no_main]
+#![no_std]
+
+use hal::{
+    delay::SYSTDelayExt,
+    rcc::{Config, RccExt},
+    stm32::Peripherals,
+    time::{Time, Date, Year, Month, MonthDay, Hour, Minute, Second, ExtU32},
+    hal::prelude::*, rtc::RtcExt
+};
+use stm32g4xx_hal as hal;
+
+use cortex_m_rt::entry;
+
+use utils::logger::info;
+
+#[macro_use]
+mod utils;
+
+#[entry]
+fn main() -> ! {
+    utils::logger::init();
+
+    info!("start");
+
+    let dp = Peripherals::take().unwrap();
+    let cp = cortex_m::Peripherals::take().expect("cannot take core peripherals");
+
+    info!("rcc");
+
+    let rcc = dp.RCC.constrain();
+    let mut rcc = rcc.freeze(Config::hsi());
+
+    info!("Setup rtc");
+    let mut delay = cp.SYST.delay(&rcc.clocks);
+    let mut rtc = dp
+        .RTC
+        .constrain(&mut rcc);
+
+    info!("Setup date");
+    rtc.set_date(&Date::new(Year(2023), Month(6), MonthDay(4)));
+    rtc.set_time(&Time::new(18.hours(), 43.minutes(), 2.secs(), true));
+
+    info!("Enter Loop");
+
+    loop {
+        info!("Timestamp: {} {}", rtc.get_date(), rtc.get_time());
+        delay.delay_ms(500);
+    }
+}

From 24d7fcfab135d95c5725cd3cc07598a2692594bf Mon Sep 17 00:00:00 2001
From: Albin Hedman <albin9604@gmail.com>
Date: Mon, 5 Aug 2024 01:01:01 +0200
Subject: [PATCH 4/8] RTC - Cleanup, use smaller types for Time and Date,
 simplify bcd2

---
 examples/rtc.rs | 19 ++++++---------
 src/rtc.rs      | 65 +++++++++++++++++++++++--------------------------
 src/time.rs     | 26 +++++++++++---------
 3 files changed, 53 insertions(+), 57 deletions(-)

diff --git a/examples/rtc.rs b/examples/rtc.rs
index a9b70189..31e7103d 100644
--- a/examples/rtc.rs
+++ b/examples/rtc.rs
@@ -3,10 +3,10 @@
 
 use hal::{
     delay::SYSTDelayExt,
-    rcc::{Config, RccExt},
+    rcc::RccExt,
+    rtc::RtcExt,
     stm32::Peripherals,
-    time::{Time, Date, Year, Month, MonthDay, Hour, Minute, Second, ExtU32},
-    hal::prelude::*, rtc::RtcExt
+    time::{Date, ExtU32, Month, MonthDay, Time, Year},
 };
 use stm32g4xx_hal as hal;
 
@@ -28,23 +28,20 @@ fn main() -> ! {
 
     info!("rcc");
 
-    let rcc = dp.RCC.constrain();
-    let mut rcc = rcc.freeze(Config::hsi());
+    let mut rcc = dp.RCC.constrain();
 
     info!("Setup rtc");
     let mut delay = cp.SYST.delay(&rcc.clocks);
-    let mut rtc = dp
-        .RTC
-        .constrain(&mut rcc);
+    let mut rtc = dp.RTC.constrain(&mut rcc);
 
     info!("Setup date");
-    rtc.set_date(&Date::new(Year(2023), Month(6), MonthDay(4)));
-    rtc.set_time(&Time::new(18.hours(), 43.minutes(), 2.secs(), true));
+    rtc.set_date(&Date::new(Year(2024), Month(8), MonthDay(5)));
+    rtc.set_time(&Time::new(0.hours(), 59.minutes(), 2.secs(), true));
 
     info!("Enter Loop");
 
     loop {
-        info!("Timestamp: {} {}", rtc.get_date(), rtc.get_time());
+        info!("Timestamp: {:?} {:?}", rtc.get_date(), rtc.get_time());
         delay.delay_ms(500);
     }
 }
diff --git a/src/rtc.rs b/src/rtc.rs
index 2a644c7e..1ba856f5 100644
--- a/src/rtc.rs
+++ b/src/rtc.rs
@@ -1,7 +1,9 @@
 //! Real Time Clock
+use core::convert::TryInto;
+
 use crate::rcc::{RTCSrc, Rcc};
 use crate::stm32::RTC;
-use crate::time::*;
+use crate::time::{self, *};
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum RtcHourFormat {
@@ -24,10 +26,10 @@ pub enum Event {
 
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct Alarm {
-    day: Option<u32>,
-    hours: Option<u32>,
-    minutes: Option<u32>,
-    seconds: Option<u32>,
+    day: Option<u8>,
+    hours: Option<u8>,
+    minutes: Option<u8>,
+    seconds: Option<u8>,
     subseconds: u16,
     subseconds_mask_bits: u8,
     use_weekday: bool,
@@ -38,29 +40,29 @@ impl Alarm {
         Self::default()
     }
 
-    pub fn set_month_day(mut self, day: u32) -> Self {
+    pub fn set_month_day(mut self, day: time::MonthDay) -> Self {
         self.use_weekday = false;
-        self.day = Some(day);
+        self.day = Some(day.0.try_into().unwrap());
         self
     }
 
-    pub fn set_week_day(mut self, day: u32) -> Self {
+    pub fn set_week_day(mut self, day: time::WeekDay) -> Self {
         self.use_weekday = true;
-        self.day = Some(day);
+        self.day = Some(day.0.try_into().unwrap());
         self
     }
 
-    pub fn set_hours(mut self, val: u32) -> Self {
+    pub fn set_hours(mut self, val: u8) -> Self {
         self.hours = Some(val);
         self
     }
 
-    pub fn set_minutes(mut self, val: u32) -> Self {
+    pub fn set_minutes(mut self, val: u8) -> Self {
         self.minutes = Some(val);
         self
     }
 
-    pub fn set_seconds(mut self, val: u32) -> Self {
+    pub fn set_seconds(mut self, val: u8) -> Self {
         self.seconds = Some(val);
         self
     }
@@ -118,7 +120,7 @@ impl Rtc {
     }
 
     pub fn set_date(&mut self, date: &Date) {
-        let (yt, yu) = bcd2_encode(date.year - 1970);
+        let (yt, yu) = bcd2_encode((date.year - 2000).try_into().unwrap());
         let (mt, mu) = bcd2_encode(date.month);
         let (dt, du) = bcd2_encode(date.day);
 
@@ -137,7 +139,7 @@ impl Rtc {
                     .yu()
                     .bits(yu)
                     .wdu()
-                    .bits(date.day as u8)
+                    .bits(date.day)
             });
         });
     }
@@ -180,7 +182,7 @@ impl Rtc {
     pub fn get_date(&self) -> Date {
         let date = self.rb.dr.read();
         Date::new(
-            (bcd2_decode(date.yt().bits(), date.yu().bits()) + 1970).year(),
+            (bcd2_decode(date.yt().bits(), date.yu().bits()) + 2000).year(),
             bcd2_decode(date.mt().bit() as u8, date.mu().bits()).month(),
             bcd2_decode(date.dt().bits(), date.du().bits()).day(),
         )
@@ -192,10 +194,10 @@ impl Rtc {
 
     pub fn set_alarm_a(&mut self, alarm: impl Into<Alarm>) {
         let alarm = alarm.into();
-        let (dt, du) = bcd2_encode(alarm.day.unwrap_or_default() as u32);
-        let (ht, hu) = bcd2_encode(alarm.hours.unwrap_or_default() as u32);
-        let (mt, mu) = bcd2_encode(alarm.minutes.unwrap_or_default() as u32);
-        let (st, su) = bcd2_encode(alarm.seconds.unwrap_or_default() as u32);
+        let (dt, du) = bcd2_encode(alarm.day.unwrap_or_default());
+        let (ht, hu) = bcd2_encode(alarm.hours.unwrap_or_default());
+        let (mt, mu) = bcd2_encode(alarm.minutes.unwrap_or_default());
+        let (st, su) = bcd2_encode(alarm.seconds.unwrap_or_default());
 
         self.modify(|rb| {
             rb.alrmassr.write(|w| unsafe {
@@ -225,10 +227,10 @@ impl Rtc {
     }
 
     pub fn set_alarm_b(&mut self, alarm: Alarm) {
-        let (dt, du) = bcd2_encode(alarm.day.unwrap_or_default() as u32);
-        let (ht, hu) = bcd2_encode(alarm.hours.unwrap_or_default() as u32);
-        let (mt, mu) = bcd2_encode(alarm.minutes.unwrap_or_default() as u32);
-        let (st, su) = bcd2_encode(alarm.seconds.unwrap_or_default() as u32);
+        let (dt, du) = bcd2_encode(alarm.day.unwrap_or_default());
+        let (ht, hu) = bcd2_encode(alarm.hours.unwrap_or_default());
+        let (mt, mu) = bcd2_encode(alarm.minutes.unwrap_or_default());
+        let (st, su) = bcd2_encode(alarm.seconds.unwrap_or_default());
 
         self.modify(|rb| {
             rb.alrmbssr.write(|w| unsafe {
@@ -354,6 +356,7 @@ pub trait RtcOutputPin {
     fn release(self) -> Self;
 }
 
+// TODO: Add support for RTC_OUT1 and RTC_OUT2
 /*macro_rules! rtc_out_pins {
     ($($pin:ty: ($af_mode:expr, $ch:expr),)+) => {
         $(
@@ -379,19 +382,13 @@ rtc_out_pins! {
     PC13<DefaultMode>: (AltFunction::AF3, false),
 }*/
 
-fn bcd2_encode(word: u32) -> (u8, u8) {
-    let mut value = word as u8;
-    let mut bcd_high: u8 = 0;
-    while value >= 10 {
-        bcd_high += 1;
-        value -= 10;
-    }
-    let bcd_low = ((bcd_high << 4) | value) as u8;
+fn bcd2_encode(word: u8) -> (u8, u8) {
+    let bcd_high = word / 10;
+    let bcd_low = word % 10;
     (bcd_high, bcd_low)
 }
 
-fn bcd2_decode(fst: u8, snd: u8) -> u32 {
-    let value = snd | fst << 4;
-    let value = (value & 0x0F) + ((value & 0xF0) >> 4) * 10;
+fn bcd2_decode(tens: u8, unit: u8) -> u32 {
+    let value = unit + 10 * tens;
     value as u32
 }
diff --git a/src/time.rs b/src/time.rs
index fed25b09..0d5770e4 100644
--- a/src/time.rs
+++ b/src/time.rs
@@ -35,18 +35,19 @@ pub struct Year(pub u32);
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Time {
-    pub hours: u32,
-    pub minutes: u32,
-    pub seconds: u32,
+    pub hours: u8,
+    pub minutes: u8,
+    pub seconds: u8,
     pub daylight_savings: bool,
 }
 
 impl Time {
     pub fn new(hours: Hour, minutes: Minute, seconds: Second, daylight_savings: bool) -> Self {
+        use core::convert::TryInto;
         Self {
-            hours: hours.ticks(),
-            minutes: minutes.ticks(),
-            seconds: seconds.ticks(),
+            hours: hours.ticks().try_into().unwrap(),
+            minutes: minutes.ticks().try_into().unwrap(),
+            seconds: seconds.ticks().try_into().unwrap(),
             daylight_savings,
         }
     }
@@ -66,17 +67,18 @@ impl defmt::Format for Time {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Date {
-    pub day: u32,
-    pub month: u32,
-    pub year: u32,
+    pub year: u16,
+    pub month: u8,
+    pub day: u8,
 }
 
 impl Date {
     pub fn new(year: Year, month: Month, day: MonthDay) -> Self {
+        use core::convert::TryInto;
         Self {
-            day: day.0,
-            month: month.0,
-            year: year.0,
+            day: day.0.try_into().unwrap(),
+            month: month.0.try_into().unwrap(),
+            year: year.0.try_into().unwrap(),
         }
     }
 }

From 843c1e823dfea314cd1be0aa3d120292c1dfbfdb Mon Sep 17 00:00:00 2001
From: Albin Hedman <albin9604@gmail.com>
Date: Mon, 5 Aug 2024 01:03:17 +0200
Subject: [PATCH 5/8] RTC - fmt

---
 src/time.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/time.rs b/src/time.rs
index 0d5770e4..e36d493f 100644
--- a/src/time.rs
+++ b/src/time.rs
@@ -58,9 +58,11 @@ impl defmt::Format for Time {
     fn format(&self, f: defmt::Formatter) {
         // format the bitfields of the register as struct fields
         defmt::write!(
-           f,
-           "{:02}:{:02}:{:02}",
-           self.hours, self.minutes, self.seconds
+            f,
+            "{:02}:{:02}:{:02}",
+            self.hours,
+            self.minutes,
+            self.seconds
         )
     }
 }
@@ -87,11 +89,7 @@ impl Date {
 impl defmt::Format for Date {
     fn format(&self, f: defmt::Formatter) {
         // format the bitfields of the register as struct fields
-        defmt::write!(
-           f,
-           "{:04}-{:02}-{:02}",
-           self.year, self.month, self.day
-        )
+        defmt::write!(f, "{:04}-{:02}-{:02}", self.year, self.month, self.day)
     }
 }
 

From 5f2dcf317d5c6cfbd433b9e65acbe86d5d447f5f Mon Sep 17 00:00:00 2001
From: Albin Hedman <albin9604@gmail.com>
Date: Mon, 5 Aug 2024 01:08:39 +0200
Subject: [PATCH 6/8] RTC - Rename RTCSrc -> RtcSrc

---
 src/rcc/config.rs |  2 +-
 src/rcc/mod.rs    | 18 +++++++++---------
 src/rtc.rs        |  6 +++---
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/rcc/config.rs b/src/rcc/config.rs
index 74997acb..5c60ea1a 100644
--- a/src/rcc/config.rs
+++ b/src/rcc/config.rs
@@ -48,7 +48,7 @@ pub enum PLLSrc {
 
 /// RTC clock input source
 #[derive(Clone, Copy)]
-pub enum RTCSrc {
+pub enum RtcSrc {
     LSE,
     LSE_BYPASS,
     LSI,
diff --git a/src/rcc/mod.rs b/src/rcc/mod.rs
index e07733cd..7b09fd59 100644
--- a/src/rcc/mod.rs
+++ b/src/rcc/mod.rs
@@ -465,7 +465,7 @@ impl Rcc {
         while pwr.cr1.read().dbp().bit_is_clear() {}
     }
 
-    pub(crate) fn enable_rtc(&self, src: RTCSrc) {
+    pub(crate) fn enable_rtc(&self, src: RtcSrc) {
         self.unlock_rtc();
         self.rb
             .apb1enr1
@@ -474,9 +474,9 @@ impl Rcc {
         self.rb.bdcr.modify(|_, w| w.bdrst().set_bit());
 
         let rtc_sel = match src {
-            RTCSrc::LSE | RTCSrc::LSE_BYPASS => 0b01,
-            RTCSrc::LSI => 0b10,
-            RTCSrc::HSE | RTCSrc::HSE_BYPASS => 0b11,
+            RtcSrc::LSE | RtcSrc::LSE_BYPASS => 0b01,
+            RtcSrc::LSI => 0b10,
+            RtcSrc::HSE | RtcSrc::HSE_BYPASS => 0b11,
         };
 
         self.rb.bdcr.modify(|_, w| {
@@ -490,11 +490,11 @@ impl Rcc {
 
         self.unlock_rtc();
         match src {
-            RTCSrc::LSE => self.enable_lse(false),
-            RTCSrc::LSE_BYPASS => self.enable_lse(true),
-            RTCSrc::LSI => self.enable_lsi(),
-            RTCSrc::HSE => self.enable_hse(false),
-            RTCSrc::HSE_BYPASS => self.enable_hse(true),
+            RtcSrc::LSE => self.enable_lse(false),
+            RtcSrc::LSE_BYPASS => self.enable_lse(true),
+            RtcSrc::LSI => self.enable_lsi(),
+            RtcSrc::HSE => self.enable_hse(false),
+            RtcSrc::HSE_BYPASS => self.enable_hse(true),
         };
     }
 }
diff --git a/src/rtc.rs b/src/rtc.rs
index 1ba856f5..a1896072 100644
--- a/src/rtc.rs
+++ b/src/rtc.rs
@@ -1,7 +1,7 @@
 //! Real Time Clock
 use core::convert::TryInto;
 
-use crate::rcc::{RTCSrc, Rcc};
+use crate::rcc::{RtcSrc, Rcc};
 use crate::stm32::RTC;
 use crate::time::{self, *};
 
@@ -108,7 +108,7 @@ pub struct Rtc {
 }
 
 impl Rtc {
-    pub fn new(rtc: RTC, src: RTCSrc, rcc: &mut Rcc) -> Self {
+    pub fn new(rtc: RTC, src: RtcSrc, rcc: &mut Rcc) -> Self {
         rcc.enable_rtc(src);
         Rtc { rb: rtc }
     }
@@ -346,7 +346,7 @@ pub trait RtcExt {
 
 impl RtcExt for RTC {
     fn constrain(self, rcc: &mut Rcc) -> Rtc {
-        Rtc::new(self, RTCSrc::LSI, rcc)
+        Rtc::new(self, RtcSrc::LSI, rcc)
     }
 }
 

From e2b56aa5d9ae2073024b5078b7a8bdad91e7c1bb Mon Sep 17 00:00:00 2001
From: Albin Hedman <albin9604@gmail.com>
Date: Mon, 5 Aug 2024 01:19:24 +0200
Subject: [PATCH 7/8] RTC - Remove old unlock_rtc method

---
 src/rcc/mod.rs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/rcc/mod.rs b/src/rcc/mod.rs
index 7b09fd59..24cf024c 100644
--- a/src/rcc/mod.rs
+++ b/src/rcc/mod.rs
@@ -231,12 +231,6 @@ impl Rcc {
         }
     }
 
-    pub fn unlock_rtc_old(&mut self) {
-        self.rb.apb1enr1.modify(|_, w| w.pwren().set_bit());
-        let pwr = unsafe { &(*PWR::ptr()) };
-        pwr.cr1.modify(|_, w| w.dbp().set_bit());
-    }
-
     fn config_pll(&self, pll_cfg: PllConfig) -> PLLClocks {
         // Disable PLL
         self.rb.cr.modify(|_, w| w.pllon().clear_bit());

From acc6c5ce47f42d6b6eb7e7ea60088a7e5462d3e5 Mon Sep 17 00:00:00 2001
From: Albin Hedman <albin9604@gmail.com>
Date: Mon, 5 Aug 2024 01:33:01 +0200
Subject: [PATCH 8/8] RTC - Use newtypes

---
 src/rtc.rs  | 28 ++++++++++++++--------------
 src/time.rs | 40 ++++++++++++++++++++--------------------
 2 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/src/rtc.rs b/src/rtc.rs
index a1896072..a5884c44 100644
--- a/src/rtc.rs
+++ b/src/rtc.rs
@@ -1,7 +1,7 @@
 //! Real Time Clock
 use core::convert::TryInto;
 
-use crate::rcc::{RtcSrc, Rcc};
+use crate::rcc::{Rcc, RtcSrc};
 use crate::stm32::RTC;
 use crate::time::{self, *};
 
@@ -52,18 +52,18 @@ impl Alarm {
         self
     }
 
-    pub fn set_hours(mut self, val: u8) -> Self {
-        self.hours = Some(val);
+    pub fn set_hours(mut self, val: time::Hour) -> Self {
+        self.hours = Some(val.ticks().try_into().unwrap());
         self
     }
 
-    pub fn set_minutes(mut self, val: u8) -> Self {
-        self.minutes = Some(val);
+    pub fn set_minutes(mut self, val: time::Minute) -> Self {
+        self.minutes = Some(val.ticks().try_into().unwrap());
         self
     }
 
-    pub fn set_seconds(mut self, val: u8) -> Self {
-        self.seconds = Some(val);
+    pub fn set_seconds(mut self, val: time::Second) -> Self {
+        self.seconds = Some(val.ticks().try_into().unwrap());
         self
     }
 
@@ -120,9 +120,9 @@ impl Rtc {
     }
 
     pub fn set_date(&mut self, date: &Date) {
-        let (yt, yu) = bcd2_encode((date.year - 2000).try_into().unwrap());
-        let (mt, mu) = bcd2_encode(date.month);
-        let (dt, du) = bcd2_encode(date.day);
+        let (yt, yu) = bcd2_encode((date.year.0 - 2000).try_into().unwrap());
+        let (mt, mu) = bcd2_encode(date.month.0.try_into().unwrap());
+        let (dt, du) = bcd2_encode(date.day.0.try_into().unwrap());
 
         self.modify(|rb| {
             rb.dr.write(|w| unsafe {
@@ -139,15 +139,15 @@ impl Rtc {
                     .yu()
                     .bits(yu)
                     .wdu()
-                    .bits(date.day)
+                    .bits(date.day.0.try_into().unwrap())
             });
         });
     }
 
     pub fn set_time(&mut self, time: &Time) {
-        let (ht, hu) = bcd2_encode(time.hours);
-        let (mnt, mnu) = bcd2_encode(time.minutes);
-        let (st, su) = bcd2_encode(time.seconds);
+        let (ht, hu) = bcd2_encode(time.hours.ticks().try_into().unwrap());
+        let (mnt, mnu) = bcd2_encode(time.minutes.ticks().try_into().unwrap());
+        let (st, su) = bcd2_encode(time.seconds.ticks().try_into().unwrap());
         self.modify(|rb| {
             rb.tr.write(|w| unsafe {
                 w.ht()
diff --git a/src/time.rs b/src/time.rs
index e36d493f..0e37e290 100644
--- a/src/time.rs
+++ b/src/time.rs
@@ -35,19 +35,18 @@ pub struct Year(pub u32);
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Time {
-    pub hours: u8,
-    pub minutes: u8,
-    pub seconds: u8,
+    pub hours: Hour,
+    pub minutes: Minute,
+    pub seconds: Second,
     pub daylight_savings: bool,
 }
 
 impl Time {
     pub fn new(hours: Hour, minutes: Minute, seconds: Second, daylight_savings: bool) -> Self {
-        use core::convert::TryInto;
         Self {
-            hours: hours.ticks().try_into().unwrap(),
-            minutes: minutes.ticks().try_into().unwrap(),
-            seconds: seconds.ticks().try_into().unwrap(),
+            hours,
+            minutes,
+            seconds,
             daylight_savings,
         }
     }
@@ -60,28 +59,23 @@ impl defmt::Format for Time {
         defmt::write!(
             f,
             "{:02}:{:02}:{:02}",
-            self.hours,
-            self.minutes,
-            self.seconds
+            self.hours.ticks(),
+            self.minutes.ticks(),
+            self.seconds.ticks()
         )
     }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Date {
-    pub year: u16,
-    pub month: u8,
-    pub day: u8,
+    pub year: Year,
+    pub month: Month,
+    pub day: MonthDay,
 }
 
 impl Date {
     pub fn new(year: Year, month: Month, day: MonthDay) -> Self {
-        use core::convert::TryInto;
-        Self {
-            day: day.0.try_into().unwrap(),
-            month: month.0.try_into().unwrap(),
-            year: year.0.try_into().unwrap(),
-        }
+        Self { day, month, year }
     }
 }
 
@@ -89,7 +83,13 @@ impl Date {
 impl defmt::Format for Date {
     fn format(&self, f: defmt::Formatter) {
         // format the bitfields of the register as struct fields
-        defmt::write!(f, "{:04}-{:02}-{:02}", self.year, self.month, self.day)
+        defmt::write!(
+            f,
+            "{:04}-{:02}-{:02}",
+            self.year.0,
+            self.month.0,
+            self.day.0
+        )
     }
 }