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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机DIY制作 › 单片机做的半导体制冷小冰箱 原理图和程序
返回列表 发新帖
查看: 28541|回复: 37
打印 上一主题 下一主题
收起左侧

单片机做的半导体制冷小冰箱 原理图和程序

  [复制链接]
跳转到指定楼层
楼主
ID:128771 发表于 2016-7-5 02:52 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式

所有制作资料下载： 电子小冰箱.zip (151.1 KB, 下载次数: 479)

冰冰可乐什么的真的太适合不过了。。器材：一个电源模块，220v转12v，6A。以及一个封装好的制冷器，元件清单都在原理图上可以看出来，继电器用的是继电器模块。

防水型的18B20，继电器模块，12c887时间芯片，12864液晶屏，蜂鸣器，89c58单片机芯片，接线子，什么开关，按键，电阻电容的你也应该知道的，就是一个单片机模块。。这些就是控制板的元件了，然后你还要去淘宝上买制冷器和制冷器血药的配套的电源模块。。然后你就可以自己DAY一个小冰箱了。。

这是控制系统板子散件



焊接好的控制板



连接好的



这些都是可以实现的功能。。






这是一个定时关闭的功能















最低温度你们看吧！里面没放任何东西的情况下的最低温度了，之后的实际使用中只有2度左右，上完课回来后喝 ...


