从业将近十年！手把手教你单片机程序框架（连载）

fshunj · 发表于 2014-3-10 19:28:37

支持一下,记得我转载过楼主的一篇文章.

jetli · 发表于 2014-3-10 19:43:43

纯膜拜下lz这在mcu行业耕耘了10年以上的牛人....

bbsview · 发表于 2014-3-10 20:13:55

超好的帖子，收藏并学习，感谢楼主的无私分享，祝好！

吴坚鸿 · 发表于 2014-3-10 20:25:42

第三十一节：数码管通过一二级菜单来设置数据的综合程序。

开场白：
上一节讲了二级菜单，这一节要教会大家两个知识点：
第一个：数码管通过一二级菜单来设置数据的综合程序框架。
第二个：继续加深熟悉鸿哥首次提出的“一二级菜单显示理论”：凡是人机界面显示，不管是数码管还是液晶屏，都可以把显示的内容分成不同的窗口来显示，每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单，用ucWd变量表示。局部就是二级菜单，用ucPart来表示。不同的窗口，会有不同的更新显示变量ucWdXUpdate来对应，表示整屏全部更新显示。不同的局部，也会有不同的更新显示变量ucWdXPartYUpdate来对应，表示局部更新显示。

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

（1）硬件平台：基于朱兆祺51单片机学习板。加按键对应S1键，减按键对应S5键，切换“光标闪烁”按键对应S9键，切换窗口按键对应S13键。

（2）实现功能：
   通过按键设置4个不同的参数。
有2个窗口。每个窗口显示2个参数。
第8,7,6,5位数码管显示”P-1 ”代表第1个窗口，显示”P-2 ”代表第2个窗口。第4,3位数码管显示该窗口下其中一个参数，第2,1位数码管显示该窗口下其中另外一个参数。每个参数的范围是从0到99。
有四个按键。
一个是切换窗口按键，依次按下此按键，会依次切换窗口显示。一个是“光标闪烁”按键，依次按下此按键，每两位数码管会依次处于闪烁的状态，哪两位数码管处于闪烁状态时，此时按加键或者减键就可以设置当前选中的参数。依次按下“光标闪烁”按键，数码管会在以下3种状态中循环：只有第4,3位数码管闪烁---只有第2,1位数码管闪烁---所有的数码管都不闪烁。

（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 //按键去抖动延时的时间

#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=0; //窗口2更新显示标志
unsigned char ucPart=0;//本程序的核心变量，局部显示变量。类似于二级菜单的变量。代表显示不同的局部。

unsigned char ucWd1Part1Update=0;  //在窗口1中，局部1的更新显示标志
unsigned char ucWd1Part2Update=0; //在窗口1中，局部2的更新显示标志
unsigned char ucWd2Part1Update=0; //在窗口2中，局部1的更新显示标志
unsigned char ucWd2Part2Update=0; //在窗口2中，局部2的更新显示标志

unsigned int  uiSetData1=0;  //本程序中需要被设置的参数1
unsigned int  uiSetData2=0;  //本程序中需要被设置的参数2
unsigned int  uiSetData3=0;  //本程序中需要被设置的参数3
unsigned int  uiSetData4=0;  //本程序中需要被设置的参数4

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;  //中间过渡变量

unsigned int  uiDpyTimeCnt=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(ucWd1Part1Update==1)  //仅仅参数1局部更新
                     {
                        ucWd1Part1Update=0; //及时清零标志，避免一直进来扫描

            ucTemp4=uiSetData1/10;  //第1个参数
            ucTemp3=uiSetData1%10;
                        if(uiSetData1<10)
                        {
                           ucDigShow4=10;
                        }
                        else
                        {
                           ucDigShow4=ucTemp4;
                        }
                        ucDigShow3=ucTemp3;
                     }

                     if(ucWd1Part2Update==1)  //仅仅参数2局部更新
                     {
                        ucWd1Part2Update=0;  //及时清零标志，避免一直进来扫描

            ucTemp2=uiSetData2/10;  //第2个参数
            ucTemp1=uiSetData2%10;
                        if(uiSetData2<10)
                        {
                           ucDigShow2=10;
                        }
                        else
                        {
                           ucDigShow2=ucTemp2;
                        }
                        ucDigShow1=ucTemp1;

                     }



