STM32 CubeMX （第二步Freertos任务通信：队列、信号量、互斥量，事件组，任务通知）

已于 2023-08-18 22:29:03 修改
阅读量2.3k 收藏 21
点赞数 5
分类专栏： STM32 CubeMX Rtos 文章标签： stm32 嵌入式硬件 单片机
于 2023-08-17 00:26:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46039185/article/details/132307672
版权

STM32 CubeMX

STM32 CubeMX ____Freertos任务通信：队列、信号量、互斥量，事件组，任务通知

学习使用Freertos第二步
在 FreeRTOS 中，任务通信可以通过以下函数来实现：

  1. xQueueCreate()：用于创建一个消息队列。可以设置队列长度和每个消息的大小。

xQueueSend()：将一条消息发送到队列中。可以选择阻塞或非阻塞发送。

xQueueReceive()：从队列中接收一条消息。可以选择阻塞或非阻塞接收。

xQueuePeek()：查看队列中的下一条消息，但不将其移除。

xQueueReset()：清空队列中的所有消息。
2. xQueueSemaphoreTake()和xQueueSemaphoreGive()：用于实现二值信号量，控制任务之间的互斥访问。
3. xSemaphoreCreateMutex()：创建一个互斥信号量，用于实现任务之间的互斥访问。
4. xTaskNotify()和ulTaskNotifyTake()：用于任务间的通知机制，一个任务可以通知另一个任务进行某种操作。
5. xEventGroupCreate()、xEventGroupSetBits()和xEventGroupWaitBits()：用于创建、设置和等待事件标志组。

一、STM32 CubeMX设置

时钟配置

在这里插入图片描述

HAL时基选择TIM1（不要选择滴答定时器；滴答定时器留给OS系统做时基）

在这里插入图片描述

使用STM32 CubeMX 库，配置Freertos

选择CMISS_V1接口就可以满足Freertos接口；且代码量比CMISS_V2小（CMISS_V2支持更多的RTOS接口，所以代码量比CMISS_V1多）
在这里插入图片描述

二、实验一：消息队列

消息队列是什么？适用于什么地方？

  • 数据传递：消息队列允许任务之间传递数据，一个任务可以将数据打包成消息发送到队列，另一个任务则可以从队列中接收该消息并处理其中的数据。这使得任务之间可以方便地进行数据交换和共享。
  • 任务解耦：通过使用消息队列，任务之间的耦合度可以降低。一个任务只需要关注发送和接收消息，而不需要知道消息的具体处理细节和目标任务的实现。这样，当需要更改或替换某个任务时，只需要保证消息的格式和接口不变即可，不会对其他任务产生影响。
  • 同步与协作：消息队列可以用于实现任务之间的同步和协作。例如，一个任务可以等待某个特定的消息到达队列后才继续执行，从而实现任务间的同步。另外，多个任务可以通过发送和接收消息来协调彼此的执行顺序和操作。
  • 缓冲和调节：消息队列可以充当缓冲区，用于存储一定数量的消息。当发送方发送消息速度较快，而接收方处理速度较慢时，消息队列可以暂时存储未处理的消息，避免数据丢失。同时，消息队列还可以调节发送和接收任务之间的速度差异，以平衡任务负载。

FreeRTOS 消息队列和数组 的几个区别：

  • 数据组织方式：消息队列是一种先进先出（FIFO）的数据结构，用于存储和传递消息。每个消息都可以包含不同类型和长度的数据。而数组是一种线性的、连续的数据结构，用于存储相同类型和长度的元素。
  • 功能和用途：消息队列主要用于任务间通信，允许任务之间传递数据和进行同步。它提供了数据传递、解耦、同步和协作等功能。而数组通常用于存储一组具有相同类型的元素，可以进行遍历、访问和修改等操作。
  • 大小和容量：消息队列的大小是可以动态调整的，可以根据需要增加或减少队列的容量。而数组的大小在创建时就确定，并且通常是固定的。
  • 可用性和效率：消息队列可以实现多个任务之间的并发通信，提供了较高的可用性和灵活性。而数组通常在单个任务内进行操作，具有较高的效率和直接性
  • 总的来说，消息队列和数组是两种不同的数据结构，适用于不同的场景和需求。消息队列主要用于任务间通信和数据传递，具有灵活性和可调节性；而数组主要用于存储相同类型的元素，并进行遍历和访问操作。选择使用哪种数据结构取决于具体的应用需求和功能要求。

