FreeRTOS进阶信号量示例的完全解析

目录

FreeRTOS的信号量包括二进制信号量、计数信号量、互斥信号量(以后简称互斥量)和递归互斥信号量(以后简称递归互斥量)。关于它们的区别可以参考《 FreeRTOS系列第19篇---FreeRTOS信号量》一文。

信号量API函数实际上都是宏,它使用现有的队列机制。这些宏定义在semphr.h文件中。如果使用信号量或者互斥量,需要包含semphr.h头文件。

二进制信号量、计数信号量和互斥量信号量的创建API函数是独立的,但是获取和释放API函数都是相同的;递归互斥信号量的创建、获取和释放API函数都是独立的。

1.信号量创建

在《FreeRTOS高级篇5---FreeRTOS队列分析》中,我们分析了队列的实现过程,包括队列创建、入队和出队操作。在那篇文章中我们说过,创建队列API函数实际是调用通用队列创建函数xQueueGenericCreate()来实现的。其实,不但创建队列实际调用通用队列创建函数,二进制信号量、计数信号量、互斥量和递归互斥量也都直接或间接使用这个函数,如表1-1所示。表1-1中红色字体表示是间接调用xQueueGenericCreate()函数。

表1-1:队列、信号量和互斥量创建宏与直接(间接)执行函数

1.1.创建二进制信号量

二进制信号量创建实际上是直接使用通用队列创建函数xQueueGenericCreate()。创建二进制信号量API接口实际上是一个宏,定义如下:

#define xSemaphoreCreateBinary()         \       xQueueGenericCreate(              \                ( UBaseType_t ) 1,       \                semSEMAPHORE_QUEUE_ITEM_LENGTH,  \                NULL,              \                NULL,              \                queueQUEUE_TYPE_BINARY_SEMAPHORE\                )

通过这个宏定义我们知道创建二进制信号量实际上是创建了一个队列,队列项有1个,但是队列项的大小为0(宏semSEMAPHORE_QUEUE_ITEM_LENGTH定义为0)。

有了队列创建的知识,我们可以很容易的画出初始化后的二进制信号量内存,如图1-1所示。

图1-1:初始化后的二进制信号量对象内存

或许不止一人像我一样奇怪,创建一个没有队列项存储空间的队列,信号量用什么表示?其实二进制信号量的释放和获取都是通过操作队列结构体成员uxMessageWaiting来实现的(图1-1红色部分,uxMessageWaiting表示队列中当前队列项的个数)。经过初始化后,变量uxMessageWaiting为0,这说明队列为空,也就是信号量处于无效状态。在使用API函数xSemaphoreTake()获取信号之前,需要先释放一个信号量。后面讲到二进制信号量释放和获取时还会详细介绍。

1.2.创建计数信号量

创建计数信号量间接使用通用队列创建函数xQueueGenericCreate()。创建计数信号量API接口同样是个宏定义:

#define xSemaphoreCreateCounting(uxMaxCount, uxInitialCount )             \       xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount ), (NULL ) )

创建计数信号量API接口有两个参数,含义如下:

uxMaxCount:最大计数值,当信号到达这个值后,就不再增长了。uxInitialCount:创建信号量时的初始值。

我们来看一下函数xQueueCreateCountingSemaphore()如何实现的:

QueueHandle_t xQueueCreateCountingSemaphore( const UBaseType_tuxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue ){QueueHandle_t xHandle;     configASSERT( uxMaxCount != 0 );    configASSERT( uxInitialCount <= uxMaxCount );       /*调用通用队列创建函数*/    xHandle =xQueueGenericCreate(          uxMaxCount,          queueSEMAPHORE_QUEUE_ITEM_LENGTH,          NULL,          pxStaticQueue,          queueQUEUE_TYPE_COUNTING_SEMAPHORE );     if( xHandle != NULL )    {        ( ( Queue_t * ) xHandle )->uxMessagesWaiting = uxInitialCount;    }    configASSERT( xHandle );    return xHandle;}

从代码可以看出,创建计数信号量仍然调用通用队列创建函数xQueueGenericCreate()来创建一个队列,队列项的数目由参数uxMaxCount指定,每个队列项的大小由宏queueSEMAPHORE_QUEUE_ITEM_LENGTH指出,我们找到这个宏定义发现,这个宏被定义为0,也就是说创建的队列只有队列数据结构存储空间而没有队列项存储空间。

