Make a Color Sensor with Measurements Displayed via an RGB LED Module, 2

//extract the 16-bit R, G, and B values from the received data
R_word = (I2C_RcvData[1] << 8) | I2C_RcvData[0];
G_word = (I2C_RcvData[3] << 8) | I2C_RcvData[2];
B_word = (I2C_RcvData[5] << 8) | I2C_RcvData[4];

//apply correction factors based on the relative sensitivity of the three photodetectors
R_intensity = R_word * 1.39;
G_intensity = G_word * 1;
B_intensity = B_word * 1.79;

//determine which intensity is the highest of the three
if(R_intensity >= G_intensity && R_intensity >= B_intensity)
	MaxIntensity = R_intensity;
else if(G_intensity >= R_intensity && G_intensity >= B_intensity)
	MaxIntensity = G_intensity;
else		
	MaxIntensity = B_intensity;

/*Now we scale each measurement into the range 0 to 100.
 * This preserves the relative ratios of the three
 * intensities but standardizes the absolute intensities.
 * Thus, the appearance of the LED module is
 * determined by the proportion of red, green,
 * and blue light, not by the overall intensity of
 * the incident light.*/
R_scaled = (R_intensity/MaxIntensity)*100;
G_scaled = (G_intensity/MaxIntensity)*100;
B_scaled = (B_intensity/MaxIntensity)*100;

int main(void) {

	unsigned char R_scaled, G_scaled, B_scaled;
	unsigned int R_word, G_word, B_word;
	float R_intensity, G_intensity, B_intensity, MaxIntensity;

	// Call hardware initialization routine
	enter_DefaultMode_from_RESET();

	//enable global interrupts
	IE_EA = 1;

	//tell the RGBC sensor to start performing measurements
	I2C_MasterWrite(RGBC_Tx_EnableConv);

	while (1)
	{
		Delay_10ms(100);	//the LED is updated once per second

		//load the proper register address (for reading) into the RGBC sensor
		I2C_MasterWrite(RGBC_Tx_SetReadRGBC);

		//read the RGBC data
		I2C_MasterRead(RGBC_Rx_RGBC);

		//wait until the read transaction is complete
		while(I2C_State != MstR_DATA_READY);
		I2C_State = IDLE;

		//extract the 16-bit R, G, and B values from the received data
		R_word = (I2C_RcvData[1] << 8) | I2C_RcvData[0];
		G_word = (I2C_RcvData[3] << 8) | I2C_RcvData[2];
		B_word = (I2C_RcvData[5] << 8) | I2C_RcvData[4];

		//apply correction factors based on the relative sensitivity of the three photodetectors
		R_intensity = R_word * 1.39;
		G_intensity = G_word * 1;
		B_intensity = B_word * 1.79;

		//determine which intensity is the highest of the three
		if(R_intensity >= G_intensity && R_intensity >= B_intensity)
			MaxIntensity = R_intensity;
		else if(G_intensity >= R_intensity && G_intensity >= B_intensity)
			MaxIntensity = G_intensity;
		else
			MaxIntensity = B_intensity;

		/*Now we scale each measurement into the range 0 to 100.
		 * This preserves the relative ratios of the three
		 * intensities but standardizes the absolute intensities.
		 * Thus, the appearance of the LED module is
		 * determined by the proportion of red, green,
		 * and blue light, not by the overall intensity of
		 * the incident light.*/
		R_scaled = (R_intensity/MaxIntensity)*100;
		G_scaled = (G_intensity/MaxIntensity)*100;
		B_scaled = (B_intensity/MaxIntensity)*100;

		/* This can be used to turn off the LED if the measured
		 * light intensity is too low. This helps to avoid distracting
		 * color changes related to irrelevant RGB variations detected
		 * during low-intensity lighting conditions. This functionality
		 * was used with the "Christmas lights" demonstration to make
		 * the LED turn off when the sensor was not illuminated by one
		 * of the lights.*/
		if(MaxIntensity < 100)
		{
			R_scaled = 0;
			G_scaled = 0;
			B_scaled = 0;
		}

		//update each DAC channel with the scaled values
		UpdateDAC(DAC_RGB_R, R_scaled);
		UpdateDAC(DAC_RGB_G, G_scaled);
		UpdateDAC(DAC_RGB_B, B_scaled);
	}
}

