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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机+1302数码管时钟程序调不了时间
返回列表 发新帖
查看: 2173|回复: 12
收起左侧

单片机+1302数码管时钟程序调不了时间

[复制链接]
ID:725922 发表于 2021-9-26 00:07 | 显示全部楼层 |阅读模式
参考了几个程序的核心部分，自己修改组合了一下，就想实现一个基本的可调时钟。一共3个按键，设置，加，减。按设置可以在时，分钟之间切换，同时相应位会闪烁。秒是采用的led指示，通过定时器中断试验出的计数值来控制，不是特别准确，主要起装饰作用。。目前的现象是，能按照初始时间走时，按设置能切换闪烁，但无法加减小时或者分钟，应该是往1302写数据的程序有问题，但也没看出来有什么问题，没有解决的思路了，希望各位高手指点一下错误。

单片机源程序如下:
  1. #include<reg52.h>
  2. #include <intrins.h>
  3. #define uint unsigned int
  4. #define uchar unsigned char
  5. uint milsec;
  6. uchar i,t,a,d,sec,hour,hour1,min,min1,flag,temp,key=0,S_flag=0,k=0;

  8. unsigned char led[12]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0xbf,0xff};  //用一维数组定义0-9、横杠、全灭

  10. unsigned char b[4]={0x07,0x0b,0x0d,0x0e}; //扫描

  12. unsigned char c[4];

  14. sbit dula=P2^6;
  15. sbit wela=P2^7;

  17. sbit SCLK=P1^0;    //1302接口
  18. sbit IO=P1^1;
  19. sbit RST=P1^2;

  21. sbit ACC0=ACC^0;
  22. sbit ACC7=ACC^7;

  24. //sbit key=P3^7;                //按键接口
  25. sbit key1=P3^3;
  26. sbit key2=P3^1;
  27. sbit key3=P3^2;
  28. sbit S5=P1^3;                 //指示秒的led

  30. void delay(uint xms)//ms延时函数
  31. {
  32.         uint x,y;
  33.         for(x=xms;x>0;x--)
  34.          for(y=110;y>0;y--);
  35. }


  38. /*********************over***********************/
  39. /********************ds1302****************************/
  40. void write_byte(uchar dat)
  41. {
  42.         ACC=dat;
  43.         RST=1;
  44.         for(a=8;a>0;a--)
  45.         {
  46.                 IO=ACC0;
  47.                 SCLK=0;
  48.                 SCLK=1;
  49.                 ACC=ACC>>1;
  50.         }
  51. }
  52. uchar read_byte()
  53. {
  54.         RST=1;
  55.         for(a=8;a>0;a--)
  56.         {
  57.                 ACC7=IO;
  58.                 SCLK=1;
  59.                 SCLK=0;
  60.                 ACC=ACC>>1;

  62.         }
  63.         return (ACC);
  64. }
  65. void write_1302(uchar add,uchar dat)
  66. {

  68.         RST=0;
  69.         SCLK=0;
  70.         RST=1;
  71.         write_byte(add);
  72.         write_byte(dat);
  73.         SCLK=1;
  74.         RST=0;
  75. }
  76. uchar read_1302(uchar add)
  77. {
  78.         uchar temp;
  79.         RST=0;
  80.         SCLK=0;
  81.         RST=1;
  82.         write_byte(add);
  83.         temp=read_byte();
  84.         SCLK=1;
  85.         RST=0;
  86.         return(temp);
  87. }
  88. uchar BCD_Decimal(uchar bcd)
  89. {
  90. uchar Decimal;
  91. Decimal=bcd>>4;
  92. return(Decimal=Decimal*10+(bcd&=0x0F));
  93. }

  95. uchar Decimal_BCD(uchar dec)
  96. {
  97.   uchar bcd;
  98.   bcd=((dec%10)&0x0f)|(((dec/10)<<4)&0xf0);
  99.   return bcd;
  100. }



  104. void ds1302_init()
  105. {
  106. RST=0;
  107. SCLK=0;
  108. write_1302(0x8e,0x00);          //关写保护

  110. write_1302(0xc0,0xfe);         
  111. write_1302(0xc2,0xff);
  112.         
  113. write_1302(0x80,0x00);  //写初始sec
  114. write_1302(0x82,0x10);        //写初始min
  115. write_1302(0x84,0x18);         //写初始hour
  116.         
  117. write_1302(0x8e,0x80);        //开写保护

  119. }




  124. void display()
  125. {
  126.         
  127.     switch(key)
  128.         {
  129.         case 0: c[0]=led[hour/10];
  130.                         c[1]=led[hour%10];
  131.                         c[2]=led[min/10];
  132.                     c[3]=led[min%10];
  133.                         break;

  135.         case 1:        if(S_flag==0)   
  136.             {     
  137.                         c[0]=led[hour/10];
  138.                         c[1]=led[hour%10];
  139.             }   
  140.             else   
  141.             {
  142.                         c[0]=0xff;
  143.                         c[1]=0xff;
  144.             }   
  145.                         
  146.                         c[2]=led[min/10];
  147.                         c[3]=led[min%10];
  148.                         break;

  150.         case 2:        c[0]=led[hour/10];
  151.                         c[1]=led[hour%10];
  152.                
  153.                 if(S_flag==0)   
  154.             {     
  155.                         c[2]=led[min/10];
  156.                         c[3]=led[min%10];
  157.             }   
  158.             else   
  159.             {
  160.                         c[2]=0xff;
  161.                         c[3]=0xff;
  162.             }  
  163.                         break;         

  165.         }                                       
  166. }
  167.         

  169. void init()
  170. {
  171.         TMOD=0x01;
  172.         TH0=0xfc;     //定时1ms   
  173.     TL0=0x18;
  174.         EA=1;
  175.         ET0=1;
  176.         TR0=1;
  177.         S5=0;
  178. }


  181. void cmg(void)//数码管锁存函数
  182. {
  183.         dula=1;
  184.         P0=0x00;
  185.         dula=0;
  186.         wela=1;
  187.         P0=0x00;
  188.         wela=0;
  189. }



  193. void keyscan()
  194. {

  196.         if(key1==0)//key1为功能键
  197.         {
  198.         delay(2);
  199.         if(key1==0)
  200.         {
  201.         //while(!key1);
  202.         for(i=0;((i<10)&&(key1==0));i++)          //检测按键释放
  203.     {
  204.     delay(1);
  205.     }
  206.         key++;
  207.         
  208.         if(key>2)
  209.         key=0;
  210.         
  211.         if(key!=0)
  212.         {

  214.         switch(key)
  215.         {
  216.         
  217.         case 1:  
  218.                  if(key2==0)                         //调时
  219.                  delay(2);
  220.                          if(key2==0)
  221.                          {
  222.                            
  223.                                 for(i=0;((i<10)&&(key2==0));i++)           //检测按键释放
  224.                                 {
  225.                                 delay(1);
  226.                                 }
  227.                         
  228.                             hour1=hour;
  229.                                 hour1++;
  230.                                 if(hour1>23)
  231.                                 hour1=0;
  232.                                  
  233.                                 temp=Decimal_BCD(hour1);
  234.                                 //temp=(hour1)/10*16+(hour1)%10;
  235.                                write_1302(0x8e,0x00);
  236.                                write_1302(0x84,temp);
  237.                               write_1302(0x8e,0x80);                                 
  238.                          }
  239.         
  240.                          if(key3==0)                        
  241.                  delay(2);
  242.                          if(key3==0)
  243.                          {
  244.                            
  245.                                 for(i=0;((i<10)&&(key3==0));i++)                   //检测按键释放
  246.                                 {
  247.                                 delay(1);
  248.                                 }
  249.                 hour1=hour;
  250.                                 hour1--;
  251.                                 if(hour1<0)
  252.                                 hour1=23;
  253.                            
  254.                                  //temp=Decimal_BCD(hour1);
  255.                                 temp=(hour1)/10*16+(hour1)%10;
  256.                                write_1302(0x8e,0x00);
  257.                                write_1302(0x84,temp);
  258.                               write_1302(0x8e,0x80);
  259.                                                                  
  260.                          }
  261.                
  262.                          break;

  264.         case 2:  if(key2==0)                         //调分
  265.                  delay(2);
  266.                          if(key2==0)
  267.                          {
  268.                                    for(i=0;((i<10)&&(key2==0));i++)
  269.                {
  270.                 delay(1);
  271.                }
  272.                                 if(min<59)
  273.                                 min++;
  274.                                 else
  275.                                 min=0;
  276.                                 //temp=(min)/10*16+(min)%10;
  277.                                  temp=Decimal_BCD(min);
  278.                              write_1302(0x8e,0x00);
  279.                                write_1302(0x82,temp);
  280.                     write_1302(0x80,0x00);          //miao复位
  281.                                write_1302(0x8e,0x80);                                         
  282.                          }
  283.                

  285.                          if(key3==0)                        
  286.                  delay(2);
  287.                          if(key3==0)
  288.                          {
  289.                             for(i=0;((i<10)&&(key3==0));i++)
  290.                 {
  291.                 delay(1);
  292.                 }
  293.                                 if(min>0)
  294.                                 min--;
  295.                                 else
  296.                                 min=59;
  297.                                 temp=(min)/10*16+(min)%10;
  298.                                  //temp=Decimal_BCD(min);
  299.                              write_1302(0x8e,0x00);
  300.                                write_1302(0x82,temp);
  301.                                 write_1302(0x80,0x00);          //miao复位
  302.                                write_1302(0x8e,0x80);                                 
  303.                          }

  305.                         break;
  306.         }
  307.          
  308.    }
  309.    }
  310.    }
  311. }
  312.                
  313.            
  314.                   

  316. void main()
  317. {

  319.     cmg();//数码管锁存 (关闭开发板数码管)
  320.         ds1302_init();
  321.         init();
  322.         while(1)
  323.         {
  324.           keyscan();
  325.           display();
  326.     }
  327. }


  330. void timer0() interrupt 1
  331. {
  332.     TH0=0xfc;     //定时1ms   
  333.     TL0=0x18;
  334.     //TL0 = (65536-1932)/256;        //设置定时初值                10ms
  335.     //TH0 = (65536-1932)%256;
  336.         //TH0=0xfb;     //定时ms   
  337.      //TL0=0x74;
  338.         /*t++;
  339.         if(t==255)
  340.         {
  341.             t=0;
  342.                 S5=!S5;
  343.         }
  344.          */
  345.         
  346.         d++;
  347.         if(d==20)
  348.         {
  349.         d=0;
  350.     write_1302(0x8e,0x00);
  351.         //sec = BCD_Decimal(read_1302(0x81));
  352.         min = BCD_Decimal(read_1302(0x83));
  353.         hour = BCD_Decimal(read_1302(0x85));
  354.         write_1302(0x8e,0x80);
  355.         }
  356.         
  357.         milsec++;
  358.         if(milsec==440)
  359.         {
  360.                 milsec=0;
  361.                 S_flag=!S_flag;
  362.                 S5=!S5;
  363.         }
  364.         
  365.     if(k==4)  
  366.     k=0;   
  367.     P0=c[k];     
  368.     P2=b[k++];      
  369.     delay(1);     
  370.     P2=0xff;
  371. }
