andrejl
/
qmk-dactyl-manuform-a
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' into promethium

master
Priyadi Iman Nurcahyo 2016-12-04 23:57:47 +07:00
parent a8e5f61805 f39e1b5dfe
commit fc80aa9974
103 changed files with 3824 additions and 591 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Dockerfile
View File

@ -25,5 +25,4 @@ ENV subproject=ez
ENV keymap=default
VOLUME /qmk
WORKDIR /qmk
CMD make clean ; make keyboard=${keyboard} subproject=${subproject} keymap=${keymap}
WORKDIR /qmk

14
build_keyboard.mk
View File

@ -131,6 +131,14 @@ ifndef CUSTOM_MATRIX
SRC += $(QUANTUM_DIR)/matrix.c
endif
ifeq ($(strip $(API_SYSEX_ENABLE)), yes)
OPT_DEFS += -DAPI_SYSEX_ENABLE
SRC += $(QUANTUM_DIR)/api/api_sysex.c
OPT_DEFS += -DAPI_ENABLE
SRC += $(QUANTUM_DIR)/api.c
MIDI_ENABLE=yes
endif
ifeq ($(strip $(MIDI_ENABLE)), yes)
OPT_DEFS += -DMIDI_ENABLE
SRC += $(QUANTUM_DIR)/process_keycode/process_midi.c
@ -174,6 +182,12 @@ ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
SRC += $(QUANTUM_DIR)/process_keycode/process_tap_dance.c
endif
ifeq ($(strip $(PRINTING_ENABLE)), yes)
OPT_DEFS += -DPRINTING_ENABLE
SRC += $(QUANTUM_DIR)/process_keycode/process_printer.c
SRC += $(TMK_DIR)/protocol/serial_uart.c
endif
ifeq ($(strip $(SERIAL_LINK_ENABLE)), yes)
SRC += $(patsubst $(QUANTUM_PATH)/%,%,$(SERIAL_SRC))
OPT_DEFS += $(SERIAL_DEFS)

1
common.mk
View File

@ -23,4 +23,5 @@ COMMON_VPATH += $(QUANTUM_PATH)
COMMON_VPATH += $(QUANTUM_PATH)/keymap_extras
COMMON_VPATH += $(QUANTUM_PATH)/audio
COMMON_VPATH += $(QUANTUM_PATH)/process_keycode
COMMON_VPATH += $(QUANTUM_PATH)/api
COMMON_VPATH += $(SERIAL_PATH)

2
keyboards/amj60/config.h
View File

@ -67,7 +67,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define RGB_DI_PIN E2
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 8 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

2
keyboards/clueboard/rev1/config.h
View File

@ -26,7 +26,7 @@
/* Underlight configuration
*/
#define RGB_DI_PIN B2
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 14 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

2
keyboards/clueboard/rev2/config.h
View File

@ -30,7 +30,7 @@
/* Underlight configuration
*/
#define RGB_DI_PIN D7
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 14 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

2
keyboards/cluecard/config.h
View File

@ -140,7 +140,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* Underlight configuration
*/
#define RGB_DI_PIN E6
//#define RGBLIGHT_TIMER
//#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 4 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

2
keyboards/cluecard/keymaps/rgb_effects/config.h
View File

@ -4,7 +4,7 @@
#include "../../config.h"
// place overrides here
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLIGHT_EFFECT_SNAKE_LENGTH 3
#define RGBLIGHT_EFFECT_KNIGHT_LENGTH 2
#define RGBLIGHT_EFFECT_KNIGHT_OFFSET 2

2
keyboards/cluepad/config.h
View File

@ -70,7 +70,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* Underlight configuration
*/
#define RGB_DI_PIN F6
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 4 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

7
keyboards/ergodox/ez/Makefile
View File

@ -1,3 +1,8 @@
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
COMMAND_ENABLE = no # Commands for debug and configuration
RGBLIGHT_ENABLE ?= yes
MIDI_ENABLE ?= yes
ifndef MAKEFILE_INCLUDED
include ../../../Makefile
endif
endif

13
keyboards/ergodox/ez/config.h
View File

@ -21,6 +21,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "../config.h"
#include "config_common.h"
/* USB Device descriptor parameter */
#define VENDOR_ID 0xFEED
#define PRODUCT_ID 0x1307
@ -39,6 +41,17 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define LED_BRIGHTNESS_LO 15
#define LED_BRIGHTNESS_HI 255
/* ws2812 RGB LED */
#define RGB_DI_PIN D7
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 15 // Number of LEDs
#define RGBLIGHT_HUE_STEP 12
#define RGBLIGHT_SAT_STEP 255
#define RGBLIGHT_VAL_STEP 12
#define RGB_MIDI
#define RGBW_BB_TWI
/* Set 0 if debouncing isn't needed */
#define DEBOUNCE 5

10
keyboards/ergodox/ez/ez.c
View File

