自动亮度适应自然醒闹铃LED电子钟

翌阳

这个是在09年制作完成的，经过近2年的运行，工作稳定，年误差在10秒以内。
此钟的特点是：
1. 时分显示，24/12小时制可选。无日期与年份功能。（就是一个表，不是日历，所以不把那功能加进去了，若是来回跳着显示，看着烦。本人制作的东西，自然要依着个人的喜好走了，这是DIY的好处）。
2. 环境光强感应，自动调整LED显示的亮度（14级亮度），以免白天看不清，晚上太刺眼。（这个原来是准备装在卧室用的，用大LED数码管的原因也在此，在睡眼惺松的时候，小的确实看不清。）
3. 自然醒闹时唤醒功能。采用白光LED逐渐亮起，模拟天亮的过程，实现自然醒，早上醒来感觉精神十足。
4. 闹时按星期设定，可以选择七天全部和一周五天工作日等模式。
5. 一键设定。 模式选择和调整都只用一个按键，长按与短按。长按进入设定或确定设定，短按调整或模式选择。
7. 电池备份供电。3.6V备份电池提供短时（数天）断电走时维持。（此时单片机感应到主电源失电，进入省电运行模式，只计时，不扫描和闹时）
8. 充分利用2051的空闲模式，省电。只要没活干的时候就进入到空闲模式，无浪费的循环等待。
9. 机壳一直没完成，线路板是用废板改造的，很乱。（都不好意思拿出来给大家看了，但只此一台，如果做多了一定会做漂亮的，但我会多DIY一个吗？这个留给大家了）。
上图：下面跟贴再发程序。

[ 本帖最后由 翌阳 于 2011-1-25 11:13 编辑 ]

翌阳

1. #pragma code
   
2. #include <stdio.h>
   
3. #include <reg51.h>
   
4. //#define TIMCNT 1563
   
5. //#define TIMCNT 3200
   
6. //#define TIMCNT 1200                        //1200 for 7.3728MHz
   
7. #define TIMCNT 3000                        //for 18.432MHz
   
8. #define DOT 0x80
   
9. #define CHAR_c        97
   
10. #define CHAR_P        115|0x80
    
11. #define CHAR_d   94
    
12. #define CHAR_o         92
    
13. #define CHAR_f        113
    
14. #define CHAR_minus        64
    
15. #define KEYDELAY TIMCNT/4
    
16. #define KEY RD
    
17. code char version[]=" ==<<Clock V1.3 by 翌展 2009.3.10>>==\n";
    
18. data unsigned char asctb[]={63, 6, 91, 79, 102, 109, 125, 7, 127, 111, 119, 124, 57, 94, 121, 113};
    
19. data unsigned char digbit[]={0xe0,0xd0,0xc8,0xc4};//11100000,11010000,11001000,11000100
    
20. data unsigned char light=8,bright,alight=0,alon=32,maxtl[8]={0,0,0,0,0,0,0,0};
    
21. //                                                   0,1 2 3 4 5 6 7 8 9 1011 12 13 14 15
    
22. data unsigned char gama[]={1,1,2,2,3,3,4,5,6,7,8,10,13,18,24,32,32};
    
23. 
    
24. 
    
25. data unsigned char mode=0,alhour=0,almin=0,almode=0,hour=0,min=0,sec=0,week=0,flash=0,se=0;
    
26. data unsigned char dispdot=0;  //0: none  1:flash  2:always
    
27. data unsigned char P1bit=0x3;
    
28. data unsigned int timcnt=TIMCNT;
    
29. data unsigned char dbuf[4]={0xff,0xff,0xff,0xff},pbuf1[4]={0xfc,0xfc,0xfc,0xfc},pbuf3[4]={0xe3,0xd3,0xcb,0xc7};
    
30. bit modi=0,h12=0,lkey=0,rkey=0,dot=0,alarm=0,alarm_on=0,power=1,dot2=0,active=0;
    
31. void inittimer0(void)
    
