单片机多路温度压力检测系统仿真与源码(LCD1604液晶显示)

多路温度压力检测系统仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:

1. #include <reg52.h>
   
2. #include "intrins.h"                                                                                          
   
3. #include <math.H>
   
4. #define     u8                          unsigned char
   
5. #define     u16                   unsigned int
   
6. #define     uchar                          unsigned char
   
7. #define     uint                   unsigned int
   
8. 
   
9. uchar yushe_wendu=80;                                //温度预设值
   
10. uchar yushe_yali=250;                                //压力预设值
    
11. uint wendu;                                                                 //温度值全局变量
    
12. uchar yali1;                                                                 //用于读取ADC数据
    
13. uchar yali2;                                                                 //用于读取ADC数据
    
14. uchar yali3;                                                                 //用于读取ADC数据
    
15. uchar yali4;                                                                 //用于读取ADC数据
    
16. 
    
17. //运行模式  
    
18. uchar Mode=0;                                                                 //=1是设置温度阀值  =2是设置压力阀值        =0是正常监控模式
    
19. //管脚声明
    
20. 
    
21. sbit Buzzer             =P2^3;                                 //蜂鸣器
    
22. sbit Fan         =P1^7;
    
23. //定义三个设置按键
    
24. sbit Key_SET = P2^4;
    
25. sbit Key_ADD = P2^5;
    
26. sbit Key_SUB = P2^6;
    
27. sbit Key_OK  = P2^7;
    
28. 
    
29. 
    
30. 
    
31. sbit ds1 = P1^2;
    
32. sbit ds2 = P1^3;
    
33. sbit ds3 = P1^4;
    
34. sbit ds4 = P1^5;
    
35. 
    
36. /********************************************************************
    
37. * 名称 : delay_1ms()
    
38. * 功能 : 延时1ms函数
    
39. * 输入 : q
    
40. * 输出 : 无
    
41. ***********************************************************************/
    
42. void delay_ms(uint q)
    
43. {
    
44.         uint i,j;
    
45.         for(i=0;i<q;i++)
    
46.                 for(j=0;j<110;j++);
    
47. }
    
48. 
    
49. 
    
50. void delayUs()
    
51. {
    
52.     _nop_();
    
53. }
    
54. 
    
55. void delayMs(uint a)
    
56. {
    
57.     uint i, j;
    
58.     for(i = a; i > 0; i--)
    
59.         for(j = 100; j > 0; j--);
    
60. }
    
61. 
    
62. /***********************************************************************************************************
    
63. LCD1604相关函数
    
64. ***********************************************************************************************************/
    
65. 
    
66. //LCD管脚声明 （RW引脚实物直接接地，因为本设计只用到液晶的写操作，RW引脚一直是低电平）
    
67. sbit LCDRS = P2^0;
    
68. sbit LCDEN = P2^2;
    
69. sbit D0                 = P0^0;
    
70. sbit D1                 = P0^1;
    
71. sbit D2                 = P0^2;
    
72. sbit D3                 = P0^3;
    
73. sbit D4                 = P0^4;
    
74. sbit D5                 = P0^5;
    
75. sbit D6                 = P0^6;
    
76. sbit D7                 = P0^7;
    
77. 
    
78. 
    
79. 
    
80. //LCD延时
    
81. void LCDdelay(uint z)                  //该延时大约100us（不精确，液晶操作的延时不要求很精确）
    
82. {
    
83.   uint x,y;
    
84.   for(x=z;x>0;x--)
    
85.     for(y=10;y>0;y--);
    
86. }
    
87. void LCD_WriteData(u8 dat)          
    
88. {
    
89.         if(dat&0x01)D0=1;else D0=0;
    
90.         if(dat&0x02)D1=1;else D1=0;
    
91.         if(dat&0x04)D2=1;else D2=0;
    
92.         if(dat&0x08)D3=1;else D3=0;
    
93.         if(dat&0x10)D4=1;else D4=0;
    
94.         if(dat&0x20)D5=1;else D5=0;
    
95.         if(dat&0x40)D6=1;else D6=0;
    
96.         if(dat&0x80)D7=1;else D7=0;
    
97. }
    
98. //写命令
    
99. void write_com(uchar com)
    
100. {
     
101.   LCDRS=0;                                  
     
102.         LCD_WriteData(com);
     
103. //  DAT=com;
     
104.   LCDdelay(5);
     
105.   LCDEN=1;
     
106.   LCDdelay(5);
     
107.   LCDEN=0;
     
108. }
     
109. //写数据
     
110. void write_data(uchar date)
     
111. {
     
112.   LCDRS=1;
     
113.         LCD_WriteData(date);
     
114. //  DAT=date;
     
115.   LCDdelay(5);
     
116.   LCDEN=1;
     
117.   LCDdelay(5);
     
118.   LCDEN=0;
     
119. }
     
120. 
     
121. /*------------------------------------------------
     
122.               选择写入位置
     
123. ------------------------------------------------*/
     
124. void SelectPosition(unsigned char x,unsigned char y)
     
125. {     
     
126.         if (x == 0)
     
127.         {     
     
128.                 write_com(0x80 + y);     //表示第一行
     
129.         }
     
130. 
     
131.         else if (x == 1)
     
132.         {      
     
133.                 write_com(0xC0 + y);      //表示第二行
     
134.         }
     
135.         else if (x == 2)
     
136.         {
     
137.             write_com(0x90 + y);
     
138.         }
     
139.         else if (x == 3)
     
140.         {
     
141.             write_com(0xD0 + y);
     
142.         }
     
143. }
     
144. /*------------------------------------------------
     
145.               写入字符串函数
     
146. ------------------------------------------------*/
     
147. void LCD_Write_String(unsigned char x,unsigned char y,unsigned char *s)
     
148. {     
     
149.         SelectPosition(x,y) ;
     
150.         while (*s)
     
151.         {     
     
152.                 write_data( *s);     
     
153.                 s++;     
     
154.         }
     
155. }
     
156. 
     
157. void writeString(uchar * str, uchar length)
     
158. {
     
159.      uchar i;
     
160.     for(i = 0; i < length; i++)
     
161.     {
     
162.          write_data(str[i]);
     
163.      }
     
164. }
     
165. 
     
166. //========================================================================
     
167. // 函数: void LCD_Write_Char(u8 x,u8 y,u16 s,u8 l)
     
168. // 应用: LCD_Write_Char(0,1,366,4) ;
     
169. // 描述: 在第0行第一个字节位置显示366的后4位,显示结果为 0366
     
