diff options
-rw-r--r-- | tmk_core/common.mk | 17 | ||||
-rw-r--r-- | tmk_core/common/debounce.c | 22 | ||||
-rw-r--r-- | tmk_core/common/debounce.h | 21 | ||||
-rw-r--r-- | tmk_core/common/debounce/debounce_eager_pk.c | 124 | ||||
-rw-r--r-- | tmk_core/common/debounce/debounce_sym_g.c | 59 | ||||
-rw-r--r-- | tmk_core/common/debounce/readme.md | 28 | ||||
-rw-r--r-- | tmk_core/common/keyboard.c | 9 |
7 files changed, 4 insertions, 276 deletions
diff --git a/tmk_core/common.mk b/tmk_core/common.mk index 7a7b3928f..335a36cfe 100644 --- a/tmk_core/common.mk +++ b/tmk_core/common.mk | |||
@@ -1,5 +1,5 @@ | |||
1 | COMMON_DIR = common | 1 | COMMON_DIR = common |
2 | DEBOUNCE = $(COMMON_DIR)/debounce | 2 | |
3 | ifeq ($(PLATFORM),AVR) | 3 | ifeq ($(PLATFORM),AVR) |
4 | PLATFORM_COMMON_DIR = $(COMMON_DIR)/avr | 4 | PLATFORM_COMMON_DIR = $(COMMON_DIR)/avr |
5 | else ifeq ($(PLATFORM),CHIBIOS) | 5 | else ifeq ($(PLATFORM),CHIBIOS) |
@@ -12,7 +12,6 @@ endif | |||
12 | 12 | ||
13 | TMK_COMMON_SRC += $(COMMON_DIR)/host.c \ | 13 | TMK_COMMON_SRC += $(COMMON_DIR)/host.c \ |
14 | $(COMMON_DIR)/keyboard.c \ | 14 | $(COMMON_DIR)/keyboard.c \ |
15 | $(COMMON_DIR)/debounce.c \ | ||
16 | $(COMMON_DIR)/action.c \ | 15 | $(COMMON_DIR)/action.c \ |
17 | $(COMMON_DIR)/action_tapping.c \ | 16 | $(COMMON_DIR)/action_tapping.c \ |
18 | $(COMMON_DIR)/action_macro.c \ | 17 | $(COMMON_DIR)/action_macro.c \ |
@@ -62,20 +61,6 @@ ifeq ($(PLATFORM),TEST) | |||
62 | TMK_COMMON_SRC += $(PLATFORM_COMMON_DIR)/eeprom.c | 61 | TMK_COMMON_SRC += $(PLATFORM_COMMON_DIR)/eeprom.c |
63 | endif | 62 | endif |
64 | 63 | ||
65 | # Debounce Modules. If implemented in matrix.c, don't use these. | ||
66 | ifeq ($(strip $(SPLIT_KEYBOARD)), yes) | ||
67 | # Do nothing, debouncing is inside matrix.c inside split_common | ||
68 | else ifeq ($(strip $(DEBOUNCE_ALGO)), manual) | ||
69 | # Do nothing. do your debouncing in matrix.c | ||
70 | else ifeq ($(strip $(DEBOUNCE_ALGO)), sym_g) | ||
71 | TMK_COMMON_SRC += $(DEBOUNCE)/debounce_sym_g.c | ||
72 | else ifeq ($(strip $(DEBOUNCE_ALGO)), eager_pk) | ||
73 | TMK_COMMON_SRC += $(DEBOUNCE)/debounce_eager_pk.c | ||
74 | else ifeq ($(strip $(CUSTOM_MATRIX)), yes) | ||
75 | # Do nothing. Custom matrix code. | ||
76 | else # default algorithm | ||
77 | TMK_COMMON_SRC += $(DEBOUNCE)/debounce_sym_g.c | ||
78 | endif | ||
79 | 64 | ||
80 | # Option modules | 65 | # Option modules |
81 | BOOTMAGIC_ENABLE ?= no | 66 | BOOTMAGIC_ENABLE ?= no |
diff --git a/tmk_core/common/debounce.c b/tmk_core/common/debounce.c deleted file mode 100644 index 406d2d0f3..000000000 --- a/tmk_core/common/debounce.c +++ /dev/null | |||
@@ -1,22 +0,0 @@ | |||
1 | /* | ||
2 | Copyright 2017 Alex Ong<the.onga@gmail.com> | ||
3 | This program is free software: you can redistribute it and/or modify | ||
4 | it under the terms of the GNU General Public License as published by | ||
5 | the Free Software Foundation, either version 2 of the License, or | ||
6 | (at your option) any later version. | ||
7 | This program is distributed in the hope that it will be useful, | ||
8 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
9 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
10 | GNU General Public License for more details. | ||
11 | You should have received a copy of the GNU General Public License | ||
12 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
13 | */ | ||
14 | #include "debounce.h" | ||
15 | #include "matrix.h" | ||
16 | //Default implementation - no debouncing | ||
17 | __attribute__((weak)) void matrix_debounce_init(void) {} | ||
18 | __attribute__((weak)) void matrix_debounce(void) {} | ||
19 | __attribute__((weak)) matrix_row_t matrix_debounce_get_row(uint8_t row) | ||
20 | { | ||
21 | return matrix_get_row(row); | ||
22 | } | ||
diff --git a/tmk_core/common/debounce.h b/tmk_core/common/debounce.h deleted file mode 100644 index fe3effab3..000000000 --- a/tmk_core/common/debounce.h +++ /dev/null | |||
@@ -1,21 +0,0 @@ | |||
1 | #ifndef DEBOUNCE_H | ||
2 | #define DEBOUNCE_H | ||
3 | #include <stdbool.h> | ||
4 | #include <stdint.h> | ||
5 | #include "matrix.h" | ||
6 | #ifdef __cplusplus | ||
7 | extern "C" { | ||
8 | #endif | ||
9 | /* called to initialize any data stores your implementation has*/ | ||
10 | void matrix_debounce_init(void); | ||
11 | /* call this every keyboard_task to debounce the matrix*/ | ||
12 | void matrix_debounce(void); | ||
13 | /* matrix state on row */ | ||
14 | matrix_row_t matrix_debounce_get_row(uint8_t row); | ||
15 | /* whether a switch is on */ | ||
16 | bool matrix_debounce_is_on(uint8_t row, uint8_t col); | ||
17 | |||
18 | #ifdef __cplusplus | ||
19 | } | ||
20 | #endif | ||
21 | #endif | ||
diff --git a/tmk_core/common/debounce/debounce_eager_pk.c b/tmk_core/common/debounce/debounce_eager_pk.c deleted file mode 100644 index 984da0570..000000000 --- a/tmk_core/common/debounce/debounce_eager_pk.c +++ /dev/null | |||
@@ -1,124 +0,0 @@ | |||
1 | /* | ||
2 | Copyright 2017 Alex Ong<the.onga@gmail.com> | ||
3 | This program is free software: you can redistribute it and/or modify | ||
4 | it under the terms of the GNU General Public License as published by | ||
5 | the Free Software Foundation, either version 2 of the License, or | ||
6 | (at your option) any later version. | ||
7 | This program is distributed in the hope that it will be useful, | ||
8 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
9 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
10 | GNU General Public License for more details. | ||
11 | You should have received a copy of the GNU General Public License | ||
12 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
13 | */ | ||
14 | |||
15 | /* | ||
16 | Basic per-key algorithm. Uses an 8-bit counter per key. | ||
17 | After pressing a key, it immediately changes state, and sets a counter. | ||
18 | No further inputs are accepted until DEBOUNCE milliseconds have occurred. | ||
19 | */ | ||
20 | |||
21 | #include "debounce.h" | ||
22 | #include "matrix.h" | ||
23 | #include "timer.h" | ||
24 | |||
25 | #ifndef DEBOUNCE | ||
26 | #define DEBOUNCE 5 | ||
27 | #endif | ||
28 | |||
29 | |||
30 | #if (MATRIX_COLS <= 8) | ||
31 | # define ROW_SHIFTER ((uint8_t)1) | ||
32 | #elif (MATRIX_COLS <= 16) | ||
33 | # define ROW_SHIFTER ((uint16_t)1) | ||
34 | #elif (MATRIX_COLS <= 32) | ||
35 | # define ROW_SHIFTER ((uint32_t)1) | ||
36 | #endif | ||
37 | |||
38 | |||
39 | |||
40 | #define debounce_counter_t uint8_t | ||
41 | |||
42 | static matrix_row_t matrix_debounced[MATRIX_ROWS]; | ||
43 | static debounce_counter_t debounce_counters[MATRIX_ROWS*MATRIX_COLS]; | ||
44 | |||
45 | #define DEBOUNCE_ELAPSED 251 | ||
46 | #define MAX_DEBOUNCE (DEBOUNCE_ELAPSED - 1) | ||
47 | |||
48 | void update_debounce_counters(uint8_t current_time); | ||
49 | void transfer_matrix_values(uint8_t current_time); | ||
50 | |||
51 | void matrix_debounce_init(void) | ||
52 | { | ||
53 | for (uint8_t r = 0; r < MATRIX_ROWS; r++) | ||
54 | { | ||
55 | matrix_debounced[r] = 0; | ||
56 | } | ||
57 | |||
58 | int i = 0; | ||
59 | for (uint8_t r = 0; r < MATRIX_ROWS; r++) | ||
60 | { | ||
61 | for (uint8_t c = 0; c < MATRIX_COLS; c++) | ||
62 | { | ||
63 | debounce_counters[i++] = DEBOUNCE_ELAPSED; | ||
64 | } | ||
65 | } | ||
66 | } | ||
67 | |||
68 | void matrix_debounce(void) | ||
69 | { | ||
70 | uint8_t current_time = timer_read() % MAX_DEBOUNCE; | ||
71 | update_debounce_counters(current_time); | ||
72 | transfer_matrix_values(current_time); | ||
73 | } | ||
74 | |||
75 | //If the current time is > debounce counter, set the counter to enable input. | ||
76 | void update_debounce_counters(uint8_t current_time) | ||
77 | { | ||
78 | debounce_counter_t *debounce_pointer = debounce_counters; | ||
79 | for (uint8_t row = 0; row < MATRIX_ROWS; row++) | ||
80 | { | ||
81 | for (uint8_t col = 0; col < MATRIX_COLS; col++) | ||
82 | { | ||
83 | if (*debounce_pointer != DEBOUNCE_ELAPSED) | ||
84 | { | ||
85 | if (TIMER_DIFF(current_time, *debounce_pointer, MAX_DEBOUNCE) >= | ||
86 | DEBOUNCING_DELAY) { | ||
87 | *debounce_pointer = DEBOUNCE_ELAPSED; | ||
88 | } | ||
89 | } | ||
90 | debounce_pointer++; | ||
91 | } | ||
92 | } | ||
93 | } | ||
94 | |||
95 | // upload from raw_matrix to final matrix; | ||
96 | void transfer_matrix_values(uint8_t current_time) | ||
97 | { | ||
98 | debounce_counter_t *debounce_pointer = debounce_counters; | ||
99 | for (uint8_t row = 0; row < MATRIX_ROWS; row++) | ||
100 | { | ||
101 | matrix_row_t existing_row = matrix_debounced[row]; | ||
102 | matrix_row_t raw_row = matrix_get_row(row); | ||
103 | |||
104 | for (uint8_t col = 0; col < MATRIX_COLS; col++) | ||
105 | { | ||
106 | matrix_row_t col_mask = (ROW_SHIFTER << col); | ||
107 | bool final_value = raw_row & col_mask; | ||
108 | bool existing_value = existing_row & col_mask; | ||
109 | if (*debounce_pointer == DEBOUNCE_ELAPSED && | ||
110 | (existing_value != final_value)) | ||
111 | { | ||
112 | *debounce_pointer = current_time; | ||
113 | existing_row ^= col_mask; //flip the bit. | ||
114 | } | ||
115 | debounce_pointer++; | ||
116 | } | ||
117 | matrix_debounced[row] = existing_row; | ||
118 | } | ||
119 | } | ||
120 | |||
121 | matrix_row_t matrix_debounce_get_row(uint8_t row) | ||
122 | { | ||
123 | return matrix_debounced[row]; | ||
124 | } | ||
diff --git a/tmk_core/common/debounce/debounce_sym_g.c b/tmk_core/common/debounce/debounce_sym_g.c deleted file mode 100644 index 2fb7a589d..000000000 --- a/tmk_core/common/debounce/debounce_sym_g.c +++ /dev/null | |||
@@ -1,59 +0,0 @@ | |||
1 | /* | ||
2 | Copyright 2017 Alex Ong<the.onga@gmail.com> | ||
3 | This program is free software: you can redistribute it and/or modify | ||
4 | it under the terms of the GNU General Public License as published by | ||
5 | the Free Software Foundation, either version 2 of the License, or | ||
6 | (at your option) any later version. | ||
7 | This program is distributed in the hope that it will be useful, | ||
8 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
9 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
10 | GNU General Public License for more details. | ||
11 | You should have received a copy of the GNU General Public License | ||
12 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
13 | */ | ||
14 | |||
15 | /* | ||
16 | Basic global debounce algorithm. Used in 99% of keyboards at time of implementation | ||
17 | When no state changes have occured for DEBOUNCE milliseconds, we push the state. | ||
18 | */ | ||
19 | #include "debounce.h" | ||
20 | #include "matrix.h" | ||
21 | #include "timer.h" | ||
22 | #ifndef DEBOUNCE | ||
23 | #define DEBOUNCE 5 | ||
24 | #endif | ||
25 | static matrix_row_t matrix_debounced[MATRIX_ROWS]; | ||
26 | static bool debouncing = false; | ||
27 | static uint16_t debouncing_time; | ||
28 | |||
29 | void matrix_debounce_init(void) | ||
30 | { | ||
31 | for (uint8_t r = 0; r < MATRIX_ROWS; r++) | ||
32 | { | ||
33 | matrix_debounced[r] = 0; | ||
34 | } | ||
35 | } | ||
36 | |||
37 | void matrix_debounce(void) | ||
38 | { | ||
39 | for (uint8_t r = 0; r < MATRIX_ROWS; r++) | ||
40 | { | ||
41 | matrix_row_t raw = matrix_get_row(r); | ||
42 | if (raw != matrix_debounced[r]) | ||
43 | { | ||
44 | debouncing = true; | ||
45 | debouncing_time = timer_read(); | ||
46 | } | ||
47 | } | ||
48 | if (debouncing && timer_elapsed(debouncing_time) > DEBOUNCE) { | ||
49 | for (int i = 0; i < MATRIX_ROWS; i++) { | ||
50 | matrix_debounced[i] = matrix_get_row(i); | ||
51 | } | ||
52 | debouncing = false; | ||
53 | } | ||
54 | } | ||
55 | |||
56 | matrix_row_t matrix_debounce_get_row(uint8_t row) | ||
57 | { | ||
58 | return matrix_debounced[row]; | ||
59 | } | ||
diff --git a/tmk_core/common/debounce/readme.md b/tmk_core/common/debounce/readme.md deleted file mode 100644 index 1a77d44df..000000000 --- a/tmk_core/common/debounce/readme.md +++ /dev/null | |||
@@ -1,28 +0,0 @@ | |||
1 | Debounce algorithms belong in this folder. | ||
2 | Here are a few ideas | ||
3 | |||
4 | 1) Global vs Per-Key vs Per-Row | ||
5 | * Global - one timer for all keys. Any key change state affects global timer | ||
6 | * Per key - one timer per key | ||
7 | * Per row - one timer per row | ||
8 | |||
9 | 2) Eager vs symmetric vs assymetric | ||
10 | * Eager - any key change is reported immediately. All further inputs for DEBOUNCE ms are ignored. | ||
11 | * Symmetric - wait for no changes for DEBOUNCE ms before reporting change | ||
12 | * Assymetric - wait for different times depending on key-down/key-up. E.g. Eager key-down, DEBOUNCE ms key up. | ||
13 | |||
14 | 3) Timestamp vs cycles | ||
15 | * old old old code waits n cycles, decreasing count by one each matrix_scan | ||
16 | * newer code stores the millisecond the change occurred, and does subraction to figure out time elapsed. | ||
17 | * Timestamps are superior, i don't think cycles will ever be used again once upgraded. | ||
18 | |||
19 | The default algorithm is symmetric and global. | ||
20 | Here are a few that could be implemented: | ||
21 | |||
22 | debounce_sym_g.c | ||
23 | debounce_sym_pk.c | ||
24 | debounce_sym_pr.c | ||
25 | debounce_sym_pr_cycles.c //currently used in ergo-dox | ||
26 | debounce_eager_g.c | ||
27 | debounce_eager_pk.c | ||
28 | debounce_eager_pr.c //could be used in ergo-dox! | ||
diff --git a/tmk_core/common/keyboard.c b/tmk_core/common/keyboard.c index 1bfd4c9cc..d22300116 100644 --- a/tmk_core/common/keyboard.c +++ b/tmk_core/common/keyboard.c | |||
@@ -18,7 +18,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
18 | #include <stdint.h> | 18 | #include <stdint.h> |
19 | #include "keyboard.h" | 19 | #include "keyboard.h" |
20 | #include "matrix.h" | 20 | #include "matrix.h" |
21 | #include "debounce.h" | ||
22 | #include "keymap.h" | 21 | #include "keymap.h" |
23 | #include "host.h" | 22 | #include "host.h" |
24 | #include "led.h" | 23 | #include "led.h" |
@@ -164,8 +163,7 @@ bool is_keyboard_master(void) { | |||
164 | */ | 163 | */ |
165 | void keyboard_init(void) { | 164 | void keyboard_init(void) { |
166 | timer_init(); | 165 | timer_init(); |
167 | matrix_init(); | 166 | matrix_init(); |
168 | matrix_debounce_init(); | ||
169 | #ifdef QWIIC_ENABLE | 167 | #ifdef QWIIC_ENABLE |
170 | qwiic_init(); | 168 | qwiic_init(); |
171 | #endif | 169 | #endif |
@@ -225,12 +223,11 @@ void keyboard_task(void) | |||
225 | uint8_t keys_processed = 0; | 223 | uint8_t keys_processed = 0; |
226 | #endif | 224 | #endif |
227 | 225 | ||
228 | matrix_scan(); | 226 | matrix_scan(); |
229 | matrix_debounce(); | ||
230 | 227 | ||
231 | if (is_keyboard_master()) { | 228 | if (is_keyboard_master()) { |
232 | for (uint8_t r = 0; r < MATRIX_ROWS; r++) { | 229 | for (uint8_t r = 0; r < MATRIX_ROWS; r++) { |
233 | matrix_row = matrix_debounce_get_row(r); | 230 | matrix_row = matrix_get_row(r); |
234 | matrix_change = matrix_row ^ matrix_prev[r]; | 231 | matrix_change = matrix_row ^ matrix_prev[r]; |
235 | if (matrix_change) { | 232 | if (matrix_change) { |
236 | #ifdef MATRIX_HAS_GHOST | 233 | #ifdef MATRIX_HAS_GHOST |