wip: smart sleep on all peripherals

Author: filipton

src/battery.rs

@@ -1,4 +1,6 @@
-use crate::{consts::BATTERY_SEND_INTERVAL_MS, utils::rolling_average::RollingAverage};
+use crate::{
+    consts::BATTERY_SEND_INTERVAL_MS, state::sleep_state, utils::rolling_average::RollingAverage,
+};
 use embassy_time::{Instant, Timer};
 use esp_hal::{
     analog::adc::{Adc, AdcConfig, Attenuation},
@@ -54,6 +56,11 @@ pub async fn battery_read_task(
 
     loop {
         Timer::after_millis(100).await;
+        if sleep_state() {
+            Timer::after_millis(500).await;
+            continue;
+        }
+
         let read = macros::nb_to_fut!(adc.read_oneshot(&mut adc_pin))
             .await
             .unwrap_or(0);

src/consts.rs

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

src/lcd.rs

@@ -5,7 +5,9 @@ use embassy_time::{Delay, Duration, Instant, Timer};
 use embedded_hal::{delay::DelayNs, digital::OutputPin};
 
 use crate::{
-    consts::{INSPECTION_TIME_PLUS2, LCD_INSPECTION_FRAME_TIME, SCROLL_TICKER_INVERVAL_MS},
+    consts::{
+        INSPECTION_TIME_PLUS2, LCD_INSPECTION_FRAME_TIME, SCROLL_TICKER_INVERVAL_MS, SLEEP_AFTER_MS,
+    },
     state::{sleep_state, GlobalState, Scene, SignaledGlobalStateInner},
     translations::{get_translation, get_translation_params},
     utils::{
@@ -122,7 +124,7 @@ pub async fn lcd_task(
                     lcd_driver.display_on_lcd(&mut lcd).unwrap();
                 }
 
-                if !sleep_state() && (Instant::now() - last_update).as_secs() > 60 * 5 {
+                if !sleep_state() && (Instant::now() - last_update).as_millis() > SLEEP_AFTER_MS {
                     lcd.backlight_off();
 
                     unsafe {

src/main.rs

@@ -17,7 +17,7 @@ use esp_hal::{
     timer::timg::TimerGroup,
 };
 use esp_storage::FlashStorage;
-use state::{ota_state, GlobalStateInner, SavedGlobalState, Scene};
+use state::{ota_state, sleep_state, GlobalStateInner, SavedGlobalState, Scene};
 use structs::ConnSettings;
 use translations::init_translations;
 use utils::{logger::FkmLogger, set_brownout_detection};
@@ -294,13 +294,15 @@ 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);
     }
+    */
 
     // only mark ota valid after wifi connection!
     {
@@ -312,7 +314,9 @@ 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(LOG_SEND_INTERVAL_MS).await;
 
@@ -322,7 +326,17 @@ async fn main(spawner: Spawner) {
             tmp_logs.push(msg);
         }
 
-        if ota_state() {
+        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/rfid.rs

@@ -1,5 +1,5 @@
 use crate::consts::RFID_RETRY_INIT_MS;
-use crate::state::{current_epoch, GlobalState};
+use crate::state::{current_epoch, sleep_state, GlobalState};
 use crate::structs::{CardInfoResponsePacket, SolveConfirmPacket};
 use alloc::string::ToString;
 use anyhow::{anyhow, Result};
@@ -73,8 +73,22 @@ pub async fn rfid_task(
 
     log::debug!("PCD ver: {:?}", mfrc522.pcd_get_version().await);
 
+    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 {
+            Timer::after(Duration::from_millis(500)).await;
+            continue;
+        }
+
         if mfrc522.picc_is_new_card_present().await.is_err() {
             continue;
         }

src/stackmat.rs

@@ -1,6 +1,6 @@
 use crate::{
     consts::{INSPECTION_TIME_DNF, INSPECTION_TIME_PLUS2},
-    state::{GlobalState, Scene},
+    state::{sleep_state, GlobalState, Scene},
     utils::stackmat::{
         ms_to_time_str, parse_stackmat_data, time_str_to_display, StackmatTimerState,
     },
@@ -26,6 +26,11 @@ pub async fn stackmat_task(
     let mut last_state = None;
     let mut last_stackmat_state = StackmatTimerState::Unknown;
     loop {
+        if sleep_state() {
+            Timer::after_millis(500).await;
+            continue;
+        }
+
         if (esp_hal::time::now() - last_read).to_millis() > 500 && last_state != Some(false) {
             global_state.state.lock().await.stackmat_connected = Some(false);
             last_state = Some(false);

src/utils/logger.rs

@@ -1,4 +1,4 @@
-use crate::state::ota_state;
+use crate::state::{ota_state, sleep_state};
 use alloc::string::String;
 use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel};
 
@@ -52,7 +52,7 @@ impl log::Log for FkmLogger {
         esp_println::println!("{}{} - {}{}", color, record.level(), record.args(), reset);
 
         #[cfg(not(feature = "bat_dev_lcd"))]
-        if !ota_state() {
+        if !ota_state() && !sleep_state() {
             if LOGS_CHANNEL.is_full() {
                 _ = LOGS_CHANNEL.try_receive();
             }

src/ws.rs

@@ -105,6 +105,8 @@ 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)));