Skip to content

Commit

Permalink
Unify matrix for split common and regular matrix (qmk#13330)
Browse files Browse the repository at this point in the history
  • Loading branch information
@drashna
drashna authored Jul 11, 2021
1 parent 63511e9 commit bf25e41
Show file tree
Hide file tree
Showing 3 changed files with 126 additions and 353 deletions.
6 changes: 1 addition & 5 deletions common_features.mk
View file
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
133 changes: 125 additions & 8 deletions quantum/matrix.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,26 +21,63 @@ 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_common/split_util.h"
# include "split_common/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_RIGHT
# define SPLIT_MUTABLE
#else
# define SPLIT_MUTABLE const
#endif
#ifdef MATRIX_ROW_PINS_RIGHT
# define SPLIT_MUTABLE_ROW
#else
# define SPLIT_MUTABLE_ROW const
#endif
#ifdef MATRIX_COL_PINS_RIGHT
# define SPLIT_MUTABLE_COL
#else
# define SPLIT_MUTABLE_COL const
#endif

#ifdef DIRECT_PINS
static pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS;
static SPLIT_MUTABLE pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS;
#elif (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW)
# ifdef MATRIX_ROW_PINS
static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static SPLIT_MUTABLE_ROW pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
# endif // MATRIX_ROW_PINS
# ifdef MATRIX_COL_PINS
static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
static SPLIT_MUTABLE_COL pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
# 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 +229,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 +254,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 +294,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 +362,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

0 comments on commit bf25e41

Please sign in to comment.