1
0
Fork 0

Convert some more boards to Matrix Lite (#15489)

This commit is contained in:
Ryan 2021-12-27 21:15:56 +11:00 committed by GitHub
parent 6209122213
commit 6f81880f17
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
20 changed files with 206 additions and 1130 deletions

View file

@ -15,77 +15,18 @@ GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdint.h>
#include <stdbool.h> #include "quantum.h"
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h" #include "matrix.h"
#include "timer.h"
#include "uart.h" #include "uart.h"
#if (MATRIX_COLS <= 8) void matrix_init_custom(void) {
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#endif
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
__attribute__ ((weak))
void matrix_init_kb(void) {
matrix_init_user();
}
__attribute__ ((weak))
void matrix_scan_kb(void) {
matrix_scan_user();
}
__attribute__ ((weak))
void matrix_init_user(void) {
}
__attribute__ ((weak))
void matrix_scan_user(void) {
}
inline
uint8_t matrix_rows(void) {
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
void matrix_init(void) {
matrix_init_quantum();
uart_init(500000); uart_init(500000);
} }
uint8_t matrix_scan(void) bool matrix_scan_custom(matrix_row_t current_matrix[]) {
{
uint32_t timeout = 0; uint32_t timeout = 0;
bool changed = false;
//the s character requests the RF remote slave to send the matrix information //the s character requests the RF remote slave to send the matrix information
uart_write('s'); uart_write('s');
@ -96,9 +37,9 @@ uint8_t matrix_scan(void)
//there are 10 bytes corresponding to 1w columns, and an end byte //there are 10 bytes corresponding to 1w columns, and an end byte
for (uint8_t i = 0; i < 11; i++) { for (uint8_t i = 0; i < 11; i++) {
//wait for the serial data, timeout if it's been too long //wait for the serial data, timeout if it's been too long
while(!uart_available()){ while (!uart_available()) {
timeout++; timeout++;
if (timeout > 10000){ if (timeout > 10000) {
break; break;
} }
} }
@ -107,47 +48,16 @@ uint8_t matrix_scan(void)
//check for the end packet, the key state bytes use the LSBs, so 0xE0 //check for the end packet, the key state bytes use the LSBs, so 0xE0
//will only show up here if the correct bytes were recieved //will only show up here if the correct bytes were recieved
if (uart_data[10] == 0xE0) if (uart_data[10] == 0xE0) {
{
//shifting and transferring the keystates to the QMK matrix variable //shifting and transferring the keystates to the QMK matrix variable
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = (uint16_t) uart_data[i*2] | (uint16_t) uart_data[i*2+1] << 5; matrix_row_t current_row = (uint16_t) uart_data[i * 2] | (uint16_t) uart_data[i * 2 + 1] << 5;
if (current_matrix[i] != current_row) {
changed = true;
}
current_matrix[i] = current_row;
} }
} }
return changed;
matrix_scan_quantum();
return 1;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}
inline
matrix_row_t matrix_get_row(uint8_t row)
{
return matrix[row];
}
void matrix_print(void)
{
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += matrix_bitpop(i);
}
return count;
} }

View file

@ -15,12 +15,14 @@ MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = yes # Commands for debug and configuration COMMAND_ENABLE = yes # Commands for debug and configuration
CUSTOM_MATRIX = yes # Remote matrix from the wireless bridge NKRO_ENABLE = no # Enable N-Key Rollover
NKRO_ENABLE = yes # Enable N-Key Rollover
BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
UNICODE_ENABLE = yes # Unicode RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
AUDIO_ENABLE = no # Audio output
UNICODE_ENABLE = yes
CUSTOM_MATRIX = lite
# # project specific files # project specific files
SRC += matrix.c SRC += matrix.c
QUANTUM_LIB_SRC += uart.c QUANTUM_LIB_SRC += uart.c

View file

