EEPW论坛

第三十二节：数码管中的倒计时程序。

开场白：
   上一节讲了一二级菜单的综合程序，这一节要教会大家三个知识点：
第一个：通过本程序，继续加深理解按键与数码管的关联方法。
第二个：复习一下我在第五节教给大家的时间校正法。
第三个：继续加深熟悉鸿哥首次提出的“一二级菜单显示理论”：凡是人机界面显示，不管是数码管还是液晶屏，都可以把显示的内容分成不同的窗口来显示，每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单，用ucWd变量表示。局部就是二级菜单，用ucPart来表示。不同的窗口，会有不同的更新显示变量ucWdXUpdate来对应，表示整屏全部更新显示。不同的局部，也会有不同的更新显示变量ucWdXPartYUpdate来对应，表示局部更新显示。

具体内容，请看源代码讲解。

（1）硬件平台：基于朱兆祺51单片机学习板。启动和暂停键对应S1键，复位键对应S5键。

（2）实现功能：按下启动暂停按键时，倒计时开始工作，再按一次启动暂停按键时，则暂停倒计时。在任何时候，按下复位按键，倒计时将暂停工作，并且恢复倒计时当前默认值99。
     

（3）源代码讲解如下：

#include "REG52.H"


#define const_voice_short  40   //蜂鸣器短叫的持续时间
#define const_voice_long   200    //蜂鸣器长叫的持续时间

#define const_key_time1  20    //按键去抖动延时的时间
#define const_key_time2  20    //按键去抖动延时的时间


#define const_dpy_time_half  200  //数码管闪烁时间的半值
#define const_dpy_time_all   400  //数码管闪烁时间的全值 一定要比const_dpy_time_half 大

/* 注释一：
* 如何知道1秒钟需要多少个定时中断？
* 这个需要编写一段小程序测试，得到测试的结果后再按比例修正。
* 步骤：
* 第一步：在程序代码上先写入1秒钟大概需要200个定时中断。
* 第二步：把程序烧录进单片机后，上电开始测试，手上同步打开手机里的秒表。
*         如果单片机倒计时跑完了99秒，而手机上的秒表才走了45秒。
* 第三步：那么最终得出1秒钟需要的定时中断次数是:const_1s=(200*99)/45=440
*/


#define const_1s  440   //大概一秒钟所需要的定时中断次数

void initial_myself();    
void initial_peripheral();
void delay_short(unsigned int uiDelayShort); 
void delay_long(unsigned int uiDelaylong);

//驱动数码管的74HC595
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);  
void display_drive(); //显示数码管字模的驱动函数
void display_service(); //显示的窗口菜单服务程序

//驱动LED的74HC595
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);

void T0_time();  //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan();//按键扫描函数 放在定时中断里


sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键

sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平

sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
sbit led_dr=P3^5;  //作为中途暂停指示灯 亮的时候表示中途暂停


sbit dig_hc595_sh_dr=P2^0;     //数码管的74HC595程序
sbit dig_hc595_st_dr=P2^1;  
sbit dig_hc595_ds_dr=P2^2;  

sbit hc595_sh_dr=P2^3;    //LED灯的74HC595程序
sbit hc595_st_dr=P2^4;  
sbit hc595_ds_dr=P2^5;  

unsigned char ucKeySec=0;   //被触发的按键编号

unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志

unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志


unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器


unsigned char ucDigShow8;  //第8位数码管要显示的内容
unsigned char ucDigShow7;  //第7位数码管要显示的内容
unsigned char ucDigShow6;  //第6位数码管要显示的内容
unsigned char ucDigShow5;  //第5位数码管要显示的内容
unsigned char ucDigShow4;  //第4位数码管要显示的内容
unsigned char ucDigShow3;  //第3位数码管要显示的内容
unsigned char ucDigShow2;  //第2位数码管要显示的内容
unsigned char ucDigShow1;  //第1位数码管要显示的内容


unsigned char ucDigDot8;  //数码管8的小数点是否显示的标志
unsigned char ucDigDot7;  //数码管7的小数点是否显示的标志
unsigned char ucDigDot6;  //数码管6的小数点是否显示的标志
unsigned char ucDigDot5;  //数码管5的小数点是否显示的标志
unsigned char ucDigDot4;  //数码管4的小数点是否显示的标志
unsigned char ucDigDot3;  //数码管3的小数点是否显示的标志
unsigned char ucDigDot2;  //数码管2的小数点是否显示的标志
unsigned char ucDigDot1;  //数码管1的小数点是否显示的标志

unsigned char ucDigShowTemp=0; //临时中间变量
unsigned char ucDisplayDriveStep=1;  //动态扫描数码管的步骤变量

unsigned char ucWd=1;  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
unsigned char ucWd1Update=1; //窗口1更新显示标志


unsigned char ucCountDown=99;  //倒计时的当前值
unsigned char ucStartFlag=0;  //暂停与启动的标志位
unsigned int  uiTimeCnt=0;  //倒计时的时间计时器

unsigned char ucTemp1=0;  //中间过渡变量
unsigned char ucTemp2=0;  //中间过渡变量
unsigned char ucTemp3=0;  //中间过渡变量
unsigned char ucTemp4=0;  //中间过渡变量
unsigned char ucTemp5=0;  //中间过渡变量
unsigned char ucTemp6=0;  //中间过渡变量
unsigned char ucTemp7=0;  //中间过渡变量
unsigned char ucTemp8=0;  //中间过渡变量


//根据原理图得出的共阴数码管字模表
code unsigned char dig_table[]=
{
0x3f,  //0       序号0
0x06,  //1       序号1
0x5b,  //2       序号2
0x4f,  //3       序号3
0x66,  //4       序号4
0x6d,  //5       序号5
0x7d,  //6       序号6
0x07,  //7       序号7
0x7f,  //8       序号8
0x6f,  //9       序号9
0x00,  //无      序号10
0x40,  //-       序号11
0x73,  //P       序号12
};

void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       key_service(); //按键服务的应用程序
       display_service(); //显示的窗口菜单服务程序
   }

}


/* 注释二：
 *鸿哥首次提出的"一二级菜单显示理论"：
 *凡是人机界面显示，不管是数码管还是液晶屏，都可以把显示的内容分成不同的窗口来显示，
 *每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单，用ucWd变量表示。
 *局部就是二级菜单，用ucPart来表示。不同的窗口，会有不同的更新显示变量ucWdXUpdate来对应，
 *表示整屏全部更新显示。不同的局部，也会有不同的更新显示变量ucWdXPartYUpdate来对应，表示局部更新显示。
 */


void display_service() //显示的窗口菜单服务程序
{



  //由于本程序只有一个窗口，读者在做实际项目的时候，可以省略switch(ucWd)
   switch(ucWd)  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
   {
       case 1:   //显示窗口1的数据
            if(ucWd1Update==1)  //窗口1要全部更新显示
			{
               ucWd1Update=0;  //及时清零标志，避免一直进来扫描

               ucTemp8=10;  //显示空
               ucTemp7=10;  //显示空
               ucTemp6=10;  //显示空
               ucTemp5=10;  //显示空
               ucTemp4=10;  //显示空
               ucTemp3=10;  //显示空

               ucTemp2=ucCountDown/10;  //倒计时的当前值
               ucTemp1=ucCountDown%10;


               ucDigShow8=ucTemp8;  
               ucDigShow7=ucTemp7;  
               ucDigShow6=ucTemp6;  
               ucDigShow5=ucTemp5; 
               ucDigShow4=ucTemp4;  
               ucDigShow3=ucTemp3; 


			   if(ucCountDown<10)
			   {
			      ucDigShow2=10; 
			   }
			   else
			   {
			      ucDigShow2=ucTemp2; 
			   }
			   ucDigShow1=ucTemp1; 

			

            }
            break;
   
     }
   


}


void key_scan()//按键扫描函数 放在定时中断里
{  

  if(key_sr1==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  {
     ucKeyLock1=0; //按键自锁标志清零
     uiKeyTimeCnt1=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
  }
  else if(ucKeyLock1==0)//有按键按下，且是第一次被按下
  {
     uiKeyTimeCnt1++; //累加定时中断次数
     if(uiKeyTimeCnt1>const_key_time1)
     {
        uiKeyTimeCnt1=0; 
        ucKeyLock1=1;  //自锁按键置位,避免一直触发
        ucKeySec=1;    //触发1号键
     }
  }

  if(key_sr2==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  {
     ucKeyLock2=0; //按键自锁标志清零
     uiKeyTimeCnt2=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
  }
  else if(ucKeyLock2==0)//有按键按下，且是第一次被按下
  {
     uiKeyTimeCnt2++; //累加定时中断次数
     if(uiKeyTimeCnt2>const_key_time2)
     {
        uiKeyTimeCnt2=0; 
        ucKeyLock2=1;  //自锁按键置位,避免一直触发
        ucKeySec=2;    //触发2号键
     }
  }

}


void key_service() //按键服务的应用程序
{
  switch(ucKeySec) //按键服务状态切换
  {
    case 1:// 启动和暂停按键 对应朱兆祺学习板的S1键 

	
         //由于本程序只有一个窗口，读者在做实际项目的时候，可以省略switch(ucWd)
          switch(ucWd)  //在不同的窗口下，设置不同的参数
          {
              case 1:
                   if(ucStartFlag==0)  //如果原来处于暂停的状态，则启动
				   {
                      ucStartFlag=1; //启动
				   }
				   else     //如果原来处于启动的状态，则暂停
				   {
				      ucStartFlag=0;  //暂停
				   }
                   break;
           
          }     
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;    
    
    case 2:// 复位按键 对应朱兆祺学习板的S5键 
 
         //由于本程序只有一个窗口，读者在做实际项目的时候，可以省略switch(ucWd)
          switch(ucWd)  //在不同的窗口下，设置不同的参数
          {
              case 1:
				   ucStartFlag=0;  //暂停
                   ucCountDown=99;  //恢复倒计时的默认值99
                   uiTimeCnt=0;  //倒计时的时间计时器清零
				   ucWd1Update=1; //窗口1更新显示标志  只要ucCountDown变化了，就要更新显示一次
                   break;
          
          }  
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;  

  }                
}


void display_drive()  
{
   //以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
   switch(ucDisplayDriveStep)
   {
      case 1:  //显示第1位
           ucDigShowTemp=dig_table[ucDigShow1];
                   if(ucDigDot1==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xfe);
               break;
      case 2:  //显示第2位
           ucDigShowTemp=dig_table[ucDigShow2];
                   if(ucDigDot2==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xfd);
               break;
      case 3:  //显示第3位
           ucDigShowTemp=dig_table[ucDigShow3];
                   if(ucDigDot3==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xfb);
               break;
      case 4:  //显示第4位
           ucDigShowTemp=dig_table[ucDigShow4];
                   if(ucDigDot4==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xf7);
               break;
      case 5:  //显示第5位
           ucDigShowTemp=dig_table[ucDigShow5];
                   if(ucDigDot5==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xef);
               break;
      case 6:  //显示第6位
           ucDigShowTemp=dig_table[ucDigShow6];
                   if(ucDigDot6==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xdf);
               break;
      case 7:  //显示第7位
           ucDigShowTemp=dig_table[ucDigShow7];
                   if(ucDigDot7==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
           }
           dig_hc595_drive(ucDigShowTemp,0xbf);
               break;
      case 8:  //显示第8位
           ucDigShowTemp=dig_table[ucDigShow8];
                   if(ucDigDot8==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0x7f);
               break;
   }

   ucDisplayDriveStep++;
   if(ucDisplayDriveStep>8)  //扫描完8个数码管后，重新从第一个开始扫描
   {
     ucDisplayDriveStep=1;
   }



}


//数码管的74HC595驱动函数
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
{
   unsigned char i;
   unsigned char ucTempData;
   dig_hc595_sh_dr=0;
   dig_hc595_st_dr=0;

   ucTempData=ucDigStatusTemp16_09;  //先送高8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)dig_hc595_ds_dr=1;
         else dig_hc595_ds_dr=0;

         dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         dig_hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   ucTempData=ucDigStatusTemp08_01;  //再先送低8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)dig_hc595_ds_dr=1;
         else dig_hc595_ds_dr=0;

         dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         dig_hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   dig_hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
   delay_short(1); 
   dig_hc595_st_dr=1;
   delay_short(1); 

   dig_hc595_sh_dr=0;    //拉低，抗干扰就增强
   dig_hc595_st_dr=0;
   dig_hc595_ds_dr=0;

}


//LED灯的74HC595驱动函数
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
{
   unsigned char i;
   unsigned char ucTempData;
   hc595_sh_dr=0;
   hc595_st_dr=0;

   ucTempData=ucLedStatusTemp16_09;  //先送高8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)hc595_ds_dr=1;
         else hc595_ds_dr=0;

         hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   ucTempData=ucLedStatusTemp08_01;  //再先送低8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)hc595_ds_dr=1;
         else hc595_ds_dr=0;

         hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
   delay_short(1); 
   hc595_st_dr=1;
   delay_short(1); 

   hc595_sh_dr=0;    //拉低，抗干扰就增强
   hc595_st_dr=0;
   hc595_ds_dr=0;

}


void T0_time() interrupt 1
{
  TF0=0;  //清除中断标志
  TR0=0; //关中断

  key_scan(); //按键扫描函数


  if(ucStartFlag==1)  //启动倒计时的计时器
  {
     uiTimeCnt++;
     if(uiTimeCnt>=const_1s)    //1秒钟的时间到
     {
	    if(ucCountDown!=0) //加这个判断，就是避免在0的情况下减1
	    {
	       ucCountDown--;  //倒计时当前显示值减1
	    }

        if(ucCountDown==0)  //倒计时结束
	    {
	       ucStartFlag=0;  //暂停
           uiVoiceCnt=const_voice_long; //蜂鸣器触发提醒，滴一声就停。
	    }

        ucWd1Update=1; //窗口1更新显示标志
        uiTimeCnt=0;   //计时器清零，准备从新开始计时
     }
  }



  if(uiVoiceCnt!=0)
  {
     uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
     beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
//     beep_dr=1;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
  }
  else
  {
     ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
     beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
//     beep_dr=0;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
  }

  display_drive();  //数码管字模的驱动函数


  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
  TR0=1;  //开中断
}


void delay_short(unsigned int uiDelayShort) 
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


void delay_long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  //内嵌循环的空指令数量
          {
             ; //一个分号相当于执行一条空语句
          }
   }
}


void initial_myself()  //第一区 初始化单片机
{

/* 注释三：
* 矩阵键盘也可以做独立按键，前提是把某一根公共输出线输出低电平，
* 模拟独立按键的触发地，本程序中，把key_gnd_dr输出低电平。
* 朱兆祺51学习板的S1就是本程序中用到的一个独立按键。
*/
  key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平

  led_dr=0;  //关闭独立LED灯
  beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。

  hc595_drive(0x00,0x00);  //关闭所有经过另外两个74HC595驱动的LED灯

  TMOD=0x01;  //设置定时器0为工作方式1

  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;

}

void initial_peripheral() //第二区 初始化外围
{


   ucDigDot8=0;   //小数点全部不显示
   ucDigDot7=0;  
   ucDigDot6=0; 
   ucDigDot5=0;  
   ucDigDot4=0; 
   ucDigDot3=0;  
   ucDigDot2=0;
   ucDigDot1=0; 

   EA=1;     //开总中断
   ET0=1;    //允许定时中断
   TR0=1;    //启动定时中断

}

 

总结陈词：
这节讲了数码管中的倒计时程序。如果要在此程序上多增加两个按键，用来控制数码管倒计时的速度档位，并且需要在数码管中闪烁显示被设置的速度档位，该怎么编写这个程序？欲知详情，请听下回分解-----能设置速度档位的数码管倒计时程序。


（未完待续，下节更精彩，不要走开哦）

这类神贴，我等屌丝必须顶礼膜拜

第三十三节：能设置速度档位的数码管倒计时程序。

开场白：
   上一节讲了数码管中的倒计时程序。这节要在此程序上多增加两个按键，用来控制数码管倒计时的速度档位，并且需要在数码管中闪烁显示被设置的速度档位。这一节要教会大家三个知识点：
第一个：把一个按键的短按与长按复合应用在项目中的程序结构。
第二个：通过本程序，继续加深理解按键与数码管的关联方法。
第三个：继续加深熟悉鸿哥首次提出的“一二级菜单显示理论”：凡是人机界面显示，不管是数码管还是液晶屏，都可以把显示的内容分成不同的窗口来显示，每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单，用ucWd变量表示。局部就是二级菜单，用ucPart来表示。不同的窗口，会有不同的更新显示变量ucWdXUpdate来对应，表示整屏全部更新显示。不同的局部，也会有不同的更新显示变量ucWdXPartYUpdate来对应，表示局部更新显示。

具体内容，请看源代码讲解。

（1）硬件平台：基于朱兆祺51单片机学习板。启动和暂停键对应S1键，复位键对应S5键。加键对应S9键，减键对应S13键。

（2）实现功能：按下启动暂停按键时，倒计时开始工作，再按一次启动暂停按键时，则暂停倒计时。在任何时候，按下复位按键，倒计时将暂停工作，并且恢复倒计时当前默认值99。如果长按复位按键，在数码管会切换到第2个闪烁窗口，用来设置速度档位，修改完速度档位后，再一次按下复位按键，或者直接按启动暂停按键，会切换回窗口1显示倒计时的当前数据。
     

（3）源代码讲解如下：

#include "REG52.H"


#define const_voice_short  40   //蜂鸣器短叫的持续时间
#define const_voice_long   200    //蜂鸣器长叫的持续时间

#define const_key_time1  20    //按键去抖动延时的时间
#define const_key_time2  20    //按键去抖动延时的时间
#define const_key_time3  20    //按键去抖动延时的时间
#define const_key_time4  20    //按键去抖动延时的时间

#define const_key_long_time 200  //长按复位按键的时间


#define const_dpy_time_half  200  //数码管闪烁时间的半值
#define const_dpy_time_all   400  //数码管闪烁时间的全值 一定要比const_dpy_time_half 大


void initial_myself();    
void initial_peripheral();
void delay_short(unsigned int uiDelayShort); 
void delay_long(unsigned int uiDelaylong);

//驱动数码管的74HC595
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);  
void display_drive(); //显示数码管字模的驱动函数

void display_service(); //显示的窗口菜单服务程序

//驱动LED的74HC595
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);

void T0_time();  //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan();//按键扫描函数 放在定时中断里


sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键


sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平

sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
sbit led_dr=P3^5;  //作为中途暂停指示灯 亮的时候表示中途暂停


sbit dig_hc595_sh_dr=P2^0;     //数码管的74HC595程序
sbit dig_hc595_st_dr=P2^1;  
sbit dig_hc595_ds_dr=P2^2;  

