这段时间一直在研究多旋翼飞行器，以及其它的事情，博客好外没更新，再不坚持怕真荒废了哦。
7 Y& i1 Y7 k* F! @

在上篇简单实现 MAVLink 协议的解析，并演示按照设计好的命令执行对应的事件处理，以及又加入 CRC 校验，实现更稳定的通信，但在上文结束时也提到当对一个包进行解析及对应事件处理时，是不能接收新的数据，直到事件处理完成，Msg_Rev.Get 状态设置为 RECEIVING 后方能再接收新的数据。这时，当事件处理需要一定时间，而又有新的数据不断发送过来时，很容易造成数据丢失现象。

如何提高串口通信效率，并避免丢包现象了？

为提高效率，首先想到采用 DMA 方式，然而考虑下发现，接收的数据包是不固定的；并且即使采用 DMA，若 MAVLink 接收缓存仍设计成只接收一条消息大小，丢包问题仍然还是会有滴。

这样就想有没方法软件来实现，就相到如果开辟一个缓存空间，不断接收的数据都放到那儿，而包的解析处理函数可从这里面依次取出一定数据，来作处理。这样只要设计比较合理，因软件阻塞造成的丢包现象就容易解决了。那么要设计一个怎样的缓存呢 ？ 其实很容易想到队列（先进先出的特性），而为了更有效且合理的利用空间，又就会想到环形队列这种数据结构 。
+ X* O2 W' q6 k8 V5 Z4 L2 Q! M3 m

首先是其数据结构设计，以及插入删除操作，不多说，如下代码：

1. #define MAX_QUEUE_LEN  (4096) // 4K
   
2. #define RW_OK   0
   
3. #define FULL_ERROR    1
   
4. #define EMPTY_ERROR   2
   
5. 
   
6. typedef uint8_t boolean;
   
7. 
   8 U/ F! c+ c) h* e* P) u' \5 B
8. typedef struct
   
9. {
   
10.     u16 MemFrontSendIndex ;
    * _0 d8 c! ~* Y* K
11.     u16 MemRearRecvIndex ;
    7 V* u$ b& S1 ~7 l' L$ G$ r% i0 y$ O
12.     u16 MemLength ;
    
13.     u8  MemDataBuf[MAX_QUEUE_LEN];
    
14. } Queue_Mem_Struct , * Queue_Mem_Struct_p ;
    " m/ T9 e8 _3 m% K  W8 A
15. 
    * b! x, M  V$ H9 m5 ^
16. Queue_Mem_Struct Queue_Recv ;
    8 }5 g5 t: b! W
17. 
    $ `+ l0 T; r0 y
18. boolean QueueMemDataInsert(u8 data)
    
19. {
    
20.     if (MAX_QUEUE_LEN == Queue_Recv.MemLength)
    
21.     {
    
22.         return FULL_ERROR;
    
23.     }
    . ~+ C- u( G3 C7 D
24.     else
    * a% O& v6 D5 Q" G
25.     {
    
26.         Queue_Recv.MemDataBuf[Queue_Recv.MemRearRecvIndex] = data ;
    . E9 `6 e( V& t9 S7 {" F- G: X8 h7 q
27.         //        if(++Queue_Recv.MemRearRecvIndex >= MAX_QUEUE_LEN){Queue_Recv.MemRearRecvIndex = 0;}
    : L: t# Y4 C  K& R6 [
28.         Queue_Recv.MemRearRecvIndex = (Queue_Recv.MemRearRecvIndex + 1) % MAX_QUEUE_LEN;
    , F9 f& K7 x; _7 ^+ B
29.         Queue_Recv.MemLength ++ ;
    
30.         return RW_OK;
    , n; [! ~. q% a5 \
31.     }
    # h$ Z4 b2 M9 S% e; w8 e
32. }
    # K2 r' Q2 d" f! c$ c. F  G# D
33. 
    1 X9 m( {" T) u- F9 h- X
34. boolean QueueMemDataDel(u8 *data)
    + i( c3 a5 v' A( L! C3 _2 F2 \
35. {
    8 T/ w* O# E* ]) s: c4 ~0 y
36.     if (0 == Queue_Recv.MemLength)
    9 u. H6 ~' d7 H- D' b7 R
37.     {
    
38.         return EMPTY_ERROR;
    3 p: A' A  w' ?8 q
39.     }
    
40.     else
    ) c& }& m& i0 j/ ~% n! D" h
41.     {
    
42.         *data = Queue_Recv.MemDataBuf[Queue_Recv.MemFrontSendIndex]  ;
    2 B( m3 C7 G  u0 {5 [" T: K
43.         Queue_Recv.MemFrontSendIndex = (Queue_Recv.MemFrontSendIndex + 1) % MAX_QUEUE_LEN;
    
44.         Queue_Recv.MemLength -- ;
    
45.         return RW_OK;
    : R9 z$ x; C( ]$ G
46.     }
    5 R+ }* Y! c& c+ h: L
47. }

复制代码

这样，只需通过 QueueMemDataInsert 函数把串口接收的数据依次填充到缓冲区 Queue_Recv.MemDataBuf 中去。而在处理时调用 QueueMemDataDel 函数取出对应个数的数据来处理。这样就避免整个处理过程中无法同时接收数据而产生丢包的问题。当然此时要保证缓冲区的数据及时处理完，否则，尤其当数据量很大时队列填充满后，又会造成数据无法再填充进来。

另外至此又会发现，如上设计可结合采用 DMA 方式。设计的好的话，可以进一步大幅度提升 STM32 利用率及系统运行效率！

8 ^" U* a2 g1 I/ G

转载自：以太快跑