170. // 参数: x:行,y:列,s:要显示的字,l:显示的位数
     
171. // 返回: none.
     
172. // 版本: VER1.0
     
173. // 日期: 2013-4-1
     
174. // 备注: 最大显示65535
     
175. //========================================================================
     
176. void LCD_Write_Char(u8 x,u8 y,u16 s,u8 l)
     
177. {     
     
178.         SelectPosition(x,y) ;
     
179. 
     
180.         if(l>=5)
     
181.                 write_data(0x30+s/10000%10);        //万位
     
182.         if(l>=4)
     
183.                 write_data(0x30+s/1000%10);                //千位
     
184.         if(l>=3)
     
185.                 write_data(0x30+s/100%10);                //百位
     
186.         if(l>=2)
     
187.                 write_data(0x30+s/10%10);                        //十位
     
188.         if(l>=1)
     
189.                 write_data(0x30+s%10);                //个位
     
190. 
     
191. }
     
192. /*1604指令简介
     
193.   write_com(0x38);//屏幕初始化
     
194.   write_com(0x0c);//打开显示 无光标 无光标闪烁
     
195.   write_com(0x0d);//打开显示 阴影闪烁
     
196.   write_com(0x0d);//打开显示 阴影闪烁
     
197. */
     
198. //1604初始化
     
199. void Init1604()
     
200. {
     
201.   uchar i=0;
     
202.   write_com(0x38);//屏幕初始化
     
203.   write_com(0x0c);//打开显示 无光标 无光标闪烁
     
204.   write_com(0x06);//当读或写一个字符是指针后一一位
     
205.   write_com(0x01);//清屏
     
206.        
     
207. }
     
208. 
     
209. void Display_1604(yali1,yali2,yali3,yali4)
     
210. {
     
211. 
     
212.           LCD_Write_Char(2,3,yali1,3) ;
     
213.           LCD_Write_Char(2,13,yali2,3) ;
     
214.           
     
215.           LCD_Write_Char(3,3,yali3,3) ;
     
216.           LCD_Write_Char(3,13,yali4,3) ;
     
217. }
     
218. 
     
219. 
     
220. 
     
221. /***********************************************************************************************************
     
222. ADC0832相关函数
     
223. ***********************************************************************************************************/
     
224. sbit ADCS1         =P1^0; //ADC0832 片选
     
225. sbit ADCLK1  =P3^1; //ADC0832 时钟
     
226. sbit ADDI1         =P3^0; //ADC0832 数据输入                /*因为单片机的管脚是双向的,且ADC0832的数据输入输出不同时进行,
     
227. sbit ADDO1         =P3^0; //ADC0832 数据输出                /*为节省单片机引脚,简化电路所以输入输出连接在同一个引脚上
     
228. 
     
229. sbit ADCS2         =P1^1; //ADC0832 片选
     
230. sbit ADCLK2  =P3^3; //ADC0832 时钟
     
231. sbit ADDI2         =P3^2; //ADC0832 数据输入                /*因为单片机的管脚是双向的,且ADC0832的数据输入输出不同时进行,
     
232. sbit ADDO2         =P3^2; //ADC0832 数据输出
     
233. 
     
234. sbit ADCS3         =P1^6; //ADC0832 片选
     
235. sbit ADCLK3  =P3^5; //ADC0832 时钟
     
236. sbit ADDI3         =P3^4; //ADC0832 数据输入                /*因为单片机的管脚是双向的,且ADC0832的数据输入输出不同时进行,
     
237. sbit ADDO3         =P3^4; //ADC0832 数据输出
     
238. 
     
239. sbit ADCS4         =P1^7; //ADC0832 片选
     
240. sbit ADCLK4  =P3^7; //ADC0832 时钟
     
241. sbit ADDI4         =P3^6; //ADC0832 数据输入                /*因为单片机的管脚是双向的,且ADC0832的数据输入输出不同时进行,
     
242. sbit ADDO4         =P3^6; //ADC0832 数据输出
     
243. 
     
244. 
     
245. //========================================================================
     
246. // 函数: unsigned int Adc0832(unsigned char channel)
     
247. // 应用:                 temp=Adc0832(0);
     
248. // 描述: 读取0通道的AD值
     
249. // 参数: channel:通道0和通道1选择
     
250. // 返回: 选取通道的AD值
     
251. // 版本: VER1.0
     
252. // 日期: 2015-05-29
     
253. // 备注:
     
254. //========================================================================
     
255. unsigned int Adc08321(unsigned char channel)
     
256. {
     
257.         uchar i=0;
     
258.         uchar j;
     
259.         uint dat=0;
     
260.         uchar ndat=0;
     
261.         uchar  Vot=0;
     
262. 
     
263.         if(channel==0)channel=2;
     
264.         if(channel==1)channel=3;
     
265.        
     
266.        
     
267.                         ADDI1=1;
     
268.                         _nop_();
     
269.                         _nop_();
     
270.                         ADCS1=0;//拉低CS端
     
271.                         _nop_();
     
272.                         _nop_();
     
273.                         ADCLK1=1;//拉高CLK端
     
274.                         _nop_();
     
275.                         _nop_();
     
276.                         ADCLK1=0;//拉低CLK端,形成下降沿1
     
277.                         _nop_();
     
278.                         _nop_();
     
279.                         ADCLK1=1;//拉高CLK端
     
280.                         ADDI1=channel&0x1;
     
281.                         _nop_();
     
282.                         _nop_();
     
283.                         ADCLK1=0;//拉低CLK端,形成下降沿2
     
284.                         _nop_();
     
285.                         _nop_();
     
286.                         ADCLK1=1;//拉高CLK端
     
287.                         ADDI1=(channel>>1)&0x1;
     
288.                         _nop_();
     
289.                         _nop_();
     
290.                         ADCLK1=0;//拉低CLK端,形成下降沿3
     
291.                         ADDI1=1;//控制命令结束
     
292.                         _nop_();
     
293.                         _nop_();
     
294.                         dat=0;
     
295.                         for(i=0;i<8;i++)
     
296.                         {
     
297.                                 dat|=ADDO1;//收数据
     
298.                                 ADCLK1=1;
     
299.                                 _nop_();
     
300.                                 _nop_();
     
301.                                 ADCLK1=0;//形成一次时钟脉冲
     
302.                                 _nop_();
     
303.                                 _nop_();
     
304.                                 dat<<=1;
     
305.                                 if(i==7)dat|=ADDO1;
     
306.                         }
     
307.                         for(i=0;i<8;i++)
     
308.                         {
     
309.                                 j=0;
     
310.                                 j=j|ADDO1;//收数据
     
311.                                 ADCLK1=1;
     
312.                                 _nop_();
     
313.                                 _nop_();
     
314.                                 ADCLK1=0;//形成一次时钟脉冲
     
315.                                 _nop_();
     
316.                                 _nop_();
     
317.                                 j=j<<7;
     
318.                                 ndat=ndat|j;
     
319.                                 if(i<7)ndat>>=1;
     
320.                         }
     
321.                         ADCS1=1;//拉低CS端
     
322.                         ADCLK1=0;//拉低CLK端
     
323.                         ADDO1=1;//拉高数据端,回到初始状态
     
324.                         dat<<=8;
     
325.                         dat|=ndat;
     
326.                         return(dat);            //return ad data
     
327. }
     