@ -15,86 +15,18 @@ GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdint.h>
#include <stdbool.h> #include "quantum.h"
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h" #include "matrix.h"
#include "timer.h"
#include "uart.h" #include "uart.h"
#if (MATRIX_COLS <= 8) void matrix_init_custom(void) {
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#endif
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
__attribute__ ((weak))
void matrix_init_quantum(void) {
matrix_init_kb();
}
__attribute__ ((weak))
void matrix_scan_quantum(void) {
matrix_scan_kb();
}
__attribute__ ((weak))
void matrix_init_kb(void) {
matrix_init_user();
}
__attribute__ ((weak))
void matrix_scan_kb(void) {
matrix_scan_user();
}
__attribute__ ((weak))
void matrix_init_user(void) {
}
__attribute__ ((weak))
void matrix_scan_user(void) {
}
inline
uint8_t matrix_rows(void) {
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
void matrix_init(void) {
matrix_init_quantum();
uart_init(1000000); uart_init(1000000);
} }
uint8_t matrix_scan(void) bool matrix_scan_custom(matrix_row_t current_matrix[]) {
{
uint32_t timeout = 0; uint32_t timeout = 0;
bool changed = false;
//the s character requests the RF slave to send the matrix //the s character requests the RF slave to send the matrix
uart_write('s'); uart_write('s');
@ -107,9 +39,9 @@ uint8_t matrix_scan(void)
//wait for the serial data, timeout if it's been too long //wait for the serial data, timeout if it's been too long
//this only happened in testing with a loose wire, but does no //this only happened in testing with a loose wire, but does no
//harm to leave it in here //harm to leave it in here
while(!uart_available()){ while (!uart_available()) {
timeout++; timeout++;
if (timeout > 10000){ if (timeout > 10000) {
break; break;
} }
} }
@ -118,47 +50,16 @@ uint8_t matrix_scan(void)
//check for the end packet, the key state bytes use the LSBs, so 0xE0 //check for the end packet, the key state bytes use the LSBs, so 0xE0
//will only show up here if the correct bytes were recieved //will only show up here if the correct bytes were recieved
if (uart_data[10] == 0xE0) if (uart_data[10] == 0xE0) {
{
//shifting and transferring the keystates to the QMK matrix variable //shifting and transferring the keystates to the QMK matrix variable
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = (uint16_t) uart_data[i*2] | (uint16_t) uart_data[i*2+1] << 6; matrix_row_t current_row = (uint16_t) uart_data[i * 2] | (uint16_t) uart_data[i * 2 + 1] << 6;
if (current_matrix[i] != current_row) {
changed = true;
}
current_matrix[i] = current_row;
} }
} }
return changed;
matrix_scan_quantum();
return 1;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}
inline
matrix_row_t matrix_get_row(uint8_t row)
{
return matrix[row];
}
void matrix_print(void)
{
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += matrix_bitpop(i);
}
return count;
} }

View file

@ -12,10 +12,12 @@ MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = yes # Commands for debug and configuration COMMAND_ENABLE = yes # Commands for debug and configuration
CUSTOM_MATRIX = yes # Remote matrix from the wireless bridge
NKRO_ENABLE = yes # Enable N-Key Rollover NKRO_ENABLE = yes # Enable N-Key Rollover
# BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
AUDIO_ENABLE = no # Audio output
CUSTOM_MATRIX = lite
# # project specific files # project specific files
SRC += matrix.c SRC += matrix.c
QUANTUM_LIB_SRC += uart.c QUANTUM_LIB_SRC += uart.c

View file