创建消息队列

在这里插入图片描述

  • Queue Name： 队列名称
  • Queue Size： 队列能够存储的最大单元数目，即队列深度
  • Queue Size： 队列中数据单元的长度，以字节为单位
  • Allocation： 分配方式：Dynamic 动态内存创建
  • Buffer Name： 缓冲区名称
  • Buffer Size： 缓冲区大小
  • Conrol Block Name： 控制块名称

创建任务

在这里插入图片描述

  • Task Name： 任务名称
  • Priority： 优先级，在 FreeRTOS 中，数值越大优先级越高，0 代表最低优先级
  • Stack Size (Words)： 堆栈大小，单位为字，在32位处理器（STM32），一个字等于4字节，如果传入128那么任务大小为128*4字节
  • Entry Function： 入口函数
  • Code Generation Option： 代码生成选项
  • Parameter： 任务入口函数形参，不用的时候配置为0或NULL即可
  • Allocation： 分配方式：Dynamic 动态内存创建
  • Buffer Name： 缓冲区名称
  • Conrol Block Name： 控制块名称

代码部分

void sendTask1(void const * argument)
{
  /* USER CODE BEGIN sendTask1 */
	BaseType_t xsatus;
	uint32_t buff=9600;
  /* Infinite loop */
  for(;;)
  {
      xsatus=xQueueSendToBack(myQueue01Handle,&buff,0);
			 if( xsatus!=pdPASS)
			 {
			 printf("输入失败\r\n");		// printf输出字符串
			 }
			 else
			 {
			 printf("成功写入%d\r\n", buff);		// printf输出字符串
			 }
			 osDelay(1000);
  }
  /* USER CODE END sendTask1 */
}
void readTask3(void const * argument)
{
  /* USER CODE BEGIN readTask3 */
  BaseType_t xsatus;
	uint32_t buff=115200;
  /* Infinite loop */
  for(;;)
  {
      xsatus=xQueueReceive(myQueue01Handle,&buff,0);
		  if( xsatus!=pdPASS)
			 {
			 printf("读取失败\r\n");		// printf输出字符串
			 }
			 else
			 {
			 printf("成功读取%d\r\n", buff);		// printf输出字符串
			 }
			  osDelay(3000);
  }
  /* USER CODE END readTask3 */
}

实验现象

在这里插入图片描述

 
			 xsatus=xQueueSendToBack(myQueue01Handle,&buff,portMAX_DELAY);//一直等待
			 if( xsatus!=pdPASS)
			 {
			 printf("输入失败\r\n");		// printf输出字符串
			 }
			 else
			 {
			 printf("成功写入%d\r\n", buff);		// printf输出字符串
			 }

还一种方式：读取不会删除信息（偷窥信息）

三，实验二：信号量

信号量是什么？适用于什么地方？

FreeRTOS中的信号量是一种用于任务间同步和资源共享的机制。它可以用来实现任务之间的互斥访问共享资源，或者在某个任务等待某个事件发生时进行阻塞。

FreeRTOS提供了两种类型的信号量：二进制信号量（Binary Semaphore）和计数信号量（Counting Semaphore）。

二进制信号量是一种简单的信号量，只有两种状态：空闲和占用。当一个任务获取到二进制信号量时，它就可以继续执行，而其他任务则会被阻塞。当任务释放二进制信号量时，其他任务可以获取到它并继续执行。

计数信号量是一种更复杂的信号量，它可以有多个资源可供获取。计数信号量可以用来实现资源池的管理，例如限制同时访问某个资源的任务数量。

在FreeRTOS中，可以使用以下函数来创建和操作信号量：

  • xSemaphoreCreateBinary(): 创建二进制信号量。
  • xSemaphoreCreateCounting(): 创建计数信号量。
  • xSemaphoreTake(): 获取一个信号量。
  • xSemaphoreGive(): 释放一个信号量。

需要注意的是，使用信号量时要确保正确的获取和释放顺序，以避免出现死锁或资源竞争的问题。

二值信号量

