使用FreeRTOS消息缓冲区，实现简单的非对称多处理（AMP）核心到核心通信（STM32H7 双核处理器）。

一、概述

实现STM32H7双核之间通信是FreeRTOS官方提供的一个方案，是基于FreeRTOS消息缓冲区，该消息缓冲区是无锁循环缓冲区，可以将大小不同的数据包从单个发送方传递到单个接收方。

说明，该消息缓冲区仅提供数据的传输，不提供通信相关协议处理。

二、基本原理

实现双核之间通信基本原理：发送和接收任务位于非对称多处理器（AMP）配置中的多核微控制器（MCU）的不同内核上，这意味着每个内核都运行自己的FreeRTOS程序。

同时，一个内核在另一个内核中具有生成中断的能力，以及两个内核都有访问的内存区域（共享内存）。消息缓冲区以每个内核上运行在应用程序已知的地址置在共享内存中，如下图：

理想情况下，还将有一个内存保护单元（MPU），以确保只能通过内核的消息缓冲区API来访问消息缓冲区，并最好将共享内存标记为不可被其他程序占用。

三、单消息代码描述

这里官方提供了实现该方案的基础代码（仅供参考）。

将数据发送到流缓冲区的代码：

1. xMessageBufferSend()
   
2. {
   $ r# J9 n  g* G7 b
3.     /* If a time out is specified and there isn't enough
   
4.     space in the message buffer to send the data, then
   / k/ n* A$ [/ F0 r
5.     enter the blocked state to wait for more space. */
   
6.     if( time out != 0 )
   / H" j5 N7 Z5 ~3 B0 I6 d4 i
7.     {
   ' d8 s8 }( U' l0 D
8.         while( there is insufficient space in the buffer &&
   / i; b" a5 @8 ?. V
9.                not timed out waiting )
   5 I8 w6 ]1 S9 L2 j- ]: Y
10.         {
    0 O! x- g$ m  j5 ?
11.             Enter the blocked state to wait for space in the buffer
    
12.         }
    
13.     }
    ) Y/ \" [6 H+ N. p# }+ T3 k! c
14. 
    # ^! F$ z, }2 E5 ?: h

复制代码

1. if( there is enough space in the buffer )
   
2. {
   
3. write data to buffer
   
4. sbSEND_COMPLETED()
   
5. }
   - K4 X6 ^- \) S& ^" L8 [/ y; _
6. }

复制代码

5 u2 B2 n. U7 g$ k& @, P, q3 J* a

从流缓冲区读取数据的代码：​​​​​​​

1. xMessageBufferReceive()
   ; n5 b1 e: G# C
2. {
   
3.     /* If a time out is specified and the buffer doesn't
   1 O+ v* i) T! K7 L6 D) |$ Y
4.     contain any data that can be read, then enter the
   ( N; g! r: a- Z- R0 o1 p8 I- I
5.     blocked state to wait for the buffer to contain data. */
   
6.     if( time out != 0 )
   - I4 }! B1 [7 |7 a; F# I! b
7.     {
   $ Z" D: P. P1 ~! \0 _% b
8.         while( there is no data in the buffer &&
   ) V  H- w3 O% V4 l4 {2 P' @- l) x; }
9.                not timed out waiting )
   
10.         {
    0 {& ]: z. C2 o, v% }1 C
11.             Enter the blocked state to wait for data
    
12.         }
    ' b' r& l5 r: \' w
13.     }
    + d& F* V) L% j5 o. e3 w
