di0ib
/
tmk_keyboard
Watch 1
Star 0
Fork 0
Code Releases 4 Activity
Browse Source

Merge remote-tracking branch 'refs/remotes/tmk/master'

master
di0ib 7 years ago
parent
3b816b9593 51326077b0
commit
61b54bd6ee
34 changed files with 4552 additions and 3929 deletions
Unified View Show Diff Stats
  1. 2
    112
      converter/adb_usb/matrix.c
  2. 0
    28
      converter/ibm4704_usb/matrix.c
  3. 0
    48
      converter/m0110_usb/matrix.c
  4. 0
    54
      converter/news_usb/matrix.c
  5. 0
    32
      converter/next_usb/matrix.c
  6. 0
    54
      converter/pc98_usb/matrix.c
  7. 2
    54
      converter/sun_usb/matrix.c
  8. 0
    86
      converter/terminal_usb/matrix.c
  9. 1
    0
      converter/usb_usb/Makefile.unimap
  10. 1
    1
      converter/usb_usb/README
  11. 1578
    1564
      converter/usb_usb/binary/usb_usb_unimap.hex
  12. 12
    0
      converter/usb_usb/usb_usb.cpp
  13. 0
    48
      converter/x68k_usb/matrix.c
  14. 0
    86
      converter/xt_usb/matrix.c
  15. 31
    63
      keyboard/alps64/Makefile
  16. 3
    0
      keyboard/alps64/Makefile.actionmap
  17. 1
    2
      keyboard/alps64/Makefile.keymap_editor
  18. 4
    0
      keyboard/alps64/Makefile.unimap
  19. 1287
    0
      keyboard/alps64/binary/alps64_unimap.hex
  20. 0
    28
      keyboard/alps64/matrix.c
  21. 64
    0
      keyboard/alps64/unimap_plain.c
  22. 63
    0
      keyboard/alps64/unimap_trans.h
  23. 0
    43
      keyboard/gh60/matrix.c
  24. 0
    59
      keyboard/hbkb/matrix.c
  25. 1453
    1452
      keyboard/hhkb/binary/hhkb_rn42_unimap.hex
  26. 0
    41
      keyboard/hhkb/matrix.c
  27. 0
    43
      keyboard/onekey/matrix.c
  28. 12
    5
      tmk_core/common/avr/sleep_led.c
  29. 5
    1
      tmk_core/common/avr/suspend.c
  30. 10
    2
      tmk_core/common/command.c
  31. 9
    1
      tmk_core/common/host.c
  32. 8
    10
      tmk_core/common/matrix.c
  33. 4
    0
      tmk_core/common/matrix.h
  34. 2
    12
      tmk_core/common/sleep_led.h

+ 2
- 112
converter/adb_usb/matrix.c View File

#include "host.h" #include "host.h"




#if (MATRIX_COLS > 16)
# error "MATRIX_COLS must not exceed 16"
#endif
#if (MATRIX_ROWS > 255)
# error "MATRIX_ROWS must not exceed 255"
#endif




static bool has_media_keys = false; static bool has_media_keys = false;
static bool is_iso_layout = false; static bool is_iso_layout = false;
static bool is_modified = false;
static report_mouse_t mouse_report = {}; static report_mouse_t mouse_report = {};


// matrix state buffer(1:on, 0:off) // matrix state buffer(1:on, 0:off)
#if (MATRIX_COLS <= 8)
static uint8_t matrix[MATRIX_ROWS];
#else
static uint16_t matrix[MATRIX_ROWS];
#endif
static matrix_row_t matrix[MATRIX_ROWS];


#ifdef MATRIX_HAS_GHOST
static bool matrix_has_ghost_in_row(uint8_t row);
#endif
static void register_key(uint8_t key); static void register_key(uint8_t key);




inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}

void matrix_init(void) void matrix_init(void)
{ {
// LED on // LED on
uint16_t codes; uint16_t codes;
uint8_t key0, key1; uint8_t key0, key1;


is_modified = false;

codes = extra_key; codes = extra_key;
extra_key = 0xFFFF; extra_key = 0xFFFF;


return 1; return 1;
} }


bool matrix_is_modified(void)
{
return is_modified;
}

inline
bool matrix_has_ghost(void)
{
#ifdef MATRIX_HAS_GHOST
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
if (matrix_has_ghost_in_row(i))
return true;
}
#endif
return false;
}

inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & (1<<col));
}

inline inline
#if (MATRIX_COLS <= 8)
uint8_t matrix_get_row(uint8_t row)
#else
uint16_t matrix_get_row(uint8_t row)
#endif
matrix_row_t matrix_get_row(uint8_t row)
{ {
return matrix[row]; return matrix[row];
} }


void matrix_print(void)
{
if (!debug_matrix) return;
#if (MATRIX_COLS <= 8)
print("r/c 01234567\n");
#else
print("r/c 0123456789ABCDEF\n");
#endif
for (uint8_t row = 0; row < matrix_rows(); row++) {
phex(row); print(": ");
#if (MATRIX_COLS <= 8)
pbin_reverse(matrix_get_row(row));
#else
pbin_reverse16(matrix_get_row(row));
#endif
#ifdef MATRIX_HAS_GHOST
if (matrix_has_ghost_in_row(row)) {
print(" <ghost");
}
#endif
print("\n");
}
}

uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
#if (MATRIX_COLS <= 8)
count += bitpop(matrix[i]);
#else
count += bitpop16(matrix[i]);
#endif
}
return count;
}

#ifdef MATRIX_HAS_GHOST
inline
static bool matrix_has_ghost_in_row(uint8_t row)
{
// no ghost exists in case less than 2 keys on
if (((matrix[row] - 1) & matrix[row]) == 0)
return false;

// ghost exists in case same state as other row
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
if (i != row && (matrix[i] & matrix[row]) == matrix[row])
return true;
}
return false;
}
#endif

inline inline
static void register_key(uint8_t key) static void register_key(uint8_t key)
{ {
} else { } else {
matrix[row] |= (1<<col); matrix[row] |= (1<<col);
} }
is_modified = true;
} }

+ 0
- 28
converter/ibm4704_usb/matrix.c View File

