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
形参:待获取状态任务的任务句柄
返回值: 任务状态

  1. 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

你可能感兴趣的:(单片机,stm32)