【菜鸟的Arduino学习之路】个人superclock时钟V0.1版

但丁

    学习Arduino有一个月左右了吧，今天尝试做了个小时钟，效果还不是很好，但是鉴于马上要出国读书了，还是想写一篇帖子，也算是交个作业以及表达一下对极客工坊这么好的学习之地表示感谢吧！
    关于时钟性能的改进等日后有空了再进一步更新~~~话说自己大爱做时钟

    元件清单：1.热敏电阻或LM35温度传感器（自己用的是热敏电阻，便宜点哇）
              2.DS1302时钟模块
              3.红外遥控器及红外一体接收头
              4.1602液晶屏   

         

    好了，废话不多说，上图，上视频~~

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

      接下来是代码，写得有点乱，喜欢的朋友可以尝试一下：

1. #include <LiquidCrystal.h>
   
2. #include <IRremote.h>
   
3. #include <stdio.h>                  //DS1302
   
4. #include <string.h>
   
5. #include <DS1302.h>
   
6. uint8_t CE_PIN   = 12;
   
7. uint8_t IO_PIN   = 11;
   
8. uint8_t SCLK_PIN = 10;
   
9. DS1302 rtc(CE_PIN,IO_PIN,SCLK_PIN);
   
10. char yearmonthday[20];
    
11. char hourminutesecond[10];
    
12. char day[10];
    
13. 
    
14. int irReceivePin=2;                       //IRremote
    
15. IRrecv irrecv(irReceivePin);
    
16. decode_results results;
    
17. 
    
18. 
    
19. #define beta 4090                       //remindianzu
    
20. LiquidCrystal lcd(3,4,5,6,7,8,9);      //displayModel2
    
21. byte one[8]={
    
22.   B11111,B11111,B00000,B11111,B11111,B00000,B11111,B11111};                                          
    
23. byte two[8]={
    
24.   B11111,B11111,B00000,B00000,B00000,B00000,B00000,B00000};
    
25. byte three[8]={
    
26.   B00000,B00000,B00000,B00000,B00000,B00000,B11111,B11111};
    
27. byte four[8]={
    
28.   B11111,B11111,B00000,B00000,B00000,B00000,B11111,B11111};
    
29. byte five[8]={
    
30.   B11111,B11111,B00000,B00000,B00000,B00000,B00000,B11111};
    
31. byte six[8]={
    
32.   B11111,B00000,B00000,B00000,B00000,B00000,B11111,B11111};
    
33. byte seven[8]={
    
34.   B00000,B00000,B00000,B11111,B11111,B00000,B00000,B00000};
    
35. byte zero[8]={
    
36.   B00000,B00000,B00000,B00000,B00000,B00000,B00000,B00000};
    
37. 
    
38. 
    
39. void setup()
    
40. {
    
41.   lcd.begin(16,2);
    
42.   lcd.display();
    
43.   lcd.createChar(1,one);             //displayModel2
    
44.   lcd.createChar(2,two);
    
45.   lcd.createChar(3,three);
    
46.   lcd.createChar(4,four);
    
47.   lcd.createChar(5,five);
    
48.   lcd.createChar(6,six);
    
49.   lcd.createChar(7,seven);  
    
50.   lcd.createChar(8,zero);
    
51.   irrecv.enableIRIn();              //IRremote
    
52.   Serial.begin(9600);
    
53. }
    
54. 
    
55. void loop()
    
56. {
    
57.   int Model;
    
58.   if(irrecv.decode(&results))
    
59.   {      
    
60.     Serial.println(results.value);
    
61.     long remote=results.value;
    
62.     if(remote==16580863)
    
63.     {
    
64.       Model=1;
    
65.       lcd.clear();     
    
66.     }
    
67.     else if(remote==16597183)
    
68.     {
    
69.       Model=2;
    
70.       lcd.clear();   
    
71.     }   
    
72.     irrecv.resume();
    
73.   }
    
74.   else
    
75.   {
    
76.     displayModel1();
    
77.   }
    
78. 
    
79.   while(Model==1)
    
80.   {
    
81.     displayModel1();
    
82.     if(irrecv.decode(&results))
    
83.     {
    
84.       Serial.println(results.value);
    
85.       long remote=results.value;
    
86.       if(remote==16580863)
    
87.       {
    
88.         Model=1;
    
89.         lcd.clear();     
    
90.       }
    
91.       else if(remote==16597183)
    
92.       {
    
93.         Model=2;
    
94.         lcd.clear();   
    
95.       }
    
96.       irrecv.resume();
    
97.     }
    
98.   }
    
99.   while(Model==2)
    
100.   {
     
101.     displayModel2();
     
102.     if(irrecv.decode(&results))
     
103.     {
     
104.       Serial.println(results.value);
     
105.       long remote=results.value;
     
106.       if(remote==16580863)
     
107.       {
     
108.         Model=1;
     
109.         lcd.clear();     
     
110.       }
     
111.       else if(remote==16597183)
     
112.       {
     
113.         Model=2;
     
114.         lcd.clear();   
     
115.       }
     
116.       irrecv.resume();
     
117.     }
     
118.   }
     
119. }
     
120. 
     
121. void displayModel1()
     
122. {
     
123.   timeandtempDisplay();
     
124. }
     
