MSPM0G3507: UART interrupt fail to start with a certain probability (approximately 1/10 probability)

Short answer: In your DL_init function, some time before the NVIC_ClearPendingIRQ call, insert something resembling:

> (void)DL_UART_Main_receiveData(UART_2_INST); // Read and throw away (and clear status)

Longer answer: I was able to produce your symptom by clearing the UART IRQ while it was Pending. The peripheral (MIS) indicated the Rx interrupt, but the NVIC didn't know about it, and subsequently since the RIS bit was already set the UART didn't issue a new IRQ to the NVIC (aka "stuck").

TRM (SLAU846C) section 3.3.1.1 (subsection "Setting and Clearing Pending Interrupt Status") appears to describe "Level" behavior for peripheral IRQs, but at least in this case (UART RX) the result seems consistent with "Pulse" behavior -- once the Pending state is cleared, it will not be re-issued.

You could encounter this case if a byte were being received when you called your DL_init, and completed some time before the ClearPendingIRQ. (The floating point arithmetic probably expands the window here.)

The usual workaround would be to explicitly clear the RX interrupt bit (RIS) before enabling it. But what I observed was that, while the receiver continued to operate, the RX interrupt still would not be raised (result: the RXDATA quietly overruns). This is presumably because the RXDATA hadn't been read.

The step that finally cleared things up was to read the RXDATA register (in my case, I used OVRERR to do this). This also has the effect of clearing the RX interrupt bit. So I'm suggesting you just do this arbitrarily when you enable the interrupt.

This test program contrives to clear every 4th RX interrupt while it's Pending (in the NVIC). Typing into a terminal emulator, every 4th/5th byte is not echoed -- the first because the IRQ was cleared, and the second due to the OVRERR. But the OVRERR code clears the condition, and things go back to normal.

The .c file:

/*
 * This started life as the uart_echo_interrupts_standby example
 */
#include "ti_msp_dl_config.h"
volatile uint32_t ctr;
volatile uint8_t gEchoData = 0;
int main(void)
{
    SYSCFG_DL_init();
    DL_UART_Main_enableInterrupt(UART_0_INST,
                              DL_UART_MAIN_INTERRUPT_OVERRUN_ERROR |
                                 DL_UART_MAIN_INTERRUPT_RX);

    NVIC_ClearPendingIRQ(UART_0_INST_INT_IRQN);
    NVIC_EnableIRQ(UART_0_INST_INT_IRQN);
    
    while (1) {
        __disable_irq(); // hold it off
        __WFI();
        asm volatile(" nop ");   // Breakpoint here
        ++ctr;
        if ((ctr & 0x03) == 0)
        {
            // Every 4th byte:
            DL_UART_clearInterruptStatus(UART_0_INST, DL_UART_INTERRUPT_RX );
            NVIC_ClearPendingIRQ(UART_0_INST_INT_IRQN);
        }
        __enable_irq(); // let it run
        asm volatile(" nop ");   // Keep the compiler from unrolling
    }
}

void UART_0_INST_IRQHandler(void)
{
    asm volatile(" nop "); // breakpoint here
    switch (DL_UART_Main_getPendingInterrupt(UART_0_INST)) {
        case DL_UART_MAIN_IIDX_RX:
            DL_GPIO_togglePins(GPIO_LEDS_PORT,
                GPIO_LEDS_USER_LED_1_PIN | GPIO_LEDS_USER_TEST_PIN);
            gEchoData = DL_UART_Main_receiveData(UART_0_INST);
            DL_UART_Main_transmitData(UART_0_INST, gEchoData);
            //DL_UART_clearInterruptStatus(UART_0_INST, DL_UART_INTERRUPT_RX );
            break;
        case DL_UART_IIDX_OVERRUN_ERROR:
            gEchoData = DL_UART_Main_receiveData(UART_0_INST);
            break;
        default:
            break;
    }
}

.syscfg:

/**
 * These arguments were used when this file was generated. They will be automatically applied on subsequent loads
 * via the GUI or CLI. Run CLI with '--help' for additional information on how to override these arguments.
 * @cliArgs --device "MSPM0G350X" --part "Default" --package "LQFP-64(PM)" --product "mspm0_sdk@2.07.00.06"
 * @v2CliArgs --device "MSPM0G3507" --package "LQFP-64(PM)" --product "mspm0_sdk@2.07.00.06"
 * @versions {"tool":"1.25.0+4268"}
 */

/**
 * Import the modules used in this configuration.
 */
const GPIO   = scripting.addModule("/ti/driverlib/GPIO", {}, false);
const GPIO1  = GPIO.addInstance();
const SYSCTL = scripting.addModule("/ti/driverlib/SYSCTL");
const UART   = scripting.addModule("/ti/driverlib/UART", {}, false);
const UART1  = UART.addInstance();

/**
 * Write custom configuration values to the imported modules.
 */
GPIO1.$name                          = "GPIO_LEDS";
GPIO1.associatedPins.create(2);
GPIO1.associatedPins[0].$name        = "USER_LED_1";
GPIO1.associatedPins[0].assignedPort = "PORTA";
GPIO1.associatedPins[0].initialValue = "SET";
GPIO1.associatedPins[0].assignedPin  = "0";
GPIO1.associatedPins[0].pin.$assign  = "PA0";
GPIO1.associatedPins[1].$name        = "USER_TEST";
GPIO1.associatedPins[1].assignedPort = "PORTA";
GPIO1.associatedPins[1].assignedPin  = "15";
GPIO1.associatedPins[1].initialValue = "SET";

const Board           = scripting.addModule("/ti/driverlib/Board", {}, false);
Board.configureUnused = true;

SYSCTL.forceDefaultClkConfig = true;
SYSCTL.clockTreeEn           = true;

UART1.$name                    = "UART_0";
UART1.rxFifoThreshold          = "DL_UART_RX_FIFO_LEVEL_ONE_ENTRY";
UART1.enableDMARX              = false;
UART1.enableDMATX              = false;
UART1.targetBaudRate           = 115200;
UART1.enabledInterrupts        = ["OVERRUN_ERROR","RX"];
UART1.peripheral.$assign       = "UART0";
UART1.peripheral.rxPin.$assign = "PA11";
UART1.peripheral.txPin.$assign = "PA10";
UART1.txPinConfig.$name        = "ti_driverlib_gpio_GPIOPinGeneric0";
UART1.rxPinConfig.$name        = "ti_driverlib_gpio_GPIOPinGeneric1";

/**
 * Pinmux solution for unlocked pins/peripherals. This ensures that minor changes to the automatic solver in a future
 * version of the tool will not impact the pinmux you originally saw.  These lines can be completely deleted in order to
 * re-solve from scratch.
 */
GPIO1.associatedPins[1].pin.$suggestSolution = "PA15";
Board.peripheral.$suggestSolution            = "DEBUGSS";
Board.peripheral.swclkPin.$suggestSolution   = "PA20";
Board.peripheral.swdioPin.$suggestSolution   = "PA19";