keyboards/clueboard/66_hotswap/gen1/matrix.c

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