#define COL(code) (code&0x07) #define COL(code) (code&0x07)




inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}

static void enable_break(void) static void enable_break(void)
{ {
print("Enable break: "); print("Enable break: ");
return 1; return 1;
} }


inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & (1<<col));
}

inline inline
uint8_t matrix_get_row(uint8_t row) uint8_t matrix_get_row(uint8_t row)
{ {
return matrix[row]; return matrix[row];
} }


void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
xprintf("%02X: %08b\n", row, bitrev(matrix_get_row(row)));
}
}



inline inline
static void matrix_make(uint8_t code) static void matrix_make(uint8_t code)
{ {

+ 0
- 48
converter/m0110_usb/matrix.c View File

static void register_key(uint8_t key); static void register_key(uint8_t key);




inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}

void matrix_init(void) void matrix_init(void)
{ {
m0110_init(); m0110_init();
return 1; return 1;
} }


bool matrix_is_modified(void)
{
return is_modified;
}

inline
bool matrix_has_ghost(void)
{
return false;
}

inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & (1<<col));
}

inline inline
uint8_t matrix_get_row(uint8_t row) uint8_t matrix_get_row(uint8_t row)
{ {
return matrix[row]; return matrix[row];
} }


void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
phex(row); print(": ");
pbin_reverse(matrix_get_row(row));
print("\n");
}
}

uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop(matrix[i]);
}
return count;
}

inline inline
static void register_key(uint8_t key) static void register_key(uint8_t key)
{ {

+ 0
- 54
converter/news_usb/matrix.c View File

#define ROW(code) ((code>>3)&0xF) #define ROW(code) ((code>>3)&0xF)
#define COL(code) (code&0x07) #define COL(code) (code&0x07)


static bool is_modified = false;


inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}


void matrix_init(void) void matrix_init(void)
{ {


uint8_t matrix_scan(void) uint8_t matrix_scan(void)
{ {
is_modified = false;

uint8_t code; uint8_t code;
code = news_recv(); code = news_recv();
if (code == 0) { if (code == 0) {
// break code // break code
if (matrix_is_on(ROW(code), COL(code))) { if (matrix_is_on(ROW(code), COL(code))) {
matrix[ROW(code)] &= ~(1<<COL(code)); matrix[ROW(code)] &= ~(1<<COL(code));
is_modified = true;
} }
} else { } else {
// make code // make code
if (!matrix_is_on(ROW(code), COL(code))) { if (!matrix_is_on(ROW(code), COL(code))) {
matrix[ROW(code)] |= (1<<COL(code)); matrix[ROW(code)] |= (1<<COL(code));
is_modified = true;
} }
} }
return code; return code;
} }


bool matrix_is_modified(void)
{
return is_modified;
}

inline
bool matrix_has_ghost(void)
{
return false;
}

inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & (1<<col));
}

inline inline
uint8_t matrix_get_row(uint8_t row) uint8_t matrix_get_row(uint8_t row)
{ {
return matrix[row]; return matrix[row];
} }

void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
phex(row); print(": ");
pbin_reverse(matrix_get_row(row));
print("\n");
}
}

uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop(matrix[i]);
}
return count;
}

+ 0
- 32
converter/next_usb/matrix.c View File



static bool is_modified = false; static bool is_modified = false;


/* number of matrix rows */
inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

/* number of matrix columns */
inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}

#ifndef NEXT_KBD_LED1_ON #ifndef NEXT_KBD_LED1_ON
#define NEXT_KBD_LED1_ON #define NEXT_KBD_LED1_ON
#endif #endif
return 1; return 1;
} }


/* whether modified from previous scan. used after matrix_scan. */
bool matrix_is_modified()
{
return is_modified;
}

/* whether a switch is on */
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & (1<<col));
}

/* matrix state on row */ /* matrix state on row */
inline inline
uint8_t matrix_get_row(uint8_t row) uint8_t matrix_get_row(uint8_t row)
return matrix[row]; return matrix[row];
} }


/* print matrix for debug */
void matrix_print(void)
{
}

inline inline
static void matrix_make(uint8_t code) static void matrix_make(uint8_t code)
{ {

+ 0
- 54
converter/pc98_usb/matrix.c View File

#define ROW(code) ((code>>3)&0xF) #define ROW(code) ((code>>3)&0xF)
#define COL(code) (code&0x07) #define COL(code) (code&0x07)


static bool is_modified = false;


inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}


static void pc98_inhibit_repeat(void) static void pc98_inhibit_repeat(void)
{ {


uint8_t matrix_scan(void) uint8_t matrix_scan(void)
{ {
is_modified = false;

uint16_t code; uint16_t code;
PC98_RDY_PORT |= (1<<PC98_RDY_BIT); PC98_RDY_PORT |= (1<<PC98_RDY_BIT);
_delay_us(30); _delay_us(30);
// break code // break code
if (matrix_is_on(ROW(code), COL(code))) { if (matrix_is_on(ROW(code), COL(code))) {
matrix[ROW(code)] &= ~(1<<COL(code)); matrix[ROW(code)] &= ~(1<<COL(code));
is_modified = true;
} }
} else { } else {
// make code // make code
if (!matrix_is_on(ROW(code), COL(code))) { if (!matrix_is_on(ROW(code), COL(code))) {
matrix[ROW(code)] |= (1<<COL(code)); matrix[ROW(code)] |= (1<<COL(code));
is_modified = true;
} }
} }
return code; return code;
} }


bool matrix_is_modified(void)
{
return is_modified;
}

inline
bool matrix_has_ghost(void)
{
return false;
}

inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & (1<<col));
}

inline inline
uint8_t matrix_get_row(uint8_t row) uint8_t matrix_get_row(uint8_t row)
{ {
return matrix[row]; return matrix[row];
} }

void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
phex(row); print(": ");
pbin_reverse(matrix_get_row(row));
print("\n");
}
}

uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop(matrix[i]);
}
return count;
}

+ 2
- 54
converter/sun_usb/matrix.c View File

#include "matrix.h" #include "matrix.h"
#include "debug.h" #include "debug.h"
#include "protocol/serial.h" #include "protocol/serial.h"
#include "led.h"
#include "host.h"




