写了几天的小制作：不起床就引爆“炸弹”的闹钟

wasdpkj

创意来自：http://www.shejipi.com/7965.html
项目名字：《不起床就引爆“炸弹”的闹钟》
你可以像普通闹钟一样，设置好闹钟时间。
但时间到后，30秒倒计时开始，你要在这个时间内选择切断三根线中的一条（随机），期间会有灯光闪烁，切错爆炸，切对则成功解除危险！              
   
还增加简单定时功能，增加了arduino端系统时间的设置，时间设置全靠红外遥控器。

演示视频：

如果无法播放，请点击此处在新窗口打开

面包板如下：用到了1307时钟模块，1602用来显示，红外遥控




程序很繁琐，自己都有点看不懂了（注释什么的更乱，可以无视），主要是倒计时当时设计的很笨，但可以用，后来就懒得改了



所用到库在文章最后面

1. #include <IRremote.h>
   
2. #include <LiquidCrystal.h>
   
3. #include <OneWire.h>
   
4. #include <Wire.h>
   
5. #include <DS1307.h>
   
6. #include <EEPROM.h>
   
7. 
   
8. #define EEPROM_write(address, p) {int i = 0; byte *pp = (byte*)&(p);for(; i < sizeof(p); i++) EEPROM.write(address+i, pp[i]);}
   
9. #define EEPROM_read(address, p)  {int i = 0; byte *pp = (byte*)&(p);for(; i < sizeof(p); i++) pp[i]=EEPROM.read(address+i);}
   
10. #define DAO 2
    
11. #define BONG 4
    
12. 
    
13. boolean  C2 = false, C3 = false;                //C2、C3
    
14. 
    
15. /*----EEPROM---*/
    
16. struct config_type
    
17. {
    
18.     int EEPROMshi;
    
19.     int EEPROMfen;
    
20.     int EEPROMmin;
    
21.     int EEPROMtem;
    
22. };
    
23. 
    
24. /*-------time------*/
    
25. String comdata = "";  //串口数据缓存
    
26. int numdata[7] = {0}, j = 0, mark = 0;
    
27. int rtc[7];
    
28. 
    
29. int timenian, timeyue, timeri, timeshi, timefen, timemiao, timezhou;        //时钟
    
30. 
    
31. int sheNIAN, sheYUE, sheRI, sheSHI, sheFEN, sheMIAO, sheZHOU;
    
32. int xuannum = 0;
    
33. 
    
34. boolean  she = false, xuan = false, sheDOWN = false, sheUP = false, sheSTA = false;
    
35. /*-------timing----*/
    
36. 
    
37. boolean BONGshiup = false, BONGshidown = true;                //定时按钮-时
    
38. boolean BONGfenup = false, BONGfendown = false;                //定时按钮-分
    
39. 
    
40. boolean DAOsetno =  false;                //定时-执行
    
41. boolean DAOsetup =  false, DAOsetdown = false;        //定时
    
42. 
    
43. boolean DAOtimesta = false;        //计时状态位
    
44. 
    
45. int DAOsettime, DAOnomtime;                //所需定时（分钟）
    
46. int DAOtimea, DAOtimeb;                //初始时间、时间差
    
47. 
    
48. int DAOjishu = 0;                                //总计时间
    
49. 
    
50. int DAOTIMEDT = 10;                        //定时
    
51. 
    
52. int BONGsetshi, BONGsetfen, BONGnomshi, BONGnomfen;        //闹钟
    
53. 
    
54. int TIMEEEP;                //设置检查EEPROM频率
    
55. 
    
56. int TIMELCDa = 1, TIMELCDb = 1, TIMELCDc = 1, TIMELCDd = 1;
    
57. 
    
58. int TIMEIR = 1;
    
59. /*-------LCD------*/
    
60. LiquidCrystal lcd(10 , 9, 8, 7, 6, 5);//设置接口
    
61. 
    
62. boolean lcda = false;
    
63. boolean lcdb = false;
    
64. boolean lcdbsta = false;
    
65. boolean lcdc = false;
    
66. boolean lcdcsta = false;
    
67. boolean lcdd = false;
    
68. 
    
69. /*-------ir------*/
    
70. int RECV_PIN = A0;                //红外输入
    
71. 
    
72. int i;
    
73. 
    
74. IRrecv irrecv(RECV_PIN);
    
75. decode_results results;
    
76. /*----BONGsta----*/
    
77. boolean BONGsta = false, STARTbong = false, OK = false, BAD = false, STAclear = false,TESTsta = false;
    
78. boolean a1, a2, a3;
    
79. int TIMEhaha = 30;
    
80. 
    
81. int SUIJI;
    
82. 
    
83. int STAa, STAb, NUMbong, Clear = 0;
    
84. 
    
85. int NUMdao = 9;
    
86. 
    
87. int DAOmiao,DAOmin;
    
88. 
    
89. 
    
90. void setup()
    
