jbrechtel/qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reimplements Oryx's live training over raw hid (#345)

Browse Source 
* feat: initial commit, random pairing sequence generation, host - board pairing handshakes

* feat: reimplements ory's live training over raw hid

* feat: adds planck / ergodox support

* chore: some code styling fixes

* fix: build smoke tests

* fix: code lint

* fix: disable console / command on moonlander, fixes build ci test

* fix: code lint

* fix: remove unused define(MATRIX_SIZE)
This commit is contained in:
Florian Didron
2022-05-31 19:03:21 +09:00
committed by GitHub
parent 1fbd91aa10
commit fc773ff0cf
14 changed files with 306 additions and 390 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
builddefs/common_features.mk
View File

@@ -549,7 +549,7 @@ ifeq ($(strip $(TERMINAL_ENABLE)), yes)
endif endif
ifeq ($(strip $(ORYX_ENABLE)), yes) ifeq ($(strip $(ORYX_ENABLE)), yes)
WEBUSB_ENABLE := yes RAW_ENABLE := yes
SRC += $(QUANTUM_DIR)/oryx.c SRC += $(QUANTUM_DIR)/oryx.c
OPT_DEFS += -DORYX_ENABLE OPT_DEFS += -DORYX_ENABLE
endif endif

8
keyboards/ergodox_ez/ergodox_ez.c
View File