32. {
    
33.     TMOD&=0xf0;
    
34.     TMOD|=0x02;
    
35.     TH0=0;
    
36.     TL0=0;
    
37.     TR0=1;
    
38.     ET0=1;
    
39.     EA=1;
    
40. }
    
41. void timer0(void) interrupt 1
    
42. {
    
43.     timcnt--;
    
44.     if(timcnt==0)
    
45.     {
    
46.         if(!modi)sec++;     
    
47.         if(sec>119)sec=0;
    
48.         dot=!dot;
    
49.         timcnt=TIMCNT;
    
50.     }
    
51. }
    
52. void display_almode(void)
    
53. {
    
54.         switch(almode){
    
55.                 case 0:                                //off
    
56.                                 dbuf[0]=0;
    
57.                                 dbuf[1]=CHAR_o;
    
58.                                 dbuf[2]=CHAR_f;
    
59.                                 dbuf[3]=CHAR_f;
    
60.                         break;
    
61.                 case 1:                                //p.d.
    
62.                                 dbuf[0]=0;
    
63.                                 dbuf[1]=CHAR_P;
    
64.                                 dbuf[2]=0;
    
65.                                 dbuf[3]=CHAR_d|DOT;
    
66.                         break;
    
67.                 case 2:                                //1-5
    
68.                                 dbuf[0]=CHAR_d;
    
69.                                 dbuf[1]=asctb[1];
    
70.                                 dbuf[2]=CHAR_minus;
    
71.                                 dbuf[3]=asctb[5];
    
72.                         break;
    
73.         }
    
74. }
    
75. void display_hm(unsigned char h,unsigned char m,bit b)       
    
76. {
    
77.             dbuf[1]=asctb[h%10];
    
78.                     h/=10;
    
79.                     if(b && !h)dbuf[0]=0;else dbuf[0]=asctb[h];
    
80.             dbuf[2]=asctb[m/10];
    
81.             dbuf[3]=asctb[m%10];
    
82. }
    
83. 
    
84. void display(void)
    
