di0ib/tmk_keyboard
1
0
Fork 0
Code Releases Activity

Merge branch 'layerfix'

Browse Source
This commit is contained in:
tmk 2012-10-18 01:11:06 +09:00
commit 3c822b511e
61 changed files with 2295 additions and 1619 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
common.mk
View File

@ -2,7 +2,6 @@ COMMON_DIR = common
SRC += $(COMMON_DIR)/host.c \ SRC += $(COMMON_DIR)/host.c \
$(COMMON_DIR)/keyboard.c \ $(COMMON_DIR)/keyboard.c \
$(COMMON_DIR)/command.c \ $(COMMON_DIR)/command.c \
$(COMMON_DIR)/layer.c \
$(COMMON_DIR)/timer.c \ $(COMMON_DIR)/timer.c \
$(COMMON_DIR)/print.c \ $(COMMON_DIR)/print.c \
$(COMMON_DIR)/debug.c \ $(COMMON_DIR)/debug.c \

570
common/command.c
View File

@ -17,16 +17,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <util/delay.h> #include <util/delay.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "host.h" #include "host.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
#include "timer.h" #include "timer.h"
#include "layer.h" #include "keyboard.h"
#include "matrix.h"
#include "bootloader.h" #include "bootloader.h"
#include "command.h" #include "command.h"
#ifdef MOUSEKEY_ENABLE
#include "mousekey.h"
#endif
#ifdef HOST_PJRC #ifdef HOST_PJRC
# include "usb_keyboard.h" # include "usb_keyboard.h"
@ -40,104 +42,182 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#endif #endif
static uint8_t command_common(void); 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);
#ifdef MOUSEKEY_ENABLE
static bool mousekey_console(uint8_t code);
static void mousekey_console_help(void);
#endif
static uint8_t numkey2num(uint8_t code);
static void switch_layer(uint8_t layer); static void switch_layer(uint8_t layer);
static void clear_keyboard(void);
static bool last_print_enable;
uint8_t command_proc(void) typedef enum { ONESHOT, CONSOLE, MOUSEKEY } cmdstate_t;
static cmdstate_t state = ONESHOT;
bool command_proc(uint8_t code)
{ {
uint8_t processed = 0; switch (state) {
last_print_enable = print_enable; case ONESHOT:
if (!IS_COMMAND())
if (!IS_COMMAND()) return false;
return 0; return (command_extra(code) || command_common(code));
case CONSOLE:
print_enable = true; command_console(code);
if (command_extra() || command_common()) {
processed = 1;
_delay_ms(500);
}
print_enable = last_print_enable;
return processed;
}
/* This allows to define extra commands. return 0 when not processed. */
uint8_t command_extra(void) __attribute__ ((weak));
uint8_t command_extra(void)
{
return 0;
}
static uint8_t command_common(void)
{
switch (host_get_first_key()) {
case KB_H:
help();
break; break;
case KB_B: #ifdef MOUSEKEY_ENABLE
host_clear_keyboard_report(); case MOUSEKEY:
host_send_keyboard_report(); mousekey_console(code);
print("jump to bootloader... "); break;
#endif
default:
state = ONESHOT;
return false;
}
return true;
}
/* 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)
{
return false;
}
/***********************************************************
* 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("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();
break;
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("\n\nJump to bootloader... ");
_delay_ms(1000); _delay_ms(1000);
bootloader_jump(); // not return bootloader_jump(); // not return
print("not supported.\n"); print("not supported.\n");
break; break;
case KB_D: case KC_D:
debug_enable = !debug_enable;
if (debug_enable) { if (debug_enable) {
last_print_enable = true; print("\nDEBUG: disabled.\n");
print("debug enabled.\n"); debug_matrix = false;
debug_matrix = true;
debug_keyboard = true;
debug_mouse = true;
} else {
print("debug disabled.\n");
last_print_enable = false;
debug_matrix = false;
debug_keyboard = 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; break;
case KB_X: // debug matrix toggle case KC_X: // debug matrix toggle
debug_matrix = !debug_matrix; debug_matrix = !debug_matrix;
if (debug_matrix) if (debug_matrix) {
print("debug matrix enabled.\n"); print("\nDEBUG: matrix enabled.\n");
else debug_enable = true;
print("debug matrix disabled.\n");
break;
case KB_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
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
print(STR(DESCRIPTION) "\n");
break;
case KB_T: // print timer
print("timer: "); phex16(timer_count); print("\n");
break;
case KB_P: // print toggle
if (last_print_enable) {
print("print disabled.\n");
last_print_enable = false;
} else { } else {
last_print_enable = true; print("\nDEBUG: matrix disabled.\n");
}
break;
case KC_K: // debug keyboard toggle
debug_keyboard = !debug_keyboard;
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("\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>>16); phex16(timer_count); print("\n");
break;
case KC_P: // print toggle
if (print_enable) {
print("print disabled.\n");
print_enable = false;
} else {
print_enable = true;
print("print enabled.\n"); print("print enabled.\n");
} }
break; break;
case KB_S: case KC_S:
print("\n\n----- Status -----\n");
print("host_keyboard_leds:"); phex(host_keyboard_leds()); print("\n"); print("host_keyboard_leds:"); phex(host_keyboard_leds()); print("\n");
#ifdef HOST_PJRC #ifdef HOST_PJRC
print("UDCON: "); phex(UDCON); print("\n"); print("UDCON: "); phex(UDCON); print("\n");
@ -156,10 +236,7 @@ static uint8_t command_common(void)
#endif #endif
break; break;
#ifdef NKRO_ENABLE #ifdef NKRO_ENABLE
case KB_N: case KC_N:
// send empty report before change
host_clear_keyboard_report();
host_send_keyboard_report();
keyboard_nkro = !keyboard_nkro; keyboard_nkro = !keyboard_nkro;
if (keyboard_nkro) if (keyboard_nkro)
print("NKRO: enabled\n"); print("NKRO: enabled\n");
@ -168,9 +245,8 @@ static uint8_t command_common(void)
break; break;
#endif #endif
#ifdef EXTRAKEY_ENABLE #ifdef EXTRAKEY_ENABLE
case KB_ESC: case KC_PSCREEN:
host_clear_keyboard_report(); // TODO: Power key should take this feature? otherwise any key during suspend.
host_send_keyboard_report();
#ifdef HOST_PJRC #ifdef HOST_PJRC
if (suspend && remote_wakeup) { if (suspend && remote_wakeup) {
usb_remote_wakeup(); usb_remote_wakeup();
@ -181,57 +257,296 @@ static uint8_t command_common(void)
} }
#else #else
host_system_send(SYSTEM_POWER_DOWN); host_system_send(SYSTEM_POWER_DOWN);
_delay_ms(100);
host_system_send(0); host_system_send(0);
_delay_ms(500); _delay_ms(500);
#endif #endif
break; break;
#endif #endif
case KB_BSPC: case KC_0:
matrix_init(); case KC_F10:
print("clear matrix\n");
break;
case KB_0:
switch_layer(0); switch_layer(0);
break; break;
case KB_1: case KC_1:
case KC_F1:
switch_layer(1); switch_layer(1);
break; break;
case KB_2: case KC_2:
case KC_F2:
switch_layer(2); switch_layer(2);
break; break;
case KB_3: case KC_3:
case KC_F3:
switch_layer(3); switch_layer(3);
break; break;
case KB_4: case KC_4:
case KC_F4:
switch_layer(4); switch_layer(4);
break; break;
default: default:
return 0; print("?");
return false;
} }
return 1; return true;
} }
static void help(void)
/***********************************************************
* Command console
***********************************************************/
static void command_console_help(void)
{ {
print("b: jump to bootloader\n"); print_enable = true;
print("d: toggle debug enable\n"); print("\n\n----- Console Help -----\n");
print("x: toggle matrix debug\n"); print("ESC/q: quit\n");
print("k: toggle keyboard debug\n"); #ifdef MOUSEKEY_ENABLE
print("m: toggle mouse debug\n"); print("m: mousekey\n");
print("p: toggle print enable\n");
print("v: print version\n");
print("t: print timer count\n");
print("s: print status\n");
#ifdef NKRO_ENABLE
print("n: toggle NKRO\n");
#endif #endif
print("Backspace: clear matrix\n"); }
print("ESC: power down/wake up\n");
print("0: switch to Layer0 \n"); static bool command_console(uint8_t code)
print("1: switch to Layer1 \n"); {
print("2: switch to Layer2 \n"); switch (code) {
print("3: switch to Layer3 \n"); case KC_H:
print("4: switch to Layer4 \n"); 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 = numkey2num(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 numkey2num(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) static void switch_layer(uint8_t layer)
@ -242,3 +557,18 @@ static void switch_layer(uint8_t layer)
default_layer = layer; default_layer = layer;
print("switch to Layer: "); phex(layer); print("\n"); print("switch to Layer: "); phex(layer); print("\n");
} }
static void clear_keyboard(void)
{
host_clear_keys();
host_clear_mods();
host_send_keyboard_report();
host_system_send(0);
host_consumer_send(0);
#ifdef MOUSEKEY_ENABLE
mousekey_clear();
mousekey_send();
#endif
}

4
common/command.h
View File

@ -18,8 +18,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef COMMAND_H #ifndef COMMAND_H
#define COMMAND #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. */ /* This allows to extend commands. Return 0 when command is not processed. */
uint8_t command_extra(void); bool command_extra(uint8_t code);
#endif #endif

2
common/debug.h
View File

@ -23,6 +23,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define debug(s) if(debug_enable) print_P(PSTR(s)) #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_hex(c) if(debug_enable) phex(c)
#define debug_hex16(i) if(debug_enable) phex16(i) #define debug_hex16(i) if(debug_enable) phex16(i)
#define debug_bin(c) if(debug_enable) pbin(c) #define debug_bin(c) if(debug_enable) pbin(c)

138
common/host.c
View File

@ -1,5 +1,5 @@
/* /*
Copyright 2011 Jun Wako <wakojun@gmail.com> Copyright 2011,2012 Jun Wako <wakojun@gmail.com>
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
@ -17,7 +17,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <avr/interrupt.h> #include <avr/interrupt.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "host.h" #include "host.h"
#include "util.h" #include "util.h"
#include "debug.h" #include "debug.h"
@ -27,13 +27,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
bool keyboard_nkro = false; bool keyboard_nkro = false;
#endif #endif
static host_driver_t *driver; report_keyboard_t *keyboard_report = &(report_keyboard_t){};
static report_keyboard_t report0; report_mouse_t mouse_report = {};
static report_keyboard_t report1;
report_keyboard_t *keyboard_report = &report0;
report_keyboard_t *keyboard_report_prev = &report1;
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 add_key_byte(uint8_t code);
static inline void del_key_byte(uint8_t code); static inline void del_key_byte(uint8_t code);
static inline void add_key_bit(uint8_t code); static inline void add_key_bit(uint8_t code);
@ -55,8 +56,48 @@ uint8_t host_keyboard_leds(void)
if (!driver) return 0; if (!driver) return 0;
return (*driver->keyboard_leds)(); 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) void host_add_key(uint8_t key)
{ {
#ifdef NKRO_ENABLE #ifdef NKRO_ENABLE
@ -79,6 +120,13 @@ void host_del_key(uint8_t key)
del_key_byte(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) void host_add_mod_bit(uint8_t mod)
{ {
keyboard_report->mods |= mod; keyboard_report->mods |= mod;
@ -94,40 +142,9 @@ void host_set_mods(uint8_t mods)
keyboard_report->mods = mods; keyboard_report->mods = mods;
} }
void host_add_code(uint8_t code) void host_clear_mods(void)
{
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)
{ {
keyboard_report->mods = 0; keyboard_report->mods = 0;
for (int8_t i = 0; i < REPORT_KEYS; i++) {
keyboard_report->keys[i] = 0;
}
} }
uint8_t host_has_anykey(void) uint8_t host_has_anykey(void)
@ -140,6 +157,11 @@ uint8_t host_has_anykey(void)
return cnt; return cnt;
} }
uint8_t host_has_anymod(void)
{
return bitpop(keyboard_report->mods);
}
uint8_t host_get_first_key(void) uint8_t host_get_first_key(void)
{ {
#ifdef NKRO_ENABLE #ifdef NKRO_ENABLE
@ -153,53 +175,36 @@ uint8_t host_get_first_key(void)
return keyboard_report->keys[0]; return keyboard_report->keys[0];
} }
void host_send_keyboard_report(void) void host_send_keyboard_report(void)
{ {
if (!driver) return; if (!driver) return;
(*driver->send_keyboard)(keyboard_report); host_keyboard_send(keyboard_report);
} }
void host_mouse_send(report_mouse_t *report) uint8_t host_mouse_in_use(void)
{ {
if (!driver) return; return (mouse_report.buttons | mouse_report.x | mouse_report.y | mouse_report.v | mouse_report.h);
(*driver->send_mouse)(report);
} }
void host_system_send(uint16_t data) uint16_t host_last_sysytem_report(void)
{ {
static uint16_t last_data = 0; return last_system_report;
if (data == last_data) return;
last_data = data;
if (!driver) return;
(*driver->send_system)(data);
} }
void host_consumer_send(uint16_t data) uint16_t host_last_consumer_report(void)
{ {
static uint16_t last_data = 0; return last_consumer_report;
if (data == last_data) return;
last_data = data;
if (!driver) return;
(*driver->send_consumer)(data);
} }
static inline void add_key_byte(uint8_t code) static inline void add_key_byte(uint8_t code)
{ {
// TODO: fix ugly code
int8_t i = 0; int8_t i = 0;
int8_t empty = -1; int8_t empty = -1;
for (; i < REPORT_KEYS; i++) { for (; i < REPORT_KEYS; i++) {
if (keyboard_report_prev->keys[i] == code) { if (keyboard_report->keys[i] == code) {
keyboard_report->keys[i] = code;
break; break;
} }
if (empty == -1 && if (empty == -1 && keyboard_report->keys[i] == 0) {
keyboard_report_prev->keys[i] == 0 &&
keyboard_report->keys[i] == 0) {
empty = i; empty = i;
} }
} }
@ -216,7 +221,6 @@ static inline void del_key_byte(uint8_t code)
for (; i < REPORT_KEYS; i++) { for (; i < REPORT_KEYS; i++) {
if (keyboard_report->keys[i] == code) { if (keyboard_report->keys[i] == code) {
keyboard_report->keys[i] = 0; keyboard_report->keys[i] = 0;
break;
} }
} }
} }

42
common/host.h
View File

@ -31,33 +31,41 @@ extern "C" {
extern bool keyboard_nkro; extern bool keyboard_nkro;
#endif #endif
/* report */
extern report_keyboard_t *keyboard_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); void host_set_driver(host_driver_t *driver);
host_driver_t *host_get_driver(void); host_driver_t *host_get_driver(void);
/* host driver interface */
uint8_t host_keyboard_leds(void); uint8_t host_keyboard_leds(void);
void host_keyboard_send(report_keyboard_t *report);
/* keyboard report operations */
void host_add_key(uint8_t key);
void host_del_key(uint8_t key);
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);
uint8_t host_has_anykey(void);
uint8_t host_get_first_key(void);
void host_send_keyboard_report(void);
void host_mouse_send(report_mouse_t *report); void host_mouse_send(report_mouse_t *report);
void host_system_send(uint16_t data); void host_system_send(uint16_t data);
void host_consumer_send(uint16_t data); void host_consumer_send(uint16_t data);
/* keyboard report utils */
void host_add_key(uint8_t key);
void host_del_key(uint8_t key);
void host_clear_keys(void);
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);
uint8_t host_has_anykey(void);
uint8_t host_has_anymod(void);
uint8_t host_get_first_key(void);
void host_send_keyboard_report(void);
/* mouse report utils */
uint8_t host_mouse_in_use(void);
uint16_t host_last_sysytem_report(void);
uint16_t host_last_consumer_report(void);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

700
common/keyboard.c
View File

@ -15,28 +15,536 @@ You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "keyboard.h" #include "keyboard.h"
#include "host.h"
#include "layer.h"
#include "matrix.h" #include "matrix.h"
#include "keymap.h"
#include "host.h"
#include "led.h" #include "led.h"
#include "usb_keycodes.h" #include "keycode.h"
#include "timer.h" #include "timer.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "command.h" #include "command.h"
#include "util.h"
#ifdef MOUSEKEY_ENABLE #ifdef MOUSEKEY_ENABLE
#include "mousekey.h" #include "mousekey.h"
#endif #endif
#ifdef EXTRAKEY_ENABLE
#include <util/delay.h>
#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 {
NONE,
FN_DOWN, FN_UP,
FNK_DOWN, FNK_UP,
KEY_DOWN, KEY_UP,
MOD_DOWN, MOD_UP,
} keykind_t;
typedef enum { IDLE, DELAYING, WAITING, PRESSING } kbdstate_t;
#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 #endif
/* 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 uint8_t last_leds = 0;
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 ? 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;
}
static void clear_keyboard(void)
{
host_clear_keys();
host_clear_mods();
host_send_keyboard_report();
host_system_send(0);
host_consumer_send(0);
#ifdef MOUSEKEY_ENABLE
mousekey_clear();
mousekey_send();
#endif
}
static void clear_keyboard_but_mods(void)
{
host_clear_keys();
host_send_keyboard_report();
host_system_send(0);
host_consumer_send(0);
#ifdef MOUSEKEY_ENABLE
mousekey_clear();
mousekey_send();
#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;
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) {
Kdebug("Layer Switch(on): "); Kdebug_hex(current_layer);
Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n");
clear_keyboard_but_mods();
current_layer = new_layer;
}
}
static bool layer_switch_off(uint8_t code)
{
if (!IS_FN(code)) return false;
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) {
Kdebug("Layer Switch(off): "); Kdebug_hex(current_layer);
Kdebug(" -> "); Kdebug_hex(new_layer); Kdebug("\n");
clear_keyboard_but_mods();
current_layer = new_layer;
return true;
}
return false;
}
static void register_code(uint8_t code)
{
if IS_KEY(code) {
if (!command_proc(code)) {
host_add_key(code);
host_send_keyboard_report();
}
}
else if IS_MOD(code) {
host_add_mod_bit(MOD_BIT(code));
host_send_keyboard_report();
}
else if IS_FN(code) {
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
mousekey_on(code);
mousekey_send();
#endif
}
else if IS_CONSUMER(code) {
uint16_t usage = 0;
switch (code) {
case KC_AUDIO_MUTE:
usage = AUDIO_MUTE;
break;
case KC_AUDIO_VOL_UP:
usage = AUDIO_VOL_UP;
break;
case KC_AUDIO_VOL_DOWN:
usage = AUDIO_VOL_DOWN;
break;
case KC_MEDIA_NEXT_TRACK:
usage = TRANSPORT_NEXT_TRACK;
break;
case KC_MEDIA_PREV_TRACK:
usage = TRANSPORT_PREV_TRACK;
break;
case KC_MEDIA_STOP:
usage = TRANSPORT_STOP;
break;
case KC_MEDIA_PLAY_PAUSE:
usage = TRANSPORT_PLAY_PAUSE;
break;
case KC_MEDIA_SELECT:
usage = AL_CC_CONFIG;
break;
case KC_MAIL:
usage = AL_EMAIL;
break;
case KC_CALCULATOR:
usage = AL_CALCULATOR;
break;
case KC_MY_COMPUTER:
usage = AL_LOCAL_BROWSER;
break;
case KC_WWW_SEARCH:
usage = AC_SEARCH;
break;
case KC_WWW_HOME:
usage = AC_HOME;
break;
case KC_WWW_BACK:
usage = AC_BACK;
break;
case KC_WWW_FORWARD:
usage = AC_FORWARD;
break;
case KC_WWW_STOP:
usage = AC_STOP;
break;
case KC_WWW_REFRESH:
usage = AC_REFRESH;
break;
case KC_WWW_FAVORITES:
usage = AC_BOOKMARKS;
break;
}
host_consumer_send(usage);
}
else if IS_SYSTEM(code) {
uint16_t usage = 0;
switch (code) {
case KC_SYSTEM_POWER:
usage = SYSTEM_POWER_DOWN;
break;
case KC_SYSTEM_SLEEP:
usage = SYSTEM_SLEEP;
break;
case KC_SYSTEM_WAKE:
usage = SYSTEM_WAKE_UP;
break;
}
host_system_send(usage);
}
}
static void unregister_code(uint8_t code)
{
if IS_KEY(code) {
host_del_key(code);
host_send_keyboard_report();
}
else if IS_MOD(code) {
host_del_mod_bit(MOD_BIT(code));
host_send_keyboard_report();
}
else if IS_FN(code) {
host_del_key(keymap_fn_keycode(FN_INDEX(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);
}
else if IS_SYSTEM(code) {
host_system_send(0x0000);
}
}
/*
*
* Event/State|IDLE PRESSING DELAYING[f] WAITING[f,k]
* -----------+------------------------------------------------------------------
* Fn Down |(L+) -*1 WAITING(Sk) IDLE(Rf,Ps)*7
* Up |(L-) IDLE(L-)*8 IDLE(L-)*8 IDLE(L-)*8
* Fnk Down |DELAYING(Sf)* (Rf) WAITING(Sk) IDLE(Rf,Ps,Rf)
* Up |(L-) IDLE(L-/Uf)*8 IDLE(Rf,Uf/L-)*3 IDLE(Rf,Ps,Uf/L-)*3
* Key Down |PRESSING(Rk) (Rk) WAITING(Sk) IDLE(Rf,Ps,Rk)
* Up |(Uk) IDLE(Uk)*4 (Uk) IDLE(L+,Ps,Pk)/(Uk)*a
* |
* Delay |- - IDLE(L+) IDLE(L+,Ps)
* Magic Key |COMMAND*5
*
* *1: ignore Fn if other key is down.
* *2: register Fnk if any key is pressing
* *3: register/unregister delayed Fnk and move to IDLE if code == delayed Fnk, else *8
* *4: if no keys registered to host
* *5: unregister all keys
* *6: only if no keys down
* *7: ignore Fn because Fnk key and stored key are down.
* *8: move to IDLE if layer switch(off) occurs, else stay at current state
* *9: repeat key if pressing Fnk twice quickly(move to PRESSING)
* *a: layer switch and process waiting key and code if code == wainting key, else unregister key
*
* States:
* IDLE: No key is down except modifiers
* DELAYING: delay layer switch after pressing Fn with alt keycode
* WAITING: key is pressed during DELAYING
*
* Events:
* Fn: Fn key without alternative keycode
* Fnk: Fn key with alternative keycode
* -: ignore
* Delay: layer switch delay term is elapsed
*
* Actions:
* Rk: register key
* Uk: unregister key
* Rf: register Fn(alt keycode)
* Uf: unregister Fn(alt keycode)
* Rs: register stored key
* Us: unregister stored key
* Sk: Store key(waiting Key)
* Sf: Store Fn(delayed Fn)
* Ps: Process stored key
* Ps: Process key
* Is: Interpret stored keys in current layer
* L+: Switch to new layer(*unregister* all keys but modifiers)
* L-: Switch back to last layer(*unregister* all keys but modifiers)
* Ld: Switch back to default layer(*unregister* all keys but modifiers)
*/
#define NEXT(state) do { \
Kdebug("NEXT: "); Kdebug_P(state_str(kbdstate)); \
kbdstate = state; \
Kdebug(" -> "); Kdebug_P(state_str(kbdstate)); Kdebug("\n"); \
} while (0)
static inline void process_key(keyevent_t event)
{
uint8_t code = keymap_get_keycode(current_layer, event.key.row, event.key.col);
keykind_t kind = get_keykind(code, event.pressed);
uint8_t tmp_mods;
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:
switch (kind) {
case FN_DOWN:
layer_switch_on(code);
break;
case FN_UP:
layer_switch_off(code);
break;
case FNK_DOWN:
// 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(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);
break;
case KEY_DOWN:
register_code(code);
NEXT(PRESSING);
break;
case MOD_DOWN:
register_code(code);
break;
case KEY_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:
if (layer_switch_off(code))
NEXT(IDLE);
break;
case FNK_DOWN:
register_code(code);
break;
case FNK_UP:
if (layer_switch_off(code)) {
NEXT(IDLE);
} else {
unregister_code(code);
if (!anykey_sent_to_host())
NEXT(IDLE);
}
break;
case KEY_DOWN:
case MOD_DOWN:
register_code(code);
break;
case KEY_UP:
case MOD_UP:
unregister_code(code);
if (!anykey_sent_to_host())
NEXT(IDLE);
break;
default:
break;
}
break;
case DELAYING:
switch (kind) {
case FN_DOWN:
case FNK_DOWN:
case KEY_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:
if (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(delayed_fn.code);
unregister_code(delayed_fn.code);
host_set_mods(tmp_mods);
NEXT(IDLE);
} else {
if (layer_switch_off(code))
NEXT(IDLE);
}
break;
case KEY_UP:
case MOD_UP:
unregister_code(code);
break;
default:
break;
}
break;
case WAITING:
switch (kind) {
case FN_DOWN:
case FNK_DOWN:
case KEY_DOWN:
tmp_mods = keyboard_report->mods;
host_set_mods(delayed_fn.mods);
register_code(delayed_fn.code);
host_set_mods(waiting_key.mods);
register_code(waiting_key.code);
host_set_mods(tmp_mods);
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:
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(delayed_fn.code);
host_set_mods(waiting_key.mods);
register_code(waiting_key.code);
unregister_code(delayed_fn.code);
host_set_mods(tmp_mods);
NEXT(IDLE);
} else {
if (layer_switch_off(code))
NEXT(IDLE);
}
break;
case KEY_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;
}
}
void keyboard_init(void) void keyboard_init(void)
{ {
debug_keyboard = true;
timer_init(); timer_init();
matrix_init(); matrix_init();
#ifdef PS2_MOUSE_ENABLE #ifdef PS2_MOUSE_ENABLE
@ -44,150 +552,72 @@ void keyboard_init(void)
#endif #endif
} }
void keyboard_proc(void) void keyboard_task(void)
{ {
uint8_t fn_bits = 0; static matrix_row_t matrix_prev[MATRIX_ROWS];
#ifdef EXTRAKEY_ENABLE matrix_row_t matrix_row = 0;
uint16_t consumer_code = 0; matrix_row_t matrix_change = 0;
uint16_t system_code = 0;
#endif
matrix_scan(); matrix_scan();
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();
if (matrix_is_modified()) { for (int c = 0; c < MATRIX_COLS; c++) {
if (debug_matrix) matrix_print(); if (matrix_change & (1<<c)) {
#ifdef DEBUG_LED process_key((keyevent_t){
// LED flash for debug .key = (key_t){ .row = r, .col = c },
DEBUG_LED_CONFIG; .pressed = (matrix_row & (1<<c))
DEBUG_LED_ON; });
#endif // record a processed key
} matrix_prev[r] ^= (1<<c);
// process a key per task call
if (matrix_has_ghost()) { goto MATRIX_LOOP_END;
// should send error?
debug("matrix has ghost!!\n");
return;
}
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();
} }
#endif
system_code = SYSTEM_POWER_DOWN;
} else if (code == KB_SYSTEM_SLEEP) {
system_code = SYSTEM_SLEEP;
} else if (code == KB_SYSTEM_WAKE) {
system_code = SYSTEM_WAKE_UP;
} }
// Consumer Page }
else if (code == KB_AUDIO_MUTE) { }
consumer_code = AUDIO_MUTE; MATRIX_LOOP_END:
} else if (code == KB_AUDIO_VOL_UP) {
consumer_code = AUDIO_VOL_UP; // layer switch when delay term elapses
} else if (code == KB_AUDIO_VOL_DOWN) { if (kbdstate == DELAYING || kbdstate == WAITING) {
consumer_code = AUDIO_VOL_DOWN; if (timer_elapsed(delayed_fn.time) > LAYER_DELAY) {
if (kbdstate == DELAYING) {
layer_switch_on(delayed_fn.code);
NEXT(IDLE);
} }
else if (code == KB_MEDIA_NEXT_TRACK) { if (kbdstate == WAITING) {
consumer_code = TRANSPORT_NEXT_TRACK; layer_switch_on(delayed_fn.code);
} else if (code == KB_MEDIA_PREV_TRACK) { NEXT(IDLE);
consumer_code = TRANSPORT_PREV_TRACK; uint8_t tmp_mods = keyboard_report->mods;
} else if (code == KB_MEDIA_STOP) { host_set_mods(waiting_key.mods);
consumer_code = TRANSPORT_STOP; process_key(waiting_key.event);
} else if (code == KB_MEDIA_PLAY_PAUSE) { host_set_mods(tmp_mods);
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");
} }
} }
} }
layer_switching(fn_bits);
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 #ifdef MOUSEKEY_ENABLE
mousekey_send(); // mousekey repeat & acceleration
mousekey_task();
#endif #endif
#ifdef PS2_MOUSE_ENABLE // FAIL SAFE: clear all key if no key down
// TODO: should comform new API if (matrix_change) {
if (ps2_mouse_read() == 0) matrix_row_t is_matrix_on = 0;
ps2_mouse_usb_send(); for (int r = 0; r < MATRIX_ROWS; r++) {
#endif is_matrix_on |= matrix_get_row(r);
}
if (last_leds != host_keyboard_leds()) { if (!is_matrix_on) {
keyboard_set_leds(host_keyboard_leds()); Kdebug("FAIL SAFE: clear all keys(default layer).\n");
last_leds = host_keyboard_leds(); clear_keyboard();
current_layer = default_layer;
}
} }
return;
} }
void keyboard_set_leds(uint8_t leds) void keyboard_set_leds(uint8_t leds)