14. 
    % n) O" g" q( }% g8 `. I

复制代码

1. if( there is data in the buffer )
   
2. {
   
3. read data from buffer
   3 O/ v& ]  |# ?/ S- Y& N
4. sbRECEIVE_COMPLETED()
   
5. }
   ( d6 A) C1 @! s6 I4 n8 v6 \6 P
6. }

复制代码

; h6 W8 n" a6 x7 G& d7 M

如果任务在xMessageBufferReceive()中进入阻塞状态以等待缓冲区包含数据，则将数据发送到缓冲区必须取消阻塞该任务，以便它可以完成其操作。

当xMessageBufferSend()调用sbSEND_COMPLETED()时，任务将不受阻碍。

6 V5 L/ i$ n) ?; s

ISR通过将消息缓冲区的句柄作为参数传递给xMessageBufferSendCompletedFromISR()函数来解除对任务的阻塞。

2 s. r- L& ^# J( r( Y  e

如图箭头所示，其中发送和接收任务位于不同的MCU内核上：

1.接收任务尝试从空的消息缓冲区中读取数据，并进入阻止状态以等待数据到达。

2.发送任务将数据写入消息缓冲区。

3.sbSEND_COMPLETED（）在正在执行接收任务的内核中触发一个中断。

4.中断服务例程调用xMessageBufferSendCompletedFromISR()来解除阻止接收任务，该任务现在可以从缓冲区读取，因为缓冲区不再为空。

" Q5 g% s1 X( [8 Y

四、多消息代码描述

当只有一个消息缓冲区时，很容易将消息缓冲区的句柄传递到xMessageBufferSendCompletedFromISR()中。

- {- z7 m1 d4 _4 s

但是要考虑有两个或更多消息缓冲区的情况，ISR必须首先确定哪个消息缓冲区包含数据。如果消息缓冲区的数量很少，则有几种方法可以实现：

• 如果硬件允许，则每个消息缓冲区可以使用不同的中断线，从而使中断服务程序和消息缓冲区之间保持一对一的映射。

• 中断服务例程可以简单地查询每个消息缓冲区以查看其是否包含数据。

• 可以通过传递元数据（消息是什么，消息的预期接收者是什么等等）以及实际数据的单个消息缓冲区来代替多个消息缓冲区。

  
  
  . r1 k" W1 O- \4 @8 X3 ^( N5 A

但是，如果存在大量或未知的消息缓冲区，则这些技术效率不高。

在这种情况下，可伸缩的解决方案是引入单独的控制消息缓冲区。如下面的代码所示，sbSEND_COMPLETED()使用控制消息缓冲区将包含数据的消息缓冲区的句柄传递到中断服务例程中。

1 U9 X' r& H8 v. g9 y; D  h, L

使用sbSEND_COMPLETED()的实现：​​​​​​​

1. /* Added to FreeRTOSConfig.h to override the default implementation. */
   
2. #define sbSEND_COMPLETED( pxStreamBuffer ) vGenerateCoreToCoreInterrupt( pxStreamBuffer )
   ( N( c; x* G7 n( ?: q& C2 U

复制代码

1. /* Implemented in a C file. */
   
2. void vGenerateCoreToCoreInterrupt( MessageBufferHandle_t xUpdatedBuffer )
   
3. {
   + ^: K- A9 l% x  q6 F4 }6 F8 [; Z( u
4. size_t BytesWritten.
   

复制代码

1. /* Called by the implementation of sbSEND_COMPLETED() in FreeRTOSConfig.h.
   0 J* F9 u: N. ~% Q7 J6 \
2. If this function was called because data was written to any message buffer
   - F+ T: I! v! _0 Z; D- g  r( V
3. other than the control message buffer then write the handle of the message
   
4. buffer that contains data to the control message buffer, then raise an
   
5. interrupt in the other core. If this function was called because data was
   
6. written to the control message buffer then do nothing. */
   : j' _$ _' p8 G
7. if( xUpdatedBuffer != xControlMessageBuffer )
   3 W; y( A3 H6 X
8. {
   4 X6 m6 q& X) s! |- q. W
9.     BytesWritten = xMessageBufferSend( xControlMessageBuffer,
   5 [  Z7 x' {% D7 j. e
10.                                                          &xUpdatedBuffer,
    ( H. q. |0 h8 s" m
11.                                                          sizeof( xUpdatedBuffer ),
    8 L- G! q, ]3 N3 f) v
12.                                                           0 );
    7 k" F2 b) i8 L9 f4 ~

复制代码

1. /* If the bytes could not be written then the control message buffer
   
2. is too small! */
   
3. configASSERT( BytesWritten == sizeof( xUpdatedBuffer );
     |+ z6 N. a7 @3 H9 @' O

复制代码

1. /* Generate interrupt in the other core (pseudocode). */
   ; x4 j' {2 O# @6 s# W+ m" E8 z
2. GenerateInterrupt();
   
3. }
   
4. }

复制代码

然后，ISR读取控制消息缓冲区以获得句柄，将句柄作为参数传递到xMessageBufferSendCompletedFromISR()中：​​​​​​​

1. void InterruptServiceRoutine( void )
   
2. {
   
3. MessageBufferHandle_t xUpdatedMessageBuffer;
   
4. BaseType_t xHigherPriorityTaskWoken = pdFALSE;
   3 o6 e* W: s2 \6 ~0 v; `9 X

