i2c working, rtc working, eeprom working

rust/src/hal/mod.rs

@@ -2,13 +2,13 @@ pub(crate) mod battery;
 pub mod esp;
 mod initial_hal;
 mod little_fs2storage_adapter;
-mod rtc;
+pub(crate) mod rtc;
 mod v4_hal;
 mod water;
 //mod water;
 
 use crate::alloc::string::ToString;
-use crate::hal::rtc::RTCModuleInteraction;
+use crate::hal::rtc::{DS3231Module, RTCModuleInteraction};
 use esp_hal::peripherals::Peripherals;
 use esp_hal::peripherals::GPIO0;
 use esp_hal::peripherals::GPIO1;
@@ -54,10 +54,20 @@ use alloc::format;
 use alloc::sync::Arc;
 use async_trait::async_trait;
 use chrono::{DateTime, FixedOffset, Utc};
+use core::cell::RefCell;
+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 eeprom24x::{Eeprom24x, SlaveAddr, Storage};
+use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
 use embassy_executor::Spawner;
+use embassy_sync::blocking_mutex::{CriticalSectionMutex, NoopMutex};
 //use battery::BQ34Z100G1;
 //use bq34z100::Bq34z100g1Driver;
-use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::blocking_mutex::raw::{CriticalSectionRawMutex, NoopRawMutex};
 use esp_bootloader_esp_idf::partitions::{
     AppPartitionSubType, DataPartitionSubType, FlashRegion, PartitionEntry,
 };
@@ -74,10 +84,14 @@ use embassy_sync::once_lock::OnceLock;
 use esp_alloc as _;
 use esp_backtrace as _;
 use esp_bootloader_esp_idf::ota::Slot;
+use esp_hal::delay::Delay;
+use esp_hal::i2c::master::{BusTimeout, Config, I2c};
 use esp_hal::rng::Rng;
 use esp_hal::rtc_cntl::{Rtc, SocResetReason};
 use esp_hal::system::reset_reason;
+use esp_hal::time::Rate;
 use esp_hal::timer::timg::TimerGroup;
+use esp_hal::Blocking;
 use esp_storage::FlashStorage;
 use esp_wifi::{init, EspWifiController};
 use littlefs2::fs::{Allocation, Filesystem as lfs2Filesystem};
@@ -90,8 +104,9 @@ pub static TIME_ACCESS: OnceLock<Rtc> = OnceLock::new();
 pub const PLANT_COUNT: usize = 8;
 
 const TANK_MULTI_SAMPLE: usize = 11;
-
-//pub static I2C_DRIVER: LazyLock<Mutex<CriticalSectionRawMutex,I2cDriver<'static>>> = LazyLock::new(PlantHal::create_i2c);
+static I2C_DRIVER: OnceLock<
+    embassy_sync::blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<I2c<Blocking>>>,
+> = OnceLock::new();
 
 #[derive(Debug, PartialEq)]
 pub enum Sensor {
@@ -127,22 +142,16 @@ pub trait BoardInteraction<'a> {
     fn set_config(&mut self, config: PlantControllerConfig);
     async fn get_mptt_voltage(&mut self) -> Result<Voltage, FatError>;
     async fn get_mptt_current(&mut self) -> Result<Current, FatError>;
-}
 