sbit hc595_sh_dr=P2^3;    //LED灯的74HC595程序
sbit hc595_st_dr=P2^4;  
sbit hc595_ds_dr=P2^5;  

unsigned char ucKeySec=0;   //被触发的按键编号

unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志

unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志

unsigned int  uiKeyTimeCnt3=0; //按键去抖动延时计数器
unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志

unsigned int  uiKeyTimeCnt4=0; //按键去抖动延时计数器
unsigned char ucKeyLock4=0; //按键触发后自锁的变量标志




unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器


unsigned char ucDigShow8;  //第8位数码管要显示的内容
unsigned char ucDigShow7;  //第7位数码管要显示的内容
unsigned char ucDigShow6;  //第6位数码管要显示的内容
unsigned char ucDigShow5;  //第5位数码管要显示的内容
unsigned char ucDigShow4;  //第4位数码管要显示的内容
unsigned char ucDigShow3;  //第3位数码管要显示的内容
unsigned char ucDigShow2;  //第2位数码管要显示的内容
unsigned char ucDigShow1;  //第1位数码管要显示的内容


unsigned char ucDigDot8;  //数码管8的小数点是否显示的标志
unsigned char ucDigDot7;  //数码管7的小数点是否显示的标志
unsigned char ucDigDot6;  //数码管6的小数点是否显示的标志
unsigned char ucDigDot5;  //数码管5的小数点是否显示的标志
unsigned char ucDigDot4;  //数码管4的小数点是否显示的标志
unsigned char ucDigDot3;  //数码管3的小数点是否显示的标志
unsigned char ucDigDot2;  //数码管2的小数点是否显示的标志
unsigned char ucDigDot1;  //数码管1的小数点是否显示的标志

unsigned char ucDigShowTemp=0; //临时中间变量
unsigned char ucDisplayDriveStep=1;  //动态扫描数码管的步骤变量

unsigned char ucWd=1;  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
unsigned char ucWd1Update=1; //窗口1更新显示标志
unsigned char ucWd2Update=1; //窗口2更新显示标志

unsigned char ucCountDown=99;  //倒计时的当前值
unsigned char ucStartFlag=0;  //暂停与启动的标志位
unsigned int  uiTimeCnt=0;  //倒计时的时间计时器

unsigned int  uiDpyTimeCnt=0;  //数码管的闪烁计时器,放在定时中断里不断累加

unsigned int  uiSetData1=50;  //速度档位
unsigned int  uiSpeedCnt=400;  //影响速度变量，它跟速度档位uiSetData1有关联

unsigned char ucTemp1=0;  //中间过渡变量
unsigned char ucTemp2=0;  //中间过渡变量
unsigned char ucTemp3=0;  //中间过渡变量
unsigned char ucTemp4=0;  //中间过渡变量
unsigned char ucTemp5=0;  //中间过渡变量
unsigned char ucTemp6=0;  //中间过渡变量
unsigned char ucTemp7=0;  //中间过渡变量
unsigned char ucTemp8=0;  //中间过渡变量


//根据原理图得出的共阴数码管字模表
code unsigned char dig_table[]=
{
0x3f,  //0       序号0
0x06,  //1       序号1
0x5b,  //2       序号2
0x4f,  //3       序号3
0x66,  //4       序号4
0x6d,  //5       序号5
0x7d,  //6       序号6
0x07,  //7       序号7
0x7f,  //8       序号8
0x6f,  //9       序号9
0x00,  //无      序号10
0x40,  //-       序号11
0x73,  //P       序号12
};

void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       key_service(); //按键服务的应用程序
       display_service(); //显示的窗口菜单服务程序
   }

}



/* 注释一：
 *鸿哥首次提出的"一二级菜单显示理论"：
 *凡是人机界面显示，不管是数码管还是液晶屏，都可以把显示的内容分成不同的窗口来显示，
 *每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单，用ucWd变量表示。
 *局部就是二级菜单，用ucPart来表示。不同的窗口，会有不同的更新显示变量ucWdXUpdate来对应，
 *表示整屏全部更新显示。不同的局部，也会有不同的更新显示变量ucWdXPartYUpdate来对应，表示局部更新显示。
 */


void display_service() //显示的窗口菜单服务程序
{


   switch(ucWd)  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
   {
       case 1:   //显示窗口1的数据
            if(ucWd1Update==1)  //窗口1要全部更新显示
			{
               ucWd1Update=0;  //及时清零标志，避免一直进来扫描

               ucTemp8=10;  //显示空
               ucTemp7=10;  //显示空
               ucTemp6=10;  //显示空
               ucTemp5=10;  //显示空
               ucTemp4=10;  //显示空
               ucTemp3=10;  //显示空

               ucTemp2=ucCountDown/10;  //倒计时的当前值
               ucTemp1=ucCountDown%10;


               ucDigShow8=ucTemp8;  
               ucDigShow7=ucTemp7;  
               ucDigShow6=ucTemp6;  
               ucDigShow5=ucTemp5; 
               ucDigShow4=ucTemp4;  
               ucDigShow3=ucTemp3; 


			   if(ucCountDown<10)
			   {
			      ucDigShow2=10; 
			   }
			   else
			   {
			      ucDigShow2=ucTemp2; 
			   }
			   ucDigShow1=ucTemp1; 

			

            }
            break;
       case 2:   //显示窗口2的数据
            if(ucWd2Update==1)  //窗口2要全部更新显示
            {
               ucWd2Update=0;  //及时清零标志，避免一直进来扫描

               ucTemp8=10;  //显示空
               ucTemp7=10;  //显示空
               ucTemp6=10;  //显示空
               ucTemp5=10;  //显示空
               ucTemp4=10;  //显示空
               ucTemp3=10;  //显示空

               ucTemp2=uiSetData1/10;  //倒计时的速度档位
               ucTemp1=uiSetData1%10;


               ucDigShow8=ucTemp8;  
               ucDigShow7=ucTemp7;  
               ucDigShow6=ucTemp6;  
               ucDigShow5=ucTemp5; 
               ucDigShow4=ucTemp4;  
               ucDigShow3=ucTemp3; 


			   if(uiSetData1<10)
			   {
			      ucDigShow2=10; 
			   }
			   else
			   {
			      ucDigShow2=ucTemp2; 
			   }
			   ucDigShow1=ucTemp1; 

                        

            }

            //数码管闪烁
            if(uiDpyTimeCnt==const_dpy_time_half)
            {
               if(uiSetData1<10)        //数码管显示内容
               {
                    ucDigShow2=10; 
               }
               else
               {
                    ucDigShow2=ucTemp2; 
               }
               ucDigShow1=ucTemp1; 
            }
            else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
            {			
               uiDpyTimeCnt=0;   //及时把闪烁记时器清零			   

               ucDigShow2=10;   //数码管显示空，什么都不显示
               ucDigShow1=10; 

            }

            break;

   
     }
   


}


void key_scan()//按键扫描函数 放在定时中断里
{  

  if(key_sr1==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  {
     ucKeyLock1=0; //按键自锁标志清零
     uiKeyTimeCnt1=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
  }
  else if(ucKeyLock1==0)//有按键按下，且是第一次被按下
  {
     uiKeyTimeCnt1++; //累加定时中断次数
     if(uiKeyTimeCnt1>const_key_time1)
     {
        uiKeyTimeCnt1=0; 
        ucKeyLock1=1;  //自锁按键置位,避免一直触发
        ucKeySec=1;    //触发1号键
     }
  }

/* 注释二：
 * 请注意以下长按复位按键与短按复位按键的写法。在本程序中，每次长按复位按键必然
 * 触发一次短按复位按键。
 */

  if(key_sr2==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  {
     ucKeyLock2=0; //按键自锁标志清零
     uiKeyTimeCnt2=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
  }
  else if(ucKeyLock2==0)//有按键按下，且是第一次被按下
  {
     uiKeyTimeCnt2++; //累加定时中断次数
     if(uiKeyTimeCnt2>const_key_time2)
     {
        uiKeyTimeCnt2=0; 
        ucKeyLock2=1;  //自锁按键置位,避免一直触发
        ucKeySec=2;    //触发2号键
     }
  }
  else if(uiKeyTimeCnt2<const_key_long_time)   //长按复位按键
  {
      uiKeyTimeCnt2++;
	  if(uiKeyTimeCnt2==const_key_long_time)
	  {
	     ucKeySec=17;    //触发17号长按复位键
	  }
  }

 if(key_sr3==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  {
     ucKeyLock3=0; //按键自锁标志清零
     uiKeyTimeCnt3=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
  }
  else if(ucKeyLock3==0)//有按键按下，且是第一次被按下
  {
     uiKeyTimeCnt3++; //累加定时中断次数
     if(uiKeyTimeCnt3>const_key_time3)
     {
        uiKeyTimeCnt3=0; 
        ucKeyLock3=1;  //自锁按键置位,避免一直触发
        ucKeySec=3;    //触发3号键
     }
  }

  if(key_sr4==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  {
     ucKeyLock4=0; //按键自锁标志清零
     uiKeyTimeCnt4=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
  }
  else if(ucKeyLock4==0)//有按键按下，且是第一次被按下
  {
     uiKeyTimeCnt4++; //累加定时中断次数
     if(uiKeyTimeCnt4>const_key_time4)
     {
        uiKeyTimeCnt4=0; 
        ucKeyLock4=1;  //自锁按键置位,避免一直触发
        ucKeySec=4;    //触发4号键
     }
  }




}


void key_service() //按键服务的应用程序
{
  switch(ucKeySec) //按键服务状态切换
  {
    case 1:// 启动和暂停按键 对应朱兆祺学习板的S1键 

          switch(ucWd)  //在不同的窗口下，设置不同的参数
          {
              case 1:
                   if(ucStartFlag==0)  //如果原来处于暂停的状态，则启动
				   {
                      ucStartFlag=1; //启动
				   }
				   else     //如果原来处于启动的状态，则暂停
				   {
				      ucStartFlag=0;  //暂停
				   }
                   break;


           
          }    

          ucWd=1;  //不管在哪个窗口，强行切换回窗口1
		  ucWd1Update=1; //窗口1更新显示标志

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;    
    
    case 2:// 复位按键 对应朱兆祺学习板的S5键 
 
          switch(ucWd)  //在不同的窗口下，设置不同的参数
          {
              case 1:    //在窗口1中
				   ucStartFlag=0;  //暂停
                   ucCountDown=99;  //恢复倒计时的默认值99
                   uiTimeCnt=0;  //倒计时的时间计时器清零
				   ucWd1Update=1; //窗口1更新显示标志  只要ucCountDown变化了，就要更新显示一次
                   break;
              case 2:    //在窗口2中
                   ucWd=1;  //切换回窗口1
				   ucWd1Update=1; //窗口1更新显示标志
                   break;
          }  
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;  

    case 3:// 加按键 对应朱兆祺学习板的S9键 


          switch(ucWd)  //在不同的窗口下，设置不同的参数
          {
              case 2:   //在窗口2中
                   uiSetData1++;       //速度档位累加，档位越大，速度越快.
				   if(uiSetData1>99)
				   {
				      uiSetData1=99;
				   }
                   uiSpeedCnt=440-(uiSetData1*2);  //速度档位越大，累计中断数uiSpeedCnt越小，从而倒计时的时间越快

				   ucWd2Update=1; //窗口2更新显示
                   break;
          }     
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;    
    
    case 4:// 减按键 对应朱兆祺学习板的S13键 
          switch(ucWd)  //在不同的窗口下，设置不同的参数
          {
              case 2:   //在窗口2中
			       if(uiSetData1>0)  //加此条件判断，避免0减1
				   {
                      uiSetData1--;       //速度档位累减，档位越小，速度越慢.
				   }

                   uiSpeedCnt=440-(uiSetData1*2);  //速度档位越小，累计中断数uiSpeedCnt越大，从而倒计时的时间越慢

				   ucWd2Update=1; //窗口2更新显示
                   break;
          } 
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break; 

    case 17:// 长按复位按键 对应朱兆祺学习板的S5键 
 
          switch(ucWd)  //在不同的窗口下，设置不同的参数
          {
              case 1:  //窗口1下
                   ucWd=2;  //切换到闪烁窗口2  进行设置速度档位显示
				   ucWd2Update=1; //窗口2更新显示标志
                   break;
          
          }  
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break; 

  }                
}


void display_drive()  
{
   //以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
   switch(ucDisplayDriveStep)
   {
      case 1:  //显示第1位
           ucDigShowTemp=dig_table[ucDigShow1];
                   if(ucDigDot1==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xfe);
               break;
      case 2:  //显示第2位
           ucDigShowTemp=dig_table[ucDigShow2];
                   if(ucDigDot2==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xfd);
               break;
      case 3:  //显示第3位
           ucDigShowTemp=dig_table[ucDigShow3];
                   if(ucDigDot3==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xfb);
               break;
      case 4:  //显示第4位
           ucDigShowTemp=dig_table[ucDigShow4];
                   if(ucDigDot4==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xf7);
               break;
      case 5:  //显示第5位
           ucDigShowTemp=dig_table[ucDigShow5];
                   if(ucDigDot5==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xef);
               break;
      case 6:  //显示第6位
           ucDigShowTemp=dig_table[ucDigShow6];
                   if(ucDigDot6==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xdf);
               break;
      case 7:  //显示第7位
           ucDigShowTemp=dig_table[ucDigShow7];
                   if(ucDigDot7==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
           }
           dig_hc595_drive(ucDigShowTemp,0xbf);
               break;
      case 8:  //显示第8位
           ucDigShowTemp=dig_table[ucDigShow8];
                   if(ucDigDot8==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0x7f);
               break;
   }

   ucDisplayDriveStep++;
   if(ucDisplayDriveStep>8)  //扫描完8个数码管后，重新从第一个开始扫描
   {
     ucDisplayDriveStep=1;
   }



}


//数码管的74HC595驱动函数
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
{
   unsigned char i;
   unsigned char ucTempData;
   dig_hc595_sh_dr=0;
   dig_hc595_st_dr=0;

   ucTempData=ucDigStatusTemp16_09;  //先送高8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)dig_hc595_ds_dr=1;
         else dig_hc595_ds_dr=0;

         dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         dig_hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   ucTempData=ucDigStatusTemp08_01;  //再先送低8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)dig_hc595_ds_dr=1;
         else dig_hc595_ds_dr=0;

         dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         dig_hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   dig_hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
   delay_short(1); 
   dig_hc595_st_dr=1;
   delay_short(1); 

   dig_hc595_sh_dr=0;    //拉低，抗干扰就增强
   dig_hc595_st_dr=0;
   dig_hc595_ds_dr=0;

}


//LED灯的74HC595驱动函数
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
{
   unsigned char i;
   unsigned char ucTempData;
   hc595_sh_dr=0;
   hc595_st_dr=0;

   ucTempData=ucLedStatusTemp16_09;  //先送高8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)hc595_ds_dr=1;
         else hc595_ds_dr=0;

         hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   ucTempData=ucLedStatusTemp08_01;  //再先送低8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)hc595_ds_dr=1;
         else hc595_ds_dr=0;

         hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
   delay_short(1); 
   hc595_st_dr=1;
   delay_short(1); 

   hc595_sh_dr=0;    //拉低，抗干扰就增强
   hc595_st_dr=0;
   hc595_ds_dr=0;

}


void T0_time() interrupt 1
{
  TF0=0;  //清除中断标志
  TR0=0; //关中断

  key_scan(); //按键扫描函数


  if(ucStartFlag==1)  //启动倒计时的计时器
  {
     uiTimeCnt++;
     if(uiTimeCnt>=uiSpeedCnt)    //时间到
     {
	    if(ucCountDown!=0) //加这个判断，就是避免在0的情况下减1
	    {
	       ucCountDown--;  //倒计时当前显示值减1
	    }

        if(ucCountDown==0)  //倒计时结束
	    {
	       ucStartFlag=0;  //暂停
           uiVoiceCnt=const_voice_long; //蜂鸣器触发提醒，滴一声就停。
	    }

        ucWd1Update=1; //窗口1更新显示标志
        uiTimeCnt=0;   //计时器清零，准备从新开始计时
     }
  }


  uiDpyTimeCnt++;  //数码管的闪烁计时器


  if(uiVoiceCnt!=0)
  {
     uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
     beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
//     beep_dr=1;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
  }
  else
  {
     ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
     beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
//     beep_dr=0;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
  }

  display_drive();  //数码管字模的驱动函数


  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
  TR0=1;  //开中断
}


void delay_short(unsigned int uiDelayShort) 
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


void delay_long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  //内嵌循环的空指令数量
          {
             ; //一个分号相当于执行一条空语句
          }
   }
}


void initial_myself()  //第一区 初始化单片机
{

/* 注释三：
* 矩阵键盘也可以做独立按键，前提是把某一根公共输出线输出低电平，
* 模拟独立按键的触发地，本程序中，把key_gnd_dr输出低电平。
* 朱兆祺51学习板的S1就是本程序中用到的一个独立按键。
*/
  key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平

  led_dr=0;  //关闭独立LED灯
  beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。

  hc595_drive(0x00,0x00);  //关闭所有经过另外两个74HC595驱动的LED灯

  TMOD=0x01;  //设置定时器0为工作方式1

  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;

}

void initial_peripheral() //第二区 初始化外围
{


   ucDigDot8=0;   //小数点全部不显示
   ucDigDot7=0;  
   ucDigDot6=0; 
   ucDigDot5=0;  
   ucDigDot4=0; 
   ucDigDot3=0;  
   ucDigDot2=0;
   ucDigDot1=0; 

   uiSpeedCnt=440-(uiSetData1*2);  //速度档位越大，累计中断数uiSpeedCnt越小，从而倒计时的时间越快

   EA=1;     //开总中断
   ET0=1;    //允许定时中断
   TR0=1;    //启动定时中断

}

 

总结陈词：
这节讲了能设置速度档位的数码管倒计时程序。现在很多人用iphone4S的手机，这个手机每次开机显示的时候，都要通过4个密码开锁，如果我们要用4位数码管来实现这个密码锁功能，该怎么编写这个程序？欲知详情，请听下回分解-----在数码管中实现iphone4S开机密码锁的程序。

（未完待续，下节更精彩，不要走开哦）

第三十四节：在数码管中实现iphone4S开机密码锁的程序。

开场白：
    这一节要教会大家四个知识点：
第一个：类似手机上10秒钟内无按键操作将自动进入锁屏的程序。
第二个：如何用一个数组来接收按键的一串数字输入。
第三个：矩阵键盘中，数字按键的输入，由于这部分按键的代码相似度非常高，因此把它封装在一个函数里可以非常简洁方便。
第四个：继续加深熟悉鸿哥首次提出的“一二级菜单显示理论”：凡是人机界面显示，不管是数码管还是液晶屏，都可以把显示的内容分成不同的窗口来显示，每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单，用ucWd变量表示。局部就是二级菜单，用ucPart来表示。不同的窗口，会有不同的更新显示变量ucWdXUpdate来对应，表示整屏全部更新显示。不同的局部，也会有不同的更新显示变量ucWdXPartYUpdate来对应，表示局部更新显示。

具体内容，请看源代码讲解。

（1）硬件平台：基于朱兆祺51单片机学习板。数字1键对应S1键，数字2键对应S2键，数字3键对应S3键…. 数字9键对应S9键, 数字0键对应S10键。其他的按键不用。

（2）实现功能：
本程序有3个窗口。
开机显示第1个密码登录框窗口“----”，在这个窗口下输入密码，如果密码等于”9922”表示密码正确，将会切换到第2个显示按键值的窗口。在窗口2下，按不同的按键会显示不同的按键值，如果10秒内没有按键操作，将会自动切换到第1个密码登录窗口，类似手机上的自动锁屏操作。在密码登录窗口1下，如果密码不正确，会自动清除密码的数字，继续在窗口1下显示”----”。  
窗口3是用来停留0.5秒显示全部密码的信息，然后根据密码的正确与否自动切换到对应的窗口。

（3）源代码讲解如下：

#include "REG52.H"


#define const_no_key_push 4400   //大概10秒内无按键按下的时间
#define const_0_1s  220            //大概0.5秒的时间

#define const_voice_short  40   //蜂鸣器短叫的持续时间
#define const_key_time  20    //按键去抖动延时的时间


void initial_myself();    
void initial_peripheral();
void delay_short(unsigned int uiDelayShort); 
void delay_long(unsigned int uiDelaylong);
//驱动数码管的74HC595
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);  
void display_drive(); //显示数码管字模的驱动函数
void display_service(); //显示的窗口菜单服务程序
//驱动LED的74HC595
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
void T0_time();  //定时中断函数

void number_key_input(unsigned char ucWhichKey);  //由于数字按键的代码相似度高，因此封装在这个函数里
void key_service(); //按键服务的应用程序
void key_scan();//按键扫描函数 放在定时中断里

sbit key_sr1=P0^0; //第一行输入
sbit key_sr2=P0^1; //第二行输入
sbit key_sr3=P0^2; //第三行输入
sbit key_sr4=P0^3; //第四行输入

sbit key_dr1=P0^4; //第一列输出
sbit key_dr2=P0^5; //第二列输出
sbit key_dr3=P0^6; //第三列输出
sbit key_dr4=P0^7; //第四列输出


sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
sbit led_dr=P3^5;  //作为中途暂停指示灯 亮的时候表示中途暂停

sbit dig_hc595_sh_dr=P2^0;     //数码管的74HC595程序
sbit dig_hc595_st_dr=P2^1;  
sbit dig_hc595_ds_dr=P2^2;  
sbit hc595_sh_dr=P2^3;    //LED灯的74HC595程序
sbit hc595_st_dr=P2^4;  
sbit hc595_ds_dr=P2^5;  

unsigned char ucKeyStep=1;  //按键扫描步骤变量

unsigned int  uiKeyTimeCnt=0; //按键去抖动延时计数器
unsigned char ucKeyLock=0; //按键触发后自锁的变量标志

unsigned char ucRowRecord=1; //记录当前扫描到第几列了


unsigned char ucKeySec=0;   //被触发的按键编号
unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

unsigned char ucDigShow8;  //第8位数码管要显示的内容
unsigned char ucDigShow7;  //第7位数码管要显示的内容
unsigned char ucDigShow6;  //第6位数码管要显示的内容
unsigned char ucDigShow5;  //第5位数码管要显示的内容
unsigned char ucDigShow4;  //第4位数码管要显示的内容
unsigned char ucDigShow3;  //第3位数码管要显示的内容
unsigned char ucDigShow2;  //第2位数码管要显示的内容
unsigned char ucDigShow1;  //第1位数码管要显示的内容

unsigned char ucDigDot8;  //数码管8的小数点是否显示的标志
unsigned char ucDigDot7;  //数码管7的小数点是否显示的标志
unsigned char ucDigDot6;  //数码管6的小数点是否显示的标志
unsigned char ucDigDot5;  //数码管5的小数点是否显示的标志
unsigned char ucDigDot4;  //数码管4的小数点是否显示的标志
unsigned char ucDigDot3;  //数码管3的小数点是否显示的标志
unsigned char ucDigDot2;  //数码管2的小数点是否显示的标志
unsigned char ucDigDot1;  //数码管1的小数点是否显示的标志
unsigned char ucDigShowTemp=0; //临时中间变量
unsigned char ucDisplayDriveStep=1;  //动态扫描数码管的步骤变量

unsigned char ucWd1Update=1; //窗口1更新显示标志
unsigned char ucWd2Update=0; //窗口2更新显示标志
unsigned char ucWd3Update=0; //窗口3更新显示标志
unsigned char ucWd=1;  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。


unsigned char ucInputPassword[4];  //在第1个窗口下，显示输入的4个密码
unsigned char ucPasswordCnt=0; //记录当前已经输入到哪一位密码了
unsigned char ucKeyNumber=1;  //在第2个窗口下，显示当前被按下的按键

unsigned int  uiNoKeyPushTimer=const_no_key_push;  //10秒内无按键按下的计时器
unsigned int  uiPasswordTimer=const_0_1s;  //显示0.5秒钟全部密码的计时器，让窗口3停留显示0.5秒钟之后自动消失

unsigned char ucTemp1=0;  //中间过渡变量
unsigned char ucTemp2=0;  //中间过渡变量
unsigned char ucTemp3=0;  //中间过渡变量
unsigned char ucTemp4=0;  //中间过渡变量

//根据原理图得出的共阴数码管字模表
code unsigned char dig_table[]=
{
0x3f,  //0       序号0
0x06,  //1       序号1
0x5b,  //2       序号2
0x4f,  //3       序号3
0x66,  //4       序号4
0x6d,  //5       序号5
0x7d,  //6       序号6
0x07,  //7       序号7
0x7f,  //8       序号8
0x6f,  //9       序号9
0x00,  //无      序号10
0x40,  //-       序号11
0x73,  //P       序号12
};
void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
     key_service(); //按键服务的应用程序
         display_service(); //显示的窗口菜单服务程序
   }
}
/* 注释一：
*鸿哥首次提出的"一二级菜单显示理论"：
*凡是人机界面显示，不管是数码管还是液晶屏，都可以把显示的内容分成不同的窗口来显示，
*每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单，用ucWd变量表示。
*局部就是二级菜单，用ucPart来表示。不同的窗口，会有不同的更新显示变量ucWdXUpdate来对应，
*表示整屏全部更新显示。不同的局部，也会有不同的更新显示变量ucWdXPartYUpdate来对应，表示局部更新显示。
*/

