FreeRTOS的任务挂起以恢复

挂起可以理解为暂时停止任务，恢复可以理解为从新启动挂起的任务

挂起API函数(可以在tasks.c中找到)

vTaskSuspend( TaskHandle_t xTaskToSuspend )

xTaskToSuspend：需要挂起的任务句柄

非中断恢复API函数(可以在tasks.c中找到)

vTaskResume( TaskHandle_t xTaskToResume )

xTaskToSuspend：需要挂起的任务句柄

中断恢复API函数(可以在tasks.c中找到)

xTaskResumeFromISR( TaskHandle_t xTaskToResume )

xTaskToSuspend：需要挂起的任务句柄

注意：中断中不可以使用

vTaskDelay( const TickType_t xTicksToDelay )

实验目的

通过按键控制LED0任务的挂起与恢复

任务挂起与恢复

#include "stm32f10x.h"


#include "stm32f10x.h"
#include 
#include "FreeRTOS.h"
#include "task.h"


uint8_t main_temp = 0;


void LED_Init(void)
{

  GPIO_InitTypeDef  GPIO_InitStructure;


  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);   //使能PE端口时钟


  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_5;  //端口配置
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;     //推挽输出
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    //IO口速度为50MHz
  GPIO_Init(GPIOC, &GPIO_InitStructure);            //推挽输出 ，IO口速度为50MHz
  GPIO_SetBits(GPIOC,GPIO_Pin_1|GPIO_Pin_5);         //输出高 

}


void KEY_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStructure; //定义结构体变量  
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);

  GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;     //选择你要设置的IO口
  GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPD;//下拉输入  
  GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;     //设置传输速率
  GPIO_Init(GPIOA,&GPIO_InitStructure);      /* 初始化GPIO */
}


// 外部中断初始化
void My_EXTI_Init(void)
{
  NVIC_InitTypeDef NVIC_InitStructure;
  EXTI_InitTypeDef  EXTI_InitStructure;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);

  GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource0);//选择GPIO管脚用作外部中断线路


  //EXTI0 NVIC 配置
  NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;//EXTI0中断通道
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;//抢占优先级
  NVIC_InitStructure.NVIC_IRQChannelSubPriority =3;    //子优先级
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;      //IRQ通道使能
  NVIC_Init(&NVIC_InitStructure);  //根据指定的参数初始化VIC寄存器

  EXTI_InitStructure.EXTI_Line=EXTI_Line0;
  EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;
  EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Rising;
  EXTI_InitStructure.EXTI_LineCmd=ENABLE;
  EXTI_Init(&EXTI_InitStructure);
}


#define START_TASK_PRIO 1 //任务优先级
#define START_STK_SIZE 128 //任务堆栈大小
TaskHandle_t StartTask_Handler; //任务句柄
void start_task(void *pvParameters); //任务函数


#define LED0_TASK_PRIO 2 //任务优先级
#define LED0_STK_SIZE 50 //任务堆栈大小
TaskHandle_t LED0Task_Handler; //任务句柄
void led0_task(void *p_arg); //任务函数


#define LED1_TASK_PRIO 2 //任务优先级
#define LED1_STK_SIZE 50 //任务堆栈大小
TaskHandle_t LED1Task_Handler; //任务句柄
void led1_task(void *p_arg); //任务函数


#define KEY0_TASK_PRIO 2 //任务优先级
#define KEY0_STK_SIZE 50 //任务堆栈大小
TaskHandle_t KEY0Task_Handler; //任务句柄
void key0_task(void *p_arg); //任务函数


int main( void ) 
{
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组 4
  LED_Init(); //初始化 LED
  KEY_Init();
  My_EXTI_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();   //进入临界区
  //创建 LED0 任务
  xTaskCreate(
    (TaskFunction_t )led0_task, 
    (const char* )"led0_task", 
    (uint16_t )LED0_STK_SIZE, 
    (void* )NULL,
    (UBaseType_t )LED0_TASK_PRIO,
    (TaskHandle_t* )&LED0Task_Handler
  );
  //创建 LED1 任务
  xTaskCreate(
    (TaskFunction_t )led1_task, 
    (const char* )"led1_task", 
    (uint16_t )LED1_STK_SIZE, 
    (void* )NULL,
    (UBaseType_t )LED1_TASK_PRIO,
    (TaskHandle_t* )&LED1Task_Handler
  );
  //创建 KEY0 任务
  xTaskCreate(
    (TaskFunction_t )key0_task, 
    (const char* )"key0_task", 
    (uint16_t )KEY0_STK_SIZE, 
    (void* )NULL,
    (UBaseType_t )KEY0_TASK_PRIO,
    (TaskHandle_t* )&KEY0Task_Handler
  );
  vTaskDelete(StartTask_Handler); //删除开始任务
  taskEXIT_CRITICAL();   //退出临界区
}
//LED0 任务函数
void led0_task(void *pvParameters)
{
  while(1)
  {
    if(GPIO_ReadInputDataBit( GPIOC, GPIO_Pin_5))
    {
      GPIO_ResetBits( GPIOC, GPIO_Pin_5);
    }
    else
    {
      GPIO_SetBits( GPIOC, GPIO_Pin_5);
    }
    vTaskDelay(400);
  }
}


//LED1 任务函数
void led1_task(void *pvParameters)
{
  while(1)
  {
    if(GPIO_ReadInputDataBit( GPIOC, GPIO_Pin_1))
    {
      GPIO_ResetBits( GPIOC, GPIO_Pin_1);
    }
    else
    {
      GPIO_SetBits( GPIOC, GPIO_Pin_1);
    }
    vTaskDelay(200);
  }
}


//KEY0 任务函数
void key0_task(void *pvParameters)
{
  while(1)
  {
    if( main_temp == 0xff ){
      //任务挂起(非中断)
      //vTaskSuspend(LED0Task_Handler);
    }
    else{
      //任务恢复(非中断)
      //vTaskResume(LED0Task_Handler);
    }
    vTaskDelay(100);
  }
}


//按键中断服务函数
void EXTI0_IRQHandler(void)
{
  if(EXTI_GetITStatus(EXTI_Line0)==1)
  {
    if( main_temp ){
      main_temp = 0x00;
      //中断函数中进行任务恢复(区分中断)
      xTaskResumeFromISR(LED0Task_Handler);
    }
    else{
      main_temp = 0xff;
      //任务挂起(谨慎在中断使用，虽然可以达到初步效果，不保证不会出问题)
      vTaskSuspend(LED0Task_Handler);
    }
  }
  EXTI_ClearITPendingBit(EXTI_Line0);
}

--END--