Helix/rev2 move to split common (#16723)
Takeshi ISHII
3 years ago
committed by
GitHub
parent
969c68a9ad
commit
8f692e22e3
@ -1,159 +0,0 @@ |
|||||||
#include <util/twi.h> |
|
||||||
#include <avr/io.h> |
|
||||||
#include <stdlib.h> |
|
||||||
#include <avr/interrupt.h> |
|
||||||
#include <util/twi.h> |
|
||||||
#include <stdbool.h> |
|
||||||
#include "i2c.h" |
|
||||||
|
|
||||||
// Limits the amount of we wait for any one i2c transaction.
|
|
||||||
// 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.
|
|
||||||
//
|
|
||||||
// (F_CPU/SCL_CLOCK) => # of μC cycles to transfer a bit
|
|
||||||
// poll loop takes at least 8 clock cycles to execute
|
|
||||||
#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) |
|
||||||
|
|
||||||
volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE]; |
|
||||||
|
|
||||||
static volatile uint8_t slave_buffer_pos; |
|
||||||
static volatile bool slave_has_register_set = false; |
|
||||||
|
|
||||||
// Wait for an i2c operation to finish
|
|
||||||
inline static |
|
||||||
void i2c_delay(void) { |
|
||||||
uint16_t lim = 0; |
|
||||||
while(!(TWCR & (1<<TWINT)) && lim < I2C_LOOP_TIMEOUT) |
|
||||||
lim++; |
|
||||||
|
|
||||||
// easier way, but will wait slightly longer
|
|
||||||
// _delay_us(100);
|
|
||||||
} |
|
||||||
|
|
||||||
// Setup twi to run at 100kHz or 400kHz (see ./i2c.h SCL_CLOCK)
|
|
||||||
void i2c_master_init(void) { |
|
||||||
// no prescaler
|
|
||||||
TWSR = 0; |
|
||||||
// Set TWI clock frequency to SCL_CLOCK. Need TWBR>10.
|
|
||||||
// Check datasheets for more info.
|
|
||||||
TWBR = ((F_CPU/SCL_CLOCK)-16)/2; |
|
||||||
} |
|
||||||
|
|
||||||
// Start a transaction with the given i2c slave address. The direction of the
|
|
||||||
// transfer is set with I2C_READ and I2C_WRITE.
|
|
||||||
// returns: 0 => success
|
|
||||||
// 1 => error
|
|
||||||
uint8_t i2c_master_start(uint8_t address) { |
|
||||||
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA); |
|
||||||
|
|
||||||
i2c_delay(); |
|
||||||
|
|
||||||
// check that we started successfully
|
|
||||||
if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START)) |
|
||||||
return 1; |
|
||||||
|
|
||||||
TWDR = address; |
|
||||||
TWCR = (1<<TWINT) | (1<<TWEN); |
|
||||||
|
|
||||||
i2c_delay(); |
|
||||||
|
|
||||||
if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) ) |
|
||||||
return 1; // slave did not acknowledge
|
|
||||||
else |
|
||||||
return 0; // success
|
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
// Finish the i2c transaction.
|
|
||||||
void i2c_master_stop(void) { |
|
||||||
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO); |
|
||||||
|
|
||||||
uint16_t lim = 0; |
|
||||||
while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT) |
|
||||||
lim++; |
|
||||||
} |
|
||||||
|
|
||||||
// Write one byte to the i2c slave.
|
|
||||||
// returns 0 => slave ACK
|
|
||||||
// 1 => slave NACK
|
|
||||||
uint8_t i2c_master_write(uint8_t data) { |
|
||||||
TWDR = data; |
|
||||||
TWCR = (1<<TWINT) | (1<<TWEN); |
|
||||||
|
|
||||||
i2c_delay(); |
|
||||||
|
|
||||||
// check if the slave acknowledged us
|
|
||||||
return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1; |
|
||||||
} |
|
||||||
|
|
||||||
// Read one byte from the i2c slave. If ack=1 the slave is acknowledged,
|
|
||||||
// if ack=0 the acknowledge bit is not set.
|
|
||||||
// returns: byte read from i2c device
|
|
||||||
uint8_t i2c_master_read(int ack) { |
|
||||||
TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA); |
|
||||||
|
|
||||||
i2c_delay(); |
|
||||||
return TWDR; |
|
||||||
} |
|
||||||
|
|
||||||
void i2c_reset_state(void) { |
|
||||||
TWCR = 0; |
|
||||||
} |
|
||||||
|
|
||||||
void i2c_slave_init(uint8_t address) { |
|
||||||
TWAR = address << 0; // slave i2c address
|
|
||||||
// TWEN - twi enable
|
|
||||||
// TWEA - enable address acknowledgement
|
|
||||||
// TWINT - twi interrupt flag
|
|
||||||
// TWIE - enable the twi interrupt
|
|
||||||
TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN); |
|
||||||
} |
|
||||||
|
|
||||||
ISR(TWI_vect); |
|
||||||
|
|
||||||
ISR(TWI_vect) { |
|
||||||
uint8_t ack = 1; |
|
||||||
switch(TW_STATUS) { |
|
||||||
case TW_SR_SLA_ACK: |
|
||||||
// this device has been addressed as a slave receiver
|
|
||||||
slave_has_register_set = false; |
|
||||||
break; |
|
||||||
|
|
||||||
case TW_SR_DATA_ACK: |
|
||||||
// this device has received data as a slave receiver
|
|
||||||
// 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
|
|
||||||
// i2c. After that, bytes will be written at slave_buffer_pos, incrementing
|
|
||||||
// slave_buffer_pos after each write.
|
|
||||||
if(!slave_has_register_set) { |
|
||||||
slave_buffer_pos = TWDR; |
|
||||||
// don't acknowledge the master if this memory loctaion is out of bounds
|
|
||||||
if ( slave_buffer_pos >= SLAVE_BUFFER_SIZE ) { |
|
||||||
ack = 0; |
|
||||||
slave_buffer_pos = 0; |
|
||||||
} |
|
||||||
slave_has_register_set = true; |
|
||||||
} else { |
|
||||||
i2c_slave_buffer[slave_buffer_pos] = TWDR; |
|
||||||
BUFFER_POS_INC(); |
|
||||||
} |
|
||||||
break; |
|
||||||
|
|
||||||
case TW_ST_SLA_ACK: |
|
||||||
case TW_ST_DATA_ACK: |
|
||||||
// master has addressed this device as a slave transmitter and is
|
|
||||||
// requesting data.
|
|
||||||
TWDR = i2c_slave_buffer[slave_buffer_pos]; |
|
||||||
BUFFER_POS_INC(); |
|
||||||
break; |
|
||||||
|
|
||||||
case TW_BUS_ERROR: // something went wrong, reset twi state
|
|
||||||
TWCR = 0; |
|
||||||
default: |
|
||||||
break; |
|
||||||
} |
|
||||||
// Reset everything, so we are ready for the next TWI interrupt
|
|
||||||
TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN); |
|
||||||
} |
|
||||||
@ -1,46 +0,0 @@ |
|||||||
#pragma once |
|
||||||
|
|
||||||
#include <stdint.h> |
|
||||||
|
|
||||||
#ifndef F_CPU |
|
||||||
#define F_CPU 16000000UL |
|
||||||
#endif |
|
||||||
|
|
||||||
#define I2C_READ 1 |
|
||||||
#define I2C_WRITE 0 |
|
||||||
|
|
||||||
#define I2C_ACK 1 |
|
||||||
#define I2C_NACK 0 |
|
||||||
|
|
||||||
#define SLAVE_BUFFER_SIZE 0x10 |
|
||||||
|
|
||||||
// i2c SCL clock frequency 400kHz
|
|
||||||
#define SCL_CLOCK 400000L |
|
||||||
|
|
||||||
extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE]; |
|
||||||
|
|
||||||
void i2c_master_init(void); |
|
||||||
uint8_t i2c_master_start(uint8_t address); |
|
||||||
void i2c_master_stop(void); |
|
||||||
uint8_t i2c_master_write(uint8_t data); |
|
||||||
uint8_t i2c_master_read(int); |
|
||||||
void i2c_reset_state(void); |
|
||||||
void i2c_slave_init(uint8_t address); |
|
||||||
|
|
||||||
|
|
||||||
static inline unsigned char i2c_start_read(unsigned char addr) { |
|
||||||
return i2c_master_start((addr << 1) | I2C_READ); |
|
||||||
} |
|
||||||
|
|
||||||
static inline unsigned char i2c_start_write(unsigned char addr) { |
|
||||||
return i2c_master_start((addr << 1) | I2C_WRITE); |
|
||||||
} |
|
||||||
|
|
||||||
// from SSD1306 scrips
|
|
||||||
extern unsigned char i2c_rep_start(unsigned char addr); |
|
||||||
extern void i2c_start_wait(unsigned char addr); |
|
||||||
extern unsigned char i2c_readAck(void); |
|
||||||
extern unsigned char i2c_readNak(void); |
|
||||||
extern unsigned char i2c_read(unsigned char ack); |
|
||||||
|
|
||||||
#define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak(); |
|
||||||
@ -1,589 +0,0 @@ |
|||||||
/*
|
|
||||||
* WARNING: be careful changing this code, it is very timing dependent |
|
||||||
* |
|
||||||
* 2018-10-28 checked |
|
||||||
* avr-gcc 4.9.2 |
|
||||||
* avr-gcc 5.4.0 |
|
||||||
* avr-gcc 7.3.0 |
|
||||||
*/ |
|
||||||
|
|
||||||
#ifndef F_CPU |
|
||||||
#define F_CPU 16000000 |
|
||||||
#endif |
|
||||||
|
|
||||||
#include <avr/io.h> |
|
||||||
#include <avr/interrupt.h> |
|
||||||
#include <util/delay.h> |
|
||||||
#include <stddef.h> |
|
||||||
#include <stdbool.h> |
|
||||||
#include "serial.h" |
|
||||||
|
|
||||||
#ifdef SOFT_SERIAL_PIN |
|
||||||
|
|
||||||
#ifdef __AVR_ATmega32U4__ |
|
||||||
// if using ATmega32U4 I2C, can not use PD0 and PD1 in soft serial.
|
|
||||||
#ifdef USE_I2C |
|
||||||
#if SOFT_SERIAL_PIN == D0 || SOFT_SERIAL_PIN == D1 |
|
||||||
#error Using ATmega32U4 I2C, so can not use PD0, PD1 |
|
||||||
#endif |
|
||||||
#endif |
|
||||||
|
|
||||||
#if SOFT_SERIAL_PIN >= D0 && SOFT_SERIAL_PIN <= D3 |
|
||||||
#define SERIAL_PIN_DDR DDRD |
|
||||||
#define SERIAL_PIN_PORT PORTD |
|
||||||
#define SERIAL_PIN_INPUT PIND |
|
||||||
#if SOFT_SERIAL_PIN == D0 |
|
||||||
#define SERIAL_PIN_MASK _BV(PD0) |
|
||||||
#define EIMSK_BIT _BV(INT0) |
|
||||||
#define EICRx_BIT (~(_BV(ISC00) | _BV(ISC01))) |
|
||||||
#define SERIAL_PIN_INTERRUPT INT0_vect |
|
||||||
#elif SOFT_SERIAL_PIN == D1 |
|
||||||
#define SERIAL_PIN_MASK _BV(PD1) |
|
||||||
#define EIMSK_BIT _BV(INT1) |
|
||||||
#define EICRx_BIT (~(_BV(ISC10) | _BV(ISC11))) |
|
||||||
#define SERIAL_PIN_INTERRUPT INT1_vect |
|
||||||
#elif SOFT_SERIAL_PIN == D2 |
|
||||||
#define SERIAL_PIN_MASK _BV(PD2) |
|
||||||
#define EIMSK_BIT _BV(INT2) |
|
||||||
#define EICRx_BIT (~(_BV(ISC20) | _BV(ISC21))) |
|
||||||
#define SERIAL_PIN_INTERRUPT INT2_vect |
|
||||||
#elif SOFT_SERIAL_PIN == D3 |
|
||||||
#define SERIAL_PIN_MASK _BV(PD3) |
|
||||||
#define EIMSK_BIT _BV(INT3) |
|
||||||
#define EICRx_BIT (~(_BV(ISC30) | _BV(ISC31))) |
|
||||||
#define SERIAL_PIN_INTERRUPT INT3_vect |
|
||||||
#endif |
|
||||||
#elif SOFT_SERIAL_PIN == E6 |
|
||||||
#define SERIAL_PIN_DDR DDRE |
|
||||||
#define SERIAL_PIN_PORT PORTE |
|
||||||
#define SERIAL_PIN_INPUT PINE |
|
||||||
#define SERIAL_PIN_MASK _BV(PE6) |
|
||||||
#define EIMSK_BIT _BV(INT6) |
|
||||||
#define EICRx_BIT (~(_BV(ISC60) | _BV(ISC61))) |
|
||||||
#define SERIAL_PIN_INTERRUPT INT6_vect |
|
||||||
#else |
|
||||||
#error invalid SOFT_SERIAL_PIN value |
|
||||||
#endif |
|
||||||
|
|
||||||
#else |
|
||||||
#error serial.c now support ATmega32U4 only |
|
||||||
#endif |
|
||||||
|
|
||||||
//////////////// for backward compatibility ////////////////////////////////
|
|
||||||
#if !defined(SERIAL_USE_SINGLE_TRANSACTION) && !defined(SERIAL_USE_MULTI_TRANSACTION) |
|
||||||
/* --- USE OLD API (compatible with let's split serial.c) */ |
|
||||||
#if SERIAL_SLAVE_BUFFER_LENGTH > 0 |
|
||||||
uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0}; |
|
||||||
#endif |
|
||||||
#if SERIAL_MASTER_BUFFER_LENGTH > 0 |
|
||||||
uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0}; |
|
||||||
#endif |
|
||||||
uint8_t volatile status0 = 0; |
|
||||||
|
|
||||||
SSTD_t transactions[] = { |
|
||||||
{ (uint8_t *)&status0, |
|
||||||
#if SERIAL_MASTER_BUFFER_LENGTH > 0 |
|
||||||
sizeof(serial_master_buffer), (uint8_t *)serial_master_buffer, |
|
||||||
#else |
|
||||||
0, (uint8_t *)NULL, |
|
||||||
#endif |
|
||||||
#if SERIAL_SLAVE_BUFFER_LENGTH > 0 |
|
||||||
sizeof(serial_slave_buffer), (uint8_t *)serial_slave_buffer |
|
||||||
#else |
|
||||||
0, (uint8_t *)NULL, |
|
||||||
#endif |
|
||||||
} |
|
||||||
}; |
|
||||||
|
|
||||||
void serial_master_init(void) |
|
||||||
{ soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); } |
|
||||||
|
|
||||||
void serial_slave_init(void) |
|
||||||
{ soft_serial_target_init(transactions, TID_LIMIT(transactions)); } |
|
||||||
|
|
||||||
// 0 => no error
|
|
||||||
// 1 => slave did not respond
|
|
||||||
// 2 => checksum error
|
|
||||||
int serial_update_buffers() |
|
||||||
{ |
|
||||||
int result; |
|
||||||
result = soft_serial_transaction(); |
|
||||||
return result; |
|
||||||
} |
|
||||||
|
|
||||||
#endif // end of OLD API (compatible with let's split serial.c)
|
|
||||||
////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#define ALWAYS_INLINE __attribute__((always_inline)) |
|
||||||
#define NO_INLINE __attribute__((noinline)) |
|
||||||
#define _delay_sub_us(x) __builtin_avr_delay_cycles(x) |
|
||||||
|
|
||||||
// parity check
|
|
||||||
#define ODD_PARITY 1 |
|
||||||
#define EVEN_PARITY 0 |
|
||||||
#define PARITY EVEN_PARITY |
|
||||||
|
|
||||||
#ifdef SERIAL_DELAY |
|
||||||
// custom setup in config.h
|
|
||||||
// #define TID_SEND_ADJUST 2
|
|
||||||
// #define SERIAL_DELAY 6 // micro sec
|
|
||||||
// #define READ_WRITE_START_ADJUST 30 // cycles
|
|
||||||
// #define READ_WRITE_WIDTH_ADJUST 8 // cycles
|
|
||||||
#else |
|
||||||
// ============ Standard setups ============
|
|
||||||
|
|
||||||
#ifndef SELECT_SOFT_SERIAL_SPEED |
|
||||||
#define SELECT_SOFT_SERIAL_SPEED 1 |
|
||||||
// 0: about 189kbps
|
|
||||||
// 1: about 137kbps (default)
|
|
||||||
// 2: about 75kbps
|
|
||||||
// 3: about 39kbps
|
|
||||||
// 4: about 26kbps
|
|
||||||
// 5: about 20kbps
|
|
||||||
#endif |
|
||||||
|
|
||||||
#if __GNUC__ < 6 |
|
||||||
#define TID_SEND_ADJUST 14 |
|
||||||
#else |
|
||||||
#define TID_SEND_ADJUST 2 |
|
||||||
#endif |
|
||||||
|
|
||||||
#if SELECT_SOFT_SERIAL_SPEED == 0 |
|
||||||
// Very High speed
|
|
||||||
#define SERIAL_DELAY 4 // micro sec
|
|
||||||
#if __GNUC__ < 6 |
|
||||||
#define READ_WRITE_START_ADJUST 33 // cycles
|
|
||||||
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
|
|
||||||
#else |
|
||||||
#define READ_WRITE_START_ADJUST 34 // cycles
|
|
||||||
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
|
|
||||||
#endif |
|
||||||
#elif SELECT_SOFT_SERIAL_SPEED == 1 |
|
||||||
// High speed
|
|
||||||
#define SERIAL_DELAY 6 // micro sec
|
|
||||||
#if __GNUC__ < 6 |
|
||||||
#define READ_WRITE_START_ADJUST 30 // cycles
|
|
||||||
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
|
|
||||||
#else |
|
||||||
#define READ_WRITE_START_ADJUST 33 // cycles
|
|
||||||
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
|
|
||||||
#endif |
|
||||||
#elif SELECT_SOFT_SERIAL_SPEED == 2 |
|
||||||
// Middle speed
|
|
||||||
#define SERIAL_DELAY 12 // micro sec
|
|
||||||
#define READ_WRITE_START_ADJUST 30 // cycles
|
|
||||||
#if __GNUC__ < 6 |
|
||||||
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
|
|
||||||
#else |
|
||||||
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
|
|
||||||
#endif |
|
||||||
#elif SELECT_SOFT_SERIAL_SPEED == 3 |
|
||||||
// Low speed
|
|
||||||
#define SERIAL_DELAY 24 // micro sec
|
|
||||||
#define READ_WRITE_START_ADJUST 30 // cycles
|
|
||||||
#if __GNUC__ < 6 |
|
||||||
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
|
|
||||||
#else |
|
||||||
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
|
|
||||||
#endif |
|
||||||
#elif SELECT_SOFT_SERIAL_SPEED == 4 |
|
||||||
// Very Low speed
|
|
||||||
#define SERIAL_DELAY 36 // micro sec
|
|
||||||
#define READ_WRITE_START_ADJUST 30 // cycles
|
|
||||||
#if __GNUC__ < 6 |
|
||||||
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
|
|
||||||
#else |
|
||||||
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
|
|
||||||
#endif |
|
||||||
#elif SELECT_SOFT_SERIAL_SPEED == 5 |
|
||||||
// Ultra Low speed
|
|
||||||
#define SERIAL_DELAY 48 // micro sec
|
|
||||||
#define READ_WRITE_START_ADJUST 30 // cycles
|
|
||||||
#if __GNUC__ < 6 |
|
||||||
#define READ_WRITE_WIDTH_ADJUST 3 // cycles
|
|
||||||
#else |
|
||||||
#define READ_WRITE_WIDTH_ADJUST 7 // cycles
|
|
||||||
#endif |
|
||||||
#else |
|
||||||
#error invalid SELECT_SOFT_SERIAL_SPEED value |
|
||||||
#endif /* SELECT_SOFT_SERIAL_SPEED */ |
|
||||||
#endif /* SERIAL_DELAY */ |
|
||||||
|
|
||||||
#define SERIAL_DELAY_HALF1 (SERIAL_DELAY/2) |
|
||||||
#define SERIAL_DELAY_HALF2 (SERIAL_DELAY - SERIAL_DELAY/2) |
|
||||||
|
|
||||||
#define SLAVE_INT_WIDTH_US 1 |
|
||||||
#ifndef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
#define SLAVE_INT_RESPONSE_TIME SERIAL_DELAY |
|
||||||
#else |
|
||||||
#define SLAVE_INT_ACK_WIDTH_UNIT 2 |
|
||||||
#define SLAVE_INT_ACK_WIDTH 4 |
|
||||||
#endif |
|
||||||
|
|
||||||
static SSTD_t *Transaction_table = NULL; |
|
||||||
static uint8_t Transaction_table_size = 0; |
|
||||||
|
|
||||||
inline static void serial_delay(void) ALWAYS_INLINE; |
|
||||||
inline static |
|
||||||
void serial_delay(void) { |
|
||||||
_delay_us(SERIAL_DELAY); |
|
||||||
} |
|
||||||
|
|
||||||
inline static void serial_delay_half1(void) ALWAYS_INLINE; |
|
||||||
inline static |
|
||||||
void serial_delay_half1(void) { |
|
||||||
_delay_us(SERIAL_DELAY_HALF1); |
|
||||||
} |
|
||||||
|
|
||||||
inline static void serial_delay_half2(void) ALWAYS_INLINE; |
|
||||||
inline static |
|
||||||
void serial_delay_half2(void) { |
|
||||||
_delay_us(SERIAL_DELAY_HALF2); |
|
||||||
} |
|
||||||
|
|
||||||
inline static void serial_output(void) ALWAYS_INLINE; |
|
||||||
inline static |
|
||||||
void serial_output(void) { |
|
||||||
SERIAL_PIN_DDR |= SERIAL_PIN_MASK; |
|
||||||
} |
|
||||||
|
|
||||||
// make the serial pin an input with pull-up resistor
|
|
||||||
inline static void serial_input_with_pullup(void) ALWAYS_INLINE; |
|
||||||
inline static |
|
||||||
void serial_input_with_pullup(void) { |
|
||||||
SERIAL_PIN_DDR &= ~SERIAL_PIN_MASK; |
|
||||||
SERIAL_PIN_PORT |= SERIAL_PIN_MASK; |
|
||||||
} |
|
||||||
|
|
||||||
inline static uint8_t serial_read_pin(void) ALWAYS_INLINE; |
|
||||||
inline static |
|
||||||
uint8_t serial_read_pin(void) { |
|
||||||
return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK); |
|
||||||
} |
|
||||||
|
|
||||||
inline static void serial_low(void) ALWAYS_INLINE; |
|
||||||
inline static |
|
||||||
void serial_low(void) { |
|
||||||
SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK; |
|
||||||
} |
|
||||||
|
|
||||||
inline static void serial_high(void) ALWAYS_INLINE; |
|
||||||
inline static |
|
||||||
void serial_high(void) { |
|
||||||
SERIAL_PIN_PORT |= SERIAL_PIN_MASK; |
|
||||||
} |
|
||||||
|
|
||||||
void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size) |
|
||||||
{ |
|
||||||
Transaction_table = sstd_table; |
|
||||||
Transaction_table_size = (uint8_t)sstd_table_size; |
|
||||||
serial_output(); |
|
||||||
serial_high(); |
|
||||||
} |
|
||||||
|
|
||||||
void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size) |
|
||||||
{ |
|
||||||
Transaction_table = sstd_table; |
|
||||||
Transaction_table_size = (uint8_t)sstd_table_size; |
|
||||||
serial_input_with_pullup(); |
|
||||||
|
|
||||||
// Enable INT0-INT3,INT6
|
|
||||||
EIMSK |= EIMSK_BIT; |
|
||||||
#if SERIAL_PIN_MASK == _BV(PE6) |
|
||||||
// Trigger on falling edge of INT6
|
|
||||||
EICRB &= EICRx_BIT; |
|
||||||
#else |
|
||||||
// Trigger on falling edge of INT0-INT3
|
|
||||||
EICRA &= EICRx_BIT; |
|
||||||
#endif |
|
||||||
} |
|
||||||
|
|
||||||
// Used by the sender to synchronize timing with the reciver.
|
|
||||||
static void sync_recv(void) NO_INLINE; |
|
||||||
static |
|
||||||
void sync_recv(void) { |
|
||||||
for (uint8_t i = 0; i < SERIAL_DELAY*5 && serial_read_pin(); i++ ) { |
|
||||||
} |
|
||||||
// This shouldn't hang if the target disconnects because the
|
|
||||||
// serial line will float to high if the target does disconnect.
|
|
||||||
while (!serial_read_pin()); |
|
||||||
} |
|
||||||
|
|
||||||
// Used by the reciver to send a synchronization signal to the sender.
|
|
||||||
static void sync_send(void) NO_INLINE; |
|
||||||
static |
|
||||||
void sync_send(void) { |
|
||||||
serial_low(); |
|
||||||
serial_delay(); |
|
||||||
serial_high(); |
|
||||||
} |
|
||||||
|
|
||||||
// Reads a byte from the serial line
|
|
||||||
static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) NO_INLINE; |
|
||||||
static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) { |
|
||||||
uint8_t byte, i, p, pb; |
|
||||||
|
|
||||||
_delay_sub_us(READ_WRITE_START_ADJUST); |
|
||||||
for( i = 0, byte = 0, p = PARITY; i < bit; i++ ) { |
|
||||||
serial_delay_half1(); // read the middle of pulses
|
|
||||||
if( serial_read_pin() ) { |
|
||||||
byte = (byte << 1) | 1; p ^= 1; |
|
||||||
} else { |
|
||||||
byte = (byte << 1) | 0; p ^= 0; |
|
||||||
} |
|
||||||
_delay_sub_us(READ_WRITE_WIDTH_ADJUST); |
|
||||||
serial_delay_half2(); |
|
||||||
} |
|
||||||
/* recive parity bit */ |
|
||||||
serial_delay_half1(); // read the middle of pulses
|
|
||||||
pb = serial_read_pin(); |
|
||||||
_delay_sub_us(READ_WRITE_WIDTH_ADJUST); |
|
||||||
serial_delay_half2(); |
|
||||||
|
|
||||||
*pterrcount += (p != pb)? 1 : 0; |
|
||||||
|
|
||||||
return byte; |
|
||||||
} |
|
||||||
|
|
||||||
// Sends a byte with MSB ordering
|
|
||||||
void serial_write_chunk(uint8_t data, uint8_t bit) NO_INLINE; |
|
||||||
void serial_write_chunk(uint8_t data, uint8_t bit) { |
|
||||||
uint8_t b, p; |
|
||||||
for( p = PARITY, b = 1<<(bit-1); b ; b >>= 1) { |
|
||||||
if(data & b) { |
|
||||||
serial_high(); p ^= 1; |
|
||||||
} else { |
|
||||||
serial_low(); p ^= 0; |
|
||||||
} |
|
||||||
serial_delay(); |
|
||||||
} |
|
||||||
/* send parity bit */ |
|
||||||
if(p & 1) { serial_high(); } |
|
||||||
else { serial_low(); } |
|
||||||
serial_delay(); |
|
||||||
|
|
||||||
serial_low(); // sync_send() / senc_recv() need raise edge
|
|
||||||
} |
|
||||||
|
|
||||||
static void serial_send_packet(uint8_t *buffer, uint8_t size) NO_INLINE; |
|
||||||
static |
|
||||||
void serial_send_packet(uint8_t *buffer, uint8_t size) { |
|
||||||
for (uint8_t i = 0; i < size; ++i) { |
|
||||||
uint8_t data; |
|
||||||
data = buffer[i]; |
|
||||||
sync_send(); |
|
||||||
serial_write_chunk(data,8); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) NO_INLINE; |
|
||||||
static |
|
||||||
uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) { |
|
||||||
uint8_t pecount = 0; |
|
||||||
for (uint8_t i = 0; i < size; ++i) { |
|
||||||
uint8_t data; |
|
||||||
sync_recv(); |
|
||||||
data = serial_read_chunk(&pecount, 8); |
|
||||||
buffer[i] = data; |
|
||||||
} |
|
||||||
return pecount == 0; |
|
||||||
} |
|
||||||
|
|
||||||
inline static |
|
||||||
void change_sender2reciver(void) { |
|
||||||
sync_send(); //0
|
|
||||||
serial_delay_half1(); //1
|
|
||||||
serial_low(); //2
|
|
||||||
serial_input_with_pullup(); //2
|
|
||||||
serial_delay_half1(); //3
|
|
||||||
} |
|
||||||
|
|
||||||
inline static |
|
||||||
void change_reciver2sender(void) { |
|
||||||
sync_recv(); //0
|
|
||||||
serial_delay(); //1
|
|
||||||
serial_low(); //3
|
|
||||||
serial_output(); //3
|
|
||||||
serial_delay_half1(); //4
|
|
||||||
} |
|
||||||
|
|
||||||
static inline uint8_t nibble_bits_count(uint8_t bits) |
|
||||||
{ |
|
||||||
bits = (bits & 0x5) + (bits >> 1 & 0x5); |
|
||||||
bits = (bits & 0x3) + (bits >> 2 & 0x3); |
|
||||||
return bits; |
|
||||||
} |
|
||||||
|
|
||||||
// interrupt handle to be used by the target device
|
|
||||||
ISR(SERIAL_PIN_INTERRUPT) { |
|
||||||
|
|
||||||
#ifndef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
serial_low(); |
|
||||||
serial_output(); |
|
||||||
SSTD_t *trans = Transaction_table; |
|
||||||
#else |
|
||||||
// recive transaction table index
|
|
||||||
uint8_t tid, bits; |
|
||||||
uint8_t pecount = 0; |
|
||||||
sync_recv(); |
|
||||||
bits = serial_read_chunk(&pecount,7); |
|
||||||
tid = bits>>3; |
|
||||||
bits = (bits&7) != nibble_bits_count(tid); |
|
||||||
if( bits || pecount> 0 || tid > Transaction_table_size ) { |
|
||||||
return; |
|
||||||
} |
|
||||||
serial_delay_half1(); |
|
||||||
|
|
||||||
serial_high(); // response step1 low->high
|
|
||||||
serial_output(); |
|
||||||
_delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT*SLAVE_INT_ACK_WIDTH); |
|
||||||
SSTD_t *trans = &Transaction_table[tid]; |
|
||||||
serial_low(); // response step2 ack high->low
|
|
||||||
#endif |
|
||||||
|
|
||||||
// target send phase
|
|
||||||
if( trans->target2initiator_buffer_size > 0 ) |
|
||||||
serial_send_packet((uint8_t *)trans->target2initiator_buffer, |
|
||||||
trans->target2initiator_buffer_size); |
|
||||||
// target switch to input
|
|
||||||
change_sender2reciver(); |
|
||||||
|
|
||||||
// target recive phase
|
|
||||||
if( trans->initiator2target_buffer_size > 0 ) { |
|
||||||
if (serial_recive_packet((uint8_t *)trans->initiator2target_buffer, |
|
||||||
trans->initiator2target_buffer_size) ) { |
|
||||||
*trans->status = TRANSACTION_ACCEPTED; |
|
||||||
} else { |
|
||||||
*trans->status = TRANSACTION_DATA_ERROR; |
|
||||||
} |
|
||||||
} else { |
|
||||||
*trans->status = TRANSACTION_ACCEPTED; |
|
||||||
} |
|
||||||
|
|
||||||
sync_recv(); //weit initiator output to high
|
|
||||||
} |
|
||||||
|
|
||||||
/////////
|
|
||||||
// start transaction by initiator
|
|
||||||
//
|
|
||||||
// int soft_serial_transaction(int sstd_index)
|
|
||||||
//
|
|
||||||
// Returns:
|
|
||||||
// TRANSACTION_END
|
|
||||||
// TRANSACTION_NO_RESPONSE
|
|
||||||
// TRANSACTION_DATA_ERROR
|
|
||||||
// this code is very time dependent, so we need to disable interrupts
|
|
||||||
#ifndef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
int soft_serial_transaction(void) { |
|
||||||
SSTD_t *trans = Transaction_table; |
|
||||||
#else |
|
||||||
int soft_serial_transaction(int sstd_index) { |
|
||||||
if( sstd_index > Transaction_table_size ) |
|
||||||
return TRANSACTION_TYPE_ERROR; |
|
||||||
SSTD_t *trans = &Transaction_table[sstd_index]; |
|
||||||
#endif |
|
||||||
cli(); |
|
||||||
|
|
||||||
// signal to the target that we want to start a transaction
|
|
||||||
serial_output(); |
|
||||||
serial_low(); |
|
||||||
_delay_us(SLAVE_INT_WIDTH_US); |
|
||||||
|
|
||||||
#ifndef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
// wait for the target response
|
|
||||||
serial_input_with_pullup(); |
|
||||||
_delay_us(SLAVE_INT_RESPONSE_TIME); |
|
||||||
|
|
||||||
// check if the target is present
|
|
||||||
if (serial_read_pin()) { |
|
||||||
// target failed to pull the line low, assume not present
|
|
||||||
serial_output(); |
|
||||||
serial_high(); |
|
||||||
*trans->status = TRANSACTION_NO_RESPONSE; |
|
||||||
sei(); |
|
||||||
return TRANSACTION_NO_RESPONSE; |
|
||||||
} |
|
||||||
|
|
||||||
#else |
|
||||||
// send transaction table index
|
|
||||||
int tid = (sstd_index<<3) | (7 & nibble_bits_count(sstd_index)); |
|
||||||
sync_send(); |
|
||||||
_delay_sub_us(TID_SEND_ADJUST); |
|
||||||
serial_write_chunk(tid, 7); |
|
||||||
serial_delay_half1(); |
|
||||||
|
|
||||||
// wait for the target response (step1 low->high)
|
|
||||||
serial_input_with_pullup(); |
|
||||||
while( !serial_read_pin() ) { |
|
||||||
_delay_sub_us(2); |
|
||||||
} |
|
||||||
|
|
||||||
// check if the target is present (step2 high->low)
|
|
||||||
for( int i = 0; serial_read_pin(); i++ ) { |
|
||||||
if (i > SLAVE_INT_ACK_WIDTH + 1) { |
|
||||||
// slave failed to pull the line low, assume not present
|
|
||||||
serial_output(); |
|
||||||
serial_high(); |
|
||||||
*trans->status = TRANSACTION_NO_RESPONSE; |
|
||||||
sei(); |
|
||||||
return TRANSACTION_NO_RESPONSE; |
|
||||||
} |
|
||||||
_delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT); |
|
||||||
} |
|
||||||
#endif |
|
||||||
|
|
||||||
// initiator recive phase
|
|
||||||
// if the target is present syncronize with it
|
|
||||||
if( trans->target2initiator_buffer_size > 0 ) { |
|
||||||
if (!serial_recive_packet((uint8_t *)trans->target2initiator_buffer, |
|
||||||
trans->target2initiator_buffer_size) ) { |
|
||||||
serial_output(); |
|
||||||
serial_high(); |
|
||||||
*trans->status = TRANSACTION_DATA_ERROR; |
|
||||||
sei(); |
|
||||||
return TRANSACTION_DATA_ERROR; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// initiator switch to output
|
|
||||||
change_reciver2sender(); |
|
||||||
|
|
||||||
// initiator send phase
|
|
||||||
if( trans->initiator2target_buffer_size > 0 ) { |
|
||||||
serial_send_packet((uint8_t *)trans->initiator2target_buffer, |
|
||||||
trans->initiator2target_buffer_size); |
|
||||||
} |
|
||||||
|
|
||||||
// always, release the line when not in use
|
|
||||||
sync_send(); |
|
||||||
|
|
||||||
*trans->status = TRANSACTION_END; |
|
||||||
sei(); |
|
||||||
return TRANSACTION_END; |
|
||||||
} |
|
||||||
|
|
||||||
#ifdef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
int soft_serial_get_and_clean_status(int sstd_index) { |
|
||||||
SSTD_t *trans = &Transaction_table[sstd_index]; |
|
||||||
cli(); |
|
||||||
int retval = *trans->status; |
|
||||||
*trans->status = 0;; |
|
||||||
sei(); |
|
||||||
return retval; |
|
||||||
} |
|
||||||
#endif |
|
||||||
|
|
||||||
#endif |
|
||||||
|
|
||||||
// Helix serial.c history
|
|
||||||
// 2018-1-29 fork from let's split and add PD2, modify sync_recv() (#2308, bceffdefc)
|
|
||||||
// 2018-6-28 bug fix master to slave comm and speed up (#3255, 1038bbef4)
|
|
||||||
// (adjusted with avr-gcc 4.9.2)
|
|
||||||
// 2018-7-13 remove USE_SERIAL_PD2 macro (#3374, f30d6dd78)
|
|
||||||
// (adjusted with avr-gcc 4.9.2)
|
|
||||||
// 2018-8-11 add support multi-type transaction (#3608, feb5e4aae)
|
|
||||||
// (adjusted with avr-gcc 4.9.2)
|
|
||||||
// 2018-10-21 fix serial and RGB animation conflict (#4191, 4665e4fff)
|
|
||||||
// (adjusted with avr-gcc 7.3.0)
|
|
||||||
// 2018-10-28 re-adjust compiler depend value of delay (#4269, 8517f8a66)
|
|
||||||
// (adjusted with avr-gcc 5.4.0, 7.3.0)
|
|
||||||
@ -1,86 +0,0 @@ |
|||||||
#pragma once |
|
||||||
|
|
||||||
#include <stdbool.h> |
|
||||||
|
|
||||||
// /////////////////////////////////////////////////////////////////
|
|
||||||
// Need Soft Serial defines in config.h
|
|
||||||
// /////////////////////////////////////////////////////////////////
|
|
||||||
// ex.
|
|
||||||
// #define SOFT_SERIAL_PIN ?? // ?? = D0,D1,D2,D3,E6
|
|
||||||
// OPTIONAL: #define SELECT_SOFT_SERIAL_SPEED ? // ? = 1,2,3,4,5
|
|
||||||
// // 1: about 137kbps (default)
|
|
||||||
// // 2: about 75kbps
|
|
||||||
// // 3: about 39kbps
|
|
||||||
// // 4: about 26kbps
|
|
||||||
// // 5: about 20kbps
|
|
||||||
//
|
|
||||||
// //// USE OLD API (compatible with let's split serial.c)
|
|
||||||
// ex.
|
|
||||||
// #define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
|
|
||||||
// #define SERIAL_MASTER_BUFFER_LENGTH 1
|
|
||||||
//
|
|
||||||
// //// USE NEW API
|
|
||||||
// //// USE simple API (using signle-type transaction function)
|
|
||||||
// #define SERIAL_USE_SINGLE_TRANSACTION
|
|
||||||
// //// USE flexible API (using multi-type transaction function)
|
|
||||||
// #define SERIAL_USE_MULTI_TRANSACTION
|
|
||||||
//
|
|
||||||
// /////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
|
|
||||||
//////////////// for backward compatibility ////////////////////////////////
|
|
||||||
#if !defined(SERIAL_USE_SINGLE_TRANSACTION) && !defined(SERIAL_USE_MULTI_TRANSACTION) |
|
||||||
/* --- USE OLD API (compatible with let's split serial.c) */ |
|
||||||
#if SERIAL_SLAVE_BUFFER_LENGTH > 0 |
|
||||||
extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH]; |
|
||||||
#endif |
|
||||||
#if SERIAL_MASTER_BUFFER_LENGTH > 0 |
|
||||||
extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH]; |
|
||||||
#endif |
|
||||||
|
|
||||||
void serial_master_init(void); |
|
||||||
void serial_slave_init(void); |
|
||||||
int serial_update_buffers(void); |
|
||||||
|
|
||||||
#endif // end of USE OLD API
|
|
||||||
////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
// Soft Serial Transaction Descriptor
|
|
||||||
typedef struct _SSTD_t { |
|
||||||
uint8_t *status; |
|
||||||
uint8_t initiator2target_buffer_size; |
|
||||||
uint8_t *initiator2target_buffer; |
|
||||||
uint8_t target2initiator_buffer_size; |
|
||||||
uint8_t *target2initiator_buffer; |
|
||||||
} SSTD_t; |
|
||||||
#define TID_LIMIT( table ) (sizeof(table) / sizeof(SSTD_t)) |
|
||||||
|
|
||||||
// initiator is transaction start side
|
|
||||||
void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size); |
|
||||||
// target is interrupt accept side
|
|
||||||
void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size); |
|
||||||
|
|
||||||
// initiator resullt
|
|
||||||
#define TRANSACTION_END 0 |
|
||||||
#define TRANSACTION_NO_RESPONSE 0x1 |
|
||||||
#define TRANSACTION_DATA_ERROR 0x2 |
|
||||||
#define TRANSACTION_TYPE_ERROR 0x4 |
|
||||||
#ifndef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
int soft_serial_transaction(void); |
|
||||||
#else |
|
||||||
int soft_serial_transaction(int sstd_index); |
|
||||||
#endif |
|
||||||
|
|
||||||
// target status
|
|
||||||
// *SSTD_t.status has
|
|
||||||
// initiator:
|
|
||||||
// TRANSACTION_END
|
|
||||||
// or TRANSACTION_NO_RESPONSE
|
|
||||||
// or TRANSACTION_DATA_ERROR
|
|
||||||
// target:
|
|
||||||
// TRANSACTION_DATA_ERROR
|
|
||||||
// or TRANSACTION_ACCEPTED
|
|
||||||
#define TRANSACTION_ACCEPTED 0x8 |
|
||||||
#ifdef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
int soft_serial_get_and_clean_status(int sstd_index); |
|
||||||
#endif |
|
||||||
@ -1,341 +0,0 @@ |
|||||||
|
|
||||||
#ifdef SSD1306OLED |
|
||||||
|
|
||||||
#include "ssd1306.h" |
|
||||||
#include "i2c.h" |
|
||||||
#include <string.h> |
|
||||||
#include "print.h" |
|
||||||
#ifndef LOCAL_GLCDFONT |
|
||||||
#include "common/glcdfont.c" |
|
||||||
#else |
|
||||||
#include "helixfont.h" |
|
||||||
#endif |
|
||||||
#ifdef PROTOCOL_LUFA |
|
||||||
#include "lufa.h" |
|
||||||
#endif |
|
||||||
#include "sendchar.h" |
|
||||||
#include "timer.h" |
|
||||||
|
|
||||||
struct CharacterMatrix display; |
|
||||||
|
|
||||||
// Set this to 1 to help diagnose early startup problems
|
|
||||||
// when testing power-on with ble. Turn it off otherwise,
|
|
||||||
// as the latency of printing most of the debug info messes
|
|
||||||
// with the matrix scan, causing keys to drop.
|
|
||||||
#define DEBUG_TO_SCREEN 0 |
|
||||||
|
|
||||||
//static uint16_t last_battery_update;
|
|
||||||
//static uint32_t vbat;
|
|
||||||
//#define BatteryUpdateInterval 10000 /* milliseconds */
|
|
||||||
|
|
||||||
// 'last_flush' is declared as uint16_t,
|
|
||||||
// so this must be less than 65535
|
|
||||||
#define ScreenOffInterval 60000 /* milliseconds */ |
|
||||||
#if DEBUG_TO_SCREEN |
|
||||||
static uint8_t displaying; |
|
||||||
#endif |
|
||||||
static uint16_t last_flush; |
|
||||||
|
|
||||||
static bool force_dirty = true; |
|
||||||
|
|
||||||
// Write command sequence.
|
|
||||||
// Returns true on success.
|
|
||||||
static inline bool _send_cmd1(uint8_t cmd) { |
|
||||||
bool res = false; |
|
||||||
|
|
||||||
if (i2c_start_write(SSD1306_ADDRESS)) { |
|
||||||
xprintf("failed to start write to %d\n", SSD1306_ADDRESS); |
|
||||||
goto done; |
|
||||||
} |
|
||||||
|
|
||||||
if (i2c_master_write(0x0 /* command byte follows */)) { |
|
||||||
print("failed to write control byte\n"); |
|
||||||
|
|
||||||
goto done; |
|
||||||
} |
|
||||||
|
|
||||||
if (i2c_master_write(cmd)) { |
|
||||||
xprintf("failed to write command %d\n", cmd); |
|
||||||
goto done; |
|
||||||
} |
|
||||||
res = true; |
|
||||||
done: |
|
||||||
i2c_master_stop(); |
|
||||||
return res; |
|
||||||
} |
|
||||||
|
|
||||||
// Write 2-byte command sequence.
|
|
||||||
// Returns true on success
|
|
||||||
static inline bool _send_cmd2(uint8_t cmd, uint8_t opr) { |
|
||||||
if (!_send_cmd1(cmd)) { |
|
||||||
return false; |
|
||||||
} |
|
||||||
return _send_cmd1(opr); |
|
||||||
} |
|
||||||
|
|
||||||
// Write 3-byte command sequence.
|
|
||||||
// Returns true on success
|
|
||||||
static inline bool _send_cmd3(uint8_t cmd, uint8_t opr1, uint8_t opr2) { |
|
||||||
if (!_send_cmd1(cmd)) { |
|
||||||
return false; |
|
||||||
} |
|
||||||
if (!_send_cmd1(opr1)) { |
|
||||||
return false; |
|
||||||
} |
|
||||||
return _send_cmd1(opr2); |
|
||||||
} |
|
||||||
|
|
||||||
#define send_cmd1(c) if (!_send_cmd1(c)) {goto done;} |
|
||||||
#define send_cmd2(c,o) if (!_send_cmd2(c,o)) {goto done;} |
|
||||||
#define send_cmd3(c,o1,o2) if (!_send_cmd3(c,o1,o2)) {goto done;} |
|
||||||
|
|
||||||
static void clear_display(void) { |
|
||||||
matrix_clear(&display); |
|
||||||
|
|
||||||
// Clear all of the display bits (there can be random noise
|
|
||||||
// in the RAM on startup)
|
|
||||||
send_cmd3(PageAddr, 0, (DisplayHeight / 8) - 1); |
|
||||||
send_cmd3(ColumnAddr, 0, DisplayWidth - 1); |
|
||||||
|
|
||||||
if (i2c_start_write(SSD1306_ADDRESS)) { |
|
||||||
goto done; |
|
||||||
} |
|
||||||
if (i2c_master_write(0x40)) { |
|
||||||
// Data mode
|
|
||||||
goto done; |
|
||||||
} |
|
||||||
for (uint8_t row = 0; row < MatrixRows; ++row) { |
|
||||||
for (uint8_t col = 0; col < DisplayWidth; ++col) { |
|
||||||
i2c_master_write(0); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
display.dirty = false; |
|
||||||
|
|
||||||
done: |
|
||||||
i2c_master_stop(); |
|
||||||
} |
|
||||||
|
|
||||||
#if DEBUG_TO_SCREEN |
|
||||||
#undef sendchar |
|
||||||
static int8_t capture_sendchar(uint8_t c) { |
|
||||||
sendchar(c); |
|
||||||
iota_gfx_write_char(c); |
|
||||||
|
|
||||||
if (!displaying) { |
|
||||||
iota_gfx_flush(); |
|
||||||
} |
|
||||||
return 0; |
|
||||||
} |
|
||||||
#endif |
|
||||||
|
|
||||||
bool iota_gfx_init(bool rotate) { |
|
||||||
bool success = false; |
|
||||||
|
|
||||||
i2c_master_init(); |
|
||||||
send_cmd1(DisplayOff); |
|
||||||
send_cmd2(SetDisplayClockDiv, 0x80); |
|
||||||
send_cmd2(SetMultiPlex, DisplayHeight - 1); |
|
||||||
|
|
||||||
send_cmd2(SetDisplayOffset, 0); |
|
||||||
|
|
||||||
|
|
||||||
send_cmd1(SetStartLine | 0x0); |
|
||||||
send_cmd2(SetChargePump, 0x14 /* Enable */); |
|
||||||
send_cmd2(SetMemoryMode, 0 /* horizontal addressing */); |
|
||||||
|
|
||||||
if(rotate){ |
|
||||||
// the following Flip the display orientation 180 degrees
|
|
||||||
send_cmd1(SegRemap); |
|
||||||
send_cmd1(ComScanInc); |
|
||||||
}else{ |
|
||||||
// Flips the display orientation 0 degrees
|
|
||||||
send_cmd1(SegRemap | 0x1); |
|
||||||
send_cmd1(ComScanDec); |
|
||||||
} |
|
||||||
|
|
||||||
send_cmd2(SetComPins, 0x2); |
|
||||||
send_cmd2(SetContrast, 0x8f); |
|
||||||
send_cmd2(SetPreCharge, 0xf1); |
|
||||||
send_cmd2(SetVComDetect, 0x40); |
|
||||||
send_cmd1(DisplayAllOnResume); |
|
||||||
send_cmd1(NormalDisplay); |
|
||||||
send_cmd1(DeActivateScroll); |
|
||||||
send_cmd1(DisplayOn); |
|
||||||
|
|
||||||
send_cmd2(SetContrast, 0); // Dim
|
|
||||||
|
|
||||||
clear_display(); |
|
||||||
|
|
||||||
success = true; |
|
||||||
|
|
||||||
iota_gfx_flush(); |
|
||||||
|
|
||||||
#if DEBUG_TO_SCREEN |
|
||||||
print_set_sendchar(capture_sendchar); |
|
||||||
#endif |
|
||||||
|
|
||||||
done: |
|
||||||
return success; |
|
||||||
} |
|
||||||
|
|
||||||
bool iota_gfx_off(void) { |
|
||||||
bool success = false; |
|
||||||
|
|
||||||
send_cmd1(DisplayOff); |
|
||||||
success = true; |
|
||||||
|
|
||||||
done: |
|
||||||
return success; |
|
||||||
} |
|
||||||
|
|
||||||
bool iota_gfx_on(void) { |
|
||||||
bool success = false; |
|
||||||
|
|
||||||
send_cmd1(DisplayOn); |
|
||||||
success = true; |
|
||||||
|
|
||||||
done: |
|
||||||
return success; |
|
||||||
} |
|
||||||
|
|
||||||
void matrix_write_char_inner(struct CharacterMatrix *matrix, uint8_t c) { |
|
||||||
*matrix->cursor = c; |
|
||||||
++matrix->cursor; |
|
||||||
|
|
||||||
if (matrix->cursor - &matrix->display[0][0] == sizeof(matrix->display)) { |
|
||||||
// We went off the end; scroll the display upwards by one line
|
|
||||||
memmove(&matrix->display[0], &matrix->display[1], |
|
||||||
MatrixCols * (MatrixRows - 1)); |
|
||||||
matrix->cursor = &matrix->display[MatrixRows - 1][0]; |
|
||||||
memset(matrix->cursor, ' ', MatrixCols); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
void matrix_write_char(struct CharacterMatrix *matrix, uint8_t c) { |
|
||||||
matrix->dirty = true; |
|
||||||
|
|
||||||
if (c == '\n') { |
|
||||||
// Clear to end of line from the cursor and then move to the
|
|
||||||
// start of the next line
|
|
||||||
uint8_t cursor_col = (matrix->cursor - &matrix->display[0][0]) % MatrixCols; |
|
||||||
|
|
||||||
while (cursor_col++ < MatrixCols) { |
|
||||||
matrix_write_char_inner(matrix, ' '); |
|
||||||
} |
|
||||||
return; |
|
||||||
} |
|
||||||
|
|
||||||
matrix_write_char_inner(matrix, c); |
|
||||||
} |
|
||||||
|
|
||||||
void iota_gfx_write_char(uint8_t c) { |
|
||||||
matrix_write_char(&display, c); |
|
||||||
} |
|
||||||
|
|
||||||
void matrix_write(struct CharacterMatrix *matrix, const char *data) { |
|
||||||
const char *end = data + strlen(data); |
|
||||||
while (data < end) { |
|
||||||
matrix_write_char(matrix, *data); |
|
||||||
++data; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
void iota_gfx_write(const char *data) { |
|
||||||
matrix_write(&display, data); |
|
||||||
} |
|
||||||
|
|
||||||
void matrix_write_P(struct CharacterMatrix *matrix, const char *data) { |
|
||||||
while (true) { |
|
||||||
uint8_t c = pgm_read_byte(data); |
|
||||||
if (c == 0) { |
|
||||||
return; |
|
||||||
} |
|
||||||
matrix_write_char(matrix, c); |
|
||||||
++data; |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
void iota_gfx_write_P(const char *data) { |
|
||||||
matrix_write_P(&display, data); |
|
||||||
} |
|
||||||
|
|
||||||
void matrix_clear(struct CharacterMatrix *matrix) { |
|
||||||
memset(matrix->display, ' ', sizeof(matrix->display)); |
|
||||||
matrix->cursor = &matrix->display[0][0]; |
|
||||||
matrix->dirty = true; |
|
||||||
} |
|
||||||
|
|
||||||
void iota_gfx_clear_screen(void) { |
|
||||||
matrix_clear(&display); |
|
||||||
} |
|
||||||
|
|
||||||
void matrix_render(struct CharacterMatrix *matrix) { |
|
||||||
last_flush = timer_read(); |
|
||||||
iota_gfx_on(); |
|
||||||
#if DEBUG_TO_SCREEN |
|
||||||
++displaying; |
|
||||||
#endif |
|
||||||
|
|
||||||
// Move to the home position
|
|
||||||
send_cmd3(PageAddr, 0, MatrixRows - 1); |
|
||||||
send_cmd3(ColumnAddr, 0, (MatrixCols * FontWidth) - 1); |
|
||||||
|
|
||||||
if (i2c_start_write(SSD1306_ADDRESS)) { |
|
||||||
goto done; |
|
||||||
} |
|
||||||
if (i2c_master_write(0x40)) { |
|
||||||
// Data mode
|
|
||||||
goto done; |
|
||||||
} |
|
||||||
|
|
||||||
for (uint8_t row = 0; row < MatrixRows; ++row) { |
|
||||||
for (uint8_t col = 0; col < MatrixCols; ++col) { |
|
||||||
const uint8_t *glyph = font + (matrix->display[row][col] * FontWidth); |
|
||||||
|
|
||||||
for (uint8_t glyphCol = 0; glyphCol < FontWidth; ++glyphCol) { |
|
||||||
uint8_t colBits = pgm_read_byte(glyph + glyphCol); |
|
||||||
i2c_master_write(colBits); |
|
||||||
} |
|
||||||
|
|
||||||
// 1 column of space between chars (it's not included in the glyph)
|
|
||||||
//i2c_master_write(0);
|
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
matrix->dirty = false; |
|
||||||
|
|
||||||
done: |
|
||||||
i2c_master_stop(); |
|
||||||
#if DEBUG_TO_SCREEN |
|
||||||
--displaying; |
|
||||||
#endif |
|
||||||
} |
|
||||||
|
|
||||||
void iota_gfx_flush(void) { |
|
||||||
matrix_render(&display); |
|
||||||
} |
|
||||||
|
|
||||||
__attribute__ ((weak)) |
|
||||||
void iota_gfx_task_user(void) { |
|
||||||
} |
|
||||||
|
|
||||||
void iota_gfx_task(void) { |
|
||||||
iota_gfx_task_user(); |
|
||||||
|
|
||||||
if (display.dirty|| force_dirty) { |
|
||||||
iota_gfx_flush(); |
|
||||||
force_dirty = false; |
|
||||||
} |
|
||||||
|
|
||||||
if (timer_elapsed(last_flush) > ScreenOffInterval) { |
|
||||||
iota_gfx_off(); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
bool process_record_gfx(uint16_t keycode, keyrecord_t *record) { |
|
||||||
force_dirty = true; |
|
||||||
return true; |
|
||||||
} |
|
||||||
|
|
||||||
#endif |
|
||||||
@ -1,89 +0,0 @@ |
|||||||
#pragma once |
|
||||||
|
|
||||||
#include <stdbool.h> |
|
||||||
#include <stdio.h> |
|
||||||
#include "action.h" |
|
||||||
|
|
||||||
enum ssd1306_cmds { |
|
||||||
DisplayOff = 0xAE, |
|
||||||
DisplayOn = 0xAF, |
|
||||||
|
|
||||||
SetContrast = 0x81, |
|
||||||
DisplayAllOnResume = 0xA4, |
|
||||||
|
|
||||||
DisplayAllOn = 0xA5, |
|
||||||
NormalDisplay = 0xA6, |
|
||||||
InvertDisplay = 0xA7, |
|
||||||
SetDisplayOffset = 0xD3, |
|
||||||
SetComPins = 0xda, |
|
||||||
SetVComDetect = 0xdb, |
|
||||||
SetDisplayClockDiv = 0xD5, |
|
||||||
SetPreCharge = 0xd9, |
|
||||||
SetMultiPlex = 0xa8, |
|
||||||
SetLowColumn = 0x00, |
|
||||||
SetHighColumn = 0x10, |
|
||||||
SetStartLine = 0x40, |
|
||||||
|
|
||||||
SetMemoryMode = 0x20, |
|
||||||
ColumnAddr = 0x21, |
|
||||||
PageAddr = 0x22, |
|
||||||
|
|
||||||
ComScanInc = 0xc0, |
|
||||||
ComScanDec = 0xc8, |
|
||||||
SegRemap = 0xa0, |
|
||||||
SetChargePump = 0x8d, |
|
||||||
ExternalVcc = 0x01, |
|
||||||
SwitchCapVcc = 0x02, |
|
||||||
|
|
||||||
ActivateScroll = 0x2f, |
|
||||||
DeActivateScroll = 0x2e, |
|
||||||
SetVerticalScrollArea = 0xa3, |
|
||||||
RightHorizontalScroll = 0x26, |
|
||||||
LeftHorizontalScroll = 0x27, |
|
||||||
VerticalAndRightHorizontalScroll = 0x29, |
|
||||||
VerticalAndLeftHorizontalScroll = 0x2a, |
|
||||||
}; |
|
||||||
|
|
||||||
// Controls the SSD1306 128x32 OLED display via i2c
|
|
||||||
|
|
||||||
#ifndef SSD1306_ADDRESS |
|
||||||
#define SSD1306_ADDRESS 0x3C |
|
||||||
#endif |
|
||||||
|
|
||||||
#define DisplayHeight 32 |
|
||||||
#define DisplayWidth 128 |
|
||||||
|
|
||||||
#define FontHeight 8 |
|
||||||
#define FontWidth 6 |
|
||||||
|
|
||||||
#define MatrixRows (DisplayHeight / FontHeight) |
|
||||||
#define MatrixCols (DisplayWidth / FontWidth) |
|
||||||
|
|
||||||
struct CharacterMatrix { |
|
||||||
uint8_t display[MatrixRows][MatrixCols]; |
|
||||||
uint8_t *cursor; |
|
||||||
bool dirty; |
|
||||||
}; |
|
||||||
|
|
||||||
extern struct CharacterMatrix display; |
|
||||||
|
|
||||||
bool iota_gfx_init(bool rotate); |
|
||||||
void iota_gfx_task(void); |
|
||||||
bool iota_gfx_off(void); |
|
||||||
bool iota_gfx_on(void); |
|
||||||
void iota_gfx_flush(void); |
|
||||||
void iota_gfx_write_char(uint8_t c); |
|
||||||
void iota_gfx_write(const char *data); |
|
||||||
void iota_gfx_write_P(const char *data); |
|
||||||
void iota_gfx_clear_screen(void); |
|
||||||
|
|
||||||
void iota_gfx_task_user(void); |
|
||||||
|
|
||||||
void matrix_clear(struct CharacterMatrix *matrix); |
|
||||||
void matrix_write_char_inner(struct CharacterMatrix *matrix, uint8_t c); |
|
||||||
void matrix_write_char(struct CharacterMatrix *matrix, uint8_t c); |
|
||||||
void matrix_write(struct CharacterMatrix *matrix, const char *data); |
|
||||||
void matrix_write_P(struct CharacterMatrix *matrix, const char *data); |
|
||||||
void matrix_render(struct CharacterMatrix *matrix); |
|
||||||
|
|
||||||
bool process_record_gfx(uint16_t keycode, keyrecord_t *record); |
|
||||||
@ -1,341 +0,0 @@ |
|||||||
/*
|
|
||||||
Copyright 2012 Jun Wako <wakojun@gmail.com> |
|
||||||
|
|
||||||
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/>.
|
|
||||||
*/ |
|
||||||
|
|
||||||
/*
|
|
||||||
* scan matrix |
|
||||||
*/ |
|
||||||
#include <stdint.h> |
|
||||||
#include <stdbool.h> |
|
||||||
#include <string.h> |
|
||||||
#include <avr/io.h> |
|
||||||
#include <avr/wdt.h> |
|
||||||
#include <avr/interrupt.h> |
|
||||||
#include <util/delay.h> |
|
||||||
#include "print.h" |
|
||||||
#include "debug.h" |
|
||||||
#include "util.h" |
|
||||||
#include "matrix.h" |
|
||||||
#include "split_util.h" |
|
||||||
#include "quantum.h" |
|
||||||
|
|
||||||
#ifdef USE_MATRIX_I2C |
|
||||||
# include "i2c.h" |
|
||||||
#else // USE_SERIAL
|
|
||||||
# include "split_scomm.h" |
|
||||||
#endif |
|
||||||
|
|
||||||
#ifndef DEBOUNCE |
|
||||||
# define DEBOUNCE 5 |
|
||||||
#endif |
|
||||||
|
|
||||||
#define ERROR_DISCONNECT_COUNT 5 |
|
||||||
|
|
||||||
static uint8_t debouncing = DEBOUNCE; |
|
||||||
static const int ROWS_PER_HAND = MATRIX_ROWS/2; |
|
||||||
static uint8_t error_count = 0; |
|
||||||
|
|
||||||
static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS; |
|
||||||
static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS; |
|
||||||
|
|
||||||
/* 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 read_cols(void); |
|
||||||
static void init_cols(void); |
|
||||||
static void unselect_rows(void); |
|
||||||
static void select_row(uint8_t row); |
|
||||||
static uint8_t matrix_master_scan(void); |
|
||||||
|
|
||||||
|
|
||||||
__attribute__ ((weak)) |
|
||||||
void matrix_init_kb(void) { |
|
||||||
matrix_init_user(); |
|
||||||
} |
|
||||||
|
|
||||||
__attribute__ ((weak)) |
|
||||||
void matrix_scan_kb(void) { |
|
||||||
matrix_scan_user(); |
|
||||||
} |
|
||||||
|
|
||||||
__attribute__ ((weak)) |
|
||||||
void matrix_init_user(void) { |
|
||||||
} |
|
||||||
|
|
||||||
__attribute__ ((weak)) |
|
||||||
void matrix_scan_user(void) { |
|
||||||
} |
|
||||||
|
|
||||||
inline |
|
||||||
uint8_t matrix_rows(void) |
|
||||||
{ |
|
||||||
return MATRIX_ROWS; |
|
||||||
} |
|
||||||
|
|
||||||
inline |
|
||||||
uint8_t matrix_cols(void) |
|
||||||
{ |
|
||||||
return MATRIX_COLS; |
|
||||||
} |
|
||||||
|
|
||||||
void matrix_init(void) |
|
||||||
{ |
|
||||||
split_keyboard_setup(); |
|
||||||
|
|
||||||
// initialize row and col
|
|
||||||
unselect_rows(); |
|
||||||
init_cols(); |
|
||||||
|
|
||||||
setPinOutput(B0); |
|
||||||
setPinOutput(D5); |
|
||||||
writePinHigh(B0); |
|
||||||
writePinHigh(D5); |
|
||||||
|
|
||||||
// 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) |
|
||||||
{ |
|
||||||
// Right hand is stored after the left in the matirx so, we need to offset it
|
|
||||||
int offset = isLeftHand ? 0 : (ROWS_PER_HAND); |
|
||||||
|
|
||||||
for (uint8_t i = 0; i < ROWS_PER_HAND; i++) { |
|
||||||
select_row(i); |
|
||||||
_delay_us(30); // without this wait read unstable value.
|
|
||||||
matrix_row_t cols = read_cols(); |
|
||||||
if (matrix_debouncing[i+offset] != cols) { |
|
||||||
matrix_debouncing[i+offset] = cols; |
|
||||||
debouncing = DEBOUNCE; |
|
||||||
} |
|
||||||
unselect_rows(); |
|
||||||
} |
|
||||||
|
|
||||||
if (debouncing) { |
|
||||||
if (--debouncing) { |
|
||||||
_delay_ms(1); |
|
||||||
} else { |
|
||||||
for (uint8_t i = 0; i < ROWS_PER_HAND; i++) { |
|
||||||
matrix[i+offset] = matrix_debouncing[i+offset]; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return 1; |
|
||||||
} |
|
||||||
|
|
||||||
#ifdef USE_MATRIX_I2C |
|
||||||
|
|
||||||
// Get rows from other half over i2c
|
|
||||||
int i2c_transaction(void) { |
|
||||||
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; |
|
||||||
|
|
||||||
int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE); |
|
||||||
if (err) goto i2c_error; |
|
||||||
|
|
||||||
// start of matrix stored at 0x00
|
|
||||||
err = i2c_master_write(0x00); |
|
||||||
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; |
|
||||||
} |
|
||||||
|
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
#else // USE_SERIAL
|
|
||||||
|
|
||||||
int serial_transaction(int master_changed) { |
|
||||||
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0; |
|
||||||
#ifdef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
int ret=serial_update_buffers(master_changed); |
|
||||||
#else |
|
||||||
int ret=serial_update_buffers(); |
|
||||||
#endif |
|
||||||
if (ret ) { |
|
||||||
if(ret==2) writePinLow(B0); |
|
||||||
return 1; |
|
||||||
} |
|
||||||
writePinHigh(B0); |
|
||||||
memcpy(&matrix[slaveOffset], |
|
||||||
(void *)serial_slave_buffer, sizeof(serial_slave_buffer)); |
|
||||||
return 0; |
|
||||||
} |
|
||||||
#endif |
|
||||||
|
|
||||||
uint8_t matrix_scan(void) |
|
||||||
{ |
|
||||||
if (is_helix_master()) { |
|
||||||
matrix_master_scan(); |
|
||||||
}else{ |
|
||||||
matrix_slave_scan(); |
|
||||||
int offset = (isLeftHand) ? ROWS_PER_HAND : 0; |
|
||||||
memcpy(&matrix[offset], |
|
||||||
(void *)serial_master_buffer, sizeof(serial_master_buffer)); |
|
||||||
matrix_scan_quantum(); |
|
||||||
} |
|
||||||
return 1; |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
uint8_t matrix_master_scan(void) { |
|
||||||
|
|
||||||
int ret = _matrix_scan(); |
|
||||||
int mchanged = 1; |
|
||||||
|
|
||||||
#ifndef KEYBOARD_helix_rev1 |
|
||||||
int offset = (isLeftHand) ? 0 : ROWS_PER_HAND; |
|
||||||
|
|
||||||
#ifdef USE_MATRIX_I2C |
|
||||||
// for (int i = 0; i < ROWS_PER_HAND; ++i) {
|
|
||||||
/* i2c_slave_buffer[i] = matrix[offset+i]; */ |
|
||||||
// i2c_slave_buffer[i] = matrix[offset+i];
|
|
||||||
// }
|
|
||||||
#else // USE_SERIAL
|
|
||||||
#ifdef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
mchanged = memcmp((void *)serial_master_buffer, |
|
||||||
&matrix[offset], sizeof(serial_master_buffer)); |
|
||||||
#endif |
|
||||||
memcpy((void *)serial_master_buffer, |
|
||||||
&matrix[offset], sizeof(serial_master_buffer)); |
|
||||||
#endif |
|
||||||
#endif |
|
||||||
|
|
||||||
#ifdef USE_MATRIX_I2C |
|
||||||
if( i2c_transaction() ) { |
|
||||||
#else // USE_SERIAL
|
|
||||||
if( serial_transaction(mchanged) ) { |
|
||||||
#endif |
|
||||||
// turn on the indicator led when halves are disconnected
|
|
||||||
writePinLow(D5); |
|
||||||
|
|
||||||
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 { |
|
||||||
// turn off the indicator led on no error
|
|
||||||
writePinHigh(D5); |
|
||||||
error_count = 0; |
|
||||||
} |
|
||||||
matrix_scan_quantum(); |
|
||||||
return ret; |
|
||||||
} |
|
||||||
|
|
||||||
void matrix_slave_scan(void) { |
|
||||||
_matrix_scan(); |
|
||||||
|
|
||||||
int offset = (isLeftHand) ? 0 : ROWS_PER_HAND; |
|
||||||
|
|
||||||
#ifdef USE_MATRIX_I2C |
|
||||||
for (int i = 0; i < ROWS_PER_HAND; ++i) { |
|
||||||
/* i2c_slave_buffer[i] = matrix[offset+i]; */ |
|
||||||
i2c_slave_buffer[i] = matrix[offset+i]; |
|
||||||
} |
|
||||||
#else // USE_SERIAL
|
|
||||||
#ifdef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
int change = 0; |
|
||||||
#endif |
|
||||||
for (int i = 0; i < ROWS_PER_HAND; ++i) { |
|
||||||
#ifdef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
if( serial_slave_buffer[i] != matrix[offset+i] ) |
|
||||||
change = 1; |
|
||||||
#endif |
|
||||||
serial_slave_buffer[i] = matrix[offset+i]; |
|
||||||
} |
|
||||||
#ifdef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
slave_buffer_change_count += change; |
|
||||||
#endif |
|
||||||
#endif |
|
||||||
} |
|
||||||
|
|
||||||
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++) { |
|
||||||
print_hex8(row); print(": "); |
|
||||||
print_bin_reverse16(matrix_get_row(row)); |
|
||||||
print("\n"); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static void init_cols(void) |
|
||||||
{ |
|
||||||
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) + 2) |= _BV(col_pins[x] & 0xF); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
static matrix_row_t read_cols(void) |
|
||||||
{ |
|
||||||
matrix_row_t result = 0; |
|
||||||
for(int x = 0; x < MATRIX_COLS; x++) { |
|
||||||
result |= (_SFR_IO8(col_pins[x] >> 4) & _BV(col_pins[x] & 0xF)) ? 0 : (1 << x); |
|
||||||
} |
|
||||||
return result; |
|
||||||
} |
|
||||||
|
|
||||||
static void unselect_rows(void) |
|
||||||
{ |
|
||||||
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) + 2) |= _BV(row_pins[x] & 0xF); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
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) + 2) &= ~_BV(row_pins[row] & 0xF); |
|
||||||
} |
|
||||||
@ -1,92 +0,0 @@ |
|||||||
#ifdef USE_SERIAL |
|
||||||
#ifdef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
/* --- USE flexible API (using multi-type transaction function) --- */ |
|
||||||
|
|
||||||
#include <stdbool.h> |
|
||||||
#include <stdint.h> |
|
||||||
#include <stddef.h> |
|
||||||
#include "split_scomm.h" |
|
||||||
#include "serial.h" |
|
||||||
#ifdef CONSOLE_ENABLE |
|
||||||
#include "print.h" |
|
||||||
#endif |
|
||||||
|
|
||||||
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 status_com = 0; |
|
||||||
uint8_t volatile status1 = 0; |
|
||||||
uint8_t slave_buffer_change_count = 0; |
|
||||||
uint8_t s_change_old = 0xff; |
|
||||||
uint8_t s_change_new = 0xff; |
|
||||||
|
|
||||||
SSTD_t transactions[] = { |
|
||||||
#define GET_SLAVE_STATUS 0 |
|
||||||
/* master buffer not changed, only recive slave_buffer_change_count */ |
|
||||||
{ (uint8_t *)&status_com, |
|
||||||
0, NULL, |
|
||||||
sizeof(slave_buffer_change_count), &slave_buffer_change_count, |
|
||||||
}, |
|
||||||
#define PUT_MASTER_GET_SLAVE_STATUS 1 |
|
||||||
/* master buffer changed need send, and recive slave_buffer_change_count */ |
|
||||||
{ (uint8_t *)&status_com, |
|
||||||
sizeof(serial_master_buffer), (uint8_t *)serial_master_buffer, |
|
||||||
sizeof(slave_buffer_change_count), &slave_buffer_change_count, |
|
||||||
}, |
|
||||||
#define GET_SLAVE_BUFFER 2 |
|
||||||
/* recive serial_slave_buffer */ |
|
||||||
{ (uint8_t *)&status1, |
|
||||||
0, NULL, |
|
||||||
sizeof(serial_slave_buffer), (uint8_t *)serial_slave_buffer |
|
||||||
} |
|
||||||
}; |
|
||||||
|
|
||||||
void serial_master_init(void) |
|
||||||
{ |
|
||||||
soft_serial_initiator_init(transactions, TID_LIMIT(transactions)); |
|
||||||
} |
|
||||||
|
|
||||||
void serial_slave_init(void) |
|
||||||
{ |
|
||||||
soft_serial_target_init(transactions, TID_LIMIT(transactions)); |
|
||||||
} |
|
||||||
|
|
||||||
// 0 => no error
|
|
||||||
// 1 => slave did not respond
|
|
||||||
// 2 => checksum error
|
|
||||||
int serial_update_buffers(int master_update) |
|
||||||
{ |
|
||||||
int status, smatstatus; |
|
||||||
static int need_retry = 0; |
|
||||||
|
|
||||||
if( s_change_old != s_change_new ) { |
|
||||||
smatstatus = soft_serial_transaction(GET_SLAVE_BUFFER); |
|
||||||
if( smatstatus == TRANSACTION_END ) { |
|
||||||
s_change_old = s_change_new; |
|
||||||
#ifdef CONSOLE_ENABLE |
|
||||||
uprintf("slave matrix = %b %b %b %b %b\n", |
|
||||||
serial_slave_buffer[0], serial_slave_buffer[1], |
|
||||||
serial_slave_buffer[2], serial_slave_buffer[3], |
|
||||||
serial_slave_buffer[4] ); |
|
||||||
#endif |
|
||||||
} |
|
||||||
} else { |
|
||||||
// serial_slave_buffer dosen't change
|
|
||||||
smatstatus = TRANSACTION_END; // dummy status
|
|
||||||
} |
|
||||||
|
|
||||||
if( !master_update && !need_retry) { |
|
||||||
status = soft_serial_transaction(GET_SLAVE_STATUS); |
|
||||||
} else { |
|
||||||
status = soft_serial_transaction(PUT_MASTER_GET_SLAVE_STATUS); |
|
||||||
} |
|
||||||
if( status == TRANSACTION_END ) { |
|
||||||
s_change_new = slave_buffer_change_count; |
|
||||||
need_retry = 0; |
|
||||||
} else { |
|
||||||
need_retry = 1; |
|
||||||
} |
|
||||||
return smatstatus; |
|
||||||
} |
|
||||||
|
|
||||||
#endif // SERIAL_USE_MULTI_TRANSACTION
|
|
||||||
#endif /* USE_SERIAL */ |
|
||||||
@ -1,21 +0,0 @@ |
|||||||
#pragma once |
|
||||||
|
|
||||||
#ifndef SERIAL_USE_MULTI_TRANSACTION |
|
||||||
/* --- USE Simple API (OLD API, compatible with let's split serial.c) --- */ |
|
||||||
#include "serial.h" |
|
||||||
|
|
||||||
#else |
|
||||||
/* --- USE flexible API (using multi-type transaction function) --- */ |
|
||||||
// Buffers for master - slave communication
|
|
||||||
#define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2 |
|
||||||
#define SERIAL_MASTER_BUFFER_LENGTH MATRIX_ROWS/2 |
|
||||||
|
|
||||||
extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH]; |
|
||||||
extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH]; |
|
||||||
extern uint8_t slave_buffer_change_count; |
|
||||||
|
|
||||||
void serial_master_init(void); |
|
||||||
void serial_slave_init(void); |
|
||||||
int serial_update_buffers(int master_changed); |
|
||||||
|
|
||||||
#endif |
|
||||||
@ -1,109 +0,0 @@ |
|||||||
#include <avr/io.h> |
|
||||||
#include <avr/wdt.h> |
|
||||||
#include <avr/power.h> |
|
||||||
#include <avr/interrupt.h> |
|
||||||
#include <util/delay.h> |
|
||||||
#include <avr/eeprom.h> |
|
||||||
#include "split_util.h" |
|
||||||
#include "matrix.h" |
|
||||||
#include "keyboard.h" |
|
||||||
#include "wait.h" |
|
||||||
|
|
||||||
#ifdef USE_MATRIX_I2C |
|
||||||
# include "i2c.h" |
|
||||||
#else |
|
||||||
# include "split_scomm.h" |
|
||||||
#endif |
|
||||||
|
|
||||||
#ifdef EE_HANDS |
|
||||||
# include "eeconfig.h" |
|
||||||
#endif |
|
||||||
|
|
||||||
#ifndef SPLIT_USB_TIMEOUT |
|
||||||
# define SPLIT_USB_TIMEOUT 2000 |
|
||||||
#endif |
|
||||||
|
|
||||||
#ifndef SPLIT_USB_TIMEOUT_POLL |
|
||||||
# define SPLIT_USB_TIMEOUT_POLL 10 |
|
||||||
#endif |
|
||||||
|
|
||||||
volatile bool isLeftHand = true; |
|
||||||
|
|
||||||
bool waitForUsb(void) { |
|
||||||
for (uint8_t i = 0; i < (SPLIT_USB_TIMEOUT / SPLIT_USB_TIMEOUT_POLL); i++) { |
|
||||||
// This will return true if a USB connection has been established
|
|
||||||
if (UDADDR & _BV(ADDEN)) { |
|
||||||
return true; |
|
||||||
} |
|
||||||
wait_ms(SPLIT_USB_TIMEOUT_POLL); |
|
||||||
} |
|
||||||
|
|
||||||
// Avoid NO_USB_STARTUP_CHECK - Disable USB as the previous checks seem to enable it somehow
|
|
||||||
(USBCON &= ~(_BV(USBE) | _BV(OTGPADE))); |
|
||||||
|
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
bool is_keyboard_left(void) { |
|
||||||
#if defined(SPLIT_HAND_PIN) |
|
||||||
// Test pin SPLIT_HAND_PIN for High/Low, if low it's right hand
|
|
||||||
setPinInput(SPLIT_HAND_PIN); |
|
||||||
return readPin(SPLIT_HAND_PIN); |
|
||||||
#elif defined(EE_HANDS) |
|
||||||
return eeconfig_read_handedness(); |
|
||||||
#elif defined(MASTER_RIGHT) |
|
||||||
return !is_helix_master(); |
|
||||||
#endif |
|
||||||
|
|
||||||
return is_helix_master(); |
|
||||||
} |
|
||||||
|
|
||||||
bool is_helix_master(void) { |
|
||||||
static enum { UNKNOWN, MASTER, SLAVE } usbstate = UNKNOWN; |
|
||||||
|
|
||||||
// only check once, as this is called often
|
|
||||||
if (usbstate == UNKNOWN) { |
|
||||||
#if defined(SPLIT_USB_DETECT) |
|
||||||
usbstate = waitForUsb() ? MASTER : SLAVE; |
|
||||||
#elif defined(__AVR__) |
|
||||||
USBCON |= (1 << OTGPADE); // enables VBUS pad
|
|
||||||
wait_us(5); |
|
||||||
|
|
||||||
usbstate = (USBSTA & (1 << VBUS)) ? MASTER : SLAVE; // checks state of VBUS
|
|
||||||
#else |
|
||||||
usbstate = MASTER; |
|
||||||
#endif |
|
||||||
} |
|
||||||
|
|
||||||
return (usbstate == MASTER); |
|
||||||
} |
|
||||||
|
|
||||||
static void keyboard_master_setup(void) { |
|
||||||
|
|
||||||
#ifdef USE_MATRIX_I2C |
|
||||||
i2c_master_init(); |
|
||||||
#else |
|
||||||
serial_master_init(); |
|
||||||
#endif |
|
||||||
} |
|
||||||
|
|
||||||
static void keyboard_slave_setup(void) { |
|
||||||
|
|
||||||
#ifdef USE_MATRIX_I2C |
|
||||||
i2c_slave_init(SLAVE_I2C_ADDRESS); |
|
||||||
#else |
|
||||||
serial_slave_init(); |
|
||||||
#endif |
|
||||||
} |
|
||||||
|
|
||||||
void split_keyboard_setup(void) { |
|
||||||
isLeftHand = is_keyboard_left(); |
|
||||||
|
|
||||||
if (is_helix_master()) { |
|
||||||
keyboard_master_setup(); |
|
||||||
} else { |
|
||||||
keyboard_slave_setup(); |
|
||||||
} |
|
||||||
sei(); |
|
||||||
} |
|
||||||
@ -1,21 +0,0 @@ |
|||||||
#pragma once |
|
||||||
|
|
||||||
#ifdef SPLIT_KEYBOARD |
|
||||||
# error This is helix local split_util.h. |
|
||||||
# error This header file is used only when SPLIT_KEYBOARD=no. |
|
||||||
#endif |
|
||||||
|
|
||||||
#include <stdbool.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 is_helix_master(void); |
|
||||||
|
|
||||||
void matrix_master_OLED_init (void); |
|
||||||
Loading…
Reference in new issue