标题: 关于第七届蓝桥杯单片机温度记录器程序问题 [打印本页]

---

作者: kyrie1997    时间: 2018-12-4 22:54
标题: 关于第七届蓝桥杯单片机温度记录器程序问题
最近我在蓝桥杯第七届温度记录器的程序时，到最后一步是采集温度，程序出现问题调试不了。温度值一直显示为0，我想把读到的十个温度数据放到一个数组内，然后要用时从数组内调出来，但是貌似数据没录入数组内，跪求各位大神帮忙看看程序。我是用郭天祥的开发板调的程序，跟大赛的板子稍微不一样。

我用郭天祥单片机开发板写的温度记录器程序，发现程序前两个功能可以实现。但是到最后温度采集上一直采集不了温度数据，我是将十个温度数据放到一个数组内，然后在从数组内调用出来给显示函数的。但是发现温度显示一直为00，再者就是8.5的显示异常现象。之前我单独测试温度程序时是单个温度值采集发现程序可行，然后我就直接加下去大程序里，发现功能不能实现。多个温度值采集如何实现呢？跪求各位大佬解答


单片机源码：

1. #include<reg52.h>
   
2. #include <stdio.h>
   
3. #define uchar unsigned char
   
4. #define unit unsigned int
   
5. #define key_input P3
   
6. sbit ds=P2^2;     //温度传感器信号线
   
7. sbit wela=P2^7;
   
8. sbit dula=P2^6;
   
9. sbit dscs=P1^4;
   
10. sbit dsas=P1^5;
    
11. sbit dsrw=P1^6;
    
12. sbit dsrd=P1^7;
    
13. sbit beep=P2^3;
    
14. bit flag;
    
15. unit temp;
    
16. 
    
17. float f_temp;
    
18. uchar jiange[]={1,5,30,60};
    
19. uchar code table_wela1[]={0xf7,0xef,0xdf};
    
20. uchar code table_wela[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf};
    
21. unsigned char code smg[]={
    
22. 0x3f,0x06,0x5b,0x4f,
    
23. 0x66,0x6d,0x7d,0x07,
    
24. 0x7f,0x6f};
    
25. uchar key1,key2,key_press,key_number,addr,i;
    
26. 
    
27. uchar key_scan(key_number)
    
28. {
    
29.         static uchar key_state=0;
    
30.         key_input=0xf0;
    
31.         key1=key_input&0xf0;
    
32.         key_input=0x0f;
    
33.         key2=key_input&0x0f;
    
34.         key_press=key1|key2;
    
35.         switch(key_state)
    
36.         {
    
37.                 case 0:
    
38.                                 if(key_press!=0xff)
    
39.                                 {
    
40.                                         key_state=1;
    
41.                                 }
    
42.                                 break;
    
43.                                 
    
44.                 case 1:
    
45.                                 if(key_press!=0xff)
    
46.                                 {
    
47.                                         switch(key_press)
    
48.                                         {
    
49.                                                 case 0x77:  key_number=2;
    
50.                                                                         break;
    
51.                                                 case 0x7b:  key_number=3;
    
52.                                                                         break;
    
53.                                                 case 0x7d:  key_number=4;
    
54.                                                                         break;
    
55.                                                 case 0x7e:  key_number=5;
    
56.                                                                         break;
    
57.                                         }
    
58.                                         key_state=2;
    
59.                                 }
    
60.                                 else
    
61.                                 {
    
62.                                         key_state=0;
    
63.                                 }
    
64.                                 break;
    
65.                 case 2:
    
66.                                 if(key_press==0xff)
    
67.                                 {
    
68.                                         key_state=0;
    
69.                                 }
    
70.                                 break;        
    
71.         }
    
72.         return key_number;
    
73. }
    
74. 
    
75. 
    
76. 
    
77. void Timer1Init(void)                //1毫秒@11.0592MHz
    
78. {
    
79.         /*AUXR |= 0x40;        */        //定时器时钟1T模式
    
80.         TMOD &= 0x0F;                //设置定时器模式
    
81.         TMOD |= 0x10;                //设置定时器模式
    
82.         TL1 = 0xCD;                //设置定时初值
    
83.         TH1 = 0xD4;                //设置定时初值
    
84.         TF1 = 0;                //清除TF1标志
    
85.         TR1 = 1;                //定时器1开始计时
    
86.         EA=1;
    
87.         ET1=1;
    
88. }
    
89. 
    
90. 
    
91. 
    