85. {
    
86.     static unsigned char pid=0;
    
87.     unsigned char c,h;
    
88.     flash=0;dispdot=1;
    
89.     switch(mode)
    
90.     {
    
91.         case 0:                                        //12 hour
    
92.                 h=hour%12;if(h==0)h=12;
    
93.                 display_hm(h,min,1);
    
94.                     if(hour<12)dbuf[0]|=DOT;
    
95.                     break;
    
96.         case 1:                                        //24 hour
    
97.                         display_hm(hour,min,1);
    
98.             break;
    
99.         case 2:                                        //second
    
100.                 display_hm(min,sec>>1,0);
     
101.                 dispdot=2;
     
102.                 break;
     
103.         case 3:                                        //h setup
     
104.                     display_hm(hour,min,1);
     
105.                     flash=1;
     
106.                 break;
     
107.         case 4:                                        //m setup
     
108.                 display_hm(hour,min,1);
     
109.                 flash=2;
     
110.                 if(modi)dispdot=2;
     
111.                 break;
     
112.         case 5:                                        //week setup
     
113.             dbuf[0]=0;
     
114.                     dbuf[1]=asctb[week];
     
115.             dbuf[2]=CHAR_d;
     
116.             dbuf[3]=0;
     
117.             flash=1;
     
118.             dispdot=0;
     
119.                         break;                                                       
     
120.         case 6:                                        //s setup
     
121.                 display_hm(min,sec>>1,0);
     
122.             dispdot=2;
     
123.             flash=2;
     
124.                 break;
     
125.         case 7:                                //week
     
126.                 dbuf[0]=0;
     
127.                 dbuf[1]=asctb[week];
     
128.                 dbuf[2]=CHAR_d;                                //'d'
     
129.                 dbuf[3]=0;
     
130.             dispdot=0;
     
131.                 break;
     
132.                 case 8:                                                                //alarm
     
133.                         if((sec & 6)==6){
     
134.                                 display_almode();
     
135.                     dispdot=0;
     
136.                         }else{
     
137.                                 display_hm(alhour,almin,1);
     
138.                            dispdot=2;
     
139.                    }
     
140.                         break;       
     
141.                 case 9:                                                                //alarm hour setup
     
142.                         display_hm(alhour,almin,1);
     
143.             dbuf[3]|=DOT;
     
144.             flash=1;
     
145.             dispdot=2;
     
146.                         break;
     
147.                 case 10:                                                                //alarm min setup
     
148.                         display_hm(alhour,almin,1);
     
149.             dbuf[3]|=DOT;
     
150.             flash=2;
     
151.             dispdot=2;
     
152.                         break;
     
153.                 case 11:                                                                //alarm mode setup     0:off  1: p.d.  2:1-5
     
154.                         display_almode();
     
155.                         flash=3;
     
156.             dispdot=0;
     
157.                         break;
     
158.                 case 12:                                                                //display bright senser data
     
159.                         dbuf[0]=asctb[light];
     
160.                         dbuf[1]=0;
     
161.                         dbuf[2]=asctb[bright/10];
     
162.                         dbuf[3]=asctb[bright%10];
     
163.             dispdot=0;
     
164.                         break;
     
165.                 case 13:                                                                //display MAX RUN DELAY
     
166.                         pid++;if(pid>63)pid=0;
     
167.                         c=pid>>3;
     
168.                         dbuf[0]=asctb[c];
     
169.                         dbuf[1]=CHAR_minus;
     
170.                         c=maxtl[c];
     
171.                         dbuf[2]=asctb[c>>4];
     
172.                         dbuf[3]=asctb[c&0xf];
     
173.             dispdot=0;
     
174.                         break;
     
175.                 case 14:                                                                //min was set and wait for starting
     
176.                         display_hm(hour,min,1);
     
177.                         dispdot=2;
     
178.                         break;
     
179.                 case 15:                                                                //LED & alarm light check
     
180.                         dbuf[0]=0xff;
     
181.                         dbuf[1]=0xff;
     
182.                         dbuf[2]=0xff;
     
183.                         dbuf[3]=0xff;
     
184.                         dispdot=0;
     
185.                         pid++;
     
186.                         if(pid>63)pid=0;
     
187.                         alight=pid>>2;
     
188.                         alarm_on=1;
     
189.                         break;
     
190. 
     
191.     }
     
192. }
     
193. void display_dot(void)
     
194. {
     
195.         if(dispdot==1 && dot2 || dispdot==2){dbuf[1]|=DOT;dbuf[2]|=DOT;}
     
196. }
     
197. void bufferproc(void)
     
198. {
     
199.         if(almode)dbuf[3]|=DOT;
     
200.         if(!dot2){
     
201.                 if(flash&1){
     
202.                         dbuf[0]&=DOT;dbuf[1]&=DOT;
     
203.                 }
     
204.                 if(flash&2){
     
205.                         dbuf[2]&=DOT;dbuf[3]&=DOT;
     
206.                 }
     
207.         }
     
208.                 pbuf1[0]=dbuf[0]&0xfc;
     
209.                 pbuf3[0]=dbuf[0]&3|digbit[0];
     
210.                 pbuf1[1]=dbuf[1]&0xfc;
     
211.                 pbuf3[1]=dbuf[1]&3|digbit[1];
     
212.                 pbuf1[2]=dbuf[2]&0xfc;
     
213.                 pbuf3[2]=dbuf[2]&3|digbit[2];
     
214.                 pbuf1[3]=dbuf[3]&0xfc;
     
215.                 pbuf3[3]=dbuf[3]&3|digbit[3];
     
216. }
     
217. 
     
218. bit caltim(void)
     
