文章目录
- 前言
- 一.创建信号量
- 二.释放信号量
- 三.获取信号量
- 成功获取
- 获取不成功
- 总结
前言
本篇文章将为大家讲解信号量，源码分析。
在 FreeRTOS 中，信号量的实现基于队列。这种设计的思想是利用队列的特性来实现信号量，因为信号量可以被视为只能存储 0 或 1 个元素的特殊队列。
在 FreeRTOS 中，二进制信号量（Binary Semaphore）通常由一个队列和一个计数器组成。
计数信号量允许计数器的值大于 1，它通常用于管理多个相同资源的可用性。计数信号量的值表示可用资源的数量，多个任务可以同时获取不同数量的资源。当任务获取资源时，计数器减少，当任务释放资源时，计数器增加。
一.创建信号量
创建二进制信号量
xBinarySemaphore = xSemaphoreCreateBinary();
创建信号量源码分析：
创建信号量时本质上还是使用到了xQueueGenericCreate队列相关的函数
信号量不能用来进行数据的传输，所以在创建信号量时Itemsize被设置为了0。
将pucQueueStorage指针指向队列的存储区域位置。
初始化队列：
根据uxItemSize是否为0调整pcHead的指向。
对uxLength和uxItemSize进行赋值。
创建计数型信号量：
创建计数型信号量使用到了xQueueCreateCountingSemaphore函数。
使用这个函数时需要开启configUSE_COUNTING_SEMAPHORES和configSUPPORT_DYNAMIC_ALLOCATION这两个宏。
创建计数型信号量时还是会使用到xQueueGenericCreate函数进行创建。
唯一的区别就是二值信号量的uxMessagesWaiting参数只能是0或者1，而计数型信号量的uxMessagesWaiting可以为任意的值(0和正数)。
二.释放信号量
由于释放信号量会涉及到访问共享资源，所以开始先关闭中断。
taskENTER_CRITICAL();
判断pxQueue->uxMessagesWaiting是否小于pxQueue->uxLength，如果小于，调用prvCopyDataToQueue函数让uxMessagesWaiting的值加1。
if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )
{
.........
xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );
}
判断是否有任务在等待信号量，有的话移除并且唤醒任务优先级最高的任务。
if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
{
if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )
{
/* The unblocked task has a priority higher than
* our own so yield immediately. Yes it is ok to do
* this from within the critical section - the kernel
* takes care of that. */
queueYIELD_IF_USING_PREEMPTION();
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
由于xSemaphoreGive函数不涉及超时参数，故不涉及超时处理。
三.获取信号量
成功获取
由于获取信号量会涉及到访问共享资源，所以开始先关闭中断。
taskENTER_CRITICAL();
获取当前count值
const UBaseType_t uxSemaphoreCount = pxQueue->uxMessagesWaiting;
判断uxSemaphoreCount是否大于0，大于0则uxMessagesWaiting的值减1。
if( uxSemaphoreCount > ( UBaseType_t ) 0 )
{
traceQUEUE_RECEIVE( pxQueue );
/* Semaphores are queues with a data size of zero and where the
* messages waiting is the semaphore's count. Reduce the count. */
pxQueue->uxMessagesWaiting = uxSemaphoreCount - ( UBaseType_t ) 1;
获取不成功
当获取不成功，并且没有设置超时时间直接返回错误：
if( xTicksToWait == ( TickType_t ) 0 )
{
/* For inheritance to have occurred there must have been an
* initial timeout, and an adjusted timeout cannot become 0, as
* if it were 0 the function would have exited. */
#if ( configUSE_MUTEXES == 1 )
{
configASSERT( xInheritanceOccurred == pdFALSE );
}
#endif /* configUSE_MUTEXES */
/* The semaphore count was 0 and no block time is specified
* (or the block time has expired) so exit now. */
taskEXIT_CRITICAL();
traceQUEUE_RECEIVE_FAILED( pxQueue );
return errQUEUE_EMPTY;//返回错误
}
设置超时时间
else if( xEntryTimeSet == pdFALSE )
{
/* The semaphore count was 0 and a block time was specified
* so configure the timeout structure ready to block. */
vTaskInternalSetTimeOutState( &xTimeOut );
xEntryTimeSet = pdTRUE;
}
检查是否超时，并且放入xTasksWaitingToReceive链表中。
if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )
{
/* A block time is specified and not expired. If the semaphore
* count is 0 then enter the Blocked state to wait for a semaphore to
* become available. As semaphores are implemented with queues the
* queue being empty is equivalent to the semaphore count being 0. */
if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
{
traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );
#if ( configUSE_MUTEXES == 1 )
{
if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )
{
taskENTER_CRITICAL();
{
xInheritanceOccurred = xTaskPriorityInherit( pxQueue->u.xSemaphore.xMutexHolder );
}
taskEXIT_CRITICAL();
}
else
{
mtCOVERAGE_TEST_MARKER();
}
}
#endif /* if ( configUSE_MUTEXES == 1 ) */
vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );
prvUnlockQueue( pxQueue );
超时直接返回错误
else
{
/* Timed out. */
prvUnlockQueue( pxQueue );
( void ) xTaskResumeAll();
/* If the semaphore count is 0 exit now as the timeout has
* expired. Otherwise return to attempt to take the semaphore that is
* known to be available. As semaphores are implemented by queues the
* queue being empty is equivalent to the semaphore count being 0. */
if( prvIsQueueEmpty( pxQueue ) != pdFALSE )
{
#if ( configUSE_MUTEXES == 1 )
{
/* xInheritanceOccurred could only have be set if
* pxQueue->uxQueueType == queueQUEUE_IS_MUTEX so no need to
* test the mutex type again to check it is actually a mutex. */
if( xInheritanceOccurred != pdFALSE )
{
taskENTER_CRITICAL();
{
UBaseType_t uxHighestWaitingPriority;
/* This task blocking on the mutex caused another
* task to inherit this task's priority. Now this task
* has timed out the priority should be disinherited
* again, but only as low as the next highest priority
* task that is waiting for the same mutex. */
uxHighestWaitingPriority = prvGetDisinheritPriorityAfterTimeout( pxQueue );
vTaskPriorityDisinheritAfterTimeout( pxQueue->u.xSemaphore.xMutexHolder, uxHighestWaitingPriority );
}
taskEXIT_CRITICAL();
}
}
#endif /* configUSE_MUTEXES */
traceQUEUE_RECEIVE_FAILED( pxQueue );
return errQUEUE_EMPTY;
}
总结
本篇文章主要讲解了信号量，互斥量源码分析，其实信号量，互斥量是一个特殊的队列，掌握了队列后来学习信号量和互斥量的话那就是比较轻松的了。
