【参赛】省电的“星光"LED时钟

d3b7

    我曾经有个烂尾工程 旷日持久的制作开始了——家用时钟，快5年过去了，仍旧没有投入实用。
    但卧室确实缺少一个夜里能轻松看清的时钟，于是正儿八经再重做这个项目吧。
    PCB就在厂家做了，当年用感光膜只能做单面工艺，还费时间。改版后，LED仍然在正面，单片机和升压电路就在背面了。这样一块板子搞定。


    上面这个图只带了两个数字的显示，一个钟需要两套显示板，就复制一份好了。控制电路只需要一份公用，所以左右两边的单片机部分只需要装一个。那么为什么我的PCB还布上两份同样的控制呢？这样可以分割成两块用，做99秒倒计时器啥的。



      这个电路不复杂，就是用三只超高亮度的LED来组成数码显示的一个笔段，用4片74HC164作为串-并转换和锁存，构成显示驱动。单片机ATMEGA48作为主控，SPI输出串行显示驱动信号，平时也就半秒种唤醒一次，刷新显示；其余时间单片机都在休眠状态，几乎没有功耗。而用于LED发光的显示耗电情况，取决于LED的性能和电流。

       PCB元旦后收到。



       焊接正面的LED，74HC164等，主要是LED手工焊接很消耗时间……



       焊接MCU主控，调试程序



       基本的程序（完成了走时和时钟调节）

1. #include <avr/io.h>
   
2. #include <avr/interrupt.h>
   
3. #include <avr/sleep.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. 
   
7. /* Current time */
   
8. uint8_t hh=12, mm=0, ss=0;
   
9. char half=0;
   
10. 
    
11. /* Clock parameters */
    
12. uint8_t flag=0;
    
13. uint8_t mode;
    
14. 
    
15. static char brt1, brt2; // button release time
    
16. 
    
17. ISR (TIMER2_COMPA_vect)
    
18. {
    
19.     if(half)
    
20.     {
    
21.         half=0;
    
22. //      PORTD |= _BV(5);
    
23.         ss++;
    
24.         if(ss>59)
    
25.         {
    
26.             ss=0;
    
27.             mm++;
    
28.             if(mm>59)
    
29.             {
    
30.                 mm=0;
    
31.                 hh++;
    
32.                 if(hh>23)
    
33.                     hh=0;
    
34.             }
    
35.         }
    
36.     }
    
37.     else
    
38.     {
    
39.         half=1;
    
40. //      PORTD &= ~_BV(5);
    
41.     }
    
42.     if(brt1>-16)
    
43.         brt1-=16;
    
44.     if(brt2>-16)
    
45.         brt2-=16;
    
46. }
    
47. 
    
48. ISR (PCINT0_vect)
    
49. {
    
50. }
    
51. 
    
52. uint8_t getbutton()
    
53. {
    
54.     static char bs1, bs2;   // button state
    
55.     static char bh1, bh2;   // button hold time
    
56.     char button=PINB;
    
57.     char tick=TCNT2;
    
58.     char state=0;
    
59.    
    
60.     if(!bs1)
    
61.     {
    
62.         if(button&1)    // button 1 release
    
63.         {
    
64.             bs1=1;
    
65.             brt1=tick;
    
66.             bh1=0;
    
67.         }
    
68.         else
    
69.         {
    
70.             if(tick==0)
    
71.                 bh1++;
    
72.         }
    
73.         if(bh1>5)
    
74.             state|=4;
    
75.     }
    
76.     else
    
77.     {
    
78.         if(!(button&1)) // button 1 press
    
79.         {
    
80.             bs1=0;
    
81.             if(tick-brt1>3) // valid key
    
82.                 state|=1;
    
83.         }
    
84.     }
    
85. 
    
86.     if(!bs2)
    
87.     {
    
88.         if(button&2)    // button 2 release
    
89.         {
    
90.             bs2=1;
    
91.             brt2=tick;
    
92.         }   
    
93.         else
    
94.         {
    
95.             if(tick==0)
    
96.                 bh2++;
    
97.         }
    
98.         if(bh2>5)
    
99.             state|=8;
    
100. 
     
101.     }
     
102.     else
     
103.     {
     
104.         if(!(button&2)) // button 2 press
     
105.         {
     
106.             bs2=0;
     
107.             if(tick-brt2>3) // valid key
     
108.                 state|=2;
     
109.         }
     
110.     }
     
111.     return state;
     
112. }
     
