标题: 51单片机设计的空调温度控制器Proteus仿真程序 [打印本页]

---

作者: Colourfuler    时间: 2021-1-21 16:45
标题: 51单片机设计的空调温度控制器Proteus仿真程序
本设计基于单片机制作了一个空调温度控制器，仿真示意图如下


系统要求利用单片机设计一空调温度控制器，能够实时检测并显示室温，能够利用键盘设定温度，并且和室温进行比较，当室温低于设定温度时，系统能够驱动加热系统工作，当室温高于设定温度时，系统能够驱动制冷系统工作，当两者温度相等时，不做动作。

总体方案设计
空调温度控制系统，主要要完成对温度的采集、显示以及设定等工作，从而实现对空调的控制。传统采用铂电阻充当测温器件的方案，虽然其中段测量线性度好，精度较高，但是测量电路的设计难度高 ，且测量电路系统庞大，难于调试 ，而且成本相对较高。鉴于上述原因，本系统采用DS18B20充当测温器件。外部温度信号经 DS18B20将输入的模拟信号转换成8位的数字信号， 通过并 口传送到单片机系统( AT89C52) 。单片机系统将接收的数字信号译码处理，通过LCD1602将温度显示出来，同时单片机系统还将完成键盘扫描 、按键温度设定、超温报警等程序的处理 ，将处理的温度信号与系统设定温度值比较，形成可以控制空调制冷、制热与停止工作三种工作状态，从而实现空调的智能化。另外，键盘输入方面，采用了软件来修正误操作输入 ，即输入的温度范围必须在系统硬件所确定的范围内，直接降低由于误操作带来的风险，提高了系统的可靠性 ，体现了人性化的系统设计原则。
系统的整体框图如图1所示：

系统要求在当前室温低于设定温度时，能够自动驱动加热系统工作 ；在当前室温高于设定温度时能够自动驱动制冷系统工作。本系统在复位后即置P2^6脚和P2^7脚为低电平，在当前室温低于设定温度时，通过置P2^7脚为高电平来驱动后级加热系统，本系统采用红色LED来代替加热系统；在当前室温高于设定温度时，通过置P2^6脚高电平来驱动后级制冷系统，本系统采用蓝色LED来代替制冷系统。
输出控制电路如图8所示。


系统总电路图如图9所示。

本系统所用的元器件清单如表1所示。
                            表1 系统所用元器件
元器件名称    数量
点触式开关    16
30pF瓷片电容    2
10uF电解电容    1
蓝色LED    1
红色RED    1
5V电源插座    1
自锁开关    1
LCD1602    1
1/4W10K电阻    3
10K可调电阻    1
AT89C52    1
DS18B20    1
12MHz晶振    1
3 软件系统设计
3.1 软件系统总体方案设计
    系统软件由主程序模块、测温程序模块、键盘扫描程序模块以及液晶驱动程序模块组成。
3.2 软件流程图设计
系统软件流程图如图10所示。

系统调试
程序在Keil uVision4环境下编写，编译通过后生成.hex文件加载到Protuse下可正常运行。程序默认温度为21.0℃，Protuse下设定DS18B20的温度也为21.0℃，故开始运行时两路LED灯都不点亮。当利用键盘设定的温度高于DS18B20默认的21.0℃时，红色LED灯被点亮；当设定的温度低于DS18B20默认的21.0℃时，蓝色LED灯被点亮。
附上仿真图
当设定的温度高于DS18B20默认的21.0℃时，红色LED灯被点亮，如图11所示。

图11 红色LED灯点亮
当设定的温度低于DS18B20默认的21.0℃时，蓝色LED灯被点亮。如图12所示。


单片机源程序如下:

1. #include<reg52.h>
   
2. #include<intrins.h>
   
3. #define uchar unsigned char//宏定义
   
4. #define uint unsigned int
   
5. ////////////////////全局变量/////////////////////////////
   
6. float  TEMP_NOW=0.0;
   
7. float  TEMP_SET=21.0;
   
