您的位置：首页 > 教育 > 培训 > 如何查询自己二建的状态_良品铺子vi设计手册_百度明星搜索量排行榜_深圳外贸网站推广

如何查询自己二建的状态_良品铺子vi设计手册_百度明星搜索量排行榜_深圳外贸网站推广

2025/8/14 19:05:33 来源：https://blog.csdn.net/2301_76762351/article/details/146037077  浏览:  次   关键词：如何查询自己二建的状态_良品铺子vi设计手册_百度明星搜索量排行榜_深圳外贸网站推广
如何查询自己二建的状态_良品铺子vi设计手册_百度明星搜索量排行榜_深圳外贸网站推广

 一、FreeRTOS任务相关API函数介绍 

二、实验 

1.获取指定任务的任务优先级

UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask ) ；

 代码：

main.c

#include "stm32f10x.h"
#include "FreeRTOS.h"
#include "task.h"
#include "freertos_demo.h"
#include "Delay.h"
#include "sys.h"
#include "usart.h"
#include "LED.h"
#include "Key.h"int main(void){	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组 4 uart_init(115200);	 delay_init();LED_Init();// 创建任务FrrrRTOS_Demo();}

freertos_demo.c

#include "FreeRTOS.h"
#include "task.h"
#include "LED.h"
#include "Key.h"
#include "usart.h"
#include "delay.h"/******************************************************************任务配置****************************************************/
//任务优先级
#define START_TASK_PRIO					1
//任务堆栈大小	
#define START_TASK_STACK_SIZE 	128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);//任务优先级
#define TASK1_PRIO							2
//任务堆栈大小	
#define TASK1_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task1_Handler;
//任务函数
void task1(void *pvParameters);//任务优先级
#define TASK2_PRIO							2
//任务堆栈大小	
#define TASK2_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task2_Handler;
//任务函数
void task2(void *pvParameters);/******************************************************************任务函数****************************************************/
void FrrrRTOS_Demo(void)
{//创建开始任务xTaskCreate((TaskFunction_t )start_task,            			//任务函数( char*         )"start_task",          			//任务名称(uint16_t       )START_TASK_STACK_SIZE, 			//任务堆栈大小(void*          )NULL,                  			//传递给任务函数的参数(UBaseType_t    )START_TASK_PRIO,       			//任务优先级(TaskHandle_t*  )&StartTask_Handler);   			//任务句柄 // 启动任务调度vTaskStartScheduler();}void start_task(void *pvParameters)
{taskENTER_CRITICAL();           //进入临界区//创建1任务xTaskCreate((TaskFunction_t )task1,     	(const char*    )"task1",   	(uint16_t       )TASK1_STACK_SIZE, (void*          )NULL,				(UBaseType_t    )TASK1_PRIO,	(TaskHandle_t*  )&Task1_Handler); //创建2任务xTaskCreate((TaskFunction_t )task2,     (const char*    )"task2",   (uint16_t       )TASK2_STACK_SIZE, (void*          )NULL,(UBaseType_t    )TASK2_PRIO,(TaskHandle_t*  )&Task2_Handler);    vTaskDelete(NULL); 							//删除开始任务taskEXIT_CRITICAL();            //退出临界区
}//1 任务函数
void task1(void *pvParameters)
{while(1){LED1_Turn();vTaskDelay(500);}
}//2 任务函数
void task2(void *pvParameters)
{UBaseType_t	priority;priority = uxTaskPriorityGet(Task1_Handler);printf("任务一的优先级为：%ld\r\n",priority);vTaskDelay(1000);}

 实验结果：

传入空句柄获取自身任务优先级；

uxTaskPriorityGet(NULL);

 2.改变某个任务优先级

 void vTaskPrioritySet( TaskHandle_t xTask,UBaseType_t uxNewPriority )；

代码： 

freertos_demo.c

#include "FreeRTOS.h"
#include "task.h"
#include "LED.h"
#include "Key.h"
#include "usart.h"
#include "delay.h"/******************************************************************任务配置****************************************************/
//任务优先级
#define START_TASK_PRIO					1
//任务堆栈大小	
#define START_TASK_STACK_SIZE 	128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);//任务优先级
#define TASK1_PRIO							2
//任务堆栈大小	
#define TASK1_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task1_Handler;
//任务函数
void task1(void *pvParameters);//任务优先级
#define TASK2_PRIO							2
//任务堆栈大小	
#define TASK2_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task2_Handler;
//任务函数
void task2(void *pvParameters);/******************************************************************任务函数****************************************************/
void FrrrRTOS_Demo(void)
{//创建开始任务xTaskCreate((TaskFunction_t )start_task,            			//任务函数( char*         )"start_task",          			//任务名称(uint16_t       )START_TASK_STACK_SIZE, 			//任务堆栈大小(void*          )NULL,                  			//传递给任务函数的参数(UBaseType_t    )START_TASK_PRIO,       			//任务优先级(TaskHandle_t*  )&StartTask_Handler);   			//任务句柄 // 启动任务调度vTaskStartScheduler();}void start_task(void *pvParameters)
{taskENTER_CRITICAL();           //进入临界区//创建1任务xTaskCreate((TaskFunction_t )task1,     	(const char*    )"task1",   	(uint16_t       )TASK1_STACK_SIZE, (void*          )NULL,				(UBaseType_t    )TASK1_PRIO,	(TaskHandle_t*  )&Task1_Handler); //创建2任务xTaskCreate((TaskFunction_t )task2,     (const char*    )"task2",   (uint16_t       )TASK2_STACK_SIZE, (void*          )NULL,(UBaseType_t    )TASK2_PRIO,(TaskHandle_t*  )&Task2_Handler);    vTaskDelete(NULL); 							//删除开始任务taskEXIT_CRITICAL();            //退出临界区
}//1 任务函数
void task1(void *pvParameters)
{while(1){LED1_Turn();vTaskDelay(500);}
}//2 任务函数
void task2(void *pvParameters)
{UBaseType_t	priority;vTaskPrioritySet(Task2_Handler,4);priority = uxTaskPriorityGet(NULL);printf("任务二的优先级为：%ld\r\n",priority);vTaskDelay(1000);}

实验结果： 

此宏决定可以设置的最大任务优先级

#define configMAX_PRIORITIES            ( 5 )                           // 最大任务优先级数

3.获取系统中任务的任务数量 

UBaseType_t uxTaskGetNumberOfTasks( void )；

代码：

 freertos_demo.c

#include "FreeRTOS.h"
#include "task.h"
#include "LED.h"
#include "Key.h"
#include "usart.h"
#include "delay.h"/******************************************************************任务配置****************************************************/
//任务优先级
#define START_TASK_PRIO					1
//任务堆栈大小	
#define START_TASK_STACK_SIZE 	128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);//任务优先级
#define TASK1_PRIO							2
//任务堆栈大小	
#define TASK1_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task1_Handler;
//任务函数
void task1(void *pvParameters);//任务优先级
#define TASK2_PRIO							2
//任务堆栈大小	
#define TASK2_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task2_Handler;
//任务函数
void task2(void *pvParameters);/******************************************************************任务函数****************************************************/
void FrrrRTOS_Demo(void)
{//创建开始任务xTaskCreate((TaskFunction_t )start_task,            			//任务函数( char*         )"start_task",          			//任务名称(uint16_t       )START_TASK_STACK_SIZE, 			//任务堆栈大小(void*          )NULL,                  			//传递给任务函数的参数(UBaseType_t    )START_TASK_PRIO,       			//任务优先级(TaskHandle_t*  )&StartTask_Handler);   			//任务句柄 // 启动任务调度vTaskStartScheduler();}void start_task(void *pvParameters)
{taskENTER_CRITICAL();           //进入临界区//创建1任务xTaskCreate((TaskFunction_t )task1,     	(const char*    )"task1",   	(uint16_t       )TASK1_STACK_SIZE, (void*          )NULL,				(UBaseType_t    )TASK1_PRIO,	(TaskHandle_t*  )&Task1_Handler); //创建2任务xTaskCreate((TaskFunction_t )task2,     (const char*    )"task2",   (uint16_t       )TASK2_STACK_SIZE, (void*          )NULL,(UBaseType_t    )TASK2_PRIO,(TaskHandle_t*  )&Task2_Handler);    vTaskDelete(NULL); 							//删除开始任务taskEXIT_CRITICAL();            //退出临界区
}//1 任务函数
void task1(void *pvParameters)
{while(1){LED1_Turn();vTaskDelay(500);}
}//2 任务函数
void task2(void *pvParameters)
{UBaseType_t	priority  = 0;UBaseType_t task_num = 0;vTaskPrioritySet(Task2_Handler,4);priority = uxTaskPriorityGet(NULL);task_num = uxTaskGetNumberOfTasks();printf("任务数量：%ld\r\n",task_num);printf("任务二的优先级为：%ld\r\n",priority);while(1){vTaskDelay(1000);}}

实验结果：

首先自己创建的3个任务，然后启动任务调度器函数vTaskStartScheduler();内部创建的2个任务：空闲任务和定时器任务，一共是5个任务。

如果是4个任务，那是因为FreeRTOSConfig.c文件里面没有启用软件定时器功能，添加下面宏即可：

 /*-------------------------------- FreeRTOS 定时器配置 --------------------------------*/
#define configUSE_TIMERS 1
#define configTIMER_TASK_PRIORITY (configMAX_PRIORITIES - 1)  // 定时器任务优先级
#define configTIMER_QUEUE_LENGTH 10  // 定时器队列长度
#define configTIMER_TASK_STACK_DEPTH (configMINIMAL_STACK_SIZE * 2)  // 定时器任务堆栈大小

4.获取系统中所有任务的任务状态信息

    UBaseType_t uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray,
                                      const UBaseType_t uxArraySize,
                                      configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime )；

 这个宏默认是0，所以要修改一下：

#define configUSE_TRACE_FACILITY        1  // 禁用可视化跟踪调试功能 

 代码：

 freertos_demo.c 

#include "FreeRTOS.h"
#include "task.h"
#include "LED.h"
#include "Key.h"
#include "usart.h"
#include "delay.h"/******************************************************************任务配置****************************************************/
//任务优先级
#define START_TASK_PRIO					1
//任务堆栈大小	
#define START_TASK_STACK_SIZE 	128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);//任务优先级
#define TASK1_PRIO							2
//任务堆栈大小	
#define TASK1_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task1_Handler;
//任务函数
void task1(void *pvParameters);//任务优先级
#define TASK2_PRIO							2
//任务堆栈大小	
#define TASK2_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task2_Handler;
//任务函数
void task2(void *pvParameters);/******************************************************************任务函数****************************************************/
void FrrrRTOS_Demo(void)
{//创建开始任务xTaskCreate((TaskFunction_t )start_task,            			//任务函数( char*         )"start_task",          			//任务名称(uint16_t       )START_TASK_STACK_SIZE, 			//任务堆栈大小(void*          )NULL,                  			//传递给任务函数的参数(UBaseType_t    )START_TASK_PRIO,       			//任务优先级(TaskHandle_t*  )&StartTask_Handler);   			//任务句柄 // 启动任务调度vTaskStartScheduler();}void start_task(void *pvParameters)
{taskENTER_CRITICAL();           //进入临界区//创建1任务xTaskCreate((TaskFunction_t )task1,     	(const char*    )"task1",   	(uint16_t       )TASK1_STACK_SIZE, (void*          )NULL,				(UBaseType_t    )TASK1_PRIO,	(TaskHandle_t*  )&Task1_Handler); //创建2任务xTaskCreate((TaskFunction_t )task2,     (const char*    )"task2",   (uint16_t       )TASK2_STACK_SIZE, (void*          )NULL,(UBaseType_t    )TASK2_PRIO,(TaskHandle_t*  )&Task2_Handler);    vTaskDelete(NULL); 							//删除开始任务taskEXIT_CRITICAL();            //退出临界区
}//1 任务函数
void task1(void *pvParameters)
{while(1){LED1_Turn();vTaskDelay(500);}
}// 任务2 函数
void task2(void *pvParameters)
{UBaseType_t priority  = 0;                                         // 用于存储任务优先级UBaseType_t task_num  = 0;                                         // 用于存储系统中任务的总数UBaseType_t task2_num = 0;                                         // 用于存储实际获取到的任务状态数量TaskStatus_t *status_array = 0;                                    // 用于存储任务状态信息的数组uint8_t i = 0;                                                     // 循环计数器// 设置任务2的优先级为4vTaskPrioritySet(Task2_Handler, 4);// 获取当前任务（任务2）的优先级priority = uxTaskPriorityGet(NULL);printf("\r\n任务二的优先级为：%ld\r\n", priority);// 获取系统中任务的总数task_num = uxTaskGetNumberOfTasks();printf("任务数量：%ld\r\n", task_num);printf("----------------------------\r\n");// 为 status_array 分配内存，用于存储任务状态信息// 分配的内存大小为 task_num * sizeof(TaskStatus_t) = 5 * 需要分配内存块的大小	   TaskStatus_t 是 FreeRTOS 中用于存储任务状态信息的结构体status_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status_array == NULL)  // 检查内存是否分配成功{printf("内存分配失败！\r\n");return;  // 如果分配失败，直接返回}// 获取系统中所有任务的状态信息// 将任务状态信息存储到 status_array 中，并返回实际获取到的任务数量task2_num = uxTaskGetSystemState(status_array, task_num, NULL);// 打印任务状态信息for (i = 0; i < task2_num; i++) {printf("任务名称: %s\r\n", status_array[i].pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status_array[i].xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status_array[i].uxCurrentPriority); 						// 打印任务优先级printf("----------------------------\r\n");}// 释放 status_array 的内存vPortFree(status_array);// 任务主循环while (1){vTaskDelay(1000);  // 任务延时 1000 个 tick（根据 configTICK_RATE_HZ 决定具体时间）}
}

实验结果：

与自己创建的任务优先级、编号等都一样；

FreeRTOS申请内存的函数：

void * pvPortMalloc( size_t xWantedSize )；

参数：需要分配内存块的大小

返回值：成功返回指向分配内存块的指针；失败返回NULL

    status_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));
    if (status_array == NULL)  // 检查内存是否分配成功
    {
        printf("内存分配失败！\r\n");
        return;  
    }

   
    vPortFree(status_array);                                                // 释放 status_array 的内存

还可以打印这些信息： 

​​​​​​​typedef struct xTASK_STATUS
{TaskHandle_t xHandle;                         /* 任务句柄，表示该结构体描述的任务。 */const char * pcTaskName;                      /* 指向任务名称的指针。如果任务在结构体填充后被删除，该值将无效！ */ /*lint !e971 允许未限定的 char 类型仅用于字符串和单个字符。 */UBaseType_t xTaskNumber;                      /* 任务的唯一编号。 */eTaskState eCurrentState;                     /* 结构体填充时任务的状态。 */UBaseType_t uxCurrentPriority;                /* 结构体填充时任务的运行优先级（可能被继承）。 */UBaseType_t uxBasePriority;                   /* 如果任务的当前优先级被继承以避免无界优先级反转（当获取互斥锁时），任务将返回的基础优先级。仅在 FreeRTOSConfig.h 中定义了 configUSE_MUTEXES 为 1 时有效。 */configRUN_TIME_COUNTER_TYPE ulRunTimeCounter; /* 任务到目前为止分配的总运行时间，由运行时间统计时钟定义。参见 https://www.FreeRTOS.org/rtos-run-time-stats.html。仅在 FreeRTOSConfig.h 中定义了 configGENERATE_RUN_TIME_STATS 为 1 时有效。 */StackType_t * pxStackBase;                    /* 指向任务堆栈区域的最低地址。 */#if ( ( portSTACK_GROWTH > 0 ) && ( configRECORD_STACK_HIGH_ADDRESS == 1 ) )StackType_t * pxTopOfStack;               /* 指向任务堆栈区域的最高地址。 */StackType_t * pxEndOfStack;               /* 指向任务堆栈区域的结束地址。 */#endifconfigSTACK_DEPTH_TYPE usStackHighWaterMark;  /* 自任务创建以来，任务堆栈剩余的最小空间量。该值越接近零，任务堆栈溢出的风险越大。 */
} TaskStatus_t;

5.获取指定的单个任务的状态信息 

    void vTaskGetInfo( TaskHandle_t xTask,
                       TaskStatus_t * pxTaskStatus,
                       BaseType_t xGetFreeStackSpace,
                       eTaskState eState );

 代码：

#include "FreeRTOS.h"
#include "task.h"
#include "LED.h"
#include "Key.h"
#include "usart.h"
#include "delay.h"/******************************************************************任务配置****************************************************/
//任务优先级
#define START_TASK_PRIO					1
//任务堆栈大小	
#define START_TASK_STACK_SIZE 	128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);//任务优先级
#define TASK1_PRIO							2
//任务堆栈大小	
#define TASK1_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task1_Handler;
//任务函数
void task1(void *pvParameters);//任务优先级
#define TASK2_PRIO							2
//任务堆栈大小	
#define TASK2_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task2_Handler;
//任务函数
void task2(void *pvParameters);/******************************************************************任务函数****************************************************/
void FrrrRTOS_Demo(void)
{//创建开始任务xTaskCreate((TaskFunction_t )start_task,            			//任务函数( char*         )"start_task",          			//任务名称(uint16_t       )START_TASK_STACK_SIZE, 			//任务堆栈大小(void*          )NULL,                  			//传递给任务函数的参数(UBaseType_t    )START_TASK_PRIO,       			//任务优先级(TaskHandle_t*  )&StartTask_Handler);   			//任务句柄 // 启动任务调度vTaskStartScheduler();}void start_task(void *pvParameters)
{taskENTER_CRITICAL();           //进入临界区//创建1任务xTaskCreate((TaskFunction_t )task1,     	(const char*    )"task1",   	(uint16_t       )TASK1_STACK_SIZE, (void*          )NULL,				(UBaseType_t    )TASK1_PRIO,	(TaskHandle_t*  )&Task1_Handler); //创建2任务xTaskCreate((TaskFunction_t )task2,     (const char*    )"task2",   (uint16_t       )TASK2_STACK_SIZE, (void*          )NULL,(UBaseType_t    )TASK2_PRIO,(TaskHandle_t*  )&Task2_Handler);    vTaskDelete(NULL); 							//删除开始任务taskEXIT_CRITICAL();            //退出临界区
}//1 任务函数
void task1(void *pvParameters)
{while(1){LED1_Turn();vTaskDelay(500);}
}// 任务2 函数
void task2(void *pvParameters)
{UBaseType_t priority  = 0;                                         // 用于存储任务优先级UBaseType_t task_num  = 0;                                         // 用于存储系统中任务的总数UBaseType_t task2_num = 0;                                         // 用于存储实际获取到的任务状态数量TaskStatus_t *status_array = 0;                                    // 用于存储任务状态信息的数组TaskStatus_t *status2_array = 0; uint8_t i = 0;                                                     // 循环计数器/*****************************************获取当前任务（任务2）的优先级*************************************************************/// 设置任务2的优先级为4vTaskPrioritySet(Task2_Handler, 4);priority = uxTaskPriorityGet(NULL);printf("\r\n任务二的优先级为：%ld\r\n", priority);
/***********************************************获取系统中任务的总数***************************************************************/task_num = uxTaskGetNumberOfTasks();printf("任务数量：%ld\r\n", task_num);printf("----------------------------\r\n");
/*************************************************获取所有任务的状态信息*****************************************************/// 为 status_array 分配内存，用于存储任务状态信息// 分配的内存大小为 task_num * sizeof(TaskStatus_t) = 5 * 需要分配内存块的大小	   TaskStatus_t 是 FreeRTOS 中用于存储任务状态信息的结构体status_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status_array == NULL) {printf("status_array内存分配失败！\r\n");return;  }task2_num = uxTaskGetSystemState(status_array, task_num, NULL);for (i = 0; i < task2_num; i++) {printf("任务名称: %s\r\n", status_array[i].pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status_array[i].xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status_array[i].uxCurrentPriority); 						// 打印任务优先级printf("----------------------------\r\n");}vPortFree(status_array);																												// 释放 status_array 的内存			
/************************************************获取任务2的状态信息****************************************************/		status2_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status2_array == NULL) {printf("status2_array内存分配失败！\r\n");return;  }vTaskGetInfo( Task2_Handler,status2_array,pdTRUE,eInvalid);printf("任务名称: %s\r\n", status2_array->pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status2_array->xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status2_array->uxCurrentPriority); 					// 打印任务优先级printf("任务状态: %d\r\n", status2_array->eCurrentState);        					// 任务状态printf("----------------------------\r\n");vPortFree(status2_array);	// 任务主循环while (1){vTaskDelay(1000);  // 任务延时 1000 个 tick（根据 configTICK_RATE_HZ 决定具体时间）}
}

实验现象： 

任务2，正在运行所以状态是0；与上面一致

获取所有任务信息：

     UBaseType_t uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray,
                                      const UBaseType_t uxArraySize,
                                      configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime )；

