From 4ae979f6ef8dbf9e1d1f35be15322ad6d02e2958 Mon Sep 17 00:00:00 2001 From: tmk Date: Sat, 6 Oct 2012 02:23:12 +0900 Subject: [PATCH 01/18] Initial version of new code for layer switch is added. --- common.mk | 1 - common/command.c | 2 +- common/host.c | 22 +- common/host.h | 4 + common/keyboard.c | 549 +++++++++++++++++++++++++++++++---------- common/keyboard.h | 28 ++- common/layer.c | 207 ---------------- common/layer.h | 32 --- common/matrix.h | 21 +- common/mousekey.c | 126 ++++++---- common/mousekey.h | 7 +- common/timer.c | 1 + common/usb_keycodes.h | 5 +- common/util.c | 16 +- common/util.h | 4 +- keyboard/hhkb/config.h | 2 - keyboard/hhkb/keymap.c | 8 +- keyboard/hhkb/matrix.c | 50 +--- protocol/lufa/lufa.c | 2 +- 19 files changed, 592 insertions(+), 495 deletions(-) mode change 100644 => 100755 common/keyboard.c mode change 100644 => 100755 common/keyboard.h delete mode 100644 common/layer.c delete mode 100644 common/layer.h diff --git a/common.mk b/common.mk index 26b4bb8596..66f9fd0999 100644 --- a/common.mk +++ b/common.mk @@ -2,7 +2,6 @@ COMMON_DIR = common SRC += $(COMMON_DIR)/host.c \ $(COMMON_DIR)/keyboard.c \ $(COMMON_DIR)/command.c \ - $(COMMON_DIR)/layer.c \ $(COMMON_DIR)/timer.c \ $(COMMON_DIR)/print.c \ $(COMMON_DIR)/debug.c \ diff --git a/common/command.c b/common/command.c index 13d37242d9..0020d8a17c 100644 --- a/common/command.c +++ b/common/command.c @@ -23,7 +23,7 @@ along with this program. If not, see . #include "debug.h" #include "util.h" #include "timer.h" -#include "layer.h" +#include "keyboard.h" #include "matrix.h" #include "bootloader.h" #include "command.h" diff --git a/common/host.c b/common/host.c index 8dd2abbee8..fddd5b6627 100644 --- a/common/host.c +++ b/common/host.c @@ -56,6 +56,19 @@ uint8_t host_keyboard_leds(void) return (*driver->keyboard_leds)(); } +/* new interface */ +void host_register_key(uint8_t key) +{ + host_add_key(key); + host_send_keyboard_report(); +} + +void host_unregister_key(uint8_t key) +{ + host_del_key(key); + host_send_keyboard_report(); +} + /* keyboard report operations */ void host_add_key(uint8_t key) { @@ -158,6 +171,14 @@ void host_send_keyboard_report(void) { if (!driver) return; (*driver->send_keyboard)(keyboard_report); + + if (debug_keyboard) { + print("keys: "); + for (int i = 0; i < REPORT_KEYS; i++) { + phex(keyboard_report->keys[i]); print(" "); + } + print(" mods: "); phex(keyboard_report->mods); print("\n"); + } } void host_mouse_send(report_mouse_t *report) @@ -216,7 +237,6 @@ static inline void del_key_byte(uint8_t code) for (; i < REPORT_KEYS; i++) { if (keyboard_report->keys[i] == code) { keyboard_report->keys[i] = 0; - break; } } } diff --git a/common/host.h b/common/host.h index 26bf3c362f..84a6c24773 100644 --- a/common/host.h +++ b/common/host.h @@ -39,6 +39,10 @@ void host_set_driver(host_driver_t *driver); host_driver_t *host_get_driver(void); uint8_t host_keyboard_leds(void); +/* new interface */ +void host_register_key(uint8_t key); +void host_unregister_key(uint8_t key); + /* keyboard report operations */ void host_add_key(uint8_t key); void host_del_key(uint8_t key); diff --git a/common/keyboard.c b/common/keyboard.c old mode 100644 new mode 100755 index 25f32eb02f..9f0c27670e --- a/common/keyboard.c +++ b/common/keyboard.c @@ -15,15 +15,16 @@ You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include "keyboard.h" -#include "host.h" -#include "layer.h" #include "matrix.h" +#include "keymap.h" +#include "host.h" #include "led.h" #include "usb_keycodes.h" #include "timer.h" #include "print.h" #include "debug.h" #include "command.h" +#include "util.h" #ifdef MOUSEKEY_ENABLE #include "mousekey.h" #endif @@ -32,11 +33,377 @@ along with this program. If not, see . #endif -static uint8_t last_leds = 0; +#define LAYER_DELAY 250 +typedef enum keykind { + NONE, + FN_DOWN, FN_UP, + FNK_DOWN, FNK_UP, + KEY_DOWN, KEY_UP, + MOD_DOWN, MOD_UP, + MOUSEKEY_DOWN, MOUSEKEY_UP, + DELAY +} keykind_t; + +typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t; + + +uint8_t current_layer = 0; +uint8_t default_layer = 0; + +/* keyboard internal states */ +static kbdstate_t kbdstate = IDLE; +static uint8_t fn_state_bits = 0; +static keyrecord_t delayed_fn; +static keyrecord_t waiting_key; + + +static const char *state_str(kbdstate_t state) +{ + if (state == IDLE) return PSTR("IDLE"); + if (state == DELAYING) return PSTR("DELAYING"); + if (state == WAITING) return PSTR("WAITING"); + if (state == PRESSING) return PSTR("PRESSING"); + return PSTR("UNKNOWN"); +} + +static inline keykind_t get_keykind(uint8_t code, bool pressed) +{ + if IS_KEY(code) return (pressed ? KEY_DOWN : KEY_UP); + if IS_MOD(code) return (pressed ? MOD_DOWN : MOD_UP); + if IS_FN(code) { + if (keymap_fn_keycode(FN_INDEX(code))) + return (pressed ? FNK_DOWN : FNK_UP); + else + return (pressed ? FN_DOWN : FN_UP); + } + if IS_MOUSEKEY(code) return (pressed ? MOUSEKEY_DOWN : MOUSEKEY_UP); + return NONE; +} + +static void layer_switch_on(uint8_t code) +{ + if (!IS_FN(code)) return; + fn_state_bits |= FN_BIT(code); + if (current_layer != keymap_fn_layer(FN_INDEX(code))) { + //TODO: clear all key execpt Mod key + debug("Layer Switch(on): "); debug_hex(current_layer); + current_layer = keymap_fn_layer(FN_INDEX(code)); + debug(" -> "); debug_hex(current_layer); debug("\n"); + } +} + +static void layer_switch_off(uint8_t code) +{ + if (!IS_FN(code)) return; + fn_state_bits &= ~FN_BIT(code); + if (current_layer != keymap_fn_layer(biton(fn_state_bits))) { + //TODO: clear all key execpt Mod key + debug("Layer Switch(off): "); debug_hex(current_layer); + current_layer = keymap_fn_layer(biton(fn_state_bits)); + debug(" -> "); debug_hex(current_layer); debug("\n"); + } +} + +static inline uint8_t get_keycode(key_t key) +{ + return keymap_get_keycode(current_layer, key.row, key.col); +} + +// whether any key except modifier is down or not +static inline bool is_anykey_down(void) +{ + for (int r = 0; r < MATRIX_ROWS; r++) { + matrix_row_t matrix_row = matrix_get_row(r); + for (int c = 0; c < MATRIX_COLS; c++) { + if (matrix_row && (1< "); print_P(state_str(kbdstate)); debug("\n"); \ +} while (0) + +static inline void process_key(keyevent_t event) +{ + + /* TODO: ring buffer + static keyrecord_t waiting_keys[5]; + static uint8_t waiting_keys_head = 0; + static uint8_t waiting_keys_tail = 0; + */ + + uint8_t code = get_keycode(event.key); + keykind_t kind = get_keykind(code, event.pressed); + + uint8_t tmp_mods; + + //debug("kbdstate: "); debug_hex(kbdstate); + debug("state: "); print_P(state_str(kbdstate)); + debug(" kind: "); debug_hex(kind); + debug(" code: "); debug_hex(code); + if (event.pressed) { debug("d"); } else { debug("u"); } + debug("\n"); + switch (kbdstate) { + case IDLE: + switch (kind) { + case FN_DOWN: + layer_switch_on(code); + break; + case FN_UP: + layer_switch_off(code); + break; + case FNK_DOWN: + // store event + delayed_fn = (keyrecord_t) { .event = event, .code = code, .mods = keyboard_report->mods, .time = timer_read() }; + NEXT(DELAYING); + break; + case FNK_UP: + layer_switch_off(code); + break; + case KEY_DOWN: + case MOUSEKEY_DOWN: + register_code(code); + NEXT(PRESSING); + break; + case MOD_DOWN: + register_code(code); + break; + case KEY_UP: + case MOUSEKEY_UP: + case MOD_UP: + unregister_code(code); + break; + default: + break; + } + break; + case PRESSING: + switch (kind) { + case FN_DOWN: + // ignored when any key is pressed + break; + case FN_UP: + layer_switch_off(code); + NEXT(IDLE); + break; + case FNK_DOWN: + register_code(keymap_fn_keycode(FN_INDEX(code))); + break; + case FNK_UP: + unregister_code(keymap_fn_keycode(FN_INDEX(code))); + break; + case KEY_DOWN: + case MOD_DOWN: + case MOUSEKEY_DOWN: + register_code(code); + break; + case KEY_UP: + case MOD_UP: + case MOUSEKEY_UP: + unregister_code(code); + // no key registered? mousekey, mediakey, systemkey + if (!host_has_anykey()) + NEXT(IDLE); + break; + default: + break; + } + break; + case DELAYING: + switch (kind) { + case FN_DOWN: + case FNK_DOWN: + case KEY_DOWN: + case MOUSEKEY_DOWN: + waiting_key = (keyrecord_t) { .event = event, .code = code, .mods = keyboard_report->mods, .time = timer_read() }; + NEXT(WAITING); + break; + case MOD_DOWN: + register_code(code); + break; + case FN_UP: + layer_switch_off(code); + NEXT(IDLE); + break; + case FNK_UP: + if (code == delayed_fn.code) { + // type Fn with alt keycode + // restore the mod status at the time of pressing Fn key + tmp_mods = keyboard_report->mods; + host_set_mods(delayed_fn.mods); + register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code))); + unregister_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code))); + host_set_mods(tmp_mods); + NEXT(IDLE); + } else { + layer_switch_off(code); + NEXT(IDLE); + } + break; + case KEY_UP: + case MOUSEKEY_UP: + unregister_code(code); + NEXT(IDLE); + break; + case MOD_UP: + unregister_code(code); + break; + default: + break; + } + break; + case WAITING: + switch (kind) { + case FN_DOWN: + case FNK_DOWN: + case KEY_DOWN: + case MOUSEKEY_DOWN: + tmp_mods = keyboard_report->mods; + host_set_mods(delayed_fn.mods); + register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code))); + host_set_mods(waiting_key.mods); + register_code(waiting_key.code); + host_set_mods(tmp_mods); + register_code(code); + NEXT(IDLE); + break; + case MOD_DOWN: + register_code(code); + break; + case FN_UP: + layer_switch_off(code); + NEXT(IDLE); + break; + case FNK_UP: + if (code == delayed_fn.code) { + // alt down, key down, alt up + tmp_mods = keyboard_report->mods; + host_set_mods(delayed_fn.mods); + register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code))); + host_set_mods(waiting_key.mods); + register_code(waiting_key.code); + unregister_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code))); + host_set_mods(tmp_mods); + NEXT(IDLE); + } else { + layer_switch_off(code); + NEXT(IDLE); + } + break; + case KEY_UP: + case MOUSEKEY_UP: + if (code == waiting_key.code) { + layer_switch_on(delayed_fn.code); + NEXT(IDLE); + // process waiting_key + tmp_mods = keyboard_report->mods; + host_set_mods(waiting_key.mods); + process_key(waiting_key.event); + host_set_mods(tmp_mods); + process_key(event); + } else { + unregister_code(code); + } + break; + case MOD_UP: + unregister_code(code); + break; + default: + break; + } + break; + } + + // TODO: FAIL SAFE: unregister all keys when no key down +} void keyboard_init(void) { + debug_keyboard = true; + timer_init(); matrix_init(); #ifdef PS2_MOUSE_ENABLE @@ -44,150 +411,66 @@ void keyboard_init(void) #endif } -void keyboard_proc(void) +void keyboard_task(void) { - uint8_t fn_bits = 0; -#ifdef EXTRAKEY_ENABLE - uint16_t consumer_code = 0; - uint16_t system_code = 0; -#endif + static matrix_row_t matrix_prev[MATRIX_ROWS]; + matrix_row_t matrix_row = 0; + matrix_row_t matrix_change = 0; matrix_scan(); - - if (matrix_is_modified()) { - if (debug_matrix) matrix_print(); -#ifdef DEBUG_LED - // LED flash for debug - DEBUG_LED_CONFIG; - DEBUG_LED_ON; -#endif - } - - if (matrix_has_ghost()) { - // should send error? - debug("matrix has ghost!!\n"); + if (command_proc()) { + debug("COMMAND\n"); + // TODO: clear all keys + host_clear_keyboard_report(); + host_send_keyboard_report(); return; } + for (int r = 0; r < MATRIX_ROWS; r++) { + matrix_row = matrix_get_row(r); + matrix_change = matrix_row ^ matrix_prev[r]; + if (matrix_change) { + // TODO: print once per scan + if (debug_matrix) matrix_print(); - host_swap_keyboard_report(); - host_clear_keyboard_report(); - for (int row = 0; row < matrix_rows(); row++) { - for (int col = 0; col < matrix_cols(); col++) { - if (!matrix_is_on(row, col)) continue; - - uint8_t code = layer_get_keycode(row, col); - if (code == KB_NO) { - // do nothing - } else if (IS_MOD(code)) { - host_add_mod_bit(MOD_BIT(code)); - } else if (IS_FN(code)) { - fn_bits |= FN_BIT(code); - } -// TODO: use table or something -#ifdef EXTRAKEY_ENABLE - // System Control - else if (code == KB_SYSTEM_POWER) { -#ifdef HOST_PJRC - if (suspend && remote_wakeup) { - usb_remote_wakeup(); + for (int c = 0; c < MATRIX_COLS; c++) { + if (matrix_change & (1< LAYER_DELAY) { + if (kbdstate == DELAYING) { + layer_switch_on(delayed_fn.code); + NEXT(IDLE); } - else if (code == KB_MEDIA_NEXT_TRACK) { - consumer_code = TRANSPORT_NEXT_TRACK; - } else if (code == KB_MEDIA_PREV_TRACK) { - consumer_code = TRANSPORT_PREV_TRACK; - } else if (code == KB_MEDIA_STOP) { - consumer_code = TRANSPORT_STOP; - } else if (code == KB_MEDIA_PLAY_PAUSE) { - consumer_code = TRANSPORT_PLAY_PAUSE; - } else if (code == KB_MEDIA_SELECT) { - consumer_code = AL_CC_CONFIG; - } - else if (code == KB_MAIL) { - consumer_code = AL_EMAIL; - } else if (code == KB_CALCULATOR) { - consumer_code = AL_CALCULATOR; - } else if (code == KB_MY_COMPUTER) { - consumer_code = AL_LOCAL_BROWSER; - } - else if (code == KB_WWW_SEARCH) { - consumer_code = AC_SEARCH; - } else if (code == KB_WWW_HOME) { - consumer_code = AC_HOME; - } else if (code == KB_WWW_BACK) { - consumer_code = AC_BACK; - } else if (code == KB_WWW_FORWARD) { - consumer_code = AC_FORWARD; - } else if (code == KB_WWW_STOP) { - consumer_code = AC_STOP; - } else if (code == KB_WWW_REFRESH) { - consumer_code = AC_REFRESH; - } else if (code == KB_WWW_FAVORITES) { - consumer_code = AC_BOOKMARKS; - } -#endif - else if (IS_KEY(code)) { - host_add_key(code); - } -#ifdef MOUSEKEY_ENABLE - else if (IS_MOUSEKEY(code)) { - mousekey_decode(code); - } -#endif - else { - debug("ignore keycode: "); debug_hex(code); debug("\n"); + if (kbdstate == WAITING) { + layer_switch_on(delayed_fn.code); + NEXT(IDLE); + uint8_t tmp_mods = keyboard_report->mods; + host_set_mods(waiting_key.mods); + process_key(waiting_key.event); + host_set_mods(tmp_mods); } } } - layer_switching(fn_bits); + // mousekey repeat & acceleration + mousekey_task(); - if (command_proc()) { - return; - } - - // TODO: should send only when changed from last report - if (matrix_is_modified()) { - host_send_keyboard_report(); -#ifdef EXTRAKEY_ENABLE - host_consumer_send(consumer_code); - host_system_send(system_code); -#endif -#ifdef DEBUG_LED - // LED flash for debug - DEBUG_LED_CONFIG; - DEBUG_LED_OFF; -#endif - } - -#ifdef MOUSEKEY_ENABLE - mousekey_send(); -#endif - -#ifdef PS2_MOUSE_ENABLE - // TODO: should comform new API - if (ps2_mouse_read() == 0) - ps2_mouse_usb_send(); -#endif - - if (last_leds != host_keyboard_leds()) { - keyboard_set_leds(host_keyboard_leds()); - last_leds = host_keyboard_leds(); - } + return; } void keyboard_set_leds(uint8_t leds) diff --git a/common/keyboard.h b/common/keyboard.h old mode 100644 new mode 100755 index 51bf67379a..2353805e17 --- a/common/keyboard.h +++ b/common/keyboard.h @@ -18,15 +18,41 @@ along with this program. If not, see . #ifndef KEYBOARD_H #define KEYBOARD_H +#include #include #ifdef __cplusplus extern "C" { #endif + +typedef struct { + uint8_t row; + uint8_t col; +} key_t; + +typedef struct { + key_t key; + bool pressed; +} keyevent_t; + +typedef struct { + keyevent_t event; + uint8_t code; + uint8_t mods; + uint16_t time; +} keyrecord_t; + +#define KEYEQ(keya, keyb) (keya.row == keyb.row && keya.col == keyb.col) + + +extern uint8_t current_layer; +extern uint8_t default_layer; + void keyboard_init(void); -void keyboard_proc(void); +void keyboard_task(void); void keyboard_set_leds(uint8_t leds); + #ifdef __cplusplus } #endif diff --git a/common/layer.c b/common/layer.c deleted file mode 100644 index 0854eede0d..0000000000 --- a/common/layer.c +++ /dev/null @@ -1,207 +0,0 @@ -/* -Copyright 2011 Jun Wako - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 2 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see . -*/ - -#include "keymap.h" -#include "host.h" -#include "debug.h" -#include "timer.h" -#include "usb_keycodes.h" -#include "layer.h" - - -/* - * Parameters: - * SWITCH_DELAY |=======| - * SEND_FN_TERM |================| - * - * Fn key processing cases: - * 1. release Fn after SEND_FN_TERM. - * Layer sw ___________|~~~~~~~~~~~|___ - * Fn press ___|~~~~~~~~~~~~~~~~~~~|___ - * Fn send ___________________________ - * - * 2. release Fn during SEND_FN_TERM.(not layer used) - * Layer sw ___________|~~~~~~|________ - * Fn press ___|~~~~~~~~~~~~~~|________ - * Fn key send __________________|~|______ - * other key press ___________________________ - * other key send ___________________________ - * - * 3. release Fn during SEND_FN_TERM.(layer used) - * Layer sw ___________|~~~~~~|________ - * Fn press ___|~~~~~~~~~~~~~~|________ - * Fn key send ___________________________ - * Fn send ___________________________ - * other key press _____________|~~|__________ - * other key send _____________|~~|__________ - * - * 4. press other key during SWITCH_DELAY. - * Layer sw ___________________________ - * Fn key press ___|~~~~~~~~~|_____________ - * Fn key send ______|~~~~~~|_____________ - * other key press ______|~~~|________________ - * other key send _______|~~|________________ - * - * 5. press Fn while press other key. - * Layer sw ___________________________ - * Fn key press ___|~~~~~~~~~|_____________ - * Fn key send ___|~~~~~~~~~|_____________ - * other key press ~~~~~~~|___________________ - * other key send ~~~~~~~|___________________ - * - * 6. press Fn twice quickly and keep holding down.(repeat) - * Layer sw ___________________________ - * Fn key press ___|~|____|~~~~~~~~~~~~~~~~ - * Fn key send _____|~|__|~~~~~~~~~~~~~~~~ - */ - -// LAYER_SWITCH_DELAY: prevent from moving to new layer -#ifndef LAYER_SWITCH_DELAY -# define LAYER_SWITCH_DELAY 150 -#endif - -// LAYER_SEND_FN_TERM: send keycode if release key in this term -#ifndef LAYER_SEND_FN_TERM -# define LAYER_SEND_FN_TERM 500 -#endif - - -uint8_t default_layer = 0; -uint8_t current_layer = 0; - -static bool layer_used = false; -static uint8_t new_layer(uint8_t fn_bits); - - -uint8_t layer_get_keycode(uint8_t row, uint8_t col) -{ - uint8_t code = keymap_get_keycode(current_layer, row, col); - // normal key or mouse key - if ((IS_KEY(code) || IS_MOUSEKEY(code))) { - layer_used = true; - } - return code; -} - -// bit substract b from a -#define BIT_SUBST(a, b) (a&(a^b)) -void layer_switching(uint8_t fn_bits) -{ - // layer switching - static uint8_t last_fn = 0; - static uint8_t last_mods = 0; - static uint16_t last_timer = 0; - static uint8_t sent_fn = 0; - - if (fn_bits == last_fn) { // Fn state is not changed - if (fn_bits == 0) { - // do nothing - } else { - if (!keymap_fn_keycode(BIT_SUBST(fn_bits, sent_fn)) || - timer_elapsed(last_timer) > LAYER_SWITCH_DELAY) { - uint8_t _layer_to_switch = new_layer(BIT_SUBST(fn_bits, sent_fn)); - if (current_layer != _layer_to_switch) { // not switch layer yet - debug("Fn case: 1,2,3(LAYER_SWITCH_DELAY passed)\n"); - debug("Switch Layer: "); debug_hex(current_layer); - current_layer = _layer_to_switch; - layer_used = false; - debug(" -> "); debug_hex(current_layer); debug("\n"); - } - } else { - if (host_has_anykey()) { // other keys is pressed - uint8_t _fn_to_send = BIT_SUBST(fn_bits, sent_fn); - if (_fn_to_send) { - debug("Fn case: 4(press other key during SWITCH_DELAY.)\n"); - // send only Fn key first - uint8_t tmp_mods = keyboard_report->mods; - host_add_code(keymap_fn_keycode(_fn_to_send)); - host_set_mods(last_mods); - host_send_keyboard_report(); - host_set_mods(tmp_mods); - host_del_code(keymap_fn_keycode(_fn_to_send)); - sent_fn |= _fn_to_send; - } - } - } - // add Fn keys to send - //host_add_code(keymap_fn_keycode(fn_bits&sent_fn)); // TODO: do all Fn keys - } - } else { // Fn state is changed(edge) - uint8_t fn_changed = 0; - - debug("fn_bits: "); debug_bin(fn_bits); debug("\n"); - debug("sent_fn: "); debug_bin(sent_fn); debug("\n"); - debug("last_fn: "); debug_bin(last_fn); debug("\n"); - debug("last_mods: "); debug_hex(last_mods); debug("\n"); - debug("last_timer: "); debug_hex16(last_timer); debug("\n"); - debug("timer_count: "); debug_hex16(timer_count); debug("\n"); - - // pressed Fn - if ((fn_changed = BIT_SUBST(fn_bits, last_fn))) { - debug("fn_changed: "); debug_bin(fn_changed); debug("\n"); - if (host_has_anykey()) { - debug("Fn case: 5(pressed Fn with other key)\n"); - sent_fn |= fn_changed; - } else if (fn_changed & sent_fn) { // pressed same Fn in a row - if (timer_elapsed(last_timer) > LAYER_SEND_FN_TERM) { - debug("Fn case: 6(not repeat)\n"); - // time passed: not repeate - sent_fn &= ~fn_changed; - } else { - debug("Fn case: 6(repeat)\n"); - } - } - } - // released Fn - if ((fn_changed = BIT_SUBST(last_fn, fn_bits))) { - debug("fn_changed: "); debug_bin(fn_changed); debug("\n"); - if (timer_elapsed(last_timer) < LAYER_SEND_FN_TERM) { - if (!layer_used && BIT_SUBST(fn_changed, sent_fn)) { - debug("Fn case: 2(send Fn one shot: released Fn during LAYER_SEND_FN_TERM)\n"); - // send only Fn key first - uint8_t tmp_mods = keyboard_report->mods; - host_add_code(keymap_fn_keycode(fn_changed)); - host_set_mods(last_mods); - host_send_keyboard_report(); - host_set_mods(tmp_mods); - host_del_code(keymap_fn_keycode(fn_changed)); - sent_fn |= fn_changed; - } - } - debug("Switch Layer(released Fn): "); debug_hex(current_layer); - current_layer = new_layer(BIT_SUBST(fn_bits, sent_fn)); - debug(" -> "); debug_hex(current_layer); debug("\n"); - } - - layer_used = false; - last_fn = fn_bits; - last_mods = keyboard_report->mods; - last_timer = timer_read(); - } - // send Fn keys - for (uint8_t i = 0; i < 8; i++) { - if ((sent_fn & fn_bits) & (1< - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 2 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see . -*/ - -#ifndef LAYER_H -#define LAYER_H 1 - -#include - -extern uint8_t default_layer; -extern uint8_t current_layer; - -/* return keycode for switch */ -uint8_t layer_get_keycode(uint8_t row, uint8_t col); - -/* process layer switching */ -void layer_switching(uint8_t fn_bits); - -#endif diff --git a/common/matrix.h b/common/matrix.h index c4b2cab518..b3332d5ff9 100644 --- a/common/matrix.h +++ b/common/matrix.h @@ -18,8 +18,23 @@ along with this program. If not, see . #ifndef MATRIX_H #define MATRIX_H +#include #include + +#if (MATRIX_COLS <= 8) +typedef uint8_t matrix_row_t; +#elif (MATRIX_COLS <= 16) +typedef uint16_t matrix_row_t; +#elif (MATRIX_COLS <= 32) +typedef uint32_t matrix_row_t; +#else +#error "MATRIX_COLS: invalid value" +#endif + +#define MATRIX_IS_ON(row, col) (matrix_get_row(row) && (1<. static report_mouse_t report; -static report_mouse_t report_prev; static uint8_t mousekey_repeat = 0; @@ -38,84 +37,111 @@ static void mousekey_debug(void); * see wikipedia http://en.wikipedia.org/wiki/Mouse_keys */ #ifndef MOUSEKEY_DELAY_TIME -# define MOUSEKEY_DELAY_TIME 255 +# define MOUSEKEY_DELAY_TIME 20 #endif +#define MOUSEKEY_MOVE_INIT 5 +#define MOUSEKEY_WHEEL_INIT 1 +#define MOUSEKEY_MOVE_ACCEL 5 +#define MOUSEKEY_WHEEL_ACCEL 1 + +static uint16_t last_timer = 0; + // acceleration parameters -uint8_t mousekey_move_unit = 2; -uint8_t mousekey_resolution = 5; +//uint8_t mousekey_move_unit = 2; +//uint8_t mousekey_resolution = 5; static inline uint8_t move_unit(void) { - uint16_t unit = 5 + mousekey_repeat*2; + uint16_t unit = 5 + mousekey_repeat*4; return (unit > 63 ? 63 : unit); } -void mousekey_decode(uint8_t code) +void mousekey_task(void) { - if (code == KB_MS_UP) report.y = -move_unit(); - else if (code == KB_MS_DOWN) report.y = move_unit(); - else if (code == KB_MS_LEFT) report.x = -move_unit(); - else if (code == KB_MS_RIGHT) report.x = move_unit(); - else if (code == KB_MS_BTN1) report.buttons |= MOUSE_BTN1; - else if (code == KB_MS_BTN2) report.buttons |= MOUSE_BTN2; - else if (code == KB_MS_BTN3) report.buttons |= MOUSE_BTN3; - else if (code == KB_MS_BTN4) report.buttons |= MOUSE_BTN4; - else if (code == KB_MS_BTN5) report.buttons |= MOUSE_BTN5; - else if (code == KB_MS_WH_UP) report.v += move_unit()/4; - else if (code == KB_MS_WH_DOWN) report.v -= move_unit()/4; - else if (code == KB_MS_WH_LEFT) report.h -= move_unit()/4; - else if (code == KB_MS_WH_RIGHT)report.h += move_unit()/4; -} - -bool mousekey_changed(void) -{ - return (report.buttons != report_prev.buttons || - report.x || report.y || report.v || report.h); -} - -void mousekey_send(void) -{ - static uint16_t last_timer = 0; - - if (!mousekey_changed()) { - mousekey_repeat = 0; - mousekey_clear_report(); + if (timer_elapsed(last_timer) < MOUSEKEY_DELAY_TIME) return; - } - // send immediately when buttun state is changed - if (report.buttons == report_prev.buttons) { - if (timer_elapsed(last_timer) < 100) { - mousekey_clear_report(); - return; - } - } + if (report.x == 0 && report.y == 0 && report.v == 0 && report.h == 0) + return; - if (mousekey_repeat != 0xFF) { + if (mousekey_repeat != UINT8_MAX) mousekey_repeat++; - } + + + if (report.x > 0) report.x = move_unit(); + if (report.x < 0) report.x = move_unit() * -1; + if (report.y > 0) report.y = move_unit(); + if (report.y < 0) report.y = move_unit() * -1; if (report.x && report.y) { report.x *= 0.7; report.y *= 0.7; } - mousekey_debug(); - host_mouse_send(&report); - report_prev = report; - last_timer = timer_read(); - mousekey_clear_report(); + if (report.v > 0) report.v = move_unit(); + if (report.v < 0) report.v = move_unit() * -1; + if (report.h > 0) report.h = move_unit(); + if (report.h < 0) report.h = move_unit() * -1; + + mousekey_send(); } -void mousekey_clear_report(void) +void mousekey_on(uint8_t code) { + if (code == KB_MS_UP) report.y = MOUSEKEY_MOVE_INIT * -1; + else if (code == KB_MS_DOWN) report.y = MOUSEKEY_MOVE_INIT; + else if (code == KB_MS_LEFT) report.x = MOUSEKEY_MOVE_INIT * -1; + else if (code == KB_MS_RIGHT) report.x = MOUSEKEY_MOVE_INIT; + else if (code == KB_MS_WH_UP) report.v = MOUSEKEY_WHEEL_INIT; + else if (code == KB_MS_WH_DOWN) report.v = MOUSEKEY_WHEEL_INIT * -1; + else if (code == KB_MS_WH_LEFT) report.h = MOUSEKEY_WHEEL_INIT * -1; + else if (code == KB_MS_WH_RIGHT) report.h = MOUSEKEY_WHEEL_INIT; + else if (code == KB_MS_BTN1) report.buttons |= MOUSE_BTN1; + else if (code == KB_MS_BTN2) report.buttons |= MOUSE_BTN2; + else if (code == KB_MS_BTN3) report.buttons |= MOUSE_BTN3; + else if (code == KB_MS_BTN4) report.buttons |= MOUSE_BTN4; + else if (code == KB_MS_BTN5) report.buttons |= MOUSE_BTN5; +} + +void mousekey_off(uint8_t code) +{ + if (code == KB_MS_UP && report.y < 0) report.y = 0; + else if (code == KB_MS_DOWN && report.y > 0) report.y = 0; + else if (code == KB_MS_LEFT && report.x < 0) report.x = 0; + else if (code == KB_MS_RIGHT && report.x > 0) report.x = 0; + else if (code == KB_MS_WH_UP && report.v > 0) report.v = 0; + else if (code == KB_MS_WH_DOWN && report.v < 0) report.v = 0; + else if (code == KB_MS_WH_LEFT && report.h < 0) report.h = 0; + else if (code == KB_MS_WH_RIGHT && report.h > 0) report.h = 0; + else if (code == KB_MS_BTN1) report.buttons &= ~MOUSE_BTN1; + else if (code == KB_MS_BTN2) report.buttons &= ~MOUSE_BTN2; + else if (code == KB_MS_BTN3) report.buttons &= ~MOUSE_BTN3; + else if (code == KB_MS_BTN4) report.buttons &= ~MOUSE_BTN4; + else if (code == KB_MS_BTN5) report.buttons &= ~MOUSE_BTN5; + + if (report.x == 0 && report.y == 0 && report.v == 0 && report.h == 0) + mousekey_repeat = 0; +} + +void mousekey_send(void) +{ + mousekey_debug(); + host_mouse_send(&report); + last_timer = timer_read(); +} + +void mousekey_clear(void) +{ + report = (report_mouse_t){}; +/* report.buttons = 0; report.x = 0; report.y = 0; report.v = 0; report.h = 0; +*/ } static void mousekey_debug(void) diff --git a/common/mousekey.h b/common/mousekey.h index c2c24e9fa5..3006c4634f 100644 --- a/common/mousekey.h +++ b/common/mousekey.h @@ -21,9 +21,10 @@ along with this program. If not, see . #include #include "host.h" -void mousekey_decode(uint8_t code); -bool mousekey_changed(void); +void mousekey_task(void); +void mousekey_on(uint8_t code); +void mousekey_off(uint8_t code); +void mousekey_clear(void); void mousekey_send(void); -void mousekey_clear_report(void); #endif diff --git a/common/timer.c b/common/timer.c index 8b8d37e8b3..e0dec6cefc 100644 --- a/common/timer.c +++ b/common/timer.c @@ -22,6 +22,7 @@ along with this program. If not, see . // counter resolution 1ms +// NOTE: union { uint32_t timer32; struct { uint16_t dummy; uint16_t timer16; }} volatile uint32_t timer_count = 0; void timer_init(void) diff --git a/common/usb_keycodes.h b/common/usb_keycodes.h index 04b398fa2a..61d6bf0029 100644 --- a/common/usb_keycodes.h +++ b/common/usb_keycodes.h @@ -33,8 +33,9 @@ along with this program. If not, see . #define IS_MOUSEKEY_BUTTON(code) (KB_MS_BTN1 <= (code) && (code) <= KB_MS_BTN5) #define IS_MOUSEKEY_WHEEL(code) (KB_MS_WH_UP <= (code) && (code) <= KB_MS_WH_RIGHT) -#define MOD_BIT(code) (1<<((code) & 0x07)) -#define FN_BIT(code) (1<<((code) - KB_FN0)) +#define MOD_BIT(code) (1<<((code) & 0x07)) +#define FN_BIT(code) (1<<((code) - KB_FN0)) +#define FN_INDEX(code) ((code) - KB_FN0) /* Short names */ diff --git a/common/util.c b/common/util.c index 36afdd4470..644301fe89 100644 --- a/common/util.c +++ b/common/util.c @@ -17,19 +17,23 @@ along with this program. If not, see . #include "util.h" -// bit population -int bitpop(uint8_t bits) +// bit population - return number of on-bit +uint8_t bitpop(uint8_t bits) { - int c; + uint8_t c; for (c = 0; bits; c++) bits &= bits -1; return c; +/* + const uint8_t bit_count[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 }; + return bit_count[bits>>4] + bit_count[bits&0x0F] +*/ } -// most significant on-bit -int biton(uint8_t bits) +// most significant on-bit - return highest location of on-bit +uint8_t biton(uint8_t bits) { - int n = 0; + uint8_t n = 0; if (bits >> 4) { bits >>= 4; n += 4;} if (bits >> 2) { bits >>= 2; n += 2;} if (bits >> 1) { bits >>= 1; n += 1;} diff --git a/common/util.h b/common/util.h index 66bccbfa58..87636c9710 100644 --- a/common/util.h +++ b/common/util.h @@ -28,7 +28,7 @@ along with this program. If not, see . #define XSTR(s) #s -int bitpop(uint8_t bits); -int biton(uint8_t bits); +uint8_t bitpop(uint8_t bits); +uint8_t biton(uint8_t bits); #endif diff --git a/keyboard/hhkb/config.h b/keyboard/hhkb/config.h index bf946ac01e..17a4494065 100644 --- a/keyboard/hhkb/config.h +++ b/keyboard/hhkb/config.h @@ -35,8 +35,6 @@ along with this program. If not, see . /* matrix size */ #define MATRIX_ROWS 8 #define MATRIX_COLS 8 -/* define if matrix has ghost */ -//#define MATRIX_HAS_GHOST /* key combination for command */ diff --git a/keyboard/hhkb/keymap.c b/keyboard/hhkb/keymap.c index f05962aed6..43f777c564 100644 --- a/keyboard/hhkb/keymap.c +++ b/keyboard/hhkb/keymap.c @@ -210,12 +210,12 @@ uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col) return KEYCODE(layer, row, col); } -uint8_t keymap_fn_layer(uint8_t fn_bits) +uint8_t keymap_fn_layer(uint8_t index) { - return pgm_read_byte(&fn_layer[biton(fn_bits)]); + return pgm_read_byte(&fn_layer[index]); } -uint8_t keymap_fn_keycode(uint8_t fn_bits) +uint8_t keymap_fn_keycode(uint8_t index) { - return pgm_read_byte(&fn_keycode[(biton(fn_bits))]); + return pgm_read_byte(&fn_keycode[index]); } diff --git a/keyboard/hhkb/matrix.c b/keyboard/hhkb/matrix.c index 79d2d98731..3bd6e73b35 100644 --- a/keyboard/hhkb/matrix.c +++ b/keyboard/hhkb/matrix.c @@ -43,22 +43,10 @@ along with this program. If not, see . // matrix state buffer(1:on, 0:off) -#if (MATRIX_COLS <= 8) -static uint8_t *matrix; -static uint8_t *matrix_prev; -static uint8_t _matrix0[MATRIX_ROWS]; -static uint8_t _matrix1[MATRIX_ROWS]; -#else -static uint16_t *matrix; -static uint16_t *matrix_prev; -static uint16_t _matrix0[MATRIX_ROWS]; -static uint16_t _matrix1[MATRIX_ROWS]; -#endif - -// HHKB has no ghost and no bounce. -#ifdef MATRIX_HAS_GHOST -static bool matrix_has_ghost_in_row(uint8_t row); -#endif +static matrix_row_t *matrix; +static matrix_row_t *matrix_prev; +static matrix_row_t _matrix0[MATRIX_ROWS]; +static matrix_row_t _matrix1[MATRIX_ROWS]; // Matrix I/O ports @@ -192,6 +180,8 @@ uint8_t matrix_scan(void) } // Ignore if this code region execution time elapses more than 20us. + // MEMO: 20[us] * (TIMER_RAW_FREQ / 1000000)[count per us] + // MEMO: then change above using this rule: a/(b/c) = a*1/(b/c) = a*(c/b) if (TIMER_DIFF_RAW(TIMER_RAW, last) > 20/(1000000/TIMER_RAW_FREQ)) { matrix[row] = matrix_prev[row]; } @@ -219,12 +209,6 @@ bool matrix_is_modified(void) inline bool matrix_has_ghost(void) { -#ifdef MATRIX_HAS_GHOST - for (uint8_t i = 0; i < MATRIX_ROWS; i++) { - if (matrix_has_ghost_in_row(i)) - return true; - } -#endif return false; } @@ -257,11 +241,6 @@ void matrix_print(void) pbin_reverse(matrix_get_row(row)); #else pbin_reverse16(matrix_get_row(row)); -#endif -#ifdef MATRIX_HAS_GHOST - if (matrix_has_ghost_in_row(row)) { - print(" Date: Sun, 7 Oct 2012 11:09:40 +0900 Subject: [PATCH 02/18] changes function name keyboard_proc to keyboard_task --- converter/usb_usb/main.cpp | 2 +- protocol/iwrap/main.c | 2 +- protocol/pjrc/main.c | 2 +- protocol/vusb/main.c | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/converter/usb_usb/main.cpp b/converter/usb_usb/main.cpp index 04d838f57f..46c728e9b5 100644 --- a/converter/usb_usb/main.cpp +++ b/converter/usb_usb/main.cpp @@ -88,7 +88,7 @@ uint16_t timer; DDRF = (1<<7); for (;;) { PORTF ^= (1<<7); - keyboard_proc(); + keyboard_task(); timer = timer_read(); usb_host.Task(); diff --git a/protocol/iwrap/main.c b/protocol/iwrap/main.c index a552afb67e..5c42a2c6ad 100644 --- a/protocol/iwrap/main.c +++ b/protocol/iwrap/main.c @@ -166,7 +166,7 @@ int main(void) if (host_get_driver() == vusb_driver()) usbPoll(); #endif - keyboard_proc(); + keyboard_task(); #ifdef HOST_VUSB if (host_get_driver() == vusb_driver()) vusb_transfer_keyboard(); diff --git a/protocol/pjrc/main.c b/protocol/pjrc/main.c index 0b0a44028e..e0f600fe7c 100644 --- a/protocol/pjrc/main.c +++ b/protocol/pjrc/main.c @@ -86,6 +86,6 @@ int main(void) host_set_driver(pjrc_driver()); while (1) { - keyboard_proc(); + keyboard_task(); } } diff --git a/protocol/vusb/main.c b/protocol/vusb/main.c index 3deb82238a..e964a69a87 100644 --- a/protocol/vusb/main.c +++ b/protocol/vusb/main.c @@ -96,7 +96,7 @@ int main(void) // TODO: configuration process is incosistent. it sometime fails. // To prevent failing to configure NOT scan keyboard during configuration if (usbConfiguration && usbInterruptIsReady()) { - keyboard_proc(); + keyboard_task(); } vusb_transfer_keyboard(); } From e9af482690152f1beedbbb915791eccd2d5c22d1 Mon Sep 17 00:00:00 2001 From: tmk Date: Sun, 7 Oct 2012 12:25:18 +0900 Subject: [PATCH 03/18] Add repeating of Fn key with alt keycode. --- common/keyboard.c | 29 ++++++++++++++++++++++------- common/keyboard.h | 0 2 files changed, 22 insertions(+), 7 deletions(-) mode change 100755 => 100644 common/keyboard.c mode change 100755 => 100644 common/keyboard.h diff --git a/common/keyboard.c b/common/keyboard.c old mode 100755 new mode 100644 index 9f0c27670e..b7063a264e --- a/common/keyboard.c +++ b/common/keyboard.c @@ -163,7 +163,7 @@ static void unregister_code(uint8_t code) * Event/State|IDLE DELAYING[f] WAITING[f,k] PRESSING * -----------+------------------------------------------------------------------ * Fn Down |IDLE(L+) WAITING(Sk) WAITING(Sk) - - * Up |IDLE(L-) IDLE(L-) IDLE(L-) IDLE(L-) + * Up |IDLE(L-) IDLE(L-) IDLE(L-) IDLE(L-) * Fnk Down |DELAYING(Sf) WAITING(Sk) WAINTING(Sk) PRESSING(Rf) * Up |IDLE(L-) IDLE(Rf,Uf) IDLE(Rf,Ps,Uf)*3 PRESSING(Uf) * Key Down |PRESSING(Rk) WAITING(Sk) WAITING(Sk) PRESSING(Rk) @@ -208,7 +208,6 @@ static void unregister_code(uint8_t code) static inline void process_key(keyevent_t event) { - /* TODO: ring buffer static keyrecord_t waiting_keys[5]; static uint8_t waiting_keys_head = 0; @@ -220,12 +219,12 @@ static inline void process_key(keyevent_t event) uint8_t tmp_mods; - //debug("kbdstate: "); debug_hex(kbdstate); debug("state: "); print_P(state_str(kbdstate)); debug(" kind: "); debug_hex(kind); debug(" code: "); debug_hex(code); if (event.pressed) { debug("d"); } else { debug("u"); } debug("\n"); + switch (kbdstate) { case IDLE: switch (kind) { @@ -236,9 +235,20 @@ static inline void process_key(keyevent_t event) layer_switch_off(code); break; case FNK_DOWN: - // store event - delayed_fn = (keyrecord_t) { .event = event, .code = code, .mods = keyboard_report->mods, .time = timer_read() }; - NEXT(DELAYING); + // repeat Fn alt key when press Fn key down, up then down again quickly + if (KEYEQ(delayed_fn.event.key, event.key) && + timer_elapsed(delayed_fn.time) < LAYER_DELAY) { + register_code(keymap_fn_keycode(FN_INDEX(code))); + NEXT(PRESSING); + } else { + delayed_fn = (keyrecord_t) { + .event = event, + .code = code, + .mods = keyboard_report->mods, + .time = timer_read() + }; + NEXT(DELAYING); + } break; case FNK_UP: layer_switch_off(code); @@ -298,7 +308,12 @@ static inline void process_key(keyevent_t event) case FNK_DOWN: case KEY_DOWN: case MOUSEKEY_DOWN: - waiting_key = (keyrecord_t) { .event = event, .code = code, .mods = keyboard_report->mods, .time = timer_read() }; + waiting_key = (keyrecord_t) { + .event = event, + .code = code, + .mods = keyboard_report->mods, + .time = timer_read() + }; NEXT(WAITING); break; case MOD_DOWN: diff --git a/common/keyboard.h b/common/keyboard.h old mode 100755 new mode 100644 From 16ba9bda5601ebef6e4db04a5ad079af32370815 Mon Sep 17 00:00:00 2001 From: tmk Date: Tue, 9 Oct 2012 13:48:39 +0900 Subject: [PATCH 04/18] Add consumer/system usage support. --- common/host.c | 8 +++ common/host.h | 1 + common/keyboard.c | 122 ++++++++++++++++++++++++++++++++++++------ common/mousekey.c | 7 --- common/usb_keycodes.h | 41 ++++++++------ 5 files changed, 141 insertions(+), 38 deletions(-) diff --git a/common/host.c b/common/host.c index fddd5b6627..0a03807f73 100644 --- a/common/host.c +++ b/common/host.c @@ -69,6 +69,14 @@ void host_unregister_key(uint8_t key) host_send_keyboard_report(); } +void host_clear_all_keys_but_mods(void) +{ + for (int8_t i = 0; i < REPORT_KEYS; i++) { + keyboard_report->keys[i] = 0; + } + host_send_keyboard_report(); +} + /* keyboard report operations */ void host_add_key(uint8_t key) { diff --git a/common/host.h b/common/host.h index 84a6c24773..a6dff8de01 100644 --- a/common/host.h +++ b/common/host.h @@ -42,6 +42,7 @@ uint8_t host_keyboard_leds(void); /* new interface */ void host_register_key(uint8_t key); void host_unregister_key(uint8_t key); +void host_clear_all_keys_but_mods(void); /* keyboard report operations */ void host_add_key(uint8_t key); diff --git a/common/keyboard.c b/common/keyboard.c index b7063a264e..328941df3f 100644 --- a/common/keyboard.c +++ b/common/keyboard.c @@ -41,8 +41,6 @@ typedef enum keykind { FNK_DOWN, FNK_UP, KEY_DOWN, KEY_UP, MOD_DOWN, MOD_UP, - MOUSEKEY_DOWN, MOUSEKEY_UP, - DELAY } keykind_t; typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t; @@ -69,15 +67,17 @@ static const char *state_str(kbdstate_t state) static inline keykind_t get_keykind(uint8_t code, bool pressed) { - if IS_KEY(code) return (pressed ? KEY_DOWN : KEY_UP); - if IS_MOD(code) return (pressed ? MOD_DOWN : MOD_UP); + if IS_KEY(code) return (pressed ? KEY_DOWN : KEY_UP); + if IS_MOD(code) return (pressed ? MOD_DOWN : MOD_UP); if IS_FN(code) { if (keymap_fn_keycode(FN_INDEX(code))) return (pressed ? FNK_DOWN : FNK_UP); else return (pressed ? FN_DOWN : FN_UP); } - if IS_MOUSEKEY(code) return (pressed ? MOUSEKEY_DOWN : MOUSEKEY_UP); + if IS_MOUSEKEY(code) return (pressed ? KEY_DOWN : KEY_UP); + if IS_SYSTEM(code) return (pressed ? KEY_DOWN : KEY_UP); + if IS_CONSUMER(code) return (pressed ? KEY_DOWN : KEY_UP); return NONE; } @@ -86,7 +86,13 @@ static void layer_switch_on(uint8_t code) if (!IS_FN(code)) return; fn_state_bits |= FN_BIT(code); if (current_layer != keymap_fn_layer(FN_INDEX(code))) { - //TODO: clear all key execpt Mod key + // clear all key execpt Mod key + host_clear_all_keys_but_mods(); + host_system_send(0); + host_consumer_send(0); + mousekey_clear(); + mousekey_send(); + debug("Layer Switch(on): "); debug_hex(current_layer); current_layer = keymap_fn_layer(FN_INDEX(code)); debug(" -> "); debug_hex(current_layer); debug("\n"); @@ -98,7 +104,13 @@ static void layer_switch_off(uint8_t code) if (!IS_FN(code)) return; fn_state_bits &= ~FN_BIT(code); if (current_layer != keymap_fn_layer(biton(fn_state_bits))) { - //TODO: clear all key execpt Mod key + // clear all key execpt Mod key + host_clear_all_keys_but_mods(); + host_system_send(0); + host_consumer_send(0); + mousekey_clear(); + mousekey_send(); + debug("Layer Switch(off): "); debug_hex(current_layer); current_layer = keymap_fn_layer(biton(fn_state_bits)); debug(" -> "); debug_hex(current_layer); debug("\n"); @@ -128,6 +140,7 @@ static inline bool is_anykey_down(void) static void register_code(uint8_t code) { +debug("register_code\n"); if IS_KEY(code) { host_add_key(code); host_send_keyboard_report(); @@ -140,6 +153,84 @@ static void register_code(uint8_t code) mousekey_on(code); mousekey_send(); } + else if IS_CONSUMER(code) { +debug("consumer\n"); + uint16_t usage = 0; + switch (code) { + case KB_AUDIO_MUTE: + usage = AUDIO_MUTE; + break; + case KB_AUDIO_VOL_UP: + usage = AUDIO_VOL_UP; + break; + case KB_AUDIO_VOL_DOWN: + usage = AUDIO_VOL_DOWN; + break; + case KB_MEDIA_NEXT_TRACK: + usage = TRANSPORT_NEXT_TRACK; + break; + case KB_MEDIA_PREV_TRACK: + usage = TRANSPORT_PREV_TRACK; + break; + case KB_MEDIA_STOP: + usage = TRANSPORT_STOP; + break; + case KB_MEDIA_PLAY_PAUSE: + usage = TRANSPORT_PLAY_PAUSE; + break; + case KB_MEDIA_SELECT: + usage = AL_CC_CONFIG; + break; + case KB_MAIL: + usage = AL_EMAIL; + break; + case KB_CALCULATOR: + usage = AL_CALCULATOR; + break; + case KB_MY_COMPUTER: + usage = AL_LOCAL_BROWSER; + break; + case KB_WWW_SEARCH: + usage = AC_SEARCH; + break; + case KB_WWW_HOME: + usage = AC_HOME; + break; + case KB_WWW_BACK: + usage = AC_BACK; + break; + case KB_WWW_FORWARD: + usage = AC_FORWARD; + break; + case KB_WWW_STOP: + usage = AC_STOP; + break; + case KB_WWW_REFRESH: + usage = AC_REFRESH; + break; + case KB_WWW_FAVORITES: + usage = AC_BOOKMARKS; + break; + } +debug("usage: "); phex16(usage); debug("\n"); + host_consumer_send(usage); + } + else if IS_SYSTEM(code) { + uint16_t usage = 0; + switch (code) { + case KB_SYSTEM_POWER: + usage = SYSTEM_POWER_DOWN; + break; + case KB_SYSTEM_SLEEP: + usage = SYSTEM_SLEEP; + break; + case KB_SYSTEM_WAKE: + usage = SYSTEM_WAKE_UP; + break; + } + host_system_send(usage); + } + } static void unregister_code(uint8_t code) @@ -156,6 +247,12 @@ static void unregister_code(uint8_t code) mousekey_off(code); mousekey_send(); } + else if IS_CONSUMER(code) { + host_consumer_send(0x0000); + } + else if IS_SYSTEM(code) { + host_system_send(0x0000); + } } /* @@ -254,7 +351,6 @@ static inline void process_key(keyevent_t event) layer_switch_off(code); break; case KEY_DOWN: - case MOUSEKEY_DOWN: register_code(code); NEXT(PRESSING); break; @@ -262,7 +358,6 @@ static inline void process_key(keyevent_t event) register_code(code); break; case KEY_UP: - case MOUSEKEY_UP: case MOD_UP: unregister_code(code); break; @@ -283,16 +378,16 @@ static inline void process_key(keyevent_t event) register_code(keymap_fn_keycode(FN_INDEX(code))); break; case FNK_UP: + // can't know whether layer switched or not + layer_switch_off(code); unregister_code(keymap_fn_keycode(FN_INDEX(code))); break; case KEY_DOWN: case MOD_DOWN: - case MOUSEKEY_DOWN: register_code(code); break; case KEY_UP: case MOD_UP: - case MOUSEKEY_UP: unregister_code(code); // no key registered? mousekey, mediakey, systemkey if (!host_has_anykey()) @@ -307,7 +402,6 @@ static inline void process_key(keyevent_t event) case FN_DOWN: case FNK_DOWN: case KEY_DOWN: - case MOUSEKEY_DOWN: waiting_key = (keyrecord_t) { .event = event, .code = code, @@ -339,7 +433,6 @@ static inline void process_key(keyevent_t event) } break; case KEY_UP: - case MOUSEKEY_UP: unregister_code(code); NEXT(IDLE); break; @@ -355,7 +448,6 @@ static inline void process_key(keyevent_t event) case FN_DOWN: case FNK_DOWN: case KEY_DOWN: - case MOUSEKEY_DOWN: tmp_mods = keyboard_report->mods; host_set_mods(delayed_fn.mods); register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code))); @@ -389,7 +481,6 @@ static inline void process_key(keyevent_t event) } break; case KEY_UP: - case MOUSEKEY_UP: if (code == waiting_key.code) { layer_switch_on(delayed_fn.code); NEXT(IDLE); @@ -444,7 +535,6 @@ void keyboard_task(void) matrix_row = matrix_get_row(r); matrix_change = matrix_row ^ matrix_prev[r]; if (matrix_change) { - // TODO: print once per scan if (debug_matrix) matrix_print(); for (int c = 0; c < MATRIX_COLS; c++) { diff --git a/common/mousekey.c b/common/mousekey.c index 7f8e860aa6..222d9e4455 100644 --- a/common/mousekey.c +++ b/common/mousekey.c @@ -135,13 +135,6 @@ void mousekey_send(void) void mousekey_clear(void) { report = (report_mouse_t){}; -/* - report.buttons = 0; - report.x = 0; - report.y = 0; - report.v = 0; - report.h = 0; -*/ } static void mousekey_debug(void) diff --git a/common/usb_keycodes.h b/common/usb_keycodes.h index 61d6bf0029..6a44374189 100644 --- a/common/usb_keycodes.h +++ b/common/usb_keycodes.h @@ -24,15 +24,20 @@ along with this program. If not, see . #define IS_ERROR(code) (KB_ROLL_OVER <= (code) && (code) <= KB_UNDEFINED) -#define IS_ANY(code) (KB_A <= (code)) +#define IS_ANY(code) (KB_A <= (code) && (code) <= 0xFF) #define IS_KEY(code) (KB_A <= (code) && (code) <= KB_EXSEL) #define IS_MOD(code) (KB_LCTRL <= (code) && (code) <= KB_RGUI) + #define IS_FN(code) (KB_FN0 <= (code) && (code) <= KB_FN7) #define IS_MOUSEKEY(code) (KB_MS_UP <= (code) && (code) <= KB_MS_WH_RIGHT) #define IS_MOUSEKEY_MOVE(code) (KB_MS_UP <= (code) && (code) <= KB_MS_RIGHT) #define IS_MOUSEKEY_BUTTON(code) (KB_MS_BTN1 <= (code) && (code) <= KB_MS_BTN5) #define IS_MOUSEKEY_WHEEL(code) (KB_MS_WH_UP <= (code) && (code) <= KB_MS_WH_RIGHT) +#define IS_SPECIAL(code) ((0xB0 <= (code) && (code) <= 0xDF) || (0xE8 <= (code) && (code) <= 0xFF)) +#define IS_CONSUMER(code) (KB_MUTE <= (code) && (code) <= KB_WFAV) +#define IS_SYSTEM(code) (KB_POWER <= (code) && (code) <= KB_WAKE) + #define MOD_BIT(code) (1<<((code) & 0x07)) #define FN_BIT(code) (1<<((code) - KB_FN0)) #define FN_INDEX(code) ((code) - KB_FN0) @@ -137,14 +142,16 @@ along with this program. If not, see . /* Special keycode */ +/* NOTE: 0xA5-DF and 0xE8-FF can be used for internal special purpose */ enum special_keycodes { /* System Control */ - KB_SYSTEM_POWER = 0xB0, + KB_SYSTEM_POWER = 0xA5, KB_SYSTEM_SLEEP, - KB_SYSTEM_WAKE, + KB_SYSTEM_WAKE, /* 0xA7 */ + /* 0xA8-AF */ /* Consumer Page */ - KB_AUDIO_MUTE, + KB_AUDIO_MUTE = 0xB0, KB_AUDIO_VOL_UP, KB_AUDIO_VOL_DOWN, KB_MEDIA_NEXT_TRACK, @@ -157,13 +164,14 @@ enum special_keycodes { KB_MY_COMPUTER, KB_WWW_SEARCH, KB_WWW_HOME, - KB_WWW_BACK, /* 0xC0 */ + KB_WWW_BACK, KB_WWW_FORWARD, KB_WWW_STOP, - KB_WWW_REFRESH, - KB_WWW_FAVORITES, + KB_WWW_REFRESH, /* 0xC0 */ + KB_WWW_FAVORITES, /* 0xC1 */ + /* 0xC2-DF vacant for future use */ - /* reserve 0xE0-E7 for Modifiers */ + /* 0xE0-E7 for Modifiers. DO NOT USE. */ /* Layer Switching */ KB_FN0 = 0xE8, @@ -173,7 +181,7 @@ enum special_keycodes { KB_FN4, KB_FN5, KB_FN6, - KB_FN7, + KB_FN7, /* 0xEF */ /* Mousekey */ KB_MS_UP = 0xF0, @@ -189,11 +197,13 @@ enum special_keycodes { KB_MS_WH_UP, KB_MS_WH_DOWN, KB_MS_WH_LEFT, - KB_MS_WH_RIGHT, + KB_MS_WH_RIGHT, /* 0xFC */ + /* 0xFD-FF vacant for future use */ }; +/* USB HID Keyboard/Keypad Usage(0x07) */ enum keycodes { - KB_NO = 0, + KB_NO = 0x00, KB_ROLL_OVER, KB_POST_FAIL, KB_UNDEFINED, @@ -357,9 +367,10 @@ enum keycodes { KB_OPER, KB_CLEAR_AGAIN, KB_CRSEL, - KB_EXSEL, + KB_EXSEL, /* 0xA4 */ + + /* NOTE: 0xA5-DF are used for internal special purpose */ - /* NOTE: 0xB0-DF are used as special_keycodes */ #if 0 KB_KP_00 = 0xB0, KB_KP_000, @@ -406,7 +417,7 @@ enum keycodes { KB_KP_BINARY, KB_KP_OCTAL, KB_KP_DECIMAL, - KB_KP_HEXADECIMAL, + KB_KP_HEXADECIMAL, /* 0xDD */ #endif /* Modifiers */ @@ -419,7 +430,7 @@ enum keycodes { KB_RALT, KB_RGUI, - /* NOTE: 0xE8-FF are used as special_keycodes */ + /* NOTE: 0xE8-FF are used for internal special purpose */ }; #endif /* USB_KEYCODES_H */ From 373ab0e7192811944786c095facb80938c33f1d5 Mon Sep 17 00:00:00 2001 From: tmk Date: Tue, 9 Oct 2012 14:36:13 +0900 Subject: [PATCH 05/18] Add keycode.h and remove usb_keycodes.h. --- common/command.c | 38 ++-- common/host.c | 2 +- common/keyboard.c | 44 ++-- common/keycode.h | 441 +++++++++++++++++++++++++++++++++++++++++ common/mousekey.c | 54 ++--- common/usb_keycodes.h | 436 ---------------------------------------- keyboard/hhkb/config.h | 2 +- keyboard/hhkb/keymap.c | 51 +++-- 8 files changed, 536 insertions(+), 532 deletions(-) create mode 100644 common/keycode.h delete mode 100644 common/usb_keycodes.h diff --git a/common/command.c b/common/command.c index 0020d8a17c..f9cdaf57de 100644 --- a/common/command.c +++ b/common/command.c @@ -17,7 +17,7 @@ along with this program. If not, see . #include #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "host.h" #include "print.h" #include "debug.h" @@ -74,10 +74,10 @@ uint8_t command_extra(void) static uint8_t command_common(void) { switch (host_get_first_key()) { - case KB_H: + case KC_H: help(); break; - case KB_B: + case KC_B: host_clear_keyboard_report(); host_send_keyboard_report(); print("jump to bootloader... "); @@ -85,7 +85,7 @@ static uint8_t command_common(void) bootloader_jump(); // not return print("not supported.\n"); break; - case KB_D: + case KC_D: debug_enable = !debug_enable; if (debug_enable) { last_print_enable = true; @@ -101,34 +101,34 @@ static uint8_t command_common(void) debug_mouse = false; } break; - case KB_X: // debug matrix toggle + case KC_X: // debug matrix toggle debug_matrix = !debug_matrix; if (debug_matrix) print("debug matrix enabled.\n"); else print("debug matrix disabled.\n"); break; - case KB_K: // debug keyboard toggle + case KC_K: // debug keyboard toggle debug_keyboard = !debug_keyboard; if (debug_keyboard) print("debug keyboard enabled.\n"); else print("debug keyboard disabled.\n"); break; - case KB_M: // debug mouse toggle + case KC_M: // debug mouse toggle debug_mouse = !debug_mouse; if (debug_mouse) print("debug mouse enabled.\n"); else print("debug mouse disabled.\n"); break; - case KB_V: // print version & information + case KC_V: // print version & information print(STR(DESCRIPTION) "\n"); break; - case KB_T: // print timer + case KC_T: // print timer print("timer: "); phex16(timer_count); print("\n"); break; - case KB_P: // print toggle + case KC_P: // print toggle if (last_print_enable) { print("print disabled.\n"); last_print_enable = false; @@ -137,7 +137,7 @@ static uint8_t command_common(void) print("print enabled.\n"); } break; - case KB_S: + case KC_S: print("host_keyboard_leds:"); phex(host_keyboard_leds()); print("\n"); #ifdef HOST_PJRC print("UDCON: "); phex(UDCON); print("\n"); @@ -156,7 +156,7 @@ static uint8_t command_common(void) #endif break; #ifdef NKRO_ENABLE - case KB_N: + case KC_N: // send empty report before change host_clear_keyboard_report(); host_send_keyboard_report(); @@ -168,7 +168,7 @@ static uint8_t command_common(void) break; #endif #ifdef EXTRAKEY_ENABLE - case KB_ESC: + case KC_ESC: host_clear_keyboard_report(); host_send_keyboard_report(); #ifdef HOST_PJRC @@ -186,23 +186,23 @@ static uint8_t command_common(void) #endif break; #endif - case KB_BSPC: + case KC_BSPC: matrix_init(); print("clear matrix\n"); break; - case KB_0: + case KC_0: switch_layer(0); break; - case KB_1: + case KC_1: switch_layer(1); break; - case KB_2: + case KC_2: switch_layer(2); break; - case KB_3: + case KC_3: switch_layer(3); break; - case KB_4: + case KC_4: switch_layer(4); break; default: diff --git a/common/host.c b/common/host.c index 0a03807f73..37f707d0b3 100644 --- a/common/host.c +++ b/common/host.c @@ -17,7 +17,7 @@ along with this program. If not, see . #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "host.h" #include "util.h" #include "debug.h" diff --git a/common/keyboard.c b/common/keyboard.c index 328941df3f..6adad88824 100644 --- a/common/keyboard.c +++ b/common/keyboard.c @@ -19,7 +19,7 @@ along with this program. If not, see . #include "keymap.h" #include "host.h" #include "led.h" -#include "usb_keycodes.h" +#include "keycode.h" #include "timer.h" #include "print.h" #include "debug.h" @@ -157,58 +157,58 @@ debug("register_code\n"); debug("consumer\n"); uint16_t usage = 0; switch (code) { - case KB_AUDIO_MUTE: + case KC_AUDIO_MUTE: usage = AUDIO_MUTE; break; - case KB_AUDIO_VOL_UP: + case KC_AUDIO_VOL_UP: usage = AUDIO_VOL_UP; break; - case KB_AUDIO_VOL_DOWN: + case KC_AUDIO_VOL_DOWN: usage = AUDIO_VOL_DOWN; break; - case KB_MEDIA_NEXT_TRACK: + case KC_MEDIA_NEXT_TRACK: usage = TRANSPORT_NEXT_TRACK; break; - case KB_MEDIA_PREV_TRACK: + case KC_MEDIA_PREV_TRACK: usage = TRANSPORT_PREV_TRACK; break; - case KB_MEDIA_STOP: + case KC_MEDIA_STOP: usage = TRANSPORT_STOP; break; - case KB_MEDIA_PLAY_PAUSE: + case KC_MEDIA_PLAY_PAUSE: usage = TRANSPORT_PLAY_PAUSE; break; - case KB_MEDIA_SELECT: + case KC_MEDIA_SELECT: usage = AL_CC_CONFIG; break; - case KB_MAIL: + case KC_MAIL: usage = AL_EMAIL; break; - case KB_CALCULATOR: + case KC_CALCULATOR: usage = AL_CALCULATOR; break; - case KB_MY_COMPUTER: + case KC_MY_COMPUTER: usage = AL_LOCAL_BROWSER; break; - case KB_WWW_SEARCH: + case KC_WWW_SEARCH: usage = AC_SEARCH; break; - case KB_WWW_HOME: + case KC_WWW_HOME: usage = AC_HOME; break; - case KB_WWW_BACK: + case KC_WWW_BACK: usage = AC_BACK; break; - case KB_WWW_FORWARD: + case KC_WWW_FORWARD: usage = AC_FORWARD; break; - case KB_WWW_STOP: + case KC_WWW_STOP: usage = AC_STOP; break; - case KB_WWW_REFRESH: + case KC_WWW_REFRESH: usage = AC_REFRESH; break; - case KB_WWW_FAVORITES: + case KC_WWW_FAVORITES: usage = AC_BOOKMARKS; break; } @@ -218,13 +218,13 @@ debug("usage: "); phex16(usage); debug("\n"); else if IS_SYSTEM(code) { uint16_t usage = 0; switch (code) { - case KB_SYSTEM_POWER: + case KC_SYSTEM_POWER: usage = SYSTEM_POWER_DOWN; break; - case KB_SYSTEM_SLEEP: + case KC_SYSTEM_SLEEP: usage = SYSTEM_SLEEP; break; - case KB_SYSTEM_WAKE: + case KC_SYSTEM_WAKE: usage = SYSTEM_WAKE_UP; break; } diff --git a/common/keycode.h b/common/keycode.h new file mode 100644 index 0000000000..4ed78a46a6 --- /dev/null +++ b/common/keycode.h @@ -0,0 +1,441 @@ +/* +Copyright 2011,2012 Jun Wako + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ + +/* + * Keycodes based on HID Usage Keyboard/Keypad Page(0x07) plus special codes + * http://www.usb.org/developers/devclass_docs/Hut1_12.pdf + */ +#ifndef KEYCODE_H +#define KEYCODE_H + + +#define IS_ERROR(code) (KC_ROLL_OVER <= (code) && (code) <= KC_UNDEFINED) +#define IS_ANY(code) (KC_A <= (code) && (code) <= 0xFF) +#define IS_KEY(code) (KC_A <= (code) && (code) <= KC_EXSEL) +#define IS_MOD(code) (KC_LCTRL <= (code) && (code) <= KC_RGUI) + +#define IS_FN(code) (KC_FN0 <= (code) && (code) <= KC_FN7) +#define IS_MOUSEKEY(code) (KC_MS_UP <= (code) && (code) <= KC_MS_WH_RIGHT) +#define IS_MOUSEKEY_MOVE(code) (KC_MS_UP <= (code) && (code) <= KC_MS_RIGHT) +#define IS_MOUSEKEY_BUTTON(code) (KC_MS_BTN1 <= (code) && (code) <= KC_MS_BTN5) +#define IS_MOUSEKEY_WHEEL(code) (KC_MS_WH_UP <= (code) && (code) <= KC_MS_WH_RIGHT) + +#define IS_SPECIAL(code) ((0xB0 <= (code) && (code) <= 0xDF) || (0xE8 <= (code) && (code) <= 0xFF)) +#define IS_CONSUMER(code) (KC_MUTE <= (code) && (code) <= KC_WFAV) +#define IS_SYSTEM(code) (KC_POWER <= (code) && (code) <= KC_WAKE) + +#define MOD_BIT(code) (1< */ + KC_SLASH, /* / and ? */ + KC_CAPSLOCK, + KC_F1, + KC_F2, + KC_F3, + KC_F4, + KC_F5, + KC_F6, + KC_F7, /* 0x40 */ + KC_F8, + KC_F9, + KC_F10, + KC_F11, + KC_F12, + KC_PSCREEN, + KC_SCKLOCK, + KC_PAUSE, + KC_INSERT, + KC_HOME, + KC_PGUP, + KC_DELETE, + KC_END, + KC_PGDOWN, + KC_RIGHT, + KC_LEFT, /* 0x50 */ + KC_DOWN, + KC_UP, + KC_NUMLOCK, + KC_KP_SLASH, + KC_KP_ASTERISK, + KC_KP_MINUS, + KC_KP_PLUS, + KC_KP_ENTER, + KC_KP_1, + KC_KP_2, + KC_KP_3, + KC_KP_4, + KC_KP_5, + KC_KP_6, + KC_KP_7, + KC_KP_8, /* 0x60 */ + KC_KP_9, + KC_KP_0, + KC_KP_DOT, + KC_NONUS_BSLASH, /* Non-US \ and | */ + KC_APPLICATION, + KC_POWER, + KC_KP_EQUAL, + KC_F13, + KC_F14, + KC_F15, + KC_F16, + KC_F17, + KC_F18, + KC_F19, + KC_F20, + KC_F21, /* 0x70 */ + KC_F22, + KC_F23, + KC_F24, + KC_EXECUTE, + KC_HELP, + KC_MENU, + KC_SELECT, + KC_STOP, + KC_AGAIN, + KC_UNDO, + KC_CUT, + KC_COPY, + KC_PASTE, + KC_FIND, + KC__MUTE, + KC__VOLUP, /* 0x80 */ + KC__VOLDOWN, + KC_LOCKING_CAPS, /* locking Caps Lock */ + KC_LOCKING_NUM, /* locking Num Lock */ + KC_LOCKING_SCROLL, /* locking Scroll Lock */ + KC_KP_COMMA, + KC_KP_EQUAL_AS400, /* equal sign on AS/400 */ + KC_INT1, + KC_INT2, + KC_INT3, + KC_INT4, + KC_INT5, + KC_INT6, + KC_INT7, + KC_INT8, + KC_INT9, + KC_LANG1, /* 0x90 */ + KC_LANG2, + KC_LANG3, + KC_LANG4, + KC_LANG5, + KC_LANG6, + KC_LANG7, + KC_LANG8, + KC_LANG9, + KC_ALT_ERASE, + KC_SYSREQ, + KC_CANCEL, + KC_CLEAR, + KC_PRIOR, + KC_RETURN, + KC_SEPARATOR, + KC_OUT, /* 0xA0 */ + KC_OPER, + KC_CLEAR_AGAIN, + KC_CRSEL, + KC_EXSEL, /* 0xA4 */ + + /* NOTE: 0xA5-DF are used for internal special purpose */ + +#if 0 + /* NOTE: Following codes(0xB0-DD) are not used. Leave them for reference. */ + KC_KP_00 = 0xB0, + KC_KP_000, + KC_THOUSANDS_SEPARATOR, + KC_DECIMAL_SEPARATOR, + KC_CURRENCY_UNIT, + KC_CURRENCY_SUB_UNIT, + KC_KP_LPAREN, + KC_KP_RPAREN, + KC_KP_LCBRACKET, /* { */ + KC_KP_RCBRACKET, /* } */ + KC_KP_TAB, + KC_KP_BSPACE, + KC_KP_A, + KC_KP_B, + KC_KP_C, + KC_KP_D, + KC_KP_E, /* 0xC0 */ + KC_KP_F, + KC_KP_XOR, + KC_KP_HAT, + KC_KP_PERC, + KC_KP_LT, + KC_KP_GT, + KC_KP_AND, + KC_KP_LAZYAND, + KC_KP_OR, + KC_KP_LAZYOR, + KC_KP_COLON, + KC_KP_HASH, + KC_KP_SPACE, + KC_KP_ATMARK, + KC_KP_EXCLAMATION, + KC_KP_MEM_STORE, /* 0xD0 */ + KC_KP_MEM_RECALL, + KC_KP_MEM_CLEAR, + KC_KP_MEM_ADD, + KC_KP_MEM_SUB, + KC_KP_MEM_MUL, + KC_KP_MEM_DIV, + KC_KP_PLUS_MINUS, + KC_KP_CLEAR, + KC_KP_CLEAR_ENTRY, + KC_KP_BINARY, + KC_KP_OCTAL, + KC_KP_DECIMAL, + KC_KP_HEXADECIMAL, /* 0xDD */ +#endif + + /* Modifiers */ + KC_LCTRL = 0xE0, + KC_LSHIFT, + KC_LALT, + KC_LGUI, + KC_RCTRL, + KC_RSHIFT, + KC_RALT, + KC_RGUI, + + /* NOTE: 0xE8-FF are used for internal special purpose */ +}; + +/* Special keycodes */ +/* NOTE: 0xA5-DF and 0xE8-FF are used for internal special purpose */ +enum internal_special_keycodes { + /* System Control */ + KC_SYSTEM_POWER = 0xA5, + KC_SYSTEM_SLEEP, + KC_SYSTEM_WAKE, /* 0xA7 */ + /* 0xA8-AF */ + + /* Consumer Page */ + KC_AUDIO_MUTE = 0xB0, + KC_AUDIO_VOL_UP, + KC_AUDIO_VOL_DOWN, + KC_MEDIA_NEXT_TRACK, + KC_MEDIA_PREV_TRACK, + KC_MEDIA_STOP, + KC_MEDIA_PLAY_PAUSE, + KC_MEDIA_SELECT, + KC_MAIL, + KC_CALCULATOR, + KC_MY_COMPUTER, + KC_WWW_SEARCH, + KC_WWW_HOME, + KC_WWW_BACK, + KC_WWW_FORWARD, + KC_WWW_STOP, + KC_WWW_REFRESH, /* 0xC0 */ + KC_WWW_FAVORITES, /* 0xC1 */ + /* 0xC2-DF vacant for future use */ + + /* 0xE0-E7 for Modifiers. DO NOT USE. */ + + /* Layer Switching */ + KC_FN0 = 0xE8, + KC_FN1, + KC_FN2, + KC_FN3, + KC_FN4, + KC_FN5, + KC_FN6, + KC_FN7, /* 0xEF */ + + /* Mousekey */ + KC_MS_UP = 0xF0, + KC_MS_DOWN, + KC_MS_LEFT, + KC_MS_RIGHT, + KC_MS_BTN1, + KC_MS_BTN2, + KC_MS_BTN3, + KC_MS_BTN4, + KC_MS_BTN5, + /* Mousekey wheel */ + KC_MS_WH_UP, + KC_MS_WH_DOWN, + KC_MS_WH_LEFT, + KC_MS_WH_RIGHT, /* 0xFC */ + /* 0xFD-FF vacant for future use */ +}; + +#endif /* KEYCODE_H */ diff --git a/common/mousekey.c b/common/mousekey.c index 222d9e4455..58a6e35bb0 100644 --- a/common/mousekey.c +++ b/common/mousekey.c @@ -17,7 +17,7 @@ along with this program. If not, see . #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "host.h" #include "timer.h" #include "print.h" @@ -90,36 +90,36 @@ void mousekey_task(void) void mousekey_on(uint8_t code) { - if (code == KB_MS_UP) report.y = MOUSEKEY_MOVE_INIT * -1; - else if (code == KB_MS_DOWN) report.y = MOUSEKEY_MOVE_INIT; - else if (code == KB_MS_LEFT) report.x = MOUSEKEY_MOVE_INIT * -1; - else if (code == KB_MS_RIGHT) report.x = MOUSEKEY_MOVE_INIT; - else if (code == KB_MS_WH_UP) report.v = MOUSEKEY_WHEEL_INIT; - else if (code == KB_MS_WH_DOWN) report.v = MOUSEKEY_WHEEL_INIT * -1; - else if (code == KB_MS_WH_LEFT) report.h = MOUSEKEY_WHEEL_INIT * -1; - else if (code == KB_MS_WH_RIGHT) report.h = MOUSEKEY_WHEEL_INIT; - else if (code == KB_MS_BTN1) report.buttons |= MOUSE_BTN1; - else if (code == KB_MS_BTN2) report.buttons |= MOUSE_BTN2; - else if (code == KB_MS_BTN3) report.buttons |= MOUSE_BTN3; - else if (code == KB_MS_BTN4) report.buttons |= MOUSE_BTN4; - else if (code == KB_MS_BTN5) report.buttons |= MOUSE_BTN5; + if (code == KC_MS_UP) report.y = MOUSEKEY_MOVE_INIT * -1; + else if (code == KC_MS_DOWN) report.y = MOUSEKEY_MOVE_INIT; + else if (code == KC_MS_LEFT) report.x = MOUSEKEY_MOVE_INIT * -1; + else if (code == KC_MS_RIGHT) report.x = MOUSEKEY_MOVE_INIT; + else if (code == KC_MS_WH_UP) report.v = MOUSEKEY_WHEEL_INIT; + else if (code == KC_MS_WH_DOWN) report.v = MOUSEKEY_WHEEL_INIT * -1; + else if (code == KC_MS_WH_LEFT) report.h = MOUSEKEY_WHEEL_INIT * -1; + else if (code == KC_MS_WH_RIGHT) report.h = MOUSEKEY_WHEEL_INIT; + else if (code == KC_MS_BTN1) report.buttons |= MOUSE_BTN1; + else if (code == KC_MS_BTN2) report.buttons |= MOUSE_BTN2; + else if (code == KC_MS_BTN3) report.buttons |= MOUSE_BTN3; + else if (code == KC_MS_BTN4) report.buttons |= MOUSE_BTN4; + else if (code == KC_MS_BTN5) report.buttons |= MOUSE_BTN5; } void mousekey_off(uint8_t code) { - if (code == KB_MS_UP && report.y < 0) report.y = 0; - else if (code == KB_MS_DOWN && report.y > 0) report.y = 0; - else if (code == KB_MS_LEFT && report.x < 0) report.x = 0; - else if (code == KB_MS_RIGHT && report.x > 0) report.x = 0; - else if (code == KB_MS_WH_UP && report.v > 0) report.v = 0; - else if (code == KB_MS_WH_DOWN && report.v < 0) report.v = 0; - else if (code == KB_MS_WH_LEFT && report.h < 0) report.h = 0; - else if (code == KB_MS_WH_RIGHT && report.h > 0) report.h = 0; - else if (code == KB_MS_BTN1) report.buttons &= ~MOUSE_BTN1; - else if (code == KB_MS_BTN2) report.buttons &= ~MOUSE_BTN2; - else if (code == KB_MS_BTN3) report.buttons &= ~MOUSE_BTN3; - else if (code == KB_MS_BTN4) report.buttons &= ~MOUSE_BTN4; - else if (code == KB_MS_BTN5) report.buttons &= ~MOUSE_BTN5; + if (code == KC_MS_UP && report.y < 0) report.y = 0; + else if (code == KC_MS_DOWN && report.y > 0) report.y = 0; + else if (code == KC_MS_LEFT && report.x < 0) report.x = 0; + else if (code == KC_MS_RIGHT && report.x > 0) report.x = 0; + else if (code == KC_MS_WH_UP && report.v > 0) report.v = 0; + else if (code == KC_MS_WH_DOWN && report.v < 0) report.v = 0; + else if (code == KC_MS_WH_LEFT && report.h < 0) report.h = 0; + else if (code == KC_MS_WH_RIGHT && report.h > 0) report.h = 0; + else if (code == KC_MS_BTN1) report.buttons &= ~MOUSE_BTN1; + else if (code == KC_MS_BTN2) report.buttons &= ~MOUSE_BTN2; + else if (code == KC_MS_BTN3) report.buttons &= ~MOUSE_BTN3; + else if (code == KC_MS_BTN4) report.buttons &= ~MOUSE_BTN4; + else if (code == KC_MS_BTN5) report.buttons &= ~MOUSE_BTN5; if (report.x == 0 && report.y == 0 && report.v == 0 && report.h == 0) mousekey_repeat = 0; diff --git a/common/usb_keycodes.h b/common/usb_keycodes.h deleted file mode 100644 index 6a44374189..0000000000 --- a/common/usb_keycodes.h +++ /dev/null @@ -1,436 +0,0 @@ -/* -Copyright 2011 Jun Wako - -This program is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 2 of the License, or -(at your option) any later version. - -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this program. If not, see . -*/ - -/* - * Key codes: HID Keyboard/Keypad Page(0x07) - * http://www.usb.org/developers/devclass_docs/Hut1_12.pdf - */ -#ifndef USB_KEYCODES_H -#define USB_KEYCODES_H - - -#define IS_ERROR(code) (KB_ROLL_OVER <= (code) && (code) <= KB_UNDEFINED) -#define IS_ANY(code) (KB_A <= (code) && (code) <= 0xFF) -#define IS_KEY(code) (KB_A <= (code) && (code) <= KB_EXSEL) -#define IS_MOD(code) (KB_LCTRL <= (code) && (code) <= KB_RGUI) - -#define IS_FN(code) (KB_FN0 <= (code) && (code) <= KB_FN7) -#define IS_MOUSEKEY(code) (KB_MS_UP <= (code) && (code) <= KB_MS_WH_RIGHT) -#define IS_MOUSEKEY_MOVE(code) (KB_MS_UP <= (code) && (code) <= KB_MS_RIGHT) -#define IS_MOUSEKEY_BUTTON(code) (KB_MS_BTN1 <= (code) && (code) <= KB_MS_BTN5) -#define IS_MOUSEKEY_WHEEL(code) (KB_MS_WH_UP <= (code) && (code) <= KB_MS_WH_RIGHT) - -#define IS_SPECIAL(code) ((0xB0 <= (code) && (code) <= 0xDF) || (0xE8 <= (code) && (code) <= 0xFF)) -#define IS_CONSUMER(code) (KB_MUTE <= (code) && (code) <= KB_WFAV) -#define IS_SYSTEM(code) (KB_POWER <= (code) && (code) <= KB_WAKE) - -#define MOD_BIT(code) (1<<((code) & 0x07)) -#define FN_BIT(code) (1<<((code) - KB_FN0)) -#define FN_INDEX(code) ((code) - KB_FN0) - - -/* Short names */ -#define KB_LCTL KB_LCTRL -#define KB_RCTL KB_RCTRL -#define KB_LSFT KB_LSHIFT -#define KB_RSFT KB_RSHIFT -#define KB_ESC KB_ESCAPE -#define KB_BSPC KB_BSPACE -#define KB_ENT KB_ENTER -#define KB_DEL KB_DELETE -#define KB_INS KB_INSERT -#define KB_CAPS KB_CAPSLOCK -#define KB_RGHT KB_RIGHT -#define KB_PGDN KB_PGDOWN -#define KB_PSCR KB_PSCREEN -#define KB_SLCK KB_SCKLOCK -#define KB_PAUS KB_PAUSE -#define KB_BRK KB_PAUSE -#define KB_NLCK KB_NUMLOCK -#define KB_SPC KB_SPACE -#define KB_MINS KB_MINUS -#define KB_EQL KB_EQUAL -#define KB_GRV KB_GRAVE -#define KB_RBRC KB_RBRACKET -#define KB_LBRC KB_LBRACKET -#define KB_COMM KB_COMMA -#define KB_BSLS KB_BSLASH -#define KB_SLSH KB_SLASH -#define KB_SCLN KB_SCOLON -#define KB_QUOT KB_QUOTE -#define KB_APP KB_APPLICATION -#define KB_NUHS KB_NONUS_HASH -#define KB_NUBS KB_NONUS_BSLASH -#define KB_ERAS KB_ALT_ERASE, -#define KB_CLR KB_CLEAR -/* for Japanese */ -#define KB_ZKHK KB_GRAVE -#define KB_RO KB_INT1 -#define KB_KANA KB_INT2 -#define KB_JYEN KB_INT3 -#define KB_HENK KB_INT4 -#define KB_MHEN KB_INT5 -/* Keypad */ -#define KB_P1 KB_KP_1 -#define KB_P2 KB_KP_2 -#define KB_P3 KB_KP_3 -#define KB_P4 KB_KP_4 -#define KB_P5 KB_KP_5 -#define KB_P6 KB_KP_6 -#define KB_P7 KB_KP_7 -#define KB_P8 KB_KP_8 -#define KB_P9 KB_KP_9 -#define KB_P0 KB_KP_0 -#define KB_PDOT KB_KP_DOT -#define KB_PCMM KB_KP_COMMA -#define KB_PSLS KB_KP_SLASH -#define KB_PAST KB_KP_ASTERISK -#define KB_PMNS KB_KP_MINUS -#define KB_PPLS KB_KP_PLUS -#define KB_PEQL KB_KP_EQUAL -#define KB_PENT KB_KP_ENTER -/* Mousekey */ -#define KB_MS_U KB_MS_UP -#define KB_MS_D KB_MS_DOWN -#define KB_MS_L KB_MS_LEFT -#define KB_MS_R KB_MS_RIGHT -#define KB_BTN1 KB_MS_BTN1 -#define KB_BTN2 KB_MS_BTN2 -#define KB_BTN3 KB_MS_BTN3 -#define KB_BTN4 KB_MS_BTN4 -#define KB_BTN5 KB_MS_BTN5 -#define KB_WH_U KB_MS_WH_UP -#define KB_WH_D KB_MS_WH_DOWN -#define KB_WH_L KB_MS_WH_LEFT -#define KB_WH_R KB_MS_WH_RIGHT -/* Sytem Control & Consumer usage */ -#define KB_PWR KB_SYSTEM_POWER -#define KB_SLEP KB_SYSTEM_SLEEP -#define KB_WAKE KB_SYSTEM_WAKE -#define KB_MUTE KB_AUDIO_MUTE -#define KB_VOLU KB_AUDIO_VOL_UP -#define KB_VOLD KB_AUDIO_VOL_DOWN -#define KB_MNXT KB_MEDIA_NEXT_TRACK -#define KB_MPRV KB_MEDIA_PREV_TRACK -#define KB_MSTP KB_MEDIA_STOP -#define KB_MPLY KB_MEDIA_PLAY_PAUSE -#define KB_MSEL KB_MEDIA_SELECT -#define KB_MAIL KB_MAIL -#define KB_CALC KB_CALCULATOR -#define KB_MYCM KB_MY_COMPUTER -#define KB_WSCH KB_WWW_SEARCH -#define KB_WHOM KB_WWW_HOME -#define KB_WBAK KB_WWW_BACK -#define KB_WFWD KB_WWW_FORWARD -#define KB_WSTP KB_WWW_STOP -#define KB_WREF KB_WWW_REFRESH -#define KB_WFAV KB_WWW_FAVORITES - - -/* Special keycode */ -/* NOTE: 0xA5-DF and 0xE8-FF can be used for internal special purpose */ -enum special_keycodes { - /* System Control */ - KB_SYSTEM_POWER = 0xA5, - KB_SYSTEM_SLEEP, - KB_SYSTEM_WAKE, /* 0xA7 */ - /* 0xA8-AF */ - - /* Consumer Page */ - KB_AUDIO_MUTE = 0xB0, - KB_AUDIO_VOL_UP, - KB_AUDIO_VOL_DOWN, - KB_MEDIA_NEXT_TRACK, - KB_MEDIA_PREV_TRACK, - KB_MEDIA_STOP, - KB_MEDIA_PLAY_PAUSE, - KB_MEDIA_SELECT, - KB_MAIL, - KB_CALCULATOR, - KB_MY_COMPUTER, - KB_WWW_SEARCH, - KB_WWW_HOME, - KB_WWW_BACK, - KB_WWW_FORWARD, - KB_WWW_STOP, - KB_WWW_REFRESH, /* 0xC0 */ - KB_WWW_FAVORITES, /* 0xC1 */ - /* 0xC2-DF vacant for future use */ - - /* 0xE0-E7 for Modifiers. DO NOT USE. */ - - /* Layer Switching */ - KB_FN0 = 0xE8, - KB_FN1, - KB_FN2, - KB_FN3, - KB_FN4, - KB_FN5, - KB_FN6, - KB_FN7, /* 0xEF */ - - /* Mousekey */ - KB_MS_UP = 0xF0, - KB_MS_DOWN, - KB_MS_LEFT, - KB_MS_RIGHT, - KB_MS_BTN1, - KB_MS_BTN2, - KB_MS_BTN3, - KB_MS_BTN4, - KB_MS_BTN5, - /* Mousekey wheel */ - KB_MS_WH_UP, - KB_MS_WH_DOWN, - KB_MS_WH_LEFT, - KB_MS_WH_RIGHT, /* 0xFC */ - /* 0xFD-FF vacant for future use */ -}; - -/* USB HID Keyboard/Keypad Usage(0x07) */ -enum keycodes { - KB_NO = 0x00, - KB_ROLL_OVER, - KB_POST_FAIL, - KB_UNDEFINED, - KB_A, - KB_B, - KB_C, - KB_D, - KB_E, - KB_F, - KB_G, - KB_H, - KB_I, - KB_J, - KB_K, - KB_L, - KB_M, /* 0x10 */ - KB_N, - KB_O, - KB_P, - KB_Q, - KB_R, - KB_S, - KB_T, - KB_U, - KB_V, - KB_W, - KB_X, - KB_Y, - KB_Z, - KB_1, - KB_2, - KB_3, /* 0x20 */ - KB_4, - KB_5, - KB_6, - KB_7, - KB_8, - KB_9, - KB_0, - KB_ENTER, - KB_ESCAPE, - KB_BSPACE, - KB_TAB, - KB_SPACE, - KB_MINUS, - KB_EQUAL, - KB_LBRACKET, - KB_RBRACKET, /* 0x30 */ - KB_BSLASH, /* \ (and |) */ - KB_NONUS_HASH, /* Non-US # and ~ */ - KB_SCOLON, /* ; (and :) */ - KB_QUOTE, /* ' and " */ - KB_GRAVE, /* Grave accent and tilde */ - KB_COMMA, /* , and < */ - KB_DOT, /* . and > */ - KB_SLASH, /* / and ? */ - KB_CAPSLOCK, - KB_F1, - KB_F2, - KB_F3, - KB_F4, - KB_F5, - KB_F6, - KB_F7, /* 0x40 */ - KB_F8, - KB_F9, - KB_F10, - KB_F11, - KB_F12, - KB_PSCREEN, - KB_SCKLOCK, - KB_PAUSE, - KB_INSERT, - KB_HOME, - KB_PGUP, - KB_DELETE, - KB_END, - KB_PGDOWN, - KB_RIGHT, - KB_LEFT, /* 0x50 */ - KB_DOWN, - KB_UP, - KB_NUMLOCK, - KB_KP_SLASH, - KB_KP_ASTERISK, - KB_KP_MINUS, - KB_KP_PLUS, - KB_KP_ENTER, - KB_KP_1, - KB_KP_2, - KB_KP_3, - KB_KP_4, - KB_KP_5, - KB_KP_6, - KB_KP_7, - KB_KP_8, /* 0x60 */ - KB_KP_9, - KB_KP_0, - KB_KP_DOT, - KB_NONUS_BSLASH, /* Non-US \ and | */ - KB_APPLICATION, - KB_POWER, - KB_KP_EQUAL, - KB_F13, - KB_F14, - KB_F15, - KB_F16, - KB_F17, - KB_F18, - KB_F19, - KB_F20, - KB_F21, /* 0x70 */ - KB_F22, - KB_F23, - KB_F24, - KB_EXECUTE, - KB_HELP, - KB_MENU, - KB_SELECT, - KB_STOP, - KB_AGAIN, - KB_UNDO, - KB_CUT, - KB_COPY, - KB_PASTE, - KB_FIND, - KB__MUTE, - KB__VOLUP, /* 0x80 */ - KB__VOLDOWN, - KB_LOCKING_CAPS, /* locking Caps Lock */ - KB_LOCKING_NUM, /* locking Num Lock */ - KB_LOCKING_SCROLL, /* locking Scroll Lock */ - KB_KP_COMMA, - KB_KP_EQUAL_AS400, /* equal sign on AS/400 */ - KB_INT1, - KB_INT2, - KB_INT3, - KB_INT4, - KB_INT5, - KB_INT6, - KB_INT7, - KB_INT8, - KB_INT9, - KB_LANG1, /* 0x90 */ - KB_LANG2, - KB_LANG3, - KB_LANG4, - KB_LANG5, - KB_LANG6, - KB_LANG7, - KB_LANG8, - KB_LANG9, - KB_ALT_ERASE, - KB_SYSREQ, - KB_CANCEL, - KB_CLEAR, - KB_PRIOR, - KB_RETURN, - KB_SEPARATOR, - KB_OUT, /* 0xA0 */ - KB_OPER, - KB_CLEAR_AGAIN, - KB_CRSEL, - KB_EXSEL, /* 0xA4 */ - - /* NOTE: 0xA5-DF are used for internal special purpose */ - -#if 0 - KB_KP_00 = 0xB0, - KB_KP_000, - KB_THOUSANDS_SEPARATOR, - KB_DECIMAL_SEPARATOR, - KB_CURRENCY_UNIT, - KB_CURRENCY_SUB_UNIT, - KB_KP_LPAREN, - KB_KP_RPAREN, - KB_KP_LCBRACKET, /* { */ - KB_KP_RCBRACKET, /* } */ - KB_KP_TAB, - KB_KP_BSPACE, - KB_KP_A, - KB_KP_B, - KB_KP_C, - KB_KP_D, - KB_KP_E, /* 0xC0 */ - KB_KP_F, - KB_KP_XOR, - KB_KP_HAT, - KB_KP_PERC, - KB_KP_LT, - KB_KP_GT, - KB_KP_AND, - KB_KP_LAZYAND, - KB_KP_OR, - KB_KP_LAZYOR, - KB_KP_COLON, - KB_KP_HASH, - KB_KP_SPACE, - KB_KP_ATMARK, - KB_KP_EXCLAMATION, - KB_KP_MEM_STORE, /* 0xD0 */ - KB_KP_MEM_RECALL, - KB_KP_MEM_CLEAR, - KB_KP_MEM_ADD, - KB_KP_MEM_SUB, - KB_KP_MEM_MUL, - KB_KP_MEM_DIV, - KB_KP_PLUS_MINUS, - KB_KP_CLEAR, - KB_KP_CLEAR_ENTRY, - KB_KP_BINARY, - KB_KP_OCTAL, - KB_KP_DECIMAL, - KB_KP_HEXADECIMAL, /* 0xDD */ -#endif - - /* Modifiers */ - KB_LCTRL = 0xE0, - KB_LSHIFT, - KB_LALT, - KB_LGUI, - KB_RCTRL, - KB_RSHIFT, - KB_RALT, - KB_RGUI, - - /* NOTE: 0xE8-FF are used for internal special purpose */ -}; - -#endif /* USB_KEYCODES_H */ diff --git a/keyboard/hhkb/config.h b/keyboard/hhkb/config.h index 17a4494065..e10a7ab37f 100644 --- a/keyboard/hhkb/config.h +++ b/keyboard/hhkb/config.h @@ -38,7 +38,7 @@ along with this program. If not, see . /* key combination for command */ -#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT))) +#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) /* mouse keys */ #ifdef MOUSEKEY_ENABLE diff --git a/keyboard/hhkb/keymap.c b/keyboard/hhkb/keymap.c index 43f777c564..3cfa5ff33b 100644 --- a/keyboard/hhkb/keymap.c +++ b/keyboard/hhkb/keymap.c @@ -22,7 +22,7 @@ along with this program. If not, see . #include #include #include "host.h" -#include "usb_keycodes.h" +#include "keycode.h" #include "print.h" #include "debug.h" #include "util.h" @@ -39,14 +39,14 @@ along with this program. If not, see . K35, K36, K37, K57, K56 \ ) \ { \ - { KB_##K00, KB_##K01, KB_##K02, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \ - { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ - { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \ - { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \ - { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \ - { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ - { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_##K66, KB_NO }, \ - { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_NO } \ + { KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \ + { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \ + { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \ + { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \ + { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \ + { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \ + { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_NO }, \ + { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_NO } \ } #define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)])) @@ -67,14 +67,14 @@ static const uint8_t PROGMEM fn_layer[] = { // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer. // See layer.c for details. static const uint8_t PROGMEM fn_keycode[] = { - KB_NO, // Fn0 - KB_NO, // Fn1 - KB_SLSH, // Fn2 - KB_SCLN, // Fn3 - KB_NO, // Fn4 - KB_SPC, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_NO, // Fn0 + KC_NO, // Fn1 + KC_SLSH, // Fn2 + KC_SCLN, // Fn3 + KC_NO, // Fn4 + KC_SPC, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 }; static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { @@ -95,7 +95,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSPC, \ LCTL,A, S, D, F, G, H, J, K, L, FN3, QUOT,ENT, \ LSFT,Z, X, C, V, B, N, M, COMM,DOT, FN2, RSFT,FN1, \ - LGUI,LALT, SPC, RALT,FN4), + LGUI,LALT, FN5, RALT,FN4), /* Layer 1: HHKB mode (HHKB Fn) * ,-----------------------------------------------------------. @@ -151,10 +151,10 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { */ #ifdef HOST_IWRAP // iWRAP does not support mouse wheel, use these keycodes to remap as wheel -#define KB_KPPL KB_KP_PLUS -#define KB_KPMI KB_KP_MINUS -#define KB_KPAS KB_KP_ASTERISK -#define KB_KPSL KB_KP_SLASH +#define KC_KPPL KC_KP_PLUS +#define KC_KPMI KC_KP_MINUS +#define KC_KPAS KC_KP_ASTERISK +#define KC_KPSL KC_KP_SLASH KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ TAB, KPAS,KPPL,MS_U,KPMI,KPSL,KPAS,KPPL,KPMI,KPSL,NO, NO, NO, BSPC, \ LCTL,NO, MS_L,MS_D,MS_R,NO, MS_L,MS_D,MS_U,MS_R,FN3, NO, ENT, \ @@ -181,14 +181,13 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * |Gui |Alt |xxxxxxxxxxxxxxxxxxxxxxx|Alt |Gui| * `--------------------------------------------' */ -/* KEYMAP(MINS,0, 9, 8, 7, 6, 5, 4, 3, 2, 1, NO, NO, NO, ESC, \ BSPC,P, O, I, U, Y, T, R, E, W, Q, NO, NO, TAB, \ LCTL,SCLN,L, K, J, H, G, F, D, S, A, RCTL,RCTL, \ LSFT,SLSH,DOT, COMM,M, N, B, V, C, X, Z, RSFT,NO, \ - LGUI,LALT, FN5, RALT,RGUI) -*/ - /* Mouse mode (Space) */ + LGUI,LALT, FN5, RALT,RGUI), + + /* Layer5: another Mouse mode (Space) */ #ifdef HOST_IWRAP KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ TAB, KPAS,KPPL,MS_U,KPMI,KPSL,KPAS,KPPL,KPMI,KPSL,NO, NO, NO, BSPC, \ From 71ac82337f803e8ec0c081b3221ac0ccf61035b0 Mon Sep 17 00:00:00 2001 From: tmk Date: Tue, 9 Oct 2012 16:50:14 +0900 Subject: [PATCH 06/18] Clean host.h interface. --- common/command.c | 7 --- common/host.c | 85 +++++++++---------------------------- common/host.h | 21 ++++----- common/keyboard.c | 84 ++++++++++++++++++++---------------- keyboard/hhkb/config_vusb.h | 2 +- protocol/vusb/vusb.c | 4 +- 6 files changed, 81 insertions(+), 122 deletions(-) diff --git a/common/command.c b/common/command.c index f9cdaf57de..16c6cfb889 100644 --- a/common/command.c +++ b/common/command.c @@ -78,8 +78,6 @@ static uint8_t command_common(void) help(); break; case KC_B: - host_clear_keyboard_report(); - host_send_keyboard_report(); print("jump to bootloader... "); _delay_ms(1000); bootloader_jump(); // not return @@ -157,9 +155,6 @@ static uint8_t command_common(void) break; #ifdef NKRO_ENABLE case KC_N: - // send empty report before change - host_clear_keyboard_report(); - host_send_keyboard_report(); keyboard_nkro = !keyboard_nkro; if (keyboard_nkro) print("NKRO: enabled\n"); @@ -169,8 +164,6 @@ static uint8_t command_common(void) #endif #ifdef EXTRAKEY_ENABLE case KC_ESC: - host_clear_keyboard_report(); - host_send_keyboard_report(); #ifdef HOST_PJRC if (suspend && remote_wakeup) { usb_remote_wakeup(); diff --git a/common/host.c b/common/host.c index 37f707d0b3..a671c97d30 100644 --- a/common/host.c +++ b/common/host.c @@ -1,5 +1,5 @@ /* -Copyright 2011 Jun Wako +Copyright 2011,2012 Jun Wako This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -28,10 +28,7 @@ bool keyboard_nkro = false; #endif static host_driver_t *driver; -static report_keyboard_t report0; -static report_keyboard_t report1; -report_keyboard_t *keyboard_report = &report0; -report_keyboard_t *keyboard_report_prev = &report1; +report_keyboard_t *keyboard_report = &(report_keyboard_t){}; static inline void add_key_byte(uint8_t code); @@ -56,27 +53,6 @@ uint8_t host_keyboard_leds(void) return (*driver->keyboard_leds)(); } -/* new interface */ -void host_register_key(uint8_t key) -{ - host_add_key(key); - host_send_keyboard_report(); -} - -void host_unregister_key(uint8_t key) -{ - host_del_key(key); - host_send_keyboard_report(); -} - -void host_clear_all_keys_but_mods(void) -{ - for (int8_t i = 0; i < REPORT_KEYS; i++) { - keyboard_report->keys[i] = 0; - } - host_send_keyboard_report(); -} - /* keyboard report operations */ void host_add_key(uint8_t key) { @@ -100,6 +76,13 @@ void host_del_key(uint8_t key) del_key_byte(key); } +void host_clear_keys(void) +{ + for (int8_t i = 0; i < REPORT_KEYS; i++) { + keyboard_report->keys[i] = 0; + } +} + void host_add_mod_bit(uint8_t mod) { keyboard_report->mods |= mod; @@ -115,40 +98,9 @@ void host_set_mods(uint8_t mods) keyboard_report->mods = mods; } -void host_add_code(uint8_t code) -{ - if (IS_MOD(code)) { - host_add_mod_bit(MOD_BIT(code)); - } else { - host_add_key(code); - } -} - -void host_del_code(uint8_t code) -{ - if (IS_MOD(code)) { - host_del_mod_bit(MOD_BIT(code)); - } else { - host_del_key(code); - } -} - -void host_swap_keyboard_report(void) -{ - uint8_t sreg = SREG; - cli(); - report_keyboard_t *tmp = keyboard_report_prev; - keyboard_report_prev = keyboard_report; - keyboard_report = tmp; - SREG = sreg; -} - -void host_clear_keyboard_report(void) +void host_clear_mods(void) { keyboard_report->mods = 0; - for (int8_t i = 0; i < REPORT_KEYS; i++) { - keyboard_report->keys[i] = 0; - } } uint8_t host_has_anykey(void) @@ -174,7 +126,6 @@ uint8_t host_get_first_key(void) return keyboard_report->keys[0]; } - void host_send_keyboard_report(void) { if (!driver) return; @@ -189,6 +140,14 @@ void host_send_keyboard_report(void) } } + +/* send report */ +void host_keyboard_send(report_keyboard_t *report) +{ + if (!driver) return; + (*driver->send_keyboard)(report); +} + void host_mouse_send(report_mouse_t *report) { if (!driver) return; @@ -218,17 +177,13 @@ void host_consumer_send(uint16_t data) static inline void add_key_byte(uint8_t code) { - // TODO: fix ugly code int8_t i = 0; int8_t empty = -1; for (; i < REPORT_KEYS; i++) { - if (keyboard_report_prev->keys[i] == code) { - keyboard_report->keys[i] = code; + if (keyboard_report->keys[i] == code) { break; } - if (empty == -1 && - keyboard_report_prev->keys[i] == 0 && - keyboard_report->keys[i] == 0) { + if (empty == -1 && keyboard_report->keys[i] == 0) { empty = i; } } diff --git a/common/host.h b/common/host.h index a6dff8de01..a0a661af57 100644 --- a/common/host.h +++ b/common/host.h @@ -35,30 +35,31 @@ extern report_keyboard_t *keyboard_report; extern report_keyboard_t *keyboard_report_prev; +/* host driver */ void host_set_driver(host_driver_t *driver); host_driver_t *host_get_driver(void); + uint8_t host_keyboard_leds(void); -/* new interface */ -void host_register_key(uint8_t key); -void host_unregister_key(uint8_t key); -void host_clear_all_keys_but_mods(void); /* keyboard report operations */ +/* key */ void host_add_key(uint8_t key); void host_del_key(uint8_t key); +void host_clear_keys(void); +/* modifier */ void host_add_mod_bit(uint8_t mod); void host_del_mod_bit(uint8_t mod); void host_set_mods(uint8_t mods); -void host_add_code(uint8_t code); -void host_del_code(uint8_t code); -void host_swap_keyboard_report(void); -void host_clear_keyboard_report(void); +void host_clear_mods(void); +/* query */ uint8_t host_has_anykey(void); uint8_t host_get_first_key(void); - - +/* send report */ void host_send_keyboard_report(void); + + +/* send report: mouse, system contorl and consumer page */ void host_mouse_send(report_mouse_t *report); void host_system_send(uint16_t data); void host_consumer_send(uint16_t data); diff --git a/common/keyboard.c b/common/keyboard.c index 6adad88824..37d3b06ba2 100644 --- a/common/keyboard.c +++ b/common/keyboard.c @@ -81,17 +81,37 @@ static inline keykind_t get_keykind(uint8_t code, bool pressed) return NONE; } +static void clear_keyboard(void) +{ + host_clear_keys(); + host_clear_mods(); + host_send_keyboard_report(); + + host_system_send(0); + host_consumer_send(0); + + mousekey_clear(); + mousekey_send(); +} + +static void clear_keyboard_but_mods(void) +{ + host_clear_keys(); + host_send_keyboard_report(); + + host_system_send(0); + host_consumer_send(0); + + mousekey_clear(); + mousekey_send(); +} + static void layer_switch_on(uint8_t code) { if (!IS_FN(code)) return; fn_state_bits |= FN_BIT(code); if (current_layer != keymap_fn_layer(FN_INDEX(code))) { - // clear all key execpt Mod key - host_clear_all_keys_but_mods(); - host_system_send(0); - host_consumer_send(0); - mousekey_clear(); - mousekey_send(); + clear_keyboard_but_mods(); debug("Layer Switch(on): "); debug_hex(current_layer); current_layer = keymap_fn_layer(FN_INDEX(code)); @@ -104,12 +124,7 @@ static void layer_switch_off(uint8_t code) if (!IS_FN(code)) return; fn_state_bits &= ~FN_BIT(code); if (current_layer != keymap_fn_layer(biton(fn_state_bits))) { - // clear all key execpt Mod key - host_clear_all_keys_but_mods(); - host_system_send(0); - host_consumer_send(0); - mousekey_clear(); - mousekey_send(); + clear_keyboard_but_mods(); debug("Layer Switch(off): "); debug_hex(current_layer); current_layer = keymap_fn_layer(biton(fn_state_bits)); @@ -117,11 +132,6 @@ static void layer_switch_off(uint8_t code) } } -static inline uint8_t get_keycode(key_t key) -{ - return keymap_get_keycode(current_layer, key.row, key.col); -} - // whether any key except modifier is down or not static inline bool is_anykey_down(void) { @@ -129,7 +139,7 @@ static inline bool is_anykey_down(void) matrix_row_t matrix_row = matrix_get_row(r); for (int c = 0; c < MATRIX_COLS; c++) { if (matrix_row && (1<. /* key combination for command */ -#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT))) +#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) /* mouse keys */ #ifdef MOUSEKEY_ENABLE diff --git a/protocol/vusb/vusb.c b/protocol/vusb/vusb.c index 4e11836e16..59834e6918 100644 --- a/protocol/vusb/vusb.c +++ b/protocol/vusb/vusb.c @@ -164,8 +164,8 @@ usbRequest_t *rq = (void *)data; if(rq->bRequest == USBRQ_HID_GET_REPORT){ debug("GET_REPORT:"); /* we only have one report type, so don't look at wValue */ - usbMsgPtr = (void *)keyboard_report_prev; - return sizeof(*keyboard_report_prev); + usbMsgPtr = (void *)keyboard_report; + return sizeof(*keyboard_report); }else if(rq->bRequest == USBRQ_HID_GET_IDLE){ debug("GET_IDLE: "); //debug_hex(vusb_idle_rate); From 5b00cf3f024a09d834d125374d93cacc269f84ba Mon Sep 17 00:00:00 2001 From: tmk Date: Wed, 10 Oct 2012 11:06:47 +0900 Subject: [PATCH 07/18] Fix build option MOUSEKEY_ENABLE. --- common/keyboard.c | 12 +++++++++++- common/mousekey.c | 36 +++++++++++++++++++++--------------- keyboard/hhkb/config.h | 2 +- keyboard/hhkb/config_vusb.h | 2 +- 4 files changed, 34 insertions(+), 18 deletions(-) diff --git a/common/keyboard.c b/common/keyboard.c index 37d3b06ba2..43abf4236f 100644 --- a/common/keyboard.c +++ b/common/keyboard.c @@ -90,8 +90,10 @@ static void clear_keyboard(void) host_system_send(0); host_consumer_send(0); +#ifdef MOUSEKEY_ENABLE mousekey_clear(); mousekey_send(); +#endif } static void clear_keyboard_but_mods(void) @@ -102,8 +104,10 @@ static void clear_keyboard_but_mods(void) host_system_send(0); host_consumer_send(0); +#ifdef MOUSEKEY_ENABLE mousekey_clear(); mousekey_send(); +#endif } static void layer_switch_on(uint8_t code) @@ -159,8 +163,10 @@ static void register_code(uint8_t code) host_send_keyboard_report(); } else if IS_MOUSEKEY(code) { +#ifdef MOUSEKEY_ENABLE mousekey_on(code); mousekey_send(); +#endif } else if IS_CONSUMER(code) { uint16_t usage = 0; @@ -251,8 +257,10 @@ static void unregister_code(uint8_t code) host_send_keyboard_report(); } else if IS_MOUSEKEY(code) { +#ifdef MOUSEKEY_ENABLE mousekey_off(code); mousekey_send(); +#endif } else if IS_CONSUMER(code) { host_consumer_send(0x0000); @@ -390,7 +398,7 @@ static inline void process_key(keyevent_t event) case KEY_UP: case MOD_UP: unregister_code(code); - // no key registered? mousekey, mediakey, systemkey + // TODO: no key registered? mousekey, mediakey, systemkey if (!host_has_anykey()) NEXT(IDLE); break; @@ -570,8 +578,10 @@ void keyboard_task(void) } } +#ifdef MOUSEKEY_ENABLE // mousekey repeat & acceleration mousekey_task(); +#endif // FAIL SAFE: clear all key if no key down if (matrix_change) { diff --git a/common/mousekey.c b/common/mousekey.c index 58a6e35bb0..6fe8e2d265 100644 --- a/common/mousekey.c +++ b/common/mousekey.c @@ -37,7 +37,7 @@ static void mousekey_debug(void); * see wikipedia http://en.wikipedia.org/wiki/Mouse_keys */ #ifndef MOUSEKEY_DELAY_TIME -# define MOUSEKEY_DELAY_TIME 20 +# define MOUSEKEY_DELAY_TIME 100 #endif #define MOUSEKEY_MOVE_INIT 5 @@ -54,10 +54,16 @@ static uint16_t last_timer = 0; static inline uint8_t move_unit(void) { - uint16_t unit = 5 + mousekey_repeat*4; + uint16_t unit = MOUSEKEY_MOVE_INIT + MOUSEKEY_MOVE_ACCEL * mousekey_repeat; return (unit > 63 ? 63 : unit); } +static inline uint8_t wheel_unit(void) +{ + uint16_t unit = MOUSEKEY_WHEEL_INIT + MOUSEKEY_WHEEL_ACCEL * mousekey_repeat; + return (unit > 15 ? 15 : unit); +} + void mousekey_task(void) { if (timer_elapsed(last_timer) < MOUSEKEY_DELAY_TIME) @@ -80,10 +86,10 @@ void mousekey_task(void) report.y *= 0.7; } - if (report.v > 0) report.v = move_unit(); - if (report.v < 0) report.v = move_unit() * -1; - if (report.h > 0) report.h = move_unit(); - if (report.h < 0) report.h = move_unit() * -1; + if (report.v > 0) report.v = wheel_unit(); + if (report.v < 0) report.v = wheel_unit() * -1; + if (report.h > 0) report.h = wheel_unit(); + if (report.h < 0) report.h = wheel_unit() * -1; mousekey_send(); } @@ -107,19 +113,19 @@ void mousekey_on(uint8_t code) void mousekey_off(uint8_t code) { - if (code == KC_MS_UP && report.y < 0) report.y = 0; - else if (code == KC_MS_DOWN && report.y > 0) report.y = 0; - else if (code == KC_MS_LEFT && report.x < 0) report.x = 0; - else if (code == KC_MS_RIGHT && report.x > 0) report.x = 0; + if (code == KC_MS_UP && report.y < 0) report.y = 0; + else if (code == KC_MS_DOWN && report.y > 0) report.y = 0; + else if (code == KC_MS_LEFT && report.x < 0) report.x = 0; + else if (code == KC_MS_RIGHT && report.x > 0) report.x = 0; else if (code == KC_MS_WH_UP && report.v > 0) report.v = 0; else if (code == KC_MS_WH_DOWN && report.v < 0) report.v = 0; else if (code == KC_MS_WH_LEFT && report.h < 0) report.h = 0; else if (code == KC_MS_WH_RIGHT && report.h > 0) report.h = 0; - else if (code == KC_MS_BTN1) report.buttons &= ~MOUSE_BTN1; - else if (code == KC_MS_BTN2) report.buttons &= ~MOUSE_BTN2; - else if (code == KC_MS_BTN3) report.buttons &= ~MOUSE_BTN3; - else if (code == KC_MS_BTN4) report.buttons &= ~MOUSE_BTN4; - else if (code == KC_MS_BTN5) report.buttons &= ~MOUSE_BTN5; + else if (code == KC_MS_BTN1) report.buttons &= ~MOUSE_BTN1; + else if (code == KC_MS_BTN2) report.buttons &= ~MOUSE_BTN2; + else if (code == KC_MS_BTN3) report.buttons &= ~MOUSE_BTN3; + else if (code == KC_MS_BTN4) report.buttons &= ~MOUSE_BTN4; + else if (code == KC_MS_BTN5) report.buttons &= ~MOUSE_BTN5; if (report.x == 0 && report.y == 0 && report.v == 0 && report.h == 0) mousekey_repeat = 0; diff --git a/keyboard/hhkb/config.h b/keyboard/hhkb/config.h index e10a7ab37f..cca75f2434 100644 --- a/keyboard/hhkb/config.h +++ b/keyboard/hhkb/config.h @@ -42,7 +42,7 @@ along with this program. If not, see . /* mouse keys */ #ifdef MOUSEKEY_ENABLE -# define MOUSEKEY_DELAY_TIME 192 +# define MOUSEKEY_DELAY_TIME 100 #endif diff --git a/keyboard/hhkb/config_vusb.h b/keyboard/hhkb/config_vusb.h index b85e16fa3f..44d5e4557d 100644 --- a/keyboard/hhkb/config_vusb.h +++ b/keyboard/hhkb/config_vusb.h @@ -37,7 +37,7 @@ along with this program. If not, see . /* mouse keys */ #ifdef MOUSEKEY_ENABLE -# define MOUSEKEY_DELAY_TIME 255 +# define MOUSEKEY_DELAY_TIME 100 #endif From 0a70be9a97215e2b514841f67e52b4c55a6adab1 Mon Sep 17 00:00:00 2001 From: tmk Date: Wed, 10 Oct 2012 15:31:00 +0900 Subject: [PATCH 08/18] Add subset of Xorg MouseKey acceleration parameters. --- common/mousekey.c | 104 +++++++++++++++++++++++++++++++++------------- 1 file changed, 75 insertions(+), 29 deletions(-) diff --git a/common/mousekey.c b/common/mousekey.c index 6fe8e2d265..4b1fe1740f 100644 --- a/common/mousekey.c +++ b/common/mousekey.c @@ -32,41 +32,87 @@ static uint8_t mousekey_repeat = 0; static void mousekey_debug(void); -/* - * TODO: fix acceleration algorithm - * see wikipedia http://en.wikipedia.org/wiki/Mouse_keys - */ -#ifndef MOUSEKEY_DELAY_TIME -# define MOUSEKEY_DELAY_TIME 100 +/* max value on report descriptor */ +#define MOUSEKEY_MOVE_MAX 127 +#define MOUSEKEY_WHEEL_MAX 15 + +#ifndef MOUSEKEY_MOVE_DELTA +#define MOUSEKEY_MOVE_DELTA 5 +#endif +#ifndef MOUSEKEY_WHEEL_DELTA +#define MOUSEKEY_WHEEL_DELTA 1 +#endif +#ifndef MOUSEKEY_DELAY +#define MOUSEKEY_DELAY 300 +#endif +#ifndef MOUSEKEY_INTERVAL +#define MOUSEKEY_INTERVAL 50 +#endif +#ifndef MOUSEKEY_MAX_SPEED +#define MOUSEKEY_MAX_SPEED 10 +#endif +#ifndef MOUSEKEY_TIME_TO_MAX +#define MOUSEKEY_TIME_TO_MAX 20 +#endif +#ifndef MOUSEKEY_WHEEL_MAX_SPEED +#define MOUSEKEY_WHEEL_MAX_SPEED 8 +#endif +#ifndef MOUSEKEY_WHEEL_TIME_TO_MAX +#define MOUSEKEY_WHEEL_TIME_TO_MAX 40 #endif -#define MOUSEKEY_MOVE_INIT 5 -#define MOUSEKEY_WHEEL_INIT 1 -#define MOUSEKEY_MOVE_ACCEL 5 -#define MOUSEKEY_WHEEL_ACCEL 1 + +/* + * Mouse keys acceleration algorithm + * http://en.wikipedia.org/wiki/Mouse_keys + * + * speed = delta * max_speed * (repeat / time_to_max)**((1000+curve)/1000) + */ +/* milliseconds between the initial key press and first repeated motion event (0-2550) */ +static uint8_t mk_delay = MOUSEKEY_DELAY/10; +/* milliseconds between repeated motion events (0-255) */ +static uint8_t mk_interval = MOUSEKEY_INTERVAL; +/* steady speed (in action_delta units) applied each event (0-255) */ +static uint8_t mk_max_speed = MOUSEKEY_MAX_SPEED; +/* number of events (count) accelerating to steady speed (0-255) */ +static uint8_t mk_time_to_max = MOUSEKEY_TIME_TO_MAX; +/* ramp used to reach maximum pointer speed (NOT SUPPORTED) */ +//static int8_t mk_curve = 0; + +static uint8_t mk_wheel_max_speed = MOUSEKEY_WHEEL_MAX_SPEED; +static uint8_t mk_wheel_time_to_max = MOUSEKEY_WHEEL_TIME_TO_MAX; + static uint16_t last_timer = 0; -// acceleration parameters -//uint8_t mousekey_move_unit = 2; -//uint8_t mousekey_resolution = 5; - -static inline uint8_t move_unit(void) +static uint8_t move_unit(void) { - uint16_t unit = MOUSEKEY_MOVE_INIT + MOUSEKEY_MOVE_ACCEL * mousekey_repeat; - return (unit > 63 ? 63 : unit); + uint16_t unit; + if (mousekey_repeat > mk_time_to_max) { + unit = MOUSEKEY_MOVE_DELTA * mk_max_speed; + } else { + unit = (MOUSEKEY_MOVE_DELTA * mk_max_speed * mousekey_repeat) / mk_time_to_max; + } + if (unit == 0) return 1; + return (unit > MOUSEKEY_MOVE_MAX ? MOUSEKEY_MOVE_MAX : unit); } -static inline uint8_t wheel_unit(void) +static uint8_t wheel_unit(void) { - uint16_t unit = MOUSEKEY_WHEEL_INIT + MOUSEKEY_WHEEL_ACCEL * mousekey_repeat; - return (unit > 15 ? 15 : unit); + uint16_t unit; + if (mousekey_repeat > mk_time_to_max) { + unit = MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed; + } else { + unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed * mousekey_repeat) / mk_time_to_max; + } + if (unit == 0) return 1; + return (unit > MOUSEKEY_WHEEL_MAX ? MOUSEKEY_WHEEL_MAX : unit); } void mousekey_task(void) { - if (timer_elapsed(last_timer) < MOUSEKEY_DELAY_TIME) + if (timer_elapsed(last_timer) < (mousekey_repeat ? mk_interval : mk_delay*10)) return; if (report.x == 0 && report.y == 0 && report.v == 0 && report.h == 0) @@ -96,14 +142,14 @@ void mousekey_task(void) void mousekey_on(uint8_t code) { - if (code == KC_MS_UP) report.y = MOUSEKEY_MOVE_INIT * -1; - else if (code == KC_MS_DOWN) report.y = MOUSEKEY_MOVE_INIT; - else if (code == KC_MS_LEFT) report.x = MOUSEKEY_MOVE_INIT * -1; - else if (code == KC_MS_RIGHT) report.x = MOUSEKEY_MOVE_INIT; - else if (code == KC_MS_WH_UP) report.v = MOUSEKEY_WHEEL_INIT; - else if (code == KC_MS_WH_DOWN) report.v = MOUSEKEY_WHEEL_INIT * -1; - else if (code == KC_MS_WH_LEFT) report.h = MOUSEKEY_WHEEL_INIT * -1; - else if (code == KC_MS_WH_RIGHT) report.h = MOUSEKEY_WHEEL_INIT; + if (code == KC_MS_UP) report.y = MOUSEKEY_MOVE_DELTA * -1; + else if (code == KC_MS_DOWN) report.y = MOUSEKEY_MOVE_DELTA; + else if (code == KC_MS_LEFT) report.x = MOUSEKEY_MOVE_DELTA * -1; + else if (code == KC_MS_RIGHT) report.x = MOUSEKEY_MOVE_DELTA; + else if (code == KC_MS_WH_UP) report.v = MOUSEKEY_WHEEL_DELTA; + else if (code == KC_MS_WH_DOWN) report.v = MOUSEKEY_WHEEL_DELTA * -1; + else if (code == KC_MS_WH_LEFT) report.h = MOUSEKEY_WHEEL_DELTA * -1; + else if (code == KC_MS_WH_RIGHT) report.h = MOUSEKEY_WHEEL_DELTA; else if (code == KC_MS_BTN1) report.buttons |= MOUSE_BTN1; else if (code == KC_MS_BTN2) report.buttons |= MOUSE_BTN2; else if (code == KC_MS_BTN3) report.buttons |= MOUSE_BTN3; From 1677b021d7bff6af7763532b038612363b61dada Mon Sep 17 00:00:00 2001 From: tmk Date: Fri, 12 Oct 2012 04:46:37 +0900 Subject: [PATCH 09/18] Fix layer switching and host API. --- common/host.c | 95 +++++++++++++++++++------------- common/host.h | 24 ++++---- common/keyboard.c | 136 ++++++++++++++++++++++++++-------------------- common/mousekey.c | 93 ++++++++++++++++--------------- 4 files changed, 193 insertions(+), 155 deletions(-) diff --git a/common/host.c b/common/host.c index a671c97d30..261ec6472f 100644 --- a/common/host.c +++ b/common/host.c @@ -27,10 +27,14 @@ along with this program. If not, see . bool keyboard_nkro = false; #endif -static host_driver_t *driver; report_keyboard_t *keyboard_report = &(report_keyboard_t){}; +report_mouse_t mouse_report = {}; +static host_driver_t *driver; +static uint16_t last_system_report = 0; +static uint16_t last_consumer_report = 0; + static inline void add_key_byte(uint8_t code); static inline void del_key_byte(uint8_t code); static inline void add_key_bit(uint8_t code); @@ -52,8 +56,48 @@ uint8_t host_keyboard_leds(void) if (!driver) return 0; return (*driver->keyboard_leds)(); } +/* send report */ +void host_keyboard_send(report_keyboard_t *report) +{ + if (!driver) return; + (*driver->send_keyboard)(report); -/* keyboard report operations */ + if (debug_keyboard) { + print("keys: "); + for (int i = 0; i < REPORT_KEYS; i++) { + phex(keyboard_report->keys[i]); print(" "); + } + print(" mods: "); phex(keyboard_report->mods); print("\n"); + } +} + +void host_mouse_send(report_mouse_t *report) +{ + if (!driver) return; + (*driver->send_mouse)(report); +} + +void host_system_send(uint16_t report) +{ + if (report == last_system_report) return; + last_system_report = report; + + if (!driver) return; + (*driver->send_system)(report); +} + +void host_consumer_send(uint16_t report) +{ + if (report == last_consumer_report) return; + last_consumer_report = report; + + if (!driver) return; + (*driver->send_consumer)(report); +} + + + +/* keyboard report utils */ void host_add_key(uint8_t key) { #ifdef NKRO_ENABLE @@ -113,6 +157,11 @@ uint8_t host_has_anykey(void) return cnt; } +uint8_t host_has_anymod(void) +{ + return bitpop(keyboard_report->mods); +} + uint8_t host_get_first_key(void) { #ifdef NKRO_ENABLE @@ -129,52 +178,24 @@ uint8_t host_get_first_key(void) void host_send_keyboard_report(void) { if (!driver) return; - (*driver->send_keyboard)(keyboard_report); - - if (debug_keyboard) { - print("keys: "); - for (int i = 0; i < REPORT_KEYS; i++) { - phex(keyboard_report->keys[i]); print(" "); - } - print(" mods: "); phex(keyboard_report->mods); print("\n"); - } + host_keyboard_send(keyboard_report); } - -/* send report */ -void host_keyboard_send(report_keyboard_t *report) +uint8_t host_mouse_in_use(void) { - if (!driver) return; - (*driver->send_keyboard)(report); + return (mouse_report.buttons | mouse_report.x | mouse_report.y | mouse_report.v | mouse_report.h); } -void host_mouse_send(report_mouse_t *report) +uint16_t host_last_sysytem_report(void) { - if (!driver) return; - (*driver->send_mouse)(report); + return last_system_report; } -void host_system_send(uint16_t data) +uint16_t host_last_consumer_report(void) { - static uint16_t last_data = 0; - if (data == last_data) return; - last_data = data; - - if (!driver) return; - (*driver->send_system)(data); + return last_consumer_report; } -void host_consumer_send(uint16_t data) -{ - static uint16_t last_data = 0; - if (data == last_data) return; - last_data = data; - - if (!driver) return; - (*driver->send_consumer)(data); -} - - static inline void add_key_byte(uint8_t code) { int8_t i = 0; diff --git a/common/host.h b/common/host.h index a0a661af57..207b683100 100644 --- a/common/host.h +++ b/common/host.h @@ -31,38 +31,40 @@ extern "C" { extern bool keyboard_nkro; #endif +/* report */ extern report_keyboard_t *keyboard_report; -extern report_keyboard_t *keyboard_report_prev; +extern report_mouse_t mouse_report; /* host driver */ void host_set_driver(host_driver_t *driver); host_driver_t *host_get_driver(void); +/* host driver interface */ uint8_t host_keyboard_leds(void); +void host_keyboard_send(report_keyboard_t *report); +void host_mouse_send(report_mouse_t *report); +void host_system_send(uint16_t data); +void host_consumer_send(uint16_t data); - -/* keyboard report operations */ -/* key */ +/* keyboard report utils */ void host_add_key(uint8_t key); void host_del_key(uint8_t key); void host_clear_keys(void); -/* modifier */ void host_add_mod_bit(uint8_t mod); void host_del_mod_bit(uint8_t mod); void host_set_mods(uint8_t mods); void host_clear_mods(void); -/* query */ uint8_t host_has_anykey(void); +uint8_t host_has_anymod(void); uint8_t host_get_first_key(void); -/* send report */ void host_send_keyboard_report(void); +/* mouse report utils */ +uint8_t host_mouse_in_use(void); -/* send report: mouse, system contorl and consumer page */ -void host_mouse_send(report_mouse_t *report); -void host_system_send(uint16_t data); -void host_consumer_send(uint16_t data); +uint16_t host_last_sysytem_report(void); +uint16_t host_last_consumer_report(void); #ifdef __cplusplus } diff --git a/common/keyboard.c b/common/keyboard.c index 43abf4236f..7a17a9e38b 100644 --- a/common/keyboard.c +++ b/common/keyboard.c @@ -110,6 +110,12 @@ static void clear_keyboard_but_mods(void) #endif } +static bool anykey_sent_to_host(void) +{ + return (host_has_anykey() || host_mouse_in_use() || + host_last_sysytem_report() || host_last_consumer_report()); +} + static void layer_switch_on(uint8_t code) { if (!IS_FN(code)) return; @@ -123,9 +129,9 @@ static void layer_switch_on(uint8_t code) } } -static void layer_switch_off(uint8_t code) +static bool layer_switch_off(uint8_t code) { - if (!IS_FN(code)) return; + if (!IS_FN(code)) return false; fn_state_bits &= ~FN_BIT(code); if (current_layer != keymap_fn_layer(biton(fn_state_bits))) { clear_keyboard_but_mods(); @@ -133,21 +139,7 @@ static void layer_switch_off(uint8_t code) debug("Layer Switch(off): "); debug_hex(current_layer); current_layer = keymap_fn_layer(biton(fn_state_bits)); debug(" -> "); debug_hex(current_layer); debug("\n"); - } -} - -// whether any key except modifier is down or not -static inline bool is_anykey_down(void) -{ - for (int r = 0; r < MATRIX_ROWS; r++) { - matrix_row_t matrix_row = matrix_get_row(r); - for (int c = 0; c < MATRIX_COLS; c++) { - if (matrix_row && (1<mods; host_set_mods(delayed_fn.mods); - register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code))); - unregister_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code))); + register_code(delayed_fn.code); + unregister_code(delayed_fn.code); host_set_mods(tmp_mods); NEXT(IDLE); } else { - layer_switch_off(code); - NEXT(IDLE); + if (layer_switch_off(code)) + NEXT(IDLE); } break; case KEY_UP: - unregister_code(code); - NEXT(IDLE); - break; case MOD_UP: unregister_code(code); break; @@ -459,34 +469,40 @@ static inline void process_key(keyevent_t event) case KEY_DOWN: tmp_mods = keyboard_report->mods; host_set_mods(delayed_fn.mods); - register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code))); + register_code(delayed_fn.code); host_set_mods(waiting_key.mods); register_code(waiting_key.code); host_set_mods(tmp_mods); - register_code(code); + if (kind == FN_DOWN) { + // ignore Fn + } else if (kind == FNK_DOWN) { + register_code(code); + } else if (kind == KEY_DOWN) { + register_code(code); + } NEXT(IDLE); break; case MOD_DOWN: register_code(code); break; case FN_UP: - layer_switch_off(code); - NEXT(IDLE); + if (layer_switch_off(code)) + NEXT(IDLE); break; case FNK_UP: if (code == delayed_fn.code) { // alt down, key down, alt up tmp_mods = keyboard_report->mods; host_set_mods(delayed_fn.mods); - register_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code))); + register_code(delayed_fn.code); host_set_mods(waiting_key.mods); register_code(waiting_key.code); - unregister_code(keymap_fn_keycode(FN_INDEX(delayed_fn.code))); + unregister_code(delayed_fn.code); host_set_mods(tmp_mods); NEXT(IDLE); } else { - layer_switch_off(code); - NEXT(IDLE); + if (layer_switch_off(code)) + NEXT(IDLE); } break; case KEY_UP: diff --git a/common/mousekey.c b/common/mousekey.c index 4b1fe1740f..353890a168 100644 --- a/common/mousekey.c +++ b/common/mousekey.c @@ -25,7 +25,6 @@ along with this program. If not, see . #include "mousekey.h" -static report_mouse_t report; static uint8_t mousekey_repeat = 0; @@ -115,89 +114,89 @@ void mousekey_task(void) if (timer_elapsed(last_timer) < (mousekey_repeat ? mk_interval : mk_delay*10)) return; - if (report.x == 0 && report.y == 0 && report.v == 0 && report.h == 0) + if (mouse_report.x == 0 && mouse_report.y == 0 && mouse_report.v == 0 && mouse_report.h == 0) return; if (mousekey_repeat != UINT8_MAX) mousekey_repeat++; - if (report.x > 0) report.x = move_unit(); - if (report.x < 0) report.x = move_unit() * -1; - if (report.y > 0) report.y = move_unit(); - if (report.y < 0) report.y = move_unit() * -1; + if (mouse_report.x > 0) mouse_report.x = move_unit(); + if (mouse_report.x < 0) mouse_report.x = move_unit() * -1; + if (mouse_report.y > 0) mouse_report.y = move_unit(); + if (mouse_report.y < 0) mouse_report.y = move_unit() * -1; - if (report.x && report.y) { - report.x *= 0.7; - report.y *= 0.7; + if (mouse_report.x && mouse_report.y) { + mouse_report.x *= 0.7; + mouse_report.y *= 0.7; } - if (report.v > 0) report.v = wheel_unit(); - if (report.v < 0) report.v = wheel_unit() * -1; - if (report.h > 0) report.h = wheel_unit(); - if (report.h < 0) report.h = wheel_unit() * -1; + if (mouse_report.v > 0) mouse_report.v = wheel_unit(); + if (mouse_report.v < 0) mouse_report.v = wheel_unit() * -1; + if (mouse_report.h > 0) mouse_report.h = wheel_unit(); + if (mouse_report.h < 0) mouse_report.h = wheel_unit() * -1; mousekey_send(); } void mousekey_on(uint8_t code) { - if (code == KC_MS_UP) report.y = MOUSEKEY_MOVE_DELTA * -1; - else if (code == KC_MS_DOWN) report.y = MOUSEKEY_MOVE_DELTA; - else if (code == KC_MS_LEFT) report.x = MOUSEKEY_MOVE_DELTA * -1; - else if (code == KC_MS_RIGHT) report.x = MOUSEKEY_MOVE_DELTA; - else if (code == KC_MS_WH_UP) report.v = MOUSEKEY_WHEEL_DELTA; - else if (code == KC_MS_WH_DOWN) report.v = MOUSEKEY_WHEEL_DELTA * -1; - else if (code == KC_MS_WH_LEFT) report.h = MOUSEKEY_WHEEL_DELTA * -1; - else if (code == KC_MS_WH_RIGHT) report.h = MOUSEKEY_WHEEL_DELTA; - else if (code == KC_MS_BTN1) report.buttons |= MOUSE_BTN1; - else if (code == KC_MS_BTN2) report.buttons |= MOUSE_BTN2; - else if (code == KC_MS_BTN3) report.buttons |= MOUSE_BTN3; - else if (code == KC_MS_BTN4) report.buttons |= MOUSE_BTN4; - else if (code == KC_MS_BTN5) report.buttons |= MOUSE_BTN5; + if (code == KC_MS_UP) mouse_report.y = MOUSEKEY_MOVE_DELTA * -1; + else if (code == KC_MS_DOWN) mouse_report.y = MOUSEKEY_MOVE_DELTA; + else if (code == KC_MS_LEFT) mouse_report.x = MOUSEKEY_MOVE_DELTA * -1; + else if (code == KC_MS_RIGHT) mouse_report.x = MOUSEKEY_MOVE_DELTA; + else if (code == KC_MS_WH_UP) mouse_report.v = MOUSEKEY_WHEEL_DELTA; + else if (code == KC_MS_WH_DOWN) mouse_report.v = MOUSEKEY_WHEEL_DELTA * -1; + else if (code == KC_MS_WH_LEFT) mouse_report.h = MOUSEKEY_WHEEL_DELTA * -1; + else if (code == KC_MS_WH_RIGHT) mouse_report.h = MOUSEKEY_WHEEL_DELTA; + else if (code == KC_MS_BTN1) mouse_report.buttons |= MOUSE_BTN1; + else if (code == KC_MS_BTN2) mouse_report.buttons |= MOUSE_BTN2; + else if (code == KC_MS_BTN3) mouse_report.buttons |= MOUSE_BTN3; + else if (code == KC_MS_BTN4) mouse_report.buttons |= MOUSE_BTN4; + else if (code == KC_MS_BTN5) mouse_report.buttons |= MOUSE_BTN5; } void mousekey_off(uint8_t code) { - if (code == KC_MS_UP && report.y < 0) report.y = 0; - else if (code == KC_MS_DOWN && report.y > 0) report.y = 0; - else if (code == KC_MS_LEFT && report.x < 0) report.x = 0; - else if (code == KC_MS_RIGHT && report.x > 0) report.x = 0; - else if (code == KC_MS_WH_UP && report.v > 0) report.v = 0; - else if (code == KC_MS_WH_DOWN && report.v < 0) report.v = 0; - else if (code == KC_MS_WH_LEFT && report.h < 0) report.h = 0; - else if (code == KC_MS_WH_RIGHT && report.h > 0) report.h = 0; - else if (code == KC_MS_BTN1) report.buttons &= ~MOUSE_BTN1; - else if (code == KC_MS_BTN2) report.buttons &= ~MOUSE_BTN2; - else if (code == KC_MS_BTN3) report.buttons &= ~MOUSE_BTN3; - else if (code == KC_MS_BTN4) report.buttons &= ~MOUSE_BTN4; - else if (code == KC_MS_BTN5) report.buttons &= ~MOUSE_BTN5; + if (code == KC_MS_UP && mouse_report.y < 0) mouse_report.y = 0; + else if (code == KC_MS_DOWN && mouse_report.y > 0) mouse_report.y = 0; + else if (code == KC_MS_LEFT && mouse_report.x < 0) mouse_report.x = 0; + else if (code == KC_MS_RIGHT && mouse_report.x > 0) mouse_report.x = 0; + else if (code == KC_MS_WH_UP && mouse_report.v > 0) mouse_report.v = 0; + else if (code == KC_MS_WH_DOWN && mouse_report.v < 0) mouse_report.v = 0; + else if (code == KC_MS_WH_LEFT && mouse_report.h < 0) mouse_report.h = 0; + else if (code == KC_MS_WH_RIGHT && mouse_report.h > 0) mouse_report.h = 0; + else if (code == KC_MS_BTN1) mouse_report.buttons &= ~MOUSE_BTN1; + else if (code == KC_MS_BTN2) mouse_report.buttons &= ~MOUSE_BTN2; + else if (code == KC_MS_BTN3) mouse_report.buttons &= ~MOUSE_BTN3; + else if (code == KC_MS_BTN4) mouse_report.buttons &= ~MOUSE_BTN4; + else if (code == KC_MS_BTN5) mouse_report.buttons &= ~MOUSE_BTN5; - if (report.x == 0 && report.y == 0 && report.v == 0 && report.h == 0) + if (mouse_report.x == 0 && mouse_report.y == 0 && mouse_report.v == 0 && mouse_report.h == 0) mousekey_repeat = 0; } void mousekey_send(void) { mousekey_debug(); - host_mouse_send(&report); + host_mouse_send(&mouse_report); last_timer = timer_read(); } void mousekey_clear(void) { - report = (report_mouse_t){}; + mouse_report = (report_mouse_t){}; } static void mousekey_debug(void) { if (!debug_mouse) return; print("mousekey [btn|x y v h]rep: ["); - phex(report.buttons); print("|"); - phex(report.x); print(" "); - phex(report.y); print(" "); - phex(report.v); print(" "); - phex(report.h); print("]"); + phex(mouse_report.buttons); print("|"); + phex(mouse_report.x); print(" "); + phex(mouse_report.y); print(" "); + phex(mouse_report.v); print(" "); + phex(mouse_report.h); print("]"); phex(mousekey_repeat); print("\n"); } From f7a445e537243f886d9cb022bede18859c9bfd12 Mon Sep 17 00:00:00 2001 From: tmk Date: Fri, 12 Oct 2012 11:00:52 +0900 Subject: [PATCH 10/18] Fix use of default_layer --- common/keyboard.c | 32 ++++++++++++++++++++------------ 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/common/keyboard.c b/common/keyboard.c index 7a17a9e38b..be01e5540c 100644 --- a/common/keyboard.c +++ b/common/keyboard.c @@ -46,8 +46,13 @@ typedef enum keykind { typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t; -uint8_t current_layer = 0; +#ifdef KEYMAP_DEFAULT_LAYER +uint8_t default_layer = KEYMAP_DEFAULT_LAYER; +uint8_t current_layer = KEYMAP_DEFAULT_LAYER; +#else uint8_t default_layer = 0; +uint8_t current_layer = 0; +#endif /* keyboard internal states */ static kbdstate_t kbdstate = IDLE; @@ -120,12 +125,13 @@ static void layer_switch_on(uint8_t code) { if (!IS_FN(code)) return; fn_state_bits |= FN_BIT(code); - if (current_layer != keymap_fn_layer(FN_INDEX(code))) { - clear_keyboard_but_mods(); - + uint8_t new_layer = (fn_state_bits ? keymap_fn_layer(biton(fn_state_bits)) : default_layer); + if (current_layer != new_layer) { debug("Layer Switch(on): "); debug_hex(current_layer); - current_layer = keymap_fn_layer(FN_INDEX(code)); - debug(" -> "); debug_hex(current_layer); debug("\n"); + debug(" -> "); debug_hex(new_layer); debug("\n"); + + clear_keyboard_but_mods(); + current_layer = new_layer; } } @@ -133,12 +139,13 @@ static bool layer_switch_off(uint8_t code) { if (!IS_FN(code)) return false; fn_state_bits &= ~FN_BIT(code); - if (current_layer != keymap_fn_layer(biton(fn_state_bits))) { - clear_keyboard_but_mods(); - + uint8_t new_layer = (fn_state_bits ? keymap_fn_layer(biton(fn_state_bits)) : default_layer); + if (current_layer != new_layer) { debug("Layer Switch(off): "); debug_hex(current_layer); - current_layer = keymap_fn_layer(biton(fn_state_bits)); - debug(" -> "); debug_hex(current_layer); debug("\n"); + debug(" -> "); debug_hex(new_layer); debug("\n"); + + clear_keyboard_but_mods(); + current_layer = new_layer; return true; } return false; @@ -606,8 +613,9 @@ void keyboard_task(void) is_matrix_on |= matrix_get_row(r); } if (!is_matrix_on) { - debug("FAIL SAFE: clear all keys.\n"); + debug("FAIL SAFE: clear all keys(default layer).\n"); clear_keyboard(); + current_layer = default_layer; } } From e451c059296a4c9af7a476577fee64afb9965bca Mon Sep 17 00:00:00 2001 From: tmk Date: Tue, 16 Oct 2012 11:20:49 +0900 Subject: [PATCH 11/18] Fix commands --- common/command.c | 77 +++++++++++++++++++++++++++++------------------ common/command.h | 4 +-- common/debug.h | 2 ++ common/keyboard.c | 28 +++++++---------- common/matrix.h | 2 +- common/mousekey.c | 2 +- 6 files changed, 64 insertions(+), 51 deletions(-) diff --git a/common/command.c b/common/command.c index 16c6cfb889..0ad06e65b8 100644 --- a/common/command.c +++ b/common/command.c @@ -24,9 +24,11 @@ along with this program. If not, see . #include "util.h" #include "timer.h" #include "keyboard.h" -#include "matrix.h" #include "bootloader.h" #include "command.h" +#ifdef MOUSEKEY_ENABLE +#include "mousekey.h" +#endif #ifdef HOST_PJRC # include "usb_keyboard.h" @@ -40,44 +42,45 @@ along with this program. If not, see . #endif -static uint8_t command_common(void); +static bool command_common(uint8_t code); static void help(void); static void switch_layer(uint8_t layer); +static void clear_keyboard(void); static bool last_print_enable; -uint8_t command_proc(void) + +bool command_proc(uint8_t code) { - uint8_t processed = 0; - last_print_enable = print_enable; - if (!IS_COMMAND()) - return 0; + return false; + last_print_enable = print_enable; print_enable = true; - if (command_extra() || command_common()) { - processed = 1; + if (command_extra(code) || command_common(code)) { _delay_ms(500); + return true; } print_enable = last_print_enable; - return processed; + return false; } /* This allows to define extra commands. return 0 when not processed. */ -uint8_t command_extra(void) __attribute__ ((weak)); -uint8_t command_extra(void) +bool command_extra(uint8_t code) __attribute__ ((weak)); +bool command_extra(uint8_t code) { - return 0; + return false; } -static uint8_t command_common(void) +static bool command_common(uint8_t code) { - switch (host_get_first_key()) { + switch (code) { case KC_H: help(); break; - case KC_B: + case KC_DEL: + clear_keyboard(); print("jump to bootloader... "); _delay_ms(1000); bootloader_jump(); // not return @@ -179,34 +182,34 @@ static uint8_t command_common(void) #endif break; #endif - case KC_BSPC: - matrix_init(); - print("clear matrix\n"); - break; case KC_0: + case KC_F10: switch_layer(0); break; case KC_1: + case KC_F1: switch_layer(1); break; case KC_2: + case KC_F2: switch_layer(2); break; case KC_3: + case KC_F3: switch_layer(3); break; case KC_4: + case KC_F4: switch_layer(4); break; default: - return 0; + return false; } - return 1; + return true; } static void help(void) { - print("b: jump to bootloader\n"); print("d: toggle debug enable\n"); print("x: toggle matrix debug\n"); print("k: toggle keyboard debug\n"); @@ -215,16 +218,16 @@ static void help(void) print("v: print version\n"); print("t: print timer count\n"); print("s: print status\n"); + print("ESC: power down/wake up\n"); + print("0/F10: switch to Layer0 \n"); + print("1/F1: switch to Layer1 \n"); + print("2/F2: switch to Layer2 \n"); + print("3/F3: switch to Layer3 \n"); + print("4/F4: switch to Layer4 \n"); #ifdef NKRO_ENABLE print("n: toggle NKRO\n"); #endif - print("Backspace: clear matrix\n"); - print("ESC: power down/wake up\n"); - print("0: switch to Layer0 \n"); - print("1: switch to Layer1 \n"); - print("2: switch to Layer2 \n"); - print("3: switch to Layer3 \n"); - print("4: switch to Layer4 \n"); + print("DEL: jump to bootloader\n"); } static void switch_layer(uint8_t layer) @@ -235,3 +238,17 @@ static void switch_layer(uint8_t layer) default_layer = layer; print("switch to Layer: "); phex(layer); print("\n"); } + +static void clear_keyboard(void) +{ + host_clear_keys(); + host_send_keyboard_report(); + + host_system_send(0); + host_consumer_send(0); + +#ifdef MOUSEKEY_ENABLE + mousekey_clear(); + mousekey_send(); +#endif +} diff --git a/common/command.h b/common/command.h index 4888f5ee0b..dafd4d0f38 100644 --- a/common/command.h +++ b/common/command.h @@ -18,8 +18,8 @@ along with this program. If not, see . #ifndef COMMAND_H #define COMMAND -uint8_t command_proc(void); +bool command_proc(uint8_t code); /* This allows to extend commands. Return 0 when command is not processed. */ -uint8_t command_extra(void); +bool command_extra(uint8_t code); #endif diff --git a/common/debug.h b/common/debug.h index 9cc8d882f3..1d56e21f77 100644 --- a/common/debug.h +++ b/common/debug.h @@ -23,6 +23,8 @@ along with this program. If not, see . #define debug(s) if(debug_enable) print_P(PSTR(s)) +#define debug_P(s) if(debug_enable) print_P(s) +#define debug_S(s) if(debug_enable) print_S(s) #define debug_hex(c) if(debug_enable) phex(c) #define debug_hex16(i) if(debug_enable) phex16(i) #define debug_bin(c) if(debug_enable) pbin(c) diff --git a/common/keyboard.c b/common/keyboard.c index be01e5540c..c7ea2b840c 100644 --- a/common/keyboard.c +++ b/common/keyboard.c @@ -28,9 +28,6 @@ along with this program. If not, see . #ifdef MOUSEKEY_ENABLE #include "mousekey.h" #endif -#ifdef EXTRAKEY_ENABLE -#include -#endif #define LAYER_DELAY 250 @@ -154,8 +151,12 @@ static bool layer_switch_off(uint8_t code) static void register_code(uint8_t code) { if IS_KEY(code) { - host_add_key(code); - host_send_keyboard_report(); + if (command_proc(code)) { + //clear_keyboard(); + } else { + host_add_key(code); + host_send_keyboard_report(); + } } else if IS_MOD(code) { host_add_mod_bit(MOD_BIT(code)); @@ -330,9 +331,9 @@ static void unregister_code(uint8_t code) * Ld: Switch back to default layer(*unregister* all keys but modifiers) */ #define NEXT(state) do { \ - debug("NEXT: "); print_P(state_str(kbdstate)); \ + debug("NEXT: "); debug_P(state_str(kbdstate)); \ kbdstate = state; \ - debug(" -> "); print_P(state_str(kbdstate)); debug("\n"); \ + debug(" -> "); debug_P(state_str(kbdstate)); debug("\n"); \ } while (0) static inline void process_key(keyevent_t event) @@ -342,7 +343,7 @@ static inline void process_key(keyevent_t event) uint8_t tmp_mods; - debug("state: "); print_P(state_str(kbdstate)); + debug("state: "); debug_P(state_str(kbdstate)); debug(" kind: "); debug_hex(kind); debug(" code: "); debug_hex(code); if (event.pressed) { debug("d"); } else { debug("u"); } @@ -554,18 +555,11 @@ void keyboard_task(void) matrix_row_t matrix_change = 0; matrix_scan(); - if (command_proc()) { - debug("COMMAND\n"); - // TODO: COMMAND state? - clear_keyboard(); - return; - } - for (int r = 0; r < MATRIX_ROWS; r++) { matrix_row = matrix_get_row(r); matrix_change = matrix_row ^ matrix_prev[r]; if (matrix_change) { - if (debug_matrix) matrix_print(); + matrix_debug(); for (int c = 0; c < MATRIX_COLS; c++) { if (matrix_change & (1< mk_time_to_max) { unit = MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed; } else { - unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed * mousekey_repeat) / mk_time_to_max; + unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed * mousekey_repeat) / mk_wheel_time_to_max; } if (unit == 0) return 1; return (unit > MOUSEKEY_WHEEL_MAX ? MOUSEKEY_WHEEL_MAX : unit); From 8f7ed2bc1902cdeeb78c49f4833816a33cd6d3a0 Mon Sep 17 00:00:00 2001 From: tmk Date: Wed, 17 Oct 2012 03:27:25 +0900 Subject: [PATCH 12/18] Add Mousekey parameters and accel keys. --- common/keycode.h | 13 +++-- common/mousekey.c | 106 +++++++++++++++++++---------------------- common/mousekey.h | 39 +++++++++++++++ keyboard/hhkb/keymap.c | 8 ++-- 4 files changed, 103 insertions(+), 63 deletions(-) diff --git a/common/keycode.h b/common/keycode.h index 4ed78a46a6..f9331cdbf3 100644 --- a/common/keycode.h +++ b/common/keycode.h @@ -29,10 +29,11 @@ along with this program. If not, see . #define IS_MOD(code) (KC_LCTRL <= (code) && (code) <= KC_RGUI) #define IS_FN(code) (KC_FN0 <= (code) && (code) <= KC_FN7) -#define IS_MOUSEKEY(code) (KC_MS_UP <= (code) && (code) <= KC_MS_WH_RIGHT) +#define IS_MOUSEKEY(code) (KC_MS_UP <= (code) && (code) <= KC_MS_ACCEL2) #define IS_MOUSEKEY_MOVE(code) (KC_MS_UP <= (code) && (code) <= KC_MS_RIGHT) #define IS_MOUSEKEY_BUTTON(code) (KC_MS_BTN1 <= (code) && (code) <= KC_MS_BTN5) #define IS_MOUSEKEY_WHEEL(code) (KC_MS_WH_UP <= (code) && (code) <= KC_MS_WH_RIGHT) +#define IS_MOUSEKEY_ACCEL(code) (KC_MS_ACCEL0 <= (code) && (code) <= KC_MS_ACCEL2) #define IS_SPECIAL(code) ((0xB0 <= (code) && (code) <= 0xDF) || (0xE8 <= (code) && (code) <= 0xFF)) #define IS_CONSUMER(code) (KC_MUTE <= (code) && (code) <= KC_WFAV) @@ -120,6 +121,9 @@ along with this program. If not, see . #define KC_WH_D KC_MS_WH_DOWN #define KC_WH_L KC_MS_WH_LEFT #define KC_WH_R KC_MS_WH_RIGHT +#define KC_ACL0 KC_MS_ACCEL0 +#define KC_ACL1 KC_MS_ACCEL1 +#define KC_ACL2 KC_MS_ACCEL2 /* Sytem Control */ #define KC_PWR KC_SYSTEM_POWER #define KC_SLEP KC_SYSTEM_SLEEP @@ -429,13 +433,16 @@ enum internal_special_keycodes { KC_MS_BTN2, KC_MS_BTN3, KC_MS_BTN4, - KC_MS_BTN5, + KC_MS_BTN5, /* 0xF8 */ /* Mousekey wheel */ KC_MS_WH_UP, KC_MS_WH_DOWN, KC_MS_WH_LEFT, KC_MS_WH_RIGHT, /* 0xFC */ - /* 0xFD-FF vacant for future use */ + /* Mousekey accel */ + KC_MS_ACCEL0, + KC_MS_ACCEL1, + KC_MS_ACCEL2 /* 0xFF */ }; #endif /* KEYCODE_H */ diff --git a/common/mousekey.c b/common/mousekey.c index 99e6d34ffe..b8af3e59c7 100644 --- a/common/mousekey.c +++ b/common/mousekey.c @@ -27,40 +27,11 @@ along with this program. If not, see . static uint8_t mousekey_repeat = 0; +static uint8_t mousekey_accel = 0; static void mousekey_debug(void); -/* max value on report descriptor */ -#define MOUSEKEY_MOVE_MAX 127 -#define MOUSEKEY_WHEEL_MAX 15 - -#ifndef MOUSEKEY_MOVE_DELTA -#define MOUSEKEY_MOVE_DELTA 5 -#endif -#ifndef MOUSEKEY_WHEEL_DELTA -#define MOUSEKEY_WHEEL_DELTA 1 -#endif -#ifndef MOUSEKEY_DELAY -#define MOUSEKEY_DELAY 300 -#endif -#ifndef MOUSEKEY_INTERVAL -#define MOUSEKEY_INTERVAL 50 -#endif -#ifndef MOUSEKEY_MAX_SPEED -#define MOUSEKEY_MAX_SPEED 10 -#endif -#ifndef MOUSEKEY_TIME_TO_MAX -#define MOUSEKEY_TIME_TO_MAX 20 -#endif -#ifndef MOUSEKEY_WHEEL_MAX_SPEED -#define MOUSEKEY_WHEEL_MAX_SPEED 8 -#endif -#ifndef MOUSEKEY_WHEEL_TIME_TO_MAX -#define MOUSEKEY_WHEEL_TIME_TO_MAX 40 -#endif - - /* * Mouse keys acceleration algorithm * http://en.wikipedia.org/wiki/Mouse_keys @@ -68,18 +39,18 @@ static void mousekey_debug(void); * speed = delta * max_speed * (repeat / time_to_max)**((1000+curve)/1000) */ /* milliseconds between the initial key press and first repeated motion event (0-2550) */ -static uint8_t mk_delay = MOUSEKEY_DELAY/10; +uint8_t mk_delay = MOUSEKEY_DELAY/10; /* milliseconds between repeated motion events (0-255) */ -static uint8_t mk_interval = MOUSEKEY_INTERVAL; +uint8_t mk_interval = MOUSEKEY_INTERVAL; /* steady speed (in action_delta units) applied each event (0-255) */ -static uint8_t mk_max_speed = MOUSEKEY_MAX_SPEED; +uint8_t mk_max_speed = MOUSEKEY_MAX_SPEED; /* number of events (count) accelerating to steady speed (0-255) */ -static uint8_t mk_time_to_max = MOUSEKEY_TIME_TO_MAX; +uint8_t mk_time_to_max = MOUSEKEY_TIME_TO_MAX; /* ramp used to reach maximum pointer speed (NOT SUPPORTED) */ -//static int8_t mk_curve = 0; - -static uint8_t mk_wheel_max_speed = MOUSEKEY_WHEEL_MAX_SPEED; -static uint8_t mk_wheel_time_to_max = MOUSEKEY_WHEEL_TIME_TO_MAX; +//int8_t mk_curve = 0; +/* wheel params */ +uint8_t mk_wheel_max_speed = MOUSEKEY_WHEEL_MAX_SPEED; +uint8_t mk_wheel_time_to_max = MOUSEKEY_WHEEL_TIME_TO_MAX; static uint16_t last_timer = 0; @@ -88,25 +59,39 @@ static uint16_t last_timer = 0; static uint8_t move_unit(void) { uint16_t unit; - if (mousekey_repeat > mk_time_to_max) { + if (mousekey_accel & (1<<0)) { + unit = (MOUSEKEY_MOVE_DELTA * mk_max_speed)/4; + } else if (mousekey_accel & (1<<1)) { + unit = (MOUSEKEY_MOVE_DELTA * mk_max_speed)/2; + } else if (mousekey_accel & (1<<2)) { + unit = (MOUSEKEY_MOVE_DELTA * mk_max_speed); + } else if (mousekey_repeat == 0) { + unit = MOUSEKEY_MOVE_DELTA; + } else if (mousekey_repeat >= mk_time_to_max) { unit = MOUSEKEY_MOVE_DELTA * mk_max_speed; } else { unit = (MOUSEKEY_MOVE_DELTA * mk_max_speed * mousekey_repeat) / mk_time_to_max; } - if (unit == 0) return 1; - return (unit > MOUSEKEY_MOVE_MAX ? MOUSEKEY_MOVE_MAX : unit); + return (unit > MOUSEKEY_MOVE_MAX ? MOUSEKEY_MOVE_MAX : (unit == 0 ? 1 : unit)); } static uint8_t wheel_unit(void) { uint16_t unit; - if (mousekey_repeat > mk_time_to_max) { + if (mousekey_accel & (1<<0)) { + unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed)/4; + } else if (mousekey_accel & (1<<1)) { + unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed)/2; + } else if (mousekey_accel & (1<<2)) { + unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed); + } else if (mousekey_repeat == 0) { + unit = MOUSEKEY_WHEEL_DELTA; + } else if (mousekey_repeat >= mk_time_to_max) { unit = MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed; } else { unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed * mousekey_repeat) / mk_wheel_time_to_max; } - if (unit == 0) return 1; - return (unit > MOUSEKEY_WHEEL_MAX ? MOUSEKEY_WHEEL_MAX : unit); + return (unit > MOUSEKEY_WHEEL_MAX ? MOUSEKEY_WHEEL_MAX : (unit == 0 ? 1 : unit)); } void mousekey_task(void) @@ -126,6 +111,7 @@ void mousekey_task(void) if (mouse_report.y > 0) mouse_report.y = move_unit(); if (mouse_report.y < 0) mouse_report.y = move_unit() * -1; + /* diagonal move [1/sqrt(2) = 0.7] */ if (mouse_report.x && mouse_report.y) { mouse_report.x *= 0.7; mouse_report.y *= 0.7; @@ -141,19 +127,22 @@ void mousekey_task(void) void mousekey_on(uint8_t code) { - if (code == KC_MS_UP) mouse_report.y = MOUSEKEY_MOVE_DELTA * -1; - else if (code == KC_MS_DOWN) mouse_report.y = MOUSEKEY_MOVE_DELTA; - else if (code == KC_MS_LEFT) mouse_report.x = MOUSEKEY_MOVE_DELTA * -1; - else if (code == KC_MS_RIGHT) mouse_report.x = MOUSEKEY_MOVE_DELTA; - else if (code == KC_MS_WH_UP) mouse_report.v = MOUSEKEY_WHEEL_DELTA; - else if (code == KC_MS_WH_DOWN) mouse_report.v = MOUSEKEY_WHEEL_DELTA * -1; - else if (code == KC_MS_WH_LEFT) mouse_report.h = MOUSEKEY_WHEEL_DELTA * -1; - else if (code == KC_MS_WH_RIGHT) mouse_report.h = MOUSEKEY_WHEEL_DELTA; + if (code == KC_MS_UP) mouse_report.y = move_unit() * -1; + else if (code == KC_MS_DOWN) mouse_report.y = move_unit(); + else if (code == KC_MS_LEFT) mouse_report.x = move_unit() * -1; + else if (code == KC_MS_RIGHT) mouse_report.x = move_unit(); + else if (code == KC_MS_WH_UP) mouse_report.v = wheel_unit(); + else if (code == KC_MS_WH_DOWN) mouse_report.v = wheel_unit() * -1; + else if (code == KC_MS_WH_LEFT) mouse_report.h = wheel_unit() * -1; + else if (code == KC_MS_WH_RIGHT) mouse_report.h = wheel_unit(); else if (code == KC_MS_BTN1) mouse_report.buttons |= MOUSE_BTN1; else if (code == KC_MS_BTN2) mouse_report.buttons |= MOUSE_BTN2; else if (code == KC_MS_BTN3) mouse_report.buttons |= MOUSE_BTN3; else if (code == KC_MS_BTN4) mouse_report.buttons |= MOUSE_BTN4; else if (code == KC_MS_BTN5) mouse_report.buttons |= MOUSE_BTN5; + else if (code == KC_MS_ACCEL0) mousekey_accel |= (1<<0); + else if (code == KC_MS_ACCEL1) mousekey_accel |= (1<<1); + else if (code == KC_MS_ACCEL2) mousekey_accel |= (1<<2); } void mousekey_off(uint8_t code) @@ -171,6 +160,9 @@ void mousekey_off(uint8_t code) else if (code == KC_MS_BTN3) mouse_report.buttons &= ~MOUSE_BTN3; else if (code == KC_MS_BTN4) mouse_report.buttons &= ~MOUSE_BTN4; else if (code == KC_MS_BTN5) mouse_report.buttons &= ~MOUSE_BTN5; + else if (code == KC_MS_ACCEL0) mousekey_accel &= ~(1<<0); + else if (code == KC_MS_ACCEL1) mousekey_accel &= ~(1<<1); + else if (code == KC_MS_ACCEL2) mousekey_accel &= ~(1<<2); if (mouse_report.x == 0 && mouse_report.y == 0 && mouse_report.v == 0 && mouse_report.h == 0) mousekey_repeat = 0; @@ -186,17 +178,19 @@ void mousekey_send(void) void mousekey_clear(void) { mouse_report = (report_mouse_t){}; + mousekey_repeat = 0; + mousekey_accel = 0; } static void mousekey_debug(void) { if (!debug_mouse) return; - print("mousekey [btn|x y v h]rep: ["); + print("mousekey [btn|x y v h](rep/acl): ["); phex(mouse_report.buttons); print("|"); phex(mouse_report.x); print(" "); phex(mouse_report.y); print(" "); phex(mouse_report.v); print(" "); - phex(mouse_report.h); print("]"); - phex(mousekey_repeat); - print("\n"); + phex(mouse_report.h); print("]("); + phex(mousekey_repeat); print("/"); + phex(mousekey_accel); print(")\n"); } diff --git a/common/mousekey.h b/common/mousekey.h index 3006c4634f..ac26a46c89 100644 --- a/common/mousekey.h +++ b/common/mousekey.h @@ -21,6 +21,45 @@ along with this program. If not, see . #include #include "host.h" + +/* max value on report descriptor */ +#define MOUSEKEY_MOVE_MAX 127 +#define MOUSEKEY_WHEEL_MAX 127 + +#ifndef MOUSEKEY_MOVE_DELTA +#define MOUSEKEY_MOVE_DELTA 5 +#endif +#ifndef MOUSEKEY_WHEEL_DELTA +#define MOUSEKEY_WHEEL_DELTA 1 +#endif +#ifndef MOUSEKEY_DELAY +#define MOUSEKEY_DELAY 300 +#endif +#ifndef MOUSEKEY_INTERVAL +#define MOUSEKEY_INTERVAL 50 +#endif +#ifndef MOUSEKEY_MAX_SPEED +#define MOUSEKEY_MAX_SPEED 10 +#endif +#ifndef MOUSEKEY_TIME_TO_MAX +#define MOUSEKEY_TIME_TO_MAX 20 +#endif +#ifndef MOUSEKEY_WHEEL_MAX_SPEED +#define MOUSEKEY_WHEEL_MAX_SPEED 16 +#endif +#ifndef MOUSEKEY_WHEEL_TIME_TO_MAX +#define MOUSEKEY_WHEEL_TIME_TO_MAX 40 +#endif + + +uint8_t mk_delay; +uint8_t mk_interval; +uint8_t mk_max_speed; +uint8_t mk_time_to_max; +uint8_t mk_wheel_max_speed; +uint8_t mk_wheel_time_to_max; + + void mousekey_task(void); void mousekey_on(uint8_t code); void mousekey_off(uint8_t code); diff --git a/keyboard/hhkb/keymap.c b/keyboard/hhkb/keymap.c index 3cfa5ff33b..659a540b13 100644 --- a/keyboard/hhkb/keymap.c +++ b/keyboard/hhkb/keymap.c @@ -59,7 +59,7 @@ static const uint8_t PROGMEM fn_layer[] = { 2, // Fn2 3, // Fn3 3, // Fn4 - 4, // Fn5 + 5, // Fn5 0, // Fn6 0 // Fn7 }; @@ -162,9 +162,9 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { LGUI,LALT, BTN1, RALT,FN4), #else KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ - TAB, WH_L,WH_U,MS_U,WH_D,WH_R,WH_L,WH_D,WH_U,WH_R,NO, NO, NO, BSPC, \ - LCTL,NO, MS_L,MS_D,MS_R,NO, MS_L,MS_D,MS_U,MS_R,FN3, NO, ENT, \ - LSFT,BTN4,BTN5,BTN1,BTN2,BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \ + TAB, NO, NO, NO, NO, NO, WH_L,WH_D,WH_U,WH_R,NO, NO, NO, BSPC, \ + LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,FN3, NO, ENT, \ + LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \ LGUI,LALT, BTN1, RALT,FN4), #endif From 30eb3e3520e9d4d7b9a9dbac0c5c0200485103c2 Mon Sep 17 00:00:00 2001 From: tmk Date: Wed, 17 Oct 2012 03:44:01 +0900 Subject: [PATCH 13/18] Add command console and mouseky parameters tweak. --- common/command.c | 427 ++++++++++++++++++++++++++++++++++++------- common/keyboard.c | 38 ++-- common/print.c | 8 + common/print.h | 1 + protocol/vusb/vusb.c | 10 +- 5 files changed, 400 insertions(+), 84 deletions(-) diff --git a/common/command.c b/common/command.c index 0ad06e65b8..bbc45f45a3 100644 --- a/common/command.c +++ b/common/command.c @@ -43,29 +43,42 @@ along with this program. If not, see . static bool command_common(uint8_t code); -static void help(void); +static void command_common_help(void); +static bool command_console(uint8_t code); +static void command_console_help(void); +static bool mousekey_console(uint8_t code); +static void mousekey_console_help(void); + +static uint8_t kc2int(uint8_t code); static void switch_layer(uint8_t layer); static void clear_keyboard(void); -static bool last_print_enable; + +typedef enum { ONESHOT, CONSOLE, MOUSEKEY } cmdstate_t; +static cmdstate_t state = ONESHOT; bool command_proc(uint8_t code) { - if (!IS_COMMAND()) - return false; - - last_print_enable = print_enable; - print_enable = true; - if (command_extra(code) || command_common(code)) { - _delay_ms(500); - return true; + switch (state) { + case ONESHOT: + if (!IS_COMMAND()) + return false; + return (command_extra(code) || command_common(code)); + case CONSOLE: + command_console(code); + break; + case MOUSEKEY: + mousekey_console(code); + break; + default: + state = ONESHOT; + return false; } - print_enable = last_print_enable; - return false; + return true; } -/* This allows to define extra commands. return 0 when not processed. */ +/* This allows to define extra commands. return false when not processed. */ bool command_extra(uint8_t code) __attribute__ ((weak)); bool command_extra(uint8_t code) { @@ -73,72 +86,122 @@ bool command_extra(uint8_t code) } +/*********************************************************** + * Command common + ***********************************************************/ +static void command_common_help(void) +{ + print_enable = true; + print("\n\n----- Command Help -----\n"); + print("c: enter console mode\n"); + print("d: toggle debug enable\n"); + print("x: toggle matrix debug\n"); + print("k: toggle keyboard debug\n"); + print("m: toggle mouse debug\n"); + print("p: toggle print enable\n"); + print("v: print device version & info\n"); + print("t: print timer count\n"); + print("s: print status\n"); +#ifdef NKRO_ENABLE + print("n: toggle NKRO\n"); +#endif + print("0/F10: switch to Layer0 \n"); + print("1/F1: switch to Layer1 \n"); + print("2/F2: switch to Layer2 \n"); + print("3/F3: switch to Layer3 \n"); + print("4/F4: switch to Layer4 \n"); + print("PScr: power down/remote wake-up\n"); + print("Paus: jump to bootloader\n"); +} + static bool command_common(uint8_t code) { switch (code) { case KC_H: - help(); + case KC_SLASH: /* ? */ + command_common_help(); break; - case KC_DEL: + case KC_C: + print_enable = true; + debug_matrix = false; + debug_keyboard = false; + debug_mouse = false; + debug_enable = false; + command_console_help(); + print("\nEnter Console Mode\n"); + print("C> "); + state = CONSOLE; + break; + case KC_PAUSE: clear_keyboard(); - print("jump to bootloader... "); + print("\n\nJump to bootloader... "); _delay_ms(1000); bootloader_jump(); // not return print("not supported.\n"); break; case KC_D: - debug_enable = !debug_enable; if (debug_enable) { - last_print_enable = true; - print("debug enabled.\n"); - debug_matrix = true; - debug_keyboard = true; - debug_mouse = true; - } else { - print("debug disabled.\n"); - last_print_enable = false; - debug_matrix = false; + print("\nDEBUG: disabled.\n"); + debug_matrix = false; debug_keyboard = false; - debug_mouse = false; + debug_mouse = false; + debug_enable = false; + } else { + print("\nDEBUG: enabled.\n"); + debug_matrix = true; + debug_keyboard = true; + debug_mouse = true; + debug_enable = true; } break; case KC_X: // debug matrix toggle debug_matrix = !debug_matrix; - if (debug_matrix) - print("debug matrix enabled.\n"); - else - print("debug matrix disabled.\n"); + if (debug_matrix) { + print("\nDEBUG: matrix enabled.\n"); + debug_enable = true; + } else { + print("\nDEBUG: matrix disabled.\n"); + } break; case KC_K: // debug keyboard toggle debug_keyboard = !debug_keyboard; - if (debug_keyboard) - print("debug keyboard enabled.\n"); - else - print("debug keyboard disabled.\n"); + if (debug_keyboard) { + print("\nDEBUG: keyboard enabled.\n"); + debug_enable = true; + } else { + print("\nDEBUG: keyboard disabled.\n"); + } break; case KC_M: // debug mouse toggle debug_mouse = !debug_mouse; - if (debug_mouse) - print("debug mouse enabled.\n"); - else - print("debug mouse disabled.\n"); + if (debug_mouse) { + print("\nDEBUG: mouse enabled.\n"); + debug_enable = true; + } else { + print("\nDEBUG: mouse disabled.\n"); + } break; case KC_V: // print version & information + print("\n\n----- Version -----\n"); print(STR(DESCRIPTION) "\n"); + print(STR(MANUFACTURER) "(" STR(VENDOR_ID) ")/"); + print(STR(PRODUCT) "(" STR(PRODUCT_ID) ") "); + print("VERSION: " STR(DEVICE_VER) "\n"); break; case KC_T: // print timer - print("timer: "); phex16(timer_count); print("\n"); + print("timer: "); phex16(timer_count>>16); phex16(timer_count); print("\n"); break; case KC_P: // print toggle - if (last_print_enable) { + if (print_enable) { print("print disabled.\n"); - last_print_enable = false; + print_enable = false; } else { - last_print_enable = true; + print_enable = true; print("print enabled.\n"); } break; case KC_S: + print("\n\n----- Status -----\n"); print("host_keyboard_leds:"); phex(host_keyboard_leds()); print("\n"); #ifdef HOST_PJRC print("UDCON: "); phex(UDCON); print("\n"); @@ -166,7 +229,8 @@ static bool command_common(uint8_t code) break; #endif #ifdef EXTRAKEY_ENABLE - case KC_ESC: + case KC_PSCREEN: + // TODO: Power key should take this feature? otherwise any key during suspend. #ifdef HOST_PJRC if (suspend && remote_wakeup) { usb_remote_wakeup(); @@ -203,31 +267,269 @@ static bool command_common(uint8_t code) switch_layer(4); break; default: + print("?"); return false; } return true; } -static void help(void) + +/*********************************************************** + * Command console + ***********************************************************/ +static void command_console_help(void) { - print("d: toggle debug enable\n"); - print("x: toggle matrix debug\n"); - print("k: toggle keyboard debug\n"); - print("m: toggle mouse debug\n"); - print("p: toggle print enable\n"); - print("v: print version\n"); - print("t: print timer count\n"); - print("s: print status\n"); - print("ESC: power down/wake up\n"); - print("0/F10: switch to Layer0 \n"); - print("1/F1: switch to Layer1 \n"); - print("2/F2: switch to Layer2 \n"); - print("3/F3: switch to Layer3 \n"); - print("4/F4: switch to Layer4 \n"); -#ifdef NKRO_ENABLE - print("n: toggle NKRO\n"); + print_enable = true; + print("\n\n----- Console Help -----\n"); + print("ESC/q: quit\n"); +#ifdef MOUSEKEY_ENABLE + print("m: mousekey\n"); #endif - print("DEL: jump to bootloader\n"); +} + +static bool command_console(uint8_t code) +{ + switch (code) { + case KC_H: + case KC_SLASH: /* ? */ + command_console_help(); + break; + case KC_Q: + case KC_ESC: + print("\nQuit Console Mode\n"); + state = ONESHOT; + return false; +#ifdef MOUSEKEY_ENABLE + case KC_M: + mousekey_console_help(); + print("\nEnter Mousekey Console\n"); + print("M0>"); + state = MOUSEKEY; + return true; +#endif + default: + print("?"); + return false; + } + print("C> "); + return true; +} + + +#ifdef MOUSEKEY_ENABLE +/*********************************************************** + * Mousekey console + ***********************************************************/ +static uint8_t mousekey_param = 0; + +static void mousekey_param_print(void) +{ + print("\n\n----- Mousekey Parameters -----\n"); + print("1: mk_delay(*10ms): "); pdec(mk_delay); print("\n"); + print("2: mk_interval(ms): "); pdec(mk_interval); print("\n"); + print("3: mk_max_speed: "); pdec(mk_max_speed); print("\n"); + print("4: mk_time_to_max: "); pdec(mk_time_to_max); print("\n"); + print("5: mk_wheel_max_speed: "); pdec(mk_wheel_max_speed); print("\n"); + print("6: mk_wheel_time_to_max: "); pdec(mk_wheel_time_to_max); print("\n"); +} + +static void mousekey_param_inc(uint8_t param, uint8_t inc) +{ + switch (param) { + case 1: + if (mk_delay + inc < UINT8_MAX) + mk_delay += inc; + else + mk_delay = UINT8_MAX; + print("mk_delay = "); pdec(mk_delay); print("\n"); + break; + case 2: + if (mk_interval + inc < UINT8_MAX) + mk_interval += inc; + else + mk_interval = UINT8_MAX; + print("mk_interval = "); pdec(mk_interval); print("\n"); + break; + case 3: + if (mk_max_speed + inc < UINT8_MAX) + mk_max_speed += inc; + else + mk_max_speed = UINT8_MAX; + print("mk_max_speed = "); pdec(mk_max_speed); print("\n"); + break; + case 4: + if (mk_time_to_max + inc < UINT8_MAX) + mk_time_to_max += inc; + else + mk_time_to_max = UINT8_MAX; + print("mk_time_to_max = "); pdec(mk_time_to_max); print("\n"); + break; + case 5: + if (mk_wheel_max_speed + inc < UINT8_MAX) + mk_wheel_max_speed += inc; + else + mk_wheel_max_speed = UINT8_MAX; + print("mk_wheel_max_speed = "); pdec(mk_wheel_max_speed); print("\n"); + break; + case 6: + if (mk_wheel_time_to_max + inc < UINT8_MAX) + mk_wheel_time_to_max += inc; + else + mk_wheel_time_to_max = UINT8_MAX; + print("mk_wheel_time_to_max = "); pdec(mk_wheel_time_to_max); print("\n"); + break; + } +} + +static void mousekey_param_dec(uint8_t param, uint8_t dec) +{ + switch (param) { + case 1: + if (mk_delay > dec) + mk_delay -= dec; + else + mk_delay = 0; + print("mk_delay = "); pdec(mk_delay); print("\n"); + break; + case 2: + if (mk_interval > dec) + mk_interval -= dec; + else + mk_interval = 0; + print("mk_interval = "); pdec(mk_interval); print("\n"); + break; + case 3: + if (mk_max_speed > dec) + mk_max_speed -= dec; + else + mk_max_speed = 0; + print("mk_max_speed = "); pdec(mk_max_speed); print("\n"); + break; + case 4: + if (mk_time_to_max > dec) + mk_time_to_max -= dec; + else + mk_time_to_max = 0; + print("mk_time_to_max = "); pdec(mk_time_to_max); print("\n"); + break; + case 5: + if (mk_wheel_max_speed > dec) + mk_wheel_max_speed -= dec; + else + mk_wheel_max_speed = 0; + print("mk_wheel_max_speed = "); pdec(mk_wheel_max_speed); print("\n"); + break; + case 6: + if (mk_wheel_time_to_max > dec) + mk_wheel_time_to_max -= dec; + else + mk_wheel_time_to_max = 0; + print("mk_wheel_time_to_max = "); pdec(mk_wheel_time_to_max); print("\n"); + break; + } +} + +static void mousekey_console_help(void) +{ + print("\n\n----- Mousekey Parameters Help -----\n"); + print("ESC/q: quit\n"); + print("1: select mk_delay(*10ms)\n"); + print("2: select mk_interval(ms)\n"); + print("3: select mk_max_speed\n"); + print("4: select mk_time_to_max\n"); + print("5: select mk_wheel_max_speed\n"); + print("6: select mk_wheel_time_to_max\n"); + print("p: print prameters\n"); + print("d: set default values\n"); + print("up: increase prameters(+1)\n"); + print("down: decrease prameters(-1)\n"); + print("pgup: increase prameters(+10)\n"); + print("pgdown: decrease prameters(-10)\n"); + print("\nspeed = delta * max_speed * (repeat / time_to_max)\n"); + print("where delta: cursor="); pdec(MOUSEKEY_MOVE_DELTA); + print(", wheel="); pdec(MOUSEKEY_WHEEL_DELTA); print("\n"); + print("See http://en.wikipedia.org/wiki/Mouse_keys\n"); +} + +static bool mousekey_console(uint8_t code) +{ + switch (code) { + case KC_H: + case KC_SLASH: /* ? */ + mousekey_console_help(); + break; + case KC_Q: + case KC_ESC: + mousekey_param = 0; + print("\nQuit Mousekey Console\n"); + print("C> "); + state = CONSOLE; + return false; + case KC_P: + mousekey_param_print(); + break; + case KC_1: + case KC_2: + case KC_3: + case KC_4: + case KC_5: + case KC_6: + case KC_7: + case KC_8: + case KC_9: + case KC_0: + mousekey_param = kc2int(code); + print("selected parameter: "); pdec(mousekey_param); print("\n"); + break; + case KC_UP: + mousekey_param_inc(mousekey_param, 1); + break; + case KC_DOWN: + mousekey_param_dec(mousekey_param, 1); + break; + case KC_PGUP: + mousekey_param_inc(mousekey_param, 10); + break; + case KC_PGDN: + mousekey_param_dec(mousekey_param, 10); + break; + case KC_D: + mk_delay = MOUSEKEY_DELAY/10; + mk_interval = MOUSEKEY_INTERVAL; + mk_max_speed = MOUSEKEY_MAX_SPEED; + mk_time_to_max = MOUSEKEY_TIME_TO_MAX; + mk_wheel_max_speed = MOUSEKEY_WHEEL_MAX_SPEED; + mk_wheel_time_to_max = MOUSEKEY_WHEEL_TIME_TO_MAX; + print("set default values.\n"); + break; + default: + print("?"); + return false; + } + print("M"); pdec(mousekey_param); print("> "); + return true; +} +#endif + + +/*********************************************************** + * Utilities + ***********************************************************/ +static uint8_t kc2int(uint8_t code) +{ + switch (code) { + case KC_1: return 1; + case KC_2: return 2; + case KC_3: return 3; + case KC_4: return 4; + case KC_5: return 5; + case KC_6: return 6; + case KC_7: return 7; + case KC_8: return 8; + case KC_9: return 9; + case KC_0: return 0; + } + return 0; } static void switch_layer(uint8_t layer) @@ -242,6 +544,7 @@ static void switch_layer(uint8_t layer) static void clear_keyboard(void) { host_clear_keys(); + host_clear_mods(); host_send_keyboard_report(); host_system_send(0); diff --git a/common/keyboard.c b/common/keyboard.c index c7ea2b840c..d7ced430e0 100644 --- a/common/keyboard.c +++ b/common/keyboard.c @@ -30,6 +30,10 @@ along with this program. If not, see . #endif +#define Kdebug(s) do { if (debug_keyboard) debug(s); } while(0) +#define Kdebug_P(s) do { if (debug_keyboard) debug_P(s); } while(0) +#define Kdebug_hex(s) do { if (debug_keyboard) debug_hex(s); } while(0) + #define LAYER_DELAY 250 typedef enum keykind { @@ -124,8 +128,8 @@ static void layer_switch_on(uint8_t code) fn_state_bits |= FN_BIT(code); uint8_t new_layer = (fn_state_bits ? keymap_fn_layer(biton(fn_state_bits)) : default_layer); if (current_layer != new_layer) { - debug("Layer Switch(on): "); debug_hex(current_layer); - debug(" -> "); debug_hex(new_layer); debug("\n"); + Kdebug("Layer Switch(on): "); Kdebug_hex(current_layer); + Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n"); clear_keyboard_but_mods(); current_layer = new_layer; @@ -138,8 +142,8 @@ static bool layer_switch_off(uint8_t code) fn_state_bits &= ~FN_BIT(code); uint8_t new_layer = (fn_state_bits ? keymap_fn_layer(biton(fn_state_bits)) : default_layer); if (current_layer != new_layer) { - debug("Layer Switch(off): "); debug_hex(current_layer); - debug(" -> "); debug_hex(new_layer); debug("\n"); + Kdebug("Layer Switch(off): "); Kdebug_hex(current_layer); + Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n"); clear_keyboard_but_mods(); current_layer = new_layer; @@ -151,9 +155,7 @@ static bool layer_switch_off(uint8_t code) static void register_code(uint8_t code) { if IS_KEY(code) { - if (command_proc(code)) { - //clear_keyboard(); - } else { + if (!command_proc(code)) { host_add_key(code); host_send_keyboard_report(); } @@ -163,8 +165,10 @@ static void register_code(uint8_t code) host_send_keyboard_report(); } else if IS_FN(code) { - host_add_key(keymap_fn_keycode(FN_INDEX(code))); - host_send_keyboard_report(); + if (!command_proc(keymap_fn_keycode(FN_INDEX(code)))) { + host_add_key(keymap_fn_keycode(FN_INDEX(code))); + host_send_keyboard_report(); + } } else if IS_MOUSEKEY(code) { #ifdef MOUSEKEY_ENABLE @@ -331,9 +335,9 @@ static void unregister_code(uint8_t code) * Ld: Switch back to default layer(*unregister* all keys but modifiers) */ #define NEXT(state) do { \ - debug("NEXT: "); debug_P(state_str(kbdstate)); \ + Kdebug("NEXT: "); Kdebug_P(state_str(kbdstate)); \ kbdstate = state; \ - debug(" -> "); debug_P(state_str(kbdstate)); debug("\n"); \ + Kdebug(" -> "); Kdebug_P(state_str(kbdstate)); Kdebug("\n"); \ } while (0) static inline void process_key(keyevent_t event) @@ -343,11 +347,11 @@ static inline void process_key(keyevent_t event) uint8_t tmp_mods; - debug("state: "); debug_P(state_str(kbdstate)); - debug(" kind: "); debug_hex(kind); - debug(" code: "); debug_hex(code); - if (event.pressed) { debug("d"); } else { debug("u"); } - debug("\n"); + Kdebug("state: "); Kdebug_P(state_str(kbdstate)); + Kdebug(" kind: "); Kdebug_hex(kind); + Kdebug(" code: "); Kdebug_hex(code); + if (event.pressed) { Kdebug("d"); } else { Kdebug("u"); } + Kdebug("\n"); switch (kbdstate) { case IDLE: @@ -607,7 +611,7 @@ void keyboard_task(void) is_matrix_on |= matrix_get_row(r); } if (!is_matrix_on) { - debug("FAIL SAFE: clear all keys(default layer).\n"); + Kdebug("FAIL SAFE: clear all keys(default layer).\n"); clear_keyboard(); current_layer = default_layer; } diff --git a/common/print.c b/common/print.c index 558181ea72..4e36d3935b 100644 --- a/common/print.c +++ b/common/print.c @@ -75,6 +75,14 @@ void phex16(unsigned int i) phex(i); } +void pdec(uint8_t i) +{ + if (!print_enable) return; + if (i/100) sendchar('0' + (i/100)); + if (i/100 || i%100/10) sendchar('0' + (i%100/10)); + sendchar('0' + (i%10)); +} + void pbin(unsigned char c) { diff --git a/common/print.h b/common/print.h index d55f5695dc..1c4567862f 100644 --- a/common/print.h +++ b/common/print.h @@ -45,6 +45,7 @@ void print_S(const char *s); void print_P(const char *s); void phex(unsigned char c); void phex16(unsigned int i); +void pdec(uint8_t i); void pbin(unsigned char c); void pbin_reverse(unsigned char c); #ifdef __cplusplus diff --git a/protocol/vusb/vusb.c b/protocol/vusb/vusb.c index 59834e6918..1d5f4a8528 100644 --- a/protocol/vusb/vusb.c +++ b/protocol/vusb/vusb.c @@ -42,12 +42,12 @@ void vusb_transfer_keyboard(void) if (usbInterruptIsReady()) { if (kbuf_head != kbuf_tail) { usbSetInterrupt((void *)&kbuf[kbuf_tail], sizeof(report_keyboard_t)); - if (!debug_keyboard) { - print("keys: "); - for (int i = 0; i < REPORT_KEYS; i++) { phex(kbuf[kbuf_tail].keys[i]); print(" "); } - print(" mods: "); phex((kbuf[kbuf_tail]).mods); print("\n"); - } kbuf_tail = (kbuf_tail + 1) % KBUF_SIZE; + if (debug_keyboard) { + print("V-USB: kbuf["); pdec(kbuf_tail); print("->"); pdec(kbuf_head); print("]("); + phex((kbuf_head < kbuf_tail) ? (KBUF_SIZE - kbuf_tail + kbuf_head) : (kbuf_head - kbuf_tail)); + print(")\n"); + } } } } From bc5ee91d14547124fd138c09b0c3623e4eefe757 Mon Sep 17 00:00:00 2001 From: tmk Date: Wed, 17 Oct 2012 14:23:31 +0900 Subject: [PATCH 14/18] HHKB scan matrix: fix wait time on power on --- keyboard/hhkb/matrix.c | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/keyboard/hhkb/matrix.c b/keyboard/hhkb/matrix.c index 3bd6e73b35..01473d1ec7 100644 --- a/keyboard/hhkb/matrix.c +++ b/keyboard/hhkb/matrix.c @@ -23,7 +23,7 @@ along with this program. If not, see . #include #include #include -#include "print.h" +#include "debug.h" #include "util.h" #include "timer.h" #include "matrix.h" @@ -107,7 +107,7 @@ static matrix_row_t _matrix1[MATRIX_ROWS]; #define KEY_POWER_ON() do { \ KEY_INIT(); \ PORTB &= ~(1<<5); \ - _delay_us(200); \ + _delay_ms(1); \ } while (0) #define KEY_POWER_OFF() do { \ DDRB &= ~0x3F; \ @@ -228,21 +228,24 @@ uint16_t matrix_get_row(uint8_t row) return matrix[row]; } -void matrix_print(void) +void matrix_debug(void) { + if (!debug_matrix) + return; + #if (MATRIX_COLS <= 8) - print("\nr/c 01234567\n"); + debug("\nr/c 01234567\n"); #else - print("\nr/c 0123456789ABCDEF\n"); + debug("\nr/c 0123456789ABCDEF\n"); #endif for (uint8_t row = 0; row < matrix_rows(); row++) { - phex(row); print(": "); + debug_hex(row); debug(": "); #if (MATRIX_COLS <= 8) - pbin_reverse(matrix_get_row(row)); + debug_bin_reverse(matrix_get_row(row)); #else - pbin_reverse16(matrix_get_row(row)); + debug_bin_reverse16(matrix_get_row(row)); #endif - print("\n"); + debug("\n"); } } From bbff8ae1c1e78f719aaec47b844c1511cfdcb774 Mon Sep 17 00:00:00 2001 From: tmk Date: Wed, 17 Oct 2012 14:24:42 +0900 Subject: [PATCH 15/18] Fix HHKB keymap --- keyboard/hhkb/keymap.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/keyboard/hhkb/keymap.c b/keyboard/hhkb/keymap.c index 659a540b13..5dc5582ec7 100644 --- a/keyboard/hhkb/keymap.c +++ b/keyboard/hhkb/keymap.c @@ -196,9 +196,9 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { LGUI,LALT, FN5, RALT,RGUI), #else KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ - TAB, WH_L,WH_U,MS_U,WH_D,WH_R,WH_L,WH_D,WH_U,WH_R,NO, NO, NO, BSPC, \ - LCTL,NO, MS_L,MS_D,MS_R,NO, MS_L,MS_D,MS_U,MS_R,FN3, NO, ENT, \ - LSFT,BTN4,BTN5,BTN1,BTN2,BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \ + TAB, NO, NO, NO, NO, NO, WH_L,WH_D,WH_U,WH_R,NO, NO, NO, BSPC, \ + LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,FN3, NO, ENT, \ + LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \ LGUI,LALT, FN5, RALT,RGUI), #endif }; From 8570c25379e168874fb4cdc7ee0590829a0f0d2c Mon Sep 17 00:00:00 2001 From: tmk Date: Wed, 17 Oct 2012 14:25:08 +0900 Subject: [PATCH 16/18] Fix HHKB iWRAP build --- keyboard/hhkb/Makefile.iwrap | 11 ++++++----- keyboard/hhkb/config_iwrap.h | 2 +- protocol/iwrap.mk | 10 ++++++---- 3 files changed, 13 insertions(+), 10 deletions(-) diff --git a/keyboard/hhkb/Makefile.iwrap b/keyboard/hhkb/Makefile.iwrap index ef7ad2eac2..f87df0d2bb 100644 --- a/keyboard/hhkb/Makefile.iwrap +++ b/keyboard/hhkb/Makefile.iwrap @@ -13,7 +13,7 @@ TOP_DIR = ../.. TARGET_DIR = . # keyboard dependent files -SRC = main.c \ +SRC = \ keymap.c \ matrix.c \ led.c @@ -28,9 +28,9 @@ OPT_DEFS = -DDEBUG_LEVEL=0 # MCU name, you MUST set this to match the board you are using # type "make clean" after changing this, so all files will be rebuilt -MCU = atmega168p +MCU = atmega328p # avrdude doesn't know atmega168p -AVRDUDE_MCU = atmega168 +AVRDUDE_MCU = $(MCU) # Processor frequency. @@ -84,10 +84,11 @@ PROGRAM_CMD = $(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE # Search Path VPATH = $(TARGET_DIR) +VPATH += $(TOP_DIR) -include $(TOP_DIR)/protocol/iwrap.mk +#include $(TOP_DIR)/protocol/iwrap.mk # To be swatchable btween Bluetooth and USB. Comment out if you don't need USB. include $(TOP_DIR)/protocol/vusb.mk -include $(TOP_DIR)/protocol.mk +#include $(TOP_DIR)/protocol.mk include $(TOP_DIR)/common.mk include $(TOP_DIR)/rules.mk diff --git a/keyboard/hhkb/config_iwrap.h b/keyboard/hhkb/config_iwrap.h index 80ab64398b..734d669774 100644 --- a/keyboard/hhkb/config_iwrap.h +++ b/keyboard/hhkb/config_iwrap.h @@ -33,7 +33,7 @@ along with this program. If not, see . /* key combination for command */ -#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT))) +#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) /* mouse keys */ #ifdef MOUSEKEY_ENABLE diff --git a/protocol/iwrap.mk b/protocol/iwrap.mk index d9906fd1b4..9c83075a4a 100644 --- a/protocol/iwrap.mk +++ b/protocol/iwrap.mk @@ -1,9 +1,11 @@ +IWRAP_DIR = protocol/iwrap + OPT_DEFS += -DHOST_IWRAP -SRC += iwrap.c \ - suart.S \ - sendchar_uart.c \ - uart.c +SRC += $(IWRAP_DIR)/iwrap.c \ + $(IWRAP_DIR)/suart.S \ + $(IWRAP_DIR)/sendchar_uart.c \ + $(IWRAP_DIR)/uart.c # Search Path From ce2e06c39465b76a1780e5d594eaea7697afafd6 Mon Sep 17 00:00:00 2001 From: tmk Date: Wed, 17 Oct 2012 21:43:44 +0900 Subject: [PATCH 17/18] Fix projects for new keycodes --- converter/adb_usb/README.md | 2 +- converter/adb_usb/config.h | 1 + converter/adb_usb/keymap.c | 50 +++++------ converter/m0110_usb/config.h | 2 +- converter/m0110_usb/keymap.c | 62 ++++++------- converter/news_usb/config_pjrc.h | 4 +- converter/news_usb/keymap.c | 50 +++++------ converter/ps2_usb/config.h | 4 +- converter/ps2_usb/keymap.c | 84 +++++++++--------- converter/ps2_usb/keymap_jis.c | 84 +++++++++--------- converter/terminal_usb/config_102_pjrc.h | 2 +- converter/terminal_usb/config_122_pjrc.h | 2 +- converter/terminal_usb/keymap_102.c | 52 +++++------ converter/terminal_usb/keymap_122.c | 52 +++++------ converter/usb_usb/config.h | 2 +- converter/usb_usb/keymap.c | 68 +++++++------- converter/usb_usb/matrix.c | 2 +- converter/x68k_usb/config_pjrc.h | 4 +- converter/x68k_usb/keymap.c | 50 +++++------ keyboard/IIgs_Standard/README | 2 +- keyboard/IIgs_Standard/config.h | 4 +- keyboard/IIgs_Standard/keymap.c | 46 +++++----- keyboard/hbkb/config.h | 4 +- keyboard/hbkb/keymap.c | 42 ++++----- keyboard/hhkb/matrix.c | 19 ++-- keyboard/macway/config.h | 4 +- keyboard/macway/keymap.c | 36 ++++---- protocol/iwrap/iwrap.c | 2 +- protocol/iwrap/main.c | 108 +++++++++++------------ protocol/pjrc/usb_keyboard.c | 2 +- 30 files changed, 422 insertions(+), 424 deletions(-) diff --git a/converter/adb_usb/README.md b/converter/adb_usb/README.md index a41d84ebb0..33fd55040d 100644 --- a/converter/adb_usb/README.md +++ b/converter/adb_usb/README.md @@ -33,7 +33,7 @@ Keymap ------ You can change a keymap by editing code of keymap.c like following. This is a keymap for AEK, however, also used for other keyboards. -How to define the keymap is probably obvious. You can find key symbols in usb_keycodes.h. +How to define the keymap is probably obvious. You can find key symbols in keycode.h. If you want to define some keymaps than just one, see hhkb/keymap.c and macway/keymap.c as examples. Keymap(layer) switching may needs a bit of effort at this time. diff --git a/converter/adb_usb/config.h b/converter/adb_usb/config.h index 875c48ce84..094252f742 100644 --- a/converter/adb_usb/config.h +++ b/converter/adb_usb/config.h @@ -54,6 +54,7 @@ along with this program. If not, see . /* key combination for command */ #include "adb.h" +#include "matrix.h" #define IS_COMMAND() ( \ matrix_is_on(MATRIX_ROW(ADB_POWER), MATRIX_COL(ADB_POWER)) \ ) diff --git a/converter/adb_usb/keymap.c b/converter/adb_usb/keymap.c index 583d73ab87..60e8c99f42 100644 --- a/converter/adb_usb/keymap.c +++ b/converter/adb_usb/keymap.c @@ -22,7 +22,7 @@ along with this program. If not, see . #include #include #include "usb_keyboard.h" -#include "usb_keycodes.h" +#include "keycode.h" #include "print.h" #include "debug.h" #include "util.h" @@ -42,22 +42,22 @@ along with this program. If not, see . K38,K06,K07,K08,K09,K0B,K2D,K2E,K2B,K2F,K2C, K7B, K3E, K53,K54,K55, \ K36,K3A,K37, K31, K3B,K3D,K3C, K52, K41,K4C \ ) { \ - { KB_##K00, KB_##K01, KB_##K02, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \ - { KB_##K08, KB_##K09, KB_NO, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \ - { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ - { KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \ - { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \ - { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \ - { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_NO, KB_##K35, KB_##K36, KB_##K37 }, \ - { KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_NO }, \ - { KB_NO, KB_##K41, KB_NO, KB_##K43, KB_NO, KB_##K45, KB_NO, KB_##K47 }, \ - { KB_NO, KB_NO, KB_NO, KB_##K4B, KB_##K4C, KB_NO, KB_##K4E, KB_NO }, \ - { KB_NO, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ - { KB_##K58, KB_##K59, KB_NO, KB_##K5B, KB_##K5C, KB_NO, KB_NO, KB_NO }, \ - { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_NO, KB_##K67 }, \ - { KB_NO, KB_##K69, KB_NO, KB_##K6B, KB_NO, KB_##K6D, KB_NO, KB_##K6F }, \ - { KB_NO, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ - { KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_NO, KB_NO, KB_NO, KB_##K7F } \ + { KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \ + { KC_##K08, KC_##K09, KC_NO, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \ + { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \ + { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \ + { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \ + { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \ + { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_NO, KC_##K35, KC_##K36, KC_##K37 }, \ + { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_NO }, \ + { KC_NO, KC_##K41, KC_NO, KC_##K43, KC_NO, KC_##K45, KC_NO, KC_##K47 }, \ + { KC_NO, KC_NO, KC_NO, KC_##K4B, KC_##K4C, KC_NO, KC_##K4E, KC_NO }, \ + { KC_NO, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \ + { KC_##K58, KC_##K59, KC_NO, KC_##K5B, KC_##K5C, KC_NO, KC_NO, KC_NO }, \ + { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_NO, KC_##K67 }, \ + { KC_NO, KC_##K69, KC_NO, KC_##K6B, KC_NO, KC_##K6D, KC_NO, KC_##K6F }, \ + { KC_NO, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \ + { KC_##K78, KC_##K79, KC_##K7A, KC_##K7B, KC_NO, KC_NO, KC_NO, KC_##K7F } \ } @@ -76,14 +76,14 @@ static const uint8_t PROGMEM fn_layer[] = { // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer. // See layer.c for details. static const uint8_t PROGMEM fn_keycode[] = { - KB_NO, // Fn0 - KB_NO, // Fn1 - KB_NO, // Fn2 - KB_NO, // Fn3 - KB_NO, // Fn4 - KB_NO, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_NO, // Fn0 + KC_NO, // Fn1 + KC_NO, // Fn2 + KC_NO, // Fn3 + KC_NO, // Fn4 + KC_NO, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 }; static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { diff --git a/converter/m0110_usb/config.h b/converter/m0110_usb/config.h index 4563d6da54..d2e904077f 100644 --- a/converter/m0110_usb/config.h +++ b/converter/m0110_usb/config.h @@ -38,7 +38,7 @@ along with this program. If not, see . /* key combination for command */ #define IS_COMMAND() ( \ - keyboard_report->mods == (MOD_BIT(KB_LALT) | MOD_BIT(KB_LGUI)) \ + keyboard_report->mods == (MOD_BIT(KC_LALT) | MOD_BIT(KC_LGUI)) \ ) diff --git a/converter/m0110_usb/keymap.c b/converter/m0110_usb/keymap.c index b5cdd300bf..5bcb6e6714 100644 --- a/converter/m0110_usb/keymap.c +++ b/converter/m0110_usb/keymap.c @@ -20,7 +20,7 @@ along with this program. If not, see . #include #include #include "usb_keyboard.h" -#include "usb_keycodes.h" +#include "keycode.h" #include "print.h" #include "debug.h" #include "util.h" @@ -36,20 +36,20 @@ along with this program. If not, see . K38,K06,K07,K08,K09,K0B,K2D,K2E,K2B,K2F,K2C, K4D, K53,K54,K55,K4C, \ K3A,K37, K31, K34,K2A,K46,K42,K48, K52, K41 \ ) { \ - { KB_##K00, KB_##K01, KB_##K02, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \ - { KB_##K08, KB_##K09, KB_NO, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \ - { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ - { KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \ - { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \ - { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \ - { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_NO, KB_NO, KB_##K37 }, \ - { KB_##K38, KB_##K39, KB_##K3A, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ - { KB_NO, KB_##K41, KB_##K42, KB_NO, KB_NO, KB_NO, KB_##K46, KB_##K47 }, \ - { KB_##K48, KB_NO, KB_NO, KB_NO, KB_##K4C, KB_##K4D, KB_##K4E, KB_NO }, \ - { KB_NO, KB_NO, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ - { KB_##K58, KB_##K59, KB_NO, KB_##K5B, KB_##K5C, KB_NO, KB_NO, KB_NO }, \ - { KB_NO, KB_NO, KB_##K62, KB_NO, KB_NO, KB_NO, KB_##K66, KB_NO }, \ - { KB_##K68, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K6D, KB_NO, KB_NO }, \ + { KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \ + { KC_##K08, KC_##K09, KC_NO, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \ + { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \ + { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \ + { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \ + { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \ + { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_NO, KC_NO, KC_##K37 }, \ + { KC_##K38, KC_##K39, KC_##K3A, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \ + { KC_NO, KC_##K41, KC_##K42, KC_NO, KC_NO, KC_NO, KC_##K46, KC_##K47 }, \ + { KC_##K48, KC_NO, KC_NO, KC_NO, KC_##K4C, KC_##K4D, KC_##K4E, KC_NO }, \ + { KC_NO, KC_NO, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \ + { KC_##K58, KC_##K59, KC_NO, KC_##K5B, KC_##K5C, KC_NO, KC_NO, KC_NO }, \ + { KC_NO, KC_NO, KC_##K62, KC_NO, KC_NO, KC_NO, KC_##K66, KC_NO }, \ + { KC_##K68, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K6D, KC_NO, KC_NO }, \ } @@ -80,23 +80,23 @@ static const uint8_t PROGMEM fn_layer[] = { // See layer.c for details. static const uint8_t PROGMEM fn_keycode[] = { #ifndef HASU - KB_NO, // Fn0 - KB_NO, // Fn1 - KB_NO, // Fn2 - KB_NO, // Fn3 - KB_NO, // Fn4 - KB_NO, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_NO, // Fn0 + KC_NO, // Fn1 + KC_NO, // Fn2 + KC_NO, // Fn3 + KC_NO, // Fn4 + KC_NO, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 #else - KB_ENTER, // Fn0 - KB_SCOLON, // Fn1 - KB_SLASH, // Fn2 - KB_UP, // Fn3 - KB_NO, // Fn4 - KB_NO, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_ENTER, // Fn0 + KC_SCOLON, // Fn1 + KC_SLASH, // Fn2 + KC_UP, // Fn3 + KC_NO, // Fn4 + KC_NO, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 #endif }; diff --git a/converter/news_usb/config_pjrc.h b/converter/news_usb/config_pjrc.h index e9cf7dedb6..5bb0216fe5 100644 --- a/converter/news_usb/config_pjrc.h +++ b/converter/news_usb/config_pjrc.h @@ -35,8 +35,8 @@ along with this program. If not, see . /* key combination for command */ #define IS_COMMAND() ( \ - keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) || \ - keyboard_report->mods == (MOD_BIT(KB_LCTRL) | MOD_BIT(KB_RSHIFT)) \ + keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) || \ + keyboard_report->mods == (MOD_BIT(KC_LCTRL) | MOD_BIT(KC_RSHIFT)) \ ) diff --git a/converter/news_usb/keymap.c b/converter/news_usb/keymap.c index 4bd556ba09..19654095c8 100644 --- a/converter/news_usb/keymap.c +++ b/converter/news_usb/keymap.c @@ -18,7 +18,7 @@ along with this program. If not, see . #include #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "util.h" #include "keymap.h" @@ -36,22 +36,22 @@ along with this program. If not, see . K36,K37,K38,K39,K3A,K3B,K3C,K3D,K3E,K3F,K40,K41, K42, K6D, K57,K59,K58, \ K43,K44,K45, K46, K47, K48,K49,K4A, K6E, K66,K5B,K5C,K5D \ ) { \ - { KB_NO, KB_##K01, KB_##K02, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \ - { KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \ - { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ - { KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \ - { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \ - { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \ - { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \ - { KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, \ - { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \ - { KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, \ - { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ - { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_NO, KB_NO }, \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_##K64, KB_##K65, KB_##K66, KB_NO }, \ - { KB_##K68, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_##K6D, KB_##K6E, KB_NO }, \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, }, \ - { KB_NO, KB_NO, KB_##K7A, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO } \ + { KC_NO, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \ + { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \ + { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \ + { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \ + { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \ + { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \ + { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \ + { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \ + { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \ + { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_##K4F }, \ + { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \ + { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_NO, KC_NO }, \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_##K64, KC_##K65, KC_##K66, KC_NO }, \ + { KC_##K68, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_##K6D, KC_##K6E, KC_NO }, \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, }, \ + { KC_NO, KC_NO, KC_##K7A, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO } \ } @@ -70,14 +70,14 @@ static const uint8_t PROGMEM fn_layer[] = { // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer. // See layer.c for details. static const uint8_t PROGMEM fn_keycode[] = { - KB_NO, // Fn0 - KB_NO, // Fn1 - KB_NO, // Fn2 - KB_NO, // Fn3 - KB_NO, // Fn4 - KB_NO, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_NO, // Fn0 + KC_NO, // Fn1 + KC_NO, // Fn2 + KC_NO, // Fn3 + KC_NO, // Fn4 + KC_NO, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 }; diff --git a/converter/ps2_usb/config.h b/converter/ps2_usb/config.h index e5d37e429a..1c53b876d2 100644 --- a/converter/ps2_usb/config.h +++ b/converter/ps2_usb/config.h @@ -36,8 +36,8 @@ along with this program. If not, see . /* key combination for command */ #define IS_COMMAND() ( \ - keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) || \ - keyboard_report->mods == (MOD_BIT(KB_LCTRL) | MOD_BIT(KB_RSHIFT)) \ + keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) || \ + keyboard_report->mods == (MOD_BIT(KC_LCTRL) | MOD_BIT(KC_RSHIFT)) \ ) diff --git a/converter/ps2_usb/keymap.c b/converter/ps2_usb/keymap.c index f1e34a929a..df3a36b7fb 100644 --- a/converter/ps2_usb/keymap.c +++ b/converter/ps2_usb/keymap.c @@ -21,7 +21,7 @@ along with this program. If not, see . #include #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "print.h" #include "debug.h" #include "util.h" @@ -51,38 +51,38 @@ along with this program. If not, see . K90, KBA, KB8, KB0, /* WWW Search, Home, Back, Forward */ \ KA8, KA0, K98 /* WWW Stop, Refresh, Favorites */ \ ) { \ - { KB_NO, KB_##K01, KB_NO, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \ - { KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_NO }, \ - { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_NO }, \ - { KB_##K18, KB_NO, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_NO }, \ - { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \ - { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_NO }, \ - { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_NO }, \ - { KB_##K38, KB_NO, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_NO }, \ - { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \ - { KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_NO }, \ - { KB_##K50, KB_##K51, KB_##K52, KB_NO, KB_##K54, KB_##K55, KB_NO, KB_##K57 }, \ - { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_NO, KB_##K5D, KB_NO, KB_##K5F }, \ - { KB_NO, KB_##K61, KB_NO, KB_NO, KB_##K64, KB_NO, KB_##K66, KB_##K67 }, \ - { KB_NO, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_NO, KB_NO, KB_NO }, \ - { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ - { KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \ - { KB_NO, KB_NO, KB_NO, KB_##K83, KB_NO, KB_NO, KB_NO, KB_NO }, \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ - { KB_##K90, KB_##K91, KB_NO, KB_NO, KB_##K94, KB_##K95, KB_NO, KB_NO }, \ - { KB_##K98, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K9F }, \ - { KB_##KA0, KB_##KA1, KB_NO, KB_##KA3, KB_NO, KB_NO, KB_NO, KB_##KA7 }, \ - { KB_##KA8, KB_NO, KB_NO, KB_##KAB, KB_NO, KB_NO, KB_NO, KB_##KAF }, \ - { KB_##KB0, KB_NO, KB_##KB2, KB_NO, KB_##KB4, KB_NO, KB_NO, KB_##KB7 }, \ - { KB_##KB8, KB_NO, KB_##KBA, KB_##KBB, KB_NO, KB_NO, KB_NO, KB_##KBF }, \ - { KB_##KC0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ - { KB_##KC8, KB_NO, KB_##KCA, KB_NO, KB_NO, KB_##KCD, KB_NO, KB_NO }, \ - { KB_##KD0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ - { KB_NO, KB_NO, KB_##KDA, KB_NO, KB_NO, KB_NO, KB_##KDE, KB_NO }, \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ - { KB_NO, KB_##KE9, KB_NO, KB_##KEB, KB_##KEC, KB_NO, KB_NO, KB_NO }, \ - { KB_##KF0, KB_##KF1, KB_##KF2, KB_NO, KB_##KF4, KB_##KF5, KB_NO, KB_NO }, \ - { KB_NO, KB_NO, KB_##KFA, KB_NO, KB_##KFC, KB_##KFD, KB_##KFE, KB_NO }, \ + { KC_NO, KC_##K01, KC_NO, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \ + { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_NO }, \ + { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_NO }, \ + { KC_##K18, KC_NO, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_NO }, \ + { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \ + { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_NO }, \ + { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_NO }, \ + { KC_##K38, KC_NO, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_NO }, \ + { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \ + { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_NO }, \ + { KC_##K50, KC_##K51, KC_##K52, KC_NO, KC_##K54, KC_##K55, KC_NO, KC_##K57 }, \ + { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_NO, KC_##K5D, KC_NO, KC_##K5F }, \ + { KC_NO, KC_##K61, KC_NO, KC_NO, KC_##K64, KC_NO, KC_##K66, KC_##K67 }, \ + { KC_NO, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_NO, KC_NO, KC_NO }, \ + { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \ + { KC_##K78, KC_##K79, KC_##K7A, KC_##K7B, KC_##K7C, KC_##K7D, KC_##K7E, KC_NO }, \ + { KC_NO, KC_NO, KC_NO, KC_##K83, KC_NO, KC_NO, KC_NO, KC_NO }, \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \ + { KC_##K90, KC_##K91, KC_NO, KC_NO, KC_##K94, KC_##K95, KC_NO, KC_NO }, \ + { KC_##K98, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K9F }, \ + { KC_##KA0, KC_##KA1, KC_NO, KC_##KA3, KC_NO, KC_NO, KC_NO, KC_##KA7 }, \ + { KC_##KA8, KC_NO, KC_NO, KC_##KAB, KC_NO, KC_NO, KC_NO, KC_##KAF }, \ + { KC_##KB0, KC_NO, KC_##KB2, KC_NO, KC_##KB4, KC_NO, KC_NO, KC_##KB7 }, \ + { KC_##KB8, KC_NO, KC_##KBA, KC_##KBB, KC_NO, KC_NO, KC_NO, KC_##KBF }, \ + { KC_##KC0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \ + { KC_##KC8, KC_NO, KC_##KCA, KC_NO, KC_NO, KC_##KCD, KC_NO, KC_NO }, \ + { KC_##KD0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \ + { KC_NO, KC_NO, KC_##KDA, KC_NO, KC_NO, KC_NO, KC_##KDE, KC_NO }, \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \ + { KC_NO, KC_##KE9, KC_NO, KC_##KEB, KC_##KEC, KC_NO, KC_NO, KC_NO }, \ + { KC_##KF0, KC_##KF1, KC_##KF2, KC_NO, KC_##KF4, KC_##KF5, KC_NO, KC_NO }, \ + { KC_NO, KC_NO, KC_##KFA, KC_NO, KC_##KFC, KC_##KFD, KC_##KFE, KC_NO }, \ } /* US layout */ @@ -185,19 +185,19 @@ static const uint8_t PROGMEM fn_layer[] = { // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer. // See layer.c for details. static const uint8_t PROGMEM fn_keycode[] = { - KB_SCLN, // Fn0 - KB_SLSH, // Fn1 - KB_NO, // Fn2 - KB_NO, // Fn3 - KB_NO, // Fn4 - KB_NO, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_SCLN, // Fn0 + KC_SLSH, // Fn1 + KC_NO, // Fn2 + KC_NO, // Fn3 + KC_NO, // Fn4 + KC_NO, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 }; // The keymap is a 32*8 byte array which convert a PS/2 scan code into a USB keycode. -// See usb_keycodes.h for USB keycodes. You should omit a 'KB_' prefix of USB keycodes in keymap macro. +// See keycode.h for USB keycodes. You should omit a 'KC_' prefix of USB keycodes in keymap macro. // Use KEYMAP_ISO() or KEYMAP_JIS() instead of KEYMAP() if your keyboard is ISO or JIS. static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { /* 0: default diff --git a/converter/ps2_usb/keymap_jis.c b/converter/ps2_usb/keymap_jis.c index 787c9558af..fcf8a2abb4 100644 --- a/converter/ps2_usb/keymap_jis.c +++ b/converter/ps2_usb/keymap_jis.c @@ -21,7 +21,7 @@ along with this program. If not, see . #include #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "print.h" #include "debug.h" #include "util.h" @@ -51,38 +51,38 @@ along with this program. If not, see . K90, KBA, KB8, KB0, /* WWW Search, Home, Back, Forward */ \ KA8, KA0, K98 /* WWW Stop, Refresh, Favorites */ \ ) { \ - { KB_NO, KB_##K01, KB_NO, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \ - { KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_NO }, \ - { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_NO }, \ - { KB_##K18, KB_NO, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_NO }, \ - { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \ - { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_NO }, \ - { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_NO }, \ - { KB_##K38, KB_NO, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_NO }, \ - { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \ - { KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_NO }, \ - { KB_##K50, KB_##K51, KB_##K52, KB_NO, KB_##K54, KB_##K55, KB_NO, KB_##K57 }, \ - { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_NO, KB_##K5D, KB_NO, KB_##K5F }, \ - { KB_NO, KB_##K61, KB_NO, KB_NO, KB_##K64, KB_NO, KB_##K66, KB_##K67 }, \ - { KB_NO, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_NO, KB_NO, KB_NO }, \ - { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ - { KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \ - { KB_NO, KB_NO, KB_NO, KB_##K83, KB_NO, KB_NO, KB_NO, KB_NO }, \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ - { KB_##K90, KB_##K91, KB_NO, KB_NO, KB_##K94, KB_##K95, KB_NO, KB_NO }, \ - { KB_##K98, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K9F }, \ - { KB_##KA0, KB_##KA1, KB_NO, KB_##KA3, KB_NO, KB_NO, KB_NO, KB_##KA7 }, \ - { KB_##KA8, KB_NO, KB_NO, KB_##KAB, KB_NO, KB_NO, KB_NO, KB_##KAF }, \ - { KB_##KB0, KB_NO, KB_##KB2, KB_NO, KB_##KB4, KB_NO, KB_NO, KB_##KB7 }, \ - { KB_##KB8, KB_NO, KB_##KBA, KB_##KBB, KB_NO, KB_NO, KB_NO, KB_##KBF }, \ - { KB_##KC0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ - { KB_##KC8, KB_NO, KB_##KCA, KB_NO, KB_NO, KB_##KCD, KB_NO, KB_NO }, \ - { KB_##KD0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ - { KB_NO, KB_NO, KB_##KDA, KB_NO, KB_NO, KB_NO, KB_##KDE, KB_NO }, \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ - { KB_NO, KB_##KE9, KB_NO, KB_##KEB, KB_##KEC, KB_NO, KB_NO, KB_NO }, \ - { KB_##KF0, KB_##KF1, KB_##KF2, KB_NO, KB_##KF4, KB_##KF5, KB_NO, KB_NO }, \ - { KB_NO, KB_NO, KB_##KFA, KB_NO, KB_##KFC, KB_##KFD, KB_##KFE, KB_NO }, \ + { KC_NO, KC_##K01, KC_NO, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \ + { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_NO }, \ + { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_NO }, \ + { KC_##K18, KC_NO, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_NO }, \ + { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \ + { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_NO }, \ + { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_NO }, \ + { KC_##K38, KC_NO, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_NO }, \ + { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \ + { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_NO }, \ + { KC_##K50, KC_##K51, KC_##K52, KC_NO, KC_##K54, KC_##K55, KC_NO, KC_##K57 }, \ + { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_NO, KC_##K5D, KC_NO, KC_##K5F }, \ + { KC_NO, KC_##K61, KC_NO, KC_NO, KC_##K64, KC_NO, KC_##K66, KC_##K67 }, \ + { KC_NO, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_NO, KC_NO, KC_NO }, \ + { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \ + { KC_##K78, KC_##K79, KC_##K7A, KC_##K7B, KC_##K7C, KC_##K7D, KC_##K7E, KC_NO }, \ + { KC_NO, KC_NO, KC_NO, KC_##K83, KC_NO, KC_NO, KC_NO, KC_NO }, \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \ + { KC_##K90, KC_##K91, KC_NO, KC_NO, KC_##K94, KC_##K95, KC_NO, KC_NO }, \ + { KC_##K98, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K9F }, \ + { KC_##KA0, KC_##KA1, KC_NO, KC_##KA3, KC_NO, KC_NO, KC_NO, KC_##KA7 }, \ + { KC_##KA8, KC_NO, KC_NO, KC_##KAB, KC_NO, KC_NO, KC_NO, KC_##KAF }, \ + { KC_##KB0, KC_NO, KC_##KB2, KC_NO, KC_##KB4, KC_NO, KC_NO, KC_##KB7 }, \ + { KC_##KB8, KC_NO, KC_##KBA, KC_##KBB, KC_NO, KC_NO, KC_NO, KC_##KBF }, \ + { KC_##KC0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \ + { KC_##KC8, KC_NO, KC_##KCA, KC_NO, KC_NO, KC_##KCD, KC_NO, KC_NO }, \ + { KC_##KD0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \ + { KC_NO, KC_NO, KC_##KDA, KC_NO, KC_NO, KC_NO, KC_##KDE, KC_NO }, \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \ + { KC_NO, KC_##KE9, KC_NO, KC_##KEB, KC_##KEC, KC_NO, KC_NO, KC_NO }, \ + { KC_##KF0, KC_##KF1, KC_##KF2, KC_NO, KC_##KF4, KC_##KF5, KC_NO, KC_NO }, \ + { KC_NO, KC_NO, KC_##KFA, KC_NO, KC_##KFC, KC_##KFD, KC_##KFE, KC_NO }, \ } /* JIS layout */ @@ -155,19 +155,19 @@ static const uint8_t PROGMEM fn_layer[] = { // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer. // See layer.c for details. static const uint8_t PROGMEM fn_keycode[] = { - KB_SCLN, // Fn0 - KB_SLSH, // Fn1 - KB_BSPC, // Fn2 - KB_NO, // Fn3 - KB_NO, // Fn4 - KB_SPC, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_SCLN, // Fn0 + KC_SLSH, // Fn1 + KC_BSPC, // Fn2 + KC_NO, // Fn3 + KC_NO, // Fn4 + KC_SPC, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 }; // The keymap is a 32*8 byte array which convert a PS/2 scan code into a USB keycode. -// See usb_keycodes.h for USB keycodes. You should omit a 'KB_' prefix of USB keycodes in keymap macro. +// See keycode.h for USB keycodes. You should omit a 'KC_' prefix of USB keycodes in keymap macro. // Use KEYMAP_ISO() or KEYMAP_JIS() instead of KEYMAP() if your keyboard is ISO or JIS. static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { /* 0: JIS LAYOUT diff --git a/converter/terminal_usb/config_102_pjrc.h b/converter/terminal_usb/config_102_pjrc.h index 2dce04af7d..3ddbee3e76 100644 --- a/converter/terminal_usb/config_102_pjrc.h +++ b/converter/terminal_usb/config_102_pjrc.h @@ -35,7 +35,7 @@ along with this program. If not, see . /* key combination for command */ #define IS_COMMAND() ( \ - keyboard_report->mods == (MOD_BIT(KB_RALT) | MOD_BIT(KB_RCTL)) \ + keyboard_report->mods == (MOD_BIT(KC_RALT) | MOD_BIT(KC_RCTL)) \ ) diff --git a/converter/terminal_usb/config_122_pjrc.h b/converter/terminal_usb/config_122_pjrc.h index 43691bd71c..8a7c86822e 100644 --- a/converter/terminal_usb/config_122_pjrc.h +++ b/converter/terminal_usb/config_122_pjrc.h @@ -35,7 +35,7 @@ along with this program. If not, see . /* key combination for command */ #define IS_COMMAND() ( \ - keyboard_report->mods == (MOD_BIT(KB_RALT) | MOD_BIT(KB_RCTL)) \ + keyboard_report->mods == (MOD_BIT(KC_RALT) | MOD_BIT(KC_RCTL)) \ ) diff --git a/converter/terminal_usb/keymap_102.c b/converter/terminal_usb/keymap_102.c index 430570c47b..49e1b17c43 100644 --- a/converter/terminal_usb/keymap_102.c +++ b/converter/terminal_usb/keymap_102.c @@ -18,7 +18,7 @@ along with this program. If not, see . #include #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "print.h" #include "debug.h" #include "util.h" @@ -50,23 +50,23 @@ along with this program. If not, see . K12,K13,K1A,K22,K21,K2A,K32,K31,K3A,K41,K49,K4A, K51,K59, K63, K69,K72,K7A,K79, \ K11, K19, K29, K39, K58, K61,K60,K6A, K68,K70,K71,K78 \ ) { \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K07 }, \ - { KB_##K08, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K0D, KB_##K0E, KB_##K0F }, \ - { KB_NO, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ - { KB_NO, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \ - { KB_NO, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \ - { KB_NO, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \ - { KB_NO, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \ - { KB_NO, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, \ - { KB_NO, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \ - { KB_NO, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, \ - { KB_NO, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ - { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_##K5E, KB_##K5F }, \ - { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_##K66, KB_##K67 }, \ - { KB_##K68, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_##K6D, KB_##K6E, KB_##K6F }, \ - { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ - { KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_##K84, KB_NO, KB_NO, KB_NO, }, \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K07 }, \ + { KC_##K08, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K0D, KC_##K0E, KC_##K0F }, \ + { KC_NO, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \ + { KC_NO, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \ + { KC_NO, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \ + { KC_NO, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \ + { KC_NO, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \ + { KC_NO, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \ + { KC_NO, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \ + { KC_NO, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_##K4F }, \ + { KC_NO, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \ + { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_##K5E, KC_##K5F }, \ + { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \ + { KC_##K68, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_##K6D, KC_##K6E, KC_##K6F }, \ + { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \ + { KC_##K78, KC_##K79, KC_##K7A, KC_##K7B, KC_##K7C, KC_##K7D, KC_##K7E, KC_NO }, \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_##K84, KC_NO, KC_NO, KC_NO, }, \ } @@ -85,14 +85,14 @@ static const uint8_t PROGMEM fn_layer[] = { // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer. // See layer.c for details. static const uint8_t PROGMEM fn_keycode[] = { - KB_SCLN, // Fn0 - KB_SLSH, // Fn1 - KB_ESC, // Fn2 - KB_NO, // Fn3 - KB_NO, // Fn4 - KB_NO, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_SCLN, // Fn0 + KC_SLSH, // Fn1 + KC_ESC, // Fn2 + KC_NO, // Fn3 + KC_NO, // Fn4 + KC_NO, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 }; diff --git a/converter/terminal_usb/keymap_122.c b/converter/terminal_usb/keymap_122.c index 7a2168122f..1b705d1d53 100644 --- a/converter/terminal_usb/keymap_122.c +++ b/converter/terminal_usb/keymap_122.c @@ -18,7 +18,7 @@ along with this program. If not, see . #include #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "print.h" #include "debug.h" #include "util.h" @@ -51,23 +51,23 @@ along with this program. If not, see . K83,K0A, K12,K13,K1A,K22,K21,K2A,K32,K31,K3A,K41,K49,K4A, K51,K59, K61,K62,K6A, K69,K72,K7A,K79, \ K01,K09, K11, K19, K29, K39, K58, K60, K68,K70,K71,K78 \ ) { \ - { KB_NO, KB_##K01, KB_NO, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \ - { KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \ - { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ - { KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \ - { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \ - { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \ - { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \ - { KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, \ - { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \ - { KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, \ - { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ - { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_##K5E, KB_##K5F }, \ - { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_##K66, KB_##K67 }, \ - { KB_##K68, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_##K6D, KB_##K6E, KB_##K6F }, \ - { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ - { KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \ - { KB_NO, KB_NO, KB_NO, KB_##K83, KB_##K84, KB_NO, KB_NO, KB_NO, }, \ + { KC_NO, KC_##K01, KC_NO, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \ + { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \ + { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \ + { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \ + { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \ + { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \ + { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \ + { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \ + { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \ + { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_##K4F }, \ + { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \ + { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_##K5E, KC_##K5F }, \ + { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \ + { KC_##K68, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_##K6D, KC_##K6E, KC_##K6F }, \ + { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \ + { KC_##K78, KC_##K79, KC_##K7A, KC_##K7B, KC_##K7C, KC_##K7D, KC_##K7E, KC_NO }, \ + { KC_NO, KC_NO, KC_NO, KC_##K83, KC_##K84, KC_NO, KC_NO, KC_NO, }, \ } @@ -86,14 +86,14 @@ static const uint8_t PROGMEM fn_layer[] = { // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer. // See layer.c for details. static const uint8_t PROGMEM fn_keycode[] = { - KB_NO, // Fn0 - KB_NO, // Fn1 - KB_NO, // Fn2 - KB_NO, // Fn3 - KB_NO, // Fn4 - KB_NO, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_NO, // Fn0 + KC_NO, // Fn1 + KC_NO, // Fn2 + KC_NO, // Fn3 + KC_NO, // Fn4 + KC_NO, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 }; diff --git a/converter/usb_usb/config.h b/converter/usb_usb/config.h index c2230fb570..ecf4ed9b19 100644 --- a/converter/usb_usb/config.h +++ b/converter/usb_usb/config.h @@ -35,6 +35,6 @@ along with this program. If not, see . /* key combination for command */ -#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT))) +#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT))) #endif diff --git a/converter/usb_usb/keymap.c b/converter/usb_usb/keymap.c index 187f6846e0..4ab8c8abcd 100644 --- a/converter/usb_usb/keymap.c +++ b/converter/usb_usb/keymap.c @@ -16,7 +16,7 @@ along with this program. If not, see . */ #include -#include "usb_keycodes.h" +#include "keycode.h" #include "util.h" #include "keymap.h" @@ -29,38 +29,38 @@ along with this program. If not, see . KE1,K1D,K1B,K06,K19,K05,K11,K10,K36,K37,K38, KE5, K52, K59,K5A,K5B, \ KE0,KE3,KE2, K2C, KE6,KE7,K65,KE4, K50,K51,K4F, K62, K63,K58 \ ) { \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, /* 00-07 */ \ - { KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, /* 08-0F */ \ - { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, /* 10-17 */ \ - { KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, /* 18-1F */ \ - { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, /* 20-27 */ \ - { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, /* 28-2F */ \ - { KB_##K30, KB_##K31, KB_NO, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, /* 30-37 */ \ - { KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, /* 38-3F */ \ - { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, /* 40-47 */ \ - { KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, /* 48-4F */ \ - { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, /* 50-57 */ \ - { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_##K5E, KB_##K5F }, /* 58-5F */ \ - { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_NO, KB_##K65, KB_NO, KB_NO }, /* 60-67 */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 68-6F */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 70-77 */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 78-7F */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 80-87 */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 88-8F */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 90-97 */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 98-9F */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* A0-A7 */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* A8-AF */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* B0-B7 */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* B8-BF */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* C0-C7 */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* C8-CF */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* D0-D7 */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* D8-DF */ \ - { KB_##KE0, KB_##KE1, KB_##KE2, KB_##KE3, KB_##KE4, KB_##KE5, KB_##KE6, KB_##KE7 }, /* E0-E7 */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* E8-EF */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* F0-F7 */ \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* F8-FF */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, /* 00-07 */ \ + { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, /* 08-0F */ \ + { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, /* 10-17 */ \ + { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, /* 18-1F */ \ + { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, /* 20-27 */ \ + { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, /* 28-2F */ \ + { KC_##K30, KC_##K31, KC_NO, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, /* 30-37 */ \ + { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, /* 38-3F */ \ + { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, /* 40-47 */ \ + { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_##K4F }, /* 48-4F */ \ + { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, /* 50-57 */ \ + { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_##K5E, KC_##K5F }, /* 58-5F */ \ + { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_NO, KC_##K65, KC_NO, KC_NO }, /* 60-67 */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 68-6F */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 70-77 */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 78-7F */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 80-87 */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 88-8F */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 90-97 */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 98-9F */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* A0-A7 */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* A8-AF */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* B0-B7 */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* B8-BF */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* C0-C7 */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* C8-CF */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* D0-D7 */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* D8-DF */ \ + { KC_##KE0, KC_##KE1, KC_##KE2, KC_##KE3, KC_##KE4, KC_##KE5, KC_##KE6, KC_##KE7 }, /* E0-E7 */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* E8-EF */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* F0-F7 */ \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* F8-FF */ \ } @@ -68,7 +68,7 @@ along with this program. If not, see . static const uint8_t PROGMEM fn_layer[] = { 5, 6, 5, 0, 0, 0, 0, 0 }; // Codes to register by clicking Fn key(0-7) -static const uint8_t PROGMEM fn_keycode[] = { KB_SCLN, KB_SLSH, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }; +static const uint8_t PROGMEM fn_keycode[] = { KC_SCLN, KC_SLSH, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }; static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { /* 0: default diff --git a/converter/usb_usb/matrix.c b/converter/usb_usb/matrix.c index 1cfecde203..3cdb0860d5 100644 --- a/converter/usb_usb/matrix.c +++ b/converter/usb_usb/matrix.c @@ -18,7 +18,7 @@ along with this program. If not, see . #include #include #include "usb_hid.h" -#include "usb_keycodes.h" +#include "keycode.h" #include "util.h" #include "print.h" #include "debug.h" diff --git a/converter/x68k_usb/config_pjrc.h b/converter/x68k_usb/config_pjrc.h index 20758bf249..77e2188a03 100644 --- a/converter/x68k_usb/config_pjrc.h +++ b/converter/x68k_usb/config_pjrc.h @@ -35,8 +35,8 @@ along with this program. If not, see . /* key combination for command */ #define IS_COMMAND() ( \ - keyboard_report->mods == (MOD_BIT(KB_LALT) | MOD_BIT(KB_RALT)) || \ - keyboard_report->mods == (MOD_BIT(KB_LCTRL) | MOD_BIT(KB_RSHIFT)) \ + keyboard_report->mods == (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT)) || \ + keyboard_report->mods == (MOD_BIT(KC_LCTRL) | MOD_BIT(KC_RSHIFT)) \ ) diff --git a/converter/x68k_usb/keymap.c b/converter/x68k_usb/keymap.c index 94c2aeee11..5cd14cb6d1 100644 --- a/converter/x68k_usb/keymap.c +++ b/converter/x68k_usb/keymap.c @@ -18,7 +18,7 @@ along with this program. If not, see . #include #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "util.h" #include "keymap.h" @@ -51,22 +51,22 @@ along with this program. If not, see . K70,K2A,K2B,K2C,K2D,K2E,K2F,K30,K31,K32,K33,K34, K3B,K3E,K3D, K4B,K4C,K4D,K4E, \ K5F,K55,K56, K35, K57,K58,K59,K60, K72, K73, K4F,K50,K51 \ ) { \ - { KB_NO, KB_##K01, KB_##K02, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \ - { KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \ - { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ - { KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \ - { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \ - { KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \ - { KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \ - { KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, \ - { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \ - { KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, \ - { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ - { KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_##K5E, KB_##K5F }, \ - { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_##K66, KB_##K67 }, \ - { KB_##K68, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_NO, KB_NO, KB_NO }, \ - { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_NO, KB_NO, KB_NO, KB_NO, }, \ - { KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO } \ + { KC_NO, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \ + { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \ + { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \ + { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \ + { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \ + { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \ + { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \ + { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \ + { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \ + { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_##K4F }, \ + { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \ + { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_##K5E, KC_##K5F }, \ + { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \ + { KC_##K68, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_NO, KC_NO, KC_NO }, \ + { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_NO, KC_NO, KC_NO, KC_NO, }, \ + { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO } \ } @@ -85,14 +85,14 @@ static const uint8_t PROGMEM fn_layer[] = { // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer. // See layer.c for details. static const uint8_t PROGMEM fn_keycode[] = { - KB_NO, // Fn0 - KB_NO, // Fn1 - KB_NO, // Fn2 - KB_NO, // Fn3 - KB_NO, // Fn4 - KB_NO, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_NO, // Fn0 + KC_NO, // Fn1 + KC_NO, // Fn2 + KC_NO, // Fn3 + KC_NO, // Fn4 + KC_NO, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 }; diff --git a/keyboard/IIgs_Standard/README b/keyboard/IIgs_Standard/README index 48d9470f62..4f9cad1ca1 100644 --- a/keyboard/IIgs_Standard/README +++ b/keyboard/IIgs_Standard/README @@ -39,7 +39,7 @@ To Do 0. When DEBOUNCE defined, there is a errors. 1. Layer Change by toggling Clear Key 2. Eject Key add. (following files should be modified.) - common/usb_keycodes.h + common/keycode.h common/keyboard.c 3. Use bluetooth EOF diff --git a/keyboard/IIgs_Standard/config.h b/keyboard/IIgs_Standard/config.h index 38ac21df66..11acf87c07 100644 --- a/keyboard/IIgs_Standard/config.h +++ b/keyboard/IIgs_Standard/config.h @@ -49,8 +49,8 @@ along with this program. If not, see . /* key combination for command */ #define IS_COMMAND() ( \ - keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_LCTRL) | MOD_BIT(KB_LALT) | MOD_BIT(KB_LGUI)) || \ - keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) \ + keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_LCTRL) | MOD_BIT(KC_LALT) | MOD_BIT(KC_LGUI)) || \ + keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \ ) diff --git a/keyboard/IIgs_Standard/keymap.c b/keyboard/IIgs_Standard/keymap.c index 77f3cd4d3b..722c44af4f 100644 --- a/keyboard/IIgs_Standard/keymap.c +++ b/keyboard/IIgs_Standard/keymap.c @@ -21,7 +21,7 @@ along with this program. If not, see . #include #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "print.h" #include "debug.h" #include "util.h" @@ -45,9 +45,9 @@ along with this program. If not, see . { R5C0, R5C1, R5C2, R5C3, R5C4, R5C5, R5C6, R5C7 }, \ { R6C0, R6C1, R6C2, R6C3, R6C4, R6C5, R6C6, R6C7 }, \ { R7C0, R7C1, R7C2, R7C3, R7C4, R7C5, R7C6, R7C7 }, \ - { R8C0, R8C1, KB_NO, KB_NO, KB_NO,KB_NO, KB_NO, KB_NO }, \ + { R8C0, R8C1, KC_NO, KC_NO, KC_NO,KC_NO, KC_NO, KC_NO }, \ { R9C0, R9C1, R9C2, R9C3, R9C4, R9C5, R9C6, R9C7 }, \ - { R10C0,R10C1, R10C2, R10C3, R10C4,R10C5, KB_NO, KB_NO} \ + { R10C0,R10C1, R10C2, R10C3, R10C4,R10C5, KC_NO, KC_NO} \ } #define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)])) @@ -68,14 +68,14 @@ static const uint8_t PROGMEM fn_layer[] = { // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer. // See layer.c for details. static const uint8_t PROGMEM fn_keycode[] = { - KB_NO, // Fn0 - KB_NO, // Fn1 - KB_SLSH, // Fn2 - KB_SCLN, // Fn3 - KB_SPC, // Fn4 - KB_NO, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_NO, // Fn0 + KC_NO, // Fn1 + KC_SLSH, // Fn2 + KC_SCLN, // Fn3 + KC_SPC, // Fn4 + KC_NO, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 }; static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { @@ -94,12 +94,12 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * |CAPS|Alt |Gui |` |SPC |BSLS |LFT|RGT|DN|UP| | 0 | . | T | * `-----------------------------------------------------------' |---------------' */ - KEYMAP( KB_PWR, - KB_ESC, KB_1, KB_2, KB_3, KB_4, KB_5, KB_6, KB_7, KB_8, KB_9, KB_0, KB_MINS,KB_EQL, KB_BSPC, KB_FN1, KB_PEQL, KB_PSLS, KB_PAST, \ - KB_TAB, KB_Q, KB_W, KB_E, KB_R, KB_T, KB_Y, KB_U, KB_I, KB_O, KB_P, KB_LBRC,KB_RBRC, KB_P7, KB_P8, KB_P9, KB_PPLS, \ - KB_LCTL,KB_A, KB_S, KB_D, KB_F, KB_G, KB_H, KB_J, KB_K, KB_L, KB_SCLN, KB_QUOT,KB_ENT, KB_P4, KB_P5, KB_P6, KB_PMNS, \ - KB_LSFT,KB_Z, KB_X, KB_C, KB_V, KB_B, KB_N, KB_M, KB_COMM,KB_DOT, KB_SLSH, KB_P1, KB_P2, KB_P3, \ - KB_CAPS,KB_LALT,KB_LGUI,KB_GRV, KB_SPC, KB_BSLS,KB_LEFT,KB_RGHT,KB_DOWN,KB_UP, KB_P0, KB_PDOT, KB_PENT), + KEYMAP( KC_PWR, + KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS,KC_EQL, KC_BSPC, KC_FN1, KC_PEQL, KC_PSLS, KC_PAST, \ + KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC,KC_RBRC, KC_P7, KC_P8, KC_P9, KC_PPLS, \ + KC_LCTL,KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,KC_ENT, KC_P4, KC_P5, KC_P6, KC_PMNS, \ + KC_LSFT,KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM,KC_DOT, KC_SLSH, KC_P1, KC_P2, KC_P3, \ + KC_CAPS,KC_LALT,KC_LGUI,KC_GRV, KC_SPC, KC_BSLS,KC_LEFT,KC_RGHT,KC_DOWN,KC_UP, KC_P0, KC_PDOT, KC_PENT), /* Layer 1: Tenkey use Layer @@ -117,12 +117,12 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { * |CAPS|Alt |Gui |` |SPC |BSLS |LFT|RGT|DN|UP| | 0 | . | T | * `-----------------------------------------------------------' `---------------' */ - KEYMAP( KB_PWR, \ - KB_ESC, KB_1, KB_2, KB_3, KB_4, KB_5, KB_6, KB_7, KB_8, KB_9, KB_0, KB_MINS,KB_EQL, KB_BSPC, KB_FN1, KB_PEQL, KB_PSLS, KB_MUTE, \ - KB_TAB, KB_Q, KB_W, KB_E, KB_R, KB_T, KB_Y, KB_U, KB_I, KB_O, KB_P, KB_LBRC,KB_RBRC, KB_INS, KB_P8, KB_PGUP, KB_VOLU, \ - KB_LCTL,KB_A, KB_S, KB_D, KB_F, KB_G, KB_H, KB_J, KB_K, KB_L, KB_SCLN, KB_QUOT,KB_ENT, KB_DEL, KB_UP, KB_PGDN, KB_VOLD, \ - KB_LSFT,KB_Z, KB_X, KB_C, KB_V, KB_B, KB_N, KB_M, KB_COMM,KB_DOT, KB_SLSH, KB_LEFT, KB_DOWN, KB_RIGHT, \ - KB_CAPS,KB_LALT,KB_LGUI,KB_GRV, KB_SPC, KB_BSLS,KB_LEFT,KB_RGHT,KB_DOWN,KB_UP, KB_P0, KB_PDOT, KB_PENT), + KEYMAP( KC_PWR, \ + KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS,KC_EQL, KC_BSPC, KC_FN1, KC_PEQL, KC_PSLS, KC_MUTE, \ + KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC,KC_RBRC, KC_INS, KC_P8, KC_PGUP, KC_VOLU, \ + KC_LCTL,KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,KC_ENT, KC_DEL, KC_UP, KC_PGDN, KC_VOLD, \ + KC_LSFT,KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM,KC_DOT, KC_SLSH, KC_LEFT, KC_DOWN, KC_RIGHT, \ + KC_CAPS,KC_LALT,KC_LGUI,KC_GRV, KC_SPC, KC_BSLS,KC_LEFT,KC_RGHT,KC_DOWN,KC_UP, KC_P0, KC_PDOT, KC_PENT), }; diff --git a/keyboard/hbkb/config.h b/keyboard/hbkb/config.h index deaabb2495..57adecfa5e 100644 --- a/keyboard/hbkb/config.h +++ b/keyboard/hbkb/config.h @@ -42,8 +42,8 @@ along with this program. If not, see . /* key combination for command */ #define IS_COMMAND() ( \ - keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_LCTRL) | MOD_BIT(KB_LALT) | MOD_BIT(KB_LGUI)) || \ - keyboard_report->mods == (MOD_BIT(KB_LALT) | MOD_BIT(KB_RALT)) \ + keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_LCTRL) | MOD_BIT(KC_LALT) | MOD_BIT(KC_LGUI)) || \ + keyboard_report->mods == (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT)) \ ) diff --git a/keyboard/hbkb/keymap.c b/keyboard/hbkb/keymap.c index 1de317c9a3..435cf1e95b 100644 --- a/keyboard/hbkb/keymap.c +++ b/keyboard/hbkb/keymap.c @@ -21,7 +21,7 @@ along with this program. If not, see . #include #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "print.h" #include "debug.h" #include "util.h" @@ -68,18 +68,18 @@ along with this program. If not, see . K11, K26, K36, K46, K56, K57, K77, K76, K86, K96, KA7, K16, \ K02, KB0, K67, KB7, K06 \ ) { \ - { KB_NO, KB_NO, KB_##K02, KB_NO, KB_NO, KB_NO, KB_##K06, KB_NO }, \ - { KB_NO, KB_##K11, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K16, KB_NO }, \ - { KB_NO, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \ - { KB_NO, KB_##K31, KB_NO, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_NO }, \ - { KB_NO, KB_NO, KB_NO, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \ - { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ - { KB_NO, KB_##K61, KB_NO, KB_NO, KB_##K64, KB_##K65, KB_##K66, KB_##K67 }, \ - { KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ - { KB_NO, KB_##K81, KB_##K82, KB_##K83, KB_##K84, KB_##K85, KB_##K86, KB_NO }, \ - { KB_NO, KB_NO, KB_NO, KB_##K93, KB_##K94, KB_##K95, KB_##K96, KB_NO }, \ - { KB_##KA0, KB_##KA1, KB_##KA2, KB_##KA3, KB_##KA4, KB_##KA5, KB_NO, KB_##KA7 }, \ - { KB_##KB0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##KB7 }, \ + { KC_NO, KC_NO, KC_##K02, KC_NO, KC_NO, KC_NO, KC_##K06, KC_NO }, \ + { KC_NO, KC_##K11, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K16, KC_NO }, \ + { KC_NO, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \ + { KC_NO, KC_##K31, KC_NO, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_NO }, \ + { KC_NO, KC_NO, KC_NO, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \ + { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \ + { KC_NO, KC_##K61, KC_NO, KC_NO, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \ + { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \ + { KC_NO, KC_##K81, KC_##K82, KC_##K83, KC_##K84, KC_##K85, KC_##K86, KC_NO }, \ + { KC_NO, KC_NO, KC_NO, KC_##K93, KC_##K94, KC_##K95, KC_##K96, KC_NO }, \ + { KC_##KA0, KC_##KA1, KC_##KA2, KC_##KA3, KC_##KA4, KC_##KA5, KC_NO, KC_##KA7 }, \ + { KC_##KB0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_##KB7 }, \ } #define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)])) @@ -100,14 +100,14 @@ static const uint8_t PROGMEM fn_layer[] = { // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer. // See layer.c for details. static const uint8_t PROGMEM fn_keycode[] = { - KB_NO, // Fn0 - KB_NO, // Fn1 - KB_SLSH, // Fn2 - KB_SCLN, // Fn3 - KB_SPC, // Fn4 - KB_NO, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_NO, // Fn0 + KC_NO, // Fn1 + KC_SLSH, // Fn2 + KC_SCLN, // Fn3 + KC_SPC, // Fn4 + KC_NO, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 }; static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { diff --git a/keyboard/hhkb/matrix.c b/keyboard/hhkb/matrix.c index 01473d1ec7..fd0d6f97f6 100644 --- a/keyboard/hhkb/matrix.c +++ b/keyboard/hhkb/matrix.c @@ -23,7 +23,7 @@ along with this program. If not, see . #include #include #include -#include "debug.h" +#include "print.h" #include "util.h" #include "timer.h" #include "matrix.h" @@ -228,24 +228,21 @@ uint16_t matrix_get_row(uint8_t row) return matrix[row]; } -void matrix_debug(void) +void matrix_print(void) { - if (!debug_matrix) - return; - #if (MATRIX_COLS <= 8) - debug("\nr/c 01234567\n"); + print("\nr/c 01234567\n"); #else - debug("\nr/c 0123456789ABCDEF\n"); + print("\nr/c 0123456789ABCDEF\n"); #endif for (uint8_t row = 0; row < matrix_rows(); row++) { - debug_hex(row); debug(": "); + phex(row); print(": "); #if (MATRIX_COLS <= 8) - debug_bin_reverse(matrix_get_row(row)); + pbin_reverse(matrix_get_row(row)); #else - debug_bin_reverse16(matrix_get_row(row)); + pbin_reverse16(matrix_get_row(row)); #endif - debug("\n"); + print("\n"); } } diff --git a/keyboard/macway/config.h b/keyboard/macway/config.h index 5503c77e3a..6ab0dec927 100644 --- a/keyboard/macway/config.h +++ b/keyboard/macway/config.h @@ -45,8 +45,8 @@ along with this program. If not, see . /* key combination for command */ #define IS_COMMAND() ( \ - keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_LCTRL) | MOD_BIT(KB_LALT) | MOD_BIT(KB_LGUI)) || \ - keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) \ + keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_LCTRL) | MOD_BIT(KC_LALT) | MOD_BIT(KC_LGUI)) || \ + keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \ ) diff --git a/keyboard/macway/keymap.c b/keyboard/macway/keymap.c index 6d5ad62e9c..aa50ba5c86 100644 --- a/keyboard/macway/keymap.c +++ b/keyboard/macway/keymap.c @@ -21,7 +21,7 @@ along with this program. If not, see . #include #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "print.h" #include "debug.h" #include "util.h" @@ -37,15 +37,15 @@ along with this program. If not, see . K67, K16, K26, K36, K46, K47, K57, K56, K66, K76, K87, K32, K35, \ K75, K22, K00, K07, K21, K04, K37, K27, K17 \ ) { \ - { KB_##K00, KB_##K01, KB_##K02, KB_NO, KB_##K04, KB_NO, KB_##K06, KB_##K07 }, \ - { KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ - { KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_NO, KB_##K26, KB_##K27 }, \ - { KB_##K30, KB_NO, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \ - { KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \ - { KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ - { KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_NO, KB_##K66, KB_##K67 }, \ - { KB_##K70, KB_NO, KB_NO, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_NO }, \ - { KB_##K80, KB_##K81, KB_##K82, KB_##K83, KB_##K84, KB_##K85, KB_NO, KB_##K87 } \ + { KC_##K00, KC_##K01, KC_##K02, KC_NO, KC_##K04, KC_NO, KC_##K06, KC_##K07 }, \ + { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \ + { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_NO, KC_##K26, KC_##K27 }, \ + { KC_##K30, KC_NO, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \ + { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \ + { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \ + { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_NO, KC_##K66, KC_##K67 }, \ + { KC_##K70, KC_NO, KC_NO, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_NO }, \ + { KC_##K80, KC_##K81, KC_##K82, KC_##K83, KC_##K84, KC_##K85, KC_NO, KC_##K87 } \ } #define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)])) @@ -66,14 +66,14 @@ static const uint8_t PROGMEM fn_layer[] = { // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer. // See layer.c for details. static const uint8_t PROGMEM fn_keycode[] = { - KB_NO, // Fn0 - KB_NO, // Fn1 - KB_SLSH, // Fn2 - KB_SCLN, // Fn3 - KB_SPC, // Fn4 - KB_NO, // Fn5 - KB_NO, // Fn6 - KB_NO // Fn7 + KC_NO, // Fn0 + KC_NO, // Fn1 + KC_SLSH, // Fn2 + KC_SCLN, // Fn3 + KC_SPC, // Fn4 + KC_NO, // Fn5 + KC_NO, // Fn6 + KC_NO // Fn7 }; static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { diff --git a/protocol/iwrap/iwrap.c b/protocol/iwrap/iwrap.c index 9c68761bf0..3cc9ca3061 100644 --- a/protocol/iwrap/iwrap.c +++ b/protocol/iwrap/iwrap.c @@ -29,7 +29,7 @@ along with this program. If not, see . #include #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "suart.h" #include "uart.h" #include "report.h" diff --git a/protocol/iwrap/main.c b/protocol/iwrap/main.c index 5c42a2c6ad..c11ff7ab95 100644 --- a/protocol/iwrap/main.c +++ b/protocol/iwrap/main.c @@ -34,7 +34,7 @@ along with this program. If not, see . #include "suart.h" #include "timer.h" #include "debug.h" -#include "usb_keycodes.h" +#include "keycode.h" #include "command.h" @@ -320,59 +320,59 @@ static uint8_t console_command(uint8_t c) static uint8_t key2asc(uint8_t key) { switch (key) { - case KB_A: return 'a'; - case KB_B: return 'b'; - case KB_C: return 'c'; - case KB_D: return 'd'; - case KB_E: return 'e'; - case KB_F: return 'f'; - case KB_G: return 'g'; - case KB_H: return 'h'; - case KB_I: return 'i'; - case KB_J: return 'j'; - case KB_K: return 'k'; - case KB_L: return 'l'; - case KB_M: return 'm'; - case KB_N: return 'n'; - case KB_O: return 'o'; - case KB_P: return 'p'; - case KB_Q: return 'q'; - case KB_R: return 'r'; - case KB_S: return 's'; - case KB_T: return 't'; - case KB_U: return 'u'; - case KB_V: return 'v'; - case KB_W: return 'w'; - case KB_X: return 'x'; - case KB_Y: return 'y'; - case KB_Z: return 'z'; - case KB_1: return '1'; - case KB_2: return '2'; - case KB_3: return '3'; - case KB_4: return '4'; - case KB_5: return '5'; - case KB_6: return '6'; - case KB_7: return '7'; - case KB_8: return '8'; - case KB_9: return '9'; - case KB_0: return '0'; - case KB_ENTER: return '\n'; - case KB_ESCAPE: return 0x1B; - case KB_BSPACE: return '\b'; - case KB_TAB: return '\t'; - case KB_SPACE: return ' '; - case KB_MINUS: return '-'; - case KB_EQUAL: return '='; - case KB_LBRACKET: return '['; - case KB_RBRACKET: return ']'; - case KB_BSLASH: return '\\'; - case KB_NONUS_HASH: return '\\'; - case KB_SCOLON: return ';'; - case KB_QUOTE: return '\''; - case KB_GRAVE: return '`'; - case KB_COMMA: return ','; - case KB_DOT: return '.'; - case KB_SLASH: return '/'; + case KC_A: return 'a'; + case KC_B: return 'b'; + case KC_C: return 'c'; + case KC_D: return 'd'; + case KC_E: return 'e'; + case KC_F: return 'f'; + case KC_G: return 'g'; + case KC_H: return 'h'; + case KC_I: return 'i'; + case KC_J: return 'j'; + case KC_K: return 'k'; + case KC_L: return 'l'; + case KC_M: return 'm'; + case KC_N: return 'n'; + case KC_O: return 'o'; + case KC_P: return 'p'; + case KC_Q: return 'q'; + case KC_R: return 'r'; + case KC_S: return 's'; + case KC_T: return 't'; + case KC_U: return 'u'; + case KC_V: return 'v'; + case KC_W: return 'w'; + case KC_X: return 'x'; + case KC_Y: return 'y'; + case KC_Z: return 'z'; + case KC_1: return '1'; + case KC_2: return '2'; + case KC_3: return '3'; + case KC_4: return '4'; + case KC_5: return '5'; + case KC_6: return '6'; + case KC_7: return '7'; + case KC_8: return '8'; + case KC_9: return '9'; + case KC_0: return '0'; + case KC_ENTER: return '\n'; + case KC_ESCAPE: return 0x1B; + case KC_BSPACE: return '\b'; + case KC_TAB: return '\t'; + case KC_SPACE: return ' '; + case KC_MINUS: return '-'; + case KC_EQUAL: return '='; + case KC_LBRACKET: return '['; + case KC_RBRACKET: return ']'; + case KC_BSLASH: return '\\'; + case KC_NONUS_HASH: return '\\'; + case KC_SCOLON: return ';'; + case KC_QUOTE: return '\''; + case KC_GRAVE: return '`'; + case KC_COMMA: return ','; + case KC_DOT: return '.'; + case KC_SLASH: return '/'; default: return 0x00; } } diff --git a/protocol/pjrc/usb_keyboard.c b/protocol/pjrc/usb_keyboard.c index e057c77fa1..49b85c179f 100644 --- a/protocol/pjrc/usb_keyboard.c +++ b/protocol/pjrc/usb_keyboard.c @@ -23,7 +23,7 @@ #include #include -#include "usb_keycodes.h" +#include "keycode.h" #include "usb_keyboard.h" #include "print.h" #include "debug.h" From fffc375b45ad795c4a8d3cde94783dac195a2613 Mon Sep 17 00:00:00 2001 From: tmk Date: Thu, 18 Oct 2012 00:10:20 +0900 Subject: [PATCH 18/18] Add child proof keyboard locking feature! Fix: add wait for Power down command Add ifdef of MOUSEKEY_ENABLE --- common/command.c | 23 ++++++++++++++++++++--- common/keyboard.c | 2 +- common/matrix.h | 2 +- 3 files changed, 22 insertions(+), 5 deletions(-) diff --git a/common/command.c b/common/command.c index bbc45f45a3..8e2e21a707 100644 --- a/common/command.c +++ b/common/command.c @@ -46,10 +46,12 @@ static bool command_common(uint8_t code); static void command_common_help(void); static bool command_console(uint8_t code); static void command_console_help(void); +#ifdef MOUSEKEY_ENABLE static bool mousekey_console(uint8_t code); static void mousekey_console_help(void); +#endif -static uint8_t kc2int(uint8_t code); +static uint8_t numkey2num(uint8_t code); static void switch_layer(uint8_t layer); static void clear_keyboard(void); @@ -68,9 +70,11 @@ bool command_proc(uint8_t code) case CONSOLE: command_console(code); break; +#ifdef MOUSEKEY_ENABLE case MOUSEKEY: mousekey_console(code); break; +#endif default: state = ONESHOT; return false; @@ -111,12 +115,24 @@ static void command_common_help(void) print("3/F3: switch to Layer3 \n"); print("4/F4: switch to Layer4 \n"); print("PScr: power down/remote wake-up\n"); + print("Caps: Lock Keyboard(Child Proof)\n"); print("Paus: jump to bootloader\n"); } static bool command_common(uint8_t code) { + static host_driver_t *host_driver = 0; switch (code) { + case KC_CAPSLOCK: + if (host_get_driver()) { + host_driver = host_get_driver(); + host_set_driver(0); + print("Locked.\n"); + } else { + host_set_driver(host_driver); + print("Unlocked.\n"); + } + break; case KC_H: case KC_SLASH: /* ? */ command_common_help(); @@ -241,6 +257,7 @@ static bool command_common(uint8_t code) } #else host_system_send(SYSTEM_POWER_DOWN); + _delay_ms(100); host_system_send(0); _delay_ms(500); #endif @@ -478,7 +495,7 @@ static bool mousekey_console(uint8_t code) case KC_8: case KC_9: case KC_0: - mousekey_param = kc2int(code); + mousekey_param = numkey2num(code); print("selected parameter: "); pdec(mousekey_param); print("\n"); break; case KC_UP: @@ -515,7 +532,7 @@ static bool mousekey_console(uint8_t code) /*********************************************************** * Utilities ***********************************************************/ -static uint8_t kc2int(uint8_t code) +static uint8_t numkey2num(uint8_t code) { switch (code) { case KC_1: return 1; diff --git a/common/keyboard.c b/common/keyboard.c index d7ced430e0..e973c46d5b 100644 --- a/common/keyboard.c +++ b/common/keyboard.c @@ -563,7 +563,7 @@ void keyboard_task(void) matrix_row = matrix_get_row(r); matrix_change = matrix_row ^ matrix_prev[r]; if (matrix_change) { - matrix_debug(); + if (debug_matrix) matrix_print(); for (int c = 0; c < MATRIX_COLS; c++) { if (matrix_change & (1<