matrix.c 8.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359
  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 <string.h>
  20. #include <avr/io.h>
  21. #include <avr/wdt.h>
  22. #include <avr/interrupt.h>
  23. #include <util/delay.h>
  24. #include "print.h"
  25. #include "debug.h"
  26. #include "util.h"
  27. #include "matrix.h"
  28. #include "split_util.h"
  29. #include "pro_micro.h"
  30. #ifdef USE_MATRIX_I2C
  31. # include "i2c.h"
  32. #else // USE_SERIAL
  33. # include "split_scomm.h"
  34. #endif
  35. #ifndef DEBOUNCE
  36. # define DEBOUNCE 5
  37. #endif
  38. #define ERROR_DISCONNECT_COUNT 5
  39. static uint8_t debouncing = DEBOUNCE;
  40. static const int ROWS_PER_HAND = MATRIX_ROWS/2;
  41. static uint8_t error_count = 0;
  42. uint8_t is_master = 0 ;
  43. static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
  44. static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
  45. /* matrix state(1:on, 0:off) */
  46. static matrix_row_t matrix[MATRIX_ROWS];
  47. static matrix_row_t matrix_debouncing[MATRIX_ROWS];
  48. static matrix_row_t read_cols(void);
  49. static void init_cols(void);
  50. static void unselect_rows(void);
  51. static void select_row(uint8_t row);
  52. static uint8_t matrix_master_scan(void);
  53. __attribute__ ((weak))
  54. void matrix_init_kb(void) {
  55. matrix_init_user();
  56. }
  57. __attribute__ ((weak))
  58. void matrix_scan_kb(void) {
  59. matrix_scan_user();
  60. }
  61. __attribute__ ((weak))
  62. void matrix_init_user(void) {
  63. }
  64. __attribute__ ((weak))
  65. void matrix_scan_user(void) {
  66. }
  67. inline
  68. uint8_t matrix_rows(void)
  69. {
  70. return MATRIX_ROWS;
  71. }
  72. inline
  73. uint8_t matrix_cols(void)
  74. {
  75. return MATRIX_COLS;
  76. }
  77. void matrix_init(void)
  78. {
  79. debug_enable = true;
  80. debug_matrix = true;
  81. debug_mouse = true;
  82. // initialize row and col
  83. unselect_rows();
  84. init_cols();
  85. TX_RX_LED_INIT;
  86. TXLED0;
  87. RXLED0;
  88. // initialize matrix state: all keys off
  89. for (uint8_t i=0; i < MATRIX_ROWS; i++) {
  90. matrix[i] = 0;
  91. matrix_debouncing[i] = 0;
  92. }
  93. is_master = has_usb();
  94. matrix_init_quantum();
  95. }
  96. uint8_t _matrix_scan(void)
  97. {
  98. // Right hand is stored after the left in the matirx so, we need to offset it
  99. int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
  100. for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
  101. select_row(i);
  102. _delay_us(30); // without this wait read unstable value.
  103. matrix_row_t cols = read_cols();
  104. if (matrix_debouncing[i+offset] != cols) {
  105. matrix_debouncing[i+offset] = cols;
  106. debouncing = DEBOUNCE;
  107. }
  108. unselect_rows();
  109. }
  110. if (debouncing) {
  111. if (--debouncing) {
  112. _delay_ms(1);
  113. } else {
  114. for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
  115. matrix[i+offset] = matrix_debouncing[i+offset];
  116. }
  117. }
  118. }
  119. return 1;
  120. }
  121. #ifdef USE_MATRIX_I2C
  122. // Get rows from other half over i2c
  123. int i2c_transaction(void) {
  124. int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
  125. int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
  126. if (err) goto i2c_error;
  127. // start of matrix stored at 0x00
  128. err = i2c_master_write(0x00);
  129. if (err) goto i2c_error;
  130. // Start read
  131. err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
  132. if (err) goto i2c_error;
  133. if (!err) {
  134. int i;
  135. for (i = 0; i < ROWS_PER_HAND-1; ++i) {
  136. matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
  137. }
  138. matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
  139. i2c_master_stop();
  140. } else {
  141. i2c_error: // the cable is disconnceted, or something else went wrong
  142. i2c_reset_state();
  143. return err;
  144. }
  145. return 0;
  146. }
  147. #else // USE_SERIAL
  148. int serial_transaction(int master_changed) {
  149. int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
  150. #ifdef SERIAL_USE_MULTI_TRANSACTION
  151. int ret=serial_update_buffers(master_changed);
  152. #else
  153. int ret=serial_update_buffers();
  154. #endif
  155. if (ret ) {
  156. if(ret==2) RXLED1;
  157. return 1;
  158. }
  159. RXLED0;
  160. memcpy(&matrix[slaveOffset],
  161. (void *)serial_slave_buffer, sizeof(serial_slave_buffer));
  162. return 0;
  163. }
  164. #endif
  165. uint8_t matrix_scan(void)
  166. {
  167. if (is_master) {
  168. matrix_master_scan();
  169. }else{
  170. matrix_slave_scan();
  171. int offset = (isLeftHand) ? ROWS_PER_HAND : 0;
  172. memcpy(&matrix[offset],
  173. (void *)serial_master_buffer, sizeof(serial_master_buffer));
  174. matrix_scan_quantum();
  175. }
  176. return 1;
  177. }
  178. uint8_t matrix_master_scan(void) {
  179. int ret = _matrix_scan();
  180. int mchanged = 1;
  181. #ifndef KEYBOARD_helix_rev1
  182. int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
  183. #ifdef USE_MATRIX_I2C
  184. // for (int i = 0; i < ROWS_PER_HAND; ++i) {
  185. /* i2c_slave_buffer[i] = matrix[offset+i]; */
  186. // i2c_slave_buffer[i] = matrix[offset+i];
  187. // }
  188. #else // USE_SERIAL
  189. #ifdef SERIAL_USE_MULTI_TRANSACTION
  190. mchanged = memcmp((void *)serial_master_buffer,
  191. &matrix[offset], sizeof(serial_master_buffer));
  192. #endif
  193. memcpy((void *)serial_master_buffer,
  194. &matrix[offset], sizeof(serial_master_buffer));
  195. #endif
  196. #endif
  197. #ifdef USE_MATRIX_I2C
  198. if( i2c_transaction() ) {
  199. #else // USE_SERIAL
  200. if( serial_transaction(mchanged) ) {
  201. #endif
  202. // turn on the indicator led when halves are disconnected
  203. TXLED1;
  204. error_count++;
  205. if (error_count > ERROR_DISCONNECT_COUNT) {
  206. // reset other half if disconnected
  207. int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
  208. for (int i = 0; i < ROWS_PER_HAND; ++i) {
  209. matrix[slaveOffset+i] = 0;
  210. }
  211. }
  212. } else {
  213. // turn off the indicator led on no error
  214. TXLED0;
  215. error_count = 0;
  216. }
  217. matrix_scan_quantum();
  218. return ret;
  219. }
  220. void matrix_slave_scan(void) {
  221. _matrix_scan();
  222. int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
  223. #ifdef USE_MATRIX_I2C
  224. for (int i = 0; i < ROWS_PER_HAND; ++i) {
  225. /* i2c_slave_buffer[i] = matrix[offset+i]; */
  226. i2c_slave_buffer[i] = matrix[offset+i];
  227. }
  228. #else // USE_SERIAL
  229. #ifdef SERIAL_USE_MULTI_TRANSACTION
  230. int change = 0;
  231. #endif
  232. for (int i = 0; i < ROWS_PER_HAND; ++i) {
  233. #ifdef SERIAL_USE_MULTI_TRANSACTION
  234. if( serial_slave_buffer[i] != matrix[offset+i] )
  235. change = 1;
  236. #endif
  237. serial_slave_buffer[i] = matrix[offset+i];
  238. }
  239. #ifdef SERIAL_USE_MULTI_TRANSACTION
  240. slave_buffer_change_count += change;
  241. #endif
  242. #endif
  243. }
  244. bool matrix_is_modified(void)
  245. {
  246. if (debouncing) return false;
  247. return true;
  248. }
  249. inline
  250. bool matrix_is_on(uint8_t row, uint8_t col)
  251. {
  252. return (matrix[row] & ((matrix_row_t)1<<col));
  253. }
  254. inline
  255. matrix_row_t matrix_get_row(uint8_t row)
  256. {
  257. return matrix[row];
  258. }
  259. void matrix_print(void)
  260. {
  261. print("\nr/c 0123456789ABCDEF\n");
  262. for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
  263. phex(row); print(": ");
  264. pbin_reverse16(matrix_get_row(row));
  265. print("\n");
  266. }
  267. }
  268. uint8_t matrix_key_count(void)
  269. {
  270. uint8_t count = 0;
  271. for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
  272. count += bitpop16(matrix[i]);
  273. }
  274. return count;
  275. }
  276. static void init_cols(void)
  277. {
  278. for(int x = 0; x < MATRIX_COLS; x++) {
  279. _SFR_IO8((col_pins[x] >> 4) + 1) &= ~_BV(col_pins[x] & 0xF);
  280. _SFR_IO8((col_pins[x] >> 4) + 2) |= _BV(col_pins[x] & 0xF);
  281. }
  282. }
  283. static matrix_row_t read_cols(void)
  284. {
  285. matrix_row_t result = 0;
  286. for(int x = 0; x < MATRIX_COLS; x++) {
  287. result |= (_SFR_IO8(col_pins[x] >> 4) & _BV(col_pins[x] & 0xF)) ? 0 : (1 << x);
  288. }
  289. return result;
  290. }
  291. static void unselect_rows(void)
  292. {
  293. for(int x = 0; x < ROWS_PER_HAND; x++) {
  294. _SFR_IO8((row_pins[x] >> 4) + 1) &= ~_BV(row_pins[x] & 0xF);
  295. _SFR_IO8((row_pins[x] >> 4) + 2) |= _BV(row_pins[x] & 0xF);
  296. }
  297. }
  298. static void select_row(uint8_t row)
  299. {
  300. _SFR_IO8((row_pins[row] >> 4) + 1) |= _BV(row_pins[row] & 0xF);
  301. _SFR_IO8((row_pins[row] >> 4) + 2) &= ~_BV(row_pins[row] & 0xF);
  302. }