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 // To use PORTF disable JTAG with writing JTD bit twice within four cycles.
152 #if (defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) || defined(__AVR_ATmega32U4__))
157 // initialize row and col
158 #if (DIODE_DIRECTION == COL2ROW)
161 #elif (DIODE_DIRECTION == ROW2COL)
166 // initialize matrix state: all keys off
167 for (uint8_t i
=0; i
< MATRIX_ROWS
; i
++) {
169 matrix_debouncing
[i
] = 0;
172 matrix_init_quantum();
175 uint8_t matrix_scan(void)
178 #if (DIODE_DIRECTION == COL2ROW)
180 // Set row, read cols
181 for (uint8_t current_row
= 0; current_row
< MATRIX_ROWS
; current_row
++) {
182 # if (DEBOUNCING_DELAY > 0)
183 bool matrix_changed
= read_cols_on_row(matrix_debouncing
, current_row
);
185 if (matrix_changed
) {
187 debouncing_time
= timer_read();
191 read_cols_on_row(matrix
, current_row
);
196 #elif (DIODE_DIRECTION == ROW2COL)
198 // Set col, read rows
199 for (uint8_t current_col
= 0; current_col
< MATRIX_COLS
; current_col
++) {
200 # if (DEBOUNCING_DELAY > 0)
201 bool matrix_changed
= read_rows_on_col(matrix_debouncing
, current_col
);
202 if (matrix_changed
) {
204 debouncing_time
= timer_read();
207 read_rows_on_col(matrix
, current_col
);
214 # if (DEBOUNCING_DELAY > 0)
215 if (debouncing
&& (timer_elapsed(debouncing_time
) > DEBOUNCING_DELAY
)) {
216 for (uint8_t i
= 0; i
< MATRIX_ROWS
; i
++) {
217 matrix
[i
] = matrix_debouncing
[i
];
223 matrix_scan_quantum();
227 bool matrix_is_modified(void)
229 #if (DEBOUNCING_DELAY > 0)
230 if (debouncing
) return false;
236 bool matrix_is_on(uint8_t row
, uint8_t col
)
238 return (matrix
[row
] & ((matrix_row_t
)1<col
));
242 matrix_row_t
matrix_get_row(uint8_t row
)
244 // Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
245 // switch blocker installed and the switch is always pressed.
247 return matrix
[row
] & matrix_mask
[row
];
253 void matrix_print(void)
255 print_matrix_header();
257 for (uint8_t row
= 0; row
< MATRIX_ROWS
; row
++) {
258 phex(row
); print(": ");
259 print_matrix_row(row
);
264 uint8_t matrix_key_count(void)
267 for (uint8_t i
= 0; i
< MATRIX_ROWS
; i
++) {
268 count
+= matrix_bitpop(i
);
275 #if (DIODE_DIRECTION == COL2ROW)
277 static void init_cols(void)
279 for(uint8_t x
= 0; x
< MATRIX_COLS
; x
++) {
280 uint8_t pin
= col_pins
[x
];
281 _SFR_IO8((pin
>> 4) + 1) &= ~_BV(pin
& 0xF); // IN
282 _SFR_IO8((pin
>> 4) + 2) |= _BV(pin
& 0xF); // HI
286 static bool read_cols_on_row(matrix_row_t current_matrix
[], uint8_t current_row
)
288 // Store last value of row prior to reading
289 matrix_row_t last_row_value
= current_matrix
[current_row
];
291 // Clear data in matrix row
292 current_matrix
[current_row
] = 0;
294 // Select row and wait for row selecton to stabilize
295 select_row(current_row
);
299 for(uint8_t col_index
= 0; col_index
< MATRIX_COLS
; col_index
++) {
301 // Select the col pin to read (active low)
302 uint8_t pin
= col_pins
[col_index
];
303 uint8_t pin_state
= (_SFR_IO8(pin
>> 4) & _BV(pin
& 0xF));
305 // Populate the matrix row with the state of the col pin
306 current_matrix
[current_row
] |= pin_state
? 0 : (ROW_SHIFTER
<< col_index
);
310 unselect_row(current_row
);
312 return (last_row_value
!= current_matrix
[current_row
]);
315 static void select_row(uint8_t row
)
317 uint8_t pin
= row_pins
[row
];
318 _SFR_IO8((pin
>> 4) + 1) |= _BV(pin
& 0xF); // OUT
319 _SFR_IO8((pin
>> 4) + 2) &= ~_BV(pin
& 0xF); // LOW
322 static void unselect_row(uint8_t row
)
324 uint8_t pin
= row_pins
[row
];
325 _SFR_IO8((pin
>> 4) + 1) &= ~_BV(pin
& 0xF); // IN
326 _SFR_IO8((pin
>> 4) + 2) |= _BV(pin
& 0xF); // HI
329 static void unselect_rows(void)
331 for(uint8_t x
= 0; x
< MATRIX_ROWS
; x
++) {
332 uint8_t pin
= row_pins
[x
];
333 _SFR_IO8((pin
>> 4) + 1) &= ~_BV(pin
& 0xF); // IN
334 _SFR_IO8((pin
>> 4) + 2) |= _BV(pin
& 0xF); // HI
338 #elif (DIODE_DIRECTION == ROW2COL)
340 static void init_rows(void)
342 for(uint8_t x
= 0; x
< MATRIX_ROWS
; x
++) {
343 uint8_t pin
= row_pins
[x
];
344 _SFR_IO8((pin
>> 4) + 1) &= ~_BV(pin
& 0xF); // IN
345 _SFR_IO8((pin
>> 4) + 2) |= _BV(pin
& 0xF); // HI
349 static bool read_rows_on_col(matrix_row_t current_matrix
[], uint8_t current_col
)
351 bool matrix_changed
= false;
353 // Select col and wait for col selecton to stabilize
354 select_col(current_col
);
358 for(uint8_t row_index
= 0; row_index
< MATRIX_ROWS
; row_index
++)
361 // Store last value of row prior to reading
362 matrix_row_t last_row_value
= current_matrix
[row_index
];
364 // Check row pin state
365 if ((_SFR_IO8(row_pins
[row_index
] >> 4) & _BV(row_pins
[row_index
] & 0xF)) == 0)
367 // Pin LO, set col bit
368 current_matrix
[row_index
] |= (ROW_SHIFTER
<< current_col
);
372 // Pin HI, clear col bit
373 current_matrix
[row_index
] &= ~(ROW_SHIFTER
<< current_col
);
376 // Determine if the matrix changed state
377 if ((last_row_value
!= current_matrix
[row_index
]) && !(matrix_changed
))
379 matrix_changed
= true;
384 unselect_col(current_col
);
386 return matrix_changed
;
389 static void select_col(uint8_t col
)
391 uint8_t pin
= col_pins
[col
];
392 _SFR_IO8((pin
>> 4) + 1) |= _BV(pin
& 0xF); // OUT
393 _SFR_IO8((pin
>> 4) + 2) &= ~_BV(pin
& 0xF); // LOW
396 static void unselect_col(uint8_t col
)
398 uint8_t pin
= col_pins
[col
];
399 _SFR_IO8((pin
>> 4) + 1) &= ~_BV(pin
& 0xF); // IN
400 _SFR_IO8((pin
>> 4) + 2) |= _BV(pin
& 0xF); // HI
403 static void unselect_cols(void)
405 for(uint8_t x
= 0; x
< MATRIX_COLS
; x
++) {
406 uint8_t pin
= col_pins
[x
];
407 _SFR_IO8((pin
>> 4) + 1) &= ~_BV(pin
& 0xF); // IN
408 _SFR_IO8((pin
>> 4) + 2) |= _BV(pin
& 0xF); // HI