获取单个任务信息 :

    void vTaskGetInfo( TaskHandle_t xTask,
                       TaskStatus_t * pxTaskStatus,
                       BaseType_t xGetFreeStackSpace,
                       eTaskState eState )

两个函数很像，但是第一个函数的第一个参数是结构体指针，第二个函数的第一个参数是结构体； 

6.获取当前任务的任务句柄

TaskHandle_t    xTaskGetCurrentTaskHandle( void )；

代码： 

#include "FreeRTOS.h"
#include "task.h"
#include "LED.h"
#include "Key.h"
#include "usart.h"
#include "delay.h"/******************************************************************任务配置****************************************************/
//任务优先级
#define START_TASK_PRIO					1
//任务堆栈大小	
#define START_TASK_STACK_SIZE 	128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);//任务优先级
#define TASK1_PRIO							2
//任务堆栈大小	
#define TASK1_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task1_Handler;
//任务函数
void task1(void *pvParameters);//任务优先级
#define TASK2_PRIO							2
//任务堆栈大小	
#define TASK2_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task2_Handler;
//任务函数
void task2(void *pvParameters);/******************************************************************任务函数****************************************************/
void FrrrRTOS_Demo(void)
{//创建开始任务xTaskCreate((TaskFunction_t )start_task,            			//任务函数( char*         )"start_task",          			//任务名称(uint16_t       )START_TASK_STACK_SIZE, 			//任务堆栈大小(void*          )NULL,                  			//传递给任务函数的参数(UBaseType_t    )START_TASK_PRIO,       			//任务优先级(TaskHandle_t*  )&StartTask_Handler);   			//任务句柄 // 启动任务调度vTaskStartScheduler();}void start_task(void *pvParameters)
{taskENTER_CRITICAL();           //进入临界区//创建1任务xTaskCreate((TaskFunction_t )task1,     	(const char*    )"task1",   	(uint16_t       )TASK1_STACK_SIZE, (void*          )NULL,				(UBaseType_t    )TASK1_PRIO,	(TaskHandle_t*  )&Task1_Handler); //创建2任务xTaskCreate((TaskFunction_t )task2,     (const char*    )"task2",   (uint16_t       )TASK2_STACK_SIZE, (void*          )NULL,(UBaseType_t    )TASK2_PRIO,(TaskHandle_t*  )&Task2_Handler);    vTaskDelete(NULL); 							//删除开始任务taskEXIT_CRITICAL();            //退出临界区
}//1 任务函数
void task1(void *pvParameters)
{while(1){LED1_Turn();vTaskDelay(500);}
}// 任务2 函数
void task2(void *pvParameters)
{UBaseType_t priority  = 0;                                         // 用于存储任务优先级UBaseType_t task_num  = 0;                                         // 用于存储系统中任务的总数UBaseType_t task2_num = 0;                                         // 用于存储实际获取到的任务状态数量TaskStatus_t *status_array = 0;                                    // 用于存储任务状态信息的数组TaskStatus_t *status2_array = 0; TaskHandle_t	TaskHandle;																					 //用于存储任务句柄uint8_t i = 0;                                                     // 循环计数器/*****************************************获取当前任务（任务2）的优先级*************************************************************/// 设置任务2的优先级为4vTaskPrioritySet(Task2_Handler, 4);priority = uxTaskPriorityGet(NULL);printf("\r\n任务二的优先级为：%ld\r\n", priority);
/***********************************************获取系统中任务的总数***************************************************************/task_num = uxTaskGetNumberOfTasks();printf("任务数量：%ld\r\n", task_num);printf("----------------------------\r\n");
/*************************************************获取所有任务的状态信息*****************************************************/// 为 status_array 分配内存，用于存储任务状态信息// 分配的内存大小为 task_num * sizeof(TaskStatus_t) = 5 * 需要分配内存块的大小	   TaskStatus_t 是 FreeRTOS 中用于存储任务状态信息的结构体status_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status_array == NULL) {printf("status_array内存分配失败！\r\n");return;  }task2_num = uxTaskGetSystemState(status_array, task_num, NULL);for (i = 0; i < task2_num; i++) {printf("任务名称: %s\r\n", status_array[i].pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status_array[i].xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status_array[i].uxCurrentPriority); 						// 打印任务优先级printf("----------------------------\r\n");}vPortFree(status_array);																												// 释放 status_array 的内存			
/************************************************获取任务2的状态信息****************************************************/		status2_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status2_array == NULL) {printf("status2_array内存分配失败！\r\n");return;  }vTaskGetInfo( Task2_Handler,status2_array,pdTRUE,eInvalid);printf("任务名称: %s\r\n", status2_array->pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status2_array->xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status2_array->uxCurrentPriority); 					// 打印任务优先级printf("任务状态: %d\r\n", status2_array->eCurrentState);        					// 任务状态printf("----------------------------\r\n");vPortFree(status2_array);	
/************************************************获取当前任务句柄****************************************************/	TaskHandle = xTaskGetCurrentTaskHandle();	printf("当前任务句柄: %p\r\n", (void *)TaskHandle);    // 打印任务句柄地址 		// 任务主循环while (1){vTaskDelay(1000);  // 任务延时 1000 个 tick（根据 configTICK_RATE_HZ 决定具体时间）}
}