28
common/keyboard.h
View File

@ -18,15 +18,41 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef KEYBOARD_H #ifndef KEYBOARD_H
#define KEYBOARD_H #define KEYBOARD_H
#include <stdbool.h>
#include <stdint.h> #include <stdint.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #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_init(void);
void keyboard_proc(void); void keyboard_task(void);
void keyboard_set_leds(uint8_t leds); void keyboard_set_leds(uint8_t leds);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

448
common/keycode.h Normal file
View File

@ -0,0 +1,448 @@
/*
Copyright 2011,2012 Jun Wako <wakojun@gmail.com>
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 <http://www.gnu.org/licenses/>.
*/
/*
* 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_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)
#define IS_SYSTEM(code) (KC_POWER <= (code) && (code) <= KC_WAKE)
#define MOD_BIT(code) (1<<MOD_INDEX(code))
#define MOD_INDEX(code) ((code) & 0x07)
#define FN_BIT(code) (1<<FN_INDEX(code))
#define FN_INDEX(code) ((code) - KC_FN0)
/*
* Short names for ease of definition of keymap
*/
#define KC_LCTL KC_LCTRL
#define KC_RCTL KC_RCTRL
#define KC_LSFT KC_LSHIFT
#define KC_RSFT KC_RSHIFT
#define KC_ESC KC_ESCAPE
#define KC_BSPC KC_BSPACE
#define KC_ENT KC_ENTER
#define KC_DEL KC_DELETE
#define KC_INS KC_INSERT
#define KC_CAPS KC_CAPSLOCK
#define KC_RGHT KC_RIGHT
#define KC_PGDN KC_PGDOWN
#define KC_PSCR KC_PSCREEN
#define KC_SLCK KC_SCKLOCK
#define KC_PAUS KC_PAUSE
#define KC_BRK KC_PAUSE
#define KC_NLCK KC_NUMLOCK
#define KC_SPC KC_SPACE
#define KC_MINS KC_MINUS
#define KC_EQL KC_EQUAL
#define KC_GRV KC_GRAVE
#define KC_RBRC KC_RBRACKET
#define KC_LBRC KC_LBRACKET
#define KC_COMM KC_COMMA
#define KC_BSLS KC_BSLASH
#define KC_SLSH KC_SLASH
#define KC_SCLN KC_SCOLON
#define KC_QUOT KC_QUOTE
#define KC_APP KC_APPLICATION
#define KC_NUHS KC_NONUS_HASH
#define KC_NUBS KC_NONUS_BSLASH
#define KC_ERAS KC_ALT_ERASE,
#define KC_CLR KC_CLEAR
/* Japanese specific */
#define KC_ZKHK KC_GRAVE
#define KC_RO KC_INT1
#define KC_KANA KC_INT2
#define KC_JYEN KC_INT3
#define KC_HENK KC_INT4
#define KC_MHEN KC_INT5
/* Keypad */
#define KC_P1 KC_KP_1
#define KC_P2 KC_KP_2
#define KC_P3 KC_KP_3
#define KC_P4 KC_KP_4
#define KC_P5 KC_KP_5
#define KC_P6 KC_KP_6
#define KC_P7 KC_KP_7
#define KC_P8 KC_KP_8
#define KC_P9 KC_KP_9
#define KC_P0 KC_KP_0
#define KC_PDOT KC_KP_DOT
#define KC_PCMM KC_KP_COMMA
#define KC_PSLS KC_KP_SLASH
#define KC_PAST KC_KP_ASTERISK
#define KC_PMNS KC_KP_MINUS
#define KC_PPLS KC_KP_PLUS
#define KC_PEQL KC_KP_EQUAL
#define KC_PENT KC_KP_ENTER
/* Mousekey */
#define KC_MS_U KC_MS_UP
#define KC_MS_D KC_MS_DOWN
#define KC_MS_L KC_MS_LEFT
#define KC_MS_R KC_MS_RIGHT
#define KC_BTN1 KC_MS_BTN1
#define KC_BTN2 KC_MS_BTN2
#define KC_BTN3 KC_MS_BTN3
#define KC_BTN4 KC_MS_BTN4
#define KC_BTN5 KC_MS_BTN5
#define KC_WH_U KC_MS_WH_UP
#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
#define KC_WAKE KC_SYSTEM_WAKE
/* Consumer Page */
#define KC_MUTE KC_AUDIO_MUTE
#define KC_VOLU KC_AUDIO_VOL_UP
#define KC_VOLD KC_AUDIO_VOL_DOWN
#define KC_MNXT KC_MEDIA_NEXT_TRACK
#define KC_MPRV KC_MEDIA_PREV_TRACK
#define KC_MSTP KC_MEDIA_STOP
#define KC_MPLY KC_MEDIA_PLAY_PAUSE
#define KC_MSEL KC_MEDIA_SELECT
#define KC_MAIL KC_MAIL
#define KC_CALC KC_CALCULATOR
#define KC_MYCM KC_MY_COMPUTER
#define KC_WSCH KC_WWW_SEARCH
#define KC_WHOM KC_WWW_HOME
#define KC_WBAK KC_WWW_BACK
#define KC_WFWD KC_WWW_FORWARD
#define KC_WSTP KC_WWW_STOP
#define KC_WREF KC_WWW_REFRESH
#define KC_WFAV KC_WWW_FAVORITES
/* USB HID Keyboard/Keypad Usage(0x07) */
enum hid_keyboard_keypad_usage {
KC_NO = 0x00,
KC_ROLL_OVER,
KC_POST_FAIL,
KC_UNDEFINED,
KC_A,
KC_B,
KC_C,
KC_D,
KC_E,
KC_F,
KC_G,
KC_H,
KC_I,
KC_J,
KC_K,
KC_L,
KC_M, /* 0x10 */
KC_N,
KC_O,
KC_P,
KC_Q,
KC_R,
KC_S,
KC_T,
KC_U,
KC_V,
KC_W,
KC_X,
KC_Y,
KC_Z,
KC_1,
KC_2,
KC_3, /* 0x20 */
KC_4,
KC_5,
KC_6,
KC_7,
KC_8,
KC_9,
KC_0,
KC_ENTER,
KC_ESCAPE,
KC_BSPACE,
KC_TAB,
KC_SPACE,
KC_MINUS,
KC_EQUAL,
KC_LBRACKET,
KC_RBRACKET, /* 0x30 */
KC_BSLASH, /* \ (and |) */
KC_NONUS_HASH, /* Non-US # and ~ */
KC_SCOLON, /* ; (and :) */
KC_QUOTE, /* ' and " */
KC_GRAVE, /* Grave accent and tilde */
KC_COMMA, /* , and < */
KC_DOT, /* . and > */
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, /* 0xF8 */
/* Mousekey wheel */
KC_MS_WH_UP,
KC_MS_WH_DOWN,
KC_MS_WH_LEFT,
KC_MS_WH_RIGHT, /* 0xFC */
/* Mousekey accel */
KC_MS_ACCEL0,
KC_MS_ACCEL1,
KC_MS_ACCEL2 /* 0xFF */
};
#endif /* KEYCODE_H */

