Merge branch 'layerfix'

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

View File

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

View File

@ -17,16 +17,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h>
#include <stdbool.h>
#include <util/delay.h>
#include "usb_keycodes.h"
#include "keycode.h"
#include "host.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "timer.h"
#include "layer.h"
#include "matrix.h"
#include "keyboard.h"
#include "bootloader.h"
#include "command.h"
#ifdef MOUSEKEY_ENABLE
#include "mousekey.h"
#endif
#ifdef HOST_PJRC
# include "usb_keyboard.h"
@ -40,104 +42,182 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#endif
static uint8_t command_common(void);
static void help(void);
static bool command_common(uint8_t code);
static void command_common_help(void);
static bool command_console(uint8_t code);
static void command_console_help(void);
#ifdef MOUSEKEY_ENABLE
static bool mousekey_console(uint8_t code);
static void mousekey_console_help(void);
#endif
static uint8_t numkey2num(uint8_t code);
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;
last_print_enable = print_enable;
if (!IS_COMMAND())
return 0;
print_enable = true;
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();
switch (state) {
case ONESHOT:
if (!IS_COMMAND())
return false;
return (command_extra(code) || command_common(code));
case CONSOLE:
command_console(code);
break;
case KB_B:
host_clear_keyboard_report();
host_send_keyboard_report();
print("jump to bootloader... ");
#ifdef MOUSEKEY_ENABLE
case MOUSEKEY:
mousekey_console(code);
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);
bootloader_jump(); // not return
print("not supported.\n");
break;
case KB_D:
debug_enable = !debug_enable;
case KC_D:
if (debug_enable) {
last_print_enable = true;
print("debug enabled.\n");
debug_matrix = true;
debug_keyboard = true;
debug_mouse = true;
} else {
print("debug disabled.\n");
last_print_enable = false;
debug_matrix = false;
print("\nDEBUG: disabled.\n");
debug_matrix = false;
debug_keyboard = false;
debug_mouse = false;
debug_mouse = false;
debug_enable = false;
} else {
print("\nDEBUG: enabled.\n");
debug_matrix = true;
debug_keyboard = true;
debug_mouse = true;
debug_enable = true;
}
break;
case KB_X: // debug matrix toggle
case KC_X: // debug matrix toggle
debug_matrix = !debug_matrix;
if (debug_matrix)
print("debug matrix enabled.\n");
else
print("debug matrix disabled.\n");
break;
case KB_K: // debug keyboard toggle
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;
if (debug_matrix) {
print("\nDEBUG: matrix enabled.\n");
debug_enable = true;
} 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");
}
break;
case KB_S:
case KC_S:
print("\n\n----- Status -----\n");
print("host_keyboard_leds:"); phex(host_keyboard_leds()); print("\n");
#ifdef HOST_PJRC
print("UDCON: "); phex(UDCON); print("\n");
@ -156,10 +236,7 @@ static uint8_t command_common(void)
#endif
break;
#ifdef NKRO_ENABLE
case KB_N:
// send empty report before change
host_clear_keyboard_report();
host_send_keyboard_report();
case KC_N:
keyboard_nkro = !keyboard_nkro;
if (keyboard_nkro)
print("NKRO: enabled\n");
@ -168,9 +245,8 @@ static uint8_t command_common(void)
break;
#endif
#ifdef EXTRAKEY_ENABLE
case KB_ESC:
host_clear_keyboard_report();
host_send_keyboard_report();
case KC_PSCREEN:
// TODO: Power key should take this feature? otherwise any key during suspend.
#ifdef HOST_PJRC
if (suspend && remote_wakeup) {
usb_remote_wakeup();
@ -181,57 +257,296 @@ static uint8_t command_common(void)
}
#else
host_system_send(SYSTEM_POWER_DOWN);
_delay_ms(100);
host_system_send(0);
_delay_ms(500);
#endif
break;
#endif
case KB_BSPC:
matrix_init();
print("clear matrix\n");
break;
case KB_0:
case KC_0:
case KC_F10:
switch_layer(0);
break;
case KB_1:
case KC_1:
case KC_F1:
switch_layer(1);
break;
case KB_2:
case KC_2:
case KC_F2:
switch_layer(2);
break;
case KB_3:
case KC_3:
case KC_F3:
switch_layer(3);
break;
case KB_4:
case KC_4:
case KC_F4:
switch_layer(4);
break;
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("d: toggle debug enable\n");
print("x: toggle matrix debug\n");
print("k: toggle keyboard debug\n");
print("m: toggle mouse debug\n");
print("p: toggle print enable\n");
print("v: print version\n");
print("t: print timer count\n");
print("s: print status\n");
#ifdef NKRO_ENABLE
print("n: toggle NKRO\n");
print_enable = true;
print("\n\n----- Console Help -----\n");
print("ESC/q: quit\n");
#ifdef MOUSEKEY_ENABLE
print("m: mousekey\n");
#endif
print("Backspace: clear matrix\n");
print("ESC: power down/wake up\n");
print("0: switch to Layer0 \n");
print("1: switch to Layer1 \n");
print("2: switch to Layer2 \n");
print("3: switch to Layer3 \n");
print("4: switch to Layer4 \n");
}
static bool command_console(uint8_t code)
{
switch (code) {
case KC_H:
case KC_SLASH: /* ? */
command_console_help();
break;
case KC_Q:
case KC_ESC:
print("\nQuit Console Mode\n");
state = ONESHOT;
return false;
#ifdef MOUSEKEY_ENABLE
case KC_M:
mousekey_console_help();
print("\nEnter Mousekey Console\n");
print("M0>");
state = MOUSEKEY;
return true;
#endif
default:
print("?");
return false;
}
print("C> ");
return true;
}
#ifdef MOUSEKEY_ENABLE
/***********************************************************
* Mousekey console
***********************************************************/
static uint8_t mousekey_param = 0;
static void mousekey_param_print(void)
{
print("\n\n----- Mousekey Parameters -----\n");
print("1: mk_delay(*10ms): "); pdec(mk_delay); print("\n");
print("2: mk_interval(ms): "); pdec(mk_interval); print("\n");
print("3: mk_max_speed: "); pdec(mk_max_speed); print("\n");
print("4: mk_time_to_max: "); pdec(mk_time_to_max); print("\n");
print("5: mk_wheel_max_speed: "); pdec(mk_wheel_max_speed); print("\n");
print("6: mk_wheel_time_to_max: "); pdec(mk_wheel_time_to_max); print("\n");
}
static void mousekey_param_inc(uint8_t param, uint8_t inc)
{
switch (param) {
case 1:
if (mk_delay + inc < UINT8_MAX)
mk_delay += inc;
else
mk_delay = UINT8_MAX;
print("mk_delay = "); pdec(mk_delay); print("\n");
break;
case 2:
if (mk_interval + inc < UINT8_MAX)
mk_interval += inc;
else
mk_interval = UINT8_MAX;
print("mk_interval = "); pdec(mk_interval); print("\n");
break;
case 3:
if (mk_max_speed + inc < UINT8_MAX)
mk_max_speed += inc;
else
mk_max_speed = UINT8_MAX;
print("mk_max_speed = "); pdec(mk_max_speed); print("\n");
break;
case 4:
if (mk_time_to_max + inc < UINT8_MAX)
mk_time_to_max += inc;
else
mk_time_to_max = UINT8_MAX;
print("mk_time_to_max = "); pdec(mk_time_to_max); print("\n");
break;
case 5:
if (mk_wheel_max_speed + inc < UINT8_MAX)
mk_wheel_max_speed += inc;
else
mk_wheel_max_speed = UINT8_MAX;
print("mk_wheel_max_speed = "); pdec(mk_wheel_max_speed); print("\n");
break;
case 6:
if (mk_wheel_time_to_max + inc < UINT8_MAX)
mk_wheel_time_to_max += inc;
else
mk_wheel_time_to_max = UINT8_MAX;
print("mk_wheel_time_to_max = "); pdec(mk_wheel_time_to_max); print("\n");
break;
}
}
static void mousekey_param_dec(uint8_t param, uint8_t dec)
{
switch (param) {
case 1:
if (mk_delay > dec)
mk_delay -= dec;
else
mk_delay = 0;
print("mk_delay = "); pdec(mk_delay); print("\n");
break;
case 2:
if (mk_interval > dec)
mk_interval -= dec;
else
mk_interval = 0;
print("mk_interval = "); pdec(mk_interval); print("\n");
break;
case 3:
if (mk_max_speed > dec)
mk_max_speed -= dec;
else
mk_max_speed = 0;
print("mk_max_speed = "); pdec(mk_max_speed); print("\n");
break;
case 4:
if (mk_time_to_max > dec)
mk_time_to_max -= dec;
else
mk_time_to_max = 0;
print("mk_time_to_max = "); pdec(mk_time_to_max); print("\n");
break;
case 5:
if (mk_wheel_max_speed > dec)
mk_wheel_max_speed -= dec;
else
mk_wheel_max_speed = 0;
print("mk_wheel_max_speed = "); pdec(mk_wheel_max_speed); print("\n");
break;
case 6:
if (mk_wheel_time_to_max > dec)
mk_wheel_time_to_max -= dec;
else
mk_wheel_time_to_max = 0;
print("mk_wheel_time_to_max = "); pdec(mk_wheel_time_to_max); print("\n");
break;
}
}
static void mousekey_console_help(void)
{
print("\n\n----- Mousekey Parameters Help -----\n");
print("ESC/q: quit\n");
print("1: select mk_delay(*10ms)\n");
print("2: select mk_interval(ms)\n");
print("3: select mk_max_speed\n");
print("4: select mk_time_to_max\n");
print("5: select mk_wheel_max_speed\n");
print("6: select mk_wheel_time_to_max\n");
print("p: print prameters\n");
print("d: set default values\n");
print("up: increase prameters(+1)\n");
print("down: decrease prameters(-1)\n");
print("pgup: increase prameters(+10)\n");
print("pgdown: decrease prameters(-10)\n");
print("\nspeed = delta * max_speed * (repeat / time_to_max)\n");
print("where delta: cursor="); pdec(MOUSEKEY_MOVE_DELTA);
print(", wheel="); pdec(MOUSEKEY_WHEEL_DELTA); print("\n");
print("See http://en.wikipedia.org/wiki/Mouse_keys\n");
}
static bool mousekey_console(uint8_t code)
{
switch (code) {
case KC_H:
case KC_SLASH: /* ? */
mousekey_console_help();
break;
case KC_Q:
case KC_ESC:
mousekey_param = 0;
print("\nQuit Mousekey Console\n");
print("C> ");
state = CONSOLE;
return false;
case KC_P:
mousekey_param_print();
break;
case KC_1:
case KC_2:
case KC_3:
case KC_4:
case KC_5:
case KC_6:
case KC_7:
case KC_8:
case KC_9:
case KC_0:
mousekey_param = 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)
@ -242,3 +557,18 @@ static void switch_layer(uint8_t layer)
default_layer = layer;
print("switch to Layer: "); phex(layer); print("\n");
}
static void clear_keyboard(void)
{
host_clear_keys();
host_clear_mods();
host_send_keyboard_report();
host_system_send(0);
host_consumer_send(0);
#ifdef MOUSEKEY_ENABLE
mousekey_clear();
mousekey_send();
#endif
}

