問題解答

曾經(jīng)有人問我，FreeRTOS那么多API，到底怎么記住呢？

我想說，其實API不難記，就是有點難找，因為FreeRTOS的API很多都是帶參宏，所以跳來跳去的比較麻煩，而且注釋也很多，要找還真不是那么容易，不過也沒啥，一般都會有API手冊的，我就告訴大家一下：

FreeRTOS Kernel: Reference Manual

FreeRTOS內(nèi)核：參考手冊，大家可以在官網(wǎng)下載，也能在后臺得到。

當(dāng)然書本是英文的，如果英語像我這樣子不咋地的同學(xué)，可以用谷歌瀏覽器在官網(wǎng)直接看API手冊，直接翻譯一下就行了。傳送門：https://www.freertos.org/a00018.html

Reference Manual

FreeRTOS官網(wǎng)的API

FreeRTOS消息隊列

基于 FreeRTOS 的應(yīng)用程序由一組獨(dú)立的任務(wù)構(gòu)成——每個任務(wù)都是具有獨(dú)立權(quán)限的程序。這些獨(dú)立的任務(wù)之間的通訊與同步一般都是基于操作系統(tǒng)提供的IPC通訊機(jī)制，而FreeRTOS 中所有的通信與同步機(jī)制都是基于隊列實現(xiàn)的。

消息隊列是一種常用于任務(wù)間通信的數(shù)據(jù)結(jié)構(gòu)，隊列可以在任務(wù)與任務(wù)間、中斷和任務(wù)間傳送信息，實現(xiàn)了任務(wù)接收來自其他任務(wù)或中斷的不固定長度的消息。任務(wù)能夠從隊列里面讀取消息，當(dāng)隊列中的消息是空時，掛起讀取任務(wù)，用戶還可以指定掛起的任務(wù)時間；當(dāng)隊列中有新消息時，掛起的讀取任務(wù)被喚醒并處理新消息，消息隊列是一種異步的通信方式。

隊列特性

1.數(shù)據(jù)存儲

隊列可以保存有限個具有確定長度的數(shù)據(jù)單元。隊列可以保存的最大單元數(shù)目被稱為隊列的“深度”。在隊列創(chuàng)建時需要設(shè)定其深度和每個單元的大小。

通常情況下，隊列被作為 FIFO(先進(jìn)先出)緩沖區(qū)使用，即數(shù)據(jù)由隊列尾寫入，從隊列首讀出。當(dāng)然，由隊列首寫入也是可能的。

往隊列寫入數(shù)據(jù)是通過字節(jié)拷貝把數(shù)據(jù)復(fù)制存儲到隊列中；從隊列讀出數(shù)據(jù)使得把隊列中的數(shù)據(jù)拷貝刪除。

2.讀阻塞

當(dāng)某個任務(wù)試圖讀一個隊列時，其可以指定一個阻塞超時時間。在這段時間中，如果隊列為空，該任務(wù)將保持阻塞狀態(tài)以等待隊列數(shù)據(jù)有效。當(dāng)其它任務(wù)或中斷服務(wù)例程往其等待的隊列中寫入了數(shù)據(jù)，該任務(wù)將自動由阻塞態(tài)轉(zhuǎn)移為就緒態(tài)。當(dāng)?shù)却臅r間超過了指定的阻塞時間，即使隊列中尚無有效數(shù)據(jù)，任務(wù)也會自動從阻塞態(tài)轉(zhuǎn)移為就緒態(tài)。

由于隊列可以被多個任務(wù)讀取，所以對單個隊列而言，也可能有多個任務(wù)處于阻塞狀態(tài)以等待隊列數(shù)據(jù)有效。這種情況下，一旦隊列數(shù)據(jù)有效，只會有一個任務(wù)會被解除阻塞，這個任務(wù)就是所有等待任務(wù)中優(yōu)先級最高的任務(wù)。而如果所有等待任務(wù)的優(yōu)先級相同，那么被解除阻塞的任務(wù)將是等待最久的任務(wù)。

說些題外話，ucos中是具有廣播消息的，當(dāng)有多個任務(wù)阻塞在隊列上，當(dāng)發(fā)送消息的時候可以選擇廣播消息，那么這些阻塞的任務(wù)都能被解除阻塞。

3.寫阻塞

與讀阻塞想反，任務(wù)也可以在寫隊列時指定一個阻塞超時時間。這個時間是當(dāng)被寫隊列已滿時，任務(wù)進(jìn)入阻塞態(tài)以等待隊列空間有效的最長時間。