void display_service() //显示的窗口菜单服务程序
{

   switch(ucWd)  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
   {
       case 1:   //显示输入密码的登录框
            if(ucWd1Update==1)  //窗口1要全部更新显示
            {
               ucWd1Update=0;  //及时清零标志，避免一直进来扫描

               ucDigShow8=10;  //第8位数码管显示无
               ucDigShow7=10;  //第7位数码管显示无
               ucDigShow6=10;  //第6位数码管显示无
               ucDigShow5=10;  //第5位数码管显示无

               ucDigShow4=ucInputPassword[0];  //第4位数码管显示输入的密码
               ucDigShow3=ucInputPassword[1];  //第3位数码管显示输入的密码
               ucDigShow2=ucInputPassword[2];  //第2位数码管显示输入的密码
               ucDigShow1=ucInputPassword[3];  //第1位数码管显示输入的密码

            }
            break;
        case 2:  //显示被按下的键值
            if(ucWd2Update==1)  //窗口2要全部更新显示
            {
               ucWd2Update=0;  //及时清零标志，避免一直进来扫描

               ucDigShow8=10;  //第8位数码管显示无
               ucDigShow7=10;  //第7位数码管显示无
               ucDigShow6=10;  //第6位数码管显示无
               ucDigShow5=10;  //第5位数码管显示无

               ucDigShow4=10;  //第4位数码管显示无
               ucDigShow3=10;  //第3位数码管显示无
               ucDigShow2=10;  //第2位数码管显示无
               ucDigShow1=ucKeyNumber; //第1位数码管显示被按下的键值
            }
            break;
       case 3:   //当输入完4个密码后，显示1秒钟的密码登录框，
            if(ucWd3Update==1)  //窗口3要全部更新显示
            {
               ucWd3Update=0;  //及时清零标志，避免一直进来扫描

               ucDigShow8=10;  //第8位数码管显示无
               ucDigShow7=10;  //第7位数码管显示无
               ucDigShow6=10;  //第6位数码管显示无
               ucDigShow5=10;  //第5位数码管显示无

               ucDigShow4=ucInputPassword[0];  //第4位数码管显示输入的密码
               ucDigShow3=ucInputPassword[1];  //第3位数码管显示输入的密码
               ucDigShow2=ucInputPassword[2];  //第2位数码管显示输入的密码
               ucDigShow1=ucInputPassword[3];  //第1位数码管显示输入的密码

            }
            break;     
    }
   

}
void key_scan()//按键扫描函数 放在定时中断里
{  


  switch(ucKeyStep)
  {
     case 1:   //按键扫描输出第ucRowRecord列低电平
              if(ucRowRecord==1)  //第一列输出低电平
                  {
             key_dr1=0;      
             key_dr2=1;
             key_dr3=1;    
             key_dr4=1;
                  }
              else if(ucRowRecord==2)  //第二列输出低电平
                  {
             key_dr1=1;      
             key_dr2=0;
             key_dr3=1;    
             key_dr4=1;
                  }
              else if(ucRowRecord==3)  //第三列输出低电平
                  {
             key_dr1=1;      
             key_dr2=1;
             key_dr3=0;    
             key_dr4=1;
                  }
              else   //第四列输出低电平
                  {
             key_dr1=1;      
             key_dr2=1;
             key_dr3=1;    
             key_dr4=0;
                  }

          uiKeyTimeCnt=0;  //延时计数器清零
          ucKeyStep++;     //切换到下一个运行步骤
              break;

     case 2:     //此处的小延时用来等待刚才列输出信号稳定，再判断输入信号。不是去抖动延时。
          uiKeyTimeCnt++;
                  if(uiKeyTimeCnt>1)
                  {
                     uiKeyTimeCnt=0;
             ucKeyStep++;     //切换到下一个运行步骤
                  }
              break;

     case 3:
          if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
          {  
             ucKeyStep=1;  //如果没有按键按下，返回到第一个运行步骤重新开始扫描
             ucKeyLock=0;  //按键自锁标志清零
             uiKeyTimeCnt=0; //按键去抖动延时计数器清零，此行非常巧妙     
   
                         ucRowRecord++;  //输出下一列
                         if(ucRowRecord>4)  
                         {
                            ucRowRecord=1; //依次输出完四列之后，继续从第一列开始输出低电平
                         }

          }
                  else if(ucKeyLock==0)  //有按键按下，且是第一次触发
                  {
                     if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零

                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=1;  //触发1号键 对应朱兆祺学习板的S1键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=2;  //触发2号键 对应朱兆祺学习板的S2键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=3;  //触发3号键 对应朱兆祺学习板的S3键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=4;  //触发4号键 对应朱兆祺学习板的S4键
                           }

                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=5;  //触发5号键 对应朱兆祺学习板的S5键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=6;  //触发6号键 对应朱兆祺学习板的S6键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=7;  //触发7号键 对应朱兆祺学习板的S7键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=8;  //触发8号键 对应朱兆祺学习板的S8键
                           }
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=9;  //触发9号键 对应朱兆祺学习板的S9键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=10;  //触发10号键 对应朱兆祺学习板的S10键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=11;  //触发11号键 对应朱兆祺学习板的S11键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=12;  //触发12号键 对应朱兆祺学习板的S12键
                           }
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=13;  //触发13号键 对应朱兆祺学习板的S13键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=14;  //触发14号键 对应朱兆祺学习板的S14键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=15;  //触发15号键 对应朱兆祺学习板的S15键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=16;  //触发16号键 对应朱兆祺学习板的S16键
                           }
                                }
                         
                         }
                  
                  }
              break;

  }


}


void key_service() //第三区 按键服务的应用程序
{
  switch(ucKeySec) //按键服务状态切换
  {
    case 1:// 1号键 对应朱兆祺学习板的S1键
          number_key_input(1);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;        
    case 2:// 2号键 对应朱兆祺学习板的S2键
          number_key_input(2);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;     
    case 3:// 3号键 对应朱兆祺学习板的S3键
          number_key_input(3);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;          
    case 4:// 4号键 对应朱兆祺学习板的S4键
          number_key_input(4);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 5:// 5号键 对应朱兆祺学习板的S5键
          number_key_input(5);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 6:// 6号键 对应朱兆祺学习板的S6键
          number_key_input(6);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 7:// 7号键 对应朱兆祺学习板的S7键
          number_key_input(7);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 8:// 8号键 对应朱兆祺学习板的S8键
          number_key_input(8);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 9:// 9号键 对应朱兆祺学习板的S9键
          number_key_input(9);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 10:// 把这个按键专门用来输入数字0    对应朱兆祺学习板的S10键
          number_key_input(0);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 11:// 11号键 对应朱兆祺学习板的S11键

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 12:// 12号键 对应朱兆祺学习板的S12键

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 13:// 13号键 对应朱兆祺学习板的S13键

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 14:// 14号键 对应朱兆祺学习板的S14键

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 15:// 15号键 对应朱兆祺学习板的S15键

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 16:// 16号键 对应朱兆祺学习板的S16键

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
  }                
}

void number_key_input(unsigned char ucWhichKey)  //由于数字按键的代码相似度高，因此封装在这个函数里
{


    switch(ucWd)
   	{
	   case 1:   //在显示密码登录框的窗口下
            ucInputPassword[ucPasswordCnt]=ucWhichKey;   //输入的密码值显示
            ucPasswordCnt++;
			if(ucPasswordCnt>=4)
			{
			    ucPasswordCnt=0;
				ucWd=3;//切换到第3个的窗口,停留显示1秒钟全部密码
			    ucWd3Update=1;  //更新显示窗口3
                uiPasswordTimer=const_0_1s;  //显示0.5秒钟全部密码的计时器，让窗口3停留显示0.5秒钟之后自动消失
			}

			ucWd1Update=1; //更新显示窗口1

			uiNoKeyPushTimer=const_no_key_push;  //10秒内无按键按下的计时器赋新值
			break;
	   case 2:   //在显示按键值的窗口下
	        ucKeyNumber=ucWhichKey; //输入的按键数值显示
		    ucWd2Update=1;  //更新显示窗口2

			uiNoKeyPushTimer=const_no_key_push;  //10秒内无按键按下的计时器赋新值
		    break;
    }

}


void display_drive()  
{
   //以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
   switch(ucDisplayDriveStep)
   { 
      case 1:  //显示第1位
           ucDigShowTemp=dig_table[ucDigShow1];
                   if(ucDigDot1==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xfe);
               break;
      case 2:  //显示第2位
           ucDigShowTemp=dig_table[ucDigShow2];
                   if(ucDigDot2==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xfd);
               break;
      case 3:  //显示第3位
           ucDigShowTemp=dig_table[ucDigShow3];
                   if(ucDigDot3==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xfb);
               break;
      case 4:  //显示第4位
           ucDigShowTemp=dig_table[ucDigShow4];
                   if(ucDigDot4==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xf7);
               break;
      case 5:  //显示第5位
           ucDigShowTemp=dig_table[ucDigShow5];
                   if(ucDigDot5==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xef);
               break;
      case 6:  //显示第6位
           ucDigShowTemp=dig_table[ucDigShow6];
                   if(ucDigDot6==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xdf);
               break;
      case 7:  //显示第7位
           ucDigShowTemp=dig_table[ucDigShow7];
                   if(ucDigDot7==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
           }
           dig_hc595_drive(ucDigShowTemp,0xbf);
               break;
      case 8:  //显示第8位
           ucDigShowTemp=dig_table[ucDigShow8];
                   if(ucDigDot8==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0x7f);
               break;
   }
   ucDisplayDriveStep++;
   if(ucDisplayDriveStep>8)  //扫描完8个数码管后，重新从第一个开始扫描
   {
     ucDisplayDriveStep=1;
   }

}

//数码管的74HC595驱动函数
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
{
   unsigned char i;
   unsigned char ucTempData;
   dig_hc595_sh_dr=0;
   dig_hc595_st_dr=0;
   ucTempData=ucDigStatusTemp16_09;  //先送高8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)dig_hc595_ds_dr=1;
         else dig_hc595_ds_dr=0;
         dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         dig_hc595_sh_dr=1;
         delay_short(1);
         ucTempData=ucTempData<<1;
   }
   ucTempData=ucDigStatusTemp08_01;  //再先送低8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)dig_hc595_ds_dr=1;
         else dig_hc595_ds_dr=0;
         dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         dig_hc595_sh_dr=1;
         delay_short(1);
         ucTempData=ucTempData<<1;
   }
   dig_hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
   delay_short(1); 
   dig_hc595_st_dr=1;
   delay_short(1);
   dig_hc595_sh_dr=0;    //拉低，抗干扰就增强
   dig_hc595_st_dr=0;
   dig_hc595_ds_dr=0;
}

//LED灯的74HC595驱动函数
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
{
   unsigned char i;
   unsigned char ucTempData;
   hc595_sh_dr=0;
   hc595_st_dr=0;
   ucTempData=ucLedStatusTemp16_09;  //先送高8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)hc595_ds_dr=1;
         else hc595_ds_dr=0;
         hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         hc595_sh_dr=1;
         delay_short(1);
         ucTempData=ucTempData<<1;
   }
   ucTempData=ucLedStatusTemp08_01;  //再先送低8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)hc595_ds_dr=1;
         else hc595_ds_dr=0;
         hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         hc595_sh_dr=1;
         delay_short(1);
         ucTempData=ucTempData<<1;
   }
   hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
   delay_short(1); 
   hc595_st_dr=1;
   delay_short(1);
   hc595_sh_dr=0;    //拉低，抗干扰就增强
   hc595_st_dr=0;
   hc595_ds_dr=0;
}

