物联网操作系统-信号量

前面介绍的队列(queue)可以用于传输数据：在任务之间、任务和中断之间。
消息队列用于传输多个数据，但是有时候我们只需要传递状态，这个状态值需要用一个
数值表示，比如：
⚫ 卖家：做好了 1 个包子！做好了 2 个包子！做好了 3 个包子！
⚫ 买家：买了 1 个包子，包子数量减 1
⚫ 这个停车位我占了，停车位减 1
⚫ 我开车走了，停车位加 1
在这种情况下我们只需要维护一个数值，使用信号量效率更高、更节省内存
本章涉及如下内容：
⚫ 怎么创建、删除信号量
⚫ 怎么发送、获得信号量
⚫ 什么是计数型信号量？什么是二进制信号量？

信号量的特性

信号量的常规操作

信号量这个名字很恰当：
⚫ 信号：起通知作用
⚫ 量：还可以用来表示资源的数量
◼ 当"量"没有限制时，它就是"计数型信号量"(Counting Semaphores)
◼ 当"量"只有 0、 1 两个取值时，它就是"二进制信号量"(Binary Semaphores)
⚫ 支持的动作： "give"给出资源，计数值加 1； "take"获得资源，计数值减 1
计数型信号量的典型场景是：
⚫ 计数：事件产生时"give"信号量，让计数值加 1；处理事件时要先"take"信号
量，就是获得信号量，让计数值减 1。
⚫ 资源管理：要想访问资源需要先"take"信号量，让计数值减 1；用完资源后
"give"信号量，让计数值加 1。
信号量的"give"、 "take"双方并不需要相同，可以用于生产者-消费者场合：
⚫ 生产者为任务 A、 B，消费者为任务 C、 D
⚫ 一开始信号量的计数值为 0，如果任务 C、 D 想获得信号量，会有两种结
果：
◼ 阻塞：买不到东西咱就等等吧，可以定个闹钟(超时时间)
◼ 即刻返回失败：不等
⚫ 任务 A、 B 可以生产资源，就是让信号量的计数值增加 1，并且把等待这个
资源的顾客唤醒
⚫ 唤醒谁？谁优先级高就唤醒谁，如果大家优先级一样就唤醒等待时间最长的
人

二进制信号量跟计数型的唯一差别，就是计数值的最大值被限定为1。

信号量跟队列的对比

差异列表如下

两种信号量的对比

信号量的计数值都有限制：限定了最大值。如果最大值被限定为 1，那么它就是二进制
信号量；如果最大值不是 1，它就是计数型信号量。

差别列表如下：

信号量函数

使用信号量时，先创建、然后去添加资源、获得资源。使用句柄来表示一个信号量。

创建

使用信号量之前，要先创建，得到一个句柄；使用信号量时，要使用句柄来表明使用哪
个信号量。

对于二进制信号量、计数型信号量，它们的创建函数不一样：

创建二进制信号量的函数原型如下：

/* 创建一个二进制信号量，返回它的句柄。
* 此函数内部会分配信号量结构体
* 返回值: 返回句柄，非 NULL 表示成功
*/
SemaphoreHandle_t xSemaphoreCreateBinary( void );
/* 创建一个二进制信号量，返回它的句柄。
* 此函数无需动态分配内存，所以需要先有一个 StaticSemaphore_t 结构体，并传入它的
指针
* 返回值: 返回句柄，非 NULL 表示成功
*/
SemaphoreHandle_t xSemaphoreCreateBinaryStatic( StaticSemaphore_t *pxSemaphoreBuf
fer );

创建计数型信号量的函数原型如下：

/* 创建一个计数型信号量，返回它的句柄。
* 此函数内部会分配信号量结构体
* uxMaxCount: 最大计数值
* uxInitialCount: 初始计数值
* 返回值: 返回句柄，非 NULL 表示成功
*/
SemaphoreHandle_t xSemaphoreCreateCounting(UBaseType_t uxMaxCount, UBaseType_t
uxInitialCount);
/* 创建一个计数型信号量，返回它的句柄。
* 此函数无需动态分配内存，所以需要先有一个 StaticSemaphore_t 结构体，并传入它的
指针
* uxMaxCount: 最大计数值
* uxInitialCount: 初始计数值
* pxSemaphoreBuffer: StaticSemaphore_t 结构体指针
* 返回值: 返回句柄，非 NULL 表示成功
*/
SemaphoreHandle_t xSemaphoreCreateCountingStatic( UBaseType_t uxMaxCount,
UBaseType_t uxInitialCount,
StaticSemaphore_t *pxSemaphore
Buffer );

