mirrors/qmk_userspace
Watch
1
0
Fork
You've already forked qmk_userspace
 1
mirror of https://github.com/qmk/qmk_userspace.git synced 2026-07-25 03:03:36 -04:00
Code Issues Projects Releases Packages Wiki Activity

Rev7-deferred

Browse source
This commit is contained in:
Jenn Sears 2026-06-23 17:47:43 -04:00
commit 3f65cf6589
8 changed files with 673 additions and 59 deletions
Download patch file Download diff file Expand all files Collapse all files

2
keyboards/boardsource/unicorne/keymaps/unicorne_mx/config.h
View file

@ -26,7 +26,7 @@
#define AUDIO_PWM_DRIVER PWMD6 #define AUDIO_PWM_DRIVER PWMD6
#define AUDIO_INIT_DELAY #define AUDIO_INIT_DELAY
#define AUDIO_PWM_CHANNEL RP2040_PWM_CHANNEL_A #define AUDIO_PWM_CHANNEL RP2040_PWM_CHANNEL_A
#define STARTUP_SONG SONG(ODE_TO_JOY) // #define STARTUP_SONG SONG(ODE_TO_JOY)
//#define AUDIO_CLICKY //#define AUDIO_CLICKY
#define ANALOG_JOYSTICK_Y_AXIS_PIN GP26 #define ANALOG_JOYSTICK_Y_AXIS_PIN GP26

134
keyboards/boardsource/unicorne/keymaps/unicorne_mx/keymap.c
View file