复制代码


回复

使用道具 举报

ID:99987 发表于 2021-9-26 12:29 | 显示全部楼层
写入数据适当加延时或空操作，太快芯片反应不过来错误。
回复

使用道具 举报

ID:725922 发表于 2021-9-26 15:10 | 显示全部楼层
madell 发表于 2021-9-26 12:29
写入数据适当加延时或空操作，太快芯片反应不过来错误。

其实我也觉得可能是这个节奏上有问题，尤其是显示刷新的太快。
回复

使用道具 举报

ID:844772 发表于 2021-9-26 16:45 | 显示全部楼层
能否把写函数的这三句： IO=ACC0;  SCLK=0; SCLK=1;顺序改一下再加个延时，改为：  SCLK=0;  IO=ACC0;SCLK=1;_nop_(); 或者你再看看手册，按你写的时序，延时不够。
回复

使用道具 举报

ID:401564 发表于 2021-9-26 17:22 | 显示全部楼层
楼上已经有人说了,在读写时钟间增加延时
可以在调用函数时先让时钟线低电平SCLK=0;
这样的话,DS1302的SDA就会经历一个上升沿和一个下降沿,也就不用在乎它是上升沿写入还是下降沿写入了

IO=ACC0;
SCLK=1;
_nop_();
SCLK=0;
_nop_();
ACC=ACC>>1;
_nop_();
回复

