feat: save state to epoch (nvs)

Author: filipton

src/buttons.rs

@@ -244,7 +244,7 @@ async fn submit_reset_competitor(
         return Ok(false);
     }
 
-    state.reset_solve_state();
+    state.reset_solve_state(None).await;
     Ok(false)
 }
 
@@ -339,7 +339,7 @@ async fn delegate_hold(
 
                 state_val.time_confirmed = true;
                 if !resp.should_scan_cards {
-                    state_val.reset_solve_state();
+                    state_val.reset_solve_state(Some(&state.nvs)).await;
                 }
             }
         }

src/main.rs

@@ -14,7 +14,7 @@ use esp_hal::{
     prelude::*,
     timer::timg::TimerGroup,
 };
-use state::{get_ota_state, GlobalStateInner, Scene};
+use state::{get_ota_state, GlobalStateInner, SavedGlobalState, Scene};
 use structs::ConnSettings;
 use translations::init_translations;
 use utils::{
@@ -281,6 +281,13 @@ async fn main(spawner: Spawner) {
 
     set_brownout_detection(true);
     global_state.state.lock().await.scene = Scene::WaitingForCompetitor;
+    if let Some(saved_state) = SavedGlobalState::from_nvs(&nvs).await {
+        global_state
+            .state
+            .lock()
+            .await
+            .parse_saved_state(saved_state);
+    }
 
     let mut counter = 0;
     loop {

src/rfid.rs

@@ -134,7 +134,7 @@ pub async fn rfid_task(
 
                                         if resp.is_ok() {
                                             log::info!("solve_resp: {resp:?}");
-                                            state.reset_solve_state();
+                                            state.reset_solve_state(Some(&global_state.nvs)).await;
                                         }
                                     }
                                 }

src/stackmat.rs

@@ -5,6 +5,7 @@ use crate::{
     },
 };
 use adv_shift_registers::wrappers::ShifterValueRange;
+use alloc::string::ToString;
 use embassy_time::{Instant, Timer};
 use esp_hal::{gpio::AnyPin, peripherals::UART1, uart::UartRx};
 
@@ -83,11 +84,19 @@ pub async fn stackmat_task(
                                 None
                             };
 
+                            if state.session_id.is_none() {
+                                state.session_id = Some(uuid::Uuid::new_v4().to_string());
+                            }
+
                             if state.current_competitor.is_some() {
                                 state.scene = Scene::Finished;
                             } else if state.scene >= Scene::WaitingForCompetitor {
                                 state.scene = Scene::WaitingForCompetitor;
                             }
+
+                            if let Some(saved_state) = state.to_saved_global_state() {
+                                saved_state.to_nvs(&global_state.nvs).await;
+                            }
                         }
                     } else if parsed.0 == StackmatTimerState::Reset {
                         let mut state = global_state.state.lock().await;

src/state.rs

@@ -1,11 +1,12 @@
 use alloc::{rc::Rc, string::String};
 use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, signal::Signal};
-use embassy_time::Instant;
+use embassy_time::{Duration, Instant};
 use esp_hal_wifimanager::Nvs;
+use serde::{Deserialize, Serialize};
 
 use crate::utils::signaled_mutex::SignaledMutex;
 
-pub static mut EPOCH_BASE: u64 = 1431212400;
+pub static mut EPOCH_BASE: u64 = 0;
 pub static mut SLEEP_STATE: bool = false;
 pub static mut OTA_STATE: bool = false;
 
@@ -125,6 +126,16 @@ pub struct SignaledGlobalStateInner {
     pub ota_update: Option<u8>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SavedGlobalState {
+    pub inspection_time: Option<u64>,
+    pub solve_time: u64,
+    pub penalty: i8,
+    pub session_id: String,
+    pub current_competitor: u64,
+    // pub solve_epoch: u64
+}
+
 impl SignaledGlobalStateInner {
     pub fn new() -> Self {
         Self {
@@ -176,7 +187,7 @@ impl SignaledGlobalStateInner {
         false
     }
 
-    pub fn reset_solve_state(&mut self) {
+    pub async fn reset_solve_state(&mut self, save_nvs: Option<&Nvs>) {
         self.last_solve_time = self.solve_time;
 
         self.solve_time = None;
@@ -189,5 +200,70 @@ impl SignaledGlobalStateInner {
         self.session_id = None;
         self.time_confirmed = false;
         self.scene = Scene::WaitingForCompetitor;
+
+        if let Some(nvs) = save_nvs {
+            SavedGlobalState::clear_saved_global_state(nvs).await;
+        }
+    }
+
+    pub fn to_saved_global_state(&self) -> Option<SavedGlobalState> {
+        log::warn!("TO_SAVED_GLOBAL_STATE: {self:?}");
+
+        Some(SavedGlobalState {
+            session_id: self.session_id.clone()?,
+            current_competitor: self.current_competitor?,
+            penalty: self.penalty.unwrap_or(0),
+            solve_time: self.solve_time?,
+            inspection_time: self
+                .inspection_end
+                .map(|e| (e - self.inspection_start.unwrap_or(Instant::now())).as_millis()),
+        })
+    }
+
+    pub fn parse_saved_state(&mut self, saved: SavedGlobalState) {
+        self.session_id = Some(saved.session_id);
+        self.penalty = Some(saved.penalty);
+        self.solve_time = Some(saved.solve_time);
+        self.current_competitor = Some(saved.current_competitor);
+
+        if let Some(inspection_time) = saved.inspection_time {
+            let now = Instant::now();
+            self.inspection_end = now.checked_add(Duration::from_millis(inspection_time));
+            self.inspection_start = Some(now);
+        }
+
+        if saved.solve_time > 0 {
+            self.scene = Scene::Finished;
+        }
+    }
+}
+
+impl SavedGlobalState {
+    pub async fn from_nvs(nvs: &Nvs) -> Option<Self> {
+        let mut buf = [0; 1024];
+        nvs.get_key(b"SAVED_GLOBAL_STATE", &mut buf).await.ok()?;
+        let end_pos = buf.iter().position(|&x| x == 0x00).unwrap_or(buf.len());
+
+        serde_json::from_slice(&buf[..end_pos]).ok()
+    }
+
+    pub async fn to_nvs(&self, nvs: &Nvs) {
+        let res = serde_json::to_vec(&self);
+        if let Ok(vec) = res {
+            let res = nvs.append_key(b"SAVED_GLOBAL_STATE", &vec).await;
+            if let Err(e) = res {
+                log::error!(
+                    "{e:?} Faile to write to nvs! (SAVED_GLOBAL_STATE {})",
+                    vec.len()
+                );
+            }
+        }
+    }
+
+    pub async fn clear_saved_global_state(nvs: &Nvs) {
+        let res = nvs.invalidate_key(b"SAVED_GLOBAL_STATE").await;
+        if let Err(e) = res {
+            log::error!("{e:?} Faile to invalidate nvs key! (SAVED_GLOBAL_STATE)",);
+        }
     }
 }