/* 注释二：
* 必须注意局部更新和全部更新的编写顺序，局部更新应该写在全部更新之前，
* 当局部更新和全部更新同时发生时，这样就能保证到全部更新的优先响应。
*/

         if(ucWd1Update==1)  //窗口1要全部更新显示
                     {
            ucWd1Update=0;  //及时清零标志，避免一直进来扫描

            ucTemp8=12;  //显示P
            ucTemp7=11;  //显示-
            ucTemp6=1;  //显示1
            ucTemp5=10;  //显示空

            ucTemp4=uiSetData1/10;  //第1个参数
            ucTemp3=uiSetData1%10;

            ucTemp2=uiSetData2/10;  //第2个参数
            ucTemp1=uiSetData2%10;

            ucDigShow8=ucTemp8;
            ucDigShow7=ucTemp7;
            ucDigShow6=ucTemp6;
            ucDigShow5=ucTemp5;

                        if(uiSetData1<10)
                        {
                           ucDigShow4=10;
                        }
                        else
                        {
                           ucDigShow4=ucTemp4;
                        }
                        ucDigShow3=ucTemp3;

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



         }

                     //数码管闪烁
         switch(ucPart)  //根据局部变量的值，使对应的参数产生闪烁的动态效果。
                     {
                        case 0:  //2个参数都不闪烁

                              break;
                        case 1:  //第1个参数闪烁
                              if(uiDpyTimeCnt==const_dpy_time_half)
                                    {
                                 if(uiSetData1<10)       //数码管显示内容
                                 {
                                    ucDigShow4=10;
                                 }
                                 else
                                 {
                                    ucDigShow4=ucTemp4;
                                 }
                                 ucDigShow3=ucTemp3;
                                    }
                              else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
                                    {
                                       uiDpyTimeCnt=0; //及时把闪烁记时器清零

                                 ucDigShow4=10; //数码管显示空，什么都不显示
                                 ucDigShow3=10;

                                    }
                              break;
                        case 2: //第2个参数闪烁
                              if(uiDpyTimeCnt==const_dpy_time_half)
                                    {
                                 if(uiSetData2<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;

                     }

         break;
   case 2: //显示窗口2的数据

                     if(ucWd2Part1Update==1)  //在窗口2中，仅仅参数1局部更新
                     {
                        ucWd2Part1Update=0; //及时清零标志，避免一直进来扫描

            ucTemp4=uiSetData3/10;  //第3个参数
            ucTemp3=uiSetData3%10;
                        if(uiSetData3<10)
                        {
                           ucDigShow4=10;
                        }
                        else
                        {
                           ucDigShow4=ucTemp4;
                        }
                        ucDigShow3=ucTemp3;
                     }

                     if(ucWd2Part2Update==1)  //在窗口2中，仅仅参数2局部更新
                     {
                        ucWd2Part2Update=0;  //及时清零标志，避免一直进来扫描

            ucTemp2=uiSetData4/10;  //第4个参数
            ucTemp1=uiSetData4%10;
                        if(uiSetData4<10)
                        {
                           ucDigShow2=10;
                        }
                        else
                        {
                           ucDigShow2=ucTemp2;
                        }
                        ucDigShow1=ucTemp1;

                     }

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

            ucTemp8=12;  //显示P
            ucTemp7=11;  //显示-
            ucTemp6=2;  //显示2
            ucTemp5=10;  //显示空

            ucTemp4=uiSetData3/10;  //第3个参数
            ucTemp3=uiSetData3%10;

            ucTemp2=uiSetData4/10;  //第4个参数
            ucTemp1=uiSetData4%10;

            ucDigShow8=ucTemp8;
            ucDigShow7=ucTemp7;
            ucDigShow6=ucTemp6;
            ucDigShow5=ucTemp5;

                        if(uiSetData3<10)
                        {
                           ucDigShow4=10;
                        }
                        else
                        {
                           ucDigShow4=ucTemp4;
                        }
                        ucDigShow3=ucTemp3;

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



         }

                     //数码管闪烁
         switch(ucPart)  //根据局部变量的值，使对应的参数产生闪烁的动态效果。
                     {
                        case 0:  //2个参数都不闪烁

                              break;
                        case 1:  //第3个参数闪烁
                              if(uiDpyTimeCnt==const_dpy_time_half)
                                    {
                                 if(uiSetData3<10)       //数码管显示内容
                                 {
                                    ucDigShow4=10;
                                 }
                                 else
                                 {
                                    ucDigShow4=ucTemp4;
                                 }
                                 ucDigShow3=ucTemp3;
                                    }
                              else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
                                    {
                                       uiDpyTimeCnt=0; //及时把闪烁记时器清零

                                 ucDigShow4=10; //数码管显示空，什么都不显示
                                 ucDigShow3=10;

                                    }
                              break;
                        case 2: //第4个参数闪烁
                              if(uiDpyTimeCnt==const_dpy_time_half)
                                    {
                                 if(uiSetData4<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;

                     }

         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号键
   }
  }

  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:
               switch(ucPart)  //在窗口1下，根据不同的局部闪烁位置来设置不同的参数
                                 {
                                    case 0:
                                             break;
                                    case 1:
                        uiSetData1++;
                        if(uiSetData1>99) //最大值是99
                        {
                           uiSetData1=99;
                        }
                                                ucWd1Part1Update=1; //局部更新显示参数1
                                             break;
                                    case 2:
                        uiSetData2++;
                        if(uiSetData2>99) //最大值是99
                        {
                           uiSetData2=99;
                        }
                                                ucWd1Part2Update=1; //局部更新显示参数2
                                             break;
                                 }
               break;
            case 2:
               switch(ucPart)  //在窗口2下，根据不同的局部闪烁位置来设置不同的参数
                                 {
                                    case 0:
                                             break;
                                    case 1:
                        uiSetData3++;
                        if(uiSetData3>99) //最大值是99
                        {
                           uiSetData3=99;
                        }
                                                ucWd2Part1Update=1; //局部更新显示参数1
                                             break;
                                    case 2:
                        uiSetData4++;
                        if(uiSetData4>99) //最大值是99
                        {
                           uiSetData4=99;
                        }
                                                ucWd2Part2Update=1; //局部更新显示参数2
                                             break;
                                 }
               break;
      }
      uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
      ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
      break;

