Jesse Vincent
41683449ec
|
7 years ago | |
---|---|---|
examples/TapDance | 8 years ago | |
src | 7 years ago | |
.gitignore | 8 years ago | |
.travis.yml | 8 years ago | |
COPYING | 8 years ago | |
Makefile | 8 years ago | |
README.md | 8 years ago | |
library.properties | 8 years ago |
README.md
Kaleidoscope-TapDance
Tap-dance keys are general purpose, multi-use keys, which trigger a different
action based on the number of times they were tapped in sequence. As an example
to make this clearer, one can have a key that inputs A
when tapped once,
inputs B
when tapped twice, and lights up the keyboard in Christmas colors
when tapped a third time.
This behaviour is most useful in cases where we have a number of things we perform rarely, where tapping a single key repeatedly is not counter-productive. Such cases include - for example - multimedia forward / backward keys: forward on single tap, backward on double. Of course, one could use modifiers to achieve a similar effect, but that's two keys to use, this is only one. We can also hide some destructive functionality behind a number of taps: reset the keyboard after 4 taps, and light up LEDs in increasingly frightful colors until then.
How does it work?
To not interfere with normal typing, tap-dance keys have two ways to decide when to call an action: they either get interrupted, or they time out. Every time a tap-dance key is pressed, the timer resets, so one does not have to finish the whole tapping sequence within a short time limit. The tap-dance counter continues incrementing until one of these cases happen.
When a tap-dance key is pressed and released, and nothing is pressed on the keyboard until the timeout is reached, then the key will time out, and trigger an action. Which action, depends on the number of times it has been tapped up until this point.
When a tap-dance key is pressed and released, and another key is hit before the timer expires, then the tap-dance key will trigger an action first, perform it, and only then will the firmware continue handling the interrupting key press. This is to preserve the order of keys pressed.
In both of these cases, the tapDanceAction
will be called, with
tapDanceIndex
set to the index of the tap-dance action (as set in the keymap),
the tapCount
, and tapDanceAction
set to either
kaleidoscope::TapDance::Interrupt
, or kaleidoscope::TapDance::Timeout
. If we
continue holding the key, then as long as it is held, the same function will be
called with tapDanceAction
set to kaleidoscope::TapDance::Hold
. When the key
is released, after either an Interrupt
or Timeout
action was triggered, the
function will be called with tapDanceAction
set to
kaleidoscope::TapDance::Release
.
These actions allow us to create sophisticated tap-dance setups, where one can tap a key twice and hold it, and have it repeat, for example.
There is one additional value the tapDanceAction
parameter can take:
kaleidoscope::TapDance::Tap
. It is called with this argument for each and
every tap, even if no action is to be triggered yet. This is so that we can have
a way to do some side-effects, like light up LEDs to show progress, and so on.
Using the plugin
To use the plugin, we need to include the header, and declare the behaviour
used. Then, we need to place tap-dance keys on the keymap. And finally, we need
to implement the tapDanceAction
function that gets called each
time an action is to be performed.
#include <Kaleidoscope.h>
#include <Kaleidoscope-TapDance.h>
// Somewhere in the keymap:
TD(0)
// later in the Sketch:
void tapDanceAction(uint8_t tap_dance_index, uint8_t tap_count,
kaleidoscope::TapDance::ActionType tap_dance_action) {
switch (tap_dance_index) {
case 0:
return tapDanceActionKeys(tap_count, tap_dance_action,
Consumer_ScanNextTrack, Consumer_ScanPreviousTrack);
}
}
void setup() {
USE_PLUGINS(&TapDance);
Kaleidoscope.setup ();
}
Keymap markup
TD(id)
A key that acts as a tap-dance key. The actions performed depend on the implementation for the
id
index within the [tapDanceActions
][tdactions] function.The
id
parameter here is what will be used astap_dance_index
in the handler function.
Plugin methods
The plugin provides a TapDance
object, but to implement the actions, we need
to define a function (tapDanceAction
) outside of the object. A
handler, of sorts. Nevertheless, the plugin provides one macro that is
particularly useful: tapDanceActionKeys
. Apart from that, it provides one
property only:
.time_out
The number of loop iterations to wait before a tap-dance sequence times out. Once the sequence timed out, the action for it will trigger, even without an interruptor. Defaults to 5, and the timer resets with every tap of the same
tapDanceActionKeys(tap_count, tap_dance_action, keys...)
Sets up an action where for each subsequent tap, a different key will be chosen from the list of keys supplied in the
keys...
argument.If we have
Key_A
andKey_B
in the list, then, if tapped once, this function will inputA
, but when tapped twice, will inputB
.When all our actions are just different keys, this is a very handy macro to use.
The
tap_count
andtap_dance_actions
parameters should be the same as the similarly named parameters of thetapDanceAction
function.
tapDanceAction(tap_dance_index, row, col, tap_count, tap_dance_action)
The heart of the tap-dance plugin is the handler method. This is called every time any kind of tap-dance action is to be performed. See the How does it work? section for details about when and how this function is called.
The
tap_dance_index
andtap_count
parameters help us choose which action to perform. Therow
andcol
parameters tell us where the tap-dance key is on the keyboard.
Dependencies
Further reading
Starting from the example is the recommended way of getting started with the plugin.