Difference between revisions of "RTOS Basics : TASK"

Revision as of 18:08, 14 April 2015

Amruta (talk) 13:41, 8 April 2015 (IST)

Intro

In RTOS implementation of a design, the program is divided into different independent functions what we call as a task. These functions are not called anywhere in the program, they are just created. Each tasks runs continuously i.e. in infinite loop.

The kernel is responsible for the management of all the tasks. Check this tutorial to know working of kernel and task scheduling.

Different states of a task

In the FreeRTOS a task can be in either of four different states viz., Running, Ready, Blocked and Suspended.

Lets see each state one by one.

Running

The task which is executing currently is said to be in running state. It owns the CPU.

Ready

The task which is neither suspended nor blocked but still not executing will be ready state. Its not in running state because either a high priority or equal priority task is executing.

Blocked

A task will go in blocked state whenever its waiting for a event to happen. The event can be completing a delay period or availability of a resource. The blocked tasks are not available for scheduling.

Suspended

When vTaskSuspend() is called, the task goes in suspended state. To resume it, xTaskResume() is called. The suspended tasks are also not available for scheduling.

It seems that the tasks in both Blocked and Suspended are in waiting state.

But the difference is, a suspended task can't come in Ready state unless xTaskResume() is called. Time out period can be specified only for Blocked tasks but not for suspended tasks.

Deciding Priority of a task

One general rule to decide the task priority is RMS ( Rate Monotonic Scheduling ). According to this rule, the most frequently executed task is given highest priority.

In FreeRTOS, higher is the priority number, higher is the task priority. FreeRTOS also always you to have multiple tasks with same priority. In that case it executes the task with same priority in time slice manner.

API Details

Here we will discuss some of the mostly frequently used APIs related to task.

Task Create function

Defination	portBASE_TYPE xTaskCreate ( pdTASK_CODE pvTaskCode, const portCHAR * const pcName, unsigned portSHORT usStackDepth, void pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle pvCreatedTask);
Input Arguments	pdTASK_CODE : Pointer to the task entry function const portCHAR * : A descriptive name for the task. It is a character pointer and is mainly used for debugging. unsigned portSHORT : The stack size of the task in terms of number of variables not the number of bytes void* : void pointer which will be used as the parameter for the task unsigned portBASE_TYPE : The task priority xTaskHandle* : Used to pass back a handle using which the task can be referenced
Return Value	Returns TRUE on successful creation of task and adding it to ready list FALSE otherwise.
Description	It creates a task and adds it to ready list.
Usage	xTaskHandle TaskHandle_1; static void MyTask1(void* pvParameters); xTaskCreate( MyTask1, ( signed char * )"Task1", configMINIMAL_STACK_SIZE, NULL, 1, &TaskHandle_1 );

Task Delay Function

Defination	void vTaskDelay( portTickType xTicksToDelay )
Input Arguments	portTickType : Number of ticks for which task is to be delayed.
Return Value	None
Description	It delays the calling task for specified number of ticks. Set the macro INCLUDE_vTaskDelay to use this API. Use the constant portTICK_RATE_MS in the file portmacro.h to calculate real time delay. Its resolution is one tick period.
Usage	vTaskDelay(100);

Task Delete Function

Defination	void vTaskDelete( xTaskHandle pxTask )
Input Arguments	xTaskHandle : handle to the task to be deleted. Pass NULL to suspend calling task
Return Value	None
Description	It removes the specified task from the RTOS real time kernels management. But it does not frees the memory allocated by the task code. Set the macro INCLUDE_vTaskDelete to use this API.
Usage	vTaskDelete(TaskHandle_1);

Task Suspend Function

Defination	void vTaskSuspend( xTaskHandle pxTaskToSuspend );
Input Arguments	xTaskHandle : handle to the task to be suspended. Pass NULL to suspend calling task
Return Value	None
Description	It suspends the specified task Set INCLUDE_vTaskSuspend to use this API.
Usage	vTaskSuspend(TaskHandle_1);

Task Resume Function

Defination	void vTaskResume( xTaskHandle pxTaskToSuspend );
Input Arguments	xTaskHandle : handle to the task to be resumed. Pass NULL to suspend the calling task.
Return Value	None
Description	It resumes the specified task Set INCLUDE_vTaskSuspend to use this API.
Usage	vTaskResume(TaskHandle_1);

@@ Line 19: / Line 19: @@
 *Ready
-::The task which is neither suspended nor blocked but still not executing will be ready state.
+::The task which is neither suspended nor blocked but still not executing will be ready state. Its not in running state because either a high priority or equal priority task is executing.
-Its not in running state because either a high priority or equal priority task is executing.
 *Blocked
-::A task will go in blocked state whenever its waiting for a event to happen.
+::A task will go in blocked state whenever its waiting for a event to happen. The event can be completing a delay period or availability of a resource. The blocked tasks are not available for scheduling.
-The event can be completing a delay period or availability of a resource.
-The blocked tasks are not available for scheduling.
 *Suspended
-::When vTaskSuspend() is called, the task goes in suspended state. To resume it, xTaskResume() is called.
+::When vTaskSuspend() is called, the task goes in suspended state. To resume it, xTaskResume() is called. The suspended tasks are also not available for scheduling.
-The suspended tasks are also not available for scheduling.
 ::It seems that the tasks in both Blocked and Suspended are in waiting state.