FreeRTOS的任务挂起和恢复很简单，分为两种情况，一种是普通的挂起恢复，一种是在中断中恢复：
普通的挂起和恢复：
普通挂起：
调用：vTaskSuspend(TaskHandle_t xTaskToSuspend);函数；
参数为：需要挂起的任务的任务句柄，如果在任务自身中挂起自身，参数可直接写为“NULL””
普通恢复：
调用：vTaskResume(TaskHandle_t xTaskToResume);函数；
参数为：需要恢复的任务的任务句柄，这里参数就不能再写NULL了，因为恢复任务不可能在任务自身中完成，它都挂起了，什么都不再运行了还怎么调用的了恢复函数…
中断中的挂起和恢复：
中断挂起：
挂起任务还是跟普通的情况一样，不管在哪里调用一下挂起任务，对应任务就挂起了。
中断恢复：
中断中的恢复就不一样了，这里面任务有个优先级问题，先讲下中断中的任务恢复函数：xTaskResumeFromISR(TaskHandle_t xTaskToResume);，同样的，参数为需要恢复的任务的任务句柄。
另外，重点：
这个函数有一个返回值，返回值类型为“BaseType_t”，FreeRTOS中有两个宏定义：pdFALSE和pdTRUE。
pdTRUE：恢复运行的任务的优先级 >= 正在运行的任务（被中断打断的任务），这意味着在退出中断服务函数后，必须进行一次上下文切换。
pdFALSE：恢复运行的任务的优先级 < 当前正在运行的任务（被中断打断的任务），这意味着在退出中断服务函数后，不需要进行上下文切换。
如果在中断中恢复任务，在调用**xTaskResumeFromISR();**函数后，需要判断其返回值，如果返回值=pdTRUE，则需要再调用一个：portYIELD_FROM_ISR();函数，来进行上下文切换。
下面是一段简单的普通任务挂起和恢复示例：
这段代码逻辑为：
创建两个任务：task1_task();和task2_task();
task1_task();这个任务中一进去，紧接着就把自己挂起了。
task2_task();这个任务中，运行到最后紧接着又把task1_task();恢复了。
task2_task();这个任务则一直处于运行状态；
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "FreeRTOS.h"
#include "task.h"
//=========================任务1函数==========================
void task1_task(void *pvParameters);
#define TASK1_TASK_PRIO 3 //任务优先级
#define TASK1_STK_SIZE 128 //任务堆栈大小
TaskHandle_t Task1Task_Handler; //任务句柄
//=========================任务2函数==========================
void task2_task(void *pvParameters);
#define TASK2_TASK_PRIO 4 //任务优先级
#define TASK2_STK_SIZE 128 //任务堆栈大小
TaskHandle_t Task2Task_Handler; //任务句柄
int main(void)
{
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
delay_init(); //延时函数初始化
uart_init(115200); //初始化串口
LED_Init(); //初始化LED
taskENTER_CRITICAL(); //进入临界区
//创建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* )"task2_task",
(uint16_t )TASK2_STK_SIZE,
(void* )NULL,
(UBaseType_t )TASK2_TASK_PRIO,
(TaskHandle_t* )&Task2Task_Handler);
taskEXIT_CRITICAL(); //退出临界区
vTaskStartScheduler(); //开启任务调度器
}
//task1任务函数
void task1_task(void *pvParameters)
{
u8 task1_num=0;
while(1)
{
task1_num++; //任务执1行次数加1 注意task1_num1加到255的时候会清零！！
LED0=!LED0;
printf("任务1已经执行：%d次\r\n",task1_num);
vTaskDelay(1000); //延时1s，也就是1000个时钟节拍
printf("挂起任务1的运行!\r\n");
vTaskSuspend(Task1Task_Handler);//挂起任务
}
}
//task2任务函数
void task2_task(void *pvParameters)
{
u8 task2_num=0;
while(1)
{
task2_num++; //任务2执行次数加1 注意task1_num2加到255的时候会清零！！
LED1=!LED1;
printf("任务2已经执行：%d次\r\n",task2_num);
vTaskDelay(1000); //延时1s，也就是1000个时钟节拍
vTaskResume(Task1Task_Handler); //恢复任务1
printf("恢复任务1的运行!\r\n");
}
}
下面是一段简单的中断中的任务挂起和恢复示例：
这是正点原子的例程，例程中关于LCD液晶屏的代码已经删除，因为初学中越简单越好。
这个例程逻辑为：
创建4个任务，
一个任务是用来创建另外3个任务的，运行后自己删除。
另外三个任务为：
key_task();
task1_task();
task2_task();
key_task();用来检测按键；
如果WKUP按键按下，就会挂起或恢复task1_task();（代码中可以看到挂起和恢复是交替进行的）
如果KEY1按下，就挂起task2_task();
task2_task();的恢复就不同了，它是在中断中进行的，恢复时使用的是：xTaskResumeFromISR();函数，在按键中断中，我们将看到对 pdFALSE 和 pdTRUE 的判断：
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "timer.h"
#include "lcd.h"
#include "key.h"
#include "exti.h"
#include "FreeRTOS.h"
#include "task.h"
//任务优先级
#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);
//任务优先级
#define TASK2_TASK_PRIO 4
//任务堆栈大小
#define TASK2_STK_SIZE 128
//任务句柄
TaskHandle_t Task2Task_Handler;
//任务函数
void task2_task(void *pvParameters);
int main(void)
{
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
delay_init(); //延时函数初始化
uart_init(115200); //初始化串口
LED_Init(); //初始化LED
KEY_Init(); //初始化按键
EXTIX_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* )"task2_task",
(uint16_t )TASK2_STK_SIZE,
(void* )NULL,
(UBaseType_t )TASK2_TASK_PRIO,
(TaskHandle_t* )&Task2Task_Handler);
vTaskDelete(StartTask_Handler); //删除开始任务
taskEXIT_CRITICAL(); //退出临界区
}
//key任务函数
void key_task(void *pvParameters)
{
u8 key,statflag=0;
while(1)
{
key=KEY_Scan(0);
switch(key)
{
case WKUP_PRES:
statflag=!statflag;
if(statflag==1)
{
vTaskSuspend(Task1Task_Handler);//挂起任务
printf("挂起任务1的运行!\r\n");
}
else if(statflag==0)
{
vTaskResume(Task1Task_Handler); //恢复任务1
printf("恢复任务1的运行!\r\n");
}
break;
case KEY1_PRES:
vTaskSuspend(Task2Task_Handler);//挂起任务2
printf("挂起任务2的运行!\r\n");
break;
}
vTaskDelay(10); //延时10ms
}
}
//task1任务函数
void task1_task(void *pvParameters)
{
u8 task1_num=0;
while(1)
{
task1_num++; //任务执1行次数加1 注意task1_num1加到255的时候会清零！！
LED0=!LED0;
printf("任务1已经执行：%d次\r\n",task1_num);
vTaskDelay(1000); //延时1s，也就是1000个时钟节拍
}
}
//task2任务函数
void task2_task(void *pvParameters)
{
u8 task2_num=0;
while(1)
{
task2_num++; //任务2执行次数加1 注意task1_num2加到255的时候会清零！！
LED1=!LED1;
printf("任务2已经执行：%d次\r\n",task2_num);
vTaskDelay(1000); //延时1s，也就是1000个时钟节拍
}
}
中断恢复，下面是按键中断相关配置和中断服务函数，这里将看到 pdFALSE 和 pdTRUE 的判断：
#include "exti.h"
#include "led.h"
#include "key.h"
#include "delay.h"
#include "FreeRTOS.h"
#include "task.h"
//外部中断0服务程序
void EXTIX_Init(void)
{
EXTI_InitTypeDef EXTI_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
KEY_Init(); // 按键端口初始化
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE); //使能复用功能时钟
//GPIOE.4 中断线以及中断初始化配置 下降沿触发 //KEY0
GPIO_EXTILineConfig(GPIO_PortSourceGPIOE,GPIO_PinSource4);
EXTI_InitStructure.EXTI_Line=EXTI_Line4;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure); //根据EXTI_InitStruct中指定的参数初始化外设EXTI寄存器
NVIC_InitStructure.NVIC_IRQChannel = EXTI4_IRQn; //使能按键KEY0所在的外部中断通道
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x06; //抢占优先级6
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00; //子优先级0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //使能外部中断通道
NVIC_Init(&NVIC_InitStructure); //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
}
//任务句柄
extern TaskHandle_t Task2Task_Handler;
//外部中断4服务程序
void EXTI4_IRQHandler(void)
{
BaseType_t YieldRequired;
delay_xms(20); //消抖
if(KEY0==0)
{
YieldRequired=xTaskResumeFromISR(Task2Task_Handler);//恢复任务2
printf("恢复任务2的运行!\r\n");
if(YieldRequired==pdTRUE)
{
/*如果函数xTaskResumeFromISR()返回值为pdTRUE，那么说明要恢复的这个
任务的任务优先级等于或者高于正在运行的任务(被中断打断的任务),所以在
退出中断的时候一定要进行上下文切换！*/
portYIELD_FROM_ISR(YieldRequired);
}
}
EXTI_ClearITPendingBit(EXTI_Line4);//清除LINE4上的中断标志位
}