Nulo/qmk_firmware
1
0
Fork 0
Code Releases Activity

Corvec's Planck layout

Browse source
This commit is contained in:
Corey T Kump 2018-03-06 17:22:13 -05:00 committed by Jack Humbert
parent 7b80aea8b2
commit b688c2c0b3
5 changed files with 449 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

53
keyboards/planck/keymaps/corvec/config.h Normal file
View file

@ -0,0 +1,53 @@
#ifndef CONFIG_USER_H
#define CONFIG_USER_H
#include "config_common.h"
#ifdef AUDIO_ENABLE
#define STARTUP_SONG SONG(PLANCK_SOUND)
// #define STARTUP_SONG SONG(NO_SOUND)
#define DEFAULT_LAYER_SONGS { SONG(QWERTY_SOUND), \
SONG(COLEMAK_SOUND), \
SONG(DVORAK_SOUND) \
}
#endif
#define MUSIC_MASK (keycode != KC_NO)
/*
* MIDI options
*/
/* 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
/* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
//#define MIDI_TONE_KEYCODE_OCTAVES 2
#define PERMISSIVE_HOLD
// AutoShift config
#define AUTO_SHIFT_TIMEOUT 135
#define NO_AUTO_SHIFT_SPECIAL
// #define NO_AUTO_SHIFT_NUMERIC
// #define NO_AUTO_SHIFT_ALPHA
// TapDance config
#define TAPPING_TERM 150
#endif

207
keyboards/planck/keymaps/corvec/keymap.c Normal file
View file

@ -0,0 +1,207 @@
/* Copyright 2015-2018 Jack Humbert, Corey Kump
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "planck.h"
#include "action_layer.h"
extern keymap_config_t keymap_config;
enum planck_layers {
_COLEMAK,
_QWERTY,
_LOWER,
_LEANDOWN,
_RAISE,
_WOBBLE,
_PLOVER,
_ADJUST
};
/* This include relies on the layer constants above and so must be declared after them */
#include "tapdance.c"
enum planck_keycodes {
QWERTY = SAFE_RANGE,
COLEMAK,
LOWER,
RAISE,
BACKLIT
};
#define KC_ KC_TRNS
#define KC_____ KC_TRNS
#define KC_XXXX KC_NO
#define KC_LOWR LOWER
#define KC_RASE RAISE
/**
* Custom Corvec Bindings
*
* Previously used but currently unused bindings are commented out.
**/
// Activate the Wobble layer
#define KC_WOBL MO(_WOBBLE)
// Dual function with Raise
#define KC_RESC LT(_RAISE, KC_ESC)
// Dual functions with Lower
#define KC_LENT LT(_LOWER, KC_ENT)
#define KC_LQUT LT(_LEANDOWN, KC_QUOT)
// Dual functions with Shift
#define KC_SDEL MT(MOD_LSFT, KC_DEL)
#define KC_SAPP MT(MOD_LSFT, KC_APP)
/**
* Functions taking advantage of tap dance:
**/
// Tap once: quote. Hold: LEANDOWN layer. Tap twice: minus.
#define KC_TQTD TD(TD_QUOT_LEAN_MINS)
// Tap once: [. Hold: RALT. Tap twice: {
#define KC_TALT TD(TD_LBRC_RALT_LCBR)
// Tap once: ]. Hold: RGUI. Tap twice: }
#define KC_TGUI TD(TD_RBRC_RGUI_RCBR)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_COLEMAK] = KC_KEYMAP(
//-----+----+----+----+----+----+----+----+----+----+----+----
TAB , Q , W , F , P , G , J , L , U , Y ,SCLN,BSPC,
//-----+----+----+----+----+----+----+----+----+----+----+----
RESC, A , R , S , T , D , H , N , E , I , O ,TQTD,
//-----+----+----+----+----+----+----+----+----+----+----+----
LSFT, Z , X , C , V , B , K , M ,COMM,DOT ,SLSH,RSFT,
//-----+----+----+----+----+----+----+----+----+----+----+----
LCTL,LGUI,WOBL,LALT,LENT, SPC, SPC,RASE,SDEL,TALT,TGUI,RCTL
),
[_QWERTY] = KC_KEYMAP(
//-----+----+----+----+----+----+----+----+----+----+----+----
TAB , Q , W , E , R , T , Y , U , I , O , P ,BSPC,
//-----+----+----+----+----+----+----+----+----+----+----+----
RESC, A , S , D , F , G , H , J , K , L ,SCLN,TQTD,
//-----+----+----+----+----+----+----+----+----+----+----+----
LSFT, Z , X , C , V , B , N , M ,COMM,DOT ,SLSH,RSFT,
//-----+----+----+----+----+----+----+----+----+----+----+----
LCTL,LGUI,WOBL,LALT,LENT, SPC, SPC,RASE,RALT,SAPP,RGUI,RCTL
),
[_LOWER] = KC_KEYMAP(
GRV ,EXLM, AT ,HASH, DLR,PERC,CIRC,AMPR,ASTR,LPRN,RPRN,____,
____,LPRN,RPRN,LBRC,RBRC,XXXX,LEFT,DOWN, UP ,RGHT,XXXX,MINS,
____,BSLS,TILD,PIPE,EQL ,UNDS,HOME,PGDN,PGUP,END ,BSLS,____,
____,____,____,____,____,____,____,____,____,____,____,____
),
[_LEANDOWN] = KC_KEYMAP(
GRV ,EXLM, AT ,HASH, DLR,PERC,CIRC,AMPR,ASTR,LPRN,RPRN,____,
____,LPRN,RPRN,LBRC,RBRC,LCBR,LCBR,DLR ,PERC,CIRC,____,____,
____,BSLS,TILD,PIPE,EQL ,UNDS,HOME,EXLM, AT ,HASH,BSLS,____,
____,____,____,____,____,____,____,____,LEFT,DOWN, UP ,RGHT
),
[_RAISE] = KC_KEYMAP(
GRV , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 0 ,____,
____,LPRN,RPRN,LCBR,RCBR,XXXX,XXXX, 4 , 5 , 6 ,PPLS,MINS,
____,BSLS,TILD,PIPE,EQL ,UNDS,XXXX, 1 , 2 , 3 ,PAST,____,
____,____,____,____,____,____,____,____,____,____,____,____
),
[_WOBBLE] = KC_KEYMAP(
GRV , F1 , F2 , F3 , F4 , NO ,MUTE,VOLD,VOLU, NO , NO , DEL,
, F5 , F6 , F7 , F8 , NO ,MPRV,MPLY,MSTP,MNXT, NO ,BSLS,
, F9 , F10, F11, F12, NO , NO , NO , NO , INS,PSCR, ,
, , , , , , , , , , ,
),
/* Adjust (Lower + Raise)
* ,-----------------------------------------------------------------------------------.
* |Colemk| | Debug|RGB Tg|RGB Md|RGB H+|RGB H-|RGB S+|RGB S-|RGB V+|RGB V-|Qwerty|
* |------+------+------+------+------+-------------+------+------+------+------+------|
* | | | |Aud on|Audoff|AGnorm|AGswap|Qwerty|Colemk| |AS On | AS + |
* |------+------+------+------+------+------|------+------+------+------+------+------|
* | |Voice-|Voice+|Mus on|Musoff|MIDIon|MIDIof|TermOn|TermOf|AS Rep|AS Off| AS - |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | | | | | | | | | Reset|
* `-----------------------------------------------------------------------------------'
*/
[_ADJUST] = {
{COLEMAK, _______, DEBUG, RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD, QWERTY },
{_______, _______, MU_MOD, AU_ON, AU_OFF, AG_NORM, AG_SWAP, QWERTY, COLEMAK, _______, KC_ASON, KC_ASUP},
{_______, MUV_DE, MUV_IN, MU_ON, MU_OFF, MI_ON, MI_OFF, TERM_ON, TERM_OFF,KC_ASRP, KC_ASOFF,KC_ASDN},
{_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, RESET }
}
};
#ifdef AUDIO_ENABLE
float plover_song[][2] = SONG(PLOVER_SOUND);
float plover_gb_song[][2] = SONG(PLOVER_GOODBYE_SOUND);
#endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
print("mode just switched to qwerty and this is a huge string\n");
set_single_persistent_default_layer(_QWERTY);
}
return false;
break;
case COLEMAK:
if (record->event.pressed) {
set_single_persistent_default_layer(_COLEMAK);
}
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
PORTE &= ~(1<<6);
} else {
unregister_code(KC_RSFT);
PORTE |= (1<<6);
}
return false;
break;
}
return true;
}

