一、头文件

#include "FreeRTOS.h"
#include "semphr.h"

二、二值信号量

2.1 运作机制

创建信号量时，系统会为创建的信号量对象分配内存，并把可用信号量初始化为用户自定义的个数，二值信号量的最大可用信号量个数为 1。

二值信号量获取，任何任务都可以从创建的二值信号量资源中获取一个二值信号量，获取成功则返回正确，否则任务会根据用户指定的阻塞超时时间来等待其它任务/中断释放信号量。在等待这段时间，系统将任务变成阻塞态，任务将被挂到该信号量的阻塞等待列表中。

假如某个时间中断/任务释放了信号量，那么，由于获取无效信号量而进入阻塞态的任务将获得信号量并且恢复为就绪态状态。

2.2 相关API说明

2.2.1 xSemaphoreCreateBinary

用于创建一个二值信号量，并返回一个句柄。

函数	#define xSemaphoreCreateBinary() xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE )
参数	无
返回值	二值信号量句柄

要想使用该函数必须在 FreeRTOSConfig.h 中把 configSUPPORT_DYNAMIC_ALLOCATION 定义为 1 来使能。

2.2.2 vSemaphoreDelete

用于删除一个信号量，包括二值信号量，计数信号量，互斥量和递
归互斥量。如果有任务阻塞在该信号量上，那么不要删除该信号量。

函数	void vSemaphoreDelete( SemaphoreHandle_t xSemaphore )
参数	xSemaphore：信号量句柄
返回值	无

2.2.3 xSemaphoreGive（任务）

用于释放信号量的宏。释放的信号量对象必须是已经被创建的，可以用于二值信号量、计数信号量、互斥量的释放，但不能释放由函数 xSemaphoreCreateRecursiveMutex() 创建的递归互斥量。此外该函数不能在中断中使用。

函数	xSemaphoreGive( SemaphoreHandle_t xSemaphore )
参数	xSemaphore：信号量句柄
返回值	成功返回 pdTRUE，否则返回 pdFALSE

2.2.4 xSemaphoreGiveFromISR（中断）

用于释放一个信号量，带中断保护。被释放的信号量可以是二进制信号量和计数信号量。和普通版本的释放信号量 API 函数有些许不同，它不能释放互斥量，这是因为互斥量不可以在中断中使用，互斥量的优先级继承机制只能在任务中起作用，而在中断中毫无意义。

函数	xSemaphoreGiveFromISR( SemaphoreHandle_t xSemaphore, BaseType_t *pxHigherPriorityTaskWoken )
参数	xSemaphore：信号量句柄 pxHigherPriorityTaskWoken：从 FreeRTOS V7.3.0 版本开始， pxHigherPriorityTaskWoken 一个或者多个任务有可能阻塞在同一个信号量上，调用函数 xSemaphoreTakeFromISR()会唤醒阻塞在该信号量上优先级最高的信号量入队任务，如果被唤醒的任务的优先级大于或者等于被中断的任务的优先级，那么形参 pxHigherPriorityTaskWoken 就会被设置为 pdTRUE，然后在中断退出前执行一次上下文切换，中断退出后则直接返回刚刚被唤醒的高优先级的任务。从 FreeRTOS V7.3.0 版本开始， pxHigherPriorityTaskWoken 是一个可选的参数，可以设置为 NULL
返回值	成功返回 pdTRUE，否则返回 errQUEUE_FULL

函数

xSemaphoreGiveFromISR( SemaphoreHandle_t xSemaphore, BaseType_t *pxHigherPriorityTaskWoken )

参数

xSemaphore： 信号量句柄
pxHigherPriorityTaskWoken： 从 FreeRTOS V7.3.0 版本开始， pxHigherPriorityTaskWoken 一个或者多个任务有可能阻塞在同一个信号量上，调用函数 xSemaphoreTakeFromISR()会唤醒阻塞在该信号量上优先级最高的信号量入队任务，如果被唤醒的任务的优先级大于或者等于被中断的任务的优先级，那么形参 pxHigherPriorityTaskWoken 就会被设置为 pdTRUE，然后在中断退出前执行一次上下文切换，中断退出后则直接返回刚刚被唤醒的高优先级的任务。从 FreeRTOS V7.3.0 版本开始， pxHigherPriorityTaskWoken 是一个可选的参数，可以设置为 NULL

