标题: 关于单片机温度采集串口中断的问题？ [打印本页]

---

作者: duwen009    时间: 2018-4-8 20:47
标题: 关于单片机温度采集串口中断的问题？
在用STC89C52单片机做一个温度采集功能。
功能是这样的：
      1、工作频率 11.0592
      2、P2.0,P2.1,P2.2,P2.3 普通IO口分别接了四个S18B20温度传感器，用来采集温度。
      3、RX,TX分别和电脑的串口连好，实现和电脑通讯
      4、电脑串口定时发送定义好的查询帧，单片机串口收到后，判断帧的内容，查询温度，并返回温度数据。
      5、功能己经实现，这样运行的也没有问题。

现在的操作方式是被动操作，（也就是电脑发送一帧数据，单片机查询一次温度，并返回）流程如下：
   1，电脑串口发送定义好的16字数据 --->2、单片机串口收到数据，根据数据的类型，查询S18B20温度传感器温度---->3，单片机将温度数据再编码成16个字节数据发送给电脑串口---->4，电脑串口收到数据后处理并显示


存在一个问题是：
现在我想在单片机上装一个显示屏，让单片机定时不断查询温度并显示在屏幕上。
但是单片机在进行S18B20查询温度是很讲究时序的，在1602显示屏上显示文字，也是讲究时序的。
问题：单片机正在对S18B20查询温度时（IO口电平拉高，或拉底），这时有串口数据来到，会中断当前的操作，直到中断函数执行完毕。这时查询S18B20的操作时序就不准确了，1602显示屏也一样。

问：有串口数据来到要接收，不能丢弃。对S18B20操作到一半时，也不能中断，不然时序可能不准确。这样怎么处理？有什么两全其美的方法吗？

电路图：



单片机源码

1. #include  "config.h"
   
2. #include<ds1.h>
   
3. #include<ds2.h>
   
4. #include<ds3.h>
   
5. #include<ds4.h>
   
6. 
   
7. void UART_init();
   
8. void PutFrame(uchar *TXStr);
   
9. void DataFrame_Put_init();
   
10. void TEMP_init_var();
    
11. 
    
12. uchar dataFrame[16];            //定义数据帧长度为16个字节
    
13. uchar dataFrame_RI;             //数据帧是否己读取标记
    
14. 
    
15. uchar dataFrame_temp[16];            //数据帧临时缓冲区16个字节
    
16. uchar dataFrame_temp_count;     //定义数据帧己接收的字节数
    
17. 
    
18. //定义发送数据缓冲区
    
19. uchar DataFrame_Put[16]={DATAFRAME_HEAD,DEVICEID_1,DEVICEID_2,0,0,0,0,0,0,0,0,0,0,0,0,DATAFRAME_TAIL};
    
20. 
    
21. INT32U led1_count;         //运行指示灯倒计时变量
    
22. uchar led1_count2;         //运行指示灯倒计时变量2
    
23. INT32U led2_count;         //收到心跳倒计时变量
    
24. INT32U led3_count;         //有数据接收倒计时变量
    
25. INT32U led4_count;                   //有数据发送倒计时变量
    
26. #define LED1_COUNT 15000
    
27. #define LED2_COUNT 125000
    
28. #define LED3_COUNT 100
    
29. #define LED4_COUNT 100
    
30. 
    
31. 
    
32. //存储温度的高8位和底8位
    
33. uchar ds_M;
    
34. uchar ds_L;
    
35. //温度变量
    
36. uchar symbol;    //符号位
    
37. uchar hundreds;  //百位
    
38. uchar decade;    //十位
    
39. uchar unit;      //个位
    
40. uchar decimal;   //小数1位
    
41. 
    
42. void main()
    
