串口通信无法检测数据

现在手上有一个传感器，测量结果用串口输出，输出频率1HZ。输出的格式是帧数据（十六进制）的形式，帧头是0XAA 0XAA，始终检测不到帧头。
做了以下实验：
1、用传感器与PC端直连，用串口助手查看结果，可以检测到帧头，且数据正常。
2、用单片机与PC端直连，用单片机发送消息，波特率9600，数据位8，正常通信。
3、用单片机与传感器相连，按上述2个实验，波特率应该无误。但是帧数据是15个字节，每次只能收到13个字节。
问：
1、既然波特率无误，为什么会漏掉2个字节内容，而且每个周期都一样呢?
2、我尝试在接收中断里用if（Buffer==某个特定字节），在检测过程中，经常出现跳帧的情况，本来应该1s能够检测到1个，但实际上，有时候会突然漏掉一个，下一秒又正常了。这又是为什么呢?
希望各位前辈能不吝赐教。

先把代码放出来，慢慢改吧

1. #include <STC12C5A60S2.h>
   
2. #include <string.h>
   
3. #include <stdio.h>
   
4. #include<LCD.h>
   
5. #define uchar unsigned char
   
6. #define uint unsigned int
   
7. 
   
8. 
   
9. #define Data_H 0XAA                                                 //帧数据定义：2个帧头
   
10. #define Data_Length 0X0D                                //帧数据定义：帧长
    
11. #define Data_Address 0X02                                //帧数据定义：地址位
    
12. #define Data_Cmd                                                //帧数据定义：命令字
    
13. #define Data_X_H                                                //
    
14. #define Data_X_L                                                //
    
15. #define Data_Y_H                                                //
    
16. #define Data_Y_L                                                //
    
17. #define Data_Tempratrue                                        //帧数据定义：温度
    
18. #define Data_Check                                                //帧数据定义：校验位
    
19. 
    
20. static uchar counter = 0;                  //字符接收计数
    
21. 
    
22. uchar receive[15];                                  //接收缓冲数组
    
23. 
    
24. bit start_flag = 0;                                //帧开始接收位
    
25. bit finish_flag = 0;                        //帧接收完成位
    
26. 
    
27. uchar Rec_Angle[20];
    
28. unsigned char code Single_Output[6]={0xAA,0xAA,0x04,0x02,0xA0,0XA6};
    
29. unsigned char code Continous_Output[6]={0xAA,0xAA,0x04,0x02,0xA1,0XA7};
    
30. 
    
31. 
    
32. void Uart_One_Send(uchar c)
    
33. {
    
34.         ES=0;                                //关中断
    
35.         SBUF=c;                                //将字符c赋值给
    
36.         while(TI！=1);                //等待发送结束
    
37.         TI=0;                                //软件置零
    
38.         ES=1;                                //开中断
    
39. }
    
40. void Uart_One_String(uchar *p,uint length)
    
41. {
    
42.         uint k=0;
    
43.         do
    
44.         {
    
45.                 Uart_One_Send(*(p+k));
    
46.                 k++;
    
47.         }while(k<length);       
    
48. }
    
49. void Uart_init(void)                //9600bps@11.0592MHz  串口初始化
    
50. {
    
51.         ES=0;
    
52.         PCON &= 0x7F;                //波特率不倍速
    
53.         SCON = 0x50;                //8位数据,可变波特率
    
54.         AUXR |= 0x40;                //定时器1时钟为Fosc,即1T
    
55.         AUXR &= 0xFE;                //串口1选择定时器1为波特率发生器
    
56.         TMOD &= 0x0F;                //清除定时器1模式位
    
57.         TMOD |= 0x20;                //设定定时器1为8位自动重装方式
    
58.         TL1 = 0xDC;                //设定定时初值
    
59.         TH1 = 0xDC;                //设定定时器重装值
    
60.         ET1 = 0;                //禁止定时器1中断
    
61.         TR1 = 1;                //启动定时器1
    
62.         ES=1;
    
63.         EA=1;
    
64. }
    
65. void delay100us(uint z)
    
66. {
    
67.         uint i,k;
    
68.         for(i=0;i<z;i++)
    
69.                 for(k=0;k<125;k++);
    
70. }
    
71. void CLR_Rec_Angle()           //清除接收指针缓存
    
72. {
    
73.         uchar k;
    
74.         for(k=0;k<15;k++)
    
75.                 Rec_Angle[k]=0;
    
76.        
    
77. }
    
78. 
    
79. void Uart_One_Receive() interrupt 4
    