92. 
    
93. 
    
94. 
    
95. ////////////
    
96. //DS18B20函数//
    
97. /////////
    
98. void delay(unit z)//延时函数
    
99. {
    
100.         unit x,y;
     
101.         for(x=z;x>0;x--)
     
102.                 for(y=110;y>0;y--);
     
103. }
     
104. 
     
105. 
     
106. 
     
107. void dsreset(void)    //18B20复位，初始化函数
     
108. {
     
109.   unit i;
     
110.   ds=0;
     
111.   i=103;
     
112.   while(i>0)i--;
     
113.   ds=1;
     
114.   i=4;
     
115.   while(i>0)i--;
     
116. }
     
117. 
     
118. bit tempreadbit(void)   //读1位函数
     
119. {
     
120.    unit i;
     
121.    bit dat;
     
122.    ds=0;i++;          //i++ 起延时作用
     
123.    ds=1;i++;i++;
     
124.    dat=ds;
     
125.    i=8;while(i>0)i--;
     
126.    return (dat);
     
127. }
     
128. 
     
129. uchar tempread(void)   //读1个字节
     
130. {
     
131.   uchar i,j,dat;
     
132.   dat=0;
     
133.   for(i=1;i<=8;i++)
     
134.   {
     
135.     j=tempreadbit();
     
136.     dat=(j<<7)|(dat>>1);   //读出的数据最低位在最前面，这样刚好一个字节在DAT里
     
137.   }
     
138.   return(dat);
     
139. }
     
140. 
     
141. void tempwritebyte(uchar dat)   //向18B20写一个字节数据
     
142. {
     
143.   unit i;
     
144.   uchar j;
     
145.   bit testb;
     
146.   for(j=1;j<=8;j++)
     
147.   {
     
148.     testb=dat&0x01;
     
149.     dat=dat>>1;
     
150.     if(testb)     //写 1
     
151.     {
     
152.       ds=0;
     
153.       i++;i++;
     
154.       ds=1;
     
155.       i=8;while(i>0)i--;
     
156.     }
     
157.     else
     
158.     {
     
159.       ds=0;       //写 0
     
160.       i=8;while(i>0)i--;
     
161.       ds=1;
     
162.       i++;i++;
     
163.     }
     
164. 
     
165.   }
     
166. }
     
167. 
     
168. void tempchange(void)  //DS18B20 开始获取温度并转换
     
169. {
     
170.   dsreset();
     
171.   delay(1);
     
172.   tempwritebyte(0xcc);  // 写跳过读ROM指令
     
173.   tempwritebyte(0x44);  // 写温度转换指令
     
174. }
     
175. 
     
176. unit get_temp()         //读取寄存器中存储的温度数据
     
177. {
     
178.   uchar a,b;
     
179. 
     
180.   dsreset();
     
181.   delay(1);
     
182.   tempwritebyte(0xcc);
     
183.   tempwritebyte(0xbe);
     
184.   a=tempread();         //读低8位
     
185.   b=tempread();         //读高8位
     
186.   temp=b;
     
187.   temp<<=8;            //两个字节组合为1个字
     
188.   temp=temp|a;
     
189.   f_temp=temp*0.0625;      //温度在寄存器中为12位 分辨率位0.0625°
     
190.   temp=f_temp*10+0.5;    //乘以10表示小数点后面只取1位，加0.5是四舍五入
     
191.   f_temp=f_temp+0.05;
     
192.   return temp;         //temp是整型
     
193. }
     
194. 
     
195. /////////////
     
196. //DS18B20函数//
     
197. //////////
     
198. 
     
199. 
     
200. /////////
     
201. //DS12C887函数//
     
202. ////////
     
203. void write_ds(uchar addr,uchar date)
     
204. {
     
205.         P0=0xff;
     
206.         dsas=1;
     
207.         dsrd=1;
     
208.         dsrw=1;
     
209.         dscs=0;
     
210.         P0=addr;
     
211.         dsas=0;
     
212.         dsrw=0;
     
213.         P0=date;
     
214.         dsas=1;
     
215.         dsrw=1;
     
216.         dscs=1;
     
217. }
     
218. 
     
219. uchar read_ds(uchar addr)
     
220. {
     
221.         uchar ds_date;
     
222.         P0=0xff;
     
223.         dscs=0;
     
224.         dsas=1;
     
225.         dsrd=1;
     
226.         dsrw=1;
     
227.         P0=addr;
     
228.         dsas=0;
     
229.         dsrd=0;
     
230.         P0=0xff;
     
231.         ds_date=P0;
     
232.         dsas=1;
     
233.         dsrd=1;
     
234.         dscs=1;
     
235.         return ds_date;
     
236. }
     
