You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
364 lines
13 KiB
364 lines
13 KiB
/* Copyright 2019 ENDO Katsuhiro <ka2hiro@kagizaraya.jp>
|
|
*
|
|
* 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 <stdint.h>
|
|
#include <stdbool.h>
|
|
#include "wait.h"
|
|
#include "print.h"
|
|
#include "debug.h"
|
|
#include "matrix.h"
|
|
#include "quantum.h"
|
|
#include "board.h"
|
|
#include "i2c_master.h"
|
|
|
|
static board_info_t boards[NUM_BOARDS] = BOARD_INFOS;
|
|
static board_info_t* master_board = NULL;
|
|
|
|
static bool board_is_master(board_info_t* board);
|
|
static bool board_is_initialized(board_info_t* board);
|
|
static board_info_t* get_board_by_index(uint8_t board_index);
|
|
static uint8_t board_merge_led_config(board_info_t* board, uint8_t iodir);
|
|
static uint8_t board_merge_led_status(board_info_t* board, uint8_t data);
|
|
static void board_master_init(void);
|
|
static void board_slave_init(void);
|
|
|
|
//
|
|
// board interface
|
|
//
|
|
static void board_select_master_row(board_info_t* board, uint8_t row);
|
|
static void board_unselect_master_row(board_info_t* board, uint8_t row);
|
|
static void board_unselect_master_rows(board_info_t* board);
|
|
static bool board_read_cols_on_master_row(board_info_t* board, matrix_row_t current_matrix[], uint8_t row);
|
|
static void board_set_master_led(board_info_t* board, uint8_t led_index, bool status);
|
|
static void board_select_slave_row(board_info_t* board, uint8_t row);
|
|
static void board_unselect_slave_row(board_info_t* board, uint8_t row);
|
|
static void board_unselect_slave_rows(board_info_t* board);
|
|
static bool board_read_cols_on_slave_row(board_info_t* board, matrix_row_t current_matrix[], uint8_t row);
|
|
static void board_set_slave_led(board_info_t* board, uint8_t led_index, bool status);
|
|
|
|
static board_interface_t master_interface = {board_select_master_row, board_unselect_master_row, board_unselect_master_rows, board_read_cols_on_master_row, board_set_master_led};
|
|
static board_interface_t slave_interface = {board_select_slave_row, board_unselect_slave_row, board_unselect_slave_rows, board_read_cols_on_slave_row, board_set_slave_led};
|
|
|
|
static board_interface_t* get_interface(board_info_t* board) {
|
|
if (board_is_master(board)) {
|
|
return &master_interface;
|
|
}
|
|
return &slave_interface;
|
|
}
|
|
|
|
static void board_set_master_led(board_info_t* board, uint8_t led_index, bool status) {
|
|
pin_t pin = board->led_pins[led_index];
|
|
board->led_status[led_index] = status;
|
|
setPinOutput(pin);
|
|
status ? writePinHigh(pin) : writePinLow(pin);
|
|
}
|
|
|
|
static void board_set_slave_led(board_info_t* board, uint8_t led_index, bool status) {
|
|
board->led_status[led_index] = status;
|
|
uint8_t iodir = board_merge_led_config(board, 0xff);
|
|
uint8_t data = board_merge_led_status(board, 0x00);
|
|
i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_IODIRB, (const uint8_t*)&iodir, sizeof(iodir), BOARD_I2C_TIMEOUT);
|
|
i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_OLATB, (const uint8_t*)&data, sizeof(data), BOARD_I2C_TIMEOUT);
|
|
}
|
|
|
|
static uint8_t board_merge_led_config(board_info_t* board, uint8_t iodir) {
|
|
for (uint8_t i = 0; i < NUM_LEDS; i++) {
|
|
iodir &= PIN2MASK(board->led_pins[i]);
|
|
}
|
|
return iodir;
|
|
}
|
|
|
|
static bool board_slave_config(board_info_t* board) {
|
|
uint8_t set = 0xff;
|
|
uint8_t clear = 0x00;
|
|
i2c_status_t res = 0;
|
|
|
|
// Set to input
|
|
res = i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_IODIRA, (const uint8_t*)&set, sizeof(set), BOARD_I2C_TIMEOUT);
|
|
if (res < 0) return false;
|
|
// RESTRICTION: LEDs only on PORT B.
|
|
set = board_merge_led_config(board, set);
|
|
res = i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_IODIRB, (const uint8_t*)&set, sizeof(set), BOARD_I2C_TIMEOUT);
|
|
if (res < 0) return false;
|
|
set = 0xff;
|
|
|
|
// Pull up for input - enable
|
|
res = i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_GPPUA, (const uint8_t*)&set, sizeof(set), BOARD_I2C_TIMEOUT);
|
|
if (res < 0) return false;
|
|
res = i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_GPPUB, (const uint8_t*)&set, sizeof(set), BOARD_I2C_TIMEOUT);
|
|
if (res < 0) return false;
|
|
|
|
// Disable interrupt
|
|
res = i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_GPINTENA, (const uint8_t*)&clear, sizeof(clear), BOARD_I2C_TIMEOUT);
|
|
if (res < 0) return false;
|
|
res = i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_GPINTENB, (const uint8_t*)&clear, sizeof(clear), BOARD_I2C_TIMEOUT);
|
|
if (res < 0) return false;
|
|
|
|
// Polarity - same logic
|
|
res = i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_IPOLA, (const uint8_t*)&clear, sizeof(clear), BOARD_I2C_TIMEOUT);
|
|
if (res < 0) return false;
|
|
res = i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_IPOLB, (const uint8_t*)&clear, sizeof(clear), BOARD_I2C_TIMEOUT);
|
|
if (res < 0) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static void board_slave_init(void) {
|
|
i2c_init();
|
|
_delay_ms(500);
|
|
|
|
for (uint8_t i = 0; i < NUM_BOARDS; i++) {
|
|
board_info_t* board = &boards[i];
|
|
if (board_is_master(board)) {
|
|
continue;
|
|
}
|
|
if (i2c_start(EXPANDER_ADDR(board->i2c_address), BOARD_I2C_TIMEOUT) != I2C_STATUS_SUCCESS) {
|
|
continue;
|
|
}
|
|
i2c_stop();
|
|
if (board_slave_config(board)) {
|
|
board->initialized = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
inline bool board_is_master(board_info_t* board) {
|
|
if (board) {
|
|
return board->master;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline uint8_t matrix2board(uint8_t row) { return row % NUM_ROWS; }
|
|
|
|
inline uint8_t board_index(uint8_t row) { return row / NUM_ROWS; }
|
|
|
|
static board_info_t* get_master_board(void) {
|
|
if (master_board == NULL) {
|
|
for (uint8_t i = 0; i < NUM_BOARDS; i++) {
|
|
if (boards[i].master) {
|
|
master_board = &boards[i];
|
|
return master_board;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
inline bool board_is_initialized(board_info_t* board) { return board == NULL ? false : board->initialized; }
|
|
|
|
static board_info_t* get_board_by_index(uint8_t board_index) {
|
|
if (board_index >= 0 && board_index < NUM_BOARDS) {
|
|
if (!board_is_initialized(&boards[board_index])) {
|
|
return NULL;
|
|
}
|
|
return &boards[board_index];
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static board_info_t* get_board(uint8_t row) {
|
|
uint8_t idx = board_index(row);
|
|
if (idx >= 0 && idx < NUM_BOARDS) {
|
|
if (!board_is_initialized(&boards[idx])) {
|
|
return NULL;
|
|
}
|
|
return &boards[idx];
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static uint8_t board_merge_led_status(board_info_t* board, uint8_t data) {
|
|
if (!board_is_initialized(board)) {
|
|
return data;
|
|
}
|
|
for (uint8_t i = 0; i < NUM_LEDS; i++) {
|
|
bool status = board->led_status[i];
|
|
if (status) {
|
|
data |= (uint8_t)1 << PIN2INDEX(board->led_pins[i]);
|
|
} else {
|
|
data &= PIN2MASK(board->led_pins[i]);
|
|
}
|
|
}
|
|
return data;
|
|
}
|
|
|
|
//
|
|
// Functions for slave
|
|
//
|
|
static uint8_t board_read_slave_cols(board_info_t* board) {
|
|
if (!board_is_initialized(board)) {
|
|
return 0xff;
|
|
}
|
|
uint8_t data = 0xff;
|
|
i2c_status_t res = i2c_readReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_GPIOA, &data, sizeof(data), BOARD_I2C_TIMEOUT);
|
|
return (res < 0) ? 0xff : data;
|
|
}
|
|
|
|
static void board_select_slave_row(board_info_t* board, uint8_t board_row) {
|
|
if (!board_is_initialized(board)) {
|
|
return;
|
|
}
|
|
uint8_t pin = board->row_pins[board_row];
|
|
uint8_t iodir = board_merge_led_config(board, PIN2MASK(pin));
|
|
uint8_t status = board_merge_led_status(board, PIN2MASK(pin));
|
|
i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_IODIRB, (const uint8_t*)&iodir, sizeof(iodir), BOARD_I2C_TIMEOUT);
|
|
i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_OLATB, (const uint8_t*)&status, sizeof(status), BOARD_I2C_TIMEOUT);
|
|
}
|
|
|
|
static void board_unselect_slave_rows(board_info_t* board) {
|
|
if (!board_is_initialized(board)) {
|
|
return;
|
|
}
|
|
uint8_t iodir = board_merge_led_config(board, 0xff);
|
|
uint8_t data = board_merge_led_status(board, 0x00);
|
|
i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_IODIRB, (const uint8_t*)&iodir, sizeof(iodir), BOARD_I2C_TIMEOUT);
|
|
i2c_writeReg(EXPANDER_ADDR(board->i2c_address), EXPANDER_OLATB, (const uint8_t*)&data, sizeof(data), BOARD_I2C_TIMEOUT);
|
|
}
|
|
|
|
static void board_unselect_slave_row(board_info_t* board, uint8_t board_row) { board_unselect_slave_rows(board); }
|
|
|
|
/*
|
|
* row : matrix row (not board row)
|
|
*/
|
|
static bool board_read_cols_on_slave_row(board_info_t* board, matrix_row_t current_matrix[], uint8_t row) {
|
|
matrix_row_t last_row_value = current_matrix[row];
|
|
current_matrix[row] = 0;
|
|
|
|
uint8_t board_row = matrix2board(row);
|
|
board_select_slave_row(board, board_row);
|
|
wait_us(30);
|
|
|
|
uint8_t cols = board_read_slave_cols(board);
|
|
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
|
|
uint8_t pin = board->col_pins[col_index];
|
|
uint8_t pin_state = cols & PIN2BIT(pin);
|
|
current_matrix[row] |= pin_state ? 0 : (1 << col_index);
|
|
}
|
|
board_unselect_slave_row(board, board_row);
|
|
|
|
return (last_row_value != current_matrix[row]);
|
|
}
|
|
|
|
//
|
|
// Functions for master board
|
|
//
|
|
static void board_select_master_row(board_info_t* board, uint8_t board_row) {
|
|
setPinOutput(board->row_pins[board_row]);
|
|
writePinLow(board->row_pins[board_row]);
|
|
}
|
|
|
|
static void board_unselect_master_row(board_info_t* board, uint8_t board_row) { setPinInputHigh(board->row_pins[board_row]); }
|
|
|
|
static void board_unselect_master_rows(board_info_t* board) {
|
|
if (!board) {
|
|
return;
|
|
}
|
|
for (uint8_t x = 0; x < NUM_ROWS; x++) {
|
|
setPinInput(board->row_pins[x]);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* row : matrix row (not board row)
|
|
*/
|
|
static bool board_read_cols_on_master_row(board_info_t* board, matrix_row_t current_matrix[], uint8_t row) {
|
|
matrix_row_t last_row_value = current_matrix[row];
|
|
current_matrix[row] = 0;
|
|
|
|
uint8_t board_row = matrix2board(row);
|
|
board_select_master_row(board, board_row);
|
|
wait_us(30);
|
|
|
|
for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
|
|
uint8_t pin_state = readPin(board->col_pins[col_index]);
|
|
current_matrix[row] |= pin_state ? 0 : (1 << col_index);
|
|
}
|
|
board_unselect_master_row(board, board_row);
|
|
|
|
return (last_row_value != current_matrix[row]);
|
|
}
|
|
|
|
static void board_master_init(void) {
|
|
board_info_t* board = get_master_board();
|
|
if (!board) {
|
|
return;
|
|
}
|
|
for (uint8_t x = 0; x < NUM_COLS; x++) {
|
|
setPinInputHigh(board->col_pins[x]);
|
|
}
|
|
board->initialized = true;
|
|
}
|
|
|
|
static void board_setup(void) {
|
|
for (uint8_t i = 0; i < NUM_BOARDS; i++) {
|
|
board_info_t* board = &boards[i];
|
|
board->interface = get_interface(board);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Public functions
|
|
//
|
|
|
|
// NOTE: Do not call this while matrix scanning...
|
|
void board_set_led_by_index(uint8_t board_index, uint8_t led_index, bool status) {
|
|
board_info_t* board = get_board_by_index(board_index);
|
|
if (!board) return;
|
|
if (led_index < 0 || led_index > NUM_LEDS) return;
|
|
(*board->interface->set_led)(board, led_index, status);
|
|
}
|
|
|
|
bool board_read_cols_on_row(matrix_row_t current_matrix[], uint8_t row) {
|
|
bool result = false;
|
|
board_info_t* board = get_board(row);
|
|
if (!board) {
|
|
return false;
|
|
}
|
|
result = (*board->interface->read_cols_on_row)(board, current_matrix, row);
|
|
return result;
|
|
}
|
|
|
|
void board_select_row(uint8_t row) {
|
|
board_info_t* board = get_board(row);
|
|
if (!board) {
|
|
return;
|
|
}
|
|
uint8_t board_row = matrix2board(row);
|
|
(*board->interface->select_row)(board, board_row);
|
|
}
|
|
|
|
void board_unselect_row(uint8_t row) {
|
|
board_info_t* board = get_board(row);
|
|
if (!board) {
|
|
return;
|
|
}
|
|
uint8_t board_row = matrix2board(row);
|
|
(*board->interface->unselect_row)(board, board_row);
|
|
}
|
|
|
|
void board_unselect_rows(void) {
|
|
for (uint8_t i = 0; i < NUM_BOARDS; i++) {
|
|
board_info_t* board = &boards[i];
|
|
(*board->interface->unselect_rows)(board);
|
|
}
|
|
}
|
|
|
|
void board_init(void) {
|
|
board_setup();
|
|
board_master_init();
|
|
board_slave_init();
|
|
board_unselect_rows();
|
|
}
|