基于stm32的FreeRTOS操作系统

已于 2024-05-14 09:20:13 修改
阅读量579 收藏 27
点赞数 11
文章标签： stm32 网络 服务器
于 2024-05-13 12:46:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39855356/article/details/138744365
版权

基于stm32的FreeRTOS操作系统

1. 任务的创建与删除

1.1 什么是任务？

简单来说任务FreeRTOS中就是一个无限循环无法返回的函数，在多任务系统中，我们根据功能的不同，把整个系统分割成一个个独立的且无法返回的函数，这个函数我们称为任务，一个任务负责项目的一块功能，每个任务都有一个独立的栈。
每个任务函数需要满足以下要求：

  1. 这个函数不能返回，无限循环。
  2. 同一个函数，可以用来创建多个任务；换句话说，多个任务可以运行同一个函数。
  3. 每个任务都有自己的栈，每个任务运行这个函数时任务A的局部变量放在任务A的栈里、任务B的局部变量放在任务B的栈里，函数内部所有栈的开销都是使用任务自己的栈。
  4. 函数使用的全局变量、静态变量存放在内存的某个区域，所有任务共用，不过要防止使用冲突，所以尽量使用局部变量。

1.2 任务创建与删除相关函数

函数名称函数作用
xTaskCreate()动态方式创建任务
xTaskCreateStatic()静态方式创建任务
vTaskDelete()删除任务

1.2.1 xTaskCreate（）原型

在这里插入图片描述

  1. pvTaskCode：指向任务函数的指针，任务必须实现为永不返回（即连续循环）；
  2. pcName：任务的名字，主要是用来调试，默认情况下最大长度是16；
  3. pvParameters：指定的任务栈的大小；
  4. uxPriority：任务优先级，数值越大，优先级越大；
  5. pxCreatedTask：用于返回已创建任务的句柄可以被引用。
  6. 返回值：pdPASS ----- 任务创建成功
    errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY ----- 任务创建失败

1.2.2 vTaskDelete（）原型

void vTaskDelete(TaskHandle_t xTaskToDelete);
只需将待删除的任务句柄传入该函数，即可将该任务删除。
当传入的参数为NULL，则代表删除任务自身（当前正在运行的任务）。

1.3 任务动态创建与静态创建的区别

本质的区别就是静态创建需要自己定义栈和TCB，而动态创建任务是malloc函数分配的栈和TCB。
静态创建的任务即使任务被删除了，它的栈和TCB所占的内存空间=不能被回收，而动态创建的任务结束后会自动被操作系统回收(其实就是调用了free函数释放内存)

1.4 实操

在这里插入图片描述
在这里插入图片描述

2.任务的调度

2.1 什么是任务调度？

调度器就是使用相关的调度算法来决定当前需要执行的哪个任务。
FreeRTOS中开启任务调度的函数是 vTaskStartScheduler() ，
但在 CubeMX 中被封装为osKernelStart() 。

2.2 FreeRTOS的任务调度规则是怎样的？

FreeRTOS 是一个实时操作系统，它所奉行的调度规则：

  1. 高优先级抢占低优先级任务，系统永远执行最高优先级的任务（即抢占式调度）
  2. 同等优先级的任务轮转调度（即时间片调度）
    还有一种调度规则是协程式调度，但官方已明确表示不更新，主要是用在小容量的芯片上，用得也不多。

2.2.1 抢占式调度运行过程

在这里插入图片描述

  1. 高优先级任务，优先执行；
  2. 高优先级任务不停止，低优先级任务无法执行；
  3. 被抢占的任务将会进入就绪态

2.2.2 时间片调度运行过程

在这里插入图片描述

  1. 同等优先级任务，轮流执行，时间片流转；
  2. 一个时间片大小，取决为滴答定时器中断周期；
  3. 注意没有用完的时间片不会再使用，下次任务 Task3 得到执行，还是按照一个时间片的时钟节拍运行

3.任务的状态

3.1 简介

