MSP430F5502: MSP430 I2C does not ack correctly during a multi-byte read operation

Kevin Lannen

Part Number: MSP430F5502

Hi,

I seem to be having a similar issue to what a.h. was seeing in this thread:

I am reading several values repeatedly from a BNO055 and occasionally the MSP430 does not send an ack, and just starts repeatedly sending clock data. I am not seeing any issues to relate this to voltage drop however.

I am reading these at 20 Hz and I see a failure every few minutes. Is there a known workaround for this bug? It was my understanding that nothing needs to be done in receive mode to trigger sending of the ack. Is this correct?

Here is the transaction that is failing:

Here it is more zoomed in on the failed byte:

Here is the same transaction when it is successful:

And zoomed in on one of the bytes:

I have attached my i2c code.

7268.i2c_driver.c

#include "i2c_driver.h"
#include "Boards/hal.h"
#include "driverlib.h"

#ifdef I2C_USCI_INT_VECTOR

volatile bool i2cTransactionInProgress = false;
const uint8_t* i2cTxBuffer;
uint8_t* i2cRxBuffer;
volatile unsigned int writeLength;
volatile unsigned int readLength;
volatile bool* statusFlag;

void initI2C(void)
{
    GPIO_setAsPeripheralModuleFunctionInputPin(I2C_PORT, I2C_SCL);
    GPIO_setAsPeripheralModuleFunctionInputPin(I2C_PORT, I2C_SDA);

    USCI_B_I2C_initMasterParam i2cParams = {0};

    i2cParams.dataRate = USCI_B_I2C_SET_DATA_RATE_400KBPS;
    i2cParams.i2cClk = UCS_getSMCLK();
    i2cParams.selectClockSource = USCI_B_I2C_CLOCKSOURCE_SMCLK;

    USCI_B_I2C_initMaster(I2C_USCI_MODULE, &i2cParams);
    USCI_B_I2C_enableInterrupt(I2C_USCI_MODULE, USCI_B_I2C_NAK_INTERRUPT);
}

bool isI2CBusy(void) { return i2cTransactionInProgress; }

int startI2CReadTransaction(uint8_t* receiveBuffer, uint8_t slaveAddress,
                            uint8_t regAddress, unsigned int length,
                            volatile bool* completedFlag)
{
    if (isI2CBusy())
    {
        return -1;
    }
    i2cTransactionInProgress = true;
    statusFlag = completedFlag;

    *statusFlag = false;

    readLength = length;
    i2cRxBuffer = receiveBuffer;

    USCI_B_I2C_setSlaveAddress(I2C_USCI_MODULE, slaveAddress);
    USCI_B_I2C_setMode(I2C_USCI_MODULE, USCI_B_I2C_TRANSMIT_MODE);
    USCI_B_I2C_enable(I2C_USCI_MODULE);
    USCI_B_I2C_disableInterrupt(I2C_USCI_MODULE, USCI_B_I2C_TRANSMIT_INTERRUPT);
    USCI_B_I2C_clearInterrupt(I2C_USCI_MODULE, USCI_B_I2C_TRANSMIT_INTERRUPT);

    USCI_B_I2C_masterSendMultiByteStart(I2C_USCI_MODULE, regAddress);

    // Wait for transmit flag to be set
    while (!USCI_B_I2C_getInterruptStatus(I2C_USCI_MODULE,
                                          USCI_B_I2C_TRANSMIT_INTERRUPT))
    {
    }

    USCI_B_I2C_masterReceiveMultiByteStart(I2C_USCI_MODULE);

    USCI_B_I2C_enableInterrupt(I2C_USCI_MODULE, USCI_B_I2C_RECEIVE_INTERRUPT);
    return 0;
}

int startI2CWriteTransaction(const uint8_t* transmitBuffer,
                             uint8_t slaveAddress, uint8_t regAddress,
                             unsigned int length)
{
    if (isI2CBusy())
    {
        return -1;
    }

    i2cTransactionInProgress = true;

    i2cTxBuffer = transmitBuffer;
    writeLength = length;

    USCI_B_I2C_setSlaveAddress(I2C_USCI_MODULE, slaveAddress);
    USCI_B_I2C_setMode(I2C_USCI_MODULE, USCI_B_I2C_TRANSMIT_MODE);
    USCI_B_I2C_enable(I2C_USCI_MODULE);

    // Enable interrupts here and handle the rest of the transaction using them
    // to free up the processor for other tasks
    USCI_B_I2C_clearInterrupt(I2C_USCI_MODULE, USCI_B_I2C_TRANSMIT_INTERRUPT);
    USCI_B_I2C_enableInterrupt(I2C_USCI_MODULE, USCI_B_I2C_TRANSMIT_INTERRUPT);

    // This function sends a start command, polls the TX IFG, and then writes
    // the byte to the TX register
    USCI_B_I2C_masterSendMultiByteStart(I2C_USCI_MODULE, regAddress);
    return 0;
}

