Temporarily disable timer interrupt

Question

I'm working on an embedded project in C on a stm32f4xx uC.

I have a portion of a code that does an loop-operation XYZ continuously, and from time to time a TIM4 interrupt changes some global parameters and causes the operation XYZ to restart.

code is something like this:

for (;;) {
       //line A
    XYZ;
       //line B
}

XYZ is a complex operation involving tranfers of data between buffers and others.

The TIM4 interrupt handler does this: stops XYZ & changes some globals that afect XYZ operations.

So basically I want XYZ to execute repeatedly and TIM4 interrupt to stop XYZ, change the parameters and then the loop must restart by restarting XYZ with the new global parameters.

PROBLEM IS: Since XYZ has many instructions, TIM4 IRQ may come right in the middle of it and, after the IRQHandler changes the globals, the operations resume from the middle of XYZ which ruins the program.

MY INITIAL SOLUTION: Disable interrupts on line A with __disable_irq() and restore them on line B with __enable_irq()

Fails because the XYZ complex operation must use other interrupts (other than TIM4).

NEXT SOLUTION Disable only TIM4 interrupt on line A with:

TIM_ITConfig(TIM4, TIM_IT_Update , DISABLE)

and enable it back on line B with:

TIM_ITConfig(TIM4, TIM_IT_Update , ENABLE)

Fails because I am losing the interrupt: when the int is restored, the interrupt that arrived during XYZ is ignored. This is a big problem (one of the reasons is that TIM4 IRQHandler changes the globals and then activates the TIM4 again to give an interrupt later, I do this because the period between interrupts varies).

Can anyone give me a solution to this problem? Is there a better way to disable/restore TIM4 IRQ and NOT lose any interrupt?

For what reason does XYZ need to stop processing? Is it because its data is invalid due to the interrupt overwriting info, or because it is actually desired to stop XYZ whenever a new interrupt comes in? If it's just due to data overwriting, in the ISR you could copy data into a temporary and set a flag, then in the main loop use the flag to know when to operate on the new data... — Ross

embedded.kyle embedded.kyle · Accepted Answer · 2012-12-11T13:37:55

You could operate on a copy of the global variables and swap in the new value from the interrupt once you're done with XYZ.

It's not clear from the question whether you need to stop processing of XYZ immediately when the globals change, or if you can wait till XYZ finishes processing to swap in new copies of the variables. I'll operate under the assumption that you need to break out of processing XYZ but it's easy enough to not.

Code would look something like this:

volatile int x;
int x_prime;

int main(void)
{
    while(1)
    {
        //copy in new global parameter value
        x_prime = x;

        while(1)
        {
            //do stuff with x_prime
            if (x_prime != x)
            {
                break;
            }

            //do more stuff with x_prime
            if (x_prime != x)
            {
                break;
            }
        }
    }
}

// interrupt handler
void TIM_IT_Update(void)
{
    x++;
}

The break patterns assume that you're not changing x_prime. If you need to modify x_prime, you'll need another copy.

Since the interrupt is never disabled, you never have to worry about losing any of them. And since you're operating on a copy of the parameters changed by the interrupt, it doesn't matter if the interrupt changes the parameters in the middle of execution because you're not looking at those values until you make copies.

Temporarily disable timer interrupt

5 Answers