keyboards/planck/rev6/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  *     col: { B11, B10, B2, B1, A7, B0 }
  16  *     row: { A10, A9, A8, B15, C13, C14, C15, A2 }
  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 static bool dip_switch[4] = {0, 0, 0, 0};
  25
  26 __attribute__ ((weak))
  27 void matrix_init_user(void) {}
  28
  29 __attribute__ ((weak))
  30 void matrix_scan_user(void) {}
  31
  32 __attribute__ ((weak))
  33 void matrix_init_kb(void) {
  34   matrix_init_user();
  35 }
  36
  37 __attribute__ ((weak))
  38 void matrix_scan_kb(void) {
  39   matrix_scan_user();
  40 }
  41
  42 void matrix_init(void) {
  43     printf("matrix init\n");
  44     //debug_matrix = true;
  45
  46     // dip switch setup
  47     palSetPadMode(GPIOB, 14, PAL_MODE_INPUT_PULLUP);
  48     palSetPadMode(GPIOA, 15, PAL_MODE_INPUT_PULLUP);
  49     palSetPadMode(GPIOA, 10, PAL_MODE_INPUT_PULLUP);
  50     palSetPadMode(GPIOB, 9,  PAL_MODE_INPUT_PULLUP);
  51
  52     // actual matrix setup
  53     palSetPadMode(GPIOB, 11, PAL_MODE_OUTPUT_PUSHPULL);
  54     palSetPadMode(GPIOB, 10, PAL_MODE_OUTPUT_PUSHPULL);
  55     palSetPadMode(GPIOB, 2,  PAL_MODE_OUTPUT_PUSHPULL);
  56     palSetPadMode(GPIOB, 1,  PAL_MODE_OUTPUT_PUSHPULL);
  57     palSetPadMode(GPIOA, 7,  PAL_MODE_OUTPUT_PUSHPULL);
  58     palSetPadMode(GPIOB, 0,  PAL_MODE_OUTPUT_PUSHPULL);
  59
  60     palSetPadMode(GPIOA, 10, PAL_MODE_INPUT_PULLDOWN);
  61     palSetPadMode(GPIOA, 9,  PAL_MODE_INPUT_PULLDOWN);
  62     palSetPadMode(GPIOA, 8,  PAL_MODE_INPUT_PULLDOWN);
  63     palSetPadMode(GPIOB, 15, PAL_MODE_INPUT_PULLDOWN);
  64     palSetPadMode(GPIOC, 13, PAL_MODE_INPUT_PULLDOWN);
  65     palSetPadMode(GPIOC, 14, PAL_MODE_INPUT_PULLDOWN);
  66     palSetPadMode(GPIOC, 15, PAL_MODE_INPUT_PULLDOWN);
  67     palSetPadMode(GPIOA, 2,  PAL_MODE_INPUT_PULLDOWN);
  68
  69
  70     memset(matrix, 0, MATRIX_ROWS * sizeof(matrix_row_t));
  71     memset(matrix_debouncing, 0, MATRIX_COLS * sizeof(matrix_row_t));
  72
  73
  74     matrix_init_quantum();
  75 }
  76
  77 __attribute__ ((weak))
  78 void dip_update(uint8_t index, bool active) { }
  79
  80 bool last_dip_switch[4] = {0};
  81
  82 uint8_t matrix_scan(void) {
  83     // dip switch
  84     dip_switch[0] = !palReadPad(GPIOB, 14);
  85     dip_switch[1] = !palReadPad(GPIOA, 15);
  86     dip_switch[2] = !palReadPad(GPIOA, 10);
  87     dip_switch[3] = !palReadPad(GPIOB, 9);
  88     for (uint8_t i = 0; i < 4; i++) {
  89       if (last_dip_switch[i] ^ dip_switch[i])
  90         dip_update(i, dip_switch[i]);
  91     }
  92     memcpy(last_dip_switch, dip_switch, sizeof(&dip_switch));
  93
  94     // actual matrix
  95     for (int col = 0; col < MATRIX_COLS; col++) {
  96         matrix_row_t data = 0;
  97
  98         // strobe col { B11, B10, B2, B1, A7, B0 }
  99         switch (col) {
 100             case 0: palSetPad(GPIOB, 11); break;
 101             case 1: palSetPad(GPIOB, 10); break;
 102             case 2: palSetPad(GPIOB, 2); break;
 103             case 3: palSetPad(GPIOB, 1); break;
 104             case 4: palSetPad(GPIOA, 7); break;
 105             case 5: palSetPad(GPIOB, 0); break;
 106         }
 107
 108         // need wait to settle pin state
 109         wait_us(20);
 110
 111         // read row data { A10, A9, A8, B15, C13, C14, C15, A2 }
 112         data = (
 113             (palReadPad(GPIOA, 10) << 0 ) |
 114             (palReadPad(GPIOA, 9)  << 1 ) |
 115             (palReadPad(GPIOA, 8)  << 2 ) |
 116             (palReadPad(GPIOB, 15) << 3 ) |
 117             (palReadPad(GPIOC, 13) << 4 ) |
 118             (palReadPad(GPIOC, 14) << 5 ) |
 119             (palReadPad(GPIOC, 15) << 6 ) |
 120             (palReadPad(GPIOA, 2)  << 7 )
 121         );
 122
 123         // unstrobe  col { B11, B10, B2, B1, A7, B0 }
 124         switch (col) {
 125             case 0: palClearPad(GPIOB, 11); break;
 126             case 1: palClearPad(GPIOB, 10); break;
 127             case 2: palClearPad(GPIOB, 2); break;
 128             case 3: palClearPad(GPIOB, 1); break;
 129             case 4: palClearPad(GPIOA, 7); break;
 130             case 5: palClearPad(GPIOB, 0); break;
 131         }
 132
 133         if (matrix_debouncing[col] != data) {
 134             matrix_debouncing[col] = data;
 135             debouncing = true;
 136             debouncing_time = timer_read();
 137         }
 138     }
 139
 140     if (debouncing && timer_elapsed(debouncing_time) > DEBOUNCE) {
 141         for (int row = 0; row < MATRIX_ROWS; row++) {
 142             matrix[row] = 0;
 143             for (int col = 0; col < MATRIX_COLS; col++) {
 144                 matrix[row] |= ((matrix_debouncing[col] & (1 << row) ? 1 : 0) << col);
 145             }
 146         }
 147         debouncing = false;
 148     }
 149
 150     matrix_scan_quantum();
 151
 152     return 1;
 153 }
 154
 155 bool matrix_is_on(uint8_t row, uint8_t col) {
 156     return (matrix[row] & (1<<col));
 157 }
 158
 159 matrix_row_t matrix_get_row(uint8_t row) {
 160     return matrix[row];
 161 }
 162
 163 void matrix_print(void) {
 164     printf("\nr/c 01234567\n");
 165     for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
 166         printf("%X0: ", row);
 167         matrix_row_t data = matrix_get_row(row);
 168         for (int col = 0; col < MATRIX_COLS; col++) {
 169             if (data & (1<<col))
 170                 printf("1");
 171             else
 172                 printf("0");
 173         }
 174         printf("\n");
 175     }
 176 }