int I2CBlockingWriteTransaction(const uint8_t* transmitBuffer,
                                uint8_t slaveAddress, uint8_t regAddress,
                                unsigned int length)
{
    int rv;
    rv = startI2CWriteTransaction(transmitBuffer, slaveAddress, regAddress,
                                  length);
    while (isI2CBusy())
    {
    }
    return rv;
}

bool i2cISR(uint16_t usciModule, int ucbIv)
{
    switch (ucbIv)
    {
    case 0x02: // Arbitration Lost
        break;
    case 0x04: // Nack
        // A NAK was received from a slave device
        // TODO: We probably should handle NAKs somehow, KJL
        USCI_B_I2C_masterSendMultiByteStop(usciModule);
        i2cTransactionInProgress = false;
        break;
    case 0x06: // Start
        // Should not get here since the START interrupt is disabled and
        // for slaves only
        break;
    case 0x08: // Stop
        // Should not get here since the STOP interrupt is disabled and
        // for slaves only
        break;
    case 0x0A: // Data Received
        // Received data is ready to be read from UCBxRXBUF into the recieve
        // buffer

        // Send a stop command if the last byte is in the RX buffer
        if (readLength == 1)
        {
            USCI_B_I2C_masterReceiveMultiByteStop(usciModule);
        }
        *i2cRxBuffer = USCI_B_I2C_masterReceiveMultiByteNext(usciModule);
        i2cRxBuffer++;
        readLength--;
        if (readLength == 0)
        {
            i2cTransactionInProgress = false;
            *statusFlag = true;
            return true;
        }
        break;
    case 0x0C: // TX Buffer Empty
        // The I2C bus is ready to transmit data written into the UCBxTXBUF
        if (writeLength == 0) // There is no data left to be written
        {
            USCI_B_I2C_masterSendMultiByteStop(usciModule);
            i2cTransactionInProgress = false;
            return true;
        }
        else
        {
            USCI_B_I2C_masterSendMultiByteNext(usciModule, *i2cTxBuffer);
            writeLength--;
            i2cTxBuffer++;
        }
        break;
    }
    return false; // stay in LPM
}
#endif

usci_interrupts.c

#include "Boards/hal.h"
#include "SerialCommunications/spi.h"
#include "driverlib.h"
#include "i2c_driver.h"

#ifndef VS_CODE
#pragma vector = USCI_B1_VECTOR
__interrupt void USCI_B1_ISR(void)
#else
void USCI_B1_ISR(void)
#endif
{
#ifdef I2C_USCI_INT_VECTOR
    if (UCB1CTL0 & UCMODE_3 == UCMODE_3)
    {
        // USCI module is in I2C Mode
        if (i2cISR(USCI_B1_BASE, UCB1IV))
        {
            __bic_SR_register_on_exit(LPM0_bits);
        }
    }
    else
    {
        // USCI module is in SPI mode
        if (spiISR(USCI_B1_BASE, UCB1IV))
        {
            __bic_SR_register_on_exit(LPM0_bits);
        }
    }
#else
    if (spiISR(USCI_B1_BASE, UCB1IV))
    {
        __bic_SR_register_on_exit(LPM0_bits);
    }
#endif
}

#ifndef VS_CODE
#pragma vector = USCI_A1_VECTOR
__interrupt void USCI_A1_ISR(void)
#else
void USCI_A1_ISR(void)
#endif
{
    // USCI module is in SPI mode
    if (spiISR(USCI_A1_BASE, UCA1IV))
    {
        __bic_SR_register_on_exit(LPM0_bits);
    }
}

#ifdef MPU

#ifndef VS_CODE
#pragma vector = USCI_B0_VECTOR
__interrupt void USCI_B0_ISR(void)
#else
void USCI_B0_ISR(void)
#endif
{
#ifdef I2C_USCI_INT_VECTOR
    if (UCB1CTL0 & UCMODE_3 == UCMODE_3)
    {
        // USCI module is in I2C Mode
        if (i2cISR(USCI_B0_BASE, UCB0IV))
        {
            __bic_SR_register_on_exit(LPM0_bits);
        }
    }
    else
    {
        // USCI module is in SPI mode
        if (spiISR(USCI_B0_BASE, UCB0IV))
        {
            __bic_SR_register_on_exit(LPM0_bits);
        }
    }
#else
    if (spiISR(USCI_B0_BASE, UCB0IV))
    {
        __bic_SR_register_on_exit(LPM0_bits);
    }
#endif
}