case 2:// 减按键对应朱兆祺学习板的S5键
      switch(ucWd)  //在不同的窗口下，设置不同的参数
      {
            case 1:
               switch(ucPart)  //在窗口1下，根据不同的局部闪烁位置来设置不同的参数
                                 {
                                    case 0:
                                             break;
                                    case 1:
                        uiSetData1--;
                        if(uiSetData1>99) //0减去1溢出肯定大于99
                        {
                           uiSetData1=0;
                        }
                                                ucWd1Part1Update=1; //局部更新显示参数1
                                             break;
                                    case 2:
                        uiSetData2--;
                        if(uiSetData2>99) //0减去1溢出肯定大于99
                        {
                           uiSetData2=0;
                        }
                                                ucWd1Part2Update=1; //局部更新显示参数2
                                             break;
                                 }
               break;
            case 2:
               switch(ucPart)  //在窗口2下，根据不同的局部闪烁位置来设置不同的参数
                                 {
                                    case 0:
                                             break;
                                    case 1:
                        uiSetData3--;
                        if(uiSetData3>99) //0减去1溢出肯定大于99
                        {
                           uiSetData3=0;
                        }
                                                ucWd2Part1Update=1; //局部更新显示参数1
                                             break;
                                    case 2:
                        uiSetData4--;
                        if(uiSetData4>99) //0减去1溢出肯定大于99
                        {
                           uiSetData4=0;
                        }
                                                ucWd2Part2Update=1; //局部更新显示参数2
                                             break;
                                 }
               break;
      }
      uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
      ucKeySec=0;  //响应按键服务处理程序后，按键编号清零，避免一致触发
      break;

case 3:// 切换"光标闪烁"按键对应朱兆祺学习板的S9键
      switch(ucWd)  //在不同的窗口下，设置不同的参数
      {
            case 1:  //在窗口1下，切换"光标闪烁"
               ucPart++;
                                 if(ucPart>2)
                                 {
                                 ucPart=0;
                                 }
                                 ucWd1Update=1;  //窗口1全部更新显示
               break;
            case 2:  //在窗口2下，切换"光标闪烁"
               ucPart++;
                                 if(ucPart>2)
                                 {
                                 ucPart=0;
                                 }
                                 ucWd2Update=1;  //窗口2全部更新显示
               break;
      }

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