207
common/layer.c
View File

@ -1,207 +0,0 @@
/*
Copyright 2011 Jun Wako <wakojun@gmail.com>
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 <http://www.gnu.org/licenses/>.
*/
#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<<i)) {
host_add_code(keymap_fn_keycode(1<<i));
}
}
}
inline
static uint8_t new_layer(uint8_t fn_bits)
{
return (fn_bits ? keymap_fn_layer(fn_bits) : default_layer);
}

32
common/layer.h
View File

@ -1,32 +0,0 @@
/*
Copyright 2011 Jun Wako <wakojun@gmail.com>
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 <http://www.gnu.org/licenses/>.
*/
#ifndef LAYER_H
#define LAYER_H 1
#include <stdint.h>
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

21
common/matrix.h
View File

@ -18,8 +18,23 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef MATRIX_H #ifndef MATRIX_H
#define MATRIX_H #define MATRIX_H
#include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#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<<col))
/* number of matrix rows */ /* number of matrix rows */
uint8_t matrix_rows(void); uint8_t matrix_rows(void);
/* number of matrix columns */ /* number of matrix columns */
@ -35,11 +50,7 @@ bool matrix_has_ghost(void);
/* whether a swtich is on */ /* whether a swtich is on */
bool matrix_is_on(uint8_t row, uint8_t col); bool matrix_is_on(uint8_t row, uint8_t col);
/* matrix state on row */ /* matrix state on row */
#if (MATRIX_COLS <= 8) matrix_row_t matrix_get_row(uint8_t row);
uint8_t matrix_get_row(uint8_t row);
#else
uint16_t matrix_get_row(uint8_t row);
#endif
/* count keys pressed */ /* count keys pressed */
uint8_t matrix_key_count(void); uint8_t matrix_key_count(void);
/* print matrix for debug */ /* print matrix for debug */

212
common/mousekey.c
View File

