【2】STM32·FreeRTOS·任务创建和删除

已于 2024-05-09 15:40:06 修改
阅读量1.2k 收藏 25
点赞数 47
分类专栏： FreeRTOS 文章标签： stm32 单片机 嵌入式硬件
于 2024-05-08 22:34:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cute758/article/details/138508397
版权

目录

一、任务创建和删除的API函数

1.1、动态创建任务函数

1.2、静态创建任务函数

1.3、任务删除函数

二、任务创建和删除（动态方法）

三、任务创建和删除（静态方法）

一、任务创建和删除的API函数

任务的创建和删除本质就是调用 FreeRTOS 的 API 函数

API函数描述

xTaskCreate()

动态方式创建任务
xTaskCreateStatic()静态方式创建任务
xTaskDelete()删除任务

动态创建任务：任务的任务控制块以及任务的栈空间所需的内存，均由 FreeRTOS 从 FreeRTOS 管理的堆中分配

静态创建任务：任务的任务控制块以及任务的栈空间所需的内存，需用户分配提供

1.1、动态创建任务函数

BaseType_t xTaskCreate
(
    TaskFunction_t                  pxTaskCode,      /* 指向任务函数的指针 */
    const char * const              pcName,          /* 任务名字，最大长度configMAX_TASK_NAME_LEN */
    const configSTACK_DEPTH_TYPE    usStackDepth,    /* 任务堆栈大小，注意字为单位 */
    void * const                    pvParameters,    /* 传递给任务函数的参数 */
    UBaseType_t                     uxPriority,      /* 任务优先级，范围：0 ~ configMAX_PRIORITIES - 1 */
    TaskHandle_t * const            pxCreatedTask    /* 任务句柄，就是任务的任务控制块 */
)
返回值描述
pdPASS任务创建成功

errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY

任务创建失败

实现动态创建任务流程

1、将宏 configSUPPORT_DYNAMIC_ALLOCATION 配置为 1

2、定义函数入口参数

3、编写任务函数

此函数创建的任务会立刻进入就绪态，由任务调度器调度运行

动态创建任务函数内部实现

1、申请堆栈内存&任务控制块内存

2、TCB结构体成员赋值

3、添加新任务到就绪列表中

任务控制块结构体成员介绍

typedef struct tskTaskControlBlock
{
    volatile StackType_t      *pxTopOfStack;                           /* 任务栈栈顶，必须为TCB的第一个成员 */
    ListItem_t                xStateListItem;                          /* 任务状态列表项 */
    ListItem_t                xEventListItem;                          /* 任务事件列表项 */
    UBaseType_t               uxPriority;                              /* 任务优先级，数值越大，优先级越大 */
    StackType_t               *pxStack;                                /* 任务栈起始地址 */
    char                      pcTaskName[configMAX_TASK_NAME_LEN];     /* 任务名字 */
    ...
} tskTCB;

任务栈栈顶，在任务切换时的任务上下文保存、任务恢复息息相关

每个任务都有属于自己的任务控制块，类似身份证

1.2、静态创建任务函数

TaskHandle_t xTaskCreateStatic
(
    TaskFunction_t          pxTaskCode,        /* 指向任务函数的指针 */
    const char * const      pcName,            /* 任务函数名 */
    const uint32_t          ulStackDepth,      /* 任务堆栈大小，注意字为单位 */
    void * const            pvParameters,      /* 传递给任务函数的参数 */
    UBaseType_t             uxPriority,        /* 任务优先级 */
    StackType_t * const     puxStackBuffer,    /* 任务堆栈，一般为数组，由用户分配 */
    StaticTask_t * const    pxTaskBuffer       /* 任务控制块指针，由用户分配 */
)
返回值描述
NULL用户没有提供相应的内存，任务创建失败

其他值

任务句柄，任务创建成功

静态创建任务使用流程

1、将宏 configSUPPORT_STATIC_ALLOCATION 配置为 1

2、定义空闲任务&定时器任务的任务堆栈及TCB

3、实现两个接口函数：vApplicationGetIdleTaskMemory()、vApplicationGetTimerTaskMemory()

4、定义函数入口参数

5、编写任务函数

此函数创建的任务会立刻进入就绪态，由任务调度器调度运行

