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

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

2016-7-5 02:46 上传

点击文件名下载附件

冰冰可乐什么的真的太适合不过了。。器材：一个电源模块，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[]={"    以开启"};
    
32. 
    
33. uchar code table0_0[]={"电气与"};
    
34. uchar code table0_1[]={"    信息工程学院"};
    
35. uchar code table0_2[]={"--电气1302唐小旺"};
    
36. uchar code table0_3[]={"  湖南工学院  "};
    
37. 
    
38. uchar code table11[]={"2015年00月00日"};
    
39. uchar code table12[]={"        "};
    
40. uchar code table13[]={"  00: 00: 00"};
    
41. uchar code table14[]={"当前温度："};
    
42. 
    
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[]={"--在按选择键返回"};
    
51. 
    
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[]={""};
    
60. 
    
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[]={""};
    
75. 
    
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[]={"定时炸弹即将爆炸"};
    
83. 
    
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[]={"        师院"};
    
92. 
    
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[]={"  游戏捏?"};
     
110. 
     
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[]={"  ~~谢谢合作~~"};
     
119. 
     
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. }
     
126. 
     
127. void di()
     
128. {
     
129.    feng=0;
     
130.    delay(100);
     
131.    feng=1;
     
132. }
     
133. 
     
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. }                          
     
145. 
     
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. }
     
157. 
     
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. }
     
168. 
     
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. }
     
179. 
     
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);
     
188. 
     
189.    }
     
190.    return(dat);
     
191. }
     
192. 
     
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. }
     
221. 
     
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. }
     
246. 
     
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. }
     
261. 
     
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. }
     
279. 
     
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. }         */
     
293. 
     
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. }
     
306. 
     
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. }
     
316. 
     
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. }
     
326. 
     
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);
     
343. 
     
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. }
     
381. 
     
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. }
     
391. 
     
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. }                                          
     
407. 
     
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. }
     
418. 
     
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. }
     
429. 
     
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);
     
514. 
     
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. }
     
537. 
     
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. }
     
836. 
     
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.                             }
     
930. 
     
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. }
      
1147. 
      
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. }
      
1508. 
      
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.         }
      
1669. 
      
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.          }
      
1702. 
      
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.           }
      
1778. 
      
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.                             }
      
1803. 
      
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.                                    }
      
1889. 
      
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.         }
      
2429. 
      
2430. 
      
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.          }
      
2463. 
      
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.           }
      
2538. 
      
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.                             }
      
2563. 
      
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.                                    }
      
2649. 
      
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. }
      
2767. 
      
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. }
      
3028. 
      
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. }
      
3039. 
      
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.         }
      
3170. 
      
3171. }
      
3172. 
      
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. }
      
3185. 
      
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. }
      
3204. 
      
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. }
      
3266. 
      
3267. void shijian_() interrupt 2
      
3268. {
      
3269.     uchar c;
      
3270.         flag_ri=1;
      
3271.         c=read_ds(0x0c);
      
3272. }                 

复制代码

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

这个好我正准备DIY个冰箱，怎样可以联系到楼主麻烦指导下

JP1 JP?这两个是啥？？？K2是18B20???接线错了吧？？？

谢谢分享！楼主威武！  下载不了  可惜了

楼主是大神啊，学习了

本来想在宿舍买个小冰箱，可是太贵了，上网看到楼主这篇文章，我觉得我也可以尝试一下DIY

打开电路原理图提示要密码？？

楼主，666.  这个冰箱能不能冰住食物

谢谢，正需要呢。

看上去不错

JP1 JP?是什么

楼楼，能给个元器件清单么

厉害厉害，制冷器有某宝链接吗

冰箱温度范围是多少？

楼主能发一下元器件清单吗

可以学习了

good job

谢谢分享

半导体制冷片能2度，这冰箱很好很实用了，就是不知道正常使用的寿命能有多久！

谢谢分享，最近在实训就是弄这个课题的

您好！我想请问继电器接电源火线，那继电器是220v的吗

谢谢楼主分享！

你好，我想问DS12c887的DB接哪里

大神，大力

感谢大神，可以给个联系方式教我下吗

请问用51可以做吗？

楼楼，能给个元器件清单么

这个费电不？制冷功率是多少？

楼主，可以做客视频什么的么，或者发一下配件清单，我小白，谢谢

超出了2K，还有就是为什么没有模块化编程呢？  

很厉害

继电器怎么选啊楼主

和楼主想的一样，碰巧找资料的时候看见了这贴子。很佩服，现在自己也开始做了，但是电工学得不好，主电路设计不出来，求问楼主，现在没有12V10A的电源，12V10A的电源主电路怎么设计，用什么继电器需要接多大的电阻，求救

       #include
       #include
这两个包含什么？ 编译的时候很多错误！

这个有点复杂咯，，

不错，赞一个，先收藏了

大概的温度范围是多少啊？