@ -16,10 +16,10 @@ void matrix_init_kb(void) {
// unused pins - C7, D4, D5, D7, E6
// set as input with internal pull-ip enabled
DDRC &= ~(1<<7);
DDRD &= ~(1<<7 | 1<<5 | 1<<4);
DDRD &= ~(1<<5 | 1<<4);
DDRE &= ~(1<<6);
PORTC |= (1<<7);
PORTD |= (1<<7 | 1<<5 | 1<<4);
PORTD |= (1<<5 | 1<<4);
PORTE |= (1<<6);
ergodox_blink_all_leds();
@ -51,6 +51,10 @@ uint8_t init_mcp23018(void) {
mcp23018_status = 0x20;
// I2C subsystem
uint8_t sreg_prev;
sreg_prev=SREG;
cli();
if (i2c_initialized == 0) {
i2c_init(); // on pins D(1,0)
i2c_initialized++;
@ -79,6 +83,8 @@ uint8_t init_mcp23018(void) {
out:
i2c_stop();
SREG=sreg_prev;
return mcp23018_status;
}

2
keyboards/ergodox/ez/matrix.c
View File

@ -121,7 +121,7 @@ void matrix_init(void)
matrix_scan_count = 0;
#endif
matrix_init_kb();
matrix_init_quantum();
}

2
keyboards/ergodox/ez/rules.mk
View File

@ -72,6 +72,8 @@ OPT_DEFS += -DBOOTLOADER_SIZE=512
#
SLEEP_LED_ENABLE = no
API_SYSEX_ENABLE ?= yes
RGBLIGHT_ENABLE ?= yes
ifndef QUANTUM_DIR
include ../../../Makefile

2
keyboards/ergodox/infinity/rules.mk
View File

@ -63,6 +63,8 @@ VISUALIZER_ENABLE ?= no #temporarily disabled to make everything compile
LCD_ENABLE ?= yes
LED_ENABLE ?= yes
LCD_BACKLIGHT_ENABLE ?= yes
MIDI_ENABLE = no
RGBLIGHT_ENABLE = no
ifndef QUANTUM_DIR
include ../../../Makefile

9
keyboards/ergodox/keymaps/bepo/Makefile 100644
View File

@ -0,0 +1,9 @@
# Having a file like this allows you to override Makefile definitions
# for your own particular keymap
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
COMMAND_ENABLE = no # Commands for debug and configuration
ifndef QUANTUM_DIR
include ../../../../Makefile
endif

BIN
keyboards/ergodox/keymaps/bepo/bepo.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 78 KiB

After

Width:  |  Height:  |  Size: 78 KiB

335
keyboards/ergodox/keymaps/bepo/keymap.c
View File

@ -1,21 +1,23 @@
#include "ergodox.h"
#include "debug.h"
#include "action_layer.h"
#include "keymap_bepo.h"
#include "keymap_french.h"
#define BASE 0 // default layer
#define QWER 1 // qwerty compat layer
#define SQWER 2 // shifted qwerty compat layer
#define AQWER 3 // alted qwerty compat layer
#define FNAV 4 // function / navigation keys
#define NUM 5 // numeric keypad keys
#define MSE 6 // mouse keys
// keymaps
#define BEPO 0 // default layer, for bepo compatible systems
#define QW_B 1 // bepo to qwerty base compat layer, for qwerty systems
#define QW_A 2 // bepo with altgr key to qwerty compat layer
#define QW_S 3 // bepo with shift key to qwerty compat layer
#define AZ_B 4 // bepo to azerty base compat layer, for azerty systems
#define AZ_A 5 // bepo with altgr key to azerty compat layer
#define AZ_S 6 // bepo with shift key to azerty compat layer
#define FNAV 7 // function / navigation / mouse layer
#define NUMK 8 // numeric keypad layer
#define KP_00 0
#define CA_Fx 1
// macros
#define KP_00 0 // keypad "double 0"
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Keymap 0: Base layer
/* Keymap 0: default layer
*
* ,--------------------------------------------------. ,--------------------------------------------------.
* | $ | " | < | > | ( | ) |Delete| |ScroLo| @ | + | - | / | * | = |
@ -26,22 +28,22 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* |--------+------+------+------+------+------| Tab | | NumLo|------+------+------+------+------+--------|
* | E_CIRC |A_GRAV| Y | X | . | K | | | | ' | Q | G | H | F | C_CEDIL|
* `--------+------+------+------+------+-------------,-------------. ,-------------`-------------+------+------+------+------+--------'
* |QWERTY| |LSuper| LCtrl| LAlt| |Escape| L_Mse| | |Insert| | AltGr| RCtrl|RSuper|PrntSc| Pause|
* |Escape|Insert|LSuper| LCtrl| LAlt| | BEPO |QWERTY| |AZERTY| BEPO | | AltGr| RCtrl|RSuper|PrntSc| Pause|
* `----------------------------------' ,------|------|------| |------+------+------. `----------------------------------'
* | | | L_Num| | CA_Fx| | |
* | | |L_NumK| |L_NumK| | |
* | Space|LShift|------| |------|RShift|Enter |
* | | |L_FNav| |L_FNav| | |
* `--------------------' `--------------------'
*/
[BASE] = KEYMAP(
[BEPO] = KEYMAP(
// Left hand
BP_DOLLAR, BP_DQOT, BP_LGIL, BP_RGIL, BP_LPRN, BP_RPRN, KC_DEL,
BP_PERCENT, BP_B, BP_E_ACUTE, BP_P, BP_O, BP_E_GRAVE, KC_BSPC,
BP_W, BP_A, BP_U, BP_I, BP_E, BP_COMMA,
BP_ECRC, BP_A_GRAVE, BP_Y, BP_X, BP_DOT, BP_K, KC_TAB,
TG(QWER), KC_NO, KC_LGUI, KC_LCTL, KC_LALT,
KC_ESC, MO(MSE),
MO(NUM),
KC_ESC, KC_INS, KC_LGUI, KC_LCTL, KC_LALT,
DF(BEPO), DF(QW_B),
MO(NUMK),
KC_SPC, KC_LSHIFT, MO(FNAV),
// Right hand
KC_SLCK, BP_AT, BP_PLUS, BP_MINUS, BP_SLASH, BP_ASTR, BP_EQUAL,
@ -49,10 +51,10 @@ TG(QWER), KC_NO, KC_LGUI, KC_LCTL, KC_LALT,
BP_C, BP_T, BP_S, BP_R, BP_N, BP_M,
KC_NUMLOCK, BP_APOS, BP_Q, BP_G, BP_H, BP_F, BP_CCED,
BP_ALGR, KC_RCTL, KC_RGUI, KC_PSCREEN, KC_PAUSE,
KC_NO, KC_INS,
M(CA_Fx),
DF(AZ_B), DF(BEPO),
MO(NUMK),
MO(FNAV), KC_RSHIFT, KC_ENTER),
/* Keymap 1: QWERTY system compatibility layer
/* Keymap 1: bepo to qwerty base compat layer
*
* ,--------------------------------------------------. ,--------------------------------------------------.
* | $ | " | < | > | ( | ) |Delete| |ScroLo| @ | + | - | / | * | = |
@ -63,33 +65,70 @@ MO(FNAV), KC_RSHIFT, KC_ENTER),
* |--------+------+------+------+------+------| Tab | | NumLo|------+------+------+------+------+--------|
* | e | a | y | x | . | k | | | | ' | q | g | h | f | c |
* `--------+------+------+------+------+-------------,-------------. ,-------------`-------------+------+------+------+------+--------'
* | BEPO | |LSuper| LCtrl| LAlt| |Escape| L_Mse| | |Insert| | AltGr| RCtrl|RSuper|PrntSc| Pause|
* |Escape|Insert|LSuper| LCtrl| LAlt| | BEPO |QWERTY| |AZERTY| BEPO | | AltGr| RCtrl|RSuper|PrntSc| Pause|
* `----------------------------------' ,------|------|------| |------+------+------. `----------------------------------'
* | | | L_Num| | | | |
* | | |L_NumK| |L_NumK| | |
* | Space|LShift|------| |------|RShift|Enter |
* | | |L_FNav| |L_FNav| | |
* `--------------------' `--------------------'
*/
[QWER] = KEYMAP(
[QW_B] = KEYMAP(
// Left hand
KC_DOLLAR, S(KC_QUOT), S(KC_COMM), S(KC_DOT), KC_LPRN, KC_RPRN, KC_DEL,
KC_PERCENT, KC_B, KC_E, KC_P, KC_O, KC_E, KC_BSPC,
KC_W, KC_A, KC_U, KC_I, KC_E, KC_COMMA,
KC_E, KC_A, KC_Y, KC_X, KC_DOT, KC_K, KC_TAB,
KC_TRNS, KC_NO, KC_LGUI, KC_LCTL, KC_LALT,
KC_ESC, MO(MSE),
MO(NUM),
KC_SPC, MO(SQWER), MO(FNAV),
KC_ESC, KC_INS, KC_LGUI, KC_LCTL, KC_LALT,
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_SPC, MO(QW_S), KC_TRNS,
// Right hand
KC_SLCK, KC_AT, KC_PLUS, KC_MINUS, KC_SLASH, KC_ASTR, KC_EQUAL,
KC_CAPSLOCK, KC_CIRC, KC_V, KC_D, KC_L, KC_J, KC_Z,
KC_C, KC_T, KC_S, KC_R, KC_N, KC_M,
KC_NUMLOCK, KC_QUOT, KC_Q, KC_G, KC_H, KC_F, KC_C,
MO(AQWER), KC_RCTL, KC_RGUI, KC_PSCREEN, KC_PAUSE,
KC_NO, KC_INS,
MO(QW_A), KC_RCTL, KC_RGUI, KC_PSCREEN, KC_PAUSE,
KC_TRNS, KC_TRNS,
KC_TRNS,
MO(FNAV), MO(SQWER), KC_ENTER),
/* Keymap 2: QWERTY shifted system compatibility layer
KC_TRNS, MO(QW_S), KC_ENTER),
/* Keymap 2: bepo with altgr key to qwerty compat layer
*
* ,--------------------------------------------------. ,--------------------------------------------------.
* | $ | " | < | > | [ | ] |Delete| |ScroLo| @ | + | - | / | * | = |
* |--------+------+------+------+------+-------------| |------+------+------+------+------+------+--------|
* | % | | | e | & | o | e |Backsp| |CapsLo| ^ | v | d | l | j | z |
* |--------+------+------+------+------+------| ace | | |------+------+------+------+------+--------|
* | w | a | u | i | € | , |------| |------| c | t | s | r | n | m |
* |--------+------+------+------+------+------| Tab | | NumLo|------+------+------+------+------+--------|
* | e | \ | { | } | . | ~ | | | | ' | q | g | h | f | c |
* `--------+------+------+------+------+-------------,-------------. ,-------------`-------------+------+------+------+------+--------'
* |Escape|Insert|LSuper| LCtrl| LAlt| | BEPO |QWERTY| |AZERTY| BEPO | | AltGr| RCtrl|RSuper|PrntSc| Pause|
* `----------------------------------' ,------|------|------| |------+------+------. `----------------------------------'
* | | |L_NumK| |L_NumK| | |
* | _ |LShift|------| |------|RShift|Enter |
* | | |L_FNav| |L_FNav| | |
* `--------------------' `--------------------'
*/
[QW_A] = KEYMAP(
// Left hand
KC_DOLLAR, S(KC_QUOT), S(KC_COMM), S(KC_DOT), KC_LBRC, KC_RBRC, KC_DEL,
KC_PERCENT, KC_PIPE, KC_E, KC_AMPR, KC_O, KC_E, KC_BSPC,
KC_W, KC_A, KC_U, KC_I, RALT(KC_5), KC_COMMA,
KC_E, KC_BSLASH, KC_LCBR, KC_RCBR, KC_DOT, KC_TILDE, KC_TAB,
KC_ESC, KC_INS, KC_LGUI, KC_LCTL, KC_LALT,
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_UNDS, MO(QW_S), KC_TRNS,
// Right hand
KC_SLCK, KC_AT, KC_PLUS, KC_MINUS, KC_SLASH, KC_ASTR, KC_EQUAL,
KC_CAPSLOCK, KC_CIRC, KC_V, KC_D, KC_L, KC_J, KC_Z,
KC_C, KC_T, KC_S, KC_R, KC_N, KC_M,
KC_NUMLOCK, KC_QUOT, KC_Q, KC_G, KC_H, KC_F, KC_C,
KC_TRNS, KC_RCTL, KC_RGUI, KC_PSCREEN, KC_PAUSE,
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_TRNS, MO(QW_S), KC_ENTER),
/* Keymap 3: bepo with shift key to qwerty compat layer
*
* ,--------------------------------------------------. ,--------------------------------------------------.
* | # | 1 | 2 | 3 | 4 | 5 |Delete| |ScroLo| 6 | 7 | 8 | 9 | 0 | = |
@ -100,20 +139,20 @@ MO(FNAV), MO(SQWER), KC_ENTER),
* |--------+------+------+------+------+------| Tab | | NumLo|------+------+------+------+------+--------|
* | E | A | Y | X | : | K | | | | ? | Q | G | H | F | C |
* `--------+------+------+------+------+-------------,-------------. ,-------------`-------------+------+------+------+------+--------'
* | BEPO | |LSuper| LCtrl| LAlt| |Escape| L_Mse| | |Insert| | AltGr| RCtrl|RSuper|PrntSc| Pause|
* |Escape|Insert|LSuper| LCtrl| LAlt| | BEPO |QWERTY| |AZERTY| BEPO | | AltGr| RCtrl|RSuper|PrntSc| Pause|
* `----------------------------------' ,------|------|------| |------+------+------. `----------------------------------'
* | | | L_Num| | | | |
* | | |L_NumK| |L_NumK| | |
* | Space|LShift|------| |------|RShift|Enter |
* | | |L_FNav| |L_FNav| | |
* `--------------------' `--------------------'
*/
[SQWER] = KEYMAP(
[QW_S] = KEYMAP(
// Left hand
KC_HASH, KC_1, KC_2, KC_3, KC_4, KC_5, KC_TRNS,
KC_GRV, S(KC_B), S(KC_E), S(KC_P), S(KC_O), S(KC_E), KC_TRNS,
S(KC_W), S(KC_A), S(KC_U), S(KC_I), S(KC_E), KC_SCOLON,
S(KC_E), S(KC_A), S(KC_Y), S(KC_X), KC_COLON, S(KC_K), S(KC_TAB),
KC_TRNS, KC_TRNS, S(KC_LGUI), S(KC_LCTL), S(KC_LALT),
S(KC_ESC), S(KC_INS), S(KC_LGUI), S(KC_LCTL), S(KC_LALT),
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_TRNS, KC_TRNS, KC_TRNS,
@ -126,51 +165,125 @@ KC_TRNS, KC_TRNS, S(KC_LGUI), S(KC_LCTL), S(KC_LALT),
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_TRNS, KC_TRNS, KC_TRNS),
/* Keymap 3: QWERTY alted system compatibility layer
/* Keymap 4: bepo to azerty base compat layer
*
* ,--------------------------------------------------. ,--------------------------------------------------.
* | $ | " | < | > | ( | ) |Delete| |ScroLo| @ | + | - | / | * | = |
* |--------+------+------+------+------+-------------| |------+------+------+------+------+------+--------|
* | % | b |e_acut| p | o |e_grav|Backsp| |CapsLo| ^ | v | d | l | j | z |
* |--------+------+------+------+------+------| ace | | |------+------+------+------+------+--------|
* | w | a | u | i | e | , |------| |------| c | t | s | r | n | m |
* |--------+------+------+------+------+------| Tab | | NumLo|------+------+------+------+------+--------|
* | e |a_grav| y | x | . | k | | | | ' | q | g | h | f | c_cedil|
* `--------+------+------+------+------+-------------,-------------. ,-------------`-------------+------+------+------+------+--------'
* |Escape|Insert|LSuper| LCtrl| LAlt| | BEPO |QWERTY| |AZERTY| BEPO | | AltGr| RCtrl|RSuper|PrntSc| Pause|
* `----------------------------------' ,------|------|------| |------+------+------. `----------------------------------'
* | | |L_NumK| |L_NumK| | |
* | Space|LShift|------| |------|RShift|Enter |
* | | |L_FNav| |L_FNav| | |
* `--------------------' `--------------------'
*/
[AZ_B] = KEYMAP(
// Left hand
FR_DLR, FR_QUOT, FR_LESS, FR_GRTR, FR_LPRN, FR_RPRN, KC_DEL,
FR_PERC, KC_B, FR_EACU, KC_P, KC_O, FR_EGRV, KC_BSPC,
FR_W, FR_A, KC_U, KC_I, KC_E, FR_COMM,
KC_E, FR_AGRV, KC_Y, KC_X, FR_DOT, KC_K, KC_TAB,
KC_ESC, KC_INS, KC_LGUI, KC_LCTL, KC_LALT,
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_SPC, MO(AZ_S), KC_TRNS,
// Right hand
KC_SLCK, FR_AT, FR_PLUS, FR_MINS, FR_SLSH, FR_ASTR, FR_EQL,
KC_CAPSLOCK, KC_LBRC, KC_V, KC_D, KC_L, KC_J, FR_Z,
KC_C, KC_T, KC_S, KC_R, KC_N, FR_M,
KC_NUMLOCK, FR_APOS, FR_Q, KC_G, KC_H, KC_F, FR_CCED,
MO(AZ_A), KC_RCTL, KC_RGUI, KC_PSCREEN, KC_PAUSE,
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_TRNS, MO(AZ_S), KC_ENTER),
/* Keymap 5: bepo with altgr key to azerty compat layer
*
* ,--------------------------------------------------. ,--------------------------------------------------.
* | $ | " | < | > | [ | ] |Delete| |ScroLo| @ | + | - | / | * | = |
* |--------+------+------+------+------+-------------| |------+------+------+------+------+------+--------|
* | % | | | e | & | o | e |Backsp| |CapsLo| ^ | v | d | l | j | z |
* |--------+------+------+------+------+------| ace | | |------+------+------+------+------+--------|
* | w | a | u | i | € | , |------| |------| c | t | s | r | n | m |
* | w | a |u_grav| trem | € | , |------| |------| c | t | s | r | n | m |
* |--------+------+------+------+------+------| Tab | | NumLo|------+------+------+------+------+--------|
* | e | \ | { | } | . | ~ | | | | ' | q | g | h | f | c |
* | / | \ | { | } | . | ~ | | | | ' | q | g | h | f | c |
* `--------+------+------+------+------+-------------,-------------. ,-------------`-------------+------+------+------+------+--------'
* | BEPO | |LSuper| LCtrl| LAlt| |Escape| L_Mse| | |Insert| | AltGr| RCtrl|RSuper|PrntSc| Pause|
* |Escape|Insert|LSuper| LCtrl| LAlt| | BEPO |QWERTY| |AZERTY| BEPO | | AltGr| RCtrl|RSuper|PrntSc| Pause|
* `----------------------------------' ,------|------|------| |------+------+------. `----------------------------------'
* | | | L_Num| | | | |
* | | |L_NumK| |L_NumK| | |
* | _ |LShift|------| |------|RShift|Enter |
* | | |L_FNav| |L_FNav| | |
* `--------------------' `--------------------'
*/
[AQWER] = KEYMAP(
[AZ_A] = KEYMAP(
// Left hand
KC_DOLLAR, S(KC_QUOT), S(KC_COMM), S(KC_DOT), KC_LBRC, KC_RBRC, KC_DEL,
KC_PERCENT, KC_PIPE, KC_E, KC_AMPR, KC_O, KC_E, KC_BSPC,
KC_W, KC_A, KC_U, KC_I, RALT(KC_5), KC_COMMA,
KC_E, KC_BSLASH, KC_LCBR, KC_RCBR, KC_DOT, KC_TILDE, KC_TAB,
KC_TRNS, KC_NO, KC_LGUI, KC_LCTL, KC_LALT,
KC_ESC, MO(MSE),
MO(NUM),
KC_UNDS, MO(SQWER), MO(FNAV),
FR_DLR, FR_QUOT, FR_LESS, FR_GRTR, FR_LBRC, FR_RBRC, KC_DEL,
FR_PERC, FR_PIPE, FR_EACU, FR_AMP, KC_O, FR_EGRV, KC_BSPC,
FR_W, FR_A, FR_UGRV, S(KC_LBRC), FR_EURO, FR_COMM,
FR_SLSH, FR_BSLS, FR_LCBR, FR_RCBR, FR_DOT, FR_TILD, KC_TAB,
KC_ESC, KC_INS, KC_LGUI, KC_LCTL, KC_LALT,
KC_TRNS, KC_TRNS,
KC_TRNS,
FR_UNDS, MO(AZ_S), KC_TRNS,
// Right hand
KC_SLCK, KC_AT, KC_PLUS, KC_MINUS, KC_SLASH, KC_ASTR, KC_EQUAL,
KC_CAPSLOCK, KC_CIRC, KC_V, KC_D, KC_L, KC_J, KC_Z,
KC_C, KC_T, KC_S, KC_R, KC_N, KC_M,
KC_NUMLOCK, KC_QUOT, KC_Q, KC_G, KC_H, KC_F, KC_C,
KC_SLCK, FR_AT, FR_PLUS, FR_MINS, FR_SLSH, FR_ASTR, FR_EQL,
KC_CAPSLOCK, KC_LBRC, KC_V, KC_D, KC_L, KC_J, FR_Z,
KC_C, KC_T, KC_S, KC_R, KC_N, FR_M,
KC_NUMLOCK, FR_APOS, FR_Q, KC_G, KC_H, KC_F, FR_CCED,
KC_TRNS, KC_RCTL, KC_RGUI, KC_PSCREEN, KC_PAUSE,
KC_NO, KC_INS,
KC_TRNS, KC_TRNS,
KC_TRNS,
MO(FNAV), MO(SQWER), KC_ENTER),
/* Keymap 4: function / navigation layer
KC_TRNS, MO(AZ_S), KC_ENTER),
/* Keymap 6: bepo with shift key to azerty compat layer
*
* ,--------------------------------------------------. ,--------------------------------------------------.
* | # | 1 | 2 | 3 | 4 | 5 |Delete| |ScroLo| 6 | 7 | 8 | 9 | 0 | ° |
* |--------+------+------+------+------+-------------| |------+------+------+------+------+------+--------|
* | ` | B | E | P | O | E |Backsp| |CapsLo| ! | V | D | L | J | Z |
* |--------+------+------+------+------+------| ace | | |------+------+------+------+------+--------|
* | W | A | U | I | E | ; |------| |------| C | T | S | R | N | M |
* |--------+------+------+------+------+------| Tab | | NumLo|------+------+------+------+------+--------|
* | E | A | Y | X | : | K | | | | ? | Q | G | H | F | C |
* `--------+------+------+------+------+-------------,-------------. ,-------------`-------------+------+------+------+------+--------'
* |Escape|Insert|LSuper| LCtrl| LAlt| | BEPO |QWERTY| |AZERTY| BEPO | | AltGr| RCtrl|RSuper|PrntSc| Pause|
* `----------------------------------' ,------|------|------| |------+------+------. `----------------------------------'
* | | |L_NumK| |L_NumK| | |
* | Space|LShift|------| |------|RShift|Enter |
* | | |L_FNav| |L_FNav| | |
* `--------------------' `--------------------'
*/
[AZ_S] = KEYMAP(
// Left hand
FR_HASH, FR_1, FR_2, FR_3, FR_4, FR_5, KC_TRNS,
FR_GRV, S(KC_B), S(KC_E), S(KC_P), S(KC_O), S(KC_E), KC_TRNS,
S(FR_W), S(FR_A), S(KC_U), S(KC_I), S(KC_E), FR_SCLN,
S(KC_E), S(FR_A), S(KC_Y), S(KC_X), FR_COLN, S(KC_K), S(KC_TAB),
S(KC_ESC), S(KC_INS), S(KC_LGUI), S(KC_LCTL), S(KC_LALT),
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_TRNS, KC_TRNS, KC_TRNS,
// Right hand
KC_TRNS, FR_6, FR_7, FR_8, FR_9, FR_0, FR_OVRR,
KC_TRNS, FR_EXLM, S(KC_V), S(KC_D), S(KC_L), S(KC_J), S(FR_Z),
S(KC_C), S(KC_T), S(KC_S), S(KC_R), S(KC_N), S(FR_M),
KC_TRNS, FR_QUES, S(FR_Q), S(KC_G), S(KC_H), S(KC_F), S(KC_C),
S(KC_RALT), S(KC_RCTL), S(KC_RGUI), KC_TRNS, KC_TRNS,
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_TRNS, KC_TRNS, KC_TRNS),
/* Keymap 7: function / navigation / mouse layer
*
* ,--------------------------------------------------. ,--------------------------------------------------.
* | | F1 | F2 | F3 | F4 | F5 |VolMut| | | F6 | F7 | F8 | F9 | F10 | |
* |--------+------+------+------+------+-------------| |------+------+------+------+------+------+--------|
* | | | | | | |VolDwn| | | PgUp | Home | Up | End | F11 | |
* | | Next |LClick| Up |RClick| WhUp |VolDwn| | | PgUp | Home | Up | End | F11 | |
* |--------+------+------+------+------+------| | | |------+------+------+------+------+--------|
* | | | | | | |------| |------| PgDn | Left | Down | Right| F12 | |
* | | Prev | Left | Down | Right|WhDown|------| |------| PgDn | Left | Down | Right| F12 | |
* |--------+------+------+------+------+------| VolUp| | |------+------+------+------+------+--------|
* | | Undo | Cut | Copy | Paste| | | | | | | | | | |
* `--------+------+------+------+------+-------------,-------------. ,-------------`-------------+------+------+------+------+--------'
@ -184,12 +297,12 @@ MO(FNAV), MO(SQWER), KC_ENTER),
[FNAV] = KEYMAP(
// Left hand
KC_NO, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_MUTE,
KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_VOLU,
KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
KC_NO, KC_MS_BTN5, KC_MS_BTN1, KC_MS_UP, KC_MS_BTN2, KC_MS_WH_UP, KC_VOLU,
KC_NO, KC_MS_BTN4, KC_MS_LEFT, KC_MS_DOWN, KC_MS_RIGHT, KC_MS_WH_DOWN,
KC_NO, KC_UNDO, KC_CUT, KC_COPY, KC_PASTE, KC_NO, KC_VOLD,
KC_NO, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS,
KC_NO, KC_NO,
KC_NO,
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_NO, KC_TRNS, KC_TRNS,
// Right hand
KC_NO, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_NO,
@ -197,91 +310,52 @@ KC_NO, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS,
KC_PGDOWN, KC_LEFT, KC_DOWN, KC_RIGHT, KC_F12, KC_NO,
KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_NO,
KC_NO, KC_NO,
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_TRNS, KC_TRNS, KC_NO),
/* Keymap 5: numeric layer, sends keypad codes
/* Keymap 8: numeric keypad layer, sends keypad codes
*
* ,--------------------------------------------------. ,--------------------------------------------------.
* | | | | | | | | | | | + | - | / | * | |
* | | | | | | | | | | | NumLo| / | * | - | |
* |--------+------+------+------+------+-------------| |------+------+------+------+------+------+--------|
* | | | | | | | | | | | 7 | 8 | 9 | | |
* | | | | | | | | | | | 7 | 8 | 9 | + | |
* |--------+------+------+------+------+------| | | |------+------+------+------+------+--------|
* | | | | | | |------| |------| | 4 | 5 | 6 | | |
* | | | | | | |------| |------| | 4 | 5 | 6 | + | |
* |--------+------+------+------+------+------| | | |------+------+------+------+------+--------|
* | | | | | | | | | | | 1 | 2 | 3 | | |
* | | | | | | | | | | | 1 | 2 | 3 | Enter| |
* `--------+------+------+------+------+-------------,-------------. ,-------------`-------------+------+------+------+------+--------'
* | | | | | | | | | | | | | 0 | 00 | . | | |
* `----------------------------------' ,------|------|------| |------+------+------. `----------------------------------'
* | | | | | | | |
* | | |------| |------| | Enter|
* | | | | | | | |
* `--------------------' `--------------------'
*/
[NUM] = KEYMAP(
// Left hand
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_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_NO,
KC_NO, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS,
KC_NO, KC_NO,
KC_TRNS,
KC_NO, KC_TRNS, KC_NO,
// Right hand
KC_NO, KC_NO, KC_KP_PLUS, KC_KP_MINUS, KC_KP_SLASH, KC_KP_ASTERISK, KC_NO,
KC_NO, KC_NO, KC_KP_7, KC_KP_8, KC_KP_9, KC_NO, KC_NO,
KC_NO, KC_KP_4, KC_KP_5, KC_KP_6, KC_NO, KC_NO,
KC_NO, KC_NO, KC_KP_1, KC_KP_2, KC_KP_3, KC_NO, KC_NO,
KC_KP_0, M(KP_00), KC_KP_COMMA, KC_NO, KC_NO,
KC_NO, KC_NO,
KC_NO,
KC_NO, KC_TRNS, KC_KP_ENTER),
/* Keymap 6: mouse layer
*
* ,--------------------------------------------------. ,--------------------------------------------------.
* | | | | | | | | | | | | | | | |
* |--------+------+------+------+------+-------------| |------+------+------+------+------+------+--------|
* | | | | | | | | | | |LClick| Up |RClick| WhUp | |
* |--------+------+------+------+------+------| | | |------+------+------+------+------+--------|
* | | | | | | |------| |------| | Left | Down | Right|WhDown| |
* |--------+------+------+------+------+------| | | |------+------+------+------+------+--------|
* | | | | | | | | | | | | | | | |
* `--------+------+------+------+------+-------------,-------------. ,-------------`-------------+------+------+------+------+--------'
* | | | | | | | | | | | | | | | | | |
* | | | | | | | | | | | | | 0 | 00 | . | Enter| |
* `----------------------------------' ,------|------|------| |------+------+------. `----------------------------------'
* | | | | | | | |
* | | |------| |------| | |
* | | | | | | | |
* `--------------------' `--------------------'
*/
[MSE] = KEYMAP(
[NUMK] = KEYMAP(
// Left hand
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_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_NO,
KC_NO, KC_NO, KC_TRNS, KC_TRNS, KC_TRNS,
KC_NO, KC_TRNS,
KC_NO,
KC_NO, KC_TRNS, KC_NO,
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_NO, KC_TRNS, KC_TRNS,
// Right hand
KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
KC_NO, KC_NO, KC_MS_BTN1, KC_MS_UP, KC_MS_BTN2, KC_MS_WH_UP, KC_NO,
KC_NO, KC_MS_LEFT, KC_MS_DOWN, KC_MS_RIGHT, KC_MS_WH_DOWN, KC_NO,
KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
KC_TRNS, KC_TRNS, KC_TRNS, KC_NO, KC_NO,
KC_NO, KC_NO,
KC_NO,
KC_NO, KC_TRNS, KC_NO)
};
const uint16_t PROGMEM fn_actions[] = {
KC_NO, KC_NO, KC_NUMLOCK, KC_KP_SLASH, KC_KP_ASTERISK, KC_KP_MINUS, KC_NO,
KC_NO, KC_NO, KC_KP_7, KC_KP_8, KC_KP_9, KC_KP_PLUS, KC_NO,
KC_NO, KC_KP_4, KC_KP_5, KC_KP_6, KC_KP_PLUS, KC_NO,
KC_NO, KC_NO, KC_KP_1, KC_KP_2, KC_KP_3, KC_KP_ENTER, KC_NO,
KC_KP_0, M(KP_00), KC_KP_COMMA, KC_KP_ENTER, KC_NO,
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_TRNS, KC_TRNS, KC_NO)
};
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
{
switch(id) {
// keypad "double 0"
case KP_00:
if (record->event.pressed) {
return MACRO( T(KP_0), D(KP_0), END );
@ -289,23 +363,6 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
return MACRO( U(KP_0), END );
}
break;
case CA_Fx:
if (record->event.pressed) {
layer_on(FNAV);
return MACRO( D(LALT), D(LCTL), END );
} else {
layer_off(FNAV);
return MACRO( U(LCTL), U(LALT), END );
}
break;
}
return MACRO_NONE;
};
// Runs just one time when the keyboard initializes.
void matrix_init_user(void) {
};
// Runs constantly in the background, in a loop.
void matrix_scan_user(void) {
};

6
keyboards/ergodox/keymaps/bepo/readme.md
View File

@ -23,12 +23,12 @@ La touche "Tab" est placée comme sur la TypeMatrix 2020.
Meilleure symétrie et accessibilité que la TypeMatrix 2030 : les touches "W" et "%" ont dû être déplacées du côté gauche en raison du nombre de touches de l'ErgoDox, mais l'auriculaire droit ne gère maintenant que deux colonnes de touches au lieu de trois. La touche "Ê" redevient accessible sur la même rangée que les autres lettres, comme sur un clavier classique en disposition bépo. Les lettres, chiffres et symboles sont tous regroupés sur 4 lignes et 6 colonnes pour chaque main, et la première rangée de lettres à la main gauche conserve une identité visuelle "BÉPO".
Touche de fonction permettant de saisir les touches F1 à F12, les touches F1 à F10 sont placées de façon logique par rapport aux chiffres 1 à 0. Cette même touche permet l'accès aux touches directionnelles sans déplacer la main droite. Les touches "Home" et "End" sont placées de la même façon que sur une TypeMatrix 2030 par rapport aux touches directionnelles. Les touches "Page Up" et "Page Down" sont également accessibles facilement sans déplacer la main droite. Les fonctions "VolUp" et "VolDown" sont placées comme sur la TypeMatrix 2030, avec la fonction "Mute" juste au dessus. Les fonctions "Undo", "Cut", "Copy" et "Paste" sont placées côte à côte comme elles le seraient sur un clavier QWERTY en combinaison avec la touche "Ctrl" (à l'emplacement des lettres "Z", "X", "C" et "V"). Par rapport au layout "SpaceFN", l'utilisation d'une touche de fonction dédiée au pouce permet de ne pas ajouter de latence, et la touche espace reste compatible avec les jeux (action au moment de l'appui et possibilité d'appui long).
Touche de fonction permettant de saisir les touches F1 à F12, les touches F1 à F10 sont placées de façon logique par rapport aux chiffres 1 à 0. Cette même touche permet l'accès aux touches directionnelles sans déplacer la main droite et d'effectuer des actions souris avec uniquement la main gauche. Les touches "Home" et "End" sont placées de la même façon que sur une TypeMatrix 2030 par rapport aux touches directionnelles. Les touches "Page Up" et "Page Down" sont également accessibles facilement sans déplacer la main droite. Les fonctions "VolUp" et "VolDown" sont placées comme sur la TypeMatrix 2030, avec la fonction "Mute" juste au dessus. Les fonctions "Undo", "Cut", "Copy" et "Paste" sont placées côte à côte comme elles le seraient sur un clavier QWERTY en combinaison avec la touche "Ctrl" (à l'emplacement des lettres "Z", "X", "C" et "V"). Par rapport au layout "SpaceFN", l'utilisation d'une touche de fonction dédiée au pouce permet de ne pas ajouter de latence, et la touche espace reste compatible avec les jeux (action au moment de l'appui et possibilité d'appui long).
Touche de fonction permettant l'accès au pavé numérique comme sur la TypeMatrix 2030, mais sans avoir à déplacer la main droite : avec les doigts sur la rangée de repos, possibilité de saisir les chiffres "4", "5" et "6" comme sur un pavé numérique classique. Le double "0" de la TypeMatrix a été conservé, et gagne une possibilité de répétition en simples "0".
L'appui sur une touche permet de basculer en mode BEPO sur un système configuré pour un clavier QWERTY. Cette compatibilité n'est pas parfaite (pas encore de gestion des accents mais ça devrait être faisable avec une disposition en qwerty international, et les combinaisons de touches ne sont pas toutes supportées puisque le clavier traduit déjà certaines touches en combinaisons) mais reste pratique pour une saisie de texte occasionnelle.
Touche permettant de basculer en mode BEPO sur un système configuré pour un clavier QWERTY. Cette compatibilité n'est pas parfaite (pas encore de gestion des accents mais ça devrait être faisable avec une disposition en qwerty international, et les combinaisons de touches ne sont pas toutes supportées puisque le clavier traduit déjà certaines touches en combinaisons) mais reste pratique pour une saisie de texte occasionnelle et pour des accès BIOS ou console en QWERTY.
TODO : couche de compatibilité pour utiliser la disposition BÉPO sur un système configuré pour un clavier AZERTY.
Touche permettant de basculer en mode BEPO sur un système configuré pour un clavier AZERTY. Cette compatibilité n'est pas parfaite (pas de gestion des caractères non présents sur le clavier AZERTY, et les combinaisons de touches ne sont pas toutes supportées puisque le clavier traduit déjà certaines touches en combinaisons) mais reste pratique pour une saisie de texte occasionnelle et pour faire du bureau à distance vers un système Windows sans BEPO.
> Olivier Smedts <olivier@gid0.org>

2
keyboards/ergodox/keymaps/erez_experimental/Makefile
View File

@ -3,6 +3,8 @@
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
COMMAND_ENABLE = no # Commands for debug and configuration
RGBLIGHT_ENABLE ?= yes
MIDI_ENABLE ?= yes
ifndef QUANTUM_DIR
include ../../../../Makefile

1
keyboards/ergodox/keymaps/erez_experimental/config.h
View File

@ -8,5 +8,6 @@
#undef LEADER_TIMEOUT
#define LEADER_TIMEOUT 300
#endif

42
keyboards/ergodox/keymaps/erez_experimental/keymap.c
View File

@ -7,6 +7,12 @@
#define SYMB 1 // symbols
#define MDIA 2 // media keys
enum custom_keycodes {
PLACEHOLDER = SAFE_RANGE, // can always be here
RGB_FF00BB // always start with RGB_
};
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Keymap 0: Basic layer
*
@ -65,33 +71,33 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* | | | |NxtTab|PrvTab| | | | | | |
* `----------------------------------' `----------------------------------'
* ,-------------. ,-------------.
* | | | | | |
* | | | |TOG |
* ,------|------|------| |------+------+------.
* | | | | | | | |
* |VAI |VAD |HUI | |SAI |TOG |MOD |
* | | |------| |------| | |
* | | | | | | | |
* | | |HUD | |SAD | | |
* `--------------------' `--------------------'
*/
// SYMBOLS
[SYMB] = KEYMAP(
// left hand
KC_TRNS, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_TRNS,
RGB_FF00BB, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_TRNS,
KC_TRNS, KC_TRNS,KC_TRNS,KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
KC_TRNS, KC_1, KC_2, KC_3, KC_4, KC_5,
KC_TRNS, KC_6, KC_7, KC_8, KC_9, KC_0, KC_TRNS,
KC_TRNS, KC_TRNS,KC_TRNS,LCTL(KC_PGUP), LCTL(KC_PGDN),
KC_TRNS,KC_TRNS,
KC_TRNS,
KC_TRNS,KC_TRNS,KC_TRNS,
RGB_HUI,
RGB_VAI,RGB_VAD,RGB_HUD,
// right hand
KC_TRNS, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11,
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_F12,
KC_AMPR, KC_UNDS, KC_MINS, CM_SCLN, KC_PLUS, KC_TRNS,
KC_TRNS, KC_PIPE, KC_AT, KC_EQL, KC_PERC, KC_TRNS, KC_TRNS,
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
KC_TRNS, KC_TRNS,
KC_TRNS,
KC_TRNS, KC_TRNS, KC_TRNS
RGB_TOG, KC_TRNS,
RGB_SAI,
RGB_SAD, KC_TRNS, RGB_MOD
),
/* Keymap 2: Media and mouse keys
*
@ -152,6 +158,24 @@ void matrix_init_user(void) {
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
// dynamically generate these.
case RGB_FF00BB:
if (record->event.pressed) {
#ifdef RGBLIGHT_ENABLE
rgblight_enable();
rgblight_mode(1);
rgblight_setrgb(0xff,0x00,0xbb);
#endif
}
return false;
break;
}
return true;
}
LEADER_EXTERNS();
// Runs constantly in the background, in a loop.

6
keyboards/ergodox/keymaps/jack/Makefile 100644
View File

@ -0,0 +1,6 @@
RGBLIGHT_ENABLE ?= yes
MIDI_ENABLE ?= yes
ifndef QUANTUM_DIR
include ../../../../Makefile
endif

17
keyboards/ergodox/keymaps/jack/config.h 100644
View File

@ -0,0 +1,17 @@
#ifndef CONFIG_USER_H
#define CONFIG_USER_H
#include "../../config.h"
/* ws2812 RGB LED */
#define RGB_DI_PIN D7
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 15 // Number of LEDs
#define RGBLIGHT_HUE_STEP 12
#define RGBLIGHT_SAT_STEP 255
#define RGBLIGHT_VAL_STEP 12
#define RGB_MIDI
#define RGBW_BB_TWI
#endif

22
keyboards/ergodox/keymaps/jack/keymap.c
View File

@ -19,14 +19,14 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
KC_HOME,
KC_SPC,KC_SPC,KC_END,
// right hand
KC_NO, KC_6, KC_7, KC_8, KC_9, KC_0, KC_NO,
KC_NO, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC,
KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,
KC_NO, M(1), KC_7, KC_8, KC_9, KC_0, KC_NO,
KC_NO, RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, KC_P, KC_BSPC,
RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD, KC_SCLN, KC_QUOT,
KC_NO, KC_N, KC_M, KC_COMM,KC_DOT, KC_SLSH, KC_ENT,
MO(1), KC_LEFT,KC_DOWN,KC_UP, KC_RGHT,
KC_NO, KC_NO,
KC_PGUP,
KC_PGDN, KC_SPC,KC_SPC
RGB_TOG, RGB_HUI,
RGB_MOD,
M(2), KC_SPC,KC_SPC
),
[SYMB] = KEYMAP(
// left hand
@ -84,6 +84,16 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
unregister_code(KC_RSFT);
}
break;
case 1:
if (record->event.pressed) { // For resetting EEPROM
eeconfig_init();
}
break;
case 2:
if (record->event.pressed) { // For resetting EEPROM
api_send_unicode(0x0CA0);
}
break;
}
return MACRO_NONE;
};

79
keyboards/ergodox/keymaps/kristian/keymap.c 100644
View File

@ -0,0 +1,79 @@
#include "ergodox.h"
#include "debug.h"
#include "action_layer.h"
#include "version.h"
#include "keymap_fr_ch.h"
#include "keymap_french.h"
#include "keymap_german.h"
#include "keymap_german_ch.h"
#include "keymap_nordic.h"
#include "keymap_norwegian.h"
#include "keymap_spanish.h"
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[0] = KEYMAP(NO_LESS,KC_1,KC_2,KC_3,KC_4,KC_5,KC_BSPACE,KC_TAB,KC_Q,KC_W,KC_E,KC_R,KC_T,TG(1),KC_BSPACE,KC_A,KC_S,KC_D,KC_F,KC_G,SFT_T(NO_APOS),CTL_T(KC_Z),KC_X,KC_C,KC_V,KC_B,SFT_T(KC_EQUAL),MO(1),CTL_T(KC_GRAVE),KC_LGUI,KC_LEFT,KC_RIGHT,KC_ESCAPE,KC_CAPSLOCK,KC_HOME,KC_SPACE,KC_LGUI,KC_LALT,KC_DELETE,KC_6,KC_7,KC_8,KC_9,KC_0,NO_PLUS,TG(1),KC_Y,KC_U,KC_I,KC_O,KC_P,NO_AM,KC_H,KC_J,KC_K,KC_L,LT(2,NO_OSLH),NO_AE,SFT_T(KC_RBRC),KC_N,KC_M,KC_COMMA,KC_DOT,CTL_T(KC_SLASH),SFT_T(NO_APOS),KC_DOWN,KC_UP,NO_LPRN,NO_RPRN,MO(1),NO_QUOT,CTL_T(KC_ESCAPE),NO_APOS,KC_LALT,KC_LGUI,KC_ENTER),
[1] = KEYMAP(M(0),KC_F1,KC_F2,KC_F3,KC_F4,KC_F5,KC_BSPACE,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_BSPACE,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_LSHIFT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_LCTL,KC_LGUI,KC_LEFT,KC_RIGHT,KC_ESCAPE,KC_TRANSPARENT,KC_HOME,KC_SPACE,KC_LGUI,KC_LALT,KC_DELETE,KC_F6,KC_F7,KC_F8,KC_F9,KC_F10,KC_F11,KC_TRANSPARENT,KC_7,KC_8,KC_9,KC_TRANSPARENT,KC_TRANSPARENT,KC_F12,KC_4,KC_5,KC_6,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_0,KC_1,KC_2,KC_3,NO_LBRC,NO_RBRC,KC_LSHIFT,KC_COMMA,KC_DOT,LSFT(NO_LBRC),LSFT(NO_RBRC),KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_LALT,KC_LGUI,KC_ENTER),
[2] = KEYMAP(KC_ESCAPE,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_MS_UP,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_MS_LEFT,KC_MS_DOWN,KC_MS_RIGHT,KC_TRANSPARENT,KC_LSHIFT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_LCTL,KC_LALT,KC_LGUI,KC_MS_BTN1,KC_MS_BTN2,KC_ESCAPE,KC_TRANSPARENT,KC_TRANSPARENT,KC_SPACE,KC_LGUI,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_MEDIA_PREV_TRACK,KC_MEDIA_PLAY_PAUSE,KC_MEDIA_NEXT_TRACK,KC_TRANSPARENT,KC_TRANSPARENT,KC_AUDIO_VOL_UP,KC_AUDIO_VOL_DOWN,KC_AUDIO_MUTE,KC_TRANSPARENT,KC_TRANSPARENT,KC_TRANSPARENT,KC_ESCAPE,KC_MS_WH_UP,KC_MS_WH_DOWN,KC_MS_ACCEL0,KC_MS_ACCEL1),
};
const uint16_t PROGMEM fn_actions[] = {
[1] = ACTION_LAYER_TAP_TOGGLE(1)
};
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
{
switch(id) {
case 0:
if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
}
break;
}
return MACRO_NONE;
};
void matrix_scan_user(void) {
uint8_t layer = biton32(layer_state);
ergodox_board_led_off();
ergodox_right_led_1_off();
ergodox_right_led_2_off();
ergodox_right_led_3_off();
switch (layer) {
case 1:
ergodox_right_led_1_on();
break;
case 2:
ergodox_right_led_2_on();
break;
case 3:
ergodox_right_led_3_on();
break;
case 4:
ergodox_right_led_1_on();
ergodox_right_led_2_on();
break;
case 5:
ergodox_right_led_1_on();
ergodox_right_led_3_on();
break;
case 6:
ergodox_right_led_2_on();
ergodox_right_led_3_on();
break;
case 7:
ergodox_right_led_1_on();
ergodox_right_led_2_on();
ergodox_right_led_3_on();
break;
default:
break;
}
};

