keyboards/meira/matrix.c

   1 /*
   2 Copyright 2012 Jun Wako <wakojun@gmail.com>
   3 Copyright 2017 Cole Markham <cole@ccmcomputing.net>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 /*
  20  * scan matrix
  21  */
  22 #include <stdint.h>
  23 #include <stdbool.h>
  24 #if defined(__AVR__)
  25 #include <avr/io.h>
  26 #endif
  27 #include "meira.h"
  28 #include "wait.h"
  29 #include "print.h"
  30 #include "debug.h"
  31 #include "util.h"
  32 #include "matrix.h"
  33 #include "config.h"
  34 #include "timer.h"
  35
  36 #ifndef DEBOUNCE
  37 #   define DEBOUNCE 5
  38 #endif
  39
  40 #if (DEBOUNCE > 0)
  41     static uint16_t debouncing_time;
  42     static bool debouncing = false;
  43 #endif
  44
  45 #if (MATRIX_COLS <= 8)
  46 #    define print_matrix_header()  print("\nr/c 01234567\n")
  47 #    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
  48 #    define matrix_bitpop(i)       bitpop(matrix[i])
  49 #    define ROW_SHIFTER ((uint8_t)1)
  50 #elif (MATRIX_COLS <= 16)
  51 #    define print_matrix_header()  print("\nr/c 0123456789ABCDEF\n")
  52 #    define print_matrix_row(row)  print_bin_reverse16(matrix_get_row(row))
  53 #    define matrix_bitpop(i)       bitpop16(matrix[i])
  54 #    define ROW_SHIFTER ((uint16_t)1)
  55 #elif (MATRIX_COLS <= 32)
  56 #    define print_matrix_header()  print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
  57 #    define print_matrix_row(row)  print_bin_reverse32(matrix_get_row(row))
  58 #    define matrix_bitpop(i)       bitpop32(matrix[i])
  59 #    define ROW_SHIFTER  ((uint32_t)1)
  60 #endif
  61
  62 static matrix_row_t matrix_debouncing[MATRIX_ROWS];
  63
  64 static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
  65 static const uint8_t col_pins[4] = MATRIX_COL_PINS;
  66 //static const uint8_t lrow_pins[MATRIX_ROWS] = LED_ROW_PINS;
  67 //static const uint8_t lcol_pins[4] = LED_COL_PINS;
  68
  69 /* matrix state(1:on, 0:off) */
  70 static matrix_row_t matrix[MATRIX_ROWS];
  71 static matrix_row_t matrix_debouncing[MATRIX_ROWS];
  72 static void init_rows(void);
  73 //static void init_lcols(void);
  74 static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
  75 static void unselect_cols(void);
  76 static void select_col(uint8_t col);
  77
  78
  79 __attribute__ ((weak))
  80 void matrix_init_kb(void) {
  81     matrix_init_user();
  82 }
  83
  84 __attribute__ ((weak))
  85 void matrix_scan_kb(void) {
  86     matrix_scan_user();
  87 }
  88
  89 __attribute__ ((weak))
  90 void matrix_init_user(void) {
  91 }
  92
  93 __attribute__ ((weak))
  94 void matrix_scan_user(void) {
  95 }
  96
  97 inline
  98 uint8_t matrix_rows(void)
  99 {
 100     return MATRIX_ROWS;
 101 }
 102
 103 inline
 104 uint8_t matrix_cols(void)
 105 {
 106     return MATRIX_COLS;
 107 }
 108
 109 void matrix_init(void)
 110 {
 111     debug_enable = true;
 112     debug_matrix = true;
 113     debug_mouse = true;
 114     // initialize row and col
 115     unselect_cols();
 116     init_rows();
 117 //    init_lcols();
 118
 119 //    TX_RX_LED_INIT;
 120
 121     // initialize matrix state: all keys off
 122     for (uint8_t i=0; i < MATRIX_ROWS; i++) {
 123         matrix[i] = 0;
 124         matrix_debouncing[i] = 0;
 125     }
 126
 127     matrix_init_quantum();
 128
 129 }
 130
 131 uint8_t _matrix_scan(void)
 132 {
 133     // Set col, read rows
 134     for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
 135 #       if (DEBOUNCE > 0)
 136             bool matrix_changed = read_rows_on_col(matrix_debouncing, current_col);
 137             if (matrix_changed) {
 138                 debouncing = true;
 139                 debouncing_time = timer_read();
 140             }
 141 #       else
 142              read_rows_on_col(matrix, current_col);
 143 #       endif
 144
 145     }
 146
 147 #   if (DEBOUNCE > 0)
 148         if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCE)) {
 149             for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 150                 matrix[i] = matrix_debouncing[i];
 151             }
 152             debouncing = false;
 153         }
 154 #   endif
 155
 156         return 1;
 157 }
 158
 159 uint8_t matrix_scan(void)
 160 {
 161         uint8_t ret = _matrix_scan();
 162         matrix_scan_quantum();
 163         return ret;
 164 }
 165
 166 bool matrix_is_modified(void)
 167 {
 168     if (debouncing) return false;
 169     return true;
 170 }
 171
 172 inline
 173 bool matrix_is_on(uint8_t row, uint8_t col)
 174 {
 175     return (matrix[row] & ((matrix_row_t)1<<col));
 176 }
 177
 178 inline
 179 matrix_row_t matrix_get_row(uint8_t row)
 180 {
 181     return matrix[row];
 182 }
 183
 184 void matrix_print(void)
 185 {
 186     print("\nr/c 0123456789ABCDEF\n");
 187     for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
 188         phex(row); print(": ");
 189         pbin_reverse16(matrix_get_row(row));
 190         print("\n");
 191     }
 192 }
 193
 194 uint8_t matrix_key_count(void)
 195 {
 196     uint8_t count = 0;
 197     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 198         count += bitpop16(matrix[i]);
 199     }
 200     return count;
 201 }
 202
 203
 204 static void init_rows(void)
 205 {
 206     for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
 207         uint8_t pin = row_pins[x];
 208         _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
 209         _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 210     }
 211 }
 212
 213
 214 static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
 215 {
 216     bool matrix_changed = false;
 217
 218     // Select col and wait for col selection to stabilize
 219     select_col(current_col);
 220     wait_us(30);
 221
 222     // For each row...
 223     for(uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++)
 224     {
 225
 226         // Store last value of row prior to reading
 227         matrix_row_t last_row_value = current_matrix[row_index];
 228
 229         // Check row pin state
 230         if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
 231         {
 232             // Pin LO, set col bit
 233             current_matrix[row_index] |= (ROW_SHIFTER << current_col);
 234         }
 235         else
 236         {
 237             // Pin HI, clear col bit
 238             current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
 239         }
 240
 241         // Determine if the matrix changed state
 242         if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
 243         {
 244             matrix_changed = true;
 245         }
 246     }
 247
 248     // Unselect col
 249     unselect_cols();
 250
 251     return matrix_changed;
 252 }
 253
 254 static void select_col(uint8_t col)
 255 {
 256 #ifdef FLIPPED_BOARD
 257         col = MATRIX_COLS - col - 1;
 258 #endif
 259     for(uint8_t x = 0; x < 4; x++) {
 260                 uint8_t pin = col_pins[x];
 261         _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
 262                 if (((col >> x) & 0x1) == 1){
 263                         _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HIGH
 264                 } else {
 265                         _SFR_IO8((pin >> 4) + 2) &=  ~_BV(pin & 0xF); // LOW
 266                 }
 267         }
 268 }
 269
 270 static void unselect_cols(void)
 271 {
 272         // FIXME This really needs to use the global enable on the decoder, because currently this sets the value to col1
 273     for(uint8_t x = 0; x < 4; x++) {
 274         uint8_t pin = col_pins[x];
 275         _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
 276         _SFR_IO8((pin >> 4) + 2) &=  ~_BV(pin & 0xF); // LOW
 277     }
 278 }