split rtc module out to reduce repreated exactly same code

rust/src/hal/rtc.rs

@@ -0,0 +1,157 @@
+use anyhow::{anyhow, bail};
+use bincode::{config, Decode, Encode};
+use chrono::{DateTime, Utc};
+use ds323x::{DateTimeAccess, Ds323x};
+use eeprom24x::{Eeprom24x, Eeprom24xTrait};
+use embedded_hal_bus::i2c::MutexDevice;
+use esp_idf_hal::delay::Delay;
+use esp_idf_hal::i2c::I2cDriver;
+use serde::{Deserialize, Serialize};
+use std::result::Result::Ok as OkStd;
+
+const X25: crc::Crc<u16> = crc::Crc::<u16>::new(&crc::CRC_16_IBM_SDLC);
+
+pub trait RTCModuleInteraction {
+    fn get_backup_info(&mut self) -> anyhow::Result<BackupHeader>;
+    fn get_backup_config(&mut self) -> anyhow::Result<Vec<u8>>;
+    fn backup_config(&mut self, bytes: &[u8]) -> anyhow::Result<()>;
+    fn get_rtc_time(&mut self) -> anyhow::Result<DateTime<Utc>>;
+    fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> anyhow::Result<()>;
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Debug, Default, Encode, Decode)]
+pub struct BackupHeader {
+    pub timestamp: i64,
+    crc16: u16,
+    pub size: usize,
+}
+
+pub struct DS3231Module<'a> {
+    pub(crate) rtc:
+        Ds323x<ds323x::interface::I2cInterface<MutexDevice<'a, I2cDriver<'a>>>, ds323x::ic::DS3231>,
+    pub(crate) eeprom: Eeprom24x<
+        MutexDevice<'a, I2cDriver<'a>>,
+        eeprom24x::page_size::B32,
+        eeprom24x::addr_size::TwoBytes,
+        eeprom24x::unique_serial::No,
+    >,
+}
+
+impl RTCModuleInteraction for DS3231Module<'_> {
+    fn get_backup_info(&mut self) -> anyhow::Result<BackupHeader> {
+        let config = config::standard();
+        let store = bincode::encode_to_vec(&BackupHeader::default(), config)?.len();
+        let mut header_page_buffer = vec![0_u8; store];
+
+        self.eeprom
+            .read_data(0, &mut header_page_buffer)
+            .map_err(|err| anyhow!("Error reading eeprom header {:?}", err))?;
+
+        println!("Raw header is {:?} with size {}", header_page_buffer, store);
+        let (header, _len): (BackupHeader, usize) =
+            bincode::decode_from_slice(&header_page_buffer[..], config)?;
+        anyhow::Ok(header)
+    }
+
+    fn get_backup_config(&mut self) -> anyhow::Result<Vec<u8>> {
+        let config = config::standard();
+        let store = bincode::encode_to_vec(&BackupHeader::default(), config)?.len();
+        let mut header_page_buffer = vec![0_u8; store];
+
+        self.eeprom
+            .read_data(0, &mut header_page_buffer)
+            .map_err(|err| anyhow!("Error reading eeprom header {:?}", err))?;
+
+        let (header, _len): (BackupHeader, usize) =
+            bincode::decode_from_slice(&header_page_buffer[..], config)?;
+
+        //skip page 0, used by the header
+        let data_start_address = self.eeprom.page_size() as u32;
+        let mut data_buffer = vec![0_u8; header.size];
+        self.eeprom
+            .read_data(data_start_address, &mut data_buffer)
+            .map_err(|err| anyhow!("Error reading eeprom data {:?}", err))?;
+
+        let checksum = X25.checksum(&data_buffer);
+        if checksum != header.crc16 {
+            bail!(
+                "Invalid checksum, got {} but expected {}",
+                checksum,
+                header.crc16
+            );
+        }
+
+        anyhow::Ok(data_buffer)
+    }
+    fn backup_config(&mut self, bytes: &[u8]) -> anyhow::Result<()> {
+        let time = self.get_rtc_time()?.timestamp_millis();
+
+        let delay = Delay::new_default();
+
+        let checksum = X25.checksum(bytes);
+        let page_size = self.eeprom.page_size();
+
+        let header = BackupHeader {
+            crc16: checksum,
+            timestamp: time,
+            size: bytes.len(),
+        };
+        let config = config::standard();
+        let encoded = bincode::encode_to_vec(&header, config)?;
+        if encoded.len() > page_size {
+            bail!(
+                "Size limit reached header is {}, but firest page is only {}",
+                encoded.len(),
+                page_size
+            )
+        }
+        let as_u8: &[u8] = &encoded;
+
+        match self.eeprom.write_page(0, as_u8) {
+            OkStd(_) => {}
+            Err(err) => bail!("Error writing eeprom {:?}", err),
+        };
+        delay.delay_ms(5);
+
+        let to_write = bytes.chunks(page_size);
+
+        let mut lastiter = 0;
+        let mut current_page = 1;
+        for chunk in to_write {
+            let address = current_page * page_size as u32;
+            self.eeprom
+                .write_page(address, chunk)
+                .map_err(|err| anyhow!("Error writing eeprom {:?}", err))?;
+            current_page += 1;
+
+            let iter = (current_page % 8) as usize;
+            if iter != lastiter {
+                //todo we want to call progress here, how to do this?
+                //target.progress();
+                lastiter = iter;
+            }
+
+            delay.delay_ms(5);
+        }
+        anyhow::Ok(())
+    }
+
+    fn get_rtc_time(&mut self) -> anyhow::Result<DateTime<Utc>> {
+        match self.rtc.datetime() {
+            OkStd(rtc_time) => anyhow::Ok(rtc_time.and_utc()),
+            Err(err) => {
+                bail!("Error getting rtc time {:?}", err)
+            }
+        }
+    }
+
+    fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> anyhow::Result<()> {
+        let naive_time = time.naive_utc();
+        match self.rtc.set_datetime(&naive_time) {
+            OkStd(_) => anyhow::Ok(()),
+            Err(err) => {
+                bail!("Error getting rtc time {:?}", err)
+            }
+        }
+    }
+}