半导体制冷冰箱的程序：
  1.        #include
  2.        #include
  3. #define uchar unsigned char
  4. #define uint unsigned int
  5. sbit ds=P2^2;
  6. sbit rs=P3^5;
  7. sbit rw=P3^6;
  8. sbit en=P3^4;
  9. sbit psb=P3^7;
  10. sbit feng=P2^0;
  11. sbit dscs=P1^4;
  12. sbit dsas=P1^5;
  13. sbit dsrw=P1^6;
  14. sbit dsds=P1^7;
  15. sbit dsirq=P3^3;
  16. sbit jidianqi=P2^3;
  17. bit flag1,flag_ri;
  18. sbit xuanzhe=P1^0;
  19. sbit queding=P1^1;
  20. sbit fanhui=P1^2;
  21. sbit tiaozheng=P1^3;
  22. sbit zengjia=P3^0;
  23. sbit jianxiao=P3^1;
  24. uint temp;
  25. int x1,x3;
  26. uchar flog1,flog,count,count1,acount1,count2,acount2,s1num,flag,t0_num,ff,xh,xh1,xh2,xw,xw1,xw2,xx,xt,axt,xt1,axt1,hh,ahh;
  27. char miao,shi,fen,year,month,day,week,amiao,afen,ashi;
  28. float f_temp;
  29. uchar code table00[]={"  系统初始化... "};
  30. uchar code table01[]={"    以关闭"};
  31. uchar code table02[]={"    以开启"};

  33. uchar code table0_0[]={"电气与"};
  34. uchar code table0_1[]={"    信息工程学院"};
  35. uchar code table0_2[]={"--电气1302唐小旺"};
  36. uchar code table0_3[]={"  湖南工学院  "};

  38. uchar code table11[]={"2015年00月00日"};
  39. uchar code table12[]={"        "};
  40. uchar code table13[]={"  00: 00: 00"};
  41. uchar code table14[]={"当前温度："};

  43. uchar code table1[]={"菜  1:温度调节"};
  44. uchar code table2[]={"单  2:定时关闭"};
  45. uchar code table3[]={"1   3:报警温度调"};
  46. uchar code table4[]={"    4:时间调节"};
  47. uchar code table5[]={"菜  5:闹钟调节"};
  48. uchar code table6[]={"单  6:小小游戏"};
  49. uchar code table7[]={"2   7:小小说明"};
  50. uchar code table8[]={"--在按选择键返回"};

  52. uchar code table1_1[]={"设置温度："};
  53. uchar code table1_2[]={"      00"};
  54. uchar code table1_3[]={""};
  55. uchar code table1_4[]={""};
  56. uchar code table1_5[]={"    设置成功"};
  57. uchar code table1_6[]={""};
  58. uchar code table1_7[]={""};
  59. uchar code table1_8[]={""};

  61. uchar code table2_1[]={"设置定时开关："};
  62. uchar code table2_2[]={"  1:开启定时关闭"};
  63. uchar code table2_3[]={"  2:关闭定时关闭"};
  64. uchar code table2_4[]={"~~~~~~~~~~~~~~~~"};
  65. uchar code table2_5[]={"设置时间:"};
  66. uchar code table2_6[]={"  00: 00: 00"};
  67. uchar code table2_7[]={""};
  68. uchar code table2_8[]={"    设置成功"};
  69. uchar code table2_9[]={"正在计时关闭中"};
  70. uchar code table2_a[]={""};
  71. uchar code table2_b[]={""};
  72. uchar code table2_c[]={"    设置成功"};
  73. uchar code table2_d[]={"以关闭定时关闭"};
  74. uchar code table2_e[]={""};

  76. uchar code table3_1[]={"设置报警温度："};
  77. uchar code table3_2[]={"      00"};
  78. uchar code table3_3[]={""};
  79. uchar code table3_4[]={""};
  80. uchar code table3_5[]={"    设置成功"};
  81. uchar code table3_6[]={"    滴滴滴滴"};
  82. uchar code table3_7[]={"定时炸弹即将爆炸"};

  84. uchar code table4_1[]={"设置时间："};
  85. uchar code table4_2[]={"2015年03月22日"};
  86. uchar code table4_3[]={"  Sun      "};
  87. uchar code table4_4[]={"  00: 00: 00  "};
  88. uchar code table4_5[]={"    设置成功"};
  89. uchar code table4_6[]={"春天到了！"};
  90. uchar code table4_7[]={"I am coming"};
  91. uchar code table4_8[]={"        师院"};

  93. uchar code table5_1[]={"设置闹钟："};
  94. uchar code table5_2[]={"  1:开启闹钟"};
  95. uchar code table5_3[]={"  2:关闭闹钟"};
  96. uchar code table5_4[]={"  00: 00: 00 "};
  97. uchar code table5_7[]={"    设置成功"};
  98. uchar code table5_8[]={"    小鸡小鸡"};
  99. uchar code table5_9[]={"小鸡小鸡咕咕day"};
  100. uchar code table5_a[]={"（咦，我的闹铃)~~"};
  101. uchar code table5_5[]={"设置时间:"};
  102. uchar code table5_6[]={"  00: 00: 00"};
  103. uchar code table5_b[]={""};
  104. uchar code table5_c[]={"    设置成功"};
  105. uchar code table5_d[]={"闹钟以关闭"};
  106. uchar code table5_e[]={""};
  107.                                 
  108. uchar code table6_1[]={"  咦！！！"};
  109. uchar code table6_2[]={"  游戏捏?"};

  111. uchar code table7_1[]={"小慧是傻逼"};
  112. uchar code table7_2[]={"  小慧是傻逼"};
  113. uchar code table7_3[]={"    小慧是傻逼"};
  114. uchar code table7_4[]={"      小慧是傻逼"};
  115. uchar code table7_5[]={"当前温度："};
  116. uchar code table7_6[]={" --’f i e r c e'"};
  117. uchar code table7_7[]={"    no way!!"};
  118. uchar code table7_8[]={"  ~~谢谢合作~~"};

  120. void delay(uint z)
  121. {
  122.    uint x,y;
  123.    for(x=z;x>0;x--)
  124.      for(y=110;y>0;y--);
  125. }

  127. void di()
  128. {
  129.    feng=0;
  130.    delay(100);
  131.    feng=1;
  132. }

  134. void write_com(uchar com)
  135. {
  136.    rs=0;
  137.    rw=0;
  138.    en=0;
  139.    P0=com;
  140.    delay(5);
  141.    en=1;
  142.    delay(5);
  143.    en=0;
  144. }                          

  146. void write_dat(uchar dat)
  147. {
  148.     rs=1;
  149.    rw=0;
  150.    en=0;
  151.    P0=dat;
  152.    delay(5);
  153.    en=1;
  154.    delay(5);
  155.    en=0;
  156. }

  158. void dsreset(void)
  159. {
  160.    uint i;
  161.    ds=0;
  162.    i=103;
  163.    while(i>0)i--;
  164.    ds=1;
  165.    i=4;
  166.    while(i>0)i--;
  167. }

  169. bit tempreadbit(void)
  170. {
  171.    uint i;
  172.         bit dat;
  173.         ds=0;i++;
  174.         ds=1;i++;i++;
  175.         dat=ds;
  176.         i=8;while(i>0)i--;
  177.         return(dat);
  178. }

  180. uchar tempread(void)
  181. {
  182.    uchar i,j,dat;
  183.    dat=0;
  184.    for(i=1;i<=8;i++)
  185.    {
  186.       j=tempreadbit();
  187.           dat=(j<<7)|(dat>>1);

  189.    }
  190.    return(dat);
  191. }

  193. void tempwritebyte(uchar dat)
  194. {
  195.    uint i;
  196.    uchar j;
  197.    bit testb;
  198.    for(j=0;j<8;j++)
  199.    {
  200.       testb=dat&0x01;
  201.           dat=dat>>1;
  202.           if(testb)
  203.           {
  204.              ds=0;
  205.                  i++;i++;
  206.                  ds=1;
  207.                  i=8;
  208.                  while(i>0)i--;
  209.           }
  210.           else
  211.           {
  212.              ds=0;
  213.                  i=8;
  214.                  while(i>0)i--;
  215.                  ds=1;
  216.                  i++;
  217.                  i++;
  218.           }
  219.    }
  220. }

  222. void tempchang(void)
  223. {
  224.    dsreset();
  225.    delay(1);
  226.    tempwritebyte(0xcc);
  227.    tempwritebyte(0x44);
  228. }
  229. uint get_temp()
  230. {
  231.    uchar a,b;
  232.    dsreset();
  233.    delay(1);
  234.    tempwritebyte(0xcc);
  235.    tempwritebyte(0xbe);
  236.    a=tempread();
  237.    b=tempread();
  238.    temp=b;
  239.    temp<<=8;
  240.    temp=temp|a;
  241.    f_temp=temp*0.0625;
  242.    temp=f_temp*10+0.5;
  243.    f_temp=f_temp+0.05;
  244.    return temp;
  245. }

  247. void write_ds(uchar add,uchar dat)
  248. {
  249.     dscs=0;
  250.         dsas=1;
  251.         dsds=1;
  252.         dsrw=1;
  253.         P0=add;
  254.         dsas=0;
  255.         dsrw=0;
  256.         P0=dat;
  257.         dsrw=1;
  258.         dsas=1;
  259.         dscs=1;
  260. }

  262. uchar read_ds(uchar add)
  263. {
  264.     uchar ds_date;
  265.         dsas=1;
  266.         dsds=1;
  267.         dsrw=1;
  268.         dscs=0;
  269.         P0=add;
  270.         dsas=0;
  271.         dsds=0;
  272.         P0=0xff;
  273.         ds_date=P0;
  274.         dsds=1;
  275.         dsas=1;
  276.         dscs=1;
  277.         return ds_date;
  278. }

  280. /*void set_time()
  281. {
  282.     write_ds(0,0);
  283.         write_ds(1,0);
  284.         write_ds(2,0);
  285.         write_ds(3,0);
  286.         write_ds(4,0);
  287.         write_ds(5,0);
  288.         write_ds(6,0);
  289.         write_ds(7,0);
  290.         write_ds(8,0);
  291.         write_ds(9,0);
  292. }         */

  294. void init1()
  295. {
  296.         EA=1;
  297.         EX1=1;
  298.         IT1=1;
  299.         t0_num=0;
  300.         s1num=0;
  301.         week=1;
  302. //        write_ds(0x0A,0x20);
  303. //        write_ds(0x0B,0x26);
  304. //        set_time();
  305. }

  307. void sfm_(uchar add,char dat)
  308. {
  309.     uchar si,ge;
  310.         si=dat/10;
  311.         ge=dat%10;
  312.         write_com(add);
  313.         write_dat(0x30+si);
  314.         write_dat(0x30+ge);
  315. }

  317. void asfm_(uchar add,char dat)
  318. {
  319.     uchar si,ge;
  320.         si=dat/10;
  321.         ge=dat%10;
  322.         write_com(add);
  323.         write_dat(0x30+si);
  324.         write_dat(0x30+ge);
  325. }

  327. void week_(uchar add,char week)
  328. {
  329.     write_com(add);
  330.         if(week==0)
  331.         {
  332.             write_dat(0x4D);
  333.                 write_dat(0x6F);
  334.                 write_dat(0x6E);
  335.                 write_dat(0x20);
  336.         }
  337.         if(week==1)
  338.         {
  339.             write_dat(0x54);
  340.                 write_dat(0x75);
  341.                 write_dat(0x65);
  342.                 write_dat(0x73);

  344.         }
  345.         if(week==2)
  346.         {
  347.             write_dat(0x57);
  348.                 write_dat(0x65);
  349.                 write_dat(0x64);
  350.                 write_dat(0x20);
  351.         }
  352.         if(week==3)
  353.         {
  354.             write_dat(0x54);
  355.                 write_dat(0x68);
  356.                 write_dat(0x75);
  357.                 write_dat(0x72);
  358.         }
  359.         if(week==4)
  360.         {
  361.             write_dat(0x46);
  362.                 write_dat(0x72);
  363.                 write_dat(0x69);
  364.                 write_dat(0x20);
  365.         }
  366.         if(week==5)
  367.         {
  368.             write_dat(0x53);
  369.                 write_dat(0x61);
  370.                 write_dat(0x74);
  371.                
  372.         }
  373.         if(week==6)
  374.         {
  375.             write_dat(0x53);
  376.                 write_dat(0x75);
  377.                 write_dat(0x6E);
  378.                 write_dat(0x20);
  379.         }
  380. }

  382. void nyr_(uchar add,char dat)
  383. {
  384.     uchar si,ge;
  385.         si=dat/10;
  386.         ge=dat%10;
  387.     write_com(add);
  388.         write_dat(0x30+si);
  389.         write_dat(0x30+ge);
  390. }

  392. void tx(uchar add,uint dat)
  393. {
  394.    uchar shi,ge,xs;
  395.    shi=(dat)/100;
  396.    ge=(dat)%100/10;
  397.    xs=(dat)%100%10;
  398.    write_com(0x98+add);
  399.    write_dat(0x30+shi);
  400.     write_dat(0x30+ge);
  401.          write_dat(0x2e);
  402.          write_dat(0x30+xs);
  403.         write_com(0x9f);
  404.           write_dat(0xA1);
  405.           write_dat(0xE6);
  406. }                                          

  408. void x1_(int x1)
  409. {
  410.    uchar si,ge;
  411.   
  412.    si=x1/10;
  413.    ge=x1%10;
  414.    write_com(0x93);
  415.     write_dat(0x30+si);
  416.     write_dat(0x30+ge);
  417. }

  419. void x3_(int x3)
  420. {
  421.    uchar si,ge;
  422.   
  423.    si=x3/10;
  424.    ge=x3%10;
  425.    write_com(0x93);
  426.     write_dat(0x30+si);
  427.     write_dat(0x30+ge);
  428. }

  430. void lcd_init()
  431. {
  432.     uchar i;
  433.     psb=1;
  434.         write_com(0x30);
  435.         delay(5);
  436.         write_com(0x0c);
  437.         delay(5);
  438.         write_com(0x01);
  439.         delay(5);
  440.         write_com(0x90);
  441.         i=0;
  442.         while(table00[i]!='')
  443.          {
  444.                      write_dat(table00[i]);
  445.                         i++;
  446.          }
  447.          delay(700);
  448.          write_com(0x01);
  449.          delay(500);
  450.          write_com(0x90);
  451.          i=0;
  452.         while(table00[i]!='')
  453.          {
  454.                      write_dat(table00[i]);
  455.                         i++;
  456.          }
  457.          delay(700);
  458.           write_com(0x01);
  459.          delay(500);
  460.          write_com(0x90);
  461.         i=0;
  462.         while(table00[i]!='')
  463.          {
  464.                      write_dat(table00[i]);
  465.                         i++;
  466.          }
  467.          delay(700);
  468.           write_com(0x01);
  469.          delay(500);
  470.          write_com(0x90);
  471.         i=0;
  472.         while(table0_3[i]!='')
  473.          {
  474.                      write_dat(table0_3[i]);
  475.                         i++;
  476.                         delay(100);
  477.          }
  478.          delay(700);
  479.          write_com(0x01);
  480.          write_com(0x90);
  481.         i=0;
  482.         while(table0_0[i]!='')
  483.          {
  484.                      write_dat(table0_0[i]);
  485.                         i++;
  486.                         delay(50);
  487.          }
  488.          write_com(0x88);
  489.         i=0;
  490.         while(table0_1[i]!='')
  491.          {
  492.                      write_dat(table0_1[i]);
  493.                         i++;
  494.                         delay(50);
  495.          }
  496.                   write_com(0x98);
  497.         i=0;
  498.         while(table0_2[i]!='')
  499.          {
  500.                      write_dat(table0_2[i]);
  501.                         i++;
  502.                         delay(50);
  503.          }
  504.          delay(700);
  505.      write_com(0x01);
  506.           write_com(0x80);
  507.         i=0;
  508.         while(table11[i]!='')
  509.          {
  510.                      write_dat(table11[i]);
  511.                         i++;
  512.          }
  513.          write_com(0x90);

  515.         i=0;
  516.         while(table12[i]!='')
  517.          {
  518.                      write_dat(table12[i]);
  519.                         i++;
  520.          }
  521.                   write_com(0x88);
  522.         i=0;
  523.         while(table13[i]!='')
  524.          {
  525.                      write_dat(table13[i]);
  526.                         i++;
  527.          }
  528.          write_com(0x98);
  529.          i=0;
  530.         while(table14[i]!='')
  531.          {
  532.                      write_dat(table14[i]);
  533.                         i++;
  534.          }
  535.          ff=1;
  536. }

  538. void xuanzhe_()
  539. {
  540.     uchar i;
  541.     if((xuanzhe==0)&&(flog1==0))
  542.         {
  543.             delay(10);
  544.                 if(xuanzhe==0)
  545.                 {
  546.                     while(!xuanzhe);
  547.                     count++;
  548.                         ff=0;
  549.                         di();
  550.                     if(count==1)
  551.                     {
  552.                             flog=1;
  553.                                 write_com(0x01);
  554.                             write_com(0x80);
  555.                             i=0;
  556.                             while(table1[i]!='')
  557.                             {
  558.                                      write_dat(table1[i]);
  559.                                         i++;
  560.                              }
  561.                                  write_com(0x81);
  562.                             write_dat(0x02);
  563.                             write_com(0x90);
  564.                             i=0;
  565.                             while(table2[i]!='')
  566.                             {
  567.                                      write_dat(table2[i]);
  568.                                         i++;
  569.                             }
  570.                             write_com(0x88);
  571.                             i=0;
  572.                              while(table3[i]!='')
  573.                             {
  574.                                      write_dat(table3[i]);
  575.                                         i++;
  576.                             }
  577.                             write_com(0x98);
  578.                             i=0;
  579.                              while(table4[i]!='')
  580.                             {
  581.                                      write_dat(table4[i]);
  582.                                         i++;
  583.                             }
  584.                     }
  585.                     if(count==2)
  586.                    {
  587.                     flog=2;
  588.                         write_com(0x01);
  589.                          write_com(0x80);
  590.                             i=0;
  591.                             while(table1[i]!='')
  592.                             {
  593.                                      write_dat(table1[i]);
  594.                                         i++;
  595.                              }
  596.                             write_com(0x90);
  597.                             i=0;
  598.                             while(table2[i]!='')
  599.                             {
  600.                                      write_dat(table2[i]);
  601.                                         i++;
  602.                             }
  603.                                 write_com(0x91);
  604.                         write_dat(0x02);
  605.                             write_com(0x88);
  606.                             i=0;
  607.                              while(table3[i]!='')
  608.                             {
  609.                                      write_dat(table3[i]);
  610.                                         i++;
  611.                             }
  612.                             write_com(0x98);
  613.                             i=0;
  614.                              while(table4[i]!='')
  615.                             {
  616.                                      write_dat(table4[i]);
  617.                                         i++;
  618.                             }
  619.                    }
  620.                    if(count==3)
  621.                    {
  622.                              flog=3;
  623.                                  write_com(0x01);
  624.                                  write_com(0x80);
  625.                             i=0;
  626.                             while(table1[i]!='')
  627.                             {
  628.                                      write_dat(table1[i]);
  629.                                         i++;
  630.                              }
  631.                             write_com(0x90);
  632.                             i=0;
  633.                             while(table2[i]!='')
  634.                             {
  635.                                      write_dat(table2[i]);
  636.                                         i++;
  637.                             }
  638.                             write_com(0x88);
  639.                             i=0;
  640.                              while(table3[i]!='')
  641.                             {
  642.                                      write_dat(table3[i]);
  643.                                         i++;
  644.                             }
  645.                                 write_com(0x89);
  646.                             write_dat(0x02);
  647.                             write_com(0x98);
  648.                             i=0;
  649.                              while(table4[i]!='')
  650.                             {
  651.                                      write_dat(table4[i]);
  652.                                         i++;
  653.                             }
  654.                    }
  655.                    if(count==4)
  656.                    {
  657.                             flog=4;
  658.                                 write_com(0x01);
  659.                                  write_com(0x80);
  660.                             i=0;
  661.                             while(table1[i]!='')
  662.                             {
  663.                                      write_dat(table1[i]);
  664.                                         i++;
  665.                              }
  666.                             write_com(0x90);
  667.                             i=0;
  668.                             while(table2[i]!='')
  669.                             {
  670.                                      write_dat(table2[i]);
  671.                                         i++;
  672.                             }
  673.                             write_com(0x88);
  674.                             i=0;
  675.                              while(table3[i]!='')
  676.                             {
  677.                                      write_dat(table3[i]);
  678.                                         i++;
  679.                             }
  680.                             write_com(0x98);
  681.                             i=0;
  682.                              while(table4[i]!='')
  683.                             {
  684.                                      write_dat(table4[i]);
  685.                                         i++;
  686.                             }
  687.                                  write_com(0x99);
  688.                             write_dat(0x02);
  689.                    }
  690.                  
  691.                  if(count==5)
  692.                  {
  693.                     flog=5;
  694.                         write_com(0x01);
  695.                          write_com(0x80);
  696.                      i=0;
  697.                      while(table5[i]!='')
  698.                      {
  699.                              write_dat(table5[i]);
  700.                                 i++;
  701.                      }
  702.                          write_com(0x81);
  703.                     write_dat(0x02);
  704.                          write_com(0x90);
  705.                       i=0;
  706.                       while(table6[i]!='')
  707.                      {
  708.                              write_dat(table6[i]);
  709.                                 i++;
  710.                      }
  711.                          write_com(0x88);
  712.                       i=0;
  713.                       while(table7[i]!='')
  714.                      {
  715.                              write_dat(table7[i]);
  716.                                 i++;
  717.                      }
  718.                          write_com(0x98);
  719.                       i=0;
  720.                       while(table8[i]!='')
  721.                      {
  722.                              write_dat(table8[i]);
  723.                                 i++;
  724.                      }
  725.                  }
  726.                  if(count==6)
  727.                  {
  728.                     flog=6;
  729.                         write_com(0x01);
  730.                          write_com(0x80);
  731.                      i=0;
  732.                      while(table5[i]!='')
  733.                      {
  734.                              write_dat(table5[i]);
  735.                                 i++;
  736.                      }
  737.                          write_com(0x90);
  738.                       i=0;
  739.                       while(table6[i]!='')
  740.                      {
  741.                              write_dat(table6[i]);
  742.                                 i++;
  743.                      }
  744.                           write_com(0x91);
  745.                     write_dat(0x02);
  746.                          write_com(0x88);
  747.                       i=0;
  748.                       while(table7[i]!='')
  749.                      {
  750.                              write_dat(table7[i]);
  751.                                 i++;
  752.                      }
  753.                          write_com(0x98);
  754.                       i=0;
  755.                       while(table8[i]!='')
  756.                      {
  757.                              write_dat(table8[i]);
  758.                                 i++;
  759.                      }
  760.                  }
  761.                  if(count==7)
  762.                  {
  763.                     flog=7;
  764.                         write_com(0x01);
  765.                          write_com(0x80);
  766.                      i=0;
  767.                      while(table5[i]!='')
  768.                      {
  769.                              write_dat(table5[i]);
  770.                                 i++;
  771.                      }
  772.                          write_com(0x90);
  773.                       i=0;
  774.                       while(table6[i]!='')
  775.                      {
  776.                              write_dat(table6[i]);
  777.                                 i++;
  778.                      }
  779.                          write_com(0x88);
  780.                       i=0;
  781.                       while(table7[i]!='')
  782.                      {
  783.                              write_dat(table7[i]);
  784.                                 i++;
  785.                      }
  786.                          write_com(0x89);
  787.                      write_dat(0x02);
  788.                          write_com(0x98);
  789.                       i=0;
  790.                       while(table8[i]!='')
  791.                      {
  792.                              write_dat(table8[i]);
  793.                                 i++;
  794.                      }
  795.                  }
  796.                  if(count==8)
  797.                  {
  798.                         count=1;
  799.                                 flog=1;
  800.                                 write_com(0x01);
  801.                         write_com(0x80);
  802.                             i=0;
  803.                             while(table1[i]!='')
  804.                             {
  805.                                      write_dat(table1[i]);
  806.                                         i++;
  807.                              }
  808.                                  write_com(0x81);
  809.                                    write_dat(0x02);
  810.                             write_com(0x90);
  811.                             i=0;
  812.                             while(table2[i]!='')
  813.                             {
  814.                                      write_dat(table2[i]);
  815.                                         i++;
  816.                             }
  817.                             write_com(0x88);
  818.                             i=0;
  819.                              while(table3[i]!='')
  820.                             {
  821.                                      write_dat(table3[i]);
  822.                                         i++;
  823.                             }
  824.                             write_com(0x98);
  825.                             i=0;
  826.                              while(table4[i]!='')
  827.                             {
  828.                                      write_dat(table4[i]);
  829.                                         i++;
  830.                             }
  831.                  }
  832.                
  833.                 }
  834.         }                                                  
  835. }

  837. void queding_()
  838. {
  839.     uchar i;
  840.     if((flog==1)&&(queding==0)&&(xh1!=1))
  841.         {
  842.             delay(5);
  843.                 {
  844.                     if(queding==0)
  845.                         {
  846.                             while(!queding);
  847.                                 di();
  848.                                 flog1=1;
  849.                                 write_com(0x01);
  850.                         write_com(0x80);
  851.                             i=0;
  852.                             while(table1_1[i]!='')
  853.                             {
  854.                                      write_dat(table1_1[i]);
  855.                                         i++;
  856.                              }
  857.                             write_com(0x90);
  858.                             i=0;
  859.                             while(table1_2[i]!='')
  860.                             {
  861.                                      write_dat(table1_2[i]);
  862.                                         i++;
  863.                             }
  864.                             write_com(0x88);
  865.                             i=0;
  866.                              while(table1_3[i]!='')
  867.                             {
  868.                                      write_dat(table1_3[i]);
  869.                                         i++;
  870.                             }
  871.                             write_com(0x98);
  872.                             i=0;
  873.                              while(table1_4[i]!='')
  874.                             {
  875.                                      write_dat(table1_4[i]);
  876.                                         i++;
  877.                             }
  878.                                 write_com(0x98);
  879.                                 write_dat(0x03);
  880.                                 write_com(0x99);
  881.                                 write_dat(0x03);
  882.                                 write_com(0x9a);
  883.                                 write_dat(0x03);
  884.                                 write_com(0x9d);
  885.                                 write_dat(0x03);
  886.                                 write_com(0x9e);
  887.                                 write_dat(0x03);
  888.                                 write_com(0x9f);
  889.                                 write_dat(0x03);
  890.                         }
  891.                 }
  892.         }
  893.         if((flog==2)&&(queding==0)&&(xt==0))
  894.         {
  895.             delay(5);
  896.                 if(queding==0)
  897.                 {
  898.                        while(!queding);
  899.                             di();
  900.                                 flog1=2;
  901.                            write_com(0x01);
  902.                         write_com(0x80);
  903.                             i=0;
  904.                             while(table2_1[i]!='')
  905.                             {
  906.                                      write_dat(table2_1[i]);
  907.                                         i++;
  908.                              }
  909.                             write_com(0x90);
  910.                             i=0;
  911.                             while(table2_2[i]!='')
  912.                             {
  913.                                      write_dat(table2_2[i]);
  914.                                         i++;
  915.                             }
  916.                             write_com(0x88);
  917.                             i=0;
  918.                              while(table2_3[i]!='')
  919.                             {
  920.                                      write_dat(table2_3[i]);
  921.                                         i++;
  922.                             }
  923.                             write_com(0x98);
  924.                             i=0;
  925.                              while(table2_4[i]!='')
  926.                             {
  927.                                      write_dat(table2_4[i]);
  928.                                         i++;
  929.                             }

  931.                 }
  932.         }
  933.         if((flog==3)&&(queding==0)&&(xw!=1))
  934.         {
  935.             delay(5);
  936.                 if(queding==0)
  937.                 {
  938.                     while(!queding);
  939.                         di();
  940.                         flog1=3;
  941.                             write_com(0x01);
  942.                         write_com(0x80);
  943.                             i=0;
  944.                             while(table3_1[i]!='')
  945.                             {
  946.                                      write_dat(table3_1[i]);
  947.                                         i++;
  948.                              }
  949.                             write_com(0x90);
  950.                             i=0;
  951.                             while(table3_2[i]!='')
  952.                             {
  953.                                      write_dat(table3_2[i]);
  954.                                         i++;
  955.                             }
  956.                             write_com(0x88);
  957.                             i=0;
  958.                              while(table3_3[i]!='')
  959.                             {
  960.                                      write_dat(table3_3[i]);
  961.                                         i++;
  962.                             }
  963.                             write_com(0x98);
  964.                             i=0;
  965.                              while(table3_4[i]!='')
  966.                             {
  967.                                      write_dat(table3_4[i]);
  968.                                         i++;
  969.                             }
  970.                                 write_com(0x98);
  971.                                 write_dat(0x03);
  972.                                 write_com(0x99);
  973.                                 write_dat(0x03);
  974.                                 write_com(0x9a);
  975.                                 write_dat(0x03);
  976.                                 write_com(0x9d);
  977.                                 write_dat(0x03);
  978.                                 write_com(0x9e);
  979.                                 write_dat(0x03);
  980.                                 write_com(0x9f);
  981.                                 write_dat(0x03);
  982.                 }
  983.         }
  984.         if((flog==4)&&(queding==0)&&(xx==0))
  985.         {
  986.             delay(5);
  987.                 if(queding==0)
  988.                 {
  989.                     while(!queding);
  990.                         di();
  991.                         flog1=4;
  992.                          write_com(0x01);
  993.                         write_com(0x80);
  994.                             i=0;
  995.                             while(table4_1[i]!='')
  996.                             {
  997.                                      write_dat(table4_1[i]);
  998.                                         i++;
  999.                              }
  1000.                             write_com(0x90);
  1001.                             i=0;
  1002.                             while(table4_2[i]!='')
  1003.                             {
  1004.                                      write_dat(table4_2[i]);
  1005.                                         i++;
  1006.                             }
  1007.                             write_com(0x88);
  1008.                             i=0;
  1009.                              while(table4_3[i]!='')
  1010.                             {
  1011.                                      write_dat(table4_3[i]);
  1012.                                         i++;
  1013.                             }
  1014.                             write_com(0x98);
  1015.                             i=0;
  1016.                              while(table4_4[i]!='')
  1017.                             {
  1018.                                      write_dat(table4_4[i]);
  1019.                                         i++;
  1020.                             }
  1021.                 }
  1022.         }
  1023.         if((flog==5)&&(queding==0)&&(axt==0))
  1024.         {
  1025.             delay(5);
  1026.                 if(queding==0)
  1027.                 {
  1028.                     while(!queding);
  1029.                         di();
  1030.                         flog1=5;
  1031.                          write_com(0x01);
  1032.                         write_com(0x80);
  1033.                             i=0;
  1034.                             while(table5_1[i]!='')
  1035.                             {
  1036.                                      write_dat(table5_1[i]);
  1037.                                         i++;
  1038.                              }
  1039.                             write_com(0x90);
  1040.                             i=0;
  1041.                             while(table5_2[i]!='')
  1042.                             {
  1043.                                      write_dat(table5_2[i]);
  1044.                                         i++;
  1045.                             }
  1046.                             write_com(0x88);
  1047.                             i=0;
  1048.                              while(table5_3[i]!='')
  1049.                             {
  1050.                                      write_dat(table5_3[i]);
  1051.                                         i++;
  1052.                             }
  1053.                             write_com(0x98);
  1054.                             i=0;
  1055.                              while(table5_4[i]!='')
  1056.                             {
  1057.                                      write_dat(table5_4[i]);
  1058.                                         i++;
  1059.                             }
  1060.                 }
  1061.         }
  1062.         if((flog==6)&&(queding==0))
  1063.         {
  1064.             delay(5);
  1065.                 if(queding==0)
  1066.                 {
  1067.                     while(!queding);
  1068.                         di();
  1069.                         flog1=6;
  1070.                          write_com(0x01);
  1071.                         write_com(0x90);
  1072.                             i=0;
  1073.                             while(table6_1[i]!='')
  1074.                             {
  1075.                                      write_dat(table6_1[i]);
  1076.                                         i++;
  1077.                              }
  1078.                                  write_com(0x90);
  1079.                                 write_dat(0x0c);
  1080.                                 write_com(0x95);
  1081.                                 write_dat(0x0b);
  1082.                             write_com(0x89);
  1083.                             i=0;
  1084.                             while(table6_2[i]!='')
  1085.                             {
  1086.                                      write_dat(table6_2[i]);
  1087.                                         i++;
  1088.                             }
  1089.                                 write_com(0x89);
  1090.                                 write_dat(0x02);
  1091.                                 write_com(0x8e);
  1092.                                 write_dat(0x02);
  1093.                 }
  1094.         }
  1095.         if((flog==7)&&(queding==0))
  1096.         {
  1097.             delay(5);
  1098.                 if(queding==0)
  1099.                 {
  1100.                     while(!queding);
  1101.                         di();
  1102.                         flog1=7;
  1103.                          write_com(0x01);
  1104.                         write_com(0x80);
  1105.                             i=0;
  1106.                             while(table7_1[i]!='')
  1107.                             {
  1108.                                      write_dat(table7_1[i]);
  1109.                                         i++;
  1110.                              }
  1111.                                  write_com(0x85);
  1112.                                  write_dat(0x03);
  1113.                             write_com(0x90);
  1114.                             i=0;
  1115.                             while(table7_2[i]!='')
  1116.                             {
  1117.                                      write_dat(table7_2[i]);
  1118.                                         i++;
  1119.                             }
  1120.                                 write_com(0x96);
  1121.                                  write_dat(0x03);
  1122.                                  write_com(0x90);
  1123.                                  write_dat(0x03);
  1124.                             write_com(0x88);
  1125.                             i=0;
  1126.                              while(table7_3[i]!='')
  1127.                             {
  1128.                                      write_dat(table7_3[i]);
  1129.                                         i++;
  1130.                             }
  1131.                                 write_com(0x8f);
  1132.                                  write_dat(0x03);
  1133.                                  write_com(0x89);
  1134.                                  write_dat(0x03);
  1135.                             write_com(0x98);
  1136.                             i=0;
  1137.                              while(table7_4[i]!='')
  1138.                             {
  1139.                                      write_dat(table7_4[i]);
  1140.                                         i++;
  1141.                             }
  1142.                                 write_com(0x9a);
  1143.                                  write_dat(0x03);
  1144.                 }
  1145.         }
  1146. }

  1148. void fanhui_()
  1149. {
  1150.     uchar i;
  1151.         if((fanhui==0)&&(flog1==0))
  1152.         {
  1153.             delay(5);
  1154.                 if(fanhui==0)
  1155.                 {
  1156.                     while(!fanhui);
  1157.                         di();
  1158.                          count=0;
  1159.                          flog=0;
  1160.                          write_com(0x01);
  1161.                  write_com(0x80);
  1162.                  i=0;
  1163.                  while(table11[i]!='')
  1164.                  {
  1165.                              write_dat(table11[i]);
  1166.                                 i++;
  1167.                 }
  1168.                 write_com(0x90);
  1169.                 i=0;
  1170.                 while(table12[i]!='')
  1171.                 {
  1172.                              write_dat(table12[i]);
  1173.                                 i++;
  1174.                 }
  1175.                      write_com(0x88);
  1176.                 i=0;
  1177.                 while(table13[i]!='')
  1178.                {
  1179.                              write_dat(table13[i]);
  1180.                                 i++;
  1181.                 }
  1182.                 write_com(0x98);
  1183.                 i=0;
  1184.                 while(table14[i]!='')
  1185.                 {
  1186.                              write_dat(table14[i]);
  1187.                                 i++;
  1188.                 }
  1189.                 ff=1;
  1190.                 }
  1191.         }
  1192.         if((fanhui==0)&&(flog1==1))
  1193.         {
  1194.            delay(5);
  1195.            if(fanhui==0)
  1196.            {
  1197.                while(!fanhui);
  1198.                    di();
  1199.                    flog1=0;
  1200.                    flog=1;
  1201.                    count=1;
  1202.                    xh=0;
  1203.                    xh1=0;
  1204.                    write_com(0x01);
  1205.                         write_com(0x80);
  1206.                             i=0;
  1207.                             while(table1[i]!='')
  1208.                             {
  1209.                                      write_dat(table1[i]);
  1210.                                         i++;
  1211.                              }
  1212.                                  write_com(0x81);
  1213.                                    write_dat(0x02);
  1214.                             write_com(0x90);
  1215.                             i=0;
  1216.                             while(table2[i]!='')
  1217.                             {
  1218.                                      write_dat(table2[i]);
  1219.                                         i++;
  1220.                             }
  1221.                             write_com(0x88);
  1222.                             i=0;
  1223.                              while(table3[i]!='')
  1224.                             {
  1225.                                      write_dat(table3[i]);
  1226.                                         i++;
  1227.                             }
  1228.                             write_com(0x98);
  1229.                             i=0;
  1230.                              while(table4[i]!='')
  1231.                             {
  1232.                                      write_dat(table4[i]);
  1233.                                         i++;
  1234.                             }
  1235.            }
  1236.         }
  1237.         if((fanhui==0)&&(flog1==2))
  1238.         {
  1239.            delay(5);
  1240.            if(fanhui==0)
  1241.            {
  1242.                while(!fanhui);
  1243.                    di();
  1244.                    flog1=0;
  1245.                    flog=2;
  1246.                    count=2;
  1247.                    count2=0;
  1248.                    count1=0;
  1249.                    xt=0;
  1250.                    xt1=0;
  1251.                    write_com(0x01);
  1252.                    write_com(0x0c);
  1253.                         write_com(0x80);
  1254.                             i=0;
  1255.                             while(table1[i]!='')
  1256.                             {
  1257.                                      write_dat(table1[i]);
  1258.                                         i++;
  1259.                              }
  1260.                             write_com(0x90);
  1261.                             i=0;
  1262.                             while(table2[i]!='')
  1263.                             {
  1264.                                      write_dat(table2[i]);
  1265.                                         i++;
  1266.                             }
  1267.                                  write_com(0x91);
  1268.                                    write_dat(0x02);
  1269.                             write_com(0x88);
  1270.                             i=0;
  1271.                              while(table3[i]!='')
  1272.                             {
  1273.                                      write_dat(table3[i]);
  1274.                                         i++;
  1275.                             }
  1276.                             write_com(0x98);
  1277.                             i=0;
  1278.                              while(table4[i]!='')
  1279.                             {
  1280.                                      write_dat(table4[i]);
  1281.                                         i++;
  1282.                             }
  1283.            }
  1284.         }
  1285.                 if((fanhui==0)&&(flog1==3))
  1286.         {
  1287.            delay(5);
  1288.            if(fanhui==0)
  1289.            {
  1290.                while(!fanhui);
  1291.                    di();
  1292.                    flog1=0;
  1293.                    flog=3;
  1294.                    count=3;
  1295.                     xw=0;
  1296.                    xw1=0;
  1297.                    write_com(0x01);
  1298.                         write_com(0x80);
  1299.                             i=0;
  1300.                             while(table1[i]!='')
  1301.                             {
  1302.                                      write_dat(table1[i]);
  1303.                                         i++;
  1304.                              }
  1305.                             write_com(0x90);
  1306.                             i=0;
  1307.                             while(table2[i]!='')
  1308.                             {
  1309.                                      write_dat(table2[i]);
  1310.                                         i++;
  1311.                             }
  1312.                             write_com(0x88);
  1313.                             i=0;
  1314.                              while(table3[i]!='')
  1315.                             {
  1316.                                      write_dat(table3[i]);
  1317.                                         i++;
  1318.                             }
  1319.                                  write_com(0x89);
  1320.                                    write_dat(0x02);
  1321.                             write_com(0x98);
  1322.                             i=0;
  1323.                              while(table4[i]!='')
  1324.                             {
  1325.                                      write_dat(table4[i]);
  1326.                                         i++;
  1327.                             }
  1328.            }
  1329.         }
  1330.          if((fanhui==0)&&(flog1==4))
  1331.         {
  1332.            delay(5);
  1333.            if(fanhui==0)
  1334.            {
  1335.                while(!fanhui);
  1336.                    di();
  1337.                    flog1=0;
  1338.                    flog=4;
  1339.                    count=4;
  1340.                    write_com(0x0c);
  1341.                    write_com(0x01);
  1342.                         write_com(0x80);
  1343.                             i=0;
  1344.                             while(table1[i]!='')
  1345.                             {
  1346.                                      write_dat(table1[i]);
  1347.                                         i++;
  1348.                              }
  1349.                             write_com(0x90);
  1350.                             i=0;
  1351.                             while(table2[i]!='')
  1352.                             {
  1353.                                      write_dat(table2[i]);
  1354.                                         i++;
  1355.                             }
  1356.                             write_com(0x88);
  1357.                             i=0;
  1358.                              while(table3[i]!='')
  1359.                             {
  1360.                                      write_dat(table3[i]);
  1361.                                         i++;
  1362.                             }
  1363.                             write_com(0x98);
  1364.                             i=0;
  1365.                              while(table4[i]!='')
  1366.                             {
  1367.                                      write_dat(table4[i]);
  1368.                                         i++;
  1369.                             }
  1370.                                  write_com(0x99);
  1371.                                    write_dat(0x02);
  1372.            }
  1373.         }
  1374.          if((fanhui==0)&&(flog1==5))
  1375.         {
  1376.            delay(5);
  1377.            if(fanhui==0)
  1378.            {
  1379.                while(!fanhui);
  1380.                    di();
  1381.                    flog1=0;
  1382.                    flog=5;
  1383.                    count=5;
  1384.                    acount2=0;
  1385.                    acount1=0;
  1386.                    axt=0;
  1387.                    axt1=0;
  1388.                    write_com(0x01);
  1389.                        write_com(0x80);
  1390.                      i=0;
  1391.                      while(table5[i]!='')
  1392.                      {
  1393.                              write_dat(table5[i]);
  1394.                                 i++;
  1395.                      }
  1396.                           write_com(0x81);
  1397.                                    write_dat(0x02);
  1398.                          write_com(0x90);
  1399.                       i=0;
  1400.                       while(table6[i]!='')
  1401.                      {
  1402.                              write_dat(table6[i]);
  1403.                                 i++;
  1404.                      }
  1405.                          write_com(0x88);
  1406.                       i=0;
  1407.                       while(table7[i]!='')
  1408.                      {
  1409.                              write_dat(table7[i]);
  1410.                                 i++;
  1411.                      }
  1412.                          write_com(0x98);
  1413.                       i=0;
  1414.                       while(table8[i]!='')
  1415.                      {
  1416.                              write_dat(table8[i]);
  1417.                                 i++;
  1418.                      }
  1419.            }
  1420.         }
  1421.           if((fanhui==0)&&(flog1==6))
  1422.         {
  1423.            delay(5);
  1424.            if(fanhui==0)
  1425.            {
  1426.                while(!fanhui);
  1427.                    di();
  1428.                    flog1=0;
  1429.                    flog=6;
  1430.                    count=6;
  1431.                    write_com(0x01);
  1432.                        write_com(0x80);
  1433.                      i=0;
  1434.                      while(table5[i]!='')
  1435.                      {
  1436.                              write_dat(table5[i]);
  1437.                                 i++;
  1438.                      }
  1439.                          write_com(0x90);
  1440.                       i=0;
  1441.                       while(table6[i]!='')
  1442.                      {
  1443.                              write_dat(table6[i]);
  1444.                                 i++;
  1445.                      }
  1446.                           write_com(0x91);
  1447.                                    write_dat(0x02);
  1448.                          write_com(0x88);
  1449.                       i=0;
  1450.                       while(table7[i]!='')
  1451.                      {
  1452.                              write_dat(table7[i]);
  1453.                                 i++;
  1454.                      }
  1455.                          write_com(0x98);
  1456.                       i=0;
  1457.                       while(table8[i]!='')
  1458.                      {
  1459.                              write_dat(table8[i]);
  1460.                                 i++;
  1461.                      }
  1462.            }
  1463.         }
  1464.         if((fanhui==0)&&(flog1==7))
  1465.         {
  1466.            delay(5);
  1467.            if(fanhui==0)
  1468.            {
  1469.                while(!fanhui);
  1470.                    di();
  1471.                    flog1=0;
  1472.                    flog=7;
  1473.                    count=7;
  1474.                    write_com(0x01);
  1475.                        write_com(0x80);
  1476.                      i=0;
  1477.                      while(table5[i]!='')
  1478.                      {
  1479.                              write_dat(table5[i]);
  1480.                                 i++;
  1481.                      }
  1482.                          write_com(0x90);
  1483.                       i=0;
  1484.                       while(table6[i]!='')
  1485.                      {
  1486.                              write_dat(table6[i]);
  1487.                                 i++;
  1488.                      }
  1489.                          write_com(0x88);
  1490.                       i=0;
  1491.                       while(table7[i]!='')
  1492.                      {
  1493.                              write_dat(table7[i]);
  1494.                                 i++;
  1495.                      }
  1496.                          write_com(0x89);
  1497.                      write_dat(0x02);
  1498.                          write_com(0x98);
  1499.                       i=0;
  1500.                       while(table8[i]!='')
  1501.                      {
  1502.                              write_dat(table8[i]);
  1503.                                 i++;
  1504.                      }
  1505.            }
  1506.         }
  1507. }

  1509. void tiaozheng_()
  1510. {
  1511.      uchar i;
  1512.     if((tiaozheng==0)&&(flog1==1))
  1513.         {
  1514.             delay(5);
  1515.                 if(tiaozheng==0)
  1516.                 {
  1517.                     while(!tiaozheng);
  1518.                         di();
  1519.                         xh=1;
  1520.                         xh1=1;
  1521.                             write_com(0x01);
  1522.                         write_com(0x80);
  1523.                             i=0;
  1524.                             while(table1_1[i]!='')
  1525.                             {
  1526.                                      write_dat(table1_1[i]);
  1527.                                         i++;
  1528.                              }
  1529.                             write_com(0x90);
  1530.                             i=0;
  1531.                             while(table1_2[i]!='')
  1532.                             {
  1533.                                      write_dat(table1_2[i]);
  1534.                                         i++;
  1535.                             }
  1536.                                  write_com(0x92);
  1537.                                  write_dat(0x02);
  1538.                             write_com(0x88);
  1539.                             i=0;
  1540.                              while(table1_3[i]!='')
  1541.                             {
  1542.                                      write_dat(table1_3[i]);
  1543.                                         i++;
  1544.                             }
  1545.                             write_com(0x98);
  1546.                             i=0;
  1547.                              while(table1_4[i]!='')
  1548.                             {
  1549.                                      write_dat(table1_4[i]);
  1550.                                         i++;
  1551.                             }
  1552.                                 write_com(0x98);
  1553.                                 write_dat(0x03);
  1554.                                 write_com(0x99);
  1555.                                 write_dat(0x03);
  1556.                                 write_com(0x9a);
  1557.                                 write_dat(0x03);
  1558.                                 write_com(0x9d);
  1559.                                 write_dat(0x03);
  1560.                                 write_com(0x9e);
  1561.                                 write_dat(0x03);
  1562.                                 write_com(0x9f);
  1563.                                 write_dat(0x03);
  1564.                 }
  1565.         }
  1566.         if(xh!=0)
  1567.         {
  1568.            if(zengjia==0)
  1569.             {
  1570.                          delay(5);
  1571.                            if(zengjia==0)
  1572.                            {
  1573.                             while(!zengjia);
  1574.                             di();
  1575.                               x1++;
  1576.                             if(x1==100)
  1577.                                   x1=0;
  1578.                              }
  1579.                         }
  1580.            if(jianxiao==0)
  1581.               {
  1582.                   delay(5);
  1583.                   if(jianxiao==0)
  1584.                     {
  1585.                         while(!jianxiao);
  1586.                                 di();
  1587.                             x1--;
  1588.                             if(x1==-1)
  1589.                             x1=99;
  1590.                     }
  1591.                 }
  1592.                 if((queding==0)&&(xh1==1))
  1593.                 {
  1594.                     delay(5);
  1595.                         if(queding==0)
  1596.                         {
  1597.                             while(!queding);
  1598.                                 di();
  1599.                                 xh2=1;
  1600.                                 xh1=0;
  1601.                                 write_com(0x01);
  1602.                         write_com(0x80);
  1603.                             i=0;
  1604.                             while(table1_5[i]!='')
  1605.                             {
  1606.                                      write_dat(table1_5[i]);
  1607.                                         i++;
  1608.                              }
  1609.                             write_com(0x90);
  1610.                             i=0;
  1611.                             while(table1_6[i]!='')
  1612.                             {
  1613.                                      write_dat(table1_6[i]);
  1614.                                         i++;
  1615.                             }
  1616.                             write_com(0x88);
  1617.                             i=0;
  1618.                              while(table1_7[i]!='')
  1619.                             {
  1620.                                      write_dat(table1_7[i]);
  1621.                                         i++;
  1622.                             }
  1623.                             write_com(0x98);
  1624.                             i=0;
  1625.                              while(table1_8[i]!='')
  1626.                             {
  1627.                                      write_dat(table1_8[i]);
  1628.                                         i++;
  1629.                             }
  1630.                                 delay(2000);
  1631.                                 flog1=0;
  1632.                         flog=1;
  1633.                         count=1;
  1634.                                 xh=0;
  1635.                         write_com(0x01);
  1636.                         write_com(0x80);
  1637.                             i=0;
  1638.                             while(table1[i]!='')
  1639.                             {
  1640.                                      write_dat(table1[i]);
  1641.                                         i++;
  1642.                              }
  1643.                                  write_com(0x81);
  1644.                                    write_dat(0x02);
  1645.                             write_com(0x90);
  1646.                             i=0;
  1647.                             while(table2[i]!='')
  1648.                             {
  1649.                                      write_dat(table2[i]);
  1650.                                         i++;
  1651.                             }
  1652.                             write_com(0x88);
  1653.                             i=0;
  1654.                              while(table3[i]!='')
  1655.                             {
  1656.                                      write_dat(table3[i]);
  1657.                                         i++;
  1658.                             }
  1659.                             write_com(0x98);
  1660.                             i=0;
  1661.                              while(table4[i]!='')
  1662.                             {
  1663.                                      write_dat(table4[i]);
  1664.                                         i++;
  1665.                             }
  1666.                         }
  1667.                 }
  1668.         }

  1670.      if((tiaozheng==0)&&(flog1==2)&&(xt!=2))
  1671.          {
  1672.              delay(5);
  1673.                  if(tiaozheng==0)
  1674.                  {
  1675.                      while(!tiaozheng);
  1676.                          di();
  1677.                          count1++;
  1678.                          if(count1==1)
  1679.                          {
  1680.                              write_com(0x88);
  1681.                                  write_dat(0x20);
  1682.                                  write_com(0x90);
  1683.                                  write_dat(0x02);
  1684.                                  xt=1;
  1685.                          }
  1686.                          if(count1==2)
  1687.                          {
  1688.                              write_com(0x88);
  1689.                                  write_dat(0x02);
  1690.                                  write_com(0x90);
  1691.                                  write_dat(0x20);
  1692.                                  xt=4;
  1693.                          }
  1694.                          if(count1==3)
  1695.                          {
  1696.                              count1=0;
  1697.                                  write_com(0x88);
  1698.                                  write_dat(0x20);
  1699.                          }
  1700.                  }         
  1701.          }

  1703.       if((xt==4)&&(queding==0))
  1704.           {
  1705.                delay(5);
  1706.                    if(queding==0)
  1707.                    {
  1708.                         while(!queding);
  1709.                                 di();
  1710.                         hh=0;
  1711.                                 xt=0;
  1712.                                 jidianqi=0;
  1713.                         write_com(0x80);
  1714.                             i=0;
  1715.                             while(table2_b[i]!='')
  1716.                             {
  1717.                                      write_dat(table2_b[i]);
  1718.                                         i++;
  1719.                              }
  1720.                             write_com(0x90);
  1721.                             i=0;
  1722.                             while(table2_c[i]!='')
  1723.                             {
  1724.                                      write_dat(table2_c[i]);
  1725.                                         i++;
  1726.                             }
  1727.                             write_com(0x88);
  1728.                             i=0;
  1729.                              while(table2_d[i]!='')
  1730.                             {
  1731.                                      write_dat(table2_d[i]);
  1732.                                         i++;
  1733.                             }
  1734.                             write_com(0x98);
  1735.                             i=0;
  1736.                              while(table2_e[i]!='')
  1737.                             {
  1738.                                      write_dat(table2_e[i]);
  1739.                                         i++;
  1740.                             }
  1741.                                 delay(2000);
  1742.                                 flog1=0;
  1743.                         flog=2;
  1744.                         count=2;
  1745.                         write_com(0x01);
  1746.                         write_com(0x80);
  1747.                             i=0;
  1748.                             while(table1[i]!='')
  1749.                             {
  1750.                                      write_dat(table1[i]);
  1751.                                         i++;
  1752.                              }
  1753.                             write_com(0x90);
  1754.                             i=0;
  1755.                             while(table2[i]!='')
  1756.                             {
  1757.                                      write_dat(table2[i]);
  1758.                                         i++;
  1759.                             }
  1760.                                 write_com(0x91);
  1761.                                    write_dat(0x02);
  1762.                             write_com(0x88);
  1763.                             i=0;
  1764.                              while(table3[i]!='')
  1765.                             {
  1766.                                      write_dat(table3[i]);
  1767.                                         i++;
  1768.                             }
  1769.                             write_com(0x98);
  1770.                             i=0;
  1771.                              while(table4[i]!='')
  1772.                             {
  1773.                                      write_dat(table4[i]);
  1774.                                         i++;
  1775.                             }
  1776.                    }
  1777.           }

  1779.          if((xt==1)&&(queding==0)&&(xt1==0))
  1780.          {
  1781.              delay(5);
  1782.              if(queding==0)
  1783.                   {
  1784.                       while(!queding);
  1785.                           di();
  1786.                           xt=2;
  1787.                           hh=1;
  1788.                           write_com(0x01);
  1789.                           write_com(0x80);
  1790.                             i=0;
  1791.                             while(table2_5[i]!='')
  1792.                             {
  1793.                                      write_dat(table2_5[i]);
  1794.                                         i++;
  1795.                             }
  1796.                                 write_com(0x90);
  1797.                             i=0;
  1798.                             while(table2_6[i]!='')
  1799.                             {
  1800.                                      write_dat(table2_6[i]);
  1801.                                         i++;
  1802.                             }

  1804.                                 write_com(0x98);
  1805.                                 write_dat(0x03);
  1806.                                 write_com(0x99);
  1807.                                 write_dat(0x03);
  1808.                                 write_com(0x9a);
  1809.                                 write_dat(0x03);
  1810.                                 write_com(0x9d);
  1811.                                 write_dat(0x03);
  1812.                                 write_com(0x9e);
  1813.                                 write_dat(0x03);
  1814.                                 write_com(0x9f);
  1815.                                 write_dat(0x03);
  1816.                   }
  1817.          }
  1818.          if((xt==2)&&(tiaozheng==0))
  1819.          {
  1820.              delay(5);
  1821.                  if(tiaozheng==0)
  1822.                  {
  1823.                      while(!tiaozheng);
  1824.                          di();
  1825.                          count2++;
  1826.                          xt1=1;
  1827.                          amiao=read_ds(1);
  1828.              afen=read_ds(3);
  1829.              ashi=read_ds(5);
  1830.                          miao=amiao;
  1831.                          fen=afen;
  1832.                          shi=ashi;
  1833.                          if(count2==1)
  1834.                          {
  1835.                              write_com(0x95);
  1836.                                  write_com(0x0f);
  1837.                          }
  1838.                          if(count2==2)
  1839.                          {
  1840.                              write_com(0x93);
  1841.                          }
  1842.                          if(count2==3)
  1843.                          {
  1844.                              write_com(0x91);
  1845.                          }
  1846.                          if(count2==4)
  1847.                          {
  1848.                              count2=0;
  1849.                                  write_com(0x0c);
  1850.                                  write_ds(1,miao);
  1851.                                  write_ds(3,fen);
  1852.                                  write_ds(5,shi);
  1853.                          }
  1854.                  }
  1855.          }
  1856.          if(count2!=0)
  1857.          {
  1858.              if(zengjia==0)
  1859.                  {
  1860.                       delay(5);
  1861.                           if(zengjia==0)
  1862.                           {
  1863.                                while(!zengjia);
  1864.                                    di();
  1865.                                    if(count2==1)
  1866.                                    {
  1867.                                        miao++;
  1868.                                            if(miao==60)
  1869.                                            miao=0;
  1870.                                            write_ds(1,miao);
  1871.                                            asfm_(0x95,miao);
  1872.                                    }
  1873.                                    if(count2==2)
  1874.                                    {
  1875.                                        fen++;
  1876.                                            if(fen==60)
  1877.                                            fen=0;
  1878.                                            write_ds(3,fen);
  1879.                                            asfm_(0x93,fen);
  1880.                                    }   
  1881.                                    if(count2==3)
  1882.                                    {
  1883.                                        shi++;
  1884.                                            if(shi==24)
  1885.                                            shi=0;
  1886.                                            write_ds(5,shi);
  1887.                                            asfm_(0x91,shi);
  1888.                                    }

  1890.                           }
  1891.                  }
  1892.                  if(jianxiao==0)
  1893.                  {
  1894.                       delay(5);
  1895.                           if(jianxiao==0)
  1896.                           {
  1897.                                while(!jianxiao);
  1898.                                    di();
  1899.                                    if(count2==1)
  1900.                                    {
  1901.                                        miao--;
  1902.                                            if(miao==-1)
  1903.                                            miao=59;
  1904.                                            write_ds(1,miao);
  1905.                                            asfm_(0x95,miao);
  1906.                                    }
  1907.                                    if(count2==2)
  1908.                                    {
  1909.                                        fen--;
  1910.                                            if(fen==-1)
  1911.                                            fen=59;
  1912.                                            write_ds(3,fen);
  1913.                                            asfm_(0x93,fen);
  1914.                                    }   
  1915.                                    if(count2==3)
  1916.                                    {
  1917.                                        shi--;
  1918.                                            if(shi==-1)
  1919.                                            shi=23;
  1920.                                            write_ds(5,shi);
  1921.                                            asfm_(0x91,shi);
  1922.                                    }
  1923.                           }
  1924.                  }
  1925.          }
  1926.          if((xt1==1)&&(queding==0))
  1927.          {
  1928.              delay(5);
  1929.                  if(queding==0)
  1930.                  {
  1931.                      while(!queding);
  1932.                          write_com(0x0c);
  1933.                                  write_ds(1,miao);
  1934.                                  write_ds(3,fen);
  1935.                                  write_ds(5,shi);
  1936.                          xt1=0;
  1937.                          xt=0;
  1938.                          count2=0;
  1939.                          count1=0;
  1940.                          write_com(0x01);
  1941.                         write_com(0x80);
  1942.                             i=0;
  1943.                             while(table2_7[i]!='')
  1944.                             {
  1945.                                      write_dat(table2_7[i]);
  1946.                                         i++;
  1947.                              }
  1948.                             write_com(0x90);
  1949.                             i=0;
  1950.                             while(table2_8[i]!='')
  1951.                             {
  1952.                                      write_dat(table2_8[i]);
  1953.                                         i++;
  1954.                             }
  1955.                             write_com(0x88);
  1956.                             i=0;
  1957.                              while(table2_9[i]!='')
  1958.                             {
  1959.                                      write_dat(table2_9[i]);
  1960.                                         i++;
  1961.                             }
  1962.                                 write_com(0x98);
  1963.                             i=0;
  1964.                              while(table2_a[i]!='')
  1965.                             {
  1966.                                      write_dat(table2_a[i]);
  1967.                                         i++;
  1968.                             }
  1969.                                 delay(2000);
  1970.                                 flog1=0;
  1971.                         flog=2;
  1972.                         count=2;
  1973.                         write_com(0x01);
  1974.                         write_com(0x80);
  1975.                             i=0;
  1976.                             while(table1[i]!='')
  1977.                             {
  1978.                                      write_dat(table1[i]);
  1979.                                         i++;
  1980.                              }
  1981.                             write_com(0x90);
  1982.                             i=0;
  1983.                             while(table2[i]!='')
  1984.                             {
  1985.                                      write_dat(table2[i]);
  1986.                                         i++;
  1987.                             }
  1988.                                 write_com(0x91);
  1989.                                    write_dat(0x02);
  1990.                             write_com(0x88);
  1991.                             i=0;
  1992.                              while(table3[i]!='')
  1993.                             {
  1994.                                      write_dat(table3[i]);
  1995.                                         i++;
  1996.                             }
  1997.                             write_com(0x98);
  1998.                             i=0;
  1999.                              while(table4[i]!='')
  2000.                             {
  2001.                                      write_dat(table4[i]);
  2002.                                         i++;
  2003.                             }
  2004.                  }
  2005.          }
  2006.          if((tiaozheng==0)&&(flog1==3))
  2007.         {
  2008.             delay(5);
  2009.                 if(tiaozheng==0)
  2010.                 {
  2011.                     while(!tiaozheng);
  2012.                         di();
  2013.                         xw=1;
  2014.                         xw1=1;
  2015.                             write_com(0x01);
  2016.                         write_com(0x80);
  2017.                             i=0;
  2018.                             while(table3_1[i]!='')
  2019.                             {
  2020.                                      write_dat(table3_1[i]);
  2021.                                         i++;
  2022.                              }
  2023.                             write_com(0x90);
  2024.                             i=0;
  2025.                             while(table3_2[i]!='')
  2026.                             {
  2027.                                      write_dat(table3_2[i]);
  2028.                                         i++;
  2029.                             }
  2030.                                  write_com(0x92);
  2031.                                  write_dat(0x02);
  2032.                             write_com(0x88);
  2033.                             i=0;
  2034.                              while(table3_3[i]!='')
  2035.                             {
  2036.                                      write_dat(table3_3[i]);
  2037.                                         i++;
  2038.                             }
  2039.                             write_com(0x98);
  2040.                             i=0;
  2041.                              while(table3_4[i]!='')
  2042.                             {
  2043.                                      write_dat(table3_4[i]);
  2044.                                         i++;
  2045.                             }
  2046.                                 write_com(0x98);
  2047.                                 write_dat(0x03);
  2048.                                 write_com(0x99);
  2049.                                 write_dat(0x03);
  2050.                                 write_com(0x9a);
  2051.                                 write_dat(0x03);
  2052.                                 write_com(0x9d);
  2053.                                 write_dat(0x03);
  2054.                                 write_com(0x9e);
  2055.                                 write_dat(0x03);
  2056.                                 write_com(0x9f);
  2057.                                 write_dat(0x03);
  2058.                 }
  2059.         }
  2060.         if(xw!=0)
  2061.         {
  2062.            if(zengjia==0)
  2063.             {
  2064.                          delay(5);
  2065.                            if(zengjia==0)
  2066.                            {
  2067.                             while(!zengjia);
  2068.                             di();
  2069.                               x3++;
  2070.                             if(x3==100)
  2071.                                   x3=0;
  2072.                              }
  2073.                         }
  2074.            if(jianxiao==0)
  2075.               {
  2076.                   delay(5);
  2077.                   if(jianxiao==0)
  2078.                     {
  2079.                         while(!jianxiao);
  2080.                                 di();
  2081.                             x3--;
  2082.                             if(x3==-1)
  2083.                             x3=99;
  2084.                     }
  2085.                 }
  2086.                 if((queding==0)&&(xw1==1))
  2087.                 {
  2088.                     delay(5);
  2089.                         if(queding==0)
  2090.                         {
  2091.                             while(!queding);
  2092.                                 di();
  2093.                                 xw2=1;
  2094.                                 xw1=0;
  2095.                                 write_com(0x01);
  2096.                         write_com(0x80);
  2097.                             i=0;
  2098.                             while(table3_5[i]!='')
  2099.                             {
  2100.                                      write_dat(table3_5[i]);
  2101.                                         i++;
  2102.                              }
  2103.                             write_com(0x90);
  2104.                             i=0;
  2105.                             while(table3_6[i]!='')
  2106.                             {
  2107.                                      write_dat(table3_6[i]);
  2108.                                         i++;
  2109.                             }
  2110.                             write_com(0x88);
  2111.                             i=0;
  2112.                              while(table3_7[i]!='')
  2113.                             {
  2114.                                      write_dat(table3_7[i]);
  2115.                                         i++;
  2116.                             }
  2117.                                 delay(2000);
  2118.                                 flog1=0;
  2119.                         flog=3;
  2120.                         count=3;
  2121.                                 xw=0;
  2122.                         write_com(0x01);
  2123.                         write_com(0x80);
  2124.                             i=0;
  2125.                             while(table1[i]!='')
  2126.                             {
  2127.                                      write_dat(table1[i]);
  2128.                                         i++;
  2129.                              }
  2130.                             write_com(0x90);
  2131.                             i=0;
  2132.                             while(table2[i]!='')
  2133.                             {
  2134.                                      write_dat(table2[i]);
  2135.                                         i++;
  2136.                             }
  2137.                             write_com(0x88);
  2138.                             i=0;
  2139.                              while(table3[i]!='')
  2140.                             {
  2141.                                      write_dat(table3[i]);
  2142.                                         i++;
  2143.                             }
  2144.                                  write_com(0x89);
  2145.                                    write_dat(0x02);
  2146.                             write_com(0x98);
  2147.                             i=0;
  2148.                              while(table4[i]!='')
  2149.                             {
  2150.                                      write_dat(table4[i]);
  2151.                                         i++;
  2152.                             }
  2153.                         }
  2154.                 }
  2155.         }
  2156.         if((tiaozheng==0)&&(flog1==4))
  2157.         {
  2158.             delay(5);
  2159.                 if(tiaozheng==0)
  2160.                 {
  2161.                      while(!tiaozheng);
  2162.                          di();
  2163.                                  s1num++;
  2164.                                  xx=1;
  2165.                                 if(s1num==1)
  2166.                                 {
  2167.                                     write_com(0x9d);
  2168.                                         write_com(0x0f);
  2169.                                 }
  2170.                                 if(s1num==2)
  2171.                                 {
  2172.                                     write_com(0x9b);
  2173.                                 }
  2174.                                 if(s1num==3)
  2175.                                 {
  2176.                                     write_com(0x99);
  2177.                                 }
  2178.                                 if(s1num==4)
  2179.                                 {
  2180.                                     write_com(0x89);
  2181.                                 }                 
  2182.                             if(s1num==5)
  2183.                                 {
  2184.                                     write_com(0x95);
  2185.                                 }
  2186.                                 if(s1num==6)
  2187.                                 {
  2188.                                     write_com(0x93);
  2189.                                 }
  2190.                                 if(s1num==7)
  2191.                                 {
  2192.                                     write_com(0x91);
  2193.                                 }
  2194.                                 if(s1num==8)
  2195.                                 {
  2196.                                     s1num=0;
  2197.                                         write_com(0x0c);
  2198.                                         write_ds(0,miao);
  2199.                                         write_ds(2,fen);
  2200.                                         write_ds(4,shi);
  2201.                                         write_ds(6,week);
  2202.                                         write_ds(7,day);
  2203.                                         write_ds(8,month);
  2204.                                         write_ds(9,year);
  2205.                                 }
  2206.                 }
  2207.         }
  2208.         if(s1num!=0)
  2209.         {
  2210.              if(zengjia==0)
  2211.                  {
  2212.                      delay(5);
  2213.                          if(zengjia==0)
  2214.                          {
  2215.                              while(!zengjia);
  2216.                                  di();
  2217.                                  if(s1num==1)
  2218.                                  {
  2219.                                      miao++;
  2220.                                          if(miao==60)
  2221.                                          miao=0;
  2222.                                          sfm_(0x9d,miao);
  2223.                                          write_com(0x9d);
  2224.                                  }
  2225.                                  if(s1num==2)
  2226.                                  {
  2227.                                      fen++;
  2228.                                          if(fen==60)
  2229.                                          fen=0;
  2230.                                          sfm_(0x9b,fen);
  2231.                                          write_com(0x9b);
  2232.                                  }
  2233.                                  if(s1num==3)
  2234.                                  {
  2235.                                      shi++;
  2236.                                          if(shi==24)
  2237.                                          shi=0;
  2238.                                          sfm_(0x99,shi);
  2239.                                          write_com(0x99);
  2240.                                  }
  2241.                                  if(s1num==4)
  2242.                                  {
  2243.                                      week++;
  2244.                                          if(week==8)
  2245.                                          week=1;
  2246.                                          week_(0x89,week);
  2247.                                          write_com(0x89);
  2248.                                  }
  2249.                                  if(s1num==5)
  2250.                                  {
  2251.                                      day++;
  2252.                                          if(day==32)
  2253.                                          day=1;
  2254.                                          nyr_(0x95,day);
  2255.                                          write_com(0x95);
  2256.                                  }
  2257.                                  if(s1num==6)
  2258.                                  {
  2259.                                      month++;
  2260.                                          if(month==13)
  2261.                                          month=1;
  2262.                                          nyr_(0x93,month);
  2263.                                          write_com(0x93);
  2264.                                  }
  2265.                                  if(s1num==7)
  2266.                                  {
  2267.                                      year++;
  2268.                                          if(year==100)
  2269.                                          year=0;
  2270.                                          nyr_(0x91,year);
  2271.                                          write_com(0x91);
  2272.                                  }
  2273.                          }
  2274.                  }
  2275.         }
  2276.         if(s1num!=0)
  2277.         {
  2278.              if(jianxiao==0)
  2279.                  {
  2280.                      delay(5);
  2281.                          if(jianxiao==0)
  2282.                          {
  2283.                              while(!jianxiao);
  2284.                                  di();
  2285.                                  if(s1num==1)
  2286.                                  {
  2287.                                      miao--;
  2288.                                          if(miao==-1)
  2289.                                          miao=59;
  2290.                                          sfm_(0x9d,miao);
  2291.                                          write_com(0x9d);
  2292.                                  }
  2293.                                  if(s1num==2)
  2294.                                  {
  2295.                                      fen--;
  2296.                                          if(fen==-1)
  2297.                                          fen=59;
  2298.                                          sfm_(0x9b,fen);
  2299.                                          write_com(0x9b);
  2300.                                  }
  2301.                                  if(s1num==3)
  2302.                                  {
  2303.                                      shi--;
  2304.                                          if(shi==-1)
  2305.                                          shi=23;
  2306.                                          sfm_(0x99,shi);
  2307.                                          write_com(0x99);
  2308.                                  }
  2309.                                  if(s1num==4)
  2310.                                  {
  2311.                                      week--;
  2312.                                          if(week==0)
  2313.                                          week=7;
  2314.                                          week_(0x89,week);
  2315.                                          write_com(0x89);
  2316.                                  }
  2317.                                  if(s1num==5)
  2318.                                  {
  2319.                                      day--;
  2320.                                          if(day==0)
  2321.                                          day=31;
  2322.                                          nyr_(0x95,day);
  2323.                                          write_com(0x95);
  2324.                                  }
  2325.                                  if(s1num==6)
  2326.                                  {
  2327.                                      month--;
  2328.                                          if(month==0)
  2329.                                          month=12;
  2330.                                          nyr_(0x93,month);
  2331.                                          write_com(0x93);
  2332.                                  }
  2333.                                  if(s1num==7)
  2334.                                  {
  2335.                                      year--;
  2336.                                          if(year==-1)
  2337.                                          year=99;
  2338.                                          nyr_(0x91,year);
  2339.                                          write_com(0x91);
  2340.                                  }
  2341.                          }
  2342.                  }
  2343.         }
  2344.         if((xx==1)&&(queding==0))
  2345.         {
  2346.             delay(5);
  2347.                 if(queding==0)
  2348.                 {
  2349.                     while(!queding);
  2350.                         di();
  2351.                         write_com(0x01);
  2352.                         xx=0;
  2353.                         s1num=0;
  2354.                         write_com(0x0c);
  2355.                         write_ds(0,miao);
  2356.                         write_ds(2,fen);
  2357.                         write_ds(4,shi);
  2358.                         write_ds(6,week);
  2359.                         write_ds(7,day);
  2360.                         write_ds(8,month);
  2361.                         write_ds(9,year);
  2362.                         write_com(0x80);
  2363.                             i=0;
  2364.                             while(table4_5[i]!='')
  2365.                             {
  2366.                                      write_dat(table4_5[i]);
  2367.                                         i++;
  2368.                              }
  2369.                             write_com(0x90);
  2370.                             i=0;
  2371.                             while(table4_6[i]!='')
  2372.                             {
  2373.                                      write_dat(table4_6[i]);
  2374.                                         i++;
  2375.                             }
  2376.                             write_com(0x88);
  2377.                             i=0;
  2378.                              while(table4_7[i]!='')
  2379.                             {
  2380.                                      write_dat(table4_7[i]);
  2381.                                         i++;
  2382.                             }
  2383.                             write_com(0x98);
  2384.                             i=0;
  2385.                              while(table4_8[i]!='')
  2386.                             {
  2387.                                      write_dat(table4_8[i]);
  2388.                                         i++;
  2389.                             }
  2390.                                 delay(2000);
  2391.                                 flog1=0;
  2392.                         flog=4;
  2393.                         count=4;
  2394.                                 xw=0;
  2395.                         write_com(0x01);
  2396.                         write_com(0x80);
  2397.                             i=0;
  2398.                             while(table1[i]!='')
  2399.                             {
  2400.                                      write_dat(table1[i]);
  2401.                                         i++;
  2402.                              }
  2403.                             write_com(0x90);
  2404.                             i=0;
  2405.                             while(table2[i]!='')
  2406.                             {
  2407.                                      write_dat(table2[i]);
  2408.                                         i++;
  2409.                             }
  2410.                             write_com(0x88);
  2411.                             i=0;
  2412.                              while(table3[i]!='')
  2413.                             {
  2414.                                      write_dat(table3[i]);
  2415.                                         i++;
  2416.                             }
  2417.                                  
  2418.                             write_com(0x98);
  2419.                             i=0;
  2420.                              while(table4[i]!='')
  2421.                             {
  2422.                                      write_dat(table4[i]);
  2423.                                         i++;
  2424.                             }
  2425.                                 write_com(0x99);
  2426.                                    write_dat(0x02);
  2427.                 }
  2428.         }


  2431.         if((tiaozheng==0)&&(flog1==5)&&(axt!=2))
  2432.          {
  2433.              delay(5);
  2434.                  if(tiaozheng==0)
  2435.                  {
  2436.                      while(!tiaozheng);
  2437.                          di();
  2438.                          acount1++;
  2439.                          if(acount1==1)
  2440.                          {
  2441.                              write_com(0x88);
  2442.                                  write_dat(0x20);
  2443.                                  write_com(0x90);
  2444.                                  write_dat(0x02);
  2445.                                  axt=1;
  2446.                          }
  2447.                          if(acount1==2)
  2448.                          {
  2449.                              write_com(0x88);
  2450.                                  write_dat(0x02);
  2451.                                  write_com(0x90);
  2452.                                  write_dat(0x20);
  2453.                                  axt=4;
  2454.                          }
  2455.                          if(acount1==3)
  2456.                          {
  2457.                              acount1=0;
  2458.                                  write_com(0x88);
  2459.                                  write_dat(0x20);
  2460.                          }
  2461.                  }         
  2462.          }

  2464.       if((axt==4)&&(queding==0))
  2465.           {
  2466.                delay(5);
  2467.                    if(queding==0)
  2468.                    {
  2469.                         while(!queding);
  2470.                                 di();
  2471.                         ahh=0;
  2472.                                 axt=0;
  2473.                         write_com(0x80);
  2474.                             i=0;
  2475.                             while(table5_b[i]!='')
  2476.                             {
  2477.                                      write_dat(table5_b[i]);
  2478.                                         i++;
  2479.                              }
  2480.                             write_com(0x90);
  2481.                             i=0;
  2482.                             while(table5_c[i]!='')
  2483.                             {
  2484.                                      write_dat(table5_c[i]);
  2485.                                         i++;
  2486.                             }
  2487.                             write_com(0x88);
  2488.                             i=0;
  2489.                              while(table5_d[i]!='')
  2490.                             {
  2491.                                      write_dat(table5_d[i]);
  2492.                                         i++;
  2493.                             }
  2494.                             write_com(0x98);
  2495.                             i=0;
  2496.                              while(table5_e[i]!='')
  2497.                             {
  2498.                                      write_dat(table5_e[i]);
  2499.                                         i++;
  2500.                             }
  2501.                                 delay(2000);
  2502.                                 flog1=0;
  2503.                         flog=5;
  2504.                         count=5;
  2505.                         write_com(0x01);
  2506.                         write_com(0x80);
  2507.                             i=0;
  2508.                             while(table5[i]!='')
  2509.                             {
  2510.                                      write_dat(table5[i]);
  2511.                                         i++;
  2512.                              }
  2513.                                  write_com(0x81);
  2514.                                    write_dat(0x02);
  2515.                             write_com(0x90);
  2516.                             i=0;
  2517.                             while(table5[i]!='')
  2518.                             {
  2519.                                      write_dat(table5[i]);
  2520.                                         i++;
  2521.                             }
  2522.                             write_com(0x88);
  2523.                             i=0;
  2524.                              while(table5[i]!='')
  2525.                             {
  2526.                                      write_dat(table5[i]);
  2527.                                         i++;
  2528.                             }
  2529.                             write_com(0x98);
  2530.                             i=0;
  2531.                              while(table5[i]!='')
  2532.                             {
  2533.                                      write_dat(table5[i]);
  2534.                                         i++;
  2535.                             }
  2536.                    }
  2537.           }

  2539.          if((axt==1)&&(queding==0)&&(axt1==0))
  2540.          {
  2541.              delay(5);
  2542.              if(queding==0)
  2543.                   {
  2544.                       while(!queding);
  2545.                           di();
  2546.                           axt=2;
  2547.                           ahh=1;
  2548.                           write_com(0x01);
  2549.                           write_com(0x80);
  2550.                             i=0;
  2551.                             while(table5_5[i]!='')
  2552.                             {
  2553.                                      write_dat(table5_5[i]);
  2554.                                         i++;
  2555.                             }
  2556.                                 write_com(0x90);
  2557.                             i=0;
  2558.                             while(table5_6[i]!='')
  2559.                             {
  2560.                                      write_dat(table5_6[i]);
  2561.                                         i++;
  2562.                             }

  2564.                                 write_com(0x98);
  2565.                                 write_dat(0x03);
  2566.                                 write_com(0x99);
  2567.                                 write_dat(0x03);
  2568.                                 write_com(0x9a);
  2569.                                 write_dat(0x03);
  2570.                                 write_com(0x9d);
  2571.                                 write_dat(0x03);
  2572.                                 write_com(0x9e);
  2573.                                 write_dat(0x03);
  2574.                                 write_com(0x9f);
  2575.                                 write_dat(0x03);
  2576.                   }
  2577.          }
  2578.          if((axt==2)&&(tiaozheng==0))
  2579.          {
  2580.              delay(5);
  2581.                  if(tiaozheng==0)
  2582.                  {
  2583.                      while(!tiaozheng);
  2584.                          di();
  2585.                          acount2++;
  2586.                          axt1=1;
  2587.                          amiao=read_ds(1);
  2588.              afen=read_ds(3);
  2589.              ashi=read_ds(5);
  2590.                          miao=amiao;
  2591.                          fen=afen;
  2592.                          shi=ashi;
  2593.                          if(acount2==1)
  2594.                          {
  2595.                              write_com(0x95);
  2596.                                  write_com(0x0f);
  2597.                          }
  2598.                          if(acount2==2)
  2599.                          {
  2600.                              write_com(0x93);
  2601.                          }
  2602.                          if(acount2==3)
  2603.                          {
  2604.                              write_com(0x91);
  2605.                          }
  2606.                          if(acount2==4)
  2607.                          {
  2608.                              acount2=0;
  2609.                                  write_com(0x0c);
  2610.                                  write_ds(1,miao);
  2611.                                  write_ds(3,fen);
  2612.                                  write_ds(5,shi);
  2613.                          }
  2614.                  }
  2615.          }
  2616.          if(acount2!=0)
  2617.          {
  2618.              if(zengjia==0)
  2619.                  {
  2620.                       delay(5);
  2621.                           if(zengjia==0)
  2622.                           {
  2623.                                while(!zengjia);
  2624.                                    di();
  2625.                                    if(acount2==1)
  2626.                                    {
  2627.                                        miao++;
  2628.                                            if(miao==60)
  2629.                                            miao=0;
  2630.                                            write_ds(1,miao);
  2631.                                            asfm_(0x95,miao);
  2632.                                    }
  2633.                                    if(acount2==2)
  2634.                                    {
  2635.                                        fen++;
  2636.                                            if(fen==60)
  2637.                                            fen=0;
  2638.                                            write_ds(3,fen);
  2639.                                            asfm_(0x93,fen);
  2640.                                    }   
  2641.                                    if(acount2==3)
  2642.                                    {
  2643.                                        shi++;
  2644.                                            if(shi==24)
  2645.                                            shi=0;
  2646.                                            write_ds(5,shi);
  2647.                                            asfm_(0x91,shi);
  2648.                                    }

  2650.                           }
  2651.                  }
  2652.                  if(jianxiao==0)
  2653.                  {
  2654.                       delay(5);
  2655.                           if(jianxiao==0)
  2656.                           {
  2657.                                while(!jianxiao);
  2658.                                    di();
  2659.                                    if(acount2==1)
  2660.                                    {
  2661.                                        miao--;
  2662.                                            if(miao==-1)
  2663.                                            miao=59;
  2664.                                            write_ds(1,miao);
  2665.                                            asfm_(0x95,miao);
  2666.                                    }
  2667.                                    if(acount2==2)
  2668.                                    {
  2669.                                        fen--;
  2670.                                            if(fen==-1)
  2671.                                            fen=59;
  2672.                                            write_ds(3,fen);
  2673.                                            asfm_(0x93,fen);
  2674.                                    }   
  2675.                                    if(acount2==3)
  2676.                                    {
  2677.                                        shi--;
  2678.                                            if(shi==-1)
  2679.                                            shi=23;
  2680.                                            write_ds(5,shi);
  2681.                                            asfm_(0x91,shi);
  2682.                                    }
  2683.                           }
  2684.                  }
  2685.          }
  2686.          if((axt1==1)&&(queding==0))
  2687.          {
  2688.              delay(5);
  2689.                  if(queding==0)
  2690.                  {
  2691.                      while(!queding);
  2692.                          write_com(0x0c);
  2693.                                  write_ds(1,miao);
  2694.                                  write_ds(3,fen);
  2695.                                  write_ds(5,shi);
  2696.                          axt1=0;
  2697.                          axt=0;
  2698.                          acount2=0;
  2699.                          acount1=0;
  2700.                          write_com(0x01);
  2701.                         write_com(0x80);
  2702.                             i=0;
  2703.                             while(table5_7[i]!='')
  2704.                             {
  2705.                                      write_dat(table5_7[i]);
  2706.                                         i++;
  2707.                              }
  2708.                             write_com(0x90);
  2709.                             i=0;
  2710.                             while(table5_8[i]!='')
  2711.                             {
  2712.                                      write_dat(table5_8[i]);
  2713.                                         i++;
  2714.                             }
  2715.                             write_com(0x88);
  2716.                             i=0;
  2717.                              while(table5_9[i]!='')
  2718.                             {
  2719.                                      write_dat(table5_9[i]);
  2720.                                         i++;
  2721.                             }
  2722.                                 write_com(0x98);
  2723.                             i=0;
  2724.                              while(table5_a[i]!='')
  2725.                             {
  2726.                                      write_dat(table5_a[i]);
  2727.                                         i++;
  2728.                             }
  2729.                                 delay(2000);
  2730.                                 flog1=0;
  2731.                         flog=5;
  2732.                         count=5;
  2733.                         write_com(0x01);
  2734.                         write_com(0x80);
  2735.                             i=0;
  2736.                             while(table5[i]!='')
  2737.                             {
  2738.                                      write_dat(table5[i]);
  2739.                                         i++;
  2740.                              }
  2741.                                  write_com(0x81);
  2742.                                    write_dat(0x02);
  2743.                             write_com(0x90);
  2744.                             i=0;
  2745.                             while(table6[i]!='')
  2746.                             {
  2747.                                      write_dat(table6[i]);
  2748.                                         i++;
  2749.                             }
  2750.                             write_com(0x88);
  2751.                             i=0;
  2752.                              while(table7[i]!='')
  2753.                             {
  2754.                                      write_dat(table7[i]);
  2755.                                         i++;
  2756.                             }
  2757.                             write_com(0x98);
  2758.                             i=0;
  2759.                              while(table8[i]!='')
  2760.                             {
  2761.                                      write_dat(table8[i]);
  2762.                                         i++;
  2763.                             }
  2764.                  }
  2765.          }
  2766. }

  2768. void sx_()
  2769. {
  2770.      uchar i;
  2771.     if((flog1==0)&&(zengjia==0))
  2772.         {
  2773.             delay(5);
  2774.                 if(zengjia==0)
  2775.                 {
  2776.                     while(!zengjia);
  2777.                         di();
  2778.                     count--;
  2779.                  if(count==1)
  2780.                     {
  2781.                             flog=1;
  2782.                                 write_com(0x01);
  2783.                             write_com(0x80);
  2784.                             i=0;
  2785.                             while(table1[i]!='')
  2786.                             {
  2787.                                      write_dat(table1[i]);
  2788.                                         i++;
  2789.                              }
  2790.                                  write_com(0x81);
  2791.                             write_dat(0x02);
  2792.                             write_com(0x90);
  2793.                             i=0;
  2794.                             while(table2[i]!='')
  2795.                             {
  2796.                                      write_dat(table2[i]);
  2797.                                         i++;
  2798.                             }
  2799.                             write_com(0x88);
  2800.                             i=0;
  2801.                              while(table3[i]!='')
  2802.                             {
  2803.                                      write_dat(table3[i]);
  2804.                                         i++;
  2805.                             }
  2806.                             write_com(0x98);
  2807.                             i=0;
  2808.                              while(table4[i]!='')
  2809.                             {
  2810.                                      write_dat(table4[i]);
  2811.                                         i++;
  2812.                             }
  2813.                     }
  2814.                     if(count==2)
  2815.                    {
  2816.                     flog=2;
  2817.                         write_com(0x01);
  2818.                          write_com(0x80);
  2819.                             i=0;
  2820.                             while(table1[i]!='')
  2821.                             {
  2822.                                      write_dat(table1[i]);
  2823.                                         i++;
  2824.                              }
  2825.                             write_com(0x90);
  2826.                             i=0;
  2827.                             while(table2[i]!='')
  2828.                             {
  2829.                                      write_dat(table2[i]);
  2830.                                         i++;
  2831.                             }
  2832.                                 write_com(0x91);
  2833.                         write_dat(0x02);
  2834.                             write_com(0x88);
  2835.                             i=0;
  2836.                              while(table3[i]!='')
  2837.                             {
  2838.                                      write_dat(table3[i]);
  2839.                                         i++;
  2840.                             }
  2841.                             write_com(0x98);
  2842.                             i=0;
  2843.                              while(table4[i]!='')
  2844.                             {
  2845.                                      write_dat(table4[i]);
  2846.                                         i++;
  2847.                             }
  2848.                    }
  2849.                    if(count==3)
  2850.                    {
  2851.                              flog=3;
  2852.                                  write_com(0x01);
  2853.                                  write_com(0x80);
  2854.                             i=0;
  2855.                             while(table1[i]!='')
  2856.                             {
  2857.                                      write_dat(table1[i]);
  2858.                                         i++;
  2859.                              }
  2860.                             write_com(0x90);
  2861.                             i=0;
  2862.                             while(table2[i]!='')
  2863.                             {
  2864.                                      write_dat(table2[i]);
  2865.                                         i++;
  2866.                             }
  2867.                             write_com(0x88);
  2868.                             i=0;
  2869.                              while(table3[i]!='')
  2870.                             {
  2871.                                      write_dat(table3[i]);
  2872.                                         i++;
  2873.                             }
  2874.                                 write_com(0x89);
  2875.                             write_dat(0x02);
  2876.                             write_com(0x98);
  2877.                             i=0;
  2878.                              while(table4[i]!='')
  2879.                             {
  2880.                                      write_dat(table4[i]);
  2881.                                         i++;
  2882.                             }
  2883.                    }
  2884.                    if(count==4)
  2885.                    {
  2886.                             flog=4;
  2887.                                 write_com(0x01);
  2888.                                  write_com(0x80);
  2889.                             i=0;
  2890.                             while(table1[i]!='')
  2891.                             {
  2892.                                      write_dat(table1[i]);
  2893.                                         i++;
  2894.                              }
  2895.                             write_com(0x90);
  2896.                             i=0;
  2897.                             while(table2[i]!='')
  2898.                             {
  2899.                                      write_dat(table2[i]);
  2900.                                         i++;
  2901.                             }
  2902.                             write_com(0x88);
  2903.                             i=0;
  2904.                              while(table3[i]!='')
  2905.                             {
  2906.                                      write_dat(table3[i]);
  2907.                                         i++;
  2908.                             }
  2909.                             write_com(0x98);
  2910.                             i=0;
  2911.                              while(table4[i]!='')
  2912.                             {
  2913.                                      write_dat(table4[i]);
  2914.                                         i++;
  2915.                             }
  2916.                                  write_com(0x99);
  2917.                             write_dat(0x02);
  2918.                    }
  2919.                  
  2920.                  if(count==5)
  2921.                  {
  2922.                     flog=5;
  2923.                         write_com(0x01);
  2924.                          write_com(0x80);
  2925.                      i=0;
  2926.                      while(table5[i]!='')
  2927.                      {
  2928.                              write_dat(table5[i]);
  2929.                                 i++;
  2930.                      }
  2931.                          write_com(0x81);
  2932.                     write_dat(0x02);
  2933.                          write_com(0x90);
  2934.                       i=0;
  2935.                       while(table6[i]!='')
  2936.                      {
  2937.                              write_dat(table6[i]);
  2938.                                 i++;
  2939.                      }
  2940.                          write_com(0x88);
  2941.                       i=0;
  2942.                       while(table7[i]!='')
  2943.                      {
  2944.                              write_dat(table7[i]);
  2945.                                 i++;
  2946.                      }
  2947.                          write_com(0x98);
  2948.                       i=0;
  2949.                       while(table8[i]!='')
  2950.                      {
  2951.                              write_dat(table8[i]);
  2952.                                 i++;
  2953.                      }
  2954.                  }
  2955.                  if(count==6)
  2956.                  {
  2957.                     flog=6;
  2958.                         write_com(0x01);
  2959.                          write_com(0x80);
  2960.                      i=0;
  2961.                      while(table5[i]!='')
  2962.                      {
  2963.                              write_dat(table5[i]);
  2964.                                 i++;
  2965.                      }
  2966.                          write_com(0x90);
  2967.                       i=0;
  2968.                       while(table6[i]!='')
  2969.                      {
  2970.                              write_dat(table6[i]);
  2971.                                 i++;
  2972.                      }
  2973.                           write_com(0x91);
  2974.                     write_dat(0x02);
  2975.                          write_com(0x88);
  2976.                       i=0;
  2977.                       while(table7[i]!='')
  2978.                      {
  2979.                              write_dat(table7[i]);
  2980.                                 i++;
  2981.                      }
  2982.                          write_com(0x98);
  2983.                       i=0;
  2984.                       while(table8[i]!='')
  2985.                      {
  2986.                              write_dat(table8[i]);
  2987.                                 i++;
  2988.                      }
  2989.                  }
  2990.                  if(count==7)
  2991.                  {
  2992.                     flog=7;
  2993.                         write_com(0x01);
  2994.                          write_com(0x80);
  2995.                      i=0;
  2996.                      while(table5[i]!='')
  2997.                      {
  2998.                              write_dat(table5[i]);
  2999.                                 i++;
  3000.                      }
  3001.                          write_com(0x90);
  3002.                       i=0;
  3003.                       while(table6[i]!='')
  3004.                      {
  3005.                              write_dat(table6[i]);
  3006.                                 i++;
  3007.                      }
  3008.                          write_com(0x88);
  3009.                       i=0;
  3010.                       while(table7[i]!='')
  3011.                      {
  3012.                              write_dat(table7[i]);
  3013.                                 i++;
  3014.                      }
  3015.                          write_com(0x89);
  3016.                      write_dat(0x02);
  3017.                          write_com(0x98);
  3018.                       i=0;
  3019.                       while(table8[i]!='')
  3020.                      {
  3021.                              write_dat(table8[i]);
  3022.                                 i++;
  3023.                      }
  3024.                  }
  3025.                 }
  3026.         }
  3027. }

  3029. void alarm()
  3030. {
  3031.     if(flag_ri==1)
  3032.         {
  3033.             if((xuanzhe==0)||(queding==0)||(fanhui==0)||(tiaozheng==0)||(zengjia==0)||(jianxiao==0))
  3034.                 {
  3035.                     flag_ri=0;
  3036.                 }
  3037.         }
  3038. }

  3040. void kaiguan()
  3041. {
  3042.      uchar i;
  3043.     if((flog1==0)&&(jianxiao==0))
  3044.         {
  3045.             delay(5);
  3046.                 if(jianxiao==0)
  3047.                 {
  3048.                            while(!jianxiao);
  3049.                            di();
  3050.                            jidianqi=~jidianqi;
  3051.                            if(jidianqi==0)
  3052.                            {
  3053.                                        write_com(0x01);
  3054.                                         write_com(0x90);
  3055.                         i=0;
  3056.                         while(table02[i]!='')
  3057.                          {
  3058.                                     write_dat(table02[i]);
  3059.                                         i++;
  3060.                         }
  3061.                                         write_com(0x98);
  3062.                                         write_dat(0x03);
  3063.                                         write_com(0x99);
  3064.                                         write_dat(0x03);
  3065.                                         write_com(0x9a);
  3066.                                         write_dat(0x03);
  3067.                                         write_com(0x9d);
  3068.                                         write_dat(0x03);
  3069.                                         write_com(0x9e);
  3070.                                         write_dat(0x03);
  3071.                                         write_com(0x9f);
  3072.                                         write_dat(0x03);
  3073.                                         delay(2000);
  3074.                                         count=1;
  3075.                                         flog=1;
  3076.                                         flog1=0;
  3077.                                         write_com(0x01);
  3078.                        write_com(0x80);
  3079.                         i=0;
  3080.                         while(table1[i]!='')
  3081.                          {
  3082.                                     write_dat(table1[i]);
  3083.                                         i++;
  3084.                         }
  3085.                                          write_com(0x81);
  3086.                                      write_dat(0x02);
  3087.                          write_com(0x90);
  3088.                         i=0;
  3089.                         while(table2[i]!='')
  3090.                          {
  3091.                                       write_dat(table2[i]);
  3092.                                            i++;
  3093.                          }
  3094.                               write_com(0x88);
  3095.                         i=0;
  3096.                         while(table3[i]!='')
  3097.                          {
  3098.                                      write_dat(table3[i]);
  3099.                                         i++;
  3100.                          }
  3101.                           write_com(0x98);
  3102.                           i=0;
  3103.                          while(table4[i]!='')
  3104.                          {
  3105.                                       write_dat(table4[i]);
  3106.                                          i++;
  3107.                           }
  3108.                            }
  3109.                            if(jidianqi==1)
  3110.                            {
  3111.                                        write_com(0x01);
  3112.                                         write_com(0x90);
  3113.                         i=0;
  3114.                                         xh2=0;
  3115.                         while(table01[i]!='')
  3116.                          {
  3117.                                     write_dat(table01[i]);
  3118.                                         i++;
  3119.                         }
  3120.                                         write_com(0x98);
  3121.                                         write_dat(0x03);
  3122.                                         write_com(0x99);
  3123.                                         write_dat(0x03);
  3124.                                         write_com(0x9a);
  3125.                                         write_dat(0x03);
  3126.                                         write_com(0x9d);
  3127.                                         write_dat(0x03);
  3128.                                         write_com(0x9e);
  3129.                                         write_dat(0x03);
  3130.                                         write_com(0x9f);
  3131.                                         write_dat(0x03);
  3132.                                         delay(2000);
  3133.                                         count=1;
  3134.                                    flog=1;
  3135.                                    flog1=0;
  3136.                                         write_com(0x01);
  3137.                        write_com(0x80);
  3138.                         i=0;
  3139.                         while(table1[i]!='')
  3140.                          {
  3141.                                     write_dat(table1[i]);
  3142.                                         i++;
  3143.                         }
  3144.                                          write_com(0x81);
  3145.                                         write_dat(0x02);
  3146.                          write_com(0x90);
  3147.                         i=0;
  3148.                         while(table2[i]!='')
  3149.                          {
  3150.                                       write_dat(table2[i]);
  3151.                                            i++;
  3152.                          }
  3153.                               write_com(0x88);
  3154.                         i=0;
  3155.                         while(table3[i]!='')
  3156.                          {
  3157.                                      write_dat(table3[i]);
  3158.                                         i++;
  3159.                          }
  3160.                           write_com(0x98);
  3161.                           i=0;
  3162.                          while(table4[i]!='')
  3163.                          {
  3164.                                       write_dat(table4[i]);
  3165.                                          i++;
  3166.                           }
  3167.                            }
  3168.                 }
  3169.         }

  3171. }

  3173. void wendu()
  3174. {
  3175.     if((xh2==1)&&(get_temp()<=(x1-2)*10))
  3176.         {
  3177.             jidianqi=1;
  3178.         //        ttmm=1;
  3179.         }
  3180.         if((get_temp()>=(x1+3)*10)&&(xh2==1))
  3181.                 {
  3182.                     jidianqi=0;
  3183.                 }
  3184. }

  3186. void baojing()
  3187. {
  3188.      uchar i;
  3189.      if((xw2==1)&&(get_temp()>=(x3*10)))
  3190.          {
  3191.             for(i=0;i<8;i++)
  3192.                 {
  3193.              di();
  3194.                  delay(80);
  3195.                  di();
  3196.                  delay(80);
  3197.                  di();
  3198.                  delay(300);
  3199.                  }
  3200.                 xw2=0;
  3201.          }
  3202.            
  3203. }

  3205. void main()
  3206. {
  3207.    uchar i;
  3208.   lcd_init();
  3209.   init1();
  3210.    while(1)
  3211.          {         
  3212.               xuanzhe_();
  3213.                   queding_();
  3214.                   fanhui_();
  3215.                   tiaozheng_();
  3216.                    kaiguan();
  3217.                    baojing();
  3218.                    wendu();
  3219.                  // read_alarm();
  3220.                   sx_();
  3221.                   if((flag_ri==1)&&(hh==1))
  3222.                   {
  3223.                       jidianqi=1;
  3224.                   }
  3225.                   if((flag_ri==1)&&(ahh==1))
  3226.                   {
  3227.                       di();
  3228.                           delay(100);
  3229.                           di();
  3230.                           delay(500);
  3231.                   }
  3232.                   if(xh==1)
  3233.                   {
  3234.                       x1_(x1);
  3235.                   }
  3236.                   if(xw==1)
  3237.                   {
  3238.                       x3_(x3);
  3239.                   }
  3240.             if(ff==1)
  3241.                 {
  3242.                     
  3243.                          tempchang();
  3244.                           for(i=10;i>0;i--)
  3245.                           {
  3246.                              tx(5,get_temp());
  3247.                           }
  3248.                           year=read_ds(9);
  3249.                           month=read_ds(8);
  3250.                           day=read_ds(7);
  3251.                           week=read_ds(6);
  3252.                           shi=read_ds(4);
  3253.                           fen=read_ds(2);
  3254.                           miao=read_ds(0);
  3255.                           sfm_(0x8d,miao);
  3256.                           sfm_(0x8b,fen);
  3257.                           sfm_(0x89,shi);
  3258.                           nyr_(0x85,day);
  3259.                           nyr_(0x83,month);
  3260.                           nyr_(0x81,year);
  3261.                           week_(0x91,week);
  3262.                   }
  3263.                   alarm();
  3264.           }
  3265. }

  3267. void shijian_() interrupt 2
  3268. {
  3269.     uchar c;
  3270.         flag_ri=1;
  3271.         c=read_ds(0x0c);
  3272. }                 
