Enables support for multiple keyboard devices

Adds support for combining keyboard input from multiple USB HID devices and a remote UART device.

This ensures all key presses are captured and sent, regardless of the input source.  It also resolves potential issues when switching between keyboards. This is achieved by storing the keyboard state for each device and merging these states into a combined report before sending.

Author: TheRedfoox

.gitignore

@@ -1 +1,3 @@
 build
+
+.idea/

src/handlers.c

@@ -150,7 +150,17 @@ void config_enable_hotkey_handler(device_t *state, hid_keyboard_report_t *report
 
 /* Function handles received keypresses from the other board */
 void handle_keyboard_uart_msg(uart_packet_t *packet, device_t *state) {
-    queue_kbd_report((hid_keyboard_report_t *)packet->data, state);
+    hid_keyboard_report_t *report = (hid_keyboard_report_t *)packet->data;
+
+    /* Update the keyboard state for the remote device (using MAX_DEVICES-1 as the index) */
+    update_kbd_state(state, report, MAX_DEVICES-1);
+
+    /* Create a combined report from all device states */
+    hid_keyboard_report_t combined_report;
+    combine_kbd_states(state, &combined_report);
+
+    /* Queue the combined report */
+    queue_kbd_report(&combined_report, state);
     state->last_activity[BOARD_ROLE] = time_us_64();
 }
 

src/include/keyboard.h

@@ -27,6 +27,12 @@ int32_t  extract_kbd_data(uint8_t *, int, uint8_t, hid_interface_t *, hid_keyboa
 
 bool check_specific_hotkey(hotkey_combo_t, const hid_keyboard_report_t *);
 
+/*==============================================================================
+ *  Keyboard State Management
+ *==============================================================================*/
+void     update_kbd_state(device_t *, hid_keyboard_report_t *, uint8_t);
+void     combine_kbd_states(device_t *, hid_keyboard_report_t *);
+
 /*==============================================================================
  *  Keyboard Report Processing
  *==============================================================================*/

src/include/structs.h

@@ -100,6 +100,10 @@ typedef struct {
     uint8_t active_output;               // Currently selected output (0 = A, 1 = B)
     uint8_t board_role;                  // Which board are we running on? (0 = A, 1 = B, etc.)
 
+    // Track keyboard state for each device
+    hid_keyboard_report_t kbd_states[MAX_DEVICES]; // Store keyboard state for each device
+    uint8_t kbd_device_count;                      // Number of active keyboard devices
+
     int16_t pointer_x; // Store and update the location of our mouse pointer
     int16_t pointer_y;
     int16_t mouse_buttons; // Store and update the state of mouse buttons

src/keyboard.c

@@ -143,6 +143,55 @@ hotkey_combo_t *check_all_hotkeys(hid_keyboard_report_t *report, device_t *state
     return NULL;
 }
 
+/* ==================================================== *
+ * Keyboard State Management
+ * ==================================================== */
+
+/* Update the keyboard state for a specific device */
+void update_kbd_state(device_t *state, hid_keyboard_report_t *report, uint8_t device_idx) {
+    /* Ensure device_idx is within bounds */
+    if (device_idx >= MAX_DEVICES)
+        return;
+
+    /* Ensure local devices never use the last slot, which is reserved for the remote device */
+    if (device_idx == MAX_DEVICES-1 && device_idx != 0) {
+        /* Use the previous slot instead */
+        device_idx = MAX_DEVICES-2;
+    }
+
+    /* Update the keyboard state for this device */
+    memcpy(&state->kbd_states[device_idx], report, sizeof(hid_keyboard_report_t));
+
+    /* Ensure kbd_device_count is at least device_idx + 1 */
+    if (state->kbd_device_count <= device_idx)
+        state->kbd_device_count = device_idx + 1;
+}
+
+/* Combine keyboard states from all devices into a single report */
+void combine_kbd_states(device_t *state, hid_keyboard_report_t *combined_report) {
+    /* Initialize combined report */
+    memset(combined_report, 0, sizeof(hid_keyboard_report_t));
+
+    /* Combine modifiers and keys from all devices */
+    for (uint8_t i = 0; i < state->kbd_device_count; i++) {
+        /* Combine modifiers with OR operation */
+        combined_report->modifier |= state->kbd_states[i].modifier;
+
+        /* Add keys from this device to the combined report */
+        for (uint8_t j = 0; j < KEYS_IN_USB_REPORT; j++) {
+            if (state->kbd_states[i].keycode[j] != 0) {
+                /* Find an empty slot in the combined report */
+                for (uint8_t k = 0; k < KEYS_IN_USB_REPORT; k++) {
+                    if (combined_report->keycode[k] == 0) {
+                        combined_report->keycode[k] = state->kbd_states[i].keycode[j];
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}
+
 /* ==================================================== *
  * Keyboard Queue Section
  * ==================================================== */
@@ -184,16 +233,29 @@ void queue_kbd_report(hid_keyboard_report_t *report, device_t *state) {
 
 void release_all_keys(device_t *state) {
     static hid_keyboard_report_t no_keys_pressed_report = {0, 0, {0}};
+
+    /* Clear keyboard states for all devices */
+    for (uint8_t i = 0; i < state->kbd_device_count; i++) {
+        memset(&state->kbd_states[i], 0, sizeof(hid_keyboard_report_t));
+    }
+
+    /* Send a report with no keys pressed */
     queue_try_add(&state->kbd_queue, &no_keys_pressed_report);
 }
 
 /* If keys need to go locally, queue packet to kbd queue, else send them through UART */
 void send_key(hid_keyboard_report_t *report, device_t *state) {
+    /* Create a combined report from all device states */
+    hid_keyboard_report_t combined_report;
+    combine_kbd_states(state, &combined_report);
+
     if (CURRENT_BOARD_IS_ACTIVE_OUTPUT) {
-        queue_kbd_report(report, state);
+        /* Queue the combined report */
+        queue_kbd_report(&combined_report, state);
         state->last_activity[BOARD_ROLE] = time_us_64();
     } else {
-        queue_packet((uint8_t *)report, KEYBOARD_REPORT_MSG, KBD_REPORT_LENGTH);
+        /* Send the combined report to ensure all keys are included */
+        queue_packet((uint8_t *)&combined_report, KEYBOARD_REPORT_MSG, KBD_REPORT_LENGTH);
     }
 }
 
@@ -235,6 +297,9 @@ void process_keyboard_report(uint8_t *raw_report, int length, uint8_t itf, hid_i
 
     extract_kbd_data(raw_report, length, itf, iface, &new_report);
 
+    /* Update the keyboard state for this device */
+    update_kbd_state(state, &new_report, itf);
+
     /* Check if any hotkey was pressed */
     hotkey = check_all_hotkeys(&new_report, state);
 
@@ -259,6 +324,7 @@ void process_keyboard_report(uint8_t *raw_report, int length, uint8_t itf, hid_i
 void process_consumer_report(uint8_t *raw_report, int length, uint8_t itf, hid_interface_t *iface) {
     uint8_t new_report[CONSUMER_CONTROL_LENGTH] = {0};
     uint16_t *report_ptr = (uint16_t *)new_report;
+    device_t *state = &global_state;
 
     /* If consumer control is variable, read the values from cc_array and send as array. */
     if (iface->consumer.is_variable) {
@@ -276,12 +342,21 @@ void process_consumer_report(uint8_t *raw_report, int length, uint8_t itf, hid_i
             new_report[i] = raw_report[i + 1];
     }
 
-    send_consumer_control(new_report, &global_state);
+    if (CURRENT_BOARD_IS_ACTIVE_OUTPUT) {
+        send_consumer_control(new_report, state);
+    } else {
+        queue_packet((uint8_t *)new_report, CONSUMER_CONTROL_MSG, CONSUMER_CONTROL_LENGTH);
+    }
 }
 
 void process_system_report(uint8_t *raw_report, int length, uint8_t itf, hid_interface_t *iface) {
     uint16_t new_report = raw_report[1];
     uint8_t *report_ptr = (uint8_t *)&new_report;
+    device_t *state = &global_state;
 
-    send_system_control(report_ptr, &global_state);
+    if (CURRENT_BOARD_IS_ACTIVE_OUTPUT) {
+        send_system_control(report_ptr, state);
+    } else {
+        queue_packet(report_ptr, SYSTEM_CONTROL_MSG, SYSTEM_CONTROL_LENGTH);
+    }
 }

src/setup.c

@@ -231,6 +231,10 @@ void initial_setup(device_t *state) {
     queue_init(&state->kbd_queue, sizeof(hid_keyboard_report_t), KBD_QUEUE_LENGTH);
     queue_init(&state->mouse_queue, sizeof(mouse_report_t), MOUSE_QUEUE_LENGTH);
 
+    /* Initialize keyboard states for all devices */
+    memset(state->kbd_states, 0, sizeof(state->kbd_states));
+    state->kbd_device_count = 0;
+
     /* Initialize generic HID packet queue */
     queue_init(&state->hid_queue_out, sizeof(hid_generic_pkt_t), HID_QUEUE_LENGTH);
 

src/usb.c

@@ -188,6 +188,34 @@ void tuh_hid_report_received_cb(uint8_t dev_addr, uint8_t instance, uint8_t cons
     if (instance >= MAX_INTERFACES)
         return;
 
+    /* Calculate a device index that distinguishes between different devices
+       while staying within the bounds of MAX_DEVICES.
+
+       Device index assignment:
+       - 0: Primary keyboard (the one set in tuh_hid_mount_cb)
+       - 1: Mouse devices
+       - MAX_DEVICES-2: Secondary keyboards (e.g., wireless keyboard through unified dongle)
+       - (dev_addr-1) % (MAX_DEVICES-1): Other devices
+
+       Note: Slot MAX_DEVICES-1 is reserved for the remote device (used in handle_keyboard_uart_msg) */
+    uint8_t device_idx;
+
+    if (itf_protocol == HID_ITF_PROTOCOL_KEYBOARD) {
+        if (dev_addr == global_state.kbd_dev_addr && instance == global_state.kbd_instance) {
+            /* Primary keyboard */
+            device_idx = 0;
+        } else {
+            /* Secondary keyboard (e.g., wireless keyboard through unified dongle) */
+            device_idx = (MAX_DEVICES - 2);
+        }
+    } else if (itf_protocol == HID_ITF_PROTOCOL_MOUSE) {
+        /* Mouse devices */
+        device_idx = 1;
+    } else {
+        /* Other devices */
+        device_idx = (dev_addr - 1) % (MAX_DEVICES - 1);
+    }
+
     if (iface->uses_report_id || itf_protocol == HID_ITF_PROTOCOL_NONE) {
         uint8_t report_id = 0;
 
@@ -198,14 +226,14 @@ void tuh_hid_report_received_cb(uint8_t dev_addr, uint8_t instance, uint8_t cons
             process_report_f receiver = iface->report_handler[report_id];
 
             if (receiver != NULL)
-                receiver((uint8_t *)report, len, itf_protocol, iface);
+                receiver((uint8_t *)report, len, device_idx, iface);
         }
     }
     else if (itf_protocol == HID_ITF_PROTOCOL_KEYBOARD) {
-        process_keyboard_report((uint8_t *)report, len, itf_protocol, iface);
+        process_keyboard_report((uint8_t *)report, len, device_idx, iface);
     }
     else if (itf_protocol == HID_ITF_PROTOCOL_MOUSE) {
-        process_mouse_report((uint8_t *)report, len, itf_protocol, iface);
+        process_mouse_report((uint8_t *)report, len, device_idx, iface);
     }
 
     /* Continue requesting reports */