matrix.c 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175
  1. #include <stdint.h>
  2. #include <stdbool.h>
  3. #include <string.h>
  4. #include "hal.h"
  5. #include "timer.h"
  6. #include "wait.h"
  7. #include "printf.h"
  8. #include "backlight.h"
  9. #include "matrix.h"
  10. /* Clueboard 60%
  11. *
  12. * Column pins are input with internal pull-down.
  13. * Row pins are output and strobe with high.
  14. * Key is high or 1 when it turns on.
  15. *
  16. * col: { PA2, PA3, PA6, PB14, PB15, PA8, PA9, PA7, PB3, PB4, PC15, PC14, PC13, PB5, PB6 }
  17. * row: { PB0, PB1, PB2, PA15, PA10 }
  18. */
  19. /* matrix state(1:on, 0:off) */
  20. static matrix_row_t matrix[MATRIX_ROWS];
  21. static matrix_row_t matrix_debouncing[MATRIX_COLS];
  22. static bool debouncing = false;
  23. static uint16_t debouncing_time = 0;
  24. __attribute__ ((weak))
  25. void matrix_init_user(void) {}
  26. __attribute__ ((weak))
  27. void matrix_scan_user(void) {}
  28. __attribute__ ((weak))
  29. void matrix_init_kb(void) {
  30. matrix_init_user();
  31. }
  32. __attribute__ ((weak))
  33. void matrix_scan_kb(void) {
  34. matrix_scan_user();
  35. }
  36. void matrix_init(void) {
  37. printf("matrix init\n");
  38. //debug_matrix = true;
  39. /* Column(sense) */
  40. palSetPadMode(GPIOA, 2, PAL_MODE_OUTPUT_PUSHPULL);
  41. palSetPadMode(GPIOA, 3, PAL_MODE_OUTPUT_PUSHPULL);
  42. palSetPadMode(GPIOA, 6, PAL_MODE_OUTPUT_PUSHPULL);
  43. palSetPadMode(GPIOB, 14, PAL_MODE_OUTPUT_PUSHPULL);
  44. palSetPadMode(GPIOB, 15, PAL_MODE_OUTPUT_PUSHPULL);
  45. palSetPadMode(GPIOA, 8, PAL_MODE_OUTPUT_PUSHPULL);
  46. palSetPadMode(GPIOA, 9, PAL_MODE_OUTPUT_PUSHPULL);
  47. palSetPadMode(GPIOA, 7, PAL_MODE_OUTPUT_PUSHPULL);
  48. palSetPadMode(GPIOB, 3, PAL_MODE_OUTPUT_PUSHPULL);
  49. palSetPadMode(GPIOB, 4, PAL_MODE_OUTPUT_PUSHPULL);
  50. palSetPadMode(GPIOC, 15, PAL_MODE_OUTPUT_PUSHPULL);
  51. palSetPadMode(GPIOC, 14, PAL_MODE_OUTPUT_PUSHPULL);
  52. palSetPadMode(GPIOC, 13, PAL_MODE_OUTPUT_PUSHPULL);
  53. palSetPadMode(GPIOB, 5, PAL_MODE_OUTPUT_PUSHPULL);
  54. palSetPadMode(GPIOB, 6, PAL_MODE_OUTPUT_PUSHPULL);
  55. /* Row(strobe) */
  56. palSetPadMode(GPIOB, 0, PAL_MODE_INPUT_PULLDOWN);
  57. palSetPadMode(GPIOB, 1, PAL_MODE_INPUT_PULLDOWN);
  58. palSetPadMode(GPIOB, 2, PAL_MODE_INPUT_PULLDOWN);
  59. palSetPadMode(GPIOA, 15, PAL_MODE_INPUT_PULLDOWN);
  60. palSetPadMode(GPIOA, 10, PAL_MODE_INPUT_PULLDOWN);
  61. memset(matrix, 0, MATRIX_ROWS * sizeof(matrix_row_t));
  62. memset(matrix_debouncing, 0, MATRIX_COLS * sizeof(matrix_row_t));
  63. palClearPad(GPIOB, 7); // Turn off capslock
  64. matrix_init_quantum();
  65. }
  66. uint8_t matrix_scan(void) {
  67. for (int col = 0; col < MATRIX_COLS; col++) {
  68. matrix_row_t data = 0;
  69. // strobe col { PA2, PA3, PA6, PB14, PB15, PA8, PA9, PA7, PB3, PB4, PC14, PC15, PC13, PB5, PB6 }
  70. switch (col) {
  71. case 0: palSetPad(GPIOA, 2); break;
  72. case 1: palSetPad(GPIOA, 3); break;
  73. case 2: palSetPad(GPIOA, 6); break;
  74. case 3: palSetPad(GPIOB, 14); break;
  75. case 4: palSetPad(GPIOB, 15); break;
  76. case 5: palSetPad(GPIOA, 8); break;
  77. case 6: palSetPad(GPIOA, 9); break;
  78. case 7: palSetPad(GPIOA, 7); break;
  79. case 8: palSetPad(GPIOB, 3); break;
  80. case 9: palSetPad(GPIOB, 4); break;
  81. case 10: palSetPad(GPIOC, 15); break;
  82. case 11: palSetPad(GPIOC, 14); break;
  83. case 12: palSetPad(GPIOC, 13); break;
  84. case 13: palSetPad(GPIOB, 5); break;
  85. case 14: palSetPad(GPIOB, 6); break;
  86. }
  87. // need wait to settle pin state
  88. wait_us(20);
  89. // read row data { PB0, PB1, PB2, PA15, PA10 }
  90. data = (
  91. (palReadPad(GPIOB, 0) << 0 ) |
  92. (palReadPad(GPIOB, 1) << 1 ) |
  93. (palReadPad(GPIOB, 2) << 2 ) |
  94. (palReadPad(GPIOA, 15) << 3 ) |
  95. (palReadPad(GPIOA, 10) << 4 )
  96. );
  97. // unstrobe col { PA2, PA3, PA6, PB14, PB15, PA8, PA9, PA7, PB3, PB4, PC15, PC14, PC13, PB5, PB6 }
  98. switch (col) {
  99. case 0: palClearPad(GPIOA, 2); break;
  100. case 1: palClearPad(GPIOA, 3); break;
  101. case 2: palClearPad(GPIOA, 6); break;
  102. case 3: palClearPad(GPIOB, 14); break;
  103. case 4: palClearPad(GPIOB, 15); break;
  104. case 5: palClearPad(GPIOA, 8); break;
  105. case 6: palClearPad(GPIOA, 9); break;
  106. case 7: palClearPad(GPIOA, 7); break;
  107. case 8: palClearPad(GPIOB, 3); break;
  108. case 9: palClearPad(GPIOB, 4); break;
  109. case 10: palClearPad(GPIOC, 15); break;
  110. case 11: palClearPad(GPIOC, 14); break;
  111. case 12: palClearPad(GPIOC, 13); break;
  112. case 13: palClearPad(GPIOB, 5); break;
  113. case 14: palClearPad(GPIOB, 6); break;
  114. }
  115. if (matrix_debouncing[col] != data) {
  116. matrix_debouncing[col] = data;
  117. debouncing = true;
  118. debouncing_time = timer_read();
  119. }
  120. }
  121. if (debouncing && timer_elapsed(debouncing_time) > DEBOUNCE) {
  122. for (int row = 0; row < MATRIX_ROWS; row++) {
  123. matrix[row] = 0;
  124. for (int col = 0; col < MATRIX_COLS; col++) {
  125. matrix[row] |= ((matrix_debouncing[col] & (1 << row) ? 1 : 0) << col);
  126. }
  127. }
  128. debouncing = false;
  129. }
  130. matrix_scan_quantum();
  131. return 1;
  132. }
  133. bool matrix_is_on(uint8_t row, uint8_t col) {
  134. return (matrix[row] & (1<<col));
  135. }
  136. matrix_row_t matrix_get_row(uint8_t row) {
  137. return matrix[row];
  138. }
  139. void matrix_print(void) {
  140. printf("\nr/c 01234567\n");
  141. for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
  142. printf("%X0: ", row);
  143. matrix_row_t data = matrix_get_row(row);
  144. for (int col = 0; col < MATRIX_COLS; col++) {
  145. if (data & (1<<col))
  146. printf("1");
  147. else
  148. printf("0");
  149. }
  150. printf("\n");
  151. }
  152. }