View File

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

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_P(s) if(debug_enable) print_P(s)
#define debug_S(s) if(debug_enable) print_S(s)
#define debug_hex(c) if(debug_enable) phex(c)
#define debug_hex16(i) if(debug_enable) phex16(i)
#define debug_bin(c) if(debug_enable) pbin(c)

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
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 <avr/interrupt.h>
#include "usb_keycodes.h"
#include "keycode.h"
#include "host.h"
#include "util.h"
#include "debug.h"
@ -27,13 +27,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
bool keyboard_nkro = false;
#endif
static host_driver_t *driver;
static report_keyboard_t report0;
static report_keyboard_t report1;
report_keyboard_t *keyboard_report = &report0;
report_keyboard_t *keyboard_report_prev = &report1;
report_keyboard_t *keyboard_report = &(report_keyboard_t){};
report_mouse_t mouse_report = {};
static host_driver_t *driver;
static uint16_t last_system_report = 0;
static uint16_t last_consumer_report = 0;
static inline void add_key_byte(uint8_t code);
static inline void del_key_byte(uint8_t code);
static inline void add_key_bit(uint8_t code);
@ -55,8 +56,48 @@ uint8_t host_keyboard_leds(void)
if (!driver) return 0;
return (*driver->keyboard_leds)();
}
/* send report */
void host_keyboard_send(report_keyboard_t *report)
{
if (!driver) return;
(*driver->send_keyboard)(report);
/* keyboard report operations */
if (debug_keyboard) {
print("keys: ");
for (int i = 0; i < REPORT_KEYS; i++) {
phex(keyboard_report->keys[i]); print(" ");
}
print(" mods: "); phex(keyboard_report->mods); print("\n");
}
}
void host_mouse_send(report_mouse_t *report)
{
if (!driver) return;
(*driver->send_mouse)(report);
}
void host_system_send(uint16_t report)
{
if (report == last_system_report) return;
last_system_report = report;
if (!driver) return;
(*driver->send_system)(report);
}
void host_consumer_send(uint16_t report)
{
if (report == last_consumer_report) return;
last_consumer_report = report;
if (!driver) return;
(*driver->send_consumer)(report);
}
/* keyboard report utils */
void host_add_key(uint8_t key)
{
#ifdef NKRO_ENABLE
@ -79,6 +120,13 @@ void host_del_key(uint8_t key)
del_key_byte(key);
}
void host_clear_keys(void)
{
for (int8_t i = 0; i < REPORT_KEYS; i++) {
keyboard_report->keys[i] = 0;
}
}
void host_add_mod_bit(uint8_t mod)
{
keyboard_report->mods |= mod;
@ -94,40 +142,9 @@ void host_set_mods(uint8_t mods)
keyboard_report->mods = mods;
}
void host_add_code(uint8_t code)
{
if (IS_MOD(code)) {
host_add_mod_bit(MOD_BIT(code));
} else {
host_add_key(code);
}
}
void host_del_code(uint8_t code)
{
if (IS_MOD(code)) {
host_del_mod_bit(MOD_BIT(code));
} else {
host_del_key(code);
}
}
void host_swap_keyboard_report(void)
{
uint8_t sreg = SREG;
cli();
report_keyboard_t *tmp = keyboard_report_prev;
keyboard_report_prev = keyboard_report;
keyboard_report = tmp;
SREG = sreg;
}
void host_clear_keyboard_report(void)
void host_clear_mods(void)
{
keyboard_report->mods = 0;
for (int8_t i = 0; i < REPORT_KEYS; i++) {
keyboard_report->keys[i] = 0;
}
}
uint8_t host_has_anykey(void)
@ -140,6 +157,11 @@ uint8_t host_has_anykey(void)
return cnt;
}
uint8_t host_has_anymod(void)
{
return bitpop(keyboard_report->mods);
}
uint8_t host_get_first_key(void)
{
#ifdef NKRO_ENABLE
@ -153,53 +175,36 @@ uint8_t host_get_first_key(void)
return keyboard_report->keys[0];
}
void host_send_keyboard_report(void)
{
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;
(*driver->send_mouse)(report);
return (mouse_report.buttons | mouse_report.x | mouse_report.y | mouse_report.v | mouse_report.h);
}
void host_system_send(uint16_t data)
uint16_t host_last_sysytem_report(void)
{
static uint16_t last_data = 0;
if (data == last_data) return;
last_data = data;
if (!driver) return;
(*driver->send_system)(data);
return last_system_report;
}
void host_consumer_send(uint16_t data)
uint16_t host_last_consumer_report(void)
{
static uint16_t last_data = 0;
if (data == last_data) return;
last_data = data;
if (!driver) return;
(*driver->send_consumer)(data);
return last_consumer_report;
}
static inline void add_key_byte(uint8_t code)
{
// TODO: fix ugly code
int8_t i = 0;
int8_t empty = -1;
for (; i < REPORT_KEYS; i++) {
if (keyboard_report_prev->keys[i] == code) {
keyboard_report->keys[i] = code;
if (keyboard_report->keys[i] == code) {
break;
}
if (empty == -1 &&
keyboard_report_prev->keys[i] == 0 &&
keyboard_report->keys[i] == 0) {
if (empty == -1 && keyboard_report->keys[i] == 0) {
empty = i;
}
}
@ -216,7 +221,6 @@ static inline void del_key_byte(uint8_t code)
for (; i < REPORT_KEYS; i++) {
if (keyboard_report->keys[i] == code) {
keyboard_report->keys[i] = 0;
break;
}
}
}

View File

@ -31,33 +31,41 @@ extern "C" {
extern bool keyboard_nkro;
#endif
/* report */
extern report_keyboard_t *keyboard_report;
extern report_keyboard_t *keyboard_report_prev;
extern report_mouse_t mouse_report;
/* host driver */
void host_set_driver(host_driver_t *driver);
host_driver_t *host_get_driver(void);
/* host driver interface */
uint8_t host_keyboard_leds(void);
/* 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_keyboard_send(report_keyboard_t *report);
void host_mouse_send(report_mouse_t *report);
void host_system_send(uint16_t data);
void host_consumer_send(uint16_t data);
/* keyboard report 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
}
#endif

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/>.
*/
#include "keyboard.h"
#include "host.h"
#include "layer.h"
#include "matrix.h"
#include "keymap.h"
#include "host.h"
#include "led.h"
#include "usb_keycodes.h"
#include "keycode.h"
#include "timer.h"
#include "print.h"
#include "debug.h"
#include "command.h"
#include "util.h"
#ifdef MOUSEKEY_ENABLE
#include "mousekey.h"
#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
/* 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)
{
debug_keyboard = true;
timer_init();
matrix_init();
#ifdef PS2_MOUSE_ENABLE
@ -44,150 +552,72 @@ void keyboard_init(void)
#endif
}
void keyboard_proc(void)
void keyboard_task(void)
{
uint8_t fn_bits = 0;
#ifdef EXTRAKEY_ENABLE
uint16_t consumer_code = 0;
uint16_t system_code = 0;
#endif
static matrix_row_t matrix_prev[MATRIX_ROWS];
matrix_row_t matrix_row = 0;
matrix_row_t matrix_change = 0;
matrix_scan();
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()) {
if (debug_matrix) matrix_print();
#ifdef DEBUG_LED
// LED flash for debug
DEBUG_LED_CONFIG;
DEBUG_LED_ON;
#endif
}
if (matrix_has_ghost()) {
// should send error?
debug("matrix has ghost!!\n");
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();
for (int c = 0; c < MATRIX_COLS; c++) {
if (matrix_change & (1<<c)) {
process_key((keyevent_t){
.key = (key_t){ .row = r, .col = c },
.pressed = (matrix_row & (1<<c))
});
// record a processed key
matrix_prev[r] ^= (1<<c);
// process a key per task call
goto MATRIX_LOOP_END;
}
#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;
} else if (code == KB_AUDIO_VOL_UP) {
consumer_code = AUDIO_VOL_UP;
} else if (code == KB_AUDIO_VOL_DOWN) {
consumer_code = AUDIO_VOL_DOWN;
}
}
MATRIX_LOOP_END:
// layer switch when delay term elapses
if (kbdstate == DELAYING || kbdstate == WAITING) {
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) {
consumer_code = TRANSPORT_NEXT_TRACK;
} else if (code == KB_MEDIA_PREV_TRACK) {
consumer_code = TRANSPORT_PREV_TRACK;
} else if (code == KB_MEDIA_STOP) {
consumer_code = TRANSPORT_STOP;
} else if (code == KB_MEDIA_PLAY_PAUSE) {
consumer_code = TRANSPORT_PLAY_PAUSE;
} else if (code == KB_MEDIA_SELECT) {
consumer_code = AL_CC_CONFIG;
}
else if (code == KB_MAIL) {
consumer_code = AL_EMAIL;
} else if (code == KB_CALCULATOR) {
consumer_code = AL_CALCULATOR;
} else if (code == KB_MY_COMPUTER) {
consumer_code = AL_LOCAL_BROWSER;
}
else if (code == KB_WWW_SEARCH) {
consumer_code = AC_SEARCH;
} else if (code == KB_WWW_HOME) {
consumer_code = AC_HOME;
} else if (code == KB_WWW_BACK) {
consumer_code = AC_BACK;
} else if (code == KB_WWW_FORWARD) {
consumer_code = AC_FORWARD;
} else if (code == KB_WWW_STOP) {
consumer_code = AC_STOP;
} else if (code == KB_WWW_REFRESH) {
consumer_code = AC_REFRESH;
} else if (code == KB_WWW_FAVORITES) {
consumer_code = AC_BOOKMARKS;
}
#endif
else if (IS_KEY(code)) {
host_add_key(code);
}
#ifdef MOUSEKEY_ENABLE
else if (IS_MOUSEKEY(code)) {
mousekey_decode(code);
}
#endif
else {
debug("ignore keycode: "); debug_hex(code); debug("\n");
if (kbdstate == WAITING) {
layer_switch_on(delayed_fn.code);
NEXT(IDLE);
uint8_t tmp_mods = keyboard_report->mods;
host_set_mods(waiting_key.mods);
process_key(waiting_key.event);
host_set_mods(tmp_mods);
}
}
}
layer_switching(fn_bits);
if (command_proc()) {
return;
}
// TODO: should send only when changed from last report
if (matrix_is_modified()) {
host_send_keyboard_report();
#ifdef EXTRAKEY_ENABLE
host_consumer_send(consumer_code);
host_system_send(system_code);
#endif
#ifdef DEBUG_LED
// LED flash for debug
DEBUG_LED_CONFIG;
DEBUG_LED_OFF;
#endif
}
#ifdef MOUSEKEY_ENABLE
mousekey_send();
// mousekey repeat & acceleration
mousekey_task();
#endif
#ifdef PS2_MOUSE_ENABLE
// TODO: should comform new API
if (ps2_mouse_read() == 0)
ps2_mouse_usb_send();
#endif
if (last_leds != host_keyboard_leds()) {
keyboard_set_leds(host_keyboard_leds());
last_leds = host_keyboard_leds();
// FAIL SAFE: clear all key if no key down
if (matrix_change) {
matrix_row_t is_matrix_on = 0;
for (int r = 0; r < MATRIX_ROWS; r++) {
is_matrix_on |= matrix_get_row(r);
}
if (!is_matrix_on) {
Kdebug("FAIL SAFE: clear all keys(default layer).\n");
clear_keyboard();
current_layer = default_layer;
}
}
return;
}
void keyboard_set_leds(uint8_t leds)

View File

@ -18,15 +18,41 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef KEYBOARD_H
#define KEYBOARD_H
#include <stdbool.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
uint8_t row;
uint8_t col;
} key_t;
typedef struct {
key_t key;
bool pressed;
} keyevent_t;
typedef struct {
keyevent_t event;
uint8_t code;
uint8_t mods;
uint16_t time;
} keyrecord_t;
#define KEYEQ(keya, keyb) (keya.row == keyb.row && keya.col == keyb.col)
extern uint8_t current_layer;
extern uint8_t default_layer;
void keyboard_init(void);
void keyboard_proc(void);
void keyboard_task(void);
void keyboard_set_leds(uint8_t leds);
#ifdef __cplusplus
}
#endif

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 */

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);
}

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

View File

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

View File

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

View File

@ -21,9 +21,49 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdbool.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_clear_report(void);
#endif

View File

@ -75,6 +75,14 @@ void phex16(unsigned int i)
phex(i);
}
void pdec(uint8_t i)
{
if (!print_enable) return;
if (i/100) sendchar('0' + (i/100));
if (i/100 || i%100/10) sendchar('0' + (i%100/10));
sendchar('0' + (i%10));
}
void pbin(unsigned char c)
{

View File

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

View File

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

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 */

View File

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

View File

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

View File

@ -33,7 +33,7 @@ Keymap
------
You can change a keymap by editing code of keymap.c like following.
This is a keymap for AEK, however, also used for other keyboards.
How to define the keymap is probably obvious. You can find key symbols in usb_keycodes.h.
How to define the keymap is probably obvious. You can find key symbols in keycode.h.
If you want to define some keymaps than just one, see hhkb/keymap.c and
macway/keymap.c as examples. Keymap(layer) switching may needs a bit of
effort at this time.

View File

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

View File

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

View File

@ -38,7 +38,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */
#define IS_COMMAND() ( \
keyboard_report->mods == (MOD_BIT(KB_LALT) | MOD_BIT(KB_LGUI)) \
keyboard_report->mods == (MOD_BIT(KC_LALT) | MOD_BIT(KC_LGUI)) \
)

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -21,7 +21,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h>
#include <stdbool.h>
#include <avr/pgmspace.h>
#include "usb_keycodes.h"
#include "keycode.h"
#include "print.h"
#include "debug.h"
#include "util.h"
@ -45,9 +45,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
{ R5C0, R5C1, R5C2, R5C3, R5C4, R5C5, R5C6, R5C7 }, \
{ R6C0, R6C1, R6C2, R6C3, R6C4, R6C5, R6C6, R6C7 }, \
{ R7C0, R7C1, R7C2, R7C3, R7C4, R7C5, R7C6, R7C7 }, \
{ R8C0, R8C1, KB_NO, KB_NO, KB_NO,KB_NO, KB_NO, KB_NO }, \
{ R8C0, R8C1, KC_NO, KC_NO, KC_NO,KC_NO, KC_NO, KC_NO }, \
{ R9C0, R9C1, R9C2, R9C3, R9C4, R9C5, R9C6, R9C7 }, \
{ R10C0,R10C1, R10C2, R10C3, R10C4,R10C5, KB_NO, KB_NO} \
{ R10C0,R10C1, R10C2, R10C3, R10C4,R10C5, KC_NO, KC_NO} \
}
#define KEYCODE(layer, row, col) (pgm_read_byte(&keymaps[(layer)][(row)][(col)]))
@ -68,14 +68,14 @@ static const uint8_t PROGMEM fn_layer[] = {
// Assign Fn key(0-7) to a keycode sent when release Fn key without use of the layer.
// See layer.c for details.
static const uint8_t PROGMEM fn_keycode[] = {
KB_NO, // Fn0
KB_NO, // Fn1
KB_SLSH, // Fn2
KB_SCLN, // Fn3
KB_SPC, // Fn4
KB_NO, // Fn5
KB_NO, // Fn6
KB_NO // Fn7
KC_NO, // Fn0
KC_NO, // Fn1
KC_SLSH, // Fn2
KC_SCLN, // Fn3
KC_SPC, // Fn4
KC_NO, // Fn5
KC_NO, // Fn6
KC_NO // Fn7
};
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
@ -94,12 +94,12 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* |CAPS|Alt |Gui |` |SPC |BSLS |LFT|RGT|DN|UP| | 0 | . | T |
* `-----------------------------------------------------------' |---------------'
*/
KEYMAP( KB_PWR,
KB_ESC, KB_1, KB_2, KB_3, KB_4, KB_5, KB_6, KB_7, KB_8, KB_9, KB_0, KB_MINS,KB_EQL, KB_BSPC, KB_FN1, KB_PEQL, KB_PSLS, KB_PAST, \
KB_TAB, KB_Q, KB_W, KB_E, KB_R, KB_T, KB_Y, KB_U, KB_I, KB_O, KB_P, KB_LBRC,KB_RBRC, KB_P7, KB_P8, KB_P9, KB_PPLS, \
KB_LCTL,KB_A, KB_S, KB_D, KB_F, KB_G, KB_H, KB_J, KB_K, KB_L, KB_SCLN, KB_QUOT,KB_ENT, KB_P4, KB_P5, KB_P6, KB_PMNS, \
KB_LSFT,KB_Z, KB_X, KB_C, KB_V, KB_B, KB_N, KB_M, KB_COMM,KB_DOT, KB_SLSH, KB_P1, KB_P2, KB_P3, \
KB_CAPS,KB_LALT,KB_LGUI,KB_GRV, KB_SPC, KB_BSLS,KB_LEFT,KB_RGHT,KB_DOWN,KB_UP, KB_P0, KB_PDOT, KB_PENT),
KEYMAP( KC_PWR,
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS,KC_EQL, KC_BSPC, KC_FN1, KC_PEQL, KC_PSLS, KC_PAST, \
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC,KC_RBRC, KC_P7, KC_P8, KC_P9, KC_PPLS, \
KC_LCTL,KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,KC_ENT, KC_P4, KC_P5, KC_P6, KC_PMNS, \
KC_LSFT,KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM,KC_DOT, KC_SLSH, KC_P1, KC_P2, KC_P3, \
KC_CAPS,KC_LALT,KC_LGUI,KC_GRV, KC_SPC, KC_BSLS,KC_LEFT,KC_RGHT,KC_DOWN,KC_UP, KC_P0, KC_PDOT, KC_PENT),
/* Layer 1: Tenkey use Layer
@ -117,12 +117,12 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* |CAPS|Alt |Gui |` |SPC |BSLS |LFT|RGT|DN|UP| | 0 | . | T |
* `-----------------------------------------------------------' `---------------'
*/
KEYMAP( KB_PWR, \
KB_ESC, KB_1, KB_2, KB_3, KB_4, KB_5, KB_6, KB_7, KB_8, KB_9, KB_0, KB_MINS,KB_EQL, KB_BSPC, KB_FN1, KB_PEQL, KB_PSLS, KB_MUTE, \
KB_TAB, KB_Q, KB_W, KB_E, KB_R, KB_T, KB_Y, KB_U, KB_I, KB_O, KB_P, KB_LBRC,KB_RBRC, KB_INS, KB_P8, KB_PGUP, KB_VOLU, \
KB_LCTL,KB_A, KB_S, KB_D, KB_F, KB_G, KB_H, KB_J, KB_K, KB_L, KB_SCLN, KB_QUOT,KB_ENT, KB_DEL, KB_UP, KB_PGDN, KB_VOLD, \
KB_LSFT,KB_Z, KB_X, KB_C, KB_V, KB_B, KB_N, KB_M, KB_COMM,KB_DOT, KB_SLSH, KB_LEFT, KB_DOWN, KB_RIGHT, \
KB_CAPS,KB_LALT,KB_LGUI,KB_GRV, KB_SPC, KB_BSLS,KB_LEFT,KB_RGHT,KB_DOWN,KB_UP, KB_P0, KB_PDOT, KB_PENT),
KEYMAP( KC_PWR, \
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS,KC_EQL, KC_BSPC, KC_FN1, KC_PEQL, KC_PSLS, KC_MUTE, \
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC,KC_RBRC, KC_INS, KC_P8, KC_PGUP, KC_VOLU, \
KC_LCTL,KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,KC_ENT, KC_DEL, KC_UP, KC_PGDN, KC_VOLD, \
KC_LSFT,KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM,KC_DOT, KC_SLSH, KC_LEFT, KC_DOWN, KC_RIGHT, \
KC_CAPS,KC_LALT,KC_LGUI,KC_GRV, KC_SPC, KC_BSLS,KC_LEFT,KC_RGHT,KC_DOWN,KC_UP, KC_P0, KC_PDOT, KC_PENT),
};

