qmk_firmware/quantum/matrix_common.c

184 lines
4.8 KiB
C
Raw Blame History

This file contains invisible Unicode characters!

This file contains invisible Unicode characters that may be processed differently from what appears below. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to reveal hidden characters.

#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
changed = debounce(raw_matrix, matrix + thisHand, ROWS_PER_HAND, changed) | matrix_post_scan();
#else
changed = 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));
}