fix: recognize actual button, not wrong one

src/navigation/inputs.rs

@@ -1,3 +1,7 @@
+use embassy_futures::select::select_array;
+use embassy_time::{Duration, Timer};
+use embedded_hal::digital::InputPin;
+use embedded_hal_async::digital::Wait;
 use esp_hal::gpio::Input;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -16,3 +20,62 @@ pub struct Inputs {
     pub back: Input<'static>,
     pub ok: Input<'static>,
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ButtonAction {
+    Up = 0,
+    Down = 1,
+    Left = 2,
+    Right = 3,
+    Ok = 4,
+    Back = 5,
+}
+
+impl Inputs {
+    pub async fn wait_for_press(&mut self) -> ButtonAction {
+        let (_, index) = select_array([
+            wait_for_button(&mut self.up),
+            wait_for_button(&mut self.down),
+            wait_for_button(&mut self.left),
+            wait_for_button(&mut self.right),
+            wait_for_button(&mut self.ok),
+            wait_for_button(&mut self.back),
+        ])
+        .await;
+
+        match index {
+            0 => ButtonAction::Up,
+            1 => ButtonAction::Down,
+            2 => ButtonAction::Left,
+            3 => ButtonAction::Right,
+            4 => ButtonAction::Ok,
+            5 => ButtonAction::Back,
+            id => panic!("Unknown button {id} pressed"),
+        }
+    }
+}
+
+/// Waits for a button press, filtering out fast transients and mechanical bounce.
+async fn wait_for_button<P>(pin: &mut P)
+where
+    P: Wait + InputPin,
+{
+    loop {
+        // 1. Wait for the hardware interrupt (could be a real press or crosstalk)
+        let _ = pin.wait_for_falling_edge().await;
+
+        // 2. Debounce window: let the noise settle
+        Timer::after(Duration::from_millis(30)).await;
+
+        // 3. Verify the pin is still held down
+        // (Adapt unwrap() based on your specific HAL's Error type)
+        if pin.is_low().unwrap_or(false) {
+            // OPTIONAL: Wait for the button to be released before returning
+            // so holding it down doesn't spam triggers.
+            // let _ = pin.wait_for_rising_edge().await;
+            // Timer::after(Duration::from_millis(30)).await;
+
+            return;
+        }
+    }
+}

src/navigation/navigation.rs

@@ -1,13 +1,12 @@
 use crate::card::model::Card;
+use crate::navigation::inputs::ButtonAction;
 use crate::navigation::state::NavigationState;
 use crate::views::view::View;
 use crate::{display::primary_lcd::PrimaryLcdDisplay, navigation::inputs::Inputs};
 
-use embassy_futures::select::{Either, Either6, select};
-use embassy_futures::select::select6;
-use embassy_time::{Duration, Timer};
+use embassy_futures::select::{Either, select};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-
+use embassy_time::{Duration, Timer};
 
 pub type Mutex<T> = embassy_sync::mutex::Mutex<CriticalSectionRawMutex, T>;
 pub type Signal<T> = embassy_sync::signal::Signal<CriticalSectionRawMutex, T>;
@@ -16,12 +15,7 @@ const DEBOUNCE_DURATION_MILLIS: u64 = 100;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Action {
-    Up,
-    Down,
-    Left,
-    Right,
-    Ok,
-    Back,
+    Button(ButtonAction),
     Timer,
 }
 
@@ -40,39 +34,29 @@ pub trait Navigable {
 }
 
 #[embassy_executor::task]
-pub async fn run(mut inputs: Inputs, display: &'static mut PrimaryLcdDisplay<'static>, ) {
+pub async fn run(mut inputs: Inputs, display: &'static mut PrimaryLcdDisplay<'static>) {
     log::info!("starting navigation");
 
     let mut state = NavigationState::new();
     state.screens.last().unwrap().display(display).await;
 
     loop {
-        let selection_buttons = select6(
-            inputs.up.wait_for_low(),
-            inputs.down.wait_for_low(),
-            inputs.left.wait_for_low(),
-            inputs.right.wait_for_low(),
-            inputs.ok.wait_for_low(),
-            inputs.back.wait_for_low(),
-        );
-
-        let selection = select(selection_buttons, Timer::after(Duration::from_millis(DEBOUNCE_DURATION_MILLIS))).await;
+        let selection = select(
+            inputs.wait_for_press(),
+            Timer::after(Duration::from_millis(DEBOUNCE_DURATION_MILLIS)),
+        )
+        .await;
 
         let action = match selection {
-            Either::First(selection_buttons) => match selection_buttons {
-                Either6::First(_) => Action::Up,
-                Either6::Second(_) => Action::Down,
-                Either6::Third(_) => Action::Left,
-                Either6::Fourth(_) => Action::Right,
-                Either6::Fifth(_) => Action::Ok,
-                Either6::Sixth(_) => Action::Back,
-            },
+            Either::First(button) => Action::Button(button),
             Either::Second(_) => Action::Timer,
         };
 
+        if Action::Timer != action {
             log::info!("Action: {:?}", action);
+        }
 
-        let new_state = if action == Action::Back {
+        let new_state = if action == Action::Button(ButtonAction::Back) {
             if state.screens.len() > 1 {
                 state.screens.pop();
             }