43. {
    
44.         //串口初始化
    
45.         UART_init();
    
46. 
    
47.         while(1)
    
48.         {
    
49.                 //调试使用
    
50.                 //uchar dataFrame[16] = {DATAFRAME_HEAD,DEVICEID_1,DEVICEID_2,0,0,1,1,0,0,0,0,0,0,0,0,DATAFRAME_TAIL};
    
51.                 //dataFrame_RI = 1;          //执行时间2.17微妙
    
52. 
    
53.                 //如果己接收到一帧数据
    
54.                 if(dataFrame_RI == 1)        // 执行时间5.42微秒
    
55.                 {      
    
56.                         //收到心跳
    
57.                     if(dataFrame[3] == 0 && dataFrame[4] == 0 && dataFrame[5] == 0 && dataFrame[6] == 1){
    
58.                            //收到心跳
    
59.                            DataFrame_Put[3] = 0;
    
60.                            DataFrame_Put[4] = 0;
    
61.                            DataFrame_Put[5] = 0;
    
62.                            DataFrame_Put[6] = 1;
    
63.                            PutFrame(&DataFrame_Put);
    
64.                            led2_count = LED2_COUNT;
    
65.                         }else if(dataFrame[3] == 0 && dataFrame[4] == 0 && dataFrame[5] == 0 && dataFrame[6] == 2){
    
66.                           //收到查询设备id
    
67.                            DataFrame_Put[3] = 1;
    
68.                            DataFrame_Put[4] = 0;
    
69.                            DataFrame_Put[5] = 0;
    
70.                            DataFrame_Put[6] = 2;
    
71.                            DataFrame_Put[7] = DEVICEID_1;
    
72.                            DataFrame_Put[8] = DEVICEID_2;
    
73.                            DataFrame_Put[9] = 255;
    
74.                            DataFrame_Put[10] = 255;
    
75.                            DataFrame_Put[11] = 255;
    
76.                            DataFrame_Put[12] = 255;
    
77.                            DataFrame_Put[13] = 002;
    
78.                            DataFrame_Put[14] = 001;
    
79.                            PutFrame(&DataFrame_Put);
    
80.                            led3_count = LED3_COUNT;
    
81.                            led4_count = LED4_COUNT;
    
82.                         }else if(dataFrame[3] == 0 && dataFrame[4] == 0 && dataFrame[5] == 0 && dataFrame[6] == 9){
    
83.                            //收到更新用户信息时间，返回
    
84.                            DataFrame_Put[3] = 1;
    
85.                            DataFrame_Put[4] = 0;
    
86.                            DataFrame_Put[5] = 0;
    
87.                            DataFrame_Put[6] = 9;
    
88.                            PutFrame(&DataFrame_Put);
    
89.                            led3_count = LED3_COUNT;
    
90.                            led4_count = LED4_COUNT;
    
91.                     }else if(dataFrame[3] == 0 && dataFrame[4] == 0 && dataFrame[5] == 1 && dataFrame[6] == 1){         // 执行时间15.19 微秒
    
92.                            //查询温度1：0 0 1 1
    
93.                            TEMP_init_var();
    
94.                            DS1_ReadWeather(&ds_M,&ds_L);
    
95.                            Convert_DS_weather(ds_M, ds_L, &symbol, &hundreds, &decade, &unit, &decimal);
    
96.                            DataFrame_Put[3] = 1;
    
97.                            DataFrame_Put[4] = 0;
    
98.                            DataFrame_Put[5] = 1;
    
99.                            DataFrame_Put[6] = 1;
    
100.                            DataFrame_Put[7] = symbol;
     
101.                            DataFrame_Put[8] = hundreds;
     
102.                            DataFrame_Put[9] = decade;
     
103.                            DataFrame_Put[10] = unit;
     
104.                            DataFrame_Put[11] = decimal;
     
105.                            PutFrame(&DataFrame_Put);
     
106.                            led3_count = LED3_COUNT;
     
107.                            led4_count = LED4_COUNT;
     
108.                         }else if(dataFrame[3] == 0 && dataFrame[4] == 0 && dataFrame[5] == 1 && dataFrame[6] == 2){
     
109.                            //查询温度2：0 0 1 2
     
110.                            TEMP_init_var();
     
111.                            DS2_ReadWeather(&ds_M,&ds_L);
     
112.                            Convert_DS_weather(ds_M, ds_L, &symbol, &hundreds, &decade, &unit, &decimal);
     
113.                            DataFrame_Put[3] = 1;
     
114.                            DataFrame_Put[4] = 0;
     
115.                            DataFrame_Put[5] = 1;
     
116.                            DataFrame_Put[6] = 2;
     
117.                            DataFrame_Put[7] = symbol;
     
118.                            DataFrame_Put[8] = hundreds;
     
119.                            DataFrame_Put[9] = decade;
     
120.                            DataFrame_Put[10] = unit;
     
121.                            DataFrame_Put[11] = decimal;
     
122.                            PutFrame(&DataFrame_Put);
     
123.                            led3_count = LED3_COUNT;
     
124.                            led4_count = LED4_COUNT;
     
125.                     }else if(dataFrame[3] == 0 && dataFrame[4] == 0 && dataFrame[5] == 1 && dataFrame[6] == 3){         // 执行时间15.19 微秒
     
126.                            //查询温度3：0 0 1 3
     
127.                            TEMP_init_var();
     
128.                            DS3_ReadWeather(&ds_M,&ds_L);
     
129.                            Convert_DS_weather(ds_M, ds_L, &symbol, &hundreds, &decade, &unit, &decimal);
     
130.                            DataFrame_Put[3] = 1;
     
131.                            DataFrame_Put[4] = 0;
     
132.                            DataFrame_Put[5] = 1;
     
133.                            DataFrame_Put[6] = 3;
     
134.                            DataFrame_Put[7] = symbol;
     
135.                            DataFrame_Put[8] = hundreds;
     
136.                            DataFrame_Put[9] = decade;
     
137.                            DataFrame_Put[10] = unit;
     
138.                            DataFrame_Put[11] = decimal;
     
139.                            PutFrame(&DataFrame_Put);
     
140.                            led3_count = LED3_COUNT;
     
141.                            led4_count = LED4_COUNT;
     
142.                     }else if(dataFrame[3] == 0 && dataFrame[4] == 0 && dataFrame[5] == 1 && dataFrame[6] == 4){
     
143.                            //查询温度4：0 0 1 4
     
144.                            TEMP_init_var();
     
145.                            DS4_ReadWeather(&ds_M,&ds_L);
     
146.                            Convert_DS_weather(ds_M, ds_L, &symbol, &hundreds, &decade, &unit, &decimal);
     
147.                            DataFrame_Put[3] = 1;
     
148.                            DataFrame_Put[4] = 0;
     
149.                            DataFrame_Put[5] = 1;
     
150.                            DataFrame_Put[6] = 4;
     
151.                            DataFrame_Put[7] = symbol;
     
152.                            DataFrame_Put[8] = hundreds;
     
153.                            DataFrame_Put[9] = decade;
     
154.                            DataFrame_Put[10] = unit;
     
155.                            DataFrame_Put[11] = decimal;
     
156.                            PutFrame(&DataFrame_Put);
     
157.                            led3_count = LED3_COUNT;
     
158.                            led4_count = LED4_COUNT;
     
159.                     }else if(dataFrame[3] == 0 && dataFrame[4] == 0 && dataFrame[5] == 2 && dataFrame[6] == 1){
     
160.                            //查询开关1
     
161.                            DataFrame_Put[3] = 1;
     
162.                            DataFrame_Put[4] = 0;
     
163.                            DataFrame_Put[5] = 2;
     
164.                            DataFrame_Put[6] = 1;
     
165.                           if(SW1 == 0){
     
166.                            DataFrame_Put[7] = 1;         
     
167.                           }else{
     
168.                            DataFrame_Put[7] = 2;
     
169.                           }
     
170.                           PutFrame(&DataFrame_Put);
     
171.                           led3_count = LED3_COUNT;
     
172.                           led4_count = LED4_COUNT;
     
173.                    }else if(dataFrame[3] == 0 && dataFrame[4] == 0 && dataFrame[5] == 2 && dataFrame[6] == 2){
     
174.                            //查询开关2
     
175.                            DataFrame_Put[3] = 1;
     
176.                            DataFrame_Put[4] = 0;
     
177.                            DataFrame_Put[5] = 2;
     
178.                            DataFrame_Put[6] = 2;
     
179.                           if(SW2 == 0){
     
180.                            DataFrame_Put[7] = 1;         
     
181.                           }else{
     
182.                            DataFrame_Put[7] = 2;
     
183.                           }
     
184.                           PutFrame(&DataFrame_Put);
     
185.                           led3_count = LED3_COUNT;
     
186.                           led4_count = LED4_COUNT;
     
187.                     }else if(dataFrame[3] == 0 && dataFrame[4] == 0 && dataFrame[5] == 2 && dataFrame[6] == 3){
     
188.                            //查询开关3
     
189.                            DataFrame_Put[3] = 1;
     
190.                            DataFrame_Put[4] = 0;
     
191.                            DataFrame_Put[5] = 2;
     
192.                            DataFrame_Put[6] = 3;
     
193.                            if(SW3 == 0){
     
194.                              DataFrame_Put[7] = 1;         
     
195.                            }else{
     
196.                              DataFrame_Put[7] = 2;
     
197.                            }
     
198.                            PutFrame(&DataFrame_Put);
     
199.                            led3_count = LED3_COUNT;
     
200.                            led4_count = LED4_COUNT;
     
201.                         }else if(dataFrame[3] == 0 && dataFrame[4] == 0 && dataFrame[5] == 2 && dataFrame[6] == 4){
     
202.                            //查询开关3
     
203.                            DataFrame_Put[3] = 1;
     
204.                            DataFrame_Put[4] = 0;
     
205.                            DataFrame_Put[5] = 2;
     
206.                            DataFrame_Put[6] = 4;
     
207.                            if(SW4 == 0){
     
208.                              DataFrame_Put[7] = 1;         
     
209.                            }else{
     
210.                              DataFrame_Put[7] = 2;
     
211.                            }
     
212.                            PutFrame(&DataFrame_Put);
     
213.                            led3_count = LED3_COUNT;
     
214.                            led4_count = LED4_COUNT;
     
215.                         }else if(dataFrame[3] == 2 && dataFrame[4] == 0 && dataFrame[5] == 2 && dataFrame[6] == 1){
     
216.                            //设置开关1
     
217.                            if(dataFrame[7] == 1 && dataFrame[8] == 0 && dataFrame[9] == 0 && dataFrame[10] == 0 && dataFrame[11] == 0 && dataFrame[12] == 0 && dataFrame[13] == 0 && dataFrame[14] == 0){
     
218.                                  SW1 = 0;
     
219.                            }
     
220.                            else if(dataFrame[7] == 2 && dataFrame[8] == 0 && dataFrame[9] == 0 && dataFrame[10] == 0 && dataFrame[11] == 0 && dataFrame[12] == 0 && dataFrame[13] == 0 && dataFrame[14] == 0){
     
221.                                    SW1 = 1;
     
222.                            }
     
223.                            led3_count = LED3_COUNT;
     
224.                 }else if(dataFrame[3] == 2 && dataFrame[4] == 0 && dataFrame[5] == 2 && dataFrame[6] == 2){
     
225.                            //设置开关2
     
226.                            if(dataFrame[7] == 1 && dataFrame[8] == 0 && dataFrame[9] == 0 && dataFrame[10] == 0 && dataFrame[11] == 0 && dataFrame[12] == 0 && dataFrame[13] == 0 && dataFrame[14] == 0){
     
227.                                  SW2 = 0;
     
228.                            }
     
229.                            else if(dataFrame[7] == 2 && dataFrame[8] == 0 && dataFrame[9] == 0 && dataFrame[10] == 0 && dataFrame[11] == 0 && dataFrame[12] == 0 && dataFrame[13] == 0 && dataFrame[14] == 0){
     
230.                                    SW2 = 1;
     
231.                            }
     
232.                            led3_count = LED3_COUNT;
     
233.                     }else if(dataFrame[3] == 2 && dataFrame[4] == 0 && dataFrame[5] == 2 && dataFrame[6] == 3){
     
234.                            //设置开关3
     
235.                            if(dataFrame[7] == 1 && dataFrame[8] == 0 && dataFrame[9] == 0 && dataFrame[10] == 0 && dataFrame[11] == 0 && dataFrame[12] == 0 && dataFrame[13] == 0 && dataFrame[14] == 0){
     
236.                                  SW3 = 0;
     
237.                            }
     
238.                            else if(dataFrame[7] == 2 && dataFrame[8] == 0 && dataFrame[9] == 0 && dataFrame[10] == 0 && dataFrame[11] == 0 && dataFrame[12] == 0 && dataFrame[13] == 0 && dataFrame[14] == 0){
     
239.                                    SW3 = 1;
     
240.                            }
     
241.                            led3_count = LED3_COUNT;
     
242.                     }else if(dataFrame[3] == 2 && dataFrame[4] == 0 && dataFrame[5] == 2 && dataFrame[6] == 4){
     
243.                            //设置开关4
     
244.                            if(dataFrame[7] == 1 && dataFrame[8] == 0 && dataFrame[9] == 0 && dataFrame[10] == 0 && dataFrame[11] == 0 && dataFrame[12] == 0 && dataFrame[13] == 0 && dataFrame[14] == 0){
     
245.                                  SW4 = 0;
     
246.                            }
     
247.                            else if(dataFrame[7] == 2 && dataFrame[8] == 0 && dataFrame[9] == 0 && dataFrame[10] == 0 && dataFrame[11] == 0 && dataFrame[12] == 0 && dataFrame[13] == 0 && dataFrame[14] == 0){
     
248.                                    SW4 = 1;
     
249.                            }
     
250.                            led3_count = LED3_COUNT;
     
251.                         }
     
252.                         dataFrame_RI = 0;     //置数据帧己读取
     
253.                         DataFrame_Put_init(); //初始化发送帧，为下一次发送数据做准备
     
254.                 }
     
255. 
     
256.                 //LED1运行指示灯闪烁，整个循环在没有接收数据时，执行一次约40us
     
257.                 if(led1_count > 0){
     
258.                   led1_count--;
     
259.                 }else{
     
260.                   if(led1_count2 == 0){
     
261.                     led1_count2 = 1;
     
262.                   }else{
     
263.                     led1_count2 = 0;
     
264.                   }
     
265.                   led1_count = LED1_COUNT;
     
266.                 }
     
267.                 if(led1_count > 0){
     
268.                   if(led1_count2 == 0){
     
269.                           LED1 = 0;
     
270.                   }else{
     
271.                     LED1 = 1;
     
272.                   }
     
273.                   led1_count--;                                    
     
274.                 }
     
275. 
     
276.                 //收到心跳灯亮20秒
     
277.                 if(led2_count > 0){
     
278.                   LED2 = 0;
     
279.                   led2_count--;
     
280.                 }else{
     
281.                   LED2 = 1;
     
282.                 }
     
283. 
     
284.                 //有数据接收闪一下
     
285.                 if(led3_count > 0){
     
286.                   LED3 = 0;
     
287.                   led3_count--;
     
288.                 }else{
     
289.                   LED3 = 1;
     
290.                 }
     
291. 
     
292.                 //有数据发送闪一下
     
293.                 if(led4_count > 0){
     
294.                   LED4 = 0;
     
295.                   led4_count--;
     
296.                 }else{
     
297.                   LED4 = 1;
     
298.                 }
     
299. 
     
300.         }
     
301. 
     
302.         while(1);
     
303. }
     