151
keyboards/ergodox/keymaps/robot_test_layout/keymap.c 100644
View File

@ -0,0 +1,151 @@
#include "ergodox.h"
#include "debug.h"
#include "action_layer.h"
#include "version.h"
enum custom_keycodes {
PLACEHOLDER = SAFE_RANGE, // can always be here
RGB_FF0000,
RGB_00FF00,
RGB_0000FF,
RGB_FFFFFF,
RGB_TOGGLE,
LED1,
LED2,
LED3
};
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[0] = KEYMAP(
RGB_TOGGLE, RGB_FF0000, RGB_00FF00, RGB_0000FF, RGB_FFFFFF, KC_5, KC_LPRN,
KC_GRAVE, KC_A, KC_B, KC_C, KC_D, KC_E, KC_EXLM,
KC_HASH, KC_J, KC_K, KC_L, KC_M, KC_N,
KC_AMPR, KC_T, KC_U, KC_V, KC_W, KC_X, KC_DLR,
KC_PIPE, KC_R, KC_PLUS, KC_LCBR, KC_RCBR,
KC_F, KC_G,
KC_H,
KC_P, KC_O, KC_I,
// RIGHT HAND
KC_RPRN, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS,
KC_AT, KC_F, KC_G, KC_H, KC_I, KC_COLN, KC_BSLS,
KC_O, KC_P, KC_Q, KC_R, KC_S, KC_QUOT,
LSFT(KC_COMM), KC_Y, KC_Z, KC_COMM, KC_DOT, KC_SLSH, KC_ASTR,
KC_A, KC_B, KC_C, KC_D, KC_PIPE,
LED1, KC_E,
LED2,
LED3, KC_J, KC_K
)
};
const uint16_t PROGMEM fn_actions[] = {
[1] = ACTION_LAYER_TAP_TOGGLE(1)
};
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
{
switch(id) {
case 0:
if (record->event.pressed) {
SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
}
break;
}
return MACRO_NONE;
};
bool status_led1_on = false, status_led2_on = false, status_led3_on = false;
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
// dynamically generate these.
case RGB_FF0000:
if (record->event.pressed) {
#ifdef RGBLIGHT_ENABLE
EZ_RGB(0xff0000);
register_code(KC_1); unregister_code(KC_1);
#endif
}
return false;
break;
case RGB_00FF00:
if (record->event.pressed) {
#ifdef RGBLIGHT_ENABLE
EZ_RGB(0x00ff00);
register_code(KC_2); unregister_code(KC_2);
#endif
}
return false;
break;
case RGB_0000FF:
if (record->event.pressed) {
#ifdef RGBLIGHT_ENABLE
EZ_RGB(0x0000ff);
register_code(KC_3); unregister_code(KC_3);
#endif
}
return false;
break;
case RGB_FFFFFF:
if (record->event.pressed) {
#ifdef RGBLIGHT_ENABLE
EZ_RGB(0xffffff);
register_code(KC_4); unregister_code(KC_4);
#endif
}
return false;
break;
case RGB_TOGGLE:
if (record->event.pressed) {
#ifdef RGBLIGHT_ENABLE
rgblight_toggle();
register_code(KC_EQL); unregister_code(KC_EQL);
#endif
}
return false;
break;
case LED1:
if (record->event.pressed) {
if(status_led1_on) {
ergodox_right_led_1_off();
status_led1_on = false;
} else {
ergodox_right_led_1_on();
status_led1_on = true;
}
}
return false;
break;
case LED2:
if (record->event.pressed) {
if(status_led2_on) {
ergodox_right_led_2_off();
status_led2_on = false;
} else {
ergodox_right_led_2_on();
status_led2_on = true;
}
}
return false;
break;
case LED3:
if (record->event.pressed) {
if(status_led3_on) {
ergodox_right_led_3_off();
status_led3_on = false;
} else {
ergodox_right_led_3_on();
status_led3_on = true;
}
}
return false;
break;
}
return true;
}

5
keyboards/ergodox/keymaps/robot_test_layout/readme.md 100644
View File

@ -0,0 +1,5 @@
# Robot test layout
Use this layout if you like to pretend you're [Norman](https://www.youtube.com/watch?v=-sbxFBay-tg), the ErgoDox EZ manufacturing robot.
It's really meant just for internal use, but we're posting it on GitHub anyway, because hurray to open source. :)

1
keyboards/ergodox/rules.mk
View File

@ -24,6 +24,5 @@ COMMAND_ENABLE ?= yes # Commands for debug and configuration
CUSTOM_MATRIX ?= yes # Custom matrix file for the ErgoDox EZ
SLEEP_LED_ENABLE ?= yes # Breathing sleep LED during USB suspend
NKRO_ENABLE ?= yes # USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
MIDI_ENABLE ?= no # MIDI controls
UNICODE_ENABLE ?= yes # Unicode
ONEHAND_ENABLE ?= yes # Allow swapping hands of keyboard

2
keyboards/gh60/keymaps/robotmaxtron/config.h
View File

@ -182,7 +182,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define ws2812_pin PF4
*/
#define RGB_DI_PIN F4
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 8 // Number of LEDs
#define RGBLIGHT_HUE_STEP 8
#define RGBLIGHT_SAT_STEP 8

2
keyboards/handwired/minorca/keymaps/rgb/config.h
View File

@ -11,7 +11,7 @@
/* ws2812 RGB LED */
#define RGB_DI_PIN D5
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 13 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

2
keyboards/jd40/config.h
View File

@ -70,7 +70,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
)
#define RGB_DI_PIN D3
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 12 // Number of LEDs
#define RGBLIGHT_HUE_STEP 8
#define RGBLIGHT_SAT_STEP 8

2
keyboards/kc60/keymaps/ws2812/config.h
View File

@ -2,7 +2,7 @@
/* WS2812B RGB Underglow LED */
#define RGB_DI_PIN F5 // Based on wiring depicted in ws2812_wiring.jpg
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 16 // Number of LEDs. Change this to match your use case.
#define RGBLIGHT_HUE_STEP 8
#define RGBLIGHT_SAT_STEP 8

3
keyboards/lets_split/config.h
View File

@ -49,6 +49,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define IS_COMMAND() ( \
keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
)
/* disable debug print */
//#define NO_DEBUG
@ -68,4 +69,4 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifdef SUBPROJECT_rev2
#include "rev2/config.h"
#endif
#endif
#endif

2
keyboards/lets_split/keymaps/i2c/config.h
View File

@ -75,7 +75,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* ws2812 RGB LED */
#define RGB_DI_PIN D4
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 8 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

2
keyboards/lets_split/keymaps/serial/config.h
View File

@ -75,7 +75,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* ws2812 RGB LED */
#define RGB_DI_PIN D4
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 8 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

2
keyboards/phantom/config.h
View File

@ -63,7 +63,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* Underlight configuration
*/
#define RGB_DI_PIN E2
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 20 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

4
keyboards/planck/keymaps/bone2planck/Makefile
View File

@ -1,4 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
# change to "no" to disable the options, or define them in the Makefile in

4
keyboards/planck/keymaps/brandon/Makefile
View File

@ -1,4 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
# change to "no" to disable the options, or define them in the Makefile in

7
keyboards/planck/keymaps/cbbrowne/Makefile
View File

@ -5,8 +5,8 @@
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
MOUSEKEY_ENABLE = no # Mouse keys(+4700)
EXTRAKEY_ENABLE = no # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = yes # Commands for debug and configuration
NKRO_ENABLE = yes # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
@ -16,10 +16,11 @@ AUDIO_ENABLE = yes # Audio output on port C6
UNICODE_ENABLE = no # Unicode
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight. Do not enable this with audio at the same time.
API_SYSEX_ENABLE = yes # Enable SYSEX API (+5390)
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifndef QUANTUM_DIR
include ../../../../Makefile
endif
endif

3
keyboards/planck/keymaps/cbbrowne/config.h
View File

@ -1,6 +1,9 @@
#ifndef CONFIG_USER_H
#define CONFIG_USER_H
#define NO_DEBUG
#define NO_PRINT
#include "../../config.h"
#define LEADER_TIMEOUT 300

10
keyboards/planck/keymaps/cbbrowne/keymap.c
View File