#ifndef VS_CODE
#pragma vector = USCI_A0_VECTOR
__interrupt void USCI_A0_ISR(void)
#else
void USCI_A0_ISR(void)
#endif
{
    // USCI module is in SPI mode
    if (spiISR(USCI_A0_BASE, UCA0IV))
    {
        __bic_SR_register_on_exit(LPM0_bits);
    }
}
#endif

over 5 years ago

0 Xiaodong LI over 5 years ago

TI__Mastermind 20035 points

I propose you can try the MSP430F55xx_usci_i2c_standard_master.c on F5502 register level peripheral code example: dev.ti.com/.../
I think it is helpful to debug and isolate the issue in case of using the register level code example

0 Kevin Lannen over 5 years ago in reply to Xiaodong LI

Intellectual 370 points

Hi Xiaodong,

It would require me to rewrite the entire driver I have to try and replicate this issue. I am trying to figure out what condition would even lead to this since if you reference the post I linked, this is totally undefined behavior for the USCI module and I could not find any mention of this in the errata sheet.

Regards,

Kevin

0 Clemens Ladisch over 5 years ago in reply to Kevin Lannen

Guru 244290 points

The USCI master delays the ACK until RXBUF is read.

In theory, it should not be possible to continue to read the next byte without the ACK, but maybe some wrong register field is set. Please show your code.

0 Kevin Lannen over 5 years ago in reply to Clemens Ladisch

Intellectual 370 points

Hi Clemens, my code is posted on the first post.

I agree it should not ack until the RXBUF is read and that matches the diagram in the users guide:

However, that does not explain why it continues to run the clock after the missed ack. I have paused execution after this occurs in the debugger and the RXIF is never set.

Regards,

Kevin

0 Xiaodong LI over 5 years ago in reply to Kevin Lannen

TI__Mastermind 20035 points

Hi Kevin
SCL is yellow waveform and SDA is green waveform. right? Could you please comment the baud rate of I2C and if there is the pull-up resistance on SCL and SDA?

0 Kevin Lannen over 5 years ago in reply to Xiaodong LI

Intellectual 370 points

Hi Xiaodong,

Yes, SCL is yellow and SDA is green. This is a 400kBaud with 10k Ohm pullups to 3.3V on the lines.

0 Xiaodong LI over 5 years ago in reply to Kevin Lannen

TI__Mastermind 20035 points

Hi Kevin, on the communication between MSP430 and BNO055, MSP is the master. is it correct? Have you ever reduced the pullup resistance because the baud rate is up to 400kHz

0 Xiaodong LI over 5 years ago in reply to Xiaodong LI

TI__Mastermind 20035 points

Hi Kevin, I am sorry that this thread will be time-out. I will close this thread. if your question is not solved. Please post another thread or reply under this post.

0 Kevin Lannen over 5 years ago in reply to Xiaodong LI

Intellectual 370 points

Hi Xiaodong,

I tried reducing the pullup resistance to 5.1k but I was still seeing the errrors. Looking at the scope captures the waveform looks pretty good even with the 10k resistors and I would prefer to have the lower power consumption.

Regards,

Kevin

0 Xiaodong LI over 5 years ago in reply to Kevin Lannen

TI__Mastermind 20035 points

Hi Kevin, Thanks for your reply. We have reviewed the hardware setting. I will discuss with the other experts to find the approach on your question

0 Xiaodong LI over 5 years ago in reply to Xiaodong LI

TI__Mastermind 20035 points

Hi Kevin, I checked the code you attached, but I haven't found the code accessing MCU USCI RX buffer. Please comment which API is this function?

0 Kevin Lannen over 5 years ago in reply to Xiaodong LI

Intellectual 370 points

Hi Xiaodong,

The read is handled in the isr routine which is at line 151 of the i2c_driver.c file. USCI_B_I2C_masterReceiveMultiByteNext(usciModule);

Regards,

0 Xiaodong LI over 5 years ago in reply to Kevin Lannen

TI__Mastermind 20035 points

Hi Kevin
Sorry to reply late! I can't find the cause of this issue from your code and setting we have discussed in this thread. I need time to prepare the board and try to reproduce the issue. if you are using EV board from TI, could you please provide the board P/N? Thanks!

0 Xiaodong LI over 4 years ago in reply to Xiaodong LI

TI__Mastermind 20035 points

Hi Kevin
I haven’t heard from you on the TI board P/N of MSP430 and BNO055 for 2 weeks, so I’m assuming you were able to resolve your issue. If this isn’t the case, please click the "This did NOT resolve my issue" button and reply to this thread with more information. If this thread locks, please click the "Ask a related question" button and in the new thread describe the current status of your issue and any additional details you may have to assist us in helping to solve your issues.

**Attention** This is a public forum

MSP low-power microcontrollers

MSP low-power microcontroller forum

MSP430F5502: MSP430 I2C does not ack correctly during a multi-byte read operation