-impl dyn BoardInteraction<'_> {
-    //the counter is just some arbitrary number that increases whenever some progress was made, try to keep the updates < 10 per second for ux reasons
-    async fn _progress(&mut self, counter: u32) {
+    async fn progress(&mut self, counter: u32) {
         let even = counter % 2 == 0;
         let current = counter / (PLANT_COUNT as u32);
         for led in 0..PLANT_COUNT {
-            match self.fault(led, current == led as u32).await {
-                Result::Ok(_) => {}
-                Err(err) => {
-                    warn!("Fault on plant {}: {:?}", led, err);
-                }
+            if let Err(err) = self.fault(led, current == led as u32).await {
+                warn!("Fault on plant {}: {:?}", led, err);
             }
         }
-        let _ = self.general_fault(even.into());
+        let _ = self.general_fault(even.into()).await;
     }
 }
 
@@ -196,7 +205,7 @@ macro_rules! mk_static {
 const GW_IP_ADDR_ENV: Option<&'static str> = option_env!("GATEWAY_IP");
 
 impl PlantHal {
-    // fn create_i2c() -> Mutex<CriticalSectionRawMutex, I2cDriver<'static>> {
+    //fn create_i2c() -> Mutex<CriticalSectionRawMutex, ()> {
     //     let peripherals = unsafe { Peripherals::new() };
     //
     //     let config = I2cConfig::new()
@@ -210,7 +219,7 @@ impl PlantHal {
     //     let sda = peripherals.pins.gpio20.downgrade();
     //
     //     Mutex::new(I2cDriver::new(i2c, sda, scl, &config).unwrap())
-    // }
+    //}
 
     pub async fn create(
         spawner: Spawner,
@@ -427,28 +436,55 @@ impl PlantHal {
         let config = esp.load_config().await;
 
         log::info!("Init rtc driver");
-        // let mut rtc = Ds323x::new_ds3231(MutexDevice::new(&I2C_DRIVER));
-        //
-        // log::info!("Init rtc eeprom driver");
-        // let eeprom = {
-        //     Eeprom24x::new_24x32(
-        //         MutexDevice::new(&I2C_DRIVER),
-        //         SlaveAddr::Alternative(true, true, true),
-        //     )
-        // };
-        // let rtc_time = rtc.datetime();
-        // match rtc_time {
-        //     OkStd(tt) => {
-        //         log::info!("Rtc Module reports time at UTC {}", tt);
-        //     }
-        //     Err(err) => {
-        //         log::info!("Rtc Module could not be read {:?}", err);
-        //     }
-        // }
 
-        // let storage = Storage::new(eeprom, Delay::new(1000));
-        let rtc_module: Box<dyn RTCModuleInteraction + Send> = Box::new(initial_hal::NoRTC {});
-        //    Box::new(DS3231Module { rtc, storage }) as Box<dyn RTCModuleInteraction + Send>;
+        let sda = peripherals.GPIO20;
+        let scl = peripherals.GPIO19;
+
+        let i2c = I2c::new(
+            peripherals.I2C0,
+            Config::default()
+                .with_frequency(Rate::from_hz(100))
+                .with_timeout(BusTimeout::Maximum),
+        )?
+        .with_scl(scl)
+        .with_sda(sda);
+        let i2c_bus: embassy_sync::blocking_mutex::Mutex<
+            CriticalSectionRawMutex,
+            RefCell<I2c<Blocking>>,
+        > = CriticalSectionMutex::new(RefCell::new(i2c));
+
+        I2C_DRIVER.init(i2c_bus).expect("Could not init i2c driver");
+
+        let i2c_bus = I2C_DRIVER.get().await;
+        let rtc_device = I2cDevice::new(&i2c_bus);
+        let eeprom_device = I2cDevice::new(&i2c_bus);
+
+        let mut rtc: Ds323x<
+            I2cInterface<I2cDevice<CriticalSectionRawMutex, I2c<Blocking>>>,
+            DS3231,
+        > = Ds323x::new_ds3231(rtc_device);
+
+        info!("Init rtc eeprom driver");
+        let eeprom = Eeprom24x::new_24x32(eeprom_device, SlaveAddr::Alternative(true, true, true));
+        let rtc_time = rtc.datetime();
+        match rtc_time {
+            Ok(tt) => {
+                log::info!("Rtc Module reports time at UTC {}", tt);
+            }
+            Err(err) => {
+                log::info!("Rtc Module could not be read {:?}", err);
+            }
+        }
+
+        let storage: Storage<
+            I2cDevice<'static, CriticalSectionRawMutex, I2c<Blocking>>,
+            B32,
+            TwoBytes,
+            No,
+            Delay,
+        > = Storage::new(eeprom, Delay::new());
+        let rtc_module: Box<dyn RTCModuleInteraction + Send> =
+            Box::new(DS3231Module { rtc, storage }) as Box<dyn RTCModuleInteraction + Send>;
 
         let hal = match config {
             Result::Ok(config) => {