113. 
     
114. const char digdisp[16]=
     
115. {
     
116.     0x02,   //0 xxxx xx.h
     
117.     0x7a,   //1 x... .x.h
     
118.     0x90,   //2 .xx. xxxh
     
119.     0x30,   //3 xx.. xxxh
     
120.     0x68,   //4 x..x .xxh
     
121.     0x24,   //5 xx.x x.xh
     
122.     0x04,   //6 xxxx x.xh
     
123.     0x72,   //7 x... xx.h
     
124.     0x00,   //8 xxxx xxxh
     
125.     0x20,   //9 xx.x xxxh
     
126.     0xfc,   // '-' symbol
     
127.     0xfe    // blank
     
128. /*  0x40,   //A x.xx xxxh
     
129.     0x0c,   //b xxxx ..xh
     
130.     0x86,   //C .xxx x..h
     
131.     0x18,   //d xxx. .xxh
     
132.     0x84,   //E .xxx x.xh
     
133.     0xc4    //F ..xx x.xh  */
     
134. };
     
135. 
     
136. inline void nop(void)
     
137. {
     
138.     __asm__ volatile("nop");
     
139. }
     
140. 
     
141. #define HHMM 8
     
142. #define MMSS 9
     
143. 
     
144. 
     
145. void display()
     
146. {   
     
147.     uint8_t l,h;
     
148.     uint8_t colon;
     
149.     uint8_t b4,b3,b2,b1;
     
150. 
     
151.     if(flag & 0x01)
     
152.         colon=0;
     
153.     else
     
154.         colon=1;
     
155.     if(flag & 0x02)
     
156.     {
     
157.         switch(mode)
     
158.         {
     
159.             case HHMM:
     
160.                 h=(mm*26)>>8;
     
161.                 l=mm-10*h;
     
162.                 break;
     
163.             case MMSS:
     
164.                 h=(ss*26)>>8;
     
165.                 l=ss-10*h;
     
166.                 break;
     
167.             default:
     
168.                 h=10;
     
169.                 l=10;
     
170.                 break;
     
171.         }
     
172.     }
     
173.     else
     
174.     {
     
175.         h=11;
     
176.         l=11;
     
177.     }
     
178.     b4=digdisp[l];
     
179.     b3=digdisp[h]|colon;
     
180.     if(flag & 0x04)
     
181.     {
     
182.         switch(mode)
     
183.         {
     
184.             case HHMM:
     
185.                 if(hh<10)
     
186.                 {
     
187.                     h=11;
     
188.                     l=hh;
     
189.                 }
     
190.                 else
     
191.                 {
     
192.                     h=(hh*26)>>8;
     
193.                     l=hh-10*h;
     
194.                 }
     
195.                 break;
     
196.             case MMSS:
     
197.                 h=(mm*26)>>8;
     
198.                 l=mm-10*h;
     
199.                 break;
     
200.             default:
     
201.                 h=10;
     
202.                 l=10;
     
203.                 break;
     
204.         }
     
205.     }
     
206.     else
     
207.     {
     
208.         h=11;
     
209.         l=11;
     
210.     }
     
211.     b2=digdisp[l];
     
212.     b1=digdisp[h];
     
213. 
     
214.     SPDR=b4;
     
215.     while(!(SPSR & _BV(SPIF)));
     
216.     SPDR=b3|colon;
     
217.     while(!(SPSR & _BV(SPIF)));
     
218.     SPDR=b2;
     
219.     while(!(SPSR & _BV(SPIF)));
     
220.     SPDR=b1;
     
221.     while(!(SPSR & _BV(SPIF)));
     
222. }
     