返回值

成功返回 pdTRUE，否则返回 errQUEUE_FULL

2.2.5 xSemaphoreTake（任务）

用于获取信号量，不带中断保护。获取的信号量对象可以是二值信号量、计数信号量和互斥量，但是递归互斥量并不能使用这个 API 函数获取。

函数	xSemaphoreTake( SemaphoreHandle_t xSemaphore, TickType_t xBlockTime )
参数	xSemaphore：信号量句柄 xBlockTime：等待信号量可用的最大超时时间，单位为 tick（即系统节拍周期）。如果宏 INCLUDE_vTaskSuspend 定义为 1 且形参 xTicksToWait 设置为 portMAX_DELAY ，则任务将一直阻塞在该信号量上（即没有超时时间）
返回值	成功返回 pdTRUE，否则返回 errQUEUE_EMPTY

2.2.6 xSemaphoreTakeFromISR（中断）

用于获取信号量，是一个不带阻塞机制获取信号量的函数，获取对象必须由是已经创建的信号量，信号量类型可以是二值信号量和计数信号量，它与 xSemaphoreTake()函数不同，它不能用于获取互斥量，因为互斥量不可以在中断中使用，并且互斥量特有的优先级继承机制只能在任务中起作用，而在中断中毫无意义。

函数	xSemaphoreTakeFromISR(SemaphoreHandle_t xSemaphore, signed BaseType_t *pxHigherPriorityTaskWoken)
参数	xSemaphore：信号量句柄 pxHigherPriorityTaskWoken：一个或者多个任务有可能阻塞在同一个信号量上，调用函数 xSemaphoreTakeFromISR()会唤醒阻塞在该信号量上优先级最高的信号量入队任务，如果被唤醒的任务的优先级大于或者等于被中断的任务的优先级，那么形参 pxHigherPriorityTaskWoken 就会被设置为 pdTRUE，然后在中断退出前执行一次上下文切换，中断退出后则直接返回刚刚被唤醒的高优先级的任务。从 FreeRTOS V7.3.0 版本开始， pxHigherPriorityTaskWoken 是一个可选的参数，可以设置为 NULL
返回值	成功返回 pdTRUE，否则返回 errQUEUE_EMPTY

函数

xSemaphoreTakeFromISR(SemaphoreHandle_t xSemaphore, signed BaseType_t *pxHigherPriorityTaskWoken)

参数

xSemaphore： 信号量句柄
pxHigherPriorityTaskWoken： 一个或者多个任务有可能阻塞在同一个信号量上，调用函数 xSemaphoreTakeFromISR()会唤醒阻塞在该信号量上优先级最高的信号量入队任务，如果被唤醒的任务的优先级大于或者等于被中断的任务的优先级，那么形参 pxHigherPriorityTaskWoken 就会被设置为 pdTRUE，然后在中断退出前执行一次上下文切换，中断退出后则直接返回刚刚被唤醒的高优先级的任务。从 FreeRTOS V7.3.0 版本开始， pxHigherPriorityTaskWoken 是一个可选的参数，可以设置为 NULL

返回值

成功返回 pdTRUE，否则返回 errQUEUE_EMPTY

2.3 示例

2.3.1 阻塞式

/* FreeRTOS 头文件 */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
/* 开发板硬件 bsp 头文件 */
#include "bsp_led.h"
#include "bsp_usart.h"
#include "bsp_key.h"
/**************************** 任务句柄 ********************************/
/*
* 任务句柄是一个指针，用于指向一个任务，当任务创建好之后，它就具有了一个任务句柄
* 以后我们要想操作这个任务都需要通过这个任务句柄，如果是自身的任务操作自己，那么
* 这个句柄可以为 NULL。
*/
static TaskHandle_t AppTaskCreate_Handle = NULL;/* 创建任务句柄 */
static TaskHandle_t Receive_Task_Handle = NULL;/* LED 任务句柄 */
static TaskHandle_t Send_Task_Handle = NULL;/* KEY 任务句柄 */
 