静态创建任务函数内部实现

1、TCB结构体成员赋值

2、添加新任务到就绪列表中

1.3、任务删除函数

void vTaskDelete(TaskHandle_t xTaskToDelete);
形参描述
xTaskToDelete待删除任务的任务句柄

用于删除已被创建的任务，被删除的任务将从就绪态任务列表、阻塞态任务列表、挂起态任务列表和事件列表中移除

1、当传入的参数为NULL，则代表删除任务自身（当前正在运行的任务）

2、当要删除任务自身时，空闲任务会负责释放被删除任务中由系统分配的内存（动态创建任务），但是由用户在任务删除前申请的内存（静态创建任务），则需要由用户在任务被删除前提前释放，否则将导致内存泄漏

删除任务流程

1、使用删除任务函数，需将宏 INCLUDE_vTaskDelete 配置为 1

2、入口参数输入需要删除的任务句柄（NULL代表删除本身）

删除任务函数内部实现

1、获取所要删除任务的控制块：通过传入的任务句柄，判断所需要删除哪个任务，NULL代表删除自身

2、将被删除任务，移除所在列表：将该任务在所在列表中移除，包括：就绪、阻塞、挂起、事件等列表

3、判断所需要删除的任务：删除任务自身，需先添加到等待删除列表，内存释放将在空闲任务执行。删除其他任务，释放内存，任务数量

4、更新下个任务的阻塞时间：更新下一个任务的阻塞超时时间，以防被删除的任务就是下一个阻塞超时的任务

二、任务创建和删除（动态方法）

将设计四个任务：start_task、task1、task2、task3

四个任务的功能如下

start_task：用来创建其他三个任务

task1：实现 LED0 每 500ms 闪烁一次

task2：实现 LED1 每 500ms 闪烁一次

task3：判断按键 KEY0 是否按下，按下则删掉 task1，判断按键 KEY1 是否按下，按下则删掉 task2

main.c

#include "./SYSTEM/sys/sys.h"
#include "./SYSTEM/usart/usart.h"
#include "./SYSTEM/delay/delay.h"
#include "./BSP/LED/led.h"
#include "./BSP/LCD/lcd.h"
#include "./BSP/KEY/key.h"
#include "freertos_demo.h"

int main(void)
{
    HAL_Init();                         /* 初始化HAL库 */
    sys_stm32_clock_init(336, 8, 2, 7); /* 设置时钟,168Mhz */
    delay_init(168);                    /* 延时初始化 */
    usart_init(115200);                 /* 串口初始化为115200 */
    led_init();                         /* 初始化LED */
    lcd_init();                         /* 初始化LCD */
    key_init();                         /* 初始化按键 */

    freertos_demo();
}

freertos_demo.c

#include "freertos_demo.h"

/******************************************************************************************************/
/*FreeRTOS配置*/

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

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

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

/* TASK3 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK3_PRIO 4            /* 任务优先级 */
#define TASK3_STK_SIZE 128      /* 任务堆栈大小 */
TaskHandle_t Task3Task_Handler; /* 任务句柄 */
void task3(void *pvParameters); /* 任务函数 */

/******************************************************************************************************/

/* LCD刷屏时使用的颜色 */
uint16_t lcd_discolor[11] = {WHITE, BLACK, BLUE, RED,
                             MAGENTA, GREEN, CYAN, YELLOW,
                             BROWN, BRRED, GRAY};

/* FreeRTOS例程入口函数 */
void freertos_demo(void)
{
    lcd_show_string(10, 10, 220, 32, 32, "STM32", RED);
    lcd_show_string(10, 47, 220, 24, 24, "Task Create & Del", RED);
    lcd_show_string(10, 76, 220, 16, 16, "ATOM@ALIENTEK", RED);

    lcd_draw_rectangle(5, 110, 115, 314, BLACK);
    lcd_draw_rectangle(125, 110, 234, 314, BLACK);
    lcd_draw_line(5, 130, 115, 130, BLACK);
    lcd_draw_line(125, 130, 234, 130, BLACK);
    lcd_show_string(15, 111, 110, 16, 16, "Task1: 000", BLUE);
    lcd_show_string(135, 111, 110, 16, 16, "Task2: 000", BLUE);

    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();
}

