在单片机开发中，串口是最常用的和外界交换数据的渠道，要使用串口，那必不可少的就是通信协议，通信协议就是单片机和外界通信的语言，要想正常和其他设备正常交流，首先语言必须相通。

  在实际开发过程中由于各种原因，导致很多时候单片机和外界其他设备协议不兼容，在使用的时候就比较麻烦。比如单片机要和两个设备通信，但是这两个设备的通信协议的不一样，在使用时单片机就必须使用两个串口分别和两个设备通信。如果这两个设备同时使用时还不感觉到资源浪费，如果每次只接一个设备，那么另一个串口也不能作为其他功能使用，还得留着备用。这样的话单片机的资源就被白白浪费掉了。于是想着能不能在一个串口上支持两个协议，让单片机自动去识别接收到的数据使用的是哪个协议。

2 ?* O; N; G$ x! p# X" r  一般使用通信协议接收数据时，都需要通过判断数据头和数据尾来确定什么时候开始接收数据，什么时候停止接收数据。但是如果要兼容多个协议的话，就不能使用这个方式去接收数据。必须先将一组数据接收完毕，然后根据数据的特点去分析数据使用的是哪个协议。

& ~3 b; k2 G0 z* \% Y) `: _  首先要实现的就是如何判断一组数据是否接收完毕。
5 P5 T1 i2 y3 g# e
9 P1 j5 n$ A) Z  实现的大概思路就是，单片机使用中断去接收数据，同时记录接收到的数据长度，在主函数中循环的去读取串口接收到的字符长度，如果超过一定时间之后，串口中接收到的数据长度没有发生变化，就说明一组数据接收完毕了。
) F9 Z& O5 m' ]2 r. f! }: [6 G6 f/ n
  比如在主函数中读取到了当前串口数据长度不为0，说明此时串口正在接收数据，此时记录下当前串口数据长度，延时一段时间再去读取一次串口接收数据的长度，如果此时数据长度和上一次数据长度一样，说明串口接收数据结束了，就可以去处理接收到的数据了，如果此时数据长度和上一次的数据长度不一样，说明串口正在接收数据，接收数据还未结束，不能去处理数据。
8 T% y. l9 D2 Y; |* P0 Z8 E. v. m1 n
  下面就通过一个工程案例来演示一个串口兼容两种协议的使用方法。

  设备默认使用的是自定义协议，协议格式如下：
[ 头1 ] (0xA5) [ 头2 ] (0x5A) [ 地址 ] [ 命令 ] [ 数据高位 ] [ 数据低位 ] [ 尾1 ] (0x55) [尾2] (0xAA)
+ q0 z: k4 `+ Y. O# m9 u! @8 o
  后来设备需要和市场上其他的工业设备对接，而大多数工业设备使用的都是Modbus协议，如果直接将设备协议修改为Modbus协议的话，那么好多旧设备和新设备就会不兼容，为了兼容旧设备同时又要对接其他工业设备，那么设备要在自定义协议的基础上兼容Modbus协议。Modbus协议格式如下：

+ y3 T3 p7 `  {* e1 x; t[ 地址 ] [ 功能码 ] [ 起始地址高 ] [ 起始地址低] [ 总寄存器数高 ] [ 总寄存器数低 ] [ CRC低 ] [ CRC高 ]
/ y# u6 s1 ?+ D% L: N
  下面分析这两种协议的特点。

. W& b+ a  I0 p3 u& ~# U  首先看自定义协议，自定义协议的数据长度是固定的，同时数据的开始和结尾都是由两个字节标识。那么识别自定义协议就和容易了，直接判断数据头和数据为就行了。当串口接收一组数据结束后，判断接收到的数据 是不是以 0xA5和0X5A 开头，同时以 0x55 和0xAA结尾。如果是那么就使用自定义协议去解析数据。

: O; U6 E, B/ b2 H  接下来分析Modbus协议，由于设备都是单独使用的，不需要级联，所以设备的地址是固定的0x01，同时由于设备的功能比较简单，所以在使用Modubus协议的时候，只用到了读保持寄存器(0x03)和写保持寄存器(0x06)这两个功能，所以Modbus的数据开头只有两种情况 0x01 0x03 和 0x01 0x06，如果数据开头是这两种情况，那么就使用Modbus协议去解析数据。
  f' l# s6 b, b, I7 D2 p
  通过对协议的分析，思路已经很清晰了，接下来使用代码来实现。

4 ^- H+ L. V: \

1. struct uart_info
   
2. {
   
3.     u8 cnt;
   2 j) ?- n  d9 z# F  O! e
4.     u8 rec_buf[10];
   
5. };
   
6. 
   
7. struct uart_info uart1;
   
8. 
   : b( b4 N: Z. `  ^" K
