FreeRTOS——API相关函数介绍及任务状态查询实战

1.API相关函数介绍

1）UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask )
功能：获得任务优先级 使用该函数需将宏 INCLUDE_uxTaskPriorityGet 置 1
形参：任务句柄，NULL代表任务自身
返回值：任务优先级数值

2）void vTaskPrioritySet( TaskHandle_t xTask , UBaseType_t uxNewPriority )
功能：改变某个任务的任务优先级，使用该函数需将宏 INCLUDE_vTaskPrioritySet 为 1
形参：
参数1：任务句柄，NULL代表任务自身
参数2：需要设置的任务优先级

3）UBaseType_t uxTaskGetNumberOfTasks( void )
功能：此函数用于获取系统中任务的任务数量
返回值：系统中任务的数量

4）UBaseType_t uxTaskGetSystemState(
TaskStatus_t * const pxTaskStatusArray,
const UBaseType_t uxArraySize,
configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime
)
功能： 此函数用于获取系统中所有任务的任务状态信息，使用该函数需将宏 configUSE_TRACE_FACILITY 置 1
形参：
形参1：指向TaskStatus_t 结构体数组首地址
形参2：接收信息的数组大小
形参3：系统总运行时间，为NULL 则省略总运行时间值
返回值：获取信息的任务数量
typedef struct xTASK_STATUS
{
TaskHandle_t xHandle; /* 任务句柄 /
const char * pcTaskName; / 任务名 /
UBaseType_t xTaskNumber; / 任务编号 /
eTaskState e CurrentState; / 任务状态 /
UBaseType_t uxCurrentPriority; / 任务优先级 /
UBaseType_t uxBasePriority; / 任务原始优先级*/
configRUN_TIME_COUNTER_TYPE ulRunTimeCounter; /* 任务运行时间*/
StackType_t * pxStackBase; /* 任务栈基地址 /
configSTACK_DEPTH_TYPE usStackHighWaterMark; / 任务栈历史剩余最小值 */
} TaskStatus_t;

5）void vTaskGetInfo( TaskHandle_t xTask,
TaskStatus_t * pxTaskStatus,
BaseType_t xGetFreeStackSpace,
eTaskState eState )
功能：此函数用于获取指定的单个任务的状态信息，使用该函数需将宏 configUSE_TRACE_FACILITY 置 1
形参：
形参1：指定获取信息的任务的句柄
形参2：接收任务信息的变量
形参3：任务栈历史剩余最小值，
当为“pdFALSE” 则跳过这个步骤，
当为“pdTRUE”则检查历史剩余最小堆栈
形参4：任务状态，可直接赋值，如想获取代入“eInvalid”
typedef enum
{
eRunning = 0, /* 运行态 /
eReady / 就绪态 /
eBlocked, / 阻塞态 /
eSuspended, / 挂起态 /
eDeleted, / 任务被删除 /
eInvalid / 无效 */
} eTaskState;

6）TaskHandle_t xTaskGetCurrentTaskHandle( void )
功能：此函数用于获取当前任务的任务句柄， 使用该函数需将宏 INCLUDE_xTaskGetCurrentTaskHandle 置 1
形参：当前任务的任务句柄

7）TaskHandle_t xTaskGetHandle(const char * pcNameToQuery)
功能：此函数用于通过任务名获取任务句柄 ， 使用该函数需将宏 INCLUDE_xTaskGetHandle 置 1
形参：任务名
返回值：任务句柄

8）UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask )
功能：此函数用于获取指定任务的任务栈历史最小剩余堆栈；使用该函数需将宏 INCLUDE_uxTaskGetStackHighWaterMark 置 1
形参：任务名
返回值：任务栈的历史剩余最小值

9）eTaskState eTaskGetState(TaskHandle_t xTask)
功能：此函数用于查询某个任务的运行状态，使用此函数需将宏 INCLUDE_eTaskGetState 置1
形参：待获取状态任务的任务句柄
返回值： 任务状态

10. void vTaskList(char * pcWriteBuffer)
    功能：此函数用于以“表格”的形式获取系统中任务的信息 ；
    使用此函数需将宏 configUSE_TRACE_FACILITY 和configUSE_STATS_FORMATTING_FUNCTIONS 置1
    Name ： 创建任务的时候给任务分配的名字。
    State ： 任务的壮态信息， B 是阻塞态， R 是就绪态， S 是挂起态， D 是删除态
    Priority ：任务优先级。
    Stack ： 任务堆栈的“高水位线”，就是堆栈历史最小剩余大小。
    Num ： 任务编号，这个编号是唯一的，当多个任务使用同一个任务名的时候可以通过此编号来做区

2.任务状态查询实战

2.1freertos_demo.c

