标题: 51单片机+SL041MG VFD显示屏时钟制作资料 源码与电路图都有 [打印本页]

---

作者: zubingming    时间: 2018-5-16 22:17
标题: 51单片机+SL041MG VFD显示屏时钟制作资料 源码与电路图都有
主控用的STC15W408AS，时钟芯片用带温度补偿功能的R8025T，以前用了不少精度也还不错。VFD用SL041MG,驱动用了比较常见的PT6312。电源直接用MicroUSB数据线连接手机充电器等供电。
遥控手动调节，一组闹钟，亮度自动手动控制，掉电记忆等，由于时间关系暂未加入年月日温度等轮回显示

用SL041MG 制作VFD显示屏时钟


电路原理图如下：


SL041MG VFD R8025单片机源程序如下:

1. //SL041MG VFD 小琼数码 2018-2-6 V1.0 无温度
   
2. //PT6312+STC15W408AS+R8025T
   
3. #include<STC15.h>
   
4. #include<intrins.h>
   
5. #define uint  unsigned int
   
6. #define uchar unsigned char
   
7. #include"IIC.h"                                //IIC驱动
   
8. #include"PT6312.H"                        //VFD驱动
   
9. #include"NEC6121.h"                        //遥控解码
   
10. #include"STC_ADC.h"                        //内部ADC
    
11. #include"STC_EEPROM1T.h"        //内部EEPROM
    
12. 
    
13.                                 //           0        1         2    3    4    5     6   7     8   9    a          b           c    d    e    f           -        空         H          L            P         U
    
14. uchar code table[] = {0x7d,0x05,0x6e,0x4f,0x17,0x5b,0x7b,0x0d,0x7f,0x5f,0x3f,0x73,0x78,0x67,0x7a,0x3a,0x02,0x00,0x37,0x70,0x3a,0x75}; //0~9显示代码
    
15. 
    
16. sbit beep    = P5^5;   //蜂鸣器  
    
17. sbit kaiping = P3^2;   //开关屏
    
18. 
    
19. sbit k1      = P1^5;   //按键1
    
20. sbit k2      = P1^3;   //按键2
    
21. bit kk1=0,kk2;                   //按键标志
    
22. 
    
23. uchar tiao;           //调整
    
24. uint fan;           //自动返回
    
25. uint liangcai; //光控采集间隔
    
26. uchar shan;           //秒点闪
    
27. uchar beeshu;  //beep计时用
    
28. bit nao=0;           //闹钟标志 0 不响  1 响
    
29. char naoshi=0,naofen=0; //闹钟时间
    
30. uchar naoji=0;                 //闹钟计数
    
31. uchar guanji=0;                 //待机
    
32. uchar naokaiguan=0;         //闹钟开关
    
33. uchar zishou=0;                 //自动手动亮度
    
34. char shoushu=0;          //手动亮度数值 0-7
    
35. char liangdu=5;                 //亮度实际数值
    
36. 
    
37. char hour,minute,second;     //时间
    
38. uchar disp[5]={0,0,0,0,0};   //显示缓存
    
39. 
    
40. uchar liangshu;    //亮度ADC
    
41. #define liang1 50  //可以修改亮度数据
    
42. #define liang2 70
    
43. #define liang3 100
    
44. #define liang4 120
    
45. #define liang5 150
    
46. #define liang6 170
    
47. #define liang7 200
    
48. 
    
49. void delay(uint z)           //延时子程序 约1MS
    
50. {
    
51.    uint x,y;
    
52.    for(x=z;x>0;x--)
    
53.    for(y=1000;y>0;y--);
    
54. }
    
55. 
    
56. void init()          //初使化
    
