logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

matrix.c (6894B)

    

  1. /*
  2. Copyright 2012 Jun Wako
  3. Copyright 2014 Jack Humbert
  4. Copyright 2017 Priyadi Iman Nurcahyo
  6. This program is free software: you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation, either version 2 of the License, or
  9. (at your option) any later version.
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  16. You should have received a copy of the GNU General Public License
  17. along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18. */
  19. #include <stdint.h>
  20. #include <stdbool.h>
  21. #if defined(__AVR__)
  22. #include <avr/io.h>
  23. #endif
  24. #include "wait.h"
  25. #include "print.h"
  26. #include "debug.h"
  27. #include "util.h"
  28. #include "matrix.h"
  29. #include "timer.h"
  32. /* Set 0 if debouncing isn't needed */
  34. #ifndef DEBOUNCE
  35. #   define DEBOUNCE 5
  36. #endif
  38. #if (DEBOUNCE > 0)
  39.     static uint16_t debouncing_time;
  40.     static bool debouncing = false;
  41. #endif
  43. #if (MATRIX_COLS <= 8)
  44. #    define print_matrix_header()  print("\nr/c 01234567\n")
  45. #    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
  46. #    define ROW_SHIFTER ((uint8_t)1)
  47. #elif (MATRIX_COLS <= 16)
  48. #    define print_matrix_header()  print("\nr/c 0123456789ABCDEF\n")
  49. #    define print_matrix_row(row)  print_bin_reverse16(matrix_get_row(row))
  50. #    define ROW_SHIFTER ((uint16_t)1)
  51. #elif (MATRIX_COLS <= 32)
  52. #    define print_matrix_header()  print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
  53. #    define print_matrix_row(row)  print_bin_reverse32(matrix_get_row(row))
  54. #    define ROW_SHIFTER  ((uint32_t)1)
  55. #endif
  57. #ifdef MATRIX_MASKED
  58.     extern const matrix_row_t matrix_mask[];
  59. #endif
  61. static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
  62. static const uint8_t tp_pins[3] = TRACKPOINT_PINS;
  64. /* matrix state(1:on, 0:off) */
  65. static matrix_row_t matrix[MATRIX_ROWS];
  66. static matrix_row_t matrix_debouncing[MATRIX_ROWS];
  68. static void init_cols(void);
  69. static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
  70. static void unselect_rows(void);
  71. static void select_row(uint8_t row);
  72. static void unselect_row(uint8_t row);
  75. __attribute__ ((weak))
  76. void matrix_init_kb(void) {
  77.     matrix_init_user();
  78. }
  80. __attribute__ ((weak))
  81. void matrix_scan_kb(void) {
  82.     matrix_scan_user();
  83. }
  85. __attribute__ ((weak))
  86. void matrix_init_user(void) {
  87. }
  89. __attribute__ ((weak))
  90. void matrix_scan_user(void) {
  91. }
  93. inline
  94. uint8_t matrix_rows(void) {
  95.     return MATRIX_ROWS;
  96. }
  98. inline
  99. uint8_t matrix_cols(void) {
  100.     return MATRIX_COLS;
  101. }
  103. void matrix_init(void) {
  104.     // initialize row and col
  105.     unselect_rows();
  106.     init_cols();
  108.     // initialize matrix state: all keys off
  109.     for (uint8_t i=0; i < MATRIX_ROWS; i++) {
  110.         matrix[i] = 0;
  111.         matrix_debouncing[i] = 0;
  112.     }
  114.     matrix_init_kb();
  115. }
  117. uint8_t matrix_scan(void)
  118. {
  119.     // Set row, read cols
  120.     for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
  121. #       if (DEBOUNCE > 0)
  122.             bool matrix_changed = read_cols_on_row(matrix_debouncing, current_row);
  124.             if (matrix_changed) {
  125.                 debouncing = true;
  126.                 debouncing_time = timer_read();
  127.             }
  129. #       else
  130.             read_cols_on_row(matrix, current_row);
  131. #       endif
  133.     }
  135. #   if (DEBOUNCE > 0)
  136.         if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCE)) {
  137.             for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
  138.                 matrix[i] = matrix_debouncing[i];
  139.             }
  140.             debouncing = false;
  141.         }
  142. #   endif
  144.     matrix_scan_kb();
  145.     return 1;
  146. }
  148. inline
  149. bool matrix_is_on(uint8_t row, uint8_t col)
  151. {
  152.     return (matrix[row] & ((matrix_row_t)1<<col));
  153. }
  155. inline
  156. matrix_row_t matrix_get_row(uint8_t row)
  157. {
  158.     // Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
  159.     // switch blocker installed and the switch is always pressed.
  160. #ifdef MATRIX_MASKED
  161.     return matrix[row] & matrix_mask[row];
  162. #else
  163.     return matrix[row];
  164. #endif
  165. }
  167. void matrix_print(void)
  168. {
  169.     print_matrix_header();
  171.     for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
  172.         print_hex8(row); print(": ");
  173.         print_matrix_row(row);
  174.         print("\n");
  175.     }
  176. }
  178. #define ROW_MASK 0b11100000
  180. static const uint8_t row_bit[MATRIX_ROWS] = {
  181.   //  76543210
  182.     0b00000000,
  183.     0b00100000,
  184.     0b01000000,
  185.     0b01100000,
  186.     0b10000000,
  187.     0b10100000,
  188.     0b11000000,
  189.     0b11100000,
  190. };
  192. static void init_cols(void)
  193. {
  194.     // columns
  195.     for(uint8_t x = 0; x < MATRIX_COLS; x++) {
  196.         uint8_t pin = col_pins[x];
  197.         _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
  198.         _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
  199.     }
  201.     // rows
  202.     DDRF  |=  ROW_MASK;
  203.     PORTF &= ~ROW_MASK;
  205.     // trackpoint
  206.     for(uint8_t x = 0; x < 3; x++) {
  207.         uint8_t pin = tp_pins[x];
  208.         _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
  209.         _SFR_IO8((pin >> 4) + 2) |=  _BV(pin & 0xF); // HI
  210.     }
  211. }
  213. static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
  214.     {
  215.         // Store last value of row prior to reading
  216.         matrix_row_t last_row_value = current_matrix[current_row];
  218.         // Clear data in matrix row
  219.         current_matrix[current_row] = 0;
  221.         // special case for trackpoint
  222.         if (current_row == 8) {
  223.             for(uint8_t tp_index = 0; tp_index < 3; tp_index++) {
  225.                 // Select the TP pin to read (active low)
  226.                 uint8_t pin = tp_pins[tp_index];
  227.                 uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
  229.                 // Populate the matrix row with the state of the col pin
  230.                 current_matrix[current_row] |=  pin_state ? 0 : (ROW_SHIFTER << tp_index);
  231.             }
  232.             return (last_row_value != current_matrix[current_row]);
  233.         }
  235.         // Select row and wait for row selecton to stabilize
  236.         select_row(current_row);
  237.         _delay_us(5);       // without this wait it won't read stable value.
  238.         // wait_us(50);
  240.         // For each col...
  241.         for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
  243.             // Select the col pin to read (active low)
  244.             uint8_t pin = col_pins[col_index];
  245.             uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
  247.             // Populate the matrix row with the state of the col pin
  248.             current_matrix[current_row] |=  pin_state ? 0 : (ROW_SHIFTER << col_index);
  249.         }
  251.         // Unselect row
  252.         unselect_row(current_row);
  254.         return (last_row_value != current_matrix[current_row]);
  255. }
  257. static void select_row(uint8_t row)
  258. {
  259.     PORTF = row_bit[row] | (PORTF & ~ROW_MASK);
  260. }
  262. static void unselect_row(uint8_t row)
  263. {
  264. }
  266. static void unselect_rows(void)
  267. {
  268. }