@ -0,0 +1,29 @@ | |||
# Zach Planck Makefile | |||
# Max .hex size is about 28636 bytes | |||
# 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 | |||
# | |||
TAP_DANCE_ENABLE = yes # Enable TapDance functionality | |||
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000) | |||
MOUSEKEY_ENABLE = no # Mouse keys(+4700) | |||
EXTRAKEY_ENABLE = no # Audio control and System control(+450) | |||
CONSOLE_ENABLE = no # Console for debug(+400) | |||
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 | |||
USB_6KRO_ENABLE = no # 6key Rollover | |||
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality | |||
MIDI_ENABLE = no # MIDI controls | |||
AUDIO_ENABLE = no # Audio output on port C6 | |||
VARIABLE_TRACE = no # Debug changes to variable values | |||
UNICODE_ENABLE = yes # Unicode | |||
UNICODEMAP_ENABLE = yes # Enable extended 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 |
@ -0,0 +1,91 @@ | |||
/* | |||
Copyright 2012 Jun Wako <wakojun@gmail.com> | |||
This program is free software: you can redistribute it and/or modify | |||
it under the terms of the GNU General Public License as published by | |||
the Free Software Foundation, either version 2 of the License, or | |||
(at your option) any later version. | |||
This program is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
GNU General Public License for more details. | |||
You should have received a copy of the GNU General Public License | |||
along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
*/ | |||
#ifndef CONFIG_H | |||
#define CONFIG_H | |||
#include "config_common.h" | |||
/* USB Device descriptor parameter */ | |||
#define VENDOR_ID 0xFEED | |||
#define PRODUCT_ID 0x6060 | |||
#define MANUFACTURER Ortholinear Keyboards | |||
#define PRODUCT The Planck Keyboard | |||
#define DESCRIPTION A compact ortholinear keyboard | |||
/* key matrix size */ | |||
#define MATRIX_ROWS 4 | |||
#define MATRIX_COLS 12 | |||
/* Planck PCB default pin-out */ | |||
#define MATRIX_ROW_PINS { D0, D5, B5, B6 } | |||
#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 } | |||
#define UNUSED_PINS | |||
#define BACKLIGHT_PIN B7 | |||
/* COL2ROW or ROW2COL */ | |||
#define DIODE_DIRECTION COL2ROW | |||
/* define if matrix has ghost */ | |||
//#define MATRIX_HAS_GHOST | |||
//#define BACKLIGHT_BREATHING // LED breathing | |||
/* number of backlight levels */ | |||
#define BACKLIGHT_LEVELS 5 | |||
/* Set 0 if debouncing isn't needed */ | |||
#define DEBOUNCING_DELAY 5 | |||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */ | |||
//#define LOCKING_SUPPORT_ENABLE | |||
/* Locking resynchronize hack */ | |||
//#define LOCKING_RESYNC_ENABLE | |||
/* key combination for command */ | |||
#define IS_COMMAND() ( \ | |||
keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \ | |||
) | |||
/* | |||
* Feature disable options | |||
* These options are also useful to firmware size reduction. | |||
*/ | |||
/* disable debug print */ | |||
//#define NO_DEBUG | |||
/* disable print */ | |||
//#define NO_PRINT | |||
/* disable action features */ | |||
//#define NO_ACTION_LAYER | |||
#define NO_ACTION_TAPPING | |||
#define NO_ACTION_ONESHOT | |||
#define NO_ACTION_MACRO | |||
#define NO_ACTION_FUNCTION | |||
#define PREVENT_STUCK_MODIFIERS | |||
//#define DYNAMIC_MACRO_ENABLE // Enable if you need to use the macro functionality | |||
//#define SPACE_CADET // Parenthesis on L/R shift | |||
#ifdef SUBPROJECT_rev3 | |||
#include "rev3/config.h" | |||
#endif | |||
#ifdef SUBPROJECT_rev4 | |||
#include "rev4/config.h" | |||
#endif | |||
#endif |
@ -0,0 +1,48 @@ | |||
// Zach Nielsen Custom Planck Keyboard layout | |||
#include "planck.h" | |||
#define PLANCK_YES // This is the Planck | |||
#include "zach_common_functions.c" | |||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
[_COLEMAK] = { /* Base Layer */ | |||
{KC_ESC, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_QUOT, KC_BSPC}, | |||
{KC_BSPC, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_ENT}, | |||
{SHFT_CAP,KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT}, | |||
{CTRLB, TD(SUP), KC_LALT, KC_LCTL, TD(LOW), KC_SPC, KC_SPC, TD(RAI), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT} | |||
}, | |||
[_SWCOLE] = { /* Software Colemak */ | |||
{_______, CM_Q, CM_W, CM_F, CM_P, CM_G, CM_J, CM_L, CM_U, CM_Y, KC_QUOT, _______}, | |||
{_______, CM_A, CM_R, CM_S, CM_T, CM_D, CM_H, CM_N, CM_E, CM_I, CM_O, _______}, | |||
{_______, CM_Z, CM_X, CM_C, CM_V, CM_B, CM_K, CM_M, CM_COMM, CM_DOT, CM_SLSH, _______}, | |||
{_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______} | |||
}, | |||
[_RAISE] = { /* RAISE - Numpad and Unicode symbols */ | |||
{KC_GRV, SUPA2, FACE, DISFACE, SHRUG, PLUMIN, IBANG, KC_7, KC_8, KC_9, KC_COLN, _______}, | |||
{KC_DEL, DEGREE, MICRO, WOMEGA, OMEGA, PENGY, KC_ENT, KC_4, KC_5, KC_6, KC_SLSH, KC_ASTR}, | |||
{_______, KC_COLN, TFLIP, LAROW, RAROW, DUCK, KC_SPC, KC_1, KC_2, KC_3, KC_MINS, KC_PLUS}, | |||
{_______, KC_PIPE, TPUT, _______, _______, KC_TAB, KC_TAB, _______, KC_0, KC_0, KC_DOT, KC_EQL} | |||
}, | |||
[_LOWER] = { /* LOWER - Symbols, Paging, CtrAltDel */ | |||
{KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_QUES, KC_DQT, KC_DEL}, | |||
{KC_DEL, KC_LBRC, KC_RBRC, KC_MINS, KC_UNDS, KC_HOME, KC_END, KC_LPRN, KC_RPRN, KC_SLSH, KC_SCLN, KC_PGUP}, | |||
{CPYPST, XXXXXXX, C(KC_X), KC_LABK, KC_RABK, XXXXXXX, XXXXXXX, KC_LCBR, KC_RCBR, KC_BSLS, KC_COLN, KC_PGDN}, | |||
{_______, _______, _______, _______, _______, KC_TAB, KC_TAB, _______, _______, _______, _______, _______} | |||
}, | |||
[_ADJUST] = { /* ADJUST - Macros, Layer Switching, Function Keys */ | |||
{UNIWIN, Sil_Usr, Sil_Pas, PENGY, DUCK, KC_INS, KC_NLCK, KC_F1, KC_F2, KC_F3, KC_F4, XXXXXXX}, | |||
{UNILIN, UltiU, UltiP, RANDIG, RANDIG, SWCOLE, COLEMAK, KC_F5, KC_F6, KC_F7, KC_F8, XXXXXXX}, | |||
{_______, CADKEY, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_F9, KC_F10, KC_F11, KC_F12, XXXXXXX}, | |||
{_______, _______, _______, _______, _______, RESET, RESET, _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX} | |||
}, | |||
[_UNICODES] = { /* UNICODES - Extra layer for unicode stuff */ | |||
{_______, TFLIP, XXXXXXX, FINGER, IBANG, roman7, XXXXXXX, XXXXXXX, ROMAN7, TappyL, TappyR, _______}, | |||
{KC_DEL, TPUT, FACE, DISFACE, SHRUG, roman4, roman5, roman6, ROMAN4, ROMAN5, ROMAN6, _______}, | |||
{XXXXXXX, PENIS, BOOBS, LAROW, RAROW, roman1, roman2, roman3, ROMAN1, ROMAN2, ROMAN3, XXXXXXX}, | |||
{_______, _______, _______, _______, _______, KC_SPC, KC_SPC, _______, _______, _______, _______, _______} | |||
} | |||
}; |
@ -0,0 +1,538 @@ | |||
#ifndef ZACH_COMMON_FUNCTIONS | |||
#define ZACH_COMMON_FUNCTIONS | |||
#include "eeconfig.h" | |||
#include "action_layer.h" | |||
#include "keymap_colemak.h" | |||
#include "extra_functions.c" | |||
extern keymap_config_t keymap_config; | |||
// Fillers to make layering more clear | |||
#define _______ KC_TRNS | |||
#define XXXXXXX KC_NO | |||
#define C(n) RCTL(n) | |||
#define CADKEY RCTL(RALT(KC_DEL)) | |||
void tap(uint16_t keycode){ | |||
register_code(keycode); | |||
unregister_code(keycode); | |||
}; | |||
void persistant_default_layer_set(uint16_t default_layer){ | |||
eeconfig_update_default_layer(default_layer); | |||
default_layer_set(default_layer); | |||
}; | |||
// Automatic number generation of important keywords | |||
enum my_keycodes{ | |||
// Layer numbers | |||
_COLEMAK = 0, | |||
_SWCOLE, | |||
_RAISE, | |||
_LOWER, | |||
_ADJUST, | |||
_UNICODES, | |||
// These use process_record_user() | |||
COLEMAK = SAFE_RANGE, | |||
SWCOLE, | |||
LOWER, | |||
RAISE, | |||
SHFT_CAP, | |||
CTRLB, | |||
CPYPST, | |||
FACE, | |||
UNIWIN, | |||
UNILIN, | |||
DISFACE, | |||
TFLIP, | |||
TPUT, | |||
SHRUG, | |||
PENIS, | |||
BOOBS, | |||
Sil_Pas, | |||
Sil_Usr, | |||
UltiU, | |||
UltiP, | |||
TappyR, | |||
TappyL, | |||
RANDIG, | |||
FINGER, | |||
// Tap_Dance nums | |||
RAI = 0, | |||
LOW, | |||
SUP | |||
}; | |||
#ifdef AUDIO_ENABLE | |||
#include "audio.h" | |||
float tone_startup[][2] = SONG(STARTUP_SOUND); | |||
float tone_goodbye[][2] = SONG(GOODBYE_SOUND); | |||
float tone_colemak[][2] = SONG(COLEMAK_SOUND); | |||
float tone_swcole[][2] = SONG(QWERTY_SOUND); | |||
float tone_capslock_on[][2] = SONG(CAPS_LOCK_ON_SOUND); | |||
float tone_capslock_off[][2] = SONG(CAPS_LOCK_OFF_SOUND); | |||
float tone_ctrl_mod[][2] = SONG(COIN_SOUND); | |||
float tone_copy[][2] = SONG(SCROLL_LOCK_ON_SOUND); | |||
float tone_paste[][2] = SONG(SCROLL_LOCK_OFF_SOUND); | |||
float uniwin[][2] = SONG(UNICODE_WINDOWS); | |||
float unilin[][2] = SONG(UNICODE_LINUX); | |||
#endif | |||
#ifdef TAP_DANCE_ENABLE | |||
#define TAPPING_TERM 200 | |||
uint8_t Lstate = 0, Rstate = 0; | |||
uint32_t Ltimer = 0, Rtimer = 0; | |||
uint32_t Ltimes[3], Rtimes[4]; // Ratio of tap times should be about 1.335 (L/R) | |||
void rhythm_parse(void){ | |||
int L = Ltimes[0] + Ltimes[1] + Ltimes[2]; // Start to end time | |||
int R = Rtimes[0] + Rtimes[1] + Rtimes[2] + Rtimes[3]; | |||
if(abs(R-L) > 10){ | |||
tap(KC_N); tap(KC_O); | |||
return; | |||
} else { | |||
L = (L / 3)*100; // Average time per tap * 100 | |||
R = (R / 4); | |||
if(abs(abs(L/R)-133) > 1){ | |||
tap(KC_N); tap(KC_O); | |||
tap(KC_P); tap(KC_E); | |||
return; | |||
} else { | |||
tap(KC_O); tap(KC_K); | |||
return; | |||
} | |||
} | |||
}; | |||
void dance_raise_press(qk_tap_dance_state_t *state, void *user_data){// Called on each tap | |||
switch(state->count){ // Only turn the layer on once | |||
case 1: | |||
layer_off(_UNICODES); | |||
layer_on(_RAISE); | |||
update_tri_layer(_LOWER, _RAISE, _ADJUST); | |||
break; | |||
} | |||
}; | |||
void dance_raise_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on release | |||
switch(state->count){ | |||
case 1: // Normal action. Turn off layers | |||
layer_off(_RAISE); | |||
update_tri_layer(_LOWER, _RAISE, _ADJUST); | |||
layer_off(_UNICODES); | |||
break; | |||
} | |||
}; | |||
///////////////////////////////////////////////////////////////////// | |||
void dance_lower_press(qk_tap_dance_state_t *state, void *user_data){// Called on tap | |||
switch(state->count){ | |||
case 1: // Turn on lower | |||
layer_off(_UNICODES); | |||
layer_on(_LOWER); | |||
update_tri_layer(_LOWER, _RAISE, _ADJUST); | |||
break; | |||
} | |||
}; | |||
void dance_lower_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on release | |||
switch(state->count){ | |||
case 1: // Normal action. Turn off layers | |||
layer_off(_LOWER); | |||
update_tri_layer(_LOWER, _RAISE, _ADJUST); | |||
layer_off(_UNICODES); | |||
break; | |||
case 2: // Turn on _UNICODES layer | |||
layer_off(_LOWER); | |||
update_tri_layer(_LOWER, _RAISE, _ADJUST); | |||
layer_on(_UNICODES); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_ctrl_mod, false, 0); | |||
#endif | |||
break; | |||
} | |||
}; | |||
///////////////////////////////////////////////////////////////////// | |||
void dance_super_press(qk_tap_dance_state_t *state, void *user_data){ // Called on down | |||
if(state->count == 1){ | |||
register_code(KC_LGUI); | |||
} | |||
} | |||
void dance_super_done(qk_tap_dance_state_t *state, void *user_data){ // Called on timeout | |||
switch(state->count){ | |||
case 2: | |||
register_code(KC_LGUI); | |||
tap(KC_L); | |||
unregister_code(KC_LGUI); | |||
break; | |||
} | |||
} | |||
void dance_super_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on up | |||
unregister_code(KC_LGUI); | |||
} | |||
qk_tap_dance_action_t tap_dance_actions[] = { | |||
[RAI] = ACTION_TAP_DANCE_FN_ADVANCED(dance_raise_press, NULL, dance_raise_lift), | |||
[LOW] = ACTION_TAP_DANCE_FN_ADVANCED(dance_lower_press, NULL, dance_lower_lift), | |||
[SUP] = ACTION_TAP_DANCE_FN_ADVANCED(dance_super_press, dance_super_done, dance_super_lift) | |||
}; | |||
#endif | |||
#ifdef UNICODE_ENABLE | |||
// Unicode shortcuts | |||
#define IBANG UC(0x203D) | |||
#define RAROW UC(0x2192) | |||
#define LAROW UC(0x2190) | |||
#define DEGREE UC(0x00B0) | |||
#define OMEGA UC(0x03A9) | |||
#define WOMEGA UC(0x03C9) | |||
#define MICRO UC(0x00B5) | |||
#define PLUMIN UC(0x00B1) | |||
#define SUPA2 UC(0x00B2) | |||
#define ROMAN1 UC(0x2160) | |||
#define ROMAN2 UC(0x2161) | |||
#define ROMAN3 UC(0x2162) | |||
#define ROMAN4 UC(0x2163) | |||
#define ROMAN5 UC(0x2164) | |||
#define ROMAN6 UC(0x2165) | |||
#define ROMAN7 UC(0x2166) | |||
#define roman1 UC(0x2170) | |||
#define roman2 UC(0x2171) | |||
#define roman3 UC(0x2172) | |||
#define roman4 UC(0x2173) | |||
#define roman5 UC(0x2174) | |||
#define roman6 UC(0x2175) | |||
#define roman7 UC(0x2176) | |||
#ifdef UNICODEMAP_ENABLE // For Unicode characters larger than 0x8000. Send with X(<unicode>) | |||
enum Ext_Unicode{ | |||
PENGUIN = 0, | |||
BOAR, | |||
MONKEY, | |||
DRAGON, | |||
CHICK, | |||
TUMBLER | |||
}; | |||
const uint32_t PROGMEM unicode_map[] = { | |||
[PENGUIN] = 0x1F427, | |||
[BOAR] = 0x1F417, | |||
[MONKEY] = 0x1F412, | |||
[DRAGON] = 0x1F409, | |||
[CHICK] = 0x1F425, | |||
[TUMBLER] = 0x1F943 | |||
}; | |||
#define PENGY X(PENGUIN) | |||
#define BOARY X(BOAR) | |||
#define MNKY X(MONKEY) | |||
#define DRGN X(DRAGON) | |||
#define DUCK X(CHICK) | |||
#define TMBL X(TUMBLER) | |||
#endif | |||
#endif | |||
static uint16_t key_timer; | |||
static uint8_t caps_status = 0; | |||
bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
switch (keycode) { | |||
case COLEMAK: | |||
if(record->event.pressed){ | |||
persistant_default_layer_set(1UL<<_COLEMAK); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_colemak, false, 0); | |||
#endif | |||
} | |||
return false; | |||
break; | |||
case SWCOLE: | |||
if(record->event.pressed){ | |||
persistant_default_layer_set(1UL<<_SWCOLE); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_swcole, false, 0); | |||
#endif | |||
} | |||
return false; | |||
break; | |||
#ifndef TAP_DANCE_ENABLE | |||
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 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; | |||
#endif | |||
case SHFT_CAP: | |||
if(record->event.pressed){ | |||
key_timer = timer_read(); // if the key is being pressed, we start the timer. | |||
register_code(KC_LSHIFT); | |||
} else { // this means the key was just released (tap or "held down") | |||
if(timer_elapsed(key_timer) < 152){ // Time in ms, the threshold we pick for counting something as a tap. | |||
tap(KC_CAPS); | |||
if(caps_status == 0){ | |||
caps_status = 1; | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_capslock_on, false, 0); | |||
#endif | |||
} else { | |||
caps_status = 0; | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_capslock_off, false, 0); | |||
#endif | |||
} | |||
} | |||
unregister_code(KC_LSHIFT); | |||
} | |||
return false; | |||
break; | |||
case CTRLB: // Control-B on tap (bold) | |||
if(record->event.pressed){ | |||
key_timer = timer_read(); // if the key is being pressed, we start the timer. | |||
register_code(KC_LCTL); | |||
} else { // this means the key was just released (tap or "held down") | |||
if (timer_elapsed(key_timer) < 152) { // Time in ms, the threshold we pick for counting something as a tap. | |||
tap(KC_B); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_ctrl_mod, false, 0); | |||
#endif | |||
#ifdef BACKLIGHT_BREATHING | |||
breathing_speed_set(2); | |||
breathing_pulse(); | |||
#endif | |||
} | |||
unregister_code(KC_LCTL); | |||
} | |||
return false; | |||
break; | |||
case CPYPST: // One key copy/paste | |||
if(record->event.pressed){ | |||
key_timer = timer_read(); | |||
} else { | |||
if (timer_elapsed(key_timer) > 152) { // Hold, copy | |||
register_code(KC_LCTL); | |||
tap(KC_C); | |||
unregister_code(KC_LCTL); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_copy, false, 0); | |||
#endif | |||
} else { // Tap, paste | |||
register_code(KC_LCTL); | |||
tap(KC_V); | |||
unregister_code(KC_LCTL); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_paste, false, 0); | |||
#endif | |||
} | |||
} | |||
return false; | |||
break; | |||
#ifdef UNICODE_ENABLE | |||
case UNIWIN: | |||
if(record->event.pressed){ | |||
set_unicode_input_mode(UC_WIN); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(uniwin, false, 0); | |||
#endif | |||
} | |||
return false; | |||
break; | |||
case UNILIN: | |||
if(record->event.pressed){ | |||
set_unicode_input_mode(UC_LNX); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(unilin, false, 0); | |||
#endif | |||
} | |||
return false; | |||
break; | |||
case DISFACE: // ಠ_ಠ | |||
if(record->event.pressed){ | |||
process_unicode((0x0CA0|QK_UNICODE), record); // Eye | |||
register_code(KC_RSFT); | |||
tap(KC_MINS); | |||
unregister_code(KC_RSFT); | |||
process_unicode((0x0CA0|QK_UNICODE), record); // Eye | |||
} | |||
return false; | |||
break; | |||
case TFLIP: // (╯°□°)╯ ︵ ┻━┻ | |||
if(record->event.pressed){ | |||
register_code(KC_RSFT); | |||
tap(KC_9); | |||
unregister_code(KC_RSFT); | |||
process_unicode((0x256F|QK_UNICODE), record); // Arm | |||
process_unicode((0x00B0|QK_UNICODE), record); // Eye | |||
process_unicode((0x25A1|QK_UNICODE), record); // Mouth | |||
process_unicode((0x00B0|QK_UNICODE), record); // Eye | |||
register_code(KC_RSFT); | |||
tap(KC_0); | |||
unregister_code(KC_RSFT); | |||
process_unicode((0x256F|QK_UNICODE), record); // Arm | |||
tap(KC_SPC); | |||
process_unicode((0x0361|QK_UNICODE), record); // Flippy | |||
tap(KC_SPC); | |||
process_unicode((0x253B|QK_UNICODE), record); // Table | |||
process_unicode((0x2501|QK_UNICODE), record); // Table | |||
process_unicode((0x253B|QK_UNICODE), record); // Table | |||
} | |||
return false; | |||
break; | |||
case TPUT: // ┬──┬ ノ( ゜-゜ノ) | |||
if(record->event.pressed){ | |||
process_unicode((0x252C|QK_UNICODE), record); // Table | |||
process_unicode((0x2500|QK_UNICODE), record); // Table | |||
process_unicode((0x2500|QK_UNICODE), record); // Table | |||
process_unicode((0x252C|QK_UNICODE), record); // Table | |||
tap(KC_SPC); | |||
process_unicode((0x30CE|QK_UNICODE), record); // Arm | |||
register_code(KC_RSFT); | |||
tap(KC_9); | |||
unregister_code(KC_RSFT); | |||
tap(KC_SPC); | |||
process_unicode((0x309C|QK_UNICODE), record); // Eye | |||
tap(KC_MINS); | |||
process_unicode((0x309C|QK_UNICODE), record); // Eye | |||
process_unicode((0x30CE|QK_UNICODE), record); // Arm | |||
register_code(KC_RSFT); | |||
tap(KC_0); | |||
unregister_code(KC_RSFT); | |||
} | |||
return false; | |||
break; | |||
case SHRUG: // ¯\_(ツ)_/¯ | |||
if(record->event.pressed){ | |||
process_unicode((0x00AF|QK_UNICODE), record); // Hand | |||
tap(KC_BSLS); // Arm | |||
register_code(KC_RSFT); | |||
tap(KC_UNDS); // Arm | |||
tap(KC_LPRN); // Head | |||
unregister_code(KC_RSFT); | |||
process_unicode((0x30C4|QK_UNICODE), record); // Face | |||
register_code(KC_RSFT); | |||
tap(KC_RPRN); // Head | |||
tap(KC_UNDS); // Arm | |||
unregister_code(KC_RSFT); | |||
tap(KC_SLSH); // Arm | |||
process_unicode((0x00AF|QK_UNICODE), record); // Hand | |||
} | |||
return false; | |||
break; | |||
#endif | |||
case FACE: // (o_O) | |||
if(record->event.pressed){ | |||
register_code(KC_RSFT); | |||
tap(KC_LPRN); | |||
unregister_code(KC_RSFT); | |||
tap(KC_O); | |||
register_code(KC_RSFT); | |||
tap(KC_UNDS); | |||
tap(KC_O); | |||
tap(KC_RPRN); | |||
unregister_code(KC_RSFT); | |||
} | |||
return false; | |||
break; | |||
#ifdef TAP_DANCE_ENABLE | |||
case TappyR: | |||
if(record->event.pressed){ | |||
if(timer_elapsed32(Rtimer) > 1052){ | |||
Rstate = 0; | |||
} | |||
switch(Rstate){ | |||
case 0: | |||
Rtimer = timer_read32(); | |||
Rstate++; | |||
break; | |||
case 1: | |||
Rtimes[0] = timer_elapsed32(Rtimer); | |||
Rtimer = timer_read32(); | |||
Rstate++; | |||
break; | |||
case 2: | |||
Rtimes[1] = timer_elapsed32(Rtimer); | |||
Rtimer = timer_read32(); | |||
Rstate++; | |||
break; | |||
case 3: | |||
Rtimes[2] = timer_elapsed32(Rtimer); | |||
Rstate = 0; | |||
break; | |||
} | |||
if(Rstate == 0 && Lstate == 0) rhythm_parse(); | |||
} | |||
return false; | |||
break; | |||
case TappyL: | |||
if(record->event.pressed){ | |||
if(timer_elapsed32(Ltimer) > 1052){ | |||
Lstate = 0; | |||
} | |||
switch(Lstate){ | |||
case 0: | |||
Ltimer = timer_read32(); | |||
Lstate++; | |||
break; | |||
case 1: | |||
Ltimes[0] = timer_elapsed32(Ltimer); | |||
Ltimer = timer_read32(); | |||
Lstate++; | |||
break; | |||
case 2: | |||
Ltimes[1] = timer_elapsed32(Ltimer); | |||
Lstate = 0; | |||
break; | |||
} | |||
if(Rstate == 0 && Lstate == 0) rhythm_parse(); | |||
} | |||
return false; | |||
break; | |||
#endif | |||
#endif | |||
case RANDIG: | |||
if (record->event.pressed) { | |||
tap_random_base64(); | |||
} | |||
return false; | |||
break; | |||
} | |||
return true; | |||
}; | |||
#ifdef AUDIO_ENABLE | |||
void matrix_init_user(void){ // Run once at startup | |||
#ifdef AUDIO_ENABLE | |||
_delay_ms(50); // gets rid of tick | |||
PLAY_NOTE_ARRAY(tone_startup, false, 0); | |||
#endif | |||
} | |||
void play_goodbye_tone(void){ | |||
PLAY_NOTE_ARRAY(tone_goodbye, false, 0); | |||
_delay_ms(150); | |||
} | |||
void shutdown_user(){ | |||
PLAY_NOTE_ARRAY(tone_goodbye, false, 0); | |||
_delay_ms(150); | |||
stop_all_notes(); | |||
} | |||
void music_on_user(void){ // Run when the music layer is turned on | |||
PLAY_NOTE_ARRAY(tone_startup, false, 0); | |||
} | |||
void music_off_user(void){ // Run when music is turned off | |||
PLAY_NOTE_ARRAY(tone_goodbye, false, 0); | |||
} | |||
#endif | |||
#endif |
@ -0,0 +1,29 @@ | |||
# Zach Preonic Makefile | |||
# Max .hex size is about 28636 bytes | |||
# 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 | |||
# | |||
TAP_DANCE_ENABLE = yes # Enable TapDance functionality | |||
BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000) | |||
MOUSEKEY_ENABLE = no # Mouse keys(+4700) | |||
EXTRAKEY_ENABLE = no # Audio control and System control(+450) | |||
CONSOLE_ENABLE = no # Console for debug(+400) | |||
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 | |||
USB_6KRO_ENABLE = no # 6key Rollover | |||
BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality | |||
MIDI_ENABLE = no # MIDI controls | |||
AUDIO_ENABLE = yes # Audio output on port C6 | |||
VARIABLE_TRACE = no # Debug changes to variable values | |||
UNICODE_ENABLE = yes # Unicode | |||
UNICODEMAP_ENABLE = no # Enable extended 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 |
@ -0,0 +1,95 @@ | |||
/* | |||
Copyright 2012 Jun Wako <wakojun@gmail.com> | |||
This program is free software: you can redistribute it and/or modify | |||
it under the terms of the GNU General Public License as published by | |||
the Free Software Foundation, either version 2 of the License, or | |||
(at your option) any later version. | |||
This program is distributed in the hope that it will be useful, | |||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
GNU General Public License for more details. | |||
You should have received a copy of the GNU General Public License | |||
along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
*/ | |||
#ifndef CONFIG_H | |||
#define CONFIG_H | |||
#include "config_common.h" | |||
/* USB Device descriptor parameter */ | |||
#define VENDOR_ID 0xFEED | |||
#define PRODUCT_ID 0x6061 | |||
#define DEVICE_VER 0x0001 | |||
#define MANUFACTURER Ortholinear Keyboards | |||
#define PRODUCT The Preonic Keyboard | |||
#define DESCRIPTION A compact ortholinear keyboard | |||
/* key matrix size */ | |||
#define MATRIX_ROWS 5 | |||
#define MATRIX_COLS 12 | |||
/* Planck PCB default pin-out */ | |||
#define MATRIX_ROW_PINS { D2, D5, B5, B6, D3 } | |||
#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 } | |||
#define UNUSED_PINS | |||
#define BACKLIGHT_PIN B7 | |||
/* COL2ROW or ROW2COL */ | |||
#define DIODE_DIRECTION COL2ROW | |||
/* define if matrix has ghost */ | |||
//#define MATRIX_HAS_GHOST | |||
#define BACKLIGHT_BREATHING // LED breathing | |||
/* number of backlight levels */ | |||
#define BACKLIGHT_LEVELS 5 | |||
/* Set 0 if debouncing isn't needed */ | |||
#define DEBOUNCING_DELAY 5 | |||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */ | |||
//#define LOCKING_SUPPORT_ENABLE | |||
/* Locking resynchronize hack */ | |||
//#define LOCKING_RESYNC_ENABLE | |||
/* key combination for command */ | |||
#define IS_COMMAND() ( \ | |||
keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \ | |||
) | |||
/* ws2812 RGB LED */ | |||
//#define RGB_DI_PIN D1 | |||
//#define RGBLIGHT_TIMER | |||
//#define RGBLED_NUM 28 // Number of LEDs | |||
//#define RGBLIGHT_HUE_STEP 10 | |||
//#define RGBLIGHT_SAT_STEP 17 | |||
//#define RGBLIGHT_VAL_STEP 17 | |||
/* | |||
* Feature disable options | |||
* These options are also useful to firmware size reduction. | |||
*/ | |||
/* disable debug print */ | |||
//#define NO_DEBUG | |||
/* disable print */ | |||
//#define NO_PRINT | |||
/* disable action features */ | |||
//#define NO_ACTION_LAYER | |||
#define NO_ACTION_TAPPING | |||
#define NO_ACTION_ONESHOT | |||
#define NO_ACTION_MACRO | |||
#define NO_ACTION_FUNCTION | |||
#define PREVENT_STUCK_MODIFIERS | |||
//#define DYNAMIC_MACRO_ENABLE // Enable if you need to use the macro functionality | |||
//#define SPACE_CADET // Parenthesis on L/R shift | |||
#endif |
@ -0,0 +1,54 @@ | |||
// Zach Nielsen Custom Preonic Keyboard layout | |||
#include "preonic.h" | |||
#define PREONIC_YES // This is the Preonic | |||
#include "zach_common_functions.c" | |||
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |||
[_COLEMAK] = { /* Base Layer */ | |||
{KC_ESC, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC}, | |||
{KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_QUOT, KC_ENT}, | |||
{KC_BSPC, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_ENT}, | |||
{SHFT_CAP, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT}, | |||
{CTRLB, TD(SUP), KC_LALT, KC_LCTL, TD(LOW), KC_SPC, KC_SPC, TD(RAI), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT} | |||
}, | |||
[_SWCOLE] = { /* Software Colemak */ | |||
{_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______}, | |||
{_______, CM_Q, CM_W, CM_F, CM_P, CM_G, CM_J, CM_L, CM_U, CM_Y, KC_QUOT, _______}, | |||
{_______, CM_A, CM_R, CM_S, CM_T, CM_D, CM_H, CM_N, CM_E, CM_I, CM_O, _______}, | |||
{_______, CM_Z, CM_X, CM_C, CM_V, CM_B, CM_K, CM_M, CM_COMM, CM_DOT, CM_SLSH, _______}, | |||
{_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______} | |||
}, | |||
[_RAISE] = { /* RAISE - Numpad and Unicode symbols */ | |||
{KC_TILD, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______}, | |||
{KC_GRV, SUPA2, FACE, DISFACE, SHRUG, PLUMIN, IBANG, KC_7, KC_8, KC_9, KC_COLN, _______}, | |||
{KC_DEL, DEGREE, MICRO, WOMEGA, OMEGA, XXXXXXX, KC_ENT, KC_4, KC_5, KC_6, KC_SLSH, KC_ASTR}, | |||
{_______, KC_COLN, TFLIP, LAROW, RAROW, XXXXXXX, KC_SPC, KC_1, KC_2, KC_3, KC_MINS, KC_PLUS}, | |||
{_______, KC_PIPE, TPUT, _______, _______, KC_TAB, KC_TAB, _______, KC_0, KC_0, KC_DOT, KC_EQL} | |||
}, | |||
[_LOWER] = { /* LOWER - Symbols, Paging, CtrAltDel */ | |||
{KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_QUES, KC_DQT, KC_DEL}, | |||
{KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_QUES, KC_DQT, KC_DEL}, | |||
{KC_DEL, KC_LBRC, KC_RBRC, KC_MINS, KC_UNDS, KC_HOME, KC_END, KC_LPRN, KC_RPRN, KC_SLSH, KC_SCLN, KC_PGUP}, | |||
{CPYPST, XXXXXXX, C(KC_X), KC_LABK, KC_RABK, XXXXXXX, XXXXXXX, KC_LCBR, KC_RCBR, KC_BSLS, KC_COLN, KC_PGDN}, | |||
{_______, _______, _______, _______, _______, KC_TAB, KC_TAB, _______, _______, _______, _______, _______} | |||
}, | |||
[_ADJUST] = { /* ADJUST - Macros, Layer Switching, Function Keys */ | |||
{UNIWIN, XXXXXXX, XXXXXXX, RANDIG, RANDIG, KC_INS, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, AU_TOG, MU_TOG}, | |||
{UNILIN, SUPA2, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_F1, KC_F2, KC_F3, KC_F4, XXXXXXX}, | |||
{XXXXXXX, DEGREE, IBANG, LAROW, RAROW, SWCOLE, COLEMAK, KC_F5, KC_F6, KC_F7, KC_F8, BL_INC}, | |||
{_______, CADKEY, MICRO, WOMEGA, OMEGA, XXXXXXX, XXXXXXX, KC_F9, KC_F10, KC_F11, KC_F12, BL_DEC}, | |||
{_______, _______, _______, _______, _______, RESET, RESET, _______, XXXXXXX, MUV_DE, MUV_IN, BL_TOGG} | |||
}, | |||
[_UNICODES] = { /* UNICODES - Extra layer for unicode stuff */ | |||
{_______, XXXXXXX, XXXXXXX, FINGER, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______}, | |||
{_______, TFLIP, XXXXXXX, XXXXXXX, IBANG, roman7, XXXXXXX, XXXXXXX, ROMAN7, XXXXXXX, XXXXXXX, _______}, | |||
{KC_DEL, TPUT, FACE, DISFACE, SHRUG, roman4, roman5, roman6, ROMAN4, ROMAN5, ROMAN6, _______}, | |||
{XXXXXXX, PENIS, BOOBS, LAROW, RAROW, roman1, roman2, roman3, ROMAN1, ROMAN2, ROMAN3, XXXXXXX}, | |||
{_______, _______, _______, _______, _______, KC_SPC, KC_SPC, _______, _______, _______, _______, _______} | |||
} | |||
}; |
@ -0,0 +1,538 @@ | |||
#ifndef ZACH_COMMON_FUNCTIONS | |||
#define ZACH_COMMON_FUNCTIONS | |||
#include "eeconfig.h" | |||
#include "action_layer.h" | |||
#include "keymap_colemak.h" | |||
#include "extra_functions.c" | |||
extern keymap_config_t keymap_config; | |||
// Fillers to make layering more clear | |||
#define _______ KC_TRNS | |||
#define XXXXXXX KC_NO | |||
#define C(n) RCTL(n) | |||
#define CADKEY RCTL(RALT(KC_DEL)) | |||
void tap(uint16_t keycode){ | |||
register_code(keycode); | |||
unregister_code(keycode); | |||
}; | |||
void persistant_default_layer_set(uint16_t default_layer){ | |||
eeconfig_update_default_layer(default_layer); | |||
default_layer_set(default_layer); | |||
}; | |||
// Automatic number generation of important keywords | |||
enum my_keycodes{ | |||
// Layer numbers | |||
_COLEMAK = 0, | |||
_SWCOLE, | |||
_RAISE, | |||
_LOWER, | |||
_ADJUST, | |||
_UNICODES, | |||
// These use process_record_user() | |||
COLEMAK = SAFE_RANGE, | |||
SWCOLE, | |||
LOWER, | |||
RAISE, | |||
SHFT_CAP, | |||
CTRLB, | |||
CPYPST, | |||
FACE, | |||
UNIWIN, | |||
UNILIN, | |||
DISFACE, | |||
TFLIP, | |||
TPUT, | |||
SHRUG, | |||
PENIS, | |||
BOOBS, | |||
Sil_Pas, | |||
Sil_Usr, | |||
UltiU, | |||
UltiP, | |||
TappyR, | |||
TappyL, | |||
RANDIG, | |||
FINGER, | |||
// Tap_Dance nums | |||
RAI = 0, | |||
LOW, | |||
SUP | |||
}; | |||
#ifdef AUDIO_ENABLE | |||
#include "audio.h" | |||
float tone_startup[][2] = SONG(STARTUP_SOUND); | |||
float tone_goodbye[][2] = SONG(GOODBYE_SOUND); | |||
float tone_colemak[][2] = SONG(COLEMAK_SOUND); | |||
float tone_swcole[][2] = SONG(QWERTY_SOUND); | |||
float tone_capslock_on[][2] = SONG(CAPS_LOCK_ON_SOUND); | |||
float tone_capslock_off[][2] = SONG(CAPS_LOCK_OFF_SOUND); | |||
float tone_ctrl_mod[][2] = SONG(COIN_SOUND); | |||
float tone_copy[][2] = SONG(SCROLL_LOCK_ON_SOUND); | |||
float tone_paste[][2] = SONG(SCROLL_LOCK_OFF_SOUND); | |||
float uniwin[][2] = SONG(UNICODE_WINDOWS); | |||
float unilin[][2] = SONG(UNICODE_LINUX); | |||
#endif | |||
#ifdef TAP_DANCE_ENABLE | |||
#define TAPPING_TERM 200 | |||
uint8_t Lstate = 0, Rstate = 0; | |||
uint32_t Ltimer = 0, Rtimer = 0; | |||
uint32_t Ltimes[3], Rtimes[4]; // Ratio of tap times should be about 1.335 (L/R) | |||
void rhythm_parse(void){ | |||
int L = Ltimes[0] + Ltimes[1] + Ltimes[2]; // Start to end time | |||
int R = Rtimes[0] + Rtimes[1] + Rtimes[2] + Rtimes[3]; | |||
if(abs(R-L) > 10){ | |||
tap(KC_N); tap(KC_O); | |||
return; | |||
} else { | |||
L = (L / 3)*100; // Average time per tap * 100 | |||
R = (R / 4); | |||
if(abs(abs(L/R)-133) > 1){ | |||
tap(KC_N); tap(KC_O); | |||
tap(KC_P); tap(KC_E); | |||
return; | |||
} else { | |||
tap(KC_O); tap(KC_K); | |||
return; | |||
} | |||
} | |||
}; | |||
void dance_raise_press(qk_tap_dance_state_t *state, void *user_data){// Called on each tap | |||
switch(state->count){ // Only turn the layer on once | |||
case 1: | |||
layer_off(_UNICODES); | |||
layer_on(_RAISE); | |||
update_tri_layer(_LOWER, _RAISE, _ADJUST); | |||
break; | |||
} | |||
}; | |||
void dance_raise_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on release | |||
switch(state->count){ | |||
case 1: // Normal action. Turn off layers | |||
layer_off(_RAISE); | |||
update_tri_layer(_LOWER, _RAISE, _ADJUST); | |||
layer_off(_UNICODES); | |||
break; | |||
} | |||
}; | |||
///////////////////////////////////////////////////////////////////// | |||
void dance_lower_press(qk_tap_dance_state_t *state, void *user_data){// Called on tap | |||
switch(state->count){ | |||
case 1: // Turn on lower | |||
layer_off(_UNICODES); | |||
layer_on(_LOWER); | |||
update_tri_layer(_LOWER, _RAISE, _ADJUST); | |||
break; | |||
} | |||
}; | |||
void dance_lower_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on release | |||
switch(state->count){ | |||
case 1: // Normal action. Turn off layers | |||
layer_off(_LOWER); | |||
update_tri_layer(_LOWER, _RAISE, _ADJUST); | |||
layer_off(_UNICODES); | |||
break; | |||
case 2: // Turn on _UNICODES layer | |||
layer_off(_LOWER); | |||
update_tri_layer(_LOWER, _RAISE, _ADJUST); | |||
layer_on(_UNICODES); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_ctrl_mod, false, 0); | |||
#endif | |||
break; | |||
} | |||
}; | |||
///////////////////////////////////////////////////////////////////// | |||
void dance_super_press(qk_tap_dance_state_t *state, void *user_data){ // Called on down | |||
if(state->count == 1){ | |||
register_code(KC_LGUI); | |||
} | |||
} | |||
void dance_super_done(qk_tap_dance_state_t *state, void *user_data){ // Called on timeout | |||
switch(state->count){ | |||
case 2: | |||
register_code(KC_LGUI); | |||
tap(KC_L); | |||
unregister_code(KC_LGUI); | |||
break; | |||
} | |||
} | |||
void dance_super_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on up | |||
unregister_code(KC_LGUI); | |||
} | |||
qk_tap_dance_action_t tap_dance_actions[] = { | |||
[RAI] = ACTION_TAP_DANCE_FN_ADVANCED(dance_raise_press, NULL, dance_raise_lift), | |||
[LOW] = ACTION_TAP_DANCE_FN_ADVANCED(dance_lower_press, NULL, dance_lower_lift), | |||
[SUP] = ACTION_TAP_DANCE_FN_ADVANCED(dance_super_press, dance_super_done, dance_super_lift) | |||
}; | |||
#endif | |||
#ifdef UNICODE_ENABLE | |||
// Unicode shortcuts | |||
#define IBANG UC(0x203D) | |||
#define RAROW UC(0x2192) | |||
#define LAROW UC(0x2190) | |||
#define DEGREE UC(0x00B0) | |||
#define OMEGA UC(0x03A9) | |||
#define WOMEGA UC(0x03C9) | |||
#define MICRO UC(0x00B5) | |||
#define PLUMIN UC(0x00B1) | |||
#define SUPA2 UC(0x00B2) | |||
#define ROMAN1 UC(0x2160) | |||
#define ROMAN2 UC(0x2161) | |||
#define ROMAN3 UC(0x2162) | |||
#define ROMAN4 UC(0x2163) | |||
#define ROMAN5 UC(0x2164) | |||
#define ROMAN6 UC(0x2165) | |||
#define ROMAN7 UC(0x2166) | |||
#define roman1 UC(0x2170) | |||
#define roman2 UC(0x2171) | |||
#define roman3 UC(0x2172) | |||
#define roman4 UC(0x2173) | |||
#define roman5 UC(0x2174) | |||
#define roman6 UC(0x2175) | |||
#define roman7 UC(0x2176) | |||
#ifdef UNICODEMAP_ENABLE // For Unicode characters larger than 0x8000. Send with X(<unicode>) | |||
enum Ext_Unicode{ | |||
PENGUIN = 0, | |||
BOAR, | |||
MONKEY, | |||
DRAGON, | |||
CHICK, | |||
TUMBLER | |||
}; | |||
const uint32_t PROGMEM unicode_map[] = { | |||
[PENGUIN] = 0x1F427, | |||
[BOAR] = 0x1F417, | |||
[MONKEY] = 0x1F412, | |||
[DRAGON] = 0x1F409, | |||
[CHICK] = 0x1F425, | |||
[TUMBLER] = 0x1F943 | |||
}; | |||
#define PENGY X(PENGUIN) | |||
#define BOARY X(BOAR) | |||
#define MNKY X(MONKEY) | |||
#define DRGN X(DRAGON) | |||
#define DUCK X(CHICK) | |||
#define TMBL X(TUMBLER) | |||
#endif | |||
#endif | |||
static uint16_t key_timer; | |||
static uint8_t caps_status = 0; | |||
bool process_record_user(uint16_t keycode, keyrecord_t *record) { | |||
switch (keycode) { | |||
case COLEMAK: | |||
if(record->event.pressed){ | |||
persistant_default_layer_set(1UL<<_COLEMAK); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_colemak, false, 0); | |||
#endif | |||
} | |||
return false; | |||
break; | |||
case SWCOLE: | |||
if(record->event.pressed){ | |||
persistant_default_layer_set(1UL<<_SWCOLE); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_swcole, false, 0); | |||
#endif | |||
} | |||
return false; | |||
break; | |||
#ifndef TAP_DANCE_ENABLE | |||
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 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; | |||
#endif | |||
case SHFT_CAP: | |||
if(record->event.pressed){ | |||
key_timer = timer_read(); // if the key is being pressed, we start the timer. | |||
register_code(KC_LSHIFT); | |||
} else { // this means the key was just released (tap or "held down") | |||
if(timer_elapsed(key_timer) < 152){ // Time in ms, the threshold we pick for counting something as a tap. | |||
tap(KC_CAPS); | |||
if(caps_status == 0){ | |||
caps_status = 1; | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_capslock_on, false, 0); | |||
#endif | |||
} else { | |||
caps_status = 0; | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_capslock_off, false, 0); | |||
#endif | |||
} | |||
} | |||
unregister_code(KC_LSHIFT); | |||
} | |||
return false; | |||
break; | |||
case CTRLB: // Control-B on tap (bold) | |||
if(record->event.pressed){ | |||
key_timer = timer_read(); // if the key is being pressed, we start the timer. | |||
register_code(KC_LCTL); | |||
} else { // this means the key was just released (tap or "held down") | |||
if (timer_elapsed(key_timer) < 152) { // Time in ms, the threshold we pick for counting something as a tap. | |||
tap(KC_B); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_ctrl_mod, false, 0); | |||
#endif | |||
#ifdef BACKLIGHT_BREATHING | |||
breathing_speed_set(2); | |||
breathing_pulse(); | |||
#endif | |||
} | |||
unregister_code(KC_LCTL); | |||
} | |||
return false; | |||
break; | |||
case CPYPST: // One key copy/paste | |||
if(record->event.pressed){ | |||
key_timer = timer_read(); | |||
} else { | |||
if (timer_elapsed(key_timer) > 152) { // Hold, copy | |||
register_code(KC_LCTL); | |||
tap(KC_C); | |||
unregister_code(KC_LCTL); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_copy, false, 0); | |||
#endif | |||
} else { // Tap, paste | |||
register_code(KC_LCTL); | |||
tap(KC_V); | |||
unregister_code(KC_LCTL); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(tone_paste, false, 0); | |||
#endif | |||
} | |||
} | |||
return false; | |||
break; | |||
#ifdef UNICODE_ENABLE | |||
case UNIWIN: | |||
if(record->event.pressed){ | |||
set_unicode_input_mode(UC_WIN); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(uniwin, false, 0); | |||
#endif | |||
} | |||
return false; | |||
break; | |||
case UNILIN: | |||
if(record->event.pressed){ | |||
set_unicode_input_mode(UC_LNX); | |||
#ifdef AUDIO_ENABLE | |||
PLAY_NOTE_ARRAY(unilin, false, 0); | |||
#endif | |||
} | |||
return false; | |||
break; | |||
case DISFACE: // ಠ_ಠ | |||
if(record->event.pressed){ | |||
process_unicode((0x0CA0|QK_UNICODE), record); // Eye | |||
register_code(KC_RSFT); | |||
tap(KC_MINS); | |||
unregister_code(KC_RSFT); | |||
process_unicode((0x0CA0|QK_UNICODE), record); // Eye | |||
} | |||
return false; | |||
break; | |||
case TFLIP: // (╯°□°)╯ ︵ ┻━┻ | |||
if(record->event.pressed){ | |||
register_code(KC_RSFT); | |||
tap(KC_9); | |||
unregister_code(KC_RSFT); | |||
process_unicode((0x256F|QK_UNICODE), record); // Arm | |||
process_unicode((0x00B0|QK_UNICODE), record); // Eye | |||
process_unicode((0x25A1|QK_UNICODE), record); // Mouth | |||
process_unicode((0x00B0|QK_UNICODE), record); // Eye | |||
register_code(KC_RSFT); | |||
tap(KC_0); | |||
unregister_code(KC_RSFT); | |||
process_unicode((0x256F|QK_UNICODE), record); // Arm | |||
tap(KC_SPC); | |||
process_unicode((0x0361|QK_UNICODE), record); // Flippy | |||
tap(KC_SPC); | |||
process_unicode((0x253B|QK_UNICODE), record); // Table | |||
process_unicode((0x2501|QK_UNICODE), record); // Table | |||
process_unicode((0x253B|QK_UNICODE), record); // Table | |||
} | |||
return false; | |||
break; | |||
case TPUT: // ┬──┬ ノ( ゜-゜ノ) | |||
if(record->event.pressed){ | |||
process_unicode((0x252C|QK_UNICODE), record); // Table | |||
process_unicode((0x2500|QK_UNICODE), record); // Table | |||
process_unicode((0x2500|QK_UNICODE), record); // Table | |||
process_unicode((0x252C|QK_UNICODE), record); // Table | |||
tap(KC_SPC); | |||
process_unicode((0x30CE|QK_UNICODE), record); // Arm | |||
register_code(KC_RSFT); | |||
tap(KC_9); | |||
unregister_code(KC_RSFT); | |||
tap(KC_SPC); | |||
process_unicode((0x309C|QK_UNICODE), record); // Eye | |||
tap(KC_MINS); | |||
process_unicode((0x309C|QK_UNICODE), record); // Eye | |||
process_unicode((0x30CE|QK_UNICODE), record); // Arm | |||
register_code(KC_RSFT); | |||
tap(KC_0); | |||
unregister_code(KC_RSFT); | |||
} | |||
return false; | |||
break; | |||
case SHRUG: // ¯\_(ツ)_/¯ | |||
if(record->event.pressed){ | |||
process_unicode((0x00AF|QK_UNICODE), record); // Hand | |||
tap(KC_BSLS); // Arm | |||
register_code(KC_RSFT); | |||
tap(KC_UNDS); // Arm | |||
tap(KC_LPRN); // Head | |||
unregister_code(KC_RSFT); | |||
process_unicode((0x30C4|QK_UNICODE), record); // Face | |||
register_code(KC_RSFT); | |||
tap(KC_RPRN); // Head | |||
tap(KC_UNDS); // Arm | |||
unregister_code(KC_RSFT); | |||
tap(KC_SLSH); // Arm | |||
process_unicode((0x00AF|QK_UNICODE), record); // Hand | |||
} | |||
return false; | |||
break; | |||
#endif | |||
case FACE: // (o_O) | |||
if(record->event.pressed){ | |||
register_code(KC_RSFT); | |||
tap(KC_LPRN); | |||
unregister_code(KC_RSFT); | |||
tap(KC_O); | |||
register_code(KC_RSFT); | |||
tap(KC_UNDS); | |||
tap(KC_O); | |||
tap(KC_RPRN); | |||
unregister_code(KC_RSFT); | |||
} | |||
return false; | |||
break; | |||
#ifdef TAP_DANCE_ENABLE | |||
case TappyR: | |||
if(record->event.pressed){ | |||
if(timer_elapsed32(Rtimer) > 1052){ | |||
Rstate = 0; | |||
} | |||
switch(Rstate){ | |||
case 0: | |||
Rtimer = timer_read32(); | |||
Rstate++; | |||
break; | |||
case 1: | |||
Rtimes[0] = timer_elapsed32(Rtimer); | |||
Rtimer = timer_read32(); | |||
Rstate++; | |||
break; | |||
case 2: | |||
Rtimes[1] = timer_elapsed32(Rtimer); | |||
Rtimer = timer_read32(); | |||
Rstate++; | |||
break; | |||
case 3: | |||
Rtimes[2] = timer_elapsed32(Rtimer); | |||
Rstate = 0; | |||
break; | |||
} | |||
if(Rstate == 0 && Lstate == 0) rhythm_parse(); | |||
} | |||
return false; | |||
break; | |||
case TappyL: | |||
if(record->event.pressed){ | |||
if(timer_elapsed32(Ltimer) > 1052){ | |||
Lstate = 0; | |||
} | |||
switch(Lstate){ | |||
case 0: | |||
Ltimer = timer_read32(); | |||
Lstate++; | |||
break; | |||
case 1: | |||
Ltimes[0] = timer_elapsed32(Ltimer); | |||
Ltimer = timer_read32(); | |||
Lstate++; | |||
break; | |||
case 2: | |||
Ltimes[1] = timer_elapsed32(Ltimer); | |||
Lstate = 0; | |||
break; | |||
} | |||
if(Rstate == 0 && Lstate == 0) rhythm_parse(); | |||
} | |||
return false; | |||
break; | |||
#endif | |||
#endif | |||
case RANDIG: | |||
if (record->event.pressed) { | |||
tap_random_base64(); | |||
} | |||
return false; | |||
break; | |||
} | |||
return true; | |||
}; | |||
#ifdef AUDIO_ENABLE | |||
void matrix_init_user(void){ // Run once at startup | |||
#ifdef AUDIO_ENABLE | |||
_delay_ms(50); // gets rid of tick | |||
PLAY_NOTE_ARRAY(tone_startup, false, 0); | |||
#endif | |||
} | |||
void play_goodbye_tone(void){ | |||
PLAY_NOTE_ARRAY(tone_goodbye, false, 0); | |||
_delay_ms(150); | |||
} | |||
void shutdown_user(){ | |||
PLAY_NOTE_ARRAY(tone_goodbye, false, 0); | |||
_delay_ms(150); | |||
stop_all_notes(); | |||
} | |||
void music_on_user(void){ // Run when the music layer is turned on | |||
PLAY_NOTE_ARRAY(tone_startup, false, 0); | |||
} | |||
void music_off_user(void){ // Run when music is turned off | |||
PLAY_NOTE_ARRAY(tone_goodbye, false, 0); | |||
} | |||
#endif | |||
#endif |