/* /*
#define ROW(code) ((code>>3)&0xF) #define ROW(code) ((code>>3)&0xF)
#define COL(code) (code&0x07) #define COL(code) (code&0x07)


static bool is_modified = false;


inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}


void matrix_init(void) void matrix_init(void)
{ {


uint8_t matrix_scan(void) uint8_t matrix_scan(void)
{ {
is_modified = false;

uint8_t code; uint8_t code;
code = serial_recv(); code = serial_recv();
if (!code) return 0; if (!code) return 0;
// break code // break code
if (matrix_is_on(ROW(code), COL(code))) { if (matrix_is_on(ROW(code), COL(code))) {
matrix[ROW(code)] &= ~(1<<COL(code)); matrix[ROW(code)] &= ~(1<<COL(code));
is_modified = true;
} }
} else { } else {
// make code // make code
if (!matrix_is_on(ROW(code), COL(code))) { if (!matrix_is_on(ROW(code), COL(code))) {
matrix[ROW(code)] |= (1<<COL(code)); matrix[ROW(code)] |= (1<<COL(code));
is_modified = true;
} }
} }
return code; return code;
} }


bool matrix_is_modified(void)
{
return is_modified;
}

inline
bool matrix_has_ghost(void)
{
return false;
}

inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & (1<<col));
}

inline inline
uint8_t matrix_get_row(uint8_t row) uint8_t matrix_get_row(uint8_t row)
{ {
return matrix[row]; return matrix[row];
} }

void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
phex(row); print(": ");
pbin_reverse(matrix_get_row(row));
print("\n");
}
}

uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop(matrix[i]);
}
return count;
}

+ 0
- 86
converter/terminal_usb/matrix.c View File



static void matrix_make(uint8_t code); static void matrix_make(uint8_t code);
static void matrix_break(uint8_t code); static void matrix_break(uint8_t code);
#ifdef MATRIX_HAS_GHOST
static bool matrix_has_ghost_in_row(uint8_t row);
#endif




/* /*
#define ROW(code) (code>>3) #define ROW(code) (code>>3)
#define COL(code) (code&0x07) #define COL(code) (code&0x07)


static bool is_modified = false;


inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}


void matrix_init(void) void matrix_init(void)
{ {
F0, F0,
} state = RESET; } state = RESET;


is_modified = false;

uint8_t code; uint8_t code;
if ((code = ps2_host_recv())) { if ((code = ps2_host_recv())) {
debug("r"); debug_hex(code); debug(" "); debug("r"); debug_hex(code); debug(" ");
return 1; return 1;
} }


bool matrix_is_modified(void)
{
return is_modified;
}

inline
bool matrix_has_ghost(void)
{
#ifdef MATRIX_HAS_GHOST
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
if (matrix_has_ghost_in_row(i))
return true;
}
#endif
return false;
}

inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & (1<<col));
}

inline inline
uint8_t matrix_get_row(uint8_t row) uint8_t matrix_get_row(uint8_t row)
{ {
return matrix[row]; return matrix[row];
} }


void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
phex(row); print(": ");
pbin_reverse(matrix_get_row(row));
#ifdef MATRIX_HAS_GHOST
if (matrix_has_ghost_in_row(row)) {
print(" <ghost");
}
#endif
print("\n");
}
}

uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop(matrix[i]);
}
return count;
}

#ifdef MATRIX_HAS_GHOST
inline
static bool matrix_has_ghost_in_row(uint8_t row)
{
// no ghost exists in case less than 2 keys on
if (((matrix[row] - 1) & matrix[row]) == 0)
return false;

// ghost exists in case same state as other row
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
if (i != row && (matrix[i] & matrix[row]) == matrix[row])
return true;
}
return false;
}
#endif


inline inline
static void matrix_make(uint8_t code) static void matrix_make(uint8_t code)
{ {
if (!matrix_is_on(ROW(code), COL(code))) { if (!matrix_is_on(ROW(code), COL(code))) {
matrix[ROW(code)] |= 1<<COL(code); matrix[ROW(code)] |= 1<<COL(code);
is_modified = true;
} }
} }


{ {
if (matrix_is_on(ROW(code), COL(code))) { if (matrix_is_on(ROW(code), COL(code))) {
matrix[ROW(code)] &= ~(1<<COL(code)); matrix[ROW(code)] &= ~(1<<COL(code));
is_modified = true;
} }
} }

+ 1
- 0
converter/usb_usb/Makefile.unimap View File

TARGET = usb_usb_unimap TARGET = usb_usb_unimap
UNIMAP_ENABLE = yes UNIMAP_ENABLE = yes
KEYMAP_SECTION_ENABLE = yes KEYMAP_SECTION_ENABLE = yes
#LUFA_DEBUG = yes
include Makefile include Makefile

+ 1
- 1
converter/usb_usb/README View File

Limitation Limitation
---------- ----------
Only supports 'HID Boot protocol'. Only supports 'HID Boot protocol'.
Not support keyboard LED yet.


Note that the converter can host only USB "boot protocol" keyboard(6KRO), not NKRO, it is possible to support NKRO keyboard but you will need to write HID report parser for that. Every NKRO keyboard can have different HID report and it is difficult to support all kind of NKRO keyboards in the market. Note that the converter can host only USB "boot protocol" keyboard(6KRO), not NKRO, it is possible to support NKRO keyboard but you will need to write HID report parser for that. Every NKRO keyboard can have different HID report and it is difficult to support all kind of NKRO keyboards in the market.


------ ------
2014/12/11 Added Hub support(confirmed with HHKB pro2) 2014/12/11 Added Hub support(confirmed with HHKB pro2)
2016/09/10 Unimap editor support 2016/09/10 Unimap editor support
2016/10/18 Fix LED state at startup







+ 1578
- 1564
converter/usb_usb/binary/usb_usb_unimap.hex
File diff suppressed because it is too large
View File


+ 12
- 0
converter/usb_usb/usb_usb.cpp View File

#include "timer.h" #include "timer.h"
#include "matrix.h" #include "matrix.h"
#include "led.h" #include "led.h"
#include "host.h"
#include "keyboard.h"




/* KEY CODE to Matrix /* KEY CODE to Matrix
dprintf("host.Task: %d\n", timer); dprintf("host.Task: %d\n", timer);
} }


static uint8_t usb_state = 0;
if (usb_state != usb_host.getUsbTaskState()) {
usb_state = usb_host.getUsbTaskState();
dprintf("usb_state: %02X\n", usb_state);

// restore LED state when keyboard comes up
if (usb_state == USB_STATE_RUNNING) {
keyboard_set_leds(host_keyboard_leds());
}
}
return 1; return 1;
} }



+ 0
- 48
converter/x68k_usb/matrix.c View File

static bool is_modified = false; static bool is_modified = false;




inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}

void matrix_init(void) void matrix_init(void)
{ {
serial_init(); serial_init();
return code; return code;
} }


bool matrix_is_modified(void)
{
return is_modified;
}

inline
bool matrix_has_ghost(void)
{
return false;
}

inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & (1<<col));
}

inline inline
uint8_t matrix_get_row(uint8_t row) uint8_t matrix_get_row(uint8_t row)
{ {
return matrix[row]; return matrix[row];
} }

void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
phex(row); print(": ");
pbin_reverse(matrix_get_row(row));
print("\n");
}
}

uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop(matrix[i]);
}
return count;
}

+ 0
- 86
converter/xt_usb/matrix.c View File



static void matrix_make(uint8_t code); static void matrix_make(uint8_t code);
static void matrix_break(uint8_t code); static void matrix_break(uint8_t code);
#ifdef MATRIX_HAS_GHOST
static bool matrix_has_ghost_in_row(uint8_t row);
#endif


static uint8_t matrix[MATRIX_ROWS]; static uint8_t matrix[MATRIX_ROWS];
#define ROW(code) (code>>3) #define ROW(code) (code>>3)
#define PRINT_SCREEN (0x7C) #define PRINT_SCREEN (0x7C)
#define PAUSE (0x7D) #define PAUSE (0x7D)


static bool is_modified = false;


inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}


void matrix_init(void) void matrix_init(void)
{ {
} state = INIT; } state = INIT;




is_modified = false;

// 'pseudo break code' hack // 'pseudo break code' hack
if (matrix_is_on(ROW(PAUSE), COL(PAUSE))) { if (matrix_is_on(ROW(PAUSE), COL(PAUSE))) {
matrix_break(PAUSE); matrix_break(PAUSE);
return 1; return 1;
} }


bool matrix_is_modified(void)
{
return is_modified;
}

inline
bool matrix_has_ghost(void)
{
#ifdef MATRIX_HAS_GHOST
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
if (matrix_has_ghost_in_row(i))
return true;
}
#endif
return false;
}

inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & (1<<col));
}

inline inline
uint8_t matrix_get_row(uint8_t row) uint8_t matrix_get_row(uint8_t row)
{ {
return matrix[row]; return matrix[row];
} }


void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
phex(row); print(": ");
pbin_reverse(matrix_get_row(row));
#ifdef MATRIX_HAS_GHOST
if (matrix_has_ghost_in_row(row)) {
print(" <ghost");
}
#endif
print("\n");
}
}

uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop(matrix[i]);
}
return count;
}

#ifdef MATRIX_HAS_GHOST
inline
static bool matrix_has_ghost_in_row(uint8_t row)
{
// no ghost exists in case less than 2 keys on
if (((matrix[row] - 1) & matrix[row]) == 0)
return false;

// ghost exists in case same state as other row
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
if (i != row && (matrix[i] & matrix[row]) == matrix[row])
return true;
}
return false;
}
#endif


inline inline
static void matrix_make(uint8_t code) static void matrix_make(uint8_t code)
{ {
if (!matrix_is_on(ROW(code), COL(code))) { if (!matrix_is_on(ROW(code), COL(code))) {
matrix[ROW(code)] |= 1<<COL(code); matrix[ROW(code)] |= 1<<COL(code);
is_modified = true;
} }
} }


{ {
if (matrix_is_on(ROW(code), COL(code))) { if (matrix_is_on(ROW(code), COL(code))) {
matrix[ROW(code)] &= ~(1<<COL(code)); matrix[ROW(code)] &= ~(1<<COL(code));
is_modified = true;
} }
} }



+ 31
- 63
keyboard/alps64/Makefile View File

#----------------------------------------------------------------------------
# On command line:
#
# make all = Make software.
#
# make clean = Clean out built project files.
#
# make coff = Convert ELF to AVR COFF.
#
# make extcoff = Convert ELF to AVR Extended COFF.
#
# make program = Download the hex file to the device.
# Please customize your programmer settings(PROGRAM_CMD)
#
# make teensy = Download the hex file to the device, using teensy_loader_cli.
# (must have teensy_loader_cli installed).
#
# make dfu = Download the hex file to the device, using dfu-programmer (must
# have dfu-programmer installed).
#
# make flip = Download the hex file to the device, using Atmel FLIP (must
# have Atmel FLIP installed).
#
# make dfu-ee = Download the eeprom file to the device, using dfu-programmer
# (must have dfu-programmer installed).
#
# make flip-ee = Download the eeprom file to the device, using Atmel FLIP
# (must have Atmel FLIP installed).
#
# make debug = Start either simulavr or avarice as specified for debugging,
# with avr-gdb or avr-insight as the front end for debugging.
#
# make filename.s = Just compile filename.c into the assembler code only.
#
# make filename.i = Create a preprocessed source file for use in submitting
# bug reports to the GCC project.
#
# To rebuild project do "make clean" then "make all".
#----------------------------------------------------------------------------

# Target file name (without extension). # Target file name (without extension).
TARGET = alps64
TARGET ?= alps64


# Directory common source filess exist # Directory common source filess exist
TMK_DIR = ../../tmk_core
TMK_DIR ?= ../../tmk_core


# Directory keyboard dependent files exist # Directory keyboard dependent files exist
TARGET_DIR = .
TARGET_DIR ?= .


# project specific files # project specific files
SRC = matrix.c \
SRC ?= matrix.c \
led.c led.c


CONFIG_H = config.h
CONFIG_H ?= config.h




# MCU name # MCU name
MCU = atmega32u2
MCU ?= atmega32u2


# Processor frequency. # Processor frequency.
# This will define a symbol, F_CPU, in all source code files equal to the # This will define a symbol, F_CPU, in all source code files equal to the
# does not *change* the processor frequency - it should merely be updated to # does not *change* the processor frequency - it should merely be updated to
# reflect the processor speed set externally so that the code can use accurate # reflect the processor speed set externally so that the code can use accurate
# software delays. # software delays.
F_CPU = 16000000
F_CPU ?= 16000000




# #
# LUFA specific # LUFA specific
# #
# Target architecture (see library "Board Types" documentation). # Target architecture (see library "Board Types" documentation).
ARCH = AVR8
ARCH ?= AVR8


# Input clock frequency. # Input clock frequency.
# This will define a symbol, F_USB, in all source code files equal to the # This will define a symbol, F_USB, in all source code files equal to the
# #
# If no clock division is performed on the input clock inside the AVR (via the # If no clock division is performed on the input clock inside the AVR (via the
# CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU. # CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
F_USB = $(F_CPU)
F_USB ?= $(F_CPU)


# Interrupt driven control endpoint task(+60) # Interrupt driven control endpoint task(+60)
OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
# Atmel DFU loader 4096 # Atmel DFU loader 4096
# LUFA bootloader 4096 # LUFA bootloader 4096
# USBaspLoader 2048 # USBaspLoader 2048
OPT_DEFS += -DBOOTLOADER_SIZE=4096
BOOTLOADER_SIZE ?= 4096
OPT_DEFS += -DBOOTLOADER_SIZE=$(BOOTLOADER_SIZE)




# Build Options # Build Options
# comment out to disable the options. # comment out to disable the options.
# #
BOOTMAGIC_ENABLE = yes # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
CONSOLE_ENABLE = yes # Console for debug(+400)
COMMAND_ENABLE = yes # Commands for debug and configuration
#SLEEP_LED_ENABLE = yes # Breathing sleep LED during USB suspend
#NKRO_ENABLE = yes # USB Nkey Rollover
#ACTIONMAP_ENABLE = yes # Use 16bit action codes in keymap instead of 8bit keycodes


ifdef ACTIONMAP_ENABLE
KEYMAP_FILE = actionmap
BOOTMAGIC_ENABLE ?= yes # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE ?= yes # Mouse keys(+4700)
EXTRAKEY_ENABLE ?= yes # Audio control and System control(+450)
CONSOLE_ENABLE ?= yes # Console for debug(+400)
COMMAND_ENABLE ?= yes # Commands for debug and configuration
#SLEEP_LED_ENABLE ?= yes # Breathing sleep LED during USB suspend
#NKRO_ENABLE ?= yes # USB Nkey Rollover
#ACTIONMAP_ENABLE ?= yes # Use 16bit action codes in keymap instead of 8bit keycodes


#
# Keymap file
#
ifeq (yes,$(strip $(UNIMAP_ENABLE)))
KEYMAP_FILE = unimap
else else
KEYMAP_FILE = keymap
ifeq (yes,$(strip $(ACTIONMAP_ENABLE)))
KEYMAP_FILE = actionmap
else
KEYMAP_FILE = keymap
endif
endif endif
ifdef KEYMAP ifdef KEYMAP
SRC := $(KEYMAP_FILE)_$(KEYMAP).c $(SRC) SRC := $(KEYMAP_FILE)_$(KEYMAP).c $(SRC)

+ 3
- 0
keyboard/alps64/Makefile.actionmap View File

TARGET = alps64_actionmap
ACTIONMAP_ENABLE = yes # Use 16bit action codes in keymap instead of 8bit keycodes
include Makefile

+ 1
- 2
keyboard/alps64/Makefile.keymap_editor View File

# build firmware for keymap editor
#
TARGET = alps64_editor
KEYMAP_SECTION_ENABLE = yes # fixed address keymap for keymap editor KEYMAP_SECTION_ENABLE = yes # fixed address keymap for keymap editor
KEYMAP = editor KEYMAP = editor
include Makefile include Makefile

+ 4
- 0
keyboard/alps64/Makefile.unimap View File

TARGET = alps64_unimap
UNIMAP_ENABLE = yes
KEYMAP_SECTION_ENABLE = yes
include Makefile

+ 1287
- 0
keyboard/alps64/binary/alps64_unimap.hex
File diff suppressed because it is too large
View File


+ 0
- 28
keyboard/alps64/matrix.c View File

static void select_row(uint8_t row); static void select_row(uint8_t row);




inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}

#define LED_ON() do { DDRC |= (1<<5); PORTC |= (1<<5); } while (0) #define LED_ON() do { DDRC |= (1<<5); PORTC |= (1<<5); } while (0)
#define LED_OFF() do { DDRC &= ~(1<<5); PORTC &= ~(1<<5); } while (0) #define LED_OFF() do { DDRC &= ~(1<<5); PORTC &= ~(1<<5); } while (0)
#define LED_TGL() do { DDRC |= (1<<5); PINC |= (1<<5); } while (0) #define LED_TGL() do { DDRC |= (1<<5); PINC |= (1<<5); } while (0)
return 1; return 1;
} }


inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}

inline inline
matrix_row_t matrix_get_row(uint8_t row) matrix_row_t matrix_get_row(uint8_t row)
{ {
return matrix[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");
}
}

/* Column pin configuration /* Column pin configuration
* col: 0 1 2 3 4 5 6 7 * col: 0 1 2 3 4 5 6 7
* pin: B0 B1 B2 B3 B4 B5 B6 B7 * pin: B0 B1 B2 B3 B4 B5 B6 B7

+ 64
- 0
keyboard/alps64/unimap_plain.c View File

/*
Copyright 2016 Jun Wako <[email protected]>

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 "unimap_trans.h"


#define AC_FN0 ACTION_LAYER_MOMENTARY(1)

#ifdef KEYMAP_SECTION_ENABLE
const action_t actionmaps[][UNIMAP_ROWS][UNIMAP_COLS] __attribute__ ((section (".keymap.keymaps"))) = {
#else
const action_t actionmaps[][UNIMAP_ROWS][UNIMAP_COLS] PROGMEM = {
#endif
/*
* Universal keyboard layout
* ,-----------------------------------------------.
* |F13|F14|F15|F16|F17|F18|F19|F20|F21|F22|F23|F24|
* ,---. |-----------------------------------------------| ,-----------. ,-----------.
* |Esc| |F1 |F2 |F3 |F4 |F5 |F6 |F7 |F8 |F9 |F10|F11|F12| |PrS|ScL|Pau| |VDn|VUp|Mut|
* `---' `-----------------------------------------------' `-----------' `-----------'
* ,-----------------------------------------------------------. ,-----------. ,---------------.
* | `| 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|JPY|Bsp| |Ins|Hom|PgU| |NmL| /| *| -|
* |-----------------------------------------------------------| |-----------| |---------------|
* |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \ | |Del|End|PgD| | 7| 8| 9| +|
* |-----------------------------------------------------------| `-----------' |---------------|
* |CapsL | A| S| D| F| G| H| J| K| L| ;| '| #|Retn| | 4| 5| 6|KP,|
* |-----------------------------------------------------------| ,---. |---------------|
* |Shft| <| Z| X| C| V| B| N| M| ,| .| /| RO|Shift | |Up | | 1| 2| 3|KP=|
* |-----------------------------------------------------------| ,-----------. |---------------|
* |Ctl|Gui|Alt|MHEN| Space |HENK|KANA|Alt|Gui|App|Ctl| |Lef|Dow|Rig| | 0 | .|Ent|
* `-----------------------------------------------------------' `-----------' `---------------'
*/
UNIMAP(
NO, NO, NO, NO, NO, NO, NO, NO, NO, NO, NO, NO,
ESC, NO, NO, NO, NO, NO, NO, NO, NO, NO, NO, NO, NO, NO, NO, NO, NO, NO, NO,
GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, NUHS,BSPC, NO, NO, NO, NO, NO, NO, NO,
TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC, BSLS, NO, NO, NO, NO, NO, NO, NO,
LCTL,A, S, D, F, G, H, J, K, L, SCLN,QUOT, NO, ENT, NO, NO, NO, NO,
LSFT,NUBS,Z, X, C, V, B, N, M, COMM,DOT, SLSH, NO, RSFT, NO, NO, NO, NO, NO,
LCTL,LGUI,LALT,NO, SPC, NO, NO, RALT,RGUI,APP, FN0, NO, NO, NO, NO, NO, NO
),
UNIMAP(
TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,
TRNS, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS,TRNS,TRNS, TRNS,TRNS,TRNS,
ESC, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, INS, DEL, TRNS,TRNS,TRNS, TRNS,TRNS,TRNS,TRNS,
CAPS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,PSCR,SLCK,PAUS,UP, TRNS, TRNS, TRNS,TRNS,TRNS, TRNS,TRNS,TRNS,TRNS,
TRNS,VOLD,VOLU,MUTE,TRNS,TRNS,PAST,PSLS,HOME,PGUP,LEFT,RGHT, TRNS,PENT, TRNS,TRNS,TRNS,TRNS,
TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,PPLS,PMNS,END, PGDN,DOWN, TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS,
TRNS,TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS,TRNS,TRNS, TRNS, TRNS,TRNS
),
};