case 4:// 切换窗口按键对应朱兆祺学习板的S13键
            ucWd++;
               if(ucWd>2)
               {
                  ucWd=1;
               }

               ucPart=0; //强行把局部变量复位，让新切换的窗口不闪烁

      switch(ucWd)  //在不同的窗口下，更新显示不同的窗口
      {
            case 1:  //在窗口1下
                                 ucWd1Update=1;  //窗口1全部更新显示
               break;
            case 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(); //按键扫描函数

  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;

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

}

总结陈词：
这节讲了数码管通过一二级菜单来设置数据的综合程序，鸿哥的人机界面程序框架基本上都涉及到了，为了继续加深熟悉鸿哥的“一二级菜单显示理论”，下一节会继续讲一个常用的数码管项目小程序，这个项目小程序鸿哥是怎么写的？欲知详情，请听下回分解-----数码管中的倒计时程序。

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

吴坚鸿 · 发表于 2014-3-10 20:27:32

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

开场白：
上一节讲了一二级菜单的综合程序，这一节要教会大家三个知识点：
第一个：通过本程序，继续加深理解按键与数码管的关联方法。
第二个：复习一下我在第五节教给大家的时间校正法。
第三个：继续加深熟悉鸿哥首次提出的“一二级菜单显示理论”：凡是人机界面显示，不管是数码管还是液晶屏，都可以把显示的内容分成不同的窗口来显示，每个显示的窗口中又可以分成不同的局部显示。其中窗口就是一级菜单，用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; //启动定时中断

}

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

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

吴坚鸿 · 发表于 2014-3-10 20:29:12

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

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

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

lcl · 发表于 2014-3-10 20:31:00

发烧友论坛就一直追你的帖子欢迎来到莫大的论坛读了你的帖子收获真的不少十分感谢啊

sunliezhi · 发表于 2014-3-10 20:36:34

楼主在实际项目中的按键部分代码也是这样：长、短按，组合键分开写的吗？

吴坚鸿 · 发表于 2014-3-10 20:38:38

sunliezhi 发表于 2014-3-10 20:36
楼主在实际项目中的按键部分代码也是这样：长、短按，组合键分开写的吗？ ...

根据客户的需要吧。基本的按键程序框架就是这样写的。

吴坚鸿 · 发表于 2014-3-10 20:39:17

fshunj 发表于 2014-3-10 19:28
支持一下,记得我转载过楼主的一篇文章.

谢谢你的支持。

ciximg · 发表于 2014-3-10 20:39:20

感谢分享、

YZDREAM8 · 发表于 2014-3-10 20:45:29

楼主是实用派人士。能毫无保留的分享自己的想法很不错。

shenzhoudadi · 发表于 2014-3-10 20:45:50

好牛哦！鸿哥，看你的

sunliezhi · 发表于 2014-3-10 20:53:09

楼主的家境应该不错

FD8000 · 发表于 2014-3-10 20:58:09

今天看到ZLG出的258元的开发板，突然想到，今后若出现100元的ARM9核心板带Linux/Wince操作系统后，开发模式会巨变，届时嵌入式系统也有128MB内存，不用考虑资源，不用考虑硬件驱动，而且考虑开发应用程序的速度，考虑产品上市的速度。

开发“单片机”程序将和开发PC机程序一样，设计模式、多线程程序设计将从PC领域直接进入嵌入式领域并成为主流，并统治高附加值的设备开发领域

单片机框架将成为历史...或被挤入极低附加值的且成本敏感的领域...

qiushui_007 · 发表于 2014-3-10 21:15:31

FD8000 发表于 2014-3-10 20:58
今天看到ZLG出的258元的开发板，突然想到，今后若出现100元的ARM9核心板带Linux/Wince操作系统后，开发模式 ...

绝对会实现的

FRED_YU · 发表于 2014-3-10 21:23:07

支持楼主，楼主辛苦

tangwei039 · 发表于 2014-3-10 21:29:37

支持一下

ds663 · 发表于 2014-3-10 21:31:14

火钳流明

agilentvee · 发表于 2014-3-10 21:32:51

不错不错

吴坚鸿 · 发表于 2014-3-10 22:08:28

FD8000 发表于 2014-3-10 20:58
今天看到ZLG出的258元的开发板，突然想到，今后若出现100元的ARM9核心板带Linux/Wince操作系统后，开发模式 ...

我也经常用我现在分享的单片机程序框架来帮一些客户开发PC端的上位机软件，虽然我是用VC帮他们开发上位机软件，但是我觉得我也用了很多单片机程序框架的思路。所以说，编程思想是灵魂，它永远都不会过时，不管你是开发单片机，还是开发嵌入式，还是开发PC端，它无处不在，放之四海而皆准。