由于隊列可以被多個任務(wù)寫入，所以對單個隊列而言，也可能有多個任務(wù)處于阻塞狀態(tài)以等待隊列空間有效。這種情況下，一旦隊列空間有效，只會有一個任務(wù)會被解除阻塞，這個任務(wù)就是所有等待任務(wù)中優(yōu)先級最高的任務(wù)。而如果所有等待任務(wù)的優(yōu)先級相同，那么被解除阻塞的任務(wù)將是等待最久的任務(wù)。

消息隊列的工作流程

1.發(fā)送消息

任務(wù)或者中斷服務(wù)程序都可以給消息隊列發(fā)送消息，當(dāng)發(fā)送消息時，如果隊列未滿或者允許覆蓋入隊， FreeRTOS 會將消息拷貝到消息隊列隊尾，否則，會根據(jù)用戶指定的阻塞超時時間進(jìn)行阻塞，在這段時間中，如果隊列一直不允許入隊，該任務(wù)將保持阻塞狀態(tài)以等待隊列允許入隊。當(dāng)其它任務(wù)從其等待的隊列中讀取入了數(shù)據(jù)（隊列未滿），該任務(wù)將自動由阻塞態(tài)轉(zhuǎn)為就緒態(tài)。當(dāng)任務(wù)等待的時間超過了指定的阻塞時間，即使隊列中還不允許入隊，任務(wù)也會自動從阻塞態(tài)轉(zhuǎn)移為就緒態(tài)，此時發(fā)送消息的任務(wù)或者中斷程序會收到一個錯誤碼 errQUEUE_FULL。

發(fā)送緊急消息的過程與發(fā)送消息幾乎一樣，唯一的不同是，當(dāng)發(fā)送緊急消息時，發(fā)送的位置是消息隊列隊頭而非隊尾，這樣，接收者就能夠優(yōu)先接收到緊急消息，從而及時進(jìn)行消息處理。

下面是消息隊列的發(fā)送API接口，函數(shù)中有FromISR則表明在中斷中使用的。

消息隊列入隊（發(fā)送）的API接口