237. ///////////
     
238. //DS12C887函数//
     
239. //////////
     
240. 
     
241. unit cishu,wenshi,wenge;
     
242. unit caiyang_time;
     
243. bit temp_flag;
     
244. 
     
245. uchar wendu[2];
     
246. char miaoshi,miaoge,fenshi,fenge,shishi,shige,shi,fen,miao,realjiange;
     
247. uchar munu;
     
248. uchar munu1[8];
     
249. uchar munu2[6];
     
250. uchar munu3[6];
     
251. unit temperature[10];
     
252. void main()
     
253. {        
     
254.         uchar display_cishu=0;
     
255.         uchar temp,jiange_count;
     
256.         Timer1Init();
     
257.         while(1)
     
258.         {
     
259.                 miao=read_ds(0);
     
260.                 miaoshi=miao/10;
     
261.                 miaoge=miao%10;
     
262.                 munu2[4]=smg[miaoshi];
     
263.                 munu2[5]=smg[miaoge];        
     
264.                 fen=read_ds(2);
     
265.                 fenshi=fen/10;
     
266.                 fenge=fen%10;
     
267.                 munu2[2]=smg[fenshi];
     
268.                 munu2[3]=smg[fenge];
     
269.                 shi=read_ds(4);
     
270.                 shishi=shi/10;
     
271.                 shige=shi%10;
     
272.                 munu2[0]=smg[shishi];
     
273.                 munu2[1]=smg[shige];
     
274. 
     
275. 
     
276.                 munu1[0]=0x40;
     
277.                 munu1[1]=smg[jiange[jiange_count]/10];
     
278.                 munu1[2]=smg[jiange[jiange_count]%10];
     
279. 
     
280.                
     
281.                 if(flag==1)
     
282.                 {
     
283.                         temp=key_scan(key_number);
     
284.                         flag=0;
     
285.                         switch(temp)
     
286.                         {
     
287.                                 case 2:        
     
288.                                                 jiange_count++;
     
289.                                                 i=0;
     
290.                                                 if(jiange_count==4)
     
291.                                                 {
     
292.                                                         jiange_count=0;
     
293.                                                 }
     
294.                                                 break;
     
295. 
     
296.                                 case 3:        
     
297.                                                 munu=1;
     
298.                                                 i=0;
     
299.                                                 write_ds(0,55);
     
300.                                                 write_ds(2,59);
     
301.                                                 write_ds(4,23);
     
302.                                                 realjiange=jiange[jiange_count];
     
303.                                                 break;
     
304. 
     
305.                                 case 4:        
     
306.                                                 display_cishu++;
     
307.                                                 if(display_cishu==10)
     
308.                                                 {
     
309.                                                         display_cishu=0;
     
310.                                                 }
     
311.                                                 break;               
     
312.                                 case 5:                        break;
     
313.                         }
     
314.                 }
     
315. 
     
316.                
     
317.                 if(temp_flag==1)
     
318.                 {
     
319.                
     
320.                         temp_flag=0;
     
321.                         if(caiyang_time<<10)
     
322.                         {
     
323.                                 EA=0;
     
324.                                 switch(caiyang_time)
     
325.                                 {
     
326.                                         case 0:
     
327.                                                         tempchange();
     
328.                                                     temperature[0]=get_temp();
     
329.                                                         break;
     
330. 
     
331.                                         case 1:        tempchange();
     
332.                                                     temperature[1]=get_temp();
     
333.                                                         break;
     
334. 
     
335.                                         case 2:        tempchange();
     
336.                                                     temperature[2]=get_temp();
     
337.                                                         break;
     
338. 
     
339.                                         case 3:        tempchange();
     
340.                                                     temperature[3]=get_temp();
     
341.                                                         break;
     
342. 
     
343.                                         case 4:        tempchange();
     
344.                                                     temperature[4]=get_temp();
     
345.                                                         break;
     
346. 
     
347.                                         case 5:        tempchange();
     
348.                                                     temperature[5]=get_temp();
     
349.                                                         break;
     
350. 
     
351.                                         case 6:        tempchange();
     
352.                                                     temperature[6]=get_temp();
     
353.                                                         break;
     
354. 
     
355.                                         case 7:        tempchange();
     
356.                                                     temperature[7]=get_temp();
     
357.                                                         break;
     
358. 
     
359.                                         case 8:        tempchange();
     
360.                                                     temperature[8]=get_temp();
     
361.                                                         break;
     
362. 
     
363.                                         case 9:        tempchange();
     
364.                                                     temperature[9]=get_temp();
     
365.                                                         break;
     
366.                                 }
     
367.                                 delay(1);
     
368.                                 EA=1;
     
369.                                 caiyang_time++;
     
370.                         }
     
371.                         else
     
372.                         {
     
373.                                 munu++;
     
374.                         }
     
375.                 }
     
376.                
     
377.                 if(munu==2)
     
378.                 {
     
379.                         switch(display_cishu)
     
380.                         {
     
381.                                 case 0:        munu3[0]=0x40;
     
382.                                                 munu3[1]=smg[0/10];
     
383.                                                 munu3[2]=smg[0%10];
     
384.                                                 munu3[3]=0x40;
     
385.                                                 wenshi=temperature[0]/10;
     
386.                                                 wenge=temperature[0]%10;
     
387.                                                 munu3[4]=smg[wenshi];
     
388.                                                 munu3[5]=smg[wenge];
     
389.                                                 break;
     
390. 
     
391.                                 case 1:        munu3[0]=0x40;
     
392.                                                 munu3[1]=smg[1/10];
     
393.                                                 munu3[2]=smg[1%10];
     
394.                                                 munu3[3]=0x40;
     
395.                                                 wenshi=temperature[1]/10;
     
396.                                                 wenge=temperature[1]%10;
     
397.                                                 munu3[4]=smg[wenshi];
     
398.                                                 munu3[5]=smg[wenge];
     
399.                                                 break;
     
400. 
     
401.                                 case 2:        munu3[0]=0x40;
     
402.                                                 munu3[1]=smg[2/10];
     
403.                                                 munu3[2]=smg[2%10];
     
404.                                                 munu3[3]=0x40;
     
405.                                                 wenshi=temperature[2]/10;
     
406.                                                 wenge=temperature[2]%10;
     
407.                                                 munu3[4]=smg[wenshi];
     
408.                                                 munu3[5]=smg[wenge];
     
409.                                                 break;
     
410. 
     
411.                                 case 3:munu3[0]=0x40;
     
412.                                                 munu3[1]=smg[3/10];
     
413.                                                 munu3[2]=smg[3%10];
     
414.                                                 munu3[3]=0x40;
     
415.                                                 wenshi=temperature[3]/10;
     
416.                                                 wenge=temperature[3]%10;
     
417.                                                 munu3[4]=smg[wenshi];
     
418.                                                 munu3[5]=smg[wenge];
     
419.                                                 break;
     
420. 
     
421.                                 case 4:        munu3[0]=0x40;
     
422.                                                 munu3[1]=smg[4/10];
     
423.                                                 munu3[2]=smg[4%10];
     
424.                                                 munu3[3]=0x40;
     
425.                                                 wenshi=temperature[4]/10;
     
426.                                                 wenge=temperature[4]%10;
     
427.                                                 munu3[4]=smg[wenshi];
     
428.                                                 munu3[5]=smg[wenge];
     
429.                                                 break;
     
430. 
     
431.                                 case 5:        munu3[0]=0x40;
     
432.                                                 munu3[1]=smg[5/10];
     
433.                                                 munu3[2]=smg[5%10];
     
434.                                                 munu3[3]=0x40;
     
435.                                                 wenshi=temperature[5]/10;
     
436.                                                 wenge=temperature[5]%10;
     
437.                                                 munu3[4]=smg[wenshi];
     
438.                                                 munu3[5]=smg[wenge];
     
439.                                                 break;
     
440. 
     
441.                                 case 6:        munu3[0]=0x40;
     
442.                                                 munu3[1]=smg[6/10];
     
443.                                                 munu3[2]=smg[6%10];
     
444.                                                 munu3[3]=0x40;
     
445.                                                 wenshi=temperature[6]/10;
     
446.                                                 wenge=temperature[6]%10;
     
447.                                                 munu3[4]=smg[wenshi];
     
448.                                                 munu3[5]=smg[wenge];
     
449.                                                 break;
     
450. 
     
451.                                 case 7:        munu3[0]=0x40;
     
452.                                                 munu3[1]=smg[7/10];
     
453.                                                 munu3[2]=smg[7%10];
     
454.                                                 munu3[3]=0x40;
     
455.                                                 wenshi=temperature[7]/10;
     
456.                                                 wenge=temperature[7]%10;
     
457.                                                 munu3[4]=smg[wenshi];
     
458.                                                 munu3[5]=smg[wenge];
     
459.                                                 break;
     
460. 
     
461.                                 case 8:        munu3[0]=0x40;
     
462.                                                 munu3[1]=smg[8/10];
     
463.                                                 munu3[2]=smg[8%10];
     
464.                                                 munu3[3]=0x40;
     
465.                                                 wenshi=temperature[8]/10;
     
466.                                                 wenge=temperature[8]%10;
     
467.                                                 munu3[4]=smg[wenshi];
     
468.                                                 munu3[5]=smg[wenge];
     
469.                                                 break;
     
470. 
     
471.                                 case 9:        munu3[0]=0x40;
     
472.                                                 munu3[1]=smg[9/10];
     
473.                                                 munu3[2]=smg[9%10];
     
474.                                                 munu3[3]=0x40;
     
475.                                                 wenshi=temperature[9]/10;
     
476.                                                 wenge=temperature[9]%10;
     
477.                                                 munu3[4]=smg[wenshi];
     
478.                                                 munu3[5]=smg[wenge];
     
479.                                                 break;
     
480.                         }
     
481.                 }
     
482. 
     
483.                
     
484.         }
     
485. }
     
