new taphold implement, buffering and state

* refactory tap build from pooling event channel to buffer vec
* fix bug for multiple hold key

introduce new featues to timeless HRM

* permissive hold: for same hand hold while release following
  keys
* chordal hold: hold on presss corss hand

TODO

deprecate and remove post wait timeout

Author: hitsmaxft

rmk-config/src/lib.rs

@@ -292,6 +292,8 @@ pub struct BehaviorConfig {
 #[serde(deny_unknown_fields)]
 pub struct TapHoldConfig {
     pub enable_hrm: Option<bool>,
+    pub permissive_hold: Option<bool>,
+    pub chordal_hold: Option<bool>,
     pub prior_idle_time: Option<DurationMillis>,
     pub post_wait_time: Option<DurationMillis>,
     pub hold_timeout: Option<DurationMillis>,

rmk-macro/src/behavior.rs

@@ -48,6 +48,14 @@ fn expand_tap_hold(tap_hold: &Option<TapHoldConfig>) -> proc_macro2::TokenStream
                 Some(enable) => quote! { enable_hrm: #enable, },
                 None => quote! {},
             };
+            let permissive_hold = match tap_hold.permissive_hold{
+                Some(enable) => quote! { permissive_hold: #enable, },
+                None => quote! {},
+            };
+            let chordal_hold = match tap_hold.chordal_hold{
+                Some(enable) => quote! { chordal_hold: #enable, },
+                None => quote! {},
+            };
             let prior_idle_time = match &tap_hold.prior_idle_time {
                 Some(t) => {
                     let timeout = t.0;
@@ -76,6 +84,8 @@ fn expand_tap_hold(tap_hold: &Option<TapHoldConfig>) -> proc_macro2::TokenStream
                     #prior_idle_time
                     #post_wait_time
                     #hold_timeout
+                    #permissive_hold
+                    #chordal_hold
                     ..Default::default()
                 }
             }

rmk/src/config/mod.rs

@@ -12,10 +12,12 @@ use heapless::Vec;
 use macro_config::KeyboardMacrosConfig;
 #[cfg(feature = "_nrf_ble")]
 pub use nrf_config::BleBatteryConfig;
+use num_enum::FromPrimitive;
 
 use crate::combo::Combo;
 use crate::fork::Fork;
 use crate::{COMBO_MAX_NUM, FORK_MAX_NUM};
+use crate::event::KeyEvent;
 
 /// The config struct for RMK keyboard.
 ///
@@ -82,15 +84,54 @@ pub struct TapHoldConfig {
     pub prior_idle_time: Duration,
     pub post_wait_time: Duration,
     pub hold_timeout: Duration,
+    pub permissive_hold: bool,
+    pub chordal_hold: bool,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum ChordHoldHand {
+    Left,
+    Right,
+}
+
+#[derive(Clone, Debug)]
+pub struct ChordHoldState<const COLS: usize> {
+    pub hand: ChordHoldHand,
+}
+
+impl<const COLS: usize> ChordHoldState<COLS> {
+    // is the key event in the same side of current chord hold
+    pub fn is_same(&self, key_event: KeyEvent) -> bool {
+        match self.hand {
+            ChordHoldHand::Left => (key_event.col as usize) < COLS / 2,
+            ChordHoldHand::Right => (key_event.col as usize) >= COLS / 2,
+        }
+    }
+
+    pub(crate) fn create(event: KeyEvent, cols: usize) -> Self {
+        if (event.col as usize) < (cols / 2) {
+            ChordHoldState {
+                hand: ChordHoldHand::Left,
+            }
+        } else {
+            ChordHoldState {
+                hand: ChordHoldHand::Right,
+            }
+        }
+    }
 }
 
 impl Default for TapHoldConfig {
     fn default() -> Self {
         Self {
             enable_hrm: false,
+            permissive_hold: false,
+
             prior_idle_time: Duration::from_millis(120),
             post_wait_time: Duration::from_millis(50),
             hold_timeout: Duration::from_millis(250),
+            chordal_hold: false,
         }
     }
 }
@@ -224,3 +265,66 @@ impl Default for KeyboardUsbConfig<'_> {
         }
     }
 }
+
+mod tests {
+    use super::*;
+    use ChordHoldHand::Left;
+    use ChordHoldHand::Right;
+
+    #[test]
+    fn test_chord_hold() {
+        assert_eq!(
+            ChordHoldState::<6>::create(
+                KeyEvent {
+                    row: 0,
+                    col: 0,
+                    pressed: true,
+                },
+                6
+            )
+            .hand,
+            Left
+        );
+        assert_eq!(
+            ChordHoldState::<6>::create(
+                KeyEvent {
+                    row: 3,
+                    col: 3,
+                    pressed: true,
+                },
+                6
+            )
+            .hand,
+            Right
+        );
+        assert_eq!(
+            ChordHoldState::<6>::create(
+                KeyEvent {
+                    row: 5,
+                    col: 6,
+                    pressed: true,
+                },
+                6
+            )
+            .hand,
+            Right
+        );
+
+        let chord = ChordHoldState::<6> { hand: Left };
+
+        let vec: Vec<_, 6> = Vec::from_slice(&[0u8, 1, 2, 3, 4, 5]).unwrap();
+        let result: Vec<_, 6> = vec
+            .iter()
+            .map(|col| {
+                chord.is_same(KeyEvent {
+                    row: 0,
+                    col: 0 + col,
+                    pressed: true,
+                })
+            })
+            .collect();
+
+        let result2: Vec<bool, 6> = Vec::from_slice(&[true, true, true, false, false, false]).unwrap();
+        assert_eq!(result, result2);
+    }
+}

rmk/src/event.rs

@@ -1,7 +1,10 @@
+use embassy_time::Instant;
 use postcard::experimental::max_size::MaxSize;
 use serde::{Deserialize, Serialize};
 
 use crate::{input_device::rotary_encoder::Direction, keycode::ModifierCombination};
+use crate::action::{KeyAction, Action};
+use crate::keycode::KeyCode::No;
 
 /// Raw events from input devices and keyboards
 ///
@@ -118,3 +121,145 @@ pub enum ControllerEvent {
     /// Split peripheral connection
     SplitPeripheral(u8, bool),
 }
+
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum HoldingKey {
+    // tap hold key
+    TapHold(PressedTapHold),
+    // normal key
+    Tapping(BufferedPressEvent),
+}
+
+pub trait HoldingKeyTrait {
+    fn update_state(&mut self, new_state: TapHoldState);
+    fn press_time(&self) -> Instant;
+    fn state(&self) -> TapHoldState;
+}
+
+impl HoldingKey {
+    pub(crate) fn start_time(&self) -> Instant {
+        match self {
+            HoldingKey::TapHold(h) => h.pressed_time,
+            HoldingKey::Tapping(h) => h.pressed_time,
+        }
+    }
+
+    pub(crate) fn key_event(&self) -> KeyEvent {
+        match self {
+            HoldingKey::TapHold(h) => h.key_event,
+            HoldingKey::Tapping(h) => h.key_event,
+        }
+    }
+
+    pub(crate) fn is_tap_hold(&self) -> bool {
+        matches!(self, HoldingKey::TapHold(_))
+    }
+}
+
+impl HoldingKeyTrait for HoldingKey {
+    fn update_state(&mut self, new_state: TapHoldState) {
+        match self {
+            HoldingKey::TapHold(h) => {
+                h.state = new_state;
+            }
+            HoldingKey::Tapping(t) => {
+                t.state = new_state;
+            }
+        }
+    }
+
+    fn press_time(&self) -> Instant {
+        match self {
+            HoldingKey::TapHold(h) => h.pressed_time,
+            HoldingKey::Tapping(t) => t.pressed_time,
+        }
+    }
+
+    fn state(&self) -> TapHoldState {
+        match self {
+            HoldingKey::TapHold(h) => h.state,
+            HoldingKey::Tapping(t) => t.state,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum TapHoldState {
+    //happen after press event arrives
+    Initial,
+    //tapping event
+    Tap,
+    //release tapping event
+    PostTap,
+    //holding event
+    Hold,
+    //release holding event
+    PostHold,
+    //reserved
+    Release,
+}
+
+// record pressing tap hold keys
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct PressedTapHold {
+    pub key_event: KeyEvent,
+    pub tap_action: Action,
+    pub hold_action: Action,
+    pub pressed_time: Instant,
+    pub deadline: Instant,
+    pub state: TapHoldState,
+}
+
+impl PressedTapHold {
+    const NO: Action = Action::Key(No);
+
+    pub(crate) fn hold_action(&self) -> Action {
+        self.hold_action
+    }
+
+    pub(crate) fn tap_action(&self) -> Action {
+        self.tap_action
+    }
+}
+
+impl HoldingKeyTrait for PressedTapHold {
+    fn update_state(&mut self, new_state: TapHoldState) {
+        self.state = new_state
+    }
+
+    fn press_time(&self) -> Instant {
+        self.pressed_time
+    }
+
+    fn state(&self) -> TapHoldState {
+        self.state
+    }
+}
+
+//buffered pressing key event while TapHolding
+#[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct BufferedPressEvent {
+    pub key_event: KeyEvent,
+    pub key_action: KeyAction,
+    pub pressed_time: Instant,
+    //initial -> tap -> post tap -> release
+    pub state: TapHoldState,
+}
+
+impl HoldingKeyTrait for BufferedPressEvent {
+    fn update_state(&mut self, new_state: TapHoldState) {
+        self.state = new_state
+    }
+
+    fn press_time(&self) -> Instant {
+        self.pressed_time
+    }
+
+    fn state(&self) -> TapHoldState {
+        self.state
+    }
+}