找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 9965|回复: 7
打印 上一主题 下一主题
收起左侧

51单片机控制8位一体数码管或两个4位一体数码管实现万年历功能(时间、日期、闹钟)

  [复制链接]
跳转到指定楼层
楼主

要求
显示当前时间与日期。
手动修改时间、日期信息,修改该位信息时该数码管闪烁。
手动开启/关闭闹钟功能,而且有闹钟状态指示灯。
手动设置闹钟,而且当达到设置好的时间点时报警,报警时长为5s。
分析
万年历的整体设计如图所示:

51单片机核心模块包括51单片机最小系统模块,是设计应用的控制核心;显示模块用于显示时间与日期、设计闹钟时间等信息;指示灯包括时间日期暂停计数指示灯和闹钟开启或关闭状态指示灯;闹钟采用蜂鸣器发出声音警报;键盘输入模块用来设置和切换时间、日期,开启或关闭闹钟,设置闹钟时间等。

制作出来的实物图如下:


可用安卓接口5V供电,也可接学生电源或两个3.7V的电池通过LM7805稳压管供电。

功能介绍:
    程序初始化处于时间计数状态(已设置初始值为12:12:00),按下Key2选择位校准位,按下第一次选中秒钟,第二次选中分钟,第三次选中时钟,第四次退出校时功能,被选中位不断闪烁,并且按下Key3可进行被选择位逐渐加一,实现校时。按下Key4,数码管显示界面跳转为日期显示,按下按键Key2Key3 可实现与时间同一校准时间的功能,再次按下Key4切换为时间界面。在时间显示或者日期显示状态下,按下按键Key1可独立暂停时间计数或日期的增加,并且LED1指示灯亮。
    按下按键K3开启闹钟功能,LED2亮,再次按下则关闭闹钟,LED2灭。按下K4切换为闹钟设置状态(已设置闹钟初始值为12:12:00),按下K1进行分钟位加一,按下Key2切换为时钟位调时,按下K1进行时钟位加一,在闹钟状态下秒钟不可调。在进入闹钟设置功能前,需先开启闹钟功能,否则闹钟不会到点闹铃。按下K2退出闹钟设置界面,等到实时时间与所设置闹钟时间一致时,蜂鸣器响5s钟,中途可按下K3关闭蜂鸣器,并且关闭闹钟功能。

仿真原理图如下(proteus仿真工程文件可到本帖附件中下载)


Altium Designer画的原理图和PCB图如下:(51hei附件中可下载工程文件)


程序流程图:


