adafruit_seesaw/modules/
keypad.rs1use crate::{
2 devices::SeesawDevice,
3 driver::Driver,
4 modules::{Modules, Reg},
5 DriverExt, SeesawError,
6};
7
8#[allow(dead_code)]
9const STATUS: &Reg = &[Modules::Keypad.into_u8(), 0x00];
10const EVENT: &Reg = &[Modules::Keypad.into_u8(), 0x01];
11const INT_SET: &Reg = &[Modules::Keypad.into_u8(), 0x02];
12const INT_CLR: &Reg = &[Modules::Keypad.into_u8(), 0x03];
13const COUNT: &Reg = &[Modules::Keypad.into_u8(), 0x04];
14const FIFO: &Reg = &[Modules::Keypad.into_u8(), 0x10];
15
16pub trait KeypadModule<D: Driver>: SeesawDevice<Driver = D> {
17 const NUM_COLS: u8;
18 const NUM_ROWS: u8;
19
20 fn num_cols(&self) -> u8 {
21 Self::NUM_COLS
22 }
23
24 fn num_rows(&self) -> u8 {
25 Self::NUM_ROWS
26 }
27
28 fn disable_interrupt(&mut self) -> Result<(), SeesawError<D::Error>> {
29 let addr = self.addr();
30 self.driver()
31 .write_u8(addr, INT_CLR, 1)
32 .map_err(SeesawError::I2c)
33 }
34
35 fn enable_interrupt(&mut self) -> Result<(), SeesawError<D::Error>> {
36 let addr = self.addr();
37 self.driver()
38 .write_u8(addr, INT_SET, 1)
39 .map_err(SeesawError::I2c)
40 }
41
42 fn read_key_events(&mut self) -> Result<KeyEventIter, SeesawError<D::Error>> {
43 let addr = self.addr();
44 let n = self
45 .driver()
46 .read_u8(addr, COUNT)
47 .map_err(SeesawError::I2c)?;
48 if n == 0 {
49 return Ok(KeyEventIter::default());
50 }
51 let events = self
52 .driver()
53 .register_read::<16>(addr, FIFO)
54 .map_err(SeesawError::I2c)?;
55 let mut buf: [Option<KeyEvent>; 16] = [None; 16];
56 for i in 0..n as usize {
57 buf[i] = Some(events[i].into());
58 }
59 Ok(KeyEventIter { buf, curr: 0 })
60 }
61
62 fn set_key_event_triggers(
63 &mut self,
64 x: u8,
65 y: u8,
66 types: &[KeyEventType],
67 enable: bool,
68 ) -> Result<(), SeesawError<D::Error>> {
69 assert!(x < Self::NUM_COLS, "x greater than cols");
70 assert!(y < Self::NUM_ROWS, "y greater than rows");
71 let addr = self.addr();
72 let key = (y << 3) + x;
73 let edges = types.iter().fold(if enable { 1 } else { 0 }, |acc, e| {
74 acc + (2_u8 << (*e as u8))
75 });
76 self.driver()
77 .register_write(addr, EVENT, &[key, edges])
78 .map_err(SeesawError::I2c)
79 }
80}
81
82#[derive(Debug, Default, Clone, Copy)]
83#[cfg_attr(feature = "defmt", derive(defmt::Format))]
84pub struct KeyEventIter {
85 buf: [Option<KeyEvent>; 16],
86 curr: usize,
87}
88
89impl Iterator for KeyEventIter {
90 type Item = KeyEvent;
91
92 fn next(&mut self) -> Option<Self::Item> {
93 if self.curr >= self.buf.len() {
94 return None;
95 }
96 let rec = self.buf[self.curr];
97 self.curr += 1;
98 rec
99 }
100}
101
102#[derive(Debug, Clone, Copy, PartialEq, Eq)]
103#[cfg_attr(feature = "defmt", derive(defmt::Format))]
104#[repr(u8)]
105pub enum KeyEventType {
106 IsPressed = 0,
108 IsReleased = 1,
110 Released = 2,
112 Pressed = 3,
114}
115
116#[derive(Debug, Clone, Copy, PartialEq, Eq)]
117#[cfg_attr(feature = "defmt", derive(defmt::Format))]
118pub struct KeyEvent {
119 pub event: KeyEventType,
120 pub x: u8,
121 pub y: u8,
122}
123
124impl From<u8> for KeyEvent {
125 fn from(value: u8) -> Self {
126 let event = match value & 3 {
127 0 => KeyEventType::IsPressed,
128 1 => KeyEventType::IsReleased,
129 2 => KeyEventType::Released,
130 3 => KeyEventType::Pressed,
131 _ => unreachable!(),
132 };
133 let x = (value >> 2) & 7;
134 let y = (value >> 2) >> 3;
135 Self { event, x, y }
136 }
137}