328. 
     
329. //2
     
330. 
     
331. unsigned int Adc08322(unsigned char channel)
     
332. {
     
333.         uchar i=0;
     
334.         uchar j;
     
335.         uint dat=0;
     
336.         uchar ndat=0;
     
337.         uchar  Vot=0;
     
338. 
     
339.         if(channel==0)channel=2;
     
340.         if(channel==1)channel=3;
     
341.        
     
342.        
     
343.                         ADDI2=1;
     
344.                         _nop_();
     
345.                         _nop_();
     
346.                         ADCS2=0;//拉低CS端
     
347.                         _nop_();
     
348.                         _nop_();
     
349.                         ADCLK2=1;//拉高CLK端
     
350.                         _nop_();
     
351.                         _nop_();
     
352.                         ADCLK2=0;//拉低CLK端,形成下降沿1
     
353.                         _nop_();
     
354.                         _nop_();
     
355.                         ADCLK2=1;//拉高CLK端
     
356.                         ADDI2=channel&0x1;
     
357.                         _nop_();
     
358.                         _nop_();
     
359.                         ADCLK2=0;//拉低CLK端,形成下降沿2
     
360.                         _nop_();
     
361.                         _nop_();
     
362.                         ADCLK2=1;//拉高CLK端
     
363.                         ADDI2=(channel>>1)&0x1;
     
364.                         _nop_();
     
365.                         _nop_();
     
366.                         ADCLK2=0;//拉低CLK端,形成下降沿3
     
367.                         ADDI2=1;//控制命令结束
     
368.                         _nop_();
     
369.                         _nop_();
     
370.                         dat=0;
     
371.                         for(i=0;i<8;i++)
     
372.                         {
     
373.                                 dat|=ADDO2;//收数据
     
374.                                 ADCLK2=1;
     
375.                                 _nop_();
     
376.                                 _nop_();
     
377.                                 ADCLK2=0;//形成一次时钟脉冲
     
378.                                 _nop_();
     
379.                                 _nop_();
     
380.                                 dat<<=1;
     
381.                                 if(i==7)dat|=ADDO2;
     
382.                         }
     
383.                         for(i=0;i<8;i++)
     
384.                         {
     
385.                                 j=0;
     
386.                                 j=j|ADDO2;//收数据
     
387.                                 ADCLK2=1;
     
388.                                 _nop_();
     
389.                                 _nop_();
     
390.                                 ADCLK2=0;//形成一次时钟脉冲
     
391.                                 _nop_();
     
392.                                 _nop_();
     
393.                                 j=j<<7;
     
394.                                 ndat=ndat|j;
     
395.                                 if(i<7)ndat>>=1;
     
396.                         }
     
397.                         ADCS2=1;//拉低CS端
     
398.                         ADCLK2=0;//拉低CLK端
     
399.                         ADDO2=1;//拉高数据端,回到初始状态
     
400.                         dat<<=8;
     
401.                         dat|=ndat;
     
402.                         return(dat);            //return ad data         
     
403. }
     
404. //23
     
405. unsigned int Adc08323(unsigned char channel)
     
406. {
     
407.         uchar i=0;
     
408.         uchar j;
     
409.         uint dat=0;
     
410.         uchar ndat=0;
     
411.         uchar  Vot=0;
     
412. 
     
413.         if(channel==0)channel=2;
     
414.         if(channel==1)channel=3;
     
415.        
     
416.         ADDI3=1;
     
417.                         _nop_();
     
418.                         _nop_();
     
419.                         ADCS3=0;//拉低CS端
     
420.                         _nop_();
     
421.                         _nop_();
     
422.                         ADCLK3=1;//拉高CLK端
     
423.                         _nop_();
     
424.                         _nop_();
     
425.                         ADCLK3=0;//拉低CLK端,形成下降沿1
     
426.                         _nop_();
     
427.                         _nop_();
     
428.                         ADCLK3=1;//拉高CLK端
     
429.                         ADDI3=channel&0x1;
     
430.                         _nop_();
     
431.                         _nop_();
     
432.                         ADCLK3=0;//拉低CLK端,形成下降沿2
     
433.                         _nop_();
     
434.                         _nop_();
     
435.                         ADCLK3=1;//拉高CLK端
     
436.                         ADDI3=(channel>>1)&0x1;
     
437.                         _nop_();
     
438.                         _nop_();
     
439.                         ADCLK3=0;//拉低CLK端,形成下降沿3
     
440.                         ADDI3=1;//控制命令结束
     
441.                         _nop_();
     
442.                         _nop_();
     
443.                         dat=0;
     
444.                         for(i=0;i<8;i++)
     
445.                         {
     
446.                                 dat|=ADDO3;//收数据
     
447.                                 ADCLK3=1;
     
448.                                 _nop_();
     
449.                                 _nop_();
     
450.                                 ADCLK3=0;//形成一次时钟脉冲
     
451.                                 _nop_();
     
452.                                 _nop_();
     
453.                                 dat<<=1;
     
454.                                 if(i==7)dat|=ADDO3;
     
455.                         }
     
456.                         for(i=0;i<8;i++)
     
457.                         {
     
458.                                 j=0;
     
459.                                 j=j|ADDO3;//收数据
     
460.                                 ADCLK3=1;
     
461.                                 _nop_();
     
462.                                 _nop_();
     
463.                                 ADCLK3=0;//形成一次时钟脉冲
     
464.                                 _nop_();
     
465.                                 _nop_();
     
466.                                 j=j<<7;
     
467.                                 ndat=ndat|j;
     
468.                                 if(i<7)ndat>>=1;
     
469.                         }
     
470.                         ADCS3=1;//拉低CS端
     
471.                         ADCLK3=0;//拉低CLK端
     
472.                         ADDO3=1;//拉高数据端,回到初始状态
     
473.                         dat<<=8;
     
474.                         dat|=ndat;
     
475.                         return(dat);            //return ad data      
     
476. }
     
