me/qmk_firmware
1
0
Fork 0
forked from mirror/qmk_firmware
Code Pull Requests Activity

Refactor debounce algorithm with static allocation (#25515)

Browse Source 
* Refactor debounce counters with direct indexing

* Refactor code to use array indexing for debounce_counters
* Use global MATRIX_ROW_SHIFTER macro

* Refactor debounce algorithm with static allocation

* Converted arrays to static allocation
* Standardised use of MATRIX_ROWS_PER_HAND for array sizing
* Added Doxygen comments for primary debounce functions
* Removed debounce_free()

* Rewrite sym_defer_pr

* Modernise code using sym_defer_pk as template
* Format consistency with other current algorithms

* Use shorter SPDX-License-Identifier

* Remove ChibiOS core memory manager guard
* Keep type definition within DEBOUNCE guard

* Add change log

* Minor optimisation refactor

* Pre-calculate row_offset in per-key matrix loops
* Add inline compiler hints
* Improve readability with blank lines

* Limit elapsed time to the maximum debounce value

* Apply suggestions from code review

Declare counters with "DEBOUNCE_ELAPSED"

Co-authored-by: Joel Challis <git@zvecr.com>

* Update change log to new breaking change date

---------

Co-authored-by: Joel Challis <git@zvecr.com>
This commit is contained in:
フィルターペーパー
2025-09-07 20:34:05 +08:00
committed by GitHub
parent 5830b1b5e3
commit 4bd5c033c3
10 changed files with 369 additions and 392 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
quantum/debounce/sym_eager_pr.c
View File

@@ -1,33 +1,14 @@
/*
Copyright 2019 Alex Ong<the.onga@gmail.com>
Copyright 2021 Simon Arlott
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/>.
*/
/*
Basic per-row algorithm. Uses an 8-bit counter per row.
After pressing a key, it immediately changes state, and sets a counter.
No further inputs are accepted until DEBOUNCE milliseconds have occurred.
*/
// Copyright 2017 Alex Ong<the.onga@gmail.com>
// Copyright 2021 Simon Arlott
// SPDX-License-Identifier: GPL-2.0-or-later
//
// Basic per-row algorithm. Uses an 8-bit counter per key.
// After pressing a key, it immediately changes state, and sets a counter.
// No further inputs are accepted until DEBOUNCE milliseconds have occurred.
#include "debounce.h"
#include "timer.h"
#include <stdlib.h>
#ifdef PROTOCOL_CHIBIOS
# if CH_CFG_USE_MEMCORE == FALSE
# error ChibiOS is configured without a memory allocator. Your keyboard may have set `#define CH_CFG_USE_MEMCORE FALSE`, which is incompatible with this debounce algorithm.
# endif
#endif
#include "util.h"
#ifndef DEBOUNCE
# define DEBOUNCE 5
@@ -39,37 +20,25 @@ No further inputs are accepted until DEBOUNCE milliseconds have occurred.
# define DEBOUNCE UINT8_MAX
#endif
typedef uint8_t debounce_counter_t;
#define DEBOUNCE_ELAPSED 0
#if DEBOUNCE > 0
static bool matrix_need_update;
typedef uint8_t debounce_counter_t;
// Uses MATRIX_ROWS_PER_HAND instead of MATRIX_ROWS to support split keyboards
static debounce_counter_t debounce_counters[MATRIX_ROWS_PER_HAND] = {DEBOUNCE_ELAPSED};
static bool counters_need_update;
static bool matrix_need_update;
static bool cooked_changed;
static debounce_counter_t *debounce_counters;
static fast_timer_t last_time;
static bool counters_need_update;
static bool cooked_changed;
static inline void update_debounce_counters(uint8_t elapsed_time);
static inline void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[]);
# define DEBOUNCE_ELAPSED 0
static void update_debounce_counters(uint8_t num_rows, uint8_t elapsed_time);
static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows);
// we use num_rows rather than MATRIX_ROWS to support split keyboards
void debounce_init(uint8_t num_rows) {
debounce_counters = (debounce_counter_t *)malloc(num_rows * sizeof(debounce_counter_t));
for (uint8_t r = 0; r < num_rows; r++) {
debounce_counters[r] = DEBOUNCE_ELAPSED;
}
}
void debounce_free(void) {
free(debounce_counters);
debounce_counters = NULL;
}
void debounce_init(uint8_t num_rows) {}
bool debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) {
bool updated_last = false;
cooked_changed = false;
static fast_timer_t last_time;
bool updated_last = false;
cooked_changed = false;
if (counters_need_update) {
fast_timer_t now = timer_read_fast();
@@ -77,12 +46,10 @@ bool debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool
last_time = now;
updated_last = true;
if (elapsed_time > UINT8_MAX) {
elapsed_time = UINT8_MAX;
}
if (elapsed_time > 0) {
update_debounce_counters(num_rows, elapsed_time);
// Update debounce counters with elapsed timer clamped to UINT8_MAX
update_debounce_counters(MIN(elapsed_time, UINT8_MAX));
}
}
@@ -91,49 +58,64 @@ bool debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool
last_time = timer_read_fast();
}
transfer_matrix_values(raw, cooked, num_rows);
transfer_matrix_values(raw, cooked);
}
return cooked_changed;
}
// If the current time is > debounce counter, set the counter to enable input.
static void update_debounce_counters(uint8_t num_rows, uint8_t elapsed_time) {
counters_need_update = false;
matrix_need_update = false;
debounce_counter_t *debounce_pointer = debounce_counters;
for (uint8_t row = 0; row < num_rows; row++) {
if (*debounce_pointer != DEBOUNCE_ELAPSED) {
if (*debounce_pointer <= elapsed_time) {
*debounce_pointer = DEBOUNCE_ELAPSED;
matrix_need_update = true;
/**
* @brief Updates per-row debounce counters and determines if matrix needs updating.
*
* Iterates through each row in the matrix and checks its debounce counter. If the debounce
* period has elapsed, the counter is reset and the matrix is marked for update. Otherwise,
* the counter is decremented by the elapsed time and marked for further updates if needed.
*
* @param elapsed_time The time elapsed since the last debounce update, in milliseconds.
*/
static inline void update_debounce_counters(uint8_t elapsed_time) {
counters_need_update = false;
matrix_need_update = false;
for (uint8_t row = 0; row < MATRIX_ROWS_PER_HAND; row++) {
if (debounce_counters[row] != DEBOUNCE_ELAPSED) {
if (debounce_counters[row] <= elapsed_time) {
debounce_counters[row] = DEBOUNCE_ELAPSED;
matrix_need_update = true;
} else {
*debounce_pointer -= elapsed_time;
debounce_counters[row] -= elapsed_time;
counters_need_update = true;
}
}
debounce_pointer++;
}
}
// upload from raw_matrix to final matrix;
static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows) {
matrix_need_update = false;
debounce_counter_t *debounce_pointer = debounce_counters;
for (uint8_t row = 0; row < num_rows; row++) {
/**
* @brief Transfers debounced key states from the raw matrix to the cooked matrix.
*
* For each row in the matrix, this function checks if its state has changed and if its
* debounce counter has elapsed. If so, the debounce counter is reset, the cooked matrix
* is updated to reflect the new state, and the matrix is marked for further updates.
*
* @param raw The current raw key state matrix.
* @param cooked The debounced key state matrix
*/
static inline void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[]) {
matrix_need_update = false;
for (uint8_t row = 0; row < MATRIX_ROWS_PER_HAND; row++) {
matrix_row_t existing_row = cooked[row];
matrix_row_t raw_row = raw[row];
// determine new value basd on debounce pointer + raw value
if (existing_row != raw_row) {
if (*debounce_pointer == DEBOUNCE_ELAPSED) {
*debounce_pointer = DEBOUNCE;
if (debounce_counters[row] == DEBOUNCE_ELAPSED) {
debounce_counters[row] = DEBOUNCE;
cooked_changed |= cooked[row] ^ raw_row;
cooked[row] = raw_row;
counters_need_update = true;
}
}
debounce_pointer++;
}
}