void T0_time() interrupt 1
{
  unsigned int i;
  TF0=0;  //清除中断标志
  TR0=0; //关中断

  if(ucWd==3)  //在窗口3下
  {
     if(uiPasswordTimer>0)   
	 {
	    uiPasswordTimer--;  
	 }
     if(uiPasswordTimer==0)
	 {
		if(ucInputPassword[0]==9&&ucInputPassword[1]==9&&ucInputPassword[2]==2&&ucInputPassword[3]==2)  
	    {     //如果密码等于9922，则正确
		      ucWd=2;//切换到第2个显示按键的窗口
		      ucWd2Update=1;  //更新显示窗口2
	    }
		else //如果密码不正确，则继续显示----
	    {
              for(i=0;i<4;i++)
              {
                 ucInputPassword[i]=11;  //开机默认密码全部显示"----"
              }
			  ucWd=1; 
	          ucWd1Update=1; //更新显示窗口1
		}

	 }
  }


  if(ucWd==2)  //在窗口2下
  {
     if(uiNoKeyPushTimer>0)   
	 {
	    uiNoKeyPushTimer--;  
	 }
     if(uiNoKeyPushTimer==0)//如果10秒内无按键按下，则自动切换到显示密码登录框的界面
	 {
       for(i=0;i<4;i++)
       {
          ucInputPassword[i]=11;  //开机默认密码全部显示"----"
       }
	   ucWd=1; 
	   ucWd1Update=1; //更新显示窗口1
	 }
  }


  key_scan(); //按键扫描函数
  if(uiVoiceCnt!=0)
  {
     uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
     beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
//     beep_dr=1;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
  }
  else
  {
     ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
     beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
//     beep_dr=0;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
  }
  display_drive();  //数码管字模的驱动函数

  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
  TR0=1;  //开中断
}

void delay_short(unsigned int uiDelayShort) 
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}

void delay_long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  //内嵌循环的空指令数量
          {
             ; //一个分号相当于执行一条空语句
          }
   }
}

void initial_myself()  //第一区 初始化单片机
{

  led_dr=0;  //关闭独立LED灯
  beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
  hc595_drive(0x00,0x00);  //关闭所有经过另外两个74HC595驱动的LED灯
  TMOD=0x01;  //设置定时器0为工作方式1
  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
}
void initial_peripheral() //第二区 初始化外围
{
   unsigned int i; //个人的变量命名习惯，i,j,k等单个字母的变量名只用在for循环里
   for(i=0;i<4;i++)
   {
     ucInputPassword[i]=11;  //开机默认密码全部显示"----"
   }

   ucDigDot8=0;   //小数点全部不显示
   ucDigDot7=0;  
   ucDigDot6=0; 
   ucDigDot5=0;  
   ucDigDot4=0; 
   ucDigDot3=0;  
   ucDigDot2=0;
   ucDigDot1=0;
   EA=1;     //开总中断
   ET0=1;    //允许定时中断
   TR0=1;    //启动定时中断
}

 

总结陈词：
这节讲了iphone4S开机密码锁的程序。2014年春节的时候，一帮朋友举行小规模的象棋比赛，有一些朋友下棋的速度实在是太慢了，为了限制比赛时间，我专门用朱兆祺的51学习板做了一个棋类比赛专用计时器给他们用，这个程序该怎么编写？欲知详情，请听下回分解-----带数码管显示的象棋比赛专用计时器。


（未完待续，下节更精彩，不要走开哦）

第三十五节：带数码管显示的象棋比赛专用计时器。

开场白：
2014年春节的时候，一帮朋友举行小规模的象棋比赛，有一些朋友下棋的速度实在是太慢了，为了限制比赛时间，我专门用朱兆祺的51学习板做了一个棋类比赛专用计时器给他们用。这一节要教会大家两个知识点：
第一个：按键服务程序操作的精髓在于根据当前系统处于什么窗口状态下就执行什么操作。紧紧围绕着不同的窗口ucWd来执行不同的操作。
第二个：继续加深熟悉鸿哥首次提出的“一二级菜单显示理论”：凡是人机界面显示，不管是数码管还是液晶屏，都可以把显示的内容分成不同的窗口来显示，每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单，用ucWd变量表示。局部就是二级菜单，用ucPart来表示。不同的窗口，会有不同的更新显示变量ucWdXUpdate来对应，表示整屏全部更新显示。不同的局部，也会有不同的更新显示变量ucWdXPartYUpdate来对应，表示局部更新显示。

具体内容，请看源代码讲解。

（1）硬件平台：基于朱兆祺51单片机学习板。
刚上电开机时，红棋加时键对应S1键，红棋减时键对应S2键.。
刚上电开机时，黑棋加时键对应S3键，黑棋减时键对应S4键.。
比赛中途暂停双方计时的暂停按键对应S6键。刚上电时，复位双方默认20分时间的复位按键对应S7按键。
红棋的抢时按键对应S13键，黑棋的抢时按键对应S16按键。

（2）实现功能：
棋类计时器有点像抢答器，本质上有两个计时器。比赛的时候对弈的两个棋友各用一个不同的按键抢时间，红棋走一步棋后，就按一下自己的抢时按键，这个时候红棋的计时器停止计时，而黑棋的计时器开始计时，黑棋走了一步棋后，按一下自己的计时器，黑棋停止计时，红棋继续计时，依次循环，谁的时间最先用完谁就输，蜂鸣器也会发出长鸣的声音提示时间到。
上电开机默认双方各有20分钟的时间，左边显示的是红棋的时间，右边显示的是黑棋的时间。此时可以通过S1,S2.,S3,S4的加减按键来设置各自的最大倒计时时间。此时如果按下复位按键S7，会自动把双方的时间设置为默认的20分钟。
设置好最大倒计时的时间后，此时任意一方按下各自的抢时按键（S13或者S16），则自己的计时器停止计时，而对方开始倒计时。此时数码管显示的是对方的时间，而自己的时间屏蔽不显示。
在开始倒计时的时候，如果中途有棋友要接听电话或者忙别的事情，需要暂时暂停一下双方的时间，这个时候可以按S6暂停按键来暂停双方的计时，忙完后再次按下暂停按键会继续倒计时。任何一方的时间走完，都会蜂鸣器长鸣提示。

（3）源代码讲解如下：

#include "REG52.H"

#define const_voice_short  40   //蜂鸣器短叫的持续时间
#define const_voice_long   900   //蜂鸣器长叫的持续时间

#define const_key_time  10    //按键去抖动延时的时间

#define const_1s     422   //产生一秒钟的时间基准

void initial_myself();    
void initial_peripheral();
void delay_short(unsigned int uiDelayShort); 
void delay_long(unsigned int uiDelaylong);
void T0_time();  //定时中断函数
void key_service();
void key_scan(); //按键扫描函数 放在定时中断里

void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);
void display_drive();  //放在定时中断里的数码管驱动函数
void time_service();  //放在定时中断里的时间应用程序
void display_service();  


sbit key_sr1=P0^0; //第一行输入
sbit key_sr2=P0^1; //第二行输入
sbit key_sr3=P0^2; //第三行输入
sbit key_sr4=P0^3; //第四行输入

sbit key_dr1=P0^4; //第一列输出
sbit key_dr2=P0^5; //第二列输出
sbit key_dr3=P0^6; //第三列输出
sbit key_dr4=P0^7; //第四列输出

sbit beep_dr=P2^7; //蜂鸣器的驱动IO口


sbit led_dr=P3^5;  //作为中途暂停指示灯 亮的时候表示中途暂停


sbit dig_hc595_sh_dr=P2^0;     //数码管 的74HC595程序
sbit dig_hc595_st_dr=P2^1;  
sbit dig_hc595_ds_dr=P2^2;  

sbit hc595_sh_dr=P2^3;    //LED灯的74HC595程序
sbit hc595_st_dr=P2^4;  
sbit hc595_ds_dr=P2^5;  


unsigned char ucKeyStep=1;  //按键扫描步骤变量

unsigned char ucKeySec=0;   //被触发的按键编号
unsigned int  uiKeyTimeCnt=0; //按键去抖动延时计数器
unsigned char ucKeyLock=0; //按键触发后自锁的变量标志

unsigned char ucRowRecord=1; //记录当前扫描到第几列了

unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

unsigned char ucDigShow8=0;  //第8位数码管要显示的内容
unsigned char ucDigShow7=0;  //第7位数码管要显示的内容
unsigned char ucDigShow6=0;  //第6位数码管要显示的内容
unsigned char ucDigShow5=0;  //第5位数码管要显示的内容
unsigned char ucDigShow4=0;  //第4位数码管要显示的内容
unsigned char ucDigShow3=0;  //第3位数码管要显示的内容
unsigned char ucDigShow2=0;  //第2位数码管要显示的内容
unsigned char ucDigShow1=0;  //第1位数码管要显示的内容
unsigned char ucDigDot3=1;  //数码管3的小数点是否显示的标志
unsigned char ucDigDot7=1;  //数码管7的小数点是否显示的标志

unsigned char ucDigShowTemp=0; //临时中间变量

unsigned char ucDisplayDriveStep=1;  //动态扫描数码管的步骤变量

unsigned int uiRedTimeCnt=0;    //红棋产生秒基准的时间计时器
unsigned int uiBlackTimeCnt=0;  //黑棋产生秒基准的时间计时器

unsigned int uiRedTotal=1200;    //红棋的总时间
unsigned int uiBlackTotal=1200;  //黑棋的总时间

unsigned char ucRedFlag=0;  //红棋是否开始计时的标志
unsigned char ucBlackFlag=0;  //黑棋是否开始计时的标志

unsigned char ucDisplayUpdate=1; //更新显示标志

/* 注释一：
*  ucWd变量是本程序最核心的变量，代表显示哪一个窗口和系统处于当前哪种状态
*/
unsigned char ucWd=1;

code unsigned char dig_table[]=
{
0x3f,  //0       序号0
0x06,  //1       序号1
0x5b,  //2       序号2
0x4f,  //3       序号3
0x66,  //4       序号4
0x6d,  //5       序号5
0x7d,  //6       序号6
0x07,  //7       序号7
0x7f,  //8       序号8
0x6f,  //9       序号9
0x00,  //不显示  序号10
};

void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       key_service(); 
       display_service();  
   }

}


void time_service()  //放在定时中断里的时间应用程序
{
  if(ucRedFlag==1)  //1代表红棋在运行中
  {
     uiRedTimeCnt++;
 	 if(uiRedTimeCnt>const_1s)
	 {
        uiRedTimeCnt=0;
        if(uiRedTotal>0)
		{
		   uiRedTotal--;
		}
		else  //时间到
		{
	 	   ucRedFlag=0;    //红棋和黑棋同时停止计时
		   ucBlackFlag=0;
		   ucWd=1;  //切换到第一个窗口的状态
		   uiVoiceCnt=const_voice_long; //报警声音触发
		}
		

        ucDisplayUpdate=1;  //更新显示
 	 }
  }


  if(ucBlackFlag==1)  //1代表黑棋在运行中
  {
     uiBlackTimeCnt++;
 	 if(uiBlackTimeCnt>const_1s)
	 {
        uiBlackTimeCnt=0;
        if(uiBlackTotal>0)
		{
		   uiBlackTotal--;
		}
		else  //时间到
		{
	 	   ucRedFlag=0;  //红棋和黑棋同时停止计时
		   ucBlackFlag=0;
		   ucWd=1;  //切换到第一个窗口的状态
		   uiVoiceCnt=const_voice_long; //报警声音触发
		}
		

        ucDisplayUpdate=1;  //更新显示
 	 }
  }
}

void display_service()  //放在定时中断里的显示应用程序
{
  if(ucDisplayUpdate==1)  //有数据更新显示
  {
     ucDisplayUpdate=0;
	 switch(ucWd)     //本程序最核心的变量ucWd
	 {
	   case 1:  //窗口1，代表刚上电或者复位后的状态
	  	    //红棋分解出分
	   	    ucDigShowTemp=uiRedTotal/60;
            ucDigShow8=ucDigShowTemp/10;
            ucDigShow7=ucDigShowTemp%10;

	   	    //红棋分解出秒
		    ucDigShowTemp=uiRedTotal%60;
            ucDigShow6=ucDigShowTemp/10;
            ucDigShow5=ucDigShowTemp%10;
			ucDigDot7=1;  //数码管7的小数点显示

	  	    //黑棋分解出分
	   	    ucDigShowTemp=uiBlackTotal/60;
            ucDigShow4=ucDigShowTemp/10;
            ucDigShow3=ucDigShowTemp%10;

	   	    //黑棋分解出秒
		    ucDigShowTemp=uiBlackTotal%60;
            ucDigShow2=ucDigShowTemp/10;
            ucDigShow1=ucDigShowTemp%10;
			ucDigDot3=1;  //数码管3的小数点显示

            led_dr=1;  //计时器处于停止状态,LED亮

	        break;
	   case 2:  //窗口2，代表黑棋正在运行中的状态

	  	    //红棋全部不显示
            ucDigShow8=10;
            ucDigShow7=10;
            ucDigShow6=10;
            ucDigShow5=10;
			ucDigDot7=0;  //数码管7的小数点不显示

	  	    //黑棋分解出分
	   	    ucDigShowTemp=uiBlackTotal/60;
            ucDigShow4=ucDigShowTemp/10;
            ucDigShow3=ucDigShowTemp%10;

	   	    //黑棋分解出秒
		    ucDigShowTemp=uiBlackTotal%60;
            ucDigShow2=ucDigShowTemp/10;
            ucDigShow1=ucDigShowTemp%10;
			ucDigDot3=1;  //数码管3的小数点显示

            led_dr=0;  //计时器处于计时状态,LED灭

	        break;

	   case 3:  //窗口3，代表黑棋在中途暂停的状态

	  	    //红棋全部不显示
            ucDigShow8=10;
            ucDigShow7=10;
            ucDigShow6=10;
            ucDigShow5=10;
			ucDigDot7=0;  //数码管7的小数点不显示

	  	    //黑棋分解出分
	   	    ucDigShowTemp=uiBlackTotal/60;
            ucDigShow4=ucDigShowTemp/10;
            ucDigShow3=ucDigShowTemp%10;

	   	    //黑棋分解出秒
		    ucDigShowTemp=uiBlackTotal%60;
            ucDigShow2=ucDigShowTemp/10;
            ucDigShow1=ucDigShowTemp%10;
			ucDigDot3=1;  //数码管3的小数点显示


            led_dr=1;  //计时器处于暂停状态,LED亮

	        break;
	   case 4:  //窗口4，代表红棋正在运行中的状态
	  	    //红棋分解出分
	   	    ucDigShowTemp=uiRedTotal/60;
            ucDigShow8=ucDigShowTemp/10;
            ucDigShow7=ucDigShowTemp%10;

	   	    //红棋分解出秒
		    ucDigShowTemp=uiRedTotal%60;
            ucDigShow6=ucDigShowTemp/10;
            ucDigShow5=ucDigShowTemp%10;
			ucDigDot7=1;  //数码管7的小数点显示


	  	    //黑棋全部不显示
            ucDigShow4=10;
            ucDigShow3=10;
            ucDigShow2=10;
            ucDigShow1=10;
			ucDigDot3=0;  //数码管3的小数点不显示

            led_dr=0;  //计时器处于倒计时状态,LED灭

	        break;

	   case 5:  //窗口5，代表红棋在中途暂停的状态
	  	    //红棋分解出分
	   	    ucDigShowTemp=uiRedTotal/60;
            ucDigShow8=ucDigShowTemp/10;
            ucDigShow7=ucDigShowTemp%10;

	   	    //红棋分解出秒
		    ucDigShowTemp=uiRedTotal%60;
            ucDigShow6=ucDigShowTemp/10;
            ucDigShow5=ucDigShowTemp%10;
			ucDigDot7=1;  //数码管7的小数点显示


	  	    //黑棋全部不显示
            ucDigShow4=10;
            ucDigShow3=10;
            ucDigShow2=10;
            ucDigShow1=10;
			ucDigDot3=0;  //数码管3的小数点不显示

            led_dr=1;  //计时器处于暂停状态,LED亮

	        break;
	 }
  }
}

void display_drive()  //放在定时中断里的数码管驱动函数
{
   //以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
   switch(ucDisplayDriveStep)
   { 
      case 1:  //显示第1位
           ucDigShowTemp=dig_table[ucDigShow1];
           dig_hc595_drive(ucDigShowTemp,0xfe);
	       break;
      case 2:  //显示第2位
           ucDigShowTemp=dig_table[ucDigShow2];
           dig_hc595_drive(ucDigShowTemp,0xfd);
	       break;
      case 3:  //显示第3位
           ucDigShowTemp=dig_table[ucDigShow3];
		   if(ucDigDot3==1)
		   {
		      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
		   }
           dig_hc595_drive(ucDigShowTemp,0xfb);
	       break;
      case 4:  //显示第4位
           ucDigShowTemp=dig_table[ucDigShow4];
           dig_hc595_drive(ucDigShowTemp,0xf7);
	       break;
      case 5:  //显示第5位
           ucDigShowTemp=dig_table[ucDigShow5];
           dig_hc595_drive(ucDigShowTemp,0xef);
	       break;
      case 6:  //显示第6位
           ucDigShowTemp=dig_table[ucDigShow6];
           dig_hc595_drive(ucDigShowTemp,0xdf);
	       break;
      case 7:  //显示第7位
           ucDigShowTemp=dig_table[ucDigShow7];
		   if(ucDigDot7==1)
		   {
		      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
           }
           dig_hc595_drive(ucDigShowTemp,0xbf);
	       break;
      case 8:  //显示第8位
           ucDigShowTemp=dig_table[ucDigShow8];
           dig_hc595_drive(ucDigShowTemp,0x7f);
	       break;
   }

   ucDisplayDriveStep++;
   if(ucDisplayDriveStep>8)  //扫描完8个数码管后，重新从第一个开始扫描
   {
     ucDisplayDriveStep=1;
   }
}


//数码管的74HC595驱动函数
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
{
   unsigned char i;
   unsigned char ucTempData;
   dig_hc595_sh_dr=0;
   dig_hc595_st_dr=0;

   ucTempData=ucDigStatusTemp16_09;  //先送高8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)dig_hc595_ds_dr=1;
         else dig_hc595_ds_dr=0;

/* 注释二：
*  注意，此处的延时delay_short必须尽可能小，否则动态扫描数码管的速度就不够。
*/
         dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         dig_hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   ucTempData=ucDigStatusTemp08_01;  //再先送低8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)dig_hc595_ds_dr=1;
         else dig_hc595_ds_dr=0;

         dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         dig_hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   dig_hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
   delay_short(1); 
   dig_hc595_st_dr=1;
   delay_short(1); 

   dig_hc595_sh_dr=0;    //拉低，抗干扰就增强
   dig_hc595_st_dr=0;
   dig_hc595_ds_dr=0;

}


//LED灯的74HC595驱动函数
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
{
   unsigned char i;
   unsigned char ucTempData;
   hc595_sh_dr=0;
   hc595_st_dr=0;

   ucTempData=ucLedStatusTemp16_09;  //先送高8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)hc595_ds_dr=1;
         else hc595_ds_dr=0;

         hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   ucTempData=ucLedStatusTemp08_01;  //再先送低8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)hc595_ds_dr=1;
         else hc595_ds_dr=0;

         hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
   delay_short(1); 
   hc595_st_dr=1;
   delay_short(1); 

   hc595_sh_dr=0;    //拉低，抗干扰就增强
   hc595_st_dr=0;
   hc595_ds_dr=0;

}