FreeRTOS中任务共存在4种状态：

  • Running 运行态
    当任务处于实际运行状态称之为运行态，即CPU的使用权被这个任务占用（同一时间仅一个任务处于运行态）。
  • Ready 就绪态
    处于就绪态的任务是指那些能够运行（没有被阻塞和挂起），但是当前没有运行的任务，因为同优先级或更高优先级的任务正在运行。
  • Blocked 阻塞态
    如果一个任务因延时，或等待信号量、消息队列、事件标志组等而处于的状态被称之为阻塞态。
  • Suspended 挂起态
    类似暂停，通过调用函数 vTaskSuspend() 对指定任务进行挂起，挂起后这个任务将不被执行，只有调用函数 xTaskResume() 才可以将这个任务从挂起态恢复。
    在这里插入图片描述
  1. 仅就绪态可转变成运行态
  2. 其他状态的任务想运行，必须先转变成就绪态

3.2 实操

实验需求
创建 4 个任务：taskLED1，taskLED2，taskKEY1，taskKEY2，任务要求如下：
taskLED1：间隔 500ms 闪烁 LED1；
taskLED2：间隔 1000ms 闪烁 LED2；
taskKEY1：如果 taskLED1 存在，则按下 KEY1 后删除 taskLED1 ，否则创建 taskLED1 ；
taskKEY2：如果 taskLED2 正常运行，则按下 KEY2 后挂起 taskLED2 ，否则恢复 taskLED2。

在这里插入图片描述
在这里插入图片描述

4. 队列

4.1 什么是队列？

队列又称消息队列，是一种常用于任务间通信的数据结构，队列可以在任务与任务间、中断和任务间传递信息。

4.2 队列的特点

  1. 数据入队出队方式
    通常采用先进先出（FIFO）的数据存储缓冲机制，即先入队的数据会先从队列中被读取。
    也可以配置为后进先出（LIFO）方式，但用得比较少。
  2. 数据传递方式
    采用实际值传递，即将数据拷贝到队列中进行传递，也可以传递指针，在传递较大的数据的时候采用指针传递。
  3. 多任务访问
    队列不属于某个任务，任何任务和中断都可以向队列发送/读取消息
  4. 出队、入队阻塞
    当任务向一个队列发送消息时，可以指定一个阻塞时间，假设此时当队列已满无法入队。
    阻塞时间如果设置为：
    0：直接返回不会等待；
    0~port_MAX_DELAY：等待设定的阻塞时间，若在该时间内还无法入队，超时后直接返回不再等待；
    port_MAX_DELAY：死等，一直等到可以入队为止。出队阻塞与入队阻塞类似；

4.3 队列相关 API 函数

4.3.1 创建队列

QueueHandle_t xQueueCreate( UBaseType_t uxQueueLength,UBaseType_t uxItemSize );
uxQueueLength：队列可同时容纳的最大项目数 。
uxItemSize：存储队列中的每个数据项所需的大小（以字节为单位）。
返回值：
如果队列创建成功，则返回所创建队列的句柄 。 如果创建队列所需的内存无法分配 ，则返回 NULL

4.3.2 写队列

BaseType_t xQueueSend(QueueHandle_t xQueue , 
                      const void * pvItemToQueue , 
                      TickType_t xTicksToWait
                      );
xQueue：队列的句柄，数据项将发送到此队列。
pvItemToQueue：待写入数据
xTicksToWait：阻塞超时时间

返回值：
如果成功写入数据，返回 pdTRUE，否则返回 errQUEUE_FULL

4.3.3 读队列

BaseType_t xQueueReceive(QueueHandle_t xQueue , 
                         void *pvBuffer , 
                         TickType_t xTicksToWait
                         );
xQueue：待读取的队列
pvItemToQueue：数据读取缓冲区
xTicksToWait：阻塞超时时间
返回值：成功返回 pdTRUE，否则返回 pdFALSE。

4.4 实操