创建信号量
在这里插入图片描述

代码部分

void sendTask1(void const * argument)
{
  /* USER CODE BEGIN sendTask1 */
	BaseType_t xsatus;
	uint32_t buff=9600;
  /* Infinite loop */
  for(;;)
  {
		
       if( xSemaphoreTake(myBinarySem01Handle,portMAX_DELAY)!=pdPASS)
			 {
			  printf("刷新失败#信号量获取失败\r\n");		// printf输出字符串
			 }
			 else
			 {
			  printf("成功刷新#信号量获取成功\r\n");		// printf输出字符串
			 }
	
			 osDelay(2000);
  }
  /* USER CODE END sendTask1 */
}
void readTask3(void const * argument)
{
  /* USER CODE BEGIN readTask3 */
  BaseType_t xsatus;
	uint32_t buff=115200;
  /* Infinite loop */
  for(;;)
  {
  
		 	 if( xSemaphoreGive(myBinarySem01Handle)!=pdPASS)
			 {
			  printf("读取失败#信号量不能释放\r\n");		// printf输出字符串
			 }
			 else
			 {
			  printf("成功读取#信号量已经释放\r\n");		// printf输出字符串
			 }
			  osDelay(1000);
  }
  /* USER CODE END readTask3 */
}

实验现象

在这里插入图片描述

计数信号量

创建计数信号量
在这里插入图片描述
在这里插入图片描述

代码部分

void sendTask1(void const * argument)
{
  /* USER CODE BEGIN sendTask1 */
	BaseType_t xsatus;
	uint32_t buff=9600;
  /* Infinite loop */
  for(;;)
  {
		
       if( xSemaphoreGive(myCountingSem01Handle)!=pdTRUE)
			 {
			  printf("停车已满\r\n");		// printf输出字符串
			 }
			 else
			 {
			  printf("停车成功\r\n");		// printf输出字符串
			 }
			 osDelay(2000);
  }
  /* USER CODE END sendTask1 */
}
void readTask3(void const * argument)
{
  /* USER CODE BEGIN readTask3 */
  BaseType_t xsatus;
	uint32_t buff=115200;
  /* Infinite loop */
  for(;;)
  {
  
		 	 if( xSemaphoreTake(myCountingSem01Handle,0)!=pdTRUE)
			 {
			  printf("无车\r\n");		// printf输出字符串
			 }
			 else
			 {
			   printf("取走车\r\n");		// printf输出字符串
			 }
			  osDelay(1000);
  }
  /* USER CODE END readTask3 */
}

实验现象

在这里插入图片描述

四，实验三：互斥量

互斥量是什么？适用于什么地方？

FreeRTOS中的互斥量（Mutex）是一种用于保护共享资源的同步机制。它可以确保在任何给定时刻只有一个任务可以访问被保护资源，以避免竞争条件和数据损坏。

在FreeRTOS中，互斥量通过以下API函数进行创建、获取和释放：

  • xSemaphoreCreateMutex()：用于创建一个互斥量，并返回一个指向该互斥量的句柄。
  • xSemaphoreTake()：用于获取（锁定）互斥量。如果互斥量当前未被锁定，则任务可以 获取互斥量并继续执行；否则，任务将被阻塞，直到互斥量可用。
  • xSemaphoreGive()：用于释放（解锁）互斥量。一旦任务完成了对共享资源的访问，应该调用此函数来释放互斥量，以允许其他任务获取它。
    创建互斥量
    在这里插入图片描述

代码部分

void sendTask1(void const * argument)
{
  /* USER CODE BEGIN sendTask1 */
	BaseType_t xsatus;
	uint32_t buff=9600;
  /* Infinite loop */
  for(;;)
  {
		 osDelay(20);
       if(xSemaphoreTake(myMutex01Handle,portMAX_DELAY)!=pdTRUE)
			 {
			   printf("1号：你上完厕所，下一个就轮到我了\r\n");		// printf输出字符串
			 }
			 else
			 {
			   printf("1号：现在是我在上厕所\r\n");		// printf输出字符串
				 xSemaphoreGive(myMutex01Handle);
	       printf("1号：我上完了\r\n");		// printf输出字符串
			 }	
			 osDelay(2000);
  }
  /* USER CODE END sendTask1 */
}

