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}