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

yxlk

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

! u- Z( L! l! y7 P' s- \, Q7 a. M
1 i8 T! o- p+ ]' T/ ~2 F! T( ]- [+ N附件里有完整源码和仿真图
# U: Y: ^. M3 g
/*********************************************************************************
0 _$ _# g) s4 h. w6 W; ]描述： 8位共阴数码管时钟，显示88-88-88样式，正常走时的时候，两个“-”0.5秒闪烁一次；
6 H+ N' A) q# N/ b0 D6 }       调时：按KEY1按键第1次分钟位闪烁，再按KEY2一次分钟加1，按KEY3一次分钟减1，长按连加连减；
                         按KEY1按键第2次小时位闪烁，再按KEY2一次小时加1，按KEY3一次小时减1，长按连加连减；
                         按KEY1按键第3次，秒从零开始累加，时钟回到正常走时；
# U- |# s2 E2 `                         对时的时候先调好时、分，分钟要比参考时间的分钟加1分，
                         再看参考时间的秒数到了59再按KEY1按键的第3次，这样对时可以很准的
! N) A# W6 ~! Y1 k, o仿真 实物都通过.  11.0592MHz晶振，STC89C52RC，两个74HC573锁存器做位选、段选
* n  Y% f1 R! f; _! E**********************************************************************************/
5 k+ f) j4 I, ^  H#include
) w1 t9 I5 C. d0 |' _#include
8 j0 [) k- M% |! @4 A9 p#define uchar unsigned char
#define uint unsigned int
/ C1 G  d0 X0 @2 V& Z5 I: I# D) [
sbit sclk = P1^0;                                                                //1302时钟端口
sbit dio = P1^1;                                                                //1302数据端口
sbit ce = P1^2;                                                                        //1302使能
sbit wela = P2^7;                                                                //位选
sbit dula = P2^6;                                                                //段选
* W  B5 ^9 V, {$ Y) j9 c) q& x
sbit KEY1=P3^0;                                                                        //按键 设置/确认
sbit KEY2=P3^1;                                                                        //按键 加
sbit KEY3=P3^2;                                                                        //按键 减
5 |' J& F' u4 \2 B
uchar snum,fnum;

char shi,fen,miao;
- t% |5 @3 c& W+ |7 d* m3 |
4 p0 N4 }& ^* Q0 B) huchar ss;

% w+ Q0 m: Z5 pchar FunctionKeyNum=0;                                //功能键键值
char FuncTempNum=0;                                        //功能键临时键值
/ @3 f. G' B* _1 h0 Q' ]typedef enum KeyState{StateInit,StateAffirm,StateSingle,StateRepeat};        //键值状态值
# ~  }% d( ]4 k# z
7 _& a+ R4 s( I' H. N* e6 o
2 Y3 r  g0 E  B! h/***********写时分秒地址************/
#define write_shi  0x84
, d3 @) S& A4 |1 V: F3 Q#define write_fen  0x82
/ _3 r0 f8 V6 O2 ^) W+ ~8 b& s3 r#define write_miao 0x80

9 R  z9 N% H0 B1 m5 U  Q6 W/***********读时分秒地址************/
#define read_shi  0x85
( X9 q$ `* {4 L! ^: N& ]5 K- \#define read_fen  0x83
. l4 o- n( ]' [% S#define read_miao 0x81
" e# T3 K0 Y8 ]# h  O8 ~: y
5 Q' r; E) y1 t                  // 0     1    2    3    4     5    6    7    8   9
0 `/ E. Y. b  I, V# O3 s& I" u% Vuchar d[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F}; //共阴不带小数点
# ?" f8 o) F; o//uchar dd[]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef};  //        共阴带小数点
2 f3 K9 {, ~* M6 [2 B: B- p

void delay(uint z)
# \* g# T! k! y2 T- I{
        uint x,y;
        for(x=z;x>0;x--)
. ]* L2 p' q' D1 ]8 F! q. X                for(y=120;y>0;y--);
$ s8 ?3 q8 Q. U, z}
' |. a/ Y/ }! i1 ]* W
( G8 D* [4 I' j
void t0_init()  //定时50ms一个中断
* r/ ]4 a* O. C/ \) b- l8 B; t{
/ N2 ?# l+ D# a2 T2 D7 N
) K' v8 T. R- o% v+ C  TMOD |= 0X01;
  TH0 = (65536-46080)/256;
  TL0 = (65536-46080)%256;
