FreeRTOS

Aspiring Q

1851人浏览 · 2025-03-15 10:21:37

Aspiring Q · 2025-03-15 10:21:37 发布

FreeRTOS

1 课程视频

（1）FreeRTOS操作系统本课程主要讲实操。

2 FreeRTOS介绍

（1）Free即免费的，RTOS的全称是Real time operating system，中文就是实时操作系统。uc/OS，FreeRTOS，RTX，RT-Thread等这些都是RTOS类操作系统。
（2）FreeRTOS是免费的并且简单(文件数量很少),功能包括：任务管理、时间管理、信号量、消息队列、内存管理、记录功能、软件定时器、协程等。
（3）FreeRTOS官网：https://freertos.org/。
（4）FreeRTOS 实现多任务的原理:严格来说 FreeRTOS 并不是实时操作系统，因为它是分时复用的。系统将时间分割成很多时间片，然后轮流执行各个任务。
每个任务都是独立运行的，互不影响，由于切换的频率很快，就感觉像是同时运行的一样。

3 移植FreeRTOS到上官二号平台

（1）移植方式：1.手动移植-参考博客链接https://blog.csdn.net/qq_61672347/article/details/125529482
（2）使用CubeMX快速移植-参考文档按步骤操作即可。
注：FreeRTOS内核配置说明博客链接：https://blog.csdn.net/zhzht19861011/article/details/50134883
2.1 从MCU开启项目
在这里插入图片描述
2.2 选择芯片

2.3 SYS设置

2.4 RCC设置

2.5 freertos版本设置

2.6 时钟设置

2.7工程设置
注：路径不能含中文或者空格，否则生成代码时会报错The Code is successfully generated under :
but MDK-ARM V5.32project generation have a problem.
在这里插入图片描述
2.8代码生成设置

2.9 生成代码后打开工程项目(工程名muban)

4 (补充)模板工程打开串口

（1）CubeMX中补充打开串口，作为最新模板；
1.1 步骤：串口选择异步模式，重新生成代码作为最新模板
在这里插入图片描述
1.2 在usart.c中插入代码#include “stdio.h”
int fputc(int ch, FILE *f)
{
unsigned char temp[1]={ch};
HAL_UART_Transmit(&huart1,temp,1,0xffff);
return ch;
}

1.3 勾选Use MicroLIB

1.4 编写代码串口输出hello world，下载到stm32芯片中
在这里插入图片描述
1.5 串口调试助手调试

5 任务的创建与删除(理论)

（1）什么是任务：任务可以理解为进程/线程，创建一个任务，就会在内存开辟一个空间。
（2）任务创建与删除相关函数：xTaskCreate()(动态方式创建任务),xTaskCreateStatic(静态方式创建任务),vTaskDelete()(删除任务);
任务动态创建与静态创建的区别：动态创建任务的堆栈由系统分配，而静态创建任务的堆栈由用户自己传递。
（3）xTaskCreate函数原型：
BaseType_t xTaskCreate
(
TaskFunction_t pxTaskCode, /指向任务函数的指针/
const char* const pcName, /任务名字/
const configSTACK_DEPTH_TYPE, /任务堆栈大小/
void* const pvParameters, /传递给任务函数的参数/
UBaseType_t uxPriority, /任务优先级/
TaskHandle_t* const pxCreatedTask /任务句柄/
)
案例：
void vTaskCode( void * pvParameters )
{
for( ;; )
{
}
}
void vOtherFunction( void )
{
BaseType_t xReturned;
TaskHandle_t xHandle = NULL;
xReturned = xTaskCreate(vTaskCode,“NAME”,STACK_SIZE,( void * ) 1,tskIDLE_PRIORITY,&xHandle);
if( xReturned == pdPASS )
{
vTaskDelete( xHandle );
}
}
返回值：pdPASS 任务创建成功,errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY 任务创建失败;
（4）vTaskDelete 函数原型：void vTaskDelete(TaskHandle_t xTaskToDelete);

6 任务的创建与删除(实操)

（1）代码编写：复制模板工程(工程名muban)，点击进入CubeMX中新建2个任务，并配置2gpio口输出,生成代码后在2任务函数中分别写led1延时500ms翻转,led2延时1000ms翻转;(工程名task_test)
1.1 创建任务taskLED1
在这里插入图片描述
1.2 创建任务taskLED2

1.3 配置两引脚为GIPIO_Output

1.4 在任务taskLED1中编写led1延时500ms翻转,任务taskLED2中编写led2延时1000ms翻转;

7 任务调度简介

（1）任务调度：使用相关的调度算法来决定当前需要执行的哪个任务。
（2）任务调度函数：开启任务调度的函数是 vTaskStartScheduler(),CubeMX 中被封装为osKernelStart();
（3）任务调度规则：1.高优先级抢占低优先级任务，系统永远执行最高优先级的任务（即抢占式调度）
2.同等优先级的任务轮转调度（即时间片调度）

8 任务状态及互相转换

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

9 任务综合小实验

（1）任务需求：创建4个任务
taskLED1,间隔 500ms 闪烁 LED1；
taskLED2,间隔 1000ms 闪烁 LED2；
taskKEY1,如果 taskLED1 存在，则按下 KEY1 后删除 taskLED1 ，否则创建 taskLED1 ；
taskKEY2,如果 taskLED2 正常运行，则按下 KEY2 后挂起 taskLED2 ，否则恢复 taskLED2;
（2）代码编写：复制上个实验工程(工程名task_test)，点击进入CubeMX中新建4个任务，并配置2gpio口输出,2gpio口输入,打开串口,生成代码后在taskKEY1进行taskLED1的创建与删除,taskKEY2中进行taskLED2的挂起与恢复;(工程名tasks_test)
2.1 PA0,PA1两引脚改为GPIO_Input
在这里插入图片描述
2.2 创建任务taskKEY1

