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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机时钟另类调时法 个十位分开调节
返回列表 发新帖
查看: 3162|回复: 1
打印 上一主题 下一主题
收起左侧

单片机时钟另类调时法 个十位分开调节

[复制链接]
跳转到指定楼层
楼主
ID:140489 发表于 2019-6-24 15:00 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
仿真 实物都通过.stc89c52  11.0592MHz晶振 ；具体电路见仿真图；仿真用5位数码管显示88-88的样式

一个按键调节时间：

1.长按key1，进入调时状态，小时十位开始闪烁，此时再短按key1，小时十位加加，
  小时十位在0-2之间变化；（key1可以是按钮，也可以用触摸开关）
2.调好后，过5秒自动跳到小时个位闪烁，此时再短按key1，小时个位加加，如果十位是0、1，
  小时个位再0-9之间变化；如果十位是2，小时个位在0-3之间变化；
3.小时个位调好后，过5秒，分钟十位开始闪烁，此时再短按key1，分钟十位加加，分钟十位在0-5
  之间变化；
4.分钟十位调好后，过5秒，分钟个位开始闪烁，此时再短按key1，分钟个位加加，分钟个位在0-9
  之间变化；
5.分钟个位调好后，过5秒，退出调时状态，时钟正常走时。

在非调时状态，短按key1，开关LED灯；

小时 、分钟的个位、十位分开调节，这样比常规的个位、十位在一起调时快；