1 /*-----------------------------------------------------------*/
 2 BaseType_t xQueueGenericSend( QueueHandle_t xQueue,        (1) 
 3                               const void * const pvItemToQueue,     (2)
 4                               TickType_t xTicksToWait,        (3)
 5                               const BaseType_t xCopyPosition )    (4)
 6 {
 7     BaseType_t xEntryTimeSet = pdFALSE, xYieldRequired;
 8     TimeOut_t xTimeOut;
 9     Queue_t * const pxQueue = ( Queue_t * ) xQueue;
10 
11     /* 已刪除一些斷言操作 */
12 
13     for ( ;; ) {
14         taskENTER_CRITICAL();                    (5)
15         {
16             /* 隊列未滿 */
17             if ( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength )
18                  || ( xCopyPosition == queueOVERWRITE ) ) {    (6) 
19                 traceQUEUE_SEND( pxQueue );
20                 xYieldRequired =
21           prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition ); (7)
22 
23                 /* 已刪除使用隊列集部分代碼 */
24                 /* 如果有任務(wù)在等待獲取此消息隊列 */
25       if ( listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive))==pdFALSE){ (8)
26                     /* 將任務(wù)從阻塞中恢復(fù) */
27             if ( xTaskRemoveFromEventList(
28                   &( pxQueue->xTasksWaitingToReceive ) )!=pdFALSE) { (9)
29                         /* 如果恢復(fù)的任務(wù)優(yōu)先級比當(dāng)前運(yùn)行任務(wù)優(yōu)先級還高，
30                         那么需要進(jìn)行一次任務(wù)切換 */
31                         queueYIELD_IF_USING_PREEMPTION();    (10)
32                     } else {
33                         mtCOVERAGE_TEST_MARKER();
34                     }
35                 } else if ( xYieldRequired != pdFALSE ) {
36                     /* 如果沒有等待的任務(wù)，拷貝成功也需要任務(wù)切換 */
37                     queueYIELD_IF_USING_PREEMPTION();        (11)
38                 } else {
39                     mtCOVERAGE_TEST_MARKER();
40                 }
41 
42                 taskEXIT_CRITICAL();                (12)
43                 return pdPASS;
44             }
45             /* 隊列已滿 */
46             else {                        (13)
47                 if ( xTicksToWait == ( TickType_t ) 0 ) {
48                     /* 如果用戶不指定阻塞超時時間，退出 */
49                     taskEXIT_CRITICAL();            (14)
50                     traceQUEUE_SEND_FAILED( pxQueue );
51                     return errQUEUE_FULL;
52                 } else if ( xEntryTimeSet == pdFALSE ) {    
53                     /* 初始化阻塞超時結(jié)構(gòu)體變量，初始化進(jìn)入
54                 阻塞的時間xTickCount和溢出次數(shù)xNumOfOverflows */
55                     vTaskSetTimeOutState( &xTimeOut );        (15)
56                     xEntryTimeSet = pdTRUE;
57                 } else {
58                     mtCOVERAGE_TEST_MARKER();
59                 }
60             }
61         }
62         taskEXIT_CRITICAL();                    (16)
63         /* 掛起調(diào)度器 */
64         vTaskSuspendAll();
65         /* 隊列上鎖 */
66         prvLockQueue( pxQueue );
67 
68         /* 檢查超時時間是否已經(jīng)過去了 */
69         if (xTaskCheckForTimeOut(&xTimeOut, &xTicksToWait)==pdFALSE){ (17)
70             /* 如果隊列還是滿的 */
71             if ( prvIsQueueFull( pxQueue ) != pdFALSE ) {    (18)    
72                 traceBLOCKING_ON_QUEUE_SEND( pxQueue );    
73                 /* 將當(dāng)前任務(wù)添加到隊列的等待發(fā)送列表中
74                    以及阻塞延時列表，延時時間為用戶指定的超時時間xTicksToWait */
75                 vTaskPlaceOnEventList(
76                    &( pxQueue->xTasksWaitingToSend ), xTicksToWait );(19)
77                 /* 隊列解鎖 */
78                 prvUnlockQueue( pxQueue );            (20)
79 
80                 /* 恢復(fù)調(diào)度器 */
81                 if ( xTaskResumeAll() == pdFALSE ) {
82                     portYIELD_WITHIN_API();
83                 }
84             } else {
85                 /* 隊列有空閑消息空間，允許入隊 */
86                 prvUnlockQueue( pxQueue );            (21)
87                 ( void ) xTaskResumeAll();
88             }
89         } else {
90             /* 超時時間已過，退出 */
91             prvUnlockQueue( pxQueue );                (22)
92             ( void ) xTaskResumeAll();
93 
94             traceQUEUE_SEND_FAILED( pxQueue );
95             return errQUEUE_FULL;
96         }
97     }
98 }
99 /*-----------------------------------------------------------*/

如果阻塞時間不為 0，任務(wù)會因為等待入隊而進(jìn)入阻塞， 在將任務(wù)設(shè)置為阻塞的過程中， 系統(tǒng)不希望有其它任務(wù)和中斷操作這個隊列的 xTasksWaitingToReceive 列表和 xTasksWaitingToSend 列表，因為可能引起其它任務(wù)解除阻塞，這可能會發(fā)生優(yōu)先級翻轉(zhuǎn)。比如任務(wù) A 的優(yōu)先級低于當(dāng)前任務(wù)，但是在當(dāng)前任務(wù)進(jìn)入阻塞的過程中，任務(wù) A 卻因為其它原因解除阻塞了，這顯然是要絕對禁止的。因此FreeRTOS 使用掛起調(diào)度器禁止其它任務(wù)操作隊列，因為掛起調(diào)度器意味著任務(wù)不能切換并且不準(zhǔn)調(diào)用可能引起任務(wù)切換的 API 函數(shù)。但掛起調(diào)度器并不會禁止中斷，中斷服務(wù)函數(shù)仍然可以操作隊列阻塞列表，可能會解除任務(wù)阻塞、可能會進(jìn)行上下文切換，這也是不允許的。于是，FreeRTOS解決辦法是不但掛起調(diào)度器，還要給隊列上鎖，禁止任何中斷來操作隊列。

下面來看看流程圖：

消息隊列發(fā)送流程

相比在任務(wù)中調(diào)用的發(fā)送函數(shù)，在中斷中調(diào)用的函數(shù)會更加簡單一些， 沒有任務(wù)阻塞操作。

函數(shù) xQueueGenericSend中插入數(shù)據(jù)后， 會檢查等待接收鏈表是否有任務(wù)等待，如果有會恢復(fù)就緒。如果恢復(fù)的任務(wù)優(yōu)先級比當(dāng)前任務(wù)高， 則會觸發(fā)任務(wù)切換；但是在中斷中調(diào)用的這個函數(shù)的做法是返回一個參數(shù)標(biāo)志是否需要觸發(fā)任務(wù)切換，并不在中斷中切換任務(wù)。

