[参考译文] MSP430FR5969：用于 MSP430FR5969微控制器与 TMP117温度传感器通信的 I2C 示例代码

#include <msp430.h>
#include "driverlib.h"
#include <stdint.h>
#include <stdbool.h>

#include "mcu.h"

unsigned char transmitLength = 0;
unsigned char transmitCount = 0;
unsigned char *transmitBuffer;
unsigned char receiveCount = 0;
unsigned char *receiveBuffer;


#define SLAVE_ADDR  0x48        // sensor address 

#define TMP117_TEMP_REG  0x00   //temperature register
#define TMP117_CONFIG_REG  0x01  //Configuration registry

#define TMP117_RESOLUTION 0.0078125f // sensor resolution 

void mcu_i2cInit(uint8_t busId) {

    //Stop WDT
    WDT_A_hold(WDT_A_BASE);

    //Set the internal pull-up resistors
    //Ports 4.2 and 4.1 are SCL/SDA, respectively
    //GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P4,
    //GPIO_PIN1 + GPIO_PIN2);

    //Assign I2C pins to USCI_B1
    //GPIO_setAsPeripheralModuleFunctionOutputPin(
    //GPIO_PORT_P4,
    //GPIO_PIN1 + GPIO_PIN2);

    GPIO_setAsPeripheralModuleFunctionInputPin(
            GPIO_PORT_P1,
            GPIO_PIN6 + GPIO_PIN7,
            GPIO_SECONDARY_MODULE_FUNCTION
        );
    PMM_unlockLPM5();

        //Initialize Master
        EUSCI_B_I2C_initMasterParam param = {0};
        param.selectClockSource = EUSCI_B_I2C_CLOCKSOURCE_SMCLK;
        param.i2cClk = CS_getSMCLK();
        param.dataRate = EUSCI_B_I2C_SET_DATA_RATE_100KBPS;
        EUSCI_B_I2C_initMaster(EUSCI_B0_BASE, &param);

        //Set Transmit mode
        EUSCI_B_I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_MODE);

        //Enable I2C Module to start operations
        EUSCI_B_I2C_enable(EUSCI_B0_BASE);
    }

    int8_t mcu_i2cTransfer(uint8_t busId, uint8_t i2cAddr, uint8_t *dataToWrite, uint8_t writeLength, uint8_t *dataToRead, uint8_t readLength) {
        EUSCI_B_I2C_setSlaveAddress(EUSCI_B0_BASE, i2cAddr);
        if (writeLength) {
            transmitBuffer = dataToWrite;
            transmitLength = writeLength;
            EUSCI_B_I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_MODE);
            EUSCI_B_I2C_clearInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_INTERRUPT0);
            EUSCI_B_I2C_enableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_INTERRUPT0);
            //Delay between each transaction
        __delay_cycles(50);
            //Load TX byte counter
            transmitCount = 1;
            //Initiate start and send first character
            EUSCI_B_I2C_masterSendMultiByteStart(EUSCI_B0_BASE, transmitBuffer[0]);
            //Enter low power mode 0 with interrupts enabled.
            __bis_SR_register(LPM0_bits + GIE);
            //__no_operation();
        }
        if (readLength) {
            //Delay until transmission completes
    //    while(USCI_B_I2C_isBusBusy(EUSCI_B0_BASE))
    //    {
    //        ;
    //    }
            EUSCI_B_I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_MODE);
            //Enable master Receive interrupt
            EUSCI_B_I2C_enableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
            EUSCI_B_I2C_clearInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
            receiveCount = readLength;
            receiveBuffer = dataToRead;

            if (receiveCount == 1) {

               EUSCI_B_I2C_disableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
               EUSCI_B_I2C_clearInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
               EUSCI_B_I2C_masterReceiveStart(EUSCI_B0_BASE);



                //dataToRead[0] = EUSCI_B_I2C_masterReceiveMultiByteNext(EUSCI_B0_BASE);
                //Set USCI in Receive mode
                HWREG16(EUSCI_B0_BASE + OFS_UCBxCTLW0) &= ~UCTR;

                //Send start condition.
                HWREG16(EUSCI_B0_BASE + OFS_UCBxCTLW0) |= UCTXSTT;

                //Poll for Start bit to complete
                while (HWREG16(EUSCI_B0_BASE + OFS_UCBxCTLW0) & UCTXSTT) {
                    ;
                }

                //Send stop condition.
                HWREG16(EUSCI_B0_BASE + OFS_UCBxCTLW0) |= UCTXSTP;
                __bis_SR_register(LPM0_bits + GIE);
            }
            else {
                EUSCI_B_I2C_masterReceiveStart(EUSCI_B0_BASE);
                //Enter low power mode 0 with interrupts enabled.
                __bis_SR_register(LPM0_bits + GIE);
            }
        }
        return (0);
    }


    /********* MCU SPECIFIC I2C CODE ENDS HERE**********/

    /********* MCU SPECIFIC DELAY CODE ENDS HERE************/
    void mcu_msWait(unsigned long msWait) {
        __delay_cycles(50);
    }
    /********* MCU SPECIFIC DELAY CODE ENDS HERE************/




    #if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
    #pragma vector = USCI_B0_VECTOR;
    __interrupt
    #elif defined(__GNUC__)
    __attribute__((interrupt(USCI_B0_VECTOR)))
    #endif
    void USCI_B1_ISR(void) {
        switch (__even_in_range(UCB0IV, 12)) {
        case USCI_I2C_UCTXIFG0: {
            //Check TX byte counter
            if (transmitCount < transmitLength) {
                //Initiate send of character from Master to Slave
                EUSCI_B_I2C_masterSendMultiByteNext(EUSCI_B0_BASE, transmitBuffer[transmitCount]);

                //Increment TX byte counter
                transmitCount++;
            } else {
                //Initiate stop only
                EUSCI_B_I2C_masterSendMultiByteStop(EUSCI_B0_BASE);

                //Clear master interrupt status
                EUSCI_B_I2C_clearInterrupt(EUSCI_B0_BASE,
                EUSCI_B_I2C_TRANSMIT_INTERRUPT0);

                //Exit LPM0 on interrupt return
                __bic_SR_register_on_exit(LPM0_bits);
            }
            break;
        }
        case USCI_I2C_UCRXIFG0: {
            //Decrement RX byte counter
            receiveCount--;
            if (receiveCount) {
                if (receiveCount == 1) {
                    //Initiate end of reception -> Receive byte with NAK
                    *receiveBuffer++ = EUSCI_B_I2C_masterReceiveMultiByteNext(EUSCI_B0_BASE);
                    EUSCI_B_I2C_clearInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
                    __bic_SR_register_on_exit(LPM0_bits);
                } else {
                    //Keep receiving one byte at a time
                    *receiveBuffer++ = EUSCI_B_I2C_masterReceiveMultiByteNext(EUSCI_B0_BASE);
                }
            } else {
                //Receive last byte
                *receiveBuffer = EUSCI_B_I2C_masterReceiveMultiByteNext(EUSCI_B0_BASE);
                EUSCI_B_I2C_disableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
                EUSCI_B_I2C_clearInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
                __bic_SR_register_on_exit(LPM0_bits);
            }
            break;
        }
        }
    }

