Nulo/qmk_firmware
1
0
Fork 0
Code Releases Activity

Merge remote-tracking branch 'jackhumbert/master' into patch-1

Browse source
This commit is contained in:
Josh Colbeck 2016-07-04 15:41:58 -05:00
commit a5fb2b58a5
8 changed files with 278 additions and 240 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
doc/keycode.txt
View file

@ -92,7 +92,7 @@ KC_LEFT 50 Keyboard LeftArrow1
KC_DOWN 51 Keyboard DownArrow1 KC_DOWN 51 Keyboard DownArrow1
KC_UP 52 Keyboard UpArrow1 KC_UP 52 Keyboard UpArrow1
KC_NUMLOCK KC_NLCK 53 Keypad Num Lock and Clear11 KC_NUMLOCK KC_NLCK 53 Keypad Num Lock and Clear11
KC_KP_SLASH KC_PSLS 54 Keypad /1 KC_KP_SLASH KC_PSLS 54 Keypad /
KC_KP_ASTERISK KC_PAST 55 Keypad * KC_KP_ASTERISK KC_PAST 55 Keypad *
KC_KP_MINUS KC_PMNS 56 Keypad - KC_KP_MINUS KC_PMNS 56 Keypad -
KC_KP_PLUS KC_PPLS 57 Keypad + KC_KP_PLUS KC_PPLS 57 Keypad +

10
keyboards/ergodox_ez/config.h
View file

@ -27,7 +27,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define DEVICE_VER 0x0001 #define DEVICE_VER 0x0001
#define MANUFACTURER ErgoDox EZ #define MANUFACTURER ErgoDox EZ
#define PRODUCT ErgoDox EZ #define PRODUCT ErgoDox EZ
#define DESCRIPTION t.m.k. keyboard firmware for Ergodox #define DESCRIPTION QMK keyboard firmware for Ergodox EZ
/* key matrix size */ /* key matrix size */
#define MATRIX_ROWS 14 #define MATRIX_ROWS 14
@ -40,12 +40,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define TAPPING_TOGGLE 1 #define TAPPING_TOGGLE 1
#define COLS (int []){ F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }
#define ROWS (int []){ D0, D5, B5, B6 }
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
/* define if matrix has ghost */ /* define if matrix has ghost */
//#define MATRIX_HAS_GHOST //#define MATRIX_HAS_GHOST
@ -53,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define BACKLIGHT_LEVELS 3 #define BACKLIGHT_LEVELS 3
/* Set 0 if debouncing isn't needed */ /* Set 0 if debouncing isn't needed */
#define DEBOUNCE 2 #define DEBOUNCE 5
#define TAPPING_TERM 200 #define TAPPING_TERM 200
#define IGNORE_MOD_TAP_INTERRUPT // this makes it possible to do rolling combos (zx) with keys that convert to other keys on hold (z becomes ctrl when you hold it, and when this option isn't enabled, z rapidly followed by x actually sends Ctrl-x. That's bad.) #define IGNORE_MOD_TAP_INTERRUPT // this makes it possible to do rolling combos (zx) with keys that convert to other keys on hold (z becomes ctrl when you hold it, and when this option isn't enabled, z rapidly followed by x actually sends Ctrl-x. That's bad.)

6
keyboards/ergodox_ez/matrix.c
View file