复制代码




半导体, 单片机, 程序, 制冷

评分

参与人数 5黑币 +35 收起 理由
阿巴 + 5 很给力！
都市郎 + 15 很给力！
qwiornbkcjoir + 5 很给力！
无解的麻瓜== + 5 很给力！
崔123 + 5 绝世好帖！很喜欢

查看全部评分

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

相关帖子
回复

使用道具 举报

沙发
ID:128771 发表于 2016-7-5 02:52 | 只看该作者
继电器具体是什么作用？来控制电源，让制冷器的温度保持吗？还有原理图的VDD是什么？接什么的？继电器模块上的火线和 零线要接到哪里？是接到变压器那里吗？还有是怎么设置温度的，设置为0度，制冷器里的温度就会改变吗，怎么控制的？18b20放外面怎么读取温度，为什么没有放到泡沫的盒子里面？制冷器是怎么工作的？
------------------------------------------
答：
继电器控制电源线从而来控制制冷器，VDD好像是接电源，太久了我也忘了。。至于火线和零线接到12v输出。18B20是放在泡沫箱子里面的。
回复

使用道具 举报

板凳
ID:68727 发表于 2016-10-3 00:25 来自手机 | 只看该作者
这个好我正准备DIY个冰箱，怎样可以联系到楼主麻烦指导下
回复