@ -15,90 +15,18 @@ GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdint.h>
#include <stdbool.h> #include "quantum.h"
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h" #include "matrix.h"
#include "timer.h"
#include "uart.h" #include "uart.h"
#if (MATRIX_COLS <= 8) void matrix_init_custom(void) {
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#elif (MATRIX_COLS <= 64)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse64(matrix_get_row(row))
# define matrix_bitpop(i) bitpop64(matrix[i])
# define ROW_SHIFTER ((uint64_t)1)
#endif
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
__attribute__ ((weak))
void matrix_init_quantum(void) {
matrix_init_kb();
}
__attribute__ ((weak))
void matrix_scan_quantum(void) {
matrix_scan_kb();
}
__attribute__ ((weak))
void matrix_init_kb(void) {
matrix_init_user();
}
__attribute__ ((weak))
void matrix_scan_kb(void) {
matrix_scan_user();
}
__attribute__ ((weak))
void matrix_init_user(void) {
}
__attribute__ ((weak))
void matrix_scan_user(void) {
}
inline
uint8_t matrix_rows(void) {
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
void matrix_init(void) {
matrix_init_quantum();
uart_init(1000000); uart_init(1000000);
} }
uint8_t matrix_scan(void) bool matrix_scan_custom(matrix_row_t current_matrix[]) {
{
uint32_t timeout = 0; uint32_t timeout = 0;
bool changed = false;
//the s character requests the RF slave to send the matrix //the s character requests the RF slave to send the matrix
uart_write('s'); uart_write('s');
@ -111,9 +39,9 @@ uint8_t matrix_scan(void)
//wait for the serial data, timeout if it's been too long //wait for the serial data, timeout if it's been too long
//this only happened in testing with a loose wire, but does no //this only happened in testing with a loose wire, but does no
//harm to leave it in here //harm to leave it in here
while(!uart_available()){ while (!uart_available()) {
timeout++; timeout++;
if (timeout > 10000){ if (timeout > 10000) {
break; break;
} }
} }
@ -122,47 +50,16 @@ uint8_t matrix_scan(void)
//check for the end packet, the key state bytes use the LSBs, so 0xE0 //check for the end packet, the key state bytes use the LSBs, so 0xE0
//will only show up here if the correct bytes were recieved //will only show up here if the correct bytes were recieved
if (uart_data[10] == 0xE0) if (uart_data[10] == 0xE0) {
{
//shifting and transferring the keystates to the QMK matrix variable //shifting and transferring the keystates to the QMK matrix variable
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = (uint16_t) uart_data[i*2] | (uint16_t) uart_data[i*2+1] << 5; matrix_row_t current_row = (uint16_t) uart_data[i * 2] | (uint16_t) uart_data[i * 2 + 1] << 5;
if (current_matrix[i] != current_row) {
changed = true;
}
current_matrix[i] = current_row;
} }
} }
return changed;
matrix_scan_quantum();
return 1;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}
inline
matrix_row_t matrix_get_row(uint8_t row)
{
return matrix[row];
}
void matrix_print(void)
{
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += matrix_bitpop(i);
}
return count;
} }

View file

@ -12,9 +12,11 @@ MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = yes # Commands for debug and configuration COMMAND_ENABLE = yes # Commands for debug and configuration
CUSTOM_MATRIX = yes # Remote matrix from the wireless bridge
NKRO_ENABLE = yes # Enable N-Key Rollover NKRO_ENABLE = yes # Enable N-Key Rollover
# BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
AUDIO_ENABLE = no # Audio output
CUSTOM_MATRIX = lite
# project specific files # project specific files
SRC += matrix.c SRC += matrix.c

View file

@ -15,76 +15,18 @@ GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdint.h>
#include <stdbool.h> #include "quantum.h"
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h" #include "matrix.h"
#include "timer.h"
#include "uart.h" #include "uart.h"
#if (MATRIX_COLS <= 8) void matrix_init_custom(void) {
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#endif
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
__attribute__ ((weak))
void matrix_init_kb(void) {
matrix_init_user();
}
__attribute__ ((weak))
void matrix_scan_kb(void) {
matrix_scan_user();
}
__attribute__ ((weak))
void matrix_init_user(void) {
}
__attribute__ ((weak))
void matrix_scan_user(void) {
}
inline
uint8_t matrix_rows(void) {
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
void matrix_init(void) {
matrix_init_quantum();
uart_init(1000000); uart_init(1000000);
} }
uint8_t matrix_scan(void) bool matrix_scan_custom(matrix_row_t current_matrix[]) {
{
uint32_t timeout = 0; uint32_t timeout = 0;
bool changed = false;
//the s character requests the RF slave to send the matrix //the s character requests the RF slave to send the matrix
uart_write('s'); uart_write('s');
@ -97,9 +39,9 @@ uint8_t matrix_scan(void)
//wait for the serial data, timeout if it's been too long //wait for the serial data, timeout if it's been too long
//this only happened in testing with a loose wire, but does no //this only happened in testing with a loose wire, but does no
//harm to leave it in here //harm to leave it in here
while(!uart_available()){ while (!uart_available()) {
timeout++; timeout++;
if (timeout > 10000){ if (timeout > 10000) {
break; break;
} }
} }
@ -108,47 +50,16 @@ uint8_t matrix_scan(void)
//check for the end packet, the key state bytes use the LSBs, so 0xE0 //check for the end packet, the key state bytes use the LSBs, so 0xE0
//will only show up here if the correct bytes were recieved //will only show up here if the correct bytes were recieved
if (uart_data[10] == 0xE0) if (uart_data[10] == 0xE0) {
{
//shifting and transferring the keystates to the QMK matrix variable //shifting and transferring the keystates to the QMK matrix variable
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = (uint16_t) uart_data[i*2] | (uint16_t) uart_data[i*2+1] << 5; matrix_row_t current_row = (uint16_t) uart_data[i * 2] | (uint16_t) uart_data[i * 2 + 1] << 5;
if (current_matrix[i] != current_row) {
changed = true;
}
current_matrix[i] = current_row;
} }
} }
return changed;
matrix_scan_quantum();
return 1;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}
inline
matrix_row_t matrix_get_row(uint8_t row)
{
return matrix[row];
}
void matrix_print(void)
{
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += matrix_bitpop(i);
}
return count;
} }