如果队列创建成功,则将队列结构体成员uxMessageWaiting设置为初始计数信号量值。初始化后的计数信号量内存如图3-1所示。

图1-2:初始化后的计数信号量对象内存

1.3创建互斥量

创建互斥量间接使用通用队列创建函数xQueueGenericCreate()。创建互斥量API接口同样是个宏,定义如下:

#define xSemaphoreCreateMutex()             \          xQueueCreateMutex( queueQUEUE_TYPE_MUTEX, NULL )

其中,宏queueQUEUE_TYPE_MUTEX用于通用队列创建函数,表示创建队列的类型是互斥量,在文章《FreeRTOS高级篇5---FreeRTOS队列分析》关于通用队列创建函数参数说明中提到了这个宏。

我们来看一下函数xQueueCreateMutex()是如何实现的:

#if ( configUSE_MUTEXES == 1 )    QueueHandle_t xQueueCreateMutex( const uint8_tucQueueType, StaticQueue_t *pxStaticQueue )    {    Queue_t *pxNewQueue;    const UBaseType_tuxMutexLength = ( UBaseType_t ) 1, uxMutexSize = ( UBaseType_t ) 0;         /* 防止编译器产生警告信息 */        ( void ) ucQueueType;               /*调用通用队列创建函数*/        pxNewQueue = ( Queue_t * )xQueueGenericCreate( uxMutexLength, uxMutexSize, NULL, pxStaticQueue, ucQueueType );         /* 成功分配新的队列结构体? */        if( pxNewQueue != NULL )        {            /*xQueueGenericCreate()函数会按照通用队列的方式设置所有队列结构体成员,但是我们是要创建互斥量.因此需要对一些结构体成员重新赋值. */            pxNewQueue->pxMutexHolder = NULL;                      pxNewQueue->uxQueueType =queueQUEUE_IS_MUTEX;  //NULL             /* 用于递归互斥量创建 */            pxNewQueue->u.uxRecursiveCallCount = 0;             /* 使用一个预期状态启动信号量 */            ( void ) xQueueGenericSend( pxNewQueue, NULL, ( TickType_t ) 0U, queueSEND_TO_BACK);        }         return pxNewQueue;    }#endif /* configUSE_MUTEXES */

这个函数是带条件编译的,只有将宏configUSE_MUTEXES定义为1才会编译这个函数。

函数首先调用通用队列创建函数xQueueGenericCreate()来创建一个队列,队列项数目为1,队列项大小为0,说明创建的队列只有队列数据结构存储空间而没有队列项存储空间。

如果队列创建成功,通用队列创建函数还会按照通用队列的方式 初始化所有队列结构体成员。但是这里要创建的是互斥量,所以有一些结构体成员必须重新赋值。在这段代码中,可能你会疑惑,队列结构体成员中,并没有pxMutexHolder和uxQueueType!其实这两个标识符只是宏定义,是专门为互斥量而定义的,如下所示:

#define pxMutexHolder                                     pcTail#define uxQueueType                                       pcHead#define queueQUEUE_IS_MUTEX                               NULL

当队列结构体用于互斥量时,成员pcHead和pcTail指针就不再需要,并且将pcHead指针设置为NULL,表示pcTail指针实际指向互斥量持有者任务TCB(如果有的话)。

最后调用函数xQueueGenericSend()释放一个互斥量,相当于互斥量创建后是有效的,可以直接使用获取信号量API函数来获取这个互斥量。如果某资源同时只准一个任务访问,可以用互斥量保护这个资源。这个资源一定是存在的,所以创建互斥量时会先释放一个互斥量,表示这个资源可以使用。任务想访问资源时,先获取互斥量,等使用完资源后,再释放它。也就是说互斥量一旦创建好后,要先获取,后释放,要在同一个任务中获取和释放。这也是互斥量和二进制信号量的一个重要区别,二进制信号量可以在随便一个任务中获取或释放,然后也可以在任意一个任务中释放或获取。互斥量不同于二进制信号量的还有:互斥量具有优先级继承机制,二进制信号量没有,互斥量不可以用于中断服务程序,二进制信号量可以。

初始化后的互斥量内存如图1-3所示。

图1-3:初始化后的互斥量对象内存

1.4创建递归互斥量

创建递归互斥量间接使用通用队列创建函数xQueueGenericCreate()。创建递归互斥量API接口同样是个宏,定义如下:

#definexSemaphoreCreateRecursiveMutex()                 \          xQueueCreateMutex(queueQUEUE_TYPE_RECURSIVE_MUTEX, NULL )

其中,宏queueQUEUE_TYPE_RECURSIVE_MUTEX用于通用队列创建函数,表示创建队列的类型是递归互斥量,在文章《FreeRTOS高级篇5---FreeRTOS队列分析》关于通用队列创建函数参数说明中提到了这个宏。

创建互斥量和创建递归互斥量是调用的同一个函数xQueueCreateMutex(),至于参数queueQUEUE_TYPE_RECURSIVE_MUTEX,我们在FreeRTOS一文中已经知道,它只是用于可视化调试,因此创建互斥量和创建递归互斥量可以看作是一样的,初始化后的递归互斥量对象内存也和互斥量一样,如图1-3所示。

2.释放信号量

无论二进制信号量、计数信号量还是互斥量,它们都使用相同的获取和释放API函数。释放信号量用于使信号量有效,分为不带中断保护和带中断保护两个版本。

2.1 xSemaphoreGive()

用于释放一个信号量,不带中断保护。被释放的信号量可以是二进制信号量、计数信号量和互斥量。注意递归互斥量并不能使用这个API函数释放。其实信号量释放是一个宏,真正调用的函数是xQueueGenericSend(),宏定义如下:

#definexSemaphoreGive( xSemaphore )                    \              xQueueGenericSend(                       \                     ( QueueHandle_t ) ( xSemaphore ), \                     NULL,                \                     semGIVE_BLOCK_TIME,  \                     queueSEND_TO_BACK )

可以看出释放信号量实际上是一次入队操作,并且阻塞时间为0(由宏semGIVE_BLOCK_TIME定义)。

对于二进制信号量和计数信号量,根据上一章的内容可以总结出,释放一个信号量的过程实际上可以简化为两种情况:第一,如果队列未满,队列结构体成员uxMessageWaiting加1,判断是否有阻塞的任务,有的话解除阻塞,然后返回成功信息(pdPASS);第二,如果队列满,返回错误代码(err_QUEUE_FULL),表示队列满。

对于互斥量要复杂些,因为互斥量具有优先级继承机制。

优先级继承是个什么过程呢?我们举个例子。某个资源X同时只能有一个任务访问,现在有任务A和任务C都要访问这个资源,任务A的优先级为1,任务C的优先级为10,所以任务C的优先级大于任务A的优先级。我们用互斥量保护资源X,并且当前任务A正在访问资源X。在任务A访问资源X的过程中,来了一个中断,中断事件使得任务C执行。任务C执行的过程中,也想访问资源X,但是因为资源X还被任务A独占着,所以任务C无法获取互斥量,会进入阻塞状态。此时,低优先级任务A会继承高优先级任务C的优先级,任务A的优先级临时的被提升,优先级变成10。这个机制能够将已经发生的优先级反转影响降低到最小。

那么什么是优先级反转呢?还是看上面的例子,任务C的优先级高于任务A,但是任务C因为没有获得互斥量而进入阻塞,只能等待低优先级的任务A释放互斥量后才能运行,这种情况就是优先级反转。

那为什么优先级继承可以降低优先级反转的影响呢?还是看上面的例子,不过我们再增加一个优先级为5的任务B,这三个任务都处于就绪状态。如果没有优先级继承机制,三个任务的优先级顺序为任务C>任务B>任务A。当任务C因为得不到互斥量而阻塞后,任务B会获取CPU权限,等到任务B主动或被动让出CPU后,任务A才会执行,任务A释放互斥量后,任务C才能得到运行。再看一下有优先级继承的情况,当任务C因为得不到互斥量而阻塞后,任务A继承任务C的优先级,现在三个任务的优先级顺序为任务C=任务A>任务B。当任务C因为得不到互斥量而阻塞后,任务A会获得CPU权限,等到任务A释放互斥量后,任务C就会得到运行。看,任务C等待的时间变短了。

有了上面的基础理论,我们就很好理解为什么释放互斥量会比较复杂了。还是可以简化为两种情况:第一,如果队列未满,除了队列结构体成员uxMessageWaiting加1外,还要判断获取互斥量的任务是否有优先级继承,如果有的话,还要将任务的优先级恢复到原始值。当然,恢复到原来值也是有条件的,就是该任务必须在没有使用其它互斥量的情况下,才能将继承的优先级恢复到原始值。然后判断是否有阻塞的任务,有的话解除阻塞,最后返回成功信息(pdPASS);第二,如果如果队列满,返回错误代码(err_QUEUE_FULL),表示队列满。

