StmF103C8T6标准库使用FreeRtos----任务挂起和恢复

一：任务挂起和恢复理论基础

 

 

 注意：任务优先级数值越大优先级越高，中断优先级数值越小优先级越高。

 

注意由于按键设备有限，task1的挂起和恢复都采用一个按键，中断采用另一个。 

 二：实验步骤

1、首先将前面创建静态任务使用过的configSUPPORT_STATIC_ALLOCATION   设置为0，不然会报错，让我们创建空闲任务，原因的话可以自己看开始调度任务那个函数，上一节讲过。

 2、将 INCLUDE_vTaskSuspend 定义为 1 才能使用此函数，根据官方api可知

 3、首先实现一个按键控制任务的挂起与恢复，在程序中我们只需要对创建动态任务项目中的main.c文件的删除任务进行修改，首先定义一个标志位，初始化为0，当按键按下时判断标志位来实现挂起与恢复，代码如下：

uint16_t Num=0;
uint16_t flag=0;

void stop_LED2_task(char * pvParameters)
{
	for(;;)
	{   
		Serial_Printf("stop_LED2_task\r\n");
		Num=Key_GetNum();
		if(Num==1)
		{
			if(flag==0)
			{
				Serial_Printf("LED2_task已挂起\r\n");
				vTaskSuspend(led2_task_handler);
				flag=1;
				
			}
			else if(flag==1)
			{
				Serial_Printf("LED2_task已恢复\r\n");
				vTaskResume(led2_task_handler);
				flag=0;
			}
		}
		
		vTaskDelay(300);
	} 
}

 注意：提一嘴，通过观察正点原子视频，当按键按下删除或者挂起任务时，那个任务所操纵的LED灯可能是常量也可能熄灭，不是代码有问题。

4、实现在中断里面恢复任务，首先我们要了解freertos的优先级是5-15之间，如果我们按照NVIC优先级分组，例如抢占优先级为2，很明显优先级高于5，是不符合定义的。虽然能够正常运行，但是port.c会有错误产生。

 

必须将 include_vTaskSuspend 和 INCLUDE_xTaskResumeFromISR 定义为 1 才能使用此函数

 5、为了能够在中断中恢复任务，我们需要对其key.c文件进行修改，首先找到官网历程，参考着进行修改，例如

 

注意：当我们写外部中断时，如果你是直接在旧项目上面修改，如果其他.c中有相同的中断名，则会报错。

key.c

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "FreeRTOS.h"
#include "task.h"
#include "Serial.h"

extern TaskHandle_t led2_task_handler;

void Key_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	
	GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource11);
	
	//配置中断输出控制
	EXTI_InitTypeDef EXTI_InitStructure;
	EXTI_InitStructure.EXTI_Line = EXTI_Line11;
	EXTI_InitStructure.EXTI_LineCmd = ENABLE;
	EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
	EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
	EXTI_Init(&EXTI_InitStructure);
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
	
	NVIC_InitTypeDef NVIC_InitStructure;
	NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	//抢占优先级设置
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 5;
	//响应优先级
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_Init(&NVIC_InitStructure);
	
	//为了使用串口打印
	Serial_Init();
	
	
	
}

uint8_t Key_GetNum(void)
{
	uint8_t KeyNum = 0;
	//当按键按下时，为低电平，进入if,因为是上拉模式，按下为低电平，松手为高电平
	if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1) == 0)
	{
		//按下的过程就像弹簧压缩一样，防止震荡，加个延时函数
		vTaskDelay(10);
		//松手时为上拉状态，此时为高电平，退出循环，
		while (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1) == 0);
		//防止震荡
		vTaskDelay(10);
		//给按键赋值
		KeyNum = 1;
	}
	
	return KeyNum;
}