单片机源程序如下:
  1. /*********************************************************************************

  3. 仿真 实物都通过.stc89c52  11.0592MHz晶振 ；具体电路见仿真图；仿真用5位数码管显示88-88的样式

  5. 一个按键调节时间：

  7. 1.长按key1，进入调时状态，小时十位开始闪烁，此时再短按key1，小时十位加加，
  8.   小时十位在0-2之间变化；（key1可以是按钮，也可以用触摸开关）
  9. 2.调好后，过5秒自动跳到小时个位闪烁，此时再短按key1，小时个位加加，如果十位是0、1，
  10.   小时个位再0-9之间变化；如果十位是2，小时个位在0-3之间变化；
  11. 3.小时个位调好后，过5秒，分钟十位开始闪烁，此时再短按key1，分钟十位加加，分钟十位在0-5
  12.   之间变化；
  13. 4.分钟十位调好后，过5秒，分钟个位开始闪烁，此时再短按key1，分钟个位加加，分钟个位在0-9
  14.   之间变化；
  15. 5.分钟个位调好后，过5秒，退出调时状态，时钟正常走时。

  17. 在非调时状态，短按key1，开关LED灯；

  19. 小时 、分钟的个位、十位分开调节，这样比常规的个位、十位在一起调时快；
  20. **********************************************************************************/
  21. #include<reg52.h>
  22. #include<intrins.h>
  23. #define uchar unsigned char
  24. #define uint unsigned int

  26. sbit sclk = P1^0;
  27. sbit dio = P1^1;
  28. sbit ce = P1^2;
  29. sbit wela = P2^7;
  30. sbit dula = P2^6;
  31. sbit led = P1^7;

  33. sbit key1=P3^0;                                                        //按键 多功能

  35. uchar knum=0,ssnum,fsnum,sgnum,fgnum;  //调时 位 闪烁变量

  37. uchar shi,fen,miao;

  39. uchar ss;        //秒点闪烁变量

  41. bit zdyw; //自动移位标志

  43. uchar count;//自动移位时间计数变量
  44. /***********写时分秒地址************/
  45. #define write_shi  0x84
  46. #define write_fen  0x82
  47. #define write_miao 0x80
  48. #define write_ram  0xc0
  49. /***********读时分秒地址************/
  50. #define read_shi  0x85
  51. #define read_fen  0x83
  52. #define read_miao 0x81
  53. #define read_ram  0xc1
  54.                   // 0     1    2    3    4     5    6    7    8   9
  55. uchar code d[]={ 0x3F,0x06,0x5B,0x4F,0x66, 0x6D,0x7D,0x07,0x7F,0x6F}; //共阴不带小数点
  56. uchar code dd[]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef};//        共阴带小数点

  58. //uchar dd[]={0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};                //共阳带小数点
  59. //uchar d[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xd8,0x80,0x90};                //共阳不带小数点

  61. void delay(uint z)
  62. {
  63.         uint x,y;
  64.         for(x=z;x>0;x--)
  65.                 for(y=120;y>0;y--);
  66. }


  69. void t0_init()  //定时50ms中断
  70. {
  71.    
  72.   TMOD=0X01;
  73.   TH0=(65536-46080)/256;
  74.   TL0=(65536-46080)%256;
  75.   EA=1;
  76.   ET0=1;
  77.   TR0=1;
  78.   ET1=1;

  80. }


  83. void display(uchar shi,uchar fen)                          //显示函数
  84. {
  85.         if(knum==0)
  86.         {
  87.                 ssnum=30;
  88.                 fsnum=30;
  89.                 sgnum=30;
  90.                 fgnum=30;
  91.         }
  92.         
  93.         if(knum==3)
  94.         {
  95.                 fsnum++;
  96.                 ssnum=30;
  97.                 fgnum=30;
  98.                 sgnum=30;
  99.         }
  100.         
  101.         if(knum==4)
  102.         {
  103.                 fgnum++;
  104.                 ssnum=30;
  105.                 fsnum=30;
  106.                 sgnum=30;
  107.         }

  109.         if(knum==1)
  110.         {
  111.                 ssnum++;
  112.                 sgnum=30;
  113.                 fgnum=30;
  114.                 fsnum=30;
  115.         }
  116.         
  117.         if(knum==2)
  118.         {
  119.                 sgnum++;
  120.                 ssnum=30;
  121.                 fsnum=30;
  122.                 fgnum=30;
  123.         }
  124.         
  125.         
  126.         if(ssnum>=30)
  127.         {        
  128. //                if((shi/10)<1)         //如果小时十位小于1，
  129. //                {
  130. //                        wela=1;
  131. //                        P0=0xfe;                //第1位
  132. //                        wela=0;
  133. //        
  134. //                        dula = 1;
  135. //                        P0=0xff;           // 小时十位就不显示
  136. //                        dula = 0;
  137. //                }
  138. //               
  139. //                else
  140.                 {
  141.                         wela=1;
  142.                         P0=0xfe;          //第1位
  143.                         wela=0;
  144.         
  145.                         dula=1;
  146.                         P0=d[shi/10];
  147.                         dula=0;
  148.                         P0=0xff;
  149.                         delay(2);
  150.                 }

  152.                 if(ssnum==60)
  153.                         ssnum=0;

  155.          }

  157.          if(sgnum>=30)
  158.          {
  159.                 wela=1;
  160.                 P0=0xfd;           //第2位
  161.                 wela=0;

  163.                 dula=1;
  164.                 P0=d[shi%10];                        //时的个位，P0=d[shi%10]时的个位小数点闪烁
  165.                 dula=0;                                        // 时的个位，P0=dd[shi%10]时的个位小数点不闪烁
  166.                 P0=0xff;
  167.                 delay(2);
  168.                
  169.         
  170.         
  171.                 if(sgnum==60)
  172.                         sgnum=0;
  173.         }               


  176.         //        if(miao%2==0)         //if(miao%2==0) 1秒闪烁1次
  177.                 if(ss>=10)                 //        这里写为ss>=10，闪烁频率可调
  178.                 {                                 
  179.                     wela=1;
  180.                         P0=0xfb;                //第3位
  181.                         wela=0;
  182.         
  183.                         dula=1;
  184.                         P0=0x40;          //第三位数码管显示“— ”
  185.                         
  186.                 //        P0=0x09;          //第三位数码管显示“= ”
  187.                         dula=0;
  188.                         P0=0xff;
  189.                         delay(2);
  190.         
  191.                 }

  193.                 else
  194.                 {
  195.                         wela=1;
  196.                         P0=0xfb;   //第3位
  197.                         wela=0;
  198.         
  199.                         dula=1;
  200.                         P0=0;          //第三位数码管不显示
  201.                         dula=0;
  202.                         P0=0xff;
  203.                         delay(2);        
  204.                 }
  205.         
  206.         
  207.         if(fsnum>=30)
  208.         {
  209.                 wela=1;
  210.                 P0=0xf7;         //第4位
  211.                 wela=0;

  213.                 dula=1;
  214.                 P0=d[fen/10];
  215.                 dula=0;
  216.                 P0=0xff;
  217.                 delay(2);
  218.                
  219.                
  220. //                wela=1;
  221. //                P0=0xef;         //第5位
  222. //                wela=0;
  223. //
  224. //                dula=1;
  225. //                P0=d[fen%10];
  226. //                dula=0;
  227. //                P0=0xff;
  228. //                delay(2);
  229.         
  230.                
  231.                 if(fsnum==60)
  232.                         fsnum=0;
  233.         }

  235.         if(fgnum>=30)
  236.         {
  237.                 wela=1;
  238.                 P0=0xef;         //第5位
  239.                 wela=0;

  241.                 dula=1;
  242.                 P0=d[fen%10];
  243.                 dula=0;
  244.                 P0=0xff;
  245.                 delay(2);

  247.                 if(fgnum==60)
  248.                         fgnum=0;

  250.          }
  251.                
  252.         //        if(miao%2==0)         //if(miao%2==0) 1秒闪烁1次
  253. //                if(ss>=10)                 //if(ss>=10)闪烁频率可调
  254. //                {
  255. //                        wela=1;
  256. //                        P0=0xdf;          //第6位
  257. //                        wela=0;
  258. //                        dula=1;
  259. //                        P0=0x40;          //第六位数码管显示“— ”
  260. //                        dula=0;
  261. //                        P0=0xff;
  262. //        
  263. //                        delay(2);
  264. //                }
  265. //
  266. //                else
  267. //                {
  268. //                        wela=1;
  269. //                        P0=0xdf;   //第6位
  270. //                        wela=0;
  271. //                        dula=1;
  272. //                        P0=0;          //第六位数码管不显示
  273. //                        dula=0;
  274. //                        P0=0xff;
  275. //        
  276. //                        delay(2);
  277. //                }
  278. //               
  279. //               
  280. //                wela=1;
  281. //                P0=0xbf;                //第7位
  282. //                wela=0;
  283. //
  284. //            dula=1;
  285. //                P0=d[miao/10];                           //秒十位
  286. //                dula=0;
  287. //                P0=0xff;
  288. //                delay(2);
  289. //        
  290. //
  291. //                wela=1;
  292. //                P0=0x7f;                          //第8位
  293. //                wela=0;
  294. //
  295. //                dula=1;
  296. //                P0=d[miao%10];                         //秒个位
  297. //                dula=0;
  298. //                P0=0xff;
  299. //                delay(2);               
  300.         
  301. }  



  305. void write_1302(uchar add,dat)                 //写1302函数  qx
  306. {
  307.         uchar i,temp;
  308.         temp=add;
  309.         ce=0;
  310.         _nop_();
  311.         sclk=0;
  312.         _nop_();
  313.         ce=1;
  314.         _nop_();
  315.         for(i=0;i<8;i++)
  316.         {
  317.                 sclk=0;
  318.                 _nop_();
  319.                 if((temp&0x01)==0x01)
  320.                         dio=1;
  321.                         else
  322.                         dio=0;
  323.                 temp>>=1;
  324.                 sclk=1;
  325.                 _nop_();
  326.         }
  327.         temp=dat;
  328.         for(i=0;i<8;i++)
  329.         {
  330.                 sclk=0;
  331.                 _nop_();
  332.                 if((temp&0x01)==0x01)
  333.                         dio=1;
  334.                         else
  335.                         dio=0;
  336.                 temp>>=1;
  337.                 sclk=1;
  338.                 _nop_();
  339.         }
  340.         ce=0;
  341.         sclk=0;
  342. }
  343. uchar read_1302(uchar add)                                   //读1302函数                qx
  344. {
  345.         uchar dat,dat1,i,temp;
  346.         temp=add;
  347.         ce=0;
  348.         _nop_();
  349.         sclk=0;
  350.         _nop_();
  351.         ce=1;
  352.         for(i=0;i<8;i++)
  353.         {
  354.                 sclk=0;
  355.                 _nop_();
  356.                 if((temp&0x01)==0x01)
  357.                         dio=1;
  358.                         else
  359.                         dio=0;
  360.                 temp>>=1;
  361.                 sclk=1;
  362.                 _nop_();
  363.         }
  364.         for(i=0;i<8;i++)
  365.         {
  366.                 sclk=0;
  367.                 _nop_();
  368.                 if(dio)
  369.                     dat|=0x80;
  370.                 if(i<7)
  371.                         dat>>=1;
  372.                 sclk=1;
  373.         }
  374.         dat1=dat/16;         //读出的数值转为10进制
  375.         dat=dat%16;
  376.         dat=dat1*10+dat;  
  377.         ce=0;
  378.         sclk=0;
  379.         return dat;
  380. }                        


  383. void init_1302()                                                        //初始化函数 设置第一次上电时显示的时间值
  384. {        
  385.         write_1302(0x8e,0x00);                                        //保护取消，可以进行写操作
  386.         write_1302(write_miao,0x57);                        //写秒57
  387.         write_1302(write_fen,0x30);                                //写分30
  388.         write_1302(write_shi,0x12);                                //写时12
  389.         write_1302(0x8e,0x80);                                        //保护启动，不能进行写操作
  390. }         

  392. void read_sf()                           //读时分秒
  393. {
  394.         shi=read_1302(read_shi);
  395.         fen=read_1302(read_fen);
  396.         miao=read_1302(read_miao);
  397.         display(shi,fen);

  399. }



  403. void keyscan()                                                                   //按键扫描函数
  404. {        
  405.         uchar fs,fg,shs,shg;                                   //分钟十位、个位 ，小时十位、个位
  406.         static uint a;                                                   //按键延时变量
  407.         fs = fen/10; fg=fen%10;                                   //分钟十位、个位
  408.         shs = shi/10; shg=shi%10;                       //小时十位、个位

  410.         if(key1==0)
  411.         {
  412.                 a++;
  413.                 if(a>50)
  414.                 while(!key1)
  415.                 {
  416.                         display(shi,fen);
  417.                         a=0;
  418.                         zdyw=1;
  419.                 }
  420.         }

  422.         else
  423.         {
  424.                 if(a>10 && a<50)
  425.                 {
  426.                         count=0;                //每次按下，count都要清零，松手后，count都是从0开始计数，这句很重要
  427.                         a=0;

  429.                         if(knum==1)                                                //小时十位调节
  430.                         {
  431.                                 shs++;
  432.                                 if(shs>2) shs=0;
  433.                                 shi=shs*16+shg;
  434.                                 write_1302(write_shi,shi);        //写入1302
  435.                                 read_sf();                                        //读出时间，然后显示
  436.                         }
  437.         /*********************/
  438.                         if(knum==2)                                                //小时个位调节
  439.                         {
  440.                
  441.                                 shg++;
  442.                                 if(shs==0 || shs==1)   //如果小时十位为0、1
  443.                                 {
  444.                                         if(shg>9) shg=0;   //小时个位可以在0-9变化
  445.                                 }
  446.                                 else                                   //否则，小时个位可以在0-3变化
  447.                                 {
  448.                                         if(shg>3) shg=0;   
  449.                                 }
  450.                                 shi=shs*16+shg;                   //10进制转为16进制
  451.                                 write_1302(write_shi,shi);        //写入1302
  452.                                 read_sf();                                        //读出时间，然后显示
  453.                         }
  454. /************************/

  456.                         if(knum==3)                                                //分钟十位调节
  457.                         {
  458.                                 fs++;
  459.                                 if(fs>5) fs=0;
  460.                                 fen=fs*16+fg;
  461.                                 write_1302(write_fen,fen);        //写入1302
  462.                                 read_sf();                                        //读出时间，然后显示
  463.                         }
  464.         /*******************/
  465.                          if(knum==4)                                        //分钟个位调节
  466.                          {
  467.                                 fg++;
  468.                                 if(fg>9) fg=0;
  469.                                 fen=fs*16+fg;
  470.                                 write_1302(write_fen,fen);        //写入1302
  471.                                 read_sf();                                        //读出时间，然后显示
  472.                          }
  473.         
  474.         /***********************/

  476.                         if(knum==0)                                                //非调时状态，短按key1，开关LED
  477.                         {
  478.                                 led=~led;
  479.                         }
  480.                 }
  481.         }           
  482. }

  484. /************************/

  486. void main()
  487. {
  488.         t0_init();
  489.         init_1302();                          
  490.         while(1)
  491.         {
  492.             read_sf();
  493.             keyscan();
  494.         }
  495. }

  497. void temer1() interrupt 1
  498. {
  499.         TH0=(65536-46080)/256;
  500.         TL0=(65536-46080)%256;
  501.         ss++;
  502.         if(ss==20)          //1秒时间到
  503.         {
  504.                 ss=0;
  505.                 if(zdyw)
  506.                 {
  507.                         count++;
  508.                         if(count==5) //调时的时候，自动移位快慢调这里，要快就把count的值减小，反之亦然。
  509.                         {
  510.                                 count=0;
  511.                                 knum++;
  512.                                 if(knum==1)
  513.                                 {
  514.                                          write_1302(0x8e,0x00);                //写保护取消
  515. //                                        write_1302(write_miao,0x80); //  写秒80，时钟停止走时;                        
  516.                                 }
  517.                                 if(knum>4)
  518.                                 {
  519.                                         knum=0;
  520.                                         zdyw=0;
  521.                                         write_1302(write_miao,0x00);
  522.                                         write_1302(0x8e,0x80);                //写保护启动
  523.                                 }
  524.                         }        
  525.                 }                        
  526.         }
  527. }         
复制代码
全部资料51hei下载地址：
时钟个十位分开调节 -1键调节.rar (181.79 KB, 下载次数: 15)

评分

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

查看全部评分

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

使用道具 举报

沙发
ID:768299 发表于 2020-6-3 12:12 | 只看该作者
膜拜大佬
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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