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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机驱动DS1302实时时钟模块用1602显示万年历全是零
返回列表 发新帖
查看: 4614|回复: 4
打印 上一主题 下一主题
收起左侧

单片机驱动DS1302实时时钟模块用1602显示万年历全是零

[复制链接]
跳转到指定楼层
楼主
ID:137239 发表于 2018-4-15 14:24 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
程序写好后下载到单片机里，1602显示的都是零，个位数字在闪烁。

部分程序：
  1. #include<reg52.h>
  2. #include<intrins.h>
  3. #define uchar unsigned char
  4. sbit DSIO=P3^4;                 //ds1302接口
  5. sbit RST=P3^5;
  6. sbit SCLK=P3^6;

  8. void zuobiao(uchar x,uchar y,uchar *s);
  9. void Ds1302Write(uchar addr, uchar dat);
  10. uchar Ds1302Read(uchar addr);
  11. void Ds1302Init();
  12. void Ds1302ReadTime();
  13. uchar code shuzi[10]={'0','1','2','3','4','5','6','7','8','9'};
  14. uchar riqi[16]={'2','0','0','0','/','0','0','/','0','0',' ','W','e','e','k','0'};
  15. //uchar code xingqi[7]={"Mon","Tue","Wed","Thu","Fri","Sat","Sun"};
  16. uchar shijian[9]={'0','0',':','0','0',':','0','0','\0'};
  17. uchar code READ_RTC_ADDR[7] = {0x81, 0x83, 0x85, 0x87, 0x89, 0x8b, 0x8d};
  18. uchar code WRITE_RTC_ADDR[7] = {0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c};
  19. //---DS1302时钟初始化2017年5月23日星期二10点57分00秒。---//
  20. //---存储顺序是秒分时日月周年,存储格式---//
  21. char TIME[7] = {0x00, 0x57, 0x10, 0x15, 0x04, 0x07, 0x18};

  23. void Ds1302Write(uchar addr, uchar dat)
  24. {
  25.         uchar n;
  26.         RST = 0;
  27.         _nop_();

  29.         SCLK = 0;//先将SCLK置低电平。
  30.         _nop_();
  31.         RST = 1; //然后将RST(CE)置高电平。
  32.         _nop_();

  34.         for (n=0; n<8; n++)//开始传送八位地址命令
  35.         {
  36.                 DSIO = addr & 0x01;//数据从低位开始传送
  37.                 addr >>= 1;
  38.                 SCLK = 1;//数据在上升沿时，DS1302读取数据
  39.                 _nop_();
  40.                 SCLK = 0;
  41.                 _nop_();
  42.         }
  43.         for (n=0; n<8; n++)//写入8位数据
  44.         {
  45.                 DSIO = dat & 0x01;
  46.                 dat >>= 1;
  47.                 SCLK = 1;//数据在上升沿时，DS1302读取数据
  48.                 _nop_();
  49.                 SCLK = 0;
  50.                 _nop_();        
  51.         }        
  52.                  
  53.         RST = 0;//传送数据结束
  54.         _nop_();
  55. }

  57. uchar Ds1302Read(uchar addr)
  58. {
  59.         uchar n,dat,dat1;
  60.         RST = 0;
  61.         _nop_();

  63.         SCLK = 0;//先将SCLK置低电平。
  64.         _nop_();
  65.         RST = 1;//然后将RST(CE)置高电平。
  66.         _nop_();

  68.         for(n=0; n<8; n++)//开始传送八位地址命令
  69.         {
  70.                 DSIO = addr & 0x01;//数据从低位开始传送
  71.                 addr >>= 1;
  72.                 SCLK = 1;//数据在上升沿时，DS1302读取数据
  73.                 _nop_();
  74.                 SCLK = 0;//DS1302下降沿时，放置数据
  75.                 _nop_();
  76.         }
  77.         _nop_();
  78.         for(n=0; n<8; n++)//读取8位数据
  79.         {
  80.                 dat1 = DSIO;//从最低位开始接收
  81.                 dat = (dat>>1) | (dat1<<7);
  82.                 SCLK = 1;
  83.                 _nop_();
  84.                 SCLK = 0;//DS1302下降沿时，放置数据
  85.                 _nop_();
  86.         }

  88.         RST = 0;
  89.         _nop_();        //以下为DS1302复位的稳定时间,必须的。
  90.         SCLK = 1;
  91.         _nop_();
  92.         DSIO = 0;
  93.         _nop_();
  94.         DSIO = 1;
  95.         _nop_();
  96.         return dat;        
  97. }

  99. void Ds1302Init()
  100. {
  101.         uchar n;
  102.         Ds1302Write(0x8E,0X00);                 //禁止写保护，就是关闭写保护功能
  103.         for (n=0; n<7; n++)//写入7个字节的时钟信号：分秒时日月周年
  104.         {
  105.                 Ds1302Write(WRITE_RTC_ADDR[n],TIME[n]);        
  106.         }
  107.         Ds1302Write(0x8E,0x80);                 //打开写保护功能
  108. }

  110. void Ds1302ReadTime()
  111. {
  112.         uchar n;
  113.         for (n=0; n<7; n++)//读取7个字节的时钟信号：分秒时日月周年
  114.         {
  115.                 TIME[n] = Ds1302Read(READ_RTC_ADDR[n]);
  116.         }               
  117. }

  119. void zhudisplay()
  120. {
  121.         Ds1302ReadTime();
  122.     riqi[2]=shuzi[TIME[6]/16];           //年
  123.         riqi[3]=shuzi[TIME[6]&0x0f];
  124.         riqi[5]=shuzi[TIME[4]/16];           //月
  125.         riqi[6]=shuzi[TIME[4]&0x0f];
  126.         riqi[8]=shuzi[TIME[3]/16];           //日
  127.         riqi[9]=shuzi[TIME[3]&0x0f];
  128.         riqi[15]=shuzi[TIME[5]&0x0f];  //星期
  129.         shijian[0]=shuzi[TIME[2]/16];  //时
  130.         shijian[1]=shuzi[TIME[2]&0x0f];
  131.         shijian[3]=shuzi[TIME[1]/16];  //分
  132.         shijian[4]=shuzi[TIME[1]&0x0f];
  133.         shijian[6]=shuzi[TIME[0]/16];  //秒
  134.         shijian[7]=shuzi[TIME[0]&0x0f];
  135. }

  137. void Display()
  138. {
  139.      zhudisplay();
  140. //         zuobiao(0,4,xianshi);
  141.          zuobiao(0,0,riqi);
  142. //         zuobiao(1,12," ");
  143.          zuobiao(1,4,shijian);
  144. }