leexu · 发表于 2014-3-10 22:12:27

搬个板凳，跟着学。

wjwjwjwj98 · 发表于 2014-3-10 22:39:18

必须欢迎，支持一下！

mdj-fish · 发表于 2014-3-10 22:54:00

看来楼主是想把单片机累死！！哈哈哈

Free_Bird · 发表于 2014-3-10 23:40:17

mcu_lover 发表于 2014-3-10 15:41
支持

能讲讲关于“按键最成熟的就是用FIFO环形缓冲”的思想么？
有链接也行；度娘没搜到

ouyj_0210 · 发表于 2014-3-10 23:48:58

标记一个，顶鸿哥

kyughanum · 发表于 2014-3-11 00:21:09

希望LZ能整理个PDF出来

hamipeter · 发表于 2014-3-11 00:24:27

顶一下！！！！

goolloo · 发表于 2014-3-11 00:45:39

本帖最后由 goolloo 于 2014-3-11 00:48 编辑

lz，教书教的好，不仅知识很重要，讲课方法也很重要。
论坛发帖要发号，不仅内容重要，排版也很重要。

大段的代码这样子看是不是清爽很多呢？

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

复制代码

kevin_me · 发表于 2014-3-11 01:55:49

看了两节，很实际也很有参考价值。给楼主提个建议，希望能把实例代码以附件形式上传，排好版，要不然一股脑的帖在帖子里面太影响阅读了。呵呵，要求可能有点过分，希望楼主能满足。多谢楼主分享，对广大电工真是好福利。

mcu_lover · 发表于 2014-3-11 08:38:59

Free_Bird 发表于 2014-3-10 23:40
能讲讲关于“按键最成熟的就是用FIFO环形缓冲”的思想么？
有链接也行；度娘没搜到 ...

仔细看完这个帖子，包括所有的回帖。
http://www.amobbs.com/thread-5542774-1-1.html

pchina8 · 发表于 2014-3-11 08:55:16

支持原创，你辛苦了，你无私的奉献精神，鼓舞着我们

menghong_4 · 发表于 2014-3-11 09:03:17

cool~~~~~~

吴坚鸿 · 发表于 2014-3-11 09:51:10

goolloo 发表于 2014-3-11 00:45
lz，教书教的好，不仅知识很重要，讲课方法也很重要。
论坛发帖要发号，不仅内容重要，排版也很重要。

谢谢你的建议，下一节我会注意的。

吴坚鸿 · 发表于 2014-3-11 09:51:46

kevin_me 发表于 2014-3-11 01:55
看了两节，很实际也很有参考价值。给楼主提个建议，希望能把实例代码以附件形式上传，排好版，要不然一股脑 ...

谢谢你的建议，下一节我会注意的。我发现大家好热心，再次表示感谢。

jiayue12450 · 发表于 2014-3-11 10:27:17

太多实用性的东西，谢谢楼主的无私奉献

dtdzlujian · 发表于 2014-3-11 11:10:40

支持LZ 初学者有福了

jiangkun0616 · 发表于 2014-3-11 11:12:23

站位！学习！

Smartist · 发表于 2014-3-11 13:24:21

阿莫我也是久闻大名，感觉还不错

zdhxzy1981 · 发表于 2014-3-11 13:26:55

好好学习学习，MARK!

lubyudf · 发表于 2014-3-11 13:32:15

LZ牛人有机会向LZ学习.

stone_mesnac · 发表于 2014-3-11 13:43:27

太好了，感谢lz

LeoJun0614 · 发表于 2014-3-11 13:53:34

支持一下

sunliezhi · 发表于 2014-3-11 14:13:24

mcu_lover 发表于 2014-3-11 08:38
仔细看完这个帖子，包括所有的回帖。
http://www.amobbs.com/thread-5542774-1-1.html

忠言逆耳啊，看来听得进的人不多呀

dantherman · 发表于 2014-3-11 22:35:41

Free_Bird 发表于 2014-3-10 23:40
能讲讲关于“按键最成熟的就是用FIFO环形缓冲”的思想么？
有链接也行；度娘没搜到 ...

同求
要用到

yyinfo263 · 发表于 2014-3-11 22:45:33

看着书学51都是单任务这种多任务操作还很少接触楼主的讲义非常实用谢谢了！！

