FreeRTOS教程——任务（一）

FreeRTOS教程——任务（一）
FreeRTOS教程——定时器（二）
FreeRTOS教程——队列（三）
FreeRTOS教程——二值信号量（四）

概述

任务状态

一个任务可以是以下几种状态中的一种：

• 运行 正在执行的任务就是处于运行状态，它占用了处理器。
• 就绪 就绪的任务是那些可以执行（没有被阻塞或暂停），但是因为其他相同或更高优先级任务正在运行造成还没有运行的任务。
• 阻塞 当一个任务等待临时事件或外部事件时它就是处于阻塞状态。例如，任务调用 vTaskDelay() ，它将被阻塞（置为阻塞状态）直到超过延时时间 – 一个临时事件。任务也可以阻塞等待队列和信号事件。阻塞状态的任务一般有一个超时时间，超时后任务将解锁。阻塞的任务不会参与调度。
• 暂停 暂停状态的任务也不参与调度。任务只有在调用 API 函数 vTaskSuspend() 和 xTaskResume() 时才会进入或者退出暂停状态。它不能指定超时时间。

任务优先级

每个任务将分配一个从 0 到 ( configMAX_PRIORITIES – 1 ) 的优先级。configMAX_PRIORITIES 在文件 FreeRTOSConfig.h 中定义，configMAX_PRIORITIES参数值越大，FreeRTOS 占用的
RAM 就越多。

低优先级任务使用较小的数字，缺省的空闲优先级 tskIDLE_PRIORITY 定义为 0。

调度器保证处于就绪或运行状态的任务分配到处理器时间，高优先级任务先分配。换句话说，处理器时间总是分配给能够运行的最高优先级任务。

执行任务

一个任务有下面的结构形式：

void vATaskFunction( void *pvParameters ) {
  for( ;; ) {
    -- Task application code here.
    --
  }
}

类型 pdTASK_CODE 定义为返回值是 void 的函数，并使用 void 指针作为唯一的参数。所有的任务函数都是这个类型，可以传递任意类型的参数到任务 – 在
任务系统标准演示
中进行了演示。

任务函数应当从不返回，因此它通常执行一个连续的循环，参考 RTOS 的例子。

任务由函数 xTaskCreate() 创建，使用 vTaskDelete() 删除。

单元

• vTaskDelay
• vTaskDelayUntil
• uxTaskPriorityGet
• vTaskPrioritySet
• vTaskSuspend
• vTaskResume
• vTaskResumeFromISR
• vTaskSetApplicationTag
• xTaskCallApplicationTaskHook

xTaskCreate

task. h

 portBASE_TYPE xTaskCreate( 
   pdTASK_CODE pvTaskCode, 
   const portCHAR * const pcName, 
   unsigned portSHORT usStackDepth, 
   void *pvParameters, 
   unsigned portBASE_TYPE uxPriority, 
   xTaskHandle *pvCreatedTask 
 );

创建新的任务并添加到任务队列中，准备运行

Parameters

pvTaskCode	指向任务的入口函数. 任务必须执行并且永不返回 (即：无限循环).
pcName	描述任务的名字。主要便于调试。最大长度由configMAX_TASK_NAME_LEN.定义
usStackDepth	指定任务堆栈的大小 ，堆栈能保护变量的数目- 不是字节数. 例如，如果堆栈为16位宽度，usStackDepth定义为 100, 200 字节，这些将分配给堆栈。堆栈嵌套深度（堆栈宽度）不能超多最大值——包含了size_t类型的变量
pvParameters	指针用于作为一个参数传向创建的任务
uxPriority	任务运行时的优先级
pvCreatedTask	用于传递一个处理——引用创建的任务

返回

pdPASS 是如果任务成功创建并且添加到就绪列中，另外错误代码在projdefs. H文件定义

使用例子

// 创建任务
void vTaskCode( void * pvParameters ){
  for( ;; ){
    // 任务代码
  }
}
// 函数来创建一个任务
void vOtherFunction( void ){
  static unsigned char ucParameterToPass;
  xTaskHandle xHandle;
  // 创建任务，存储处理。注意传递的参数为ucParameterToPass
  //它在任务中不能始终存在, 所以定义为静态变量. 如果它是动态堆栈的变量，可能存在
  // 没有那么长，或者至少随着时间毁灭，
  // 新的时间， 尝试存储它
  xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass, tskIDLE_PRIORITY, &xHandle );
  // 使用句柄来删除任务
  vTaskDelete( xHandle );
}

vTaskDelete

task. h

void vTaskDelete( xTaskHandle pxTask );

