feat: use ag-lcd fork with async support fix: decrease button debounce time fix: ms time to str above 9 minutes 59seconds

Author: filipton

Cargo.lock

@@ -44,15 +44,15 @@ anyhow = { version = "1.0.97", default-features = false }
 embedded-hal-bus = { version = "0.3.0", features = ["async"] }
 embedded-tls = { version = "0.17.0", default-features = false, features = ["alloc", "embedded-io-adapters", "log"] }
 rand_core = { version = "0.6.4", features = ["getrandom"] }
-ag-lcd = { version = "0.3.0", features = [] }
+ag-lcd-async = { git = "https://github.com/filipton/ag-lcd-async", features = [] }
 port-expander = { version = "0.6.4", optional = true }
 
 mfrc522-01 = { version = "0.1.1", package = "esp-hal-mfrc522", optional = true }
 mfrc522-02 = { version = "0.2.1", features = ["embassy-time"], package = "esp-hal-mfrc522", optional = true }
 
 [features]
 default = ["esp32c3", "sleep"]
-esp32 = ["esp-backtrace/esp32", "esp-hal/esp32", "esp-println/esp32", "esp-wifi/esp32", "esp-hal-embassy/esp32", "esp-storage/esp32", "esp-hal-wifimanager/esp32", "esp-hal-ota/esp32", "dep:esp32", "dep:mfrc522-01", "dep:port-expander", "ag-lcd/i2c"]
+esp32 = ["esp-backtrace/esp32", "esp-hal/esp32", "esp-println/esp32", "esp-wifi/esp32", "esp-hal-embassy/esp32", "esp-storage/esp32", "esp-hal-wifimanager/esp32", "esp-hal-ota/esp32", "dep:esp32", "dep:mfrc522-01", "dep:port-expander", "ag-lcd-async/i2c"]
 esp32c3 = ["esp-backtrace/esp32c3", "esp-hal/esp32c3", "esp-println/esp32c3", "esp-wifi/esp32c3", "esp-hal-embassy/esp32c3", "esp-storage/esp32c3", "esp-hal-wifimanager/esp32c3", "esp-hal-ota/esp32c3", "dep:esp32c3", "dep:mfrc522-02"]
 gen_version = []
 bat_dev_lcd = []

Cargo.toml

@@ -8,6 +8,8 @@ pub const SLEEP_AFTER_MS: u64 = 60000 * 9999;
 #[cfg(not(feature = "sleep"))]
 pub const DEEPER_SLEEP_AFTER_MS: u64 = 60000 * 99999;
 
+pub const BUTTON_DEBOUNCE_TIME: u64 = 25;
+
 pub const LOG_SEND_INTERVAL_MS: u64 = 5000;
 pub const PRINT_HEAP_INTERVAL_MS: u64 = 30000;
 

src/consts.rs

@@ -1,9 +1,10 @@
 use adv_shift_registers::wrappers::ShifterValueRange;
-use ag_lcd::LcdDisplay;
+use ag_lcd_async::LcdDisplay;
 use alloc::{rc::Rc, string::ToString};
 use embassy_sync::{blocking_mutex::raw::NoopRawMutex, signal::Signal};
 use embassy_time::{Delay, Duration, Instant, Timer};