+ 63
- 0
keyboard/alps64/unimap_trans.h View File

/*
Copyright 2016 Jun Wako <[email protected]>

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/>.
*/
#ifndef UNIMAP_TRNAS_H
#define UNIMAP_TRNAS_H

#include <stdint.h>
#include <avr/pgmspace.h>
#include "unimap.h"


/* Mapping to Universal keyboard layout
* ,-----------------------------------------------------------.
* |` | 1| 2| 3| 4| 5| 6| 7| 8| 9| 0| -| =|JPY|Bsp|
* |-----------------------------------------------------------|
* |Tab | Q| W| E| R| T| Y| U| I| O| P| [| ]| \ |
* |-----------------------------------------------------------|
* |Caps | A| S| D| F| G| H| J| K| L| ;| '|Enter |
* |-----------------------------------------------------------|
* |Shft| \| Z| X| C| V| B| N| M| ,| .| /|Shift |Esc|
* |-----------------------------------------------------------'
* |Ctrl|Gui |Alt | Space |App |Alt |Gui |Ctrl |
* `-----------------------------------------------------------'
*
* ,-----------------------------------------------------------.
* |36 |37 |46 |47 |56 |57 |66 |67 |76 |77 |06 |07 |17 |26 |27 |
* |-----------------------------------------------------------|
* |34 |35 |44 |45 |54 |55 |64 |65 |75 |05 |15 |16 |25 |24 |
* |-----------------------------------------------------------|
* |32 |33 |43 |52 |53 |63 |73 |74 |03 |04 |13 |14 | 23 |
* |-----------------------------------------------------------|
* |31 |41 |42 |51 |61 |62 |71 |72 |01 |02 |11 |12 |21 |22 |
* |-----------------------------------------------------------|
* |30 |40 |50 | 60 |70 |00 |10 |20 |
* `-----------------------------------------------------------'
*/
const uint8_t PROGMEM unimap_trans[MATRIX_ROWS][MATRIX_COLS] = {
{ UNIMAP_RALT, UNIMAP_M, UNIMAP_COMM, UNIMAP_K, UNIMAP_L, UNIMAP_O, UNIMAP_0, UNIMAP_MINS }, /* 00-07 */
{ UNIMAP_RGUI, UNIMAP_DOT, UNIMAP_SLSH, UNIMAP_SCLN, UNIMAP_QUOT, UNIMAP_P, UNIMAP_LBRC, UNIMAP_EQL }, /* 10-17 */
{ UNIMAP_RCTL, UNIMAP_RSFT, UNIMAP_ESC, UNIMAP_ENT, UNIMAP_BSLS, UNIMAP_RBRC, UNIMAP_JYEN, UNIMAP_BSPC }, /* 20-27 */
{ UNIMAP_LCTL, UNIMAP_LSFT, UNIMAP_CAPS, UNIMAP_A, UNIMAP_TAB, UNIMAP_Q, UNIMAP_GRV, UNIMAP_1 }, /* 30-37 */
{ UNIMAP_LGUI, UNIMAP_NUBS, UNIMAP_Z, UNIMAP_S, UNIMAP_W, UNIMAP_E, UNIMAP_2, UNIMAP_3 }, /* 40-47 */
{ UNIMAP_LALT, UNIMAP_X, UNIMAP_D, UNIMAP_F, UNIMAP_R, UNIMAP_T, UNIMAP_4, UNIMAP_5 }, /* 50-57 */
{ UNIMAP_SPC, UNIMAP_C, UNIMAP_V, UNIMAP_G, UNIMAP_Y, UNIMAP_U, UNIMAP_6, UNIMAP_7 }, /* 60-67 */
{ UNIMAP_APP, UNIMAP_B, UNIMAP_N, UNIMAP_H, UNIMAP_J, UNIMAP_I, UNIMAP_8, UNIMAP_9 }, /* 70-77 */
};