实验结果：

7.通过任务名获取任务句柄

TaskHandle_t xTaskGetHandle(const char * pcNameToQuery);

默认不是1需要置1 ：

 #define    INCLUDE_xTaskGetHandle                    1   

 代码：

#include "FreeRTOS.h"
#include "task.h"
#include "LED.h"
#include "Key.h"
#include "usart.h"
#include "delay.h"/******************************************************************任务配置****************************************************/
//任务优先级
#define START_TASK_PRIO					1
//任务堆栈大小	
#define START_TASK_STACK_SIZE 	128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);//任务优先级
#define TASK1_PRIO							2
//任务堆栈大小	
#define TASK1_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task1_Handler;
//任务函数
void task1(void *pvParameters);//任务优先级
#define TASK2_PRIO							2
//任务堆栈大小	
#define TASK2_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task2_Handler;
//任务函数
void task2(void *pvParameters);/******************************************************************任务函数****************************************************/
void FrrrRTOS_Demo(void)
{//创建开始任务xTaskCreate((TaskFunction_t )start_task,            			//任务函数( char*         )"start_task",          			//任务名称(uint16_t       )START_TASK_STACK_SIZE, 			//任务堆栈大小(void*          )NULL,                  			//传递给任务函数的参数(UBaseType_t    )START_TASK_PRIO,       			//任务优先级(TaskHandle_t*  )&StartTask_Handler);   			//任务句柄 // 启动任务调度vTaskStartScheduler();}void start_task(void *pvParameters)
{taskENTER_CRITICAL();           //进入临界区//创建1任务xTaskCreate((TaskFunction_t )task1,     	(const char*    )"task1",   	(uint16_t       )TASK1_STACK_SIZE, (void*          )NULL,				(UBaseType_t    )TASK1_PRIO,	(TaskHandle_t*  )&Task1_Handler); //创建2任务xTaskCreate((TaskFunction_t )task2,     (const char*    )"task2",   (uint16_t       )TASK2_STACK_SIZE, (void*          )NULL,(UBaseType_t    )TASK2_PRIO,(TaskHandle_t*  )&Task2_Handler);    vTaskDelete(NULL); 							//删除开始任务taskEXIT_CRITICAL();            //退出临界区
}//1 任务函数
void task1(void *pvParameters)
{while(1){LED1_Turn();vTaskDelay(500);}
}// 任务2 函数
void task2(void *pvParameters)
{UBaseType_t priority  = 0;                                         // 用于存储任务优先级UBaseType_t task_num  = 0;                                         // 用于存储系统中任务的总数UBaseType_t task2_num = 0;                                         // 用于存储实际获取到的任务状态数量TaskStatus_t *status_array = 0;                                    // 用于存储任务状态信息的数组TaskStatus_t *status2_array = 0; TaskHandle_t	TaskHandle;																					 //用于存储任务句柄uint8_t i = 0;                                                     // 循环计数器/*****************************************获取当前任务（任务2）的优先级*************************************************************/// 设置任务2的优先级为4vTaskPrioritySet(Task2_Handler, 4);priority = uxTaskPriorityGet(NULL);printf("\r\n任务二的优先级为：%ld\r\n", priority);printf("----------------------------\r\n");
/***********************************************获取系统中任务的总数***************************************************************/task_num = uxTaskGetNumberOfTasks();printf("任务数量：%ld\r\n", task_num);printf("----------------------------\r\n");
/*************************************************获取所有任务的状态信息*****************************************************/// 为 status_array 分配内存，用于存储任务状态信息// 分配的内存大小为 task_num * sizeof(TaskStatus_t) = 5 * 需要分配内存块的大小	   TaskStatus_t 是 FreeRTOS 中用于存储任务状态信息的结构体status_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status_array == NULL) {printf("status_array内存分配失败！\r\n");return;  }task2_num = uxTaskGetSystemState(status_array, task_num, NULL);for (i = 0; i < task2_num; i++) {printf("任务名称: %s\r\n", status_array[i].pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status_array[i].xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status_array[i].uxCurrentPriority); 						// 打印任务优先级printf("----------------------------\r\n");}vPortFree(status_array);																												// 释放 status_array 的内存			
/************************************************获取任务2的状态信息****************************************************/		status2_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status2_array == NULL) {printf("status2_array内存分配失败！\r\n");return;  }vTaskGetInfo( Task2_Handler,status2_array,pdTRUE,eInvalid);printf("任务名称: %s\r\n", status2_array->pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status2_array->xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status2_array->uxCurrentPriority); 					// 打印任务优先级printf("任务状态: %d\r\n", status2_array->eCurrentState);        					// 任务状态printf("----------------------------\r\n");vPortFree(status2_array);	
/************************************************获取当前任务句柄****************************************************/	TaskHandle = xTaskGetCurrentTaskHandle();	printf("当前任务句柄: %p\r\n", (void *)TaskHandle);    // 打印任务句柄地址printf("----------------------------\r\n"); 		
/************************************************通过任务名获取任务句柄****************************************************/			TaskHandle =  xTaskGetHandle("task2");printf("当前任务句柄: %p\r\n", (void *)TaskHandle);    // 打印任务句柄地址 printf("----------------------------\r\n");// 任务主循环while (1){vTaskDelay(1000);  // 任务延时 1000 个 tick（根据 configTICK_RATE_HZ 决定具体时间）}
}

