Updated to use ringbuf and an event callback.

Author: joshua-beck-0908

ports/espressif/boards/m5stack_cardputer/board.c

@@ -26,7 +26,7 @@
 
 #include "keymap.h"
 #include "supervisor/board.h"
-#include "supervisor/serial.h"
+#include "supervisor/shared/serial.h"
 #include "mpconfigboard.h"
 #include "shared-bindings/busio/SPI.h"
 #include "shared-bindings/fourwire/FourWire.h"
@@ -39,13 +39,14 @@
 #include "shared-bindings/keypad/Event.h"
 #include "supervisor/shared/reload.h"
 #include "py/runtime.h"
+#include "py/ringbuf.h"
+#include "shared/runtime/interrupt_char.h"
 
 fourwire_fourwire_obj_t board_display_obj;
 keypad_demux_demuxkeymatrix_obj_t board_keyboard;
 
-void update_keyboard(void);
-void queue_key(char c);
-void queue_seq(const char *seq);
+void update_keyboard(keypad_eventqueue_obj_t *queue);
+void keyboard_seq(const char *seq);
 
 const mcu_pin_obj_t *row_addr_pins[] = {
     &pin_GPIO8,
@@ -66,9 +67,8 @@ const mcu_pin_obj_t *column_pins[] = {
 keypad_event_obj_t event;
 
 char keystate[56];
-char keyqueue[16];
-int keyqueue_head = 0;
-int keyqueue_tail = 0;
+ringbuf_t keyqueue;
+char keybuf[32];
 
 #define DELAY 0x80
 
@@ -144,6 +144,7 @@ void board_init(void) {
 }
 
 void board_serial_init() {
+    ringbuf_init(&keyqueue, (uint8_t *)keybuf, sizeof(keybuf));
     common_hal_keypad_demux_demuxkeymatrix_construct(
         &board_keyboard,     // self
         3,     // num_row_addr_pins
@@ -155,42 +156,32 @@ void board_serial_init() {
         2     // debounce_threshold
         );
     demuxkeymatrix_never_reset(&board_keyboard);
+    common_hal_keypad_eventqueue_set_event_handler(board_keyboard.events, update_keyboard);
+
 }
 
 bool board_serial_connected() {
     return true;
 }
 
-bool board_serial_bytes_available() {
-    update_keyboard();
-    if (keyqueue_head != keyqueue_tail) {
-        return true;
-    } else {
-        return false;
-    }
-}
-
-void queue_key(char c) {
-    if ((keyqueue_head + 1) % 16 != keyqueue_tail) {
-        keyqueue[keyqueue_head] = c;
-        keyqueue_head = (keyqueue_head + 1) % 16;
-    }
+uint32_t board_serial_bytes_available() {
+    return ringbuf_num_filled(&keyqueue);
 }
 
-void queue_seq(const char *seq) {
+void keyboard_seq(const char *seq) {
     while (*seq) {
-        queue_key(*seq++);
+        ringbuf_put(&keyqueue, *seq++);
     }
 }
 
-void update_keyboard() {
-    char ascii = 0;
+void update_keyboard(keypad_eventqueue_obj_t *queue) {
+    uint8_t ascii = 0;
 
-    if (common_hal_keypad_eventqueue_get_length(board_keyboard.events) == 0) {
+    if (common_hal_keypad_eventqueue_get_length(queue) == 0) {
         return;
     }
 
-    while (common_hal_keypad_eventqueue_get_into(board_keyboard.events, &event)) {
+    while (common_hal_keypad_eventqueue_get_into(queue, &event)) {
         if (event.pressed) {
             keystate[event.key_number] = 1;
 
@@ -202,27 +193,31 @@ void update_keyboard() {
                 if (ascii >= 'a' && ascii <= 'z') {
                     ascii -= 'a' - 1;
                 }
+
+                if (ascii == mp_interrupt_char) {
+                    mp_sched_keyboard_interrupt();
+                }
             } else if (keystate[KEY_SHIFT]) {
                 ascii = keymap_shifted[event.key_number];
             } else if (keystate[KEY_FN] && event.key_number != KEY_FN) {
                 switch (event.key_number | FN_MOD) {
                     case KEY_DOWN:
-                        queue_seq("\e[B");
+                        keyboard_seq("\e[B");
                         break;
                     case KEY_UP:
-                        queue_seq("\e[A");
+                        keyboard_seq("\e[A");
                         break;
                     case KEY_DELETE:
-                        queue_seq("\e[3~");
+                        keyboard_seq("\e[3~");
                         break;
                     case KEY_LEFT:
-                        queue_seq("\e[D");
+                        keyboard_seq("\e[D");
                         break;
                     case KEY_RIGHT:
-                        queue_seq("\e[C");
+                        keyboard_seq("\e[C");
                         break;
                     case KEY_ESC:
-                        queue_key('\e');
+                        ringbuf_put(&keyqueue, '\e');
                         break;
                 }
             } else {
@@ -231,9 +226,9 @@ void update_keyboard() {
 
             if (ascii > 0) {
                 if (keystate[KEY_ALT]) {
-                    queue_key('\e');
+                    ringbuf_put(&keyqueue, '\e');
                 }
-                queue_key(ascii);
+                ringbuf_put(&keyqueue, ascii);
             }
 
         } else {
@@ -243,14 +238,7 @@ void update_keyboard() {
 }
 
 char board_serial_read() {
-    update_keyboard();
-    if (keyqueue_head != keyqueue_tail) {
-        char c = keyqueue[keyqueue_tail];
-        keyqueue_tail = (keyqueue_tail + 1) % 16;
-        return c;
-    } else {
-        return -1;
-    }
+    return ringbuf_get(&keyqueue);
 }
 
 // Use the MP_WEAK supervisor/shared/board.c versions of routines not defined here.

ports/espressif/boards/m5stack_cardputer/keymap.h

@@ -173,8 +173,8 @@ int keymap_shifted[56] = {
     '%', // KEY_5 -> '%'
     '&', // KEY_7 -> '&'
     '(', // KEY_9 -> '('
-    '_', // KEY_UNDERSCORE -> '-'
-    '\x7F',// KEY_BACKSPACE
+    '-', // KEY_UNDERSCORE -> '-'
+    '\b',// KEY_BACKSPACE
     0,   // KEY_CTRL
     0,   // KEY_ALT
     'X', // KEY_X

shared-bindings/keypad/EventQueue.h

@@ -42,4 +42,6 @@ bool common_hal_keypad_eventqueue_get_into(keypad_eventqueue_obj_t *self, keypad
 bool common_hal_keypad_eventqueue_get_overflowed(keypad_eventqueue_obj_t *self);
 void common_hal_keypad_eventqueue_set_overflowed(keypad_eventqueue_obj_t *self, bool overflowed);
 
+void common_hal_keypad_eventqueue_set_event_handler(keypad_eventqueue_obj_t *self, void (*event_handler)(keypad_eventqueue_obj_t *));
+
 #endif  // MICROPY_INCLUDED_SHARED_BINDINGS_KEYPAD_EVENTQUEUE_H

shared-module/keypad/EventQueue.c

@@ -37,6 +37,7 @@ void common_hal_keypad_eventqueue_construct(keypad_eventqueue_obj_t *self, size_
     // Event queue is 16-bit values.
     ringbuf_alloc(&self->encoded_events, max_events * (sizeof(uint16_t) + sizeof(mp_obj_t)));
     self->overflowed = false;
+    self->event_handler = NULL;
 }
 
 bool common_hal_keypad_eventqueue_get_into(keypad_eventqueue_obj_t *self, keypad_event_obj_t *event) {
@@ -79,6 +80,10 @@ size_t common_hal_keypad_eventqueue_get_length(keypad_eventqueue_obj_t *self) {
     return ringbuf_num_filled(&self->encoded_events);
 }
 
+void common_hal_keypad_eventqueue_set_event_handler(keypad_eventqueue_obj_t *self, void (*event_handler)(keypad_eventqueue_obj_t *)) {
+    self->event_handler = event_handler;
+}
+
 bool keypad_eventqueue_record(keypad_eventqueue_obj_t *self, mp_uint_t key_number, bool pressed, mp_obj_t timestamp) {
     if (ringbuf_num_empty(&self->encoded_events) == 0) {
         // Queue is full. Set the overflow flag. The caller will decide what else to do.
@@ -93,5 +98,9 @@ bool keypad_eventqueue_record(keypad_eventqueue_obj_t *self, mp_uint_t key_numbe
     ringbuf_put16(&self->encoded_events, encoded_event);
     ringbuf_put_n(&self->encoded_events, (uint8_t *)&timestamp, sizeof(mp_obj_t));
 
+    if (self->event_handler) {
+        self->event_handler(self);
+    }
+
     return true;
 }

shared-module/keypad/EventQueue.h

@@ -30,11 +30,14 @@
 #include "py/obj.h"
 #include "py/ringbuf.h"
 
-typedef struct _keypad_eventqueue_obj_t {
+typedef struct _keypad_eventqueue_obj_t keypad_eventqueue_obj_t;
+
+struct _keypad_eventqueue_obj_t {
     mp_obj_base_t base;
     ringbuf_t encoded_events;
     bool overflowed;
-} keypad_eventqueue_obj_t;
+    void (*event_handler)(keypad_eventqueue_obj_t *);
+};
 
 bool keypad_eventqueue_record(keypad_eventqueue_obj_t *self, mp_uint_t key_number, bool pressed, mp_obj_t timestamp);
 

supervisor/shared/serial.c

@@ -121,7 +121,7 @@ MP_WEAK char board_serial_read(void) {
     return -1;
 }
 
-MP_WEAK bool board_serial_bytes_available(void) {
+MP_WEAK uint32_t board_serial_bytes_available(void) {
     return false;
 }
 
@@ -330,6 +330,9 @@ uint32_t serial_bytes_available(void) {
     count += tud_cdc_available();
     #endif
 
+    // Board-specific serial input.
+    count += board_serial_bytes_available();
+
     // Port-specific serial input.
     count += port_serial_bytes_available();
 

supervisor/shared/serial.h

@@ -65,7 +65,7 @@ void board_serial_early_init(void);
 void board_serial_init(void);
 bool board_serial_connected(void);
 char board_serial_read(void);
-bool board_serial_bytes_available(void);
+uint32_t board_serial_bytes_available(void);
 void board_serial_write_substring(const char *text, uint32_t length);
 
 int console_uart_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));