• State Resolved
  • Locked Locked
  • Replies 13 replies
  • Subscribers 80 subscribers
  • Views 10345 views
  • Users 0 members are here
Support feedback
Options
Options
Related

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

MSP432P401R: Launchpad S2 GPIO Interrupt Bug

Nicholas Kimball91
Prodigy 210 points

Part Number: MSP432P401R

I am trying to write some simple code to turn an on-board LED on and off using the two switches on the Launchpad. However, as soon as I enable interrupts on Port 1 Pin 4, the interrupt flag is raised. This pin is connected to Switch 2 on the Launchpad which is normally open and connects the pin to GND when it is closed. I started doing some experimenting and this also happens when I enable interrupts on Port 1 Pin 5 which is not connected to any button. I've played around with several different configurations and I simply cannot figure out why the interrupt is occurring as soon as I enable it. Port 1 Pin 1 has the exact same register and switch configuration and does not behave in this way.

I initially wrote the code using TI's driverlib for the MSP432 and then wrote it a second time by just setting the register value. Both pieces of code had the same problem.

I have tried both rising edge triggering with the pin configured as input with pulldown and falling edge interrupt triggering with the pin configured as input with a pullup and both have the same issue. I know on MSP430s, you have to clear the interrupt as the register initializes to the flag being set. However, the P1IFG register initializes to all the flags not asserted.

Here is the code:

void main(void)
{
    WDT_A->CTL = WDT_A_CTL_PW | WDT_A_CTL_HOLD;     // stop watchdog timer

    /* S1 */
    GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN1);

    /* S2 */
    GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN4);

    /* Red LED */
    GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);
    GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);

    GPIO_interruptEdgeSelect(GPIO_PORT_P1, GPIO_PIN1, GPIO_HIGH_TO_LOW_TRANSITION);
    GPIO_interruptEdgeSelect(GPIO_PORT_P1, GPIO_PIN4, GPIO_HIGH_TO_LOW_TRANSITION);

    // Upper 3 bits control hardware priority, lower 7 bits control sub-priority
    Interrupt_setPriority(INT_PORT1, 0xC0);

    GPIO_registerInterrupt(GPIO_PORT_P1, inputIRQHandler);

    interrupts = GPIO_getEnabledInterruptStatus(GPIO_PORT_P1);

    GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN1);
    GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN4);

    /* Register Level Code
    P1->SEL0 &= ~BIT4;
    P1->SEL1 &= ~BIT4;
    P1->DIR  &= ~BIT4;
    P1->OUT |= BIT4;
    P1->REN |= BIT4;
    P1->IES |= BIT4;
    P1->IE  |= BIT4;
    */

    Interrupt_enableMaster();

    while(1);
}

void inputIRQHandler(void)
{
    uint_fast16_t interrupts;

    interrupts = GPIO_getEnabledInterruptStatus(GPIO_PORT_P1);

    if (interrupts & GPIO_PIN1)
    {
        GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN1);
        GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
    }

    if (interrupts & GPIO_PIN4)
    {
        GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN4);
        GPIO_setOutputHighOnPin(GPIO_PORT_P1, GPIO_PIN0);
    }
}

Any thoughts?

  • 0
    TI__Genius 14165 points
    Hi Nicholas,

    I know you wrote it in your last statement but cannot see it in your code so can you please clear all the GPIO IFGs before you enable the interrupt you use to ensure no previous event triggered the flag which will immediatly trigger your ISR after you enabled the interrupt?

    P1->IFG &= ~BIT4;
    or
    GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN4);

    Best regards,
    Dietmar
  • 0 in reply to Dietmar Walther
    TI__Mastermind 25045 points
    Hello Nicholas,

    Did Dietmar suggestion fix your problem.

    Thanks,

    David
  • 0 in reply to Dietmar Walther
    Prodigy 210 points

    Here is my code now:

    #include <stdint.h>

/* MSP432 driverlib includes */
#include <ti/devices/msp432p4xx/driverlib/gpio.h>
#include <ti/devices/msp432p4xx/driverlib/interrupt.h>

void inputIRQHandler(void)
{
    uint_fast16_t interrupts;

    interrupts = GPIO_getEnabledInterruptStatus(GPIO_PORT_P1);

    if (interrupts & GPIO_PIN1)
    {
        GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN1);
        GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
    }

    if (interrupts & GPIO_PIN4)
    {
        GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN4);
        GPIO_setOutputHighOnPin(GPIO_PORT_P1, GPIO_PIN0);
    }
}