125. 
     
126. void timeandtempDisplay()
     
127. {
     
128.   Time t=rtc.time();
     
129.   memset(day,0, sizeof(day));
     
130.   switch (t.day)
     
131.   {
     
132.   case 1:
     
133.     strcpy(day, "Sun");
     
134.     break;
     
135.   case 2:
     
136.     strcpy(day, "Mon");
     
137.     break;
     
138.   case 3:
     
139.     strcpy(day, "Tue");
     
140.     break;
     
141.   case 4:
     
142.     strcpy(day, "Wed");
     
143.     break;
     
144.   case 5:
     
145.     strcpy(day, "Thr");
     
146.     break;
     
147.   case 6:
     
148.     strcpy(day, "Fri");
     
149.     break;
     
150.   case 7:
     
151.     strcpy(day, "Sat");
     
152.     break;
     
153.   }
     
154.   snprintf(yearmonthday, sizeof(yearmonthday), "%04d/%02d/%02d",t.yr,t.mon,t.date);
     
155.   snprintf(hourminutesecond,sizeof(hourminutesecond),"%02d:%02d:%02d",t.hr, t.min, t.sec);
     
156.   lcd.setCursor(0,0);
     
157.   lcd.print(yearmonthday);
     
158.   lcd.setCursor(13,0);
     
159.   lcd.print(day);  
     
160.   lcd.setCursor(0,1);
     
161.   tempDisplay();   
     
162.   lcd.setCursor(8,1);
     
163.   lcd.print(hourminutesecond);
     
164. }
     
165. 
     
166. void tempDisplay()
     
167. {  
     
168.   int t=analogRead(A0);
     
169.   float temp=beta/(log((1023.0/t)-1.0)+(beta/298.0))-273.0;
     
170.   int temperature=temp;
     
171.   lcd.print(temperature);
     
172.   lcd.write(0xDF);
     
173.   lcd.print("C");  
     
174. }
     
175. 
     
176. 
     
177. void displayModel2()
     
178. {  
     
179.   minuteDisplay();  
     
180.   hourDisplay();   
     
181. }
     
182. 
     
183. void hourDisplay()
     
184. {
     
185.   Time t=rtc.time();
     
186.   int hour=t.hr;  
     
187.   if(hour<12&hour>0)
     
188.   {   
     
189.     int houra=hour/10;
     
190.     int hourb=hour%10;
     
191.     if(hour>0&hour<10)
     
192.     {
     
193.       numberDisplay(10,-1,0);
     
194.       numberDisplay(hour,3,0);      
     
195.     }
     
196.     else
     
197.     {
     
198.       numberDisplay(houra,-1,0);
     
199.       numberDisplay(hourb,3,0);
     
200.     }
     
201.     amDisplay();   
     
202.   }
     
203.   else if(hour>12&hour<24)
     
204.   {     
     
205.     hour=hour-12;
     
206.     int houra=hour/10;
     
207.     int hourb=hour%10;
     
208.     if(hour>0&hour<10)
     
209.     {
     
210.       numberDisplay(10,-1,0);
     
211.       numberDisplay(hour,3,0);      
     
212.     }
     
213.     else
     
214.     {
     
215.       numberDisplay(houra,-1,0);
     
216.       numberDisplay(hourb,3,0);
     
217.     }
     
218.     pmDisplay();
     
219.   }
     
220.   else if(hour<1)
     
221.   {     
     
222.     numberDisplay(1,-1,0);
     
223.     numberDisplay(2,3,0);
     
224.     amDisplay();
     
225.   }
     
226.   else if (hour==12)
     
227.   {
     
228.     numberDisplay(0,3,0);
     
229.     pmDisplay();
     
230.   }
     
231. }
     
232. 
     
233. void minuteDisplay()
     
234. {
     
235.   Time t=rtc.time();
     
236.   int minute=t.min;
     
237.   int minutea=minute/10;
     
238.   int minuteb=minute%10;
     
239.   if(minute>=10)
     
240.   {
     
241.     numberDisplay(minutea,9,0);
     
242.     numberDisplay(minuteb,13,0);
     
243.   }
     
244.   else  
     
245.   {
     
246.     numberDisplay(0,9,0);
     
247.     numberDisplay(minuteb,13,0);
     
248.   }
     
249. }
     
250. 
     
251. void numberDisplay(int i,int cols,int rows)
     
252. {
     
253.   switch(i)
     
254.   {
     
255.   case 0:
     
256.     zeroDisplay(cols,rows);
     
257.     break;
     
258.   case 1:
     
259.     oneDisplay(cols,rows);
     
260.     break;
     
261.   case 2:
     
262.     twoDisplay(cols,rows);
     
263.     break;
     
264.   case 3:
     
265.     threeDisplay(cols,rows);
     
266.     break;
     
267.   case 4:
     
268.     fourDisplay(cols,rows);
     
269.     break;
     
270.   case 5:
     
271.     fiveDisplay(cols,rows);
     
272.     break;
     
273.   case 6:
     
274.     sixDisplay(cols,rows);
     
275.     break;
     
276.   case 7:
     
277.     sevenDisplay(cols,rows);
     
278.     break;
     
279.   case 8:
     
280.     eightDisplay(cols,rows);
     
281.     break;
     
282.   case 9:
     
283.     nineDisplay(cols,rows);
     
284.     break;
     
285.   case 10:
     
286.     nullDisplay(cols,rows);
     
287.     break;
     
288.   }
     
289. }
     
