rekahsoft
/
qmk-firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Normalize all line endings

This commit is contained in:
Zeal Jagannatha 2017-08-01 13:36:44 -07:00 committed by Jack Humbert
parent bd0a888133
commit dd3803f334
8 changed files with 899 additions and 899 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

324
keyboards/deltasplit75/i2c.c
View File

@ -1,162 +1,162 @@
#include <util/twi.h> #include <util/twi.h>
#include <avr/io.h> #include <avr/io.h>
#include <stdlib.h> #include <stdlib.h>
#include <avr/interrupt.h> #include <avr/interrupt.h>
#include <util/twi.h> #include <util/twi.h>
#include <stdbool.h> #include <stdbool.h>
#include "i2c.h" #include "i2c.h"
#ifdef USE_I2C #ifdef USE_I2C
// Limits the amount of we wait for any one i2c transaction. // Limits the amount of we wait for any one i2c transaction.
// Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is // Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is
// 9 bits, a single transaction will take around 90μs to complete. // 9 bits, a single transaction will take around 90μs to complete.
// //
// (F_CPU/SCL_CLOCK) => # of μC cycles to transfer a bit // (F_CPU/SCL_CLOCK) => # of μC cycles to transfer a bit
// poll loop takes at least 8 clock cycles to execute // poll loop takes at least 8 clock cycles to execute
#define I2C_LOOP_TIMEOUT (9+1)*(F_CPU/SCL_CLOCK)/8 #define I2C_LOOP_TIMEOUT (9+1)*(F_CPU/SCL_CLOCK)/8
#define BUFFER_POS_INC() (slave_buffer_pos = (slave_buffer_pos+1)%SLAVE_BUFFER_SIZE) #define BUFFER_POS_INC() (slave_buffer_pos = (slave_buffer_pos+1)%SLAVE_BUFFER_SIZE)
volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE]; volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
static volatile uint8_t slave_buffer_pos; static volatile uint8_t slave_buffer_pos;
static volatile bool slave_has_register_set = false; static volatile bool slave_has_register_set = false;
// Wait for an i2c operation to finish // Wait for an i2c operation to finish
inline static inline static
void i2c_delay(void) { void i2c_delay(void) {
uint16_t lim = 0; uint16_t lim = 0;
while(!(TWCR & (1<<TWINT)) && lim < I2C_LOOP_TIMEOUT) while(!(TWCR & (1<<TWINT)) && lim < I2C_LOOP_TIMEOUT)
lim++; lim++;
// easier way, but will wait slightly longer // easier way, but will wait slightly longer
// _delay_us(100); // _delay_us(100);
} }
// Setup twi to run at 100kHz // Setup twi to run at 100kHz
void i2c_master_init(void) { void i2c_master_init(void) {
// no prescaler // no prescaler
TWSR = 0; TWSR = 0;
// Set TWI clock frequency to SCL_CLOCK. Need TWBR>10. // Set TWI clock frequency to SCL_CLOCK. Need TWBR>10.
// Check datasheets for more info. // Check datasheets for more info.
TWBR = ((F_CPU/SCL_CLOCK)-16)/2; TWBR = ((F_CPU/SCL_CLOCK)-16)/2;
} }
// Start a transaction with the given i2c slave address. The direction of the // Start a transaction with the given i2c slave address. The direction of the
// transfer is set with I2C_READ and I2C_WRITE. // transfer is set with I2C_READ and I2C_WRITE.
// returns: 0 => success // returns: 0 => success
// 1 => error // 1 => error
uint8_t i2c_master_start(uint8_t address) { uint8_t i2c_master_start(uint8_t address) {
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA); TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);
i2c_delay(); i2c_delay();
// check that we started successfully // check that we started successfully
if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START)) if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START))
return 1; return 1;
TWDR = address; TWDR = address;
TWCR = (1<<TWINT) | (1<<TWEN); TWCR = (1<<TWINT) | (1<<TWEN);
i2c_delay(); i2c_delay();
if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) ) if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) )
return 1; // slave did not acknowledge return 1; // slave did not acknowledge
else else
return 0; // success return 0; // success
} }
// Finish the i2c transaction. // Finish the i2c transaction.
void i2c_master_stop(void) { void i2c_master_stop(void) {
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
uint16_t lim = 0; uint16_t lim = 0;
while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT) while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT)
lim++; lim++;
} }
// Write one byte to the i2c slave. // Write one byte to the i2c slave.
// returns 0 => slave ACK // returns 0 => slave ACK
// 1 => slave NACK // 1 => slave NACK
uint8_t i2c_master_write(uint8_t data) { uint8_t i2c_master_write(uint8_t data) {
TWDR = data; TWDR = data;
TWCR = (1<<TWINT) | (1<<TWEN); TWCR = (1<<TWINT) | (1<<TWEN);
i2c_delay(); i2c_delay();
// check if the slave acknowledged us // check if the slave acknowledged us
return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1; return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1;
} }
// Read one byte from the i2c slave. If ack=1 the slave is acknowledged, // Read one byte from the i2c slave. If ack=1 the slave is acknowledged,
// if ack=0 the acknowledge bit is not set. // if ack=0 the acknowledge bit is not set.
// returns: byte read from i2c device // returns: byte read from i2c device
uint8_t i2c_master_read(int ack) { uint8_t i2c_master_read(int ack) {
TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA); TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA);
i2c_delay(); i2c_delay();
return TWDR; return TWDR;
} }
void i2c_reset_state(void) { void i2c_reset_state(void) {
TWCR = 0; TWCR = 0;
} }
void i2c_slave_init(uint8_t address) { void i2c_slave_init(uint8_t address) {
TWAR = address << 0; // slave i2c address TWAR = address << 0; // slave i2c address
// TWEN - twi enable // TWEN - twi enable
// TWEA - enable address acknowledgement // TWEA - enable address acknowledgement
// TWINT - twi interrupt flag // TWINT - twi interrupt flag
// TWIE - enable the twi interrupt // TWIE - enable the twi interrupt
TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN); TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN);
} }
ISR(TWI_vect); ISR(TWI_vect);
ISR(TWI_vect) { ISR(TWI_vect) {
uint8_t ack = 1; uint8_t ack = 1;
switch(TW_STATUS) { switch(TW_STATUS) {
case TW_SR_SLA_ACK: case TW_SR_SLA_ACK:
// this device has been addressed as a slave receiver // this device has been addressed as a slave receiver
slave_has_register_set = false; slave_has_register_set = false;
break; break;
case TW_SR_DATA_ACK: case TW_SR_DATA_ACK:
// this device has received data as a slave receiver // this device has received data as a slave receiver
// The first byte that we receive in this transaction sets the location // The first byte that we receive in this transaction sets the location
// of the read/write location of the slaves memory that it exposes over // of the read/write location of the slaves memory that it exposes over
// i2c. After that, bytes will be written at slave_buffer_pos, incrementing // i2c. After that, bytes will be written at slave_buffer_pos, incrementing
// slave_buffer_pos after each write. // slave_buffer_pos after each write.
if(!slave_has_register_set) { if(!slave_has_register_set) {
slave_buffer_pos = TWDR; slave_buffer_pos = TWDR;
// don't acknowledge the master if this memory loctaion is out of bounds // don't acknowledge the master if this memory loctaion is out of bounds
if ( slave_buffer_pos >= SLAVE_BUFFER_SIZE ) { if ( slave_buffer_pos >= SLAVE_BUFFER_SIZE ) {
ack = 0; ack = 0;
slave_buffer_pos = 0; slave_buffer_pos = 0;
} }
slave_has_register_set = true; slave_has_register_set = true;
} else { } else {
i2c_slave_buffer[slave_buffer_pos] = TWDR; i2c_slave_buffer[slave_buffer_pos] = TWDR;
BUFFER_POS_INC(); BUFFER_POS_INC();
} }
break; break;
case TW_ST_SLA_ACK: case TW_ST_SLA_ACK:
case TW_ST_DATA_ACK: case TW_ST_DATA_ACK:
// master has addressed this device as a slave transmitter and is // master has addressed this device as a slave transmitter and is
// requesting data. // requesting data.
TWDR = i2c_slave_buffer[slave_buffer_pos]; TWDR = i2c_slave_buffer[slave_buffer_pos];
BUFFER_POS_INC(); BUFFER_POS_INC();
break; break;
case TW_BUS_ERROR: // something went wrong, reset twi state case TW_BUS_ERROR: // something went wrong, reset twi state
TWCR = 0; TWCR = 0;
default: default:
break; break;
} }
// Reset everything, so we are ready for the next TWI interrupt // Reset everything, so we are ready for the next TWI interrupt
TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN); TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN);
} }
#endif #endif