304. 
     
305. //初始化输出帧
     
306. void DataFrame_Put_init(){
     
307.    DataFrame_Put[3] = 0;
     
308.    DataFrame_Put[4] = 0;
     
309.    DataFrame_Put[5] = 0;
     
310.    DataFrame_Put[6] = 0;
     
311.    DataFrame_Put[7] = 0;
     
312.    DataFrame_Put[8] = 0;
     
313.    DataFrame_Put[9] = 0;
     
314.    DataFrame_Put[10] = 0;
     
315.    DataFrame_Put[11] = 0;
     
316.    DataFrame_Put[12] = 0;
     
317.    DataFrame_Put[13] = 0;
     
318.    DataFrame_Put[14] = 0;
     
319. }
     
320. 
     
321. //初始化温度值
     
322. void TEMP_init_var(){
     
323.     ds_M = 0;
     
324.     ds_L = 0;
     
325.         symbol = 0;     //符号位
     
326.         hundreds = 0;   //百位
     
327.         decade = 0;     //十位
     
328.         unit = 0;       //个位
     
329.         decimal = 0;    //小数1位
     
330. }
     
331. 
     
332. //初始化
     
333. void UART_init()
     
334. {
     
335.         TMOD = 0x20;          //T1工作模式2  8位自动重装
     
336.         TH1 = 0xfd;
     
337.         TL1 = 0xfd;         //比特率9600
     
338.         TR1 = 1;                //启动T1定时器
     
339.         SM0 = 0;
     
340.         SM1 = 1;                 //串口工作方式1 10位异步
     
341.         REN = 1;                //串口允许接收
     
342.         EA  = 1;                //开总中断
     
343.         ES  = 1;                //串口中断打开
     
344. }
     
