zephyr
/
zmk
mirror of https://github.com/zmkfirmware/zmk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor(combos): Reduce RAM usage, simplify config (#2849) 

* Reference combos by index, not 32-bit pointers, and store bitfields
instead of arrays in several places, to bring down our flash/RAM usage.
* Use bit field to track candidate combos, to avoid needing an explicit
`ZMK_COMBO_MAX_COMBOS_PER_KEY` setting.
* Determine the max keys per combo automatically from the devicetree,
so we remove the ZMK_COMBO_MAX_KEYS_PER_COMBO Kconfig symbol.
This commit is contained in:
Pete Johanson 2025-04-20 03:01:22 -06:00 committed by GitHub
parent d9576c5534
commit c4ee8ab86b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 196 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
app/Kconfig
View File

@ -444,12 +444,16 @@ config ZMK_COMBO_MAX_PRESSED_COMBOS
default 4 default 4
config ZMK_COMBO_MAX_COMBOS_PER_KEY config ZMK_COMBO_MAX_COMBOS_PER_KEY
int "Maximum number of combos per key" int
default 5 default 0
help
Deprecated: Storage for combos is now determined automatically
config ZMK_COMBO_MAX_KEYS_PER_COMBO config ZMK_COMBO_MAX_KEYS_PER_COMBO
int "Maximum number of keys per combo" int
default 4 default 0
help
Deprecated: This is now auto-calculated based on `key-positions` in devicetree
# Combo options # Combo options
endmenu endmenu

1
app/dts/bindings/zmk,combos.yaml
View File

@ -25,4 +25,3 @@ child-binding:
type: boolean type: boolean
layers: layers:
type: array type: array
default: [-1]

380
app/src/combo.c
View File

