keyboards/preonic/rev3/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_col_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     palSetPadMode(GPIOA, 3,  PAL_MODE_INPUT_PULLDOWN);
  69     palSetPadMode(GPIOA, 6,  PAL_MODE_INPUT_PULLDOWN);
  70
  71
  72     memset(matrix, 0, MATRIX_ROWS * sizeof(matrix_row_t));
  73     memset(matrix_debouncing, 0, MATRIX_COLS * sizeof(matrix_col_t));
  74
  75
  76     matrix_init_quantum();
  77 }
  78
  79 __attribute__ ((weak))
  80 void dip_update(uint8_t index, bool active) { }
  81
  82 __attribute__ ((weak))
  83 void encoder_update(bool clockwise) { }
  84
  85 bool last_dip_switch[4] = {0};
  86
  87 #ifndef ENCODER_RESOLUTION
  88   #define ENCODER_RESOLUTION 4
  89 #endif
  90
  91 uint8_t matrix_scan(void) {
  92     // dip switch
  93     dip_switch[0] = !palReadPad(GPIOB, 14);
  94     dip_switch[1] = !palReadPad(GPIOA, 15);
  95     dip_switch[2] = !palReadPad(GPIOA, 10);
  96     dip_switch[3] = !palReadPad(GPIOB, 9);
  97     for (uint8_t i = 0; i < 4; i++) {
  98       if (last_dip_switch[i] ^ dip_switch[i])
  99         dip_update(i, dip_switch[i]);
 100     }
 101     memcpy(last_dip_switch, dip_switch, sizeof(&dip_switch));
 102
 103     // actual matrix
 104     for (int col = 0; col < MATRIX_COLS; col++) {
 105         matrix_col_t data = 0;
 106
 107         // strobe col { B11, B10, B2, B1, A7, B0 }
 108         switch (col) {
 109             case 0: palSetPad(GPIOB, 11); break;
 110             case 1: palSetPad(GPIOB, 10); break;
 111             case 2: palSetPad(GPIOB, 2); break;
 112             case 3: palSetPad(GPIOB, 1); break;
 113             case 4: palSetPad(GPIOA, 7); break;
 114             case 5: palSetPad(GPIOB, 0); break;
 115         }
 116
 117         // need wait to settle pin state
 118         wait_us(20);
 119
 120         // read row data { A10, A9, A8, B15, C13, C14, C15, A2 }
 121         data = (
 122             (palReadPad(GPIOA, 10) << 0 ) |
 123             (palReadPad(GPIOA, 9)  << 1 ) |
 124             (palReadPad(GPIOA, 8)  << 2 ) |
 125             (palReadPad(GPIOB, 15) << 3 ) |
 126             (palReadPad(GPIOC, 13) << 4 ) |
 127             (palReadPad(GPIOC, 14) << 5 ) |
 128             (palReadPad(GPIOC, 15) << 6 ) |
 129             (palReadPad(GPIOA, 2)  << 7 ) |
 130             (palReadPad(GPIOA, 3)  << 8 ) |
 131             (palReadPad(GPIOA, 6)  << 9 )
 132         );
 133
 134         // unstrobe  col { B11, B10, B2, B1, A7, B0 }
 135         switch (col) {
 136             case 0: palClearPad(GPIOB, 11); break;
 137             case 1: palClearPad(GPIOB, 10); break;
 138             case 2: palClearPad(GPIOB, 2); break;
 139             case 3: palClearPad(GPIOB, 1); break;
 140             case 4: palClearPad(GPIOA, 7); break;
 141             case 5: palClearPad(GPIOB, 0); break;
 142         }
 143
 144         if (matrix_debouncing[col] != data) {
 145             matrix_debouncing[col] = data;
 146             debouncing = true;
 147             debouncing_time = timer_read();
 148         }
 149     }
 150
 151     if (debouncing && timer_elapsed(debouncing_time) > DEBOUNCE) {
 152         for (int row = 0; row < MATRIX_ROWS; row++) {
 153             matrix[row] = 0;
 154             for (int col = 0; col < MATRIX_COLS; col++) {
 155                 matrix[row] |= ((matrix_debouncing[col] & (1 << row) ? 1 : 0) << col);
 156             }
 157         }
 158         debouncing = false;
 159     }
 160
 161     matrix_scan_quantum();
 162
 163     return 1;
 164 }
 165
 166 bool matrix_is_on(uint8_t row, uint8_t col) {
 167     return (matrix[row] & (1<<col));
 168 }
 169
 170 matrix_row_t matrix_get_row(uint8_t row) {
 171     return matrix[row];
 172 }
 173
 174 void matrix_print(void) {
 175     printf("\nr/c 01234567\n");
 176     for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
 177         printf("%X0: ", row);
 178         matrix_row_t data = matrix_get_row(row);
 179         for (int col = 0; col < MATRIX_COLS; col++) {
 180             if (data & (1<<col))
 181                 printf("1");
 182             else
 183                 printf("0");
 184         }
 185         printf("\n");
 186     }
 187 }