硬件实验箱是伟福LAB2000实验箱。

程序代码：

/****************************************************************************/
/*       电子日历，有时间显示、闹铃、日期、秒表及键盘设置功能               */
/* 功能键A:   设置位数字+1      闹钟模式下为闹钟开关  秒表模式下为记时开关  */
/* 功能键B:   设置位数字-1      闹钟模式下为闹钟开关                        */
/* 功能键C:设置模式及设置位选择                       秒表模式下为清零键    */                         
/* 功能键D:在四种工作模式下切换 设置闹钟开关                                */       
/*                    曹宇  03电子  0201029                                 */
/*                       2006.6.3  更新                                     */
/*                      中央民族大学                                     */
***********************************************************************/
#include 
#include 

/***************这里设置程序初始化时显示的时间****************/
#define SET_HOUR 12  /*设置初始化小时*/
#define SET_MINUTE 00  /*设置初始化分钟*/
#define SET_SECOND 00  /*设置初始化秒数*/

/*************************系统地址****************************/
#define BASE_PORT 0x8000 /*选通基地址*/
#define KEY_LINE BASE_PORT+1 /*键盘行线地址*/
#define KEY_COLUMN BASE_PORT+2 /*键盘列线地址*/
#define LED_SEG BASE_PORT+4 /*数码管段选地址*/
#define LED_BIT BASE_PORT+2 /*数码管位选地址*/
#define LED_ON(x) XBYTE[LED_BIT]=(0x01<<1)
#define LED_OFF XBYTE[LED_SEG]=0x00  /*LED显示空*/

/**************在设置模式下对秒分时的宏定义*****************/
#define SECOND 0   /*对应数码管右边两位*/
#define MINUTE 1   /*对应数码管中间两位*/
#define HOUR 2     /*对应数码管左边两位*/

/********************定义四种工作模式***********************/
#define CLOCK clockstr /*时钟模式*/
#define ALART alartstr /*闹钟模式*/
#define DATE datestr   /*日期模式*/
#define TIMER timerstr /*秒表模式*/

/****************以下是所有子函数的声明*********************/
void sys_init(void);                    /*系统的初始化程序*/
void display(void);   /*动态刷新一次数码管子程序*/
void clockplus(void);   /*时间加1S的子程序*/
void update_clockstr(void);  /*更新时间显示编码*/
void update_alartstr(void);             /*更新闹钟时间的显示编码*/
void update_datestr(void);  /*更新日期显示编码*/
void update_timerstr(void);             /*更新秒表时间的显示编码*/
void deley(int);    /*延时子程序*/
void update_dispbuf(unsigned char *);  /*更新显示缓冲区*/
unsigned char getkeycode(void);  /*获取键值子程序*/
void keyprocess(unsigned char);  /*键值处理子程序*/
unsigned char getmonthdays(unsigned int,unsigned char);/*计算某月的天数子程序*/

/*功能键功能子函数*/
void Akey(void);    /*当前设置位+1 开关闹钟 开关秒表*/
void Bkey(void);    /*当前设置位-1 开关闹钟 */
void Ckey(void);    /*设置位选择  秒表清零*/
void Dkey(void);    /*切换四种工作模式*/

/**********************全局变量声明部分*********************/
unsigned char led[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};/*从0～9的LED编码*/
unsigned char ledchar[3]={0x5c,0x54,0x71};/*o n f*/

//unsigned char key[24]={  /* 键值代码数组 对应键位：*/
// 0x70,0x71,0x72,0x73,0x74,0x75, /*  7  8  9  A TRACE RESET*/
// 0x0,0xb1,0xb2,0xb3,0xb4,0xb5, /*  4  5  6  B STEP   MON */
// 0xd0,0xd1,0xd2,0xd3,0xd4,0xd5, /*  1  2  3  C HERE  LAST */
// 0xe0,0xe1,0xe2,0xe3,0xe4,0xe5}; /*  0  F  E  D EXEC  NEXT */
struct{        /*时间结构体变量*/
 unsigned char s;
 unsigned char m;
 unsigned char h;
 }clock={SET_SECOND,SET_MINUTE,SET_HOUR};
