Added impl for get & set time. Started testing, init is failing will need to expore this further

Author: MabezDev

.vscode/launch.json

@@ -13,7 +13,7 @@
             "debugger_args": [
                 "-nx" // dont use the .gdbinit file
             ],
-            "executable": "./target/thumbv7em-none-eabi/debug/examples/serial_dma_partial_peek",
+            "executable": "./target/thumbv7em-none-eabi/debug/examples/rtc",
             "remote": true,
             "target": ":3333",
             "cwd": "${workspaceRoot}",

examples/rtc.rs

@@ -0,0 +1,76 @@
+//! Blinks an LED
+
+#![deny(unsafe_code)]
+// #![deny(warnings)]
+#![no_std]
+#![no_main]
+
+extern crate cortex_m;
+#[macro_use]
+extern crate cortex_m_rt as rt;
+extern crate cortex_m_semihosting as sh;
+extern crate panic_semihosting;
+extern crate stm32l432xx_hal as hal;
+// #[macro_use(block)]
+// extern crate nb;
+
+use hal::prelude::*;
+use hal::stm32l4::stm32l4x2;
+
+use hal::delay::Delay;
+use hal::rtc::Rtc;
+use hal::rtc::Time;
+use hal::datetime::*;
+use rt::ExceptionFrame;
+
+use core::fmt::Write;
+use sh::hio;
+
+entry!(main);
+
+fn main() -> ! {
+
+    let mut hstdout = hio::hstdout().unwrap();
+
+    writeln!(hstdout, "Hello, world!").unwrap();
+
+    let cp = cortex_m::Peripherals::take().unwrap();
+    let dp = stm32l4x2::Peripherals::take().unwrap();
+
+    let mut flash = dp.FLASH.constrain(); // .constrain();
+    let mut rcc = dp.RCC.constrain();
+
+    // Try a different clock configuration
+    let clocks = rcc.cfgr.freeze(&mut flash.acr);
+    // let clocks = rcc.cfgr
+    //     .sysclk(64.mhz())
+    //     .pclk1(32.mhz())
+    //     .freeze(&mut flash.acr);
+    let mut timer = Delay::new(cp.SYST, clocks);
+
+    let rtc = Rtc::init(dp.RTC, &mut rcc.bdcr);
+    let time = Time::new(0, 0, 19, false);
+    rtc.set_time(&time);
+
+    timer.delay_ms(1000_u32);
+    timer.delay_ms(1000_u32);
+    timer.delay_ms(1000_u32);
+
+    let _time = rtc.get_time();
+
+    
+    writeln!(hstdout, "Good bye!").unwrap();
+    loop {}
+}
+
+exception!(HardFault, hard_fault);
+
+fn hard_fault(ef: &ExceptionFrame) -> ! {
+    panic!("{:#?}", ef);
+}
+
+exception!(*, default_handler);
+
+fn default_handler(irqn: i16) {
+    panic!("Unhandled exception (IRQn = {})", irqn);
+}

src/datetime.rs

@@ -91,3 +91,21 @@ impl Into<Seconds> for Hours {
         Seconds(self.0 * 3600)
     }
 }
+
+impl From <u32> for Seconds {
+    fn from(inner: u32) -> Seconds {
+        Seconds(inner)
+    }
+}
+
+impl From <u32> for Minutes {
+    fn from(inner: u32) -> Minutes {
+        Minutes(inner)
+    }
+}
+
+impl From <u32> for Hours {
+    fn from(inner: u32) -> Hours {
+        Hours(inner)
+    }
+}

src/rtc.rs

@@ -1,23 +1,35 @@
 /// RTC peripheral abstraction
 
 use datetime::*;
-use rcc::{BDCR, Clocks};
-use stm32l4::stm32l4x2::{RTC, rtc};
+use rcc::{BDCR};
+use stm32l4::stm32l4x2::{RTC};
 
+#[derive(Clone,Copy,Debug)]
 pub struct Time {
-    seconds: Seconds,
-    minutes: Minutes,
-    hours: Hours,
+    seconds: u8,
+    minutes: u8,
+    hours: u8,
     daylight_savings: bool
 }
 
