Simplify split_common Code significantly (#4772)
* Eliminate separate slave loop Both master and slave run the standard keyboard_task main loop now. * Refactor i2c/serial specific code Simplify some of the preprocessor mess by using common function names. * Fix missing #endif * Move direct pin mapping support from miniaxe to split_common For boards with more pins than sense--sorry, switches. * Reordering and reformatting only * Don't run matrix_scan_quantum on slave side * Clean up the offset/slaveOffset calculations * Cut undebounced matrix size in half * Refactor debouncing * Minor fixups * Split split_common transport and debounce code into their own files Can now be replaced with custom versions per keyboard using CUSTOM_TRANSPORT = yes and CUSTOM_DEBOUNCE = yes * Refactor debounce for non-split keyboards too * Update handwired/xealous to build using new split_common * Fix debounce breaking basic test * Dodgy method to allow a split kb to only include one of i2c/serial SPLIT_TRANSPORT = serial or SPLIT_TRANSPORT = i2c will include only that driver code in the binary. SPLIT_TRANSPORT = custom (or anything else) will include neither, the keyboard must supply it's own code if SPLIT_TRANSPORT is not defined then the original behaviour (include both avr i2c and serial code) is maintained. This could be better but it would require explicitly updating all the existing split keyboards. * Enable LTO to get lets_split/sockets under the line * Add docs for SPLIT_TRANSPORT, CUSTOM_MATRIX, CUSTOM_DEBOUNCE * Remove avr-specific sei() from split matrix_setup Not needed now that slave doesn't have a separate main loop. Both sides (on avr) call sei() in lufa's main() after exiting keyboard_setup(). * Fix QUANTUM_LIB_SRC references and simplify SPLIT_TRANSPORT. * Add comments and fix formatting.
This commit is contained in:
James Churchill
committed by
Drashna Jaelre
Drashna Jaelre
parent
5fcca9a226
commit
28929ad017
@ -1,5 +1,4 @@
|
||||
#ifndef I2C_H
|
||||
#define I2C_H
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
@ -58,5 +57,3 @@ extern unsigned char i2c_readNak(void);
|
||||
extern unsigned char i2c_read(unsigned char ack);
|
||||
|
||||
#define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak();
|
||||
|
||||
#endif
|
||||
|
||||
@ -25,529 +25,304 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#include "matrix.h"
|
||||
#include "split_util.h"
|
||||
#include "config.h"
|
||||
#include "timer.h"
|
||||
#include "split_flags.h"
|
||||
#include "quantum.h"
|
||||
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
# include "backlight.h"
|
||||
extern backlight_config_t backlight_config;
|
||||
#endif
|
||||
|
||||
#if defined(USE_I2C) || defined(EH)
|
||||
# include "i2c.h"
|
||||
#else // USE_SERIAL
|
||||
# include "serial.h"
|
||||
#endif
|
||||
|
||||
#ifndef DEBOUNCING_DELAY
|
||||
# define DEBOUNCING_DELAY 5
|
||||
#endif
|
||||
|
||||
#if (DEBOUNCING_DELAY > 0)
|
||||
static uint16_t debouncing_time;
|
||||
static bool debouncing = false;
|
||||
#endif
|
||||
|
||||
#if defined(USE_I2C) || defined(EH)
|
||||
#include "debounce.h"
|
||||
#include "transport.h"
|
||||
|
||||
#if (MATRIX_COLS <= 8)
|
||||
# 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)
|
||||
#else
|
||||
# error "Currently only supports 8 COLS"
|
||||
#endif
|
||||
|
||||
#else // USE_SERIAL
|
||||
|
||||
#if (MATRIX_COLS <= 8)
|
||||
# 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)
|
||||
# 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)
|
||||
# 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)
|
||||
# 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
|
||||
|
||||
#endif
|
||||
static matrix_row_t matrix_debouncing[MATRIX_ROWS];
|
||||
|
||||
#define ERROR_DISCONNECT_COUNT 5
|
||||
|
||||
#define ROWS_PER_HAND (MATRIX_ROWS/2)
|
||||
|
||||
static uint8_t error_count = 0;
|
||||
#define ROWS_PER_HAND (MATRIX_ROWS / 2)
|
||||
|
||||
#ifdef DIRECT_PINS
|
||||
static pin_t direct_pins[MATRIX_ROWS][MATRIX_COLS] = DIRECT_PINS;
|
||||
#else
|
||||
static pin_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
|
||||
static pin_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
|
||||
#endif
|
||||
|
||||
/* matrix state(1:on, 0:off) */
|
||||
static matrix_row_t matrix[MATRIX_ROWS];
|
||||
static matrix_row_t matrix_debouncing[MATRIX_ROWS];
|
||||
static matrix_row_t raw_matrix[ROWS_PER_HAND];
|
||||
|
||||
// row offsets for each hand
|
||||
uint8_t thisHand, thatHand;
|
||||
|
||||
// user-defined overridable functions
|
||||
|
||||
__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) {}
|
||||
|
||||
__attribute__((weak)) void matrix_slave_scan_user(void) {}
|
||||
|
||||
// helper functions
|
||||
|
||||
inline uint8_t matrix_rows(void) { return MATRIX_ROWS; }
|
||||
|
||||
inline uint8_t matrix_cols(void) { return MATRIX_COLS; }
|
||||
|
||||
bool matrix_is_modified(void) {
|
||||
if (debounce_active()) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
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++) {
|
||||
phex(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;
|
||||
}
|
||||
|
||||
// matrix code
|
||||
|
||||
#ifdef DIRECT_PINS
|
||||
|
||||
static void init_pins(void) {
|
||||
for (int row = 0; row < MATRIX_ROWS; row++) {
|
||||
for (int col = 0; col < MATRIX_COLS; col++) {
|
||||
pin_t pin = direct_pins[row][col];
|
||||
if (pin != NO_PIN) {
|
||||
setPinInputHigh(pin);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
|
||||
matrix_row_t last_row_value = current_matrix[current_row];
|
||||
current_matrix[current_row] = 0;
|
||||
|
||||
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
|
||||
pin_t pin = direct_pins[current_row][col_index];
|
||||
if (pin != NO_PIN) {
|
||||
current_matrix[current_row] |= readPin(pin) ? 0 : (ROW_SHIFTER << col_index);
|
||||
}
|
||||
}
|
||||
|
||||
return (last_row_value != current_matrix[current_row]);
|
||||
}
|
||||
|
||||
#elif (DIODE_DIRECTION == COL2ROW)
|
||||
|
||||
static void select_row(uint8_t row) {
|
||||
writePinLow(row_pins[row]);
|
||||
setPinOutput(row_pins[row]);
|
||||
}
|
||||
|
||||
static void unselect_row(uint8_t row) { setPinInputHigh(row_pins[row]); }
|
||||
|
||||
static void unselect_rows(void) {
|
||||
for (uint8_t x = 0; x < ROWS_PER_HAND; x++) {
|
||||
setPinInputHigh(row_pins[x]);
|
||||
}
|
||||
}
|
||||
|
||||
static void init_pins(void) {
|
||||
unselect_rows();
|
||||
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
|
||||
setPinInputHigh(col_pins[x]);
|
||||
}
|
||||
}
|
||||
|
||||
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row) {
|
||||
// Store last value of row prior to reading
|
||||
matrix_row_t last_row_value = current_matrix[current_row];
|
||||
|
||||
// Clear data in matrix row
|
||||
current_matrix[current_row] = 0;
|
||||
|
||||
// Select row and wait for row selecton to stabilize
|
||||
select_row(current_row);
|
||||
wait_us(30);
|
||||
|
||||
// For each col...
|
||||
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
|
||||
// Populate the matrix row with the state of the col pin
|
||||
current_matrix[current_row] |= readPin(col_pins[col_index]) ? 0 : (ROW_SHIFTER << col_index);
|
||||
}
|
||||
|
||||
// Unselect row
|
||||
unselect_row(current_row);
|
||||
|
||||
return (last_row_value != current_matrix[current_row]);
|
||||
}
|
||||
|
||||
#if (DIODE_DIRECTION == COL2ROW)
|
||||
static void init_cols(void);
|
||||
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
|
||||
static void unselect_rows(void);
|
||||
static void select_row(uint8_t row);
|
||||
static void unselect_row(uint8_t row);
|
||||
#elif (DIODE_DIRECTION == ROW2COL)
|
||||
static void init_rows(void);
|
||||
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
|
||||
static void unselect_cols(void);
|
||||
static void unselect_col(uint8_t col);
|
||||
static void select_col(uint8_t col);
|
||||
|
||||
static void select_col(uint8_t col) {
|
||||
writePinLow(col_pins[col]);
|
||||
setPinOutput(col_pins[col]);
|
||||
}
|
||||
|
||||
static void unselect_col(uint8_t col) { setPinInputHigh(col_pins[col]); }
|
||||
|
||||
static void unselect_cols(void) {
|
||||
for (uint8_t x = 0; x < MATRIX_COLS; x++) {
|
||||
setPinInputHigh(col_pins[x]);
|
||||
}
|
||||
}
|
||||
|
||||
static void init_pins(void) {
|
||||
unselect_cols();
|
||||
for (uint8_t x = 0; x < ROWS_PER_HAND; x++) {
|
||||
setPinInputHigh(row_pins[x]);
|
||||
}
|
||||
}
|
||||
|
||||
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col) {
|
||||
bool matrix_changed = false;
|
||||
|
||||
// Select col and wait for col selecton to stabilize
|
||||
select_col(current_col);
|
||||
wait_us(30);
|
||||
|
||||
// For each row...
|
||||
for (uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++) {
|
||||
// Store last value of row prior to reading
|
||||
matrix_row_t last_row_value = current_matrix[row_index];
|
||||
|
||||
// Check row pin state
|
||||
if (readPin(row_pins[row_index])) {
|
||||
// Pin HI, clear col bit
|
||||
current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
|
||||
} else {
|
||||
// Pin LO, set col bit
|
||||
current_matrix[row_index] |= (ROW_SHIFTER << current_col);
|
||||
}
|
||||
|
||||
// Determine if the matrix changed state
|
||||
if ((last_row_value != current_matrix[row_index]) && !(matrix_changed)) {
|
||||
matrix_changed = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Unselect col
|
||||
unselect_col(current_col);
|
||||
|
||||
return matrix_changed;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
__attribute__ ((weak))
|
||||
void matrix_init_kb(void) {
|
||||
matrix_init_user();
|
||||
}
|
||||
void matrix_init(void) {
|
||||
debug_enable = true;
|
||||
debug_matrix = true;
|
||||
debug_mouse = true;
|
||||
|
||||
__attribute__ ((weak))
|
||||
void matrix_scan_kb(void) {
|
||||
matrix_scan_user();
|
||||
}
|
||||
|
||||
__attribute__ ((weak))
|
||||
void matrix_init_user(void) {
|
||||
}
|
||||
|
||||
__attribute__ ((weak))
|
||||
void matrix_scan_user(void) {
|
||||
}
|
||||
|
||||
__attribute__ ((weak))
|
||||
void matrix_slave_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)
|
||||
{
|
||||
debug_enable = true;
|
||||
debug_matrix = true;
|
||||
debug_mouse = true;
|
||||
|
||||
// Set pinout for right half if pinout for that half is defined
|
||||
if (!isLeftHand) {
|
||||
// Set pinout for right half if pinout for that half is defined
|
||||
if (!isLeftHand) {
|
||||
#ifdef MATRIX_ROW_PINS_RIGHT
|
||||
const uint8_t row_pins_right[MATRIX_ROWS] = MATRIX_ROW_PINS_RIGHT;
|
||||
for (uint8_t i = 0; i < MATRIX_ROWS; i++)
|
||||
row_pins[i] = row_pins_right[i];
|
||||
const uint8_t row_pins_right[MATRIX_ROWS] = MATRIX_ROW_PINS_RIGHT;
|
||||
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
|
||||
row_pins[i] = row_pins_right[i];
|
||||
}
|
||||
#endif
|
||||
#ifdef MATRIX_COL_PINS_RIGHT
|
||||
const uint8_t col_pins_right[MATRIX_COLS] = MATRIX_COL_PINS_RIGHT;
|
||||
for (uint8_t i = 0; i < MATRIX_COLS; i++)
|
||||
col_pins[i] = col_pins_right[i];
|
||||
#endif
|
||||
}
|
||||
|
||||
// initialize row and col
|
||||
#if (DIODE_DIRECTION == COL2ROW)
|
||||
unselect_rows();
|
||||
init_cols();
|
||||
#elif (DIODE_DIRECTION == ROW2COL)
|
||||
unselect_cols();
|
||||
init_rows();
|
||||
#endif
|
||||
|
||||
// initialize matrix state: all keys off
|
||||
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
|
||||
matrix[i] = 0;
|
||||
matrix_debouncing[i] = 0;
|
||||
}
|
||||
|
||||
matrix_init_quantum();
|
||||
|
||||
}
|
||||
|
||||
uint8_t _matrix_scan(void)
|
||||
{
|
||||
int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
|
||||
#if (DIODE_DIRECTION == COL2ROW)
|
||||
// Set row, read cols
|
||||
for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
|
||||
# if (DEBOUNCING_DELAY > 0)
|
||||
bool matrix_changed = read_cols_on_row(matrix_debouncing+offset, current_row);
|
||||
|
||||
if (matrix_changed) {
|
||||
debouncing = true;
|
||||
debouncing_time = timer_read();
|
||||
}
|
||||
|
||||
# else
|
||||
read_cols_on_row(matrix+offset, current_row);
|
||||
# endif
|
||||
|
||||
}
|
||||
|
||||
#elif (DIODE_DIRECTION == ROW2COL)
|
||||
// Set col, read rows
|
||||
for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
|
||||
# if (DEBOUNCING_DELAY > 0)
|
||||
bool matrix_changed = read_rows_on_col(matrix_debouncing+offset, current_col);
|
||||
if (matrix_changed) {
|
||||
debouncing = true;
|
||||
debouncing_time = timer_read();
|
||||
}
|
||||
# else
|
||||
read_rows_on_col(matrix+offset, current_col);
|
||||
# endif
|
||||
|
||||
const uint8_t col_pins_right[MATRIX_COLS] = MATRIX_COL_PINS_RIGHT;
|
||||
for (uint8_t i = 0; i < MATRIX_COLS; i++) {
|
||||
col_pins[i] = col_pins_right[i];
|
||||
}
|
||||
#endif
|
||||
|
||||
# if (DEBOUNCING_DELAY > 0)
|
||||
if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) {
|
||||
for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
|
||||
matrix[i+offset] = matrix_debouncing[i+offset];
|
||||
}
|
||||
debouncing = false;
|
||||
}
|
||||
# endif
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
#if defined(USE_I2C) || defined(EH)
|
||||
|
||||
// Get rows from other half over i2c
|
||||
int i2c_transaction(void) {
|
||||
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
|
||||
int err = 0;
|
||||
|
||||
// write backlight info
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
if (BACKLIT_DIRTY) {
|
||||
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
|
||||
if (err) goto i2c_error;
|
||||
|
||||
// Backlight location
|
||||
err = i2c_master_write(I2C_BACKLIT_START);
|
||||
if (err) goto i2c_error;
|
||||
|
||||
// Write backlight
|
||||
i2c_master_write(get_backlight_level());
|
||||
|
||||
BACKLIT_DIRTY = false;
|
||||
}
|
||||
#endif
|
||||
|
||||
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
|
||||
if (err) goto i2c_error;
|
||||
|
||||
// start of matrix stored at I2C_KEYMAP_START
|
||||
err = i2c_master_write(I2C_KEYMAP_START);
|
||||
if (err) goto i2c_error;
|
||||
|
||||
// Start read
|
||||
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
|
||||
if (err) goto i2c_error;
|
||||
|
||||
if (!err) {
|
||||
int i;
|
||||
for (i = 0; i < ROWS_PER_HAND-1; ++i) {
|
||||
matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
|
||||
}
|
||||
matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
|
||||
i2c_master_stop();
|
||||
} else {
|
||||
i2c_error: // the cable is disconnceted, or something else went wrong
|
||||
i2c_reset_state();
|
||||
return err;
|
||||
}
|
||||
|
||||
#ifdef RGBLIGHT_ENABLE
|
||||
if (RGB_DIRTY) {
|
||||
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
|
||||
if (err) goto i2c_error;
|
||||
|
||||
// RGB Location
|
||||
err = i2c_master_write(I2C_RGB_START);
|
||||
if (err) goto i2c_error;
|
||||
|
||||
uint32_t dword = eeconfig_read_rgblight();
|
||||
|
||||
// Write RGB
|
||||
err = i2c_master_write_data(&dword, 4);
|
||||
if (err) goto i2c_error;
|
||||
|
||||
RGB_DIRTY = false;
|
||||
i2c_master_stop();
|
||||
}
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#else // USE_SERIAL
|
||||
|
||||
|
||||
typedef struct _Serial_s2m_buffer_t {
|
||||
// TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack
|
||||
matrix_row_t smatrix[ROWS_PER_HAND];
|
||||
} Serial_s2m_buffer_t;
|
||||
|
||||
volatile Serial_s2m_buffer_t serial_s2m_buffer = {};
|
||||
volatile Serial_m2s_buffer_t serial_m2s_buffer = {};
|
||||
uint8_t volatile status0 = 0;
|
||||
|
||||
SSTD_t transactions[] = {
|
||||
{ (uint8_t *)&status0,
|
||||
sizeof(serial_m2s_buffer), (uint8_t *)&serial_m2s_buffer,
|
||||
sizeof(serial_s2m_buffer), (uint8_t *)&serial_s2m_buffer
|
||||
}
|
||||
};
|
||||
|
||||
void serial_master_init(void)
|
||||
{ soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
|
||||
thisHand = isLeftHand ? 0 : (ROWS_PER_HAND);
|
||||
thatHand = ROWS_PER_HAND - thisHand;
|
||||
|
||||
void serial_slave_init(void)
|
||||
{ soft_serial_target_init(transactions, TID_LIMIT(transactions)); }
|
||||
// initialize key pins
|
||||
init_pins();
|
||||
|
||||
int serial_transaction(void) {
|
||||
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
|
||||
// initialize matrix state: all keys off
|
||||
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
|
||||
matrix[i] = 0;
|
||||
}
|
||||
|
||||
if (soft_serial_transaction()) {
|
||||
return 1;
|
||||
}
|
||||
debounce_init(ROWS_PER_HAND);
|
||||
|
||||
// TODO: if MATRIX_COLS > 8 change to unpack()
|
||||
for (int i = 0; i < ROWS_PER_HAND; ++i) {
|
||||
matrix[slaveOffset+i] = serial_s2m_buffer.smatrix[i];
|
||||
}
|
||||
|
||||
#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
|
||||
// Code to send RGB over serial goes here (not implemented yet)
|
||||
#endif
|
||||
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
// Write backlight level for slave to read
|
||||
serial_m2s_buffer.backlight_level = backlight_config.enable ? backlight_config.level : 0;
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
uint8_t matrix_scan(void)
|
||||
{
|
||||
uint8_t ret = _matrix_scan();
|
||||
|
||||
#if defined(USE_I2C) || defined(EH)
|
||||
if( i2c_transaction() ) {
|
||||
#else // USE_SERIAL
|
||||
if( serial_transaction() ) {
|
||||
#endif
|
||||
|
||||
error_count++;
|
||||
|
||||
if (error_count > ERROR_DISCONNECT_COUNT) {
|
||||
// reset other half if disconnected
|
||||
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
|
||||
for (int i = 0; i < ROWS_PER_HAND; ++i) {
|
||||
matrix[slaveOffset+i] = 0;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
error_count = 0;
|
||||
}
|
||||
matrix_scan_quantum();
|
||||
return ret;
|
||||
matrix_init_quantum();
|
||||
}
|
||||
|
||||
void matrix_slave_scan(void) {
|
||||
_matrix_scan();
|
||||
|
||||
int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
|
||||
|
||||
#if defined(USE_I2C) || defined(EH)
|
||||
for (int i = 0; i < ROWS_PER_HAND; ++i) {
|
||||
i2c_slave_buffer[I2C_KEYMAP_START+i] = matrix[offset+i];
|
||||
}
|
||||
#else // USE_SERIAL
|
||||
// TODO: if MATRIX_COLS > 8 change to pack()
|
||||
for (int i = 0; i < ROWS_PER_HAND; ++i) {
|
||||
serial_s2m_buffer.smatrix[i] = matrix[offset+i];
|
||||
}
|
||||
#endif
|
||||
matrix_slave_scan_user();
|
||||
}
|
||||
|
||||
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
|
||||
matrix_row_t matrix_get_row(uint8_t row)
|
||||
{
|
||||
return matrix[row];
|
||||
}
|
||||
|
||||
void matrix_print(void)
|
||||
{
|
||||
print("\nr/c 0123456789ABCDEF\n");
|
||||
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
|
||||
phex(row); print(": ");
|
||||
pbin_reverse16(matrix_get_row(row));
|
||||
print("\n");
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
#if (DIODE_DIRECTION == COL2ROW)
|
||||
|
||||
static void init_cols(void)
|
||||
{
|
||||
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
|
||||
setPinInputHigh(col_pins[x]);
|
||||
}
|
||||
}
|
||||
|
||||
static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
|
||||
{
|
||||
// Store last value of row prior to reading
|
||||
matrix_row_t last_row_value = current_matrix[current_row];
|
||||
|
||||
// Clear data in matrix row
|
||||
current_matrix[current_row] = 0;
|
||||
|
||||
// Select row and wait for row selecton to stabilize
|
||||
select_row(current_row);
|
||||
wait_us(30);
|
||||
|
||||
// For each col...
|
||||
for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
|
||||
// Populate the matrix row with the state of the col pin
|
||||
current_matrix[current_row] |= readPin(col_pins[col_index]) ? 0 : (ROW_SHIFTER << col_index);
|
||||
}
|
||||
|
||||
// Unselect row
|
||||
unselect_row(current_row);
|
||||
|
||||
return (last_row_value != current_matrix[current_row]);
|
||||
}
|
||||
|
||||
static void select_row(uint8_t row)
|
||||
{
|
||||
writePinLow(row_pins[row]);
|
||||
setPinOutput(row_pins[row]);
|
||||
}
|
||||
|
||||
static void unselect_row(uint8_t row)
|
||||
{
|
||||
setPinInputHigh(row_pins[row]);
|
||||
}
|
||||
|
||||
static void unselect_rows(void)
|
||||
{
|
||||
for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
|
||||
setPinInputHigh(row_pins[x]);
|
||||
}
|
||||
}
|
||||
uint8_t _matrix_scan(void) {
|
||||
bool changed = false;
|
||||
|
||||
#if defined(DIRECT_PINS) || (DIODE_DIRECTION == COL2ROW)
|
||||
// Set row, read cols
|
||||
for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
|
||||
changed |= read_cols_on_row(raw_matrix, current_row);
|
||||
}
|
||||
#elif (DIODE_DIRECTION == ROW2COL)
|
||||
|
||||
static void init_rows(void)
|
||||
{
|
||||
for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
|
||||
setPinInputHigh(row_pins[x]);
|
||||
}
|
||||
}
|
||||
|
||||
static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
|
||||
{
|
||||
bool matrix_changed = false;
|
||||
|
||||
// Select col and wait for col selecton to stabilize
|
||||
select_col(current_col);
|
||||
wait_us(30);
|
||||
|
||||
// For each row...
|
||||
for(uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++)
|
||||
{
|
||||
|
||||
// Store last value of row prior to reading
|
||||
matrix_row_t last_row_value = current_matrix[row_index];
|
||||
|
||||
// Check row pin state
|
||||
if (readPin(row_pins[row_index]))
|
||||
{
|
||||
// Pin HI, clear col bit
|
||||
current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Pin LO, set col bit
|
||||
current_matrix[row_index] |= (ROW_SHIFTER << current_col);
|
||||
}
|
||||
|
||||
// Determine if the matrix changed state
|
||||
if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
|
||||
{
|
||||
matrix_changed = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Unselect col
|
||||
unselect_col(current_col);
|
||||
|
||||
return matrix_changed;
|
||||
}
|
||||
|
||||
static void select_col(uint8_t col)
|
||||
{
|
||||
writePinLow(col_pins[col]);
|
||||
setPinOutput(col_pins[col]);
|
||||
}
|
||||
|
||||
static void unselect_col(uint8_t col)
|
||||
{
|
||||
setPinInputHigh(col_pins[col]);
|
||||
}
|
||||
|
||||
static void unselect_cols(void)
|
||||
{
|
||||
for(uint8_t x = 0; x < MATRIX_COLS; x++) {
|
||||
setPinInputHigh(col_pins[x]);
|
||||
}
|
||||
}
|
||||
|
||||
// Set col, read rows
|
||||
for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
|
||||
changed |= read_rows_on_col(raw_matrix, current_col);
|
||||
}
|
||||
#endif
|
||||
|
||||
debounce(raw_matrix, matrix + thisHand, ROWS_PER_HAND, changed);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
uint8_t matrix_scan(void) {
|
||||
uint8_t ret = _matrix_scan();
|
||||
|
||||
if (is_keyboard_master()) {
|
||||
static uint8_t error_count;
|
||||
|
||||
if (!transport_master(matrix + thatHand)) {
|
||||
error_count++;
|
||||
|
||||
if (error_count > ERROR_DISCONNECT_COUNT) {
|
||||
// reset other half if disconnected
|
||||
for (int i = 0; i < ROWS_PER_HAND; ++i) {
|
||||
matrix[thatHand + i] = 0;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
error_count = 0;
|
||||
}
|
||||
|
||||
matrix_scan_quantum();
|
||||
} else {
|
||||
transport_slave(matrix + thisHand);
|
||||
matrix_slave_scan_user();
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -1,31 +1,3 @@
|
||||
#ifndef SPLIT_COMMON_MATRIX_H
|
||||
#define SPLIT_COMMON_MATRIX_H
|
||||
#pragma once
|
||||
|
||||
#include <common/matrix.h>
|
||||
|
||||
#ifdef RGBLIGHT_ENABLE
|
||||
# include "rgblight.h"
|
||||
#endif
|
||||
|
||||
typedef struct _Serial_m2s_buffer_t {
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
uint8_t backlight_level;
|
||||
#endif
|
||||
#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
|
||||
rgblight_config_t rgblight_config; //not yet use
|
||||
//
|
||||
// When MCUs on both sides drive their respective RGB LED chains,
|
||||
// it is necessary to synchronize, so it is necessary to communicate RGB information.
|
||||
// In that case, define the RGBLIGHT_SPLIT macro.
|
||||
//
|
||||
// Otherwise, if the master side MCU drives both sides RGB LED chains,
|
||||
// there is no need to communicate.
|
||||
#endif
|
||||
} Serial_m2s_buffer_t;
|
||||
|
||||
extern volatile Serial_m2s_buffer_t serial_m2s_buffer;
|
||||
|
||||
void serial_master_init(void);
|
||||
void serial_slave_init(void);
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
#ifndef SOFT_SERIAL_H
|
||||
#define SOFT_SERIAL_H
|
||||
#pragma once
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
@ -61,5 +60,3 @@ int soft_serial_transaction(int sstd_index);
|
||||
#ifdef SERIAL_USE_MULTI_TRANSACTION
|
||||
int soft_serial_get_and_clean_status(int sstd_index);
|
||||
#endif
|
||||
|
||||
#endif /* SOFT_SERIAL_H */
|
||||
|
||||
@ -1,10 +1,9 @@
|
||||
#ifndef SPLIT_FLAGS_H
|
||||
#define SPLIT_FLAGS_H
|
||||
#pragma once
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/**
|
||||
/**
|
||||
* Global Flags
|
||||
**/
|
||||
|
||||
@ -14,7 +13,3 @@ extern volatile bool RGB_DIRTY;
|
||||
|
||||
//Backlight Stuff
|
||||
extern volatile bool BACKLIT_DIRTY;
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
@ -4,142 +4,84 @@
|
||||
#include "config.h"
|
||||
#include "timer.h"
|
||||
#include "split_flags.h"
|
||||
#include "transport.h"
|
||||
#include "quantum.h"
|
||||
|
||||
#ifdef EE_HANDS
|
||||
# include "tmk_core/common/eeprom.h"
|
||||
#endif
|
||||
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
# include "backlight.h"
|
||||
#endif
|
||||
|
||||
#if defined(USE_I2C) || defined(EH)
|
||||
# include "i2c.h"
|
||||
# include "eeconfig.h"
|
||||
#endif
|
||||
|
||||
volatile bool isLeftHand = true;
|
||||
|
||||
volatile uint8_t setTries = 0;
|
||||
|
||||
static void setup_handedness(void) {
|
||||
__attribute__((weak))
|
||||
bool is_keyboard_left(void) {
|
||||
#ifdef SPLIT_HAND_PIN
|
||||
// Test pin SPLIT_HAND_PIN for High/Low, if low it's right hand
|
||||
setPinInput(SPLIT_HAND_PIN);
|
||||
isLeftHand = readPin(SPLIT_HAND_PIN);
|
||||
return readPin(SPLIT_HAND_PIN);
|
||||
#else
|
||||
#ifdef EE_HANDS
|
||||
isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS);
|
||||
return eeprom_read_byte(EECONFIG_HANDEDNESS);
|
||||
#else
|
||||
#ifdef MASTER_RIGHT
|
||||
isLeftHand = !has_usb();
|
||||
return !is_keyboard_master();
|
||||
#else
|
||||
isLeftHand = has_usb();
|
||||
return is_keyboard_master();
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
bool is_keyboard_master(void)
|
||||
{
|
||||
#ifdef __AVR__
|
||||
static enum { UNKNOWN, MASTER, SLAVE } usbstate = UNKNOWN;
|
||||
|
||||
// only check once, as this is called often
|
||||
if (usbstate == UNKNOWN)
|
||||
{
|
||||
USBCON |= (1 << OTGPADE); // enables VBUS pad
|
||||
wait_us(5);
|
||||
|
||||
usbstate = (USBSTA & (1 << VBUS)) ? MASTER : SLAVE; // checks state of VBUS
|
||||
}
|
||||
|
||||
return (usbstate == MASTER);
|
||||
#else
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
|
||||
static void keyboard_master_setup(void) {
|
||||
#if defined(USE_I2C) || defined(EH)
|
||||
i2c_master_init();
|
||||
#ifdef SSD1306OLED
|
||||
matrix_master_OLED_init ();
|
||||
#endif
|
||||
#else
|
||||
serial_master_init();
|
||||
#endif
|
||||
transport_master_init();
|
||||
|
||||
// For master the Backlight info needs to be sent on startup
|
||||
// Otherwise the salve won't start with the proper info until an update
|
||||
BACKLIT_DIRTY = true;
|
||||
// For master the Backlight info needs to be sent on startup
|
||||
// Otherwise the salve won't start with the proper info until an update
|
||||
BACKLIT_DIRTY = true;
|
||||
}
|
||||
|
||||
static void keyboard_slave_setup(void) {
|
||||
timer_init();
|
||||
#if defined(USE_I2C) || defined(EH)
|
||||
i2c_slave_init(SLAVE_I2C_ADDRESS);
|
||||
#else
|
||||
serial_slave_init();
|
||||
#endif
|
||||
}
|
||||
|
||||
bool has_usb(void) {
|
||||
USBCON |= (1 << OTGPADE); //enables VBUS pad
|
||||
_delay_us(5);
|
||||
return (USBSTA & (1<<VBUS)); //checks state of VBUS
|
||||
}
|
||||
|
||||
void split_keyboard_setup(void) {
|
||||
setup_handedness();
|
||||
|
||||
if (has_usb()) {
|
||||
keyboard_master_setup();
|
||||
} else {
|
||||
keyboard_slave_setup();
|
||||
}
|
||||
sei();
|
||||
}
|
||||
|
||||
void keyboard_slave_loop(void) {
|
||||
matrix_init();
|
||||
|
||||
//Init RGB
|
||||
#ifdef RGBLIGHT_ENABLE
|
||||
rgblight_init();
|
||||
#endif
|
||||
|
||||
while (1) {
|
||||
// Matrix Slave Scan
|
||||
matrix_slave_scan();
|
||||
|
||||
// Read Backlight Info
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
#ifdef USE_I2C
|
||||
if (BACKLIT_DIRTY) {
|
||||
backlight_set(i2c_slave_buffer[I2C_BACKLIT_START]);
|
||||
BACKLIT_DIRTY = false;
|
||||
}
|
||||
#else // USE_SERIAL
|
||||
backlight_set(serial_m2s_buffer.backlight_level);
|
||||
#endif
|
||||
#endif
|
||||
// Read RGB Info
|
||||
#ifdef RGBLIGHT_ENABLE
|
||||
#ifdef USE_I2C
|
||||
if (RGB_DIRTY) {
|
||||
// Disable interupts (RGB data is big)
|
||||
cli();
|
||||
// Create new DWORD for RGB data
|
||||
uint32_t dword;
|
||||
|
||||
// Fill the new DWORD with the data that was sent over
|
||||
uint8_t *dword_dat = (uint8_t *)(&dword);
|
||||
for (int i = 0; i < 4; i++) {
|
||||
dword_dat[i] = i2c_slave_buffer[I2C_RGB_START+i];
|
||||
}
|
||||
|
||||
// Update the RGB now with the new data and set RGB_DIRTY to false
|
||||
rgblight_update_dword(dword);
|
||||
RGB_DIRTY = false;
|
||||
// Re-enable interupts now that RGB is set
|
||||
sei();
|
||||
}
|
||||
#else // USE_SERIAL
|
||||
#ifdef RGBLIGHT_SPLIT
|
||||
// Add serial implementation for RGB here
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
static void keyboard_slave_setup(void)
|
||||
{
|
||||
transport_slave_init();
|
||||
}
|
||||
|
||||
// this code runs before the usb and keyboard is initialized
|
||||
void matrix_setup(void) {
|
||||
split_keyboard_setup();
|
||||
void matrix_setup(void)
|
||||
{
|
||||
isLeftHand = is_keyboard_left();
|
||||
|
||||
if (!has_usb()) {
|
||||
//rgblight_init();
|
||||
keyboard_slave_loop();
|
||||
}
|
||||
if (is_keyboard_master())
|
||||
{
|
||||
keyboard_master_setup();
|
||||
}
|
||||
else
|
||||
{
|
||||
keyboard_slave_setup();
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,23 +1,10 @@
|
||||
#ifndef SPLIT_KEYBOARD_UTIL_H
|
||||
#define SPLIT_KEYBOARD_UTIL_H
|
||||
#pragma once
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include "eeconfig.h"
|
||||
|
||||
#define SLAVE_I2C_ADDRESS 0x32
|
||||
|
||||
extern volatile bool isLeftHand;
|
||||
|
||||
// slave version of matix scan, defined in matrix.c
|
||||
void matrix_slave_scan(void);
|
||||
|
||||
void split_keyboard_setup(void);
|
||||
bool has_usb(void);
|
||||
void keyboard_slave_loop(void);
|
||||
|
||||
void matrix_master_OLED_init (void);
|
||||
|
||||
#endif
|
||||
|
||||
224
quantum/split_common/transport.c
Normal file
224
quantum/split_common/transport.c
Normal file
@ -0,0 +1,224 @@
|
||||
|
||||
#include "config.h"
|
||||
#include "matrix.h"
|
||||
#include "quantum.h"
|
||||
|
||||
#define ROWS_PER_HAND (MATRIX_ROWS/2)
|
||||
|
||||
#ifdef RGBLIGHT_ENABLE
|
||||
# include "rgblight.h"
|
||||
#endif
|
||||
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
# include "backlight.h"
|
||||
extern backlight_config_t backlight_config;
|
||||
#endif
|
||||
|
||||
#if defined(USE_I2C) || defined(EH)
|
||||
|
||||
#include "i2c.h"
|
||||
|
||||
#ifndef SLAVE_I2C_ADDRESS
|
||||
# define SLAVE_I2C_ADDRESS 0x32
|
||||
#endif
|
||||
|
||||
#if (MATRIX_COLS > 8)
|
||||
# error "Currently only supports 8 COLS"
|
||||
#endif
|
||||
|
||||
// Get rows from other half over i2c
|
||||
bool transport_master(matrix_row_t matrix[]) {
|
||||
int err = 0;
|
||||
|
||||
// write backlight info
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
if (BACKLIT_DIRTY) {
|
||||
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
|
||||
if (err) { goto i2c_error; }
|
||||
|
||||
// Backlight location
|
||||
err = i2c_master_write(I2C_BACKLIT_START);
|
||||
if (err) { goto i2c_error; }
|
||||
|
||||
// Write backlight
|
||||
i2c_master_write(get_backlight_level());
|
||||
|
||||
BACKLIT_DIRTY = false;
|
||||
}
|
||||
#endif
|
||||
|
||||
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
|
||||
if (err) { goto i2c_error; }
|
||||
|
||||
// start of matrix stored at I2C_KEYMAP_START
|
||||
err = i2c_master_write(I2C_KEYMAP_START);
|
||||
if (err) { goto i2c_error; }
|
||||
|
||||
// Start read
|
||||
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
|
||||
if (err) { goto i2c_error; }
|
||||
|
||||
if (!err) {
|
||||
int i;
|
||||
for (i = 0; i < ROWS_PER_HAND-1; ++i) {
|
||||
matrix[i] = i2c_master_read(I2C_ACK);
|
||||
}
|
||||
matrix[i] = i2c_master_read(I2C_NACK);
|
||||
i2c_master_stop();
|
||||
} else {
|
||||
i2c_error: // the cable is disconnceted, or something else went wrong
|
||||
i2c_reset_state();
|
||||
return false;
|
||||
}
|
||||
|
||||
#ifdef RGBLIGHT_ENABLE
|
||||
if (RGB_DIRTY) {
|
||||
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
|
||||
if (err) { goto i2c_error; }
|
||||
|
||||
// RGB Location
|
||||
err = i2c_master_write(I2C_RGB_START);
|
||||
if (err) { goto i2c_error; }
|
||||
|
||||
uint32_t dword = eeconfig_read_rgblight();
|
||||
|
||||
// Write RGB
|
||||
err = i2c_master_write_data(&dword, 4);
|
||||
if (err) { goto i2c_error; }
|
||||
|
||||
RGB_DIRTY = false;
|
||||
i2c_master_stop();
|
||||
}
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void transport_slave(matrix_row_t matrix[]) {
|
||||
|
||||
for (int i = 0; i < ROWS_PER_HAND; ++i)
|
||||
{
|
||||
i2c_slave_buffer[I2C_KEYMAP_START + i] = matrix[i];
|
||||
}
|
||||
// Read Backlight Info
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
if (BACKLIT_DIRTY)
|
||||
{
|
||||
backlight_set(i2c_slave_buffer[I2C_BACKLIT_START]);
|
||||
BACKLIT_DIRTY = false;
|
||||
}
|
||||
#endif
|
||||
#ifdef RGBLIGHT_ENABLE
|
||||
if (RGB_DIRTY)
|
||||
{
|
||||
// Disable interupts (RGB data is big)
|
||||
cli();
|
||||
// Create new DWORD for RGB data
|
||||
uint32_t dword;
|
||||
|
||||
// Fill the new DWORD with the data that was sent over
|
||||
uint8_t * dword_dat = (uint8_t *)(&dword);
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
dword_dat[i] = i2c_slave_buffer[I2C_RGB_START + i];
|
||||
}
|
||||
|
||||
// Update the RGB now with the new data and set RGB_DIRTY to false
|
||||
rgblight_update_dword(dword);
|
||||
RGB_DIRTY = false;
|
||||
// Re-enable interupts now that RGB is set
|
||||
sei();
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void transport_master_init(void) {
|
||||
i2c_master_init();
|
||||
}
|
||||
|
||||
void transport_slave_init(void) {
|
||||
i2c_slave_init(SLAVE_I2C_ADDRESS);
|
||||
}
|
||||
|
||||
#else // USE_SERIAL
|
||||
|
||||
#include "serial.h"
|
||||
|
||||
typedef struct _Serial_s2m_buffer_t {
|
||||
// TODO: if MATRIX_COLS > 8 change to uint8_t packed_matrix[] for pack/unpack
|
||||
matrix_row_t smatrix[ROWS_PER_HAND];
|
||||
} Serial_s2m_buffer_t;
|
||||
|
||||
typedef struct _Serial_m2s_buffer_t {
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
uint8_t backlight_level;
|
||||
#endif
|
||||
#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
|
||||
rgblight_config_t rgblight_config; //not yet use
|
||||
//
|
||||
// When MCUs on both sides drive their respective RGB LED chains,
|
||||
// it is necessary to synchronize, so it is necessary to communicate RGB information.
|
||||
// In that case, define the RGBLIGHT_SPLIT macro.
|
||||
//
|
||||
// Otherwise, if the master side MCU drives both sides RGB LED chains,
|
||||
// there is no need to communicate.
|
||||
#endif
|
||||
} Serial_m2s_buffer_t;
|
||||
|
||||
volatile Serial_s2m_buffer_t serial_s2m_buffer = {};
|
||||
volatile Serial_m2s_buffer_t serial_m2s_buffer = {};
|
||||
uint8_t volatile status0 = 0;
|
||||
|
||||
SSTD_t transactions[] = {
|
||||
{ (uint8_t *)&status0,
|
||||
sizeof(serial_m2s_buffer), (uint8_t *)&serial_m2s_buffer,
|
||||
sizeof(serial_s2m_buffer), (uint8_t *)&serial_s2m_buffer
|
||||
}
|
||||
};
|
||||
|
||||
void transport_master_init(void)
|
||||
{ soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); }
|
||||
|
||||
void transport_slave_init(void)
|
||||
{ soft_serial_target_init(transactions, TID_LIMIT(transactions)); }
|
||||
|
||||
bool transport_master(matrix_row_t matrix[]) {
|
||||
|
||||
if (soft_serial_transaction()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// TODO: if MATRIX_COLS > 8 change to unpack()
|
||||
for (int i = 0; i < ROWS_PER_HAND; ++i) {
|
||||
matrix[i] = serial_s2m_buffer.smatrix[i];
|
||||
}
|
||||
|
||||
#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
|
||||
// Code to send RGB over serial goes here (not implemented yet)
|
||||
#endif
|
||||
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
// Write backlight level for slave to read
|
||||
serial_m2s_buffer.backlight_level = backlight_config.enable ? backlight_config.level : 0;
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void transport_slave(matrix_row_t matrix[]) {
|
||||
|
||||
// TODO: if MATRIX_COLS > 8 change to pack()
|
||||
for (int i = 0; i < ROWS_PER_HAND; ++i)
|
||||
{
|
||||
serial_s2m_buffer.smatrix[i] = matrix[i];
|
||||
}
|
||||
#ifdef BACKLIGHT_ENABLE
|
||||
backlight_set(serial_m2s_buffer.backlight_level);
|
||||
#endif
|
||||
#if defined(RGBLIGHT_ENABLE) && defined(RGBLIGHT_SPLIT)
|
||||
// Add serial implementation for RGB here
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
10
quantum/split_common/transport.h
Normal file
10
quantum/split_common/transport.h
Normal file
@ -0,0 +1,10 @@
|
||||
#pragma once
|
||||
|
||||
#include <common/matrix.h>
|
||||
|
||||
void transport_master_init(void);
|
||||
void transport_slave_init(void);
|
||||
|
||||
// returns false if valid data not received from slave
|
||||
bool transport_master(matrix_row_t matrix[]);
|
||||
void transport_slave(matrix_row_t matrix[]);
|
||||
Reference in New Issue
Block a user