期待后期更多好文出来！

yayagepei · 发表于 2014-3-12 12:44:36

写的很详细，膜拜中

Irving · 发表于 2014-3-12 13:04:05

太牛了一定要支持

yixin1851 · 发表于 2014-3-12 13:14:26

膜拜支持一下

MINI2440 · 发表于 2014-3-12 13:19:50

新手的福音！！！！！！！！！

starsnow · 发表于 2014-3-12 15:25:59

楼主是个热情和热于分享的人，在别的论坛都有见到过，欢迎并感谢~

xucilong · 发表于 2014-3-12 15:49:30

支持，先mark一下，有时间慢慢研究！

carollim · 发表于 2014-3-12 15:57:06

本帖最后由 carollim 于 2014-3-12 16:13 编辑

支持了在FS那边看过楼主大牛一只

yanwuhen · 发表于 2014-3-12 16:48:39

搬凳子，准备听课！先谢谢啦~

banyan_city · 发表于 2014-3-12 16:52:04

谢谢分享

Free_Bird · 发表于 2014-3-12 20:15:54

dantherman 发表于 2014-3-11 22:35
同求
要用到

仔细看完这个帖子，包括所有的回帖。
http://www.amobbs.com/thread-5542774-1-1.html

yxm433 · 发表于 2014-3-12 20:37:49

mark,谢谢分享

cld795 · 发表于 2014-3-12 23:00:31

MARK

ljt80158015 · 发表于 2014-3-12 23:04:19

支持一哈！！

吴坚鸿 · 发表于 2014-3-12 23:07:09

yyinfo263 发表于 2014-3-11 22:45
看着书学51都是单任务这种多任务操作还很少接触楼主的讲义非常实用谢谢了！！
期待后期更多好 ...

我一路走来，都是靠自己不断积累不断摸索的，积累到一定程度才形成现在的理论。我懂初学者缺什么，我知道他们需要什么。有好多朋友愿意花几千元让我教他两个星期怎么做项目，只是我平时项目缠身，实在抽不出太多时间来手把手教，因此我决定把它写出来，让它像病毒一样到处传播，让无数单片机初学者都获益。

xiaoliusheng · 发表于 2014-3-12 23:25:23

这个一定要顶，扫盲一下.

banyai · 发表于 2014-3-13 08:13:09

标记一下，学习。

wydking · 发表于 2014-3-13 13:27:31

支持一下！收藏了

ababvic · 发表于 2014-3-13 14:13:58

mark sp

xly · 发表于 2014-3-13 14:16:08

感谢无私奉献。先收藏了，有空好好看看，总有值得学习的地方。

老赵 · 发表于 2014-3-13 17:44:11

希望楼主能够更新1602液晶部分的讲解。

memstone · 发表于 2014-3-13 17:57:59

68336016 发表于 2014-3-10 13:09
半路出家人士来学习一下

偶也是，都金牌了，膜拜。

biying · 发表于 2014-3-13 19:09:57

吴坚鸿发表于 2014-3-12 23:07
我一路走来，都是靠自己不断积累不断摸索的，积累到一定程度才形成现在的理论。我懂初学者缺什么，我知道 ...

我是一个电工，这两天才买的马潮AVR学习板，你的代码我都看不懂，可是看你的例子的名字就很兴奋，谢谢楼主，先收藏起来以后再学习吧

jz701209李 · 发表于 2014-3-13 20:16:44

学习学习，谢谢

xou822 · 发表于 2014-3-13 22:14:10

马克一下先

hcqqlin · 发表于 2014-3-13 22:17:32

好贴，学习中。

newidea · 发表于 2014-3-13 23:23:25

好东西。
楼主做了这么多年，硬件方面是否也有类似心得？

wushifeng · 发表于 2014-3-13 23:55:33

收藏了…………

xymbmcu · 发表于 2014-3-13 23:56:49

直接顶起。

chp019479 · 发表于 2014-3-14 00:05:48

感谢分享！

canopen · 发表于 2014-3-14 00:32:49

epwwm 发表于 2014-3-10 12:01
“（2）很难记住繁杂的汇编语言指令？除非是在校学生要应付考试或者少数工作中绕不开汇编，否则学汇编就是 ...

顶你这句

nsj21n · 发表于 2014-3-14 08:52:14