@ -17,7 +17,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <util/delay.h> #include <util/delay.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "host.h" #include "host.h"
#include "timer.h" #include "timer.h"
#include "print.h" #include "print.h"
@ -25,108 +25,172 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "mousekey.h" #include "mousekey.h"
static report_mouse_t report;
static report_mouse_t report_prev;
static uint8_t mousekey_repeat = 0; static uint8_t mousekey_repeat = 0;
static uint8_t mousekey_accel = 0;
static void mousekey_debug(void); static void mousekey_debug(void);
/* /*
* TODO: fix acceleration algorithm * Mouse keys acceleration algorithm
* see wikipedia http://en.wikipedia.org/wiki/Mouse_keys * http://en.wikipedia.org/wiki/Mouse_keys
*
* speed = delta * max_speed * (repeat / time_to_max)**((1000+curve)/1000)
*/ */
#ifndef MOUSEKEY_DELAY_TIME /* milliseconds between the initial key press and first repeated motion event (0-2550) */
# define MOUSEKEY_DELAY_TIME 255 uint8_t mk_delay = MOUSEKEY_DELAY/10;
#endif /* milliseconds between repeated motion events (0-255) */
uint8_t mk_interval = MOUSEKEY_INTERVAL;
// acceleration parameters /* steady speed (in action_delta units) applied each event (0-255) */
uint8_t mousekey_move_unit = 2; uint8_t mk_max_speed = MOUSEKEY_MAX_SPEED;
uint8_t mousekey_resolution = 5; /* number of events (count) accelerating to steady speed (0-255) */
uint8_t mk_time_to_max = MOUSEKEY_TIME_TO_MAX;
/* ramp used to reach maximum pointer speed (NOT SUPPORTED) */
//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 inline uint8_t move_unit(void) static uint16_t last_timer = 0;
static uint8_t move_unit(void)
{ {
uint16_t unit = 5 + mousekey_repeat*2; uint16_t unit;
return (unit > 63 ? 63 : unit); 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;
}
return (unit > MOUSEKEY_MOVE_MAX ? MOUSEKEY_MOVE_MAX : (unit == 0 ? 1 : unit));
} }
void mousekey_decode(uint8_t code) static uint8_t wheel_unit(void)
{ {
if (code == KB_MS_UP) report.y = -move_unit(); uint16_t unit;
else if (code == KB_MS_DOWN) report.y = move_unit(); if (mousekey_accel & (1<<0)) {
else if (code == KB_MS_LEFT) report.x = -move_unit(); unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed)/4;
else if (code == KB_MS_RIGHT) report.x = move_unit(); } else if (mousekey_accel & (1<<1)) {
else if (code == KB_MS_BTN1) report.buttons |= MOUSE_BTN1; unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed)/2;
else if (code == KB_MS_BTN2) report.buttons |= MOUSE_BTN2; } else if (mousekey_accel & (1<<2)) {
else if (code == KB_MS_BTN3) report.buttons |= MOUSE_BTN3; unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed);
else if (code == KB_MS_BTN4) report.buttons |= MOUSE_BTN4; } else if (mousekey_repeat == 0) {
else if (code == KB_MS_BTN5) report.buttons |= MOUSE_BTN5; unit = MOUSEKEY_WHEEL_DELTA;
else if (code == KB_MS_WH_UP) report.v += move_unit()/4; } else if (mousekey_repeat >= mk_time_to_max) {
else if (code == KB_MS_WH_DOWN) report.v -= move_unit()/4; unit = MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed;
else if (code == KB_MS_WH_LEFT) report.h -= move_unit()/4; } else {
else if (code == KB_MS_WH_RIGHT)report.h += move_unit()/4; unit = (MOUSEKEY_WHEEL_DELTA * mk_wheel_max_speed * mousekey_repeat) / mk_wheel_time_to_max;
}
return (unit > MOUSEKEY_WHEEL_MAX ? MOUSEKEY_WHEEL_MAX : (unit == 0 ? 1 : unit));
} }
bool mousekey_changed(void) void mousekey_task(void)
{ {
return (report.buttons != report_prev.buttons || if (timer_elapsed(last_timer) < (mousekey_repeat ? mk_interval : mk_delay*10))
report.x || report.y || report.v || report.h); return;
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 (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;
/* diagonal move [1/sqrt(2) = 0.7] */
if (mouse_report.x && mouse_report.y) {
mouse_report.x *= 0.7;
mouse_report.y *= 0.7;
}
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) 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)
{
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;
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;
} }
void mousekey_send(void) void mousekey_send(void)
{ {
static uint16_t last_timer = 0;
if (!mousekey_changed()) {
mousekey_repeat = 0;
mousekey_clear_report();
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 (mousekey_repeat != 0xFF) {
mousekey_repeat++;
}
if (report.x && report.y) {
report.x *= 0.7;
report.y *= 0.7;
}
mousekey_debug(); mousekey_debug();
host_mouse_send(&report); host_mouse_send(&mouse_report);
report_prev = report;
last_timer = timer_read(); last_timer = timer_read();
mousekey_clear_report();
} }
void mousekey_clear_report(void) void mousekey_clear(void)
{ {
report.buttons = 0; mouse_report = (report_mouse_t){};
report.x = 0; mousekey_repeat = 0;
report.y = 0; mousekey_accel = 0;
report.v = 0;
report.h = 0;
} }
static void mousekey_debug(void) static void mousekey_debug(void)
{ {
if (!debug_mouse) return; if (!debug_mouse) return;
print("mousekey [btn|x y v h]rep: ["); print("mousekey [btn|x y v h](rep/acl): [");
phex(report.buttons); print("|"); phex(mouse_report.buttons); print("|");
phex(report.x); print(" "); phex(mouse_report.x); print(" ");
phex(report.y); print(" "); phex(mouse_report.y); print(" ");
phex(report.v); print(" "); phex(mouse_report.v); print(" ");
phex(report.h); print("]"); phex(mouse_report.h); print("](");
phex(mousekey_repeat); phex(mousekey_repeat); print("/");
print("\n"); phex(mousekey_accel); print(")\n");
} }

46
common/mousekey.h
View File

@ -21,9 +21,49 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdbool.h> #include <stdbool.h>
#include "host.h" #include "host.h"
void mousekey_decode(uint8_t code);
bool mousekey_changed(void); /* 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);
void mousekey_clear(void);
void mousekey_send(void); void mousekey_send(void);
void mousekey_clear_report(void);
#endif #endif

8
common/print.c
View File

@ -75,6 +75,14 @@ void phex16(unsigned int i)
phex(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) void pbin(unsigned char c)
{ {

1
common/print.h
View File

@ -45,6 +45,7 @@ void print_S(const char *s);
void print_P(const char *s); void print_P(const char *s);
void phex(unsigned char c); void phex(unsigned char c);
void phex16(unsigned int i); void phex16(unsigned int i);
void pdec(uint8_t i);
void pbin(unsigned char c); void pbin(unsigned char c);
void pbin_reverse(unsigned char c); void pbin_reverse(unsigned char c);
#ifdef __cplusplus #ifdef __cplusplus

1
common/timer.c
View File

@ -22,6 +22,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// counter resolution 1ms // counter resolution 1ms
// NOTE: union { uint32_t timer32; struct { uint16_t dummy; uint16_t timer16; }}
volatile uint32_t timer_count = 0; volatile uint32_t timer_count = 0;
void timer_init(void) void timer_init(void)

424
common/usb_keycodes.h
View File

@ -1,424 +0,0 @@
/*
Copyright 2011 Jun Wako <wakojun@gmail.com>
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 <http://www.gnu.org/licenses/>.
*/
/*
* 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))
#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 MOD_BIT(code) (1<<((code) & 0x07))
#define FN_BIT(code) (1<<((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 */
enum special_keycodes {
/* System Control */
KB_SYSTEM_POWER = 0xB0,
KB_SYSTEM_SLEEP,
KB_SYSTEM_WAKE,
/* Consumer Page */
KB_AUDIO_MUTE,
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, /* 0xC0 */
KB_WWW_FORWARD,
KB_WWW_STOP,
KB_WWW_REFRESH,
KB_WWW_FAVORITES,
/* reserve 0xE0-E7 for Modifiers */
/* Layer Switching */
KB_FN0 = 0xE8,
KB_FN1,
KB_FN2,
KB_FN3,
KB_FN4,
KB_FN5,
KB_FN6,
KB_FN7,
/* 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,
};
enum keycodes {
KB_NO = 0,
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,
/* NOTE: 0xB0-DF are used as special_keycodes */
#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,
#endif
/* Modifiers */
KB_LCTRL = 0xE0,
KB_LSHIFT,
KB_LALT,
KB_LGUI,
KB_RCTRL,
KB_RSHIFT,
KB_RALT,
KB_RGUI,
/* NOTE: 0xE8-FF are used as special_keycodes */
};
#endif /* USB_KEYCODES_H */

16
common/util.c
View File

@ -17,19 +17,23 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "util.h" #include "util.h"
// bit population // bit population - return number of on-bit
int bitpop(uint8_t bits) uint8_t bitpop(uint8_t bits)
{ {
int c; uint8_t c;
for (c = 0; bits; c++) for (c = 0; bits; c++)
bits &= bits -1; bits &= bits -1;
return c; 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 // most significant on-bit - return highest location of on-bit
int biton(uint8_t bits) uint8_t biton(uint8_t bits)
{ {
int n = 0; uint8_t n = 0;
if (bits >> 4) { bits >>= 4; n += 4;} if (bits >> 4) { bits >>= 4; n += 4;}
if (bits >> 2) { bits >>= 2; n += 2;} if (bits >> 2) { bits >>= 2; n += 2;}
if (bits >> 1) { bits >>= 1; n += 1;} if (bits >> 1) { bits >>= 1; n += 1;}

4
common/util.h
View File

@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define XSTR(s) #s #define XSTR(s) #s
int bitpop(uint8_t bits); uint8_t bitpop(uint8_t bits);
int biton(uint8_t bits); uint8_t biton(uint8_t bits);
#endif #endif

2
converter/adb_usb/README.md
View File

@ -33,7 +33,7 @@ Keymap
------ ------
You can change a keymap by editing code of keymap.c like following. 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. 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 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 macway/keymap.c as examples. Keymap(layer) switching may needs a bit of
effort at this time. effort at this time.

1
converter/adb_usb/config.h
View File

@ -54,6 +54,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* key combination for command */
#include "adb.h" #include "adb.h"
#include "matrix.h"
#define IS_COMMAND() ( \ #define IS_COMMAND() ( \
matrix_is_on(MATRIX_ROW(ADB_POWER), MATRIX_COL(ADB_POWER)) \ matrix_is_on(MATRIX_ROW(ADB_POWER), MATRIX_COL(ADB_POWER)) \
) )

50
converter/adb_usb/keymap.c
View File

@ -22,7 +22,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdbool.h> #include <stdbool.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keyboard.h" #include "usb_keyboard.h"
#include "usb_keycodes.h" #include "keycode.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
@ -42,22 +42,22 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
K38,K06,K07,K08,K09,K0B,K2D,K2E,K2B,K2F,K2C, K7B, K3E, K53,K54,K55, \ 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 \ 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 }, \ { KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \
{ KB_##K08, KB_##K09, KB_NO, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \ { KC_##K08, KC_##K09, KC_NO, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \
{ KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
{ KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \ { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \
{ KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \ { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \
{ KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \ { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \
{ KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_NO, KB_##K35, KB_##K36, KB_##K37 }, \ { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_NO, KC_##K35, KC_##K36, KC_##K37 }, \
{ KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_NO }, \ { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_NO }, \
{ KB_NO, KB_##K41, KB_NO, KB_##K43, KB_NO, KB_##K45, KB_NO, KB_##K47 }, \ { KC_NO, KC_##K41, KC_NO, KC_##K43, KC_NO, KC_##K45, KC_NO, KC_##K47 }, \
{ KB_NO, KB_NO, KB_NO, KB_##K4B, KB_##K4C, KB_NO, KB_##K4E, KB_NO }, \ { KC_NO, KC_NO, KC_NO, KC_##K4B, KC_##K4C, KC_NO, KC_##K4E, KC_NO }, \
{ KB_NO, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ { KC_NO, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
{ KB_##K58, KB_##K59, KB_NO, KB_##K5B, KB_##K5C, KB_NO, KB_NO, KB_NO }, \ { KC_##K58, KC_##K59, KC_NO, KC_##K5B, KC_##K5C, KC_NO, KC_NO, KC_NO }, \
{ KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_NO, KB_##K67 }, \ { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_NO, KC_##K67 }, \
{ KB_NO, KB_##K69, KB_NO, KB_##K6B, KB_NO, KB_##K6D, KB_NO, KB_##K6F }, \ { KC_NO, KC_##K69, KC_NO, KC_##K6B, KC_NO, KC_##K6D, KC_NO, KC_##K6F }, \
{ KB_NO, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ { KC_NO, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \
{ KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_NO, KB_NO, KB_NO, KB_##K7F } \ { 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. // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
// See layer.c for details. // See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = { static const uint8_t PROGMEM fn_keycode[] = {
KB_NO, // Fn0 KC_NO, // Fn0
KB_NO, // Fn1 KC_NO, // Fn1
KB_NO, // Fn2 KC_NO, // Fn2
KB_NO, // Fn3 KC_NO, // Fn3
KB_NO, // Fn4 KC_NO, // Fn4
KB_NO, // Fn5 KC_NO, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
}; };
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

2
converter/m0110_usb/config.h
View File

@ -38,7 +38,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* key combination for command */
#define IS_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)) \
) )

62
converter/m0110_usb/keymap.c
View File

@ -20,7 +20,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdbool.h> #include <stdbool.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keyboard.h" #include "usb_keyboard.h"
#include "usb_keycodes.h" #include "keycode.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
@ -36,20 +36,20 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
K38,K06,K07,K08,K09,K0B,K2D,K2E,K2B,K2F,K2C, K4D, K53,K54,K55,K4C, \ 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 \ 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 }, \ { KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \
{ KB_##K08, KB_##K09, KB_NO, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \ { KC_##K08, KC_##K09, KC_NO, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \
{ KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
{ KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \ { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \
{ KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \ { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \
{ KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \ { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \
{ KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_NO, KB_NO, KB_##K37 }, \ { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_NO, KC_NO, KC_##K37 }, \
{ KB_##K38, KB_##K39, KB_##K3A, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ { KC_##K38, KC_##K39, KC_##K3A, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KB_NO, KB_##K41, KB_##K42, KB_NO, KB_NO, KB_NO, KB_##K46, KB_##K47 }, \ { KC_NO, KC_##K41, KC_##K42, KC_NO, KC_NO, KC_NO, KC_##K46, KC_##K47 }, \
{ KB_##K48, KB_NO, KB_NO, KB_NO, KB_##K4C, KB_##K4D, KB_##K4E, KB_NO }, \ { KC_##K48, KC_NO, KC_NO, KC_NO, KC_##K4C, KC_##K4D, KC_##K4E, KC_NO }, \
{ KB_NO, KB_NO, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ { KC_NO, KC_NO, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
{ KB_##K58, KB_##K59, KB_NO, KB_##K5B, KB_##K5C, KB_NO, KB_NO, KB_NO }, \ { KC_##K58, KC_##K59, KC_NO, KC_##K5B, KC_##K5C, KC_NO, KC_NO, KC_NO }, \
{ KB_NO, KB_NO, KB_##K62, KB_NO, KB_NO, KB_NO, KB_##K66, KB_NO }, \ { KC_NO, KC_NO, KC_##K62, KC_NO, KC_NO, KC_NO, KC_##K66, KC_NO }, \
{ KB_##K68, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K6D, KB_NO, KB_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. // See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = { static const uint8_t PROGMEM fn_keycode[] = {
#ifndef HASU #ifndef HASU
KB_NO, // Fn0 KC_NO, // Fn0
KB_NO, // Fn1 KC_NO, // Fn1
KB_NO, // Fn2 KC_NO, // Fn2
KB_NO, // Fn3 KC_NO, // Fn3
KB_NO, // Fn4 KC_NO, // Fn4
KB_NO, // Fn5 KC_NO, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
#else #else
KB_ENTER, // Fn0 KC_ENTER, // Fn0
KB_SCOLON, // Fn1 KC_SCOLON, // Fn1
KB_SLASH, // Fn2 KC_SLASH, // Fn2
KB_UP, // Fn3 KC_UP, // Fn3
KB_NO, // Fn4 KC_NO, // Fn4
KB_NO, // Fn5 KC_NO, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
#endif #endif
}; };

4
converter/news_usb/config_pjrc.h
View File

@ -35,8 +35,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* key combination for command */
#define IS_COMMAND() ( \ #define IS_COMMAND() ( \
keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) || \ keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) || \
keyboard_report->mods == (MOD_BIT(KB_LCTRL) | MOD_BIT(KB_RSHIFT)) \ keyboard_report->mods == (MOD_BIT(KC_LCTRL) | MOD_BIT(KC_RSHIFT)) \
) )

50
converter/news_usb/keymap.c
View File

@ -18,7 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "util.h" #include "util.h"
#include "keymap.h" #include "keymap.h"
@ -36,22 +36,22 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
K36,K37,K38,K39,K3A,K3B,K3C,K3D,K3E,K3F,K40,K41, K42, K6D, K57,K59,K58, \ 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 \ 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 }, \ { KC_NO, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \
{ KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \ { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \
{ KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
{ KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \ { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \
{ KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \ { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \
{ KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \ { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \
{ KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \ { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
{ KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, \ { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \
{ KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \ { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \
{ KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, \ { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_##K4F }, \
{ KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
{ KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_NO, KB_NO }, \ { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_NO, KC_NO }, \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_##K64, KB_##K65, KB_##K66, KB_NO }, \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_##K64, KC_##K65, KC_##K66, KC_NO }, \
{ KB_##K68, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_##K6D, KB_##K6E, KB_NO }, \ { KC_##K68, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_##K6D, KC_##K6E, KC_NO }, \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, }, \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, }, \
{ KB_NO, KB_NO, KB_##K7A, KB_NO, KB_NO, KB_NO, KB_NO, KB_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. // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
// See layer.c for details. // See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = { static const uint8_t PROGMEM fn_keycode[] = {
KB_NO, // Fn0 KC_NO, // Fn0
KB_NO, // Fn1 KC_NO, // Fn1
KB_NO, // Fn2 KC_NO, // Fn2
KB_NO, // Fn3 KC_NO, // Fn3
KB_NO, // Fn4 KC_NO, // Fn4
KB_NO, // Fn5 KC_NO, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
}; };

4
converter/ps2_usb/config.h
View File

@ -36,8 +36,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* key combination for command */
#define IS_COMMAND() ( \ #define IS_COMMAND() ( \
keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) || \ keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) || \
keyboard_report->mods == (MOD_BIT(KB_LCTRL) | MOD_BIT(KB_RSHIFT)) \ keyboard_report->mods == (MOD_BIT(KC_LCTRL) | MOD_BIT(KC_RSHIFT)) \
) )

84
converter/ps2_usb/keymap.c
View File

@ -21,7 +21,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
@ -51,38 +51,38 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
K90, KBA, KB8, KB0, /* WWW Search, Home, Back, Forward */ \ K90, KBA, KB8, KB0, /* WWW Search, Home, Back, Forward */ \
KA8, KA0, K98 /* WWW Stop, Refresh, Favorites */ \ KA8, KA0, K98 /* WWW Stop, Refresh, Favorites */ \
) { \ ) { \
{ KB_NO, KB_##K01, KB_NO, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \ { KC_NO, KC_##K01, KC_NO, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \
{ KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_NO }, \ { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_NO }, \
{ KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_NO }, \ { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_NO }, \
{ KB_##K18, KB_NO, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_NO }, \ { KC_##K18, KC_NO, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_NO }, \
{ KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \ { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \
{ KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_NO }, \ { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_NO }, \
{ KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_NO }, \ { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_NO }, \
{ KB_##K38, KB_NO, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_NO }, \ { KC_##K38, KC_NO, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_NO }, \
{ KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \ { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \
{ KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_NO }, \ { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_NO }, \
{ KB_##K50, KB_##K51, KB_##K52, KB_NO, KB_##K54, KB_##K55, KB_NO, KB_##K57 }, \ { KC_##K50, KC_##K51, KC_##K52, KC_NO, KC_##K54, KC_##K55, KC_NO, KC_##K57 }, \
{ KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_NO, KB_##K5D, KB_NO, KB_##K5F }, \ { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_NO, KC_##K5D, KC_NO, KC_##K5F }, \
{ KB_NO, KB_##K61, KB_NO, KB_NO, KB_##K64, KB_NO, KB_##K66, KB_##K67 }, \ { KC_NO, KC_##K61, KC_NO, KC_NO, KC_##K64, KC_NO, KC_##K66, KC_##K67 }, \
{ KB_NO, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_NO, KB_NO, KB_NO }, \ { KC_NO, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_NO, KC_NO, KC_NO }, \
{ KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \
{ KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \ { KC_##K78, KC_##K79, KC_##K7A, KC_##K7B, KC_##K7C, KC_##K7D, KC_##K7E, KC_NO }, \
{ KB_NO, KB_NO, KB_NO, KB_##K83, KB_NO, KB_NO, KB_NO, KB_NO }, \ { KC_NO, KC_NO, KC_NO, KC_##K83, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KB_##K90, KB_##K91, KB_NO, KB_NO, KB_##K94, KB_##K95, KB_NO, KB_NO }, \ { KC_##K90, KC_##K91, KC_NO, KC_NO, KC_##K94, KC_##K95, KC_NO, KC_NO }, \
{ KB_##K98, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K9F }, \ { KC_##K98, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K9F }, \
{ KB_##KA0, KB_##KA1, KB_NO, KB_##KA3, KB_NO, KB_NO, KB_NO, KB_##KA7 }, \ { KC_##KA0, KC_##KA1, KC_NO, KC_##KA3, KC_NO, KC_NO, KC_NO, KC_##KA7 }, \
{ KB_##KA8, KB_NO, KB_NO, KB_##KAB, KB_NO, KB_NO, KB_NO, KB_##KAF }, \ { KC_##KA8, KC_NO, KC_NO, KC_##KAB, KC_NO, KC_NO, KC_NO, KC_##KAF }, \
{ KB_##KB0, KB_NO, KB_##KB2, KB_NO, KB_##KB4, KB_NO, KB_NO, KB_##KB7 }, \ { KC_##KB0, KC_NO, KC_##KB2, KC_NO, KC_##KB4, KC_NO, KC_NO, KC_##KB7 }, \
{ KB_##KB8, KB_NO, KB_##KBA, KB_##KBB, KB_NO, KB_NO, KB_NO, KB_##KBF }, \ { KC_##KB8, KC_NO, KC_##KBA, KC_##KBB, KC_NO, KC_NO, KC_NO, KC_##KBF }, \
{ KB_##KC0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ { KC_##KC0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KB_##KC8, KB_NO, KB_##KCA, KB_NO, KB_NO, KB_##KCD, KB_NO, KB_NO }, \ { KC_##KC8, KC_NO, KC_##KCA, KC_NO, KC_NO, KC_##KCD, KC_NO, KC_NO }, \
{ KB_##KD0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ { KC_##KD0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KB_NO, KB_NO, KB_##KDA, KB_NO, KB_NO, KB_NO, KB_##KDE, KB_NO }, \ { KC_NO, KC_NO, KC_##KDA, KC_NO, KC_NO, KC_NO, KC_##KDE, KC_NO }, \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KB_NO, KB_##KE9, KB_NO, KB_##KEB, KB_##KEC, KB_NO, KB_NO, KB_NO }, \ { KC_NO, KC_##KE9, KC_NO, KC_##KEB, KC_##KEC, KC_NO, KC_NO, KC_NO }, \
{ KB_##KF0, KB_##KF1, KB_##KF2, KB_NO, KB_##KF4, KB_##KF5, KB_NO, KB_NO }, \ { KC_##KF0, KC_##KF1, KC_##KF2, KC_NO, KC_##KF4, KC_##KF5, KC_NO, KC_NO }, \
{ KB_NO, KB_NO, KB_##KFA, KB_NO, KB_##KFC, KB_##KFD, KB_##KFE, KB_NO }, \ { KC_NO, KC_NO, KC_##KFA, KC_NO, KC_##KFC, KC_##KFD, KC_##KFE, KC_NO }, \
} }
/* US layout */ /* 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. // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
// See layer.c for details. // See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = { static const uint8_t PROGMEM fn_keycode[] = {
KB_SCLN, // Fn0 KC_SCLN, // Fn0
KB_SLSH, // Fn1 KC_SLSH, // Fn1
KB_NO, // Fn2 KC_NO, // Fn2
KB_NO, // Fn3 KC_NO, // Fn3
KB_NO, // Fn4 KC_NO, // Fn4
KB_NO, // Fn5 KC_NO, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
}; };
// The keymap is a 32*8 byte array which convert a PS/2 scan code into a USB keycode. // 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. // 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] = { static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* 0: default /* 0: default

84
converter/ps2_usb/keymap_jis.c
View File

@ -21,7 +21,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
@ -51,38 +51,38 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
K90, KBA, KB8, KB0, /* WWW Search, Home, Back, Forward */ \ K90, KBA, KB8, KB0, /* WWW Search, Home, Back, Forward */ \
KA8, KA0, K98 /* WWW Stop, Refresh, Favorites */ \ KA8, KA0, K98 /* WWW Stop, Refresh, Favorites */ \
) { \ ) { \
{ KB_NO, KB_##K01, KB_NO, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \ { KC_NO, KC_##K01, KC_NO, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \
{ KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_NO }, \ { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_NO }, \
{ KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_NO }, \ { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_NO }, \
{ KB_##K18, KB_NO, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_NO }, \ { KC_##K18, KC_NO, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_NO }, \
{ KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \ { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \
{ KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_NO }, \ { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_NO }, \
{ KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_NO }, \ { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_NO }, \
{ KB_##K38, KB_NO, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_NO }, \ { KC_##K38, KC_NO, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_NO }, \
{ KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \ { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \
{ KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_NO }, \ { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_NO }, \
{ KB_##K50, KB_##K51, KB_##K52, KB_NO, KB_##K54, KB_##K55, KB_NO, KB_##K57 }, \ { KC_##K50, KC_##K51, KC_##K52, KC_NO, KC_##K54, KC_##K55, KC_NO, KC_##K57 }, \
{ KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_NO, KB_##K5D, KB_NO, KB_##K5F }, \ { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_NO, KC_##K5D, KC_NO, KC_##K5F }, \
{ KB_NO, KB_##K61, KB_NO, KB_NO, KB_##K64, KB_NO, KB_##K66, KB_##K67 }, \ { KC_NO, KC_##K61, KC_NO, KC_NO, KC_##K64, KC_NO, KC_##K66, KC_##K67 }, \
{ KB_NO, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_NO, KB_NO, KB_NO }, \ { KC_NO, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_NO, KC_NO, KC_NO }, \
{ KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \
{ KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \ { KC_##K78, KC_##K79, KC_##K7A, KC_##K7B, KC_##K7C, KC_##K7D, KC_##K7E, KC_NO }, \
{ KB_NO, KB_NO, KB_NO, KB_##K83, KB_NO, KB_NO, KB_NO, KB_NO }, \ { KC_NO, KC_NO, KC_NO, KC_##K83, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KB_##K90, KB_##K91, KB_NO, KB_NO, KB_##K94, KB_##K95, KB_NO, KB_NO }, \ { KC_##K90, KC_##K91, KC_NO, KC_NO, KC_##K94, KC_##K95, KC_NO, KC_NO }, \
{ KB_##K98, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K9F }, \ { KC_##K98, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K9F }, \
{ KB_##KA0, KB_##KA1, KB_NO, KB_##KA3, KB_NO, KB_NO, KB_NO, KB_##KA7 }, \ { KC_##KA0, KC_##KA1, KC_NO, KC_##KA3, KC_NO, KC_NO, KC_NO, KC_##KA7 }, \
{ KB_##KA8, KB_NO, KB_NO, KB_##KAB, KB_NO, KB_NO, KB_NO, KB_##KAF }, \ { KC_##KA8, KC_NO, KC_NO, KC_##KAB, KC_NO, KC_NO, KC_NO, KC_##KAF }, \
{ KB_##KB0, KB_NO, KB_##KB2, KB_NO, KB_##KB4, KB_NO, KB_NO, KB_##KB7 }, \ { KC_##KB0, KC_NO, KC_##KB2, KC_NO, KC_##KB4, KC_NO, KC_NO, KC_##KB7 }, \
{ KB_##KB8, KB_NO, KB_##KBA, KB_##KBB, KB_NO, KB_NO, KB_NO, KB_##KBF }, \ { KC_##KB8, KC_NO, KC_##KBA, KC_##KBB, KC_NO, KC_NO, KC_NO, KC_##KBF }, \
{ KB_##KC0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ { KC_##KC0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KB_##KC8, KB_NO, KB_##KCA, KB_NO, KB_NO, KB_##KCD, KB_NO, KB_NO }, \ { KC_##KC8, KC_NO, KC_##KCA, KC_NO, KC_NO, KC_##KCD, KC_NO, KC_NO }, \
{ KB_##KD0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ { KC_##KD0, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KB_NO, KB_NO, KB_##KDA, KB_NO, KB_NO, KB_NO, KB_##KDE, KB_NO }, \ { KC_NO, KC_NO, KC_##KDA, KC_NO, KC_NO, KC_NO, KC_##KDE, KC_NO }, \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, \
{ KB_NO, KB_##KE9, KB_NO, KB_##KEB, KB_##KEC, KB_NO, KB_NO, KB_NO }, \ { KC_NO, KC_##KE9, KC_NO, KC_##KEB, KC_##KEC, KC_NO, KC_NO, KC_NO }, \
{ KB_##KF0, KB_##KF1, KB_##KF2, KB_NO, KB_##KF4, KB_##KF5, KB_NO, KB_NO }, \ { KC_##KF0, KC_##KF1, KC_##KF2, KC_NO, KC_##KF4, KC_##KF5, KC_NO, KC_NO }, \
{ KB_NO, KB_NO, KB_##KFA, KB_NO, KB_##KFC, KB_##KFD, KB_##KFE, KB_NO }, \ { KC_NO, KC_NO, KC_##KFA, KC_NO, KC_##KFC, KC_##KFD, KC_##KFE, KC_NO }, \
} }
/* JIS layout */ /* 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. // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
// See layer.c for details. // See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = { static const uint8_t PROGMEM fn_keycode[] = {
KB_SCLN, // Fn0 KC_SCLN, // Fn0
KB_SLSH, // Fn1 KC_SLSH, // Fn1
KB_BSPC, // Fn2 KC_BSPC, // Fn2
KB_NO, // Fn3 KC_NO, // Fn3
KB_NO, // Fn4 KC_NO, // Fn4
KB_SPC, // Fn5 KC_SPC, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
}; };
// The keymap is a 32*8 byte array which convert a PS/2 scan code into a USB keycode. // 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. // 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] = { static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* 0: JIS LAYOUT /* 0: JIS LAYOUT

2
converter/terminal_usb/config_102_pjrc.h
View File

@ -35,7 +35,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* key combination for command */
#define IS_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)) \
) )

2
converter/terminal_usb/config_122_pjrc.h
View File

@ -35,7 +35,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* key combination for command */
#define IS_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)) \
) )

52
converter/terminal_usb/keymap_102.c
View File

@ -18,7 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
@ -50,23 +50,23 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
K12,K13,K1A,K22,K21,K2A,K32,K31,K3A,K41,K49,K4A, K51,K59, K63, K69,K72,K7A,K79, \ 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 \ 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 }, \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K07 }, \
{ KB_##K08, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K0D, KB_##K0E, KB_##K0F }, \ { KC_##K08, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K0D, KC_##K0E, KC_##K0F }, \
{ KB_NO, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ { KC_NO, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
{ KB_NO, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \ { KC_NO, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \
{ KB_NO, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \ { KC_NO, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \
{ KB_NO, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \ { KC_NO, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \
{ KB_NO, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \ { KC_NO, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
{ KB_NO, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, \ { KC_NO, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \
{ KB_NO, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \ { KC_NO, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \
{ KB_NO, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, \ { KC_NO, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_##K4F }, \
{ KB_NO, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ { KC_NO, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
{ KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_##K5E, KB_##K5F }, \ { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_##K5E, KC_##K5F }, \
{ KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_##K66, KB_##K67 }, \ { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \
{ KB_##K68, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_##K6D, KB_##K6E, KB_##K6F }, \ { KC_##K68, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_##K6D, KC_##K6E, KC_##K6F }, \
{ KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \
{ KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \ { KC_##K78, KC_##K79, KC_##K7A, KC_##K7B, KC_##K7C, KC_##K7D, KC_##K7E, KC_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_##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. // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
// See layer.c for details. // See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = { static const uint8_t PROGMEM fn_keycode[] = {
KB_SCLN, // Fn0 KC_SCLN, // Fn0
KB_SLSH, // Fn1 KC_SLSH, // Fn1
KB_ESC, // Fn2 KC_ESC, // Fn2
KB_NO, // Fn3 KC_NO, // Fn3
KB_NO, // Fn4 KC_NO, // Fn4
KB_NO, // Fn5 KC_NO, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
}; };

52
converter/terminal_usb/keymap_122.c
View File

@ -18,7 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
@ -51,23 +51,23 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
K83,K0A, K12,K13,K1A,K22,K21,K2A,K32,K31,K3A,K41,K49,K4A, K51,K59, K61,K62,K6A, K69,K72,K7A,K79, \ 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 \ 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 }, \ { KC_NO, KC_##K01, KC_NO, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \
{ KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \ { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \
{ KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
{ KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \ { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \
{ KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \ { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \
{ KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \ { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \
{ KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \ { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
{ KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, \ { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \
{ KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \ { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \
{ KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, \ { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_##K4F }, \
{ KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
{ KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_##K5E, KB_##K5F }, \ { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_##K5E, KC_##K5F }, \
{ KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_##K66, KB_##K67 }, \ { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \
{ KB_##K68, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_##K6D, KB_##K6E, KB_##K6F }, \ { KC_##K68, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_##K6D, KC_##K6E, KC_##K6F }, \
{ KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \
{ KB_##K78, KB_##K79, KB_##K7A, KB_##K7B, KB_##K7C, KB_##K7D, KB_##K7E, KB_NO }, \ { KC_##K78, KC_##K79, KC_##K7A, KC_##K7B, KC_##K7C, KC_##K7D, KC_##K7E, KC_NO }, \
{ KB_NO, KB_NO, KB_NO, KB_##K83, KB_##K84, KB_NO, KB_NO, KB_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. // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
// See layer.c for details. // See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = { static const uint8_t PROGMEM fn_keycode[] = {
KB_NO, // Fn0 KC_NO, // Fn0
KB_NO, // Fn1 KC_NO, // Fn1
KB_NO, // Fn2 KC_NO, // Fn2
KB_NO, // Fn3 KC_NO, // Fn3
KB_NO, // Fn4 KC_NO, // Fn4
KB_NO, // Fn5 KC_NO, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
}; };

2
converter/usb_usb/config.h
View File

@ -35,6 +35,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* 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 #endif

68
converter/usb_usb/keymap.c
View File

@ -16,7 +16,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "util.h" #include "util.h"
#include "keymap.h" #include "keymap.h"
@ -29,38 +29,38 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
KE1,K1D,K1B,K06,K19,K05,K11,K10,K36,K37,K38, KE5, K52, K59,K5A,K5B, \ 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 \ 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 */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, /* 00-07 */ \
{ KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, /* 08-0F */ \ { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, /* 08-0F */ \
{ KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, /* 10-17 */ \ { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, /* 10-17 */ \
{ KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, /* 18-1F */ \ { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, /* 18-1F */ \
{ KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, /* 20-27 */ \ { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, /* 20-27 */ \
{ KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, /* 28-2F */ \ { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, /* 28-2F */ \
{ KB_##K30, KB_##K31, KB_NO, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, /* 30-37 */ \ { KC_##K30, KC_##K31, KC_NO, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, /* 30-37 */ \
{ KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, /* 38-3F */ \ { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, /* 38-3F */ \
{ KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, /* 40-47 */ \ { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, /* 40-47 */ \
{ KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, /* 48-4F */ \ { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_##K4F }, /* 48-4F */ \
{ KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, /* 50-57 */ \ { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, /* 50-57 */ \
{ KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_##K5E, KB_##K5F }, /* 58-5F */ \ { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_##K5E, KC_##K5F }, /* 58-5F */ \
{ KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_NO, KB_##K65, KB_NO, KB_NO }, /* 60-67 */ \ { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_NO, KC_##K65, KC_NO, KC_NO }, /* 60-67 */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 68-6F */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 68-6F */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 70-77 */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 70-77 */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 78-7F */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 78-7F */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 80-87 */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 80-87 */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 88-8F */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 88-8F */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 90-97 */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 90-97 */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* 98-9F */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* 98-9F */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* A0-A7 */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* A0-A7 */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* A8-AF */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* A8-AF */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* B0-B7 */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* B0-B7 */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* B8-BF */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* B8-BF */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* C0-C7 */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* C0-C7 */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* C8-CF */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* C8-CF */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* D0-D7 */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* D0-D7 */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* D8-DF */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* D8-DF */ \
{ KB_##KE0, KB_##KE1, KB_##KE2, KB_##KE3, KB_##KE4, KB_##KE5, KB_##KE6, KB_##KE7 }, /* E0-E7 */ \ { KC_##KE0, KC_##KE1, KC_##KE2, KC_##KE3, KC_##KE4, KC_##KE5, KC_##KE6, KC_##KE7 }, /* E0-E7 */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* E8-EF */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO }, /* E8-EF */ \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO }, /* F0-F7 */ \ { KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_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_NO, KC_NO, KC_NO, KC_NO }, /* F8-FF */ \
} }
@ -68,7 +68,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
static const uint8_t PROGMEM fn_layer[] = { 5, 6, 5, 0, 0, 0, 0, 0 }; static const uint8_t PROGMEM fn_layer[] = { 5, 6, 5, 0, 0, 0, 0, 0 };
// Codes to register by clicking Fn key(0-7) // 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] = { static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* 0: default /* 0: default

2
converter/usb_usb/main.cpp
View File

@ -88,7 +88,7 @@ uint16_t timer;
DDRF = (1<<7); DDRF = (1<<7);
for (;;) { for (;;) {
PORTF ^= (1<<7); PORTF ^= (1<<7);
keyboard_proc(); keyboard_task();
timer = timer_read(); timer = timer_read();
usb_host.Task(); usb_host.Task();

2
converter/usb_usb/matrix.c
View File

@ -18,7 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include "usb_hid.h" #include "usb_hid.h"
#include "usb_keycodes.h" #include "keycode.h"
#include "util.h" #include "util.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"

4
converter/x68k_usb/config_pjrc.h
View File

@ -35,8 +35,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* key combination for command */
#define IS_COMMAND() ( \ #define IS_COMMAND() ( \
keyboard_report->mods == (MOD_BIT(KB_LALT) | MOD_BIT(KB_RALT)) || \ keyboard_report->mods == (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT)) || \
keyboard_report->mods == (MOD_BIT(KB_LCTRL) | MOD_BIT(KB_RSHIFT)) \ keyboard_report->mods == (MOD_BIT(KC_LCTRL) | MOD_BIT(KC_RSHIFT)) \
) )

50
converter/x68k_usb/keymap.c
View File

@ -18,7 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "util.h" #include "util.h"
#include "keymap.h" #include "keymap.h"
@ -51,22 +51,22 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
K70,K2A,K2B,K2C,K2D,K2E,K2F,K30,K31,K32,K33,K34, K3B,K3E,K3D, K4B,K4C,K4D,K4E, \ 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 \ 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 }, \ { KC_NO, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \
{ KB_##K08, KB_##K09, KB_##K0A, KB_##K0B, KB_##K0C, KB_##K0D, KB_##K0E, KB_##K0F }, \ { KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D, KC_##K0E, KC_##K0F }, \
{ KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
{ KB_##K18, KB_##K19, KB_##K1A, KB_##K1B, KB_##K1C, KB_##K1D, KB_##K1E, KB_##K1F }, \ { KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D, KC_##K1E, KC_##K1F }, \
{ KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_##K27 }, \ { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27 }, \
{ KB_##K28, KB_##K29, KB_##K2A, KB_##K2B, KB_##K2C, KB_##K2D, KB_##K2E, KB_##K2F }, \ { KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D, KC_##K2E, KC_##K2F }, \
{ KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \ { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
{ KB_##K38, KB_##K39, KB_##K3A, KB_##K3B, KB_##K3C, KB_##K3D, KB_##K3E, KB_##K3F }, \ { KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D, KC_##K3E, KC_##K3F }, \
{ KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \ { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \
{ KB_##K48, KB_##K49, KB_##K4A, KB_##K4B, KB_##K4C, KB_##K4D, KB_##K4E, KB_##K4F }, \ { KC_##K48, KC_##K49, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D, KC_##K4E, KC_##K4F }, \
{ KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
{ KB_##K58, KB_##K59, KB_##K5A, KB_##K5B, KB_##K5C, KB_##K5D, KB_##K5E, KB_##K5F }, \ { KC_##K58, KC_##K59, KC_##K5A, KC_##K5B, KC_##K5C, KC_##K5D, KC_##K5E, KC_##K5F }, \
{ KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_##K66, KB_##K67 }, \ { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \
{ KB_##K68, KB_##K69, KB_##K6A, KB_##K6B, KB_##K6C, KB_NO, KB_NO, KB_NO }, \ { KC_##K68, KC_##K69, KC_##K6A, KC_##K6B, KC_##K6C, KC_NO, KC_NO, KC_NO }, \
{ KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_NO, KB_NO, KB_NO, KB_NO, }, \ { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_NO, KC_NO, KC_NO, KC_NO, }, \
{ KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_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. // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
// See layer.c for details. // See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = { static const uint8_t PROGMEM fn_keycode[] = {
KB_NO, // Fn0 KC_NO, // Fn0
KB_NO, // Fn1 KC_NO, // Fn1
KB_NO, // Fn2 KC_NO, // Fn2
KB_NO, // Fn3 KC_NO, // Fn3
KB_NO, // Fn4 KC_NO, // Fn4
KB_NO, // Fn5 KC_NO, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
}; };

2
keyboard/IIgs_Standard/README
View File

@ -39,7 +39,7 @@ To Do
0. When DEBOUNCE defined, there is a errors. 0. When DEBOUNCE defined, there is a errors.
1. Layer Change by toggling Clear Key 1. Layer Change by toggling Clear Key
2. Eject Key add. (following files should be modified.) 2. Eject Key add. (following files should be modified.)
common/usb_keycodes.h common/keycode.h
common/keyboard.c common/keyboard.c
3. Use bluetooth 3. Use bluetooth
EOF EOF

4
keyboard/IIgs_Standard/config.h
View File

@ -49,8 +49,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* key combination for command */
#define IS_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(KC_LSHIFT) | MOD_BIT(KC_LCTRL) | MOD_BIT(KC_LALT) | MOD_BIT(KC_LGUI)) || \
keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) \ keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
) )

46
keyboard/IIgs_Standard/keymap.c
View File

@ -21,7 +21,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
@ -45,9 +45,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
{ R5C0, R5C1, R5C2, R5C3, R5C4, R5C5, R5C6, R5C7 }, \ { R5C0, R5C1, R5C2, R5C3, R5C4, R5C5, R5C6, R5C7 }, \
{ R6C0, R6C1, R6C2, R6C3, R6C4, R6C5, R6C6, R6C7 }, \ { R6C0, R6C1, R6C2, R6C3, R6C4, R6C5, R6C6, R6C7 }, \
{ R7C0, R7C1, R7C2, R7C3, R7C4, R7C5, R7C6, R7C7 }, \ { 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 }, \ { 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)])) #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. // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
// See layer.c for details. // See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = { static const uint8_t PROGMEM fn_keycode[] = {
KB_NO, // Fn0 KC_NO, // Fn0
KB_NO, // Fn1 KC_NO, // Fn1
KB_SLSH, // Fn2 KC_SLSH, // Fn2
KB_SCLN, // Fn3 KC_SCLN, // Fn3
KB_SPC, // Fn4 KC_SPC, // Fn4
KB_NO, // Fn5 KC_NO, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
}; };
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { 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 | * |CAPS|Alt |Gui |` |SPC |BSLS |LFT|RGT|DN|UP| | 0 | . | T |
* `-----------------------------------------------------------' |---------------' * `-----------------------------------------------------------' |---------------'
*/ */
KEYMAP( KB_PWR, KEYMAP( KC_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, \ 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, \
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, \ 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, \
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, \ 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, \
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, \ 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, \
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), 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 /* 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 | * |CAPS|Alt |Gui |` |SPC |BSLS |LFT|RGT|DN|UP| | 0 | . | T |
* `-----------------------------------------------------------' `---------------' * `-----------------------------------------------------------' `---------------'
*/ */
KEYMAP( KB_PWR, \ KEYMAP( KC_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, \ 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, \
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, \ 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, \
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, \ 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, \
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, \ 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, \
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), 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),
}; };

4
keyboard/hbkb/config.h
View File

@ -42,8 +42,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* key combination for command */
#define IS_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(KC_LSHIFT) | MOD_BIT(KC_LCTRL) | MOD_BIT(KC_LALT) | MOD_BIT(KC_LGUI)) || \
keyboard_report->mods == (MOD_BIT(KB_LALT) | MOD_BIT(KB_RALT)) \ keyboard_report->mods == (MOD_BIT(KC_LALT) | MOD_BIT(KC_RALT)) \
) )

42
keyboard/hbkb/keymap.c
View File

@ -21,7 +21,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
@ -68,18 +68,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
K11, K26, K36, K46, K56, K57, K77, K76, K86, K96, KA7, K16, \ K11, K26, K36, K46, K56, K57, K77, K76, K86, K96, KA7, K16, \
K02, KB0, K67, KB7, K06 \ K02, KB0, K67, KB7, K06 \
) { \ ) { \
{ KB_NO, KB_NO, KB_##K02, KB_NO, KB_NO, KB_NO, KB_##K06, KB_NO }, \ { KC_NO, KC_NO, KC_##K02, KC_NO, KC_NO, KC_NO, KC_##K06, KC_NO }, \
{ KB_NO, KB_##K11, KB_NO, KB_NO, KB_NO, KB_NO, KB_##K16, KB_NO }, \ { KC_NO, KC_##K11, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K16, KC_NO }, \
{ KB_NO, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \ { KC_NO, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \
{ KB_NO, KB_##K31, KB_NO, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_NO }, \ { KC_NO, KC_##K31, KC_NO, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_NO }, \
{ KB_NO, KB_NO, KB_NO, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \ { KC_NO, KC_NO, KC_NO, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \
{ KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
{ KB_NO, KB_##K61, KB_NO, KB_NO, KB_##K64, KB_##K65, KB_##K66, KB_##K67 }, \ { KC_NO, KC_##K61, KC_NO, KC_NO, KC_##K64, KC_##K65, KC_##K66, KC_##K67 }, \
{ KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_##K77 }, \ { KC_##K70, KC_##K71, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_##K77 }, \
{ KB_NO, KB_##K81, KB_##K82, KB_##K83, KB_##K84, KB_##K85, KB_##K86, KB_NO }, \ { KC_NO, KC_##K81, KC_##K82, KC_##K83, KC_##K84, KC_##K85, KC_##K86, KC_NO }, \
{ KB_NO, KB_NO, KB_NO, KB_##K93, KB_##K94, KB_##K95, KB_##K96, KB_NO }, \ { KC_NO, KC_NO, KC_NO, KC_##K93, KC_##K94, KC_##K95, KC_##K96, KC_NO }, \
{ KB_##KA0, KB_##KA1, KB_##KA2, KB_##KA3, KB_##KA4, KB_##KA5, KB_NO, KB_##KA7 }, \ { KC_##KA0, KC_##KA1, KC_##KA2, KC_##KA3, KC_##KA4, KC_##KA5, KC_NO, KC_##KA7 }, \
{ KB_##KB0, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_NO, KB_##KB7 }, \ { 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)])) #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. // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
// See layer.c for details. // See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = { static const uint8_t PROGMEM fn_keycode[] = {
KB_NO, // Fn0 KC_NO, // Fn0
KB_NO, // Fn1 KC_NO, // Fn1
KB_SLSH, // Fn2 KC_SLSH, // Fn2
KB_SCLN, // Fn3 KC_SCLN, // Fn3
KB_SPC, // Fn4 KC_SPC, // Fn4
KB_NO, // Fn5 KC_NO, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
}; };
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

11
keyboard/hhkb/Makefile.iwrap
View File

@ -13,7 +13,7 @@ TOP_DIR = ../..
TARGET_DIR = . TARGET_DIR = .
# keyboard dependent files # keyboard dependent files
SRC = main.c \ SRC = \
keymap.c \ keymap.c \
matrix.c \ matrix.c \
led.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 # 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 # type "make clean" after changing this, so all files will be rebuilt
MCU = atmega168p MCU = atmega328p
# avrdude doesn't know atmega168p # avrdude doesn't know atmega168p
AVRDUDE_MCU = atmega168 AVRDUDE_MCU = $(MCU)
# Processor frequency. # Processor frequency.
@ -84,10 +84,11 @@ PROGRAM_CMD = $(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE
# Search Path # Search Path
VPATH = $(TARGET_DIR) 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. # 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/vusb.mk
include $(TOP_DIR)/protocol.mk #include $(TOP_DIR)/protocol.mk
include $(TOP_DIR)/common.mk include $(TOP_DIR)/common.mk
include $(TOP_DIR)/rules.mk include $(TOP_DIR)/rules.mk

6
keyboard/hhkb/config.h
View File

@ -35,16 +35,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* matrix size */ /* matrix size */
#define MATRIX_ROWS 8 #define MATRIX_ROWS 8
#define MATRIX_COLS 8 #define MATRIX_COLS 8
/* define if matrix has ghost */
//#define MATRIX_HAS_GHOST
/* key combination for command */ /* 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 */ /* mouse keys */
#ifdef MOUSEKEY_ENABLE #ifdef MOUSEKEY_ENABLE
# define MOUSEKEY_DELAY_TIME 192 # define MOUSEKEY_DELAY_TIME 100
#endif #endif

2
keyboard/hhkb/config_iwrap.h
View File

@ -33,7 +33,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* 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 */ /* mouse keys */
#ifdef MOUSEKEY_ENABLE #ifdef MOUSEKEY_ENABLE

4
keyboard/hhkb/config_vusb.h
View File

@ -33,11 +33,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* 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 */ /* mouse keys */
#ifdef MOUSEKEY_ENABLE #ifdef MOUSEKEY_ENABLE
# define MOUSEKEY_DELAY_TIME 255 # define MOUSEKEY_DELAY_TIME 100
#endif #endif

73
keyboard/hhkb/keymap.c
View File

@ -22,7 +22,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdbool.h> #include <stdbool.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "host.h" #include "host.h"
#include "usb_keycodes.h" #include "keycode.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
@ -39,14 +39,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
K35, K36, K37, K57, K56 \ K35, K36, K37, K57, K56 \
) \ ) \
{ \ { \
{ KB_##K00, KB_##K01, KB_##K02, KB_##K03, KB_##K04, KB_##K05, KB_##K06, KB_##K07 }, \ { KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07 }, \
{ KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
{ KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_##K25, KB_##K26, KB_NO }, \ { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \
{ KB_##K30, KB_##K31, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \ { KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
{ KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_NO }, \ { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_NO }, \
{ KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
{ KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_##K65, KB_##K66, KB_NO }, \ { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_NO }, \
{ KB_##K70, KB_##K71, KB_##K72, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_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)])) #define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)]))
@ -59,7 +59,7 @@ static const uint8_t PROGMEM fn_layer[] = {
2, // Fn2 2, // Fn2
3, // Fn3 3, // Fn3
3, // Fn4 3, // Fn4
4, // Fn5 5, // Fn5
0, // Fn6 0, // Fn6
0 // Fn7 0 // Fn7
}; };
@ -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. // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
// See layer.c for details. // See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = { static const uint8_t PROGMEM fn_keycode[] = {
KB_NO, // Fn0 KC_NO, // Fn0
KB_NO, // Fn1 KC_NO, // Fn1
KB_SLSH, // Fn2 KC_SLSH, // Fn2
KB_SCLN, // Fn3 KC_SCLN, // Fn3
KB_NO, // Fn4 KC_NO, // Fn4
KB_SPC, // Fn5 KC_SPC, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
}; };
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { 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, \ 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, \ 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, \ 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) /* Layer 1: HHKB mode (HHKB Fn)
* ,-----------------------------------------------------------. * ,-----------------------------------------------------------.
@ -151,10 +151,10 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
*/ */
#ifdef HOST_IWRAP #ifdef HOST_IWRAP
// iWRAP does not support mouse wheel, use these keycodes to remap as wheel // iWRAP does not support mouse wheel, use these keycodes to remap as wheel
#define KB_KPPL KB_KP_PLUS #define KC_KPPL KC_KP_PLUS
#define KB_KPMI KB_KP_MINUS #define KC_KPMI KC_KP_MINUS
#define KB_KPAS KB_KP_ASTERISK #define KC_KPAS KC_KP_ASTERISK
#define KB_KPSL KB_KP_SLASH #define KC_KPSL KC_KP_SLASH
KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ 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, \ 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, \ LCTL,NO, MS_L,MS_D,MS_R,NO, MS_L,MS_D,MS_U,MS_R,FN3, NO, ENT, \
@ -162,9 +162,9 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
LGUI,LALT, BTN1, RALT,FN4), LGUI,LALT, BTN1, RALT,FN4),
#else #else
KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ 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, \ TAB, NO, NO, NO, NO, NO, 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, \ LCTL,NO, ACL0,ACL1,ACL2,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, \ LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \
LGUI,LALT, BTN1, RALT,FN4), LGUI,LALT, BTN1, RALT,FN4),
#endif #endif
@ -181,14 +181,13 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* |Gui |Alt |xxxxxxxxxxxxxxxxxxxxxxx|Alt |Gui| * |Gui |Alt |xxxxxxxxxxxxxxxxxxxxxxx|Alt |Gui|
* `--------------------------------------------' * `--------------------------------------------'
*/ */
/*
KEYMAP(MINS,0, 9, 8, 7, 6, 5, 4, 3, 2, 1, NO, NO, NO, ESC, \ 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, \ 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, \ 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, \ LSFT,SLSH,DOT, COMM,M, N, B, V, C, X, Z, RSFT,NO, \
LGUI,LALT, FN5, RALT,RGUI) LGUI,LALT, FN5, RALT,RGUI),
*/
/* Mouse mode (Space) */ /* Layer5: another Mouse mode (Space) */
#ifdef HOST_IWRAP #ifdef HOST_IWRAP
KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ 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, \ TAB, KPAS,KPPL,MS_U,KPMI,KPSL,KPAS,KPPL,KPMI,KPSL,NO, NO, NO, BSPC, \
@ -197,9 +196,9 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
LGUI,LALT, FN5, RALT,RGUI), LGUI,LALT, FN5, RALT,RGUI),
#else #else
KEYMAP(ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ 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, \ TAB, NO, NO, NO, NO, NO, 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, \ LCTL,NO, ACL0,ACL1,ACL2,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, \ LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,BTN4,BTN5,NO, RSFT,NO, \
LGUI,LALT, FN5, RALT,RGUI), LGUI,LALT, FN5, RALT,RGUI),
#endif #endif
}; };
@ -210,12 +209,12 @@ uint8_t keymap_get_keycode(uint8_t layer, uint8_t row, uint8_t col)
return KEYCODE(layer, row, 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]);
} }

52
keyboard/hhkb/matrix.c
View File

@ -43,22 +43,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
// matrix state buffer(1:on, 0:off) // matrix state buffer(1:on, 0:off)
#if (MATRIX_COLS <= 8) static matrix_row_t *matrix;
static uint8_t *matrix; static matrix_row_t *matrix_prev;
static uint8_t *matrix_prev; static matrix_row_t _matrix0[MATRIX_ROWS];
static uint8_t _matrix0[MATRIX_ROWS]; static matrix_row_t _matrix1[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
// Matrix I/O ports // Matrix I/O ports
@ -119,7 +107,7 @@ static bool matrix_has_ghost_in_row(uint8_t row);
#define KEY_POWER_ON() do { \ #define KEY_POWER_ON() do { \
KEY_INIT(); \ KEY_INIT(); \
PORTB &= ~(1<<5); \ PORTB &= ~(1<<5); \
_delay_us(200); \ _delay_ms(1); \
} while (0) } while (0)
#define KEY_POWER_OFF() do { \ #define KEY_POWER_OFF() do { \
DDRB &= ~0x3F; \ DDRB &= ~0x3F; \
@ -192,6 +180,8 @@ uint8_t matrix_scan(void)
} }
// Ignore if this code region execution time elapses more than 20us. // 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)) { if (TIMER_DIFF_RAW(TIMER_RAW, last) > 20/(1000000/TIMER_RAW_FREQ)) {
matrix[row] = matrix_prev[row]; matrix[row] = matrix_prev[row];
} }
@ -219,12 +209,6 @@ bool matrix_is_modified(void)
inline inline
bool matrix_has_ghost(void) 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; return false;
} }
@ -257,11 +241,6 @@ void matrix_print(void)
pbin_reverse(matrix_get_row(row)); pbin_reverse(matrix_get_row(row));
#else #else
pbin_reverse16(matrix_get_row(row)); pbin_reverse16(matrix_get_row(row));
#endif
#ifdef MATRIX_HAS_GHOST
if (matrix_has_ghost_in_row(row)) {
print(" <ghost");
}
#endif #endif
print("\n"); print("\n");
} }
@ -279,20 +258,3 @@ uint8_t matrix_key_count(void)
} }
return count; return count;
} }
#ifdef MATRIX_HAS_GHOST
inline
static bool matrix_has_ghost_in_row(uint8_t row)
{
// no ghost exists in case less than 2 keys on
if (((matrix[row] - 1) & matrix[row]) == 0)
return false;
// ghost exists in case same state as other row
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
if (i != row && (matrix[i] & matrix[row]) == matrix[row])
return true;
}
return false;
}
#endif

4
keyboard/macway/config.h
View File

@ -45,8 +45,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */ /* key combination for command */
#define IS_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(KC_LSHIFT) | MOD_BIT(KC_LCTRL) | MOD_BIT(KC_LALT) | MOD_BIT(KC_LGUI)) || \
keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)) \ keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
) )

36
keyboard/macway/keymap.c
View File

@ -21,7 +21,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
@ -37,15 +37,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
K67, K16, K26, K36, K46, K47, K57, K56, K66, K76, K87, K32, K35, \ K67, K16, K26, K36, K46, K47, K57, K56, K66, K76, K87, K32, K35, \
K75, K22, K00, K07, K21, K04, K37, K27, K17 \ 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 }, \ { KC_##K00, KC_##K01, KC_##K02, KC_NO, KC_##K04, KC_NO, KC_##K06, KC_##K07 }, \
{ KB_##K10, KB_##K11, KB_##K12, KB_##K13, KB_##K14, KB_##K15, KB_##K16, KB_##K17 }, \ { KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17 }, \
{ KB_##K20, KB_##K21, KB_##K22, KB_##K23, KB_##K24, KB_NO, KB_##K26, KB_##K27 }, \ { KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_NO, KC_##K26, KC_##K27 }, \
{ KB_##K30, KB_NO, KB_##K32, KB_##K33, KB_##K34, KB_##K35, KB_##K36, KB_##K37 }, \ { KC_##K30, KC_NO, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37 }, \
{ KB_##K40, KB_##K41, KB_##K42, KB_##K43, KB_##K44, KB_##K45, KB_##K46, KB_##K47 }, \ { KC_##K40, KC_##K41, KC_##K42, KC_##K43, KC_##K44, KC_##K45, KC_##K46, KC_##K47 }, \
{ KB_##K50, KB_##K51, KB_##K52, KB_##K53, KB_##K54, KB_##K55, KB_##K56, KB_##K57 }, \ { KC_##K50, KC_##K51, KC_##K52, KC_##K53, KC_##K54, KC_##K55, KC_##K56, KC_##K57 }, \
{ KB_##K60, KB_##K61, KB_##K62, KB_##K63, KB_##K64, KB_NO, KB_##K66, KB_##K67 }, \ { KC_##K60, KC_##K61, KC_##K62, KC_##K63, KC_##K64, KC_NO, KC_##K66, KC_##K67 }, \
{ KB_##K70, KB_NO, KB_NO, KB_##K73, KB_##K74, KB_##K75, KB_##K76, KB_NO }, \ { KC_##K70, KC_NO, KC_NO, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_NO }, \
{ KB_##K80, KB_##K81, KB_##K82, KB_##K83, KB_##K84, KB_##K85, KB_NO, KB_##K87 } \ { 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)])) #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. // Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
// See layer.c for details. // See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = { static const uint8_t PROGMEM fn_keycode[] = {
KB_NO, // Fn0 KC_NO, // Fn0
KB_NO, // Fn1 KC_NO, // Fn1
KB_SLSH, // Fn2 KC_SLSH, // Fn2
KB_SCLN, // Fn3 KC_SCLN, // Fn3
KB_SPC, // Fn4 KC_SPC, // Fn4
KB_NO, // Fn5 KC_NO, // Fn5
KB_NO, // Fn6 KC_NO, // Fn6
KB_NO // Fn7 KC_NO // Fn7
}; };
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

10
protocol/iwrap.mk
View File

@ -1,9 +1,11 @@
IWRAP_DIR = protocol/iwrap
OPT_DEFS += -DHOST_IWRAP OPT_DEFS += -DHOST_IWRAP
SRC += iwrap.c \ SRC += $(IWRAP_DIR)/iwrap.c \
suart.S \ $(IWRAP_DIR)/suart.S \
sendchar_uart.c \ $(IWRAP_DIR)/sendchar_uart.c \
uart.c $(IWRAP_DIR)/uart.c
# Search Path # Search Path

2
protocol/iwrap/iwrap.c
View File

@ -29,7 +29,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <string.h> #include <string.h>
#include <avr/interrupt.h> #include <avr/interrupt.h>
#include <util/delay.h> #include <util/delay.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "suart.h" #include "suart.h"
#include "uart.h" #include "uart.h"
#include "report.h" #include "report.h"

110
protocol/iwrap/main.c
View File

@ -34,7 +34,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "suart.h" #include "suart.h"
#include "timer.h" #include "timer.h"
#include "debug.h" #include "debug.h"
#include "usb_keycodes.h" #include "keycode.h"
#include "command.h" #include "command.h"
@ -166,7 +166,7 @@ int main(void)
if (host_get_driver() == vusb_driver()) if (host_get_driver() == vusb_driver())
usbPoll(); usbPoll();
#endif #endif
keyboard_proc(); keyboard_task();
#ifdef HOST_VUSB #ifdef HOST_VUSB
if (host_get_driver() == vusb_driver()) if (host_get_driver() == vusb_driver())
vusb_transfer_keyboard(); vusb_transfer_keyboard();
@ -320,59 +320,59 @@ static uint8_t console_command(uint8_t c)
static uint8_t key2asc(uint8_t key) static uint8_t key2asc(uint8_t key)
{ {
switch (key) { switch (key) {
case KB_A: return 'a'; case KC_A: return 'a';
case KB_B: return 'b'; case KC_B: return 'b';
case KB_C: return 'c'; case KC_C: return 'c';
case KB_D: return 'd'; case KC_D: return 'd';
case KB_E: return 'e'; case KC_E: return 'e';
case KB_F: return 'f'; case KC_F: return 'f';
case KB_G: return 'g'; case KC_G: return 'g';
case KB_H: return 'h'; case KC_H: return 'h';
case KB_I: return 'i'; case KC_I: return 'i';
case KB_J: return 'j'; case KC_J: return 'j';
case KB_K: return 'k'; case KC_K: return 'k';
case KB_L: return 'l'; case KC_L: return 'l';
case KB_M: return 'm'; case KC_M: return 'm';
case KB_N: return 'n'; case KC_N: return 'n';
case KB_O: return 'o'; case KC_O: return 'o';
case KB_P: return 'p'; case KC_P: return 'p';
case KB_Q: return 'q'; case KC_Q: return 'q';
case KB_R: return 'r'; case KC_R: return 'r';
case KB_S: return 's'; case KC_S: return 's';
case KB_T: return 't'; case KC_T: return 't';
case KB_U: return 'u'; case KC_U: return 'u';
case KB_V: return 'v'; case KC_V: return 'v';
case KB_W: return 'w'; case KC_W: return 'w';
case KB_X: return 'x'; case KC_X: return 'x';
case KB_Y: return 'y'; case KC_Y: return 'y';
case KB_Z: return 'z'; case KC_Z: return 'z';
case KB_1: return '1'; case KC_1: return '1';
case KB_2: return '2'; case KC_2: return '2';
case KB_3: return '3'; case KC_3: return '3';
case KB_4: return '4'; case KC_4: return '4';
case KB_5: return '5'; case KC_5: return '5';
case KB_6: return '6'; case KC_6: return '6';
case KB_7: return '7'; case KC_7: return '7';
case KB_8: return '8'; case KC_8: return '8';
case KB_9: return '9'; case KC_9: return '9';
case KB_0: return '0'; case KC_0: return '0';
case KB_ENTER: return '\n'; case KC_ENTER: return '\n';
case KB_ESCAPE: return 0x1B; case KC_ESCAPE: return 0x1B;
case KB_BSPACE: return '\b'; case KC_BSPACE: return '\b';
case KB_TAB: return '\t'; case KC_TAB: return '\t';
case KB_SPACE: return ' '; case KC_SPACE: return ' ';
case KB_MINUS: return '-'; case KC_MINUS: return '-';
case KB_EQUAL: return '='; case KC_EQUAL: return '=';
case KB_LBRACKET: return '['; case KC_LBRACKET: return '[';
case KB_RBRACKET: return ']'; case KC_RBRACKET: return ']';
case KB_BSLASH: return '\\'; case KC_BSLASH: return '\\';
case KB_NONUS_HASH: return '\\'; case KC_NONUS_HASH: return '\\';
case KB_SCOLON: return ';'; case KC_SCOLON: return ';';
case KB_QUOTE: return '\''; case KC_QUOTE: return '\'';
case KB_GRAVE: return '`'; case KC_GRAVE: return '`';
case KB_COMMA: return ','; case KC_COMMA: return ',';
case KB_DOT: return '.'; case KC_DOT: return '.';
case KB_SLASH: return '/'; case KC_SLASH: return '/';
default: return 0x00; default: return 0x00;
} }
} }

2
protocol/lufa/lufa.c
View File

@ -475,7 +475,7 @@ int main(void)
keyboard_init(); keyboard_init();
host_set_driver(&lufa_driver); host_set_driver(&lufa_driver);
while (1) { while (1) {
keyboard_proc(); keyboard_task();
#if !defined(INTERRUPT_CONTROL_ENDPOINT) #if !defined(INTERRUPT_CONTROL_ENDPOINT)
USB_USBTask(); USB_USBTask();

2
protocol/pjrc/main.c
View File

@ -86,6 +86,6 @@ int main(void)
host_set_driver(pjrc_driver()); host_set_driver(pjrc_driver());
while (1) { while (1) {
keyboard_proc(); keyboard_task();
} }
} }

2
protocol/pjrc/usb_keyboard.c
View File

@ -23,7 +23,7 @@
#include <avr/interrupt.h> #include <avr/interrupt.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "usb_keycodes.h" #include "keycode.h"
#include "usb_keyboard.h" #include "usb_keyboard.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"

2
protocol/vusb/main.c
View File

@ -96,7 +96,7 @@ int main(void)
// TODO: configuration process is incosistent. it sometime fails. // TODO: configuration process is incosistent. it sometime fails.
// To prevent failing to configure NOT scan keyboard during configuration // To prevent failing to configure NOT scan keyboard during configuration
if (usbConfiguration && usbInterruptIsReady()) { if (usbConfiguration && usbInterruptIsReady()) {
keyboard_proc(); keyboard_task();
} }
vusb_transfer_keyboard(); vusb_transfer_keyboard();
} }

14
protocol/vusb/vusb.c
View File

@ -42,12 +42,12 @@ void vusb_transfer_keyboard(void)
if (usbInterruptIsReady()) { if (usbInterruptIsReady()) {
if (kbuf_head != kbuf_tail) { if (kbuf_head != kbuf_tail) {
usbSetInterrupt((void *)&kbuf[kbuf_tail], sizeof(report_keyboard_t)); 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; 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");
}
} }
} }
} }
@ -164,8 +164,8 @@ usbRequest_t *rq = (void *)data;
if(rq->bRequest == USBRQ_HID_GET_REPORT){ if(rq->bRequest == USBRQ_HID_GET_REPORT){
debug("GET_REPORT:"); debug("GET_REPORT:");
/* we only have one report type, so don't look at wValue */ /* we only have one report type, so don't look at wValue */
usbMsgPtr = (void *)keyboard_report_prev; usbMsgPtr = (void *)keyboard_report;
return sizeof(*keyboard_report_prev); return sizeof(*keyboard_report);
}else if(rq->bRequest == USBRQ_HID_GET_IDLE){ }else if(rq->bRequest == USBRQ_HID_GET_IDLE){
debug("GET_IDLE: "); debug("GET_IDLE: ");
//debug_hex(vusb_idle_rate); //debug_hex(vusb_idle_rate);