实验需求：创建一个队列，按下 KEY1 向队列发送数据，按下 KEY2 向队列读取数据。
在这里插入图片描述
在这里插入图片描述
发送多少个队列信息，最多可以接收多少队列信息。不可以大于16个队列。

5. 二值信号量

5.1 什么是信号量？

信号量（Semaphore）是一种实现任务间通信的机制，可以实现任务之间同步或临界资源的互斥访问。
所谓二值信号量其实就是一个队列长度为1，没有数据存储器的队列，而二值则表示计数值uxMessagesWaiting只有0和1两种状态(就是队列空与队列满两种情况)，uxMessagesWaiting在队列中表示队列中现有消息数量，而在信号量中则表示信号量的数量。

xMessagesWaiting为0表示：信号量资源被获取了.
uxMessagesWaiting为1表示：信号量资源被释放了
把这种只有 0 和 1 两种情况的信号量称之为二值信号量。

5.2 什么是同步与互斥？

  1. 同步
    比如说，买包子
    我要去买包子，如果包子店没有包子了，则需要等待卖包子的把包子做出来我才能买到包子，这个等待的过程就叫做同步。(在实际应用中：一个采集数据的传感器任务，一个处理数据的任务，则处理数据的任务需要等待传感器去采用数据，则在FreeRTOS系统中等待不能干等着，在该任务等待的过程中，CPU转而可以去执行其他任务，则就可以提高效率，则就是队列的阻塞机制)
  2. 互斥
    比如说，抢厕所
    厕所只有一个，一个人进去上了，另一个人也要上，则必须等待前人上完厕所才能上，等待的过程就是同步，而保护厕所的过程叫做互斥，则厕所就是所谓临界资源，同一时间只能一个人使用厕所，当然前人上完厕所应该提醒等待的人，厕所用完了可以上了，其中本质也是阻塞机制。

5.3 二值信号量

二值信号量其实就是一个长度为1，大小为零的队列，只有0和1两种状态，通常情况下，我们用它来进行互斥访问或任务同步。
在这里插入图片描述

5.4 二值信号量相关 API 函数

5.4.1 创建二值信号量

SemaphoreHandle_t xSemaphoreCreateBinary( void )
返回值：
成功，返回对应二值信号量的句柄；
失败，返回 NULL 。

5.4.2 释放二值信号量

BaseType_t xSemaphoreGive( SemaphoreHandle_t xSemaphore )
参数：
xSemaphore：要释放的信号量句柄
返回值：
成功，返回 pdPASS ；
失败，返回 errQUEUE_FULL 。

5.4.3 获取二值信号量

BaseType_t xSemaphoreTake( SemaphoreHandle_t xSemaphore,
                           TickType_t xTicksToWait 
                           );
参数：
xSemaphore：要获取的信号量句柄
xTicksToWait：超时时间，0 表示不超时，portMAX_DELAY表示卡死等待；
返回值：
成功，返回 pdPASS ；
失败，返回 errQUEUE_FULL 。

使用xSemaphoreCreateBinary创建二值信号量默认的初始值是 0，也就是没有可用资源。
引用另一个博客的文章
在这里插入图片描述
运行条件：
创建 2 个任务 Task1 和 Task2。
创建二值信号量默认的初始值是 0，也就是没有可用资源。

运行过程描述如下：
任务 Task1 运行过程中调用函数 xSemaphoreTake 获取信号量资源，但是由于创建二值信号的初始值是 0，没有信号量可以用，任务 Task1 将由运行态转到阻塞状态。
运行的过程中，任务 Task2 通过函数 xSemaphoreGive 释放信号量，任务 Task1 由阻塞态进入到就绪态，在调度器的作用下由就绪态又进入到运行态，实现Task1与Task2的同步功能。

5.5 实操

在这里插入图片描述
在这里插入图片描述
STM32Cube生成的FreeRTos代码创建二值信号量时，默认为1，此处释放避免串口误同步在这里插入图片描述

6. 计数型信号量

