FreeRTOS 中是如何实现基于优先级的互斥信号量的？

FreeRTOS 中基于优先级的互斥信号量是通过优先级继承和优先级反转机制来实现的。

当一个高优先级任务试图获取一个被低优先级任务持有的互斥信号量时，如果该互斥信号量已经被低优先级任务占用，则会发生优先级反转。这意味着高优先级任务会暂时降低其优先级，以避免低优先级任务持有的资源被其他更高优先级的任务所阻塞。

同时，当一个任务持有一个互斥信号量时，如果有一个更高优先级的任务试图获取该信号量，那么该任务将会暂停，直到当前持有该信号量的任务释放该资源。这个过程叫做优先级继承。

通过这些机制，FreeRTOS 可以在多任务环境下实现基于优先级的互斥信号量，保证高优先级任务能够优先获得资源，提高系统的实时性和可靠性。

相关问题

请结合源码讲解FreeRTOS 中是如何实现基于优先级的互斥信号量的？

FreeRTOS 中基于优先级的互斥信号量的实现主要依赖于任务调度器和任务控制块（TCB）。

首先，FreeRTOS 中的互斥信号量是一种用于任务间同步的基本机制。当一个任务需要访问某个共享资源时，它会尝试获取该互斥信号量。如果该信号量当前没有被占用，则任务可以获得该信号量并访问共享资源。如果该信号量已被其他任务占用，则当前任务需要等待，直到该信号量被释放。

基于优先级的互斥信号量的实现主要涉及以下几个关键点：

1. 任务的优先级

在 FreeRTOS 中，每个任务都有一个优先级，范围从 0 到 configMAX_PRIORITIES - 1（默认为 5）。任务的优先级越高，它在任务调度器中的调度优先级也越高。

2. 互斥信号量的状态

FreeRTOS 中的互斥信号量的状态可以分为两种：空闲状态和占用状态。当一个任务成功获取互斥信号量时，该信号量的状态会变为占用状态，直到该任务释放该信号量。

3. 任务的等待队列

当一个任务尝试获取一个已被占用的互斥信号量时，它会被加入到该信号量的等待队列中，等待信号量被释放。等待队列中的任务按照它们的优先级从高到低排序。

4. 任务的挂起和恢复

当一个任务在等待一个互斥信号量时，它会被挂起，并且不会参与任务调度。当该信号量被释放时，优先级最高的等待任务会被恢复，并且参与任务调度。

综上所述，FreeRTOS 中基于优先级的互斥信号量的实现可以通过以下步骤描述：

1. 初始化互斥信号量，将其状态设置为“空闲”。

2. 当一个任务需要访问共享资源时，它尝试获取该互斥信号量。如果该信号量当前没有被占用，则该任务可以获得该信号量，并访问共享资源。否则，该任务会被加入到该信号量的等待队列中，并被挂起。

3. 当该信号量被释放时，优先级最高的等待任务会被恢复，并且参与任务调度。如果等待队列中没有任务，则该信号量的状态会被设置为“空闲”。

4. 当一个任务释放该互斥信号量时，该信号量的状态会被设置为“空闲”，并且优先级最高的等待任务会被恢复，并且参与任务调度。

在实现过程中，需要注意以下几点：

1. 任务的优先级应该根据应用场景进行合理设置，以确保高优先级任务能够及时访问共享资源。

2. 等待队列中的任务应该按照它们的优先级从高到低排序，以确保优先级高的任务能够及时访问共享资源。

3. 由于等待队列中的任务被挂起时不参与任务调度，需要确保等待队列中的任务不会长时间等待，否则可能会导致任务饥饿问题。

4. 当多个任务同时尝试获取同一个互斥信号量时，需要确保只有一个任务能够成功获取该信号量，并访问共享资源。

请打印freertos中关于实现基于优先级的互斥信号量的代码，并加以注释

下面是FreeRTOS中实现基于优先级的互斥信号量的代码，注释已经加上：

typedef struct xQUEUE {  // 定义队列结构体
    volatile unsigned portBASE_TYPE uxMessagesWaiting;
    // 队列中等待的消息数目
    List_t xWaitingTasks; // 等待队列
} xQUEUE;

typedef struct xTIME_OUT { // 定义超时结构体
    portTickType xTicksToWait; // 等待时间
    portTickType xTimeOnEntering; // 进入等待状态时的时间
} xTIME_OUT;

typedef struct xSEM { // 定义信号量结构体
    xQUEUE xTasksWaitingToSend; // 任务等待发送信号量
    xQUEUE xTasksWaitingToReceive; // 任务等待接收信号量
    volatile unsigned portBASE_TYPE uxSemaphoreCount; // 信号量计数
} xSemaphore;

#define queueQUEUE_TYPE_BASE             ( 0U )
#define queueQUEUE_TYPE_MUTEX            ( 1U << 1 ) // 定义互斥信号量类型

#define queueQUEUE_TYPE_COUNTING_SEMAPHORE     ( 2U << 1 )
#define queueQUEUE_TYPE_BINARY_SEMAPHORE       ( 3U << 1 )
#define queueQUEUE_TYPE_RECURSIVE_MUTEX        ( 4U << 1 )
#define queueQUEUE_TYPE_SET                  ( 5U << 1 )

#define queueQUEUE_TYPE_IS_MUTEX( pxQueue )         ( ( ( pxQueue )->ucQueueType & queueQUEUE_TYPE_MUTEX ) != 0 ) // 判断队列是否是互斥信号量类型

#define queueQUEUE_TYPE_IS_SEMAPHORE( pxQueue )     ( ( ( pxQueue )->ucQueueType & queueQUEUE_TYPE_MUTEX ) == 0 )

