Clean up debounce a bit (#5255)

common_features.mk

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

docs/config_options.md

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

docs/feature_debounce_type.md

@@ -2,45 +2,38 @@
 
 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                    |
-| -------------    | ---------------------------------------------------         | ----------------------------- |
-| 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 |
+| DEBOUNCE_TYPE    | Description                                          | What else is needed           |
+| -------------    | ---------------------------------------------------  | ----------------------------- |
+| 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 |
+| anything_else    | Use another algorithm from quantum/debounce/*        | Nothing                       |
 
-**Regarding split keyboards**: 
+**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.
+* 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.
 
 

docs/getting_started_make_guide.md

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

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!

show_options.mk

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