1 #include <util/twi.h>
\r
4 #include <avr/interrupt.h>
\r
5 #include <util/twi.h>
\r
11 // Limits the amount of we wait for any one i2c transaction.
\r
12 // Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is
\r
13 // 9 bits, a single transaction will take around 90μs to complete.
\r
15 // (F_CPU/SCL_CLOCK) => # of μC cycles to transfer a bit
\r
16 // poll loop takes at least 8 clock cycles to execute
\r
17 #define I2C_LOOP_TIMEOUT (9+1)*(F_CPU/SCL_CLOCK)/8
\r
19 #define BUFFER_POS_INC() (slave_buffer_pos = (slave_buffer_pos+1)%SLAVE_BUFFER_SIZE)
\r
21 volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
\r
23 static volatile uint8_t slave_buffer_pos;
\r
24 static volatile bool slave_has_register_set = false;
\r
26 // Wait for an i2c operation to finish
\r
28 void i2c_delay(void) {
\r
30 while(!(TWCR & (1<<TWINT)) && lim < I2C_LOOP_TIMEOUT)
\r
33 // easier way, but will wait slightly longer
\r
37 // Setup twi to run at 100kHz
\r
38 void i2c_master_init(void) {
\r
41 // Set TWI clock frequency to SCL_CLOCK. Need TWBR>10.
\r
42 // Check datasheets for more info.
\r
43 TWBR = ((F_CPU/SCL_CLOCK)-16)/2;
\r
46 // Start a transaction with the given i2c slave address. The direction of the
\r
47 // transfer is set with I2C_READ and I2C_WRITE.
\r
48 // returns: 0 => success
\r
50 uint8_t i2c_master_start(uint8_t address) {
\r
51 TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);
\r
55 // check that we started successfully
\r
56 if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START))
\r
60 TWCR = (1<<TWINT) | (1<<TWEN);
\r
64 if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) )
\r
65 return 1; // slave did not acknowledge
\r
67 return 0; // success
\r
71 // Finish the i2c transaction.
\r
72 void i2c_master_stop(void) {
\r
73 TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
\r
76 while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT)
\r
80 // Write one byte to the i2c slave.
\r
81 // returns 0 => slave ACK
\r
83 uint8_t i2c_master_write(uint8_t data) {
\r
85 TWCR = (1<<TWINT) | (1<<TWEN);
\r
89 // check if the slave acknowledged us
\r
90 return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1;
\r
93 // Read one byte from the i2c slave. If ack=1 the slave is acknowledged,
\r
94 // if ack=0 the acknowledge bit is not set.
\r
95 // returns: byte read from i2c device
\r
96 uint8_t i2c_master_read(int ack) {
\r
97 TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA);
\r
103 void i2c_reset_state(void) {
\r
107 void i2c_slave_init(uint8_t address) {
\r
108 TWAR = address << 0; // slave i2c address
\r
109 // TWEN - twi enable
\r
110 // TWEA - enable address acknowledgement
\r
111 // TWINT - twi interrupt flag
\r
112 // TWIE - enable the twi interrupt
\r
113 TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN);
\r
120 switch(TW_STATUS) {
\r
121 case TW_SR_SLA_ACK:
\r
122 // this device has been addressed as a slave receiver
\r
123 slave_has_register_set = false;
\r
126 case TW_SR_DATA_ACK:
\r
127 // this device has received data as a slave receiver
\r
128 // The first byte that we receive in this transaction sets the location
\r
129 // of the read/write location of the slaves memory that it exposes over
\r
130 // i2c. After that, bytes will be written at slave_buffer_pos, incrementing
\r
131 // slave_buffer_pos after each write.
\r
132 if(!slave_has_register_set) {
\r
133 slave_buffer_pos = TWDR;
\r
134 // don't acknowledge the master if this memory loctaion is out of bounds
\r
135 if ( slave_buffer_pos >= SLAVE_BUFFER_SIZE ) {
\r
137 slave_buffer_pos = 0;
\r
139 slave_has_register_set = true;
\r
141 i2c_slave_buffer[slave_buffer_pos] = TWDR;
\r
146 case TW_ST_SLA_ACK:
\r
147 case TW_ST_DATA_ACK:
\r
148 // master has addressed this device as a slave transmitter and is
\r
149 // requesting data.
\r
150 TWDR = i2c_slave_buffer[slave_buffer_pos];
\r
154 case TW_BUS_ERROR: // something went wrong, reset twi state
\r
159 // Reset everything, so we are ready for the next TWI interrupt
\r
160 TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN);
\r