477.        
     
478. 
     
479. //23
     
480. unsigned int Adc08324(unsigned char channel)
     
481. {
     
482.         uchar i=0;
     
483.         uchar j;
     
484.         uint dat=0;
     
485.         uchar ndat=0;
     
486.         uchar  Vot=0;
     
487. 
     
488.         if(channel==0)channel=2;
     
489.         if(channel==1)channel=3;
     
490.        
     
491.         ADDI4=1;
     
492.                         _nop_();
     
493.                         _nop_();
     
494.                         ADCS4=0;//拉低CS端
     
495.                         _nop_();
     
496.                         _nop_();
     
497.                         ADCLK4=1;//拉高CLK端
     
498.                         _nop_();
     
499.                         _nop_();
     
500.                         ADCLK4=0;//拉低CLK端,形成下降沿1
     
501.                         _nop_();
     
502.                         _nop_();
     
503.                         ADCLK4=1;//拉高CLK端
     
504.                         ADDI4=channel&0x1;
     
505.                         _nop_();
     
506.                         _nop_();
     
507.                         ADCLK4=0;//拉低CLK端,形成下降沿2
     
508.                         _nop_();
     
509.                         _nop_();
     
510.                         ADCLK4=1;//拉高CLK端
     
511.                         ADDI4=(channel>>1)&0x1;
     
512.                         _nop_();
     
513.                         _nop_();
     
514.                         ADCLK4=0;//拉低CLK端,形成下降沿3
     
515.                         ADDI4=1;//控制命令结束
     
516.                         _nop_();
     
517.                         _nop_();
     
518.                         dat=0;
     
519.                         for(i=0;i<8;i++)
     
520.                         {
     
521.                                 dat|=ADDO4;//收数据
     
522.                                 ADCLK4=1;
     
523.                                 _nop_();
     
524.                                 _nop_();
     
525.                                 ADCLK4=0;//形成一次时钟脉冲
     
526.                                 _nop_();
     
527.                                 _nop_();
     
528.                                 dat<<=1;
     
529.                                 if(i==7)dat|=ADDO4;
     
530.                         }
     
531.                         for(i=0;i<8;i++)
     
532.                         {
     
533.                                 j=0;
     
534.                                 j=j|ADDO4;//收数据
     
535.                                 ADCLK4=1;
     
536.                                 _nop_();
     
537.                                 _nop_();
     
538.                                 ADCLK4=0;//形成一次时钟脉冲
     
539.                                 _nop_();
     
540.                                 _nop_();
     
541.                                 j=j<<7;
     
542.                                 ndat=ndat|j;
     
543.                                 if(i<7)ndat>>=1;
     
544.                         }
     
545.                         ADCS4=1;//拉低CS端
     
546.                         ADCLK4=0;//拉低CLK端
     
547.                         ADDO4=1;//拉高数据端,回到初始状态
     
548.                         dat<<=8;
     
549.                         dat|=ndat;
     
550.                         return(dat);            //return ad data   
     
551. }
     
552.                
     
553. 
     
554. //         else if(num==4)
     
555. //         {
     
556. //                 //if(channel==0)channel=2;
     
557. //                 //        if(channel==1)channel=3;
     
558. //                         ADDI4=1;
     
559. //                         _nop_();
     
560. //                         _nop_();
     
561. //                         ADCS4=0;//拉低CS端
     
562. //                         _nop_();
     
563. //                         _nop_();
     
564. //                         ADCLK4=1;//拉高CLK端
     
565. //                         _nop_();
     
566. //                         _nop_();
     
567. //                         ADCLK4=0;//拉低CLK端,形成下降沿1
     
568. //                         _nop_();
     
569. //                         _nop_();
     
570. //                         ADCLK4=1;//拉高CLK端
     
571. //                         ADDI4=channel&0x1;
     
572. //                         _nop_();
     
573. //                         _nop_();
     
574. //                         ADCLK4=0;//拉低CLK端,形成下降沿2
     
575. //                         _nop_();
     
576. //                         _nop_();
     
577. //                         ADCLK4=1;//拉高CLK端
     
578. //                         ADDI4=(channel>>1)&0x1;
     
579. //                         _nop_();
     
580. //                         _nop_();
     
581. //                         ADCLK4=0;//拉低CLK端,形成下降沿3
     
582. //                         ADDI4=1;//控制命令结束
     
583. //                         _nop_();
     
584. //                         _nop_();
     
585. //                         dat=0;
     
586. //                         for(i=0;i<8;i++)
     
587. //                         {
     
588. //                                 dat|=ADDO4;//收数据
     
589. //                                 ADCLK4=1;
     
590. //                                 _nop_();
     
591. //                                 _nop_();
     
592. //                                 ADCLK4=0;//形成一次时钟脉冲
     
593. //                                 _nop_();
     
594. //                                 _nop_();
     
595. //                                 dat<<=1;
     
596. //                                 if(i==7)dat|=ADDO4;
     
597. //                         }
     
598. //                         for(i=0;i<8;i++)
     
599. //                         {
     
600. //                                 j=0;
     
601. //                                 j=j|ADDO4;//收数据
     
602. //                                 ADCLK4=1;
     
603. //                                 _nop_();
     
604. //                                 _nop_();
     
605. //                                 ADCLK4=0;//形成一次时钟脉冲
     
606. //                                 _nop_();
     
607. //                                 _nop_();
     
608. //                                 j=j<<7;
     
609. //                                 ndat=ndat|j;
     
610. //                                 if(i<7)ndat>>=1;
     
611. //                         }
     
612. //                         ADCS4=1;//拉低CS端
     
613. //                         ADCLK4=0;//拉低CLK端
     
614. //                         ADDO4=1;//拉高数据端,回到初始状态
     
615. //                         dat<<=8;
     
616. //                         dat|=ndat;
     
617. //                         return(dat);            //return ad data
     
618. //                
     
619. //         }
     
620. //         else;
     
621. //        
     
622. 
     
623. //         //return(dat);            //return ad data
     
624. // }
     
625. 
     
626. 
     
627. /***********************************************************************************************************
     
628. DS18B20相关函数
     
629. ***********************************************************************************************************/
     
630. 
     
631. /***********************************************************************************************************
     
632. DS18B20相关函数
     
633. ***********************************************************************************************************/
     
634. 
     
635. void ds1Init()
     