struct{                                  /*闹铃时间结构体变量*/
 unsigned char m;
 unsigned char h;
 }alart={SET_MINUTE,SET_HOUR};
struct{                                 /*日期结构体变量*/
        unsigned int year;
        unsigned char month;
        unsigned char day;
        }date={6,1,1};
struct{                                 /*秒表时间结构体变量*/
        unsigned char ms;
        unsigned char s;
        unsigned char m;
        }timer={0,0,0};
unsigned char dispbuf[6]; /*显示缓冲区数组*/
unsigned char clockstr[6]; /*时间显示的数码管编码数组*/
unsigned char alartstr[6]; /*闹钟显示的数码管编码数组*/
unsigned char datestr[6]; /*日期显示的数码管编码数组*/
unsigned char timerstr[6];      /*秒表显示的数码管编码数组*/
unsigned int itime=0,idot; /*定时器0中断计数*/
unsigned char itime1=0;  /*定时器1中断计数*/
sbit P3_1=P3^1;   /*外接蜂鸣器的管脚*/
bdata bit IsSet=0;  /*设置模式标志位　０：正常走时 １：设置模式*/
bdata bit Alart_EN=0;  /*闹铃功能允许位  ０：禁止闹铃 １：允许闹铃*/
bdata bit IsBeep=0;             /*响铃标志位      ０：未响铃   １：正在响铃*/
unsigned char SetSelect=0; /*在设置模式IsSet=1时，正在被设置的位,对应上面的宏*/
unsigned char *CurrentMode; /*标志当前正设置的功能,如CurrentMode=CLOCK或CurrentMode=ALART等*/

void timerplus(void);

/**************************函数部分*************************/
void main(void)
{
        sys_init();
    while(1)
 {
  XBYTE[KEY_COLUMN,0x00];   /*给键盘列线赋全零扫描码，判断是否有键按下   */
  while((XBYTE[KEY_LINE]&0x0f)==0x0f) /*检测是否有键按下，无则一直进行LED的刷新显示*/
                {
                 if(Alart_EN&&(clock.h==alart.h)&&(clock.m==alart.m)) {IsBeep=1;}
                 else
                 { IsBeep=0;
                  P3_1=0;}
                 display();
                }
  keyprocess(getkeycode());  /*有键按下时得到键值，并送入键值处理程序*/
                display();    /*可要可不要*/
 }
}
void sys_init(void)
{
 TMOD=0x22;  /*定时器0和1都设置为工作方式2,基准定时250×2＝500us=0.5ms*/
 TH0=6;          /*定时器0中断服务用来产生1秒时钟定时及闹钟蜂鸣器蜂鸣脉冲*/
 TL0=6;          /*定时器1中断服务留给秒表使用，产生1/100秒定时*/
        TH1=6;
        TL1=6;
        ET0=1;
        ET1=1;
        EA=1;
 TR0=1;
        update_clockstr();  /*初始化时钟显示编码数组*/
        update_alartstr();       /*初始化闹钟显示编码数组*/
        update_datestr();        /*初始化日期显示编码数组*/
        update_timerstr();       /*初始化秒表显示编码数组*/
        update_dispbuf(clockstr);/*初始化显示缓冲数组*/
        CurrentMode=CLOCK;       /*默认的显示摸式为时钟*/
        P3_1=0;                  /*蜂鸣器接线引脚复位*/
}

void timer0(void) interrupt 1 using 1  /*定时器0中断服务器，用来产生1秒定时*/
{
 itime++;
 if(itime==1000)
 {
                if(IsSet)  /*在设置模式下，对正在设置的位闪烁显示*/
  {
                        dispbuf[SetSelect*2]=0;  /*对正在设置的位所对应的显示缓冲区元素赋0，使LED灭*/
          dispbuf[SetSelect*2+1]=0;
                }
                if(IsBeep) P3_1=!P3_1; /*闹钟模式时，产生峰鸣器响脉冲*/
                if(CurrentMode==CLOCK)
                {
                        dispbuf[2]=dispbuf[2]&0x7f;
                        dispbuf[4]=dispbuf[4]&0x7f;
                }
 }
 if(itime==2000)   /*两千次计数为1S  2000×0.5ms=1s*/
 {
   itime=0;   /*定时1s时间到，软计数清零*/
   clockplus();   /*时间结构体变量秒数加1 */
   update_clockstr();  /* 更新时间显示编码数组 */
          if(CurrentMode!=TIMER) update_dispbuf(CurrentMode); /* 用时间编码数组更新显示缓冲区 */
 }
}

