找回密码
 立即注册

QQ登录

只需一步,快速开始

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

基于51单片机的带闹钟整点报时的数字钟设计,含代码,原理图,PCB代码

  [复制链接]
跳转到指定楼层
楼主
基于51单片机的数字钟设计,功能如下:1.正常走时   2.整点报时   3.闹钟设置   4.设置时数字高亮

(缺点:PCB蜂鸣器正负需要反一下,自行改)

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


单片机源程序如下:
  1. #include<reg52.h>

  2. #define uint unsigned int
  3. #define uchar unsigned char

  4. #define K_1 1
  5. #define K_2 2
  6. #define K_3 3
  7. #define K_4 4  

  8. sbit K1=P3^1;                          //功能键,按一次调节时间,按两次设置闹钟,按三次确定
  9. sbit K2=P3^0;                          //移位键
  10. sbit K3=P3^2;                          //调时加键
  11. sbit K4=P3^3;                          //调时减键
  12. uint w,s,f,m;                        //时分秒
  13. uint s1=0,f1=0,m1=0;        //闹钟的时分秒
  14. uint b=0,a=0;                        //记录K1,K2的键值
  15. uint j,i=0;                                //j空循环,i是标志,避免开机闹钟响
  16. uint temp=0;                        //判断扫描标志位
  17. uint clock[3];                        //记录闹钟设置的时间
  18. uint shi=0,fen=0,miao=0;//使对应位高亮的标志
  19. static int key=0;                //按键扫描的键值标志
  20. sbit speak=P1^5;            //蜂鸣器
  21.         uchar led1[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};

  22. void delay(unsigned int i)                 //延迟函数
  23. {
  24.         while(i--);
  25. }

  26. void scan(uchar h,uchar m,uchar s) //输入时分秒
  27. {
  28.         uchar led[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
  29.         P0=0X00;
  30.         P0=led[s%10];                //秒个位
  31.         P2=0x01;                        //第一位
  32.         for(j=0;j<50;j++);         

  33.         P0=0X00;
  34.         P0=led[s/10];                //秒十位
  35.         P2=0x04;                        //第二位
  36.         for(j=0;j<50;j++);

  37.         P0=0X00;
  38.         P0=led[m%10];                //分个位
  39.         P2=0x08;                        //第三位
  40.         for(j=0;j<50;j++);
  41.         
  42.         P0=0X00;
  43.         P0=led[m/10];                //分十位
  44.         P2=0x0C;                        //第四位
  45.         for(j=0;j<50;j++);

  46.         P0=0X00;
  47.         P0=led[h%10];                //时个位
  48.         P2=0x10;                        //第五位        
  49.         for(j=0;j<50;j++);

  50.         P0=0X00;
  51.         P0=led[h/10];                //时十位
  52.         P2=0x14;                        //第六位        
  53.         for(j=0;j<50;j++);
  54. }

  55. void zoushi() interrupt 1           //走时中断
  56. {
  57.         TH0=(65536-50000)/256;
  58.         TL0=(65536-50000)%256;
  59.         w++;
  60.         if(w==20)                  //机器周期计数
  61.         {
  62.                 m++;
  63.                 w=0;
  64.                 if(m==60)
  65.                 {
  66.                         f++;
  67.                         m=0;
  68.                         if(f==60)
  69.                         {
  70.                                 s++;
  71.                                 f=0;
  72.                                 if(s==24)
  73.                                         s=0;
  74.                         }
  75.                 }
  76.         }        
  77. }


  78. uint KEY_Scan()                           //按键扫描
  79. {
  80.         
  81.         if(K1==0||K2==0||K3==0||K4==0)
  82.         {
  83.                 for(j=0;j<10;j++);
  84.                 key=0;
  85.                 if(K1==0)
  86.                 {
  87.                         return K_1;
  88.                 }
  89.                 else if(K2==0)
  90.                 {
  91.                         return K_2;
  92.                 }
  93.                 else if(K3==0)
  94.                 {
  95.                         return K_3;
  96.                 }
  97.                 else if(K4==0)
  98.                 {
  99.                         return K_4;
  100.                 }
  101.                 else
  102.                         return 0;
  103.         }
  104. }


  105. void xiaoshi()                  //调节
  106. {
  107. //                temp=1;
  108.                 key=KEY_Scan();
  109.                 if(key==K_1)
  110.                 {
  111.                         a++;
  112.                         a%=3;
  113.                         while(!K1);
  114. //                                temp=1;//scan(s,f,m);
  115.                 }
  116.                 if(key==K_2)
  117.                 {

  118.                         b++;
  119.                         b%=3;
  120.                         while(!K2);
  121. //                                temp=1;//scan(s,f,m);
  122.                 }
  123.                
  124.                 if(a==1)
  125.                 {
  126.                         P0=0X00;
  127.                         P0=0X06;  
  128.                         P2=0X1c;
  129.                         for(j=0;j<10;j++);
  130.                         temp=1;
  131.                         if(b==0)
  132.                         {
  133.                                 P0=0X00;
  134.                                 P0=0X06;  
  135.                                 P2=0X18;
  136.                                 for(j=0;j<10;j++);
  137.                                 miao=1;
  138.                                 if(key==K_3)
  139.                                 {
  140.                                         if(m==59)
  141.                                                 m=0;
  142.                                         else
  143.                                                 m++;
  144.                                         while(!K3);
  145. //                                                temp=1;//scan(s,f,m);
  146.                                 }
  147.                                 if(key==K_4)
  148.                                 {
  149.                                         if(m==0)
  150.                                                 m=59;
  151.                                         else
  152.                                                 m--;
  153.                                         while(!K4);
  154. //                                                temp=1;//scan(s,f,m);
  155.                                 }
  156.                         }
  157.                         else if(b==1)
  158.                         {
  159.                                 P0=0X00;
  160.                                 P0=0X5B;  
  161.                                 P2=0X18;
  162.                                 for(j=0;j<10;j++);
  163.                                 fen=1;
  164.                                 if(key==K_3)
  165.                                 {
  166.                                         if(f==59)
  167.                                                 f=0;
  168.                                         else
  169.                                                 f++;
  170.                                 
  171.                                         while(!K3);
  172. //                                                temp=1;//scan(s,f,m);
  173.                                 }
  174.                                 if(key==K_4)
  175.                                 {
  176.                                         if(f==0)
  177.                                                 f=59;
  178.                                         else
  179.                                                 f--;
  180.                                 
  181.                                         while(!K4);
  182. //                                                temp=1;//scan(s,f,m);
  183.                                 }
  184.                         }
  185.                         else
  186.                         {
  187.                                 P0=0X00;
  188.                                 P0=0X4F;  
  189.                                 P2=0X18;
  190.                                 for(j=0;j<10;j++);
  191.                                 shi=1;
  192.                                 if(key==K_3)
  193.                                 {
  194.                                         if(s==23)
  195.                                                 s=0;
  196.                                         else
  197.                                                 s++;
  198.                                         while(!K3);
  199. //                                                temp=1;//scan(s,f,m);
  200.                                 }
  201.                                 if(key==K_4)
  202.                                 {
  203.                                         if(s==0)
  204.                                                 s=23;
  205.                                         else
  206.                                                 s--;
  207.                                         while(!K4);
  208. //                                                temp=1;//scan(s,f,m);
  209.                                 }
  210.                         }
  211.                 }

  212.                 else if(a==2)
  213.                 {
  214.                         i=1;
  215.                         P0=0X00;
  216.                         P0=0X5b;  
  217.                         P2=0X1c;
  218.                         for(j=0;j<10;j++);
  219.                         temp=2;
  220.                         if(b==0)
  221.                         {
  222.                                 P0=0X00;
  223.                                 P0=0X06;  
  224.                                 P2=0X18;
  225.                                 for(j=0;j<10;j++);
  226.                                 miao=1;
  227.                                 if(key==K_3)
  228.                                 {
  229.                                         if(m1==59)
  230.                                                 m1=0;
  231.                                         else
  232.                                                 m1++;
  233.                                         clock[0]=m1;
  234.                                         while(!K3);
  235. //                                                temp=1;//scan(s1,f1,m1);
  236.                                 }
  237.                                 if(key==K_4)
  238.                                 {
  239.                                         if(m1==0)
  240.                                                 m1=59;
  241.                                         else
  242.                                                 m1--;
  243.                                         clock[0]=m1;
  244.                                         while(!K4);
  245. //                                                temp=1;//scan(s1,f1,m1);
  246.                                 }
  247. //                                miao=0;
  248.                         }
  249.                         
  250.                         else if(b==1)
  251.                         {
  252.                                 P0=0X00;
  253.                                 P0=0X5B;  
  254.                                 P2=0X18;
  255.                                 for(j=0;j<10;j++);
  256.                                 fen=1;
  257.                                 if(key==K_3)
  258.                                 {
  259.                                         if(f1==59)
  260.                                                 f1=0;
  261.                                         else
  262.                                                 f1++;
  263.                                         clock[1]=f1;
  264.                                         while(!K3);
  265. //                                                temp=1;//scan(s1,f1,m1);
  266.                                 }
  267.                                 if(key==K_4)
  268.                                 {
  269.                                         if(f1==0)
  270.                                                 f1=59;
  271.                                         else
  272.                                                 f1--;
  273.                                         clock[1]=f1;
  274.                                         while(!K4);
  275. //                                                temp=1;//scan(s1,f1,m1);
  276.                                 }
  277. //                                fen=0;
  278.                         }
  279.                         
  280.                         else
  281.                         {
  282.                                 P0=0X00;
  283.                                 P0=0X4F;  
  284.                                 P2=0X18;
  285.                                 for(j=0;j<10;j++);
  286.                                 shi=1;
  287.                                 if(key==K_3)
  288.                                 {
  289.                                         if(s1==23)
  290.                                                 s1=0;
  291.                                         else
  292.                                                 s1++;
  293.                                         clock[2]=s1;
  294.                                         while(!K3);
  295. //                                                temp=1;//scan(s1,f1,m1);
  296.                                 }
  297.                                 if(key==K_4)
  298.                                 {
  299.                                         if(s1==0)
  300.                                                 s1=23;
  301.                                         else
  302.                                                 s1--;
  303.                                         clock[2]=s1;
  304.                                         while(!K4);
  305. //                                                temp=1;//scan(s1,f1,m1);
  306.                                 }
  307. //                                shi=0;
  308.                         }
  309.                                 
  310.                 }

  311.                 else
  312.                 {
  313.                         temp=0;
  314.                 }
  315. }

  316. void nao()                   //闹钟
  317. {
  318.         if(i==1)
  319.         {
  320.                 if((m==clock[0])&&(f==clock[1])&&(s==clock[2]))
  321.                 {
  322.                         speak=1;
  323.                         delay(10);
  324.                         speak=0;
  325.                         delay(10);
  326.                 }        
  327.         }
  328.         
  329. }

  330. //void zhengdian()                 //整点报时
  331. //{
  332. //        if((f==0)&&((m>=0)&&(m<=3)))
  333. //        {
  334. //                speak=1;
  335. //                delay(10);
  336. //                speak=0;
  337. //                delay(10);
  338. //        }
  339. //}

  340. void test()
  341. {
  342.         if(temp==0)                        
  343.                 scan(s,f,m);
  344.         else if(temp==1)
  345.         {
  346.                         
  347.                 if(miao==1)
  348.                 {
  349.                         scan(s,f,m);
  350.                         P0=led1[m%10];
  351.                         P2=0X01;
  352.                         delay(500);
  353.                         P0=led1[m/10];
  354.                         P2=0X04;
  355.                         delay(500);
  356.                         miao=0;
  357.                 }
  358.                 else if(fen==1)
  359.                 {
  360.                         scan(s,f,m);
  361.                         P0=led1[f%10];
  362.                         P2=0X08;
  363.                         delay(500);
  364.                         P0=led1[f/10];
  365.                         P2=0X0C;
  366.                         delay(500);
  367.                         fen=0;
  368.                 }
  369.                 else if(shi==1)
  370.                 {
  371.                         scan(s,f,m);
  372.                         P0=led1[s%10];
  373.                         P2=0X10;
  374.                         delay(500);
  375.                         P0=led1[s/10];
  376.                         P2=0X14;
  377.                         delay(500);
  378.                         shi=0;
  379.                 }
  380.         }

  381.         else
  382.         {
  383.                         
  384.                 if(miao==1)
  385.                 {
  386.                         scan(s1,f1,m1);
  387.                         P0=led1[m1%10];
  388.                         P2=0X01;
  389.                         delay(500);
  390.                         P0=led1[m1/10];
  391.                         P2=0X04;
  392.                         delay(500);
  393.                         miao=0;
  394.                 }
  395.                 else if(fen==1)
  396.                 {
  397.                         scan(s1,f1,m1);
  398.                         P0=led1[f1%10];
  399.                         P2=0X08;
  400. ……………………

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

所有资料51hei提供下载:
基于51的数字钟设计.7z (739.09 KB, 下载次数: 215)


评分

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

查看全部评分

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

使用道具 举报

沙发
ID:773272 发表于 2020-6-17 11:55 | 只看该作者
有无protues仿真图?
回复

使用道具 举报

板凳
ID:635913 发表于 2020-9-27 15:12 | 只看该作者

没有,这个我做的是实物
回复

使用道具 举报

地板
ID:929789 发表于 2021-6-2 08:48 来自手机 | 只看该作者
未来可期鸭 发表于 2020-9-27 15:12
没有,这个我做的是实物

怎么设置调时间的时候显示器高亮,整点报时显示器高亮
回复

使用道具 举报

5#
ID:754395 发表于 2021-6-29 02:25 | 只看该作者
准备做一个实物了
回复

使用道具 举报

6#
ID:951314 发表于 2021-7-9 23:03 | 只看该作者
实物能做出来吗?还有功能怎么设置
回复

使用道具 举报

7#
ID:332082 发表于 2021-7-10 19:49 | 只看该作者
我准备按这个资料做一个实物
回复

使用道具 举报

8#
ID:245820 发表于 2022-5-9 11:07 | 只看该作者
非常好的资料,可惜币不够
回复

使用道具 举报

9#
ID:245820 发表于 2022-5-9 11:11 | 只看该作者
原理图的数码管驱动电路是不是接错了,PNP三极管应该是发射极接电源
回复

使用道具 举报

10#
ID:232619 发表于 2022-9-24 23:01 | 只看该作者
代码编写的行数少,收下学习。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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