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

yxlk

DS1302 8位数码管时钟，调时可以连加连减
2 B. H  m' R/ ~8 [
- r3 h; @" U; Q/ }. y4 L
# Q( V" n7 M' C! p9 M附件里有完整源码和仿真图

( w6 ~) r6 M# q2 G, p/*********************************************************************************
" y9 c9 Q9 A5 G: ~+ B8 k描述： 8位共阴数码管时钟，显示88-88-88样式，正常走时的时候，两个“-”0.5秒闪烁一次；
       调时：按KEY1按键第1次分钟位闪烁，再按KEY2一次分钟加1，按KEY3一次分钟减1，长按连加连减；
                         按KEY1按键第2次小时位闪烁，再按KEY2一次小时加1，按KEY3一次小时减1，长按连加连减；
                         按KEY1按键第3次，秒从零开始累加，时钟回到正常走时；
3 f) X* |# M0 K& h4 F/ c$ e2 [8 _  p                         对时的时候先调好时、分，分钟要比参考时间的分钟加1分，
                         再看参考时间的秒数到了59再按KEY1按键的第3次，这样对时可以很准的
仿真 实物都通过.  11.0592MHz晶振，STC89C52RC，两个74HC573锁存器做位选、段选
**********************************************************************************/
9 n: _& }7 f/ s5 E#include
) E. y1 ~, g; I; ^$ V3 K" X#include
* r" u5 q) O1 x7 Y' {#define uchar unsigned char
#define uint unsigned int

