219 lines
6.7 KiB
C
219 lines
6.7 KiB
C
#include "oryx.h"
|
|
#include "eeprom.h"
|
|
|
|
rawhid_state_t rawhid_state = {.pairing = false, .paired = false};
|
|
|
|
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_CMD_GET_FW_VERSION: {
|
|
uint8_t event[RAW_EPSIZE];
|
|
uint8_t fw_version_size = sizeof(FIRMWARE_VERSION);
|
|
uint8_t stop[1];
|
|
|
|
event[0] = ORYX_EVT_GET_FW_VERSION;
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
pairing_validate_eeprom_handler();
|
|
break;
|
|
|
|
case ORYX_SET_LAYER:
|
|
if(rawhid_state.paired == true) {
|
|
layer_clear();
|
|
layer_on(param[0]);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void pairing_validate_eeprom_handler(void) {
|
|
bool match = false;
|
|
uint8_t event[RAW_EPSIZE];
|
|
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);
|
|
match = true;
|
|
|
|
if (match == 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));
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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 compare_sequences(keypos_t a[PAIRING_SEQUENCE_SIZE], keypos_t b[PAIRING_SEQUENCE_SIZE]) {
|
|
bool valid = true;
|
|
for (uint8_t i = 0; i < PAIRING_SEQUENCE_SIZE; i++) {
|
|
if (a[i].row != b[i].row) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
if (a[i].col != b[i].col) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
}
|
|
return valid;
|
|
}
|
|
|
|
void pairing_validate_handler() {
|
|
|
|
uint8_t event[RAW_EPSIZE];
|
|
bool valid = compare_sequences(keyboard_pairing_sequence, host_pairing_sequence);
|
|
|
|
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));
|
|
}
|
|
|
|
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();
|
|
}
|
|
}
|
|
|
|
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 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) {
|
|
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 == true) {
|
|
// 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;
|
|
pairing_key_input_event();
|
|
}
|
|
wait_ms(1000);
|
|
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 == 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;
|
|
}
|
|
|
|
void layer_state_set_oryx(layer_state_t state) {
|
|
if (rawhid_state.paired) {
|
|
wait_ms(50);
|
|
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));
|
|
}
|
|
}
|