Lab 5

Lab 5: Maestro RTX

Prep:

Build RTX Tiny operating system (kernel). Here are the steps you need to follow to build and use the kernel:
1. Create a new project and add all of the assembly files (.a51) in this ZIP file to it.
2. Under options for target->output, enable "create library" instead of "create executable".
3. Edit the conf_tny.a51 file to configure the operating system for:
  - The tick and round-robin time slice that you want
  - The register bank that operating system uses (its 1 by default, which is fine)
  - how much stack space you reserve for tasks: Make it big enough for the worst case stack size for all tasks.
  - An assembly routine that the OS will run if the stack runs out of the room...no need to change this either.
  - oh....and you have to change the first line of the file to $DEBUG. I don't know why!!
4. Compile the kernel...you should get a file called <projectname>.lib. Move this file to d:\keil\c51\lib\rtx51tny.lib. This file will be used by the linker when you compile your user program. If that doesn't work, try naming it RTX51.LIB
Compile and link a user program with the RTX Tiny Kernel library you just built:
1. Under options for target->target, set operating system to RTX-51 Tiny
2. In your source file, include <rtx51tny.h>.
3. The kernel uses timer 0. There is no need to use any other timers for this assignment. I don't recommend using the other timers for this assignment because the debugger doesn't seem to support Timer 1 or Timer 2. Just use the debugger to simulate interrupts (I think external interrupts simulate correctly).
4. You should have no main, everything should happen in a task or in an ISR.
5. The debugger has lots of good tools for using the kernel. One of the best is View->Periodic Window Update so that you can see variables changing while the simulator is running. You can also get a list of tasks and status. Also, you can look at RAM in the memory window, look at timer status and change timer 0 values to cause context switch whenever you want.

Do the Following:

qWhy does Tiny limit the user tasks to Reg Bank 0?
Write a program using Tiny OS that causes a context switch to occur with a fair amount of data (calls) on the stack (least two threads). Then use the simulator to trigger an interrupt.
determine the latency to the start of the interrupt routine
Are interrupts disabled for the entire context switch process? if so then explain the experiment you did to prove this…otherwise
How is it possible to allow interrupts during context switch? Make sure your interrupt routine also has some subroutine calls so that you can see what happens to the stack.
If one thread signals another thread, then executes a wait before the end of the OS timeslice, does the signaled thread start running immediately or only at the beginning of the next timeslice?
Turn in answers to the questions along with your test code. Include clear explanations for how you arrived at your answers.
The Keil debugger has many utilities to help you: Dissassembler, memory window, timer window for timer 0, elapsed time in machine cycles and seconds, etc. The debugger has lots of good tools for using the kernel. One of the best is View->Periodic Window Update so that you can see variables changing while the simulator is running. You can also get a list of tasks and status. Also, you can look at RAM in the memory window, look at timer status and change timer 0 values to cause context switch whenever you want
Turn in clearly explained incontrovertible proof of your answers.