8. uint  T_Count=0;
   
9. uint  S_Count=0;
   
10. uint  P_Count=0;
    
11. uint  N_Count=0;
    
12. uint  M_Count=1;
    
13. 
    
14. 
    
15. #define                K_UP                    0X20//定义键值
    
16. #define                K_DOWN                 0X21
    
17. #define                K_CLEAR             0X24
    
18. #define                K_OK                    0X25
    
19. #define                K_ONE                    0X30
    
20. #define                K_FOUR                 0X31
    
21. #define                K_SEVEN            0X32
    
22. #define                K_POINT                 0X33
    
23. #define                K_TWO                    0X34
    
24. #define                K_FIVE                    0X43
    
25. #define                K_EIGHT                0X36
    
26. #define                K_ZERO                0X37
    
27. #define                K_THREE                0X38
    
28. #define                K_SIX                    0X40
    
29. #define                K_NINE                0X41
    
30. #define                K_SET                   0X42
    
31. extern float TEMP_NOW;
    
32. extern float TEMP_SET;
    
33. extern uint  T_Count;
    
34. extern uint  S_Count;
    
35. extern uint  P_Count;
    
36. extern uint  N_Count;
    
37. extern uint  M_Count;
    
38. extern uchar Current_Temp_Display_Buffer[];
    
39. extern uchar set_Temp_Display_Buffer[];
    
40. extern int sel;
    
41. sbit  lcden=P2^7;//液晶使能
    
42. sbit  lcdrs=P2^6;//液晶数据/命令选择端
    
43. sbit  DQ   =P3^7;//DS18B20数据端
    
44. sbit  XX   =P2^5;//读写选择端
    
45. sbit  cold =P2^0;//输出信号
    
46. sbit  warm =P2^1;//输出信号
    
47. uchar Current_Temp_Display_Buffer[]={"   NOW: 00.0"};
    
48. uchar set_Temp_Display_Buffer[]=    {"   SET: 38.0"};
    
49. int sel=0;                                                       
    
50. 
    
51. uchar code KeyCodeTable[]=
    
52. {
    
53.           0x11,0x12,0x14,0x18,0x21,0x22,0x24,0x28,0x41,0x42,0x44,0x48,0x81,0x82,0x84,0x88
    
54. };
    
55. 
    
56. 
    
57. #define delayNOP() {_nop_();_nop_();_nop_();_nop_();}
    
58. 
    
59. uchar code Temperature_Char[8] = {0x0c,0x12,0x12,0x0c,0x00,0x00,0x00,0x00};
    
60. uchar code df_Table[]={0,1,1,2,3,3,4,4,5,6,6,7,8,8,9,9};
    
61. uchar CurrentT = 0;
    
62. uchar Temp_Value[]={0x00,0x00};
    
63. uchar Display_Digit[]={0,0,0,0};
    
64. 
    
65. bit DS18B20_IS_OK = 1;
    
66. 
    
67. void Read_Temperature();
    
68. void Display_Temperature();
    
69. 
    
70. void Comparison();
    
71. //////////////////////定时///////////////////////////////
    
72. void timer0_init(void)
    
73. {
    
74.         TMOD =        0x00  ; //设置定时器0的工作方式
    
75.         TH0 = (8192-5000)/32;//单片机晶振为12MHz，机器周期为1us，t=5ms，
    
76.                       //N=5000/1=5000
    
77.         TL0 = (8192-5000)%32;
    
78.         IE  =        0x82;
    
79.         TR0=1;                       
    
80. }
    
81. void timer0() interrupt 1
    
82. {                                           
    
83.         TH0 = (8192-5000)/32;
    
84.         TL0 = (8192-5000)%32;
    
85.         if(++T_Count == 100)                   //////100为0.5s          
    
86.         {           
    
87.                 TR0=0;                               
    
88.                 Read_Temperature();
    
89.                 Display_Temperature() ;
    
90.                 T_Count=0;
    
91.                 if(++P_Count == 6)
    
92.                 {
    
93.                          N_Count=1;
    
94.                 }
    
95.                    TR0=1;
    
96.         }
    
97. }
    
