2,27 → 2,28 |
#include "i2c.h" |
|
static I2C_DATA i2c_data; |
static I2C_DATA *i2c_data_p = &i2c_data; |
|
// Set up the data structures for the i2c code |
// Should be called once before any i2c routines are called |
void I2C_Init() { |
i2c_data.buffer_in_len = 0; |
i2c_data.buffer_in_len_tmp = 0; |
i2c_data.buffer_in_read_ind = 0; |
i2c_data.buffer_in_write_ind = 0; |
i2c_data_p->buffer_in_len = 0; |
i2c_data_p->buffer_in_len_tmp = 0; |
i2c_data_p->buffer_in_read_ind = 0; |
i2c_data_p->buffer_in_write_ind = 0; |
|
i2c_data.buffer_out_ind = 0; |
i2c_data.buffer_out_len = 0; |
i2c_data_p->buffer_out_ind = 0; |
i2c_data_p->buffer_out_len = 0; |
|
i2c_data.operating_mode = 0; |
i2c_data.operating_state = I2C_IDLE; |
i2c_data.return_status = 0; |
i2c_data_p->operating_mode = 0; |
i2c_data_p->operating_state = I2C_IDLE; |
i2c_data_p->return_status = 0; |
|
i2c_data.slave_in_last_byte = 0; |
i2c_data.slave_sending_data = 0; |
i2c_data_p->slave_in_last_byte = 0; |
i2c_data_p->slave_sending_data = 0; |
|
i2c_data.master_dest_addr = 0; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data_p->master_dest_addr = 0; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
|
// Enable I2C interrupt |
PIE1bits.SSPIE = 1; |
30,7 → 31,7 |
|
// Setup the PIC to operate as a master. |
void I2C_Configure_Master(unsigned char speed) { |
i2c_data.operating_mode = I2C_MODE_MASTER; |
i2c_data_p->operating_mode = I2C_MODE_MASTER; |
|
TRISCbits.TRISC3 = 1; |
TRISCbits.TRISC4 = 1; |
56,16 → 57,16 |
|
// Copy message to send into buffer and save length/address |
for (i = 0; i < length; i++) { |
i2c_data.buffer_in[i] = msg[i]; |
i2c_data_p->buffer_in[i] = msg[i]; |
} |
i2c_data.buffer_in_len = length; |
i2c_data.master_dest_addr = address; |
i2c_data.buffer_in_read_ind = 0; |
i2c_data.buffer_in_write_ind = 0; |
i2c_data_p->buffer_in_len = length; |
i2c_data_p->master_dest_addr = address; |
i2c_data_p->buffer_in_read_ind = 0; |
i2c_data_p->buffer_in_write_ind = 0; |
|
// Change status to 'next' operation |
i2c_data.operating_state = I2C_SEND_ADDR; |
i2c_data.master_status = I2C_MASTER_SEND; |
i2c_data_p->operating_state = I2C_SEND_ADDR; |
i2c_data_p->master_status = I2C_MASTER_SEND; |
|
// Generate start condition |
SSPCON2bits.SEN = 1; |
77,14 → 78,14 |
return; |
|
// Save length and address to get data from |
i2c_data.buffer_in_len = length; |
i2c_data.master_dest_addr = address; |
i2c_data.buffer_in_read_ind = 0; |
i2c_data.buffer_in_write_ind = 0; |
i2c_data_p->buffer_in_len = length; |
i2c_data_p->master_dest_addr = address; |
i2c_data_p->buffer_in_read_ind = 0; |
i2c_data_p->buffer_in_write_ind = 0; |
|
// Change status to 'next' operation |
i2c_data.operating_state = I2C_SEND_ADDR; |
i2c_data.master_status = I2C_MASTER_RECV; |
i2c_data_p->operating_state = I2C_SEND_ADDR; |
i2c_data_p->master_status = I2C_MASTER_RECV; |
|
// Generate start condition |
SSPCON2bits.SEN = 1; |
100,15 → 101,15 |
} |
|
// Save length and address to get data from |
i2c_data.buffer_in[0] = msg; |
i2c_data.buffer_in_len = length; |
i2c_data.master_dest_addr = address; |
i2c_data.buffer_in_read_ind = 0; |
i2c_data.buffer_in_write_ind = 0; |
i2c_data_p->buffer_in[0] = msg; |
i2c_data_p->buffer_in_len = length; |
i2c_data_p->master_dest_addr = address; |
i2c_data_p->buffer_in_read_ind = 0; |
i2c_data_p->buffer_in_write_ind = 0; |
|
// Change status to 'next' operation |
i2c_data.operating_state = I2C_SEND_ADDR; |
i2c_data.master_status = I2C_MASTER_RESTART; |
i2c_data_p->operating_state = I2C_SEND_ADDR; |
i2c_data_p->master_status = I2C_MASTER_RESTART; |
|
// Generate start condition |
SSPCON2bits.SEN = 1; |
116,7 → 117,7 |
|
// Setup the PIC to operate as a slave. The address must not include the R/W bit |
void I2C_Configure_Slave(unsigned char addr) { |
i2c_data.operating_mode = I2C_MODE_SLAVE; |
i2c_data_p->operating_mode = I2C_MODE_SLAVE; |
|
// Ensure the two lines are set for input (we are a slave) |
TRISCbits.TRISC3 = 1; |
135,9 → 136,9 |
|
void I2C_Interrupt_Handler() { |
// Call interrupt depending on which mode we are operating in |
if (i2c_data.operating_mode == I2C_MODE_MASTER) { |
if (i2c_data_p->operating_mode == I2C_MODE_MASTER) { |
I2C_Interrupt_Master(); |
} else if (i2c_data.operating_mode == I2C_MODE_SLAVE) { |
} else if (i2c_data_p->operating_mode == I2C_MODE_SLAVE) { |
I2C_Interrupt_Slave(); |
} |
} |
145,75 → 146,75 |
// An internal subroutine used in the master version of the i2c_interrupt_handler |
void I2C_Interrupt_Master() { |
// If we are in the middle of sending data |
if (i2c_data.master_status == I2C_MASTER_SEND) { |
switch (i2c_data.operating_state) { |
if (i2c_data_p->master_status == I2C_MASTER_SEND) { |
switch (i2c_data_p->operating_state) { |
case I2C_IDLE: |
break; |
case I2C_SEND_ADDR: |
// Send the address with read bit set |
i2c_data.operating_state = I2C_CHECK_ACK_SEND; |
SSPBUF = (i2c_data.master_dest_addr << 1) | 0x0; |
i2c_data_p->operating_state = I2C_CHECK_ACK_SEND; |
SSPBUF = (i2c_data_p->master_dest_addr << 1) | 0x0; |
break; |
case I2C_CHECK_ACK_SEND: |
// Check if ACK is received or not |
if (!SSPCON2bits.ACKSTAT) { |
// If an ACK is received, send next byte of data |
if (i2c_data.buffer_in_read_ind < i2c_data.buffer_in_len) { |
SSPBUF = i2c_data.buffer_in[i2c_data.buffer_in_read_ind]; |
i2c_data.buffer_in_read_ind++; |
if (i2c_data_p->buffer_in_read_ind < i2c_data_p->buffer_in_len) { |
SSPBUF = i2c_data_p->buffer_in[i2c_data_p->buffer_in_read_ind]; |
i2c_data_p->buffer_in_read_ind++; |
} else { |
// If no more data is to be sent, send stop bit |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_SEND_OK; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
i2c_data_p->return_status = I2C_SEND_OK; |
} |
} else { |
// If a NACK is received, stop transmission and send error |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_SEND_FAIL; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
i2c_data_p->return_status = I2C_SEND_FAIL; |
} |
break; |
} |
// If we are in the middle of receiving data |
} else if (i2c_data.master_status == I2C_MASTER_RECV) { |
switch (i2c_data.operating_state) { |
} else if (i2c_data_p->master_status == I2C_MASTER_RECV) { |
switch (i2c_data_p->operating_state) { |
case I2C_IDLE: |
break; |
case I2C_SEND_ADDR: |
// Send address with write bit set |
i2c_data.operating_state = I2C_CHECK_ACK_RECV; |
SSPBUF = (i2c_data.master_dest_addr << 1) | 0x1; |
i2c_data_p->operating_state = I2C_CHECK_ACK_RECV; |
SSPBUF = (i2c_data_p->master_dest_addr << 1) | 0x1; |
break; |
case I2C_CHECK_ACK_RECV: |
// Check if ACK is received |
if (!SSPCON2bits.ACKSTAT) { |
// If an ACK is received, set module to receive 1 byte of data |
i2c_data.operating_state = I2C_RCV_DATA; |
i2c_data_p->operating_state = I2C_RCV_DATA; |
SSPCON2bits.RCEN = 1; |
} else { |
// If a NACK is received, stop transmission and send error |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_RECV_FAIL; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
i2c_data_p->return_status = I2C_RECV_FAIL; |
} |
break; |
case I2C_RCV_DATA: |
// On receive, save byte into buffer |
// TODO: handle i2c buffer overflow |
i2c_data.buffer_in[i2c_data.buffer_in_write_ind] = SSPBUF; |
i2c_data.buffer_in_write_ind++; |
if (i2c_data.buffer_in_write_ind < i2c_data.buffer_in_len) { |
i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = SSPBUF; |
i2c_data_p->buffer_in_write_ind++; |
if (i2c_data_p->buffer_in_write_ind < i2c_data_p->buffer_in_len) { |
// If we still need to read, send an ACK to the slave |
i2c_data.operating_state = I2C_REQ_DATA; |
i2c_data_p->operating_state = I2C_REQ_DATA; |
SSPCON2bits.ACKDT = 0; // ACK |
SSPCON2bits.ACKEN = 1; |
} else { |
// If we are done reading, send an NACK to the slave |
i2c_data.operating_state = I2C_SEND_STOP; |
i2c_data_p->operating_state = I2C_SEND_STOP; |
SSPCON2bits.ACKDT = 1; // NACK |
SSPCON2bits.ACKEN = 1; |
} |
220,84 → 221,84 |
break; |
case I2C_REQ_DATA: |
// Set module to receive one byte of data |
i2c_data.operating_state = I2C_RCV_DATA; |
i2c_data_p->operating_state = I2C_RCV_DATA; |
SSPCON2bits.RCEN = 1; |
break; |
case I2C_SEND_STOP: |
// Send the stop bit and copy message to send to Main() |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_RECV_OK; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
i2c_data_p->return_status = I2C_RECV_OK; |
break; |
} |
} else if (i2c_data.master_status == I2C_MASTER_RESTART) { |
switch (i2c_data.operating_state) { |
} else if (i2c_data_p->master_status == I2C_MASTER_RESTART) { |
switch (i2c_data_p->operating_state) { |
case I2C_IDLE: |
break; |
case I2C_SEND_ADDR: |
// Send the address with read bit set |
i2c_data.operating_state = I2C_CHECK_ACK_SEND; |
SSPBUF = (i2c_data.master_dest_addr << 1) | 0x0; |
i2c_data_p->operating_state = I2C_CHECK_ACK_SEND; |
SSPBUF = (i2c_data_p->master_dest_addr << 1) | 0x0; |
break; |
case I2C_CHECK_ACK_SEND: |
// Check if ACK is received or not |
if (!SSPCON2bits.ACKSTAT) { |
// If an ACK is received, send first byte of data |
SSPBUF = i2c_data.buffer_in[0]; |
i2c_data.operating_state = I2C_CHECK_ACK_RESTART; |
SSPBUF = i2c_data_p->buffer_in[0]; |
i2c_data_p->operating_state = I2C_CHECK_ACK_RESTART; |
} else { |
// If a NACK is received, stop transmission and send error |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_SEND_FAIL; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
i2c_data_p->return_status = I2C_SEND_FAIL; |
} |
break; |
case I2C_CHECK_ACK_RESTART: |
if (!SSPCON2bits.ACKSTAT) { |
SSPCON2bits.RSEN = 1; |
i2c_data.operating_state = I2C_SEND_ADDR_2; |
i2c_data_p->operating_state = I2C_SEND_ADDR_2; |
} else { |
// If a NACK is received, stop transmission and send error |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_SEND_FAIL; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
i2c_data_p->return_status = I2C_SEND_FAIL; |
} |
break; |
case I2C_SEND_ADDR_2: |
// Send the address with read bit set |
i2c_data.operating_state = I2C_CHECK_ACK_RECV; |
SSPBUF = (i2c_data.master_dest_addr << 1) | 0x1; |
i2c_data_p->operating_state = I2C_CHECK_ACK_RECV; |
SSPBUF = (i2c_data_p->master_dest_addr << 1) | 0x1; |
break; |
case I2C_CHECK_ACK_RECV: |
// Check if ACK is received |
if (!SSPCON2bits.ACKSTAT) { |
// If an ACK is received, set module to receive 1 byte of data |
i2c_data.operating_state = I2C_RCV_DATA; |
i2c_data_p->operating_state = I2C_RCV_DATA; |
SSPCON2bits.RCEN = 1; |
} else { |
// If a NACK is received, stop transmission and send error |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_RECV_FAIL; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
i2c_data_p->return_status = I2C_RECV_FAIL; |
} |
break; |
case I2C_RCV_DATA: |
// On receive, save byte into buffer |
// TODO: handle i2c buffer overflow |
i2c_data.buffer_in[i2c_data.buffer_in_write_ind] = SSPBUF; |
i2c_data.buffer_in_write_ind++; |
if (i2c_data.buffer_in_write_ind < i2c_data.buffer_in_len) { |
i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = SSPBUF; |
i2c_data_p->buffer_in_write_ind++; |
if (i2c_data_p->buffer_in_write_ind < i2c_data_p->buffer_in_len) { |
// If we still need to read, send an ACK to the slave |
i2c_data.operating_state = I2C_REQ_DATA; |
i2c_data_p->operating_state = I2C_REQ_DATA; |
SSPCON2bits.ACKDT = 0; // ACK |
SSPCON2bits.ACKEN = 1; |
} else { |
// If we are done reading, send an NACK to the slave |
i2c_data.operating_state = I2C_SEND_STOP; |
i2c_data_p->operating_state = I2C_SEND_STOP; |
SSPCON2bits.ACKDT = 1; // NACK |
SSPCON2bits.ACKEN = 1; |
} |
304,15 → 305,15 |
break; |
case I2C_REQ_DATA: |
// Set module to receive one byte of data |
i2c_data.operating_state = I2C_RCV_DATA; |
i2c_data_p->operating_state = I2C_RCV_DATA; |
SSPCON2bits.RCEN = 1; |
break; |
case I2C_SEND_STOP: |
// Send the stop bit and copy message to send to Main() |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
SSPCON2bits.PEN = 1; |
i2c_data.master_status = I2C_MASTER_IDLE; |
i2c_data.return_status = I2C_RECV_OK; |
i2c_data_p->master_status = I2C_MASTER_IDLE; |
i2c_data_p->return_status = I2C_RECV_OK; |
break; |
} |
} |
331,9 → 332,9 |
// We failed to read the buffer in time, so we know we |
// can't properly receive this message, just put us in the |
// a state where we are looking for a new message |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
overrun_error = 1; |
i2c_data.return_status = I2C_ERR_OVERRUN; |
i2c_data_p->return_status = I2C_ERR_OVERRUN; |
} |
|
// Read SPPxBUF if it is full |
344,29 → 345,29 |
} |
|
if (!overrun_error) { |
switch (i2c_data.operating_state) { |
switch (i2c_data_p->operating_state) { |
case I2C_IDLE: |
{ |
// Ignore anything except a start |
if (SSPSTATbits.S == 1) { |
i2c_data.buffer_in_len_tmp = 0; |
i2c_data.operating_state = I2C_STARTED; |
i2c_data_p->buffer_in_len_tmp = 0; |
i2c_data_p->operating_state = I2C_STARTED; |
// if (data_read_from_buffer) { |
// if (SSPSTATbits.D_A == 1) { |
// DBG_PRINT_I2C("I2C Start: (ERROR) no address recieved\r\n"); |
// // This is bad because we got data and we wanted an address |
// i2c_data.operating_state = I2C_IDLE; |
// i2c_data.return_status = I2C_ERR_NOADDR; |
// i2c_data_p->operating_state = I2C_IDLE; |
// i2c_data_p->return_status = I2C_ERR_NOADDR; |
// } else { |
// // Determine if we are sending or receiving data |
// if (SSPSTATbits.R_W == 1) { |
// i2c_data.operating_state = I2C_SEND_DATA; |
// i2c_data_p->operating_state = I2C_SEND_DATA; |
// } else { |
// i2c_data.operating_state = I2C_RCV_DATA; |
// i2c_data_p->operating_state = I2C_RCV_DATA; |
// } |
// } |
// } else { |
// i2c_data.operating_state = I2C_STARTED; |
// i2c_data_p->operating_state = I2C_STARTED; |
// } |
} |
break; |
376,23 → 377,23 |
// In this case, we expect either an address or a stop bit |
if (SSPSTATbits.P == 1) { |
// Return to idle mode |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->operating_state = I2C_IDLE; |
} else if (data_read_from_buffer) { |
if (SSPSTATbits.D_A == 0) { |
// Address received |
if (SSPSTATbits.R_W == 0) { |
// Slave write mode |
i2c_data.operating_state = I2C_RCV_DATA; |
i2c_data_p->operating_state = I2C_RCV_DATA; |
} else { |
// Slave read mode |
i2c_data.operating_state = I2C_SEND_DATA; |
i2c_data_p->operating_state = I2C_SEND_DATA; |
// Process the first byte immediatly if sending data |
goto send; |
} |
} else { |
DBG_PRINT_I2C("I2C: (ERROR) no data recieved\r\n"); |
i2c_data.operating_state = I2C_IDLE; |
i2c_data.return_status = I2C_ERR_NODATA; |
i2c_data_p->operating_state = I2C_IDLE; |
i2c_data_p->return_status = I2C_ERR_NODATA; |
} |
} |
break; |
400,29 → 401,29 |
send: |
case I2C_SEND_DATA: |
{ |
if (!i2c_data.slave_sending_data) { |
if (!i2c_data_p->slave_sending_data) { |
// If we are not currently sending data, figure out what to reply with |
if (I2C_Process_Send(i2c_data.slave_in_last_byte)) { |
if (I2C_Process_Send(i2c_data_p->slave_in_last_byte)) { |
// Data exists to be returned, send first byte |
SSPBUF = i2c_data.buffer_out[0]; |
i2c_data.buffer_out_ind = 1; |
i2c_data.slave_sending_data = 1; |
SSPBUF = i2c_data_p->buffer_out[0]; |
i2c_data_p->buffer_out_ind = 1; |
i2c_data_p->slave_sending_data = 1; |
data_written_to_buffer = 1; |
} else { |
// Unknown request |
i2c_data.slave_sending_data = 0; |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->slave_sending_data = 0; |
i2c_data_p->operating_state = I2C_IDLE; |
} |
} else { |
// Sending remaining data back to master |
if (i2c_data.buffer_out_ind < i2c_data.buffer_out_len) { |
SSPBUF = i2c_data.buffer_out[i2c_data.buffer_out_ind]; |
i2c_data.buffer_out_ind++; |
if (i2c_data_p->buffer_out_ind < i2c_data_p->buffer_out_len) { |
SSPBUF = i2c_data_p->buffer_out[i2c_data_p->buffer_out_ind]; |
i2c_data_p->buffer_out_ind++; |
data_written_to_buffer = 1; |
} else { |
// Nothing left to send |
i2c_data.slave_sending_data = 0; |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->slave_sending_data = 0; |
i2c_data_p->operating_state = I2C_IDLE; |
} |
} |
break; |
436,49 → 437,49 |
if (SSPSTATbits.D_A == 1) { |
// Data received with stop bit |
// TODO: handle i2c buffer overflow |
i2c_data.buffer_in[i2c_data.buffer_in_write_ind] = received_data; |
if (i2c_data.buffer_in_write_ind == MAXI2CBUF-1) { |
i2c_data.buffer_in_write_ind = 0; |
i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = received_data; |
if (i2c_data_p->buffer_in_write_ind == MAXI2CBUF-1) { |
i2c_data_p->buffer_in_write_ind = 0; |
} else { |
i2c_data.buffer_in_write_ind++; |
i2c_data_p->buffer_in_write_ind++; |
} |
i2c_data.buffer_in_len_tmp++; |
i2c_data_p->buffer_in_len_tmp++; |
// Save the last byte received |
i2c_data.slave_in_last_byte = received_data; |
i2c_data.return_status = I2C_DATA_AVAL; |
i2c_data_p->slave_in_last_byte = received_data; |
i2c_data_p->return_status = I2C_DATA_AVAL; |
} else { |
DBG_PRINT_I2C("I2C: (ERROR) no data recieved\r\n"); |
i2c_data.operating_state = I2C_IDLE; |
i2c_data.return_status = I2C_ERR_NODATA; |
i2c_data_p->operating_state = I2C_IDLE; |
i2c_data_p->return_status = I2C_ERR_NODATA; |
} |
} |
i2c_data.buffer_in_len += i2c_data.buffer_in_len_tmp; |
i2c_data.operating_state = I2C_IDLE; |
i2c_data_p->buffer_in_len += i2c_data_p->buffer_in_len_tmp; |
i2c_data_p->operating_state = I2C_IDLE; |
} else if (data_read_from_buffer) { |
if (SSPSTATbits.D_A == 1) { |
// Data received |
i2c_data.buffer_in[i2c_data.buffer_in_write_ind] = received_data; |
if (i2c_data.buffer_in_write_ind == MAXI2CBUF-1) { |
i2c_data.buffer_in_write_ind = 0; |
i2c_data_p->buffer_in[i2c_data_p->buffer_in_write_ind] = received_data; |
if (i2c_data_p->buffer_in_write_ind == MAXI2CBUF-1) { |
i2c_data_p->buffer_in_write_ind = 0; |
} else { |
i2c_data.buffer_in_write_ind++; |
i2c_data_p->buffer_in_write_ind++; |
} |
i2c_data.buffer_in_len_tmp++; |
i2c_data_p->buffer_in_len_tmp++; |
// Save the last byte received |
i2c_data.slave_in_last_byte = received_data; |
i2c_data.return_status = I2C_DATA_AVAL; |
i2c_data_p->slave_in_last_byte = received_data; |
i2c_data_p->return_status = I2C_DATA_AVAL; |
} else { |
// Restart bit detected |
if (SSPSTATbits.R_W == 1) { |
i2c_data.buffer_in_len += i2c_data.buffer_in_len_tmp; |
i2c_data.operating_state = I2C_SEND_DATA; |
i2c_data_p->buffer_in_len += i2c_data_p->buffer_in_len_tmp; |
i2c_data_p->operating_state = I2C_SEND_DATA; |
// Process the first byte immediatly if sending data |
goto send; |
} else { |
// Bad to recv an address again, we aren't ready |
DBG_PRINT_I2C("I2C: (ERROR) no data recieved\r\n"); |
i2c_data.operating_state = I2C_IDLE; |
i2c_data.return_status = I2C_ERR_NODATA; |
i2c_data_p->operating_state = I2C_IDLE; |
i2c_data_p->return_status = I2C_ERR_NODATA; |
} |
} |
} |
498,37 → 499,37 |
|
/* Returns 0 if I2C module is currently busy, otherwise returns status code */ |
unsigned char I2C_Get_Status() { |
if (i2c_data.operating_mode == I2C_MODE_MASTER) { |
if (i2c_data.master_status != I2C_MASTER_IDLE || i2c_data.buffer_in_len == 0) { |
if (i2c_data_p->operating_mode == I2C_MODE_MASTER) { |
if (i2c_data_p->master_status != I2C_MASTER_IDLE || i2c_data_p->buffer_in_len == 0) { |
return 0; |
} else { |
return i2c_data.return_status; |
return i2c_data_p->return_status; |
} |
} else if (i2c_data.operating_mode = I2C_MODE_SLAVE) { |
if (i2c_data.operating_state != I2C_IDLE || i2c_data.buffer_in_len == 0) { |
} else if (i2c_data_p->operating_mode = I2C_MODE_SLAVE) { |
if (i2c_data_p->operating_state != I2C_IDLE || i2c_data_p->buffer_in_len == 0) { |
return 0; |
} else { |
return i2c_data.return_status; |
return i2c_data_p->return_status; |
} |
} |
} |
|
unsigned char I2C_Buffer_Len() { |
return i2c_data.buffer_in_len; |
return i2c_data_p->buffer_in_len; |
} |
|
/* Returns 0 if I2C module is currently busy, otherwise returns buffer length */ |
unsigned char I2C_Read_Buffer(char *buffer) { |
unsigned char i = 0; |
while (i2c_data.buffer_in_len != 0) { |
buffer[i] = i2c_data.buffer_in[i2c_data.buffer_in_read_ind]; |
while (i2c_data_p->buffer_in_len != 0) { |
buffer[i] = i2c_data_p->buffer_in[i2c_data_p->buffer_in_read_ind]; |
i++; |
if (i2c_data.buffer_in_read_ind == MAXI2CBUF-1) { |
i2c_data.buffer_in_read_ind = 0; |
if (i2c_data_p->buffer_in_read_ind == MAXI2CBUF-1) { |
i2c_data_p->buffer_in_read_ind = 0; |
} else { |
i2c_data.buffer_in_read_ind++; |
i2c_data_p->buffer_in_read_ind++; |
} |
i2c_data.buffer_in_len--; |
i2c_data_p->buffer_in_len--; |
} |
return i; |
} |
538,14 → 539,14 |
unsigned char ret = 0; |
switch (c) { |
case 0xAA: |
i2c_data.buffer_out[0] = 'A'; |
i2c_data.buffer_out_len = 1; |
i2c_data_p->buffer_out[0] = 'A'; |
i2c_data_p->buffer_out_len = 1; |
ret = 1; |
break; |
case 0xBB: |
i2c_data.buffer_out[0] = '1'; |
i2c_data.buffer_out[1] = '2'; |
i2c_data.buffer_out_len = 2; |
i2c_data_p->buffer_out[0] = '1'; |
i2c_data_p->buffer_out[1] = '2'; |
i2c_data_p->buffer_out_len = 2; |
ret = 1; |
break; |
} |