MDK-ARM Keil, MDK-ARM Datasheet - Page 44

• Manufacturer Part Number: MDK-ARM
• Description: KIT REALVIEW MCU DEVELOPMENT
• Manufacturer: Keil
• Type: Compiler and IDEr

Specifications of MDK-ARM

• For Use With/related Products: ARM MCUs
• Lead Free Status / RoHS Status: Lead free / RoHS Compliant

44
Chapter 2. Developing With an RTOS
Task Definitions
In the Task Definitions section, we define the basic resources that will be
required by the tasks. For each task, we allocate a default stack space (in the
above example this is 200 bytes). We also define the maximum number of
concurrently running tasks. Thus, the amount of RAM required for the above
example can be calculated easily as 200 x 6 = 1,200 bytes. If some of our tasks
need a larger stack space, they must be started with the os_task create_usr() API
call. If we are defining custom stack sizes, we must define the number of tasks
with custom stacks. Again, the RAM requirement can be calculated easily.
During development, RTX can be set up to trap stack overflows. When this
option is enabled, an overflow of a task stack space will cause the RTX kernel to
call the os_stk_overflow() function that is located in the
file. This
RTX_Config.c
function gets the TASK ID of the running task and then sits in an infinite loop.
The stack checking option is intended for use during debugging and should be
disabled on the final application to minimize the kernel overhead. However, it is
possible to modify the os_stack_overflow() function, if enhanced error protection
is required in the final release.
The final option in the Task Definitions section allows you to define the number
of user timers. It is a common mistake to leave this set at zero. If you do not set
this value to match the number of virtual timers in use by your application, the
os_timer() API calls will fail to work.
For Cortex-based microcontrollers the Task Definitions section has one
additional option. Disabling the “run in privileged mode” tick box allows the
RTOS kernel to run in Handler Mode with privileged access, while the user tasks
run in Thread Mode with unprivileged access. This means that the RTX kernel
has full access to the microcontroller resources and its own stack space while the
application code has limited access to the microcontroller resources. For
example, it cannot access the Cortex interrupt control registers. This can be very
useful for safety critical code where we may need to partition the user task code
from the kernel code.