INCLUDE_vTaskDelete必须定义为1，这个函数才能可用。查看配置部分获得更多信息。

从RTOS实时内核管理中移除任务。要删除的任务将从就绪，封锁，挂起，事件列表中移除，

注意：空闲任务负责释放内核分配给已删除任务的内存。因此，如果应用程序调用了vTaskDelete ()，微控制器执行时间，空闲任务不假死是很重要的。内存分配给任务的代码不会自动释放，应该在任务删除之前。

参考演示程序death. c 中的例子使用 vTaskDelete ().

参数：

pxTask	处理要删除的任务。传递NULL将引起调用任务删除

Example usage:

void vOtherFunction( void ){
  xTaskHandle xHandle;
  // 创建任务，存储处理
  xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
  // 使用处理来删除任务. 
  vTaskDelete( xHandle );
}

vTaskDelay

task. h

void vTaskDelay( portTickType xTicksToDelay );

INCLUDE_vTaskDelay必须设置为1，这个函数才为可用。参考配置获得更多信息。

延时任务为已知时间片。任务被锁住剩余的实际时间由时间片率决定。portTICK_RATE_MS常量用来用来从时间片速率（一片周期代表着分辨率）来计算实际时间。

vTaskDelay()指定一个任务希望的时间段，这个时间之后（调用vTaskDelay() ）任务解锁。例如，指定周期段为100时间片，将使任务在调用vTaskDelay()100个时间片之后解锁。vTaskDelay()不提供一个控制周期性任务频率的好方法，像通过代码采取的路径，和其他任务和中断一样，在调用vTaskDelay()后 影响频率，因此任务所需的时间下一次执行。

参考

vTaskDelayUntil() ，这个交替的API函数设计了执行固定的频率。它是指定的一个绝对时间（而不是一个相对时间）后，调用任务解锁。

参数:

xTicksToDelay	时间数量，调用任务应该锁住的时间片周期

使用例子:

void vTaskFunction( void * pvParameters ) {
/* 挂起500ms. */
const portTickType xDelay = 500 / portTICK_RATE_MS; 
  for( ;; ) {
    /* 简单的每 500ms触发LED, .在每两次触发间挂起*/ 
    vToggleLED();
    vTaskDelay( xDelay );
  }
}

vTaskSuspend

task.h

void vTaskSuspend( xTaskHandle pxTaskToSuspend );

设置INCLUDE_vTaskSuspend 为1，此函数才能使用。参考配置获得更多信息。

挂起任务。当挂起一个任务时，不管优先级是多少，不需要占用任何微控制器处理器时间。

调用vTaskSuspend不会累积——即：在统一任务中调用vTaskSuspend两次，但只需调用一次vTaskResume () 来是挂起的任务就绪。

参数：

xTaskToSuspend	处理需要挂起的任务。传递NULL将挂起调用此函数的任务。

使用范例：

void vAFunction( void ){
  xTaskHandle xHandle;
  // 创建任务，保存句柄
  xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
  // ...
  // 使用此句柄来挂起创建的任务
  vTaskSuspend( xHandle );
  // ...
  // 创建的任务不会在这期间运行，除非
  // 其他任务调用 vTaskResume( xHandle )
  //...
  // 挂起自己
  vTaskSuspend( NULL );
  // 不能运行到这里，除非另一个任务调用vTaskResume
  // 使用此任务的句柄为参数
}

vTaskResume

task. h

void vTaskResume( xTaskHandle pxTaskToResume );

设置INCLUDE_vTaskSuspend为1，此函数才能使用。参考配置获得更多信息。

唤醒挂起的任务。

必须是调用 vTaskSuspend () 后挂起的任务，才有可能通过调用 vTaskResume ()重新运行。

• Parameters:

  pxTaskToResume 就绪的任务的句柄

使用范例：

 void vAFunction( void )
 {
 xTaskHandle xHandle;

// 创建任务，保存句柄
xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );

// ...

// 使用此句柄来挂起创建的任务
vTaskSuspend( xHandle );

// ...

// 创建的任务不会在此期间运行，除
// 另外一个任务调用 vTaskResume( xHandle )

//...

// 唤醒自己
vTaskResume( xHandle );

// 创建的任务将按照它在系统中的优先级
// 再次获得微处理器的处理时间
 }

综合实例

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "timer.h"
#include "key.h"
#include "exti.h"
#include "FreeRTOS.h"
#include "task.h"
#include "beep.h"
/*
key_up键按下，任务1挂起，key1键按下，任务1恢复运行，key2键按下，任务2挂起，
*/
//任务优先级
#define START_TASK_PRIO		1
//任务堆栈大小	
#define START_STK_SIZE 		128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);

