I'm an 'On Interrupt Goto' newbee too
My understanding is, that although there are many sources of interrupts possible within the PIC's hardware, there is only one resulting interrupt condition. Either the processor has been interrupted or it has not. This leads me to believe that this interrupt condition has to be dealt with by a single interrupt handling routine which tells the interrupted processor what to do.
The interrupt routine, or interrupt handler, in its execution could, of course, determine the source of the interrupt by investigating the various interrupt flags and take specific action appropriate to the source, but there is only one routine and the point in the program (the label) where it is located is stated in the 'ON INTERRUPT GOTO' statement. Having more than one 'ON INTERRUPT GOTO', each with a different label, doesn't make sense to me, as that would mean that the interrupted processor could go to more than one routine to resolve the interrupt. How would it know which to go to ?
The flexibility allowed by MELabs by not predetermining the label in the command just means that you can call your interrupt handler what you like. It doesn't mean that there can be more than one and that they are differentiated by having different labels.
OK.. now to the question! The 'ON INTERRUPT' statement reference on MELabs PIC BASIC Pro support website, clearly states before giving the syntax example, that "More than one ON INTERRUPT may be used in a program"... Is this a typo or have I got it completely wrong?
Brian Walsh
Multiple ON INTERRUPT GOTO's
This example should show how you can use multiple ON INTERRUPTS.
But it's not much use for anything else.
The key thing to remember here, is that the assignments of the Interrupt Handlers only happens at Compile-Time. Attempting to execute an ON INTERRUPT statement at Run-Time to change the handler will not work.
As the program gets compiled, starting from the top, the interrupts are considered DISABLED, and no interrupt checks will be placed between the PBP lines of code.
When it encounters an ON INTERRUPT statement, the status changes to ENABLED, and in between every PBP statement, it will place an Interrupt Check, that jumps to the last assigned Handler.
In the example below, if an interrupt occurs while the program flow is within the Main loop, then the Handler0 will be jumped to.
Then when it encounters the second ON INTERRUPT statement, all lines following that assignment will interrupt to Handler1.
It does not matter if they are subroutines, main routines, or whatever, ANY lines following an ON INTERRUPT will jump to the last known handler (if interrupted).
It really does get tricky, because then each handler must be capable of handling any interrupt, which leads to multiple copies of the same handler or gosubs to common handlers. Or you have to make sure that before switching modes, ONLY the interrupts that the next mode can handle are enabled, I mean SERIOUSLY Tricky!
Just remember, It all happens at Compile-Time.
Code:
Mode VAR BYTE
Mode = 0
ON INTERRUPT GOTO Handler0
Main:
R0 = R0 ; just some stuff to put int checks between
R1 = R1
IF Mode = 1 then DoMode1
IF Mode = 2 then DoMode2
GOTO Main
DISABLE
Handler0:
; Interrupt handler for the Main Loop
RESUME
ENABLE
;--------------------------------------------------------
ON INTERRUPT GOTO Handler1
DoMode1:
; Do Mode 1 tasks here
IF Mode = 0 then Main
IF Mode = 2 then DoMode2
GOTO DoMode1
DISABLE
Handler1:
; Interrupt handler for Mode 1
RESUME
ENABLE
;--------------------------------------------------------
ON INTERRUPT GOTO Handler2
DoMode2:
; Do Mode 2 tasks here
IF Mode = 0 then Main
IF Mode = 1 then DoMode1
GOTO DoMode2
DISABLE
Handler2:
; Interrupt handler for Mode 2
RESUME
ENABLE
hth,
Multiple ON INTERRUPT GOTOs
Thanks Darrel. That's quite an explanation!
Regards,
Brian Walsh.