219. {
     
220.     if(se!=sec)
     
221.     {
     
222.         se=sec;
     
223.         if(sec==0)
     
224.         {
     
225.             min++;
     
226.             if(min>59)
     
227.             {
     
228.                 hour++;min=0;
     
229.                 if(hour>23)
     
230.                 {       
     
231.                     hour=0;week++;if(week>6)week=0;
     
232.                                 }
     
233.             }
     
234.         }
     
235.         return 1;
     
236.      }
     
237.      return 0;
     
238. }
     
239. 
     
240. void LEDscan(void)
     
241. {
     
242.         static unsigned char dly=8,dig=0;
     
243.         dly--;
     
244.         if(dly==0){dly=8;P3=0xc0;}  // 11000000
     
245.         if(dly==light){
     
246.                 dig++;
     
247.                 if(dig>3)dig=0;
     
248.                 P1=pbuf1[dig]|P1bit;
     
249.                 P3=pbuf3[dig];
     
250.         }
     
251.         if(alarm_on){
     
252.                 alon--;                                                                        ///alarm
     
253.                 if(alon==0){alon=32;P10=1;P1bit|=1;}
     
254.                 if(alon==alight){P10=0;P1bit&=2;}
     
255.         }
     
256. }
     
257. void bright_senser(void)
     
258. {
     
259.         static unsigned char bcount=63,b2=0;
     
260.         if((P1bit&0x2)==0x2){
     
261.                 if(!P11 && bcount!=0)bcount--;
     
262.                 else{
     
263.                         bright=(bright+bcount)>>1;
     
264.                         if(b2>bright+4 || b2+4<bright){
     
265.                                 light=gama[bright/6]; //0-63 /6 =0-10      //(bright>>3)+1;  //*8/256;
     
266.                                 b2=bright;
     
267.                         }
     
268.                         P1bit&=0x1;
     
269.                         P11=0;
     
270.                         bcount=10;
     
271.                 }
     
272.         }else{
     
273.                 if(bcount!=0)bcount--;else{
     
274.                         P1bit|=0x2;
     
275.                         P11=1;
     
276.                         bcount=63;
     
277.                 }
     
278.         }
     
279. }
     
280. void alarmlight(void)
     
281. {
     
282.         static unsigned char mina=0,fade=0;
     
283. //        static unsigned int fade=0;
     
284.         if(almode==0)return;
     
285.         if(mina!=min){
     
286.                 mina=min;
     
287.                 if(!alarm && alhour==hour && almin==min && (almode==1||week>0 && week<6)){
     
288.                         alarm=1;alarm_on=1;fade=0;alight=0;
     
289.                 }
     
290.                 if(alarm){
     
291.                         if(fade<46){
     
292.                                 if(fade<16)alight=gama[fade];                //0-15
     
293.                                 else if(fade<31)alight=32;                        //16-30
     
294.                                 else alight=gama[45-fade];                        //31-45
     
295.                                 fade++;
     
296.                         }else{
     
297.                                 alarm=0;alarm_on=0;fade=0;alight=0;P10=1;P1bit|=1;
     
298.                         }
     
299.                 }
     
300.         }
     
301. }
     
302. void chkpower(void)
     
303. {
     
304.         if(P1bit&1){
     
305.                 power=P10;
     
306.                 if(!power){P1=3;P3=0;}
     
307.         }
     
308. }
     
309. void setup(void)
     