486. 
     
487. 
     
488. void timer1() interrupt 3
     
489. {
     
490.         static uchar key_count=0,smg_count=0;
     
491.         static unit caiyang_time=0;
     
492.         TL1 = 0xCD;                //设置定时初值
     
493.         TH1 = 0xD4;                //设置定时初值
     
494.         smg_count++;
     
495.         key_count++;
     
496.         if(key_count==1)
     
497.         {
     
498.                 key_count=0;
     
499.                 flag=1;
     
500.         }
     
501.         if(smg_count==1)
     
502.         {
     
503.                 smg_count=0;
     
504.                 P0=0XFF;
     
505. 
     
506.                 if(munu==0)
     
507.                 {
     
508.                         P0=0XFF;
     
509.                         dula=1;
     
510.                         P0=munu1[i];
     
511.                         dula=0;
     
512.                         P0=0xff;
     
513.                         P0=0XFF;
     
514.                         wela=1;
     
515.                         P0=table_wela1[i];
     
516.                         wela=0;
     
517.                         P0=0XFF;
     
518.                         
     
519.                         i++;
     
520.                         if(i==3)
     
521.                         {
     
522.                                 i=0;
     
523.                         }                        
     
524.                 }
     
525.                
     
526.                 if(munu==1)
     
527.                 {
     
528.                         P0=0XFF;
     
529.                         dula=0;
     
530.                         dula=1;
     
531.                         P0=munu2[i];
     
532.                         dula=0;
     
533.                         P0=0xff;
     
534.                         wela=0;
     
535.                         P0=0XFF;
     
536.                         wela=1;
     
537.                         P0=table_wela[i];
     
538.                         wela=0;
     
539.                         P0=0XFF;
     
540.                         
     
541.                         i++;
     
542.                         if(i==6)
     
543.                         {
     
544.                                 i=0;
     
545.                         }               
     
546.                 }
     
547.         
     
548.                 if(munu==2)
     
549.                 {
     
550.                         P0=0XFF;
     
551.                         dula=0;
     
552.                           P0=munu3[i];
     
553.                           dula=1;
     
554.                           dula=0;
     
555.                         P0=0xff;
     
556.                           wela=0;
     
557.                           P0=table_wela[i];
     
558.                           wela=1;
     
559.                           wela=0;
     
560.                         i++;
     
561.                         if(i==6)
     
562.                         {
     
563.                                 i=0;
     
564.                         }         
     
565.                 }
     
566. 
     
567.                
     
568.         }
     
569.         if(munu==1)
     
570.         {        
     
571.                 caiyang_time++;
     
572.                 if(caiyang_time==(realjiange*4000))//1s
     
573.                 {
     
574.                         caiyang_time=0;
     
575.                         temp_flag=1;        
     
576.                 }
     
577.         }
     
578. }

复制代码

全部资料51hei下载地址：
蓝桥杯实验-温度记录器.zip (2.7 KB, 下载次数: 49)

2018-12-4 22:42 上传

点击文件名下载附件

---

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

Powered by Discuz! X3.1