删除

对于动态创建的信号量，不再需要它们时，可以删除它们以回收内存。

vSemaphoreDelete可以用来删除二进制信号量、计数型信号量，函数原型如下：

/*
* xSemaphore: 信号量句柄，你要删除哪个信号量
*/
void vSemaphoreDelete( SemaphoreHandle_t xSemaphore );

give/take

二进制信号量、计数型信号量的 give、 take 操作函数是一样的。这些函数也分为 2 个版
本：给任务使用，给 ISR 使用。 列表如下：

xSemaphoreGive的函数原型如下：

BaseType_t xSemaphoreGive( SemaphoreHandle_t xSemaphore );

xSemaphoreGive 函数的参数与返回值列表如下：

pxHigherPriorityTaskWoken的函数原型如下：

BaseType_t xSemaphoreGiveFromISR(
SemaphoreHandle_t xSemaphore,
BaseType_t *pxHigherPriorityTaskWoken
);

xSemaphoreGiveFromISR 函数的参数与返回值列表如下：

xSemaphoreTake的函数原型如下：

BaseType_t xSemaphoreTake(
SemaphoreHandle_t xSemaphore,
TickType_t xTicksToWait
);

xSemaphoreTake 函数的参数与返回值列表如下：

xSemaphoreTakeFromISR的函数原型如下：

BaseType_t xSemaphoreTakeFromISR(
SemaphoreHandle_t xSemaphore,
BaseType_t *pxHigherPriorityTaskWoken
);

xSemaphoreTakeFromISR 函数的参数与返回值列表如下：

示例 ：使用二进制信号量来同步

main函数中创建了一个二进制信号量，然后创建2个任务：一个用于释放信号量，另一
个用于获取信号量，代码如下：

/* 二进制信号量句柄 */
SemaphoreHandle_t xBinarySemaphore;
int main( void )
{
prvSetupHardware();
/* 创建二进制信号量 */
xBinarySemaphore = xSemaphoreCreateBinary( );
if( xBinarySemaphore != NULL )
{
/* 创建 1 个任务用于释放信号量
* 优先级为 2
*/
xTaskCreate( vSenderTask, "Sender", 1000, NULL, 2, NULL );
/* 创建 1 个任务用于获取信号量
* 优先级为 1
*/
xTaskCreate( vReceiverTask, "Receiver", 1000, NULL, 1, NULL );
/* 启动调度器 */
vTaskStartScheduler();
}
{
/* 无法创建二进制信号量 */
}
/* 如果程序运行到了这里就表示出错了, 一般是内存不足 */
return 0;
}

发送任务、接收任务的代码和执行流程如下：
⚫ A：发送任务优先级高，先执行。连续 3 次释放二进制信号量，只有第 1 次
成功
⚫ B：发送任务进入阻塞态
⚫ C：接收任务得以执行，得到信号量，打印 OK；再次去获得信号量时，进入
阻塞状态
⚫ 在发送任务的 vTaskDelay 退出之前，运行的是空闲任务：现在发送任务、接
收任务都阻塞了
⚫ D：发送任务再次运行，连续 3 次释放二进制信号量，只有第 1 次成功
⚫ E：发送任务进入阻塞态
⚫ F：接收任务被唤醒，得到信号量，打印 OK；再次去获得信号量时，进入阻
塞状态

运行结果如下图所示，
即使发送任务连续释放多个信号量，也只能成功1次。释放、获得信号量是一一对应的。

示例 : 防止数据丢失

在上个示例中，发送任务发出3次"提醒"，但是接收任务只接收到1次"提醒"，其中2次"提
醒"丢失了。
这种情况很常见，比如每接收到一个串口字符，串口中断程序就给任务发一次"提醒"，
假设收到多个字符、发出了多次"提醒"。当任务来处理时，它只能得到1次"提醒"。
你需要使用其他方法来防止数据丢失，比如：
⚫ 在串口中断中，把数据放入缓冲区
⚫ 在任务中，一次性把缓冲区中的数据都读出
⚫ 简单地说，就是：你提醒了我多次，我太忙只响应你一次，但是我一次性拿
走所有数据