0 V5 u( e' ^! i# gsbit sclk = P1^0;                                                                //1302时钟端口
sbit dio = P1^1;                                                                //1302数据端口
% u5 x; C0 E( Y* P# isbit ce = P1^2;                                                                        //1302使能
sbit wela = P2^7;                                                                //位选
9 D& H- S9 Z( n0 I, Q. qsbit dula = P2^6;                                                                //段选
8 Y- U$ q4 Q* Q+ _. y
4 p- y. I% S+ ^9 @sbit KEY1=P3^0;                                                                        //按键 设置/确认
sbit KEY2=P3^1;                                                                        //按键 加
sbit KEY3=P3^2;                                                                        //按键 减
" s( c/ j8 h' A0 M% |1 T
uchar snum,fnum;
5 J* F" C. o% m) ^# c
char shi,fen,miao;

uchar ss;
  y$ ?. f/ k9 S
char FunctionKeyNum=0;                                //功能键键值
# Y6 T  G3 i# U7 g. u3 E9 Xchar FuncTempNum=0;                                        //功能键临时键值
typedef enum KeyState{StateInit,StateAffirm,StateSingle,StateRepeat};        //键值状态值
: w5 ]: C. L. y% ]( P. G

- {0 A, h! V9 h/***********写时分秒地址************/
#define write_shi  0x84
) {: Y! U3 j% c#define write_fen  0x82
#define write_miao 0x80

/***********读时分秒地址************/
& L; K8 a2 J, P) g5 }#define read_shi  0x85
  U# f+ S2 P, K- z& ^# s#define read_fen  0x83
#define read_miao 0x81
3 @& g) m$ x( K/ ~
                  // 0     1    2    3    4     5    6    7    8   9
4 ]2 c0 F3 c$ p1 Q0 c1 Luchar d[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F}; //共阴不带小数点
( z5 h% C" J% n( c//uchar dd[]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef};  //        共阴带小数点
, P" x) O5 f1 u, M
& ~9 \) |/ b" x/ G; x/ @/ {" ~8 |9 `
void delay(uint z)
- H# C5 s% q1 t{
        uint x,y;
        for(x=z;x>0;x--)
                for(y=120;y>0;y--);
. i' p- W4 x$ V% ]) q9 K}
7 r( I: Y2 z3 _" a1 y4 e) J

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

) z' W' |, n2 S/ k/ e4 P+ @7 N" j  TMOD |= 0X01;
  TH0 = (65536-46080)/256;
0 V- J3 e' k' S" ~- f) G  TL0 = (65536-46080)%256;
$ w# H7 t4 {4 J* M  EA = 1;
  ET0 = 1;
1 ^+ m: M# t0 }+ i/ ]  TR0 = 1;
6 E" F' U+ e2 W4 ^8 i5 b
8 K7 E1 B6 x: S. Z8 n1 L$ V2 i}
$ j* }* r$ H. I" W4 t. g) f
8 Y4 O+ `  [9 N% W1 D4 E/ ^void t1_init()
4 P7 D: h% q9 H, w7 t& s{
. f6 H1 W" C3 W, W  Q' w# ^        TMOD |= 0x10;
        TH1 = 0xDC;
        TL1 = 0x00;
. _" o9 N* Q/ v0 j4 Q, e" u        TR1 = 1;        
}
% d$ S1 I! D) f6 _
void temer0() interrupt 1
{
  TH0=(65536-46080)/256;
2 b3 z& l' @: H5 c7 f8 ]  TL0=(65536-46080)%256;
$ q/ }  S6 F. S. [1 [& C1 S  ss++;
  if(ss==20)
  ss=0;
# z$ |( B# J0 }
}         
8 h% e3 _& g% B4 Z) Y2 W  v
% j& ?4 x" o# c( T4 g: U, a
9 O* d0 [* A, j: ^" O
% y) L- w4 {: X! k! L, B$ y
! }4 ?1 k$ E/ `; P: m! s: C3 x
void display(uchar shi,uchar fen,uchar miao)                          //显示函数
{
        if(FunctionKeyNum==0)
' b$ m5 I! u+ f; D5 G3 B, B  Z        {
, t" \6 }  [4 d8 J                snum=30;
7 h4 _: L5 m  H- ~: j8 T% h% {. d                fnum=30;
3 j) s5 }; i- X5 G$ Y6 @        }
) Z! s7 p, P( O- q% a        
        if(FunctionKeyNum==1)
        {
% H! a9 d$ e4 c! q9 u% y                fnum++;
" {8 }, R! j9 M+ ?" M                snum=30;
  ^, W1 n/ b4 G' h        }
        
: s$ X5 T; i3 _' q' G        if(FunctionKeyNum==2)
        {
/ Y! b( Y, f0 Z: ?, F7 m                snum++;
                fnum=30;
        }
+ V9 F7 F; \- ]* T7 i        
# P2 s* g3 _5 h5 M        
        if(snum>=30)
( P) Y4 N# d, h! c, g: w+ ^        {        
                if((shi/10)<1)         //如果小时十位小于1，
" n, R9 r& ]: H/ K9 J( E                {
                wela=1;
                P0=0xfe;                //第1位
/ F; p) N% c: T  D                wela=0;

4 V& t( `8 R4 u! N3 ^( ?; R                dula = 1;
                P0=0xff;           // 小时十位就不显示
6 z% h) \$ j  A0 Q  D# S                dula = 0;
                }
               
                else
                {
                wela=1;
2 @5 [% {- U& `: @                P0=0xfe;          //第1位
# L: M* {1 b2 h; {2 u2 y* [2 Y8 n                wela=0;

                dula=1;
                P0=d[shi/10];
                dula=0;
                P0=0xff;
/ f2 ^- l# O; F5 Y6 F                delay(2);
' y2 ^1 Y! y7 j/ K3 M" T                }
, t$ ^  \* E: ]! K( c# w6 |           
5 @5 {' c/ s, h' q# l                        wela=1;
5 {, m- i5 A0 v6 U- g0 y                        P0=0xfd;           //第2位
                        wela=0;

                        dula=1;
                        P0=d[shi%10];                        //时的个位，P0=d[shi%10]时的个位小数点闪烁
- W6 q* }# P% e: Y" _6 T                        dula=0;                                        // 时的个位，P0=dd[shi%10]时的个位小数点不闪烁
: v4 t1 _+ o, M2 r3 Y' p                        P0=0xff;
                        delay(2);
) L* U* q5 C: V        
) a5 _4 ^: K0 W; J; G7 G        
                if(snum==60)
: G: x% n, Q4 i- u+ I                        snum=0;
9 n' ^4 N' a- m; d4 @( T  k) c        }               


" r2 L. l$ M% V0 W4 a( n1 m( h/ s        //        if(miao%2==0)         //if(miao%2==0) 1秒闪烁1次
7 `8 K8 I$ ]6 O3 c# \) G                if(ss>=10)                 //        这里写为ss>=10，闪烁频率可调
- n! g, X& X/ c  E                {                                 
$ E. N6 R0 E$ e5 \            wela=1;
# d+ X; I$ p3 V8 m6 ?' J                P0=0xfb;                //第3位
                wela=0;
8 q7 q5 Y' c) n5 x: Y4 Y
5 R2 M1 g6 R; R  `( N: D                dula=1;
                P0=0x40;          //第三位数码管显示“— ”
, x+ V( S4 ?) T- @% g               
, N8 ]' ]$ \* C7 w: j3 C                dula=0;
# j: a; ^+ G7 f0 k                P0=0xff;
                delay(2);
0 D$ d# Y0 D/ v4 \0 d        
                }
$ }8 [8 h  t. h9 v# `- {
                else
) k! }8 [  _# g( ~. X0 H: N                {
                wela=1;
* U9 E4 F$ n0 u) a# c  ?1 b; X. D                P0=0xfb;   //第3位
                wela=0;

                dula=1;
& N; t" b0 v7 ~5 N$ l# U) y+ V5 P0 Z! Z                P0=0;          //第三位数码管不显示
                dula=0;
2 n0 d$ s* L: K. ]7 ^                P0=0xff;
                delay(2);        
                }
