CCS/MSP432P401R: BMI160 I2C read/write functions

Thanks for your reply Fredrick!

I think one thing is missing in my code: the acknowledgment bit. How can I check the this bit in my code after I sent a byte to the slave?

Thanks

Saber  

For receiving and sending data with I2C protocol, I have defined two functions for I2C write and read. The chip I am working it, BMI160, accepts data on I2C bus like what is defined in below:

For I2C read access:

I have configured the read/write functions like below:

1- The I2C configuration:

/* Select Port 1 for I2C - Set Pin 6, 7 to input Primary Module Function,
	     *   (UCB0SIMO/UCB0SDA, UCB0SOMI/UCB0SCL).
	     */
	    P1->SEL0 |= BIT6+BIT7;
	    //MAP_GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P1,
	    //        GPIO_PIN6 + GPIO_PIN7, GPIO_PRIMARY_MODULE_FUNCTION);

	    stopSent = false;

	    /* Initializing I2C Master to SMCLK at 100khz with no autostop */
	    MAP_I2C_initMaster(EUSCI_B0_BASE, &i2cConfig);

	    /* Specify slave address */
	    MAP_I2C_setSlaveAddress(EUSCI_B0_BASE, BMI160_I2C_ADDR);

	    /* Set Master in transmit mode */
	     MAP_I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_MODE);

	     /* Enable I2C Module to start operations */
	     MAP_I2C_enableModule(EUSCI_B0_BASE);

	     /* Enable and clear the interrupt flag */
	     MAP_I2C_clearInterruptFlag(EUSCI_B0_BASE,
	             EUSCI_B_I2C_TRANSMIT_INTERRUPT0 + EUSCI_B_I2C_RECEIVE_INTERRUPT0);

	     //Enable master Receive interrupt
	     MAP_I2C_enableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_INTERRUPT0);


	 //    MAP_Interrupt_enableSleepOnIsrExit();

	     /* Enable master transmit interrupt */
	     MAP_I2C_enableInterrupt(EUSCI_B0_BASE,
	             EUSCI_B_I2C_TRANSMIT_INTERRUPT0 + EUSCI_B_I2C_NAK_INTERRUPT);
	     MAP_Interrupt_enableInterrupt(INT_EUSCIB0); /* EUSCIB0 IRQ */

2- I2C write function:

int8_t user_i2c_write(uint8_t dev_id, uint8_t reg_addr, uint8_t *reg_data, uint16_t len)
{
    int8_t rslt = BMI160_OK; /* Return 0 for Success, non-zero for failure */

    /* Transmit interrupt comes from i2c write function*/
    readModule = 0;

    /* Load Byte Counter */
    TXByteCtr = len;

    /* Making sure the last transaction has been completely sent out */
    while (MAP_I2C_masterIsStopSent(EUSCI_B0_BASE) == EUSCI_B_I2C_SENDING_STOP);

    /* Set Master in transmit mode */
     MAP_I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_MODE);

    /* Sending the initial start condition *///And register address.
    MAP_I2C_masterSendMultiByteStart(EUSCI_B0_BASE, reg_addr);

    while(TRANSMITFLAG);

    TRANSMITFLAG=1;

   // MAP_Interrupt_enableSleepOnIsrExit();
   // MAP_PCM_gotoLPM0InterruptSafe();
    return rslt;
}

3- I2C read function:

int8_t user_i2c_read(uint8_t dev_id, uint8_t reg_addr, uint8_t *reg_data, uint16_t len)
    {
    int8_t rslt = BMI160_OK; /* Return 0 for Success, non-zero for failure */

    /* Transmit interrupt comes from i2c read function*/
    readModule = 1;

   /*Number of bytes to be received*/
    NUM_OF_REC_BYTES = len;
    MAP_I2C_enableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);

   /* Making sure the last transaction has been completely sent out */
   while (MAP_I2C_masterIsStopSent(EUSCI_B0_BASE) == EUSCI_B_I2C_SENDING_STOP);

     /* Send start and the first byte of the transmit buffer. We have to send
      * two bytes to clean out whatever is in the buffer from a previous
      * send  */
     //MAP_I2C_masterSendMultiByteStart(EUSCI_B0_BASE,reg_addr);
     MAP_I2C_masterSendMultiByteNext(EUSCI_B0_BASE, reg_addr);


     /* Enabling transfer interrupt after stop has been sent */
     MAP_I2C_enableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_INTERRUPT0);

     /* While the stop condition hasn't been sent out... */
     while(!stopSent)
     {
     //    MAP_PCM_gotoLPM0InterruptSafe();
     }

     stopSent = false;
     return rslt;
    }