void key_scan()//按键扫描函数 放在定时中断里
{  

  switch(ucKeyStep)
  {
     case 1:   //按键扫描输出第ucRowRecord列低电平
              if(ucRowRecord==1)  //第一列输出低电平
                  {
             key_dr1=0;      
             key_dr2=1;
             key_dr3=1;    
             key_dr4=1;
                  }
              else if(ucRowRecord==2)  //第二列输出低电平
                  {
             key_dr1=1;      
             key_dr2=0;
             key_dr3=1;    
             key_dr4=1;
                  }
              else if(ucRowRecord==3)  //第三列输出低电平
                  {
             key_dr1=1;      
             key_dr2=1;
             key_dr3=0;    
             key_dr4=1;
                  }
              else   //第四列输出低电平
                  {
             key_dr1=1;      
             key_dr2=1;
             key_dr3=1;    
             key_dr4=0;
                  }

          uiKeyTimeCnt=0;  //延时计数器清零
          ucKeyStep++;     //切换到下一个运行步骤
              break;

     case 2:     //此处的小延时用来等待刚才列输出信号稳定，再判断输入信号。不是去抖动延时。
          uiKeyTimeCnt++;
                  if(uiKeyTimeCnt>1)
                  {
                     uiKeyTimeCnt=0;
             ucKeyStep++;     //切换到下一个运行步骤
                  }
              break;

     case 3:
          if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
          {  
             ucKeyStep=1;  //如果没有按键按下，返回到第一个运行步骤重新开始扫描
             ucKeyLock=0;  //按键自锁标志清零
             uiKeyTimeCnt=0; //按键去抖动延时计数器清零，此行非常巧妙     
   
                         ucRowRecord++;  //输出下一列
                         if(ucRowRecord>4)  
                         {
                            ucRowRecord=1; //依次输出完四列之后，继续从第一列开始输出低电平
                         }

          }
                  else if(ucKeyLock==0)  //有按键按下，且是第一次触发
                  {
                     if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零

                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=1;  //触发1号键 对应朱兆祺学习板的S1键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=2;  //触发2号键 对应朱兆祺学习板的S2键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=3;  //触发3号键 对应朱兆祺学习板的S3键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=4;  //触发4号键 对应朱兆祺学习板的S4键
                           }

                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=5;  //触发5号键 对应朱兆祺学习板的S5键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=6;  //触发6号键 对应朱兆祺学习板的S6键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=7;  //触发7号键 对应朱兆祺学习板的S7键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=8;  //触发8号键 对应朱兆祺学习板的S8键
                           }
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=9;  //触发9号键 对应朱兆祺学习板的S9键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=10;  //触发10号键 对应朱兆祺学习板的S10键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=11;  //触发11号键 对应朱兆祺学习板的S11键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=12;  //触发12号键 对应朱兆祺学习板的S12键
                           }
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=13;  //触发13号键 对应朱兆祺学习板的S13键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=14;  //触发14号键 对应朱兆祺学习板的S14键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=15;  //触发15号键 对应朱兆祺学习板的S15键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=16;  //触发16号键 对应朱兆祺学习板的S16键
                           }
                                }
                         
                         }
                  
                  }
              break;

  }


}

/* 注释三：
*  按键服务程序操作的精髓在于根据当前系统处于什么窗口下就执行什么操作。
*  紧紧围绕着不同的窗口ucWd来执行不同的操作。
*/
void key_service() //第三区 放在定时中断里的按键服务应用程序
{
  switch(ucKeySec) //按键服务状态切换
  {
    case 1:// 1号键 对应朱兆祺学习板的S1键  红棋加分 按键
	      switch(ucWd)  //本程序最核心的变量ucWd
	      {
	         case 1:  //窗口1，代表刚上电，完成或者复位后的状态	  
			      uiRedTotal=uiRedTotal+60;  //加红棋分的时间,此处60秒代表一分
				  if(uiRedTotal>5940)
				  {
				     uiRedTotal=5940;
				  }
                  uiRedTotal=uiRedTotal-(uiRedTotal%60);  //去秒取整分

				  ucDisplayUpdate=1;  //更新显示
                  uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
	              break;

	         case 2:  //窗口2，代表黑棋正在运行中的状态	
	              break;

	         case 3:  //窗口3，代表黑棋在中途暂停的状态
	              break;

	         case 4:  //窗口4，代表红棋正在运行中的状态	  
	              break;

	         case 5:  //窗口5，代表红棋在中途暂停的状态
	              break;

          }
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;        

    case 2:// 2号键 对应朱兆祺学习板的S2键  红棋减分 按键
	      switch(ucWd)  //本程序最核心的变量ucWd
	      {
	         case 1:  //窗口1，代表刚上电，完成或者复位后的状态	  
			      if(uiRedTotal>=60)
				  {
			         uiRedTotal=uiRedTotal-60;  //减红棋分的时间,此处60秒代表一分
				  }
                  uiRedTotal=uiRedTotal-(uiRedTotal%60);  //去秒取整分

				  ucDisplayUpdate=1;  //更新显示
                  uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
	              break;

	         case 2:  //窗口2，代表黑棋正在运行中的状态	
	              break;

	         case 3:  //窗口3，代表黑棋在中途暂停的状态
	              break;

	         case 4:  //窗口4，代表红棋正在运行中的状态	  
	              break;

	         case 5:  //窗口5，代表红棋在中途暂停的状态
	              break;

          }
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;     

    case 3:// 3号键 对应朱兆祺学习板的S3键  黑棋加分 按键
	      switch(ucWd)  //本程序最核心的变量ucWd
	      {
	         case 1:  //窗口1，代表刚上电，完成或者复位后的状态	  
			      uiBlackTotal=uiBlackTotal+60;  //加黑棋分的时间,此处60秒代表一分
				  if(uiBlackTotal>5940)
				  {
				     uiBlackTotal=5940;
				  }
                  uiBlackTotal=uiBlackTotal-(uiBlackTotal%60);  //去秒取整分

				  ucDisplayUpdate=1;  //更新显示
                  uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
	              break;

	         case 2:  //窗口2，代表黑棋正在运行中的状态	
	              break;

	         case 3:  //窗口3，代表黑棋在中途暂停的状态
	              break;

	         case 4:  //窗口4，代表红棋正在运行中的状态	  
	              break;

	         case 5:  //窗口5，代表红棋在中途暂停的状态
	              break;

          }
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;          

    case 4:// 4号键 对应朱兆祺学习板的S4键  黑棋减分 按键
	      switch(ucWd)  //本程序最核心的变量ucWd
	      {
	         case 1:  //窗口1，代表刚上电，完成或者复位后的状态	  
			      if(uiBlackTotal>=60)
				  {
			         uiBlackTotal=uiBlackTotal-60;  //减黑棋分的时间,此处60秒代表一分
				  }
                  uiBlackTotal=uiBlackTotal-(uiBlackTotal%60);  //去秒取整分

				  ucDisplayUpdate=1;  //更新显示
                  uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
	              break;

	         case 2:  //窗口2，代表黑棋正在运行中的状态	
	              break;

	         case 3:  //窗口3，代表黑棋在中途暂停的状态
	              break;

	         case 4:  //窗口4，代表红棋正在运行中的状态	  
	              break;

	         case 5:  //窗口5，代表红棋在中途暂停的状态
	              break;

          }
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   

    case 5:// 5号键 对应朱兆祺学习板的S5键


          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   

    case 6:// 6号键 对应朱兆祺学习板的S6键  中途暂停和启动按键
	      switch(ucWd)  //本程序最核心的变量ucWd
	      {
	         case 1:  //窗口1，代表刚上电，完成或者复位后的状态	  

	              break;

	         case 2:  //窗口2，代表黑棋正在运行中的状态	
                  ucRedFlag=0;    //暂停计时
                  ucBlackFlag=0;//暂停计时
				  ucWd=3; //切换到黑棋中途暂停的状态

				  ucDisplayUpdate=1;  //更新显示
                  uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
	              break;

	         case 3:  //窗口3，代表黑棋在中途暂停的状态
                  ucRedFlag=0;   //红棋暂停计时 
                  ucBlackFlag=1; //黑棋继续计时
				  ucWd=2;       //切换到黑棋正在运行中的状态

				  ucDisplayUpdate=1;  //更新显示
                  uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
	              break;

	         case 4:  //窗口4，代表红棋正在运行中的状态	  
                  ucRedFlag=0;    //暂停计时
                  ucBlackFlag=0;//暂停计时
				  ucWd=5;       //切换到红棋中途暂停的状态

				  ucDisplayUpdate=1;  //更新显示
                  uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
	              break;

	         case 5:  //窗口5，代表红棋在中途暂停的状态
                  ucRedFlag=1;   //红棋继续计时 
                  ucBlackFlag=0; //黑棋暂停计时
				  ucWd=4;       //切换到红棋正在运行中的状态

				  ucDisplayUpdate=1;  //更新显示
                  uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。

	              break;

          }
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   

    case 7:// 7号键 对应朱兆祺学习板的S7键  在第一个窗口下，把计时器的值恢复为开机时的默认值20分钟
	      switch(ucWd)  //本程序最核心的变量ucWd
	      {
	         case 1:  //窗口1，代表刚上电，完成或者复位后的状态	  
                  uiRedTotal=1200;    //红棋的总时间
                  uiBlackTotal=1200;  //黑棋的总时间

				  ucDisplayUpdate=1;  //更新显示
				  uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
	              break;

	         case 2:  //窗口2，代表黑棋正在运行中的状态	

	              break;

	         case 3:  //窗口3，代表黑棋在中途暂停的状态

	              break;

	         case 4:  //窗口4，代表红棋正在运行中的状态	  

	              break;

	         case 5:  //窗口5，代表红棋在中途暂停的状态

	              break;

          }
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 8:// 8号键 对应朱兆祺学习板的S8键

          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 9:// 9号键 对应朱兆祺学习板的S9键

          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 10:// 10号键 对应朱兆祺学习板的S10键

          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 11:// 11号键 对应朱兆祺学习板的S11键

          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 12:// 12号键 对应朱兆祺学习板的S12键

          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 13:// 13号键 对应朱兆祺学习板的S13键  红棋按下
	      switch(ucWd)  //本程序最核心的变量ucWd
	      {
	         case 1:  //窗口1，代表刚上电，完成或者复位后的状态	  
                  ucRedFlag=0;    //红棋暂停计时
                  ucBlackFlag=1;  //黑棋继续计时
				  ucWd=2; //切换到黑棋正在运行中的状态

				  ucDisplayUpdate=1;  //更新显示
	              break;

	         case 2:  //窗口2，代表黑棋正在运行中的状态	

	              break;

	         case 3:  //窗口3，代表黑棋在中途暂停的状态

	              break;

	         case 4:  //窗口4，代表红棋正在运行中的状态	  
                  ucRedFlag=0;    //红棋暂停计时
                  ucBlackFlag=1;  //黑棋继续计时
				  ucWd=2; //切换到黑棋正在运行中的状态

				  ucDisplayUpdate=1;  //更新显示
	              break;

	         case 5:  //窗口5，代表红棋在中途暂停的状态

	              break;

          }

          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 14:// 14号键 对应朱兆祺学习板的S14键

          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 15:// 15号键 对应朱兆祺学习板的S15键

          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   

    case 16:// 16号键 对应朱兆祺学习板的S16键    黑棋按下
	      switch(ucWd)  //本程序最核心的变量ucWd
	      {
	         case 1:  //窗口1，代表刚上电，完成或者复位后的状态	  
                  ucRedFlag=1;    //红棋继续计时
                  ucBlackFlag=0;  //黑棋暂停计时
				  ucWd=4; //切换到红棋正在运行中的状态

				  ucDisplayUpdate=1;  //更新显示
	              break;

	         case 2:  //窗口2，代表黑棋正在运行中的状态	
                  ucRedFlag=1;    //红棋继续计时
                  ucBlackFlag=0;  //黑棋暂停计时
				  ucWd=4; //切换到红棋正在运行中的状态

				  ucDisplayUpdate=1;  //更新显示
	              break;

	         case 3:  //窗口3，代表黑棋在中途暂停的状态

	              break;

	         case 4:  //窗口4，代表红棋正在运行中的状态	  

	              break;

	         case 5:  //窗口5，代表红棋在中途暂停的状态

	              break;

          }
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
  }                
}



void T0_time() interrupt 1
{
  TF0=0;  //清除中断标志
  TR0=0; //关中断
  key_scan(); //放在定时中断里的按键扫描函数
  time_service();  //放在定时中断里的时间应用程序

  if(uiVoiceCnt!=0)
  {
     uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
         beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
  }
  else
  {
     ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
           beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
  }

  display_drive();  //放在定时中断里的数码管驱动函数

/* 注释四：
*  注意，此处的重装初始值不能太大，否则动态扫描数码管的速度就不够。我把原来常用的2000改成了500。
*/
  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
  TR0=1;  //开中断
}

void delay_short(unsigned int uiDelayShort) 
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


void delay_long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  //内嵌循环的空指令数量
          {
             ; //一个分号相当于执行一条空语句
          }
   }
}


void initial_myself()  //第一区 初始化单片机
{

  led_dr=1;
  beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。

  hc595_drive(0x00,0x00);
  TMOD=0x01;  //设置定时器0为工作方式1

  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
}
void initial_peripheral() //第二区 初始化外围
{


  EA=1;     //开总中断
  ET0=1;    //允许定时中断
  TR0=1;    //启动定时中断



}

 

总结陈词：
这节讲了象棋比赛专用计时器的项目程序。为了继续加深读者理解按键和显示是如何有规律关联起来的，下节会继续讲一个相关的小项目程序。欲知详情，请听下回分解-----带数码管显示的加法简易计算器。

（未完待续，下节更精彩，不要走开哦）

第三十六节：带数码管显示的加法简易计算器。

开场白：
   这一节要做一个简单的计算器。这个计算器不带小数点，只能进行不超过8位数据的加法运算，它麻雀虽小但是五脏俱全，它能清晰地勾勒出商业计算器的程序框架和思路。读者只要看懂本节程序框架的规律，以后自己想做一个复杂一点的计算器应该是没问题的。复杂的计算器在算法上要用数组进行特殊处理，不能简单地直接用C语言的+，-，*,/运算符，这方面的内容我会在以后的章节中跟大家分享。
这一节要教会大家两个知识点：
第一个：数字按键的输入和十进制数值的移位方法。
第二个：继续加深理解按键与数码管的关联程序框架。

具体内容，请看源代码讲解。

（1）硬件平台：
基于朱兆祺51单片机学习板。数字1键对应S1键，数字2键对应S2键，数字3键对应S3键…. 数字9键对应S9键, 数字0键对应S10键。加号键对应S13，等于号键对应S14，清除复位按键对应S16。其它按键不用。

（2）实现功能：
常用的加法计算器功能。有连加功能。
本程序有2个窗口。
第1个窗口：原始数据和运算结果窗口。  比如加法运算中的被加数
第2个窗口：第二个参与运行的数据窗口。比如加法运算中的加数

（3）源代码讲解如下：

#include "REG52.H"

#define const_voice_short  40   //蜂鸣器短叫的持续时间
#define const_voice_long   900   //蜂鸣器长叫的持续时间

#define const_key_time  10    //按键去抖动延时的时间

#define const_1s     422   //产生一秒钟的时间基准

void initial_myself();    
void initial_peripheral();
void delay_short(unsigned int uiDelayShort); 
void delay_long(unsigned int uiDelaylong);
void T0_time();  //定时中断函数
void key_service();
void key_scan(); //按键扫描函数 放在定时中断里

void number_key_input(unsigned long ucWhichKey);  //由于数字按键的代码相似度高，因此封装在这个函数里

void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);
void display_drive();  //放在定时中断里的数码管驱动函数
void display_service();  


sbit key_sr1=P0^0; //第一行输入
sbit key_sr2=P0^1; //第二行输入
sbit key_sr3=P0^2; //第三行输入
sbit key_sr4=P0^3; //第四行输入

sbit key_dr1=P0^4; //第一列输出
sbit key_dr2=P0^5; //第二列输出
sbit key_dr3=P0^6; //第三列输出
sbit key_dr4=P0^7; //第四列输出

sbit beep_dr=P2^7; //蜂鸣器的驱动IO口


sbit led_dr=P3^5; //LED指示灯


sbit dig_hc595_sh_dr=P2^0;     //数码管 的74HC595程序
sbit dig_hc595_st_dr=P2^1;  
sbit dig_hc595_ds_dr=P2^2;  

sbit hc595_sh_dr=P2^3;    //LED灯的74HC595程序
sbit hc595_st_dr=P2^4;  
sbit hc595_ds_dr=P2^5;  


unsigned char ucKeyStep=1;  //按键扫描步骤变量

unsigned char ucKeySec=0;   //被触发的按键编号
unsigned int  uiKeyTimeCnt=0; //按键去抖动延时计数器
unsigned char ucKeyLock=0; //按键触发后自锁的变量标志

unsigned char ucRowRecord=1; //记录当前扫描到第几列了

unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

unsigned char ucDigShow8=0;  //第8位数码管要显示的内容
unsigned char ucDigShow7=0;  //第7位数码管要显示的内容
unsigned char ucDigShow6=0;  //第6位数码管要显示的内容
unsigned char ucDigShow5=0;  //第5位数码管要显示的内容
unsigned char ucDigShow4=0;  //第4位数码管要显示的内容
unsigned char ucDigShow3=0;  //第3位数码管要显示的内容
unsigned char ucDigShow2=0;  //第2位数码管要显示的内容
unsigned char ucDigShow1=0;  //第1位数码管要显示的内容


unsigned char ucDigShowTemp=0; //临时中间变量

unsigned char ucDisplayDriveStep=1;  //动态扫描数码管的步骤变量


unsigned char ucDisplayUpdate=1; //更新显示标志

unsigned long ulSource=0;  //原始数据    比如在加法运算中的被加数
unsigned long ulOther=0; //另外一个参与运算的数据  比如在加法运算中的加数
unsigned long ulResult=0; //运算结果
unsigned char ucOperator=0; //运行符号。0代表当前没有选择运行符号。1代表当前的运算符是加法。

/* 注释一：
 *  ucWd变量是本程序最核心的变量，代表数码管显示哪一个窗口
 *  本程序只有两个窗口，他们分别是：
 *  第一个窗口：原始数据和运算结果窗口。  比如加法运算中的被加数
 *  第二个窗口：第二个参与运行的数据窗口。比如加法运算中的加数
 */
unsigned char ucWd=1;

code unsigned char dig_table[]=
{
0x3f,  //0       序号0
0x06,  //1       序号1
0x5b,  //2       序号2
0x4f,  //3       序号3
0x66,  //4       序号4
0x6d,  //5       序号5
0x7d,  //6       序号6
0x07,  //7       序号7
0x7f,  //8       序号8
0x6f,  //9       序号9
0x00,  //不显示  序号10
};