@@ -424,13 +424,13 @@ void dynamic_macro_record_end_user(int8_t direction) {
void matrix_scan_kb(void) { void matrix_scan_kb(void) {
#ifdef ORYX_ENABLE #ifdef ORYX_ENABLE
if(webusb_state.pairing == true) { if(rawhid_state.pairing == true) {
if(loops == 0) { if(loops == 0) {
ergodox_right_led_1_off(); ergodox_right_led_1_off();
ergodox_right_led_2_off(); ergodox_right_led_2_off();
ergodox_right_led_3_off(); ergodox_right_led_3_off();
} }
if(loops % WEBUSB_BLINK_STEPS == 0) { if(loops % PAIRING_BLINK_STEPS == 0) {
if(is_on) { if(is_on) {
ergodox_right_led_2_off(); ergodox_right_led_2_off();
} else { } else {
@@ -438,8 +438,8 @@ void matrix_scan_kb(void) {
} }
is_on ^= 1; is_on ^= 1;
} }
if(loops > WEBUSB_BLINK_END) { if(loops > PAIRING_BLINK_END) {
webusb_state.pairing = false; rawhid_state.pairing = false;
layer_state_set_user(layer_state); layer_state_set_user(layer_state);
loops = 0; loops = 0;
} }

3
keyboards/ergodox_ez/keymaps/oryx/config.h
View File

@@ -1,3 +1,6 @@
#pragma once #pragma once
#define LAYER_STATE_8BIT #define LAYER_STATE_8BIT
#define FIRMWARE_VERSION u8"default/latest"
#define RAW_USAGE_PAGE 0xFF60
#define RAW_USAGE_ID 0x61

3
keyboards/moonlander/keymaps/oryx/config.h
View File

@@ -1,3 +1,6 @@
#pragma once #pragma once
#include "../default/config.h" #include "../default/config.h"
#define FIRMWARE_VERSION u8"default/latest"
#define RAW_USAGE_PAGE 0xFF60
#define RAW_USAGE_ID 0x61

2
keyboards/moonlander/keymaps/oryx/rules.mk
View File

@@ -1,6 +1,4 @@
SRC += ../default/keymap.c SRC += ../default/keymap.c
-include ../default/rules.mk -include ../default/rules.mk
WEBUSB_ENABLE = yes
ORYX_ENABLE = yes ORYX_ENABLE = yes
DYNAMIC_KEYMAP_ENABLE = yes

33
keyboards/moonlander/moonlander.c
View File

@@ -14,11 +14,10 @@
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "moonlander.h" #include "moonlander.h"
#include "raw_hid.h"
keyboard_config_t keyboard_config; keyboard_config_t keyboard_config;
@@ -28,7 +27,9 @@ bool is_launching = false;
#ifdef DYNAMIC_MACRO_ENABLE #ifdef DYNAMIC_MACRO_ENABLE
static bool is_dynamic_recording = false; static bool is_dynamic_recording = false;
void dynamic_macro_record_start_user(void) { is_dynamic_recording = true; } void dynamic_macro_record_start_user(void) {
is_dynamic_recording = true;
}
void dynamic_macro_record_end_user(int8_t direction) { void dynamic_macro_record_end_user(int8_t direction) {
is_dynamic_recording = false; is_dynamic_recording = false;
@@ -96,7 +97,6 @@ static THD_FUNCTION(LEDThread, arg) {
} }
} }
void keyboard_pre_init_kb(void) { void keyboard_pre_init_kb(void) {
setPinOutput(B5); setPinOutput(B5);
setPinOutput(B4); setPinOutput(B4);
@@ -125,9 +125,9 @@ layer_state_t layer_state_set_kb(layer_state_t state) {
bool LED_3 = false; bool LED_3 = false;
bool LED_4 = false; bool LED_4 = false;
bool LED_5 = false; bool LED_5 = false;
#if !defined(CAPS_LOCK_STATUS) # if !defined(CAPS_LOCK_STATUS)
bool LED_6 = false; bool LED_6 = false;
#endif # endif
uint8_t layer = get_highest_layer(state); uint8_t layer = get_highest_layer(state);
switch (layer) { switch (layer) {
@@ -141,9 +141,9 @@ layer_state_t layer_state_set_kb(layer_state_t state) {
break; break;
case 3: case 3:
LED_3 = true; LED_3 = true;
#if !defined(CAPS_LOCK_STATUS) # if !defined(CAPS_LOCK_STATUS)
LED_6 = true; LED_6 = true;
#endif # endif
break; break;
case 4: case 4:
LED_4 = true; LED_4 = true;
@@ -152,9 +152,9 @@ layer_state_t layer_state_set_kb(layer_state_t state) {
LED_5 = true; LED_5 = true;
break; break;
case 6: case 6:
#if !defined(CAPS_LOCK_STATUS) # if !defined(CAPS_LOCK_STATUS)
LED_6 = true; LED_6 = true;
#endif # endif
break; break;
default: default:
break; break;
@@ -165,10 +165,9 @@ layer_state_t layer_state_set_kb(layer_state_t state) {
ML_LED_3(LED_3); ML_LED_3(LED_3);
ML_LED_4(LED_4); ML_LED_4(LED_4);
ML_LED_5(LED_5); ML_LED_5(LED_5);
#if !defined(CAPS_LOCK_STATUS) # if !defined(CAPS_LOCK_STATUS)
ML_LED_6(LED_6); ML_LED_6(LED_6);
#endif # endif
return state; return state;
} }
#endif #endif
@@ -373,7 +372,7 @@ const uint8_t music_map[MATRIX_ROWS][MATRIX_COLS] = LAYOUT_moonlander(
#ifdef CAPS_LOCK_STATUS #ifdef CAPS_LOCK_STATUS
bool led_update_kb(led_t led_state) { bool led_update_kb(led_t led_state) {
bool res = led_update_user(led_state); bool res = led_update_user(led_state);
if(res) { if (res) {
ML_LED_6(led_state.caps_lock); ML_LED_6(led_state.caps_lock);
} }
return res; return res;
@@ -381,7 +380,9 @@ bool led_update_kb(led_t led_state) {
#endif #endif
bool process_record_kb(uint16_t keycode, keyrecord_t *record) { bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
if (!process_record_user(keycode, record)) { return false; } if (!process_record_user(keycode, record)) {
return false;
}
switch (keycode) { switch (keycode) {
#if !defined(MOONLANDER_USER_LEDS) #if !defined(MOONLANDER_USER_LEDS)
case LED_LEVEL: case LED_LEVEL:

4
keyboards/moonlander/rules.mk
View File

@@ -10,8 +10,8 @@ BOOTLOADER = stm32-dfu
BOOTMAGIC_ENABLE = yes # Enable Bootmagic Lite BOOTMAGIC_ENABLE = yes # Enable Bootmagic Lite
MOUSEKEY_ENABLE = yes # Mouse keys MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug CONSOLE_ENABLE = no # Console for debug
COMMAND_ENABLE = yes # Commands for debug and configuration COMMAND_ENABLE = no # Commands for debug and configuration
NKRO_ENABLE = yes # Enable N-Key Rollover NKRO_ENABLE = yes # Enable N-Key Rollover
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow

8
keyboards/planck/ez/ez.c
View File

@@ -335,11 +335,11 @@ void dynamic_macro_record_end_user(int8_t direction) {
void matrix_scan_kb(void) { void matrix_scan_kb(void) {
#ifdef ORYX_ENABLE #ifdef ORYX_ENABLE
if(webusb_state.pairing == true) { if(rawhid_state.pairing == true) {
if(loops == 0) { if(loops == 0) {
//lights off //lights off
} }
if(loops % WEBUSB_BLINK_STEPS == 0) { if(loops % PAIRING_BLINK_STEPS == 0) {
if(is_on) { if(is_on) {
planck_ez_left_led_on(); planck_ez_left_led_on();
planck_ez_right_led_off(); planck_ez_right_led_off();
@@ -350,8 +350,8 @@ void matrix_scan_kb(void) {
} }
is_on ^= 1; is_on ^= 1;
} }
if(loops > WEBUSB_BLINK_END * 2) { if(loops > PAIRING_BLINK_END * 2) {
webusb_state.pairing = false; rawhid_state.pairing = false;
loops = 0; loops = 0;
planck_ez_left_led_off(); planck_ez_left_led_off();
planck_ez_right_led_off(); planck_ez_right_led_off();

7
quantum/eeconfig.c
View File

@@ -3,9 +3,6 @@
#include "eeprom.h" #include "eeprom.h"
#include "eeconfig.h" #include "eeconfig.h"
#include "action_layer.h" #include "action_layer.h"
#ifdef ORYX_ENABLE
# include "oryx.h"
#endif
#if defined(EEPROM_DRIVER) #if defined(EEPROM_DRIVER)
# include "eeprom_driver.h" # include "eeprom_driver.h"
@@ -60,10 +57,6 @@ void eeconfig_init_quantum(void) {
eeprom_update_dword(EECONFIG_RGB_MATRIX, 0); eeprom_update_dword(EECONFIG_RGB_MATRIX, 0);
eeprom_update_word(EECONFIG_RGB_MATRIX_EXTENDED, 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 // TODO: Remove once ARM has a way to configure EECONFIG_HANDEDNESS
// within the emulated eeprom via dfu-util or another tool // within the emulated eeprom via dfu-util or another tool
#if defined INIT_EE_HANDS_LEFT #if defined INIT_EE_HANDS_LEFT

359
quantum/oryx.c
View File

@@ -1,253 +1,180 @@
#include "oryx.h" #include "oryx.h"
#include "eeprom.h" #include "eeprom.h"
#include <string.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) { 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 command = data[0];
uint8_t *param = &(data[1]); uint8_t *param = &data[1];
uint8_t cmd_index = 0;
switch (command) { switch (command) {
case ORYX_GET_LAYER: case ORYX_CMD_GET_FW_VERSION: {
oryx_layer_event(); uint8_t event[RAW_EPSIZE];
return true; uint8_t fw_version_size = sizeof(FIRMWARE_VERSION);
case ORYX_CMD_LIVE_TRAINING: { uint8_t stop[1];
uint8_t event[4];
switch (param[0]) { // 0 for querying, 1 for off, 2 for on event[0] = ORYX_EVT_GET_FW_VERSION;
case 0: stop[0] = ORYX_STOP_BIT;
memcpy(event + 1, FIRMWARE_VERSION, fw_version_size);
memcpy(event + fw_version_size, stop, 1);
raw_hid_send(event, RAW_EPSIZE);
break; break;
case 1: }
oryx_state_live_training_enabled = false;
case ORYX_CMD_PAIRING_INIT:
pairing_init_handler();
store_pairing_sequence(&keyboard_pairing_sequence[0]);
break; break;
case 2:
oryx_state_live_training_enabled = true; 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;
}
pairing_validate_handler();
break; break;
default: }
webusb_error(WEBUSB_STATUS_UNKNOWN_COMMAND); }
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);
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;
}
}
eeprom_update_block(stored_sequences, (uint8_t *)EECONFIG_SIZE, PAIRING_STORAGE_SIZE);
return true; return true;
}
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[0] = WEBUSB_STATUS_OK; event[event_index++] = ORYX_STOP_BIT;
event[1] = ORYX_EVT_LIVE_TRAINING; rawhid_state.pairing = true;
event[2] = oryx_state_live_training_enabled; raw_hid_send(event, RAW_EPSIZE);
event[3] = WEBUSB_STOP_BIT; }
webusb_send(event, sizeof(event));
return true; void pairing_validate_handler() {
bool valid = true;
uint8_t event[RAW_EPSIZE];
for (uint8_t i = 0; i < PAIRING_SEQUENCE_SIZE; i++) {
if (keyboard_pairing_sequence[i].row != host_pairing_sequence[i].row) {
valid = false;
break;
} }
#ifdef DYNAMIC_KEYMAP_ENABLE if (keyboard_pairing_sequence[i].col != host_pairing_sequence[i].col) {
case ORYX_CMD_LIVE_UPDATE_GET_KEYCODE: { valid = false;
uint8_t event[5]; break;
// 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: { if (valid == true) {
uint8_t event[3]; event[0] = ORYX_EVT_PAIRING_SUCCESS;
dynamic_keymap_reset(); rawhid_state.paired = true;
event[0] = WEBUSB_STATUS_OK;
event[1] = ORYX_EVT_LIVE_UPDATE_KEYMAP_RESET; } else {
event[2] = WEBUSB_STOP_BIT; event[0] = ORYX_EVT_PAIRING_FAILED;
webusb_send(event, sizeof(event)); rawhid_state.paired = false;
return true;
} }
case ORYX_CMD_LIVE_UPDATE_GET_BUFFER: { event[1] = ORYX_STOP_BIT;
uint16_t offset = (param[0] << 8) | param[1]; rawhid_state.pairing = false;
uint16_t size = param[2]; // size <= 28 raw_hid_send(event, sizeof(event));
uint8_t event[size+3]; }
uint8_t i;
dynamic_keymap_get_buffer(offset, size, &param[3]); keypos_t get_random_keypos(void) {
event[0] = WEBUSB_STATUS_OK; uint8_t col = rand() % MATRIX_COLS;
event[1] = ORYX_EVT_LIVE_UPDATE_GET_BUFFER; uint8_t row = rand() % MATRIX_ROWS;
for (i = 0; i < size; i++) { keypos_t pos = {.col = col, .row = row};
event[i+2] = param[i];
if (keymap_key_to_keycode(0, pos) != KC_NO) {
return pos;
} else {
return get_random_keypos();
} }
event[i+2] = WEBUSB_STOP_BIT; }
webusb_send(event, sizeof(event));
return true; void create_pairing_code(void) {
} for (uint8_t i = 0; i < PAIRING_SEQUENCE_SIZE; i++) {
case ORYX_CMD_LIVE_UPDATE_SET_BUFFER: { keypos_t pos = get_random_keypos();
uint16_t offset = (param[0] << 8) | param[1]; keyboard_pairing_sequence[i] = pos;
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;
}
#endif
default:
return webusb_receive_kb(data, length);
} }
} }
void pairing_key_input_event(void) {
uint8_t event[RAW_EPSIZE];
event[0] = ORYX_EVT_PAIRING_KEY_INPUT;
raw_hid_send(event, sizeof(event));
}
void oryx_layer_event(void) { void oryx_layer_event(void) {
uint8_t layer; uint8_t layer;
uint8_t event[4]; uint8_t event[RAW_EPSIZE];
layer = get_highest_layer(layer_state); layer = get_highest_layer(layer_state);
#ifdef WEBUSB_ENABLE event[0] = ORYX_EVT_LAYER;
event[0] = WEBUSB_STATUS_OK; event[1] = layer;
event[1] = ORYX_EVT_LAYER; event[2] = ORYX_STOP_BIT;
event[2] = layer; raw_hid_send(event, sizeof(event));
event[3] = WEBUSB_STOP_BIT;
webusb_send(event, sizeof(event));
#endif
} }
bool is_oryx_live_training_enabled(void) { return (oryx_state_live_training_enabled && webusb_state.paired); }
bool process_record_oryx(uint16_t keycode, keyrecord_t *record) { bool process_record_oryx(uint16_t keycode, keyrecord_t *record) {
if(is_oryx_live_training_enabled()) { // In pairing mode, key events are absorbed, and the host pairing sequence is filled.
uint8_t event[5]; // Once filled, the keyboard and host sequence are compaired, pairing state set to false
event[0] = WEBUSB_STATUS_OK; // and the proper pairing validation event is sent to the host
event[1] = record->event.pressed ? ORYX_EVT_KEYDOWN : ORYX_EVT_KEYUP; if (rawhid_state.pairing == true) {
event[2] = record->event.key.col; // The host pairing sequence is filled on key up only
event[3] = record->event.key.row; if (!record->event.pressed) {
event[4] = WEBUSB_STOP_BIT; if (pairing_input_index < PAIRING_SEQUENCE_SIZE) {
webusb_send(event, sizeof(event)); host_pairing_sequence[pairing_input_index++] = record->event.key;
pairing_key_input_event();
} }
if (keycode == WEBUSB_PAIR && record->event.pressed) { if (pairing_input_index == PAIRING_SEQUENCE_SIZE) {
webusb_state.pairing ^= true; rawhid_state.pairing = false;
return true; pairing_input_index = 0;
pairing_validate_handler();
} }
#ifdef DYNAMIC_KEYMAP_ENABLE
switch (keycode) {
case MACRO00 ... MACRO15:
if (record->event.pressed) {
dynamic_keymap_macro_send(keycode - MACRO00);
} }
return false; return false;
} }
#endif // While paired, the keyboard sends keystrokes positions to the host
if (rawhid_state.paired == true) {
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; return true;
} }
void layer_state_set_oryx(layer_state_t state) { void layer_state_set_oryx(layer_state_t state) {
if(is_oryx_live_training_enabled()) { if (rawhid_state.paired) {
uint8_t event[4]; uint8_t event[RAW_EPSIZE];
event[0] = WEBUSB_STATUS_OK; event[0] = ORYX_EVT_LAYER;
event[1] = ORYX_EVT_LAYER; event[1] = get_highest_layer(state);
event[2] = get_highest_layer(state); event[2] = ORYX_STOP_BIT;
event[3] = WEBUSB_STOP_BIT; raw_hid_send(event, sizeof(event));
webusb_send(event, sizeof(event));
} }
} }
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 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();
}
#endif
}

103
quantum/oryx.h
View File

@@ -1,82 +1,61 @@
#pragma once #pragma once
#include "quantum.h" #include "quantum.h"
#include "webusb.h" #include "raw_hid.h"
#ifndef WEBUSB_ENABLE #ifndef RAW_ENABLE
# error "WebUSB needs to be enabled, please enable it!" # error "Raw hid needs to be enabled, please enable it!"
#endif
#ifndef RAW_EPSIZE
# define RAW_EPSIZE 32
#endif #endif
// enum Oryx_Status_code { #define ORYX_STOP_BIT -2
// PLACEHOLDER = WEBUSB_STATUS_SAFE_RANGE, #define PAIRING_BLINK_STEPS 512
// } #define PAIRING_BLINK_END PAIRING_BLINK_STEPS * 60
#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 { enum Oryx_Command_Code {
ORYX_GET_LAYER = WEBUSB_CMD_SAFE_RANGE, ORYX_CMD_GET_FW_VERSION,
ORYX_CMD_LIVE_TRAINING, ORYX_CMD_PAIRING_INIT,
ORYX_CMD_LIVE_UPDATE_GET_KEYCODE, ORYX_CMD_PAIRING_VALIDATE,
ORYX_CMD_LIVE_UPDATE_SET_KEYCODE, ORYX_CMD_DISCONNECT,
ORYX_CMD_LIVE_UPDATE_KEYMAP_RESET, ORYX_GET_LAYER,
ORYX_CMD_LIVE_UPDATE_GET_BUFFER,
ORYX_CMD_LIVE_UPDATE_SET_BUFFER,
ORYX_CMD_LIVE_UPDATE_GET_LAYER_COUNT,
ORYX_CMD_LIVE_UPDATE_GET_MACRO_COUNT,
ORYX_CMD_LIVE_UPDATE_GET_MACRO_BUFFER_SIZE,
ORYX_CMD_LIVE_UPDATE_GET_MACRO_BUFFER,
ORYX_CMD_LIVE_UPDATE_SET_MACRO_BUFFER,
ORYX_CMD_LIVE_UPDATE_MACRO_RESET,
ORYX_CMD_LIVE_UPDATE_EEPROM_RESET,
ORYX_CMD_LIVE_UPDATE_KEYBOARD_RESET,
}; };
enum Oryx_Event_Code { enum Oryx_Event_Code {
ORYX_EVT_LAYER = WEBUSB_EVT_SAFE_RANGE, ORYX_EVT_GET_FW_VERSION,
ORYX_EVT_LIVE_TRAINING, ORYX_EVT_PAIRING_INPUT,
ORYX_EVT_LIVE_UPDATE_GET_KEYCODE, ORYX_EVT_PAIRING_KEY_INPUT,
ORYX_EVT_LIVE_UPDATE_SET_KEYCODE, ORYX_EVT_PAIRING_FAILED,
ORYX_EVT_LIVE_UPDATE_KEYMAP_RESET, ORYX_EVT_PAIRING_SUCCESS,
ORYX_EVT_LIVE_UPDATE_GET_BUFFER, ORYX_EVT_LAYER,
ORYX_EVT_LIVE_UPDATE_SET_BUFFER,
ORYX_EVT_LIVE_UPDATE_GET_LAYER_COUNT,
ORYX_EVT_LIVE_UPDATE_GET_MACRO_COUNT,
ORYX_EVT_LIVE_UPDATE_GET_MACRO_BUFFER_SIZE,
ORYX_EVT_LIVE_UPDATE_GET_MACRO_BUFFER,
ORYX_EVT_LIVE_UPDATE_SET_MACRO_BUFFER,
ORYX_EVT_LIVE_UPDATE_MACRO_RESET,
ORYX_EVT_LIVE_UPDATE_EEPROM_RESET,
ORYX_EVT_LIVE_UPDATE_KEYBOARD_RESET,
ORYX_EVT_KEYDOWN, ORYX_EVT_KEYDOWN,
ORYX_EVT_KEYUP, 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; 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_key_input_event(void);
void pairing_failed_event(void);
void pairing_succesful_event(void);
void oryx_layer_event(void); void oryx_layer_event(void);
bool is_oryx_live_training_enabled(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 layer_state_set_oryx(layer_state_t state);
void eeconfig_init_oryx(void);
void matrix_init_oryx(void);

16
quantum/quantum.c
View File

@@ -412,7 +412,6 @@ bool process_record_quantum(keyrecord_t *record) {
} }
} }
return process_action_kb(record); return process_action_kb(record);
} }
@@ -442,21 +441,19 @@ void matrix_scan_quantum() {
matrix_scan_kb(); matrix_scan_kb();
} }
#ifdef WEBUSB_ENABLE #ifdef WEBUSB_ENABLE
__attribute__((weak)) bool webusb_receive_user(uint8_t *data, uint8_t length) { return false; } __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); } return false;
}
__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) { 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); return webusb_receive_kb(data, length);
# endif
} }
#endif #endif
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Override these functions in your keymap file to play different tunes on // Override these functions in your keymap file to play different tunes on
// different events such as startup and bootloader jump // different events such as startup and bootloader jump
@@ -465,7 +462,6 @@ __attribute__((weak)) void startup_user() {}
__attribute__((weak)) void shutdown_user() {} __attribute__((weak)) void shutdown_user() {}
void suspend_power_down_quantum(void) { void suspend_power_down_quantum(void) {
suspend_power_down_kb(); suspend_power_down_kb();
#ifndef NO_SUSPEND_POWER_DOWN #ifndef NO_SUSPEND_POWER_DOWN

25
tmk_core/protocol/chibios/usb_main.c
View File

@@ -49,6 +49,14 @@
extern keymap_config_t keymap_config; extern keymap_config_t keymap_config;
#endif #endif
#ifdef RAW_ENABLE
# include "raw_hid.h"
#endif
#ifdef ORYX_ENABLE
# include "oryx.h"
#endif
#ifdef WEBUSB_ENABLE #ifdef WEBUSB_ENABLE
# include "webusb.h" # include "webusb.h"
#endif #endif
@@ -176,7 +184,6 @@ static const USBEndpointConfig shared_ep_config = {
}; };
#endif #endif
#ifdef WEBUSB_ENABLE #ifdef WEBUSB_ENABLE
/** Microsoft OS 2.0 Descriptor. This is used by Windows to select the USB driver for the device. /** Microsoft OS 2.0 Descriptor. This is used by Windows to select the USB driver for the device.
* *
@@ -1145,7 +1152,15 @@ void raw_hid_send(uint8_t *data, uint8_t length) {
if (length != RAW_EPSIZE) { if (length != RAW_EPSIZE) {
return; 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); chnWrite(&drivers.raw_driver.driver, data, length);
# endif
} }
__attribute__((weak)) void raw_hid_receive(uint8_t *data, uint8_t length) { __attribute__((weak)) void raw_hid_receive(uint8_t *data, uint8_t length) {
@@ -1169,15 +1184,15 @@ void raw_hid_task(void) {
#ifdef WEBUSB_ENABLE #ifdef WEBUSB_ENABLE
void webusb_send(uint8_t *data, uint8_t length) { void webusb_send(uint8_t *data, uint8_t length) {
if(chnWriteTimeout(&drivers.webusb_driver.driver, data, length, TIME_IMMEDIATE) != length){ if (chnWriteTimeout(&drivers.webusb_driver.driver, data, length, TIME_IMMEDIATE) != length) {
webusb_state.paired = false; webusb_state.paired = false;
webusb_state.pairing = false; webusb_state.pairing = false;
} }
} }
// Users should #include "raw_hid.h" in their own code // Users should #include "raw_hid.h" in their own code
// and implement this function there. Leave this as weak linkage // and implement this function there. Leave this as weak linkage
// so users can opt to not handle data coming in. // so users can opt to not handle data coming in.
void webusb_task(void) { void webusb_task(void) {
uint8_t buffer[WEBUSB_EPSIZE]; uint8_t buffer[WEBUSB_EPSIZE];

9
tmk_core/protocol/lufa/lufa.c
View File

@@ -161,7 +161,10 @@ void raw_hid_send(uint8_t *data, uint8_t length) {
// Check to see if the host is ready to accept another packet // Check to see if the host is ready to accept another packet
if (Endpoint_IsINReady()) { if (Endpoint_IsINReady()) {
// Write data // Write data
Endpoint_Write_Stream_LE(data, RAW_EPSIZE, NULL); if (Endpoint_Write_Stream_LE(data, RAW_EPSIZE, NULL)) {
rawhid_state.pairing = false;
rawhid_state.paired = false;
}
// Finalize the stream transfer to send the last packet // Finalize the stream transfer to send the last packet
Endpoint_ClearIN(); Endpoint_ClearIN();
} }
@@ -279,7 +282,7 @@ void webusb_send(uint8_t *data, uint8_t length) {
Endpoint_SelectEndpoint(WEBUSB_IN_EPNUM); Endpoint_SelectEndpoint(WEBUSB_IN_EPNUM);
if(Endpoint_Write_Stream_LE(data, length, NULL)) { if (Endpoint_Write_Stream_LE(data, length, NULL)) {
// Stream failed to complete, resetting WEBUSB's state // Stream failed to complete, resetting WEBUSB's state
webusb_state.paired = false; webusb_state.paired = false;
webusb_state.pairing = false; webusb_state.pairing = false;
@@ -292,7 +295,6 @@ static void webusb_task(void) {
uint8_t data[WEBUSB_EPSIZE]; uint8_t data[WEBUSB_EPSIZE];
bool data_read = false; bool data_read = false;
// Device must be connected and configured for the task to run // Device must be connected and configured for the task to run
if (USB_DeviceState != DEVICE_STATE_Configured) return; if (USB_DeviceState != DEVICE_STATE_Configured) return;
@@ -896,7 +898,6 @@ static void send_consumer(uint16_t data) {
#endif #endif
} }
static void send_programmable_button(uint32_t data) { static void send_programmable_button(uint32_t data) {
#ifdef PROGRAMMABLE_BUTTON_ENABLE #ifdef PROGRAMMABLE_BUTTON_ENABLE
static report_programmable_button_t r; static report_programmable_button_t r;