/* start_task */
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 *)&Task1Task_Handler); /* 任务句柄 */
    /* 创建任务2 */
    xTaskCreate((TaskFunction_t)task2,               /* 任务函数 */
                (const char *)"task2",               /* 任务名称 */
                (uint16_t)TASK2_STK_SIZE,            /* 任务堆栈大小 */
                (void *)NULL,                        /* 传入给任务函数的参数 */
                (UBaseType_t)TASK2_PRIO,             /* 任务优先级 */
                (TaskHandle_t *)&Task2Task_Handler); /* 任务句柄 */
    /* 创建任务3 */
    xTaskCreate((TaskFunction_t)task3,               /* 任务函数 */
                (const char *)"task3",               /* 任务名称 */
                (uint16_t)TASK3_STK_SIZE,            /* 任务堆栈大小 */
                (void *)NULL,                        /* 传入给任务函数的参数 */
                (UBaseType_t)TASK3_PRIO,             /* 任务优先级 */
                (TaskHandle_t *)&Task3Task_Handler); /* 任务句柄 */
    vTaskDelete(StartTask_Handler);                  /* 删除开始任务 */
    taskEXIT_CRITICAL();                             /* 退出临界区 */
}

/* task1 */
void task1(void *pvParameters)
{
    uint32_t task1_num = 0;

    while (1)
    {
        lcd_fill(6, 131, 114, 313, lcd_discolor[++task1_num % 11]);
        lcd_show_xnum(71, 111, task1_num, 3, 16, 0x80, BLUE);
        LED0_TOGGLE();
        vTaskDelay(500);
    }
}

/* task2 */
void task2(void *pvParameters)
{
    uint32_t task2_num = 0;

    while (1)
    {
        lcd_fill(126, 131, 233, 313, lcd_discolor[11 - (++task2_num % 11)]);
        lcd_show_xnum(191, 111, task2_num, 3, 16, 0x80, BLUE);
        LED1_TOGGLE();
        vTaskDelay(500);
    }
}

/* task3 */
void task3(void *pvParameters)
{
    uint8_t key = 0;

    while (1)
    {
        key = key_scan(0);

        switch (key)
        {
        case KEY0_PRES: /* 删除任务1 */
        {
            if (Task1Task_Handler != NULL)
            {
                vTaskDelete(Task1Task_Handler);
                Task1Task_Handler = NULL;
            }
            break;
        }
        case KEY1_PRES: /* 删除任务2 */
        {
            if (Task2Task_Handler != NULL)
            {
                vTaskDelete(Task2Task_Handler);
                Task2Task_Handler = NULL;
            }
            break;
        }
        default:
        {
            break;
        }
        }
        vTaskDelay(10);
    }
}

freertos_demo.h

#ifndef __FREERTOS_DEMO_H
#define __FREERTOS_DEMO_H

#include "./SYSTEM/usart/usart.h"
#include "./BSP/LED/led.h"
#include "./BSP/KEY/key.h"
#include "./BSP/LCD/lcd.h"
#include "FreeRTOS.h"
#include "task.h"

void freertos_demo(void);

#endif

三、任务创建和删除（静态方法）

将设计四个任务：start_task、task1、task2、task3

四个任务的功能如下

start_task：用来创建其他三个任务

task1：实现 LED0 每 500ms 闪烁一次

task2：实现 LED1 每 500ms 闪烁一次

task3：判断按键 KEY0 是否按下，按下则删掉 task1，判断按键 KEY1 是否按下，按下则删掉 task2

main.c、freertos_demo.h 和动态创建一样

freertos_demo.c

#include "freertos_demo.h"

/******************************************************************************************************/
/*FreeRTOS配置*/

static StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];      /* 空闲任务任务堆栈 */
static StaticTask_t IdleTaskTCB;                                 /* 空闲任务控制块 */
static StackType_t TimerTaskStack[configTIMER_TASK_STACK_DEPTH]; /* 定时器服务任务堆栈 */
static StaticTask_t TimerTaskTCB;                                /* 定时器服务任务控制块 */

