From c1297ceb972d45407cc1f518fd0527efda7ee796 Mon Sep 17 00:00:00 2001 From: Stefan Kerkmann Date: Mon, 29 Nov 2021 17:22:10 +0100 Subject: [Core] Remove matrix_is_modified() and debounce_is_active() (#15349) --- quantum/debounce/asym_eager_defer_pk.c | 1 - quantum/debounce/none.c | 2 -- quantum/debounce/sym_defer_g.c | 2 -- quantum/debounce/sym_defer_pk.c | 1 - quantum/debounce/sym_eager_pk.c | 1 - quantum/debounce/sym_eager_pr.c | 1 - 6 files changed, 8 deletions(-) (limited to 'quantum/debounce') diff --git a/quantum/debounce/asym_eager_defer_pk.c b/quantum/debounce/asym_eager_defer_pk.c index 81f39383c4..b1eb4a2b7b 100644 --- a/quantum/debounce/asym_eager_defer_pk.c +++ b/quantum/debounce/asym_eager_defer_pk.c @@ -165,7 +165,6 @@ static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], ui } } -bool debounce_active(void) { return true; } #else # include "none.c" #endif diff --git a/quantum/debounce/none.c b/quantum/debounce/none.c index b03892bc5b..8a85cc04a8 100644 --- a/quantum/debounce/none.c +++ b/quantum/debounce/none.c @@ -26,6 +26,4 @@ void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool } } -bool debounce_active(void) { return false; } - void debounce_free(void) {} diff --git a/quantum/debounce/sym_defer_g.c b/quantum/debounce/sym_defer_g.c index 9155eb914c..8cac1c37f9 100644 --- a/quantum/debounce/sym_defer_g.c +++ b/quantum/debounce/sym_defer_g.c @@ -44,8 +44,6 @@ void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool } } -bool debounce_active(void) { return debouncing; } - void debounce_free(void) {} #else // no debouncing. # include "none.c" diff --git a/quantum/debounce/sym_defer_pk.c b/quantum/debounce/sym_defer_pk.c index 1b698ba347..9dee29e28e 100644 --- a/quantum/debounce/sym_defer_pk.c +++ b/quantum/debounce/sym_defer_pk.c @@ -134,7 +134,6 @@ static void start_debounce_counters(matrix_row_t raw[], matrix_row_t cooked[], u } } -bool debounce_active(void) { return true; } #else # include "none.c" #endif diff --git a/quantum/debounce/sym_eager_pk.c b/quantum/debounce/sym_eager_pk.c index 9da000ea9a..deec463649 100644 --- a/quantum/debounce/sym_eager_pk.c +++ b/quantum/debounce/sym_eager_pk.c @@ -140,7 +140,6 @@ static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], ui } } -bool debounce_active(void) { return true; } #else # include "none.c" #endif diff --git a/quantum/debounce/sym_eager_pr.c b/quantum/debounce/sym_eager_pr.c index eda92a263b..29b0cabefb 100644 --- a/quantum/debounce/sym_eager_pr.c +++ b/quantum/debounce/sym_eager_pr.c @@ -132,7 +132,6 @@ static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], ui } } -bool debounce_active(void) { return true; } #else # include "none.c" #endif -- cgit v1.2.3 From 25713dc2225556b20101347580146f9820d5e831 Mon Sep 17 00:00:00 2001 From: Chad Austin Date: Sun, 26 Dec 2021 18:44:56 -0800 Subject: Add sym_defer_pr debouncer type (#14948) --- quantum/debounce/sym_defer_pr.c | 72 +++++++++ quantum/debounce/tests/rules.mk | 5 + quantum/debounce/tests/sym_defer_pr_tests.cpp | 223 ++++++++++++++++++++++++++ quantum/debounce/tests/testlist.mk | 1 + 4 files changed, 301 insertions(+) create mode 100644 quantum/debounce/sym_defer_pr.c create mode 100644 quantum/debounce/tests/sym_defer_pr_tests.cpp (limited to 'quantum/debounce') diff --git a/quantum/debounce/sym_defer_pr.c b/quantum/debounce/sym_defer_pr.c new file mode 100644 index 0000000000..8b33acc6a2 --- /dev/null +++ b/quantum/debounce/sym_defer_pr.c @@ -0,0 +1,72 @@ +/* +Copyright 2021 Chad Austin +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 . +*/ + +/* +Symmetric per-row debounce algorithm. Changes only apply when +DEBOUNCE milliseconds have elapsed since the last change. +*/ + +#include "matrix.h" +#include "timer.h" +#include "quantum.h" +#include + +#ifndef DEBOUNCE +# define DEBOUNCE 5 +#endif + +static uint16_t last_time; +// [row] milliseconds until key's state is considered debounced. +static uint8_t* countdowns; +// [row] +static matrix_row_t* last_raw; + +void debounce_init(uint8_t num_rows) { + countdowns = (uint8_t*)calloc(num_rows, sizeof(uint8_t)); + last_raw = (matrix_row_t*)calloc(num_rows, sizeof(matrix_row_t)); + + last_time = timer_read(); +} + +void debounce_free(void) { + free(countdowns); + countdowns = NULL; + free(last_raw); + last_raw = NULL; +} + +void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) { + uint16_t now = timer_read(); + uint16_t elapsed16 = TIMER_DIFF_16(now, last_time); + last_time = now; + uint8_t elapsed = (elapsed16 > 255) ? 255 : elapsed16; + + uint8_t* countdown = countdowns; + + for (uint8_t row = 0; row < num_rows; ++row, ++countdown) { + matrix_row_t raw_row = raw[row]; + + if (raw_row != last_raw[row]) { + *countdown = DEBOUNCE; + last_raw[row] = raw_row; + } else if (*countdown > elapsed) { + *countdown -= elapsed; + } else if (*countdown) { + cooked[row] = raw_row; + *countdown = 0; + } + } +} + +bool debounce_active(void) { return true; } diff --git a/quantum/debounce/tests/rules.mk b/quantum/debounce/tests/rules.mk index e908dd6f67..8318b1c668 100644 --- a/quantum/debounce/tests/rules.mk +++ b/quantum/debounce/tests/rules.mk @@ -28,6 +28,11 @@ debounce_sym_defer_pk_SRC := $(DEBOUNCE_COMMON_SRC) \ $(QUANTUM_PATH)/debounce/sym_defer_pk.c \ $(QUANTUM_PATH)/debounce/tests/sym_defer_pk_tests.cpp +debounce_sym_defer_pr_DEFS := $(DEBOUNCE_COMMON_DEFS) +debounce_sym_defer_pr_SRC := $(DEBOUNCE_COMMON_SRC) \ + $(QUANTUM_PATH)/debounce/sym_defer_pr.c \ + $(QUANTUM_PATH)/debounce/tests/sym_defer_pr_tests.cpp + debounce_sym_eager_pk_DEFS := $(DEBOUNCE_COMMON_DEFS) debounce_sym_eager_pk_SRC := $(DEBOUNCE_COMMON_SRC) \ $(QUANTUM_PATH)/debounce/sym_eager_pk.c \ diff --git a/quantum/debounce/tests/sym_defer_pr_tests.cpp b/quantum/debounce/tests/sym_defer_pr_tests.cpp new file mode 100644 index 0000000000..bb3333cf7b --- /dev/null +++ b/quantum/debounce/tests/sym_defer_pr_tests.cpp @@ -0,0 +1,223 @@ +/* Copyright 2021 Simon Arlott + * + * 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 . + */ + +#include "gtest/gtest.h" + +#include "debounce_test_common.h" + +TEST_F(DebounceTest, OneKeyShort1) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + + {5, {}, {{0, 1, DOWN}}}, + /* 0ms delay (fast scan rate) */ + {5, {{0, 1, UP}}, {}}, + + {10, {}, {{0, 1, UP}}}, + }); + runEvents(); +} + +TEST_F(DebounceTest, OneKeyShort2) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + + {5, {}, {{0, 1, DOWN}}}, + /* 1ms delay */ + {6, {{0, 1, UP}}, {}}, + + {11, {}, {{0, 1, UP}}}, + }); + runEvents(); +} + +TEST_F(DebounceTest, OneKeyShort3) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + + {5, {}, {{0, 1, DOWN}}}, + /* 2ms delay */ + {7, {{0, 1, UP}}, {}}, + + {12, {}, {{0, 1, UP}}}, + }); + runEvents(); +} + +TEST_F(DebounceTest, OneKeyTooQuick1) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + /* Release key exactly on the debounce time */ + {5, {{0, 1, UP}}, {}}, + }); + runEvents(); +} + +TEST_F(DebounceTest, OneKeyTooQuick2) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + + {5, {}, {{0, 1, DOWN}}}, + {6, {{0, 1, UP}}, {}}, + + /* Press key exactly on the debounce time */ + {11, {{0, 1, DOWN}}, {}}, + }); + runEvents(); +} + +TEST_F(DebounceTest, OneKeyBouncing1) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + {1, {{0, 1, UP}}, {}}, + {2, {{0, 1, DOWN}}, {}}, + {3, {{0, 1, UP}}, {}}, + {4, {{0, 1, DOWN}}, {}}, + {5, {{0, 1, UP}}, {}}, + {6, {{0, 1, DOWN}}, {}}, + {11, {}, {{0, 1, DOWN}}}, /* 5ms after DOWN at time 7 */ + }); + runEvents(); +} + +TEST_F(DebounceTest, OneKeyBouncing2) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + {5, {}, {{0, 1, DOWN}}}, + {6, {{0, 1, UP}}, {}}, + {7, {{0, 1, DOWN}}, {}}, + {8, {{0, 1, UP}}, {}}, + {9, {{0, 1, DOWN}}, {}}, + {10, {{0, 1, UP}}, {}}, + {15, {}, {{0, 1, UP}}}, /* 5ms after UP at time 10 */ + }); + runEvents(); +} + +TEST_F(DebounceTest, OneKeyLong) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + + {5, {}, {{0, 1, DOWN}}}, + + {25, {{0, 1, UP}}, {}}, + + {30, {}, {{0, 1, UP}}}, + + {50, {{0, 1, DOWN}}, {}}, + + {55, {}, {{0, 1, DOWN}}}, + }); + runEvents(); +} + +TEST_F(DebounceTest, TwoKeysShort) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + {1, {{0, 2, DOWN}}, {}}, + + {6, {}, {{0, 1, DOWN}, {0, 2, DOWN}}}, + + {7, {{0, 1, UP}}, {}}, + {8, {{0, 2, UP}}, {}}, + + {13, {}, {{0, 1, UP}, {0, 2, UP}}}, + }); + runEvents(); +} + +TEST_F(DebounceTest, TwoKeysSimultaneous1) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}, {0, 2, DOWN}}, {}}, + + {5, {}, {{0, 1, DOWN}, {0, 2, DOWN}}}, + {6, {{0, 1, UP}, {0, 2, UP}}, {}}, + + {11, {}, {{0, 1, UP}, {0, 2, UP}}}, + }); + runEvents(); +} + +TEST_F(DebounceTest, TwoKeysSimultaneous2) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + {1, {{0, 2, DOWN}}, {}}, + + {6, {}, {{0, 1, DOWN}, {0, 2, DOWN}}}, + {7, {{0, 2, UP}}, {}}, + {9, {{0, 1, UP}}, {}}, + + // Debouncing loses the specific ordering -- both events report simultaneously. + {14, {}, {{0, 1, UP}, {0, 2, UP}}}, + }); + runEvents(); +} + +TEST_F(DebounceTest, OneKeyDelayedScan1) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + + /* Processing is very late */ + {300, {}, {{0, 1, DOWN}}}, + /* Immediately release key */ + {300, {{0, 1, UP}}, {}}, + + {305, {}, {{0, 1, UP}}}, + }); + time_jumps_ = true; + runEvents(); +} + +TEST_F(DebounceTest, OneKeyDelayedScan2) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + + /* Processing is very late */ + {300, {}, {{0, 1, DOWN}}}, + /* Release key after 1ms */ + {301, {{0, 1, UP}}, {}}, + + {306, {}, {{0, 1, UP}}}, + }); + time_jumps_ = true; + runEvents(); +} + +TEST_F(DebounceTest, OneKeyDelayedScan3) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + + /* Release key before debounce expires */ + {300, {{0, 1, UP}}, {}}, + }); + time_jumps_ = true; + runEvents(); +} + +TEST_F(DebounceTest, OneKeyDelayedScan4) { + addEvents({ /* Time, Inputs, Outputs */ + {0, {{0, 1, DOWN}}, {}}, + + /* Processing is a bit late */ + {50, {}, {{0, 1, DOWN}}}, + /* Release key after 1ms */ + {51, {{0, 1, UP}}, {}}, + + {56, {}, {{0, 1, UP}}}, + }); + time_jumps_ = true; + runEvents(); +} diff --git a/quantum/debounce/tests/testlist.mk b/quantum/debounce/tests/testlist.mk index c54c45aa63..f7bd520698 100644 --- a/quantum/debounce/tests/testlist.mk +++ b/quantum/debounce/tests/testlist.mk @@ -1,6 +1,7 @@ TEST_LIST += \ debounce_sym_defer_g \ debounce_sym_defer_pk \ + debounce_sym_defer_pr \ debounce_sym_eager_pk \ debounce_sym_eager_pr \ debounce_asym_eager_defer_pk -- cgit v1.2.3 From eadfcb9a40e3812ed66b484b9302ca5ff5e9b852 Mon Sep 17 00:00:00 2001 From: QMK Bot Date: Sun, 26 Dec 2021 19:34:15 -0800 Subject: Format code according to conventions (#15590) --- quantum/debounce/tests/sym_defer_pr_tests.cpp | 45 ++++++++++++++++++--------- 1 file changed, 30 insertions(+), 15 deletions(-) (limited to 'quantum/debounce') diff --git a/quantum/debounce/tests/sym_defer_pr_tests.cpp b/quantum/debounce/tests/sym_defer_pr_tests.cpp index bb3333cf7b..417e1f4ca2 100644 --- a/quantum/debounce/tests/sym_defer_pr_tests.cpp +++ b/quantum/debounce/tests/sym_defer_pr_tests.cpp @@ -19,7 +19,8 @@ #include "debounce_test_common.h" TEST_F(DebounceTest, OneKeyShort1) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, {5, {}, {{0, 1, DOWN}}}, @@ -32,7 +33,8 @@ TEST_F(DebounceTest, OneKeyShort1) { } TEST_F(DebounceTest, OneKeyShort2) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, {5, {}, {{0, 1, DOWN}}}, @@ -45,7 +47,8 @@ TEST_F(DebounceTest, OneKeyShort2) { } TEST_F(DebounceTest, OneKeyShort3) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, {5, {}, {{0, 1, DOWN}}}, @@ -58,7 +61,8 @@ TEST_F(DebounceTest, OneKeyShort3) { } TEST_F(DebounceTest, OneKeyTooQuick1) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, /* Release key exactly on the debounce time */ {5, {{0, 1, UP}}, {}}, @@ -67,7 +71,8 @@ TEST_F(DebounceTest, OneKeyTooQuick1) { } TEST_F(DebounceTest, OneKeyTooQuick2) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, {5, {}, {{0, 1, DOWN}}}, @@ -80,7 +85,8 @@ TEST_F(DebounceTest, OneKeyTooQuick2) { } TEST_F(DebounceTest, OneKeyBouncing1) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, {1, {{0, 1, UP}}, {}}, {2, {{0, 1, DOWN}}, {}}, @@ -94,7 +100,8 @@ TEST_F(DebounceTest, OneKeyBouncing1) { } TEST_F(DebounceTest, OneKeyBouncing2) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, {5, {}, {{0, 1, DOWN}}}, {6, {{0, 1, UP}}, {}}, @@ -108,7 +115,8 @@ TEST_F(DebounceTest, OneKeyBouncing2) { } TEST_F(DebounceTest, OneKeyLong) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, {5, {}, {{0, 1, DOWN}}}, @@ -125,7 +133,8 @@ TEST_F(DebounceTest, OneKeyLong) { } TEST_F(DebounceTest, TwoKeysShort) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, {1, {{0, 2, DOWN}}, {}}, @@ -140,7 +149,8 @@ TEST_F(DebounceTest, TwoKeysShort) { } TEST_F(DebounceTest, TwoKeysSimultaneous1) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}, {0, 2, DOWN}}, {}}, {5, {}, {{0, 1, DOWN}, {0, 2, DOWN}}}, @@ -152,7 +162,8 @@ TEST_F(DebounceTest, TwoKeysSimultaneous1) { } TEST_F(DebounceTest, TwoKeysSimultaneous2) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, {1, {{0, 2, DOWN}}, {}}, @@ -167,7 +178,8 @@ TEST_F(DebounceTest, TwoKeysSimultaneous2) { } TEST_F(DebounceTest, OneKeyDelayedScan1) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, /* Processing is very late */ @@ -182,7 +194,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan1) { } TEST_F(DebounceTest, OneKeyDelayedScan2) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, /* Processing is very late */ @@ -197,7 +210,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan2) { } TEST_F(DebounceTest, OneKeyDelayedScan3) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, /* Release key before debounce expires */ @@ -208,7 +222,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan3) { } TEST_F(DebounceTest, OneKeyDelayedScan4) { - addEvents({ /* Time, Inputs, Outputs */ + addEvents({ + /* Time, Inputs, Outputs */ {0, {{0, 1, DOWN}}, {}}, /* Processing is a bit late */ -- cgit v1.2.3 From 63646e8906e062d1c1de3925cba70c4e3426a855 Mon Sep 17 00:00:00 2001 From: QMK Bot Date: Sat, 12 Feb 2022 10:29:31 -0800 Subject: Format code according to conventions (#16322) --- quantum/debounce/sym_defer_g.c | 2 +- quantum/debounce/sym_defer_pr.c | 4 +++- quantum/debounce/sym_eager_pk.c | 2 +- quantum/debounce/tests/debounce_test_common.cpp | 4 +++- 4 files changed, 8 insertions(+), 4 deletions(-) (limited to 'quantum/debounce') diff --git a/quantum/debounce/sym_defer_g.c b/quantum/debounce/sym_defer_g.c index 8cac1c37f9..47450992a4 100644 --- a/quantum/debounce/sym_defer_g.c +++ b/quantum/debounce/sym_defer_g.c @@ -45,6 +45,6 @@ void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool } void debounce_free(void) {} -#else // no debouncing. +#else // no debouncing. # include "none.c" #endif diff --git a/quantum/debounce/sym_defer_pr.c b/quantum/debounce/sym_defer_pr.c index 8b33acc6a2..ce24f0922f 100644 --- a/quantum/debounce/sym_defer_pr.c +++ b/quantum/debounce/sym_defer_pr.c @@ -69,4 +69,6 @@ void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool } } -bool debounce_active(void) { return true; } +bool debounce_active(void) { + return true; +} diff --git a/quantum/debounce/sym_eager_pk.c b/quantum/debounce/sym_eager_pk.c index deec463649..fe3e88bb06 100644 --- a/quantum/debounce/sym_eager_pk.c +++ b/quantum/debounce/sym_eager_pk.c @@ -131,7 +131,7 @@ static void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[], ui if (*debounce_pointer == DEBOUNCE_ELAPSED) { *debounce_pointer = DEBOUNCE; counters_need_update = true; - existing_row ^= col_mask; // flip the bit. + existing_row ^= col_mask; // flip the bit. } } debounce_pointer++; diff --git a/quantum/debounce/tests/debounce_test_common.cpp b/quantum/debounce/tests/debounce_test_common.cpp index f9414e571d..0d5a7bb766 100644 --- a/quantum/debounce/tests/debounce_test_common.cpp +++ b/quantum/debounce/tests/debounce_test_common.cpp @@ -31,7 +31,9 @@ void set_time(uint32_t t); void advance_time(uint32_t ms); } -void DebounceTest::addEvents(std::initializer_list events) { events_.insert(events_.end(), events.begin(), events.end()); } +void DebounceTest::addEvents(std::initializer_list events) { + events_.insert(events_.end(), events.begin(), events.end()); +} void DebounceTest::runEvents() { /* Run the test multiple times, from 1kHz to 10kHz scan rate */ -- cgit v1.2.3