＜FreeRTOS入门第七节＞信号量学习(上)

最新推荐文章于 2023-06-19 00:15:06 发布
最新推荐文章于 2023-06-19 00:15:06 发布
阅读量378 收藏
点赞数
分类专栏： FreeRTOS学习区 文章标签： 学习 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_58149788/article/details/126197150
版权
本文详细介绍了嵌入式RTOS中的两种信号量——二值式信号量和计数型信号量。二值式信号量仅有两种状态，用于任务同步；计数型信号量则能记录队列中使用的资源数量，适用于资源管理和事件计数。文中通过创建、释放和获取信号量的API示例，展示了如何在实际任务中运用这两种信号量，并给出了相关代码实现及效果展示。
摘要由CSDN通过智能技术生成

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

今天很充实，晚上去吃席。

一、什么是信号量？

信号量就是用来管理资源和同步任务的，并且信号量可以分为二值式信号量，计数型信号量、互斥信号量，递归互斥信号量。
本编博客主要说二值式和计数型信号量。

二、二值式信号量

2.1 什么是二值式信号量

二值式信号量：就是只有两个状态，0或1。有数据和没有数据。主要用于任务同步。
其实质就是一个包含一个项的队列，这个你可以看下semaphore的相关源码就能清楚明了了。

在这里插入图片描述

在这里插入图片描述

2.2 相关API介绍

使用信号量的API时要主函数要添加semphr.h库
创建二值信号量
在这里插入图片描述

其中第一个是老版的创建二值信号量（已经淘汰），动态创建二值信号量使用xSemaphoreCreateBinary()函数。这里只讲一下动态创建API，其他自己看源码哈。

/*
	动态创建二值信号量  打开configSUPPORT_DYNAMIC_ALLOCATION宏
	BaseType_t的返回值函数。
	成功：其他值
	失败：NULL	
*/
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
    #define xSemaphoreCreateBinary()    xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE )
#endif

释放二值信号量
在这里插入图片描述

/*
	释放信号量（像队列中添加消息）
	xSemaphore：semaphore的句柄
	成功：pdTRUE 
	失败：pdFALSE
*/
#define xSemaphoreGive( xSemaphore )    xQueueGenericSend( ( QueueHandle_t ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )

获取二值信号量
在这里插入图片描述

/*
	获取二值式信号量数据
	xSemaphore：semaphore的句柄
	xBlockTime：阻塞时间
	成功：pdTRUE 
	失败：pdFALSE	
*/
#define xSemaphoreTake( xSemaphore, xBlockTime )    xQueueSemaphoreTake( ( xSemaphore ), ( xBlockTime ) )

实战
main.c
任务一获取信号量的数据然后判断在通过串口打印“Semaphore->True”
任务二使用一个变量来实现二值信号量的释放

#include "main.h"
#include "usart.h"
#include "gpio.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
#include "stdio.h"

#ifdef __GNUC__ //printf重定向
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif
PUTCHAR_PROTOTYPE
{
	HAL_UART_Transmit(&huart1, (uint8_t*)&ch,1,HAL_MAX_DELAY);
    return ch;
}

TaskHandle_t HandlerTask1;
TaskHandle_t Task_Name4;


BaseType_t xReturn;

SemaphoreHandle_t Task1semaphore;


void SystemClock_Config(void);
StackType_t xTask3Static[128];
StaticTask_t xTaskTCB;

StackType_t xIdle3Static[128];
StaticTask_t xIdleTCB;

void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,StackType_t ** ppxIdleTaskStackBuffer,uint32_t * pulIdleTaskStackSize ){
			*ppxIdleTaskTCBBuffer=&xIdleTCB;				
			*ppxIdleTaskStackBuffer=xIdle3Static;
			*pulIdleTaskStackSize=128;
}

void Task1Function( void * param){
		BaseType_t err;
	for(;;){
		if(Task1semaphore!=NULL){
			err=xSemaphoreTake(Task1semaphore,portMAX_DELAY);
			if(err==pdTRUE){
				printf("Semaphore->True\r\n");			
			}
		}
		vTaskDelay(100);
	}
}
void Task2Function(void* param){
		uint8_t num;
		
  for(;;)
  {
		num++;
		if(num==2){
			xSemaphoreGive(Task1semaphore);
			
		}else if(num==8){
			xSemaphoreGive(Task1semaphore);	
		
		}
		printf("Task%d\r\n",num);
		vTaskDelay(100);
  }
}
void Task3Funtion(void* param){
	TickType_t st_time=xTaskGetTickCount(); 

	while(1){
		uint32_t num =1;
		xTaskDelayUntil(&st_time,30);
		
	}
	
}