290. 
     
291. void zeroDisplay(int col, int row)
     
292. {
     
293.   lcd.setCursor(col,row);
     
294.   lcd.write(1);
     
295.   lcd.setCursor(col+1,row);
     
296.   lcd.write(2);
     
297.   lcd.setCursor(col+2,row);
     
298.   lcd.write(1);
     
299.   lcd.setCursor(col,row+1);
     
300.   lcd.write(1);
     
301.   lcd.setCursor(col+1,row+1);
     
302.   lcd.write(3);
     
303.   lcd.setCursor(col+2,row+1);
     
304.   lcd.write(1);
     
305. }
     
306. 
     
307. void oneDisplay(int col, int row)
     
308. {
     
309.   lcd.setCursor(col,row);
     
310.   lcd.write(8);
     
311.   lcd.setCursor(col+1,row);
     
312.   lcd.write(1);
     
313.   lcd.setCursor(col+2,row);
     
314.   lcd.write(8);
     
315.   lcd.setCursor(col,row+1);
     
316.   lcd.write(8);
     
317.   lcd.setCursor(col+1,row+1);
     
318.   lcd.write(1);
     
319.   lcd.setCursor(col+2,row+1);
     
320.   lcd.write(8);
     
321. }
     
322. 
     
323. 
     
324. void twoDisplay(int col, int row)
     
325. {
     
326.   lcd.setCursor(col,row);
     
327.   lcd.write(2);
     
328.   lcd.setCursor(col+1,row);
     
329.   lcd.write(2);
     
330.   lcd.setCursor(col+2,row);
     
331.   lcd.write(1);
     
332.   lcd.setCursor(col,row+1);
     
333.   lcd.write(1);
     
334.   lcd.setCursor(col+1,row+1);
     
335.   lcd.write(4);
     
336.   lcd.setCursor(col+2,row+1);
     
337.   lcd.write(4);
     
338. }
     
339. 
     
340. void threeDisplay(int col, int row)
     
341. {
     
342.   lcd.setCursor(col,row);
     
343.   lcd.write(4);
     
344.   lcd.setCursor(col+1,row);
     
345.   lcd.write(4);
     
346.   lcd.setCursor(col+2,row);
     
347.   lcd.write(1);
     
348.   lcd.setCursor(col,row+1);
     
349.   lcd.write(3);
     
350.   lcd.setCursor(col+1,row+1);
     
351.   lcd.write(3);
     
352.   lcd.setCursor(col+2,row+1);
     
353.   lcd.write(1);
     
354. }
     
355. 
     
356. void fourDisplay(int col, int row)
     
357. {
     
358.   lcd.setCursor(col,row);
     
359.   lcd.write(1);
     
360.   lcd.setCursor(col+1,row);
     
361.   lcd.write(8);
     
362.   lcd.setCursor(col+2,row);
     
363.   lcd.write(1);
     
364.   lcd.setCursor(col,row+1);
     
365.   lcd.write(2);
     
366.   lcd.setCursor(col+1,row+1);
     
367.   lcd.write(2);
     
368.   lcd.setCursor(col+2,row+1);
     
369.   lcd.write(1);
     
370. }
     
371. 
     
372. void fiveDisplay(int col, int row)
     
373. {
     
374.   lcd.setCursor(col,row);
     
375.   lcd.write(1);
     
376.   lcd.setCursor(col+1,row);
     
377.   lcd.write(4);
     
378.   lcd.setCursor(col+2,row);
     
379.   lcd.write(4);
     
380.   lcd.setCursor(col,row+1);
     
381.   lcd.write(3);
     
382.   lcd.setCursor(col+1,row+1);
     
383.   lcd.write(3);
     
384.   lcd.setCursor(col+2,row+1);
     
385.   lcd.write(1);
     
386. }
     
387. 
     
388. void sixDisplay(int col, int row)
     
389. {
     
390.   lcd.setCursor(col,row);
     
391.   lcd.write(1);
     
392.   lcd.setCursor(col+1,row);
     
393.   lcd.write(2);
     
394.   lcd.setCursor(col+2,row);
     
395.   lcd.write(2);
     
396.   lcd.setCursor(col,row+1);
     
397.   lcd.write(1);
     
398.   lcd.setCursor(col+1,row+1);
     
399.   lcd.write(4);
     
400.   lcd.setCursor(col+2,row+1);
     
401.   lcd.write(1);
     
402. }
     
403. 
     
404. void sevenDisplay(int col, int row)
     
405. {
     
406.   lcd.setCursor(col,row);
     
407.   lcd.write(2);
     
408.   lcd.setCursor(col+1,row);
     
409.   lcd.write(2);
     
410.   lcd.setCursor(col+2,row);
     
411.   lcd.write(1);
     
412.   lcd.setCursor(col,row+1);
     
413.   lcd.write(8);
     
414.   lcd.setCursor(col+1,row+1);
     
415.   lcd.write(8);
     
416.   lcd.setCursor(col+2,row+1);
     
417.   lcd.write(1);
     
418. }
     
419. 
     
