概述

串口通信是目前单片机和DSP等嵌入式系统之间，以及嵌入式系统与 PC 机或无线模块之间的一种非常重要且普遍使用的通信方式。在嵌入式系统的硬件结构中，通常只有一个8位或16位的CPU，不仅要完成主流程的工作，同时还要处理随时发生的各种中断，因而嵌入式系统中的串口通信程序设计与PC机有很大的不同。若嵌入式系统中的中断服务子程序在系统运行过程中占用了较多的时间，就有可能在中断服务子程序正运行时，又产生一个同类型或其它类型的中断，从而造成主程序得不到执行或后续中断数据丢失等问题。所以嵌入式系统中的串口通信虽然看似简单，但其中仍有许多问题值得研究，例如串口通信过程中的帧同步问题。

串口通信的数据帧结构

现在的单片机系统中，往往需要由多个独立的控制模块来共同完成功能。不同模块之间可以通过串口，RS232，SPI等不同的通信接口来进行通信，在通信过程中我们可以加入一些通信协议，以提高系统的可靠性和稳定性；而要完成特定的通信协议，就得有一定的同步机制。下面介绍一下简化的通信数据帧结构，以便分析说明嵌入式系统通信过程中的帧同步方法。

假定串口发送的数据帧结构为：
image.png
其中：“帧头”用于同步，一般是一个或多个字节，本文中假定数据帧同步头有2字节(0xFE、0xEF)；“帧长度”表示数据包中除去“帧头”和“帧长度”的字节数，即“帧类型”、“帧数据”和“校验”的总长度；“帧类型”为通信协议里规定的命令类型；“帧数据”为应发送的主要信息；“校验”可以采用简单的单字节“异或”的方法，复杂点的可以采用“CRC校验”。

基于有限状态机的帧同步方法

下面我们就来说说“基于有限状态机的帧同步方法”，该方法是将数据帧的接收过程分为若干个状态：“接收帧头HEAD1状态”、“接收帧头HEAD2状态”、“接收帧长度状态”、“接收帧类型状态”、“接收数据状态”及“接收校验和状态”。系统的初始状态为“接收帧头HEAD1状态”，各接收状态间的状态转移图如下图所示。随着串口接收中断新数据的接收，系统的接收状态依次为 HEAD1→HEAD2→LEN→TYPE→DATA→CHECK。该方法也快速、有效地实现了同步；但是需要注意的是，在每一次接收完1帧完整的数据之后，必须把系统的接收状态重新设置为HEAD1，否则将会影响下一帧的数据接收。
自定义通信协议设计基础 - 图2
此后，程序按照协议开始依次接收数据帧长度、命令类型、数据和校验位。接收完后，重新设置系统接收状态为HEAD1，同时对该数据帧进行校验。校验正确后，利用消息机制通知主程序根据命令类型对数据帧进行处理或执行相应的命令操作。

