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;
}
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;
}
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;
}
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);
}
unsigned long I2CController::read8(uint8_t addr, uint8_t *data, bool sendStartCondition, bool sendStopCondition)
{
RecursiveMutexGuard guard(&_lock);
unsigned long ret;
I2CMasterSlaveAddrSet(_base, addr, 1);
if (sendStartCondition) {
I2CMasterControl(_base, sendStopCondition ? I2C_MASTER_CMD_SINGLE_SEND : I2C_MASTER_CMD_BURST_RECEIVE_START);
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
} else {
I2CMasterControl(_base, sendStopCondition ? I2C_MASTER_CMD_BURST_RECEIVE_FINISH : I2C_MASTER_CMD_BURST_RECEIVE_CONT);
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
}
ret = waitFinish(_defaultTimeout);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
*data = I2CMasterDataGet(_base);
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
return 0;
}
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));
}
unsigned long I2CController::nolock_write8(uint8_t addr, uint8_t data, bool sendStartCondition, bool sendStopCondition)
{
unsigned long ret;
I2CMasterSlaveAddrSet(_base, addr, 0);
I2CMasterDataPut(_base, data);
if (sendStartCondition) {
I2CMasterControl(_base, sendStopCondition ? I2C_MASTER_CMD_SINGLE_SEND : I2C_MASTER_CMD_BURST_SEND_START);
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
} else {
I2CMasterControl(_base, sendStopCondition ? I2C_MASTER_CMD_BURST_SEND_FINISH : I2C_MASTER_CMD_BURST_SEND_CONT);
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
}
ret = waitFinish();
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
return 0;
}
/*
*********************************************************************************************************
* BSP_DACReadRegister (CPU_INT08U ucRegister, CPU_INT08U *pucData)
*
* Description : Read a register in the TLV320AIC3107 DAC.
*
* Argument(s) : ucRegister is the offset to the register to write.
* pucData is a pointer to the returned data.
*
* Return(s) : True on success or false on error.
*
* Caller(s) : Sound driver.
*
* Note(s) :
*
*********************************************************************************************************
*/
static CPU_BOOLEAN BSP_DACReadRegister (CPU_INT08U ucRegister, CPU_INT08U *pucData)
{
// Set the slave address and "WRITE"/false.
I2CMasterSlaveAddrSet(DAC_I2C_MASTER_BASE, TI_TLV320AIC3107_ADDR, false);
// Write the first byte to the controller (register)
I2CMasterDataPut(DAC_I2C_MASTER_BASE, ucRegister);
// Continue the transfer.
I2CMasterControl(DAC_I2C_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_START);
// Wait until the current byte has been transferred.
while(I2CMasterIntStatus(DAC_I2C_MASTER_BASE, false) == 0)
{
}
if(I2CMasterErr(DAC_I2C_MASTER_BASE) != I2C_MASTER_ERR_NONE)
{
I2CMasterIntClear(DAC_I2C_MASTER_BASE);
return(false);
}
// Wait until the current byte has been transferred.
while(I2CMasterIntStatus(DAC_I2C_MASTER_BASE, false))
{
I2CMasterIntClear(DAC_I2C_MASTER_BASE);
}
// Set the slave address and "READ"/true.
I2CMasterSlaveAddrSet(DAC_I2C_MASTER_BASE, TI_TLV320AIC3107_ADDR, true);
// Read Data Byte.
I2CMasterControl(DAC_I2C_MASTER_BASE, I2C_MASTER_CMD_SINGLE_RECEIVE);
// Wait until the current byte has been transferred.
while(I2CMasterIntStatus(DAC_I2C_MASTER_BASE, false) == 0)
{
}
if(I2CMasterErr(DAC_I2C_MASTER_BASE) != I2C_MASTER_ERR_NONE)
{
I2CMasterIntClear(DAC_I2C_MASTER_BASE);
return(false);
}
// Wait until the current byte has been transferred.
while(I2CMasterIntStatus(DAC_I2C_MASTER_BASE, false))
{
I2CMasterIntClear(DAC_I2C_MASTER_BASE);
}
*pucData = I2CMasterDataGet(DAC_I2C_MASTER_BASE);
return(true);
}
/**
* \brief This function reads data from EEPROM.
*
* \param data Address where data is to be read.
* \param length Length of data to be read
* \param offset Address of the byte from which data to be read.
*
* \return None.
*
* \note This muxing depends on the profile in which the EVM is configured.
* EEPROMI2CSetUp Shall be called Before this API is used
*/
void EEPROMI2CRead(unsigned char *data, unsigned int length,
unsigned short offset)
{
unsigned int idx = 0;
/* First send the register offset - TX operation */
I2CSetDataCount(I2C_BASE_ADDR, 2);
StatusClear();
I2CMasterControl(I2C_BASE_ADDR, I2C_CFG_MST_TX);
I2CMasterStart(I2C_BASE_ADDR);
/* Wait for the START to actually occir on the bus */
while (0 == I2CMasterBusBusy(I2C_BASE_ADDR));
I2CMasterDataPut(I2C_BASE_ADDR, (unsigned char)((offset >> 8) & 0xFF));
/* Wait for the Tx register to be empty */
while (0 == I2CMasterIntRawStatusEx(I2C_BASE_ADDR,
I2C_INT_TRANSMIT_READY));
/* Push offset out and tell CPLD from where we intend to read the data */
I2CMasterDataPut(I2C_BASE_ADDR, (unsigned char)(offset & 0xFF));
I2CMasterIntClearEx(I2C_BASE_ADDR, I2C_INT_TRANSMIT_READY);
while(0 == (I2CMasterIntRawStatus(I2C_BASE_ADDR) & I2C_INT_ADRR_READY_ACESS));
StatusClear();
I2CSetDataCount(I2C_BASE_ADDR, length);
/* Now that we have sent the register offset, start a RX operation*/
I2CMasterControl(I2C_BASE_ADDR, I2C_CFG_MST_RX);
/* Repeated start condition */
I2CMasterStart(I2C_BASE_ADDR);
while (length--)
{
while (0 == I2CMasterIntRawStatusEx(I2C_BASE_ADDR,
I2C_INT_RECV_READY));
data[idx++] = (unsigned char)I2CMasterDataGet(I2C_BASE_ADDR);
I2CMasterIntClearEx(I2C_BASE_ADDR, I2C_INT_RECV_READY);
}
I2CMasterStop(I2C_BASE_ADDR);
while(0 == (I2CMasterIntRawStatus(I2C_BASE_ADDR) & I2C_INT_STOP_CONDITION));
I2CMasterIntClearEx(I2C_BASE_ADDR, I2C_INT_STOP_CONDITION);
}
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));
}
//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);
}
}
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);
}
//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
}
//*****************************************************************************
//
// 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;
}
/*
*********************************************************************************************************
* BSP_DACWriteRegister (CPU_INT08U ucRegister, CPU_INT32U ulData)
*
* Description : Write a register in the TLV320AIC3107 DAC.
*
* Argument(s) : ucRegister is the offset to the register to write.
* ulData is the data to be written to the DAC register.
*
* Return(s) : True on success or false on error.
*
* Caller(s) : Sound driver.
*
* Note(s) : This function will write the register passed in ucAddr with the value
* passed in to ulData. The data in ulData is actually 9 bits and the
* value in ucAddr is interpreted as 7 bits.
*********************************************************************************************************
*/
static CPU_BOOLEAN BSP_DACWriteRegister (CPU_INT08U ucRegister, CPU_INT32U ulData)
{
// Set the slave address.
I2CMasterSlaveAddrSet(DAC_I2C_MASTER_BASE, TI_TLV320AIC3107_ADDR, false);
// Write the first byte to the controller (register)
I2CMasterDataPut(DAC_I2C_MASTER_BASE, ucRegister);
// Continue the transfer.
I2CMasterControl(DAC_I2C_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_START);
// Wait until the current byte has been transferred.
while(I2CMasterIntStatus(DAC_I2C_MASTER_BASE, false) == 0)
{
}
if(I2CMasterErr(DAC_I2C_MASTER_BASE) != I2C_MASTER_ERR_NONE)
{
I2CMasterIntClear(DAC_I2C_MASTER_BASE);
return(false);
}
// Wait until the current byte has been transferred.
while(I2CMasterIntStatus(DAC_I2C_MASTER_BASE, false))
{
I2CMasterIntClear(DAC_I2C_MASTER_BASE);
}
// Write the data byte to the controller.
I2CMasterDataPut(DAC_I2C_MASTER_BASE, ulData);
// End the transfer.
I2CMasterControl(DAC_I2C_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);
// Wait until the current byte has been transferred.
while(I2CMasterIntStatus(DAC_I2C_MASTER_BASE, false) == 0)
{
}
if(I2CMasterErr(DAC_I2C_MASTER_BASE) != I2C_MASTER_ERR_NONE)
{
return(false);
}
while(I2CMasterIntStatus(DAC_I2C_MASTER_BASE, false))
{
I2CMasterIntClear(DAC_I2C_MASTER_BASE);
}
return(true);
}
//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);
}
}
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 i2c3_master_interrupt(void) {
unsigned long status = I2CMasterIntStatusEx(I2C3_MASTER_BASE, false);
if (status & I2C_MASTER_INT_TIMEOUT) {
i2c_flag = 2;
I2CMasterIntClearEx(I2C3_MASTER_BASE, I2C_MASTER_INT_TIMEOUT);
}
if (status & I2C_MASTER_INT_DATA) {
err = I2CMasterErr(I2C3_MASTER_BASE);
if (err != I2C_MASTER_ERR_NONE)
i2c_flag = 2;
if (what_we_re_doing == sending) {
sent_bytes++;
if (sent_bytes < sizeof(data)-1) {
//Continuing
I2CMasterDataPut(I2C3_MASTER_BASE, ((unsigned char *)&data)[sent_bytes]);
I2CMasterControl(I2C3_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);
}
else if (sent_bytes == sizeof(data)-1) {
//Last byte remaining
I2CMasterDataPut(I2C3_MASTER_BASE, ((unsigned char *)&data)[sent_bytes]);
I2CMasterControl(I2C3_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);
}
else {
//Transaction is done
i2c_flag = 1;
}
}
else if (what_we_re_doing == receiving) {
unsigned char *p = (unsigned char *)&data_recv + received_bytes;
*p = I2CMasterDataGet(I2C3_MASTER_BASE);
received_bytes++;
if (received_bytes < sizeof(data_recv) - 1) {
I2CMasterControl(I2C3_MASTER_BASE, I2C_MASTER_CMD_BURST_RECEIVE_CONT);
}
else if (received_bytes == sizeof(data_recv) - 1) {
I2CMasterControl(I2C3_MASTER_BASE, I2C_MASTER_CMD_BURST_RECEIVE_FINISH);
}
else {
//Transaction is done
i2c_flag = 1;
}
}
I2CMasterIntClearEx(I2C3_MASTER_BASE, I2C_MASTER_INT_DATA);
}
}
//*****************************************************************************
//
//! \internal
//!
//! Write a sequence of bytes to the SSD0303 controller.
//!
//! This function continues a transfer to the SSD0303 controller by writing a
//! sequence of bytes over the I2C bus. This must only be called after calling
//! OSRAMWriteFirst(), but before calling OSRAMWriteFinal().
//!
//! The data is written in a polled fashion; this function will not return
//! until the entire byte sequence has been written to the controller.
//!
//! \return None.
//
//*****************************************************************************
static void
OSRAMWriteArray(const unsigned char *pucBuffer, unsigned long ulCount)
{
//
// Loop while there are more bytes left to be transferred.
//
while(ulCount != 0) {
//
// Wait until the current byte has been transferred.
//
while(I2CMasterIntStatus(I2C_MASTER_BASE, false) == 0) {
}
//
// Provide the required inter-byte delay.
//
OSRAMDelay(g_ulDelay);
//
// Write the next byte to the controller.
//
I2CMasterDataPut(I2C_MASTER_BASE, *pucBuffer++);
ulCount--;
//
// Continue the transfer.
//
I2CMasterControl(I2C_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);
}
}
unsigned long I2CController::nolock_read(uint8_t addr, uint8_t *buf, int count, bool sendStartCondition, bool sendStopCondition)
{
unsigned long ret;
if (count<1) return 0;
ret = nolock_read8(addr, buf, sendStartCondition, (sendStopCondition && count==1));
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
for (uint8_t i=1; i<count; i++) {
I2CMasterControl(_base, ((i==(count-1)) && sendStopCondition) ? I2C_MASTER_CMD_BURST_RECEIVE_FINISH : I2C_MASTER_CMD_BURST_RECEIVE_CONT);
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
ret = waitFinish();
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
buf[i] = I2CMasterDataGet(_base);
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
}
return 0;
}
unsigned long I2CController::write(uint8_t addr, const void *ptr, int count, bool sendStartCondition, bool sendStopCondition)
{
const uint8_t *buf = (const uint8_t *) ptr;
RecursiveMutexGuard guard(&_lock);
unsigned long ret;
if (count<1) return 0;
ret = write8(addr, buf[0], sendStartCondition, (count==1) && sendStopCondition);
if (ret != I2C_MASTER_ERR_NONE) { return ret; }
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) { return ret; }
for(int i=1; i<count; i++) {
I2CMasterDataPut(_base, buf[i]);
I2CMasterControl(_base, (sendStopCondition && (i == count-1)) ? I2C_MASTER_CMD_BURST_SEND_FINISH : I2C_MASTER_CMD_BURST_SEND_CONT);
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
ret = waitFinish(_defaultTimeout);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
}
return 0;
}
unsigned long I2CController::read(uint8_t addr, void *ptr, int count, bool sendStartCondition, bool sendStopCondition)
{
uint8_t *buf = (uint8_t *) ptr;
RecursiveMutexGuard guard(&_lock);
unsigned long ret;
if (count<1) return 0;
ret = read8(addr, buf, sendStartCondition, (sendStopCondition && count==1));
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
for (uint8_t i=1; i<count; i++) {
I2CMasterControl(_base, ((i==(count-1)) && sendStopCondition) ? I2C_MASTER_CMD_BURST_RECEIVE_FINISH : I2C_MASTER_CMD_BURST_RECEIVE_CONT);
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
ret = waitFinish(_defaultTimeout);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
buf[i] = I2CMasterDataGet(_base);
ret = I2CMasterErr(_base);
if (ret != I2C_MASTER_ERR_NONE) {
return ret;
}
}
return 0;
}
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));
}
//*****************************************************************************
//
//! \internal
//!
//! Write a byte to the SSD0303 controller.
//!
//! \param ucChar is the byte to be transmitted to the controller.
//!
//! This function continues a transfer to the SSD0303 controller by writing
//! another byte over the I2C bus. This must only be called after calling
//! OSRAM96x16x1WriteFirst(), but before calling OSRAM96x16x1WriteFinal().
//!
//! The data is written in a polled faashion; this function will not return
//! until the byte has been written to the controller.
//!
//! \return None.
//
//*****************************************************************************
static void
OSRAM96x16x1WriteByte(unsigned char ucChar)
{
//
// Wait until the current byte has been transferred.
//
while(I2CMasterIntStatus(I2C0_MASTER_BASE, false) == 0)
{
}
//
// Provide the required inter-byte delay.
//
SysCtlDelay(g_ulDelay);
//
// Write the next byte to the controller.
//
I2CMasterDataPut(I2C0_MASTER_BASE, ucChar);
//
// Continue the transfer.
//
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);
}
//*****************************************************************************
//
//! \internal
//!
//! Finish a transfer to the SSD0303 controller.
//!
//! \param ucChar is the final byte to be written to the controller.
//!
//! This function will finish a transfer to the SSD0303 controller via the I2C
//! bus. This must only be called after calling OSRAMWriteFirst().
//!
//! The data is written in a polled fashion; this function will not return
//! until the byte has been written to the controller.
//!
//! \return None.
//
//*****************************************************************************
static void
OSRAMWriteFinal(unsigned char ucChar)
{
//
// Wait until the current byte has been transferred.
//
while(I2CMasterIntStatus(I2C_MASTER_BASE, false) == 0) {
}
//
// Provide the required inter-byte delay.
//
OSRAMDelay(g_ulDelay);
//
// Write the final byte to the controller.
//
I2CMasterDataPut(I2C_MASTER_BASE, ucChar);
//
// Finish the transfer.
//
I2CMasterControl(I2C_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH);
//
// Wait until the final byte has been transferred.
//
while(I2CMasterIntStatus(I2C_MASTER_BASE, false) == 0) {
}
//
// Provide the required inter-byte delay.
//
OSRAMDelay(g_ulDelay);
}
/**
* 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
}
}
//*****************************************************************************
//
//! \internal
//!
//! Write a sequence of bytes to the SSD0303 or SD1300 controller.
//!
//! This function continues a transfer to the display controller by writing a
//! sequence of bytes over the I2C bus. This must only be called after calling
//! Display96x16x1WriteFirst(), but before calling Display96x16x1WriteFinal().
//!
//! The data is written in a polled fashion; this function will not return
//! until the entire byte sequence has been written to the controller.
//!
//! \return None.
//
//*****************************************************************************
static void
Display96x16x1WriteArray(const unsigned char *pucBuffer, unsigned long ulCount)
{
//
// Loop while there are more bytes left to be transferred.
//
while(ulCount != 0)
{
//
// Wait until the current byte has been transferred.
//
while(I2CMasterIntStatus(I2C0_MASTER_BASE, false) == 0)
{
}
//
// Clear the I2C interrupt.
//
I2CMasterIntClear(I2C0_MASTER_BASE);
//
// Write the next byte to the controller.
//
I2CMasterDataPut(I2C0_MASTER_BASE, *pucBuffer++);
ulCount--;
//
// Continue the transfer.
//
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);
}
}
//*****************************************************************************
//
//! \internal
//!
//! Write a byte to the SSD0303 or SSD1300 controller.
//!
//! \param ucChar is the byte to be transmitted to the controller.
//!
//! This function continues a transfer to the display controller by writing
//! another byte over the I2C bus. This must only be called after calling
//! Display96x16x1WriteFirst(), but before calling Display96x16x1WriteFinal().
//!
//! The data is written in a polled faashion; this function will not return
//! until the byte has been written to the controller.
//!
//! \return None.
//
//*****************************************************************************
static void
Display96x16x1WriteByte(unsigned char ucChar)
{
//
// Wait until the current byte has been transferred.
//
while(I2CMasterIntStatus(I2C0_MASTER_BASE, false) == 0)
{
}
//
// Clear the I2C interrupt.
//
I2CMasterIntClear(I2C0_MASTER_BASE);
//
// Write the next byte to the controller.
//
I2CMasterDataPut(I2C0_MASTER_BASE, ucChar);
//
// Continue the transfer.
//
I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_CONT);
}
//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
}
}
