设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机DIY制作 › 51单片机+SL041MG VFD显示屏时钟制作资料 源码与电路图 ...
返回列表 发新帖
查看: 10918|回复: 10
打印 上一主题 下一主题
收起左侧

51单片机+SL041MG VFD显示屏时钟制作资料 源码与电路图都有

  [复制链接]
跳转到指定楼层
楼主
ID:93248 发表于 2018-5-16 22:17 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
主控用的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

  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显示代码

  16. sbit beep    = P5^5;   //蜂鸣器  
  17. sbit kaiping = P3^2;   //开关屏

  19. sbit k1      = P1^5;   //按键1
  20. sbit k2      = P1^3;   //按键2
  21. bit kk1=0,kk2;                   //按键标志

  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;                 //亮度实际数值

  37. char hour,minute,second;     //时间
  38. uchar disp[5]={0,0,0,0,0};   //显示缓存

  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

  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. }

  56. void init()          //初使化
  57. {   
  58.    delay(100);
  59.    P3M0=0x04;    //P3.2强上拉
  60.    P3M1=0x00;
  61.    init_IIC();   //IIC初使化       

  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运行       

  72.         AUXR &= 0xFB;        //定时器时钟12T模式
  73.         T2L = 0x00;                //设置定时初值
  74.         T2H = 0xB8;                //设置定时初值
  75.         AUXR |= 0x10;        //定时器2开始计时
  76.         IE2|=0x04;                //开定时器2中断

  78.         PT6312_1(); //设置显示方式 8位20段
  79.     PT6312_2(); //数据设定 写显存 固定地址 正常模式
  80.         beep=0;
  81.         delay(100);
  82.         beep=0;

  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. }

  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;

  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;

  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. }

  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. }

  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);      

  321.               write_PT6312(disp[2]);
  322.             write_PT6312(0x00);      

  324.             write_PT6312(table[disp[1]]);      
  325.             write_PT6312(0x00);      

  327.             write_PT6312(table[disp[0]]);        
  328.             write_PT6312(0x00);      
  329.          
  330.                    PT6312_4(liangdu);     
  331. }

  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.          }

  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.            }

  623.                   keyscan(); //按键扫描
  624.                     
  625.                 if(jie)        //红外线遥控数据解码
  626.                 {
  627.                 yaokong();                       
  628.                     jie        =0;
  629.                 }

  631.     liangcai++;
  632.         if(liangcai>300)
  633. ……………………

  635. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

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


评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏7 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:436165 发表于 2018-11-29 23:43 | 只看该作者
怎么这么好的帖子竟然没有顶 的
楼主高手，希望多多分享有关资料
回复

使用道具 举报

板凳
ID:436724 发表于 2018-11-30 18:49 | 只看该作者
顶一下楼主，非常赞！
回复

使用道具 举报

地板
ID:106627 发表于 2019-1-23 16:25 | 只看该作者
谢谢分享！！！！！
回复

使用道具 举报

5#
ID:612348 发表于 2019-9-17 01:23 | 只看该作者
这么好的贴子定起来了
回复

使用道具 举报

6#
ID:693571 发表于 2020-3-9 10:22 | 只看该作者

这么好的贴子顶起来了
回复

使用道具 举报

7#
ID:834201 发表于 2020-10-25 08:51 | 只看该作者
这帖子真好
回复

使用道具 举报

8#
ID:901512 发表于 2021-4-7 20:09 | 只看该作者
VFD如何点亮?需要怎样供电？
回复

使用道具 举报

9#
ID:882946 发表于 2021-10-27 11:22 | 只看该作者
非常需要，现在已经很少见了
回复

使用道具 举报

10#
ID:476623 发表于 2022-11-13 14:57 | 只看该作者
好资料下载了，谢谢楼主了！
回复

使用道具 举报

11#
ID:58986 发表于 2023-4-3 17:42 | 只看该作者
正想学习怎么点亮VFD屏，就看到这资料了，感谢大佬
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表