- Z5 F- `2 b9 R6 J  l8 g9 ?        
! j/ x! X$ H- Z* I/ j5 Z        
; R! D8 L3 V; ~  s4 h+ Q& S        if(fnum>=30)
        {
0 |3 k7 L4 G/ v                wela=1;
                P0=0xf7;         //第4位
                wela=0;

) [: x: t3 A* G$ \                dula=1;
                P0=d[fen/10];
+ I+ \( Z& m8 o/ o1 ?( P! N                dula=0;
* F. r, k; u' d! F8 r' {                P0=0xff;
                delay(2);
               
. k( M, s1 v; J( _               
                wela=1;
  x* b' w2 c  o+ G* ]0 _                P0=0xef;         //第5位
                wela=0;

/ t/ F4 @$ h- S3 c" ]' z( V) H                dula=1;
2 j8 ^% P1 {' d# I1 Y" G8 L                P0=d[fen%10];
: e* H* q. k$ j                dula=0;
) Q# H7 Z  M' i1 s                P0=0xff;
                delay(2);
        
6 l6 R/ G! _, z% K9 b" T  n               
) z7 J# k/ z) z                if(fnum==60)
) v0 U  `+ q. F' g$ y( J8 L                        fnum=0;
5 S0 `' S8 Y( \5 B        }
               
        //        if(miao%2==0)         //if(miao%2==0) 1秒闪烁1次
2 K4 ^0 V- o# e( c( w( J  p7 o$ ]( u                if(ss>=10)                 //if(ss>=10)闪烁频率可调
" |7 ^7 n! A! h. f  V2 w                {
8 B9 o0 e& a# ~, K, t" `* ~                wela=1;
0 X9 \; P1 T' X2 k8 W                P0=0xdf;          //第6位
                wela=0;
  Y2 S+ ~" S+ o' r4 {  {                dula=1;
                P0=0x40;          //第六位数码管显示“— ”