复制代码



1602自定义.zip

40.59 KB, 下载次数: 23

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

使用道具 举报

沙发
ID:111634 发表于 2018-4-15 16:57 | 只看该作者
本帖最后由 zl2168 于 2018-4-15 16:59 编辑

实例91  具有校正功能的时钟1302（LCD1602显示）
先Proteus仿真，确认有效。
实例91 带校正时钟1302（LCD1602显示）.rar (52.68 KB, 下载次数: 34)

以上摘自张志良编著《80C51单片机仿真设计实例教程——基于Keil C和Proteus》清华大学出版社ISBN 978-7-302-41682-1，书中电路和程序设计有详细说明，程序语句条条有注解。
回复

使用道具 举报

板凳
ID:198608 发表于 2018-4-15 17:42 | 只看该作者
首先检查电路，电路没有问题肯定就是程序问题了，看你这个就是没有接收到时钟信号，硬件，程序好好查查吧
回复

使用道具 举报

地板
ID:291829 发表于 2018-4-15 20:39 | 只看该作者
/***************************************************************************
*标题：                 可调的DS1302时钟在LCD1602上显示                   *
*                                                                                                                                                   *******************************************************************************
*接线：JP8接JP4、蜂鸣器短路帽的左端接到P3^2(用一根杜邦线)                             *
*说明：本实验是在普中科技单片机开发板HC6800EM3上实现的                        ******************************************************************************/
#include<reg52.h>
#include <intrins.h>
#define uchar unsigned char
#define uint  unsigned int

sbit SCK=P3^6;        //时钟       
sbit SDA=P3^4;        //数据       
sbit RST=P3^5;  // DS1302复位

