crimsen
/
qmk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Debounce: Deprecate num_rows parameter (#25632)

This commit is contained in:
フィルターペーパー 2025-10-19 10:14:37 +08:00 committed by GitHub
parent 4f21beb715
commit 81df543086
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
32 changed files with 983 additions and 1106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/ChangeLog/20251130/PR25632.md Normal file
View File

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

4
docs/custom_matrix.md
View File

@ -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();

120
keyboards/bpiphany/pegasushoof/2015/matrix.c
View File

@ -35,9 +35,13 @@ 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,18 +49,15 @@ __attribute__((weak)) void matrix_scan_user(void) {}
// helper functions
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;
}
void matrix_init(void)
{
void matrix_init(void) {
/* Column output pins */
DDRD |= 0b01111011;
/* Row input pins */
@ -73,8 +74,7 @@ void matrix_init(void)
matrix_init_kb();
}
uint8_t matrix_scan(void)
{
uint8_t matrix_scan(void) {
bool changed = false;
for (uint8_t col = 0; col < MATRIX_COLS; col++) {
select_row(col);
@ -89,61 +89,85 @@ uint8_t matrix_scan(void)
}
}
debounce(matrix_debouncing, matrix, matrix_rows(), changed);
debounce(matrix_debouncing, matrix, changed);
matrix_scan_kb();
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)
{
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");
}
}
static matrix_row_t read_cols(void)
{
return
(PINB&(1<<5) ? 0 : ((matrix_row_t)1<<0)) |
(PINC&(1<<7) ? 0 : ((matrix_row_t)1<<1)) |
(PINB&(1<<4) ? 0 : ((matrix_row_t)1<<2)) |
(PINB&(1<<6) ? 0 : ((matrix_row_t)1<<3)) |
(PINB&(1<<1) ? 0 : ((matrix_row_t)1<<4)) |
(PINB&(1<<2) ? 0 : ((matrix_row_t)1<<5)) |
(PINB&(1<<3) ? 0 : ((matrix_row_t)1<<6)) |
(PINB&(1<<0) ? 0 : ((matrix_row_t)1<<7));
static matrix_row_t read_cols(void) {
return (PINB & (1 << 5) ? 0 : ((matrix_row_t)1 << 0)) | (PINC & (1 << 7) ? 0 : ((matrix_row_t)1 << 1)) | (PINB & (1 << 4) ? 0 : ((matrix_row_t)1 << 2)) | (PINB & (1 << 6) ? 0 : ((matrix_row_t)1 << 3)) | (PINB & (1 << 1) ? 0 : ((matrix_row_t)1 << 4)) | (PINB & (1 << 2) ? 0 : ((matrix_row_t)1 << 5)) | (PINB & (1 << 3) ? 0 : ((matrix_row_t)1 << 6)) | (PINB & (1 << 0) ? 0 : ((matrix_row_t)1 << 7));
}
static void select_row(uint8_t col)
{
static void select_row(uint8_t col) {
switch (col) {
case 0: PORTD = (PORTD & ~0b01111011) | 0b00011011; break;
case 1: PORTD = (PORTD & ~0b01111011) | 0b01000011; break;
case 2: PORTD = (PORTD & ~0b01111011) | 0b01100000; break;
case 3: PORTD = (PORTD & ~0b01111011) | 0b01111001; break;
case 4: PORTD = (PORTD & ~0b01111011) | 0b01100010; break;
case 5: PORTD = (PORTD & ~0b01111011) | 0b01101010; break;
case 6: PORTD = (PORTD & ~0b01111011) | 0b01110001; break;
case 7: PORTD = (PORTD & ~0b01111011) | 0b01101001; break;
case 8: PORTD = (PORTD & ~0b01111011) | 0b01100001; break;
case 9: PORTD = (PORTD & ~0b01111011) | 0b01111000; break;
case 10: PORTD = (PORTD & ~0b01111011) | 0b00100011; break;
case 11: PORTD = (PORTD & ~0b01111011) | 0b00101011; break;
case 12: PORTD = (PORTD & ~0b01111011) | 0b00110011; break;
case 13: PORTD = (PORTD & ~0b01111011) | 0b01110000; break;
case 14: PORTD = (PORTD & ~0b01111011) | 0b00010011; break;
case 15: PORTD = (PORTD & ~0b01111011) | 0b01101000; break;
case 16: PORTD = (PORTD & ~0b01111011) | 0b00001011; break;
case 17: PORTD = (PORTD & ~0b01111011) | 0b00111011; break;
case 0:
PORTD = (PORTD & ~0b01111011) | 0b00011011;
break;
case 1:
PORTD = (PORTD & ~0b01111011) | 0b01000011;
break;
case 2:
PORTD = (PORTD & ~0b01111011) | 0b01100000;
break;
case 3:
PORTD = (PORTD & ~0b01111011) | 0b01111001;
break;
case 4:
PORTD = (PORTD & ~0b01111011) | 0b01100010;
break;
case 5:
PORTD = (PORTD & ~0b01111011) | 0b01101010;
break;
case 6:
PORTD = (PORTD & ~0b01111011) | 0b01110001;
break;
case 7:
PORTD = (PORTD & ~0b01111011) | 0b01101001;
break;
case 8:
PORTD = (PORTD & ~0b01111011) | 0b01100001;
break;
case 9:
PORTD = (PORTD & ~0b01111011) | 0b01111000;
break;
case 10:
PORTD = (PORTD & ~0b01111011) | 0b00100011;
break;
case 11:
PORTD = (PORTD & ~0b01111011) | 0b00101011;
break;
case 12:
PORTD = (PORTD & ~0b01111011) | 0b00110011;
break;
case 13:
PORTD = (PORTD & ~0b01111011) | 0b01110000;
break;
case 14:
PORTD = (PORTD & ~0b01111011) | 0b00010011;
break;
case 15:
PORTD = (PORTD & ~0b01111011) | 0b01101000;
break;
case 16:
PORTD = (PORTD & ~0b01111011) | 0b00001011;
break;
case 17:
PORTD = (PORTD & ~0b01111011) | 0b00111011;
break;
}
}

3
keyboards/gboards/gergo/gergo.c
View File

@ -1,3 +1,6 @@
// Jane Bernhardt (https://github.com/germ)
// SPDX-License-Identifier: GPL-2.0+
#include "gergo.h"
bool i2c_initialized = 0;

3
keyboards/gboards/gergo/gergo.h
View File

@ -1,3 +1,6 @@
// Jane Bernhardt (https://github.com/germ)
// SPDX-License-Identifier: GPL-2.0+
#pragma once
#include "quantum.h"

79
keyboards/gboards/gergo/matrix.c
View File

@ -65,7 +65,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define TRKRT (1u << 7)
#define TRKBTN (1u << 6)
// Multiple for mouse moves
#ifndef TRKSTEP
# define TRKSTEP 20
@ -120,20 +119,21 @@ __attribute__ ((weak)) void matrix_init_user(void) {}
__attribute__((weak)) void matrix_scan_user(void) {}
__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();
}
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
@ -147,7 +147,7 @@ void matrix_init(void) {
raw_matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
}
@ -174,8 +174,6 @@ static inline bool store_raw_matrix_row(uint8_t index) {
return false;
}
uint8_t matrix_scan(void) {
// TODO: Find what is trashing interrupts
enableInterrupts();
@ -186,8 +184,7 @@ uint8_t matrix_scan(void) {
# 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));
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
@ -195,28 +192,34 @@ uint8_t matrix_scan(void) {
// 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);
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;
// 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
@ -254,7 +257,7 @@ uint8_t matrix_scan(void) {
unselect_rows();
}
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
debounce(raw_matrix, matrix, changed);
matrix_scan_kb();
enableInterrupts();
@ -268,14 +271,19 @@ 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 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");
}
@ -312,16 +320,12 @@ static matrix_row_t read_cols(uint8_t row) {
// 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 ~((((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
@ -337,8 +341,7 @@ static void unselect_rows(void)
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
@ -381,7 +384,6 @@ static void select_row(uint8_t row)
}
}
// Trackball Interrupts
static void enableInterrupts(void) {
#ifdef BALLER
@ -412,6 +414,5 @@ ISR (PCINT0_vect) {
if ((pState & TRKLT) != (trkState & TRKLT)) tbLtCnt++;
if ((pState & TRKRT) != (trkState & TRKRT)) tbRtCnt++;
trkState = pState;
}
#endif

3
keyboards/gboards/gergoplex/keymaps/default/config.h
View File

@ -1,3 +1,6 @@
// Jane Bernhardt (https://github.com/germ)
// SPDX-License-Identifier: GPL-2.0+
#pragma once
#define COMBO_ALLOW_ACTION_KEYS

17
keyboards/gboards/gergoplex/matrix.c
View File

@ -68,7 +68,9 @@ static uint8_t mcp23018_reset_loop;
__attribute__((weak)) void matrix_init_user(void) {}
__attribute__((weak)) void matrix_scan_user(void) {}
__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); }
__attribute__((weak)) void matrix_scan_kb(void) {
matrix_scan_user();
}
void matrix_init(void) {
// initialize row and col
@ -82,7 +84,7 @@ void matrix_init(void) {
raw_matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
}
void matrix_power_up(void) {
@ -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");
@ -208,7 +214,6 @@ static void select_row(uint8_t row) {
uint8_t data;
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]);

36
keyboards/halfcliff/matrix.c
View File

@ -36,9 +36,13 @@ static matrix_row_t matrix[MATRIX_ROWS]; // debounced values
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++) {
@ -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++) {
@ -201,7 +217,7 @@ void matrix_init(void) {
matrix[i] = 0;
}
debounce_init(ROWS_PER_HAND);
debounce_init();
matrix_init_kb();
@ -267,7 +283,7 @@ uint8_t matrix_scan(void) {
}
}
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);