/* USER CODE BEGIN Header_sendTask2 */
/**
* @brief Function implementing the Task2 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_sendTask2 */
void sendTask2(void const * argument)
{
  /* USER CODE BEGIN sendTask2 */
	BaseType_t xsatus;
	uint32_t buff=115200;
  /* Infinite loop */
  for(;;)
  {
     xSemaphoreTake(myMutex01Handle,0); 
     printf("2号：我在厕所\r\n");		// printf输出字符串
	   osDelay(3000);
     printf("2号：我上完了\r\n");		// printf输出字符串
	   xSemaphoreGive(myMutex01Handle);
     osDelay(2000);
	}
  /* USER CODE END sendTask2 */
}

/* USER CODE BEGIN Header_readTask3 */
/**
* @brief Function implementing the read thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_readTask3 */
void readTask3(void const * argument)
{
  /* USER CODE BEGIN readTask3 */
  BaseType_t xsatus;
	uint32_t buff=115200;
  /* Infinite loop */
  for(;;)
  {
      if(xSemaphoreTake(myMutex01Handle,0)!=pdTRUE)
			 {
			   printf("3号：厕所有人，等一会儿再来\r\n");		// printf输出字符串
			 }
			 else
			 {
			    printf("3号：到我上小便了\r\n");		// printf输出字符串
	        printf("3号：我撒完尿了\r\n");		// printf输出字符串
				  xSemaphoreGive(myMutex01Handle);
			 }	 
			  osDelay(1000);
  }
  /* USER CODE END readTask3 */
}

实验现象

在这里插入图片描述

五，实验四：事件组

互斥量是什么？适用于什么地方？

FreeRTOS事件组是一个用于多任务协调和通信的机制。它允许任务等待多个事件同时发生，并在事件发生后恢复任务的执行。事件组可以用于线程同步、互斥、事件通知等应用场景。

FreeRTOS事件组由32位的二进制位表示，每个事件标志位对应一个事件。任务可以通过等待特定的事件标志位来挂起自己的执行，并在其中一个或多个事件标志位被设置时被唤醒。任务还可以使用事件组的API函数来设置或清除特定的事件标志位。

以下是一些常用的FreeRTOS事件组API函数：

  1. xEventGroupCreate()：创建一个新的事件组。
  2. vEventGroupDelete()：删除已创建的事件组。
  3. xEventGroupSetBits()：设置一个或多个事件标志位。
  4. xEventGroupClearBits()：清除一个或多个事件标志位。
  5. xEventGroupWaitBits()：等待一个或多个事件标志位被设置。

使用FreeRTOS事件组可以实现任务之间的同步和通信，提高系统的可靠性和效率。
**CMSIS_V1不支持创建事件组，所以手创建 **

EventGroupHandle_t myEvent=NULL;//创建句柄
myEvent = 	xEventGroupCreate(); //创建事件组

与逻辑，事件组

任务代码：

/* USER CODE END Header_sendTask1 */
void sendTask1(void const * argument)
{
  /* USER CODE BEGIN sendTask1 */
	BaseType_t xsatus;
	uint32_t buff=9600;
  /* Infinite loop */
  for(;;)
  {
		     printf("1号：这个方案我同意了\r\n");		// printf输出字符串
         xEventGroupSetBits(myEvent,0x0001);			   
		     osDelay(2000);
  }
  /* USER CODE END sendTask1 */
}

/* USER CODE BEGIN Header_sendTask2 */
/**
* @brief Function implementing the Task2 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_sendTask2 */
void sendTask2(void const * argument)
{
  /* USER CODE BEGIN sendTask2 */
	BaseType_t xsatus;
	uint32_t buff=115200;
  /* Infinite loop */
  for(;;)
  {
		     osDelay(5000);
         printf("2号：这个方案我同意了\r\n");		// printf输出字符串
         xEventGroupSetBits(myEvent,0x0010);			   			
	}
  /* USER CODE END sendTask2 */
}

