Merge pull request #250 from TheRedfoox/main

Enables support for multiple keyboard devices

Author: hrvach

.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 */