345. 
     
346. //串口发送一帧数据函数，一帧16个字节
     
347. void PutFrame(uchar *TXStr)  
     
348. {   
     
349.          uchar i = 0;
     
350.          while(1){
     
351.            SBUF=*TXStr;
     
352.            while(TI == 0);  //对方接收后TI置1,停止等待
     
353.            TI = 0;
     
354.            i++;
     
355.            if(i > 15){break;}
     
356.            TXStr++;
     
357.      }
     
358. }
     
359. 
     
360. void UART() interrupt 4
     
361. {
     
362.    if(RI)   //检测是否接收完成
     
363.    {
     
364.      uchar temp = SBUF;
     
365.          RI = 0;
     
366.          // 如果接收的一帧，第一个字节不是包头标志，则抛弃这个字节
     
367.          if(dataFrame_temp_count == 0)
     
368.          {
     
369.             if(temp != DATAFRAME_HEAD)
     
370.                         return;
     
371.          }
     
372.          //如果接收的一帧，最后一个字节不是包尾标志，则抛弃这帧数据
     
373.          if(dataFrame_temp_count == 15)
     
374.          {
     
375.             if(temp != DATAFRAME_TAIL){
     
376.                   dataFrame_temp_count = 0;
     
377.                   return;
     
378.                 }               
     
379.          }
     
380.      //将接收的一个字节装入缓冲区
     
381.      dataFrame_temp[dataFrame_temp_count] = temp;
     
382.          dataFrame_temp_count++;
     
383. 
     
384.          //如果一帧数据接收完
     
385.          if(dataFrame_temp_count >= 16){
     
386.             //如果上一帧还没有读取，则抛弃这一帧
     
387.                 if(dataFrame_RI == 1){
     
388.                         dataFrame_temp_count = 0;
     
389.                         return;
     
390.                 }
     
391. 
     
392.                 //拷贝一帧数据，并置这一帧数数没有读取
     
393.                 dataFrame[0] = dataFrame_temp[0];
     
394.                 dataFrame[1] = dataFrame_temp[1];
     
395.                 dataFrame[2] = dataFrame_temp[2];
     
396.                 dataFrame[3] = dataFrame_temp[3];
     
397.                 dataFrame[4] = dataFrame_temp[4];
     
398.                 dataFrame[5] = dataFrame_temp[5];
     
399.                 dataFrame[6] = dataFrame_temp[6];
     
400.                 dataFrame[7] = dataFrame_temp[7];
     
401.                 dataFrame[8] = dataFrame_temp[8];
     
402.                 dataFrame[9] = dataFrame_temp[9];
     
403.                 dataFrame[10] = dataFrame_temp[10];
     
404.                 dataFrame[11] = dataFrame_temp[11];
     
405.                 dataFrame[12] = dataFrame_temp[12];
     
406.                 dataFrame[13] = dataFrame_temp[13];
     
407.                 dataFrame[14] = dataFrame_temp[14];
     
408.                 dataFrame[15] = dataFrame_temp[15];
     
409.                
     
410.                 dataFrame_temp_count = 0;
     
411.                 dataFrame_RI = 1;
     
412.          }
     
413.    }
     
414. }