实验结果： 

 8.获取指定任务的任务栈历史最小剩余堆栈 

UBaseType_t    uxTaskGetStackHighWaterMark( TaskHandle_t  xTask )

 默认不是1需置1：

#define    INCLUDE_uxTaskGetStackHighWaterMark                    1     

 代码：

#include "FreeRTOS.h"
#include "task.h"
#include "LED.h"
#include "Key.h"
#include "usart.h"
#include "delay.h"/******************************************************************任务配置****************************************************/
//任务优先级
#define START_TASK_PRIO					1
//任务堆栈大小	
#define START_TASK_STACK_SIZE 	128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);//任务优先级
#define TASK1_PRIO							2
//任务堆栈大小	
#define TASK1_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task1_Handler;
//任务函数
void task1(void *pvParameters);//任务优先级
#define TASK2_PRIO							2
//任务堆栈大小	
#define TASK2_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task2_Handler;
//任务函数
void task2(void *pvParameters);/******************************************************************任务函数****************************************************/
void FrrrRTOS_Demo(void)
{//创建开始任务xTaskCreate((TaskFunction_t )start_task,            			//任务函数( char*         )"start_task",          			//任务名称(uint16_t       )START_TASK_STACK_SIZE, 			//任务堆栈大小(void*          )NULL,                  			//传递给任务函数的参数(UBaseType_t    )START_TASK_PRIO,       			//任务优先级(TaskHandle_t*  )&StartTask_Handler);   			//任务句柄 // 启动任务调度vTaskStartScheduler();}void start_task(void *pvParameters)
{taskENTER_CRITICAL();           //进入临界区//创建1任务xTaskCreate((TaskFunction_t )task1,     	(const char*    )"task1",   	(uint16_t       )TASK1_STACK_SIZE, (void*          )NULL,				(UBaseType_t    )TASK1_PRIO,	(TaskHandle_t*  )&Task1_Handler); //创建2任务xTaskCreate((TaskFunction_t )task2,     (const char*    )"task2",   (uint16_t       )TASK2_STACK_SIZE, (void*          )NULL,(UBaseType_t    )TASK2_PRIO,(TaskHandle_t*  )&Task2_Handler);    vTaskDelete(NULL); 							//删除开始任务taskEXIT_CRITICAL();            //退出临界区
}//1 任务函数
void task1(void *pvParameters)
{while(1){LED1_Turn();vTaskDelay(500);}
}// 任务2 函数
void task2(void *pvParameters)
{UBaseType_t priority  = 0;                                         // 用于存储任务优先级UBaseType_t task_num  = 0;                                         // 用于存储系统中任务的总数UBaseType_t task2_num = 0;                                         // 用于存储实际获取到的任务状态数量TaskStatus_t *status_array = 0;                                    // 用于存储任务状态信息的数组TaskStatus_t *status2_array = 0; TaskHandle_t	TaskHandle;																					 //用于存储任务句柄UBaseType_t		task2_stack_min = 0;																//用于储存堆栈大小uint8_t i = 0;                                                     // 循环计数器/*****************************************获取当前任务（任务2）的优先级*************************************************************/// 设置任务2的优先级为4vTaskPrioritySet(Task2_Handler, 4);priority = uxTaskPriorityGet(NULL);printf("\r\n任务二的优先级为：%ld\r\n", priority);printf("----------------------------\r\n");
/***********************************************获取系统中任务的总数***************************************************************/task_num = uxTaskGetNumberOfTasks();printf("任务数量：%ld\r\n", task_num);printf("----------------------------\r\n");
/*************************************************获取所有任务的状态信息*****************************************************/// 为 status_array 分配内存，用于存储任务状态信息// 分配的内存大小为 task_num * sizeof(TaskStatus_t) = 5 * 需要分配内存块的大小	   TaskStatus_t 是 FreeRTOS 中用于存储任务状态信息的结构体status_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status_array == NULL) {printf("status_array内存分配失败！\r\n");return;  }task2_num = uxTaskGetSystemState(status_array, task_num, NULL);for (i = 0; i < task2_num; i++) {printf("任务名称: %s\r\n", status_array[i].pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status_array[i].xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status_array[i].uxCurrentPriority); 						// 打印任务优先级printf("----------------------------\r\n");}vPortFree(status_array);																												// 释放 status_array 的内存			
/************************************************获取任务2的状态信息****************************************************/		status2_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status2_array == NULL) {printf("status2_array内存分配失败！\r\n");return;  }vTaskGetInfo( Task2_Handler,status2_array,pdTRUE,eInvalid);printf("任务名称: %s\r\n", status2_array->pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status2_array->xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status2_array->uxCurrentPriority); 					// 打印任务优先级printf("任务状态: %d\r\n", status2_array->eCurrentState);        					// 任务状态printf("----------------------------\r\n");vPortFree(status2_array);	
/************************************************获取当前任务句柄****************************************************/	TaskHandle = xTaskGetCurrentTaskHandle();	printf("当前任务句柄: %p\r\n", (void *)TaskHandle);    // 打印任务句柄地址printf("----------------------------\r\n"); 		
/************************************************通过任务名获取任务句柄****************************************************/			TaskHandle =  xTaskGetHandle("task2");printf("当前任务句柄: %p\r\n", (void *)TaskHandle);    // 打印任务句柄地址 printf("----------------------------\r\n");
/************************************************通过任务名获取任务句柄****************************************************/				task2_stack_min = uxTaskGetStackHighWaterMark(Task2_Handler);printf("task2历史剩余最小堆栈位: %ld\r\n", task2_stack_min);    // 打印任务句柄地址 printf("----------------------------\r\n");		// 任务主循环while (1){vTaskDelay(1000);  // 任务延时 1000 个 tick（根据 configTICK_RATE_HZ 决定具体时间）}
}

