#include "quantum.h" #include "matrix.h" #include "debounce.h" #include "wait.h" #include "print.h" #include "debug.h" #ifdef SPLIT_KEYBOARD # include "split_common/split_util.h" # include "split_common/transactions.h" # include <string.h> # define ROWS_PER_HAND (MATRIX_ROWS / 2) #else # define ROWS_PER_HAND (MATRIX_ROWS) #endif #ifndef MATRIX_IO_DELAY # define MATRIX_IO_DELAY 30 #endif /* matrix state(1:on, 0:off) */ matrix_row_t raw_matrix[MATRIX_ROWS]; matrix_row_t matrix[MATRIX_ROWS]; #ifdef SPLIT_KEYBOARD // row offsets for each hand uint8_t thisHand, thatHand; #endif #ifdef MATRIX_MASKED extern const matrix_row_t matrix_mask[]; #endif // user-defined overridable functions __attribute__((weak)) void matrix_init_kb(void) { matrix_init_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 inline uint8_t matrix_rows(void) { return MATRIX_ROWS; } 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 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 return matrix[row] & matrix_mask[row]; #else return matrix[row]; #endif } #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)) #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)) #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)) #endif void matrix_print(void) { print_matrix_header(); for (uint8_t row = 0; row < MATRIX_ROWS; row++) { print_hex8(row); print(": "); print_matrix_row(row); print("\n"); } } #ifdef SPLIT_KEYBOARD bool matrix_post_scan(void) { bool changed = false; if (is_keyboard_master()) { static bool last_connected = false; matrix_row_t slave_matrix[ROWS_PER_HAND] = {0}; if (transport_master_if_connected(matrix + thisHand, slave_matrix)) { changed = memcmp(matrix + thatHand, slave_matrix, sizeof(slave_matrix)) != 0; last_connected = true; } else if (last_connected) { // reset other half when disconnected memset(slave_matrix, 0, sizeof(slave_matrix)); changed = true; last_connected = false; } if (changed) memcpy(matrix + thatHand, slave_matrix, sizeof(slave_matrix)); matrix_scan_quantum(); } else { transport_slave(matrix + thatHand, matrix + thisHand); matrix_slave_scan_kb(); } return changed; } #endif /* `matrix_io_delay ()` exists for backwards compatibility. From now on, use matrix_output_unselect_delay(). */ __attribute__((weak)) void matrix_io_delay(void) { wait_us(MATRIX_IO_DELAY); } __attribute__((weak)) void matrix_output_select_delay(void) { waitInputPinDelay(); } __attribute__((weak)) void matrix_output_unselect_delay(uint8_t line, bool key_pressed) { matrix_io_delay(); } // CUSTOM MATRIX 'LITE' __attribute__((weak)) void matrix_init_custom(void) {} __attribute__((weak)) bool matrix_scan_custom(matrix_row_t current_matrix[]) { return true; } #ifdef SPLIT_KEYBOARD __attribute__((weak)) void matrix_slave_scan_kb(void) { matrix_slave_scan_user(); } __attribute__((weak)) void matrix_slave_scan_user(void) {} #endif __attribute__((weak)) void matrix_init(void) { #ifdef SPLIT_KEYBOARD thisHand = isLeftHand ? 0 : (ROWS_PER_HAND); thatHand = ROWS_PER_HAND - thisHand; #endif matrix_init_custom(); // initialize matrix state: all keys off for (uint8_t i = 0; i < MATRIX_ROWS; i++) { raw_matrix[i] = 0; matrix[i] = 0; } debounce_init(ROWS_PER_HAND); matrix_init_quantum(); } __attribute__((weak)) uint8_t matrix_scan(void) { bool changed = matrix_scan_custom(raw_matrix); #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 changed; } __attribute__((weak)) bool peek_matrix(uint8_t row_index, uint8_t col_index, bool raw) { return 0 != ((raw ? raw_matrix[row_index] : matrix[row_index]) & (MATRIX_ROW_SHIFTER << col_index)); }