sbit lcdrs=P2^6;
sbit lcdrw=P2^5;
sbit lcden=P2^7;

sbit key1=P1^4;
sbit key2=P1^5;
sbit key3=P1^6;
sbit key4=P1^7;

sbit H=P1^1;            //矩阵键盘第一行四个键
sbit beep=P3^2;
bit  ReadRTC_Flag;      //定义读DS1302标志

uchar miao,fen,shi,ri,yue,week,nian,a,T,n=0;

char l_tmpdate[7]={50,8,1,7,10,1,12};//设置初始时间，秒分时日月周年12-10-07 01:08:50

uchar code write_rtc_address[7]={0x80,0x82,0x84,0x86,0x88,0x8a,0x8c}; //秒分时日月周年 最低位写位
uchar code  read_rtc_address[7]={0x81,0x83,0x85,0x87,0x89,0x8b,0x8d}; //秒分时日月周年 最低位读位
  
uchar code table1[]="SUN";                           //星期字表
uchar code table2[]="MON";
uchar code table3[]="TUE";
uchar code table4[]="WED";
uchar code table5[]="THU";
uchar code table6[]="FRI";
uchar code table7[]="SAT";

uchar code tab1[]="20  -  -";
uchar code tab2[]="  :  :";

/******************************************************************/
/*                    函数声明                                    */
/******************************************************************/                                                                                               
void Write_Ds1302_byte(uchar temp);
void Write_Ds1302( uchar address,uchar dat );
uchar Read_Ds1302 ( uchar address );
void Read_RTC(void);
void Set_RTC(void);  
void delay(uchar a);
void ini_Timer();
void di();
void lcd_mang();
void write_lcd1602(uchar cmd,uchar i);
void ini_lcd1602();
void write_week(uchar xq);
void write_nyr(uchar add,uchar dat);
void write_sfm(uchar add,uchar dat);
void display();
void keyscan();
/******************************************************************/
/*                   主函数                                       */
/******************************************************************/
void main(void)   
{
    ini_Timer();
    ini_lcd1602();
        //Set_RTC();                                     //写入时钟值，如果使用备用电池时候，不需要没每次上电写入，此程序应该屏蔽
        while(1)
        {
                keyscan();               
               
                if(ReadRTC_Flag==0)
                {
                          Read_RTC();
               
                        display();                               
                }
         }
}
/******************************************************************/
/*     BCD转换成LCD1602能显示的16进制数，秒、分、时               */
/******************************************************************/
void write_sfm(uchar add,uchar dat)                                 
{
        uchar gw,sw;
        gw=dat%16;
        sw=dat/16;
        write_lcd1602(0x80+0x40+add,0);
        write_lcd1602(sw+0x30,1);
        write_lcd1602(gw+0x30,1);       
}