! z' p+ L7 `6 s1 m; {1 ?2 A  EA = 1;
/ p( H, o& a1 h- F. l" u  ET0 = 1;
  TR0 = 1;
7 [* @  V) ~# v# P/ q/ S
}
$ H% l/ _( q1 ~' x- y
void t1_init()
+ D9 f: y) I* I{
/ X: Z% v  q( k$ o# X        TMOD |= 0x10;
2 [5 {, X9 ~8 M' F0 g9 ?; `        TH1 = 0xDC;
; ~. f3 b. A9 |2 H& G9 \* i; m        TL1 = 0x00;
/ U7 B3 I+ I) b2 y' W" Y        TR1 = 1;        
7 Z; F" O- |. [% X; K2 d* \}

5 i: W/ H7 h1 J1 _' ?2 p5 ]void temer0() interrupt 1
, d/ h" E2 ?0 e, g( _{
  TH0=(65536-46080)/256;
5 ~/ ^$ l6 J9 i: `% @! }: U  TL0=(65536-46080)%256;
  ss++;
  if(ss==20)
  ss=0;

# ^4 P1 D: ^# z}         





; S, W, g8 L3 }$ ]. }. g8 Gvoid display(uchar shi,uchar fen,uchar miao)                          //显示函数
{
        if(FunctionKeyNum==0)
        {
; I( e9 J7 H; v) y# V- M                snum=30;
                fnum=30;
+ j: t' d2 H: b/ d        }
2 j3 X$ W, T  Y: i  o        
        if(FunctionKeyNum==1)
1 a( V9 B2 S1 J+ F/ k        {
  J; b! ]: l4 S1 V                fnum++;
4 i/ y* {1 u/ Q: o( x                snum=30;
0 \2 n" M- i6 c2 {6 P        }
" F7 o; r. S* v3 n* u+ Z        
        if(FunctionKeyNum==2)
        {
                snum++;
* n3 O6 Z6 ^) J2 l: h1 ?* l; i4 y                fnum=30;
( A$ S* |0 x  g7 _; J3 P& |' _        }
        
' k; a% y% x( k5 P6 {/ y8 Q        
* ?& H* l& x7 i5 O        if(snum>=30)
        {        
                if((shi/10)<1)         //如果小时十位小于1，
- v+ o/ }/ L$ L9 L8 l2 W                {
                wela=1;
                P0=0xfe;                //第1位
: h) @, [6 x+ L/ C: p( ?& \# h                wela=0;
! t$ }4 e- `4 w  I  s
( M& o& q/ R7 [/ a  j  o                dula = 1;
* h) N% j6 G# T7 t# n( }                P0=0xff;           // 小时十位就不显示
                dula = 0;
                }
               
. D+ ]1 X- M  r! p. y! l. ~                else
, C9 L8 x" s/ Y7 f4 M1 F9 _                {
+ w, A5 X% V6 ^6 Y5 b, T                wela=1;
  f8 [% O5 Q- ^9 R                P0=0xfe;          //第1位
                wela=0;

                dula=1;
/ @! N" A1 I# R8 Z5 W                P0=d[shi/10];
4 y5 n/ U9 t* Z$ ~7 \* h" \                dula=0;
5 J* _( `3 d" J) h; T                P0=0xff;
                delay(2);
$ Z: q, \# K; H: f2 T                }
           
                        wela=1;
% }8 H* A* c2 [                        P0=0xfd;           //第2位
                        wela=0;
4 Q# N2 }& i0 g( m4 p2 ~+ z
                        dula=1;
                        P0=d[shi%10];                        //时的个位，P0=d[shi%10]时的个位小数点闪烁
                        dula=0;                                        // 时的个位，P0=dd[shi%10]时的个位小数点不闪烁
                        P0=0xff;
, k# w6 z) H! u% I! A                        delay(2);
2 X/ c" P' _) c6 ]2 M        
        
- v8 j( P% J/ x# a' ]4 L                if(snum==60)
                        snum=0;
        }               
. w& O4 W; S; c5 `

2 o# I: o& Q0 c8 [  K+ e        //        if(miao%2==0)         //if(miao%2==0) 1秒闪烁1次
% o0 X% a" i. |6 [                if(ss>=10)                 //        这里写为ss>=10，闪烁频率可调
                {                                 
8 k4 F" {2 c& K3 W4 L            wela=1;
  u/ [3 k, k4 _8 t0 ^                P0=0xfb;                //第3位
! n4 [  J& @/ n/ `; P9 ]                wela=0;
' e( D/ f; [% I' r4 s, a
) Q- f& f1 {1 H                dula=1;
                P0=0x40;          //第三位数码管显示“— ”
               
                dula=0;
                P0=0xff;
                delay(2);
        
                }
0 {+ f+ r' I1 n  T% Z
( t3 @% {4 \5 A" {$ S                else
                {
                wela=1;
7 v2 P+ f, ]8 [0 M# g                P0=0xfb;   //第3位
                wela=0;
8 l" y- D6 o! E) b* x
                dula=1;
                P0=0;          //第三位数码管不显示
                dula=0;
                P0=0xff;
                delay(2);        
$ }; p# Q+ e6 Z. i7 {                }
: g& e# W! e3 `, g, U6 \        
        
        if(fnum>=30)
+ t" J6 Z' }* j  z        {
                wela=1;
                P0=0xf7;         //第4位
/ k* W3 j6 G  V( Q& ~9 F                wela=0;

5 @( q( L# b, w6 `  X, c                dula=1;
                P0=d[fen/10];
                dula=0;
                P0=0xff;
                delay(2);
               
               
7 Y; B; k0 b4 s- V/ I( O# y) z+ s2 r                wela=1;
2 f! j4 J7 S7 k3 n- G0 D; s                P0=0xef;         //第5位
                wela=0;
% }' ?  p4 @$ R4 G2 v, k5 G( q
: c2 ~; r; v" u$ A9 R                dula=1;
                P0=d[fen%10];
: f, D$ }8 w) N                dula=0;
( T% [( f3 J2 [7 D                P0=0xff;
                delay(2);
        
               
0 Q8 I1 q. y: e$ p) N                if(fnum==60)
5 p9 B3 C7 c& I; y5 D7 S                        fnum=0;
        }
               
6 t/ F' W* }) Q1 `8 Q% _" }        //        if(miao%2==0)         //if(miao%2==0) 1秒闪烁1次
# d1 p! g+ h" c                if(ss>=10)                 //if(ss>=10)闪烁频率可调
                {
8 a- \+ u) P4 a                wela=1;
5 U' J9 @! }" u+ H                P0=0xdf;          //第6位
  t, ^, ^# |0 j% L& D7 ^" o2 g( E/ c                wela=0;
  R$ M: d( N% z- h2 k. B                dula=1;
% [6 }  r: I1 S" s                P0=0x40;          //第六位数码管显示“— ”
                dula=0;
6 F. w% T% a/ s, K; n+ Q                P0=0xff;

( f0 o; E4 u! H5 N                delay(2);
                }
5 K( o% w/ i7 y# C* I8 v; k
; f/ ?) d( S# W0 t) h                else
2 K: n) F; ^- t4 ~" }                {
: k, t  X) G! W% k& }; C$ Y0 [                wela=1;
6 e# L0 r9 |% j. Q) }                P0=0xdf;   //第6位
1 v$ G3 _6 P0 N2 c. x/ K/ l                wela=0;
                dula=1;
                P0=0;          //第六位数码管不显示
                dula=0;
5 W, a9 P  i: s+ i                P0=0xff;
; q$ g' l5 v# a% n% o2 w* @8 a
3 U) N$ h% G: c, R$ `! \2 x                delay(2);
                }
: N2 x2 T/ \' w7 g. y               
9 Z, {+ f/ X, I0 S9 h; {& D( I               
                wela=1;
8 V0 W3 Z  ]9 Z                P0=0xbf;                //第7位
4 T1 U5 V3 w, k! s2 \2 C. G                wela=0;

            dula=1;
                P0=d[miao/10];                           //秒十位
4 K) x0 p1 h" b4 j$ T                dula=0;
4 K, F( ?) q& h) p. W                P0=0xff;
  c  J/ J2 P5 Z& I* Y                delay(2);
        

& l, G: j5 t$ m% T1 p  q1 W+ o. ?. Z                wela=1;
1 K+ ^6 G7 I2 g3 x                P0=0x7f;                          //第8位
9 l, ^1 o) C0 f7 F5 a) p7 s                wela=0;
* K+ G$ M6 L" K' Y9 P" Q
                dula=1;
4 Q, _- q% i& w9 H0 S. E) K                P0=d[miao%10];                         //秒个位
. v  F6 z& k, h" C/ I                dula=0;
                P0=0xff;
5 j4 E! |( b: N8 ]& v                delay(2);               
! A9 J* g6 v: [/ r7 r* Y                                   
               
' w; {) x. J6 g7 x% s! X        
* M& @6 D1 A! k4 G# k4 s        
}  

' k0 L3 S# P; L; M6 r& ^

% j; _- _3 U! x5 s, q" ~void write_1302(uchar add,dat)                 //写1302函数  
{
& J2 z6 H7 c6 [/ p  L+ f        uchar i,temp;
        temp=add;
0 `$ |" m$ |0 K        ce=0;
7 a2 s; K$ R; G  N/ n        _nop_();
* ]) O3 n5 A) K: o7 X6 V; i        sclk=0;
        _nop_();
        ce=1;
# d9 }% ^9 Y9 R        _nop_();
; n+ V, [) Y" m* e) z        for(i=0;i<8;i++)
" j8 u# Q& N4 _' T7 ^5 i        {
                sclk=0;
                _nop_();
                if((temp&0x01)==0x01)
                        dio=1;
0 W  K, G# i5 D4 B# g                        else
                        dio=0;
! |4 w! K3 O& w5 U5 S                temp>>=1;
                sclk=1;
3 T& g8 D" C2 g* o                _nop_();
" B7 ~( C! C2 {( A3 t9 ^2 M        }
- C1 M& y9 P. i; F, b- o        temp=dat;
7 M1 j# F) f; h0 c7 I        for(i=0;i<8;i++)
        {
3 a# R; P% x" i6 O3 a1 s                sclk=0;
4 m  t# S( U, n: P; q- n                _nop_();
                if((temp&0x01)==0x01)
, N6 T. w* X6 [' O) X. V* H2 j                        dio=1;
- S2 |# C- D9 Z6 v+ m' B7 V                        else
0 `, ~8 _* F# [" r; B0 P                        dio=0;
                temp>>=1;
  ~; P' ?- b; H. u                sclk=1;
6 \4 z; O# p6 D- B7 |5 x) _0 T4 Q                _nop_();
2 j. s  Q/ ^  I% P0 m9 b' \5 n  c        }
        ce=0;
/ L2 w6 C* B9 _. ^/ e        sclk=0;
}
uchar read_1302(uchar add)                                   //读1302函数               
  D. ?. Q$ D: `- D{
        uchar dat,dat1,i,temp;
7 X, u- e/ `" N! f        temp=add;
        ce=0;
        _nop_();
        sclk=0;
7 v" a5 p1 T& e  |( Z        _nop_();
2 c3 ~- _. |1 V  h: _' D, O        ce=1;
( N# z# R( L% h4 x        for(i=0;i<8;i++)
        {
4 B" V5 \7 e+ [, A                sclk=0;
3 d# d. k- C$ A2 \                _nop_();
                if((temp&0x01)==0x01)
& w0 k/ m8 F3 q; |* |) o9 S                        dio=1;
; {/ Z$ @5 Y4 ~4 v) M                        else
/ O  o) M$ }5 _2 D! K5 ?: u4 j                        dio=0;
/ Q8 p) g& N5 H6 H! A                temp>>=1;
, P. d1 h5 ?2 b2 F+ s, F9 p7 c* G                sclk=1;
                _nop_();
1 e, w# q; a7 M0 d" d        }
4 L/ p; \2 a4 q+ e0 q4 P$ E        for(i=0;i<8;i++)
        {
                sclk=0;
                _nop_();
$ E8 c7 `8 H5 x) c% B                if(dio)
: Q; \: E' ^8 w1 O. v2 ^# R                    dat|=0x80;
                if(i<7)
                        dat>>=1;
' M3 Y2 }; D6 }- N9 O                sclk=1;
8 V5 z! C  X, D. m2 n, L: |9 D2 L        }
        dat1=dat/16;
3 @% Y8 i' T: {5 s/ ^        dat=dat%16;
        dat=dat1*10+dat;  
2 [# b3 d* v$ F' w, w$ |/ i        ce=0;
        sclk=0;
& ?: H. T) ]" Z: p        return dat;
}                        
9 e) a1 V, A( O# ^  J

: J3 r/ p# @6 r7 [3 M8 n
void init_1302()                                                        //初始化函数 设置时间
{        
2 V/ \6 \2 j- D8 O        write_1302(0x8e,0x00);                                        //保护取消，可以进行写操作
        write_1302(write_miao,0x57);        
        write_1302(write_fen,0x55);
% {9 I+ Y3 \, Q4 l        write_1302(write_shi,0x15);
; J, j0 D# d, O, g/ M        write_1302(0x8e,0x80);                                        //保护启动，不能进行写操作
}         
9 O) w* g" G( p" P) _. B' G
void read_sf()
3 r. b5 P* ?4 m6 v. \; p{
7 e1 [/ D" E- K. P- Y' N        shi=read_1302(read_shi);
        fen=read_1302(read_fen);
2 P8 r& n* _1 {: K2 d        miao=read_1302(read_miao);
* e+ b6 f" G9 I        display(shi,fen,miao);

$ \1 Q& v8 f! f% t% m( \}
& }8 f& `$ H  o$ |3 Q& e. y
6 |: J& S6 O# E' p8 x7 dvoid KeyScan(void)
0 y- a5 C& J  `& e* l{
        static uchar KeyStateTemp1 = 0;                  //按键状态临时存储值1
        static uchar KeyStateTemp2 = 0;                  //按键状态临时存储值2
5 `* y3 Y$ _/ S3 v! s: [) A2 j. ?        static uchar KeyStateTemp3 = 0;                  //按键状态临时存储值3
6 j  h, B  o2 h5 a& _) o        static uchar KeyTime = 0;                          //按键延时时间
        bit KeyPressTemp1;                                          //按键是否按下存储值1
% R2 v$ S0 N! g( n  @$ H        bit KeyPressTemp2;                                          //按键是否按下存储值2
        bit KeyPressTemp3;                                          //按键是否按下存储值3
8 A/ y7 T1 f% Z  V2 t8 X- ~+ \1 X5 ]
        KeyPressTemp1 = KEY1;                                  //读取IO口的键值
        switch(KeyStateTemp1)
; f( m/ `* h% O" ]9 `' ]        {
                case StateInit:
! h( f7 a4 B  N$ s$ @% J$ g                        if(!KeyPressTemp1)                                        //KEY1按下
0 n. k3 u* a) R' I4 ^0 x                                KeyStateTemp1 = StateAffirm;        //按键状态切换到确认态
                break;
) U# U8 [1 ?0 i. N( t9 A/ W                case StateAffirm:                                                //确认状态
9 A* J0 i) C: a& |  W                        if(!KeyPressTemp1)                                        //按键还在按下
- f8 O" R- |& ]% h, U& e                        {
5 v1 S2 ?: S5 W( h3 R6 N                                KeyTime = 0;
                                KeyStateTemp1 = StateSingle;        //按键状态切换到单击状态
: A" v. {# C4 Q- Q& I( @. M                        }
* {% `9 @- Q1 P3 ~4 ?5 P' {# B                        else KeyStateTemp1 = StateInit;                //否则按键抬起，回到初始态
  n6 n: y, J. `! h                break;
+ [5 R" U, _8 Q               
% p, m7 s1 R  P  A: T! Q                case StateSingle:                                                //单击
                         if(KeyPressTemp1)
8 O! J$ ^( }9 W, y5 f+ _( c                         {
* J. Q6 y0 @! E! w! w6 e. i                                KeyStateTemp1 = StateInit;                 //按键释放
                                FuncTempNum++;                                         //键值加1
                                if(FuncTempNum>3)  FuncTempNum = 0;
; {, B" N3 W. p, P& v2 z( _3 a                         }

                         else if(++KeyTime>100)
- B  f6 c# i* ^( g0 _                         {
$ u. _4 t4 v/ B) n1 n# W1 ?: G; ]                                         KeyPressTemp1 = StateRepeat;
% o9 X+ ]' ^1 M7 p& X. R# e1 s                                        KeyTime = 0;
                         }
                break;
        
                case StateRepeat:                                                 //连发
                        if(KeyPressTemp1)
' d) e$ R3 o% E, E                                KeyStateTemp1 = StateInit;
4 ^, s; z8 f) I. q                        else
                        {
                                if(++KeyTime > 10)
                                {
9 J9 B0 r1 g# X( j3 s                                        KeyTime = 0;
                                        FuncTempNum++;
$ y* S( i( _) D- Q4 t# b                                        if(FuncTempNum>3)  FuncTempNum = 0;
                                }
3 M; l* k0 B5 [- j- `& k, g- K                                break;
                        }
! z" z9 F+ x2 a( H5 J" J                break;
5 x$ W- o* L8 X" m        
  H% s' }7 p8 W: [# C7 i7 c" R                default :KeyStateTemp1 = KeyStateTemp1 = StateInit; break;
& Y4 C7 b, R) A                        
        }


if(FuncTempNum)                                                                //只有功能键被按下后，增加和减小键才有效
        {
# M/ j$ U! h1 `. s% l                KeyPressTemp2 = KEY2;                                        //读取I/O口的键值
+ w* Y( W6 m# t8 y; C) ?                switch(KeyStateTemp2)
& L! N0 t. Q# ~# ~                {        
                        case StateInit:                                                //按键初始状态
                                if(!KeyPressTemp2)                                //当按键按下，状态切换到确认态
9 l4 g* k0 h( S; L8 K- X' U                                        KeyStateTemp2 = StateAffirm;
* a% K! p2 a7 D/ K. o  i" a                                break;
* w  p+ {  o+ `4 K                        case StateAffirm:                                        //按键确认态
& r6 m5 v" S) Y. f                                if(!KeyPressTemp2)
4 ]4 m- J" H2 F1 E$ |                                {
                                        KeyTime = 0;
+ j6 c4 |8 ?" V# M                                        KeyStateTemp2 = StateSingle;//切换到单次触发态        
                                }
7 w+ Y) V5 u8 |, |; M9 i3 ^                                else KeyStateTemp2 = StateInit; //按键已抬起，切换到初始态
                                break;
; i! V* K/ }& z4 |; c7 j                        case StateSingle:                                        //按键单发态
                                if(KeyPressTemp2)                                //按下时间小于1s
- H% |' S1 R$ |$ c$ s) D                                {
                                        KeyStateTemp2 = StateInit;  //按键释放，则回到初始态
/ U  j: R- u6 g2 |                                        if(FunctionKeyNum == 1)                //若功能键第一次按下
                                        {
                                        fen++;
                                        fen=fen/10*16+fen%10;                //转为16进制
* \) D- |$ ]3 T                                        if(fen==0x60)
2 J% k- s7 e* H% U0 \0 [                                            fen=0x00;
                                           write_1302(write_fen,fen);        //写入1302
6 H- p6 {6 M0 r0 r2 j                                        read_sf();                                        //读出时间，然后显示
                                        }
. k1 i  f. e% y9 b+ ]                                        if(FunctionKeyNum == 2)                //若功能键第二次按下
8 V- @$ W( L0 j$ p9 Z, h, r8 b                                        {
' S. F6 p) F; l; u                                                shi++;
                                                shi=shi/10*16+shi%10;                //转为16进制
                                                if(shi==0x24)
1 n& ?; a* E) D: m( A4 z                                                        shi=0x00;
8 r# C2 b8 Y/ O1 w) u' f% I                                                write_1302(write_shi,shi);
6 y, B- B, b( H4 j1 H& I* X' [7 v) H                                                read_sf();
& a* F, ]- N6 X$ [* P1 i, l
                                        }
6 Z- L$ Q% B1 J% m" O7 s( @                                        }
9 a* o/ J/ s2 _. B$ S4 j# T- k: ^                                        else if(++KeyTime > 100)        //按下时间大于1s(100*10ms)
                                        {
/ E! L# A- x. h  y                                                KeyStateTemp2 = StateRepeat;//状态切换到连发态
                                                KeyTime = 0;        
                                        }
                                break;
                        case StateRepeat:                                        //按键连发态               
- f& u" `; @# n  ^4 O                                if(KeyPressTemp2)
3 i5 \: Z5 S' y" A$ S& q; _7 x0 ~1 C                                        KeyStateTemp2 = StateInit;        //按键释放，则进初始态
  j- j7 z2 a# n( A, m                                else                                                        //按键未释放
                                {
+ a( U4 }5 u$ s8 {4 u  U                                        if(++KeyTime > 10)                        //按键计时值大于100ms（10*10ms）
) C/ M$ r1 ^2 ?7 u' r/ ~. }                                        {
5 d# @7 @2 B3 t0 b/ C                                                KeyTime = 0;        
: A& l/ k- G8 L# y6 Q& K                                                if(FunctionKeyNum == 1)        //若功能键第一次按下
. L' s# @) P; j( I' q+ a                                                {
                                        fen++;
                                        fen=fen/10*16+fen%10;                //转为16进制
  k; Q# G% ]4 R1 v" k' z' X                                        if(fen==0x60)
; J" _5 E  X+ b                                            fen=0x00;
; S  w" h0 _9 i: q1 o% u                                           write_1302(write_fen,fen);        //写入1302
                                        read_sf();                                        //读出时间，然后显示
                                                }
; ^. D+ U5 u1 Z6 i6 E- [                                                
                                                if(FunctionKeyNum == 2)        //若功能键第二次按下
                                                {
& X5 @+ Y- p, z; N# z4 D                                                shi++;
                                                shi=shi/10*16+shi%10;                //转为16进制
                                                if(shi==0x24)
/ M  v  Y6 H. l, e, A  {8 o- `                                                        shi=0x00;
& l0 j. y# a5 d9 \/ b) ?9 _                                                write_1302(write_shi,shi);
                                                read_sf();
                                                }
                                        }
. R0 H& P. v0 U7 D/ k- ~                                        break;
                                }
                                break;
                        default: KeyStateTemp2 = KeyStateTemp2 = StateInit; break;
8 z) n3 b0 q* |0 H, S                }

$ u0 k8 L% k! X8 u: Z* n
                KeyPressTemp3 = KEY3;                                                //读取I/O口的键值
                switch(KeyStateTemp3)
* D# m" l, \* C1 z& u                {        
6 i8 T+ y1 x" O- @. e                        case StateInit:                                                        //按键初始状态
! G0 H  X: ~" T1 J2 b                                if(!KeyPressTemp3)                                        //当按键按下，状态切换到确认态
8 w9 {* E* ]" Z4 E) ]' Z  M1 E                                        KeyStateTemp3 = StateAffirm;
) h2 q$ z+ {7 a  F/ H( j                                break;
                        case StateAffirm:                                                //按键确认态
- c( l) v/ o0 E1 T4 k                                if(!KeyPressTemp3)
                                {
                                        KeyTime = 0;
                                        KeyStateTemp3 = StateSingle;        //切换到单次触发态        
% ~" Y8 ?$ V+ o$ I. f                                }
3 D# S/ p* e( S5 A6 X  @5 x                                else KeyStateTemp3 = StateInit;         //按键已抬起，切换到初始态
* s0 A+ k, l! b/ Q                                break;
                        case StateSingle:                                                //按键单发态
4 i1 V( V& s- i0 X1 ^7 o, K0 Y                                if(KeyPressTemp3)                                        //按下时间小于1s
                                {
% B0 V0 M* E( G; q) _' L                                        KeyStateTemp3 = StateInit;          //按键释放，则回到初始态
                                        if(FunctionKeyNum == 1)                        //若功能键第一次按下
                                        {
% {# |$ b5 a. M/ Y  j. [, [( k# H                                                fen--;
                                                fen=fen/10*16+fen%10;                //转为16进制
+ Z% s  t+ c: W3 n                                                if(fen==-1)
* j% J$ u2 a3 u+ J  c8 J                                                fen=0x59;
9 t" ^, E; `3 h) T                                                write_1302(write_fen,fen);
                                                read_sf();
  L8 X+ c4 F/ n- D. O0 l                                        }
+ U) e0 y+ s% I; S8 r$ \5 x8 N, R                                        if(FunctionKeyNum == 2)                        //若功能键第二次按下
                                        {
                                                shi--;
2 I5 x0 C; @4 k7 B4 Y+ g: K5 u: ]4 q& j                                                shi=shi/10*16+shi%10;                //转为16进制
                                                if(shi==-1)
                                                shi=0x23;
9 U$ s+ L% p' r7 ]0 C. q, T                                                write_1302(write_shi,shi);
; V# o- S4 D- T7 S                                                read_sf();
' r9 D0 m, N/ j) q                                        }
                                }
) S3 ]  L% n4 `% y* J                                else if(++KeyTime > 100)                        //按下时间大于1s(100*10ms)
                                {
6 H: a9 ], c/ B3 }: x2 \7 q                                        KeyStateTemp3 = StateRepeat;        //状态切换到连发态
7 f6 t% r( S7 u  @; l                                        KeyTime = 0;        
9 B- L# Z. d# T                                }
                                break;
                        case StateRepeat:                                                //按键连发态               
  c7 |3 S/ Z( r) G. z6 j6 u                                if(KeyPressTemp3)
                                        KeyStateTemp3 = StateInit;                //按键释放，则进初始态
% j" g& i1 V. ]0 g/ X7 O  |/ `" T                                else                                                                //按键未释放
8 ^+ s! R3 z1 B                                {
                                        if(++KeyTime > 10)                                //按键计时值大于100ms（10*10ms）
- Z7 U/ j- M* Q- |" w7 ~2 V& d# R: h                                        {
5 ~7 m; p6 |" O, K. Q6 c3 [                                                KeyTime = 0;        
2 C7 O! x0 ~1 |( }7 |/ `, W+ y3 H                                                if(FunctionKeyNum == 1)                //若功能键第一次按下
* T. Q5 `+ v9 D/ ~8 r3 Q                                                {
1 K- V8 O9 ]- ~8 k- c# |3 _0 q                                                        fen--;
                                                        fen=fen/10*16+fen%10;                //转为16进制
2 K* t9 Y8 m  r, A+ M9 ^                                                        if(fen==-1)
                                                        fen=0x59;
                                                        write_1302(write_fen,fen);
                                                        read_sf();
                                                }
3 A% j9 B# J0 r/ j* e/ Z* @                                                if(FunctionKeyNum == 2)                //若功能键第二次按下
                                                {
+ p6 p" ]/ g5 ~0 ]4 h- ^% a: d% D                                                        shi--;
                                                        shi=shi/10*16+shi%10;                //转为16进制
                                                        if(shi==-1)
                                                        shi=0x23;
                                                        write_1302(write_shi,shi);
) _+ O* B* e& X# Q/ |( p: `$ I                                                        read_sf();
1 T3 z/ ?6 v- D3 U# E                                                }
% i9 X( L2 r. T7 j                                        }
                                        break;
5 P2 i7 f/ ~% X! w$ X7 l5 o) l                                }
                                break;
3 X( }3 d! d5 a; r1 g                        default: KeyStateTemp3 = KeyStateTemp3 = StateInit; break;
                }
        }
8 O; `( d# R( J' d) P; L1 U}


void ExecuteKeyNum()
6 p4 y, M2 O$ d{
        if(TF1)
        {
                TF1 = 0;
; ]$ [0 q$ w/ Q' d" d                TH1 = 0xDC;
7 }2 T7 x  O& ^/ W# w7 A; k                TL1 = 0x00;
                KeyScan();
! z. D7 A4 |4 \2 L% |8 O        }

; {" ^9 ^# d5 T  T. D* W以上是部分源码，完整的代码在附件里：
下载：

游客，如果您要查看本帖隐藏内容请回复

Demyar

谢谢分享

Mhza

看看楼主的代码

wang5825

谢谢楼主分享