62
keyboards/deltasplit75/i2c.h
View File

@ -1,31 +1,31 @@
#ifndef I2C_H #ifndef I2C_H
#define I2C_H #define I2C_H
#include <stdint.h> #include <stdint.h>
#ifndef F_CPU #ifndef F_CPU
#define F_CPU 16000000UL #define F_CPU 16000000UL
#endif #endif
#define I2C_READ 1 #define I2C_READ 1
#define I2C_WRITE 0 #define I2C_WRITE 0
#define I2C_ACK 1 #define I2C_ACK 1
#define I2C_NACK 0 #define I2C_NACK 0
#define SLAVE_BUFFER_SIZE 0x10 #define SLAVE_BUFFER_SIZE 0x10
// i2c SCL clock frequency // i2c SCL clock frequency
#define SCL_CLOCK 100000L #define SCL_CLOCK 100000L
extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE]; extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
void i2c_master_init(void); void i2c_master_init(void);
uint8_t i2c_master_start(uint8_t address); uint8_t i2c_master_start(uint8_t address);
void i2c_master_stop(void); void i2c_master_stop(void);
uint8_t i2c_master_write(uint8_t data); uint8_t i2c_master_write(uint8_t data);
uint8_t i2c_master_read(int); uint8_t i2c_master_read(int);
void i2c_reset_state(void); void i2c_reset_state(void);
void i2c_slave_init(uint8_t address); void i2c_slave_init(uint8_t address);
#endif #endif