实验结果：

如果创建任务时，堆栈分配很小，就会溢出打印0；

9.查询某个任务的运行状态 

eTaskState    eTaskGetState(TaskHandle_t xTask)

 默认不是1需置1：

 #define    INCLUDE_eTaskGetState                    1    

 代码：

#include "FreeRTOS.h"
#include "task.h"
#include "LED.h"
#include "Key.h"
#include "usart.h"
#include "delay.h"/******************************************************************任务配置****************************************************/
//任务优先级
#define START_TASK_PRIO					1
//任务堆栈大小	
#define START_TASK_STACK_SIZE 	128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);//任务优先级
#define TASK1_PRIO							2
//任务堆栈大小	
#define TASK1_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task1_Handler;
//任务函数
void task1(void *pvParameters);//任务优先级
#define TASK2_PRIO							2
//任务堆栈大小	
#define TASK2_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task2_Handler;
//任务函数
void task2(void *pvParameters);/******************************************************************任务函数****************************************************/
void FrrrRTOS_Demo(void)
{//创建开始任务xTaskCreate((TaskFunction_t )start_task,            			//任务函数( char*         )"start_task",          			//任务名称(uint16_t       )START_TASK_STACK_SIZE, 			//任务堆栈大小(void*          )NULL,                  			//传递给任务函数的参数(UBaseType_t    )START_TASK_PRIO,       			//任务优先级(TaskHandle_t*  )&StartTask_Handler);   			//任务句柄 // 启动任务调度vTaskStartScheduler();}void start_task(void *pvParameters)
{taskENTER_CRITICAL();           //进入临界区//创建1任务xTaskCreate((TaskFunction_t )task1,     	(const char*    )"task1",   	(uint16_t       )TASK1_STACK_SIZE, (void*          )NULL,				(UBaseType_t    )TASK1_PRIO,	(TaskHandle_t*  )&Task1_Handler); //创建2任务xTaskCreate((TaskFunction_t )task2,     (const char*    )"task2",   (uint16_t       )TASK2_STACK_SIZE, (void*          )NULL,(UBaseType_t    )TASK2_PRIO,(TaskHandle_t*  )&Task2_Handler);    vTaskDelete(NULL); 							//删除开始任务taskEXIT_CRITICAL();            //退出临界区
}//1 任务函数
void task1(void *pvParameters)
{while(1){LED1_Turn();vTaskDelay(500);}
}// 任务2 函数
void task2(void *pvParameters)
{UBaseType_t priority  = 0;                                         // 用于存储任务优先级UBaseType_t task_num  = 0;                                         // 用于存储系统中任务的总数UBaseType_t task2_num = 0;                                         // 用于存储实际获取到的任务状态数量TaskStatus_t *status_array = 0;                                    // 用于存储任务状态信息的数组TaskStatus_t *status2_array = 0; TaskHandle_t	TaskHandle;																					 //用于存储任务句柄UBaseType_t		task2_stack_min = 0;																 //用于储存堆栈大小eTaskState	task_state;																						// 用于存储任务状态uint8_t i = 0;                                                     // 循环计数器/*****************************************获取当前任务（任务2）的优先级*************************************************************/// 设置任务2的优先级为4vTaskPrioritySet(Task2_Handler, 4);priority = uxTaskPriorityGet(NULL);printf("\r\n任务二的优先级为：%ld\r\n", priority);printf("----------------------------\r\n");
/***********************************************获取系统中任务的总数***************************************************************/task_num = uxTaskGetNumberOfTasks();printf("任务数量：%ld\r\n", task_num);printf("----------------------------\r\n");
/*************************************************获取所有任务的状态信息*****************************************************/// 为 status_array 分配内存，用于存储任务状态信息// 分配的内存大小为 task_num * sizeof(TaskStatus_t) = 5 * 需要分配内存块的大小	   TaskStatus_t 是 FreeRTOS 中用于存储任务状态信息的结构体status_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status_array == NULL) {printf("status_array内存分配失败！\r\n");return;  }task2_num = uxTaskGetSystemState(status_array, task_num, NULL);for (i = 0; i < task2_num; i++) {printf("任务名称: %s\r\n", status_array[i].pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status_array[i].xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status_array[i].uxCurrentPriority); 						// 打印任务优先级printf("----------------------------\r\n");}vPortFree(status_array);																												// 释放 status_array 的内存			
/************************************************获取任务2的状态信息****************************************************/		status2_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status2_array == NULL) {printf("status2_array内存分配失败！\r\n");return;  }vTaskGetInfo( Task2_Handler,status2_array,pdTRUE,eInvalid);printf("任务名称: %s\r\n", status2_array->pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status2_array->xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status2_array->uxCurrentPriority); 					// 打印任务优先级printf("任务状态: %d\r\n", status2_array->eCurrentState);        					// 任务状态printf("----------------------------\r\n");vPortFree(status2_array);	
/************************************************获取当前任务句柄****************************************************/	TaskHandle = xTaskGetCurrentTaskHandle();	printf("当前任务句柄: %p\r\n", (void *)TaskHandle);    // 打印任务句柄地址printf("----------------------------\r\n"); 		
/************************************************通过任务名获取任务句柄****************************************************/			TaskHandle =  xTaskGetHandle("task2");printf("当前任务句柄: %p\r\n", (void *)TaskHandle);    // 打印任务句柄地址 printf("----------------------------\r\n");
/************************************************通过任务名获取任务句柄****************************************************/				task2_stack_min = uxTaskGetStackHighWaterMark(Task2_Handler);printf("task2历史剩余最小堆栈位: %ld\r\n", task2_stack_min);    // 打印任务句柄地址 printf("----------------------------\r\n");		
/************************************************查询某个任务的运行状态?****************************************************/			task_state = eTaskGetState(Task2_Handler);printf("task2任务的状态: %d\r\n", task_state);    // 打印任务句柄地址 printf("----------------------------\r\n");	// 任务主循环while (1){vTaskDelay(1000);  // 任务延时 1000 个 tick（根据 configTICK_RATE_HZ 决定具体时间）}
}