/**
 * @brief       获取空闲任务地任务堆栈和任务控制块内存，因为本例程使用的
                静态内存，因此空闲任务的任务堆栈和任务控制块的内存就应该
                有用户来提供，FreeRTOS提供了接口函数vApplicationGetIdleTaskMemory()
                实现此函数即可。
 * @param       ppxIdleTaskTCBBuffer:任务控制块内存
                ppxIdleTaskStackBuffer:任务堆栈内存
                pulIdleTaskStackSize:任务堆栈大小
 * @retval      无
 */
void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
                                   StackType_t **ppxIdleTaskStackBuffer,
                                   uint32_t *pulIdleTaskStackSize)
{
    *ppxIdleTaskTCBBuffer = &IdleTaskTCB;
    *ppxIdleTaskStackBuffer = IdleTaskStack;
    *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
}

/**
 * @brief       获取定时器服务任务的任务堆栈和任务控制块内存
 * @param       ppxTimerTaskTCBBuffer:任务控制块内存
                ppxTimerTaskStackBuffer:任务堆栈内存
                pulTimerTaskStackSize:任务堆栈大小
 * @retval      无
 */
void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
                                    StackType_t **ppxTimerTaskStackBuffer,
                                    uint32_t *pulTimerTaskStackSize)
{
    *ppxTimerTaskTCBBuffer = &TimerTaskTCB;
    *ppxTimerTaskStackBuffer = TimerTaskStack;
    *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
}

/* START_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define START_TASK_PRIO 1                   /* 任务优先级 */
#define START_STK_SIZE 128                  /* 任务堆栈大小 */
StackType_t StartTaskStack[START_STK_SIZE]; /* 任务堆栈 */
StaticTask_t StartTaskTCB;                  /* 任务控制块 */
TaskHandle_t StartTask_Handler;             /* 任务句柄 */
void start_task(void *pvParameters);        /* 任务函数 */

/* TASK1 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK1_PRIO 2                        /* 任务优先级 */
#define TASK1_STK_SIZE 128                  /* 任务堆栈大小 */
StackType_t Task1TaskStack[TASK1_STK_SIZE]; /* 任务堆栈 */
StaticTask_t Task1TaskTCB;                  /* 任务控制块 */
TaskHandle_t Task1Task_Handler;             /* 任务句柄 */
void task1(void *pvParameters);             /* 任务函数 */

/* TASK2 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK2_PRIO 3                        /* 任务优先级 */
#define TASK2_STK_SIZE 128                  /* 任务堆栈大小 */
StackType_t Task2TaskStack[TASK2_STK_SIZE]; /* 任务堆栈 */
StaticTask_t Task2TaskTCB;                  /* 任务控制块 */
TaskHandle_t Task2Task_Handler;             /* 任务句柄 */
void task2(void *pvParameters);             /* 任务函数 */

/* TASK3 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define TASK3_PRIO 4                        /* 任务优先级 */
#define TASK3_STK_SIZE 128                  /* 任务堆栈大小 */
StackType_t Task3TaskStack[TASK3_STK_SIZE]; /* 任务堆栈 */
StaticTask_t Task3TaskTCB;                  /* 任务控制块 */
TaskHandle_t Task3Task_Handler;             /* 任务句柄 */
void task3(void *pvParameters);             /* 任务函数 */

/******************************************************************************************************/

/* LCD刷屏时使用的颜色 */
uint16_t lcd_discolor[11] = {WHITE, BLACK, BLUE, RED,
                             MAGENTA, GREEN, CYAN, YELLOW,
                             BROWN, BRRED, GRAY};

/* FreeRTOS例程入口函数 */
void freertos_demo(void)
{
    lcd_show_string(10, 10, 220, 32, 32, "STM32", RED);
    lcd_show_string(10, 47, 220, 24, 24, "Task Create & Del", RED);
    lcd_show_string(10, 76, 220, 16, 16, "ATOM@ALIENTEK", RED);

    lcd_draw_rectangle(5, 110, 115, 314, BLACK);
    lcd_draw_rectangle(125, 110, 234, 314, BLACK);
    lcd_draw_line(5, 130, 115, 130, BLACK);
    lcd_draw_line(125, 130, 234, 130, BLACK);
    lcd_show_string(15, 111, 110, 16, 16, "Task1: 000", BLUE);
    lcd_show_string(135, 111, 110, 16, 16, "Task2: 000", BLUE);

    StartTask_Handler = xTaskCreateStatic((TaskFunction_t)start_task,     /* 任务函数 */
                                          (const char *)"start_task",     /* 任务名称 */
                                          (uint32_t)START_STK_SIZE,       /* 任务堆栈大小 */
                                          (void *)NULL,                   /* 传递给任务函数的参数 */
                                          (UBaseType_t)START_TASK_PRIO,   /* 任务优先级 */
                                          (StackType_t *)StartTaskStack,  /* 任务堆栈 */
                                          (StaticTask_t *)&StartTaskTCB); /* 任务控制块 */
    vTaskStartScheduler();
}

