（一）uart通信：基于51实现

一、原理简介

　　51 单片机内部有一个全双工串行接口。什么叫全双工串口呢？一般来说，只能接受或只能发送的称为单工串行；既可接收又可发送，但不能同时进行的称为半双工；能同时接收和发送的串行口称为全双工串行口。串行通信是指数据一位一位地按顺序传送的通信方式，其突出优点是只需一根传输线，可大大降低硬件成本，适合远距离通信。其缺点是传输速度较低。

　　与之前一样，首先我们来了解单片机串口相关的寄存器。

　　SBUF 寄存器：它是两个在物理上独立的接收、发送缓冲器，可同时发送、接收数据，可通过指令对SBUF 的读写来区别是对接收缓冲器的操作还是对发送缓冲器的操作。从而控制外部两条独立的收发信号线RXD（P3.0）、TXD（P3.1），同时发送、接收数据，实现全双工。

　　串行口控制寄存器SCON（见表1）。

表1 SCON寄存器

　　表中各位（从左至右为从高位到低位）含义如下。

　　SM0 和SM1 ：串行口工作方式控制位，其定义如表2 所示。

表2 串行口工作方式控制位

　　其中，fOSC 为单片机的时钟频率；波特率指串行口每秒钟发送（或接收）的位数。

　　SM2 ：多机通信控制位。该仅用于方式2 和方式3 的多机通信。其中发送机SM2 ＝ 1（需要程序控制设置）。接收机的串行口工作于方式2 或3，SM2=1 时，只有当接收到第9 位数据（RB8）为1 时，才把接收到的前8 位数据送入SBUF，且置位RI 发出中断申请引发串行接收中断，否则会将接受到的数据放弃。当SM2=0 时，就不管第位数据是0 还是1，都将数据送入SBUF，并置位RI 发出中断申请。工作于方式0 时，SM2 必须为0。

　　REN ：串行接收允许位：REN =0 时，禁止接收；REN =1 时，允许接收。

　　TB8 ：在方式2、3 中，TB8 是发送机要发送的第9 位数据。在多机通信中它代表传输的地址或数据，TB8=0 为数据，TB8=1 时为地址。

　　RB8 ：在方式2、3 中，RB8 是接收机接收到的第9 位数据，该数据正好来自发送机的TB8，从而识别接收到的数据特征。

　　TI ：串行口发送中断请求标志。当CPU 发送完一串行数据后，此时SBUF 寄存器为空，硬件使TI 置1，请求中断。CPU 响应中断后，由软件对TI 清零。

　　RI ：串行口接收中断请求标志。当串行口接收完一帧串行数据时，此时SBUF 寄存器为满，硬件使RI 置1，请求中断。CPU 响应中断后，用软件对RI 清零。

　　电源控制寄存器PCON（见表3）。

表3 PCON寄存器

　　表中各位（从左至右为从高位到低位）含义如下。

　　SMOD ：波特率加倍位。SMOD=1，当串行口工作于方式1、2、3 时，波特率加倍。SMOD=0，波特率不变。

　　GF1、GF0 ：通用标志位。

　　PD（PCON.1）：掉电方式位。当PD=1 时，进入掉电方式。

　　IDL（PCON.0）：待机方式位。当IDL=1 时，进入待机方式。

　　另外与串行口相关的寄存器有前面文章叙述的定时器相关寄存器和中断寄存器。定时器寄存器用来设定波特率。中断允许寄存器IE 中的ES 位也用来作为串行I/O 中断允许位。当ES ＝ 1，允许串行I/O 中断；当ES ＝ 0，禁止串行I/O 中断。中断优先级寄存器IP的PS 位则用作串行I/O 中断优先级控制位。当PS=1，设定为高优先级；当PS =0，设定为低优先级。

　　波特率计算：在了解了串行口相关的寄存器之后，我们可得出其通信波特率的一些结论：

　　① 方式0 和方式2 的波特率是固定的。

　　在方式0 中，波特率为时钟频率的1/12，即fOSC/12，固定不变。

　　在方式2 中，波特率取决于PCON 中的SMOD 值，即波特率为：

　　当SMOD=0 时，波特率为fosc/64 ；当SMOD=1 时，波特率为fosc/32。

　　② 方式1 和方式3 的波特率可变，由定时器1 的溢出率决定。