复制代码

---

作者: wulin    时间: 2018-4-8 21:23
串口接收使用查询法，放弃使用中断法，这样可以避免与其他应用程序发生冲突。

---

作者: 沧浪    时间: 2018-4-8 22:40
在进行DS18B20查询之前把中断给关掉不就好了吗

---

作者: duwen009    时间: 2018-4-9 09:08

沧浪 发表于 2018-4-8 22:40
在进行DS18B20查询之前把中断给关掉不就好了吗

中断关了，如果这时串口有数据来到，串口数据就会丢失。

---

作者: duwen009    时间: 2018-4-9 12:46

wulin 发表于 2018-4-8 21:23
串口接收使用查询法，放弃使用中断法，这样可以避免与其他应用程序发生冲突。

如果使用查询法，单片机不能一直只查询串口有没有数据来到。同时还要l轮询DS18B20的温度数据，查询一个DS18B20 时间就早己超过1毫秒，如果查询几个，还执行其他的操作，如1602显示的话，就会更长。

9600波特率下，串口收取数据，下一个字节数据接收完成前，约有1毫秒的时间，要把数据取走，不然串口就会丢弃接收的数据。这样，在查询其他器件时，串口还是会丢数据。

感觉查询法似乎不行

---

作者: wulin    时间: 2018-4-9 15:33