#include "freertos_demo.h"
#include "./SYSTEM/usart/usart.h"
#include "./BSP/LED/led.h"
#include "./BSP/KEY/key.h"
#include "./MALLOC/malloc.h"
#include "string.h"
/*FreeRTOS*********************************************************************************************/
#include "FreeRTOS.h"
#include "task.h"

/*1.FreeRTOS配置*/

/* 1.1 START_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define START_TASK_PRIO 1                   /* 任务优先级 */
#define START_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            StartTask_Handler;  /* 任务句柄 */
void start_task(void *pvParameters);        /* 任务函数 */

/* 1.2 TASK1 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK1_PRIO      2                   /* 任务优先级 */
#define TASK1_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task1_Handler;  /* 任务句柄 */
void task1(void *pvParameters);             /* 任务函数 */

/* 1.3 TASK2 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK2_PRIO      2                   /* 任务优先级 */
#define TASK2_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task2Task_Handler;  /* 任务句柄 */
void task2(void *pvParameters);             /* 任务函数 */

//2创建freertos_demo函数，在此函数中创建start_task
void freertos_demo(void)
{
    
    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();
}

//3创建task_task函数，在此函数中创建task1
void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();           /* 进入临界区 */
    /* 创建任务1 */
    xTaskCreate((TaskFunction_t )task1,
                (const char*    )"task1",
                (uint16_t       )TASK1_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK1_PRIO,
                (TaskHandle_t*  )&Task1_Handler);
                
    /* 创建任务1 */
    xTaskCreate((TaskFunction_t )task2,
                (const char*    )"task2",
                (uint16_t       )TASK2_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK2_PRIO,
                (TaskHandle_t*  )&Task2Task_Handler);
                
    vTaskDelete(StartTask_Handler); /* 删除开始任务 */
    taskEXIT_CRITICAL();            /* 退出临界区 */
}

//3创建task1函数，实现LEDO每500ms翻转一次
void task1(void *pvParameters)
{

    while (1)
    {
        LED0_TOGGLE();
        vTaskDelay(500);

    }
}

char task_buf[300];
//4创建task1函数，实现LEDO每500ms翻转一次
void task2(void *pvParameters)
{

    UBaseType_t prio_num = 0;
    UBaseType_t task_num = 0;
    UBaseType_t task_num2 = 0;
    TaskStatus_t * status_arry = NULL;
    TaskStatus_t * status_arry2 = NULL;
    TaskHandle_t   task_handler=0;
    UBaseType_t task_stack_min = 0;
    eTaskState state = eInvalid;
    
    //任务优先级
    vTaskPrioritySet(Task2Task_Handler,4);
    prio_num = uxTaskPriorityGet(Task2Task_Handler);
    printf("task2的任务优先级：%ld\r\n",prio_num);
    
    //任务数量
    task_num = uxTaskGetNumberOfTasks();
    printf("任务数量：%ld\r\n",task_num);
    //所有任务状态信息
    status_arry = mymalloc(SRAMIN,(sizeof(TaskStatus_t))*task_num);
    task_num2 = uxTaskGetSystemState(status_arry,task_num,NULL);
    printf("任务名\t\t任务优先级\t任务编号\r\n");
    for(int i = 0; i<task_num2; i++)
    {
        printf("%s\t\t%ld\t\%ld\r\n",status_arry[i].pcTaskName,
        status_arry[i].uxCurrentPriority,status_arry[i].xTaskNumber);
    }
    
    //单个任务状态信息
    status_arry2 = mymalloc(SRAMIN,(sizeof(TaskStatus_t)));
    vTaskGetInfo(Task1_Handler,status_arry2,pdTRUE,eInvalid);
    printf("任务名：%s\r\n",status_arry2->pcTaskName);
    printf("任务优先级：%ld\r\n",status_arry2->uxCurrentPriority);
    printf("任务编号：%ld\r\n",status_arry2->xTaskNumber);
    printf("任务状态：%d\r\n",status_arry2->eCurrentState);
    
    //根据任务名称获取句柄
    task_handler = xTaskGetHandle("task1");
    printf("task1任务句柄：%#x\r\n",(int)task_handler);
    
    //获取任务状态
    state = eTaskGetState(Task2Task_Handler);
    printf("当前task2的任务状态：%d\r\n",state);
    
    //以“表格”的形式获取系统中任务的信息 
    vTaskList(task_buf);
    printf("%s\r\n",task_buf);
    
    while (1)
    {
        //获取指定任务的任务栈历史最小剩余堆栈
        task_stack_min =uxTaskGetStackHighWaterMark(Task2Task_Handler);
        printf("历史剩余最小堆栈位：%ld\r\n",task_stack_min);
        vTaskDelay(1000);
    }
}

2.2 freertos_demo.h

#ifndef __FREERTOS_DEMO_H
#define __FREERTOS_DEMO_H

void freertos_demo(void);

#endif