　　当定时器T1 用作波特率发生器时，通常选用定时初值自动重装的工作方式2（注意：不要把定时器的工作方式与串行口的工作方式搞混淆了）。其计数结构为8 位，假定计数初值为Count，单片机的机器周期为T，则定时时间为（256 ?Count）×T 。从而在1s内发生溢出的次数（即溢出率）可由公式（1）所示：

　　从而波特率的计算公式由公式（2）所示：

　　在实际应用时，通常是先确定波特率，后根据波特率求T1 定时初值，因此式（2）又可写为：

　　二、电路详解

　　下面就对图1 所示电路进行详细说明。

图1 串行通信实验电路图

　　最小系统部分（时钟电路、复位电路等）第一讲已经讲过，在此不再叙述。我们重点来了解下与计算机通信的RS-232 接口电路。可以看到，在电路图中，有TXD 和RXD 两个接收和发送指示状态灯，此外用了一个叫MAX3232 的芯片，那它是用来实现什么的呢？首先我们要知道计算机上的串口是具有RS-232 标准的串行接口，而RS-232 的标准中定义了其电气特性：高电平“1”信号电压的范围为-15V~-3V，低电平“0”

　　信号电压的范围为+3V~+15V。可能有些读者会问，它为什么要以这样的电气特性呢？这是因为高低电平用相反的电压表示，至少有6V 的压差，非常好的提高了数据传输的可靠性。由于单片机的管脚电平为TTL，单片机与RS-232 标准的串行口进行通信时，首先要解决的便是电平转换的问题。一般来说，可以选择一些专业的集成电路芯片，如图中的MAX3232。MAX3232 芯片内部集成了电压倍增电路，单电源供电即可完成电平转换，而且工作电压宽，3V~5.5V 间均能正常工作。其典型应用如图中所示，其外围所接的电容对传输速率有影响，在试验套件中采用的是0.1μF。

　　值得一提的是MAX3232 芯片拥有两对电平转换线路，图中只用了一路，因此浪费了另一路，在一些场合可以将两路并联以获得较强的驱动抗干扰能力。此外，我们有必要了解图中与计算机相连的DB-9 型RS-232的引脚结构（见图2）。

图2 DB-9连接器接口图

　　其各管脚定义如下（见表4）。

表4 DB-9型接口管脚定义

　　三、程序设计

本讲设计实例程序如下：

　　＃i nclude "AT89X52.h" （1）

　　void Init_Com（void）（ 2）

　　{

　　TMOD = 0x20; （ 3）

　　PCON = 0x00; （ 4）

　　SCON = 0x50; （ 5）

　　TH1 = 0xE8; （ 6）

　　TL1 = 0xE8; （ 7）

　　TR1 = 1; （ 8）

　　}

　　void main（void）（ 9）

