本帖最后由 xiaojie0513 于 2019-3-8 19:00 编辑
FreeRTOS官网的API FreeRTOS消息队列3.写阻塞 与读阻塞想反，任务也可以在写队列时指定一个阻塞超时时间。这个时间是当被写队列已满时，任务进入阻塞态以等待队列空间有效的最长时间。 消息队列的工作流程1.发送消息由于队列可以被多个任务写入，所以对单个队列而言，也可能有多个任务处于阻塞状态以等待队列空间有效。这种情况下，一旦队列空间有效，只会有一个任务会被解除阻塞，这个任务就是所有等待任务中优先级最高的任务。而如果所有等待任务的优先级相同，那么被解除阻塞的任务将是等待最久的任务。 任务或者中断服务程序都可以给消息队列发送消息，当发送消息时，如果队列未满或者允许覆盖入队， FreeRTOS 会将消息拷贝到消息队列队尾，否则，会根据用户指定的阻塞超时时间进行阻塞，在这段时间中，如果队列一直不允许入队，该任务将保持阻塞状态以等待队列允许入队。当其它任务从其等待的队列中读取入了数据（队列未满），该任务将自动由阻塞态转为就绪态。当任务等待的时间超过了指定的阻塞时间，即使队列中还不允许入队，任务也会自动从阻塞态转移为就绪态，此时发送消息的任务或者中断程序会收到一个错误码 errQUEUE_FULL。$ h3 A5 A! f& I9 ^ 发送紧急消息的过程与发送消息几乎一样，唯一的不同是，当发送紧急消息时，发送的位置是消息队列队头而非队尾，这样，接收者就能够优先接收到紧急消息，从而及时进行消息处理。, C [9 t/ f, b* s# E8 T2 g 下面是消息队列的发送API接口，函数中有FromISR则表明在中断中使用的。  + O; x. X9 Q, v o& D# _消息队列入队（发送）的API接口2 z& C% R( R9 X$ o# Q 1 /*-----------------------------------------------------------*/ 2 BaseType_t xQueueGenericSend( QueueHandle_t xQueue, (1) # M2 }0 M% p& I1 g0 b: d% g 3 const void * const pvItemToQueue, (2)+ D: h% v0 ]" L. C' X1 a 4 TickType_t xTicksToWait, (3)# }6 n$ {5 n. S, W 5 const BaseType_t xCopyPosition ) (4) 6 {0 m- W# o9 o% h* Z/ k9 c0 C9 z 7 BaseType_t xEntryTimeSet = pdFALSE, xYieldRequired; 8 TimeOut_t xTimeOut; 9 Queue_t * const pxQueue = ( Queue_t * ) xQueue;$ y$ B2 I. H8 `' \. u7 M 10 6 m' A% D8 x& B5 y9 J3 c5 _1 Z k 11 /* 已删除一些断言操作 */& e4 p' e$ d3 \: t 12 $ J. Q9 M$ K, h# v. h 13 for ( ;; ) {& L# X( B D& M" ?, D; s 14 taskENTER_CRITICAL(); (5) 15 { 16 /* 队列未满 */ 17 if ( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) 18 || ( xCopyPosition == queueOVERWRITE ) ) { (6) , F0 O# `/ S+ p+ P7 R3 T0 y 19 traceQUEUE_SEND( pxQueue ); 20 xYieldRequired =5 s" Y5 f$ l' q 21 prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition ); (7) 22 23 /* 已删除使用队列集部分代码 */2 c4 k9 P' S4 Y, a 24 /* 如果有任务在等待获取此消息队列 */ 25 if ( listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive))==pdFALSE){ (8) 26 /* 将任务从阻塞中恢复 */5 P7 j# y% Y0 _4 a 27 if ( xTaskRemoveFromEventList( 28 &( pxQueue->xTasksWaitingToReceive ) )!=pdFALSE) { (9) 29 /* 如果恢复的任务优先级比当前运行任务优先级还高， E, }, r+ W" R y 30 那么需要进行一次任务切换 */$ d' N6 b1 d) _0 P4 ?' @ 31 queueYIELD_IF_USING_PREEMPTION(); (10) 32 } else { 33 mtCOVERAGE_TEST_MARKER(); 34 } 35 } else if ( xYieldRequired != pdFALSE ) {4 |) m0 e( ]! ^/ e; g0 D 36 /* 如果没有等待的任务，拷贝成功也需要任务切换 */( H6 d r. d; t0 q- c3 X 37 queueYIELD_IF_USING_PREEMPTION(); (11) 38 } else { 39 mtCOVERAGE_TEST_MARKER();8 F7 E7 q0 g2 n$ g! n2 _ m0 Z& } 40 } 41 42 taskEXIT_CRITICAL(); (12)( V, m& v. N+ k! K4 c 43 return pdPASS;1 }3 C) P) d' [ 44 } 45 /* 队列已满 */ 46 else { (13) 47 if ( xTicksToWait == ( TickType_t ) 0 ) { 48 /* 如果用户不指定阻塞超时时间，退出 */) q2 D( }. w7 q$ N 49 taskEXIT_CRITICAL(); (14)9 J0 J$ W* N i; _ 50 traceQUEUE_SEND_FAILED( pxQueue ); 51 return errQUEUE_FULL; 52 } else if ( xEntryTimeSet == pdFALSE ) { 53 /* 初始化阻塞超时结构体变量，初始化进入 54 阻塞的时间xTickCount和溢出次数xNumOfOverflows */. O- D2 G# o1 R6 Y6 w& | 55 vTaskSetTimeOutState( &xTimeOut ); (15)) t9 Q- _8 o* k 56 xEntryTimeSet = pdTRUE; 57 } else {+ G+ S# H! X7 J% ^2 h 58 mtCOVERAGE_TEST_MARKER(); 59 } 60 } 61 }1 r; x) c4 `4 z! }0 |. T 62 taskEXIT_CRITICAL(); (16) 63 /* 挂起调度器 */ 64 vTaskSuspendAll(); 65 /* 队列上锁 */ 66 prvLockQueue( pxQueue );% {& f. U. W8 g9 h, ?- S 67 & Q/ a6 L- B8 ?1 C6 G' `5 ~ 68 /* 检查超时时间是否已经过去了 */ 69 if (xTaskCheckForTimeOut(&xTimeOut, &xTicksToWait)==pdFALSE){ (17). a: w) \7 O. s4 a' m 70 /* 如果队列还是满的 */; ]# r0 \5 E/ p9 U% U 71 if ( prvIsQueueFull( pxQueue ) != pdFALSE ) { (18) 72 traceBLOCKING_ON_QUEUE_SEND( pxQueue ); 73 /* 将当前任务添加到队列的等待发送列表中 74 以及阻塞延时列表，延时时间为用户指定的超时时间xTicksToWait */ 75 vTaskPlaceOnEventList( 76 &( pxQueue->xTasksWaitingToSend ), xTicksToWait );(19) 77 /* 队列解锁 */3 @- k9 x" P T. ~5 v 78 prvUnlockQueue( pxQueue ); (20)6 O8 u9 c T) d- ?9 j3 C( E: N" i 79 1 o3 W( R! c$ k% b2 R% `5 Y 80 /* 恢复调度器 */ 81 if ( xTaskResumeAll() == pdFALSE ) { 82 portYIELD_WITHIN_API();9 ?2 M: r" q! T1 N% C, x 83 } 84 } else {) [, |/ G) r, B 85 /* 队列有空闲消息空间，允许入队 */ 86 prvUnlockQueue( pxQueue ); (21) 87 ( void ) xTaskResumeAll();4 U3 i6 M- h. l8 e7 L6 Z 88 }. g* A! g. s9 J, Z7 K/ l 89 } else {1 ~6 k0 `, H) V( Y) d, B- | 90 /* 超时时间已过，退出 */1 U! n+ K+ q/ z/ ^# c 91 prvUnlockQueue( pxQueue ); (22)0 N6 P- ?% O1 E 92 ( void ) xTaskResumeAll(); 93 94 traceQUEUE_SEND_FAILED( pxQueue );6 ^" `' N8 i( O# d. Q. p 95 return errQUEUE_FULL; 96 } 97 } z) v: a! `* Z3 ~8 V9 ?7 C4 r# ~ 98 }1 e4 T, w- x' C5 q 99 /*-----------------------------------------------------------*/8 h( e& b& G1 \! o5 x 如果阻塞时间不为 0，任务会因为等待入队而进入阻塞， 在将任务设置为阻塞的过程中， 系统不希望有其它任务和中断操作这个队列的 xTasksWaitingToReceive 列表和 xTasksWaitingToSend 列表，因为可能引起其它任务解除阻塞，这可能会发生优先级翻转。比如任务 A 的优先级低于当前任务，但是在当前任务进入阻塞的过程中，任务 A 却因为其它原因解除阻塞了，这显然是要绝对禁止的。因此FreeRTOS 使用挂起调度器禁止其它任务操作队列，因为挂起调度器意味着任务不能切换并且不准调用可能引起任务切换的 API 函数。但挂起调度器并不会禁止中断，中断服务函数仍然可以操作队列阻塞列表，可能会解除任务阻塞、可能会进行上下文切换，这也是不允许的。于是，FreeRTOS解决办法是不但挂起调度器，还要给队列上锁，禁止任何中断来操作队列。 下面来看看流程图：# I$ N c9 L' x7 [, o# b  消息队列发送流程6 W+ w7 C- ]3 Z$ N" I : G1 S, K4 g; W7 X+ {7 S0 e) [$ x 相比在任务中调用的发送函数，在中断中调用的函数会更加简单一些， 没有任务阻塞操作。 函数 xQueueGenericSend中插入数据后， 会检查等待接收链表是否有任务等待，如果有会恢复就绪。如果恢复的任务优先级比当前任务高， 则会触发任务切换；但是在中断中调用的这个函数的做法是返回一个参数标志是否需要触发任务切换，并不在中断中切换任务。+ G/ M( I5 T3 C( _3 M2 B B+ v5 X 在任务中调用的函数中有锁定和解锁队列的操作， 锁定队列的时候， 队列的事件链表不能被修改。 而在被中断中发送消息的处理是： 当遇到队列被锁定的时候， 将新数据插入到队列后， 并不会直接恢复因为等待接收的任务， 而是累加了计数， 当队列解锁的时候， 会根据这个计数， 对应恢复几个任务。 遇到队列满的情况， 函数会直接返回， 而不是阻塞等待， 因为在中断中阻塞是不允许的！！！ 1 BaseType_t xQueueGenericSendFromISR(: V$ ]2 @2 h5 n) y$ W# P 2 QueueHandle_t xQueue,' R5 O/ z$ G' O/ k 3 const void * const pvItemToQueue, 4 /* 不在中断函数中触发任务切换， 而是返回一个标记 *// w' d; L/ N x# o2 b% s/ w 5 BaseType_t * const pxHigherPriorityTaskWoken,- C, }' H' W% D: n 6 const BaseType_t xCopyPosition ) 7{! d" M& u3 f( }' b 8 BaseType_t xReturn;' @4 m x# D: d 9 UBaseType_t uxSavedInterruptStatus; 10 Queue_t * const pxQueue = ( Queue_t * ) xQueue; 11 12 uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();7 g m7 B7 W8 V1 Z: i 13 {0 Q" g6 n6 e. j; S& Q9 Q. z9 S 14 // 判断队列是否有空间插入新内容" i* N1 i$ G! @; j" L; C. W 15 if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) ) 16 {6 j5 J l+ A5 P 17 const int8_t cTxLock = pxQueue->cTxLock;1 ]' x5 @ R2 x$ o 18/ F- \! e1 Y( \" A, Z+ P% ] 19 // 中断中不能使用互斥锁， 所以拷贝函数只是拷贝数据，9 L5 W& u. ]. _0 P5 { 20 // 没有任务优先级继承需要考虑' {, Z/ G v- c3 }$ F9 l. t 21 ( void ) prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );% a. w+ m& T y 22 23 // 判断队列是否被锁定 24 if( cTxLock == queueUNLOCKED ) 25 { 26 #if ( configUSE_QUEUE_SETS == 1 ) 27 // 集合相关代码9 d! h& n5 z# V9 ~# ?9 z9 R3 d4 W5 C 28 #else /* configUSE_QUEUE_SETS */( G6 T! V9 B% X3 t 29 {& {3 T& u3 t& [- Y5 l$ I) t4 Y 30 // 将最高优先级的等待任务恢复到就绪链表 31 if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )( f, E, v2 o& @+ u9 W4 O/ } 32 {; H9 L7 N& l) t5 a8 X 33 if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE) 34 { 35 // 如果有高优先级的任务被恢复: h4 ^! F/ S& X+ I% `( F+ Z' ? 36 // 此处不直接触发任务切换， 而是返回一个标记 37 if( pxHigherPriorityTaskWoken != NULL ) 38 {6 l. T4 F; {" H. f# j u9 L 39 *pxHigherPriorityTaskWoken = pdTRUE;: C5 P3 B3 T+ V8 t9 K! z( w 40 }- I* d- V, g6 P# E$ V. r 41 }- V4 V+ V5 O0 w 42 }& |. m2 b( D& o1 m- R2 A 43 }2 w+ i( ^/ M5 @) X9 b; F6 F# f" w 44 #endif /* configUSE_QUEUE_SETS */ 45 } 46 else1 `5 q8 [ l' c- g& y" G8 r 47 {9 M, E0 ^8 ^2 T5 O2 O! H5 p 48 // 队列被锁定， 不能修改事件链表 49 // 增加计数， 记录需要接触几个任务到就绪% B; {& m" I5 S6 S+ a 50 // 在解锁队列的时候会根据这个计数恢复任务& D7 `5 z. n& L" s) U 51 pxQueue->cTxLock = ( int8_t ) ( cTxLock + 1 ); 52 } 53 xReturn = pdPASS;' W6 ~5 B: n( a! ^6 b7 U 54 }7 R3 h7 I& A' A4 K* v+ ] 55 else% c3 Z7 n% |" D- q6 S3 { 56 { 57 // 队列满 直接返回 不阻塞 58 xReturn = errQUEUE_FULL;6 c4 e# W' b/ `% @5 g6 ]. Y0 { 59 } 60 } 61 62 // 恢复中断的优先级 63 portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );" z8 g* N! b9 M! @9 {3 E9 R* ?! v+ C 64 65 return xReturn; 66} 消息队列读取9 e5 d. ]" `% x0 V- Z3 \3 v' V  消息读取 任务调用接收函数收取队列消息， 函数首先判断当前队列是否有未读消息， 如果没有， 则会判断参数 xTicksToWait, 决定直接返回函数还是阻塞等待。% ]+ W& d) i$ d% b" B 如果队列中有消息未读， 首先会把待读的消息复制到传进来的指针所指内， 然后判断函数参数 xJustPeeking == pdFALSE的时候， 符合的话， 说明这个函数读取了数据， 需要把被读取的数据做出队处理， 如果不是， 则只是查看一下（peek），只是返回数据，但是不会把数据清除。 对于正常读取数据的操作， 清除数据后队列会空出空位， 所以查看队列中的等待列表中是否有任务等发送数据而被挂起， 有的话恢复一个任务就绪， 并根据优先级判断是否需要出进行任务切换。 对于只是查看数据的， 由于没有清除数据， 所以没有空间新空出，不需要检查发送等待链表， 但是会检查接收等待链表， 如果有任务挂起会切换其到就绪并判断是否需要切换。' U* A; b9 \' Z6 t( i 消息队列出队过程分析，其实跟入队差不多，请看注释： 1 /*-----------------------------------------------------------*/2 BaseType_t xQueueGenericReceive( QueueHandle_t xQueue, (1) 3 void * const pvBuffer, (2)) g0 S& Q; {+ a# p& V 4 TickType_t xTicksToWait, (3) 5 const BaseType_t xJustPeeking ) (4)8 X5 M8 E% } A" ? 6 {+ m7 N0 e# j0 n9 `- z8 T) Z1 Z3 | 7 BaseType_t xEntryTimeSet = pdFALSE;8 i/ P1 o& Z% w+ M: B 8 TimeOut_t xTimeOut; 9 int8_t *pcOriginalReadPosition;* O7 u! i; C/ d7 M 10 Queue_t * const pxQueue = ( Queue_t * ) xQueue; 11 12 /* 已删除一些断言 */ 13 for ( ;; ) {& z4 A( B+ G1 [2 ^9 L& Q 14 taskENTER_CRITICAL(); (5)! h) Z) e8 L! |- c% G8 v" V 15 {0 i$ @3 Q- D; \/ o/ @, ~; u6 C 16 const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting; 17 18 /* 看看队列中有没有消息 */ 19 if ( uxMessagesWaiting > ( UBaseType_t ) 0 ) { (6) 1 d3 s" f5 }. Z! d2 y7 e4 A 20 /*防止仅仅是读取消息，而不进行消息出队操作*/7 u" a `) T$ V& j# U* H 21 pcOriginalReadPosition = pxQueue->u.pcReadFrom; (7) 22 /* 拷贝消息到用户指定存放区域pvBuffer */ 23 prvCopyDataFromQueue( pxQueue, pvBuffer ); (8) 24 - w+ S# x5 y' \+ T) {& W1 U 25 if ( xJustPeeking == pdFALSE ) { (9) 26 /* 读取消息并且消息出队 */ 27 traceQUEUE_RECEIVE( pxQueue ); , r. h9 y o8 k9 M: b4 C7 k 28 29 /* 获取了消息，当前消息队列的消息个数需要减一 */0 j1 c( y* w" P+ E5 }) V. q 30 pxQueue->uxMessagesWaiting = uxMessagesWaiting - 1; (10) 31 /* 判断一下消息队列中是否有等待发送消息的任务 */ 32 if ( listLIST_IS_EMPTY( (11) 33 &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE ) {/ n- h0 @, g t- @ 34 /* 将任务从阻塞中恢复 */ 35 if ( xTaskRemoveFromEventList( (12): k$ k, e0 _/ a4 O: Q 36 &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE ) { 37 /* 如果被恢复的任务优先级比当前任务高，会进行一次任务切换 */: W& V% ]1 T D 38 queueYIELD_IF_USING_PREEMPTION(); (13) 39 } else { 40 mtCOVERAGE_TEST_MARKER(); 41 } 42 } else {: L5 ^2 a3 m& ]2 L 43 mtCOVERAGE_TEST_MARKER();. |& I( Q; H5 X5 y! N 44 }- i' Z0 `' [/ C 45 } else { (14) 46 /* 任务只是看一下消息（peek），并不出队 */ 47 traceQUEUE_PEEK( pxQueue ); 48 6 D8 g' \8 f! d) H! Y5 b, n% d 49 /* 因为是只读消息 所以还要还原读消息位置指针 */ 50 pxQueue->u.pcReadFrom = pcOriginalReadPosition; (15); b e4 R0 c: p 51 52 /* 判断一下消息队列中是否还有等待获取消息的任务 */ 53 if ( listLIST_IS_EMPTY( (16)5 N/ q& A- v( t+ P0 O6 t2 ~) V3 o 54 &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE ) { 55 /* 将任务从阻塞中恢复 */ 56 if ( xTaskRemoveFromEventList( 0 M2 v$ i4 {5 g! m 57 &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE ) {) \! z' H3 ^' z8 f& t 58 /* 如果被恢复的任务优先级比当前任务高，会进行一次任务切换 *// Y0 u$ ^ |6 q; f& |; N 59 queueYIELD_IF_USING_PREEMPTION(); 60 } else {* \( ~, a( m; K. P& l 61 mtCOVERAGE_TEST_MARKER();+ |7 Z* x& \, T6 ]3 R" P4 c/ \6 P3 H' x 62 } 63 } else {2 W% r) `5 y8 M3 R4 q9 ? 64 mtCOVERAGE_TEST_MARKER(); 65 } 66 }- B0 L a: y, n! \: f 67 6 d& x7 E/ T; t7 d$ v. O, ^ 68 taskEXIT_CRITICAL(); (17)( G. d( X5 B+ J$ F 69 return pdPASS;' ?7 I/ J# v, b. p$ V% i2 o, S 70 } else { (18) 71 /* 消息队列中没有消息可读 */' D% `, m9 T7 ~* ` 72 if ( xTicksToWait == ( TickType_t ) 0 ) { (19) 73 /* 不等待，直接返回 */ 74 taskEXIT_CRITICAL();, ~/ f- [ l- z+ A( ]+ U( i, f/ w. G 75 traceQUEUE_RECEIVE_FAILED( pxQueue ); 76 return errQUEUE_EMPTY; 77 } else if ( xEntryTimeSet == pdFALSE ) { 78 /* 初始化阻塞超时结构体变量，初始化进入$ X+ e" z( V; y4 { 79 阻塞的时间xTickCount和溢出次数xNumOfOverflows */ 80 vTaskSetTimeOutState( &xTimeOut ); (20), d W) P' s) O% _0 `* G2 U 81 xEntryTimeSet = pdTRUE;/ E4 g. t1 w$ F' g$ | 82 } else {" b, G3 F2 l# s4 ]. r! e 83 mtCOVERAGE_TEST_MARKER();; P G* e/ X. i 84 } 85 }' h1 O9 p3 d, z) r; h. U9 a 86 }6 u$ J e0 J7 ^$ F0 x 87 taskEXIT_CRITICAL(); 4 a! O( U- U/ ?6 | 88 89 vTaskSuspendAll(); 90 prvLockQueue( pxQueue ); (21) 91 ( V* M+ G8 Z0 A. T 92 /* 检查超时时间是否已经过去了*/ 93 if ( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE ) {(22)4 z. t* v+ V! |) e/ O8 {7 g 94 /* 如果队列还是空的 */ 95 if ( prvIsQueueEmpty( pxQueue ) != pdFALSE ) {4 m6 o7 `2 w! s3 [0 W. J2 ] 96 traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue ); (23) 7 } I( X, I+ E, u6 i3 _# X' A 97 /* 将当前任务添加到队列的等待接收列表中4 ]! }6 N* J5 J: W 98 以及阻塞延时列表，阻塞时间为用户指定的超时时间xTicksToWait */ 99 vTaskPlaceOnEventList( & f% [8 ?; \' ?* t/ T) y Z 100 &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );3 d3 r+ i: p2 O9 ]2 ` 101 prvUnlockQueue( pxQueue ); 102 if ( xTaskResumeAll() == pdFALSE ) { 1 c2 g4 N. ]5 w6 j$ S+ B 103 /* 如果有任务优先级比当前任务高，会进行一次任务切换 */+ @0 w a. S( f- [7 t 104 portYIELD_WITHIN_API(); 105 } else {' _7 H; I& P# `& T% U0 E 106 mtCOVERAGE_TEST_MARKER(); 107 } 108 } else {+ c8 `, N+ q! E0 J1 D( a: a 109 /* 如果队列有消息了，就再试一次获取消息 */ 110 prvUnlockQueue( pxQueue ); (24)" b% m: m0 f$ c) ]- M 111 ( void ) xTaskResumeAll();# C Q6 c( C" S' N/ Y 112 }% r$ Z9 D$ v$ g" f 113 } else { 114 /* 超时时间已过，退出 */8 c2 I/ s9 `$ z 115 prvUnlockQueue( pxQueue ); (25)* N! R9 h6 W N7 H* _6 R 116 ( void ) xTaskResumeAll();/ U5 q1 V; H" e/ l' C! H 117 118 if ( prvIsQueueEmpty( pxQueue ) != pdFALSE ) { 119 /* 如果队列还是空的，返回错误代码errQUEUE_EMPTY */* `4 H3 F: [5 k6 l X2 q3 \4 q( i 120 traceQUEUE_RECEIVE_FAILED( pxQueue );" j+ |. C' y+ u( J2 R( R; o' ]2 U 121 return errQUEUE_EMPTY; (26) 122 } else {7 I# L9 `* v- S$ v$ U 123 mtCOVERAGE_TEST_MARKER(); 124 }& V( X7 m1 H3 o: r 125 } 126 }+ f. z0 s! v* G) `; c 127 }2 ~7 u ?, o' S/ N) W7 Q$ j6 w 128 /*-----------------------------------------------------------*/* }! Y4 d, @ u e+ ] 提示 如果队列存储的数据较大时，那最好是利用队列来传递数据的指针而不是数据本身，因为传递数据的时候是需要CPU一字节一字节地将数据拷贝进队列或从队列拷贝出来。而传递指针无论是在处理速度上还是内存空间利用上都更有效。但是，当利用队列传递指针时，一定要十分小心地做到以下两点： 1.指针指向的内存空间的所有权必须明确当任务间通过指针共享内存时，应该从根本上保证所不会有任意两个任务同时修改共享内存中的数据，或是以其它行为方式使得共享内存数据无效或产生一致性问题。原则上，共享内存在其指针发送到队列之前，其内容只允许被发送任务访问；共享内存指针从队列中被读出之后，其内容亦只允许被接收任务访问。 2.指针指向的内存空间必须有效如果指针指向的内存空间是动态分配的，只应该有一个任务负责对其进行内存释放。当这段内存空间被释放之后，就不应该有任何一个任务再访问这段空间。 : [0 k$ k" j4 h$ E! ^并且最最最重要的是禁止使用指针访问任务栈上的空间，也就是局部变量。因为当栈发生改变后，栈上的数据将不再有效。 如需转载请说明出处" x# g1 ?1 N- e/ } 欢迎关注我个人微信公众号“创客飞梦空间” 0 K% K8 w( j a+ e& f |
STMCU-管管
回答时间：2019-3-18 14:54:33
| 支持支持 |
| 收藏 |
| 支持。 |
Reference Manual# K/ t4 T- I) [ K% O