2.2xSemaphoreGiveFromISR()

用于释放一个信号量,带中断保护。被释放的信号量可以是二进制信号量和计数信号量。和普通版本的释放信号量API函数不同,它不能释放互斥量,这是因为互斥量不可以在中断中使用!互斥量的优先级继承机制只能在任务中起作用,在中断中毫无意义。带中断保护的信号量释放其实也是一个宏,真正调用的函数是xQueueGiveFromISR (),宏定义如下:

#definexSemaphoreGiveFromISR( xSemaphore, pxHigherPriorityTaskWoken )     \            xQueueGiveFromISR(                     \                ( QueueHandle_t ) ( xSemaphore),  \                ( pxHigherPriorityTaskWoken ) )

我们看真正被调用的函数源码(经过整理后的):

BaseType_t xQueueGiveFromISR(            QueueHandle_t xQueue,            BaseType_t * constpxHigherPriorityTaskWoken ){BaseType_t xReturn;UBaseType_t uxSavedInterruptStatus;Queue_t * const pxQueue = ( Queue_t * ) xQueue;    uxSavedInterruptStatus =portSET_INTERRUPT_MASK_FROM_ISR();    {        /*当队列用于实现信号量时,永远不会有数据出入队列,但是任然要检查队列是否为空 */        if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )        {            /* 一个任务可以获取多个互斥量,但是只能有一个继承优先级,如果任务是互斥量的持有者,则互斥量不允许在中断服务程序中释放.因此这里不需要判断是否要恢复任务的原始优先级值,只是简单更新队列项计数器. */            ++( pxQueue->uxMessagesWaiting );             /* 如果列表上锁,不能改变队列的事件列表. */            if( pxQueue->xTxLock == queueUNLOCKED )            {                if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive) ) == pdFALSE )                {                    if(xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive) ) != pdFALSE )                    {                        /* 解除阻塞的任务有更高优先级,因此记录上下文切换请求*/                        if(pxHigherPriorityTaskWoken != NULL )                        {                            *pxHigherPriorityTaskWoken= pdTRUE;                        }                    }                }            }            else            {                /* Increment thelock count so the task that unlocks the queue                knows that data wasposted while it was locked. */                ++( pxQueue->xTxLock );            }             xReturn = pdPASS;        }        else        {            xReturn = errQUEUE_FULL;        }    }    portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus );     return xReturn;}

因为不涉及互斥量,不涉及阻塞,函数xQueueGiveFromISR()异常简单,如果队列满,直接返回错误代码(err_QUEUE_FULL);如果队列未满,则将队列结构体成员uxMessageWaiting加1,然后视队列是否上锁而决定是否解除任务阻塞(如果有得话)。如果你觉得难以理解,则需要先看看《FreeRTOS高级篇5---FreeRTOS队列分析》。

3.获取信号量

无论二进制信号量、计数信号量还是互斥量,它们都使用相同的获取和释放API函数。释获取信号量会消耗信号量,如果获取信号量失败,任务可能会阻塞,阻塞时间由函数参数xBlockTime指定,如果为0,则直接返回,不阻塞。获取信号量分为不带中断保护和带中断保护两个版本。

3.1 xSemaphoreTake

用于获取信号量,不带中断保护。获取的信号量可以是二进制信号量、计数信号量和互斥量。注意递归互斥量并不能使用这个API函数获取。其实获取信号量是一个宏,真正调用的函数是xQueueGenericReceive (),宏定义如下:

#definexSemaphoreTake( xSemaphore, xBlockTime )        \              xQueueGenericReceive(                    \             ( QueueHandle_t ) ( xSemaphore ),         \              NULL,                                    \             ( xBlockTime ),                           \              pdFALSE )

通过上面的宏定义可以看出,获取信号量实际上是执行出队操作。

对于二进制信号量和计数信号量,可以简化为三种情况:第一,如果队列不为空,队列结构体成员uxMessageWaiting减1,判断是否有因入队而阻塞的任务,有的话解除阻塞,然后返回成功信息(pdPASS);第二,如果队列为空并且阻塞时间为0,则直接返回错误码(errQUEUE_EMPTY),表示队列为空;第三,如果队列为空并且阻塞时间不为0,则任务会因为等待信号量而进入阻塞状态,任务会被挂接到延时列表中。