62
keyboards/deltasplit75/keymaps/default/config.h
View File

@ -1,31 +1,31 @@
/* /*
Copyright 2012 Jun Wako <wakojun@gmail.com> Copyright 2012 Jun Wako <wakojun@gmail.com>
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or the Free Software Foundation, either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. 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/>.
*/ */
#define USE_SERIAL #define USE_SERIAL
#define MASTER_LEFT #define MASTER_LEFT
// #define _MASTER_RIGHT // #define _MASTER_RIGHT
// #define EE_HANDS // #define EE_HANDS
#ifdef SUBPROJECT_v2 #ifdef SUBPROJECT_v2
#include "../../v2/config.h" #include "../../v2/config.h"
#endif #endif
#ifdef SUBPROJECT_protosplit #ifdef SUBPROJECT_protosplit
#include "../../protosplit/config.h" #include "../../protosplit/config.h"
#endif #endif

636
keyboards/deltasplit75/matrix.c
View File

@ -1,318 +1,318 @@
/* /*
Copyright 2012 Jun Wako <wakojun@gmail.com> Copyright 2012 Jun Wako <wakojun@gmail.com>
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or the Free Software Foundation, either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. 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/>.
*/ */
/* /*
* scan matrix * scan matrix
*/ */
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <avr/io.h> #include <avr/io.h>
#include <avr/wdt.h> #include <avr/wdt.h>
#include <avr/interrupt.h> #include <avr/interrupt.h>
#include <util/delay.h> #include <util/delay.h>
#include "print.h" #include "print.h"
#include "debug.h" #include "debug.h"
#include "util.h" #include "util.h"
#include "matrix.h" #include "matrix.h"
#include "split_util.h" #include "split_util.h"
#include "pro_micro.h" #include "pro_micro.h"
#include "config.h" #include "config.h"
#ifdef USE_I2C #ifdef USE_I2C
# include "i2c.h" # include "i2c.h"
#else // USE_SERIAL #else // USE_SERIAL
# include "serial.h" # include "serial.h"
#endif #endif
#ifndef DEBOUNCE #ifndef DEBOUNCE
# define DEBOUNCE 5 # define DEBOUNCE 5
#endif #endif
#define ERROR_DISCONNECT_COUNT 5 #define ERROR_DISCONNECT_COUNT 5
static uint8_t debouncing = DEBOUNCE; static uint8_t debouncing = DEBOUNCE;
static const int ROWS_PER_HAND = MATRIX_ROWS/2; static const int ROWS_PER_HAND = MATRIX_ROWS/2;
static uint8_t error_count = 0; static uint8_t error_count = 0;
static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
/* matrix state(1:on, 0:off) */ /* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS]; static matrix_row_t matrix[MATRIX_ROWS];
static matrix_row_t matrix_debouncing[MATRIX_ROWS]; static matrix_row_t matrix_debouncing[MATRIX_ROWS];
static matrix_row_t read_cols(void); static matrix_row_t read_cols(void);
static void init_cols(void); static void init_cols(void);
static void unselect_rows(void); static void unselect_rows(void);
static void select_row(uint8_t row); static void select_row(uint8_t row);
__attribute__ ((weak)) __attribute__ ((weak))
void matrix_init_quantum(void) { void matrix_init_quantum(void) {
matrix_init_kb(); matrix_init_kb();
} }
__attribute__ ((weak)) __attribute__ ((weak))
void matrix_scan_quantum(void) { void matrix_scan_quantum(void) {
matrix_scan_kb(); matrix_scan_kb();
} }
__attribute__ ((weak)) __attribute__ ((weak))
void matrix_init_kb(void) { void matrix_init_kb(void) {
matrix_init_user(); matrix_init_user();
} }
__attribute__ ((weak)) __attribute__ ((weak))
void matrix_scan_kb(void) { void matrix_scan_kb(void) {
matrix_scan_user(); matrix_scan_user();
} }
__attribute__ ((weak)) __attribute__ ((weak))
void matrix_init_user(void) { void matrix_init_user(void) {
} }
__attribute__ ((weak)) __attribute__ ((weak))
void matrix_scan_user(void) { void matrix_scan_user(void) {
} }
inline inline
uint8_t matrix_rows(void) uint8_t matrix_rows(void)
{ {
return MATRIX_ROWS; return MATRIX_ROWS;
} }
inline inline
uint8_t matrix_cols(void) uint8_t matrix_cols(void)
{ {
return MATRIX_COLS; return MATRIX_COLS;
} }
void matrix_init(void) void matrix_init(void)
{ {
debug_enable = true; debug_enable = true;
debug_matrix = true; debug_matrix = true;
debug_mouse = true; debug_mouse = true;
// initialize row and col // initialize row and col
unselect_rows(); unselect_rows();
init_cols(); init_cols();
TX_RX_LED_INIT; TX_RX_LED_INIT;
// initialize matrix state: all keys off // initialize matrix state: all keys off
for (uint8_t i=0; i < MATRIX_ROWS; i++) { for (uint8_t i=0; i < MATRIX_ROWS; i++) {
matrix[i] = 0; matrix[i] = 0;
matrix_debouncing[i] = 0; matrix_debouncing[i] = 0;
} }
matrix_init_quantum(); matrix_init_quantum();
} }
uint8_t _matrix_scan(void) uint8_t _matrix_scan(void)
{ {
// Right hand is stored after the left in the matirx so, we need to offset it // Right hand is stored after the left in the matirx so, we need to offset it
int offset = isLeftHand ? 0 : (ROWS_PER_HAND); int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
for (uint8_t i = 0; i < ROWS_PER_HAND; i++) { for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
select_row(i); select_row(i);
_delay_us(30); // without this wait read unstable value. _delay_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols(); matrix_row_t cols = read_cols();
if (matrix_debouncing[i+offset] != cols) { if (matrix_debouncing[i+offset] != cols) {
matrix_debouncing[i+offset] = cols; matrix_debouncing[i+offset] = cols;
debouncing = DEBOUNCE; debouncing = DEBOUNCE;
} }
unselect_rows(); unselect_rows();
} }
if (debouncing) { if (debouncing) {
if (--debouncing) { if (--debouncing) {
_delay_ms(1); _delay_ms(1);
} else { } else {
for (uint8_t i = 0; i < ROWS_PER_HAND; i++) { for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
matrix[i+offset] = matrix_debouncing[i+offset]; matrix[i+offset] = matrix_debouncing[i+offset];
} }
} }
} }
return 1; return 1;
} }
#ifdef USE_I2C #ifdef USE_I2C
// Get rows from other half over i2c // Get rows from other half over i2c
int i2c_transaction(void) { int i2c_transaction(void) {
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE); int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
if (err) goto i2c_error; if (err) goto i2c_error;
// start of matrix stored at 0x00 // start of matrix stored at 0x00
err = i2c_master_write(0x00); err = i2c_master_write(0x00);
if (err) goto i2c_error; if (err) goto i2c_error;
// Start read // Start read
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ); err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
if (err) goto i2c_error; if (err) goto i2c_error;
if (!err) { if (!err) {
int i; int i;
for (i = 0; i < ROWS_PER_HAND-1; ++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_ACK);
} }
matrix[slaveOffset+i] = i2c_master_read(I2C_NACK); matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
i2c_master_stop(); i2c_master_stop();
} else { } else {
i2c_error: // the cable is disconnceted, or something else went wrong i2c_error: // the cable is disconnceted, or something else went wrong
i2c_reset_state(); i2c_reset_state();
return err; return err;
} }
return 0; return 0;
} }
#else // USE_SERIAL #else // USE_SERIAL
int serial_transaction(void) { int serial_transaction(void) {
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
if (serial_update_buffers()) { if (serial_update_buffers()) {
return 1; return 1;
} }
for (int i = 0; i < ROWS_PER_HAND; ++i) { for (int i = 0; i < ROWS_PER_HAND; ++i) {
matrix[slaveOffset+i] = serial_slave_buffer[i]; matrix[slaveOffset+i] = serial_slave_buffer[i];
} }
return 0; return 0;
} }
#endif #endif
uint8_t matrix_scan(void) uint8_t matrix_scan(void)
{ {
int ret = _matrix_scan(); int ret = _matrix_scan();
#ifdef USE_I2C #ifdef USE_I2C
if( i2c_transaction() ) { if( i2c_transaction() ) {
#else // USE_SERIAL #else // USE_SERIAL
if( serial_transaction() ) { if( serial_transaction() ) {
#endif #endif
// turn on the indicator led when halves are disconnected // turn on the indicator led when halves are disconnected
TXLED1; TXLED1;
error_count++; error_count++;
if (error_count > ERROR_DISCONNECT_COUNT) { if (error_count > ERROR_DISCONNECT_COUNT) {
// reset other half if disconnected // reset other half if disconnected
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
for (int i = 0; i < ROWS_PER_HAND; ++i) { for (int i = 0; i < ROWS_PER_HAND; ++i) {
matrix[slaveOffset+i] = 0; matrix[slaveOffset+i] = 0;
} }
} }
} else { } else {
// turn off the indicator led on no error // turn off the indicator led on no error
TXLED0; TXLED0;
error_count = 0; error_count = 0;
} }
matrix_scan_quantum(); matrix_scan_quantum();
return ret; return ret;
} }
void matrix_slave_scan(void) { void matrix_slave_scan(void) {
_matrix_scan(); _matrix_scan();
int offset = (isLeftHand) ? 0 : (MATRIX_ROWS / 2); int offset = (isLeftHand) ? 0 : (MATRIX_ROWS / 2);
#ifdef USE_I2C #ifdef USE_I2C
for (int i = 0; i < ROWS_PER_HAND; ++i) { for (int i = 0; i < ROWS_PER_HAND; ++i) {
/* i2c_slave_buffer[i] = matrix[offset+i]; */ /* i2c_slave_buffer[i] = matrix[offset+i]; */
i2c_slave_buffer[i] = matrix[offset+i]; i2c_slave_buffer[i] = matrix[offset+i];
} }
#else // USE_SERIAL #else // USE_SERIAL
for (int i = 0; i < ROWS_PER_HAND; ++i) { for (int i = 0; i < ROWS_PER_HAND; ++i) {
serial_slave_buffer[i] = matrix[offset+i]; serial_slave_buffer[i] = matrix[offset+i];
} }
#endif #endif
} }
bool matrix_is_modified(void) bool matrix_is_modified(void)
{ {
if (debouncing) return false; if (debouncing) return false;
return true; return true;
} }
inline inline
bool matrix_is_on(uint8_t row, uint8_t col) bool matrix_is_on(uint8_t row, uint8_t col)
{ {
return (matrix[row] & ((matrix_row_t)1<<col)); return (matrix[row] & ((matrix_row_t)1<<col));
} }
inline inline
matrix_row_t matrix_get_row(uint8_t row) matrix_row_t matrix_get_row(uint8_t row)
{ {
return matrix[row]; return matrix[row];
} }
void matrix_print(void) void matrix_print(void)
{ {
print("\nr/c 0123456789ABCDEF\n"); print("\nr/c 0123456789ABCDEF\n");
for (uint8_t row = 0; row < MATRIX_ROWS; row++) { for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
phex(row); print(": "); phex(row); print(": ");
pbin_reverse16(matrix_get_row(row)); pbin_reverse16(matrix_get_row(row));
print("\n"); print("\n");
} }
} }
uint8_t matrix_key_count(void) uint8_t matrix_key_count(void)
{ {
uint8_t count = 0; uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop16(matrix[i]); count += bitpop16(matrix[i]);
} }
return count; return count;
} }
static void init_cols(void) static void init_cols(void)
{ {
for(int x = 0; x < MATRIX_COLS; x++) { for(int x = 0; x < MATRIX_COLS; x++) {
_SFR_IO8((col_pins[x] >> 4) + 1) &= ~_BV(col_pins[x] & 0xF); _SFR_IO8((col_pins[x] >> 4) + 1) &= ~_BV(col_pins[x] & 0xF);
_SFR_IO8((col_pins[x] >> 4) + 2) |= _BV(col_pins[x] & 0xF); _SFR_IO8((col_pins[x] >> 4) + 2) |= _BV(col_pins[x] & 0xF);
} }
} }
static matrix_row_t read_cols(void) static matrix_row_t read_cols(void)
{ {
matrix_row_t result = 0; matrix_row_t result = 0;
for(int x = 0; x < MATRIX_COLS; x++) { for(int x = 0; x < MATRIX_COLS; x++) {
result |= (_SFR_IO8(col_pins[x] >> 4) & _BV(col_pins[x] & 0xF)) ? 0 : (1 << x); result |= (_SFR_IO8(col_pins[x] >> 4) & _BV(col_pins[x] & 0xF)) ? 0 : (1 << x);
} }
return result; return result;
} }
static void unselect_rows(void) static void unselect_rows(void)
{ {
for(int x = 0; x < ROWS_PER_HAND; x++) { for(int x = 0; x < ROWS_PER_HAND; x++) {
_SFR_IO8((row_pins[x] >> 4) + 1) &= ~_BV(row_pins[x] & 0xF); _SFR_IO8((row_pins[x] >> 4) + 1) &= ~_BV(row_pins[x] & 0xF);
_SFR_IO8((row_pins[x] >> 4) + 2) |= _BV(row_pins[x] & 0xF); _SFR_IO8((row_pins[x] >> 4) + 2) |= _BV(row_pins[x] & 0xF);
} }
} }
static void select_row(uint8_t row) static void select_row(uint8_t row)
{ {
_SFR_IO8((row_pins[row] >> 4) + 1) |= _BV(row_pins[row] & 0xF); _SFR_IO8((row_pins[row] >> 4) + 1) |= _BV(row_pins[row] & 0xF);
_SFR_IO8((row_pins[row] >> 4) + 2) &= ~_BV(row_pins[row] & 0xF); _SFR_IO8((row_pins[row] >> 4) + 2) &= ~_BV(row_pins[row] & 0xF);
} }