2.3 创建任务taskKEY2

2.4 freertos.c中编写代码

/* USER CODE END Header_StartTaskLED1 */
void StartTaskLED1(void const * argument)
{
  /* USER CODE BEGIN StartTaskLED1 */
  /* Infinite loop */
  for(;;)
  {
    HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_8);
    osDelay(500);
  }
  /* USER CODE END StartTaskLED1 */
}
/* USER CODE END Header_StartTaskLED2 */
void StartTaskLED2(void const * argument)
{
  /* USER CODE BEGIN StartTaskLED2 */
  /* Infinite loop */
  for(;;)
  {
    HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_9);
    osDelay(1000);
  }
  /* USER CODE END StartTaskLED2 */
}
/* USER CODE END Header_StartTaskKEY1 */
void StartTaskKEY1(void const * argument)
{
  /* USER CODE BEGIN StartTaskKEY1 */
  /* 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("KEY1按下！\r\n");
            if(taskLED1Handle == NULL)
            {
                printf("任务1不存在，准备创建任务1\r\n");
                osThreadDef(taskLED1, StartTaskLED1, osPriorityNormal, 0, 128);
                taskLED1Handle = osThreadCreate(osThread(taskLED1), NULL);
                if(taskLED1Handle != NULL)
                    printf("任务1创建完成!\r\n");
            }
            else
            {
                printf("删除任务\r\n");
                osThreadTerminate(taskLED1Handle);    
                taskLED1Handle = NULL;
            }
        }
        while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET);
    }
    osDelay(10);
  }
  /* USER CODE END StartTaskKEY1 */
}

/* USER CODE END Header_StartTaskKEY2 */
void StartTaskKEY2(void const * argument)
{
  /* USER CODE BEGIN StartTaskKEY2 */
  /* Infinite loop */
    static int flag = 0;
  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)
        {
            printf("KEY2按下！\r\n");
            if(flag == 0)
            {
                osThreadSuspend(taskLED2Handle);
                printf("任务2已被暂停\r\n");
                flag =1;
            }
            else
            {
                osThreadResume(taskLED2Handle);
                printf("任务2已被恢复\r\n");
                flag = 0;
            }
            
        }
        while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET);
    }
    osDelay(10);
  }
  /* USER CODE END StartTaskKEY2 */
}

10 队列简介

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

（3）队列相关API函数：
1. 创建队列
例：QueueHandle_t xQueueCreate( UBaseType_t uxQueueLength,UBaseType_t uxItemSize );
参数：
uxQueueLength：队列可同时容纳的最大项目数。
uxItemSize：存储队列中的每个数据项所需的大小（以字节为单位）。
返回值：如果队列创建成功，则返回所创建队列的句柄。如果创建队列所需的内存无法分配，则返回 NULL。
2. 写队列
写队列函数：
xQueueSend() 往队列的尾部写入消息
xQueueSendToBack() 同 xQueueSend()
xQueueSendToFront() 往队列的头部写入消息
xQueueOverwrite() 覆写队列消息（只用于队列长度为 1 的情况）
xQueueSendFromISR() 在中断中往队列的尾部写入消息
xQueueSendToBackFromISR() 同 xQueueSendFromISR()
xQueueSendToFrontFromISR() 在中断中往队列的头部写入消息
xQueueOverwriteFromISR() 在中断中覆写队列消息（只用于队列长度为 1 的情况）
例：BaseType_t xQueueSend(QueueHandle_t xQueue,const void * pvItemToQueue,TickType_t xTicksToWait);
参数：
xQueue：队列的句柄，数据项将发送到此队列。
pvItemToQueue：待写入数据
xTicksToWait：阻塞超时时间
返回值：如果成功写入数据，返回 pdTRUE，否则返回 errQUEUE_FULL。
3. 读队列
读队列函数：
xQueueReceive() 从队列头部读取消息，并删除消息
xQueuePeek() 从队列头部读取消息，但是不删除消息
xQueueReceiveFromISR() 在中断中从队列头部读取消息，并删除消息
xQueuePeekFromISR() 在中断中从队列头部读取消息
例：BaseType_t xQueueReceive(QueueHandle_t xQueue,void *pvBuffer,TickType_t xTicksToWait);
参数：
xQueue：待读取的队列
pvItemToQueue：数据读取缓冲区
xTicksToWait：阻塞超时时间
返回值：成功返回 pdTRUE，否则返回 pdFALSE。

11 队列实操

（1）实验需求：创建一个队列，按下 KEY1 向队列发送数据，按下 KEY2 向队列读取数据。
（2）代码编写：复制模板工程（工程名：muban），点击进入CubeMX中创建2个任务及1个队列，按键1中写发送数据到队列，按键2中写从队列中读取数据。（工程名：queue_test）
2.1 PA0，PA两引脚设置为GPIO_Input
在这里插入图片描述
2.2 创建任务taskSend

2.3 创建任务taskRecieve

2.4 创建队列
2.5 freertos.c中编写代码