使用道具 举报

地板
ID:99130 发表于 2016-10-3 11:02 | 只看该作者
JP1 JP?这两个是啥？？？K2是18B20???接线错了吧？？？
回复

使用道具 举报

5#
ID:99612 发表于 2016-10-5 22:28 | 只看该作者
谢谢分享！楼主威武！  下载不了  可惜了
回复

使用道具 举报

6#
ID:150676 发表于 2016-11-28 09:05 | 只看该作者
楼主是大神啊，学习了
回复

使用道具 举报

7#
ID:190295 发表于 2017-4-17 01:07 | 只看该作者
本来想在宿舍买个小冰箱，可是太贵了，上网看到楼主这篇文章，我觉得我也可以尝试一下DIY
回复

使用道具 举报

8#
ID:124044 发表于 2017-5-16 17:21 | 只看该作者
打开电路原理图提示要密码？？
回复

使用道具 举报

9#
ID:226544 发表于 2017-8-10 13:40 | 只看该作者
楼主，666.  这个冰箱能不能冰住食物
回复

使用道具 举报

10#
ID:230337 发表于 2017-8-31 22:17 | 只看该作者
谢谢，正需要呢。

回复

使用道具 举报

11#
ID:124729 发表于 2017-9-22 13:03 | 只看该作者
看上去不错
回复