636. {
     
637.    
     
638.     unsigned int i;  
     
639.     ds1 = 0;
     
640.     i = 100;  
     
641.      while(i>0) i--;
     
642.     ds1 = 1;   
     
643.     i = 4;
     
644.      while(i>0) i--;
     
645. }
     
646. 
     
647. void ds1Wait()
     
648. {
     
649.       unsigned int i;
     
650.       while(ds1);  
     
651.       while(~ds1);
     
652.       i = 4;
     
653.       while(i > 0) i--;
     
654. }
     
655. 
     
656. 
     
657. void ds2Init()
     
658. {
     
659.    
     
660.     unsigned int i;  
     
661.     ds2 = 0;
     
662.     i = 100;  
     
663.      while(i>0) i--;
     
664.     ds2 = 1;   
     
665.     i = 4;
     
666.      while(i>0) i--;
     
667. }
     
668. 
     
669. void ds2Wait()
     
670. {
     
671.       unsigned int i;
     
672.       while(ds2);  
     
673.       while(~ds2);
     
674.       i = 4;
     
675.       while(i > 0) i--;
     
676. }
     
677. 
     
678. 
     
679. void ds3Init()
     
680. {
     
681.    
     
682.     unsigned int i;  
     
683.     ds3 = 0;
     
684.     i = 100;  
     
685.      while(i>0) i--;
     
686.     ds3 = 1;   
     
687.     i = 4;
     
688.      while(i>0) i--;
     
689. }
     
690. 
     
691. void ds3Wait()
     
692. {
     
693.       unsigned int i;
     
694.       while(ds3);  
     
695.       while(~ds3);
     
696.       i = 4;
     
697.       while(i > 0) i--;
     
698. }
     
699. 
     
700. void ds4Init()
     
701. {
     
702.    
     
703.     unsigned int i;  
     
704.     ds4 = 0;
     
705.     i = 100;  
     
706.      while(i>0) i--;
     
707.     ds4 = 1;   
     
708.     i = 4;
     
709.      while(i>0) i--;
     
710. }
     
711. 
     
712. void ds4Wait()
     
713. {
     
714.       unsigned int i;
     
715.       while(ds4);  
     
716.       while(~ds4);
     
717.       i = 4;
     
718.       while(i > 0) i--;
     
719. }
     
720. 
     
721. //************************************功能函数
     
722. bit readBit1()
     
723. {
     
724.     unsigned int i;
     
725.     bit b;
     
726.     ds1 = 0;
     
727.     i++;   
     
728.     ds1 = 1;
     
729.    i++; i++;  
     
730.     b = ds1;
     
731.     i = 8;
     
732.     while(i>0) i--;
     
733.     return b;
     
734. }
     
735. 
     
736. unsigned char readByte1()
     
737. {
     
738.     unsigned int i;
     
739.     unsigned char j, dat;
     
740.    dat = 0;
     
741.     for(i=0; i<8; i++)
     
742.     {
     
743.         j = readBit1();
     
744.       
     
745.         dat = (j << 7) | (dat >> 1);
     
746.     }
     
747.     return dat;
     
748. }
     
749. 
     
750. 
     
751. void writeByte1(unsigned char dat)
     
752. {
     
753.     unsigned int i;
     
754.     unsigned char j;
     
755.     bit b;
     
756.     for(j = 0; j < 8; j++)
     
757.     {
     
758.         b = dat & 0x01;
     
759.         dat >>= 1;
     
760.    
     
761.         if(b)   
     
762.         {
     
763.            ds1 = 0;          i++; i++;  
     
764.             ds1 = 1;   
     
765.             i = 8; while(i>0) i--;  
     
766.         }
     
767.         else  
     
768.         {
     
769.             ds1 = 0;
     
770.           i = 8; while(i>0) i--;  
     
771.             ds1 = 1;
     
772.            i++; i++;
     
773.         }
     
774.    }
     
775. }
     
776. 
     
777. 
     
778. 
     
779. //2
     
780. 
     
781. bit readBit2()
     
782. {
     
783.     unsigned int i;
     
784.     bit b;
     
785.     ds2 = 0;
     
786.     i++;   
     
787.     ds2 = 1;
     
788.    i++; i++;  
     
789.     b = ds2;
     
790.     i = 8;
     
791.     while(i>0) i--;
     
792.     return b;
     
793. }
     
794. 
     
795. unsigned char readByte2()
     
796. {
     
797.     unsigned int i;
     
798.     unsigned char j, dat;
     
799.    dat = 0;
     
800.     for(i=0; i<8; i++)
     
801.     {
     
802.         j = readBit2();
     
803.       
     
804.         dat = (j << 7) | (dat >> 1);
     
805.     }
     
806.     return dat;
     
807. }
     
808. 
     
809. 
     
810. void writeByte2(unsigned char dat)
     
811. {
     
812.     unsigned int i;
     
813.     unsigned char j;
     
814.     bit b;
     
815.     for(j = 0; j < 8; j++)
     
816.     {
     
817.         b = dat & 0x01;
     
818.         dat >>= 1;
     
819.    
     
820.         if(b)   
     
821.         {
     
822.            ds2 = 0;          i++; i++;  
     
823.             ds2 = 1;   
     
824.             i = 8; while(i>0) i--;  
     
825.         }
     
826.         else  
     
827.         {
     
828.             ds2 = 0;
     
829.           i = 8; while(i>0) i--;  
     
830.             ds2 = 1;
     
831.            i++; i++;
     
832.         }
     
833.    }
     
834. }
     
835. 
     
836. //3
     
837. 
     
838. bit readBit3()
     
839. {
     
840.     unsigned int i;
     
841.     bit b;
     
842.     ds3 = 0;
     
843.     i++;   
     
844.     ds3 = 1;
     
845.    i++; i++;  
     
846.     b = ds3;
     
847.     i = 8;
     
848.     while(i>0) i--;
     
849.     return b;
     
850. }
     
851. 
     
852. unsigned char readByte3()
     
853. {
     
854.     unsigned int i;
     
855.     unsigned char j, dat;
     
856.    dat = 0;
     
857.     for(i=0; i<8; i++)
     
858.     {
     
859.         j = readBit3();
     
860.       
     
861.         dat = (j << 7) | (dat >> 1);
     
862.     }
     
863.     return dat;
     
864. }
     
865. 
     
866. 
     
867. void writeByte3(unsigned char dat)
     
