aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--tmk_core/common.mk17
-rw-r--r--tmk_core/common/debounce.c22
-rw-r--r--tmk_core/common/debounce.h21
-rw-r--r--tmk_core/common/debounce/debounce_eager_pk.c124
-rw-r--r--tmk_core/common/debounce/debounce_sym_g.c59
-rw-r--r--tmk_core/common/debounce/readme.md28
-rw-r--r--tmk_core/common/keyboard.c9
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 @@
1COMMON_DIR = common 1COMMON_DIR = common
2DEBOUNCE = $(COMMON_DIR)/debounce 2
3ifeq ($(PLATFORM),AVR) 3ifeq ($(PLATFORM),AVR)
4 PLATFORM_COMMON_DIR = $(COMMON_DIR)/avr 4 PLATFORM_COMMON_DIR = $(COMMON_DIR)/avr
5else ifeq ($(PLATFORM),CHIBIOS) 5else ifeq ($(PLATFORM),CHIBIOS)
@@ -12,7 +12,6 @@ endif
12 12
13TMK_COMMON_SRC += $(COMMON_DIR)/host.c \ 13TMK_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
63endif 62endif
64 63
65# Debounce Modules. If implemented in matrix.c, don't use these.
66ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
67 # Do nothing, debouncing is inside matrix.c inside split_common
68else ifeq ($(strip $(DEBOUNCE_ALGO)), manual)
69 # Do nothing. do your debouncing in matrix.c
70else ifeq ($(strip $(DEBOUNCE_ALGO)), sym_g)
71 TMK_COMMON_SRC += $(DEBOUNCE)/debounce_sym_g.c
72else ifeq ($(strip $(DEBOUNCE_ALGO)), eager_pk)
73 TMK_COMMON_SRC += $(DEBOUNCE)/debounce_eager_pk.c
74else ifeq ($(strip $(CUSTOM_MATRIX)), yes)
75 # Do nothing. Custom matrix code.
76else # default algorithm
77 TMK_COMMON_SRC += $(DEBOUNCE)/debounce_sym_g.c
78endif
79 64
80# Option modules 65# Option modules
81BOOTMAGIC_ENABLE ?= no 66BOOTMAGIC_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/*
2Copyright 2017 Alex Ong<the.onga@gmail.com>
3This program is free software: you can redistribute it and/or modify
4it under the terms of the GNU General Public License as published by
5the Free Software Foundation, either version 2 of the License, or
6(at your option) any later version.
7This program is distributed in the hope that it will be useful,
8but WITHOUT ANY WARRANTY; without even the implied warranty of
9MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10GNU General Public License for more details.
11You should have received a copy of the GNU General Public License
12along 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
7extern "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/*
2Copyright 2017 Alex Ong<the.onga@gmail.com>
3This program is free software: you can redistribute it and/or modify
4it under the terms of the GNU General Public License as published by
5the Free Software Foundation, either version 2 of the License, or
6(at your option) any later version.
7This program is distributed in the hope that it will be useful,
8but WITHOUT ANY WARRANTY; without even the implied warranty of
9MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10GNU General Public License for more details.
11You should have received a copy of the GNU General Public License
12along with this program. If not, see <http://www.gnu.org/licenses/>.
13*/
14
15/*
16Basic per-key algorithm. Uses an 8-bit counter per key.
17After pressing a key, it immediately changes state, and sets a counter.
18No 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
42static matrix_row_t matrix_debounced[MATRIX_ROWS];
43static debounce_counter_t debounce_counters[MATRIX_ROWS*MATRIX_COLS];
44
45#define DEBOUNCE_ELAPSED 251
46#define MAX_DEBOUNCE (DEBOUNCE_ELAPSED - 1)
47
48void update_debounce_counters(uint8_t current_time);
49void transfer_matrix_values(uint8_t current_time);
50
51void 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
68void 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.
76void 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;
96void 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
121matrix_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/*
2Copyright 2017 Alex Ong<the.onga@gmail.com>
3This program is free software: you can redistribute it and/or modify
4it under the terms of the GNU General Public License as published by
5the Free Software Foundation, either version 2 of the License, or
6(at your option) any later version.
7This program is distributed in the hope that it will be useful,
8but WITHOUT ANY WARRANTY; without even the implied warranty of
9MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10GNU General Public License for more details.
11You should have received a copy of the GNU General Public License
12along with this program. If not, see <http://www.gnu.org/licenses/>.
13*/
14
15/*
16Basic global debounce algorithm. Used in 99% of keyboards at time of implementation
17When 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
25static matrix_row_t matrix_debounced[MATRIX_ROWS];
26static bool debouncing = false;
27static uint16_t debouncing_time;
28
29void matrix_debounce_init(void)
30{
31 for (uint8_t r = 0; r < MATRIX_ROWS; r++)
32 {
33 matrix_debounced[r] = 0;
34 }
35}
36
37void 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
56matrix_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 @@
1Debounce algorithms belong in this folder.
2Here are a few ideas
3
41) 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
92) 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
143) 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
19The default algorithm is symmetric and global.
20Here are a few that could be implemented:
21
22debounce_sym_g.c
23debounce_sym_pk.c
24debounce_sym_pr.c
25debounce_sym_pr_cycles.c //currently used in ergo-dox
26debounce_eager_g.c
27debounce_eager_pk.c
28debounce_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 */
165void keyboard_init(void) { 164void 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