#endif



+ 0
- 43
keyboard/gh60/matrix.c View File

static void select_row(uint8_t row); static void select_row(uint8_t row);




inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}

void matrix_init(void) void matrix_init(void)
{ {
// initialize row and col // initialize row and col
return 1; return 1;
} }


bool matrix_is_modified(void)
{
if (debouncing) return false;
return true;
}

inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}

inline inline
matrix_row_t matrix_get_row(uint8_t row) matrix_row_t matrix_get_row(uint8_t row)
{ {
return matrix[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");
}
}

uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop16(matrix[i]);
}
return count;
}

/* Column pin configuration /* Column pin configuration
* col: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 * col: 0 1 2 3 4 5 6 7 8 9 10 11 12 13
* pin: F0 F1 E6 C7 C6 B6 D4 B1 B0 B5 B4 D7 D6 B3 (Rev.A) * pin: F0 F1 E6 C7 C6 B6 D4 B1 B0 B5 B4 D7 D6 B3 (Rev.A)

+ 0
- 59
keyboard/hbkb/matrix.c View File

static matrix_row_t matrix[MATRIX_ROWS]; static matrix_row_t matrix[MATRIX_ROWS];
static matrix_row_t matrix_debouncing[MATRIX_ROWS]; static matrix_row_t matrix_debouncing[MATRIX_ROWS];


#ifdef MATRIX_HAS_GHOST
static bool matrix_has_ghost_in_row(uint8_t row);
#endif
static matrix_row_t read_cols(void); static matrix_row_t read_cols(void);
static void unselect_rows(void); static void unselect_rows(void);
static void select_row(uint8_t row); static void select_row(uint8_t row);




inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}

void matrix_init(void) void matrix_init(void)
{ {
// JTAG disable for PORT F. write JTD bit twice within four cycles. // JTAG disable for PORT F. write JTD bit twice within four cycles.
return 1; return 1;
} }


bool matrix_is_modified(void)
{
if (debouncing) return false;
return true;
}

inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}

inline inline
matrix_row_t matrix_get_row(uint8_t row) matrix_row_t matrix_get_row(uint8_t row)
{ {
return matrix[row]; return matrix[row];
} }


void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
phex(row); print(": ");
pbin_reverse(matrix_get_row(row));
#ifdef MATRIX_HAS_GHOST
if (matrix_has_ghost_in_row(row)) {
print(" <ghost");
}
#endif
print("\n");
}
}

#ifdef MATRIX_HAS_GHOST
inline
static bool matrix_has_ghost_in_row(uint8_t row)
{
// no ghost exists in case less than 2 keys on
if (((matrix[row] - 1) & matrix[row]) == 0)
return false;

// ghost exists in case same state as other row
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
if (i != row && (matrix[i] & matrix[row]))
return true;
}
return false;
}
#endif

inline inline
static matrix_row_t read_cols(void) static matrix_row_t read_cols(void)
{ {

+ 1453
- 1452
keyboard/hhkb/binary/hhkb_rn42_unimap.hex
File diff suppressed because it is too large
View File


+ 0
- 41
keyboard/hhkb/matrix.c View File

static matrix_row_t _matrix1[MATRIX_ROWS]; static matrix_row_t _matrix1[MATRIX_ROWS];




inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}

void matrix_init(void) void matrix_init(void)
{ {
#ifdef DEBUG #ifdef DEBUG
return 1; return 1;
} }


bool matrix_is_modified(void)
{
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
if (matrix[i] != matrix_prev[i])
return true;
}
return false;
}

inline
bool matrix_has_ghost(void)
{
return false;
}

inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & (1<<col));
}

inline inline
matrix_row_t matrix_get_row(uint8_t row) matrix_row_t matrix_get_row(uint8_t row)
{ {
return matrix[row]; return matrix[row];
} }


void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
xprintf("%02X: %08b\n", row, bitrev(matrix_get_row(row)));
}
}

void matrix_power_up(void) { void matrix_power_up(void) {
KEY_POWER_ON(); KEY_POWER_ON();
} }

+ 0
- 43
keyboard/onekey/matrix.c View File

static void select_row(uint8_t row); static void select_row(uint8_t row);




inline
uint8_t matrix_rows(void)
{
return MATRIX_ROWS;
}

inline
uint8_t matrix_cols(void)
{
return MATRIX_COLS;
}

void matrix_init(void) void matrix_init(void)
{ {
debug_enable = true; debug_enable = true;
return 1; return 1;
} }


bool matrix_is_modified(void)
{
if (debouncing) return false;
return true;
}

inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}

inline inline
matrix_row_t matrix_get_row(uint8_t row) matrix_row_t matrix_get_row(uint8_t row)
{ {
return matrix[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");
}
}

uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop16(matrix[i]);
}
return count;
}

/* Column pin configuration /* Column pin configuration
* col: 0 * col: 0
* pin: B0 * pin: B0

+ 12
- 5
tmk_core/common/avr/sleep_led.c View File

TIMSK1 &= ~_BV(OCIE1A); TIMSK1 &= ~_BV(OCIE1A);
} }


void sleep_led_toggle(void)

__attribute__ ((weak))
void sleep_led_on(void)
{ {
/* Disable Compare Match Interrupt */
TIMSK1 ^= _BV(OCIE1A);
led_set(1<<USB_LED_CAPS_LOCK);
}