310. {
     
311.         static unsigned int kcode=0;
     
312.         unsigned char key=0;
     
313.         ///----------------------getkey
     
314.         if(!KEY){
     
315.                 lkey=1;
     
316.                 if(!rkey){
     
317.                         kcode++;
     
318.                         if(kcode>KEYDELAY*2){key=2;rkey=1;}
     
319.                 }
     
320.         }else if(lkey){
     
321.                 if(kcode<KEYDELAY/20)key=0;
     
322.                 else if(!rkey)key=1;
     
323.                 lkey=0;
     
324.                 rkey=0;
     
325.                 kcode=0;
     
326.         }
     
327.         if(!key)return;
     
328. 
     
329.                         //------------------setup
     
330.                 if(alarm){alarm=0;alarm_on=0;P1bit|=1;return;}   //turn off alarm
     
331.                
     
332.                 switch(mode){
     
333.                         case 0:                                                                        //12h       
     
334.                                 if(key==2)mode=3;
     
335.                                 else mode=1;
     
336.                                 break;
     
337.                         case 1:                                                                        //24h
     
338.                                 if(key==2)mode=12;else mode=2;
     
339.                                 break;
     
340.                         case 2:                                                                         //second                                                                       
     
341.                                 if(key==2)mode=6;else mode=7;
     
342.                                 break;
     
343.                         case 3:                                                                        //hour setup
     
344.                                 if(key==2)mode=4;else{
     
345.                                         hour++;
     
346.                                         if(hour>23)hour=0;
     
347.                                 }
     
348.                                 break;
     
349.                         case 4:                                                                        //minute setup
     
350.                                 if(key==2){mode=modi?14:0;}else{
     
351.                                         modi=1;
     
352.                                         min++;
     
353.                                         if(min>59)min=0;
     
354.                                 }
     
355.                                 break;
     
356.                         case 5:                                                                        //week setup
     
357.                                 if(key==2){mode=7;}else{
     
358.                                         week++;
     
359.                                         if(week>6)week=0;
     
360.                                 }
     
361.                                 break;
     
362.                         case 6:                                                                        //second setup
     
363.                                 if(key==2){mode=2;}
     
364.                                 else{
     
365.                                         timcnt=TIMCNT;
     
366.                                         if(sec<59)se=0;
     
367.                                         sec=0;
     
368.                                 }
     
369.                                 break;
     
370.                         case 7:                                                                //week
     
371.                                 if(key==2)mode=5;else mode=8;
     
372.                                 break;
     
373.                         case 8:                                                                //alarm
     
374.                                 if(key==2)mode=9;else mode=0;
     
375.                                 break;       
     
376.                         case 9:                                                                //alarm hour setup
     
377.                                 if(key==2)mode=10;else{
     
378.                                         alhour++;
     
379.                                         if(alhour>23)alhour=0;
     
380.                                 }
     
381.                                 break;
     
382.                         case 10:                                                                //alarm min setup
     
383.                                 if(key==2)mode=11;else{
     
384.                                         almin++;
     
385.                                         if(almin>59)almin=0;
     
386.                                 }
     
387.                                 break;
     
388.                         case 11:                                                                //alarm mode setup     0:off  1: week  2:1-5
     
389.                                 if(key==2)mode=8;else{
     
390.                                         almode++;
     
391.                                         if(almode>2)almode=0;
     
392.                                 }
     
393.                                 break;
     
394.                         case 12:                                                                //display bright senser data
     
395.                                 mode=13;
     
396.                                 break;
     
397.                         case 13:                                                                //display MAX RUN DELAY
     
398.                                 mode=15;
     
399.                                 break;
     
400.                         case 14:                                                                //min was set and wait for starting
     
401.                                 modi=0;
     
402.                                 sec=0;se=0;
     
403.                                 timcnt=TIMCNT;
     
404.                                 mode=0;
     
405.                                 break;
     
406.                         case 15:
     
407.                                 alarm_on=0;P1bit|=1;                                        //alarm light check
     
408.                                 mode=1;
     
409.                                 break;
     
410.                         default:
     
411.                                 mode=0;
     
412.                                
     
413.                 }
     
414. 
     
415. }
     
416. 
     
417. main()
     