使用道具 举报

12#
ID:305926 发表于 2018-4-11 15:55 来自手机 | 只看该作者
JP1 JP?是什么
回复

使用道具 举报

13#
ID:305926 发表于 2018-4-11 16:47 来自手机 | 只看该作者
楼楼，能给个元器件清单么
回复

使用道具 举报

14#
ID:321156 发表于 2018-5-3 13:33 | 只看该作者
厉害厉害，制冷器有某宝链接吗
回复

使用道具 举报

15#
ID:291355 发表于 2018-5-14 16:55 | 只看该作者
冰箱温度范围是多少？
回复

使用道具 举报

16#
ID:327167 发表于 2018-6-11 16:58 | 只看该作者
楼主能发一下元器件清单吗
回复

使用道具 举报

17#
ID:357697 发表于 2018-6-24 12:11 | 只看该作者
可以学习了
回复

使用道具 举报

18#
ID:68875 发表于 2018-6-24 19:36 | 只看该作者
good job
回复

使用道具 举报

19#
ID:357855 发表于 2018-6-26 00:22 | 只看该作者
谢谢分享
回复

使用道具 举报

20#
ID:359022 发表于 2018-7-11 09:29 | 只看该作者
半导体制冷片能2度，这冰箱很好很实用了，就是不知道正常使用的寿命能有多久！
回复

