From c7c4937eef9cb34b73e765390b842282ad9f0544 Mon Sep 17 00:00:00 2001 From: James Churchill Date: Tue, 5 Mar 2019 01:44:46 +1000 Subject: Clean up debounce a bit (#5255) --- quantum/debounce/debounce_eager_pk.c | 121 ----------------------------------- quantum/debounce/debounce_sym_g.c | 57 ----------------- quantum/debounce/eager_pk.c | 121 +++++++++++++++++++++++++++++++++++ quantum/debounce/readme.md | 18 +++--- quantum/debounce/sym_g.c | 57 +++++++++++++++++ 5 files changed, 187 insertions(+), 187 deletions(-) delete mode 100644 quantum/debounce/debounce_eager_pk.c delete mode 100644 quantum/debounce/debounce_sym_g.c create mode 100644 quantum/debounce/eager_pk.c create mode 100644 quantum/debounce/sym_g.c (limited to 'quantum/debounce') diff --git a/quantum/debounce/debounce_eager_pk.c b/quantum/debounce/debounce_eager_pk.c deleted file mode 100644 index b8ad09cee..000000000 --- a/quantum/debounce/debounce_eager_pk.c +++ /dev/null @@ -1,121 +0,0 @@ -/* -Copyright 2017 Alex Ong -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 . -*/ - -/* -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 - -#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; -} - diff --git a/quantum/debounce/debounce_sym_g.c b/quantum/debounce/debounce_sym_g.c deleted file mode 100644 index c8ab34e1a..000000000 --- a/quantum/debounce/debounce_sym_g.c +++ /dev/null @@ -1,57 +0,0 @@ -/* -Copyright 2017 Alex Ong -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 . -*/ - -/* -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; -} - diff --git a/quantum/debounce/eager_pk.c b/quantum/debounce/eager_pk.c new file mode 100644 index 000000000..b8ad09cee --- /dev/null +++ b/quantum/debounce/eager_pk.c @@ -0,0 +1,121 @@ +/* +Copyright 2017 Alex Ong +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 . +*/ + +/* +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 + +#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; +} + diff --git a/quantum/debounce/readme.md b/quantum/debounce/readme.md index 1a77d44df..5b318d845 100644 --- a/quantum/debounce/readme.md +++ b/quantum/debounce/readme.md @@ -6,10 +6,10 @@ Here are a few ideas * Per key - one timer per key * Per row - one timer per row -2) Eager vs symmetric vs assymetric +2) Eager vs symmetric vs asymmetric * 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. + * Asymmetric - 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 @@ -19,10 +19,10 @@ Here are a few ideas 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! +sym_g.c +sym_pk.c +sym_pr.c +sym_pr_cycles.c //currently used in ergo-dox +eager_g.c +eager_pk.c +eager_pr.c //could be used in ergo-dox! diff --git a/quantum/debounce/sym_g.c b/quantum/debounce/sym_g.c new file mode 100644 index 000000000..c8ab34e1a --- /dev/null +++ b/quantum/debounce/sym_g.c @@ -0,0 +1,57 @@ +/* +Copyright 2017 Alex Ong +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 . +*/ + +/* +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; +} + -- cgit v1.2.3-24-g4f1b