feat: ws smart sleep

Author: filipton

Cargo.lock

@@ -99,7 +99,11 @@ async fn room_left(
 ) -> Result<bool, ()> {
     let mut state = state.state.lock().await;
     if state.scene == Scene::RoundSelect {
-        state.round_select = state.round_select.saturating_sub(1);
+        state.round_select = state
+            .round_select
+            .wrapping_sub(1)
+            .min(state.possible_rounds.len() - 1);
+
         return Ok(true);
     }
 
@@ -114,7 +118,11 @@ async fn room_right(
 ) -> Result<bool, ()> {
     let mut state = state.state.lock().await;
     if state.scene == Scene::RoundSelect {
-        state.round_select = (state.round_select + 1).min(state.possible_rounds.len() - 1);
+        state.round_select += 1;
+        if state.round_select == state.possible_rounds.len() {
+            state.round_select = 0;
+        }
+
         return Ok(true);
     }
 

src/buttons.rs

@@ -1,4 +1,4 @@
-pub const SLEEP_AFTER_MS: u64 = 60000;
+pub const SLEEP_AFTER_MS: u64 = 60000 * 5;
 
 pub const LOG_SEND_INTERVAL_MS: u64 = 5000;
 pub const PRINT_HEAP_INTERVAL_MS: u64 = 30000;

src/consts.rs

@@ -277,19 +277,20 @@ async fn process_lcd<T: OutputPin, D: DelayNs>(
                 .ok()?;
         }
         Scene::RoundSelect => {
-            if current_state.round_select > 0 {
-                lcd_driver.print(0, "<", PrintAlign::Left, false).ok()?;
-                lcd_driver.print(1, "<", PrintAlign::Left, false).ok()?;
-            }
-
-            if current_state.round_select < current_state.possible_rounds.len() - 1 {
-                lcd_driver.print(0, ">", PrintAlign::Right, false).ok()?;
-                lcd_driver.print(1, ">", PrintAlign::Right, false).ok()?;
-            }
+            lcd_driver.print(0, "<", PrintAlign::Left, false).ok()?;
+            lcd_driver.print(1, "<", PrintAlign::Left, false).ok()?;
+            lcd_driver.print(0, ">", PrintAlign::Right, false).ok()?;
+            lcd_driver.print(1, ">", PrintAlign::Right, false).ok()?;
 
             lcd_driver
-                .print(0, "Select room", PrintAlign::Center, false)
+                .print(
+                    0,
+                    &get_translation("SELECT_ROUND"),
+                    PrintAlign::Center,
+                    false,
+                )
                 .ok()?;
+
             lcd_driver
                 .print(
                     1,

src/lcd.rs

@@ -286,23 +286,25 @@ async fn main(spawner: Spawner) {
     };
 
     utils::backtrace_store::read_saved_backtrace().await;
+
+    let ws_sleep_sig = Rc::new(Signal::new());
     _ = spawner.spawn(ws::ws_task(
         wifi_res.sta_stack,
         ws_url,
         global_state.clone(),
+        ws_sleep_sig.clone(),
     ));
+    _ = spawner.spawn(logger_task());
 
     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);
     }
-    */
 
     // only mark ota valid after wifi connection!
     {
@@ -314,28 +316,32 @@ async fn main(spawner: Spawner) {
         }
     }
 
-    log::info!("main loop enter");
-    let mut heap_start = Instant::now();
     let mut last_sleep = false;
+    loop {
+        Timer::after_millis(100).await;
+        if sleep_state() != last_sleep {
+            last_sleep = sleep_state();
+            ws_sleep_sig.signal(last_sleep);
+
+            match last_sleep {
+                true => wifi_res.stop_radio(),
+                false => wifi_res.restart_radio(),
+            }
+        }
+    }
+}
+
+#[embassy_executor::task]
+async fn logger_task() {
+    let mut heap_start = Instant::now();
     loop {
         Timer::after_millis(LOG_SEND_INTERVAL_MS).await;
 
-        // TODO: move to own task
         let mut tmp_logs: Vec<String> = Vec::new();
         while let Ok(msg) = utils::logger::LOGS_CHANNEL.try_receive() {
             tmp_logs.push(msg);
         }
 
-        if sleep_state() && !last_sleep {
-            wifi_res.disc.signal(true);
-            last_sleep = true;
-        }
-
-        if !sleep_state() && last_sleep {
-            wifi_res.disc.signal(false);
-            last_sleep = false;
-        }
-
         if ota_state() || sleep_state() {
             continue;
         }

src/main.rs

@@ -76,15 +76,16 @@ pub async fn rfid_task(
     let mut rfid_sleep = false;
     loop {
         Timer::after(Duration::from_millis(10)).await;
-        if sleep_state() && !rfid_sleep {
-            _ = mfrc522.pcd_soft_power_down().await;
-            rfid_sleep = true;
-        } else if !sleep_state() && rfid_sleep {
-            _ = mfrc522.pcd_soft_power_up().await;
-            rfid_sleep = false;
+        if sleep_state() != rfid_sleep {
+            rfid_sleep = sleep_state();
+
+            match rfid_sleep {
+                true => _ = mfrc522.pcd_soft_power_down().await,
+                false => _ = mfrc522.pcd_soft_power_up().await,
+            }
         }
 
-        if sleep_state() && rfid_sleep {
+        if rfid_sleep {
             Timer::after(Duration::from_millis(500)).await;
             continue;
         }

src/rfid.rs

@@ -36,6 +36,8 @@ pub fn init_translations() {
             "of a competitor ({0})",
         ));
 
+        t.push(TranslationRecord::new("SELECT_ROUND", "Select round"));
+
         t.push(TranslationRecord::new("CONFIRM_TIME", "Confirm the time"));
         t.push(TranslationRecord::new(
             "SCAN_JUDGE_CARD",

src/translations.rs

@@ -3,11 +3,12 @@ use crate::{
     state::{GlobalState, Scene},
     structs::{ApiError, FromPacket, TimerPacket, TimerPacketInner},
 };
-use alloc::string::String;
+use alloc::{rc::Rc, string::String};
 use core::str::FromStr;
 use embassy_net::{tcp::TcpSocket, IpAddress, Stack};
 use embassy_sync::{
     blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel, pubsub::PubSubChannel,
+    signal::Signal,
 };
 use embassy_time::{Instant, Timer};
 use embedded_io_async::Write;
@@ -22,7 +23,12 @@ static TAGGED_RETURN: PubSubChannel<CriticalSectionRawMutex, (u64, TimerPacket),
     PubSubChannel::new();
 
 #[embassy_executor::task]
-pub async fn ws_task(stack: Stack<'static>, ws_url: String, global_state: GlobalState) {
+pub async fn ws_task(
+    stack: Stack<'static>,
+    ws_url: String,
+    global_state: GlobalState,
+    ws_sleep_sig: Rc<Signal<CriticalSectionRawMutex, bool>>,
+) {
     let ws_url = WsUrl::from_str(&ws_url).expect("Ws url parse error");
 
     let mut rx_buf = [0; 8192];
@@ -41,7 +47,7 @@ pub async fn ws_task(stack: Stack<'static>, ws_url: String, global_state: Global
     }
 
     loop {
-        let res = ws_loop(
+        let ws_fut = ws_loop(
             &global_state,
             &ws_url,
             stack,
@@ -51,11 +57,26 @@ pub async fn ws_task(stack: Stack<'static>, ws_url: String, global_state: Global
             &mut ws_tx_buf,
             &mut ssl_rx_buf,
             &mut ssl_tx_buf,
-        )
-        .await;
+        );
+
+        let res = embassy_futures::select::select(ws_fut, ws_sleep_sig.wait()).await;
 
-        if let Err(e) = res {
-            log::error!("Ws_loop errored! {e:?}");
+        match res {
+            embassy_futures::select::Either::First(res) => {
+                if let Err(e) = res {
+                    log::error!("Ws_loop errored! {e:?}");
+                }
+            }
+            embassy_futures::select::Either::Second(sleep) => {
+                if sleep {
+                    loop {
+                        let sleep = ws_sleep_sig.wait().await;
+                        if !sleep {
+                            break;
+                        }
+                    }
+                }
+            }
         }
 
         Timer::after_millis(500).await;
@@ -105,8 +126,6 @@ async fn ws_loop(
             *addr
         };
 
-        Timer::after_millis(10000000).await;
-        continue;
         let mut socket = TcpSocket::new(stack, rx_buf, tx_buf);
         socket.set_timeout(Some(embassy_time::Duration::from_secs(15)));