Postponing an interrupt execution.

[Peter]

Hi all.

Am wondering if there is an easy way of postponing an execution of interrupt. Let's say I have a code being executed in a loop of main subroutine:

do sth1
do sth2
do sth3
do sth4

but I want do sth2 and do sth3 couldn't be stopped by any coming interrupts, e.g. timer. On the other hand, I don't want to miss any interrupts, just delay them for a short moment, if they happen when executing do sth 2 and do sth3.

E.g.
do sth1
{block and queue int_rttc}
do sth2
do sth3
{unblock and execute int_rttc from queue}
do sth4

Is sth like this viable? Any suggestions on how to approach this?

Regards,
Peter.

[libor]

It works per se.
When you disable an interrupt the interrupt flag still continues being set, and when you reenable that interrupt, the ISR gets (postponedly) called if the flag has been set already before (during the time it was disabled.) if you don't clear it. You can though only queue one interrupt per type.

[Peter.]

Erm, I know, am wondering whether this would do or not. What happens, if there's a flag signalized, rttc int is enabled again, rttc int subroutine executes (may take long) and meantime another rttc interrupt happens b/c of the previous delay? Am taking they won't queue. Will they?

Cheers,
P.

[Ttelmah]

No, there is no 'stack' for the interrupt flags themselves.
However you can improve the behaviour. The default behaviour, is that the interrupt is cleared automatically by the compiler, when the handler routine _exits_.
Instead, use the 'noclear' declaration, and either:

[libor]

What happens, if there's a flag signalized, rttc int is enabled again, rttc int subroutine executes

a well-behaved isr first clears the interrupt flag, making it able to receive another interrupt signal during the time it executes. Than when it returns to normal program execution it sees the flag set again and executes a second time (so they do kinda 'queue' one level deep)
an isr should not take a long time (you will be still miss interrupts if more than two arrive). so you should move all long-taking operations to the main code using your own queuing (task-scheduling, flagging) technique if you wish (your own queue can be of any depth)

[rnielsen]

If your interrupt is not time sensitive you could simply set a flag, in the interrupt, and then check, inside of main(), to see if the flag has been set. Call whatever routine you need to and clear the flag.

Ronald