@ -27,7 +27,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <avr/io.h> #include <avr/io.h>
#include <util/delay.h> #include "wait.h"
#include "action_layer.h" #include "action_layer.h"
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
@ -166,6 +166,7 @@ uint8_t matrix_scan(void)
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select_row(i); select_row(i);
wait_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols(i); matrix_row_t cols = read_cols(i);
if (matrix_debouncing[i] != cols) { if (matrix_debouncing[i] != cols) {
matrix_debouncing[i] = cols; matrix_debouncing[i] = cols;
@ -179,7 +180,7 @@ uint8_t matrix_scan(void)
if (debouncing) { if (debouncing) {
if (--debouncing) { if (--debouncing) {
_delay_ms(1); wait_us(1);
} else { } else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i]; matrix[i] = matrix_debouncing[i];
@ -267,7 +268,6 @@ static matrix_row_t read_cols(uint8_t row)
return data; return data;
} }
} else { } else {
_delay_us(30); // without this wait read unstable value.
// read from teensy // read from teensy
return return
(PINF&(1<<0) ? 0 : (1<<0)) | (PINF&(1<<0) ? 0 : (1<<0)) |

302
quantum/matrix.c
View file

@ -26,32 +26,46 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "util.h" #include "util.h"
#include "matrix.h" #include "matrix.h"
#ifdef MATRIX_HAS_GHOST /* Set 0 if debouncing isn't needed */
# error "The universal matrix.c file cannot be used for this keyboard." /*
#endif * This constant define not debouncing time in msecs, but amount of matrix
* scan loops which should be made to get stable debounced results.
*
* On Ergodox matrix scan rate is relatively low, because of slow I2C.
* Now it's only 317 scans/second, or about 3.15 msec/scan.
* According to Cherry specs, debouncing time is 5 msec.
*
* And so, there is no sense to have DEBOUNCE higher than 2.
*/
#ifndef DEBOUNCING_DELAY #ifndef DEBOUNCING_DELAY
# define DEBOUNCING_DELAY 5 # define DEBOUNCING_DELAY 5
#endif #endif
static uint8_t debouncing = DEBOUNCING_DELAY;
static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
/* matrix state */
#if DIODE_DIRECTION == COL2ROW
static matrix_row_t matrix[MATRIX_ROWS];
#else
static matrix_col_t matrix[MATRIX_COLS];
#endif
static int8_t debouncing_delay = -1;
#if DIODE_DIRECTION == COL2ROW /* matrix state(1:on, 0:off) */
static void toggle_row(uint8_t row); static matrix_row_t matrix[MATRIX_ROWS];
static matrix_row_t read_cols(void); static matrix_row_t matrix_debouncing[MATRIX_ROWS];
#else
static void toggle_col(uint8_t col); #if DIODE_DIRECTION == ROW2COL
static matrix_col_t read_rows(void); static matrix_row_t matrix_reversed[MATRIX_COLS];
static matrix_row_t matrix_reversed_debouncing[MATRIX_COLS];
#endif #endif
#if MATRIX_COLS > 16
#define SHIFTER 1UL
#else
#define SHIFTER 1
#endif
static matrix_row_t read_cols(void);
static void init_cols(void);
static void unselect_rows(void);
static void select_row(uint8_t row);
__attribute__ ((weak)) __attribute__ ((weak))
void matrix_init_quantum(void) { void matrix_init_quantum(void) {
matrix_init_kb(); matrix_init_kb();
@ -80,10 +94,12 @@ __attribute__ ((weak))
void matrix_scan_user(void) { void matrix_scan_user(void) {
} }
inline
uint8_t matrix_rows(void) { uint8_t matrix_rows(void) {
return MATRIX_ROWS; return MATRIX_ROWS;
} }
inline
uint8_t matrix_cols(void) { uint8_t matrix_cols(void) {
return MATRIX_COLS; return MATRIX_COLS;
} }
@ -113,161 +129,179 @@ uint8_t matrix_cols(void) {
// } // }
void matrix_init(void) { void matrix_init(void) {
/* frees PORTF by setting the JTD bit twice within four cycles */ // To use PORTF disable JTAG with writing JTD bit twice within four cycles.
#ifdef __AVR_ATmega32U4__ #ifdef __AVR_ATmega32U4__
MCUCR |= _BV(JTD); MCUCR |= _BV(JTD);
MCUCR |= _BV(JTD); MCUCR |= _BV(JTD);
#endif #endif
/* initializes the I/O pins */
#if DIODE_DIRECTION == COL2ROW // initialize row and col
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) { unselect_rows();
/* DDRxn */ init_cols();
_SFR_IO8((row_pins[r] >> 4) + 1) |= _BV(row_pins[r] & 0xF);
toggle_row(r); // initialize matrix state: all keys off
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
matrix[i] = 0;
matrix_debouncing[i] = 0;
} }
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
/* PORTxn */
_SFR_IO8((col_pins[c] >> 4) + 2) |= _BV(col_pins[c] & 0xF);
}
#else
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
/* DDRxn */
_SFR_IO8((col_pins[c] >> 4) + 1) |= _BV(col_pins[c] & 0xF);
toggle_col(c);
}
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
/* PORTxn */
_SFR_IO8((row_pins[r] >> 4) + 2) |= _BV(row_pins[r] & 0xF);
}
#endif
matrix_init_quantum(); matrix_init_quantum();
} }
uint8_t matrix_scan(void)
{
#if DIODE_DIRECTION == COL2ROW #if DIODE_DIRECTION == COL2ROW
uint8_t matrix_scan(void) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
static matrix_row_t debouncing_matrix[MATRIX_ROWS]; select_row(i);
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) { wait_us(30); // without this wait read unstable value.
toggle_row(r); matrix_row_t cols = read_cols();
matrix_row_t state = read_cols(); if (matrix_debouncing[i] != cols) {
if (debouncing_matrix[r] != state) { matrix_debouncing[i] = cols;
debouncing_matrix[r] = state; if (debouncing) {
debouncing_delay = DEBOUNCING_DELAY; debug("bounce!: "); debug_hex(debouncing); debug("\n");
} }
toggle_row(r); debouncing = DEBOUNCING_DELAY;
} }
if (debouncing_delay >= 0) { unselect_rows();
dprintf("Debouncing delay remaining: %X\n", debouncing_delay);
--debouncing_delay;
if (debouncing_delay >= 0) {
wait_ms(1);
}
else {
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
matrix[r] = debouncing_matrix[r];
}
}
}
matrix_scan_quantum();
return 1;
} }
static void toggle_row(uint8_t row) { if (debouncing) {
/* PINxn */ if (--debouncing) {
_SFR_IO8((row_pins[row] >> 4)) = _BV(row_pins[row] & 0xF); wait_us(1);
} } else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
static matrix_row_t read_cols(void) { matrix[i] = matrix_debouncing[i];
matrix_row_t state = 0;
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
/* PINxn */
if (!(_SFR_IO8((col_pins[c] >> 4)) & _BV(col_pins[c] & 0xF))) {
state |= (matrix_row_t)1 << c;
} }
} }
return state;
} }
matrix_row_t matrix_get_row(uint8_t row) {
return matrix[row];
}
#else #else
uint8_t matrix_scan(void) { for (uint8_t i = 0; i < MATRIX_COLS; i++) {
static matrix_col_t debouncing_matrix[MATRIX_COLS]; select_row(i);
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) { wait_us(30); // without this wait read unstable value.
toggle_col(c); matrix_row_t rows = read_cols();
matrix_col_t state = read_rows(); if (matrix_reversed_debouncing[i] != rows) {
if (debouncing_matrix[c] != state) { matrix_reversed_debouncing[i] = rows;
debouncing_matrix[c] = state; if (debouncing) {
debouncing_delay = DEBOUNCING_DELAY; debug("bounce!: "); debug_hex(debouncing); debug("\n");
} }
toggle_col(c); debouncing = DEBOUNCING_DELAY;
} }
if (debouncing_delay >= 0) { unselect_rows();
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) { if (debouncing) {
/* PINxn */ if (--debouncing) {
_SFR_IO8((col_pins[col] >> 4)) = _BV(col_pins[col] & 0xF); wait_us(1);
} } else {
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
static matrix_col_t read_rows(void) { matrix_reversed[i] = matrix_reversed_debouncing[i];
matrix_col_t state = 0;
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
/* PINxn */
if (!(_SFR_IO8((row_pins[r] >> 4)) & _BV(row_pins[r] & 0xF))) {
state |= (matrix_col_t)1 << r;
} }
} }
return state;
} }
for (uint8_t y = 0; y < MATRIX_ROWS; y++) {
matrix_row_t matrix_get_row(uint8_t row) { matrix_row_t row = 0;
matrix_row_t state = 0; for (uint8_t x = 0; x < MATRIX_COLS; x++) {
matrix_col_t mask = (matrix_col_t)1 << row; row |= ((matrix_reversed[x] & (1<<y)) >> y) << x;
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) {
if (matrix[c] & mask) {
state |= (matrix_row_t)1 << c;
} }
matrix[y] = row;
} }
return state;
}
#endif #endif
bool matrix_is_modified(void) { matrix_scan_quantum();
if (debouncing_delay >= 0) return false;
return 1;
}
bool matrix_is_modified(void)
{
if (debouncing) return false;
return true; return true;
} }
bool matrix_is_on(uint8_t row, uint8_t col) { inline
return matrix_get_row(row) & (matrix_row_t)1 << col; bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<col));
} }
void matrix_print(void) { inline
dprintln("Human-readable matrix state:"); matrix_row_t matrix_get_row(uint8_t row)
for (uint8_t r = 0; r < MATRIX_ROWS; r++) { {
dprintf("State of row %X: %016b\n", r, bitrev16(matrix_get_row(r))); 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");
} }
} }
uint8_t matrix_key_count(void) { uint8_t matrix_key_count(void)
{
uint8_t count = 0; uint8_t count = 0;
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop16(matrix_get_row(r)); count += bitpop16(matrix[i]);
} }
return count; return count;
} }
static void init_cols(void)
{
#if DIODE_DIRECTION == COL2ROW
for(int x = 0; x < MATRIX_COLS; x++) {
int pin = col_pins[x];
#else
for(int x = 0; x < MATRIX_ROWS; x++) {
int pin = row_pins[x];
#endif
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF);
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF);
}
}
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 pin = col_pins[x];
#else
for(int x = 0; x < MATRIX_ROWS; x++) {
int pin = row_pins[x];
#endif
result |= (_SFR_IO8(pin >> 4) & _BV(pin & 0xF)) ? 0 : (SHIFTER << x);
}
return result;
}
static void unselect_rows(void)
{
#if DIODE_DIRECTION == COL2ROW
for(int x = 0; x < MATRIX_ROWS; x++) {
int pin = row_pins[x];
#else
for(int x = 0; x < MATRIX_COLS; x++) {
int pin = col_pins[x];
#endif
_SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF);
_SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF);
}
}
static void select_row(uint8_t row)
{
#if DIODE_DIRECTION == COL2ROW
int pin = row_pins[row];
#else
int pin = col_pins[row];
#endif
_SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF);
_SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF);
}