91. {
    
92.     Serial.begin(9600);
    
93. 
    
94.     config_type config_readback;
    
95.     EEPROM_read(0, config_readback);
    
96. 
    
97.     DAOsettime = config_readback.EEPROMmin;
    
98.     DAOnomtime = config_readback.EEPROMmin;
    
99.     BONGsetshi = config_readback.EEPROMshi;
    
100.     BONGsetfen = config_readback.EEPROMfen;
     
101.     BONGnomshi = config_readback.EEPROMshi;
     
102.     BONGnomfen = config_readback.EEPROMfen;
     
103. 
     
104.     pinMode(DAO, OUTPUT); //C2
     
105.     pinMode(BONG, OUTPUT); //C3
     
106. 
     
107.     pinMode(A1, INPUT); //C3
     
108.     pinMode(A2, INPUT); //C3
     
109.     pinMode(A3, INPUT); //C3
     
110. 
     
111.     lcd.begin(16, 2);                                 //初始化LCD
     
112.     lcd.setCursor(0, 0) ;
     
113.     lcd.print("BONG!Alarm Clock");       //显示文字
     
114.     lcd.setCursor(0, 1) ;
     
115.     lcd.print("-----By PKJ-----");       //显示文字
     
116.     delay(2000);                                                 //延时
     
117. 
     
118.     irrecv.enableIRIn();                                 //开始采集
     
119. }
     
120. 
     
121. 
     
122. void loop()
     