View file

@ -12,9 +12,11 @@ MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = yes # Commands for debug and configuration COMMAND_ENABLE = yes # Commands for debug and configuration
CUSTOM_MATRIX = yes # Remote matrix from the wireless bridge
NKRO_ENABLE = yes # Enable N-Key Rollover NKRO_ENABLE = yes # Enable N-Key Rollover
# BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
AUDIO_ENABLE = no # Audio output
CUSTOM_MATRIX = lite
# project specific files # project specific files
SRC += matrix.c SRC += matrix.c

View file

@ -15,76 +15,18 @@ GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdint.h>
#include <stdbool.h> #include "quantum.h"
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h" #include "matrix.h"
#include "timer.h"
#include "uart.h" #include "uart.h"
#if (MATRIX_COLS <= 8) void matrix_init_custom(void) {
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#endif
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
__attribute__ ((weak))
void matrix_init_kb(void) {
matrix_init_user();
}
__attribute__ ((weak))
void matrix_scan_kb(void) {
matrix_scan_user();
}
__attribute__ ((weak))
void matrix_init_user(void) {
}
__attribute__ ((weak))
void matrix_scan_user(void) {
}
inline
uint8_t matrix_rows(void) {
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
void matrix_init(void) {
matrix_init_quantum();
uart_init(1000000); uart_init(1000000);
} }
uint8_t matrix_scan(void) bool matrix_scan_custom(matrix_row_t current_matrix[]) {
{
uint32_t timeout = 0; uint32_t timeout = 0;
bool changed = false;
//the s character requests the RF slave to send the matrix //the s character requests the RF slave to send the matrix
uart_write('s'); uart_write('s');
@ -97,9 +39,9 @@ uint8_t matrix_scan(void)
//wait for the serial data, timeout if it's been too long //wait for the serial data, timeout if it's been too long
//this only happened in testing with a loose wire, but does no //this only happened in testing with a loose wire, but does no
//harm to leave it in here //harm to leave it in here
while(!uart_available()){ while (!uart_available()) {
timeout++; timeout++;
if (timeout > 10000){ if (timeout > 10000) {
break; break;
} }
} }
@ -108,47 +50,16 @@ uint8_t matrix_scan(void)
//check for the end packet, the key state bytes use the LSBs, so 0xE0 //check for the end packet, the key state bytes use the LSBs, so 0xE0
//will only show up here if the correct bytes were recieved //will only show up here if the correct bytes were recieved
if (uart_data[10] == 0xE0) if (uart_data[10] == 0xE0) {
{
//shifting and transferring the keystates to the QMK matrix variable //shifting and transferring the keystates to the QMK matrix variable
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = (uint16_t) uart_data[i*2] | (uint16_t) uart_data[i*2+1] << 6; matrix_row_t current_row = (uint16_t) uart_data[i * 2] | (uint16_t) uart_data[i * 2 + 1] << 6;
if (current_matrix[i] != current_row) {
changed = true;
}
current_matrix[i] = current_row;
} }
} }
return changed;
matrix_scan_quantum();
return 1;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}
inline
matrix_row_t matrix_get_row(uint8_t row)
{
return matrix[row];
}
void matrix_print(void)
{
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += matrix_bitpop(i);
}
return count;
} }

View file

@ -17,7 +17,7 @@ BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
AUDIO_ENABLE = no # Audio output AUDIO_ENABLE = no # Audio output
UNICODE_ENABLE = yes UNICODE_ENABLE = yes
CUSTOM_MATRIX = yes CUSTOM_MATRIX = lite
# project specific files # project specific files
SRC += matrix.c SRC += matrix.c

View file

