qmk-dactyl-manuform-a/quantum/matrix.c

211 lines
5.9 KiB
C
Raw Normal View History

2015-08-21 16:46:53 +02:00
/*
Copyright 2012-2018 Jun Wako, Jack Humbert, Yiancar
2015-08-21 16:46:53 +02:00
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdbool.h>
2016-05-24 05:42:21 +02:00
#include "wait.h"
2015-08-21 16:46:53 +02:00
#include "util.h"
#include "matrix.h"
Simplify split_common Code significantly (#4772) * Eliminate separate slave loop Both master and slave run the standard keyboard_task main loop now. * Refactor i2c/serial specific code Simplify some of the preprocessor mess by using common function names. * Fix missing #endif * Move direct pin mapping support from miniaxe to split_common For boards with more pins than sense--sorry, switches. * Reordering and reformatting only * Don't run matrix_scan_quantum on slave side * Clean up the offset/slaveOffset calculations * Cut undebounced matrix size in half * Refactor debouncing * Minor fixups * Split split_common transport and debounce code into their own files Can now be replaced with custom versions per keyboard using CUSTOM_TRANSPORT = yes and CUSTOM_DEBOUNCE = yes * Refactor debounce for non-split keyboards too * Update handwired/xealous to build using new split_common * Fix debounce breaking basic test * Dodgy method to allow a split kb to only include one of i2c/serial SPLIT_TRANSPORT = serial or SPLIT_TRANSPORT = i2c will include only that driver code in the binary. SPLIT_TRANSPORT = custom (or anything else) will include neither, the keyboard must supply it's own code if SPLIT_TRANSPORT is not defined then the original behaviour (include both avr i2c and serial code) is maintained. This could be better but it would require explicitly updating all the existing split keyboards. * Enable LTO to get lets_split/sockets under the line * Add docs for SPLIT_TRANSPORT, CUSTOM_MATRIX, CUSTOM_DEBOUNCE * Remove avr-specific sei() from split matrix_setup Not needed now that slave doesn't have a separate main loop. Both sides (on avr) call sei() in lufa's main() after exiting keyboard_setup(). * Fix QUANTUM_LIB_SRC references and simplify SPLIT_TRANSPORT. * Add comments and fix formatting.
2019-01-17 19:08:14 +01:00
#include "debounce.h"
#include "quantum.h"
2016-10-29 23:12:58 +02:00
#ifdef DIRECT_PINS
static pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS;
#elif (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW)
static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
#endif
2016-07-04 17:45:58 +02:00
/* 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
2016-07-04 17:45:58 +02:00
// matrix code
2015-09-14 04:10:01 +02:00
#ifdef DIRECT_PINS
static void init_pins(void) {
2019-08-30 20:19:03 +02:00
for (int row = 0; row < MATRIX_ROWS; row++) {
for (int col = 0; col < MATRIX_COLS; col++) {
pin_t pin = direct_pins[row][col];
if (pin != NO_PIN) {
setPinInputHigh(pin);
}
}
}
}
2016-10-28 21:21:38 +02:00
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
2019-08-30 20:19:03 +02:00
matrix_row_t last_row_value = current_matrix[current_row];
current_matrix[current_row] = 0;
2016-10-28 21:21:38 +02:00
2019-08-30 20:19:03 +02:00
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
pin_t pin = direct_pins[current_row][col_index];
if (pin != NO_PIN) {
current_matrix[current_row] |= readPin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index);
2019-08-30 20:19:03 +02:00
}
}
2019-08-30 20:19:03 +02:00
return (last_row_value != current_matrix[current_row]);
}
#elif defined(DIODE_DIRECTION)
# if (DIODE_DIRECTION == COL2ROW)
2019-08-30 20:19:03 +02:00
static void select_row(uint8_t row) {
setPinOutput(row_pins[row]);
writePinLow(row_pins[row]);
}
2019-08-30 20:19:03 +02:00
static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); }
2019-08-30 20:19:03 +02:00
static void unselect_rows(void) {
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
setPinInputHigh(row_pins[x]);
2016-07-04 17:45:58 +02:00
}
2015-08-21 16:46:53 +02:00
}
static void init_pins(void) {
2019-08-30 20:19:03 +02:00
unselect_rows();
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
setPinInputHigh(col_pins[x]);
}
}
2019-08-30 20:19:03 +02:00
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
2016-10-29 23:12:58 +02:00
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[current_row];
2016-10-28 23:24:20 +02:00
// Clear data in matrix row
current_matrix[current_row] = 0;
2015-09-14 04:10:01 +02:00
2016-10-28 23:24:20 +02:00
// Select row and wait for row selecton to stabilize
select_row(current_row);
wait_us(30);
2016-10-28 21:21:38 +02:00
2016-10-28 23:24:20 +02:00
// For each col...
2019-08-30 20:19:03 +02:00
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
2016-10-28 23:24:20 +02:00
// Select the col pin to read (active low)
uint8_t pin_state = readPin(col_pins[col_index]);
2016-10-28 23:24:20 +02:00
// Populate the matrix row with the state of the col pin
current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index);
2016-10-28 23:24:20 +02:00
}
2016-10-29 17:39:03 +02:00
// Unselect row
unselect_row(current_row);
2016-10-29 23:12:58 +02:00
return (last_row_value != current_matrix[current_row]);
2015-08-21 16:46:53 +02:00
}
# elif (DIODE_DIRECTION == ROW2COL)
2019-08-30 20:19:03 +02:00
static void select_col(uint8_t col) {
setPinOutput(col_pins[col]);
writePinLow(col_pins[col]);
2016-10-28 21:21:38 +02:00
}
2019-08-30 20:19:03 +02:00
static void unselect_col(uint8_t col) { setPinInputHigh(col_pins[col]); }
2016-10-28 21:21:38 +02:00
2019-08-30 20:19:03 +02:00
static void unselect_cols(void) {
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
setPinInputHigh(col_pins[x]);
2016-05-24 05:42:21 +02:00
}
2016-07-04 17:45:58 +02:00
}
static void init_pins(void) {
2019-08-30 20:19:03 +02:00
unselect_cols();
for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
setPinInputHigh(row_pins[x]);
}
2016-10-28 21:21:38 +02:00
}
2016-07-04 17:45:58 +02:00
2019-08-30 20:19:03 +02:00
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
2016-10-29 23:12:58 +02:00
bool matrix_changed = false;
2016-10-28 21:21:38 +02:00
2016-10-28 23:24:20 +02:00
// Select col and wait for col selecton to stabilize
select_col(current_col);
wait_us(30);
2016-10-28 21:21:38 +02:00
2016-10-28 23:24:20 +02:00
// For each row...
2019-08-30 20:19:03 +02:00
for (uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) {
2016-10-29 23:12:58 +02:00
// Store last value of row prior to reading
matrix_row_t last_row_value = current_matrix[row_index];
2016-10-28 23:24:20 +02:00
2016-10-29 17:39:03 +02:00
// Check row pin state
2019-08-30 20:19:03 +02:00
if (readPin(row_pins[row_index]) == 0) {
2016-10-29 17:39:03 +02:00
// Pin LO, set col bit
current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col);
2019-08-30 20:19:03 +02:00
} else {
2016-10-29 17:39:03 +02:00
// Pin HI, clear col bit
current_matrix[row_index] &= ~(MATRIX_ROW_SHIFTER << current_col);
2016-10-29 17:39:03 +02:00
}
2016-10-29 23:12:58 +02:00
// Determine if the matrix changed state
2019-08-30 20:19:03 +02:00
if ((last_row_value != current_matrix[row_index]) && !(matrix_changed)) {
2016-10-29 23:12:58 +02:00
matrix_changed = true;
}
2016-10-28 23:24:20 +02:00
}
2016-10-29 17:39:03 +02:00
// Unselect col
unselect_col(current_col);
2016-10-29 23:12:58 +02:00
return matrix_changed;
2016-10-28 21:21:38 +02:00
}
# else
# error DIODE_DIRECTION must be one of COL2ROW or ROW2COL!
# endif
#else
# error DIODE_DIRECTION is not defined!
#endif
2016-10-28 21:21:38 +02:00
void matrix_init(void) {
// initialize key pins
init_pins();
// initialize matrix state: all keys off
2019-08-30 20:19:03 +02:00
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
raw_matrix[i] = 0;
2019-08-30 20:19:03 +02:00
matrix[i] = 0;
2016-10-28 21:21:38 +02:00
}
debounce_init(MATRIX_ROWS);
matrix_init_quantum();
2016-10-28 21:21:38 +02:00
}
2019-08-30 20:19:03 +02:00
uint8_t matrix_scan(void) {
bool changed = false;
#if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW)
2019-08-30 20:19:03 +02:00
// 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);
}
#elif (DIODE_DIRECTION == ROW2COL)
2019-08-30 20:19:03 +02:00
// Set col, read rows
for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
changed |= read_rows_on_col(raw_matrix, current_col);
}
2016-10-28 21:21:38 +02:00
#endif
2019-08-30 20:19:03 +02:00
debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
2019-08-30 20:19:03 +02:00
matrix_scan_quantum();
return (uint8_t)changed;
}