# List C source files here. (C dependencies are automatically generated.) | # List C source files here. (C dependencies are automatically generated.) | ||||
SRC = tmk.c \ | SRC = tmk.c \ | ||||
key_process.c \ | key_process.c \ | ||||
usb.c \ | |||||
usb_keyboard.c \ | usb_keyboard.c \ | ||||
usb_mouse.c \ | usb_mouse.c \ | ||||
usb_debug.c \ | usb_debug.c \ | ||||
usb.c \ | |||||
jump_bootloader.c \ | jump_bootloader.c \ | ||||
print.c | print.c | ||||
SRC += $(TARGET_SRC) | SRC += $(TARGET_SRC) |
*/ | */ | ||||
#include <stdbool.h> | #include <stdbool.h> | ||||
#include <avr/pgmspace.h> | #include <avr/pgmspace.h> | ||||
#include "usb_keyboard.h" | |||||
#include "matrix.h" | #include "matrix.h" | ||||
#include "keymap.h" | #include "keymap.h" | ||||
#include "usb_keyboard.h" | |||||
#include "print.h" | |||||
int current_layer = 0; | |||||
bool key_sent = false; | |||||
#define FN_KEYCODE(fn) (pgm_read_byte(&fn_keycode[(fn)])) | |||||
#define FN_LAYER(fn) (pgm_read_byte(&fn_layer[(fn)])) | |||||
#define KEYMAPS(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)])) | |||||
static int current_layer = 0; | |||||
static bool layer_used = false; | |||||
static int onbit(uint8_t bits); | |||||
/* | /* | ||||
* Layer0(Default Layer) | * Layer0(Default Layer) | ||||
* Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel | * Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel | ||||
*/ | */ | ||||
/* keycode sent when Fn key released without using layer keys. */ | |||||
static const uint8_t PROGMEM FnKey[] = { | |||||
KB_NO, // this must be KB_NO. (not used) | |||||
/* keycode to sent when Fn key released without using layer keys. */ | |||||
static const uint8_t PROGMEM fn_keycode[] = { | |||||
KB_NO, // FN_0 | |||||
KB_NO, // FN_1 | KB_NO, // FN_1 | ||||
KB_RALT, // FN_2 | KB_RALT, // FN_2 | ||||
KB_SCOLON, // FN_3 | KB_SCOLON, // FN_3 | ||||
KB_NO, // FN_4 | |||||
KB_NO, // FN_5 | |||||
KB_NO, // FN_6 | |||||
KB_NO, // FN_7 | |||||
}; | }; | ||||
/* layer to change into while Fn key pressed */ | |||||
static const int PROGMEM fn_layer[] = { 0, 1, 2, 3, 0, 0, 0, 0 }; | |||||
static const uint8_t PROGMEM Keymap[][MATRIX_ROWS][MATRIX_COLS] = { | |||||
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||||
/* plain keymap | /* plain keymap | ||||
{ | { | ||||
{ KB_2, KB_Q, KB_W, KB_S, KB_A, KB_Z, KB_X, KB_C }, | { KB_2, KB_Q, KB_W, KB_S, KB_A, KB_Z, KB_X, KB_C }, | ||||
}; | }; | ||||
uint8_t get_keycode(int layer, int row, int col) | |||||
uint8_t keymap_get_keycode(int row, int col) | |||||
{ | { | ||||
if (row >= MATRIX_ROWS) | |||||
return KB_NO; | |||||
if (col >= MATRIX_COLS) | |||||
return KB_NO; | |||||
return pgm_read_byte(&Keymap[layer][row][col]); | |||||
return keymap_get_keycodel(current_layer, row, col); | |||||
} | } | ||||
int get_layer(void) { | |||||
// keep modifier state when Fn key pressed | |||||
static uint8_t preserved_modifiers = 0; | |||||
int layer = 0; | |||||
uint8_t modifiers = 0; | |||||
for (int row = 0; row < MATRIX_ROWS; row++) { | |||||
for (int col = 0; col < MATRIX_ROWS; col++) { | |||||
if (matrix[row] & 1<<col) continue; // NOT pressed | |||||
uint8_t code = get_keycode(0, row, col); | |||||
uint8_t keymap_get_keycodel(int layer, int row, int col) | |||||
{ | |||||
uint8_t code = KEYMAPS(layer, row, col); | |||||
// normal key or mouse key | |||||
if ((KB_A <= code && code <= KP_HEXADECIMAL) || | |||||
(MS_UP <= code && code <= MS_WH_RIGHT)) | |||||
layer_used = true; | |||||
return code; | |||||
} | |||||
// NOT change current_layer when one more Fn keys pressed | |||||
// when other than Fn key pressed | |||||
if (code == FN_1) layer = layer ? current_layer : 1; | |||||
else if (code == FN_2) layer = layer ? current_layer : 2; | |||||
else if (code == FN_3) layer = layer ? current_layer : 3; | |||||
else if (code == FN_4) layer = layer ? current_layer : 4; | |||||
else if (KB_LCTRL <= code && code <= KB_RGUI) | |||||
modifiers |= 1<<(code & 0x07); | |||||
else // other_key_pressed | |||||
layer = current_layer; | |||||
} | |||||
} | |||||
inline | |||||
int keymap_get_layer(void) { | |||||
return current_layer; | |||||
} | |||||
// TODO: this logic should go anywhere | |||||
// TODO: need timeout for key_sent | |||||
// send key when Fn key reloeased without used | |||||
if (layer != current_layer) { | |||||
if (layer == 0 && !key_sent) { | |||||
uint8_t code = pgm_read_byte(&FnKey[current_layer]); | |||||
if (code) { | |||||
// send modifiers when Fn key pressed. | |||||
keyboard_modifier_keys = preserved_modifiers; | |||||
for (int i = 0; i < 6; i++) keyboard_keys[i] = KB_NO; | |||||
inline | |||||
int keymap_set_layer(int layer) { | |||||
current_layer = layer; | |||||
return current_layer; | |||||
} | |||||
if (KB_LCTRL <= code && code <= KB_RGUI) { | |||||
keyboard_modifier_keys |= 1<<(code & 0x07); | |||||
} else { | |||||
void keymap_fn_proc(int fn_bits) { | |||||
// layer switching | |||||
static int last_bits = 0; | |||||
static uint8_t last_mod = 0; | |||||
if (usb_keyboard_has_key() || fn_bits == last_bits) { | |||||
// do nothing during press other than Fn key | |||||
return; | |||||
} else if (fn_bits == 0) { | |||||
// send key when Fn key is released without using the layer | |||||
if (!layer_used) { | |||||
uint8_t code = FN_KEYCODE(onbit(last_bits)); | |||||
if (code != KB_NO) { | |||||
if (KB_LCTRL <= code && code <= KB_RGUI) { | |||||
keyboard_modifier_keys = last_mod | 1<<(code & 0x07); | |||||
} else { | |||||
keyboard_keys[0] = code; | keyboard_keys[0] = code; | ||||
keyboard_modifier_keys = last_mod; | |||||
} | } | ||||
usb_keyboard_send(); | usb_keyboard_send(); | ||||
usb_keyboard_print(); | |||||
usb_keyboard_clear(); | |||||
} | } | ||||
} | } | ||||
current_layer = layer; | |||||
key_sent = false; | |||||
preserved_modifiers = modifiers; | |||||
last_bits = 0; | |||||
last_mod = 0; | |||||
layer_used = false; | |||||
keymap_set_layer(0); // default layer | |||||
print("layer default: "); phex(current_layer); print("\n"); | |||||
} else if ((fn_bits & (fn_bits - 1)) == 0) { | |||||
// switch layer when just one Fn Key is pressed | |||||
last_bits = fn_bits; | |||||
last_mod = keyboard_modifier_keys; | |||||
layer_used = false; | |||||
keymap_set_layer(FN_LAYER(onbit(fn_bits))); | |||||
print("layer: "); phex(current_layer); print("\n"); | |||||
print("last_bits: "); phex(last_bits); print("\n"); | |||||
print("last_mod: "); phex(last_mod); print("\n"); | |||||
} | } | ||||
} | |||||
return current_layer; | |||||
static int onbit(uint8_t bits) { | |||||
int n = 0; | |||||
if (bits >> 4) { bits >>= 4; n += 4;} | |||||
if (bits >> 2) { bits >>= 2; n += 2;} | |||||
if (bits >> 1) { bits >>= 1; n += 1;} | |||||
return n; | |||||
} | } |
#include <stdint.h> | #include <stdint.h> | ||||
#include <stdbool.h> | #include <stdbool.h> | ||||
#include "usb_keycodes.h" | #include "usb_keycodes.h" | ||||
#define MATRIX_ROWS 8 | |||||
#define MATRIX_COLS 8 | |||||
extern int current_layer; | |||||
extern bool key_sent; | |||||
int get_layer(void); | |||||
uint8_t get_keycode(int layer, int row, int col); | |||||
#include "keymap_skel.h" | |||||
#endif | #endif |
static uint8_t _matrix1[MATRIX_ROWS]; | static uint8_t _matrix1[MATRIX_ROWS]; | ||||
static bool matrix_has_ghost_in_row(int row); | |||||
inline | |||||
int matrix_rows(void) { | |||||
return MATRIX_ROWS; | |||||
} | |||||
inline | |||||
int matrix_cols(void) { | |||||
return MATRIX_COLS; | |||||
} | |||||
// this must be called once before matrix_scan. | // this must be called once before matrix_scan. | ||||
void matrix_init(void) | void matrix_init(void) | ||||
{ | { | ||||
matrix_prev = _matrix1; | matrix_prev = _matrix1; | ||||
} | } | ||||
uint8_t matrix_scan(void) | |||||
int matrix_scan(void) | |||||
{ | { | ||||
uint8_t *tmp; | uint8_t *tmp; | ||||
return false; | return false; | ||||
} | } | ||||
inline | |||||
bool matrix_has_ghost(void) { | bool matrix_has_ghost(void) { | ||||
return false; | return false; | ||||
} | } | ||||
bool matrix_has_ghost_in_row(uint8_t row) { | |||||
inline | |||||
uint16_t matrix_get_row(int row) { | |||||
return matrix[row]; | |||||
} | |||||
void matrix_print(void) { | |||||
print("\nr/c 01234567\n"); | |||||
for (int row = 0; row < matrix_rows(); row++) { | |||||
phex(row); print(": "); | |||||
pbin_reverse(matrix_get_row(row)); | |||||
if (matrix_has_ghost_in_row(row)) { | |||||
print(" <ghost"); | |||||
} | |||||
print("\n"); | |||||
} | |||||
} | |||||
inline | |||||
static bool matrix_has_ghost_in_row(int row) { | |||||
return false; | return false; | ||||
} | } |
#ifndef MATRIX_H | |||||
#define MATRIX_H 1 | |||||
#include <stdbool.h> | |||||
#include "matrix_skel.h" | |||||
#define MATRIX_ROWS 8 | |||||
#define MATRIX_COLS 8 | |||||
extern uint8_t *matrix; | |||||
extern uint8_t *matrix_prev; | |||||
#endif |
#include "usb_keyboard.h" | #include "usb_keyboard.h" | ||||
#include "usb_mouse.h" | #include "usb_mouse.h" | ||||
#include "print.h" | #include "print.h" | ||||
#include "matrix.h" | |||||
#include "matrix_skel.h" | |||||
#include "keymap.h" | #include "keymap.h" | ||||
#include "jump_bootloader.h" | #include "jump_bootloader.h" | ||||
#define MOUSE_DELAY_ACC 5 | #define MOUSE_DELAY_ACC 5 | ||||
static void print_matrix(void); | |||||
static void print_keys(void); | |||||
static void print_mouse(int8_t mouse_x, int8_t mouse_y, int8_t wheel_v, int8_t wheel_h); | |||||
void proc_matrix(void) { | void proc_matrix(void) { | ||||
static int mouse_repeat = 0; | static int mouse_repeat = 0; | ||||
bool modified = false; | bool modified = false; | ||||
bool has_ghost = false; | |||||
int layer = 0; | |||||
//bool has_ghost = false; | |||||
int key_index = 0; | int key_index = 0; | ||||
uint8_t mouse_btn = 0; | uint8_t mouse_btn = 0; | ||||
int8_t mouse_x = 0; | int8_t mouse_x = 0; | ||||
int8_t mouse_y = 0; | int8_t mouse_y = 0; | ||||
int8_t mouse_wheel = 0; | int8_t mouse_wheel = 0; | ||||
int8_t mouse_hwheel = 0; | int8_t mouse_hwheel = 0; | ||||
int fn_bits = 0; | |||||
matrix_scan(); | |||||
modified = matrix_is_modified(); | |||||
has_ghost = matrix_has_ghost(); | |||||
layer = get_layer(); | |||||
matrix_scan(); | |||||
modified = matrix_is_modified(); | |||||
// print matrix state for debug | |||||
if (modified) { | |||||
print_matrix(); | |||||
if (modified) { | |||||
matrix_print(); | |||||
// LED flash for debug | |||||
LED_CONFIG; | |||||
LED_ON; | |||||
} | |||||
// LED flash for debug | |||||
LED_CONFIG; | |||||
LED_ON; | |||||
} | |||||
keyboard_modifier_keys = 0; | |||||
for (int i = 0; i < 6; i++) keyboard_keys[i] = KB_NO; | |||||
key_index = 0; | |||||
mouse_btn = 0; | |||||
mouse_x = 0; | |||||
mouse_y = 0; | |||||
mouse_wheel = 0; | |||||
mouse_hwheel = 0; | |||||
// convert matrix state to HID report | |||||
for (int row = 0; row < MATRIX_ROWS; row++) { | |||||
for (int col = 0; col < MATRIX_COLS; col++) { | |||||
if (matrix[row] & 1<<col) continue; | |||||
uint8_t code = get_keycode(layer, row, col); | |||||
if (code == KB_NO) { | |||||
continue; | |||||
} else if (KB_LCTRL <= code && code <= KB_RGUI) { | |||||
// modifier keys(0xE0-0xE7) | |||||
keyboard_modifier_keys |= 1<<(code & 0x07); | |||||
} else if (code >= MS_UP) { | |||||
// mouse | |||||
if (code == MS_UP) mouse_y -= MOUSE_MOVE_UNIT + (mouse_repeat < 50 ? mouse_repeat/5 : 10); | |||||
if (code == MS_DOWN) mouse_y += MOUSE_MOVE_UNIT + (mouse_repeat < 50 ? mouse_repeat/5 : 10); | |||||
if (code == MS_LEFT) mouse_x -= MOUSE_MOVE_UNIT + (mouse_repeat < 50 ? mouse_repeat/5 : 10); | |||||
if (code == MS_RIGHT) mouse_x += MOUSE_MOVE_UNIT + (mouse_repeat < 50 ? mouse_repeat/5 : 10); | |||||
if (code == MS_BTN1) mouse_btn |= 1<<0; | |||||
if (code == MS_BTN2) mouse_btn |= 1<<1; | |||||
if (code == MS_BTN3) mouse_btn |= 1<<2; | |||||
if (code == MS_BTN4) mouse_btn |= 1<<3; | |||||
if (code == MS_BTN5) mouse_btn |= 1<<4; | |||||
if (code == MS_WH_UP) mouse_wheel += 1; | |||||
if (code == MS_WH_DOWN) mouse_wheel -= 1; | |||||
if (code == MS_WH_LEFT) mouse_hwheel -= 1; | |||||
if (code == MS_WH_RIGHT) mouse_hwheel += 1; | |||||
} else { | |||||
// normal keys | |||||
if (key_index < 6) | |||||
keyboard_keys[key_index] = code; | |||||
key_index++; | |||||
if (matrix_has_ghost()) { | |||||
// should send error? | |||||
print("matrix has ghost!!\n"); | |||||
return; | |||||
} | |||||
usb_keyboard_clear(); | |||||
for (int row = 0; row < matrix_rows(); row++) { | |||||
for (int col = 0; col < matrix_cols(); col++) { | |||||
if (matrix_get_row(row) & 1<<col) continue; | |||||
uint8_t code = keymap_get_keycode(row, col); | |||||
if (code == KB_NO) { | |||||
code = keymap_get_keycodel(0, row, col); | |||||
if (FN_0 <= code && code <= FN_7) { | |||||
fn_bits |= 1<<(code - FN_0); | |||||
} | } | ||||
} else if (KB_LCTRL <= code && code <= KB_RGUI) { | |||||
// modifier keys(0xE0-0xE7) | |||||
keyboard_modifier_keys |= 1<<(code & 0x07); | |||||
} else if (code >= MS_UP) { | |||||
// mouse | |||||
if (code == MS_UP) mouse_y -= MOUSE_MOVE_UNIT + (mouse_repeat < 50 ? mouse_repeat/5 : 10); | |||||
if (code == MS_DOWN) mouse_y += MOUSE_MOVE_UNIT + (mouse_repeat < 50 ? mouse_repeat/5 : 10); | |||||
if (code == MS_LEFT) mouse_x -= MOUSE_MOVE_UNIT + (mouse_repeat < 50 ? mouse_repeat/5 : 10); | |||||
if (code == MS_RIGHT) mouse_x += MOUSE_MOVE_UNIT + (mouse_repeat < 50 ? mouse_repeat/5 : 10); | |||||
if (code == MS_BTN1) mouse_btn |= 1<<0; | |||||
if (code == MS_BTN2) mouse_btn |= 1<<1; | |||||
if (code == MS_BTN3) mouse_btn |= 1<<2; | |||||
if (code == MS_BTN4) mouse_btn |= 1<<3; | |||||
if (code == MS_BTN5) mouse_btn |= 1<<4; | |||||
if (code == MS_WH_UP) mouse_wheel += 1; | |||||
if (code == MS_WH_DOWN) mouse_wheel -= 1; | |||||
if (code == MS_WH_LEFT) mouse_hwheel -= 1; | |||||
if (code == MS_WH_RIGHT) mouse_hwheel += 1; | |||||
} else if (FN_0 <= code && code <= FN_7) { | |||||
fn_bits |= 1<<(code - FN_0); | |||||
} else { | |||||
// normal keys | |||||
if (key_index < 6) | |||||
keyboard_keys[key_index] = code; | |||||
key_index++; | |||||
} | } | ||||
} | } | ||||
} | |||||
keymap_fn_proc(fn_bits); | |||||
if (!has_ghost) { | |||||
// when 4 left modifier keys down | |||||
if (keyboard_modifier_keys == (MOD_LCTRL | MOD_LSHIFT | MOD_LALT | MOD_LGUI)) { | |||||
// cancel all keys | |||||
keyboard_modifier_keys = 0; | |||||
for (int i = 0; i < 6; i++) keyboard_keys[i] = KB_NO; | |||||
usb_keyboard_send(); | |||||
print("jump to bootloader...\n"); | |||||
_delay_ms(100); | |||||
jump_bootloader(); // not return | |||||
} | |||||
if (mouse_x || mouse_y || mouse_wheel || mouse_hwheel || mouse_btn != mouse_buttons) { | |||||
mouse_buttons = mouse_btn; | |||||
usb_mouse_move(mouse_x, mouse_y, mouse_wheel, mouse_hwheel); | |||||
print_mouse(mouse_x, mouse_y, mouse_wheel, mouse_hwheel); | |||||
key_sent = true; | |||||
// when 4 left modifier keys down | |||||
if (keyboard_modifier_keys == (MOD_LCTRL | MOD_LSHIFT | MOD_LALT | MOD_LGUI)) { | |||||
// cancel all keys | |||||
keyboard_modifier_keys = 0; | |||||
for (int i = 0; i < 6; i++) keyboard_keys[i] = KB_NO; | |||||
usb_keyboard_send(); | |||||
// acceleration | |||||
_delay_ms(MOUSE_DELAY_MS >> (mouse_repeat < MOUSE_DELAY_ACC ? mouse_repeat : MOUSE_DELAY_ACC)); | |||||
mouse_repeat++; | |||||
} else { | |||||
mouse_repeat = 0; | |||||
} | |||||
print("jump to bootloader...\n"); | |||||
_delay_ms(100); | |||||
jump_bootloader(); // not return | |||||
} | |||||
// send keys to host | |||||
if (modified) { | |||||
if (key_index > 6) { | |||||
//Rollover | |||||
} | |||||
usb_keyboard_send(); | |||||
if (keyboard_keys[0]) | |||||
key_sent = true; | |||||
print_keys(); | |||||
// LED flash for debug | |||||
LED_CONFIG; | |||||
LED_OFF; | |||||
} | |||||
} | |||||
} | |||||
if (mouse_x || mouse_y || mouse_wheel || mouse_hwheel || mouse_btn != mouse_buttons) { | |||||
mouse_buttons = mouse_btn; | |||||
usb_mouse_move(mouse_x, mouse_y, mouse_wheel, mouse_hwheel); | |||||
usb_mouse_print(mouse_x, mouse_y, mouse_wheel, mouse_hwheel); | |||||
static void print_matrix(void) { | |||||
print("\nr/c 01234567\n"); | |||||
for (int row = 0; row < MATRIX_ROWS; row++) { | |||||
phex(row); print(": "); | |||||
pbin_reverse(matrix[row]); | |||||
if (matrix_has_ghost_in_row(row)) { | |||||
print(" <ghost"); | |||||
} | |||||
print("\n"); | |||||
// acceleration | |||||
_delay_ms(MOUSE_DELAY_MS >> (mouse_repeat < MOUSE_DELAY_ACC ? mouse_repeat : MOUSE_DELAY_ACC)); | |||||
mouse_repeat++; | |||||
} else { | |||||
mouse_repeat = 0; | |||||
} | } | ||||
} | |||||
static void print_keys(void) { | |||||
print("\nkeys: "); | |||||
for (int i = 0; i < 6; i++) { phex(keyboard_keys[i]); print(" "); } | |||||
print("\n"); | |||||
print("mods: "); phex(keyboard_modifier_keys); print("\n"); | |||||
} | |||||
static void print_mouse(int8_t mouse_x, int8_t mouse_y, int8_t wheel_v, int8_t wheel_h) { | |||||
print("\nmouse_x y v h: "); | |||||
phex(mouse_x); print(" "); | |||||
phex(mouse_y); print(" "); | |||||
phex(wheel_v); print(" "); | |||||
phex(wheel_h); print("\n"); | |||||
print("buttons: "); phex(mouse_buttons); print("\n"); | |||||
// send keys to host | |||||
if (modified) { | |||||
if (key_index > 6) { | |||||
//Rollover | |||||
} | |||||
usb_keyboard_send(); | |||||
usb_keyboard_print(); | |||||
// LED flash for debug | |||||
LED_CONFIG; | |||||
LED_OFF; | |||||
} | |||||
} | } |
#ifndef KEY_PROCESS_H | #ifndef KEY_PROCESS_H | ||||
#define KEY_PROCESS_H 1 | #define KEY_PROCESS_H 1 | ||||
void proc_matrix(void); | void proc_matrix(void); | ||||
#endif | #endif |
#ifndef KEYMAP_SKEL_H | |||||
#define KEYMAP_SKEL_H 1 | |||||
#include <stdint.h> | |||||
#include <stdbool.h> | |||||
#include "usb_keycodes.h" | |||||
uint8_t keymap_get_keycode(int row, int col); | |||||
uint8_t keymap_get_keycodel(int layer, int row, int col); | |||||
int keymap_get_layer(void); | |||||
int keymap_set_layer(int layer); | |||||
/* process Fn keys. This.should be called every scan. */ | |||||
void keymap_fn_proc(int fn_bits); | |||||
#endif |
#ifndef MATRIX_H | |||||
#define MATRIX_H 1 | |||||
#include <stdbool.h> | |||||
extern uint8_t *matrix; | |||||
extern uint8_t *matrix_prev; | |||||
void matrix_init(void); | |||||
uint8_t matrix_scan(void); | |||||
bool matrix_is_modified(void); | |||||
bool matrix_has_ghost(void); | |||||
bool matrix_has_ghost_in_row(uint8_t row); | |||||
#endif |
#ifndef MATRIX_SKEL_H | |||||
#define MATRIX_SKEL_H 1 | |||||
#include <stdbool.h> | |||||
/* number of matrix rows */ | |||||
int matrix_rows(void); | |||||
/* number of matrix columns */ | |||||
int matrix_cols(void); | |||||
/* intialize matrix for scaning. should be called once. */ | |||||
void matrix_init(void); | |||||
/* scan all key states on matrix */ | |||||
int matrix_scan(void); | |||||
/* whether modified from previous scan. used after matrix_scan. */ | |||||
bool matrix_is_modified(void); | |||||
/* whether ghosting occur on matrix. */ | |||||
bool matrix_has_ghost(void); | |||||
/* matrix state on row */ | |||||
uint16_t matrix_get_row(int row); | |||||
/* print matrix for debug */ | |||||
void matrix_print(void); | |||||
#endif |
#include "usb_keyboard.h" | #include "usb_keyboard.h" | ||||
#include "usb_mouse.h" | #include "usb_mouse.h" | ||||
#include "print.h" | #include "print.h" | ||||
#include "matrix.h" | |||||
#include "matrix_skel.h" | |||||
#include "keymap.h" | #include "keymap.h" | ||||
#include "jump_bootloader.h" | #include "jump_bootloader.h" | ||||
#include <avr/interrupt.h> | #include <avr/interrupt.h> | ||||
#include <avr/pgmspace.h> | #include <avr/pgmspace.h> | ||||
#include "usb_keyboard.h" | #include "usb_keyboard.h" | ||||
#include "print.h" | |||||
static bool is_sent = false; | |||||
// which modifier keys are currently pressed | // which modifier keys are currently pressed | ||||
// 1=left ctrl, 2=left shift, 4=left alt, 8=left gui | // 1=left ctrl, 2=left shift, 4=left alt, 8=left gui | ||||
// 16=right ctrl, 32=right shift, 64=right alt, 128=right gui | // 16=right ctrl, 32=right shift, 64=right alt, 128=right gui | ||||
UEINTX = 0x3A; | UEINTX = 0x3A; | ||||
keyboard_idle_count = 0; | keyboard_idle_count = 0; | ||||
SREG = intr_state; | SREG = intr_state; | ||||
is_sent = true; | |||||
return 0; | return 0; | ||||
} | } | ||||
void usb_keyboard_init(void) { | |||||
usb_keyboard_clear(); | |||||
is_sent = false; | |||||
} | |||||
void usb_keyboard_clear(void) { | |||||
usb_keyboard_clear_key(); | |||||
usb_keyboard_clear_mod(); | |||||
} | |||||
void usb_keyboard_clear_key(void) { | |||||
for (int i = 0; i < 6; i++) keyboard_keys[i] = 0; | |||||
} | |||||
void usb_keyboard_clear_mod(void) { | |||||
keyboard_modifier_keys = 0; | |||||
} | |||||
bool usb_keyboard_is_sent(void) { | |||||
return is_sent; | |||||
} | |||||
bool usb_keyboard_has_key(void) { | |||||
uint8_t keys = 0; | |||||
for (int i = 0; i < 6; i++) keys |= keyboard_keys[i]; | |||||
return keys ? true : false; | |||||
} | |||||
bool usb_keyboard_has_mod(void) { | |||||
return keyboard_modifier_keys ? true : false; | |||||
} | |||||
void usb_keyboard_print(void) { | |||||
print("\nkeys: "); | |||||
for (int i = 0; i < 6; i++) { phex(keyboard_keys[i]); print(" "); } | |||||
print("\n"); | |||||
print("mods: "); phex(keyboard_modifier_keys); print("\n"); | |||||
} |
#define USB_KEYBOARD_H 1 | #define USB_KEYBOARD_H 1 | ||||
#include <stdint.h> | #include <stdint.h> | ||||
#include <stdbool.h> | |||||
#include "usb.h" | #include "usb.h" | ||||
#define KEYBOARD_SIZE 8 | #define KEYBOARD_SIZE 8 | ||||
#define KEYBOARD_BUFFER EP_DOUBLE_BUFFER | #define KEYBOARD_BUFFER EP_DOUBLE_BUFFER | ||||
// TODO: move to usb_keycodes.h ? | |||||
// modifier bits | // modifier bits | ||||
#define MOD_LCTRL (1<<0) | #define MOD_LCTRL (1<<0) | ||||
#define MOD_LSHIFT (1<<1) | #define MOD_LSHIFT (1<<1) | ||||
#define MOD_RGUI (1<<7) | #define MOD_RGUI (1<<7) | ||||
// TODO: change variable name: usb_keyboard_ or usb_kb_ | |||||
extern uint8_t keyboard_modifier_keys; | extern uint8_t keyboard_modifier_keys; | ||||
extern uint8_t keyboard_keys[6]; | extern uint8_t keyboard_keys[6]; | ||||
extern uint8_t keyboard_protocol; | extern uint8_t keyboard_protocol; | ||||
extern uint8_t keyboard_idle_config; | extern uint8_t keyboard_idle_config; | ||||
extern uint8_t keyboard_idle_count; | extern uint8_t keyboard_idle_count; | ||||
extern volatile uint8_t keyboard_leds; | |||||
extern volatile uint8_t keyboard_leds; // TODO: delete NOT USED? | |||||
int8_t usb_keyboard_press(uint8_t key, uint8_t modifier); | int8_t usb_keyboard_press(uint8_t key, uint8_t modifier); | ||||
int8_t usb_keyboard_send(void); | int8_t usb_keyboard_send(void); | ||||
void usb_keyboard_init(void); | |||||
void usb_keyboard_clear(void); | |||||
void usb_keyboard_clear_key(void); | |||||
void usb_keyboard_clear_mod(void); | |||||
bool usb_keyboard_is_sent(void); | |||||
bool usb_keyboard_has_key(void); | |||||
bool usb_keyboard_has_mod(void); | |||||
void usb_keyboard_print(void); | |||||
#endif | #endif |
KB_RGUI, /* 0x80 */ | KB_RGUI, /* 0x80 */ | ||||
/* extensions for internal use */ | /* extensions for internal use */ | ||||
FN_1 = 0xE8, | |||||
FN_0 = 0xE8, | |||||
FN_1, | |||||
FN_2, | FN_2, | ||||
FN_3, | FN_3, | ||||
FN_4, | FN_4, | ||||
FN_5, | |||||
FN_6, | |||||
FN_7, | |||||
MS_UP = 0xF0, | MS_UP = 0xF0, | ||||
MS_DOWN, | MS_DOWN, | ||||
MS_LEFT, | MS_LEFT, |
#include <avr/interrupt.h> | #include <avr/interrupt.h> | ||||
#include <util/delay.h> | #include <util/delay.h> | ||||
#include "usb_mouse.h" | #include "usb_mouse.h" | ||||
#include "print.h" | |||||
static bool is_sent = false; | |||||
// which buttons are currently pressed | // which buttons are currently pressed | ||||
uint8_t mouse_buttons=0; | uint8_t mouse_buttons=0; | ||||
UEINTX = 0x3A; | UEINTX = 0x3A; | ||||
SREG = intr_state; | SREG = intr_state; | ||||
is_sent = true; | |||||
return 0; | return 0; | ||||
} | } | ||||
void usb_mouse_clear(void) { | |||||
is_sent = false; | |||||
} | |||||
bool usb_mouse_is_sent(void) { | |||||
return is_sent; | |||||
} | |||||
void usb_mouse_print(int8_t mouse_x, int8_t mouse_y, int8_t wheel_v, int8_t wheel_h) { | |||||
print("mouse btn|x y v h: "); | |||||
phex(mouse_buttons); print("|"); | |||||
phex(mouse_x); print(" "); | |||||
phex(mouse_y); print(" "); | |||||
phex(wheel_v); print(" "); | |||||
phex(wheel_h); print("\n"); | |||||
} |
#define USB_MOUSE_H 1 | #define USB_MOUSE_H 1 | ||||
#include <stdint.h> | #include <stdint.h> | ||||
#include <stdbool.h> | |||||
#include "usb.h" | #include "usb.h" | ||||
int8_t usb_mouse_buttons(uint8_t left, uint8_t middle, uint8_t right); | int8_t usb_mouse_buttons(uint8_t left, uint8_t middle, uint8_t right); | ||||
int8_t usb_mouse_move(int8_t x, int8_t y, int8_t wheel, int8_t hwheel); | int8_t usb_mouse_move(int8_t x, int8_t y, int8_t wheel, int8_t hwheel); | ||||
void usb_mouse_clear(void); | |||||
bool usb_mouse_is_sent(void); | |||||
void usb_mouse_print(int8_t mouse_x, int8_t mouse_y, int8_t wheel_v, int8_t wheel_h); | |||||
#endif | #endif |