在任務(wù)中調(diào)用的函數(shù)中有鎖定和解鎖隊列的操作， 鎖定隊列的時候， 隊列的事件鏈表不能被修改。 而在被中斷中發(fā)送消息的處理是： 當(dāng)遇到隊列被鎖定的時候， 將新數(shù)據(jù)插入到隊列后， 并不會直接恢復(fù)因為等待接收的任務(wù)， 而是累加了計數(shù)， 當(dāng)隊列解鎖的時候， 會根據(jù)這個計數(shù)， 對應(yīng)恢復(fù)幾個任務(wù)。

遇到隊列滿的情況， 函數(shù)會直接返回， 而不是阻塞等待， 因為在中斷中阻塞是不允許的?。。?/p>

1 BaseType_t xQueueGenericSendFromISR(
 2        QueueHandle_t xQueue,
 3        const void * const pvItemToQueue,
 4        /* 不在中斷函數(shù)中觸發(fā)任務(wù)切換， 而是返回一個標(biāo)記 */
 5        BaseType_t * const pxHigherPriorityTaskWoken,
 6        const BaseType_t xCopyPosition )
 7{
 8    BaseType_t xReturn;
 9    UBaseType_t uxSavedInterruptStatus;
10    Queue_t * const pxQueue = ( Queue_t * ) xQueue;
11
12    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
13    {
14        // 判斷隊列是否有空間插入新內(nèi)容
15        if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )
16        {
17            const int8_t cTxLock = pxQueue->cTxLock;
18
19            // 中斷中不能使用互斥鎖， 所以拷貝函數(shù)只是拷貝數(shù)據(jù)，
20            // 沒有任務(wù)優(yōu)先級繼承需要考慮
21            ( void ) prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );
22
23            // 判斷隊列是否被鎖定
24            if( cTxLock == queueUNLOCKED )
25            {
26            #if ( configUSE_QUEUE_SETS == 1 )
27                // 集合相關(guān)代碼
28            #else /* configUSE_QUEUE_SETS */
29                {
30                    // 將最高優(yōu)先級的等待任務(wù)恢復(fù)到就緒鏈表
31                    if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )
32                    {
33                        if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE)
34                        {
35                            // 如果有高優(yōu)先級的任務(wù)被恢復(fù)
36                            // 此處不直接觸發(fā)任務(wù)切換， 而是返回一個標(biāo)記
37                            if( pxHigherPriorityTaskWoken != NULL )
38                            {
39                                *pxHigherPriorityTaskWoken = pdTRUE;
40                            }
41                        }
42                    }
43                }
44            #endif /* configUSE_QUEUE_SETS */
45            }
46            else
47            {
48                // 隊列被鎖定， 不能修改事件鏈表
49                // 增加計數(shù)， 記錄需要接觸幾個任務(wù)到就緒
50                // 在解鎖隊列的時候會根據(jù)這個計數(shù)恢復(fù)任務(wù)
51                pxQueue->cTxLock = ( int8_t ) ( cTxLock + 1 );
52            }
53            xReturn = pdPASS;
54        }
55        else
56        {
57            // 隊列滿 直接返回 不阻塞
58            xReturn = errQUEUE_FULL;
59        }
60    }
61
62    // 恢復(fù)中斷的優(yōu)先級
63    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
64
65    return xReturn;
66}

消息隊列讀取

消息讀取

任務(wù)調(diào)用接收函數(shù)收取隊列消息， 函數(shù)首先判斷當(dāng)前隊列是否有未讀消息， 如果沒有， 則會判斷參數(shù) xTicksToWait, 決定直接返回函數(shù)還是阻塞等待。

如果隊列中有消息未讀， 首先會把待讀的消息復(fù)制到傳進(jìn)來的指針?biāo)竷?nèi)， 然后判斷函數(shù)參數(shù) xJustPeeking == pdFALSE的時候， 符合的話， 說明這個函數(shù)讀取了數(shù)據(jù)， 需要把被讀取的數(shù)據(jù)做出隊處理， 如果不是， 則只是查看一下（peek），只是返回數(shù)據(jù)，但是不會把數(shù)據(jù)清除。

