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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机+1602+DS18B20出现光标漂移问题
返回列表 发新帖
查看: 1738|回复: 2
打印 上一主题 下一主题
收起左侧

单片机+1602+DS18B20出现光标漂移问题

[复制链接]
跳转到指定楼层
楼主
ID:235296 发表于 2018-2-11 18:47 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
我做了一个带日期显示的温度计，但是在显示时1602液晶出现光标漂移的问题，在0xc0+8和9的位置。
那位帮我看看时怎么回事，初学单片机，还请多多指教。

  1. #include <AT89X52.h>
  2. #include <Intrins.h>  
  3. #define uchar unsigned char
  4. #define uint unsigned int

  6. uchar a,count,S1num,xqnum;
  7. char yue,ri,shi,fen,miao;
  8. int nian;

  10. sbit lcdrs=P2^5;
  11. sbit lcdrw=P2^4;                             //1602
  12. sbit lcden=P2^3;

  14. sbit S1=P3^0;                                //定义键——进入设置
  15. sbit S2=P3^1;                                //定义键——增大
  16. sbit S3=P3^2;                                //定义键——减小
  17. sbit S4=P3^3;                                //定义键——退出设置

  19. sbit ds18b20=P1^7;                                 //DS18B20

  21. uchar code table0[]="2018-02-13 WED";
  22. uchar code table1[]="23:59:50  ";
  23. uchar code xingqi[][3]={"MON","TUE","WED","THU","FRI","SAT","SUN"};

  25. //---------------------------------------
  26. //1602液晶寄存器设置   
  27. //---------------------------------------         
  28. unsigned char temp1;
  29. unsigned char temp2;
  30. unsigned char code table[16]={0,0,1,2,2,3,4,4,5,6,6,7,8,8,9,9};

  32. void delay(uint z)
  33. {
  34.         unsigned int i;
  35.     while (z--)
  36.         for (i=0;i<125;i++);
  37. }
  38. //名称：复位DS18B20函数
  39. //---------------------------------------
  40. bit Reset(void)
  41. {
  42.         unsigned int i;
  43.    bit k;
  44.    ds18b20=0;                             //拉低DQ总线开始复位      
  45.    i=200;                                             //保持DQ低大约870uS，符合不低于48US的要求
  46.    while(i>0)                             //保持DQ低大约870uS，符合不低于48US的要求
  47.        i--;                               //保持DQ低大约870uS，符合不低于48US的要求            
  48.    ds18b20=1;                             //拉高准备接收数据   
  49.    i=18;                                            //大约80uS后
  50.    while(i>0)                                    //大约80uS后
  51.        i--;                                      //大约80uS后
  52.    k=ds18b20;                               //读出数据并保存   
  53.    i=91;                                                    //维持约400US，符合总读时隙不低于480US的要求
  54.    while(i>0)                                    //维持约400US，符合总读时隙不低于480US的要求
  55.        i--;                                      //维持约400US，符合总读时隙不低于480US的要求
  56.    return k;               //k=0为复位成功，k=1为复位失败
  57. }
  58. //---------------------------------------
  59. //名称：读一字节函数
  60. //---------------------------------------
  61. unsigned char ReadByte(void)
  62. {
  63.         unsigned int i;
  64.    unsigned char j,buf=0;
  65.    for(j=0;j<8;j++)                        //接收8次还原一个字节数据
  66.    {
  67.                 buf=buf>>1;                          //接收前，想将接收缓冲区右移
  68.                 ds18b20=0;                                 //拉低      
  69.       _nop_();                       //维持2US，符合大于1US小于15US的规范
  70.       _nop_();                       //维持2US，符合大于1US小于15US的规范
  71.       _nop_();                       //维持2US，符合大于1US小于15US的规范
  72.            _nop_();                       //维持2US，符合大于1US小于15US的规范
  73.       ds18b20=1;                                  //拉高,为读数据做准备
  74.                 _nop_();                       //维持6US，符合大于1US小于15US的规范
  75.       _nop_();                       //维持6US，符合大于1US小于15US的规范
  76.       _nop_();                       //维持6US，符合大于1US小于15US的规范
  77.            _nop_();                       //维持6US，符合大于1US小于15US的规范
  78.                 _nop_();                       //维持6US，符合大于1US小于15US的规范
  79.       _nop_();                       //维持6US，符合大于1US小于15US的规范
  80.       _nop_();                       //维持6US，符合大于1US小于15US的规范
  81.            _nop_();                       //维持6US，符合大于1US小于15US的规范
  82.                 _nop_();                       //维持6US，符合大于1US小于15US的规范
  83.       _nop_();                       //维持6US，符合大于1US小于15US的规范
  84.       _nop_();                       //维持6US，符合大于1US小于15US的规范
  85.            _nop_();                       //维持6US，符合大于1US小于15US的规范
  86.                 if(ds18b20==1) buf|=0x80;  //读出1位数据保存于buf中
  87.                 i=12;                                          //维持约52US，符合总读时隙不低于60US的要求
  88.       while(i>0)                          //维持约52US，符合总读时隙不低于60US的要求
  89.               i--;                             //维持约52US，符合总读时隙不低于60US的要求
  90.         }
  91.    return buf;             //退出的同时将接收缓冲区参数返回
  92. }

  94. //---------------------------------------
  95. //名称：写一字节函数
  96. //---------------------------------------
  97. void WriteByte(unsigned char dat)
  98. {
  99.         unsigned int i;
  100.    unsigned char j;
  101.    for(j=0;j<8;j++)
  102.    {            
  103.                 if(dat&0x01)                        //如果写1
  104.       {      
  105.                    ds18b20=0;                         //拉低      
  106.          _nop_();               //维持2US，符合大于1US小于15US的规范
  107.          _nop_();               //维持2US，符合大于1US小于15US的规范
  108.          _nop_();               //维持2US，符合大于1US小于15US的规范
  109.                     _nop_();               //维持2US，符合大于1US小于15US的规范
  110.          ds18b20=1;                          //拉高        
  111.          i=14;                                  //维持约63US，符合不低于60US的要求
  112.          while(i>0)                  //维持约63US，符合不低于60US的要求
  113.                  i--;                     //维持约63US，符合不低于60US的要求
  114.                 }
  115.       else                                                //如果写0
  116.       {            
  117.                         ds18b20=0;                         //拉低                 
  118.          i=14;                                        //维持约63US，符合不低于60US的要求
  119.          while(i>0)                        //维持约63US，符合不低于60US的要求
  120.                  i--;                            //维持约63US，符合不低于60US的要求        
  121.          ds18b20=1;                         //拉高               
  122.          _nop_();               //维持2US，符合大于1US的规范
  123.          _nop_();               //维持2US，符合大于1US的规范
  124.          _nop_();               //维持2US，符合大于1US的规范
  125.                     _nop_();               //维持2US，符合大于1US的规范
  126.       }
  127.                 dat=dat>>1;                                //写入字节右移1位
  128.         }
  129. }

  131. //---------------------------------------
  132. //名称：DS18B20温度转换函数
  133. //---------------------------------------
  134. bit Convert(void)
  135. {   
  136.         if(Reset()==0)          //复位DS18B20
  137.         {               
  138.             WriteByte(0xcc);                //写入跳过序列号命令字 Skip Rom
  139.       WriteByte(0x44);                //写入温度转换命令字 Convert T  
  140.                   return 1;            //启动温度转换成功
  141.         }
  142.         else
  143.         {         
  144.                   return 0;            //启动温度转换失败
  145.         }
  146. }

  148. //---------------------------------------
  149. //名称：转换结束处理函数
  150. //---------------------------------------
  151. void ReadFlash(void)
  152. {   
  153.         unsigned char Lsb,Msb;      
  154.    if(Reset()==0)          //复位DS18B20
  155.         {
  156.       WriteByte(0xcc);                //写入跳过序列号命令字 Skip Rom
  157.       WriteByte(0xbe);                //写入读取数据令字 Read Scratchpad
  158.       Lsb=ReadByte();                //读出第一个字节暂存于LSB
  159.       Msb=ReadByte();                //读出第二个字节暂存于MSB      
  160.                   temp1=Lsb&0x0f;                //temp1内装温度参数的小数部分
  161.       temp2=(Lsb>>4)|(Msb<<4);//temp2内装温度参数的整数部分         
  162.         }      
  163.         else
  164.         {
  165.                 temp1=0;                                        //如果复位失败，温度参数清零
  166.       temp2=0;                                        //如果复位失败，温度参数清零      
  167.         }
  168. }
  169. /**************************************************
  170. 1602液晶显示器模块
  171. sbit lcdrs=P2^5;
  172. sbit lcdrw=P2^4;
  173. sbit lcden=P2^3;
  174. *************************************************/
  175. void write_com(uchar com)                                        //液晶写指令
  176. {
  177.         lcdrw=0;
  178.         lcdrs=0;
  179.         P0=com;
  180.         delay(5);
  181.         lcden=1;
  182.         delay(5);
  183.         lcden=0;
  184. }

  186. void write_data(uchar dat)                                        //液晶写数据
  187. {
  188.         lcdrw=0;
  189.         lcdrs=1;
  190.         P0=dat;
  191.         delay(5);
  192.         lcden=1;
  193.         delay(5);
  194.         lcden=0;
  195. }
  196. /********************************************
  197. 年月日写入1602函数
  198. ********************************************/
  199. void write_sfm(uchar add,uchar dat)                           //写时分秒函数
  200. {      
  201.               uchar shi,ge;

  203.               shi=dat/10;
  204.         ge=dat%10;
  205.         write_com(0x80+0x40+add);
  206.         write_data(0x30+shi);
  207.         write_data(0x30+ge);
  208. }
  209. void write_yr(uchar add,uchar dat)                           //写月日函数
  210. {
  211.         uchar shi,ge;
  212.         shi=dat/10;
  213.         ge=dat%10;
  214.         write_com(0x80+add);
  215.         write_data(0x30+shi);
  216.         write_data(0x30+ge);
  217. }
  218. void write_nian(uchar add,uint dat)                           //写年函数
  219. {
  220.         uint qian,bai,shi,ge;
  221.         qian=dat/1000;
  222.         bai=dat%1000/100;
  223.         shi=dat%100/10;
  224.         ge=dat%10;
  225.         write_com(0x80+add);
  226.         write_data(0x30+qian);
  227.         write_data(0x30+bai);
  228.         write_data(0x30+shi);
  229.         write_data(0x30+ge);
  230. }
  231. void xwd()
  232. {      
  233.             
  234.      if(Convert()==1)                                                 //启动转换
  235.                 {            
  236.                     ReadFlash();                       //读取温度                           
  237.          if(temp2>99) temp2=99;                        
  238.                             if(temp1>15) temp1=0;                                                

  240.                         write_com(0xc0+10);

  242.                         write_data(temp2/10+'0');                         //LCD1602_Disp(0,0,temp2/10+'0');  //温度整数部分十位                              

  244.                         write_com(0xc0+11);

  246.                         write_data(temp2%10+'0');     //LCD1602_Disp(1,0,temp2%10+'0');  //温度整数部分个位

  248.                         write_com(0xc0+12);

  250.                         write_data('.');               //LCD1602_Disp(2,0,'.');  //.               

  252.                         write_com(0xc0+13);

  254.                         write_data(table[temp1]+'0');  //LCD1602_Disp(3,0,table[temp1]+'0');  //温度小数部分

  256.                         write_com(0xc0+14);
  257.                        
  258.                         write_data(0xdf);              //LCD1602_Disp(4,0,0xdf);   //.

  260.                         write_com(0xc0+15);

  262.                         write_data(0x43);                        //LCD1602_Disp(5,0,0x43);   //C                                                                 

  264.                 }   
  265. }
  266. /***************************************************
  267. 初始化
  268. ***************************************************/
  269. void init_lcd()                                                          //液晶初始化
  270. {
  271.         lcden=0;

  273.         nian=2018;
  274.         yue=2;
  275.         ri=13;
  276.         shi=23;                                                                   //初始shi、fen、miao
  277.         fen=59;
  278.         miao=50;

  280.         write_com(0x38);                                           //设置16x2显示，5x7点阵，8位数据口
  281.         write_com(0x0c);                                           //设置开显示，不显示光标
  282.         write_com(0x06);                                        //写一个字符后地址指针加1
  283.         write_com(0x01);                                           //显示清0，数据指针清0
  284. }

  286. void init()                                                                        //初始化函数
  287. {
  288.         init_lcd();                                                                 //液晶初始化
  289.         write_com(0x80);                                                  //设置显示初始坐标
  290.         for(a=0;a<14;a++)                                                   //显示年月日初始值
  291.         {
  292.                 write_data(table0[a]);
  293.                 delay(5);
  294.         }
  295.         write_com(0x80+0x40);                                           //设置显示初始坐标
  296.         for(a=0;a<8;a++)                                                        //显示时分秒初始值
  297.         {
  298.                 write_data(table1[a]);                                       
  299.                 delay(5);
  300.         }
  301.                
  302.                                 count=0;
  303.         xqnum=0;
  304.         S1num=0;                                                                         //初始化全局变量count

  306.         TMOD=0x01;                                                                          //设置定时器0工作模式1
  307.         TH0=0xdb;                                                  //定时器装初始值
  308.         TL0=0xff;
  309.         EA=1;                                                                                        //开总中断
  310.         ET0=1;                                                                                        //开定时器0中断
  311.         TR0=1;                                                                                        //启动定时器0
  312. }
  313. /**************************************************
  314. 独立键盘
  315. sbit S1=P3^0;                                //定义键——进入设置
  316. sbit S2=P3^1;                                //定义键——增大
  317. sbit S3=P3^2;                                //定义键——减小
  318. sbit S4=P3^3;                                //定义键——退出设置
  319. 独立键盘已接地
  320. *************************************************/
  321. void keyscan()
  322. {
  323.         if(S1==0)
  324.         {
  325.                 delay(5);                                        //确认定义键被按下
  326.                 if(S1==0)
  327.                 {
  328.                         S1num++;                                //定义键S1按下次数记录
  329.                         while(!S1);                                //释放按键确认
  330.                         if(S1num==1)                        //S1按下一次时
  331.                         {
  332.                                 TR0=0;                                //关闭定时器
  333.                                 write_com(0xc0+7);        //光标定位到秒位置
  334.                                 write_com(0x0f);        //光标闪烁
  335.                         }
  336.                         if(S1num==2)                         //S1按下两次时
  337.                         {
  338.                                 write_com(0xc0+4);         //光标定位到分位置
  339.                         }
  340.                         if(S1num==3)                          //S1按下三次时
  341.                         {
  342.                                 write_com(0xc0+1);          //光标定位到时位置
  343.                         }
  344.                         if(S1num==4)                          //S1按下四次时
  345.                         {
  346.                                 write_com(0x80+13);          //光标定位到星期位置
  347.                         }
  348.                         if(S1num==5)                          //S1按下五次时
  349.                         {
  350.                                 write_com(0x80+9);          //光标定位到日位置
  351.                         }
  352.                         if(S1num==6)                          //S1按下六次时
  353.                         {
  354.                                 write_com(0x80+6);          //光标定位到月位置
  355.                         }
  356.                         if(S1num==7)                          //S1按下七次时
  357.                         {
  358.                                 write_com(0x80+3);          //光标定位到年位置
  359.                         }
  360.                         if(S1num==8)                          //S1按下八次时
  361.                         {
  362.                                 S1num=0;                          //S1记录按键次数清零
  363.                                 TR0=1;                                  //开启定时器
  364.                                 write_com(0x0c);          //取消光标闪烁
  365.                         }
  366.                 }
  367.         }
  368.         if(S1num!=0)                                           //只有定义键按下后S2、S3、S4才有效
  369.         {
  370.                 if(S2==0)
  371.                 {
  372.                         delay(5);                                        //防抖
  373.                         if(S2==0)                                   //确认按键被按下
  374.                         {
  375.                                 while(!S2);                                //释放按键确认
  376.                                 if(S1num==1)                        //S1按下一次时
  377.                                 {
  378.                                         miao++;                                //调整秒加1
  379.                                         if(miao==60)                //满60清零
  380.                                                 miao=0;
  381.                                         write_sfm(6,miao);                   //每调节一次送液晶显示一次
  382.                                         write_com(0x80+0x40+7);           //显示位置重新回到调节处
  383.                                 }
  384.                                 if(S1num==2)                           //S1按下两次时
  385.                                 {
  386.                                         fen++;                                        //调整分加1
  387.                                         if(fen==60)
  388.                                                 fen=0;
  389.                                         write_sfm(3,fen);
  390.                                         write_com(0x80+0x40+4);
  391.                                 }
  392.                                 if(S1num==3)                                 //S1按下三次时
  393.                                 {
  394.                                         shi++;                                          //调整时加1
  395.                                         if(shi==24)
  396.                                                 shi=0;                                       
  397.                                         write_sfm(0,shi);
  398.                                                                                                                                                                 write_com(0xc0+1);
  399.                                 }
  400.                                 if(S1num==4)                                                   //星期加调整
  401.                                 {
  402.                                         xqnum++;
  403.                                         if(xqnum==7)
  404.                                                 xqnum=0;
  405.                                         write_com(0x80+0x0b);
  406.                                         for(a=0;a<3;a++)
  407.                                         {
  408.                                                 write_data(xingqi[xqnum][a]);
  409.                                                 delay(5);
  410.                                                                                                                                                                              

  412.                                                                                                                                                                 }
  413.                                 }
  414.                                 if(S1num==5)                                                                //日加调整
  415.                                 {
  416.                                         ri++;
  417.                                         if(yue==2)
  418.                                         {
  419.                                                 if(nian%400==0)
  420.                                                 {
  421.                                                         if(ri==30)
  422.                                                         {
  423.                                                                 ri=1;
  424.                                                         }
  425.                                                 }
  426.                                                 if(nian%400!=0)
  427.                                                 {
  428.                                                         if(ri==29)
  429.                                                         {
  430.                                                                 ri=1;
  431.                                                         }
  432.                                                 }
  433.                                         }
  434.                                         else if(yue<=7)
  435.                                         {
  436.                                                 if(yue%2==0&yue!=2)
  437.                                                 {
  438.                                                         if(ri==31)
  439.                                                         {
  440.                                                                 ri=1;
  441.                                                         }
  442.                                                 }
  443.                                                 else if(yue%2!=0&yue!=2)
  444.                                                 {
  445.                                                         if(ri==32)
  446.                                                         {
  447.                                                                 ri=1;
  448.                                                         }
  449.                                                 }
  450.                                         }
  451.                                         else if(yue>=8)
  452.                                         {
  453.                                                 if(yue%2==0)
  454.                                                 {
  455.                                                         if(ri==32)
  456.                                                         {
  457.                                                                 ri=1;
  458.                                                         }
  459.                                                 }
  460.                                                 else if(yue%2!=0)
  461.                                                 {
  462.                                                         if(ri==31)
  463.                                                         {
  464.                                                                 ri=1;
  465.                                                         }
  466.                                                 }
  467.                                         }
  468.                                         write_yr(8,ri);
  469.                                                                                                                                                                 write_com(0x80+9);
  470.                                 }
  471.                                 if(S1num==6)                                                        //月加调整
  472.                                 {
  473.                                         yue++;
  474.                                         if(yue==13)
  475.                                                 yue=1;
  476.                                         write_yr(5,yue);
  477.                                                                                                                                                                 write_com(0x80+6);
  478.                                 }                                                                                 
  479.                                 if(S1num==7)                                                 //年加调整
  480.                                 {
  481.                                         nian++;
  482.                                         if(nian==2021)
  483.                                                 nian=2018;
  484.                                         write_nian(0,nian);
  485.                                                                                                                                                                 write_com(0x80+3);
  486.                                 }
  487.                         }
  488.                 }
  489.                 if(S3==0)
  490.                 {
  491.                         delay(5);
  492.                         if(S3==0)                                                 //确认按键被按下
  493.                         {
  494.                                 while(!S3);
  495.                                 if(S1num==1)                                 
  496.                                 {
  497.                                         miao--;                                          //调整秒减1
  498.                                         if(miao==-1)                          //减到00后再减重新设置为59
  499.                                                 miao=59;
  500.                                         write_sfm(6,miao);
  501.                                         write_com(0x80+0x40+7);
  502.                                 }
  503.                                 if(S1num==2)
  504.                                 {
  505.                                         fen--;                                           //调整分减1
  506.                                         if(fen==-1)
  507.                                                 fen=59;
  508.                                         write_sfm(3,fen);
  509.                                         write_com(0x80+0x40+4);
  510.                                 }
  511.                                 if(S1num==3)
  512.                                 {
  513.                                         shi--;                                                //调整时减1
  514.                                         if(shi==-1)
  515.                                                 shi=23;
  516.                                         write_sfm(0,shi);
  517.                                         write_com(0x80+0x40+1);
  518.                                 }
  519.                                 if(S1num==4)
  520.                                 {
  521.                                         xqnum--;                                        //调整星期减一
  522.                                         if(xqnum==-1)
  523.                                                 xqnum=6;
  524.                                         write_com(0x80+0x0b);
  525.                                         for(a=0;a<3;a++)
  526.                                         {
  527.                                                 write_data(xingqi[xqnum][a]);
  528.                                                 delay(5);
  529.                                                       
  530.                                         }
  531.                                 }
  532.                                 if(S1num==5)                                   //调整日
  533.                                 {
  534.                                         ri--;                                                
  535.                                         if(yue==2)
  536.                                         {
  537.                                                 if(nian%400==0)
  538.                                                 {
  539.                                                         if(ri==0)
  540.                                                         {
  541.                                                                 ri=29;
  542.                                                         }
  543.                                                 }
  544.                                                 if(nian%400!=0)
  545.                                                 {
  546.                                                         if(ri==0)
  547.                                                         {
  548.                                                                 ri=28;
  549.                                                         }
  550.                                                 }
  551.                                         }
  552.                                         else if(yue<=7)                                 
  553.                                         {
  554.                                                 if(yue%2==0&yue!=2)
  555.                                                 {
  556.                                                         if(ri==0)
  557.                                                         {
  558.                                                                 ri=30;
  559.                                                         }
  560.                                                 }
  561.                                                 else if(yue%2!=0&yue!=2)
  562.                                                 {
  563.                                                         if(ri==0)
  564.                                                         {
  565.                                                                 ri=31;
  566.                                                         }
  567.                                                 }
  568.                                         }
  569.                                         else if(yue>=8)
  570.                                         {
  571.                                                 if(yue%2==0)
  572.                                                 {
  573.                                                         if(ri==0)
  574.                                                         {
  575.                                                                 ri=31;
  576.                                                         }
  577.                                                 }
  578.                                                 else if(yue%2!=0)
  579.                                                 {
  580.                                                         if(ri==0)
  581.                                                         {
  582.                                                                 ri=30;
  583.                                                         }
  584.                                                 }
  585.                                         }
  586.                                         write_yr(8,ri);
  587.                                         write_com(0x80+9);                                                                                                                                                      
  588.                                 }
  589.                                 if(S1num==6)                                           //调整月
  590.                                 {
  591.                                         yue--;
  592.                                         if(yue==0)
  593.                                                 yue=12;
  594.                                         write_yr(5,yue);
  595.                                                                                                                                                                 write_com(0x80+6);
  596.                                 }
  597.                                 if(S1num==7)                                          //调整年
  598.                                 {
  599.                                         nian--;
  600.                                         if(nian==2017)
  601.                                                 nian=2020;
  602.                                         write_nian(0,nian);
  603.                                                                                                                                                                 write_com(0x80+3);
  604.                                 }
  605.                         }
  606.                 }
  607.                 if(S4==0)                                                                   //退出设置、开启中断
  608.                 {
  609.                         delay(5);
  610.                         if(S4==0)
  611.                         {
  612.                                 S1num=0;
  613.                                 TR0=1;
  614.                                 write_com(0x0c);
  615.                         }
  616.                 }
  617.         }
  618. }

  620. /**************************************************
  621. 定时器0
  622. *************************************************/
  623. void timer0() interrupt 1                                         //定时器0中断服务程序
  624. {
  625.         TH0=0xdb;                                         //重装定时器初始值
  626.         TL0=0xff;
  627.         count++;                                                                  //中断次数累加
  628.         if(count==200)                                                         //20次50毫秒即一秒
  629.         {
  630.                 count=0;
  631.                 miao++;
  632.                 if(miao==60)                                                  //秒加到60时分进位
  633.                 {
  634.                         miao=0;
  635.                         fen++;
  636.                         if(fen==60)                                                  //分加到60时时进位
  637.                         {
  638.                                 fen=0;
  639.                                 shi++;
  640.                                 if(shi==24)                                                //时加到24时清0
  641.                                 {
  642.                                         shi=0;
  643.                                         xqnum++;
  644.                                         ri++;

  646.                                         if(yue==2)                                        //如果是二月
  647.                                         {
  648.                                                 if(nian%400==0)                         //闰年判断
  649.                                                 {
  650.                                                         if(ri==30)
  651.                                                         {
  652.                                                                 ri=1;
  653.                                                                 yue++;
  654.                                                                 write_yr(5,yue);
  655.                                                         }
  656.                                                 }
  657.                                                 if(nian%400!=0)                           //平年判断
  658.                                                 {
  659.                                                         if(ri==29)
  660.                                                         {
  661.                                                                 ri=1;
  662.                                                                 yue++;
  663.                                                                 write_yr(5,yue);
  664.                                                         }
  665.                                                 }
  666.                                         }
  667.                                         else if(yue<=7&yue!=2)           //一月到七月
  668.                                         {
  669.                                                 if(yue%2==0)                //偶数月（除二月）
  670.                                                 {
  671.                                                         if(ri==31)                                          
  672.                                                         {
  673.                                                                 ri=1;
  674.                                                                 yue++;
  675.                                                         }
  676.                                                 }
  677.                                                 else if(yue%2!=0)                         //奇数月
  678.                                                 {
  679.                                                         if(ri==32)
  680.                                                         {
  681.                                                                 ri=1;
  682.                                                                 yue++;
  683.                                                         }
  684.                                                 }
  685.                                                 write_yr(5,yue);
  686.                                         }
  687.                                         else if(yue>=8)                                         //八月到12月
  688.                                         {
  689.                                                 if(yue%2==0)                //偶数月（除二月）
  690.                                                 {
  691.                                                         if(ri==32)                                          
  692.                                                         {
  693.                                                                 ri=1;
  694.                                                                 yue++;
  695.                                                                 if(yue==13)                                   //如果判断月份为12月，则加一后重新定义月份为1
  696.                                                                 {
  697.                                                                         yue=1;
  698.                                                                         nian++;
  699.                                                                         write_nian(0,nian);
  700.                                                                 }
  701.                                                                 write_yr(5,yue);
  702.                                                         }
  703.                                                 }
  704.                                                 else if(yue%2!=0)                         //奇数月
  705.                                                 {
  706.                                                         if(ri==31)
  707.                                                         {
  708.                                                                 ri=1;
  709.                                                                 yue++;
  710.                                                                 write_yr(5,yue);
  711.                                                         }
  712.                                                 }
  713.                                         }
  714.                                         write_yr(8,ri);

  716.                                         if(xqnum==7)                                        //星期写入
  717.                                                 xqnum=0;
  718.                                         write_com(0x80+0x0b);
  719.                                         for(a=0;a<3;a++)
  720.                                         {
  721.                                                 write_data(xingqi[xqnum][a]);
  722.                                                 delay(5);
  723.                                         }
  724.                                 }
  725.                                 write_sfm(0,shi);                                //重新写入数据
  726.                         }
  727.                         write_sfm(3,fen);                                        //重新写入数据
  728.                 }
  729.                 write_sfm(6,miao);                                                //重新写入数据
  730.         }
  731. }



  735. /*************************************************
  736. 主函数
  737. *************************************************/
  738. void main()
  739. {
  740.         init();
  741.         while(1)
  742.         {                             
  743.             if(S1num==0)                                       
  744.                                                 {   
  745.                                                 xwd();
  746.                                                 }               
  747.                                                            
  748.                   keyscan();                                                                //不停的检测按键是否被按下
  749.         }
  750. }
复制代码



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

使用道具 举报

沙发
ID:235296 发表于 2018-2-21 02:55 | 只看该作者
已解决
回复

使用道具 举报

板凳
ID:788 发表于 2019-1-16 22:14 | 只看该作者
sdfecx 发表于 2018-2-21 02:55
已解决

遇到同样的问题，请问是怎么解决的
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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