FreeRTOS队列分析

一、xQueueGenericSend()：
BaseType_t xQueueGenericSend( QueueHandle_t xQueue, const void *const pvItemToQueue, TickType_t xTicksToWait, const BaseType_t xCopyPosition )
{
    BaseType_t xEntryTimeSet = pdFALSE, xYieldRequired;
    TimeOut_t xTimeOut;
    Queue_t *const pxQueue = xQueue;
    configASSERT( pxQueue );
    configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
    configASSERT( !( ( xCopyPosition == queueOVERWRITE ) && ( pxQueue->uxLength != 1 ) ) );
#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
    {
        configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
    }
#endif

    /*lint -save -e904 This function relaxes the coding standard somewhat to
    allow return statements within the function itself.  This is done in the
    interest of execution time efficiency. */
    for ( ;; ) {//如果没有执行完，循环执行，一般是等待阻塞超时，再次执行
        taskENTER_CRITICAL();//进入临界区，关闭系统管理的中断
        {
            /* Is there room on the queue now?  The running task must be the
            highest priority task wanting to access the queue.  If the head item
            in the queue is to be overwritten then it does not matter if the
            queue is full. */
            if ( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) ) {//队列是否已满
                traceQUEUE_SEND( pxQueue );

#if ( configUSE_QUEUE_SETS == 1 )
                {
                    UBaseType_t uxPreviousMessagesWaiting = pxQueue->uxMessagesWaiting;
                    xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

                    if ( pxQueue->pxQueueSetContainer != NULL ) {
                        if ( ( xCopyPosition == queueOVERWRITE ) && ( uxPreviousMessagesWaiting != ( UBaseType_t ) 0 ) ) {
                            /* Do not notify the queue set as an existing item
                            was overwritten in the queue so the number of items
                            in the queue has not changed. */
                            mtCOVERAGE_TEST_MARKER();
                        } else if ( prvNotifyQueueSetContainer( pxQueue, xCopyPosition ) != pdFALSE ) {
                            /* The queue is a member of a queue set, and posting
                            to the queue set caused a higher priority task to
                            unblock. A context switch is required. */
                            queueYIELD_IF_USING_PREEMPTION();
                        } else {
                            mtCOVERAGE_TEST_MARKER();
                        }
                    } else {
                        /* If there was a task waiting for data to arrive on the
                        queue then unblock it now. */
                        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();
                            }
                        } else if ( xYieldRequired != pdFALSE ) {
                            /* This path is a special case that will only get
                            executed if the task was holding multiple mutexes
                            and the mutexes were given back in an order that is
                            different to that in which they were taken. */
                            queueYIELD_IF_USING_PREEMPTION();
                        } else {
                            mtCOVERAGE_TEST_MARKER();
                        }
                    }
                }
#else /* configUSE_QUEUE_SETS */
                {
                    //队列没有满，写数据到队列中，不需要分配内存，队列的内存创建时已分配，只做数据拷贝
                    xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

                    /* If there was a task waiting for data to arrive on the
                    queue then unblock it now. */
                    //判断是否有任务等待接收队列
                    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();
                        }
                    } else if ( xYieldRequired != pdFALSE ) {
                        /* This path is a special case that will only get
                        executed if the task was holding multiple mutexes and
                        the mutexes were given back in an order that is
                        different to that in which they were taken. */
                        queueYIELD_IF_USING_PREEMPTION();
                    } else {
                        mtCOVERAGE_TEST_MARKER();
                    }
                }