418. {
     
419.     unsigned char c=0,d=0;
     
420.     bit b;
     
421.     inittimer0();
     
422.     while(1)
     
423.     {
     
424.         PCON|=1;
     
425.                 b=caltim();
     
426.                 if(!power){chkpower();continue;}
     
427.                 LEDscan();
     
428.                 if(b)continue;
     
429.             if(d>maxtl[c]){maxtl[c]=d;}
     
430.                 c++;
     
431.                 switch(c){
     
432.                         case 1:
     
433.                                 if(dot2!=dot){dot2=dot;active=1;}
     
434.                                 chkpower();
     
435.                                 break;
     
436.                         case 2:
     
437.                                 if(active)display();
     
438.                                 break;
     
439.                         case 3:
     
440.                                 if(active)display_dot();
     
441.                                 break;
     
442.                         case 4:
     
443.                                 if(active)bufferproc();
     
444.                                 break;
     
445.                         case 5:
     
446.                                 if(active)alarmlight();
     
447.                                 break;
     
448.                         case 6:
     
449.                                 bright_senser();
     
450.                                 break;
     
451.                         case 7:
     
452.                                 setup();
     
453.                                 break;
     
454.                         case 8:
     
455.                                 active=0;
     
456.                                 c=0;
     
457.                                 break;
     
458.                         default:
     
459.                                 c=0;
     
460.                 }
     
461.             d=TL0;
     
462.     }
     
463. 
     
464. }
     

复制代码

翌阳

程序写得有点怪，朋友们分析分析吧，反正与常规思路不太一样。这个原因也是为了保证计时精度，中断是用定时器自动装载模式的，同时还要保证中断处理程序里的活越少越好，这样在一次中断的时间内就把活干完。但中断会扰乱其它工作，还需要其它的工作也不要被中断所打乱才好，否则会在显示的时候有点点的跳动。主循环也受到中断的影响，主要是利用定时器中断把空闲状态跳出的功能实现的。

再说一点有关闹时的事，其实也可以加进声音的，但考虑两件事：一是实在没有输出端口了，2051本来管脚就不多；二是现在我这儿有个钟控收音机，一直习惯听中央台的播音时醒来，那个自然醒是辅助的，当然定时的时间要提前20分钟到30分钟啊，醒来是需要一定时间的。可别依赖这东西来唤醒你。如果需要，可以自己加个声音的装置，改个程序。

[ 本帖最后由 翌阳 于 2011-1-24 11:57 编辑 ]

翌阳

这是编译后的HEX和BIN文件。

nnn2688

老师这个表真的在桌子上裸了两年啊



那几个照眼睛的LED放哪儿了？

http://web.crystalradio.cn/bbs/thread-60621-1-1.html
http://web.crystalradio.cn/bbs/thread-60122-1-1.html

微调电容的镀膜要当心变黑啊

BTW：您的结石怎么样了？

翌阳

一直没空做机壳。
那个LED弄成了6只了，很亮。就在边上呢，照片没照到。
微调电容是NN年的东西了，已经基本上稳定了。

谢谢您的关心，结石仍然是结石，只要它不堵着就没感觉了。多喝水，少吃草酸多的食物。


制作两周年纪念，又把它晒出来了，等有时间弄个机壳就全部完成了。到时再拿出来晒晒。

[ 本帖最后由 翌阳 于 2011-1-24 12:28 编辑 ]

2051

精度相当高了

lxa000

做位驱动的那8个三极管极性没有画错吧？

[ 本帖最后由 lxa000 于 2011-1-25 19:35 编辑 ]

翌阳

做位驱动的那4个画错了。不好意思，一会儿改过来。

fq967

进来学习一下

7169

我找遍市场，想要买一个这样的成品，但遍寻不得。不知道能否做得轻薄小巧一些，如果行的话，建议斑竹找个厂子代工一下，批量做一些出来，应该是有市场的

xiaomu

年误差在10秒以内
这个是不是和用的晶振 精度高有关系？
不好意思 程序神马 还没认真看一遍就先问问

翌阳

与晶振的稳定度有关，当然也有不稳定因素，但综合起来，一会变正一会变负，总体的误差就不大了。当然与环境温度也会有关系。
其实最主要的晶振的频率校准过，用标准时间台的频率校准过。
晶体的频率越高，误差会越小。

zh68a11

进来学习一下，

tohom2a2

请问楼主.LED数码管是共阳极还是共阴极的?