/* USER CODE END Header_StartTaskSend */
void StartTaskSend(void const * argument)
{
  /* USER CODE BEGIN StartTaskSend */
	uint16_t buf = 100;
	BaseType_t status;
  /* 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)
			{
				status = xQueueSend(myQueueHandle, &buf, 0);
				if (status == pdTRUE)
					printf("写入队列成功，写入值%d\r\n", buf);
				else
					printf("写入队列失败\r\n");
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
		}
    osDelay(10);
  }
  /* USER CODE END StartTaskSend */
}

/* USER CODE END Header_StartTaskReceive */
void StartTaskReceive(void const * argument)
{
  /* USER CODE BEGIN StartTaskReceive */
	uint16_t buf;
	BaseType_t status;
  /* 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)
			{
				status = xQueueReceive(myQueueHandle, &buf, 0);
				if (status == pdTRUE)
					printf("读取队列成功，读出值%d\r\n", buf);
				else
					printf("读取队列失败\r\n");
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
		}
    osDelay(10);
  }
  /* USER CODE END StartTaskReceive */
}

12 二值信号量简介

（1）信号量（Semaphore）是在多任务环境下使用的一种机制，是可以用来保证两个或多个关键代码段不被并发调用。
二值信号量：一个长度为1，大小为零的队列，只有0和1两种状态；通常情况下，我们用它来进行互斥访问或任务同步。
（2）二值信号量函数：
xSemaphoreCreateBinary() 使用动态方式创建二值信号量
xSemaphoreCreateBinaryStatic() 使用静态方式创建二值信号量
xSemaphoreGive() 释放信号量
xSemaphoreGiveFromISR() 在中断中释放信号量
xSemaphoreTake() 获取信号量
xSemaphoreTakeFromISR() 在中断中获取信号量
创建二值信号量：SemaphoreHandle_t xSemaphoreCreateBinary( void )
参数：无
返回值：成功，返回对应二值信号量的句柄；失败，返回 NULL 。
释放二值信号量：BaseType_t xSemaphoreGive( SemaphoreHandle_t xSemaphore )
参数：xSemaphore：要释放的信号量句柄
返回值：成功，返回 pdPASS ；失败，返回 errQUEUE_FULL 。
获取二值信号量:BaseType_t xSemaphoreTake( SemaphoreHandle_t xSemaphore,TickType_t xTicksToWait );
参数：xSemaphore：要获取的信号量句柄
xTicksToWait：超时时间，0 表示不超时，portMAX_DELAY表示卡死等待；
返回值：成功，返回 pdPASS ；失败，返回 errQUEUE_FULL 。

13 二值信号量实操

（1）代码编写：复制模板工程（工程名：muban），点击进入CubeMX中创建2个任务及1个二值信号量，按键1中释放二值信号量，按键2中获取二值信号量。（项目名：semaphore_binary_test）
1.1 PA0,PA1引脚设置为GPIO_Input
在这里插入图片描述
1.2 创建任务taskGive

1.3 创建任务taskTake

1.4 创建二值信号量

1.5 freertos.c中编写代码

  //osSemaphoreDef(myBinary);
  //myBinaryHandle = osSemaphoreCreate(osSemaphore(myBinary), 1);
	myBinaryHandle = xSemaphoreCreateBinary();
	
  osThreadDef(taskGive, StartTaskGive, osPriorityNormal, 0, 128);
  taskGiveHandle = osThreadCreate(osThread(taskGive), NULL);

  /* definition and creation of taskTake */
  osThreadDef(taskTake, StartTaskTake, osPriorityNormal, 0, 128);
  taskTakeHandle = osThreadCreate(osThread(taskTake), NULL);
  
/* USER CODE END Header_StartTaskGive */
void StartTaskGive(void const * argument)
{
  /* USER CODE BEGIN StartTaskGive */
  /* 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)
			{
				if (xSemaphoreGive(myBinaryHandle) == pdTRUE)
					printf("二值信号量放入成功\r\n");
				else
					printf("二值信号量放入失败\r\n");
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
		}
    osDelay(10);
  }
  /* USER CODE END StartTaskGive */
}

/* USER CODE END Header_StartTaskTake */
void StartTaskTake(void const * argument)
{
  /* USER CODE BEGIN StartTaskTake */
  /* 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)
			{
				if (xSemaphoreTake(myBinaryHandle, portMAX_DELAY ) == pdTRUE)
					printf("二值信号量获取成功\r\n");
				else
					printf("二值信号量获取失败\r\n");
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
		}
    osDelay(10);
  }
  /* USER CODE END StartTaskTake */
}

14 计数型信号量简介及实操

（1）计数型信号量：计数型信号量相当于队列长度大于1的队列，因此计数型信号量能够容纳多个资源。
（2）计数型信号量函数：
xSemaphoreCreateCounting() 使用动态方法创建计数型信号量。
xSemaphoreCreateCountingStatic() 使用静态方法创建计数型信号量
uxSemaphoreGetCount() 获取信号量的计数值
例：SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount,UBaseType_t uxInitialCount);
参数：uxMaxCount：可以达到的最大计数值
uxInitialCount：创建信号量时分配给信号量的计数值
返回值：成功，返回对应计数型信号量的句柄；失败，返回 NULL 。
（3）实验需求：创建一个计数型信号量，按下 KEY1 则释放信号量，按下 KEY2 获取信号量。
代码编写：参考二值信号量实操（项目名：semaphore_binary_test），点击进入CubeMX中开启计数型信号量，删除二值信号量，新建计数型信号量。函数中将创建二值信号量修改为创建计数型信号量。（项目名：semaphore_counting_test）
3.1 使用计数型信号量配置为Enabled
在这里插入图片描述
3.2 创建计数型信号量

