C3MA/PlantCtrl
6
0
Fork 0
Code Issues 7 Pull Requests Packages Projects Releases Wiki Activity

i2c working, rtc working, eeprom working

Browse Source
This commit is contained in:
Empire Phoenix
2025-09-22 23:44:33 +02:00
parent 1791f463b7
commit 5b0e2b6797
9 changed files with 523 additions and 407 deletions
Download Patch File Download Diff File Expand all files Collapse all files

237
rust/src/hal/rtc.rs
View File

@@ -1,139 +1,138 @@
use crate::bail;
use crate::hal::Box;
use crate::FatError::FatResult;
use alloc::vec;
use alloc::vec::Vec;
use async_trait::async_trait;
use bincode::config::Configuration;
use bincode::{config, Decode, Encode};
use chrono::{DateTime, Utc};
use crc::Digest;
use ds323x::ic::DS3231;
use ds323x::interface::I2cInterface;
use ds323x::{DateTimeAccess, Ds323x};
use eeprom24x::addr_size::TwoBytes;
use eeprom24x::page_size::B32;
use eeprom24x::unique_serial::No;
use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
use embassy_sync::blocking_mutex::raw::{CriticalSectionRawMutex, NoopRawMutex};
use embedded_storage::{ReadStorage, Storage};
use esp_hal::delay::Delay;
use esp_hal::i2c::master::I2c;
use esp_hal::Blocking;
use littlefs2_core::{PathBuf, SeekFrom};
use serde::{Deserialize, Serialize};
// use crate::hal::Box;
// use alloc::vec::Vec;
// use anyhow::{anyhow, bail};
// use async_trait::async_trait;
// use bincode::config::Configuration;
// use bincode::{config, Decode, Encode};
// use chrono::{DateTime, Utc};
// use ds323x::{DateTimeAccess, Ds323x};
// use eeprom24x::addr_size::TwoBytes;
// use eeprom24x::page_size::B32;
// use eeprom24x::unique_serial::No;
// use eeprom24x::Storage;
// use embedded_storage::ReadStorage as embedded_storage_ReadStorage;
// use embedded_storage::Storage as embedded_storage_Storage;
// use serde::{Deserialize, Serialize};
//
// const X25: crc::Crc<u16> = crc::Crc::<u16>::new(&crc::CRC_16_IBM_SDLC);
// const CONFIG: Configuration = config::standard();
pub const X25: crc::Crc<u16> = crc::Crc::<u16>::new(&crc::CRC_16_IBM_SDLC);
const CONFIG: Configuration = config::standard();
//
#[async_trait]
pub trait RTCModuleInteraction {
async fn get_backup_info(&mut self) -> FatResult<BackupHeader>;
async fn get_backup_config(&mut self) -> FatResult<Vec<u8>>;
async fn backup_config(&mut self, bytes: &[u8]) -> FatResult<()>;
async fn get_backup_config(&mut self, chunk: usize) -> FatResult<([u8; 32], usize, u16)>;
async fn backup_config(&mut self, offset: usize, bytes: &[u8]) -> FatResult<()>;
async fn backup_config_finalize(&mut self, crc: u16, length: usize) -> FatResult<()>;
async fn get_rtc_time(&mut self) -> FatResult<DateTime<Utc>>;
async fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> FatResult<()>;
}
//
// const BACKUP_HEADER_MAX_SIZE: usize = 64;
// #[derive(Serialize, Deserialize, PartialEq, Debug, Default, Encode, Decode)]
const BACKUP_HEADER_MAX_SIZE: usize = 64;
#[derive(Serialize, Deserialize, PartialEq, Debug, Default, Encode, Decode)]
pub struct BackupHeader {
pub timestamp: i64,
crc16: u16,
pub size: u16,
}
//
// pub struct DS3231Module<'a> {
// pub(crate) rtc:
// Ds323x<ds323x::interface::I2cInterface<MutexDevice<'a, I2cDriver<'a>>>, ds323x::ic::DS3231>,
//
// pub(crate) storage: Storage<MutexDevice<'a, I2cDriver<'a>>, B32, TwoBytes, No, Delay>,
// }
//
// impl RTCModuleInteraction for DS3231Module<'_> {
// fn get_backup_info(&mut self) -> anyhow::Result<BackupHeader> {
// let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
//
// self.storage
// .read(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)?;
//
// log::info!("Raw header is {:?} with size {}", header_page_buffer, len);
// anyhow::Ok(header)
// }
//
// fn get_backup_config(&mut self) -> anyhow::Result<Vec<u8>> {
// let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
//
// self.storage
// .read(0, &mut header_page_buffer)
// .map_err(|err| anyhow!("Error reading eeprom header {:?}", err))?;
// let (header, _header_size): (BackupHeader, usize) =
// bincode::decode_from_slice(&header_page_buffer[..], CONFIG)?;
//
// let mut data_buffer = vec![0_u8; header.size as usize];
// //read the specified number of bytes after the header
// self.storage
// .read(BACKUP_HEADER_MAX_SIZE as u32, &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 mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
//
// let time = self.get_rtc_time()?.timestamp_millis();
// let checksum = X25.checksum(bytes);
//
// let header = BackupHeader {
// crc16: checksum,
// timestamp: time,
// size: bytes.len() as u16,
// };
// let config = config::standard();
// let encoded = bincode::encode_into_slice(&header, &mut header_page_buffer, config)?;
// log::info!(
// "Raw header is {:?} with size {}",
// header_page_buffer,
// encoded
// );
// self.storage
// .write(0, &header_page_buffer)
// .map_err(|err| anyhow!("Error writing header {:?}", err))?;
//
// //write rest after the header
// self.storage
// .write(BACKUP_HEADER_MAX_SIZE as u32, &bytes)
// .map_err(|err| anyhow!("Error writing body {:?}", err))?;
//
// 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)
// }
// }
// }
// }
pub struct DS3231Module {
pub(crate) rtc: Ds323x<
I2cInterface<I2cDevice<'static, CriticalSectionRawMutex, I2c<'static, Blocking>>>,
DS3231,
>,
pub(crate) storage: eeprom24x::Storage<
I2cDevice<'static, CriticalSectionRawMutex, I2c<'static, Blocking>>,
B32,
TwoBytes,
No,
Delay,
>,
}
#[async_trait]
impl RTCModuleInteraction for DS3231Module {
async fn get_backup_info(&mut self) -> FatResult<BackupHeader> {
let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
self.storage.read(0, &mut header_page_buffer)?;
let (header, len): (BackupHeader, usize) =
bincode::decode_from_slice(&header_page_buffer[..], CONFIG)?;
log::info!("Raw header is {:?} with size {}", header_page_buffer, len);
Ok(header)
}
async fn get_backup_config(&mut self, chunk: usize) -> FatResult<([u8; 32], usize, u16)> {
let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
self.storage.read(0, &mut header_page_buffer)?;
let (header, _header_size): (BackupHeader, usize) =
bincode::decode_from_slice(&header_page_buffer[..], CONFIG)?;
let mut buf = [0_u8; 32];
let offset = chunk * buf.len() + BACKUP_HEADER_MAX_SIZE;
let end: usize = header.size as usize + BACKUP_HEADER_MAX_SIZE;
let current_end = offset + buf.len();
let chunk_size = if current_end > end {
end - offset
} else {
buf.len()
};
if chunk_size == 0 {
Ok((buf, 0, header.crc16))
} else {
self.storage.read(offset as u32, &mut buf)?;
let data = &buf[..chunk_size];
Ok((buf, chunk_size, header.crc16))
}
}
async fn backup_config(&mut self, offset: usize, bytes: &[u8]) -> FatResult<()> {
//skip header and write after
self.storage
.write((BACKUP_HEADER_MAX_SIZE + offset) as u32, &bytes)?;
Ok(())
}
async fn backup_config_finalize(&mut self, crc: u16, length: usize) -> FatResult<()> {
let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
let time = self.get_rtc_time().await?.timestamp_millis();
let header = BackupHeader {
crc16: crc,
timestamp: time,
size: length as u16,
};
let config = config::standard();
let encoded = bincode::encode_into_slice(&header, &mut header_page_buffer, config)?;
log::info!(
"Raw header is {:?} with size {}",
header_page_buffer,
encoded
);
self.storage.write(0, &header_page_buffer)?;
Ok(())
}
async fn get_rtc_time(&mut self) -> FatResult<DateTime<Utc>> {
Ok(self.rtc.datetime()?.and_utc())
}
async fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> FatResult<()> {
let naive_time = time.naive_utc();
Ok(self.rtc.set_datetime(&naive_time)?)
}
}