420. void eightDisplay(int col, int row)
     
421. {
     
422.   lcd.setCursor(col,row);
     
423.   lcd.write(1);
     
424.   lcd.setCursor(col+1,row);
     
425.   lcd.write(5);
     
426.   lcd.setCursor(col+2,row);
     
427.   lcd.write(1);
     
428.   lcd.setCursor(col,row+1);
     
429.   lcd.write(1);
     
430.   lcd.setCursor(col+1,row+1);
     
431.   lcd.write(6);
     
432.   lcd.setCursor(col+2,row+1);
     
433.   lcd.write(1);
     
434. }
     
435. 
     
436. void nineDisplay(int col, int row)
     
437. {
     
438.   lcd.setCursor(col,row);
     
439.   lcd.write(1);
     
440.   lcd.setCursor(col+1,row);
     
441.   lcd.write(4);
     
442.   lcd.setCursor(col+2,row);
     
443.   lcd.write(1);
     
444.   lcd.setCursor(col,row+1);
     
445.   lcd.write(3);
     
446.   lcd.setCursor(col+1,row+1);
     
447.   lcd.write(3);
     
448.   lcd.setCursor(col+2,row+1);
     
449.   lcd.write(1);
     
450. }
     
451. 
     
452. void nullDisplay(int col,int row)
     
453. {
     
454.   lcd.setCursor(col,row);
     
455.   lcd.write(8);
     
456.   lcd.setCursor(col+1,row);
     
457.   lcd.write(8);
     
458.   lcd.setCursor(col+2,row);
     
459.   lcd.write(8);
     
460.   lcd.setCursor(col,row+1);
     
461.   lcd.write(8);
     
462.   lcd.setCursor(col+1,row+1);
     
463.   lcd.write(8);
     
464.   lcd.setCursor(col+2,row+1);
     
465.   lcd.write(8);
     
466. }
     
467. 
     
468. 
     
469. void amDisplay()
     
470. {
     
471.   lcd.setCursor(7,0);
     
472.   lcd.print('a');
     
473.   lcd.setCursor(7,1);
     
474.   lcd.print('m');
     
475.   delay(500);
     
476.   lcd.setCursor(7,0);
     
477.   lcd.write(8);
     
478.   lcd.setCursor(7,1);
     
479.   lcd.write(8);
     
480.   delay(500);
     
481. }
     
482. 
     
483. void pmDisplay()
     
484. {
     
485.   lcd.setCursor(7,0);
     
486.   lcd.print('p');
     
487.   lcd.setCursor(7,1);
     
488.   lcd.print('m');
     
489.   delay(500);
     
490.   lcd.setCursor(7,0);
     
491.   lcd.write(8);
     
492.   lcd.setCursor(7,1);
     
493.   lcd.write(8);
     
494.   delay(500);
     
495. }

复制代码

       基本上我的superclock的V0.1版本就是这个样子了，当然还存在很多问题，等日后有空了果断再更新一下，只因我个人大爱时钟，希望能做出更加个性化而且功能完善的时钟吧，先mark下日后需要改进的地方：
    1.遥控设定时间
    2.闹钟设定


    PS：视频中也提到了Remote的库和Arduino本身的tone函数存在冲突，暂时功力还不够深厚，等日后好好研究一下再改进！
    鄙人不才，还望各位大神指点！另真心感谢极客工坊提供这么好的学习平台！  

Randy

你的时钟模块是在信德电子买的吧？哈哈

太行摄狼

还不错啊，学习了

但丁

Randy 发表于 2012-9-13 23:17
你的时钟模块是在信德电子买的吧？哈哈

老大，这你也看得出来？.....佩服

Randy

但丁 发表于 2012-9-14 11:20
老大，这你也看得出来？.....佩服

呵呵，逛多了就觉得熟悉了！

id9502

找个时间试试，不错。

jack3150

还不错了~！~

acdc0616

求一下原理图或接线图，程序里我不会看啊，谢谢

maybachwang

有点晕，留爪慢慢学习

穿山甲

秒有点快啊

wqian

一个月就能搞定啊

迷你强

逆天的超长无注释代码啊。。。。。

ttyp

原来有人做了啊，我还做了一个呢不过我用的是1307+DHT11，有时间设置和温度和湿度

龙腾东山

有空模仿一个,谢谢了!

ogre_c

谢谢楼主，学习了，因现有的苹果遥控器闲置，所以模仿了楼主的代码，用它遥控小表，兼职遥控个电视啥的。
主要硬件：arduino uno，一样的液晶屏和时间模块，红外收发头，蜂鸣器，sht10温湿度传感器。

1. #define menu   0x77E1406A
   
2. #define up     0x77E1D06A
   
3. #define down   0x77E1B06A
   
4. #define left   0x77E1106A
   
5. #define right  0x77E1E06A
   
6. #define center 0x77E1BA6A
   
7. #define play   0x77E17A6A
   
8. #include <IRremote.h>
   
9. int RECV_PIN = 5;
   
10. IRrecv irrecv(RECV_PIN);
    
11. decode_results results;
    
12. IRsend irsend;
    
13. int Model;
    
14. 
    
15. #include <Wire.h>
    
16. #include <LiquidCrystal_I2C.h>
    