4
tmk_core/common/avr/suspend.c
View file

@ -114,7 +114,9 @@ bool suspend_wakeup_condition(void)
matrix_power_up(); matrix_power_up();
matrix_scan(); matrix_scan();
matrix_power_down(); matrix_power_down();
if (matrix_key_count()) return true; for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
if (matrix_get_row(r)) return true;
}
return false; return false;
} }

14
tmk_core/common/bootmagic.c
View file

@ -106,13 +106,15 @@ void bootmagic(void)
} }
} }
static bool scan_keycode(uint8_t keycode) { static bool scan_keycode(uint8_t keycode)
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) { {
for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
matrix_row_t matrix_row = matrix_get_row(r); matrix_row_t matrix_row = matrix_get_row(r);
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) { for (uint8_t c = 0; c < MATRIX_COLS; c++) {
if (matrix_row & (matrix_row_t)1 << 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, (keypos_t){ .row = r, .col = c })) {
if (keycode == keymap_key_to_keycode(0, key)) return true; return true;
}
} }
} }
} }

107
tmk_core/common/keyboard.c
View file

@ -51,17 +51,20 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#endif #endif
#ifdef MATRIX_HAS_GHOST #ifdef MATRIX_HAS_GHOST
static bool is_row_ghosting(uint8_t row){ static bool has_ghost_in_row(uint8_t row)
matrix_row_t state = matrix_get_row(row); {
/* no ghosting happens when only one key in the row is pressed */ matrix_row_t matrix_row = matrix_get_row(row);
if (!(state - 1 & state)) return false; // No ghost exists when less than 2 keys are down on the row
/* ghosting occurs when two keys in the same column are pressed */ if (((matrix_row - 1) & matrix_row) == 0)
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) { return false;
if (r != row && matrix_get_row(r) & state) return true;
// 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;
} }
return false; return false;
} }
#endif #endif
__attribute__ ((weak)) __attribute__ ((weak))
@ -100,72 +103,86 @@ void keyboard_init(void) {
#endif #endif
} }
/* does routine keyboard jobs */ /*
void keyboard_task(void) { * Do keyboard routine jobs: scan mantrix, light LEDs, ...
static uint8_t led_status; * This is repeatedly called as fast as possible.
matrix_scan();
for (int8_t r = MATRIX_ROWS - 1; r >= 0; --r) {
static matrix_row_t previous_matrix[MATRIX_ROWS];
matrix_row_t state = matrix_get_row(r);
matrix_row_t changes = state ^ previous_matrix[r];
if (changes) {
#ifdef MATRIX_HAS_GHOST
static matrix_row_t deghosting_matrix[MATRIX_ROWS];
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 && deghosting_matrix[r] != state) { void keyboard_task(void)
{
static matrix_row_t matrix_prev[MATRIX_ROWS];
#ifdef MATRIX_HAS_GHOST
static matrix_row_t matrix_ghost[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) {
#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 (debug_matrix && matrix_ghost[r] != matrix_row) {
matrix_print(); matrix_print();
} }
deghosting_matrix[r] = state; matrix_ghost[r] = matrix_row;
continue; continue;
} }
deghosting_matrix[r] = state; matrix_ghost[r] = matrix_row;
#endif #endif
if (debug_matrix) matrix_print(); if (debug_matrix) matrix_print();
for (int8_t c = MATRIX_COLS - 1; c >= 0; --c) { for (uint8_t c = 0; c < MATRIX_COLS; c++) {
matrix_row_t mask = (matrix_row_t)1 << c; if (matrix_change & ((matrix_row_t)1<<c)) {
if (changes & mask) { action_exec((keyevent_t){
keyevent_t event; .key = (keypos_t){ .row = r, .col = c },
event.key = (keypos_t){ .row = r, .col = c }; .pressed = (matrix_row & ((matrix_row_t)1<<c)),
event.pressed = state & mask; .time = (timer_read() | 1) /* time should not be 0 */
/* the time should not be 0 */ });
event.time = timer_read() | 1; // record a processed key
action_exec(event); matrix_prev[r] ^= ((matrix_row_t)1<<c);
/* records the processed key event */ // process a key per task call
previous_matrix[r] ^= mask; goto MATRIX_LOOP_END;
/* processes one key event per call */
goto event_processed;
} }
} }
} }
} }
/* sends tick events when the keyboard is idle */ // call with pseudo tick event when no real key event.
action_exec(TICK); action_exec(TICK);
event_processed:
MATRIX_LOOP_END:
#ifdef MOUSEKEY_ENABLE #ifdef MOUSEKEY_ENABLE
/* repeats and accelerates the mouse keys */ // mousekey repeat & acceleration
mousekey_task(); mousekey_task();
#endif #endif
#ifdef PS2_MOUSE_ENABLE #ifdef PS2_MOUSE_ENABLE
ps2_mouse_task(); ps2_mouse_task();
#endif #endif
#ifdef SERIAL_MOUSE_ENABLE #ifdef SERIAL_MOUSE_ENABLE
serial_mouse_task(); serial_mouse_task();
#endif #endif
#ifdef ADB_MOUSE_ENABLE #ifdef ADB_MOUSE_ENABLE
adb_mouse_task(); adb_mouse_task();
#endif #endif
/* updates the LEDs */
// update LED
if (led_status != host_keyboard_leds()) { if (led_status != host_keyboard_leds()) {
led_status = host_keyboard_leds(); led_status = host_keyboard_leds();
keyboard_set_leds(led_status); keyboard_set_leds(led_status);
} }
} }
void keyboard_set_leds(uint8_t leds) { void keyboard_set_leds(uint8_t leds)
if (debug_keyboard) dprintf("Keyboard LEDs state: %x\n", leds); {
if (debug_keyboard) { debug("keyboard_set_led: "); debug_hex8(leds); debug("\n"); }
led_set(leds); led_set(leds);
} }