　　{

　　unsigned char dat; （ 10）

　　Init_Com（）；（ 11）

　　while（1）（ 12）

　　程序详细说明：

　　（1）头文件包含。

　　（2）声明串口初始化程序。

　　（3）设置定时器1 工作在模式2，自动装载初值（详见第二讲）。

　　（4）SMOD 位清0，波特率不加倍。

　　（5）串行口工作在方式1，并允许接收。

　　（6）定时器1 高8 位赋初值。波特率为1200b/s（7）定时器1 低8 位赋初值。

　　（8）启动定时器。

　　（9）主函数。

　　（10）定义一个字符型变量。

　　（11）初始化串口。

　　（12）死循环。

　　（13）如果接收到数据。

　　（14）将接收到的数据赋给之前定义的变量。

　　（15）将接收到的值输出到P0 口。

　　（16）对接收标志位清0，准备再次接收。

　　（17）将接收到的数据又发送出去。

　　（18）查询是否发送完毕。

　　（19）对发送标志位清0。

　　四、调试要点与实验现象

　　接好硬件，通过冷启动方式将程序所生成的。hex文件下载到单片机运行后，打开串口调试助手软件，设置好波特率1200，复位单片机，然后在通过串口调试助手往单片机发送数据（见图3），可以观察到在接收窗口有发送的数据显示，此外电路板上的串行通信指示灯也会闪烁，P0 口所接到LED 灯会闪烁所接收到的数据。

图3 串口软件调试界面

　　另外串口调试助手软件使用时应注意的是，如果单片机开发板采用串口下载而且和串口调试助手是使用同一串口，则在打开串口软件的同时不能给单片机下载程序，如需要下载，请首先点击“关闭串口”，做发送实验的时候，注意如果选中16 进制发送的就是数字或者字母的16 进制数值，比如发送“0”，实际接收的就应该是0x00，如果不选中，默认发送的是ASCII 码值，此时发送“0”，实际接收的就应该是0x30，这点可以通过观察板子P0 口上的对应的LED 指示出来。

　　五、总结

　　本讲介绍了单片机串口通信的原理并给出了实例，通过该讲，读者可以了解和掌握51 单片机串口通信的原理与应用流程，利用串口通信，单片机可以与计算机相连，也可以单片机互联或者多个单片机相互通信组网等，在实际的工程应用中非常广泛。从学习的角度来说，熟练的利用串口将单片机系统中的相关信息显示在计算机上可以很直观方便的进行调试和开发。因此希望读者能够自己灵活应用串口通信到自己的实际开发当中，至此，51 单片机内部资源讲述得差不多了，从下讲开始，将要介绍单片机外围电路。下讲将讲述单片机外接按键的原理与实例，敬请期待

六：分析

51单片机的串口，是个全双工的串口，发送数据的同时，还可以接收数据。
当串行发送完毕后，将在标志位 TI 置 1，同样，当收到了数据后，也会在 RI 置 1。
无论 RI 或 TI 出现了 1，只要串口中断处于开放状态，单片机都会进入串口中断处理程序。
在中断程序中，要区分出来究竟是发送引起的中断，还是接收引起的中断，然后分别进行处理。
看到过一些书籍和文章，在串口收、发数据的处理方法上，很多人都有不妥之处。
接收数据时，基本上都是使用“中断方式”，这是正确合理的。
即：每当收到一个新数据，就在中断函数中，把 RI 清零，并用一个变量，通知主函数，收到了新数据。
发送数据时，很多的程序都是使用的“查询方式”，就是执行 while(TI ==0); 这样的语句来等待发送完毕。
这时，处理不好的话，就可能带来问题。
看了一些网友编写的程序，发现有如下几条容易出错：
１．有人在发送数据之前，先关闭了串口中断！等待发送完毕后，再打开串口中断。
这样，在发送数据的等待期间内，如果收到了数据，将不能进入中断函数，也就不会保存的这个新收到的数据。
这种处理方法，就会遗漏收到的数据。
２．有人在发送数据之前，并没有关闭串口中断，当 TI = 1 时，是可以进入中断程序的。
但是，却在中断函数中，将 TI 清零!
这样，在主函数中的while(TI ==0);，将永远等不到发送结束的标志。
３．还有人在中断程序中，并没有区分中断的来源，反而让发送引起的中断，执行了接收中断的程序。
对此，做而论道发表自己常用的方法：
接收数据时，使用“中断方式”，清除 RI 后，用一个变量通知主函数，收到新数据。
发送数据时，也用“中断方式”，清除 TI 后，用另一个变量通知主函数，数据发送完毕。
这样一来，收、发两者基本一致，编写程序也很规范、易懂。
更重要的是，主函数中，不用在那儿死等发送完毕，可以有更多的时间查看其它的标志。

实例：
求一个PC与单片机串口通信的程序，要求如下：
1、如果在电脑上发送以$开始的字符串，则将整个字符串原样返回（字符串长度不是固定的）。
2、如果接收到1，则将P10置高电平，接收到0，P10置低电平。（用来控制一个LED）
单片机是STC89C52RC/晶振11.0592/波特率要求是9600或4800。谢谢！
问题补充：可能会将【$ABCD,123456,987654ccc,aasdasd,aaaa,sssd,4D】这样的字符串（字符串长度约为50-150个字符）传送给单片机，只能能原样返回。

[cpp] view plain copy

print ?

最佳答案：
下列程序，已经调试成功。
#include <REG52.H>
sbit LED = P1^0;
unsigned char UART_buff;
bit New_rec = 0, Send_ed = 1, Money = 0;
//----------------------------------------------
void main (void)
{
SCON = 0x50; //串口方式1, 8-n-1, 允许接收.
TMOD = 0x20; //T1方式2
TH1 = 0xFD; [url=]//[email protected][/url]
TL1 = 0xFD;
TR1 = 1;
ES = 1; //开中断.
EA = 1;
while(Money == 0); //等着交费，呵呵，等着接收$.
while(1) {
if ((New_rec == 1) && (Send_ed == 1)) { //如果收到新数据及发送完毕
SBUF = UART_buff; //那就发送.
New_rec = 0;
Send_ed = 0;
} }
}
//----------------------------------------------
void ser_int (void) interrupt 4
{
if(RI == 1) { //如果收到.
RI = 0; //清除标志.
New_rec = 1;
UART_buff = SBUF; //接收.
if(UART_buff == '1') LED = 1;
if(UART_buff == '0') LED = 0;
if(UART_buff == '$') Money = 1;
}
else { //如果送毕.
TI = 0; //清除标志.
Send_ed = 1;
}
}
//----------------------------------------------

最佳答案：
下列程序，已经调试成功。
#include <REG52.H>
sbit LED = P1^0;
unsigned char UART_buff;
bit New_rec = 0, Send_ed = 1, Money = 0;
//----------------------------------------------
void main (void)
{
    SCON = 0x50;   //串口方式1, 8-n-1, 允许接收.
    TMOD = 0x20;   //T1方式2
    TH1 = 0xFD;    [url=]//[email protected][/url]
    TL1 = 0xFD;
    TR1 = 1;                        
    ES  = 1;       //开中断.
    EA  = 1;
    while(Money == 0);    //等着交费，呵呵，等着接收$.
    while(1)  { 
      if ((New_rec == 1) && (Send_ed == 1))  {  //如果收到新数据及发送完毕
        SBUF = UART_buff; //那就发送.
        New_rec = 0;
        Send_ed = 0;
    } }
}
//----------------------------------------------
void ser_int (void) interrupt 4 
{
    if(RI == 1) {  //如果收到.
      RI = 0;      //清除标志.
      New_rec = 1;
      UART_buff = SBUF;  //接收.
      if(UART_buff == '1')  LED = 1;
      if(UART_buff == '0')  LED = 0;
      if(UART_buff == '$')  Money = 1;
    }
    else  {        //如果送毕.
      TI = 0;      //清除标志.
      Send_ed = 1;
    }
} 
//----------------------------------------------

http://bbs.ednchina.com/BLOG_ARTICLE_3007162.HTM

串口接收程序是基于串口中断的，单片机的串口每次接收到一字节数据产生一次中断，然后再读取某个寄存器就可以得到串口接收的数据了。然而在实际应用当中，基本上不会有单字节接收的情况。一般都是基于一定串口通信协议的多字节通信。在422或者485通信中，还可能是一个主机（一般是计算机）带多个从机（相应的有单片机的板卡）。这就要求我们的单片机能够在连续接收到的串口数据序列中识别出符合自己板卡对应的通信协议，来进行控制操作，不符合则不进行任何操作。简而言之就是，单片机要在一串数据中找到符合一定规律的几个字节的数据。

先来说下怎样定串口协议吧。这个协议指的不是串口底层的协议，而是前面提到的数据帧协议。一般都是有帧头（2~3个字节吧），数据（长度根据需要），结束位（1位，有时候设计成校验字节，最简单的校验也就是前面所有数据求和）。

比如0xaa 0x55 +（数据部分省略）+校验和（除了aa 55 之外数据的和），如果要是多板卡的话有时候还要在帧头后面加一个板选字节（相当于3字节帧头了）。

第一次写串口接收程序的时候，我首先想到的就是定义一个全局变量（实际上最好是定义局部静态变量），初始值设置为0，然后每进一次中断+1，然后加到串口通信协议的长度的时候再清零。然后判断帧头、校验。写完了之后我自己都觉得不对，一旦数据错开了一位，后面就永远都接收不到数了。无奈看了一下前辈们的代码，跟我的思路差不多，只不过那个计数值跟接收到的数据时同时判断的，而且每次中断都要判断，一旦不对计数的那个变量就清零。

废话少说，直接上一段代码让大家看看就明白了。（通信协议姑且按照简单的aa 55 一个字节数据一个字节校验，代码是基于51单片机的）。接收成功则在中断程序中把串口接收成功标志位置1。

[cpp] view plain copy

print ?

然后串口中断部分
void ser()interrupt 4
{
static unsigned char count;//串口接收计数的变量
RI=0;//手动清某个寄存器，大家都懂的
receive[count]=SBUF;
if(count==0&&receive[count]==0xaa)//同时判断count跟收到的数据
{
count=1;
}
else if(count==1&&receive[count]==0x55)
{
count=2;
}
else if(count==2)
{
count++;
}
else if(count==3&&receive[count]== receive [2])//判断校验和，数据多的话是求//和，或者其他的校验方法，也可能是固定的帧尾
{
count=0;
uart_flag =1;//串口接收成功标志，为1时在主程序中回复，然后清零
ES=0; //关中断，回复完了再ES=1;
}
else
{
count=0;//判断不满足条件就将计数值清零
}
}

然后串口中断部分
void ser()interrupt 4
{
static unsigned char count;//串口接收计数的变量
  RI=0;//手动清某个寄存器，大家都懂的
  receive[count]=SBUF;
  if(count==0&&receive[count]==0xaa)//同时判断count跟收到的数据
  {
       count=1;
  }
  else if(count==1&&receive[count]==0x55)
  {
     count=2;
  }
  else if(count==2)
  {
       count++;
  }
  else if(count==3&&receive[count]== receive [2])//判断校验和，数据多的话是求//和，或者其他的校验方法，也可能是固定的帧尾
  {
    count=0;
     uart_flag =1;//串口接收成功标志，为1时在主程序中回复，然后清零
   ES=0;      //关中断，回复完了再ES=1;
  }
  else
  {
     count=0;//判断不满足条件就将计数值清零
  }
}

第一次做的串口大概就按照这个方法写完了（我后来看过其他的代码，有人用switch语句写的，逻辑跟这个也差不多，不过我还是感觉用if else来写清晰一些），

不过在测试的时候发现了bug，如果数据帧发送一半，然后突然停止，再来重新发，就会丢失一帧的数据。比如先接受到aa 55，然后断了，再进来aa 55 01 01，就不受控制了。后来我也想到一个bug，如果在多设备通信中，属于其他设备的的帧数据最后一位是aa（或者最后两位为aa 55 ，或者最后3位为aa 55 板选），下一次通信的数据就接收不到了。

当时对于数据突然中断的bug，没有想到很好的解决办法，不过这种情况几率极小，所以一直用这个方法写也没有问题。多设备通信最后一位恰好是aa的几率也很小，出问题的可能也很小。当时项目里面的控制数据跟校验恰好不可能出现aa，于是我把if(count==0&&receive[count]==0xaa)改成了if(receive[count]==0xaa)其他都没变，解决了，没有bug了。

后来我又写了几次单片机程序，才想到了一些解决问题的方法——不过改天再接着写吧，太累了，明天还要上班呢。

在后来的项目中，真的遇到了数据位跟校验位都可能出现aa的情况。我考虑到每次数据都是连续发送的（至少我们用labwindows做的上位机程序是这样的），成功接收到了一帧数据是要有一定时间回复的，也就是说如果接收到一半，但是很长时间没接收到数据，把计数值count清零就ok啦。涉及时间的问题自然要用定时器来实现啦。

这次的通信协议如下，串口波特率19200,2个帧头aa 55 ，一个板选，6字节数据，一个校验字节（除帧头外其他数据的和）。

[cpp] view plain copy

print ?

全局变量定义
unsigned char boardAddr;//板选地址，通过检测几个io引脚，具体怎么得到的就不写了，很简单的
unsigned char g_DatRev [10]={0};//接收缓存
bit retFlag=0；//为1代表串口接收到了一帧数据
串口初始化函数，晶振22.1184
void init_uart()
{
SCON = 0x50; //串口方式1允许接收
TMOD = 0x21; //定时器1，方式2，8位自动重载，同时配置定时器0，工作方式1
PCON = 0x80; // 波特率加倍
TH1 = 0xfa;
TL1 = 0xfa; //写入串口定时器初值
TH0=(65536-2000)/256; //写入定时器0初值，串口传输一个字节时间为（1/19200）*10，计算得0.52ms
TL0=(65536-2000)%256; //定时器0定时大约1ms多
EA=1;
ET0=1; //波特率：19200 22.1184M 初值：250(0xfa)
IE |= 0x90;
TR1 = 1;
}
串口中断函数
void UART_INT(void) interrupt 4
{
static unsigned char count;//串口接收计数的变量
RI = 0;
g_DatRev[count] = SBUF;
if(g_DatRev[count]==0xaa&&count==0) //帧头
{
count=1;
}
else if(count==1&&g_DatRev[count]==0x55)
{
count=2;
}
else if (count==2&&g_DatRev[2] == boardAddr)
{
CK = g_DatRev[count];
count=3;
}
else if(count>=3&&count<9)
{
CK += g_DatRev[count];
count ++;
}
else if(count == 9&&CK==g_DatRev[9])
{
ES = 0;
retFlag = 1;
count=0;
}
else
{
count=0;
}
resettimer();
}
//判断count不为0的话就启动定时器
void resettimer()
{
TR0=0;
TH0=(65536-2000)/256;
TL0=(65536-2000)%256;
if(count!=0)
{
TR0=1;
}
}
定时器中断函数
void T0_time()interrupt 1
{
TR0=0;
TH0=(65536-2000)/256;
TL0=(65536-2000)%256;
count=0;
}

全局变量定义
unsigned char boardAddr;//板选地址，通过检测几个io引脚，具体怎么得到的就不写了，很简单的
unsigned char g_DatRev [10]={0};//接收缓存
bit retFlag=0；//为1代表串口接收到了一帧数据
 
 
串口初始化函数，晶振22.1184
 
void init_uart()
{
       SCON = 0x50;                 //串口方式1允许接收
       TMOD = 0x21;                //定时器1，方式2，8位自动重载，同时配置定时器0，工作方式1
       PCON = 0x80;                // 波特率加倍
       TH1 = 0xfa;
       TL1 = 0xfa;               //写入串口定时器初值
       TH0=(65536-2000)/256;    //写入定时器0初值，串口传输一个字节时间为（1/19200）*10，计算得0.52ms
       TL0=(65536-2000)%256;   //定时器0定时大约1ms多
    EA=1;
    ET0=1;                  //波特率：19200    22.1184M  初值：250(0xfa)
       IE |= 0x90;           
    TR1 = 1;                   
}
 
串口中断函数
 
void UART_INT(void) interrupt 4
{ 
       static unsigned char count;//串口接收计数的变量
 
              RI = 0;
              g_DatRev[count] = SBUF;
              if(g_DatRev[count]==0xaa&&count==0)             //帧头
           {
                   count=1;                                                 
            }
               else if(count==1&&g_DatRev[count]==0x55) 
            {  
                         count=2;          
            }
 
                else if (count==2&&g_DatRev[2] == boardAddr)
               { 
                  CK = g_DatRev[count];
                   count=3;
                 
               }
     
               else if(count>=3&&count<9)
              {     
                
                     CK += g_DatRev[count];
                    count ++;
            }
             
           else if(count == 9&&CK==g_DatRev[9])
                     {     
                         ES = 0; 
                        retFlag = 1;
                         count=0;            
                     }            
              else
               {
                    count=0;
               } 
             resettimer();
 
}
 
//判断count不为0的话就启动定时器
void resettimer()
{
       TR0=0;
       TH0=(65536-2000)/256;
       TL0=(65536-2000)%256;
       if(count!=0)
       {
              TR0=1;
       }
}
 
定时器中断函数
void T0_time()interrupt 1
{     
    TR0=0;
       TH0=(65536-2000)/256;
       TL0=(65536-2000)%256;
       count=0;
 
}

这种方法的确是本人自己想出来的，别人可能也这样做过，但我这个绝对不是抄袭或者模仿来的。这样写的确可以避免前面提到过的bug，不过代价是多用了一个定时器的资源，而且中断函数里的内容更多了，占用了更多的时间。

要是能把第一种方法改进一下就好了，主要是那个校验不能为aa的那个bug，因为毕竟传输到一半突然断了的可能性是非常小的。后来我想第一个判断if(count==0&&receive[count]==0xaa)好像有点太严格了，考虑到第二字节的帧头，跟板选地址不可能为aa，于是把这个改写为if(count>=0&&count<=2&& receive[count]==0xaa),这样就把bug出现的几率降到了非常小，也只是在前一帧结尾数据恰好为 aa 55 板选的时候才出现，几率是多少大家自己算一下吧，呵呵。这样我自己觉得，昨天写的那种方法改进到这个程度，应该算可以啦，反正我是很满意了。

实际上我还想过其他的方法，比如缓存的数组采用移位寄存的方式。拿前面的4个字节的协议为例。

[cpp] view plain copy

print ?

void ser()interrupt 4
{
unsigned char i;
RI=0;
for(i=0;i<3;i++)
{
receive[i]=receive[i+1];
}
receive[3]=SBUF;
if(reveive[0]==0xaa&&receive[1]==0x55&&receive[2]==receive[3])
{
ret_flag=1;
ES = 0;
}
}

void ser()interrupt 4
{
 unsigned char i;
  RI=0;
 
  for(i=0;i<3;i++)
  {
     receive[i]=receive[i+1];
  }
  receive[3]=SBUF;
  if(reveive[0]==0xaa&&receive[1]==0x55&&receive[2]==receive[3])
  {
     ret_flag=1;
       ES = 0;  
  }
 
}

这段代码看上去可是简单明了，这样判断可是不错啊，同时判断帧头跟校验不会产生前面提到的bug。说实话当时我刚想出这种方法并写出来的时候，马上就被我给否了。那个for循环可真是很占时间的啊，延时函数都是这样写的。每次都循环一下，这延时太长，通信速度太快的话就不能接收到下一字节数据了。最要命的是这个时间的长度是随着通信协议帧的字节数增加而增加的，如果一次要接收几十个字节，肯定就玩完了。这种方法我一次都没用过。

不过我居然又想出来了这种方法的改良措施，是前两天刚想出来的，呵呵，还没有实践过呢。

下面代码的协议就按第二段程序（定时器清零的那个协议，一共10字节）

全局变量

[cpp] view plain copy

print ?

bit ret_flag;
unsigned char receive[256]={0};
unsigned char boardaddress;
中断函数
void ser()interrupt 4
{
static unsigned char i=0;
static unsigned char total=0;
RI=0;
receive[i]=SBUF;
total=total-receive[i-7]+receive[i-1];
if(receive[i-9]==0xaa&&receive[i-8]==0x55
&&receive[i-7]==boardaddress&&receive[i]==total
)
{
ret_flag=1;
ES = 0;
}
i++;
}

bit ret_flag;
unsigned char receive[256]={0};
unsigned char boardaddress;
 
中断函数
 
void ser()interrupt 4
{
 
 
  static unsigned char i=0;
  static unsigned char total=0;
  RI=0;
  receive[i]=SBUF;
  total=total-receive[i-7]+receive[i-1];
 
  if(receive[i-9]==0xaa&&receive[i-8]==0x55
  &&receive[i-7]==boardaddress&&receive[i]==total
  )
  {
     ret_flag=1;
       ES = 0;  
  }
  i++;
 
}

之所以要定义256个长度的数组，就是为了能够让数组“首尾相接”。因为0 -1 = 255 ， 255+1 = 0。而且我在计算校验的时候也改进了算法，不会因为数据长度的增加而增加计算校验值的时间。这种方法也是我不久前才想出来的，所以还没有经过实际的验证。上面的代码可能会有逻辑上的错误，如果真有错误，有网友看出来的话，请在下面留言告诉我。这个方法也是我原创的哦，别人也肯能会想到，不过我这个绝对不是抄袭别人的。

上面的代码最大的缺点就是变量定义的太多了，太占ram资源了，编译的时候可能会出现错误，毕竟51单片机才128字节的ram（有的资源也很丰富的，比如c8051系列的），这一下子就是256字节的变量。不过对于资源多一些的单片机，这样写还是可以的。要是能有4bit在一起的数据类型就好了，呵呵，verilog代码里面是可以的,C语言里貌似不行啊。

要想能在例如51单片机上运行，只能按照下面的折中方式了，也就是把i相关的量都与一个0x0f

[cpp] view plain copy

print ?

全局变量
bit ret_flag;
unsigned char receive[16]={0};// 可以考虑在定义时加上idata,毕竟还可能是32
//或者64长度的数组呢unsigned char idata receive[16]={0};
unsigned char boardaddress;
中断函数
void ser()interrupt 4
{
static unsigned char i=0;
static unsigned char total=0;
RI=0;
receive[i&0x0f]=SBUF;
total=total-receive[(i-7)&0x0f]+receive[(i-1)&0x0f];
if(receive[(i-9)&0x0f]==0xaa&&receive[(i-8)&0x0f]==0x55
&&receive[(i-7)&0x0f]==boardaddress&&receive[i&0x0f]==total
)
{
ret_flag=1;
ES = 0;
}
i++;
}

（一）uart通信：基于51实现

猜你喜欢