Debounce refactor / API (#3720)
* Added xeal60 via clone of lets split * Delete removed other keymaps * Basic keymap (no FN). Compiles. * Removed NP_STAR and NP_SLSH. * Removed "debounce_algo = manual" in all keyboards with CUSTOM_MATRIX = yes. * Changed order of rules in TMK. Documented feature. * Fixed missing whitespace in debounce documentation Table wasn't working due to missing newline. * Added bold in a few areas. * DO NOT USE - Removed debounce from TMK. * Remove accidental xeal60 commit * DO NOT USE - debounce successfully compiled. * DO NOT USE Revert back to original API to support split_keyboards. * Working eager_pk * Whitespace cleanup. * Restored debounce.h since there wasnt any real change. * Moved debouncing_time variable to inside #if debounce * Removed check for custom_matrix. We can safely include the debounce file for compilation when custom_matrix is used. * Removed #include "matrix.h" from debounce.h * Bug fix - was using MATRIX_ROWS instead of num_rows * Fixed compilation error with debounce_sym_g * Renamed DEBOUNCE_ALGO to DEBOUNCE_TYPE * Malloc array in debounce_eager_pk, since split keyboards only use MATRIX_ROWS/2. * Fix compile error in debounce_eager_pk * Stricter, leaner DEBOUNCE_TYPE section in common_features.mk. Cleanup debounce_type.mkrgb7seg 0.6.280
Drashna Jaelre
6 years ago
committed by
GitHub
commit
c22f3ba3a2
@ -0,0 +1,46 @@ |
|||||||
|
# Debounce algorithm |
||||||
|
|
||||||
|
QMK supports multiple debounce algorithms through its debounce API. |
||||||
|
|
||||||
|
The underlying debounce algorithm is determined by which matrix.c file you are using. |
||||||
|
|
||||||
|
The logic for which debounce method called is below. It checks various defines that you have set in rules.mk |
||||||
|
|
||||||
|
``` |
||||||
|
DEBOUNCE_TYPE?= sym_g |
||||||
|
VALID_DEBOUNCE_TYPES := sym_g eager_pk custom |
||||||
|
ifeq ($(filter $(DEBOUNCE_TYPE),$(VALID_DEBOUNCE_TYPES)),) |
||||||
|
$(error DEBOUNCE_TYPE="$(DEBOUNCE_TYPE)" is not a valid debounce algorithm) |
||||||
|
endif |
||||||
|
ifeq ($(strip $(DEBOUNCE_TYPE)), sym_g) |
||||||
|
QUANTUM_SRC += $(DEBOUNCE_DIR)/debounce_sym_g.c |
||||||
|
else ifeq ($(strip $(DEBOUNCE_TYPE)), eager_pk) |
||||||
|
QUANTUM_SRC += $(DEBOUNCE_DIR)/debounce_eager_pk.c |
||||||
|
endif |
||||||
|
``` |
||||||
|
|
||||||
|
# Debounce selection |
||||||
|
|
||||||
|
| DEBOUNCE_ALGO | Description | What to do | |
||||||
|
| ------------- | --------------------------------------------------- | ----------------------------- | |
||||||
|
| Not defined | You are using the included matrix.c and debounce.c | Nothing. Debounce_sym_g will be compiled, and used if necessary | |
||||||
|
| custom | Use your own debounce.c | ```SRC += debounce.c``` add your own debounce.c and implement necessary functions | |
||||||
|
| sym_g / eager_pk | You are using the included matrix.c and debounce.c | Use an alternative debounce algorithm | |
||||||
|
|
||||||
|
**Regarding split keyboards**: |
||||||
|
The debounce code is compatible with split keyboards. |
||||||
|
|
||||||
|
# Use your own debouncing code |
||||||
|
* Set ```DEBOUNCE_TYPE = custom ```. |
||||||
|
* Add ```SRC += debounce.c``` |
||||||
|
* Add your own ```debounce.c```. Look at included ```debounce_sym_g.c```s for sample implementations. |
||||||
|
* Debouncing occurs after every raw matrix scan. |
||||||
|
* Use num_rows rather than MATRIX_ROWS, so that split keyboards are supported correctly. |
||||||
|
|
||||||
|
# Changing between included debouncing methods |
||||||
|
You can either use your own code, by including your own debounce.c, or switch to another included one. |
||||||
|
Included debounce methods are: |
||||||
|
* debounce_eager_pk - debouncing per key. On any state change, response is immediate, followed by ```DEBOUNCE_DELAY``` millseconds of no further input for that key |
||||||
|
* debounce_sym_g - debouncing per keyboard. On any state change, a global timer is set. When ```DEBOUNCE_DELAY``` milliseconds of no changes has occured, all input changes are pushed. |
||||||
|
|
||||||
|
|
||||||
@ -1,52 +0,0 @@ |
|||||||
|
|
||||||
#include "matrix.h" |
|
||||||
#include "timer.h" |
|
||||||
#include "quantum.h" |
|
||||||
|
|
||||||
#ifndef DEBOUNCING_DELAY |
|
||||||
# define DEBOUNCING_DELAY 5 |
|
||||||
#endif |
|
||||||
|
|
||||||
void debounce_init(uint8_t num_rows) { |
|
||||||
} |
|
||||||
|
|
||||||
#if DEBOUNCING_DELAY > 0 |
|
||||||
|
|
||||||
static bool debouncing = false; |
|
||||||
|
|
||||||
void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) { |
|
||||||
static uint16_t debouncing_time; |
|
||||||
|
|
||||||
if (changed) { |
|
||||||
debouncing = true; |
|
||||||
debouncing_time = timer_read(); |
|
||||||
} |
|
||||||
|
|
||||||
if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) { |
|
||||||
for (uint8_t i = 0; i < num_rows; i++) { |
|
||||||
cooked[i] = raw[i]; |
|
||||||
} |
|
||||||
debouncing = false; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
bool debounce_active(void) { |
|
||||||
return debouncing; |
|
||||||
} |
|
||||||
|
|
||||||
#else |
|
||||||
|
|
||||||
// no debounce
|
|
||||||
void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) { |
|
||||||
if (changed) |
|
||||||
{ |
|
||||||
for (uint8_t i = 0; i < num_rows; i++) { |
|
||||||
cooked[i] = raw[i]; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
bool debounce_active(void) { |
|
||||||
return false; |
|
||||||
} |
|
||||||
#endif |
|
||||||
@ -0,0 +1,121 @@ |
|||||||
|
/*
|
||||||
|
Copyright 2017 Alex Ong<the.onga@gmail.com> |
||||||
|
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-key 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 "matrix.h" |
||||||
|
#include "timer.h" |
||||||
|
#include "quantum.h" |
||||||
|
#include <stdlib.h> |
||||||
|
|
||||||
|
#ifndef DEBOUNCE |
||||||
|
#define DEBOUNCE 5 |
||||||
|
#endif |
||||||
|
|
||||||
|
|
||||||
|
#if (MATRIX_COLS <= 8) |
||||||
|
# define ROW_SHIFTER ((uint8_t)1) |
||||||
|
#elif (MATRIX_COLS <= 16) |
||||||
|
# define ROW_SHIFTER ((uint16_t)1) |
||||||
|
#elif (MATRIX_COLS <= 32) |
||||||
|
# define ROW_SHIFTER ((uint32_t)1) |
||||||
|
#endif |
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#define debounce_counter_t uint8_t |
||||||
|
|
||||||
|
static debounce_counter_t *debounce_counters; |
||||||
|
|
||||||
|
#define DEBOUNCE_ELAPSED 251 |
||||||
|
#define MAX_DEBOUNCE (DEBOUNCE_ELAPSED - 1) |
||||||
|
|
||||||
|
void update_debounce_counters(uint8_t num_rows, uint8_t current_time); |
||||||
|
void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, uint8_t current_time); |
||||||
|
|
||||||
|
//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*MATRIX_COLS * sizeof(debounce_counter_t)); |
||||||
|
int i = 0; |
||||||
|
for (uint8_t r = 0; r < num_rows; r++) |
||||||
|
{ |
||||||
|
for (uint8_t c = 0; c < MATRIX_COLS; c++) |
||||||
|
{ |
||||||
|
debounce_counters[i++] = DEBOUNCE_ELAPSED; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) |
||||||
|
{ |
||||||
|
uint8_t current_time = timer_read() % MAX_DEBOUNCE; |
||||||
|
update_debounce_counters(num_rows, current_time); |
||||||
|
transfer_matrix_values(raw, cooked, num_rows, current_time); |
||||||
|
} |
||||||
|
|
||||||
|
//If the current time is > debounce counter, set the counter to enable input.
|
||||||
|
void update_debounce_counters(uint8_t num_rows, uint8_t current_time) |
||||||
|
{ |
||||||
|
debounce_counter_t *debounce_pointer = debounce_counters; |
||||||
|
for (uint8_t row = 0; row < num_rows; row++) |
||||||
|
{ |
||||||
|
for (uint8_t col = 0; col < MATRIX_COLS; col++) |
||||||
|
{ |
||||||
|
if (*debounce_pointer != DEBOUNCE_ELAPSED) |
||||||
|
{ |
||||||
|
if (TIMER_DIFF(current_time, *debounce_pointer, MAX_DEBOUNCE) >= DEBOUNCE) { |
||||||
|
*debounce_pointer = DEBOUNCE_ELAPSED; |
||||||
|
} |
||||||
|
} |
||||||
|
debounce_pointer++; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// upload from raw_matrix to final matrix;
|
||||||
|
void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, uint8_t current_time) |
||||||
|
{ |
||||||
|
debounce_counter_t *debounce_pointer = debounce_counters; |
||||||
|
for (uint8_t row = 0; row < num_rows; row++) |
||||||
|
{ |
||||||
|
matrix_row_t existing_row = cooked[row];
|
||||||
|
matrix_row_t raw_row = raw[row]; |
||||||
|
|
||||||
|
for (uint8_t col = 0; col < MATRIX_COLS; col++) |
||||||
|
{ |
||||||
|
matrix_row_t col_mask = (ROW_SHIFTER << col); |
||||||
|
bool final_value = raw_row & col_mask; |
||||||
|
bool existing_value = existing_row & col_mask; |
||||||
|
if (*debounce_pointer == DEBOUNCE_ELAPSED && |
||||||
|
(existing_value != final_value)) |
||||||
|
{ |
||||||
|
*debounce_pointer = current_time; |
||||||
|
existing_row ^= col_mask; //flip the bit.
|
||||||
|
} |
||||||
|
debounce_pointer++; |
||||||
|
} |
||||||
|
cooked[row] = existing_row; |
||||||
|
}
|
||||||
|
} |
||||||
|
|
||||||
|
bool debounce_active(void) |
||||||
|
{ |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
@ -0,0 +1,57 @@ |
|||||||
|
/*
|
||||||
|
Copyright 2017 Alex Ong<the.onga@gmail.com> |
||||||
|
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 global debounce algorithm. Used in 99% of keyboards at time of implementation |
||||||
|
When no state changes have occured for DEBOUNCE milliseconds, we push the state. |
||||||
|
*/ |
||||||
|
#include "matrix.h" |
||||||
|
#include "timer.h" |
||||||
|
#include "quantum.h" |
||||||
|
#ifndef DEBOUNCE |
||||||
|
#define DEBOUNCE 5 |
||||||
|
#endif |
||||||
|
|
||||||
|
void debounce_init(uint8_t num_rows) {} |
||||||
|
static bool debouncing = false; |
||||||
|
|
||||||
|
#if DEBOUNCE > 0 |
||||||
|
static uint16_t debouncing_time; |
||||||
|
void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) |
||||||
|
{ |
||||||
|
if (changed) { |
||||||
|
debouncing = true; |
||||||
|
debouncing_time = timer_read(); |
||||||
|
} |
||||||
|
|
||||||
|
if (debouncing && timer_elapsed(debouncing_time) > DEBOUNCE) { |
||||||
|
for (int i = 0; i < num_rows; i++) { |
||||||
|
cooked[i] = raw[i]; |
||||||
|
} |
||||||
|
debouncing = false; |
||||||
|
} |
||||||
|
} |
||||||
|
#else //no debouncing.
|
||||||
|
void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) |
||||||
|
{ |
||||||
|
for (int i = 0; i < num_rows; i++) { |
||||||
|
cooked[i] = raw[i]; |
||||||
|
} |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
bool debounce_active(void) { |
||||||
|
return debouncing; |
||||||
|
} |
||||||
|
|
||||||
@ -0,0 +1,28 @@ |
|||||||
|
Debounce algorithms belong in this folder. |
||||||
|
Here are a few ideas |
||||||
|
|
||||||
|
1) Global vs Per-Key vs Per-Row |
||||||
|
* Global - one timer for all keys. Any key change state affects global timer |
||||||
|
* Per key - one timer per key |
||||||
|
* Per row - one timer per row |
||||||
|
|
||||||
|
2) Eager vs symmetric vs assymetric |
||||||
|
* Eager - any key change is reported immediately. All further inputs for DEBOUNCE ms are ignored. |
||||||
|
* Symmetric - wait for no changes for DEBOUNCE ms before reporting change |
||||||
|
* Assymetric - wait for different times depending on key-down/key-up. E.g. Eager key-down, DEBOUNCE ms key up. |
||||||
|
|
||||||
|
3) Timestamp vs cycles |
||||||
|
* old old old code waits n cycles, decreasing count by one each matrix_scan |
||||||
|
* newer code stores the millisecond the change occurred, and does subraction to figure out time elapsed. |
||||||
|
* Timestamps are superior, i don't think cycles will ever be used again once upgraded. |
||||||
|
|
||||||
|
The default algorithm is symmetric and global. |
||||||
|
Here are a few that could be implemented: |
||||||
|
|
||||||
|
debounce_sym_g.c |
||||||
|
debounce_sym_pk.c |
||||||
|
debounce_sym_pr.c |
||||||
|
debounce_sym_pr_cycles.c //currently used in ergo-dox |
||||||
|
debounce_eager_g.c |
||||||
|
debounce_eager_pk.c |
||||||
|
debounce_eager_pr.c //could be used in ergo-dox! |
||||||
Loading…
Reference in new issue