3.3 freertos.c中编写代码

//  osSemaphoreDef(myCountingSem);
//  myCountingSemHandle = osSemaphoreCreate(osSemaphore(myCountingSem), 3);
    myCountingSemHandle= xSemaphoreCreateCounting(3,0);

/* USER CODE END Header_StartTaskGive */
void StartTaskGive(void const * argument)
{
  /* USER CODE BEGIN StartTaskGive */
  /* 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)
        {
            if(xSemaphoreGive(myCountingSemHandle) == pdPASS)
                printf("计数型信号量释放成功\r\n");
            else 
                printf("计数型信号量释放失败\r\n");
        }
        while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET);
    }
    osDelay(10);
  }
  /* USER CODE END StartTaskGive */
}

/* USER CODE END Header_StartTaskTake */
void StartTaskTake(void const * argument)
{
  /* USER CODE BEGIN StartTaskTake */
  /* 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)
        {
            if(xSemaphoreTake(myCountingSemHandle,0) == pdPASS)
                printf("计数型信号量获取成功\r\n");
            else 
                printf("计数型信号量获取失败\r\n");           
        }
        while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET);
    }
    osDelay(10);
  }
  /* USER CODE END StartTaskTake */
}

15 互斥量简介

（1）互斥型信号量和二值型信号量非常相似，但是从功能上二值型信号量用于同步，而互斥型信号量用于资源保护。
互斥型信号量和二值型信号量还有一个最大的区别，互斥型信号量可以有效解决优先级反转现象。
（2）优先级倒置或反转：例，系统中有3个不同优先级的任务H/M/L，最高优先级任务H和最低优先级任务L通过信号量机制，共享资源。目前任务L占有资源，锁定了信号量，Task H运行后将被阻塞，
直到TaskL释放信号量后，Task H才能够退出阻塞状态继续运行。但是Task H在等待Task L释放信号量的过程中，中等优先级任务M抢占了任务L，从而延迟了信号量的释放时间，
导致Task H阻塞了更长时间，这种现象称为优先级倒置或反转。
（即H/M/L这3个优先级任务，H,L共用一个信号量，L执行H被阻塞，由于M优先级高于L，L信号量还未释放完，M抢占，所以先执行M，再执行完L，再执行H）
（3）优先级继承：当一个互斥信号量正在被一个低优先级的任务持有时，如果此时有个高优先级的任务也尝试获取这个互斥信号量，那么这个高优先级的任务就会被阻塞。不过这个高优先级的任务
会将低优先级任务的优先级提升到与自己相同的优先级。（即H/M/L这3个优先级任务，H,L共用一个互斥信号量，那么L优先级提升到跟H一样，先执行L，再执行H，再执行M）。
优先级继承并不能完全的消除优先级翻转的问题，它只是尽可能的降低优先级翻转带来的影响。
（4）互斥量相关函数：
xSemaphoreCreateMutex() 使用动态方法创建互斥信号量。
xSemaphoreCreateMutexStatic() 使用静态方法创建互斥信号量。
例：SemaphoreHandle_t xSemaphoreCreateMutex( void )
参数：无
返回值：成功，返回对应互斥量的句柄；失败，返回 NULL 。

16 互斥量实操

（1）实验需求：1. 演示优先级翻转；2. 使用互斥量优化优先级翻转问题
（2）代码编写：1.复制模板工程，点击进入CubeMX中创建3个优先级分别为高，中，低的任务及1个二值信号量，高，低优先级任务共用一个二值信号量。
2.1 创建任务taskH
在这里插入图片描述
2.2 创建任务taskM

2.3 创建任务taskL

2.4 创建二值信号量

2.5 在freertos.c中编写代码

/* USER CODE END Header_StartTaskH */
void StartTaskH(void const * argument)
{
  /* USER CODE BEGIN StartTaskH */
  /* Infinite loop */
  for(;;)
  {
    xSemaphoreTake(myBinarySemHandle,portMAX_DELAY);
    printf("taskH:获取信号量中\r\n");
    HAL_Delay(1000);
    printf("taskH:获取到了信号量\r\n");
    xSemaphoreGive(myBinarySemHandle);
    osDelay(1000);
  }
  /* USER CODE END StartTaskH */
}

/* USER CODE END Header_StartTaskM */
void StartTaskM(void const * argument)
{
  /* USER CODE BEGIN StartTaskM */
  /* Infinite loop */
  for(;;)
  {
    printf("taskM:路过而已\r\n");     
    osDelay(1000);
  }
  /* USER CODE END StartTaskM */
}

/* USER CODE END Header_StartTaskL */
void StartTaskL(void const * argument)
{
  /* USER CODE BEGIN StartTaskL */
  /* Infinite loop */
  for(;;)
  {
    xSemaphoreTake(myBinarySemHandle,portMAX_DELAY);
    printf("taskL:获取信号量中\r\n");
    HAL_Delay(3000);
    printf("taskL:获取到了信号量\r\n");
    xSemaphoreGive(myBinarySemHandle);
    osDelay(1000);
  }
  /* USER CODE END StartTaskL */
}

2.6 演示优先级翻转，taskL被taskM抢占
在这里插入图片描述

2.复制模板工程，点击进入CubeMX中创建3个优先级分别为高，中，低的任务及1个互斥信号量，高，低优先级任务共用一个互斥信号量。
2.1 将上述实验创建的二值信号量删除，创建互斥信号量
在这里插入图片描述
2.2 在freertos.c中编写代码

