FREERTOS学习五--信号量Semaphore

已于 2023-04-28 17:53:50 修改
阅读量1.1k 收藏 4
点赞数 1
分类专栏： FreeRTOS 文章标签： 单片机 物联网 stm32 mcu
于 2023-03-28 13:40:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49968063/article/details/129811968
版权
文章介绍了信号量在任务间同步和资源管理中的作用，包括二值信号量和计数信号量的概念。二值信号量用于简单的同步，如婴儿饿了的信号；计数信号量用于管理有限资源，如停车位。文中还详细阐述了创建、等待、释放和删除信号量的相关函数，并提供了二值信号量和计数信号量的使用示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

前言

  队列主要用在任务之间传递数据，当然也可以是任务与中断之间传递数据。

如果只是为了传递一种状态，比如婴儿饿了，他就开始哭，这时候他妈妈就要过来喂奶了。这个哭声就是一个信号，他妈妈只要收到信号了就喂奶。这个信号量只表示饿与不饿，叫二值信号量。二值信号量主要用于任务之间的同步，或者中断与任务之间的同步。

如果是为了统筹共享的资源，比如停车场有100个停车位，停一辆车就少一个空位，走一辆车就多一个空位，这也是一个信号量，叫计数信号量。

一、信号量是什么？

        信号量，理解字面意思就可以了，就是描述信号的量。其实信号量也是一个消息队列，二值信号量就相当于一个深度为1但是没有数据的消息队列

二、与信号量相关的函数

//1、创建信号量函数，二值信号量与计数信号量都是这个函数来创建
osSemaphoreId osSemaphoreCreate (const osSemaphoreDef_t *semaphore_def, int32_t count);

//2、等待并获取信号量
int32_t osSemaphoreWait (osSemaphoreId semaphore_id, uint32_t millisec);

//3、释放信号量
osStatus osSemaphoreRelease (osSemaphoreId semaphore_id);

//4、删除信号量
osStatus osSemaphoreDelete (osSemaphoreId semaphore_id);

//5、获得信号量的值
uint32_t osSemaphoreGetCount(osSemaphoreId semaphore_id)

函数讲解与分析

1、创建信号量函数

/**
* @brief 创建并初始化一个信号量
* @param 需要创建的信号量
* @param 计数的值         
* @retval  返回信号量ID
*/
osSemaphoreId osSemaphoreCreate (const osSemaphoreDef_t *semaphore_def, int32_t count)
{ 
//如果同时支持动态分配内存和静态分配内存
#if( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

  osSemaphoreId sema;
  
  //判断信号量的控制块，如果不是空的，表示要使用静态分配内存，就用静态创建函数
  if (semaphore_def->controlblock != NULL){

    if (count == 1) { //如果计数值是1，表示创建二值信号量
      return xSemaphoreCreateBinaryStatic( semaphore_def->controlblock );
    }
    else {
//如果计数值不是1，且配置了使用计数信号量，就创建计数信号量
#if (configUSE_COUNTING_SEMAPHORES == 1 )
      return xSemaphoreCreateCountingStatic( count, count, semaphore_def->controlblock );
#else
      return NULL;
#endif
    }
  }
  else {//如果信号量的控制块是空的，就用动态方式创建函数
    if (count == 1) { //计数值为1，那就创建二值信号量
      vSemaphoreCreateBinary(sema);
      return sema;
    }
    else {//计数值不是1，就创建计数信号量
//创建计数信号量的前提是在配置里面使能了计数信号量
#if (configUSE_COUNTING_SEMAPHORES == 1 )	
      return xSemaphoreCreateCounting(count, count);
#else
      return NULL;
#endif    
    }
  }
//如果仅支持静态创建函数
#elif ( configSUPPORT_STATIC_ALLOCATION == 1 )
  if(count == 1) {//计数值==1，就创建二值信号量
    return xSemaphoreCreateBinaryStatic( semaphore_def->controlblock );
  }
  else
  {
//计数值不等于1，就创建计数信号量
#if (configUSE_COUNTING_SEMAPHORES == 1 )
      return xSemaphoreCreateCountingStatic( count, count, semaphore_def->controlblock );
#else
      return NULL;
#endif    
  }
#else  // 如果只支持动态创建函数
  osSemaphoreId sema;
 
  if (count == 1) {//计数值为1，创建二值信号量
    vSemaphoreCreateBinary(sema);
    return sema;
  }
  else {//计数值不为1，创建计数信号量
#if (configUSE_COUNTING_SEMAPHORES == 1 )	
    return xSemaphoreCreateCounting(count, count);
#else
    return NULL;
#endif
  }
#endif
}

  2、等待并获取信号量