57. {   
    
58.    delay(100);
    
59.    P3M0=0x04;    //P3.2强上拉
    
60.    P3M1=0x00;
    
61.    init_IIC();   //IIC初使化       
    
62. 
    
63.    
    
64.     AUXR |=        0x80;//Timer0 1T Timer1 12T
    
65.         EA=1;        //开总中断
    
66.     ET0=1;       //开定时器0中断
    
67.         TMOD=0x00;         //定时器0,1模式0 自动重装
    
68.         TL0                =        T125US;                        //Initial timer0 low byte
    
69.         TH0                =        T125US>>8;                //Initial timer0 high byte
    
70.     TR0=1;                //开定时器0运行       
    
71. 
    
72.         AUXR &= 0xFB;        //定时器时钟12T模式
    
73.         T2L = 0x00;                //设置定时初值
    
74.         T2H = 0xB8;                //设置定时初值
    
75.         AUXR |= 0x10;        //定时器2开始计时
    
76.         IE2|=0x04;                //开定时器2中断
    
77. 
    
78.         PT6312_1(); //设置显示方式 8位20段
    
79.     PT6312_2(); //数据设定 写显存 固定地址 正常模式
    
80.         beep=0;
    
81.         delay(100);
    
82.         beep=0;
    
83. 
    
84.            guanji=STC_read(0x0000);
    
85.            if(guanji>1)
    
86.            {
    
87.                     guanji=1;
    
88.                  STC_del(0x0000);
    
89.                  STC_write(0x0000,guanji);
    
90.            }
    
91.        
    
92.                    naokaiguan=STC_read(0x0200);
    
93.            if(naokaiguan>1)
    
94.            {
    
95.                     naokaiguan=0;
    
96.                  STC_del(0x0200);
    
97.                  STC_write(0x0200,naokaiguan);
    
98.            }
    
99.        
    
100.                 naoshi=STC_read(0x0400);
     
101.            if(naoshi>23)
     
102.            {
     
103.                     naoshi=8;
     
104.                  STC_del(0x0400);
     
105.                  STC_write(0x0400,naoshi);
     
106.            }
     
107.        
     
108.                 naofen=STC_read(0x0600);
     
109.            if(naofen>59)
     
110.            {
     
111.                     naofen=0;
     
112.                  STC_del(0x0600);
     
113.                  STC_write(0x0600,naofen);
     
114.            }
     
115.        
     
116.                    zishou=STC_read(0x0800);
     
117.            if(zishou>1)
     
118.            {
     
119.                     zishou=0;
     
120.                  STC_del(0x0800);
     
121.                  STC_write(0x0800,zishou);
     
122.            }
     
123.        
     
124.                 shoushu=STC_read(0x0A00);
     
125.            if(shoushu>7)
     
126.            {
     
127.                     shoushu=5;
     
128.                  STC_del(0x0A00);
     
129.                  STC_write(0x0A00,shoushu);
     
130.            }
     
131. }
     
132. 
     
133. void read_RX8025()          //读时期和时间
     
134. {
     
135.        uchar dat1,dat2,number;
     
136.        number=read_IIC(RX8025,0);
     
137.        dat1=number&0x7f;
     
138.        dat2=dat1/16;                           //数据进制转换
     
139.        dat1=dat1%16;                         //十六进制转十进制
     
140.        dat1=dat1+dat2*10;
     
141.        second=dat1;
     
142. 
     
143.        number=read_IIC(RX8025,1);
     
144.        dat1=number&0x7f;
     
145.        dat2=dat1/16;                           //数据进制转换
     
146.        dat1=dat1%16;                         //十六进制转十进制
     
147.        dat1=dat1+dat2*10;
     
148.        minute=dat1;
     
149. 
     
150.        number=read_IIC(RX8025,2);
     
151.        dat1=number&0x3f;
     
152.        dat2=dat1/16;                           //数据进制转换
     
153.        dat1=dat1%16;                         //十六进制转十进制
     
154.        dat1=dat1+dat2*10;
     
155.        hour=dat1;
     
156. }
     
157. 
     
158. void huancun()           //显示数据送入缓存
     
