logo

qmk_firmware

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

matrix.c (9229B)

    

  1. /*
  2. Copyright 2012-2018 Jun Wako, Jack Humbert, Yiancar
  3. Port done by Andy Lee <alee@alittlepeacemusic.com>
  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.
  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.
  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. #include "wait.h"
  18. #include "print.h"
  19. #include "debug.h"
  20. #include "util.h"
  21. #include "matrix.h"
  22. #include "debounce.h"
  24. #if (MATRIX_COLS <= 8)
  25. #    define print_matrix_header()  print("\nr/c 01234567\n")
  26. #    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
  27. #    define ROW_SHIFTER ((uint8_t)1)
  28. #elif (MATRIX_COLS <= 16)
  29. #    define print_matrix_header()  print("\nr/c 0123456789ABCDEF\n")
  30. #    define print_matrix_row(row)  print_bin_reverse16(matrix_get_row(row))
  31. #    define ROW_SHIFTER ((uint16_t)1)
  32. #elif (MATRIX_COLS <= 32)
  33. #    define print_matrix_header()  print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
  34. #    define print_matrix_row(row)  print_bin_reverse32(matrix_get_row(row))
  35. #    define ROW_SHIFTER  ((uint32_t)1)
  36. #endif
  38. #ifdef MATRIX_MASKED
  39.     extern const matrix_row_t matrix_mask[];
  40. #endif
  42. #ifdef DIRECT_PINS
  43. static pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS;
  44. #elif (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW)
  45. // static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
  46. static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
  47. #endif
  49. /* matrix state(1:on, 0:off) */
  50. static matrix_row_t raw_matrix[MATRIX_ROWS]; //raw values
  51. static matrix_row_t matrix[MATRIX_ROWS]; //debounced values
  53. __attribute__ ((weak))
  54. void matrix_init_kb(void) {
  55.     matrix_init_user();
  56. }
  58. __attribute__ ((weak))
  59. void matrix_scan_kb(void) {
  60.     matrix_scan_user();
  61. }
  63. __attribute__ ((weak))
  64. void matrix_init_user(void) {
  65. }
  67. __attribute__ ((weak))
  68. void matrix_scan_user(void) {
  69. }
  71. inline
  72. uint8_t matrix_rows(void) {
  73.     return MATRIX_ROWS;
  74. }
  76. inline
  77. uint8_t matrix_cols(void) {
  78.     return MATRIX_COLS;
  79. }
  81. inline
  82. bool matrix_is_on(uint8_t row, uint8_t col)
  83. {
  84.     return (matrix[row] & ((matrix_row_t)1<<col));
  85. }
  87. inline
  88. matrix_row_t matrix_get_row(uint8_t row)
  89. {
  90.     // Matrix mask lets you disable switches in the returned matrix data. For example, if you have a
  91.     // switch blocker installed and the switch is always pressed.
  92. #ifdef MATRIX_MASKED
  93.     return matrix[row] & matrix_mask[row];
  94. #else
  95.     return matrix[row];
  96. #endif
  97. }
  99. void matrix_print(void)
  100. {
  101.     print_matrix_header();
  103.     for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
  104.         print_hex8(row); print(": ");
  105.         print_matrix_row(row);
  106.         print("\n");
  107.     }
  108. }
  110. #ifdef DIRECT_PINS
  112. static void init_pins(void) {
  113.   for (int row = 0; row < MATRIX_ROWS; row++) {
  114.     for (int col = 0; col < MATRIX_COLS; col++) {
  115.       pin_t pin = direct_pins[row][col];
  116.       if (pin != NO_PIN) {
  117.         gpio_set_pin_input_high(pin);
  118.       }
  119.     }
  120.   }
  121. }
  123. static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
  124.   matrix_row_t last_row_value = current_matrix[current_row];
  125.   current_matrix[current_row] = 0;
  127.   for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
  128.     pin_t pin = direct_pins[current_row][col_index];
  129.     if (pin != NO_PIN) {
  130.       current_matrix[current_row] |= gpio_read_pin(pin) ? 0 : (ROW_SHIFTER << col_index);
  131.     }
  132.   }
  134.   return (last_row_value != current_matrix[current_row]);
  135. }
  137. #elif (DIODE_DIRECTION == COL2ROW)
  138. /* Rows 0 - 5
  139.  * These rows use a 74HC138 3-to-8 demultiplexer.
  140.  *                C    B    A
  141.  * row / pin:    PB0  PB1  PB2
  142.  * 0:             0    0    0
  143.  * 1:             0    0    1
  144.  * 2:             0    1    0
  145.  * 3:             0    1    1
  146.  * 4:             1    0    0
  147.  * 5:             1    0    1
  148.  */
  149. static void select_row(uint8_t col)
  150. {
  151.     switch (col) {
  152.         case 0:
  153.             gpio_write_pin_low(B0);
  154.             gpio_write_pin_low(B1);
  155.             gpio_write_pin_low(B2);
  156.             break;
  157.         case 1:
  158.             gpio_write_pin_low(B0);
  159.             gpio_write_pin_low(B1);
  160.             break;
  161.         case 2:
  162.             gpio_write_pin_low(B0);
  163.             gpio_write_pin_low(B2);
  164.             break;
  165.         case 3:
  166.             gpio_write_pin_low(B0);
  167.             break;
  168.         case 4:
  169.             gpio_write_pin_low(B1);
  170.             gpio_write_pin_low(B2);
  171.             break;
  172.         case 5:
  173.             gpio_write_pin_low(B1);
  174.             break;
  175.     }
  176. }
  178. static void unselect_row(uint8_t col)
  179. {
  180.     switch (col) {
  181.         case 0:
  182.             gpio_write_pin_high(B0);
  183.             gpio_write_pin_high(B1);
  184.             gpio_write_pin_high(B2);
  185.             break;
  186.         case 1:
  187.             gpio_write_pin_high(B0);
  188.             gpio_write_pin_high(B1);
  189.             break;
  190.         case 2:
  191.             gpio_write_pin_high(B0);
  192.             gpio_write_pin_high(B2);
  193.             break;
  194.         case 3:
  195.             gpio_write_pin_high(B0);
  196.             break;
  197.         case 4:
  198.             gpio_write_pin_high(B1);
  199.             gpio_write_pin_high(B2);
  200.             break;
  201.         case 5:
  202.             gpio_write_pin_high(B1);
  203.             break;
  204.     }
  205. }
  207. static void unselect_rows(void)
  208. {
  209.     gpio_set_pin_output(B0);
  210.     gpio_set_pin_output(B1);
  211.     gpio_set_pin_output(B2);
  212. 	// make all pins high to select Y7, nothing is connected to that (otherwise the first row will act weird)
  213.     gpio_write_pin_high(B0);
  214.     gpio_write_pin_high(B1);
  215.     gpio_write_pin_high(B2);
  216. }
  218. static void init_pins(void) {
  219.   unselect_rows();
  220.   for (uint8_t x = 0; x < MATRIX_COLS; x++) {
  221.     gpio_set_pin_input_high(col_pins[x]);
  222.   }
  223. }
  225. static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
  226. {
  227.     // Store last value of row prior to reading
  228.     matrix_row_t last_row_value = current_matrix[current_row];
  230.     // Clear data in matrix row
  231.     current_matrix[current_row] = 0;
  233.     // Select row and wait for row selecton to stabilize
  234.     select_row(current_row);
  235.     wait_us(30);
  237.     // For each col...
  238.     for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
  240.         // Select the col pin to read (active low)
  241.         uint8_t pin_state = gpio_read_pin(col_pins[col_index]);
  243.         // Populate the matrix row with the state of the col pin
  244.         current_matrix[current_row] |=  pin_state ? 0 : (ROW_SHIFTER << col_index);
  245.     }
  247.     // Unselect row
  248.     unselect_row(current_row);
  250.     return (last_row_value != current_matrix[current_row]);
  251. }
  253. #elif (DIODE_DIRECTION == ROW2COL)
  255. static void select_col(uint8_t col)
  256. {
  257.     gpio_set_pin_output(col_pins[col]);
  258.     gpio_write_pin_low(col_pins[col]);
  259. }
  261. static void unselect_col(uint8_t col)
  262. {
  263.     gpio_set_pin_input_high(col_pins[col]);
  264. }
  266. static void unselect_cols(void)
  267. {
  268.     for(uint8_t x = 0; x < MATRIX_COLS; x++) {
  269.         gpio_set_pin_input_high(col_pins[x]);
  270.     }
  271. }
  273. static void init_pins(void) {
  274.   unselect_cols();
  275.   for (uint8_t x = 0; x < MATRIX_ROWS; x++) {
  276.     gpio_set_pin_input_high(row_pins[x]);
  277.   }
  278. }
  280. static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
  281. {
  282.     bool matrix_changed = false;
  284.     // Select col and wait for col selecton to stabilize
  285.     select_col(current_col);
  286.     wait_us(30);
  288.     // For each row...
  289.     for(uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++)
  290.     {
  292.         // Store last value of row prior to reading
  293.         matrix_row_t last_row_value = current_matrix[row_index];
  295.         // Check row pin state
  296.         if (gpio_read_pin(row_pins[row_index]) == 0)
  297.         {
  298.             // Pin LO, set col bit
  299.             current_matrix[row_index] |= (ROW_SHIFTER << current_col);
  300.         }
  301.         else
  302.         {
  303.             // Pin HI, clear col bit
  304.             current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
  305.         }
  307.         // Determine if the matrix changed state
  308.         if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
  309.         {
  310.             matrix_changed = true;
  311.         }
  312.     }
  314.     // Unselect col
  315.     unselect_col(current_col);
  317.     return matrix_changed;
  318. }
  320. #endif
  322. void matrix_init(void) {
  324.     // initialize key pins
  325.     init_pins();
  327.     // initialize matrix state: all keys off
  328.     for (uint8_t i=0; i < MATRIX_ROWS; i++) {
  329.         raw_matrix[i] = 0;
  330.         matrix[i] = 0;
  331.     }
  333.     debounce_init(MATRIX_ROWS);
  335.     matrix_init_kb();
  336. }
  338. uint8_t matrix_scan(void)
  339. {
  340.   bool changed = false;
  342. #if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW)
  343.   // Set row, read cols
  344.   for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) {
  345.     changed |= read_cols_on_row(raw_matrix, current_row);
  346.   }
  347. #elif (DIODE_DIRECTION == ROW2COL)
  348.   // Set col, read rows
  349.   for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
  350.     changed |= read_rows_on_col(raw_matrix, current_col);
  351.   }
  352. #endif
  354.   debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
  356.   matrix_scan_kb();
  357.   return 1;
  358. }