/******************************************************************/
/*     BCD转换成LCD1602能显示的16进制数，日、月、年               */
/******************************************************************/
void write_nyr(uchar add,uchar dat)                               
{
        uchar gw,sw;
        gw=dat%16;
        sw=dat/16;
        write_lcd1602(0x80+add,0);
        write_lcd1602(sw+0x30,1);
        write_lcd1602(gw+0x30,1);       
}
/******************************************************************/
/*                                             显示星期                                                     */
/******************************************************************/
void write_week(uchar xq)                                               
{
        uchar x;
        write_lcd1602(0x80+12,0);
        switch(xq)
        {
                case 1:
                for(x=0;x<3;x++)
                {
                        write_lcd1602(table1[x],1);
                }
                break;
                case 2:
                for(x=0;x<3;x++)
                {
                        write_lcd1602(table2[x],1);
                }
                break;
                case 3:
                for(x=0;x<3;x++)
                {
                        write_lcd1602(table3[x],1);
                }
                break;
                case 4:
                for(x=0;x<3;x++)
            {
                        write_lcd1602(table4[x],1);
                }
                break;
                case 5:
                for(x=0;x<3;x++)
                {
                        write_lcd1602(table5[x],1);
                }
                break;
                case 6:
                for(x=0;x<3;x++)
                {
                        write_lcd1602(table6[x],1);
                }
                break;
                case 7:
                for(x=0;x<3;x++)
                {
                        write_lcd1602(table7[x],1);
                }
                break;
        }
        write_lcd1602(0x80+12,0);       
}
/******************************************************************/
/*                                             显示函数                                                     */
/******************************************************************/
void display()
{
        write_sfm(10,miao);
        write_sfm(7,fen);
        write_sfm(4,shi);
        write_nyr(3,nian);
        write_nyr(6,yue);       
        write_nyr(9,ri);
        write_week(week);
}
/******************************************************************/
/*                             毫秒级延时函数                                                       */
/******************************************************************/
void delay(uchar a)
{
     uchar i;
     while(a--)
           {
              for(i=0;i<250;i++)
                    {
                           _nop_();
               _nop_();
                           _nop_();
               _nop_();  
                        }
           }   
}
/******************************************************************/
/*                                     定时器0使蜂鸣器发声函数                                 */
/******************************************************************/
void ini_Timer()
{
        a=0;
        TMOD=0X01;
        TH0=(65536-250)/256;
        TL0=(65536-250)%256;
        EA=1;
        ET0=1;       
        TR0=1;
}
void timer0() interrupt 1
{
        TH0=(65536-250)/256;
        TL0=(65536-250)%256;
        a++;       
}
void di()
{
        while(key1==0||key2==0||key3==0)
        {
                if(a==2)
                {
                        a=0;
                        beep=~beep;
                }
        }
}
/******************************************************************/
/*                                             LCD1602判忙函数                                         */
/******************************************************************/
void lcd_mang()
{
           lcdrs=0;
           lcdrw=1;
           lcden=1;
           _nop_();
        _nop_();
        _nop_();
        _nop_();
           while(P0&0x80);
           lcden=0;
}

/******************************************************************/
/*                             LCD1602写指令(i=0)、数据(i=1)函数                            */
/******************************************************************/
void write_lcd1602(uchar cmd,uchar i)
{                                                                                                                                          
    lcd_mang();
        lcdrs=i;
        lcdrw=0;
        lcden=0;
        _nop_();
        _nop_();       
        lcden=1;
        _nop_();
        _nop_();
        P0=cmd;
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        lcden=0;       
}

/******************************************************************/
/*                             LCD1602初始化函数                                             */
/******************************************************************/
void ini_lcd1602()
{
  uchar i;
  write_lcd1602(0x38,0);
  delay(1);  
  write_lcd1602(0x0c,0);
  delay(1);
  write_lcd1602(0x06,0);
  delay(1);
  write_lcd1602(0x01,0);
  delay(1);

  write_lcd1602(0x80+1,0);
  for(i=0;i<8;i++)
  {
            write_lcd1602(tab1[i],1);
  }
  write_lcd1602(0x80+0x40+4,0);
  for(i=0;i<6;i++)
  {
            write_lcd1602(tab2[i],1);
  }  
}