對于正常讀取數(shù)據(jù)的操作， 清除數(shù)據(jù)后隊列會空出空位， 所以查看隊列中的等待列表中是否有任務(wù)等發(fā)送數(shù)據(jù)而被掛起， 有的話恢復(fù)一個任務(wù)就緒， 并根據(jù)優(yōu)先級判斷是否需要出進(jìn)行任務(wù)切換。

對于只是查看數(shù)據(jù)的， 由于沒有清除數(shù)據(jù)， 所以沒有空間新空出，不需要檢查發(fā)送等待鏈表， 但是會檢查接收等待鏈表， 如果有任務(wù)掛起會切換其到就緒并判斷是否需要切換。

消息隊列出隊過程分析，其實跟入隊差不多，請看注釋：

1 /*-----------------------------------------------------------*/
 2 BaseType_t xQueueGenericReceive( QueueHandle_t xQueue,        (1) 
 3                                  void * const pvBuffer,        (2)
 4                                  TickType_t xTicksToWait,    (3) 
 5                                  const BaseType_t xJustPeeking )    (4)
 6 {
 7     BaseType_t xEntryTimeSet = pdFALSE;
 8     TimeOut_t xTimeOut;
 9     int8_t *pcOriginalReadPosition;
10     Queue_t * const pxQueue = ( Queue_t * ) xQueue;
11 
12     /* 已刪除一些斷言 */
13     for ( ;; ) {
14         taskENTER_CRITICAL();                    (5)
15         {
16             const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting; 
17 
18             /* 看看隊列中有沒有消息 */
19             if ( uxMessagesWaiting > ( UBaseType_t ) 0 ) {    (6) 
20                 /*防止僅僅是讀取消息，而不進(jìn)行消息出隊操作*/
21                 pcOriginalReadPosition = pxQueue->u.pcReadFrom;    (7)
22                 /* 拷貝消息到用戶指定存放區(qū)域pvBuffer */
23                 prvCopyDataFromQueue( pxQueue, pvBuffer );    (8)
24 
25                 if ( xJustPeeking == pdFALSE ) {        (9)
26                     /* 讀取消息并且消息出隊 */
27                     traceQUEUE_RECEIVE( pxQueue );    
28 
29                     /* 獲取了消息，當(dāng)前消息隊列的消息個數(shù)需要減一 */
30                     pxQueue->uxMessagesWaiting = uxMessagesWaiting - 1;  (10)
31                     /* 判斷一下消息隊列中是否有等待發(fā)送消息的任務(wù) */
32                     if ( listLIST_IS_EMPTY(            (11)
33                              &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE ) {
34                         /* 將任務(wù)從阻塞中恢復(fù) */
35                         if ( xTaskRemoveFromEventList(        (12)
36                                  &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE ) {
37                             /* 如果被恢復(fù)的任務(wù)優(yōu)先級比當(dāng)前任務(wù)高，會進(jìn)行一次任務(wù)切換 */
38                             queueYIELD_IF_USING_PREEMPTION();    (13)
39                         } else {
40                             mtCOVERAGE_TEST_MARKER();
41                         }
42                     } else {
43                         mtCOVERAGE_TEST_MARKER();
44                     }
45                 } else {                    (14)
46                     /* 任務(wù)只是看一下消息（peek），并不出隊 */    
47                     traceQUEUE_PEEK( pxQueue );
48 
49                     /* 因為是只讀消息 所以還要還原讀消息位置指針 */
50                     pxQueue->u.pcReadFrom = pcOriginalReadPosition; (15)
51 
52                     /* 判斷一下消息隊列中是否還有等待獲取消息的任務(wù) */
53                     if ( listLIST_IS_EMPTY(            (16)
54                              &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE ) {
55                         /* 將任務(wù)從阻塞中恢復(fù) */
56                         if ( xTaskRemoveFromEventList(            
57                               &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE ) {
58                             /* 如果被恢復(fù)的任務(wù)優(yōu)先級比當(dāng)前任務(wù)高，會進(jìn)行一次任務(wù)切換 */
59                             queueYIELD_IF_USING_PREEMPTION();    
60                         } else {
61                             mtCOVERAGE_TEST_MARKER();
62                         }
63                     } else {
64                         mtCOVERAGE_TEST_MARKER();
65                     }
66                 }
67 
68                 taskEXIT_CRITICAL();                (17)
69                 return pdPASS;
70             } else {                        (18)
71                 /* 消息隊列中沒有消息可讀 */
72                 if ( xTicksToWait == ( TickType_t ) 0 ) {    (19)    
73                     /* 不等待，直接返回 */
74                     taskEXIT_CRITICAL();
75                     traceQUEUE_RECEIVE_FAILED( pxQueue );
76                     return errQUEUE_EMPTY;
77                 } else if ( xEntryTimeSet == pdFALSE ) {        
78                     /* 初始化阻塞超時結(jié)構(gòu)體變量，初始化進(jìn)入
79                     阻塞的時間xTickCount和溢出次數(shù)xNumOfOverflows */
80                     vTaskSetTimeOutState( &xTimeOut );        (20)
81                     xEntryTimeSet = pdTRUE;
82                 } else {
83                     mtCOVERAGE_TEST_MARKER();
84                 }
85             }
86         }
87         taskEXIT_CRITICAL();                    
88 
89         vTaskSuspendAll();
90         prvLockQueue( pxQueue );                (21)
91 
92         /* 檢查超時時間是否已經(jīng)過去了*/
93         if ( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE ) {(22)
94             /* 如果隊列還是空的 */
95             if ( prvIsQueueEmpty( pxQueue ) != pdFALSE ) {
96                 traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );    (23)    
97                 /* 將當(dāng)前任務(wù)添加到隊列的等待接收列表中
98                    以及阻塞延時列表，阻塞時間為用戶指定的超時時間xTicksToWait */
99                 vTaskPlaceOnEventList(                
100                     &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );
101                 prvUnlockQueue( pxQueue );
102                 if ( xTaskResumeAll() == pdFALSE ) {        
103                     /* 如果有任務(wù)優(yōu)先級比當(dāng)前任務(wù)高，會進(jìn)行一次任務(wù)切換 */
104                     portYIELD_WITHIN_API();            
105                 } else {
106                     mtCOVERAGE_TEST_MARKER();
107                 }
108             } else {
109                 /* 如果隊列有消息了，就再試一次獲取消息 */
110                 prvUnlockQueue( pxQueue );            (24)
111                 ( void ) xTaskResumeAll();
112             }
113         } else {
114             /* 超時時間已過，退出 */
115             prvUnlockQueue( pxQueue );                (25)
116             ( void ) xTaskResumeAll();
117 
118             if ( prvIsQueueEmpty( pxQueue ) != pdFALSE ) {
119                 /* 如果隊列還是空的，返回錯誤代碼errQUEUE_EMPTY */
120                 traceQUEUE_RECEIVE_FAILED( pxQueue );
121                 return errQUEUE_EMPTY;                (26)
122             } else {
123                 mtCOVERAGE_TEST_MARKER();
124             }
125         }
126     }
127 }
128 /*-----------------------------------------------------------*/

提示

如果隊列存儲的數(shù)據(jù)較大時，那最好是利用隊列來傳遞數(shù)據(jù)的指針而不是數(shù)據(jù)本身，因為傳遞數(shù)據(jù)的時候是需要CPU一字節(jié)一字節(jié)地將數(shù)據(jù)拷貝進(jìn)隊列或從隊列拷貝出來。而傳遞指針無論是在處理速度上還是內(nèi)存空間利用上都更有效。但是，當(dāng)利用隊列傳遞指針時，一定要十分小心地做到以下兩點：

1.指針指向的內(nèi)存空間的所有權(quán)必須明確

當(dāng)任務(wù)間通過指針共享內(nèi)存時，應(yīng)該從根本上保證所不會有任意兩個任務(wù)同時修改共享內(nèi)存中的數(shù)據(jù)，或是以其它行為方式使得共享內(nèi)存數(shù)據(jù)無效或產(chǎn)生一致性問題。原則上，共享內(nèi)存在其指針發(fā)送到隊列之前，其內(nèi)容只允許被發(fā)送任務(wù)訪問；共享內(nèi)存指針從隊列中被讀出之后，其內(nèi)容亦只允許被接收任務(wù)訪問。

2.指針指向的內(nèi)存空間必須有效

如果指針指向的內(nèi)存空間是動態(tài)分配的，只應(yīng)該有一個任務(wù)負(fù)責(zé)對其進(jìn)行內(nèi)存釋放。當(dāng)這段內(nèi)存空間被釋放之后，就不應(yīng)該有任何一個任務(wù)再訪問這段空間。

并且最最最重要的是禁止使用指針訪問任務(wù)棧上的空間，也就是局部變量。因為當(dāng)棧發(fā)生改變后，棧上的數(shù)據(jù)將不再有效。