@ -1,15 +1,8 @@
#include QMK_KEYBOARD_H #include QMK_KEYBOARD_H
#include "print.h"
extern uint8_t is_master; extern uint8_t is_master;
bool is_mouse_jiggle_active = false;
bool mouse_jiggle_direction = false; // used to alternate direction
uint16_t mouse_jiggle_frequency = 3000; // how often to move the mouse (15 seconds)
uint16_t mouse_jiggle_timer = 0;
bool is_alt_tab_active = false; // ADD this near the beginning of keymap.c
uint16_t alt_tab_timer = 0; // we will be using them soon.
void keyboard_post_init_user(void) { void keyboard_post_init_user(void) {
#ifdef RGB_MATRIX_ENABLE #ifdef RGB_MATRIX_ENABLE
rgb_matrix_enable(); rgb_matrix_enable();
@ -17,21 +10,33 @@ void keyboard_post_init_user(void) {
//rgb_matrix_mode(RGB_MATRIX_SOLID_REACTIVE); //rgb_matrix_mode(RGB_MATRIX_SOLID_REACTIVE);
rgb_matrix_sethsv(HSV_PURPLE); rgb_matrix_sethsv(HSV_PURPLE);
#endif #endif
debug_enable=true;
debug_matrix=true;
debug_keyboard=true;
} }
// 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 _LOWER 1
#define _RAISE 2
#define _FUNC 3
#define _SPCHRS 4
enum custom_keycodes { enum custom_keycodes {
DEFAULT = SAFE_RANGE, DEFAULT = SAFE_RANGE,
LOWER, LOWER,
RAISE, RAISE,
FUNC, FUNC,
LOCKWIN, LOCKWIN,
M_JIGL, KC_JIGG,
C_ALT_D, C_ALT_D,
SNAP_LFT, SNAP_LFT,
SNAP_RT, SNAP_RT,
SNAP_TOP, SNAP_TOP,
SNAP_BTM, SNAP_BTM
KVM_SW
}; };
enum combos { enum combos {
@ -47,8 +52,62 @@ combo_t key_combos[COMBO_COUNT] = {
}; };
__attribute__((weak))
bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { return true; }
__attribute__((weak))
bool process_record_secrets(uint16_t keycode, keyrecord_t *record) { return true; }
/*declare boolean for jiggler*/
bool is_jiggling = false;
/*timers*/
uint32_t idle_timeout = 30000; // (after 30s)
uint32_t mouse_interval = 10000; // (every 10s)
static uint32_t idle_callback(uint32_t trigger_time, void* cb_arg) {
// now idle
if(is_jiggling) {
#ifdef CONSOLE_ENABLE
dprintf("sending: %s\n", "X_F15");
#endif
SEND_STRING(SS_TAP(X_F15));
}
return mouse_interval;
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) { bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// on every key event start or extend `idle_callback()` deferred execution after IDLE_TIMEOUT_MS
static deferred_token idle_token = INVALID_DEFERRED_TOKEN;
#ifdef CONSOLE_ENABLE
dprintf("deferred_exec: %s\n", !extend_deferred_exec(idle_token, idle_timeout) ? "true" : "false");
#endif
if (!extend_deferred_exec(idle_token, idle_timeout)) {
idle_token = defer_exec(idle_timeout, idle_callback, NULL);
}
#ifdef CONSOLE_ENABLE
// uprintf("KL: kc: 0x%04X, col: %2u, row: %2u, pressed: %u, time: %5u, int: %u, count: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed, record->event.time, record->tap.interrupted, record->tap.count);
#endif
switch (keycode) { switch (keycode) {
case KC_JIGG:
if (record->event.pressed) {
is_jiggling = !is_jiggling; /*flip boolean to true*/
#ifdef CONSOLE_ENABLE
dprintf("is_jiggling: %s\n", is_jiggling ? "true" : "false");
#endif
if(is_jiggling) {
layer_on(_SPCHRS);
} else {
layer_off(_SPCHRS);
}
}
break;
case LOCKWIN: case LOCKWIN:
if (record->event.pressed) { if (record->event.pressed) {
// when keycode LOCKWIN is pressed // when keycode LOCKWIN is pressed
@ -60,11 +119,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
unregister_code(KC_L); // release the L key unregister_code(KC_L); // release the L key
} }
break; break;
case M_JIGL:
if (record->event.pressed) {
is_mouse_jiggle_active = !is_mouse_jiggle_active;
}
break;
case C_ALT_D: case C_ALT_D:
if(record->event.pressed) { if(record->event.pressed) {
register_code(KC_LCTL); register_code(KC_LCTL);
@ -122,39 +176,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
} }
break; break;
} }
return true; // return true;
return process_record_keymap(keycode, record) && process_record_secrets(keycode, record);
} }
void matrix_scan_user(void) {
if (is_keyboard_master()) {
// initialize timer on master half only, remove if statement above for non-split
if (mouse_jiggle_timer == 0) mouse_jiggle_timer = timer_read();
}
if (is_mouse_jiggle_active) {
if (timer_elapsed(mouse_jiggle_timer) > mouse_jiggle_frequency) {
mouse_jiggle_timer = timer_read();
tap_code(KC_NUM);
if (mouse_jiggle_direction) {
tap_code(KC_MS_L);
} else {
tap_code(KC_MS_R);
}
tap_code(KC_NUM);
mouse_jiggle_direction = !mouse_jiggle_direction;
}
}
}
// 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 _LOWER 1
#define _RAISE 2
#define _FUNC 3
// For _QWERTY layer // For _QWERTY layer
#define OSL_FUN OSL(_FUNC) #define OSL_FUN OSL(_FUNC)
#define LOW_TAB LT(_LOWER, KC_TAB) #define LOW_TAB LT(_LOWER, KC_TAB)
@ -184,11 +209,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_LOWER] = LAYOUT_split_3x6_3( \ [_LOWER] = LAYOUT_split_3x6_3( \
//,-----------------------------------------------------. ,-----------------------------------------------------. //,-----------------------------------------------------. ,-----------------------------------------------------.
KC_GRV, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, _______,\ KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F12,\
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
_______, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, _______,\ _______, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, _______,\
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
_______, XXXXXXX, XXXXXXX, KC_EQL, KC_LBRC, KC_LCBR, KC_RCBR, KC_RBRC, KC_MINS, XXXXXXX, XXXXXXX,_______,\ _______, XXXXXXX, XXXXXXX, KC_EQL, KC_LBRC, KC_LCBR, KC_RCBR, KC_RBRC, KC_MINS, XXXXXXX, XXXXXXX,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 \
//`--------------------------' `--------------------------' //`--------------------------' `--------------------------'
@ -200,7 +225,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
_______, KC_INS, KC_END, KC_PGDN, XXXXXXX, XXXXXXX, _______, KC_LEFT, KC_DOWN, KC_RGHT, XXXXXXX, _______,\ _______, KC_INS, KC_END, KC_PGDN, XXXXXXX, XXXXXXX, _______, KC_LEFT, KC_DOWN, KC_RGHT, XXXXXXX, _______,\
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_MPLY, KC_MPRV, KC_MNXT, KC_VOLD, KC_VOLU, KC_MUTE,\ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_MPLY, KC_MPRV, KC_MNXT, KC_VOLD, KC_VOLU, 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\
//`--------------------------' `--------------------------' //`--------------------------' `--------------------------'
@ -208,11 +233,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_FUNC] = LAYOUT_split_3x6_3( \ [_FUNC] = LAYOUT_split_3x6_3( \
//,-----------------------------------------------------. ,-----------------------------------------------------. //,-----------------------------------------------------. ,-----------------------------------------------------.
_______, KC_F1 , KC_F2 , KC_F3 , KC_F4 , KC_F5 , KVM_SW, XXXXXXX, SNAP_TOP, XXXXXXX, RGB_TOG, _______,\ _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, SNAP_TOP, XXXXXXX, RGB_TOG, _______,\
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
C_ALT_D, KC_MS_L, KC_MS_U, KC_MS_D, KC_MS_R, KC_F12, M_JIGL,SNAP_LFT, SNAP_BTM, SNAP_RT, KC_CALC, _______,\ C_ALT_D, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,SNAP_LFT, SNAP_BTM, SNAP_RT, KC_CALC, _______,\
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------|
_______, KC_BTN1, KC_BTN2, KC_BTN3, XXXXXXX, KC_NUM, LOCKWIN, QK_RBT, QK_BOOT, EE_CLR, KC_SLEP, _______,\ _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, LOCKWIN, QK_RBT, QK_BOOT, EE_CLR, KC_SLEP, _______,\
//|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------| //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------|
KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS\ KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS\
//`--------------------------' `--------------------------' //`--------------------------' `--------------------------'
@ -244,6 +269,9 @@ layer_state_t layer_state_set_user(layer_state_t state) {
case _FUNC: case _FUNC:
rgb_matrix_sethsv(HSV_RED); rgb_matrix_sethsv(HSV_RED);
break; break;
case _SPCHRS:
rgb_matrix_set_color(i, HSV_YELLOW);
break;
} }
return state; return state;
} }

