g1smo
/
qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Manually format develop (#15003)

master
Joel Challis 2021-11-01 19:18:33 +00:00 committed by GitHub
parent ee371c1295
commit 92385e30cd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
30 changed files with 595 additions and 523 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
drivers/sensors/adns5050.c
View File

@ -17,7 +17,6 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "adns5050.h" #include "adns5050.h"
#include "wait.h" #include "wait.h"
#include "debug.h" #include "debug.h"
@ -61,13 +60,9 @@ void adns_sync(void) {
writePinHigh(ADNS_CS_PIN); writePinHigh(ADNS_CS_PIN);
} }
void adns_cs_select(void) { void adns_cs_select(void) { writePinLow(ADNS_CS_PIN); }
writePinLow(ADNS_CS_PIN);
}
void adns_cs_deselect(void) { void adns_cs_deselect(void) { writePinHigh(ADNS_CS_PIN); }
writePinHigh(ADNS_CS_PIN);
}
uint8_t adns_serial_read(void) { uint8_t adns_serial_read(void) {
setPinInput(ADNS_SDIO_PIN); setPinInput(ADNS_SDIO_PIN);
@ -180,9 +175,7 @@ int8_t convert_twoscomp(uint8_t data) {
} }
// Don't forget to use the definitions for CPI in the header file. // Don't forget to use the definitions for CPI in the header file.
void adns_set_cpi(uint8_t cpi) { void adns_set_cpi(uint8_t cpi) { adns_write_reg(REG_MOUSE_CONTROL2, cpi); }
adns_write_reg(REG_MOUSE_CONTROL2, cpi);
}
bool adns_check_signature(void) { bool adns_check_signature(void) {
uint8_t pid = adns_read_reg(REG_PRODUCT_ID); uint8_t pid = adns_read_reg(REG_PRODUCT_ID);

13
drivers/sensors/adns9800.c
View File

@ -80,12 +80,9 @@
extern const uint8_t firmware_data[]; extern const uint8_t firmware_data[];
void adns_spi_start(void){ void adns_spi_start(void) { spi_start(SPI_SS_PIN, false, SPI_MODE, SPI_DIVISOR); }
spi_start(SPI_SS_PIN, false, SPI_MODE, SPI_DIVISOR);
}
void adns_write(uint8_t reg_addr, uint8_t data) { void adns_write(uint8_t reg_addr, uint8_t data) {
adns_spi_start(); adns_spi_start();
spi_write(reg_addr | MSB1); spi_write(reg_addr | MSB1);
spi_write(data); spi_write(data);
@ -94,7 +91,6 @@ void adns_write(uint8_t reg_addr, uint8_t data){
} }
uint8_t adns_read(uint8_t reg_addr) { uint8_t adns_read(uint8_t reg_addr) {
adns_spi_start(); adns_spi_start();
spi_write(reg_addr & 0x7f); spi_write(reg_addr & 0x7f);
uint8_t data = spi_read(); uint8_t data = spi_read();
@ -105,7 +101,6 @@ uint8_t adns_read(uint8_t reg_addr){
} }
void adns_init() { void adns_init() {
setPinOutput(SPI_SS_PIN); setPinOutput(SPI_SS_PIN);
spi_init(); spi_init();
@ -170,19 +165,16 @@ void adns_set_config(config_adns_t config) {
} }
static int16_t convertDeltaToInt(uint8_t high, uint8_t low) { static int16_t convertDeltaToInt(uint8_t high, uint8_t low) {
// join bytes into twos compliment // join bytes into twos compliment
uint16_t twos_comp = (high << 8) | low; uint16_t twos_comp = (high << 8) | low;
// convert twos comp to int // convert twos comp to int
if (twos_comp & 0x8000) if (twos_comp & 0x8000) return -1 * (~twos_comp + 1);
return -1 * (~twos_comp + 1);
return twos_comp; return twos_comp;
} }
report_adns_t adns_get_report(void) { report_adns_t adns_get_report(void) {
report_adns_t report = {0, 0}; report_adns_t report = {0, 0};
adns_spi_start(); adns_spi_start();
@ -195,7 +187,6 @@ report_adns_t adns_get_report(void) {
uint8_t motion = spi_read(); uint8_t motion = spi_read();
if (motion & 0x80) { if (motion & 0x80) {
// clear observation register // clear observation register
spi_read(); spi_read();

3
drivers/sensors/pmw3360.h
View File

@ -66,8 +66,6 @@ typedef struct {
int8_t mdy; int8_t mdy;
} report_pmw_t; } report_pmw_t;
bool spi_start_adv(void); bool spi_start_adv(void);
void spi_stop_adv(void); void spi_stop_adv(void);
spi_status_t spi_write_adv(uint8_t reg_addr, uint8_t data); spi_status_t spi_write_adv(uint8_t reg_addr, uint8_t data);
@ -79,7 +77,6 @@ void pmw_upload_firmware(void);
bool pmw_check_signature(void); bool pmw_check_signature(void);
report_pmw_t pmw_read_burst(void); report_pmw_t pmw_read_burst(void);
#define degToRad(angleInDegrees) ((angleInDegrees)*M_PI / 180.0) #define degToRad(angleInDegrees) ((angleInDegrees)*M_PI / 180.0)
#define radToDeg(angleInRadians) ((angleInRadians)*180.0 / M_PI) #define radToDeg(angleInRadians) ((angleInRadians)*180.0 / M_PI)
#define constrain(amt, low, high) ((amt) < (low) ? (low) : ((amt) > (high) ? (high) : (amt))) #define constrain(amt, low, high) ((amt) < (low) ? (low) : ((amt) > (high) ? (high) : (amt)))

37
quantum/action.c
View File

@ -821,7 +821,8 @@ void register_code(uint8_t code) {
} }
#endif #endif
else if IS_KEY (code) { else if
IS_KEY(code) {
// TODO: should push command_proc out of this block? // TODO: should push command_proc out of this block?
if (command_proc(code)) return; if (command_proc(code)) return;
@ -851,19 +852,21 @@ void register_code(uint8_t code) {
add_key(code); add_key(code);
send_keyboard_report(); send_keyboard_report();
} }
} else if IS_MOD (code) { }
else if
IS_MOD(code) {
add_mods(MOD_BIT(code)); add_mods(MOD_BIT(code));
send_keyboard_report(); send_keyboard_report();
} }
#ifdef EXTRAKEY_ENABLE #ifdef EXTRAKEY_ENABLE
else if IS_SYSTEM (code) { else if
host_system_send(KEYCODE2SYSTEM(code)); IS_SYSTEM(code) { host_system_send(KEYCODE2SYSTEM(code)); }
} else if IS_CONSUMER (code) { else if
host_consumer_send(KEYCODE2CONSUMER(code)); IS_CONSUMER(code) { host_consumer_send(KEYCODE2CONSUMER(code)); }
}
#endif #endif
#ifdef MOUSEKEY_ENABLE #ifdef MOUSEKEY_ENABLE
else if IS_MOUSEKEY (code) { else if
IS_MOUSEKEY(code) {
mousekey_on(code); mousekey_on(code);
mousekey_send(); mousekey_send();
} }
@ -911,19 +914,23 @@ void unregister_code(uint8_t code) {
} }
#endif #endif
else if IS_KEY (code) { else if
IS_KEY(code) {
del_key(code); del_key(code);
send_keyboard_report(); send_keyboard_report();
} else if IS_MOD (code) { }
else if
IS_MOD(code) {
del_mods(MOD_BIT(code)); del_mods(MOD_BIT(code));
send_keyboard_report(); send_keyboard_report();
} else if IS_SYSTEM (code) {
host_system_send(0);
} else if IS_CONSUMER (code) {
host_consumer_send(0);
} }
else if
IS_SYSTEM(code) { host_system_send(0); }
else if
IS_CONSUMER(code) { host_consumer_send(0); }
#ifdef MOUSEKEY_ENABLE #ifdef MOUSEKEY_ENABLE
else if IS_MOUSEKEY (code) { else if
IS_MOUSEKEY(code) {
mousekey_off(code); mousekey_off(code);
mousekey_send(); mousekey_send();
} }

12
quantum/action_tapping.c
View File

@ -212,7 +212,11 @@ bool process_tapping(keyrecord_t *keyp) {
if (tapping_key.tap.count > 1) { if (tapping_key.tap.count > 1) {
debug("Tapping: Start new tap with releasing last tap(>1).\n"); debug("Tapping: Start new tap with releasing last tap(>1).\n");
// unregister key // unregister key
process_record(&(keyrecord_t){.tap = tapping_key.tap, .event.key = tapping_key.event.key, .event.time = event.time, .event.pressed = false, process_record(&(keyrecord_t){
.tap = tapping_key.tap,
.event.key = tapping_key.event.key,
.event.time = event.time,
.event.pressed = false,
# ifdef COMBO_ENABLE # ifdef COMBO_ENABLE
.keycode = tapping_key.keycode, .keycode = tapping_key.keycode,
# endif # endif
@ -254,7 +258,11 @@ bool process_tapping(keyrecord_t *keyp) {
if (tapping_key.tap.count > 1) { if (tapping_key.tap.count > 1) {
debug("Tapping: Start new tap with releasing last timeout tap(>1).\n"); debug("Tapping: Start new tap with releasing last timeout tap(>1).\n");
// unregister key // unregister key
process_record(&(keyrecord_t){.tap = tapping_key.tap, .event.key = tapping_key.event.key, .event.time = event.time, .event.pressed = false, process_record(&(keyrecord_t){
.tap = tapping_key.tap,
.event.key = tapping_key.event.key,
.event.time = event.time,
.event.pressed = false,
# ifdef COMBO_ENABLE # ifdef COMBO_ENABLE
.keycode = tapping_key.keycode, .keycode = tapping_key.keycode,
# endif # endif

64
quantum/debounce/tests/asym_eager_defer_pk_tests.cpp
View File

@ -19,7 +19,8 @@
#include "debounce_test_common.h" #include "debounce_test_common.h"
TEST_F(DebounceTest, OneKeyShort1) { TEST_F(DebounceTest, OneKeyShort1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Release key after 1ms delay */ /* Release key after 1ms delay */
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -43,7 +44,8 @@ TEST_F(DebounceTest, OneKeyShort1) {
} }
TEST_F(DebounceTest, OneKeyShort2) { TEST_F(DebounceTest, OneKeyShort2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Release key after 2ms delay */ /* Release key after 2ms delay */
{2, {{0, 1, UP}}, {}}, {2, {{0, 1, UP}}, {}},
@ -58,7 +60,8 @@ TEST_F(DebounceTest, OneKeyShort2) {
} }
TEST_F(DebounceTest, OneKeyShort3) { TEST_F(DebounceTest, OneKeyShort3) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Release key after 3ms delay */ /* Release key after 3ms delay */
{3, {{0, 1, UP}}, {}}, {3, {{0, 1, UP}}, {}},
@ -73,7 +76,8 @@ TEST_F(DebounceTest, OneKeyShort3) {
} }
TEST_F(DebounceTest, OneKeyShort4) { TEST_F(DebounceTest, OneKeyShort4) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Release key after 4ms delay */ /* Release key after 4ms delay */
{4, {{0, 1, UP}}, {}}, {4, {{0, 1, UP}}, {}},
@ -88,7 +92,8 @@ TEST_F(DebounceTest, OneKeyShort4) {
} }
TEST_F(DebounceTest, OneKeyShort5) { TEST_F(DebounceTest, OneKeyShort5) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Release key after 5ms delay */ /* Release key after 5ms delay */
@ -102,7 +107,8 @@ TEST_F(DebounceTest, OneKeyShort5) {
} }
TEST_F(DebounceTest, OneKeyShort6) { TEST_F(DebounceTest, OneKeyShort6) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Release key after 6ms delay */ /* Release key after 6ms delay */
@ -116,7 +122,8 @@ TEST_F(DebounceTest, OneKeyShort6) {
} }
TEST_F(DebounceTest, OneKeyShort7) { TEST_F(DebounceTest, OneKeyShort7) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Release key after 7ms delay */ /* Release key after 7ms delay */
@ -130,7 +137,8 @@ TEST_F(DebounceTest, OneKeyShort7) {
} }
TEST_F(DebounceTest, OneKeyShort8) { TEST_F(DebounceTest, OneKeyShort8) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Release key after 1ms delay */ /* Release key after 1ms delay */
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -145,7 +153,8 @@ TEST_F(DebounceTest, OneKeyShort8) {
} }
TEST_F(DebounceTest, OneKeyShort9) { TEST_F(DebounceTest, OneKeyShort9) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Release key after 1ms delay */ /* Release key after 1ms delay */
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -159,7 +168,8 @@ TEST_F(DebounceTest, OneKeyShort9) {
} }
TEST_F(DebounceTest, OneKeyBouncing1) { TEST_F(DebounceTest, OneKeyBouncing1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
{2, {{0, 1, DOWN}}, {}}, {2, {{0, 1, DOWN}}, {}},
@ -185,7 +195,8 @@ TEST_F(DebounceTest, OneKeyBouncing1) {
} }
TEST_F(DebounceTest, OneKeyBouncing2) { TEST_F(DebounceTest, OneKeyBouncing2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Change twice in the same time period */ /* Change twice in the same time period */
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -217,7 +228,8 @@ TEST_F(DebounceTest, OneKeyBouncing2) {
} }
TEST_F(DebounceTest, OneKeyLong) { TEST_F(DebounceTest, OneKeyLong) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{25, {{0, 1, UP}}, {}}, {25, {{0, 1, UP}}, {}},
@ -236,7 +248,8 @@ TEST_F(DebounceTest, OneKeyLong) {
} }
TEST_F(DebounceTest, TwoKeysShort) { TEST_F(DebounceTest, TwoKeysShort) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 2, DOWN}}, {{0, 2, DOWN}}}, {1, {{0, 2, DOWN}}, {{0, 2, DOWN}}},
/* Release key after 2ms delay */ /* Release key after 2ms delay */
@ -254,9 +267,9 @@ TEST_F(DebounceTest, TwoKeysShort) {
runEvents(); runEvents();
} }
TEST_F(DebounceTest, OneKeyDelayedScan1) { TEST_F(DebounceTest, OneKeyDelayedScan1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late, immediately release key */ /* Processing is very late, immediately release key */
@ -269,7 +282,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan1) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan2) { TEST_F(DebounceTest, OneKeyDelayedScan2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late, immediately release key */ /* Processing is very late, immediately release key */
@ -283,7 +297,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan2) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan3) { TEST_F(DebounceTest, OneKeyDelayedScan3) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late */ /* Processing is very late */
@ -298,7 +313,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan3) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan4) { TEST_F(DebounceTest, OneKeyDelayedScan4) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late */ /* Processing is very late */
@ -314,7 +330,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan4) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan5) { TEST_F(DebounceTest, OneKeyDelayedScan5) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{5, {{0, 1, UP}}, {}}, {5, {{0, 1, UP}}, {}},
@ -329,7 +346,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan5) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan6) { TEST_F(DebounceTest, OneKeyDelayedScan6) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{5, {{0, 1, UP}}, {}}, {5, {{0, 1, UP}}, {}},
@ -345,7 +363,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan6) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan7) { TEST_F(DebounceTest, OneKeyDelayedScan7) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{5, {{0, 1, UP}}, {}}, {5, {{0, 1, UP}}, {}},
@ -358,7 +377,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan7) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan8) { TEST_F(DebounceTest, OneKeyDelayedScan8) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is a bit late */ /* Processing is a bit late */

40
quantum/debounce/tests/debounce_test_common.cpp
View File

@ -31,9 +31,7 @@ void set_time(uint32_t t);
void advance_time(uint32_t ms); void advance_time(uint32_t ms);
} }
void DebounceTest::addEvents(std::initializer_list<DebounceTestEvent> events) { void DebounceTest::addEvents(std::initializer_list<DebounceTestEvent> events) { events_.insert(events_.end(), events.begin(), events.end()); }
events_.insert(events_.end(), events.begin(), events.end());
}
void DebounceTest::runEvents() { void DebounceTest::runEvents() {
/* Run the test multiple times, from 1kHz to 10kHz scan rate */ /* Run the test multiple times, from 1kHz to 10kHz scan rate */
@ -98,12 +96,7 @@ void DebounceTest::runEventsInternal() {
/* Check output matrix has expected change events */ /* Check output matrix has expected change events */
for (auto &output : event.outputs_) { for (auto &output : event.outputs_) {
EXPECT_EQ(!!(cooked_matrix_[output.row_] & (1U << output.col_)), directionValue(output.direction_)) 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_);
<< "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 */ /* Check output matrix has no other changes */
@ -133,27 +126,20 @@ void DebounceTest::runDebounce(bool changed) {
debounce(raw_matrix_, cooked_matrix_, MATRIX_ROWS, changed); debounce(raw_matrix_, cooked_matrix_, MATRIX_ROWS, changed);
if (!std::equal(std::begin(input_matrix_), std::end(input_matrix_), std::begin(raw_matrix_))) { if (!std::equal(std::begin(input_matrix_), std::end(input_matrix_), std::begin(raw_matrix_))) {
FAIL() << "Fatal error: debounce() modified raw matrix at " << strTime() FAIL() << "Fatal error: debounce() modified raw matrix at " << strTime() << "\ninput_matrix: changed=" << changed << "\n" << strMatrix(input_matrix_) << "\nraw_matrix:\n" << strMatrix(raw_matrix_);
<< "\ninput_matrix: changed=" << changed << "\n" << strMatrix(input_matrix_)
<< "\nraw_matrix:\n" << strMatrix(raw_matrix_);
} }
} }
void DebounceTest::checkCookedMatrix(bool changed, const std::string &error_message) { 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_))) { if (!std::equal(std::begin(output_matrix_), std::end(output_matrix_), std::begin(cooked_matrix_))) {
FAIL() << "Unexpected event: " << error_message << " at " << strTime() 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_);
<< "\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::string DebounceTest::strTime() {
std::stringstream text; std::stringstream text;
text << "time " << (timer_read_fast() - time_offset_) text << "time " << (timer_read_fast() - time_offset_) << " (extra_iterations=" << extra_iterations_ << ", auto_advance_time=" << auto_advance_time_ << ")";
<< " (extra_iterations=" << extra_iterations_
<< ", auto_advance_time=" << auto_advance_time_ << ")";
return text.str(); return text.str();
} }
@ -201,11 +187,7 @@ std::string DebounceTest::directionLabel(Direction direction) {
/* Modify a matrix and verify that events always specify a change */ /* 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) { 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_)) 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);
<< "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_) { switch (event.direction_) {
case DOWN: case DOWN:
@ -218,12 +200,6 @@ void DebounceTest::matrixUpdate(matrix_row_t matrix[], const std::string &name,
} }
} }
DebounceTestEvent::DebounceTestEvent(fast_timer_t time, DebounceTestEvent::DebounceTestEvent(fast_timer_t time, std::initializer_list<MatrixTestEvent> inputs, std::initializer_list<MatrixTestEvent> outputs) : time_(time), inputs_(inputs), outputs_(outputs) {}
std::initializer_list<MatrixTestEvent> inputs,
std::initializer_list<MatrixTestEvent> outputs)
: time_(time), inputs_(inputs), outputs_(outputs) {
}
MatrixTestEvent::MatrixTestEvent(int row, int col, Direction direction) MatrixTestEvent::MatrixTestEvent(int row, int col, Direction direction) : row_(row), col_(col), direction_(direction) {}
: row_(row), col_(col), direction_(direction) {
}

4
quantum/debounce/tests/debounce_test_common.h
View File

@ -42,9 +42,7 @@ public:
class DebounceTestEvent { class DebounceTestEvent {
public: public:
// 0, {{0, 1, DOWN}}, {{0, 1, DOWN}}) // 0, {{0, 1, DOWN}}, {{0, 1, DOWN}})
DebounceTestEvent(fast_timer_t time, DebounceTestEvent(fast_timer_t time, std::initializer_list<MatrixTestEvent> inputs, std::initializer_list<MatrixTestEvent> outputs);
std::initializer_list<MatrixTestEvent> inputs,
std::initializer_list<MatrixTestEvent> outputs);
const fast_timer_t time_; const fast_timer_t time_;
const std::list<MatrixTestEvent> inputs_; const std::list<MatrixTestEvent> inputs_;

45
quantum/debounce/tests/sym_defer_g_tests.cpp
View File

@ -19,7 +19,8 @@
#include "debounce_test_common.h" #include "debounce_test_common.h"
TEST_F(DebounceTest, OneKeyShort1) { TEST_F(DebounceTest, OneKeyShort1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}}}, {5, {}, {{0, 1, DOWN}}},
@ -32,7 +33,8 @@ TEST_F(DebounceTest, OneKeyShort1) {
} }
TEST_F(DebounceTest, OneKeyShort2) { TEST_F(DebounceTest, OneKeyShort2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}}}, {5, {}, {{0, 1, DOWN}}},
@ -45,7 +47,8 @@ TEST_F(DebounceTest, OneKeyShort2) {
} }
TEST_F(DebounceTest, OneKeyShort3) { TEST_F(DebounceTest, OneKeyShort3) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}}}, {5, {}, {{0, 1, DOWN}}},
@ -58,7 +61,8 @@ TEST_F(DebounceTest, OneKeyShort3) {
} }
TEST_F(DebounceTest, OneKeyTooQuick1) { TEST_F(DebounceTest, OneKeyTooQuick1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
/* Release key exactly on the debounce time */ /* Release key exactly on the debounce time */
{5, {{0, 1, UP}}, {}}, {5, {{0, 1, UP}}, {}},
@ -67,7 +71,8 @@ TEST_F(DebounceTest, OneKeyTooQuick1) {
} }
TEST_F(DebounceTest, OneKeyTooQuick2) { TEST_F(DebounceTest, OneKeyTooQuick2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}}}, {5, {}, {{0, 1, DOWN}}},
@ -80,7 +85,8 @@ TEST_F(DebounceTest, OneKeyTooQuick2) {
} }
TEST_F(DebounceTest, OneKeyBouncing1) { TEST_F(DebounceTest, OneKeyBouncing1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
{2, {{0, 1, DOWN}}, {}}, {2, {{0, 1, DOWN}}, {}},
@ -94,7 +100,8 @@ TEST_F(DebounceTest, OneKeyBouncing1) {
} }
TEST_F(DebounceTest, OneKeyBouncing2) { TEST_F(DebounceTest, OneKeyBouncing2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}}}, {5, {}, {{0, 1, DOWN}}},
{6, {{0, 1, UP}}, {}}, {6, {{0, 1, UP}}, {}},
@ -108,7 +115,8 @@ TEST_F(DebounceTest, OneKeyBouncing2) {
} }
TEST_F(DebounceTest, OneKeyLong) { TEST_F(DebounceTest, OneKeyLong) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}}}, {5, {}, {{0, 1, DOWN}}},
@ -125,7 +133,8 @@ TEST_F(DebounceTest, OneKeyLong) {
} }
TEST_F(DebounceTest, TwoKeysShort) { TEST_F(DebounceTest, TwoKeysShort) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{1, {{0, 2, DOWN}}, {}}, {1, {{0, 2, DOWN}}, {}},
@ -140,7 +149,8 @@ TEST_F(DebounceTest, TwoKeysShort) {
} }
TEST_F(DebounceTest, TwoKeysSimultaneous1) { TEST_F(DebounceTest, TwoKeysSimultaneous1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}, {0, 2, DOWN}}, {}}, {0, {{0, 1, DOWN}, {0, 2, DOWN}}, {}},
{5, {}, {{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) { TEST_F(DebounceTest, TwoKeysSimultaneous2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{1, {{0, 2, DOWN}}, {}}, {1, {{0, 2, DOWN}}, {}},
@ -167,7 +178,8 @@ TEST_F(DebounceTest, TwoKeysSimultaneous2) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan1) { TEST_F(DebounceTest, OneKeyDelayedScan1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
/* Processing is very late */ /* Processing is very late */
@ -182,7 +194,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan1) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan2) { TEST_F(DebounceTest, OneKeyDelayedScan2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
/* Processing is very late */ /* Processing is very late */
@ -197,7 +210,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan2) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan3) { TEST_F(DebounceTest, OneKeyDelayedScan3) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
/* Release key before debounce expires */ /* Release key before debounce expires */
@ -208,7 +222,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan3) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan4) { TEST_F(DebounceTest, OneKeyDelayedScan4) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
/* Processing is a bit late */ /* Processing is a bit late */

45
quantum/debounce/tests/sym_defer_pk_tests.cpp
View File

@ -19,7 +19,8 @@
#include "debounce_test_common.h" #include "debounce_test_common.h"
TEST_F(DebounceTest, OneKeyShort1) { TEST_F(DebounceTest, OneKeyShort1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}}}, {5, {}, {{0, 1, DOWN}}},
@ -32,7 +33,8 @@ TEST_F(DebounceTest, OneKeyShort1) {
} }
TEST_F(DebounceTest, OneKeyShort2) { TEST_F(DebounceTest, OneKeyShort2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}}}, {5, {}, {{0, 1, DOWN}}},
@ -45,7 +47,8 @@ TEST_F(DebounceTest, OneKeyShort2) {
} }
TEST_F(DebounceTest, OneKeyShort3) { TEST_F(DebounceTest, OneKeyShort3) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}}}, {5, {}, {{0, 1, DOWN}}},
@ -58,7 +61,8 @@ TEST_F(DebounceTest, OneKeyShort3) {
} }
TEST_F(DebounceTest, OneKeyTooQuick1) { TEST_F(DebounceTest, OneKeyTooQuick1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
/* Release key exactly on the debounce time */ /* Release key exactly on the debounce time */
{5, {{0, 1, UP}}, {}}, {5, {{0, 1, UP}}, {}},
@ -67,7 +71,8 @@ TEST_F(DebounceTest, OneKeyTooQuick1) {
} }
TEST_F(DebounceTest, OneKeyTooQuick2) { TEST_F(DebounceTest, OneKeyTooQuick2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}}}, {5, {}, {{0, 1, DOWN}}},
@ -80,7 +85,8 @@ TEST_F(DebounceTest, OneKeyTooQuick2) {
} }
TEST_F(DebounceTest, OneKeyBouncing1) { TEST_F(DebounceTest, OneKeyBouncing1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
{2, {{0, 1, DOWN}}, {}}, {2, {{0, 1, DOWN}}, {}},
@ -94,7 +100,8 @@ TEST_F(DebounceTest, OneKeyBouncing1) {
} }
TEST_F(DebounceTest, OneKeyBouncing2) { TEST_F(DebounceTest, OneKeyBouncing2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}}}, {5, {}, {{0, 1, DOWN}}},
{6, {{0, 1, UP}}, {}}, {6, {{0, 1, UP}}, {}},
@ -108,7 +115,8 @@ TEST_F(DebounceTest, OneKeyBouncing2) {
} }
TEST_F(DebounceTest, OneKeyLong) { TEST_F(DebounceTest, OneKeyLong) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}}}, {5, {}, {{0, 1, DOWN}}},
@ -125,7 +133,8 @@ TEST_F(DebounceTest, OneKeyLong) {
} }
TEST_F(DebounceTest, TwoKeysShort) { TEST_F(DebounceTest, TwoKeysShort) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{1, {{0, 2, DOWN}}, {}}, {1, {{0, 2, DOWN}}, {}},
@ -142,7 +151,8 @@ TEST_F(DebounceTest, TwoKeysShort) {
} }
TEST_F(DebounceTest, TwoKeysSimultaneous1) { TEST_F(DebounceTest, TwoKeysSimultaneous1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}, {0, 2, DOWN}}, {}}, {0, {{0, 1, DOWN}, {0, 2, DOWN}}, {}},
{5, {}, {{0, 1, DOWN}, {0, 2, DOWN}}}, {5, {}, {{0, 1, DOWN}, {0, 2, DOWN}}},
@ -154,7 +164,8 @@ TEST_F(DebounceTest, TwoKeysSimultaneous1) {
} }
TEST_F(DebounceTest, TwoKeysSimultaneous2) { TEST_F(DebounceTest, TwoKeysSimultaneous2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
{1, {{0, 2, DOWN}}, {}}, {1, {{0, 2, DOWN}}, {}},
@ -169,7 +180,8 @@ TEST_F(DebounceTest, TwoKeysSimultaneous2) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan1) { TEST_F(DebounceTest, OneKeyDelayedScan1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
/* Processing is very late */ /* Processing is very late */
@ -184,7 +196,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan1) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan2) { TEST_F(DebounceTest, OneKeyDelayedScan2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
/* Processing is very late */ /* Processing is very late */
@ -199,7 +212,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan2) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan3) { TEST_F(DebounceTest, OneKeyDelayedScan3) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
/* Release key before debounce expires */ /* Release key before debounce expires */
@ -210,7 +224,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan3) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan4) { TEST_F(DebounceTest, OneKeyDelayedScan4) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {}}, {0, {{0, 1, DOWN}}, {}},
/* Processing is a bit late */ /* Processing is a bit late */