/***************************** 内核对象句柄 *****************************/
/*
* 信号量，消息队列，事件标志组，软件定时器这些都属于内核的对象，要想使用这些内核
* 对象，必须先创建，创建成功之后会返回一个相应的句柄。实际上就是一个指针，后续我
* 们就可以通过这个句柄操作这些内核对象。
*
* 内核对象说白了就是一种全局的数据结构，通过这些数据结构我们可以实现任务间的通信，
* 任务间的事件同步等各种功能。至于这些功能的实现我们是通过调用这些内核对象的函数
* 来完成的
*
*/
SemaphoreHandle_t BinarySem_Handle = NULL;

static void AppTaskCreate(void);/* 用于创建任务 */ 
static void Receive_Task(void* pvParameters);/* Receive_Task 任务实现 */ 
static void Send_Task(void* pvParameters);/* Send_Task 任务实现 */ 
static void BSP_Init(void);/* 用于初始化板载相关资源 */

int main(void)
{
    
    
    BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为 pdPASS */

    /* 开发板硬件初始化 */
    BSP_Init();
    printf("按下 KEY1 或者 KEY2 进行任务与任务间的同步\n");
    /* 创建 AppTaskCreate 任务 */
    xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate,/* 任务入口函数 */
                          (const char* )"AppTaskCreate",/* 任务名字 */
                          (uint16_t )512, /* 任务栈大小 */
                          (void* )NULL,/* 任务入口函数参数 */
                          (UBaseType_t )1, /* 任务的优先级 */
                          (TaskHandle_t*)&AppTaskCreate_Handle);/* 任务控制块指针 */
    /* 启动任务调度 */
    if (pdPASS == xReturn)
    {
    
    
        vTaskStartScheduler(); /* 启动任务，开启调度 */
    }
    else
    {
    
    
        return -1;
    } 

    while (1); /* 正常不会执行到这里 */
}

/***********************************************************************
* @ 函数名 ： AppTaskCreate
* @ 功能说明： 为了方便管理，所有的任务创建函数都放在这个函数里面
* @ 参数 ： 无
* @ 返回值 ： 无
***************************************************************/
static void AppTaskCreate(void)
{
    
    
    BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为 pdPASS */
  
    taskENTER_CRITICAL(); //进入临界区
   
    /* 创建 BinarySem */ 
    BinarySem_Handle = xSemaphoreCreateBinary();
    if (NULL != BinarySem_Handle) 
    {
    
    
        printf("BinarySem_Handle 二值信号量创建成功!\r\n"); 
    }
  
    /* 创建 Receive_Task 任务 */
    xReturn = xTaskCreate((TaskFunction_t )Receive_Task,/* 任务入口函数 */
                          (const char* )"Receive_Task",/* 任务名字 */
                          (uint16_t )512, /* 任务栈大小 */
                          (void* )NULL, /* 任务入口函数参数 */
                          (UBaseType_t )2, /* 任务的优先级 */
                          (TaskHandle_t* )&Receive_Task_Handle);/* 任务控制块指针 */
    if (pdPASS == xReturn)
    {
    
    
        printf("创建 Receive_Task 任务成功!\r\n");
    }
  
    /* 创建 Send_Task 任务 */
    xReturn = xTaskCreate((TaskFunction_t )Send_Task, /* 任务入口函数 */
                          (const char* )"Send_Task",/* 任务名字 */
                          (uint16_t )512, /* 任务栈大小 */
                          (void* )NULL,/* 任务入口函数参数 */
                          (UBaseType_t )3, /* 任务的优先级 */
                          (TaskHandle_t* )&Send_Task_Handle);/* 任务控制块指针 */
    if (pdPASS == xReturn)
    {
    
    
        printf("创建 Send_Task 任务成功!\n\n");
    }
    vTaskDelete(AppTaskCreate_Handle); //删除 AppTaskCreate 任务
    
    taskEXIT_CRITICAL(); //退出临界区
}

/**********************************************************************
* @ 函数名 ： Receive_Task
* @ 功能说明： Receive_Task 任务主体
* @ 参数 ：
* @ 返回值 ： 无
********************************************************************/
static void Receive_Task(void* parameter) 
{
    
     
    BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为 pdPASS */ 
    while (1) 
    {
    
     
        //获取二值信号量 xSemaphore,没获取到则一直等待 
        xReturn = xSemaphoreTake(BinarySem_Handle,/* 二值信号量句柄 */ 
                                portMAX_DELAY); /* 等待时间 */ 
        if (pdTRUE == xReturn) 
        {
    
    
            printf("BinarySem_Handle 二值信号量获取成功!\n\n"); 
            LED1_TOGGLE; 
        } 
    }
} 