unsigned char I2C_SlaveAddr;	//global variable for current slave address
unsigned char I2C_NumReadBytes;	//number of bytes to be read
unsigned char idata *I2C_WriteBufferPtr;	//pointer to bytes to be transmitted
unsigned char I2C_FinalWriteAddress;	//the ISR uses this to determine which byte is the final byte

/*These "transaction arrays" contain all the information needed for a particular I2C transaction*/

//write to register address 0x42 to enable RGBC conversions and keep the gain at default (1x)
unsigned char idata RGBC_Tx_EnableConv[4] = {RGB_SENS_ADDR, 2, 0x42, 0x10};

//write to register address 0x42 to enable RGBC conversions and set the gain to 16x
//(so far it appears that it is best to leave the gain at 1x)
unsigned char idata RGBC_Tx_EnableConv_16x[4] = {RGB_SENS_ADDR, 2, 0x42, 0x12};

//set the read address to 0x50, which is the beginning of the registers that hold RGBC data
unsigned char idata RGBC_Tx_SetReadRGBC[3] = {RGB_SENS_ADDR, 1, 0x50};

//read RGBC data (after setting the read address using RGBC_Tx_SetReadRGBC )
unsigned char idata RGBC_Rx_RGBC[3] = {RGB_SENS_ADDR, RGBC_DATA_LEN};


void I2C_MasterWrite(unsigned char* PtrtoCmdBuffer)	//function argument is simply the name of the transaction array
{
	//ensure that we are not interrupting an ongoing transaction
	while(I2C_State != IDLE);

	I2C_State = MstW_STA_SENT;	//first state is "start condition generated"
	I2C_SlaveAddr = PtrtoCmdBuffer[0];	//copy the slave address from the transaction array to the global variable
	I2C_WriteBufferPtr = PtrtoCmdBuffer + 2;	//set the address of the first data byte in the transaction array
	I2C_FinalWriteAddress = I2C_WriteBufferPtr + (PtrtoCmdBuffer[1] - 1);	//set the final address based on the number of bytes to be transmitted

	SFRPAGE = SMB0_PAGE;
	SMB0CN0_STA = 1;	//initiate the transaction by setting the start-condition bit
}

void I2C_MasterRead(unsigned char* PtrtoCmdBuffer)	//function argument is simply the name of the transaction array
{
	//ensure that we are not interrupting an ongoing transaction
	while(I2C_State != IDLE);

	I2C_State = MstR_STA_SENT;	//first state is "start condition generated"
	I2C_SlaveAddr = PtrtoCmdBuffer[0];	//copy the slave address from the transaction array to the global variable
	I2C_NumReadBytes = PtrtoCmdBuffer[1];	//copy the number of bytes to be read from the transaction array to the global variable

	SFRPAGE = SMB0_PAGE;
	SMB0CN0_STA = 1;	//initiate the transaction by setting the start-condition bit
}