/* --COPYRIGHT--,BSD_EX
 * Copyright (c) 2012, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *******************************************************************************
 *
 *                       MSP430 CODE EXAMPLE DISCLAIMER
 *
 * MSP430 code examples are self-contained low-level programs that typically
 * demonstrate a single peripheral function or device feature in a highly
 * concise manner. For this the code may rely on the device's power-on default
 * register values and settings such as the clock configuration and care must
 * be taken when combining code from several examples to avoid potential side
 * effects. Also see www.ti.com/grace for a GUI- and www.ti.com/msp430ware
 * for an API functional library-approach to peripheral configuration.
 *
 * --/COPYRIGHT--*/
//******************************************************************************
//  MSP430FR59xx Demo - USCI_A0 External Loopback test @ 115200 baud
//
//  Description: This demo connects TX to RX of the MSP430 UART
//  The example code shows proper initialization of registers
//  and interrupts to receive and transmit data. If data is incorrect P1.0 LED is
//  turned ON.
//  ACLK = n/a, MCLK = SMCLK = BRCLK = default DCO = 1MHz
//
//
//                MSP430FR5969
//             -----------------
//       RST -|     P2.0/UCA0TXD|----|
//            |                 |    |
//           -|                 |    |
//            |     P2.1/UCA0RXD|----|
//            |                 |
//            |             P1.0|---> LED
//
//   P. Thanigai
//   Texas Instruments Inc.
//   August 2012
//   Built with CCS V4 and IAR Embedded Workbench Version: 5.5
//******************************************************************************
#include <msp430.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>

