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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › DS1302 8位数码管时钟，调时可以连加连减
返回列表 发新帖
查看: 6944|回复: 9
收起左侧

DS1302 8位数码管时钟，调时可以连加连减

  [复制链接]
ID:140489 发表于 2017-4-25 14:59 | 显示全部楼层 |阅读模式
附件里有完整源码和仿真图
QQ截图20170425151550.png
/*********************************************************************************
描述： 8位共阴数码管时钟，显示88-88-88样式，正常走时的时候，两个“-”0.5秒闪烁一次；
       调时：按KEY1按键第1次分钟位闪烁，再按KEY2一次分钟加1，按KEY3一次分钟减1，长按连加连减；
                         按KEY1按键第2次小时位闪烁，再按KEY2一次小时加1，按KEY3一次小时减1，长按连加连减；
                         按KEY1按键第3次，秒从零开始累加，时钟回到正常走时；
                         对时的时候先调好时、分，分钟要比参考时间的分钟加1分，
                         再看参考时间的秒数到了59再按KEY1按键的第3次，这样对时可以很准的
仿真 实物都通过.  11.0592MHz晶振，STC89C52RC，两个74HC573锁存器做位选、段选
**********************************************************************************/
#include<reg52.h>
#include<intrins.h>
#define uchar unsigned char
#define uint unsigned int

sbit sclk = P1^0;                                                                //1302时钟端口
sbit dio = P1^1;                                                                //1302数据端口
sbit ce = P1^2;                                                                        //1302使能
sbit wela = P2^7;                                                                //位选
sbit dula = P2^6;                                                                //段选

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

uchar snum,fnum;

char shi,fen,miao;

uchar ss;

char FunctionKeyNum=0;                                //功能键键值
char FuncTempNum=0;                                        //功能键临时键值
typedef enum KeyState{StateInit,StateAffirm,StateSingle,StateRepeat};        //键值状态值


/***********写时分秒地址************/
#define write_shi  0x84
#define write_fen  0x82
#define write_miao 0x80

/***********读时分秒地址************/
#define read_shi  0x85
#define read_fen  0x83
#define read_miao 0x81

                  // 0     1    2    3    4     5    6    7    8   9
uchar d[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F}; //共阴不带小数点
//uchar dd[]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef};  //        共阴带小数点


void delay(uint z)
{
        uint x,y;
        for(x=z;x>0;x--)
                for(y=120;y>0;y--);
}


void t0_init()  //定时50ms一个中断
{

  TMOD |= 0X01;
  TH0 = (65536-46080)/256;
  TL0 = (65536-46080)%256;
  EA = 1;
  ET0 = 1;
  TR0 = 1;

}

void t1_init()
{
        TMOD |= 0x10;
        TH1 = 0xDC;
        TL1 = 0x00;
        TR1 = 1;        
}

void temer0() interrupt 1
{
  TH0=(65536-46080)/256;
  TL0=(65536-46080)%256;
  ss++;
  if(ss==20)
  ss=0;

}         