void main(void)
{
    uint_fast16_t interrupts;

    WDT_A->CTL = WDT_A_CTL_PW | WDT_A_CTL_HOLD;     // stop watchdog timer

    Interrupt_disableMaster();

    /* S1 */
    GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN1);

    /* S2 */
    GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN4);


    /* Red LED */
    GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);
    GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);

    GPIO_interruptEdgeSelect(GPIO_PORT_P1, GPIO_PIN1, GPIO_HIGH_TO_LOW_TRANSITION);
    GPIO_interruptEdgeSelect(GPIO_PORT_P1, GPIO_PIN4, GPIO_HIGH_TO_LOW_TRANSITION);

    // Upper 3 bits control hardware priority, lower 7 bits control sub-priority
    //Interrupt_setPriority(INT_PORT1, 0xC0);

    GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN1);
    GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN1);
    GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN4);
    GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN4);

    GPIO_registerInterrupt(GPIO_PORT_P1, inputIRQHandler);

    interrupts = GPIO_getEnabledInterruptStatus(GPIO_PORT_P1);

    Interrupt_enableMaster();

    interrupts = GPIO_getEnabledInterruptStatus(GPIO_PORT_P1);

    while(1);
}

    I found out the master interrupt is enabled by default so I disabled it before doing all the setup and reenabled it at the end of setup. I check the GPIO Interrupt Status both before and after enabling master interrupts. Both times shows no interrupts flags asserted, however the ISR is still entered once. However, because the ISR logic checks the GPIO Interrupt flags (which are still all unasserted), the ISR does nothing.

    When I comment out the code that clears the GPIO interrupt flags, the function which returns their status shows that the interrupt associated with P1.4 is asserted. It seems like the interrupt is somehow latched in the NVIC as soon as I enable it. Is this even possible? I'm 99% sure this isn't some sort of problem with the button as P1.1 has exactly the same configuration and does not exhibit this problem. I tried setting up all the pins on port 1 the same way as P1.1 and P1.4 and only P1.5 (which is a floating pin) also exhibited this strange behavior of asserting the interrupt as soon as it was enabled. 

    Any thoughts?

  • 0 in reply to Nicholas Kimball91
    Prodigy 210 points

    I used the CMSIS function NVIC_GetPendingIRQ(PORT1_IRQn) to check the status of the Port 1 interrupt in the NVIC. Before I enabled the P1.4 interrupt, the function returns 0. Afterwards, it returns 1. Therefore, enabling the interrupt is somehow causing the NVIC Port 1 interrupt to be asserted. How could this happen?

    This code seems to fix it, but I shouldn't have to clear a specific pin interrupt in order to have it behave properly. I would like to understand exactly what is going on to cause this specific pin interrupt to be automatically asserted when I enable it.

    #include <stdint.h>

/* MSP432 driverlib includes */
#include <ti/devices/msp432p4xx/driverlib/gpio.h>
#include <ti/devices/msp432p4xx/driverlib/interrupt.h>

void inputIRQHandler(void)
{
    uint_fast16_t interrupts;

    interrupts = GPIO_getEnabledInterruptStatus(GPIO_PORT_P1);

    if (interrupts & GPIO_PIN1)
    {
        GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN1);
        GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);
    }

    if (interrupts & GPIO_PIN4)
    {
        GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN4);
        GPIO_setOutputHighOnPin(GPIO_PORT_P1, GPIO_PIN0);
    }
}