/******************************************************************/
/*                   DS1302写一个字节                             */
/******************************************************************/
void Write_Ds1302_Byte(uchar temp)
{
         uchar i;
         for (i=0;i<8;i++)             //循环8次 写入数据
          {
           SCK=0;
             SDA=temp&0x01;     //每次传输低字节
             temp>>=1;                  //右移一位
             SCK=1;
           }  
}   
/******************************************************************/
/*                  写入DS1302                                    */
/******************************************************************/
void Write_Ds1302( uchar address,uchar dat )     
{
        RST=0;
        _nop_();
        SCK=0;
        _nop_();
        RST=1;       
           _nop_();                    //启动
        Write_Ds1302_Byte(address);        //发送地址
        Write_Ds1302_Byte(dat);                //发送数据
        RST=0;                                              //恢复
}
/******************************************************************/
/*                   读出DS1302数据                               */
/******************************************************************/
uchar Read_Ds1302 ( uchar address )
{
        uchar i,temp=0x00;
        RST=0;
        _nop_();
        _nop_();
        SCK=0;
        _nop_();
        _nop_();
        RST=1;
        _nop_();
        _nop_();
        Write_Ds1302_Byte(address);
        for (i=0;i<8;i++)                 //循环8次 读取数据
        {               
                if(SDA)
                temp|=0x80;                        //每次传输低字节
                SCK=0;
                temp>>=1;                        //右移一位
           _nop_();
           _nop_();
           _nop_();
                SCK=1;
        }
        RST=0;
        _nop_();                          //以下为DS1302复位的稳定时间
        _nop_();
        RST=0;
        SCK=0;
        _nop_();
        _nop_();
        _nop_();
        _nop_();
        SCK=1;
        _nop_();
        _nop_();
        SDA=0;
        _nop_();
        _nop_();
        SDA=1;
        _nop_();
        _nop_();
        return (temp);                                //返回
}
/******************************************************************/
/*                   读时钟数据                                   */
/******************************************************************/
void Read_RTC(void)                //读取 日历
{
         uchar i,*p;
         p=read_rtc_address;             //地址传递
         for(i=0;i<7;i++)                    //分7次读取 秒分时日月周年
         {
                  l_tmpdate[i]=Read_Ds1302(*p);
                  p++;

                  miao=l_tmpdate[0];
                  fen =l_tmpdate[1];
                  shi =l_tmpdate[2];
                  ri  =l_tmpdate[3];
                  yue =l_tmpdate[4];
                  week=l_tmpdate[5];
                   nian=l_tmpdate[6];                    
         }

}
/******************************************************************/
/*                  设定时钟数据                                  */
/******************************************************************/
void Set_RTC(void)                    //设定 日历
{
        uchar i,*p,tmp;
        for(i=0;i<7;i++)
         {       //BCD处理
                tmp=l_tmpdate[i]/10;
                l_tmpdate[i]=l_tmpdate[i]%10;
                l_tmpdate[i]=l_tmpdate[i]+tmp*16;
        }  
        Write_Ds1302(0x8E,0X00);         //允许写，禁止写保护
       
        p=write_rtc_address;             //传地址       
        for(i=0;i<7;i++)                     //7次写入 秒分时日月周年
        {
                  Write_Ds1302(*p,l_tmpdate[i]);
                  p++;  
         }
         Write_Ds1302(0x8E,0x80);           //打开写保护
}