使用道具 举报

21#
ID:377064 发表于 2018-9-26 20:39 | 只看该作者
谢谢分享，最近在实训就是弄这个课题的
回复

使用道具 举报

22#
ID:321156 发表于 2018-10-16 18:30 来自手机 | 只看该作者
您好！我想请问继电器接电源火线，那继电器是220v的吗
回复

使用道具 举报

23#
ID:399179 发表于 2018-10-16 19:14 来自手机 | 只看该作者
谢谢楼主分享！
回复

使用道具 举报

24#
ID:321156 发表于 2018-11-22 13:12 来自手机 | 只看该作者
你好，我想问DS12c887的DB接哪里
回复

使用道具 举报

25#
ID:452513 发表于 2018-12-24 11:45 | 只看该作者
大神，大力
回复

使用道具 举报

26#
ID:478628 发表于 2019-2-20 20:24 | 只看该作者
感谢大神，可以给个联系方式教我下吗
回复

使用道具 举报

27#
ID:486664 发表于 2019-3-27 23:47 来自手机 | 只看该作者
请问用51可以做吗？
回复

使用道具 举报

28#
ID:432004 发表于 2019-4-4 20:01 | 只看该作者
楼楼，能给个元器件清单么
回复

使用道具 举报

29#
ID:456690 发表于 2019-4-6 17:10 | 只看该作者
这个费电不？制冷功率是多少？
回复