@ -15,76 +15,18 @@ GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdint.h>
#include <stdbool.h> #include "quantum.h"
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h" #include "matrix.h"
#include "timer.h"
#include "uart.h" #include "uart.h"
#if (MATRIX_COLS <= 8) void matrix_init_custom(void) {
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#endif
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
__attribute__ ((weak))
void matrix_init_kb(void) {
matrix_init_user();
}
__attribute__ ((weak))
void matrix_scan_kb(void) {
matrix_scan_user();
}
__attribute__ ((weak))
void matrix_init_user(void) {
}
__attribute__ ((weak))
void matrix_scan_user(void) {
}
inline
uint8_t matrix_rows(void) {
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
void matrix_init(void) {
matrix_init_quantum();
uart_init(1000000); uart_init(1000000);
} }
uint8_t matrix_scan(void) bool matrix_scan_custom(matrix_row_t current_matrix[]) {
{
uint32_t timeout = 0; uint32_t timeout = 0;
bool changed = false;
//the s character requests the RF slave to send the matrix //the s character requests the RF slave to send the matrix
uart_write('s'); uart_write('s');
@ -97,9 +39,9 @@ uint8_t matrix_scan(void)
//wait for the serial data, timeout if it's been too long //wait for the serial data, timeout if it's been too long
//this only happened in testing with a loose wire, but does no //this only happened in testing with a loose wire, but does no
//harm to leave it in here //harm to leave it in here
while(!uart_available()){ while (!uart_available()) {
timeout++; timeout++;
if (timeout > 10000){ if (timeout > 10000) {
break; break;
} }
} }
@ -108,47 +50,16 @@ uint8_t matrix_scan(void)
//check for the end packet, the key state bytes use the LSBs, so 0xE0 //check for the end packet, the key state bytes use the LSBs, so 0xE0
//will only show up here if the correct bytes were recieved //will only show up here if the correct bytes were recieved
if (uart_data[10] == 0xE0) if (uart_data[10] == 0xE0) {
{
//shifting and transferring the keystates to the QMK matrix variable //shifting and transferring the keystates to the QMK matrix variable
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = (uint16_t) uart_data[i*2] | (uint16_t) uart_data[i*2+1] << 5; matrix_row_t current_row = (uint16_t) uart_data[i * 2] | (uint16_t) uart_data[i * 2 + 1] << 5;
if (current_matrix[i] != current_row) {
changed = true;
}
current_matrix[i] = current_row;
} }
} }
return changed;
matrix_scan_quantum();
return 1;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}
inline
matrix_row_t matrix_get_row(uint8_t row)
{
return matrix[row];
}
void matrix_print(void)
{
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += matrix_bitpop(i);
}
return count;
} }

View file

@ -12,9 +12,11 @@ MOUSEKEY_ENABLE = no # Mouse keys
EXTRAKEY_ENABLE = no # Audio control and System control EXTRAKEY_ENABLE = no # Audio control and System control
CONSOLE_ENABLE = no # Console for debug CONSOLE_ENABLE = no # Console for debug
COMMAND_ENABLE = no # Commands for debug and configuration COMMAND_ENABLE = no # Commands for debug and configuration
CUSTOM_MATRIX = yes # Remote matrix from the wireless bridge
NKRO_ENABLE = yes # Enable N-Key Rollover NKRO_ENABLE = yes # Enable N-Key Rollover
# BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
AUDIO_ENABLE = no # Audio output
CUSTOM_MATRIX = lite
# project specific files # project specific files
SRC += matrix.c \ SRC += matrix.c \

View file