使用道具 举报

ID:624769 发表于 2021-9-26 20:48 | 显示全部楼层
那么多人给你分析了代码，我就不看你的代码了， 就提几个关键的时序，
RST = 0    =>  RST =1     手册上要求最少 4us 间隔，实际测试 2us 的间隔是有必要的。
CLK = 0   =>   RST =1     手册上要求最少2us 间隔  实际测试最少 0.3us 是有必要的。
在STC8系列单片机， 24MHz 下。
IO = 0  =>   IO = 1     如IO有上拉电阻， 可在 IO = 1 后 立刻 CLK = 1
如没有上拉电阻，  IO = 1 后  最少 3个 NOP 才可以 CLK = 1
IO = 1   =>   IO =0     无论有没有上拉电阻，  IO =0 后 都可以立刻  CLK = 1
回复

使用道具 举报

ID:725922 发表于 2021-9-26 23:17 | 显示全部楼层
感谢各位的指点，我再看下。单片机水平还很菜，不过也在努力吧。
回复

使用道具 举报

ID:725922 发表于 2021-10-5 12:18 | 显示全部楼层
找到问题了，不是1302写不进去时间，是按键扫描函数有问题。。按下设置后，再次扫描按键函数时，因为检测不到按键按下，所以进不去函数了，因此也无法扫描到加减语句，修改if嵌套就好了。但是现在加减还是有点卡顿，需要慢一点按，偶尔不太灵，不过还能接受吧。
回复

使用道具 举报

ID:725922 发表于 2021-10-5 12:47 | 显示全部楼层
按键卡顿，把keyscan()函数放中断里面，设置一个合理的扫描时间，灵敏度提高，有改善。
回复