28
keyboards/planck/keymaps/corvec/readme.md Normal file
View file

@ -0,0 +1,28 @@
# Corvec's Planck Layout
This layout is a development-focused layout with an emphasis on ergonomics. It is intended to be used in Colemak mode,
but has a full-QWERTY mode for gaming compatibility.
It utilizes redundancy for common keys so that they are more easily accessible in every task. For example, the common
layers, Raise and Lower, both can be activated with two different keys, each pressed with either hand. Certain symbols
( \~|+_ ) are on both layers, since the keys they take up are a bit out of the way. The minus symbol is available on the
quote key in a variety of ways - both layers, as well as via tap dance.
The right-hand Lower activation key activates a slightly different layer. The keys accessed by the opposite hand are the
same as the Lower layer, but the keys on the right hand differ. For this reason, we refer to this instead as the
Leandown layer.
Auto-shift is enabled, but there are also three shift keys, since typing with auto-shift is by necessity slow.
Movement is done Vim-style, on the hjkl / hnei keys, on the Lower layer so that it is easiest to activate it.
The arrow keys are mimicked by Home/PgDn/PgUp/End on the next row.
The arrow keys and broad navigation keys are replaced by a symbol-pad on the Leandown layer. However, in order to allow
single-hand navigation, the bottom right corner cluster becomes arrow keys.
Media keys are in the same location as the arrow keys, but are on the Wobble layer instead.
Toggle layers are minimized so that the state of the keyboard is more predictable. Shift Toggle is in the works, but
will not be included until it can be set to deactivate automatically.
Delete is accessible from the third Shift key.

