diff --git a/examples/rtc.rs b/examples/rtc.rs
new file mode 100644
index 00000000..31e7103d
--- /dev/null
+++ b/examples/rtc.rs
@@ -0,0 +1,47 @@
+#![no_main]
+#![no_std]
+
+use hal::{
+    delay::SYSTDelayExt,
+    rcc::RccExt,
+    rtc::RtcExt,
+    stm32::Peripherals,
+    time::{Date, ExtU32, Month, MonthDay, Time, Year},
+};
+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 mut rcc = dp.RCC.constrain();
+
+    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(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());
+        delay.delay_ms(500);
+    }
+}
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..5c60ea1a 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..24cf024c 100644
--- a/src/rcc/mod.rs
+++ b/src/rcc/mod.rs
@@ -231,12 +231,6 @@ impl Rcc {
         }
     }
 
-    pub fn unlock_rtc(&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());
@@ -457,6 +451,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..a5884c44
--- /dev/null
+++ b/src/rtc.rs
@@ -0,0 +1,394 @@
+//! Real Time Clock
+use core::convert::TryInto;
+
+use crate::rcc::{Rcc, RtcSrc};
+use crate::stm32::RTC;
+use crate::time::{self, *};
+
+#[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<u8>,
+    hours: Option<u8>,
+    minutes: Option<u8>,
+    seconds: Option<u8>,
+    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: time::MonthDay) -> Self {
+        self.use_weekday = false;
+        self.day = Some(day.0.try_into().unwrap());
+        self
+    }
+
+    pub fn set_week_day(mut self, day: time::WeekDay) -> Self {
+        self.use_weekday = true;
+        self.day = Some(day.0.try_into().unwrap());
+        self
+    }
+
+    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: time::Minute) -> Self {
+        self.minutes = Some(val.ticks().try_into().unwrap());
+        self
+    }
+
+    pub fn set_seconds(mut self, val: time::Second) -> Self {
+        self.seconds = Some(val.ticks().try_into().unwrap());
+        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.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 {
+                w.dt()
+                    .bits(dt)
+                    .du()
+                    .bits(du)
+                    .mt()
+                    .bit(mt > 0)
+                    .mu()
+                    .bits(mu)
+                    .yt()
+                    .bits(yt)
+                    .yu()
+                    .bits(yu)
+                    .wdu()
+                    .bits(date.day.0.try_into().unwrap())
+            });
+        });
+    }
+
+    pub fn set_time(&mut self, time: &Time) {
+        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()
+                    .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()) + 2000).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());
+        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 {
+                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());
+        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 {
+                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;
+}
+
+// TODO: Add support for RTC_OUT1 and RTC_OUT2
+/*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: u8) -> (u8, u8) {
+    let bcd_high = word / 10;
+    let bcd_low = word % 10;
+    (bcd_high, bcd_low)
+}
+
+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 98a44a31..0e37e290 100644
--- a/src/time.rs
+++ b/src/time.rs
@@ -35,37 +35,61 @@ 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: 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 {
         Self {
-            hours: hours.ticks(),
-            minutes: minutes.ticks(),
-            seconds: seconds.ticks(),
+            hours,
+            minutes,
+            seconds,
             daylight_savings,
         }
     }
 }
 
+#[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.ticks(),
+            self.minutes.ticks(),
+            self.seconds.ticks()
+        )
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct Date {
-    pub day: u32,
-    pub month: u32,
-    pub year: u32,
+    pub year: Year,
+    pub month: Month,
+    pub day: MonthDay,
 }
 
 impl Date {
     pub fn new(year: Year, month: Month, day: MonthDay) -> Self {
-        Self {
-            day: day.0,
-            month: month.0,
-            year: year.0,
-        }
+        Self { day, month, year }
+    }
+}
+
+#[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.0,
+            self.month.0,
+            self.day.0
+        )
     }
 }