6.1 什么是计数型信号量？

计数型信号量相当于队列长度大于1 的队列，因此计数型信号量能够容纳多个资源，这在计数型信号量被创建的时候确定的。
在这里插入图片描述
在这里插入图片描述

6.2 计数型信号量相关 API 函数

6.2.1 获取信号量

BaseType_t xSemaphoreTake( SemaphoreHandle_t xSemaphore,
                           TickType_t xTicksToWait 
                           );
参数：
xSemaphore：要获取的信号量句柄
xTicksToWait：超时时间，0 表示不超时，portMAX_DELAY表示卡死等待；
返回值：
成功，返回 pdPASS ；
失败，返回 errQUEUE_FULL 。

6.2.2 释放信号量

BaseType_t xSemaphoreGive( SemaphoreHandle_t xSemaphore )
参数：
xSemaphore：要释放的信号量句柄
返回值：
成功，返回 pdPASS ；
失败，返回 errQUEUE_FULL 。

6.2.3 创建计数型信号量

SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount,
											UBaseType_t uxInitialCount
											);
参数：
uxMaxCount：可以达到的最大计数值
uxInitialCount：创建信号量时分配给信号量的计数值
返回值：
成功，返回对应计数型信号量的句柄；
失败，返回 NULL 。

6.3 实操

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

7. 互斥量

7.1 什么是互斥量？

在多数情况下，互斥型信号量和二值型信号量非常相似，但是从功能上二值型信号量用于同步，而互斥型信号量用于资源保护。
互斥型信号量和二值型信号量还有一个最大的区别，互斥型信号量可以有效解决优先级反转现象。

7.2 什么是优先级翻转？

在这里插入图片描述
以上图为例，系统中有3个不同优先级的任务H/M/L，最高优先级任务H和最低优先级任务L通过信号量机制，共享资源。目前任务L占有资源，锁定了信号量，Task H运行后将被阻塞，直到Task L释放信号量后，Task H才能够退出阻塞状态继续运行。但是Task H在等待Task L释放信号量的过程中，中等优先级任务M抢占了任务L，从而延迟了信号量的释放时间，导致Task H阻塞了更长时间，这种现象称为优先级倒置或反转。
优先级继承：当一个互斥信号量正在被一个低优先级的任务持有时， 如果此时有个高优先级的任务也尝试获取这个互斥信号量，那么这个高优先级的任务就会被阻塞。不过这个高优先级的任务会将低优先级任务的优先级提升到与自己相同的优先级。优先级继承并不能完全的消除优先级翻转的问题，它只是尽可能的降低优先级翻转带来的影响。

7.3 互斥量相关 API 函数

SemaphoreHandle_t xSemaphoreCreateMutex( void )
参数：
无
返回值：
成功，返回对应互斥量的句柄；
失败，返回 NULL 。

7.4 实操

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
为了解决这一问题，采用互斥量！！！
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

8. 事件标志组

8.1 什么是事件标志组？

事件标志位：表明某个事件是否发生，联想：全局变量 flag。通常按位表示，每一个位表示一个事件（高8位不算）
事件标志组是一组事件标志位的集合，可以简单的理解事件标志组，就是一个整数。
事件标志组本质是一个 16 位或 32 位无符号的数据类型 EventBits_t ，由 configUSE_16_BIT_TICKS 决定。
虽然使用了 32 位无符号的数据类型变量来存储事件标志， 但其中的高8位用作存储事件标志组的控制信息，低 24 位用作存储事件标志 ，所以说一个事件组最多可以存储 24 个事件标志。
在这里插入图片描述

8.2 事件标志组相关 API 函数

8.2.1 创建事件标志组

EventGroupHandle_t xEventGroupCreate( void );
参数：
无
返回值：
成功，返回对应事件标志组的句柄；
失败，返回 NULL 。

8.2.2 设置事件标志位

EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
								const EventBits_t uxBitsToSet 
								);
参数：
xEventGroup：对应事件组句柄。
uxBitsToSet：指定要在事件组中设置的一个或多个位的按位值。
返回值：
设置之后事件组中的事件标志位值。

8.2.3 清除事件标志位

EventBits_t xEventGroupClearBits(EventGroupHandle_t xEventGroup,
								 const EventBits_t uxBitsToClear 
								 );
参数：
xEventGroup：对应事件组句柄。
uxBitsToClear：指定要在事件组中清除的一个或多个位的按位值。
返回值：
清零之前事件组中事件标志位的值。

8.2.4 等待事件标志位

EventBits_t xEventGroupWaitBits(const EventGroupHandle_t xEventGroup,
								const EventBits_t uxBitsToWaitFor,
								const BaseType_t xClearOnExit,
								const BaseType_t xWaitForAllBits,
								TickType_t xTicksToWait
								 );
参数： 	
xEventGroup：对应的事件标志组句柄
uxBitsToWaitFor：指定事件组中要等待的一个或多个事件位的按位值
xClearOnExit：pdTRUE——清除对应事件位，pdFALSE——不清除
xWaitForAllBits：pdTRUE——所有等待事件位全为1（逻辑与），pdFALSE——等待的事件位有一个为1（逻辑或）
xTicksToWait：超时
返回值：
等待的事件标志位值：等待事件标志位成功，返回等待到的事件标志位
其他值：等待事件标志位失败，返回事件组中的事件标志位

8.3 实操

实验需求
创建一个事件标志组和两个任务（ task1 和 task2），task1 检测按键，如果检测到 KEY1 和 KEY2 都按过，则执行 task2 。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

9. 任务通知

9.1 什么是任务通知？

FreeRTOS 从版本 V8.2.0开始提供任务通知这个功能，每个任务都有一个32位的通知值。按照 FreeRTOS官方的说法，使用消息通知比通过二进制信号量方式解除阻塞任务快45%，并且更加省内存（无需创建队列）。
在大多数情况下，任务通知可以替代二值信号量、计数信号量、事件标志组，可以替代长度为 1 的队列（可以保存一个 32 位整数或指针值），并且任务通知速度更快、使用的RAM更少！

9.2 任务通知值的更新方式

FreeRTOS 提供以下几种方式发送通知给任务 ：

  • 发送消息给任务，如果有通知未读， 不覆盖通知值
  • 发送消息给任务，直接覆盖通知值
  • 发送消息给任务，设置通知值的一个或者多个位
  • 发送消息给任务，递增通知值

通过对以上方式的合理使用，可以在一定场合下替代原本的队列、信号量、事件标志组等。

9.3 任务通知相关 API 函数

9.3.1 发送通知

//发送通知，带有通知值
BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify,
						uint32_t ulValue,
						eNotifyAction eAction 
						);
参数：
xTaskToNotify：需要接收通知的任务句柄；
ulValue：用于更新接收任务通知值， 具体如何更新由形参 eAction 决定；
eAction：一个枚举，代表如何使用任务通知的值；
返回值：
如果被通知任务还没取走上一个通知，又接收了一个通知，则这次通知值未能更新并返回 pdFALSE， 而其他
情况均返回pdPASS。

//发送通知，带有通知值并且保留接收任务的原通知值
BaseType_t xTaskNotifyAndQuery( TaskHandle_t xTaskToNotify,
								uint32_t ulValue,
								eNotifyAction eAction,
								uint32_t *pulPreviousNotifyValue 
								);
参数：
xTaskToNotify：需要接收通知的任务句柄；
ulValue：用于更新接收任务通知值， 具体如何更新由形参 eAction 决定；
eAction：一个枚举，代表如何使用任务通知的值；
pulPreviousNotifyValue：对象任务的上一个任务通知值，如果为 NULL， 则不需要回传， 这个时候就等价
于函数 xTaskNotify()。
返回值：
如果被通知任务还没取走上一个通知，又接收了一个通知，则这次通知值未能更新并返回 pdFALSE， 而其他
情况均返回pdPASS。

//发送通知，不带通知值
BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );
参数：
xTaskToNotify：接收通知的任务句柄， 并让其自身的任务通知值加 1。
返回值：
总是返回 pdPASS。

9.3.2 等待通知

uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit,
							TickType_t xTicksToWait 
							);
参数：
xClearCountOnExit：指定在成功接收通知后，将通知值清零或减 1，pdTRUE：把通知值清零（二值信号
量）；pdFALSE：把通知值减一（计数型信号量）；
xTicksToWait：阻塞等待任务通知值的最大时间；
返回值：
0：接收失败
非0：接收成功，返回任务通知的通知值

BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry,    （正常情况不清0 ---0）
							uint32_t ulBitsToClearOnExit,								(要清零，所有位都为1 --0xffffffff)
							uint32_t *pulNotificationValue,
							TickType_t xTicksToWait 
							);
ulBitsToClearOnEntry：函数执行前清零任务通知值那些位 。
ulBitsToClearOnExit：表示在函数退出前，清零任务通知值那些位，在清 0 前，接收到的任务通知值会先被
保存到形参*pulNotificationValue 中。
pulNotificationValue：用于保存接收到的任务通知值。 如果 不需要使用，则设置为 NULL 即可 。
xTicksToWait：等待消息通知的最大等待时间。

9.4 实操

9.4.1 模拟二值信号量

在这里插入图片描述
在这里插入图片描述

void StartTaskSend(void const * argument)
{
  /* USER CODE BEGIN StartTaskSend */
  /* Infinite loop */
  for(;;)
  {
    if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
    {
        osDelay(20);
        if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
        {
            xTaskNotifyGive(TaskReceiveHandle);
            printf("任务通知：模拟二值信号量发送成功\r\n");
        }
        while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET);
    }
    osDelay(10);
  }
  /* USER CODE END StartTaskSend */
}

void StartTaskReceive(void const * argument)
{
  /* USER CODE BEGIN StartTaskReceive */
    uint32_t rev = 0;
  /* Infinite loop */
  for(;;)
  {
    if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)
    {
        osDelay(20);
        if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)
        { 
            rev = ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
            if(rev != 0)
                printf("任务通知：模拟二值信号量接收成功\r\n");
        }
        while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET);
    }
    osDelay(10);
  }
  /* USER CODE END StartTaskReceive */
}

9.4.2 模拟计数型信号量

在这里插入图片描述

9.4.3 模拟事件标志组

void StartTaskSend(void const * argument)
{
  /* USER CODE BEGIN StartTaskSend */
  /* Infinite loop */
  for(;;)
  {
    if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
    {
        osDelay(20);
        if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
        {
            printf("将bit0位置1\r\n");
            xTaskNotify(TaskReceiveHandle,0x01,eSetBits);
        }
        while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET);
    }
    
    if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)
    {
        osDelay(20);
        if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)
        {
            printf("将bit1位置1\r\n");
            xTaskNotify(TaskReceiveHandle,0x02,eSetBits);
        }
        while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET);
    }
    osDelay(10);
  }
  /* USER CODE END StartTaskSend */
}

void StartTaskReceive(void const * argument)
{
  /* USER CODE BEGIN StartTaskReceive */
    uint32_t notify_val = 0,event_bit = 0;   
  /* Infinite loop */
  for(;;)
  {
      xTaskNotifyWait(0,0xFFFFFFFF,&notify_val,portMAX_DELAY);
      if(notify_val & 0x01)
          event_bit |= 0x01;
      if(notify_val & 0x02)
          event_bit |= 0x02;
      if(event_bit == (0x01 | 0x02))
      {
          printf("任务通知模拟事件标志组接收成功\r\n");
          event_bit = 0;
      }
    osDelay(10);
  }
  /* USER CODE END StartTaskReceive */
}

9.4.4 模拟邮箱