@ -15,77 +15,18 @@ GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdint.h>
#include <stdbool.h> #include "quantum.h"
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h" #include "matrix.h"
#include "timer.h"
#include "uart.h" #include "uart.h"
#if (MATRIX_COLS <= 8) void matrix_init_custom(void) {
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#endif
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
__attribute__ ((weak))
void matrix_init_kb(void) {
matrix_init_user();
}
__attribute__ ((weak))
void matrix_scan_kb(void) {
matrix_scan_user();
}
__attribute__ ((weak))
void matrix_init_user(void) {
}
__attribute__ ((weak))
void matrix_scan_user(void) {
}
inline
uint8_t matrix_rows(void) {
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
void matrix_init(void) {
matrix_init_quantum();
uart_init(1000000); uart_init(1000000);
} }
uint8_t matrix_scan(void) bool matrix_scan_custom(matrix_row_t current_matrix[]) {
{
uint32_t timeout = 0; uint32_t timeout = 0;
bool changed = false;
//the s character requests the RF slave to send the matrix //the s character requests the RF slave to send the matrix
uart_write('s'); uart_write('s');
@ -98,9 +39,9 @@ uint8_t matrix_scan(void)
//wait for the serial data, timeout if it's been too long //wait for the serial data, timeout if it's been too long
//this only happened in testing with a loose wire, but does no //this only happened in testing with a loose wire, but does no
//harm to leave it in here //harm to leave it in here
while(!uart_available()){ while (!uart_available()) {
timeout++; timeout++;
if (timeout > 10000){ if (timeout > 10000) {
break; break;
} }
} }
@ -109,47 +50,16 @@ uint8_t matrix_scan(void)
//check for the end packet, the key state bytes use the LSBs, so 0xE0 //check for the end packet, the key state bytes use the LSBs, so 0xE0
//will only show up here if the correct bytes were recieved //will only show up here if the correct bytes were recieved
if (uart_data[10] == 0xE0) if (uart_data[10] == 0xE0) {
{
//shifting and transferring the keystates to the QMK matrix variable //shifting and transferring the keystates to the QMK matrix variable
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = (uint16_t) uart_data[i*2] | (uint16_t) uart_data[i*2+1] << 5; matrix_row_t current_row = (uint16_t) uart_data[i * 2] | (uint16_t) uart_data[i * 2 + 1] << 5;
if (current_matrix[i] != current_row) {
changed = true;
}
current_matrix[i] = current_row;
} }
} }
return changed;
matrix_scan_quantum();
return 1;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}
inline
matrix_row_t matrix_get_row(uint8_t row)
{
return matrix[row];
}
void matrix_print(void)
{
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += matrix_bitpop(i);
}
return count;
} }

View file

@ -12,11 +12,13 @@ MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = yes # Commands for debug and configuration COMMAND_ENABLE = yes # Commands for debug and configuration
CUSTOM_MATRIX = yes # Remote matrix from the wireless bridge
NKRO_ENABLE = yes # Enable N-Key Rollover NKRO_ENABLE = yes # Enable N-Key Rollover
# BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
UNICODE_ENABLE = yes # Unicode RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
AUDIO_ENABLE = no # Audio output
UNICODE_ENABLE = yes
CUSTOM_MATRIX = lite
# # project specific files # project specific files
SRC += matrix.c SRC += matrix.c
QUANTUM_LIB_SRC += uart.c QUANTUM_LIB_SRC += uart.c

View file

@ -13,86 +13,18 @@
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdint.h>
#include <stdbool.h> #include "quantum.h"
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h" #include "matrix.h"
#include "timer.h"
#include "uart.h" #include "uart.h"
#if (MATRIX_COLS <= 8) void matrix_init_custom(void) {
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#endif
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
__attribute__ ((weak))
void matrix_init_quantum(void) {
matrix_init_kb();
}
__attribute__ ((weak))
void matrix_scan_quantum(void) {
matrix_scan_kb();
}
__attribute__ ((weak))
void matrix_init_kb(void) {
matrix_init_user();
}
__attribute__ ((weak))
void matrix_scan_kb(void) {
matrix_scan_user();
}
__attribute__ ((weak))
void matrix_init_user(void) {
}
__attribute__ ((weak))
void matrix_scan_user(void) {
}
inline
uint8_t matrix_rows(void) {
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
void matrix_init(void) {
matrix_init_quantum();
uart_init(1000000); uart_init(1000000);
} }
uint8_t matrix_scan(void) bool matrix_scan_custom(matrix_row_t current_matrix[]) {
{
uint32_t timeout = 0; uint32_t timeout = 0;
bool changed = false;
//the s character requests the RF slave to send the matrix //the s character requests the RF slave to send the matrix
uart_write('s'); uart_write('s');
@ -105,9 +37,9 @@ uint8_t matrix_scan(void)
//wait for the serial data, timeout if it's been too long //wait for the serial data, timeout if it's been too long
//this only happened in testing with a loose wire, but does no //this only happened in testing with a loose wire, but does no
//harm to leave it in here //harm to leave it in here
while(!uart_available()){ while (!uart_available()) {
timeout++; timeout++;
if (timeout > 10000){ if (timeout > 10000) {
break; break;
} }
} }
@ -116,47 +48,16 @@ uint8_t matrix_scan(void)
//check for the end packet, the key state bytes use the LSBs, so 0xE0 //check for the end packet, the key state bytes use the LSBs, so 0xE0
//will only show up here if the correct bytes were recieved //will only show up here if the correct bytes were recieved
if (uart_data[10] == 0xE0) if (uart_data[10] == 0xE0) {
{
//shifting and transferring the keystates to the QMK matrix variable //shifting and transferring the keystates to the QMK matrix variable
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = (uint16_t) uart_data[i*2] | (uint16_t) uart_data[i*2+1] << 7; matrix_row_t current_row = (uint16_t) uart_data[i * 2] | (uint16_t) uart_data[i * 2 + 1] << 7;
if (current_matrix[i] != current_row) {
changed = true;
}
current_matrix[i] = current_row;
} }
} }
return changed;
matrix_scan_quantum();
return 1;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}
inline
matrix_row_t matrix_get_row(uint8_t row)
{
return matrix[row];
}
void matrix_print(void)
{
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += matrix_bitpop(i);
}
return count;
} }