& A2 Z  @3 {( B  `" g9 o' J; J                dula=0;
5 b$ ^. q9 k( l# L9 B7 M% ~( g3 W                P0=0xff;
: s3 Y( b' A0 a6 f
* G- t- x( ?7 Q2 n                delay(2);
                }
# ~' L1 Y2 v  ^# N8 p  d: A
) c0 u1 q: J6 c5 x! n2 t                else
$ i0 z7 V' v  @& _9 W                {
                wela=1;
                P0=0xdf;   //第6位
                wela=0;
                dula=1;
                P0=0;          //第六位数码管不显示
  G* Q' N1 V2 V, b+ z  _" w( @- F                dula=0;
" f+ v9 _" Q* B% e, B                P0=0xff;
  n% L. J( @: ^" g
                delay(2);
                }
               
% o: i% A9 Y5 a5 x6 I               
  X! M. S1 K( r) @* C! \1 `' Z                wela=1;
                P0=0xbf;                //第7位
$ \4 u" `& M7 H1 q7 X+ |" D                wela=0;

! j# Q7 j( C. A! \' ?            dula=1;
5 i5 y: j7 J$ d% {0 _2 z, Q: q                P0=d[miao/10];                           //秒十位
                dula=0;
                P0=0xff;
                delay(2);
        

                wela=1;
                P0=0x7f;                          //第8位
' z; N, e! |$ b% f$ j4 u4 y' G                wela=0;

                dula=1;
                P0=d[miao%10];                         //秒个位
                dula=0;
6 ]! S) p# d$ z# |0 z3 b, H+ c                P0=0xff;
  p" ~2 r* F/ d5 ~' s, ~1 q                delay(2);               
3 f& l" X2 c; X                                   
. a" Z( x5 b9 Z7 K1 r9 u  W9 c) O0 @               
        
5 ~; L- @& e9 Z# v4 H        
}  