@ -9,6 +9,7 @@
#include <zephyr/device.h> #include <zephyr/device.h>
#include <zephyr/logging/log.h> #include <zephyr/logging/log.h>
#include <zephyr/sys/dlist.h> #include <zephyr/sys/dlist.h>
#include <zephyr/sys/util.h>
#include <zephyr/kernel.h> #include <zephyr/kernel.h>
#include <drivers/behavior.h> #include <drivers/behavior.h>
@ -26,53 +27,99 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
#if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT) #if DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT)
#if CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO > 0
#warning \
"CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO is deprecated, and is auto-calculated from the devicetree now."
#endif
#if CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY > 0
#warning "CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY is deprecated, and is auto-calculated."
#endif
#define COMBOS_KEYS_BYTE_ARRAY(node_id) \
uint8_t _CONCAT(combo_prop_, node_id)[DT_PROP_LEN(node_id, key_positions)];
#define MAX_COMBO_KEYS sizeof(union {DT_INST_FOREACH_CHILD(0, COMBOS_KEYS_BYTE_ARRAY)})
struct combo_cfg { struct combo_cfg {
int32_t key_positions[CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO]; int32_t key_positions[MAX_COMBO_KEYS];
int32_t key_position_len; int16_t key_position_len;
struct zmk_behavior_binding behavior; int16_t require_prior_idle_ms;
int32_t timeout_ms; int32_t timeout_ms;
int32_t require_prior_idle_ms; uint32_t layer_mask;
struct zmk_behavior_binding behavior;
// if slow release is set, the combo releases when the last key is released. // if slow release is set, the combo releases when the last key is released.
// otherwise, the combo releases when the first key is released. // otherwise, the combo releases when the first key is released.
bool slow_release; bool slow_release;
// the virtual key position is a key position outside the range used by the keyboard.
// it is necessary so hold-taps can uniquely identify a behavior.
int32_t virtual_key_position;
int32_t layers_len;
int8_t layers[];
}; };
struct active_combo { struct active_combo {
const struct combo_cfg *combo; uint16_t combo_idx;
// key_positions_pressed is filled with key_positions when the combo is pressed. // key_positions_pressed is filled with key_positions when the combo is pressed.
// The keys are removed from this array when they are released. // The keys are removed from this array when they are released.
// Once this array is empty, the behavior is released. // Once this array is empty, the behavior is released.
uint32_t key_positions_pressed_count; uint16_t key_positions_pressed_count;
struct zmk_position_state_changed_event struct zmk_position_state_changed_event key_positions_pressed[MAX_COMBO_KEYS];
key_positions_pressed[CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO];
}; };
struct combo_candidate { #define PROP_BIT_AT_IDX(n, prop, idx) BIT(DT_PROP_BY_IDX(n, prop, idx))
const struct combo_cfg *combo;
// the time after which this behavior should be removed from candidates.
// by keeping track of when the candidate should be cleared there is no
// possibility of accidental releases.
int64_t timeout_at;
};
uint32_t pressed_keys_count = 0; #define NODE_PROP_BITMASK(n, prop) \
COND_CODE_1(DT_NODE_HAS_PROP(n, prop), \
(DT_FOREACH_PROP_ELEM_SEP(n, prop, PROP_BIT_AT_IDX, (|))), (0))
#define GET_KEY_POSITION_MASK_PORTION(idx, n) ((NODE_PROP_BITMASK(n, key_positions) >> idx) & 0xFF)
#define COMBO_INST(n, positions) \
COND_CODE_1(IS_EQ(DT_PROP_LEN(n, key_positions), positions), \
( \
{ \
.timeout_ms = DT_PROP(n, timeout_ms), \
.require_prior_idle_ms = DT_PROP(n, require_prior_idle_ms), \
.key_positions = DT_PROP(n, key_positions), \
.key_position_len = DT_PROP_LEN(n, key_positions), \
.behavior = ZMK_KEYMAP_EXTRACT_BINDING(0, n), \
.slow_release = DT_PROP(n, slow_release), \
.layer_mask = NODE_PROP_BITMASK(n, layers), \
}, ), \
())
#define COMBO_CONFIGS_WITH_MATCHING_POSITIONS_LEN(positions, _ignore) \
DT_INST_FOREACH_CHILD_VARGS(0, COMBO_INST, positions)
// We do some magic here to generate the `combos` array by "key position length", looping
// by key position length and on each iteration, only include entries where the `key-positions`
// length matches.
// Doing so allows our bitmasks to be "shorted key positions list first" when searching for matches.
// `20` is chosen as a reasonable limit, since the theoretical maximum number of keys you might
// reasonably press simultaneously with 10 fingers is 20 keys, two keys per finger.
static const struct combo_cfg combos[] = {
LISTIFY(20, COMBO_CONFIGS_WITH_MATCHING_POSITIONS_LEN, (), 0)};
#define COMBO_ONE(n) +1
#define COMBO_CHILDREN_COUNT (0 DT_INST_FOREACH_CHILD(0, COMBO_ONE))
// We need at least 4 bytes to avoid alignment issues
#define BYTES_FOR_COMBOS_MASK DIV_ROUND_UP(COMBO_CHILDREN_COUNT, 32)
uint8_t pressed_keys_count = 0;
// set of keys pressed // set of keys pressed
struct zmk_position_state_changed_event pressed_keys[CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO] = {}; struct zmk_position_state_changed_event pressed_keys[MAX_COMBO_KEYS] = {};
// the set of candidate combos based on the currently pressed_keys // the set of candidate combos based on the currently pressed_keys
struct combo_candidate candidates[CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY]; uint32_t candidates[BYTES_FOR_COMBOS_MASK];
// the last candidate that was completely pressed // the last candidate that was completely pressed
const struct combo_cfg *fully_pressed_combo = NULL; int16_t fully_pressed_combo = INT16_MAX;
// a lookup dict that maps a key position to all combos on that position // a lookup dict that maps a key position to all combos on that position
const struct combo_cfg *combo_lookup[ZMK_KEYMAP_LEN][CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY] = {NULL}; uint32_t combo_lookup[ZMK_KEYMAP_LEN][BYTES_FOR_COMBOS_MASK] = {};
// combos that have been activated and still have (some) keys pressed // combos that have been activated and still have (some) keys pressed
// this array is always contiguous from 0. // this array is always contiguous from 0.
struct active_combo active_combos[CONFIG_ZMK_COMBO_MAX_PRESSED_COMBOS] = {NULL}; struct active_combo active_combos[CONFIG_ZMK_COMBO_MAX_PRESSED_COMBOS] = {};
int active_combo_count = 0; uint8_t active_combo_count = 0;
struct k_work_delayable timeout_task; struct k_work_delayable timeout_task;
int64_t timeout_task_timeout_at; int64_t timeout_task_timeout_at;
@ -90,52 +137,22 @@ static void store_last_tapped(int64_t timestamp) {
// Store the combo key pointer in the combos array, one pointer for each key position // Store the combo key pointer in the combos array, one pointer for each key position
// The combos are sorted shortest-first, then by virtual-key-position. // The combos are sorted shortest-first, then by virtual-key-position.
static int initialize_combo(const struct combo_cfg *new_combo) { static int initialize_combo(size_t index) {
for (int i = 0; i < new_combo->key_position_len; i++) { const struct combo_cfg *new_combo = &combos[index];
int32_t position = new_combo->key_positions[i];
if (position >= ZMK_KEYMAP_LEN) {
LOG_ERR("Unable to initialize combo, key position %d does not exist", position);
return -EINVAL;
}
const struct combo_cfg *insert_combo = new_combo; for (size_t kp = 0; kp < new_combo->key_position_len; kp++) {
bool set = false; sys_bitfield_set_bit((mem_addr_t)&combo_lookup[new_combo->key_positions[kp]], index);
for (int j = 0; j < CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY; j++) {
const struct combo_cfg *combo_at_j = combo_lookup[position][j];
if (combo_at_j == NULL) {
combo_lookup[position][j] = insert_combo;
set = true;
break;
}
if (combo_at_j->key_position_len < insert_combo->key_position_len ||
(combo_at_j->key_position_len == insert_combo->key_position_len &&
combo_at_j->virtual_key_position < insert_combo->virtual_key_position)) {
continue;
}
// put insert_combo in this spot, move all other combos up.
combo_lookup[position][j] = insert_combo;
insert_combo = combo_at_j;
}
if (!set) {
LOG_ERR("Too many combos for key position %d, CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY %d.",
position, CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY);
return -ENOMEM;
}
} }
return 0; return 0;
} }
static bool combo_active_on_layer(const struct combo_cfg *combo, uint8_t layer) { static bool combo_active_on_layer(const struct combo_cfg *combo, uint8_t layer) {
if (combo->layers[0] == -1) { if (!combo->layer_mask) {
// -1 in the first layer position is global layer scope
return true; return true;
} }
for (int j = 0; j < combo->layers_len; j++) {
if (combo->layers[j] == layer) { return combo->layer_mask & BIT(layer);
return true;
}
}
return false;
} }
static bool is_quick_tap(const struct combo_cfg *combo, int64_t timestamp) { static bool is_quick_tap(const struct combo_cfg *combo, int64_t timestamp) {
@ -145,66 +162,58 @@ static bool is_quick_tap(const struct combo_cfg *combo, int64_t timestamp) {
static int setup_candidates_for_first_keypress(int32_t position, int64_t timestamp) { static int setup_candidates_for_first_keypress(int32_t position, int64_t timestamp) {
int number_of_combo_candidates = 0; int number_of_combo_candidates = 0;
uint8_t highest_active_layer = zmk_keymap_highest_layer_active(); uint8_t highest_active_layer = zmk_keymap_highest_layer_active();
for (int i = 0; i < CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY; i++) {
const struct combo_cfg *combo = combo_lookup[position][i]; for (size_t i = 0; i < ARRAY_SIZE(combos); i++) {
if (combo == NULL) { if (sys_bitfield_test_bit((mem_addr_t)&combo_lookup[position], i)) {
return number_of_combo_candidates; const struct combo_cfg *combo = &combos[i];
if (combo_active_on_layer(combo, highest_active_layer) &&
!is_quick_tap(combo, timestamp)) {
sys_bitfield_set_bit((mem_addr_t)&candidates, i);
number_of_combo_candidates++;
}
// LOG_DBG("combo timeout %d %d %d", position, i, candidates[i].timeout_at);
} }
if (combo_active_on_layer(combo, highest_active_layer) && !is_quick_tap(combo, timestamp)) {
candidates[number_of_combo_candidates].combo = combo;
candidates[number_of_combo_candidates].timeout_at = timestamp + combo->timeout_ms;
number_of_combo_candidates++;
}
// LOG_DBG("combo timeout %d %d %d", position, i, candidates[i].timeout_at);
} }
return number_of_combo_candidates; return number_of_combo_candidates;
} }
static inline uint8_t zero_one_or_more_bits(uint32_t field) {
if (field == 0) {
return 0;
}
if ((field & (field - 1)) == 0) {
return 1;
}
return 2;
}
static int filter_candidates(int32_t position) { static int filter_candidates(int32_t position) {
// this code iterates over candidates and the lookup together to filter in O(n) int matches = 0;
// assuming they are both sorted on key_position_len, virtual_key_position for (int i = 0; i < BYTES_FOR_COMBOS_MASK; i++) {
int matches = 0, lookup_idx = 0, candidate_idx = 0; candidates[i] &= combo_lookup[position][i];
while (lookup_idx < CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY && if (matches < 2) {
candidate_idx < CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY) { matches += zero_one_or_more_bits(candidates[i]);
const struct combo_cfg *candidate = candidates[candidate_idx].combo;
const struct combo_cfg *lookup = combo_lookup[position][lookup_idx];
if (candidate == NULL || lookup == NULL) {
break;
}
if (candidate->virtual_key_position == lookup->virtual_key_position) {
candidates[matches] = candidates[candidate_idx];
matches++;
candidate_idx++;
lookup_idx++;
} else if (candidate->key_position_len > lookup->key_position_len) {
lookup_idx++;
} else if (candidate->key_position_len < lookup->key_position_len) {
candidate_idx++;
} else if (candidate->virtual_key_position > lookup->virtual_key_position) {
lookup_idx++;
} else if (candidate->virtual_key_position < lookup->virtual_key_position) {
candidate_idx++;
} }
} }
// clear unmatched candidates
for (int i = matches; i < CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY; i++) { LOG_DBG("combo matches after filter %d", matches);
candidates[i].combo = NULL;
}
// LOG_DBG("combo matches after filter %d", matches);
return matches; return matches;
} }
static int64_t first_candidate_timeout() { static int64_t first_candidate_timeout() {
if (pressed_keys_count == 0) {
return LONG_MAX;
}
int64_t first_timeout = LONG_MAX; int64_t first_timeout = LONG_MAX;
for (int i = 0; i < CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY; i++) { for (int i = 0; i < ARRAY_SIZE(combos); i++) {
if (candidates[i].combo == NULL) { if (sys_bitfield_test_bit((mem_addr_t)&candidates, i)) {
break; first_timeout = MIN(first_timeout, combos[i].timeout_ms);
}
if (candidates[i].timeout_at < first_timeout) {
first_timeout = candidates[i].timeout_at;
} }
} }
return first_timeout;
return pressed_keys[0].data.timestamp + first_timeout;
} }
static inline bool candidate_is_completely_pressed(const struct combo_cfg *candidate) { static inline bool candidate_is_completely_pressed(const struct combo_cfg *candidate) {
@ -219,26 +228,17 @@ static inline bool candidate_is_completely_pressed(const struct combo_cfg *candi
static int cleanup(); static int cleanup();
static int filter_timed_out_candidates(int64_t timestamp) { static int filter_timed_out_candidates(int64_t timestamp) {
int remaining_candidates = 0; __ASSERT(pressed_keys_count > 0, "Searching for a candidate timeout with no keys pressed");
for (int i = 0; i < CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY; i++) {
struct combo_candidate *candidate = &candidates[i];
if (candidate->combo == NULL) {
break;
}
if (candidate->timeout_at > timestamp) {
bool need_to_bubble_up = remaining_candidates != i;
if (need_to_bubble_up) {
// bubble up => reorder candidates so they're contiguous
candidates[remaining_candidates].combo = candidate->combo;
candidates[remaining_candidates].timeout_at = candidate->timeout_at;
// clear the previous location
candidates[i].combo = NULL;
candidates[i].timeout_at = 0;
}
remaining_candidates++; int remaining_candidates = 0;
} else { for (int i = 0; i < ARRAY_SIZE(combos); i++) {
candidate->combo = NULL; if (sys_bitfield_test_bit((mem_addr_t)&candidates, i)) {
if (pressed_keys[0].data.timestamp + combos[i].timeout_ms > timestamp) {
remaining_candidates++;
} else {
sys_bitfield_clear_bit((mem_addr_t)&candidates, i);
}
} }
} }
@ -249,18 +249,8 @@ static int filter_timed_out_candidates(int64_t timestamp) {
return remaining_candidates; return remaining_candidates;
} }
static int clear_candidates() {
for (int i = 0; i < CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY; i++) {
if (candidates[i].combo == NULL) {
return i;
}
candidates[i].combo = NULL;
}
return CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY;
}
static int capture_pressed_key(const struct zmk_position_state_changed *ev) { static int capture_pressed_key(const struct zmk_position_state_changed *ev) {
if (pressed_keys_count == CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY) { if (pressed_keys_count == MAX_COMBO_KEYS) {
return ZMK_EV_EVENT_BUBBLE; return ZMK_EV_EVENT_BUBBLE;
} }
@ -271,7 +261,7 @@ static int capture_pressed_key(const struct zmk_position_state_changed *ev) {
const struct zmk_listener zmk_listener_combo; const struct zmk_listener zmk_listener_combo;
static int release_pressed_keys() { static int release_pressed_keys() {
uint32_t count = pressed_keys_count; uint8_t count = pressed_keys_count;
pressed_keys_count = 0; pressed_keys_count = 0;
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
struct zmk_position_state_changed_event *ev = &pressed_keys[i]; struct zmk_position_state_changed_event *ev = &pressed_keys[i];
@ -288,9 +278,10 @@ static int release_pressed_keys() {
return count; return count;
} }
static inline int press_combo_behavior(const struct combo_cfg *combo, int32_t timestamp) { static inline int press_combo_behavior(int combo_idx, const struct combo_cfg *combo,
int32_t timestamp) {
struct zmk_behavior_binding_event event = { struct zmk_behavior_binding_event event = {
.position = combo->virtual_key_position, .position = ZMK_VIRTUAL_KEY_POSITION_COMBO(combo_idx),
.timestamp = timestamp, .timestamp = timestamp,
#if IS_ENABLED(CONFIG_ZMK_SPLIT) #if IS_ENABLED(CONFIG_ZMK_SPLIT)
.source = ZMK_POSITION_STATE_CHANGE_SOURCE_LOCAL, .source = ZMK_POSITION_STATE_CHANGE_SOURCE_LOCAL,
@ -302,9 +293,10 @@ static inline int press_combo_behavior(const struct combo_cfg *combo, int32_t ti
return zmk_behavior_invoke_binding(&combo->behavior, event, true); return zmk_behavior_invoke_binding(&combo->behavior, event, true);
} }
static inline int release_combo_behavior(const struct combo_cfg *combo, int32_t timestamp) { static inline int release_combo_behavior(int combo_idx, const struct combo_cfg *combo,
int32_t timestamp) {
struct zmk_behavior_binding_event event = { struct zmk_behavior_binding_event event = {
.position = combo->virtual_key_position, .position = ZMK_VIRTUAL_KEY_POSITION_COMBO(combo_idx),
.timestamp = timestamp, .timestamp = timestamp,
#if IS_ENABLED(CONFIG_ZMK_SPLIT) #if IS_ENABLED(CONFIG_ZMK_SPLIT)
.source = ZMK_POSITION_STATE_CHANGE_SOURCE_LOCAL, .source = ZMK_POSITION_STATE_CHANGE_SOURCE_LOCAL,
@ -316,7 +308,7 @@ static inline int release_combo_behavior(const struct combo_cfg *combo, int32_t
static void move_pressed_keys_to_active_combo(struct active_combo *active_combo) { static void move_pressed_keys_to_active_combo(struct active_combo *active_combo) {
int combo_length = MIN(pressed_keys_count, active_combo->combo->key_position_len); int combo_length = MIN(pressed_keys_count, combos[active_combo->combo_idx].key_position_len);
for (int i = 0; i < combo_length; i++) { for (int i = 0; i < combo_length; i++) {
active_combo->key_positions_pressed[i] = pressed_keys[i]; active_combo->key_positions_pressed[i] = pressed_keys[i];
} }
@ -330,10 +322,10 @@ static void move_pressed_keys_to_active_combo(struct active_combo *active_combo)
pressed_keys_count -= combo_length; pressed_keys_count -= combo_length;
} }
static struct active_combo *store_active_combo(const struct combo_cfg *combo) { static struct active_combo *store_active_combo(int32_t combo_idx) {
for (int i = 0; i < CONFIG_ZMK_COMBO_MAX_PRESSED_COMBOS; i++) { for (int i = 0; i < CONFIG_ZMK_COMBO_MAX_PRESSED_COMBOS; i++) {
if (active_combos[i].combo == NULL) { if (active_combos[i].combo_idx == UINT16_MAX) {
active_combos[i].combo = combo; active_combos[i].combo_idx = combo_idx;
active_combo_count++; active_combo_count++;
return &active_combos[i]; return &active_combos[i];
} }
@ -344,15 +336,16 @@ static struct active_combo *store_active_combo(const struct combo_cfg *combo) {
return NULL; return NULL;
} }
static void activate_combo(const struct combo_cfg *combo) { static void activate_combo(int combo_idx) {
struct active_combo *active_combo = store_active_combo(combo); struct active_combo *active_combo = store_active_combo(combo_idx);
if (active_combo == NULL) { if (active_combo == NULL) {
// unable to store combo // unable to store combo
release_pressed_keys(); release_pressed_keys();
return; return;
} }
move_pressed_keys_to_active_combo(active_combo); move_pressed_keys_to_active_combo(active_combo);
press_combo_behavior(combo, active_combo->key_positions_pressed[0].data.timestamp); press_combo_behavior(combo_idx, &combos[combo_idx],
active_combo->key_positions_pressed[0].data.timestamp);
} }
static void deactivate_combo(int active_combo_index) { static void deactivate_combo(int active_combo_index) {
@ -361,8 +354,8 @@ static void deactivate_combo(int active_combo_index) {
memcpy(&active_combos[active_combo_index], &active_combos[active_combo_count], memcpy(&active_combos[active_combo_index], &active_combos[active_combo_count],
sizeof(struct active_combo)); sizeof(struct active_combo));
} }
active_combos[active_combo_count].combo = NULL;
active_combos[active_combo_count] = (struct active_combo){0}; active_combos[active_combo_count] = (struct active_combo){0};
active_combos[active_combo_count].combo_idx = UINT16_MAX;
} }
/* returns true if a key was released. */ /* returns true if a key was released. */
@ -371,8 +364,8 @@ static bool release_combo_key(int32_t position, int64_t timestamp) {
struct active_combo *active_combo = &active_combos[combo_idx]; struct active_combo *active_combo = &active_combos[combo_idx];
bool key_released = false; bool key_released = false;
bool all_keys_pressed = bool all_keys_pressed = active_combo->key_positions_pressed_count ==
active_combo->key_positions_pressed_count == active_combo->combo->key_position_len; combos[active_combo->combo_idx].key_position_len;
bool all_keys_released = true; bool all_keys_released = true;
for (int i = 0; i < active_combo->key_positions_pressed_count; i++) { for (int i = 0; i < active_combo->key_positions_pressed_count; i++) {
if (key_released) { if (key_released) {
@ -387,9 +380,9 @@ static bool release_combo_key(int32_t position, int64_t timestamp) {
if (key_released) { if (key_released) {
active_combo->key_positions_pressed_count--; active_combo->key_positions_pressed_count--;
if ((active_combo->combo->slow_release && all_keys_released) || const struct combo_cfg *c = &combos[active_combo->combo_idx];
(!active_combo->combo->slow_release && all_keys_pressed)) { if ((c->slow_release && all_keys_released) || (!c->slow_release && all_keys_pressed)) {
release_combo_behavior(active_combo->combo, timestamp); release_combo_behavior(active_combo->combo_idx, c, timestamp);
} }
if (all_keys_released) { if (all_keys_released) {
deactivate_combo(combo_idx); deactivate_combo(combo_idx);
@ -402,10 +395,10 @@ static bool release_combo_key(int32_t position, int64_t timestamp) {
static int cleanup() { static int cleanup() {
k_work_cancel_delayable(&timeout_task); k_work_cancel_delayable(&timeout_task);
clear_candidates(); memset(candidates, 0, BYTES_FOR_COMBOS_MASK);
if (fully_pressed_combo != NULL) { if (fully_pressed_combo != INT16_MAX) {
activate_combo(fully_pressed_combo); activate_combo(fully_pressed_combo);
fully_pressed_combo = NULL; fully_pressed_combo = INT16_MAX;
} }
return release_pressed_keys(); return release_pressed_keys();
} }
@ -427,7 +420,7 @@ static void update_timeout_task() {
static int position_state_down(const zmk_event_t *ev, struct zmk_position_state_changed *data) { static int position_state_down(const zmk_event_t *ev, struct zmk_position_state_changed *data) {
int num_candidates; int num_candidates;
if (candidates[0].combo == NULL) { if (!pressed_keys_count) {
num_candidates = setup_candidates_for_first_keypress(data->position, data->timestamp); num_candidates = setup_candidates_for_first_keypress(data->position, data->timestamp);
if (num_candidates == 0) { if (num_candidates == 0) {
return ZMK_EV_EVENT_BUBBLE; return ZMK_EV_EVENT_BUBBLE;
@ -436,27 +429,31 @@ static int position_state_down(const zmk_event_t *ev, struct zmk_position_state_
filter_timed_out_candidates(data->timestamp); filter_timed_out_candidates(data->timestamp);
num_candidates = filter_candidates(data->position); num_candidates = filter_candidates(data->position);
} }
update_timeout_task();
const struct combo_cfg *candidate_combo = candidates[0].combo;
LOG_DBG("combo: capturing position event %d", data->position); LOG_DBG("combo: capturing position event %d", data->position);
int ret = capture_pressed_key(data); int ret = capture_pressed_key(data);
switch (num_candidates) { update_timeout_task();
case 0:
if (num_candidates) {
for (int i = 0; i < ARRAY_SIZE(combos); i++) {
if (sys_bitfield_test_bit((mem_addr_t)&candidates, i)) {
const struct combo_cfg *candidate_combo = &combos[i];
if (candidate_is_completely_pressed(candidate_combo)) {
fully_pressed_combo = i;
if (num_candidates == 1) {
cleanup();
}
}
return ret;
}
}
} else {
cleanup(); cleanup();
return ret; return ret;
case 1:
if (candidate_is_completely_pressed(candidate_combo)) {
fully_pressed_combo = candidate_combo;
cleanup();
}
return ret;
default:
if (candidate_is_completely_pressed(candidate_combo)) {
fully_pressed_combo = candidate_combo;
}
return ret;
} }
return -EINVAL;
} }
static int position_state_up(const zmk_event_t *ev, struct zmk_position_state_changed *data) { static int position_state_up(const zmk_event_t *ev, struct zmk_position_state_changed *data) {
@ -481,8 +478,11 @@ static void combo_timeout_handler(struct k_work *item) {
return; return;
} }
if (filter_timed_out_candidates(timeout_task_timeout_at) == 0) { if (filter_timed_out_candidates(timeout_task_timeout_at) == 0) {
LOG_DBG("CLEANUP!");
cleanup(); cleanup();
} }
LOG_DBG("ABOUT TO UPDATE IN TIMEOUT");
update_timeout_task(); update_timeout_task();
} }
@ -520,26 +520,16 @@ ZMK_LISTENER(combo, behavior_combo_listener);
ZMK_SUBSCRIPTION(combo, zmk_position_state_changed); ZMK_SUBSCRIPTION(combo, zmk_position_state_changed);
ZMK_SUBSCRIPTION(combo, zmk_keycode_state_changed); ZMK_SUBSCRIPTION(combo, zmk_keycode_state_changed);
#define COMBO_INST(n) \
static const struct combo_cfg combo_config_##n = { \
.timeout_ms = DT_PROP(n, timeout_ms), \
.require_prior_idle_ms = DT_PROP(n, require_prior_idle_ms), \
.key_positions = DT_PROP(n, key_positions), \
.key_position_len = DT_PROP_LEN(n, key_positions), \
.behavior = ZMK_KEYMAP_EXTRACT_BINDING(0, n), \
.virtual_key_position = ZMK_VIRTUAL_KEY_POSITION_COMBO(__COUNTER__), \
.slow_release = DT_PROP(n, slow_release), \
.layers = DT_PROP(n, layers), \
.layers_len = DT_PROP_LEN(n, layers), \
};
#define INITIALIZE_COMBO(n) initialize_combo(&combo_config_##n);
DT_INST_FOREACH_CHILD(0, COMBO_INST)
static int combo_init(void) { static int combo_init(void) {
for (size_t i = 0; i < CONFIG_ZMK_COMBO_MAX_PRESSED_COMBOS; i++) {
active_combos[i].combo_idx = UINT16_MAX;
}
k_work_init_delayable(&timeout_task, combo_timeout_handler); k_work_init_delayable(&timeout_task, combo_timeout_handler);
DT_INST_FOREACH_CHILD(0, INITIALIZE_COMBO); LOG_WRN("Have %d combos!", ARRAY_SIZE(combos));
for (int i = 0; i < ARRAY_SIZE(combos); i++) {
initialize_combo(i);
}
return 0; return 0;
} }

14
docs/docs/config/combos.md
View File

@ -11,15 +11,9 @@ See [Configuration Overview](index.md) for instructions on how to change these s
Definition file: [zmk/app/Kconfig](https://github.com/zmkfirmware/zmk/blob/main/app/Kconfig) Definition file: [zmk/app/Kconfig](https://github.com/zmkfirmware/zmk/blob/main/app/Kconfig)
| Config | Type | Description | Default | | Config | Type | Description | Default |
| ------------------------------------- | ---- | -------------------------------------------------------------- | ------- | | ------------------------------------- | ---- | ------------------------------------------------------------ | ------- |
| `CONFIG_ZMK_COMBO_MAX_PRESSED_COMBOS` | int | Maximum number of combos that can be active at the same time | 4 | | `CONFIG_ZMK_COMBO_MAX_PRESSED_COMBOS` | int | Maximum number of combos that can be active at the same time | 4 |
| `CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY` | int | Maximum number of active combos that use the same key position | 5 |
| `CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO` | int | Maximum number of keys to press to activate a combo | 4 |
If `CONFIG_ZMK_COMBO_MAX_COMBOS_PER_KEY` is 5, you can have 5 separate combos that use position `0`, 5 combos that use position `1`, and so on.
If you want a combo that triggers when pressing 5 keys, you must set `CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO` to 5.
## Devicetree ## Devicetree
@ -39,5 +33,3 @@ Each child node can have the following properties:
| `require-prior-idle-ms` | int | If any non-modifier key is pressed within `require-prior-idle-ms` before a key in the combo, the key will not be considered for the combo | -1 (disabled) | | `require-prior-idle-ms` | int | If any non-modifier key is pressed within `require-prior-idle-ms` before a key in the combo, the key will not be considered for the combo | -1 (disabled) |
| `slow-release` | bool | Releases the combo when all keys are released instead of when any key is released | false | | `slow-release` | bool | Releases the combo when all keys are released instead of when any key is released | false |
| `layers` | array | A list of layers on which the combo may be triggered. `-1` allows all layers. | `<-1>` | | `layers` | array | A list of layers on which the combo may be triggered. `-1` allows all layers. | `<-1>` |
The `key-positions` array must not be longer than the `CONFIG_ZMK_COMBO_MAX_KEYS_PER_COMBO` setting, which defaults to 4. If you want a combo that triggers when pressing 5 keys, then you must change the setting to 5.