456
keyboards/deltasplit75/serial.c
View File

@ -1,228 +1,228 @@
/* /*
* WARNING: be careful changing this code, it is very timing dependent * WARNING: be careful changing this code, it is very timing dependent
*/ */
#ifndef F_CPU #ifndef F_CPU
#define F_CPU 16000000 #define F_CPU 16000000
#endif #endif
#include <avr/io.h> #include <avr/io.h>
#include <avr/interrupt.h> #include <avr/interrupt.h>
#include <util/delay.h> #include <util/delay.h>
#include <stdbool.h> #include <stdbool.h>
#include "serial.h" #include "serial.h"
#ifdef USE_SERIAL #ifdef USE_SERIAL
// Serial pulse period in microseconds. Its probably a bad idea to lower this // Serial pulse period in microseconds. Its probably a bad idea to lower this
// value. // value.
#define SERIAL_DELAY 24 #define SERIAL_DELAY 24
uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0}; uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0}; uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
#define SLAVE_DATA_CORRUPT (1<<0) #define SLAVE_DATA_CORRUPT (1<<0)
volatile uint8_t status = 0; volatile uint8_t status = 0;
inline static inline static
void serial_delay(void) { void serial_delay(void) {
_delay_us(SERIAL_DELAY); _delay_us(SERIAL_DELAY);
} }
inline static inline static
void serial_output(void) { void serial_output(void) {
SERIAL_PIN_DDR |= SERIAL_PIN_MASK; SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
} }
// make the serial pin an input with pull-up resistor // make the serial pin an input with pull-up resistor
inline static inline static
void serial_input(void) { void serial_input(void) {
SERIAL_PIN_DDR &= ~SERIAL_PIN_MASK; SERIAL_PIN_DDR &= ~SERIAL_PIN_MASK;
SERIAL_PIN_PORT |= SERIAL_PIN_MASK; SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
} }
inline static inline static
uint8_t serial_read_pin(void) { uint8_t serial_read_pin(void) {
return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK); return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
} }
inline static inline static
void serial_low(void) { void serial_low(void) {
SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK; SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
} }
inline static inline static
void serial_high(void) { void serial_high(void) {
SERIAL_PIN_PORT |= SERIAL_PIN_MASK; SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
} }
void serial_master_init(void) { void serial_master_init(void) {
serial_output(); serial_output();
serial_high(); serial_high();
} }
void serial_slave_init(void) { void serial_slave_init(void) {
serial_input(); serial_input();
// Enable INT0 // Enable INT0
EIMSK |= _BV(INT0); EIMSK |= _BV(INT0);
// Trigger on falling edge of INT0 // Trigger on falling edge of INT0
EICRA &= ~(_BV(ISC00) | _BV(ISC01)); EICRA &= ~(_BV(ISC00) | _BV(ISC01));
} }
// Used by the master to synchronize timing with the slave. // Used by the master to synchronize timing with the slave.
static static
void sync_recv(void) { void sync_recv(void) {
serial_input(); serial_input();
// This shouldn't hang if the slave disconnects because the // This shouldn't hang if the slave disconnects because the
// serial line will float to high if the slave does disconnect. // serial line will float to high if the slave does disconnect.
while (!serial_read_pin()); while (!serial_read_pin());
serial_delay(); serial_delay();
} }
// Used by the slave to send a synchronization signal to the master. // Used by the slave to send a synchronization signal to the master.
static static
void sync_send(void) { void sync_send(void) {
serial_output(); serial_output();
serial_low(); serial_low();
serial_delay(); serial_delay();
serial_high(); serial_high();
} }
// Reads a byte from the serial line // Reads a byte from the serial line
static static
uint8_t serial_read_byte(void) { uint8_t serial_read_byte(void) {
uint8_t byte = 0; uint8_t byte = 0;
serial_input(); serial_input();
for ( uint8_t i = 0; i < 8; ++i) { for ( uint8_t i = 0; i < 8; ++i) {
byte = (byte << 1) | serial_read_pin(); byte = (byte << 1) | serial_read_pin();
serial_delay(); serial_delay();
_delay_us(1); _delay_us(1);
} }
return byte; return byte;
} }
// Sends a byte with MSB ordering // Sends a byte with MSB ordering
static static
void serial_write_byte(uint8_t data) { void serial_write_byte(uint8_t data) {
uint8_t b = 8; uint8_t b = 8;
serial_output(); serial_output();
while( b-- ) { while( b-- ) {
if(data & (1 << b)) { if(data & (1 << b)) {
serial_high(); serial_high();
} else { } else {
serial_low(); serial_low();
} }
serial_delay(); serial_delay();
} }
} }
// interrupt handle to be used by the slave device // interrupt handle to be used by the slave device
ISR(SERIAL_PIN_INTERRUPT) { ISR(SERIAL_PIN_INTERRUPT) {
sync_send(); sync_send();
uint8_t checksum = 0; uint8_t checksum = 0;
for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) { for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
serial_write_byte(serial_slave_buffer[i]); serial_write_byte(serial_slave_buffer[i]);
sync_send(); sync_send();
checksum += serial_slave_buffer[i]; checksum += serial_slave_buffer[i];
} }
serial_write_byte(checksum); serial_write_byte(checksum);
sync_send(); sync_send();
// wait for the sync to finish sending // wait for the sync to finish sending
serial_delay(); serial_delay();
// read the middle of pulses // read the middle of pulses
_delay_us(SERIAL_DELAY/2); _delay_us(SERIAL_DELAY/2);
uint8_t checksum_computed = 0; uint8_t checksum_computed = 0;
for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) { for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
serial_master_buffer[i] = serial_read_byte(); serial_master_buffer[i] = serial_read_byte();
sync_send(); sync_send();
checksum_computed += serial_master_buffer[i]; checksum_computed += serial_master_buffer[i];
} }
uint8_t checksum_received = serial_read_byte(); uint8_t checksum_received = serial_read_byte();
sync_send(); sync_send();
serial_input(); // end transaction serial_input(); // end transaction
if ( checksum_computed != checksum_received ) { if ( checksum_computed != checksum_received ) {
status |= SLAVE_DATA_CORRUPT; status |= SLAVE_DATA_CORRUPT;
} else { } else {
status &= ~SLAVE_DATA_CORRUPT; status &= ~SLAVE_DATA_CORRUPT;
} }
} }
inline inline
bool serial_slave_DATA_CORRUPT(void) { bool serial_slave_DATA_CORRUPT(void) {
return status & SLAVE_DATA_CORRUPT; return status & SLAVE_DATA_CORRUPT;
} }
// Copies the serial_slave_buffer to the master and sends the // Copies the serial_slave_buffer to the master and sends the
// serial_master_buffer to the slave. // serial_master_buffer to the slave.
// //
// Returns: // Returns:
// 0 => no error // 0 => no error
// 1 => slave did not respond // 1 => slave did not respond
int serial_update_buffers(void) { int serial_update_buffers(void) {
// this code is very time dependent, so we need to disable interrupts // this code is very time dependent, so we need to disable interrupts
cli(); cli();
// signal to the slave that we want to start a transaction // signal to the slave that we want to start a transaction
serial_output(); serial_output();
serial_low(); serial_low();
_delay_us(1); _delay_us(1);
// wait for the slaves response // wait for the slaves response
serial_input(); serial_input();
serial_high(); serial_high();
_delay_us(SERIAL_DELAY); _delay_us(SERIAL_DELAY);
// check if the slave is present // check if the slave is present
if (serial_read_pin()) { if (serial_read_pin()) {
// slave failed to pull the line low, assume not present // slave failed to pull the line low, assume not present
sei(); sei();
return 1; return 1;
} }
// if the slave is present syncronize with it // if the slave is present syncronize with it
sync_recv(); sync_recv();
uint8_t checksum_computed = 0; uint8_t checksum_computed = 0;
// receive data from the slave // receive data from the slave
for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) { for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
serial_slave_buffer[i] = serial_read_byte(); serial_slave_buffer[i] = serial_read_byte();
sync_recv(); sync_recv();
checksum_computed += serial_slave_buffer[i]; checksum_computed += serial_slave_buffer[i];
} }
uint8_t checksum_received = serial_read_byte(); uint8_t checksum_received = serial_read_byte();
sync_recv(); sync_recv();
if (checksum_computed != checksum_received) { if (checksum_computed != checksum_received) {
sei(); sei();
return 1; return 1;
} }
uint8_t checksum = 0; uint8_t checksum = 0;
// send data to the slave // send data to the slave
for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) { for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
serial_write_byte(serial_master_buffer[i]); serial_write_byte(serial_master_buffer[i]);
sync_recv(); sync_recv();
checksum += serial_master_buffer[i]; checksum += serial_master_buffer[i];
} }
serial_write_byte(checksum); serial_write_byte(checksum);
sync_recv(); sync_recv();
// always, release the line when not in use // always, release the line when not in use
serial_output(); serial_output();
serial_high(); serial_high();
sei(); sei();
return 0; return 0;
} }
#endif #endif