对于互斥量,也可以简化为三种情况,但是过程要复杂一些:第一,如果队列不为空,队列结构体成员uxMessageWaiting减1、将当前任务TCB结构体成员uxMutexesHeld加1,表示任务获取互斥量的个数、将队列结构体成员指针pxMutexHolder指向任务TCB、判断是否有因入队而阻塞的任务,有的话解除阻塞,然后返回成功信息(pdPASS);第二,如果队列为空并且阻塞时间为0,则直接返回错误码(errQUEUE_EMPTY),表示队列为空;第三,如果队列为空并且阻塞时间不为0,则任务会因为等待信号量而进入阻塞状态,在将任务挂接到延时列表之前,会判断当前任务和拥有互斥量的任务优先级哪个高,如果当前任务优先级高,则拥有互斥量的任务继承当前任务优先级。

3.2xSemaphoreTakeFromISR()

用于获取信号量,带中断保护。获取的信号量可以是二进制信号量和计数信号量。和普通版本的获取信号量API函数不同,它不能获取互斥量,这是因为互斥量不可以在中断中使用!互斥量的优先级继承机制只能在任务中起作用,在中断中毫无意义。带中断保护的获取信号量其实也是一个宏,真正调用的函数是xQueueReceiveFromISR (),宏定义如下:

#definexSemaphoreTakeFromISR( xSemaphore, pxHigherPriorityTaskWoken )   \              xQueueReceiveFromISR(              \             ( QueueHandle_t ) ( xSemaphore ),   \              NULL,                              \             ( pxHigherPriorityTaskWoken ) )

同样因为不涉及互斥量,不涉及阻塞,函数xQueueReceiveFromISR ()同样异常简单:如果队列为空,直接返回错误代码(pdFAIL);如果队列非空,则将队列结构体成员uxMessageWaiting减1,然后视队列是否上锁而决定是否解除任务阻塞(如果有得话)。

4.释放递归互斥量

函数xSemaphoreGiveRecursive()用于释放一个递归互斥量。已经获取递归互斥量的任务可以重复获取该递归互斥量。使用xSemaphoreTakeRecursive() 函数成功获取几次递归互斥量,就要使用xSemaphoreGiveRecursive()函数返还几次,在此之前递归互斥量都处于无效状态。比如,某个任务成功获取5次递归互斥量,那么在它没有返还5次该递归互斥量之前,这个互斥量对别的任务无效。

像其它信号量一样,xSemaphoreGiveRecursive()也是一个宏定义,它最终使用现有的队列机制,实际执行的函数是xQueueGiveMutexRecursive(),这个宏定义如下所示:

#definexSemaphoreGiveRecursive( xMutex )            \                xQueueGiveMutexRecursive( (xMutex ) )     

我们重点来看函数xQueueGiveMutexRecursive()的实现过程。经过整理后(去除跟踪调试语句)的源码如下所示:

#if ( configUSE_RECURSIVE_MUTEXES == 1 )    BaseType_txQueueGiveMutexRecursive( QueueHandle_t xMutex )    {    BaseType_t xReturn;    Queue_t * const pxMutex = ( Queue_t * ) xMutex;         /* 互斥量和递归互斥量要在同一个任务中获取和释放,当获取互斥量或递归互斥量时,队列结构体成员指针pxMutexHolder指向获取互斥量或递归互斥量的任务TCB,所以在释放递归互斥量时需要检查这个指针指向的TCB是否是和当前任务TCB相同,如果不相同是不能释放这个递归互斥量的! 注:释放互斥量时,这个检查不是必须的,FreeRTOS的作者将这个检查放在了断言中(configASSERT( pxTCB == pxCurrentTCB);).*/        if( pxMutex->pxMutexHolder == ( void * )xTaskGetCurrentTaskHandle() )        {            /* 每当任务获取递归互斥量时,队列结构体成员u.uxRecursiveCallCount会加1,互斥量不会使用这个变量,它用来保存递归次数.所以,在释放递归互斥量的时候要将它减1*/            ( pxMutex->u.uxRecursiveCallCount)--;             /* 递归计数器为0? */            if( pxMutex->u.uxRecursiveCallCount == ( UBaseType_t ) 0 )            {                /* 调用入队函数释放一个互斥量,注意阻塞时间(由宏queueMUTEX_GIVE_BLOCK_TIME定义)为0 */                ( void ) xQueueGenericSend( pxMutex, NULL,queueMUTEX_GIVE_BLOCK_TIME, queueSEND_TO_BACK );            }             xReturn = pdPASS;        }        else        {            /* 如果不是本任务拥有这个互斥量,则直接返回错误码 */            xReturn = pdFAIL;        }         return xReturn;    }#endif /* configUSE_RECURSIVE_MUTEXES */