159. {                                
     
160.   switch(tiao)
     
161.            {
     
162.             case 0:           //平时显示
     
163.             if((hour/10)==0)
     
164.                 disp[0]=17;
     
165.                 else
     
166.                   disp[0]=hour/10;
     
167.                 disp[1]=hour%10;
     
168.                 if(shan<25)
     
169.                 disp[2]=0x44;
     
170.                 else
     
171.                 disp[2]=0x00;
     
172.                 disp[3]=minute/10;
     
173.                 disp[4]=minute%10;
     
174.        
     
175.                 break;
     
176.                    case 1:           //调整小时
     
177.                 if(shan<25)
     
178.                 {
     
179.                   disp[0]=hour/10;
     
180.                 disp[1]=hour%10;
     
181.                 disp[2]=0x44;
     
182.                 }
     
183.                 else
     
184.                 {
     
185.                   disp[0]=17;
     
186.                 disp[1]=17;
     
187.                 disp[2]=0;
     
188.                 }
     
189.                 disp[3]=minute/10;
     
190.                 disp[4]=minute%10;
     
191.                 break;           //调整分钟
     
192.             case 2:
     
193.                   disp[0]=hour/10;
     
194.                 disp[1]=hour%10;
     
195.                 if(shan<25)
     
196.                 {
     
197.                 disp[2]=0x44;
     
198.                 disp[3]=minute/10;
     
199.                 disp[4]=minute%10;
     
200.                 }
     
201.                 else
     
202.                 {
     
203.                 disp[2]=0;
     
204.                 disp[3]=17;
     
205.                 disp[4]=17;
     
206.                 }
     
207.                 break;
     
208.                 case 3:          //调整秒
     
209.                 disp[0]=17;
     
210.                 disp[1]=17;
     
211.                 if(shan<25)
     
212.                 disp[2]=0x44;
     
213.                 else
     
214.                 disp[2]=0x00;
     
215.                 disp[3]=second/10;
     
216.                 disp[4]=second%10;
     
217.                 break;
     
218.                 case 4:                //闹钟开关
     
219.                   disp[0]=10;
     
220.                 disp[1]=19;
     
221.                 disp[2]=0x40;
     
222.                 if(shan<25)
     
223.                 {
     
224.                         if(naokaiguan)
     
225.                         {
     
226.                         disp[3]=1;
     
227.                         disp[4]=1;
     
228.                         }
     
229.                         else
     
230.                         {
     
231.                         disp[3]=0;
     
232.                         disp[4]=15;
     
233.                         }
     
234.                 }
     
235.                 else
     
236.                 {
     
237.                 disp[3]=17;
     
238.                 disp[4]=17;
     
239.                 }
     
240.                 break;
     
241.                    case 5:                //闹钟小时
     
242.                 if(shan<25)
     
243.                 {
     
244.                   disp[0]=naoshi/10;
     
245.                 disp[1]=naoshi%10;
     
246.                 }                       
     
247.                 else
     
248.                 {
     
249.                   disp[0]=17;
     
250.                 disp[1]=17;
     
251.                 }
     
252.                 disp[2]=0x04;
     
253.                 disp[3]=naofen/10;
     
254.                 disp[4]=naofen%10;
     
255.                 break;
     
256.             case 6:            //闹钟分钟
     
257.                   disp[0]=naoshi/10;
     
258.                 disp[1]=naoshi%10;
     
259.                 disp[2]=0x04;
     
260.                 if(shan<25)
     
261.                 {
     
262.                 disp[3]=naofen/10;
     
263.                 disp[4]=naofen%10;
     
264.                 }
     
265.                 else
     
266.                 {
     
267.                 disp[3]=17;
     
268.                 disp[4]=17;
     
269.                 }
     
270.                 break;
     
271.                 case 7:                //自动手动亮度
     
272.                 disp[0]=19;
     
273.                 disp[1]=19;
     
274.                 disp[2]=0x40;
     
275.                 if(shan<25)
     
276.                 {
     
277.                         if(zishou)
     
278.                         {
     
279.                         disp[3]=5;
     
280.                         disp[4]=13;
     
281.                         }
     
282.                         else
     
283.                            {
     
284.                         disp[3]=10;
     
285.                         disp[4]=21;
     
286.                         }
     
287.                 }
     
288.                 else
     
289.                 {
     
290.                 disp[3]=17;
     
291.                 disp[4]=17;
     
292.                 }
     
293.                 break;
     
294.                 case 8:                //手动亮度数
     
295.                   disp[0]=5;
     
296.                 disp[1]=13;
     
297.                 disp[2]=0x40;
     
298.                 if(shan<25)
     
299.                 {
     
300.                 disp[3]=0;
     
301.                 disp[4]=shoushu;
     
302.                 }
     
303.                 else
     
304.                 {
     
305.                 disp[3]=17;
     
306.                 disp[4]=17;
     
307.                 }
     
308.                 break;          
     
309.            }
     
310. }
     
311. 
     