52
keyboards/deltasplit75/serial.h
View File

@ -1,26 +1,26 @@
#ifndef MY_SERIAL_H #ifndef MY_SERIAL_H
#define MY_SERIAL_H #define MY_SERIAL_H
#include "config.h" #include "config.h"
#include <stdbool.h> #include <stdbool.h>
/* TODO: some defines for interrupt setup */ /* TODO: some defines for interrupt setup */
#define SERIAL_PIN_DDR DDRD #define SERIAL_PIN_DDR DDRD
#define SERIAL_PIN_PORT PORTD #define SERIAL_PIN_PORT PORTD
#define SERIAL_PIN_INPUT PIND #define SERIAL_PIN_INPUT PIND
#define SERIAL_PIN_MASK _BV(PD0) #define SERIAL_PIN_MASK _BV(PD0)
#define SERIAL_PIN_INTERRUPT INT0_vect #define SERIAL_PIN_INTERRUPT INT0_vect
#define SERIAL_SLAVE_BUFFER_LENGTH ((MATRIX_COLS+7)/8 *MATRIX_ROWS/2) #define SERIAL_SLAVE_BUFFER_LENGTH ((MATRIX_COLS+7)/8 *MATRIX_ROWS/2)
#define SERIAL_MASTER_BUFFER_LENGTH 1 #define SERIAL_MASTER_BUFFER_LENGTH 1
// Buffers for master - slave communication // Buffers for master - slave communication
extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH]; extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH]; extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
void serial_master_init(void); void serial_master_init(void);
void serial_slave_init(void); void serial_slave_init(void);
int serial_update_buffers(void); int serial_update_buffers(void);
bool serial_slave_data_corrupt(void); bool serial_slave_data_corrupt(void);
#endif #endif

