uint32_t I2CWriteSingle(uint32_t i2c_base, uint8_t address, uint8_t reg, uint8_t data) {
// Set slave register to be written
while(I2CMasterBusy(i2c_base));
I2CMasterSlaveAddrSet(i2c_base, address, 0);
I2CMasterDataPut(i2c_base, reg);
I2CMasterControl(i2c_base, I2C_MASTER_CMD_BURST_SEND_START);
while(I2CMasterBusy(i2c_base));
// Check for errors
if (I2CMasterErr(i2c_base) != I2C_MASTER_ERR_NONE) return 0;
// Write data
I2CMasterDataPut(i2c_base, data);
I2CMasterControl(i2c_base, I2C_MASTER_CMD_BURST_SEND_CONT);
while(I2CMasterBusy(i2c_base));
// Check for errors
if (I2CMasterErr(i2c_base) != I2C_MASTER_ERR_NONE) return 0;
// End transmission
I2CMasterControl(i2c_base, I2C_MASTER_CMD_BURST_SEND_FINISH);
while(I2CMasterBusy(i2c_base));
// Check for errors
if (I2CMasterErr(i2c_base) != I2C_MASTER_ERR_NONE) return 0;
return 1;
}
void i2c_rx_multi(unsigned char SlaveAddr, unsigned char dest, unsigned char num_bytes, unsigned long *data)
{
unsigned int i=0;
// Set the address
I2CMasterSlaveAddrSet( I2C1_MASTER_BASE, SlaveAddr, I2C_SEND );
I2CMasterDataPut( I2C1_MASTER_BASE, dest );
I2CMasterControl( I2C1_MASTER_BASE, I2C_MASTER_CMD_SINGLE_SEND );
while (I2CMasterBusy( I2C1_MASTER_BASE ));
// Set the address again to tell the device to start sending data
I2CMasterSlaveAddrSet( I2C1_MASTER_BASE, SlaveAddr, I2C_RECEIVE );
I2CMasterControl( I2C1_MASTER_BASE, I2C_MASTER_CMD_BURST_RECEIVE_START );
while(I2CMasterBusy( I2C1_MASTER_BASE ));
*data++ = I2CMasterDataGet(I2C1_MASTER_BASE);
while(i++ < (num_bytes-2))
{
I2CMasterControl( I2C1_MASTER_BASE, I2C_MASTER_CMD_BURST_RECEIVE_CONT );
while(I2CMasterBusy( I2C1_MASTER_BASE ));
*data++ = I2CMasterDataGet(I2C1_MASTER_BASE);
}
I2CMasterControl( I2C1_MASTER_BASE, I2C_MASTER_CMD_BURST_RECEIVE_FINISH );
while(I2CMasterBusy( I2C1_MASTER_BASE ));
*data++ = I2CMasterDataGet(I2C1_MASTER_BASE);
}
uint32_t I2CReadSingle(uint32_t i2c_base, uint8_t address, uint8_t reg) {
uint32_t data = 0;
// Set slave register to be read
while(I2CMasterBusy(i2c_base));
I2CMasterSlaveAddrSet(i2c_base, address, 0);
I2CMasterDataPut(i2c_base, reg);
I2CMasterControl(i2c_base, I2C_MASTER_CMD_SINGLE_SEND);
while(I2CMasterBusy(i2c_base));
// Check for errors
if (I2CMasterErr(i2c_base) != I2C_MASTER_ERR_NONE) return 0;
// Request for register data
I2CMasterSlaveAddrSet(i2c_base, address, 1);
I2CMasterControl(i2c_base, I2C_MASTER_CMD_SINGLE_RECEIVE);
while(I2CMasterBusy(i2c_base));
// Check for errors
if (I2CMasterErr(i2c_base) != I2C_MASTER_ERR_NONE) return 0;
// Read received data
data = I2CMasterDataGet(i2c_base);
return data;
}
void I2C_Write0(uint16_t device_address, uint16_t device_register, uint8_t device_data)
{
//specify that we want to communicate to device address with an intended write to bus
I2CMasterSlaveAddrSet(I2C0_BASE, device_address, false);
//register to be read
I2CMasterDataPut(I2C0_BASE, device_register);
//send control byte and register address byte to slave device
I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_SEND_START);
//wait for MCU to finish transaction
while(I2CMasterBusy(I2C0_BASE));
I2CMasterSlaveAddrSet(I2C0_BASE, device_address, true);
//specify data to be written to the above mentioned device_register
I2CMasterDataPut(I2C0_BASE, device_data);
//wait while checking for MCU to complete the transaction
I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_BURST_RECEIVE_FINISH);
//wait for MCU & device to complete transaction
while(I2CMasterBusy(I2C0_BASE));
}
uint32_t I2C_Read0(uint16_t device_address, uint16_t device_register)
{
//specify that we want to communicate to device address with an intended write to bus
I2CMasterSlaveAddrSet(I2C0_BASE, device_address, false);
//the register to be read
I2CMasterDataPut(I2C0_BASE, device_register);
//send control byte and register address byte to slave device
I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_SINGLE_SEND);
//wait for MCU to complete send transaction
while(I2CMasterBusy(I2C0_BASE));
//read from the specified slave device
I2CMasterSlaveAddrSet(I2C0_BASE, device_address, true);
//send control byte and read from the register from the MCU
I2CMasterControl(I2C0_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE);
//wait while checking for MCU to complete the transaction
while(I2CMasterBusy(I2C0_BASE));
//Get the data from the MCU register and return to caller
return( (uint32_t)I2CMasterDataGet(I2C0_BASE));
}
uint8_t TwoWire::sendTxData(unsigned long cmd, uint8_t data) {
while(I2CMasterBusy(MASTER_BASE));
I2CMasterDataPut(MASTER_BASE, data);
HWREG(MASTER_BASE + I2C_O_MCS) = cmd;
while(I2CMasterBusy(MASTER_BASE));
uint8_t error = I2CMasterErr(MASTER_BASE);
if (error != I2C_MASTER_ERR_NONE)
I2CMasterControl(MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_ERROR_STOP);
return(getError(error));
}
void i2c_tx_single(unsigned char SlaveAddr, unsigned char dest, unsigned char data)
{
I2CMasterSlaveAddrSet( I2C1_MASTER_BASE, SlaveAddr, I2C_SEND );
I2CMasterDataPut( I2C1_MASTER_BASE, dest );
I2CMasterControl( I2C1_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_START );
while(I2CMasterBusy(I2C1_MASTER_BASE));
I2CMasterDataPut( I2C1_MASTER_BASE, data );
I2CMasterControl( I2C1_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH );
while(I2CMasterBusy(I2C1_MASTER_BASE));
}
//This will setup the com for a device, declare the regiester to write to and then write to that regiester
//Note I2C waits for a response bit before continuing. If there is no device on the other end the masterbusy loop will NEVER exit
void I2CTransmit(unsigned char device, unsigned char regiester, unsigned char value){
I2CMasterSlaveAddrSet(I2C1_MASTER_BASE, device, false); //Set Device to transmit to
I2CMasterDataPut(I2C1_MASTER_BASE,regiester); //Put on regiester to prep writting
I2CMasterControl(I2C1_MASTER_BASE,I2C_MASTER_CMD_BURST_SEND_START); //Send start bit and the first thing
while(I2CMasterBusy(I2C1_MASTER_BASE)); //Wait till data sent
I2CMasterDataPut(I2C1_MASTER_BASE,value); //Put more data on
I2CMasterControl(I2C1_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH); //Send data and finish bit
while(I2CMasterBusy(I2C1_MASTER_BASE)); //Wait till done
}
unsigned long i2c_rx_single(unsigned char SlaveAddr, unsigned char dest)
{
I2CMasterSlaveAddrSet( I2C1_MASTER_BASE, SlaveAddr, I2C_SEND );
I2CMasterDataPut( I2C1_MASTER_BASE, dest );
I2CMasterControl( I2C1_MASTER_BASE, I2C_MASTER_CMD_SINGLE_SEND );
while (I2CMasterBusy( I2C1_MASTER_BASE ));
I2CMasterSlaveAddrSet( I2C1_MASTER_BASE, SlaveAddr, I2C_RECEIVE );
I2CMasterControl( I2C1_MASTER_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE );
while(I2CMasterBusy( I2C1_MASTER_BASE ));
return I2CMasterDataGet(I2C1_MASTER_BASE);
}
//*****************************************************************************
//
// Reads a single gyro register. This routine is blocking.
//
// \param ui8RegisterAddress is the register address
// \return read data
//
//*****************************************************************************
uint8_t
Accel_RegRead(uint8_t ui8RegisterAddress)
{
uint8_t ui8Data = 0;
if (VERBOSE) UARTprintf("GryroRegRead(0x%x)\n", ui8RegisterAddress);
// Set the slave device address for WRITE
// false = this I2C Master is initiating a writes to the slave.
// true = this I2C Master is initiating reads from the slave.
I2CMasterSlaveAddrSet(I2C1_BASE, ACCEL_SLAVE_ADDRESS, false);
//
// Transaction #1: Send the register address
//
// Set the Gyro Register address to write
I2CMasterDataPut(I2C1_BASE, ui8RegisterAddress);
// Start, send device address, write one byte (register address), and end the transaction
I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_SINGLE_SEND);
// Wait for completion
while(I2CMasterBusy(I2C1_BASE))
{
//spin wait
}
//TODO: Check I2CMasterErr(I2C1_BASE)
//
// Transaction #2: Read the register data
//
// Set the slave device address for READ
// false = this I2C Master is initiating a writes to the slave.
// true = this I2C Master is initiating reads from the slave.
I2CMasterSlaveAddrSet(I2C1_BASE, ACCEL_SLAVE_ADDRESS, true);
// Start, send device address, read one byte (register data), and end the transaction
I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE);
// Wait for completion
while(I2CMasterBusy(I2C1_BASE))
{
//spin wait
}
//TODO: Check I2CMasterErr(I2C1_BASE)
ui8Data = I2CMasterDataGet(I2C1_BASE);
return ui8Data;
}
unsigned long byteAccelRead(int reg)
{
short temp;
I2CMasterSlaveAddrSet(I2C_MASTER_BASE, 0x1D, false);
I2CMasterDataPut(I2C_MASTER_BASE, reg);
I2CMasterControl(I2C_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_START);
while(I2CMasterBusy(I2C_MASTER_BASE));
I2CMasterSlaveAddrSet(I2C_MASTER_BASE, 0x1D, true);
I2CMasterControl(I2C_MASTER_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE);
while(I2CMasterBusy(I2C_MASTER_BASE));
return I2CMasterDataGet(I2C_MASTER_BASE);
}
void accelWrite (int reg,char data)
{
// Sets the slave address
I2CMasterSlaveAddrSet(I2C_MASTER_BASE, 0x1D, false);
// Sends the register we want
I2CMasterDataPut(I2C_MASTER_BASE, reg);
I2CMasterControl(I2C_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_START);
while(I2CMasterBusy(I2C_MASTER_BASE));
// Set the register value
I2CMasterDataPut(I2C_MASTER_BASE, data);
I2CMasterControl(I2C_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);
while(I2CMasterBusy(I2C_MASTER_BASE));
}
uint32_t i2c_read_bytes(uint8_t address, uint8_t* buffer, uint32_t length) {
uint32_t future = I2C_MAX_DELAY_US;
// Receive operation
I2CMasterSlaveAddrSet(address, true);
// Multiple receive operation
I2CMasterControl(I2C_MASTER_CMD_BURST_RECEIVE_START);
// Calculate timeout
future += board_timer_get();
// Iterate overall all bytes
while (length) {
// Wait until complete or timeout
while (I2CMasterBusy()) {
// Update timeout status and return if expired
if (board_timer_expired(future)) return length;
}
// Read data from I2C
*buffer++ = I2CMasterDataGet();
length--;
// Check if it's the last byte
if (length == 1) I2CMasterControl(I2C_MASTER_CMD_BURST_RECEIVE_FINISH);
else I2CMasterControl(I2C_MASTER_CMD_BURST_RECEIVE_CONT);
}
// Return bytes read
return length;
}
unsigned long I2CController::waitFinish(uint32_t timeout_ms)
{
unsigned long ret;
if (_interruptsEnabled) {
if (_interruptSemaphore.take(timeout_ms)) {
return I2CMasterErr(_base);
} else {
return 0xFFFFFFFF; // timeout;
}
} else {
uint32_t timeout_time = Task::getTime() + timeout_ms;
while (I2CMasterBusy(_base)) {
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
if ( (timeout_ms!=0xFFFFFFFF) && (Task::getTime() > timeout_time) ) {
return 0xFFFFFFFF; // timeout;
}
Task::yield();
}
return I2CMasterErr(_base);
}
}
//*****************************************************************************
// Reads one byte of data over a I2C bus.
//
// Paramters:
// baseAddr: The base address of the I2C peripheral that is being
// configured
// data: The data read by the transaction.
// mcs: Sets master control register of the I2C peripheral. Since a
// data transaction can consist of multiple bytes, the value
// of mcs is used to determine when start and stop bits are
// generated.
//
// Examples:
// * Sending control word (i2c address) + read 1st byte of data. This
// * assumes that additional bytes be read after this byte. This
// * would be used for reading multiple bytes at consecutive addresses
// * in the slave address.
// i2cGetByte(I2C0_BASE, byte, I2C_MCS_START | I2C_MCS_RUN);
//
// * Reading a byte in the middle of a multi-byte operation. (> 2 bytes)
// i2cGetByte(I2C0_BASE, byte, I2C_MCS_RUN);
//
// * Reading final byte of data in a multi-byte read
// i2cGetByte(I2C0_BASE, byte, I2C_MCS_RUN | I2C_MCS_STOP);
//
// * Sending control word (i2c address) + reading a single byte read.
// i2cGetByte(I2C0_BASE, byte, I2C_MCS_START | I2C_MCS_RUN | I2C_MCS_STOP);
//
// Return Value:
// Returns I2C_OK if the base address is a valid and the data was
// transmitted sucessfully.
//*****************************************************************************
i2c_status_t i2cGetByte(
uint32_t baseAddr,
uint8_t *data,
uint8_t mcs
)
{
I2C0_Type *myI2C;
if( i2cVerifyBaseAddr(baseAddr) == false)
{
return I2C_INVALID_BASE;
}
myI2C = (I2C0_Type *) baseAddr;
// Start the transaction
myI2C->MCS = mcs;
// Wait for the device to be free
while ( I2CMasterBusy(baseAddr)) {};
// Check for error conditions
if ( myI2C->MCS & I2C_MCS_ERROR )
{
myI2C->MCS = I2C_MCS_STOP;
return I2C_BUS_ERROR;
}
else
{
*data = myI2C->MDR;
return I2C_OK;
}
}
//Read from device using address and put the read values into buff. num=num of bytes to read
void I2CRead(unsigned char device, unsigned char regiester, unsigned char num, unsigned long *buff){
//All commented code could likely be delted currently saving for record / emergency
/*I2CMasterSlaveAddrSet(I2C1_MASTER_BASE, device, false); //Set Device to transmit to
I2CMasterDataPut(I2C1_MASTER_BASE,regiester); //Put on regiester to prep writting
I2CMasterControl(I2C1_MASTER_BASE,I2C_MASTER_CMD_SINGLE_SEND);
//while(I2CMasterBusBusy(I2C1_MASTER_BASE)); //Wait till data sent
while(I2CMasterBusy(I2C1_MASTER_BASE)); //this is good
short i=0;
for (i=0; i<num; i++){
I2CMasterSlaveAddrSet(I2C1_MASTER_BASE, device, true); //Set device to RECIEVE FROM
/*I2CMasterDataPut(I2C1_MASTER_BASE,regiester+i); //Put on regiester to prep writting
I2CMasterControl(I2C1_MASTER_BASE,I2C_MASTER_CMD_SINGLE_SEND);
//while(I2CMasterBusBusy(I2C1_MASTER_BASE)); //Wait till data sent
while(I2CMasterBusy(I2C1_MASTER_BASE));
*/
/*if(i==0){
I2CMasterControl(I2C1_MASTER_BASE, I2C_MASTER_CMD_BURST_RECEIVE_START);
}else if(i==(num-1)){
I2CMasterControl(I2C1_MASTER_BASE, I2C_MASTER_CMD_BURST_RECEIVE_FINISH);
}else{
I2CMasterControl(I2C1_MASTER_BASE, I2C_MASTER_CMD_BURST_RECEIVE_CONT);
}
//while(I2CMasterIntStatus(I2C1_MASTER_BASE, false) == 0);
while(I2CMasterBusy(I2C1_MASTER_BASE));
buff[i] = I2CMasterDataGet(I2C1_MASTER_BASE);
//I2CMasterIntClear(I2C1_MASTER_BASE);
}
//buff[0]=0x02;
*/
short i=0; //Initalize i because CCS doesn't like initalizing inside for loop :P
for(i=0; i<num; i++){
I2CMasterSlaveAddrSet(I2C1_MASTER_BASE, device, false); //Set device to write to
I2CMasterDataPut(I2C1_MASTER_BASE,regiester+i); //Put on regiester to prep writting
I2CMasterControl(I2C1_MASTER_BASE,I2C_MASTER_CMD_SINGLE_SEND); //Make a single send there is no bursting through
while(I2CMasterBusy(I2C1_MASTER_BASE)); //wait for the transmission to end via checking the master's state NOT THE BUS
I2CMasterSlaveAddrSet(I2C1_MASTER_BASE, device, true); //Set device to RECIEVE FROM
I2CMasterControl(I2C1_MASTER_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE); //Set a single read because it will only return this address
while(I2CMasterBusy(I2C1_MASTER_BASE)); //Wait for the master to stop recieving data
buff[i] = I2CMasterDataGet(I2C1_MASTER_BASE); //Place the data recieved (that is in the FIFO) into the buffer to return
}
}
uint8_t TwoWire::getRxData(unsigned long cmd) {
if (currentState == IDLE) while(I2CMasterBusBusy(MASTER_BASE));
HWREG(MASTER_BASE + I2C_O_MCS) = cmd;
while(I2CMasterBusy(MASTER_BASE));
uint8_t error = I2CMasterErr(MASTER_BASE);
if (error != I2C_MASTER_ERR_NONE) {
I2CMasterControl(MASTER_BASE, I2C_MASTER_CMD_BURST_RECEIVE_ERROR_STOP);
}
else {
while(I2CMasterBusy(MASTER_BASE));
rxBuffer[rxWriteIndex] = I2CMasterDataGet(MASTER_BASE);
rxWriteIndex = (rxWriteIndex + 1) % BUFFER_LENGTH;
}
return error;
}
uint32_t i2c_write_bytes(uint8_t address, uint8_t* buffer, uint32_t length) {
uint32_t future = I2C_MAX_DELAY_US;
// Transmit operation
I2CMasterSlaveAddrSet(address, false);
// Write byte to I2C buffer
I2CMasterDataPut(*buffer++);
length--;
// Multiple transmit operation
I2CMasterControl(I2C_MASTER_CMD_BURST_SEND_START);
// Calculate timeout
future += board_timer_get();
// Wait until complete or timeout
while (I2CMasterBusy()) {
// Check timeout status and return if expired
if (board_timer_expired(future)) return length;
}
// Iterate overall all bytes
while (length) {
// Write byte to I2C buffer
I2CMasterDataPut(*buffer++);
// Check if it's the last byte
if (length == 1) I2CMasterControl(I2C_MASTER_CMD_BURST_SEND_FINISH);
else I2CMasterControl(I2C_MASTER_CMD_BURST_SEND_CONT);
// Wait until complete or timeout
while (I2CMasterBusy()) {
// Check timeout status and return if expired
if (board_timer_expired(future)) return length;
}
// Update the length
length--;
}
// Return bytes written
return length;
}
//*****************************************************************************
//
// Writes a single gyro register. This routine is blocking.
//
// \param ui8RegisterAddress is the register address
// \param ui8Data is the data to write
//
//*****************************************************************************
void
Accel_RegWrite(uint8_t ui8RegisterAddress, uint8_t ui8Data)
{
if (VERBOSE) UARTprintf("GryroWriteReg(0x%x, 0x%x)\n", ui8RegisterAddress, ui8Data);
// Set the slave device address for WRITE
// false = this I2C Master is initiating a writes to the slave.
// true = this I2C Master is initiating reads from the slave.
I2CMasterSlaveAddrSet(I2C1_BASE, ACCEL_SLAVE_ADDRESS, false);
//
// Transaction #1: Send the register address
//
// Set the Gyro Register address to write
I2CMasterDataPut(I2C1_BASE, ui8RegisterAddress);
// Start, send device address, write one byte (register address)...
I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_BURST_SEND_START);
// Wait for completion
while(I2CMasterBusy(I2C1_BASE))
{
//spin wait
}
//TODO: Check I2CMasterErr(I2C1_BASE)
//
// Transaction #1 continued: Send the register data
//
//Set the Gyro Register address to write
I2CMasterDataPut(I2C1_BASE, ui8Data);
// ... write another byte (register data) and end the transaction
I2CMasterControl(I2C1_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);
// Wait for completion
while(I2CMasterBusy(I2C1_BASE))
{
//spin wait
}
//TODO: Check I2CMasterErr(I2C1_BASE)
}
uint32_t I2CReadMultiple(uint32_t i2c_base, uint8_t address, uint8_t reg, uint8_t *data, uint32_t size) {
uint32_t byte_count;
uint32_t master_command;
// Set slave register to be read
while(I2CMasterBusy(i2c_base));
I2CMasterSlaveAddrSet(i2c_base, address, 0);
I2CMasterDataPut(i2c_base, reg);
I2CMasterControl(i2c_base, I2C_MASTER_CMD_SINGLE_SEND);
while(I2CMasterBusy(i2c_base));
// Check for errors
if (I2CMasterErr(i2c_base) != I2C_MASTER_ERR_NONE) return 0;
// Start burst read
I2CMasterSlaveAddrSet(i2c_base, address, 1);
master_command = I2C_MASTER_CMD_BURST_RECEIVE_START;
for (byte_count = 0; byte_count < size; byte_count++) {
// The second byte has to be read with CONT
if (byte_count == 1) master_command = I2C_MASTER_CMD_BURST_RECEIVE_CONT;
// The last byte has to be read with FINISH
if (byte_count == size - 1) master_command = I2C_MASTER_CMD_BURST_RECEIVE_FINISH;
// If only one byte, reconfigure to SINGLE
if (size == 1) master_command = I2C_MASTER_CMD_SINGLE_RECEIVE;
// Initiate read
I2CMasterControl(i2c_base, master_command);
// Wait for master operation
while(I2CMasterBusy(i2c_base));
// Check for errors
if (I2CMasterErr(i2c_base) != I2C_MASTER_ERR_NONE) return 0;
// Put data into array
data[byte_count] = I2CMasterDataGet(i2c_base);
}
return byte_count;
}
uint32_t I2CWriteMultiple(uint32_t i2c_base, uint8_t address, uint8_t reg, uint8_t *data, uint32_t size) {
uint32_t byte_count;
uint32_t master_command;
// Set slave register to be written
while(I2CMasterBusy(i2c_base));
I2CMasterSlaveAddrSet(i2c_base, address, 0);
I2CMasterDataPut(i2c_base, reg);
I2CMasterControl(i2c_base, I2C_MASTER_CMD_BURST_SEND_START);
while(I2CMasterBusy(i2c_base));
// Check for errors
if (I2CMasterErr(i2c_base) != I2C_MASTER_ERR_NONE) return 0;
// Start burst write
master_command = I2C_MASTER_CMD_BURST_SEND_CONT;
for (byte_count = 0; byte_count < size; byte_count++) {
// The second byte has to be sent with CONT
if (byte_count == 1) master_command = I2C_MASTER_CMD_BURST_SEND_CONT;
// The last byte has to be sent with FINISH
if (byte_count == size - 1) master_command = I2C_MASTER_CMD_BURST_SEND_FINISH;
// If only one byte, reconfigure to SINGLE
if (size == 1) master_command = I2C_MASTER_CMD_SINGLE_SEND;
// Write byte
I2CMasterDataPut(i2c_base, data[byte_count]);
I2CMasterControl(i2c_base, master_command);
// Wait for master operation
while(I2CMasterBusy(i2c_base));
// Check for errors
if (I2CMasterErr(i2c_base) != I2C_MASTER_ERR_NONE) return 0;
}
return 1;
}
uint8_t TwoWire::endTransmission(uint8_t sendStop)
{
uint8_t error = I2C_MASTER_ERR_NONE;
if(TX_BUFFER_EMPTY) return 0;
//Wait for any previous transaction to complete
while(I2CMasterBusBusy(MASTER_BASE));
while(I2CMasterBusy(MASTER_BASE));
//Select which slave we are requesting data from
//false indicates we are writing to the slave
I2CMasterSlaveAddrSet(MASTER_BASE, txAddress, false);
while(I2CMasterBusy(MASTER_BASE));
unsigned long cmd = RUN_BIT | START_BIT;
error = sendTxData(cmd,txBuffer[txReadIndex]);
txReadIndex = (txReadIndex + 1) % BUFFER_LENGTH;
if(error) return error;
while(!TX_BUFFER_EMPTY) {
error = sendTxData(RUN_BIT,txBuffer[txReadIndex]);
txReadIndex = (txReadIndex + 1) % BUFFER_LENGTH;
if(error) return getError(error);
}
if(sendStop) {
while(I2CMasterBusy(MASTER_BASE));
HWREG(MASTER_BASE + I2C_O_MCS) = STOP_BIT;
while(I2CMasterBusy(MASTER_BASE));
currentState = IDLE;
}
else {
currentState = MASTER_TX;
}
// indicate that we are done transmitting
transmitting = 0;
return error;
}
//used to control the leds
void LED_CONTROL(int LED_NUMBER, int LED_COMMAND)
{
data_handler(LED_NUMBER,LED_COMMAND);
// Slave address of TCA6507 is 0x45 (binary 1001 101)
// false=write / true=read
I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, 0x45, false);
// the for loop is there to make the code more compact and removes some redundant commands.
int COUNTER;
for (COUNTER=0;COUNTER!=5;COUNTER++)
{
if(COUNTER == 2)
{
//puts the command-byte in the dataput getting ready to sending it.
I2CMasterDataPut(I2C0_MASTER_BASE, COMMAND_BYTE_INCREMENT);
//starts sending the data.
I2CMasterControl(I2C0_MASTER_BASE,I2C_MASTER_CMD_BURST_SEND_START);
}
else if(COUNTER == 3)
{
//gets the first led_current_setting containing the byte for select0 ready to transmitting.
I2CMasterDataPut(I2C0_MASTER_BASE,led_current_setting[0] );
//keeps sending data.
I2CMasterControl(I2C0_MASTER_BASE,I2C_MASTER_CMD_BURST_SEND_CONT);
}
else if(COUNTER == 4)
{
//gets the second led_current_setting containing the byte for select1 ready to transmitting.
I2CMasterDataPut(I2C0_MASTER_BASE,led_current_setting[1] );
//keeps sending data.
I2CMasterControl(I2C0_MASTER_BASE,I2C_MASTER_CMD_BURST_SEND_CONT);
}
else if(COUNTER == 5)
{
//gets the third led_current_setting containing the byte for select2 ready to transmitting.
I2CMasterDataPut(I2C0_MASTER_BASE,led_current_setting[2] );
//transmitting the final byte and a stop command.
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH );
}
// Wait for I2C to finish.
while(I2CMasterBusy(I2C0_MASTER_BASE));
//a short delay.
SysCtlDelay(80000);
}
}
uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop)
{
uint8_t error = 0;
uint8_t oldWriteIndex = rxWriteIndex;
uint8_t spaceAvailable = (rxWriteIndex >= rxReadIndex) ?
BUFFER_LENGTH - (rxWriteIndex - rxReadIndex) : (rxReadIndex - rxWriteIndex);
if (quantity > spaceAvailable)
quantity = spaceAvailable;
if (!quantity) return 0;
//Select which slave we are requesting data from
//true indicates we are reading from the slave
I2CMasterSlaveAddrSet(MASTER_BASE, address, true);
unsigned long cmd = 0;
if((quantity > 1) || !sendStop)
cmd = RUN_BIT | START_BIT | ACK_BIT;
else cmd = RUN_BIT | START_BIT | (sendStop << 2);
error = getRxData(cmd);
if(error) return 0;
currentState = MASTER_RX;
for (int i = 1; i < quantity; i++) {
//since NACK is being sent on last byte, a consecutive burst read will
//need to send a start condition
if(i == (quantity - 1))
cmd = RUN_BIT;
else
cmd = RUN_BIT | ACK_BIT;
error = getRxData(cmd);
if(error) return i;
}
if(sendStop) {
HWREG(MASTER_BASE + I2C_O_MCS) = STOP_BIT;
while(I2CMasterBusy(MASTER_BASE));
currentState = IDLE;
}
uint8_t bytesWritten = (rxWriteIndex >= oldWriteIndex) ?
BUFFER_LENGTH - (rxWriteIndex - oldWriteIndex) : (oldWriteIndex - rxWriteIndex);
return(bytesWritten);
}
//used to control the brightness value.
void CHANGE_BRIGHTNESS_VALUES(int value0,int value1)
{
// Slave address of TCA6507 is 0x45 (binary 1001 101)
// false=write / true=read
I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, 0x45, false);
int COUNTER;
for (COUNTER=0;COUNTER!=4;COUNTER++)
{
//ensure that the user input value is a legal value if not it skips out of the function.
if(value0||value1 > 15 )
{
COUNTER=4;
}
else if(value0||value1 < 1 )
{
COUNTER=4;
}
else if(COUNTER == 2)
{
//puts the command-byte in the dataput getting ready to sending it.
I2CMasterDataPut(I2C0_MASTER_BASE, COMMAND_BYTE_MAXIMUM_INTENSITY);
//starts sending the data.
I2CMasterControl(I2C0_MASTER_BASE,I2C_MASTER_CMD_BURST_SEND_START);
}
else if(COUNTER == 3)
{
//value0 and value1 is send through the same byte where value0 is the first 4bit and value1 is the last 4bit.
I2CMasterDataPut(I2C0_MASTER_BASE,NUMBER_HEX[value0]+(10*NUMBER_HEX[value1]));
//transmitting the final byte and a stop command.
I2CMasterControl(I2C0_MASTER_BASE,I2C_MASTER_CMD_BURST_SEND_FINISH );
}
// Wait for I2C to finish.
while(I2CMasterBusy(I2C0_MASTER_BASE));
//a short delay.
SysCtlDelay(80000);
}
}
/**
* Verifies that a transmission from the master has completed successfully
*
* \param ui32base Base address of the I2C peripheral
*
* \param burst Set to true if burst mode was used for the transmission
*
* \param receive Set to true if a receive transmission is to be verified
* Set to false if a send transmission is to be verified
*
* \note Waits until a transmission is complete and then checks that no errors have occurred
*
* \note If an error occurs the I2C transmission is stopped, the error LED is lit and the
* program enters an infinite loop to hold the state.
**/
void twe_I2CMasterVerify(uint32_t ui32base, bool burst, bool receive) {
while(I2CMasterBusy(ui32base)) {} // Wait until the transfer is complete
//uint32_t errorStatus = I2CMasterErr(ui32Base);
if(I2CMasterErr(ui32base) != I2C_MASTER_ERR_NONE) {
// An error has occured
if(burst && !receive) {
I2CMasterControl(ui32base, I2C_MASTER_CMD_BURST_SEND_ERROR_STOP);
}
else if(burst && !receive) {
I2CMasterControl(ui32base, I2C_MASTER_CMD_BURST_RECEIVE_ERROR_STOP);
}
while(1) {} // Capture state
}
}
unsigned long I2CController::waitFinish()
{
unsigned long ret;
while (I2CMasterBusy(_base)) {
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
}
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
return 0;
}
//*****************************************************************************
// Sends one byte of data over a I2C bus.
//
// Paramters:
// baseAddr: The base address of the I2C peripheral that is being
// configured
// byte: The next byte of the data transaction.
// mcs: Sets master control register of the I2C peripheral. Since a
// data transaction can consist of multiple bytes, the value
// of mcs is used to determine when start and stop bits are
// generated.
//
// Examples:
// * Sending control word (i2c address) + write 1st byte of data. This
// * assumes that additional bytes will follow in the transaction
// i2cSendByte(I2C0_BASE, byte, I2C_MCS_START | I2C_MCS_RUN);
//
// * Sending a byte in the middle of a multi-byte operation. (> 2 bytes)
// i2cSendByte(I2C0_BASE, byte, I2C_MCS_RUN);
//
// * Sending final byte of data
// i2cSendByte(I2C0_BASE, byte, I2C_MCS_RUN | I2C_MCS_STOP);
//
// * Sending control word (i2c address) + a single byte transaction.
// i2cSendByte(I2C0_BASE, byte, I2C_MCS_START | I2C_MCS_RUN | I2C_MCS_STOP);
//
// Return Value:
// Returns I2C_OK if the base address is a valid and the data was
// transmitted sucessfully.
//*****************************************************************************
i2c_status_t i2cSendByte(
uint32_t baseAddr,
uint8_t byte,
uint8_t mcs
)
{
I2C0_Type *myI2C;
if( i2cVerifyBaseAddr(baseAddr) == false)
{
return I2C_INVALID_BASE;
}
myI2C = (I2C0_Type *) baseAddr;
// Write the upper address to the data register
myI2C->MDR = byte;
// Start the transaction
myI2C->MCS = mcs;
// Wait for the device to be free
while ( I2CMasterBusy(baseAddr)) {};
// Check for error conditions
if ( myI2C->MCS & (I2C_MCS_ERROR | I2C_MCS_ARBLST) )
{
return I2C_ARBLST;
}
else if ( myI2C->MCS & I2C_MCS_ERROR )
{
myI2C->MCS = I2C_MCS_STOP;
return I2C_BUS_ERROR;
}
else if ( myI2C->MCS & I2C_MCS_DATACK )
{
return I2C_NO_ACK;
}
else
{
return I2C_OK;
}
}
void I2CController::setup(GPIOPin sda, GPIOPin scl, speed_t speed)
{
MutexGuard guard(&_lock);
_sda = sda;
_scl = scl;
ROM_SysCtlPeripheralEnable(_periph);
SysCtlPeripheralReset(_periph);
_sda.enablePeripheral();
if (_base == I2C0_MASTER_BASE) {
_sda.mapAsI2C0SDA();
}
else if (_base == I2C1_MASTER_BASE) {
_sda.mapAsI2C1SDA();
}
else {
while(1) { /* we should never get here! */ }
}
_sda.configure(GPIOPin::I2C);
_scl.enablePeripheral();
if (_base == I2C0_MASTER_BASE) {
_scl.mapAsI2C0SCL();
}
else if (_base == I2C1_MASTER_BASE) {
_scl.mapAsI2C1SCL();
}
else {
while(1) { /* we should never get here! */ }
}
_scl.configure(GPIOPin::I2CSCL);
I2CMasterInitExpClk(_base, ROM_SysCtlClockGet(), (speed==speed_400kBit) ? 1 : 0);
I2CMasterEnable(_base);
// Do a dummy receive to make sure you don't get junk on the first receive.
I2CMasterControl(_base, I2C_MASTER_CMD_SINGLE_RECEIVE);
while(I2CMasterBusy(_base));
}
bool i2c_write_byte(uint8_t address, uint8_t byte) {
uint32_t future = I2C_MAX_DELAY_US;
// Transmit operation
I2CMasterSlaveAddrSet(address, false);
// Write byte to I2C buffer
I2CMasterDataPut(byte);
// Single transmit operation
I2CMasterControl(I2C_MASTER_CMD_SINGLE_SEND);
// Calculate timeout
future += board_timer_get();
// Wait until complete or timeout
while (I2CMasterBusy()) {
// Check timeout status and return if expired
if (board_timer_expired(future)) return false;
}
return true;
}