312. void display()                //送显示数据
     
313. {          
     
314.                   PT6312_3();
     
315.             write_PT6312(table[disp[4]]);      
     
316.             write_PT6312(0x00);      
     
317.           
     
318.             write_PT6312(table[disp[3]]);      
     
319.             write_PT6312(0x00);      
     
320. 
     
321.               write_PT6312(disp[2]);
     
322.             write_PT6312(0x00);      
     
323. 
     
324.             write_PT6312(table[disp[1]]);      
     
325.             write_PT6312(0x00);      
     
326. 
     
327.             write_PT6312(table[disp[0]]);        
     
328.             write_PT6312(0x00);      
     
329.          
     
330.                    PT6312_4(liangdu);     
     
331. }
     
332. 
     
333. void yaokong()          //遥控功能
     
334. {
     
335.                  if(IR_code==daiji)
     
336.                 {
     
337.                           if(guanji==0) guanji=1;
     
338.                           else if(guanji==1)
     
339.                                   {
     
340.                                   guanji=0;
     
341.                                   tiao=0;
     
342.                                   }
     
343.                           STC_del(0x0000);
     
344.                           STC_write(0x0000,guanji);
     
345.                   beep=0;
     
346.                 }
     
347.                 if(guanji)
     
348.                 {
     
349.                          if(IR_code==xiaoshi)
     
350.                         {
     
351.                           tiao++;
     
352.                           if(tiao>=9)
     
353.                           {
     
354.                           tiao=0;
     
355.                           beep=0;
     
356.                           delay(100);
     
357.                           }
     
358.                           beep=0;
     
359.                           fan=0;
     
360.                         }
     
361.                          if(IR_code==jing)
     
362.                         {
     
363.                           nao=0;
     
364.                           naoji=0;
     
365.                           beep=0;                 
     
366.                         }
     
367.                         if(tiao!=0)
     
368.                         {
     
369.                          if(IR_code==jia)
     
370.                                 {
     
371.                                   switch(tiao)
     
372.                                           {
     
373.                                             case 1:
     
374.                                           hour++;
     
375.                                           if(hour>=24)
     
376.                                           hour=0;
     
377.                                           write_IIC(RX8025,2,(hour/10)<<4|(hour%10));
     
378.                                           break;
     
379.                                             case 2:
     
380.                                           minute++;
     
381.                                           if(minute>=60)
     
382.                                           minute=0;
     
383.                                           write_IIC(RX8025,1,(minute/10)<<4|(minute%10));
     
384.                                           break;
     
385.                                           case 3:
     
386.                                           second++;
     
387.                                           if(second>=60)
     
388.                                           second=0;
     
389.                                           write_IIC(RX8025,0,(second/10)<<4|(second%10));
     
390.                                           break;
     
391.                                           case 4:
     
392.                                           if(naokaiguan==0) naokaiguan=1;
     
393.                                           else if(naokaiguan==1) naokaiguan=0;
     
394.                                           STC_del(0x0200);
     
395.                                           STC_write(0x0200,naokaiguan);
     
396.                                           break;
     
397.                                           case 5:
     
398.                                           naoshi++;
     
399.                                           if(naoshi>23)
     
400.                                           naoshi=0;
     
401.                                           STC_del(0x0400);
     
402.                                           STC_write(0x0400,naoshi);
     
403.                                           break;
     
404.                                           case 6:
     
405.                                           naofen++;
     
406.                                           if(naofen>59)
     
407.                                           naofen=0;
     
408.                                           STC_del(0x0600);
     
409.                                           STC_write(0x0600,naofen);
     
410.                                           break;
     
411.                                           case 7:
     
412.                                           if(zishou==0) zishou=1;
     
413.                                           else if(zishou==1) zishou=0;
     
414.                                           STC_del(0x0800);
     
415.                                           STC_write(0x0800,zishou);
     
416.                                           break;
     
417.                                           case 8:
     
418.                                           shoushu++;
     
419.                                           if(shoushu>=8)
     
420.                                           shoushu=0;
     
421.                                           STC_del(0x0A00);
     
422.                                       STC_write(0x0A00,shoushu);
     
423.                                           break;
     
424.                                   }
     
425.                                  beep=0;
     
426.                                   fan=0;
     
427.                                 }
     
428.        
     
429.                            if(IR_code==jian)
     
430.                                 {
     
431.                                   switch(tiao)
     
432.                                           {
     
433.                                            case 1:
     
434.                                           hour--;
     
435.                                           if(hour<0)
     
436.                                           hour=23;
     
437.                                           write_IIC(RX8025,2,(hour/10)<<4|(hour%10));
     
438.                                           break;
     
439.                                             case 2:
     
440.                                           minute--;
     
441.                                           if(minute<0)
     
442.                                           minute=59;
     
443.                                           write_IIC(RX8025,1,(minute/10)<<4|(minute%10));
     
444.                                           break;
     
445.                                           case 3:
     
446.                                           second--;
     
447.                                           if(second<0)
     
448.                                           second=59;
     
449.                                           write_IIC(RX8025,0,(second/10)<<4|(second%10));
     
450.                                           break;
     
451.                                           case 4:
     
452.                                           if(naokaiguan==0) naokaiguan=1;
     
453.                                           else if(naokaiguan==1) naokaiguan=0;
     
454.                                           STC_del(0x0200);
     
455.                                           STC_write(0x0200,naokaiguan);
     
456.                                           break;
     
457.                                           case 5:
     
458.                                           naoshi--;
     
459.                                           if(naoshi<0)
     
460.                                           naoshi=23;
     
461.                                           STC_del(0x0400);
     
462.                                           STC_write(0x0400,naoshi);
     
463.                                           break;
     
464.                                           case 6:
     
465.                                           naofen--;
     
466.                                           if(naofen<0)
     
467.                                           naofen=59;
     
468.                                           STC_del(0x0600);
     
469.                                           STC_write(0x0600,naofen);
     
470.                                           break;
     
471.                                           case 7:
     
472.                                           if(zishou==0) zishou=1;
     
473.                                           else if(zishou==1) zishou=0;
     
474.                                           STC_del(0x0800);
     
475.                                           STC_write(0x0800,zishou);
     
476.                                           break;
     
477.                                           case 8:
     
478.                                           shoushu--;
     
479.                                           if(shoushu<0)
     
480.                                           shoushu=7;
     
481.                                           STC_del(0x0A00);
     
482.                                       STC_write(0x0A00,shoushu);
     
483.                                           break;
     
484.                                               }
     
485.                                   beep=0;
     
486.                                   fan=0;
     
487.                                 }
     
488.                         }
     
489.                 }
     
490. }       
     