使用道具 举报

30#
ID:516282 发表于 2019-4-19 12:54 | 只看该作者
楼主，可以做客视频什么的么，或者发一下配件清单，我小白，谢谢
回复

使用道具 举报

31#
ID:95059 发表于 2019-4-20 11:59 | 只看该作者
超出了2K，还有就是为什么没有模块化编程呢？  
回复

使用道具 举报

32#
ID:528547 发表于 2019-5-20 09:03 | 只看该作者
很厉害
回复

使用道具 举报

33#
ID:625798 发表于 2019-10-22 20:54 | 只看该作者
继电器怎么选啊楼主
回复

使用道具 举报

34#
ID:625798 发表于 2019-10-23 00:29 来自手机 | 只看该作者
和楼主想的一样，碰巧找资料的时候看见了这贴子。很佩服，现在自己也开始做了，但是电工学得不好，主电路设计不出来，求问楼主，现在没有12V10A的电源，12V10A的电源主电路怎么设计，用什么继电器需要接多大的电阻，求救
回复

使用道具 举报

35#
ID:97678 发表于 2020-5-7 12:31 | 只看该作者
       #include
       #include
这两个包含什么？ 编译的时候很多错误！
回复

使用道具 举报

36#
ID:599670 发表于 2020-5-29 09:58 | 只看该作者
这个有点复杂咯，，
回复

使用道具 举报

37#
ID:336645 发表于 2020-9-16 13:48 | 只看该作者
不错，赞一个，先收藏了
回复

使用道具 举报

38#
ID:907956 发表于 2021-4-18 22:43 | 只看该作者
大概的温度范围是多少啊？
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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