duwen009 发表于 2018-4-9 12:46
如果使用查询法，单片机不能一直只查询串口有没有数据来到。同时还要l轮询DS18B20的温度数据，查询一个DS ...

你如果无法协调使用时间片轮询处理多任务管理，这通讯协议就要修改。上位机每发送一个字节需要等待下位机应答后才能发送下一个字节。你的程序写得很啰嗦，会占用MCU很多时间，DS18B20是单总线器件，不必开多个I/O口。串口中断里也不要处理非必须的事务，信息保存后由主程序处理。

---

作者: duwen009    时间: 2018-4-9 19:50

wulin 发表于 2018-4-9 15:33
你如果无法协调使用时间片轮询处理多任务管理，这通讯协议就要修改。上位机每发送一个字节需要等待下位机 ...

新手，这是第一个51单片机程序，想在电脑上显示采集的温度，和控制继电器开关，程序是很啰嗦。

我又想了一种方法，把这样的通讯写出来，串口收发数据，同时操作其他的不影响。不知别人有没有这么实现的。打了个草稿。用两个51单片机来弄，相当于两个进程在工作。两个单片机传数据用轮询，不使用中断，用逻辑来判断。
发送端代码写出来了，接收端还没有写。还要再想想，大家一般是怎么弄的。写的很费劲，要想很久。
通讯的方法打了个草稿。四根线实现单向通讯。八根线实现双向通讯。