491.           
     
492. void keyscan()
     
493. {
     
494.   
     
495.      if(!k1)
     
496.      kk1=1;
     
497.      if(kk1&&k1)
     
498.          {
     
499.                   if(guanji==0)
     
500.                   {
     
501.                     tiao=0;
     
502.                     guanji=1;
     
503.                         beep=0;
     
504.                         STC_del(0x0000);
     
505.                         STC_write(0x0000,guanji);
     
506.                   }
     
507.                   else if(nao==1)
     
508.                                   {
     
509.                                           naoji=0;
     
510.                                         nao=0;
     
511.                                   }
     
512.                           else
     
513.                                   {
     
514.                                   tiao++;
     
515.                                           if(tiao>=9)
     
516.                                           {
     
517.                                                  tiao=0;
     
518.                                                  beep=0;
     
519.                                                  delay(100);
     
520.                                           }
     
521.                                   }
     
522.                           beep=0;
     
523.                           kk1=0;
     
524.                           fan=0;
     
525.                          
     
526.          }
     
527. 
     
528.          if(guanji==1)
     
529.          {
     
530.          if(!k2)
     
531.      kk2=1;
     
532.      if(kk2&&k2)
     
533.          {
     
534.                      if(nao==1)
     
535.                   {
     
536.                           naoji=0;
     
537.                         nao=0;
     
538.                   }
     
539.           else
     
540.           {
     
541.               switch(tiao)
     
542.                   {
     
543.                     case 1:
     
544.                   hour++;
     
545.                   if(hour>=24)
     
546.                   hour=0;
     
547.                   write_IIC(RX8025,2,(hour/10)<<4|(hour%10));
     
548.                   break;
     
549.                     case 2:
     
550.                   minute++;
     
551.                   if(minute>=60)
     
552.                   minute=0;
     
553.                   write_IIC(RX8025,1,(minute/10)<<4|(minute%10));
     
554.                   break;
     
555.                   case 3:
     
556.                   second++;
     
557.                   if(second>=60)
     
558.                   second=0;
     
559.                   write_IIC(RX8025,0,(second/10)<<4|(second%10));
     
560.                   break;
     
561.                   case 4:
     
562.                   if(naokaiguan==0) naokaiguan=1;
     
563.                   else if(naokaiguan==1) naokaiguan=0;
     
564.                   STC_del(0x0200);
     
565.                   STC_write(0x0200,naokaiguan);
     
566.                   break;
     
567.                   case 5:
     
568.                   naoshi++;
     
569.                   if(naoshi>23)
     
570.                   naoshi=0;
     
571.                   STC_del(0x0400);
     
572.                   STC_write(0x0400,naoshi);
     
573.                   break;
     
574.                   case 6:
     
575.                   naofen++;
     
576.                   if(naofen>59)
     
577.                   naofen=0;
     
578.                   STC_del(0x0600);
     
579.                   STC_write(0x0600,naofen);
     
580.                   break;
     
581.                   case 7:
     
582.                   if(zishou==0) zishou=1;
     
583.                   else if(zishou==1) zishou=0;
     
584.                   STC_del(0x0800);
     
585.                   STC_write(0x0800,zishou);
     
586.                   break;
     
587.                   case 8:
     
588.                   shoushu++;
     
589.                   if(shoushu>=8)
     
590.                   shoushu=0;
     
591.                   STC_del(0x0A00);
     
592.               STC_write(0x0A00,shoushu);
     
593.                   break;
     
594.               }
     
595.           }
     
596.           beep=0;
     
597.           kk2=0;
     
598.           fan=0;
     
599.           }
     
600.          }
     
601. }  
     