//volatile unsigned char RXData = 0;
//volatile unsigned char TXData = 1;

   char RXbuffer[32];
   const unsigned char maxRXbytes = sizeof(RXbuffer);
   unsigned char RXbytes = 0;

   const char message[] = "ok\n";
   const unsigned char messageLength = sizeof(message);
   unsigned char TXbytes = 0;

   const char firstquestion[] = "Hello World\n ";
   unsigned int i=0;

   int temp = 56;
   char stringTemp[80];
   unsigned int len;

int main(void)
{
  WDTCTL = WDTPW | WDTHOLD;                 // Stop watchdog

  // Configure GPIO
  P1OUT &= ~BIT0;                           // Clear P1.0 output latch
  P1DIR |= BIT0;                            // For LED on P1.0
  P2SEL1 |= BIT0 | BIT1;                    // USCI_A0 UART operation
  P2SEL0 &= ~(BIT0 | BIT1);

  // Disable the GPIO power-on default high-impedance mode to activate
  // previously configured port settings
  PM5CTL0 &= ~LOCKLPM5;

  // Configure USCI_A0 for UART mode
  UCA0CTLW0 = UCSWRST;                      // Put eUSCI in reset
  UCA0CTL1 |= UCSSEL__SMCLK;                // CLK = SMCLK
  UCA0BR0 = 8;                              // 1000000/115200 = 8.68
  UCA0MCTLW = 0xD600;                       // 1000000/115200 - INT(1000000/115200)=0.68
                                            // UCBRSx value = 0xD6 (See UG)
  UCA0BR1 = 0;
  UCA0CTL1 &= ~UCSWRST;                     // release from reset
  //UCA0IE |= UCRXIE;                         // Enable USCI_A0 RX interrupt

 


  while (1)
  {
   // while(!(UCA0IFG & UCTXIFG));
    //UCA0TXBUF = TXData;                     // Load data onto buffer

   //UCA0TXBUF = message[TXbytes];

    // If last byte sent, disable the interrupt
   //if(TXbytes == messageLength)
   // {
       // UCA0IE &= ~UCTXIE;
       // TXbytes = 0;
   // }

      //for(i=0; i<strlen(firstquestion); i++)   //loops through first question elements and outputs
      // {
          // while (!(UCA0IFG & UCTXIFG));          //waits for character
           //UCA0TXBUF = firstquestion[i];         //sets character to for element of first question

      // }

     sprintf(stringTemp, "%d\n", temp);

      len = strlen(stringTemp);

      for(i=0; i<len; i++){
            while(!(UCA0IFG&UCTXIFG));
            UCA0TXBUF = stringTemp[i];
            }

    __bis_SR_register(LPM0_bits | GIE);     // Enter LPM0, interrupts enabled

  }
}