162
keyboards/deltasplit75/split_util.c
View File

@ -1,81 +1,81 @@
#include <avr/io.h> #include <avr/io.h>
#include <avr/wdt.h> #include <avr/wdt.h>
#include <avr/power.h> #include <avr/power.h>
#include <avr/interrupt.h> #include <avr/interrupt.h>
#include <util/delay.h> #include <util/delay.h>
#include <avr/eeprom.h> #include <avr/eeprom.h>
#include "split_util.h" #include "split_util.h"
#include "matrix.h" #include "matrix.h"
#include "keyboard.h" #include "keyboard.h"
#include "config.h" #include "config.h"
#ifdef USE_I2C #ifdef USE_I2C
# include "i2c.h" # include "i2c.h"
#else #else
# include "serial.h" # include "serial.h"
#endif #endif
volatile bool isLeftHand = true; volatile bool isLeftHand = true;
static void setup_handedness(void) { static void setup_handedness(void) {
#ifdef EE_HANDS #ifdef EE_HANDS
isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS); isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS);
#else #else
// I2C_MASTER_RIGHT is deprecated use MASTER_RIGHT instead since this works for both serial and i2c // I2C_MASTER_RIGHT is deprecated use MASTER_RIGHT instead since this works for both serial and i2c
#if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT) #if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT)
isLeftHand = !has_usb(); isLeftHand = !has_usb();
#else #else
isLeftHand = has_usb(); isLeftHand = has_usb();
#endif #endif
#endif #endif
} }
static void keyboard_master_setup(void) { static void keyboard_master_setup(void) {
#ifdef USE_I2C #ifdef USE_I2C
i2c_master_init(); i2c_master_init();
#else #else
serial_master_init(); serial_master_init();
#endif #endif
} }
static void keyboard_slave_setup(void) { static void keyboard_slave_setup(void) {
#ifdef USE_I2C #ifdef USE_I2C
i2c_slave_init(SLAVE_I2C_ADDRESS); i2c_slave_init(SLAVE_I2C_ADDRESS);
#else #else
serial_slave_init(); serial_slave_init();
#endif #endif
} }
bool has_usb(void) { bool has_usb(void) {
USBCON |= (1 << OTGPADE); //enables VBUS pad USBCON |= (1 << OTGPADE); //enables VBUS pad
_delay_us(5); _delay_us(5);
return (USBSTA & (1<<VBUS)); //checks state of VBUS return (USBSTA & (1<<VBUS)); //checks state of VBUS
} }
void split_keyboard_setup(void) { void split_keyboard_setup(void) {
setup_handedness(); setup_handedness();
if (has_usb()) { if (has_usb()) {
keyboard_master_setup(); keyboard_master_setup();
} else { } else {
keyboard_slave_setup(); keyboard_slave_setup();
} }
sei(); sei();
} }
void keyboard_slave_loop(void) { void keyboard_slave_loop(void) {
matrix_init(); matrix_init();
while (1) { while (1) {
matrix_slave_scan(); matrix_slave_scan();
} }
} }
// this code runs before the usb and keyboard is initialized // this code runs before the usb and keyboard is initialized
void matrix_setup(void) { void matrix_setup(void) {
split_keyboard_setup(); split_keyboard_setup();
if (!has_usb()) { if (!has_usb()) {
keyboard_slave_loop(); keyboard_slave_loop();
} }
} }

