哞＜FreeRTOS＞自學笔记——静态创建任务

 （整体代码放在最后）

步骤一

在FreeRTOS .h中找到 宏 configSUPPORT_STATIC_ALLOCATION ，将其值改为 1 

步骤二

 如果使用静态方法的话需要配置两个函数vApplicationGetldleTaskMemory()和 vApplicationGetTimerTaskMemory ()。通过这两个函数来给空闲任务和定时器服务任务的任务堆栈和任务控制块分配内存，这两个函数我们在mainc.c中定义

步骤三       开始任务的配置

（一）自定义开始任务宏

 （二）在main函数中配置开始任务的xTaskCreateStatic( ）函数

 

 （三）创建开始任务函数 void start_task( void * pvParameters )

 步骤四       任务一的配置

（一）自定义任务1 宏

          与开始任务的宏一样，只需改名称即可

 （二）在开始任务函数 void start_task( void * pvParameters )  中配置 任务1 的xTaskCreateStatic( ）函数

与开始任务的xTaskCreateStatic( ）函数一样。复制粘贴就好，按照任务1 的宏修改名称

（三）创建任务1 函数void task1_task( void * pvParameters )

将自己的业务代码写入其中

 步骤五       任务二的配置

与任务一的配置方法相同

 注意别漏红框内的函数

 注意开始任务、任务1、任务2 的优先级分别为 1、2、3

自己编的任务1、任务2的业务代码

串口打印效果

main中的代码

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "FreeRTOS.h"
#include "task.h"





//空闲任务
static StaticTask_t IdleTCB;  //空闲任务的任务控制块
static StackType_t IdleStak[configMINIMAL_STACK_SIZE] ; //空闲任务的堆栈

 void vApplicationGetIdleTaskMemory(           StaticTask_t ** ppxIdleTaskTCBBuffer,  //空闲任务的任务控制块
                                               StackType_t ** ppxIdleTaskStackBuffer, //空闲任务的堆栈
                                               uint32_t * pulIdleTaskStackSize )  // 堆栈的大小 
{
	* ppxIdleTaskTCBBuffer =  &IdleTCB ;
	* ppxIdleTaskStackBuffer = IdleStak ;
	*pulIdleTaskStackSize  = configMINIMAL_STACK_SIZE ;
}

//定时器任务
static StaticTask_t TimerTCB;   
static StackType_t TimerStak[configTIMER_TASK_STACK_DEPTH] ;  
void vApplicationGetTimerTaskMemory(         StaticTask_t ** ppxTimerTaskTCBBuffer, 
                                             StackType_t ** ppxTimerTaskStackBuffer, 
                                             uint32_t * pulTimerTaskStackSize )   
{
	* ppxTimerTaskTCBBuffer =   &TimerTCB ;
	* ppxTimerTaskStackBuffer =  TimerStak ;
	*pulTimerTaskStackSize  = configTIMER_TASK_STACK_DEPTH ;
	
}


//开始任务

#define START_TASK_SIZE 120  //堆栈大小
#define START_TASK_PRIO 1    //优先级
StackType_t StartTaskStack[START_TASK_SIZE];//任务堆栈
StaticTask_t StartTaskTCB ;//控制块
TaskHandle_t StartTask_Handle ;//句柄
void start_task( void * pvParameters );


  //任务函数

// 任务1

#define TASK1_TASK_SIZE 120  //堆栈大小
#define TASK1_TASK_PRIO 2    //优先级
StackType_t Task1TaskStack[START_TASK_SIZE];//任务堆栈
StaticTask_t Task1TaskTCB ;//控制块
TaskHandle_t Task1Task_Handle ;
void task1_task( void * pvParameters );

// 任务2

#define TASK2_TASK_SIZE 120  //堆栈大小
#define TASK2_TASK_PRIO 3   //优先级
StackType_t Task2TaskStack[START_TASK_SIZE];//任务堆栈
StaticTask_t Task2TaskTCB ;//控制块
TaskHandle_t Task2Task_Handle ;
void task2_task( void * pvParameters );





int main(void)
{
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4	 
	delay_init();	    				//延时函数初始化	  
	uart_init(115200);					//初始化串口
	LED_Init();		  					//初始化LED
	
	
	
 StartTask_Handle  = xTaskCreateStatic(          (TaskFunction_t)             start_task,   //任务函数
                                                (char *)                    "start_task" ,      //任务名称
                                                (uint32_t)                   START_TASK_SIZE, //任务堆栈大小
                                                (void *)                      NULL,   //传递给任务函数的参数
                                                (UBaseType_t)                 START_TASK_PRIO,   //任务优先级
                                                (StackType_t *)               StartTaskStack,  //任务堆栈
                                                (StaticTask_t *)             &StartTaskTCB );   //任务控制块
	
	
  vTaskStartScheduler();   //开始任务调度
	
	
}

 void start_task( void * pvParameters )
    { 
			 taskENTER_CRITICAL();           //进入临界区
         
					
					//task1
					Task1Task_Handle  = xTaskCreateStatic(          (TaskFunction_t)            task1_task,   //任务函数
                                                (char *)                    "task1_task" ,      //任务名称
                                                (uint32_t)                   TASK1_TASK_SIZE, //任务堆栈大小
                                                (void *)                      NULL,   //传递给任务函数的参数
                                                (UBaseType_t)                 TASK1_TASK_PRIO,   //任务优先级
                                                (StackType_t *)              Task1TaskStack,  //任务堆栈
                                                (StaticTask_t *)             &Task1TaskTCB );   //任务控制块
																								
																								
					//task2																			
					Task2Task_Handle  = xTaskCreateStatic(          (TaskFunction_t)             task2_task,   //任务函数
                                                (char *)                    " task2_task" ,      //任务名称
                                                (uint32_t)                   TASK2_TASK_SIZE, //任务堆栈大小
                                                (void *)                      NULL,   //传递给任务函数的参数
                                                (UBaseType_t)                  TASK2_TASK_PRIO,   //任务优先级
                                                (StackType_t *)                Task2TaskStack,  //任务堆栈
                                                (StaticTask_t *)             & Task2TaskTCB );   //任务控制块  
																								
				 
					vTaskDelete(StartTask_Handle); //删除开始任务
    taskEXIT_CRITICAL();            //退出临界区		 
                                               
    }



void task1_task( void * pvParameters )
{
		char task_name = 0 ;
		while(1)
		{
			 
			task_name ++;
				printf ("task1 is runing %d\r\n",task_name);
				vTaskDelay(1000);
			if(task_name == 10)
			{
				printf ("task2_stop\r\n");
				
				vTaskDelete(Task2Task_Handle);
					vTaskDelay(1000);
				
			}
		 
  		
	 
		}
	
	
	
}

void task2_task( void * pvParameters )
{
	char task2_name = 0 ;
		while(1)
		{
			task2_name ++;
				vTaskDelay(1000);
				printf ("task2 is runing %d\r\n",task2_name);
		}
	
	
	
	
	
}