void display(uchar shi,uchar fen,uchar miao)                          //显示函数
{
        if(FunctionKeyNum==0)
        {
                snum=30;
                fnum=30;
        }
        
        if(FunctionKeyNum==1)
        {
                fnum++;
                snum=30;
        }
        
        if(FunctionKeyNum==2)
        {
                snum++;
                fnum=30;
        }
        
        
        if(snum>=30)
        {        
                if((shi/10)<1)         //如果小时十位小于1，
                {
                wela=1;
                P0=0xfe;                //第1位
                wela=0;

                dula = 1;
                P0=0xff;           // 小时十位就不显示
                dula = 0;
                }
               
                else
                {
                wela=1;
                P0=0xfe;          //第1位
                wela=0;

                dula=1;
                P0=d[shi/10];
                dula=0;
                P0=0xff;
                delay(2);
                }
           
                        wela=1;
                        P0=0xfd;           //第2位
                        wela=0;

                        dula=1;
                        P0=d[shi%10];                        //时的个位，P0=d[shi%10]时的个位小数点闪烁
                        dula=0;                                        // 时的个位，P0=dd[shi%10]时的个位小数点不闪烁
                        P0=0xff;
                        delay(2);
        
        
                if(snum==60)
                        snum=0;
        }               


        //        if(miao%2==0)         //if(miao%2==0) 1秒闪烁1次
                if(ss>=10)                 //        这里写为ss>=10，闪烁频率可调
                {                                 
            wela=1;
                P0=0xfb;                //第3位
                wela=0;

                dula=1;
                P0=0x40;          //第三位数码管显示“— ”
               
                dula=0;
                P0=0xff;
                delay(2);
        
                }

                else
                {
                wela=1;
                P0=0xfb;   //第3位
                wela=0;

                dula=1;
                P0=0;          //第三位数码管不显示
                dula=0;
                P0=0xff;
                delay(2);        
                }
        
        
        if(fnum>=30)
        {
                wela=1;
                P0=0xf7;         //第4位
                wela=0;

                dula=1;
                P0=d[fen/10];
                dula=0;
                P0=0xff;
                delay(2);
               
               
                wela=1;
                P0=0xef;         //第5位
                wela=0;

                dula=1;
                P0=d[fen%10];
                dula=0;
                P0=0xff;
                delay(2);
        
               
                if(fnum==60)
                        fnum=0;
        }
               
        //        if(miao%2==0)         //if(miao%2==0) 1秒闪烁1次
                if(ss>=10)                 //if(ss>=10)闪烁频率可调
                {
                wela=1;
                P0=0xdf;          //第6位
                wela=0;
                dula=1;
                P0=0x40;          //第六位数码管显示“— ”
                dula=0;
                P0=0xff;

                delay(2);
                }

                else
                {
                wela=1;
                P0=0xdf;   //第6位
                wela=0;
                dula=1;
                P0=0;          //第六位数码管不显示
                dula=0;
                P0=0xff;

                delay(2);
                }
               
               
                wela=1;
                P0=0xbf;                //第7位
                wela=0;

            dula=1;
                P0=d[miao/10];                           //秒十位
                dula=0;
                P0=0xff;
                delay(2);
        

                wela=1;
                P0=0x7f;                          //第8位
                wela=0;

                dula=1;
                P0=d[miao%10];                         //秒个位
                dula=0;
                P0=0xff;
                delay(2);               
                                   
               
        
        
}  



void write_1302(uchar add,dat)                 //写1302函数  
{
        uchar i,temp;
        temp=add;
        ce=0;
        _nop_();
        sclk=0;
        _nop_();
        ce=1;
        _nop_();
        for(i=0;i<8;i++)
        {
                sclk=0;
                _nop_();
                if((temp&0x01)==0x01)
                        dio=1;
                        else
                        dio=0;
                temp>>=1;
                sclk=1;
                _nop_();
        }
        temp=dat;
        for(i=0;i<8;i++)
        {
                sclk=0;
                _nop_();
                if((temp&0x01)==0x01)
                        dio=1;
                        else
                        dio=0;
                temp>>=1;
                sclk=1;
                _nop_();
        }
        ce=0;
        sclk=0;
}
uchar read_1302(uchar add)                                   //读1302函数               
{
        uchar dat,dat1,i,temp;
        temp=add;
        ce=0;
        _nop_();
        sclk=0;
        _nop_();
        ce=1;
        for(i=0;i<8;i++)
        {
                sclk=0;
                _nop_();
                if((temp&0x01)==0x01)
                        dio=1;
                        else
                        dio=0;
                temp>>=1;
                sclk=1;
                _nop_();
        }
        for(i=0;i<8;i++)
        {
                sclk=0;
                _nop_();
                if(dio)
                    dat|=0x80;
                if(i<7)
                        dat>>=1;
                sclk=1;
        }
        dat1=dat/16;
        dat=dat%16;
        dat=dat1*10+dat;  
        ce=0;
        sclk=0;
        return dat;
}                        