/* USER CODE END Header_StartTaskH */
void StartTaskH(void const * argument)
{
  /* USER CODE BEGIN StartTaskH */
  /* Infinite loop */
  for(;;)
  {
    xSemaphoreTake(myMutexHandle,portMAX_DELAY);
    printf("taskH:获取信号量中\r\n");
    HAL_Delay(1000);
    printf("taskH:获取到了信号量\r\n");
    xSemaphoreGive(myMutexHandle);
    osDelay(1000);
  }
  /* USER CODE END StartTaskH */
}

/* USER CODE END Header_StartTaskM */
void StartTaskM(void const * argument)
{
  /* USER CODE BEGIN StartTaskM */
  /* Infinite loop */
  for(;;)
  {
    printf("taskM:路过而已\r\n");     
    osDelay(1000);
  }
  /* USER CODE END StartTaskM */
}

/* USER CODE END Header_StartTaskL */
void StartTaskL(void const * argument)
{
  /* USER CODE BEGIN StartTaskL */
  /* Infinite loop */
  for(;;)
  {
    xSemaphoreTake(myMutexHandle,portMAX_DELAY);
    printf("taskL:获取信号量中\r\n");
    HAL_Delay(3000);
    printf("taskL:获取到了信号量\r\n");
    xSemaphoreGive(myMutexHandle);
    osDelay(1000);
  }
  /* USER CODE END StartTaskL */
}

2.3 使用互斥量优化优先级翻转问题，无taskL抢占taskM的现象
在这里插入图片描述

17 事件标志组简介

（1）事件标志位：表明某个事件是否发生；通常按位表示，每一位表示一个事件；
（2）事件标志组：一组事件标志位的集合；本质是一个16位或32位无符号的数据类型 EventBits_t ，由 configUSE_16_BIT_TICKS决定。
其中32位无符号的数据类型变量来存储事件标志，但其中的高8位用作存储事件标志组的控制信息，低24位用作存储事件标志。
（3）事件标志组相关函数：
xEventGroupCreate() 使用动态方式创建事件标志组
xEventGroupCreateStatic() 使用静态方式创建事件标志组
xEventGroupClearBits() 清零事件标志位
xEventGroupClearBitsFromISR() 在中断中清零事件标志位
xEventGroupSetBits() 设置事件标志位
xEventGroupSetBitsFromISR() 在中断中设置事件标志位
xEventGroupWaitBits() 等待事件标志位
创建事件标志组：EventGroupHandle_t xEventGroupCreate( void );
参数：无
返回值：成功，返回对应事件标志组的句柄；失败，返回NULL。
设置事件标志位：EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,const EventBits_t uxBitsToSet );
参数：xEventGroup：对应事件组句柄。 uxBitsToSet：指定要在事件组中设置的一个或多个位的按位值。
返回值：设置之后事件组中的事件标志位值。
清除事件标志位：EventBits_t xEventGroupClearBits(EventGroupHandle_t xEventGroup,const EventBits_t uxBitsToClear );
参数：xEventGroup：对应事件组句柄。 uxBitsToClear：指定要在事件组中清除的一个或多个位的按位值。
返回值：清零之前事件组中事件标志位的值。
等待事件标志位：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：超时
返回值：
等待的事件标志位值：等待事件标志位成功，返回等待到的事件标志位
其他值：等待事件标志位失败，返回事件组中的事件标志位

18 事件标志组实操

（1）实验需求:创建一个事件标志组和两个任务（task1和task2），task1检测按键，如果检测到 KEY1和KEY2都按过，则执行task2。
（2）代码编写：复制模板工程(工程名:muban)，点击进入CubeMX中创建2个任务；任务1检测key1跟key2是否按过，key1按过设置事件标志位0x01,key2按过设置事件标志位0x02；任务2则进行等待事件标志位，当第一位跟第二位都为1时，才执行响应操作;(工程名：events_test)
2.1 创建任务Task1
在这里插入图片描述
2.2 创建任务Task2

2.3 在freertos.c中编写代码

EventGroupHandle_t eventgroup_handle;
eventgroup_handle = xEventGroupCreate();
/* USER CODE END Header_StartTask1 */
void StartTask1(void const * argument)
{
  /* USER CODE BEGIN StartTask1 */
  /* Infinite loop */
  for(;;)
  {
    // 等待 KEY1 按下
	if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
	{
		osDelay(20);
		if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
			{
                xEventGroupSetBits(eventgroup_handle,0x01);
			}
		while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
	}
    // 等待 KEY2 按下
	if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
	{
		osDelay(20);
		if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
			{
                xEventGroupSetBits(eventgroup_handle,0x02);
			}
		while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
	}  
    osDelay(1);    
  }
  /* USER CODE END StartTask1 */
}
/* USER CODE END Header_StartTask2 */
void StartTask2(void const * argument)
{
  /* USER CODE BEGIN StartTask2 */
  /* Infinite loop */
  EventBits_t event_bit = 0;  
  for(;;)
  {
    event_bit = xEventGroupWaitBits(eventgroup_handle,0x01 | 0x02,pdTRUE,pdTRUE,portMAX_DELAY);
    printf("返回值为%#x\r\n",event_bit);
    osDelay(1);
  }
  /* USER CODE END StartTask2 */
}

2.4 结果检测到 KEY1和KEY2都按过，返回事件组中的事件标志位值为0x3
在这里插入图片描述

19 任务通知简介