/******************************************************************/
/*                                             键盘扫描函数                                             */
/******************************************************************/
void keyscan()
{
       
        H=0;                                                                 //矩阵键盘第一排公共端拉低用于矩阵键盘的扫描检测
        if(key1==0)                                                         //功能键
        {
                delay(1);
                if(key1==0)
                {
                        di();
                        while(!key1);                                                //松手检测
                        ++n;
                        ReadRTC_Flag=1;                                        //停止走时
                        switch(n)
                        {
                                case 1: write_lcd1602(0x80+0x40+11,0);                //按一次功能键秒闪烁
                                                write_lcd1602(0x0f,0);
                                                Write_Ds1302(0x8e,0x00);                        //允许写，禁止写保护
                                                Write_Ds1302(0x80,0x80|miao);                //写入DS1302秒位
                                                Write_Ds1302(0x8e,0x80);                        //打开写保护
                                                break;
                                case 2: write_lcd1602(0x80+0x40+8,0);                //按两次功能键分闪烁       
                                                break;
                                case 3: write_lcd1602(0x80+0x40+5,0);                //按三次功能键时闪烁       
                                                break;
                                case 4: write_lcd1602(0x80+10,0);                         //按四次功能键日闪烁       
                                                break;
                                case 5: write_lcd1602(0x80+7,0);                         //按五次功能键月闪烁       
                                                break;
                                case 6:write_lcd1602(0x80+4,0);                                 //按六次功能键年闪烁
                                                break;
                                case 7: write_lcd1602(0x80+12,0);                        //按七次功能键周闪烁       
                                                break;
                                case 8: n=0;                                                //按八次功能键开始走时，停止闪烁
                                                ReadRTC_Flag=0;                                               
                                                write_lcd1602(0x0c,0);
                                                Write_Ds1302(0x8e,0x00);
                                                Write_Ds1302(0x80,0x00|miao);
                                                Write_Ds1302(0x8e,0x80);
                                                break;
                        }
                }               
        }
        if(n!=0)                                                                                                                //功能加键
        {
                if(key2==0)
                {
                        delay(1);
                        if(key2==0)
                        {                                       
                                di();
                                while(!key2);
                                switch(n)
                                {
                                        case 1: miao++;
                                                        if(miao>=60)
                                                        miao=0;
                                                        write_lcd1602(0x80+0x40+10,0);           //使LCD1602在秒位上显示“加”设好的秒数
                                                        write_lcd1602((miao)/10+'0',1);           //十进制转换成LCD1602能显示的字符，显示出来
                                                        write_lcd1602((miao)%10+'0',1);
                                                        T=(miao)/10*16+(miao)%10;                   //十进制转换成DS1302能写的BCD码
                                                        Write_Ds1302(0x8e,0x00);                   //允许写，禁止写保护
                                                        Write_Ds1302(0x80,T);                           //写入DS1302
                                                        Write_Ds1302(0x8e,0x80);                   //打开写保护
                                                        write_lcd1602(0x80+0x40+11,0);    //写完数据后光标自动右移，所以要归位                                                                                                               
                                                        break;
                                        case 2: fen++;
                                                        if(fen>=60)
                                                        fen=0;
                                                        write_lcd1602(0x80+0x40+7,0);
                                                        write_lcd1602((fen)/10+'0',1);
                                                        write_lcd1602((fen)%10+'0',1);
                                                        T=(fen)/10*16+(fen)%10;
                                                        Write_Ds1302(0x8e,0x00);
                                                        Write_Ds1302(0x82,T);
                                                        Write_Ds1302(0x8e,0x80);
                                                        write_lcd1602(0x80+0x40+8,0);
                                                        break;
                                        case 3: shi++;
                                                        if(shi>=24)
                                                        shi=0;
                                                        write_lcd1602(0x80+0x40+4,0);
                                                        write_lcd1602((shi)/10+'0',1);
                                                        write_lcd1602((shi)%10+'0',1);
                                                        T=(shi)/10*16+(shi)%10;
                                                        Write_Ds1302(0x8e,0x00);
                                                        Write_Ds1302(0x84,T);
                                                        Write_Ds1302(0x8e,0x80);
                                                        write_lcd1602(0x80+0x40+5,0);
                                                        break;
                                        case 4: ri++;
                                                        if(ri>31)
                                                        ri=1;
                                                        write_lcd1602(0x80+9,0);
                                                        write_lcd1602((ri)/10+'0',1);
                                                        write_lcd1602((ri)%10+'0',1);
                                                        T=(ri)/10*16+(ri)%10;                       
                                                        Write_Ds1302(0x8e,0x00);       
                                                        Write_Ds1302(0x86,T);
                                                        Write_Ds1302(0x8e,0x80);
                                                        write_lcd1602(0x80+10,0);
                                                        break;
                                        case 5: yue++;
                                                        if(yue>12)
                                                        yue=1;
                                                        write_lcd1602(0x80+6,0);
                                                        write_lcd1602((yue)/10+'0',1);
                                                        write_lcd1602((yue)%10+'0',1);
                                                        T=(yue)/10*16+(yue)%10;
                                                        Write_Ds1302(0x8e,0x00);
                                                        Write_Ds1302(0x88,T);
                                                        Write_Ds1302(0x8e,0x80);
                                                        write_lcd1602(0x80+7,0);
                                                        break;
                                        case 6: nian++;
                                                        if(nian>=100)
                                                        nian=0;
                                                        write_lcd1602(0x80+3,0);
                                                        write_lcd1602((nian)/10+'0',1);
                                                        write_lcd1602((nian)%10+'0',1);
                                                        T=(nian)/10*16+(nian)%10;
                                                        Write_Ds1302(0x8e,0x00);
                                                        Write_Ds1302(0x8c,T);
                                                        Write_Ds1302(0x8e,0x80);
                                                        write_lcd1602(0x80+4,0);
                                                        break;
                                        case 7: week++;
                                                        if(week>=8)
                                                        week=1;
                                                        write_week(week);
                                                        T=(week)/10*16+(week)%10;
                                                        Write_Ds1302(0x8e,0x00);
                                                        Write_Ds1302(0x8a,T);
                                                        Write_Ds1302(0x8e,0x80);
                                                        break;
                                }
                        }
                }                       
        }
        if(key3==0)                                                                                                   //功能减键
        {
                delay(1);
                if(key3==0)
                {
                        di();
                        while(!key3);
                        switch(n)
                        {
                                case 1: miao--;
                                                if(miao<=0)
                                                miao=59;
                                                write_lcd1602(0x80+0x40+10,0);
                                                write_lcd1602((miao)/10+'0',1);
                                                write_lcd1602((miao)%10+'0',1);
                                                T=(miao)/10*16+(miao)%10;
                                                Write_Ds1302(0x8e,0x00);
                                                Write_Ds1302(0x80,T);
                                                Write_Ds1302(0x8e,0x80);
                                                write_lcd1602(0x80+0x40+11,0);
                                                break;
                                case 2: fen--;
                                                if(fen<0)
                                                 fen=59;
                                                write_lcd1602(0x80+0x40+7,0);
                                                write_lcd1602((fen)/10+'0',1);
                                                write_lcd1602((fen)%10+'0',1);
                                                T=(fen)/10*16+(fen)%10;
                                                Write_Ds1302(0x8e,0x00);
                                                Write_Ds1302(0x82,T);
                                                Write_Ds1302(0x8e,0x80);
                                                write_lcd1602(0x80+0x40+8,0);
                                                break;
                                case 3: shi--;
                                                if(shi<0)
                                                shi=23;
                                                write_lcd1602(0x80+0x40+4,0);
                                                write_lcd1602((shi)/10+'0',1);
                                                write_lcd1602((shi)%10+'0',1);
                                                T=(shi)/10*16+(shi)%10;
                                                Write_Ds1302(0x8e,0x00);
                                                Write_Ds1302(0x84,T);
                                                Write_Ds1302(0x8e,0x80);
                                                write_lcd1602(0x80+0x40+5,0);
                                                break;
                                case 4: ri--;
                                                if(ri<1)
                                                ri=31;
                                                write_lcd1602(0x80+9,0);
                                                write_lcd1602((ri)/10+'0',1);
                                                write_lcd1602((ri)%10+'0',1);
                                                T=(ri)/10*16+(ri)%10;                       
                                                Write_Ds1302(0x8e,0x00);       
                                                Write_Ds1302(0x86,T);
                                                Write_Ds1302(0x8e,0x80);
                                                write_lcd1602(0x80+10,0);
                                                break;
                                case 5: yue--;
                                                if(yue<0)
                                                yue=12;
                                                write_lcd1602(0x80+6,0);
                                                write_lcd1602((yue)/10+'0',1);
                                                write_lcd1602((yue)%10+'0',1);
                                                T=(yue)/10*16+(yue)%10;
                                                Write_Ds1302(0x8e,0x00);
                                                Write_Ds1302(0x88,T);
                                                Write_Ds1302(0x8e,0x80);
                                                write_lcd1602(0x80+7,0);
                                                break;
                                case 6: nian--;
                                                if(nian<0)
                                                nian=99;
                                                write_lcd1602(0x80+3,0);
                                                write_lcd1602((nian)/10+'0',1);
                                                write_lcd1602((nian)%10+'0',1);
                                                T=(nian)/10*16+(nian)%10;
                                                Write_Ds1302(0x8e,0x00);
                                                Write_Ds1302(0x8c,T);
                                                Write_Ds1302(0x8e,0x80);
                                                write_lcd1602(0x80+4,0);
                                                break;
                                case 7: week--;
                                                if(week<1)
                                                week=7;
                                                write_week(week);
                                                T=(week)/10*16+(week)%10;
                                                Write_Ds1302(0x8e,0x00);
                                                Write_Ds1302(0x8a,T);
                                                Write_Ds1302(0x8e,0x80);
                                                break;
                        }
                }
        }       
}



自己看吧
回复

使用道具 举报

5#
ID:137239 发表于 2018-4-16 10:56 | 只看该作者
zl2168 发表于 2018-4-15 16:57
实例91  具有校正功能的时钟1302（LCD1602显示）
先Proteus仿真，确认有效。

我的程序用Proteus仿真也是可以的，能够解释下为何一直在闪烁？
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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