868. {
     
869.     unsigned int i;
     
870.     unsigned char j;
     
871.     bit b;
     
872.     for(j = 0; j < 8; j++)
     
873.     {
     
874.         b = dat & 0x01;
     
875.         dat >>= 1;
     
876.    
     
877.         if(b)   
     
878.         {
     
879.            ds3 = 0;          i++; i++;  
     
880.             ds3 = 1;   
     
881.             i = 8; while(i>0) i--;  
     
882.         }
     
883.         else  
     
884.         {
     
885.             ds3 = 0;
     
886.           i = 8; while(i>0) i--;  
     
887.             ds3 = 1;
     
888.            i++; i++;
     
889.         }
     
890.    }
     
891. }
     
892. //4
     
893. 
     
894. bit readBit4()
     
895. {
     
896.     unsigned int i;
     
897.     bit b;
     
898.     ds4 = 0;
     
899.     i++;   
     
900.     ds4 = 1;
     
901.    i++; i++;  
     
902.     b = ds4;
     
903.     i = 8;
     
904.     while(i>0) i--;
     
905.     return b;
     
906. }
     
907. 
     
908. unsigned char readByte4()
     
909. {
     
910.     unsigned int i;
     
911.     unsigned char j, dat;
     
912.    dat = 0;
     
913.     for(i=0; i<8; i++)
     
914.     {
     
915.         j = readBit4();
     
916.       
     
917.         dat = (j << 7) | (dat >> 1);
     
918.     }
     
919.     return dat;
     
920. }
     
921. 
     
922. 
     
923. void writeByte4(unsigned char dat)
     
924. {
     
925.     unsigned int i;
     
926.     unsigned char j;
     
927.     bit b;
     
928.     for(j = 0; j < 8; j++)
     
929.     {
     
930.         b = dat & 0x01;
     
931.         dat >>= 1;
     
932.    
     
933.         if(b)   
     
934.         {
     
935.            ds4 = 0;          i++; i++;  
     
936.             ds4 = 1;   
     
937.             i = 8; while(i>0) i--;  
     
938.         }
     
939.         else  
     
940.         {
     
941.             ds4 = 0;
     
942.           i = 8; while(i>0) i--;  
     
943.             ds4 = 1;
     
944.            i++; i++;
     
945.         }
     
946.    }
     
947. }
     
948. 
     
949. 
     
950. //发送转换命令
     
951. void sendChangeCmd(unsigned char num)
     
952. {
     
953.                  if(num==1)
     
954.                  {
     
955.                         ds1Init();   
     
956.                         ds1Wait();
     
957.                         delayMs(1);   
     
958.                         writeByte1(0xcc);
     
959.                         writeByte1(0x44);
     
960.                  }
     
961.                 else if(num==2)
     
962.                 {
     
963.                         ds2Init();   
     
964.                         ds2Wait();
     
965.                                  delayMs(1);   
     
966.       writeByte2(0xcc);
     
967.      writeByte2(0x44);
     
968.                 }       
     
969.                 else if(num==3)
     
970.                 {
     
971.                         ds3Init();   
     
972.                         ds3Wait();
     
973.                          delayMs(1);   
     
974.     writeByte3(0xcc);
     
975.     writeByte3(0x44);
     
976.                 }       
     
977.                 else if(num==4)
     
978.                 {
     
979.                         ds4Init();   
     
980.                         ds4Wait();
     
981.                          delayMs(1);   
     
982.     writeByte4(0xcc);
     
983.     writeByte4(0x44);
     
984.                 }       
     
985.                 else;
     
986.    
     
987. }
     
988. 
     
989. void sendReadCmd(unsigned char num)
     
990. {
     
991.    if(num==1)
     
992.                  {
     
993.                                 ds1Init();   
     
994.                                 ds1Wait();
     
995.                           delayMs(1);
     
996.                                 writeByte1(0xcc);
     
997.                                 writeByte1(0xbe);
     
998.                  }
     
999.                 else if(num==2)
     
1000.                 {
      
1001.                                 ds2Init();   
      
1002.                                 ds2Wait();
      
1003.                                 delayMs(1);
      
1004.                                 writeByte2(0xcc);
      
1005.                                 writeByte2(0xbe);
      
1006.                 }       
      
1007.                 else if(num==3)
      
1008.                 {
      
1009.                                 ds3Init();   
      
1010.                                 ds3Wait();
      
1011.                          delayMs(1);
      
1012.                                 writeByte3(0xcc);
      
1013.                                 writeByte3(0xbe);
      
1014.                 }       
      
1015.                 else if(num==4)
      
1016.                 {
      
1017.                         ds4Init();   
      
1018.                         ds4Wait();
      
1019.                          delayMs(1);
      
1020.                         writeByte4(0xcc);
      
1021.                         writeByte4(0xbe);
      
1022.                 }       
      
1023.                 else;
      
1024.    
      
1025. }
      
1026. 
      
1027. 
      
1028. int getTmpValue(unsigned char num)
      
1029. {
      
1030.     unsigned int tmpvalue;
      
1031.     int value;
      
1032.     float t;
      
1033.     unsigned char low, high;
      
1034.     sendReadCmd(num);
      
1035.    
      
1036.         if(num==1)
      
1037.         {
      
1038.     low = readByte1();
      
1039.     high = readByte1();
      
1040.         }
      
1041.         else if(num==2)
      
1042.         {
      
1043.                 low = readByte2();
      
1044.     high = readByte2();
      
1045.         }
      
1046.         else if(num==3)
      
1047.         {
      
1048.                 low = readByte3();
      
1049.     high = readByte3();
      
1050.         }
      
1051.         else if(num==4)
      
1052.         {
      
1053.                 low = readByte4();
      
1054.     high = readByte4();
      
1055.         }
      
1056.         else;
      
1057.     tmpvalue = high;
      
1058.     tmpvalue <<= 8;
      
1059.     tmpvalue |= low;
      
1060.     value = tmpvalue;
      
1061.    
      
1062.   \
      
1063.     t = value * 0.0625;
      
1064.     \
      
1065.     value = t * 100 + (value > 0 ? 0.5 : -0.5); //大于0加0.5, 小于0减0.5
      
1066.     return value;
      
1067. }
      
1068. 
      
1069. void display(int v, unsigned char num)
      
