程序员经验分享-hwhale

（第9-10讲）STM32F4单片机，FreeRTOS任务创建和删除（动态方法）【视频笔记、代码讲解】【正点原子】【原创】

2023-05-16

文章目录

  • 🔴🟡🟢其他文章链接，独家吐血整理
  • 1、视频笔记
  • 2、实验现象
  • 3、代码讲解（个人注释）
    • 1、为什么堆栈取128*4字节？
    • 2、开启临界区保护和不开启临界区保护的区别？
    • 3、来自弹幕区的一个小问题？
  • 4、demo函数（正点原子）

🔴🟡🟢其他文章链接，独家吐血整理

【吐血总结】FreeRTOS难点、Systick中断-滴答定时器、PendSV中断-任务切换、SVC中断-系统底层、时间片调度-时钟节拍【已完结】
（第1-8讲）STM32F4单片机，FreeRTOS基础知识总结【视频笔记、代码讲解】【正点原子】【原创】
（第9-10讲）STM32F4单片机，FreeRTOS任务创建和删除（动态方法）【视频笔记、代码讲解】【正点原子】【原创】
（第12讲）STM32F4单片机，FreeRTOS任务创建和删除（静态方法）【视频笔记、代码讲解】【正点原子】【原创】
（第13-14讲）STM32F4单片机，FreeRTOS任务挂起和恢复【视频笔记、代码讲解】【正点原子】【原创】
（第16-17讲）STM32F4单片机，FreeRTOS中断管理简介【视频笔记、代码讲解】【正点原子】【原创】
（第18-19讲）32单片机，FreeRTOS临界段代码保护、任务调度器的挂起和恢复【视频笔记、代码讲解】【原创】
（第20-22讲）STM32F4单片机，FreeRTOS列表和列表项API函数讲解【视频笔记、代码讲解、正点原子】【原创】
（第34-36讲）FreeRTOS消息队列知识汇总【B站UP、硬件家园、普中科技、正点原子】【视频笔记】【原创】
（第40-44讲）STM32F4单片机，FreeRTOS信号量【二值、计数、翻转、互斥】【代码讲解】【正点原子】【原创】

1、视频笔记

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
start_task只创建一次（如果是一直创建，则会内存爆炸，因为一直在申请堆栈块）

2、实验现象 

 * 实验现象
 * 1 本实验开机后，显示提示信息，等待外部输入。
      KEY0用于申请内存，每次申请2K字节内存。
      KEY1用于释放内存。
      KEY_UP用于切换操作内存区（内部SRAM内存/内部CCM内存/外部SRAM内存）。
 * 2 LED0闪烁 ,提示程序运行。

3、代码讲解（个人注释）

在这里插入图片描述
这里就是128*uint32_t的大小堆栈
在这里插入图片描述

1、为什么堆栈取128*4字节？

