欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: DS1302 8位數碼管時鐘，調時可以連加連減 [打印本頁]
作者: lids    時間: 2017-4-25 14:59
標題: DS1302 8位數碼管時鐘，調時可以連加連減
附件里有完整源碼和仿真圖

/*********************************************************************************
描述： 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, 下載次數: 189)



作者: xmch    時間: 2017-7-8 22:25
感謝分享
作者: lids    時間: 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. //}



復制代碼
作者: stlong    時間: 2018-1-31 10:43
不錯不錯，感謝分享！
作者: gxlin    時間: 2018-4-21 09:22
很好，可是掉電后就變了。
作者: 釣魚臺    時間: 2018-4-30 14:25
感謝分享
作者: lzDestiny    時間: 2018-11-17 15:30
挺好的，正需要這樣的程序，謝謝樓主
作者: lzDestiny    時間: 2018-11-17 15:45
很可以想學習一下
作者: jiangyimfs    時間: 2018-11-17 16:47
學習了 啊 啊
作者: l730    時間: 2019-12-8 14:25
仿真為啥打不開。。



歡迎光臨 (http://www.raoushi.com/bbs/) Powered by Discuz! X3.1