自学教程：C++ I2CMasterControl函数代码示例

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 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 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 ledsvoid 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 exitvoid 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_tAccel_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 voidOSRAMWriteArray(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;}

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 voidOSRAM96x16x1WriteByte(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 voidOSRAMWriteFinal(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 voidDisplay96x16x1WriteArray(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 voidDisplay96x16x1WriteByte(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 readvoid 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	}}