4- And finally, the I2C interrupt handler is like:

void EUSCIB0_IRQHandler(void)
{
    uint_fast16_t status;

       status = MAP_I2C_getEnabledInterruptStatus(EUSCI_B0_BASE);
       MAP_I2C_clearInterruptFlag(EUSCI_B0_BASE, status);

       if (status & EUSCI_B_I2C_NAK_INTERRUPT)
          {
              MAP_I2C_masterSendStart(EUSCI_B0_BASE);
          }
       /* If we reached the transmit interrupt, it means we are at index 1 of
           * the transmit buffer. When doing a repeated start, before we reach the
           * last byte we will need to change the mode to receive mode, set the start
           * condition send bit, and then load the final byte into the TXBUF.
           */
          if (status & EUSCI_B_I2C_TRANSMIT_INTERRUPT0)
          {c1++;
              if(readModule)
              {
           //   MAP_I2C_masterSendMultiByteNext(EUSCI_B1_BASE, TXData[1]);/////?????
              MAP_I2C_disableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_INTERRUPT0);

              MAP_I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_MODE);
              xferIndex = 0;
              MAP_I2C_masterReceiveStart(EUSCI_B0_BASE);
              MAP_I2C_enableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
              }
              else
              {
               /* Check the byte counter */
                      if (TXByteCtr)
                      {
                          /* Send the next data and decrement the byte counter */
                          MAP_I2C_masterSendMultiByteNext(EUSCI_B0_BASE, *reg_data);
                          TXByteCtr--;
                          reg_data++;
                      }
                      else
                      {
                          MAP_I2C_masterSendMultiByteStop(EUSCI_B0_BASE);
                        //  MAP_Interrupt_disableSleepOnIsrExit();
                          TRANSMITFLAG=0;
                      }
              }
          }

          /* Receives bytes into the receive buffer. If we have received all bytes,
           * send a STOP condition */
          if (status & EUSCI_B_I2C_RECEIVE_INTERRUPT0)
          {c2++;

              if(xferIndex == NUM_OF_REC_BYTES - 2)
              {
                  MAP_I2C_masterReceiveMultiByteStop(EUSCI_B0_BASE);
                  *reg_data = MAP_I2C_masterReceiveMultiByteNext(EUSCI_B0_BASE);
                  reg_data++;
                  xferIndex++;
              }
              else if(xferIndex == NUM_OF_REC_BYTES - 1)
              {
                  *reg_data = MAP_I2C_masterReceiveMultiByteNext(EUSCI_B0_BASE);
                  xferIndex++;
                  reg_data++;
                  MAP_I2C_masterReceiveMultiByteStop(EUSCI_B0_BASE);
                  MAP_I2C_disableInterrupt(EUSCI_B0_BASE, EUSCI_B_I2C_RECEIVE_INTERRUPT0);
                  MAP_I2C_setMode(EUSCI_B0_BASE, EUSCI_B_I2C_TRANSMIT_MODE);
                  xferIndex = 0;
                  stopSent = true;
             //     MAP_Interrupt_disableSleepOnIsrExit();
              }
              else
              {
                  *reg_data = MAP_I2C_masterReceiveMultiByteNext(EUSCI_B0_BASE);
                  xferIndex++;
                  reg_data++;
              }

          }
}

The code get stuck in 

 while(!stopSent)
     {
     //    MAP_PCM_gotoLPM0InterruptSafe();
     }

     stopSent = false;

It seems the module never go to the interrupt vector.

Do you have any idea where the problem is?

Thanks

Saber