17. #include <SHT1x.h>
    
18. #include <DS1302.h>
    
19. uint8_t CE_PIN   = 12;
    
20. uint8_t IO_PIN   = 11;
    
21. uint8_t SCLK_PIN = 10;
    
22. DS1302 rtc(CE_PIN,IO_PIN,SCLK_PIN);
    
23. char yearmonthday[20];
    
24. char hourminutesecond[10];
    
25. char day[10];
    
26. byte one[8]={
    
27.   B11111,B11111,B00000,B11111,B11111,B00000,B11111,B11111};                                          
    
28. byte two[8]={
    
29.   B11111,B11111,B00000,B00000,B00000,B00000,B00000,B00000};
    
30. byte three[8]={
    
31.   B00000,B00000,B00000,B00000,B00000,B00000,B11111,B11111};
    
32. byte four[8]={
    
33.   B11111,B11111,B00000,B00000,B00000,B00000,B11111,B11111};
    
34. byte five[8]={
    
35.   B11111,B11111,B00000,B00000,B00000,B00000,B00000,B11111};
    
36. byte six[8]={
    
37.   B11111,B00000,B00000,B00000,B00000,B00000,B11111,B11111};
    
38. byte seven[8]={
    
39.   B00000,B00000,B00000,B11111,B11111,B00000,B00000,B00000};
    
40. byte zero[8]={
    
41.   B00000,B00000,B00000,B00000,B00000,B00000,B00000,B00000};
    
42. 
    
43. // Specify data and clock connections and instantiate SHT1x object
    
44. #define dataPin  8
    
45. #define clockPin 9
    
46. int BeepPin = 7;        // 指定有源蜂鸣器输出端口
    
47. int buttonPin = 6;
    
48. 
    
49. SHT1x sht1x(dataPin, clockPin);
    
50. LiquidCrystal_I2C lcd(0x27,16,2);  //set the LCD address to 0x27 for a 16 chars and 2 line display
    
51. 
    
52. int ledPin = 13;
    
53. int menu_status = 0;
    
54. int center_status= 0;
    
55. 
    
56. void setup()
    
57. {
    
58.   lcd.init();
    
59.   delay(2000);
    
60.   lcd.init();
    
61.   lcd.backlight();
    
62.   lcd.clear();
    
63.   lcd.createChar(1,one);             //displayModel2
    
64.   lcd.createChar(2,two);
    
65.   lcd.createChar(3,three);
    
66.   lcd.createChar(4,four);
    
67.   lcd.createChar(5,five);
    
68.   lcd.createChar(6,six);
    
69.   lcd.createChar(7,seven);  
    
70.   lcd.createChar(8,zero);
    
71. 
    
72.   Serial.begin(9600);
    
73.   
    
74.   pinMode(buttonPin, INPUT);   
    
75.   pinMode(BeepPin, OUTPUT);
    
76.   beep_long();                      //蛐蛐开叫，证明系统运行。
    
77.   delay(1000);
    
78.   beep_short();
    
79. 
    
80.   irrecv.enableIRIn(); // Start the receiver
    
81. }
    
82. void loop()
    
83. {
    
84.   receiver();
    
85.   if(Model==1)
    
86.   {
    
87.     displayModel1();
    
88.   }  
    
89.   else
    
90.   {
    
91.     displayModel2();
    
92.   }
    
93. //*******************************************        
    
94.        // delay(1000);
    
95. }
    
96. 
    
97. void timeandtempDisplay()
    
98. {
    
99.   Time t=rtc.time();
    
100.   memset(day,0, sizeof(day));
     
101.   switch (t.day)
     
102.   {
     
103.   case 1:
     
104.     strcpy(day, "Sun");
     
105.     break;
     
106.   case 2:
     
107.     strcpy(day, "Mon");
     
108.     break;
     
109.   case 3:
     
110.     strcpy(day, "Tue");
     
111.     break;
     
112.   case 4:
     
113.     strcpy(day, "Wed");
     
114.     break;
     
115.   case 5:
     
116.     strcpy(day, "Thr");
     
117.     break;
     
118.   case 6:
     
119.     strcpy(day, "Fri");
     
120.     break;
     
121.   case 7:
     
122.     strcpy(day, "Sat");
     
123.     break;
     
124.   }
     
125.   snprintf(yearmonthday, sizeof(yearmonthday), "%04d/%02d/%02d",t.yr,t.mon,t.date);
     
126.   snprintf(hourminutesecond,sizeof(hourminutesecond),"%02d:%02d:%02d",t.hr, t.min, t.sec);
     
127.   lcd.setCursor(0,0);
     
128.   lcd.print(yearmonthday);
     
129.   lcd.setCursor(13,0);
     
130.   lcd.print(day);  
     
131.   lcd.setCursor(0,1);
     
132.   tempDisplay();
     
133.   lcd.setCursor(8,1);
     
134.   lcd.print(hourminutesecond);
     
135. }
     
136. 
     
137. void tempDisplay()
     
138. {  
     
139.   float  temp = sht1x.readTemperatureC();
     
140.   int temperature=temp;
     
141.   lcd.print(temperature);
     
142.   lcd.write(0xDF);
     
143. //  lcd.print("c");
     
144. //**********************
     
145.   float  hum = sht1x.readHumidity();
     
146.   int humidity=hum;
     
147.   lcd.print(humidity);
     
148. }
     
