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

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

2 Q) ^, D6 N: b" l

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

: X: a" t/ }3 }% o6 e# d8 S! r

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

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

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

1. #define MAX_QUEUE_LEN  (4096) // 4K
   
2. #define RW_OK   0
   
3. #define FULL_ERROR    1
   , A) N/ M& ]/ B
4. #define EMPTY_ERROR   2
   
5. 
   
6. typedef uint8_t boolean;
     M6 ^( p  j& c. _7 s' w! n# U
7. 
   
8. typedef struct
   ' c2 R8 b0 A" ]: Q+ Z7 G+ r
9. {
   ( c5 S" f+ O1 C4 s1 ^
10.     u16 MemFrontSendIndex ;
    
11.     u16 MemRearRecvIndex ;
    ' v& W+ u( k( `3 g
12.     u16 MemLength ;
    
13.     u8  MemDataBuf[MAX_QUEUE_LEN];
    ! {/ q3 R% l9 ~5 ~
14. } Queue_Mem_Struct , * Queue_Mem_Struct_p ;
    " s" H; `  ~# S6 y, M
15. 
    
16. Queue_Mem_Struct Queue_Recv ;
    , a* Z% k' I) \) V# E* h
17. 
    
18. boolean QueueMemDataInsert(u8 data)
    ( ^+ ~4 i6 e# g- l: p! w1 y
19. {
    % J8 g" N# r: x; X' M- H5 q
20.     if (MAX_QUEUE_LEN == Queue_Recv.MemLength)
    
21.     {
    
22.         return FULL_ERROR;
    
23.     }
    
24.     else
    # b/ s8 B( D# T9 `' C2 D0 ]- v
25.     {
    6 U0 E! v5 B- r1 \2 j
26.         Queue_Recv.MemDataBuf[Queue_Recv.MemRearRecvIndex] = data ;
    
27.         //        if(++Queue_Recv.MemRearRecvIndex >= MAX_QUEUE_LEN){Queue_Recv.MemRearRecvIndex = 0;}
    
28.         Queue_Recv.MemRearRecvIndex = (Queue_Recv.MemRearRecvIndex + 1) % MAX_QUEUE_LEN;
      \0 n1 L5 B5 x1 X0 H9 u
29.         Queue_Recv.MemLength ++ ;
    
30.         return RW_OK;
    
31.     }
    $ N) @8 U  S$ {  u( q
32. }
    * z3 p  ~% g# _2 O2 S. y! {( X
33. 
    
34. boolean QueueMemDataDel(u8 *data)
    * [$ B6 Y9 V& t+ X
35. {
    ; `2 g1 k" j3 g
36.     if (0 == Queue_Recv.MemLength)
    . o! p7 Y' ^% l
37.     {
    ; i1 z6 S6 e# g  c, ~* t+ d9 m
38.         return EMPTY_ERROR;
    . F' V% k. i4 G8 K# C- v) w( [. q
39.     }
    1 ]0 A7 H6 a$ G. V
40.     else
    
41.     {
    7 M, c2 }( i7 |0 M- }2 }/ I3 v
42.         *data = Queue_Recv.MemDataBuf[Queue_Recv.MemFrontSendIndex]  ;
    % g: t0 ], a- d
43.         Queue_Recv.MemFrontSendIndex = (Queue_Recv.MemFrontSendIndex + 1) % MAX_QUEUE_LEN;
    6 }0 ~( T! v1 H) [/ t# D( {
44.         Queue_Recv.MemLength -- ;
    
45.         return RW_OK;
    8 u! `/ S6 m  _
46.     }
    
47. }

复制代码

; y! \  j# }5 ?$ b) z) F

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

% N/ y* F, P2 @- T' u0 ^

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

* s7 x5 H1 X7 J! v5 W( F

转载自：以太快跑

3 Z* b- A2 Y/ E