void timer1(void) interrupt 3 using 2    /*定时器1中断服务器，用来产生1/100秒定时*/
{
 idot++; if(++itime1==20)       /*20*0.5ms=10ms*/
 {
        itime1=0;
        timerplus();
        update_timerstr();
        if(CurrentMode==TIMER)
        {
         update_dispbuf(timerstr);
         dispbuf[2]=dispbuf[2]&0x7f;    /*关闭小数点的显示*/
         dispbuf[4]=dispbuf[4]&0x7f;
         if(idot<1000)                  /*闪烁显示小数点*/
         {
                dispbuf[2]=dispbuf[2]|0x80;
                dispbuf[4]=dispbuf[4]|0x80;
         }else{
                dispbuf[2]=dispbuf[2]&0x7f;
                dispbuf[4]=dispbuf[4]&0x7f;
               }
        }
        
 }
 if(idot==2000) idot=0;
}

/*功能模块子函数*/
void clockplus(void)  /*时间加1s判断分，时子函数*/
{
 if(++clock.s==60)  /*秒位判断*/
 {
  clock.s=0;
 if(++clock.m==60) /*分位判断*/
 {
  clock.m=0;
  if(++clock.h==24) /*时位判断*/
  {
          clock.h=0;
          if(++date.day==(getmonthdays(date.year,date.month)+1))
          {
           date.day=1;
           if(++date.month==13) date.month=1;
          }
         }
 }
 }
}
void timerplus()        /*秒表1/100秒位加1，判断秒、分子程序*/
{
 if(++timer.ms==100)
 {
        timer.ms=0;
        if(++timer.s==60)
        {
         timer.s=0;
         if(++timer.m==60)
         {
          timer.m=0;
         }       
        }
  }         
}

void update_clockstr(void) /*更新时钟显示代码数组clockstr*/
{
 clockstr[0]=led[clock.s%10];  /*给元素0赋相应数码管显示编码，编码序号是秒数的个位*/
 clockstr[1]=led[(int)(clock.s/10)]; /*给元素1赋相应数码管显示编码，编码序号是秒数的十位*/
 clockstr[2]=led[clock.m%10];  /*以下类推*/
 clockstr[3]=led[(int)(clock.m/10)];
 clockstr[4]=led[clock.h%10];
 clockstr[5]=led[(int)(clock.h/10)];
}

void update_alartstr(void)      /*更新闹钟显示代码数组alartstr*/
{                               /*右边两位显示on：闹钟开启  of:闹钟关闭*/
        if(Alart_EN) alartstr[0]=ledchar[1];/*显示字母n*/
        else alartstr[0]=ledchar[2];        /*显示字母f*/
        alartstr[1]=ledchar[0];             /*显示字母o*/
        alartstr[2]=led[alart.m%10];
        alartstr[3]=led[(int)(alart.m/10)];
        alartstr[4]=led[alart.h%10];
        alartstr[5]=led[(int)(alart.h/10)];
}

void update_datestr(void)       /*更新日期显示代码数组datestr*/
{
        datestr[0]=led[date.day%10];
        datestr[1]=led[(int)(date.day/10)];
        datestr[2]=led[date.month%10];
        datestr[3]=led[(int)(date.month/10)];
        datestr[4]=led[date.year%10];
        datestr[5]=led[(int)(date.year/10)];
}