149. 
     
150. void beep_long(){                    //蛐蛐叫声，表示错误。
     
151.   for(int j=0;j<3;j++){
     
152.     for(int i=0;i<5;i++){
     
153.       digitalWrite(BeepPin, HIGH);   
     
154.       delay(20);         
     
155.       digitalWrite(BeepPin, LOW);   
     
156.       delay(20);              
     
157.     }
     
158.     delay(800);              
     
159.   }
     
160. }
     
161. 
     
162. void beep_short(){                  //蛐蛐叫声，表示成功。
     
163.   for(int j=0;j<2;j++){
     
164.     for(int i=0;i<2;i++){
     
165.       digitalWrite(BeepPin, HIGH);  
     
166.       delay(20);            
     
167.       digitalWrite(BeepPin, LOW);   
     
168.       delay(20);            
     
169.     }
     
170.     delay(500);   
     
171.   }
     
172. }
     
173. 
     
174. void receiver(){
     
175.    if (irrecv.decode(&results))
     
176.   {
     
177.      Serial.println(results.value, HEX);
     
178.      switch (results.value)
     
179.      {
     
180. //*****************************0media
     
181.        case menu:
     
182.        if(menu_status==0)
     
183.       {
     
184.       Model=1;
     
185.       lcd.clear();
     
186.       menu_status=1;
     
187.       //****************
     
188.      for (int i = 0; i < 3; i++) {
     
189.       irsend.sendSony(0xa50, 12);
     
190.       delay(50);
     
191.     }
     
192.    
     
193.     delay(500);
     
194.       }
     
195.       else if(menu_status==1)
     
196.       {
     
197.        Model=2;
     
198.        lcd.clear();
     
199.        menu_status=0;
     
200.        //****************
     
201.       for (int i = 0; i < 3; i++) {
     
202.       irsend.sendSony(0xa50, 12);
     
203.       delay(50);}
     
204.       }   
     
205.          
     
206.       irrecv.enableIRIn();
     
207.       break;
     
208.       //*****************************play
     
209.        case play:  
     
210.           delay(200);
     
211.      
     
212.      for (int i = 0; i < 3; i++) {
     
213.       irsend.sendSony(0xa90, 12);
     
214.       delay(50);
     
215.     }
     
216.    
     
217.       delay(500);      
     
218.       irrecv.enableIRIn();
     
219.       break;     
     
220.       //*****************************center
     
221.        case center:  
     
222.       if(center_status==0)
     
223.       {
     
224.       lcd.noBacklight();
     
225.       center_status=1;
     
226.       }
     
227.       else if(center_status==1)
     
228.       {
     
229.        lcd.backlight();
     
230.        center_status=0;
     
231.       }
     
232.       irrecv.enableIRIn();
     
233.       break;
     
234.      //*****************************left
     
235.     case left:  
     
236.      delay(100);
     
237.       irsend.sendNEC(0x801FE817, 32);
     
238.    
     
239.     delay(500);
     
240.     irrecv.enableIRIn();
     
241.     break;
     
242.    //*****************************right
     
243.     case right:  
     
244.      delay(100);
     
245.      irsend.sendNEC(0x801F58A7, 32);
     
246.    
     
247.     delay(500);
     
248.     irrecv.enableIRIn();
     
249.     break;
     
250.     //*****************************
     
251.         case up:  
     
252.      delay(50);
     
253.      
     
254.      for (int i = 0; i < 3; i++) {
     
255.       irsend.sendSony(0x490, 12); // Sony TV power code
     
256.       delay(50);
     
257.     }
     
258.    
     
259.     delay(500);
     
260.     irrecv.enableIRIn();
     
261.     break;
     
262. //*****************************3down
     
263.     case down:  
     
264.      delay(50);
     
265.      
     
266.      for (int i = 0; i < 3; i++) {
     
267.       irsend.sendSony(0xc90, 12); // Sony TV power code
     
268.       delay(50);
     
269.     }
     
270.    
     
271.     delay(500);
     
272.     irrecv.enableIRIn();
     
273.     break;
     
274.    //*********************************
     
275.     }
     
276.    irrecv.resume(); // Receive the next value
     
277.   }
     
278. }
     
279. void displayModel1()
     
280. {
     
281.   timeandtempDisplay();
     
282. }
     
283. void displayModel2()
     
284. {  
     
285.   minuteDisplay();  
     
286.   hourDisplay();   
     
287. }
     
288. 
     
289. void hourDisplay()
     