void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       key_service(); 
       display_service();  
   }

}



void display_service()  //放在定时中断里的显示应用程序
{
  if(ucDisplayUpdate==1)  //有数据更新显示
  {
     ucDisplayUpdate=0;
         switch(ucWd)     //本程序最核心的变量ucWd
         {
           case 1:  //窗口1  原始数据和运算结果窗口
                if(ulSource>=10000000)
				{
				   ucDigShow8=ulSource/10000000;
				}
				else
				{
			       ucDigShow8=10;//数据显示空
				}


                if(ulSource>=1000000)
				{
				   ucDigShow7=ulSource%10000000/1000000;
				}
				else
				{
			       ucDigShow7=10;//数据显示空
				}


                if(ulSource>=100000)
				{
				   ucDigShow6=ulSource%1000000/100000;
				}
				else
				{
			       ucDigShow6=10;//数据显示空
				}

                if(ulSource>=10000)
				{
				   ucDigShow5=ulSource%100000/10000;
				}
				else
				{
			       ucDigShow5=10;//数据显示空
				}

                if(ulSource>=1000)
				{
				   ucDigShow4=ulSource%10000/1000;
				}
				else
				{
			       ucDigShow4=10;//数据显示空
				}

                if(ulSource>=100)
				{
				   ucDigShow3=ulSource%1000/100;
				}
				else
				{
			       ucDigShow3=10;//数据显示空
				}

                if(ulSource>=10)
				{
				   ucDigShow2=ulSource%100/10;
				}
				else
				{
			       ucDigShow2=10;//数据显示空
				}

				ucDigShow1=ulSource%10;

                break;
           case 2:  //窗口2  第二个参与运算数据的窗口  比如加法运算中的加数
                if(ulOther>=10000000)
				{
				   ucDigShow8=ulOther/10000000;
				}
				else
				{
			       ucDigShow8=10;//数据显示空
				}


                if(ulOther>=1000000)
				{
				   ucDigShow7=ulOther%10000000/1000000;
				}
				else
				{
			       ucDigShow7=10;//数据显示空
				}


                if(ulOther>=100000)
				{
				   ucDigShow6=ulOther%1000000/100000;
				}
				else
				{
			       ucDigShow6=10;//数据显示空
				}

                if(ulOther>=10000)
				{
				   ucDigShow5=ulOther%100000/10000;
				}
				else
				{
			       ucDigShow5=10;//数据显示空
				}

                if(ulOther>=1000)
				{
				   ucDigShow4=ulOther%10000/1000;
				}
				else
				{
			       ucDigShow4=10;//数据显示空
				}

                if(ulOther>=100)
				{
				   ucDigShow3=ulOther%1000/100;
				}
				else
				{
			       ucDigShow3=10;//数据显示空
				}

                if(ulOther>=10)
				{
				   ucDigShow2=ulOther%100/10;
				}
				else
				{
			       ucDigShow2=10;//数据显示空
				}

				ucDigShow1=ulOther%10;

                break;
         }
  }
}

void display_drive()  //放在定时中断里的数码管驱动函数
{
   //以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
   switch(ucDisplayDriveStep)
   { 
      case 1:  //显示第1位
           ucDigShowTemp=dig_table[ucDigShow1];
           dig_hc595_drive(ucDigShowTemp,0xfe);
               break;
      case 2:  //显示第2位
           ucDigShowTemp=dig_table[ucDigShow2];
           dig_hc595_drive(ucDigShowTemp,0xfd);
               break;
      case 3:  //显示第3位
           ucDigShowTemp=dig_table[ucDigShow3];
           dig_hc595_drive(ucDigShowTemp,0xfb);
               break;
      case 4:  //显示第4位
           ucDigShowTemp=dig_table[ucDigShow4];
           dig_hc595_drive(ucDigShowTemp,0xf7);
               break;
      case 5:  //显示第5位
           ucDigShowTemp=dig_table[ucDigShow5];
           dig_hc595_drive(ucDigShowTemp,0xef);
               break;
      case 6:  //显示第6位
           ucDigShowTemp=dig_table[ucDigShow6];
           dig_hc595_drive(ucDigShowTemp,0xdf);
               break;
      case 7:  //显示第7位
           ucDigShowTemp=dig_table[ucDigShow7];
           dig_hc595_drive(ucDigShowTemp,0xbf);
               break;
      case 8:  //显示第8位
           ucDigShowTemp=dig_table[ucDigShow8];
           dig_hc595_drive(ucDigShowTemp,0x7f);
               break;
   }

   ucDisplayDriveStep++;
   if(ucDisplayDriveStep>8)  //扫描完8个数码管后，重新从第一个开始扫描
   {
     ucDisplayDriveStep=1;
   }
}


//数码管的74HC595驱动函数
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
{
   unsigned char i;
   unsigned char ucTempData;
   dig_hc595_sh_dr=0;
   dig_hc595_st_dr=0;

   ucTempData=ucDigStatusTemp16_09;  //先送高8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)dig_hc595_ds_dr=1;
         else dig_hc595_ds_dr=0;

/* 注释二：
*  注意，此处的延时delay_short必须尽可能小，否则动态扫描数码管的速度就不够。
*/
         dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         dig_hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   ucTempData=ucDigStatusTemp08_01;  //再先送低8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)dig_hc595_ds_dr=1;
         else dig_hc595_ds_dr=0;

         dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         dig_hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   dig_hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
   delay_short(1); 
   dig_hc595_st_dr=1;
   delay_short(1); 

   dig_hc595_sh_dr=0;    //拉低，抗干扰就增强
   dig_hc595_st_dr=0;
   dig_hc595_ds_dr=0;

}


//LED灯的74HC595驱动函数
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
{
   unsigned char i;
   unsigned char ucTempData;
   hc595_sh_dr=0;
   hc595_st_dr=0;

   ucTempData=ucLedStatusTemp16_09;  //先送高8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)hc595_ds_dr=1;
         else hc595_ds_dr=0;

         hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   ucTempData=ucLedStatusTemp08_01;  //再先送低8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)hc595_ds_dr=1;
         else hc595_ds_dr=0;

         hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
   delay_short(1); 
   hc595_st_dr=1;
   delay_short(1); 

   hc595_sh_dr=0;    //拉低，抗干扰就增强
   hc595_st_dr=0;
   hc595_ds_dr=0;

}


void key_scan()//按键扫描函数 放在定时中断里
{  

  switch(ucKeyStep)
  {
     case 1:   //按键扫描输出第ucRowRecord列低电平
              if(ucRowRecord==1)  //第一列输出低电平
                  {
             key_dr1=0;      
             key_dr2=1;
             key_dr3=1;    
             key_dr4=1;
                  }
              else if(ucRowRecord==2)  //第二列输出低电平
                  {
             key_dr1=1;      
             key_dr2=0;
             key_dr3=1;    
             key_dr4=1;
                  }
              else if(ucRowRecord==3)  //第三列输出低电平
                  {
             key_dr1=1;      
             key_dr2=1;
             key_dr3=0;    
             key_dr4=1;
                  }
              else   //第四列输出低电平
                  {
             key_dr1=1;      
             key_dr2=1;
             key_dr3=1;    
             key_dr4=0;
                  }

          uiKeyTimeCnt=0;  //延时计数器清零
          ucKeyStep++;     //切换到下一个运行步骤
              break;

     case 2:     //此处的小延时用来等待刚才列输出信号稳定，再判断输入信号。不是去抖动延时。
          uiKeyTimeCnt++;
                  if(uiKeyTimeCnt>1)
                  {
                     uiKeyTimeCnt=0;
             ucKeyStep++;     //切换到下一个运行步骤
                  }
              break;

     case 3:
          if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==1)
          {  
             ucKeyStep=1;  //如果没有按键按下，返回到第一个运行步骤重新开始扫描
             ucKeyLock=0;  //按键自锁标志清零
             uiKeyTimeCnt=0; //按键去抖动延时计数器清零，此行非常巧妙     
   
                         ucRowRecord++;  //输出下一列
                         if(ucRowRecord>4)  
                         {
                            ucRowRecord=1; //依次输出完四列之后，继续从第一列开始输出低电平
                         }

          }
                  else if(ucKeyLock==0)  //有按键按下，且是第一次触发
                  {
                     if(key_sr1==0&&key_sr2==1&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零

                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=1;  //触发1号键 对应朱兆祺学习板的S1键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=2;  //触发2号键 对应朱兆祺学习板的S2键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=3;  //触发3号键 对应朱兆祺学习板的S3键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=4;  //触发4号键 对应朱兆祺学习板的S4键
                           }

                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==0&&key_sr3==1&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=5;  //触发5号键 对应朱兆祺学习板的S5键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=6;  //触发6号键 对应朱兆祺学习板的S6键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=7;  //触发7号键 对应朱兆祺学习板的S7键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=8;  //触发8号键 对应朱兆祺学习板的S8键
                           }
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==0&&key_sr4==1)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=9;  //触发9号键 对应朱兆祺学习板的S9键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=10;  //触发10号键 对应朱兆祺学习板的S10键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=11;  //触发11号键 对应朱兆祺学习板的S11键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=12;  //触发12号键 对应朱兆祺学习板的S12键
                           }
                                }
                         
                         }
                     else if(key_sr1==1&&key_sr2==1&&key_sr3==1&&key_sr4==0)
                         {
                            uiKeyTimeCnt++;  //去抖动延时计数器
                                if(uiKeyTimeCnt>const_key_time)
                                {
                                   uiKeyTimeCnt=0;
                                   ucKeyLock=1;//自锁按键置位,避免一直触发,只有松开按键,此标志位才会被清零
                       if(ucRowRecord==1)  //第一列输出低电平
                           {
                                      ucKeySec=13;  //触发13号键 对应朱兆祺学习板的S13键
                           }
                       else if(ucRowRecord==2)  //第二列输出低电平
                           {
                                      ucKeySec=14;  //触发14号键 对应朱兆祺学习板的S14键
                           }
                       else if(ucRowRecord==3)  //第三列输出低电平
                           {
                                      ucKeySec=15;  //触发15号键 对应朱兆祺学习板的S15键
                           }
                       else   //第四列输出低电平
                           {
                                      ucKeySec=16;  //触发16号键 对应朱兆祺学习板的S16键
                           }
                                }
                         
                         }
                  
                  }
              break;

  }


}

/* 注释三：
*  按键服务程序操作的精髓在于根据当前系统处于什么窗口下，在此窗口下的运算符处于
*  什么状态，然后紧紧围绕着不同的窗口ucWd，不同的ucOperator来执行不同的操作。
*/
void key_service() //第三区 按键服务的应用程序
{
  switch(ucKeySec) //按键服务状态切换
  {
    case 1:// 1号键 对应朱兆祺学习板的S1键
          number_key_input(1);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;        
    case 2:// 2号键 对应朱兆祺学习板的S2键
          number_key_input(2);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;     
    case 3:// 3号键 对应朱兆祺学习板的S3键
          number_key_input(3);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;          
    case 4:// 4号键 对应朱兆祺学习板的S4键
          number_key_input(4);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 5:// 5号键 对应朱兆祺学习板的S5键
          number_key_input(5);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 6:// 6号键 对应朱兆祺学习板的S6键
          number_key_input(6);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 7:// 7号键 对应朱兆祺学习板的S7键
          number_key_input(7);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 8:// 8号键 对应朱兆祺学习板的S8键
          number_key_input(8);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 9:// 9号键 对应朱兆祺学习板的S9键
          number_key_input(9);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 10:// 把这个按键专门用来输入数字0    对应朱兆祺学习板的S10键
          number_key_input(0);  //由于数字按键的代码相似度高，因此把具体代码封装在这个函数里
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 11:// 11号键 对应朱兆祺学习板的S11键

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 12:// 12号键 对应朱兆祺学习板的S12键

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 13:// 13号键 加号按键  对应朱兆祺学习板的S13键 
          switch(ucWd)
       	  {
	          case 1:   //在原始数据和运算结果的窗口下
                   ucOperator=1; //加法
                   ulOther=ulSource;  //第二个运算数默认等于原始数
                   ucDisplayUpdate=1;  //刷新显示窗口
		  	       break;
	          case 2:   //在第二个参与运算数据的窗口下 
                   ulResult=ulSource+ulOther;//连加
                   ulSource=ulResult; //下一次运算的原始数据默认为当前运算结果，方便连加功能
                   ucWd=1;        //切换到第一个窗口
                   ucDisplayUpdate=1;  //刷新显示窗口
		           break;
          }

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 14:// 14号键 等于号按键  对应朱兆祺学习板的S14键  
          switch(ucWd)
       	  {
	          case 1:   //在原始数据和运算结果的窗口下
		           switch(ucOperator)  //根据不同的运算符号进行不同的操作
		           {
			           case 0:  //无运算符号

			                break;
			           case 1:  //加法
                            ulResult=ulSource+ulOther;//连加
                            ulSource=ulResult; //下一次运算的原始数据默认为当前运算结果，方便连加功能
                            ucDisplayUpdate=1;  //刷新显示窗口
			                break;
			           case 2:  //减法  本程序没有减法功能，如果读者想增加减法程序，可以按键这个框架添加下去

			                break;
			
		           }
		  	       break;
	          case 2:   //在第二个参与运算数据的窗口下 
		           switch(ucOperator)  //根据不同的运算符号进行不同的操作
		           {
			           case 1:  //加法
                            ulResult=ulSource+ulOther;//连加
                            ulSource=ulResult; //下一次运算的原始数据默认为当前运算结果，方便连加功能
                            ucWd=1;        //切换到第一个窗口
                            ucDisplayUpdate=1;  //刷新显示窗口
			                break;
			           case 2:  //减法  本程序没有减法功能，如果读者想增加减法程序，可以按键这个框架添加下去

			                break;
			
		           }
		           break;
          }

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 15:// 15号键 对应朱兆祺学习板的S15键

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
    case 16:// 16号键 清除按键 相当于复位的功能。重新输入数据  对应朱兆祺学习板的S16键
	      ulSource=0;
		  ulOther=0;
          ulResult=0;
		  ucOperator=0;
          ucWd=1;        //切换到第一个窗口
          ucDisplayUpdate=1;  //刷新显示窗口
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;   
  }                
}


/* 注释四：
 * 此处参与运算的输入数字ucWhichKey记得用最大变量类型unsigned long，可以避免数据溢出等错误
 */
void number_key_input(unsigned long ucWhichKey)  //由于数字按键的代码相似度高，因此封装在这个函数里
{


    switch(ucWd)
   	{
	   case 1:   //在原始数据和运算结果的窗口下
            switch(ucOperator)  //根据不同的运算符号进行不同的操作
			{
			   case 0:  //无运算符号  按键输入原始数据，比如被加输
			        if(ulSource<=9999999) //最大只能输入8位数
					{
                       ulSource=ulSource*10+ucWhichKey;  //十进制的数值移位方法。
					}
			        break;
			   default:  //在已经按下了运算符号的情况下
                    ulOther=0;  //第二个运算数先清零，再输入新的数据，然后马上切换到第2个窗口下
                    ulOther=ucWhichKey;
                    ucWd=2; //马上切换到第二个窗口下
			        break;
			
			}

            ucDisplayUpdate=1;  //刷新显示窗口
			break;
	   case 2:   //在第二个参与运算数据的窗口下   按键输入第二个参与运算的数据
			if(ulOther<=9999999) //最大只能输入8位数
			{
               ulOther=ulOther*10+ucWhichKey;  //十进制的数值移位方法。
		    }

            ucDisplayUpdate=1;  //刷新显示窗口
		    break;
    }

}


void T0_time() interrupt 1
{
  TF0=0;  //清除中断标志
  TR0=0; //关中断
  key_scan(); //放在定时中断里的按键扫描函数
  if(uiVoiceCnt!=0)
  {
     uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
         beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
  }
  else
  {
     ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
           beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
  }

  display_drive();  //放在定时中断里的数码管驱动函数

/* 注释五：
*  注意，此处的重装初始值不能太大，否则动态扫描数码管的速度就不够。我把原来常用的2000改成了500。
*/
  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
  TR0=1;  //开中断
}

void delay_short(unsigned int uiDelayShort) 
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


void delay_long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  //内嵌循环的空指令数量
          {
             ; //一个分号相当于执行一条空语句
          }
   }
}


void initial_myself()  //第一区 初始化单片机
{

  led_dr=0;
  beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。

  hc595_drive(0x00,0x00);
  TMOD=0x01;  //设置定时器0为工作方式1

  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
}
void initial_peripheral() //第二区 初始化外围
{


  EA=1;     //开总中断
  ET0=1;    //允许定时中断
  TR0=1;    //启动定时中断



}

 

总结陈词：
这节讲了加法简易计算器的程序项目。为了让读者理解运动，按键，显示是如何有规律关联起来的，下节会继续讲一个相关的小项目程序。欲知详情，请听下回分解-----数码管作为仪表盘显示跑马灯的方向，速度和运行状态。

（未完待续，下节更精彩，不要走开哦）

第三十七节：数码管作为仪表盘显示跑马灯的方向，速度和运行状态。

开场白：
    我在第24节中讲过按键控制跑马灯的方向，速度和运行状态的项目程序，只可惜那个程序不能直观地显示运行中的三种状态，这节我决定在24节的基础上，增加一个数码管显示作为类似汽车仪表盘的界面，实时显示跑马灯的方向，速度，和运行状态。
这一节要教会大家一个知识点：继续加深理解运动，按键与数码管三者之间的关联程序框架。

具体内容，请看源代码讲解。

（1）硬件平台：
基于朱兆祺51单片机学习板。用S1键作为控制跑马灯的方向按键，S5键作为控制跑马灯方向的加速度按键，S9键作为控制跑马灯方向的减速度按键，S13键作为控制跑马灯方向的启动或者暂停按键。记得把输出线P0.4一直输出低电平，模拟独立按键的触发地GND。

（2）实现功能：
跑马灯运行：第1个至第8个LED灯一直不亮。在第9个至第16个LED灯，依次逐个亮灯并且每次只能亮一个灯。每按一次独立按键S13键，原来运行的跑马灯会暂停，原来暂停的跑马灯会运行。用S1来改变方向。用S5和S9来改变速度，每按一次按键的递增或者递减以10为单位。
数码管显示：本程序只有1个窗口，这个窗口分成3个局部显示。8，7，6位数码管显示运行状态，启动时显示“on”，停止时显示“oFF”。5位数码管显示数码管方向，正向显示“n”，反向显示“U”。4,3,2,1位数码管显示速度。数值越大速度越慢，最慢的速度是550，最快的速度是50。

（3）源代码讲解如下：

#include "REG52.H"


#define const_voice_short  40   //蜂鸣器短叫的持续时间


