2 Copyright 2012-2017 Jun Wako, Jack Humbert
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>.
30 /* Set 0 if debouncing isn't needed */
32 #ifndef DEBOUNCING_DELAY
33 # define DEBOUNCING_DELAY 5
36 #if (DEBOUNCING_DELAY > 0)
37 static uint16_t debouncing_time;
38 static bool debouncing = false;
41 #if (MATRIX_COLS <= 8)
42 # define print_matrix_header() print("\nr/c 01234567\n")
43 # define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
44 # define matrix_bitpop(i) bitpop(matrix[i])
45 # define ROW_SHIFTER ((uint8_t)1)
46 #elif (MATRIX_COLS <= 16)
47 # define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
48 # define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
49 # define matrix_bitpop(i) bitpop16(matrix[i])
50 # define ROW_SHIFTER ((uint16_t)1)
51 #elif (MATRIX_COLS <= 32)
52 # define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
53 # define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
54 # define matrix_bitpop(i) bitpop32(matrix[i])
55 # define ROW_SHIFTER ((uint32_t)1)
59 extern const matrix_row_t matrix_mask[];
62 #if (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW)
63 static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
64 static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
67 /* matrix state(1:on, 0:off) */
68 static matrix_row_t matrix[MATRIX_ROWS];
70 static matrix_row_t matrix_debouncing[MATRIX_ROWS];
73 #if (DIODE_DIRECTION == COL2ROW)
74 static void init_cols(void);
75 static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
76 static void unselect_rows(void);
77 static void select_row(uint8_t row);
78 static void unselect_row(uint8_t row);
79 #elif (DIODE_DIRECTION == ROW2COL)
80 static void init_rows(void);
81 static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
82 static void unselect_cols(void);
83 static void unselect_col(uint8_t col);
84 static void select_col(uint8_t col);
87 __attribute__ ((weak))
88 void matrix_init_quantum(void) {
92 __attribute__ ((weak))
93 void matrix_scan_quantum(void) {
97 __attribute__ ((weak))
98 void matrix_init_kb(void) {
102 __attribute__ ((weak))
103 void matrix_scan_kb(void) {
107 __attribute__ ((weak))
108 void matrix_init_user(void) {
111 __attribute__ ((weak))
112 void matrix_scan_user(void) {
116 uint8_t matrix_rows(void) {
121 uint8_t matrix_cols(void) {
125 // void matrix_power_up(void) {
126 // #if (DIODE_DIRECTION == COL2ROW)
127 // for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
129 // _SFR_IO8((row_pins[r] >> 4) + 1) |= _BV(row_pins[r] & 0xF);
132 // for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
134 // _SFR_IO8((col_pins[c] >> 4) + 2) |= _BV(col_pins[c] & 0xF);
136 // #elif (DIODE_DIRECTION == ROW2COL)
137 // for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
139 // _SFR_IO8((col_pins[c] >> 4) + 1) |= _BV(col_pins[c] & 0xF);
142 // for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
144 // _SFR_IO8((row_pins[r] >> 4) + 2) |= _BV(row_pins[r] & 0xF);
149 void matrix_init(void) {
151 // initialize row and col
152 #if (DIODE_DIRECTION == COL2ROW)
155 #elif (DIODE_DIRECTION == ROW2COL)
160 // initialize matrix state: all keys off
161 for (uint8_t i=0; i < MATRIX_ROWS; i++) {
163 matrix_debouncing[i] = 0;
166 matrix_init_quantum();
169 uint8_t matrix_scan(void)
172 #if (DIODE_DIRECTION == COL2ROW)
174 // Set row, read cols
175 for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
176 # if (DEBOUNCING_DELAY > 0)
177 bool matrix_changed = read_cols_on_row(matrix_debouncing, current_row);
179 if (matrix_changed) {
181 debouncing_time = timer_read();
185 read_cols_on_row(matrix, current_row);
190 #elif (DIODE_DIRECTION == ROW2COL)
192 // Set col, read rows
193 for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
194 # if (DEBOUNCING_DELAY > 0)
195 bool matrix_changed = read_rows_on_col(matrix_debouncing, current_col);
196 if (matrix_changed) {
198 debouncing_time = timer_read();
201 read_rows_on_col(matrix, current_col);
208 # if (DEBOUNCING_DELAY > 0)
209 if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) {
210 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
211 matrix[i] = matrix_debouncing[i];
217 matrix_scan_quantum();
221 bool matrix_is_modified(void)
223 #if (DEBOUNCING_DELAY > 0)
224 if (debouncing) return false;
230 bool matrix_is_on(uint8_t row, uint8_t col)
232 return (matrix[row] & ((matrix_row_t)1<col));
236 matrix_row_t matrix_get_row(uint8_t row)
238 // Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
239 // switch blocker installed and the switch is always pressed.
241 return matrix[row] & matrix_mask[row];
247 void matrix_print(void)
249 print_matrix_header();
251 for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
252 phex(row); print(": ");
253 print_matrix_row(row);
258 uint8_t matrix_key_count(void)
261 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
262 count += matrix_bitpop(i);
269 #if (DIODE_DIRECTION == COL2ROW)
271 static void init_cols(void)
273 for(uint8_t x = 0; x < MATRIX_COLS; x++) {
274 uint8_t pin = col_pins[x];
275 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
276 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
280 static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
282 // Store last value of row prior to reading
283 matrix_row_t last_row_value = current_matrix[current_row];
285 // Clear data in matrix row
286 current_matrix[current_row] = 0;
288 // Select row and wait for row selecton to stabilize
289 select_row(current_row);
293 for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
295 // Select the col pin to read (active low)
296 uint8_t pin = col_pins[col_index];
297 uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
299 // Populate the matrix row with the state of the col pin
300 current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
304 unselect_row(current_row);
306 return (last_row_value != current_matrix[current_row]);
309 static void select_row(uint8_t row)
311 uint8_t pin = row_pins[row];
312 _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
313 _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
316 static void unselect_row(uint8_t row)
318 uint8_t pin = row_pins[row];
319 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
320 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
323 static void unselect_rows(void)
325 for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
326 uint8_t pin = row_pins[x];
327 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
328 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
332 #elif (DIODE_DIRECTION == ROW2COL)
334 static void init_rows(void)
336 for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
337 uint8_t pin = row_pins[x];
338 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
339 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
343 static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
345 bool matrix_changed = false;
347 // Select col and wait for col selecton to stabilize
348 select_col(current_col);
352 for(uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++)
355 // Store last value of row prior to reading
356 matrix_row_t last_row_value = current_matrix[row_index];
358 // Check row pin state
359 if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
361 // Pin LO, set col bit
362 current_matrix[row_index] |= (ROW_SHIFTER << current_col);
366 // Pin HI, clear col bit
367 current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
370 // Determine if the matrix changed state
371 if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
373 matrix_changed = true;
378 unselect_col(current_col);
380 return matrix_changed;
383 static void select_col(uint8_t col)
385 uint8_t pin = col_pins[col];
386 _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
387 _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
390 static void unselect_col(uint8_t col)
392 uint8_t pin = col_pins[col];
393 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
394 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
397 static void unselect_cols(void)
399 for(uint8_t x = 0; x < MATRIX_COLS; x++) {
400 uint8_t pin = col_pins[x];
401 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
402 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI