基于stm32的FreeRTOS操作系统_stm32 freertos

1. 任务的创建与删除

1.1 什么是任务？

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

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

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

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
2
3

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
1
2
3
4
5

4.3.2 写队列

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

返回值：
如果成功写入数据，返回 pdTRUE，否则返回 errQUEUE_FULL
1
2
3
4
5
6
7
8
9
10

4.3.3 读队列

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

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 。
1
2
3
4

5.4.2 释放二值信号量

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

5.4.3 获取二值信号量

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

使用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 。
1
2
3
4
5
6
7
8
9

6.2.2 释放信号量

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

6.2.3 创建计数型信号量

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

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 。
1
2
3
4
5
6

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 。
1
2
3
4
5
6

8.2.2 设置事件标志位

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

8.2.3 清除事件标志位

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

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：超时
返回值：
等待的事件标志位值：等待事件标志位成功，返回等待到的事件标志位
其他值：等待事件标志位失败，返回事件组中的事件标志位
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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：等待消息通知的最大等待时间。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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 */
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

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 */
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

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 */
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46