keyboards/hadron/ver3/matrix.c

   1 #include <string.h>
   2 #include "hal.h"
   3 #include "timer.h"
   4 #include "wait.h"
   5 #include "printf.h"
   6 #include "backlight.h"
   7 #include "matrix.h"
   8 #include "action.h"
   9 #include "keycode.h"
  10
  11 /* matrix state(1:on, 0:off) */
  12 static matrix_row_t matrix[MATRIX_ROWS];
  13 static matrix_row_t matrix_debouncing[MATRIX_COLS];
  14 static bool debouncing = false;
  15 static uint16_t debouncing_time = 0;
  16
  17 static uint8_t encoder_state = 0;
  18 static int8_t encoder_value = 0;
  19 static int8_t encoder_LUT[] = { 0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0 };
  20
  21 __attribute__ ((weak))
  22 void matrix_init_user(void) {}
  23
  24 __attribute__ ((weak))
  25 void matrix_scan_user(void) {}
  26
  27 __attribute__ ((weak))
  28 void matrix_init_kb(void) {
  29   matrix_init_user();
  30 }
  31
  32 __attribute__ ((weak))
  33 void matrix_scan_kb(void) {
  34   matrix_scan_user();
  35 }
  36
  37 void matrix_init(void) {
  38     printf("matrix init\n");
  39     //debug_matrix = true;
  40
  41     // encoder setup
  42     palSetPadMode(GPIOB, 13, PAL_MODE_INPUT_PULLUP);
  43     palSetPadMode(GPIOB, 14, PAL_MODE_INPUT_PULLUP);
  44
  45     encoder_state = (palReadPad(GPIOB, 13) << 0) | (palReadPad(GPIOB, 14) << 1);
  46
  47     // actual matrix setup
  48     palSetPadMode(GPIOB, 8, PAL_MODE_OUTPUT_PUSHPULL);
  49     palSetPadMode(GPIOB, 2, PAL_MODE_OUTPUT_PUSHPULL);
  50     palSetPadMode(GPIOB, 10,  PAL_MODE_OUTPUT_PUSHPULL);
  51     palSetPadMode(GPIOA, 0,  PAL_MODE_OUTPUT_PUSHPULL);
  52     palSetPadMode(GPIOA, 1,  PAL_MODE_OUTPUT_PUSHPULL);
  53     palSetPadMode(GPIOA, 2,  PAL_MODE_OUTPUT_PUSHPULL);
  54     palSetPadMode(GPIOB, 0, PAL_MODE_OUTPUT_PUSHPULL);
  55     palSetPadMode(GPIOA, 3, PAL_MODE_OUTPUT_PUSHPULL);
  56     palSetPadMode(GPIOB, 1,  PAL_MODE_OUTPUT_PUSHPULL);
  57     palSetPadMode(GPIOA, 6,  PAL_MODE_OUTPUT_PUSHPULL);
  58     palSetPadMode(GPIOA, 7,  PAL_MODE_OUTPUT_PUSHPULL);
  59     palSetPadMode(GPIOB, 12,  PAL_MODE_OUTPUT_PUSHPULL);
  60     palSetPadMode(GPIOC, 13,  PAL_MODE_OUTPUT_PUSHPULL);
  61     palSetPadMode(GPIOB, 11,  PAL_MODE_OUTPUT_PUSHPULL);
  62     palSetPadMode(GPIOB, 9,  PAL_MODE_OUTPUT_PUSHPULL);
  63
  64     palSetPadMode(GPIOC, 15, PAL_MODE_INPUT_PULLDOWN);
  65     palSetPadMode(GPIOC, 14,  PAL_MODE_INPUT_PULLDOWN);
  66     palSetPadMode(GPIOA, 10,  PAL_MODE_INPUT_PULLDOWN);
  67     palSetPadMode(GPIOA, 9, PAL_MODE_INPUT_PULLDOWN);
  68     palSetPadMode(GPIOA, 8, PAL_MODE_INPUT_PULLDOWN);
  69
  70
  71     memset(matrix, 0, MATRIX_ROWS * sizeof(matrix_row_t));
  72     memset(matrix_debouncing, 0, MATRIX_COLS * sizeof(matrix_row_t));
  73
  74
  75     matrix_init_quantum();
  76 }
  77
  78 __attribute__ ((weak))
  79 void encoder_update(bool clockwise) { }
  80
  81 #ifndef ENCODER_RESOLUTION
  82   #define ENCODER_RESOLUTION 4
  83 #endif
  84
  85 uint8_t matrix_scan(void) {
  86     // encoder on B13 and B14
  87     encoder_state <<= 2;
  88     encoder_state |= (palReadPad(GPIOB, 13) << 0) | (palReadPad(GPIOB, 14) << 1);
  89     encoder_value += encoder_LUT[encoder_state & 0xF];
  90     if (encoder_value >= ENCODER_RESOLUTION) {
  91         encoder_update(0);
  92     }
  93     if (encoder_value <= -ENCODER_RESOLUTION) { // direction is arbitrary here, but this clockwise
  94         encoder_update(1);
  95     }
  96     encoder_value %= ENCODER_RESOLUTION;
  97
  98     // actual matrix
  99     for (int col = 0; col < MATRIX_COLS; col++) {
 100         matrix_row_t data = 0;
 101
 102         // strobe col { PB8, PB2, PB10, PA0, PA1, PA2, PB0, PA3, PB1, PA6, PA7, PB1, PA6, PA7, PB12, PC3, PB11,  }
 103         switch (col) {
 104             case 0:  palSetPad(GPIOB, 8); break;
 105             case 1:  palSetPad(GPIOB, 2); break;
 106             case 2:  palSetPad(GPIOB, 10); break;
 107             case 3:  palSetPad(GPIOA, 0); break;
 108             case 4:  palSetPad(GPIOA, 1); break;
 109             case 5:  palSetPad(GPIOA, 2); break;
 110             case 6:  palSetPad(GPIOB, 0); break;
 111             case 7:  palSetPad(GPIOA, 3); break;
 112             case 8:  palSetPad(GPIOB, 1); break;
 113             case 9:  palSetPad(GPIOA, 6); break;
 114             case 10: palSetPad(GPIOA, 7); break;
 115             case 11: palSetPad(GPIOB, 12); break;
 116             case 12: palSetPad(GPIOC, 13); break;
 117             case 13: palSetPad(GPIOB, 11); break;
 118             case 14: palSetPad(GPIOB, 9); break;
 119         }
 120
 121         // need wait to settle pin state
 122         wait_us(20);
 123
 124         // read row data { PC15, PC14, PA10, PA9, PA8 }
 125         data = (
 126             (palReadPad(GPIOC, 15)  << 0 ) |
 127             (palReadPad(GPIOC, 14)  << 1 ) |
 128             (palReadPad(GPIOA, 10)  << 2 ) |
 129             (palReadPad(GPIOA, 9)   << 3 ) |
 130             (palReadPad(GPIOA, 8)   << 4 )
 131         );
 132
 133         // unstrobe  col { PB8, PB2, PB10, PA0, PA1, PA2, PB0, PA3, PB1, PA6, PA7, PB1, PA6, PA7, PB12, PC3, PB11,  }
 134         switch (col) {
 135             case 0:  palClearPad(GPIOB, 8); break;
 136             case 1:  palClearPad(GPIOB, 2); break;
 137             case 2:  palClearPad(GPIOB, 10); break;
 138             case 3:  palClearPad(GPIOA, 0); break;
 139             case 4:  palClearPad(GPIOA, 1); break;
 140             case 5:  palClearPad(GPIOA, 2); break;
 141             case 6:  palClearPad(GPIOB, 0); break;
 142             case 7:  palClearPad(GPIOA, 3); break;
 143             case 8:  palClearPad(GPIOB, 1); break;
 144             case 9:  palClearPad(GPIOA, 6); break;
 145             case 10: palClearPad(GPIOA, 7); break;
 146             case 11: palClearPad(GPIOB, 12); break;
 147             case 12: palClearPad(GPIOC, 13); break;
 148             case 13: palClearPad(GPIOB, 11); break;
 149             case 14: palClearPad(GPIOB, 9); break;
 150         }
 151
 152         if (matrix_debouncing[col] != data) {
 153             matrix_debouncing[col] = data;
 154             debouncing = true;
 155             debouncing_time = timer_read();
 156         }
 157     }
 158
 159     if (debouncing && timer_elapsed(debouncing_time) > DEBOUNCE) {
 160         for (int row = 0; row < MATRIX_ROWS; row++) {
 161             matrix[row] = 0;
 162             for (int col = 0; col < MATRIX_COLS; col++) {
 163                 matrix[row] |= ((matrix_debouncing[col] & (1 << row) ? 1 : 0) << col);
 164             }
 165         }
 166         debouncing = false;
 167     }
 168
 169     matrix_scan_quantum();
 170
 171     return 1;
 172 }
 173
 174 bool matrix_is_on(uint8_t row, uint8_t col) {
 175     return (matrix[row] & (1<<col));
 176 }
 177
 178 matrix_row_t matrix_get_row(uint8_t row) {
 179     return matrix[row];
 180 }
 181
 182 void matrix_print(void) {
 183     printf("\nr/c 01234567\n");
 184     for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
 185         printf("%X0: ", row);
 186         matrix_row_t data = matrix_get_row(row);
 187         for (int col = 0; col < MATRIX_COLS; col++) {
 188             if (data & (1<<col))
 189                 printf("1");
 190             else
 191                 printf("0");
 192         }
 193         printf("\n");
 194     }
 195 }