#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector=USCI_A0_VECTOR
__interrupt void USCI_A0_ISR(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(USCI_A0_VECTOR))) USCI_A0_ISR (void)
#else
#error Compiler not supported!
#endif
{
  switch(__even_in_range(UCA0IV,USCI_UART_UCTXCPTIFG))
  {
    case USCI_NONE: break;
    case USCI_UART_UCRXIFG:
      //RXData = UCA0RXBUF;                   // Read buffer
      //if(RXData != TXData)                  // Check value
     // {
       // P1OUT |= BIT0;                      // If incorrect turn on P1.0
         // while(1);                         // Trap CPU
     // }
     // TXData++;                             // increment data byte
     // __bic_SR_register_on_exit(LPM0_bits); // Exit LPM0 on reti
      break;
    case USCI_UART_UCTXIFG: break;
    case USCI_UART_UCSTTIFG: break;
    case USCI_UART_UCTXCPTIFG: break;
  }
}

sprintf(stringTemp, "%d\n", temp);

//******************************************************************************
//   MSP430FR59xx Demo - eUSCI_B0, I2C Master multiple byte TX/RX
//
//   Description: I2C master communicates to I2C slave sending and receiving
//   3 different messages of different length. I2C master will enter LPM0 mode
//   while waiting for the messages to be sent/receiving using I2C interrupt.
//   ACLK = NA, MCLK = SMCLK = DCO 16MHz.
//
//                                     /|\ /|\
//                   MSP430FR5969      4.7k |
//                 -----------------    |  4.7k
//            /|\ |             P1.7|---+---|-- I2C Clock (UCB0SCL)
//             |  |                 |       |
//             ---|RST          P1.6|-------+-- I2C Data (UCB0SDA)
//                |                 |
//                |                 |
//                |                 |
//                |                 |
//                |                 |
//                |                 |
//
//   Nima Eskandari
//   Texas Instruments Inc.
//   April 2017
//   Built with CCS V7.0
//******************************************************************************

#include <stdio.h>
#include <msp430.h> 
#include <stdint.h>
#include <stdbool.h>

#include <string.h>
#include <ctype.h>
#include <stdlib.h>

//******************************************************************************
// Example Commands ************************************************************
//******************************************************************************

#define SLAVE_ADDR  0x48
#define CONVERSION_READY  0x10

#define TMP117_TEMP_REG  0x00
#define TMP117_CONFIG_REG  0x01

#define TMP117_RESOLUTION 0.0078125f

/* CMD_TYPE_X_SLAVE are example commands the master sends to the slave.
 * The slave will send example SlaveTypeX buffers in response.
 *
 * CMD_TYPE_X_MASTER are example commands the master sends to the slave.
 * The slave will initialize itself to receive MasterTypeX example buffers.
 * */

#define CMD_TYPE_0_SLAVE      0
#define CMD_TYPE_1_SLAVE      1
#define CMD_TYPE_2_SLAVE      2

#define CMD_TYPE_0_MASTER      3
#define CMD_TYPE_1_MASTER      4
#define CMD_TYPE_2_MASTER      5

#define TYPE_0_LENGTH   1
#define TYPE_1_LENGTH   2
#define TYPE_2_LENGTH   6

#define MAX_BUFFER_SIZE     20

/* MasterTypeX are example buffers initialized in the master, they will be
 * sent by the master to the slave.
 * SlaveTypeX are example buffers initialized in the slave, they will be
 * sent by the slave to the master.
 * */

uint8_t MasterType2 [TYPE_2_LENGTH] = {'F', '4', '1', '9', '2', 'B'};
//uint8_t MasterType1 [TYPE_1_LENGTH] = { 8, 9};
uint8_t MasterType1 [TYPE_1_LENGTH] = {0x02, 0x20};

uint8_t MasterType0 [TYPE_0_LENGTH] = {11};


uint8_t SlaveType2 [TYPE_2_LENGTH] = {0};
uint8_t SlaveType1 [TYPE_1_LENGTH] = {0};
uint8_t SlaveType0 [TYPE_0_LENGTH] = {0};

   char RXbuffer[32];
   const unsigned char maxRXbytes = sizeof(RXbuffer);
   unsigned char RXbytes = 0;

   const char message[] = "ok\n";
   const unsigned char messageLength = sizeof(message);
   unsigned char TXbytes = 0;

   const char firstquestion[] = "Hello World\n ";
   unsigned int i=0;

   int temp = 56;
   char stringTemp[80];
   unsigned int len;