1070. {
      
1071.     unsigned char count;
      
1072.     unsigned char datas[] = {0, 0, 0, 0, 0};
      
1073.     unsigned int tmp = abs(v);
      
1074.     datas[0] = tmp / 10000;
      
1075.     datas[1] = tmp % 10000 / 1000;
      
1076.     datas[2] = tmp % 1000 / 100;
      
1077.     datas[3] = tmp % 100 / 10;
      
1078.     datas[4] = tmp % 10;
      
1079. if(num==1)
      
1080. {
      
1081.     write_com(0x80+2);
      
1082.     if(v < 0)
      
1083.     {
      
1084.         writeString("-", 1);
      
1085.    }
      
1086.     else
      
1087.     {
      
1088.        writeString("+", 1);
      
1089.     }
      
1090.     if(datas[0] != 0)
      
1091.     {
      
1092.         write_data('0'+datas[0]);
      
1093.     }
      
1094.     for(count = 1; count != 4; count++)
      
1095.     {
      
1096.         write_data('0'+datas[count]);
      
1097.         if(count == 2)
      
1098.         {
      
1099.             write_data('.');
      
1100.         }
      
1101.     }
      
1102.         }
      
1103.         else if(num==2)
      
1104. {
      
1105.     write_com(0x80+11);
      
1106.     if(v < 0)
      
1107.     {
      
1108.         writeString("-", 1);
      
1109.    }
      
1110.     else
      
1111.     {
      
1112.        writeString("+", 1);
      
1113.     }
      
1114.     if(datas[0] != 0)
      
1115.     {
      
1116.         write_data('0'+datas[0]);
      
1117.     }
      
1118.     for(count = 1; count != 4; count++)
      
1119.     {
      
1120.         write_data('0'+datas[count]);
      
1121.         if(count == 2)
      
1122.         {
      
1123.             write_data('.');
      
1124.         }
      
1125.     }
      
1126.         }
      
1127.         else if(num==3)
      
1128. {
      
1129.     write_com(0xc0+2);
      
1130.     if(v < 0)
      
1131.     {
      
1132.         writeString("-", 1);
      
1133.    }
      
1134.     else
      
1135.     {
      
1136.        writeString("+", 1);
      
1137.     }
      
1138.     if(datas[0] != 0)
      
1139.     {
      
1140.         write_data('0'+datas[0]);
      
1141.     }
      
1142.     for(count = 1; count != 4; count++)
      
1143.     {
      
1144.         write_data('0'+datas[count]);
      
1145.         if(count == 2)
      
1146.         {
      
1147.             write_data('.');
      
1148.         }
      
1149.     }
      
1150.         }
      
1151.         else if(num==4)
      
1152. {
      
1153.     write_com(0xC0+11);
      
1154.     if(v < 0)
      
1155.     {
      
1156.         writeString("-", 1);
      
1157.    }
      
1158.     else
      
1159.     {
      
1160.        writeString("+", 1);
      
1161.     }
      
1162.     if(datas[0] != 0)
      
1163.     {
      
1164.         write_data('0'+datas[0]);
      
1165.     }
      
1166.     for(count = 1; count != 4; count++)
      
1167.     {
      
1168.         write_data('0'+datas[count]);
      
1169.         if(count == 2)
      
1170.         {
      
1171.             write_data('.');
      
1172.         }
      
1173.     }
      
1174.         }
      
1175. }
      
1176. /**//*****************************DS18B20*******************************/
      
1177. 
      
1178. 
      
1179. 
      
1180. /***********************************************************************************************************
      
1181. 按键检测相关函数
      
1182. ***********************************************************************************************************/
      
1183. //按键
      
1184. sbit Key1=P1^6;                                 //设置键
      
1185. sbit Key2=P1^7;                                 //加按键
      
1186. sbit Key3=P3^2;                                 //减按键
      
1187. 
      
1188. 
      
1189. 
      
1190. #define KEY_SET                 1                //设置
      
1191. #define KEY_ADD                        2                //加
      
1192. #define KEY_MINUS                3                //减
      
1193. 
      
1194. 
      
1195. //========================================================================
      
1196. // 函数: u8 Key_Scan()
      
1197. // 应用: temp=u8 Key_Scan();
      
1198. // 描述: 按键扫描并返回按下的键值
      
1199. // 参数: NONE
      
1200. // 返回: 按下的键值
      
1201. // 版本: VER1.0
      
1202. // 日期: 2015-05-29
      
1203. // 备注: 该函数带松手检测,按下键返回一次键值后返回0,直至第二次按键按下
      
1204. //========================================================================
      
1205. u8 Key_Scan()
      
1206. {         
      
1207.         static u8 key_up=1;//按键按松开标志
      
1208.         if(key_up&&(Key1==0||Key2==0||Key3==0))
      
1209.         {
      
1210.                 delay_ms(10);//去抖动
      
1211.                 key_up=0;
      
1212.                 if(Key1==0)                        return 1;
      
1213.                 else if(Key2==0)return 2;
      
1214.                 else if(Key3==0)return 3;
      
1215.         }
      
1216.         else if(Key1==1&&Key2==1&&Key3==1)
      
1217.                 key_up=1;             
      
1218.         return 0;// 无按键按下
      
1219. }
      
1220. 
      
1221. unsigned char table1[] = "T1";
      
1222.         unsigned char table2[] = "T2";
      
1223.         unsigned char table3[] = "T3";
      
1224.         unsigned char table4[] = "T4";
      
1225.   unsigned char table5[] = "P1";
      
1226.         unsigned char table6[] = "P2";
      
1227.         unsigned char table7[] = "P3";
      
1228.         unsigned char table8[] = "P4";
      
1229. 
      
1230. void main (void)
      
