keyboards/vitamins_included/matrix.c

   1 /*
   2 Copyright 2012 Jun Wako <wakojun@gmail.com>
   3
   4 This program is free software: you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation, either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 /*
  19  * scan matrix
  20  */
  21 #include <stdint.h>
  22 #include <stdbool.h>
  23 #include <avr/io.h>
  24 #include <avr/interrupt.h>
  25 #include <util/delay.h>
  26 #include "wait.h"
  27 #include "print.h"
  28 #include "debug.h"
  29 #include "util.h"
  30 #include "matrix.h"
  31 #include "split_util.h"
  32 #include "pro_micro.h"
  33 #include "config.h"
  34 #include "timer.h"
  35 #include <print.h>
  36
  37 #if (defined(RGB_MIDI) | defined(RGBLIGHT_ANIMATIONS)) & defined(RGBLIGHT_ENABLE)
  38     #include "rgblight.h"
  39 #endif
  40
  41
  42 #ifdef USE_I2C
  43 #  include "i2c.h"
  44 #else // USE_SERIAL
  45 #  include "serial.h"
  46 #endif
  47
  48 #ifndef DEBOUNCING_DELAY
  49 #   define DEBOUNCING_DELAY 5
  50 #endif
  51
  52 #if (DEBOUNCING_DELAY > 0)
  53     static uint16_t debouncing_time;
  54     static bool debouncing = false;
  55 #endif
  56
  57 #if (MATRIX_COLS <= 8)
  58 #    define print_matrix_header()  print("\nr/c 01234567\n")
  59 #    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
  60 #    define matrix_bitpop(i)       bitpop(matrix[i])
  61 #    define ROW_SHIFTER ((uint8_t)1)
  62 #else
  63 #    error "Currently only supports 8 COLS"
  64 #endif
  65 static matrix_row_t matrix_debouncing[MATRIX_ROWS];
  66
  67 #define ERROR_DISCONNECT_COUNT 5
  68
  69 #define ROWS_PER_HAND (MATRIX_ROWS/2)
  70
  71 static uint8_t error_count = 0;
  72
  73 static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
  74 static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
  75
  76 /* matrix state(1:on, 0:off) */
  77 static matrix_row_t matrix[MATRIX_ROWS];
  78 static matrix_row_t matrix_debouncing[MATRIX_ROWS];
  79
  80 #if (DIODE_DIRECTION == COL2ROW)
  81     static void init_cols(void);
  82     static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
  83     static void unselect_rows(void);
  84     static void select_row(uint8_t row);
  85     static void unselect_row(uint8_t row);
  86 #elif (DIODE_DIRECTION == ROW2COL)
  87     static void init_rows(void);
  88     static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
  89     static void unselect_cols(void);
  90     static void unselect_col(uint8_t col);
  91     static void select_col(uint8_t col);
  92 #endif
  93
  94
  95 __attribute__ ((weak))
  96 void matrix_init_quantum(void) {
  97     matrix_init_kb();
  98 }
  99
 100 __attribute__ ((weak))
 101 void matrix_scan_quantum(void) {
 102     matrix_scan_kb();
 103 }
 104
 105 __attribute__ ((weak))
 106 void matrix_init_kb(void) {
 107     matrix_init_user();
 108 }
 109
 110 __attribute__ ((weak))
 111 void matrix_scan_kb(void) {
 112     matrix_scan_user();
 113 }
 114
 115 __attribute__ ((weak))
 116 void matrix_init_user(void) {
 117 }
 118
 119 __attribute__ ((weak))
 120 void matrix_scan_user(void) {
 121 }
 122
 123 inline
 124 uint8_t matrix_rows(void) {
 125     return MATRIX_ROWS;
 126 }
 127
 128 inline
 129 uint8_t matrix_cols(void) {
 130     return MATRIX_COLS;
 131 }
 132
 133 bool has_usb(void) {
 134   return UDADDR & _BV(ADDEN); // This will return true of a USB connection has been established
 135 }
 136
 137 void matrix_init(void)
 138 {
 139 #ifdef DISABLE_JTAG
 140   // JTAG disable for PORT F. write JTD bit twice within four cycles.
 141   MCUCR |= (1<<JTD);
 142   MCUCR |= (1<<JTD);
 143 #endif
 144
 145     // initialize row and col
 146 #if (DIODE_DIRECTION == COL2ROW)
 147     unselect_rows();
 148     init_cols();
 149 #elif (DIODE_DIRECTION == ROW2COL)
 150     unselect_cols();
 151     init_rows();
 152 #endif
 153
 154   TX_RX_LED_INIT;
 155
 156   // initialize matrix state: all keys off
 157   for (uint8_t i=0; i < MATRIX_ROWS; i++) {
 158     matrix[i] = 0;
 159     matrix_debouncing[i] = 0;
 160   }
 161
 162   #ifdef RGBLIGHT_ENABLE
 163     rgblight_init();
 164   #endif
 165
 166   timer_init();
 167   #ifdef USE_I2C
 168     i2c_slave_init(SLAVE_I2C_ADDRESS);
 169   #else
 170     serial_slave_init();
 171   #endif
 172
 173   sei();
 174
 175   matrix_init_quantum();
 176   while(!has_usb() || contacted_by_master){
 177     matrix_slave_scan();
 178   }
 179
 180   // Set up as master
 181   #ifdef USE_I2C
 182     i2c_reset_state();
 183     i2c_master_init();
 184   #else
 185     serial_master_init();
 186   #endif
 187 }
 188
 189 uint8_t _matrix_scan(void)
 190 {
 191     int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
 192 #if (DIODE_DIRECTION == COL2ROW)
 193     // Set row, read cols
 194     for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
 195 #       if (DEBOUNCING_DELAY > 0)
 196             bool matrix_changed = read_cols_on_row(matrix_debouncing+offset, current_row);
 197
 198             if (matrix_changed) {
 199                 debouncing = true;
 200                 debouncing_time = timer_read();
 201                 PORTD ^= (1 << 2);
 202             }
 203
 204 #       else
 205             read_cols_on_row(matrix+offset, current_row);
 206 #       endif
 207
 208     }
 209
 210 #elif (DIODE_DIRECTION == ROW2COL)
 211     // Set col, read rows
 212     for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
 213 #       if (DEBOUNCING_DELAY > 0)
 214             bool matrix_changed = read_rows_on_col(matrix_debouncing+offset, current_col);
 215             if (matrix_changed) {
 216                 debouncing = true;
 217                 debouncing_time = timer_read();
 218             }
 219 #       else
 220              read_rows_on_col(matrix+offset, current_col);
 221 #       endif
 222
 223     }
 224 #endif
 225
 226 #   if (DEBOUNCING_DELAY > 0)
 227         if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) {
 228             for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
 229                 matrix[i+offset] = matrix_debouncing[i+offset];
 230             }
 231             debouncing = false;
 232         }
 233 #   endif
 234
 235     return 1;
 236 }
 237
 238 #ifdef USE_I2C
 239
 240 // Get rows from other half over i2c
 241 int i2c_transaction(void) {
 242     int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
 243
 244     int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
 245     if (err) goto i2c_error;
 246
 247     // start of matrix stored at 0x00
 248     err = i2c_master_write(0x00);
 249     if (err) goto i2c_error;
 250
 251     // Start read
 252     err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
 253     if (err) goto i2c_error;
 254
 255     if (!err) {
 256         int i;
 257         for (i = 0; i < ROWS_PER_HAND-1; ++i) {
 258             matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
 259         }
 260         matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
 261         i2c_master_stop();
 262     } else {
 263 i2c_error: // the cable is disconnceted, or something else went wrong
 264         i2c_reset_state();
 265         return err;
 266     }
 267
 268     return 0;
 269 }
 270
 271 #else // USE_SERIAL
 272
 273 int serial_transaction(void) {
 274     int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
 275
 276     if (serial_update_buffers()) {
 277         return 1;
 278     }
 279
 280     for (int i = 0; i < ROWS_PER_HAND; ++i) {
 281         matrix[slaveOffset+i] = serial_slave_buffer[i];
 282     }
 283     return 0;
 284 }
 285 #endif
 286
 287 uint8_t matrix_scan(void)
 288 {
 289     uint8_t ret = _matrix_scan();
 290
 291 #ifdef USE_I2C
 292     if( i2c_transaction() ) {
 293 #else // USE_SERIAL
 294     if( serial_transaction() ) {
 295 #endif
 296         // turn on the indicator led when halves are disconnected
 297         TXLED1;
 298
 299         error_count++;
 300
 301         if (error_count > ERROR_DISCONNECT_COUNT) {
 302             // reset other half if disconnected
 303             int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
 304             for (int i = 0; i < ROWS_PER_HAND; ++i) {
 305                 matrix[slaveOffset+i] = 0;
 306             }
 307         }
 308     } else {
 309         // turn off the indicator led on no error
 310         TXLED0;
 311         error_count = 0;
 312     }
 313     matrix_scan_quantum();
 314     return ret;
 315 }
 316
 317 void matrix_slave_scan(void) {
 318   #if defined(RGBLIGHT_ANIMATIONS) & defined(RGBLIGHT_ENABLE)
 319     rgblight_task();
 320   #endif
 321   _matrix_scan();
 322
 323   int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
 324
 325 #ifdef USE_I2C
 326     for (int i = 0; i < ROWS_PER_HAND; ++i) {
 327         i2c_slave_buffer[i] = matrix[offset+i];
 328     }
 329 #else // USE_SERIAL
 330     for (int i = 0; i < ROWS_PER_HAND; ++i) {
 331         serial_slave_buffer[i] = matrix[offset+i];
 332     }
 333 #endif
 334 }
 335
 336 bool matrix_is_modified(void)
 337 {
 338     if (debouncing) return false;
 339     return true;
 340 }
 341
 342 inline
 343 bool matrix_is_on(uint8_t row, uint8_t col)
 344 {
 345     return (matrix[row] & ((matrix_row_t)1<<col));
 346 }
 347
 348 inline
 349 matrix_row_t matrix_get_row(uint8_t row)
 350 {
 351     return matrix[row];
 352 }
 353
 354 void matrix_print(void)
 355 {
 356     print("\nr/c 0123456789ABCDEF\n");
 357     for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
 358         phex(row); print(": ");
 359         pbin_reverse16(matrix_get_row(row));
 360         print("\n");
 361     }
 362 }
 363
 364 uint8_t matrix_key_count(void)
 365 {
 366     uint8_t count = 0;
 367     for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
 368         count += bitpop16(matrix[i]);
 369     }
 370     return count;
 371 }
 372
 373 #if (DIODE_DIRECTION == COL2ROW)
 374
 375 static void init_cols(void)
 376 {
 377     for(uint8_t x = 0; x < MATRIX_COLS; x++) {
 378         uint8_t pin = col_pins[x];
 379         _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
 380         _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 381     }
 382 }
 383
 384 static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
 385 {
 386     // Store last value of row prior to reading
 387     matrix_row_t last_row_value = current_matrix[current_row];
 388
 389     // Clear data in matrix row
 390     current_matrix[current_row] = 0;
 391
 392     // Select row and wait for row selecton to stabilize
 393     select_row(current_row);
 394     wait_us(30);
 395
 396     // For each col...
 397     for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
 398
 399         // Select the col pin to read (active low)
 400         uint8_t pin = col_pins[col_index];
 401         uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
 402
 403         // Populate the matrix row with the state of the col pin
 404         current_matrix[current_row] |=  pin_state ? 0 : (ROW_SHIFTER << col_index);
 405     }
 406
 407     // Unselect row
 408     unselect_row(current_row);
 409
 410     return (last_row_value != current_matrix[current_row]);
 411 }
 412
 413 static void select_row(uint8_t row)
 414 {
 415     uint8_t pin = row_pins[row];
 416     _SFR_IO8((pin >> 4) + 1) |=  _BV(pin & 0xF); // OUT
 417     _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
 418 }
 419
 420 static void unselect_row(uint8_t row)
 421 {
 422     uint8_t pin = row_pins[row];
 423     _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
 424     _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 425 }
 426
 427 static void unselect_rows(void)
 428 {
 429     for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
 430         uint8_t pin = row_pins[x];
 431         _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
 432         _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 433     }
 434 }
 435
 436 #elif (DIODE_DIRECTION == ROW2COL)
 437
 438 static void init_rows(void)
 439 {
 440     for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
 441         uint8_t pin = row_pins[x];
 442         _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
 443         _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 444     }
 445 }
 446
 447 static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
 448 {
 449     bool matrix_changed = false;
 450
 451     // Select col and wait for col selecton to stabilize
 452     select_col(current_col);
 453     wait_us(30);
 454
 455     // For each row...
 456     for(uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++)
 457     {
 458
 459         // Store last value of row prior to reading
 460         matrix_row_t last_row_value = current_matrix[row_index];
 461
 462         // Check row pin state
 463         if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
 464         {
 465             // Pin LO, set col bit
 466             current_matrix[row_index] |= (ROW_SHIFTER << current_col);
 467         }
 468         else
 469         {
 470             // Pin HI, clear col bit
 471             current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
 472         }
 473
 474         // Determine if the matrix changed state
 475         if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
 476         {
 477             matrix_changed = true;
 478         }
 479     }
 480
 481     // Unselect col
 482     unselect_col(current_col);
 483
 484     return matrix_changed;
 485 }
 486
 487 static void select_col(uint8_t col)
 488 {
 489     uint8_t pin = col_pins[col];
 490     _SFR_IO8((pin >> 4) + 1) |=  _BV(pin & 0xF); // OUT
 491     _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
 492 }
 493
 494 static void unselect_col(uint8_t col)
 495 {
 496     uint8_t pin = col_pins[col];
 497     _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
 498     _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 499 }
 500
 501 static void unselect_cols(void)
 502 {
 503     for(uint8_t x = 0; x < MATRIX_COLS; x++) {
 504         uint8_t pin = col_pins[x];
 505         _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
 506         _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
 507     }
 508 }
 509
 510 #endif