/* START_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define START_TASK_PRIO         1
#define START_TASK_STACK_SIZE   128//128*4个字节，为什么定义128？
//因为为了保证每个任务都能正常申请内存，128算冗余了
//此外官方提供了一个api函数，可以查询任务的堆栈使用量，用来确认定义128还是别的数字
TaskHandle_t    start_task_handler;
void start_task( void * pvParameters );

每个任务只会申请一次堆栈内存，不然的话一直申请，内存岂不是爆炸了吗？

void freertos_demo(void)
{    
    xTaskCreate((TaskFunction_t         )   start_task,//优先级最低1
                (char *                 )   "start_task",
                (configSTACK_DEPTH_TYPE )   START_TASK_STACK_SIZE,
                (void *                 )   NULL,
                (UBaseType_t            )   START_TASK_PRIO,
                (TaskHandle_t *         )   &start_task_handler );
    vTaskStartScheduler();//这句话代表开启了任务调度，说明开始任务进入就绪
                          //就绪之后直接进入运行态（如果没有被阻塞或者挂起）
}

2、开启临界区保护和不开启临界区保护的区别？

//void start_task( void * pvParameters )
//{
//    xTaskCreate((TaskFunction_t         )   task1,//优先级2
//                (char *                 )   "task1",
//                (configSTACK_DEPTH_TYPE )   TASK1_STACK_SIZE,
//                (void *                 )   NULL,
//                (UBaseType_t            )   TASK1_PRIO,
//                (TaskHandle_t *         )   &task1_handler );
//                
//    xTaskCreate((TaskFunction_t         )   task2,//优先级2
//                (char *                 )   "task2",
//                (configSTACK_DEPTH_TYPE )   TASK2_STACK_SIZE,
//                (void *                 )   NULL,
//                (UBaseType_t            )   TASK2_PRIO,
//                (TaskHandle_t *         )   &task2_handler );
//                
//    xTaskCreate((TaskFunction_t         )   task3,//优先级3，优先级最高
//                (char *                 )   "task3",
//                (configSTACK_DEPTH_TYPE )   TASK3_STACK_SIZE,
//                (void *                 )   NULL,
//                (UBaseType_t            )   TASK3_PRIO,
//                (TaskHandle_t *         )   &task3_handler );
//    vTaskDelete(NULL);//这句话是删除开始任务，而不是任务123（一共四个任务）
//    //为什么要删除呢？因为开始任务存在的目的就是创建task123，因此创建一次就行了，然后delete	
//}
上面开始任务的全过程是：首先创建开始任务->开启任务调度->执行开启任务->进入临界区关闭中断，保护数据->创建任务1
->任务1优先级高于start任务->开始任务被阻塞，执行任务1->任务1执行完之后，创建任务2->任务2继续阻塞开始任务，也阻塞任务1
->任务3创建了，它优先级最高，阻塞了所有任务->任务3执行完之后->删除开始任务->退出保护区，打开中断
->然后无限开始循环模式

结果就是：task1-task2-task3-按优先级执行    虽然task1优先级最低，但是它首先执行

//上面开始任务的全过程是：首先创建开始任务->开启任务调度->执行开启任务->进入临界区关闭中断，保护数据->创建任务1
//->任务1优先级高于start任务->开始任务被阻塞，执行任务1->任务1执行完之后，创建任务2->任务2继续阻塞开始任务，也阻塞任务1
//->任务3创建了，它优先级最高，阻塞了所有任务->任务3执行完之后->删除开始任务->退出保护区，打开中断
//->然后无限开始循环模式

在这里插入图片描述

结果就是：task1-task2-task3-按优先级执行 虽然task1优先级最低，但是它首先执行

在这里插入图片描述

/* 任务一，实现LED0每500ms翻转一次 */
void task1( void * pvParameters )
{
    while(1)
    {
        printf("task1正在运行！！！\r\n");
        LED0_TOGGLE();
        vTaskDelay(500);//被延时函数阻塞了
    }
}

/* 任务二，实现LED1每500ms翻转一次 */
void task2( void * pvParameters )
{
    while(1)
    {
        printf("task2正在运行！！！\r\n");
        LED1_TOGGLE();
        vTaskDelay(500);//被延时函数阻塞了
    }
}

void start_task( void * pvParameters )
{
    taskENTER_CRITICAL();               /* 进入临界区 */ //关闭总中断，为了保护数据不被别的中断影响
    //任务切换是在中断中进行的，此时你关闭了中断，那么任务之间不会切换（即任务调度无法执行）
    xTaskCreate((TaskFunction_t         )   task1,//优先级2
                (char *                 )   "task1",
                (configSTACK_DEPTH_TYPE )   TASK1_STACK_SIZE,
                (void *                 )   NULL,
                (UBaseType_t            )   TASK1_PRIO,
                (TaskHandle_t *         )   &task1_handler );
                
    xTaskCreate((TaskFunction_t         )   task2,//优先级2
                (char *                 )   "task2",
                (configSTACK_DEPTH_TYPE )   TASK2_STACK_SIZE,
                (void *                 )   NULL,
                (UBaseType_t            )   TASK2_PRIO,
                (TaskHandle_t *         )   &task2_handler );
                
    xTaskCreate((TaskFunction_t         )   task3,//优先级3，优先级最高
                (char *                 )   "task3",
                (configSTACK_DEPTH_TYPE )   TASK3_STACK_SIZE,
                (void *                 )   NULL,
                (UBaseType_t            )   TASK3_PRIO,
                (TaskHandle_t *         )   &task3_handler );
    vTaskDelete(NULL);//这句话是删除开始任务，而不是任务123（一共四个任务）
    //为什么要删除呢？因为开始任务存在的目的就是创建task123，因此创建一次就行了，然后delete	
    taskEXIT_CRITICAL();                /* 退出临界区 */ //开启总中断，其它中断可以运行了
    //打开了中断之后，才会再次开启任务调度
}
//上面开始任务的全过程是：首先创建开始任务->进入临界区关闭任务调度->依次创建任务123->删除开始任务->退出保护区，打开中断
//->开启任务调度->任务123按优先级顺序执行->然后无限开始循环模式