98. void delay1(uint z)          //延时函数
    
99. {
    
100.         uint x,y;
     
101.         for(x=z;x>0;x--)
     
102.                 for(y=110;y>0;y--);
     
103. }
     
104. void write_com(uchar com)  //写命令函数
     
105. {
     
106.         lcdrs=0;  //选择写命令模式
     
107.         P0=com;          //将要写的命令字送到数据总线上
     
108.         delay1(5); //稍作延时以待数据稳定
     
109.         lcden=1;  //使能端给一高脉冲，因为初始化函数中已经将lcden置零
     
110.         delay1(5); //稍作延时
     
111.         lcden=0;  //将使能端置0完成高脉冲
     
112. }
     
113. void write_date(uchar date)         //写数据函数
     
114. {
     
115.         lcdrs=1;   //选择写数据模式
     
116.         P0=date;
     
117.         delay1(5);
     
118.         lcden=1;
     
119.         delay1(5);
     
120.         lcden=0;
     
121. }
     
122. void init_lcd()                   //初始化函数
     
123. {
     
124.         lcden=0;
     
125.         write_com(0x38); //设置16*2显示，5*7点阵，8位数据接口
     
126.         write_com(0x0c); //设置开显示，不显示光标
     
127.         write_com(0x06); //写一个字符后地址指针加1
     
128.         write_com(0x01); //显示清0,数据指针清0
     
129. }
     
130. void Print()
     
131. {
     
132.         uchar num;
     
133.         write_com(0x80);
     
134.         for(num=0;num<12;num++)
     
135.         {
     
136.                 write_date(Current_Temp_Display_Buffer[num]);
     
137.         }
     
138.         write_date(0xdf);
     
139.         write_date('C');
     
140.         write_com(0x80+0x40);
     
141.         for(num=0;num<12;num++)
     
142.         {
     
143.                  write_date(set_Temp_Display_Buffer[num]);
     
144.         }
     
145.         write_date(0xdf);
     
146.         write_date('C');
     
147. }
     
148. 
     
149. 
     
150. void Delay_INI(uint x)
     
151. {
     
152.         while(--x);
     
153. }
     
154. 
     
155. void Delay(unsigned int n)       
     
156. {
     
157.         do
     
158.         {
     
159.                 _nop_();_nop_();
     
160.                 _nop_();_nop_();
     
161.                 _nop_();_nop_();
     
162.                 _nop_();_nop_();
     
163.                 _nop_();
     
164.                 n--;
     
165.         }while(n);
     
166. }
     
167. 
     
168. 
     
169. uchar Init_DS18B20()
     
170.   {
     
171.         uchar status;
     
172.         DQ = 1;
     
173.         Delay_INI(8);
     
174.         DQ = 0;
     
175.         Delay_INI(90);
     
176.         DQ = 1;
     
177.         Delay_INI(8);
     
178.         status=DQ;
     
179.         Delay_INI(100);
     
180.         DQ = 1;
     
181.         return status;
     
182. }
     
183. 
     
184. uchar ReadOneByte()
     
185. {
     
186.         uchar i,dat=0;
     
187.         DQ = 1;
     
188.         _nop_();
     
189.         for(i=0;i<8;i++)
     
190.         {
     
191.                  DQ = 0;
     
192.                 dat >>= 1;
     
193.                 DQ = 1;
     
194.                 _nop_();
     
195.                 _nop_();
     
196.                 if(DQ)
     
197.                         dat |= 0X80;
     
198.                 Delay(30);
     
199.                 DQ = 1;
     
200.         }
     
201.         return dat;
     
202. }
     
203. 
     
204. void WriteOneByte(uchar dat)
     
205. {
     
206.         uchar i;
     
207.         for(i=0;i<8;i++)
     
208.         {
     
209.                  DQ = 0;
     
210.                 DQ = dat& 0x01;
     
211.                 Delay(5);
     
212.                 DQ = 1;
     
213.                 dat >>= 1;
     
214.         }
     
215. }
     