/* start_task */
void start_task(void *pvParameters)
{
    taskENTER_CRITICAL(); /* 进入临界区 */
    /* 创建任务1 */
    Task1Task_Handler = xTaskCreateStatic((TaskFunction_t)task1,          /* 任务函数 */
                                          (const char *)"task1",          /* 任务名称 */
                                          (uint32_t)TASK1_STK_SIZE,       /* 任务堆栈大小 */
                                          (void *)NULL,                   /* 传递给任务函数的参数 */
                                          (UBaseType_t)TASK1_PRIO,        /* 任务优先级 */
                                          (StackType_t *)Task1TaskStack,  /* 任务堆栈 */
                                          (StaticTask_t *)&Task1TaskTCB); /* 任务控制块 */
    /* 创建任务2 */
    Task2Task_Handler = xTaskCreateStatic((TaskFunction_t)task2,          /* 任务函数 */
                                          (const char *)"task2",          /* 任务名称 */
                                          (uint32_t)TASK2_STK_SIZE,       /* 任务堆栈大小 */
                                          (void *)NULL,                   /* 传递给任务函数的参数 */
                                          (UBaseType_t)TASK2_PRIO,        /* 任务优先级 */
                                          (StackType_t *)Task2TaskStack,  /* 任务堆栈 */
                                          (StaticTask_t *)&Task2TaskTCB); /* 任务控制块 */
    /* 创建任务3 */
    Task3Task_Handler = xTaskCreateStatic((TaskFunction_t)task3,          /* 任务函数 */
                                          (const char *)"task3",          /* 任务名称 */
                                          (uint32_t)TASK3_STK_SIZE,       /* 任务堆栈大小 */
                                          (void *)NULL,                   /* 传递给任务函数的参数 */
                                          (UBaseType_t)TASK3_PRIO,        /* 任务优先级 */
                                          (StackType_t *)Task3TaskStack,  /* 任务堆栈 */
                                          (StaticTask_t *)&Task3TaskTCB); /* 任务控制块 */
    vTaskDelete(StartTask_Handler);                                       /* 删除开始任务 */
    taskEXIT_CRITICAL();                                                  /* 退出临界区 */
}

/* task1 */
void task1(void *pvParameters)
{
    uint32_t task1_num = 0;

    while (1)
    {
        lcd_fill(6, 131, 114, 313, lcd_discolor[++task1_num % 11]);
        lcd_show_xnum(71, 111, task1_num, 3, 16, 0x80, BLUE);
        LED0_TOGGLE();
        vTaskDelay(500);
    }
}

/* task2 */
void task2(void *pvParameters)
{
    uint32_t task2_num = 0;

    while (1)
    {
        lcd_fill(126, 131, 233, 313, lcd_discolor[11 - (++task2_num % 11)]);
        lcd_show_xnum(191, 111, task2_num, 3, 16, 0x80, BLUE);
        LED1_TOGGLE();
        vTaskDelay(500);
    }
}

