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 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);
    }
}