@@ -51,10 +51,10 @@ | |||
# List C source files here. (C dependencies are automatically generated.) | |||
SRC = tmk.c \ | |||
key_process.c \ | |||
usb.c \ | |||
usb_keyboard.c \ | |||
usb_mouse.c \ | |||
usb_debug.c \ | |||
usb.c \ | |||
jump_bootloader.c \ | |||
print.c | |||
SRC += $(TARGET_SRC) |
@@ -3,12 +3,18 @@ | |||
*/ | |||
#include <stdbool.h> | |||
#include <avr/pgmspace.h> | |||
#include "usb_keyboard.h" | |||
#include "matrix.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) | |||
@@ -66,15 +72,21 @@ bool key_sent = false; | |||
* 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_RALT, // FN_2 | |||
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 | |||
{ | |||
{ KB_2, KB_Q, KB_W, KB_S, KB_A, KB_Z, KB_X, KB_C }, | |||
@@ -134,61 +146,77 @@ static const uint8_t PROGMEM Keymap[][MATRIX_ROWS][MATRIX_COLS] = { | |||
}; | |||
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_modifier_keys = last_mod; | |||
} | |||
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; | |||
} |
@@ -4,17 +4,6 @@ | |||
#include <stdint.h> | |||
#include <stdbool.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 |
@@ -31,6 +31,19 @@ static uint8_t _matrix0[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. | |||
void matrix_init(void) | |||
{ | |||
@@ -48,7 +61,7 @@ void matrix_init(void) | |||
matrix_prev = _matrix1; | |||
} | |||
uint8_t matrix_scan(void) | |||
int matrix_scan(void) | |||
{ | |||
uint8_t *tmp; | |||
@@ -82,10 +95,29 @@ bool matrix_is_modified(void) { | |||
return false; | |||
} | |||
inline | |||
bool matrix_has_ghost(void) { | |||
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; | |||
} |
@@ -0,0 +1,15 @@ | |||
#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 |
@@ -8,7 +8,7 @@ | |||
#include "usb_keyboard.h" | |||
#include "usb_mouse.h" | |||
#include "print.h" | |||
#include "matrix.h" | |||
#include "matrix_skel.h" | |||
#include "keymap.h" | |||
#include "jump_bootloader.h" | |||
@@ -25,150 +25,113 @@ | |||
#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) { | |||
static int mouse_repeat = 0; | |||
bool modified = false; | |||
bool has_ghost = false; | |||
int layer = 0; | |||
//bool has_ghost = false; | |||
int key_index = 0; | |||
uint8_t mouse_btn = 0; | |||
int8_t mouse_x = 0; | |||
int8_t mouse_y = 0; | |||
int8_t mouse_wheel = 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; | |||
} | |||
} |
@@ -1,6 +1,7 @@ | |||
#ifndef KEY_PROCESS_H | |||
#define KEY_PROCESS_H 1 | |||
void proc_matrix(void); | |||
#endif |
@@ -0,0 +1,17 @@ | |||
#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 |
@@ -1,15 +0,0 @@ | |||
#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 |
@@ -0,0 +1,24 @@ | |||
#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 |
@@ -34,7 +34,7 @@ | |||
#include "usb_keyboard.h" | |||
#include "usb_mouse.h" | |||
#include "print.h" | |||
#include "matrix.h" | |||
#include "matrix_skel.h" | |||
#include "keymap.h" | |||
#include "jump_bootloader.h" | |||
@@ -1,8 +1,11 @@ | |||
#include <avr/interrupt.h> | |||
#include <avr/pgmspace.h> | |||
#include "usb_keyboard.h" | |||
#include "print.h" | |||
static bool is_sent = false; | |||
// which modifier keys are currently pressed | |||
// 1=left ctrl, 2=left shift, 4=left alt, 8=left gui | |||
// 16=right ctrl, 32=right shift, 64=right alt, 128=right gui | |||
@@ -72,5 +75,45 @@ int8_t usb_keyboard_send(void) | |||
UEINTX = 0x3A; | |||
keyboard_idle_count = 0; | |||
SREG = intr_state; | |||
is_sent = true; | |||
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"); | |||
} |
@@ -2,6 +2,7 @@ | |||
#define USB_KEYBOARD_H 1 | |||
#include <stdint.h> | |||
#include <stdbool.h> | |||
#include "usb.h" | |||
@@ -10,6 +11,7 @@ | |||
#define KEYBOARD_SIZE 8 | |||
#define KEYBOARD_BUFFER EP_DOUBLE_BUFFER | |||
// TODO: move to usb_keycodes.h ? | |||
// modifier bits | |||
#define MOD_LCTRL (1<<0) | |||
#define MOD_LSHIFT (1<<1) | |||
@@ -21,15 +23,24 @@ | |||
#define MOD_RGUI (1<<7) | |||
// TODO: change variable name: usb_keyboard_ or usb_kb_ | |||
extern uint8_t keyboard_modifier_keys; | |||
extern uint8_t keyboard_keys[6]; | |||
extern uint8_t keyboard_protocol; | |||
extern uint8_t keyboard_idle_config; | |||
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_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 |
@@ -262,10 +262,14 @@ enum keycodes { | |||
KB_RGUI, /* 0x80 */ | |||
/* extensions for internal use */ | |||
FN_1 = 0xE8, | |||
FN_0 = 0xE8, | |||
FN_1, | |||
FN_2, | |||
FN_3, | |||
FN_4, | |||
FN_5, | |||
FN_6, | |||
FN_7, | |||
MS_UP = 0xF0, | |||
MS_DOWN, | |||
MS_LEFT, |
@@ -1,8 +1,11 @@ | |||
#include <avr/interrupt.h> | |||
#include <util/delay.h> | |||
#include "usb_mouse.h" | |||
#include "print.h" | |||
static bool is_sent = false; | |||
// which buttons are currently pressed | |||
uint8_t mouse_buttons=0; | |||
@@ -60,5 +63,23 @@ int8_t usb_mouse_move(int8_t x, int8_t y, int8_t wheel, int8_t hwheel) | |||
UEINTX = 0x3A; | |||
SREG = intr_state; | |||
is_sent = true; | |||
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"); | |||
} |
@@ -2,6 +2,7 @@ | |||
#define USB_MOUSE_H 1 | |||
#include <stdint.h> | |||
#include <stdbool.h> | |||
#include "usb.h" | |||
@@ -16,5 +17,8 @@ extern uint8_t mouse_protocol; | |||
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); | |||
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 |