//结果就是：task3-task2-task1   task3优先级最高，所以它先执行

在这里插入图片描述
//结果就是：task3-task2-task1 task3优先级最高，所以它先执行

3、来自弹幕区的一个小问题？

在这里插入图片描述
在这里插入图片描述
有人问这个问题，我也感到很疑惑？（即没有“打印task12正在执行！！！”）
在这里插入图片描述
很好地回答了这个问题

4、demo函数（正点原子） 

/**
 ****************************************************************************************************
 * @file        freertos.c
 * @author      正点原子团队(ALIENTEK)
 * @version     V1.4
 * @date        2022-01-04
 * @brief       FreeRTOS 移植实验
 * @license     Copyright (c) 2020-2032, 广州市星翼电子科技有限公司
 ****************************************************************************************************
 * @attention
 *
 * 实验平台:正点原子 F407电机开发板
 * 在线视频:www.yuanzige.com
 * 技术论坛:www.openedv.com
 * 公司网址:www.alientek.com
 * 购买地址:openedv.taobao.com
 *
 ****************************************************************************************************
 */

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

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

/* START_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define START_TASK_PRIO         1
#define START_TASK_STACK_SIZE   128//128*4个字节，为什么定义128？
//因为为了保证每个任务都能正常申请内存，128算冗余了
//此外官方提供了一个api函数，可以查询任务的堆栈使用量，用来确认定义128还是别的数字
TaskHandle_t    start_task_handler;
void start_task( void * pvParameters );

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

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

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


/**
 * @brief       FreeRTOS例程入口函数
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{    
    xTaskCreate((TaskFunction_t         )   start_task,//优先级最低1
                (char *                 )   "start_task",
                (configSTACK_DEPTH_TYPE )   START_TASK_STACK_SIZE,
                (void *                 )   NULL,
                (UBaseType_t            )   START_TASK_PRIO,
                (TaskHandle_t *         )   &start_task_handler );
    vTaskStartScheduler();//这句话代表开启了任务调度，说明开始任务进入就绪
                          //就绪之后直接进入运行态（如果没有被阻塞或者挂起）
}
//void start_task( void * pvParameters )
//{
//    xTaskCreate((TaskFunction_t         )   task1,//优先级2
//                (char *                 )   "task1",
//                (configSTACK_DEPTH_TYPE )   TASK1_STACK_SIZE,
//                (void *                 )   NULL,
//                (UBaseType_t            )   TASK1_PRIO,
//                (TaskHandle_t *         )   &task1_handler );
//                
//    xTaskCreate((TaskFunction_t         )   task2,//优先级3
//                (char *                 )   "task2",
//                (configSTACK_DEPTH_TYPE )   TASK2_STACK_SIZE,
//                (void *                 )   NULL,
//                (UBaseType_t            )   TASK2_PRIO,
//                (TaskHandle_t *         )   &task2_handler );
//                
//    xTaskCreate((TaskFunction_t         )   task3,//优先级4，优先级最高
//                (char *                 )   "task3",
//                (configSTACK_DEPTH_TYPE )   TASK3_STACK_SIZE,
//                (void *                 )   NULL,
//                (UBaseType_t            )   TASK3_PRIO,
//                (TaskHandle_t *         )   &task3_handler );
//    vTaskDelete(NULL);//这句话是删除开始任务，而不是任务123（一共四个任务）
//    //为什么要删除呢？因为开始任务存在的目的就是创建task123，因此创建一次就行了，然后delete	
//}
上面开始任务的全过程是：首先创建开始任务->开启任务调度->执行开启任务->创建任务1
->任务1优先级高于start任务->开始任务被阻塞，执行任务1->任务1执行完之后，创建任务2->任务2继续阻塞开始任务，也阻塞任务1
->任务3创建了，它优先级最高，阻塞了所有任务->任务3执行完之后->删除开始任务
->然后无限开始循环模式

结果就是：task1-task2-task3-按优先级执行    虽然task1优先级最低，但是它首先执行

void start_task( void * pvParameters )
{
    taskENTER_CRITICAL();               /* 进入临界区 */ //关闭总中断，为了保护数据不被别的中断影响
    //任务切换是在中断中进行的，此时你关闭了中断，那么任务之间不会切换（即任务调度无法执行）
    xTaskCreate((TaskFunction_t         )   task1,//优先级2
                (char *                 )   "task1",
                (configSTACK_DEPTH_TYPE )   TASK1_STACK_SIZE,
                (void *                 )   NULL,
                (UBaseType_t            )   TASK1_PRIO,
                (TaskHandle_t *         )   &task1_handler );
                
    xTaskCreate((TaskFunction_t         )   task2,//优先级3
                (char *                 )   "task2",
                (configSTACK_DEPTH_TYPE )   TASK2_STACK_SIZE,
                (void *                 )   NULL,
                (UBaseType_t            )   TASK2_PRIO,
                (TaskHandle_t *         )   &task2_handler );
                
    xTaskCreate((TaskFunction_t         )   task3,//优先级4，优先级最高
                (char *                 )   "task3",
                (configSTACK_DEPTH_TYPE )   TASK3_STACK_SIZE,
                (void *                 )   NULL,
                (UBaseType_t            )   TASK3_PRIO,
                (TaskHandle_t *         )   &task3_handler );
    vTaskDelete(NULL);//这句话是删除开始任务，而不是任务123（一共四个任务）
    //为什么要删除呢？因为开始任务存在的目的就是创建task123，因此创建一次就行了，然后delete	
    taskEXIT_CRITICAL();                /* 退出临界区 */ //开启总中断，其它中断可以运行了
    //打开了中断之后，才会再次开启任务调度
}
//上面开始任务的全过程是：首先创建开始任务->->进入临界区关闭中断，保护数据，关闭任务调度->依次创建任务123->删除开始任务->退出保护区，打开中断
//->开启任务调度->任务123按优先级顺序执行->然后无限开始循环模式

