@@ -1,141 +0,0 @@ | |||
#---------------------------------------------------------------------------- | |||
# On command line: | |||
# | |||
# make all = Make software. | |||
# | |||
# make clean = Clean out built project files. | |||
# | |||
# make coff = Convert ELF to AVR COFF. | |||
# | |||
# make extcoff = Convert ELF to AVR Extended COFF. | |||
# | |||
# make program = Download the hex file to the device. | |||
# Please customize your programmer settings(PROGRAM_CMD) | |||
# | |||
# make teensy = Download the hex file to the device, using teensy_loader_cli. | |||
# (must have teensy_loader_cli installed). | |||
# | |||
# make dfu = Download the hex file to the device, using dfu-programmer (must | |||
# have dfu-programmer installed). | |||
# | |||
# make flip = Download the hex file to the device, using Atmel FLIP (must | |||
# have Atmel FLIP installed). | |||
# | |||
# make dfu-ee = Download the eeprom file to the device, using dfu-programmer | |||
# (must have dfu-programmer installed). | |||
# | |||
# make flip-ee = Download the eeprom file to the device, using Atmel FLIP | |||
# (must have Atmel FLIP installed). | |||
# | |||
# make debug = Start either simulavr or avarice as specified for debugging, | |||
# with avr-gdb or avr-insight as the front end for debugging. | |||
# | |||
# make filename.s = Just compile filename.c into the assembler code only. | |||
# | |||
# make filename.i = Create a preprocessed source file for use in submitting | |||
# bug reports to the GCC project. | |||
# | |||
# To rebuild project do "make clean" then "make all". | |||
#---------------------------------------------------------------------------- | |||
# Target file name (without extension). | |||
TARGET = hhkb_lufa | |||
# Directory common source filess exist | |||
TOP_DIR = ../.. | |||
# Directory keyboard dependent files exist | |||
TARGET_DIR = . | |||
# List C source files here. (C dependencies are automatically generated.) | |||
SRC += keymap_common.c \ | |||
matrix.c \ | |||
led.c | |||
ifdef KEYMAP | |||
SRC := keymap_$(KEYMAP).c $(SRC) | |||
else | |||
SRC := keymap_hasu.c $(SRC) | |||
endif | |||
CONFIG_H = config.h | |||
# MCU name | |||
# PJRC Teensy++ 2.0 | |||
#MCU = at90usb1286 | |||
# TMK Alt Controller or PJRC Teensy 2.0 | |||
MCU = atmega32u4 | |||
# Processor frequency. | |||
# This will define a symbol, F_CPU, in all source code files equal to the | |||
# processor frequency in Hz. You can then use this symbol in your source code to | |||
# calculate timings. Do NOT tack on a 'UL' at the end, this will be done | |||
# automatically to create a 32-bit value in your source code. | |||
# | |||
# This will be an integer division of F_USB below, as it is sourced by | |||
# F_USB after it has run through any CPU prescalers. Note that this value | |||
# does not *change* the processor frequency - it should merely be updated to | |||
# reflect the processor speed set externally so that the code can use accurate | |||
# software delays. | |||
F_CPU = 16000000 | |||
# | |||
# LUFA specific | |||
# | |||
# Target architecture (see library "Board Types" documentation). | |||
ARCH = AVR8 | |||
# Input clock frequency. | |||
# This will define a symbol, F_USB, in all source code files equal to the | |||
# input clock frequency (before any prescaling is performed) in Hz. This value may | |||
# differ from F_CPU if prescaling is used on the latter, and is required as the | |||
# raw input clock is fed directly to the PLL sections of the AVR for high speed | |||
# clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL' | |||
# at the end, this will be done automatically to create a 32-bit value in your | |||
# source code. | |||
# | |||
# If no clock division is performed on the input clock inside the AVR (via the | |||
# CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU. | |||
F_USB = $(F_CPU) | |||
# Interrupt driven control endpoint task | |||
#OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT | |||
# Boot Section Size in *bytes* | |||
# Teensy halfKay 512 | |||
# Teensy++ halfKay 1024 | |||
# Atmel DFU loader 4096 (TMK Alt Controller) | |||
# LUFA bootloader 4096 | |||
# USBaspLoader 2048 | |||
OPT_DEFS += -DBOOTLOADER_SIZE=4096 | |||
# Build Options | |||
# comment out to disable the options. | |||
# | |||
BOOTMAGIC_ENABLE = yes # Virtual DIP switch configuration | |||
MOUSEKEY_ENABLE = yes # Mouse keys | |||
EXTRAKEY_ENABLE = yes # Audio control and System control | |||
#CONSOLE_ENABLE = yes # Console for debug | |||
COMMAND_ENABLE = yes # Commands for debug and configuration | |||
NKRO_ENABLE = yes # USB Nkey Rollover | |||
KEYMAP_SECTION_ENABLE = yes # fixed address keymap for keymap editor | |||
# Search Path | |||
VPATH += $(TARGET_DIR) | |||
VPATH += $(TOP_DIR) | |||
include $(TOP_DIR)/protocol/lufa.mk | |||
include $(TOP_DIR)/common.mk | |||
include $(TOP_DIR)/rules.mk | |||
debug-on: EXTRAFLAGS += -DDEBUG -DDEBUG_ACTION | |||
debug-on: all | |||
debug-off: EXTRAFLAGS += -DNO_DEBUG -DNO_PRINT | |||
debug-off: all |
@@ -39,7 +39,7 @@ | |||
#---------------------------------------------------------------------------- | |||
# Target file name (without extension). | |||
TARGET = hhkb_lufa | |||
TARGET = hhkb_rn42 | |||
# Directory common source filess exist | |||
TOP_DIR = ../.. | |||
@@ -53,13 +53,10 @@ SRC += keymap_common.c \ | |||
matrix.c \ | |||
led.c | |||
CONFIG_H = config.h | |||
CONFIG_H = config_rn42.h | |||
# MCU name | |||
# PJRC Teensy++ 2.0 | |||
#MCU = at90usb1286 | |||
# TMK Alt Controller or PJRC Teensy 2.0 | |||
MCU = atmega32u4 | |||
# Processor frequency. | |||
@@ -121,11 +118,6 @@ COMMAND_ENABLE = yes # Commands for debug and configuration | |||
#HHKB_JP = yes # HHKB JP support | |||
ifdef HHKB_JP | |||
OPT_DEFS += -DHHKB_JP | |||
endif | |||
# | |||
# Keymap file | |||
# | |||
@@ -134,12 +126,17 @@ ifdef KEYMAP | |||
else | |||
ifdef HHKB_JP | |||
SRC := keymap_jp.c $(SRC) | |||
else | |||
SRC := keymap_hasu.c $(SRC) | |||
else | |||
SRC := keymap_hhkb.c $(SRC) | |||
endif | |||
endif | |||
ifneq (, $(or $(findstring keymap_jp.c, $(SRC)), $(findstring yes, $(HHKB_JP)))) | |||
OPT_DEFS += -DHHKB_JP | |||
endif | |||
# Search Path | |||
VPATH += $(TARGET_DIR) | |||
VPATH += $(TOP_DIR) | |||
@@ -154,4 +151,5 @@ debug-on: EXTRAFLAGS += -DDEBUG -DDEBUG_ACTION | |||
debug-on: all | |||
debug-off: EXTRAFLAGS += -DNO_DEBUG -DNO_PRINT | |||
debug-off: OPT_DEFS := $(filter-out -DCONSOLE_ENABLE,$(OPT_DEFS)) | |||
debug-off: all |
@@ -10,11 +10,17 @@ See [this thread][AltController] in geekhack.org. | |||
[AltController]: http://geekhack.org/index.php?topic=12047.0 | |||
## Update | |||
* Bluetooth module RN-42 is supported.(2015/01) | |||
* V-USB and iWRAP are no longer supported now, but still it'll works with a little fix. See not_supported directory.(2015/01) | |||
##Features | |||
* Customizable keymap | |||
* More keymap layers(more Fn keys) | |||
* Mouse keys | |||
* USB NKRO | |||
* Bluetooth(RN-42) | |||
See README of [tmk_keyboard] for more. | |||
@@ -50,8 +56,9 @@ If you use other than **TMK Alt Controller Board** set proper `MCU`, `BOOTLOADER | |||
### Build | |||
Several version of keymap are available in advance but you are recommended to define your favorite layout yourself. Just `make` with `KEYMAP` option like: | |||
$ make KEYMAP=[hasu|hhkb|spacefn|<name>] | |||
$ make -f Makefile.jp KEYMAP=[jp|<name>] # for HHKB JP | |||
$ make -f Makefile.<jp|pjrc|rn42> KEYMAP=(hasu|hhkb|spacefn|<name>) | |||
You can omit `-f` option when you use `Makefile`. `Makefile` is used for **Pro2 and Pro**, `Makefile.jp` fits for **JP** model and `Makefile.rn42` supports Bluetooth module **RN-42**. `Makefile.pjrc` uses **PJRC** as output protocol instead of **LUFA**. | |||
### Program | |||
@@ -59,13 +66,11 @@ First, push reset button on board to start bootloader. | |||
This command programs the controller with [dfu-programmer] if the tool is installed and configured properly. | |||
$ make dfu | |||
$ make -f Makefile.jp dfu # for HHKB JP | |||
$ make -f Makefile.<variant> KEYMAP=<name> dfu | |||
Or you can also use [FLIP] command to program. Also the tool should be installed and configured properly. FLIP GUI application is also available. | |||
$ make flip | |||
$ make -f Makefile.jp flip # for HHKB JP | |||
$ make -f Makefile.<variant> KEYMAP=<name> flip | |||
Use [Teensy Loader] if your controller is Teensy/Teensy++. | |||
@@ -41,17 +41,32 @@ static inline void KEY_UNABLE(void) { (PORTB |= (1<<6)); } | |||
static inline bool KEY_STATE(void) { return (PIND & (1<<7)); } | |||
static inline void KEY_PREV_ON(void) { (PORTB |= (1<<7)); } | |||
static inline void KEY_PREV_OFF(void) { (PORTB &= ~(1<<7)); } | |||
#ifdef HHKB_POWER_SAVING | |||
static inline void KEY_POWER_ON(void) { | |||
DDRB = 0xFF; PORTB = 0x40; // change pins output | |||
DDRD |= (1<<4); PORTD |= (1<<4); // MOS FET switch on | |||
/* Without this wait you will miss or get false key events. */ | |||
_delay_ms(5); // wait for powering up | |||
} | |||
static inline void KEY_POWER_OFF(void) { | |||
/* input with pull-up consumes less than without it when pin is open. */ | |||
DDRB = 0x00; PORTB = 0xFF; // change pins input with pull-up | |||
DDRD |= (1<<4); PORTD &= ~(1<<4); // MOS FET switch off | |||
} | |||
static inline bool KEY_POWER_STATE(void) { return PORTD & (1<<4); } | |||
#else | |||
static inline void KEY_POWER_ON(void) {} | |||
static inline void KEY_POWER_OFF(void) {} | |||
static inline bool KEY_POWER_STATE(void) { return true; } | |||
#endif | |||
static inline void KEY_INIT(void) | |||
{ | |||
/* row,col,prev: output */ | |||
DDRB = 0xFF; | |||
PORTB = 0x00; | |||
PORTB = 0x40; // unable | |||
/* key: input with pull-up */ | |||
DDRD &= ~0x80; | |||
PORTD |= 0x80; | |||
/* keyswitch board power on */ | |||
DDRD |= (1<<4); | |||
PORTD |= (1<<4); | |||
PORTD |= 0x80; | |||
#ifdef HHKB_JP | |||
/* row extention for HHKB JP */ | |||
DDRC |= (1<<6|1<<7); | |||
@@ -59,6 +74,8 @@ static inline void KEY_INIT(void) | |||
#endif | |||
KEY_UNABLE(); | |||
KEY_PREV_OFF(); | |||
KEY_POWER_OFF(); | |||
} | |||
static inline void KEY_SELECT(uint8_t ROW, uint8_t COL) | |||
{ | |||
@@ -98,6 +115,7 @@ static inline void KEY_SELECT(uint8_t ROW, uint8_t COL) | |||
#define KEY_PREV_OFF() (PORTE &= ~(1<<7)) | |||
#define KEY_POWER_ON() | |||
#define KEY_POWER_OFF() | |||
#define KEY_POWER_STATE() true | |||
#else |
@@ -27,8 +27,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
#include "timer.h" | |||
#include "matrix.h" | |||
#include "hhkb_avr.h" | |||
#include <avr/wdt.h> | |||
#include "suspend.h" | |||
#include "lufa.h" | |||
// matrix power saving | |||
#define MATRIX_POWER_SAVE 10000 | |||
static uint32_t matrix_last_modified = 0; | |||
// matrix state buffer(1:on, 0:off) | |||
static matrix_row_t *matrix; | |||
static matrix_row_t *matrix_prev; | |||
@@ -72,7 +79,8 @@ uint8_t matrix_scan(void) | |||
matrix_prev = matrix; | |||
matrix = tmp; | |||
KEY_POWER_ON(); | |||
// power on | |||
if (!KEY_POWER_STATE()) KEY_POWER_ON(); | |||
for (uint8_t row = 0; row < MATRIX_ROWS; row++) { | |||
for (uint8_t col = 0; col < MATRIX_COLS; col++) { | |||
KEY_SELECT(row, col); | |||
@@ -126,8 +134,16 @@ uint8_t matrix_scan(void) | |||
// This takes 25us or more to make sure KEY_STATE returns to idle state. | |||
_delay_us(75); | |||
} | |||
if (matrix[row] ^ matrix_prev[row]) matrix_last_modified = timer_read32(); | |||
} | |||
// power off | |||
if (KEY_POWER_STATE() && | |||
(USB_DeviceState == DEVICE_STATE_Suspended || | |||
USB_DeviceState == DEVICE_STATE_Unattached ) && | |||
timer_elapsed32(matrix_last_modified) > MATRIX_POWER_SAVE) { | |||
KEY_POWER_OFF(); | |||
suspend_power_down(); | |||
} | |||
KEY_POWER_OFF(); | |||
return 1; | |||
} | |||
@@ -165,3 +181,10 @@ void matrix_print(void) | |||
xprintf("%02X: %08b\n", row, bitrev(matrix_get_row(row))); | |||
} | |||
} | |||
void matrix_power_up(void) { | |||
KEY_POWER_ON(); | |||
} | |||
void matrix_power_down(void) { | |||
KEY_POWER_OFF(); | |||
} |
@@ -1,11 +1,9 @@ | |||
RN-42 | |||
===== | |||
Power Saving | |||
============ | |||
12/11 | |||
Power Comsumption | |||
MCU+HHKB | |||
-------- | |||
MCU+HHKB Power Comsumption | |||
-------------------------- | |||
Battery drive: | |||
idle 18.9mA | |||
active 35.8mA | |||
@@ -76,40 +74,3 @@ S%,1000 status led and connection control don't work | |||
GPIO5: status LED | |||
GPIO6: Connection control | |||
GPIO2: linked status | |||
Ver 6.15 04/26/2013 | |||
(c) Roving Networks | |||
***Settings*** | |||
BTA=00066667BBE9 | |||
BTName=tmkBT-BBE9 | |||
Baudrt(SW4)=115K | |||
Mode =DTR | |||
Authen=1 | |||
Bonded=0 | |||
Rem=001BDC06415B | |||
***ADVANCED Settings*** | |||
SrvName= keyboard/mouse | |||
SrvClass=0000 | |||
DevClass=1F00 | |||
InqWindw=0012 | |||
PagWindw=0012 | |||
CfgTimer=255 | |||
StatuStr=NULL | |||
HidFlags=3c | |||
DTRtimer=8 | |||
KeySwapr=0 | |||
***OTHER Settings*** | |||
Profile= HID | |||
CfgChar= $ | |||
SniffEna=8010 | |||
LowPower=0 S|, | |||
TX Power=fff4 SY, | |||
IOPorts= 0 | |||
IOValues=0 | |||
Sleeptmr=0 | |||
DebugMod=0 | |||
RoleSwch=0 |
@@ -1,166 +0,0 @@ | |||
#ifndef HHKB_AVR_H | |||
#define HHKB_AVR_H | |||
#include <stdint.h> | |||
#include <stdbool.h> | |||
#include <avr/io.h> | |||
#include <avr/interrupt.h> | |||
#include <util/delay.h> | |||
// Timer resolution check | |||
#if (1000000/TIMER_RAW_FREQ > 20) | |||
# error "Timer resolution(>20us) is not enough for HHKB matrix scan tweak on V-USB." | |||
#endif | |||
/* | |||
* HHKB Matrix I/O | |||
* | |||
* row: HC4051[A,B,C] selects scan row0-7 | |||
* row-ext: [En0,En1] row extention for JP | |||
* col: LS145[A,B,C,D] selects scan col0-7 and enable(D) | |||
* key: on: 0/off: 1 | |||
* prev: hysteresis control: assert(1) when previous key state is on | |||
*/ | |||
#if defined(__AVR_ATmega32U4__) | |||
/* | |||
* For TMK HHKB alt controller(ATMega32U4) | |||
* | |||
* row: PB0-2 | |||
* col: PB3-5,6 | |||
* key: PD7(pull-uped) | |||
* prev: PB7 | |||
* power: PD4(L:off/H:on) | |||
* row-ext: PC6,7 for HHKB JP(active low) | |||
*/ | |||
static inline void KEY_ENABLE(void) { (PORTB &= ~(1<<6)); } | |||
static inline void KEY_UNABLE(void) { (PORTB |= (1<<6)); } | |||
static inline bool KEY_STATE(void) { return (PIND & (1<<7)); } | |||
static inline void KEY_PREV_ON(void) { (PORTB |= (1<<7)); } | |||
static inline void KEY_PREV_OFF(void) { (PORTB &= ~(1<<7)); } | |||
#ifdef HHKB_POWER_SAVING | |||
static inline void KEY_POWER_ON(void) { | |||
DDRB = 0xFF; PORTB = 0x40; // change pins output | |||
DDRD |= (1<<4); PORTD |= (1<<4); // MOS FET switch on | |||
/* Without this wait you will miss or get false key events. */ | |||
_delay_ms(5); // wait for powering up | |||
} | |||
static inline void KEY_POWER_OFF(void) { | |||
/* input with pull-up consumes less than without it when pin is open. */ | |||
DDRB = 0x00; PORTB = 0xFF; // change pins input with pull-up | |||
DDRD |= (1<<4); PORTD &= ~(1<<4); // MOS FET switch off | |||
} | |||
static inline bool KEY_POWER_STATE(void) { return PORTD & (1<<4); } | |||
#else | |||
static inline void KEY_POWER_ON(void) {} | |||
static inline void KEY_POWER_OFF(void) {} | |||
static inline bool KEY_POWER_STATE(void) { return true; } | |||
#endif | |||
static inline void KEY_INIT(void) | |||
{ | |||
/* row,col,prev: output */ | |||
DDRB = 0xFF; | |||
PORTB = 0x40; // unable | |||
/* key: input with pull-up */ | |||
DDRD &= ~0x80; | |||
PORTD |= 0x80; | |||
#ifdef HHKB_JP | |||
/* row extention for HHKB JP */ | |||
DDRC |= (1<<6|1<<7); | |||
PORTC |= (1<<6|1<<7); | |||
#endif | |||
KEY_UNABLE(); | |||
KEY_PREV_OFF(); | |||
KEY_POWER_OFF(); | |||
} | |||
static inline void KEY_SELECT(uint8_t ROW, uint8_t COL) | |||
{ | |||
PORTB = (PORTB & 0xC0) | (((COL) & 0x07)<<3) | ((ROW) & 0x07); | |||
#ifdef HHKB_JP | |||
if ((ROW) & 0x08) PORTC = (PORTC & ~(1<<6|1<<7)) | (1<<6); | |||
else PORTC = (PORTC & ~(1<<6|1<<7)) | (1<<7); | |||
#endif | |||
} | |||
#elif defined(__AVR_AT90USB1286__) | |||
/* | |||
* For Teensy++(AT90USB1286) | |||
* | |||
* HHKB pro HHKB pro2 | |||
* row: PB0-2 (6-8) (5-7) | |||
* col: PB3-5,6 (9-12) (8-11) | |||
* key: PE6(pull-uped) (4) (3) | |||
* prev: PE7 (5) (4) | |||
* | |||
* TODO: convert into 'staitc inline' function | |||
*/ | |||
#define KEY_INIT() do { \ | |||
DDRB |= 0x7F; \ | |||
DDRE |= (1<<7); \ | |||
DDRE &= ~(1<<6); \ | |||
PORTE |= (1<<6); \ | |||
} while (0) | |||
#define KEY_SELECT(ROW, COL) (PORTB = (PORTB & 0xC0) | \ | |||
(((COL) & 0x07)<<3) | \ | |||
((ROW) & 0x07)) | |||
#define KEY_ENABLE() (PORTB &= ~(1<<6)) | |||
#define KEY_UNABLE() (PORTB |= (1<<6)) | |||
#define KEY_STATE() (PINE & (1<<6)) | |||
#define KEY_PREV_ON() (PORTE |= (1<<7)) | |||
#define KEY_PREV_OFF() (PORTE &= ~(1<<7)) | |||
#define KEY_POWER_ON() | |||
#define KEY_POWER_OFF() | |||
#else | |||
# error "define code for matrix scan" | |||
#endif | |||
#if 0 | |||
// For ATMega328P with V-USB | |||
// | |||
// #elif defined(__AVR_ATmega328P__) | |||
// Ports for V-USB | |||
// key: PB0(pull-uped) | |||
// prev: PB1 | |||
// row: PB2-4 | |||
// col: PC0-2,3 | |||
// power: PB5(Low:on/Hi-z:off) | |||
#define KEY_INIT() do { \ | |||
DDRB |= 0x3E; \ | |||
DDRB &= ~(1<<0); \ | |||
PORTB |= 1<<0; \ | |||
DDRC |= 0x0F; \ | |||
KEY_UNABLE(); \ | |||
KEY_PREV_OFF(); \ | |||
} while (0) | |||
#define KEY_SELECT(ROW, COL) do { \ | |||
PORTB = (PORTB & 0xE3) | ((ROW) & 0x07)<<2; \ | |||
PORTC = (PORTC & 0xF8) | ((COL) & 0x07); \ | |||
} while (0) | |||
#define KEY_ENABLE() (PORTC &= ~(1<<3)) | |||
#define KEY_UNABLE() (PORTC |= (1<<3)) | |||
#define KEY_STATE() (PINB & (1<<0)) | |||
#define KEY_PREV_ON() (PORTB |= (1<<1)) | |||
#define KEY_PREV_OFF() (PORTB &= ~(1<<1)) | |||
// Power supply switching | |||
#define KEY_POWER_ON() do { \ | |||
KEY_INIT(); \ | |||
PORTB &= ~(1<<5); \ | |||
_delay_ms(1); \ | |||
} while (0) | |||
#define KEY_POWER_OFF() do { \ | |||
DDRB &= ~0x3F; \ | |||
PORTB &= ~0x3F; \ | |||
DDRC &= ~0x0F; \ | |||
PORTC &= ~0x0F; \ | |||
} while (0) | |||
#endif | |||
#endif |
@@ -1,33 +0,0 @@ | |||
/* | |||
Copyright 2012,2013 Jun Wako <[email protected]> | |||
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 <stdint.h> | |||
#include "action.h" | |||
#include <avr/pgmspace.h> | |||
#include "keymap_common.h" | |||
/* translates key to keycode */ | |||
uint8_t keymap_key_to_keycode(uint8_t layer, keypos_t key) | |||
{ | |||
return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]); | |||
} | |||
/* translates Fn keycode to action */ | |||
action_t keymap_fn_to_action(uint8_t keycode) | |||
{ | |||
return (action_t){ .code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]) }; | |||
} |
@@ -1,84 +0,0 @@ | |||
/* | |||
Copyright 2012,2013 Jun Wako <[email protected]> | |||
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 KEYMAP_COMMON_H | |||
#define KEYMAP_COMMON_H | |||
#include <stdint.h> | |||
#include <stdbool.h> | |||
#include "keycode.h" | |||
#include "action.h" | |||
#include "action_code.h" | |||
#include "action_layer.h" | |||
#include "action_macro.h" | |||
#include "action_util.h" | |||
#include "report.h" | |||
#include "host.h" | |||
#include "print.h" | |||
#include "debug.h" | |||
#include "keymap.h" | |||
extern const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS]; | |||
extern const uint16_t fn_actions[]; | |||
#define KEYMAP( \ | |||
K31, K30, K00, K10, K11, K20, K21, K40, K41, K60, K61, K70, K71, K50, K51, \ | |||
K32, K01, K02, K13, K12, K23, K22, K42, K43, K62, K63, K73, K72, K52, \ | |||
K33, K04, K03, K14, K15, K24, K25, K45, K44, K65, K64, K74, K53, \ | |||
K34, K05, K06, K07, K16, K17, K26, K46, K66, K76, K75, K55, K54, \ | |||
K35, K36, K37, K57, K56 \ | |||
) \ | |||
{ \ | |||
{ 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 KEYMAP_JP( \ | |||
K02, K32, K62, K22, K12, K52, K72, KA2, K92, K82, KB2, KE2, KF2, KD2, KC2, \ | |||
K03, K63, K23, K13, K53, K73, KA3, K93, K83, KB3, KE3, KF3, KD3, \ | |||
K06, K66, K26, K16, K56, K76, KA6, K96, K86, KB6, KE6, KF6, KD6, KC6, \ | |||
K05, K65, K25, K15, K55, K75, KA5, K95, K85, KB5, KE5, KF5, KD5, KC5, \ | |||
K04, K34, K64, K24, K14, K74, K94, K84, KB4, KE4, KF4, KD4, KC4 \ | |||
) \ | |||
{ \ | |||
{ KC_NO, KC_NO, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##K32, KC_NO, KC_##K34, 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_NO, KC_##K52, KC_##K53, KC_NO, KC_##K55, KC_##K56, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##K62, KC_##K63, KC_##K64, KC_##K65, KC_##K66, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##K72, KC_##K73, KC_##K74, KC_##K75, KC_##K76, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##K82, KC_##K83, KC_##K84, KC_##K85, KC_##K86, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##K92, KC_##K93, KC_##K94, KC_##K95, KC_##K96, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##KA2, KC_##KA3, KC_NO, KC_##KA5, KC_##KA6, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##KB2, KC_##KB3, KC_##KB4, KC_##KB5, KC_##KB6, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##KC2, KC_NO, KC_##KC4, KC_##KC5, KC_##KC6, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##KD2, KC_##KD3, KC_##KD4, KC_##KD5, KC_##KD6, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##KE2, KC_##KE3, KC_##KE4, KC_##KE5, KC_##KE6, KC_NO }, \ | |||
{ KC_NO, KC_NO, KC_##KF2, KC_##KF3, KC_##KF4, KC_##KF5, KC_##KF6, KC_NO } \ | |||
} | |||
#endif |
@@ -1,282 +0,0 @@ | |||
/* | |||
* Hasu: my personal keymap | |||
*/ | |||
#include "keymap_common.h" | |||
#ifdef KEYMAP_SECTION_ENABLE | |||
const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] __attribute__ ((section (".keymap.keymaps"))) = { | |||
#else | |||
const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] PROGMEM = { | |||
#endif | |||
/* Layer 0: Default Layer | |||
* ,-----------------------------------------------------------. | |||
* |Esc| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =| \| `| | |||
* |-----------------------------------------------------------| | |||
* |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]|Backs| | |||
* |-----------------------------------------------------------| | |||
* |Contro| A| S| D| F| G| H| J| K| L|Fn3| '|Fn6 | | |||
* |-----------------------------------------------------------| | |||
* |Fn7 | Z| X| C| V| B| N| M| ,| .|Fn2|Shift |Fn1| | |||
* `-----------------------------------------------------------' | |||
* |Gui|Alt | Fn4 |Fn5 |Gui| | |||
* `-------------------------------------------' | |||
*/ | |||
[0] = \ | |||
KEYMAP(ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSLS,GRV, \ | |||
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,FN6, \ | |||
FN7, Z, X, C, V, B, N, M, COMM,DOT, FN2, RSFT,FN1, \ | |||
LGUI,LALT, FN4, FN5, RGUI), | |||
/* Layer 1: HHKB mode[HHKB Fn] | |||
* ,-----------------------------------------------------------. | |||
* |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del| | |||
* |-----------------------------------------------------------| | |||
* |Caps | | | | | | | |Psc|Slk|Pus|Up | |Backs| | |||
* |-----------------------------------------------------------| | |||
* |Contro|VoD|VoU|Mut| | | *| /|Hom|PgU|Lef|Rig|Enter | | |||
* |-----------------------------------------------------------| | |||
* |Shift | | | | | | +| -|End|PgD|Dow|Shift | | | |||
* `-----------------------------------------------------------' | |||
* |Gui|Alt | Space |Alt |Gui| | |||
* `-------------------------------------------' | |||
*/ | |||
[1] = \ | |||
KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ | |||
CAPS,NO, NO, NO, NO, NO, NO, NO, PSCR,SLCK,PAUS, UP, NO, BSPC, \ | |||
LCTL,VOLD,VOLU,MUTE,NO, NO, PAST,PSLS,HOME,PGUP,LEFT,RGHT,ENT, \ | |||
LSFT,NO, NO, NO, NO, NO, PPLS,PMNS,END, PGDN,DOWN,RSFT,TRNS, \ | |||
LGUI,LALT, TRNS, RALT,RGUI), | |||
/* Layer 2: Vi mode[Slash] | |||
* ,-----------------------------------------------------------. | |||
* |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del| | |||
* |-----------------------------------------------------------| | |||
* |Tab |Hom|PgD|Up |PgU|End|Hom|PgD|PgUlEnd| | | |Backs| | |||
* |-----------------------------------------------------------| | |||
* |Contro| |Lef|Dow|Rig| |Lef|Dow|Up |Rig| | |Return | | |||
* |-----------------------------------------------------------| | |||
* |Shift | | | | | |Hom|PgD|PgUlEnd|Fn0|Shift | | | |||
* `-----------------------------------------------------------' | |||
* |Gui|Alt | Space |Alt |Gui| | |||
* `-------------------------------------------' | |||
*/ | |||
[2] = \ | |||
KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ | |||
TAB, HOME,PGDN,UP, PGUP,END, HOME,PGDN,PGUP,END, NO, NO, NO, BSPC, \ | |||
LCTL,NO, LEFT,DOWN,RGHT,NO, LEFT,DOWN,UP, RGHT,NO, NO, ENT, \ | |||
LSFT,NO, NO, NO, NO, NO, HOME,PGDN,PGUP,END, FN2, RSFT,TRNS, \ | |||
LGUI,LALT, SPC, RALT,RGUI), | |||
/* Layer 3: Mouse mode(IJKL)[Semicolon] | |||
* ,-----------------------------------------------------------. | |||
* |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del| | |||
* |-----------------------------------------------------------| | |||
* |Tab | | | | | |MwL|MwD|McU|MwU|MwR|Wbk|Wfr|Alt-T| | |||
* |-----------------------------------------------------------| | |||
* |Contro| | | | | |Mb2|McL|McD|McR|Fn | |Return | | |||
* |-----------------------------------------------------------| | |||
* |Shift | | | | |Mb3|Mb2|Mb1|Mb4|Mb5| |Shift | | | |||
* `-----------------------------------------------------------' | |||
* |Gui |Alt | Mb1 |Fn |Fn | | |||
* `--------------------------------------------' | |||
* Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel | |||
*/ | |||
[3] = \ | |||
KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ | |||
FN8, NO, NO, NO, NO, NO, NO, WH_D,MS_U,WH_U,RGHT,FN9, FN10,FN8, \ | |||
LCTL,ACL0,ACL1,ACL2,ACL2,NO, NO, MS_L,MS_D,MS_R,FN3, NO, ENT, \ | |||
LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,FN9, FN10,NO, RSFT,TRNS, \ | |||
LGUI,LALT, BTN1, TRNS,TRNS), | |||
/* Layer 4: Mouse mode(IJKL)[Space] | |||
* ,-----------------------------------------------------------. | |||
* |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del| | |||
* |-----------------------------------------------------------| | |||
* |Tab | | | | | |MwL|MwD|McU|MwU|MwR|Wbk|Wfr|Alt-T| | |||
* |-----------------------------------------------------------| | |||
* |Contro| | | | | |Mb2|McL|McD|McR|Mb1| |Return | | |||
* |-----------------------------------------------------------| | |||
* |Shift | | | | |Mb3|Mb2|Mb1|Mb4|Mb5| |Shift | | | |||
* `-----------------------------------------------------------' | |||
* |Gui |Alt | Mb1 |Fn |Fn | | |||
* `--------------------------------------------' | |||
* Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel | |||
*/ | |||
[4] = \ | |||
KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ | |||
FN8, NO, NO, NO, NO, NO, NO, WH_D,MS_U,WH_U,RGHT,FN9, FN10,FN8, \ | |||
LCTL,VOLD,VOLU,MUTE,NO, NO, NO, MS_L,MS_D,MS_R,BTN1,NO, ENT, \ | |||
LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,FN9, FN10,NO, RSFT,TRNS, \ | |||
LGUI,LALT, TRNS, TRNS,TRNS), | |||
#if 0 | |||
/* Layer 3: Mouse mode(HJKL)[Semicolon] | |||
* ,-----------------------------------------------------------. | |||
* |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del| | |||
* |-----------------------------------------------------------| | |||
* |Tab | | | | | |MwL|MwD|MwU|MwR| | | |Backs| | |||
* |-----------------------------------------------------------| | |||
* |Contro| | | | | |McL|McD|McU|McR|Fn0| |Return | | |||
* |-----------------------------------------------------------| | |||
* |Shift | | | | |Mb3|Mb2|Mb1|Mb4|Mb5| |Shift | | | |||
* `-----------------------------------------------------------' | |||
* |Gui |Alt | Mb1 |Alt |Fn0| | |||
* `--------------------------------------------' | |||
* Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel | |||
*/ | |||
KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ | |||
TAB, NO, NO, NO, NO, NO, NO, WH_D,WH_U,RGHT,NO, NO, NO, BSPC, \ | |||
LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,TRNS,QUOT,ENT, \ | |||
LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,FN9, FN10,SLSH,RSFT,NO, \ | |||
LGUI,LALT, BTN1, RALT,TRNS), | |||
/* Layer4: Mouse mode(HJKL)[Space] | |||
* ,-----------------------------------------------------------. | |||
* |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del| | |||
* |-----------------------------------------------------------| | |||
* |Tab | | | | | |MwL|MwD|MwU|MwR| |Wbk|Wfr|Alt-T| | |||
* |-----------------------------------------------------------| | |||
* |Contro| | | | | |McL|McD|McU|McR|Fn0| |Return | | |||
* |-----------------------------------------------------------| | |||
* |Shift | | | | |Mb3|Mb2|Mb1|Mb4|Mb5| |Shift | | | |||
* `-----------------------------------------------------------' | |||
* |Gui |Alt | Fn0 |Alt |Fn0| | |||
* `--------------------------------------------' | |||
* Mc: Mouse Cursor / Mb: Mouse Button / Mw: Mouse Wheel | |||
*/ | |||
KEYMAP(GRV, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ | |||
FN8, NO, NO, NO, NO, NO, NO, WH_D,WH_U,RGHT,NO, FN9, FN10,FN8, \ | |||
LCTL,NO, ACL0,ACL1,ACL2,NO, MS_L,MS_D,MS_U,MS_R,BTN1,NO, ENT, \ | |||
LSFT,NO, NO, NO, NO, BTN3,BTN2,BTN1,FN9, FN10,NO, RSFT,NO, \ | |||
LGUI,LALT, TRNS, RALT,RGUI), | |||
#endif | |||
#if 0 | |||
/* Layer x: Matias half-qwerty keyboard style[Space] | |||
* ,-----------------------------------------------------------. | |||
* | -| 0| 9| 8| 7| 6| 5| 4| 3| 2| 1| | | |Esc| | |||
* |-----------------------------------------------------------| | |||
* |Backs| P| O| I| U| Y| T| R| E| W| Q| | |Tab | | |||
* |-----------------------------------------------------------| | |||
* |Contro| ;| L| K| J| H| G| F| D| S| A|Con|Control | | |||
* |-----------------------------------------------------------| | |||
* |Shift | /| .| ,| M| N| B| V| C| X| Z|Shift | | | |||
* `-----------------------------------------------------------' | |||
* |Gui |Alt | Fn0 |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, TRNS, RALT,RGUI), | |||
#endif | |||
}; | |||
/* id for user defined functions */ | |||
enum function_id { | |||
LSHIFT_LPAREN, | |||
}; | |||
enum macro_id { | |||
HELLO, | |||
VOLUP, | |||
ALT_TAB, | |||
}; | |||
/* | |||
* Fn action definition | |||
*/ | |||
#ifdef KEYMAP_SECTION_ENABLE | |||
const uint16_t fn_actions[] __attribute__ ((section (".keymap.fn_actions"))) = { | |||
#else | |||
const uint16_t fn_actions[] PROGMEM = { | |||
#endif | |||
[0] = ACTION_DEFAULT_LAYER_SET(0), // Default layer(not used) | |||
[1] = ACTION_LAYER_TAP_TOGGLE(1), // HHKB layer(toggle with 5 taps) | |||
[2] = ACTION_LAYER_TAP_KEY(2, KC_SLASH), // Cursor layer with Slash* | |||
[3] = ACTION_LAYER_TAP_KEY(3, KC_SCLN), // Mousekey layer with Semicolon* | |||
[4] = ACTION_LAYER_TAP_KEY(4, KC_SPC), // Mousekey layer with Space | |||
[5] = ACTION_LAYER_MOMENTARY(4), // Mousekey layer(IJKL) | |||
[6] = ACTION_MODS_TAP_KEY(MOD_RCTL, KC_ENT), // RControl with tap Enter | |||
[7] = ACTION_MODS_ONESHOT(MOD_LSFT), // Oneshot Shift | |||
[8] = ACTION_MACRO(ALT_TAB), // Application switching | |||
[9] = ACTION_MODS_KEY(MOD_LALT, KC_LEFT), | |||
[10] = ACTION_MODS_KEY(MOD_LALT, KC_RIGHT), | |||
// [x] = ACTION_LMOD_TAP_KEY(KC_LCTL, KC_BSPC), // LControl with tap Backspace | |||
// [x] = ACTION_LMOD_TAP_KEY(KC_LCTL, KC_ESC), // LControl with tap Esc | |||
// [x] = ACTION_FUNCTION_TAP(LSHIFT_LPAREN), // Function: LShift with tap '(' | |||
// [x] = ACTION_MACRO(HELLO), // Macro: say hello | |||
// [x] = ACTION_MACRO(VOLUP), // Macro: media key | |||
}; | |||
/* | |||
* Macro definition | |||
*/ | |||
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) | |||
{ | |||
switch (id) { | |||
case HELLO: | |||
return (record->event.pressed ? | |||
MACRO( I(0), T(H), T(E), T(L), T(L), W(255), T(O), END ) : | |||
MACRO_NONE ); | |||
case VOLUP: | |||
return (record->event.pressed ? | |||
MACRO( D(VOLU), U(VOLU), END ) : | |||
MACRO_NONE ); | |||
case ALT_TAB: | |||
return (record->event.pressed ? | |||
MACRO( D(LALT), D(TAB), END ) : | |||
MACRO( U(TAB), END )); | |||
} | |||
return MACRO_NONE; | |||
} | |||
/* | |||
* user defined action function | |||
*/ | |||
void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) | |||
{ | |||
if (record->event.pressed) dprint("P"); else dprint("R"); | |||
dprintf("%d", record->tap.count); | |||
if (record->tap.interrupted) dprint("i"); | |||
dprint("\n"); | |||
switch (id) { | |||
case LSHIFT_LPAREN: | |||
// Shift parentheses example: LShft + tap '(' | |||
// http://stevelosh.com/blog/2012/10/a-modern-space-cadet/#shift-parentheses | |||
// http://geekhack.org/index.php?topic=41989.msg1304899#msg1304899 | |||
if (record->event.pressed) { | |||
if (record->tap.count > 0 && !record->tap.interrupted) { | |||
if (record->tap.interrupted) { | |||
dprint("tap interrupted\n"); | |||
register_mods(MOD_BIT(KC_LSHIFT)); | |||
} | |||
} else { | |||
register_mods(MOD_BIT(KC_LSHIFT)); | |||
} | |||
} else { | |||
if (record->tap.count > 0 && !(record->tap.interrupted)) { | |||
add_weak_mods(MOD_BIT(KC_LSHIFT)); | |||
send_keyboard_report(); | |||
register_code(KC_9); | |||
unregister_code(KC_9); | |||
del_weak_mods(MOD_BIT(KC_LSHIFT)); | |||
send_keyboard_report(); | |||
record->tap.count = 0; // ad hoc: cancel tap | |||
} else { | |||
unregister_mods(MOD_BIT(KC_LSHIFT)); | |||
} | |||
} | |||
break; | |||
} | |||
} |
@@ -1,50 +0,0 @@ | |||
/* | |||
* HHKB JP Layout | |||
*/ | |||
#include "keymap_common.h" | |||
#ifdef KEYMAP_SECTION_ENABLE | |||
const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] __attribute__ ((section (".keymap.keymaps"))) = { | |||
#else | |||
const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS] PROGMEM = { | |||
#endif | |||
/* Layer 0: Default Layer */ | |||
KEYMAP_JP(ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, JYEN,BSPC, \ | |||
TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC, \ | |||
LCTL,A, S, D, F, G, H, J, K, L, SCLN,QUOT,BSLS,ENT, \ | |||
LSFT,Z, X, C, V, B, N, M, COMM,DOT, SLSH,RO, UP, RSFT, \ | |||
FN0, ZKHK,LGUI,LALT,MHEN, SPC, HENK,KANA,RALT,FN0, LEFT,DOWN,RGHT), | |||
/* Layer 1: HHKB mode (HHKB Fn) | |||
* ,-----------------------------------------------------------. | |||
* |Pwr| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|Ins|Del| | |||
* |-----------------------------------------------------------| | |||
* |Caps | | | | | | | |Psc|Slk|Pus|Up | | | | |||
* |------------------------------------------------------` | | |||
* | |VoD|VoU|Mut| | | *| /|Hom|PgU|Lef|Rig| | | | |||
* |-----------------------------------------------------------| | |||
* | | | | | | | +| -|End|PgD|Dow| | | | | |||
* |-----------------------------------------------------------| | |||
* | || | | | | | | | | || | | | | |||
* `-----------------------------------------------------------' | |||
*/ | |||
KEYMAP_JP(PWR, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, \ | |||
CAPS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,PSCR,SLCK,PAUS, UP, TRNS, \ | |||
TRNS,VOLD,VOLU,MUTE,TRNS,TRNS,PAST,PSLS,HOME,PGUP,LEFT,RGHT,TRNS,PENT, \ | |||
TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,PPLS,PMNS,END, PGDN,DOWN,TRNS,TRNS,TRNS, \ | |||
TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS), | |||
}; | |||
/* | |||
* Fn action definition | |||
*/ | |||
#ifdef KEYMAP_SECTION_ENABLE | |||
const uint16_t fn_actions[] __attribute__ ((section (".keymap.fn_actions"))) = { | |||
#else | |||
const uint16_t fn_actions[] PROGMEM = { | |||
#endif | |||
[0] = ACTION_LAYER_MOMENTARY(1), | |||
}; |
@@ -1,33 +0,0 @@ | |||
/* | |||
Copyright 2011 Jun Wako <[email protected]> | |||
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 <avr/io.h> | |||
#include "stdint.h" | |||
#include "led.h" | |||
/* HHKB has no LEDs */ | |||
void led_set(uint8_t usb_led) | |||
{ | |||
if (usb_led & (1<<USB_LED_CAPS_LOCK)) { | |||
DDRD |= (1<<6); | |||
PORTD |= (1<<6); | |||
} else { | |||
DDRD |= (1<<6); | |||
PORTD &= ~(1<<6); | |||
} | |||
} |
@@ -1,190 +0,0 @@ | |||
/* | |||
Copyright 2011 Jun Wako <[email protected]> | |||
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/>. | |||
*/ | |||
/* | |||
* scan matrix | |||
*/ | |||
#include <stdint.h> | |||
#include <stdbool.h> | |||
#include <util/delay.h> | |||
#include "print.h" | |||
#include "debug.h" | |||
#include "util.h" | |||
#include "timer.h" | |||
#include "matrix.h" | |||
#include "hhkb_avr.h" | |||
#include <avr/wdt.h> | |||
#include "suspend.h" | |||
#include "lufa.h" | |||
// matrix power saving | |||
#define MATRIX_POWER_SAVE 10000 | |||
static uint32_t matrix_last_modified = 0; | |||
// matrix state buffer(1:on, 0:off) | |||
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]; | |||
inline | |||
uint8_t matrix_rows(void) | |||
{ | |||
return MATRIX_ROWS; | |||
} | |||
inline | |||
uint8_t matrix_cols(void) | |||
{ | |||
return MATRIX_COLS; | |||
} | |||
void matrix_init(void) | |||
{ | |||
#ifdef DEBUG | |||
debug_enable = true; | |||
debug_keyboard = true; | |||
#endif | |||
KEY_INIT(); | |||
// initialize matrix state: all keys off | |||
for (uint8_t i=0; i < MATRIX_ROWS; i++) _matrix0[i] = 0x00; | |||
for (uint8_t i=0; i < MATRIX_ROWS; i++) _matrix1[i] = 0x00; | |||
matrix = _matrix0; | |||
matrix_prev = _matrix1; | |||
} | |||
uint8_t matrix_scan(void) | |||
{ | |||
uint8_t *tmp; | |||
tmp = matrix_prev; | |||
matrix_prev = matrix; | |||
matrix = tmp; | |||
// power on | |||
if (!KEY_POWER_STATE()) KEY_POWER_ON(); | |||
for (uint8_t row = 0; row < MATRIX_ROWS; row++) { | |||
for (uint8_t col = 0; col < MATRIX_COLS; col++) { | |||
KEY_SELECT(row, col); | |||
_delay_us(5); | |||
// Not sure this is needed. This just emulates HHKB controller's behaviour. | |||
if (matrix_prev[row] & (1<<col)) { | |||
KEY_PREV_ON(); | |||
} | |||
_delay_us(10); | |||
// NOTE: KEY_STATE is valid only in 20us after KEY_ENABLE. | |||
// If V-USB interrupts in this section we could lose 40us or so | |||
// and would read invalid value from KEY_STATE. | |||
uint8_t last = TIMER_RAW; | |||
KEY_ENABLE(); | |||
// Wait for KEY_STATE outputs its value. | |||
// 1us was ok on one HHKB, but not worked on another. | |||
// no wait doesn't work on Teensy++ with pro(1us works) | |||
// no wait does work on tmk PCB(8MHz) with pro2 | |||
// 1us wait does work on both of above | |||
// 1us wait doesn't work on tmk(16MHz) | |||
// 5us wait does work on tmk(16MHz) | |||
// 5us wait does work on tmk(16MHz/2) | |||
// 5us wait does work on tmk(8MHz) | |||
// 10us wait does work on Teensy++ with pro | |||
// 10us wait does work on 328p+iwrap with pro | |||
// 10us wait doesn't work on tmk PCB(8MHz) with pro2(very lagged scan) | |||
_delay_us(5); | |||
if (KEY_STATE()) { | |||
matrix[row] &= ~(1<<col); | |||
} else { | |||
matrix[row] |= (1<<col); | |||
} | |||
// 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]; | |||
} | |||
_delay_us(5); | |||
KEY_PREV_OFF(); | |||
KEY_UNABLE(); | |||
// NOTE: KEY_STATE keep its state in 20us after KEY_ENABLE. | |||
// This takes 25us or more to make sure KEY_STATE returns to idle state. | |||
_delay_us(75); | |||
} | |||
if (matrix[row] ^ matrix_prev[row]) matrix_last_modified = timer_read32(); | |||
} | |||
// power off | |||
if (KEY_POWER_STATE() && | |||
(USB_DeviceState == DEVICE_STATE_Suspended || | |||
USB_DeviceState == DEVICE_STATE_Unattached ) && | |||
timer_elapsed32(matrix_last_modified) > MATRIX_POWER_SAVE) { | |||
KEY_POWER_OFF(); | |||
suspend_power_down(); | |||
} | |||
return 1; | |||
} | |||
bool matrix_is_modified(void) | |||
{ | |||
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { | |||
if (matrix[i] != matrix_prev[i]) | |||
return true; | |||
} | |||
return false; | |||
} | |||
inline | |||
bool matrix_has_ghost(void) | |||
{ | |||
return false; | |||
} | |||
inline | |||
bool matrix_is_on(uint8_t row, uint8_t col) | |||
{ | |||
return (matrix[row] & (1<<col)); | |||
} | |||
inline | |||
matrix_row_t matrix_get_row(uint8_t row) | |||
{ | |||
return matrix[row]; | |||
} | |||
void matrix_print(void) | |||
{ | |||
print("\nr/c 01234567\n"); | |||
for (uint8_t row = 0; row < matrix_rows(); row++) { | |||
xprintf("%02X: %08b\n", row, bitrev(matrix_get_row(row))); | |||
} | |||
} | |||
void matrix_power_up(void) { | |||
KEY_POWER_ON(); | |||
} | |||
void matrix_power_down(void) { | |||
KEY_POWER_OFF(); | |||
} |