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 DEBOUNCING_DELAY
  37 #   define DEBOUNCING_DELAY 5
  38 #endif
  39
  40 #if (DEBOUNCING_DELAY > 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 __attribute__ ((weak))
  79 void matrix_init_quantum(void) {
  80     matrix_init_kb();
  81 }
  82
  83 __attribute__ ((weak))
  84 void matrix_scan_quantum(void) {
  85     matrix_scan_kb();
  86 }
  87
  88 __attribute__ ((weak))
  89 void matrix_init_kb(void) {
  90     matrix_init_user();
  91 }
  92
  93 __attribute__ ((weak))
  94 void matrix_scan_kb(void) {
  95     matrix_scan_user();
  96 }
  97
  98 __attribute__ ((weak))
  99 void matrix_init_user(void) {
 100 }
 101
 102 __attribute__ ((weak))
 103 void matrix_scan_user(void) {
 104 }
 105
 106 inline
 107 uint8_t matrix_rows(void)
 108 {
 109     return MATRIX_ROWS;
 110 }
 111
 112 inline
 113 uint8_t matrix_cols(void)
 114 {
 115     return MATRIX_COLS;
 116 }
 117
 118 void matrix_init(void)
 119 {
 120     debug_enable = true;
 121     debug_matrix = true;
 122     debug_mouse = true;
 123     // initialize row and col
 124     unselect_cols();
 125     init_rows();
 126 //    init_lcols();
 127
 128 //    TX_RX_LED_INIT;
 129
 130     // initialize matrix state: all keys off
 131     for (uint8_t i=0; i < MATRIX_ROWS; i++) {
 132         matrix[i] = 0;
 133         matrix_debouncing[i] = 0;
 134     }
 135
 136     matrix_init_quantum();
 137
 138 }
 139
 140 uint8_t _matrix_scan(void)
 141 {
 142     // Set col, read rows
 143     for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
 144 #       if (DEBOUNCING_DELAY > 0)
 145             bool matrix_changed = read_rows_on_col(matrix_debouncing, current_col);
 146             if (matrix_changed) {
 147                 debouncing = true;
 148                 debouncing_time = timer_read();
 149             }
 150 #       else
 151              read_rows_on_col(matrix, current_col);
 152 #       endif
 153
 154     }
 155
 156 #   if (DEBOUNCING_DELAY > 0)
 157         if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) {
 158             for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 159                 matrix[i] = matrix_debouncing[i];
 160             }
 161             debouncing = false;
 162         }
 163 #   endif
 164
 165         return 1;
 166 }
 167
 168 uint8_t matrix_scan(void)
 169 {
 170         uint8_t ret = _matrix_scan();
 171         matrix_scan_quantum();
 172         return ret;
 173 }
 174
 175 bool matrix_is_modified(void)
 176 {
 177     if (debouncing) return false;
 178     return true;
 179 }
 180
 181 inline
 182 bool matrix_is_on(uint8_t row, uint8_t col)
 183 {
 184     return (matrix[row] & ((matrix_row_t)1<<col));
 185 }
 186
 187 inline
 188 matrix_row_t matrix_get_row(uint8_t row)
 189 {
 190     return matrix[row];
 191 }
 192
 193 void matrix_print(void)
 194 {
 195     print("\nr/c 0123456789ABCDEF\n");
 196     for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
 197         phex(row); print(": ");
 198         pbin_reverse16(matrix_get_row(row));
 199         print("\n");
 200     }
 201 }
 202
 203 uint8_t matrix_key_count(void)
 204 {
 205     uint8_t count = 0;
 206     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 207         count += bitpop16(matrix[i]);
 208     }
 209     return count;
 210 }
 211
 212
 213 static void init_rows(void)
 214 {
 215     for(uint8_t x = 0; x < MATRIX_ROWS; x++) {
 216         uint8_t pin = row_pins[x];
 217         _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
 218         _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 219     }
 220 }
 221
 222
 223 static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
 224 {
 225     bool matrix_changed = false;
 226
 227     // Select col and wait for col selection to stabilize
 228     select_col(current_col);
 229     wait_us(30);
 230
 231     // For each row...
 232     for(uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++)
 233     {
 234
 235         // Store last value of row prior to reading
 236         matrix_row_t last_row_value = current_matrix[row_index];
 237
 238         // Check row pin state
 239         if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
 240         {
 241             // Pin LO, set col bit
 242             current_matrix[row_index] |= (ROW_SHIFTER << current_col);
 243         }
 244         else
 245         {
 246             // Pin HI, clear col bit
 247             current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
 248         }
 249
 250         // Determine if the matrix changed state
 251         if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
 252         {
 253             matrix_changed = true;
 254         }
 255     }
 256
 257     // Unselect col
 258     unselect_cols();
 259
 260     return matrix_changed;
 261 }
 262
 263 static void select_col(uint8_t col)
 264 {
 265 #ifdef FLIPPED_BOARD
 266         col = MATRIX_COLS - col - 1;
 267 #endif
 268     for(uint8_t x = 0; x < 4; x++) {
 269                 uint8_t pin = col_pins[x];
 270         _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
 271                 if (((col >> x) & 0x1) == 1){
 272                         _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HIGH
 273                 } else {
 274                         _SFR_IO8((pin >> 4) + 2) &=  ~_BV(pin & 0xF); // LOW
 275                 }
 276         }
 277 }
 278
 279 static void unselect_cols(void)
 280 {
 281         // FIXME This really needs to use the global enable on the decoder, because currently this sets the value to col1
 282     for(uint8_t x = 0; x < 4; x++) {
 283         uint8_t pin = col_pins[x];
 284         _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
 285         _SFR_IO8((pin >> 4) + 2) &=  ~_BV(pin & 0xF); // LOW
 286     }
 287 }
 288
 289