8
keyboards/boardsource/unicorne/keymaps/unicorne_mx/rules.mk
View file

@ -3,13 +3,15 @@ AUDIO_DRIVER = pwm_hardware
POINTING_DEVICE_DRIVER = analog_joystick POINTING_DEVICE_DRIVER = analog_joystick
OLED_ENABLE = yes OLED_ENABLE = yes
AUDIO_ENABLE = yes AUDIO_ENABLE = yes
MOUSEKEY_ENABLE = yes MOUSEKEY_ENABLE = no
ENCODER_ENABLE = yes ENCODER_ENABLE = no
ENCODER_MAP_ENABLE = yes ENCODER_MAP_ENABLE = no
# markstos: enable media keys # markstos: enable media keys
EXTRAKEY_ENABLE = yes EXTRAKEY_ENABLE = yes
DEFERRED_EXEC_ENABLE = yes
# markstos: smaller file size, little down-side # markstos: smaller file size, little down-side
LINK_TIME_OPTIMIZATION_ENABLE = yes LINK_TIME_OPTIMIZATION_ENABLE = yes

2
keyboards/inland/mk47/keymaps/inland/keymap.c
View file

@ -88,7 +88,7 @@ static uint32_t idle_callback(uint32_t trigger_time, void* cb_arg) {
bool process_record_user(uint16_t keycode, keyrecord_t *record) { bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// on every key event start or extend `idle_callback()` deferred execution after IDLE_TIMEOUT_MS // on every key event start or extend `idle_callback()` deferred execution after IDLE_TIMEOUT_MS
static deferred_token idle_token = INVALID_DEFERRED_TOKEN; static deferred_token idle_token = INVALID_DEFERRED_TOKEN;
#ifdef CONSOLE_ENABLE #ifdef CONSOLE_ENABLE

2
keyboards/planck/rev7/keymaps/default/keymap.c
View file

@ -158,7 +158,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
*/ */
[_RAISE] = LAYOUT_planck_grid( [_RAISE] = LAYOUT_planck_grid(
_______, KC_DEL, KC_HOME, KC_PGUP, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_UP, XXXXXXX, XXXXXXX, KC_BSPC, _______, KC_DEL, KC_HOME, KC_PGUP, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_UP, XXXXXXX, XXXXXXX, KC_BSPC,
_______, KC_INS, KC_END, KC_PGDN, XXXXXXX, XXXXXXX, XXXXXXX, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, KC_BSLS, _______, KC_INS, KC_END, KC_PGDN, XXXXXXX, XXXXXXX, XXXXXXX, KC_LEFT, KC_DOWN, KC_UP, XXXXXXX, KC_BSLS,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, OSL_FUN, _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, OSL_FUN,
_______, _______, OSM_ALT, OSM_GUI,LOW_TAB, KC_SPC, KC_ENT, RSE_BSP, OSM_SFT, _______, _______, _______ _______, _______, OSM_ALT, OSM_GUI,LOW_TAB, KC_SPC, KC_ENT, RSE_BSP, OSM_SFT, _______, _______, _______
), ),

65
keyboards/planck/rev7/keymaps/deferred/config.h Normal file
View file

@ -0,0 +1,65 @@
#pragma once
/* SPI Config for spi flash*/
#define SPI_DRIVER SPIDQ
#define SPI_SCK_PIN B3
#define SPI_MOSI_PIN B5
#define SPI_MISO_PIN B4
#define EXTERNAL_FLASH_SPI_SLAVE_SELECT_PIN C12
/* I2C Config for LED Driver */
#define SNLED27351_I2C_ADDRESS_1 SNLED27351_I2C_ADDRESS_GND
/* WB32 MCU has no default definition */
#define I2C1_OPMODE OPMODE_I2C
#define I2C1_CLOCK_SPEED 400000
#define RGB_MATRIX_LED_COUNT 47
#define RGB_MATRIX_DEFAULT_SPD 127
#define RGB_MATRIX_TIMEOUT 180000 // 3 minutes // 300000 = 5 minutes
#define RGB_MATRIX_LED_FLUSH_LIMIT 16
#define RGB_MATRIX_DEFAULT_SAT 77
#define RGB_MATRIX_DEFAULT_VAL 86
#define RGB_DISABLE_WHEN_USB_SUSPENDED
#define ENABLE_RGB_MATRIX_ALPHAS_MODS
#define RGB_MATRIX_DEFAULT_MODE RGB_MATRIX_ALPHAS_MODS
#define ENABLE_RGB_MATRIX_SOLID_REACTIVE
#define RGB_TRIGGER_ON_KEYDOWN
#define RGB_MATRIX_FRAMEBUFFER_EFFECTS
#define RGB_MATRIX_KEYPRESSES
// Customized by markstos
#define TAPPING_TERM 200
#define TAPPING_TERM_PER_KEY
// used for Tapping Term on thumb keys
#define TAPPING_TERM_THUMB 125
// If you press a dual-role key, press another key, and then release the
// dual-role key, all within the tapping term, by default the dual-role key
// will perform its tap action. If the HOLD_ON_OTHER_KEY_PRESS option is
// enabled, the dual-role key will perform its hold action instead.
#define HOLD_ON_OTHER_KEY_PRESS
// markstos: prevent keydown and keyup from firing on different layers
#define PREVENT_STUCK_MODIFER
// When enabled, typing a mod-tap plus second within term will register as the mod-combo
// Ref: https://beta.docs.qmk.fm/using-qmk/software-features/tap_hold#permissive-hold
#define PERMISSIVE_HOLD
#define COMBO_COUNT 3
// Set the COMBO_TERM so low that I won't type the keys one after each other during normal typing.
// They would have be held together intentionally to trigger this.
#define COMBO_TERM 40
// These mostly affect my one-shot Shift key, providing a CapsLock alternative.
// I want a relatively low timeout, so if I accidentally type "Shift", I can pause just briefly and move on.
#define ONESHOT_TAP_TOGGLE 3 /* Tapping this number of times holds the key until tapped once again. */
#define ONESHOT_TIMEOUT 2000 /* Time (in ms) before the one shot key is released */

500
keyboards/planck/rev7/keymaps/deferred/keymap.c Normal file
View file

@ -0,0 +1,500 @@
/* Copyright 2015-2023 Jack Humbert
*
* 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 QMK_KEYBOARD_H
enum planck_layers { _QWERTY, _COLEMAK, _COLEMAKDH, _DVORAK, _LOWER, _RAISE, _FUNC, _PLOVER, _ADJUST };
enum planck_keycodes { QWERTY = SAFE_RANGE, COLEMAK, COLEMAKDH, DVORAK, PLOVER, BACKLIT, EXT_PLV, LOCKWIN, KC_JIGG, C_ALT_D, SNAP_LFT, SNAP_RT, SNAP_TOP, SNAP_BTM};
//Combos
enum combos { JK_ESC };
const uint16_t PROGMEM jk_combo[] = {KC_J, KC_K, COMBO_END};
// For Vim, put Escape on the home row
combo_t key_combos[COMBO_COUNT] = { [JK_ESC] = COMBO(jk_combo, KC_ESC),};
// Tap Dance declarations
enum { TD_SPC_ENT, };
// Tap Dance definitions
// Tap once for Space, twice for Enter Lock
tap_dance_action_t tap_dance_actions[] = {
[TD_SPC_ENT] = ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT),
};
__attribute__((weak))
bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { return true; }
__attribute__((weak))
bool process_record_secrets(uint16_t keycode, keyrecord_t *record) { return true; }
/*declare boolean for jiggler*/
bool is_jiggling = false;
/*timers*/
uint32_t idle_timeout = 30000; // (after 30s)
uint32_t mouse_interval = 10000; // (every 10s)
static uint32_t idle_callback(uint32_t trigger_time, void* cb_arg) {
// now idle
if(is_jiggling) {
#ifdef CONSOLE_ENABLE
dprintf("sending: %s\n", "X_F15");
#endif
SEND_STRING(SS_TAP(X_F15));
}
return mouse_interval;
}
#define LOWER MO(_LOWER)
#define RAISE MO(_RAISE)
// For _QWERTY layer
#define OSL_FUN OSL(_FUNC)
#define LOW_TAB LT(_LOWER, KC_TAB)
#define RSE_BSP LT(_RAISE, KC_BSPC)
#define OSM_SFT OSM(MOD_LSFT)
#define OSM_RSFT OSM(MOD_RSFT)
#define OSM_ALT OSM(MOD_LALT)
#define OSM_CTL OSM(MOD_LCTL)
#define OSM_GUI OSM(MOD_LGUI)
// For _LOWER layer
#define ALT_TAB LALT(KC_TAB)
/* clang-format off */
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Qwerty
* ,-----------------------------------------------------------------------------------.
* | Alt | Q | W | E | R | T | Y | U | I | O | P | \ | |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Shift| A | S | D | F | G | H | J | K | L | ; | ' |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Ctrl | Z | X | C | V | B | N | M | , | . | / | Func |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | Alt | GUI |Lower |Space |Enter |Raise |Shift | | |LCKWIN|
* `-----------------------------------------------------------------------------------'
*/
[_QWERTY] = LAYOUT_planck_grid(
OSM_ALT, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSLS,
OSM_SFT, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,
OSM_CTL, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, OSL_FUN,
XXXXXXX, XXXXXXX, OSM_ALT, OSM_GUI, LOW_TAB, KC_SPC, KC_ENT, RSE_BSP, OSM_RSFT,C_ALT_D, XXXXXXX, LOCKWIN
),
/* Colemak
* ,-----------------------------------------------------------------------------------.
* | Alt | Q | W | F | P | G | J | L | U | Y | ; | \ | |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Esc | A | R | S | T | D | H | N | E | I | O | ' |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | K | M | , | . | / | Func |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | Alt | GUI |LowTab|Space |Enter |RaiBsp|Shift | | | |
* `-----------------------------------------------------------------------------------'
*/
[_COLEMAK] = LAYOUT_planck_grid(
OSM_ALT, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSLS,
OSM_SFT, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT,
OSM_CTL, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, OSL_FUN,
XXXXXXX, XXXXXXX, OSM_ALT, OSM_GUI, LOW_TAB, KC_SPC, KC_ENT, RSE_BSP, OSM_RSFT, XXXXXXX, XXXXXXX, XXXXXXX
),
/* ColemakDH
* ,-----------------------------------------------------------------------------------.
* | Alt | Q | W | F | P | B | J | L | U | Y | ; | Bksp |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Esc | A | R | S | T | G | M | N | E | I | O | ' |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Shift| Z | X | C | D | V | K | H | , | . | / | Func |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | Alt | GUI |LowTab|Space |Enter |RaiBsp|Shift | | | |
* `-----------------------------------------------------------------------------------'
*/
[_COLEMAKDH] = LAYOUT_planck_grid(
OSM_ALT, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSPC,
OSM_SFT, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT,
OSM_CTL, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, OSL_FUN ,
XXXXXXX, XXXXXXX, OSM_ALT, OSM_GUI, LOW_TAB, KC_SPC, KC_ENT, RSE_BSP, OSM_RSFT, XXXXXXX, XXXXXXX, XXXXXXX
),
/* Dvorak
* ,-----------------------------------------------------------------------------------.
* | Alt | ' | , | . | 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 | Func |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | Alt | GUI |LowTab|Space |Enter |RaiBsp|Shift | | | |
* `-----------------------------------------------------------------------------------'
*/
[_DVORAK] = LAYOUT_planck_grid(
OSM_ALT, 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 ,
XXXXXXX, XXXXXXX, OSM_ALT, OSM_GUI, LOW_TAB, KC_SPC, KC_ENT, RSE_BSP, OSM_RSFT, XXXXXXX, XXXXXXX, XXXXXXX
),
/* Lower
* ,-----------------------------------------------------------------------------------.
* | ~ ` | F1 | F2 | F3 | F4 | F5 | F6 | F7 | F8 | F9 | F10 | F12 |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | 1 ! | 2 @ | 3 # | 4 $ | 5 % | 6 ^ | 7 & | 8 * | 9 ( | 0 ) | |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | | = + | [ | { | } | ] | - _ | | | Func |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | Alt | GUI |LowTab|Space |Enter |RaiBsp|Shift | | | |
* `-----------------------------------------------------------------------------------'
*/
[_LOWER] = LAYOUT_planck_grid(
KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F12,
_______, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, _______,
_______, _______, _______, KC_EQL, KC_LBRC, KC_LCBR, KC_RCBR, KC_RBRC, KC_MINS, _______, _______, OSL_FUN,
_______, _______, OSM_ALT, OSM_GUI,LOW_TAB, KC_SPC, KC_ENT, RSE_BSP, OSM_SFT, _______, _______, _______
),
/* Raise
* ,-----------------------------------------------------------------------------------.
* | | Del | Home | PGUP | | | | | Up | | | |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | Ins | End | PGDN | | | | Left | Down | Up | Right| |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | | | | | | | | | | Func |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | Alt | GUI |LowTab|Space |Enter |RaiBsp|Shift | | | |
* `-----------------------------------------------------------------------------------'
*/
[_RAISE] = LAYOUT_planck_grid(
_______, KC_DEL, KC_HOME, KC_PGUP, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_UP, XXXXXXX, XXXXXXX, KC_BSPC,
_______, KC_INS, KC_END, KC_PGDN, XXXXXXX, XXXXXXX, XXXXXXX, KC_LEFT, KC_DOWN, KC_UP, XXXXXXX, KC_BSLS,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, OSL_FUN,
_______, _______, OSM_ALT, OSM_GUI,LOW_TAB, KC_SPC, KC_ENT, RSE_BSP, OSM_SFT, _______, _______, _______
),
/* Func
* ,-----------------------------------------------------------------------------------.
* | | | | | | | | | | | | MUTE |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | | | | | |SNPLFT|SNPBTM|SNPTOP|SNP_RT| CALC |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | | | | |LCKWIN|QK_RBT|QK_BT |EE_CLR| | Func |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | Alt | GUI |LowTab|Space |Enter |RaiBsp|Shift | | | |
* `-----------------------------------------------------------------------------------'
*/
[_FUNC] = LAYOUT_planck_grid(
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, SNAP_TOP, XXXXXXX, XXXXXXX, KC_MUTE,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, SNAP_LFT, SNAP_BTM, SNAP_RT, KC_CALC, XXXXXXX,
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, LOCKWIN, QK_RBT, QK_BOOT, EE_CLR, XXXXXXX, OSL_FUN,
XXXXXXX, XXXXXXX, OSM_ALT, OSM_GUI, LOW_TAB, KC_SPC, KC_ENT, RSE_BSP, OSM_SFT, XXXXXXX, XXXXXXX, XXXXXXX
),
/* Plover layer (http://opensteno.org)
* ,-----------------------------------------------------------------------------------.
* | # | # | # | # | # | # | # | # | # | # | # | # |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | S | T | P | H | * | * | F | P | L | T | D |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | S | K | W | R | * | * | R | B | G | S | Z |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | Exit | | | A | O | | | E | U | | | |
* `-----------------------------------------------------------------------------------'
*/
[_PLOVER] = LAYOUT_planck_grid(
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)
* v------------------------RGB CONTROL--------------------v
* ,-----------------------------------------------------------------------------------.
* | | Reset|Debug | RGB |RGBMOD| HUE+ | HUE- | SAT+ | SAT- |BRGTH+|BRGTH-| Del |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | |MUSmod|Aud on|Audoff|AGnorm|AGswap|Qwerty|Colemk|Dvorak|Plover| |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | |Voice-|Voice+|Mus on|Musoff|MIDIon|MIDIof| | | | | |
* |------+------+------+------+------+------+------+------+------+------+------+------|
* | | | Alt | GUI |LowTab|Space |Enter |RaiBsp|Shift | | | |
* `-----------------------------------------------------------------------------------'
*/
[_ADJUST] = LAYOUT_planck_grid(
_______, QK_BOOT, DB_TOGG, RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD, KC_DEL ,
_______, EE_CLR, MU_NEXT, AU_ON, AU_OFF, AG_NORM, AG_SWAP, QWERTY, COLEMAK, COLEMAKDH, PLOVER, _______,
_______, AU_PREV, AU_NEXT, MU_ON, MU_OFF, MI_ON, MI_OFF, _______, _______, _______, _______, _______,
_______, _______, OSM_ALT, OSM_GUI, LOW_TAB, KC_SPC, KC_ENT, RSE_BSP, OSM_SFT, _______, _______, _______
)
};
/* clang-format on */
uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case LT(_RAISE, KC_BSPC):
return TAPPING_TERM_THUMB;
case LT(_LOWER, KC_TAB):
return TAPPING_TERM_THUMB;
default:
return TAPPING_TERM;
}
}
#ifdef AUDIO_ENABLE
float plover_song[][2] = SONG(PLOVER_SOUND);
float plover_gb_song[][2] = SONG(PLOVER_GOODBYE_SOUND);
#endif
layer_state_t layer_state_set_user(layer_state_t state) {
return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST);
}
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
// on every key event start or extend `idle_callback()` deferred execution after IDLE_TIMEOUT_MS
static deferred_token idle_token = INVALID_DEFERRED_TOKEN;
#ifdef CONSOLE_ENABLE
dprintf("deferred_exec: %s\n", !extend_deferred_exec(idle_token, idle_timeout) ? "true" : "false");
#endif
if (!extend_deferred_exec(idle_token, idle_timeout)) {
idle_token = defer_exec(idle_timeout, idle_callback, NULL);
}
#ifdef CONSOLE_ENABLE
// uprintf("KL: kc: 0x%04X, col: %2u, row: %2u, pressed: %u, time: %5u, int: %u, count: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed, record->event.time, record->tap.interrupted, record->tap.count);
#endif
switch (keycode) {
case KC_JIGG:
if (record->event.pressed) {
is_jiggling = !is_jiggling; /*flip boolean to true*/
#ifdef CONSOLE_ENABLE
dprintf("is_jiggling: %s\n", is_jiggling ? "true" : "false");
#endif
if(is_jiggling) {
layer_on(_SPCHRS);
} else {
layer_off(_SPCHRS);
}
}
break;
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 COLEMAKDH:
if (record->event.pressed) {
set_single_persistent_default_layer(_COLEMAKDH);
}
return false;
break;
case DVORAK:
if (record->event.pressed) {
set_single_persistent_default_layer(_DVORAK);
}
return false;
break;
case BACKLIT:
if (record->event.pressed) {
register_code(KC_RSFT);
} else {
unregister_code(KC_RSFT);
}
return false;
break;
case PLOVER:
if (record->event.pressed) {
#ifdef AUDIO_ENABLE
stop_all_notes();
PLAY_SONG(plover_song);
#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_SONG(plover_gb_song);
#endif
layer_off(_PLOVER);
}
return false;
break;
case LOCKWIN:
if (record->event.pressed) {
// when keycode LOCKWIN is pressed
register_code(KC_LGUI); // press the Windows key
register_code(KC_L); // press the L key
} else {
// when keycode LOCKWIN is released
unregister_code(KC_LGUI); // release the Windows key
unregister_code(KC_L); // release the L key
}
break;
case C_ALT_D:
if(record->event.pressed) {
register_code(KC_LCTL);
register_code(KC_LALT);
register_code(KC_DEL);
} else {
unregister_code(KC_LCTL);
unregister_code(KC_LALT);
unregister_code(KC_DEL);
}
break;
case SNAP_LFT:
if(record->event.pressed) {
register_code(KC_LGUI);
register_code(KC_LEFT);
} else {
unregister_code(KC_LGUI);
unregister_code(KC_LEFT);
}
break;
case SNAP_RT:
if(record->event.pressed) {
register_code(KC_LGUI);
register_code(KC_RIGHT);
} else {
unregister_code(KC_LGUI);
unregister_code(KC_RIGHT);
}
break;
case SNAP_TOP:
if(record->event.pressed) {
register_code(KC_LGUI);
register_code(KC_UP);
} else {
unregister_code(KC_LGUI);
unregister_code(KC_UP);
}
break;
case SNAP_BTM:
if(record->event.pressed) {
register_code(KC_LGUI);
register_code(KC_DOWN);
} else {
unregister_code(KC_LGUI);
unregister_code(KC_DOWN);
}
break;
}
// return true;
return process_record_keymap(keycode, record) && process_record_secrets(keycode, record);
}
/* clang-format off */
float melody[8][2][2] = {
{{440.0f, 8}, {440.0f, 24}},
{{440.0f, 8}, {440.0f, 24}},
{{440.0f, 8}, {440.0f, 24}},
{{440.0f, 8}, {440.0f, 24}},
{{440.0f, 8}, {440.0f, 24}},
{{440.0f, 8}, {440.0f, 24}},
{{440.0f, 8}, {440.0f, 24}},
{{440.0f, 8}, {440.0f, 24}},
};
/* clang-format on */
#define JUST_MINOR_THIRD 1.2
#define JUST_MAJOR_THIRD 1.25
#define JUST_PERFECT_FOURTH 1.33333333
#define JUST_TRITONE 1.42222222
#define JUST_PERFECT_FIFTH 1.33333333
#define ET12_MINOR_SECOND 1.059463
#define ET12_MAJOR_SECOND 1.122462
#define ET12_MINOR_THIRD 1.189207
#define ET12_MAJOR_THIRD 1.259921
#define ET12_PERFECT_FOURTH 1.33484
#define ET12_TRITONE 1.414214
#define ET12_PERFECT_FIFTH 1.498307
deferred_token tokens[8];
uint32_t reset_note(uint32_t trigger_time, void *note) {
*(float*)note = 440.0f;
return 0;
}
bool encoder_update_user(uint8_t index, bool clockwise) {
cancel_deferred_exec(tokens[index]);
if (clockwise) {
melody[index][1][0] = melody[index][1][0] * ET12_MINOR_SECOND;
melody[index][0][0] = melody[index][1][0] / ET12_PERFECT_FIFTH;
audio_play_melody(&melody[index], 2, false);
} else {
melody[index][1][0] = melody[index][1][0] / ET12_MINOR_SECOND;
melody[index][0][0] = melody[index][1][0] * ET12_TRITONE;
audio_play_melody(&melody[index], 2, false);
}
tokens[index] = defer_exec(1000, reset_note, &melody[index][1][0]);
return false;
}
bool dip_switch_update_user(uint8_t index, bool active) {
switch (index) {
case 0: {
#ifdef AUDIO_ENABLE
static bool play_sound = false;
#endif
if (active) {
#ifdef AUDIO_ENABLE
if (play_sound) {
PLAY_SONG(plover_song);
}
#endif
layer_on(_ADJUST);
} else {
#ifdef AUDIO_ENABLE
if (play_sound) {
PLAY_SONG(plover_gb_song);
}
#endif
layer_off(_ADJUST);
}
#ifdef AUDIO_ENABLE
play_sound = true;
#endif
break;
}
}
return true;
}

19
keyboards/planck/rev7/keymaps/deferred/rules.mk Normal file
View file

@ -0,0 +1,19 @@
BOOTMAGIC_ENABLE = yes
CONSOLE_ENABLE = yes
COMMAND_ENABLE = no
ENCODER_ENABLE = no
RGB_MATRIX_ENABLE = yes
VIA_ENABLE = no
# markstos: enable media keys
EXTRAKEY_ENABLE = yes
DEFERRED_EXEC_ENABLE = yes
# markstos: smaller file size, little down-side
LINK_TIME_OPTIMIZATION_ENABLE = yes
# markstos: for combos!
COMBO_ENABLE = yes
TAP_DANCE_ENABLE = yes