feat: initial commit, random pairing sequence generation, host - board pairing handshakesfeat/livetraining-rawhid

6 files changed, 204 insertions, 272 deletions

diff --git a/quantum/eeconfig.c b/quantum/eeconfig.c
index 1aa9e8725c..14cd5887f4 100644
--- a/quantum/eeconfig.c
+++ b/quantum/eeconfig.c
@@ -3,9 +3,6 @@
 #include "eeprom.h"
 #include "eeconfig.h"
 #include "action_layer.h"
-#ifdef ORYX_ENABLE
-#    include "oryx.h"
-#endif
 
 #if defined(EEPROM_DRIVER)
 #    include "eeprom_driver.h"
@@ -60,10 +57,6 @@ void eeconfig_init_quantum(void) {
     eeprom_update_dword(EECONFIG_RGB_MATRIX, 0);
     eeprom_update_word(EECONFIG_RGB_MATRIX_EXTENDED, 0);
 
-#ifdef ORYX_ENABLE
-    eeconfig_init_oryx();
-#endif
-
     // TODO: Remove once ARM has a way to configure EECONFIG_HANDEDNESS
     //        within the emulated eeprom via dfu-util or another tool
 #if defined INIT_EE_HANDS_LEFT
diff --git a/quantum/oryx.c b/quantum/oryx.c
index c1e5dfba31..a65a8f5293 100644
--- a/quantum/oryx.c
+++ b/quantum/oryx.c
@@ -1,253 +1,177 @@
 #include "oryx.h"
 #include "eeprom.h"
-#include <string.h>
+#include "print.h"
 
-bool oryx_state_live_training_enabled;
+rawhid_state_t rawhid_state = {.pairing = false, .paired = false};
 
-bool webusb_receive_oryx(uint8_t *data, uint8_t length) {
-    uint8_t command = data[0];
-    uint8_t *param   = &(data[1]);
+keypos_t keyboard_pairing_sequence[PAIRING_SEQUENCE_SIZE];
+keypos_t host_pairing_sequence[PAIRING_SEQUENCE_SIZE];
+uint8_t  pairing_input_index = 0;
+
+void raw_hid_receive(uint8_t *data, uint8_t length) {
+    uint8_t  command   = data[0];
+    uint8_t *param     = &data[1];
+    uint8_t  cmd_index = 0;
 
     switch (command) {
-        case ORYX_GET_LAYER:
-            oryx_layer_event();
-            return true;
-        case ORYX_CMD_LIVE_TRAINING: {
-            uint8_t event[4];
-            switch (param[0]) {  // 0 for querying, 1 for off, 2 for on
-                case 0:
-                    break;
-                case 1:
-                    oryx_state_live_training_enabled = false;
-                    break;
-                case 2:
-                    oryx_state_live_training_enabled = true;
-                    break;
-                default:
-                    webusb_error(WEBUSB_STATUS_UNKNOWN_COMMAND);
-                    return true;
+        case ORYX_CMD_PAIRING_INIT:
+            pairing_init_handler();
+            store_pairing_sequence(&keyboard_pairing_sequence[0]);
+            break;
+        case ORYX_CMD_PAIRING_VALIDATE:
+            for (uint8_t i = 0; i < PAIRING_SEQUENCE_SIZE; i++) {
+                keypos_t pos;
+                pos.col                  = param[cmd_index++];
+                pos.row                  = param[cmd_index++];
+                host_pairing_sequence[i] = pos;
             }
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_TRAINING;
-            event[2] = oryx_state_live_training_enabled;
-            event[3] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            return true;
-        }
-#ifdef DYNAMIC_KEYMAP_ENABLE
-        case ORYX_CMD_LIVE_UPDATE_GET_KEYCODE: {
-            uint8_t event[5];
-            // layer, row, col
-            uint16_t keycode = dynamic_keymap_get_keycode(param[0], param[1], param[2]);
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_GET_KEYCODE;
-            event[2] = keycode >> 8;
-            event[3] = keycode & 0xFF;
-            event[4] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            return true;
-        }
-        case ORYX_CMD_LIVE_UPDATE_SET_KEYCODE: {
-            uint8_t event[5];
-            dynamic_keymap_set_keycode(param[0], param[1], param[2], (param[3] << 8) | param[4]);
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_SET_KEYCODE;
-            event[2] = param[3];
-            event[3] = param[4];
-            event[4] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            return true;
-        }
-        case ORYX_CMD_LIVE_UPDATE_KEYMAP_RESET: {
-            uint8_t event[3];
-            dynamic_keymap_reset();
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_KEYMAP_RESET;
-            event[2] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            return true;
-        }
-        case ORYX_CMD_LIVE_UPDATE_GET_BUFFER: {
-            uint16_t offset = (param[0] << 8) | param[1];
-            uint16_t size   = param[2];  // size <= 28
-            uint8_t event[size+3];
-            uint8_t i;
-            dynamic_keymap_get_buffer(offset, size, &param[3]);
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_GET_BUFFER;
-            for (i = 0; i < size; i++) {
-                event[i+2] = param[i];
-            }
-            event[i+2] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            return true;
-        }
-        case ORYX_CMD_LIVE_UPDATE_SET_BUFFER: {
-            uint16_t offset = (param[0] << 8) | param[1];
-            uint16_t size   = param[2];  // size <= 28
-            uint8_t event[3];
-            dynamic_keymap_set_buffer(offset, size, &param[3]);
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_SET_BUFFER;
-            event[2] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            return true;
-        }
-        case ORYX_CMD_LIVE_UPDATE_GET_LAYER_COUNT: {
-            uint8_t event[4];
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_GET_LAYER_COUNT;
-            event[2] = dynamic_keymap_get_layer_count();
-            event[3] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            return true;
-        }
-        case ORYX_CMD_LIVE_UPDATE_GET_MACRO_COUNT: {
-            uint8_t event[4];
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_GET_MACRO_COUNT;
-            event[2] = dynamic_keymap_macro_get_count();
-            event[3] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            return true;
-        }
-        case ORYX_CMD_LIVE_UPDATE_GET_MACRO_BUFFER_SIZE: {
-            uint16_t size   = dynamic_keymap_macro_get_buffer_size();
-            uint8_t event[5];
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_GET_MACRO_BUFFER_SIZE;
-            event[2] = size >> 8;
-            event[3] = size & 0xFF;
-            event[4] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            return true;
-        }
-        case ORYX_CMD_LIVE_UPDATE_GET_MACRO_BUFFER: {
-            uint16_t offset = (param[0] << 8) | param[1];
-            uint16_t size   = param[2];  // size <= 28
-            uint8_t event[size+3];
-            uint8_t i;
-            dynamic_keymap_macro_get_buffer(offset, size, &param[3]);
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_GET_MACRO_BUFFER;
-            for (i = 0; i < size; i++) {
-                event[i+2] = param[i];
-            }
-            event[i+2] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            return true;
-        }
-        case ORYX_CMD_LIVE_UPDATE_SET_MACRO_BUFFER: {
-            uint16_t offset = (param[0] << 8) | param[1];
-            uint16_t size   = param[2];  // size <= 28
-            dynamic_keymap_macro_set_buffer(offset, size, &param[3]);
-            uint8_t event[3];
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_SET_MACRO_BUFFER;
-            event[2] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            return true;
-        }
-        case ORYX_CMD_LIVE_UPDATE_MACRO_RESET: {
-            uint8_t event[3];
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_MACRO_RESET;
-            event[2] = WEBUSB_STOP_BIT;
-            dynamic_keymap_macro_reset();
-            webusb_send(event, sizeof(event));
-            return true;
-        }
-        case ORYX_CMD_LIVE_UPDATE_EEPROM_RESET: {
-            uint8_t event[3];
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_EEPROM_RESET;
-            event[2] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            eeconfig_init();
-            return true;
-        }
-        case ORYX_CMD_LIVE_UPDATE_KEYBOARD_RESET: {
-            uint8_t event[3];
-            event[0] = WEBUSB_STATUS_OK;
-            event[1] = ORYX_EVT_LIVE_UPDATE_KEYBOARD_RESET;
-            event[2] = WEBUSB_STOP_BIT;
-            webusb_send(event, sizeof(event));
-            reset_keyboard();
-            return true;
+            pairing_validate_handler();
+            break;
+    }
+}
+
+bool store_pairing_sequence(keypos_t *pairing_sequence) {
+    uint8_t stored_sequences[sizeof(uint16_t) * PAIRING_SEQUENCE_SIZE * PAIRING_SEQUENCE_NUM_STORED];
+
+    eeprom_read_block(&stored_sequences, (uint8_t *)EECONFIG_SIZE, PAIRING_STORAGE_SIZE);
+
+    uint8_t shiftLen = sizeof(&pairing_sequence);
+    uprintf("storage size %u\n", PAIRING_STORAGE_SIZE);
+    uprintf("shift size %u\n", shiftLen);
+
+    // dumping before
+    uprintf("Dumping pairing eeprom storage\n");
+    for (uint8_t i = 0; i < PAIRING_STORAGE_SIZE; i++) {
+        uprintf("%u ", stored_sequences[i]);
+    }
+    uprintf("\nEnd of Dumping pairing eeprom storage\n");
+
+    for (int8_t i = PAIRING_STORAGE_SIZE; i >= 0; i--) {
+        if (i > shiftLen) {
+            stored_sequences[i] = stored_sequences[i - 1];
+        } else {
+            stored_sequences[i] = 0;
         }
-#endif
-        default:
-            return webusb_receive_kb(data, length);
     }
+
+    // dumping after
+    uprintf("Dumping pairing eeprom storage\n");
+    for (uint8_t i = 0; i < PAIRING_STORAGE_SIZE; i++) {
+        uprintf("%u ", stored_sequences[i]);
+    }
+    uprintf("\nEnd of Dumping pairing eeprom storage\n");
+    eeprom_update_block(stored_sequences, (uint8_t *)EECONFIG_SIZE, PAIRING_STORAGE_SIZE);
+    return true;
 }
 
-void oryx_layer_event(void) {
-    uint8_t layer;
-    uint8_t event[4];
-    layer = get_highest_layer(layer_state);
-#ifdef WEBUSB_ENABLE
-    event[0] = WEBUSB_STATUS_OK;
-    event[1] = ORYX_EVT_LAYER;
-    event[2] = layer;
-    event[3] = WEBUSB_STOP_BIT;
-    webusb_send(event, sizeof(event));
-#endif
+void pairing_init_handler(void) {
+    create_pairing_code();
+    uint8_t event[RAW_EPSIZE];
+    uint8_t event_index  = 0;
+    event[event_index++] = ORYX_EVT_PAIRING_INPUT;
+    for (uint8_t i = 0; i < PAIRING_SEQUENCE_SIZE; i++) {
+        event[event_index++] = keyboard_pairing_sequence[i].col;
+        event[event_index++] = keyboard_pairing_sequence[i].row;
+    }
+    event[event_index++] = ORYX_STOP_BIT;
+    rawhid_state.pairing = true;
+    raw_hid_send(event, RAW_EPSIZE);
 }
 
-bool is_oryx_live_training_enabled(void) { return (oryx_state_live_training_enabled && webusb_state.paired); }
+void pairing_validate_handler() {
+    bool    valid = true;
+    uint8_t event[RAW_EPSIZE];
+    for (uint8_t i = 0; i < PAIRING_SEQUENCE_SIZE; i++) {
+        uprintf("\nExpected: Row: %u / Col:%u\n", keyboard_pairing_sequence[i].col, keyboard_pairing_sequence[i].row);
+        uprintf("GOT: Row: %u / Col:%u\n", host_pairing_sequence[i].col, host_pairing_sequence[i].row);
 
-bool process_record_oryx(uint16_t keycode, keyrecord_t *record) {
-    if(is_oryx_live_training_enabled()) {
-        uint8_t event[5];
-        event[0] = WEBUSB_STATUS_OK;
-        event[1] = record->event.pressed ? ORYX_EVT_KEYDOWN : ORYX_EVT_KEYUP;
-        event[2] = record->event.key.col;
-        event[3] = record->event.key.row;
-        event[4] = WEBUSB_STOP_BIT;
-        webusb_send(event, sizeof(event));
+        if (keyboard_pairing_sequence[i].row != host_pairing_sequence[i].row) {
+            valid = false;
+            break;
+        }
+        if (keyboard_pairing_sequence[i].col != host_pairing_sequence[i].col) {
+            valid = false;
+            break;
+        }
     }
-    if (keycode == WEBUSB_PAIR && record->event.pressed) {
-         webusb_state.pairing ^= true;
-        return true;
+    if (valid == true) {
+        event[0]            = ORYX_EVT_PAIRING_SUCCESS;
+        rawhid_state.paired = true;
+
+    } else {
+        event[0]            = ORYX_EVT_PAIRING_FAILED;
+        rawhid_state.paired = false;
     }
+    event[1]             = ORYX_STOP_BIT;
+    rawhid_state.pairing = false;
+    raw_hid_send(event, sizeof(event));
+}
 
-#ifdef DYNAMIC_KEYMAP_ENABLE
-    switch (keycode) {
-        case MACRO00 ... MACRO15:
-            if (record->event.pressed) {
-                dynamic_keymap_macro_send(keycode - MACRO00);
-            }
-            return false;
+keypos_t get_random_keypos(void) {
+    uint8_t  col = rand() % MATRIX_COLS;
+    uint8_t  row = rand() % MATRIX_ROWS;
+    keypos_t pos = {.col = col, .row = row};
+
+    if (keymap_key_to_keycode(0, pos) != KC_NO) {
+        return pos;
+    } else {
+        return get_random_keypos();
     }
-#endif
-    return true;
 }
 
-void layer_state_set_oryx(layer_state_t state) {
-    if(is_oryx_live_training_enabled()) {
-        uint8_t event[4];
-        event[0] = WEBUSB_STATUS_OK;
-        event[1] = ORYX_EVT_LAYER;
-        event[2] = get_highest_layer(state);
-        event[3] = WEBUSB_STOP_BIT;
-        webusb_send(event, sizeof(event));
+void create_pairing_code(void) {
+    for (uint8_t i = 0; i < PAIRING_SEQUENCE_SIZE; i++) {
+        keypos_t pos                 = get_random_keypos();
+        keyboard_pairing_sequence[i] = pos;
     }
 }
 
-void eeconfig_init_oryx(void) {
-#ifdef DYNAMIC_KEYMAP_ENABLE
-    // reread settings from flash into eeprom
-    dynamic_keymap_reset();
-    dynamic_keymap_macro_reset();
-    eeprom_update_block(FIRMWARE_VERSION, (uint8_t *)EECONFIG_SIZE, sizeof(uint8_t)*FIRMWARE_VERSION_SIZE);
+void oryx_layer_event(void) {
+    uint8_t layer;
+    uint8_t event[RAW_EPSIZE];
+    layer    = get_highest_layer(layer_state);
+    event[0] = ORYX_EVT_LAYER;
+    event[1] = layer;
+    event[2] = ORYX_STOP_BIT;
+    raw_hid_send(event, sizeof(event));
+}
+
+bool process_record_oryx(uint16_t keycode, keyrecord_t *record) {
+    // In pairing mode, key events are absorbed, and the host pairing sequence is filled.
+    // Once filled, the keyboard and host sequence are compaired, pairing state set to false
+    // and the proper pairing validation event is sent to the host
+    if (rawhid_state.pairing) {
+        // The host pairing sequence is filled on key up only
+        if (!record->event.pressed) {
+            if (pairing_input_index < PAIRING_SEQUENCE_SIZE) {
+                host_pairing_sequence[pairing_input_index++] = record->event.key;
+            }
+            if (pairing_input_index == PAIRING_SEQUENCE_SIZE) {
+                rawhid_state.pairing = false;
+                pairing_input_index  = 0;
+                pairing_validate_handler();
+            }
+        }
+        return false;
+    }
+    // While paired, the keyboard sends keystrokes positions to the host
+    if (rawhid_state.paired) {
+        uint8_t event[RAW_EPSIZE];
+        event[0] = record->event.pressed ? ORYX_EVT_KEYDOWN : ORYX_EVT_KEYUP;
+        event[1] = record->event.key.col;
+        event[2] = record->event.key.row;
+        event[3] = ORYX_STOP_BIT;
+        raw_hid_send(event, sizeof(event));
+    }
+    return true;
 }
 
-void matrix_init_oryx(void) {
-    uint8_t temp[FIRMWARE_VERSION_SIZE];
-    uint8_t firmware[FIRMWARE_VERSION_SIZE] = FIRMWARE_VERSION;
-    eeprom_read_block(&temp, (uint8_t *)EECONFIG_SIZE, sizeof(uint8_t)*FIRMWARE_VERSION_SIZE);
-    if (!memcmp(&temp, &firmware, sizeof(uint8_t)*FIRMWARE_VERSION_SIZE)) {
-        eeconfig_init_oryx();
+void layer_state_set_oryx(layer_state_t state) {
+    if (rawhid_state.paired) {
+        uint8_t event[RAW_EPSIZE];
+        event[0] = ORYX_EVT_LAYER;
+        event[1] = get_highest_layer(state);
+        event[2] = ORYX_STOP_BIT;
+        raw_hid_send(event, sizeof(event));
     }
-#endif
 }
diff --git a/quantum/oryx.h b/quantum/oryx.h
index b1fe78a061..9437a7092c 100644
--- a/quantum/oryx.h
+++ b/quantum/oryx.h
@@ -1,18 +1,25 @@
 #pragma once
 
 #include "quantum.h"
-#include "webusb.h"
+#include "raw_hid.h"
 
-#ifndef WEBUSB_ENABLE
-#    error "WebUSB needs to be enabled, please enable it!"
+#ifndef RAW_ENABLE
+#    error "Raw hid needs to be enabled, please enable it!"
+#endif
+#ifndef RAW_EPSIZE
+#    define RAW_EPSIZE 32
 #endif
 
-// enum Oryx_Status_code {
-//     PLACEHOLDER = WEBUSB_STATUS_SAFE_RANGE,
-// }
+#define ORYX_STOP_BIT -2
+#define PAIRING_SEQUENCE_SIZE 3
+#define PAIRING_SEQUENCE_NUM_STORED 5
+#define PAIRING_STORAGE_SIZE PAIRING_SEQUENCE_SIZE * PAIRING_SEQUENCE_NUM_STORED * sizeof(uint16_t)
 
 enum Oryx_Command_Code {
-    ORYX_GET_LAYER = WEBUSB_CMD_SAFE_RANGE,
+    ORYX_CMD_PAIRING_INIT,
+    ORYX_CMD_PAIRING_VALIDATE,
+    ORYX_CMD_DISCONNECT,
+    ORYX_GET_LAYER,
     ORYX_CMD_LIVE_TRAINING,
     ORYX_CMD_LIVE_UPDATE_GET_KEYCODE,
     ORYX_CMD_LIVE_UPDATE_SET_KEYCODE,
@@ -27,11 +34,13 @@ enum Oryx_Command_Code {
     ORYX_CMD_LIVE_UPDATE_MACRO_RESET,
     ORYX_CMD_LIVE_UPDATE_EEPROM_RESET,
     ORYX_CMD_LIVE_UPDATE_KEYBOARD_RESET,
-
 };
 
 enum Oryx_Event_Code {
-    ORYX_EVT_LAYER = WEBUSB_EVT_SAFE_RANGE,
+    ORYX_EVT_PAIRING_INPUT,
+    ORYX_EVT_PAIRING_FAILED,
+    ORYX_EVT_PAIRING_SUCCESS,
+    ORYX_EVT_LAYER,
     ORYX_EVT_LIVE_TRAINING,
     ORYX_EVT_LIVE_UPDATE_GET_KEYCODE,
     ORYX_EVT_LIVE_UPDATE_SET_KEYCODE,
@@ -50,33 +59,25 @@ enum Oryx_Event_Code {
     ORYX_EVT_KEYUP,
 };
 
-#ifdef DYNAMIC_KEYMAP_ENABLE
-enum dynamic_macros_keycodes {
-    MACRO00 = 0x5F12,
-    MACRO01,
-    MACRO02,
-    MACRO03,
-    MACRO04,
-    MACRO05,
-    MACRO06,
-    MACRO07,
-    MACRO08,
-    MACRO09,
-    MACRO10,
-    MACRO11,
-    MACRO12,
-    MACRO13,
-    MACRO14,
-    MACRO15,
-};
-#endif
-
 extern bool oryx_state_live_training_enabled;
 
-bool webusb_receive_oryx(uint8_t *data, uint8_t length);
+typedef struct {
+    bool pairing;
+    bool paired;
+} rawhid_state_t;
+
+extern rawhid_state_t rawhid_state;
+
+void     create_pairing_code(void);
+bool     store_pairing_sequence(keypos_t* pairing_sequence);
+keypos_t get_random_keypos(void);
+void     pairing_init_handler(void);
+void     pairing_validate_handler(void);
+void     pairing_init_event(void);
+void     pairing_failed_event(void);
+void     pairing_succesful_event(void);
+
 void oryx_layer_event(void);
 bool is_oryx_live_training_enabled(void);
-bool process_record_oryx(uint16_t keycode, keyrecord_t *record);
+bool process_record_oryx(uint16_t keycode, keyrecord_t* record);
 void layer_state_set_oryx(layer_state_t state);
-void eeconfig_init_oryx(void);
-void matrix_init_oryx(void);
diff --git a/quantum/quantum.c b/quantum/quantum.c
index 3dc613dc7c..c91cb96d6e 100644
--- a/quantum/quantum.c
+++ b/quantum/quantum.c
@@ -401,11 +401,7 @@ __attribute__((weak)) bool webusb_receive_user(uint8_t *data, uint8_t length) {
 __attribute__((weak)) bool webusb_receive_kb(uint8_t *data, uint8_t length) { return webusb_receive_user(data, length); }
 
 bool webusb_receive_quantum(uint8_t *data, uint8_t length) {
-#    ifdef ORYX_ENABLE
-    return webusb_receive_oryx(data, length);
-#    else
     return webusb_receive_kb(data, length);
-#    endif
 }
 #endif
 
diff --git a/tmk_core/protocol/chibios/usb_main.c b/tmk_core/protocol/chibios/usb_main.c
index e18268db3b..8c3f5c55e3 100644
--- a/tmk_core/protocol/chibios/usb_main.c
+++ b/tmk_core/protocol/chibios/usb_main.c
@@ -49,6 +49,14 @@
 extern keymap_config_t keymap_config;
 #endif
 
+#ifdef RAW_ENABLE
+#    include "raw_hid.h"
+#endif
+
+#ifdef ORYX_ENABLE
+#    include "oryx.h"
+#endif
+
 #ifdef WEBUSB_ENABLE
 #    include "webusb.h"
 #endif
@@ -1141,7 +1149,15 @@ void raw_hid_send(uint8_t *data, uint8_t length) {
     if (length != RAW_EPSIZE) {
         return;
     }
+
+#ifdef ORYX_ENABLE
+    if(chnWriteTimeout(&drivers.raw_driver.driver, data, length, TIME_IMMEDIATE) != length){
+        rawhid_state.pairing = false;
+        rawhid_state.paired = false;
+    }
+#else
     chnWrite(&drivers.raw_driver.driver, data, length);
+#endif
 }
 
 __attribute__((weak)) void raw_hid_receive(uint8_t *data, uint8_t length) {
diff --git a/tmk_core/protocol/lufa/lufa.c b/tmk_core/protocol/lufa/lufa.c
index bf005d519f..ae43c67f1a 100644
--- a/tmk_core/protocol/lufa/lufa.c
+++ b/tmk_core/protocol/lufa/lufa.c
@@ -161,7 +161,9 @@ void raw_hid_send(uint8_t *data, uint8_t length) {
     // Check to see if the host is ready to accept another packet
     if (Endpoint_IsINReady()) {
         // Write data
-        Endpoint_Write_Stream_LE(data, RAW_EPSIZE, NULL);
+        if(Endpoint_Write_Stream_LE(data, RAW_EPSIZE, NULL)) {
+          rawhid_state.connected = false;
+        }
         // Finalize the stream transfer to send the last packet
         Endpoint_ClearIN();
     }