void update_timerstr(void)      /*更新秒表显示代码数组timerstr*/
{
        timerstr[0]=led[timer.ms%10];
        timerstr[1]=led[(int)(timer.ms/10)];
        timerstr[2]=led[timer.s%10];
        timerstr[3]=led[(int)(timer.s/10)];
        timerstr[4]=led[timer.m%10];
        timerstr[5]=led[(int)(timer.m/10)];
}
void display(void)        /*刷新显示六位LED一次*/
{
 unsigned char i;
 for(i=0;i<6;i++)
 {
  LED_ON(i);   /*选通相应位*/
  XBYTE[LED_SEG]=dispbuf[i]; /*写显示段码*/
                deley(50);   /*延时显示*/
  LED_OFF;   /*写LED全灭段码*/
 }
}
void update_dispbuf(unsigned char *str)    /*更新显示缓冲区子函数,参数为要用来更新缓冲区的源字符数组的首地址*/
{
        dispbuf[0]=str[0]; /*将要更新的源字符数组内容COPY至dispbuf数组，用作显示缓冲区*/
        dispbuf[1]=str[1];
        dispbuf[2]=str[2]|0x80; /*默认把时位和分位后面的小数点显示出来，根据需要再取舍*/
        dispbuf[3]=str[3];
        dispbuf[4]=str[4]|0x80;
        dispbuf[5]=str[5];
}
void deley(int i)  /*延时子函数*/
{
  while(i--);
}
unsigned char getkeycode(void) /*键盘扫描子程序，返回获得的键码*/
{
 unsigned char keycode;  /*键码变量,一开始存行码*/
 unsigned char scancode=0x20; /*列扫描码*/
 unsigned char icolumn=0;  /*键的列号*/
        display();                      /*用刷新数码管显示的时间去抖*/
        XBYTE[KEY_COLUMN]=0x00;
 keycode=XBYTE[KEY_LINE]&0x0f; /*从行端口读入四位行码*/
 while((scancode&0x3f)!=0) /*取scancode的低六位，只没变为全0,则执行循环*/
 {
  XBYTE[KEY_COLUMN]=(~scancode)&0x3f; /*给列赋扫描码，第一次为011111*/
  if((XBYTE[KEY_LINE]&0x0f)==keycode) break; /*检测按键所在的列跳出循环*/
                scancode=scancode>>1; /*列扫描码右移一位*/
  icolumn++;  /*列号加1*/
        }
 keycode=keycode<<4;  /*把行码移到高四位*/
 keycode=keycode|icolumn; /*由行码和列码组成键码*/
 //等待按键放开
 XBYTE[KEY_COLUMN]=0x00;
 while((XBYTE[KEY_LINE]&0x0f)!=0x0f) display();
 return keycode;
}
void keyprocess(unsigned char keycode) /*键值处理函数*/
{
 switch (keycode)
 {
  case 0x73: Akey();
             break;
  case 0xB3: Bkey();
      break;
  case 0xD3: Ckey();
      break;
                case 0xE3: Dkey();
                           break;
  default:   break;
 }
        update_dispbuf(CurrentMode);
}
unsigned char getmonthdays(unsigned int year,unsigned char month)/*得到某月的天数*/
{
 unsigned char days;
 switch (month)
 {
  case 4:
  case 6:
  case 9:
  case 11:days=30;
          break;
  case 2: if(year%4==0) days=29;
   else days=28;
          break;
  default:days=31;
          break;
 }
 return days;
}