//******************************************************************************
// General I2C State Machine ***************************************************
//******************************************************************************

typedef enum I2C_ModeEnum{
    IDLE_MODE,
    NACK_MODE,
    TX_REG_ADDRESS_MODE,
    RX_REG_ADDRESS_MODE,
    TX_DATA_MODE,
    RX_DATA_MODE,
    SWITCH_TO_RX_MODE,
    SWITHC_TO_TX_MODE,
    TIMEOUT_MODE
} I2C_Mode;


/* Used to track the state of the software state machine*/
I2C_Mode MasterMode = IDLE_MODE;

/* The Register Address/Command to use*/
uint8_t TransmitRegAddr = 0;

/* ReceiveBuffer: Buffer used to receive data in the ISR
 * RXByteCtr: Number of bytes left to receive
 * ReceiveIndex: The index of the next byte to be received in ReceiveBuffer
 * TransmitBuffer: Buffer used to transmit data in the ISR
 * TXByteCtr: Number of bytes left to transfer
 * TransmitIndex: The index of the next byte to be transmitted in TransmitBuffer
 * */
uint8_t ReceiveBuffer[MAX_BUFFER_SIZE] = {0};
uint8_t RXByteCtr = 0;
uint8_t ReceiveIndex = 0;
uint8_t TransmitBuffer[MAX_BUFFER_SIZE] = {0};
uint8_t TXByteCtr = 0;
uint8_t TransmitIndex = 0;


/* I2C Write and Read Functions */

/* For slave device with dev_addr, writes the data specified in *reg_data
 *
 * dev_addr: The slave device address.
 *           Example: SLAVE_ADDR
 * reg_addr: The register or command to send to the slave.
 *           Example: CMD_TYPE_0_MASTER
 * *reg_data: The buffer to write
 *           Example: MasterType0
 * count: The length of *reg_data
 *           Example: TYPE_0_LENGTH
 *  */
I2C_Mode I2C_Master_WriteReg(uint8_t dev_addr, uint8_t reg_addr, uint8_t *reg_data, uint8_t count);

/* For slave device with dev_addr, read the data specified in slaves reg_addr.
 * The received data is available in ReceiveBuffer
 *
 * dev_addr: The slave device address.
 *           Example: SLAVE_ADDR
 * reg_addr: The register or command to send to the slave.
 *           Example: CMD_TYPE_0_SLAVE
 * count: The length of data to read
 *           Example: TYPE_0_LENGTH
 *  */
I2C_Mode I2C_Master_ReadReg(uint8_t dev_addr, uint8_t reg_addr, uint8_t count);
void CopyArray(uint8_t *source, uint8_t *dest, uint8_t count);


I2C_Mode I2C_Master_ReadReg(uint8_t dev_addr, uint8_t reg_addr, uint8_t count)
{
    /* Initialize state machine */
    MasterMode = TX_REG_ADDRESS_MODE;
    TransmitRegAddr = reg_addr;
    RXByteCtr = count;
    TXByteCtr = 0;
    ReceiveIndex = 0;
    TransmitIndex = 0;

    /* Initialize slave address and interrupts */
    UCB0I2CSA = dev_addr;
    UCB0IFG &= ~(UCTXIFG + UCRXIFG);       // Clear any pending interrupts
    UCB0IE &= ~UCRXIE;                       // Disable RX interrupt
    UCB0IE |= UCTXIE;                        // Enable TX interrupt

    UCB0CTLW0 |= UCTR + UCTXSTT;             // I2C TX, start condition
    __bis_SR_register(LPM0_bits + GIE);              // Enter LPM0 w/ interrupts

    return MasterMode;
}

