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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › STC89C52单片机+DS1302+数码管显示及按键调时的时钟程序 ...
返回列表 发新帖
查看: 3484|回复: 0
收起左侧

STC89C52单片机+DS1302+数码管显示及按键调时的时钟程序Proteus仿真图

[复制链接]
ID:603753 发表于 2021-11-13 09:58 | 显示全部楼层 |阅读模式
STC89C52单片机+DS1302+数码管显示时钟及按键时+整点报时功能
资料含有程序源代码+及仿真原理图
仿真软件运行和实际焊接电路运行都通过验证。
//注意事项：//:仿真时请将程序char H=0,L=1,开发板下载试验请将变量char H=1  ,L=0;
//:请屏蔽此 DS1302初始化 //init_1302(); 函数。
void main()
{
        t0_init();
        t1_init();
        //init_1302();                //仿真时如你需要显示当前实时系统时间，请屏蔽此函数。          
        while(1)
        {
           read_sf();
           ExecuteKeyNum();
        }
        
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）
51hei.gif 说明2.jpg 说明.jpg
1》按下设置启动键：分钟闪烁进入分钟调时，再次按下小时闪烁进入小时调时
2》按下参数加或参数减按钮：进行小时后分钟的时间设置
注意：仿真时请将程序里WELA的变量H=0  L=1,开发板试验请将变量H=1  L=0;

单片机源程序如下:
  1. /*********************************************************************************
  2. 描述： 8位共阴数码管时钟，显示88-88-88样式，正常走时的时候，两个“-”0.5秒闪烁一次；
  3.        调时：按KEY1按键第1次分钟位闪烁，再按KEY2一次分钟加1，按KEY3一次分钟减1，长按连加连减；
  4.                          按KEY1按键第2次小时位闪烁，再按KEY2一次小时加1，按KEY3一次小时减1，长按连加连减；
  5.                          按KEY1按键第3次，秒从零开始累加，时钟回到正常走时；
  6.                          对时的时候先调好时、分，分钟要比参考时间的分钟加1分，
  7.                          再看参考时间的秒数到了59再按KEY1按键的第3次，这样对时可以很准的
  8. 仿真 实物都通过.  11.0592MHz晶振，STC89C52RC，两个74HC573锁存器做位选、段选
  9. **********************************************************************************/
  10. #include<reg52.h>
  11. #include<intrins.h>

  13. #define uchar unsigned char
  14. #define uint unsigned int

  16. sbit sclk = P2^4;                                                                //1302时钟端口
  17. sbit dio = P2^5;                                                                //1302数据端口
  18. sbit ce = P2^6;
  19.                                                                         //1302使能
  20. sbit wela1 = P2^0;                                                                //位选
  21. sbit wela2 = P2^1;                                                                //位选
  22. sbit wela3 = P2^2;        
  23. sbit wela4 = P2^3;        

  25. sbit buzzer=P3^7;

  27. sbit KEY1=P3^0;                                                                        //按键 设置/确认
  28. sbit KEY2=P3^1;                                                                        //按键 加
  29. sbit KEY3=P3^2;                                                                        //按键 减

  31. uchar snum,fnum;

  33. char shi,fen,miao,shi_alarm=6;

  35. uchar ss,mm;
  36. char H=0,L=1;                                                //用软件仿真时关闭数码管H全部改为0，单片机下载H改为1.
  37. char FunctionKeyNum=0;                                //功能键键值
  38. char FuncTempNum=0;                                        //功能键临时键值
  39. typedef enum KeyState{StateInit,StateAffirm,StateSingle,StateRepeat};        //键值状态值


  42. /***********写时DS1302地址************/
  43. #define write_year  0x8c         //写年的地址
  44. #define write_moon  0x88         //写月的地址
  45. #define write_week  0x8a         //写周的地址
  46. #define write_day   0x86         //写日的地址
  47. #define write_shi  0x84                 //写时的地址
  48. #define write_fen  0x82                 //写分的地址
  49. #define write_miao 0x80                 //写秒的地址
  50. #define write_ram  0xc0                 ////RAM的基地址
  51. /***********读时DS1302地址************/
  52. #define read_year  0x8d                 //读年的地址
  53. #define read_moon  0x89                 //读月的地址
  54. #define read_week 0x8b                 //读周的地址
  55. #define read_day  0x87                 //读日的地址
  56. #define read_shi  0x85                 //读时的地址
  57. #define read_fen  0x83                 //读分的地址
  58. #define read_miao 0x81                 //读秒的地址
  59. #define read_ram  0xc1                 //RAM的基地址
  60.                   // 0     1    2    3    4     5    6    7    8   9
  61. //uchar d[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F}; //共阴不带小数点
  62. //uchar d[]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef};  //        共阴带小数点
  63. uchar d[]={0Xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};          //共阳极
  64. uchar dd[]={0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};          //共阳极带小数点

  66. void Time_alarm();                 //整点报时子程序

  68. void delayms(uint z)
  69. {
  70.         uint x,y;
  71.         for(x=z;x>0;x--)
  72.                 for(y=120;y>0;y--);
  73. }
  74. /*
  75. void buzzer1()
  76. {
  77. uint i;
  78. for(i=0;i<10;i++)
  79.         {
  80.     buzzer=0;
  81.         delayms(500);
  82.         buzzer=1;
  83.         delayms(500);
  84.         }
  85. }
  86. */
  87. void buzzer2() //发声子程序
  88. {
  89.          
  90.           uint t,tt;
  91.           for(t=0;t<50;t++) //45为蜂鸣器发声频率
  92.           {
  93.           buzzer=!buzzer;
  94.           for(tt=0;tt<50;tt++); //45为蜂鸣器发声频率
  95.           }
  96. }



  100. void t0_init()  //定时50ms一个中断
  101. {
  102.    
  103.   TMOD |= 0X01;
  104.   TH0 = (65536-46080)/256;
  105.   TL0 = (65536-46080)%256;
  106.   EA = 1;
  107.   ET0 = 1;
  108.   TR0 = 1;

  110. }

  112. void t1_init()
  113. {
  114.         TMOD |= 0x10;
  115.         TH1 = 0x500;
  116.         TL1 = 0x00;
  117.         TR1 = 1;        
  118. }

  120. void temer0() interrupt 1
  121. {
  122.   TH0=(65536-46080)/256;
  123.   TL0=(65536-46080)%256;
  124.   ss++;
  125.   mm++;
  126.   if(ss==22)
  127.   {
  128.   ss=0;
  129.   }
  130.   if(mm==10)
  131.   {
  132.    mm=0;
  133.    Time_alarm();   
  134. }
  135. }         





  141. void Display(uchar shi,uchar fen)                          //显示函数
  142. {
  143.         if(FunctionKeyNum==0)
  144.         {
  145.                 snum=30;
  146.                 fnum=30;
  147.         }
  148.         
  149.         if(FunctionKeyNum==1)
  150.         {
  151.                 fnum++;
  152.                 snum=30;
  153.         }
  154.         
  155.         if(FunctionKeyNum==2)
  156.         {
  157.                 snum++;
  158.                 fnum=30;
  159.         }
  160.         
  161.             wela1=H;   //关闭所有数码管
  162.                 wela2=H;   //用软件仿真时关闭数码管H全部改为0，单片机下载H改为1.
  163.                 wela3=H;   //用软件仿真时关闭数码管H全部改为0，单片机下载H改为1.
  164.                 wela4=H;

  166.         
  167.         if(snum>=30)
  168.         {        
  169.                 if((shi/10)<1)         //如果小时十位小于1，
  170.                 {        
  171.                 wela1=L;                 // 小时十位就不显示                  
  172.                 P0=d[0];                           // 小时十位就显示"0"
  173.                 delayms(2);
  174.                 P0=0xff;
  175.                 wela1=H;
  176.         
  177.                 }
  178.         
  179.                 else
  180.                 {
  181.                 wela1=L;
  182.                 P0=d[shi/10];
  183.                 delayms(2);
  184.                 P0=0xff;
  185.                 wela1=H;

  187.                 }
  188.   
  189.         if(miao%2==0)            //if(miao%2==0) 1秒闪烁1次
  190.   //        if(ss>=20)                 //        这里写为ss>=10，闪烁频率可调
  191.                 {                                 
  192.             wela2=L;
  193.                 P0=dd[shi%10];
  194.                 delayms(2);
  195.                 P0=0xff;
  196.                 wela2=H;
  197.               }
  198.                
  199.                 else
  200.                 {
  201.                 wela2=L;
  202.                 P0=d[shi%10];                                                        
  203.                 delayms(2);
  204.                 P0=0xff;
  205.                 wela2=H;
  206.                 }

  208.                 if(snum==60)
  209.                         snum=0;
  210.         }  
  211.                         
  212.    //        if(miao%2==0)         //if(miao%2==0) 1秒闪烁1次
  213.                   if(ss>=20)                 //        这里写为ss>=10，闪烁频率可调
  214.                 {                                 
  215.             wela2=L;
  216.                 P0=d[shi%10];
  217.                 delayms(2);
  218.                 P0=0xff;
  219.                 wela2=H;
  220.               }
  221.                                 
  222.         if(fnum>=30)
  223.         {  
  224.                 wela3=L;
  225.                 P0=d[fen/10];
  226.                 delayms(2);
  227.                 P0=0xff;
  228.                 wela3=H;
  229.                         
  230.                 wela4=L;
  231.                 P0=d[fen%10];
  232.                 delayms(2);
  233.                 P0=0xff;
  234.                 wela4=H;
  235.                
  236.                
  237.                 if(fnum==60)
  238.                         fnum=0;
  239.                                 }         
  240. }


  243. void write_1302(uchar add,dat)                 //写1302函数  
  244. {
  245.         uchar i,temp;
  246.         temp=add;
  247.         ce=0;
  248.         _nop_();
  249.         sclk=0;
  250.         _nop_();
  251.         ce=1;
  252.         _nop_();
  253.         for(i=0;i<8;i++)
  254.         {
  255.                 sclk=0;
  256.                 _nop_();
  257.                 if((temp&0x01)==0x01)
  258.                         dio=1;
  259.                         else
  260.                         dio=0;
  261.                 temp>>=1;
  262.                 sclk=1;
  263.                 _nop_();
  264.         }
  265.         temp=dat;
  266.         for(i=0;i<8;i++)
  267.         {
  268.                 sclk=0;
  269.                 _nop_();
  270.                 if((temp&0x01)==0x01)
  271.                         dio=1;
  272.                         else
  273.                         dio=0;
  274.                 temp>>=1;
  275.                 sclk=1;
  276.                 _nop_();
  277.         }
  278.         ce=0;
  279.         sclk=0;
  280. }
  281. uchar read_1302(uchar add)                                   //读1302函数               
  282. {
  283.         uchar dat,dat1,i,temp;
  284.         temp=add;
  285.         ce=0;
  286.         _nop_();
  287.         sclk=0;
  288.         _nop_();
  289.         ce=1;
  290.         for(i=0;i<8;i++)
  291.         {
  292.                 sclk=0;
  293.                 _nop_();
  294.                 if((temp&0x01)==0x01)
  295.                         dio=1;
  296.                         else
  297.                         dio=0;
  298.                 temp>>=1;
  299.                 sclk=1;
  300.                 _nop_();
  301.         }
  302.         for(i=0;i<8;i++)
  303.         {
  304.                 sclk=0;
  305.                 _nop_();
  306.                 if(dio)
  307.                     dat|=0x80;
  308.                 if(i<7)
  309.                         dat>>=1;
  310.                 sclk=1;
  311.         }
  312.         dat1=dat/16;
  313.         dat=dat%16;
  314.         dat=dat1*10+dat;  
  315.         ce=0;
  316.         sclk=0;
  317.         return dat;
  318. }                        



  322. void init_1302()                                                        //初始化函数 设置时间
  323. {        
  324.         write_1302(0x8e,0x00);                                        //保护取消，可以进行写操作
  325.         write_1302(write_year,0x20);
  326.         write_1302(write_moon,0x12);                        //写入时修改月
  327.         write_1302(write_week,0x30);                        //写入时修改星期
  328.         write_1302(write_day,0x04);                           //写时修改日期
  329.         write_1302(write_miao,0x00);        
  330.         write_1302(write_fen,0x30);
  331.         write_1302(write_shi,0x10);
  332.         write_1302(0x8e,0x80);                                        //保护启动，不能进行写操作
  333. }         

  335. void read_sf()
  336. {
  337.         shi=read_1302(read_shi);
  338.         fen=read_1302(read_fen);
  339.         miao=read_1302(read_miao);
  340.         Display(shi,fen);

  342. }

  344. void KeyScan(void)
  345. {
  346.         static uchar KeyStateTemp1 = 0;                  //按键状态临时存储值1
  347.         static uchar KeyStateTemp2 = 0;                  //按键状态临时存储值2
  348.         static uchar KeyStateTemp3 = 0;                  //按键状态临时存储值3
  349.         static uchar KeyTime = 0;                          //按键延时时间
  350.         bit KeyPressTemp1;                                          //按键是否按下存储值1
  351.         bit KeyPressTemp2;                                          //按键是否按下存储值2
  352.         bit KeyPressTemp3;                                          //按键是否按下存储值3

  354.         KeyPressTemp1 = KEY1;                                  //读取IO口的键值
  355.         switch(KeyStateTemp1)
  356.         {
  357.                 case StateInit:
  358.                         if(!KeyPressTemp1)                                        //KEY1按下
  359.                                 KeyStateTemp1 = StateAffirm;        //按键状态切换到确认态
  360.                 break;
  361.                 case StateAffirm:                                                //确认状态
  362.                         if(!KeyPressTemp1)                                        //按键还在按下
  363.                         {
  364.                                 KeyTime = 0;
  365.                                 KeyStateTemp1 = StateSingle;        //按键状态切换到单击状态
  366.                         }
  367.                         else KeyStateTemp1 = StateInit;                //否则按键抬起，回到初始态
  368.                 break;
  369.                
  370.                 case StateSingle:                                                //单击
  371.                          if(KeyPressTemp1)
  372.                          {
  373.                                 KeyStateTemp1 = StateInit;                 //按键释放
  374.                                 FuncTempNum++;                                         //键值加1
  375.                                 if(FuncTempNum>3)  
  376.                                 FuncTempNum = 0;
  377.                          }

  379.                          else if(++KeyTime>100)
  380.                          {
  381.                                          KeyPressTemp1 = StateRepeat;
  382.                                         KeyTime = 0;
  383.                          }
  384.                 break;
  385.         
  386.                 case StateRepeat:                                                 //连发
  387.                         if(KeyPressTemp1)
  388.                                 KeyStateTemp1 = StateInit;
  389.                         else
  390.                         {
  391.                                 if(++KeyTime > 10)
  392.                                 {
  393.                                         KeyTime = 0;
  394.                                         FuncTempNum++;
  395.                                         if(FuncTempNum>3)  
  396.                                         FuncTempNum = 0;
  397.                                 }
  398.                                 break;
  399.                         }
  400.                 break;
  401.         
  402.                 default :KeyStateTemp1 = KeyStateTemp1 = StateInit; break;
  403.                         
  404.         }


  407. if(FuncTempNum)                                                                //只有功能键被按下后，增加和减小键才有效
  408.         {
  409.                 KeyPressTemp2 = KEY2;                                        //读取I/O口的键值
  410.                 switch(KeyStateTemp2)
  411.                 {        
  412.                         case StateInit:                                                //按键初始状态
  413.                                 if(!KeyPressTemp2)                                //当按键按下，状态切换到确认态
  414.                                         KeyStateTemp2 = StateAffirm;
  415.                                 break;
  416.                         case StateAffirm:                                        //按键确认态
  417.                                 if(!KeyPressTemp2)
  418.                                 {
  419.                                         KeyTime = 0;
  420.                                         KeyStateTemp2 = StateSingle;//切换到单次触发态        
  421.                                 }
  422.                                 else KeyStateTemp2 = StateInit; //按键已抬起，切换到初始态
  423.                                 break;
  424.                         case StateSingle:                                        //按键单发态
  425.                                 if(KeyPressTemp2)                                //按下时间小于1s
  426.                                 {
  427.                                         KeyStateTemp2 = StateInit;  //按键释放，则回到初始态
  428.                                         if(FunctionKeyNum == 1)                //若功能键第一次按下
  429.                                         {
  430.                                         fen++;
  431.                                         fen=fen/10*16+fen%10;                //转为16进制
  432.                                         if(fen==0x60)
  433.                                             fen=0x00;
  434.                                            write_1302(write_fen,fen);        //写入1302
  435. ……………………

  437. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码
51hei.png
所有资料51hei附件下载:
STC89C52单片机+DS1302+数码管显示及按键调时的时钟程序.7z (72.88 KB, 下载次数: 58)

评分

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

查看全部评分

回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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