290. {
     
291.   Time t=rtc.time();
     
292.   int hour=t.hr;  
     
293.   if(hour<12&hour>0)
     
294.   {   
     
295.     int houra=hour/10;
     
296.     int hourb=hour%10;
     
297.     if(hour>0&hour<10)
     
298.     {
     
299.       numberDisplay(10,-1,0);
     
300.       numberDisplay(hour,3,0);      
     
301.     }
     
302.     else
     
303.     {
     
304.       numberDisplay(houra,-1,0);
     
305.       numberDisplay(hourb,3,0);
     
306.     }
     
307.     amDisplay();   
     
308.   }
     
309.   else if(hour>12&hour<24)
     
310.   {     
     
311.     hour=hour-12;
     
312.     int houra=hour/10;
     
313.     int hourb=hour%10;
     
314.     if(hour>0&hour<10)
     
315.     {
     
316.       numberDisplay(10,-1,0);
     
317.       numberDisplay(hour,3,0);      
     
318.     }
     
319.     else
     
320.     {
     
321.       numberDisplay(houra,-1,0);
     
322.       numberDisplay(hourb,3,0);
     
323.     }
     
324.     pmDisplay();
     
325.   }
     
326.   else if(hour<1)
     
327.   {     
     
328.     numberDisplay(1,-1,0);
     
329.     numberDisplay(2,3,0);
     
330.     amDisplay();
     
331.   }
     
332.   else if (hour==12)
     
333.   {
     
334.     numberDisplay(0,3,0);
     
335.     pmDisplay();
     
336.   }
     
337. }
     
338. 
     
339. void minuteDisplay()
     
340. {
     
341.   Time t=rtc.time();
     
342.   int minute=t.min;
     
343.   int minutea=minute/10;
     
344.   int minuteb=minute%10;
     
345.   if(minute>=10)
     
346.   {
     
347.     numberDisplay(minutea,9,0);
     
348.     numberDisplay(minuteb,13,0);
     
349.   }
     
350.   else  
     
351.   {
     
352.     numberDisplay(0,9,0);
     
353.     numberDisplay(minuteb,13,0);
     
354.   }
     
355. }
     
356. 
     
357. void numberDisplay(int i,int cols,int rows)
     
358. {
     
359.   switch(i)
     
360.   {
     
361.   case 0:
     
362.     zeroDisplay(cols,rows);
     
363.     break;
     
364.   case 1:
     
365.     oneDisplay(cols,rows);
     
366.     break;
     
367.   case 2:
     
368.     twoDisplay(cols,rows);
     
369.     break;
     
370.   case 3:
     
371.     threeDisplay(cols,rows);
     
372.     break;
     
373.   case 4:
     
374.     fourDisplay(cols,rows);
     
375.     break;
     
376.   case 5:
     
377.     fiveDisplay(cols,rows);
     
378.     break;
     
379.   case 6:
     
380.     sixDisplay(cols,rows);
     
381.     break;
     
382.   case 7:
     
383.     sevenDisplay(cols,rows);
     
384.     break;
     
385.   case 8:
     
386.     eightDisplay(cols,rows);
     
387.     break;
     
388.   case 9:
     
389.     nineDisplay(cols,rows);
     
390.     break;
     
391.   case 10:
     
392.     nullDisplay(cols,rows);
     
393.     break;
     
394.   }
     
395. }
     
396. 
     
397. void zeroDisplay(int col, int row)
     
398. {
     
399.   lcd.setCursor(col,row);
     
400.   lcd.write(1);
     
401.   lcd.setCursor(col+1,row);
     
402.   lcd.write(2);
     
403.   lcd.setCursor(col+2,row);
     
404.   lcd.write(1);
     
405.   lcd.setCursor(col,row+1);
     
406.   lcd.write(1);
     
407.   lcd.setCursor(col+1,row+1);
     
408.   lcd.write(3);
     
409.   lcd.setCursor(col+2,row+1);
     
410.   lcd.write(1);
     
411. }
     
412. 
     
413. void oneDisplay(int col, int row)
     
414. {
     
415.   lcd.setCursor(col,row);
     
416.   lcd.write(8);
     
417.   lcd.setCursor(col+1,row);
     
418.   lcd.write(1);
     
419.   lcd.setCursor(col+2,row);
     
420.   lcd.write(8);
     
421.   lcd.setCursor(col,row+1);
     
422.   lcd.write(8);
     
423.   lcd.setCursor(col+1,row+1);
     
424.   lcd.write(1);
     
425.   lcd.setCursor(col+2,row+1);
     
426.   lcd.write(8);
     
427. }
     
428. 
     
429. 
     
430. void twoDisplay(int col, int row)
     
431. {
     
432.   lcd.setCursor(col,row);
     
433.   lcd.write(2);
     
434.   lcd.setCursor(col+1,row);
     
435.   lcd.write(2);
     
436.   lcd.setCursor(col+2,row);
     
437.   lcd.write(1);
     
438.   lcd.setCursor(col,row+1);
     
439.   lcd.write(1);
     
440.   lcd.setCursor(col+1,row+1);
     
441.   lcd.write(4);
     
442.   lcd.setCursor(col+2,row+1);
     
443.   lcd.write(4);
     
444. }
     
445. 
     
446. void threeDisplay(int col, int row)
     
447. {
     
448.   lcd.setCursor(col,row);
     
449.   lcd.write(4);
     
450.   lcd.setCursor(col+1,row);
     
451.   lcd.write(4);
     
452.   lcd.setCursor(col+2,row);
     
453.   lcd.write(1);
     
454.   lcd.setCursor(col,row+1);
     
455.   lcd.write(3);
     
456.   lcd.setCursor(col+1,row+1);
     
457.   lcd.write(3);
     
458.   lcd.setCursor(col+2,row+1);
     
459.   lcd.write(1);
     
460. }
     
461. 
     
462. void fourDisplay(int col, int row)
     