/**
* @brief 获取信号量
* @param  信号量ID
* @param  超时时间
* @retval  取到了就返回osOK,没取到就报错
*/
int32_t osSemaphoreWait (osSemaphoreId semaphore_id, uint32_t millisec)
{
  TickType_t ticks;
  portBASE_TYPE taskWoken = pdFALSE;  
  
  //没有信号量ID，直接报错
  if (semaphore_id == NULL) {
    return osErrorParameter;
  }
  
  ticks = 0;
  if (millisec == osWaitForever) { //如果是一直等，tick值设置为最大
    ticks = portMAX_DELAY;
  }
  else if (millisec != 0) {//如果是等某个时间，把ms时间转换成tick
    ticks = millisec / portTICK_PERIOD_MS;
    if (ticks == 0) {
      ticks = 1;
    }
  }
  
  if (inHandlerMode()) { //如果是中断模式，就从中断中取信号量
    if (xSemaphoreTakeFromISR(semaphore_id, &taskWoken) != pdTRUE) {
      return osErrorOS;
    }
	portEND_SWITCHING_ISR(taskWoken);
  }  
  
    //如果不是中断模式，也就是任务模式
  else if (xSemaphoreTake(semaphore_id, ticks) != pdTRUE) {
    return osErrorOS;
  }
  
  return osOK;
}

3、释放信号量 

/**
* @brief 释放一个信号量
* @param  信号量ID
* @retval  返回状态

*/
osStatus osSemaphoreRelease (osSemaphoreId semaphore_id)
{
  osStatus result = osOK;
  portBASE_TYPE taskWoken = pdFALSE;
  
  //中断模式释放信号量
  if (inHandlerMode()) {
    if (xSemaphoreGiveFromISR(semaphore_id, &taskWoken) != pdTRUE) {
      return osErrorOS;
    }
    portEND_SWITCHING_ISR(taskWoken);
  }
  else {//任务模式释放信号量
    if (xSemaphoreGive(semaphore_id) != pdTRUE) {
      result = osErrorOS;
    }
  }
  
  return result;
}

4、删除信号量

/**
* @brief 删除一个信号量
* @param  被删除的信号量ID
* @retval  status code that indicates the execution status of the function.

*/
osStatus osSemaphoreDelete (osSemaphoreId semaphore_id)
{
   //中断模式不能删除信号量
  if (inHandlerMode()) {
    return osErrorISR;
  }

  vSemaphoreDelete(semaphore_id);

  return osOK; 
}

5、获取信号量的计数值

/**
* @brief  Returns the current count value of a counting semaphore
* @param  semaphore_id  semaphore_id ID obtained by \ref osSemaphoreCreate.
* @retval  count value
*/
uint32_t osSemaphoreGetCount(osSemaphoreId semaphore_id)
{
  return uxSemaphoreGetCount(semaphore_id);
}

三、信号量的使用

        二值信号量的使用

二值信号量主要用于任务之间的通知，比如在任务StartTask02中按下一个按键，就释放一个信号量。

