refactor: consolidate logging and time handling, remove TIME_ACCESS and LOG_ACCESS

Software/MainBoard/rust/src/hal/mod.rs

@@ -44,8 +44,8 @@ use crate::{
         battery::{BatteryInteraction, NoBatteryMonitor},
         esp::Esp,
     },
+    log::log,
     log::LogMessage,
-    BOARD_ACCESS,
 };
 use alloc::boxed::Box;
 use alloc::format;
@@ -77,7 +77,6 @@ use crate::fat_error::{ContextExt, FatError, FatResult};
 use crate::hal::battery::WCHI2CSlave;
 use crate::hal::savegame_manager::SavegameManager;
 use crate::hal::water::TankSensor;
-use crate::log::LOG_ACCESS;
 use embassy_sync::mutex::Mutex;
 use embassy_sync::once_lock::OnceLock;
 use embedded_storage::nor_flash::RmwNorFlashStorage;
@@ -104,8 +103,6 @@ use portable_atomic::AtomicBool;
 use serde::{Deserialize, Serialize};
 use shared_flash::MutexFlashStorage;
 
-pub static TIME_ACCESS: OnceLock<Mutex<CriticalSectionRawMutex, Rtc>> = OnceLock::new();
-
 //Only support for 8 right now!
 pub const PLANT_COUNT: usize = 8;
 
@@ -145,6 +142,8 @@ pub trait BoardInteraction<'a> {
     fn get_config(&mut self) -> &PlantControllerConfig;
     fn get_battery_monitor(&mut self) -> &mut Box<dyn BatteryInteraction + Send>;
     fn get_rtc_module(&mut self) -> &mut Box<dyn RTCModuleInteraction + Send>;
+    async fn get_time(&mut self) -> DateTime<Utc>;
+    async fn set_time(&mut self, time: &DateTime<FixedOffset>) -> FatResult<()>;
     async fn set_charge_indicator(&mut self, charging: bool) -> Result<(), FatError>;
     async fn deep_sleep(&mut self, duration_in_ms: u64) -> !;
 
@@ -246,12 +245,7 @@ impl PlantHal {
         esp_alloc::heap_allocator!(size: 64 * 1024);
         esp_alloc::heap_allocator!(#[link_section = ".dram2_uninit"] size: 64000);
 
-        let rtc: Rtc = Rtc::new(peripherals.LPWR);
-        TIME_ACCESS
-            .init(Mutex::new(rtc))
-            .map_err(|_| FatError::String {
-                error: "Init error rct".to_string(),
-            })?;
+        let rtc_peripheral: Rtc = Rtc::new(peripherals.LPWR);
 
         let timg0 = TimerGroup::new(peripherals.TIMG0);
         let sw_int = SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
@@ -409,6 +403,7 @@ impl PlantHal {
             slot0_state: state_0,
             slot1_state: state_1,
             uart0,
+            rtc: rtc_peripheral,
         };
 
         //init,reset rtc memory depending on cause
@@ -444,17 +439,14 @@ impl PlantHal {
                 SocResetReason::Cpu0JtagCpu => "cpu0 jtag cpu",
             },
         };
-        LOG_ACCESS
-            .lock()
-            .await
-            .log(
-                LogMessage::ResetReason,
-                init_rtc_store as u32,
-                to_config_mode as u32,
-                "",
-                &format!("{reasons:?}"),
-            )
-            .await;
+        log(
+            LogMessage::ResetReason,
+            init_rtc_store as u32,
+            to_config_mode as u32,
+            "",
+            &format!("{reasons:?}"),
+        )
+        .await;
 
         esp.init_rtc_deepsleep_memory(init_rtc_store, to_config_mode)
             .await;
@@ -548,17 +540,14 @@ impl PlantHal {
                 HAL { board_hal }
             }
             Err(err) => {
-                LOG_ACCESS
-                    .lock()
-                    .await
-                    .log(
-                        LogMessage::ConfigModeMissingConfig,
-                        0,
-                        0,
-                        "",
-                        &err.to_string(),
-                    )
-                    .await;
+                log(
+                    LogMessage::ConfigModeMissingConfig,
+                    0,
+                    0,
+                    "",
+                    &err.to_string(),
+                )
+                .await;
                 HAL {
                     board_hal: v4_hal::create_v4(
                         free_pins,
@@ -641,27 +630,6 @@ pub fn next_partition(current: AppPartitionSubType) -> FatResult<AppPartitionSub
     Ok(next)
 }
 
-pub async fn esp_time() -> DateTime<Utc> {
-    let guard = TIME_ACCESS.get().await.lock().await;
-    DateTime::from_timestamp_micros(guard.current_time_us() as i64).unwrap_or(DateTime::UNIX_EPOCH)
-}
-
-pub async fn esp_set_time(time: DateTime<FixedOffset>) -> FatResult<()> {
-    {
-        let guard = TIME_ACCESS.get().await.lock().await;
-        guard.set_current_time_us(time.timestamp_micros() as u64);
-    }
-    BOARD_ACCESS
-        .get()
-        .await
-        .lock()
-        .await
-        .board_hal
-        .get_rtc_module()
-        .set_rtc_time(&time.to_utc())
-        .await
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Default, Serialize)]
 pub struct Moistures {
     pub sensor_a_hz: [Option<f32>; PLANT_COUNT],