80. {               
    
81.         ES=0;
    
82.         if(TI)
    
83.         {
    
84.           TI=0;          
    
85.         }
    
86.         if(RI)
    
87.         {
    
88.                 RI=0;       
    
89.                 receive[counter++] = SBUF;
    
90.                 if(counter==15)
    
91.                 {
    
92.                         counter=0;
    
93.                         finish_flag=1;
    
94.                 }
    
95.                
    
96. 
    
97.                
    
98. 
    
99. 
    
100. /*********************************************中断用于接收15个字节*********************************/
     
101. //                if(counter == 0 && receive[counter] == Data_H)                //判断第一个字节是否是第一个帧头AA
     
102. //                        {
     
103. //                                counter = 1;
     
104. //                        }
     
105. //                else if(counter==1&&receive[counter]==Data_H)        //判断第二个字节是否是第二个帧头AA
     
106. //                        {
     
107. //                                counter = 2 ;
     
108. //                        }
     
109. //                else if(counter == 2 && receive[counter] == Data_Length)        //判断第三个字节是否是帧长度13个字节
     
110. //                        {
     
111. //                                counter = 3;
     
112. //                                start_flag = 1 ;
     
113. //                        }
     
114. //                else if(counter ！= 14 && counter>2 )        //后续数据接收
     
115. //                        {
     
116. //                                counter++;                                                       
     
117. //                        }
     
118. //                else if(counter == 14 )                             //最后的校验位接收
     
119. //                        {
     
120. //                                uint temp,j ;
     
121. //                                uint result = 0;
     
122. //                                counter = 0;
     
123. //                                for(j=0;j<14;j++)
     
124. //                                {
     
125. //                                        temp = result^receive[j];
     
126. //                                        result= temp;       
     
127. //                                }
     
128. //                                if(result==receive[14])                        //数据校验
     
129. //                                {
     
130. //                                        finish_flag = 1;
     
131. //                                        counter=0;
     
132. //                                }
     
133. //                        }       
     
134. //                else if(counter > 14)
     
135. //                {
     
136. //                                counter = 0;
     
137. //                }
     
138. /*********************************************中断用于接收15个字节*********************************/
     
139.                
     
140.         }
     
141.                 ES=1;
     
142. }
     
143. 
     
144. 
     
145. 
     
146. 
     
147. 
     
148. void main()
     
149. {       
     
150.         uchar *p = Continous_Output;
     
151.         uint i = 0 ;
     
152.         uint j = 8 ;
     
153.         delay100us(10000);
     
154.         L1602_init();
     
155.         delay100us(20000);
     
156.         wcmd(0xc1+0x01);
     
157.         L1602_string(1,1,"Linking...")  ;
     
158.         Uart_init();
     
159.         delay100us(10000);
     
160.         L1602_string(1,1,"Setting...");
     
161.         delay100us(10000);
     
162.         wcmd(0x01);
     
163. 
     
164.                        
     
165. /*****************************************十六进制显示******************************************/       
     
166. //                wcmd(0x80);
     
167. //                display_num(receive[0]);
     
168. //                wcmd(0x82);
     
169. //                display_num(receive[1]);
     
170. //                wcmd(0x84);
     
171. //                display_num();
     
172. //                wcmd(0xc0);
     
173. //                display_num(0xAA);       
     
174. /*****************************************十六进制显示******************************************/       
     
175.                   
     
176.         while(1){
     
177.                        
     
178.                            Uart_One_String(p,6);
     
179.                         delay100us(5000);
     
180. 
     
181. 
     
182. /*****************************************1602显示接收的数据******************************************/       
     
183.                         if(finish_flag)
     
184.                         {
     
185.                                 wcmd(0x01);
     
186.                                 finish_flag = 0;
     
187.                                 for(i=0;i<8;i++)                          //第一行显示前8位
     
188.                                 {
     
189.                                         wcmd(0x80+0x02*i);
     
190.                                         display_num(receive[i]);
     
191.                                 }
     
192.                                 for(j=8;j<15;j++)                          //第二行显示后7位
     
193.                                 {
     
194.                                         wcmd(0xc0+0x02*(j-8));
     
195.                                         display_num(receive[j]);
     
196.                                 }
     
197.                                 delay100us(5000) ;
     
198.                         }
     
199. /*****************************************1602显示接收的数据******************************************/       
     
200. 
     
201.                
     
202. /**********************************************十进制显示******************************************/
     
203. //                if(receive[counter])
     
204. //                {                                 
     
205. //               
     
206. //                          wcmd(0xc1);
     
207. //                        x1 = counter;
     
208. //                        L1602_char(2,1,x1/100+0x30);
     
209. //                        L1602_char(2,2,x1%100/10+0x30);
     
210. //                        L1602_char(2,3,x1%10+0x30);
     
211. //                }
     
212. /**********************************************十进制显示******************************************/
     
213.                 }
     
214.        
     
215. //        Read_Angle();
     
216. }
     
217.                  

复制代码

1、下载上面的程序，单片机以0.5s间隔发送 AA AA 04 02 A1 A7。使用串口助手发送AA AA 0D 02 A0 2C 25 19 B5 1B 2C F2 8A F1 B4 ，1602显示AA AA 0D 02 A0 2C 25 19 B5 1B 2C F2 8A F1 B4 ，显示正常。
2、将传感器与单片机相连，1602有时候接收后不显示，有时候显示16*2个0.是否哪里时序不对?

同学说可能是电平不对，我只有一个万用表啊。
传感器通过串口线与单片机开发板的串口相连，单片机开发板的串口经过max232与单片机相连，大家都是共地的，电平怎么会有问题呢?

被自己弄醉了，原来是母头串口线的RX tX接反了，结贴