#define const_key_time1  20    //按键去抖动延时的时间
#define const_key_time2  20    //按键去抖动延时的时间
#define const_key_time3  20    //按键去抖动延时的时间
#define const_key_time4  20    //按键去抖动延时的时间


void initial_myself();    
void initial_peripheral();
void delay_short(unsigned int uiDelayShort); 
void delay_long(unsigned int uiDelaylong);

//驱动数码管的74HC595
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);  
void display_drive(); //显示数码管字模的驱动函数
void display_service(); //显示的窗口菜单服务程序

//驱动LED的74HC595
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
void led_flicker_09_16(); //第9个至第16个LED的跑马灯程序，逐个亮并且每次只能亮一个.
void led_update();  //LED更新函数

void T0_time();  //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan();//按键扫描函数 放在定时中断里


sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键

sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平

sbit led_dr=P3^5;  


sbit dig_hc595_sh_dr=P2^0;     //数码管的74HC595程序
sbit dig_hc595_st_dr=P2^1;  
sbit dig_hc595_ds_dr=P2^2;  

sbit hc595_sh_dr=P2^3;    //LED灯的74HC595程序
sbit hc595_st_dr=P2^4;  
sbit hc595_ds_dr=P2^5;  


unsigned char ucKeySec=0;   //被触发的按键编号

unsigned int  uiKeyTimeCnt1=0; //按键去抖动延时计数器
unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志

unsigned int  uiKeyTimeCnt2=0; //按键去抖动延时计数器
unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志

unsigned int  uiKeyTimeCnt3=0; //按键去抖动延时计数器
unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志


unsigned int  uiKeyTimeCnt4=0; //按键去抖动延时计数器
unsigned char ucKeyLock4=0; //按键触发后自锁的变量标志

unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器

unsigned char ucLed_dr1=0;   //代表16个灯的亮灭状态，0代表灭，1代表亮
unsigned char ucLed_dr2=0;
unsigned char ucLed_dr3=0;
unsigned char ucLed_dr4=0;
unsigned char ucLed_dr5=0;
unsigned char ucLed_dr6=0;
unsigned char ucLed_dr7=0;
unsigned char ucLed_dr8=0;
unsigned char ucLed_dr9=0;
unsigned char ucLed_dr10=0;
unsigned char ucLed_dr11=0;
unsigned char ucLed_dr12=0;
unsigned char ucLed_dr13=0;
unsigned char ucLed_dr14=0;
unsigned char ucLed_dr15=0;
unsigned char ucLed_dr16=0;

unsigned char ucLed_update=0;  //刷新变量。每次更改LED灯的状态都要更新一次。


unsigned char ucLedStep_09_16=0; //第9个至第16个LED跑马灯的步骤变量
unsigned int  uiTimeCnt_09_16=0; //第9个至第16个LED跑马灯的统计定时中断次数的延时计数器

unsigned char ucLedStatus16_09=0;   //代表底层74HC595输出状态的中间变量
unsigned char ucLedStatus08_01=0;   //代表底层74HC595输出状态的中间变量

unsigned char ucLedDirFlag=0;   //方向变量，把按键与跑马灯关联起来的核心变量,0代表正方向，1代表反方向
unsigned int  uiSetTimeLevel_09_16=300;  //速度变量，此数值越大速度越慢，此数值越小速度越快。
unsigned char ucLedStartFlag=1;   //启动和暂停的变量，0代表暂停，1代表启动



unsigned char ucDigShow8;  //第8位数码管要显示的内容
unsigned char ucDigShow7;  //第7位数码管要显示的内容
unsigned char ucDigShow6;  //第6位数码管要显示的内容
unsigned char ucDigShow5;  //第5位数码管要显示的内容
unsigned char ucDigShow4;  //第4位数码管要显示的内容
unsigned char ucDigShow3;  //第3位数码管要显示的内容
unsigned char ucDigShow2;  //第2位数码管要显示的内容
unsigned char ucDigShow1;  //第1位数码管要显示的内容


unsigned char ucDigDot8;  //数码管8的小数点是否显示的标志
unsigned char ucDigDot7;  //数码管7的小数点是否显示的标志
unsigned char ucDigDot6;  //数码管6的小数点是否显示的标志
unsigned char ucDigDot5;  //数码管5的小数点是否显示的标志
unsigned char ucDigDot4;  //数码管4的小数点是否显示的标志
unsigned char ucDigDot3;  //数码管3的小数点是否显示的标志
unsigned char ucDigDot2;  //数码管2的小数点是否显示的标志
unsigned char ucDigDot1;  //数码管1的小数点是否显示的标志

unsigned char ucDigShowTemp=0; //临时中间变量
unsigned char ucDisplayDriveStep=1;  //动态扫描数码管的步骤变量

unsigned char ucWd1Part1Update=1;  //窗口1的局部1更新显示变量
unsigned char ucWd1Part2Update=1;  //窗口1的局部2更新显示变量
unsigned char ucWd1Part3Update=1;  //窗口1的局部3更新显示变量


//根据原理图得出的共阴数码管字模表
code unsigned char dig_table[]=
{
0x3f,  //0       序号0
0x06,  //1       序号1
0x5b,  //2       序号2
0x4f,  //3       序号3
0x66,  //4       序号4
0x6d,  //5       序号5
0x7d,  //6       序号6
0x07,  //7       序号7
0x7f,  //8       序号8
0x6f,  //9       序号9
0x00,  //无      序号10
0x40,  //-       序号11
0x73,  //P       序号12
0x5c,  //o       序号13
0x71,  //F       序号14
0x3e,  //U       序号15
0x37,  //n       序号16
};

void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
      key_service(); //按键服务的应用程序
      display_service(); //显示的窗口菜单服务程序

      led_flicker_09_16(); //第9个至第16个LED的跑马灯程序，逐个亮并且每次只能亮一个.
	  led_update();  //LED更新函数
   }

}



/* 注释一：
 * 由于本程序只有1个窗口，而这个窗口又分成3个局部，因此可以省略去窗口变量uWd，
 * 只用三个局部变量ucWdxPartyUpdate就可以了。
 */

void display_service() //显示的窗口菜单服务程序
{


    if(ucWd1Part1Update==1) //更新显示当前系统是处于运行还是暂停的状态
	{
       ucWd1Part1Update=0; //及时把更新变量清零，防止一直进来更新
	   if(ucLedStartFlag==1)  //启动，显示on
	   {
	       ucDigShow8=13;  //显示o
           ucDigShow7=16;  //显示n
           ucDigShow6=10;  //显示空
	   }
	   else  //暂停，显示oFF
	   {
	   	   ucDigShow8=13;  //显示o
           ucDigShow7=14;  //显示F
           ucDigShow6=14;  //显示F
	   }
	}

    if(ucWd1Part2Update==1) //更新显示当前系统是处于正方向还是反方向
	{
       ucWd1Part2Update=0; //及时把更新变量清零，防止一直进来更新
	   if(ucLedDirFlag==0)  //正方向，向上，显示n
	   {
	       ucDigShow5=16;  //显示n
	   }
	   else  //反方向，向下，显示U
	   {
	       ucDigShow5=15;  //显示U
	   }
	}

    if(ucWd1Part3Update==1) //更新显示当前系统的速度，此数值越大速度越慢，此数值越小速度越快。
	{
       ucWd1Part3Update=0; //及时把更新变量清零，防止一直进来更新

	   ucDigShow4=10;  //显示空  这一位不用，作为空格

	   if(uiSetTimeLevel_09_16>=100)
	   {
          ucDigShow3=uiSetTimeLevel_09_16/100;     //显示速度的百位
	   }
	   else
	   {
          ucDigShow3=10;     //显示空
	   }

	   if(uiSetTimeLevel_09_16>=10)
	   {
          ucDigShow2=uiSetTimeLevel_09_16%100/10;  //显示速度的十位
	   }
	   else
	   {
          ucDigShow2=10;     //显示空
	   }

       ucDigShow1=uiSetTimeLevel_09_16%10;      //显示速度的个位
	}


   


}


void key_scan()//按键扫描函数 放在定时中断里
{  

  if(key_sr1==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  {
     ucKeyLock1=0; //按键自锁标志清零
     uiKeyTimeCnt1=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
  }
  else if(ucKeyLock1==0)//有按键按下，且是第一次被按下
  {
     uiKeyTimeCnt1++; //累加定时中断次数
     if(uiKeyTimeCnt1>const_key_time1)
     {
        uiKeyTimeCnt1=0; 
        ucKeyLock1=1;  //自锁按键置位,避免一直触发
        ucKeySec=1;    //触发1号键
     }
  }

  if(key_sr2==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  {
     ucKeyLock2=0; //按键自锁标志清零
     uiKeyTimeCnt2=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
  }
  else if(ucKeyLock2==0)//有按键按下，且是第一次被按下
  {
     uiKeyTimeCnt2++; //累加定时中断次数
     if(uiKeyTimeCnt2>const_key_time2)
     {
        uiKeyTimeCnt2=0; 
        ucKeyLock2=1;  //自锁按键置位,避免一直触发
        ucKeySec=2;    //触发2号键
     }
  }

  if(key_sr3==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  {
     ucKeyLock3=0; //按键自锁标志清零
     uiKeyTimeCnt3=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
  }
  else if(ucKeyLock3==0)//有按键按下，且是第一次被按下
  {
     uiKeyTimeCnt3++; //累加定时中断次数
     if(uiKeyTimeCnt3>const_key_time3)
     {
        uiKeyTimeCnt3=0; 
        ucKeyLock3=1;  //自锁按键置位,避免一直触发
        ucKeySec=3;    //触发3号键
     }
  }

  if(key_sr4==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  {
     ucKeyLock4=0; //按键自锁标志清零
     uiKeyTimeCnt4=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。      
  }
  else if(ucKeyLock4==0)//有按键按下，且是第一次被按下
  {
     uiKeyTimeCnt4++; //累加定时中断次数
     if(uiKeyTimeCnt4>const_key_time4)
     {
        uiKeyTimeCnt4=0; 
        ucKeyLock4=1;  //自锁按键置位,避免一直触发
        ucKeySec=4;    //触发4号键
     }
  }

}


void key_service() //按键服务的应用程序
{
  switch(ucKeySec) //按键服务状态切换
  {
    case 1:// 改变跑马灯方向的按键 对应朱兆祺学习板的S1键 

          if(ucLedDirFlag==0) //通过中间变量改变跑马灯的方向
		  {
		     ucLedDirFlag=1;
		  }
		  else
		  {
		  	 ucLedDirFlag=0;
		  }

          ucWd1Part2Update=1; //及时更新显示方向

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;    
    
    case 2:// 加速按键 对应朱兆祺学习板的S5键 uiSetTimeLevel_09_16越小速度越快
          uiSetTimeLevel_09_16=uiSetTimeLevel_09_16-10;
		  if(uiSetTimeLevel_09_16<50)  //最快限定在50
		  {
		      uiSetTimeLevel_09_16=50;
		  }

          ucWd1Part3Update=1; //及时更新显示速度

          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;  

    case 3:// 减速按键 对应朱兆祺学习板的S9键  uiSetTimeLevel_09_16越大速度越慢
          uiSetTimeLevel_09_16=uiSetTimeLevel_09_16+10;
		  if(uiSetTimeLevel_09_16>550)  //最慢限定在550
		  {
		      uiSetTimeLevel_09_16=550;
		  }
          ucWd1Part3Update=1; //及时更新显示速度
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;         
         
    case 4:// 启动和暂停按键 对应朱兆祺学习板的S13键  ucLedStartFlag为0时代表暂停，为1时代表启动

	      if(ucLedStartFlag==1)  //启动和暂停两种状态循环切换
		  {
		     ucLedStartFlag=0;
		  }
		  else                   //启动和暂停两种状态循环切换
		  {
		  	 ucLedStartFlag=1;
		  }
          ucWd1Part1Update=1; //及时更新显示系统的运行状态，是运行还是暂停.
          uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
          ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
          break;    
  }                
}




void led_update()  //LED更新函数
{

   if(ucLed_update==1)
   {
       ucLed_update=0;   //及时清零，让它产生只更新一次的效果，避免一直更新。

       if(ucLed_dr1==1)
	   {
	      ucLedStatus08_01=ucLedStatus08_01|0x01;
	   }
	   else
	   {
	      ucLedStatus08_01=ucLedStatus08_01&0xfe;
	   }

       if(ucLed_dr2==1)
	   {
	      ucLedStatus08_01=ucLedStatus08_01|0x02;
	   }
	   else
	   {
	      ucLedStatus08_01=ucLedStatus08_01&0xfd;
	   }

       if(ucLed_dr3==1)
	   {
	      ucLedStatus08_01=ucLedStatus08_01|0x04;
	   }
	   else
	   {
	      ucLedStatus08_01=ucLedStatus08_01&0xfb;
	   }

       if(ucLed_dr4==1)
	   {
	      ucLedStatus08_01=ucLedStatus08_01|0x08;
	   }
	   else
	   {
	      ucLedStatus08_01=ucLedStatus08_01&0xf7;
	   }


       if(ucLed_dr5==1)
	   {
	      ucLedStatus08_01=ucLedStatus08_01|0x10;
	   }
	   else
	   {
	      ucLedStatus08_01=ucLedStatus08_01&0xef;
	   }


       if(ucLed_dr6==1)
	   {
	      ucLedStatus08_01=ucLedStatus08_01|0x20;
	   }
	   else
	   {
	      ucLedStatus08_01=ucLedStatus08_01&0xdf;
	   }


       if(ucLed_dr7==1)
	   {
	      ucLedStatus08_01=ucLedStatus08_01|0x40;
	   }
	   else
	   {
	      ucLedStatus08_01=ucLedStatus08_01&0xbf;
	   }


       if(ucLed_dr8==1)
	   {
	      ucLedStatus08_01=ucLedStatus08_01|0x80;
	   }
	   else
	   {
	      ucLedStatus08_01=ucLedStatus08_01&0x7f;
	   }

       if(ucLed_dr9==1)
	   {
	      ucLedStatus16_09=ucLedStatus16_09|0x01;
	   }
	   else
	   {
	      ucLedStatus16_09=ucLedStatus16_09&0xfe;
	   }

       if(ucLed_dr10==1)
	   {
	      ucLedStatus16_09=ucLedStatus16_09|0x02;
	   }
	   else
	   {
	      ucLedStatus16_09=ucLedStatus16_09&0xfd;
	   }

       if(ucLed_dr11==1)
	   {
	      ucLedStatus16_09=ucLedStatus16_09|0x04;
	   }
	   else
	   {
	      ucLedStatus16_09=ucLedStatus16_09&0xfb;
	   }

       if(ucLed_dr12==1)
	   {
	      ucLedStatus16_09=ucLedStatus16_09|0x08;
	   }
	   else
	   {
	      ucLedStatus16_09=ucLedStatus16_09&0xf7;
	   }


       if(ucLed_dr13==1)
	   {
	      ucLedStatus16_09=ucLedStatus16_09|0x10;
	   }
	   else
	   {
	      ucLedStatus16_09=ucLedStatus16_09&0xef;
	   }


       if(ucLed_dr14==1)
	   {
	      ucLedStatus16_09=ucLedStatus16_09|0x20;
	   }
	   else
	   {
	      ucLedStatus16_09=ucLedStatus16_09&0xdf;
	   }


       if(ucLed_dr15==1)
	   {
	      ucLedStatus16_09=ucLedStatus16_09|0x40;
	   }
	   else
	   {
	      ucLedStatus16_09=ucLedStatus16_09&0xbf;
	   }


       if(ucLed_dr16==1)
	   {
	      ucLedStatus16_09=ucLedStatus16_09|0x80;
	   }
	   else
	   {
	      ucLedStatus16_09=ucLedStatus16_09&0x7f;
	   }

       hc595_drive(ucLedStatus16_09,ucLedStatus08_01);  //74HC595底层驱动函数

   }
}


void display_drive()  
{
   //以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
   switch(ucDisplayDriveStep)
   {
      case 1:  //显示第1位
           ucDigShowTemp=dig_table[ucDigShow1];
                   if(ucDigDot1==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xfe);
               break;
      case 2:  //显示第2位
           ucDigShowTemp=dig_table[ucDigShow2];
                   if(ucDigDot2==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xfd);
               break;
      case 3:  //显示第3位
           ucDigShowTemp=dig_table[ucDigShow3];
                   if(ucDigDot3==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xfb);
               break;
      case 4:  //显示第4位
           ucDigShowTemp=dig_table[ucDigShow4];
                   if(ucDigDot4==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xf7);
               break;
      case 5:  //显示第5位
           ucDigShowTemp=dig_table[ucDigShow5];
                   if(ucDigDot5==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xef);
               break;
      case 6:  //显示第6位
           ucDigShowTemp=dig_table[ucDigShow6];
                   if(ucDigDot6==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0xdf);
               break;
      case 7:  //显示第7位
           ucDigShowTemp=dig_table[ucDigShow7];
                   if(ucDigDot7==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
           }
           dig_hc595_drive(ucDigShowTemp,0xbf);
               break;
      case 8:  //显示第8位
           ucDigShowTemp=dig_table[ucDigShow8];
                   if(ucDigDot8==1)
                   {
                      ucDigShowTemp=ucDigShowTemp|0x80;  //显示小数点
                   }
           dig_hc595_drive(ucDigShowTemp,0x7f);
               break;
   }

   ucDisplayDriveStep++;
   if(ucDisplayDriveStep>8)  //扫描完8个数码管后，重新从第一个开始扫描
   {
     ucDisplayDriveStep=1;
   }



}


//数码管的74HC595驱动函数
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
{
   unsigned char i;
   unsigned char ucTempData;
   dig_hc595_sh_dr=0;
   dig_hc595_st_dr=0;

   ucTempData=ucDigStatusTemp16_09;  //先送高8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)dig_hc595_ds_dr=1;
         else dig_hc595_ds_dr=0;

         dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         dig_hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   ucTempData=ucDigStatusTemp08_01;  //再先送低8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)dig_hc595_ds_dr=1;
         else dig_hc595_ds_dr=0;

         dig_hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         dig_hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   dig_hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
   delay_short(1); 
   dig_hc595_st_dr=1;
   delay_short(1); 

   dig_hc595_sh_dr=0;    //拉低，抗干扰就增强
   dig_hc595_st_dr=0;
   dig_hc595_ds_dr=0;

}


//LED灯的74HC595驱动函数
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
{
   unsigned char i;
   unsigned char ucTempData;
   hc595_sh_dr=0;
   hc595_st_dr=0;

   ucTempData=ucLedStatusTemp16_09;  //先送高8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)hc595_ds_dr=1;
         else hc595_ds_dr=0;

         hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   ucTempData=ucLedStatusTemp08_01;  //再先送低8位
   for(i=0;i<8;i++)
   { 
         if(ucTempData>=0x80)hc595_ds_dr=1;
         else hc595_ds_dr=0;

         hc595_sh_dr=0;     //SH引脚的上升沿把数据送入寄存器
         delay_short(1); 
         hc595_sh_dr=1;
         delay_short(1); 

         ucTempData=ucTempData<<1;
   }

   hc595_st_dr=0;  //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
   delay_short(1); 
   hc595_st_dr=1;
   delay_short(1); 

   hc595_sh_dr=0;    //拉低，抗干扰就增强
   hc595_st_dr=0;
   hc595_ds_dr=0;

}


void led_flicker_09_16() //第9个至第16个LED的跑马灯程序，逐个亮并且每次只能亮一个.
{
  if(ucLedStartFlag==1)  //此变量为1时代表启动
  {
     switch(ucLedStep_09_16)
     {
     case 0:
           if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
           {
               uiTimeCnt_09_16=0; //时间计数器清零

			   if(ucLedDirFlag==0)  //正方向
			   {
                  ucLed_dr16=0;  //第16个灭
                  ucLed_dr9=1;  //第9个亮

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=1; //切换到下一个步骤
			   }
			   else  //反方向
			   {
                  ucLed_dr15=1;  //第15个亮
                  ucLed_dr16=0;  //第16个灭

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=7; //返回上一个步骤
			   }
           }
           break;
     case 1:
           if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
           {
               uiTimeCnt_09_16=0; //时间计数器清零

			   if(ucLedDirFlag==0)  //正方向
			   {
                  ucLed_dr9=0;  //第9个灭
                  ucLed_dr10=1;  //第10个亮

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=2; //切换到下一个步骤
			   }
			   else  //反方向
			   {
                  ucLed_dr16=1;  //第16个亮
                  ucLed_dr9=0;  //第9个灭

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=0; //返回上一个步骤
			   }
           }
           break;
     case 2:
           if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
           {
               uiTimeCnt_09_16=0; //时间计数器清零

			   if(ucLedDirFlag==0)  //正方向
			   {
                  ucLed_dr10=0;  //第10个灭
                  ucLed_dr11=1;  //第11个亮

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=3; //切换到下一个步骤
			   }
			   else  //反方向
			   {
                  ucLed_dr9=1;  //第9个亮
                  ucLed_dr10=0;  //第10个灭

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=1; //返回上一个步骤
			   }
           }
           break;
     case 3:
           if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
           {
               uiTimeCnt_09_16=0; //时间计数器清零

			   if(ucLedDirFlag==0)  //正方向
			   {
                  ucLed_dr11=0;  //第11个灭
                  ucLed_dr12=1;  //第12个亮

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=4; //切换到下一个步骤
			   }
			   else  //反方向
			   {
                  ucLed_dr10=1;  //第10个亮
                  ucLed_dr11=0;  //第11个灭

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=2; //返回上一个步骤
			   }
           }
           break;
     case 4:
           if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
           {
               uiTimeCnt_09_16=0; //时间计数器清零

			   if(ucLedDirFlag==0)  //正方向
			   {
                  ucLed_dr12=0;  //第12个灭
                  ucLed_dr13=1;  //第13个亮

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=5; //切换到下一个步骤
			   }
			   else  //反方向
			   {
                  ucLed_dr11=1;  //第11个亮
                  ucLed_dr12=0;  //第12个灭

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=3; //返回上一个步骤
			   }
           }
           break;
     case 5:
           if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
           {
               uiTimeCnt_09_16=0; //时间计数器清零

			   if(ucLedDirFlag==0)  //正方向
			   {
                  ucLed_dr13=0;  //第13个灭
                  ucLed_dr14=1;  //第14个亮

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=6; //切换到下一个步骤
			   }
			   else  //反方向
			   {
                  ucLed_dr12=1;  //第12个亮
                  ucLed_dr13=0;  //第13个灭

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=4; //返回上一个步骤
			   }
           }
           break;
     case 6:
           if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
           {
               uiTimeCnt_09_16=0; //时间计数器清零

			   if(ucLedDirFlag==0)  //正方向
			   {
                  ucLed_dr14=0;  //第14个灭
                  ucLed_dr15=1;  //第15个亮

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=7; //切换到下一个步骤
			   }
			   else  //反方向
			   {
                  ucLed_dr13=1;  //第13个亮
                  ucLed_dr14=0;  //第14个灭

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=5; //返回上一个步骤
			   }
           }
           break;
     case 7:
           if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
           {
               uiTimeCnt_09_16=0; //时间计数器清零

			   if(ucLedDirFlag==0)  //正方向
			   {
                  ucLed_dr15=0;  //第15个灭
                  ucLed_dr16=1;  //第16个亮

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=0; //返回到开始处，重新开始新的一次循环
			   }
			   else  //反方向
			   {
                  ucLed_dr14=1;  //第14个亮
                  ucLed_dr15=0;  //第15个灭

                  ucLed_update=1;  //更新显示
                  ucLedStep_09_16=6; //返回上一个步骤
			   }
           }
           break;
    
      }
   }

}


void T0_time() interrupt 1
{
  TF0=0;  //清除中断标志
  TR0=0; //关中断


  if(uiTimeCnt_09_16<0xffff)  //设定这个条件，防止uiTimeCnt超范围。
  {
      if(ucLedStartFlag==1)  //此变量为1时代表启动
	  {
         uiTimeCnt_09_16++;  //累加定时中断的次数，
	  }
  }

  key_scan(); //按键扫描函数






  if(uiVoiceCnt!=0)
  {
     uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
     beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
//     beep_dr=1;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
  }
  else
  {
     ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
     beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
//     beep_dr=0;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
  }

  display_drive();  //数码管字模的驱动函数


  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
  TR0=1;  //开中断
}


void delay_short(unsigned int uiDelayShort) 
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


void delay_long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  //内嵌循环的空指令数量
          {
             ; //一个分号相当于执行一条空语句
          }
   }
}


void initial_myself()  //第一区 初始化单片机
{

/* 注释二：
* 矩阵键盘也可以做独立按键，前提是把某一根公共输出线输出低电平，
* 模拟独立按键的触发地，本程序中，把key_gnd_dr输出低电平。
* 朱兆祺51学习板的S1就是本程序中用到的一个独立按键。
*/
  key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平

  led_dr=0;  //关闭独立LED灯
  beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。

  TMOD=0x01;  //设置定时器0为工作方式1

  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;

}

void initial_peripheral() //第二区 初始化外围
{


   ucDigDot8=0;   //小数点全部不显示
   ucDigDot7=0;  
   ucDigDot6=0; 
   ucDigDot5=0;  
   ucDigDot4=0; 
   ucDigDot3=0;  
   ucDigDot2=0;
   ucDigDot1=0; 

   EA=1;     //开总中断
   ET0=1;    //允许定时中断
   TR0=1;    //启动定时中断

}

 

总结陈词：
    前面花了大量的章节在讲数码管显示，按键，运动的关联程序框架，从下一节开始，我将会用八节内容来讲我常用的串口程序框架，内容非常精彩和震撼，思路非常简单而又实用。欲知详情，请听下回分解-----判断数据尾来接收一串数据的串口通用程序框架。

（未完待续，下节更精彩，不要走开哦）

第三十八节：判断数据尾来接收一串数据的串口通用程序框架。

开场白：
    在实际项目中，串口通讯不可能一次通讯只发送或接收一个字节，大部分的项目都是一次发送或者接受一串的数据。我们还要在这一串数据里解析数据协议，提取有用的数据。
这一节要教会大家三个知识点：
第一个：如何识别一串数据已经发送接收完毕。
第二个：如何在已经接收到的一串数据中解析数据尾协议并且提取有效数据。
第三个：接收一串数据的通用程序框架涉及到main循环里的串口服务程序，定时器的计时程序，串口接收中断程序的密切配合。大家要理解它们三者之间是如何关联起来的。

具体内容，请看源代码讲解。

（1）硬件平台：
基于朱兆祺51单片机学习板。

（2）实现功能：

波特率是：9600 。 
通讯协议：XX YY  EB 00 55 
          其中后三位 EB 00 55就是我所说的数据尾，它的有效数据XX YY在数据尾的前面。
        任意时刻，单片机从电脑“串口调试助手”上位机收到的一串数据中，只要此数据中包含关键字EB00 55 ，并且此关键字前面两个字节的数据XX YY 分别为01 02,那么蜂鸣器鸣叫一声表示接收的数据尾和有效数据都是正确的。

（3）源代码讲解如下：

#include "REG52.H"


#define const_voice_short  40   //蜂鸣器短叫的持续时间
#define const_rc_size  10  //接收串口中断数据的缓冲区数组大小

#define const_receive_time  5  //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小

void initial_myself(void);    
void initial_peripheral(void);
void delay_long(unsigned int uiDelaylong);



void T0_time(void);  //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void);  //串口服务程序,在main函数里

sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

unsigned int  uiSendCnt=0;     //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1;    //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned int  uiRcregTotal=0;  //代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
unsigned int  uiRcMoveIndex=0;  //用来解析数据协议的中间变量


unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器



void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       usart_service();  //串口服务程序
   }

}