void StartTask02(void const * argument)
{

  for(;;)
  {
    if(HAL_GPIO_ReadPin(KEY_1_GPIO_Port,KEY_1_Pin) == GPIO_PIN_RESET)
    {
      HAL_Delay(20);
      while(HAL_GPIO_ReadPin(KEY_1_GPIO_Port,KEY_1_Pin) == GPIO_PIN_RESET);
      if(osSemaphoreRelease(myBinarySem01Handle)!= osOK)
      {

      } else{
        osThreadSuspendAll();
        printf("send BinarySem sucess! \r\n");
        osThreadResumeAll();
      }
    }
    osDelay(1);
  }
}

   建一个任务来取二值信号量，取到信号量就改变一下LED的状态

void StartTask03(void const * argument)
{
  for(;;)
  {
    if(osSemaphoreWait(myBinarySem01Handle,osWaitForever)!=osOK)
    {
      printf("get BinarySem fialed! \r\n");
    }else{
      printf("get BinarySem success! \r\n");
      HAL_GPIO_TogglePin(LED_B_GPIO_Port,LED_B_Pin);  
    } 
    osDelay(1);
  }
}

二值信号量的使用需要注意一点，在创建好二值信号量之后，里面就有信号了，所以上面的实例，还没按下按键，只要单片机复位一下LED灯的状态就改变了，也会打印信息说get到二值信号量，实际工程应用的时候需要注意。

    计数信号量的使用

计数信号量主要用来统筹资源，或者统计资源的，比如统计停车场的停车位，建立一个计数信号了，计数值为10，相当于停车场有10个停车位，进来一辆车，停车位就少一个，出去一辆车停车位就增加一个。因此可以建立两个任务，一个任务用来模拟进停车场，一个任务用来模拟出停车场。

先建立一个计数信号量，建立一个计数值为10的计数信号量，相当于一个停车场有10个空位

  osSemaphoreDef(myCountingSem01);
  myCountingSem01Handle = osSemaphoreCreate(osSemaphore(myCountingSem01), 10);

再建立一个任务，用按键模拟出停车场，按一下按键出一辆车，同时读出计数值的大小

void StartTask02(void const * argument)
{
  uint16_t m;
  for(;;)
  {
    if(HAL_GPIO_ReadPin(KEY_1_GPIO_Port,KEY_1_Pin) == GPIO_PIN_RESET)
    {
      HAL_Delay(20);
      while(HAL_GPIO_ReadPin(KEY_1_GPIO_Port,KEY_1_Pin) == GPIO_PIN_RESET);
      if(osSemaphoreRelease(myCountingSem01Handle)!= osOK)
      {

      } else{
        osThreadSuspendAll();
        m = osSemaphoreGetCount(myCountingSem01Handle);
        printf("m = %d \r\n",m);
        printf("send BinarySem sucess! \r\n");
        osThreadResumeAll();
      }
    }
    osDelay(1);
  }
}

再建一个任务，用按键模拟进停车场，按一下按键进一辆车，计数值就自动-1

void StartTask03(void const * argument)
{
  uint16_t n;
  for(;;)
  {
    if(HAL_GPIO_ReadPin(KEY_3_GPIO_Port,KEY_3_Pin) == GPIO_PIN_RESET)
    {
      HAL_Delay(20);
      while(HAL_GPIO_ReadPin(KEY_3_GPIO_Port,KEY_3_Pin) == GPIO_PIN_RESET);
      if(osSemaphoreWait(myCountingSem01Handle,osWaitForever)!=osOK)
      {   
        printf("get BinarySem fialed! \r\n");
      }else{      
        printf("get BinarySem success! \r\n");
        n = osSemaphoreGetCount(myCountingSem01Handle);
        printf("n = %d \r\n",n);
        HAL_GPIO_TogglePin(LED_B_GPIO_Port,LED_B_Pin);    
      }  
    }
    osDelay(1);
  }
}