223. 
     
224. int main()
     
225. {
     
226.     int i;
     
227.     // set sysclk prescaler
     
228.     CLKPR=_BV(CLKPCE);
     
229.     CLKPR=0;    // no div
     
230.     nop();
     
231.     nop();
     
232.     nop();
     
233.     nop();
     
234.     nop();
     
235.    
     
236.    
     
237.     // configure Timer 2        
     
238.     ASSR=_BV(AS2);  // asynchronous clock osc
     
239.     TCCR2A=_BV(WGM21);  // Timer2 CTC mode, TOP as OCRA
     
240.     OCR2A=15;
     
241.     TCCR2B=_BV(CS22)|_BV(CS21)|_BV(CS20);   // enable, clk/1024
     
242.     TIFR2=_BV(OCF2A);   // clear flag
     
243.     TIMSK2=_BV(OCIE2A); // enable interrupt
     
244.     sei();
     
245.    
     
246.     // configure SPI
     
247.     DDRB=_BV(2)|_BV(3)|_BV(5);  // SPI output pin, SS must be output
     
248.     SPSR=_BV(SPI2X);
     
249.     SPCR=_BV(SPE)|_BV(MSTR)|_BV(CPHA);  // Fastest SPI
     
250.    
     
251.     set_sleep_mode(SLEEP_MODE_IDLE);
     
252.    
     
253.     DDRD=_BV(5)|_BV(2); //PD5: Status (BLUE), PD5: DC-DC EN
     
254.     PORTD=_BV(2);   // DC-DC on
     
255.     PORTB |= _BV(0)|_BV(1); // button 1, 2
     
256.    
     
257.     flag=7;
     
258.     display();
     
259.     sleep_mode();   // wait until RTC oscillator is stable
     
260.     set_sleep_mode(SLEEP_MODE_PWR_SAVE);
     
261. 
     
262.     PCICR=_BV(PCIE0);   // Pin-change interrupt 0
     
263.     PCMSK0=_BV(PCINT0)|_BV(PCINT1);
     
264.     PCIFR=_BV(PCIF0);
     
265.    
     
266.     mode=HHMM;
     
267.     for(;;)
     
268.     {
     
269.         static char phalf=3;
     
270.         char b;
     
271.         char show=0;
     
272.         static char adjust=0;
     
273.         char update=0;
     
274. 
     
275.         if(phalf!=half)
     
276.         {
     
277.             show=1;
     
278.             phalf=half;
     
279.         }
     
280. 
     
281.         b=getbutton();
     
282.         if(adjust==0)
     
283.         {
     
284.             if(b&2)
     
285.             {
     
286.                 if(mode==HHMM)
     
287.                     mode=MMSS;
     
288.                 else
     
289.                     mode=HHMM;
     
290.                 show=1;
     
291.             }
     
292.             else
     
293.             {
     
294.                 if((b&12)==4)   // button 1 Hold
     
295.                 {
     
296.                     set_sleep_mode(SLEEP_MODE_IDLE);    // change back later
     
297.                     if(mode==HHMM)
     
298.                         adjust=1;
     
299.                     else
     
300.                         adjust=3;
     
301.                     show=1;
     
302.                 }
     
303.             }
     
304.         }
     
305.         else
     
306.         {
     
307.             switch(adjust)
     
308.             {
     
309.                 case 1:     // adjust Minute
     
310.                 if(b&2)
     
311.                 {
     
312.                     mm++;
     
313.                     if(mm>59)
     
314.                         mm=0;
     
315.                     update=1;
     
316.                 }
     
317.                 else
     
318.                     if(b&1)
     
319.                     {
     
320.                         adjust=2;
     
321.                         show=1;
     
322.                     }
     
323.                 break;
     
324.                 case 2:     // adjust Hour
     
325.                 if(b&2)
     
326.                 {
     
327.                     hh++;
     
328.                     if(hh>23)
     
329.                         hh=0;
     
330.                     update=1;
     
331.                 }
     
332.                 else
     
333.                     if(b&1)
     
334.                     {
     
335.                         adjust=0;
     
336.                         set_sleep_mode(SLEEP_MODE_PWR_SAVE);
     
337.                         show=1;
     
338. 
     
339.                     }
     
340.                 break;
     
341.                 case 3:     // adjust Second
     
342.                 if(b&2)
     
343.                 {
     
344.                     ss=0;
     
345.                     TCNT2=0;
     
346.                     half=0;
     
347.                     update=1;
     
348.                 }
     
349.                 else
     
350.                     if(b&1)
     
351.                     {
     
352.                         adjust=0;
     
353.                         set_sleep_mode(SLEEP_MODE_PWR_SAVE);
     
354.                         show=1;
     
355.                     }
     
356.                 break;
     
357.             }
     
358.             if(update)
     
359.                 show=1;
     
360.         }
     
361.         
     
362.                
     
363.         if(mode==HHMM && half==0)
     
364.         {
     
365.             flag |= 0x01;
     
366.         }
     
367.         else
     
368.         {
     
369.             flag &= ~0x01;
     
370.         }
     
371.         
     
372.         if(half==0 || update)
     
373.         {
     
374.             flag |= 0x06;
     
375.         }
     
376.         else
     
377.         {
     
378.             if(adjust==1 || adjust==3)
     
379.                 flag &= ~0x02;
     
380.             if(adjust==2)
     
381.                 flag &= ~0x04;
     
382.         }
     
383.         
     
384.         if(show)
     
385.             display();
     
386. 
     
387.         sleep_mode();
     
388. 
     
389.     }
     
390.    
     
391. 
     
392. }
     