单片机源程序如下:
  1. #include<reg51.h>
  2. #define uChar unsigned char
  3. #define uInt  unsigned int

  4. uChar a[]={~0x3f,~0x06,~0x5b,~0x4f,~0x66,~0x6d,~0x7d,~0x07,~0x7f,~0x6f};        //数码管段选码,0——9     
  5. uChar b[]={~0xfe,~0xfd,~0xfb,~0xf7,~0xef,~0xdf,~0xbf,~0x7f};        //数码管位选码,高——低   
  6. uChar second=0,minute=12,hour=12,month=1,day=13,count; uInt year=2019;
  7. uChar f_nao=12,s_nao=12;                //闹钟分计数,闹钟时计数
  8. uChar wave=0;                //定时器1对0.1ms定时时间进行计数,控制蜂鸣器响的频率
  9. bit flag_nao;                //控制闹钟开关变量         flag_nao= 0-off;1--on

  10. sbit K1   = P3^0;       //设置闹钟分/时位加一
  11. sbit K2   = P3^1;                //退出设置闹钟
  12. sbit K3   = P3^2;            //闹钟开关
  13. sbit K4   = P3^3;       //进入设置闹钟状态
  14. sbit Key1 = P3^4;       //计时停止
  15. sbit Key2 = P3^5;                //调位(校准)
  16. sbit Key3 = P3^6;            //所调位加一        
  17. sbit Key4 = P3^7;       //切换时-分-秒、年-月-日
  18. sbit BEEP = P2^2;                //蜂鸣器端口
  19. sbit LED1 = P2^0;                  //计时停止时LED1亮
  20. sbit LED2 = P2^1;                //闹钟开启时LED2亮
  21.                                                 
  22. //函数声明
  23. void Delayms(uInt t);         //长延时函数
  24. void Dispaly1(uChar second,uChar minute,uChar hour);        //时-分-秒显示
  25. void Dispaly2(uChar day,uChar month,uInt year);                        //年-月-日显示
  26. void Keyscan1();                                                                                //按键Key4按下次数为双数时(按键Key1~3控制时-分-秒)
  27. void Keyscan2();                                                                                //按键Key4按下次数为单数时(按键Key1~3控制年-月-日)
  28. void nao_judge();                                                                                //判断闹钟
  29.    
  30. /*************时-分-秒、年-月-日闪烁函数声明*********************/
  31. void delay(uInt t);                                                                                         /***/
  32. void Bright1(uChar second,uChar minute,uChar hour);                         /***/
  33. void Hour_flicker(uChar second,uChar minute,uChar hour);         /***/
  34. void Minute_flicker(uChar second,uChar minute,uChar hour);         /***/
  35. void Second_flicker(uChar second,uChar minute,uChar hour);          /***/
  36. void Bright2(uChar day,uChar month,uInt year);                                 /***/
  37. void Year_flicker(uChar day,uChar month,uInt year);                         /***/
  38. void Month_flicker(uChar day,uChar month,uInt year);                 /***/
  39. void Day_flicker(uChar day,uChar month,uInt year);                          /***/
  40. /*************时-分-秒、年-月-日闪烁函数声明*********************/

  41. //主函数
  42. void main()
  43. {
  44.         TMOD=0x11;        //置T0、T1都为工作方式1   
  45.            TH0=(65536-10000)/256;
  46.         TL0=(65536-10000)%256;           
  47.         TR0=1;        //开启T0
  48.         ET0=1;        //打开T0中断允许位
  49.         IT1=1;        //设置外部中断1为下降沿触发
  50.         IT0=0;        //设置外部中断0为低电平触发
  51.         EX1=1;        //打开外部中断1允许位
  52.         EX0=1;        //打开外部中断0允许位
  53.         PT0=1;        //设置内部定时中断优先级大于外部中断优先级
  54.         EA=1;        //打开中断总允许位

  55.         BEEP=1;         
  56.         flag_nao=0;
  57.         while(1)
  58.         {
  59.                 static        uChar h=0;         
  60.                 nao_judge();                                       
  61.                 if(Key4==0)                                                                                       
  62.                 {
  63.                         Delayms(10);                                                                                
  64.                         if(Key4==0)
  65.                                 while(!Key4);        //空操作,等待按键释放
  66.                         h++;
  67.                 }
  68.                         if(h%2==1)                                                                                       
  69.                         {
  70.                                 Dispaly2(day,month,year);
  71.                                 Keyscan2();        
  72.                         }               
  73.                         if(h%2==0)
  74.                         {
  75.                                 Dispaly1(second,minute,hour);
  76.                                 nao_judge();
  77.                                 Keyscan1();                                
  78.                         }
  79.         }
  80. }

  81. //长延时函数
  82. void Delayms(uInt t)
  83. {                  
  84.         uInt i,j;
  85.         for(i=0;i<t;i++)
  86.                 for(j=0;j<125;j++)
  87.                         ;
  88. }

  89. //时-分-秒显示
  90. void Dispaly1(uChar second,uChar minute,uChar hour)
  91. {
  92.                 P0=b[0];
  93.                 P1=a[hour/10];
  94.                 Delayms(1);
  95.                 P1=0xff;

  96.                 P0=b[1];
  97.                 P1=a[hour%10];
  98.                 Delayms(1);
  99.                 P1=0xff;

  100.                 P0=b[2];               
  101.                 P1=0xbf;        
  102.                 Delayms(1);
  103.                 P1=0xff;

  104.                 P0=b[3];               
  105.                 P1=a[minute/10];               
  106.                 Delayms(1);
  107.                 P1=0xff;

  108.                 P0=b[4];               
  109.                 P1=a[minute%10];        
  110.                 Delayms(1);
  111.                 P1=0xff;

  112.                 P0=b[5];        
  113.                 P1=0xbf;               
  114.                 Delayms(1);
  115.                 P1=0xff;

  116.                 P0=b[6];                        
  117.                 P1=a[second/10];        
  118.                 Delayms(1);
  119.                 P1=0xff;

  120.                 P0=b[7];        
  121.                 P1=a[second%10];               
  122.                 Delayms(1);         
  123.                 P1=0xff;
  124. }

  125. //年-月-日显示
  126. void Dispaly2(uChar day,uChar month,uInt year)
  127. {
  128.                 P0=b[7];
  129.                 P1=a[day%10];
  130.                 Delayms(1);           
  131.                 P1=0xff;

  132.                 P0=b[6];
  133.                 P1=a[day/10];
  134.                 Delayms(1);            
  135.                 P1=0xff;

  136.                 P0=b[5];               
  137.                 P1=a[month%10]&0x7f;                                
  138.                 Delayms(1);           
  139.                 P1=0xff;

  140.                 P0=b[4];               
  141.                 P1=a[month/10];        
  142.                 Delayms(1);            
  143.                 P1=0xff;

  144.                 P0=b[3];        
  145.                 P1=a[year%10]&0x7f;               
  146.                 Delayms(1);            
  147.                 P1=0xff;

  148.                 P0=b[2];                                
  149.                 P1=a[(year%100)/10];               
  150.                 Delayms(1);                  
  151.                 P1=0xff;

  152.                 P0=b[1];        
  153.                 P1=a[(year/100)%10];               
  154.                 Delayms(1);                     
  155.                 P1=0xff;

  156.                 P0=b[0];        
  157.                 P1=a[(year/1000)];               
  158.                 Delayms(1);                           
  159.                 P1=0xff;
  160. }

  161. //按键Key4按下次数为双数时(控制时-分-秒),按键Key1~3的控制
  162. void Keyscan1()
  163. {
  164.         static        uChar i=0,j=0;        //static-保存变量数据,不会清零                                       
  165.         if(Key1==0)                                                                                                
  166.         {
  167.                 Delayms(10);                //消抖                                                                                
  168.                 if(Key1==0)           
  169.                         while(!Key1);          //等待按键弹起
  170.                 i++;
  171.         }        
  172.                 if(i%2==1)                //若Key1按下次数为单数时,停止计数                                                                                                
  173.                 {
  174.                         LED1=0;
  175.                         TR0=0;
  176.                 }        
  177.                 if(i%2==0)                //若Key1按下次数为双数时,开始计数
  178.                 {
  179.                         LED1=1;               
  180.                         TR0=1;                                
  181.                 }
  182.          
  183.         if(Key2==0)                //按键Key2选择调位                                                                                
  184.         {
  185.                 Delayms(10);                                                                                
  186.                 if(Key2==0)
  187.                         while(!Key2);
  188.                 j++;                                                                                
  189.         }
  190.                 if(j%4==1)        //按键按下一次
  191.                 {                        
  192.                         Second_flicker(second,minute,hour);                //秒显示位闪烁  
  193.                         if(Key3==0)               
  194.                         {
  195.                                 Delayms(10);                                                                                
  196.                                 if(Key3==0)                //按键Key3进行选定位加一
  197.                                         while(!Key3);
  198.                                 second++;
  199.                                 if(second==60)
  200.                                         second=0;
  201.                         }
  202.                 }        
  203.                 if(j%4==2)//按键按下两次
  204.                 {
  205.                         Minute_flicker(second,minute,hour);         //分显示位闪烁
  206.                         if(Key3==0)
  207.                         {
  208.                                 Delayms(10);                                                                                
  209.                                 if(Key3==0)
  210.                                         while(!Key3);
  211.                                 minute++;
  212.                                 if(minute==60)
  213.                                         minute=0;                                       
  214.                         }
  215.                 }
  216.                 if(j%4==3)//按键按下三次
  217.                 {                  
  218.                         Hour_flicker(second,minute,hour);                //时显示位闪烁
  219.                         if(Key3==0)
  220.                         {               
  221.                                 Delayms(10);                                                                                
  222.                                 if(Key3==0)
  223.                                         while(!Key3);
  224.                                 hour++;                        
  225.                                 if(hour==24)
  226.                                         hour=0;                                
  227.                         }
  228.                 }
  229. }

  230. //按键Key4按下次数为单数时(控制年-月-日),按键Key1~3的控制
  231. void Keyscan2()
  232. {
  233.         static        uChar m=0,n=0;                                                
  234.         if(Key1==0)                                                                                                
  235.         {
  236.                 Delayms(10);                                                                                
  237.                 if(Key1==0)
  238.                         while(!Key3);
  239.                 m++;
  240.         }
  241.                 if(m%2==1)                                                                                                
  242.                 {
  243.                         LED1=0;
  244.                         TR0=0;
  245.                 }                                                                                                                                                                                          
  246.                 if(m%2==0)
  247.                 {
  248.                         LED1=1;
  249.                         TR0=1;                                                
  250.                 }

  251.         if(Key2==0)                                                                                                
  252.         {
  253.                 Delayms(10);                                                                                
  254.                 if(Key2==0)
  255.                         while(!Key2);
  256.                 n++;                                                                                
  257.         }
  258.                 if(n%4==1)
  259.                 {
  260.                         Day_flicker(day,month,year);        //日显示位闪烁
  261.                         if(Key3==0)
  262.                         {
  263.                                 Delayms(10);                                                                                
  264.                                 if(Key3==0)
  265.                                         while(!Key3);
  266.                                 day++;
  267.                                 if(day==32)
  268.                                         day=1;
  269.                         }
  270.                 }        
  271.                 if(n%4==2)
  272.                 {
  273.                         Month_flicker(day,month,year);        //月显示位闪烁
  274.                         if(Key3==0)
  275.                         {               
  276.                                 Delayms(10);                                                                                
  277.                                 if(Key3==0)
  278.                                         while(!Key3);
  279.                                 month++;
  280.                                 if(month==13)
  281.                                         month=1;                                       
  282.                         }
  283.                 }        
  284.                 if(n%4==3)
  285.                 {
  286.                         Year_flicker(day,month,year);        //年显示位闪烁
  287.                         if(Key3==0)
  288.                         {               
  289.                                 Delayms(10);                                                                                
  290.                                 if(Key3==0)
  291.                                         while(!Key3);
  292.                                 year++;
  293.                                 if(year==10000)
  294.                                         year=0;                                
  295.                         }
  296.                 }
  297. }

  298. //判断闹钟,当时间和设置闹钟时间相等时,闹铃响5S
  299. void nao_judge()
  300. {
  301.         if(flag_nao==1)                 //如果flag_nao为真,闹钟开启
  302.         {
  303.                 if((minute==f_nao)&&(hour==s_nao))                //判断实时时间和闹钟时间的分、时是否同时相等
  304.                 {
  305.                         while(second<5&&flag_nao)                //如果second<=5和flag_nao都为真,闹铃响5s
  306.                         {
  307.                                 BEEP=0;         //TR1=1;        //开启T0                                                        
  308.                                 Dispaly1(second,minute,hour);
  309.                         }
  310.                 }
  311.         }
  312.         BEEP=1;
  313. }

  314. //定时器中断0,时钟计数(不断执行)
  315. void time0_int(void) interrupt 1
  316. {
  317.         TH0=(65536-10000)/256;
  318.         TL0=(65536-10000)%256;
  319.         count++;
  320.         if(count==100)
  321.         {
  322.                 count=0;
  323.                 second++;
  324.                 if(second==60)
  325.                 {
  326.                         second=0;
  327.                         minute++;
  328.                         if(minute==60)
  329.                         {
  330.                                 minute=0;
  331.                                 hour++;
  332.                                 if(hour==24)
  333.                                 {
  334.                                         hour=0;
  335.                                         day++;
  336.                                         if(day==32)
  337.                                         {
  338.                                                 day=1;
  339.                                                 month++;
  340.                                                 if(month==13)
  341.                                                 {
  342.                                                         month=1;
  343.                                                         year++;
  344.                                                         if(year==10000)
  345.                                                         {
  346.                                                                 year=0;
  347.                                                         }
  348.                                                 }
  349.                                         }
  350.                                 }
  351.                         }
  352.                 }
  353.         }
  354. }

  355. //外部中断0,闹钟开关,控制flag_nao,按下K3关闭闹钟
  356. void guan_naozhong() interrupt 0           
  357. {
  358.         flag_nao=~flag_nao;
  359.         LED2=~LED2;
  360.         TR1 = 0;        //K3按下,开启外部中断0,关闭定时器中断1,闹钟停止响铃               
  361.         while(!K3)
  362.                 Dispaly1(second,minute,hour);
  363. }

  364. //外部中断1,调节闹钟时间
  365. void naozhong() interrupt 2
  366. {
  367.         static uChar n=0;         
  368. //        s_nao=12;        //设置闹钟时钟初始值
  369. //        f_nao=31;        //设置闹钟分钟初始值
  370.         while(K2)        //等待按下K2退出,否则循环执行闹钟时间设置
  371.         {
  372.                 Dispaly1(0,f_nao,s_nao);        //显示闹钟设置
  373.                 if(Key2==0)                        //闹钟调位调时钟、分钟                                                                                       
  374.                 {
  375.                         Delayms(10);                                                                                
  376.                         if(Key2==0)
  377.                                 while(!Key2);
  378.                         n++;
  379.                 }
  380.                         if(n%2==1)                //调节闹钟时钟                                                                                       
  381.                         {
  382.                                 if(K1==0)                                                                                                
  383.                                 {  
  384.                                         Dispaly1(0,f_nao,s_nao);
  385.                                         if(K1==0)                                                                                                
  386.                                         {  
  387.                                                 if(s_nao==23)        
  388.                                                         s_nao=0;
  389.                                                 else s_nao++;
  390.                                         }
  391.                                         while(!K1)
  392.                                                 Dispaly1(0,f_nao,s_nao);                        
  393.                                 }               
  394.                         }
  395.                         if(n%2==0)                //调节闹钟分钟
  396.                         {
  397.                                 if(K1==0)                                                                                                
  398.                                 {  
  399.                                         Dispaly1(0,f_nao,s_nao);
  400.                                         if(K1==0)                                                                                                
  401.                                         {                                          
  402.                                                 if(f_nao==59)        
  403.                                                         f_nao=0;
  404.                                                 else f_nao++;
  405.                                         }
  406.                                         while(!K1)
  407.                                                 Dispaly1(0,f_nao,s_nao);        
  408.                                 }               
  409.                         }                                                                        
  410.         }
  411. }

  412.                                                   
  413. /************************************************/        
  414. /****************调位时选择位闪烁****************/
  415. /************************************************/        
  416. //短延时
  417. void delay(uInt t)                                 
  418. {
  419.         uInt i;
  420.         for(i=0;i<t;i++)
  421.                 ;
  422. }

  423. //数码管0~7位分别显示时-分-秒
  424. void Bright1(uChar second,uChar minute,uChar hour)
  425. {
  426.         uChar p,k=10;
  427.         for(p=0;p<50;p++)
  428.         {
  429.                 P0=b[0];
  430.                 P1=a[hour/10];
  431.                 delay(k);
  432.                 P1=0xff;

  433.                 P0=b[1];
  434.                 P1=a[hour%10];
  435.                 delay(k);
  436.                 P1=0xff;

  437.                 P0=b[2];               
  438.                 P1=0xbf;        
  439.                 delay(k);
  440.                 P1=0xff;

  441.                 P0=b[3];               
  442.                 P1=a[minute/10];               
  443.                 delay(k);
  444.                 P1=0xff;

  445.                 P0=b[4];               
  446.                 P1=a[minute%10];        
  447.                 delay(k);
  448.                 P1=0xff;

  449.                 P0=b[5];        
  450.                 P1=0xbf;               
  451.                 delay(k);
  452.                 P1=0xff;

  453.                 P0=b[6];                        
  454.                 P1=a[second/10];        
  455.                 delay(k);
  456.                 P1=0xff;           

  457.                 P0=b[7];        
  458.                 P1=a[second%10];               
  459.                 delay(k);         
  460.                 P1=0xff;        
  461.         }
  462. }

  463. //秒显示位闪烁
  464. void Second_flicker(uChar second,uChar minute,uChar hour)
  465. {
  466.         uChar p,k=10;
  467.         Bright1(second,minute,hour);
  468.         for(p=0;p<50;p++)
  469.         {
  470.                 P0=b[0];
  471.                 P1=a[hour/10];
  472.                 delay(k);
  473.                 P1=0xff;

  474.                 P0=b[1];
  475.                 P1=a[hour%10];
  476.                 delay(k);
  477.                 P1=0xff;

  478.                 P0=b[2];               
  479.                 P1=0xbf;        
  480.                 delay(k);
  481.                 P1=0xff;

  482.                 P0=b[3];               
  483.                 P1=a[minute/10];               
  484.                 delay(k);
  485.                 P1=0xff;

  486.                 P0=b[4];               
  487.                 P1=a[minute%10];        
  488.                 delay(k);
  489.                 P1=0xff;

  490.                 P0=b[5];        
  491.                 P1=0xbf;               
  492.                 delay(k);
  493.                 P1=0xff;

  494.                 P0=b[6];        //该位数码管灭                        
  495.                 P1=0xff;         
  496.                 delay(k);

  497.                 P0=b[7];        //该位数码管灭  
  498.                 P1=0xff;                        
  499.                 delay(k);        
  500.         }
  501. }

  502. //分显示位闪烁
  503. void Minute_flicker(uChar second,uChar minute,uChar hour)
  504. {
  505.         uChar p,k=10;
  506.         Bright1(second,minute,hour);
  507.         for(p=0;p<50;p++)
  508.         {
  509.                 P0=b[0];
  510.                 P1=a[hour/10];
  511.                 delay(k);
  512.                 P1=0xff;

  513.                 P0=b[1];
  514.                 P1=a[hour%10];
  515.                 delay(k);
  516.                 P1=0xff;

  517.                 P0=b[2];               
  518.                 P1=0xbf;        
  519.                 delay(k);
  520.                 P1=0xff;

  521.                 P0=b[3];                           ////熄灭
  522.                 P1=0xff;                                
  523.                 delay(k);

  524.                 P0=b[4];                           ////熄灭
  525.                 P1=0xff;                        
  526.                 delay(k);

  527.                 P0=b[5];        
  528.                 P1=0xbf;               
  529.                 delay(k);
  530.                 P1=0xff;

  531.                 P0=b[6];                        
  532.                 P1=a[second/10];        
  533.                 delay(k);
  534.                 P1=0xff;           

  535.                 P0=b[7];        
  536.                 P1=a[second%10];               
  537.                 delay(k);         
  538.                 P1=0xff;        
  539.         }
  540. }

  541. //时显示位闪烁
  542. void Hour_flicker(uChar second,uChar minute,uChar hour)
  543. {
  544.         uChar p,k=10;
  545.         Bright1(second,minute,hour);
  546.         for(p=0;p<50;p++)
  547.         {
  548.                 P0=b[0];                              ////熄灭
  549.                 P1=0xff;
  550.                 delay(k);

  551.                 P0=b[1];                              ////熄灭
  552.                 P1=0xff;
  553.                 delay(k);

  554.                 P0=b[2];               
  555.                 P1=0xbf;        
  556.                 delay(k);
  557.                 P1=0xff;

  558.                 P0=b[3];               
  559.                 P1=a[minute/10];               
  560.                 delay(k);
  561.                 P1=0xff;

  562.                 P0=b[4];               
  563.                 P1=a[minute%10];        
  564.                 delay(k);
  565.                 P1=0xff;

  566.                 P0=b[5];        
  567.                 P1=0xbf;               
  568.                 delay(k);
  569.                 P1=0xff;

  570.                 P0=b[6];                        
  571.                 P1=a[second/10];        
  572.                 delay(k);
  573.                 P1=0xff;           

  574.                 P0=b[7];        
  575.                 P1=a[second%10];               
  576.                 delay(k);         
  577.                 P1=0xff;
  578.         }
  579. }


  580. //数码管0~7位分别显示年-月-日
  581. void Bright2(uChar day,uChar month,uInt year)
  582. {
  583.         uChar p,k=10;
  584.         for(p=0;p<50;p++)
  585.         {
  586.                 P0=b[7];
  587.                 P1=a[day%10];
  588.                 delay(k);           
  589.                 P1=0xff;

  590.                 P0=b[6];
  591.                 P1=a[day/10];
  592.                 delay(k);     
  593.                 P1=0xff;

  594.                 P0=b[5];               
  595.                 P1=a[month%10]&0x7f;        
  596.                 delay(k);     
  597.                 P1=0xff;

  598.                 P0=b[4];               
  599.                 P1=a[month/10];        
  600.                 delay(k);     
  601.                 P1=0xff;

  602.                 P0=b[3];        
  603.                 P1=a[year%10]&0x7f;        
  604.                 delay(k);     
  605.                 P1=0xff;

  606.                 P0=b[2];                                
  607.                 P1=a[(year%100)/10];
  608.                 delay(k);     
  609.                 P1=0xff;

  610.                 P0=b[1];        
  611.                 P1=a[(year/100)%10];
  612.                 delay(k);     
  613.                 P1=0xff;

  614.                 P0=b[0];        
  615.                 P1=a[(year/1000)];        
  616.                 delay(k);        
  617.                 P1=0xff;
  618.         }
  619. }

  620. //日显示位闪烁
  621. void Day_flicker(uChar day,uChar month,uInt year)
  622. {
  623.         uChar p,k=10;
  624.         Bright2(day,month,year);
  625.         for(p=0;p<50;p++)
  626.         {
  627.                 P0=b[7];                           ////熄灭
  628.                 P1=0xff;
  629.                 delay(k);     

  630.                 P0=b[6];                       ////熄灭
  631.                 P1=0xff;
  632.                 delay(k);     

  633.                 P0=b[5];               
  634.                 P1=a[month%10]&0x7f;        
  635.                 delay(k);     
  636.                 P1=0xff;

  637.                 P0=b[4];               
  638.                 P1=a[month/10];        
  639.                 delay(k);     
  640.                 P1=0xff;

  641.                 P0=b[3];        
  642.                 P1=a[year%10]&0x7f;               
  643.                 delay(k);     
  644.                 P1=0xff;

  645.                 P0=b[2];                                
  646.                 P1=a[(year%100)/10];        
  647.                 delay(k);     
  648.                 P1=0xff;

  649.                 P0=b[1];        
  650.                 P1=a[(year/100)%10];        
  651.                 delay(k);     
  652.                 P1=0xff;

  653.                 P0=b[0];        
  654.                 P1=a[(year/1000)];        
  655.                 delay(k);     
  656.                 P1=0xff;
  657.         }
  658. }

  659. //月显示位闪烁
  660. void Month_flicker(uChar day,uChar month,uInt year)
  661. {
  662.         uChar p,k=10;
  663.         Bright2(day,month,year);
  664.         for(p=0;p<50;p++)
  665.         {
  666.                 P0=b[7];
  667.                 P1=a[day%10];
  668. ……………………

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

所有资料51hei提供下载:
万年历-原理图 功能介绍 程序 PCB.zip (14.17 MB, 下载次数: 157)



评分

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

查看全部评分

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

使用道具 举报

沙发
ID:470643 发表于 2019-1-19 20:24 | 只看该作者
74LS245是数码管驱动芯片,Proteus仿真软件不用也可以正常实现功能,但是实物就必须有驱动芯片。
回复

使用道具 举报

板凳
ID:1 发表于 2019-1-20 01:26 | 只看该作者
好资料,51黑有你更精彩!!!
回复

使用道具 举报

地板
ID:405588 发表于 2019-1-20 10:38 | 只看该作者
膜拜大神,谢谢分享!
回复

使用道具 举报

5#
ID:669941 发表于 2019-12-21 17:05 | 只看该作者
大佬大佬,琢磨不透,要多多跟你学习
回复

使用道具 举报

6#
ID:283591 发表于 2019-12-21 23:00 | 只看该作者
好东东,感谢分享!!
回复

使用道具 举报

7#
ID:674458 发表于 2019-12-26 12:59 | 只看该作者

好资料,谢谢分享
回复

使用道具 举报

8#
ID:236035 发表于 2019-12-26 14:37 | 只看该作者
谢谢分享!
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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