void Task4Funtion(void* param){
	taskENTER_CRITICAL();
	
	Task1semaphore=xSemaphoreCreateBinary();
	
	xReturn=xTaskCreate(Task1Function,"Task1",128,NULL,2,&HandlerTask1);
	
	xTaskCreate(Task2Function,"Task2",128,NULL,2,NULL);

 	xTaskCreateStatic(Task3Funtion,"Task3",128,NULL,2,xTask3Static,&xTaskTCB);
	if(xReturn == pdPASS){
			uint8_t buffS[20]="Task1 Create OK..\r\n";
			HAL_UART_Transmit(&huart1,(uint8_t*)buffS,strlen(buffS)*sizeof(char),HAL_MAX_DELAY);
			
		}
	vTaskDelete(Task_Name4);
	taskEXIT_CRITICAL();
}



int main(void)
{
  
	
	HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
	MX_USART1_UART_Init();
	
	xTaskCreate(Task4Funtion,"Task4",600,NULL,1,&Task_Name4);
	
  vTaskStartScheduler();
	
  while (1)
  {
   
  }
 
}


void SystemClock_Config(void)
{
	
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};


  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

 
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

void Error_Handler(void)
{
 
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT

void assert_failed(uint8_t *file, uint32_t line)
{

}
#endif /* USE_FULL_ASSERT */

效果展示：
在这里插入图片描述

三、计数型信号量

3.1 什么是计数型信号量

计数型信号量就是有多个队列，并且你可以读取现在队列里使用了多少的队列项，其主要用于事件计数和资源管理

3.2 相关API介绍

在这里插入图片描述

主要介绍一下计数型信号量的创建函数

/*
	动态创建计数型信号量
	uxMaxCount：队列项的数量
	uxInitialCount：队列项的初始开始位
	成功：返回其他
	失败：NULL
*/
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
    #define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount )    xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount ) )
#endif

/*
	获取计数型信号量的队列值
	SemaphoreHandle_t：信号量句柄
	成功：pdTRUE 
	失败：pdFALSE
	注意使用uxSemaphoreGetCount()函数时不要使用xSemaphoreTake();,不然获取的数一直为初始化的值
*/
UBaseType_t uxSemaphoreGetCount( SemaphoreHandle_t xSemaphore );

案例代码
main.c

#include "main.h"
#include "usart.h"
#include "gpio.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
#include "stdio.h"

#ifdef __GNUC__ //printf重定向
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif
PUTCHAR_PROTOTYPE
{
	HAL_UART_Transmit(&huart1, (uint8_t*)&ch,1,HAL_MAX_DELAY);
    return ch;
}

TaskHandle_t HandlerTask1;
TaskHandle_t Task_Name4;


BaseType_t xReturn;

SemaphoreHandle_t Task1semaphore;


void SystemClock_Config(void);
StackType_t xTask3Static[128];
StaticTask_t xTaskTCB;

StackType_t xIdle3Static[128];
StaticTask_t xIdleTCB;

void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,StackType_t ** ppxIdleTaskStackBuffer,uint32_t * pulIdleTaskStackSize ){
			*ppxIdleTaskTCBBuffer=&xIdleTCB;				
			*ppxIdleTaskStackBuffer=xIdle3Static;
			*pulIdleTaskStackSize=128;
}

void Task1Function( void * param){
		BaseType_t err;
		UBaseType_t Semaphore_num;
	for(;;){
		if(Task1semaphore!=NULL){
			//xSemaphoreTake(Task1semaphore,portMAX_DELAY);
			//if(err==pdTRUE){
				Semaphore_num=uxSemaphoreGetCount(Task1semaphore);
				printf("Semaphore->Number:%d\r\n",Semaphore_num);			
			//}
		}
		vTaskDelay(100);
	}
}
void Task2Function(void* param){
		uint8_t num;
		
  for(;;)
  {
		num++;
		xSemaphoreGive(Task1semaphore);		
		printf("Task%d\r\n",num);
		vTaskDelay(100);
  }
}
void Task3Funtion(void* param){
	TickType_t st_time=xTaskGetTickCount(); 

	while(1){
		uint32_t num =1;
		xTaskDelayUntil(&st_time,30);
		
	}
	
}