//结果就是：task3-task2-task1   task3优先级最高，所以它先执行

/* 任务一，实现LED0每500ms翻转一次 */
void task1( void * pvParameters )
{
    while(1)
    {
        printf("task1正在运行！！！\r\n");
        LED0_TOGGLE();
        vTaskDelay(500);//被延时函数阻塞了
    }
}

/* 任务二，实现LED1每500ms翻转一次 */
void task2( void * pvParameters )
{
    while(1)
    {
        printf("task2正在运行！！！\r\n");
        LED1_TOGGLE();
        vTaskDelay(500);//被延时函数阻塞了
    }
}

/* 任务三，判断按键KEY0，按下KEY0删除task1 */
void task3( void * pvParameters )
{
    uint8_t key = 0;
    while(1)
    {
        printf("task3正在运行！！！\r\n");
        key = key_scan(0);
        if(key == KEY0_PRES)
        {
            if(task1_handler != NULL)
            {
                printf("删除task1任务\r\n");
                vTaskDelete(task1_handler);
                task1_handler = NULL;
            }

        }
        vTaskDelay(10);//被延时函数阻塞了
    }
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

（第9-10讲）STM32F4单片机，FreeRTOS任务创建和删除（动态方法）【视频笔记、代码讲解】【正点原子】【原创】 的相关文章

  • 计算机视觉算法——基于Transformer的语义分割（SETR / Segmenter / SegFormer）

    计算机视觉算法 基于Transformer的语义分割 xff08 SETR Segmenter SegFormer xff09 1 SETR1 1 网络结构及特点1 1 1 Decoder 1 2 实验 2 Segmenter2 1 网络结

  • 计算机视觉算法——基于深度学习的高精地图算法（HDMapNet / VectorMapNet / MapTR / VectorNet）

    计算机视觉算法 基于深度学习的高精地图算法 xff08 HDMapNet VectorMapNet MapTR VectorNet xff09 计算机视觉算法 基于深度学习的高精地图算法 xff08 HDMapNet VectorMapNe

  • VINS-Mono关键知识点总结——前端详解

    VINS Mono关键知识点总结 前端详解 VINS Mono关键知识点总结 前端详解1 VINS Mono的前端流程概述2 setMask 函数的作用3 rejectWithF 函数的作用4 addPoints 函数和 updataID

  • Px4源码框架结构图

    此篇blog的目的是对px4工程有一个整体认识 xff0c 对各个信号的流向有个了解 xff0c 以及控制算法采用的控制框架 PX4自动驾驶仪软件 可分为三大部分 xff1a 实时操作系统 中间件和飞行控制栈 1 NuttX实时操作系统 提

  • 深蓝学院《从零开始手写VIO》作业五

    深蓝学院 从零开始手写VIO 作业五 1 完成Bundle Adjustment求解器2 完成测试函数3 论文总结 1 完成Bundle Adjustment求解器 完成单目 Bundle Adjustment 求解器 problem cc

  • VIO在走廊弱纹理环境下的优化——VINS-Mono的点线紧耦合优化

    VIO在走廊弱纹理环境下的优化 VINS Mono的点线紧耦合优化 VIO在走廊弱纹理环境下的优化0 前言1 思路概述1 1 Super Pixel SLAM1 2 Edge SLAM1 3 PL SLAM 2 算法实施2 1 Edge S

  • SLAM综述：激光雷达与视觉SLAM（2019.10.12）

    本文基于https arxiv org pdf 1909 05214v2 pdf 进行阐述 xff08 其实差不多就是精简版翻译 xff09 第一节概述 第二节讲述激光SLAM xff1a 激光传感器 xff0c 开源系统 xff0c 深度

  • HAL库串口收发

    1 通讯方式介绍 在微处理器和外部通信模块之间主要有并行通信和串行通信两种 并行通讯传输速率快 xff0c 但是占用引脚较多 xff0c 串行通信与之相反 串行通讯分别有单工 半双工 全双工三种模式 单工 xff1a 只能发送数据或者只能接

  • ros 启动

    绑定usb设备端口号 11条消息 Ubuntu下绑定串口的两种方式ID法和serial法 haley du的博客 CSDN博客 11条消息 Ubuntu usb设备端口号绑定 一抹烟霞的博客 CSDN博客 2 2执行 1 执行相关launc

  • c++中“::“表示含义

    1 表示 域操作符 例 xff1a 声明了一个类A xff0c 类A里声明了一个成员函数void f xff0c 但没有在类的声明里给出f的定义 xff0c 那么在类外定义f时 xff0c 就要写成void A f xff0c 表示这个f

  • ROS自学笔记整合-串口通信篇

    ROS自学笔记整合 串口通信篇 最近也是刚开始接触ROS xff0c 然后买了一本古月大神的 ROS机器人开发实践 自己在捣鼓 本人编程小白 xff0c 只能做代码的搬运工 书本上的仿真基本都看的差不多了 xff0c 也动手做了不少例子 x

  • docker宿主机ssh免密

    若要实现免密登陆 xff0c 意味着无论是宿主机 xff0c 还是容器都要彼此交互公钥 xff1a 容器A发送自身公钥给中心机器 xff0c 统一由中心机器 xff0c 回发全部需要ssh到容器A的公钥信息 xff0c 任何一个新加入的容器

  • redis指定配置文件启动失败

    redis指定配置文件启动失败 redis指定配置文件启动失败 redis server redis conf失败 但是直接执行redis server是可以成功的 之所以没有启动成功 xff0c 且没有报错的原因是 在自己的redis c

  • Ubuntu 查看磁盘空间及目录容量

    Ubuntu 查看磁盘空间及目录容量 http www zhcn org 548 Df命令是linux系统以磁盘分区为单位查看文件系统 xff0c 可以加上参数查看磁盘剩余空间 xff1a df hl 显示格式为 xff1a 文件系统 容量

  • VS(Visual Studio)与VC(Visual C++)版本对应关系

    VS全名是Microsoft Visual Studio xff0c 是很大的一个开发环境 xff0c 包含很多高级语言的开发环境 xff0c VC只是VS其中的一个开发环境 VC版本与VS版本对应关系如下所示 xff1a Visual S

  • docker 状态Removal In Progress，rm提示无法删除

    docker 无法删除场景 docker 进入Removal In Progress状态 xff0c 无法直接删除 1 docker rm f 容器 提示文件无权限操作 2 xxxx 表示上图的文件路径 需要登录到宿主机上 xff0c 执行

  • windows上安装启动pgsql,postgres

    windows上安装启动pgsql postgres 1 在官网下载pgsql2 进入pgsql的安装目录 bin 下面3 windows 启动 pgsql server cmd窗口退出 server关闭4 注册成服务 cmd窗口退出 se

  • django调试问题django.core.exceptions.ImproperlyConfigured

    django项目调试子应用app时提示缺少配置 1 项目的settings文件里面设置的有子app xff0c 依旧提示下面问题 django core exceptions ImproperlyConfigured Requested s

  • Python 数据描述符

    今天看到一篇文档介绍了Python描述符 xff0c 转发学习下 1 默认的属相访问是从对象的字典中 get set 或者 delete 属性 xff1b 例如a x的查找顺序是 a x gt a dict x gt type a dict

  • pycharm中terminal中使用git bash替换cmd（无弹窗）

    pycharm中terminal中使用git bash替换cmd 1 背景 系统 xff1a windows 想要在pycharm上的terminal中使用git bash而不是系统自带的cmd 可以调用基础的Linux命令 比如ls 等

随机推荐

热门标签