void StartTaskSend(void const * argument)
{
  /* USER CODE BEGIN StartTaskSend */
  /* Infinite loop */
  for(;;)
  {
    if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
    {
        osDelay(20);
        if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
        {
            printf("按键1按下\r\n");
            xTaskNotify(TaskReceiveHandle,1,eSetValueWithoutOverwrite);
        }
        while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET);
    }
    
    if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)
    {
        osDelay(20);
        if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)
        {
            printf("按键2按下\r\n");
            xTaskNotify(TaskReceiveHandle,2,eSetValueWithoutOverwrite);
        }
        while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET);
    }
    osDelay(10);
  }
  /* USER CODE END StartTaskSend */
}


void StartTaskReceive(void const * argument)
{
  /* USER CODE BEGIN StartTaskReceive */
    uint32_t notify_val = 0,event_bit = 0;   
  /* Infinite loop */
  for(;;)
  {
      xTaskNotifyWait(0,0xFFFFFFFF,&notify_val,portMAX_DELAY);
      printf("接收到的通知值为：%d\r\n",notify_val);
    osDelay(10);
  }
  /* USER CODE END StartTaskReceive */
}
小强子！
关注
  • 11
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
FreeRTOS基于STM32单片机
m0_69225476的博客
08-07 924
FreeRTOS,操作系统。
基于stm32f103移植freertos
01-04
基于stm32f103移植freertos
FreeRTOS实时操作系统 —基于STM32
Naiva的博客
09-07 3571
前在使用 51、AVR、STM32 单片机裸机(未使用系统)的时候一般都是在main 函数里面用 while(1)做一个大循环来完成所有的处理，即应用程序是一个无限的循环，循环中调用相应的函数完成所需的处理。有时候我们也需要中断中完成一些处理。相对于多任务系统而言，这个就是单任务系统，也称作前后台系统，中断服务函数作为前台程序，大循环while(1)作为后台程序。前后台系统的实时性差，前后台系统各个任务(应用程序)都是排队等着轮流执行，不管你这个程序现在有多紧急，没轮到你就只能等着！
STM32操作系统FreeRTOS学习——基于hal库
weixin_64207326的博客
06-02 4813
在 FreeRTOS 中，定义变量的时候往往会把变量的类型当作前缀加在变量上， 这样的好处是让用户一看到这个变量就知道该变量的类型。比如 char 型变量的前缀是 c， short 型变量的前缀是 s， long 型变量的前缀是 l， portBASE_TYPE 类型变量的前缀是 x。还有其他的数据类型，比如数据结构，任务句柄， 队列句柄等定义的变量名的前缀也是 x。如果一个变量是无符号型的那么会有一个前缀 u， 如果是一个指针变量则会有一个前缀 p。
使用STM32CubeMx完成FreeRTOS操作系统移植
anyi66622的博客
04-27 3580
通过STM32CUBEMX创建新工程，移植官方库文件实现FREERTOS系统移植
基于STM32F407芯片FreeRTOS操作系统设计的云台色彩追踪系统
11-05
本程序是基于STM32F407芯片FreeRTOS操作系统设计的云台色彩追踪系统，采用树莓派，外置摄像头，视觉处理部分采用OPENCV库处理。 通过树莓派外置USB3.0串口通信到STM32，来操作云台追踪物体。 版本：V1.1 1. 可以在...
stm32+freemodbusRTU+freertos+主机/从机
03-16
stm32l151移植freemodbus协议，搭配freertos实现主/从机代码
STM32FreeRTOS:为STM32实现的实时操作系统
03-11
用于Arduino的STM32 FreeRTOS库 这是用于STM32的FreeRTOS的端口，作为Arduino库。 有关FreeRTOS的更多信息，请访问。 另外，请参阅非常有用的“ 页面。 该库提供3个FreeRTOS版本： 两者均已由ST修改（请参见...
基于STM32和FreeRTOS的智能门锁（技术资料）.zip
03-19
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料...基于STM32和FreeRTOS的智能门锁（技术资料）.zip
STM32快速入门（ADC数模转换）
m0_52566365的博客
06-09 1394
STM32对实现ADC数模转换的原理进行讲解
【STM32】输入捕获应用-测量脉宽或者频率（方法1）
GY3509
06-12 410
CCR 中，并再次进入捕获中断，在捕获中断中，把捕获寄存器的值读取到value2 中，并清除捕获。当捕获通道TIx 上出现上升沿时，发生第一次捕获，计数器CNT 的值会被锁存到捕获寄存器CCR。然后把捕获边沿改变为下降沿捕获，目的是捕获后面的。中，而且还会进入捕获中断，在中断服务程序中记录一次捕获（可以用一个标志变量来记录），并。的值会再次被锁存到捕获寄存器CCR 中，并再次进入捕获中断，在捕获中断中，把捕获寄存器。中，而且还会进入捕获中断，在中断服务程序中记录一次捕获（可以用一个标志变量来记录），并。
【电机控制】FOC算法验证步骤——PWM、ADC
qq_42681425的博客
06-09 1814
【电机控制】直流有刷电机、无刷电机汇总——持续更新使用工具：1.示波器：PICO7提示：以下是本篇文章正文内容，下面案例可供参考本文仅仅简单介绍了【电机控制】FOC算法验证步骤，评论区欢迎讨论。
STM32程序启动过程
世间所有的相遇都是久别重逢
06-13 374
（2）然后执行复位中断，在复位中断服务程序中跳转 C/C++标准实时库的main函数(__main)，完成用户堆栈等的初始化后，跳转.c 文件中的main函数(真正的用户main函数)开始执行程序。（1）首先对栈和堆的大小进行定义，并在代码区的起始处建立中断向量表，其第一个表项是栈顶地址（32位），第二个表项是复位中断服务入口地址；
stm32_HAL_CAN(特点：广播试，检测线路是否空，id有优先级)
qq_59527512的博客
06-13 785
CAN（Controller Area Network）接口是一种常用于嵌入式系统中的通信接口，尤其在汽车和工业领域。它由Robert Bosch GmbH在1986年开发，旨在提供一种可靠、高效、灵活的车载通信网络。CAN总线的主要/*** CAN 发送一组数据* 数据 长度*///发的结构体// 数据长度代码// 扩展标识符// 标识符类型为扩展帧 //标识符的长度// 远程传输请求为数据帧// 标准标识符 //can的ID。
STM32-17-DAC
L的博客
06-13 1006
b本文包含DAC的基础知识。包括DAC简介、DAC工作原理、DAC输出实验、DAC输出三角波实验、DAC输出正弦波实验、PWM DAC实验。
面向云计算平台的信息安全等级保护测评实践与建议
最新发布
ddcajdkdl的博客
06-14 670
面向云计算平台的信息安全等级保护测评是一项系统工程，需要政府、云服务商、用户及第三方测评机构等多方共同努力，通过持续的技术创新与管理优化，确保云计算环境下的信息安全，为数字经济发展提供坚实的安全保障。
Linux网络编程（二）Socket编程
Oafz的博客
06-12 319
【代码】Linux网络编程（二）Socket编程。
stm32f103freertos操作系统
03-16
STM32F103是一款基于ARM Cortex-M3内核的微控制器，而FreeRTOS是一款开源的实时操作系统。在STM32F103上使用FreeRTOS可以提高系统的可靠性和稳定性，同时也可以方便地实现多任务处理和资源管理。通过使用FreeRTOS，开发者可以将系统分解为多个独立的任务，每个任务都有自己的优先级和调度算法，从而实现更加高效的系统运行。同时，FreeRTOS还提供了丰富的API和工具，方便开发者进行任务管理、内存管理、时间管理等操作。因此，STM32F103FreeRTOS操作系统是一种非常实用的嵌入式系统开发方案。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小强子！

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

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

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

打赏作者

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

抵扣说明：

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

余额充值