I2C_Mode I2C_Master_WriteReg(uint8_t dev_addr, uint8_t reg_addr, uint8_t *reg_data, uint8_t count)
{
    /* Initialize state machine */
    MasterMode = TX_REG_ADDRESS_MODE;
    TransmitRegAddr = reg_addr;

    //Copy register data to TransmitBuffer
    CopyArray(reg_data, TransmitBuffer, count);

    TXByteCtr = count;
    RXByteCtr = 0;
    ReceiveIndex = 0;
    TransmitIndex = 0;

    /* Initialize slave address and interrupts */
    UCB0I2CSA = dev_addr;
    UCB0IFG &= ~(UCTXIFG + UCRXIFG);       // Clear any pending interrupts
    UCB0IE &= ~UCRXIE;                       // Disable RX interrupt
    UCB0IE |= UCTXIE;                        // Enable TX interrupt

    UCB0CTLW0 |= UCTR + UCTXSTT;             // I2C TX, start condition
    __bis_SR_register(LPM0_bits + GIE);              // Enter LPM0 w/ interrupts

    return MasterMode;
}

void CopyArray(uint8_t *source, uint8_t *dest, uint8_t count)
{
    uint8_t copyIndex = 0;
    for (copyIndex = 0; copyIndex < count; copyIndex++)
    {
        dest[copyIndex] = source[copyIndex];
    }
}

//******************************************************************************
// Device Initialization *******************************************************
//******************************************************************************

void initGPIO()
{
    // Configure GPIO
    P1OUT &= ~BIT0;                           // Clear P1.0 output latch
    P1DIR |= BIT0;                            // For LED
    P1SEL1 |= BIT6 | BIT7;                    // I2C pins
    // Disable the GPIO power-on default high-impedance mode to activate
    // previously configured port settings
    PM5CTL0 &= ~LOCKLPM5;
}

void initClockTo16MHz()
{
    // Configure one FRAM waitstate as required by the device datasheet for MCLK
    // operation beyond 8MHz _before_ configuring the clock system.
    FRCTL0 = FRCTLPW | NWAITS_1;

    // Clock System Setup
    CSCTL0_H = CSKEY >> 8;                    // Unlock CS registers
    CSCTL1 = DCORSEL | DCOFSEL_4;             // Set DCO to 16MHz
    CSCTL2 = SELA__VLOCLK | SELS__DCOCLK | SELM__DCOCLK;
    CSCTL3 = DIVA__1 | DIVS__1 | DIVM__1;     // Set all dividers

    CSCTL0_H = 0;                             // Lock CS registerss
}

void initI2C()
{
    UCB0CTLW0 = UCSWRST;                      // Enable SW reset
    UCB0CTLW0 |= UCMODE_3 | UCMST | UCSSEL__SMCLK | UCSYNC; // I2C master mode, SMCLK
    UCB0BRW = 160;                            // fSCL = SMCLK/160 = ~100kHz
    UCB0I2CSA = SLAVE_ADDR;                   // Slave Address
    UCB0CTLW0 &= ~UCSWRST;                    // Clear SW reset, resume operation
    UCB0IE |= UCNACKIE;

}

//**********************UART****************************************************
int uart()
{
 // WDTCTL = WDTPW | WDTHOLD;                 // Stop watchdog

  // Configure GPIO
  P1OUT &= ~BIT0;                           // Clear P1.0 output latch
  P1DIR |= BIT0;                            // For LED on P1.0
  P2SEL1 |= BIT0 | BIT1;                    // USCI_A0 UART operation
  P2SEL0 &= ~(BIT0 | BIT1);

  // Disable the GPIO power-on default high-impedance mode to activate
  // previously configured port settings
  PM5CTL0 &= ~LOCKLPM5;

  // Configure USCI_A0 for UART mode
  UCA0CTLW0 = UCSWRST;                      // Put eUSCI in reset
  UCA0CTL1 |= UCSSEL__SMCLK;                // CLK = SMCLK
  UCA0BR0 = 8;                              // 1000000/115200 = 8.68
  UCA0MCTLW = 0xD600;                       // 1000000/115200 - INT(1000000/115200)=0.68
                                            // UCBRSx value = 0xD6 (See UG)
  UCA0BR1 = 0;
  UCA0CTL1 &= ~UCSWRST;                     // release from reset
  //UCA0IE |= UCRXIE;                         // Enable USCI_A0 RX interrupt

  while (1)
  {

     sprintf(stringTemp, "%d", temp);

      len = strlen(stringTemp);

      for(i=0; i<len; i++){
            while(!(UCA0IFG&UCTXIFG));
            UCA0TXBUF = stringTemp[i];
            }

   // __bis_SR_register(LPM0_bits | GIE);     // Enter LPM0, interrupts enabled

  }
}