使用道具 举报

ID:161164 发表于 2021-10-5 15:51 | 显示全部楼层
wdmcp 发表于 2021-10-5 12:47
按键卡顿，把keyscan()函数放中断里面，设置一个合理的扫描时间，灵敏度提高，有改善。

中断里不要放太多东西
不要用太长(>1ms)的delay
贴段代码让你参考一下
  1. void keyscan()
  2. {static u8 Delay_XD;//静态局部变数,离开函数后保持数值
  3. bit Key_Add, Key_Dec;//局部变数,离开函数后清零
  4.         if(!key1 || !key2 || !key3)//有键按下
  5.         {
  6.                 if(Delay_XD<0xFF)Delay_XD++;//消抖延时并限制溢出
  7.                 if(Delay_XD == 250)//延时250个周期
  8.                 {
  9.                         if(!key1)//功能键按下
  10.                         {
  11.                                 key++;
  12.                                 if(key>2)key=0;
  13.                         }
  14.                         if(!key2)//加键按下
  15.                         {
  16.                                 Key_Add = 1;//加标志位置1
  17.                         }
  18.                         if(!key3)//减键按下
  19.                         {
  20.                                 Key_Dec = 1;//减标志位置1
  21.                         }                       
  22.                 }
  23.         }else{
  24.                 Delay_XD = 0;//没有键按下清零
  25.         }
  26.         switch(key)
  27.         {
  28.                 case 1:
  29.                         if(Key_Add)
  30.                         {
  31.                                 hour1=hour;
  32.                                 hour1++;
  33.                                 if(hour1>23)
  34.                                         hour1=0;

  36.                                 temp=Decimal_BCD(hour1);
  37.                                 //temp=(hour1)/10*16+(hour1)%10;
  38.                                 write_1302(0x8e,0x00);
  39.                                 write_1302(0x84,temp);
  40.                                 write_1302(0x8e,0x80);
  41.                         }

  43.                         if(Key_Dec)
  44.                         {
  45.                                 hour1=hour;
  46.                                 hour1--;
  47.                                 if(hour1<0)
  48.                                         hour1=23;

  50.                                 //temp=Decimal_BCD(hour1);
  51.                                 temp=(hour1)/10*16+(hour1)%10;
  52.                                 write_1302(0x8e,0x00);
  53.                                 write_1302(0x84,temp);
  54.                                 write_1302(0x8e,0x80);
  55.                         }
  56.                         break;

  58.                 case 2:
  59.                         if(Key_Add)
  60.                         {
  61.                                 if(min<59)
  62.                                         min++;
  63.                                 else
  64.                                         min=0;
  65.                                 //temp=(min)/10*16+(min)%10;
  66.                                 temp=Decimal_BCD(min);
  67.                                 write_1302(0x8e,0x00);
  68.                                 write_1302(0x82,temp);
  69.                                 write_1302(0x80,0x00);          //miao复位
  70.                                 write_1302(0x8e,0x80);
  71.                         }

  73.                         if(Key_Dec)
  74.                         {
  75.                                 if(min>0)
  76.                                         min--;
  77.                                 else
  78.                                         min=59;
  79.                                 temp=(min)/10*16+(min)%10;
  80.                                 //temp=Decimal_BCD(min);
  81.                                 write_1302(0x8e,0x00);
  82.                                 write_1302(0x82,temp);
  83.                                 write_1302(0x80,0x00);          //miao复位
  84.                                 write_1302(0x8e,0x80);
  85.                         }
  86.                         break;
  87.                
  88.                 default:
  89.                         break;
  90.         }
  91. }
复制代码
回复

使用道具 举报

ID:725922 发表于 2021-10-5 20:10 | 显示全部楼层
lkc8210 发表于 2021-10-5 15:51
中断里不要放太多东西
不要用太长(>1ms)的delay
贴段代码让你参考一下

谢谢热心的回复。
回复

使用道具 举报

ID:824490 发表于 2021-10-7 11:57 | 显示全部楼层
判断问题要精准！
1302能走时，说明初始化正常，说明写入时间正常，说明写入代码没问题。不能设置时间，就去查按键代码了。

什么延时啊、节奏啊、中断啊、、、都是空的！除非你初始化用的不是与设置时间是2套写入代码。。
回复

使用道具 举报

ID:725922 发表于 2021-10-8 18:06 | 显示全部楼层
名字不是重点 发表于 2021-10-7 11:57
判断问题要精准！
1302能走时，说明初始化正常，说明写入时间正常，说明写入代码没问题。不能设置时间，就 ...

对，排查问题思路要清晰，我就有点糊涂了。开始以为是定时器读取频率太快，可能导致写入时间出问题，直到增加延时还不行，我才看出按键函数有大漏洞。。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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