久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 5651|回復: 1
打印 上一主題 下一主題
收起左側

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;


  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;                                                       

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


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

  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};

  65. bit DS18B20_IS_OK = 1;

  67. void Read_Temperature();
  68. void Display_Temperature();

  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. }


  150. void Delay_INI(uint x)
  151. {
  152.         while(--x);
  153. }

  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. }


  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. }

  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. }

  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';

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

  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);

  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. }

  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. ……………………

  660. …………限于本文篇幅 余下代碼請從51黑下載附件…………
復制代碼

本系統所設計的空調溫度控制器僅對溫度部分實現了控制，但對于實際空調中的模式選擇以及定時運行等工作過程還無法實現，希望在以后的學習研究中能夠解決這些問題。
所有資料51hei提供下載:
基于單片機設計的空調溫度控制器.zip (655.11 KB, 下載次數: 134)

評分

參與人數 1黑幣 +50 收起 理由
admin + 50 共享資料的黑幣獎勵！

查看全部評分

分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏2 分享淘帖 頂頂1 踩踩
回復

使用道具 舉報

沙發
ID:908826 發表于 2021-8-21 08:44 | 只看該作者
ds18b20要加個上拉電阻吧
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

手機版|小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表
主站蜘蛛池模板： 国产精品久久精品 | 999精品视频| 东京久久| 69性欧美高清影院 | 日韩一区二区免费视频 | 欧美亚洲视频 | 日韩精品一区二区三区视频播放 | 日韩在线免费视频 | 在线伊人网 | 亚洲免费观看视频 | 久久久久免费精品国产小说色大师 | 一级毛片视频在线 | 欧美一级在线观看 | 国产精品99久久久久久动医院 | 蜜月aⅴ国产精品 | 久久久精品综合 | 国产1区| 日韩免费一区 | 欧美精品在线一区二区三区 | 99re视频| 欧美视频二区 | 欧美日韩国产精品一区二区 | www.久久久.com| 一区二区三区高清 | 久久夜视频 | 男女下面一进一出网站 | 亚洲一级黄色 | 美女福利网站 | 精品av | 精品欧美乱码久久久久久 | 国产一区二区在线免费视频 | 男女精品久久 | 国产精品自拍av | 免费一级黄色电影 | h视频免费观看 | 亚洲国产精品成人综合久久久 | 亚洲综合在线视频 | 极品一区| 亚洲精品区 | 久久久久久久一区二区三区 | 亚洲一区有码 |