216. void Read_Temperature()
     
217. {
     
218.         if(Init_DS18B20()==1)
     
219.                 DS18B20_IS_OK=0;
     
220.         else
     
221.         {
     
222.                 WriteOneByte(0xcc);
     
223.                 WriteOneByte(0x44);
     
224.                 Init_DS18B20();
     
225.                 WriteOneByte(0xcc);
     
226.                 WriteOneByte(0xbe);
     
227.                 Temp_Value[0] = ReadOneByte();
     
228.                 Temp_Value[1] = ReadOneByte();
     
229.                 DS18B20_IS_OK=1;       
     
230.         }       
     
231. }
     
232. void Display_Temperature()
     
233. {
     
234.         uchar t = 150, ng = 0;
     
235.         if((Temp_Value[1]&0xf8)==0xf8)
     
236.         {
     
237.                  Temp_Value[1] = ~Temp_Value[1];
     
238.                 Temp_Value[0] = ~Temp_Value[0]+1;
     
239.                 if(Temp_Value[0]==0x00)
     
240.                         Temp_Value[1]++;
     
241.                 ng = 1;       
     
242.         }
     
243.         Display_Digit[0] = df_Table[Temp_Value[0]&0x0f];
     
244.         CurrentT = ((Temp_Value[0]&0xf0)>>4) | ((Temp_Value[1]&0x07)<<4);
     
245.         Display_Digit[3] = CurrentT/100;
     
246.         Display_Digit[2] = CurrentT%100/10;
     
247.         Display_Digit[1] = CurrentT%10;
     
248.         Current_Temp_Display_Buffer[11] = Display_Digit[0] + '0';
     
249.         Current_Temp_Display_Buffer[10] = '.';
     
250.         Current_Temp_Display_Buffer[9]  = Display_Digit[1] + '0';
     
251.         Current_Temp_Display_Buffer[8]  = Display_Digit[2] + '0';
     
252.         Current_Temp_Display_Buffer[7]  = Display_Digit[3] + '0';
     
253. 
     
254.         TEMP_NOW=Display_Digit[2]*10+Display_Digit[1]+Display_Digit[0]*0.1         ;
     
255. 
     
256.         if(Display_Digit[3] == 0)
     
257.                 Current_Temp_Display_Buffer[7]  = ' ';
     
258.         if(Display_Digit[2] == 0&&Display_Digit[3]==0)
     
259.                 Current_Temp_Display_Buffer[8]  = ' ';
     
260.         if(ng)
     
261.         {
     
262.                 TEMP_NOW=-(Display_Digit[2]*10+Display_Digit[1]+Display_Digit[0]*0.1);
     
263. 
     
264.                  if(Current_Temp_Display_Buffer[8]  == ' ')
     
265.                         Current_Temp_Display_Buffer[8]  = '-';
     
266.                 else if(Current_Temp_Display_Buffer[7]  == ' ')
     
267.                         Current_Temp_Display_Buffer[7]  = '-';
     
268.                 else
     
269.                         Current_Temp_Display_Buffer[6]  = '-';
     
270.         }         
     
271. }
     
272. void Delay_key()
     
273. {
     
274.         uchar i;
     
275.         for(i=0;i<200;i++);
     
276. }
     
277. 
     
278. uchar Keys_Scan()
     