#define queueSET_QUEUE_TYPE( pxQueue, uxType )    ( ( pxQueue )->ucQueueType = ( uxType ) )

#define queueGET_MUTEX_OWNER( pxQueue )            ( ( pxQueue )->pxMutexHolder )

#define queueSET_MUTEX_OWNER( pxQueue, pxHolder )  ( ( pxQueue )->pxMutexHolder = ( pxHolder ) )

#define queueYIELD_FROM_ISR( x )                   { if( x == pdTRUE ) { portEND_SWITCHING_ISR( pdTRUE ); } }

BaseType_t xSemaphoreTake( SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait ) // 获取互斥信号量
{
    BaseType_t xReturn = pdFALSE;
    xSemaphore = prvGetMutexSemaphoreHandle( xSemaphore ); // 获取信号量句柄
    configASSERT( xSemaphore );

    if( xSemaphore != NULL ) {
        if( xSemaphore->uxSemaphoreCount == 0 ) {
            if( xTicksToWait == ( TickType_t ) 0 ) {
                /* The semaphore was not immediately available and no block time
                * was specified (or the block time has expired) so simply return
                * false to indicate that the take could not be accomplished. */
                xReturn = pdFALSE;
            }
            else {
                if( xTaskGetSchedulerState() == taskSCHEDULER_NOT_STARTED ) {
                    /* Schedule has not started yet, so just wait in a loop until
                    semaphore becomes available.  This is a special case that only
                    arises during the startup of the scheduler. */
                    while( xSemaphore->uxSemaphoreCount == 0 ) {
                        asm volatile ( "NOP" );
                    }
                    xSemaphore->uxSemaphoreCount--; // 获取信号量
                    xReturn = pdTRUE;
                }
                else {
                    vTaskPlaceOnEventList( &( xSemaphore->xTasksWaitingToReceive ), xTicksToWait );
                    tracePEND_SEMAPHORE_TAKE( xSemaphore );
                    portENABLE_INTERRUPTS();
                    if( xSemaphore->uxSemaphoreCount == 0 ) {
                        /* The semaphore was not available immediately so the
                        calling task must have been placed in the queue of tasks that
                        are waiting for the semaphore to become available.  It must
                        now block to wait for the semaphore to become available. */
                        configASSERT( ( ( volatile uOS32_t * ) &( xSemaphore->uxSemaphoreCount ) )->ucCount == 0U );
                        portRESET_READY_PRIORITY( pxCurrentTCB );
                        prvAddCurrentTaskToDelayedList( &( xSemaphore->xTasksWaitingToReceive ), xTicksToWait, pdFALSE );
                        portYIELD_WITHIN_API(); // 切换到其他任务
                        if( pxCurrentTCB->uxMutexesHeld == 0U ) {
                            xReturn = pdTRUE;
                        }
                        else {
                            xReturn = pdFALSE;
                        }
                    }
                    else {
                        /* The semaphore was obtained. */
                        ( xSemaphore->uxSemaphoreCount )--;
                        traceSEMAPHORE_TAKE( xSemaphore );
                        prvUpdateTickCounts();
                        xReturn = pdTRUE;
                    }
                    portDISABLE_INTERRUPTS();
                }
            }
        }
        else {
            /* The semaphore was obtained. */
            ( xSemaphore->uxSemaphoreCount )--;
            traceSEMAPHORE_TAKE( xSemaphore );
            prvUpdateTickCounts();
            xReturn = pdTRUE;
        }
        if( xReturn == pdTRUE ) {
            queueSET_MUTEX_OWNER( &( xSemaphore->xTasksWaitingToSend ), pxCurrentTCB ); // 设置当前任务为互斥信号量的持有者
        }
    }

    return xReturn;
}

void vSemaphoreCreateMutex( SemaphoreHandle_t xMutex ) // 创建互斥信号量
{
    xSemaphore *pxNewQueue;

    pxNewQueue = ( xSemaphore * ) pvPortMalloc( sizeof( xSemaphore ) );

    if( pxNewQueue != NULL ) {
        memset( pxNewQueue, 0x00, sizeof( xSemaphore ) );

        /* The semaphore count starts at 1 as it is assumed the semaphore
        * is being created to guard access to a resource. */
        pxNewQueue->uxSemaphoreCount = ( unsigned portBASE_TYPE ) 1;

        /* The semaphore is a mutex, so the queue can only hold one item. */
        pxNewQueue->xTasksWaitingToSend.uxMessagesWaiting = ( unsigned portBASE_TYPE ) 1;

        queueSET_QUEUE_TYPE( &( pxNewQueue->xTasksWaitingToSend ), queueQUEUE_TYPE_MUTEX ); // 设置队列类型为互斥信号量类型

        /* Store the handle of the mutex in the TCB of the creating task so the
        * handle gets cleaned up when the task is deleted. */
        vListInitialise( &( pxNewQueue->xTasksWaitingToSend.xWaitingTasks ) ); // 初始化等待队列
        vListInitialise( &( pxNewQueue->xTasksWaitingToReceive.xWaitingTasks ) ); // 初始化等待队列
        vListInitialise( &( pxNewQueue->xTasksWaitingToSend.xTasksWaitingToSend ) ); // 初始化等待队列
        vListInitialise( &( pxNewQueue->xTasksWaitingToReceive.xTasksWaitingToSend ) ); // 初始化等待队列

        *( SemaphoreHandle_t * ) xMutex = pxNewQueue; // 设置互斥信号量的句柄
        traceSEMAPHORE_CREATE( xMutex ); // 跟踪互斥信号量的创建
    }
}