matrix.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536
  1. /*
  2. Copyright 2012 Jun Wako <wakojun@gmail.com>
  3. This program is free software: you can redistribute it and/or modify
  4. it under the terms of the GNU General Public License as published by
  5. the Free Software Foundation, either version 2 of the License, or
  6. (at your option) any later version.
  7. This program is distributed in the hope that it will be useful,
  8. but WITHOUT ANY WARRANTY; without even the implied warranty of
  9. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  10. GNU General Public License for more details.
  11. You should have received a copy of the GNU General Public License
  12. along with this program. If not, see <http://www.gnu.org/licenses/>.
  13. */
  14. /*
  15. * scan matrix
  16. */
  17. #include <stdint.h>
  18. #include <stdbool.h>
  19. #include <avr/io.h>
  20. #include "wait.h"
  21. #include "print.h"
  22. #include "debug.h"
  23. #include "util.h"
  24. #include "matrix.h"
  25. #include "split_util.h"
  26. #include "pro_micro.h"
  27. #include "config.h"
  28. #include "timer.h"
  29. #include "split_flags.h"
  30. #ifdef RGBLIGHT_ENABLE
  31. # include "rgblight.h"
  32. #endif
  33. #ifdef BACKLIGHT_ENABLE
  34. # include "backlight.h"
  35. extern backlight_config_t backlight_config;
  36. #endif
  37. #if defined(USE_I2C) || defined(EH)
  38. # include "i2c.h"
  39. #else // USE_SERIAL
  40. # include "serial.h"
  41. #endif
  42. #ifndef DEBOUNCING_DELAY
  43. # define DEBOUNCING_DELAY 5
  44. #endif
  45. #if (DEBOUNCING_DELAY > 0)
  46. static uint16_t debouncing_time;
  47. static bool debouncing = false;
  48. #endif
  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. #define ERROR_DISCONNECT_COUNT 5
  59. #define ROWS_PER_HAND (MATRIX_ROWS/2)
  60. static uint8_t error_count = 0;
  61. static uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
  62. static uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
  63. /* matrix state(1:on, 0:off) */
  64. static matrix_row_t matrix[MATRIX_ROWS];
  65. static matrix_row_t matrix_debouncing[MATRIX_ROWS];
  66. #if (DIODE_DIRECTION == COL2ROW)
  67. static void init_cols(void);
  68. static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
  69. static void unselect_rows(void);
  70. static void select_row(uint8_t row);
  71. static void unselect_row(uint8_t row);
  72. #elif (DIODE_DIRECTION == ROW2COL)
  73. static void init_rows(void);
  74. static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
  75. static void unselect_cols(void);
  76. static void unselect_col(uint8_t col);
  77. static void select_col(uint8_t col);
  78. #endif
  79. __attribute__ ((weak))
  80. void matrix_init_kb(void) {
  81. matrix_init_user();
  82. }
  83. __attribute__ ((weak))
  84. void matrix_scan_kb(void) {
  85. matrix_scan_user();
  86. }
  87. __attribute__ ((weak))
  88. void matrix_init_user(void) {
  89. }
  90. __attribute__ ((weak))
  91. void matrix_scan_user(void) {
  92. }
  93. __attribute__ ((weak))
  94. void matrix_slave_scan_user(void) {
  95. }
  96. inline
  97. uint8_t matrix_rows(void)
  98. {
  99. return MATRIX_ROWS;
  100. }
  101. inline
  102. uint8_t matrix_cols(void)
  103. {
  104. return MATRIX_COLS;
  105. }
  106. void matrix_init(void)
  107. {
  108. #ifdef DISABLE_JTAG
  109. // JTAG disable for PORT F. write JTD bit twice within four cycles.
  110. MCUCR |= (1<<JTD);
  111. MCUCR |= (1<<JTD);
  112. #endif
  113. debug_enable = true;
  114. debug_matrix = true;
  115. debug_mouse = true;
  116. // Set pinout for right half if pinout for that half is defined
  117. if (!isLeftHand) {
  118. #ifdef MATRIX_ROW_PINS_RIGHT
  119. const uint8_t row_pins_right[MATRIX_ROWS] = MATRIX_ROW_PINS_RIGHT;
  120. for (uint8_t i = 0; i < MATRIX_ROWS; i++)
  121. row_pins[i] = row_pins_right[i];
  122. #endif
  123. #ifdef MATRIX_COL_PINS_RIGHT
  124. const uint8_t col_pins_right[MATRIX_COLS] = MATRIX_COL_PINS_RIGHT;
  125. for (uint8_t i = 0; i < MATRIX_COLS; i++)
  126. col_pins[i] = col_pins_right[i];
  127. #endif
  128. }
  129. // initialize row and col
  130. #if (DIODE_DIRECTION == COL2ROW)
  131. unselect_rows();
  132. init_cols();
  133. #elif (DIODE_DIRECTION == ROW2COL)
  134. unselect_cols();
  135. init_rows();
  136. #endif
  137. // initialize matrix state: all keys off
  138. for (uint8_t i=0; i < MATRIX_ROWS; i++) {
  139. matrix[i] = 0;
  140. matrix_debouncing[i] = 0;
  141. }
  142. matrix_init_quantum();
  143. }
  144. uint8_t _matrix_scan(void)
  145. {
  146. int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
  147. #if (DIODE_DIRECTION == COL2ROW)
  148. // Set row, read cols
  149. for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
  150. # if (DEBOUNCING_DELAY > 0)
  151. bool matrix_changed = read_cols_on_row(matrix_debouncing+offset, current_row);
  152. if (matrix_changed) {
  153. debouncing = true;
  154. debouncing_time = timer_read();
  155. }
  156. # else
  157. read_cols_on_row(matrix+offset, current_row);
  158. # endif
  159. }
  160. #elif (DIODE_DIRECTION == ROW2COL)
  161. // Set col, read rows
  162. for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
  163. # if (DEBOUNCING_DELAY > 0)
  164. bool matrix_changed = read_rows_on_col(matrix_debouncing+offset, current_col);
  165. if (matrix_changed) {
  166. debouncing = true;
  167. debouncing_time = timer_read();
  168. }
  169. # else
  170. read_rows_on_col(matrix+offset, current_col);
  171. # endif
  172. }
  173. #endif
  174. # if (DEBOUNCING_DELAY > 0)
  175. if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) {
  176. for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
  177. matrix[i+offset] = matrix_debouncing[i+offset];
  178. }
  179. debouncing = false;
  180. }
  181. # endif
  182. return 1;
  183. }
  184. #if defined(USE_I2C) || defined(EH)
  185. // Get rows from other half over i2c
  186. int i2c_transaction(void) {
  187. int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
  188. int err = 0;
  189. // write backlight info
  190. #ifdef BACKLIGHT_ENABLE
  191. if (BACKLIT_DIRTY) {
  192. err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
  193. if (err) goto i2c_error;
  194. // Backlight location
  195. err = i2c_master_write(I2C_BACKLIT_START);
  196. if (err) goto i2c_error;
  197. // Write backlight
  198. i2c_master_write(get_backlight_level());
  199. BACKLIT_DIRTY = false;
  200. }
  201. #endif
  202. err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
  203. if (err) goto i2c_error;
  204. // start of matrix stored at I2C_KEYMAP_START
  205. err = i2c_master_write(I2C_KEYMAP_START);
  206. if (err) goto i2c_error;
  207. // Start read
  208. err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
  209. if (err) goto i2c_error;
  210. if (!err) {
  211. int i;
  212. for (i = 0; i < ROWS_PER_HAND-1; ++i) {
  213. matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
  214. }
  215. matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
  216. i2c_master_stop();
  217. } else {
  218. i2c_error: // the cable is disconnceted, or something else went wrong
  219. i2c_reset_state();
  220. return err;
  221. }
  222. #ifdef RGBLIGHT_ENABLE
  223. if (RGB_DIRTY) {
  224. err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
  225. if (err) goto i2c_error;
  226. // RGB Location
  227. err = i2c_master_write(I2C_RGB_START);
  228. if (err) goto i2c_error;
  229. uint32_t dword = eeconfig_read_rgblight();
  230. // Write RGB
  231. err = i2c_master_write_data(&dword, 4);
  232. if (err) goto i2c_error;
  233. RGB_DIRTY = false;
  234. i2c_master_stop();
  235. }
  236. #endif
  237. return 0;
  238. }
  239. #else // USE_SERIAL
  240. int serial_transaction(void) {
  241. int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
  242. if (serial_update_buffers()) {
  243. return 1;
  244. }
  245. for (int i = 0; i < ROWS_PER_HAND; ++i) {
  246. matrix[slaveOffset+i] = serial_slave_buffer[i];
  247. }
  248. #ifdef RGBLIGHT_ENABLE
  249. // Code to send RGB over serial goes here (not implemented yet)
  250. #endif
  251. #ifdef BACKLIGHT_ENABLE
  252. // Write backlight level for slave to read
  253. serial_master_buffer[SERIAL_BACKLIT_START] = backlight_config.enable ? backlight_config.level : 0;
  254. #endif
  255. return 0;
  256. }
  257. #endif
  258. uint8_t matrix_scan(void)
  259. {
  260. uint8_t ret = _matrix_scan();
  261. #if defined(USE_I2C) || defined(EH)
  262. if( i2c_transaction() ) {
  263. #else // USE_SERIAL
  264. if( serial_transaction() ) {
  265. #endif
  266. error_count++;
  267. if (error_count > ERROR_DISCONNECT_COUNT) {
  268. // reset other half if disconnected
  269. int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
  270. for (int i = 0; i < ROWS_PER_HAND; ++i) {
  271. matrix[slaveOffset+i] = 0;
  272. }
  273. }
  274. } else {
  275. error_count = 0;
  276. }
  277. matrix_scan_quantum();
  278. return ret;
  279. }
  280. void matrix_slave_scan(void) {
  281. _matrix_scan();
  282. int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
  283. #if defined(USE_I2C) || defined(EH)
  284. for (int i = 0; i < ROWS_PER_HAND; ++i) {
  285. i2c_slave_buffer[I2C_KEYMAP_START+i] = matrix[offset+i];
  286. }
  287. #else // USE_SERIAL
  288. for (int i = 0; i < ROWS_PER_HAND; ++i) {
  289. serial_slave_buffer[i] = matrix[offset+i];
  290. }
  291. #endif
  292. matrix_slave_scan_user();
  293. }
  294. bool matrix_is_modified(void)
  295. {
  296. if (debouncing) return false;
  297. return true;
  298. }
  299. inline
  300. bool matrix_is_on(uint8_t row, uint8_t col)
  301. {
  302. return (matrix[row] & ((matrix_row_t)1<<col));
  303. }
  304. inline
  305. matrix_row_t matrix_get_row(uint8_t row)
  306. {
  307. return matrix[row];
  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. uint8_t matrix_key_count(void)
  319. {
  320. uint8_t count = 0;
  321. for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
  322. count += bitpop16(matrix[i]);
  323. }
  324. return count;
  325. }
  326. #if (DIODE_DIRECTION == COL2ROW)
  327. static void init_cols(void)
  328. {
  329. for(uint8_t x = 0; x < MATRIX_COLS; x++) {
  330. uint8_t pin = col_pins[x];
  331. _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
  332. _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
  333. }
  334. }
  335. static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
  336. {
  337. // Store last value of row prior to reading
  338. matrix_row_t last_row_value = current_matrix[current_row];
  339. // Clear data in matrix row
  340. current_matrix[current_row] = 0;
  341. // Select row and wait for row selecton to stabilize
  342. select_row(current_row);
  343. wait_us(30);
  344. // For each col...
  345. for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
  346. // Select the col pin to read (active low)
  347. uint8_t pin = col_pins[col_index];
  348. uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
  349. // Populate the matrix row with the state of the col pin
  350. current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
  351. }
  352. // Unselect row
  353. unselect_row(current_row);
  354. return (last_row_value != current_matrix[current_row]);
  355. }
  356. static void select_row(uint8_t row)
  357. {
  358. uint8_t pin = row_pins[row];
  359. _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
  360. _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
  361. }
  362. static void unselect_row(uint8_t row)
  363. {
  364. uint8_t pin = row_pins[row];
  365. _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
  366. _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
  367. }
  368. static void unselect_rows(void)
  369. {
  370. for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
  371. uint8_t pin = row_pins[x];
  372. _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
  373. _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
  374. }
  375. }
  376. #elif (DIODE_DIRECTION == ROW2COL)
  377. static void init_rows(void)
  378. {
  379. for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
  380. uint8_t pin = row_pins[x];
  381. _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
  382. _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
  383. }
  384. }
  385. static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
  386. {
  387. bool matrix_changed = false;
  388. // Select col and wait for col selecton to stabilize
  389. select_col(current_col);
  390. wait_us(30);
  391. // For each row...
  392. for(uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++)
  393. {
  394. // Store last value of row prior to reading
  395. matrix_row_t last_row_value = current_matrix[row_index];
  396. // Check row pin state
  397. if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
  398. {
  399. // Pin LO, set col bit
  400. current_matrix[row_index] |= (ROW_SHIFTER << current_col);
  401. }
  402. else
  403. {
  404. // Pin HI, clear col bit
  405. current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
  406. }
  407. // Determine if the matrix changed state
  408. if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
  409. {
  410. matrix_changed = true;
  411. }
  412. }
  413. // Unselect col
  414. unselect_col(current_col);
  415. return matrix_changed;
  416. }
  417. static void select_col(uint8_t col)
  418. {
  419. uint8_t pin = col_pins[col];
  420. _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
  421. _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
  422. }
  423. static void unselect_col(uint8_t col)
  424. {
  425. uint8_t pin = col_pins[col];
  426. _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
  427. _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
  428. }
  429. static void unselect_cols(void)
  430. {
  431. for(uint8_t x = 0; x < MATRIX_COLS; x++) {
  432. uint8_t pin = col_pins[x];
  433. _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
  434. _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
  435. }
  436. }
  437. #endif