|
|
@ -17,160 +17,53 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
|
#include <stdint.h> |
|
|
|
#include <stdbool.h> |
|
|
|
#include "wait.h" |
|
|
|
#include "print.h" |
|
|
|
#include "debug.h" |
|
|
|
#include "util.h" |
|
|
|
#include "matrix.h" |
|
|
|
#include "debounce.h" |
|
|
|
#include "quantum.h" |
|
|
|
#include "i2c_master.h" |
|
|
|
|
|
|
|
#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)) |
|
|
|
# define matrix_bitpop(i) bitpop(matrix[i]) |
|
|
|
# define ROW_SHIFTER ((uint8_t)1) |
|
|
|
#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)) |
|
|
|
# define matrix_bitpop(i) bitpop16(matrix[i]) |
|
|
|
# define ROW_SHIFTER ((uint16_t)1) |
|
|
|
#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)) |
|
|
|
# define matrix_bitpop(i) bitpop32(matrix[i]) |
|
|
|
# define ROW_SHIFTER ((uint32_t)1) |
|
|
|
#endif |
|
|
|
|
|
|
|
#ifdef MATRIX_MASKED |
|
|
|
extern const matrix_row_t matrix_mask[]; |
|
|
|
#endif |
|
|
|
|
|
|
|
static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; |
|
|
|
static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; |
|
|
|
|
|
|
|
/* matrix state(1:on, 0:off) */ |
|
|
|
static matrix_row_t raw_matrix[MATRIX_ROWS]; //raw values |
|
|
|
static matrix_row_t matrix[MATRIX_ROWS]; //debounced values |
|
|
|
|
|
|
|
__attribute__ ((weak)) |
|
|
|
void matrix_init_quantum(void) { |
|
|
|
matrix_init_kb(); |
|
|
|
} |
|
|
|
|
|
|
|
__attribute__ ((weak)) |
|
|
|
void matrix_scan_quantum(void) { |
|
|
|
matrix_scan_kb(); |
|
|
|
} |
|
|
|
|
|
|
|
__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) { |
|
|
|
} |
|
|
|
|
|
|
|
inline |
|
|
|
uint8_t matrix_rows(void) { |
|
|
|
return MATRIX_ROWS; |
|
|
|
} |
|
|
|
|
|
|
|
inline |
|
|
|
uint8_t matrix_cols(void) { |
|
|
|
return MATRIX_COLS; |
|
|
|
} |
|
|
|
|
|
|
|
//Deprecated. |
|
|
|
bool matrix_is_modified(void) |
|
|
|
{ |
|
|
|
if (debounce_active()) return false; |
|
|
|
return true; |
|
|
|
} |
|
|
|
|
|
|
|
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 |
|
|
|
} |
|
|
|
|
|
|
|
void matrix_print(void) |
|
|
|
{ |
|
|
|
print_matrix_header(); |
|
|
|
|
|
|
|
for (uint8_t row = 0; row < MATRIX_ROWS; row++) { |
|
|
|
phex(row); print(": "); |
|
|
|
print_matrix_row(row); |
|
|
|
print("\n"); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
uint8_t matrix_key_count(void) |
|
|
|
{ |
|
|
|
uint8_t count = 0; |
|
|
|
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { |
|
|
|
count += matrix_bitpop(i); |
|
|
|
static void unselect_rows(void) { |
|
|
|
for(uint8_t x = 0; x < MATRIX_ROWS; x++) { |
|
|
|
setPinInputHigh(row_pins[x]); |
|
|
|
} |
|
|
|
return count; |
|
|
|
} |
|
|
|
|
|
|
|
static void select_row(uint8_t row) |
|
|
|
{ |
|
|
|
static void select_row(uint8_t row) { |
|
|
|
setPinOutput(row_pins[row]); |
|
|
|
writePinLow(row_pins[row]); |
|
|
|
} |
|
|
|
|
|
|
|
static void unselect_row(uint8_t row) |
|
|
|
{ |
|
|
|
static void unselect_row(uint8_t row) { |
|
|
|
setPinInputHigh(row_pins[row]); |
|
|
|
} |
|
|
|
|
|
|
|
static void unselect_rows(void) |
|
|
|
{ |
|
|
|
for(uint8_t x = 0; x < MATRIX_ROWS; x++) { |
|
|
|
setPinInputHigh(row_pins[x]); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
static void init_pins(void) { |
|
|
|
unselect_rows(); |
|
|
|
// Set I/O |
|
|
|
uint8_t send_data = 0x07; |
|
|
|
i2c_writeReg((PORT_EXPANDER_ADDRESS << 1), 0x00, &send_data, 1, 20); |
|
|
|
// // Set Pull-up |
|
|
|
// Set Pull-up |
|
|
|
i2c_writeReg((PORT_EXPANDER_ADDRESS << 1), 0x06, &send_data, 1, 20); |
|
|
|
|
|
|
|
for (uint8_t x = 0; x < MATRIX_COLS; x++) { |
|
|
|
if ( (x > 0) && (x < 12) ) { |
|
|
|
setPinInputHigh(col_pins[x]); |
|
|
|
setPinInputHigh(col_pins[x]); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) |
|
|
|
{ |
|
|
|
void matrix_init_custom(void) { |
|
|
|
// TODO: initialize hardware here |
|
|
|
// Initialize I2C |
|
|
|
i2c_init(); |
|
|
|
|
|
|
|
// initialize key pins |
|
|
|
init_pins(); |
|
|
|
wait_ms(50); |
|
|
|
} |
|
|
|
|
|
|
|
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]; |
|
|
|
|
|
|
@ -203,7 +96,7 @@ static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) |
|
|
|
} |
|
|
|
|
|
|
|
// Populate the matrix row with the state of the col pin |
|
|
|
current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index); |
|
|
|
current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index); |
|
|
|
} |
|
|
|
|
|
|
|
// Unselect row |
|
|
@ -212,36 +105,13 @@ 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 I2C |
|
|
|
i2c_init(); |
|
|
|
|
|
|
|
// initialize key pins |
|
|
|
init_pins(); |
|
|
|
|
|
|
|
// initialize matrix state: all keys off |
|
|
|
for (uint8_t i=0; i < MATRIX_ROWS; i++) { |
|
|
|
raw_matrix[i] = 0; |
|
|
|
matrix[i] = 0; |
|
|
|
} |
|
|
|
|
|
|
|
debounce_init(MATRIX_ROWS); |
|
|
|
|
|
|
|
matrix_init_quantum(); |
|
|
|
} |
|
|
|
|
|
|
|
uint8_t matrix_scan(void) |
|
|
|
{ |
|
|
|
bool changed = false; |
|
|
|
bool matrix_scan_custom(matrix_row_t current_matrix[]) { |
|
|
|
bool matrix_has_changed = false; |
|
|
|
|
|
|
|
// Set row, read cols |
|
|
|
for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) { |
|
|
|
changed |= read_cols_on_row(raw_matrix, current_row); |
|
|
|
matrix_has_changed |= read_cols_on_row(current_matrix, current_row); |
|
|
|
} |
|
|
|
|
|
|
|
debounce(raw_matrix, matrix, MATRIX_ROWS, changed); |
|
|
|
|
|
|
|
matrix_scan_quantum(); |
|
|
|
return (uint8_t)changed; |
|
|
|
return matrix_has_changed; |
|
|
|
} |