@ -62,6 +62,7 @@
- How about Alt-F1 thru Alt-F8?
- What's the keystroke to get from X to console these days?
- A layer for doing console switching would not be a bad idea
- I haven't got page-up/page-down, let's have that...
*/
enum layers {
@ -94,6 +95,7 @@ enum macro_id {
#define SHIFTQUOTE MT(MOD_RSFT, KC_QUOT)
#define ALTRIGHT MT(MOD_LALT, KC_RGHT)
#define MVERSION M(M_VERSION)
#define ALTSLASH LALT(KC_SLSH)
/* Note that Planck has dimensions 4 rows x 12 columns */
@ -109,14 +111,14 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_RAISE] = { /* RAISE */
{KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC},
{_______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS},
{_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, QWERTY, KEYPAD, KEYPAD, RESET, _______},
{_______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
{_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, QWERTY, KEYPAD, KEYPAD, ALTSLASH,_______},
{_______, _______, _______, _______, _______, _______, _______, _______, KC_PGDN, KC_VOLD, KC_VOLU, KC_PGUP}
},
[_LOWER] = { /* LOWER */
{KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC},
{_______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE},
{_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, QWERTY, KEYPAD, KEYPAD, RESET, _______},
{_______, KEYPAD, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
{_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, QWERTY, KEYPAD, KEYPAD, ALTSLASH, _______},
{_______, KEYPAD, _______, _______, _______, _______, _______, _______, KC_PGDN, KC_VOLD, KC_VOLU, KC_PGUP}
},
[_KEYPAD] = { /* Key Pad */
{KC_ESC, USERNAME, MVERSION, KC_F10, KC_F11, KC_F12, KC_PGUP, KC_KP_ENTER, KC_7, KC_8, KC_9, KC_BSPC},

8
keyboards/planck/keymaps/default/Makefile
View File

@ -5,17 +5,17 @@
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
MOUSEKEY_ENABLE = no # Mouse keys(+4700)
EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = yes # Commands for debug and configuration
COMMAND_ENABLE = no # Commands for debug and configuration
NKRO_ENABLE = yes # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality
MIDI_ENABLE = no # MIDI controls
MIDI_ENABLE = yes # MIDI controls
AUDIO_ENABLE = yes # Audio output on port C6
UNICODE_ENABLE = no # Unicode
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight. Do not enable this with audio at the same time.
RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend

4
keyboards/planck/keymaps/default/keymap.c
View File

@ -107,7 +107,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_LOWER] = {
{KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC},
{KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE},
{_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,S(KC_NUHS),S(KC_NUBS),_______, _______, _______},
{_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,S(KC_NUHS),S(KC_NUBS),KC_HOME, KC_END, _______},
{_______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
},
@ -125,7 +125,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_RAISE] = {
{KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC},
{KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS},
{_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NUHS, KC_NUBS, _______, _______, _______},
{_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NUHS, KC_NUBS, KC_PGUP, KC_PGDN, _______},
{_______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
},

2
keyboards/planck/keymaps/experimental/config.h
View File

@ -9,7 +9,7 @@
/* ws2812 RGB LED */
#define RGB_DI_PIN B1
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 8 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

4
keyboards/planck/keymaps/impossible/Makefile
View File

@ -1,4 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
# change to "no" to disable the options, or define them in the Makefile in

4
keyboards/planck/keymaps/jeebak/Makefile
View File

@ -1,4 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
# change to "no" to disable the options, or define them in the Makefile in

4
keyboards/planck/keymaps/jhenahan/Makefile
View File

@ -1,4 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
# change to "no" to disable the options, or define them in the Makefile in

5
keyboards/planck/keymaps/joe/Makefile
View File

@ -1,3 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
@ -22,4 +25,4 @@ SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifndef QUANTUM_DIR
include ../../../../Makefile
endif
endif

5
keyboards/planck/keymaps/leo/Makefile
View File

@ -1,3 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
@ -22,4 +25,4 @@ SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifndef QUANTUM_DIR
include ../../../../Makefile
endif
endif

5
keyboards/planck/keymaps/lucas/Makefile
View File

@ -1,3 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
@ -22,4 +25,4 @@ SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifndef QUANTUM_DIR
include ../../../../Makefile
endif
endif

5
keyboards/planck/keymaps/mollat/Makefile
View File

@ -1,3 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
@ -22,4 +25,4 @@ SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifndef QUANTUM_DIR
include ../../../../Makefile
endif
endif

5
keyboards/planck/keymaps/nico/Makefile
View File

@ -1,3 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
@ -22,4 +25,4 @@ SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifndef QUANTUM_DIR
include ../../../../Makefile
endif
endif

3
keyboards/planck/keymaps/premek/Makefile
View File

@ -1,3 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options

3
keyboards/planck/keymaps/priyadi/Makefile
View File

@ -1,3 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options

5
keyboards/planck/keymaps/pvc/Makefile
View File

@ -1,3 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
# change to "no" to disable the options, or define them in the Makefile in
@ -21,4 +24,4 @@ SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifndef QUANTUM_DIR
include ../../../../Makefile
endif
endif

5
keyboards/planck/keymaps/sgoodwin/Makefile
View File

@ -1,3 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
@ -22,4 +25,4 @@ SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifndef QUANTUM_DIR
include ../../../../Makefile
endif
endif

5
keyboards/planck/keymaps/tak3over/Makefile
View File

@ -1,3 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
@ -22,4 +25,4 @@ SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifndef QUANTUM_DIR
include ../../../../Makefile
endif
endif

29
keyboards/planck/keymaps/thermal_printer/Makefile 100644
View File

@ -0,0 +1,29 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options
# change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = yes # Commands for debug and configuration
NKRO_ENABLE = yes # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality
MIDI_ENABLE = no # MIDI controls
AUDIO_ENABLE = yes # Audio output on port C6
UNICODE_ENABLE = no # Unicode
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight. Do not enable this with audio at the same time.
PRINTING_ENABLE = yes
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifndef QUANTUM_DIR
include ../../../../Makefile
endif

23
keyboards/planck/keymaps/thermal_printer/config.h 100644
View File

@ -0,0 +1,23 @@
#ifndef CONFIG_USER_H
#define CONFIG_USER_H
#include "../../config.h"
# define SERIAL_UART_BAUD 19200
# define SERIAL_UART_DATA UDR1
# define SERIAL_UART_UBRR (F_CPU / (16UL * SERIAL_UART_BAUD) - 1)
# define SERIAL_UART_RXD_VECT USART1_RX_vect
# define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1))
# define SERIAL_UART_INIT() do { \
/* baud rate */ \
UBRR1L = SERIAL_UART_UBRR; \
/* baud rate */ \
UBRR1H = SERIAL_UART_UBRR >> 8; \
/* enable TX */ \
UCSR1B = _BV(TXEN1); \
/* 8-bit data */ \
UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \
sei(); \
} while(0)
#endif

314
keyboards/planck/keymaps/thermal_printer/keymap.c 100644
View File

@ -0,0 +1,314 @@
// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
// this is the style you want to emulate.
#include "planck.h"
#include "action_layer.h"
#ifdef AUDIO_ENABLE
#include "audio.h"
#endif
#include "eeconfig.h"
extern keymap_config_t keymap_config;
// Each layer gets a name for readability, which is then used in the keymap matrix below.
// The underscores don't mean anything - you can have a layer called STUFF or any other name.
// Layer names don't all need to be of the same length, obviously, and you can also skip them
// entirely and just use numbers.
#define _QWERTY 0
#define _COLEMAK 1
#define _DVORAK 2
#define _LOWER 3
#define _RAISE 4
#define _PLOVER 5
#define _ADJUST 16
enum planck_keycodes {
QWERTY = SAFE_RANGE,
COLEMAK,
DVORAK,
PLOVER,
LOWER,
RAISE,
BACKLIT,
EXT_PLV
};
// Fillers to make layering more clear
#define _______ KC_TRNS
#define XXXXXXX KC_NO
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Qwerty
* ,-----------------------------------------------------------------------------------.
* | Tab | Q | W | E | R | T | Y | U | I | O | P | Bksp |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | Esc | A | S | D | F | G | H | J | K | L | ; | " |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | N | M | , | . | / |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Brite| Ctrl | Alt | GUI |Lower | Space |Raise | Left | Down | Up |Right |
* `-----------------------------------------------------------------------------------'
*/
[_QWERTY] = {
{KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC},
{KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT},
{KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT },
{BACKLIT, KC_LCTL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT}
},
/* Colemak
* ,-----------------------------------------------------------------------------------.
* | Tab | Q | W | F | P | G | J | L | U | Y | ; | Bksp |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | Esc | A | R | S | T | D | H | N | E | I | O | " |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | K | M | , | . | / |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Brite| Ctrl | Alt | GUI |Lower | Space |Raise | Left | Down | Up |Right |
* `-----------------------------------------------------------------------------------'
*/
[_COLEMAK] = {
{KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSPC},
{KC_ESC, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT},
{KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT },
{BACKLIT, KC_LCTL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT}
},
/* Dvorak
* ,-----------------------------------------------------------------------------------.
* | Tab | " | , | . | P | Y | F | G | C | R | L | Bksp |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | Esc | A | O | E | U | I | D | H | T | N | S | / |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | Shift| ; | Q | J | K | X | B | M | W | V | Z |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Brite| Ctrl | Alt | GUI |Lower | Space |Raise | Left | Down | Up |Right |
* `-----------------------------------------------------------------------------------'
*/
[_DVORAK] = {
{KC_TAB, KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y, KC_F, KC_G, KC_C, KC_R, KC_L, KC_BSPC},
{KC_ESC, KC_A, KC_O, KC_E, KC_U, KC_I, KC_D, KC_H, KC_T, KC_N, KC_S, KC_SLSH},
{KC_LSFT, KC_SCLN, KC_Q, KC_J, KC_K, KC_X, KC_B, KC_M, KC_W, KC_V, KC_Z, KC_ENT },
{BACKLIT, KC_LCTL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT}
},
/* Lower
* ,-----------------------------------------------------------------------------------.
* | ~ | ! | @ | # | $ | % | ^ | & | * | ( | ) | Bksp |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | Del | F1 | F2 | F3 | F4 | F5 | F6 | _ | + | { | } | | |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | | F7 | F8 | F9 | F10 | F11 | F12 |ISO ~ |ISO | | | |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | | | | | | Next | Vol- | Vol+ | Play |
* `-----------------------------------------------------------------------------------'
*/
[_LOWER] = {
{KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC},
{KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE},
{_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,S(KC_NUHS),S(KC_NUBS),_______, _______, _______},
{_______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
},
/* Raise
* ,-----------------------------------------------------------------------------------.
* | ` | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | Bksp |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | Del | F1 | F2 | F3 | F4 | F5 | F6 | - | = | [ | ] | \ |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | | F7 | F8 | F9 | F10 | F11 | F12 |ISO # |ISO / | | |Enter |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | | | | | | Next | Vol- | Vol+ | Play |
* `-----------------------------------------------------------------------------------'
*/
[_RAISE] = {
{KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC},
{KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS},
{_______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NUHS, KC_NUBS, _______, _______, _______},
{_______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY}
},
/* Plover layer (http://opensteno.org)
* ,-----------------------------------------------------------------------------------.
* | # | # | # | # | # | # | # | # | # | # | # | # |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | | S | T | P | H | * | * | F | P | L | T | D |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* |TogOut| S | K | W | R | * | * | R | B | G | S | Z |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Exit | | | A | O | | E | U | | | |
* `-----------------------------------------------------------------------------------'
*/
[_PLOVER] = {
{KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1, KC_1 },
{XXXXXXX, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC},
{XXXXXXX, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT},
{EXT_PLV, XXXXXXX, XXXXXXX, KC_C, KC_V, XXXXXXX, XXXXXXX, KC_N, KC_M, XXXXXXX, XXXXXXX, XXXXXXX}
},
/* Adjust (Lower + Raise)
* ,-----------------------------------------------------------------------------------.
* | | Reset| | Print|no prnt | | | | | | | Del |
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | | | |Aud on|Audoff|AGnorm|AGswap|Qwerty|Colemk|Dvorak|Plover| |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | |Voice-|Voice+|Mus on|Musoff|MIDIon|MIDIof| | | | | |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | | | | | | | | | |
* `-----------------------------------------------------------------------------------'
*/
[_ADJUST] = {
{_______, RESET, _______, PRINT_ON, PRINT_OFF, _______, _______, _______, _______, _______, _______, KC_DEL},
{_______, _______, _______, AU_ON, AU_OFF, AG_NORM, AG_SWAP, QWERTY, COLEMAK, DVORAK, PLOVER, _______},
{_______, MUV_DE, MUV_IN, MU_ON, MU_OFF, MI_ON, MI_OFF, _______, _______, _______, _______, _______},
{_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______}
}
};
#ifdef AUDIO_ENABLE
float tone_startup[][2] = SONG(STARTUP_SOUND);
float tone_qwerty[][2] = SONG(QWERTY_SOUND);
float tone_dvorak[][2] = SONG(DVORAK_SOUND);
float tone_colemak[][2] = SONG(COLEMAK_SOUND);
float tone_plover[][2] = SONG(PLOVER_SOUND);
float tone_plover_gb[][2] = SONG(PLOVER_GOODBYE_SOUND);
float music_scale[][2] = SONG(MUSIC_SCALE_SOUND);
float tone_goodbye[][2] = SONG(GOODBYE_SOUND);
#endif
void persistant_default_layer_set(uint16_t default_layer) {
eeconfig_update_default_layer(default_layer);
default_layer_set(default_layer);
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
#ifdef AUDIO_ENABLE
PLAY_NOTE_ARRAY(tone_qwerty, false, 0);
#endif
persistant_default_layer_set(1UL<<_QWERTY);
}
return false;
break;
case COLEMAK:
if (record->event.pressed) {
#ifdef AUDIO_ENABLE
PLAY_NOTE_ARRAY(tone_colemak, false, 0);
#endif
persistant_default_layer_set(1UL<<_COLEMAK);
}
return false;
break;
case DVORAK:
if (record->event.pressed) {
#ifdef AUDIO_ENABLE
PLAY_NOTE_ARRAY(tone_dvorak, false, 0);
#endif
persistant_default_layer_set(1UL<<_DVORAK);
}
return false;
break;
case LOWER:
if (record->event.pressed) {
layer_on(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
case RAISE:
if (record->event.pressed) {
layer_on(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
case BACKLIT:
if (record->event.pressed) {
register_code(KC_RSFT);
#ifdef BACKLIGHT_ENABLE
backlight_step();
#endif
} else {
unregister_code(KC_RSFT);
}
return false;
break;
case PLOVER:
if (record->event.pressed) {
#ifdef AUDIO_ENABLE
stop_all_notes();
PLAY_NOTE_ARRAY(tone_plover, false, 0);
#endif
layer_off(_RAISE);
layer_off(_LOWER);
layer_off(_ADJUST);
layer_on(_PLOVER);
if (!eeconfig_is_enabled()) {
eeconfig_init();
}
keymap_config.raw = eeconfig_read_keymap();
keymap_config.nkro = 1;
eeconfig_update_keymap(keymap_config.raw);
}
return false;
break;
case EXT_PLV:
if (record->event.pressed) {
#ifdef AUDIO_ENABLE
PLAY_NOTE_ARRAY(tone_plover_gb, false, 0);
#endif
layer_off(_PLOVER);
}
return false;
break;
}
return true;
}
void matrix_init_user(void) {
#ifdef AUDIO_ENABLE
startup_user();
#endif
}
#ifdef AUDIO_ENABLE
void startup_user()
{
_delay_ms(20); // gets rid of tick
PLAY_NOTE_ARRAY(tone_startup, false, 0);
}
void shutdown_user()
{
PLAY_NOTE_ARRAY(tone_goodbye, false, 0);
_delay_ms(150);
stop_all_notes();
}
void music_on_user(void)
{
music_scale_user();
}
void music_scale_user(void)
{
PLAY_NOTE_ARRAY(music_scale, false, 0);
}
#endif

2
keyboards/planck/keymaps/thermal_printer/readme.md 100644
View File

@ -0,0 +1,2 @@
# The Default Planck Layout

3
keyboards/planck/keymaps/vifon/Makefile
View File

@ -1,3 +1,6 @@
# Please remove if no longer applicable
$(warning THIS FILE MAY BE TOO LARGE FOR YOUR KEYBOARD)
$(warning Please disable some options in the Makefile to resolve)
# Build Options

2
keyboards/planck/keymaps/yang/config.h
View File

@ -5,7 +5,7 @@
/* ws2812 RGB LED */
#define RGB_DI_PIN D1
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 28 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

1
keyboards/planck/rules.mk
View File

@ -62,6 +62,7 @@ AUDIO_ENABLE ?= no # Audio output on port C6
UNICODE_ENABLE ?= no # Unicode
BLUETOOTH_ENABLE ?= no # Enable Bluetooth with the Adafruit EZ-Key HID
RGBLIGHT_ENABLE ?= no # Enable WS2812 RGB underlight. Do not enable this with audio at the same time.
API_SYSEX_ENABLE = yes
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE ?= no # Breathing sleep LED during USB suspend

2
keyboards/preonic/config.h
View File

@ -63,7 +63,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* ws2812 RGB LED */
#define RGB_DI_PIN D1
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 28 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

22
keyboards/preonic/keymaps/default/Makefile
View File

@ -1,25 +1,3 @@
# Build Options
# change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
CONSOLE_ENABLE = no # Console for debug(+400)
COMMAND_ENABLE = yes # Commands for debug and configuration
NKRO_ENABLE = yes # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality
MIDI_ENABLE = no # MIDI controls
AUDIO_ENABLE = yes # Audio output on port C6
UNICODE_ENABLE = no # Unicode
BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight. Do not enable this with audio at the same time.
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
ifndef QUANTUM_DIR
include ../../../../Makefile
endif

2
keyboards/preonic/keymaps/kinesis/config.h
View File

@ -63,7 +63,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* ws2812 RGB LED */
#define RGB_DI_PIN D1
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 28 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

3
keyboards/preonic/rules.mk
View File

@ -53,7 +53,7 @@ OPT_DEFS += -DBOOTLOADER_SIZE=4096
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE ?= no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE ?= yes # Mouse keys(+4700)
MOUSEKEY_ENABLE ?= no # Mouse keys(+4700)
EXTRAKEY_ENABLE ?= yes # Audio control and System control(+450)
CONSOLE_ENABLE ?= no # Console for debug(+400)
COMMAND_ENABLE ?= yes # Commands for debug and configuration
@ -64,6 +64,7 @@ AUDIO_ENABLE ?= no # Audio output on port C6
UNICODE_ENABLE ?= no # Unicode
BLUETOOTH_ENABLE ?= no # Enable Bluetooth with the Adafruit EZ-Key HID
RGBLIGHT_ENABLE ?= no # Enable WS2812 RGB underlight. Do not enable this with audio at the same time.
API_SYSEX_ENABLE ?= yes
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE ?= no # Breathing sleep LED during USB suspend

2
keyboards/satan/config.h
View File

@ -67,7 +67,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define RGB_DI_PIN E2
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 8 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

2
keyboards/tada68/config.h
View File

@ -67,7 +67,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*#define RGB_DI_PIN E2
#define RGBLIGHT_TIMER
#define RGBLIGHT_ANIMATIONS
#define RGBLED_NUM 2 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17

178
quantum/api.c 100644
View File

@ -0,0 +1,178 @@
#include "api.h"
#include "quantum.h"
void dword_to_bytes(uint32_t dword, uint8_t * bytes) {
bytes[0] = (dword >> 24) & 0xFF;
bytes[1] = (dword >> 16) & 0xFF;
bytes[2] = (dword >> 8) & 0xFF;
bytes[3] = (dword >> 0) & 0xFF;
}
uint32_t bytes_to_dword(uint8_t * bytes, uint8_t index) {
return ((uint32_t)bytes[index + 0] << 24) | ((uint32_t)bytes[index + 1] << 16) | ((uint32_t)bytes[index + 2] << 8) | (uint32_t)bytes[index + 3];
}
__attribute__ ((weak))
bool process_api_quantum(uint8_t length, uint8_t * data) {
return process_api_keyboard(length, data);
}
__attribute__ ((weak))
bool process_api_keyboard(uint8_t length, uint8_t * data) {
return process_api_user(length, data);
}
__attribute__ ((weak))
bool process_api_user(uint8_t length, uint8_t * data) {
return true;
}
void process_api(uint16_t length, uint8_t * data) {
// SEND_STRING("\nRX: ");
// for (uint8_t i = 0; i < length; i++) {
// send_byte(data[i]);
// SEND_STRING(" ");
// }
if (!process_api_quantum(length, data))
return;
switch (data[0]) {
case MT_SET_DATA:
switch (data[1]) {
case DT_DEFAULT_LAYER: {
eeconfig_update_default_layer(data[2]);
default_layer_set((uint32_t)(data[2]));
break;
}
case DT_KEYMAP_OPTIONS: {
eeconfig_update_keymap(data[2]);
break;
}
case DT_RGBLIGHT: {
#ifdef RGBLIGHT_ENABLE
uint32_t rgblight = bytes_to_dword(data, 2);
rgblight_update_dword(rgblight);
#endif
break;
}
}
case MT_GET_DATA:
switch (data[1]) {
case DT_HANDSHAKE: {
MT_GET_DATA_ACK(DT_HANDSHAKE, NULL, 0);
break;
}
case DT_DEBUG: {
uint8_t debug_bytes[1] = { eeprom_read_byte(EECONFIG_DEBUG) };
MT_GET_DATA_ACK(DT_DEBUG, debug_bytes, 1);
break;
}
case DT_DEFAULT_LAYER: {
uint8_t default_bytes[1] = { eeprom_read_byte(EECONFIG_DEFAULT_LAYER) };
MT_GET_DATA_ACK(DT_DEFAULT_LAYER, default_bytes, 1);
break;
}
case DT_CURRENT_LAYER: {
uint8_t layer_state_bytes[4];
dword_to_bytes(layer_state, layer_state_bytes);
MT_GET_DATA_ACK(DT_CURRENT_LAYER, layer_state_bytes, 4);
break;
}
case DT_AUDIO: {
#ifdef AUDIO_ENABLE
uint8_t audio_bytes[1] = { eeprom_read_byte(EECONFIG_AUDIO) };
MT_GET_DATA_ACK(DT_AUDIO, audio_bytes, 1);
#else
MT_GET_DATA_ACK(DT_AUDIO, NULL, 0);
#endif
break;
}
case DT_BACKLIGHT: {
#ifdef BACKLIGHT_ENABLE
uint8_t backlight_bytes[1] = { eeprom_read_byte(EECONFIG_BACKLIGHT) };
MT_GET_DATA_ACK(DT_BACKLIGHT, backlight_bytes, 1);
#else
MT_GET_DATA_ACK(DT_BACKLIGHT, NULL, 0);
#endif
break;
}
case DT_RGBLIGHT: {
#ifdef RGBLIGHT_ENABLE
uint8_t rgblight_bytes[4];
dword_to_bytes(eeconfig_read_rgblight(), rgblight_bytes);
MT_GET_DATA_ACK(DT_RGBLIGHT, rgblight_bytes, 4);
#else
MT_GET_DATA_ACK(DT_RGBLIGHT, NULL, 0);
#endif
break;
}
case DT_KEYMAP_OPTIONS: {
uint8_t keymap_bytes[1] = { eeconfig_read_keymap() };
MT_GET_DATA_ACK(DT_KEYMAP_OPTIONS, keymap_bytes, 1);
break;
}
case DT_KEYMAP_SIZE: {
uint8_t keymap_size[2] = {MATRIX_ROWS, MATRIX_COLS};
MT_GET_DATA_ACK(DT_KEYMAP_SIZE, keymap_size, 2);
break;
}
case DT_KEYMAP: {
uint8_t keymap_data[MATRIX_ROWS * MATRIX_COLS * 4 + 3];
keymap_data[0] = data[2];
keymap_data[1] = MATRIX_ROWS;
keymap_data[2] = MATRIX_COLS;
for (int i = 0; i < MATRIX_ROWS; i++) {
for (int j = 0; j < MATRIX_COLS; j++) {
keymap_data[3 + (i*MATRIX_COLS*2) + (j*2)] = pgm_read_word(&keymaps[data[2]][i][j]) >> 8;
keymap_data[3 + (i*MATRIX_COLS*2) + (j*2) + 1] = pgm_read_word(&keymaps[data[2]][i][j]) & 0xFF;
}
}
MT_GET_DATA_ACK(DT_KEYMAP, keymap_data, MATRIX_ROWS * MATRIX_COLS * 4 + 3);
// uint8_t keymap_data[5];
// keymap_data[0] = data[2];
// keymap_data[1] = data[3];
// keymap_data[2] = data[4];
// keymap_data[3] = pgm_read_word(&keymaps[data[2]][data[3]][data[4]]) >> 8;
// keymap_data[4] = pgm_read_word(&keymaps[data[2]][data[3]][data[4]]) & 0xFF;
// MT_GET_DATA_ACK(DT_KEYMAP, keymap_data, 5);
break;
}
default:
break;
}
break;
case MT_SET_DATA_ACK:
case MT_GET_DATA_ACK:
break;
case MT_SEND_DATA:
break;
case MT_SEND_DATA_ACK:
break;
case MT_EXE_ACTION:
break;
case MT_EXE_ACTION_ACK:
break;
case MT_TYPE_ERROR:
break;
default: ; // command not recognised
SEND_BYTES(MT_TYPE_ERROR, DT_NONE, data, length);
break;
// #ifdef RGBLIGHT_ENABLE
// case 0x27: ; // RGB LED functions
// switch (*data++) {
// case 0x00: ; // Update HSV
// rgblight_sethsv((data[0] << 8 | data[1]) % 360, data[2], data[3]);
// break;
// case 0x01: ; // Update RGB
// break;
// case 0x02: ; // Update mode
// rgblight_mode(data[0]);
// break;
// }
// break;
// #endif
}
}

59
quantum/api.h 100644
View File

@ -0,0 +1,59 @@
#ifndef _API_H_
#define _API_H_
#include "lufa.h"
enum MESSAGE_TYPE {
MT_GET_DATA = 0x10, // Get data from keyboard
MT_GET_DATA_ACK = 0x11, // returned data to process (ACK)
MT_SET_DATA = 0x20, // Set data on keyboard
MT_SET_DATA_ACK = 0x21, // returned data to confirm (ACK)
MT_SEND_DATA = 0x30, // Sending data/action from keyboard
MT_SEND_DATA_ACK = 0x31, // returned data/action confirmation (ACK)
MT_EXE_ACTION = 0x40, // executing actions on keyboard
MT_EXE_ACTION_ACK =0x41, // return confirmation/value (ACK)
MT_TYPE_ERROR = 0x80 // type not recofgnised (ACK)
};
enum DATA_TYPE {
DT_NONE = 0x00,
DT_HANDSHAKE,
DT_DEFAULT_LAYER,
DT_CURRENT_LAYER,
DT_KEYMAP_OPTIONS,
DT_BACKLIGHT,
DT_RGBLIGHT,
DT_UNICODE,
DT_DEBUG,
DT_AUDIO,
DT_QUANTUM_ACTION,
DT_KEYBOARD_ACTION,
DT_USER_ACTION,
DT_KEYMAP_SIZE,
DT_KEYMAP
};
void dword_to_bytes(uint32_t dword, uint8_t * bytes);
uint32_t bytes_to_dword(uint8_t * bytes, uint8_t index);
#define MT_GET_DATA(data_type, data, length) SEND_BYTES(MT_GET_DATA, data_type, data, length)
#define MT_GET_DATA_ACK(data_type, data, length) SEND_BYTES(MT_GET_DATA_ACK, data_type, data, length)
#define MT_SET_DATA(data_type, data, length) SEND_BYTES(MT_SET_DATA, data_type, data, length)
#define MT_SET_DATA_ACK(data_type, data, length) SEND_BYTES(MT_SET_DATA_ACK, data_type, data, length)
#define MT_SEND_DATA(data_type, data, length) SEND_BYTES(MT_SEND_DATA, data_type, data, length)
#define MT_SEND_DATA_ACK(data_type, data, length) SEND_BYTES(MT_SEND_DATA_ACK, data_type, data, length)
#define MT_EXE_ACTION(data_type, data, length) SEND_BYTES(MT_EXE_ACTION, data_type, data, length)
#define MT_EXE_ACTION_ACK(data_type, data, length) SEND_BYTES(MT_EXE_ACTION_ACK, data_type, data, length)
void process_api(uint16_t length, uint8_t * data);
__attribute__ ((weak))
bool process_api_quantum(uint8_t length, uint8_t * data);
__attribute__ ((weak))
bool process_api_keyboard(uint8_t length, uint8_t * data);
__attribute__ ((weak))
bool process_api_user(uint8_t length, uint8_t * data);
#endif

29
quantum/api/api_sysex.c 100644
View File

@ -0,0 +1,29 @@
#include "api_sysex.h"
void send_bytes_sysex(uint8_t message_type, uint8_t data_type, uint8_t * bytes, uint16_t length) {
// SEND_STRING("\nTX: ");
// for (uint8_t i = 0; i < length; i++) {
// send_byte(bytes[i]);
// SEND_STRING(" ");
// }
uint8_t * precode = malloc(sizeof(uint8_t) * (length + 2));
precode[0] = message_type;
precode[1] = data_type;
memcpy(precode + 2, bytes, length);
uint8_t * encoded = malloc(sizeof(uint8_t) * (sysex_encoded_length(length + 2)));
uint16_t encoded_length = sysex_encode(encoded, precode, length + 2);
uint8_t * array = malloc(sizeof(uint8_t) * (encoded_length + 5));
array[0] = 0xF0;
array[1] = 0x00;
array[2] = 0x00;
array[3] = 0x00;
array[encoded_length + 4] = 0xF7;
memcpy(array + 4, encoded, encoded_length);
midi_send_array(&midi_device, encoded_length + 5, array);
// SEND_STRING("\nTD: ");
// for (uint8_t i = 0; i < encoded_length + 5; i++) {
// send_byte(array[i]);
// SEND_STRING(" ");
// }
}

10
quantum/api/api_sysex.h 100644
View File

@ -0,0 +1,10 @@
#ifndef _API_SYSEX_H_
#define _API_SYSEX_H_
#include "api.h"
void send_bytes_sysex(uint8_t message_type, uint8_t data_type, uint8_t * bytes, uint16_t length);
#define SEND_BYTES(mt, dt, b, l) send_bytes_sysex(mt, dt, b, l)
#endif

101
quantum/config_common.h
View File

@ -5,55 +5,56 @@
#define COL2ROW 0
#define ROW2COL 1
/* I/O pins */
#define B0 0x30
#define B1 0x31
#define B2 0x32
#define B3 0x33
#define B4 0x34
#define B5 0x35
#define B6 0x36
#define B7 0x37
#define C0 0x60
#define C1 0x61
#define C2 0x62
#define C3 0x63
#define C4 0x64
#define C5 0x65
#define C6 0x66
#define C7 0x67
#define D0 0x90
#define D1 0x91
#define D2 0x92
#define D3 0x93
#define D4 0x94
#define D5 0x95
#define D6 0x96
#define D7 0x97
#define E0 0xC0
#define E1 0xC1
#define E2 0xC2
#define E3 0xC3
#define E4 0xC4
#define E5 0xC5
#define E6 0xC6
#define E7 0xC7
#define F0 0xF0
#define F1 0xF1
#define F2 0xF2
#define F3 0xF3
#define F4 0xF4
#define F5 0xF5
#define F6 0xF6
#define F7 0xF7
#define A0 0x00
#define A1 0x01
#define A2 0x02
#define A3 0x03
#define A4 0x04
#define A5 0x05
#define A6 0x06
#define A7 0x07
#ifndef F0
#define B0 0x30
#define B1 0x31
#define B2 0x32
#define B3 0x33
#define B4 0x34
#define B5 0x35
#define B6 0x36
#define B7 0x37
#define C0 0x60
#define C1 0x61
#define C2 0x62
#define C3 0x63
#define C4 0x64
#define C5 0x65
#define C6 0x66
#define C7 0x67
#define D0 0x90
#define D1 0x91
#define D2 0x92
#define D3 0x93
#define D4 0x94
#define D5 0x95
#define D6 0x96
#define D7 0x97
#define E0 0xC0
#define E1 0xC1
#define E2 0xC2
#define E3 0xC3
#define E4 0xC4
#define E5 0xC5
#define E6 0xC6
#define E7 0xC7
#define F0 0xF0
#define F1 0xF1
#define F2 0xF2
#define F3 0xF3
#define F4 0xF4
#define F5 0xF5
#define F6 0xF6
#define F7 0xF7
#define A0 0x00
#define A1 0x01
#define A2 0x02
#define A3 0x03
#define A4 0x04
#define A5 0x05
#define A6 0x06
#define A7 0x07
#endif
/* USART configuration */
#ifdef BLUETOOTH_ENABLE
@ -79,4 +80,4 @@
# endif
#endif
#endif
#endif

4
quantum/keymap.h
View File

@ -178,6 +178,10 @@ enum quantum_keycodes {
// Right shift, close paren
KC_RSPC,
// Printing
PRINT_ON,
PRINT_OFF,
// always leave at the end
SAFE_RANGE
};

2
quantum/keymap_extras/keymap_nordic.h
View File

@ -13,7 +13,7 @@
#define NO_ACUT KC_EQL
#define NO_AM KC_LBRC
#define NO_QUOT KC_RBRC
#define NO_QUOT KC_RBRC // this is the "umlaut" char on Nordic keyboards, Apple layout
#define NO_AE KC_SCLN
#define NO_OSLH KC_QUOT
#define NO_APOS KC_NUHS

151
quantum/light_ws2812.c
View File

@ -16,14 +16,128 @@
#include <util/delay.h>
#include "debug.h"
#ifdef RGBW_BB_TWI
// Port for the I2C
#define I2C_DDR DDRD
#define I2C_PIN PIND
#define I2C_PORT PORTD
// Pins to be used in the bit banging
#define I2C_CLK 0
#define I2C_DAT 1
#define I2C_DATA_HI()\
I2C_DDR &= ~ (1 << I2C_DAT);\
I2C_PORT |= (1 << I2C_DAT);
#define I2C_DATA_LO()\
I2C_DDR |= (1 << I2C_DAT);\
I2C_PORT &= ~ (1 << I2C_DAT);
#define I2C_CLOCK_HI()\
I2C_DDR &= ~ (1 << I2C_CLK);\
I2C_PORT |= (1 << I2C_CLK);
#define I2C_CLOCK_LO()\
I2C_DDR |= (1 << I2C_CLK);\
I2C_PORT &= ~ (1 << I2C_CLK);
#define I2C_DELAY 1
void I2C_WriteBit(unsigned char c)
{
if (c > 0)
{
I2C_DATA_HI();
}
else
{
I2C_DATA_LO();
}
I2C_CLOCK_HI();
_delay_us(I2C_DELAY);
I2C_CLOCK_LO();
_delay_us(I2C_DELAY);
if (c > 0)
{
I2C_DATA_LO();
}
_delay_us(I2C_DELAY);
}
// Inits bitbanging port, must be called before using the functions below
//
void I2C_Init()
{
I2C_PORT &= ~ ((1 << I2C_DAT) | (1 << I2C_CLK));
I2C_CLOCK_HI();
I2C_DATA_HI();
_delay_us(I2C_DELAY);
}
// Send a START Condition
//
void I2C_Start()
{
// set both to high at the same time
I2C_DDR &= ~ ((1 << I2C_DAT) | (1 << I2C_CLK));
_delay_us(I2C_DELAY);
I2C_DATA_LO();
_delay_us(I2C_DELAY);
I2C_CLOCK_LO();
_delay_us(I2C_DELAY);
}
// Send a STOP Condition
//
void I2C_Stop()
{
I2C_CLOCK_HI();
_delay_us(I2C_DELAY);
I2C_DATA_HI();
_delay_us(I2C_DELAY);
}
// write a byte to the I2C slave device
//
unsigned char I2C_Write(unsigned char c)
{
for (char i = 0; i < 8; i++)
{
I2C_WriteBit(c & 128);
c <<= 1;
}
I2C_WriteBit(0);
_delay_us(I2C_DELAY);
_delay_us(I2C_DELAY);
// _delay_us(I2C_DELAY);
//return I2C_ReadBit();
return 0;
}
#endif
// Setleds for standard RGB
void inline ws2812_setleds(struct cRGB *ledarray, uint16_t leds)
void inline ws2812_setleds(LED_TYPE *ledarray, uint16_t leds)
{
// ws2812_setleds_pin(ledarray,leds, _BV(ws2812_pin));
ws2812_setleds_pin(ledarray,leds, _BV(RGB_DI_PIN & 0xF));
}
void inline ws2812_setleds_pin(struct cRGB *ledarray, uint16_t leds, uint8_t pinmask)
void inline ws2812_setleds_pin(LED_TYPE *ledarray, uint16_t leds, uint8_t pinmask)
{
// ws2812_DDRREG |= pinmask; // Enable DDR
// new universal format (DDR)
@ -34,14 +148,41 @@ void inline ws2812_setleds_pin(struct cRGB *ledarray, uint16_t leds, uint8_t pin
}
// Setleds for SK6812RGBW
void inline ws2812_setleds_rgbw(struct cRGBW *ledarray, uint16_t leds)
void inline ws2812_setleds_rgbw(LED_TYPE *ledarray, uint16_t leds)
{
#ifdef RGBW_BB_TWI
uint8_t sreg_prev, twcr_prev;
sreg_prev=SREG;
twcr_prev=TWCR;
cli();
TWCR &= ~(1<<TWEN);
I2C_Init();
I2C_Start();
I2C_Write(0x84);
uint16_t datlen = leds<<2;
uint8_t curbyte;
uint8_t * data = (uint8_t*)ledarray;
while (datlen--) {
curbyte=*data++;
I2C_Write(curbyte);
}
I2C_Stop();
SREG=sreg_prev;
TWCR=twcr_prev;
#endif
// ws2812_DDRREG |= _BV(ws2812_pin); // Enable DDR
// new universal format (DDR)
_SFR_IO8((RGB_DI_PIN >> 4) + 1) |= _BV(RGB_DI_PIN & 0xF);
ws2812_sendarray_mask((uint8_t*)ledarray,leds<<2,_BV(RGB_DI_PIN & 0xF));
_delay_us(80);
#ifndef RGBW_BB_TWI
_delay_us(80);
#endif
}
void ws2812_sendarray(uint8_t *data,uint16_t datlen)
@ -123,7 +264,7 @@ void inline ws2812_sendarray_mask(uint8_t *data,uint16_t datlen,uint8_t maskhi)
cli();
while (datlen--) {
curbyte=*data++;
curbyte=(*data++);
asm volatile(
" ldi %0,8 \n\t"

21
quantum/light_ws2812.h
View File

@ -16,6 +16,21 @@
#include <avr/io.h>
#include <avr/interrupt.h>
//#include "ws2812_config.h"
//#include "i2cmaster.h"
#define LIGHT_I2C 1
#define LIGHT_I2C_ADDR 0x84
#define LIGHT_I2C_ADDR_WRITE ( (LIGHT_I2C_ADDR<<1) | I2C_WRITE )
#define LIGHT_I2C_ADDR_READ ( (LIGHT_I2C_ADDR<<1) | I2C_READ )
#define RGBW 1
#ifdef RGBW
#define LED_TYPE struct cRGBW
#else
#define LED_TYPE struct cRGB
#endif
/*
* Structure of the LED array
@ -42,9 +57,9 @@ struct cRGBW { uint8_t g; uint8_t r; uint8_t b; uint8_t w;};
* - Wait 50<EFBFBD>s to reset the LEDs
*/
void ws2812_setleds (struct cRGB *ledarray, uint16_t number_of_leds);
void ws2812_setleds_pin (struct cRGB *ledarray, uint16_t number_of_leds,uint8_t pinmask);
void ws2812_setleds_rgbw(struct cRGBW *ledarray, uint16_t number_of_leds);
void ws2812_setleds (LED_TYPE *ledarray, uint16_t number_of_leds);
void ws2812_setleds_pin (LED_TYPE *ledarray, uint16_t number_of_leds,uint8_t pinmask);
void ws2812_setleds_rgbw(LED_TYPE *ledarray, uint16_t number_of_leds);
/*
* Old interface / Internal functions

37
quantum/pincontrol.h 100644
View File

@ -0,0 +1,37 @@
#pragma once
// Some helpers for controlling gpio pins
#include <avr/io.h>
enum {
PinDirectionInput = 0,
PinDirectionOutput = 1,
PinLevelHigh = 1,
PinLevelLow = 0,
};
// ex: pinMode(B0, PinDirectionOutput);
static inline void pinMode(uint8_t pin, int mode) {
uint8_t bv = _BV(pin & 0xf);
if (mode == PinDirectionOutput) {
_SFR_IO8((pin >> 4) + 1) |= bv;
} else {
_SFR_IO8((pin >> 4) + 1) &= ~bv;
_SFR_IO8((pin >> 4) + 2) &= ~bv;
}
}
// ex: digitalWrite(B0, PinLevelHigh);
static inline void digitalWrite(uint8_t pin, int mode) {
uint8_t bv = _BV(pin & 0xf);
if (mode == PinLevelHigh) {
_SFR_IO8((pin >> 4) + 2) |= bv;
} else {
_SFR_IO8((pin >> 4) + 2) &= ~bv;
}
}
// Return true if the pin is HIGH
// digitalRead(B0)
static inline bool digitalRead(uint8_t pin) {
return _SFR_IO8(pin >> 4) & _BV(pin & 0xf);
}

254
quantum/process_keycode/process_printer.c 100644
View File

@ -0,0 +1,254 @@
#include "process_printer.h"
#include "action_util.h"
bool printing_enabled = false;
uint8_t character_shift = 0;
void enabled_printing() {
printing_enabled = true;
serial_init();
}
void disable_printing() {
printing_enabled = false;
}
uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0x28, 0x29};
// uint8_t keycode_to_ascii[0xFF][2];
// keycode_to_ascii[KC_MINS] = {0x2D, 0x5F};
void print_char(char c) {
USB_Disable();
serial_send(c);
USB_Init();
}
void print_box_string(uint8_t text[]) {
uint8_t len = strlen(text);
uint8_t out[len * 3 + 8];
out[0] = 0xDA;
for (uint8_t i = 0; i < len; i++) {
out[i+1] = 0xC4;
}
out[len + 1] = 0xBF;
out[len + 2] = '\n';
out[len + 3] = 0xB3;
for (uint8_t i = 0; i < len; i++) {
out[len + 4 + i] = text[i];
}
out[len * 2 + 4] = 0xB3;
out[len * 2 + 5] = '\n';
out[len * 2 + 6] = 0xC0;
for (uint8_t i = 0; i < len; i++) {
out[len * 2 + 7 + i] = 0xC4;
}
out[len * 3 + 7] = 0xD9;
out[len * 3 + 8] = '\n';
print_string(out);
}
void print_string(char c[]) {
for(uint8_t i = 0; i < strlen(c); i++)
print_char(c[i]);
}
bool process_printer(uint16_t keycode, keyrecord_t *record) {
if (keycode == PRINT_ON) {
enabled_printing();
return false;
}
if (keycode == PRINT_OFF) {
disable_printing();
return false;
}
if (printing_enabled) {
switch(keycode) {
case KC_EXLM ... KC_RPRN:
case KC_UNDS:
case KC_PLUS:
case KC_LCBR:
case KC_RCBR:
case KC_PIPE:
case KC_TILD:
keycode &= 0xFF;
case KC_LSFT:
case KC_RSFT:
if (record->event.pressed) {
character_shift++;
} else {
character_shift--;
}
return false;
break;
}
switch(keycode) {
case KC_F1:
if (record->event.pressed) {
print_box_string("This is a line of text!");
}
return false;
case KC_ESC:
if (record->event.pressed) {
print_char(0x1B);
}
return false;
break;
case KC_SPC:
if (record->event.pressed) {
print_char(0x20);
}
return false;
break;
case KC_A ... KC_Z:
if (record->event.pressed) {
if (character_shift) {
print_char(0x41 + (keycode - KC_A));
} else {
print_char(0x61 + (keycode - KC_A));
}
}
return false;
break;
case KC_1 ... KC_0:
if (record->event.pressed) {
if (character_shift) {
print_char(shifted_numbers[keycode - KC_1]);
} else {
print_char(0x30 + ((keycode - KC_1 + 1) % 10));
}
}
return false;
break;
case KC_ENT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x0C);
} else {
print_char(0x0A);
}
}
return false;
break;
case KC_BSPC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x18);
} else {
print_char(0x1A);
}
}
return false;
break;
case KC_DOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3E);
} else {
print_char(0x2E);
}
}
return false;
break;
case KC_COMM:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3C);
} else {
print_char(0x2C);
}
}
return false;
break;
case KC_SLSH:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3F);
} else {
print_char(0x2F);
}
}
return false;
break;
case KC_QUOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x22);
} else {
print_char(0x27);
}
}
return false;
break;
case KC_GRV:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7E);
} else {
print_char(0x60);
}
}
return false;
break;
case KC_MINS:
if (record->event.pressed) {
if (character_shift) {
print_char(0x5F);
} else {
print_char(0x2D);
}
}
return false;
break;
case KC_EQL:
if (record->event.pressed) {
if (character_shift) {
print_char(0x2B);
} else {
print_char(0x3D);
}
}
return false;
break;
case KC_LBRC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7B);
} else {
print_char(0x5B);
}
}
return false;
break;
case KC_RBRC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7D);
} else {
print_char(0x5D);
}
}
return false;
break;
case KC_BSLS:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7C);
} else {
print_char(0x5C);
}
}
return false;
break;
}
}
return true;
}

8
quantum/process_keycode/process_printer.h 100644
View File

@ -0,0 +1,8 @@
#ifndef PROCESS_PRINTER_H
#define PROCESS_PRINTER_H
#include "quantum.h"
#include "protocol/serial.h"
#endif

260
quantum/process_keycode/process_printer_bb.c 100644
View File

@ -0,0 +1,260 @@
#include "process_printer.h"
#include "action_util.h"
bool printing_enabled = false;
uint8_t character_shift = 0;
#define SERIAL_PIN_DDR DDRD
#define SERIAL_PIN_PORT PORTD
#define SERIAL_PIN_MASK _BV(PD3)
#define SERIAL_DELAY 52
inline static
void serial_delay(void) {
_delay_us(SERIAL_DELAY);
}
inline static
void serial_high(void) {
SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
}
inline static
void serial_low(void) {
SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
}
inline static
void serial_output(void) {
SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
}
void enabled_printing() {
printing_enabled = true;
serial_output();
serial_high();
}
void disable_printing() {
printing_enabled = false;
}
uint8_t shifted_numbers[10] = {0x21, 0x40, 0x23, 0x24, 0x25, 0x5E, 0x26, 0x2A, 0x28, 0x29};
// uint8_t keycode_to_ascii[0xFF][2];
// keycode_to_ascii[KC_MINS] = {0x2D, 0x5F};
void print_char(char c) {
uint8_t b = 8;
serial_output();
while( b-- ) {
if(c & (1 << b)) {
serial_high();
} else {
serial_low();
}
serial_delay();
}
}
void print_string(char c[]) {
for(uint8_t i = 0; i < strlen(c); i++)
print_char(c[i]);
}
bool process_printer(uint16_t keycode, keyrecord_t *record) {
if (keycode == PRINT_ON) {
enabled_printing();
return false;
}
if (keycode == PRINT_OFF) {
disable_printing();
return false;
}
if (printing_enabled) {
switch(keycode) {
case KC_EXLM ... KC_RPRN:
case KC_UNDS:
case KC_PLUS:
case KC_LCBR:
case KC_RCBR:
case KC_PIPE:
case KC_TILD:
keycode &= 0xFF;
case KC_LSFT:
case KC_RSFT:
if (record->event.pressed) {
character_shift++;
} else {
character_shift--;
}
return false;
break;
}
switch(keycode) {
case KC_F1:
if (record->event.pressed) {
print_string("This is a line of text!\n\n\n");
}
return false;
case KC_ESC:
if (record->event.pressed) {
print_char(0x1B);
}
return false;
break;
case KC_SPC:
if (record->event.pressed) {
print_char(0x20);
}
return false;
break;
case KC_A ... KC_Z:
if (record->event.pressed) {
if (character_shift) {
print_char(0x41 + (keycode - KC_A));
} else {
print_char(0x61 + (keycode - KC_A));
}
}
return false;
break;
case KC_1 ... KC_0:
if (record->event.pressed) {
if (character_shift) {
print_char(shifted_numbers[keycode - KC_1]);
} else {
print_char(0x30 + ((keycode - KC_1 + 1) % 10));
}
}
return false;
break;
case KC_ENT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x0C);
} else {
print_char(0x0A);
}
}
return false;
break;
case KC_BSPC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x18);
} else {
print_char(0x1A);
}
}
return false;
break;
case KC_DOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3E);
} else {
print_char(0x2E);
}
}
return false;
break;
case KC_COMM:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3C);
} else {
print_char(0x2C);
}
}
return false;
break;
case KC_SLSH:
if (record->event.pressed) {
if (character_shift) {
print_char(0x3F);
} else {
print_char(0x2F);
}
}
return false;
break;
case KC_QUOT:
if (record->event.pressed) {
if (character_shift) {
print_char(0x22);
} else {
print_char(0x27);
}
}
return false;
break;
case KC_GRV:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7E);
} else {
print_char(0x60);
}
}
return false;
break;
case KC_MINS:
if (record->event.pressed) {
if (character_shift) {
print_char(0x5F);
} else {
print_char(0x2D);
}
}
return false;
break;
case KC_EQL:
if (record->event.pressed) {
if (character_shift) {
print_char(0x2B);
} else {
print_char(0x3D);
}
}
return false;
break;
case KC_LBRC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7B);
} else {
print_char(0x5B);
}
}
return false;
break;
case KC_RBRC:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7D);
} else {
print_char(0x5D);
}
}
return false;
break;
case KC_BSLS:
if (record->event.pressed) {
if (character_shift) {
print_char(0x7C);
} else {
print_char(0x5C);
}
}
return false;
break;
}
}
return true;
}

1
quantum/process_keycode/process_unicode.h
View File

@ -22,6 +22,7 @@ void register_hex(uint16_t hex);
bool process_unicode(uint16_t keycode, keyrecord_t *record);
#ifdef UNICODEMAP_ENABLE
void unicode_map_input_error(void);
bool process_unicode_map(uint16_t keycode, keyrecord_t *record);
#endif

48
quantum/quantum.c
View File

@ -134,6 +134,9 @@ bool process_record_quantum(keyrecord_t *record) {
#ifdef UCIS_ENABLE
process_ucis(keycode, record) &&
#endif
#ifdef PRINTING_ENABLE
process_printer(keycode, record) &&
#endif
#ifdef UNICODEMAP_ENABLE
process_unicode_map(keycode, record) &&
#endif
@ -806,6 +809,51 @@ void backlight_set(uint8_t level)
#endif // backlight
// Functions for spitting out values
//
void send_dword(uint32_t number) { // this might not actually work
uint16_t word = (number >> 16);
send_word(word);
send_word(number & 0xFFFFUL);
}
void send_word(uint16_t number) {
uint8_t byte = number >> 8;
send_byte(byte);
send_byte(number & 0xFF);
}
void send_byte(uint8_t number) {
uint8_t nibble = number >> 4;
send_nibble(nibble);
send_nibble(number & 0xF);
}
void send_nibble(uint8_t number) {
switch (number) {
case 0:
register_code(KC_0);
unregister_code(KC_0);
break;
case 1 ... 9:
register_code(KC_1 + (number - 1));
unregister_code(KC_1 + (number - 1));
break;
case 0xA ... 0xF:
register_code(KC_A + (number - 0xA));
unregister_code(KC_A + (number - 0xA));
break;
}
}
void api_send_unicode(uint32_t unicode) {
#ifdef API_ENABLE
uint8_t chunk[4];
dword_to_bytes(unicode, chunk);
MT_SEND_DATA(DT_UNICODE, chunk, 5);
#endif
}
__attribute__ ((weak))
void led_set_user(uint8_t usb_led) {

11
quantum/quantum.h
View File

@ -59,6 +59,10 @@ extern uint32_t default_layer_state;
#include "process_tap_dance.h"
#ifdef PRINTING_ENABLE
#include "process_printer.h"
#endif
#define SEND_STRING(str) send_string(PSTR(str))
void send_string(const char *str);
@ -106,8 +110,15 @@ void breathing_speed_dec(uint8_t value);
#endif
#endif
void send_dword(uint32_t number);
void send_word(uint16_t number);
void send_byte(uint8_t number);
void send_nibble(uint8_t number);
void led_set_user(uint8_t usb_led);
void led_set_kb(uint8_t usb_led);
void api_send_unicode(uint32_t unicode);
#endif

145
quantum/rgblight.c
View File

@ -69,11 +69,12 @@ const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {100, 50, 20};
rgblight_config_t rgblight_config;
rgblight_config_t inmem_config;
struct cRGB led[RGBLED_NUM];
LED_TYPE led[RGBLED_NUM];
uint8_t rgblight_inited = 0;
bool rgblight_timer_enabled = false;
void sethsv(uint16_t hue, uint8_t sat, uint8_t val, struct cRGB *led1) {
void sethsv(uint16_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1) {
uint8_t r = 0, g = 0, b = 0, base, color;
if (sat == 0) { // Acromatic color (gray). Hue doesn't mind.
@ -124,7 +125,7 @@ void sethsv(uint16_t hue, uint8_t sat, uint8_t val, struct cRGB *led1) {
setrgb(r, g, b, led1);
}
void setrgb(uint8_t r, uint8_t g, uint8_t b, struct cRGB *led1) {
void setrgb(uint8_t r, uint8_t g, uint8_t b, LED_TYPE *led1) {
(*led1).r = r;
(*led1).g = g;
(*led1).b = b;
@ -141,9 +142,9 @@ void eeconfig_update_rgblight_default(void) {
dprintf("eeconfig_update_rgblight_default\n");
rgblight_config.enable = 1;
rgblight_config.mode = 1;
rgblight_config.hue = 200;
rgblight_config.sat = 204;
rgblight_config.val = 204;
rgblight_config.hue = 0;
rgblight_config.sat = 255;
rgblight_config.val = 255;
eeconfig_update_rgblight(rgblight_config.raw);
}
void eeconfig_debug_rgblight(void) {
@ -173,7 +174,7 @@ void rgblight_init(void) {
}
eeconfig_debug_rgblight(); // display current eeprom values
#if !defined(AUDIO_ENABLE) && defined(RGBLIGHT_TIMER)
#ifdef RGBLIGHT_ANIMATIONS
rgblight_timer_init(); // setup the timer
#endif
@ -182,6 +183,19 @@ void rgblight_init(void) {
}
}
void rgblight_update_dword(uint32_t dword) {
rgblight_config.raw = dword;
eeconfig_update_rgblight(rgblight_config.raw);
if (rgblight_config.enable)
rgblight_mode(rgblight_config.mode);
else {
#ifdef RGBLIGHT_ANIMATIONS
rgblight_timer_disable();
#endif
rgblight_set();
}
}
void rgblight_increase(void) {
uint8_t mode = 0;
if (rgblight_config.mode < RGBLIGHT_MODES) {
@ -220,7 +234,7 @@ void rgblight_mode(uint8_t mode) {
eeconfig_update_rgblight(rgblight_config.raw);
xprintf("rgblight mode: %u\n", rgblight_config.mode);
if (rgblight_config.mode == 1) {
#if !defined(AUDIO_ENABLE) && defined(RGBLIGHT_TIMER)
#ifdef RGBLIGHT_ANIMATIONS
rgblight_timer_disable();
#endif
} else if (rgblight_config.mode >= 2 && rgblight_config.mode <= 23) {
@ -230,7 +244,7 @@ void rgblight_mode(uint8_t mode) {
// MODE 15-20, snake
// MODE 21-23, knight
#if !defined(AUDIO_ENABLE) && defined(RGBLIGHT_TIMER)
#ifdef RGBLIGHT_ANIMATIONS
rgblight_timer_enable();
#endif
}
@ -244,7 +258,7 @@ void rgblight_toggle(void) {
if (rgblight_config.enable) {
rgblight_mode(rgblight_config.mode);
} else {
#if !defined(AUDIO_ENABLE) && defined(RGBLIGHT_TIMER)
#ifdef RGBLIGHT_ANIMATIONS
rgblight_timer_disable();
#endif
_delay_ms(50);
@ -252,6 +266,13 @@ void rgblight_toggle(void) {
}
}
void rgblight_enable(void) {
rgblight_config.enable = 1;
eeconfig_update_rgblight(rgblight_config.raw);
xprintf("rgblight enable: rgblight_config.enable = %u\n", rgblight_config.enable);
rgblight_mode(rgblight_config.mode);
}
void rgblight_increase_hue(void) {
uint16_t hue;
@ -307,7 +328,7 @@ void rgblight_decrease_val(void) {
void rgblight_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val) {
inmem_config.raw = rgblight_config.raw;
if (rgblight_config.enable) {
struct cRGB tmp_led;
LED_TYPE tmp_led;
sethsv(hue, sat, val, &tmp_led);
inmem_config.hue = hue;
inmem_config.sat = sat;
@ -351,66 +372,84 @@ void rgblight_setrgb(uint8_t r, uint8_t g, uint8_t b) {
void rgblight_set(void) {
if (rgblight_config.enable) {
ws2812_setleds(led, RGBLED_NUM);
#ifdef RGBW
ws2812_setleds_rgbw(led, RGBLED_NUM);
#else
ws2812_setleds(led, RGBLED_NUM);
#endif
} else {
for (uint8_t i = 0; i < RGBLED_NUM; i++) {
led[i].r = 0;
led[i].g = 0;
led[i].b = 0;
}
ws2812_setleds(led, RGBLED_NUM);
#ifdef RGBW
ws2812_setleds_rgbw(led, RGBLED_NUM);
#else
ws2812_setleds(led, RGBLED_NUM);
#endif
}
}
#if !defined(AUDIO_ENABLE) && defined(RGBLIGHT_TIMER)
#ifdef RGBLIGHT_ANIMATIONS
// Animation timer -- AVR Timer3
void rgblight_timer_init(void) {
static uint8_t rgblight_timer_is_init = 0;
if (rgblight_timer_is_init) {
return;
}
rgblight_timer_is_init = 1;
/* Timer 3 setup */
TCCR3B = _BV(WGM32) //CTC mode OCR3A as TOP
| _BV(CS30); //Clock selelct: clk/1
/* Set TOP value */
uint8_t sreg = SREG;
cli();
OCR3AH = (RGBLED_TIMER_TOP >> 8) & 0xff;
OCR3AL = RGBLED_TIMER_TOP & 0xff;
SREG = sreg;
// static uint8_t rgblight_timer_is_init = 0;
// if (rgblight_timer_is_init) {
// return;
// }
// rgblight_timer_is_init = 1;
// /* Timer 3 setup */
// TCCR3B = _BV(WGM32) // CTC mode OCR3A as TOP
// | _BV(CS30); // Clock selelct: clk/1
// /* Set TOP value */
// uint8_t sreg = SREG;
// cli();
// OCR3AH = (RGBLED_TIMER_TOP >> 8) & 0xff;
// OCR3AL = RGBLED_TIMER_TOP & 0xff;
// SREG = sreg;
rgblight_timer_enabled = true;
}
void rgblight_timer_enable(void) {
TIMSK3 |= _BV(OCIE3A);
rgblight_timer_enabled = true;
dprintf("TIMER3 enabled.\n");
}
void rgblight_timer_disable(void) {
TIMSK3 &= ~_BV(OCIE3A);
rgblight_timer_enabled = false;
dprintf("TIMER3 disabled.\n");
}
void rgblight_timer_toggle(void) {
TIMSK3 ^= _BV(OCIE3A);
rgblight_timer_enabled ^= rgblight_timer_enabled;
dprintf("TIMER3 toggled.\n");
}
ISR(TIMER3_COMPA_vect) {
// mode = 1, static light, do nothing here
if (rgblight_config.mode >= 2 && rgblight_config.mode <= 5) {
// mode = 2 to 5, breathing mode
rgblight_effect_breathing(rgblight_config.mode - 2);
} else if (rgblight_config.mode >= 6 && rgblight_config.mode <= 8) {
// mode = 6 to 8, rainbow mood mod
rgblight_effect_rainbow_mood(rgblight_config.mode - 6);
} else if (rgblight_config.mode >= 9 && rgblight_config.mode <= 14) {
// mode = 9 to 14, rainbow swirl mode
rgblight_effect_rainbow_swirl(rgblight_config.mode - 9);
} else if (rgblight_config.mode >= 15 && rgblight_config.mode <= 20) {
// mode = 15 to 20, snake mode
rgblight_effect_snake(rgblight_config.mode - 15);
} else if (rgblight_config.mode >= 21 && rgblight_config.mode <= 23) {
// mode = 21 to 23, knight mode
rgblight_effect_knight(rgblight_config.mode - 21);
void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b) {
rgblight_enable();
rgblight_mode(1);
rgblight_setrgb(r, g, b);
}
void rgblight_task(void) {
if (rgblight_timer_enabled) {
// mode = 1, static light, do nothing here
if (rgblight_config.mode >= 2 && rgblight_config.mode <= 5) {
// mode = 2 to 5, breathing mode
rgblight_effect_breathing(rgblight_config.mode - 2);
} else if (rgblight_config.mode >= 6 && rgblight_config.mode <= 8) {
// mode = 6 to 8, rainbow mood mod
rgblight_effect_rainbow_mood(rgblight_config.mode - 6);
} else if (rgblight_config.mode >= 9 && rgblight_config.mode <= 14) {
// mode = 9 to 14, rainbow swirl mode
rgblight_effect_rainbow_swirl(rgblight_config.mode - 9);
} else if (rgblight_config.mode >= 15 && rgblight_config.mode <= 20) {
// mode = 15 to 20, snake mode
rgblight_effect_snake(rgblight_config.mode - 15);
} else if (rgblight_config.mode >= 21 && rgblight_config.mode <= 23) {
// mode = 21 to 23, knight mode
rgblight_effect_knight(rgblight_config.mode - 21);
}
}
}
@ -449,7 +488,7 @@ void rgblight_effect_rainbow_swirl(uint8_t interval) {
last_timer = timer_read();
for (i = 0; i < RGBLED_NUM; i++) {
hue = (360 / RGBLED_NUM * i + current_hue) % 360;
sethsv(hue, rgblight_config.sat, rgblight_config.val, &led[i]);
sethsv(hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&led[i]);
}
rgblight_set();
@ -486,7 +525,7 @@ void rgblight_effect_snake(uint8_t interval) {
k = k + RGBLED_NUM;
}
if (i == k) {
sethsv(rgblight_config.hue, rgblight_config.sat, (uint8_t)(rgblight_config.val*(RGBLIGHT_EFFECT_SNAKE_LENGTH-j)/RGBLIGHT_EFFECT_SNAKE_LENGTH), &led[i]);
sethsv(rgblight_config.hue, rgblight_config.sat, (uint8_t)(rgblight_config.val*(RGBLIGHT_EFFECT_SNAKE_LENGTH-j)/RGBLIGHT_EFFECT_SNAKE_LENGTH), (LED_TYPE *)&led[i]);
}
}
}
@ -506,7 +545,7 @@ void rgblight_effect_knight(uint8_t interval) {
static uint16_t last_timer = 0;
uint8_t i, j, cur;
int8_t k;
struct cRGB preled[RGBLED_NUM];
LED_TYPE preled[RGBLED_NUM];
static int8_t increment = -1;
if (timer_elapsed(last_timer) < pgm_read_byte(&RGBLED_KNIGHT_INTERVALS[interval])) {
return;
@ -525,7 +564,7 @@ void rgblight_effect_knight(uint8_t interval) {
k = RGBLED_NUM - 1;
}
if (i == k) {
sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, &preled[i]);
sethsv(rgblight_config.hue, rgblight_config.sat, rgblight_config.val, (LED_TYPE *)&preled[i]);
}
}
}

15
quantum/rgblight.h
View File

@ -1,8 +1,7 @@
#ifndef RGBLIGHT_H
#define RGBLIGHT_H
#if !defined(AUDIO_ENABLE) && defined(RGBLIGHT_TIMER)
#ifdef RGBLIGHT_ANIMATIONS
#define RGBLIGHT_MODES 23
#else
#define RGBLIGHT_MODES 1
@ -34,6 +33,7 @@
#endif
#define RGBLED_TIMER_TOP F_CPU/(256*64)
// #define RGBLED_TIMER_TOP 0xFF10
#include <stdint.h>
#include <stdbool.h>
@ -61,9 +61,11 @@ void rgblight_init(void);
void rgblight_increase(void);
void rgblight_decrease(void);
void rgblight_toggle(void);
void rgblight_enable(void);
void rgblight_step(void);
void rgblight_mode(uint8_t mode);
void rgblight_set(void);
void rgblight_update_dword(uint32_t dword);
void rgblight_increase_hue(void);
void rgblight_decrease_hue(void);
void rgblight_increase_sat(void);
@ -78,10 +80,15 @@ void eeconfig_update_rgblight(uint32_t val);
void eeconfig_update_rgblight_default(void);
void eeconfig_debug_rgblight(void);
void sethsv(uint16_t hue, uint8_t sat, uint8_t val, struct cRGB *led1);
void setrgb(uint8_t r, uint8_t g, uint8_t b, struct cRGB *led1);
void sethsv(uint16_t hue, uint8_t sat, uint8_t val, LED_TYPE *led1);
void setrgb(uint8_t r, uint8_t g, uint8_t b, LED_TYPE *led1);
void rgblight_sethsv_noeeprom(uint16_t hue, uint8_t sat, uint8_t val);
#define EZ_RGB(val) rgblight_show_solid_color((val >> 16) & 0xFF, (val >> 8) & 0xFF, val & 0xFF)
void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b);
void rgblight_task(void);
void rgblight_timer_init(void);
void rgblight_timer_enable(void);
void rgblight_timer_disable(void);

191
readme.md
View File

@ -45,19 +45,19 @@ Before you are able to compile, you'll need to install an environment for AVR de
### Windows 10
It's still recommended to use the method for Vista and later below. The reason for this is that the Windows 10 Subsystem for Linux lacks [USB support](https://wpdev.uservoice.com/forums/266908-command-prompt-console-bash-on-ubuntu-on-windo/suggestions/13355724-unable-to-access-usb-devices-from-bash), so it's not possible to flash the firmware to the keyboard. Please add your vote to the link!
Due to some issues with the "Windows (Vista and later)" instructions below, we now recommend following these instructions if you use Windows, which will allow you to use the Windows Subsystem for Linux to compile the firmware. If you are not using Windows 10 with the Anniversary Update installed (which came out in July 2016), you will need to use one of the other methods, such as Docker, Vagrant, or the instructions for Vista and later.
That said, it's still possible to use it for compilation. And recommended, if you need to compile much, since it's much faster than at least Cygwin (which is also supported, but currently lacking documentation). I haven't tried the method below, so I'm unable to tell.
If you use this method, you will need to use a standalone tool to flash the firmware to the keyboard after you compile it. We recommend the official [QMK Firmware Flasher](https://github.com/jackhumbert/qmk_firmware_flasher/releases). This is because the Windows 10 Subsystem for Linux lacks [libUSB support](https://wpdev.uservoice.com/forums/266908-command-prompt-console-bash-on-ubuntu-on-windo/suggestions/13355724-unable-to-access-usb-devices-from-bash), so it can't access the keyboard's microcontroller. Please add your vote for Microsoft to fix this issue using the link!
Here are the steps
1. Install the Windows 10 subsystem for Linux, following [these instructions](http://www.howtogeek.com/249966/how-to-install-and-use-the-linux-bash-shell-on-windows-10/).
2. If you have previously cloned the repository using the normal Git bash, you will need to clean up the line endings. If you have cloned it after 20th of August 2016, you are likely fine. To clean up the line endings do the following
1. Make sure that you have no changes you haven't committed by running `git status`, if you do commit them first
2. From within the Git bash run `git rm --cached -r .`
3. Followed by `git reset --hard`
3. Start the "Bash On Ubuntu On Windows" from the start menu
4. With the bash open, navigate to your Git checkout. The harddisk can be accessed from `/mnt` for example `/mnt/c` for the `c:\` drive.
2. If you have cloned the repository using git before August 20, 2016, clean up the line endings from wherever you currently access git:
1. Make sure that you have no changes you haven't committed by running `git status`. ANY UNCOMMITTED CHANGES WILL BE PERMANENTLY LOST.
2. Run `git rm --cached -r .`
3. Run `git reset --hard`
3. Open "Bash On Ubuntu On Windows" from the start menu
4. With the bash window open, navigate to your copy of the [qmk_firmware repository](https://github.com/jackhumbert/qmk_firmware) using the `cd` command. The harddisks can be accessed from `/mnt/<driveletter>`. For example, your main hard drive (C:) can be accessed by executiing the command `cd /mnt/c`. If your username is John and the qmk_firmware folder is in your Downloads folder, you can move to it with the command `cd /mnt/c/Users/John/Downloads/qmk_firmware`. You can use the Tab key as you go to help you autocomplete the folder names.
5. Run `sudo util/install_dependencies.sh`.
6. After a while the installation will finish, and you are good to go
@ -348,6 +348,10 @@ This allows you output audio on the C6 pin (needs abstracting). See the [audio s
Use this to debug changes to variable values, see the [tracing variables](#tracing-variables) section for more information.
`API_SYSEX_ENABLE`
This enables using the Quantum SYSEX API to send strings (somewhere?)
### Customizing Makefile options on a per-keymap basis
If your keymap directory has a file called `Makefile` (note the filename), any Makefile options you set in that file will take precedence over other Makefile options for your particular keyboard.
@ -911,7 +915,33 @@ In `quantum/keymap_extras/`, you'll see various language files - these work the
## Unicode support
You can currently send 4 hex digits with your OS-specific modifier key (RALT for OSX with the "Unicode Hex Input" layout, see [this article](http://www.poynton.com/notes/misc/mac-unicode-hex-input.html) to learn more) - this is currently limited to supporting one OS at a time, and requires a recompile for switching. 8 digit hex codes are being worked on. The keycode function is `UC(n)`, where *n* is a 4 digit hexidecimal. Enable from the Makefile.
There are three Unicode keymap definition method available in QMK:
### UNICODE_ENABLE
Supports Unicode input up to 0xFFFF. The keycode function is `UC(n)` in
keymap file, where *n* is a 4 digit hexadecimal.
### UNICODEMAP_ENABLE
Supports Unicode up to 0xFFFFFFFF. You need to maintain a separate mapping
table `const uint32_t PROGMEM unicode_map[] = {...}` in your keymap file.
The keycode function is `X(n)` where *n* is the array index of the mapping
table.
### UCIS_ENABLE
TBD
Unicode input in QMK works by inputing a sequence of characters to the OS,
sort of like macro. Unfortunately, each OS has different ideas on how Unicode is inputted.
This is the current list of Unicode input method in QMK:
* UC_OSX: MacOS Unicode Hex Input support. Works only up to 0xFFFF. Disabled by default. To enable: go to System Preferences -> Keyboard -> Input Sources, and enable Unicode Hex.
* UC_LNX: Unicode input method under Linux. Works up to 0xFFFFF. Should work almost anywhere on ibus enabled distros. Without ibus, this works under GTK apps, but rarely anywhere else.
* UC_WIN: (not recommended) Windows built-in Unicode input. To enable: create registry key under `HKEY_CURRENT_USER\Control Panel\Input Method\EnableHexNumpad` of type `REG_SZ` called `EnableHexNumpad`, set its value to 1, and reboot. This method is not recommended because of reliability and compatibility issue, use WinCompose method below instead.
* UC_WINC: Windows Unicode input using WinCompose. Requires [WinCompose](https://github.com/samhocevar/wincompose). Works reliably under many (all?) variations of Windows.
## Backlight Breathing
@ -1136,12 +1166,12 @@ For this mod, you need an unused pin wiring to DI of WS2812 strip. After wiring
RGBLIGHT_ENABLE = yes
In order to use the underglow timer functions, you need to have `#define RGBLIGHT_TIMER` in your `config.h`, and have audio disabled (`AUDIO_ENABLE = no` in your Makefile).
In order to use the underglow animation functions, you need to have `#define RGBLIGHT_ANIMATIONS` in your `config.h`.
Please add the following options into your config.h, and set them up according your hardware configuration. These settings are for the `F4` pin by default:
#define RGB_DI_PIN F4 // The pin your RGB strip is wired to
#define RGBLIGHT_TIMER // Require for fancier stuff (not compatible with audio)
#define RGBLIGHT_ANIMATIONS // Require for fancier stuff (not compatible with audio)
#define RGBLED_NUM 14 // Number of LEDs
#define RGBLIGHT_HUE_STEP 10
#define RGBLIGHT_SAT_STEP 17
@ -1161,7 +1191,7 @@ Please note the USB port can only supply a limited amount of power to the keyboa
Its possible to hook up a PS/2 mouse (for example touchpads or trackpoints) to your keyboard as a composite device.
Then, decide whether to use USART (best), interrupts (better) or busywait (not recommended), and enable the relevant option.
There are three available modes for hooking up PS/2 devices: USART (best), interrupts (better) or busywait (not recommended).
### Busywait version
@ -1286,20 +1316,149 @@ In your keyboard config.h:
#endif
```
### Additional Settings
#### PS/2 mouse features
These enable settings supported by the PS/2 mouse protocol: http://www.computer-engineering.org/ps2mouse/
```
/* Use remote mode instead of the default stream mode (see link) */
#define PS2_MOUSE_USE_REMOTE_MODE
/* Enable the scrollwheel or scroll gesture on your mouse or touchpad */
#define PS2_MOUSE_ENABLE_SCROLLING
/* Some mice will need a scroll mask to be configured. The default is 0xFF. */
#define PS2_MOUSE_SCROLL_MASK 0x0F
/* Applies a transformation to the movement before sending to the host (see link) */
#define PS2_MOUSE_USE_2_1_SCALING
/* The time to wait after initializing the ps2 host */
#define PS2_MOUSE_INIT_DELAY 1000 /* Default */
```
You can also call the following functions from ps2_mouse.h
```
void ps2_mouse_disable_data_reporting(void);
void ps2_mouse_enable_data_reporting(void);
void ps2_mouse_set_remote_mode(void);
void ps2_mouse_set_stream_mode(void);
void ps2_mouse_set_scaling_2_1(void);
void ps2_mouse_set_scaling_1_1(void);
void ps2_mouse_set_resolution(ps2_mouse_resolution_t resolution);
void ps2_mouse_set_sample_rate(ps2_mouse_sample_rate_t sample_rate);
```
#### Fine control
Use the following defines to change the sensitivity and speed of the mouse.
Note: you can also use `ps2_mouse_set_resolution` for the same effect (not supported on most touchpads).
```
#define PS2_MOUSE_X_MULTIPLIER 3
#define PS2_MOUSE_Y_MULTIPLIER 3
#define PS2_MOUSE_V_MULTIPLIER 1
```
#### Scroll button
If you're using a trackpoint, you will likely want to be able to use it for scrolling.
Its possible to enable a "scroll button/s" that when pressed will cause the mouse to scroll instead of moving.
To enable the feature, you must set a scroll button mask as follows:
```
#define PS2_MOUSE_SCROLL_BTN_MASK (1<<PS2_MOUSE_BUTTON_MIDDLE) /* Default */
```
To disable the scroll button feature:
```
#define PS2_MOUSE_SCROLL_BTN_MASK 0
```
The available buttons are:
```
#define PS2_MOUSE_BTN_LEFT 0
#define PS2_MOUSE_BTN_RIGHT 1
#define PS2_MOUSE_BTN_MIDDLE 2
```
You can also combine buttons in the mask by `|`ing them together.
Once you've configured your scroll button mask, you must configure the scroll button send interval.
This is the interval before which if the scroll buttons were released they would be sent to the host.
After this interval, they will cause the mouse to scroll and will not be sent.
```
#define PS2_MOUSE_SCROLL_BTN_SEND 300 /* Default */
```
To disable sending the scroll buttons:
```
#define PS2_MOUSE_SCROLL_BTN_SEND 0
```
Fine control over the scrolling is supported with the following defines:
```
#define PS2_MOUSE_SCROLL_DIVISOR_H 2
#define PS2_MOUSE_SCROLL_DIVISOR_V 2
```
#### Debug settings
To debug the mouse, add `debug_mouse = true` or enable via bootmagic.
```
/* To debug the mouse reports */
#define PS2_MOUSE_DEBUG_HID
#define PS2_MOUSE_DEBUG_RAW
```
## Safety Considerations
You probably don't want to "brick" your keyboard, making it impossible
to rewrite firmware onto it. Here are some of the parameters to show
what things are (and likely aren't) too risky.
- If a keyboard map does not include RESET, then, to get into DFU
- If your keyboard map does not include RESET, then, to get into DFU
mode, you will need to press the reset button on the PCB, which
requires unscrewing some bits.
requires unscrewing the bottom.
- Messing with tmk_core / common files might make the keyboard
inoperable
- Too large a .hex file is trouble; `make dfu` will erase the block,
test the size (oops, wrong order!), which errors out, failing to
flash the keyboard
flash the keyboard, leaving it in DFU mode.
- To this end, note that the maximum .hex file size on Planck is
7000h (28672 decimal)
```
Linking: .build/planck_rev4_cbbrowne.elf [OK]
Creating load file for Flash: .build/planck_rev4_cbbrowne.hex [OK]
Size after:
text data bss dec hex filename
0 22396 0 22396 577c planck_rev4_cbbrowne.hex
```
- The above file is of size 22396/577ch, which is less than
28672/7000h
- As long as you have a suitable alternative .hex file around, you
can retry, loading that one
- Some of the options you might specify in your keyboard's Makefile
consume extra memory; watch out for BOOTMAGIC_ENABLE,
MOUSEKEY_ENABLE, EXTRAKEY_ENABLE, CONSOLE_ENABLE, API_SYSEX_ENABLE
- DFU tools do /not/ allow you to write into the bootloader (unless
you throw in extra fruitsalad of options), so there is little risk
there.
@ -1435,4 +1594,4 @@ This will add a traced variable named "layer" (the name is just for your informa
In order to actually detect changes to the variables you should call `VERIFY_TRACED_VARIABLES` around the code that you think that modifies the variable. If a variable is modified it will tell you between which two `VERIFY_TRACED_VARIABLES` calls the modification happened. You can then add more calls to track it down further. I don't recommend spamming the codebase with calls. It's better to start with a few, and then keep adding them in a binary search fashion. You can also delete the ones you don't need, as each call need to store the file name and line number in the ROM, so you can run out of memory if you add too many calls.
Also remember to delete all the tracing code ones you have found the bug, as you wouldn't want to create a pull request with tracing code.
Also remember to delete all the tracing code ones you have found the bug, as you wouldn't want to create a pull request with tracing code.

6
tmk_core/common.mk
View File

@ -81,6 +81,10 @@ ifeq ($(strip $(BACKLIGHT_ENABLE)), yes)
TMK_COMMON_DEFS += -DBACKLIGHT_ENABLE
endif
ifeq ($(strip $(ADAFRUIT_BLE_ENABLE)), yes)
TMK_COMMON_DEFS += -DADAFRUIT_BLE_ENABLE
endif
ifeq ($(strip $(BLUETOOTH_ENABLE)), yes)
TMK_COMMON_DEFS += -DBLUETOOTH_ENABLE
endif
@ -110,4 +114,4 @@ endif
VPATH += $(TMK_PATH)/$(COMMON_DIR)
ifeq ($(PLATFORM),CHIBIOS)
VPATH += $(TMK_PATH)/$(COMMON_DIR)/chibios
endif
endif

36
tmk_core/common/avr/timer.c
View File

@ -17,6 +17,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/atomic.h>
#include <stdint.h>
#include "timer_avr.h"
#include "timer.h"
@ -24,7 +25,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;
volatile uint32_t timer_count;
void timer_init(void)
{
@ -52,10 +53,9 @@ void timer_init(void)
inline
void timer_clear(void)
{
uint8_t sreg = SREG;
cli();
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
timer_count = 0;
SREG = sreg;
}
}
inline
@ -63,10 +63,9 @@ uint16_t timer_read(void)
{
uint32_t t;
uint8_t sreg = SREG;
cli();
t = timer_count;
SREG = sreg;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
t = timer_count;
}
return (t & 0xFFFF);
}
@ -76,10 +75,9 @@ uint32_t timer_read32(void)
{
uint32_t t;
uint8_t sreg = SREG;
cli();
t = timer_count;
SREG = sreg;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
t = timer_count;
}
return t;
}
@ -89,10 +87,9 @@ uint16_t timer_elapsed(uint16_t last)
{
uint32_t t;
uint8_t sreg = SREG;
cli();
t = timer_count;
SREG = sreg;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
t = timer_count;
}
return TIMER_DIFF_16((t & 0xFFFF), last);
}
@ -102,10 +99,9 @@ uint32_t timer_elapsed32(uint32_t last)
{
uint32_t t;
uint8_t sreg = SREG;
cli();
t = timer_count;
SREG = sreg;
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
t = timer_count;
}
return TIMER_DIFF_32(t, last);
}

9
tmk_core/common/host_driver.h
View File

@ -20,7 +20,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h>
#include "report.h"
#ifdef MIDI_ENABLE
#include "midi.h"
#endif
typedef struct {
uint8_t (*keyboard_leds)(void);
@ -28,6 +30,11 @@ typedef struct {
void (*send_mouse)(report_mouse_t *);
void (*send_system)(uint16_t);
void (*send_consumer)(uint16_t);
#ifdef MIDI_ENABLE
void (*usb_send_func)(MidiDevice *, uint16_t, uint8_t, uint8_t, uint8_t);
void (*usb_get_midi)(MidiDevice *);
void (*midi_usb_init)(MidiDevice *);
#endif
} host_driver_t;
#endif

4
tmk_core/protocol/lufa.mk
View File

@ -21,6 +21,10 @@ ifeq ($(strip $(MIDI_ENABLE)), yes)
include $(TMK_PATH)/protocol/midi.mk
endif
ifeq ($(strip $(ADAFRUIT_BLE_ENABLE)), yes)
LUFA_SRC += $(LUFA_DIR)/adafruit_ble.cpp
endif
ifeq ($(strip $(BLUETOOTH_ENABLE)), yes)
LUFA_SRC += $(LUFA_DIR)/bluetooth.c \
$(TMK_DIR)/protocol/serial_uart.c

805
tmk_core/protocol/lufa/adafruit_ble.cpp 100644
View File

@ -0,0 +1,805 @@
#include "adafruit_ble.h"
#include <stdio.h>
#include <stdlib.h>
#include <alloca.h>
#include <util/delay.h>
#include <util/atomic.h>
#include "debug.h"
#include "pincontrol.h"
#include "timer.h"
#include "action_util.h"
#include "ringbuffer.hpp"
#include <string.h>
// These are the pin assignments for the 32u4 boards.
// You may define them to something else in your config.h
// if yours is wired up differently.
#ifndef AdafruitBleResetPin
#define AdafruitBleResetPin D4
#endif
#ifndef AdafruitBleCSPin
#define AdafruitBleCSPin B4
#endif
#ifndef AdafruitBleIRQPin
#define AdafruitBleIRQPin E6
#endif
#define SAMPLE_BATTERY
#define ConnectionUpdateInterval 1000 /* milliseconds */
static struct {
bool is_connected;
bool initialized;
bool configured;
#define ProbedEvents 1
#define UsingEvents 2
bool event_flags;
#ifdef SAMPLE_BATTERY
uint16_t last_battery_update;
uint32_t vbat;
#endif
uint16_t last_connection_update;
} state;
// Commands are encoded using SDEP and sent via SPI
// https://github.com/adafruit/Adafruit_BluefruitLE_nRF51/blob/master/SDEP.md
#define SdepMaxPayload 16
struct sdep_msg {
uint8_t type;
uint8_t cmd_low;
uint8_t cmd_high;
struct __attribute__((packed)) {
uint8_t len:7;
uint8_t more:1;
};
uint8_t payload[SdepMaxPayload];
} __attribute__((packed));
// The recv latency is relatively high, so when we're hammering keys quickly,
// we want to avoid waiting for the responses in the matrix loop. We maintain
// a short queue for that. Since there is quite a lot of space overhead for
// the AT command representation wrapped up in SDEP, we queue the minimal
// information here.
enum queue_type {
QTKeyReport, // 1-byte modifier + 6-byte key report
QTConsumer, // 16-bit key code
#ifdef MOUSE_ENABLE
QTMouseMove, // 4-byte mouse report
#endif
};
struct queue_item {
enum queue_type queue_type;
uint16_t added;
union __attribute__((packed)) {
struct __attribute__((packed)) {
uint8_t modifier;
uint8_t keys[6];
} key;
uint16_t consumer;
struct __attribute__((packed)) {
uint8_t x, y, scroll, pan;
} mousemove;
};
};
// Items that we wish to send
static RingBuffer<queue_item, 40> send_buf;
// Pending response; while pending, we can't send any more requests.
// This records the time at which we sent the command for which we
// are expecting a response.
static RingBuffer<uint16_t, 2> resp_buf;
static bool process_queue_item(struct queue_item *item, uint16_t timeout);
enum sdep_type {
SdepCommand = 0x10,
SdepResponse = 0x20,
SdepAlert = 0x40,
SdepError = 0x80,
SdepSlaveNotReady = 0xfe, // Try again later
SdepSlaveOverflow = 0xff, // You read more data than is available
};
enum ble_cmd {
BleInitialize = 0xbeef,
BleAtWrapper = 0x0a00,
BleUartTx = 0x0a01,
BleUartRx = 0x0a02,
};
enum ble_system_event_bits {
BleSystemConnected = 0,
BleSystemDisconnected = 1,
BleSystemUartRx = 8,
BleSystemMidiRx = 10,
};
// The SDEP.md file says 2MHz but the web page and the sample driver
// both use 4MHz
#define SpiBusSpeed 4000000
#define SdepTimeout 150 /* milliseconds */
#define SdepShortTimeout 10 /* milliseconds */
#define SdepBackOff 25 /* microseconds */
#define BatteryUpdateInterval 10000 /* milliseconds */
static bool at_command(const char *cmd, char *resp, uint16_t resplen,
bool verbose, uint16_t timeout = SdepTimeout);
static bool at_command_P(const char *cmd, char *resp, uint16_t resplen,
bool verbose = false);
struct SPI_Settings {
uint8_t spcr, spsr;
};
static struct SPI_Settings spi;
// Initialize 4Mhz MSBFIRST MODE0
void SPI_init(struct SPI_Settings *spi) {
spi->spcr = _BV(SPE) | _BV(MSTR);
spi->spsr = _BV(SPI2X);
static_assert(SpiBusSpeed == F_CPU / 2, "hard coded at 4Mhz");
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
// Ensure that SS is OUTPUT High
digitalWrite(B0, PinLevelHigh);
pinMode(B0, PinDirectionOutput);
SPCR |= _BV(MSTR);
SPCR |= _BV(SPE);
pinMode(B1 /* SCK */, PinDirectionOutput);
pinMode(B2 /* MOSI */, PinDirectionOutput);
}
}
static inline void SPI_begin(struct SPI_Settings*spi) {
SPCR = spi->spcr;
SPSR = spi->spsr;
}
static inline uint8_t SPI_TransferByte(uint8_t data) {
SPDR = data;
asm volatile("nop");
while (!(SPSR & _BV(SPIF))) {
; // wait
}
return SPDR;
}
static inline void spi_send_bytes(const uint8_t *buf, uint8_t len) {
if (len == 0) return;
const uint8_t *end = buf + len;
while (buf < end) {
SPDR = *buf;
while (!(SPSR & _BV(SPIF))) {
; // wait
}
++buf;
}
}
static inline uint16_t spi_read_byte(void) {
return SPI_TransferByte(0x00 /* dummy */);
}
static inline void spi_recv_bytes(uint8_t *buf, uint8_t len) {
const uint8_t *end = buf + len;
if (len == 0) return;
while (buf < end) {
SPDR = 0; // write a dummy to initiate read
while (!(SPSR & _BV(SPIF))) {
; // wait
}
*buf = SPDR;
++buf;
}
}
#if 0
static void dump_pkt(const struct sdep_msg *msg) {
print("pkt: type=");
print_hex8(msg->type);
print(" cmd=");
print_hex8(msg->cmd_high);
print_hex8(msg->cmd_low);
print(" len=");
print_hex8(msg->len);
print(" more=");
print_hex8(msg->more);
print("\n");
}
#endif
// Send a single SDEP packet
static bool sdep_send_pkt(const struct sdep_msg *msg, uint16_t timeout) {
SPI_begin(&spi);
digitalWrite(AdafruitBleCSPin, PinLevelLow);
uint16_t timerStart = timer_read();
bool success = false;
bool ready = false;
do {
ready = SPI_TransferByte(msg->type) != SdepSlaveNotReady;
if (ready) {
break;
}
// Release it and let it initialize
digitalWrite(AdafruitBleCSPin, PinLevelHigh);
_delay_us(SdepBackOff);
digitalWrite(AdafruitBleCSPin, PinLevelLow);
} while (timer_elapsed(timerStart) < timeout);
if (ready) {
// Slave is ready; send the rest of the packet
spi_send_bytes(&msg->cmd_low,
sizeof(*msg) - (1 + sizeof(msg->payload)) + msg->len);
success = true;
}
digitalWrite(AdafruitBleCSPin, PinLevelHigh);
return success;
}
static inline void sdep_build_pkt(struct sdep_msg *msg, uint16_t command,
const uint8_t *payload, uint8_t len,
bool moredata) {
msg->type = SdepCommand;
msg->cmd_low = command & 0xff;
msg->cmd_high = command >> 8;
msg->len = len;
msg->more = (moredata && len == SdepMaxPayload) ? 1 : 0;
static_assert(sizeof(*msg) == 20, "msg is correctly packed");
memcpy(msg->payload, payload, len);
}
// Read a single SDEP packet
static bool sdep_recv_pkt(struct sdep_msg *msg, uint16_t timeout) {
bool success = false;
uint16_t timerStart = timer_read();
bool ready = false;
do {
ready = digitalRead(AdafruitBleIRQPin);
if (ready) {
break;
}
_delay_us(1);
} while (timer_elapsed(timerStart) < timeout);
if (ready) {
SPI_begin(&spi);
digitalWrite(AdafruitBleCSPin, PinLevelLow);
do {
// Read the command type, waiting for the data to be ready
msg->type = spi_read_byte();
if (msg->type == SdepSlaveNotReady || msg->type == SdepSlaveOverflow) {
// Release it and let it initialize
digitalWrite(AdafruitBleCSPin, PinLevelHigh);
_delay_us(SdepBackOff);
digitalWrite(AdafruitBleCSPin, PinLevelLow);
continue;
}
// Read the rest of the header
spi_recv_bytes(&msg->cmd_low, sizeof(*msg) - (1 + sizeof(msg->payload)));
// and get the payload if there is any
if (msg->len <= SdepMaxPayload) {
spi_recv_bytes(msg->payload, msg->len);
}
success = true;
break;
} while (timer_elapsed(timerStart) < timeout);
digitalWrite(AdafruitBleCSPin, PinLevelHigh);
}
return success;
}
static void resp_buf_read_one(bool greedy) {
uint16_t last_send;
if (!resp_buf.peek(last_send)) {
return;
}
if (digitalRead(AdafruitBleIRQPin)) {
struct sdep_msg msg;
again:
if (sdep_recv_pkt(&msg, SdepTimeout)) {
if (!msg.more) {
// We got it; consume this entry
resp_buf.get(last_send);
dprintf("recv latency %dms\n", TIMER_DIFF_16(timer_read(), last_send));
}
if (greedy && resp_buf.peek(last_send) && digitalRead(AdafruitBleIRQPin)) {
goto again;
}
}
} else if (timer_elapsed(last_send) > SdepTimeout * 2) {
dprintf("waiting_for_result: timeout, resp_buf size %d\n",
(int)resp_buf.size());
// Timed out: consume this entry
resp_buf.get(last_send);
}
}
static void send_buf_send_one(uint16_t timeout = SdepTimeout) {
struct queue_item item;
// Don't send anything more until we get an ACK
if (!resp_buf.empty()) {
return;
}
if (!send_buf.peek(item)) {
return;
}
if (process_queue_item(&item, timeout)) {
// commit that peek
send_buf.get(item);
dprintf("send_buf_send_one: have %d remaining\n", (int)send_buf.size());
} else {
dprint("failed to send, will retry\n");
_delay_ms(SdepTimeout);
resp_buf_read_one(true);
}
}
static void resp_buf_wait(const char *cmd) {
bool didPrint = false;
while (!resp_buf.empty()) {
if (!didPrint) {
dprintf("wait on buf for %s\n", cmd);
didPrint = true;
}
resp_buf_read_one(true);
}
}
static bool ble_init(void) {
state.initialized = false;
state.configured = false;
state.is_connected = false;
pinMode(AdafruitBleIRQPin, PinDirectionInput);
pinMode(AdafruitBleCSPin, PinDirectionOutput);
digitalWrite(AdafruitBleCSPin, PinLevelHigh);
SPI_init(&spi);
// Perform a hardware reset
pinMode(AdafruitBleResetPin, PinDirectionOutput);
digitalWrite(AdafruitBleResetPin, PinLevelHigh);
digitalWrite(AdafruitBleResetPin, PinLevelLow);
_delay_ms(10);
digitalWrite(AdafruitBleResetPin, PinLevelHigh);
_delay_ms(1000); // Give it a second to initialize
state.initialized = true;
return state.initialized;
}
static inline uint8_t min(uint8_t a, uint8_t b) {
return a < b ? a : b;
}
static bool read_response(char *resp, uint16_t resplen, bool verbose) {
char *dest = resp;
char *end = dest + resplen;
while (true) {
struct sdep_msg msg;
if (!sdep_recv_pkt(&msg, 2 * SdepTimeout)) {
dprint("sdep_recv_pkt failed\n");
return false;
}
if (msg.type != SdepResponse) {
*resp = 0;
return false;
}
uint8_t len = min(msg.len, end - dest);
if (len > 0) {
memcpy(dest, msg.payload, len);
dest += len;
}
if (!msg.more) {
// No more data is expected!
break;
}
}
// Ensure the response is NUL terminated
*dest = 0;
// "Parse" the result text; we want to snip off the trailing OK or ERROR line
// Rewind past the possible trailing CRLF so that we can strip it
--dest;
while (dest > resp && (dest[0] == '\n' || dest[0] == '\r')) {
*dest = 0;
--dest;
}
// Look back for start of preceeding line
char *last_line = strrchr(resp, '\n');
if (last_line) {
++last_line;
} else {
last_line = resp;
}
bool success = false;
static const char kOK[] PROGMEM = "OK";
success = !strcmp_P(last_line, kOK );
if (verbose || !success) {
dprintf("result: %s\n", resp);
}
return success;
}
static bool at_command(const char *cmd, char *resp, uint16_t resplen,
bool verbose, uint16_t timeout) {
const char *end = cmd + strlen(cmd);
struct sdep_msg msg;
if (verbose) {
dprintf("ble send: %s\n", cmd);
}
if (resp) {
// They want to decode the response, so we need to flush and wait
// for all pending I/O to finish before we start this one, so
// that we don't confuse the results
resp_buf_wait(cmd);
*resp = 0;
}
// Fragment the command into a series of SDEP packets
while (end - cmd > SdepMaxPayload) {
sdep_build_pkt(&msg, BleAtWrapper, (uint8_t *)cmd, SdepMaxPayload, true);
if (!sdep_send_pkt(&msg, timeout)) {
return false;
}
cmd += SdepMaxPayload;
}
sdep_build_pkt(&msg, BleAtWrapper, (uint8_t *)cmd, end - cmd, false);
if (!sdep_send_pkt(&msg, timeout)) {
return false;
}
if (resp == NULL) {
auto now = timer_read();
while (!resp_buf.enqueue(now)) {
resp_buf_read_one(false);
}
auto later = timer_read();
if (TIMER_DIFF_16(later, now) > 0) {
dprintf("waited %dms for resp_buf\n", TIMER_DIFF_16(later, now));
}
return true;
}
return read_response(resp, resplen, verbose);
}
bool at_command_P(const char *cmd, char *resp, uint16_t resplen, bool verbose) {
auto cmdbuf = (char *)alloca(strlen_P(cmd) + 1);
strcpy_P(cmdbuf, cmd);
return at_command(cmdbuf, resp, resplen, verbose);
}
bool adafruit_ble_is_connected(void) {
return state.is_connected;
}
bool adafruit_ble_enable_keyboard(void) {
char resbuf[128];
if (!state.initialized && !ble_init()) {
return false;
}
state.configured = false;
// Disable command echo
static const char kEcho[] PROGMEM = "ATE=0";
// Make the advertised name match the keyboard
static const char kGapDevName[] PROGMEM =
"AT+GAPDEVNAME=" STR(PRODUCT) " " STR(DESCRIPTION);
// Turn on keyboard support
static const char kHidEnOn[] PROGMEM = "AT+BLEHIDEN=1";
// Adjust intervals to improve latency. This causes the "central"
// system (computer/tablet) to poll us every 10-30 ms. We can't
// set a smaller value than 10ms, and 30ms seems to be the natural
// processing time on my macbook. Keeping it constrained to that
// feels reasonable to type to.
static const char kGapIntervals[] PROGMEM = "AT+GAPINTERVALS=10,30,,";
// Reset the device so that it picks up the above changes
static const char kATZ[] PROGMEM = "ATZ";
// Turn down the power level a bit
static const char kPower[] PROGMEM = "AT+BLEPOWERLEVEL=-12";
static PGM_P const configure_commands[] PROGMEM = {
kEcho,
kGapIntervals,
kGapDevName,
kHidEnOn,
kPower,
kATZ,
};
uint8_t i;
for (i = 0; i < sizeof(configure_commands) / sizeof(configure_commands[0]);
++i) {
PGM_P cmd;
memcpy_P(&cmd, configure_commands + i, sizeof(cmd));
if (!at_command_P(cmd, resbuf, sizeof(resbuf))) {
dprintf("failed BLE command: %S: %s\n", cmd, resbuf);
goto fail;
}
}
state.configured = true;
// Check connection status in a little while; allow the ATZ time
// to kick in.
state.last_connection_update = timer_read();
fail:
return state.configured;
}
static void set_connected(bool connected) {
if (connected != state.is_connected) {
if (connected) {
print("****** BLE CONNECT!!!!\n");
} else {
print("****** BLE DISCONNECT!!!!\n");
}
state.is_connected = connected;
// TODO: if modifiers are down on the USB interface and
// we cut over to BLE or vice versa, they will remain stuck.
// This feels like a good point to do something like clearing
// the keyboard and/or generating a fake all keys up message.
// However, I've noticed that it takes a couple of seconds
// for macOS to to start recognizing key presses after BLE
// is in the connected state, so I worry that doing that
// here may not be good enough.
}
}
void adafruit_ble_task(void) {
char resbuf[48];
if (!state.configured && !adafruit_ble_enable_keyboard()) {
return;
}
resp_buf_read_one(true);
send_buf_send_one(SdepShortTimeout);
if (resp_buf.empty() && (state.event_flags & UsingEvents) &&
digitalRead(AdafruitBleIRQPin)) {
// Must be an event update
if (at_command_P(PSTR("AT+EVENTSTATUS"), resbuf, sizeof(resbuf))) {
uint32_t mask = strtoul(resbuf, NULL, 16);
if (mask & BleSystemConnected) {
set_connected(true);
} else if (mask & BleSystemDisconnected) {
set_connected(false);
}
}
}
if (timer_elapsed(state.last_connection_update) > ConnectionUpdateInterval) {
bool shouldPoll = true;
if (!(state.event_flags & ProbedEvents)) {
// Request notifications about connection status changes.
// This only works in SPIFRIEND firmware > 0.6.7, which is why
// we check for this conditionally here.
// Note that at the time of writing, HID reports only work correctly
// with Apple products on firmware version 0.6.7!
// https://forums.adafruit.com/viewtopic.php?f=8&t=104052
if (at_command_P(PSTR("AT+EVENTENABLE=0x1"), resbuf, sizeof(resbuf))) {
at_command_P(PSTR("AT+EVENTENABLE=0x2"), resbuf, sizeof(resbuf));
state.event_flags |= UsingEvents;
}
state.event_flags |= ProbedEvents;
// leave shouldPoll == true so that we check at least once
// before relying solely on events
} else {
shouldPoll = false;
}
static const char kGetConn[] PROGMEM = "AT+GAPGETCONN";
state.last_connection_update = timer_read();
if (at_command_P(kGetConn, resbuf, sizeof(resbuf))) {
set_connected(atoi(resbuf));
}
}
#ifdef SAMPLE_BATTERY
// I don't know if this really does anything useful yet; the reported
// voltage level always seems to be around 3200mV. We may want to just rip
// this code out.
if (timer_elapsed(state.last_battery_update) > BatteryUpdateInterval &&
resp_buf.empty()) {
state.last_battery_update = timer_read();
if (at_command_P(PSTR("AT+HWVBAT"), resbuf, sizeof(resbuf))) {
state.vbat = atoi(resbuf);
}
}
#endif
}
static bool process_queue_item(struct queue_item *item, uint16_t timeout) {
char cmdbuf[48];
char fmtbuf[64];
// Arrange to re-check connection after keys have settled
state.last_connection_update = timer_read();
#if 1
if (TIMER_DIFF_16(state.last_connection_update, item->added) > 0) {
dprintf("send latency %dms\n",
TIMER_DIFF_16(state.last_connection_update, item->added));
}
#endif
switch (item->queue_type) {
case QTKeyReport:
strcpy_P(fmtbuf,
PSTR("AT+BLEKEYBOARDCODE=%02x-00-%02x-%02x-%02x-%02x-%02x-%02x"));
snprintf(cmdbuf, sizeof(cmdbuf), fmtbuf, item->key.modifier,
item->key.keys[0], item->key.keys[1], item->key.keys[2],
item->key.keys[3], item->key.keys[4], item->key.keys[5]);
return at_command(cmdbuf, NULL, 0, true, timeout);
case QTConsumer:
strcpy_P(fmtbuf, PSTR("AT+BLEHIDCONTROLKEY=0x%04x"));
snprintf(cmdbuf, sizeof(cmdbuf), fmtbuf, item->consumer);
return at_command(cmdbuf, NULL, 0, true, timeout);
#ifdef MOUSE_ENABLE
case QTMouseMove:
strcpy_P(fmtbuf, PSTR("AT+BLEHIDMOUSEMOVE=%d,%d,%d,%d"));
snprintf(cmdbuf, sizeof(cmdbuf), fmtbuf, item->mousemove.x,
item->mousemove.y, item->mousemove.scroll, item->mousemove.pan);
return at_command(cmdbuf, NULL, 0, true, timeout);
#endif
default:
return true;
}
}
bool adafruit_ble_send_keys(uint8_t hid_modifier_mask, uint8_t *keys,
uint8_t nkeys) {
struct queue_item item;
bool didWait = false;
item.queue_type = QTKeyReport;
item.key.modifier = hid_modifier_mask;
item.added = timer_read();
while (nkeys >= 0) {
item.key.keys[0] = keys[0];
item.key.keys[1] = nkeys >= 1 ? keys[1] : 0;
item.key.keys[2] = nkeys >= 2 ? keys[2] : 0;
item.key.keys[3] = nkeys >= 3 ? keys[3] : 0;
item.key.keys[4] = nkeys >= 4 ? keys[4] : 0;
item.key.keys[5] = nkeys >= 5 ? keys[5] : 0;
if (!send_buf.enqueue(item)) {
if (!didWait) {
dprint("wait for buf space\n");
didWait = true;
}
send_buf_send_one();
continue;
}
if (nkeys <= 6) {
return true;
}
nkeys -= 6;
keys += 6;
}
return true;
}
bool adafruit_ble_send_consumer_key(uint16_t keycode, int hold_duration) {
struct queue_item item;
item.queue_type = QTConsumer;
item.consumer = keycode;
while (!send_buf.enqueue(item)) {
send_buf_send_one();
}
return true;
}
#ifdef MOUSE_ENABLE
bool adafruit_ble_send_mouse_move(int8_t x, int8_t y, int8_t scroll,
int8_t pan) {
struct queue_item item;
item.queue_type = QTMouseMove;
item.mousemove.x = x;
item.mousemove.y = y;
item.mousemove.scroll = scroll;
item.mousemove.pan = pan;
while (!send_buf.enqueue(item)) {
send_buf_send_one();
}
return true;
}
#endif
uint32_t adafruit_ble_read_battery_voltage(void) {
return state.vbat;
}
bool adafruit_ble_set_mode_leds(bool on) {
if (!state.configured) {
return false;
}
// The "mode" led is the red blinky one
at_command_P(on ? PSTR("AT+HWMODELED=1") : PSTR("AT+HWMODELED=0"), NULL, 0);
// Pin 19 is the blue "connected" LED; turn that off too.
// When turning LEDs back on, don't turn that LED on if we're
// not connected, as that would be confusing.
at_command_P(on && state.is_connected ? PSTR("AT+HWGPIO=19,1")
: PSTR("AT+HWGPIO=19,0"),
NULL, 0);
return true;
}
// https://learn.adafruit.com/adafruit-feather-32u4-bluefruit-le/ble-generic#at-plus-blepowerlevel
bool adafruit_ble_set_power_level(int8_t level) {
char cmd[46];
if (!state.configured) {
return false;
}
snprintf(cmd, sizeof(cmd), "AT+BLEPOWERLEVEL=%d", level);
return at_command(cmd, NULL, 0, false);
}

60
tmk_core/protocol/lufa/adafruit_ble.h 100644
View File

@ -0,0 +1,60 @@
/* Bluetooth Low Energy Protocol for QMK.
* Author: Wez Furlong, 2016
* Supports the Adafruit BLE board built around the nRF51822 chip.
*/
#pragma once
#ifdef ADAFRUIT_BLE_ENABLE
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#ifdef __cplusplus
extern "C" {
#endif
/* Instruct the module to enable HID keyboard support and reset */
extern bool adafruit_ble_enable_keyboard(void);
/* Query to see if the BLE module is connected */
extern bool adafruit_ble_query_is_connected(void);
/* Returns true if we believe that the BLE module is connected.
* This uses our cached understanding that is maintained by
* calling ble_task() periodically. */
extern bool adafruit_ble_is_connected(void);
/* Call this periodically to process BLE-originated things */
extern void adafruit_ble_task(void);
/* Generates keypress events for a set of keys.
* The hid modifier mask specifies the state of the modifier keys for
* this set of keys.
* Also sends a key release indicator, so that the keys do not remain
* held down. */
extern bool adafruit_ble_send_keys(uint8_t hid_modifier_mask, uint8_t *keys,
uint8_t nkeys);
/* Send a consumer keycode, holding it down for the specified duration
* (milliseconds) */
extern bool adafruit_ble_send_consumer_key(uint16_t keycode, int hold_duration);
#ifdef MOUSE_ENABLE
/* Send a mouse/wheel movement report.
* The parameters are signed and indicate positive of negative direction
* change. */
extern bool adafruit_ble_send_mouse_move(int8_t x, int8_t y, int8_t scroll,
int8_t pan);
#endif
/* Compute battery voltage by reading an analog pin.
* Returns the integer number of millivolts */
extern uint32_t adafruit_ble_read_battery_voltage(void);
extern bool adafruit_ble_set_mode_leds(bool on);
extern bool adafruit_ble_set_power_level(int8_t level);
#ifdef __cplusplus
}
#endif
#endif // ADAFRUIT_BLE_ENABLE

141
tmk_core/protocol/lufa/lufa.c
View File

@ -51,6 +51,8 @@
#include "descriptor.h"
#include "lufa.h"
#include "quantum.h"
#include <util/atomic.h>
#ifdef NKRO_ENABLE
#include "keycode_config.h"
@ -66,11 +68,22 @@
#ifdef BLUETOOTH_ENABLE
#include "bluetooth.h"
#endif
#ifdef ADAFRUIT_BLE_ENABLE
#include "adafruit_ble.h"
#endif
#ifdef VIRTSER_ENABLE
#include "virtser.h"
#endif
#if (defined(RGB_MIDI) | defined(RGBLIGHT_ANIMATIONS)) & defined(RGBLIGHT_ENABLE)
#include "rgblight.h"
#endif
#ifdef MIDI_ENABLE
#include "sysex_tools.h"
#endif
uint8_t keyboard_idle = 0;
/* 0: Boot Protocol, 1: Report Protocol(default) */
uint8_t keyboard_protocol = 1;
@ -79,9 +92,9 @@ static uint8_t keyboard_led_stats = 0;
static report_keyboard_t keyboard_report_sent;
#ifdef MIDI_ENABLE
void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2);
void usb_get_midi(MidiDevice * device);
void midi_usb_init(MidiDevice * device);
static void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2);
static void usb_get_midi(MidiDevice * device);
static void midi_usb_init(MidiDevice * device);
#endif
/* Host driver */
@ -288,7 +301,9 @@ void EVENT_USB_Device_WakeUp()
#ifdef CONSOLE_ENABLE
static bool console_flush = false;
#define CONSOLE_FLUSH_SET(b) do { \
uint8_t sreg = SREG; cli(); console_flush = b; SREG = sreg; \
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {\
console_flush = b; \
} \
} while (0)
// called every 1ms
@ -492,9 +507,35 @@ static uint8_t keyboard_leds(void)
return keyboard_led_stats;
}
#define SendToUSB 1
#define SendToBT 2
#define SendToBLE 4
static inline uint8_t where_to_send(void) {
#ifdef ADAFRUIT_BLE_ENABLE
#if 0
if (adafruit_ble_is_connected()) {
// For testing, send to BLE as a priority
return SendToBLE;
}
#endif
// This is the real policy
if (USB_DeviceState != DEVICE_STATE_Configured) {
if (adafruit_ble_is_connected()) {
return SendToBLE;
}
}
#endif
return ((USB_DeviceState == DEVICE_STATE_Configured) ? SendToUSB : 0)
#ifdef BLUETOOTH_ENABLE
|| SendToBT
#endif
;
}
static void send_keyboard(report_keyboard_t *report)
{
#ifdef BLUETOOTH_ENABLE
bluefruit_serial_send(0xFD);
for (uint8_t i = 0; i < KEYBOARD_EPSIZE; i++) {
@ -503,9 +544,17 @@ static void send_keyboard(report_keyboard_t *report)
#endif
uint8_t timeout = 255;
uint8_t where = where_to_send();
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
#ifdef ADAFRUIT_BLE_ENABLE
if (where & SendToBLE) {
adafruit_ble_send_keys(report->mods, report->keys, sizeof(report->keys));
}
#endif
if (!(where & SendToUSB)) {
return;
}
/* Select the Keyboard Report Endpoint */
#ifdef NKRO_ENABLE
@ -558,8 +607,17 @@ static void send_mouse(report_mouse_t *report)
uint8_t timeout = 255;
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
uint8_t where = where_to_send();
#ifdef ADAFRUIT_BLE_ENABLE
if (where & SendToBLE) {
// FIXME: mouse buttons
adafruit_ble_send_mouse_move(report->x, report->y, report->v, report->h);
}
#endif
if (!(where & SendToUSB)) {
return;
}
/* Select the Mouse Report Endpoint */
Endpoint_SelectEndpoint(MOUSE_IN_EPNUM);
@ -617,9 +675,16 @@ static void send_consumer(uint16_t data)
#endif
uint8_t timeout = 255;
uint8_t where = where_to_send();
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
#ifdef ADAFRUIT_BLE_ENABLE
if (where & SendToBLE) {
adafruit_ble_send_consumer_key(data, 0);
}
#endif
if (!(where & SendToUSB)) {
return;
}
report_extra_t r = {
.report_id = REPORT_ID_CONSUMER,
@ -709,7 +774,7 @@ int8_t sendchar(uint8_t c)
******************************************************************************/
#ifdef MIDI_ENABLE
void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
static void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
MIDI_EventPacket_t event;
event.Data1 = byte0;
event.Data2 = byte1;
@ -769,7 +834,7 @@ void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byt
USB_USBTask();
}
void usb_get_midi(MidiDevice * device) {
static void usb_get_midi(MidiDevice * device) {
MIDI_EventPacket_t event;
while (MIDI_Device_ReceiveEventPacket(&USB_MIDI_Interface, &event)) {
@ -799,12 +864,12 @@ void usb_get_midi(MidiDevice * device) {
USB_USBTask();
}
void midi_usb_init(MidiDevice * device){
static void midi_usb_init(MidiDevice * device){
midi_device_init(device);
midi_device_set_send_func(device, usb_send_func);
midi_device_set_pre_input_process_func(device, usb_get_midi);
SetupHardware();
// SetupHardware();
sei();
}
@ -1029,7 +1094,7 @@ int main(void)
print("Keyboard start.\n");
while (1) {
#ifndef BLUETOOTH_ENABLE
#if !defined(BLUETOOTH_ENABLE) && !defined(ADAFRUIT_BLE_ENABLE)
while (USB_DeviceState == DEVICE_STATE_Suspended) {
print("[s]");
suspend_power_down();
@ -1039,11 +1104,20 @@ int main(void)
}
#endif
keyboard_task();
#ifdef MIDI_ENABLE
midi_device_process(&midi_device);
// MIDI_Task();
#endif
keyboard_task();
#if defined(RGBLIGHT_ANIMATIONS) & defined(RGBLIGHT_ENABLE)
rgblight_task();
#endif
#ifdef ADAFRUIT_BLE_ENABLE
adafruit_ble_task();
#endif
#ifdef VIRTSER_ENABLE
virtser_task();
@ -1077,15 +1151,38 @@ void fallthrough_callback(MidiDevice * device,
#endif
}
void cc_callback(MidiDevice * device,
uint8_t chan, uint8_t num, uint8_t val) {
//sending it back on the next channel
midi_send_cc(device, (chan + 1) % 16, num, val);
// midi_send_cc(device, (chan + 1) % 16, num, val);
}
void sysex_callback(MidiDevice * device,
uint16_t start, uint8_t length, uint8_t * data) {
for (int i = 0; i < length; i++)
midi_send_cc(device, 15, 0x7F & data[i], 0x7F & (start + i));
uint8_t midi_buffer[MIDI_SYSEX_BUFFER] = {0};
void sysex_callback(MidiDevice * device, uint16_t start, uint8_t length, uint8_t * data) {
#ifdef API_SYSEX_ENABLE
// SEND_STRING("\n");
// send_word(start);
// SEND_STRING(": ");
for (uint8_t place = 0; place < length; place++) {
// send_byte(*data);
midi_buffer[start + place] = *data;
if (*data == 0xF7) {
// SEND_STRING("\nRD: ");
// for (uint8_t i = 0; i < start + place + 1; i++){
// send_byte(midi_buffer[i]);
// SEND_STRING(" ");
// }
uint8_t * decoded = malloc(sizeof(uint8_t) * (sysex_decoded_length(start + place - 4)));
uint16_t decode_length = sysex_decode(decoded, midi_buffer + 4, start + place - 4);
process_api(decode_length, decoded);
}
// SEND_STRING(" ");
data++;
}
#endif
}
#endif

13
tmk_core/protocol/lufa/lufa.h
View File

@ -68,8 +68,17 @@ typedef struct {
} __attribute__ ((packed)) report_extra_t;
#ifdef MIDI_ENABLE
void MIDI_Task(void);
MidiDevice midi_device;
void MIDI_Task(void);
MidiDevice midi_device;
#define MIDI_SYSEX_BUFFER 32
#endif
#ifdef API_ENABLE
#include "api.h"
#endif
#ifdef API_SYSEX_ENABLE
#include "api_sysex.h"
#endif
// #if LUFA_VERSION_INTEGER < 0x120730

66
tmk_core/protocol/lufa/ringbuffer.hpp 100644
View File

@ -0,0 +1,66 @@
#pragma once
// A simple ringbuffer holding Size elements of type T
template <typename T, uint8_t Size>
class RingBuffer {
protected:
T buf_[Size];
uint8_t head_{0}, tail_{0};
public:
inline uint8_t nextPosition(uint8_t position) {
return (position + 1) % Size;
}
inline uint8_t prevPosition(uint8_t position) {
if (position == 0) {
return Size - 1;
}
return position - 1;
}
inline bool enqueue(const T &item) {
static_assert(Size > 1, "RingBuffer size must be > 1");
uint8_t next = nextPosition(head_);
if (next == tail_) {
// Full
return false;
}
buf_[head_] = item;
head_ = next;
return true;
}
inline bool get(T &dest, bool commit = true) {
auto tail = tail_;
if (tail == head_) {
// No more data
return false;
}
dest = buf_[tail];
tail = nextPosition(tail);
if (commit) {
tail_ = tail;
}
return true;
}
inline bool empty() const { return head_ == tail_; }
inline uint8_t size() const {
int diff = head_ - tail_;
if (diff >= 0) {
return diff;
}
return Size + diff;
}
inline T& front() {
return buf_[tail_];
}
inline bool peek(T &item) {
return get(item, false);
}
};

1
tmk_core/protocol/midi.mk
View File

@ -4,6 +4,7 @@ SRC += midi.c \
midi_device.c \
bytequeue/bytequeue.c \
bytequeue/interrupt_setting.c \
sysex_tools.c \
$(LUFA_SRC_USBCLASS)
VPATH += $(TMK_PATH)/$(MIDI_DIR)

Some files were not shown because too many files have changed in this diff Show More