/*功能键子函数部分*/
void Akey(void) /*对当前设置位进行加一操作，如果设置秒位，则给秒位清零*/
{
        if(CurrentMode==TIMER)  /*秒表模式下启闭走时*/
        { TR1=!TR1;
          return;
        }
        if(!IsSet) return;     /*如果不是设置模式退出*/
 switch (SetSelect)
 {
  case SECOND:if(CurrentMode==CLOCK)
                            {
                             clock.s=0;  /*如果当前被设置位是秒位，则清零秒位*/
           update_clockstr();
                            }
                            if(CurrentMode==ALART)
                            {
                             Alart_EN=!Alart_EN;
                             update_alartstr();
                            }
                            if(CurrentMode==DATE)
                            {
                             if(++date.day==(getmonthdays(date.year,date.month)+1)) date.day=1;
                             update_datestr();
                            }
                            if(CurrentMode==TIMER)
                            {
                             TR1=!TR1;
                            }
                            break;
  case MINUTE:if(CurrentMode==CLOCK)
                            {
                             if(++clock.m==60) clock.m=0; /*如果当前被设置分位，则分位加1*/
        update_clockstr();
                            }
                            if(CurrentMode==ALART)
                            {
                             if(++alart.m==60) alart.m=0;
                             update_alartstr();
                            }
                            if(CurrentMode==DATE)
                            {
                             if(++date.month==13) date.month=1;
                             update_datestr();
                            }
                            break;
  case HOUR:  if(CurrentMode==CLOCK)
                            {
                             if(++clock.h==24) clock.h=0; /*如果当前被设置时位，则时位加1*/
        update_clockstr();
                            }
                            if(CurrentMode==ALART)
                            {
                             if(++alart.h==24) alart.h=0;
                             update_alartstr();
                            }
                            if(CurrentMode==DATE)
                            {
                             if(++date.year==100) date.year=0;
                             update_datestr();
                            }
                            break;
    default:   break;
 }
        update_dispbuf(CurrentMode);
}
void Bkey(void)  /*对当前设置位进行减一操作，如果设置秒分，则给秒位清零,类比Akey()函数*/
{
        if(!IsSet) return;
 switch (SetSelect)
 {
  case SECOND:if(CurrentMode==CLOCK)
                            {
                             clock.s=0;
        update_clockstr();
                            }
                            if(CurrentMode==ALART)
                            {
                             Alart_EN=!Alart_EN;
                             update_alartstr();
                            }
                            if(CurrentMode==DATE)
                            {
                             if(--date.day==0x00) date.day=getmonthdays(date.year,date.month);
                             update_datestr();
                            }
       break;
  case MINUTE:if(CurrentMode==CLOCK)
                            {
                             if(--clock.m==0xff) clock.m=59;
        update_clockstr();
                            }
                            if(CurrentMode==ALART)
                            {
                             if(--alart.m==0xff) alart.m=59;
                             update_alartstr();
                            }
                        &nbs;   if(CurrentMode==DATE)
                            {
                             if(--date.month==0x00) date.month=12;
                             update_datestr();
                            }
       break;
  case HOUR:  if(CurrentMode==CLOCK)
                            {
                             if(--clock.h==0xff) clock.h=23;
        update_clockstr();
                            }
                            if(CurrentMode==ALART)
                            {
                             if(--alart.h==0xff) alart.h=23;
                             update_alartstr();
                            }
                            if(CurrentMode==DATE)
                            {
                             if(--date.year==0xffff) date.year=99;
                             update_datestr();
                            }
       break;
   default:    break;
 }
        update_dispbuf(CurrentMode);
}
void Ckey(void) /*正常走时模式和设置模式的切换*/
{
  if(CurrentMode==TIMER)
  {
        TR1=0;          /*初始化定时器1设置，停止秒表记时*/
        TH1=6;
        TL1=6;
        timer.ms=0;     /*初始化秒表数组*/
        timer.s=0;
        timer.m=0;
        update_timerstr();
  }else
  {
 if(IsSet==0) /*在非秒表模式下，第一次按下C键进入设置模式,设置时位*/
 {
  IsSet=1; /*置位标志位，进入设置模式 */
  SetSelect=HOUR;
  return;
 }   /*第二次按Ｃ键设置分位，第三次按键设置秒位，第四次按键完成退出设置*/
 if(SetSelect==0) /*按到第四次，即设置完秒位后，将标志位IsSet置0，完成设置*/
 {
  IsSet=0; /*复位标志位，进入正常走时模式*/
  return;
 }
 if(SetSelect>0) SetSelect--;    /*设置位的标志变量SetSelect=0:时位 1：分位 2：秒位*/
 }
}
void Dkey(void) /*工作状态切换：时钟、闹钟、日期、秒表*/
{
        if(CurrentMode==CLOCK)         /*切换至闹钟，同时开关闹钟*/
        { CurrentMode=ALART;
          Alart_EN=!Alart_EN;
          update_alartstr();
          return;
        }
        if(CurrentMode==ALART)         /*切换至日期*/
        { CurrentMode=DATE;
          return;
        }
        if(CurrentMode==DATE)          /*切换至秒表，同时关闭设置模式*/
        {
          CurrentMode=TIMER;
          IsSet=0;
          return;
        }
        if(CurrentMode==TIMER)         /*切换至时钟*/
        {        
          CurrentMode=CLOCK;
          return;
        }
}