void write_1302(uchar add,dat)                 //写1302函数  
{
        uchar i,temp;
        temp=add;
2 O, R  Q9 |( u4 w! x" g        ce=0;
2 V" s- ~3 C4 R8 h- O        _nop_();
- `+ ]8 n/ |! ?  I5 w* q6 Z        sclk=0;
! G4 ~4 B4 \) L6 ^; D        _nop_();
        ce=1;
        _nop_();
        for(i=0;i<8;i++)
        {
                sclk=0;
                _nop_();
3 y- l: |% g  k, I                if((temp&0x01)==0x01)
3 f# a. P3 l3 s: Y8 X/ l                        dio=1;
                        else
+ q# c: [. o7 Q: P6 k, ?# b                        dio=0;
1 V, Z4 g+ f8 Q- Z0 m& H                temp>>=1;
. y4 L* k+ c! G. G! s# I1 Y, t                sclk=1;
& ^; W1 x6 c3 ?& @                _nop_();
; {) X0 h% z. u3 Z0 ?5 a% V' r- v4 b        }
: |- v& `! ]8 `% a        temp=dat;
) c' H$ v. V" r8 |- h. W        for(i=0;i<8;i++)
        {
& ~; m8 V7 ^+ n" V9 g7 k* @& L4 G2 J                sclk=0;
                _nop_();
2 N) V; a# M5 N( V                if((temp&0x01)==0x01)
                        dio=1;
                        else
( {$ o7 {6 U3 n0 h. }) ?                        dio=0;
0 p1 N' u8 j5 ~3 w+ b# }' ?                temp>>=1;
* N2 \, g9 f% @- S% u6 @1 F/ ^' x                sclk=1;
# _1 h7 g- G+ N                _nop_();
# y0 a2 A  \1 [- y, Q& z- R        }
4 h4 {) }6 o6 S+ E7 q3 a        ce=0;
4 _  n8 s2 Z5 E: e7 ^6 p: O        sclk=0;
}
uchar read_1302(uchar add)                                   //读1302函数               
1 ~: L- ~  i2 ~& \6 `$ J1 }( A/ q{
        uchar dat,dat1,i,temp;
7 Q1 p# m: s# Z2 X1 p5 Z5 _        temp=add;
, {7 `4 l# p/ E3 [        ce=0;
$ A# e/ W8 R. ~. {; @& n; B7 Z        _nop_();
        sclk=0;
4 R5 F3 w1 `/ k4 ^; a        _nop_();
% a, a4 U" B* i$ [7 c        ce=1;
        for(i=0;i<8;i++)
        {
                sclk=0;
                _nop_();
/ u! [" }; V: D7 ^( h                if((temp&0x01)==0x01)
+ Z4 o( F5 F6 N; P                        dio=1;
                        else
; @+ c* _$ m1 b3 x                        dio=0;
                temp>>=1;
4 A4 {- H$ ^* r& F                sclk=1;
% ~9 D0 L4 p8 `) I, @9 o. m                _nop_();
" c0 V: x. Q2 |7 _9 B+ b0 \' ^        }
4 F8 ~* }- c. E4 x* r% M5 E        for(i=0;i<8;i++)
- b+ Y. \+ i' W6 {* Q        {
4 f( u5 B- f: I/ {, G$ \; K                sclk=0;
                _nop_();
& ?$ w# c1 }$ v                if(dio)
2 H' u! a0 J' p$ M2 d                    dat|=0x80;
                if(i<7)
/ }- p* V; D1 L) G                        dat>>=1;
9 R  E9 X& c; s! T: x- |                sclk=1;
* t3 B+ Z: ~/ Z' V        }
5 b* Z5 ~& K' N/ ~* e        dat1=dat/16;
        dat=dat%16;
! Z1 J' F" ~$ y& l( Z        dat=dat1*10+dat;  
; T) ~& O- S; D+ N, b9 C1 `        ce=0;
        sclk=0;
        return dat;
}                        

% @" P+ I8 {7 ?
3 f! j- p% k9 |7 y' W( M" H& O
$ M0 n% `% }( rvoid init_1302()                                                        //初始化函数 设置时间
{        
        write_1302(0x8e,0x00);                                        //保护取消，可以进行写操作
) n( \6 c( a5 ^' A0 v4 P! o# l        write_1302(write_miao,0x57);        
& w" i4 Q6 t. E1 B        write_1302(write_fen,0x55);
4 \6 @! g2 |7 X5 f5 y: Z, ^        write_1302(write_shi,0x15);
        write_1302(0x8e,0x80);                                        //保护启动，不能进行写操作
/ k( v; V- q' W}         
, w4 r* T8 F: i, K4 _. V# t
8 n9 c9 v) X* f$ [* `. N. r! Kvoid read_sf()
5 J+ ?- n& Z* k& s; l3 \" n{
% t2 j2 n: V, F! @3 z# s1 T" e        shi=read_1302(read_shi);
        fen=read_1302(read_fen);
        miao=read_1302(read_miao);
        display(shi,fen,miao);

7 ~3 N1 }0 b! j- I+ X9 \3 i( ?}

void KeyScan(void)
, i% E7 V0 x, l4 W& n{
        static uchar KeyStateTemp1 = 0;                  //按键状态临时存储值1
! h- L4 A0 n, j- S        static uchar KeyStateTemp2 = 0;                  //按键状态临时存储值2
! t6 t0 V( Y/ k/ U. R        static uchar KeyStateTemp3 = 0;                  //按键状态临时存储值3
        static uchar KeyTime = 0;                          //按键延时时间
        bit KeyPressTemp1;                                          //按键是否按下存储值1
        bit KeyPressTemp2;                                          //按键是否按下存储值2
7 I# [: P9 ?; }4 J0 f4 k        bit KeyPressTemp3;                                          //按键是否按下存储值3

        KeyPressTemp1 = KEY1;                                  //读取IO口的键值
        switch(KeyStateTemp1)
        {
. v0 i4 I) E& x$ G9 A( q. `                case StateInit:
6 [2 L/ C: j7 q/ u4 L* j. B                        if(!KeyPressTemp1)                                        //KEY1按下
                                KeyStateTemp1 = StateAffirm;        //按键状态切换到确认态
                break;
: g9 {* U# |% N+ D* T4 _8 @3 O$ `  ^                case StateAffirm:                                                //确认状态
# K1 U6 h6 v, Z                        if(!KeyPressTemp1)                                        //按键还在按下
  X8 Y9 I$ X# @6 z+ h( l                        {
$ v; O3 E. O) f* ^( j% u$ z                                KeyTime = 0;
                                KeyStateTemp1 = StateSingle;        //按键状态切换到单击状态
7 }1 B7 c  E8 [' E4 y                        }
) B$ d' ?! a5 }                        else KeyStateTemp1 = StateInit;                //否则按键抬起，回到初始态
                break;
               
3 `, v* ]7 V" |; |1 u: p0 }                case StateSingle:                                                //单击
5 r  g1 z/ U5 Q1 G* j8 a6 ^                         if(KeyPressTemp1)
) z% q0 e& S. s# I2 v5 Y& q5 p+ S                         {
0 D2 A" ~0 W" o3 q. h" D                                KeyStateTemp1 = StateInit;                 //按键释放
                                FuncTempNum++;                                         //键值加1
                                if(FuncTempNum>3)  FuncTempNum = 0;
                         }
7 ^. ^6 j  g$ i! I" g
                         else if(++KeyTime>100)
# V" }6 J( d; d: N- K                         {
                                         KeyPressTemp1 = StateRepeat;
- E& _! `, A3 D9 U                                        KeyTime = 0;
9 o# b3 X$ r# b6 m7 H                         }
, [! w3 s5 v+ x' J; A                break;
        
2 R$ O$ N0 P+ |! t                case StateRepeat:                                                 //连发
) ~% a+ I" `1 y- P1 Q2 g- ~                        if(KeyPressTemp1)
; \/ A7 |9 V% b2 S: G; K                                KeyStateTemp1 = StateInit;
                        else
- ?2 z8 {7 B* q3 A5 r0 |5 V1 S! E) h( a                        {
                                if(++KeyTime > 10)
                                {
                                        KeyTime = 0;
                                        FuncTempNum++;
# h9 J# P9 s8 G6 z                                        if(FuncTempNum>3)  FuncTempNum = 0;
                                }
' V; T7 A  e" V4 ~6 S4 X2 ?                                break;
                        }
5 e  k6 R3 P  Y                break;
- A5 N, u7 z1 H  _- i% S3 d        
                default :KeyStateTemp1 = KeyStateTemp1 = StateInit; break;
                        
        }

6 A6 j! b% |$ D
if(FuncTempNum)                                                                //只有功能键被按下后，增加和减小键才有效
        {
; f9 D1 Y& _6 N9 u: y                KeyPressTemp2 = KEY2;                                        //读取I/O口的键值
* ?$ C: |! _5 X/ s                switch(KeyStateTemp2)
                {        
                        case StateInit:                                                //按键初始状态
                                if(!KeyPressTemp2)                                //当按键按下，状态切换到确认态
/ y8 o4 O8 j7 D                                        KeyStateTemp2 = StateAffirm;
                                break;
  M3 b6 a6 a4 }! P% Q  I                        case StateAffirm:                                        //按键确认态
  L/ A2 Y( H# l                                if(!KeyPressTemp2)
                                {
+ z0 d# d/ f8 T: c5 S0 _+ A& s                                        KeyTime = 0;
                                        KeyStateTemp2 = StateSingle;//切换到单次触发态        
                                }
                                else KeyStateTemp2 = StateInit; //按键已抬起，切换到初始态
: o2 B+ Y6 F# \" s2 b" p2 a                                break;
7 Y# }2 g3 c6 g                        case StateSingle:                                        //按键单发态
                                if(KeyPressTemp2)                                //按下时间小于1s
1 L( b; t, o  z3 w7 q# e: K                                {
6 ?" O, t  x! `# Z$ q                                        KeyStateTemp2 = StateInit;  //按键释放，则回到初始态
5 D+ ]( R; T# A                                        if(FunctionKeyNum == 1)                //若功能键第一次按下
                                        {
                                        fen++;
/ @0 e. \6 J9 {6 n- s                                        fen=fen/10*16+fen%10;                //转为16进制
                                        if(fen==0x60)
. M* l: h  G& }2 J7 ^                                            fen=0x00;
                                           write_1302(write_fen,fen);        //写入1302
9 V& z8 M8 g+ y- S  e0 e                                        read_sf();                                        //读出时间，然后显示
& N. ?! \8 x& k9 [/ U8 `$ z/ `                                        }
                                        if(FunctionKeyNum == 2)                //若功能键第二次按下
; F6 S% {3 r9 R8 A+ u- q                                        {
                                                shi++;
                                                shi=shi/10*16+shi%10;                //转为16进制
                                                if(shi==0x24)
0 A5 K  e/ ]6 h. L- p- r' d6 R                                                        shi=0x00;
3 }8 w3 I* t6 ]: h$ x                                                write_1302(write_shi,shi);
1 W; ?) h2 E- {; q) I                                                read_sf();

                                        }
                                        }
$ u+ h; i2 T0 a                                        else if(++KeyTime > 100)        //按下时间大于1s(100*10ms)
                                        {
% m8 h; [$ d* ^4 A                                                KeyStateTemp2 = StateRepeat;//状态切换到连发态
1 `: L8 N* n- Y                                                KeyTime = 0;        
( F4 B- n! b9 @" r, M                                        }
: ^6 G3 g+ o! D( {( g* e* Z; f                                break;
/ y7 b2 v) S( C3 b1 q+ u5 i1 F+ Q                        case StateRepeat:                                        //按键连发态               
7 c& h6 j( A" i; k: Q                                if(KeyPressTemp2)
                                        KeyStateTemp2 = StateInit;        //按键释放，则进初始态
                                else                                                        //按键未释放
                                {
                                        if(++KeyTime > 10)                        //按键计时值大于100ms（10*10ms）
                                        {
) q, w+ C2 [! [                                                KeyTime = 0;        
                                                if(FunctionKeyNum == 1)        //若功能键第一次按下
1 @0 W. E5 N; c% L  w- x1 }                                                {
7 |. g* o, o% Y                                        fen++;
                                        fen=fen/10*16+fen%10;                //转为16进制
3 v" T. U) k+ H# p                                        if(fen==0x60)
! j( K* D- D) [( d2 N2 O7 x2 Q                                            fen=0x00;
3 e- _6 g7 `! c& b4 ~                                           write_1302(write_fen,fen);        //写入1302
5 k& @$ h+ g3 S$ J: \: L; r( ~                                        read_sf();                                        //读出时间，然后显示
/ u  ~+ u! _0 q% h7 y1 [3 X                                                }
" a/ K( T* z! p                                                
                                                if(FunctionKeyNum == 2)        //若功能键第二次按下
                                                {
2 |  N5 W  s! N# l1 _                                                shi++;
+ i5 |% N0 f2 v- E# o3 v                                                shi=shi/10*16+shi%10;                //转为16进制
                                                if(shi==0x24)
7 ?' {( @; J! `1 M. K# g# Z# X- N                                                        shi=0x00;
* W! P7 j; D( V+ v. K                                                write_1302(write_shi,shi);
8 j) K( V& J$ R: I9 k, u$ f2 r                                                read_sf();
                                                }
& J* h6 s4 q- H" ?0 v: y                                        }
                                        break;
6 ?7 H0 ~6 T/ c& ]0 q                                }
                                break;
                        default: KeyStateTemp2 = KeyStateTemp2 = StateInit; break;
                }
& A6 f) S' }$ b8 W9 k  W3 r

                KeyPressTemp3 = KEY3;                                                //读取I/O口的键值
8 z- p) o% X* |5 y1 T) E! l' p1 R/ Y                switch(KeyStateTemp3)
                {        
                        case StateInit:                                                        //按键初始状态
9 |- N4 @0 a& `5 z0 O( D! K  D                                if(!KeyPressTemp3)                                        //当按键按下，状态切换到确认态
                                        KeyStateTemp3 = StateAffirm;
  ?: Z2 ]0 c# C4 d6 D% }' ~/ `/ y8 f                                break;
                        case StateAffirm:                                                //按键确认态
                                if(!KeyPressTemp3)
                                {
                                        KeyTime = 0;
                                        KeyStateTemp3 = StateSingle;        //切换到单次触发态        
/ ^- r; j; P# T) O                                }
                                else KeyStateTemp3 = StateInit;         //按键已抬起，切换到初始态
0 ?7 s7 o' G5 U                                break;
                        case StateSingle:                                                //按键单发态
2 N( m( ^- \  K                                if(KeyPressTemp3)                                        //按下时间小于1s
                                {
1 m1 l: i: b9 B* p                                        KeyStateTemp3 = StateInit;          //按键释放，则回到初始态
1 n- F& l% y( Z4 t6 B& L                                        if(FunctionKeyNum == 1)                        //若功能键第一次按下
                                        {
0 `) z# r* H( p                                                fen--;
                                                fen=fen/10*16+fen%10;                //转为16进制
- q+ R& T+ i! b                                                if(fen==-1)
                                                fen=0x59;
                                                write_1302(write_fen,fen);
9 V$ P0 C, j) ]& h8 r                                                read_sf();
                                        }
  Q4 _( t! |  ?* q' B: S" _                                        if(FunctionKeyNum == 2)                        //若功能键第二次按下
) ^4 Q# o7 _' S  h5 b                                        {
( W: l: L" q3 Y; b                                                shi--;
                                                shi=shi/10*16+shi%10;                //转为16进制
( f7 R. {1 x+ g, o. \                                                if(shi==-1)
                                                shi=0x23;
& V3 L9 ?) g8 ?  ]5 a                                                write_1302(write_shi,shi);
5 N/ J* B3 w6 z" w' l* ~" D                                                read_sf();
4 K& T( H7 h  v6 D* U                                        }
& J4 D! W8 n( R, _# I                                }
  u* c7 j0 u. T! K3 E                                else if(++KeyTime > 100)                        //按下时间大于1s(100*10ms)
9 C2 v1 ~% u& l& b( k                                {
( i' B) i5 b2 g0 d( ~, a; Q                                        KeyStateTemp3 = StateRepeat;        //状态切换到连发态
4 e, L. ^6 z+ e' E                                        KeyTime = 0;        
# b! g' K/ F9 g1 K( v                                }
& e" X# O4 b8 T4 D' h7 z                                break;
  Z3 V5 J. m" Q% a1 U1 z+ }                        case StateRepeat:                                                //按键连发态               
                                if(KeyPressTemp3)
1 E/ O) G) r# ]" n  D- ^6 ?* D7 X                                        KeyStateTemp3 = StateInit;                //按键释放，则进初始态
                                else                                                                //按键未释放
                                {
4 I7 y. b, o& E7 L2 b# T                                        if(++KeyTime > 10)                                //按键计时值大于100ms（10*10ms）
                                        {
0 M. [7 ~! }8 ^. m- G8 ?$ U$ ~                                                KeyTime = 0;        
                                                if(FunctionKeyNum == 1)                //若功能键第一次按下
                                                {
( W7 u, x/ X- e* ?, f# ]                                                        fen--;
. L5 X/ s1 t7 |4 w* A) h                                                        fen=fen/10*16+fen%10;                //转为16进制
4 O: r% H. y% ~$ o                                                        if(fen==-1)
                                                        fen=0x59;
' b  S) m- G6 }8 h- g* A                                                        write_1302(write_fen,fen);
/ ^" ?4 O8 V% w4 }+ r' p                                                        read_sf();
! p* F# g1 e& l) k# d2 I                                                }
                                                if(FunctionKeyNum == 2)                //若功能键第二次按下
                                                {
                                                        shi--;
& {, Y) ?! n7 O5 k* L& L                                                        shi=shi/10*16+shi%10;                //转为16进制
& M8 U* l* o& Y' }1 e) E# k                                                        if(shi==-1)
- ]) E; V2 z3 ?0 z( J                                                        shi=0x23;
* ?* e; F' u. {6 ~                                                        write_1302(write_shi,shi);
                                                        read_sf();
9 y# l2 a' n/ [# s9 J3 a                                                }
9 O( b; j' D4 ~+ x& i) {& p5 E                                        }
) m# f2 u2 J! ^6 z                                        break;
                                }
7 S1 ]9 \; \& {$ D$ E% L" D                                break;
                        default: KeyStateTemp3 = KeyStateTemp3 = StateInit; break;
  n, E) ]& D/ c4 D5 r                }
% v0 A& y. s& \, J; L) q- ~2 T. R        }
}


void ExecuteKeyNum()
# V* G9 P4 h* t9 b1 @5 m( _. V) `{
% {* Z) }( w& W0 z        if(TF1)
        {
# R& W+ h7 _6 h% y- D$ F4 T                TF1 = 0;
                TH1 = 0xDC;
- V6 M: x% k" h  a& ^( ]& v                TL1 = 0x00;
                KeyScan();
* I6 k: D! [  w( J# e# b        }
# I) n7 h: o7 G  U& A
! I. y' H* @# K( Q7 J- G以上是部分源码，完整的代码在附件里：
$ H% H5 g( k* l5 j$ n) v+ N/ T# k9 {下载：

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

wang5825

谢谢楼主分享

Mhza

看看楼主的代码

Demyar

谢谢分享