diff options
author | James Young <[email protected]> | 2020-11-28 12:02:18 -0800 |
---|---|---|
committer | GitHub <[email protected]> | 2020-11-28 12:02:18 -0800 |
commit | c66df1664497546f32662409778731143e45a552 (patch) | |
tree | da73a2d532a27685a31d932b3a44a707d4a3af81 /keyboards/evyd13/wasdat/matrix.c | |
parent | 15385d4113414d42bd062c60c9de5df797d3157f (diff) | |
download | qmk_firmware-c66df1664497546f32662409778731143e45a552.tar.gz qmk_firmware-c66df1664497546f32662409778731143e45a552.zip |
2020 November 28 Breaking Changes Update (#11053)0.11.0
* Branch point for 2020 November 28 Breaking Change
* Remove matrix_col_t to allow MATRIX_ROWS > 32 (#10183)
* Add support for soft serial to ATmega32U2 (#10204)
* Change MIDI velocity implementation to allow direct control of velocity value (#9940)
* Add ability to build a subset of all keyboards based on platform.
* Actually use eeprom_driver_init().
* Make bootloader_jump weak for ChibiOS. (#10417)
* Joystick 16-bit support (#10439)
* Per-encoder resolutions (#10259)
* Share button state from mousekey to pointing_device (#10179)
* Add hotfix for chibios keyboards not wake (#10088)
* Add advanced/efficient RGB Matrix Indicators (#8564)
* Naming change.
* Support for STM32 GPIOF,G,H,I,J,K (#10206)
* Add milc as a dependency and remove the installed milc (#10563)
* ChibiOS upgrade: early init conversions (#10214)
* ChibiOS upgrade: configuration file migrator (#9952)
* Haptic and solenoid cleanup (#9700)
* XD75 cleanup (#10524)
* OLED display update interval support (#10388)
* Add definition based on currently-selected serial driver. (#10716)
* New feature: Retro Tapping per key (#10622)
* Allow for modification of output RGB values when using rgblight/rgb_matrix. (#10638)
* Add housekeeping task callbacks so that keyboards/keymaps are capable of executing code for each main loop iteration. (#10530)
* Rescale both ChibiOS and AVR backlighting.
* Reduce Helix keyboard build variation (#8669)
* Minor change to behavior allowing display updates to continue between task ticks (#10750)
* Some GPIO manipulations in matrix.c change to atomic. (#10491)
* qmk cformat (#10767)
* [Keyboard] Update the Speedo firmware for v3.0 (#10657)
* Maartenwut/Maarten namechange to evyd13/Evy (#10274)
* [quantum] combine repeated lines of code (#10837)
* Add step sequencer feature (#9703)
* aeboards/ext65 refactor (#10820)
* Refactor xelus/dawn60 for Rev2 later (#10584)
* add DEBUG_MATRIX_SCAN_RATE_ENABLE to common_features.mk (#10824)
* [Core] Added `add_oneshot_mods` & `del_oneshot_mods` (#10549)
* update chibios os usb for the otg driver (#8893)
* Remove HD44780 References, Part 4 (#10735)
* [Keyboard] Add Valor FRL TKL (+refactor) (#10512)
* Fix cursor position bug in oled_write_raw functions (#10800)
* Fixup version.h writing when using SKIP_VERSION=yes (#10972)
* Allow for certain code in the codebase assuming length of string. (#10974)
* Add AT90USB support for serial.c (#10706)
* Auto shift: support repeats and early registration (#9826)
* Rename ledmatrix.h to match .c file (#7949)
* Split RGB_MATRIX_ENABLE into _ENABLE and _DRIVER (#10231)
* Split LED_MATRIX_ENABLE into _ENABLE and _DRIVER (#10840)
* Merge point for 2020 Nov 28 Breaking Change
Diffstat (limited to 'keyboards/evyd13/wasdat/matrix.c')
-rw-r--r-- | keyboards/evyd13/wasdat/matrix.c | 344 |
1 files changed, 344 insertions, 0 deletions
diff --git a/keyboards/evyd13/wasdat/matrix.c b/keyboards/evyd13/wasdat/matrix.c new file mode 100644 index 0000000000..6dd79b5330 --- /dev/null +++ b/keyboards/evyd13/wasdat/matrix.c @@ -0,0 +1,344 @@ +/* +Copyright 2012-2018 Jun Wako, Jack Humbert, Yiancar + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ +#include <stdint.h> +#include <stdbool.h> +#include "wait.h" +#include "util.h" +#include "matrix.h" +#include "debounce.h" +#include "quantum.h" + +#ifdef DIRECT_PINS +static pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS; +#elif (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW) +static const pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; +//static const pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; +#endif + +// matrix code + +#ifdef DIRECT_PINS + +static void init_pins(void) { + for (int row = 0; row < MATRIX_ROWS; row++) { + for (int col = 0; col < MATRIX_COLS; col++) { + pin_t pin = direct_pins[row][col]; + if (pin != NO_PIN) { + setPinInputHigh(pin); + } + } + } +} + +static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) { + matrix_row_t last_row_value = current_matrix[current_row]; + current_matrix[current_row] = 0; + + for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) { + pin_t pin = direct_pins[current_row][col_index]; + if (pin != NO_PIN) { + current_matrix[current_row] |= readPin(pin) ? 0 : (MATRIX_ROW_SHIFTER << col_index); + } + } + + return (last_row_value != current_matrix[current_row]); +} + +#elif (DIODE_DIRECTION == COL2ROW) + +static void select_row(uint8_t row) { + setPinOutput(row_pins[row]); + writePinLow(row_pins[row]); +} + +static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); } + +static void unselect_rows(void) { + for (uint8_t x = 0; x < MATRIX_ROWS; x++) { + setPinInputHigh(row_pins[x]); + } +} + +static void init_pins(void) { + unselect_rows(); + for (uint8_t x = 0; x < MATRIX_COLS; x++) { + setPinInputHigh(col_pins[x]); + } +} + +static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) { + // Store last value of row prior to reading + matrix_row_t last_row_value = current_matrix[current_row]; + + // Clear data in matrix row + current_matrix[current_row] = 0; + + // Select row and wait for row selecton to stabilize + select_row(current_row); + wait_us(30); + + // For each col... + for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) { + + // Select the col pin to read (active low) + uint8_t pin_state = readPin(col_pins[col_index]); + + // Populate the matrix row with the state of the col pin + current_matrix[current_row] |= pin_state ? 0 : (MATRIX_ROW_SHIFTER << col_index); + } + + // Unselect row + unselect_row(current_row); + + return (last_row_value != current_matrix[current_row]); +} + +#elif (DIODE_DIRECTION == ROW2COL) + +/* Cols 0 - 15 + * col 0: C7 + * col 1: B6 + * col 2: C6 + * col 3: B4 + * col 4: B5 + * col 5: D7 + * These columns use a 74HC237D 3 to 8 bit demultiplexer. + * A0 A1 A2 + * col / pin: PD2 PD1 PD0 + * 6: 1 1 1 + * 7: 0 1 1 + * 8: 1 0 1 + * 9: 0 0 1 + * 10: 1 1 0 + * 11: 0 1 0 + * 12: 1 0 0 + * col 13: D3 + * col 14: B7 + * col 15: B3 + */ +static void select_col(uint8_t col) { + switch (col) { + case 0: + writePinLow(C7); + break; + case 1: + writePinLow(B6); + break; + case 2: + writePinLow(C6); + break; + case 3: + writePinLow(B4); + break; + case 4: + writePinLow(B5); + break; + case 5: + writePinLow(D7); + break; + case 6: + writePinHigh(D0); + writePinHigh(D1); + writePinHigh(D2); + break; + case 7: + writePinHigh(D0); + writePinHigh(D1); + break; + case 8: + writePinHigh(D0); + writePinHigh(D2); + break; + case 9: + writePinHigh(D0); + break; + case 10: + writePinHigh(D1); + writePinHigh(D2); + break; + case 11: + writePinHigh(D1); + break; + case 12: + writePinHigh(D2); + break; + case 13: + writePinLow(D3); + break; + case 14: + writePinLow(B7); + break; + case 15: + writePinLow(B3); + break; + } +} + +static void unselect_col(uint8_t col) { + switch (col) { + case 0: + writePinHigh(C7); + break; + case 1: + writePinHigh(B6); + break; + case 2: + writePinHigh(C6); + break; + case 3: + writePinHigh(B4); + break; + case 4: + writePinHigh(B5); + break; + case 5: + writePinHigh(D7); + break; + case 6: + writePinLow(D0); + writePinLow(D1); + writePinLow(D2); + break; + case 7: + writePinLow(D0); + writePinLow(D1); + break; + case 8: + writePinLow(D0); + writePinLow(D2); + break; + case 9: + writePinLow(D0); + break; + case 10: + writePinLow(D1); + writePinLow(D2); + break; + case 11: + writePinLow(D1); + break; + case 12: + writePinLow(D2); + break; + case 13: + writePinHigh(D3); + break; + case 14: + writePinHigh(B7); + break; + case 15: + writePinHigh(B3); + break; + } +} + +static void unselect_cols(void) { + //Native + setPinOutput(D3); + setPinOutput(D7); + writePinHigh(D3); + writePinHigh(D7); + + setPinOutput(C6); + setPinOutput(C7); + writePinHigh(C6); + writePinHigh(C7); + + setPinOutput(B3); + setPinOutput(B4); + setPinOutput(B5); + setPinOutput(B6); + setPinOutput(B7); + writePinHigh(B3); + writePinHigh(B4); + writePinHigh(B5); + writePinHigh(B6); + writePinHigh(B7); + + //Demultiplexer + setPinOutput(D0); + setPinOutput(D1); + setPinOutput(D2); + writePinLow(D0); + writePinLow(D1); + writePinLow(D2); +} + +static void init_pins(void) { + unselect_cols(); + for (uint8_t x = 0; x < MATRIX_ROWS; x++) { + setPinInputHigh(row_pins[x]); + } +} + +static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) { + bool matrix_changed = false; + + // Select col and wait for col selecton to stabilize + select_col(current_col); + wait_us(30); + + // For each row... + for (uint8_t row_index = 0; row_index < MATRIX_ROWS; row_index++) { + // Store last value of row prior to reading + matrix_row_t last_row_value = current_matrix[row_index]; + + // Check row pin state + if (readPin(row_pins[row_index]) == 0) { + // Pin LO, set col bit + current_matrix[row_index] |= (MATRIX_ROW_SHIFTER << current_col); + } else { + // Pin HI, clear col bit + current_matrix[row_index] &= ~(MATRIX_ROW_SHIFTER << current_col); + } + + // Determine if the matrix changed state + if ((last_row_value != current_matrix[row_index]) && !(matrix_changed)) { + matrix_changed = true; + } + } + + // Unselect col + unselect_col(current_col); + + return matrix_changed; +} + +#endif + +void matrix_init_custom(void) { + // initialize key pins + init_pins(); +} + +bool matrix_scan_custom(matrix_row_t current_matrix[]) { + bool changed = false; + +#if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW) + // Set row, read cols + for (uint8_t current_row = 0; current_row < MATRIX_ROWS; current_row++) { + changed |= read_cols_on_row(current_matrix, current_row); + } +#elif (DIODE_DIRECTION == ROW2COL) + // Set col, read rows + for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) { + changed |= read_rows_on_col(current_matrix, current_col); + } +#endif + + return changed; +} |