/**********************************************************************
* @ 函数名 ： Send_Task
* @ 功能说明： Send_Task 任务主体
* @ 参数 ：
* @ 返回值 ： 无
********************************************************************/
static void Send_Task(void* parameter) 
{
    
     
    BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为 pdPASS */ 
    while (1) 
    {
    
     
        /* KEY1 被按下 */
        if ( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON ) 
        {
    
     
            xReturn = xSemaphoreGive( BinarySem_Handle );//给出二值信号量 
            if ( xReturn == pdTRUE ) 
            {
    
    
                printf("BinarySem_Handle 二值信号量释放成功!\r\n"); 
           }
            else 
            {
    
    
                printf("BinarySem_Handle 二值信号量释放失败!\r\n"); 
            }
        }

        /* KEY2 被按下 */ 
        if ( Key_Scan(KEY2_GPIO_PORT,KEY2_GPIO_PIN) == KEY_ON ) 
        {
    
     
            xReturn = xSemaphoreGive( BinarySem_Handle );//给出二值信号量 
            if ( xReturn == pdTRUE ) 
            {
    
    
                printf("BinarySem_Handle 二值信号量释放成功!\r\n"); 
            }
            else 
            {
    
    
                printf("BinarySem_Handle 二值信号量释放失败!\r\n"); 
            }
        } 
        vTaskDelay(20); 
    } 
} 

/***********************************************************************
* @ 函数名 ： BSP_Init
* @ 功能说明： 板级外设初始化，所有板子上的初始化均可放在这个函数里面
* @ 参数 ：
* @ 返回值 ： 无
*********************************************************************/
static void BSP_Init(void)
{
    
    
    /*
    * STM32 中断优先级分组为 4，即 4bit 都用来表示抢占优先级，范围为：0~15
    * 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
    * 都统一用这个优先级分组，千万不要再分组，切忌。
    */
    NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
   
    /* LED 初始化 */
    LED_GPIO_Config();
  
    /* 串口初始化 */
    USART_Config();
   
    /* 按键初始化 */
    Key_GPIO_Config();     
}

2.3.2 非阻塞式

void vTestISR( void )
{
    
    
    BaseType_t pxHigherPriorityTaskWoken;
    uint32_t ulReturn;
    /* 进入临界段，临界段可以嵌套 */
    ulReturn = taskENTER_CRITICAL_FROM_ISR();
   
    /* 判断是否产生中断 */
    {
    
    
        /* 如果产生中断，清除中断标志位 */
  
        //释放二值信号量，发送接收到新数据标志，供前台程序查询 
        xSemaphoreGiveFromISR(BinarySem_Handle,&pxHigherPriorityTaskWoken); 
  
        //如果需要的话进行一次任务切换，系统会判断是否需要进行切换 
        portYIELD_FROM_ISR(pxHigherPriorityTaskWoken); 
    }
   
    /* 退出临界段 */
    taskEXIT_CRITICAL_FROM_ISR( ulReturn );
}

三、计数信号量

3.1 运作机制

计数信号量可以用于资源管理，允许多个任务获取信号量访问共享资源，但会限制任务的最大数目。访问的任务数达到可支持的最大数目时，会阻塞其他试图获取该信号量的任务，直到有任务释放了信号量。这就是计数型信号量的运作机制，虽然计数信号量允许多个任务访问同一个资源，但是也有限定，比如某个资源限定只能有 3 个任务访问，那么第 4 个任务访问的时候，会因为获取不到信号量而进入阻塞，等到有任务（比如任务 1）释放掉该资源的时候，第 4 个任务才能获取到信号量从而进行资源的访问。

3.2 相关API说明

3.2.1 xSemaphoreCreateCounting

用于创建一个计数信号量，并返回一个句柄。

函数	SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount)
参数	uxMaxCount：计数信号量的最大值，当达到这个值的时候，信号量不能再被释放 uxInitialCount：创建计数信号量的初始值
返回值	如果创建成功则返回一个计数信号量句柄，用于访问创建的计数信号量。如果创建不成功则返回 NULL