找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 4538|回复: 1
收起左侧

51单片机设计的空调温度控制器Proteus仿真程序

[复制链接]
ID:846537 发表于 2021-1-21 16:45 | 显示全部楼层 |阅读模式
本设计基于单片机制作了一个空调温度控制器,仿真示意图如下

包含矩阵键盘控制模块,LCD1602液晶显示模块等

包含矩阵键盘控制模块,LCD1602液晶显示模块等


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

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

系统总电路图如图9所示。
51hei.png
本系统所用的元器件清单如表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所示。
51hei.png
图11 红色LED灯点亮
当设定的温度低于DS18B20默认的21.0℃时,蓝色LED灯被点亮。如图12所示。
51hei.png

单片机源程序如下:
  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. #define                K_UP                    0X20//定义键值
  14. #define                K_DOWN                 0X21
  15. #define                K_CLEAR             0X24
  16. #define                K_OK                    0X25
  17. #define                K_ONE                    0X30
  18. #define                K_FOUR                 0X31
  19. #define                K_SEVEN            0X32
  20. #define                K_POINT                 0X33
  21. #define                K_TWO                    0X34
  22. #define                K_FIVE                    0X43
  23. #define                K_EIGHT                0X36
  24. #define                K_ZERO                0X37
  25. #define                K_THREE                0X38
  26. #define                K_SIX                    0X40
  27. #define                K_NINE                0X41
  28. #define                K_SET                   0X42
  29. extern float TEMP_NOW;
  30. extern float TEMP_SET;
  31. extern uint  T_Count;
  32. extern uint  S_Count;
  33. extern uint  P_Count;
  34. extern uint  N_Count;
  35. extern uint  M_Count;
  36. extern uchar Current_Temp_Display_Buffer[];
  37. extern uchar set_Temp_Display_Buffer[];
  38. extern int sel;
  39. sbit  lcden=P2^7;//液晶使能
  40. sbit  lcdrs=P2^6;//液晶数据/命令选择端
  41. sbit  DQ   =P3^7;//DS18B20数据端
  42. sbit  XX   =P2^5;//读写选择端
  43. sbit  cold =P2^0;//输出信号
  44. sbit  warm =P2^1;//输出信号
  45. uchar Current_Temp_Display_Buffer[]={"   NOW: 00.0"};
  46. uchar set_Temp_Display_Buffer[]=    {"   SET: 38.0"};
  47. int sel=0;                                                       

  48. uchar code KeyCodeTable[]=
  49. {
  50.           0x11,0x12,0x14,0x18,0x21,0x22,0x24,0x28,0x41,0x42,0x44,0x48,0x81,0x82,0x84,0x88
  51. };


  52. #define delayNOP() {_nop_();_nop_();_nop_();_nop_();}

  53. uchar code Temperature_Char[8] = {0x0c,0x12,0x12,0x0c,0x00,0x00,0x00,0x00};
  54. uchar code df_Table[]={0,1,1,2,3,3,4,4,5,6,6,7,8,8,9,9};
  55. uchar CurrentT = 0;
  56. uchar Temp_Value[]={0x00,0x00};
  57. uchar Display_Digit[]={0,0,0,0};

  58. bit DS18B20_IS_OK = 1;

  59. void Read_Temperature();
  60. void Display_Temperature();

  61. void Comparison();
  62. //////////////////////定时///////////////////////////////
  63. void timer0_init(void)
  64. {
  65.         TMOD =        0x00  ; //设置定时器0的工作方式
  66.         TH0 = (8192-5000)/32;//单片机晶振为12MHz,机器周期为1us,t=5ms,
  67.                       //N=5000/1=5000
  68.         TL0 = (8192-5000)%32;
  69.         IE  =        0x82;
  70.         TR0=1;                       
  71. }
  72. void timer0() interrupt 1
  73. {                                           
  74.         TH0 = (8192-5000)/32;
  75.         TL0 = (8192-5000)%32;
  76.         if(++T_Count == 100)                   //////100为0.5s          
  77.         {           
  78.                 TR0=0;                               
  79.                 Read_Temperature();
  80.                 Display_Temperature() ;
  81.                 T_Count=0;
  82.                 if(++P_Count == 6)
  83.                 {
  84.                          N_Count=1;
  85.                 }
  86.                    TR0=1;
  87.         }
  88. }
  89. void delay1(uint z)          //延时函数
  90. {
  91.         uint x,y;
  92.         for(x=z;x>0;x--)
  93.                 for(y=110;y>0;y--);
  94. }
  95. void write_com(uchar com)  //写命令函数
  96. {
  97.         lcdrs=0;  //选择写命令模式
  98.         P0=com;          //将要写的命令字送到数据总线上
  99.         delay1(5); //稍作延时以待数据稳定
  100.         lcden=1;  //使能端给一高脉冲,因为初始化函数中已经将lcden置零
  101.         delay1(5); //稍作延时
  102.         lcden=0;  //将使能端置0完成高脉冲
  103. }
  104. void write_date(uchar date)         //写数据函数
  105. {
  106.         lcdrs=1;   //选择写数据模式
  107.         P0=date;
  108.         delay1(5);
  109.         lcden=1;
  110.         delay1(5);
  111.         lcden=0;
  112. }
  113. void init_lcd()                   //初始化函数
  114. {
  115.         lcden=0;
  116.         write_com(0x38); //设置16*2显示,5*7点阵,8位数据接口
  117.         write_com(0x0c); //设置开显示,不显示光标
  118.         write_com(0x06); //写一个字符后地址指针加1
  119.         write_com(0x01); //显示清0,数据指针清0
  120. }
  121. void Print()
  122. {
  123.         uchar num;
  124.         write_com(0x80);
  125.         for(num=0;num<12;num++)
  126.         {
  127.                 write_date(Current_Temp_Display_Buffer[num]);
  128.         }
  129.         write_date(0xdf);
  130.         write_date('C');
  131.         write_com(0x80+0x40);
  132.         for(num=0;num<12;num++)
  133.         {
  134.                  write_date(set_Temp_Display_Buffer[num]);
  135.         }
  136.         write_date(0xdf);
  137.         write_date('C');
  138. }


  139. void Delay_INI(uint x)
  140. {
  141.         while(--x);
  142. }

  143. void Delay(unsigned int n)       
  144. {
  145.         do
  146.         {
  147.                 _nop_();_nop_();
  148.                 _nop_();_nop_();
  149.                 _nop_();_nop_();
  150.                 _nop_();_nop_();
  151.                 _nop_();
  152.                 n--;
  153.         }while(n);
  154. }


  155. uchar Init_DS18B20()
  156.   {
  157.         uchar status;
  158.         DQ = 1;
  159.         Delay_INI(8);
  160.         DQ = 0;
  161.         Delay_INI(90);
  162.         DQ = 1;
  163.         Delay_INI(8);
  164.         status=DQ;
  165.         Delay_INI(100);
  166.         DQ = 1;
  167.         return status;
  168. }

  169. uchar ReadOneByte()
  170. {
  171.         uchar i,dat=0;
  172.         DQ = 1;
  173.         _nop_();
  174.         for(i=0;i<8;i++)
  175.         {
  176.                  DQ = 0;
  177.                 dat >>= 1;
  178.                 DQ = 1;
  179.                 _nop_();
  180.                 _nop_();
  181.                 if(DQ)
  182.                         dat |= 0X80;
  183.                 Delay(30);
  184.                 DQ = 1;
  185.         }
  186.         return dat;
  187. }

  188. void WriteOneByte(uchar dat)
  189. {
  190.         uchar i;
  191.         for(i=0;i<8;i++)
  192.         {
  193.                  DQ = 0;
  194.                 DQ = dat& 0x01;
  195.                 Delay(5);
  196.                 DQ = 1;
  197.                 dat >>= 1;
  198.         }
  199. }
  200. void Read_Temperature()
  201. {
  202.         if(Init_DS18B20()==1)
  203.                 DS18B20_IS_OK=0;
  204.         else
  205.         {
  206.                 WriteOneByte(0xcc);
  207.                 WriteOneByte(0x44);
  208.                 Init_DS18B20();
  209.                 WriteOneByte(0xcc);
  210.                 WriteOneByte(0xbe);
  211.                 Temp_Value[0] = ReadOneByte();
  212.                 Temp_Value[1] = ReadOneByte();
  213.                 DS18B20_IS_OK=1;       
  214.         }       
  215. }
  216. void Display_Temperature()
  217. {
  218.         uchar t = 150, ng = 0;
  219.         if((Temp_Value[1]&0xf8)==0xf8)
  220.         {
  221.                  Temp_Value[1] = ~Temp_Value[1];
  222.                 Temp_Value[0] = ~Temp_Value[0]+1;
  223.                 if(Temp_Value[0]==0x00)
  224.                         Temp_Value[1]++;
  225.                 ng = 1;       
  226.         }
  227.         Display_Digit[0] = df_Table[Temp_Value[0]&0x0f];
  228.         CurrentT = ((Temp_Value[0]&0xf0)>>4) | ((Temp_Value[1]&0x07)<<4);
  229.         Display_Digit[3] = CurrentT/100;
  230.         Display_Digit[2] = CurrentT%100/10;
  231.         Display_Digit[1] = CurrentT%10;
  232.         Current_Temp_Display_Buffer[11] = Display_Digit[0] + '0';
  233.         Current_Temp_Display_Buffer[10] = '.';
  234.         Current_Temp_Display_Buffer[9]  = Display_Digit[1] + '0';
  235.         Current_Temp_Display_Buffer[8]  = Display_Digit[2] + '0';
  236.         Current_Temp_Display_Buffer[7]  = Display_Digit[3] + '0';

  237.         TEMP_NOW=Display_Digit[2]*10+Display_Digit[1]+Display_Digit[0]*0.1         ;

  238.         if(Display_Digit[3] == 0)
  239.                 Current_Temp_Display_Buffer[7]  = ' ';
  240.         if(Display_Digit[2] == 0&&Display_Digit[3]==0)
  241.                 Current_Temp_Display_Buffer[8]  = ' ';
  242.         if(ng)
  243.         {
  244.                 TEMP_NOW=-(Display_Digit[2]*10+Display_Digit[1]+Display_Digit[0]*0.1);

  245.                  if(Current_Temp_Display_Buffer[8]  == ' ')
  246.                         Current_Temp_Display_Buffer[8]  = '-';
  247.                 else if(Current_Temp_Display_Buffer[7]  == ' ')
  248.                         Current_Temp_Display_Buffer[7]  = '-';
  249.                 else
  250.                         Current_Temp_Display_Buffer[6]  = '-';
  251.         }         
  252. }
  253. void Delay_key()
  254. {
  255.         uchar i;
  256.         for(i=0;i<200;i++);
  257. }

  258. uchar Keys_Scan()
  259. {
  260.         uchar sCode,kCode,k;
  261.         P1 = 0xf0;
  262.         if((P1&0xf0)!=0xf0)
  263.         {
  264.                  Delay_key();
  265.                 if((P1&0xf0)!=0xf0)
  266.                 {
  267.                          sCode = 0xfe;
  268.                         for(k=0;k<4;k++)
  269.                         {
  270.                                  P1 = sCode;
  271.                                 if((P1&0xf0)!=0xf0)
  272.                                 {
  273.                                          kCode = ~P1;
  274.                                         if(kCode == KeyCodeTable[0]) return K_ONE;
  275.                                         else if(kCode == KeyCodeTable[1]) return K_TWO;
  276.                                         else if(kCode == KeyCodeTable[2]) return K_THREE;
  277.                                         else if(kCode == KeyCodeTable[3]) return K_FOUR;
  278.                                         else if(kCode == KeyCodeTable[4]) return K_FIVE;
  279.                                         else if(kCode == KeyCodeTable[5]) return K_SIX;
  280.                                         else if(kCode == KeyCodeTable[6]) return K_SEVEN;
  281.                                         else if(kCode == KeyCodeTable[7]) return K_EIGHT;
  282.                                         else if(kCode == KeyCodeTable[8]) return K_NINE;
  283.                                         else if(kCode == KeyCodeTable[9]) return K_UP;
  284.                                         else if(kCode == KeyCodeTable[10]) return K_DOWN;
  285.                                         else if(kCode == KeyCodeTable[11]) return K_CLEAR;
  286.                                         else if(kCode == KeyCodeTable[12]) return K_OK;
  287.                                         else if(kCode == KeyCodeTable[13]) return K_ZERO;
  288.                                         else if(kCode == KeyCodeTable[14]) return K_POINT;
  289.                                         else if(kCode == KeyCodeTable[15]) return K_SET;
  290.                                 }
  291.                                 else
  292.                                         sCode = _crol_(sCode,1);
  293.                         }
  294.                 }
  295.         }
  296.         return -1;
  297. }
  298. void set_num()
  299. {               
  300.         uchar key;       
  301.         if(sel==0)
  302.         {
  303.                 key = Keys_Scan();
  304.                 if(K_CLEAR == key)
  305.                 {
  306.                         while(Keys_Scan() == K_CLEAR);
  307.                         set_Temp_Display_Buffer[8] =' ';
  308.                         set_Temp_Display_Buffer[9] =' ';
  309.                         set_Temp_Display_Buffer[10]=' ';
  310.                         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)
  311.                         M_Count=0;
  312.                         cold=0;
  313.                         warm=0;
  314.                 }
  315.                 if(K_UP == key)
  316.                 {
  317.                         while(Keys_Scan() == K_UP);
  318.                         if((set_Temp_Display_Buffer[11]>47)&&(set_Temp_Display_Buffer[11]<57))
  319.                         {
  320.                                 set_Temp_Display_Buffer[11]+=1;
  321.                         }
  322.                         else if(set_Temp_Display_Buffer[11]==57)
  323.                         {
  324.                                 set_Temp_Display_Buffer[11]=48;
  325.                                 if((set_Temp_Display_Buffer[9]>47)&&(set_Temp_Display_Buffer[9]<57))
  326.                                 {
  327.                                         set_Temp_Display_Buffer[9]+=1;
  328.                                 }
  329.                                 else if(set_Temp_Display_Buffer[9]==57)
  330.                                 {       
  331.                                         set_Temp_Display_Buffer[9]=48;
  332.                                         if((set_Temp_Display_Buffer[8]>47)&&(set_Temp_Display_Buffer[8]<57))
  333.                                         {
  334.                                                  set_Temp_Display_Buffer[8]+=1;
  335.                                         }
  336.                                         else if(set_Temp_Display_Buffer[8]==57)
  337.                                         {
  338.                                                  set_Temp_Display_Buffer[8]=48;
  339.                                         }
  340.                                 }
  341.                         }      
  342.                 }
  343.                 if(K_DOWN == key)                                                                  // 48(0)49(1)50(2)51(3)52(4)53(5)54(6)55(7)56(8)57(9)
  344.                 {
  345.                         while(Keys_Scan() == K_DOWN);
  346.                         if((set_Temp_Display_Buffer[11]>48)&&(set_Temp_Display_Buffer[11]<58))
  347.                         {
  348.                                 set_Temp_Display_Buffer[11]-=1;
  349.                         }
  350.                         else if(set_Temp_Display_Buffer[11]==48)
  351.                         {
  352.                                 set_Temp_Display_Buffer[11]=57;
  353.                                 if((set_Temp_Display_Buffer[9]>48)&&(set_Temp_Display_Buffer[9]<58))
  354.                                 {
  355.                                         set_Temp_Display_Buffer[9]-=1;
  356.                                 }
  357.                                 else if(set_Temp_Display_Buffer[9]==48)
  358.                                 {       
  359.                                         set_Temp_Display_Buffer[9]=57;
  360.                                         if((set_Temp_Display_Buffer[8]>48)&&(set_Temp_Display_Buffer[8]<58))
  361.                                         {
  362.                                                  set_Temp_Display_Buffer[8]-=1;
  363.                                         }
  364.                                         else if(set_Temp_Display_Buffer[8]==48)
  365.                                         {
  366.                                                  set_Temp_Display_Buffer[8]=57;
  367.                                         }
  368.                                 }
  369.                         }
  370.                 }                       
  371.                 if(K_ONE == key)
  372.                 {
  373.                         while(Keys_Scan() == K_ONE);
  374.                         set_Temp_Display_Buffer[11]='1';
  375.                         sel++;       
  376.                 }
  377.                 if(K_TWO == key)
  378.                 {
  379.                         while(Keys_Scan() == K_TWO);
  380.                         set_Temp_Display_Buffer[11]='2';
  381.                         sel++;
  382.                 }
  383.                 if(K_THREE == key)
  384.                 {
  385.                         while(Keys_Scan() == K_THREE);
  386.                         set_Temp_Display_Buffer[11]='3';
  387.                         sel++;
  388.                 }
  389.                 if(K_FOUR == key)
  390.                 {
  391.                         while(Keys_Scan() == K_FOUR);
  392.                         set_Temp_Display_Buffer[11]='4';
  393.                         sel++;
  394.                 }
  395.                 if(K_FIVE == key)
  396.                 {
  397.                         while(Keys_Scan() == K_FIVE);
  398.                         set_Temp_Display_Buffer[11]='5';
  399.                         sel++;
  400.                 }
  401.                 if(K_SIX == key)
  402.                 {
  403.                         while(Keys_Scan() == K_SIX);
  404.                         set_Temp_Display_Buffer[11]='6';
  405.                         sel++;
  406.                 }
  407.                 if(K_SEVEN == key)
  408.                 {
  409.                         while(Keys_Scan() == K_SEVEN);
  410.                         set_Temp_Display_Buffer[11]='7';
  411.                         sel++;
  412.                 }
  413.                 if(K_EIGHT == key)
  414.                 {
  415.                         while(Keys_Scan() == K_EIGHT);
  416.                         set_Temp_Display_Buffer[11]='8';
  417.                         sel++;
  418.                 }
  419.                 if(K_NINE == key)
  420.                 {
  421.                         while(Keys_Scan() == K_NINE);
  422.                         set_Temp_Display_Buffer[11]='9';
  423.                         sel++;
  424.                 }
  425.                 if(K_ZERO == key)
  426.                 {
  427.                         while(Keys_Scan() == K_ZERO);
  428.                         set_Temp_Display_Buffer[11]='0';
  429.                         sel++;
  430.                 }
  431.                 if(K_OK == key)
  432.                 {
  433.                         while(Keys_Scan() == K_OK);
  434.                         TEMP_SET=(set_Temp_Display_Buffer[8]-48)*10+(set_Temp_Display_Buffer[9]-48)+(set_Temp_Display_Buffer[11]-48)*0.1;
  435.                         sel=0;
  436.                         M_Count=1;       
  437.                 }
  438.         }
  439.         if(sel==1)
  440.         {
  441.                 key = Keys_Scan();
  442.                 if(K_CLEAR == key)
  443.                 {
  444.                         while(Keys_Scan() == K_CLEAR);
  445.                         set_Temp_Display_Buffer[8] =' ';
  446.                         set_Temp_Display_Buffer[9] =' ';
  447.                         set_Temp_Display_Buffer[10]=' ';
  448.                         set_Temp_Display_Buffer[11]=' ';
  449.                         M_Count=0;
  450.                         cold=0;
  451.                         warm=0;
  452.                         sel=0;
  453.                 }                        
  454.                 if(K_ONE == key)
  455.                 {
  456.                         while(Keys_Scan() == K_ONE);
  457.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  458.                         set_Temp_Display_Buffer[11]='1';
  459.                         sel++;       
  460.                 }
  461.                 if(K_TWO == key)
  462.                 {
  463.                         while(Keys_Scan() == K_TWO);
  464.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  465.                         set_Temp_Display_Buffer[11]='2';
  466.                         sel++;
  467.                 }
  468.                 if(K_THREE == key)
  469.                 {
  470.                         while(Keys_Scan() == K_THREE);
  471.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  472.                         set_Temp_Display_Buffer[11]='3';
  473.                         sel++;
  474.                 }
  475.                 if(K_FOUR == key)
  476.                 {
  477.                         while(Keys_Scan() == K_FOUR);
  478.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  479.                         set_Temp_Display_Buffer[11]='4';
  480.                         sel++;
  481.                 }
  482.                 if(K_FIVE == key)
  483.                 {
  484.                         while(Keys_Scan() == K_FIVE);
  485.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  486.                         set_Temp_Display_Buffer[11]='5';
  487.                         sel++;
  488.                 }
  489.                 if(K_SIX == key)
  490.                 {
  491.                         while(Keys_Scan() == K_SIX);
  492.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  493.                         set_Temp_Display_Buffer[11]='6';
  494.                         sel++;
  495.                 }
  496.                 if(K_SEVEN == key)
  497.                 {
  498.                         while(Keys_Scan() == K_SEVEN);
  499.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  500.                         set_Temp_Display_Buffer[11]='7';
  501.                         sel++;
  502.                 }
  503.                 if(K_EIGHT == key)
  504.                 {
  505.                         while(Keys_Scan() == K_EIGHT);
  506.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  507.                         set_Temp_Display_Buffer[11]='8';
  508.                         sel++;
  509.                 }
  510.                 if(K_NINE == key)
  511.                 {
  512.                         while(Keys_Scan() == K_NINE);
  513.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  514.                         set_Temp_Display_Buffer[11]='9';
  515.                         sel++;
  516.                 }
  517.                 if(K_ZERO == key)
  518.                 {
  519.                         while(Keys_Scan() == K_ZERO);
  520.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  521.                         set_Temp_Display_Buffer[11]='0';
  522.                         sel++;
  523.                 }
  524.         }
  525.         if(sel==2)
  526.         {
  527.                 key = Keys_Scan();
  528.                 if(K_CLEAR == key)
  529.                 {
  530.                         while(Keys_Scan() == K_CLEAR);
  531.                         set_Temp_Display_Buffer[8] =' ';
  532.                         set_Temp_Display_Buffer[9] =' ';
  533.                         set_Temp_Display_Buffer[10]=' ';
  534.                         set_Temp_Display_Buffer[11]=' ';
  535.                         M_Count=0;
  536.                         cold=0;
  537.                         warm=0;
  538.                         sel=0;
  539.                 }                  
  540.                 if(K_POINT == key)
  541.                 {
  542.                         while(Keys_Scan() == K_POINT);
  543.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
  544.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  545.                         set_Temp_Display_Buffer[11]='.';
  546.                         sel++;       
  547.                 }
  548.         }
  549.         if(sel==3)
  550.         {
  551.                 key = Keys_Scan();
  552.                 if(K_CLEAR == key)
  553.                 {
  554.                         while(Keys_Scan() == K_CLEAR);
  555.                         set_Temp_Display_Buffer[8] =' ';
  556.                         set_Temp_Display_Buffer[9] =' ';
  557.                         set_Temp_Display_Buffer[10]=' ';
  558.                         set_Temp_Display_Buffer[11]=' ';
  559.                         M_Count=0;
  560.                         cold=0;
  561.                         warm=0;
  562.                         sel=0;
  563.                 }                      
  564.                 if(K_ONE == key)
  565.                 {
  566.                         while(Keys_Scan() == K_ONE);
  567.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
  568.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
  569.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  570.                         set_Temp_Display_Buffer[11]='1';
  571.                         sel++;       
  572.                 }
  573.                 if(K_TWO == key)
  574.                 {
  575.                         while(Keys_Scan() == K_TWO);
  576.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
  577.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
  578.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  579.                         set_Temp_Display_Buffer[11]='2';
  580.                         sel++;
  581.                 }
  582.                 if(K_THREE == key)
  583.                 {
  584.                         while(Keys_Scan() == K_THREE);
  585.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
  586.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
  587.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  588.                         set_Temp_Display_Buffer[11]='3';
  589.                         sel++;
  590.                 }
  591.                 if(K_FOUR == key)
  592.                 {
  593.                         while(Keys_Scan() == K_FOUR);
  594.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
  595.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
  596.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  597.                         set_Temp_Display_Buffer[11]='4';
  598.                         sel++;
  599.                 }
  600.                 if(K_FIVE == key)
  601.                 {
  602.                         while(Keys_Scan() == K_FIVE);
  603.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
  604.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
  605.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  606.                         set_Temp_Display_Buffer[11]='5';
  607.                         sel++;
  608.                 }
  609.                 if(K_SIX == key)
  610.                 {
  611.                         while(Keys_Scan() == K_SIX);
  612.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
  613.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
  614.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  615.                         set_Temp_Display_Buffer[11]='6';
  616.                         sel++;
  617.                 }
  618.                 if(K_SEVEN == key)
  619.                 {
  620.                         while(Keys_Scan() == K_SEVEN);
  621.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
  622.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
  623.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  624.                         set_Temp_Display_Buffer[11]='7';
  625.                         sel++;
  626.                 }
  627.                 if(K_EIGHT == key)
  628.                 {
  629.                         while(Keys_Scan() == K_EIGHT);
  630.                         set_Temp_Display_Buffer[8]=set_Temp_Display_Buffer[9] ;
  631.                         set_Temp_Display_Buffer[9]=set_Temp_Display_Buffer[10] ;
  632.                         set_Temp_Display_Buffer[10]=set_Temp_Display_Buffer[11] ;
  633.                         set_Temp_Display_Buffer[11]='8';
  634.                         sel++;
  635.                 }
  636.                 if(K_NINE == key)
  637.                 {
  638. ……………………

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

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

回复

使用道具 举报

ID:908826 发表于 2021-8-21 08:44 | 显示全部楼层
ds18b20要加个上拉电阻吧
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表