#endif /* configUSE_QUEUE_SETS */

                taskEXIT_CRITICAL();//退出临界区，使能中断
                return pdPASS;
            } else {
                if ( xTicksToWait == ( TickType_t ) 0 ) {
                    //如果队列已满，超时时间为0，则退出临界区，返回队列已满
                    /* The queue was full and no block time is specified (or
                    the block time has expired) so leave now. */
                    taskEXIT_CRITICAL();

                    /* Return to the original privilege level before exiting
                    the function. */
                    traceQUEUE_SEND_FAILED( pxQueue );
                    return errQUEUE_FULL;
                } else if ( xEntryTimeSet == pdFALSE ) {
                    /* The queue was full and a block time was specified so
                    configure the timeout structure. */
                    //如果超时时间不为0，超时时间没有配置，则配置超时时间
                    vTaskInternalSetTimeOutState( &xTimeOut );
                    xEntryTimeSet = pdTRUE;
                } else {
                    /* Entry time was already set. */
                    //超时时间已配置
                    mtCOVERAGE_TEST_MARKER();
                }
            }
        }
        taskEXIT_CRITICAL();

        /* Interrupts and other tasks can send to and receive from the queue
        now the critical section has been exited. */

        vTaskSuspendAll();//挂起任务调度器
        prvLockQueue( pxQueue );//发送队列上锁，初始化为0，主要是针对退出临界区后，当前的队列发送未执行完，中断中发送队列，队列处理的同步

        /* Update the timeout state to see if it has expired yet. */
        //检查当前发送是否超时
        if ( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE ) {
            //没有超时，则判断当前队列是否已满
            if ( prvIsQueueFull( pxQueue ) != pdFALSE ) {
                extern QueueHandle_t xTimerQueue;
                extern TaskHandle_t xTimerTaskHandle;
                extern TaskHandle_t pxCurrentTCB;

                if ((pxCurrentTCB == xTimerTaskHandle) && (pxQueue == xTimerQueue)) {
                    // OSTimer would be blocked infinitely by self when its queue is full
                    configASSERT(0);
                }

                traceBLOCKING_ON_QUEUE_SEND( pxQueue );
                //队列已满，则把当前发送任务阻塞，插入到阻塞列表中
                vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );

                /* Unlocking the queue means queue events can effect the
                event list.  It is possible that interrupts occurring now
                remove this task from the event list again - but as the
                scheduler is suspended the task will go onto the pending
                ready last instead of the actual ready list. */
                //队列解锁，根据pxQueue->cTxLock判断中断是否有发送队列，如果有，把等待接收队列消息的任务，插入到就绪列表
                prvUnlockQueue( pxQueue );

                /* Resuming the scheduler will move tasks from the pending
                ready list into the ready list - so it is feasible that this
                task is already in a ready list before it yields - in which
                case the yield will not cause a context switch unless there
                is also a higher priority task in the pending ready list. */
                if ( xTaskResumeAll() == pdFALSE ) {
                    portYIELD_WITHIN_API();
                }
            } else {
                /* Try again. */
                //如果发送队列已满，解锁队列，恢复任务调度器
                prvUnlockQueue( pxQueue );
                ( void ) xTaskResumeAll();
            }
        } else {
            /* The timeout has expired. */
            //如果已经超时，队列解锁，恢复任务调度器，返回队列已满
            prvUnlockQueue( pxQueue );
            ( void ) xTaskResumeAll();

            traceQUEUE_SEND_FAILED( pxQueue );
            return errQUEUE_FULL;
        }
    } /*lint -restore */
}

二、xQueueGenericSendFromISR()：
BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue, const void *const pvItemToQueue, BaseType_t *const pxHigherPriorityTaskWoken, const BaseType_t xCopyPosition )
{
    BaseType_t xReturn;
    UBaseType_t uxSavedInterruptStatus;
    Queue_t *const pxQueue = xQueue;

    configASSERT( pxQueue );
    configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );
    configASSERT( !( ( xCopyPosition == queueOVERWRITE ) && ( pxQueue->uxLength != 1 ) ) );

    /* RTOS ports that support interrupt nesting have the concept of a maximum
    system call (or maximum API call) interrupt priority.  Interrupts that are
    above the maximum system call priority are kept permanently enabled, even
    when the RTOS kernel is in a critical section, but cannot make any calls to
    FreeRTOS API functions.  If configASSERT() is defined in FreeRTOSConfig.h
    then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
    failure if a FreeRTOS API function is called from an interrupt that has been
    assigned a priority above the configured maximum system call priority.
    Only FreeRTOS functions that end in FromISR can be called from interrupts
    that have been assigned a priority at or (logically) below the maximum
    system call interrupt priority.  FreeRTOS maintains a separate interrupt
    safe API to ensure interrupt entry is as fast and as simple as possible.
    More information (albeit Cortex-M specific) is provided on the following
    link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
    portASSERT_IF_INTERRUPT_PRIORITY_INVALID();

    /* Similar to xQueueGenericSend, except without blocking if there is no room
    in the queue.  Also don't directly wake a task that was blocked on a queue
    read, instead return a flag to say whether a context switch is required or
    not (i.e. has a task with a higher priority than us been woken by this
    post). */
    //中断使能控制
    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
    {
        //判断队列是否已满
        if ( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) ) {
            const int8_t cTxLock = pxQueue->cTxLock;

            traceQUEUE_SEND_FROM_ISR( pxQueue );

            /* Semaphores use xQueueGiveFromISR(), so pxQueue will not be a
            semaphore or mutex.  That means prvCopyDataToQueue() cannot result
            in a task disinheriting a priority and prvCopyDataToQueue() can be
            called here even though the disinherit function does not check if
            the scheduler is suspended before accessing the ready lists. */
            ( void ) prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

            /* The event list is not altered if the queue is locked.  This will
            be done when the queue is unlocked later. */
            if ( cTxLock == queueUNLOCKED ) {
#if ( configUSE_QUEUE_SETS == 1 )
                {
                    if ( pxQueue->pxQueueSetContainer != NULL )
                    {
                        if ( prvNotifyQueueSetContainer( pxQueue, xCopyPosition ) != pdFALSE ) {
                            /* The queue is a member of a queue set, and posting
                            to the queue set caused a higher priority task to
                            unblock.  A context switch is required. */
                            if ( pxHigherPriorityTaskWoken != NULL ) {
                                *pxHigherPriorityTaskWoken = pdTRUE;
                            } else {
                                mtCOVERAGE_TEST_MARKER();
                            }
                        } else {
                            mtCOVERAGE_TEST_MARKER();
                        }
                    } else
                    {
                        if ( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE ) {
                            
                            if ( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE ) {
                                /* The task waiting has a higher priority so
                                record that a context switch is required. */
                                if ( pxHigherPriorityTaskWoken != NULL ) {
                                    *pxHigherPriorityTaskWoken = pdTRUE;
                                } else {
                                    mtCOVERAGE_TEST_MARKER();
                                }
                            } else {
                                mtCOVERAGE_TEST_MARKER();
                            }
                        } else {
                            mtCOVERAGE_TEST_MARKER();
                        }
                    }
                }
#else /* configUSE_QUEUE_SETS */
                {
                    if ( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
                    {
                        //如果有任务在等待队列接收，则把对应的任务插入到就绪列表中，等待任务调度器调度
                        if ( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE ) {
                            /* The task waiting has a higher priority so record that a
                            context switch is required. */
                            if ( pxHigherPriorityTaskWoken != NULL ) {
                                *pxHigherPriorityTaskWoken = pdTRUE;
                            } else {
                                mtCOVERAGE_TEST_MARKER();
                            }
                        } else {
                            mtCOVERAGE_TEST_MARKER();
                        }
                    } else
                    {
                        mtCOVERAGE_TEST_MARKER();
                    }
                }
#endif /* configUSE_QUEUE_SETS */
            } else {
                /* Increment the lock count so the task that unlocks the queue
                knows that data was posted while it was locked. */
                //如果队列已上锁，只做队列项加1操作，正在发送队列的任务会处理计数，把等待接收队列的任务插入到就绪链表；
                pxQueue->cTxLock = ( int8_t ) ( cTxLock + 1 );
            }

            xReturn = pdPASS;
        } else {
            traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue );
            //队列满了不会重试，直接返回错误码
            xReturn = errQUEUE_FULL;
        }
    }
    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

    return xReturn;
}