复制代码

相对于传统的LED钟来说，这个是相当省电：1节3.2V的磷酸铁锂电池供电时，总电流大约1mA~1.1mA之间


       当然，这个电流下不可能觉得亮，强光下就很难看出来了。台灯下勉强能识别。


        做这个钟我是给卧室用的，暗光环境下足够亮了，关了灯就觉得很亮了。


       其实我还设计了亚克力的面板，只是没有做绿色亚克力的，所以颜色不搭，暂时没安装。

补充内容 (2016-2-16 20:56):
又做了一个蓝色LED的，加上亚克力面板。
[attachimg]6101171[/attachimg]

bluegrass

不错不错，比我的大很多，可以考虑加入授时系统哦，有单片机就比较简单了。

正直电子

牛！比我用数码管做的好看，而且经济

gd4424

佩服动手能力强,我一直都想做一个可编程不熟悉

d3b7

今天又焊了一块，使用蓝色LED。 同等电流下蓝色的亮度不及如翠绿色的。

szshly

白天不能用吗？

ckc

很漂亮！
亮度有些差异，美中不足。
总电流这么小？才1mA多点？

d3b7

szshly 发表于 2016-2-17 08:08
白天不能用吗？

LED电流需要根据环境光线强度设定（可以加光敏元件自动调节）
白天室内很亮的话，需要把电流调大，就不那么省电了。

d3b7

ckc 发表于 2016-2-17 12:03
很漂亮！
亮度有些差异，美中不足。
总电流这么小？才1mA多点？

亮度和颜色不均匀是因为LED的离散性，如果买来先筛选一下的话可以做得好些。
没错，总电流1mA多晚上足够亮了。翠绿色LED效率很高，每只LED的电流数十微安级就够了。

huarana

我也一直有这个想法。


不过要加入授时 哦 ，不加授时的话  要用 ds3231这类高精度的

lxa000

d3b7 发表于 2016-2-17 15:09
亮度和颜色不均匀是因为LED的离散性，如果买来先筛选一下的话可以做得好些。
没错，总电流1mA多晚上足够 ...

还是用数码管效果好

HYLG

我做的是白光的可以当照明用的.每段6个LED.
PCB画好了还没做板.等有空了做出来也来晒一下.

xinglong1115

做的不错，以前也做过不少LED/LCD的电子时钟，但是精度是个不好解决的问题，都成了摆设

LI192721

楼主，可以卖了，我们需要