5
keyboards/planck/keymaps/corvec/rules.mk Normal file
View file

@ -0,0 +1,5 @@
AUTO_SHIFT_ENABLE = yes
TAP_DANCE_ENABLE = yes
API_SYSEX_ENABLE = no
CONSOLE_ENABLE = no
EXTRAKEY_ENABLE = no

156
keyboards/planck/keymaps/corvec/tapdance.c Normal file
View file

@ -0,0 +1,156 @@
/**
* Tap Dance config and functions
**/
/* Copyright 2018 Corey Kump
*
* 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/>.
*/
enum {
SINGLE_TAP = 1,
SINGLE_HOLD = 2,
DOUBLE_TAP = 3,
DOUBLE_SINGLE_TAP = 4,
UNKNOWN_TAPS = 5
};
typedef struct {
bool is_press_action;
int state;
} tap;
int cur_dance (qk_tap_dance_state_t *state) {
if (state->count == 1) {
if (state->interrupted || !state->pressed) {
return SINGLE_TAP;
} else {
return SINGLE_HOLD;
}
}
if (state->count == 2) {
if (state->interrupted) {
return DOUBLE_SINGLE_TAP;
} else if (!state->pressed) {
return DOUBLE_TAP;
}
}
return UNKNOWN_TAPS;
}
/**
* quote
**/
static tap quote_state = {
.is_press_action = true,
.state = 0
};
void quote_finished(qk_tap_dance_state_t *state, void *user_data) {
quote_state.state = cur_dance(state);
switch(quote_state.state) {
case SINGLE_TAP: register_code(KC_QUOT); break;
case SINGLE_HOLD: layer_on(_LEANDOWN); break;
case DOUBLE_TAP: register_code(KC_MINS); break;
case DOUBLE_SINGLE_TAP: register_code(KC_QUOT); unregister_code(KC_QUOT); register_code(KC_QUOT); break;
}
}
void quote_reset(qk_tap_dance_state_t *state, void *user_data) {
switch(quote_state.state) {
case SINGLE_TAP: unregister_code(KC_QUOT); break;
case SINGLE_HOLD: layer_off(_LEANDOWN); break;
case DOUBLE_TAP: unregister_code(KC_MINS); break;
case DOUBLE_SINGLE_TAP: unregister_code(KC_QUOT); break;
}
quote_state.state = 0;
}
/**
* ralt / left bracket / left curly brace
**/
static tap ralt_state = {
.is_press_action = true,
.state = 0
};
void ralt_finished(qk_tap_dance_state_t *state, void *user_data) {
ralt_state.state = cur_dance(state);
switch(ralt_state.state) {
case SINGLE_TAP: register_code(KC_LBRC); break;
case SINGLE_HOLD: register_code(KC_RALT); break;
case DOUBLE_TAP: register_code(KC_LSFT); register_code(KC_LBRC); break;
// fallback to alt because it's the primary purpose of this key
case DOUBLE_SINGLE_TAP: register_code(KC_RALT); break;
}
}
void ralt_reset(qk_tap_dance_state_t *state, void *user_data) {
switch(ralt_state.state) {
case SINGLE_TAP: unregister_code(KC_LBRC); break;
case SINGLE_HOLD: unregister_code(KC_RALT); break;
case DOUBLE_TAP: unregister_code(KC_LBRC); unregister_code(KC_LSFT); break;
case DOUBLE_SINGLE_TAP: unregister_code(KC_RALT); break;
}
ralt_state.state = 0;
}
/**
* rgui / right bracket / right curly brace
**/
static tap rgui_state = {
.is_press_action = true,
.state = 0
};
void rgui_finished(qk_tap_dance_state_t *state, void *user_data) {
rgui_state.state = cur_dance(state);
switch(rgui_state.state) {
case SINGLE_TAP: register_code(KC_RBRC); break;
case SINGLE_HOLD: register_code(KC_RGUI); break;
case DOUBLE_TAP: register_code(KC_LSFT); register_code(KC_RBRC); break;
// fallback to alt because it's the primary purpose of this key
case DOUBLE_SINGLE_TAP: register_code(KC_RGUI); break;
}
}
void rgui_reset(qk_tap_dance_state_t *state, void *user_data) {
switch(rgui_state.state) {
case SINGLE_TAP: unregister_code(KC_RBRC); break;
case SINGLE_HOLD: unregister_code(KC_RGUI); break;
case DOUBLE_TAP: unregister_code(KC_RBRC); unregister_code(KC_LSFT); break;
case DOUBLE_SINGLE_TAP: unregister_code(KC_RGUI); break;
}
rgui_state.state = 0;
}
/**
* Define the available tap dance keys
**/
enum {
TD_ALT_SHIFT = 0,
TD_LQUT_MINS,
TD_QUOT_LEAN_MINS,
TD_LBRC_RALT_LCBR,
TD_RBRC_RGUI_RCBR
};
qk_tap_dance_action_t tap_dance_actions[] = {
// Tap once for Alt, twice for Shift
[TD_ALT_SHIFT] = ACTION_TAP_DANCE_DOUBLE(KC_RALT, KC_RSFT),
[TD_QUOT_LEAN_MINS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, quote_finished, quote_reset),
[TD_LBRC_RALT_LCBR] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ralt_finished, ralt_reset),
[TD_RBRC_RGUI_RCBR] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, rgui_finished, rgui_reset)
};