这个函数是带条件编译的,只有将宏configUSE_RECURSIVE_MUTEXES定义为1才会编译这个函数。

互斥量和递归互斥量的最大区别在于一个递归互斥量可以被已经获取这个递归互斥量的任务重复获取,这个递归调用功能是通过队列结构体成员u.uxRecursiveCallCount实现的。这个变量用于存储递归调用的次数,每次获取递归互斥量后,这个变量加1,在释放递归互斥量后,这个变量减1。只有这个变量减到0,即释放和获取的次数相等时,互斥量才能再次有效,使用入队函数释放一个递归互斥量。

5.获取递归互斥量

函数xSemaphoreTakeRecursive()用于获取一个递归互斥量。像其它信号量一样,xSemaphoreTakeRecursive()也是一个宏定义,它最终使用现有的队列机制,实际执行的函数是xQueueTakeMutexRecursive(),这个宏定义如下所示:

#definexSemaphoreTakeRecursive( xMutex, xBlockTime )       \               xQueueTakeMutexRecursive( ( xMutex ), ( xBlockTime ) )

获取递归互斥量具有阻塞超时参数,如果互斥量正被别的任务使用,可以阻塞设定的时间。我们重点来看函数xQueueTakeMutexRecursive()的实现过程。经过整理后(去除跟踪调试语句)的源码如下所示:

#if ( configUSE_RECURSIVE_MUTEXES == 1 )    BaseType_txQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_txTicksToWait )    {    BaseType_t xReturn;    Queue_t * const pxMutex = ( Queue_t * ) xMutex;    /*互斥量和递归互斥量要在同一个任务中获取和释放,递归互斥量可以在一个任务中多次获取,当第一次获取递归互斥量时,队列结构体成员指针pxMutexHolder指向获取递归互斥量的任务TCB,在此获取这个递归互斥量时,如果这个指针指向的TCB和当前任务TCB相同,只需要将递归次数计数器u.uxRecursiveCallCount加1即可,不需要再操作队列.*/        if( pxMutex->pxMutexHolder == ( void * )xTaskGetCurrentTaskHandle() )        {            ( pxMutex->u.uxRecursiveCallCount)++;            xReturn = pdPASS;        }        else        {            /*调用出队函数*/            xReturn =xQueueGenericReceive( pxMutex, NULL, xTicksToWait, pdFALSE );             /* 成功获取递归互斥量后,要将递归次数计数器加1*/            if( xReturn != pdFAIL )            {                ( pxMutex->u.uxRecursiveCallCount)++;            }        }         return xReturn;    }#endif /* configUSE_RECURSIVE_MUTEXES */

这个函数是带条件编译的,只有将宏configUSE_RECURSIVE_MUTEXES定义为1才会编译这个函数。

程序逻辑比较简单,如果是第一次获取这个递归互斥量,直接使用出队函数,成功后将递归次数计数器加1;如果是第二次或者更多次获取这个递归互斥量,则只需要将递归次数计数器加1即可。

以上就是FreeRTOS进阶信号量示例的完全解析的详细内容,更多关于FreeRTOS进阶信号量分析的资料请关注我们其它相关文章!

(0)