1231. {
      
1232.         u8 key;
      
1233.        
      
1234.         Init1604();                          //调用初始化显示函数
      
1235. 
      
1236. //         LCD_Write_String(0,0,"NOW T:00.0 P:000");
      
1237. //         LCD_Write_String(1,0,"NOW T:00.0 P:000");
      
1238. //   LCD_Write_String(2,0,"NOW T:00.0 P:000");
      
1239.        
      
1240.     write_com(0x80);
      
1241.     writeString(table1, 2);
      
1242.           write_com(0x89);
      
1243.     writeString(table2, 2);
      
1244.                 write_com(0xc0);
      
1245.     writeString(table3, 2);
      
1246.                 write_com(0xc9);
      
1247.     writeString(table4, 2);
      
1248.        
      
1249.                 write_com(0x90);
      
1250.     writeString(table5, 2);
      
1251.           write_com(0x99);
      
1252.     writeString(table6, 2);
      
1253.                 write_com(0xd0);
      
1254.     writeString(table7, 2);
      
1255.                 write_com(0xd9);
      
1256.     writeString(table8, 2);
      
1257.                 delay_ms(1000);
      
1258. 
      
1259.         while (1)                                                //主循环
      
1260.         {
      
1261.                 key=Key_Scan();                                        //按键扫描
      
1262.                 yali1=Adc08321(0);                                //读取烟雾值
      
1263.                 delay_ms(10);
      
1264.                 yali2=Adc08322(0);                                //读取烟雾值
      
1265.                 delay_ms(10);
      
1266.                 yali3=Adc08323(0);                                //读取烟雾值
      
1267.                 delay_ms(10);
      
1268.                 yali4=Adc08324(0);                                //读取烟雾值
      
1269.                 delay_ms(10);
      
1270. //                 yali2=Adc0832(0,2);                                //读取烟雾值
      
1271.                         write_com(0xc0);
      
1272.     display(getTmpValue(1),1);
      
1273.     sendChangeCmd(1);
      
1274.                        
      
1275.                 write_com(0xc0);
      
1276.     display(getTmpValue(2),2);
      
1277.     sendChangeCmd(2);
      
1278.                        
      
1279.                 write_com(0xc0);
      
1280.     display(getTmpValue(3),3);
      
1281.     sendChangeCmd(3);
      
1282.                        
      
1283.           write_com(0xc0);
      
1284.     display(getTmpValue(4),4);
      
1285.     sendChangeCmd(4);
      
1286.                
      
1287.                 if(key==KEY_SET)
      
1288.                 {
      
1289.                         Mode++;
      
1290.                 }
      
1291.                
      
1292.                 switch(Mode)                                                //判断模式的值
      
1293.                 {
      
1294.                         case 0:                                                                //监控模式
      
1295.                         {
      
1296.                                 Display_1604(yali1,yali2,yali3,yali4);  //显示预设温度，预设烟雾，温度值，烟雾值
      
1297.                                 if(yali1>=yushe_yali)          //烟雾值大于等于预设值时
      
1298.                                 {
      
1299. 
      
1300.                                         Fan=0;
      
1301.                                         Buzzer=0;                                                  //蜂鸣器报警
      
1302.                                 }
      
1303.                                 else                                                                                  //烟雾值小于预设值时
      
1304.                                 {
      
1305. 
      
1306.                                         Fan=1;
      
1307.                                 }
      
1308.                                 if(wendu>=(yushe_wendu*10))          //温度大于等于预设温度值时（为什么是大于预设值*10：因为我们要显示的温度是有小数点后一位，是一个3位数，25.9°C时实际读的数是259，所以判断预设值时将预设值*10）
      
1309.                                 {
      
1310.                                         Buzzer=0;                                                  //打开蜂鸣器报警
      
1311. 
      
1312.                                 }
      
1313.                                 else                                                                                  //温度值小于预设值时
      
1314.                                 {
      
1315. 
      
1316.                                 }
      
1317.                                 if((yali1<yushe_yali)&&(wendu<(yushe_wendu*10)))          //当烟雾小于预设值并且温度也小于预设值时 （&&：逻辑与，左右两边的表达式都成立（都为真，也就是1）时，该if语句才成立）
      
1318.                                 {
      
1319.                                         Buzzer=1;                                                  //停止报警
      
1320.                                 }
      
1321.                                 break;
      
1322.                         }
      
1323.                         case 1://预设温度模式
      
1324.                         {
      
1325.                                 SelectPosition(0,5) ;                                        //指定位置
      
1326.                            write_com(0x0d);                                                        //阴影闪烁
      
1327.                                 if(key==KEY_ADD)                                                        //加键按下
      
1328.                                 {
      
1329.                                         yushe_wendu++;                                            //预设温度值（阀值）加1
      
1330.                                         if(yushe_wendu>=120)                                         //当阀值加到大于等于99时
      
1331.                                         yushe_wendu=120;                                                         //阀值固定为99
      
1332.                                         LCD_Write_Char(0,6,yushe_wendu,2) ;//显示预设温度
      
1333.                                 }
      
1334.                                 if(key==KEY_MINUS)                                                 //减键按下
      
1335.                                 {
      
1336.                                         if(yushe_wendu<=1)                                        //当温度上限值减小到1时
      
1337.                                         yushe_wendu=1;                          //固定为1
      
1338.                                         yushe_wendu--;                                                        //预设温度值减一,最小为0
      
1339.                                         LCD_Write_Char(0,6,yushe_wendu,2) ;//显示预设温度
      
1340.                                 }
      
1341.                                 break;                                                                                          //执行后跳出switch
      
1342.                         }
      
1343.                         case 2:                                //预设烟雾模式
      
1344.                         {
      
1345.                                 SelectPosition(0,12) ;                                //指定位置       
      
1346.                            write_com(0x0d);                                                        //打开显示 无光标 光标闪烁
      
1347.                                 if(key==KEY_ADD)                                                        //加键按下
      
1348.                                 {
      
1349.                                         if(yushe_yali>=255)        //当阀值加到大于等于255时
      
1350.                                         yushe_yali=254;            //阀值固定为254
      
1351.                                         yushe_yali++;                                            //预设烟雾值（阀值）加1,最大为255
      
1352.                                         LCD_Write_Char(0,13,yushe_yali,3) ;//显示预设烟雾
      
1353.                                 }
      
1354.                                 if(key==KEY_MINUS)                                                //减键按下
      
1355.                                 {
      
1356.                                         if(yushe_yali<=1)                                        //当烟雾上限值减小到1时
      
1357.                                                 yushe_yali=1;                  //固定为1
      
1358.                                         yushe_yali--;                                                        //预设温度值减一,最小为0          
      
1359.                                         LCD_Write_Char(0,13,yushe_yali,3) ;//显示预设烟雾
      
1360.                                 }
      
1361.                                 break;
      
1362.                         }
      
1363.                         default        :       
      
1364.                         {
      
1365.                                 write_com(0x38);//屏幕初始化
      
1366.                                 write_com(0x0c);//打开显示 无光标 无光标闪烁
      
1367.                                 Mode=0;                        //恢复正常模式
      
1368.                                 break;
      
1369.                         }
      
1370.                 }
      
1371.                
      
1372.         }
      
1373. 
      
1374. }
      
1375. 
      

复制代码

所有资料51hei提供下载:
多路温度压力检测系统.rar (136.27 KB, 下载次数: 191)

2018-6-3 23:09 上传

点击文件名下载附件
51单片机设计

51hei有你更精彩！

厉害

请问楼主，你这个作品可以实现各路温度压力值的选择显示和连续滚动显示吗？

楼主好棒

为什么我仿真的时候，显示屏不显示东西？

下载之后，用什么软件能打开呀

大佬为啥运行起来有这个报警Logic contention(s) detected on net #00005.