void EXTI15_10_IRQHandler(void)
{
	//查看中断标志位的状态
	if (EXTI_GetITStatus(EXTI_Line11) == SET)
	{
		BaseType_t xYieldRequired;
		/*用于消抖，一般不建议在中断里面使用延时*/
		vTaskDelay(10);
		/*如果出现数据乱跳的现象，可再次判断引脚电平，以避免抖动*/
		if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_11) == 0)
		{
			 /*任务恢复*/ 
			xYieldRequired = xTaskResumeFromISR(led2_task_handler);
			Serial_Printf("LED2_task已恢复\r\n");
		}
		if(xYieldRequired ==pdTRUE)
		{
			 /*任务切换*/
			portYIELD_FROM_ISR( xYieldRequired );
		}
		//清除中断标志位
		EXTI_ClearITPendingBit(EXTI_Line11);
	}
}

main.c

#include "stm32f10x.h"     // Device header
#include "Delay.h"
#include "LED.h"
#include "Key.h"

#include "OLED.h"

#include "Serial.h"
#include "FreeRTOS.h"
#include "task.h"



uint16_t Num=0;
uint16_t flag=0;


#define START_STK_DEPTH						64
#define START_TASK_PRIO						1
TaskHandle_t start_task_handler;
void start_task(void * pvParameters);

#define LED2_STK_DEPTH						64
#define LED2_TASK_PRIO						2
TaskHandle_t led2_task_handler;
void led2_task(char * pvParameters);

#define LED3_STK_DEPTH						64
#define LED3_TASK_PRIO						3
TaskHandle_t led3_task_handler;
void led3_task(char * pvParameters);

#define Stop_LED2_STK_DEPTH						64
#define Stop_LED2_TASK_PRIO						4
TaskHandle_t stop_LED2_task_handler;
void stop_LED2_task(char * pvParameters);

int main(void)
{
	
	LED_Init();
	Serial_Init();
	Key_Init();
	xTaskCreate(            (TaskFunction_t) start_task,		//创建开始任务
							(const char *  ) "start_task",
							(uint16_t      ) START_STK_DEPTH,
							(void *        ) NULL,
							(UBaseType_t   ) START_TASK_PRIO,
							(TaskHandle_t *) &start_task_handler);
	vTaskStartScheduler();  //开启任务调度器			
}

/*******开始任务函数*****/
void start_task(void * pvParameters)
{
	taskENTER_CRITICAL();
	
	xTaskCreate((TaskFunction_t) led2_task,
							(const char *  ) "led2_task",
							(uint16_t      ) LED2_STK_DEPTH,
							(void *        ) NULL,
							(UBaseType_t   ) LED2_TASK_PRIO,
							(TaskHandle_t *) &led2_task_handler); 			
							
	xTaskCreate((TaskFunction_t) led3_task,
							(const char *  ) "led3_task",
							(uint16_t      ) LED3_STK_DEPTH,
							(void *        ) NULL,
							(UBaseType_t   ) LED3_TASK_PRIO,
							(TaskHandle_t *) &led3_task_handler); 	
	xTaskCreate((TaskFunction_t) stop_LED2_task,
							(const char *  ) "stop_LED2_task",
							(uint16_t      ) Stop_LED2_STK_DEPTH,
							(void *        ) NULL,
							(UBaseType_t   ) Stop_LED2_TASK_PRIO,
							(TaskHandle_t *) &stop_LED2_task_handler); 
							
	vTaskDelete(start_task_handler);
							
  taskEXIT_CRITICAL();					
}

void led2_task(char * pvParameters)
{
	for(;;)
	{
		Serial_Printf("LED2_task\r\n");
		LED1_Turn();
		vTaskDelay(333);
	} 
}

void led3_task(char * pvParameters)
{
	for(;;)
	{	
		Serial_Printf("LED3_task\r\n");
		LED2_Turn();
		vTaskDelay(1000);
	} 
}

void stop_LED2_task(char * pvParameters)
{
	for(;;)
	{   
		Serial_Printf("stop_LED2_task\r\n");
		Num=Key_GetNum();
		if(Num==1)
		{
			if(flag==0)
			{
				Serial_Printf("LED2_task已挂起\r\n");
				vTaskSuspend(led2_task_handler);
				flag=1;
				
			}
			else if(flag==1)
			{
				Serial_Printf("LED2_task已恢复\r\n");
				vTaskResume(led2_task_handler);
				flag=0;
			}
		}
		
		vTaskDelay(300);
	} 
}

三、实验结果