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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机可调时钟的C程序及proteus仿真图
返回列表 发新帖
查看: 4137|回复: 1
打印 上一主题 下一主题
收起左侧

单片机可调时钟的C程序及proteus仿真图

[复制链接]
跳转到指定楼层
楼主
ID:320518 发表于 2018-5-30 12:00 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
分享一个基于51单片机的可调时钟小设计

模式键：按一次，进入倒计时设置模式（设置倒计时的时间，比如2min30s，5min40s等）
    按两次，进入倒计时模式（开始倒计时）
    按三次，进入钟表时间调节模式
    按四次，回到正常显示模式（进入计时器/倒计时模式时不影响钟表正常走时）

配置键：按一次调整分
    按两次调整时
    按三次，回到调整分，依次循环
    （配置键选择需要调整的单位，由加/减键进行加减调整）

加法键：数值加
减法键：数值减


红色数码管显示0时，为正常显示模式
红色数码管显示1时，为倒计时设置模式
红色数码管显示3时，为倒计时模式

在正常显示模式下，除模式键外其他按键都不可用
在钟表时间调节模式下，钟表不走时，其他任何模式都不影响钟表的正常走时

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



单片机源程序如下:
  1.         /*晶振12MHZ*/   
  2. #include<reg52.h>
  3. #define uchar unsigned char
  4. #define uint unsigned int
  5. uchar code wela[6] = {0x20,0x10,0x08,0x04,0x02,0x01};           //位选码
  6. uchar code dula[10] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};         //段选码
  7. uchar buff[6] = {0,0,0,0,0,0};

  9. sbit P33 = P3^3;
  10. sbit P32 = P3^2;
  11. sbit P34 = P3^4;
  12. sbit P35 = P3^5;
  13. uchar hour,second,minute,hour_1,second_1,minute_1,hour_2,second_2,minute_2,t0,mode,reset,i;
  14.         //无下划线的为时分秒辅助变量，下划线1的为时钟时分秒，下划线2的为倒计时时分秒

  16. void init();       //初始化函数
  17. void mode_0(void);                //动态扫描函数       
  18. void mode_1(void);                //闪烁函数       
  19. void time_1(void);                //时钟函数（正计时）
  20. void time_2(void);                //倒计时函数
  21. void oper_add(void);        //加法键函数
  22. void oper_minus(void);         //减法键函数
  23. void delay(uint z);                 //延时函数

  25. void main()
  26. {
  27.         init();
  28.         while(1)
  29.         {
  30.                 if(mode==1)
  31.                 {
  32.                         second = second_2;
  33.                         minute = minute_2;
  34.                         hour = hour_2;
  35.                         oper_add();                          //加法键函数
  36.                         oper_minus();                //减法键函数
  37.                         second_2 = second;
  38.                         minute_2 = minute;
  39.                         hour_2 = hour;
  40.                 }
  41.                 else if(mode==3)
  42.                 {
  43.                         second = second_1;
  44.                         minute = minute_1;
  45.                         hour = hour_1;
  46.                         oper_add();
  47.                         oper_minus();
  48.                         second_1 = second;
  49.                         minute_1 = minute;
  50.                         hour_1 = hour;
  51.                 }
  52.         }
  53. }

  55.         /*初始化函数*/
  56. void init()
  57. {
  58.         TMOD = 0x01;                           //设置T0为方式一
  59.         TH0 = 0x3c;
  60.         TL0 = 0xb0;
  61.         IE = 0x87;
  62.         IT0 = IT1 = 0;
  63.         IP = 0X02;                                        //设置T0为高优先级
  64.         TR0 = 1;
  65.         t0 = 0;
  66.         mode = 0;
  67.         P1 = 0xc0;

  69. }

  71.         /*模式键函数，外部中断0*/
  72. void X0_mode() interrupt 0                                               
  73. {
  74.         delay(10);
  75.         if(P32 == 0)
  76.         {
  77.                 mode++;                                                //mode为模式标志位
  78.                 reset = 0;                                        //reset为时分秒调节标志位
  79.                 switch(mode)
  80.                 {
  81.                         case 0 :        P1 = 0xc0 ; break;
  82.                         case 1 : {  P1 = 0xf9 ; hour_2 = second_2 = minute_2 = 0;} break;
  83.                         case 2 :         P1 = 0xa4 ; break;
  84.                         case 3 :        P1 = 0xb0 ; break;
  85.                         case 4 : {        P1 = 0xc0 ; mode = 0;} break;
  86.                         default : break;
  87.                 }

  89.         }
  90.         while(P32 == 0);
  91.        
  92. }

  94.         /*配置键函数，外部中断1*/
  95. void X1_reset() interrupt 2                                               
  96. {
  97.         delay(10);
  98.         if(P33 == 0)
  99.         {
  100.                 if((mode==1) || (mode==3))
  101.                         {
  102.                                 reset++;                         //时分秒调节标志位
  103.                                 if(reset == 3)
  104.                                         reset = 0;
  105.                         }
  106.         }
  107.         while(P33 == 0);
  108.        
  109. }

  111.         /*计时/动态扫描函数，内部中断0*/
  112. void T0_disp() interrupt 1                                  
  113. {       
  114.         TH0 = 0xb1;
  115.         TL0 = 0xe0;                                                 //b1e0(20ms)
  116.         t0++;
  117.         if(t0==50)                                                 //秒计数部分（正倒计时共用）
  118.         {
  119.                 t0=0;
  120.                 if(mode != 3)
  121.                         time_1();                                 //除了调节钟表时间调节模式外，其他模式下执行正计时函数
  122.                 if(mode==2)
  123.                         time_2();                                 //进入倒计时模式时，执行倒计时函数（正计时不受干扰）
  124.         }
  125.         if((mode==1) || (mode==2))                   //装载部分，将时分秒装载到数组buff，便于动态扫描。
  126.         {
  127.                 buff[0]=second_2%10;
  128.                 buff[1]=second_2/10;
  129.                 buff[2]=minute_2%10;
  130.                 buff[3]=minute_2/10;
  131.                 buff[4]=hour_2%10;
  132.                 buff[5]=hour_2/10;
  133.                        
  134.         }
  135.         else
  136.         {
  137.                 buff[0]=second_1%10;
  138.                 buff[1]=second_1/10;
  139.                 buff[2]=minute_1%10;
  140.                 buff[3]=minute_1/10;
  141.                 buff[4]=hour_1%10;
  142.                 buff[5]=hour_1/10;
  143.         }                       
  144.         switch(mode)                                                //显示部分，包括动态扫描和闪烁函数
  145.         {
  146.                 case 0 : mode_0() ; break;
  147.                 case 1 : mode_1() ; break;
  148.                 case 2 : mode_0() ; break;
  149.                 case 3 : mode_1() ; break;
  150.                 default : break;
  151.         }       
  152.        
  153. }

  155.         /*动态扫描函数*/
  156. void mode_0(void)
  157. {
  158.         for(i=0;i<6;i++)
  159.         {
  160.                 P2=wela[i];
  161.                 P0=dula[buff[i]];
  162.                 delay(1);       
  163.         }
  164.         P2 = 0xe0;
  165.         P0 = 0xbf;
  166.         delay(1);               
  167. }

  169.         /*闪烁函数*/
  170. void mode_1(void)                                                                //实现0.5s亮灭闪烁
  171. {
  172.         P2 = 0xc0;
  173.         P0 = 0xbf;
  174.         delay(1);
  175.                
  176.         if((reset==0) && (t0>24))        P2 = 0;
  177.         else        P2 = wela[0];
  178.         P0 = dula[buff[0]];
  179.         delay(1);

  181.         if((reset==0) && (t0>24))        P2 = 0;
  182.         else        P2 = wela[1];       
  183.         P0 = dula[buff[1]];
  184.         delay(1);

  186.         if((reset==1) && (t0>24))        P2 = 0;
  187.         else        P2 = wela[2];
  188.         P0 = dula[buff[2]];
  189.         delay(1);

  191.         if((reset==1) && (t0>24))        P2 = 0;
  192.         else        P2 = wela[3];
  193.         P0 = dula[buff[3]];
  194.         delay(1);

  196.         if((reset==2) && (t0>24))        P2 = 0;
  197.         else        P2 = wela[4];
  198.         P0 = dula[buff[4]];
  199.         delay(1);

  201.         if((reset==2) && (t0>24))        P2 = 0;
  202.         else        P2 = wela[5];
  203.         P0 = dula[buff[5]];
  204.         delay(1);


  207. }

  209.         /*正计时函数*/
  210. void time_1(void)                                                                 
  211. {
  212.         second_1++;
  213.         if(second_1==60)
  214.         {
  215.                 second_1=0;
  216.                 minute_1++;
  217.                 if(minute_1==60)
  218.                 {
  219.                         minute_1=0;
  220.                         hour_1++;
  221.                         if(hour_1==24)
  222.                                 hour_1=0;
  223.                 }
  224.         }
  225. }

  227.         /*倒计时函数*/
  228. void time_2(void)                                                                 
  229. {
  230.         second_2--;
  231.         if(second_2==255)
  232.         {
  233.                 second_2=59;
  234.                 minute_2--;
  235.                 if(minute_2==255)
  236.                 {
  237.                         minute_2=59;
  238.                         hour_2--;
  239.                         if(hour_2==255)
  240.                                 hour_2=23;
  241.                 }
  242.         }
  243. }

  245.         /*加法键函数*/
  246. void oper_add(void)
  247. {
  248.         if(P35 == 0)
  249.         {
  250.                 delay(10);
  251.                 if(P35 == 0)
  252.                 {
  253.                         switch(reset)
  254.                         {
  255.                                 case 0 :
  256.                                         {
  257.                                                 second++;
  258.                                                 if(second > 59)
  259.                                                         second = 0;                                               
  260.                                         } break;
  261.                                 case 1 :
  262.                                         {
  263.                                                 minute++;
  264.                                                 if(minute > 59)
  265.                                                         minute = 0;                                               
  266.                                         } break;
  267.                                 case 2 :
  268.                                         {
  269.                                                 hour++;
  270.                                                 if(hour > 24)
  271.                                                         hour = 0;                                       
  272.                                         }
  273.                                 default : break;
  274.                         }

  276.                 }
  277.                 while(P35 == 0);
  278.         }       
  279. }

  281.         /*减法键函数*/
  282. void oper_minus(void)
  283. {
  284.         if(P34 == 0)
  285.         {
  286.                 delay(10);
  287.                 if(P34 == 0)
  288.                 {
  289.                         switch(reset)
  290. ……………………

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

所有资料51hei提供下载:
clock.zip (65.56 KB, 下载次数: 67)


评分

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

查看全部评分

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

使用道具 举报

沙发
ID:411940 发表于 2018-10-18 21:31 | 只看该作者
很厉害的程序，感谢楼主分享
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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