（1）任务通知：每个任务都有一个32位的通知值,任务通知可以替代二值信号量、计数信号量、事件标志组，可以替代长度为1的队列（可以保存一个32位整数或指针值），并且任务通知速度更快、使用的RAM更少。
（2）任务通知值的更新方式：
1.发送消息给任务，如果有通知未读，不覆盖通知值
2.发送消息给任务，直接覆盖通知值
3.发送消息给任务，设置通知值的一个或者多个位
4.发送消息给任务，递增通知值
（3）任务通知的优势：
1. 使用任务通知向任务发送事件或数据，比使用队列、事件标志组或信号量快得多。
2. 使用其他方法时都要先创建对应的结构体，使用任务通知时无需额外创建结构体。
（4）任务通知的劣势：
1. 只有任务可以等待通知，中断服务函数中不可以，因为中断没有TCB 。
2. 通知只能一对一，因为通知必须指定任务。
3. 等待通知的任务可以被阻塞，但是发送消息的任务，任何情况下都不会被阻塞等待。
4. 任务通知是通过更新任务通知值来发送数据的，任务结构体中只有一个任务通知值，只能保持一个数据。
（5）任务通知相关函数：
1.发送通知函数：
xTaskNotify() 发送通知，带有通知值
xTaskNotifyAndQuery() 发送通知，带有通知值并且保留接收任务的原通知值
xTaskNotifyGive() 发送通知，不带通知值
xTaskNotifyFromISR() 在中断中发送任务通知
xTaskNotifyAndQueryFromISR() 在中断中发送任务通知
vTaskNotifyGiveFromISR() 在中断中发送任务通知
例1：BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify,uint32_t ulValue,eNotifyAction eAction );
参数：
xTaskToNotify：需要接收通知的任务句柄；
ulValue：用于更新接收任务通知值，具体如何更新由形参 eAction 决定；
eAction：一个枚举，代表如何使用任务通知的值；
在这里插入图片描述

返回值：如果被通知任务还没取走上一个通知，又接收了一个通知，则这次通知值未能更新并返回pdFALSE，而其他情况均返回pdPASS。
例2：BaseType_t xTaskNotifyAndQuery( TaskHandle_t xTaskToNotify,uint32_t ulValue,eNotifyAction eAction,uint32_t *pulPreviousNotifyValue );
参数：
xTaskToNotify：需要接收通知的任务句柄；
ulValue：用于更新接收任务通知值，具体如何更新由形参 eAction 决定；
eAction：一个枚举，代表如何使用任务通知的值；
pulPreviousNotifyValue：对象任务的上一个任务通知值，如果为 NULL，则不需要回传，这个时候就等价于函数 xTaskNotify()。
返回值：
如果被通知任务还没取走上一个通知，又接收了一个通知，则这次通知值未能更新并返回pdFALSE，而其他情况均返回pdPASS。
例3：BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );
参数：xTaskToNotify：接收通知的任务句柄，并让其自身的任务通知值加 1。
返回值：总是返回 pdPASS。
2.等待通知函数：
ulTaskNotifyTake() 获取任务通知，可以设置在退出此函数的时候将任务通知值清零或者减一。当任务通知用作二值信号量或者计数信号量的时候，使用此函数来获取信号量。
xTaskNotifyWait() 获取任务通知，比 ulTaskNotifyTak()更为复杂，可获取通知值和清除通知值的指定位
例1：uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit,TickType_t xTicksToWait );
参数：xClearCountOnExit：指定在成功接收通知后，将通知值清零或减 1，pdTRUE：把通知值清零（二值信号量）；pdFALSE：把通知值减一（计数型信号量）；
xTicksToWait：阻塞等待任务通知值的最大时间；
返回值：0：接收失败非0：接收成功，返回任务通知的通知值
例2：BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry,uint32_t ulBitsToClearOnExit,uint32_t pulNotificationValue,TickType_t xTicksToWait );
参数：
ulBitsToClearOnEntry：函数执行前清零任务通知值那些位。
ulBitsToClearOnExit：表示在函数退出前，清零任务通知值那些位，在清0前，接收到的任务通知值会先被保存到形参pulNotificationValue 中。
pulNotificationValue：用于保存接收到的任务通知值。如果不需要使用，则设置为 NULL 即可。
xTicksToWait：等待消息通知的最大等待时间。

20 任务通知实操

（1）实验需求：1. 模拟二值信号量
2. 模拟计数型信号量
3. 模拟事件标志组
4. 模拟邮箱
（2）代码实现：复制模板工程，点击进入CubeMX中创建2个任务；任务1为任务发送，任务2为任务接收；
1.模拟二值信号量的话，任务1中按下按键1用xTaskNotifyGive()发送通知，任务2中按下按下按键2用ulTaskNotifyTake()接收通知,其中xClearCountOnExit为pdTRUE。（工程名:notify_binary_test）
1.1 PA0,PA1两引脚设置为GPIO_input 在这里插入图片描述
1.2 创建任务taskSend
1.3 创建任务taskRecieve
1.4 在freertos.c中编写代码

/* USER CODE END Header_StartTaskSend */
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(taskRecieveHandle);
                printf("任务通知：模拟二值信号量发送成功\r\n");
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
		}
    osDelay(10);
  }
  /* USER CODE END StartTaskSend */
}
/* USER CODE END Header_StartTaskRecieve */
void StartTaskRecieve(void const * argument)
{
  /* USER CODE BEGIN StartTaskRecieve */
  /* Infinite loop */
  uint32_t rev = 0;
  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 StartTaskRecieve */
}

1.5 模拟二值信号量成功
在这里插入图片描述

