feat: send test ack with snapshot data

Author: filipton

src/rfid.rs

@@ -150,7 +150,7 @@ pub async fn rfid_task(
         }
 
         #[cfg(feature = "e2e")]
-        crate::ws::send_test_ack().await;
+        crate::ws::send_test_ack(&global_state).await;
 
         #[cfg(not(feature = "e2e"))]
         {

src/stackmat.rs

@@ -204,7 +204,7 @@ pub async fn stackmat_task(
 
                 #[cfg(feature = "e2e")]
                 if send_ack {
-                    crate::ws::send_test_ack().await;
+                    crate::ws::send_test_ack(&global_state).await;
                 }
 
                 global_state.timer_signal.signal(parsed.1);

src/state.rs

@@ -1,11 +1,10 @@
+use crate::{structs::PossibleGroup, utils::signaled_mutex::SignaledMutex};
 use alloc::{rc::Rc, string::String, vec::Vec};
 use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, signal::Signal};
 use embassy_time::{Duration, Instant, Timer};
 use esp_hal_wifimanager::Nvs;
 use serde::{Deserialize, Serialize};
 
-use crate::{structs::PossibleGroup, utils::signaled_mutex::SignaledMutex};
-
 pub static mut EPOCH_BASE: u64 = 0;
 pub static mut SLEEP_STATE: bool = false;
 pub static mut DEEPER_SLEEP: bool = false;
@@ -342,6 +341,26 @@ impl SignaledGlobalStateInner {
             Some(false) => false,
         }
     }
+
+    #[cfg(feature = "e2e")]
+    pub fn snapshot_data(&self) -> crate::structs::SnapshotData {
+        let inspection_time = self
+            .inspection_end
+            .zip(self.inspection_start)
+            .map(|(end, start)| (end - start).as_millis());
+
+        crate::structs::SnapshotData {
+            scene: self.scene.to_index(),
+            inspection_time,
+            penalty: self.penalty,
+            solve_time: self.solve_time,
+            current_judge: self.current_judge,
+            current_competitor: self.current_competitor,
+            group_selected_idx: self.group_selected_idx,
+            time_confirmed: self.time_confirmed,
+            possible_groups: self.possible_groups.len(),
+        }
+    }
 }
 
 #[cfg(not(feature = "e2e"))]

src/structs.rs

@@ -82,12 +82,11 @@ pub enum TimerPacketInner {
         current_epoch: u64,
     },
     // packet for end to end testing
-    //Snapshot(SnapshotData),
     #[cfg(feature = "e2e")]
     TestPacket(TestPacketData),
 
     #[cfg(feature = "e2e")]
-    TestAck,
+    TestAck(SnapshotData),
 }
 
 #[cfg(feature = "e2e")]
@@ -100,7 +99,20 @@ pub enum TestPacketData {
     ButtonPress { pin: u8, press_time: u64 },
     StackmatTime(u64),
     StackmatReset,
-    Snapshot,
+}
+
+#[cfg(feature = "e2e")]
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct SnapshotData {
+    pub scene: usize,
+    pub inspection_time: Option<u64>,
+    pub solve_time: Option<u64>,
+    pub penalty: Option<i8>,
+    pub time_confirmed: bool,
+    pub possible_groups: usize,
+    pub group_selected_idx: usize,
+    pub current_competitor: Option<u64>,
+    pub current_judge: Option<u64>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]

src/utils/buttons.rs

@@ -138,7 +138,7 @@ impl ButtonsHandler {
 
                         #[cfg(feature = "e2e")]
                         if send_ack {
-                            crate::ws::send_test_ack().await;
+                            crate::ws::send_test_ack(&state).await;
                             send_ack = false;
                         }
                     }

src/ws.rs

@@ -384,7 +384,7 @@ async fn parse_test_packet(
                 .stackmat_sig
                 .signal((crate::utils::stackmat::StackmatTimerState::Reset, 0));
 
-            send_test_ack().await;
+            send_test_ack(&global_state).await;
         }
         crate::structs::TestPacketData::HardStateReset => {
             global_state.state.lock().await.hard_state_reset().await;
@@ -406,15 +406,14 @@ async fn parse_test_packet(
                 .stackmat_sig
                 .signal((crate::utils::stackmat::StackmatTimerState::Reset, 0));
         }
-        crate::structs::TestPacketData::Snapshot => todo!(),
     }
 }
 
 #[cfg(feature = "e2e")]
-pub async fn send_test_ack() {
+pub async fn send_test_ack(global_state: &GlobalState) {
     send_packet(TimerPacket {
         tag: None,
-        data: TimerPacketInner::TestAck,
+        data: TimerPacketInner::TestAck(global_state.state.value().await.snapshot_data()),
     })
     .await;
 }