48
quantum/debounce/tests/sym_eager_pk_tests.cpp
View File

@ -19,7 +19,8 @@
#include "debounce_test_common.h" #include "debounce_test_common.h"
TEST_F(DebounceTest, OneKeyShort1) { TEST_F(DebounceTest, OneKeyShort1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -32,7 +33,8 @@ TEST_F(DebounceTest, OneKeyShort1) {
} }
TEST_F(DebounceTest, OneKeyShort2) { TEST_F(DebounceTest, OneKeyShort2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -45,7 +47,8 @@ TEST_F(DebounceTest, OneKeyShort2) {
} }
TEST_F(DebounceTest, OneKeyShort3) { TEST_F(DebounceTest, OneKeyShort3) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -58,7 +61,8 @@ TEST_F(DebounceTest, OneKeyShort3) {
} }
TEST_F(DebounceTest, OneKeyShort4) { TEST_F(DebounceTest, OneKeyShort4) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -71,7 +75,8 @@ TEST_F(DebounceTest, OneKeyShort4) {
} }
TEST_F(DebounceTest, OneKeyShort5) { TEST_F(DebounceTest, OneKeyShort5) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -83,7 +88,8 @@ TEST_F(DebounceTest, OneKeyShort5) {
} }
TEST_F(DebounceTest, OneKeyShort6) { TEST_F(DebounceTest, OneKeyShort6) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -95,7 +101,8 @@ TEST_F(DebounceTest, OneKeyShort6) {
} }
TEST_F(DebounceTest, OneKeyBouncing1) { TEST_F(DebounceTest, OneKeyBouncing1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
{2, {{0, 1, DOWN}}, {}}, {2, {{0, 1, DOWN}}, {}},
@ -110,7 +117,8 @@ TEST_F(DebounceTest, OneKeyBouncing1) {
} }
TEST_F(DebounceTest, OneKeyBouncing2) { TEST_F(DebounceTest, OneKeyBouncing2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Change twice in the same time period */ /* Change twice in the same time period */
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -135,7 +143,8 @@ TEST_F(DebounceTest, OneKeyBouncing2) {
} }
TEST_F(DebounceTest, OneKeyLong) { TEST_F(DebounceTest, OneKeyLong) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{25, {{0, 1, UP}}, {{0, 1, UP}}}, {25, {{0, 1, UP}}, {{0, 1, UP}}},
@ -146,7 +155,8 @@ TEST_F(DebounceTest, OneKeyLong) {
} }
TEST_F(DebounceTest, TwoKeysShort) { TEST_F(DebounceTest, TwoKeysShort) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
{2, {{0, 2, DOWN}}, {{0, 2, DOWN}}}, {2, {{0, 2, DOWN}}, {{0, 2, DOWN}}},
@ -167,7 +177,8 @@ TEST_F(DebounceTest, TwoKeysShort) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan1) { TEST_F(DebounceTest, OneKeyDelayedScan1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late but the change will now be accepted */ /* Processing is very late but the change will now be accepted */
@ -178,7 +189,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan1) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan2) { TEST_F(DebounceTest, OneKeyDelayedScan2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late but the change will now be accepted even with a 1 scan delay */ /* Processing is very late but the change will now be accepted even with a 1 scan delay */
@ -190,7 +202,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan2) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan3) { TEST_F(DebounceTest, OneKeyDelayedScan3) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late but the change will now be accepted even with a 1ms delay */ /* Processing is very late but the change will now be accepted even with a 1ms delay */
@ -202,7 +215,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan3) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan4) { TEST_F(DebounceTest, OneKeyDelayedScan4) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is a bit late but the change will now be accepted */ /* Processing is a bit late but the change will now be accepted */
@ -213,7 +227,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan4) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan5) { TEST_F(DebounceTest, OneKeyDelayedScan5) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late but the change will now be accepted even with a 1 scan delay */ /* Processing is very late but the change will now be accepted even with a 1 scan delay */
@ -225,7 +240,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan5) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan6) { TEST_F(DebounceTest, OneKeyDelayedScan6) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late but the change will now be accepted even with a 1ms delay */ /* Processing is very late but the change will now be accepted even with a 1ms delay */

57
quantum/debounce/tests/sym_eager_pr_tests.cpp
View File

@ -19,7 +19,8 @@
#include "debounce_test_common.h" #include "debounce_test_common.h"
TEST_F(DebounceTest, OneKeyShort1) { TEST_F(DebounceTest, OneKeyShort1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -32,7 +33,8 @@ TEST_F(DebounceTest, OneKeyShort1) {
} }
TEST_F(DebounceTest, OneKeyShort2) { TEST_F(DebounceTest, OneKeyShort2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -45,7 +47,8 @@ TEST_F(DebounceTest, OneKeyShort2) {
} }
TEST_F(DebounceTest, OneKeyShort3) { TEST_F(DebounceTest, OneKeyShort3) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -58,7 +61,8 @@ TEST_F(DebounceTest, OneKeyShort3) {
} }
TEST_F(DebounceTest, OneKeyShort4) { TEST_F(DebounceTest, OneKeyShort4) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -71,7 +75,8 @@ TEST_F(DebounceTest, OneKeyShort4) {
} }
TEST_F(DebounceTest, OneKeyShort5) { TEST_F(DebounceTest, OneKeyShort5) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -83,7 +88,8 @@ TEST_F(DebounceTest, OneKeyShort5) {
} }
TEST_F(DebounceTest, OneKeyShort6) { TEST_F(DebounceTest, OneKeyShort6) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -95,7 +101,8 @@ TEST_F(DebounceTest, OneKeyShort6) {
} }
TEST_F(DebounceTest, OneKeyBouncing1) { TEST_F(DebounceTest, OneKeyBouncing1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
{2, {{0, 1, DOWN}}, {}}, {2, {{0, 1, DOWN}}, {}},
@ -110,7 +117,8 @@ TEST_F(DebounceTest, OneKeyBouncing1) {
} }
TEST_F(DebounceTest, OneKeyBouncing2) { TEST_F(DebounceTest, OneKeyBouncing2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Change twice in the same time period */ /* Change twice in the same time period */
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
@ -135,7 +143,8 @@ TEST_F(DebounceTest, OneKeyBouncing2) {
} }
TEST_F(DebounceTest, OneKeyLong) { TEST_F(DebounceTest, OneKeyLong) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{25, {{0, 1, UP}}, {{0, 1, UP}}}, {25, {{0, 1, UP}}, {{0, 1, UP}}},
@ -146,7 +155,8 @@ TEST_F(DebounceTest, OneKeyLong) {
} }
TEST_F(DebounceTest, TwoRowsShort) { TEST_F(DebounceTest, TwoRowsShort) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
{2, {{2, 0, DOWN}}, {{2, 0, DOWN}}}, {2, {{2, 0, DOWN}}, {{2, 0, DOWN}}},
@ -167,7 +177,8 @@ TEST_F(DebounceTest, TwoRowsShort) {
} }
TEST_F(DebounceTest, TwoKeysOverlap) { TEST_F(DebounceTest, TwoKeysOverlap) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
{1, {{0, 1, UP}}, {}}, {1, {{0, 1, UP}}, {}},
/* Press a second key during the first debounce */ /* Press a second key during the first debounce */
@ -190,7 +201,8 @@ TEST_F(DebounceTest, TwoKeysOverlap) {
} }
TEST_F(DebounceTest, TwoKeysSimultaneous1) { TEST_F(DebounceTest, TwoKeysSimultaneous1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}, {0, 2, DOWN}}, {{0, 1, DOWN}, {0, 2, DOWN}}}, {0, {{0, 1, DOWN}, {0, 2, DOWN}}, {{0, 1, DOWN}, {0, 2, DOWN}}},
{20, {{0, 1, UP}}, {{0, 1, UP}}}, {20, {{0, 1, UP}}, {{0, 1, UP}}},
{21, {{0, 2, UP}}, {}}, {21, {{0, 2, UP}}, {}},
@ -202,7 +214,8 @@ TEST_F(DebounceTest, TwoKeysSimultaneous1) {
} }
TEST_F(DebounceTest, TwoKeysSimultaneous2) { TEST_F(DebounceTest, TwoKeysSimultaneous2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}, {0, 2, DOWN}}, {{0, 1, DOWN}, {0, 2, DOWN}}}, {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}}}, {20, {{0, 1, UP}, {0, 2, UP}}, {{0, 1, UP}, {0, 2, UP}}},
}); });
@ -210,7 +223,8 @@ TEST_F(DebounceTest, TwoKeysSimultaneous2) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan1) { TEST_F(DebounceTest, OneKeyDelayedScan1) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late but the change will now be accepted */ /* Processing is very late but the change will now be accepted */
@ -221,7 +235,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan1) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan2) { TEST_F(DebounceTest, OneKeyDelayedScan2) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late but the change will now be accepted even with a 1 scan delay */ /* Processing is very late but the change will now be accepted even with a 1 scan delay */
@ -233,7 +248,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan2) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan3) { TEST_F(DebounceTest, OneKeyDelayedScan3) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late but the change will now be accepted even with a 1ms delay */ /* Processing is very late but the change will now be accepted even with a 1ms delay */
@ -245,7 +261,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan3) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan4) { TEST_F(DebounceTest, OneKeyDelayedScan4) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is a bit late but the change will now be accepted */ /* Processing is a bit late but the change will now be accepted */
@ -256,7 +273,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan4) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan5) { TEST_F(DebounceTest, OneKeyDelayedScan5) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late but the change will now be accepted even with a 1 scan delay */ /* Processing is very late but the change will now be accepted even with a 1 scan delay */
@ -268,7 +286,8 @@ TEST_F(DebounceTest, OneKeyDelayedScan5) {
} }
TEST_F(DebounceTest, OneKeyDelayedScan6) { TEST_F(DebounceTest, OneKeyDelayedScan6) {
addEvents({ /* Time, Inputs, Outputs */ addEvents({
/* Time, Inputs, Outputs */
{0, {{0, 1, DOWN}}, {{0, 1, DOWN}}}, {0, {{0, 1, DOWN}}, {{0, 1, DOWN}}},
/* Processing is very late but the change will now be accepted even with a 1ms delay */ /* Processing is very late but the change will now be accepted even with a 1ms delay */

3
quantum/keymap_extras/keymap_steno.h
View File

@ -74,8 +74,7 @@ enum steno_keycodes {
}; };
#ifdef STENO_COMBINEDMAP #ifdef STENO_COMBINEDMAP
enum steno_combined_keycodes enum steno_combined_keycodes {
{
STN_S3 = QK_STENO_COMB, STN_S3 = QK_STENO_COMB,
STN_TKL, STN_TKL,
STN_PWL, STN_PWL,

74
quantum/process_keycode/process_combo.c
View File

@ -18,7 +18,6 @@
#include "process_combo.h" #include "process_combo.h"
#include "action_tapping.h" #include "action_tapping.h"
#ifdef COMBO_COUNT #ifdef COMBO_COUNT
__attribute__((weak)) combo_t key_combos[COMBO_COUNT]; __attribute__((weak)) combo_t key_combos[COMBO_COUNT];
uint16_t COMBO_LEN = COMBO_COUNT; uint16_t COMBO_LEN = COMBO_COUNT;
@ -70,17 +69,26 @@ static queued_combo_t combo_buffer[COMBO_BUFFER_LENGTH];
#define COMBO_KEY_POS ((keypos_t){.col = 254, .row = 254}) #define COMBO_KEY_POS ((keypos_t){.col = 254, .row = 254})
#ifndef EXTRA_SHORT_COMBOS #ifndef EXTRA_SHORT_COMBOS
/* flags are their own elements in combo_t struct. */ /* flags are their own elements in combo_t struct. */
# define COMBO_ACTIVE(combo) (combo->active) # define COMBO_ACTIVE(combo) (combo->active)
# define COMBO_DISABLED(combo) (combo->disabled) # define COMBO_DISABLED(combo) (combo->disabled)
# define COMBO_STATE(combo) (combo->state) # define COMBO_STATE(combo) (combo->state)
# define ACTIVATE_COMBO(combo) do {combo->active = true;}while(0) # define ACTIVATE_COMBO(combo) \
# define DEACTIVATE_COMBO(combo) do {combo->active = false;}while(0) do { \
# define DISABLE_COMBO(combo) do {combo->disabled = true;}while(0) combo->active = true; \
# define RESET_COMBO_STATE(combo) do { \ } while (0)
# define DEACTIVATE_COMBO(combo) \
do { \
combo->active = false; \
} while (0)
# define DISABLE_COMBO(combo) \
do { \
combo->disabled = true; \
} while (0)
# define RESET_COMBO_STATE(combo) \
do { \
combo->disabled = false; \ combo->disabled = false; \
combo->state = 0; \ combo->state = 0; \
} while (0) } while (0)
@ -90,16 +98,29 @@ static queued_combo_t combo_buffer[COMBO_BUFFER_LENGTH];
# define COMBO_DISABLED(combo) (combo->state & 0x40) # define COMBO_DISABLED(combo) (combo->state & 0x40)
# define COMBO_STATE(combo) (combo->state & 0x3F) # define COMBO_STATE(combo) (combo->state & 0x3F)
# define ACTIVATE_COMBO(combo) do {combo->state |= 0x80;}while(0) # define ACTIVATE_COMBO(combo) \
# define DEACTIVATE_COMBO(combo) do {combo->state &= ~0x80;}while(0) do { \
# define DISABLE_COMBO(combo) do {combo->state |= 0x40;}while(0) combo->state |= 0x80; \
# define RESET_COMBO_STATE(combo) do {combo->state &= ~0x7F;}while(0) } while (0)
# define DEACTIVATE_COMBO(combo) \
do { \
combo->state &= ~0x80; \
} while (0)
# define DISABLE_COMBO(combo) \
do { \
combo->state |= 0x40; \
} while (0)
# define RESET_COMBO_STATE(combo) \
do { \
combo->state &= ~0x7F; \
} while (0)
#endif #endif
static inline void release_combo(uint16_t combo_index, combo_t *combo) { static inline void release_combo(uint16_t combo_index, combo_t *combo) {
if (combo->keycode) { if (combo->keycode) {
keyrecord_t record = { keyrecord_t record = {
.event = { .event =
{
.key = COMBO_KEY_POS, .key = COMBO_KEY_POS,
.time = timer_read() | 1, .time = timer_read() | 1,
.pressed = false, .pressed = false,
@ -123,8 +144,7 @@ static inline bool _get_combo_must_hold(uint16_t combo_index, combo_t *combo) {
#elif defined(COMBO_MUST_HOLD_PER_COMBO) #elif defined(COMBO_MUST_HOLD_PER_COMBO)
return get_combo_must_hold(combo_index, combo); return get_combo_must_hold(combo_index, combo);
#elif defined(COMBO_MUST_HOLD_MODS) #elif defined(COMBO_MUST_HOLD_MODS)
return (KEYCODE_IS_MOD(combo->keycode) || return (KEYCODE_IS_MOD(combo->keycode) || (combo->keycode >= QK_MOMENTARY && combo->keycode <= QK_MOMENTARY_MAX));
(combo->keycode >= QK_MOMENTARY && combo->keycode <= QK_MOMENTARY_MAX));
#endif #endif
return false; return false;
} }
@ -144,7 +164,6 @@ static inline uint16_t _get_wait_time(uint16_t combo_index, combo_t *combo ) {
} }
static inline uint16_t _get_combo_term(uint16_t combo_index, combo_t *combo) { static inline uint16_t _get_combo_term(uint16_t combo_index, combo_t *combo) {
#if defined(COMBO_TERM_PER_COMBO) #if defined(COMBO_TERM_PER_COMBO)
return get_combo_term(combo_index, combo); return get_combo_term(combo_index, combo);
#endif #endif
@ -242,7 +261,9 @@ void apply_combo(uint16_t combo_index, combo_t *combo) {
/* Apply combo's result keycode to the last chord key of the combo and /* Apply combo's result keycode to the last chord key of the combo and
* disable the other keys. */ * disable the other keys. */
if (COMBO_DISABLED(combo)) { return; } if (COMBO_DISABLED(combo)) {
return;
}
// state to check against so we find the last key of the combo from the buffer // state to check against so we find the last key of the combo from the buffer
#if defined(EXTRA_EXTRA_LONG_COMBOS) #if defined(EXTRA_EXTRA_LONG_COMBOS)
@ -254,7 +275,6 @@ void apply_combo(uint16_t combo_index, combo_t *combo) {
#endif #endif
for (uint8_t key_buffer_i = 0; key_buffer_i < key_buffer_size; key_buffer_i++) { for (uint8_t key_buffer_i = 0; key_buffer_i < key_buffer_size; key_buffer_i++) {
queued_record_t *qrecord = &key_buffer[key_buffer_i]; queued_record_t *qrecord = &key_buffer[key_buffer_i];
keyrecord_t * record = &qrecord->record; keyrecord_t * record = &qrecord->record;
uint16_t keycode = qrecord->keycode; uint16_t keycode = qrecord->keycode;
@ -283,17 +303,13 @@ void apply_combo(uint16_t combo_index, combo_t *combo) {
// by making it a TICK event. // by making it a TICK event.
record->event.time = 0; record->event.time = 0;
} }
} }
drop_combo_from_buffer(combo_index); drop_combo_from_buffer(combo_index);
} }
static inline void apply_combos(void) { static inline void apply_combos(void) {
// Apply all buffered normal combos. // Apply all buffered normal combos.
for (uint8_t i = combo_buffer_read; for (uint8_t i = combo_buffer_read; i != combo_buffer_write; INCREMENT_MOD(i)) {
i != combo_buffer_write;
INCREMENT_MOD(i)) {
queued_combo_t *buffered_combo = &combo_buffer[i]; queued_combo_t *buffered_combo = &combo_buffer[i];
combo_t * combo = &key_combos[buffered_combo->combo_index]; combo_t * combo = &key_combos[buffered_combo->combo_index];
@ -369,10 +385,7 @@ static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *
// disable readied combos that overlap with this combo // disable readied combos that overlap with this combo
combo_t *drop = NULL; combo_t *drop = NULL;
for (uint8_t combo_buffer_i = combo_buffer_read; for (uint8_t combo_buffer_i = combo_buffer_read; combo_buffer_i != combo_buffer_write; INCREMENT_MOD(combo_buffer_i)) {
combo_buffer_i != combo_buffer_write;
INCREMENT_MOD(combo_buffer_i)) {
queued_combo_t *qcombo = &combo_buffer[combo_buffer_i]; queued_combo_t *qcombo = &combo_buffer[combo_buffer_i];
combo_t * buffered_combo = &key_combos[qcombo->combo_index]; combo_t * buffered_combo = &key_combos[qcombo->combo_index];
@ -387,7 +400,6 @@ static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *
INCREMENT_MOD(combo_buffer_read); INCREMENT_MOD(combo_buffer_read);
} }
} }
} }
if (drop != combo) { if (drop != combo) {
@ -401,7 +413,6 @@ static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *
longest_term = _get_wait_time(combo_index, combo); longest_term = _get_wait_time(combo_index, combo);
} }
} // if timer elapsed end } // if timer elapsed end
} }
} else { } else {
// chord releases // chord releases
@ -424,10 +435,7 @@ static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *
# endif # endif
} }
#endif #endif
} else if (COMBO_ACTIVE(combo) } else if (COMBO_ACTIVE(combo) && ONLY_ONE_KEY_IS_DOWN(COMBO_STATE(combo)) && KEY_NOT_YET_RELEASED(COMBO_STATE(combo), key_index)) {
&& ONLY_ONE_KEY_IS_DOWN(COMBO_STATE(combo))
&& KEY_NOT_YET_RELEASED(COMBO_STATE(combo), key_index)
) {
/* last key released */ /* last key released */
release_combo(combo_index, combo); release_combo(combo_index, combo);
key_is_part_of_combo = true; key_is_part_of_combo = true;
@ -435,9 +443,7 @@ static bool process_single_combo(combo_t *combo, uint16_t keycode, keyrecord_t *
#ifdef COMBO_PROCESS_KEY_RELEASE #ifdef COMBO_PROCESS_KEY_RELEASE
process_combo_key_release(combo_index, combo, key_index, keycode); process_combo_key_release(combo_index, combo, key_index, keycode);
#endif #endif
} else if (COMBO_ACTIVE(combo) } else if (COMBO_ACTIVE(combo) && KEY_NOT_YET_RELEASED(COMBO_STATE(combo), key_index)) {
&& KEY_NOT_YET_RELEASED(COMBO_STATE(combo), key_index)
) {
/* first or middle key released */ /* first or middle key released */
key_is_part_of_combo = true; key_is_part_of_combo = true;

3
quantum/process_keycode/process_steno.c
View File

@ -174,8 +174,7 @@ bool process_steno(uint16_t keycode, keyrecord_t *record) {
return false; return false;
#ifdef STENO_COMBINEDMAP #ifdef STENO_COMBINEDMAP
case QK_STENO_COMB ... QK_STENO_COMB_MAX: case QK_STENO_COMB ... QK_STENO_COMB_MAX: {
{
uint8_t result; uint8_t result;
result = process_steno(combinedmap_first[keycode - QK_STENO_COMB], record); result = process_steno(combinedmap_first[keycode - QK_STENO_COMB], record);
result &= process_steno(combinedmap_second[keycode - QK_STENO_COMB], record); result &= process_steno(combinedmap_second[keycode - QK_STENO_COMB], record);

33
quantum/rgb_matrix/animations/fractal_anim.h
View File

@ -25,30 +25,43 @@ static bool FRACTAL(effect_params_t* params) {
static bool led[MATRIX_ROWS][MATRIX_COLS]; static bool led[MATRIX_ROWS][MATRIX_COLS];
static uint32_t wait_timer = 0; static uint32_t wait_timer = 0;
if (wait_timer > g_rgb_timer) { return false; } if (wait_timer > g_rgb_timer) {
return false;
}
inline uint32_t interval(void) { return 3000 / scale16by8(qadd8(rgb_matrix_config.speed, 16), 16); } inline uint32_t interval(void) { return 3000 / scale16by8(qadd8(rgb_matrix_config.speed, 16), 16); }
RGB rgb = rgb_matrix_hsv_to_rgb(rgb_matrix_config.hsv); RGB rgb = rgb_matrix_hsv_to_rgb(rgb_matrix_config.hsv);
for (uint8_t h = 0; h < MATRIX_ROWS; ++h) { for (uint8_t h = 0; h < MATRIX_ROWS; ++h) {
for (uint8_t l = 0; l < MID_COL - 1; ++l) { // Light and move left columns outwards for (uint8_t l = 0; l < MID_COL - 1; ++l) { // Light and move left columns outwards
if (led[h][l]) { rgb_matrix_set_color(g_led_config.matrix_co[h][l], rgb.r, rgb.g, rgb.b); } if (led[h][l]) {
else { rgb_matrix_set_color(g_led_config.matrix_co[h][l], 0, 0, 0); } rgb_matrix_set_color(g_led_config.matrix_co[h][l], rgb.r, rgb.g, rgb.b);
} else {
rgb_matrix_set_color(g_led_config.matrix_co[h][l], 0, 0, 0);
}
led[h][l] = led[h][l + 1]; led[h][l] = led[h][l + 1];
} }
for (uint8_t r = MATRIX_COLS - 1; r > MID_COL; --r) { // Light and move right columns outwards for (uint8_t r = MATRIX_COLS - 1; r > MID_COL; --r) { // Light and move right columns outwards
if (led[h][r]) { rgb_matrix_set_color(g_led_config.matrix_co[h][r], rgb.r, rgb.g, rgb.b); } if (led[h][r]) {
else { rgb_matrix_set_color(g_led_config.matrix_co[h][r], 0, 0, 0); } rgb_matrix_set_color(g_led_config.matrix_co[h][r], rgb.r, rgb.g, rgb.b);
} else {
rgb_matrix_set_color(g_led_config.matrix_co[h][r], 0, 0, 0);
}
led[h][r] = led[h][r - 1]; led[h][r] = led[h][r - 1];
} }
// Light both middle columns // Light both middle columns
if (led[h][MID_COL]) { rgb_matrix_set_color(g_led_config.matrix_co[h][MID_COL], rgb.r, rgb.g, rgb.b); } if (led[h][MID_COL]) {
else { rgb_matrix_set_color(g_led_config.matrix_co[h][MID_COL], 0, 0, 0); } rgb_matrix_set_color(g_led_config.matrix_co[h][MID_COL], rgb.r, rgb.g, rgb.b);
if (led[h][MID_COL-1]) { rgb_matrix_set_color(g_led_config.matrix_co[h][MID_COL-1], rgb.r, rgb.g, rgb.b); } } else {
else { rgb_matrix_set_color(g_led_config.matrix_co[h][MID_COL-1], 0, 0, 0); } rgb_matrix_set_color(g_led_config.matrix_co[h][MID_COL], 0, 0, 0);
}
if (led[h][MID_COL - 1]) {
rgb_matrix_set_color(g_led_config.matrix_co[h][MID_COL - 1], rgb.r, rgb.g, rgb.b);
} else {
rgb_matrix_set_color(g_led_config.matrix_co[h][MID_COL - 1], 0, 0, 0);
}
// Generate new random fractal columns // Generate new random fractal columns
led[h][MID_COL] = led[h][MID_COL - 1] = (random8() & 3) ? false : true; led[h][MID_COL] = led[h][MID_COL - 1] = (random8() & 3) ? false : true;