佩服楼主这么博大的胸怀，将自己的宝贵经验倾囊相授，非常期待楼主的创作，我会经常来看看！

richsjh · 发表于 2014-3-14 10:42:23

非常感谢，崇拜呀

吴坚鸿 · 发表于 2014-3-14 12:59:10

newidea 发表于 2014-3-13 23:23
好东西。
楼主做了这么多年，硬件方面是否也有类似心得？

硬件方面也有一些。可能以后会另外开贴分享。

吴坚鸿 · 发表于 2014-3-14 13:09:36

nsj21n 发表于 2014-3-14 08:52
佩服楼主这么博大的胸怀，将自己的宝贵经验倾囊相授，非常期待楼主的创作，我会经常来看看！ ...

其实以前我年轻的时候也不愿意分享技术的，我想以后我的技术传男不传女，世世代代传下去。
后来我想开了，人生在世短短数十年，不管是技术还是金钱，生不带来死不带去，你只有把它分享出来才会对社会有价值有意义，
从而让你获得更大的心理满足。

ainiyifei · 发表于 2014-3-14 13:10:06

很好很强大向前辈学习

cd4000 · 发表于 2014-3-14 13:11:39

学习一下！

小谭 · 发表于 2014-3-14 16:37:29

值得学习，谢谢楼主！

nsj21n · 发表于 2014-3-14 18:26:49

吴坚鸿发表于 2014-3-14 13:09
其实以前我年轻的时候也不愿意分享技术的，我想以后我的技术传男不传女，世世代代传下去。
后来我想开了 ...

嗯，楼主说的在理。我工作了5年了，不管是兴趣还是为了工作我都一直愿意去学习一些东西，虽然可能没那么逻辑思维强，不管怎么说我还是喜欢单片机，喜欢调试成功那种成就感，部位别的，只为通过自己的努力成功。楼主的经验我要认真学习下，编程的精髓要掌握，活到老学到老！

hustwjg · 发表于 2014-3-14 18:34:07

辛苦好好学习一下

PADS菜鸟 · 发表于 2014-3-14 19:17:34

LZ,我在电子发烧友论坛看过你的文章，写的别具一格，很不错，向LZ学习。

小黑@电子 · 发表于 2014-3-14 21:22:56

鸿哥，看好你

4317mjh · 发表于 2014-3-14 21:45:57

本帖最后由 4317mjh 于 2014-3-14 21:48 编辑

很难记住繁杂的汇编语言指令？除非是在校学生要应付考试或者少数工作中绕不开汇编，否则学汇编就是浪费时间。我从来就没有用汇编帮客户做过一个项目这话，感觉不对。。。。。谁能说说汇编和C语言对于单片机的关系？？

4317mjh · 发表于 2014-3-14 21:46:26

本帖最后由 4317mjh 于 2014-3-14 21:48 编辑

。。。。。。。。。。。。。。

renmin · 发表于 2014-3-15 00:49:53

我业余爱好，写程序都是瞎编乱写，看了这个帖子受益匪浅，非常感谢分享这些经验和思维，辛苦了。

xyr · 发表于 2014-3-15 09:24:59

支持支持

gfy200866 · 发表于 2014-3-15 09:31:07

很全面的资料！

吴坚鸿 · 发表于 2014-3-15 09:52:18

本帖最后由吴坚鸿于 2014-3-15 09:58 编辑

第三十四节：在数码管中实现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学习板做了一个棋类比赛专用计时器给他们用，这个程序该怎么编写？欲知详情，请听下回分解-----带数码管显示的象棋比赛专用计时器。

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

cshm0101 · 发表于 2014-3-15 10:08:49

学习！！！

ayumi8 · 发表于 2014-3-15 10:26:41

哇哦～～～～哇噢～～～～～赞一个这个绝对好帖绝对火！！！！顶一个！！！！

三木 · 发表于 2014-3-15 10:53:25

玩转了

，必须顶！

BCE312 · 发表于 2014-3-15 10:58:42

这是一笔很大的财富！

苹果520 · 发表于 2014-3-15 11:02:16

先mark下，再顶一下，欢迎来阿莫

huilai · 发表于 2014-3-15 11:28:49

从业将近十年！手把手教你单片机程序框架（连载）
谢谢！学习

NC_Zyang · 发表于 2014-3-15 17:26:25

看看大侠的风格是怎么样的？

从业将近十年！手把手教你单片机程序框架（连载）

本帖子中包含更多资源