设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 自己参考例子写的带字库12864（ST7920）液晶屏程序，求 ...
返回列表 发新帖
查看: 2361|回复: 4
打印 上一主题 下一主题
收起左侧

自己参考例子写的带字库12864（ST7920）液晶屏程序，求优化

[复制链接]
回帖奖励 30 黑币 回复本帖可获得 10 黑币奖励! 每人限 1 次
跳转到指定楼层
楼主
ID:261451 发表于 2018-7-19 16:49 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
本帖最后由 一袋天骄 于 2018-7-23 10:58 编辑
  1. #include<reg52.h>
  2. #include<intrins.h>
  3. #define uchar unsigned char
  4. #define uint unsigned int
  5. #include "4.h"

  7. uchar code table[] = "      测试      ";
  8. uchar code table1[]= "  实时数据查看  ";
  9. uchar code table2[]= "  上下限设置    ";  
  10. uchar code table3[]= "光照:           ";
  11. uchar code table4[]= "风速:           ";
  12. uchar code table5[]= "风向:           ";
  13. uchar code table6[]= "温度:           ";
  14. uchar code table7[]= "湿度:           ";
  15. uchar code table8[]= "土温:           ";
  16. uchar code table9[]= "土湿:           ";
  17. uchar code table10[]="时:             ";
  18. uchar code table11[]="天:             ";
  19. uchar code table12[]="月:             ";
  20. uchar code table13[]="年:             ";
  21. uchar code table14[]="下限:           ";
  22. uchar code table15[]="上限:           ";
  23. uchar code table16[]="  请输入密码:   ";
  24. uchar code table17[]="    密码错误    ";
  25. uchar code table18[]="  请重新输入    ";
  26. uchar code table19[]="    降雨量      ";
  27. uchar code table20[]="    设置成功    ";
  28. uchar fanye,fanye2,guangbiao;
  29. uchar b,c,d,e,f,g;
  30. uchar yi,er,san,si;
  31. uchar ge,shi,bai,qian,wan;
  32. uint  guang_shang,guang_xia,feng_shang,wendu_shang,wendu_xia,shidu_shang,shidu_xia,tuwen_shang,tuwen_xia,tushi_shang,tushi_xia,yu_shang;
  33. uint  guang,fengsu,fengxiang,wendu,wendu1,shidu,tuwen,tuwen1,tushi,yu_shi,yu_tian;
  34. long  yu_yue,yu_nian;
  35. //sbit LCD_CS=P0^7;   //RS
  36. sbit LCD_SID=P0^6;    //RW
  37. sbit LCD_SCLK=P0^5;   //E
  38. sbit key1=P1^1;       //确认
  39. sbit key2=P1^2;       //按键减一
  40. sbit key3=P1^3;       //按键加一
  41. sbit key4=P1^4;       //返回
  42. sbit key5=P1^5;

  44. void delay_ms(uint z)
  45. {
  46.    uint x,y;
  47.         for(x=z;x>0;x--)
  48.                 for(y=110;y>0;y--);
  49. }
  50. void sendbyte(unsigned char bbyte) //发送一个字节
  51. {
  52. unsigned char i;
  53. for(i=0;i<8;i++)
  54.    {
  55.    LCD_SID=bbyte&0x80; //取出最高位
  56.    LCD_SCLK=1;
  57.    LCD_SCLK=0;
  58.    bbyte<<=1; //左移
  59.    }  
  60. }

  62. void write(bit start, unsigned char ddata) //写指令或数据
  63. {
  64.   unsigned char start_data,Hdata,Ldata;
  65.   if(start==0)
  66.     start_data=0xf8;  //写指令
  67.   else      
  68.         start_data=0xfa;  //写数据
  69.   
  70.   Hdata=ddata&0xf0;    //取高四位
  71.   Ldata=(ddata<<4)&0xf0;  //取低四位
  72.   sendbyte(start_data);   //发送起始信号
  73.   delay_ms(1); //延时
  74.   sendbyte(Hdata);       //发送高四位
  75.   delay_ms(1);
  76.   sendbyte(Ldata);    //发送低四位
  77.   delay_ms(1);
  78. }
  79. //***********一行显示8个汉字***********
  80. //***************汉字显示***************
  81. //***X为行Y为列,K为字的个数,*P为数组*
  82. //*************************************
  83. void chinese(uchar x,uchar y,uchar k,uchar *p)
  84. {
  85.         uchar hang,out,i;
  86.         y=y-1;
  87.         switch(x)
  88.         {
  89.                 case 1:hang=0x80;break;
  90.                 case 2:hang=0x90;break;
  91.                 case 3:hang=0x88;break;
  92.                 case 4:hang=0x98;break;        
  93.         }
  94.         out=hang+y;        
  95.         write(0,out);
  96.         for(i=0;i<k*2;i++) {
  97.              write(1,*p);
  98.                   p++;
  99.                     }
  100.                                 //write(1,p);
  101. }
  102. //**********一行显示16个字母***********
  103. //***********英文数字显示***************
  104. //***X为行Y为列,K为字的个数,*P为数组*
  105. //************************************
  106. void english(uchar x,uchar y,uchar k,uchar *p)
  107. {
  108.         uchar hang,out,i;
  109.         y=y-1;
  110.         
  111.         switch(x)
  112.         {
  113.                 case 1:hang=0x80;break;
  114.                 case 2:hang=0x90;break;
  115.                 case 3:hang=0x88;break;
  116.                 case 4:hang=0x98;break;        
  117.         }
  118.         out=hang+y;        
  119.         write(0,out);
  120.         for(i=0;i<k;i++) {
  121.                  write(1,*p);
  122.                   p++;
  123.                        }
  124. }

  126. void lcd_init()
  127. {
  128.         write(0,0x30);  //8位介面,基本指令集
  129.         write(0,0x0c);  //显示打开,光标关,光标位置关
  130.         write(0,0x01);  //清屏,将DDRAM地址计数器归零
  131.         delay_ms(10);
  132. }

  134. /*****************箭头指示*****************/
  135. void zhishi(uchar a)
  136. {
  137.            write(0,0x30);  //8位介面,基本指令集
  138.            
  139.      switch(a)
  140.         {
  141.                 case 1:write(0,0x80);break;
  142.                 case 2:write(0,0x90);break;
  143.                 case 3:write(0,0x88);break;
  144.                 case 4:write(0,0x98);break;        
  145.         }           
  146.             write(1,0x1a);           
  147. }

  149. /*******************************反白1**************************
  150. 将128*64看做256*32,3.4行在1.2行右边
  151. x0范围(0x80,0x80+16),x1范围(1,16)按字数算
  152. y0范围(0x80,0x80+32),y1范围(1,32)按点数算
  153. data1,data2写入0xff为反白,写入0x00为清零图片缓存
  154. ********************************************************************/
  155. /*void fanbai(uchar data1,uchar data2,uchar x0,uchar y0,uchar x1,uchar y1)
  156. {
  157.              uchar i,j;
  158.         for(j=0;j<y1;j++)
  159.         {
  160.         for(i=0;i<x1;i++)
  161.           {
  162.                   write(0,0x34);
  163.                         write(0,y0+j);  //写y坐标
  164.                         write(0,x0+i);  //写x坐标
  165.                         write(0,0x30);
  166.                         write(1,data1);
  167.                         write(1,data2);
  168.           }
  169.         }
  170.         write(0,0x36);
  171. }

  173. /*******************显示*******************************/
  174.    void display_start()
  175.     {
  176.                         write(0,0x01);
  177.                          english(2,1,15,table);  //开始界面
  178.                                  }
  179.    void display_menu()
  180.     {
  181.                         write(0,0x01);
  182.                           english(1,1,15,table1);// 实时数据查看
  183.         english(2,1,15,table2);//上下限设置  
  184.                                  }
  185.   /* void display_menu2()
  186.     {
  187.                         write(0,0x01);
  188.                           english(3,1,15,table1);// 实时数据查看
  189.         english(4,1,15,table2);//上下限设置  
  190.                                  }*/
  191.    void display_mima()
  192.     {
  193.                         write(0,0x01);
  194.                         english(1,1,15,table16);//请输入密码:
  195.                                  }
  196.                 void display_error()
  197.                 {
  198.                         write(0,0x01);
  199.                         english(1,1,15,table17);//密码错误
  200.                         english(3,1,15,table18);//请重新输入
  201.                 }
  202.                 void display1()
  203.     {
  204.                         write(0,0x01);
  205.                           english(2,1,15,table3);//光照
  206.                           guang=1234;
  207.                           write(0,0x93);
  208.                           write(1,0x30+guang/10000);
  209.                           write(1,0x30+guang/1000%10);
  210.                           write(0,0x94);
  211.                           write(1,0x30+guang/100%10);
  212.                           write(1,0x30+guang/10%10);
  213.                           write(0,0x95);
  214.                           write(1,0x30+guang%10);
  215.                            write(1,0x30);
  216.                           write(0,0x96);
  217.                           write(1,0x20);
  218.                           write(1,0x4c);
  219.                           write(0,0x97);
  220.                           write(1,0x78);
  221.                                  }
  222.                 void display2()
  223.     {
  224.                         write(0,0x01);
  225.                         english(2,1,15,table4);//风速
  226.                         fengsu=1230;
  227.                         write(0,0x93);
  228.                         write(1,0x30+fengsu/1000);
  229.                         write(1,0x30+fengsu/100%10);
  230.                         write(0,0x94);                        
  231.                         write(1,0x2e);
  232.                         write(1,0x30+fengsu/10%10);
  233.                         write(0,0x95);
  234.                         write(1,0x30+fengsu%10);
  235.                         write(0,0x96);
  236.                         write(1,0x6d);
  237.                         write(1,0x2f);
  238.                         write(0,0x97);
  239.                         write(1,0x73);
  240.                         english(4,1,15,table5);//风向
  241.                         fengxiang=1800;
  242.                         write(0,0x9b);
  243.                         write(1,0x30+fengxiang/1000);
  244.                         write(1,0x30+fengxiang/100%10);
  245.                         write(0,0x9c);
  246.                         write(1,0x30+fengxiang/10%10);
  247.                         write(1,0x2e);
  248.                         write(0,0x9d);
  249.                         write(1,0x30+fengxiang%10);
  250.                         write(0,0x9e);
  251.                         write(1,0xa1);
  252.                         write(1,0xe3);
  253.                                  }
  254.                 void display3()
  255.     {
  256.                         write(0,0x01);
  257.                         english(2,1,15,table6);//空气温度
  258.                         wendu=120;
  259.                         //wendu=0xfff0;
  260.                         if(wendu<8000)
  261.                                 {
  262.          write(0,0x93);
  263.                            write(1,0x30+wendu/100);
  264.                                  write(1,0x30+wendu/10%10);
  265.                            write(0,0x94);
  266.                            write(1,0x2e);
  267.                                  write(1,0x30+wendu%10);
  268.                                  write(0,0x96);
  269.                                  write(1,0xa1);
  270.                                  write(1,0xe6);
  271.                                 }
  272.                         if(wendu>=8000)
  273.                                 {
  274.                                  wendu1=0xffff-wendu+1;
  275.                                  write(0,0x93);
  276.                                  write(1,0x2d);
  277.                            write(1,0x30+wendu1/100);
  278.                                  write(0,0x94);
  279.                                  write(1,0x30+wendu1/10%10);
  280.                            write(1,0x2e);
  281.                                  write(0,0x95);
  282.                                  write(1,0x30+wendu1%10);
  283.                                  write(1,0x20);
  284.                                  write(0,0x96);
  285.                                  write(1,0xa1);
  286.                                  write(1,0xe6);
  287.                                 }
  288.                         english(4,1,15,table7);//空气湿度
  289.                                 shidu=120;
  290.                                 write(0,0x9b);
  291.                                 write(1,0x30+shidu/100);
  292.                                 write(1,0x30+shidu/10%10);
  293.                                 write(0,0x9c);
  294.                                 write(1,0x2e);
  295.                                 write(1,0x30+shidu%10);
  296.                                 write(0,0x9e);
  297.                                 write(1,0xa3);
  298.                                 write(1,0xa5);
  299.                                  }
  300.                 void display4()
  301.     {
  302.                         write(0,0x01);
  303.                   english(2,1,15,table8);//土壤温度
  304.                         //tuwen=120;
  305.                         tuwen=0xfff0;
  306.                         if(shidu<8000)
  307.                                 {
  308.          write(0,0x93);
  309.                            write(1,0x30+tuwen/100);
  310.                                  write(1,0x30+tuwen/10%10);
  311.                            write(0,0x94);
  312.                            write(1,0x2e);
  313.                                  write(1,0x30+tuwen%10);
  314.                                  write(0,0x96);
  315.                                  write(1,0xa1);
  316.                                  write(1,0xe6);
  317.                                 }
  318.                         if(tuwen>=8000)
  319.                                 {
  320.                                  tuwen1=0xffff-tuwen+1;
  321.                                  write(0,0x93);
  322.                                  write(1,0x2d);
  323.                            write(1,0x30+tuwen1/100);
  324.                                  write(0,0x94);
  325.                                  write(1,0x30+tuwen1/10%10);
  326.                            write(1,0x2e);
  327.                                  write(0,0x95);
  328.                                  write(1,0x30+tuwen1%10);
  329.                                  write(1,0x20);
  330.                                  write(0,0x96);
  331.                                  write(1,0xa1);
  332.                                  write(1,0xe6);
  333.                                 }
  334.       english(4,1,15,table9);//土壤湿度
  335.                                 tushi=210;
  336.                                 write(0,0x9b);
  337.                                 write(1,0x30+tushi/100);
  338.                                 write(1,0x30+tushi/10%10);
  339.                                 write(0,0x9c);
  340.                                 write(1,0x2e);
  341.                                 write(1,0x30+tushi%10);
  342.                                 write(0,0x9e);
  343.                                 write(1,0xa3);
  344.                                 write(1,0xa5);
  345.                                  }
  346.                 void display5()
  347.     {
  348.                         write(0,0x01);
  349.                          english(1,1,15,table19);
  350.                          english(2,1,15,table10);//小时雨量
  351.                          yu_shi=120;
  352.                          write(0,0x92);
  353.                          write(1,0x30+yu_shi/100);
  354.                          write(1,0x30+yu_shi/10%10);
  355.                          write(0,0x93);
  356.                          write(1,0x2e);
  357.                          write(1,0x30+yu_shi%10);
  358.                          write(0,0x95);
  359.                          write(1,0x6d);
  360.                          write(1,0x6d);
  361.                          english(4,1,15,table11);//天雨量
  362.                          yu_tian=2100;
  363.                          write(0,0x9a);
  364.                          write(1,0x30+yu_tian/1000);
  365.                          write(1,0x30+yu_tian/100%10);
  366.                          write(0,0x9b);
  367.                          write(1,0x30+yu_tian/10%10);
  368.                          write(1,0x2e);
  369.                          write(0,0x9c);
  370.                          write(1,0x30+yu_tian%10);
  371.                          write(1,0x20);
  372.                          write(0,0x9d);
  373.                          write(1,0x6d);
  374.                          write(1,0x6d);
  375.                                  }
  376.                 void display6()
  377.     {
  378.                         write(0,0x01);
  379.                          english(1,1,15,table19);
  380.                          english(2,1,15,table12);//月雨量
  381.                          yu_yue=11110;
  382.                          write(0,0x92);
  383.                          write(1,0x30+yu_yue/10000);
  384.                          write(1,0x30+yu_yue/1000%10);
  385.                          write(0,0x93);
  386.                          write(1,0x30+yu_yue/100%10);
  387.                          write(1,0x30+yu_yue/10%10);
  388.                          write(0,0x94);
  389.                          write(1,0x2e);
  390.                          write(1,0x30+yu_yue%10);
  391.                          write(0,0x96);
  392.                          write(1,0x6d);
  393.                          write(1,0x6d);
  394.                          english(4,1,15,table13);//年雨量
  395.                          yu_nian=201422;
  396.                          write(0,0x9a);
  397.                          write(1,0x30+yu_nian/100000);
  398.                          write(1,0x30+yu_nian/10000%10);
  399.                          write(0,0x9b);
  400.                          write(1,0x30+yu_nian/1000%10);
  401.                          write(1,0x30+yu_nian/100%10);
  402.                          write(0,0x9c);
  403.                          write(1,0x30+yu_nian/10%10);
  404.                          write(1,0x2e);
  405.                          write(0,0x9d);
  406.                          write(1,0x30+yu_nian%10);
  407.                          write(0,0x9f);
  408.                          write(1,0x6d);
  409.                          write(1,0x6d);
  410.                                  }

  412.                 void display1_1()
  413.     {
  414.                         write(0,0x01);
  415.                         english(1,1,15,table3);//光照
  416.                         english(2,1,15,table15);//上限
  417.                         english(3,1,15,table14);//下限
  418.                                  }
  419.                 void display1_2()
  420.     {
  421.                         write(0,0x01);
  422.                         english(1,1,15,table4);//风速
  423.                         english(2,1,15,table15);//上限
  424.                                  }
  425.                
  426.                 void display1_3()
  427.     {
  428.                         write(0,0x01);
  429.                         english(1,1,15,table6);//空气温度
  430.                          english(2,1,15,table15);//上限
  431.                         english(3,1,15,table14);//下限
  432.                                  }
  433.                 void display1_4()
  434.     {
  435.                         write(0,0x01);
  436.                         english(1,1,15,table7);//空气湿度
  437.                         english(2,1,15,table15);//上限
  438.                          english(3,1,15,table14);//下限
  439.                                  }
  440.                 void display1_5()
  441.     {
  442.                         write(0,0x01);
  443.                         english(1,1,15,table8);//土壤温度
  444.                          english(2,1,15,table15);//上限
  445.                         english(3,1,15,table14);//下限
  446.                                  }
  447.                 void display1_6()
  448.     {
  449.                         write(0,0x01);
  450.                         english(1,1,15,table9);//土壤湿度
  451.                          english(2,1,15,table15);//上限
  452.                          english(3,1,15,table14);//下限
  453.                                  }
  454.                 void display1_7()
  455.     {
  456.                         write(0,0x01);
  457.                         english(1,1,15,table19);//小时降雨
  458.                         english(2,1,15,table10);//小时降雨
  459.                          english(3,1,15,table15);//上限
  460.                                  }
  461.                 void display1_8()
  462.                 {
  463.                 write(0,0x01);
  464.                 english(2,1,15,table20);//设置成功
  465.                 }
  466.                 void anjian_wan()
  467.                 {
  468.                  if(key3==0)
  469.                         {
  470.                           delay_ms(50);        
  471.                           if(key3==0)
  472.                                         {
  473.                                                 if(wan<9)
  474.                                                         {
  475.                                        wan++;
  476.                                  }
  477.                        }                     
  478.                                   while(!key3);
  479.                         }
  480.                  if(key2==0)
  481.                         {
  482.                          delay_ms(50);        
  483.                            if(key2==0)
  484.                                                 {
  485.                                                 if(wan>0)
  486.                                                     {
  487.                                          wan--;
  488.                                    }
  489.                               }
  490.                   while(!key2);
  491.                          }
  492.                 }
  493.                 void anjian_qian()
  494.                 {
  495.                 if(key3==0)
  496.                         {
  497.                          delay_ms(50);        
  498.                           if(key3==0)
  499.                                         {
  500.                                                 if(qian<9)
  501.                                                         {
  502.                                        qian++;
  503.                                  }
  504.                              }
  505.                                         while(!key3);
  506.                                 }
  507.                  if(key2==0)
  508.                                 {
  509.                           delay_ms(50);        
  510.                            if(key2==0)
  511.                                                 {
  512.                                                   if(qian>0)
  513.                                                                 {
  514.                                          qian--;
  515.                                   }
  516.                   }               
  517.                 while(!key2);
  518.                                 }
  519.                 }
  520. void anjian_bai()
  521.                 {
  522.                 if(key3==0)
  523.                         {
  524.                          delay_ms(50);        
  525.                           if(key3==0)
  526.                                         {
  527.                                                 if(bai<9)
  528.                                                         {
  529.                                        bai++;
  530.                                  }
  531.                              }
  532.                 while(!key3);
  533.                                 }
  534.                  if(key2==0)
  535.                                 {
  536.                           delay_ms(50);        
  537.                            if(key2==0)
  538.                                                 {
  539.                                                   if(bai>0)
  540.                                                                 {
  541.                                          bai--;
  542.                                   }
  543.                   }                             
  544.           while(!key2);
  545.                                 }
  546.                 }
  547.                 void anjian_shi()
  548.                 {
  549.                 if(key3==0)
  550.                         {
  551.                          delay_ms(50);        
  552.                           if(key3==0)
  553.                                         {
  554.                                                 if(shi<9)
  555.                                                         {
  556.                                        shi++;
  557.                                  }
  558.                              }
  559.                  while(!key3);
  560.                                 }
  561.                  if(key2==0)
  562.                                 {
  563.                           delay_ms(50);        
  564.                            if(key2==0)
  565.                                                 {
  566.                                                   if(shi>0)
  567.                                                                 {
  568.                                          shi--;
  569.                                   }
  570.                               }
  571.                  while(!key2);
  572.                                 }
  573.                 }
  574.                 void anjian_ge()
  575.                 {
  576.                 if(key3==0)
  577.                         {
  578.                          delay_ms(50);        
  579.                           if(key3==0)
  580.                                         {
  581.                                                 if(ge<9)
  582.                                                         {
  583.                                        ge++;
  584.                                  }
  585.                              }
  586.                  while(!key3);
  587.                                 }
  588.                  if(key2==0)
  589.                                 {
  590.                           delay_ms(50);        
  591.                            if(key2==0)
  592.                                                 {
  593.                                                   if(ge>0)
  594.                                                                 {
  595.                                          ge--;
  596.                                   }
  597.                              }
  598.                 while(!key2);  
  599.                                 }
  600.                 }
  601.                 void anjian_fuhao()
  602.                 {
  603.                 if((key3==0)||(bai==0))
  604.                         {
  605.                         delay_ms(50);
  606.                                         if((key3==0)||(bai==0))
  607.                                                         {
  608.                                                         bai=0x2b;
  609.                                                   }
  610.                                         while(!key3);
  611.                         }
  612.                 if(key2==0)
  613.                         {
  614.                         delay_ms(50);
  615.                           if(key2==0)
  616.            {
  617.                                                 bai=0x2d;
  618.                                                 }
  619.                                 while(!key2);
  620.                         }
  621.                 }
  622.                
  623. void main()
  624. {
  625.         lcd_init();
  626. //fanbai(0x00,0x00,0x80,0x80,16,32);   //上电清空图片缓存
  627. //lcd_init();
  628. display_start();
  629. while(1){
  630.          //key1确认键
  631.                   if(key1==0)
  632.                  {
  633.                         delay_ms(50);
  634.                            if(key1==0)
  635.                                 {                  
  636.                                                 if(c<2)
  637.                                                 {
  638.                                                 c++;      
  639.                                                 }
  640.                                                 if((c==1)&&(b==0))
  641.                                                 {
  642.                                                 display_menu();
  643.                                                 zhishi(1);
  644.                                                 b=1;
  645.                                                 }
  646.                                 }        
  647.                          while(!key1);
  648.                  }
  649.                  //key4返回键
  650.                 if(key4==0)
  651.                 {
  652.                 delay_ms(50);
  653.                                 if(key4==0)
  654.                                 {
  655.                                 yi=er=san=si=0;
  656.                                 write(0,0x0c);          //关闭光标显示
  657.                                 b=0;
  658.                                 e=0;
  659.                           f=0;
  660.                                 fanye2=0;
  661.                                      if(c>0)
  662.                                                  {
  663.                                                         c--;                  
  664.                                                  }
  665.                                                  if(c==1)
  666.                                                  {
  667.                                                         display_menu();
  668.                                                         zhishi(1);
  669.                                                         b=1;
  670.                                                         }
  671.                                                  if(c==0)
  672.                                                  {
  673.                                                   fanye=0;
  674.                                                         display_start();
  675.                                                  }
  676.                                         }        
  677.          while(!key4);
  678.                         }
  679.                  
  680. //按键翻页
  681.               if(c==0)
  682.                                 {                            //一级界面
  683.                  if(key3==0)
  684.                                          {
  685.                        delay_ms(50);
  686.                           if(key3==0) //key3向右翻页
  687.                                                         {
  688.                                        fanye++;
  689.                                     if(fanye>6)
  690.                                                                         {
  691.                                                  fanye=6;
  692.                                                                         }
  693.                                                         }
  694.                                 while(!key3);
  695.                                                         if(fanye==1){display1();delay_ms(50);}
  696.                                 if(fanye==2){display2();delay_ms(50);}
  697.                                 if(fanye==3){display3();delay_ms(50);}
  698.                                                         if(fanye==4){display4();delay_ms(50);}
  699.                                 if(fanye==5){display5();delay_ms(50);}
  700.                                 if(fanye==6){display6();delay_ms(50);}
  701.                         }
  702.                              if(key2==0)
  703.                                           {
  704.                                    delay_ms(50);
  705.                                        if(key2==0)  //key2向左翻页
  706.                                                          {      
  707.                                              fanye--;
  708.                                                  if(fanye<1)
  709.                                                                          {
  710.                                            fanye=1;
  711.                                                                          }
  712.                                                                 }
  713.                                   while(!key2);
  714.                if(fanye==6){display6();delay_ms(50);}
  715.                                  if(fanye==5){display5();delay_ms(50);}
  716.                                                          if(fanye==4){display4();delay_ms(50);}
  717.                if(fanye==3){display3();delay_ms(50);}
  718.                                        if(fanye==2){display2();delay_ms(50);}
  719.                                        if(fanye==1){display1();delay_ms(50);}
  720.                         }
  721.                                 
  722.              }
  723. //************菜单**************************/
  724.                                                   if(c==1)
  725.                                                         {
  726.                                                                   if(key3==0)
  727.                                                                         {                              
  728.                               delay_ms(50);
  729.                                   if(key3==0)
  730.                                                                                         {
  731.                                                                                                   if(b<2)
  732.                                                                                                         {
  733.                                                    b++;
  734.                                                                                                         }
  735.                                                                                         }
  736.                                                                                         while(!key3);
  737.                                                                                         if(b==1){display_menu();zhishi(1);delay_ms(50);}
  738.                                                                                         if(b==2){display_menu();zhishi(2);delay_ms(50);}
  739.                     /*  if(b==3){display_menu();zhishi(3);delay_ms(50);}
  740.                       if(b==4){display_menu();zhishi(4);delay_ms(50);}
  741.                       if(b==5){display_menu2();zhishi(1);delay_ms(50);}
  742.                       if(b==6){display_menu2();zhishi(2);delay_ms(50);}
  743.                       if(b==7){display_menu2();zhishi(3);delay_ms(50);}        */                                                                                       
  744.                                                                                 }
  745.                                                               if(key2==0)
  746.                                                                                 {
  747.                                  delay_ms(50);
  748.                                      if(key2==0)
  749.                                                                                                  {
  750.                                                                                                                  if(b>1)
  751.                                                                                                                  {
  752.                                                      b--;
  753.                                                                                                                  }
  754.                                                                                                         }
  755.                                                                                                          while(!key2);
  756.                                                                                                  if(b==1){display_menu();zhishi(1);delay_ms(50);}
  757.                                                                                                  if(b==2){display_menu();zhishi(2);delay_ms(50);}
  758.                         /* if(b==3){display_menu();zhishi(3);delay_ms(50);}
  759.                          if(b==4){display_menu();zhishi(4);delay_ms(50);}        
  760.                          if(b==5){display_menu2();zhishi(1);delay_ms(50);}
  761.                          if(b==6){display_menu2();zhishi(2);delay_ms(50);}        
  762.                          if(b==7){display_menu2();zhishi(3);delay_ms(50);}        */                                                                                                
  763.                                                                                  }
  764.                                                                         
  765.                                          }
  766.                                                     if((b==1)&&(key1==0))       //实时数据查看
  767.                                                                  {
  768.                              delay_ms(50);
  769.                                   if(key1==0)
  770.                                                                                         {
  771.                                                                                          b=0;
  772.                                                                                          c=0;                                                                                                                                       
  773.                                                                                          fanye=1;
  774.                                                                                          display1();
  775.                                                                                         }
  776.                                                                                         while(!key1);
  777.                                                                  }
  778.                                         if((b==2)&&(e==0))
  779.                                                                  {
  780.                                                                                                         if(key1==0)
  781.                                                                                                         {
  782.                                                                                                         delay_ms(50);
  783.                                                   if(key1==0)
  784.                                                                                                                                 {
  785.                                                                                                                                 display_mima();         //输入密码：1425
  786.                                                                                                                                 write(0,0x0f);          //打开光标显示
  787.                                                                                                                                 write(0,0x8a);
  788.                                                                                                                                 e=1;
  789.                                                                                                                           c=2;
  790.                                                                                                                                 delay_ms(50);  
  791.                                                                                                                                 }
  792.                                                                                                                          while(!key1);
  793.                                                                                                    }
  794.                                                                                 }
  795.                                                                                 if(e==1)
  796.                                                                                   {
  797.                                                                                                         if(key3==0)
  798.                                                                                                         {
  799.                                             delay_ms(50);        
  800.                                                 if(key3==0)
  801.                                                                                                                         {
  802.                                                                                                                       if(yi<9)
  803.                                                                                                                                         {
  804.                                                           yi++;
  805.                                                     }
  806.                                                 }
  807.                                     while(!key3);
  808.                                                                                                         }
  809.                                                                                              if(key2==0)
  810.                                                                                                         {
  811.                                             delay_ms(50);        
  812.                                                  if(key2==0)
  813.                                                                                                                          {
  814.                                                                                                                         if(yi>0)
  815.                                                                                                                                                 {
  816.                                                              yi--;
  817.                                                       }
  818.                                                  }
  819.                                      while(!key2);
  820.                                                                                                         }
  821.                                             write(0,0x8a);
  822.                                             write(1,0x30+yi);
  823.                                                                                                         delay_ms(50);
  824.                           if(key1==0)
  825.                                                                                                         {
  826.                                                                                                         delay_ms(50);
  827.                                                                                                                         if(key1==0)
  828.                                                                                                                         {
  829.                                                                                                                   write(0,0x8b);
  830.                                                                                                                         delay_ms(50);
  831.                                                                                                                         e=2;
  832.                                                                                                                         }
  833.                                                                                                         while(!key1);               
  834.                                                                                                         }                                                                                                                                 
  835.                                                                                          }
  836.                                                                                  if(e==2)
  837.                                                                                          {
  838.                                                                                                         if(key3==0)
  839.                                                                                                         {
  840.                                             delay_ms(50);        
  841.                                                 if(key3==0)
  842.                                                                                                                         {                                 
  843.                                                                                                                         if(er<9)
  844.                                                                                                                                                 {
  845.                                                             er++;
  846.                                                       }
  847.                                                }
  848.                                    while(!key3);
  849.                                                                                                          }
  850.                                             if(key2==0)
  851.                                                                                                          {
  852.                                               delay_ms(50);        
  853.                                                   if(key2==0)
  854.                                                                                                                                 {
  855.                                                             if(er>0)
  856.                                                                                                                                                 {
  857.                                                              er--;
  858.                                                        }
  859.                                                   }
  860.                                       while(!key2);
  861.                                                                                                                 }
  862.                                               write(0,0x8b);
  863.                                               write(1,0x30+er);
  864.                                                                                                                 delay_ms(50);
  865.                                   if(key1==0)
  866.                                                                                                                 {
  867.                                                                                                                 delay_ms(50);
  868.                                                                                                                                         if(key1==0)
  869.                                                                                                                                         {
  870.                                                                                                                                         write(0,0x8c);
  871.                                                                                                                                         delay_ms(50);
  872.                                                                                                                                         e=3;
  873.                                                                                                                                  }
  874.                                                                                                                 while(!key1);
  875.                                                                                                                 }                                                                                                                                                         
  876.                                                                                                  }
  877.                                                                                                 if(e==3)
  878.                                                                                                  {
  879.                                                                                                                 if(key3==0)
  880.                                                                                                                 {
  881.                                                   delay_ms(50);        
  882.                                                   if(key3==0)
  883.                                                                                                                                 {
  884.                                                                                                                          if(san<9)
  885.                                                                                                                                                  {
  886.                                                               san++;
  887.                                                         }
  888.                                                    }   
  889.                                       while(!key3);
  890.                                                                                                                 }
  891.                                                                                                         if(key2==0)
  892.                                                                                                                 {
  893.                                                delay_ms(50);        
  894.                                                    if(key2==0)
  895.                                                                                                                                  {
  896.                                                                                                                            if(san>0)
  897.                                                                                                                                                         {
  898.                                                                san--;
  899.                                                         }
  900.                                                   }
  901.                                       while(!key2);  
  902.                                                                                                                 }
  903.                                               write(0,0x8c);
  904.                                               write(1,0x30+san);
  905.                                                                                                                 delay_ms(50);
  906.                             if(key1==0)
  907.                                                                                                                 {
  908.                                                                                                                  delay_ms(50);
  909.                                                                                                                                 if(key1==0)
  910.                                                                                                                                 {
  911.                                                                                                                                 write(0,0x8d);
  912.                                                                                                                                 delay_ms(50);
  913.                                                                                                                                 e=4;
  914.                                                                                                                                 }
  915.                                                                                                                 while(!key1);
  916.                                                                                                                 }
  917.                                                                                                  }
  918.                                                                                                  if(e==4)
  919.                                                                                                  {
  920.                                                                                                                 if(key3==0)
  921.                                                                                                                 {
  922.                                                delay_ms(50);        
  923.                                                  if(key3==0)
  924.                                                                                                                    {
  925.                                                                                                                         if(si<9)
  926.                                                                                                                                     {
  927.                                                             si++;
  928.                                                       }
  929.                                                  }
  930.                                     while(!key3);
  931.                                                                                                                 }
  932.                                                                                                                 if(key2==0)
  933.                                                                                                                 {
  934.                                                delay_ms(50);        
  935.                                                    if(key2==0)
  936.                                                                                                                                  {
  937.                                                                                                                           if(si>0)
  938.                                                                                                                                                         {
  939.                                                               si--;
  940.                                                         }
  941.                                                    }
  942.                                       while(!key2);
  943.                                                                                                                 }
  944.                                                 write(0,0x8d);
  945.                                                 write(1,0x30+si);
  946.                                                                                                                         delay_ms(50);
  947.                             if(key1==0)
  948.                                                                                                                 {
  949.                                                                                                                         delay_ms(50);
  950.                                                                                                                                         if(key1==0)
  951.                                                                                                                                         {
  952.                                                                                                                                          write(0,0x0c);          //关闭光标显示
  953.                                                                                                                                                 if((yi==1)&&(er==4)&&(san==2)&&(si==5))//密码:1425
  954.                                                                                                                                                         {
  955.                                                                                                                                                         e=5;
  956.                                                                                                                                                         }
  957.                                                                                                                                                         if((yi!=1)||(er!=4)||(san!=2)||(si!=5))
  958.                                                                                                                                                         {
  959.                                                                                                                                                          display_error();   //密码错误
  960.                                                                                                                                                          delay_ms(3000);
  961.                                                                                                                                                          display_mima();
  962.                                                                                                                                                          write(0,0x0f); //打开光标显示
  963.                                                                                                                                                          write(0,0x8a);
  964.                                                                                                                                                          delay_ms(50);
  965.                                                                                                                                                          yi=er=san=si=0;
  966.                                                                                                                                                          e=1;
  967.                                                                                                                                                          }
  968.                                                                                                                                          }
  969.                                                                                                                         while(!key1);
  970.                                                                                                                 }                                                                                                                                                         
  971.                                                                                                 }
  972.                                                                                                 if((e==5)&&(fanye2==0))
  973.                                                                                                 {
  974.                                                                                                                 if((b==2)&&(key1==0))        //上下限设置
  975.                                                                                                                 {         
  976.                                                delay_ms(50);
  977.                                             if(key1==0)
  978.                                                                                                               {
  979.                                                                                                                                  fanye2=1;
  980.                                                                                                                                  f=1;
  981.                                                                                                                                  display1_1();
  982.                                                                                                                                  write(0,0x93);
  983.                                                    write(1,0x30+guang_shang/10000);
  984.                                                                                                                                  write(0,0x94);
  985.                                                    write(1,0x30+guang_shang/1000%10);
  986.                                                    write(0,0x95);
  987.                                                    write(1,0x30+guang_shang/100%10);
  988.                                                                                                                                  write(0,0x96);
  989.                                                    write(1,0x30+guang_shang/10%10);
  990.                                                    write(0,0x97);
  991.                                                    write(1,0x30+guang_shang%10);
  992.                                                                                                                                  write(0,0x8b);
  993.                                                    write(1,0x30+guang_xia/10000);
  994.                                                                                                                                  write(0,0x8c);
  995.                                                    write(1,0x30+guang_xia/1000%10);
  996.                                                    write(0,0x8d);
  997.                                                    write(1,0x30+guang_xia/100%10);
  998.                                                                                                                                  write(0,0x8e);
  999.                                                    write(1,0x30+guang_xia/10%10);
  1000.                                                    write(0,0x8f);
  1001.                                                    write(1,0x30+guang_xia%10);
  1002.                                                                                                                                  write(0,0x0f);         //打开光标显示
  1003.                                                                                                                                  write(0,0x93);
  1004.                                                                                                                                 }
  1005.                                                                                                                                 while(!key1);
  1006.                                                                                                           }
  1007.                                                                                                 }
  1008.                                                                                                 if(fanye2==1)             //光照
  1009.                                                                                                 {
  1010.                                                                                                      if(f==1)           //光照上限万位
  1011.                                                                                                      {     
  1012.                                                                                                                           if(g==0)
  1013.                                                                                                                                   {
  1014.                                                                                                                             wan=guang_shang/10000;
  1015.                                                                                                                                         g=1;
  1016.                                                                                                                             }
  1017.                                                                                                                              anjian_wan();
  1018.                                                                                                                                          write(0,0x93);
  1019.                                                                                                                                          write(1,0x30+wan);
  1020.                                                                                                                      if(key1==0)
  1021.                                                                                                                        {
  1022.                                                      delay_ms(50);
  1023.                                                     if(key1==0)
  1024.                                                                                                                                               {
  1025.                                                                                                                                          write(0,0x94);
  1026.                                                                        f=2;
  1027.                                                                                                                                                                  g=0;
  1028.                                                                                                                                         }
  1029.                                                           while(!key1);
  1030.                                                                                                            }
  1031.                                                                                                                         }
  1032.                                                                                                                  if(f==2)            //光照上限千位
  1033.                                                                                                                  {     
  1034.                                                                                                                          if(g==0)
  1035.                                                                                                                                  {
  1036.                                                                                                                             qian=guang_shang/1000%10;
  1037.                                                                                                                                          g=1;
  1038.                                                                                                                             }
  1039.                                                                                                                              anjian_qian();
  1040.                                                                                                                                          write(0,0x94);
  1041.                                                                                                                                          write(1,0x30+qian);
  1042.                                                                                                                        if(key1==0)
  1043.                                                                                                                        {
  1044.                                                      delay_ms(50);
  1045.                                                     if(key1==0)
  1046.                                                                                                                                               {
  1047.                                                                                                                                          write(0,0x95);
  1048.                                                                        f=3;
  1049.                                                                                                                                                                  g=0;
  1050.                                                                                                                                         }
  1051.                                                          while(!key1);
  1052.                                                                                                            }
  1053.                                                                                                                         }
  1054.                                                                                                                  if(f==3)        //光照上限百位
  1055.                                                                                                                  {
  1056.                                                                                                                          if(g==0)
  1057.                                                                                                                                  {
  1058.                                                                                                                             bai=guang_shang/100%10;
  1059.                                                                                                                                          g=1;
  1060.                                                                                                                             }
  1061.                                                                                                                              anjian_bai();
  1062.                                                                                                                                          write(0,0x95);
  1063.                                                                                                                                          write(1,0x30+bai);
  1064.                                                                                                                        if(key1==0)
  1065.                                                                                                                        {
  1066.                                                      delay_ms(50);
  1067.                                                     if(key1==0)
  1068.                                                                                                                                               {
  1069.                                                                                                                                          write(0,0x96);
  1070.                                                                        f=4;
  1071.                                                                                                                                                                  g=0;
  1072.                                                                                                                                         }
  1073.                                                          while(!key1);
  1074.                                                                                                            }
  1075.                                                                                                                         }
  1076.                                                                                                                  if(f==4)           //光照上限十位
  1077.                                                                                                                  {
  1078.                                                                                                                          if(g==0)
  1079.                                                                                                                                  {
  1080.                                                                                                                             shi=guang_shang/10%10;
  1081.                                                                                                                                          g=1;
  1082.                                                                                                                             }
  1083.                                                                                                                              anjian_shi();
  1084.                                                                                                                                          write(0,0x96);
  1085.                                                                                                                                          write(1,0x30+shi);
  1086.                                                                                                                        if(key1==0)
  1087.                                                                                                                        {
  1088.                                                      delay_ms(50);
  1089.                                                     if(key1==0)
  1090.                                                                                                                                               {
  1091.                                                                                                                                          write(0,0x97);
  1092.                                                                        f=5;
  1093.                                                                                                                                                                  g=0;
  1094.                                                                                                                                          }
  1095.                                                          while(!key1);
  1096.                                                                                                            }
  1097.                                                                                                                         }
  1098.                                                                                                                  if(f==5)      //光照上限个位
  1099.                                                                                                                  {     
  1100.                                                                                                                          if(g==0)
  1101.                                                                                                                                  {
  1102.                                                                                                                             ge=guang_shang%10;
  1103.                                                                                                                                          g=1;
  1104.                                                                                                                             }
  1105.                                                                                                                              anjian_ge();
  1106.                                                                                                                                          write(0,0x97);
  1107.                                                                                                                                          write(1,0x30+ge);
  1108.                                                                                                                        if(key1==0)
  1109.                                                                                                                        {
  1110.                                                      delay_ms(50);
  1111.                                                     if(key1==0)
  1112.                                                                                                                                               {
  1113.                                                                                                                                                                 guang_shang=wan*10000+qian*1000+bai*100+shi*10+ge;//光照上限
  1114.                                                                                                                                                                         
  1115.                                                                                                                                                                  wan=qian=bai=shi=ge=0;
  1116.                                                                                                                                          write(0,0x8b);
  1117.                                                                        f=6;
  1118.                                                                                                                                                                  g=0;
  1119.                                                                                                                                         }
  1120.                                                          while(!key1);
  1121.                                                                                                            }
  1122.                                                                                                                         }
  1123.                                                                                                                  if(f==6)         //光照下限万位
  1124.                                                                                                                  {
  1125.                                                                                                                            if(g==0)
  1126.                                                                                                                                   {
  1127.                                                                                                                             wan=guang_xia/10000;
  1128.                                                                                                                                         g=1;
  1129.                                                                                                                             }
  1130.                                                                                                                            anjian_wan();
  1131.                                                                                                                                  write(0,0x8b);
  1132.                                                                                                                            write(1,0x30+wan);
  1133.                                                                                                                                  if(key1==0)
  1134.                                   {
  1135.                                                      delay_ms(50);
  1136.                                                     if(key1==0)
  1137.                                                                                                                                               {
  1138.                                                                                                                                          write(0,0x8c);
  1139.                                                                        f=7;
  1140.                                                                                                                                                                  g=0;
  1141.                                                                                                                                          }
  1142.                                                          while(!key1);
  1143.                                                                                                                                   }
  1144.                                                                                                                   }
  1145.                                                                                                                   if(f==7)        //光照下限千位
  1146.                                                                                                                   {
  1147.                                                                                                                                  if(g==0)
  1148.                                                                                                                                   {
  1149.                                                                                                                             qian=guang_xia/1000%10;
  1150.                                                                                                                                         g=1;
  1151.                                                                                                                             }
  1152.                                                                                                                            anjian_qian();
  1153.                                                                                                                                  write(0,0x8c);
  1154.                                                                                                                            write(1,0x30+qian);
  1155.                                                                                                                                  if(key1==0)
  1156.                                   {
  1157.                                                      delay_ms(50);
  1158.                                                     if(key1==0)
  1159.                                                                                                                                               {
  1160.                                                                                                                                          write(0,0x8d);
  1161.                                                                        f=8;
  1162.                                                                                                                                                                  g=0;
  1163.                                                                                                                                         }
  1164.                                                         while(!key1);
  1165.                                                                                                                                   }
  1166.                                                                                                                   }
  1167.                                                                                                                  if(f==8)          //光照下限百位
  1168.                                                                                                                  {
  1169.                                                                                                                            if(g==0)
  1170.                                                                                                                                   {
  1171.                                                                                                                             bai=guang_xia/100%10;
  1172.                                                                                                                                         g=1;
  1173.                                                                                                                             }
  1174.                                                                                                                            anjian_bai();
  1175.                                                                                                                                  write(0,0x8d);
  1176.                                                                                                                            write(1,0x30+bai);
  1177.                                                                                                                                  if(key1==0)
  1178.                                   {
  1179.                                                      delay_ms(50);
  1180.                                                     if(key1==0)
  1181.                                                                                                                                               {
  1182.                                                                                                                                          write(0,0x8e);
  1183.                                                                        f=9;
  1184.                                                                                                                                                                  g=0;
  1185.                                                                                                                                         }
  1186.                                                         while(!key1);
  1187.                                                                                                                                   }
  1188.                                                                                                                   }
  1189.                                                                                                                  if(f==9)         //光照下限十位
  1190.                                                                                                                  {
  1191.                                                                                                                                               //标志位g
  1192.                                                                                                                            anjian_shi();
  1193.                                                                                                                                  write(0,0x8e);
  1194.                                                                                                                            write(1,0x30+shi);
  1195.                                                                                                                                  if(key1==0)
  1196.                                   {
  1197.                                                      delay_ms(50);
  1198.                                                     if(key1==0)
  1199.                                                                                                                                               {
  1200.                                                                                                                                          write(0,0x8f);
  1201.                                                                        f=10;
  1202.                                                                                                                                         }
  1203.                                                         while(!key1);  
  1204.                                                                                                                                   }
  1205.                                                                                                                   }
  1206.                                                                                                                  if(f==10)        //光照下限个位
  1207.                                                                                                                  {
  1208.                                                                                                                            anjian_ge();
  1209.                                                                                                                                  write(0,0x8f);
  1210.                                                                                                                            write(1,0x30+ge);
  1211.                                                                                                                                  if(key1==0)
  1212.                                   {
  1213.                                                      delay_ms(50);
  1214.                                                     if(key1==0)
  1215.                                                                                                                                               {
  1216.                                                                                                                                                            guang_xia=wan*10000+qian*1000+bai*100+shi*10+ge;//光照下限
  1217.                                                                                                                                                                  wan=qian=bai=shi=ge=0;
  1218.                                                                                                                                                                  fanye2=2;
  1219.                                                                                                                                                                  write(0,0x0c);     //关闭光标显示
  1220.                                                                                                                                                                  display1_2();           //风速
  1221.                                                                                                                                                                  write(0,0x93);
  1222.                                                            write(1,0x30+feng_shang/10);
  1223.                                                                                                                                          write(0,0x94);
  1224.                                                            write(1,0x30+feng_shang%10);
  1225.                                                                        f=1;
  1226.                                                                                                                                                                  write(0,0x0f);         //打开光标显示
  1227.                                                                                                                                          write(0,0x93);
  1228.                                                                                                                                         }
  1229.                                                           while(!key1);
  1230.                                                                                                                                   }
  1231.                                                                                                                   }
  1232.                                                                                                         }         
  1233.                                                                                                 if(fanye2==2)             //风速
  1234.                          {
  1235.                                                                                                      if(f==1)               //风速上限十位
  1236.                                                                                                                   {
  1237.                                                                                                                       anjian_shi();
  1238.                                                                                                                             write(0,0x93);
  1239.                                                                                                                                         write(1,0x30+shi);
  1240.                                                                                                                                         if(key1==0)
  1241.                                   {
  1242.                                                      delay_ms(50);
  1243.                                                     if(key1==0)
  1244.                                                                                                                                               {
  1245.                                                                                                                                          write(0,0x94);
  1246.                                                                        f=2;
  1247.                                                                                                                                         }
  1248.                                                         while(!key1);
  1249.                                                                                                                                   }
  1250.                                                                                                                   }
  1251.                                                                                                                 if(f==2)            //风速上限个位
  1252.                                                                                                                   {
  1253.                                                                                                                       anjian_ge();
  1254.                                                                                                                             write(0,0x94);
  1255.                                                                                                                                         write(1,0x30+ge);
  1256.                                                                                                                                         if(key1==0)
  1257.                                   {
  1258.                                                      delay_ms(50);
  1259.                                                     if(key1==0)
  1260.                                                                                                                                               {
  1261.                                                                                                                                                                  feng_shang=shi*10+ge;     //风速上限
  1262.                                                                                                                                                                  shi=ge=0;
  1263.                                                                                                                                                                  fanye2=3;
  1264.                                                                                                                                                                  write(0,0x0c);     //关闭光标显示
  1265.                                                                                                                                                                   display1_3();          //温度
  1266.                                                                                                                                                                  write(0,0x94);
  1267.                                                            write(1,0x30+wendu_shang/10);
  1268.                                                                                                                                          write(0,0x95);
  1269.                                                            write(1,0x30+wendu_shang%10);
  1270.                                                                                                                                                                  write(0,0x8c);
  1271.                                                            write(1,0x30+wendu_xia/10);
  1272.                                                                                                                                          write(0,0x8d);
  1273.                                                            write(1,0x30+wendu_xia%10);
  1274.                                                                                                                                                                         
  1275.                                                                                                                                                                  f=1;
  1276.                                                                                                                                                                  write(0,0x0f);         //打开光标显示
  1277.                                                                                                                                          write(0,0x93);
  1278.                                                                                                                                          }
  1279.                                                         while(!key1);
  1280.                                                                                                                                   }
  1281.                                                                                                                  }
  1282.                                                                                                 }
  1283.                                                                                          if(fanye2==3)              //温度
  1284.                                                                                            {
  1285.                                                                                             if(f==1)            //温度上限符号
  1286.                                                                                                     {
  1287.                                                                                                           anjian_fuhao();
  1288.                                                                                                                                         write(0,0x93);
  1289.                                                                                                                                         write(1,bai);
  1290.                                                                                                                                 if(key1==0)
  1291.                                   {
  1292.                                                      delay_ms(50);
  1293.                                                     if(key1==0)
  1294.                                                                                                                                               {
  1295.                                                                                                                                          write(0,0x94);
  1296.                                                                        f=2;
  1297.                                                                                                                                         }
  1298.                                                         while(!key1);
  1299.                                                                                                                                   }
  1300.                                                                                                      }
  1301.                                                                                                                 if(f==2)         //温度上限十位
  1302.                                                                                                                  {
  1303.                                                                                                                       anjian_shi();
  1304.                                                                                                                             write(0,0x94);
  1305.                                                                                                                                         write(1,0x30+shi);
  1306.                                                                                                                                         if(key1==0)
  1307.                                   {
  1308.                                                      delay_ms(50);
  1309.                                                     if(key1==0)
  1310.                                                                                                                                               {
  1311.                                                                                                                                          write(0,0x95);
  1312.                                                                        f=3;
  1313.                                                                                                                                          }
  1314.                                                          while(!key1);
  1315.                                                                                                                                   }
  1316.                                                                                                                  }
  1317.                                                                                                                 if(f==3)            //温度上限个位
  1318.                                                                                                                  {
  1319.                                                                                                                       anjian_ge();
  1320.                                                                                                                             write(0,0x95);
  1321.                                                                                                                                         write(1,0x30+ge);
  1322.                                                                                                                                         if(key1==0)
  1323.                                   {
  1324.                                                      delay_ms(50);
  1325.                                                     if(key1==0)
  1326.                                                                                                                                               {
  1327.                                                                                                                                                                  wendu_shang=shi*10+ge;     //温度上限
  1328.                                                                                                                                                                  bai=shi=ge=0;
  1329.                                                                                                                                          write(0,0x8b);
  1330.                                                                        f=4;
  1331.                                                                                                                                         }
  1332.                                                        while(!key1);
  1333.                                                                                                                                   }
  1334.                                                                                                                  }
  1335.                                 if(f==4)         //温度下限符号
  1336.                                                                                                      {
  1337.                                                                                                           anjian_fuhao();
  1338.                                                                                                                                         write(0,0x8b);
  1339.                                                                                                                                         write(1,bai);
  1340.                                                                                                                                 if(key1==0)
  1341.                                   {
  1342.                                                      delay_ms(50);
  1343.                                                     if(key1==0)
  1344.                                                                                                                                               {
  1345.                                                                                                                                          write(0,0x8c);
  1346.                                                                        f=5;
  1347.                                                                                                                                         }
  1348.                                                         while(!key1);
  1349.                                                                                                                                   }
  1350.                                                                                                      }
  1351.                            if(f==5)            //温度下限十位
  1352.                                                                                                                  {
  1353.                                                                                                                       anjian_shi();
  1354.                                                                                                                             write(0,0x8c);
  1355.                                                                                                                                         write(1,0x30+shi);
  1356.                                                                                                                                         if(key1==0)
  1357.                                   {
  1358.                                                      delay_ms(50);
  1359.                                                     if(key1==0)
  1360.                                                                                                                                               {
  1361.                                                                                                                                          write(0,0x8d);
  1362.                                                                        f=6;
  1363.                                                                                                                                         }
  1364.                                                          while(!key1);
  1365.                                                                                                                                   }
  1366.                                                                                                                  }        
  1367.                                                                                                    if(f==6)             //温度下限个位
  1368.                                                                                                                  {
  1369.                                                                                                                       anjian_ge();
  1370.                                                                                                                             write(0,0x8d);
  1371.                                                                                                                                         write(1,0x30+ge);
  1372.                                                                                                                                         if(key1==0)
  1373.                                   {
  1374.                                                      delay_ms(50);
  1375.                                                     if(key1==0)
  1376.                                                                                                                                               {
  1377.                                                                                                                                                                  wendu_xia=shi*10+ge;     //温度下限
  1378.                                                                                                                                                                  bai=shi=ge=0;
  1379.                                                                        fanye2=4;
  1380.                                                                                                                                                                  write(0,0x0c);     //关闭光标显示
  1381.                                                                                                                                                                  display1_4();       //湿度
  1382.                                                                                                                                                                  write(0,0x93);
  1383.                                                            write(1,0x30+shidu_shang/10);
  1384.                                                                                                                                          write(0,0x94);
  1385.                                                            write(1,0x30+shidu_shang%10);
  1386.                                                                                                                                                                  write(0,0x8b);
  1387.                                                            write(1,0x30+shidu_xia/10);
  1388.                                                                                                                                          write(0,0x8c);
  1389.                                                            write(1,0x30+shidu_xia%10);
  1390.                                                                                                                                                                  f=1;
  1391.                                                                                                                                                                  write(0,0x0f);         //打开光标显示
  1392.                                                                                                                                          write(0,0x93);
  1393.                                                                                                                                          }
  1394.                                                          while(!key1);
  1395.                                                                                                                                   }
  1396.                                                                                                                  }
  1397.                                                                                                 }
  1398.                                                                                         if(fanye2==4)               //湿度
  1399.                                                                                            {
  1400.                                                                                             if(f==1)                 //湿度上限十位
  1401.                                                                                                                  {
  1402.                                                                                                                       anjian_shi();
  1403.                                                                                                                             write(0,0x93);
  1404.                                                                                                                                         write(1,0x30+shi);
  1405.                                                                                                                                         if(key1==0)
  1406.                                   {
  1407.                                                      delay_ms(50);
  1408.                                                     if(key1==0)
  1409.                                                                                                                                               {
  1410.                                                                                                                                          write(0,0x94);
  1411.                                                                        f=2;
  1412.                                                                                                                                         }
  1413.                                                         while(!key1);
  1414.                                                                                                                                   }
  1415.                                                                                                                  }
  1416.                                                                                                                 if(f==2)              //湿度上限个位
  1417.                                                                                                                  {
  1418.                                                                                                                       anjian_ge();
  1419.                                                                                                                             write(0,0x94);
  1420.                                                                                                                                         write(1,0x30+ge);
  1421.                                                                                                                                         if(key1==0)
  1422.                                   {
  1423.                                                      delay_ms(50);
  1424.                                                     if(key1==0)
  1425.                                                                                                                                               {
  1426.                                                                                                                                                                  shidu_shang=shi*10+ge;     //湿度上限
  1427.                                                                                                                                                                  shi=ge=0;
  1428.                                                                                                                                          write(0,0x8b);
  1429.                                                                        f=3;
  1430.                                                                                                                                         }
  1431.                                                         while(!key1);
  1432.                                                                                                                                   }
  1433.                                                                                                                  }
  1434.                            if(f==3)              // 湿度下限十位
  1435.                                                                                                                  {
  1436.                                                                                                                       anjian_shi();
  1437.                                                                                                                             write(0,0x8b);
  1438.                                                                                                                                         write(1,0x30+shi);
  1439.                                                                                                                                         if(key1==0)
  1440.                                   {
  1441.                                                      delay_ms(50);
  1442.                                                     if(key1==0)
  1443.                                                                                                                                               {
  1444.                                                                                                                                          write(0,0x8c);
  1445.                                                                        f=4;
  1446.                                                                                                                                          }
  1447.                                                           while(!key1);
  1448.                                                                                                                                   }
  1449.                                                                                                                  }        
  1450.                                                                                                    if(f==4)                  //湿度下限个位
  1451.                                                                                                                  {
  1452.                                                                                                                       anjian_ge();
  1453.                                                                                                                             write(0,0x8c);
  1454.                                                                                                                                         write(1,0x30+ge);
  1455.                                                                                                                                  if(key1==0)
  1456.                                   {
  1457.                                                      delay_ms(50);
  1458.                                                     if(key1==0)
  1459.                                                                                                                                               {
  1460.                                                                                                                                                                  shidu_xia=shi*10+ge;     //湿度下限
  1461.                                                                                                                                                                  shi=ge=0;
  1462.                                                                                                                                                                  fanye2=5;
  1463.                                                                                                                                                                  write(0,0x0c);     //关闭光标显示
  1464.                                                                                                                                                                  display1_5();          //土温
  1465.                                                                                                                                                                  write(0,0x94);
  1466.                                                            write(1,0x30+tuwen_shang/10);
  1467.                                                                                                                                          write(0,0x95);
  1468.                                                            write(1,0x30+tuwen_shang%10);
  1469.                                                                                                                                                                  write(0,0x8c);
  1470.                                                            write(1,0x30+tuwen_xia/10);
  1471.                                                                                                                                          write(0,0x8d);
  1472.                                                            write(1,0x30+tuwen_xia%10);
  1473.                                                                                                                                                                  write(0,0x0f);         //打开光标显示
  1474.                                                                                                                                          write(0,0x93);
  1475.                                                                                                                                                                  f=1;
  1476.                                                                                                                                          }
  1477.                                                          while(!key1);
  1478.                                                                                                                                   }
  1479.                                                                                                                  }
  1480.                                                                                                 }
  1481.                                                                                          if(fanye2==5)                //土温
  1482.                                                                                           {
  1483.                                                                                             if(f==1)                    //土温上限符号
  1484.                                                                                                     {
  1485.                                                                                                           anjian_fuhao();
  1486.                                                                                                                                         write(0,0x93);
  1487.                                                                                                                                         write(1,bai);
  1488.                                                                                                                                 if(key1==0)
  1489.                                   {
  1490.                                                      delay_ms(50);
  1491.                                                     if(key1==0)
  1492.                                                                                                                                               {
  1493.                                                                                                                                          write(0,0x94);
  1494.                                                                        f=2;
  1495.                                                                                                                                         }
  1496.                                                          while(!key1);
  1497.                                                                                                                                   }
  1498.                                                                                                      }
  1499.                                                                                                                 if(f==2)       //土温上限十位
  1500.                                                                                                                  {
  1501.                                                                                                                       anjian_shi();
  1502.                                                                                                                             write(0,0x94);
  1503.                                                                                                                                         write(1,0x30+shi);
  1504.                                                                                                                                         if(key1==0)
  1505.                                   {
  1506.                                                      delay_ms(50);
  1507.                                                     if(key1==0)
  1508.                                                                                                                                               {
  1509.                                                                                                                                          write(0,0x95);
  1510.                                                                        f=3;
  1511.                                                                                                                                           }
  1512.                                                          while(!key1);
  1513.                                                                                                                                   }
  1514.                                                                                                                  }
  1515.                                                                                                                 if(f==3)           //土温上限个位
  1516.                                                                                                                  {
  1517.                                                                                                                       anjian_ge();
  1518.                                                                                                                             write(0,0x95);
  1519.                                                                                                                                         write(1,0x30+ge);
  1520.                                                                                                                                         if(key1==0)
  1521.                                   {
  1522.                                                      delay_ms(50);
  1523.                                                     if(key1==0)
  1524.                                                                                                                                               {
  1525.                                                                                                                                                                  tuwen_shang=shi*10+ge;     //土温上限
  1526.                                                                                                                                                                  bai=shi=ge=0;
  1527.                                                                                                                                          write(0,0x8b);
  1528.                                                                        f=4;
  1529.                                                                                                                                         }
  1530.                                                         while(!key1);
  1531.                                                                                                                                   }
  1532.                                                                                                                  }
  1533.                                 if(f==4)          //土温下限符号
  1534.                                                                                                      {
  1535.                                                                                                           anjian_fuhao();
  1536.                                                                                                                                         write(0,0x8b);
  1537.                                                                                                                                         write(1,bai);
  1538.                                                                                                                                 if(key1==0)
  1539.                                   {
  1540.                                                      delay_ms(50);
  1541.                                                     if(key1==0)
  1542.                                                                                                                                               {
  1543.                                                                                                                                          write(0,0x8c);
  1544.                                                                        f=5;
  1545.                                                                                                                                          }
  1546.                                                          while(!key1);
  1547.                                                                                                                                   }
  1548.                                                                                                      }
  1549.                            if(f==5)         //土温下限十位
  1550.                                                                                                                  {
  1551.                                                                                                                       anjian_shi();
  1552.                                                                                                                             write(0,0x8c);
  1553.                                                                                                                                         write(1,0x30+shi);
  1554.                                                                                                                                         if(key1==0)
  1555.                                   {
  1556.                                                      delay_ms(50);
  1557.                                                     if(key1==0)
  1558.                                                                                                                                               {
  1559.                                                                                                                                          write(0,0x8d);
  1560.                                                                        f=6;
  1561.                                                                                                                                         }
  1562.                                                         while(!key1);
  1563.                                                                                                                                   }
  1564.                                                                                                                  }        
  1565.                                                                                                    if(f==6)            //土温下限个位
  1566.                                                                                                                  {
  1567.                                                                                                                       anjian_ge();
  1568.                                                                                                                             write(0,0x8d);
  1569.                                                                                                                                         write(1,0x30+ge);
  1570.                                                                                                                                         if(key1==0)
  1571.                                   {
  1572.                                                      delay_ms(50);
  1573.                                                     if(key1==0)
  1574.                                                                                                                                               {
  1575.                                                                                                                                                                  tuwen_xia=shi*10+ge;     //土温下限
  1576.                                                                                                                                                                  bai=shi=ge=0;
  1577.                                                                        fanye2=6;
  1578.                                                                                                                                                                  write(0,0x0c);     //关闭光标显示
  1579.                                                                                                                                                                  display1_6();       //土湿
  1580.                                                                                                                                                                  write(0,0x93);
  1581.                                                            write(1,0x30+tushi_shang/10);
  1582.                                                                                                                                          write(0,0x94);
  1583.                                                            write(1,0x30+tushi_shang%10);
  1584.                                                                                                                                                                  write(0,0x8b);
  1585.                                                            write(1,0x30+tushi_xia/10);
  1586.                                                                                                                                          write(0,0x8c);
  1587.                                                            write(1,0x30+tushi_xia%10);
  1588.                                                                                                                                                                  f=1;
  1589.                                                                                                                                                                  write(0,0x0f);         //打开光标显示
  1590.                                                                                                                                          write(0,0x93);
  1591.                                                                                                                                         }
  1592.                                                         while(!key1);
  1593.                                                                                                                                   }
  1594.                                                                                                                  }
  1595.                                                                                                 }
  1596.                                                                                 if(fanye2==6)                  //土湿
  1597.                                                                                           {
  1598.                                                                                             if(f==1)                 //土湿上限十位
  1599.                                                                                                                  {
  1600.                                                                                                                       anjian_shi();
  1601.                                                                                                                             write(0,0x93);
  1602.                                                                                                                                         write(1,0x30+shi);
  1603.                                                                                                                                         if(key1==0)
  1604.                                   {
  1605.                                                      delay_ms(50);
  1606.                                                     if(key1==0)
  1607.                                                                                                                                               {
  1608.                                                                                                                                          write(0,0x94);
  1609.                                                                        f=2;
  1610.                                                                                                                                         }
  1611.                                                         while(!key1);
  1612.                                                                                                                                   }
  1613.                                                                                                                  }
  1614.                                                                                                                 if(f==2)           //土湿上限个位
  1615.                                                                                                                  {
  1616.                                                                                                                       anjian_ge();
  1617.                                                                                                                             write(0,0x94);
  1618.                                                                                                                                         write(1,0x30+ge);
  1619.                                                                                                                                         if(key1==0)
  1620.                                   {
  1621.                                                      delay_ms(50);
  1622.                                                     if(key1==0)
  1623.                                                                                                                                               {
  1624.                                                                                                                                                                  tushi_shang=shi*10+ge;     //土湿上限
  1625.                                                                                                                                                                  shi=ge=0;
  1626.                                                                                                                                          write(0,0x8b);
  1627.                                                                        f=3;
  1628.                                                                                                                                         }
  1629.                                                         while(!key1);
  1630.                                                                                                                                   }
  1631.                                                                                                                  }
  1632.                            if(f==3)            //土湿下限十位
  1633.                                                                                                                  {
  1634.                                                                                                                       anjian_shi();
  1635.                                                                                                                             write(0,0x8b);
  1636.                                                                                                                                         write(1,0x30+shi);
  1637.                                                                                                                                         if(key1==0)
  1638.                                   {
  1639.                                                      delay_ms(50);
  1640.                                                     if(key1==0)
  1641.                                                                                                                                               {
  1642.                                                                                                                                          write(0,0x8c);
  1643.                                                                        f=4;
  1644.                                                                                                                                          }
  1645.                                                          while(!key1);
  1646.                                                                                                                                   }
  1647.                                                                                                                  }
  1648.                                                                                                    if(f==4)             //土湿下限个位
  1649.                                                                                                                  {
  1650.                                                                                                                       anjian_ge();
  1651.                         
复制代码

程序4.zip

113.89 KB, 下载次数: 29

12864

评分

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

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:261451 发表于 2018-7-19 16:52 | 只看该作者
水平有限，stc89c52rc的8k内存写满了，功能还不完善，不知道有没有大神指点一下怎么优化一下
回复

使用道具 举报

板凳
ID:261451 发表于 2018-7-19 17:36 | 只看该作者
程序没写完，占不下了，不过下面基本都是一种方法写的
回复

使用道具 举报

地板
ID:451441 发表于 2018-12-24 17:18 | 只看该作者
谢谢LZ的分享
回复

使用道具 举报

5#
ID:451718 发表于 2018-12-24 19:04 | 只看该作者
这个好，正是我想要的。不过代码的效率可能有点低，等我看完了，看看能不能优化一下算法。
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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