实验结果：

0：运行态

1：就绪态

10.以“表格”的形式获取系统中任务的信息 

void   vTaskList(char * pcWriteBuffer)

 默认不是1需置1：

#define configUSE_STATS_FORMATTING_FUNCTIONS             1 

代码：

#include "FreeRTOS.h"
#include "task.h"
#include "LED.h"
#include "Key.h"
#include "usart.h"
#include "delay.h"/******************************************************************任务配置****************************************************/
//任务优先级
#define START_TASK_PRIO					1
//任务堆栈大小	
#define START_TASK_STACK_SIZE 	128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);//任务优先级
#define TASK1_PRIO							2
//任务堆栈大小	
#define TASK1_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task1_Handler;
//任务函数
void task1(void *pvParameters);//任务优先级
#define TASK2_PRIO							2
//任务堆栈大小	
#define TASK2_STACK_SIZE 				128  
//任务句柄
TaskHandle_t Task2_Handler;
//任务函数
void task2(void *pvParameters);char  task_buffer[500]; 							//用于存储系统中任务信息表格/******************************************************************任务函数****************************************************/
void FrrrRTOS_Demo(void)
{//创建开始任务xTaskCreate((TaskFunction_t )start_task,            			//任务函数( char*         )"start_task",          			//任务名称(uint16_t       )START_TASK_STACK_SIZE, 			//任务堆栈大小(void*          )NULL,                  			//传递给任务函数的参数(UBaseType_t    )START_TASK_PRIO,       			//任务优先级(TaskHandle_t*  )&StartTask_Handler);   			//任务句柄 // 启动任务调度vTaskStartScheduler();}void start_task(void *pvParameters)
{taskENTER_CRITICAL();           //进入临界区//创建1任务xTaskCreate((TaskFunction_t )task1,     	(const char*    )"task1",   	(uint16_t       )TASK1_STACK_SIZE, (void*          )NULL,				(UBaseType_t    )TASK1_PRIO,	(TaskHandle_t*  )&Task1_Handler); //创建2任务xTaskCreate((TaskFunction_t )task2,     (const char*    )"task2",   (uint16_t       )TASK2_STACK_SIZE, (void*          )NULL,(UBaseType_t    )TASK2_PRIO,(TaskHandle_t*  )&Task2_Handler);    vTaskDelete(NULL); 							//删除开始任务taskEXIT_CRITICAL();            //退出临界区
}//1 任务函数
void task1(void *pvParameters)
{while(1){LED1_Turn();vTaskDelay(500);}
}// 任务2 函数
void task2(void *pvParameters)
{UBaseType_t priority  = 0;                                         // 用于存储任务优先级UBaseType_t task_num  = 0;                                         // 用于存储系统中任务的总数UBaseType_t task2_num = 0;                                         // 用于存储实际获取到的任务状态数量TaskStatus_t *status_array = 0;                                    // 用于存储任务状态信息的数组TaskStatus_t *status2_array = 0; TaskHandle_t	TaskHandle;																					 //用于存储任务句柄UBaseType_t		task2_stack_min = 0;																 //用于储存堆栈大小eTaskState	task_state;																						// 用于存储任务状态uint8_t i = 0;                                                     // 循环计数器/*****************************************获取当前任务（任务2）的优先级*************************************************************/// 设置任务2的优先级为4vTaskPrioritySet(Task2_Handler, 4);priority = uxTaskPriorityGet(NULL);printf("\r\n任务二的优先级为：%ld\r\n", priority);printf("----------------------------\r\n");
/***********************************************获取系统中任务的总数***************************************************************/task_num = uxTaskGetNumberOfTasks();printf("任务数量：%ld\r\n", task_num);printf("----------------------------\r\n");
/*************************************************获取所有任务的状态信息*****************************************************/// 为 status_array 分配内存，用于存储任务状态信息// 分配的内存大小为 task_num * sizeof(TaskStatus_t) = 5 * 需要分配内存块的大小	   TaskStatus_t 是 FreeRTOS 中用于存储任务状态信息的结构体status_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status_array == NULL) {printf("status_array内存分配失败！\r\n");return;  }task2_num = uxTaskGetSystemState(status_array, task_num, NULL);for (i = 0; i < task2_num; i++) {printf("任务名称: %s\r\n", status_array[i].pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status_array[i].xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status_array[i].uxCurrentPriority); 						// 打印任务优先级printf("----------------------------\r\n");}vPortFree(status_array);																												// 释放 status_array 的内存			
/************************************************获取任务2的状态信息****************************************************/		status2_array = (TaskStatus_t *)pvPortMalloc(task_num * sizeof(TaskStatus_t));	if (status2_array == NULL) {printf("status2_array内存分配失败！\r\n");return;  }vTaskGetInfo( Task2_Handler,status2_array,pdTRUE,eInvalid);printf("任务名称: %s\r\n", status2_array->pcTaskName);        							// 打印任务名称printf("任务编号: %ld\r\n", status2_array->xTaskNumber);      							// 打印任务编号printf("任务优先级: %ld\r\n", status2_array->uxCurrentPriority); 					// 打印任务优先级printf("任务状态: %d\r\n", status2_array->eCurrentState);        					// 任务状态printf("----------------------------\r\n");vPortFree(status2_array);	
/************************************************获取当前任务句柄****************************************************/	TaskHandle = xTaskGetCurrentTaskHandle();	printf("当前任务句柄: %p\r\n", (void *)TaskHandle);    // 打印任务句柄地址printf("----------------------------\r\n"); 		
/************************************************通过任务名获取任务句柄****************************************************/			TaskHandle =  xTaskGetHandle("task2");printf("当前任务句柄: %p\r\n", (void *)TaskHandle);    // 打印任务句柄地址 printf("----------------------------\r\n");
/************************************************通过任务名获取任务句柄****************************************************/				task2_stack_min = uxTaskGetStackHighWaterMark(Task2_Handler);printf("task2历史剩余最小堆栈位: %ld\r\n", task2_stack_min);    // 打印任务句柄地址 printf("----------------------------\r\n");		
/************************************************查询某个任务的运行状态?****************************************************/			task_state = eTaskGetState(Task2_Handler);printf("task2任务的状态: %d\r\n", task_state);    // 打印任务句柄地址 printf("----------------------------\r\n");	
/************************************************以“表格”的形式获取系统中任务的信息****************************************************/					vTaskList( task_buffer );printf("%s\r\n",task_buffer);	// 任务主循环while (1){vTaskDelay(1000);  // 任务延时 1000 个 tick（根据 configTICK_RATE_HZ 决定具体时间）}
}

实验结果：

版权声明:

本网仅为发布的内容提供存储空间，不对发表、转载的内容提供任何形式的保证。凡本网注明“来源：XXX网络”的作品，均转载自其它媒体，著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处。

我们尊重并感谢每一位作者，均已注明文章来源和作者。如因作品内容、版权或其它问题，请及时与我们联系，联系邮箱：809451989@qq.com，投稿邮箱：809451989@qq.com

推荐新闻

热搜词

记录---为什么你写的 `position: sticky` 不工作？99% 的前端都踩过这个坑 SciTech-Management-Salary Reckoning: 上市公司的高管收入估计: 确认企业高管薪酬信息的途径 + 企业高管薪酬信息对投资者的参考价值 大模型算法-PT（预训练）、SFT（监督微调）和RL（强化学习） PostgreSQL 常用命令行工具 GAS_Aura-Init Ability Actor Info 发电

声明：本站所有新闻及新闻图片来源于其他网站，如有侵权，请及时联系我们！

客户服务 | 关于我们 | 版权声明

版权所有：

Copyright 2024 尧图网 All Rights Reserved.QQ:809451989