1
0
Fork 0

Clean up debounce a bit (#5255)

This commit is contained in:
James Churchill 2019-03-05 01:44:46 +10:00 committed by MechMerlin
parent cdfcbfc92d
commit c7c4937eef
8 changed files with 29 additions and 44 deletions

View file

@ -298,19 +298,11 @@ ifneq ($(strip $(CUSTOM_MATRIX)), yes)
endif
DEBOUNCE_DIR:= $(QUANTUM_DIR)/debounce
# Debounce Modules. If implemented in matrix.c, don't use these.
# Debounce Modules. Set DEBOUNCE_TYPE=custom if including one manually.
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)
ifneq ($(strip $(DEBOUNCE_TYPE)), custom)
QUANTUM_SRC += $(DEBOUNCE_DIR)/$(strip $(DEBOUNCE_TYPE)).c
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
ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
OPT_DEFS += -DSPLIT_KEYBOARD

View file

@ -307,8 +307,8 @@ Use these to enable or disable building certain features. The more you have enab
* Enables split keyboard support (dual MCU like the let's split and bakingpy's boards) and includes all necessary files located at quantum/split_common
* `CUSTOM_MATRIX`
* Allows replacing the standard matrix scanning routine with a custom one.
* `CUSTOM_DEBOUNCE`
* Allows replacing the standard key debouncing routine with a custom one.
* `DEBOUNCE_TYPE`
* Allows replacing the standard key debouncing routine with an alternative or custom one.
* `WAIT_FOR_USB`
* Forces the keyboard to wait for a USB connection to be established before it starts up
* `NO_USB_STARTUP_CHECK`

View file

@ -2,30 +2,23 @@
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_DIR:= $(QUANTUM_DIR)/debounce
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
ifneq ($(strip $(DEBOUNCE_TYPE)), custom)
QUANTUM_SRC += $(DEBOUNCE_DIR)/$(strip $(DEBOUNCE_TYPE)).c
endif
```
# Debounce selection
| DEBOUNCE_ALGO | Description | What to do |
| DEBOUNCE_TYPE | Description | What else is needed |
| ------------- | --------------------------------------------------- | ----------------------------- |
| Not defined | You are using the included matrix.c and debounce.c | Nothing. Debounce_sym_g will be compiled, and used if necessary |
| Not defined | Use the default algorithm, currently sym_g | Nothing |
| 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 |
| anything_else | Use another algorithm from quantum/debounce/* | Nothing |
**Regarding split keyboards**:
The debounce code is compatible with split keyboards.
@ -33,14 +26,14 @@ 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.
* Add your own ```debounce.c```. Look at current implementations in ```quantum/debounce``` for examples.
* 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.
* eager_pk - debouncing per key. On any state change, response is immediate, followed by ```DEBOUNCE_DELAY``` millseconds of no further input for that key
* 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.

View file

@ -143,9 +143,9 @@ As there is no standard split communication driver for ARM-based split keyboards
Lets you replace the default matrix scanning routine with your own code. You will need to provide your own implementations of matrix_init() and matrix_scan().
`CUSTOM_DEBOUNCE`
`DEBOUNCE_TYPE`
Lets you replace the default key debouncing routine with your own code. You will need to provide your own implementation of debounce().
Lets you replace the default key debouncing routine with an alternative one. If `custom` you will need to provide your own implementation.
## Customizing Makefile Options on a Per-Keymap Basis

View file

@ -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!

View file

@ -7,7 +7,7 @@ BUILD_OPTION_NAMES = \
NKRO_ENABLE \
TERMINAL_ENABLE \
CUSTOM_MATRIX \
CUSTOM_DEBOUNCE \
DEBOUNCE_TYPE \
SPLIT_KEYBOARD \
DYNAMIC_KEYMAP_ENABLE \
USB_HID_ENABLE