/* USER CODE BEGIN Header_readTask3 */
/**
* @brief Function implementing the read thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_readTask3 */
void readTask3(void const * argument)
{
  /* USER CODE BEGIN readTask3 */
  BaseType_t xsatus;
	uint32_t buff=115200;
  /* Infinite loop */
  for(;;)
  {
        buff=xEventGroupWaitBits(myEvent,0x0011,pdTRUE,pdTRUE,portMAX_DELAY);//1.句柄；2.哪些位；3.读完清零；4.全部有效(与逻辑)；5.等待时间
		    if(buff==0x0011)
				{
				   printf("3号：好这个方案全票同意\r\n");		// printf输出字符串
				}
			  osDelay(10000);
  }
  /* USER CODE END readTask3 */
}

实验现象

在这里插入图片描述

或逻辑，事件组

void sendTask1(void const * argument)
{
  /* USER CODE BEGIN sendTask1 */
	BaseType_t xsatus;
	uint32_t buff=9600;
  /* Infinite loop */
  for(;;)
  {
		     printf("1号：这个方案我同意了\r\n");		// printf输出字符串
         xEventGroupSetBits(myEvent,0x0001);			   
		     osDelay(2000);
  }
  /* USER CODE END sendTask1 */
}

/* USER CODE BEGIN Header_sendTask2 */
/**
* @brief Function implementing the Task2 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_sendTask2 */
void sendTask2(void const * argument)
{
  /* USER CODE BEGIN sendTask2 */
	BaseType_t xsatus;
	uint32_t buff=115200;
  /* Infinite loop */
  for(;;)
  {
		     osDelay(5000);
         printf("2号：这个方案我同意了\r\n");		// printf输出字符串
         xEventGroupSetBits(myEvent,0x0010);			   			
	}
  /* USER CODE END sendTask2 */
}

/* USER CODE BEGIN Header_readTask3 */
/**
* @brief Function implementing the read thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_readTask3 */
void readTask3(void const * argument)
{
  /* USER CODE BEGIN readTask3 */
  BaseType_t xsatus;
	uint32_t buff=115200;
  /* Infinite loop */
  for(;;)
  {
        buff=xEventGroupWaitBits(myEvent,0x0011,pdTRUE,pdFALSE,portMAX_DELAY);//1.句柄；2.哪些位；3.读完清零；4.全部有效(与逻辑)；5.等待时间
		    if((buff==0x0010)||(buff==0x0001))
				{
				   printf("3号：好方案通过，下一个方案\r\n");		// printf输出字符串
				}
 
  }
  /* USER CODE END readTask3 */
}

实验现象

在这里插入图片描述

六，实验五：任务通知