发送端代码

1. #include        "config.h"
   
2. 
   
3. #define dataFrame_headFlag 254   //用于串口通信时，定义数据帧头部的验证标记
   
4. #define dataFrame_tailFlag 255   //用于串口通信时，定义数据帧尾部的验证标记
   
5. 
   
6. #define deviceID_1Bit 0        //用于串口通信时，定义本地设备ID的第1位
   
7. #define deviceID_2Bit 1        //用于串口通信时，定义本地设备ID的第2位
   
8. 
   
9. //定义DS18B20查询包，查询控制位0,0,1,1
   
10. uchar DataFrame_DS18B20[16]={dataFrame_headFlag,deviceID_1Bit,deviceID_2Bit,0,0,1,1,0,0,0,0,0,0,0,0,dataFrame_tailFlag};
    
11. //定义心跳包
    
12. uchar DataFrame_HeartBeat[16]={dataFrame_headFlag,deviceID_1Bit,deviceID_2Bit,0,0,0,1,0,0,0,0,0,0,0,0,dataFrame_tailFlag};
    
13. 
    
14. 
    
15. uchar DWBusPutFrame_byte;                          //正在发送的byte
    
16. uchar DWBusPutFrame_bitCount;                  //己发送bit计数
    
17. uchar DWBusPutFrame_byteCount;                  //己发送的byte计数
    
18. 
    
19. uchar DWBusPutFrame_buf[16];          //一帧数据缓冲区,16个字节
    
20. uchar DWBusPutFrame_buf_isPut = 0;    //缓冲区发送标志，0 不发送，1 发送
    
21. 
    
22. uchar DWBusPutFrame_step;                          //步骤
    
23. 
    
24. //发送数据
    
25. void DWBusPutFrame()
    