44
keyboards/deltasplit75/split_util.h
View File

@ -1,22 +1,22 @@
#ifndef SPLIT_KEYBOARD_UTIL_H #ifndef SPLIT_KEYBOARD_UTIL_H
#define SPLIT_KEYBOARD_UTIL_H #define SPLIT_KEYBOARD_UTIL_H
#include <stdbool.h> #include <stdbool.h>
#ifdef EE_HANDS #ifdef EE_HANDS
#define EECONFIG_BOOTMAGIC_END (uint8_t *)10 #define EECONFIG_BOOTMAGIC_END (uint8_t *)10
#define EECONFIG_HANDEDNESS EECONFIG_BOOTMAGIC_END #define EECONFIG_HANDEDNESS EECONFIG_BOOTMAGIC_END
#endif #endif
#define SLAVE_I2C_ADDRESS 0x32 #define SLAVE_I2C_ADDRESS 0x32
extern volatile bool isLeftHand; extern volatile bool isLeftHand;
// slave version of matix scan, defined in matrix.c // slave version of matix scan, defined in matrix.c
void matrix_slave_scan(void); void matrix_slave_scan(void);
void split_keyboard_setup(void); void split_keyboard_setup(void);
bool has_usb(void); bool has_usb(void);
void keyboard_slave_loop(void); void keyboard_slave_loop(void);
#endif #endif