//任务优先级
#define KEY_TASK_PRIO		2
//任务堆栈大小	
#define KEY_STK_SIZE 		128  
//任务句柄
TaskHandle_t KeyTask_Handler;
//任务函数
void key_task(void *pvParameters);

//任务优先级
#define TASK1_TASK_PRIO		3
//任务堆栈大小	
#define TASK1_STK_SIZE 		128  
//任务句柄
TaskHandle_t Task1Task_Handler;
//任务函数
void task1_task(void *pvParameters);

TaskHandle_t Task2Task_Handler;
TaskHandle_t Task3Task_Handler;
void task2_task(void *pvParameters);
void task3_task(void *pvParameters);


int main(void)
{
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4	 
	delay_init();	    				//延时函数初始化	 
	uart_init(115200);					//初始化串口
	LED_Init();		  					//初始化LED
	KEY_Init();							//初始化按键
	EXTIX_Init();						//初始化外部中断
	BEEP_Init();         	//初始化蜂鸣器端口

	//创建开始任务
    xTaskCreate((TaskFunction_t )start_task,            //任务函数
                (const char*    )"start_task",          //任务名称
                (uint16_t       )START_STK_SIZE,        //任务堆栈大小
                (void*          )NULL,                  //传递给任务函数的参数
                (UBaseType_t    )START_TASK_PRIO,       //任务优先级
                (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    vTaskStartScheduler();          //开启任务调度
}

//开始任务任务函数
void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();           //进入临界区
	//创建KEY任务
	xTaskCreate((TaskFunction_t )key_task,             
                (const char*    )"key_task",           
                (uint16_t       )KEY_STK_SIZE,        
                (void*          )NULL,                  
                (UBaseType_t    )KEY_TASK_PRIO,        
                (TaskHandle_t*  )&KeyTask_Handler);  
    //创建TASK1任务
    xTaskCreate((TaskFunction_t )task1_task,             
                (const char*    )"task1_task",           
                (uint16_t       )TASK1_STK_SIZE,        
                (void*          )NULL,                  
                (UBaseType_t    )TASK1_TASK_PRIO,        
                (TaskHandle_t*  )&Task1Task_Handler);   
    //创建TASK2任务
    xTaskCreate((TaskFunction_t )task2_task,     
                (const char*    )"task1_task",   
                (uint16_t       )TASK1_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK1_TASK_PRIO,
                (TaskHandle_t*  )&Task2Task_Handler); 
		//创建TASK3任务
    xTaskCreate((TaskFunction_t )task3_task,     
                (const char*    )"task3_task",   
                (uint16_t       )TASK1_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK1_TASK_PRIO,
                (TaskHandle_t*  )&Task3Task_Handler); 
    vTaskDelete(StartTask_Handler); //删除开始任务
    taskEXIT_CRITICAL();            //退出临界区
}

//key任务函数
void key_task(void *pvParameters)
{
	u8 key;
	while(1)
	{
		
		key=KEY_Scan(0);
		switch(key)
		{
			case KEY0_PRES:
				vTaskSuspend(Task1Task_Handler);//挂起任务1
				printf("挂起任务1的运行!\r\n");
				break;	
			case KEY1_PRES:
				vTaskSuspend(Task2Task_Handler);//挂起任务2
				printf("挂起任务2的运行!\r\n");
				break;
			case KEY2_PRES:
				vTaskSuspend(Task3Task_Handler);//挂起任务3
				printf("挂起任务3的运行!\r\n");
				break;
			case WKUP_PRES:
				vTaskResume(Task1Task_Handler);	//恢复任务1
				vTaskResume(Task2Task_Handler);	//恢复任务1
				vTaskResume(Task3Task_Handler);	//恢复任务1
				printf("恢复所有任务的运行!\r\n");
		}
		vTaskDelay(10);			//延时10ms 
	}
}



//task1任务函数
void task1_task(void *pvParameters)
{
	u8 task1_num=0;
	while(1)
	{
		task1_num++;
		printf("任务1已经执行：%d次\r\n",task1_num);
    vTaskDelay(1000);                          
	}
}

//task2任务函数
void task2_task(void *pvParameters)
{
	u8 task2_num=0;
	while(1)
	{
		task2_num++;
		printf("任务2已经执行：%d次\r\n",task2_num);
    vTaskDelay(1000);                         
	}
}
void task3_task(void *pvParameters)
{
	u8 task3_num=0;
	while(1)
	{
		task3_num++;
		printf("任务3已经执行：%d次\r\n",task3_num);
    vTaskDelay(1000);                         
	}
}