26. {
    
27.   if(DWBusPutFrame_step == 0){
    
28.            DWBusPutFrame_byte = DWBusPutFrame_buf[DWBusPutFrame_byteCount];
    
29.          DWBusPutFrame_byteCount++;
    
30.          DWBusPutFrame_step = 1;
    
31.          if(DWBusPutFrame_byteCount >=16){
    
32.                 DWBusPutFrame_byte = 0;
    
33.             DWBusPutFrame_bitCount = 0;
    
34.                 DWBusPutFrame_byteCount = 0;
    
35.             DWBusPutFrame_step = 0;
    
36.                 DWBusPutFrame_buf_isPut = 0;  //置不发送，因为数据己发送
    
37.          }
    
38.   }
    
39.   if(DWBusPutFrame_step == 1){
    
40.      if(DWBusPutFrame_bitCount == 0){  //发送开始位
    
41.                    D1 = 0;_nop_();
    
42.                 D2 = 0;_nop_();
    
43.                 C1 = 0;_nop_();
    
44.          }
    
45.          if(DWBusPutFrame_bitCount > 0 && DWBusPutFrame_bitCount < 9){        //发送数据
    
46.             if(DWBusPutFrame_byte & 0x80){
    
47.                       D1 = 1;_nop_();
    
48.                    D2 = 0;_nop_();
    
49.                    C1 = 0;_nop_();
    
50.             }else{
    
51.                D1 = 0;_nop_();
    
52.                    D2 = 1;_nop_();
    
53.                    C1 = 0;_nop_();
    
54.             }
    
55.          }
    
56.          if(DWBusPutFrame_bitCount >= 9){  //发送结束位
    
57.                    D1 = 0;_nop_();
    
58.                 D2 = 0;_nop_();
    
59.                 C1 = 0;_nop_();
    
60.          }
    
61.          DWBusPutFrame_step = 2;
    
62.   }
    
63.   if(DWBusPutFrame_step == 2){  //接收端响应 1
    
64.      if(C2 == 0){
    
65.                    D1 = 1;_nop_();
    
66.                 D2 = 1;_nop_();
    
67.                 C1 = 1;_nop_();
    
68.                 DWBusPutFrame_step = 3;         
    
69.          }
    
70.   }
    
71.   if(DWBusPutFrame_step == 3){         //接收端响应 2
    
72.            if(C2 == 1){
    
73.                  DWBusPutFrame_bitCount++;     //完成1Bit发送
    
74.                 if(DWBusPutFrame_bitCount > 1 && DWBusPutFrame_bitCount < 10){
    
75.                    DWBusPutFrame_byte <<= 1;  //左移一位                  
    
76.             }
    
77.                 if(DWBusPutFrame_bitCount >= 10){
    
78.                    DWBusPutFrame_byte = 0;
    
79.             }
    
80.                 DWBusPutFrame_step = 0;
    
81.          }
    
82.   }
    
83. }
    
84. 
    
85. int i = 0;
    
86. void main()
    
87. {
    
88.         for(i = 0;i<16;i++){
    
89.                 DWBusPutFrame_buf[i] = DataFrame_DS18B20[i];
    
90.         }
    
91.         DWBusPutFrame_buf_isPut = 1;
    
92.         //开始轮询发送数据
    
93.         while(1){
    
94.           DWBusPutFrame();
    
95.         }
    
96.    
    
97.         while(1);
    
98. }
    
99. 
    
100. 
     

复制代码

---

作者: duwen009    时间: 2018-4-9 19:57

wulin 发表于 2018-4-9 15:33
你如果无法协调使用时间片轮询处理多任务管理，这通讯协议就要修改。上位机每发送一个字节需要等待下位机 ...

用两个51单片机实现多任务，每个51单片机执行不同的任务。
两个单片机通信，不能用串口，因为被占用了。也不能用中断，不然会引响时序。
用轮询，有好的稳定的实例吗？

---

作者: duwen009    时间: 2018-4-9 23:05
看到了用这个 RTX51 Tiny 可以让51单片机实现多任务，得研究一下。这样就可以实现收数据时，同时执行查询DS18B20温度。

---

作者: 笨笨兔    时间: 2018-12-27 13:04
软件结构问题。
你可以定义标志位，有发送标志，发送数据；有接收数据完成标志，处理接收数据；有屏刷新标志，刷新屏幕。。。。。。

---

作者: 周超然    时间: 2018-12-27 17:18
楼上有人说的是对的
我今天也写了类似代码，你串口检测接受。当你采集温度的时候，把串口中断关闭。
还有就是你的显示，你可以先判断下数据改变了，在去刷屏显示。没有必要接受到数据就是显示，做个判断也是对资源合理利用

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1