void main(void)
{
    uint_fast16_t interrupts;

    WDT_A->CTL = WDT_A_CTL_PW | WDT_A_CTL_HOLD;     // stop watchdog timer

    Interrupt_disableMaster();

    /* S1 */
    GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN1);

    /* S2 */
    GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN4);


    /* Red LED */
    GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);
    GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);

    GPIO_interruptEdgeSelect(GPIO_PORT_P1, GPIO_PIN1, GPIO_HIGH_TO_LOW_TRANSITION);
    GPIO_interruptEdgeSelect(GPIO_PORT_P1, GPIO_PIN4, GPIO_HIGH_TO_LOW_TRANSITION);

    // Upper 3 bits control hardware priority, lower 7 bits control sub-priority
    //Interrupt_setPriority(INT_PORT1, 0xC0);

    GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN1);
    GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN1);
    GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN4);
    GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN4);

    NVIC_ClearPendingIRQ(PORT1_IRQn);

    GPIO_registerInterrupt(GPIO_PORT_P1, inputIRQHandler);

    Interrupt_enableMaster();

    while(1);
}

  • 0 in reply to Nicholas Kimball91
    TI__Genius 14165 points

    Hi Nicholas,

    can you please tell me which Launchpad version you used (maybe send a picture). Also please let me know the marking of the chip so I know what DIE revision you have assembled.

    I will set up a launch pad v1.9 with a RevC device and will try the MSP432 SDK - v:1.40.01.00 example "gpio_input_interrupt" example utalizing the DriverLib.

    Once I have results I will come back to you.

    Best regards,
    Dietmar

  • 0 in reply to Dietmar Walther
    TI__Genius 14165 points
    Nicholas,

    I used the code below and it works as expected. The LED turns only on if S1 or S2 is pressed. The LED does not turn without pressing anything.
    Do you have a 2nd launch pad you can try maybe you chip is damaged. Also please try the code below.

    * MSP432 GPIO - Input Interrupt
    *
    * Description: This example demonstrates a very simple use case of the
    * DriverLib GPIO APIs. P1.1 (which has a switch connected to it) is configured
    * as an input with interrupts enabled and P1.0 (which has an LED connected)
    * is configured as an output. When the switch is pressed, the LED output
    * is toggled.
    *
    * MSP432P401
    * ------------------
    * /|\| |
    * | | |
    * --|RST P1.0 |---> P1.0 LED
    * | |
    * | P1.1 |<--Toggle Switch
    * | |
    * | |
    *
    ******************************************************************************/
    /* DriverLib Includes */
    #include <ti/devices/msp432p4xx/driverlib/driverlib.h>

    /* Standard Includes */
    #include <stdint.h>
    #include <stdbool.h>

    int main(void)
    {
    volatile uint32_t ii;

    /* Halting the Watchdog */
    MAP_WDT_A_holdTimer();

    /* Configuring P1.0 as output and P1.1 (switch) as input */
    MAP_GPIO_setAsOutputPin(GPIO_PORT_P1, GPIO_PIN0);
    GPIO_setOutputLowOnPin(GPIO_PORT_P1, GPIO_PIN0);

    /* Configuring P1.1 as an input and enabling interrupts */
    MAP_GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN1);
    MAP_GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN1);
    MAP_GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN1);

    /* Configuring P1.4 as an input and enabling interrupts */
    MAP_GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN4);
    MAP_GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN4);
    MAP_GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN4);
    MAP_Interrupt_enableInterrupt(INT_PORT1);

    /* Enabling SRAM Bank Retention */
    MAP_SysCtl_enableSRAMBankRetention(SYSCTL_SRAM_BANK1);

    /* Enabling MASTER interrupts */
    MAP_Interrupt_enableMaster();

    /* Going to LPM3 */
    while (1)
    {
    MAP_PCM_gotoLPM3();
    }
    }

    /* GPIO ISR */
    void PORT1_IRQHandler(void)
    {
    uint32_t status;

    status = MAP_GPIO_getEnabledInterruptStatus(GPIO_PORT_P1);


    /* Toggling the output on the LED */
    if(status & GPIO_PIN1)
    {
    MAP_GPIO_clearInterruptFlag(GPIO_PORT_P1, status);
    MAP_GPIO_toggleOutputOnPin(GPIO_PORT_P1, GPIO_PIN0);
    }


    if (status & GPIO_PIN4)

    {
    MAP_GPIO_clearInterruptFlag(GPIO_PORT_P1, status);
    MAP_GPIO_toggleOutputOnPin(GPIO_PORT_P1, GPIO_PIN0);
    }


    }
  • 0 in reply to Dietmar Walther
    Prodigy 210 points

    Try setting a breakpoint in the ISR and see if it enters it. The code I posted functionally works but unexpectedly enters the ISR for no apparent reason.

  • 0 in reply to Nicholas Kimball91
    TI__Genius 14165 points

    Nicholas,

    for sure I also tried it with breakpoints as well but once I let the program run via the debugger it will not enter the ISR.

    First time it enters the ISR is when I press one of the 2 buttons.

    Again can you please tell me which version of the launchpad you use and which device? Maybe there is a difference.

    Best regards,
    Dietmar

  • 0 in reply to Dietmar Walther
    Prodigy 210 points

    I am using the MSP-EXP432P401R Rev 2.1 Launchpad

  • 0 in reply to Nicholas Kimball91
    TI__Genius 14165 points
    Nicholas, thanks I will try to get version 2.1 trying to reproduce it because with my version 1.9 I don't see it.
    Will keep you posted once I have results.
  • 0 in reply to Dietmar Walther
    TI__Genius 14165 points
    Nicholas,

    luckily I got a brand new v2.1 Launchpad with a Rev C assembled. I tried the code I posted above and set the breakpoint inside ISR before I run the project with my CCSv7 environment but was not able to see that the ISR is executed without pressing a button.

    Can you please update to the latest Driver Lib (same version I used) and try again. Otherwise I would assume that something on your launch pad was damaged. Do you use this according ESD handling guidelines in an ESD safe environment?
    You do not have 2nd launchpad for correlation right?

    Best regards,
    Dietmar
  • 0 in reply to Dietmar Walther
    Prodigy 210 points

    I figured it out. I was clearing the interrupt flag directly after enabling the interrupt instead of directly before it. I changed

    GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN4);
GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN4);

    to

    GPIO_clearInterruptFlag(GPIO_PORT_P1, GPIO_PIN4);
GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN4);

     and it worked...Just goes to show you cant necessarily trust the register's default values. Sorry for the non-issue. I know you suggested this earlier but I didn't realize that my flag clear was happening after the interrupt enable which essentially defeats the purpose of clearing the flag. I'm still not sure why only GPIO interrupts on pins 4 and 5 were being asserted automatically, but I guess that's besides the point...Thanks for the help!

  • 0 in reply to Nicholas Kimball91
    TI__Genius 14165 points
    Nicholas,

    nice to hear that it worked when using the right coding. The reason why only some GPIOs shows it is random. Non initialized bits can up the one or the other way depends on device to device variations. There it is important to take care on all GPIO setting especially the unused ones to prevent unexpected high current due to floating inputs and also unexpected functional behavior.
    Good luck with your future development!

**Attention** This is a public forum