void Task4Funtion(void* param){
	taskENTER_CRITICAL();
	
	Task1semaphore=xSemaphoreCreateCounting(255,0);
	//Task1semaphore=xSemaphoreCreateBinary();
	xReturn=xTaskCreate(Task1Function,"Task1",128,NULL,2,&HandlerTask1);
	
	xTaskCreate(Task2Function,"Task2",128,NULL,2,NULL);

 	xTaskCreateStatic(Task3Funtion,"Task3",128,NULL,2,xTask3Static,&xTaskTCB);
	if(xReturn == pdPASS){
			uint8_t buffS[20]="Task1 Create OK..\r\n";
			HAL_UART_Transmit(&huart1,(uint8_t*)buffS,strlen(buffS)*sizeof(char),HAL_MAX_DELAY);
			
		}
	vTaskDelete(Task_Name4);
	taskEXIT_CRITICAL();
}



int main(void)
{
  
	
	HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
	MX_USART1_UART_Init();
	
	xTaskCreate(Task4Funtion,"Task4",600,NULL,1,&Task_Name4);
	
  vTaskStartScheduler();
	
  while (1)
  {
   
  }
 
}


void SystemClock_Config(void)
{
	
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};


  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

 
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

void Error_Handler(void)
{
 
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT

void assert_failed(uint8_t *file, uint32_t line)
{

}
#endif /* USE_FULL_ASSERT */

效果展示
在这里插入图片描述

总结

二值式信号量和计数型信号量区别就是二值式只有一个队列，计数型的队列是很多。
少壮不努力，老大徒伤悲。

单片有机机
关注
专栏目录
STM32Cube高效开发教程＜高级篇＞＜FreeRTOS＞(一)-----FreeRTOS基础
我的博客
06-27 565
一、 FreeRTOS概述声明：本人水平有限，博客可能存在部分错误的地方，请广大读者谅解并向本人反馈错误。本专栏博客参考《STM32Cube高效开发教程(高级篇)》，有意向的读者可以购买正版书籍辅助学习，本书籍由王维波老师、鄢志丹老师、王钊老师倾力打造，书籍内容干货满满。写在前面：今天就算正式开始高级篇的博客编写了，我本人也是第一次学习FreeRTOS，所以整体的进度会比较慢，博客更新可能不太会及时，希望大家原谅。一、 FreeRTOS概述。
FreeRTOS任务调度从入门到精通
最新发布
大模型大数据攻城狮的专栏
08-13 232
FreeRTOS 任务调度是 FreeRTOS 操作系统的核心功能之一，它负责根据一定的策略和算法，对系统中的多个任务进行合理的分配和处理，以确保系统的稳定性和高效性。在嵌入式系统中，任务调度尤为关键，因为它直接影响到系统的实时性和响应能力。FreeRTOS 任务调度的基本原理主要基于优先级调度算法。在 FreeRTOS 中，每个任务都被赋予一个优先级，任务调度器根据任务的优先级来决定哪个任务应该首先获得处理器的执行权。当系统中有多个任务同时处于就绪状态时，优先级最高的任务将首先被执行。
FreeRTOS学习笔记 7 - 信号量
pq的博客
05-27 256
从互斥量的定义可以看出，FreeRTOS的互斥量其实也是走的信号量。而RT Thread中定义的信号量在FreeRTOS中定义为计数信号量，对应的宏定义配置是 configUSE_COUNTING_SEMAPHORES 信号量句柄定义： #define rtosSem_t SemaphoreHandle_t 1. 创建 #define rtosSemCreate(
freeRtos学习笔记 (7)信号量
不咸不要钱
02-22 1800
freeRtos学习笔记 freeRtos信号量 优先级翻转 信号量分为四种:二值信号量,互斥信号量,计数信号量和递归互斥信号量,其中计数信号量用于管理系统多个共享资源,用计数值表示可用资源数目;二值信号量是一种特殊的计数信号量,和事件组类似,相当于裸机中的标志位,常用于任务之间的同步;互斥信号量和二值信号量类似,相比二值信号量避免了任务优先级翻转问题,因此常用来保护临界资源,但是互斥信号量不可以在中断中使用,只能在任务中使用;递归互斥信号量是一种特殊的互斥信号量,如果任务获取到递归互斥信号量后,该任务中
＜FreeRTOS入门第六节＞消息队列
sinat_58149788的博客
08-06 741
今天我学习了FreeRTOS的新知识消息队列FreeRTPS消息队列产生就是为了解决任务与任务，任务与中断之间的消息传递，一般我们在任务和任务直接消息的传递是使用一个全局变量来实现的，但是我们使用这种方法也存在一些问题。所以在FreeRTOS中就出现了消息队列。他就是相当于把任务和任务直接传递的信息拷贝到队列里面，然后在调用队列里面的信息，这样就实现了任务与任务之间消息的传递 队列不属于某一个任务，是所以任务都可以调用的入队阻塞：当wait等待设置为0时就是没有发送数据马上执行其他任务，当wait等待为我们
【FreeRTOS】FreeRTOS 动态创建任务与删除
FuckerGod的博客
06-19 982
动态创建任务需要使用到函数，我们可以在 FreeRTOS 官网中查看此函数详细的文档，点击此处跳转根据上方的描述我们可以得知，此函数将会创建一个新任务，并将其添加到就绪任务列表中。在中，必须设置为 1，或者不定义(在这种情况下，它将默认为1)，以便此函数可以使用。每个任务都需要用于保存任务状态的 RAM，并被任务用作其堆栈。如果使用创建任务，则会==从 FreeRTOS 堆中自动分配所需的 RAM ==。如果使用。
1333_FreeRTOS中xQueueSemaphoreTake函数的实现分析
小灰笔记
08-19 1717
接下来，又是一个死循环的结构，其实处理的一些机制又是有任务的处理理念了。但是，这个不同于任务的定义，这个处理是有退出返回的可能性的。接下来的处理是等待超时的过程，如果等的过程中队列不再空，那么应该是直接提取信号即可，否则的话等到超时返回为空。如果需要等待，那么这样的返回信息即使是成立也得有一个延迟的时间，这个在后面的代码逻辑中是可以看得到的。超时的很多处理在常规队列处理的时候做了一些防御式的编程，其实这个处理也是差不多的。这样的操作跟队列传递的处理还是很相似的，只是少了数据的处理。
FreeRTOS开发手册PDF，简单易懂，来源于韦东山的b站视频
05-13
1. FreeRTOS 目录结构：展示了 FreeRTOS 源码的组织方式，通常包括任务管理、时间管理、同步机制（如信号量和互斥锁）、通信机制（如队列）等子目录。 2. 核心文件：这些文件是 FreeRTOS 操作系统的核心组成部分，...
去水印 freertos入门
07-02
总结起来，去水印Freertos入门需要下载和安装FreeRTOS的开发环境，编写任务函数，使用API函数来创建和管理任务，使用同步机制来实现任务间的通信和同步，最后进行编译和下载测试。通过这个过程，我们可以初步掌握...
FreeRTOS很全的资料.7z
06-13
这个“FreeRTOS很全的资料.7z”压缩包包含了全面的学习资源，对于初学者或者想要深入理解FreeRTOS的人来说非常有价值。 首先，系统介绍部分将涵盖FreeRTOS的基本概念和架构。FreeRTOS的核心是任务调度器，它负责...
【FreeRTOS学习05】深度解剖FreeRTOSConfig.h实现对系统的自定义剪裁
01-06
ROM/RAM太小，因此要对系统进行剪裁； 文章目录1 系统的剪裁2 FreeRTOSConfig.h3 应用相关配置configUSE_PREEMPTIONconfigMAX_PRIORITIESconfigMINIMAL_STACK_SIZEconfigUSE_16_BIT_TICKSconfigUSE_CO_ROUTINESconfigMAX_CO_ROUTINE_PRIORITIES4 内存管理配置configSUPPORT_STATIC_ALLOCATIONconfigSUPPORT_DYNAMIC_ALLOCATIONconfigTOTAL_HEAP_SIZEconfigAPPLI
FreeRTOS信号量
qq_43460068的博客
02-25 1331
信号量是一种解决同步问题的机制，可以实现对共享资源的有序访问。其中，“同步”指的是任务之间的同步，即信号量可以使得一个任务等待另一个任务完成某件事后，才继续执行；而“有序访问”指的是对被多任务或中断访问的共享资源（如全局变量）的管理，当一个任务在访问（读取或写入）一个共享资源时，信号量可以防止其他任务或中断在这期间访问（读取或写入）这个共享资源。信号量是一种特殊的队列，其中二值信号量是长度为1的队列，计数型信号量是长度大于1的队列。
FreeRTOS学习-中断管理
Duran.L的专栏
03-04 3506
中断管理是一个操作系统中最核心的功能之一。在FreeRTOS中，中断总是可以打断task（尽管是最高优先级的task），而task永远不可能打断中断ISR（interrupt service routine）。本文先介绍了FreeRTOS中的中断管理，然后介绍了中断处理函数中如何使用FreeRTOS的API，最后介绍了中断处理函数与任务之间的同步方法——信号量。
【FreeRTOS】02 任务的创建
小白白学电子
05-07 6170
本节我们将分析一下FreeRTOS任务创建的过程，并结合创建时需要的参数讲解一下FreeRTOS任务的一些特性。
FreeRTOS学习（五）消息队列和二值信号量 xQueue / xSemaphore
xuehu96的博客
04-22 1724
消息队列 可以和中断 人物间发送和接受不定长的消息，在消息队列中会使任务进入阻塞。 可以在调度器开始前，创建消息队列。 #include "FreeRTOS.h" #include "queue.h" //创建成功返回消息队列句柄，失败返回NULL QueueHandle_t xQueueCreate( UBaseType_t uxQueueLength, //消息队列最大长度 Ub...
9-FreeRTOS之静态内存分配与动态内存分配
南山府的博客
12-06 1615
从9.0版本之后，FreeRTOS允许用户自己定义内存的大小，允许在以下对象创建而不用创建内存的分配： 任务 静态内存分配的创建 静态内存分配的好处是，可以更好的对应用程序的内存的利用，具有更好的控制代码的编写： 以上这些函数后面都会讲解。 下面是官方提供的有关上面这些函数的静态应用，自己可以看一下，我看了一下，基本上没有理解难度：
ESP32-C3入门教程 问题篇⑥——assert failed: prvTaskExitError port.c:165 (uxCriticalNesting == ~0UL)…重启
小康师兄
05-26 1408
ESP32-C3入门教程 问题篇⑥——assert failed: prvTaskExitError port.c:165 (uxCriticalNesting == ~0UL)…重启
24-RTOS 信号量_互斥锁 API 函数
南山府的博客
01-31 769
semphr. h创建一个，并返回一个可以引用该信号量的 句柄。必须在 FreeRTOSConfig.h 中被设置为 1，或保留未定义状态（此时，它默认 （此时默认为1），才能使用RTOSAPI函数。每个二进制信号量需要少量RAM，用于保持 信号量的状态。如果使用 xSemaphoreCreateBinary() 创建二进制信号量 则会从RAM。如果使用创建二进制信号量， 那么RAM由应用程序编写者提供，这需要用到一个附加参数， 但允许在编译时静态分配 RAM。
【嵌入式操作系统】FreeRTOS信号量mutex和semaphore的区别
NBDR_YL的博客
04-23 5560
今天学习信号量mutex和semaphore的区别，找到了正点原子的博客介绍，讲的挺详细的。建议大家阅读 转载自：https://blog.csdn.net/nippon1218/article/details/79039197 1 二值信号量 1.1 二值信号量简介 二值信号量通常用于互斥访问或同步，二值信号量和互斥信号量非常类似，但是还是有一些细微的差别，互斥信号量拥有...
freertos 信号量和rtthread信号量
06-13
FreeRTOS信号量和RT-Thread信号量都是用于线程同步和通信的机制，但它们的实现略有不同。 FreeRTOS信号量使用二进制信号量和计数信号量两种类型。二进制信号量只有两种状态，可用值为0或1，用于互斥同步；计数信号...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

单片有机机

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

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

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

打赏作者

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

抵扣说明：

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

余额充值