463. {
     
464.   lcd.setCursor(col,row);
     
465.   lcd.write(1);
     
466.   lcd.setCursor(col+1,row);
     
467.   lcd.write(8);
     
468.   lcd.setCursor(col+2,row);
     
469.   lcd.write(1);
     
470.   lcd.setCursor(col,row+1);
     
471.   lcd.write(2);
     
472.   lcd.setCursor(col+1,row+1);
     
473.   lcd.write(2);
     
474.   lcd.setCursor(col+2,row+1);
     
475.   lcd.write(1);
     
476. }
     
477. 
     
478. void fiveDisplay(int col, int row)
     
479. {
     
480.   lcd.setCursor(col,row);
     
481.   lcd.write(1);
     
482.   lcd.setCursor(col+1,row);
     
483.   lcd.write(4);
     
484.   lcd.setCursor(col+2,row);
     
485.   lcd.write(4);
     
486.   lcd.setCursor(col,row+1);
     
487.   lcd.write(3);
     
488.   lcd.setCursor(col+1,row+1);
     
489.   lcd.write(3);
     
490.   lcd.setCursor(col+2,row+1);
     
491.   lcd.write(1);
     
492. }
     
493. 
     
494. void sixDisplay(int col, int row)
     
495. {
     
496.   lcd.setCursor(col,row);
     
497.   lcd.write(1);
     
498.   lcd.setCursor(col+1,row);
     
499.   lcd.write(2);
     
500.   lcd.setCursor(col+2,row);
     
501.   lcd.write(2);
     
502.   lcd.setCursor(col,row+1);
     
503.   lcd.write(1);
     
504.   lcd.setCursor(col+1,row+1);
     
505.   lcd.write(4);
     
506.   lcd.setCursor(col+2,row+1);
     
507.   lcd.write(1);
     
508. }
     
509. 
     
510. void sevenDisplay(int col, int row)
     
511. {
     
512.   lcd.setCursor(col,row);
     
513.   lcd.write(2);
     
514.   lcd.setCursor(col+1,row);
     
515.   lcd.write(2);
     
516.   lcd.setCursor(col+2,row);
     
517.   lcd.write(1);
     
518.   lcd.setCursor(col,row+1);
     
519.   lcd.write(8);
     
520.   lcd.setCursor(col+1,row+1);
     
521.   lcd.write(8);
     
522.   lcd.setCursor(col+2,row+1);
     
523.   lcd.write(1);
     
524. }
     
525. 
     
526. void eightDisplay(int col, int row)
     
527. {
     
528.   lcd.setCursor(col,row);
     
529.   lcd.write(1);
     
530.   lcd.setCursor(col+1,row);
     
531.   lcd.write(5);
     
532.   lcd.setCursor(col+2,row);
     
533.   lcd.write(1);
     
534.   lcd.setCursor(col,row+1);
     
535.   lcd.write(1);
     
536.   lcd.setCursor(col+1,row+1);
     
537.   lcd.write(6);
     
538.   lcd.setCursor(col+2,row+1);
     
539.   lcd.write(1);
     
540. }
     
541. 
     
542. void nineDisplay(int col, int row)
     
543. {
     
544.   lcd.setCursor(col,row);
     
545.   lcd.write(1);
     
546.   lcd.setCursor(col+1,row);
     
547.   lcd.write(4);
     
548.   lcd.setCursor(col+2,row);
     
549.   lcd.write(1);
     
550.   lcd.setCursor(col,row+1);
     
551.   lcd.write(3);
     
552.   lcd.setCursor(col+1,row+1);
     
553.   lcd.write(3);
     
554.   lcd.setCursor(col+2,row+1);
     
555.   lcd.write(1);
     
556. }
     
557. 
     
558. void nullDisplay(int col,int row)
     
559. {
     
560.   lcd.setCursor(col,row);
     
561.   lcd.write(8);
     
562.   lcd.setCursor(col+1,row);
     
563.   lcd.write(8);
     
564.   lcd.setCursor(col+2,row);
     
565.   lcd.write(8);
     
566.   lcd.setCursor(col,row+1);
     
567.   lcd.write(8);
     
568.   lcd.setCursor(col+1,row+1);
     
569.   lcd.write(8);
     
570.   lcd.setCursor(col+2,row+1);
     
571.   lcd.write(8);
     
572. }
     
573. 
     
574. 
     
575. void amDisplay()
     
576. {
     
577.   lcd.setCursor(7,0);
     
578.   lcd.print('a');
     
579.   lcd.setCursor(7,1);
     
580.   lcd.print('m');
     
581.   delay(500);
     
582.   lcd.setCursor(7,0);
     
583.   lcd.write(8);
     
584.   lcd.setCursor(7,1);
     
585.   lcd.write(8);
     
586.   delay(500);
     
587. }
     
588. 
     
589. void pmDisplay()
     
590. {
     
591.   lcd.setCursor(7,0);
     
592.   lcd.print('p');
     
593.   lcd.setCursor(7,1);
     
594.   lcd.print('m');
     
595.   delay(500);
     
596.   lcd.setCursor(7,0);
     
597.   lcd.write(8);
     
598.   lcd.setCursor(7,1);
     
599.   lcd.write(8);
     
600.   delay(500);
     
601. }
     

复制代码