matrix.c (5807B)
1 /* Copyright 2023 @ 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)) shiftout_single(0x01); 122 } 123 } 124 125 static void unselect_cols(void) { 126 // unselect column pins 127 for (uint8_t x = 0; x < MATRIX_COLS; x++) { 128 pin_t pin = col_pins[x]; 129 130 if (pin != NO_PIN) { 131 #ifdef MATRIX_UNSELECT_DRIVE_HIGH 132 gpio_atomic_set_pin_output_high(pin); 133 #else 134 gpio_atomic_set_pin_input_high(pin); 135 #endif 136 } 137 if (x == (MATRIX_COLS - 1)) 138 // unselect Shift Register 139 shiftOut(0xFF); 140 } 141 } 142 143 static void matrix_init_pins(void) { 144 unselect_cols(); 145 for (uint8_t x = 0; x < MATRIX_ROWS; x++) { 146 if (row_pins[x] != NO_PIN) { 147 gpio_atomic_set_pin_input_high(row_pins[x]); 148 } 149 } 150 } 151 152 static void matrix_read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col, matrix_row_t row_shifter) { 153 bool key_pressed = false; 154 155 // Select col 156 if (!select_col(current_col)) { // select col 157 return; // skip NO_PIN col 158 } 159 160 if (current_col < 8) { 161 matrix_output_select_delay(); 162 } else { 163 for (int8_t cycle = 4; cycle > 0; cycle--) { 164 matrix_output_select_delay(); // 0.25us 165 matrix_output_select_delay(); 166 matrix_output_select_delay(); 167 matrix_output_select_delay(); 168 } 169 } 170 171 // For each row... 172 for (uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++) { 173 // Check row pin state 174 if (readMatrixPin(row_pins[row_index]) == 0) { 175 // Pin LO, set col bit 176 current_matrix[row_index] |= row_shifter; 177 key_pressed = true; 178 } else { 179 // Pin HI, clear col bit 180 current_matrix[row_index] &= ~row_shifter; 181 } 182 } 183 184 // Unselect col 185 unselect_col(current_col); 186 matrix_output_unselect_delay(current_col, key_pressed); // wait for all Row signals to go HIGH 187 } 188 189 void matrix_init_custom(void) { 190 // initialize key pins 191 matrix_init_pins(); 192 } 193 194 bool matrix_scan_custom(matrix_row_t current_matrix[]) { 195 matrix_row_t curr_matrix[MATRIX_ROWS] = {0}; 196 197 // Set col, read rows 198 matrix_row_t row_shifter = MATRIX_ROW_SHIFTER; 199 for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++, row_shifter <<= 1) { 200 matrix_read_rows_on_col(curr_matrix, current_col, row_shifter); 201 } 202 203 bool changed = memcmp(current_matrix, curr_matrix, sizeof(curr_matrix)) != 0; 204 if (changed) memcpy(current_matrix, curr_matrix, sizeof(curr_matrix)); 205 206 return changed; 207 }