/* task3 */
void task3(void *pvParameters)
{
    uint8_t key = 0;

    while (1)
    {
        key = key_scan(0);

        switch (key)
        {
        case KEY0_PRES: /* 删除任务1 */
        {
            if (Task1Task_Handler != NULL)
            {
                vTaskDelete(Task1Task_Handler);
                Task1Task_Handler = NULL;
            }
            break;
        }
        case KEY1_PRES: /* 删除任务2 */
        {
            if (Task2Task_Handler != NULL)
            {
                vTaskDelete(Task2Task_Handler);
                Task2Task_Handler = NULL;
            }
            break;
        }
        default:
        {
            break;
        }
        }
        vTaskDelay(10);
    }
}
HZU_Puzzle
关注
  • 47
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
STM32 【FreeRTOS HAL库】创建任务
吻等离子的博客
05-06 642
线程定义结构包含线程的启动信息。char *name;//任务名//函数指针指向任务函数//枚举类型的任务优先级//传递参数//堆栈大小;0是默认的堆栈大小所以通过osThreadDef相当于当定义了一个结构体变量os_thread_def_Display。
在STM32上创建一个任务
02-17
一份在硬件平台上经过验证的MDK工程文件!
STM32 实现简单定时任务调度器，动态创建任务，两种思路实现流水灯
刻[苦] 的 blog
06-06 3881
代码实现和硬件没关系，所以并不限于STM32，Arduino 之类的其他地方也能用，只要有一个能获取时间的函数就行，或者说，只要有一个会随着时间自动增加的变量就行，时间单位无所谓，所以确实想的话，拿到电脑上也能用。
STM32之任务的创建与删除
weixin_49001476的博客
06-02 602
任务可以理解为进程线程，创建一个任务，就会在内存开辟一个空间。比如：玩游戏、陪女朋友，都可以视为任务Windows系统中的MarkText、谷歌浏览器、记事本，都是任务。任务通常都含有while(1)死循环。
stm32 cubemax freeRTOS 学习：任务的创建和删除
m0_45820434的博客
04-18 371
stm32 freeRTOS 任务创建和删除
stm32f103 FreeRTOS任务创建和删除实验(静态方法).zip
03-07
在这个"STM32F103 FreeRTOS任务创建和删除实验"中，我们主要关注如何在STM32F103上移植并使用FreeRTOS进行任务管理。FreeRTOS的核心概念包括任务（Task）、事件标志组（Event Flags）、信号量（Semaphore）、互斥锁...
stm32f103 FreeRTOS任务创建和删除实验(动态方法).zip
03-07
2. **STM32F103与FreeRTOS结合**：STM32F103拥有丰富的外设接口和充足的RAM、Flash空间，适合运行FreeRTOS这样的实时操作系统。移植FreeRTOS到STM32F103，首先需要配置中断向量表、初始化堆栈和系统时钟，然后编译...
STM32F103实现FreeRTOS任务创建和删除(静态方法)【支持STM32F10X系列单片机】
11-23
STM32F103 FreeRTOS实战。 项目支持STM32F10X系列单片机调测和移植。 项目代码可直接编译、运行。
STM32F103实现FreeRTOS任务创建和删除(动态方法)【支持STM32F10X系列单片机】
11-23
STM32F103 FreeRTOS实战。 项目支持STM32F10X系列单片机调测和移植。 项目代码可直接编译、运行。
STM32H562实现FreeRTOS任务创建与删除实验(静态方法)【支持STM32H系列单片机】.zip
最新发布
06-03
STM32H562 FreeRTOS驱动程序，支持STM32H系列单片机。 项目代码可直接运行~
2.stm32freeRTOS---创建一个任务
m0_56058618的博客
05-04 766
文章目录前言一、创建一个任务需要注意哪些？1、任务创建函数xTaskCreate2、代码分析二、动态/静态分配1· 动态分配2· 静态分配：三、删除任务四、一个函数创建两个任务总结 前言 上一次是初步接触实时系统，这次开始认真学习 一、创建一个任务需要注意哪些？ 1、任务创建函数xTaskCreate BaseType_t xTaskCreate( TaskFunction_t pxTaskCode, //任务名 const char * con
stm32RTOS创建任务
m0_49476241的博客
02-21 1247
文章目录前言一、cuebMX配置二、代码解析总结 前言 本篇文章带大家学习一下如何使用RTOS API函数创建任务。 一、cuebMX配置 具体配置 二、代码解析 osThreadId defaultTaskHandle; osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 128); defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL); void St
stm32 FreeRTOS中如何创建任务
crjmail的博客
04-20 1595
#include "config.h" #include "global.h" #include "stdio.h" #include "PC.h" #include "FreeRTOS.h" #include "task.h" #include "list.h" void vLED1Task(void *pvParameters) { while(1) {
在STM32上创建一个自己的操作系统
热门推荐
Jun626的博客
02-05 1万+
参考文章：http://www.cnblogs.com/ansersion/p/4328800.html 二维码是我创建的QQ群，欢迎新朋友加入。 之前看了蛮多帖子，不过苦于自己对着基本上是门外汉，基本上只明白个大概，幸亏找到一个分享源码的帖子，在这上面我也实现了一个操作系统的移植；同时我也感觉到了自己学习的不足，以前总以为会用几款单片机就觉得单片机学完了，这段时间看系统的内容...
FreeRTOS（基于STM32）——任务创建
vizio.blog.csdn.net
10-28 1540
FreeRTOS笔记，任务的创建。
FreeRTOS学习笔记——动态创建任务（STM32）
a610787932的博客
05-30 1277
1.任务创建和删除API函数 函数 描述 xTaskCreate 动态创建一个任务 xTaskCreateStatic 静态创建一个任务 xTaskCreateRestricted 创建使用MPU进行限制任务。内存相关分配 vTaskDelete 删除一个任务 1.1 xTaskCreate动态创建函数 BaseType_t xTaskCre...
STM32CubeMX学习笔记——FreeRTOS_任务创建与删除
weixin_41738734的博客
12-15 4984
STM32CubeMX学习笔记——FreeRTOS_任务创建与删除Github简介任务创建可视化创建方式代码创建方式任务删除 Github https://github.com/HaHaHaHaHaGe/Planof2019_half/tree/master/Course_Project/FreeRTOS/Class01_CreateTask 简介 在STM32CubeMX上配置FreeRTOS非...
STM32 F4 任务创建的步骤
weixin_30547797的博客
07-02 398
※跟任务重要的三个参数:任务函数,任务堆栈,任务控制块 其他参数 ※stk_limit 任务堆栈深度限位: 栈深,确保堆栈不溢出,一般的为堆栈大小的1/10 ※QTY 内建的消息队列 ※OS_TICK 时间轮转 ※OS_OPT 选项,监测任务堆栈,允许任务对战清除 ※OS_ERR 可以打印出来查看错误类型 任务删除:OSTaskDel函数, 应当尽量避免删除 ※如果未开启时...
stm32 freertos 创建删除队列
05-29
要在 STM32 的 FreeRTOS 中创建和删除队列，需要使用以下 API： 1. `xQueueCreate()`：用于创建一个队列。该函数需要传入队列的长度和每个队列元素的大小，返回一个 `QueueHandle_t` 类型的队列句柄，用于后续操作。 2. `xQueueSend()`：用于向队列发送数据。该函数需要传入队列句柄、要发送的数据、阻塞时间（如果队列已满则等待的时间，单位为 tick），返回一个 `BaseType_t` 类型的值，表示是否发送成功。 3. `xQueueReceive()`：用于从队列接收数据。该函数需要传入队列句柄、接收数据的指针、阻塞时间，返回一个 `BaseType_t` 类型的值，表示是否接收成功。 4. `vQueueDelete()`：用于删除队列。该函数需要传入队列句柄。 以下是一个示例代码，用于创建一个长度为 10，每个元素大小为 4 字节的队列，并向其中发送和接收数据： ```c #include "FreeRTOS.h" #include "task.h" #include "queue.h" void task1(void *pvParameters) { QueueHandle_t xQueue; int data; // 创建队列 xQueue = xQueueCreate(10, sizeof(int)); // 向队列发送数据 for (int i = 0; i < 10; i++) { xQueueSend(xQueue, &i, portMAX_DELAY); } // 从队列接收数据 for (int i = 0; i < 10; i++) { xQueueReceive(xQueue, &data, portMAX_DELAY); printf("Received data: %d\n", data); } // 删除队列 vQueueDelete(xQueue); while (1) {} } int main(void) { xTaskCreate(task1, "Task 1", configMINIMAL_STACK_SIZE, NULL, 1, NULL); vTaskStartScheduler(); return 0; } ``` 该示例中，任务 `task1` 创建了一个长度为 10 的队列，并向其中发送了 10 个整数，然后接收了这些整数并打印出来，最后删除了队列。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HZU_Puzzle

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值