相关推荐

  • FreeRTOS进阶系统节拍时钟示例的完全解析

    目录 操作系统的运行是由系统节拍时钟驱动的. 在FreeRTOS中,我们知道系统延时和阻塞时间都是以系统节拍时钟周期为单位.在配置文件FreeRTOSConfig.h,改变宏configTICK_RATE_HZ的值,可以改变系统节拍时钟的中断频率,也间接的改变了系统节拍时钟周期(T=1/f).比如设置宏configTICK_RATE_HZ为100,则系统节拍时钟周期为10ms,设置宏configTICK_RATE_HZ为1000,则系统节拍时钟周期为1ms. 系统节拍中断服务程序会调用函数xTa

  • FreeRTOS进阶之队列示例分析

    目录 FreeRTOS提供了多种任务间通讯方式,包括:任务通知(版本V8.2以及以上版本)队列二进制信号量计数信号量互斥量递归互斥量      其中,二进制信号量.计数信号量.互斥量和递归互斥量都是使用队列来实现的,因此掌握队列的运行机制,是很有必要的.      队列是FreeRTOS主要的任务间通讯方式.可以在任务与任务间.中断和任务间传送信息.发送到队列的消息是通过拷贝实现的,这意味着队列存储的数据是原数据,而不是原数据的引用.先看一下队列的数据结构: typedef struct Que

  • FreeRTOS进阶任务通知示例分析

    目录 在FreeRTOS版本V8.2.0中推出了全新的功能:任务通知.在大多数情况下,任务通知可以替代二进制信号量.计数信号量.事件组,可以替代长度为1的队列(可以保存一个32位整数或指针值),并且任务通知速度更快.使用的RAM更少!我在< FreeRTOS系列第14篇---FreeRTOS任务通知>一文中介绍了任务通知如何使用以及局限性,今天我们将分析任务通知的实现源码,看一下任务通知是如何做到效率与RAM消耗双赢的.        在<FreeRTOS高级篇6---FreeRTOS信

  • FreeRTOS信号量API函数基础教程

    目录 前言 1创建二进制信号量 1.1函数描述 2创建计数信号量 3创建互斥量 4创建递归互斥量 5删除信号量 6获取信号量 7获取信号量(带中断保护) 8获取递归互斥量 9释放信号量 10释放信号量(带中断保护) 11释放递归互斥量 12获取互斥量持有任务的句柄 前言 FreeRTOS的信号量包括二进制信号量.计数信号量.互斥信号量(以后简称互斥量)和递归互斥信号量(以后简称递归互斥量).我们可以把互斥量和递归互斥量看成特殊的信号量. 信号量API函数实际上都是宏,它使用现有的队列机制.这些宏

  • FreeRTOS实时操作系统信号量基础

    目录 前言 1.信号量简介 2.二进制信号量 3.计数信号量 4.互斥量 5.递归互斥量 前言 本文介绍信号量的基础知识,详细源码分析见<FreeRTOS进阶FreeRTOS信号量分析> 1.信号量简介 FreeRTOS的信号量包括二进制信号量.计数信号量.互斥信号量(以后简称互斥量)和递归互斥信号量(以后简称递归互斥量). 我们可以把互斥量和递归互斥量看成特殊的信号量.互斥量和信号量在用法上不同: 信号量用于同步,任务间或者任务和中断间同步:互斥量用于互锁,用于保护同时只能有一个任务访问的资

  • FreeRTOS进阶列表和列表项示例分析

    目录 前言 1.初始化列表 2.初始化列表项 4.将列表项插入到列表末端 前言 FreeRTOS内核调度大量使用了列表(list)和列表项(list item)数据结构.我们如果想一探FreeRTOS背后的运行机制,首先遇到的拦路虎就是列表和列表项.对于FreeRTOS内核来说,列表就是它最基础的部分.我们在这一章集中讲解列表和列表项的结构以及操作函数,在下一章讲解任务创建时,会用到本章的知识点. 列表被FreeRTOS调度器使用,用于跟踪任务,处于就绪.挂起.延时的任务,都会被挂接到各自的列表

  • FreeRTOS进阶内存管理示例完全解析

    内存管理对应用程序和操作系统来说都非常重要.现在很多的程序漏洞和运行崩溃都和内存分配使用错误有关. FreeRTOS操作系统将内核与内存管理分开实现,操作系统内核仅规定了必要的内存管理函数原型,而不关心这些内存管理函数是如何实现的.这样做大有好处,可以增加系统的灵活性:不同的应用场合可以使用不同的内存分配实现,选择对自己更有利的内存管理策略.比如对于安全型的嵌入式系统,通常不允许动态内存分配,那么可以采用非常简单的内存管理策略,一经申请的内存,甚至不允许被释放.在满足设计要求的前提下,系统越简单

  • FreeRTOS进阶信号量示例的完全解析

    目录 FreeRTOS的信号量包括二进制信号量.计数信号量.互斥信号量(以后简称互斥量)和递归互斥信号量(以后简称递归互斥量).关于它们的区别可以参考< FreeRTOS系列第19篇---FreeRTOS信号量>一文. 信号量API函数实际上都是宏,它使用现有的队列机制.这些宏定义在semphr.h文件中.如果使用信号量或者互斥量,需要包含semphr.h头文件. 二进制信号量.计数信号量和互斥量信号量的创建API函数是独立的,但是获取和释放API函数都是相同的:递归互斥信号量的创建.获取和释

  • FreeRTOS进阶之任务创建完全解析

    目录 在FreeRTOS基础系列<FreeRTOS系列第10篇---FreeRTOS任务创建和删除>中介绍了任务创建API函数xTaskCreate(),我们这里先回顾一下这个函数的声明: BaseType_t xTaskCreate( TaskFunction_tp vTaskCode, const char * constpcName, unsigned short usStackDepth, void *pvParameters, UBaseType_t uxPriority, Task

  • FreeRTOS进阶之系统延时完全解析

    目录 1. 相对延时函数vTaskDelay() 2. 绝对延时函数vTaskDelayUntil() 3.小结 FreeRTOS提供了两个系统延时函数:相对延时函数vTaskDelay()和绝对延时函数 vTaskDelayUntil().相对延时是指每次延时都是从任务执行函数vTaskDelay()开始,延时指定的时间结束: 绝对延时是指每隔指定的时间,执行一次调用vTaskDelayUntil()函数的任务.换句话说:任务以固定的频率执行. 在<FreeRTOS任务控制>一文中,已经介绍

  • FreeRTOS进阶之调度器启动过程分析

    目录 使用FreeRTOS,一个最基本的程序架构如下所示: int main(void) { 必要的初始化工作; 创建任务1; 创建任务2; ... vTaskStartScheduler(); /*启动调度器*/ while(1); } 任务创建完成后,静态变量指针pxCurrentTCB(见<FreeRTOS进阶之任务创建完全解析>第7节内容)指向优先级最高的就绪任务.但此时任务并不能运行,因为接下来还有关键的一步:启动FreeRTOS调度器. 调度器是FreeRTOS操作系统的核心,主要

  • FreeRTOS进阶之空闲任务示例完全解析

    目录 当RTOS调度器开始工作后,为了保证至少有一个任务在运行,空闲任务被自动创建,占用最低优先级(0优先级). xReturn = xTaskCreate( prvIdleTask, "IDLE",configMINIMAL_STACK_SIZE, (void * ) NULL, (tskIDLE_PRIORITY | portPRIVILEGE_BIT ), &xIdleTaskHandle); 空闲任务是FreeRTOS不可缺少的任务,因为FreeRTOS设计要求必须至少

  • FreeRTOS进阶之任务通知示例完全解析

    目录 前言 1.发送通知 1.1 xTaskGenericNotify() 1.2 vTaskNotifyGiveFromISR() 1.3 xTaskGenericNotifyFromISR() 2.等待通知 2.1 ulTaskNotifyTake() 2.2 xTaskNotifyWait() 前言 在FreeRTOS版本V8.2.0中推出了全新的功能:任务通知.在大多数情况下,任务通知可以替代二进制信号量.计数信号量.事件组,可以替代长度为1的队列(可以保存一个32位整数或指针值),并且

  • FreeRTOS进阶之队列示例完全解析

    目录 前言 1.队列创建函数 2.入队 2.1 xQueueGenericSend() 2.2 xQueueGenericSendFromISR () 3.出队 前言 FreeRTOS提供了多种任务间通讯方式,包括: 任务通知(版本V8.2以及以上版本) 队列 二进制信号量 计数信号量 互斥量 递归互斥量 其中,二进制信号量.计数信号量.互斥量和递归互斥量都是使用队列来实现的,因此掌握队列的运行机制,是很有必要的. 队列是FreeRTOS主要的任务间通讯方式.可以在任务与任务间.中断和任务间传送

  • FreeRTOS操作系统的配置示例解析

    目录 1. FreeRTOSConfig.h 文件 2.  “INCLUDE_” 开始的宏 3.“config”开始的宏 FreeRTOS 的系统配置文件为 FreeRTOSConfig.h,在此配置文件中可以完成 FreeRTOS 的裁剪和配置. 1. FreeRTOSConfig.h 文件 FreeRTOS 的配置基本是通过在 FreeRTOSConfig.h 中使用“#define”这样的语句来定义宏定义实现的.在 FreeRTOS 的官方 demo 中,每个工程都有一个 FreeRTOS

随机推荐