matrix.c (5527B)
1 /* Copyright 2021 @ Keychron (https://www.keychron.com) 2 * 3 * This program is free software: you can redistribute it and/or modify 4 * it under the terms of the GNU General Public License as published by 5 * the Free Software Foundation, either version 2 of the License, or 6 * (at your option) any later version. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program. If not, see <http://www.gnu.org/licenses/>. 15 */ 16 17 #include "matrix.h" 18 #include "atomic_util.h" 19 #include <string.h> 20 21 // Pin connected to DS of 74HC595 22 #define DATA_PIN A7 23 // Pin connected to SH_CP of 74HC595 24 #define CLOCK_PIN B1 25 // Pin connected to ST_CP of 74HC595 26 #define LATCH_PIN B0 27 28 #ifdef MATRIX_ROW_PINS 29 static pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; 30 #endif // MATRIX_ROW_PINS 31 #ifdef MATRIX_COL_PINS 32 static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; 33 #endif // MATRIX_COL_PINS 34 35 #define ROWS_PER_HAND (MATRIX_ROWS) 36 37 static inline void gpio_atomic_set_pin_output_low(pin_t pin) { 38 ATOMIC_BLOCK_FORCEON { 39 gpio_set_pin_output(pin); 40 gpio_write_pin_low(pin); 41 } 42 } 43 44 static inline void gpio_atomic_set_pin_output_high(pin_t pin) { 45 ATOMIC_BLOCK_FORCEON { 46 gpio_set_pin_output(pin); 47 gpio_write_pin_high(pin); 48 } 49 } 50 51 static inline void gpio_atomic_set_pin_input_high(pin_t pin) { 52 ATOMIC_BLOCK_FORCEON { 53 gpio_set_pin_input_high(pin); 54 } 55 } 56 57 static inline uint8_t readMatrixPin(pin_t pin) { 58 if (pin != NO_PIN) { 59 return gpio_read_pin(pin); 60 } else { 61 return 1; 62 } 63 } 64 65 static void shiftOut(uint8_t dataOut) { 66 for (uint8_t i = 0; i < 8; i++) { 67 if (dataOut & 0x1) { 68 gpio_atomic_set_pin_output_high(DATA_PIN); 69 } else { 70 gpio_atomic_set_pin_output_low(DATA_PIN); 71 } 72 dataOut = dataOut >> 1; 73 gpio_atomic_set_pin_output_high(CLOCK_PIN); 74 gpio_atomic_set_pin_output_low(CLOCK_PIN); 75 } 76 gpio_atomic_set_pin_output_high(LATCH_PIN); 77 gpio_atomic_set_pin_output_low(LATCH_PIN); 78 } 79 80 static void shiftout_single(uint8_t data) { 81 if (data & 0x1) { 82 gpio_atomic_set_pin_output_high(DATA_PIN); 83 } else { 84 gpio_atomic_set_pin_output_low(DATA_PIN); 85 } 86 87 gpio_atomic_set_pin_output_high(CLOCK_PIN); 88 gpio_atomic_set_pin_output_low(CLOCK_PIN); 89 90 gpio_atomic_set_pin_output_high(LATCH_PIN); 91 gpio_atomic_set_pin_output_low(LATCH_PIN); 92 } 93 94 static bool select_col(uint8_t col) { 95 pin_t pin = col_pins[col]; 96 97 if (pin != NO_PIN) { 98 gpio_atomic_set_pin_output_low(pin); 99 return true; 100 } else { 101 if (col == 8) { 102 shiftout_single(0x00); 103 } else { 104 shiftout_single(0x01); 105 } 106 return true; 107 } 108 return false; 109 } 110 111 static void unselect_col(uint8_t col) { 112 pin_t pin = col_pins[col]; 113 114 if (pin != NO_PIN) { 115 #ifdef MATRIX_UNSELECT_DRIVE_HIGH 116 gpio_atomic_set_pin_output_high(pin); 117 #else 118 gpio_atomic_set_pin_input_high(pin); 119 #endif 120 } else { 121 if (col == (MATRIX_COLS - 1)) 122 shiftout_single(0x01); 123 } 124 } 125 126 static void unselect_cols(void) { 127 // unselect column pins 128 for (uint8_t x = 0; x < MATRIX_COLS; x++) { 129 pin_t pin = col_pins[x]; 130 131 if (pin != NO_PIN) { 132 #ifdef MATRIX_UNSELECT_DRIVE_HIGH 133 gpio_atomic_set_pin_output_high(pin); 134 #else 135 gpio_atomic_set_pin_input_high(pin); 136 #endif 137 } 138 if (x == (MATRIX_COLS - 1)) 139 // unselect Shift Register 140 shiftOut(0xFF); 141 } 142 } 143 144 static void matrix_init_pins(void) { 145 unselect_cols(); 146 for (uint8_t x = 0; x < MATRIX_ROWS; x++) { 147 if (row_pins[x] != NO_PIN) { 148 gpio_atomic_set_pin_input_high(row_pins[x]); 149 } 150 } 151 } 152 153 static void matrix_read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col, matrix_row_t row_shifter) { 154 bool key_pressed = false; 155 156 // Select col 157 if (!select_col(current_col)) { // select col 158 return; // skip NO_PIN col 159 } 160 matrix_output_select_delay(); 161 162 // For each row... 163 for (uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++) { 164 // Check row pin state 165 if (readMatrixPin(row_pins[row_index]) == 0) { 166 // Pin LO, set col bit 167 current_matrix[row_index] |= row_shifter; 168 key_pressed = true; 169 } else { 170 // Pin HI, clear col bit 171 current_matrix[row_index] &= ~row_shifter; 172 } 173 } 174 175 // Unselect col 176 unselect_col(current_col); 177 matrix_output_unselect_delay(current_col, key_pressed); // wait for all Row signals to go HIGH 178 } 179 180 void matrix_init_custom(void) { 181 // initialize key pins 182 matrix_init_pins(); 183 } 184 185 bool matrix_scan_custom(matrix_row_t current_matrix[]) { 186 matrix_row_t curr_matrix[MATRIX_ROWS] = {0}; 187 188 // Set col, read rows 189 matrix_row_t row_shifter = MATRIX_ROW_SHIFTER; 190 for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++, row_shifter <<= 1) { 191 matrix_read_rows_on_col(curr_matrix, current_col, row_shifter); 192 } 193 194 bool changed = memcmp(current_matrix, curr_matrix, sizeof(curr_matrix)) != 0; 195 if (changed) memcpy(current_matrix, curr_matrix, sizeof(curr_matrix)); 196 197 return changed; 198 }