队列解析
xQueueGenericSend:
taskENTER_CRITICAL();
1、队列没有满，拷贝数据到队列内存，然后把等待接收队列的任务放到就绪队列，返回发送成功；
taskEXIT_CRITICAL();

2、如果队列已经满了：
taskENTER_CRITICAL();
如果超时时间为0，则直接返回队列已满；
如果超时时间不为0，更新当前的tick以及溢出次数。
taskEXIT_CRITICAL();
挂起任务调度器，队列上锁：prvLockQueue
判断是当前发送队列的任务是否超时，如果超时，队列解锁prvUnlockQueue，恢复任务调度器；如果没有超时，对列满了，把当前发送队列的任务插入到阻塞链表，解锁队列prvUnlockQueue，恢复任务调度器；
当前任务被挂起，等待超时调度；如果没有超时，队列没有满，解锁队列prvUnlockQueue，恢复任务调度器，任务调度器调度到当前任务，会从第一步开始循环执行。
如果任务阻塞超时，任务调度器调度到当前任务，会从第一步开始循环执行

prvLockQueue：此接口主要是在任务中执行完队列拷贝后，在挂起任务调度器，做队列的相关处理或者任务相关的超时与任务列表项的插入时，中断中进行了队列的插入操作。中断中做队列插入操作，如果队列上锁了，发送队列计数加1，如果没有上锁，不用对队列计数操作，把等待接收队列的任务放到就绪链表
prvUnlockQueue：
如果pxQueue->cTxLock小于0，则pxQueue->cTxLock置为解锁状态；
如果pxQueue->cTxLock大于0，则把每一个等待接收队列的任务插入到就绪链表，pxQueue->cTxLock--，直到pxQueue->cTxLock为0.最后pxQueue->cTxLock置为解锁状态；

xQueueGenericSendFromISR：
1、如果队列满了，直接返回队列已满，不会阻塞，等待超时，循环执行；
2、如果队列没有满，
1）如果队列没有上锁，判断有任务等待接收队列，则把对应的任务放到就绪链表；
2）如果队列上锁，pxQueue->cTxLock加1，等待正在发送队列的任务，来做任务列表处理与任务调度；

队列发送注意点：
1、插入到队列中，数据拷贝时，都会进入临界区，关闭中断，不需要上锁，关闭中断后，不会发生任务调度，只有系统管理不到的中断优先级有可能执行程序；
2、中断发送接口不会阻塞，不会循环执行，不会做任务调度器的挂起和恢复；任务中执行发送时会循环执行，会对任务调度器挂起和恢复，也会对队列上锁与解锁（主要是和中断发送队列做配合）；
3、队列的发送不会调用互斥锁，因为会进入临界区，或者挂起任务调度器，不存在多任务竞争；