+impl Time {
+    pub fn new(hours: u8, minutes: u8, seconds: u8, daylight_savings: bool) -> Self {
+        Self {
+            seconds: seconds,
+            minutes: minutes,
+            hours: hours,
+            daylight_savings: daylight_savings
+        }
+    }
+}
+
 /// RTC Abstraction
 pub struct Rtc {
     rtc: RTC
 }
 
 impl Rtc {
-    pub fn init(&self, rtc: RTC, bdcr: &mut BDCR) -> Self {
+    pub fn init(rtc: RTC, bdcr: &mut BDCR) -> Self {
         bdcr.enr().modify(|_, w| unsafe {
             w.rtcsel()
                 /* 
@@ -31,9 +43,9 @@ impl Rtc {
                 .set_bit()
         });
 
-        self.write_protection(&rtc, false);
+       write_protection(&rtc, false);
         {
-            self.init_mode(&rtc, true);
+            init_mode(&rtc, true);
             {
                 rtc.cr.modify(|_, w| unsafe {
                     w.fmt()
@@ -57,7 +69,7 @@ impl Rtc {
                         .bits(127)
                 });
             }
-            self.init_mode(&rtc, false);
+            init_mode(&rtc, false);
 
             rtc.or.modify(|_, w| {
                 w.rtc_alarm_type()
@@ -67,61 +79,93 @@ impl Rtc {
             });
 
         }
-        self.write_protection(&rtc, true);
+        write_protection(&rtc, true);
 
         Self {
             rtc: rtc
         }
     }
 
-    fn init_mode(&self, rtc: &RTC, enabled: bool) {
-        if enabled {
-            rtc.isr.write(|w| unsafe { w.bits(0xFFFFFFFF) }); // Sets init mode
-            while rtc.isr.read().initf().bit_is_clear() {} // wait to return to init state
-        } else {
-            rtc.isr.write(|w| { w.init().clear_bit() }); // Exits init mode
+    pub fn set_time(&self, time: &Time){
+        write_protection(&self.rtc, false);
+        {
+            init_mode(&self.rtc, true);
+            {
+                self.rtc.tr.write(|w| unsafe {
+                    w.pm()
+                        .clear_bit()
+                        .hu()
+                        .bits(byte_to_bcd2(time.hours as u8))
+                        .mnu()
+                        .bits(byte_to_bcd2(time.minutes as u8))
+                        .su()
+                        .bits(byte_to_bcd2(time.seconds as u8))
+
+                });
+
+                self.rtc.cr.modify(|_, w| {
+                    w.fmt()
+                        .bit(time.daylight_savings)
+
+                });
+            }
+            init_mode(&self.rtc, false);
         }
-        
+        write_protection(&self.rtc, true);
     }
 
-    pub fn set_time(&self, time: Time){
-        self.write_protection(&self.rtc, false);
+    pub fn get_time(&self) -> Time {
+        let time;
+        write_protection(&self.rtc, false);
         {
-            self.init_mode(&self.rtc, true);
+            init_mode(&self.rtc, true);
             {
-                self.rtc.tr.write(|w| {
-                    w.pm()
-                        .clear_bit()
-                        //TODO set time!
-                })
+                let timer = self.rtc.tr.read();
+                let cr = self.rtc.cr.read();
+                time = Time::new(timer.su().bits(), timer.mnu().bits(), timer.hu().bits(), cr.fmt().bit());
             }
-            self.init_mode(&self.rtc, false);
+            init_mode(&self.rtc, false);
         }
-        self.write_protection(&self.rtc, true);
+        write_protection(&self.rtc, true);
+        time
     }
+    
+}
 
-    fn write_protection(&self, rtc: &RTC, enable: bool){
-        if enable {
-            rtc.wpr.write(|w| unsafe {
+fn write_protection(rtc: &RTC, enable: bool){
+    if enable {
+        rtc.wpr.write(|w| unsafe {
             w.bits(0xFF)
-            });
-        } else {
-            rtc.wpr.write(|w| unsafe {
-                w.bits(0xCA)
-            });
+        });
+    } else {
+        rtc.wpr.write(|w| unsafe {
+            w.bits(0xCA)
+        });
 
-            rtc.wpr.write(|w| unsafe {
-                w.bits(0x53)
-            });
-        }
+        rtc.wpr.write(|w| unsafe {
+            w.bits(0x53)
+        });
+    }
+}
+
+fn init_mode(rtc: &RTC, enabled: bool) {
+    if enabled {
+        let isr = rtc.isr.read();
+        if isr.initf().bit_is_clear() {
+            rtc.isr.write(|w| unsafe { w.bits(0xFFFFFFFF) }); // Sets init mode
+            while rtc.isr.read().initf().bit_is_clear() {} // wait to return to init state
+        } 
+    } else {
+        rtc.isr.write(|w| { w.init().clear_bit() }); // Exits init mode
     }
+    
 }
 
 fn byte_to_bcd2(byte: u8) -> u8{
     let mut bcd_high: u8 = 0;
     let mut value = byte;
 
-    while byte >= 10 {
+    while value >= 10 {
         bcd_high += 1;
         value -= 10;
     }