View File

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

View File

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

View File

@ -13,7 +13,7 @@ TOP_DIR = ../..
TARGET_DIR = .
# keyboard dependent files
SRC = main.c \
SRC = \
keymap.c \
matrix.c \
led.c
@ -28,9 +28,9 @@ OPT_DEFS = -DDEBUG_LEVEL=0
# MCU name, you MUST set this to match the board you are using
# type "make clean" after changing this, so all files will be rebuilt
MCU = atmega168p
MCU = atmega328p
# avrdude doesn't know atmega168p
AVRDUDE_MCU = atmega168
AVRDUDE_MCU = $(MCU)
# Processor frequency.
@ -84,10 +84,11 @@ PROGRAM_CMD = $(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE
# Search Path
VPATH = $(TARGET_DIR)
VPATH += $(TOP_DIR)
include $(TOP_DIR)/protocol/iwrap.mk
#include $(TOP_DIR)/protocol/iwrap.mk
# To be swatchable btween Bluetooth and USB. Comment out if you don't need USB.
include $(TOP_DIR)/protocol/vusb.mk
include $(TOP_DIR)/protocol.mk
#include $(TOP_DIR)/protocol.mk
include $(TOP_DIR)/common.mk
include $(TOP_DIR)/rules.mk

View File

@ -35,16 +35,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* matrix size */
#define MATRIX_ROWS 8
#define MATRIX_COLS 8
/* define if matrix has ghost */
//#define MATRIX_HAS_GHOST
/* key combination for command */
#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)))
#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)))
/* mouse keys */
#ifdef MOUSEKEY_ENABLE
# define MOUSEKEY_DELAY_TIME 192
# define MOUSEKEY_DELAY_TIME 100
#endif

View File

@ -33,7 +33,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */
#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)))
#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)))
/* mouse keys */
#ifdef MOUSEKEY_ENABLE

View File

@ -33,11 +33,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* key combination for command */
#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KB_LSHIFT) | MOD_BIT(KB_RSHIFT)))
#define IS_COMMAND() (keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)))
/* mouse keys */
#ifdef MOUSEKEY_ENABLE
# define MOUSEKEY_DELAY_TIME 255
# define MOUSEKEY_DELAY_TIME 100
#endif

View File

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

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)
#if (MATRIX_COLS <= 8)
static uint8_t *matrix;
static uint8_t *matrix_prev;
static uint8_t _matrix0[MATRIX_ROWS];
static uint8_t _matrix1[MATRIX_ROWS];
#else
static uint16_t *matrix;
static uint16_t *matrix_prev;
static uint16_t _matrix0[MATRIX_ROWS];
static uint16_t _matrix1[MATRIX_ROWS];
#endif
// HHKB has no ghost and no bounce.
#ifdef MATRIX_HAS_GHOST
static bool matrix_has_ghost_in_row(uint8_t row);
#endif
static matrix_row_t *matrix;
static matrix_row_t *matrix_prev;
static matrix_row_t _matrix0[MATRIX_ROWS];
static matrix_row_t _matrix1[MATRIX_ROWS];
// Matrix I/O ports
@ -119,7 +107,7 @@ static bool matrix_has_ghost_in_row(uint8_t row);
#define KEY_POWER_ON() do { \
KEY_INIT(); \
PORTB &= ~(1<<5); \
_delay_us(200); \
_delay_ms(1); \
} while (0)
#define KEY_POWER_OFF() do { \
DDRB &= ~0x3F; \
@ -192,6 +180,8 @@ uint8_t matrix_scan(void)
}
// Ignore if this code region execution time elapses more than 20us.
// MEMO: 20[us] * (TIMER_RAW_FREQ / 1000000)[count per us]
// MEMO: then change above using this rule: a/(b/c) = a*1/(b/c) = a*(c/b)
if (TIMER_DIFF_RAW(TIMER_RAW, last) > 20/(1000000/TIMER_RAW_FREQ)) {
matrix[row] = matrix_prev[row];
}
@ -219,12 +209,6 @@ bool matrix_is_modified(void)
inline
bool matrix_has_ghost(void)
{
#ifdef MATRIX_HAS_GHOST
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
if (matrix_has_ghost_in_row(i))
return true;
}
#endif
return false;
}
@ -257,11 +241,6 @@ void matrix_print(void)
pbin_reverse(matrix_get_row(row));
#else
pbin_reverse16(matrix_get_row(row));
#endif
#ifdef MATRIX_HAS_GHOST
if (matrix_has_ghost_in_row(row)) {
print(" <ghost");
}
#endif
print("\n");
}
@ -279,20 +258,3 @@ uint8_t matrix_key_count(void)
}
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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -42,12 +42,12 @@ void vusb_transfer_keyboard(void)
if (usbInterruptIsReady()) {
if (kbuf_head != kbuf_tail) {
usbSetInterrupt((void *)&kbuf[kbuf_tail], sizeof(report_keyboard_t));
if (!debug_keyboard) {
print("keys: ");
for (int i = 0; i < REPORT_KEYS; i++) { phex(kbuf[kbuf_tail].keys[i]); print(" "); }
print(" mods: "); phex((kbuf[kbuf_tail]).mods); print("\n");
}
kbuf_tail = (kbuf_tail + 1) % KBUF_SIZE;
if (debug_keyboard) {
print("V-USB: kbuf["); pdec(kbuf_tail); print("->"); pdec(kbuf_head); print("](");
phex((kbuf_head < kbuf_tail) ? (KBUF_SIZE - kbuf_tail + kbuf_head) : (kbuf_head - kbuf_tail));
print(")\n");
}
}
}
}
@ -164,8 +164,8 @@ usbRequest_t *rq = (void *)data;
if(rq->bRequest == USBRQ_HID_GET_REPORT){
debug("GET_REPORT:");
/* we only have one report type, so don't look at wValue */
usbMsgPtr = (void *)keyboard_report_prev;
return sizeof(*keyboard_report_prev);
usbMsgPtr = (void *)keyboard_report;
return sizeof(*keyboard_report);
}else if(rq->bRequest == USBRQ_HID_GET_IDLE){
debug("GET_IDLE: ");
//debug_hex(vusb_idle_rate);