82
keyboards/handwired/owlet60/matrix.c
View File

@ -52,59 +52,39 @@ 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) {
__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();
}
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)
{
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)
{
inline matrix_row_t matrix_get_row(uint8_t row) {
// Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
// switch blocker installed and the switch is always pressed.
#ifdef MATRIX_MASKED
@ -114,31 +94,28 @@ matrix_row_t matrix_get_row(uint8_t row)
#endif
}
void matrix_print(void)
{
void matrix_print(void) {
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_hex8(row);
print(": ");
print_matrix_row(row);
print("\n");
}
}
// uses standard row code
static void select_row(uint8_t row)
{
static void select_row(uint8_t row) {
gpio_set_pin_output(row_pins[row]);
gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
static void unselect_row(uint8_t row) {
gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void)
{
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
gpio_set_pin_input_high(row_pins[x]);
}
@ -154,8 +131,7 @@ static void init_pins(void) { // still need some fixing, this might not work
gpio_set_pin_input_high(dat_pin);
}
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
{
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[current_row];
@ -168,7 +144,6 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
select_col_analog(col_index);
wait_us(30);
@ -184,9 +159,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
return (last_row_value != current_matrix[current_row]);
}
void matrix_init(void) {
// initialize key pins
init_pins();
@ -196,7 +169,7 @@ void matrix_init(void) {
matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
@ -205,15 +178,14 @@ void matrix_init(void) {
}
// modified for per col read matrix scan
uint8_t matrix_scan(void)
{
uint8_t matrix_scan(void) {
bool changed = false;
for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
changed |= read_cols_on_row(raw_matrix, current_row);
}
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
debounce(raw_matrix, matrix, changed);
matrix_scan_kb();
return (uint8_t)changed;
@ -231,7 +203,7 @@ uint8_t matrix_scan(void)
}
#endif
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
debounce(raw_matrix, matrix, changed);
matrix_scan_kb();
return (uint8_t)changed;
@ -240,7 +212,6 @@ uint8_t matrix_scan(void)
static void select_col_analog(uint8_t col) {
switch (col) {
case 0:
mux_pin_control(num_in_binary[0]);
break;
@ -275,24 +246,21 @@ static void mux_pin_control(const uint8_t binary[]) {
gpio_set_pin_output(col_select_pins[0]);
if (binary[2] == 0) {
gpio_write_pin_low(col_select_pins[0]);
}
else {
} else {
gpio_write_pin_high(col_select_pins[0]);
}
// set pin1
gpio_set_pin_output(col_select_pins[1]);
if (binary[1] == 0) {
gpio_write_pin_low(col_select_pins[1]);
}
else {
} else {
gpio_write_pin_high(col_select_pins[1]);
}
// set pin2
gpio_set_pin_output(col_select_pins[2]);
if (binary[0] == 0) {
gpio_write_pin_low(col_select_pins[2]);
}
else {
} else {
gpio_write_pin_high(col_select_pins[2]);
}
}

24
keyboards/handwired/symmetric70_proto/matrix_debug/matrix.c
View File

@ -68,7 +68,9 @@ 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
@ -108,9 +110,13 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
#elif defined(DIODE_DIRECTION)
# if (DIODE_DIRECTION == COL2ROW)
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 < MATRIX_ROWS; x++) {
@ -218,9 +224,13 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
# elif (DIODE_DIRECTION == ROW2COL)
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++) {
@ -292,7 +302,7 @@ void matrix_init(void) {
matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
}
@ -317,7 +327,7 @@ uint8_t matrix_scan(void) {
MATRIX_DEBUG_GAP();
MATRIX_DEBUG_SCAN_START();
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
debounce(raw_matrix, matrix, changed);
MATRIX_DEBUG_SCAN_END();
MATRIX_DEBUG_GAP();

4
keyboards/handwired/symmetric70_proto/matrix_fast/matrix.c
View File

@ -166,7 +166,7 @@ void matrix_init(void) {
matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
}
@ -221,7 +221,7 @@ uint8_t matrix_scan(void) {
MATRIX_DEBUG_SCAN_END(); MATRIX_DEBUG_GAP(); MATRIX_DEBUG_SCAN_START();
// debounce raw_matrix[] to matrix[]
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
debounce(raw_matrix, matrix, changed);
MATRIX_DEBUG_SCAN_END(); MATRIX_DEBUG_GAP();
MATRIX_DEBUG_SCAN_START();

80
keyboards/kakunpc/angel64/alpha/matrix.c
View File

@ -46,43 +46,31 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
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)
{
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)
{
inline matrix_row_t matrix_get_row(uint8_t row) {
// Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
// switch blocker installed and the switch is always pressed.
#ifdef MATRIX_MASKED
@ -92,48 +80,42 @@ matrix_row_t matrix_get_row(uint8_t row)
#endif
}
void matrix_print(void)
{
void matrix_print(void) {
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_hex8(row);
print(": ");
print_matrix_row(row);
print("\n");
}
}
static void select_row(uint8_t row)
{
static void select_row(uint8_t row) {
gpio_set_pin_output(row_pins[row]);
gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
static void unselect_row(uint8_t row) {
gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void)
{
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_col(uint8_t col)
{
static void select_col(uint8_t col) {
gpio_set_pin_output(col_pins[col]);
gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
static void unselect_col(uint8_t col) {
gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
static void unselect_cols(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
gpio_set_pin_input_high(col_pins[x]);
}
@ -150,8 +132,7 @@ static void init_pins(void) {
}
}
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
{
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[current_row];
@ -164,7 +145,6 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
@ -178,8 +158,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
return (last_row_value != current_matrix[current_row]);
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
{
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
bool matrix_changed = false;
// Select col and wait for col selecton to stabilize
@ -187,27 +166,22 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
wait_us(30);
// For each row...
for(uint8_t row_index = 0; row_index < MATRIX_ROWS/2; row_index++)
{
for (uint8_t row_index = 0; row_index < MATRIX_ROWS / 2; row_index++) {
uint8_t tmp = row_index + MATRIX_ROWS / 2;
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[tmp];
// Check row pin state
if (gpio_read_pin(row_pins[row_index]) == 0)
{
if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[tmp] |= (ROW_SHIFTER << current_col);
}
else
{
} else {
// Pin HI, clear col bit
current_matrix[tmp] &= ~(ROW_SHIFTER << current_col);
}
// Determine if the matrix changed state
if ((last_row_value != current_matrix[tmp]) && !(matrix_changed))
{
if ((last_row_value != current_matrix[tmp]) && !(matrix_changed)) {
matrix_changed = true;
}
}
@ -219,7 +193,6 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
}
void matrix_init(void) {
// initialize key pins
init_pins();
@ -229,13 +202,12 @@ void matrix_init(void) {
matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
}
uint8_t matrix_scan(void)
{
uint8_t matrix_scan(void) {
bool changed = false;
// Set row, read cols
@ -248,7 +220,7 @@ uint8_t matrix_scan(void)
changed |= read_rows_on_col(raw_matrix, current_col);
}
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
debounce(raw_matrix, matrix, changed);
matrix_scan_kb();
return (uint8_t)changed;

80
keyboards/kakunpc/angel64/rev1/matrix.c
View File

@ -46,43 +46,31 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
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)
{
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)
{
inline matrix_row_t matrix_get_row(uint8_t row) {
// Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
// switch blocker installed and the switch is always pressed.
#ifdef MATRIX_MASKED
@ -92,48 +80,42 @@ matrix_row_t matrix_get_row(uint8_t row)
#endif
}
void matrix_print(void)
{
void matrix_print(void) {
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_hex8(row);
print(": ");
print_matrix_row(row);
print("\n");
}
}
static void select_row(uint8_t row)
{
static void select_row(uint8_t row) {
gpio_set_pin_output(row_pins[row]);
gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
static void unselect_row(uint8_t row) {
gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void)
{
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_col(uint8_t col)
{
static void select_col(uint8_t col) {
gpio_set_pin_output(col_pins[col]);
gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
static void unselect_col(uint8_t col) {
gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
static void unselect_cols(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
gpio_set_pin_input_high(col_pins[x]);
}
@ -150,8 +132,7 @@ static void init_pins(void) {
}
}
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
{
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[current_row];
@ -164,7 +145,6 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
@ -178,8 +158,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
return (last_row_value != current_matrix[current_row]);
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
{
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
bool matrix_changed = false;
// Select col and wait for col selecton to stabilize
@ -187,27 +166,22 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
wait_us(30);
// For each row...
for(uint8_t row_index = 0; row_index < MATRIX_ROWS/2; row_index++)
{
for (uint8_t row_index = 0; row_index < MATRIX_ROWS / 2; row_index++) {
uint8_t tmp = row_index + MATRIX_ROWS / 2;
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[tmp];
// Check row pin state
if (gpio_read_pin(row_pins[row_index]) == 0)
{
if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[tmp] |= (ROW_SHIFTER << current_col);
}
else
{
} else {
// Pin HI, clear col bit
current_matrix[tmp] &= ~(ROW_SHIFTER << current_col);
}
// Determine if the matrix changed state
if ((last_row_value != current_matrix[tmp]) && !(matrix_changed))
{
if ((last_row_value != current_matrix[tmp]) && !(matrix_changed)) {
matrix_changed = true;
}
}
@ -219,7 +193,6 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
}
void matrix_init(void) {
// initialize key pins
init_pins();
@ -229,13 +202,12 @@ void matrix_init(void) {
matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
}
uint8_t matrix_scan(void)
{
uint8_t matrix_scan(void) {
bool changed = false;
// Set row, read cols
@ -248,7 +220,7 @@ uint8_t matrix_scan(void)
changed |= read_rows_on_col(raw_matrix, current_col);
}
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
debounce(raw_matrix, matrix, changed);
matrix_scan_kb();
return (uint8_t)changed;

80
keyboards/kakunpc/thedogkeyboard/matrix.c
View File

@ -46,43 +46,31 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
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)
{
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)
{
inline matrix_row_t matrix_get_row(uint8_t row) {
// Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
// switch blocker installed and the switch is always pressed.
#ifdef MATRIX_MASKED
@ -92,48 +80,42 @@ matrix_row_t matrix_get_row(uint8_t row)
#endif
}
void matrix_print(void)
{
void matrix_print(void) {
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_hex8(row);
print(": ");
print_matrix_row(row);
print("\n");
}
}
static void select_row(uint8_t row)
{
static void select_row(uint8_t row) {
gpio_set_pin_output(row_pins[row]);
gpio_write_pin_low(row_pins[row]);
}
static void unselect_row(uint8_t row)
{
static void unselect_row(uint8_t row) {
gpio_set_pin_input_high(row_pins[row]);
}
static void unselect_rows(void)
{
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
gpio_set_pin_input_high(row_pins[x]);
}
}
static void select_col(uint8_t col)
{
static void select_col(uint8_t col) {
gpio_set_pin_output(col_pins[col]);
gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
static void unselect_col(uint8_t col) {
gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
static void unselect_cols(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
gpio_set_pin_input_high(col_pins[x]);
}
@ -150,8 +132,7 @@ static void init_pins(void) {
}
}
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
{
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[current_row];
@ -164,7 +145,6 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
@ -178,8 +158,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
return (last_row_value != current_matrix[current_row]);
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
{
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
bool matrix_changed = false;
// Select col and wait for col selecton to stabilize
@ -187,27 +166,22 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
wait_us(30);
// For each row...
for(uint8_t row_index = 0; row_index < MATRIX_ROWS/2; row_index++)
{
for (uint8_t row_index = 0; row_index < MATRIX_ROWS / 2; row_index++) {
uint8_t tmp = row_index + MATRIX_ROWS / 2;
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[tmp];
// Check row pin state
if (gpio_read_pin(row_pins[row_index]) == 0)
{
if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[tmp] |= (ROW_SHIFTER << current_col);
}
else
{
} else {
// Pin HI, clear col bit
current_matrix[tmp] &= ~(ROW_SHIFTER << current_col);
}
// Determine if the matrix changed state
if ((last_row_value != current_matrix[tmp]) && !(matrix_changed))
{
if ((last_row_value != current_matrix[tmp]) && !(matrix_changed)) {
matrix_changed = true;
}
}
@ -219,7 +193,6 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
}
void matrix_init(void) {
// initialize key pins
init_pins();
@ -229,13 +202,12 @@ void matrix_init(void) {
matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
}
uint8_t matrix_scan(void)
{
uint8_t matrix_scan(void) {
bool changed = false;
// Set row, read cols
@ -248,7 +220,7 @@ uint8_t matrix_scan(void)
changed |= read_rows_on_col(raw_matrix, current_col);
}
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
debounce(raw_matrix, matrix, changed);
matrix_scan_kb();
return (uint8_t)changed;

28
keyboards/kbdmania/kmac/matrix.c
View File

@ -42,21 +42,33 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
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) { 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) {}
__attribute__((weak)) void matrix_scan_user(void) {}
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;
}
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_matrix_header();
@ -182,7 +194,7 @@ void matrix_init(void) {
matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
}
@ -194,7 +206,7 @@ uint8_t matrix_scan(void) {
changed |= read_rows_on_col(raw_matrix, current_col);
}
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
debounce(raw_matrix, matrix, changed);
matrix_scan_kb();

81
keyboards/redscarf_iiplus/verb/matrix.c Executable file → Normal file
View File

@ -50,43 +50,31 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
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)
{
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)
{
inline matrix_row_t matrix_get_row(uint8_t row) {
// Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
// switch blocker installed and the switch is always pressed.
#ifdef MATRIX_MASKED
@ -96,12 +84,12 @@ matrix_row_t matrix_get_row(uint8_t row)
#endif
}
void matrix_print(void)
{
void matrix_print(void) {
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_hex8(row);
print(": ");
print_matrix_row(row);
print("\n");
}
@ -146,8 +134,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
* 4: 1 0 0
* 5: 1 0 1
*/
static void select_row(uint8_t col)
{
static void select_row(uint8_t col) {
switch (col) {
case 0:
gpio_write_pin_low(B0);
@ -175,8 +162,7 @@ static void select_row(uint8_t col)
}
}
static void unselect_row(uint8_t col)
{
static void unselect_row(uint8_t col) {
switch (col) {
case 0:
gpio_write_pin_high(B0);
@ -204,8 +190,7 @@ static void unselect_row(uint8_t col)
}
}
static void unselect_rows(void)
{
static void unselect_rows(void) {
gpio_set_pin_output(B0);
gpio_set_pin_output(B1);
gpio_set_pin_output(B2);
@ -222,8 +207,7 @@ static void init_pins(void) {
}
}
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
{
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[current_row];
@ -236,7 +220,6 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
@ -252,19 +235,16 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
#elif (DIODE_DIRECTION == ROW2COL)
static void select_col(uint8_t col)
{
static void select_col(uint8_t col) {
gpio_set_pin_output(col_pins[col]);
gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
static void unselect_col(uint8_t col) {
gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
static void unselect_cols(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
gpio_set_pin_input_high(col_pins[x]);
}
@ -277,8 +257,7 @@ static void init_pins(void) {
}
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
{
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
bool matrix_changed = false;
// Select col and wait for col selecton to stabilize
@ -286,27 +265,21 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
wait_us(30);
// For each row...
for(uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++)
{
for (uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) {
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
if (gpio_read_pin(row_pins[row_index]) == 0)
{
if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (ROW_SHIFTER << current_col);
}
else
{
} else {
// Pin HI, clear col bit
current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
}
// Determine if the matrix changed state
if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
{
if ((last_row_value != current_matrix[row_index]) && !(matrix_changed)) {
matrix_changed = true;
}
}
@ -320,7 +293,6 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
#endif
void matrix_init(void) {
// initialize key pins
init_pins();
@ -330,13 +302,12 @@ void matrix_init(void) {
matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
}
uint8_t matrix_scan(void)
{
uint8_t matrix_scan(void) {
bool changed = false;
#if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW)
@ -351,7 +322,7 @@ uint8_t matrix_scan(void)
}
#endif
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
debounce(raw_matrix, matrix, changed);
matrix_scan_kb();
return 1;

81
keyboards/redscarf_iiplus/verc/matrix.c Executable file → Normal file
View File

@ -50,43 +50,31 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
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)
{
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)
{
inline matrix_row_t matrix_get_row(uint8_t row) {
// Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
// switch blocker installed and the switch is always pressed.
#ifdef MATRIX_MASKED
@ -96,12 +84,12 @@ matrix_row_t matrix_get_row(uint8_t row)
#endif
}
void matrix_print(void)
{
void matrix_print(void) {
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_hex8(row);
print(": ");
print_matrix_row(row);
print("\n");
}
@ -146,8 +134,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
* 4: 1 0 0
* 5: 1 0 1
*/
static void select_row(uint8_t col)
{
static void select_row(uint8_t col) {
switch (col) {
case 0:
gpio_write_pin_low(B0);
@ -175,8 +162,7 @@ static void select_row(uint8_t col)
}
}
static void unselect_row(uint8_t col)
{
static void unselect_row(uint8_t col) {
switch (col) {
case 0:
gpio_write_pin_high(B0);
@ -204,8 +190,7 @@ static void unselect_row(uint8_t col)
}
}
static void unselect_rows(void)
{
static void unselect_rows(void) {
gpio_set_pin_output(B0);
gpio_set_pin_output(B1);
gpio_set_pin_output(B2);
@ -222,8 +207,7 @@ static void init_pins(void) {
}
}
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
{
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[current_row];
@ -236,7 +220,6 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
@ -252,19 +235,16 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
#elif (DIODE_DIRECTION == ROW2COL)
static void select_col(uint8_t col)
{
static void select_col(uint8_t col) {
gpio_set_pin_output(col_pins[col]);
gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
static void unselect_col(uint8_t col) {
gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
static void unselect_cols(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
gpio_set_pin_input_high(col_pins[x]);
}
@ -277,8 +257,7 @@ static void init_pins(void) {
}
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
{
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
bool matrix_changed = false;
// Select col and wait for col selecton to stabilize
@ -286,27 +265,21 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
wait_us(30);
// For each row...
for(uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++)
{
for (uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) {
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
if (gpio_read_pin(row_pins[row_index]) == 0)
{
if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (ROW_SHIFTER << current_col);
}
else
{
} else {
// Pin HI, clear col bit
current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
}
// Determine if the matrix changed state
if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
{
if ((last_row_value != current_matrix[row_index]) && !(matrix_changed)) {
matrix_changed = true;
}
}
@ -320,7 +293,6 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
#endif
void matrix_init(void) {
// initialize key pins
init_pins();
@ -330,13 +302,12 @@ void matrix_init(void) {
matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
}
uint8_t matrix_scan(void)
{
uint8_t matrix_scan(void) {
bool changed = false;
#if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW)
@ -351,7 +322,7 @@ uint8_t matrix_scan(void)
}
#endif
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
debounce(raw_matrix, matrix, changed);
matrix_scan_kb();
return 1;

81
keyboards/redscarf_iiplus/verd/matrix.c
View File

@ -50,43 +50,31 @@ static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
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)
{
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)
{
inline matrix_row_t matrix_get_row(uint8_t row) {
// Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
// switch blocker installed and the switch is always pressed.
#ifdef MATRIX_MASKED
@ -96,12 +84,12 @@ matrix_row_t matrix_get_row(uint8_t row)
#endif
}
void matrix_print(void)
{
void matrix_print(void) {
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_hex8(row);
print(": ");
print_matrix_row(row);
print("\n");
}
@ -146,8 +134,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
* 4: 1 0 0
* 5: 1 0 1
*/
static void select_row(uint8_t col)
{
static void select_row(uint8_t col) {
switch (col) {
case 0:
gpio_write_pin_low(B0);
@ -175,8 +162,7 @@ static void select_row(uint8_t col)
}
}
static void unselect_row(uint8_t col)
{
static void unselect_row(uint8_t col) {
switch (col) {
case 0:
gpio_write_pin_high(B0);
@ -204,8 +190,7 @@ static void unselect_row(uint8_t col)
}
}
static void unselect_rows(void)
{
static void unselect_rows(void) {
gpio_set_pin_output(B0);
gpio_set_pin_output(B1);
gpio_set_pin_output(B2);
@ -222,8 +207,7 @@ static void init_pins(void) {
}
}
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
{
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[current_row];
@ -236,7 +220,6 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
// For each col...
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
// Select the col pin to read (active low)
uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
@ -252,19 +235,16 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
#elif (DIODE_DIRECTION == ROW2COL)
static void select_col(uint8_t col)
{
static void select_col(uint8_t col) {
gpio_set_pin_output(col_pins[col]);
gpio_write_pin_low(col_pins[col]);
}
static void unselect_col(uint8_t col)
{
static void unselect_col(uint8_t col) {
gpio_set_pin_input_high(col_pins[col]);
}
static void unselect_cols(void)
{
static void unselect_cols(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
gpio_set_pin_input_high(col_pins[x]);
}
@ -277,8 +257,7 @@ static void init_pins(void) {
}
}
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
{
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
bool matrix_changed = false;
// Select col and wait for col selecton to stabilize
@ -286,27 +265,21 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
wait_us(30);
// For each row...
for(uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++)
{
for (uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) {
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[row_index];
// Check row pin state
if (gpio_read_pin(row_pins[row_index]) == 0)
{
if (gpio_read_pin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
current_matrix[row_index] |= (ROW_SHIFTER << current_col);
}
else
{
} else {
// Pin HI, clear col bit
current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
}
// Determine if the matrix changed state
if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
{
if ((last_row_value != current_matrix[row_index]) && !(matrix_changed)) {
matrix_changed = true;
}
}
@ -320,7 +293,6 @@ static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
#endif
void matrix_init(void) {
// initialize key pins
init_pins();
@ -330,13 +302,12 @@ void matrix_init(void) {
matrix[i] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
}
uint8_t matrix_scan(void)
{
uint8_t matrix_scan(void) {
bool changed = false;
#if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW)
@ -351,7 +322,7 @@ uint8_t matrix_scan(void)
}
#endif
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
debounce(raw_matrix, matrix, changed);
matrix_scan_kb();
return 1;

3
keyboards/ymdk/sp64/keymaps/default/keymap.c
View File

@ -1,3 +1,6 @@
// Copyright 2019 Neil Kettle
// SPDX-License-Identifier: GPL-2.0+
#include QMK_KEYBOARD_H
enum layer_names {

37
keyboards/ymdk/sp64/matrix.c
View File

@ -40,17 +40,20 @@ static uint8_t mcp23018_reset_loop = 0;
// 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) {}
__attribute__((weak)) void matrix_scan_user(void) {}
// helper functions
void matrix_init(void)
{
void matrix_init(void) {
// all outputs for rows high
DDRB = 0xFF;
PORTB = 0xFF;
@ -73,12 +76,11 @@ void matrix_init(void)
matrix[row] = 0;
matrix_debouncing[row] = 0;
}
debounce_init(MATRIX_ROWS);
debounce_init();
matrix_init_kb();
}
uint8_t matrix_scan(void)
{
uint8_t matrix_scan(void) {
#ifdef RIGHT_HALF
// Then the keyboard
if (mcp23018_status != I2C_STATUS_SUCCESS) {
@ -97,8 +99,7 @@ uint8_t matrix_scan(void)
}
#endif
bool changed = false;
for (uint8_t row = 0; row < MATRIX_ROWS; row++)
{
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
matrix_row_t cols;
matrix_select_row(row);
@ -108,8 +109,7 @@ uint8_t matrix_scan(void)
cols = (
// cols 0..7, PORTA 0 -> 7
(~PINA) & 0xFF
);
(~PINA) & 0xFF);
#ifdef RIGHT_HALF
uint8_t data = 0x7F;
@ -125,7 +125,7 @@ uint8_t matrix_scan(void)
}
}
debounce(matrix_debouncing, matrix, MATRIX_ROWS, changed);
debounce(matrix_debouncing, matrix, changed);
matrix_scan_kb();
@ -138,24 +138,21 @@ uint8_t matrix_scan(void)
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)
{
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");
}
}
static void matrix_select_row(uint8_t row)
{
static void matrix_select_row(uint8_t row) {
#ifdef RIGHT_HALF
uint8_t txdata[3];

5
quantum/debounce.h
View File

@ -9,11 +9,10 @@
*
* @param raw The current key state
* @param cooked The debounced key state
* @param num_rows Number of rows to debounce
* @param changed True if raw has changed since the last call
* @return true Cooked has new keychanges after debouncing
* @return false Cooked is the same as before
*/
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);
void debounce_init(uint8_t num_rows);
void debounce_init(void);

4
quantum/debounce/asym_eager_defer_pk.c
View File

@ -38,9 +38,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 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;

6
quantum/debounce/none.c
View File

@ -17,13 +17,13 @@
#include "debounce.h"
#include <string.h>
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;

6
quantum/debounce/sym_defer_g.c
View File

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

4
quantum/debounce/sym_defer_pk.c
View File

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

4
quantum/debounce/sym_defer_pr.c
View File

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

4
quantum/debounce/sym_eager_pk.c
View File

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

4
quantum/debounce/sym_eager_pr.c
View File

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

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

@ -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_);

6
quantum/matrix.c
View File

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

6
quantum/matrix_common.c
View File

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