SI_INTERRUPT (SMBUS0_ISR, SMBUS0_IRQn)
{
	SFRPAGE_SAVE = SFRPAGE;
	SFRPAGE = SMB0_PAGE;

	switch(I2C_State)
	{
		//Master Read===================================================
				//start condition transmitted
		case MstR_STA_SENT:
			SMB0CN0_STA = 0;	//clear start-condition bit
			SMB0CN0_STO = 0;	//make sure that stop-condition bit is cleared
			SMB0DAT = (I2C_SlaveAddr<<1)|BIT0;	//combine slave address with R/nW = 1
			I2C_State = MstR_ADDR_SENT;		//set state variable to next state
			SMB0CN0_SI = 0;	//clear interrupt flag
			break;

				//master transmitted "address + R/W" byte
		case MstR_ADDR_SENT:
			if(SMB0CN0_ACK == I2C_NACK)	//if slave did not ACK
			{
				//cancel transmission and release bus, as follows:
				SMB0CN0_STO = 1;	//transmit stop condition
				I2C_State = IDLE;	//set current state as IDLE
			}
			else	//if slave ACKed
			{
				if(I2C_NumReadBytes == 1)	//if only one byte will be read
				{
					//master NACKs next byte to say "stop transmitting"
					SMB0CN0_ACK = I2C_NACK;
				}
				else	//if more than one byte will be read
				{
					//master ACKs next byte to say "continue transmitting"
					SMB0CN0_ACK = I2C_ACK;
				}
				RcvdByteCount = 0;	//this variable will be an index for storing received bytes in an array
				I2C_State = MstR_READ_BYTE;	//set next state
			}
			SMB0CN0_SI = 0;	//clear interrupt flag
			break;

				//master received a byte
		case MstR_READ_BYTE:
			I2C_RcvData[RcvdByteCount] = SMB0DAT;	//store received byte
			RcvdByteCount++;	//increment byte counter (which is also the array index)
			SMB0CN0_SI = 0;	//clear interrupt flag

			if(RcvdByteCount == I2C_NumReadBytes)	//if this was the final byte
			{
				//release bus, as follows:
				SMB0CN0_STO = 1;	//transmit stop condition
				SMB0CN0_SI = 0;	//clear interrupt flag
				I2C_State = MstR_DATA_READY;	//this state tells the while loop in main() that the received data is ready
			}
			else if(RcvdByteCount == (I2C_NumReadBytes-1))	//if the next byte is the final byte
			{
				SMB0CN0_ACK = I2C_NACK;	//master NACKs next byte to say "stop transmitting"
			}
			else
			{
				SMB0CN0_ACK = I2C_ACK;	//master ACKs next byte to say "continue transmitting"
			}
			break;

		//Master Write===================================================
			//start condition transmitted
		case MstW_STA_SENT:
			SMB0CN0_STA = 0;	//clear start-condition bit
			SMB0CN0_STO = 0;	//make sure that stop-condition bit is cleared
			SMB0DAT = (I2C_SlaveAddr<<1);	//combine slave address with R/nW = 0
			I2C_State = MstW_ADDR_SENT;	//set state variable to next state
			SMB0CN0_SI = 0;	//clear interrupt flag
			break;

			//master transmitted "address + R/W" byte
		case MstW_ADDR_SENT:
			if(SMB0CN0_ACK == I2C_NACK)	//if slave did not ACK
			{
				//cancel transmission and release bus, as follows:
				SMB0CN0_STO = 1;	//transmit stop condition
				I2C_State = IDLE;	//set current state as IDLE
			}
			else	//if slave ACKed
			{
				SMB0DAT = *I2C_WriteBufferPtr;	//write first byte to SMBus data register
				I2C_State = MstW_BYTE_SENT;	//set next state
			}
			SMB0CN0_SI = 0;	//clear interrupt flag
			break;

			//master transmitted a byte
		case MstW_BYTE_SENT:
			if(SMB0CN0_ACK == I2C_NACK)	//if slave NACKed
			{
				//stop transmission and release bus, as follows:
				SMB0CN0_STO = 1;	//transmit stop condition
				I2C_State = IDLE;	//set current state as IDLE
			}
			//if slave ACKed and this was the final byte
			else if(I2C_WriteBufferPtr == I2C_FinalWriteAddress)
			{
				SMB0CN0_STO = 1;	//transmit stop condition
				I2C_State = IDLE;	//set current state as IDLE
			}
			//if slave ACKed and this was not the final byte
			else
			{
				I2C_WriteBufferPtr++;	//increment pointer that points at data to be transmitted
				SMB0DAT = *I2C_WriteBufferPtr;	//write next byte to SMBus data register
			}
			SMB0CN0_SI = 0;	//clear interrupt flag
			break;
	}

	SFRPAGE = SFRPAGE_SAVE;
}