PIC: Global variable not modified inside interrupt handler

Question

I have an interrupt handler for my PIC 16 that should modify a global variable. The global variable is then read by main() in an infinite loop.

For some reason, it seems that the global variable is being modified inside the interrupt handler, but that the modifications do not persist out of the interrupt handler. I am sure that:

• The interrupt handler is being called properly
• The handler modifies the global variable inside the handler
• The code in main() that reads the global variable is correct

Finally, I have been careful to declare the global variable as volatile as recommended here.

What could explain that the global variable change in the interrupt handler does not persist to main()?

[Note: My C code is compiled by XC8. Below is the full code of my reduced test case.]

#include <pic16f1824.h>
#include <xc.h>

volatile unsigned char buttonPress = 0b0;

void interrupt InterruptServiceRoutine(void) {
    // Update the button press value
    buttonPress = 0b1;
}

void main(void) {
    // Make RA4 an output
    TRISAbits.TRISA4 = 0b0;

    // Turn off status LED
    LATAbits.LATA4 = 0b0;

    // Enable interrupts
    INTCONbits.GIE = 0b1;

    // Enable interrupt-on-change to wake from sleep
    INTCONbits.IOCIE = 0b1;

    // Make the RA2 pin a digital input
    TRISAbits.TRISA2 = 0b1;
    ANSELAbits.ANSA2 = 0b0;

    // Interrupt on RA2 negedges
    IOCANbits.IOCAN2 = 0b1;

    while(1) {
        if(buttonPress == 0b1) {
            // Turn on LED <-- Never turns on
            LATAbits.LATA4 = 0b1;
        }
    }
}

Answer 1

Now that more code is available, here's my theory:

The interrupt flag does not seem to be reset, so the interrupt gets called over and over after the first time, therefore the code in the main loop never progresses.

Answer 2

Have you identified the global variable as a volatile?

To ensure that the compiler does not optimize out any variable updates expected to be done within an interrupt handler, the variable declaration must be thus:

volatile unsigned int theVariableThatTheIsrChanges;

---

Edit to original question invalidates above solution. Other possible issues:

• Global variable is not in scope within ISR: This should throw an error, but some compilers and compile flags have automatic declaration of undeclared variables on first access, making such bugs notoriously difficult to track down.
• Disable all compiler optimizations for debugging: It is possible that for some reason the compiler does not see the actual variable update, and thus optimizes that code out of existence.
• The LED does turn on, but for too short a duration: button_debounce() code is not in listing, not sure how it behaves. Try changing the code to use booleans, and set the variable on a positive return from button_debounce, and never resetting it (OR the return value) for debugging - the LED should now turn on but never turn off.

More possibilities:

• initialize_stuff() has some error causing ISR to never be set up
• ISR is not being called at all
• Interrupt has not been enabled
• The while() loop is blocking interrupts (why?)
• Interrupt flag is not being reset, hence next interrupt never gets generated

---

Final update: The last point above was the solution.