__attribute__ ((weak))
void sleep_led_off(void)
{
led_set(0);
} }




// LED on // LED on
if (timer.pwm.count == 0) { if (timer.pwm.count == 0) {
led_set(1<<USB_LED_CAPS_LOCK);
sleep_led_on();
} }
// LED off // LED off
if (timer.pwm.count == pgm_read_byte(&breathing_table[timer.pwm.index])) { if (timer.pwm.count == pgm_read_byte(&breathing_table[timer.pwm.index])) {
led_set(0);
sleep_led_off();
} }
} }

+ 5
- 1
tmk_core/common/avr/suspend.c View File



void suspend_power_down(void) void suspend_power_down(void)
{ {
#ifdef SUSPEND_MODE_STANDBY
#ifdef NO_SUSPEND_POWER_DOWN
;
#elif defined(SUSPEND_MODE_NOPOWERSAVE)
;
#elif defined(SUSPEND_MODE_STANDBY)
standby(); standby();
#elif defined(SUSPEND_MODE_IDLE) #elif defined(SUSPEND_MODE_IDLE)
idle(); idle();

+ 10
- 2
tmk_core/common/command.c View File

{ {
#ifdef KEYBOARD_LOCK_ENABLE #ifdef KEYBOARD_LOCK_ENABLE
static host_driver_t *host_driver = 0; static host_driver_t *host_driver = 0;
#endif
#ifdef SLEEP_LED_ENABLE
static bool sleep_led_test = false;
#endif #endif
switch (code) { switch (code) {
#ifdef SLEEP_LED_ENABLE #ifdef SLEEP_LED_ENABLE
case KC_Z: case KC_Z:
// test breathing sleep LED // test breathing sleep LED
print("Sleep LED test\n"); print("Sleep LED test\n");
sleep_led_toggle();
led_set(host_keyboard_leds());
if (sleep_led_test) {
sleep_led_disable();
led_set(host_keyboard_leds());
} else {
sleep_led_enable();
}
sleep_led_test = !sleep_led_test;
break; break;
#endif #endif
#ifdef BOOTMAGIC_ENABLE #ifdef BOOTMAGIC_ENABLE

+ 9
- 1
tmk_core/common/host.c View File

(*driver->send_keyboard)(report); (*driver->send_keyboard)(report);


if (debug_keyboard) { if (debug_keyboard) {
dprint("keyboard_report: ");
dprint("keyboard: ");
for (uint8_t i = 0; i < KEYBOARD_REPORT_SIZE; i++) { for (uint8_t i = 0; i < KEYBOARD_REPORT_SIZE; i++) {
dprintf("%02X ", report->raw[i]); dprintf("%02X ", report->raw[i]);
} }


if (!driver) return; if (!driver) return;
(*driver->send_system)(report); (*driver->send_system)(report);

if (debug_keyboard) {
dprintf("system: %04X\n", report);
}
} }


void host_consumer_send(uint16_t report) void host_consumer_send(uint16_t report)


if (!driver) return; if (!driver) return;
(*driver->send_consumer)(report); (*driver->send_consumer)(report);

if (debug_keyboard) {
dprintf("consumer: %04X\n", report);
}
} }


uint16_t host_last_sysytem_report(void) uint16_t host_last_sysytem_report(void)

+ 8
- 10
tmk_core/common/matrix.c View File

__attribute__ ((weak)) __attribute__ ((weak))
void matrix_clear(void) void matrix_clear(void)
{ {
matrix_init();
} }


__attribute__ ((weak)) __attribute__ ((weak))
#elif (MATRIX_COLS <= 32) #elif (MATRIX_COLS <= 32)
print("r/c 0123456789ABCDEF0123456789ABCDEF\n"); print("r/c 0123456789ABCDEF0123456789ABCDEF\n");
#endif #endif

for (uint8_t row = 0; row < MATRIX_ROWS; row++) { for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
xprintf("%02X:", row);


#if (MATRIX_COLS <= 8) #if (MATRIX_COLS <= 8)
print_bin_reverse8(matrix_get_row(row));
xprintf("%02X: %08b%s\n", row, bitrev(matrix_get_row(row)),
#elif (MATRIX_COLS <= 16) #elif (MATRIX_COLS <= 16)
print_bin_reverse16(matrix_get_row(row));
xprintf("%02X: %016b%s\n", row, bitrev16(matrix_get_row(row)),
#elif (MATRIX_COLS <= 32) #elif (MATRIX_COLS <= 32)
print_bin_reverse32(matrix_get_row(row));
xprintf("%02X: %032b%s\n", row, bitrev32(matrix_get_row(row)),
#endif #endif

#ifdef MATRIX_HAS_GHOST #ifdef MATRIX_HAS_GHOST
if (matrix_has_ghost_in_row(row)) {
print(" <ghost");
}
matrix_has_ghost_in_row(row) ? " <ghost" : ""
#else
""
#endif #endif
print("\n");
);
} }
} }



+ 4
- 0
tmk_core/common/matrix.h View File

#error "MATRIX_COLS: invalid value" #error "MATRIX_COLS: invalid value"
#endif #endif


#if (MATRIX_ROWS > 255)
#error "MATRIX_ROWS must not exceed 255"
#endif

#define MATRIX_IS_ON(row, col) (matrix_get_row(row) && (1<<col)) #define MATRIX_IS_ON(row, col) (matrix_get_row(row) && (1<<col))





+ 2
- 12
tmk_core/common/sleep_led.h View File

#define SLEEP_LED_H #define SLEEP_LED_H




#ifdef SLEEP_LED_ENABLE

void sleep_led_init(void); void sleep_led_init(void);
void sleep_led_enable(void); void sleep_led_enable(void);
void sleep_led_disable(void); void sleep_led_disable(void);
void sleep_led_toggle(void);

#else

#define sleep_led_init()
#define sleep_led_enable()
#define sleep_led_disable()
#define sleep_led_toggle()

#endif
void sleep_led_on(void);
void sleep_led_off(void);


#endif #endif

Write Preview
Loading…
Cancel
Save