123. {
     
124.     SUIJI = random(1, 4);
     
125. 
     
126.     a1 = digitalRead(A1);
     
127.     a2 = digitalRead(A2);
     
128.     a3 = digitalRead(A3);
     
129. 
     
130.     digitalWrite(DAO, C2); //C2
     
131.     digitalWrite(BONG, C3); //C3
     
132. 
     
133.     xuan = false;
     
134.     sheDOWN = false;
     
135.     sheUP = false;
     
136. 
     
137.     DAOsetno =  false;
     
138.     DAOsetup =  false;
     
139.     DAOsetdown = false;
     
140. 
     
141.     BONGshiup =  false;
     
142.     BONGshidown = false;
     
143.     BONGfenup =  false;
     
144.     BONGfendown = false;
     
145. 
     
146.     /*==================Time======================*/
     
147.     RTC.get(rtc, true);
     
148. 
     
149.     timenian = rtc[6];
     
150.     timeyue = rtc[5];
     
151.     timeri = rtc[4];
     
152.     timezhou = rtc[3];
     
153.     timeshi = rtc[2];
     
154.     timefen = rtc[1];
     
155.     timemiao = rtc[0];
     
156. 
     
157. 
     
158.     /*=================红外控制=================*/
     
159.     if (irrecv.decode(&results))
     
160.     {
     
161.         voir();
     
162.     }
     
163. 
     
164.     /*==============End-红外控制=================*/
     
165. 
     
166. 
     
167.         /*===============设置时钟================*/
     
168.     /*--------------------时间范围-----------------*/       
     
169.     if(sheNIAN <= 2000)
     
170.     {
     
171.         sheNIAN = 2000;
     
172.     }
     
173. 
     
174.     if(sheYUE > 12)
     
175.     {
     
176.         sheYUE = 1;
     
177.     }
     
178.     if(sheYUE < 1)
     
179.     {
     
180.         sheYUE = 12;
     
181.     }
     
182. 
     
183.     if(sheRI > 31)
     
184.     {
     
185.         sheRI = 1;
     
186.     }
     
187.     if(sheRI < 1)
     
188.     {
     
189.         sheRI = 31;
     
190.     }
     
191. 
     
192.     if (sheSHI > 23)
     
193.     {
     
194.         sheSHI = 0;
     
195.     }
     
196.     if (sheSHI < 0)
     
197.     {
     
198.         sheSHI = 23;
     
199.     }
     
200. 
     
201.     if (sheFEN > 59)
     
202.     {
     
203.         sheFEN = 0;
     
204.     }
     
205.     if (sheFEN < 0)
     
206.     {
     
207.         sheFEN = 59;
     
208.     }
     
209. 
     
210.     if (sheZHOU > 7)
     
211.     {
     
212.         sheZHOU = 1;
     
213.     }
     
214.     if (sheZHOU < 1)
     
215.     {
     
216.         sheZHOU = 7;
     
217.     }
     
218.    
     
219.     /*----------------end-时间范围-----------------*/       
     
220.    
     
221.     if (she == true)
     
222.     {
     
223.         RTC.stop();
     
224.         sheSTA = true;
     
225. 
     
226.         if(xuan == true)
     
227.         {
     
228.             xuannum++;
     
229.         }
     
230. 
     
231.         if(xuannum >= 7)
     
232.         {
     
233.             xuannum = 1;
     
234.         }
     
235. 
     
236.         if(xuannum == 1)
     
237.         {
     
238.             if(sheUP == true)
     
239.             {
     
240.                 sheNIAN++;
     
241.             }
     
242.             if(sheDOWN == true)
     
243.             {
     
244.                 sheNIAN--;
     
245.             }
     
246.         }
     
247. 
     
248.         if(xuannum == 2)
     
249.         {
     
250.             if(sheUP == true)
     
251.             {
     
252.                 sheYUE++;
     
253.             }
     
254.             if(sheDOWN == true)
     
255.             {
     
256.                 sheYUE--;
     
257.             }
     
258.         }
     
259. 
     
260.         if(xuannum == 3)
     
261.         {
     
262.             if(sheUP == true)
     
263.             {
     
264.                 sheRI++;
     
265.             }
     
266.             if(sheDOWN == true)
     
267.             {
     
268.                 sheRI--;
     
269.             }
     
270.         }
     
271.         if(xuannum == 4)
     
272.         {
     
273.             if(sheUP == true)
     
274.             {
     
275.                 sheSHI++;
     
276.             }
     
277.             if(sheDOWN == true)
     
278.             {
     
279.                 sheSHI--;
     
280.             }
     
281.         }
     
282. 
     
283.         if(xuannum == 5)
     
284.         {
     
285.             if(sheUP == true)
     
286.             {
     
287.                 sheFEN++;
     
288.             }
     
289.             if(sheDOWN == true)
     
290.             {
     
291.                 sheFEN--;
     
292.             }
     
293.         }
     
294. 
     
295.         if(xuannum == 6)
     
296.         {
     
297.             if(sheUP == true)
     
298.             {
     
299.                 sheZHOU++;
     
300.             }
     
301.             if(sheDOWN == true)
     
302.             {
     
303.                 sheZHOU--;
     
304.             }
     
305.         }
     
306. 
     
307.     }
     
308. 
     
309.     else
     
310.     {
     
311.         if(sheSTA == true)
     
312.         {
     
313.             Serial.println("--OK--");
     
314. 
     
315.             RTC.set(DS1307_YR, sheNIAN);
     
316.             RTC.set(DS1307_MTH, sheYUE);
     
317.             RTC.set(DS1307_DATE, sheRI);
     
318.             RTC.set(DS1307_HR, sheSHI);
     
319.             RTC.set(DS1307_MIN, sheFEN);
     
320.             RTC.set(DS1307_SEC, sheMIAO);
     
321.             RTC.set(DS1307_DOW, sheZHOU);
     
322.             RTC.start();
     
323.             sheSTA = false;
     
324.         }
     
325.         xuannum = 0;
     
326.     }
     
327. 
     
328.         /*===============end-设置时钟============*/
     
329. 
     
330. 
     
331.     /*==================BONGsta======================*/
     
332.    
     
333.     if(STAclear == true)
     
334.     {
     
335.         if(timemiao != STAb)
     
336.         {
     
337.             Clear++;
     
338.         }
     
339.         if(Clear >= 10)
     
340.         {
     
341.             C2 = false;
     
342.             C3 = false;
     
343.             Clear = 0;
     
344.             STAclear = false;
     
345.         }
     
346.     }
     
347. 
     
348.     if(BONGsta == true && STARTbong == true)
     
349.     {
     
350.         if(TIMEhaha == 30)
     
351.         {
     
352.             NUMbong = SUIJI;
     
353.         }
     
354. 
     
355.         if(timemiao != STAa)
     
356.         {
     
357.             TIMEhaha--;
     
358.             C2 = !C2;
     
359.         }
     
360.     }
     
361. 
     
362.     if(TIMEhaha <= 0)
     
363.     {
     
364.         BAD = true;
     
365.     }
     
366. 
     
367.     if(BONGsta == true)
     
368.         switch(NUMbong)
     
369.         {
     
370.         case 1:
     
371.             Serial.print("                                 a1");
     
372.             Serial.println("");
     
373.             if(a1 == false && a2 == true && a3 == true)
     
374.             {
     
375.                 OK = true;
     
376.                 Serial.print("                                 OK");
     
377.                 Serial.println("");
     
378.             }
     
379.             else
     
380.             {
     
381.                 if(!(a1 == true && a2 == true && a3 == true))
     
382.                 {
     
383.                     BAD = true;
     
384.                     Serial.print("                                 BONG");
     
385.                     Serial.println("");
     
386.                 }
     
387.             }
     
388.             ;
     
389.             break;
     
390. 
     
391.         case 2:
     
392.             Serial.print("                                 a2");
     
393.             Serial.println("");
     
394.             if(a1 == true && a2 == false && a3 == true)
     
395.             {
     
396.                 OK = true;
     
397.                 Serial.print("                                 OK");
     
398.                 Serial.println("");
     
399.             }
     
400.             else
     
401.             {
     
402.                 if(!(a1 == true && a2 == true && a3 == true))
     
403.                 {
     
404.                     BAD = true;
     
405.                     Serial.print("                                 BONG");
     
406.                     Serial.println("");
     
407.                 }
     
408.             }
     
409.             ;
     
410.             break;
     
411. 
     
412.         case 3:
     
413.             Serial.print("                                 a3");
     
414.             Serial.println("");
     
415.             if(a1 == true && a2 == true && a3 == false)
     
416.             {
     
417.                 OK = true;
     
418.                 Serial.print("                                 OK");
     
419.                 Serial.println("");
     
420.             }
     
421.             else
     
422.             {
     
423.                 if(!(a1 == true && a2 == true && a3 == true))
     
424.                 {
     
425.                     BAD = true;
     
426.                     Serial.print("                                 BONG");
     
427.                     Serial.println("");
     
428.                 }
     
429.             }
     
430.             ;
     
431.             break;
     
432.         }
     
433. 
     
434.     STARTbong = false;
     
435. 
     
436.     if(a1 == true && a2 == true && a3 == true)
     
437.     {
     
438.         STARTbong = true;
     
439.     }
     
440. 
     
441.         /*=================执行================*/
     
442.     if(OK == true)
     
443.     {
     
444.         digitalWrite(BONG, 0); //C3
     
445.         delay(600);
     
446.         digitalWrite(BONG, 1); //C3
     
447.         delay(550);
     
448.         digitalWrite(BONG, 0); //C3
     
449.         delay(500);
     
450.         digitalWrite(BONG, 1); //C3
     
451.         delay(450);
     
452.         digitalWrite(BONG, 0); //C3
     
453.         delay(400);
     
454.         digitalWrite(BONG, 1); //C3
     
455.         delay(350);
     
456.         digitalWrite(BONG, 0); //C3
     
457.         delay(300);
     
458.         digitalWrite(BONG, 1); //C3
     
459.         delay(250);
     
460.         digitalWrite(BONG, 0); //C3
     
461.         delay(200);
     
462.         digitalWrite(BONG, 1); //C3
     
463.         delay(150);
     
464.         digitalWrite(BONG, 0); //C3
     
465.         delay(150);
     
466.         digitalWrite(BONG, 1); //C3
     
467.         delay(150);
     
468.         digitalWrite(BONG, 0); //C3
     
469.         delay(150);
     
470.         digitalWrite(BONG, 1); //C3
     
471.         delay(150);
     
472.         digitalWrite(BONG, 0); //C3
     
473.         delay(150);
     
474.         digitalWrite(BONG, 1); //C3
     
475.         delay(150);
     
476.         digitalWrite(BONG, 0); //C3
     
477.         delay(150);
     
478.         digitalWrite(BONG, 1); //C3
     
479.         delay(150);
     
480.         digitalWrite(BONG, 0); //C3
     
481. 
     
482.         TIMEhaha = 30;
     
483. 
     
484.         C3 = false;
     
485.         C2 = false;
     
486.         BONGsta = false;
     
487. 
     
488.         STAclear = true;
     
489. 
     
490.         OK = false;
     
491.         Serial.print("                                 [OK]");
     
492.         Serial.println("");
     
493.     }
     
494. 
     
495.     if(BAD == true)
     
496.     {
     
497.         digitalWrite(BONG, 0); //C3
     
498.         delay(600);
     
499.         digitalWrite(BONG, 1); //C3
     
500.         delay(550);
     
501.         digitalWrite(BONG, 0); //C3
     
502.         delay(500);
     
503.         digitalWrite(BONG, 1); //C3
     
504.         delay(450);
     
505.         digitalWrite(BONG, 0); //C3
     
506.         delay(400);
     
507.         digitalWrite(BONG, 1); //C3
     
508.         delay(350);
     
509.         digitalWrite(BONG, 0); //C3
     
510.         delay(300);
     
511.         digitalWrite(BONG, 1); //C3
     
512.         delay(250);
     
513.         digitalWrite(BONG, 0); //C3
     
514.         delay(200);
     
515.         digitalWrite(BONG, 1); //C3
     
516.         delay(150);
     
517.         digitalWrite(BONG, 0); //C3
     
518.         delay(150);
     
519.         digitalWrite(BONG, 1); //C3
     
520.         delay(150);
     
521.         digitalWrite(BONG, 0); //C3
     
522.         delay(150);
     
523.         digitalWrite(BONG, 1); //C3
     
524.         delay(150);
     
525.         digitalWrite(BONG, 0); //C3
     
526.         delay(150);
     
527.         digitalWrite(BONG, 1); //C3
     
528.         delay(150);
     
529.         digitalWrite(BONG, 0); //C3
     
530.         delay(150);
     
531.         digitalWrite(BONG, 1); //C3
     
532.         delay(150);
     
533.         digitalWrite(BONG, 0); //C3
     
534.         delay(150);
     
535.         digitalWrite(BONG, 1); //C3
     
536. 
     
537.         TIMEhaha = 30;
     
538. 
     
539.         BONGsta = false;
     
540.         C2 = false;
     
541.         C3 = true;
     
542. 
     
543.         STAclear = true;
     
544. 
     
545.         BAD = false;
     
546.         
     
547.         Serial.print("                                 [BAD]");
     
548.         Serial.println("");
     
549.     }
     
550. 
     
551.     delay(80);   
     
552. 
     
553.     /*===============end-BONGsta================*/
     
554. 
     
555. 
     
556.     /*================定时===================*/
     
557. 
     
558.     if (BONGshiup == true)     //控制数值上升
     
559.     {
     
560.         BONGsetshi++;
     
561.     }
     
562.     if (BONGshidown == true)           //控制数值下降
     
563.     {
     
564.         BONGsetshi--;
     
565.     }
     
566. 
     
567.     if (BONGfenup == true)     //控制数值上升
     
568.     {
     
569.         BONGsetfen++;
     
570.     }
     
571.     if (BONGfendown == true)           //控制数值下降
     
572.     {
     
573.         BONGsetfen--;
     
574.     }
     
575. 
     
576.     if (BONGsetshi > 23)
     
577.     {
     
578.         BONGsetshi = 0;
     
579.     }
     
580.     if (BONGsetshi < 0)
     
581.     {
     
582.         BONGsetshi = 23;
     
583.     }
     
584.     if (BONGsetfen > 59)
     
585.     {
     
586.         BONGsetfen = 0;
     
587.     }
     
588.     if (BONGsetfen < 0)
     
589.     {
     
590.         BONGsetfen = 59;
     
591.     }
     
592. 
     
593.     if(timeshi == BONGsetshi && timefen == (BONGsetfen-1) && timemiao == 30)
     
594.     {
     
595.         BONGsta = true;
     
596.         delay(1000);
     
597.     }
     
598.    
     
599.     if(TESTsta == true)
     
600.     {
     
601.         BONGsta = true;
     
602.         delay(1000);
     
603.         TESTsta = false;
     
604.     }
     
605.    
     
606.     /*================end-定时===================*/
     
607. 
     
608.    
     
609.     /*================倒计时===================*/
     
610. 
     
611.     if (DAOsetup == true && DAOtimesta == false)     //控制数值上升
     
612.     {
     
613.         DAOsettime++;
     
614.     }
     
615.     if (DAOsetdown == true && DAOtimesta == false)           //控制数值下降
     
616.     {
     
617.         DAOsettime--;
     
618.     }
     
619. 
     
620.     if (DAOsettime > 30)
     
621.     {
     
622.         DAOsettime = 1;
     
623.     }
     
624.     if (DAOsettime < 1)
     
625.     {
     
626.         DAOsettime = 30;
     
627.     }
     
628. 
     
629. 
     
630.     if (DAOsetno == true && (DAOtimesta == false && C2 == false) && STAclear == false && BONGsta == false)          //C2为零时可触发计时
     
631.     {
     
632.         delay(20);
     
633.         C2 = true;                                //开始烧水
     
634.         DAOtimea = timemiao;                //计时起始位
     
635.         DAOtimeb = 0;                        //十秒清零
     
636.         DAOjishu = 0;                        //计数清零
     
637.         DAOtimesta = true;                  //开始计时
     
638.     }
     
639. 
     
640.     else if (DAOsetno == true && (DAOtimesta == true || C2 == true))          //C2为1时或计时开始后，再次触发则停止计时、
     
641.     {
     
642.         delay(20);
     
643.         C2 = false;
     
644.         DAOtimesta = false;                  //停止计时
     
645.     }
     
646. 
     
647.     if(DAOtimesta == true)
     
648.     {
     
649.         if(DAOtimea >= 49)                  //以十秒为基数统计
     
650.         {
     
651.             if(timemiao <= 59 && timemiao >= 49)
     
652.             {
     
653.                 DAOtimeb = timemiao - DAOtimea;
     
654.             }
     
655.             if(timemiao >= 0 && timemiao <= 9)
     
656.             {
     
657.                 DAOtimeb = 60 + timemiao - DAOtimea;
     
658.             }
     
659.         }
     
660. 
     
661.         else
     
662.         {
     
663.             DAOtimeb = timemiao - DAOtimea;        //49秒以下正常计数
     
664.         }
     
665. 
     
666.     }
     
667. 
     
668.     if(DAOtimeb >= 10)                          //十秒计时完毕后
     
669.     {
     
670.         DAOjishu++;                //以计时值得到总时间
     
671.         DAOtimeb = 0;                                //归零
     
672.         DAOtimea = timemiao;                //开始新一轮计时
     
673.     }
     
674. 
     
675.     if(DAOsettime <= DAOjishu/6)          //大于设置值
     
676.     {
     
677.         DAOtimesta = false;                      //停止计时
     
678.         C2 = false;                                //停止
     
679.     }
     
680. 
     
681.     if(DAOtimesta == false)          //必要的清零
     
682.     {
     
683.         DAOtimeb = 0;
     
684.         DAOjishu = 0;
     
685.     }
     
686.    
     
687.     DAOmin=((DAOsettime * 6 - DAOjishu)-1) / 6;
     
688. 
     
689.     DAOmiao=((DAOsettime * 6 - DAOjishu)-1) % 6;
     
690.    
     
691.     if(DAOtimesta == true)
     
692.     {
     
693.         if(timemiao != STAa)
     
694.         {
     
695.             C2 = !C2;
     
696.             NUMdao--;
     
697.         }
     
698.         if(NUMdao<0)
     
699.         {
     
700.         NUMdao=9;
     
701.         }
     
702.     }
     
703.     else
     
704.     {
     
705.     NUMdao=9;
     
706.     }
     
707. 
     
708.     /*=============End-倒计时===================*/
     
709. 
     
710.    
     
711.    
     
712.     /*==================EEPROM==================*/
     
713.     if (TIMEEEP <= 10)                          //设置EEPROM检查刷新频率
     
714.     {
     
715.         TIMEEEP++;
     
716.     }
     
717. 
     
718.     else
     
719.     {
     
720.         if((BONGnomshi != BONGsetshi) || (BONGnomfen != BONGsetfen) || (DAOsettime != DAOnomtime))
     
721.         {
     
722.             eeprom_test();
     
723.             BONGnomshi = BONGsetshi;
     
724.             BONGnomfen = BONGsetfen;
     
725.             DAOnomtime = DAOsettime;
     
726.         }
     
727.     }
     
728. 
     
729.     /*================endEEPROM================*/
     
730. 
     
731. 
     
732.     /*==================显示===================*/
     
733. 
     
734.     {
     
735.         if(DAOsetup == true || DAOsetdown == true)                  //触发
     
736.         {
     
737.             TIMELCDa = 1;
     
738.             lcda = true;
     
739.         }
     
740. 
     
741.         if(lcda == true)
     
742.         {
     
743.             volcda();
     
744.         }
     
745.         /*--------------------------------------------------------*/
     
746. 
     
747. 
     
748.         /*--------------------------------------------------------*/
     
749. 
     
750.         if(BONGshiup == true || BONGshidown == true || BONGfendown == true || BONGfenup == true)                  //触发
     
751.         {
     
752.             TIMELCDd = 1;
     
753.             lcdd = true;
     
754.         }
     
755. 
     
756.         if(lcdd == true)
     
757.         {
     
758.             volcdd();
     
759.         }
     
760. 
     
761.         /*--------------------------------------------------------*/
     
762. 
     
763.         voLCD();
     
764. 
     
765.     }
     
766. 
     
767.     STAb = timemiao;
     
768.     STAa = timemiao;
     
769.     /*===============End-显示===================*/
     
770. 
     
771.     Serial.print("                    TIMEhaha:");
     
772.     Serial.print(TIMEhaha);
     
773.     Serial.println("");
     
774. 
     
775.     Serial.print("                    BONGsta:");
     
776.     Serial.print(BONGsta);
     
777.     Serial.println("");
     
778. 
     
779.     Serial.print("                                              Clear: ");
     
780.     Serial.print(Clear);
     
781.     Serial.println("");
     
782. 
     
783.     Serial.print("                                 NUMbong: ");
     
784.     Serial.print(NUMbong);
     
785.     Serial.println("");
     
786. 
     
787.     Serial.print("                                 STARTbong: ");
     
788.     Serial.print(STARTbong);
     
789.     Serial.println("");
     
790.    
     
791.     Serial.print("                                 OK: ");
     
792.     Serial.print(OK);
     
793.     Serial.println("");
     
794.    
     
795.     Serial.print("                                 BAD: ");
     
796.     Serial.print(BAD);
     
797.     Serial.println("");
     
798. 
     
799.    
     
800. 
     
801. }
     