无情大菜刀
关注
  • 5
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
STM32CubeMX FreeRTOS 互斥锁
weixin_46286415的博客
12-15 1132
语句表示调用当前函数，即递归调用。这是为了模拟同一线程在递归调用中多次获取和释放递归互斥锁。为了简化演示，这里使用了延时，模拟任务执行一段时间后再次尝试获取锁。任务执行结束后，相应的资源将被释放。在递归调用返回后，表示退出临界区并释放递归互斥锁。在FreeRTOSConfig.h文件中，确保。在FreeRTOSConfig.h文件中，确保。宏被设置为1，以启用互斥锁。配置串口重定向，选好记得保存。宏被设置为1，以启用互斥锁。配置串口重定向，选好记得保存。在任务执行结束时，调用。二、互斥锁（Mutex）
STM32CubeMX——FREERTOS学习：消息队列Queue
m0_49968063的博客
03-28 2207
队列，也叫消息队列，就是把消息一条一条的排个队。 比如创建了一个消息队列，这个消息队列可以存10条消息。任务A可以往里存消息，任务B也可以往里存。这个存的消息是要讲先来后到的，存满了10条消息就不能存了。假设任务C从里面去消息，也是一条一条的取，按照先后顺序取，先存的先取，后存的后取。信息取一个，队列里面就少一个，取10个之后，消息队列就空了。 往队列里面存消息，如果队列已经满了，可以一直等着，直到队列里面有空位置，也可以等一会，没空位离开。 从队列里面取消息，如果队列已经空了，可以一直等着，直到队列
FreeRTOS任务通知
最新发布
2301_78772787的博客
05-15 1039
而这里的实验成功模仿了二值信号量的获取释放，按下KEY1发送二至信号量，再次按下KEY2接收二值信号量。如果被通知任务没有取走上一个通知，又接收到了一个通 知，则这次通知值丢弃，在这种情况下视为调用失败并返回 pdFALSE。按键KEY1按下发送多个计数型型号量，按键KEY2按下一次接收计数型型号了，同时任务通知值递减。这里的相关配置是基于上一个实验的，所以与上面的CubeMX配置流程相同。如果被通知的任务当前没有通知，则被通知的任务的通知值设为ulValue。
一篇文章教会你：CubeMX使用FreeRTOS编程指南
WC211314F的博客
07-06 4314
互斥量其实就是一个拥有优先级继承的二值信号量，互斥信号量适合用于那些需要互斥访问的应用中，在互斥访问中互斥信号量相当于一个钥匙，当任务想要使用资源的时候就必须先获得这个钥匙，当使用完资源以后就必须归还这个钥匙，这样其他的任务就可以拿着这个钥匙去使用资源，与信号量不同的是，互斥量的释放必须由获取他的任务进行释放，如果不释放，可能会造成死锁。消息队列常用的是插入与获取消息，初始化系统已经帮助我们完成，在初始化的时候会获取一个队列的句柄，之后对队列的操作都是围绕这个句柄展开，比如上面的代码中，句柄就是。
使用STM32CubeMx完成FreeRTOS操作系统移植
anyi66622的博客
04-27 3796
通过STM32CUBEMX创建新工程，移植官方库文件实现FREERTOS系统移植
FreeRTOS（STM32CubeMX）
JiaYu的博客
08-07 5862
FreeRTOS（Real-Time Operating System）是一款开源的实时操作系统内核，专为嵌入式系统和微控制器设计。FreeRTOS提供了一套功能丰富的实时调度和任务管理机制，可用于在嵌入式系统中实现多任务处理。FreeRTOS的主要目标是为嵌入式应用程序提供一个轻量级、高效和可移植的实时操作系统。它被广泛应用于各种嵌入式设备和应用领域，如工业自动化、物联网设备、消费电子、汽车控制系统、医疗设备等。
STM32CubeMx+freeRTOS的使用
weixin_38743772的博客
08-21 8623
利用STM32CubeMx生成freeRTOS代码，并进行使用
STM32CubeMX Freertos 外部中断处理例程
01-04
在这个特定的示例中，我们关注的是如何在STM32CubeMX中配置FreeRTOS，并创建一个处理外部中断的例程，适用于STM32F103RCT6这款芯片。 STM32F103RCT6是STM32系列中的一款经典芯片，具有高性能、低功耗的特点，拥有多...
STM32F429 FreeRTOS实战：实现FreeRTOS任务通知模拟事件标志组【支持STM32F42X系列单片机】.zip
12-15
它提供了任务调度、信号量、互斥锁、消息队列、事件标志组等多种同步和通信机制，以实现并发执行的任务管理和资源管理。 3. **FreeRTOS任务**： 任务是FreeRTOS中的基本执行单元，每个任务都是一个独立的线程。...
STM32F429 FreeRTOS实战：实现FreeRTOS互斥信号量操作【支持STM32F42X系列单片机】.zip
12-15
这个项目着重于如何在STM32F429芯片上实现FreeRTOS的互斥信号量操作，这对于实现多任务并发和资源保护至关重要。 FreeRTOS是为嵌入式系统设计的开源RTOS，它提供了调度、任务、信号量、互斥锁、消息队列等多种功能...
STM32MP157 FreeRTOS实现任务通知模拟二值信号量【支持STM32MP1系列单片机_FreeRTOS系统】.zip
02-27
在这个项目中，我们将深入探讨如何在STM32MP157上使用FreeRTOS实现任务通知和模拟二值信号量。 首先，FreeRTOS的任务通知是一种轻量级的同步机制，允许任务间传递简单信息，如事件发生或者数据可用。任务通知可以...
STM32H743 FreeRTOS实现任务通知模拟二值信号量【支持STM32H7系列单片机_FreeRTOS操作系统】.zip
01-30
在这个项目中，我们将深入探讨如何在STM32H743上使用FreeRTOS实现任务通知，以及如何模拟二值信号量。 FreeRTOS是一个实时操作系统内核，它提供了任务调度、中断处理、同步和通信机制等核心功能。在FreeRTOS中，...
FreeRtos 操作系统 STM32 CubeMx系列教程
Joseph Wen的博客
11-22 1119
本系列学习笔记是对“韦东山FreeRtos学习系列教程”和B站up主“愿意做我的战士吗”的FreeRtos操作系统教程的总结。
STM32CUBEMX创建FREERTOS之队列
qq_43497365的博客
11-04 2730
目录1. 创建队列1.1 动态创建入队函数 1. 创建队列 1.1 动态创建 QueueHandle_t xQueueCreate(UBaseType_t uxQueueLength,UBaseType_t uxItemSize) 示例 QueueHandle_t Message_Queue; //句柄 #define Message_Q_NUM 4 //队列长度 #define USART_REC_LEN 50 //定义最大接收字节数 50 Message_Queue = xQ
STM32CubeMX学习笔记（30）——FreeRTOS实时操作系统使用（信号量）
Leung的博客
12-29 6963
一、FreeRTOS简介 FreeRTOS 是一个可裁剪、可剥夺型的多任务内核，而且没有任务数限制。FreeRTOS 提供了实时操作系统所需的所有功能，包括资源管理、同步、任务通信等。 FreeRTOS 是用 C 和汇编来写的，其中绝大部分都是用 C 语言编写的，只有极少数的与处理器密切相关的部分代码才是用汇编写的，FreeRTOS 结构简洁，可读性很强！最主要的是非常适合初次接触嵌入式实时操作系统学生、嵌入式系统开发人员和爱好者学习。 最新版本 V9.0.0（2016年），尽管现在 FreeRTOS 的
STM32CubeMX+FATFS+FREERTOS读写U盘
chen18221987993的博客
02-08 3364
使用STM32CubeMX配置基于FATFS和FREERTOS读写U盘
STM32CubeMX之freeRTOS消息通知（有点全能）
weixin_63163242的博客
08-12 114
进入前不清除数据，退出清除数据参数 0x0000000000 0xffffffff的意思。任务通知是任务自带的程序，不需要单独去创建。这里就是发送过去，然后把其存到了num中。不要有太多疑问，并不是发送num过去的。如果能覆盖就可以一直发。
STM32CubeMX学习笔记（31）——FreeRTOS实时操作系统使用(互斥量)
Leung的博客
12-30 6959
一、FreeRTOS简介 FreeRTOS 是一个可裁剪、可剥夺型的多任务内核，而且没有任务数限制。FreeRTOS 提供了实时操作系统所需的所有功能，包括资源管理、同步、任务通信等。 FreeRTOS 是用 C 和汇编来写的，其中绝大部分都是用 C 语言编写的，只有极少数的与处理器密切相关的部分代码才是用汇编写的，FreeRTOS 结构简洁，可读性很强！最主要的是非常适合初次接触嵌入式实时操作系统学生、嵌入式系统开发人员和爱好者学习。 最新版本 V9.0.0（2016年），尽管现在 FreeRTOS 的
STM32CubeMx+FreeRTOS+Clion运用事件组开发按键
不想随波逐流的大学生一枚，我们每个人都在努力奔跑
02-19 1155
STM32CubeMx+FreeRTOS+Clion运用事件组开发按键
stm32cubemx中freertos配置
07-28
在STM32CubeMX中配置FreeRTOS的步骤如下： 1. 打开STM32CubeMX，并选择你的目标STM32微控制器型号。 2. 在"Pinout & Configuration"选项卡中，配置你的引脚和时钟设置。 3. 在"Middleware"选项卡中，找到并启用FreeRTOS。可以在"RTOS"子选项卡中找到它。 4. 在FreeRTOS配置页面，你可以设置任务、信号量、队列以及其他FreeRTOS相关的参数。 5. 点击"Generate Code"按钮以生成初始化代码。 6. 选择你喜欢的IDE（如Keil、IAR等），导入生成的代码并构建项目。 7. 在你的应用程序中使用FreeRTOS API编写任务和其他相关代码。 需要注意的是，这些步骤只是基本的配置过程，根据你的具体需求，你可能还需要对FreeRTOS进行更深入的配置和定制。你可以参考STM32CubeMX的官方文档以获取更详细的配置指南和示例代码。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值