51
tmk_core/common/matrix.h
View file

@ -20,59 +20,48 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#if MATRIX_COLS <= 8
#if (MATRIX_COLS <= 8)
typedef uint8_t matrix_row_t; typedef uint8_t matrix_row_t;
#elif MATRIX_COLS <= 16 #elif (MATRIX_COLS <= 16)
typedef uint16_t matrix_row_t; typedef uint16_t matrix_row_t;
#elif MATRIX_COLS <= 32 #elif (MATRIX_COLS <= 32)
typedef uint32_t matrix_row_t; typedef uint32_t matrix_row_t;
#else #else
# error "There are too many columns." #error "MATRIX_COLS: invalid value"
#endif #endif
#if DIODE_DIRECTION == ROW2COL #define MATRIX_IS_ON(row, col) (matrix_get_row(row) && (1<<col))
# 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 #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* counts the number of rows in the matrix */
/* number of matrix rows */
uint8_t matrix_rows(void); uint8_t matrix_rows(void);
/* counts the number of columns in the matrix */ /* number of matrix columns */
uint8_t matrix_cols(void); uint8_t matrix_cols(void);
/* sets up the matrix before matrix_init */ /* should be called at early stage of startup before matrix_init.(optional) */
void matrix_setup(void); void matrix_setup(void);
/* intializes the matrix */ /* intialize matrix for scaning. */
void matrix_init(void); void matrix_init(void);
/* scans the entire matrix */ /* scan all key states on matrix */
uint8_t matrix_scan(void); uint8_t matrix_scan(void);
/* checks if the matrix has been modified */ /* whether modified from previous scan. used after matrix_scan. */
bool matrix_is_modified(void) __attribute__ ((deprecated)); bool matrix_is_modified(void) __attribute__ ((deprecated));
/* checks if a key is pressed */ /* whether a swtich is on */
bool matrix_is_on(uint8_t row, uint8_t col); bool matrix_is_on(uint8_t row, uint8_t col);
/* inspects the state of a row in the matrix */ /* matrix state on row */
matrix_row_t matrix_get_row(uint8_t row); matrix_row_t matrix_get_row(uint8_t row);
/* prints the matrix for debugging */ /* print matrix for debug */
void matrix_print(void); void matrix_print(void);
/* counts the total number of keys pressed */
uint8_t matrix_key_count(void);
/* controls power to the matrix */ /* power control */
void matrix_power_up(void); void matrix_power_up(void);
void matrix_power_down(void); void matrix_power_down(void);
/* executes code for Quantum */ /* executes code for Quantum */
void matrix_init_quantum(void); void matrix_init_quantum(void);
void matrix_scan_quantum(void); void matrix_scan_quantum(void);