下面给出该方法在CC2530裸机中的实例程序：

  1. #include "iocc2530.h"
  3. #define TRUE    1
  4. #define FALSE   0
  5. // 状态机状态
  6. #define HEAD1   0x00
  7. #define HEAD2    0x01
  8. #define LEN     0x02
  9. #define TYPE    0x03
  10. #define DATA    0x04
  11. #define CHECK    0x05
  12. // 命令
  13. #define COMMAND1 0x01
  14. #define COMMAND2 0x02
  16. // 状态机用到的全局变量
  17. unsigned char g_datrev[48];                // 串口数据缓存
  18. unsigned char g_cmd;                    // 接收的命令
  19. unsigned char g_recok;                    // 串口事件标志位
  20. unsigned char g_recstate = HEAD1;       // 接收状态
  21. unsigned char g_len = 0;                // 已接收的数据长度
  22. unsigned char g_check_sum = 0;          // 校验和
  23. unsigned char g_lentotal = 0;           // 包长
  25. void main(void)
  26. {
  27.   // 初始化程序
  30.   // 任务轮询
  31.   while(1)
  32.   {
  33.     // 有新的事件发生
  34.     if(g_recok==TRUE)
  35.     {
  36.       // 清除串口事件标志位
  37.       g_recok = FALSE;
  38.       // 处理命令
  39.       switch(g_cmd)
  40.       {
  41.         case COMMAND1:
  42.           {
  43.             // 处理命令1
  45.           }
  46.           break;
  48.         case COMMAND2:
  49.           {
  50.             // 处理命令2
  52.           }
  53.           break;
  55.         default:
  56.           break;
  57.       }
  58.     }
  59.   }
  60. }
  62. // 串口0中断处理函数
  63. #pragma vector = URX0_VECTOR
  64. __interrupt void UART0_ISR(void)
  65. {
  66.   // 接收串口数据
  67.   unsigned char recdata = 0;
  68.   // 清中断标志
  69.   URX0IF = 0;
  71.   // 接收串口0数据
  72.   recdata = U0DBUF;
  73.   // 进入接收状态机
  74.   switch(g_recstate)
  75.   {
  76.     case HEAD1:
  77.     {
  78.       // 如果接收到HEAD1的值0xFE,则进入状态HEAD2
  79.       if(recdata==0xFE)
  80.       {
  81.         g_recstate = HEAD2;
  82.       }
  83.     }
  84.     break;
  86.     case HEAD2:
  87.     {
  88.       // 如果接收到HEAD2的值0xEF,则进入状态LEN接收帧数据长度
  89.       if(recdata==0xEF)
  90.       {
  91.         g_recstate = LEN;
  92.       }
  93.       // 如果接收到的还是HEAD1的数据0xFE,则不跳转，等待下一个数据
  94.       else if(recdata==0xFE)
  95.       {
  96.         g_recstate = HEAD2;
  97.       }
  98.       // 如果没有接收到HEAD1或HEAD2的数据则返回HEAD1状态重新再来
  99.       else
  100.       {
  101.         g_recstate = HEAD1;
  102.       }
  103.     }
  104.     break;
  106.     case LEN:
  107.     {
  108.       // 将状态机指向下一个状态“TYPE”
  109.       g_recstate = TYPE;
  110.       // 接收帧数据长度
  111.       g_lentotal = recdata;
  112.       // 异或校验，先校验“HEAD1”和“HEAD2”
  113.       g_check_sum = 0xFE^0xEF;
  114.     }
  115.     break;
  117.     case TYPE:
  118.     {
  119.       // 将状态机指向下一个状态“DATA”
  120.       g_recstate = DATA;
  121.       // 接收帧命令数据
  122.       g_cmd = recdata;
  123.       // 校验命令数据
  124.       g_check_sum = g_check_sum ^ recdata;
  125.       // 将下一状态要用的“g_len”先清零
  126.       g_len = 0;
  127.     }
  128.     break;
  130.     case DATA:
  131.     {
  132.       // 将接收到的帧数据存储在数据缓存数组中
  133.       g_datrev[g_len] = recdata;
  134.       // 校验帧数据
  135.       g_check_sum = g_check_sum ^ recdata;
  136.       // 记录接收了多少字节数据
  137.       g_len++;
  138.       // 接收总帧长度的数据后转向“CHECK”状态校验整个帧是否正确
  139.       if(g_len>=g_lentotal)
  140.       {
  141.         g_recstate = CHECK;
  142.       }
  143.     }
  144.     break;
  146.     case CHECK:
  147.     {
  148.       // 检测接收到的帧数据是否正确，正确则通知主函数有新的事件；错误则抛弃此帧，重置状态机
  149.       if(g_check_sum==recdata)
  150.       {
  151.         g_recok = TRUE;
  152.       }
  153.       g_recstate = HEAD1;
  154.     }
  155.     break;
  157.     default:
  158.     {
  159.       g_recstate = HEAD1;
  160.     }
  161.     break;
  162.   }
  163. }

由于采用了状态机和消息机制的结构，上述设计思路快速有效地实现了串口通信的同步，而且程序结构清晰，便于维护，也易于向其他的串口通信协议移植。另外，串口中断服务子程序中需要处理的工作很少，大大减轻了串口接收中断服务程序的压力，缓解了嵌入式系统有限资源与需求之问的矛盾，提高了嵌入式系统的稳定性。

qrcode_for_gh_e95b474fcf08_344.jpg