Optimize matrix scanning (#343)
This commit is contained in:
Eric Tang
Jack Humbert
parent
d66aa0abf9
commit
aaa758f1d3
@ -195,11 +195,9 @@ You'll want to navigate to the `keyboard/<project_name>/` folder by typing, like
|
||||
|
||||
#### config.h
|
||||
|
||||
The first thing we're going to want to modify is the `config.h` file. On line 32 and 33, you'll see `MATRIX_ROWS` and `MATRIX_COLS` - set both these variables to however many rows and columns you have on your keyboard.
|
||||
The first thing you're going to want to modify is the `config.h` file. Find `MATRIX_ROWS` and `MATRIX_COLS` and them to match the dimensions of your keyboard's matrix.
|
||||
|
||||
On line 38 and 39 you'll see the `COLS` and `ROWS` definitions - this is where you'll enter the pins you used, in order (left-to-right when looking at the top of the keyboard, but right-to-left when looking at the bottom).
|
||||
|
||||
There are some other variables that you'll be able to modify (lines 23-29), but it's not necessary to do that now (or ever, really).
|
||||
Farther down are `MATRIX_ROW_PINS` and `MATRIX_COL_PINS`. Change their definitions to match how you wired up your matrix (looking from the top of the keyboard, the rows run top-to-bottom and the columns run left-to-right). Likewise, change the definition of `UNUSED_PINS` to match the pins you did not use (this will save power).
|
||||
|
||||
#### \<project_name\>.h
|
||||
|
||||
|
||||
@ -35,8 +35,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
// Planck PCB default pin-out
|
||||
// Change this to how you wired your keyboard
|
||||
// COLS: Left to right, ROWS: Top to bottom
|
||||
#define COLS (int []){ B0, B1, B2, B3, B7, D0, B6, F7, F6, F5, F4, F1 }
|
||||
#define ROWS (int []){ F0, D6, D4, D5 }
|
||||
#define MATRIX_ROW_PINS { F0, D6, D4, D5 }
|
||||
#define MATRIX_COL_PINS { B0, B1, B2, B3, B7, D0, B6, F7, F6, F5, F4, F1 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
@ -48,7 +49,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define BACKLIGHT_LEVELS 3
|
||||
|
||||
/* Set 0 if debouncing isn't needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
|
||||
#define LOCKING_SUPPORT_ENABLE
|
||||
|
||||
@ -42,14 +42,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
* ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
|
||||
*
|
||||
*/
|
||||
#define COLS (int []){ F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7, D3, D2, D1 }
|
||||
#define ROWS (int []){ D0, D5, B5, B6, C6 }
|
||||
#define MATRIX_ROW_PINS { D0, D5, B5, B6, C6 }
|
||||
#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7, D3, D2, D1 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
|
||||
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* define if matrix has ghost (lacks anti-ghosting diodes) */
|
||||
//#define MATRIX_HAS_GHOST
|
||||
|
||||
@ -42,14 +42,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
* ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
|
||||
*
|
||||
*/
|
||||
#define COLS (int []){ F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7, D3, D2, D1 }
|
||||
#define ROWS (int []){ D0, D5, B5, B6, B3 }
|
||||
#define MATRIX_ROW_PINS { D0, D5, B5, B6, B3 }
|
||||
#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7, D3, D2, D1 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
|
||||
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* define if matrix has ghost (lacks anti-ghosting diodes) */
|
||||
//#define MATRIX_HAS_GHOST
|
||||
|
||||
@ -36,11 +36,13 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
// Change this to how you wired your keyboard
|
||||
// COLS: Left to right, ROWS: Top to bottom
|
||||
#if defined(ATREUS_ASTAR)
|
||||
#define COLS (int []){ D7, C6, B5, B4, E6, D4, B6, F6, F7, D6, B7 }
|
||||
#define ROWS (int []){ D0, D1, D3, D2 }
|
||||
# define MATRIX_ROW_PINS { D0, D1, D3, D2 }
|
||||
# define MATRIX_COL_PINS { D7, C6, B5, B4, E6, D4, B6, F6, F7, D6, B7 }
|
||||
# define UNUSED_PINS
|
||||
#elif defined(ATREUS_TEENSY2)
|
||||
#define COLS (int []){ F6, F5, F4, B7, B6, B5, B4, B3, B2, B1, B0}
|
||||
#define ROWS (int []){ D0, D1, D2, D3 }
|
||||
# define MATRIX_ROW_PINS { D0, D1, D2, D3 }
|
||||
# define MATRIX_COL_PINS { F6, F5, F4, B7, B6, B5, B4, B3, B2, B1, B0 }
|
||||
# define UNUSED_PINS
|
||||
#endif
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
@ -53,7 +55,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
//#define BACKLIGHT_LEVELS 3
|
||||
|
||||
/* Set 0 if debouncing isn't needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
|
||||
#define LOCKING_SUPPORT_ENABLE
|
||||
|
||||
@ -32,19 +32,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define MATRIX_ROWS 5
|
||||
#define MATRIX_COLS 16
|
||||
|
||||
// COLS: Left to right, ROWS: Top to bottom
|
||||
|
||||
// ROWS: Top to bottom, COLS: Left to right
|
||||
/* Column pin configuration
|
||||
* col: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
|
||||
* pin: B3 F1 F4 F5 F6 C7 C6 B6 B5 B4 D7 D6 D4 F7 B0 B1
|
||||
*/
|
||||
#define COLS (int []){ B3, F1, F4, F5, F6, C7, C6, B6, B5, B4, D7, D6, D4, F7, B0, B1 }
|
||||
|
||||
/* Row pin configuration
|
||||
* row: 0 1 2 3 4
|
||||
* pin: D1 D0 D2 D5 D3
|
||||
*/
|
||||
#define ROWS (int []){ D1, D0, D2, D5, D3 }
|
||||
* col: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
|
||||
* pin: B3 F1 F4 F5 F6 C7 C6 B6 B5 B4 D7 D6 D4 F7 B0 B1
|
||||
*/
|
||||
#define MATRIX_COL_PINS { B3, F1, F4, F5, F6, C7, C6, B6, B5, B4, D7, D6, D4, F7, B0, B1 }
|
||||
/* Row pin configuration
|
||||
* row: 0 1 2 3 4
|
||||
* pin: D1 D0 D2 D5 D3
|
||||
*/
|
||||
#define MATRIX_ROW_PINS { D1, D0, D2, D5, D3 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
@ -53,7 +52,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
//#define MATRIX_HAS_GHOST
|
||||
|
||||
/* Set 0 if debouncing isn't needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
|
||||
#define LOCKING_SUPPORT_ENABLE
|
||||
|
||||
@ -32,19 +32,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define MATRIX_ROWS 10
|
||||
#define MATRIX_COLS 8
|
||||
|
||||
// COLS: Left to right, ROWS: Top to bottom
|
||||
|
||||
// ROWS: Top to bottom, COLS: Left to right
|
||||
/* Row pin configuration
|
||||
* row: 0 1 2 3 4 5 6 7 8 9
|
||||
* pin: B2 C7 C6 B6 B5 B0 B3 D5 D3 D2
|
||||
*/
|
||||
#define MATRIX_ROW_PINS { B2, C7, C6, B6, B5, B0, B3, D5, D3, D2 }
|
||||
/* Column pin configuration
|
||||
* col: 0 1 2 3 4 5 6 7
|
||||
* pin: F0 F1 F4 F5 F6 F7 E6 B1
|
||||
*/
|
||||
#define COLS (int []){ F0, F1, F4, F5, F6, F7, E6, B1 }
|
||||
|
||||
/* Row pin configuration
|
||||
* row: 0 1 2 3 4 5 6 7 8 9
|
||||
* pin: B2 C7 C6 B6 B5 B0 B3 D5 D3 D2
|
||||
*/
|
||||
#define ROWS (int []){ B2, C7, C6, B6, B5, B0, B3, D5, D3, D2 }
|
||||
#define MATRIX_COL_PINS { F0, F1, F4, F5, F6, F7, E6, B1 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
@ -53,7 +52,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
//#define MATRIX_HAS_GHOST
|
||||
|
||||
/* Set 0 if debouncing isn't needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
|
||||
#define LOCKING_SUPPORT_ENABLE
|
||||
|
||||
@ -32,19 +32,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define MATRIX_ROWS 5
|
||||
#define MATRIX_COLS 4
|
||||
|
||||
// COLS: Left to right, ROWS: Top to bottom
|
||||
|
||||
// ROWS: Top to bottom, COLS: Left to right
|
||||
/* Row pin configuration
|
||||
* row: 0 1 2 3 4
|
||||
* pin:
|
||||
*/
|
||||
#define MATRIX_ROW_PINS { B0, D3, D5, D4, D6 }
|
||||
/* Column pin configuration
|
||||
* col: 0 1 2 3
|
||||
* pin: F4 E6 B1 D2
|
||||
*/
|
||||
#define COLS (int []){ F4, E6, B1, D2 }
|
||||
|
||||
/* Row pin configuration
|
||||
* row: 0 1 2 3 4
|
||||
* pin:
|
||||
*/
|
||||
#define ROWS (int []){ B0, D3, D5, D4, D6 }
|
||||
#define MATRIX_COL_PINS { F4, E6, B1, D2 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
@ -53,7 +52,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
//#define MATRIX_HAS_GHOST
|
||||
|
||||
/* Set 0 if debouncing isn't needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* Number of backlighting levels */
|
||||
#define BACKLIGHT_LEVELS 3
|
||||
|
||||
@ -42,14 +42,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
* ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
|
||||
*
|
||||
*/
|
||||
#define COLS (int []){ F0, F1, E6, C7, C6, B6, D4, B1, B7, B5, B4, D7, D6, B3 }
|
||||
#define ROWS (int []){ D0, D1, D2, D3, D5 }
|
||||
#define MATRIX_ROW_PINS { D0, D1, D2, D3, D5 }
|
||||
#define MATRIX_COL_PINS { F0, F1, E6, C7, C6, B6, D4, B1, B7, B5, B4, D7, D6, B3 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
|
||||
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* define if matrix has ghost (lacks anti-ghosting diodes) */
|
||||
//#define MATRIX_HAS_GHOST
|
||||
|
||||
@ -33,8 +33,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define MATRIX_COLS 13
|
||||
|
||||
/* Planck PCB default pin-out */
|
||||
#define COLS (int []){F4, D7, B5, B6, C6, C7, D4, D6, D5, D0, D1, D2, B0}
|
||||
#define ROWS (int []){F0, F1, F5, B4}
|
||||
#define MATRIX_ROW_PINS { F0, F1, F5, B4 }
|
||||
#define MATRIX_COL_PINS { F4, D7, B5, B6, C6, C7, D4, D6, D5, D0, D1, D2, B0 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
@ -46,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define BACKLIGHT_LEVELS 3
|
||||
|
||||
/* Set 0 if debouncing isn't needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
|
||||
#define LOCKING_SUPPORT_ENABLE
|
||||
|
||||
@ -33,8 +33,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define MATRIX_COLS 12
|
||||
|
||||
/* Planck PCB default pin-out */
|
||||
#define COLS (int []){ F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
|
||||
#define ROWS (int []){ D0, D5, B5, B6 }
|
||||
#define MATRIX_ROW_PINS { D0, D5, B5, B6 }
|
||||
#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
@ -46,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define BACKLIGHT_LEVELS 3
|
||||
|
||||
/* Set 0 if debouncing isn't needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
|
||||
#define LOCKING_SUPPORT_ENABLE
|
||||
|
||||
@ -33,8 +33,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define MATRIX_COLS 12
|
||||
|
||||
/* Planck PCB default pin-out */
|
||||
#define COLS (int []){ F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
|
||||
#define ROWS (int []){ D0, D5, B5, B6 }
|
||||
#define MATRIX_ROW_PINS { D0, D5, B5, B6 }
|
||||
#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
@ -46,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define BACKLIGHT_LEVELS 3
|
||||
|
||||
/* Set 0 if debouncing isn't needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
|
||||
#define LOCKING_SUPPORT_ENABLE
|
||||
|
||||
@ -33,8 +33,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define MATRIX_COLS 12
|
||||
|
||||
/* Planck PCB default pin-out */
|
||||
#define COLS (int []){ F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
|
||||
#define ROWS (int []){ D2, D5, B5, B6, D3 }
|
||||
#define MATRIX_ROW_PINS { D2, D5, B5, B6, D3 }
|
||||
#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
@ -46,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define BACKLIGHT_LEVELS 3
|
||||
|
||||
/* Set 0 if debouncing isn't needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
|
||||
#define LOCKING_SUPPORT_ENABLE
|
||||
|
||||
@ -33,8 +33,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define MATRIX_COLS 8
|
||||
|
||||
// See note in retro_refit.h for an explanation of how this matrix is wired up
|
||||
#define COLS (int []){ B0, B1, B2, B3, D2, D3, C7, D5 }
|
||||
#define ROWS (int []){ D4, D7, B4, B5, B6, F7, F6, F5, F4, F1, F0 }
|
||||
#define MATRIX_ROW_PINS { D4, D7, B4, B5, B6, F7, F6, F5, F4, F1, F0 }
|
||||
#define MATRIX_COL_PINS { B0, B1, B2, B3, D2, D3, C7, D5 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
@ -46,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#define BACKLIGHT_LEVELS 0
|
||||
|
||||
/* Set 0 if debouncing isn't needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
|
||||
#define LOCKING_SUPPORT_ENABLE
|
||||
|
||||
@ -1,70 +1,74 @@
|
||||
#ifndef CONFIG_DEFINITIONS_H
|
||||
#define CONFIG_DEFINITIONS_H
|
||||
|
||||
#define B0 0x20
|
||||
#define B1 0x21
|
||||
#define B2 0x22
|
||||
#define B3 0x23
|
||||
#define B4 0x24
|
||||
#define B5 0x25
|
||||
#define B6 0x26
|
||||
#define B7 0x27
|
||||
#define C0 0x30
|
||||
#define C1 0x31
|
||||
#define C2 0x32
|
||||
#define C3 0x33
|
||||
#define C4 0x34
|
||||
#define C5 0x35
|
||||
#define C6 0x36
|
||||
#define C7 0x37
|
||||
#define D0 0x40
|
||||
#define D1 0x41
|
||||
#define D2 0x42
|
||||
#define D3 0x43
|
||||
#define D4 0x44
|
||||
#define D5 0x45
|
||||
#define D6 0x46
|
||||
#define D7 0x47
|
||||
#define E0 0x50
|
||||
#define E1 0x51
|
||||
#define E2 0x52
|
||||
#define E3 0x53
|
||||
#define E4 0x54
|
||||
#define E5 0x55
|
||||
#define E6 0x56
|
||||
#define E7 0x57
|
||||
#define F0 0x60
|
||||
#define F1 0x61
|
||||
#define F2 0x62
|
||||
#define F3 0x63
|
||||
#define F4 0x64
|
||||
#define F5 0x65
|
||||
#define F6 0x66
|
||||
#define F7 0x67
|
||||
|
||||
#define COL2ROW 0x0
|
||||
#define ROW2COL 0x1
|
||||
/* diode directions */
|
||||
#define COL2ROW 0
|
||||
#define ROW2COL 1
|
||||
/* I/O pins */
|
||||
#define B0 { .input_addr = 3, .bit = 0 }
|
||||
#define B1 { .input_addr = 3, .bit = 1 }
|
||||
#define B2 { .input_addr = 3, .bit = 2 }
|
||||
#define B3 { .input_addr = 3, .bit = 3 }
|
||||
#define B4 { .input_addr = 3, .bit = 4 }
|
||||
#define B5 { .input_addr = 3, .bit = 5 }
|
||||
#define B6 { .input_addr = 3, .bit = 6 }
|
||||
#define B7 { .input_addr = 3, .bit = 7 }
|
||||
#define C0 { .input_addr = 6, .bit = 0 }
|
||||
#define C1 { .input_addr = 6, .bit = 1 }
|
||||
#define C2 { .input_addr = 6, .bit = 2 }
|
||||
#define C3 { .input_addr = 6, .bit = 3 }
|
||||
#define C4 { .input_addr = 6, .bit = 4 }
|
||||
#define C5 { .input_addr = 6, .bit = 5 }
|
||||
#define C6 { .input_addr = 6, .bit = 6 }
|
||||
#define C7 { .input_addr = 6, .bit = 7 }
|
||||
#define D0 { .input_addr = 9, .bit = 0 }
|
||||
#define D1 { .input_addr = 9, .bit = 1 }
|
||||
#define D2 { .input_addr = 9, .bit = 2 }
|
||||
#define D3 { .input_addr = 9, .bit = 3 }
|
||||
#define D4 { .input_addr = 9, .bit = 4 }
|
||||
#define D5 { .input_addr = 9, .bit = 5 }
|
||||
#define D6 { .input_addr = 9, .bit = 6 }
|
||||
#define D7 { .input_addr = 9, .bit = 7 }
|
||||
#define E0 { .input_addr = 0xC, .bit = 0 }
|
||||
#define E1 { .input_addr = 0xC, .bit = 1 }
|
||||
#define E2 { .input_addr = 0xC, .bit = 2 }
|
||||
#define E3 { .input_addr = 0xC, .bit = 3 }
|
||||
#define E4 { .input_addr = 0xC, .bit = 4 }
|
||||
#define E5 { .input_addr = 0xC, .bit = 5 }
|
||||
#define E6 { .input_addr = 0xC, .bit = 6 }
|
||||
#define E7 { .input_addr = 0xC, .bit = 7 }
|
||||
#define F0 { .input_addr = 0xF, .bit = 0 }
|
||||
#define F1 { .input_addr = 0xF, .bit = 1 }
|
||||
#define F2 { .input_addr = 0xF, .bit = 2 }
|
||||
#define F3 { .input_addr = 0xF, .bit = 3 }
|
||||
#define F4 { .input_addr = 0xF, .bit = 4 }
|
||||
#define F5 { .input_addr = 0xF, .bit = 5 }
|
||||
#define F6 { .input_addr = 0xF, .bit = 6 }
|
||||
#define F7 { .input_addr = 0xF, .bit = 7 }
|
||||
|
||||
/* USART configuration */
|
||||
#ifdef BLUETOOTH_ENABLE
|
||||
#ifdef __AVR_ATmega32U4__
|
||||
#define SERIAL_UART_BAUD 9600
|
||||
#define SERIAL_UART_DATA UDR1
|
||||
#define SERIAL_UART_UBRR ((F_CPU/(16UL*SERIAL_UART_BAUD))-1)
|
||||
#define SERIAL_UART_RXD_VECT USART1_RX_vect
|
||||
#define SERIAL_UART_TXD_READY (UCSR1A&(1<<UDRE1))
|
||||
#define SERIAL_UART_INIT() do { \
|
||||
UBRR1L = (uint8_t) SERIAL_UART_UBRR; /* baud rate */ \
|
||||
UBRR1H = (uint8_t) (SERIAL_UART_UBRR>>8); /* baud rate */ \
|
||||
UCSR1B = (1<<TXEN1); /* TX: enable */ \
|
||||
UCSR1C = (0<<UPM11) | (0<<UPM10) | /* parity: none(00), even(01), odd(11) */ \
|
||||
(0<<UCSZ12) | (1<<UCSZ11) | (1<<UCSZ10); /* data-8bit(011) */ \
|
||||
# ifdef __AVR_ATmega32U4__
|
||||
# define SERIAL_UART_BAUD 9600
|
||||
# define SERIAL_UART_DATA UDR1
|
||||
# define SERIAL_UART_UBRR (F_CPU / (16UL * SERIAL_UART_BAUD) - 1)
|
||||
# define SERIAL_UART_RXD_VECT USART1_RX_vect
|
||||
# define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1))
|
||||
# define SERIAL_UART_INIT() do { \
|
||||
/* baud rate */ \
|
||||
UBRR1L = SERIAL_UART_UBRR; \
|
||||
/* baud rate */ \
|
||||
UBRR1H = SERIAL_UART_UBRR >> 8; \
|
||||
/* enable TX */ \
|
||||
UCSR1B = _BV(TXEN1); \
|
||||
/* 8-bit data */ \
|
||||
UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \
|
||||
sei(); \
|
||||
} while(0)
|
||||
#else
|
||||
# else
|
||||
# error "USART configuration is needed."
|
||||
#endif
|
||||
|
||||
|
||||
// I'm fairly sure these aren't needed, but oh well - Jack
|
||||
|
||||
/*
|
||||
@ -113,4 +117,3 @@
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
389
quantum/matrix.c
389
quantum/matrix.c
@ -1,6 +1,6 @@
|
||||
/*
|
||||
Copyright 2012 Jun Wako
|
||||
Generated by planckkeyboard.com (2014 Jack Humbert)
|
||||
Copyright 2014 Jack Humbert
|
||||
|
||||
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
|
||||
@ -15,300 +15,211 @@ 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/>.
|
||||
*/
|
||||
|
||||
/*
|
||||
* scan matrix
|
||||
*/
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <avr/io.h>
|
||||
#include <util/delay.h>
|
||||
#include "wait.h"
|
||||
#include "print.h"
|
||||
#include "debug.h"
|
||||
#include "util.h"
|
||||
#include "matrix.h"
|
||||
|
||||
#ifndef DEBOUNCE
|
||||
# define DEBOUNCE 10
|
||||
#ifdef MATRIX_HAS_GHOST
|
||||
# error "The universal matrix.c file cannot be used for this keyboard."
|
||||
#endif
|
||||
static uint8_t debouncing = DEBOUNCE;
|
||||
|
||||
/* matrix state(1:on, 0:off) */
|
||||
#ifndef DEBOUNCING_DELAY
|
||||
# define DEBOUNCING_DELAY 5
|
||||
#endif
|
||||
|
||||
static const io_pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
|
||||
static const io_pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
|
||||
/* matrix state */
|
||||
#if DIODE_DIRECTION == COL2ROW
|
||||
static matrix_row_t matrix[MATRIX_ROWS];
|
||||
static matrix_row_t matrix_debouncing[MATRIX_ROWS];
|
||||
|
||||
#if DIODE_DIRECTION == ROW2COL
|
||||
static matrix_row_t matrix_reversed[MATRIX_COLS];
|
||||
static matrix_row_t matrix_reversed_debouncing[MATRIX_COLS];
|
||||
#endif
|
||||
|
||||
|
||||
#if MATRIX_COLS > 16
|
||||
#define SHIFTER 1UL
|
||||
static matrix_row_t debouncing_matrix[MATRIX_ROWS];
|
||||
#else
|
||||
#define SHIFTER 1
|
||||
static matrix_col_t matrix[MATRIX_COLS];
|
||||
static matrix_col_t debouncing_matrix[MATRIX_COLS];
|
||||
#endif
|
||||
static int8_t debouncing_delay = -1;
|
||||
|
||||
#if DIODE_DIRECTION == COL2ROW
|
||||
static void toggle_row(uint8_t row);
|
||||
static matrix_row_t read_cols(void);
|
||||
static void init_cols(void);
|
||||
static void unselect_rows(void);
|
||||
static void select_row(uint8_t row);
|
||||
#else
|
||||
static void toggle_col(uint8_t col);
|
||||
static matrix_col_t read_rows(void);
|
||||
#endif
|
||||
|
||||
__attribute__ ((weak))
|
||||
void matrix_init_quantum(void) {
|
||||
|
||||
}
|
||||
|
||||
__attribute__ ((weak))
|
||||
void matrix_scan_quantum(void) {
|
||||
|
||||
}
|
||||
|
||||
inline
|
||||
uint8_t matrix_rows(void)
|
||||
{
|
||||
uint8_t matrix_rows(void) {
|
||||
return MATRIX_ROWS;
|
||||
}
|
||||
|
||||
inline
|
||||
uint8_t matrix_cols(void)
|
||||
{
|
||||
uint8_t matrix_cols(void) {
|
||||
return MATRIX_COLS;
|
||||
}
|
||||
|
||||
void matrix_init(void)
|
||||
{
|
||||
// To use PORTF disable JTAG with writing JTD bit twice within four cycles.
|
||||
MCUCR |= (1<<JTD);
|
||||
MCUCR |= (1<<JTD);
|
||||
|
||||
|
||||
// initialize row and col
|
||||
unselect_rows();
|
||||
init_cols();
|
||||
|
||||
// initialize matrix state: all keys off
|
||||
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
|
||||
matrix[i] = 0;
|
||||
matrix_debouncing[i] = 0;
|
||||
void matrix_init(void) {
|
||||
/* frees PORTF by setting the JTD bit twice within four cycles */
|
||||
MCUCR |= _BV(JTD);
|
||||
MCUCR |= _BV(JTD);
|
||||
/* initializes the I/O pins */
|
||||
#if DIODE_DIRECTION == COL2ROW
|
||||
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
|
||||
/* DDRxn */
|
||||
_SFR_IO8(row_pins[r].input_addr + 1) |= _BV(row_pins[r].bit);
|
||||
toggle_row(r);
|
||||
}
|
||||
|
||||
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
|
||||
/* PORTxn */
|
||||
_SFR_IO8(col_pins[c].input_addr + 2) |= _BV(col_pins[c].bit);
|
||||
}
|
||||
#else
|
||||
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
|
||||
/* DDRxn */
|
||||
_SFR_IO8(col_pins[c].input_addr + 1) |= _BV(col_pins[c].bit);
|
||||
toggle_col(c);
|
||||
}
|
||||
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
|
||||
/* PORTxn */
|
||||
_SFR_IO8(row_pins[r].input_addr + 2) |= _BV(row_pins[r].bit);
|
||||
}
|
||||
#endif
|
||||
matrix_init_quantum();
|
||||
}
|
||||
|
||||
|
||||
uint8_t matrix_scan(void)
|
||||
{
|
||||
|
||||
#if DIODE_DIRECTION == COL2ROW
|
||||
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
|
||||
select_row(i);
|
||||
_delay_us(30); // without this wait read unstable value.
|
||||
matrix_row_t cols = read_cols();
|
||||
if (matrix_debouncing[i] != cols) {
|
||||
matrix_debouncing[i] = cols;
|
||||
if (debouncing) {
|
||||
debug("bounce!: "); debug_hex(debouncing); debug("\n");
|
||||
uint8_t matrix_scan(void) {
|
||||
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
|
||||
toggle_row(r);
|
||||
matrix_row_t state = read_cols();
|
||||
if (debouncing_matrix[r] != state) {
|
||||
debouncing_matrix[r] = state;
|
||||
debouncing_delay = DEBOUNCING_DELAY;
|
||||
}
|
||||
debouncing = DEBOUNCE;
|
||||
toggle_row(r);
|
||||
}
|
||||
unselect_rows();
|
||||
if (debouncing_delay >= 0) {
|
||||
dprintf("Debouncing delay remaining: %X\n", debouncing_delay);
|
||||
--debouncing_delay;
|
||||
if (debouncing_delay >= 0) {
|
||||
wait_ms(1);
|
||||
}
|
||||
|
||||
if (debouncing) {
|
||||
if (--debouncing) {
|
||||
_delay_ms(1);
|
||||
} else {
|
||||
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
|
||||
matrix[i] = matrix_debouncing[i];
|
||||
else {
|
||||
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
|
||||
matrix[r] = debouncing_matrix[r];
|
||||
}
|
||||
}
|
||||
}
|
||||
#else
|
||||
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
|
||||
select_row(i);
|
||||
_delay_us(30); // without this wait read unstable value.
|
||||
matrix_row_t rows = read_cols();
|
||||
if (matrix_reversed_debouncing[i] != rows) {
|
||||
matrix_reversed_debouncing[i] = rows;
|
||||
if (debouncing) {
|
||||
debug("bounce!: "); debug_hex(debouncing); debug("\n");
|
||||
}
|
||||
debouncing = DEBOUNCE;
|
||||
}
|
||||
unselect_rows();
|
||||
}
|
||||
|
||||
if (debouncing) {
|
||||
if (--debouncing) {
|
||||
_delay_ms(1);
|
||||
} else {
|
||||
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
|
||||
matrix_reversed[i] = matrix_reversed_debouncing[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
for (uint8_t y = 0; y < MATRIX_ROWS; y++) {
|
||||
matrix_row_t row = 0;
|
||||
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
|
||||
row |= ((matrix_reversed[x] & (1<<y)) >> y) << x;
|
||||
}
|
||||
matrix[y] = row;
|
||||
}
|
||||
#endif
|
||||
|
||||
matrix_scan_quantum();
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
bool matrix_is_modified(void)
|
||||
{
|
||||
if (debouncing) return false;
|
||||
return true;
|
||||
static void toggle_row(uint8_t row) {
|
||||
/* PINxn */
|
||||
_SFR_IO8(row_pins[row].input_addr) = _BV(row_pins[row].bit);
|
||||
}
|
||||
|
||||
inline
|
||||
bool matrix_is_on(uint8_t row, uint8_t col)
|
||||
{
|
||||
return (matrix[row] & ((matrix_row_t)1<col));
|
||||
static matrix_row_t read_cols(void) {
|
||||
matrix_row_t state = 0;
|
||||
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
|
||||
/* PINxn */
|
||||
if (!(_SFR_IO8(col_pins[c].input_addr) & _BV(col_pins[c].bit))) {
|
||||
state |= (matrix_row_t)1 << c;
|
||||
}
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
inline
|
||||
matrix_row_t matrix_get_row(uint8_t row)
|
||||
{
|
||||
matrix_row_t matrix_get_row(uint8_t row) {
|
||||
return matrix[row];
|
||||
}
|
||||
|
||||
void matrix_print(void)
|
||||
{
|
||||
print("\nr/c 0123456789ABCDEF\n");
|
||||
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
|
||||
phex(row); print(": ");
|
||||
pbin_reverse16(matrix_get_row(row));
|
||||
print("\n");
|
||||
#else
|
||||
uint8_t matrix_scan(void) {
|
||||
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
|
||||
toggle_col(c);
|
||||
matrix_col_t state = read_rows();
|
||||
if (debouncing_matrix[c] != state) {
|
||||
debouncing_matrix[c] = state;
|
||||
debouncing_delay = DEBOUNCING_DELAY;
|
||||
}
|
||||
toggle_col(c);
|
||||
}
|
||||
if (debouncing_delay >= 0) {
|
||||
dprintf("Debouncing delay remaining: %X\n", debouncing_delay);
|
||||
--debouncing_delay;
|
||||
if (debouncing_delay >= 0) {
|
||||
wait_ms(1);
|
||||
}
|
||||
else {
|
||||
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
|
||||
matrix[c] = debouncing_matrix[c];
|
||||
}
|
||||
}
|
||||
}
|
||||
matrix_scan_quantum();
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void toggle_col(uint8_t col) {
|
||||
/* PINxn */
|
||||
_SFR_IO8(col_pins[col].input_addr) = _BV(col_pins[col].bit);
|
||||
}
|
||||
|
||||
static matrix_col_t read_rows(void) {
|
||||
matrix_col_t state = 0;
|
||||
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
|
||||
/* PINxn */
|
||||
if (!(_SFR_IO8(row_pins[r].input_addr) & _BV(row_pins[r].bit))) {
|
||||
state |= (matrix_col_t)1 << r;
|
||||
}
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
matrix_row_t matrix_get_row(uint8_t row) {
|
||||
matrix_row_t state = 0;
|
||||
matrix_col_t mask = (matrix_col_t)1 << row;
|
||||
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
|
||||
if (matrix[c] & mask) {
|
||||
state |= (matrix_row_t)1 << c;
|
||||
}
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
bool matrix_is_modified(void) {
|
||||
if (debouncing_delay >= 0) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool matrix_is_on(uint8_t row, uint8_t col) {
|
||||
return matrix_get_row(row) & (matrix_row_t)1 << col;
|
||||
}
|
||||
|
||||
void matrix_print(void) {
|
||||
dprintln("Human-readable matrix state:");
|
||||
for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
|
||||
dprintf("State of row %X: %016b\n", r, bitrev16(matrix_get_row(r)));
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t matrix_key_count(void)
|
||||
{
|
||||
uint8_t matrix_key_count(void) {
|
||||
uint8_t count = 0;
|
||||
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
|
||||
count += bitpop16(matrix[i]);
|
||||
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
|
||||
count += bitpop16(matrix_get_row(r));
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
static void init_cols(void)
|
||||
{
|
||||
int B = 0, C = 0, D = 0, E = 0, F = 0;
|
||||
|
||||
#if DIODE_DIRECTION == COL2ROW
|
||||
for(int x = 0; x < MATRIX_COLS; x++) {
|
||||
int col = COLS[x];
|
||||
#else
|
||||
for(int x = 0; x < MATRIX_ROWS; x++) {
|
||||
int col = ROWS[x];
|
||||
#endif
|
||||
if ((col & 0xF0) == 0x20) {
|
||||
B |= (1<<(col & 0x0F));
|
||||
} else if ((col & 0xF0) == 0x30) {
|
||||
C |= (1<<(col & 0x0F));
|
||||
} else if ((col & 0xF0) == 0x40) {
|
||||
D |= (1<<(col & 0x0F));
|
||||
} else if ((col & 0xF0) == 0x50) {
|
||||
E |= (1<<(col & 0x0F));
|
||||
} else if ((col & 0xF0) == 0x60) {
|
||||
F |= (1<<(col & 0x0F));
|
||||
}
|
||||
}
|
||||
DDRB &= ~(B); PORTB |= (B);
|
||||
DDRC &= ~(C); PORTC |= (C);
|
||||
DDRD &= ~(D); PORTD |= (D);
|
||||
DDRE &= ~(E); PORTE |= (E);
|
||||
DDRF &= ~(F); PORTF |= (F);
|
||||
}
|
||||
|
||||
static matrix_row_t read_cols(void)
|
||||
{
|
||||
matrix_row_t result = 0;
|
||||
|
||||
#if DIODE_DIRECTION == COL2ROW
|
||||
for(int x = 0; x < MATRIX_COLS; x++) {
|
||||
int col = COLS[x];
|
||||
#else
|
||||
for(int x = 0; x < MATRIX_ROWS; x++) {
|
||||
int col = ROWS[x];
|
||||
#endif
|
||||
|
||||
if ((col & 0xF0) == 0x20) {
|
||||
result |= (PINB&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x));
|
||||
} else if ((col & 0xF0) == 0x30) {
|
||||
result |= (PINC&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x));
|
||||
} else if ((col & 0xF0) == 0x40) {
|
||||
result |= (PIND&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x));
|
||||
} else if ((col & 0xF0) == 0x50) {
|
||||
result |= (PINE&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x));
|
||||
} else if ((col & 0xF0) == 0x60) {
|
||||
result |= (PINF&(1<<(col & 0x0F)) ? 0 : (SHIFTER<<x));
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
static void unselect_rows(void)
|
||||
{
|
||||
int B = 0, C = 0, D = 0, E = 0, F = 0;
|
||||
|
||||
#if DIODE_DIRECTION == COL2ROW
|
||||
for(int x = 0; x < MATRIX_ROWS; x++) {
|
||||
int row = ROWS[x];
|
||||
#else
|
||||
for(int x = 0; x < MATRIX_COLS; x++) {
|
||||
int row = COLS[x];
|
||||
#endif
|
||||
if ((row & 0xF0) == 0x20) {
|
||||
B |= (1<<(row & 0x0F));
|
||||
} else if ((row & 0xF0) == 0x30) {
|
||||
C |= (1<<(row & 0x0F));
|
||||
} else if ((row & 0xF0) == 0x40) {
|
||||
D |= (1<<(row & 0x0F));
|
||||
} else if ((row & 0xF0) == 0x50) {
|
||||
E |= (1<<(row & 0x0F));
|
||||
} else if ((row & 0xF0) == 0x60) {
|
||||
F |= (1<<(row & 0x0F));
|
||||
}
|
||||
}
|
||||
DDRB &= ~(B); PORTB |= (B);
|
||||
DDRC &= ~(C); PORTC |= (C);
|
||||
DDRD &= ~(D); PORTD |= (D);
|
||||
DDRE &= ~(E); PORTE |= (E);
|
||||
DDRF &= ~(F); PORTF |= (F);
|
||||
}
|
||||
|
||||
static void select_row(uint8_t row)
|
||||
{
|
||||
|
||||
#if DIODE_DIRECTION == COL2ROW
|
||||
int row_pin = ROWS[row];
|
||||
#else
|
||||
int row_pin = COLS[row];
|
||||
#endif
|
||||
|
||||
if ((row_pin & 0xF0) == 0x20) {
|
||||
DDRB |= (1<<(row_pin & 0x0F));
|
||||
PORTB &= ~(1<<(row_pin & 0x0F));
|
||||
} else if ((row_pin & 0xF0) == 0x30) {
|
||||
DDRC |= (1<<(row_pin & 0x0F));
|
||||
PORTC &= ~(1<<(row_pin & 0x0F));
|
||||
} else if ((row_pin & 0xF0) == 0x40) {
|
||||
DDRD |= (1<<(row_pin & 0x0F));
|
||||
PORTD &= ~(1<<(row_pin & 0x0F));
|
||||
} else if ((row_pin & 0xF0) == 0x50) {
|
||||
DDRE |= (1<<(row_pin & 0x0F));
|
||||
PORTE &= ~(1<<(row_pin & 0x0F));
|
||||
} else if ((row_pin & 0xF0) == 0x60) {
|
||||
DDRF |= (1<<(row_pin & 0x0F));
|
||||
PORTF &= ~(1<<(row_pin & 0x0F));
|
||||
}
|
||||
}
|
||||
@ -42,14 +42,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
* ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
|
||||
*
|
||||
*/
|
||||
#define COLS (int []){ F1, F0, B0 }
|
||||
#define ROWS (int []){ D0, D5 }
|
||||
#define MATRIX_ROW_PINS { D0, D5 }
|
||||
#define MATRIX_COL_PINS { F1, F0, B0 }
|
||||
#define UNUSED_PINS
|
||||
|
||||
/* COL2ROW or ROW2COL */
|
||||
#define DIODE_DIRECTION COL2ROW
|
||||
|
||||
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
|
||||
#define DEBOUNCE 5
|
||||
#define DEBOUNCING_DELAY 5
|
||||
|
||||
/* define if matrix has ghost (lacks anti-ghosting diodes) */
|
||||
//#define MATRIX_HAS_GHOST
|
||||
|
||||
@ -114,9 +114,7 @@ bool suspend_wakeup_condition(void)
|
||||
matrix_power_up();
|
||||
matrix_scan();
|
||||
matrix_power_down();
|
||||
for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
|
||||
if (matrix_get_row(r)) return true;
|
||||
}
|
||||
if (matrix_key_count()) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -146,4 +144,3 @@ ISR(WDT_vect)
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
@ -105,15 +105,13 @@ void bootmagic(void)
|
||||
}
|
||||
}
|
||||
|
||||
static bool scan_keycode(uint8_t keycode)
|
||||
{
|
||||
for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
|
||||
static bool scan_keycode(uint8_t keycode) {
|
||||
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
|
||||
matrix_row_t matrix_row = matrix_get_row(r);
|
||||
for (uint8_t c = 0; c < MATRIX_COLS; c++) {
|
||||
if (matrix_row & ((matrix_row_t)1<<c)) {
|
||||
if (keycode == keymap_key_to_keycode(0, (keypos_t){ .row = r, .col = c })) {
|
||||
return true;
|
||||
}
|
||||
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
|
||||
if (matrix_row & (matrix_row_t)1 << c) {
|
||||
keypos_t key = (keypos_t){ .row = r, .col = c };
|
||||
if (keycode == keymap_key_to_keycode(0, key)) return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
Copyright 2011,2012,2013 Jun Wako <wakojun@gmail.com>
|
||||
Copyright 2011, 2012, 2013 Jun Wako <wakojun@gmail.com>
|
||||
|
||||
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
|
||||
@ -27,13 +27,13 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#include "command.h"
|
||||
#include "util.h"
|
||||
#include "sendchar.h"
|
||||
#ifdef BOOTMAGIC_ENABLE
|
||||
#include "bootmagic.h"
|
||||
#else
|
||||
#include "magic.h"
|
||||
#endif
|
||||
#include "eeconfig.h"
|
||||
#include "backlight.h"
|
||||
#ifdef BOOTMAGIC_ENABLE
|
||||
# include "bootmagic.h"
|
||||
#else
|
||||
# include "magic.h"
|
||||
#endif
|
||||
#ifdef MOUSEKEY_ENABLE
|
||||
# include "mousekey.h"
|
||||
#endif
|
||||
@ -41,40 +41,35 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
# include "ps2_mouse.h"
|
||||
#endif
|
||||
#ifdef SERIAL_MOUSE_ENABLE
|
||||
#include "serial_mouse.h"
|
||||
# include "serial_mouse.h"
|
||||
#endif
|
||||
#ifdef ADB_MOUSE_ENABLE
|
||||
#include "adb.h"
|
||||
# include "adb.h"
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef MATRIX_HAS_GHOST
|
||||
static bool has_ghost_in_row(uint8_t row)
|
||||
{
|
||||
matrix_row_t matrix_row = matrix_get_row(row);
|
||||
// No ghost exists when less than 2 keys are down on the row
|
||||
if (((matrix_row - 1) & matrix_row) == 0)
|
||||
return false;
|
||||
|
||||
// Ghost occurs when the row shares column line with other row
|
||||
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
|
||||
if (i != row && (matrix_get_row(i) & matrix_row))
|
||||
return true;
|
||||
static bool is_row_ghosting(uint8_t row){
|
||||
matrix_row_t state = matrix_get_row(row);
|
||||
/* no ghosting happens when only one key in the row is pressed */
|
||||
if (!(state - 1 & state)) return false;
|
||||
/* ghosting occurs when two keys in the same column are pressed */
|
||||
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
|
||||
if (r != row && matrix_get_row(r) & state) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
__attribute__ ((weak))
|
||||
void matrix_setup(void) {
|
||||
}
|
||||
|
||||
__attribute__ ((weak)) void matrix_setup(void) {}
|
||||
void keyboard_setup(void)
|
||||
{
|
||||
void keyboard_setup(void) {
|
||||
matrix_setup();
|
||||
}
|
||||
|
||||
void keyboard_init(void)
|
||||
{
|
||||
|
||||
void keyboard_init(void) {
|
||||
timer_init();
|
||||
matrix_init();
|
||||
#ifdef PS2_MOUSE_ENABLE
|
||||
@ -86,104 +81,87 @@ void keyboard_init(void)
|
||||
#ifdef ADB_MOUSE_ENABLE
|
||||
adb_mouse_init();
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef BOOTMAGIC_ENABLE
|
||||
bootmagic();
|
||||
#else
|
||||
magic();
|
||||
#endif
|
||||
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
backlight_init();
|
||||
#endif
|
||||
|
||||
#if defined(NKRO_ENABLE) && defined(FORCE_NKRO)
|
||||
keyboard_nkro = true;
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
* Do keyboard routine jobs: scan mantrix, light LEDs, ...
|
||||
* This is repeatedly called as fast as possible.
|
||||
*/
|
||||
void keyboard_task(void)
|
||||
{
|
||||
static matrix_row_t matrix_prev[MATRIX_ROWS];
|
||||
/* does routine keyboard jobs */
|
||||
void keyboard_task(void) {
|
||||
static matrix_row_t previous_matrix[MATRIX_ROWS];
|
||||
#ifdef MATRIX_HAS_GHOST
|
||||
static matrix_row_t matrix_ghost[MATRIX_ROWS];
|
||||
static matrix_row_t deghosting_matrix[MATRIX_ROWS];
|
||||
#endif
|
||||
static uint8_t led_status = 0;
|
||||
matrix_row_t matrix_row = 0;
|
||||
matrix_row_t matrix_change = 0;
|
||||
|
||||
matrix_scan();
|
||||
for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
|
||||
matrix_row = matrix_get_row(r);
|
||||
matrix_change = matrix_row ^ matrix_prev[r];
|
||||
if (matrix_change) {
|
||||
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
|
||||
matrix_row_t state = matrix_get_row(r);
|
||||
matrix_row_t changes = state ^ previous_matrix[r];
|
||||
if (changes) {
|
||||
#ifdef MATRIX_HAS_GHOST
|
||||
if (has_ghost_in_row(r)) {
|
||||
/* Keep track of whether ghosted status has changed for
|
||||
* debugging. But don't update matrix_prev until un-ghosted, or
|
||||
* the last key would be lost.
|
||||
if (is_row_ghosting(r)) {
|
||||
/* debugs the deghosting mechanism */
|
||||
/* doesn't update previous_matrix until the ghosting has stopped
|
||||
* in order to prevent the last key from being lost
|
||||
*/
|
||||
if (debug_matrix && matrix_ghost[r] != matrix_row) {
|
||||
if (debug_matrix && deghosting_matrix[r] != state) {
|
||||
matrix_print();
|
||||
}
|
||||
matrix_ghost[r] = matrix_row;
|
||||
deghosting_matrix[r] = state;
|
||||
continue;
|
||||
}
|
||||
matrix_ghost[r] = matrix_row;
|
||||
deghosting_matrix[r] = state;
|
||||
#endif
|
||||
if (debug_matrix) matrix_print();
|
||||
for (uint8_t c = 0; c < MATRIX_COLS; c++) {
|
||||
if (matrix_change & ((matrix_row_t)1<<c)) {
|
||||
action_exec((keyevent_t){
|
||||
.key = (keypos_t){ .row = r, .col = c },
|
||||
.pressed = (matrix_row & ((matrix_row_t)1<<c)),
|
||||
.time = (timer_read() | 1) /* time should not be 0 */
|
||||
});
|
||||
// record a processed key
|
||||
matrix_prev[r] ^= ((matrix_row_t)1<<c);
|
||||
// process a key per task call
|
||||
goto MATRIX_LOOP_END;
|
||||
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
|
||||
matrix_row_t mask = (matrix_row_t)1 << c;
|
||||
if (changes & mask) {
|
||||
keyevent_t event;
|
||||
event.key = (keypos_t){ .row = r, .col = c };
|
||||
event.pressed = state & mask;
|
||||
/* the time should not be 0 */
|
||||
event.time = timer_read() | 1;
|
||||
action_exec(event);
|
||||
/* records the processed key event */
|
||||
previous_matrix[r] ^= mask;
|
||||
/* processes one key event per call */
|
||||
goto event_processed;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// call with pseudo tick event when no real key event.
|
||||
/* sends tick events when the keyboard is idle */
|
||||
action_exec(TICK);
|
||||
|
||||
MATRIX_LOOP_END:
|
||||
|
||||
event_processed:
|
||||
#ifdef MOUSEKEY_ENABLE
|
||||
// mousekey repeat & acceleration
|
||||
/* repeats and accelerates the mouse keys */
|
||||
mousekey_task();
|
||||
#endif
|
||||
|
||||
#ifdef PS2_MOUSE_ENABLE
|
||||
ps2_mouse_task();
|
||||
#endif
|
||||
|
||||
#ifdef SERIAL_MOUSE_ENABLE
|
||||
serial_mouse_task();
|
||||
#endif
|
||||
|
||||
#ifdef ADB_MOUSE_ENABLE
|
||||
adb_mouse_task();
|
||||
#endif
|
||||
|
||||
// update LED
|
||||
/* updates the LEDs */
|
||||
if (led_status != host_keyboard_leds()) {
|
||||
led_status = host_keyboard_leds();
|
||||
keyboard_set_leds(led_status);
|
||||
}
|
||||
}
|
||||
|
||||
void keyboard_set_leds(uint8_t leds)
|
||||
{
|
||||
if (debug_keyboard) { debug("keyboard_set_led: "); debug_hex8(leds); debug("\n"); }
|
||||
void keyboard_set_leds(uint8_t leds) {
|
||||
if (debug_keyboard) dprintf("Keyboard LEDs state: %x\n", leds);
|
||||
led_set(leds);
|
||||
}
|
||||
|
||||
@ -14,59 +14,68 @@ 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/>.
|
||||
*/
|
||||
|
||||
#ifndef MATRIX_H
|
||||
#define MATRIX_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
|
||||
#if (MATRIX_COLS <= 8)
|
||||
#if MATRIX_COLS <= 8
|
||||
typedef uint8_t matrix_row_t;
|
||||
#elif (MATRIX_COLS <= 16)
|
||||
#elif MATRIX_COLS <= 16
|
||||
typedef uint16_t matrix_row_t;
|
||||
#elif (MATRIX_COLS <= 32)
|
||||
#elif MATRIX_COLS <= 32
|
||||
typedef uint32_t matrix_row_t;
|
||||
#else
|
||||
#error "MATRIX_COLS: invalid value"
|
||||
# error "There are too many columns."
|
||||
#endif
|
||||
|
||||
#define MATRIX_IS_ON(row, col) (matrix_get_row(row) && (1<<col))
|
||||
#if DIODE_DIRECTION == ROW2COL
|
||||
# if MATRIX_ROWS <= 8
|
||||
typedef uint8_t matrix_col_t;
|
||||
# elif MATRIX_ROWS <= 16
|
||||
typedef uint16_t matrix_col_t;
|
||||
# elif MATRIX_ROWS <= 32
|
||||
typedef uint32_t matrix_col_t;
|
||||
# else
|
||||
# error "There are too many rows."
|
||||
# endif
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
uint8_t input_addr:4;
|
||||
uint8_t bit:4;
|
||||
} io_pin_t;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* number of matrix rows */
|
||||
/* counts the number of rows in the matrix */
|
||||
uint8_t matrix_rows(void);
|
||||
/* number of matrix columns */
|
||||
/* counts the number of columns in the matrix */
|
||||
uint8_t matrix_cols(void);
|
||||
/* should be called at early stage of startup before matrix_init.(optional) */
|
||||
/* sets up the matrix before matrix_init */
|
||||
void matrix_setup(void);
|
||||
/* intialize matrix for scaning. */
|
||||
/* intializes the matrix */
|
||||
void matrix_init(void);
|
||||
/* scan all key states on matrix */
|
||||
/* scans the entire matrix */
|
||||
uint8_t matrix_scan(void);
|
||||
/* whether modified from previous scan. used after matrix_scan. */
|
||||
/* checks if the matrix has been modified */
|
||||
bool matrix_is_modified(void) __attribute__ ((deprecated));
|
||||
/* whether a swtich is on */
|
||||
/* checks if a key is pressed */
|
||||
bool matrix_is_on(uint8_t row, uint8_t col);
|
||||
/* matrix state on row */
|
||||
/* inspects the state of a row in the matrix */
|
||||
matrix_row_t matrix_get_row(uint8_t row);
|
||||
/* print matrix for debug */
|
||||
/* prints the matrix for debugging */
|
||||
void matrix_print(void);
|
||||
|
||||
|
||||
/* power control */
|
||||
/* counts the total number of keys pressed */
|
||||
uint8_t matrix_key_count(void);
|
||||
/* controls power to the matrix */
|
||||
void matrix_power_up(void);
|
||||
void matrix_power_down(void);
|
||||
|
||||
/* keyboard-specific setup/loop functionality */
|
||||
/* executes code for Quantum */
|
||||
void matrix_init_quantum(void);
|
||||
void matrix_scan_quantum(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
Loading…
Reference in New Issue
Block a user