View file

@ -12,10 +12,12 @@ MOUSEKEY_ENABLE = yes # Mouse keys
EXTRAKEY_ENABLE = yes # Audio control and System control EXTRAKEY_ENABLE = yes # Audio control and System control
CONSOLE_ENABLE = yes # Console for debug CONSOLE_ENABLE = yes # Console for debug
COMMAND_ENABLE = yes # Commands for debug and configuration COMMAND_ENABLE = yes # Commands for debug and configuration
CUSTOM_MATRIX = yes # Remote matrix from the wireless bridge
NKRO_ENABLE = yes # Enable N-Key Rollover NKRO_ENABLE = yes # Enable N-Key Rollover
# BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
AUDIO_ENABLE = no # Audio output
CUSTOM_MATRIX = lite
# # project specific files # project specific files
SRC += matrix.c SRC += matrix.c
QUANTUM_LIB_SRC += uart.c QUANTUM_LIB_SRC += uart.c

View file

@ -15,80 +15,18 @@ GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdint.h>
#include <stdbool.h> #include "quantum.h"
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h" #include "matrix.h"
#include "timer.h"
#include "debounce.h"
#include "uart.h" #include "uart.h"
#if (MATRIX_COLS <= 8) void matrix_init_custom(void) {
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#endif
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
__attribute__ ((weak))
void matrix_init_kb(void) {
matrix_init_user();
}
__attribute__ ((weak))
void matrix_scan_kb(void) {
matrix_scan_user();
}
__attribute__ ((weak))
void matrix_init_user(void) {
}
__attribute__ ((weak))
void matrix_scan_user(void) {
}
inline
uint8_t matrix_rows(void) {
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
void matrix_init(void) {
debounce_init(MATRIX_ROWS);
matrix_init_quantum();
uart_init(1000000); uart_init(1000000);
} }
uint8_t matrix_scan(void) bool matrix_scan_custom(matrix_row_t current_matrix[]) {
{
bool matrix_has_changed = false;
uint32_t timeout = 0; uint32_t timeout = 0;
bool changed = false;
//the s character requests the RF slave to send the matrix //the s character requests the RF slave to send the matrix
uart_write('s'); uart_write('s');
@ -101,9 +39,9 @@ uint8_t matrix_scan(void)
//wait for the serial data, timeout if it's been too long //wait for the serial data, timeout if it's been too long
//this only happened in testing with a loose wire, but does no //this only happened in testing with a loose wire, but does no
//harm to leave it in here //harm to leave it in here
while(!uart_available()){ while (!uart_available()) {
timeout++; timeout++;
if (timeout > 10000){ if (timeout > 10000) {
break; break;
} }
} }
@ -112,49 +50,16 @@ uint8_t matrix_scan(void)
//check for the end packet, the key state bytes use the LSBs, so 0xE0 //check for the end packet, the key state bytes use the LSBs, so 0xE0
//will only show up here if the correct bytes were recieved //will only show up here if the correct bytes were recieved
if (uart_data[10] == 0xE0) if (uart_data[10] == 0xE0) {
{
//shifting and transferring the keystates to the QMK matrix variable //shifting and transferring the keystates to the QMK matrix variable
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = (uint16_t) uart_data[i*2] | (uint16_t) uart_data[i*2+1] << 8; matrix_row_t current_row = (uint16_t) uart_data[i * 2] | (uint16_t) uart_data[i * 2 + 1] << 8;
if (current_matrix[i] != current_row) {
changed = true;
}
current_matrix[i] = current_row;
} }
} }
debounce(matrix, matrix, MATRIX_ROWS, matrix_has_changed); return changed;
matrix_scan_quantum();
return matrix_has_changed;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}
inline
matrix_row_t matrix_get_row(uint8_t row)
{
return matrix[row];
}
void matrix_print(void)
{
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += matrix_bitpop(i);
}
return count;
} }