void init_1302()                                                        //初始化函数 设置时间
{        
        write_1302(0x8e,0x00);                                        //保护取消，可以进行写操作
        write_1302(write_miao,0x57);        
        write_1302(write_fen,0x55);
        write_1302(write_shi,0x15);
        write_1302(0x8e,0x80);                                        //保护启动，不能进行写操作
}         

void read_sf()
{
        shi=read_1302(read_shi);
        fen=read_1302(read_fen);
        miao=read_1302(read_miao);
        display(shi,fen,miao);

}

void KeyScan(void)
{
        static uchar KeyStateTemp1 = 0;                  //按键状态临时存储值1
        static uchar KeyStateTemp2 = 0;                  //按键状态临时存储值2
        static uchar KeyStateTemp3 = 0;                  //按键状态临时存储值3
        static uchar KeyTime = 0;                          //按键延时时间
        bit KeyPressTemp1;                                          //按键是否按下存储值1
        bit KeyPressTemp2;                                          //按键是否按下存储值2
        bit KeyPressTemp3;                                          //按键是否按下存储值3

        KeyPressTemp1 = KEY1;                                  //读取IO口的键值
        switch(KeyStateTemp1)
        {
                case StateInit:
                        if(!KeyPressTemp1)                                        //KEY1按下
                                KeyStateTemp1 = StateAffirm;        //按键状态切换到确认态
                break;
                case StateAffirm:                                                //确认状态
                        if(!KeyPressTemp1)                                        //按键还在按下
                        {
                                KeyTime = 0;
                                KeyStateTemp1 = StateSingle;        //按键状态切换到单击状态
                        }
                        else KeyStateTemp1 = StateInit;                //否则按键抬起，回到初始态
                break;
               
                case StateSingle:                                                //单击
                         if(KeyPressTemp1)
                         {
                                KeyStateTemp1 = StateInit;                 //按键释放
                                FuncTempNum++;                                         //键值加1
                                if(FuncTempNum>3)  FuncTempNum = 0;
                         }

                         else if(++KeyTime>100)
                         {
                                         KeyPressTemp1 = StateRepeat;
                                        KeyTime = 0;
                         }
                break;
        
                case StateRepeat:                                                 //连发
                        if(KeyPressTemp1)
                                KeyStateTemp1 = StateInit;
                        else
                        {
                                if(++KeyTime > 10)
                                {
                                        KeyTime = 0;
                                        FuncTempNum++;
                                        if(FuncTempNum>3)  FuncTempNum = 0;
                                }
                                break;
                        }
                break;
        
                default :KeyStateTemp1 = KeyStateTemp1 = StateInit; break;
                        
        }


if(FuncTempNum)                                                                //只有功能键被按下后，增加和减小键才有效
        {
                KeyPressTemp2 = KEY2;                                        //读取I/O口的键值
                switch(KeyStateTemp2)
                {        
                        case StateInit:                                                //按键初始状态
                                if(!KeyPressTemp2)                                //当按键按下，状态切换到确认态
                                        KeyStateTemp2 = StateAffirm;
                                break;
                        case StateAffirm:                                        //按键确认态
                                if(!KeyPressTemp2)
                                {
                                        KeyTime = 0;
                                        KeyStateTemp2 = StateSingle;//切换到单次触发态        
                                }
                                else KeyStateTemp2 = StateInit; //按键已抬起，切换到初始态
                                break;
                        case StateSingle:                                        //按键单发态
                                if(KeyPressTemp2)                                //按下时间小于1s
                                {
                                        KeyStateTemp2 = StateInit;  //按键释放，则回到初始态
                                        if(FunctionKeyNum == 1)                //若功能键第一次按下
                                        {
                                        fen++;
                                        fen=fen/10*16+fen%10;                //转为16进制
                                        if(fen==0x60)
                                            fen=0x00;
                                           write_1302(write_fen,fen);        //写入1302
                                        read_sf();                                        //读出时间，然后显示
                                        }
                                        if(FunctionKeyNum == 2)                //若功能键第二次按下
                                        {
                                                shi++;
                                                shi=shi/10*16+shi%10;                //转为16进制
                                                if(shi==0x24)
                                                        shi=0x00;
                                                write_1302(write_shi,shi);
                                                read_sf();

                                        }
                                        }
                                        else if(++KeyTime > 100)        //按下时间大于1s(100*10ms)
                                        {
                                                KeyStateTemp2 = StateRepeat;//状态切换到连发态
                                                KeyTime = 0;        
                                        }
                                break;
                        case StateRepeat:                                        //按键连发态               
                                if(KeyPressTemp2)
                                        KeyStateTemp2 = StateInit;        //按键释放，则进初始态
                                else                                                        //按键未释放
                                {
                                        if(++KeyTime > 10)                        //按键计时值大于100ms（10*10ms）
                                        {
                                                KeyTime = 0;        
                                                if(FunctionKeyNum == 1)        //若功能键第一次按下
                                                {
                                        fen++;
                                        fen=fen/10*16+fen%10;                //转为16进制
                                        if(fen==0x60)
                                            fen=0x00;
                                           write_1302(write_fen,fen);        //写入1302
                                        read_sf();                                        //读出时间，然后显示
                                                }
                                                
                                                if(FunctionKeyNum == 2)        //若功能键第二次按下
                                                {
                                                shi++;
                                                shi=shi/10*16+shi%10;                //转为16进制
                                                if(shi==0x24)
                                                        shi=0x00;
                                                write_1302(write_shi,shi);
                                                read_sf();
                                                }
                                        }
                                        break;
                                }
                                break;
                        default: KeyStateTemp2 = KeyStateTemp2 = StateInit; break;
                }


                KeyPressTemp3 = KEY3;                                                //读取I/O口的键值
                switch(KeyStateTemp3)
                {        
                        case StateInit:                                                        //按键初始状态
                                if(!KeyPressTemp3)                                        //当按键按下，状态切换到确认态
                                        KeyStateTemp3 = StateAffirm;
                                break;
                        case StateAffirm:                                                //按键确认态
                                if(!KeyPressTemp3)
                                {
                                        KeyTime = 0;
                                        KeyStateTemp3 = StateSingle;        //切换到单次触发态        
                                }
                                else KeyStateTemp3 = StateInit;         //按键已抬起，切换到初始态
                                break;
                        case StateSingle:                                                //按键单发态
                                if(KeyPressTemp3)                                        //按下时间小于1s
                                {
                                        KeyStateTemp3 = StateInit;          //按键释放，则回到初始态
                                        if(FunctionKeyNum == 1)                        //若功能键第一次按下
                                        {
                                                fen--;
                                                fen=fen/10*16+fen%10;                //转为16进制
                                                if(fen==-1)
                                                fen=0x59;
                                                write_1302(write_fen,fen);
                                                read_sf();
                                        }
                                        if(FunctionKeyNum == 2)                        //若功能键第二次按下
                                        {
                                                shi--;
                                                shi=shi/10*16+shi%10;                //转为16进制
                                                if(shi==-1)
                                                shi=0x23;
                                                write_1302(write_shi,shi);
                                                read_sf();
                                        }
                                }
                                else if(++KeyTime > 100)                        //按下时间大于1s(100*10ms)
                                {
                                        KeyStateTemp3 = StateRepeat;        //状态切换到连发态
                                        KeyTime = 0;        
                                }
                                break;
                        case StateRepeat:                                                //按键连发态               
                                if(KeyPressTemp3)
                                        KeyStateTemp3 = StateInit;                //按键释放，则进初始态
                                else                                                                //按键未释放
                                {
                                        if(++KeyTime > 10)                                //按键计时值大于100ms（10*10ms）
                                        {
                                                KeyTime = 0;        
                                                if(FunctionKeyNum == 1)                //若功能键第一次按下
                                                {
                                                        fen--;
                                                        fen=fen/10*16+fen%10;                //转为16进制
                                                        if(fen==-1)
                                                        fen=0x59;
                                                        write_1302(write_fen,fen);
                                                        read_sf();
                                                }
                                                if(FunctionKeyNum == 2)                //若功能键第二次按下
                                                {
                                                        shi--;
                                                        shi=shi/10*16+shi%10;                //转为16进制
                                                        if(shi==-1)
                                                        shi=0x23;
                                                        write_1302(write_shi,shi);
                                                        read_sf();
                                                }
                                        }
                                        break;
                                }
                                break;
                        default: KeyStateTemp3 = KeyStateTemp3 = StateInit; break;
                }
        }
}


