* Add fast_timer_t that is 16-bit or 32-bit based on architecture A 16-bit timer will overflow sooner but be faster to compare on AVR. * Avoid 8-bit timer overflows in debounce algorithms Count down remaining elapsed time instead of trying to do 8-bit timer comparisons. Add a "none" implementation that is automatically used if DEBOUNCE is 0 otherwise it will break the _pk/_pr count down. * Avoid unnecessary polling of the entire matrix in sym_eager_pk The matrix only needs to be updated when a debounce timer expires. * Avoid unnecessary polling of the entire matrix in sym_eager_pr The matrix only needs to be updated when a debounce timer expires. The use of the "needed_update" variable is trying to do what "matrix_need_update" was added to fix but didn't work because it only applied when all keys finished debouncing. * Fix sym_defer_g timing inconsistency compared to other debounce algorithms DEBOUNCE=5 should process the key after 5ms, not 6ms * Add debounce testspull/12689/head
@ -0,0 +1,31 @@ | |||
/* 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 <http://www.gnu.org/licenses/>. | |||
*/ | |||
#include "matrix.h" | |||
#include "quantum.h" | |||
#include <stdlib.h> | |||
void debounce_init(uint8_t num_rows) {} | |||
void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) { | |||
for (int i = 0; i < num_rows; i++) { | |||
cooked[i] = raw[i]; | |||
} | |||
} | |||
bool debounce_active(void) { return false; } | |||
void debounce_free(void) {} |
@ -0,0 +1,229 @@ | |||
/* 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 <http://www.gnu.org/licenses/>. | |||
*/ | |||
#include "gtest/gtest.h" | |||
#include "debounce_test_common.h" | |||
#include <algorithm> | |||
#include <iomanip> | |||
#include <sstream> | |||
extern "C" { | |||
#include "quantum.h" | |||
#include "timer.h" | |||
#include "debounce.h" | |||
void set_time(uint32_t t); | |||
void advance_time(uint32_t ms); | |||
} | |||
void DebounceTest::addEvents(std::initializer_list<DebounceTestEvent> events) { | |||
events_.insert(events_.end(), events.begin(), events.end()); | |||
} | |||
void DebounceTest::runEvents() { | |||
/* Run the test multiple times, from 1kHz to 10kHz scan rate */ | |||
for (extra_iterations_ = 0; extra_iterations_ < 10; extra_iterations_++) { | |||
if (time_jumps_) { | |||
/* Don't advance time smoothly, jump to the next event (some tests require this) */ | |||
auto_advance_time_ = false; | |||
runEventsInternal(); | |||
} else { | |||
/* Run the test with both smooth and irregular time; it must produce the same result */ | |||
auto_advance_time_ = true; | |||
runEventsInternal(); | |||
auto_advance_time_ = false; | |||
runEventsInternal(); | |||
} | |||
} | |||
} | |||
void DebounceTest::runEventsInternal() { | |||
fast_timer_t previous = 0; | |||
bool first = true; | |||
/* Initialise keyboard with start time (offset to avoid testing at 0) and all keys UP */ | |||
debounce_init(MATRIX_ROWS); | |||
set_time(time_offset_); | |||
std::fill(std::begin(input_matrix_), std::end(input_matrix_), 0); | |||
std::fill(std::begin(output_matrix_), std::end(output_matrix_), 0); | |||
for (auto &event : events_) { | |||
if (!auto_advance_time_) { | |||
/* Jump to the next event */ | |||
set_time(time_offset_ + event.time_); | |||
} else if (!first && event.time_ == previous + 1) { | |||
/* This event immediately follows the previous one, don't make extra debounce() calls */ | |||
advance_time(1); | |||
} else { | |||
/* Fast forward to the time for this event, calling debounce() with no changes */ | |||
ASSERT_LT((time_offset_ + event.time_) - timer_read_fast(), 60000) << "Test tries to advance more than 1 minute of time"; | |||
while (timer_read_fast() != time_offset_ + event.time_) { | |||
runDebounce(false); | |||
checkCookedMatrix(false, "debounce() modified cooked matrix"); | |||
advance_time(1); | |||
} | |||
} | |||
first = false; | |||
previous = event.time_; | |||
/* Prepare input matrix */ | |||
for (auto &input : event.inputs_) { | |||
matrixUpdate(input_matrix_, "input", input); | |||
} | |||
/* Call debounce */ | |||
runDebounce(!event.inputs_.empty()); | |||
/* Prepare output matrix */ | |||
for (auto &output : event.outputs_) { | |||
matrixUpdate(output_matrix_, "output", output); | |||
} | |||
/* Check output matrix has expected change events */ | |||
for (auto &output : event.outputs_) { | |||
EXPECT_EQ(!!(cooked_matrix_[output.row_] & (1U << output.col_)), directionValue(output.direction_)) | |||
<< "Missing event at " << strTime() | |||
<< " expected key " << output.row_ << "," << output.col_ << " " << directionLabel(output.direction_) | |||
<< "\ninput_matrix: changed=" << !event.inputs_.empty() << "\n" << strMatrix(input_matrix_) | |||
<< "\nexpected_matrix:\n" << strMatrix(output_matrix_) | |||
<< "\nactual_matrix:\n" << strMatrix(cooked_matrix_); | |||
} | |||
/* Check output matrix has no other changes */ | |||
checkCookedMatrix(!event.inputs_.empty(), "debounce() cooked matrix does not match expected output matrix"); | |||
/* Perform some extra iterations of the matrix scan with no changes */ | |||
for (int i = 0; i < extra_iterations_; i++) { | |||
runDebounce(false); | |||
checkCookedMatrix(false, "debounce() modified cooked matrix"); | |||
} | |||
} | |||
/* Check that no further changes happen for 1 minute */ | |||
for (int i = 0; i < 60000; i++) { | |||
runDebounce(false); | |||
checkCookedMatrix(false, "debounce() modified cooked matrix"); | |||
advance_time(1); | |||
} | |||
debounce_free(); | |||
} | |||
void DebounceTest::runDebounce(bool changed) { | |||
std::copy(std::begin(input_matrix_), std::end(input_matrix_), std::begin(raw_matrix_)); | |||
std::copy(std::begin(output_matrix_), std::end(output_matrix_), std::begin(cooked_matrix_)); | |||
debounce(raw_matrix_, cooked_matrix_, MATRIX_ROWS, changed); | |||
if (!std::equal(std::begin(input_matrix_), std::end(input_matrix_), std::begin(raw_matrix_))) { | |||
FAIL() << "Fatal error: debounce() modified raw matrix at " << strTime() | |||
<< "\ninput_matrix: changed=" << changed << "\n" << strMatrix(input_matrix_) | |||
<< "\nraw_matrix:\n" << strMatrix(raw_matrix_); | |||
} | |||
} | |||
void DebounceTest::checkCookedMatrix(bool changed, const std::string &error_message) { | |||
if (!std::equal(std::begin(output_matrix_), std::end(output_matrix_), std::begin(cooked_matrix_))) { | |||
FAIL() << "Unexpected event: " << error_message << " at " << strTime() | |||
<< "\ninput_matrix: changed=" << changed << "\n" << strMatrix(input_matrix_) | |||
<< "\nexpected_matrix:\n" << strMatrix(output_matrix_) | |||
<< "\nactual_matrix:\n" << strMatrix(cooked_matrix_); | |||
} | |||
} | |||
std::string DebounceTest::strTime() { | |||
std::stringstream text; | |||
text << "time " << (timer_read_fast() - time_offset_) | |||
<< " (extra_iterations=" << extra_iterations_ | |||
<< ", auto_advance_time=" << auto_advance_time_ << ")"; | |||
return text.str(); | |||
} | |||
std::string DebounceTest::strMatrix(matrix_row_t matrix[]) { | |||
std::stringstream text; | |||
text << "\t" << std::setw(3) << ""; | |||
for (int col = 0; col < MATRIX_COLS; col++) { | |||
text << " " << std::setw(2) << col; | |||
} | |||
text << "\n"; | |||
for (int row = 0; row < MATRIX_ROWS; row++) { | |||
text << "\t" << std::setw(2) << row << ":"; | |||
for (int col = 0; col < MATRIX_COLS; col++) { | |||
text << ((matrix[row] & (1U << col)) ? " XX" : " __"); | |||
} | |||
text << "\n"; | |||
} | |||
return text.str(); | |||
} | |||
bool DebounceTest::directionValue(Direction direction) { | |||
switch (direction) { | |||
case DOWN: | |||
return true; | |||
case UP: | |||
return false; | |||
} | |||
} | |||
std::string DebounceTest::directionLabel(Direction direction) { | |||
switch (direction) { | |||
case DOWN: | |||
return "DOWN"; | |||
case UP: | |||
return "UP"; | |||
} | |||
} | |||
/* Modify a matrix and verify that events always specify a change */ | |||
void DebounceTest::matrixUpdate(matrix_row_t matrix[], const std::string &name, const MatrixTestEvent &event) { | |||
ASSERT_NE(!!(matrix[event.row_] & (1U << event.col_)), directionValue(event.direction_)) | |||
<< "Test " << name << " at " << strTime() | |||
<< " sets key " << event.row_ << "," << event.col_ << " " << directionLabel(event.direction_) | |||
<< " but it is already " << directionLabel(event.direction_) | |||
<< "\n" << name << "_matrix:\n" << strMatrix(matrix); | |||
switch (event.direction_) { | |||
case DOWN: | |||
matrix[event.row_] |= (1U << event.col_); | |||
break; | |||
case UP: | |||
matrix[event.row_] &= ~(1U << event.col_); | |||
break; | |||
} | |||
} | |||
DebounceTestEvent::DebounceTestEvent(fast_timer_t time, | |||
std::initializer_list<MatrixTestEvent> inputs, | |||
std::initializer_list<MatrixTestEvent> outputs) | |||
: time_(time), inputs_(inputs), outputs_(outputs) { | |||
} | |||
MatrixTestEvent::MatrixTestEvent(int row, int col, Direction direction) | |||
: row_(row), col_(col), direction_(direction) { | |||
} |
@ -0,0 +1,83 @@ | |||
/* 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 <http://www.gnu.org/licenses/>. | |||
*/ | |||
#include "gtest/gtest.h" | |||
#include <initializer_list> | |||
#include <list> | |||
#include <string> | |||
extern "C" { | |||
#include "quantum.h" | |||
#include "timer.h" | |||
} | |||
enum Direction { | |||
DOWN, | |||
UP, | |||
}; | |||
class MatrixTestEvent { | |||
public: | |||
MatrixTestEvent(int row, int col, Direction direction); | |||
const int row_; | |||
const int col_; | |||
const Direction direction_; | |||
}; | |||
class DebounceTestEvent { | |||
public: | |||
// 0, {{0, 1, DOWN}}, {{0, 1, DOWN}}) | |||
DebounceTestEvent(fast_timer_t time, | |||
std::initializer_list<MatrixTestEvent> inputs, | |||
std::initializer_list<MatrixTestEvent> outputs); | |||
const fast_timer_t time_; | |||
const std::list<MatrixTestEvent> inputs_; | |||
const std::list<MatrixTestEvent> outputs_; | |||
}; | |||
class DebounceTest : public ::testing::Test { | |||
protected: | |||
void addEvents(std::initializer_list<DebounceTestEvent> events); | |||
void runEvents(); | |||
fast_timer_t time_offset_ = 7777; | |||
bool time_jumps_ = false; | |||
private: | |||
static bool directionValue(Direction direction); | |||
static std::string directionLabel(Direction direction); | |||
void runEventsInternal(); | |||
void runDebounce(bool changed); | |||
void checkCookedMatrix(bool changed, const std::string &error_message); | |||
void matrixUpdate(matrix_row_t matrix[], const std::string &name, const MatrixTestEvent &event); | |||
std::string strTime(); | |||
std::string strMatrix(matrix_row_t matrix[]); | |||
std::list<DebounceTestEvent> events_; | |||
matrix_row_t input_matrix_[MATRIX_ROWS]; | |||
matrix_row_t raw_matrix_[MATRIX_ROWS]; | |||
matrix_row_t cooked_matrix_[MATRIX_ROWS]; | |||
matrix_row_t output_matrix_[MATRIX_ROWS]; | |||
int extra_iterations_; | |||
bool auto_advance_time_; | |||
}; |
@ -0,0 +1,39 @@ | |||
# 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 <http://www.gnu.org/licenses/>. | |||
DEBOUNCE_COMMON_DEFS := -DMATRIX_ROWS=4 -DMATRIX_COLS=10 -DDEBOUNCE=5 | |||
DEBOUNCE_COMMON_SRC := $(QUANTUM_PATH)/debounce/tests/debounce_test_common.cpp \ | |||
$(TMK_PATH)/common/test/timer.c | |||
debounce_sym_defer_g_DEFS := $(DEBOUNCE_COMMON_DEFS) | |||
debounce_sym_defer_g_SRC := $(DEBOUNCE_COMMON_SRC) \ | |||
$(QUANTUM_PATH)/debounce/sym_defer_g.c \ | |||
$(QUANTUM_PATH)/debounce/tests/sym_defer_g_tests.cpp | |||
debounce_sym_defer_pk_DEFS := $(DEBOUNCE_COMMON_DEFS) | |||
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_eager_pk_DEFS := $(DEBOUNCE_COMMON_DEFS) | |||
debounce_sym_eager_pk_SRC := $(DEBOUNCE_COMMON_SRC) \ | |||
$(QUANTUM_PATH)/debounce/sym_eager_pk.c \ | |||
$(QUANTUM_PATH)/debounce/tests/sym_eager_pk_tests.cpp | |||
debounce_sym_eager_pr_DEFS := $(DEBOUNCE_COMMON_DEFS) | |||
debounce_sym_eager_pr_SRC := $(DEBOUNCE_COMMON_SRC) \ | |||
$(QUANTUM_PATH)/debounce/sym_eager_pr.c \ | |||
$(QUANTUM_PATH)/debounce/tests/sym_eager_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 <http://www.gnu.org/licenses/>. | |||
*/ | |||
#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}}, {}}, | |||
{5, {}, {}}, | |||
{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, 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(); | |||
} |
@ -0,0 +1,225 @@ | |||
/* 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 <http://www.gnu.org/licenses/>. | |||
*/ | |||
#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}}, {}}, | |||
{5, {}, {{0, 1, DOWN}}}, | |||
{6, {}, {{0, 2, DOWN}}}, | |||
{7, {{0, 1, UP}}, {}}, | |||
{8, {{0, 2, UP}}, {}}, | |||
{12, {}, {{0, 1, UP}}}, | |||
{13, {}, {{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}}, {}}, | |||
{5, {}, {{0, 1, DOWN}}}, | |||
{6, {{0, 1, UP}}, {{0, 2, DOWN}}}, | |||
{7, {{0, 2, UP}}, {}}, | |||
{11, {}, {{0, 1, UP}}}, | |||
{12, {}, {{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(); | |||
} |
@ -0,0 +1,237 @@ | |||
/* 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 <http://www.gnu.org/licenses/>. | |||
*/ | |||
#include "gtest/gtest.h" | |||
#include "debounce_test_common.h" | |||
TEST_F(DebounceTest, OneKeyShort1) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key again after 1ms delay (debounce has not yet finished) */ | |||
{6, {{0, 1, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyShort2) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key again after 2ms delay (debounce has not yet finished) */ | |||
{7, {{0, 1, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyShort3) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key again after 3ms delay (debounce has not yet finished) */ | |||
{8, {{0, 1, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyShort4) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key again after 4ms delay (debounce has not yet finished) */ | |||
{9, {{0, 1, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyShort5) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key again after 5ms delay (debounce has finished) */ | |||
{10, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyShort6) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key after after 6ms delay (debounce has finished) */ | |||
{11, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyBouncing1) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{2, {{0, 1, DOWN}}, {}}, | |||
{3, {{0, 1, UP}}, {}}, | |||
{4, {{0, 1, DOWN}}, {}}, | |||
{5, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
/* Press key again after 1ms delay (debounce has not yet finished) */ | |||
{6, {{0, 1, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyBouncing2) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Change twice in the same time period */ | |||
{1, {{0, 1, UP}}, {}}, | |||
{1, {{0, 1, DOWN}}, {}}, | |||
/* Change three times in the same time period */ | |||
{2, {{0, 1, UP}}, {}}, | |||
{2, {{0, 1, DOWN}}, {}}, | |||
{2, {{0, 1, UP}}, {}}, | |||
/* Change three times in the same time period */ | |||
{3, {{0, 1, DOWN}}, {}}, | |||
{3, {{0, 1, UP}}, {}}, | |||
{3, {{0, 1, DOWN}}, {}}, | |||
/* Change twice in the same time period */ | |||
{4, {{0, 1, UP}}, {}}, | |||
{4, {{0, 1, DOWN}}, {}}, | |||
{5, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
/* Press key again after 1ms delay (debounce has not yet finished) */ | |||
{6, {{0, 1, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyLong) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{25, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
{50, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, TwoKeysShort) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{2, {{0, 2, DOWN}}, {{0, 2, DOWN}}}, | |||
{3, {{0, 2, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key again after 1ms delay (debounce has not yet finished) */ | |||
{6, {{0, 1, DOWN}}, {}}, | |||
{7, {}, {{0, 2, UP}}}, | |||
/* Press key again after 1ms delay (debounce has not yet finished) */ | |||
{9, {{0, 2, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
{12, {}, {{0, 2, DOWN}}}, /* 5ms after UP at time 7 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyDelayedScan1) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Processing is very late but the change will now be accepted */ | |||
{300, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
}); | |||
time_jumps_ = true; | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyDelayedScan2) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Processing is very late but the change will now be accepted even with a 1 scan delay */ | |||
{300, {}, {}}, | |||
{300, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
}); | |||
time_jumps_ = true; | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyDelayedScan3) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Processing is very late but the change will now be accepted even with a 1ms delay */ | |||
{300, {}, {}}, | |||
{301, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
}); | |||
time_jumps_ = true; | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyDelayedScan4) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Processing is a bit late but the change will now be accepted */ | |||
{50, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
}); | |||
time_jumps_ = true; | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyDelayedScan5) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Processing is very late but the change will now be accepted even with a 1 scan delay */ | |||
{50, {}, {}}, | |||
{50, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
}); | |||
time_jumps_ = true; | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyDelayedScan6) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Processing is very late but the change will now be accepted even with a 1ms delay */ | |||
{50, {}, {}}, | |||
{51, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
}); | |||
time_jumps_ = true; | |||
runEvents(); | |||
} |
@ -0,0 +1,280 @@ | |||
/* 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 <http://www.gnu.org/licenses/>. | |||
*/ | |||
#include "gtest/gtest.h" | |||
#include "debounce_test_common.h" | |||
TEST_F(DebounceTest, OneKeyShort1) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key again after 1ms delay (debounce has not yet finished) */ | |||
{6, {{0, 1, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyShort2) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key again after 2ms delay (debounce has not yet finished) */ | |||
{7, {{0, 1, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyShort3) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key again after 3ms delay (debounce has not yet finished) */ | |||
{8, {{0, 1, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyShort4) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key again after 4ms delay (debounce has not yet finished) */ | |||
{9, {{0, 1, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyShort5) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key again after 5ms delay (debounce has finished) */ | |||
{10, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyShort6) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key after after 6ms delay (debounce has finished) */ | |||
{11, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyBouncing1) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{2, {{0, 1, DOWN}}, {}}, | |||
{3, {{0, 1, UP}}, {}}, | |||
{4, {{0, 1, DOWN}}, {}}, | |||
{5, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
/* Press key again after 1ms delay (debounce has not yet finished) */ | |||
{6, {{0, 1, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyBouncing2) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Change twice in the same time period */ | |||
{1, {{0, 1, UP}}, {}}, | |||
{1, {{0, 1, DOWN}}, {}}, | |||
/* Change three times in the same time period */ | |||
{2, {{0, 1, UP}}, {}}, | |||
{2, {{0, 1, DOWN}}, {}}, | |||
{2, {{0, 1, UP}}, {}}, | |||
/* Change three times in the same time period */ | |||
{3, {{0, 1, DOWN}}, {}}, | |||
{3, {{0, 1, UP}}, {}}, | |||
{3, {{0, 1, DOWN}}, {}}, | |||
/* Change twice in the same time period */ | |||
{4, {{0, 1, UP}}, {}}, | |||
{4, {{0, 1, DOWN}}, {}}, | |||
{5, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
/* Press key again after 1ms delay (debounce has not yet finished) */ | |||
{6, {{0, 1, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyLong) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{25, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
{50, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, TwoRowsShort) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
{2, {{2, 0, DOWN}}, {{2, 0, DOWN}}}, | |||
{3, {{2, 0, UP}}, {}}, | |||
{5, {}, {{0, 1, UP}}}, | |||
/* Press key again after 1ms delay (debounce has not yet finished) */ | |||
{6, {{0, 1, DOWN}}, {}}, | |||
{7, {}, {{2, 0, UP}}}, | |||
/* Press key again after 1ms delay (debounce has not yet finished) */ | |||
{9, {{2, 0, DOWN}}, {}}, | |||
{10, {}, {{0, 1, DOWN}}}, /* 5ms after UP at time 5 */ | |||
{12, {}, {{2, 0, DOWN}}}, /* 5ms after UP at time 7 */ | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, TwoKeysOverlap) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
{1, {{0, 1, UP}}, {}}, | |||
/* Press a second key during the first debounce */ | |||
{2, {{0, 2, DOWN}}, {}}, | |||
/* Key registers as soon as debounce finishes, 5ms after time 0 */ | |||
{5, {}, {{0, 1, UP}, {0, 2, DOWN}}}, | |||
{6, {{0, 1, DOWN}}, {}}, | |||
/* Key registers as soon as debounce finishes, 5ms after time 5 */ | |||
{10, {}, {{0, 1, DOWN}}}, | |||
/* Release both keys */ | |||
{11, {{0, 1, UP}}, {}}, | |||
{12, {{0, 2, UP}}, {}}, | |||
/* Keys register as soon as debounce finishes, 5ms after time 10 */ | |||
{15, {}, {{0, 1, UP}, {0, 2, UP}}}, | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, TwoKeysSimultaneous1) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}, {0, 2, DOWN}}, {{0, 1, DOWN}, {0, 2, DOWN}}}, | |||
{20, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
{21, {{0, 2, UP}}, {}}, | |||
/* Key registers as soon as debounce finishes, 5ms after time 20 */ | |||
{25, {}, {{0, 2, UP}}}, | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, TwoKeysSimultaneous2) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}, {0, 2, DOWN}}, {{0, 1, DOWN}, {0, 2, DOWN}}}, | |||
{20, {{0, 1, UP}, {0, 2, UP}}, {{0, 1, UP}, {0, 2, UP}}}, | |||
}); | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyDelayedScan1) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Processing is very late but the change will now be accepted */ | |||
{300, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
}); | |||
time_jumps_ = true; | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyDelayedScan2) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Processing is very late but the change will now be accepted even with a 1 scan delay */ | |||
{300, {}, {}}, | |||
{300, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
}); | |||
time_jumps_ = true; | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyDelayedScan3) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Processing is very late but the change will now be accepted even with a 1ms delay */ | |||
{300, {}, {}}, | |||
{301, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
}); | |||
time_jumps_ = true; | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyDelayedScan4) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Processing is a bit late but the change will now be accepted */ | |||
{50, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
}); | |||
time_jumps_ = true; | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyDelayedScan5) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Processing is very late but the change will now be accepted even with a 1 scan delay */ | |||
{50, {}, {}}, | |||
{50, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
}); | |||
time_jumps_ = true; | |||
runEvents(); | |||
} | |||
TEST_F(DebounceTest, OneKeyDelayedScan6) { | |||
addEvents({ /* Time, Inputs, Outputs */ | |||
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, | |||
/* Processing is very late but the change will now be accepted even with a 1ms delay */ | |||
{50, {}, {}}, | |||
{51, {{0, 1, UP}}, {{0, 1, UP}}}, | |||
}); | |||
time_jumps_ = true; | |||
runEvents(); | |||
} |
@ -0,0 +1,5 @@ | |||
TEST_LIST += \ | |||
debounce_sym_defer_g \ | |||
debounce_sym_defer_pk \ | |||
debounce_sym_eager_pk \ | |||
debounce_sym_eager_pr |
@ -0,0 +1,19 @@ | |||
/* 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 <http://www.gnu.org/licenses/>. | |||
*/ | |||
#pragma once | |||
// The platform is 32-bit, so prefer 32-bit timers to avoid overflow | |||
#define FAST_TIMER_T_SIZE 32 |
@ -0,0 +1,19 @@ | |||
/* 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 <http://www.gnu.org/licenses/>. | |||
*/ | |||
#pragma once | |||
// The platform is 8-bit, so prefer 16-bit timers to reduce code size | |||
#define FAST_TIMER_T_SIZE 16 |
@ -0,0 +1,19 @@ | |||
/* 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 <http://www.gnu.org/licenses/>. | |||
*/ | |||
#pragma once | |||
// The platform is 32-bit, so prefer 32-bit timers to avoid overflow | |||
#define FAST_TIMER_T_SIZE 32 |