View file

@ -17,7 +17,7 @@ BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
AUDIO_ENABLE = no # Audio output AUDIO_ENABLE = no # Audio output
UNICODE_ENABLE = yes # Unicode UNICODE_ENABLE = yes # Unicode
CUSTOM_MATRIX = yes CUSTOM_MATRIX = lite
# project specific files # project specific files
SRC += matrix.c SRC += matrix.c

View file

@ -15,80 +15,18 @@ GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdint.h>
#include <stdbool.h> #include "quantum.h"
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h" #include "matrix.h"
#include "timer.h"
#include "debounce.h"
#include "uart.h" #include "uart.h"
#if (MATRIX_COLS <= 8) void matrix_init_custom(void) {
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#endif
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
__attribute__ ((weak))
void matrix_init_kb(void) {
matrix_init_user();
}
__attribute__ ((weak))
void matrix_scan_kb(void) {
matrix_scan_user();
}
__attribute__ ((weak))
void matrix_init_user(void) {
}
__attribute__ ((weak))
void matrix_scan_user(void) {
}
inline
uint8_t matrix_rows(void) {
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
void matrix_init(void) {
debounce_init(MATRIX_ROWS);
matrix_init_quantum();
uart_init(1000000); uart_init(1000000);
} }
uint8_t matrix_scan(void) bool matrix_scan_custom(matrix_row_t current_matrix[]) {
{
bool matrix_has_changed = false;
uint32_t timeout = 0; uint32_t timeout = 0;
bool changed = false;
//the s character requests the RF slave to send the matrix //the s character requests the RF slave to send the matrix
uart_write('s'); uart_write('s');
@ -101,9 +39,9 @@ uint8_t matrix_scan(void)
//wait for the serial data, timeout if it's been too long //wait for the serial data, timeout if it's been too long
//this only happened in testing with a loose wire, but does no //this only happened in testing with a loose wire, but does no
//harm to leave it in here //harm to leave it in here
while(!uart_available()){ while (!uart_available()) {
timeout++; timeout++;
if (timeout > 10000){ if (timeout > 10000) {
break; break;
} }
} }
@ -112,49 +50,16 @@ uint8_t matrix_scan(void)
//check for the end packet, the key state bytes use the LSBs, so 0xE0 //check for the end packet, the key state bytes use the LSBs, so 0xE0
//will only show up here if the correct bytes were recieved //will only show up here if the correct bytes were recieved
if (uart_data[10] == 0xE0) if (uart_data[10] == 0xE0) {
{
//shifting and transferring the keystates to the QMK matrix variable //shifting and transferring the keystates to the QMK matrix variable
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = (uint16_t) uart_data[i*2] | (uint16_t) uart_data[i*2+1] << 8; matrix_row_t current_row = (uint16_t) uart_data[i * 2] | (uint16_t) uart_data[i * 2 + 1] << 8;
if (current_matrix[i] != current_row) {
changed = true;
}
current_matrix[i] = current_row;
} }
} }
debounce(matrix, matrix, MATRIX_ROWS, matrix_has_changed); return changed;
matrix_scan_quantum();
return matrix_has_changed;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<<col));
}
inline
matrix_row_t matrix_get_row(uint8_t row)
{
return matrix[row];
}
void matrix_print(void)
{
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
print_hex8(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += matrix_bitpop(i);
}
return count;
} }

View file

@ -17,7 +17,7 @@ BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow RGBLIGHT_ENABLE = no # Enable keyboard RGB underglow
AUDIO_ENABLE = no # Audio output AUDIO_ENABLE = no # Audio output
UNICODE_ENABLE = yes # Unicode UNICODE_ENABLE = yes # Unicode
CUSTOM_MATRIX = yes CUSTOM_MATRIX = lite
# project specific files # project specific files
SRC += matrix.c SRC += matrix.c