jordan
/
qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

new planck keymap, new feature - hybrid shift/enter action key (great for small keyboards!) (#2100)

Browse Source 
* new planck keymap, new feature - hybrid shift/enter action key (great for small keyboards!)

* corrected documentation to specify rules.mk file instead of Makefile
pjrc_hid 0.5.192
Zach Richard 7 years ago committed by Jack Humbert
parent 56f266173c
commit 8a1e656099
6 changed files with 785 additions and 0 deletions
Show Stats Download Patch File Download Diff File

26
docs/feature_space_shift_cadet.md
Unescape Escape View File

@ -0,0 +1,26 @@
## Space Cadet Shift Enter: The future, built in
Based on the Space Cadet Shift by Steve Losh [described](http://stevelosh.com/blog/2012/10/a-modern-space-cadet/)
Essentially, you hit the Shift on its own, and it acts as the enter key. When hit with other keys, the Shift key keeps working as it always does. Yes, it's as cool as it sounds. This solution works better than using a macro since the timers defined in quantum allow us to tell when another key is pressed, rather than just having a janky timer than results in accidental endlines.
To use it, use `KC_SFTENT` (Shift, Enter) for any Shift on your keymap.
It's defaulted to work on US keyboards, but if you'd like to use a different key for Enter, you can define those in your `config.h` like this:
#define SFTENT_KEY KC_ENT
The only other thing you're going to want to do is create a `rules.mk` in your keymap directory and set the following:
```
COMMAND_ENABLE = no # Commands for debug and configuration
```
This is just to keep the keyboard from going into command mode when you hold both Shift keys at the same time.
PLEASE NOTE: this feature uses the same timers as the Space Cadet Shift feature, so using them in tandem may produce unwanted results.

76
keyboards/planck/keymaps/zrichard/config.h
Unescape Escape View File

@ -0,0 +1,76 @@
/*
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_USER_H
#define CONFIG_USER_H
#include "config_common.h"
/* 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
/* Prevent use of disabled MIDI features in the keymap */
//#define MIDI_ENABLE_STRICT 1
/* enable basic MIDI features:
- MIDI notes can be sent when in Music mode is on
*/
#define MIDI_BASIC
/* enable advanced MIDI features:
- MIDI notes can be added to the keymap
- Octave shift and transpose
- Virtual sustain, portamento, and modulation wheel
- etc.
*/
//#define MIDI_ADVANCED
/*
* Feature disable options
* These options are also useful to firmware size reduction.
*/
/* disable debug print */
#ifndef NO_DEBUG
# define NO_DEBUG
#endif
/* disable print */
// #ifndef NO_PRINT
// # define NO_PRINT
// #endif
/* Only print user print statements */
#define USER_PRINT
#define BACKLIGHT_BREATHING
/* disable action features */
//#define NO_ACTION_LAYER
//#define NO_ACTION_TAPPING
//#define NO_ACTION_ONESHOT
//#define NO_ACTION_MACRO
//#define NO_ACTION_FUNCTION
#endif

627
keyboards/planck/keymaps/zrichard/keymap.c
Unescape Escape View File

@ -0,0 +1,627 @@
#include "planck.h"
#include "action_layer.h"
#include "eeconfig.h"
#include "led.h"
#include "mousekey.h"
#ifdef AUDIO_ENABLE
#include "audio.h"
#include "song_list.h"
#endif
enum keyboard_layers {
LAYER_QWERTY = 0,
LAYER_UPPER,
LAYER_LOWER,
LAYER_FUNCTION,
LAYER_MOUSE,
LAYER_ADJUST,
};
enum keyboard_macros {
MACRO_QWERTY = 0,
MACRO_UPPER,
MACRO_LOWER,
MACRO_FUNCTION,
MACRO_MOUSE,
MACRO_TIMBRE_1,
MACRO_TIMBRE_2,
MACRO_TIMBRE_3,
MACRO_TIMBRE_4,
MACRO_TEMPO_U,
MACRO_TEMPO_D,
MACRO_TONE_DEFAULT,
MACRO_MUSIC_TOGGLE,
MACRO_AUDIO_TOGGLE,
MACRO_INC_VOICE,
MACRO_DEC_VOICE,
MACRO_BACKLIGHT,
MACRO_BREATH_TOGGLE,
MACRO_BREATH_SPEED_INC,
MACRO_BREATH_SPEED_DEC,
MACRO_BREATH_DEFAULT,
MACRO_MOUSE_MOVE_UL,
MACRO_MOUSE_MOVE_UR,
MACRO_MOUSE_MOVE_DL,
MACRO_MOUSE_MOVE_DR,
MACRO_HELP_1,
MACRO_HELP_2,
MACRO_HELP_3,
MACRO_HELP_4,
MACRO_HELP_5,
MACRO_HELP_6,
MACRO_HELP_7,
MACRO_HELP_8,
MACRO_HELP_9,
MACRO_MINE,
//MACRO_SHENT,
};
enum {
TD_SPENT = 0
};
#define M_QWRTY M(MACRO_QWERTY)
#define M_UPPER M(MACRO_UPPER)
#define M_LOWER M(MACRO_LOWER)
#define M_FUNCT M(MACRO_FUNCTION)
#define M_MOUSE M(MACRO_MOUSE)
#define TIMBR_1 M(MACRO_TIMBRE_1)
#define TIMBR_2 M(MACRO_TIMBRE_2)
#define TIMBR_3 M(MACRO_TIMBRE_3)
#define TIMBR_4 M(MACRO_TIMBRE_4)
#define TMPO_UP M(MACRO_TEMPO_U)
#define TMPO_DN M(MACRO_TEMPO_D)
#define TMPO_DF M(MACRO_TONE_DEFAULT)
#define M_BACKL M(MACRO_BACKLIGHT)
#define M_BRTOG M(MACRO_BREATH_TOGGLE)
#define M_BSPDU M(MACRO_BREATH_SPEED_INC)
#define M_BSPDD M(MACRO_BREATH_SPEED_DEC)
#define M_BDFLT M(MACRO_BREATH_DEFAULT)
#define M_MS_UL M(MACRO_MOUSE_MOVE_UL)
#define M_MS_UR M(MACRO_MOUSE_MOVE_UR)
#define M_MS_DL M(MACRO_MOUSE_MOVE_DL)
#define M_MS_DR M(MACRO_MOUSE_MOVE_DR)
#define M_HELP1 M(MACRO_HELP_1)
#define M_HELP2 M(MACRO_HELP_2)
#define M_HELP3 M(MACRO_HELP_3)
#define M_HELP4 M(MACRO_HELP_4)
#define M_HELP5 M(MACRO_HELP_5)
#define M_HELP6 M(MACRO_HELP_6)
#define M_HELP7 M(MACRO_HELP_7)
#define M_HELP8 M(MACRO_HELP_8)
#define M_HELP9 M(MACRO_HELP_9)
#define MY_MACRO M(MACRO_MINE)
//#define M_SHENT M(MACRO_SHENT)
#define VC_UP M(MACRO_INC_VOICE)
#define VC_DOWN M(MACRO_DEC_VOICE)
#define SC_UNDO LCTL(KC_Z)
#define SC_REDO LCTL(KC_Y)
#define SC_CUT LCTL(KC_X)
#define SC_COPY LCTL(KC_C)
#define SC_PSTE LCTL(KC_V)
#define SC_SELA LCTL(KC_A)
#define SC_SAVE LCTL(KC_S)
#define SC_OPEN LCTL(KC_O)
#define SC_ACLS LALT(KC_F4)
#define SC_CCLS LCTL(KC_F4)
#define TG_NKRO MAGIC_TOGGLE_NKRO
#define OS_SHFT KC_FN0
#define _______ KC_TRNS
#define XXXXXXX KC_NO
#define ________________ _______, _______
#define XXXXXXXXXXXXXXXX XXXXXXX, XXXXXXX
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* LAYER = LAYER_QWERTY
.-----------------------------------------------------------------------------------------------------------.
| ESC | Q | W | E | R | T | Y | U | I | O | P | BACKSP |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| TAB | A | S | D | F | G | H | J | K | L | ; | ' |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| LSHIFT | Z | X | C | V | B | N | M | , | . | UP | SH/ENT |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| LCTRL | LWIN | FN | LALT | LOWER | SPACE | SPACE | UPPER | MENU | LEFT | DOWN | RIGHT |
'-----------------------------------------------------------------------------------------------------------'
*/
[LAYER_QWERTY] = {
{ KC_ESC , KC_Q , KC_W , KC_E , KC_R , KC_T , KC_Y , KC_U , KC_I , KC_O , KC_P , KC_BSPC },
{ KC_TAB , 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_UP , KC_SFTENT /*M_SHENT*/ },
{ KC_LCTL, KC_LGUI, M_FUNCT, KC_LALT, M_LOWER, KC_SPC , KC_SPC , M_UPPER, KC_APP , KC_LEFT, KC_DOWN, KC_RGHT }
},
/* LAYER = LAYER_UPPER
.-----------------------------------------------------------------------------------------------------------.
| PRINT | F1 | F2 | F3 | F4 | NUM LK | KP / | KP 7 | KP 8 | KP 9 | KP - | DEL |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| PAUSE | F5 | F6 | F7 | F8 | SCR LK | KP * | KP 4 | KP 5 | KP 6 | KP + | HOME |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| ______ | F9 | F10 | F11 | F12 | PAUSE | KP 0 | KP 1 | KP 2 | KP 3 | KP ENT | END |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| ______ | ______ | ______ | ______ | LOWER | KP 0 | KP 0 | ______ | RALT | KP 0 | KP ENT | RTCTRL |
'-----------------------------------------------------------------------------------------------------------'
*/
[LAYER_UPPER] = {
{ KC_PSCR, KC_F1 , KC_F2 , KC_F3 , KC_F4 , KC_NLCK, KC_PSLS, KC_KP_7, KC_KP_8, KC_KP_9, KC_PMNS, KC_DEL },
{ KC_PAUS, KC_F5 , KC_F6 , KC_F7 , KC_F8 , KC_SLCK, KC_PAST, KC_KP_4, KC_KP_5, KC_KP_6, KC_PPLS, KC_HOME },
{ _______, KC_F9 , KC_F10 , KC_F11 , KC_F12 , KC_PAUS, KC_KP_0, KC_KP_1, KC_KP_2, KC_KP_3, KC_PENT, KC_END },
{ _______, _______, _______, _______, M_LOWER, KC_KP_0, KC_KP_0, _______, KC_KP_0, KC_PDOT, KC_PENT, KC_RCTL }
},
/* LAYER = LAYER_LOWER
.-----------------------------------------------------------------------------------------------------------.
| ______ | $ | { | [ | ( | % | # | ) | ] | } | @ | PG UP |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| ______ | ^ | * | + | - | / | \ | _ | ' | " | ` | PG DN |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| ______ | | | & | ! | ~ | ; | : | = | < | > | ? | HOME |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| ______ | ______ | ______ | ______ | ______ | ______ | ______ | UPPER | ______ | ______ | ______ | END |
'-----------------------------------------------------------------------------------------------------------'
*/
[LAYER_LOWER] = {
{ _______, KC_DLR , KC_LCBR, KC_LBRC, KC_LPRN, KC_PERC, KC_HASH, KC_RPRN, KC_RBRC, KC_RCBR, KC_AT , KC_PGUP },
{ _______, KC_CIRC, KC_ASTR, KC_PLUS, KC_MINS, KC_SLSH, KC_BSLS, KC_UNDS, KC_QUOT, KC_DQT , KC_GRV , KC_PGDN },
{ _______, KC_PIPE, KC_AMPR, KC_EXLM, KC_TILD, KC_SCLN, KC_COLN, KC_EQL , KC_LT , KC_GT , KC_QUES, KC_HOME },
{ _______, _______, _______, _______, _______, _______, _______, M_UPPER, _______, _______, _______, KC_END }
},
/* LAYER = LAYER_FUNCTION
.-----------------------------------------------------------------------------------------------------------.
| XXXXXX | F13 | F14 | F15 | F16 | NUM LK | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| XXXXXX | F17 | F18 | F19 | F20 | SCR LK | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| ______ | F21 | F22 | F23 | F24 | CAP LK | XXXXXX | XXXXXX | XXXXXX | XXXXXX | VOL UP | MUTE |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| ______ | ______ | FN | ______ | ______ | PLAY | PLAY | ______ | ______ | PREV | VOL DN | NEXT |
'-----------------------------------------------------------------------------------------------------------'
*/
[LAYER_FUNCTION] = {
{ XXXXXXX, KC_F13 , KC_F14 , KC_F15 , KC_F16 , KC_NLCK, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX },
{ XXXXXXX, KC_F17 , KC_F18 , KC_F19 , KC_F20 , KC_SLCK, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX },
{ _______, KC_F21 , KC_F22 , KC_F23 , KC_F24 , KC_CAPS, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_VOLU, KC_MUTE },
{ _______, _______, M_FUNCT, _______, _______, KC_MPLY, KC_MPLY, _______, _______, KC_MPRV, KC_VOLD, KC_MNXT }
},
/* LAYER = LAYER_MOUSE
.-----------------------------------------------------------------------------------------------------------.
| ESC | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | MS UL | MS U | MS UR | MS WHL | MS WHR |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| XXXXXX | MS BT5 | MS BT4 | MS BT3 | MS BT2 | XXXXXX | XXXXXX | MS L | XXXXXX | MS R | XXXXXX | MS WHU |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| ______ | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | MS DL | MS D | MS DR | MS U | MS WHD |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| ______ | ______ | ______ | ______ | ______ | MS BT1 | MS BT1 | ______ | ______ | MS L | MS D | MS R |
'-----------------------------------------------------------------------------------------------------------'
*/
[LAYER_MOUSE] = {
{ KC_ESC , XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, M_MS_UL, KC_MS_U, M_MS_UR, KC_WH_L, KC_WH_R },
{ XXXXXXX, KC_BTN5, KC_BTN4, KC_BTN3, KC_BTN2, XXXXXXX, XXXXXXX, KC_MS_L, XXXXXXX, KC_MS_R, XXXXXXX, KC_WH_U },
{ _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, M_MS_DL, KC_MS_D, M_MS_DR, KC_MS_U, KC_WH_D },
{ _______, _______, _______, _______, _______, KC_BTN1, KC_BTN1, _______, _______, KC_MS_L, KC_MS_D, KC_MS_R }
},
/* LAYER = LAYER_ADJUST
.-----------------------------------------------------------------------------------------------------------.
| XXXXXX | HELP 1 | HELP 2 | HELP 3 | HELP 4 | HELP 5 | HELP 6 | HELP 7 | HELP 8 | HELP 9 | MUSIC | AUDIO |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| XXXXXX | BRTOG | BRSPD+ | BRSPD- | BRDFLT | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX | XXXXXX |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| XXXXXX | QWERTY | XXXXXX | XXXXXX | BACKLT | RESET | XXXXXX | MOUSE | XXXXXX | XXXXXX | VOICE+ | MACRO |
|--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
| XXXXXX | XXXXXX | XXXXXX | XXXXXX | LOWER | XXXXXX | XXXXXX | UPPER | XXXXXX | TEMPO- | VOICE- | TEMPO+ |
'-----------------------------------------------------------------------------------------------------------'
*/
[LAYER_ADJUST] = {
{ XXXXXXX, M_HELP1, M_HELP2, M_HELP3, M_HELP4, M_HELP5, M_HELP6, M_HELP7, M_HELP8, M_HELP9, MU_TOG , AU_TOG },
{ XXXXXXX, M_BRTOG, M_BSPDU, M_BSPDD, M_BDFLT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX },
{ XXXXXXX, M_QWRTY, XXXXXXX, XXXXXXX, M_BACKL, RESET , XXXXXXX, M_MOUSE, XXXXXXX, XXXXXXX, MUV_IN , MY_MACRO},
{ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, M_LOWER, XXXXXXX, XXXXXXX, M_UPPER, XXXXXXX, TMPO_DN, MUV_DE , TMPO_UP }
},
};
#ifdef AUDIO_ENABLE
float tone_my_startup[][2] = SONG(QWERTY_SOUND);
float tone_my_goodbye[][2] = SONG(QWERTY_SOUND);
float tone_audio_on[][2] = SONG(CLOSE_ENCOUNTERS_5_NOTE);
float tone_music_on[][2] = SONG(DOE_A_DEER);
float tone_caps_on[][2] = SONG(CAPS_LOCK_ON_SOUND);
float tone_caps_off[][2] = SONG(CAPS_LOCK_OFF_SOUND);
float tone_numlk_on[][2] = SONG(NUM_LOCK_ON_SOUND);
float tone_numlk_off[][2] = SONG(NUM_LOCK_OFF_SOUND);
float tone_scroll_on[][2] = SONG(SCROLL_LOCK_ON_SOUND);
float tone_scroll_off[][2] = SONG(SCROLL_LOCK_OFF_SOUND);
float music_scale[][2] = SONG(MUSIC_SCALE_SOUND);
#endif /* AUDIO_ENABLE */
void persistant_default_layer_set(uint16_t default_layer)
{
eeconfig_update_default_layer(default_layer);
default_layer_set(default_layer);
}
const uint16_t PROGMEM fn_actions[] = {
[0] = ACTION_MODS_ONESHOT(MOD_RSFT),
};
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
{
// MACRODOWN only works in this function
switch(id)
{
case MACRO_HELP_1:
if (record->event.pressed)
{
//uprintf("1");
}
break;
case MACRO_HELP_2:
if (record->event.pressed)
{
//uprintf("2");
}
break;
case MACRO_HELP_3:
if (record->event.pressed)
{
//uprintf("3");
}
break;
case MACRO_HELP_4:
if (record->event.pressed)
{
//uprintf("4");
}
break;
case MACRO_HELP_5:
if (record->event.pressed)
{
//uprintf("5");
}
break;
case MACRO_HELP_6:
if (record->event.pressed)
{
//uprintf("6");
}
break;
case MACRO_HELP_7:
if (record->event.pressed)
{
//uprintf("7");
}
break;
case MACRO_HELP_8:
if (record->event.pressed)
{
//uprintf("8");
}
break;
case MACRO_HELP_9:
if (record->event.pressed)
{
//uprintf("9");
}
break;
case MACRO_BREATH_TOGGLE:
if (record->event.pressed)
{
breathing_toggle();
}
break;
case MACRO_BREATH_SPEED_INC:
if (record->event.pressed)
{
breathing_speed_inc(1);
}
break;
case MACRO_BREATH_SPEED_DEC:
if (record->event.pressed)
{
breathing_speed_dec(1);
}
break;
case MACRO_BREATH_DEFAULT:
if (record->event.pressed)
{
breathing_defaults();
}
break;
case MACRO_QWERTY:
if (record->event.pressed)
{
persistant_default_layer_set(1UL<<LAYER_QWERTY);
}
break;
case MACRO_UPPER:
if (record->event.pressed)
{
layer_on(LAYER_UPPER);
breathing_speed_set(2);
breathing_pulse();
update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
}
else
{
layer_off(LAYER_UPPER);
update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
}
break;
case MACRO_LOWER:
if (record->event.pressed)
{
layer_on(LAYER_LOWER);
breathing_speed_set(2);
breathing_pulse();
update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
}
else
{
layer_off(LAYER_LOWER);
update_tri_layer(LAYER_LOWER, LAYER_UPPER, LAYER_ADJUST);
}
break;
case MACRO_FUNCTION:
if (record->event.pressed)
{
breathing_speed_set(3);
breathing_enable();
layer_on(LAYER_FUNCTION);
}
else
{
breathing_speed_set(1);
breathing_self_disable();
layer_off(LAYER_FUNCTION);
}
break;
case MACRO_MINE:
if(record->event.pressed)
{
return MACRO( I(03), T(R), T(O), T(O), T(T), W(10), T(TAB), W(10), T(T), T(O), T(O), T(R), T(ENTER), END );
}
break;
/*
case MACRO_SHENT:
if (record->event.pressed)
{
start = timer_read();
return MACRO( D(LSHIFT), END );
}
else
{
if (timer_elapsed(start) > 100)
{
return MACRO( U(LSHIFT), END);
}
else
{
return MACRO( U(LSHIFT), T(ENTER), END);
}
}
break;
*/
#ifdef BACKLIGHT_ENABLE
case MACRO_BACKLIGHT:
if (record->event.pressed)
{
backlight_step();
}
#endif
#ifdef MOUSEKEY_ENABLE
case MACRO_MOUSE:
if (record->event.pressed)
{
layer_invert(LAYER_MOUSE);
}
break;
case MACRO_MOUSE_MOVE_UL:
if (record->event.pressed)
{
mousekey_on(KC_MS_UP);
mousekey_on(KC_MS_LEFT);
}
else
{
mousekey_off(KC_MS_UP);
mousekey_off(KC_MS_LEFT);
}
break;
case MACRO_MOUSE_MOVE_UR:
if (record->event.pressed)
{
mousekey_on(KC_MS_UP);
mousekey_on(KC_MS_RIGHT);
}
else
{
mousekey_off(KC_MS_UP);
mousekey_off(KC_MS_RIGHT);
}
break;
case MACRO_MOUSE_MOVE_DL:
if (record->event.pressed)
{
mousekey_on(KC_MS_DOWN);
mousekey_on(KC_MS_LEFT);
}
else
{
mousekey_off(KC_MS_DOWN);
mousekey_off(KC_MS_LEFT);
}
break;
case MACRO_MOUSE_MOVE_DR:
if (record->event.pressed)
{
mousekey_on(KC_MS_DOWN);
mousekey_on(KC_MS_RIGHT);
}
else
{
mousekey_off(KC_MS_DOWN);
mousekey_off(KC_MS_RIGHT);
}
break;
#endif /* MOUSEKEY_ENABLE */
#ifdef AUDIO_ENABLE
case MACRO_TIMBRE_1:
if (record->event.pressed) set_timbre(TIMBRE_12);
break;
case MACRO_TIMBRE_2:
if (record->event.pressed) set_timbre(TIMBRE_25);
break;
case MACRO_TIMBRE_3:
if (record->event.pressed) set_timbre(TIMBRE_50);
break;
case MACRO_TIMBRE_4:
if (record->event.pressed) set_timbre(TIMBRE_75);
break;
case MACRO_TEMPO_U:
if (record->event.pressed) increase_tempo(10);
break;
case MACRO_TEMPO_D:
if (record->event.pressed) decrease_tempo(10);
break;
case MACRO_TONE_DEFAULT:
if (record->event.pressed)
{
set_timbre(TIMBRE_DEFAULT);
set_tempo(TEMPO_DEFAULT);
}
break;
#endif /* AUDIO_ENABLE */
default:
break;
}
return MACRO_NONE;
};
#ifdef AUDIO_ENABLE
void matrix_init_user(void)
{
set_voice(default_voice);
startup_user();
println("Matrix Init");
}
void led_set_user(uint8_t usb_led)
{
static uint8_t old_usb_led = 0;
_delay_ms(10); // gets rid of tick
if ((usb_led & (1<<USB_LED_CAPS_LOCK)) && !(old_usb_led & (1<<USB_LED_CAPS_LOCK)))
{
// If CAPS LK LED is turning on...
PLAY_SONG(tone_caps_on);
}
else if (!(usb_led & (1<<USB_LED_CAPS_LOCK)) && (old_usb_led & (1<<USB_LED_CAPS_LOCK)))
{
// If CAPS LK LED is turning off...
PLAY_SONG(tone_caps_off);
}
else if ((usb_led & (1<<USB_LED_NUM_LOCK)) && !(old_usb_led & (1<<USB_LED_NUM_LOCK)))
{
// If NUM LK LED is turning on...
PLAY_SONG(tone_numlk_on);
}
else if (!(usb_led & (1<<USB_LED_NUM_LOCK)) && (old_usb_led & (1<<USB_LED_NUM_LOCK)))
{
// If NUM LED is turning off...
PLAY_SONG(tone_numlk_off);
}
else if ((usb_led & (1<<USB_LED_SCROLL_LOCK)) && !(old_usb_led & (1<<USB_LED_SCROLL_LOCK)))
{
// If SCROLL LK LED is turning on...
PLAY_SONG(tone_scroll_on);
}
else if (!(usb_led & (1<<USB_LED_SCROLL_LOCK)) && (old_usb_led & (1<<USB_LED_SCROLL_LOCK)))
{
// If SCROLL LED is turning off...
PLAY_SONG(tone_scroll_off);
}
old_usb_led = usb_led;
}
void startup_user()
{
_delay_ms(10); // gets rid of tick
PLAY_SONG(tone_my_startup);
}
void shutdown_user()
{
PLAY_SONG(tone_my_goodbye);
_delay_ms(2000);
stop_all_notes();
}
void audio_on_user(void)
{
PLAY_SONG(tone_audio_on);
}
void music_on_user(void)
{
PLAY_SONG(tone_music_on);
}
void music_scale_user(void)
{
PLAY_SONG(music_scale);
}
#endif /* AUDIO_ENABLE */

30
keyboards/planck/keymaps/zrichard/rules.mk
Unescape Escape View File

@ -0,0 +1,30 @@
# 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)
# NOTE: the maximum .hex file size on Planck is 7000h (28672 decimal)
# 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 = 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 = yes # MIDI controls
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.
TAP_DANCE_ENABLE = no # Enable double or n tap macros
# 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
quantum/quantum.c
Unescape Escape View File

@ -162,6 +162,11 @@ void reset_keyboard(void) {
#define RSPC_KEY KC_0
#endif
// Shift / Enter setup
#ifndef SFTENT_KEY
#define SFTENT_KEY KC_ENT
#endif
static bool shift_interrupted[2] = {0, 0};
static uint16_t scs_timer[2] = {0, 0};
@ -552,6 +557,24 @@ bool process_record_quantum(keyrecord_t *record) {
}
return false;
}
case KC_SFTENT: {
if (record->event.pressed) {
shift_interrupted[1] = false;
scs_timer[1] = timer_read ();
register_mods(MOD_BIT(KC_RSFT));
}
else if (!shift_interrupted[1] && timer_elapsed(scs_timer[1]) < TAPPING_TERM) {
unregister_mods(MOD_BIT(KC_RSFT));
register_code(SFTENT_KEY);
unregister_code(SFTENT_KEY);
}
else {
unregister_mods(MOD_BIT(KC_RSFT));
}
return false;
}
case GRAVE_ESC: {
uint8_t shifted = get_mods() & ((MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT)
|MOD_BIT(KC_LGUI)|MOD_BIT(KC_RGUI)));

3
quantum/quantum_keycodes.h
Unescape Escape View File

@ -423,6 +423,9 @@ enum quantum_keycodes {
// Right shift, close paren
KC_RSPC,
// Shift, Enter
KC_SFTENT,
// Printing
PRINT_ON,
PRINT_OFF,

Write Preview
Loading…
Cancel
Save