复制代码

1. /* Receive the handle of the message buffer that contains data from the
   
2. control message buffer. Ensure to drain the buffer before returning. */
   
3. while( xMessageBufferReceiveFromISR( xControlMessageBuffer,
   $ x3 z: |2 T; k
4. &xUpdatedMessageBuffer,
   
5. sizeof( xUpdatedMessageBuffer ),
   ) T' l: W8 O2 @2 H0 e
6. &xHigherPriorityTaskWoken )
   $ j: o9 y1 X+ D
7. == sizeof( xUpdatedMessageBuffer ) )
   
8. {
   4 T6 @/ [% \9 k4 s
9. /* Call the API function that sends a notification to any task that is
   / o. j% X! d/ Q9 s; S3 X
10. blocked on the xUpdatedMessageBuffer message buffer waiting for data to
    / j+ A  h0 a4 r) A; r7 n  q+ |: B
11. arrive. */
    2 {7 P# R" l( p' i& L
12. xMessageBufferSendCompletedFromISR( xUpdatedMessageBuffer,
    2 m8 @, S% H" I& K7 Z2 X! U
13. &xHigherPriorityTaskWoken );
    & M. {( y' E* }) l; V& A& t  b
14. }
    7 E% N  e$ j. R

复制代码

1. /* Normal FreeRTOS "yield from interrupt" semantics, where
   ) ~8 u2 n$ Y3 d9 t& |5 X
2. xHigherPriorityTaskWoken is initialised to pdFALSE and will then get set to
   
3. pdTRUE if the interrupt unblocks a task that has a priority above that of
   
4. the currently executing task. */
   
5. portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
   % o  O7 f+ m6 N: c/ Y4 y3 a
6. }

复制代码

. s) ~- [8 b$ y0 c/ Q
0 G0 J6 L" Y3 h5 S! U" P, ~1 P2 ~

如图，使用控制消息缓冲区时的顺序：

1.接收任务尝试从空的消息缓冲区中读取数据，并进入阻止状态以等待数据到达。

2.发送任务将数据写入消息缓冲区。

3.sbSEND_COMPLETED()将现在包含数据的消息缓冲区的句柄发送到控制消息缓冲区。

4.sbSEND_COMPLETED()在正在执行接收任务的内核中触发一个中断。

5.中断服务例程从控制消息缓冲区中读取包含数据的消息缓冲区的句柄，然后将该句柄传递给xMessageBufferSendCompletedFromISR（）API函数以取消阻止接收任务，该任务现在可以从缓冲区读取，因为缓冲区不再存在空的。

$ S" K7 E. |$ v7 k1 A* l

当然，以上仅提供基础原理和方法，具体实现需结合项目实际情况。更多相关内容，请参看官方信息。

好好学习