void ExecuteKeyNum()
{
        if(TF1)
        {
                TF1 = 0;
                TH1 = 0xDC;
                TL1 = 0x00;
                KeyScan();
        }

以上是部分源码，完整的代码在附件里：
下载： 时钟.rar (26.29 KB, 下载次数: 185)

评分

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

查看全部评分

回复

使用道具 举报

ID:161033 发表于 2017-7-8 22:25 | 显示全部楼层
感谢分享
回复

使用道具 举报

ID:140489 发表于 2018-1-30 16:26 | 显示全部楼层
  1. /*********************************************************************************
  2. 8位数码管显示实时时钟
  3. 仿真 实物都通过.  11.0592MHz晶振，两片74HC573做段选、位选
  4. 调时的时候，key2键短按加1，长按连加；key3键短按减一，长按连减；按键消抖不用delay
  5. **********************************************************************************/
  6. #include<reg52.h>
  7. #include<intrins.h>
  8. #define uchar unsigned char
  9. #define uint unsigned int

  11. /***********写时分秒地址************/
  12. #define write_shi  0x84
  13. #define write_fen  0x82
  14. #define write_miao 0x80
  15. /***********读时分秒地址************/
  16. #define read_shi  0x85
  17. #define read_fen  0x83
  18. #define read_miao 0x81

  20. sbit sclk = P1^0;           //控制数据时钟
  21. sbit dio = P1^1;           //数据口
  22. sbit ce = P1^2;                   //使能端、复位端
  23. sbit wela = P2^7;           //位选
  24. sbit dula = P2^6;           //段选
  25. //sbit IO=P1^1;                                                                          //数据口
  26. //sbit SCLK=P1^0;                                                                 //控制数据时钟
  27. //sbit RST=P1^2;                                                                  //使能端、复位端

  29. sbit key1=P3^0;                                                                        //按键 选择
  30. sbit key2=P3^1;                                                                        //按键 加
  31. sbit key3=P3^2;                                                                        //按键 减

  33. uchar knum=0,snum,fnum,ss;
  34. char shi,fen,miao;
  35.                   // 0     1    2    3    4     5    6    7    8   9
  36. uchar code d[]={ 0x3F,0x06,0x5B,0x4F,0x66, 0x6D,0x7D,0x07,0x7F,0x6F}; //共阴不带小数点
  37. uchar code dd[]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef};//        共阴带小数点

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

  42. void delay(uint z)
  43. {
  44.         uint x,y;
  45.         for(x=z;x>0;x--)
  46.                 for(y=120;y>0;y--);
  47. }


  50. void t0_init()  //定时50ms一个中断
  51. {
  52.    
  53.   TMOD=0X01;
  54.   TH0=(65536-46080)/256;
  55.   TL0=(65536-46080)%256;
  56. //  TH1=(65536-46080)/256;
  57. //  TL1=(65536-46080)%256;

  59.   EA=1;
  60.   ET0=1;
  61.   TR0=1;
  62. //  ET1=1;
  63. //  TR1=1;

  65. }


  68. void display(uchar shi,uchar fen,uchar miao)                          //显示函数
  69. {
  70.         if(knum==0)
  71.         {
  72.                 snum=30;
  73.                 fnum=30;
  74.         }
  75.        
  76.         if(knum==1)
  77.         {
  78.                 fnum++;
  79.                 snum=30;
  80.         }
  81.        
  82.         if(knum==2)
  83.         {
  84.                 snum++;
  85.                 fnum=30;
  86.         }
  87.        
  88.        
  89.         if(snum>=30)
  90.         {       
  91.                 if((shi/10)<1)         //如果小时十位小于1，
  92.                 {
  93.                         wela=1;
  94.                         P0=0xfe;                //第1位
  95.                         wela=0;
  96.        
  97.                         dula = 1;
  98.                         P0=0xff;           // 小时十位就不显示
  99.                         dula = 0;
  100.                 }
  101.                
  102.                 else
  103.                 {
  104.                         wela=1;
  105.                         P0=0xfe;          //第1位
  106.                         wela=0;
  107.        
  108.                         dula=1;
  109.                         P0=d[shi/10];
  110.                         dula=0;
  111.                         P0=0xff;
  112.                         delay(2);
  113.                 }

  115.                 wela=1;
  116.                 P0=0xfd;           //第2位
  117.                 wela=0;

  119.                 dula=1;
  120.                 P0=d[shi%10];                        //时的个位，P0=d[shi%10]时的个位小数点闪烁
  121.                 dula=0;                                        // 时的个位，P0=dd[shi%10]时的个位小数点不闪烁
  122.                 P0=0xff;
  123.                 delay(2);
  124.        
  125.                 if(snum==60)
  126.                         snum=0;
  127.         }               


  130.         //        if(miao%2==0)         //if(miao%2==0) 1秒闪烁1次
  131.                 if(ss>=10)                 //        这里写为ss>=10，闪烁频率可调
  132.                 {                                  
  133.                     wela=1;
  134.                         P0=0xfb;                //第3位
  135.                         wela=0;
  136.        
  137.                         dula=1;
  138.                         P0=0x40;          //第三位数码管显示“— ”
  139.                        
  140.                 //        P0=0x09;          //第三位数码管显示“= ”
  141.                         dula=0;
  142.                         P0=0xff;
  143.                         delay(2);
  144.                 }

  146.                 else
  147.                 {
  148.                         wela=1;
  149.                         P0=0xfb;   //第3位
  150.                         wela=0;
  151.        
  152.                         dula=1;
  153.                         P0=0;          //第三位数码管不显示
  154.                         dula=0;
  155.                         P0=0xff;
  156.                         delay(2);       
  157.                 }
  158.        
  159.        
  160.         if(fnum>=30)
  161.         {
  162.                 wela=1;
  163.                 P0=0xf7;         //第4位
  164.                 wela=0;

  166.                 dula=1;
  167.                 P0=d[fen/10];
  168.                 dula=0;
  169.                 P0=0xff;
  170.                 delay(2);
  171.                
  172.                
  173.                 wela=1;
  174.                 P0=0xef;         //第5位
  175.                 wela=0;

  177.                 dula=1;
  178.                 P0=d[fen%10];
  179.                 dula=0;
  180.                 P0=0xff;
  181.                 delay(2);
  182.        
  183.                
  184.                 if(fnum==60)
  185.                         fnum=0;
  186.         }
  187.                
  188.         //        if(miao%2==0)         //if(miao%2==0) 1秒闪烁1次
  189.                 if(ss>=10)                 //if(ss>=10)闪烁频率可调
  190.                 {
  191.                         wela=1;
  192.                         P0=0xdf;          //第6位
  193.                         wela=0;
  194.                         dula=1;
  195.                         P0=0x40;          //第六位数码管显示“— ”
  196.                         dula=0;
  197.                         P0=0xff;
  198.        
  199.                         delay(2);
  200.                 }

  202.                 else
  203.                 {
  204.                         wela=1;
  205.                         P0=0xdf;   //第6位
  206.                         wela=0;
  207.                         dula=1;
  208.                         P0=0;          //第六位数码管不显示
  209.                         dula=0;
  210.                         P0=0xff;
  211.        
  212.                         delay(2);
  213.                 }
  214.                
  215.                
  216.                 wela=1;
  217.                 P0=0xbf;                //第7位
  218.                 wela=0;

  220.             dula=1;
  221.                 P0=d[miao/10];                           //秒十位
  222.                 dula=0;
  223.                 P0=0xff;
  224.                 delay(2);
  225.        

  227.                 wela=1;
  228.                 P0=0x7f;                          //第8位
  229.                 wela=0;

  231.                 dula=1;
  232.                 P0=d[miao%10];                         //秒个位
  233.                 dula=0;
  234.                 P0=0xff;
  235.                 delay(2);               
  236. }  



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

  317. /*
  318. uchar read_1302(uchar add)                                                //读函数
  319. {
  320.         uchar i,date;
  321.         RST=0;                                                                                 //禁止读写数据
  322.         for(i=0;i<8;i++)
  323.         {
  324.                 RST=1;
  325.                 SCLK=0;
  326.                 IO=add&0x01;
  327.                 add>>=1;
  328.                 SCLK=1;
  329.         }
  330.         for(i=0;i<8;i++)
  331.         {
  332.                 if(IO)
  333.                         date=date|0x80;
  334.                 else
  335.                         date=date|0x00;
  336.                 SCLK=1;       
  337.                 date>>=1;
  338.                 SCLK=0;
  339.         }
  340.         RST=0;
  341.         date=date/16*10+date%16;                  //进制转换 16转10进制
  342.         IO=0;                                                          //数据读完后，IO口必须为0，不然小时一直显示85
  343.         return date;
  344. }
  345. void write_1302(uchar add,uchar dat)                //写函数
  346. {
  347.         uchar i;
  348.         RST=0;                                                                        //禁止读写数据
  349.         SCLK=0;                         
  350.         for(i=0;i<8;i++)                                                 //写地址
  351.         {
  352.                 RST=1;                                                                 //允许读写数据
  353.                 SCLK=0;
  354.                 IO=add&0x01;        
  355.                 add>>=1;
  356.                 SCLK=1;
  357.         }
  358.         for(i=0;i<8;i++)                                                 //写数据
  359.         {
  360.                 RST=1;                                                                //允许读写数据
  361.                 SCLK=0;       
  362.                 IO=dat&0x01;
  363.                 dat>>=1;
  364.                 SCLK=1;
  365.         }
  366.         RST=0;
  367. }         */


  370. void init_1302()                                                        //初始化函数 设置第一次上电时显示的时间值
  371. {       
  372.         write_1302(0x8e,0x00);                                        //保护取消，可以进行写操作
  373.         write_1302(write_miao,0x57);                        //写秒57
  374.         write_1302(write_fen,0x55);                                //写分55
  375.         write_1302(write_shi,0x15);                                //写时15
  376.         write_1302(0x8e,0x80);                                        //保护启动，不能进行写操作
  377. }         

  379. void read_sf()                           //读时分秒并显示
  380. {
  381.         shi=read_1302(read_shi);
  382.         fen=read_1302(read_fen);
  383.         miao=read_1302(read_miao);
  384.         display(shi,fen,miao);
  385. }


  388. void keyscan()                        //按键扫描函数
  389. {       
  390.         static uchar count;          //这里要定义为静态变量
  391.         if(key1==0)                          //按键按下
  392.         {
  393.                 count++;                          //消抖,也是连加一次的间隔时间
  394.                 if(key1==0 && count>10)//按键按下，计数变量加到12，
  395.                 {

  397.                         while(!key1)           //这里不需要连加，就加一句松手检测
  398.                         display(shi,fen,miao);
  399.                         count=0;
  400.                         TR0=0;
  401.                         knum++;                          
  402.                         if(knum==1)                                                 
  403.                         {
  404.                                  write_1302(0x8e,0x00);                  //DS1302写保护取消
  405.                                  write_1302(write_miao,0x80); //写秒80，时钟停止走时;
  406.                         }
  407.                        
  408.                         if(knum==3)                                                   //调时完毕，时钟启动
  409.                         {
  410.                                 TR0=1;
  411.                                 knum=0;
  412.                                 write_1302(write_miao,0x00); //写秒0，时钟启动走时
  413.                                 write_1302(0x8e,0x80);                 //保护启动
  414.                         }
  415.                 }
  416.         }


  419.         if(knum==1)                                                                //分钟调节
  420.         {
  421.                 if(key2==0)                                                        //加
  422.                 {
  423.                         count++;
  424.                         if(key2==0 && count>12)//短按加1，长按连加
  425.                         {
  426.                                 count=0;
  427.                                 fen++;
  428.                                 fen=fen/10*16+fen%10;                //转为16进制
  429.                                 if(fen==0x60)
  430.                                         fen=0x00;
  431.                                 write_1302(write_fen,fen);        //写入1302
  432.                         }
  433.                 }
  434.                
  435.                 if(key3==0)                                                   //减
  436.                 {
  437.                         count++;
  438.                         if(key3==0 && count>12)//短按减1，长按连减
  439.                         {
  440.                                 count=0;
  441.                                 fen--;
  442.                                 fen=fen/10*16+fen%10;                //转为16进制
  443.                                 if(fen==-1)
  444.                                         fen=0x59;
  445.                                 write_1302(write_fen,fen);
  446.                         }
  447.                 }
  448.         }
  449.        
  450.        
  451.         if(knum==2)                                                          //小时调节
  452.         {
  453.                 if(key2==0)
  454.                 {
  455.                         count++;
  456.                         if(key2==0 && count>12 )//短按加1，长按连加
  457.                         {
  458.                                 count=0;
  459.                                 shi++;
  460.                                 shi=shi/10*16+shi%10;                //转为16进制
  461.                                 if(shi==0x24)
  462.                                         shi=0x00;
  463.                                 write_1302(write_shi,shi);
  464.                         }
  465.                 }
  466.                
  467.                
  468.                 if(key3==0)
  469.                 {
  470.                         count++;
  471.                         if(key3==0 && count>12 )//短按减1，长按连减
  472.                         {       
  473.                                 count=0;
  474.                                 shi--;
  475.                                 shi=shi/10*16+shi%10;                //转为16进制
  476.                                 if(shi==-1)
  477.                                         shi=0x23;
  478.                                 write_1302(write_shi,shi);
  479.                         }
  480.                 }
  481.         }
  482. }          


  485. void main()
  486. {//        uchar i;
  487.         t0_init();
  488.         init_1302();                          
  489.         while(1)
  490.         {
  491.            //        for(i=0;i<4;i++)       
  492.         //        display(shi,fen,miao);
  493.             read_sf();
  494.             keyscan();
  495.         }
  496. }

  498. void temer1() interrupt 1
  499. {
  500.         TH0=(65536-46080)/256;
  501.         TL0=(65536-46080)%256;
  502.         ss++;
  503.         if(ss==20)
  504.                 ss=0;
  505. }        

  507. //void temer2() interrupt 3
  508. //{
  509. //        TH1=(65536-46080)/256;
  510. //        TL1=(65536-46080)%256;
  511. //        ss1++;
  512. //        if(ss1==20) //1秒
  513. //        {       
  514. //                ss1=0;
  515. ////                zs++;
  516. //                zs1--;
  517. //        }
  518. //}



复制代码
回复

使用道具 举报

ID:111376 发表于 2018-1-31 10:43 | 显示全部楼层
不错不错，感谢分享！
回复

使用道具 举报

ID:231936 发表于 2018-4-21 09:22 | 显示全部楼层
很好，可是掉电后就变了。
回复

使用道具 举报

ID:74370 发表于 2018-4-30 14:25 | 显示全部楼层
感谢分享
回复

使用道具 举报

ID:404878 发表于 2018-11-17 15:30 | 显示全部楼层
挺好的，正需要这样的程序，谢谢楼主
回复

使用道具 举报

ID:404878 发表于 2018-11-17 15:45 | 显示全部楼层
很可以想学习一下
回复

使用道具 举报

ID:127977 发表于 2018-11-17 16:47 | 显示全部楼层
学习了 啊 啊
回复

使用道具 举报

ID:658790 发表于 2019-12-8 14:25 | 显示全部楼层
仿真为啥打不开。。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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