2.模拟计数型信号量的话，任务1中按下按键1用xTaskNotifyGive()发送通知，任务2中按下按下按键2用ulTaskNotifyTake()接收通知,其中xClearCountOnExit为pdFALSE。（工程名:notify_counting_test）
2.1 在freertos.c中编写代码

/* USER CODE END Header_StartTaskSend */
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(taskRecieveHandle);
                printf("任务通知：模拟计数型信号量发送成功\r\n");
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
		}
    osDelay(10);
  }
  /* USER CODE END StartTaskSend */
}
/* USER CODE END Header_StartTaskRecieve */
void StartTaskRecieve(void const * argument)
{
  /* USER CODE BEGIN StartTaskRecieve */
  /* Infinite loop */
  uint32_t rev = 0;
  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(pdFALSE,portMAX_DELAY);
                if(rev != 0)
                {
                    printf("任务通知：模拟计数型信号量接收成功,rev=%d\r\n",rev);
                }
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
		}
    osDelay(10);
  }
  /* USER CODE END StartTaskRecieve */
}

2.2 模拟计数型信号量成功
在这里插入图片描述

3.模拟事件标志组的话，任务1中按下按键1用xTaskNotify()发送通知，第0位置1,按下按键2用xTaskNotify()发送通知，第1位置1,其中eAction为eSetBits;任务2用xTaskNotifyWait()接收通知;（工程名:notify_events_test）
3.1 在freertos.c中编写代码

/* USER CODE END Header_StartTaskSend */
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(taskRecieveHandle,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(taskRecieveHandle,0x02,eSetBits);
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
		}        
    osDelay(10);
  }
  /* USER CODE END StartTaskSend */
}
/* USER CODE END Header_StartTaskRecieve */
void StartTaskRecieve(void const * argument)
{
  /* USER CODE BEGIN StartTaskRecieve */
  /* Infinite loop */
  uint32_t notify_val = 0,event_bit = 0;
  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 StartTaskRecieve */
}

3.2 模拟事件标志组成功在这里插入图片描述

4.模拟邮箱的话，任务1中按下按键1用xTaskNotify()发送通知，按下按键2也用xTaskNotify()发送通知,其中eAction为eSetValueWithOverWrite(覆写)或eSetValueWithoutOverwrite(不覆写);任务2用xTaskNotifyWait()接收通知;
（工程名:notify_queue_test）
4.1 在freertos.c中编写代码

/* USER CODE END Header_StartTaskSend */
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(taskRecieveHandle,0x01,eSetValueWithOverwrite);
			}
			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(taskRecieveHandle,0x02,eSetValueWithOverwrite);
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
		}        
    osDelay(10);
  }
  /* USER CODE END StartTaskSend */
}
/* USER CODE END Header_StartTaskRecieve */
void StartTaskRecieve(void const * argument)
{
  /* USER CODE BEGIN StartTaskRecieve */
  /* Infinite loop */
  uint32_t notify_val = 0;
  for(;;)
  {
    xTaskNotifyWait(0,0xFFFFFFFF,&notify_val,portMAX_DELAY);
    printf("接收到的通知值为:%d\r\n",notify_val);
    osDelay(10);
  }
  /* USER CODE END StartTaskRecieve */
}

4.2 模拟邮箱成功
在这里插入图片描述

21 延时函数

（1）延时函数分类：
相对延时：vTaskDelay,起点是从调用延时函数开始;
绝对延时：vTaskDelayUntil，第2次调用延时函数的起点是第一次调用延时函数的终点;
（2）vTaskDelay与HAL_Delay的区别：
vTaskDelay 作用是让任务阻塞，任务阻塞后，RTOS系统调用其它处于就绪状态的优先级最高的任务来执行。
HAL_Delay 一直不停的调用获取系统时间的函数，直到指定的时间流逝然后退出，故其占用了全部CPU时间。

22 软件定时器简介

