summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--builddefs/generic_features.mk1
-rw-r--r--builddefs/show_options.mk1
-rw-r--r--docs/config_options.md2
-rw-r--r--docs/keycodes.md10
-rw-r--r--docs/tap_hold.md80
-rw-r--r--docs/understanding_qmk.md1
-rw-r--r--quantum/action_tapping.c8
-rw-r--r--quantum/action_tapping.h4
-rw-r--r--quantum/process_keycode/process_dynamic_tapping_term.c50
-rw-r--r--quantum/process_keycode/process_dynamic_tapping_term.h26
-rw-r--r--quantum/quantum.c3
-rw-r--r--quantum/quantum.h4
-rw-r--r--quantum/quantum_keycodes.h5
13 files changed, 191 insertions, 4 deletions
diff --git a/builddefs/generic_features.mk b/builddefs/generic_features.mk
index e41ce6ac91..e4151eb217 100644
--- a/builddefs/generic_features.mk
+++ b/builddefs/generic_features.mk
@@ -36,6 +36,7 @@ GENERIC_FEATURES = \
TAP_DANCE \
VELOCIKEY \
WPM \
+ DYNAMIC_TAPPING_TERM \
define HANDLE_GENERIC_FEATURE
# $$(info "Processing: $1_ENABLE $2.c")
diff --git a/builddefs/show_options.mk b/builddefs/show_options.mk
index ee60597e1c..2820332d56 100644
--- a/builddefs/show_options.mk
+++ b/builddefs/show_options.mk
@@ -39,6 +39,7 @@ OTHER_OPTION_NAMES = \
UNICODE_COMMON \
AUTO_SHIFT_ENABLE \
AUTO_SHIFT_MODIFIERS \
+ DYNAMIC_TAPPING_TERM_ENABLE \
COMBO_ENABLE \
KEY_LOCK_ENABLE \
KEY_OVERRIDE_ENABLE \
diff --git a/docs/config_options.md b/docs/config_options.md
index 9f2453b698..b661b55ee0 100644
--- a/docs/config_options.md
+++ b/docs/config_options.md
@@ -448,6 +448,8 @@ Use these to enable or disable building certain features. The more you have enab
* Disables usb suspend check after keyboard startup. Usually the keyboard waits for the host to wake it up before any tasks are performed. This is useful for split keyboards as one half will not get a wakeup call but must send commands to the master.
* `DEFERRED_EXEC_ENABLE`
* Enables deferred executor support -- timed delays before callbacks are invoked. See [deferred execution](custom_quantum_functions.md#deferred-execution) for more information.
+* `DYNAMIC_TAPPING_TERM_ENABLE`
+ * Allows to configure the global tapping term on the fly.
## USB Endpoint Limitations
diff --git a/docs/keycodes.md b/docs/keycodes.md
index 926d4fdcef..ba06e1b8b6 100644
--- a/docs/keycodes.md
+++ b/docs/keycodes.md
@@ -586,6 +586,16 @@ See also: [Mod-Tap](mod_tap.md)
|`MEH_T(kc)` | |Left Control, Shift and Alt when held, `kc` when tapped |
|`HYPR_T(kc)` |`ALL_T(kc)` |Left Control, Shift, Alt and GUI when held, `kc` when tapped - more info [here](https://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)|
+## Tapping Term Keys :id=tapping-term-keys
+
+See also: [Dynamic Tapping Term](tap_hold#dynamic-tapping-term)
+
+| Key | Description |
+|-------------|------------------------------------------------------------------------------------------------------------------------|
+| `DT_PRNT` | "Dynamic Tapping Term Print": Types the current tapping term, in milliseconds |
+| `DT_UP` | "Dynamic Tapping Term Up": Increases the current tapping term by `DYNAMIC_TAPPING_TERM_INCREMENT`ms (5ms by default) |
+| `DT_DOWN` | "Dynamic Tapping Term Down": Decreases the current tapping term by `DYNAMIC_TAPPING_TERM_INCREMENT`ms (5ms by default) |
+
## RGB Lighting :id=rgb-lighting
See also: [RGB Lighting](feature_rgblight.md)
diff --git a/docs/tap_hold.md b/docs/tap_hold.md
index a343d0bc3e..d206c10cc5 100644
--- a/docs/tap_hold.md
+++ b/docs/tap_hold.md
@@ -6,7 +6,9 @@ These options let you modify the behavior of the Tap-Hold keys.
## Tapping Term
-The crux of all of the following features is the tapping term setting. This determines what is a tap and what is a hold. And the exact timing for this to feel natural can vary from keyboard to keyboard, from switch to switch, and from key to key.
+The crux of all of the following features is the tapping term setting. This determines what is a tap and what is a hold. The exact timing for this to feel natural can vary from keyboard to keyboard, from switch to switch, and from key to key.
+
+?> `DYNAMIC_TAPPING_TERM_ENABLE` enables three special keys that can help you quickly find a comfortable tapping term for you. See "Dynamic Tapping Term" for more details.
You can set the global time for this by adding the following setting to your `config.h`:
@@ -36,6 +38,82 @@ uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
}
```
+### Dynamic Tapping Term :id=dynamic-tapping-term
+
+`DYNAMIC_TAPPING_TERM_ENABLE` is a feature you can enable in `rules.mk` that lets you use three special keys in your keymap to configure the tapping term on the fly.
+
+| Key | Description |
+|-------------|------------------------------------------------------------------------------------------------------------------------|
+| `DT_PRNT` | "Dynamic Tapping Term Print": Types the current tapping term, in milliseconds |
+| `DT_UP` | "Dynamic Tapping Term Up": Increases the current tapping term by `DYNAMIC_TAPPING_TERM_INCREMENT`ms (5ms by default) |
+| `DT_DOWN` | "Dynamic Tapping Term Down": Decreases the current tapping term by `DYNAMIC_TAPPING_TERM_INCREMENT`ms (5ms by default) |
+
+Set the tapping term as usual with `#define TAPPING_TERM <value>` in `config.h` and add `DYNAMIC_TAPPING_TERM_ENABLE = yes` in `rules.mk`. Then, place the above three keys somewhere in your keymap and flash the new firmware onto your board.
+
+Now, you can try using your dual-role keys, such as layer-taps and mod-taps, and use `DT_DOWN` and `DT_UP` to adjust the tapping term immediately. If you find that you frequently trigger the modifier of your mod-tap(s) by accident for example, that's a sign that your tapping term may be too low so tap `DT_UP` a few times to increase the tapping term until that no longer happens. On the flip side, if you get superfluous characters when you actually intended to momentarily activate a layer, tap `DT_DOWN` to lower the tapping term. Do note that these keys affect the *global* tapping term, you cannot change the tapping term of a specific key on the fly.
+
+Once you're satisfied with the current tapping term value, open `config.h` and replace whatever value you first wrote for the tapping term by the output of the `DT_PRNT` key.
+
+It's important to update `TAPPING_TERM` with the new value because the adjustments made using `DT_UP` and `DT_DOWN` are not persistent.
+
+The value by which the tapping term increases or decreases when you tap `DT_UP` and `DT_DOWN` can be configured in `config.h` with `#define DYNAMIC_TAPPING_TERM_INCREMENT <new value>`. Note that the tapping term is *not* modified when holding down the tap term keys so if you need to, for example, decrease the current tapping term by 50ms, you cannot just press down and hold `DT_DOWN`; you will have to tap it 10 times in a row with the default increment of 5ms.
+
+If you need more flexibility, nothing prevents you from defining your own custom keys to dynamically change the tapping term.
+
+```c
+enum custom_dynamic_tapping_term_keys = {
+ DT_UP_50 = SAFE_RANGE,
+ DT_DOWN_50,
+ DT_UP_X2,
+ DT_DOWN_X2,
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+ switch (keycode) {
+ case DT_UP_50:
+ if (record->event.pressed) {
+ g_tapping_term += 50;
+ }
+ break;
+ case DT_DOWN_50:
+ if (record->event.pressed) {
+ g_tapping_term -= 50;
+ }
+ break;
+ case DT_UP_X2:
+ if (record->event.pressed) {
+ g_tapping_term *= 2;
+ }
+ break;
+ case DT_DOWN_X2:
+ if (record->event.pressed) {
+ g_tapping_term /= 2;
+ }
+ break;
+ }
+ return true;
+};
+```
+
+In order for this feature to be effective if you use per-key tapping terms, you need to make a few changes to the syntax of the `get_tapping_term` function. All you need to do is replace every occurrence of `TAPPING_TERM` in the `get_tapping_term` function by lowercase `g_tapping_term`. If you don't do that, you will still see the value typed by `DT_PRNT` go up and down as you configure the tapping term on the fly but you won't feel those changes as they don't get applied. If you can go as low as 10ms and still easily trigger the tap function of a dual-role key, that's a sign that you forgot to make the necessary changes to your `get_tapping_term` function.
+
+For instance, here's how the example `get_tapping_term` shown earlier should look like after the transformation:
+
+```c
+uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
+ switch (keycode) {
+ case SFT_T(KC_SPC):
+ return g_tapping_term + 1250;
+ case LT(1, KC_GRV):
+ return 130;
+ default:
+ return g_tapping_term;
+ }
+}
+```
+
+The reason being that `TAPPING_TERM` is a macro that expands to a constant integer and thus cannot be changed at runtime whereas `g_tapping_term` is a variable whose value can be changed at runtime. If you want, you can temporarily enable `DYNAMIC_TAPPING_TERM_ENABLE` to find a suitable tapping term value and then disable that feature and revert back to using the classic syntax for per-key tapping term settings.
+
## Tap-Or-Hold Decision Modes
The code which decides between the tap and hold actions of dual-role keys supports three different modes, in increasing order of preference for the hold action:
diff --git a/docs/understanding_qmk.md b/docs/understanding_qmk.md
index e0c2ab7dc3..016e3d9fd2 100644
--- a/docs/understanding_qmk.md
+++ b/docs/understanding_qmk.md
@@ -157,6 +157,7 @@ The `process_record()` function itself is deceptively simple, but hidden within
* [`bool process_combo(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/e1203a222bb12ab9733916164a000ef3ac48da93/quantum/process_keycode/process_combo.c#L115)
* [`bool process_printer(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/e1203a222bb12ab9733916164a000ef3ac48da93/quantum/process_keycode/process_printer.c#L77)
* [`bool process_auto_shift(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/e1203a222bb12ab9733916164a000ef3ac48da93/quantum/process_keycode/process_auto_shift.c#L94)
+ * `bool process_dynamic_tapping_term(uint16_t keycode, keyrecord_t *record)`
* [`bool process_terminal(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/e1203a222bb12ab9733916164a000ef3ac48da93/quantum/process_keycode/process_terminal.c#L264)
* [Identify and process Quantum-specific keycodes](https://github.com/qmk/qmk_firmware/blob/e1203a222bb12ab9733916164a000ef3ac48da93/quantum/quantum.c#L291)
diff --git a/quantum/action_tapping.c b/quantum/action_tapping.c
index 0586fad421..b64d8b710b 100644
--- a/quantum/action_tapping.c
+++ b/quantum/action_tapping.c
@@ -24,12 +24,14 @@
# define IS_TAPPING_RECORD(r) (IS_TAPPING() && KEYEQ(tapping_key.event.key, (r->event.key)) && tapping_key.keycode == r->keycode)
# endif
-__attribute__((weak)) uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { return TAPPING_TERM; }
+uint16_t g_tapping_term = TAPPING_TERM;
+
+__attribute__((weak)) uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { return g_tapping_term; }
# ifdef TAPPING_TERM_PER_KEY
# define WITHIN_TAPPING_TERM(e) (TIMER_DIFF_16(e.time, tapping_key.event.time) < get_tapping_term(get_record_keycode(&tapping_key, false), &tapping_key))
# else
-# define WITHIN_TAPPING_TERM(e) (TIMER_DIFF_16(e.time, tapping_key.event.time) < TAPPING_TERM)
+# define WITHIN_TAPPING_TERM(e) (TIMER_DIFF_16(e.time, tapping_key.event.time) < g_tapping_term)
# endif
# ifdef TAPPING_FORCE_HOLD_PER_KEY
@@ -158,7 +160,7 @@ bool process_tapping(keyrecord_t *keyp) {
# ifdef TAPPING_TERM_PER_KEY
get_tapping_term(tapping_keycode, keyp)
# else
- TAPPING_TERM
+ g_tapping_term
# endif
>= 500
)
diff --git a/quantum/action_tapping.h b/quantum/action_tapping.h
index 7de8049c7f..b2feb6850c 100644
--- a/quantum/action_tapping.h
+++ b/quantum/action_tapping.h
@@ -33,10 +33,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
uint16_t get_record_keycode(keyrecord_t *record, bool update_layer_cache);
uint16_t get_event_keycode(keyevent_t event, bool update_layer_cache);
void action_tapping_process(keyrecord_t record);
+#endif
uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record);
bool get_permissive_hold(uint16_t keycode, keyrecord_t *record);
bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record);
bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record);
bool get_retro_tapping(uint16_t keycode, keyrecord_t *record);
+
+#ifdef DYNAMIC_TAPPING_TERM_ENABLE
+extern uint16_t g_tapping_term;
#endif
diff --git a/quantum/process_keycode/process_dynamic_tapping_term.c b/quantum/process_keycode/process_dynamic_tapping_term.c
new file mode 100644
index 0000000000..bdc5529e33
--- /dev/null
+++ b/quantum/process_keycode/process_dynamic_tapping_term.c
@@ -0,0 +1,50 @@
+/* Copyright 2020 Vladislav Kucheriavykh
+ *
+ * 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 "quantum.h"
+#include "process_dynamic_tapping_term.h"
+
+#ifndef DYNAMIC_TAPPING_TERM_INCREMENT
+# define DYNAMIC_TAPPING_TERM_INCREMENT 5
+#endif
+
+static void tapping_term_report(void) {
+ const char *tapping_term_str = get_u16_str(g_tapping_term, ' ');
+ // Skip padding spaces
+ while (*tapping_term_str == ' ') {
+ tapping_term_str++;
+ }
+ send_string(tapping_term_str);
+}
+
+bool process_dynamic_tapping_term(uint16_t keycode, keyrecord_t *record) {
+ if (record->event.pressed) {
+ switch (keycode) {
+ case DT_PRNT:
+ tapping_term_report();
+ return false;
+
+ case DT_UP:
+ g_tapping_term += DYNAMIC_TAPPING_TERM_INCREMENT;
+ return false;
+
+ case DT_DOWN:
+ g_tapping_term -= DYNAMIC_TAPPING_TERM_INCREMENT;
+ return false;
+ }
+ }
+ return true;
+}
diff --git a/quantum/process_keycode/process_dynamic_tapping_term.h b/quantum/process_keycode/process_dynamic_tapping_term.h
new file mode 100644
index 0000000000..85e83ee73b
--- /dev/null
+++ b/quantum/process_keycode/process_dynamic_tapping_term.h
@@ -0,0 +1,26 @@
+/* Copyright 2020 Vladislav Kucheriavykh
+ *
+ * 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
+
+#include <stdbool.h>
+#include "action.h"
+
+#ifndef DYNAMIC_TAPPING_TERM_INCREMENT
+# define DYNAMIC_TAPPING_TERM_INCREMENT 5
+#endif
+
+bool process_dynamic_tapping_term(uint16_t keycode, keyrecord_t *record);
diff --git a/quantum/quantum.c b/quantum/quantum.c
index ba3ae03457..35b6351e9d 100644
--- a/quantum/quantum.c
+++ b/quantum/quantum.c
@@ -275,6 +275,9 @@ bool process_record_quantum(keyrecord_t *record) {
#ifdef AUTO_SHIFT_ENABLE
process_auto_shift(keycode, record) &&
#endif
+#ifdef DYNAMIC_TAPPING_TERM_ENABLE
+ process_dynamic_tapping_term(keycode, record) &&
+#endif
#ifdef TERMINAL_ENABLE
process_terminal(keycode, record) &&
#endif
diff --git a/quantum/quantum.h b/quantum/quantum.h
index 45050ac0ea..6927884e2f 100644
--- a/quantum/quantum.h
+++ b/quantum/quantum.h
@@ -125,6 +125,10 @@ extern layer_state_t layer_state;
# include "process_auto_shift.h"
#endif
+#ifdef DYNAMIC_TAPPING_TERM_ENABLE
+# include "process_dynamic_tapping_term.h"
+#endif
+
#ifdef COMBO_ENABLE
# include "process_combo.h"
#endif
diff --git a/quantum/quantum_keycodes.h b/quantum/quantum_keycodes.h
index d013a6a169..e4d0167aac 100644
--- a/quantum/quantum_keycodes.h
+++ b/quantum/quantum_keycodes.h
@@ -524,6 +524,11 @@ enum quantum_keycodes {
// Additional magic key
MAGIC_TOGGLE_GUI,
+ // Adjust tapping term on the fly
+ DT_PRNT,
+ DT_UP,
+ DT_DOWN,
+
// Programmable Button
PROGRAMMABLE_BUTTON_1,
PROGRAMMABLE_BUTTON_2,