Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Unify matrix for split common and regular matrix #13330

Merged
merged 6 commits into from
Jul 11, 2021
Merged

Unify matrix for split common and regular matrix #13330

Show file tree
Hide file tree
Changes from 3 commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
adebc98
Unify matrix for split common and regular matrix
drashna Jun 24, 2021
2ae66f6
Add fix for MATRIX_*_PINS_RIGHT
drashna Jun 24, 2021
1e2119a
add const to direct pins array if appropriate, for consistency
drashna Jun 24, 2021
2f08f5d
Remove unneded config include
drashna Jul 10, 2021
add3459
add suggestion from mtei
drashna Jul 10, 2021
c47d3b6
Fix matrix.c includes for split boards
drashna Jul 11, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 1 addition & 5 deletions common_features.mk
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -511,11 +511,7 @@ ifneq ($(strip $(CUSTOM_MATRIX)), yes)
# if 'lite' then skip the actual matrix implementation
ifneq ($(strip $(CUSTOM_MATRIX)), lite)
# Include the standard or split matrix code if needed
ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
QUANTUM_SRC += $(QUANTUM_DIR)/split_common/matrix.c
else
QUANTUM_SRC += $(QUANTUM_DIR)/matrix.c
endif
QUANTUM_SRC += $(QUANTUM_DIR)/matrix.c
endif
endif

Expand Down
124 changes: 119 additions & 5 deletions quantum/matrix.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,26 +21,60 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "matrix.h"
#include "debounce.h"
#include "quantum.h"
#ifdef SPLIT_KEYBOARD
# include "split_util.h"
# include "config.h"
drashna marked this conversation as resolved.
Show resolved Hide resolved
# include "transactions.h"

# ifndef ERROR_DISCONNECT_COUNT
# define ERROR_DISCONNECT_COUNT 5
# endif // ERROR_DISCONNECT_COUNT

# define ROWS_PER_HAND (MATRIX_ROWS / 2)
#else
# define ROWS_PER_HAND (MATRIX_ROWS)
#endif

#ifdef DIRECT_PINS
# ifdef DIRECT_PINS_RIGHT
static pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS;
# else
static const pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS;
# endif
#elif (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW)
# ifdef MATRIX_ROW_PINS
# ifdef MATRIX_ROW_PINS_RIGHT
static pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
# else
static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
# endif
# endif // MATRIX_ROW_PINS
# ifdef MATRIX_COL_PINS
# ifdef MATRIX_COL_PINS_RIGHT
static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
# else
static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
# endif
# endif // MATRIX_COL_PINS
#endif

/* matrix state(1:on, 0:off) */
extern matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values
extern matrix_row_t matrix[MATRIX_ROWS]; // debounced values

#ifdef SPLIT_KEYBOARD
// row offsets for each hand
uint8_t thisHand, thatHand;
#endif

// user-defined overridable functions
__attribute__((weak)) void matrix_init_pins(void);
__attribute__((weak)) void matrix_read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
__attribute__((weak)) void matrix_read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
#ifdef SPLIT_KEYBOARD
__attribute__((weak)) void matrix_slave_scan_kb(void) { matrix_slave_scan_user(); }
__attribute__((weak)) void matrix_slave_scan_user(void) {}
#endif

static inline void setPinOutput_writeLow(pin_t pin) {
ATOMIC_BLOCK_FORCEON {
Expand Down Expand Up @@ -192,7 +226,7 @@ __attribute__((weak)) void matrix_read_rows_on_col(matrix_row_t current_matrix[]
matrix_output_select_delay();

// For each row...
for (uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) {
for (uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++) {
// Check row pin state
if (readMatrixPin(row_pins[row_index]) == 0) {
// Pin LO, set col bit
Expand All @@ -217,6 +251,37 @@ __attribute__((weak)) void matrix_read_rows_on_col(matrix_row_t current_matrix[]
#endif

void matrix_init(void) {
#ifdef SPLIT_KEYBOARD
split_pre_init();

// Set pinout for right half if pinout for that half is defined
if (!isLeftHand) {
# ifdef DIRECT_PINS_RIGHT
const pin_t direct_pins_right[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS_RIGHT;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
for (uint8_t j = 0; j < MATRIX_COLS; j++) {
direct_pins[i][j] = direct_pins_right[i][j];
}
}
# endif
# ifdef MATRIX_ROW_PINS_RIGHT
const pin_t row_pins_right[MATRIX_ROWS] = MATRIX_ROW_PINS_RIGHT;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
row_pins[i] = row_pins_right[i];
}
# endif
# ifdef MATRIX_COL_PINS_RIGHT
const pin_t col_pins_right[MATRIX_COLS] = MATRIX_COL_PINS_RIGHT;
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
col_pins[i] = col_pins_right[i];
}
# endif
}

thisHand = isLeftHand ? 0 : (ROWS_PER_HAND);
thatHand = ROWS_PER_HAND - thisHand;
#endif

// initialize key pins
matrix_init_pins();

Expand All @@ -226,17 +291,62 @@ void matrix_init(void) {
matrix[i] = 0;
}

debounce_init(MATRIX_ROWS);
debounce_init(ROWS_PER_HAND);

matrix_init_quantum();

#ifdef SPLIT_KEYBOARD
split_post_init();
#endif
}

#ifdef SPLIT_KEYBOARD
bool matrix_post_scan(void) {
bool changed = false;
if (is_keyboard_master()) {
static uint8_t error_count;

matrix_row_t slave_matrix[ROWS_PER_HAND] = {0};
if (!transport_master(matrix + thisHand, slave_matrix)) {
error_count++;

if (error_count > ERROR_DISCONNECT_COUNT) {
// reset other half if disconnected
for (int i = 0; i < ROWS_PER_HAND; ++i) {
matrix[thatHand + i] = 0;
slave_matrix[i] = 0;
}

changed = true;
}
} else {
error_count = 0;

for (int i = 0; i < ROWS_PER_HAND; ++i) {
if (matrix[thatHand + i] != slave_matrix[i]) {
matrix[thatHand + i] = slave_matrix[i];
changed = true;
}
}
}

matrix_scan_quantum();
} else {
transport_slave(matrix + thatHand, matrix + thisHand);

matrix_slave_scan_kb();
}

return changed;
}
#endif

uint8_t matrix_scan(void) {
matrix_row_t curr_matrix[MATRIX_ROWS] = {0};

#if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW)
// Set row, read cols
for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
matrix_read_cols_on_row(curr_matrix, current_row);
}
#elif (DIODE_DIRECTION == ROW2COL)
Expand All @@ -249,8 +359,12 @@ uint8_t matrix_scan(void) {
bool changed = memcmp(raw_matrix, curr_matrix, sizeof(curr_matrix)) != 0;
if (changed) memcpy(raw_matrix, curr_matrix, sizeof(curr_matrix));

debounce(raw_matrix, matrix, MATRIX_ROWS, changed);

#ifdef SPLIT_KEYBOARD
debounce(raw_matrix, matrix + thisHand, ROWS_PER_HAND, changed);
changed = (changed || matrix_post_scan());
#else
debounce(raw_matrix, matrix, ROWS_PER_HAND, changed);
matrix_scan_quantum();
#endif
return (uint8_t)changed;
}
Loading