diff options
Diffstat (limited to 'qmk')
| -rw-r--r-- | qmk/keyboards/sofle_choc/keymaps/custom/config.h | 45 | ||||
| -rw-r--r-- | qmk/keyboards/sofle_choc/keymaps/custom/keycodes.c | 78 | ||||
| -rw-r--r-- | qmk/keyboards/sofle_choc/keymaps/custom/keycodes.h | 28 | ||||
| -rw-r--r-- | qmk/keyboards/sofle_choc/keymaps/custom/keymap.c | 68 | ||||
| -rw-r--r-- | qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.c | 226 | ||||
| -rw-r--r-- | qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.h | 30 | ||||
| -rw-r--r-- | qmk/keyboards/sofle_choc/keymaps/custom/rules.mk | 6 |
7 files changed, 481 insertions, 0 deletions
diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/config.h b/qmk/keyboards/sofle_choc/keymaps/custom/config.h new file mode 100644 index 0000000..9a89fd8 --- /dev/null +++ b/qmk/keyboards/sofle_choc/keymaps/custom/config.h @@ -0,0 +1,45 @@ +/* Copyright 2023 Brian Low + * + * 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/>. + */ +#pragma once + +// Enabling this option changes the startup behavior to listen for an +// active USB communication to delegate which part is master and which +// is slave. With this option enabled and theres’s USB communication, +// then that half assumes it is the master, otherwise it assumes it +// is the slave. +// +// I've found this helps with some ProMicros where the slave does not boot +#define SPLIT_USB_DETECT + +#define RGB_DISABLE_WHEN_USB_SUSPENDED // turn off effects when suspended +#define SPLIT_TRANSPORT_MIRROR // If LED_MATRIX_KEYPRESSES or LED_MATRIX_KEYRELEASES is enabled, you also will want to enable SPLIT_TRANSPORT_MIRROR +#define RGB_MATRIX_MAXIMUM_BRIGHTNESS 100 // limits maximum brightness of LEDs (max 255). Higher may cause the controller to crash. + + + +#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET // Activates the double-tap behavior +#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_TIMEOUT 200U // Timeout window in ms in which the double tap can occur. +#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_LED D5 // Specify an optional status LED by GPIO number which blinks when entering the bootloader + +#define TAPPING_TERM 200 + +// Movihy the tap-hold configuration for helping with some tap-dance keys. +// The behavior with double-tap (like c/ç) and mod-tap is to wait the delay for +// the tap-dance before reporting the key to send. +// If I release the MOD-TAP key before, the modifier is not applied and the +// host receive a sequence of two keys, which is not what I want. +//#define PERMISSIVE_HOLD +//#define HOLD_ON_OTHER_KEY_PRESS diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/keycodes.c b/qmk/keyboards/sofle_choc/keymaps/custom/keycodes.c new file mode 100644 index 0000000..e0f8994 --- /dev/null +++ b/qmk/keyboards/sofle_choc/keymaps/custom/keycodes.c @@ -0,0 +1,78 @@ +#include QMK_KEYBOARD_H +#include "keymap_bepo.h" +#include "keycodes.h" + +/* + * Rules and modifier to apply over the keycodes. This includes the keys + * redefinitions and the keys to include in the caps_word mecanism. + * + * All thoses update are working over the custom keys declared in `keycodes.h` + */ + +/* + * This function need to be declared after the key definition, including the + * tapdance keys because I need to reference the keycode here if I want to + * include them in the caps_word mecanism. + */ +bool caps_word_press_user(uint16_t keycode) { + switch (keycode) { + // Keycodes that continue Caps Word, with shift applied. + case KC_A ... KC_Z: + case KC_1 ... KC_0: + case KC_MINS: + case KEY_C: // Add also the tapdance keys here. + case KEY_W: + case KEY_E: + case BP_Z: // Additionals keys from the bepo layout. + case BP_M: + case BP_G: + case BP_H: + case BP_N: + add_weak_mods(MOD_BIT(KC_LSFT)); // Apply shift to next key. + return true; + + // Keycodes that continue Caps Word, without shifting. + case KC_BSPC: + case KC_DEL: + return true; + case KC_SPACE: + // The space key is used in order to generate the _ symbol, + // I check which modifier is applied, it’s ok when it’s ALT + return get_mods() & MOD_MASK_ALT; + + default: + return false; // Deactivate Caps Word. + } +} + +// +// Override the symbol ° and replace it by ` +// The symbol is still available in the symbol layer with the key just below. +// +const key_override_t perc_key_override = + ko_make_basic(MOD_MASK_SHIFT, KEY_PRC, LSFT(BP_PERC)); + +// +// I don’t care of the mapping CTRL+Ç and using the mod_tap does not work well +// when I type too fast because of tap-dance, so I remap the pattern here. +// +const key_override_t c_key_override = + ko_make_basic(MOD_MASK_CTRL, KEY_C, LCTL(BP_C)); + +// Same here, I override the key W with CTRL because the tapdance activate the +// caps_word which does not make sense here. +const key_override_t w_key_override = + ko_make_basic(MOD_MASK_CTRL, KEY_W, LCTL(BP_W)); + +const key_override_t e_key_override = + ko_make_basic(MOD_MASK_CTRL, KEY_E, RCTL(BP_E)); + + +// This globally defines all key overrides to be used +const key_override_t **key_overrides = (const key_override_t *[]){ + &perc_key_override, + &c_key_override, + &w_key_override, + &e_key_override, + NULL +}; diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/keycodes.h b/qmk/keyboards/sofle_choc/keymaps/custom/keycodes.h new file mode 100644 index 0000000..9837769 --- /dev/null +++ b/qmk/keyboards/sofle_choc/keymaps/custom/keycodes.h @@ -0,0 +1,28 @@ +#pragma once + +enum { + // Custom key for defining the tapdance allowing to transform C into Ç + TD_C_CCED, + // Transform the key W into SHIFT or CAPSLOCK + TD_W_CAPSLOCK, + // Transform the key E into È + TD_E_EE, + TD_PRC, + TD_LAYER_SYMB, + TD_LSFT, +}; + +#define _BASE 0 +#define LAYER_SYMBOLS 1 + +#define MENU LGUI(BP_I) +#define KEY_C TD(TD_C_CCED) +#define KEY_W TD(TD_W_CAPSLOCK) +#define KEY_PRC TD(TD_PRC) +#define LT_SFT TD(TD_LSFT) +#define AL_ENT MT(MOD_RALT, KC_ENT) +#define AL_SPC MT(MOD_LALT, KC_SPC) +#define KEY_E TD(TD_E_EE) +#define KEY_T MT(MOD_RCTL, BP_T) +#define KEY_INS MT(MOD_RGUI, KC_INS) + diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/keymap.c b/qmk/keyboards/sofle_choc/keymaps/custom/keymap.c new file mode 100644 index 0000000..fb1ba89 --- /dev/null +++ b/qmk/keyboards/sofle_choc/keymaps/custom/keymap.c @@ -0,0 +1,68 @@ +/* Copyright 2023 Brian Low + * + * 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 +#include "keymap_bepo.h" +#include "keycodes.h" + + +#define LY_SYMBOL TD(TD_LAYER_SYMB) + + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { +/* + * BÉPO + * ,-----------------------------------------. ,-----------------------------------------. + * | ` | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | ° | + * |------+------+------+------+------+------| |------+------+------+------+------+------| + * | ESC | B | É | P | O | È | | ! | V | D | L | J | Z | + * |------+------+------+------+------+------| |------+------+------+------+------+------| + * | Tab | A | U | I | EÈ | ; |-------. ,-------| CÇ | T | S | R | N | M | + * |------+------+------+------+------+------| Mute | | Pause |------+------+------+------+------+------| + * |LShift| À | Y | X | : | K |-------| |-------| ? | Q | G | H | F | W | + * `-----------------------------------------/ / \ \-----------------------------------------' + * | LCTL | LGUI | LCMD | Layer| / Space / \Enter \ | Layer| RCMD | RGUI | RCTL | + * | | | | dwn |/ LALT / \ RALT \ | up | | | | + * `-----------------------------------' '------''---------------------------' + */ + +[_BASE] = LAYOUT( + KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KEY_PRC, + BP_DLR, BP_B, BP_EACU, BP_P, BP_O, KC_BSPC, BP_DCIR, BP_V, BP_D, BP_L, BP_J, BP_Z, + KC_TAB, BP_A, BP_U, BP_I, KEY_E, BP_COMM, KEY_C, KEY_T, BP_S, BP_R, BP_N, BP_M, + LT_SFT, BP_AGRV,BP_Y, BP_X, BP_DOT, KC_B, KC_MUTE, KC_MPLY,BP_QUOT, BP_Q, BP_G, BP_H, BP_F, KEY_W, + KC_LCTL, KC_LGUI, KC_BSPC, LY_SYMBOL,AL_SPC, AL_ENT, LY_SYMBOL,MENU, KEY_INS, KC_RCTL +), + +// In the number layout, I keep the mod-tap modifiers applies to the middle letters : +// +#define KEY_5 MT(MOD_LCTL, KC_P5) +#define KEY_DOWN MT(MOD_RCTL, KC_DOWN) + +[LAYER_SYMBOLS] = LAYOUT( + KC_ESC, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, + KC_NO, KC_NO, KC_NO, KC_P7, KC_P8, KC_P9, KC_HOME, KC_UP, KC_END, KC_NO, KC_NO, S(BP_EQL), + KC_TAB, KC_NO, KC_NO, KC_P4, KEY_5, KC_P6, KC_LEFT, KEY_DOWN, KC_RIGHT,KC_NO, KC_NO, KC_NO, + LT_SFT, KC_NO, KC_P0, KC_P1, KC_P2, KC_P3, KC_MUTE, KC_MPLY,KC_PGUP, KC_NO, KC_PGDN, KC_NO, KC_NO, KC_RIGHT_SHIFT, + KC_LCTL, KC_LGUI, KC_BSPC, LY_SYMBOL,AL_SPC, AL_ENT, LY_SYMBOL,KC_NO, KC_RGUI, KC_RCTL +), +}; + +#if defined(ENCODER_MAP_ENABLE) +const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS] = { + [_BASE] = { ENCODER_CCW_CW(KC_VOLD, KC_VOLU), ENCODER_CCW_CW(KC_MS_WH_UP, KC_MS_WH_DOWN) }, + [LAYER_SYMBOLS] = { ENCODER_CCW_CW(KC_VOLD, KC_VOLU), ENCODER_CCW_CW(KC_MS_WH_UP, KC_MS_WH_DOWN) }, +}; +#endif diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.c b/qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.c new file mode 100644 index 0000000..9978315 --- /dev/null +++ b/qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.c @@ -0,0 +1,226 @@ +/* Return an integer that corresponds to what kind of tap dance should be executed. + * + * How to figure out tap dance state: interrupted and pressed. + * + * Interrupted: If the state of a dance is "interrupted", that means that another key has been hit + * under the tapping term. This is typically indicitive that you are trying to "tap" the key. + * + * Pressed: Whether or not the key is still being pressed. If this value is true, that means the tapping term + * has ended, but the key is still being pressed down. This generally means the key is being "held". + * + * One thing that is currenlty not possible with qmk software in regards to tap dance is to mimic the "permissive hold" + * feature. In general, advanced tap dances do not work well if they are used with commonly typed letters. + * For example "A". Tap dances are best used on non-letter keys that are not hit while typing letters. + * + * Good places to put an advanced tap dance: + * z,q,x,j,k,v,b, any function key, home/end, comma, semi-colon + * + * Criteria for "good placement" of a tap dance key: + * Not a key that is hit frequently in a sentence + * Not a key that is used frequently to double tap, for example 'tab' is often double tapped in a terminal, or + * in a web form. So 'tab' would be a poor choice for a tap dance. + * Letters used in common words as a double. For example 'p' in 'pepper'. If a tap dance function existed on the + * letter 'p', the word 'pepper' would be quite frustating to type. + * + * For the third point, there does exist the 'TD_DOUBLE_SINGLE_TAP', however this is not fully tested + * + */ + +#include QMK_KEYBOARD_H +#include "keymap_bepo.h" +#include "quad_tapdance.h" +#include "keycodes.h" + +td_state_t cur_dance(tap_dance_state_t *state) { + if (state->count == 1) { + if (!state->pressed) return TD_SINGLE_TAP; + // Key has not been interrupted, but the key is still held. Means you want to send a 'HOLD'. + else return TD_SINGLE_HOLD; + } else if (state->count == 2) { + // TD_DOUBLE_SINGLE_TAP is to distinguish between typing "pepper", and actually wanting a double tap + // action when hitting 'pp'. Suggested use case for this return value is when you want to send two + // keystrokes of the key, and not the 'double tap' action/macro. + if (state->interrupted) return TD_DOUBLE_SINGLE_TAP; + else if (state->pressed) return TD_DOUBLE_HOLD; + else return TD_DOUBLE_TAP; + } + + // Assumes no one is trying to type the same letter three times (at least not quickly). + // If your tap dance key is 'KC_W', and you want to type "www." quickly - then you will need to add + // an exception here to return a 'TD_TRIPLE_SINGLE_TAP', and define that enum just like 'TD_DOUBLE_SINGLE_TAP' + if (state->count == 3) { + if (state->interrupted || !state->pressed) return TD_TRIPLE_TAP; + else return TD_TRIPLE_HOLD; + } else return TD_UNKNOWN; +} + +// +// Definition for the key W. +// +// The main usage is to send the letter W when pressed, but the key is also +// used to activate the SHIFT mode when pressed. +// +// If the key is double tapped, it will also switch into the caps_word mode. +// + +static td_tap_t w_tap_state = { + .is_press_action = true, + .state = TD_NONE +}; + +void w_finished(tap_dance_state_t *state, void *user_data) { + w_tap_state.state = cur_dance(state); + switch (w_tap_state.state) { + case TD_SINGLE_TAP: register_code(BP_W); break; + case TD_SINGLE_HOLD: register_code(KC_RIGHT_SHIFT); break; + case TD_DOUBLE_TAP: caps_word_on(); break; + case TD_DOUBLE_SINGLE_TAP: tap_code(BP_W); register_code(BP_W); break; + default: break; + } +} + +void w_reset(tap_dance_state_t *state, void *user_data) { + switch (w_tap_state.state) { + case TD_SINGLE_TAP: unregister_code(BP_W); break; + case TD_SINGLE_HOLD: unregister_code(KC_RIGHT_SHIFT); break; + case TD_DOUBLE_SINGLE_TAP: unregister_code(BP_W); break; + default: break; + } + w_tap_state.state = TD_NONE; +} + +// +// Definition for the layer key +// +// The only one usage is to activate the layer over the keyboard, but there is +// two way of doing it: +// +// The first mode, when hold, is to activate the layer as long as the key is pressed. +// The second one is to switch in the layer mode when double tapped, in this +// mode, you can go back into the normal layer by a single press on the key. +// +static td_tap_t ql_tap_state = { + .is_press_action = true, + .state = TD_NONE +}; + +// Functions that control what our tap dance key does +void ql_finished(tap_dance_state_t *state, void *user_data) { + ql_tap_state.state = cur_dance(state); + switch (ql_tap_state.state) { + // Remove the layer with a single tap, this way I always have a key to remove the + // the layer, without knowing the previous state I had. + case TD_SINGLE_TAP: layer_off(LAYER_SYMBOLS); break; + case TD_SINGLE_HOLD: layer_on(LAYER_SYMBOLS); break; + case TD_DOUBLE_TAP: layer_invert(LAYER_SYMBOLS); break; + default: break; + } +} + +void ql_reset(tap_dance_state_t *state, void *user_data) { + // If the key was held down and now is released then switch off the layer + if (ql_tap_state.state == TD_SINGLE_HOLD) { + layer_off(LAYER_SYMBOLS); + } + ql_tap_state.state = TD_NONE; +} + +// +// Definiton for the key DEL. +// The main usage of the key is to activate the LShift when hold. But the key +// can also be used to send the DEL keycode. +// +// As I do not want to send the DEL keycode by mistake, I’ve configured the key +// to do it on double-tap. If you hold the key after a double tap, the DELETE +// code will be repeated again until the key is released. +// +// On a single press, the key will just remove the CAPSLOCK state if active. +// +static td_tap_t lshift_tap_state = { + .is_press_action = true, + .state = TD_NONE +}; + +// Functions that control what our tap dance key does +void lshift_finished(tap_dance_state_t *state, void *user_data) { + lshift_tap_state.state = cur_dance(state); + switch (lshift_tap_state.state) { + // Remove the layer with a single tap, this way I always have a key to remove the + // the layer, without knowing the previous state I had. + case TD_SINGLE_HOLD: register_code(KC_LEFT_SHIFT); break; + case TD_DOUBLE_TAP: + case TD_DOUBLE_HOLD: + register_code(KC_DELETE); break; + case TD_SINGLE_TAP: + if (host_keyboard_led_state().caps_lock) + register_code(KC_CAPS_LOCK); + break; + default: break; + } +} + +void lshift_reset(tap_dance_state_t *state, void *user_data) { + switch (lshift_tap_state.state) { + case TD_SINGLE_HOLD: unregister_code(KC_LEFT_SHIFT); break; + case TD_DOUBLE_TAP: + case TD_DOUBLE_HOLD: + unregister_code(KC_DELETE); break; + case TD_SINGLE_TAP: + if (host_keyboard_led_state().caps_lock) + unregister_code(KC_CAPS_LOCK); + break; + default: break; + } + lshift_tap_state.state = TD_NONE; +} + +// Definition for the key E +// This key can transform into LEFT CONTROL when hold, but can also transform into È when double tapped. +static td_tap_t e_tap_state = { + .is_press_action = true, + .state = TD_NONE +}; + +// Functions that control what our tap dance key does +void e_finished(tap_dance_state_t *state, void *user_data) { + e_tap_state.state = cur_dance(state); + switch (e_tap_state.state) { + // Remove the layer with a single tap, this way I always have a key to remove the + // the layer, without knowing the previous state I had. + case TD_SINGLE_HOLD: register_code(KC_LEFT_CTRL); break; + case TD_DOUBLE_TAP: + register_code(BP_EGRV); break; + case TD_SINGLE_TAP: + register_code(BP_E); break; + break; + default: break; + } +} + +void e_reset(tap_dance_state_t *state, void *user_data) { + switch (e_tap_state.state) { + case TD_SINGLE_HOLD: unregister_code(KC_LEFT_CTRL); break; + case TD_DOUBLE_TAP: + unregister_code(BP_EGRV); break; + case TD_SINGLE_TAP: + unregister_code(BP_E); break; + break; + default: break; + } + e_tap_state.state = TD_NONE; +} + + + +// +// Declare the tapdance table here. +// +tap_dance_action_t tap_dance_actions[] = { + [TD_C_CCED] = ACTION_TAP_DANCE_DOUBLE(BP_C, BP_CCED), + [TD_PRC] = ACTION_TAP_DANCE_DOUBLE(BP_EQL, BP_PERC), + [TD_W_CAPSLOCK] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, w_finished, w_reset), + [TD_LAYER_SYMB] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ql_finished, ql_reset), + [TD_LSFT] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, lshift_finished, lshift_reset), + [TD_E_EE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, e_finished, e_reset), +}; + diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.h b/qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.h new file mode 100644 index 0000000..87da433 --- /dev/null +++ b/qmk/keyboards/sofle_choc/keymaps/custom/quad_tapdance.h @@ -0,0 +1,30 @@ +#pragma once + +typedef enum { + TD_NONE, + TD_UNKNOWN, + TD_SINGLE_TAP, + TD_SINGLE_HOLD, + TD_DOUBLE_TAP, + TD_DOUBLE_HOLD, + TD_DOUBLE_SINGLE_TAP, // Send two single taps + TD_TRIPLE_TAP, + TD_TRIPLE_HOLD +} td_state_t; + +typedef struct { + bool is_press_action; + td_state_t state; +} td_tap_t; + +td_state_t cur_dance(tap_dance_state_t *state); + +// For the x tap dance. Put it here so it can be used in any keymap +void w_finished(tap_dance_state_t *state, void *user_data); +void w_reset(tap_dance_state_t *state, void *user_data); + +void ql_finished(tap_dance_state_t *state, void *user_data); +void ql_reset(tap_dance_state_t *state, void *user_data); + +void lshift_finished(tap_dance_state_t *state, void *user_data); +void lshift_reset(tap_dance_state_t *state, void *user_data); diff --git a/qmk/keyboards/sofle_choc/keymaps/custom/rules.mk b/qmk/keyboards/sofle_choc/keymaps/custom/rules.mk new file mode 100644 index 0000000..5edfedd --- /dev/null +++ b/qmk/keyboards/sofle_choc/keymaps/custom/rules.mk @@ -0,0 +1,6 @@ +ENCODER_MAP_ENABLE = yes +SPLIT_KEYBOARD = yes +TAP_DANCE_ENABLE = yes +CAPS_WORD_ENABLE = yes +KEY_OVERRIDE_ENABLE = yes +SRC += quad_tapdance.c keycodes.c |