9. //在Library Options中将Printf formatter改成Large
   
10. //重新定向putchar函数,使支持printf函数
    , _- B8 q' O( Q1 n) E
11. int putchar( int ch )
    
12. {
    - v  Y$ ^( G  k( s" J+ o  W; d
13.     while( !( UART1_SR & 0X80 ) ); //循环发送,直到发送完毕
    
14.     UART1_DR = ( u8 ) ch;
    ( U9 r" T' l, w
15.     return ch;
    
16. }
    
17. static void uart_io_init( void )
    . [% E1 D- c' O& b  ?, Z
18. {
    , c% Q+ L3 Q( d7 d9 @/ c7 Q
19.     PD_DDR |= ( 1 << 5 ); //输出模式 TXD
    8 E. \- {7 ~! \
20.     PD_CR1 |= ( 1 << 5 ); //推挽输出
    
21.     PD_DDR &= ~( 1 << 6 ); //输入模式 RXD
    
22.     PD_CR1 &= ~( 1 << 6 ); //浮空输入
    ; e( c, @# T7 e- R- x
23. }
    
24. //波特率最大可以设置为38400
    
25. void uart_init( unsigned int baudrate )
    
26. {
    
27.     unsigned int baud;
    
28. 
    6 |$ `5 c* Q' V& Z
29.     uart_io_init();
    
30. 
    % A8 d9 i8 |/ _1 q0 e/ F0 o/ S
31.     baud = 16000000 / baudrate;
    
32.     UART1_CR1 = 0;
    
33.     UART1_CR2 = 0;
    % B' B: ?1 P% a3 h
34.     UART1_CR3 = 0;
    2 c  [* {3 E6 I
35.     UART1_BRR2 = ( unsigned char )( ( baud & 0xf000 ) >> 8 ) | ( ( unsigned char )( baud & 0x000f ) );
    3 B1 Y" y7 ~8 U
36.     UART1_BRR1 = ( ( unsigned char )( ( baud & 0x0ff0 ) >> 4 ) );
      T1 y6 y* W8 o- q3 i5 Q
37.     UART1_CR2_bit.REN = 1;        //接收使能
    : J: W- K3 m4 I1 n7 p3 P! a
38.     UART1_CR2_bit.TEN = 1;        //发送使能
    
39.     UART1_CR2_bit.RIEN = 1;       //接收中断使能
    
40. }
    
41. 
    - \4 A+ J  H+ R/ A2 N1 {3 O! h
42. 
    9 `; Q, @$ G* x% S9 S
43. //接收中断函数 中断号18
    
44. #pragma vector = 20                             // IAR中的中断号，要在STVD中的中断号上加2
    
45. __interrupt void UART1_Handle( void )
    
46. {
    2 Z! I: }0 o$ m7 ]  e
47.     unsigned char res = 0;
    , z- [) P: T6 `
48.     UART1_SR &= ~( 1 << 5 );                    //RXNE 清零
    
49. 
    
50.     res = UART1_DR;
    ! e( F' n. A, O! e7 r# }5 S3 L7 M) z( B
51.     if( uart1.cnt < 9 )
    
52.         uart1.rec_buf[uart1.cnt++] = res;
    1 E4 ?) w, Q7 M( ^: b- }
53. }

复制代码

  定义一个结构体来存储接收到的数据长度和数据，由于自定义协议和Modbus协议最长的数据只有8个字节，所以这里的数组长度设置10就可以了。下面初始化串口使用的IO口，设置数据位和波特率。最后在中断中接收数据并存储到数组中。
$ J" Y6 R& ?) }4 p0 U* q8 b
  接下来在编写一个函数用来分析接收到的数据。

: h) B3 O; E. u# H! O1 U

1. //检测串口数据
   5 B! ^+ K9 C4 g  O; V! `( R
2. void read_uart( void )
   1 D8 Q# b. h. ?2 z  y( t& w
3. {
   
4.     static u8 recevie_buf[10];
   
5.     static u8 recevie_cnt = 0;
   / Y$ c4 B8 X  _" ^) F  I) p# a
6.     u8 i = 0;
   
7. 
   
8.     delay_ms( 10 ); //隔一段时间检测一次串口数据长度，如果数据长度没有发生变化说明串口接收数据完成
   
9. 
   
10.     if( ( uart1.cnt != recevie_cnt ) && ( uart1.cnt > 6 ) )
    6 D5 T' E9 P5 }, A( y
11.     {
    9 i+ O' J, l  j8 ]6 M
12.         recevie_cnt = uart1.cnt;
    % `9 ^( ?- Y( B6 @! q# z
13.         for( i = 0; i < recevie_cnt; i++ )            //拷贝数据
    
14.         {
    
15.             recevie_buf<i> = uart1.rec_buf<i>;
    
16.         }
    4 J" c5 m) _" Z- |
17.         //根据接收到的数据区分协议
    
18.         //自定义协议
    & m$ N! A& o/ W- ]3 m
19.         if( ( recevie_buf[0] == 0xA5 ) && ( recevie_buf[1] == 0x5A ) )
    
20.         {
    
21.             self_define_protocol( recevie_buf, recevie_cnt );
    
22.         }
    
23.         //modbus协议
    
24.         if( ( recevie_buf[0] == 0x01 ) && ( ( recevie_buf[1] == 0x03 ) || ( recevie_buf[1] == 0x06 ) ) )
    
25.         {
    , {& U: b4 _& m1 ?
26.             modbus_protocol( recevie_buf, recevie_cnt );
    - Z2 @& G$ j0 Z
27.         }
    1 k& h  W8 v2 Z) T! \5 C
28. 
    
29.         //清空数组
    ' O* {2 p* V2 y" S& l4 r1 u, h
30.         for( i = 0; i < 10; i++ )
    
31.         {
    
32.             uart1.rec_buf<i> = 0;
    
33.             recevie_buf<i> = 0;
    5 h  {4 k8 m- f( \
34.         }
    * w# M( w- @, [0 I/ s, z
35.         uart1.cnt = recevie_cnt  = 0;
    
36.     }
    ! ^/ B; }- l- [* \6 _
37. }</i></i></i></i>

复制代码

/ P# i- ~- h$ t" V: H: _$ N
8 |: b1 J$ Q1 ]' R$ r" W: L  ]: \, x' u  由于此设备中两种协议的数据长度都比较小，所以这里并没有分两次去判断数据长度，然后根据数据长度来判断数据接收是否完毕。只是延时10ms之后去判断数据长度，当接收的数据长度大于6时，说明数据基本已经接收完成了。由于数据的最大长度是8，所以接收的数据长度大于6时，基本数据已经接收完了，在中断中接收8个数据速度还是非常快的。如果数据量比较大，数据比较长时，最好还是通过数据长度去判断比较可靠。这里为了编写方便，就简单的时候延时去判断了。
/ o$ h5 |, M1 c( L9 q" b
7 d9 M' R2 h" G1 S# f2 k7 h/ t  当串口接收的数据长度大于6时，说明一组数据已经接收完毕了，此时需要将串口接收的数据拷贝一份出来在使用。那为什么要将数据拷贝出来，而不是直接使用串口接收缓存区的数据呢？这是为了防止在处理数据的过程中国，串口又接收到了新的数据，这样新数据就会将旧的数据覆盖掉，有可能导致数据异常。为了数据的安全性将数据拷贝一份使用，即使在处理数据过程中串口缓存区的数据发生了变化，也不会破坏掉上一次接收的数据。

# r. W4 F  p7 t* I  i  数据拷贝结束后，就根据数据的特点来判断当前接收到的数据使用的是哪种协议。如果接收到的数据前两个是 0xA5和0x5A那么就直接调用自定义协议处理函数，如果前面的数据是0x01和0x03或者是0x01和0x06那么就直接调用Modbus协议去处理函数。

, h$ w8 l* Z3 t' D7 ~" M; [6 z  接下来就可以单独编写两个函数分别处理这这种协议。
! |' Z  B& M8 q3 V, I! d6 N" g
4 J2 w- o& s) y8 _5 r- R

1. //处理自定义协议
   9 ~2 U' ]! [3 }" |7 ?' F
2. // [头1](0xA5) [头2](0x5A) [地址]  [命令]  [数据高位] [数据低位]  [尾1](0x55) [尾2](0xAA)
   
3. //A5 5A 00 01 01 90 55 AA
   
4. void self_define_protocol( u8 arr[], u8 size )
   
5. {
   8 q- F/ [/ b  G* n8 L/ b
6. 
   $ A* y7 ?, H% h' R( D5 T
7.     if( ( arr[0] == 0xA5 ) && ( arr[1] == 0x5A ) && ( arr[6] == 0x55 ) && ( arr[7] == 0xAA ) )
   
8.     {
   
9.                 //根据命令值执行不同的动作
   
10.     }
    $ M1 E2 S7 [6 Y4 Y
11. }
    
12. 
    
13. //处理modbus协议
    
14. //[地址][功能码][起始地址高][起始地址低][总寄存器数高][总寄存器数低][CRC低][CRC高]
    
15. //01 03 00 00 00 01 84 0A
    
16. //01 06 00 00 03 E8 89 74
    
17. void modbus_protocol( u8 arr[], u8 size )
    ) H3 p; R0 B  b- @  W" J
18. {
    ) T) q/ @- p% Z  z
19.     //调用 modbus相关处理代码
    4 y4 R% D1 T0 H9 Q& g5 y; n
20. }

复制代码

  将数据协议识别出来之后，就可以按照通常处理协议的方式去处理数据了。最后在主函数中循环的调用数据查询函数，检查串口是否有接收到数据。
/ k. g  x3 c8 a5 _2 e" I

1. void main( void )
   2 X- |' ?) b& I9 R( D
2. {
   5 q! Q: ?4 D: d
3. 
   , \( V! f5 \3 C$ H
4.     __asm( "sim" );                             //禁止中断
   
5.     SysClkInit();
   
6.     delay_init( 16 );
   
7.     LED_GPIO_Init();
   / A5 A+ s* v$ s, A/ s# H
8.     uart_init( 9600 );
   ; ]0 w0 l4 }) ?
9.     __asm( "rim" );                             //开启中断
   
10.     while( 1 )
    ( e- `/ j. l" G' D
11.     {
    
12.         read_uart();
    6 q4 i$ ?3 C; ?1 |
13.     }
    
14. }

复制代码

; c( e2 I6 k- J9 D' S  接下来分别用这两种协议测试代码。


  使用串口助手发送自定义协议时，代码就会调用自定义协议处理函数。

8 I8 i* j+ \( r- n# `8 q. `
5 w9 q1 p1 z0 r- {
  发送Modbus协议时，代码就会调用Modbus协议处理函数。

. V% ~. B- P- V( q8 B  这样根据协议的特点可以通过代码自动去识别协议的类型，用一个串口就可以实现不同协议的解析。按照同样的方法还可以解析更多的协议。当前在不同的协议使用的波特率要相同，否则波特率不同解析出来的数据就会出现错误，导致协议解析失败。



$ S8 P/ p! b+ L! f/ t- W