From 81df54308687713371ed5fbf4947e38963c7867b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E3=83=95=E3=82=A3=E3=83=AB=E3=82=BF=E3=83=BC=E3=83=9A?= =?UTF-8?q?=E3=83=BC=E3=83=91=E3=83=BC?= <76888457+filterpaper@users.noreply.github.com> Date: Sun, 19 Oct 2025 10:14:37 +0800 Subject: [PATCH] Debounce: Deprecate num_rows parameter (#25632) --- docs/ChangeLog/20251130/PR25632.md | 4 + docs/custom_matrix.md | 4 +- keyboards/bpiphany/pegasushoof/2015/matrix.c | 202 ++++++----- keyboards/gboards/gergo/gergo.c | 3 + keyboards/gboards/gergo/gergo.h | 3 + keyboards/gboards/gergo/matrix.c | 315 +++++++++--------- .../gergoplex/keymaps/default/config.h | 3 + keyboards/gboards/gergoplex/matrix.c | 35 +- keyboards/halfcliff/matrix.c | 56 ++-- keyboards/handwired/owlet60/matrix.c | 144 ++++---- .../symmetric70_proto/matrix_debug/matrix.c | 42 ++- .../symmetric70_proto/matrix_fast/matrix.c | 4 +- keyboards/kakunpc/angel64/alpha/matrix.c | 156 ++++----- keyboards/kakunpc/angel64/rev1/matrix.c | 156 ++++----- keyboards/kakunpc/thedogkeyboard/matrix.c | 156 ++++----- keyboards/kbdmania/kmac/matrix.c | 32 +- keyboards/redscarf_iiplus/verb/matrix.c | 183 +++++----- keyboards/redscarf_iiplus/verc/matrix.c | 183 +++++----- keyboards/redscarf_iiplus/verd/matrix.c | 183 +++++----- keyboards/ymdk/sp64/keymaps/default/keymap.c | 3 + keyboards/ymdk/sp64/matrix.c | 169 +++++----- quantum/debounce.h | 5 +- quantum/debounce/asym_eager_defer_pk.c | 4 +- quantum/debounce/none.c | 6 +- quantum/debounce/sym_defer_g.c | 6 +- quantum/debounce/sym_defer_pk.c | 4 +- quantum/debounce/sym_defer_pr.c | 4 +- quantum/debounce/sym_eager_pk.c | 4 +- quantum/debounce/sym_eager_pr.c | 4 +- .../debounce/tests/debounce_test_common.cpp | 4 +- quantum/matrix.c | 6 +- quantum/matrix_common.c | 6 +- 32 files changed, 983 insertions(+), 1106 deletions(-) create mode 100644 docs/ChangeLog/20251130/PR25632.md mode change 100755 => 100644 keyboards/redscarf_iiplus/verb/matrix.c mode change 100755 => 100644 keyboards/redscarf_iiplus/verc/matrix.c diff --git a/docs/ChangeLog/20251130/PR25632.md b/docs/ChangeLog/20251130/PR25632.md new file mode 100644 index 0000000000..39136067b9 --- /dev/null +++ b/docs/ChangeLog/20251130/PR25632.md @@ -0,0 +1,4 @@ +# Changes Requiring User Action +## Debounce: Deprecate init and remove num_rows parameter [#25632](https://github.com/qmk/qmk_firmware/pull/25632) + +With dynamic memory allocation removed from all debounce implementations ([#25515](https://github.com/qmk/qmk_firmware/pull/25515)), the `num_rows` parameter has been removed from the `debounce_init()` and `debounce()` functions. The `MATRIX_ROWS_PER_HAND` is now used by default in every implementation. diff --git a/docs/custom_matrix.md b/docs/custom_matrix.md index ef206944e1..294b88bb0b 100644 --- a/docs/custom_matrix.md +++ b/docs/custom_matrix.md @@ -74,7 +74,7 @@ void matrix_init(void) { // TODO: initialize hardware and global matrix state here // Unless hardware debouncing - Init the configured debounce routine - debounce_init(MATRIX_ROWS); + debounce_init(); // This *must* be called for correct keyboard behavior matrix_init_kb(); @@ -86,7 +86,7 @@ uint8_t matrix_scan(void) { // TODO: add matrix scanning routine here // Unless hardware debouncing - use the configured debounce routine - changed = debounce(raw_matrix, matrix, MATRIX_ROWS, changed); + changed = debounce(raw_matrix, matrix, changed); // This *must* be called for correct keyboard behavior matrix_scan_kb(); diff --git a/keyboards/bpiphany/pegasushoof/2015/matrix.c b/keyboards/bpiphany/pegasushoof/2015/matrix.c index 6fc1fd6e9e..61135e5833 100644 --- a/keyboards/bpiphany/pegasushoof/2015/matrix.c +++ b/keyboards/bpiphany/pegasushoof/2015/matrix.c @@ -31,13 +31,17 @@ static matrix_row_t matrix[MATRIX_ROWS]; static matrix_row_t matrix_debouncing[MATRIX_ROWS]; static matrix_row_t read_cols(void); -static void select_row(uint8_t col); +static void select_row(uint8_t col); // user-defined overridable functions -__attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); } +__attribute__((weak)) void matrix_init_kb(void) { + matrix_init_user(); +} -__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); } +__attribute__((weak)) void matrix_scan_kb(void) { + matrix_scan_user(); +} __attribute__((weak)) void matrix_init_user(void) {} @@ -45,105 +49,125 @@ __attribute__((weak)) void matrix_scan_user(void) {} // helper functions -inline uint8_t matrix_rows(void) -{ - return MATRIX_ROWS; +inline uint8_t matrix_rows(void) { + return MATRIX_ROWS; } -inline uint8_t matrix_cols(void) -{ - return MATRIX_COLS; +inline uint8_t matrix_cols(void) { + return MATRIX_COLS; } -void matrix_init(void) -{ - /* Column output pins */ - DDRD |= 0b01111011; - /* Row input pins */ - DDRC &= ~0b10000000; - DDRB &= ~0b01111111; - PORTC |= 0b10000000; - PORTB |= 0b01111111; +void matrix_init(void) { + /* Column output pins */ + DDRD |= 0b01111011; + /* Row input pins */ + DDRC &= ~0b10000000; + DDRB &= ~0b01111111; + PORTC |= 0b10000000; + PORTB |= 0b01111111; - for (uint8_t i=0; i < matrix_rows(); i++) { - matrix[i] = 0; - matrix_debouncing[i] = 0; - } - - matrix_init_kb(); -} - -uint8_t matrix_scan(void) -{ - bool changed = false; - for (uint8_t col = 0; col < MATRIX_COLS; col++) { - select_row(col); - wait_us(30); - matrix_row_t rows = read_cols(); - for (uint8_t row = 0; row < matrix_rows(); row++) { - bool prev_bit = matrix_debouncing[row] & ((matrix_row_t)1<. #include "gergo.h" #ifdef BALLER -#include -#include "pointing_device.h" +# include +# include "pointing_device.h" #endif #ifndef DEBOUNCE -# define DEBOUNCE 5 +# define DEBOUNCE 5 #endif // MCP Pin Defs -#define RROW1 (1u<<3) -#define RROW2 (1u<<2) -#define RROW3 (1u<<1) -#define RROW4 (1u<<0) -#define COL0 (1u<<0) -#define COL1 (1u<<1) -#define COL2 (1u<<2) -#define COL3 (1u<<3) -#define COL4 (1u<<4) -#define COL5 (1u<<5) -#define COL6 (1u<<6) +#define RROW1 (1u << 3) +#define RROW2 (1u << 2) +#define RROW3 (1u << 1) +#define RROW4 (1u << 0) +#define COL0 (1u << 0) +#define COL1 (1u << 1) +#define COL2 (1u << 2) +#define COL3 (1u << 3) +#define COL4 (1u << 4) +#define COL5 (1u << 5) +#define COL6 (1u << 6) // ATmega pin defs -#define ROW1 (1u<<6) -#define ROW2 (1u<<5) -#define ROW3 (1u<<4) -#define ROW4 (1u<<1) -#define COL7 (1u<<0) -#define COL8 (1u<<1) -#define COL9 (1u<<2) -#define COL10 (1u<<3) -#define COL11 (1u<<2) -#define COL12 (1u<<3) -#define COL13 (1u<<6) - -//Trackball pin defs -#define TRKUP (1u<<4) -#define TRKDN (1u<<5) -#define TRKLT (1u<<6) -#define TRKRT (1u<<7) -#define TRKBTN (1u<<6) +#define ROW1 (1u << 6) +#define ROW2 (1u << 5) +#define ROW3 (1u << 4) +#define ROW4 (1u << 1) +#define COL7 (1u << 0) +#define COL8 (1u << 1) +#define COL9 (1u << 2) +#define COL10 (1u << 3) +#define COL11 (1u << 2) +#define COL12 (1u << 3) +#define COL13 (1u << 6) +// Trackball pin defs +#define TRKUP (1u << 4) +#define TRKDN (1u << 5) +#define TRKLT (1u << 6) +#define TRKRT (1u << 7) +#define TRKBTN (1u << 6) // Multiple for mouse moves #ifndef TRKSTEP -#define TRKSTEP 20 +# define TRKSTEP 20 #endif // multiple for mouse scroll #ifndef SCROLLSTEP -#define SCROLLSTEP 5 +# define SCROLLSTEP 5 #endif // bit masks -#define BMASK (COL7 | COL8 | COL9 | COL10) -#define CMASK (COL13) -#define DMASK (COL11 | COL12) -#define FMASK (ROW1 | ROW2 | ROW3 | ROW4) -#define RROWMASK (RROW1 | RROW2 | RROW3 | RROW4) -#define MCPMASK (COL0 | COL1 | COL2 | COL3 | COL4 | COL5 | COL6) -#define TRKMASK (TRKUP | TRKDN | TRKRT | TRKLT) +#define BMASK (COL7 | COL8 | COL9 | COL10) +#define CMASK (COL13) +#define DMASK (COL11 | COL12) +#define FMASK (ROW1 | ROW2 | ROW3 | ROW4) +#define RROWMASK (RROW1 | RROW2 | RROW3 | RROW4) +#define MCPMASK (COL0 | COL1 | COL2 | COL3 | COL4 | COL5 | COL6) +#define TRKMASK (TRKUP | TRKDN | TRKRT | TRKLT) // Trackball interrupts accumulate over here. Processed on scan // Stores prev state of mouse, high bits store direction uint8_t trkState = 0; uint8_t trkBtnState = 0; -volatile uint8_t tbUpCnt = 0; -volatile uint8_t tbDnCnt = 0; -volatile uint8_t tbLtCnt = 0; -volatile uint8_t tbRtCnt = 0; +volatile uint8_t tbUpCnt = 0; +volatile uint8_t tbDnCnt = 0; +volatile uint8_t tbLtCnt = 0; +volatile uint8_t tbRtCnt = 0; /* matrix state(1:on, 0:off) */ static matrix_row_t matrix[MATRIX_ROWS]; @@ -111,29 +110,30 @@ static matrix_row_t read_cols(uint8_t row); static void init_cols(void); static void unselect_rows(void); static void select_row(uint8_t row); -static void enableInterrupts(void); +static void enableInterrupts(void); static uint8_t mcp23018_reset_loop; // static uint16_t mcp23018_reset_loop; -__attribute__ ((weak)) void matrix_init_user(void) {} +__attribute__((weak)) void matrix_init_user(void) {} -__attribute__ ((weak)) void matrix_scan_user(void) {} +__attribute__((weak)) void matrix_scan_user(void) {} -__attribute__ ((weak)) -void matrix_init_kb(void) { - matrix_init_user(); +__attribute__((weak)) void matrix_init_kb(void) { + matrix_init_user(); } -__attribute__ ((weak)) -void matrix_scan_kb(void) { - matrix_scan_user(); +__attribute__((weak)) void matrix_scan_kb(void) { + matrix_scan_user(); } -inline uint8_t matrix_rows(void) { return MATRIX_ROWS; } - -inline uint8_t matrix_cols(void) { return MATRIX_COLS; } +inline uint8_t matrix_rows(void) { + return MATRIX_ROWS; +} +inline uint8_t matrix_cols(void) { + return MATRIX_COLS; +} void matrix_init(void) { // initialize row and col @@ -141,13 +141,13 @@ void matrix_init(void) { unselect_rows(); init_cols(); - // initialize matrix state: all keys off - for (uint8_t i = 0; i < MATRIX_ROWS; i++) { - matrix[i] = 0; - raw_matrix[i] = 0; - } + // initialize matrix state: all keys off + for (uint8_t i = 0; i < MATRIX_ROWS; i++) { + matrix[i] = 0; + raw_matrix[i] = 0; + } - debounce_init(MATRIX_ROWS); + debounce_init(); matrix_init_kb(); } @@ -158,7 +158,7 @@ void matrix_power_up(void) { init_cols(); // initialize matrix state: all keys off - for (uint8_t i=0; i < MATRIX_ROWS; i++) { + for (uint8_t i = 0; i < MATRIX_ROWS; i++) { matrix[i] = 0; } } @@ -166,63 +166,66 @@ void matrix_power_up(void) { // Reads and stores a row, returning // whether a change occurred. static inline bool store_raw_matrix_row(uint8_t index) { - matrix_row_t temp = read_cols(index); - if (raw_matrix[index] != temp) { - raw_matrix[index] = temp; - return true; - } - return false; + matrix_row_t temp = read_cols(index); + if (raw_matrix[index] != temp) { + raw_matrix[index] = temp; + return true; + } + return false; } - - uint8_t matrix_scan(void) { // TODO: Find what is trashing interrupts enableInterrupts(); // First we handle the mouse inputs #ifdef BALLER - uint8_t pBtn = PINE & TRKBTN; + uint8_t pBtn = PINE & TRKBTN; - #ifdef DEBUG_BALLER +# ifdef DEBUG_BALLER // Compare to previous, mod report - if (tbUpCnt + tbDnCnt + tbLtCnt + tbRtCnt != 0) - xprintf("U: %d D: %d L: %d R: %d B: %d\n", tbUpCnt, tbDnCnt, tbLtCnt, tbRtCnt, (trkBtnState >> 6)); - #endif + if (tbUpCnt + tbDnCnt + tbLtCnt + tbRtCnt != 0) xprintf("U: %d D: %d L: %d R: %d B: %d\n", tbUpCnt, tbDnCnt, tbLtCnt, tbRtCnt, (trkBtnState >> 6)); +# endif // Modify the report report_mouse_t pRprt = pointing_device_get_report(); // Scroll by default, move on layer if (layer_state == 0) { - pRprt.h += tbLtCnt * SCROLLSTEP; tbLtCnt = 0; - pRprt.h -= tbRtCnt * SCROLLSTEP; tbRtCnt = 0; - pRprt.v -= tbUpCnt * SCROLLSTEP; tbUpCnt = 0; - pRprt.v += tbDnCnt * SCROLLSTEP; tbDnCnt = 0; + pRprt.h += tbLtCnt * SCROLLSTEP; + tbLtCnt = 0; + pRprt.h -= tbRtCnt * SCROLLSTEP; + tbRtCnt = 0; + pRprt.v -= tbUpCnt * SCROLLSTEP; + tbUpCnt = 0; + pRprt.v += tbDnCnt * SCROLLSTEP; + tbDnCnt = 0; } else { - pRprt.x -= tbLtCnt * TRKSTEP * (layer_state - 1); tbLtCnt = 0; - pRprt.x += tbRtCnt * TRKSTEP * (layer_state - 1); tbRtCnt = 0; - pRprt.y -= tbUpCnt * TRKSTEP * (layer_state - 1); tbUpCnt = 0; - pRprt.y += tbDnCnt * TRKSTEP * (layer_state - 1); tbDnCnt = 0; + pRprt.x -= tbLtCnt * TRKSTEP * (layer_state - 1); + tbLtCnt = 0; + pRprt.x += tbRtCnt * TRKSTEP * (layer_state - 1); + tbRtCnt = 0; + pRprt.y -= tbUpCnt * TRKSTEP * (layer_state - 1); + tbUpCnt = 0; + pRprt.y += tbDnCnt * TRKSTEP * (layer_state - 1); + tbDnCnt = 0; } -#ifdef DEBUG_BALLER - if (pRprt.x != 0 || pRprt.y != 0) - xprintf("X: %d Y: %d\n", pRprt.x, pRprt.y); -#endif +# ifdef DEBUG_BALLER + if (pRprt.x != 0 || pRprt.y != 0) xprintf("X: %d Y: %d\n", pRprt.x, pRprt.y); +# endif - if ((pBtn != trkBtnState) && ((pBtn >> 6) == 0)) pRprt.buttons |= MOUSE_BTN1; - if ((pBtn != trkBtnState) && ((pBtn >> 6) == 1)) pRprt.buttons &= ~MOUSE_BTN1; + if ((pBtn != trkBtnState) && ((pBtn >> 6) == 0)) pRprt.buttons |= MOUSE_BTN1; + if ((pBtn != trkBtnState) && ((pBtn >> 6) == 1)) pRprt.buttons &= ~MOUSE_BTN1; // Save state, push update - if (pRprt.x != 0 || pRprt.y != 0 || pRprt.h != 0 || pRprt.v != 0 || (trkBtnState != pBtn)) - pointing_device_set_report(pRprt); + if (pRprt.x != 0 || pRprt.y != 0 || pRprt.h != 0 || pRprt.v != 0 || (trkBtnState != pBtn)) pointing_device_set_report(pRprt); trkBtnState = pBtn; #endif // Then the keyboard - if (mcp23018_status) { // if there was an error + if (mcp23018_status) { // if there was an error if (++mcp23018_reset_loop == 0) { // if (++mcp23018_reset_loop >= 1300) { // since mcp23018_reset_loop is 8 bit - we'll try to reset once in 255 matrix scans @@ -240,7 +243,7 @@ uint8_t matrix_scan(void) { bool changed = false; for (uint8_t i = 0; i < MATRIX_ROWS_PER_SIDE; i++) { // select rows from left and right hands - uint8_t left_index = i; + uint8_t left_index = i; uint8_t right_index = i + MATRIX_ROWS_PER_SIDE; select_row(left_index); select_row(right_index); @@ -254,41 +257,46 @@ uint8_t matrix_scan(void) { unselect_rows(); } - debounce(raw_matrix, matrix, MATRIX_ROWS, changed); + debounce(raw_matrix, matrix, changed); matrix_scan_kb(); enableInterrupts(); #ifdef DEBUG_MATRIX for (uint8_t c = 0; c < MATRIX_COLS; c++) - for (uint8_t r = 0; r < MATRIX_ROWS; r++) - if (matrix_is_on(r, c)) xprintf("r:%d c:%d \n", r, c); + for (uint8_t r = 0; r < MATRIX_ROWS; r++) + if (matrix_is_on(r, c)) xprintf("r:%d c:%d \n", r, c); #endif return 1; } -inline bool matrix_is_on(uint8_t row, uint8_t col) { return (matrix[row] & ((matrix_row_t)1 << col)); } +inline bool matrix_is_on(uint8_t row, uint8_t col) { + return (matrix[row] & ((matrix_row_t)1 << col)); +} -inline matrix_row_t matrix_get_row(uint8_t row) { return matrix[row]; } +inline matrix_row_t matrix_get_row(uint8_t row) { + return matrix[row]; +} void matrix_print(void) { print("\nr/c 0123456789ABCDEF\n"); for (uint8_t row = 0; row < MATRIX_ROWS; row++) { - print_hex8(row); print(": "); + print_hex8(row); + print(": "); print_bin_reverse16(matrix_get_row(row)); print("\n"); } } // Remember this means ROWS -static void init_cols(void) { +static void init_cols(void) { // init on mcp23018 // not needed, already done as part of init_mcp23018() // Input with pull-up(DDR:0, PORT:1) - DDRF &= ~FMASK; - PORTF |= FMASK; + DDRF &= ~FMASK; + PORTF |= FMASK; } static matrix_row_t read_cols(uint8_t row) { @@ -296,7 +304,7 @@ static matrix_row_t read_cols(uint8_t row) { if (mcp23018_status) { // if there was an error return 0; } else { - uint8_t data = 0; + uint8_t data = 0; mcp23018_status = i2c_read_register(I2C_ADDR, GPIOB, &data, 1, I2C_TIMEOUT); #ifdef DEBUG_MATRIX @@ -305,113 +313,106 @@ static matrix_row_t read_cols(uint8_t row) { return ~data; } } else { - /* read from teensy - * bitmask is 0b0111001, but we want the lower four - * we'll return 1s for the top two, but that's harmless. - */ + /* read from teensy + * bitmask is 0b0111001, but we want the lower four + * we'll return 1s for the top two, but that's harmless. + */ // So I need to confuckulate all this - //return ~(((PIND & DMASK) >> 1 | ((PINC & CMASK) >> 6) | (PIN))); - //return ~((PINF & 0x03) | ((PINF & 0xF0) >> 2)); - return ~( - (((PINF & ROW4) >> 1) - | ((PINF & (ROW1 | ROW2 | ROW3)) >> 3)) - & 0xF); + // return ~(((PIND & DMASK) >> 1 | ((PINC & CMASK) >> 6) | (PIN))); + // return ~((PINF & 0x03) | ((PINF & 0xF0) >> 2)); + return ~((((PINF & ROW4) >> 1) | ((PINF & (ROW1 | ROW2 | ROW3)) >> 3)) & 0xF); } } // Row pin configuration -static void unselect_rows(void) -{ +static void unselect_rows(void) { // no need to unselect on mcp23018, because the select step sets all // the other row bits high, and it's not changing to a different // direction // Hi-Z(DDR:0, PORT:0) to unselect - DDRB &= ~(BMASK | TRKMASK); + DDRB &= ~(BMASK | TRKMASK); PORTB &= ~(BMASK); - DDRC &= ~CMASK; + DDRC &= ~CMASK; PORTC &= ~CMASK; - DDRD &= ~DMASK; + DDRD &= ~DMASK; PORTD &= ~DMASK; - // Fix trashing of DDRB for TB + // Fix trashing of DDRB for TB PORTB |= TRKMASK; } -static void select_row(uint8_t row) -{ +static void select_row(uint8_t row) { if (row < 7) { // select on mcp23018 if (mcp23018_status) { // do nothing on error - } else { // set active row low : 0 // set other rows hi-Z : 1 - uint8_t data = 0xFF & ~(1<= 1300) { // since mcp23018_reset_loop is 8 bit - we'll try to reset once in 255 matrix scans @@ -140,7 +142,7 @@ uint8_t matrix_scan(void) { unselect_rows(); } - debounce(raw_matrix, matrix, MATRIX_ROWS, changed); + debounce(raw_matrix, matrix, changed); matrix_scan_kb(); #ifdef DEBUG_MATRIX @@ -152,8 +154,12 @@ uint8_t matrix_scan(void) { return 1; } -inline bool matrix_is_on(uint8_t row, uint8_t col) { return (matrix[row] & ((matrix_row_t)1 << col)); } -inline matrix_row_t matrix_get_row(uint8_t row) { return matrix[row]; } +inline bool matrix_is_on(uint8_t row, uint8_t col) { + return (matrix[row] & ((matrix_row_t)1 << col)); +} +inline matrix_row_t matrix_get_row(uint8_t row) { + return matrix[row]; +} void matrix_print(void) { print("\nr/c 0123456789ABCDEF\n"); @@ -168,16 +174,16 @@ void matrix_print(void) { // Remember this means ROWS static void init_cols(void) { for (uint8_t col = 0; col < MATRIX_COLS; col++) { - gpio_set_pin_input_high(col_pins[col]); + gpio_set_pin_input_high(col_pins[col]); } } static matrix_row_t read_cols(uint8_t row) { if (row < 5) { - if (mcp23018_status) { // if there was an error + if (mcp23018_status) { // if there was an error return 0; } else { - uint8_t data = 0; + uint8_t data = 0; mcp23018_status = i2c_receive(I2C_ADDR, &data, 1, I2C_TIMEOUT); #ifdef DEBUG_MATRIX if (~data != 0x00) xprintf("I2C: %d\n", ~data); @@ -195,20 +201,19 @@ static void unselect_rows(void) { // the other row bits high, and it's not changing to a different direction for (uint8_t row = 0; row < MATRIX_ROWS_PER_SIDE; row++) { - gpio_set_pin_input(row_pins[row]); - gpio_write_pin_low(row_pins[row]); + gpio_set_pin_input(row_pins[row]); + gpio_write_pin_low(row_pins[row]); } } static void select_row(uint8_t row) { if (row < 5) { // select on mcp23018 - if (mcp23018_status) { // do nothing on error - } else { // set active row low : 0 // set other rows hi-Z : 1 + if (mcp23018_status) { // do nothing on error + } else { // set active row low : 0 // set other rows hi-Z : 1 uint8_t data; - data = 0xFF & ~(1 << (row + 1)); + data = 0xFF & ~(1 << (row + 1)); mcp23018_status = i2c_write_register(I2C_ADDR, GPIOA, &data, 1, I2C_TIMEOUT); - } } else { gpio_set_pin_output(row_pins[row - MATRIX_ROWS_PER_SIDE]); diff --git a/keyboards/halfcliff/matrix.c b/keyboards/halfcliff/matrix.c index 790f8c41bb..fc9d437a45 100644 --- a/keyboards/halfcliff/matrix.c +++ b/keyboards/halfcliff/matrix.c @@ -29,16 +29,20 @@ static pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; /* matrix state(1:on, 0:off) */ -static matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values -static matrix_row_t matrix[MATRIX_ROWS]; // debounced values +static matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values +static matrix_row_t matrix[MATRIX_ROWS]; // debounced values // row offsets for each hand uint8_t thisHand, thatHand; // user-defined overridable functions -__attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); } +__attribute__((weak)) void matrix_init_kb(void) { + matrix_init_user(); +} -__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); } +__attribute__((weak)) void matrix_scan_kb(void) { + matrix_scan_user(); +} __attribute__((weak)) void matrix_init_user(void) {} @@ -46,7 +50,9 @@ __attribute__((weak)) void matrix_scan_user(void) {} __attribute__((weak)) void matrix_slave_scan_user(void) {} -matrix_row_t matrix_get_row(uint8_t row) { return matrix[row]; } +matrix_row_t matrix_get_row(uint8_t row) { + return matrix[row]; +} void matrix_print(void) {} @@ -58,13 +64,19 @@ static inline void gpio_atomic_set_pin_output_low(pin_t pin) { } static inline void gpio_atomic_set_pin_input_high(pin_t pin) { - ATOMIC_BLOCK_FORCEON { gpio_set_pin_input_high(pin); } + ATOMIC_BLOCK_FORCEON { + gpio_set_pin_input_high(pin); + } } // matrix code -static void select_row(uint8_t row) { gpio_atomic_set_pin_output_low(row_pins[row]); } +static void select_row(uint8_t row) { + gpio_atomic_set_pin_output_low(row_pins[row]); +} -static void unselect_row(uint8_t row) { gpio_atomic_set_pin_input_high(row_pins[row]); } +static void unselect_row(uint8_t row) { + gpio_atomic_set_pin_input_high(row_pins[row]); +} static void unselect_rows(void) { for (uint8_t x = 0; x < ROWS_PER_HAND; x++) { @@ -92,7 +104,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) // Unselect row unselect_row(current_row); if (current_row + 1 < MATRIX_ROWS) { - wait_us(30); // wait for row signal to go HIGH + wait_us(30); // wait for row signal to go HIGH } // If the row has changed, store the row and return the changed flag. @@ -103,9 +115,13 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) return false; } -static void select_col(uint8_t col) { gpio_atomic_set_pin_output_low(col_pins[col]); } +static void select_col(uint8_t col) { + gpio_atomic_set_pin_output_low(col_pins[col]); +} -static void unselect_col(uint8_t col) { gpio_atomic_set_pin_input_high(col_pins[col]); } +static void unselect_col(uint8_t col) { + gpio_atomic_set_pin_input_high(col_pins[col]); +} static void unselect_cols(void) { for (uint8_t x = 0; x < MATRIX_COLS; x++) { @@ -156,7 +172,7 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) // Unselect col unselect_col(current_col); if (current_col + 1 < MATRIX_COLS) { - wait_us(30); // wait for col signal to go HIGH + wait_us(30); // wait for col signal to go HIGH } return matrix_changed; @@ -201,7 +217,7 @@ void matrix_init(void) { matrix[i] = 0; } - debounce_init(ROWS_PER_HAND); + debounce_init(); matrix_init_kb(); @@ -248,26 +264,26 @@ bool matrix_post_scan(void) { } uint8_t matrix_scan(void) { - bool local_changed = false; - static matrix_row_t temp_raw_matrix[MATRIX_ROWS]; // temp raw values + bool local_changed = false; + static matrix_row_t temp_raw_matrix[MATRIX_ROWS]; // temp raw values // Set row, read cols - for (uint8_t current_row = 0; current_row < ROWS_PER_HAND/2; current_row++) { + for (uint8_t current_row = 0; current_row < ROWS_PER_HAND / 2; current_row++) { local_changed |= read_cols_on_row(raw_matrix, current_row); } // Set col, read rows for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) { local_changed |= read_rows_on_col(temp_raw_matrix, current_col); - //Updated key matrix on lines 6-10 (or lines 16-20) - if(local_changed) { - for (uint8_t i = ROWS_PER_HAND/2; i < ROWS_PER_HAND; i++) { + // Updated key matrix on lines 6-10 (or lines 16-20) + if (local_changed) { + for (uint8_t i = ROWS_PER_HAND / 2; i < ROWS_PER_HAND; i++) { raw_matrix[i] = temp_raw_matrix[i]; } } } - debounce(raw_matrix, matrix + thisHand, ROWS_PER_HAND, local_changed); + debounce(raw_matrix, matrix + thisHand, local_changed); bool remote_changed = matrix_post_scan(); return (uint8_t)(local_changed || remote_changed); diff --git a/keyboards/handwired/owlet60/matrix.c b/keyboards/handwired/owlet60/matrix.c index 7ef5d66a9f..2017b4de85 100644 --- a/keyboards/handwired/owlet60/matrix.c +++ b/keyboards/handwired/owlet60/matrix.c @@ -29,82 +29,62 @@ along with this program. If not, see . #include "timer.h" #if (MATRIX_COLS <= 8) -# define print_matrix_header() print("\nr/c 01234567\n") -# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 01234567\n") +# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) # define ROW_SHIFTER ((uint8_t)1) #elif (MATRIX_COLS <= 16) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) # define ROW_SHIFTER ((uint16_t)1) #elif (MATRIX_COLS <= 32) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) -# define ROW_SHIFTER ((uint32_t)1) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) +# define ROW_SHIFTER ((uint32_t)1) #endif static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; -static const uint8_t col_select_pins[3] = MATRIX_COL_SELECT_PINS; -static const uint8_t dat_pin = MATRIX_COL_DATA_PIN; +static const uint8_t col_select_pins[3] = MATRIX_COL_SELECT_PINS; +static const uint8_t dat_pin = MATRIX_COL_DATA_PIN; /* matrix state(1:on, 0:off) */ -static matrix_row_t raw_matrix[MATRIX_ROWS]; //raw values -static matrix_row_t matrix[MATRIX_ROWS]; //raw values +static matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values +static matrix_row_t matrix[MATRIX_ROWS]; // raw values /* 2d array containing binary representation of its index */ static const uint8_t num_in_binary[8][3] = { - {0, 0, 0}, - {0, 0, 1}, - {0, 1, 0}, - {0, 1, 1}, - {1, 0, 0}, - {1, 0, 1}, - {1, 1, 0}, - {1, 1, 1}, + {0, 0, 0}, {0, 0, 1}, {0, 1, 0}, {0, 1, 1}, {1, 0, 0}, {1, 0, 1}, {1, 1, 0}, {1, 1, 1}, }; static void select_col_analog(uint8_t col); static void mux_pin_control(const uint8_t binary[]); -void debounce_init(uint8_t num_rows); -void debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed); +void debounce_init(void); +void debounce(matrix_row_t raw[], matrix_row_t cooked[], bool changed); +__attribute__((weak)) void matrix_init_user(void) {} -__attribute__ ((weak)) -void matrix_init_user(void) {} +__attribute__((weak)) void matrix_scan_user(void) {} -__attribute__ ((weak)) -void matrix_scan_user(void) {} - -__attribute__ ((weak)) -void matrix_init_kb(void) { - matrix_init_user(); +__attribute__((weak)) void matrix_init_kb(void) { + matrix_init_user(); } -__attribute__ ((weak)) -void matrix_scan_kb(void) { - matrix_scan_user(); +__attribute__((weak)) void matrix_scan_kb(void) { + matrix_scan_user(); } -inline -uint8_t matrix_rows(void) -{ +inline uint8_t matrix_rows(void) { return MATRIX_ROWS; } -inline -uint8_t matrix_cols(void) -{ +inline uint8_t matrix_cols(void) { return MATRIX_COLS; } -inline -bool matrix_is_on(uint8_t row, uint8_t col) -{ - return (matrix[row] & ((matrix_row_t)1<. #include "debounce.h" #if (MATRIX_COLS <= 8) -# define print_matrix_header() print("\nr/c 01234567\n") -# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 01234567\n") +# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) # define ROW_SHIFTER ((uint8_t)1) #elif (MATRIX_COLS <= 16) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) # define ROW_SHIFTER ((uint16_t)1) #elif (MATRIX_COLS <= 32) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) -# define ROW_SHIFTER ((uint32_t)1) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) +# define ROW_SHIFTER ((uint32_t)1) #endif #ifdef MATRIX_MASKED - extern const matrix_row_t matrix_mask[]; +extern const matrix_row_t matrix_mask[]; #endif static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; /* matrix state(1:on, 0:off) */ -static matrix_row_t raw_matrix[MATRIX_ROWS]; //raw values -static matrix_row_t matrix[MATRIX_ROWS]; //debounced values +static matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values +static matrix_row_t matrix[MATRIX_ROWS]; // debounced values -__attribute__ ((weak)) -void matrix_init_kb(void) { +__attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); } -__attribute__ ((weak)) -void matrix_scan_kb(void) { +__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); } -__attribute__ ((weak)) -void matrix_init_user(void) { -} +__attribute__((weak)) void matrix_init_user(void) {} -__attribute__ ((weak)) -void matrix_scan_user(void) { -} +__attribute__((weak)) void matrix_scan_user(void) {} -inline -uint8_t matrix_rows(void) { +inline uint8_t matrix_rows(void) { return MATRIX_ROWS; } -inline -uint8_t matrix_cols(void) { +inline uint8_t matrix_cols(void) { return MATRIX_COLS; } -inline -bool matrix_is_on(uint8_t row, uint8_t col) -{ - return (matrix[row] & ((matrix_row_t)1<. #include "debounce.h" #if (MATRIX_COLS <= 8) -# define print_matrix_header() print("\nr/c 01234567\n") -# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 01234567\n") +# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) # define ROW_SHIFTER ((uint8_t)1) #elif (MATRIX_COLS <= 16) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) # define ROW_SHIFTER ((uint16_t)1) #elif (MATRIX_COLS <= 32) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) -# define ROW_SHIFTER ((uint32_t)1) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) +# define ROW_SHIFTER ((uint32_t)1) #endif #ifdef MATRIX_MASKED - extern const matrix_row_t matrix_mask[]; +extern const matrix_row_t matrix_mask[]; #endif static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; /* matrix state(1:on, 0:off) */ -static matrix_row_t raw_matrix[MATRIX_ROWS]; //raw values -static matrix_row_t matrix[MATRIX_ROWS]; //debounced values +static matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values +static matrix_row_t matrix[MATRIX_ROWS]; // debounced values -__attribute__ ((weak)) -void matrix_init_kb(void) { +__attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); } -__attribute__ ((weak)) -void matrix_scan_kb(void) { +__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); } -__attribute__ ((weak)) -void matrix_init_user(void) { -} +__attribute__((weak)) void matrix_init_user(void) {} -__attribute__ ((weak)) -void matrix_scan_user(void) { -} +__attribute__((weak)) void matrix_scan_user(void) {} -inline -uint8_t matrix_rows(void) { +inline uint8_t matrix_rows(void) { return MATRIX_ROWS; } -inline -uint8_t matrix_cols(void) { +inline uint8_t matrix_cols(void) { return MATRIX_COLS; } -inline -bool matrix_is_on(uint8_t row, uint8_t col) -{ - return (matrix[row] & ((matrix_row_t)1<. #include "debounce.h" #if (MATRIX_COLS <= 8) -# define print_matrix_header() print("\nr/c 01234567\n") -# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 01234567\n") +# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) # define ROW_SHIFTER ((uint8_t)1) #elif (MATRIX_COLS <= 16) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) # define ROW_SHIFTER ((uint16_t)1) #elif (MATRIX_COLS <= 32) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) -# define ROW_SHIFTER ((uint32_t)1) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) +# define ROW_SHIFTER ((uint32_t)1) #endif #ifdef MATRIX_MASKED - extern const matrix_row_t matrix_mask[]; +extern const matrix_row_t matrix_mask[]; #endif static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; /* matrix state(1:on, 0:off) */ -static matrix_row_t raw_matrix[MATRIX_ROWS]; //raw values -static matrix_row_t matrix[MATRIX_ROWS]; //debounced values +static matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values +static matrix_row_t matrix[MATRIX_ROWS]; // debounced values -__attribute__ ((weak)) -void matrix_init_kb(void) { +__attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); } -__attribute__ ((weak)) -void matrix_scan_kb(void) { +__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); } -__attribute__ ((weak)) -void matrix_init_user(void) { -} +__attribute__((weak)) void matrix_init_user(void) {} -__attribute__ ((weak)) -void matrix_scan_user(void) { -} +__attribute__((weak)) void matrix_scan_user(void) {} -inline -uint8_t matrix_rows(void) { +inline uint8_t matrix_rows(void) { return MATRIX_ROWS; } -inline -uint8_t matrix_cols(void) { +inline uint8_t matrix_cols(void) { return MATRIX_COLS; } -inline -bool matrix_is_on(uint8_t row, uint8_t col) -{ - return (matrix[row] & ((matrix_row_t)1<. #include "debounce.h" #if (MATRIX_COLS <= 8) -# define print_matrix_header() print("\nr/c 01234567\n") -# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 01234567\n") +# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) # define ROW_SHIFTER ((uint8_t)1) #elif (MATRIX_COLS <= 16) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) # define ROW_SHIFTER ((uint16_t)1) #elif (MATRIX_COLS <= 32) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) -# define ROW_SHIFTER ((uint32_t)1) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) +# define ROW_SHIFTER ((uint32_t)1) #endif #ifdef MATRIX_MASKED - extern const matrix_row_t matrix_mask[]; +extern const matrix_row_t matrix_mask[]; #endif #ifdef DIRECT_PINS @@ -47,46 +47,34 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #endif /* matrix state(1:on, 0:off) */ -static matrix_row_t raw_matrix[MATRIX_ROWS]; //raw values -static matrix_row_t matrix[MATRIX_ROWS]; //debounced values +static matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values +static matrix_row_t matrix[MATRIX_ROWS]; // debounced values -__attribute__ ((weak)) -void matrix_init_kb(void) { +__attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); } -__attribute__ ((weak)) -void matrix_scan_kb(void) { +__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); } -__attribute__ ((weak)) -void matrix_init_user(void) { -} +__attribute__((weak)) void matrix_init_user(void) {} -__attribute__ ((weak)) -void matrix_scan_user(void) { -} +__attribute__((weak)) void matrix_scan_user(void) {} -inline -uint8_t matrix_rows(void) { +inline uint8_t matrix_rows(void) { return MATRIX_ROWS; } -inline -uint8_t matrix_cols(void) { +inline uint8_t matrix_cols(void) { return MATRIX_COLS; } -inline -bool matrix_is_on(uint8_t row, uint8_t col) -{ - return (matrix[row] & ((matrix_row_t)1<. #include "debounce.h" #if (MATRIX_COLS <= 8) -# define print_matrix_header() print("\nr/c 01234567\n") -# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 01234567\n") +# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) # define ROW_SHIFTER ((uint8_t)1) #elif (MATRIX_COLS <= 16) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) # define ROW_SHIFTER ((uint16_t)1) #elif (MATRIX_COLS <= 32) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) -# define ROW_SHIFTER ((uint32_t)1) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) +# define ROW_SHIFTER ((uint32_t)1) #endif #ifdef MATRIX_MASKED - extern const matrix_row_t matrix_mask[]; +extern const matrix_row_t matrix_mask[]; #endif #ifdef DIRECT_PINS @@ -47,46 +47,34 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #endif /* matrix state(1:on, 0:off) */ -static matrix_row_t raw_matrix[MATRIX_ROWS]; //raw values -static matrix_row_t matrix[MATRIX_ROWS]; //debounced values +static matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values +static matrix_row_t matrix[MATRIX_ROWS]; // debounced values -__attribute__ ((weak)) -void matrix_init_kb(void) { +__attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); } -__attribute__ ((weak)) -void matrix_scan_kb(void) { +__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); } -__attribute__ ((weak)) -void matrix_init_user(void) { -} +__attribute__((weak)) void matrix_init_user(void) {} -__attribute__ ((weak)) -void matrix_scan_user(void) { -} +__attribute__((weak)) void matrix_scan_user(void) {} -inline -uint8_t matrix_rows(void) { +inline uint8_t matrix_rows(void) { return MATRIX_ROWS; } -inline -uint8_t matrix_cols(void) { +inline uint8_t matrix_cols(void) { return MATRIX_COLS; } -inline -bool matrix_is_on(uint8_t row, uint8_t col) -{ - return (matrix[row] & ((matrix_row_t)1<. #include "debounce.h" #if (MATRIX_COLS <= 8) -# define print_matrix_header() print("\nr/c 01234567\n") -# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 01234567\n") +# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) # define ROW_SHIFTER ((uint8_t)1) #elif (MATRIX_COLS <= 16) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row)) # define ROW_SHIFTER ((uint16_t)1) #elif (MATRIX_COLS <= 32) -# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") -# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) -# define ROW_SHIFTER ((uint32_t)1) +# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n") +# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row)) +# define ROW_SHIFTER ((uint32_t)1) #endif #ifdef MATRIX_MASKED - extern const matrix_row_t matrix_mask[]; +extern const matrix_row_t matrix_mask[]; #endif #ifdef DIRECT_PINS @@ -47,46 +47,34 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; #endif /* matrix state(1:on, 0:off) */ -static matrix_row_t raw_matrix[MATRIX_ROWS]; //raw values -static matrix_row_t matrix[MATRIX_ROWS]; //debounced values +static matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values +static matrix_row_t matrix[MATRIX_ROWS]; // debounced values -__attribute__ ((weak)) -void matrix_init_kb(void) { +__attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); } -__attribute__ ((weak)) -void matrix_scan_kb(void) { +__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); } -__attribute__ ((weak)) -void matrix_init_user(void) { -} +__attribute__((weak)) void matrix_init_user(void) {} -__attribute__ ((weak)) -void matrix_scan_user(void) { -} +__attribute__((weak)) void matrix_scan_user(void) {} -inline -uint8_t matrix_rows(void) { +inline uint8_t matrix_rows(void) { return MATRIX_ROWS; } -inline -uint8_t matrix_cols(void) { +inline uint8_t matrix_cols(void) { return MATRIX_COLS; } -inline -bool matrix_is_on(uint8_t row, uint8_t col) -{ - return (matrix[row] & ((matrix_row_t)1<= 1300) { - // since mcp23018_reset_loop is 8 bit - we'll try to reset once in 255 matrix scans - // this will be approx bit more frequent than once per second - print("trying to reset mcp23018\n"); - mcp23018_status = init_mcp23018(); - if (mcp23018_status) { - print("left side not responding\n"); - } else { - print("left side attached\n"); - } + // Then the keyboard + if (mcp23018_status != I2C_STATUS_SUCCESS) { + if (++mcp23018_reset_loop == 0) { + // if (++mcp23018_reset_loop >= 1300) { + // since mcp23018_reset_loop is 8 bit - we'll try to reset once in 255 matrix scans + // this will be approx bit more frequent than once per second + print("trying to reset mcp23018\n"); + mcp23018_status = init_mcp23018(); + if (mcp23018_status) { + print("left side not responding\n"); + } else { + print("left side attached\n"); + } + } } - } #endif - bool changed = false; - for (uint8_t row = 0; row < MATRIX_ROWS; row++) - { - matrix_row_t cols; + bool changed = false; + for (uint8_t row = 0; row < MATRIX_ROWS; row++) { + matrix_row_t cols; - matrix_select_row(row); + matrix_select_row(row); #ifndef RIGHT_HALF - _delay_us(5); + _delay_us(5); #endif - cols = ( - // cols 0..7, PORTA 0 -> 7 - (~PINA) & 0xFF - ); + cols = ( + // cols 0..7, PORTA 0 -> 7 + (~PINA) & 0xFF); #ifdef RIGHT_HALF - uint8_t data = 0x7F; - // Receive the columns from right half - i2c_receive(I2C_ADDR, &data, 1, MCP23018_I2C_TIMEOUT); - cols |= ((~(data) & 0x7F) << 7); + uint8_t data = 0x7F; + // Receive the columns from right half + i2c_receive(I2C_ADDR, &data, 1, MCP23018_I2C_TIMEOUT); + cols |= ((~(data) & 0x7F) << 7); #endif - if (matrix_debouncing[row] != cols) { - matrix_debouncing[row] = cols; - //debouncing = DEBOUNCE; - changed = true; + if (matrix_debouncing[row] != cols) { + matrix_debouncing[row] = cols; + // debouncing = DEBOUNCE; + changed = true; + } } - } - debounce(matrix_debouncing, matrix, MATRIX_ROWS, changed); + debounce(matrix_debouncing, matrix, changed); - matrix_scan_kb(); + matrix_scan_kb(); #ifdef DEBUG_MATRIX - for (uint8_t c = 0; c < MATRIX_COLS; c++) - for (uint8_t r = 0; r < MATRIX_ROWS; r++) - if (matrix_is_on(r, c)) xprintf("r:%d c:%d \n", r, c); + for (uint8_t c = 0; c < MATRIX_COLS; c++) + for (uint8_t r = 0; r < MATRIX_ROWS; r++) + if (matrix_is_on(r, c)) xprintf("r:%d c:%d \n", r, c); #endif - return (uint8_t)changed; + return (uint8_t)changed; } -inline -matrix_row_t matrix_get_row(uint8_t row) -{ +inline matrix_row_t matrix_get_row(uint8_t row) { return matrix[row]; } -void matrix_print(void) -{ - print("\nr/c 0123456789ABCDEF\n"); - for (uint8_t row = 0; row < MATRIX_ROWS; row++) { - print_hex8(row); print(": "); - print_bin_reverse16(matrix_get_row(row)); - print("\n"); - } +void matrix_print(void) { + print("\nr/c 0123456789ABCDEF\n"); + for (uint8_t row = 0; row < MATRIX_ROWS; row++) { + print_hex8(row); + print(": "); + print_bin_reverse16(matrix_get_row(row)); + print("\n"); + } } -static void matrix_select_row(uint8_t row) -{ +static void matrix_select_row(uint8_t row) { #ifdef RIGHT_HALF - uint8_t txdata[3]; + uint8_t txdata[3]; - //Set the remote row on port A - txdata[0] = GPIOA; - txdata[1] = 0xFF & ~(1< -void debounce_init(uint8_t num_rows) {} +void debounce_init(void) {} -bool debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) { +bool debounce(matrix_row_t raw[], matrix_row_t cooked[], bool changed) { bool cooked_changed = false; if (changed) { - size_t matrix_size = num_rows * sizeof(matrix_row_t); + size_t matrix_size = MATRIX_ROWS_PER_HAND * sizeof(matrix_row_t); if (memcmp(cooked, raw, matrix_size) != 0) { memcpy(cooked, raw, matrix_size); cooked_changed = true; diff --git a/quantum/debounce/sym_defer_g.c b/quantum/debounce/sym_defer_g.c index 81f351c126..a60a131072 100644 --- a/quantum/debounce/sym_defer_g.c +++ b/quantum/debounce/sym_defer_g.c @@ -20,9 +20,9 @@ #if DEBOUNCE > 0 -void debounce_init(uint8_t num_rows) {} +void debounce_init(void) {} -bool debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) { +bool debounce(matrix_row_t raw[], matrix_row_t cooked[], bool changed) { static fast_timer_t debouncing_time; static bool debouncing = false; bool cooked_changed = false; @@ -31,7 +31,7 @@ bool debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool debouncing = true; debouncing_time = timer_read_fast(); } else if (debouncing && timer_elapsed_fast(debouncing_time) >= DEBOUNCE) { - size_t matrix_size = num_rows * sizeof(matrix_row_t); + size_t matrix_size = MATRIX_ROWS_PER_HAND * sizeof(matrix_row_t); if (memcmp(cooked, raw, matrix_size) != 0) { memcpy(cooked, raw, matrix_size); cooked_changed = true; diff --git a/quantum/debounce/sym_defer_pk.c b/quantum/debounce/sym_defer_pk.c index 063094efe5..b910571219 100644 --- a/quantum/debounce/sym_defer_pk.c +++ b/quantum/debounce/sym_defer_pk.c @@ -32,9 +32,9 @@ static bool cooked_changed; static inline void update_debounce_counters_and_transfer_if_expired(matrix_row_t raw[], matrix_row_t cooked[], uint8_t elapsed_time); static inline void start_debounce_counters(matrix_row_t raw[], matrix_row_t cooked[]); -void debounce_init(uint8_t num_rows) {} +void debounce_init(void) {} -bool debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) { +bool debounce(matrix_row_t raw[], matrix_row_t cooked[], bool changed) { static fast_timer_t last_time; bool updated_last = false; cooked_changed = false; diff --git a/quantum/debounce/sym_defer_pr.c b/quantum/debounce/sym_defer_pr.c index 2382fae898..feaf55b08a 100644 --- a/quantum/debounce/sym_defer_pr.c +++ b/quantum/debounce/sym_defer_pr.c @@ -33,9 +33,9 @@ static bool cooked_changed; static inline void update_debounce_counters_and_transfer_if_expired(matrix_row_t raw[], matrix_row_t cooked[], uint8_t elapsed_time); static inline void start_debounce_counters(matrix_row_t raw[], matrix_row_t cooked[]); -void debounce_init(uint8_t num_rows) {} +void debounce_init(void) {} -bool debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) { +bool debounce(matrix_row_t raw[], matrix_row_t cooked[], bool changed) { static fast_timer_t last_time; bool updated_last = false; cooked_changed = false; diff --git a/quantum/debounce/sym_eager_pk.c b/quantum/debounce/sym_eager_pk.c index c3a7afde24..1f53330e9c 100644 --- a/quantum/debounce/sym_eager_pk.c +++ b/quantum/debounce/sym_eager_pk.c @@ -46,9 +46,9 @@ static bool cooked_changed; static inline void update_debounce_counters(uint8_t elapsed_time); static inline void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[]); -void debounce_init(uint8_t num_rows) {} +void debounce_init(void) {} -bool debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) { +bool debounce(matrix_row_t raw[], matrix_row_t cooked[], bool changed) { static fast_timer_t last_time; bool updated_last = false; cooked_changed = false; diff --git a/quantum/debounce/sym_eager_pr.c b/quantum/debounce/sym_eager_pr.c index 5a1e3a1bda..c929ff53dc 100644 --- a/quantum/debounce/sym_eager_pr.c +++ b/quantum/debounce/sym_eager_pr.c @@ -33,9 +33,9 @@ static bool cooked_changed; static inline void update_debounce_counters(uint8_t elapsed_time); static inline void transfer_matrix_values(matrix_row_t raw[], matrix_row_t cooked[]); -void debounce_init(uint8_t num_rows) {} +void debounce_init(void) {} -bool debounce(matrix_row_t raw[], matrix_row_t cooked[], uint8_t num_rows, bool changed) { +bool debounce(matrix_row_t raw[], matrix_row_t cooked[], bool changed) { static fast_timer_t last_time; bool updated_last = false; cooked_changed = false; diff --git a/quantum/debounce/tests/debounce_test_common.cpp b/quantum/debounce/tests/debounce_test_common.cpp index 3782f51411..84b91f85e1 100644 --- a/quantum/debounce/tests/debounce_test_common.cpp +++ b/quantum/debounce/tests/debounce_test_common.cpp @@ -60,7 +60,7 @@ void DebounceTest::runEventsInternal() { bool first = true; /* Initialise keyboard with start time (offset to avoid testing at 0) and all keys UP */ - debounce_init(MATRIX_ROWS); + debounce_init(); set_time(time_offset_); simulate_async_tick(async_time_jumps_); std::fill(std::begin(input_matrix_), std::end(input_matrix_), 0); @@ -129,7 +129,7 @@ void DebounceTest::runDebounce(bool changed) { reset_access_counter(); - bool cooked_changed = debounce(raw_matrix_, cooked_matrix_, MATRIX_ROWS, changed); + bool cooked_changed = debounce(raw_matrix_, cooked_matrix_, 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_); diff --git a/quantum/matrix.c b/quantum/matrix.c index 167a70e5b6..2e7ea085f4 100644 --- a/quantum/matrix.c +++ b/quantum/matrix.c @@ -303,7 +303,7 @@ void matrix_init(void) { memset(matrix, 0, sizeof(matrix)); memset(raw_matrix, 0, sizeof(raw_matrix)); - debounce_init(MATRIX_ROWS_PER_HAND); + debounce_init(); matrix_init_kb(); } @@ -336,9 +336,9 @@ uint8_t matrix_scan(void) { if (changed) memcpy(raw_matrix, curr_matrix, sizeof(curr_matrix)); #ifdef SPLIT_KEYBOARD - changed = debounce(raw_matrix, matrix + thisHand, MATRIX_ROWS_PER_HAND, changed) | matrix_post_scan(); + changed = debounce(raw_matrix, matrix + thisHand, changed) | matrix_post_scan(); #else - changed = debounce(raw_matrix, matrix, MATRIX_ROWS_PER_HAND, changed); + changed = debounce(raw_matrix, matrix, changed); matrix_scan_kb(); #endif return (uint8_t)changed; diff --git a/quantum/matrix_common.c b/quantum/matrix_common.c index b4a86fc483..26589f29a6 100644 --- a/quantum/matrix_common.c +++ b/quantum/matrix_common.c @@ -156,7 +156,7 @@ __attribute__((weak)) void matrix_init(void) { matrix[i] = 0; } - debounce_init(MATRIX_ROWS_PER_HAND); + debounce_init(); matrix_init_kb(); } @@ -165,9 +165,9 @@ __attribute__((weak)) uint8_t matrix_scan(void) { bool changed = matrix_scan_custom(raw_matrix); #ifdef SPLIT_KEYBOARD - changed = debounce(raw_matrix, matrix + thisHand, MATRIX_ROWS_PER_HAND, changed) | matrix_post_scan(); + changed = debounce(raw_matrix, matrix + thisHand, changed) | matrix_post_scan(); #else - changed = debounce(raw_matrix, matrix, MATRIX_ROWS_PER_HAND, changed); + changed = debounce(raw_matrix, matrix, changed); matrix_scan_kb(); #endif