（1）硬件定时器：STM32 芯片自带硬件定时器，精度较高，达到定时时间后会触发中断，也可以生成 PWM 、输入捕获、输出比较，等等，功能强大，但是由于硬件的限制，个数有限。
软件定时器：软件定时器也可以实现定时功能，达到定时时间后可调用回调函数，可以在回调函数里处理信息。
（2）软件定时器服务任务：在调用函数 vTaskStartScheduler() 开启任务调度器的时候，会创建一个用于管理软件定时器的任务，这个任务就叫做软件定时器服务任务。
软件定时器服务任务作用：1. 负责软件定时器超时的逻辑判断 2. 调用超时软件定时器的超时回调函数 3. 处理软件定时器命令队列
定时器命令队列：FreeRTOS提供了很多定时器有关的API函数，这些API函数大多都使用FreeRTOS的队列发送命令给定时器服务任务。这个队列叫做定时器命令队列。
（3）软件定时器相关配置：
1.configUSE_TIMERS 设置为1的话定时器服务任务就会在启动FreeRTOS调度器的时候自动创建
2.configTIMER_TASK_PRIORITY 设置软件定时器服务任务的任务优先级，可以为0~(configMAX_PRIORITIES-1)
3.configTIMER_QUEUE_LENGTH 此宏用来设置定时器命令队列的队列长度。
4.configTIMER_TASK_STACK_DEPTH 此宏用来设置定时器服务任务的任务堆栈大小。
（4）单次定时器和周期定时器：
单次定时器：只超时一次，调用一次回调函数。可手动再开启定时器；
周期定时器：多次超时，多次调用回调函数。
（5）软件定时器相关API函数：
xTimerCreate() 动态方式创建软件定时器
xTimerCreateStatic() 静态方式创建软件定时器
xTimerStart() 开启软件定时器定时
xTimerStop() 停止软件定时器定时
xTimerReset() 复位软件定时器定时
xTimerChangePeriod() 更改软件定时器的定时超时时间
xTimerStartFromISR() 在中断中开启软件定时器定时
xTimerStopFromISR() 在中断中停止软件定时器定时
xTimerResetFromISR() 在中断中复位软件定时器定时
xTimerChangePeriodFromISR() 在中断中更改定时超时时间
1. 创建软件定时器:TimerHandle_t xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriod,const UBaseType_t uxAutoReload,void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction );
参数：pcTimerName：软件定时器名称
xTimerPeriodInTicks：定时超时时间，单位：系统时钟节拍。宏pdMS_TO_TICKS() 可用于将以毫秒为单位指定的时间转换为以 tick 为单位指定的时间。
uxAutoReload：定时器模式， pdTRUE：周期定时器， pdFALSE：单次定时器
pvTimerID：软件定时器 ID，用于多个软件定时器公用一个超时回调函数
pxCallbackFunction：软件定时器超时回调函数
返回值：成功：定时器句柄失败：NULL
2.开启软件定时器:BaseType_t xTimerStart( TimerHandle_t xTimer, TickType_t xBlockTime );
参数：xTimer：待开启的软件定时器的句柄 xTickToWait：发送命令到软件定时器命令队列的最大等待时间
返回值：pdPASS：开启成功 pdFAIL：开启失败
3. 停止软件定时器:BaseType_t xTimerStop( TimerHandle_t xTimer,TickType_t xBlockTime );
参数与返回值同上。
4. 复位软件定时器:BaseType_t xTimerReset( TimerHandle_t xTimer, TickType_t xBlockTime );
参数与返回值同上。
5. 更改软件定时器定时时间：BaseType_t xTimerChangePeriod( TimerHandle_t xTimer, TickType_t xNewPeriod,TickType_t xBlockTime );
xNewPeriod：新的定时超时时间，单位：系统时钟节拍。其余参数与返回值同上。

23 软件定时器实操

（1）实验需求：创建两个定时器，定时器1，周期定时器，每1秒打印一次A；定时器2，单次定时器，启动后 2 秒打印一次B
（2）代码实现：复制模板工程（工程名：muban），点击进入CubeMX中设定USE_TIMERS为Enable,创建一个周期定时器，一个单次定时器；
代码中用 osTimerStart(myTimer01Handle, 1000)或xTimerChangePeriod(myTimer01Handle, pdMS_TO_TICKS(1000), 0)开启定时器，定时器1回调函数中打印A，定时器2回调函数中打印B；(工程名：timer_test)
2.1 配置使用定时器为Enabled
在这里插入图片描述
2.2 创建定时器1为周期定时器

2.3 创建定时器2为单次定时器

2.4 在freertos.c中编写代码

/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void const * argument)
{
  /* USER CODE BEGIN StartDefaultTask */
  /* Infinite loop */
   // osTimerStart(myTimer01Handle,1000);
    xTimerChangePeriod(myTimer01Handle,pdMS_TO_TICKS(1000),0);//更改软件定时器定时时间来开启定时
    osTimerStart(myTimer02Handle,2000);//自带封装了的开启软件定时器函数
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END StartDefaultTask */
}

/* Callback01 function */
void Callback01(void const * argument)
{
  /* USER CODE BEGIN Callback01 */
    printf("timer01:A");
  /* USER CODE END Callback01 */
}

/* Callback02 function */
void Callback02(void const * argument)
{
  /* USER CODE BEGIN Callback02 */
   printf("timer02:B");
  /* USER CODE END Callback02 */
}

2.5显示结果：定时器1启动后每隔1秒打印A，定时器2启动2秒后仅打印一次B
在这里插入图片描述

24 中断管理

（1）实验需求：创建一个队列及一个任务，按下按键 KEY1 触发中断，在中断服务函数里向队列里发送数据，任务则阻塞接收队列数据。
（2）代码实现：复制模板工程(工程名:muban)，点击进入CubeMX中配置中断引脚，勾选中断使能，创建1个任务和一个队列，重写中断回调函数HAL_GPIO_EXTI_Callback(),回调函数中用xQueueSendFromISR(myQueue01Handle, &snd, NULL)向队列中发送数据,然后在任务中用xQueueReceive(myQueue01Handle, &rev, portMAX_DELAY)接收数据。(工程名:int_test)
2.1 PA0设定为GPIO_EXTI0
在这里插入图片描述
2.2 中断控制器NVIC中外部中断0设定为enable

2.3 创建任务defaultTask

2.4 创建队列myQueue01

2.5 在freertos.c中编写代码

#include "stdio.h"
/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void const * argument)
{
  /* USER CODE BEGIN StartDefaultTask */
  /* Infinite loop */
  for(;;)
  {
    uint32_t rev = 0;
    if(xQueueReceive(myQueue01Handle,&rev,portMAX_DELAY) == pdTRUE)
        printf("rev=%d\r\n",rev);
    osDelay(1);
  }
  /* USER CODE END StartDefaultTask */
}

在stm32f1xx_it.c中编写代码

#include "cmsis_os.h"
extern osMessageQId myQueue01Handle;
/* USER CODE BEGIN 1 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    uint32_t snd = 1;
    xQueueSendFromISR(myQueue01Handle,&snd,NULL);
}    
/* USER CODE END 1 */