802. 
     
803. 
     
804. void volcda()
     
805. {
     
806.     if (TIMELCDa <= 12 && lcda == true)                          //设置刷新频率
     
807.     {
     
808.         TIMELCDa++;
     
809.     }
     
810. 
     
811.     else
     
812.     {
     
813.         lcda = false;
     
814.         TIMELCDa = 1;
     
815.     }
     
816. }
     
817. 
     
818. 
     
819. void volcdd()
     
820. {
     
821.     if (TIMELCDd <= 20 && lcdd == true)                          //设置刷新频率
     
822.     {
     
823.         TIMELCDd++;
     
824.     }
     
825. 
     
826.     else
     
827.     {
     
828.         lcdd = false;
     
829.         TIMELCDd = 1;
     
830.     }
     
831. }
     
832. 
     
833. 
     
834. void voLCD()
     
835. {
     
836.     lcd.clear();                                                //清屏
     
837. 
     
838.     /*-----------------------显示时间---------------------*/
     
839.     lcd.setCursor(0, 0) ;
     
840.     lcd.print(timenian);
     
841.     lcd.print("-");
     
842.     if(timeyue <= 9)
     
843.     {
     
844.         lcd.print("0");
     
845.         lcd.print(timeyue);
     
846.     }
     
847.     else
     
848.     {
     
849.         lcd.print(timeyue);
     
850.     }
     
851.     lcd.print("-");
     
852.     if(timeri <= 9)
     
853.     {
     
854.         lcd.print("0");
     
855.         lcd.print(timeri);
     
856.     }
     
857.     else
     
858.     {
     
859.         lcd.print(timeri);
     
860.     }
     
861.     lcd.print(" ");
     
862. 
     
863.     lcd.setCursor(11, 0) ;
     
864.     if(timeshi <= 9)
     
865.     {
     
866.         lcd.print("0");
     
867.         lcd.print(timeshi);
     
868.     }
     
869.     else
     
870.     {
     
871.         lcd.print(timeshi);
     
872.     }
     
873.     lcd.setCursor(13, 0) ;
     
874.     if(timemiao % 2 == 0)
     
875.     {
     
876.         lcd.print(":");
     
877.     }
     
878.     else
     
879.     {
     
880.         lcd.print(" ");
     
881.     }
     
882.     lcd.setCursor(14, 0) ;
     
883.     if(timefen <= 9)
     
884.     {
     
885.         lcd.print("0");
     
886.         lcd.print(timefen);
     
887.     }
     
888.     else
     
889.     {
     
890.         lcd.print(timefen);
     
891.     }
     
892. 
     
893. 
     
894.     /*---------------sheTIME----------------*/
     
895.     if(she == false)
     
896.     {
     
897.         lcd.setCursor(0, 1) ;
     
898.         lcd.print("Set Time : ");
     
899.     }
     
900.     else
     
901.     {
     
902.         switch(xuannum)
     
903.         {
     
904.         case 0:
     
905.             lcd.setCursor(0, 1) ;
     
906.             lcd.print("Switch[0]");
     
907.             break;
     
908.         case 1:
     
909.             lcd.setCursor(0, 1) ;
     
910.             lcd.print("YEAR:");
     
911.             lcd.print(sheNIAN);
     
912.             break;
     
913.         case 2:
     
914.             lcd.setCursor(0, 1) ;
     
915.             lcd.print("MON.:");
     
916.             lcd.print(sheYUE);
     
917.             break;
     
918.         case 3:
     
919.             lcd.setCursor(0, 1) ;
     
920.             lcd.print("DATA:");
     
921.             lcd.print(sheRI);
     
922.             break;
     
923.         case 4:
     
924.             lcd.setCursor(0, 1) ;
     
925.             lcd.print("HOUR:");
     
926.             lcd.print(sheSHI);
     
927.             break;
     
928.         case 5:
     
929.             lcd.setCursor(0, 1) ;
     
930.             lcd.print("MIN.:");
     
931.             lcd.print(sheFEN);
     
932.             break;
     
933.         case 6:
     
934.             lcd.setCursor(0, 1) ;
     
935.             lcd.print("WEEK:");
     
936.             lcd.print(sheZHOU);
     
937.             break;
     
938.         }
     
939.     }
     
940.     /*--------------------------------------------------------*/
     
941.     lcd.setCursor(11, 1) ;
     
942.     if(BONGsetshi <= 9)
     
943.     {
     
944.         lcd.print("0");
     
945.         lcd.print(BONGsetshi);
     
946.     }
     
947.     else
     
948.     {
     
949.         lcd.print(BONGsetshi);
     
950.     }
     
951.     lcd.setCursor(13, 1) ;
     
952.     lcd.print(":");
     
953.     lcd.setCursor(14, 1) ;
     
954.     if(BONGsetfen <= 9)
     
955.     {
     
956.         lcd.print("0");
     
957.         lcd.print(BONGsetfen);
     
958.     }
     
959.     else
     
960.     {
     
961.         lcd.print(BONGsetfen);
     
962.     }
     
963. 
     
964.     /*-------------------------STABONG--------------------------------*/
     
965. 
     
966.     if(STAclear == true)
     
967.     {
     
968.         lcd.setCursor(0, 1) ;
     
969.         if(timemiao % 2 == 0)
     
970.         {
     
971.             if(C3 == true)
     
972.             {
     
973.                 lcd.print("!!!!!!BONG!!!!!!");
     
974.             }
     
975.             else
     
976.             {
     
977.                 lcd.print("^_^^_^Clean^_^^_^");
     
978.             }
     
979.         }
     
980.         else
     
981.         {
     
982.             lcd.print("                ");
     
983.         }
     
984. 
     
985.     }
     
986. 
     
987.     /*------------------------设置二路时间----------------------------*/
     
988.     if (lcda == true)
     
989.     {
     
990.         lcd.setCursor(10, 1) ;
     
991.         lcd.print("[");
     
992.         if(DAOsettime <= 9)
     
993.         {
     
994.             lcd.print("0");
     
995.             lcd.setCursor(11, 1) ;
     
996.         }
     
997.         else
     
998.         {
     
999.             lcd.setCursor(10, 1) ;
     
1000.         }
      
1001.         lcd.print(DAOsettime);
      
1002.         lcd.setCursor(12, 1) ;
      
1003.         lcd.print("min] ");
      
1004.     }
      
1005. 
      
1006.     /*----------------------显示设置3路时间--------------------------*/
      
1007. 
      
1008.     if (lcdd == true)
      
1009.     {
      
1010.         lcd.setCursor(10, 1) ;
      
1011.         lcd.print("=");
      
1012.         lcd.setCursor(11, 1) ;
      
1013.         if(BONGsetshi <= 9)
      
1014.         {
      
1015.             lcd.print("0");
      
1016.             lcd.print(BONGsetshi);
      
1017.         }
      
1018.         else
      
1019.         {
      
1020.             lcd.print(BONGsetshi);
      
1021.         }
      
1022.         lcd.setCursor(13, 1) ;
      
1023.         lcd.print(":");
      
1024.         lcd.setCursor(14, 1) ;
      
1025.         if(BONGsetfen <= 9)
      
1026.         {
      
1027.             lcd.print("0");
      
1028.             lcd.print(BONGsetfen);
      
1029.         }
      
1030.         else
      
1031.         {
      
1032.             lcd.print(BONGsetfen);
      
1033.         }
      
1034.     }
      
1035. 
      
1036.     /*------------------------二路倒计时---------------------------*/
      
1037.     if(DAOtimesta == true)
      
1038.     {
      
1039.         lcd.setCursor(0, 1) ;
      
1040.         lcd.print("Remaining: ");
      
1041.         if(DAOmin <= 9)
      
1042.         {
      
1043.             lcd.print("0");
      
1044.             lcd.setCursor(12, 1) ;
      
1045.         }
      
1046.         else
      
1047.         {
      
1048.             lcd.setCursor(11, 1) ;
      
1049.         }
      
1050.         lcd.print(DAOmin);
      
1051.         lcd.setCursor(13, 1) ;
      
1052.         lcd.print(":");
      
1053. 
      
1054.             lcd.setCursor(14, 1) ;
      
1055.                         lcd.print(DAOmiao);
      
1056.                         lcd.print(NUMdao);
      
1057.     }
      
1058. 
      
1059.     if(BONGsta == true)
      
1060.     {
      
1061.         if(STARTbong == false && BAD == false && OK == false)
      
1062.         {
      
1063.             lcd.setCursor(0, 1) ;
      
1064.             lcd.print("     NO-READY   ");
      
1065.             delay(1200);
      
1066.             BONGsta = false;
      
1067.         }
      
1068.         lcd.setCursor(0, 1) ;
      
1069.         lcd.print("Left:[");
      
1070.         if(TIMEhaha <= 9)
      
1071.         {
      
1072.             lcd.print("0");
      
1073.             lcd.print(TIMEhaha);
      
1074.         }
      
1075.         else
      
1076.         {
      
1077.             lcd.print(TIMEhaha);
      
1078.         }
      
1079.         lcd.print("s] ");
      
1080.     }
      
1081. }
      