//***************************UART***************************************************

//******************************************************************************
// Main ************************************************************************
// Send and receive three messages containing the example commands *************
//******************************************************************************

int main(void) {
    WDTCTL = WDTPW | WDTHOLD;	// Stop watchdog timer
    initClockTo16MHz();
    initGPIO();
    initI2C();
    uart();

    //I2C_Master_WriteReg(SLAVE_ADDR, CMD_TYPE_0_MASTER, MasterType0, TYPE_0_LENGTH);
    I2C_Master_WriteReg(SLAVE_ADDR, 0x01, MasterType1, TYPE_1_LENGTH);
    while(1)
    {

       _delay_cycles(500000);
       // _delay_cycles(1600);

        I2C_Master_ReadReg(SLAVE_ADDR, 0x00, TYPE_1_LENGTH);
        CopyArray(ReceiveBuffer, SlaveType1, TYPE_1_LENGTH);

        if(ReceiveBuffer[1] & CONVERSION_READY)
        {
            I2C_Master_ReadReg(SLAVE_ADDR, 0x00, TYPE_1_LENGTH);
            CopyArray(ReceiveBuffer, SlaveType1, TYPE_1_LENGTH);
            _no_operation();
        }
   }

  //  float finalTempC = ReceiveBuffer [1]* TMP117_RESOLUTION;

    //return 0;
}
    //I2C_Master_WriteReg(SLAVE_ADDR, CMD_TYPE_2_MASTER, MasterType2, TYPE_2_LENGTH);

    ///I2C_Master_ReadReg(SLAVE_ADDR, CMD_TYPE_0_SLAVE, TYPE_0_LENGTH);
    //CopyArray(ReceiveBuffer, SlaveType0, TYPE_0_LENGTH);

    //I2C_Master_ReadReg(SLAVE_ADDR, 0x00, TYPE_1_LENGTH);
    //CopyArray(ReceiveBuffer, SlaveType1, TYPE_1_LENGTH);

   //I2C_Master_ReadReg(SLAVE_ADDR, CMD_TYPE_2_SLAVE, TYPE_2_LENGTH);
   // CopyArray(ReceiveBuffer, SlaveType2, TYPE_2_LENGTH);

   // __bis_SR_register(LPM0_bits + GIE);
	//return 0;
//}

//******************************************************************************
// I2C Interrupt ***************************************************************
//******************************************************************************