602.   
     
603. void main()
     
604. {
     
605.           init();         //初使化
     
606.         init_ADC();         //ADC初使化
     
607.                                             
     
608.         while(1)
     
609.         {       
     
610.            if(tiao!=0)                 //自动返回
     
611.            {
     
612.                fan++;
     
613.                    if(fan>400)
     
614.                    {
     
615.                     fan=0;
     
616.                         tiao=0;
     
617.                         beep=0;
     
618.                         delay(100);
     
619.                         beep=0;
     
620.                    }
     
621.            }
     
622. 
     
623.                   keyscan(); //按键扫描
     
624.                     
     
625.                 if(jie)        //红外线遥控数据解码
     
626.                 {
     
627.                 yaokong();                       
     
628.                     jie        =0;
     
629.                 }
     
630. 
     
631.     liangcai++;
     
632.         if(liangcai>300)
     
633. ……………………
     
634. 
     
635. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

所有资料51hei提供下载:
用51单片机制作VFD显示屏时钟.rar (1.16 MB, 下载次数: 148)

2018-5-16 22:17 上传

点击文件名下载附件
用51单片机制作VFD显示屏时钟
下载积分: 黑币 -5

---

作者: 闫Sir    时间: 2018-11-29 23:43
怎么这么好的帖子竟然没有顶 的
楼主高手，希望多多分享有关资料

---

作者: 守缺1111    时间: 2018-11-30 18:49
顶一下楼主，非常赞！

---

作者: mj8abcd    时间: 2019-1-23 16:25
谢谢分享！！！！！

---

作者: 涟漪依    时间: 2019-9-17 01:23
这么好的贴子定起来了

---

作者: liangdong1    时间: 2020-3-9 10:22

这么好的贴子顶起来了

---

作者: 王绪    时间: 2020-10-25 08:51
这帖子真好

---

作者: Len51    时间: 2021-4-7 20:09
VFD如何点亮?需要怎样供电？

---

作者: lpcyh    时间: 2021-10-27 11:22
非常需要，现在已经很少见了

---

作者: gxjhgxjh    时间: 2022-11-13 14:57
好资料下载了，谢谢楼主了！

---

作者: 雨蝶的伤    时间: 2023-4-3 17:42
正想学习怎么点亮VFD屏，就看到这资料了，感谢大佬

---

作者: fhwong66    时间: 2024-6-17 09:27
好资料下载了，谢谢楼主了！

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1