void usart_service(void)  //串口服务程序,在main函数里
{

        
/* 注释一：
 * 识别一串数据是否已经全部接收完了的原理:
 * 在规定的时间里，如果没有接收到任何一个字节数据，那么就认为一串数据被接收完了，然后就进入数据协议
 * 解析和处理的阶段。这个功能的实现要配合定时中断，串口中断的程序一起阅读，要理解他们之间的关系。
 */
     if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
     {

            ucSendLock=0;    //处理一次就锁起来，不用每次都进来,除非有新接收的数据

                    //下面的代码进入数据协议解析和数据处理的阶段

                    uiRcMoveIndex=uiRcregTotal; //由于是判断数据尾，所以下标移动变量从数组的最尾端开始向0移动
            while(uiRcMoveIndex>=5)   //如果处理的数据量大于等于5（2个有效数据，3个数据头）说明还没有把缓冲区的数据处理完
            {
               if(ucRcregBuf[uiRcMoveIndex-3]==0xeb&&ucRcregBuf[uiRcMoveIndex-2]==0x00&&ucRcregBuf[uiRcMoveIndex-1]==0x55)  //数据尾eb 00 55的判断
               {
                              if(ucRcregBuf[uiRcMoveIndex-5]==0x01&&ucRcregBuf[uiRcMoveIndex-4]==0x02)  //有效数据01 02的判断
                                  {
                                      uiVoiceCnt=const_voice_short; //蜂鸣器发出声音，说明数据尾和有效数据都接收正确
                                  }
                  break;   //退出循环
               }
               uiRcMoveIndex--; //因为是判断数据尾，下标向着0的方向移动
           }
                                         
           uiRcregTotal=0;  //清空缓冲的下标，方便下次重新从0下标开始接受新数据
  
     }
                         
}


void T0_time(void) interrupt 1    //定时中断
{
  TF0=0;  //清除中断标志
  TR0=0; //关中断


  if(uiSendCnt<const_receive_time)   //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完
  {
          uiSendCnt++;    //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
      ucSendLock=1;     //开自锁标志
  }

  if(uiVoiceCnt!=0)
  {
     uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
     beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。

  }
  else
  {
     ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
     beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
  }


  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
  TR0=1;  //开中断
}


void usart_receive(void) interrupt 4                 //串口接收数据中断        
{        

   if(RI==1)  
   {
        RI = 0;

            ++uiRcregTotal;
        if(uiRcregTotal>const_rc_size)  //超过缓冲区
        {
           uiRcregTotal=const_rc_size;
        }
        ucRcregBuf[uiRcregTotal-1]=SBUF;   //将串口接收到的数据缓存到接收缓冲区里
        uiSendCnt=0;  //及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
    
   }
   else  //我在其它单片机上都不用else这段代码的，可能在51单片机上多增加" TI = 0;"稳定性会更好吧。
   {
        TI = 0;
   }
                                                         
}                                


void delay_long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  //内嵌循环的空指令数量
          {
             ; //一个分号相当于执行一条空语句
          }
   }
}


void initial_myself(void)  //第一区 初始化单片机
{

  beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。

  //配置定时器
  TMOD=0x01;  //设置定时器0为工作方式1
  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;


  //配置串口
  SCON=0x50;
  TMOD=0X21;
  TH1=TL1=-(11059200L/12/32/9600);  //这段配置代码具体是什么意思，我也不太清楚，反正是跟串口波特率有关。
  TR1=1;

}

void initial_peripheral(void) //第二区 初始化外围
{

   EA=1;     //开总中断
   ES=1;     //允许串口中断
   ET0=1;    //允许定时中断
   TR0=1;    //启动定时中断

}

 

总结陈词：
     这一节讲了判断数据尾的程序框架，但是在大部分的项目中，都是通过判断数据头来接收数据的，这样的程序该怎么写？欲知详情，请听下回分解-----判断数据头来接收一串数据的串口通用程序框架。

（未完待续，下节更精彩，不要走开哦）

第三十九节：判断数据头来接收一串数据的串口通用程序框架。

开场白：
上一节讲了判断数据尾的程序框架，但是在大部分的项目中，都是通过判断数据头来接收数据的，这一节要教会大家两个知识点：
第一个：如何在已经接收到的一串数据中解析数据头协议并且提取有效数据。
第二个：无论是判断数据头还是判断数据尾，无论是单片机还是上位机，最好在固定协议前多发送一个填充的无效字节0x00，因为硬件原因，第一个字节往往容易丢失。

具体内容，请看源代码讲解。

（1）硬件平台：
基于朱兆祺51单片机学习板。

（2）实现功能：

波特率是：9600 。 
通讯协议：EB 00 55  XX YY  
加无效填充字节后,上位机实际上应该发送：00  EB 00 55  XX YY 
其中第1位00是无效填充字节，防止由于硬件原因丢失第一个字节。
其中第2,3,4位EB 00 55就是数据头
           后2位XX YY就是有效数据
任意时刻，单片机从电脑“串口调试助手”上位机收到的一串数据中，只要此数据中包含关键字EB 00 55 ，并且此关键字后面两个字节的数据XX YY 分别为01 02,那么蜂鸣器鸣叫一声表示接收的数据头和有效数据都是正确的。

（3）源代码讲解如下：

#include "REG52.H"


#define const_voice_short  40   //蜂鸣器短叫的持续时间
#define const_rc_size  10  //接收串口中断数据的缓冲区数组大小

#define const_receive_time  5  //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小

void initial_myself(void);    
void initial_peripheral(void);
void delay_long(unsigned int uiDelaylong);



void T0_time(void);  //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void);  //串口服务程序,在main函数里

sbit beep_dr=P2^7; //蜂鸣器的驱动IO口

unsigned int  uiSendCnt=0;     //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1;    //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned int  uiRcregTotal=0;  //代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
unsigned int  uiRcMoveIndex=0;  //用来解析数据协议的中间变量


unsigned int  uiVoiceCnt=0;  //蜂鸣器鸣叫的持续时间计数器



void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
       usart_service();  //串口服务程序
   }

}


void usart_service(void)  //串口服务程序,在main函数里
{

        
/* 注释一：
 * 识别一串数据是否已经全部接收完了的原理:
 * 在规定的时间里，如果没有接收到任何一个字节数据，那么就认为一串数据被接收完了，然后就进入数据协议
 * 解析和处理的阶段。这个功能的实现要配合定时中断，串口中断的程序一起阅读，要理解他们之间的关系。
 */
     if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
     {

            ucSendLock=0;    //处理一次就锁起来，不用每次都进来,除非有新接收的数据



                    //下面的代码进入数据协议解析和数据处理的阶段

                    uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动

/* 注释二：
 * 判断数据头，进入循环解析数据协议必须满足两个条件:
 * 第一：最大接收缓冲数据必须大于一串数据的长度（这里是5。包括2个有效数据，3个数据头）
 * 第二：游标uiRcMoveIndex必须小于等于最大接收缓冲数据减去一串数据的长度（这里是5。包括2个有效数据，3个数据头）
 */
            while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5)) 
            {
               if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
               {
                              if(ucRcregBuf[uiRcMoveIndex+3]==0x01&&ucRcregBuf[uiRcMoveIndex+4]==0x02)  //有效数据01 02的判断
                                  {
                                      uiVoiceCnt=const_voice_short; //蜂鸣器发出声音，说明数据头和有效数据都接收正确
                                  }
                  break;   //退出循环
               }
               uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
           }
                                         
           uiRcregTotal=0;  //清空缓冲的下标，方便下次重新从0下标开始接受新数据
  
     }
                         
}


void T0_time(void) interrupt 1    //定时中断
{
  TF0=0;  //清除中断标志
  TR0=0; //关中断


  if(uiSendCnt<const_receive_time)   //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完
  {
          uiSendCnt++;    //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
      ucSendLock=1;     //开自锁标志
  }

  if(uiVoiceCnt!=0)
  {
     uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
     beep_dr=0;  //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。

  }
  else
  {
     ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
     beep_dr=1;  //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
  }


  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;
  TR0=1;  //开中断
}


void usart_receive(void) interrupt 4                 //串口接收数据中断        
{        

   if(RI==1)  
   {
        RI = 0;

            ++uiRcregTotal;
        if(uiRcregTotal>const_rc_size)  //超过缓冲区
        {
           uiRcregTotal=const_rc_size;
        }
        ucRcregBuf[uiRcregTotal-1]=SBUF;   //将串口接收到的数据缓存到接收缓冲区里
        uiSendCnt=0;  //及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
    
   }
   else  //我在其它单片机上都不用else这段代码的，可能在51单片机上多增加" TI = 0;"稳定性会更好吧。
   {
        TI = 0;
   }
                                                         
}                                


void delay_long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  //内嵌循环的空指令数量
          {
             ; //一个分号相当于执行一条空语句
          }
   }
}


void initial_myself(void)  //第一区 初始化单片机
{

  beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。

  //配置定时器
  TMOD=0x01;  //设置定时器0为工作方式1
  TH0=0xfe;   //重装初始值(65535-500)=65035=0xfe0b
  TL0=0x0b;


  //配置串口
  SCON=0x50;
  TMOD=0X21;
  TH1=TL1=-(11059200L/12/32/9600);  //这段配置代码具体是什么意思，我也不太清楚，反正是跟串口波特率有关。
  TR1=1;

}

void initial_peripheral(void) //第二区 初始化外围
{

   EA=1;     //开总中断
   ES=1;     //允许串口中断
   ET0=1;    //允许定时中断
   TR0=1;    //启动定时中断

}

 

总结陈词：
     这一节讲了常用的判断数据头来接收一串数据的程序框架，但是在很多项目中，仅仅靠判断数据头还是不够的，必须要有更加详细的通讯协议，比如可以包含数据类型，有效数据长度，有效数据，数据校验的通讯协议。这样的程序该怎么写？欲知详情，请听下回分解-----常用的自定义串口通讯协议。

（未完待续，下节更精彩，不要走开哦）