#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector = USCI_B0_VECTOR
__interrupt void USCI_B0_ISR(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(USCI_B0_VECTOR))) USCI_B0_ISR (void)
#else
#error Compiler not supported!
#endif
{
  //Must read from UCB0RXBUF
  uint8_t rx_val = 0;
  switch(__even_in_range(UCB0IV, USCI_I2C_UCBIT9IFG))
  {
    case USCI_NONE:          break;         // Vector 0: No interrupts
    case USCI_I2C_UCALIFG:   break;         // Vector 2: ALIFG
    case USCI_I2C_UCNACKIFG:                // Vector 4: NACKIFG
      break;
    case USCI_I2C_UCSTTIFG:  break;         // Vector 6: STTIFG
    case USCI_I2C_UCSTPIFG:  break;         // Vector 8: STPIFG
    case USCI_I2C_UCRXIFG3:  break;         // Vector 10: RXIFG3
    case USCI_I2C_UCTXIFG3:  break;         // Vector 12: TXIFG3
    case USCI_I2C_UCRXIFG2:  break;         // Vector 14: RXIFG2
    case USCI_I2C_UCTXIFG2:  break;         // Vector 16: TXIFG2
    case USCI_I2C_UCRXIFG1:  break;         // Vector 18: RXIFG1
    case USCI_I2C_UCTXIFG1:  break;         // Vector 20: TXIFG1
    case USCI_I2C_UCRXIFG0:                 // Vector 22: RXIFG0
        rx_val = UCB0RXBUF;
        if (RXByteCtr)
        {
          ReceiveBuffer[ReceiveIndex++] = rx_val;
          RXByteCtr--;
        }

        if (RXByteCtr == 1)
        {
          UCB0CTLW0 |= UCTXSTP;
        }
        else if (RXByteCtr == 0)
        {
          UCB0IE &= ~UCRXIE;
          MasterMode = IDLE_MODE;
          __bic_SR_register_on_exit(CPUOFF);      // Exit LPM0
        }
        break;
    case USCI_I2C_UCTXIFG0:                 // Vector 24: TXIFG0
        switch (MasterMode)
        {
          case TX_REG_ADDRESS_MODE:
              UCB0TXBUF = TransmitRegAddr;
              if (RXByteCtr)
                  MasterMode = SWITCH_TO_RX_MODE;   // Need to start receiving now
              else
                  MasterMode = TX_DATA_MODE;        // Continue to transmision with the data in Transmit Buffer
              break;

          case SWITCH_TO_RX_MODE:
              UCB0IE |= UCRXIE;              // Enable RX interrupt
              UCB0IE &= ~UCTXIE;             // Disable TX interrupt
              UCB0CTLW0 &= ~UCTR;            // Switch to receiver
              MasterMode = RX_DATA_MODE;    // State state is to receive data
              UCB0CTLW0 |= UCTXSTT;          // Send repeated start
              if (RXByteCtr == 1)
              {
                  //Must send stop since this is the N-1 byte
                  while((UCB0CTLW0 & UCTXSTT));
                  UCB0CTLW0 |= UCTXSTP;      // Send stop condition
              }
              break;

          case TX_DATA_MODE:
              if (TXByteCtr)
              {
                  UCB0TXBUF = TransmitBuffer[TransmitIndex++];
                  TXByteCtr--;
              }
              else
              {
                  //Done with transmission
                  UCB0CTLW0 |= UCTXSTP;     // Send stop condition
                  MasterMode = IDLE_MODE;
                  UCB0IE &= ~UCTXIE;                       // disable TX interrupt
                  __bic_SR_register_on_exit(CPUOFF);      // Exit LPM0
              }
              break;

          default:
              __no_operation();
              break;
        }
        break;
    default: break;
  }
}

//**********************************uart interrupt****************************
#if defined(__TI_COMPILER_VERSION__) || defined(__IAR_SYSTEMS_ICC__)
#pragma vector=USCI_A0_VECTOR
__interrupt void USCI_A0_ISR(void)
#elif defined(__GNUC__)
void __attribute__ ((interrupt(USCI_A0_VECTOR))) USCI_A0_ISR (void)
#else
#error Compiler not supported!
#endif
{
  switch(__even_in_range(UCA0IV,USCI_UART_UCTXCPTIFG))
  {
    case USCI_NONE: break;
    case USCI_UART_UCRXIFG:
      //RXData = UCA0RXBUF;                   // Read buffer
      //if(RXData != TXData)                  // Check value
     // {
       // P1OUT |= BIT0;                      // If incorrect turn on P1.0
         // while(1);                         // Trap CPU
     // }
     // TXData++;                             // increment data byte
     // __bic_SR_register_on_exit(LPM0_bits); // Exit LPM0 on reti
      break;
    case USCI_UART_UCTXIFG: break;
    case USCI_UART_UCSTTIFG: break;
    case USCI_UART_UCTXCPTIFG: break;
  }
}
//**********************************uart interrupt****************************