QDK PIC24/dsPIC-C30 - Quantum Leaps

QDK
PIC24/dsPIC-C30
www.state-machine.com/pic
4.4.2 Task Preemption Test
The next interesting test is verifying that tasks can preempt each other. You set a breakpoint anywhere in
the Philosopher state machine code. You run the application until the breakpoint is hit. After this
happens, you remove the original breakpoint and place another breakpoint at the very next machine
instruction (use the Disassembly window). You also place a breakpoint inside the _INT0Interrupt()
interrupt handler and on the first instruction at the first instruction of the QK_schedule_() function. Next
you trigger the INT0 interrupt per the instructions given earlier. You hit the Run button.
The pass criteria of this test are as follows:
1. The first breakpoint hit is the one inside the _INT0Interrupt() function, which means that INT0 ISR
preempted the Philospher task.
2. The second breakpoint hit is the one in QK_schedule_() function, which means that the QK
scheduler is activated before the control returns to the preempted Philosopher task.
3. After hitting the breakpoint in QK_schedule_() function, you must first disable the Timer2 interrupts
by clearing bit #7 in the IEC0 register at address 0x0094, in the “File Registers” window, in the similar
way as you set the bit #0 in the IFS0 register to trigger INT0.
4. Next, you single step into the QK_schedule_(). (NOTE: you might want to close the “File Registers”
window to speed up the single stepping.) You verify that the scheduler invokes a state handler of the
Table state machine. This proves that the Table task preempts the Philosopher task.
5. After this you free-run the application and verify that the next breakpoint hit is the one inside the
Philosopher state machine. This validates that the preempted task continues executing only after
the preempting task (the Table state machine) completes.
4.4.3 Other Tests
Other interesting tests that you can perform include changing priority of the INT0 ISR to be lower than the
priority of Timer2 ISR to verify that the QK scheduler is still called only after all interrupts complete.
In yet another test you could post an event to Philosopher active object rather than Table active object
from the INT0 ISR to verify that the QK scheduler will not preempt the Philosopher task by itself. Rather
the extra event will be queued and the Philosopher task will process the queued event only after
completing the current event processing.
Copyright © Quantum Leaps, LLC. All Rights Reserved.
25 of 35