279. {
     
280.         uchar sCode,kCode,k;
     
281.         P1 = 0xf0;
     
282.         if((P1&0xf0)!=0xf0)
     
283.         {
     
284.                  Delay_key();
     
285.                 if((P1&0xf0)!=0xf0)
     
286.                 {
     
287.                          sCode = 0xfe;
     
288.                         for(k=0;k<4;k++)
     
289.                         {
     
290.                                  P1 = sCode;
     
291.                                 if((P1&0xf0)!=0xf0)
     
292.                                 {
     
293.                                          kCode = ~P1;
     
294.                                         if(kCode == KeyCodeTable[0]) return K_ONE;
     
295.                                         else if(kCode == KeyCodeTable[1]) return K_TWO;
     
296.                                         else if(kCode == KeyCodeTable[2]) return K_THREE;
     
297.                                         else if(kCode == KeyCodeTable[3]) return K_FOUR;
     
298.                                         else if(kCode == KeyCodeTable[4]) return K_FIVE;
     
299.                                         else if(kCode == KeyCodeTable[5]) return K_SIX;
     
300.                                         else if(kCode == KeyCodeTable[6]) return K_SEVEN;
     
301.                                         else if(kCode == KeyCodeTable[7]) return K_EIGHT;
     
302.                                         else if(kCode == KeyCodeTable[8]) return K_NINE;
     
303.                                         else if(kCode == KeyCodeTable[9]) return K_UP;
     
304.                                         else if(kCode == KeyCodeTable[10]) return K_DOWN;
     
305.                                         else if(kCode == KeyCodeTable[11]) return K_CLEAR;
     
306.                                         else if(kCode == KeyCodeTable[12]) return K_OK;
     
307.                                         else if(kCode == KeyCodeTable[13]) return K_ZERO;
     
308.                                         else if(kCode == KeyCodeTable[14]) return K_POINT;
     
309.                                         else if(kCode == KeyCodeTable[15]) return K_SET;
     
310.                                 }
     
311.                                 else
     
312.                                         sCode = _crol_(sCode,1);
     
313.                         }
     
314.                 }
     
315.         }
     
316.         return -1;
     
317. }
     
318. void set_num()
     