main 函数中创建了一个二进制信号量，然后创建 2 个任务：一个用于释放信号量，另
一个用于获取信号量，代码如下：

/* 二进制信号量句柄 */
SemaphoreHandle_t xBinarySemaphore;
int main( void )
{
prvSetupHardware();
/* 创建二进制信号量 */
xBinarySemaphore = xSemaphoreCreateBinary( );
if( xBinarySemaphore != NULL )
{
/* 创建 1 个任务用于释放信号量
* 优先级为 2
*/
xTaskCreate( vSenderTask, "Sender", 1000, NULL, 2, NULL );
/* 创建 1 个任务用于获取信号量
* 优先级为 1
*/
xTaskCreate( vReceiverTask, "Receiver", 1000, NULL, 1, NULL );
/* 启动调度器 */
vTaskStartScheduler();
}
else
{
/* 无法创建二进制信号量 */
}
/* 如果程序运行到了这里就表示出错了, 一般是内存不足 */
return 0;
}

发送任务、接收任务的代码和执行流程如下：
⚫ A：发送任务优先级高，先执行。连续写入 3 个数据、释放 3 个信号量：只
有 1 个信号量起作用
⚫ B：发送任务进入阻塞态
⚫ C：接收任务得以执行，得到信号量
⚫ D：接收任务一次性把所有数据取出
⚫ E：接收任务再次尝试获取信号量，进入阻塞状态
⚫ 在发送任务的 vTaskDelay 退出之前，运行的是空闲任务：现在发送任务、接
收任务都阻塞了
⚫ F：发送任务再次运行，连续写入 3 个数据、释放 3 个信号量：只有 1 个信
号量起作用
⚫ G：发送任务进入阻塞态
⚫ H：接收任务被唤醒，得到信号量，一次性把所有数据取出

程序运行结果如下，数据未丢失：

示例 : 使用计数型信号量

使用计数型信号量时，可以多次释放信号量；当信号量的技术值达到最大时，再次释放
信号量就会出错。
如果信号量计数值为n，就可以连续n次获取信号量，第(n+1)次获取信号量就会阻塞或
失败。

main函数中创建了一个计数型信号量，最大计数值为3，初始值计数值为0；然后创建2
个任务：一个用于释放信号量，另一个用于获取信号量，代码如下：

/* 计数型信号量句柄 */
SemaphoreHandle_t xCountingSemaphore;
int main( void )
{
prvSetupHardware();
/* 创建计数型信号量 */
xCountingSemaphore = xSemaphoreCreateCounting(3, 0);
if( xCountingSemaphore != NULL )
{
/* 创建 1 个任务用于释放信号量
* 优先级为 2
*/
xTaskCreate( vSenderTask, "Sender", 1000, NULL, 2, NULL );
/* 创建 1 个任务用于获取信号量
* 优先级为 1
*/
xTaskCreate( vReceiverTask, "Receiver", 1000, NULL, 1, NULL );
/* 启动调度器 */
vTaskStartScheduler();
}
else
{
/* 无法创建信号量 */
}
/* 如果程序运行到了这里就表示出错了, 一般是内存不足 */
return 0;
}

发送任务、接收任务的代码和执行流程如下：
⚫ A：发送任务优先级高，先执行。连续释放 4 个信号量：只有前面 3 次成
功，第 4 次失败
⚫ B：发送任务进入阻塞态
⚫ CDE：接收任务得以执行，得到 3 个信号量
⚫ F：接收任务试图获得第 4 个信号量时进入阻塞状态
⚫ 在发送任务的 vTaskDelay 退出之前，运行的是空闲任务：现在发送任务、接
收任务都阻塞了
⚫ G：发送任务再次运行，连续释放 4 个信号量：只有前面 3 次成功，第 4 次
失败
⚫ H：发送任务进入阻塞态
⚫ IJK：接收任务得以执行，得到 3 个信号量
⚫ L：接收任务再次获取信号量时进入阻塞状态