unsigned char *PTxData;                     // Pointer to TX data
unsigned char TXByteCtr;


unsigned char *PRxData;                     // Pointer to RX data
unsigned char RXByteCtr;
 unsigned char RxBuffer[5];         // Allocate 5 byte of RAM

void i2cb2_configuration()
{

	  P9SEL |= BIT5 + BIT6;                            // Assign P2.0 to UCB0SDA and...
	  P9DIR |= BIT5 + BIT6;                            // P2.1 to UCB0SCL

	  UCB2CTL1 |= UCSWRST;                      // Enable SW reset
	  UCB2CTL0 = UCMST | UCMODE_3 | UCSYNC;     // I2C Master, synchronous mode
	  UCB2CTL1 = UCSSEL_2 | UCSWRST;            // Use SMCLK, keep SW reset
	  UCB2BR0 = 40;                             // fSCL = SMCLK/40 = 4MHz/40= ~100kHz
	  UCB2BR1 = 0;
	  UCB2I2CSA = 0x68;                         // Slave Address is 048h
	  UCB2CTL1 &= ~UCSWRST;                     // Clear SW reset, resume operation
	  UCB2IE |= UCTXIE + UCRXIE;                         // Enable TX interrupt

}

void i2cb2_transmit_string(unsigned char* TxData )
{
	  unsigned int i;
    for(i=0;i<10;i++);                      // Delay required between transaction
    PTxData = (unsigned char *)TxData;      // TX array start address
                                            // Place breakpoint here to see each
                                            // transmit operation.
    TXByteCtr = sizeof TxData;              // Load TX byte counter

    UCB2CTL1 |= UCTR | UCTXSTT;             // I2C TX, start condition
  //  __delay_cycles(400);
    __bis_SR_register(LPM0_bits | GIE);     // Enter LPM0, enable interrupts
    //__no_operation();                       // Remain in LPM0 until all data
                                            // is TX'd

   // __delay_cycles(400);

    while (UCB2CTL1 & UCTXSTP);             // Ensure stop condition got sent

}

void i2cb2_write_i2c(unsigned char write, unsigned char addr, unsigned char data)
{
	unsigned char TxString[4];
	TxString[0]= write;
	TxString[1]= addr;
	TxString[2]= data;

	i2cb2_transmit_string(TxString);
}

int main()
{

	unsigned char TxData[] =              // Table of data to transmit
	{
	  0xD0,
	  0x00,
	  0x01,
	  0x04,
	  0x05
	};

	unsigned char RxData[] =              // Table of data to transmit
	{
	  0xD0,
	  0x00,
	  0xD1
	};

	  WDTCTL = WDTPW | WDTHOLD;                 // Stop WDT

	    P3DIR=0XFF;
		P3OUT=0X00;

	    P5DIR=0XFF;
		P5OUT=0XFF;

		__delay_cycles(400); // is 10 Seconds

		clear_lcd();
	    lcd_init();
	    clear_lcd();

	    UART_INIT();

	    set_cursor_pos(0,0);
	    display("I2C Program ");

	    set_cursor_pos(0,0);
	    display("UART Program ");

		clock();
		i2cb2_configuration();

	//	 i2cb2_transmit_string(TxData);

	i2cb2_transmit_string(TxData);

	//while(1)
	//	i2cb2_transmit_string(RxData);				// while loop to chck transmit function working or not 
		while(1)
		{
			i2cb2_transmit_string(RxData);				// data transmit to receive second

		    PRxData = (unsigned char *)RxBuffer;    // Start of RX buffer
		    RXByteCtr = 0;                          // Load RX byte counter
		    while (UCB2CTL1 & UCTXSTP);             // Ensure stop condition got sent

			  UCB2CTL1 &= ~UCTR;

		    UCB2CTL1 |= UCTXSTT;                    // I2C start condition

		    __delay_cycles(400);

		    __bis_SR_register(LPM0_bits | GIE);     // Enter LPM0, enable interrupts
		                                            // Remain in LPM0 until all data
		                                            // is RX'd
		   // __no_operation();                       // Set breakpoint >>here<< and

		}
//		  }                                         // read out the RxBuffer buffer

}


#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector = USCI_B2_VECTOR
__interrupt void USCI_B2_ISR(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(USCI_B2_VECTOR))) USCI_B2_ISR (void)
#else
#error Compiler not supported!
#endif
{
  switch(__even_in_range(UCB2IV,12))
  {
  case  0: break;                           // Vector  0: No interrupts
  case  2: break;                           // Vector  2: ALIFG
  case  4: break;                           // Vector  4: NACKIFG
  case  6: break;                           // Vector  6: STTIFG
  case  8: break;                           // Vector  8: STPIFG
  case 10:  RXByteCtr--;                            // Decrement RX byte counter
  	  	  	  if (RXByteCtr)
  	  	  	  {
  	  	  		  *PRxData++ = UCB2RXBUF;               // Move RX data to address PRxData
  	  	  		  if (RXByteCtr == 1)                   // Only one byte left?
  	  	  			  UCB2CTL1 |= UCTXSTP;                // Generate I2C stop condition
  	  	  	  }
  	  	  	  else
  	  	  	  {
  	  	  		  *PRxData = UCB2RXBUF;                 // Move final RX data to PRxData
  	  	  		  __bic_SR_register_on_exit(LPM0_bits); // Exit active CPU
  	  	  	  }
  	  	  	break;                           // Vector 10: RXIFG
  case 12:                                  // Vector 12: TXIFG
    if (TXByteCtr)                          // Check TX byte counter
    {
      UCB2TXBUF = *PTxData++;               // Load TX buffer
      TXByteCtr--;                          // Decrement TX byte counter
	    //set_cursor_pos(0,0);
	  //display(&TXByteCtr);
    }
    else
    {
      UCB2CTL1 |= UCTXSTP;                  // I2C stop condition
      UCB2IFG &= ~UCTXIFG;                  // Clear USCI_B0 TX int flag
      __bic_SR_register_on_exit(LPM0_bits); // Exit LPM0
    }
  default: break;
  }
}