6.FreeRTOS学习笔记-信号量
Car12
11-17 1011
基本概念 抽象的来讲，信号量是一个非负整数，所有获取它的任务都会将该整数减一（获取它当然是为了使用资源），当该整数值为零时，所有试图获取它的任务都将处于阻塞状态 二值信号量 二值信号量既可以用于临界资源访问也可以用于同步功能 互斥量有优先级继承机制，二值信号量则没有这个机制 二值信号量更偏向应用于同步功能（任务与任务间的同步或任务和中断间同步） 而互斥量更偏向应用于临界资源的访问 将二值信号量看作只有一个消息的队列因此这个队列只能为空或满 计数信号量 计数信号量肯定是用于计数
ESP32-IDF开发实例-FreeRTOS信号量-二值信号量
视觉与物联智能
06-07 1205
信号量-二值信号量 信号量（Semaphore）是一种任务间通信的机制，可以实现任务之间同步或临界资源的互斥访问。信号量通常用于一组相互竞争的任务来访问临界资源。 FreeRTOS分别提供了二值信号量和计数信号量，其中二值信号量可以理解成计数信号量的特殊形式。二值信号量资源被获取了，信号量的值就变为0，信号资源被释放了，信号量的值就为1，只有0和1两种情况。 任务间通过二值信号量同步抽象如下： 调用步骤如下： 创建任务Task1、Task2 创建二值信号量，其默认值为0，即没有可用资源 任务Task1
Free RTOS中Semaphore（二值信号量）的使用介绍
mftang的博客
05-16 2577
本文主要介绍Free RTOS中Semaphore的使用方法，包括使用STM32Cube中配置FreeRTOS，并且使能Semaphore，还介绍了Free RTOS中Semaphore中相关的函数。还通过一个简单的实例，来介绍Semaphore的使用方法。
CubeMx 配置FreeRTOS是存在报错，osSemaphoreCreate, osSemaphoreWait未定义
ZYH10140的博客
02-22 1237
和Hal库版本不兼容问题导致的，使用CubeMa生成的函数会生成老版本的，所以需要改掉。 F470\F470.axf: Error: L6218E: Undefined symbol osSemaphoreWait (referred from syscall.o). F470\F470.axf: Error: L6218E: Undefined symbol osSemaphoreCreate (referred from syscall.o). FreeRTos HAL库配置RTOS STM32移植
FreeRTOS 中的信号量：概念、类型与用法详解
最新发布
wanghao312的博客
03-25 371
二值信号量：单次事件通知（如中断触发）。计数信号量：多资源池管理（如内存块、连接池）。互斥量：保护临界资源（如硬件外设）。递归互斥量：允许同一任务多次获取同一锁。正确选择信号量类型可显著提升系统可靠性与效率，开发者需根据具体场景权衡设计。
RTOS Semaphore Services
weixin_34261739的博客
06-07 99
http://www.beck-ipc.com/files/api/scxxx/rtxover.htm Semaphores are used to guarantee a task mutually exclusive access to a critical resource. Semaphores synchronize asynchronous occurring activities....
FreeRTOS笔记（五）信号量semaphore
m0_58575472的博客
03-14 426
为此，FreeRTOS引入了信号量（Semaphore）概念，通过信号量的同步机制可以使消费者任务在数据还没到达的时候进入阻塞状态，并让出CPU资源给其他任务。假设一个简单的生产者消费者模型--有两个任务，一个任务是数据的生产者（Producer）任务，一个任务是数据的消费者（Consumer）任务，二进制信号量适用于在数据产生的频率比较低的场合。按照正常的思路，消费者任务和生产者任务会轮流执行，但是如果在消费者任务执行的时候数据还没有产生的话，消费者任务的运行就是无用的，会降低CPU的使用效率。
12、FreeRTOS信号量(semaphore)
Lim的博客
05-11 1342
信号量（Semaphore），是在多任务环境下使用的一种机制，是可以用来保证两个或多个关键代码段不被并发调用。信号量这个名字，我们可以把它拆分来看，信号可以起到通知信号的作用，然后我们的量还可以用来表示资源的数量，当我们的量只有0和1的时候，它就可以被称作二值信号量，只有两个状态，当我们的那个量没有限制的时候，它就可以被称作为计数型信号量。信号量也是队列的一种二值信号量其实就是一个长度为1，大小为零的队列，只有0和1两种状态，通常情况下，我们用它来进行互斥访问或任务同步。互斥访问。
详解FreeRTOS中的信号量(semaphore)
闪耀大叔的博客
04-11 4115
在这种情况下，事件处理程序将在每次事件发生时“give”一个信号量——导致信号量的计数值在每次“give”时增加。可以将延迟处理任务的优先级设置最高，然后，在ISR中调用portYIELD_FROM_ISR()，ISR结束后会运行延迟处理的任务（因为它优先级最高）。当一个任务完成对资源的处理后，它将信号量的计数值向后递增“give”信号量。t1时Task1运行，Task2阻塞等待信号量，t2时发生中断，ISR执行，give一个信号量解除Task2的阻塞态，t3时Task2运行，结束后继续等待下一个信号量。
RTOS介绍------五、信号量 semaphore
cesare20的博客
01-22 2056
Concepts 在编程中，信号量是一个变量，用于控制 多线程或多进程 对 共享资源的访问。它类似于互斥锁，因为它可以阻止其他线程访问共享资源或临界区。 但是，mutex意味着对锁拥有所有权（即 在临界区执行时，单个线程被称为拥有锁），信号量则是计数器，它可以允许多个线程进入临界区。 理论上讲，信号量是一个共享的counter，可以做原子级别的加减（PV操作）。例如，上图中Task A，B，C都想进入临界区。每个Task都调用了semaphoreTake()，使得信号量计数减1.这时，这三个task都在临
FreeRTOS学习 --- 信号量
gdragen_的博客
02-03 1055
当一个互斥信号量正在被一个低优先级的任务持有时， 如果此时有个高优先级的任务也尝试获取这个互斥信号量，那么这个高优先级的任务就会被阻塞。互斥信号量有任务优先级继承的机制， 但是中断不是任务，没有任务优先级， 所以互斥信号量只能用与任务中，不能用于中断服务函数。的队列，因此计数型信号量能够容纳多个资源，这在计数型信号量被创建的时候确定的。使用计数型信号量的过程：创建计数型信号量 --->使用二值信号量的过程：创建二值信号量 --->信号量表示有效的资源数目。），其他任务会获取计数型信号量（计数值-1。
【树莓派Pico FreeRTOS】-Semaphore（信号量）
视觉与物联智能
03-23 286
本文将详细介绍如何在Raspberry Pi Pico上使用信号量进行任务同步。
freertos通讯---信号量与队列
vircun的博客
04-28 832
哈喽,又见面了. 一.信号量 1.1创建二进制信号量 #define xSemaphoreCreateBinary() xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE ) 上篇队列已经提到,信号量也是用队列实现的.这里semSEM...
FreeRTOS_信号量(Semaphore)
w237838的博客
11-11 321
若同时有多个消费者，则会有先提供给优先级更高的，若优先级相等，则提供给等待时间最长的。当消费者想要获得资源时，若信号量的计数值未0，则消费者可以阻塞也可以直接返回失败。当生产者”give“资源后，就会将计数值加1，并且唤醒正在阻塞等待的消费者。此函数用于删除使用动态方法创建的信号量，它会释放回收资源并避免内存泄漏。信号量的使用流程：创建信号量、添加资源、获得资源、删除信号量。读写信号量的函数有两套：在任务中使用、在ISR中使用。，所以更加节省内存，并且容易维护。信号量根据最大计数值的不同分为。
FreeRTOS 中Semaphore 的用法
m0_37817135的博客
11-09 5503
FreeRTOS 中Semaphore 的用法 FreeRTOS引入了信号量（Semaphore）概念，通过信号量的同步机制可以使消费者任务在数据还没到达的时候进入阻塞状态，并让出CPU资源给其他任务。信号量是一种同步机制，可以起到消息通知和提高CPU利用率的作用。 网摘： Semaphore是一件可以容纳N人的房间，如果人不满就可以进去，如果人满了，就要等待有人出来。对于N=1的情况，称为binary semaphore。一般的用法是，用于限制对于某一资源的同时访问。 semaphore可以由其它进程释放
FreeRTOS信号量（semaphore）
sakabu的博客
08-10 901
前面介绍的队列(queue)可以用于传输数据：在任务之间、任务和中断之间。有时候我们只需要传递状态，并不需要传递具体的信息，比如：我的事做完了，通知一下你卖包子了、卖包子了，做好了1个包子！做好了2个包子！做好了3个包子！这个停车位我占了，你们只能等着在这种情况下我们可以使用信号量(semaphore)，它更节省内存。信号量（Semaphore），是在多任务环境下使用的一种机制，是可以用来保证两个或多个关键代 码段不被并发调用。信号量这个名字，我们可以把它拆分来看，
【FreeRTOS】信号量 semaphore（附源码）
你要拥有一个你喜欢并且热爱的人生
06-09 494
前面介绍的队列(queue)可以用于传输数据：在任务之间、任务和中断之间。 有时候我们只需要传递状态，并不需要传递具体的信息，比如： 我的事做完了，通知一下你； 卖包子了、卖包子了，做好了1个包子！做好了2个包子！做好了3个包子； 这个停车位我占了，你们只能等着； 综上所述，在这种情况下我们可以使用信号量(semaphore)，它更节省内存。
Hal库自动生成Freertos时出现osSemaphoreCreate和osSemaphoreWait报错
weixin_57634511的博客
07-03 918
将osSemaphoreCreate(osSemaphore(SEM), 1);改成 osSemaphoreNew(1,1,osSemaphore(SEM));由于freertos和Hal版本问题，生成的函数会生成老版本的，所以不兼容，需要改掉。将osSemaphoreWait改成osSemaphoreAcquire。
freertos（第七课，semaphore, mutex, msg queue）
Huskar_Liu的博客
05-22 2373
freertos是一个多进程操作系统。 多进程的一个重要控制，就是进程同步。 大多数的OS，都会基于PV操作完成进程同步。 基于EVENT的进程同步， event在OS中，被表示为一个结构体对象，最简单的情况下，只有一个数据成员。 需要同步的进程，分别向OS申请P操作或者申请V操作，并告知OS，所锚定的event对象。 OS检查event的状态，并对发出申请的进程执行相应的状态切换。 申请P操作的进程，将被OS尝试阻塞，如果event状态允许进程继续执行，则不阻塞，而允许进程继续执行。如果event状态不允
freeRTOS使用Lab-Project-FreeRTOS-POSIX-1.0中sem_destory的示例代码
11-15
FreeRTOS是一个实时操作系统(RTOS)，特别适合嵌入式系统。在Lab-Project-FreeRTOS-POSIX-1.0这个项目中，`sem_destroy()`函数用于销毁之前创建的信号量，释放与之关联的资源。以下是一个简单的示例代码片段： ```c // 首先，包含必要的头文件 #include "FreeRTOS.h" #include "task.h" #include "Semaphore.h" // 定义信号量 SemaphoreHandle_t xSemaphore; // 创建信号量 void create_semaphore() { xSemaphore = xSemaphoreCreateMutex(); } // 当不再需要信号量时，进行销毁 void destroy_semaphore() { if (xSemaphore != NULL) { vSemaphoreDelete(xSemaphore); xSemaphore = NULL; printf("Semaphore destroyed.\n"); } else { printf("Semaphore already destroyed.\n"); } } // 示例任务，演示如何在任务之间同步 void example_task(void *pvParameters) { // 等待信号量 vSemaphoreTake(xSemaphore, portMAX_DELAY); // ... 这里是任务体 ... // 任务完成后，释放信号量 vSemaphoreGive(xSemaphore); } int main(void) { // 初始化FreeRTOS vTaskStartScheduler(); // 如果这里返回，意味着初始化失败 for( ;; ); } ``` 在这个例子中，`create_semaphore()`函数创建了一个互斥信号量。`example_task()`会在执行前等待该信号量。当主任务或其他任务完成某些操作后通过`vSemaphoreGive()`将其释放，允许`example_task()`继续执行。而`destroy_semaphore()`则用于在程序结束时安全地删除信号量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值