319. {               
     
320.         uchar key;       
     
321.         if(sel==0)
     
322.         {
     
323.                 key = Keys_Scan();
     
324.                 if(K_CLEAR == key)
     
325.                 {
     
326.                         while(Keys_Scan() == K_CLEAR);
     
327.                         set_Temp_Display_Buffer[8] =' ';
     
328.                         set_Temp_Display_Buffer[9] =' ';
     
329.                         set_Temp_Display_Buffer[10]=' ';
     
330.                         set_Temp_Display_Buffer[11]=' ';  // 48(0)49(1)50(2)51(3)52(4)53(5)54(6)55(7)56(8)57(9)
     
331.                         M_Count=0;
     
332.                         cold=0;
     
333.                         warm=0;
     
334.                 }
     
335.                 if(K_UP == key)
     
336.                 {
     
337.                         while(Keys_Scan() == K_UP);
     
338.                         if((set_Temp_Display_Buffer[11]>47)&&(set_Temp_Display_Buffer[11]<57))
     
339.                         {
     
340.                                 set_Temp_Display_Buffer[11]+=1;
     
341.                         }
     
342.                         else if(set_Temp_Display_Buffer[11]==57)
     
343.                         {
     
344.                                 set_Temp_Display_Buffer[11]=48;
     
345.                                 if((set_Temp_Display_Buffer[9]>47)&&(set_Temp_Display_Buffer[9]<57))
     
346.                                 {
     
347.                                         set_Temp_Display_Buffer[9]+=1;
     
348.                                 }
     
349.                                 else if(set_Temp_Display_Buffer[9]==57)
     
350.                                 {       
     
351.                                         set_Temp_Display_Buffer[9]=48;
     
352.                                         if((set_Temp_Display_Buffer[8]>47)&&(set_Temp_Display_Buffer[8]<57))
     
353.                                         {
     
354.                                                  set_Temp_Display_Buffer[8]+=1;
     
355.                                         }
     
356.                                         else if(set_Temp_Display_Buffer[8]==57)
     
357.                                         {
     
358.                                                  set_Temp_Display_Buffer[8]=48;
     
359.                                         }
     
360.                                 }
     
361.                         }      
     
362.                 }
     
363.                 if(K_DOWN == key)                                                                  // 48(0)49(1)50(2)51(3)52(4)53(5)54(6)55(7)56(8)57(9)
     
364.                 {
     
365.                         while(Keys_Scan() == K_DOWN);
     
366.                         if((set_Temp_Display_Buffer[11]>48)&&(set_Temp_Display_Buffer[11]<58))
     
367.                         {
     
368.                                 set_Temp_Display_Buffer[11]-=1;
     
369.                         }
     
370.                         else if(set_Temp_Display_Buffer[11]==48)
     
371.                         {
     
372.                                 set_Temp_Display_Buffer[11]=57;
     
373.                                 if((set_Temp_Display_Buffer[9]>48)&&(set_Temp_Display_Buffer[9]<58))
     
374.                                 {
     
375.                                         set_Temp_Display_Buffer[9]-=1;
     
376.                                 }
     
377.                                 else if(set_Temp_Display_Buffer[9]==48)
     
378.                                 {       
     
379.                                         set_Temp_Display_Buffer[9]=57;
     
380.                                         if((set_Temp_Display_Buffer[8]>48)&&(set_Temp_Display_Buffer[8]<58))
     
381.                                         {
     
382.                                                  set_Temp_Display_Buffer[8]-=1;
     
383.                                         }
     
384.                                         else if(set_Temp_Display_Buffer[8]==48)
     
385.                                         {
     
386.                                                  set_Temp_Display_Buffer[8]=57;
     
387.                                         }
     
388.                                 }
     
389.                         }
     
390.                 }                       
     
391.                 if(K_ONE == key)
     
392.                 {
     
393.                         while(Keys_Scan() == K_ONE);
     
394.                         set_Temp_Display_Buffer[11]='1';
     
395.                         sel++;       
     
396.                 }
     
397.                 if(K_TWO == key)
     
398.                 {
     
399.                         while(Keys_Scan() == K_TWO);
     
400.                         set_Temp_Display_Buffer[11]='2';
     
401.                         sel++;
     
402.                 }
     
403.                 if(K_THREE == key)
     
404.                 {
     
405.                         while(Keys_Scan() == K_THREE);
     
406.                         set_Temp_Display_Buffer[11]='3';
     
407.                         sel++;
     
408.                 }
     
409.                 if(K_FOUR == key)
     
410.                 {
     
411.                         while(Keys_Scan() == K_FOUR);
     
412.                         set_Temp_Display_Buffer[11]='4';
     
413.                         sel++;
     
414.                 }
     
415.                 if(K_FIVE == key)
     
416.                 {
     
417.                         while(Keys_Scan() == K_FIVE);
     
418.                         set_Temp_Display_Buffer[11]='5';
     
419.                         sel++;
     
420.                 }
     
421.                 if(K_SIX == key)
     
422.                 {
     
423.                         while(Keys_Scan() == K_SIX);
     
424.                         set_Temp_Display_Buffer[11]='6';
     
425.                         sel++;
     
426.                 }
     
427.                 if(K_SEVEN == key)
     
428.                 {
     
429.                         while(Keys_Scan() == K_SEVEN);
     
430.                         set_Temp_Display_Buffer[11]='7';
     
431.                         sel++;
     
432.                 }
     
433.                 if(K_EIGHT == key)
     
434.                 {
     
435.                         while(Keys_Scan() == K_EIGHT);
     
436.                         set_Temp_Display_Buffer[11]='8';
     
437.                         sel++;
     
438.                 }
     
439.                 if(K_NINE == key)
     
440.                 {
     
441.                         while(Keys_Scan() == K_NINE);
     
442.                         set_Temp_Display_Buffer[11]='9';
     
443.                         sel++;
     
444.                 }
     
445.                 if(K_ZERO == key)
     
446.                 {
     
447.                         while(Keys_Scan() == K_ZERO);
     
448.                         set_Temp_Display_Buffer[11]='0';
     
449.                         sel++;
     
450.                 }
     
451.                 if(K_OK == key)
     
452.                 {
     
453.                         while(Keys_Scan() == K_OK);
     
454.                         TEMP_SET=(set_Temp_Display_Buffer[8]-48)*10+(set_Temp_Display_Buffer[9]-48)+(set_Temp_Display_Buffer[11]-48)*0.1;
     
455.                         sel=0;
     
456.                         M_Count=1;       
     
457.                 }
     
458.         }
     
459.         if(sel==1)
     
460.         {
     
461.                 key = Keys_Scan();
     
462.                 if(K_CLEAR == key)
     
463.                 {
     
464.                         while(Keys_Scan() == K_CLEAR);
     
465.                         set_Temp_Display_Buffer[8] =' ';
     
466.                         set_Temp_Display_Buffer[9] =' ';
     
467.                         set_Temp_Display_Buffer[10]=' ';
     
468.                         set_Temp_Display_Buffer[11]=' ';
     
469.                         M_Count=0;
     
470.                         cold=0;
     
471.                         warm=0;
     
472.                         sel=0;
     
473.                 }                        
     
474.                 if(K_ONE == key)
     
475.                 {
     
476.                         while(Keys_Scan() == K_ONE);
     
477.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
478.                         set_Temp_Display_Buffer[11]='1';
     
479.                         sel++;       
     
480.                 }
     
481.                 if(K_TWO == key)
     
482.                 {
     
483.                         while(Keys_Scan() == K_TWO);
     
484.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
485.                         set_Temp_Display_Buffer[11]='2';
     
486.                         sel++;
     
487.                 }
     
488.                 if(K_THREE == key)
     
489.                 {
     
490.                         while(Keys_Scan() == K_THREE);
     
491.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
492.                         set_Temp_Display_Buffer[11]='3';
     
493.                         sel++;
     
494.                 }
     
495.                 if(K_FOUR == key)
     
496.                 {
     
497.                         while(Keys_Scan() == K_FOUR);
     
498.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
499.                         set_Temp_Display_Buffer[11]='4';
     
500.                         sel++;
     
501.                 }
     
502.                 if(K_FIVE == key)
     
503.                 {
     
504.                         while(Keys_Scan() == K_FIVE);
     
505.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
506.                         set_Temp_Display_Buffer[11]='5';
     
507.                         sel++;
     
508.                 }
     
509.                 if(K_SIX == key)
     
510.                 {
     
511.                         while(Keys_Scan() == K_SIX);
     
512.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
513.                         set_Temp_Display_Buffer[11]='6';
     
514.                         sel++;
     
515.                 }
     
516.                 if(K_SEVEN == key)
     
517.                 {
     
518.                         while(Keys_Scan() == K_SEVEN);
     
519.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
520.                         set_Temp_Display_Buffer[11]='7';
     
521.                         sel++;
     
522.                 }
     
523.                 if(K_EIGHT == key)
     
524.                 {
     
525.                         while(Keys_Scan() == K_EIGHT);
     
526.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
527.                         set_Temp_Display_Buffer[11]='8';
     
528.                         sel++;
     
529.                 }
     
530.                 if(K_NINE == key)
     
531.                 {
     
532.                         while(Keys_Scan() == K_NINE);
     
533.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
534.                         set_Temp_Display_Buffer[11]='9';
     
535.                         sel++;
     
536.                 }
     
537.                 if(K_ZERO == key)
     
538.                 {
     
539.                         while(Keys_Scan() == K_ZERO);
     
540.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
541.                         set_Temp_Display_Buffer[11]='0';
     
542.                         sel++;
     
543.                 }
     
544.         }
     
545.         if(sel==2)
     
546.         {
     
547.                 key = Keys_Scan();
     
548.                 if(K_CLEAR == key)
     
549.                 {
     
550.                         while(Keys_Scan() == K_CLEAR);
     
551.                         set_Temp_Display_Buffer[8] =' ';
     
552.                         set_Temp_Display_Buffer[9] =' ';
     
553.                         set_Temp_Display_Buffer[10]=' ';
     
554.                         set_Temp_Display_Buffer[11]=' ';
     
555.                         M_Count=0;
     
556.                         cold=0;
     
557.                         warm=0;
     
558.                         sel=0;
     
559.                 }                  
     
560.                 if(K_POINT == key)
     
561.                 {
     
562.                         while(Keys_Scan() == K_POINT);
     
563.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
     
564.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
565.                         set_Temp_Display_Buffer[11]='.';
     
566.                         sel++;       
     
567.                 }
     
568.         }
     
569.         if(sel==3)
     
570.         {
     
571.                 key = Keys_Scan();
     
572.                 if(K_CLEAR == key)
     
573.                 {
     
574.                         while(Keys_Scan() == K_CLEAR);
     
575.                         set_Temp_Display_Buffer[8] =' ';
     
576.                         set_Temp_Display_Buffer[9] =' ';
     
577.                         set_Temp_Display_Buffer[10]=' ';
     
578.                         set_Temp_Display_Buffer[11]=' ';
     
579.                         M_Count=0;
     
580.                         cold=0;
     
581.                         warm=0;
     
582.                         sel=0;
     
583.                 }                      
     
584.                 if(K_ONE == key)
     
585.                 {
     
586.                         while(Keys_Scan() == K_ONE);
     
587.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
     
588.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
     
589.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
590.                         set_Temp_Display_Buffer[11]='1';
     
591.                         sel++;       
     
592.                 }
     
593.                 if(K_TWO == key)
     
594.                 {
     
595.                         while(Keys_Scan() == K_TWO);
     
596.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
     
597.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
     
598.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
599.                         set_Temp_Display_Buffer[11]='2';
     
600.                         sel++;
     
601.                 }
     
602.                 if(K_THREE == key)
     
603.                 {
     
604.                         while(Keys_Scan() == K_THREE);
     
605.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
     
606.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
     
607.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
608.                         set_Temp_Display_Buffer[11]='3';
     
609.                         sel++;
     
610.                 }
     
611.                 if(K_FOUR == key)
     
612.                 {
     
613.                         while(Keys_Scan() == K_FOUR);
     
614.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
     
615.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
     
616.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
617.                         set_Temp_Display_Buffer[11]='4';
     
618.                         sel++;
     
619.                 }
     
620.                 if(K_FIVE == key)
     
621.                 {
     
622.                         while(Keys_Scan() == K_FIVE);
     
623.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
     
624.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
     
625.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
626.                         set_Temp_Display_Buffer[11]='5';
     
627.                         sel++;
     
628.                 }
     
629.                 if(K_SIX == key)
     
630.                 {
     
631.                         while(Keys_Scan() == K_SIX);
     
632.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
     
633.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
     
634.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
635.                         set_Temp_Display_Buffer[11]='6';
     
636.                         sel++;
     
637.                 }
     
638.                 if(K_SEVEN == key)
     
639.                 {
     
640.                         while(Keys_Scan() == K_SEVEN);
     
641.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
     
642.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
     
643.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
644.                         set_Temp_Display_Buffer[11]='7';
     
645.                         sel++;
     
646.                 }
     
647.                 if(K_EIGHT == key)
     
648.                 {
     
649.                         while(Keys_Scan() == K_EIGHT);
     
650.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
     
651.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
     
652.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
     
653.                         set_Temp_Display_Buffer[11]='8';
     
654.                         sel++;
     
655.                 }
     
656.                 if(K_NINE == key)
     
657.                 {
     
658. ……………………
     
659. 
     
660. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

本系统所设计的空调温度控制器仅对温度部分实现了控制，但对于实际空调中的模式选择以及定时运行等工作过程还无法实现，希望在以后的学习研究中能够解决这些问题。
所有资料51hei提供下载:
基于单片机设计的空调温度控制器.zip (655.11 KB, 下载次数: 134)

2021-1-21 16:47 上传

点击文件名下载附件
下载积分: 黑币 -5

---

作者: 13205495918    时间: 2021-8-21 08:44
ds18b20要加个上拉电阻吧

---

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

Powered by Discuz! X3.1