1082. 
      
1083. 
      
1084. void voir()
      
1085. {
      
1086.     unsigned long remote = results.value;                //设红外信号为remote
      
1087. 
      
1088.     if(remote == (-1))          //溢出时
      
1089.     {
      
1090.         Serial.print("irCode: ");
      
1091.         Serial.print(results.value, HEX);   //输出红外线解码结果（十六进制）
      
1092.         Serial.print(",  bits: ");
      
1093.         Serial.println(results.bits);
      
1094.     }
      
1095.     switch (remote)
      
1096.     {
      
1097.     case 0xFF629D:                //CH   -开始定时
      
1098.         DAOsetno = true;
      
1099.         delay(10);
      
1100.         break;
      
1101. 
      
1102.     case 0xFFE21D:                //CH+   -定时设置
      
1103.         DAOsetup = true;
      
1104.         delay(10);
      
1105.         break;
      
1106. 
      
1107.     case 0xFFA25D:                //CH-   -定时设置
      
1108.         DAOsetdown = true;
      
1109.         delay(10);
      
1110.         break;
      
1111. 
      
1112.     case 0xFF02FD:                //NEXT  -闹钟设置
      
1113.         BONGfenup = true;
      
1114.         delay(10);
      
1115.         break;
      
1116. 
      
1117.     case 0xFF22DD:                //PREV  -闹钟设置
      
1118.         BONGfendown = true;
      
1119.         delay(10);
      
1120.         break;
      
1121. 
      
1122.     case 0xFFA857:                //+  -闹钟设置
      
1123.         BONGshiup = true;
      
1124.         delay(10);
      
1125.         break;
      
1126. 
      
1127.     case 0xFFE01F:                //-   -闹钟设置
      
1128.         BONGshidown = true;
      
1129.         delay(10);
      
1130.         break;
      
1131. 
      
1132.     case 0xFF906F:                //EQ   -更改系统时钟
      
1133.         she = !she;
      
1134.         if(sheSTA == false)
      
1135.         {
      
1136.             sheNIAN = timenian;
      
1137.             sheYUE = timeyue;
      
1138.             sheRI = timeri;
      
1139.             sheSHI = timeshi;
      
1140.             sheFEN = timefen;
      
1141.             sheMIAO = timemiao;
      
1142.             sheZHOU = timezhou;
      
1143.         }
      
1144.         delay(10);
      
1145.         break;
      
1146. 
      
1147.     case 0xFF6897:                //0   -切换时钟设置菜单
      
1148.         xuan = true;
      
1149.         delay(10);
      
1150.         break;
      
1151.     case 0xFF9867:                //100+   -调整系统时钟
      
1152.         sheDOWN = true;
      
1153.         delay(10);
      
1154.         break;
      
1155.     case 0xFFB04F:                //200+   -调整系统时钟
      
1156.         sheUP = true;
      
1157.         delay(10);
      
1158.         break;
      
1159. 
      
1160.     case 0xFFC23D:                //PLAY   -用以测试倒计时
      
1161.         TESTsta = true;
      
1162.         delay(10);
      
1163.         break;
      
1164. 
      
1165.     }
      
1166.     /*--------------------------------*/
      
1167. 
      
1168.     irrecv.resume();                 // 返回值
      
1169. }
      
