MSP432P401R: Interrupt Latching

Thanks for taking the time to reply, Bob! I'd perused that section of the manual, but had assumed that clearing the second port line's IE bit, even once the second line's IFG bit was set, would prevent the second interrupt from being taken..... You seem to be saying that the manual has to be taken very literally, and that the IE bit is irrelevant in this situation, only the IFG flag is important? That's not what I expected, but I must admit it does appear to be what I'm seeing.....

Best wishes,
John

I was sufficiently surprised by this result that I had to try it.

Bob is (as usual) correct, though I would instead reference SLAU356H sec 2.2.2.1-2 (which appears to be adapted from ARM's DUI0553A sec 4.2.9). I always supposed that, due to the intervention of the IV, the GPIO presented a Level interrupt, but apparently it is a Pulse directly from the IFG+IE.

This Useless Little Program lights both Launchpad LEDs, where for a Level interrupt I would expect only one to light. The debugger confirms that on the second ISR call P1IE.4=0 and P1IV=0 (and yet Here We Are).

/**
 * main.c
 * This brainless example demonstrates that the GPIO system
 * presents a Pulse rather than a Level interrupt to the NVIC.
 * Pushing the P1.1 Launchpad button results in both LEDs being lit,
 * where for a Level interrupt we would expect only one to light.
 * Stopping in the second ISR call shows (P1IFG&P1IE) == 0, IV=0.
 */
#include "msp.h"
void main(void)
{
	WDT_A->CTL = WDT_A_CTL_PW | WDT_A_CTL_HOLD;		// stop watchdog timer
	//  LEDs:
    P1->OUT &= ~BIT0;        // Launchpad P1.0 LED off
    P1->DIR |= BIT0;         //    +output
    P2->OUT &= ~BIT0;        // Launchpad P2.0 LED
    P2->DIR |= BIT0;
    //  Buttons:
    P1->OUT |= BIT1|BIT4;    // Launchpad buttons
    P1->REN |= BIT1|BIT4;    //   pullup
    P1->IES |= BIT1|BIT4;    // High->Low
    __no_operation();        // Per PORT32
    P1->IFG &= ~(BIT1|BIT4); // Clear stale
    P1->IE  |= BIT1|BIT4;
    NVIC_EnableIRQ(PORT1_IRQn);
	while (1)
	{
	    __WFI();
	}
	/*NOTREACHED*/
	return;
}

void
PORT1_IRQHandler(void)
{
    if (P1->IFG & BIT1)             // I pushed the (P1.1) button
    {
        __delay_cycles(50000);      // Cheap imitation debounce
        P1->IFG &= ~BIT1;           // I guess it's quiet now
        P1->IFG |= BIT4;            // Trigger P1.4 interrupt
        __delay_cycles(50);         // Just in case of propagation race
        P1->IE  &= ~BIT4;           // Now disable it
        P1->OUT |= BIT0;            // Light LED to show we got here
    }
    else if (P1->IFG & BIT4)        // I Promise I didn't push the (P1.4) button
    {
        P1->IFG &= ~BIT4;           // Thank you, now go away
        P2->OUT |= BIT0;            // Light LED to show we got here
    }
    return;
}

In case anyone's wondering (I suddenly did): The MSP430 behaves the other way. I translated that program for (in this case) the MSP430FR2433, and only one of the LEDs lights (there is no second ISR call):

/**
 * main.c
 * This brainless example demonstrates that the MSP430(FR2433) GPIO system
 * presents something more like a Level interrupt to the interrupt controller.
 * Pushing the P2.3 Launchpad button results in only one LED being lit.
 * (There is no second ISR call.)
 */
#include "msp430.h"         // MSP430FR2433, but mostly its Launchpad
void main(void)
{
    WDTCTL = WDTPW | WDTHOLD;    // Stop watchdog timer
    //  LEDs:
    P1OUT &= ~BIT0;         // Launchpad P1.0 LED off
    P1DIR |= BIT0;          //    +output
    P1OUT &= ~BIT1;         // Launchpad P1.1 LED off
    P1DIR |= BIT1;          //    +output
    //  Buttons:
    P2OUT |= BIT3|BIT7;     // Launchpad buttons
    P2REN |= BIT3|BIT7;     //   pullup
    P2IES |= BIT3|BIT7;     // High->Low
    __no_operation();       // Per PORT32
    PM5CTL0 &= ~LOCKLPM5;   // Should be OK now
    P2IFG &= ~(BIT3|BIT7);  // Clear stale
    P2IE  |= BIT3|BIT7;     // Enable
    _EINT();
    P1OUT |= BIT0|BIT1;     // Make sure both LEDs work.
    __delay_cycles(500000); // About a half second
    P1OUT &= ~(BIT0|BIT1);  // End of that exercise
    while (1)
    {
        LPM0;
    }
    /*NOTREACHED*/
    return;
}

#pragma vector=PORT2_VECTOR
__interrupt void
PORT2_IRQHandler(void)
{
    if (P2IFG & BIT3)             // I pushed the (P2.3) button
    {
        __delay_cycles(50000);    // Cheap imitation debounce
        P2IFG &= ~BIT3;           // I guess it's quiet now
        P2IFG |= BIT7;            // Trigger P2.7 interrupt
        __delay_cycles(50);       // Just in case of propagation race
        P2IE  &= ~BIT7;           // Now disable it
        P1OUT |= BIT0;            // Light LED to show we got here
    }
    else if (P2IFG & BIT7)        // I Promise I didn't push the (P2.7) button
    {
        P2IFG &= ~BIT7;           // Thank you, now go away
        P1OUT |= BIT1;            // Light LED to show we got here
    }
    return;
}