-use embedded_hal::{delay::DelayNs, digital::OutputPin};
+use embedded_hal::digital::OutputPin;
+use embedded_hal_async::delay::DelayNs;
 
 use crate::{
     consts::{
@@ -33,13 +34,14 @@ pub async fn lcd_task(
 
     #[cfg(feature = "esp32")]
     let mut lcd = LcdDisplay::new_pcf8574(&mut i2c_expander, Delay)
-        .with_display(ag_lcd::Display::On)
-        .with_blink(ag_lcd::Blink::Off)
-        .with_cursor(ag_lcd::Cursor::Off)
-        .with_size(ag_lcd::Size::Dots5x8)
+        .with_display(ag_lcd_async::Display::On)
+        .with_blink(ag_lcd_async::Blink::Off)
+        .with_cursor(ag_lcd_async::Cursor::Off)
+        .with_size(ag_lcd_async::Size::Dots5x8)
         .with_cols(16)
-        .with_lines(ag_lcd::Lines::TwoLines)
-        .build();
+        .with_lines(ag_lcd_async::Lines::TwoLines)
+        .build()
+        .await;
 
     #[cfg(feature = "esp32c3")]
     let mut lcd = {
@@ -50,19 +52,20 @@ pub async fn lcd_task(
         let d5_pin = lcd_shifter.get_pin_mut(5, false);
         let d6_pin = lcd_shifter.get_pin_mut(6, false);
         let d7_pin = lcd_shifter.get_pin_mut(7, false);
-        ag_lcd::LcdDisplay::new(rs_pin, en_pin, Delay)
-            .with_display(ag_lcd::Display::On)
-            .with_blink(ag_lcd::Blink::Off)
-            .with_cursor(ag_lcd::Cursor::Off)
-            .with_size(ag_lcd::Size::Dots5x8)
+        LcdDisplay::new(rs_pin, en_pin, Delay)
+            .with_display(ag_lcd_async::Display::On)
+            .with_blink(ag_lcd_async::Blink::Off)
+            .with_cursor(ag_lcd_async::Cursor::Off)
+            .with_size(ag_lcd_async::Size::Dots5x8)
             .with_cols(16)
-            .with_lines(ag_lcd::Lines::TwoLines)
+            .with_lines(ag_lcd_async::Lines::TwoLines)
             .with_half_bus(d4_pin, d5_pin, d6_pin, d7_pin)
             .with_backlight(bl_pin)
             .build()
+            .await
     };
 
-    lcd.clear();
+    lcd.clear().await;
     lcd.backlight_on();
 
     let mut lcd_driver: LcdAbstract<80, 16, 2, 3> = LcdAbstract::new();
@@ -79,15 +82,15 @@ pub async fn lcd_task(
         PrintAlign::Left,
         true,
     );
-    lcd_driver.display_on_lcd(&mut lcd);
+    lcd_driver.display_on_lcd(&mut lcd).await;
 
     _ = lcd_driver.print(
         0,
         &alloc::format!("{}%", global_state.show_battery.wait().await),
         PrintAlign::Right,
         false,
     );
-    lcd_driver.display_on_lcd(&mut lcd);
+    lcd_driver.display_on_lcd(&mut lcd).await;
 
     #[cfg(not(feature = "bat_dev_lcd"))]
     Timer::after_millis(2500).await;
@@ -118,15 +121,15 @@ pub async fn lcd_task(
                 &display,
             )
             .await;
-            lcd_driver.display_on_lcd(&mut lcd);
+            lcd_driver.display_on_lcd(&mut lcd).await;
 
             let mut scroll_ticker =
                 embassy_time::Ticker::every(Duration::from_millis(SCROLL_TICKER_INVERVAL_MS));
             loop {
                 scroll_ticker.next().await;
                 let changed = lcd_driver.scroll_step();
                 if changed.is_ok_and(|c| c) {
-                    lcd_driver.display_on_lcd(&mut lcd);
+                    lcd_driver.display_on_lcd(&mut lcd).await;
                 }
 
                 #[cfg(not(any(feature = "e2e", feature = "qa")))]
@@ -136,7 +139,7 @@ pub async fn lcd_task(
                 {
                     _ = lcd_driver.print(0, "Sleep", PrintAlign::Center, true);
                     _ = lcd_driver.print(1, "Press any key", PrintAlign::Center, true);
-                    lcd_driver.display_on_lcd(&mut lcd);
+                    lcd_driver.display_on_lcd(&mut lcd).await;
                     lcd.backlight_off();
 
                     unsafe {
@@ -151,7 +154,7 @@ pub async fn lcd_task(
                 {
                     _ = lcd_driver.print(0, "Deep Sleep", PrintAlign::Center, true);
                     _ = lcd_driver.print(1, "Press any key", PrintAlign::Center, true);
-                    lcd_driver.display_on_lcd(&mut lcd);
+                    lcd_driver.display_on_lcd(&mut lcd).await;
                     crate::utils::deeper_sleep();
                 }
             }
@@ -286,7 +289,7 @@ async fn process_lcd<T: OutputPin, D: DelayNs>(
                 )
                 .ok()?;
 
-            lcd_driver.display_on_lcd(lcd);
+            lcd_driver.display_on_lcd(lcd).await;
             wifi_setup_sig.wait().await;
             global_state.state.lock().await.scene = Scene::AutoSetupWait;
         }
@@ -408,6 +411,10 @@ async fn process_lcd<T: OutputPin, D: DelayNs>(
                 .inspection_start
                 .unwrap_or(Instant::now());
 
+            lcd_driver
+                .print(1, "Inspection", PrintAlign::Center, true)
+                .ok()?;
+
             loop {
                 let elapsed = (Instant::now() - inspection_start).as_millis();
                 let time_str = ms_to_time_str(elapsed);
@@ -416,7 +423,7 @@ async fn process_lcd<T: OutputPin, D: DelayNs>(
                     .print(0, &time_str, PrintAlign::Center, true)
                     .ok()?;
 
-                lcd_driver.display_on_lcd(lcd);
+                lcd_driver.display_on_lcd(lcd).await;
                 Timer::after_millis(LCD_INSPECTION_FRAME_TIME).await;
             }
         }
@@ -428,7 +435,7 @@ async fn process_lcd<T: OutputPin, D: DelayNs>(
                 .ok()?;
 
             display.set_data_raw(&crate::utils::stackmat::time_str_to_display(&time_str));
-            lcd_driver.display_on_lcd(lcd);
+            lcd_driver.display_on_lcd(lcd).await;
         },
         Scene::Finished => {
             let solve_time = current_state.solve_time.unwrap_or(0);
@@ -513,7 +520,7 @@ async fn process_lcd<T: OutputPin, D: DelayNs>(
                 let progress = global_state.update_progress.wait().await;
                 _ = lcd_driver.print(1, &alloc::format!("{progress}%"), PrintAlign::Center, true);
 
-                lcd_driver.display_on_lcd(lcd);
+                lcd_driver.display_on_lcd(lcd).await;
             }
         }
     }

src/lcd.rs

@@ -59,12 +59,12 @@ async fn main(spawner: Spawner) {
 
         #[cfg(feature = "esp32")]
         {
-            config = config.with_cpu_clock(esp_hal::clock::CpuClock::max());
+            config = config.with_cpu_clock(esp_hal::clock::CpuClock::_80MHz);
         }
 
         #[cfg(feature = "esp32c3")]
         {
-            config = config.with_cpu_clock(esp_hal::clock::CpuClock::max());
+            config = config.with_cpu_clock(esp_hal::clock::CpuClock::_80MHz);
         }
 
         config

src/main.rs

@@ -1,6 +1,9 @@
 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_sync::{
+    blocking_mutex::raw::{CriticalSectionRawMutex, NoopRawMutex},
+    signal::Signal,
+};
 use embassy_time::{Duration, Instant, Timer};
 use esp_hal_wifimanager::Nvs;
 use serde::{Deserialize, Serialize};
@@ -118,7 +121,7 @@ impl End2End {
 pub type GlobalState = Rc<GlobalStateInner>;
 pub struct GlobalStateInner {
     pub state: SignaledMutex<CriticalSectionRawMutex, SignaledGlobalStateInner>,
-    pub timer_signal: Signal<CriticalSectionRawMutex, u64>,
+    pub timer_signal: Signal<NoopRawMutex, u64>,
     pub show_battery: Signal<CriticalSectionRawMutex, u8>,
     pub update_progress: Signal<CriticalSectionRawMutex, u8>,
 

src/state.rs

@@ -1,5 +1,6 @@
 use crate::{
     buttons::HandlersDerive,
+    consts::BUTTON_DEBOUNCE_TIME,
     state::{sleep_state, GlobalState},
 };
 use alloc::vec::Vec;
@@ -133,7 +134,7 @@ impl ButtonsHandler {
                 debounce_time = esp_hal::time::Instant::now();
             } else if old_debounced != out_val {
                 let duration = esp_hal::time::Instant::now() - debounce_time;
-                if duration.as_millis() > 50 || sleep_state() {
+                if duration.as_millis() > BUTTON_DEBOUNCE_TIME || sleep_state() {
                     if old_debounced == 0 {
                         #[cfg(not(feature = "qa"))]
                         self.button_down((out_val as u8).into(), state).await;

src/utils/buttons.rs

@@ -1,5 +1,6 @@
-use ag_lcd::LcdDisplay;
-use embedded_hal::{delay::DelayNs, digital::OutputPin};
+use ag_lcd_async::LcdDisplay;
+use embedded_hal::digital::OutputPin;
+use embedded_hal_async::delay::DelayNs;
 
 pub enum PrintAlign {
     Left,
@@ -151,12 +152,13 @@ impl<const LINE_SIZE: usize, const X: usize, const Y: usize, const SCROLLER_WT:
         Ok(())
     }
 
-    pub fn display_on_lcd<T: OutputPin, D: DelayNs>(&mut self, lcd: &mut LcdDisplay<T, D>) {
+    pub async fn display_on_lcd<T: OutputPin, D: DelayNs>(&mut self, lcd: &mut LcdDisplay<T, D>) {
         let display_data = self.display_data();
         for (y, line) in display_data.0.iter().enumerate() {
             if line.1 {
-                lcd.set_position(0, y as u8);
-                lcd.print(unsafe { core::str::from_utf8_unchecked(line.0) });
+                lcd.set_position(0, y as u8).await;
+                lcd.print(unsafe { core::str::from_utf8_unchecked(line.0) })
+                    .await;
 
                 display_data.1[y].copy_from_slice(line.0);
             }

src/utils/lcd_abstract.rs

@@ -103,16 +103,14 @@ pub fn time_str_to_display(time: &str) -> [u8; 6] {
     data
 }
 
-pub fn ms_to_time_str(ms: u64) -> heapless::String<8> {
+pub fn ms_to_time_str(ms: u64) -> heapless::String<12> {
     let minutes: u8 = (ms / 60000) as u8;
     let seconds: u8 = ((ms % 60000) / 1000) as u8;
     let ms: u16 = (ms % 1000) as u16;
 
-    let mut time_str = heapless::String::<8>::new();
+    let mut time_str = heapless::String::<12>::new();
     if minutes > 0 {
-        _ = time_str.push((minutes + b'0') as char);
-        _ = time_str.push(':');
-        _ = time_str.push_str(&alloc::format!("{seconds:02}.{ms:03}"));
+        _ = time_str.push_str(&alloc::format!("{minutes}:{seconds:02}.{ms:03}"));
     } else {
         _ = time_str.push_str(&alloc::format!("{seconds:01}.{ms:03}"));
     }