Commit | Line | Data |
---|---|---|
d7077386 JH |
1 | /* |
2 | Copyright 2012 Jun Wako <wakojun@gmail.com> | |
3 | ||
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. | |
8 | ||
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. | |
13 | ||
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/>. | |
16 | */ | |
17 | ||
18 | /* | |
19 | * scan matrix | |
20 | */ | |
21 | #include <stdint.h> | |
22 | #include <stdbool.h> | |
23 | #include <avr/io.h> | |
07cb997b | 24 | #include "wait.h" |
d7077386 JH |
25 | #include "print.h" |
26 | #include "debug.h" | |
27 | #include "util.h" | |
28 | #include "matrix.h" | |
d7077386 JH |
29 | #include "split_util.h" |
30 | #include "pro_micro.h" | |
31 | #include "config.h" | |
07cb997b | 32 | #include "timer.h" |
d7077386 | 33 | |
6631abc1 I |
34 | #ifdef USE_I2C |
35 | # include "i2c.h" | |
36 | #else // USE_SERIAL | |
37 | # include "serial.h" | |
38 | #endif | |
39 | ||
07cb997b | 40 | #ifndef DEBOUNCING_DELAY |
41 | # define DEBOUNCING_DELAY 5 | |
d7077386 JH |
42 | #endif |
43 | ||
07cb997b | 44 | #if (DEBOUNCING_DELAY > 0) |
45 | static uint16_t debouncing_time; | |
46 | static bool debouncing = false; | |
47 | #endif | |
48 | ||
49 | #if (MATRIX_COLS <= 8) | |
50 | # define print_matrix_header() print("\nr/c 01234567\n") | |
51 | # define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row)) | |
52 | # define matrix_bitpop(i) bitpop(matrix[i]) | |
53 | # define ROW_SHIFTER ((uint8_t)1) | |
54 | #else | |
55 | # error "Currently only supports 8 COLS" | |
56 | #endif | |
57 | static matrix_row_t matrix_debouncing[MATRIX_ROWS]; | |
58 | ||
d7077386 JH |
59 | #define ERROR_DISCONNECT_COUNT 5 |
60 | ||
07cb997b | 61 | #define ROWS_PER_HAND (MATRIX_ROWS/2) |
62 | ||
d7077386 JH |
63 | static uint8_t error_count = 0; |
64 | ||
65 | static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; | |
66 | static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; | |
67 | ||
68 | /* matrix state(1:on, 0:off) */ | |
69 | static matrix_row_t matrix[MATRIX_ROWS]; | |
70 | static matrix_row_t matrix_debouncing[MATRIX_ROWS]; | |
71 | ||
07cb997b | 72 | #if (DIODE_DIRECTION == COL2ROW) |
73 | static void init_cols(void); | |
74 | static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row); | |
75 | static void unselect_rows(void); | |
76 | static void select_row(uint8_t row); | |
77 | static void unselect_row(uint8_t row); | |
78 | #elif (DIODE_DIRECTION == ROW2COL) | |
79 | static void init_rows(void); | |
80 | static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col); | |
81 | static void unselect_cols(void); | |
82 | static void unselect_col(uint8_t col); | |
83 | static void select_col(uint8_t col); | |
84 | #endif | |
d7077386 JH |
85 | |
86 | __attribute__ ((weak)) | |
87 | void matrix_init_kb(void) { | |
88 | matrix_init_user(); | |
89 | } | |
90 | ||
91 | __attribute__ ((weak)) | |
92 | void matrix_scan_kb(void) { | |
93 | matrix_scan_user(); | |
94 | } | |
95 | ||
96 | __attribute__ ((weak)) | |
97 | void matrix_init_user(void) { | |
98 | } | |
99 | ||
100 | __attribute__ ((weak)) | |
101 | void matrix_scan_user(void) { | |
102 | } | |
103 | ||
104 | inline | |
105 | uint8_t matrix_rows(void) | |
106 | { | |
107 | return MATRIX_ROWS; | |
108 | } | |
109 | ||
110 | inline | |
111 | uint8_t matrix_cols(void) | |
112 | { | |
113 | return MATRIX_COLS; | |
114 | } | |
115 | ||
116 | void matrix_init(void) | |
117 | { | |
e2352d4f MJ |
118 | #ifdef DISABLE_JTAG |
119 | // JTAG disable for PORT F. write JTD bit twice within four cycles. | |
120 | MCUCR |= (1<<JTD); | |
121 | MCUCR |= (1<<JTD); | |
122 | #endif | |
123 | ||
d7077386 JH |
124 | debug_enable = true; |
125 | debug_matrix = true; | |
126 | debug_mouse = true; | |
127 | // initialize row and col | |
3f1aab0c | 128 | #if (DIODE_DIRECTION == COL2ROW) |
d7077386 JH |
129 | unselect_rows(); |
130 | init_cols(); | |
3f1aab0c MR |
131 | #elif (DIODE_DIRECTION == ROW2COL) |
132 | unselect_cols(); | |
133 | init_rows(); | |
134 | #endif | |
d7077386 JH |
135 | |
136 | TX_RX_LED_INIT; | |
137 | ||
138 | // initialize matrix state: all keys off | |
139 | for (uint8_t i=0; i < MATRIX_ROWS; i++) { | |
140 | matrix[i] = 0; | |
141 | matrix_debouncing[i] = 0; | |
142 | } | |
143 | ||
144 | matrix_init_quantum(); | |
07cb997b | 145 | |
d7077386 JH |
146 | } |
147 | ||
148 | uint8_t _matrix_scan(void) | |
149 | { | |
d7077386 | 150 | int offset = isLeftHand ? 0 : (ROWS_PER_HAND); |
07cb997b | 151 | #if (DIODE_DIRECTION == COL2ROW) |
152 | // Set row, read cols | |
153 | for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) { | |
154 | # if (DEBOUNCING_DELAY > 0) | |
155 | bool matrix_changed = read_cols_on_row(matrix_debouncing+offset, current_row); | |
156 | ||
157 | if (matrix_changed) { | |
158 | debouncing = true; | |
159 | debouncing_time = timer_read(); | |
07cb997b | 160 | } |
161 | ||
162 | # else | |
163 | read_cols_on_row(matrix+offset, current_row); | |
164 | # endif | |
165 | ||
166 | } | |
167 | ||
168 | #elif (DIODE_DIRECTION == ROW2COL) | |
169 | // Set col, read rows | |
170 | for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) { | |
171 | # if (DEBOUNCING_DELAY > 0) | |
172 | bool matrix_changed = read_rows_on_col(matrix_debouncing+offset, current_col); | |
173 | if (matrix_changed) { | |
174 | debouncing = true; | |
175 | debouncing_time = timer_read(); | |
176 | } | |
177 | # else | |
178 | read_rows_on_col(matrix+offset, current_col); | |
179 | # endif | |
d7077386 | 180 | |
d7077386 | 181 | } |
07cb997b | 182 | #endif |
d7077386 | 183 | |
07cb997b | 184 | # if (DEBOUNCING_DELAY > 0) |
185 | if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) { | |
d7077386 JH |
186 | for (uint8_t i = 0; i < ROWS_PER_HAND; i++) { |
187 | matrix[i+offset] = matrix_debouncing[i+offset]; | |
188 | } | |
07cb997b | 189 | debouncing = false; |
d7077386 | 190 | } |
07cb997b | 191 | # endif |
d7077386 JH |
192 | |
193 | return 1; | |
194 | } | |
195 | ||
6631abc1 I |
196 | #ifdef USE_I2C |
197 | ||
d7077386 JH |
198 | // Get rows from other half over i2c |
199 | int i2c_transaction(void) { | |
200 | int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; | |
201 | ||
202 | int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE); | |
203 | if (err) goto i2c_error; | |
204 | ||
205 | // start of matrix stored at 0x00 | |
206 | err = i2c_master_write(0x00); | |
207 | if (err) goto i2c_error; | |
208 | ||
209 | // Start read | |
210 | err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ); | |
211 | if (err) goto i2c_error; | |
212 | ||
213 | if (!err) { | |
214 | int i; | |
215 | for (i = 0; i < ROWS_PER_HAND-1; ++i) { | |
216 | matrix[slaveOffset+i] = i2c_master_read(I2C_ACK); | |
217 | } | |
218 | matrix[slaveOffset+i] = i2c_master_read(I2C_NACK); | |
219 | i2c_master_stop(); | |
220 | } else { | |
221 | i2c_error: // the cable is disconnceted, or something else went wrong | |
222 | i2c_reset_state(); | |
223 | return err; | |
224 | } | |
225 | ||
226 | return 0; | |
227 | } | |
228 | ||
6631abc1 I |
229 | #else // USE_SERIAL |
230 | ||
d7077386 JH |
231 | int serial_transaction(void) { |
232 | int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; | |
233 | ||
234 | if (serial_update_buffers()) { | |
235 | return 1; | |
236 | } | |
237 | ||
238 | for (int i = 0; i < ROWS_PER_HAND; ++i) { | |
239 | matrix[slaveOffset+i] = serial_slave_buffer[i]; | |
240 | } | |
241 | return 0; | |
242 | } | |
243 | #endif | |
244 | ||
245 | uint8_t matrix_scan(void) | |
246 | { | |
07cb997b | 247 | uint8_t ret = _matrix_scan(); |
d7077386 JH |
248 | |
249 | #ifdef USE_I2C | |
250 | if( i2c_transaction() ) { | |
6631abc1 | 251 | #else // USE_SERIAL |
d7077386 JH |
252 | if( serial_transaction() ) { |
253 | #endif | |
254 | // turn on the indicator led when halves are disconnected | |
1f7b8a03 | 255 | TXLED1; |
732a7f2b | 256 | |
d7077386 JH |
257 | error_count++; |
258 | ||
259 | if (error_count > ERROR_DISCONNECT_COUNT) { | |
260 | // reset other half if disconnected | |
261 | int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; | |
262 | for (int i = 0; i < ROWS_PER_HAND; ++i) { | |
263 | matrix[slaveOffset+i] = 0; | |
264 | } | |
265 | } | |
266 | } else { | |
267 | // turn off the indicator led on no error | |
268 | TXLED0; | |
269 | error_count = 0; | |
270 | } | |
d7077386 | 271 | matrix_scan_quantum(); |
d7077386 JH |
272 | return ret; |
273 | } | |
274 | ||
275 | void matrix_slave_scan(void) { | |
276 | _matrix_scan(); | |
277 | ||
07cb997b | 278 | int offset = (isLeftHand) ? 0 : ROWS_PER_HAND; |
d7077386 JH |
279 | |
280 | #ifdef USE_I2C | |
281 | for (int i = 0; i < ROWS_PER_HAND; ++i) { | |
d7077386 JH |
282 | i2c_slave_buffer[i] = matrix[offset+i]; |
283 | } | |
6631abc1 | 284 | #else // USE_SERIAL |
d7077386 JH |
285 | for (int i = 0; i < ROWS_PER_HAND; ++i) { |
286 | serial_slave_buffer[i] = matrix[offset+i]; | |
287 | } | |
288 | #endif | |
289 | } | |
290 | ||
291 | bool matrix_is_modified(void) | |
292 | { | |
293 | if (debouncing) return false; | |
294 | return true; | |
295 | } | |
296 | ||
297 | inline | |
298 | bool matrix_is_on(uint8_t row, uint8_t col) | |
299 | { | |
300 | return (matrix[row] & ((matrix_row_t)1<<col)); | |
301 | } | |
302 | ||
303 | inline | |
304 | matrix_row_t matrix_get_row(uint8_t row) | |
305 | { | |
306 | return matrix[row]; | |
307 | } | |
308 | ||
309 | void matrix_print(void) | |
310 | { | |
311 | print("\nr/c 0123456789ABCDEF\n"); | |
312 | for (uint8_t row = 0; row < MATRIX_ROWS; row++) { | |
313 | phex(row); print(": "); | |
314 | pbin_reverse16(matrix_get_row(row)); | |
315 | print("\n"); | |
316 | } | |
317 | } | |
318 | ||
319 | uint8_t matrix_key_count(void) | |
320 | { | |
321 | uint8_t count = 0; | |
322 | for (uint8_t i = 0; i < MATRIX_ROWS; i++) { | |
323 | count += bitpop16(matrix[i]); | |
324 | } | |
325 | return count; | |
326 | } | |
327 | ||
07cb997b | 328 | #if (DIODE_DIRECTION == COL2ROW) |
329 | ||
330 | static void init_cols(void) | |
d7077386 | 331 | { |
07cb997b | 332 | for(uint8_t x = 0; x < MATRIX_COLS; x++) { |
333 | uint8_t pin = col_pins[x]; | |
334 | _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN | |
335 | _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI | |
d7077386 JH |
336 | } |
337 | } | |
338 | ||
07cb997b | 339 | static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) |
d7077386 | 340 | { |
07cb997b | 341 | // Store last value of row prior to reading |
342 | matrix_row_t last_row_value = current_matrix[current_row]; | |
343 | ||
344 | // Clear data in matrix row | |
345 | current_matrix[current_row] = 0; | |
346 | ||
347 | // Select row and wait for row selecton to stabilize | |
348 | select_row(current_row); | |
349 | wait_us(30); | |
350 | ||
351 | // For each col... | |
352 | for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) { | |
353 | ||
354 | // Select the col pin to read (active low) | |
355 | uint8_t pin = col_pins[col_index]; | |
356 | uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF)); | |
357 | ||
358 | // Populate the matrix row with the state of the col pin | |
359 | current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index); | |
d7077386 | 360 | } |
07cb997b | 361 | |
362 | // Unselect row | |
363 | unselect_row(current_row); | |
364 | ||
365 | return (last_row_value != current_matrix[current_row]); | |
366 | } | |
367 | ||
368 | static void select_row(uint8_t row) | |
369 | { | |
370 | uint8_t pin = row_pins[row]; | |
371 | _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT | |
372 | _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW | |
373 | } | |
374 | ||
375 | static void unselect_row(uint8_t row) | |
376 | { | |
377 | uint8_t pin = row_pins[row]; | |
378 | _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN | |
379 | _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI | |
d7077386 JH |
380 | } |
381 | ||
382 | static void unselect_rows(void) | |
383 | { | |
07cb997b | 384 | for(uint8_t x = 0; x < ROWS_PER_HAND; x++) { |
385 | uint8_t pin = row_pins[x]; | |
386 | _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN | |
387 | _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI | |
d7077386 JH |
388 | } |
389 | } | |
390 | ||
07cb997b | 391 | #elif (DIODE_DIRECTION == ROW2COL) |
392 | ||
393 | static void init_rows(void) | |
394 | { | |
395 | for(uint8_t x = 0; x < ROWS_PER_HAND; x++) { | |
396 | uint8_t pin = row_pins[x]; | |
397 | _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN | |
398 | _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI | |
399 | } | |
400 | } | |
401 | ||
402 | static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) | |
403 | { | |
404 | bool matrix_changed = false; | |
405 | ||
406 | // Select col and wait for col selecton to stabilize | |
407 | select_col(current_col); | |
408 | wait_us(30); | |
409 | ||
410 | // For each row... | |
411 | for(uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++) | |
412 | { | |
413 | ||
414 | // Store last value of row prior to reading | |
415 | matrix_row_t last_row_value = current_matrix[row_index]; | |
416 | ||
417 | // Check row pin state | |
418 | if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0) | |
419 | { | |
420 | // Pin LO, set col bit | |
421 | current_matrix[row_index] |= (ROW_SHIFTER << current_col); | |
422 | } | |
423 | else | |
424 | { | |
425 | // Pin HI, clear col bit | |
426 | current_matrix[row_index] &= ~(ROW_SHIFTER << current_col); | |
427 | } | |
428 | ||
429 | // Determine if the matrix changed state | |
430 | if ((last_row_value != current_matrix[row_index]) && !(matrix_changed)) | |
431 | { | |
432 | matrix_changed = true; | |
433 | } | |
434 | } | |
435 | ||
436 | // Unselect col | |
437 | unselect_col(current_col); | |
438 | ||
439 | return matrix_changed; | |
440 | } | |
441 | ||
442 | static void select_col(uint8_t col) | |
443 | { | |
444 | uint8_t pin = col_pins[col]; | |
445 | _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT | |
446 | _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW | |
447 | } | |
448 | ||
449 | static void unselect_col(uint8_t col) | |
450 | { | |
451 | uint8_t pin = col_pins[col]; | |
452 | _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN | |
453 | _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI | |
454 | } | |
455 | ||
456 | static void unselect_cols(void) | |
d7077386 | 457 | { |
07cb997b | 458 | for(uint8_t x = 0; x < MATRIX_COLS; x++) { |
459 | uint8_t pin = col_pins[x]; | |
460 | _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN | |
461 | _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI | |
462 | } | |
d7077386 | 463 | } |
07cb997b | 464 | |
465 | #endif |