1170. 
      
1171. 
      
1172. void eeprom_test()
      
1173. {
      
1174.     config_type config;                  // 定义结构变量config，并定义config的内容
      
1175.     config.EEPROMshi = BONGsetshi;
      
1176.     config.EEPROMfen = BONGsetfen;
      
1177.     config.EEPROMmin = DAOsettime;
      
1178. 
      
1179.     EEPROM_write(0, config);         // 变量config存储到EEPROM，地址0写入
      
1180. }

复制代码

arduino-ice

库收了。。哈哈

Randy

这个创意很好！！！

ttyp

每天起床心惊胆战啊

zcbzjx

恩，不太利于身体健康，人说，醒了就直接起床的容易短命。。。要在床上赖会儿才起来比较好！

wasdpkj

zcbzjx 发表于 2013-1-18 19:57
恩，不太利于身体健康，人说，醒了就直接起床的容易短命。。。要在床上赖会儿才起来比较好！

如果不想开启炸弹模式，几根线不接上也就不会启动了

zcbzjx

wasdpkj 发表于 2013-1-18 20:34
如果不想开启炸弹模式，几根线不接上也就不会启动了

玩笑玩笑。。。挺好的应用。。。最好赶飞机，赶火车的时候启动炸弹模式。。免得耽误事

wasdpkj

zcbzjx 发表于 2013-1-18 20:51
玩笑玩笑。。。挺好的应用。。。最好赶飞机，赶火车的时候启动炸弹模式。。免得耽误事

可惜目前没有真炸弹，只能拿个蜂鸣器唬唬人

迷你强

这个做闹钟有点那个啥。。。应该用来做安全锁。。。两层门的那种。。第一层门打开开始倒计时。。开关拨错了。一盆水就扣下来。。。。

天天煎蛋

迷你强 发表于 2013-1-20 09:53
这个做闹钟有点那个啥。。。应该用来做安全锁。。。两层门的那种。。第一层门打开开始倒计时。。开关拨错 ...

错了，就放高压电~~

wasdpkj

迷你强 发表于 2013-1-20 09:53
这个做闹钟有点那个啥。。。应该用来做安全锁。。。两层门的那种。。第一层门打开开始倒计时。。开关拨错 ...

你更能整

jock

放烟怎么样