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

#include "REG52.H"



#define const_N   8  //连续判断N次一致性滤波方法中，N的取值

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



void initial_myself(void);    

void initial_peripheral(void);

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); //显示数码管字模的驱动函数

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

//驱动LED的74HC595

void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);



void T0_time(void);  //定时中断函数



void ad_sampling_service(void); //AD采样与处理的服务程序





sbit led_dr=P3^5;  //LED灯

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







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;  





sbit adc0832_clk_dr     = P1^2;  // 定义adc0832的引脚

sbit adc0832_cs_dr      = P1^0;

sbit adc0832_data_sr_dr = P1^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 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 char ucAD=0;   //AD值

unsigned char ucCheckAD=0; //用来做校验对比的AD值





unsigned long ulTemp=0;  //参与换算的中间变量

unsigned long ulTempFilterV=0; //参与换算的中间变量

unsigned long ulBackupFilterV=5000;  //备份最新采样数据的中间变量

unsigned char ucSamplingCnt=0; //记录连续N次采样的计数器



unsigned long ulV=0; //未经滤波处理的实时电压值

unsigned long ulFilterV=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)  

   { 

      ad_sampling_service(); //AD采样与处理的服务程序

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

   }

}



void ad_sampling_service(void) //AD采样与处理的服务程序

{

    unsigned char i;



    ucAD=0;   //AD值

    ucCheckAD=0; //用来做校验对比的AD值





    /* 片选信号置为低电平 */

    adc0832_cs_dr = 0;



        /* 第一个脉冲，开始位 */

        adc0832_data_sr_dr = 1;

        adc0832_clk_dr  = 0;

    delay_short(1);

        adc0832_clk_dr  = 1;



        /* 第二个脉冲，选择通道 */

        adc0832_data_sr_dr = 1;

        adc0832_clk_dr  = 0;

        adc0832_clk_dr  = 1;



        /* 第三个脉冲，选择通道 */

        adc0832_data_sr_dr = 0;

        adc0832_clk_dr  = 0;

        adc0832_clk_dr  = 1;



    /* 数据线输出高电平 */

        adc0832_data_sr_dr = 1;

    delay_short(2);



        /* 第一个下降沿 */

        adc0832_clk_dr  = 1;

        adc0832_clk_dr  = 0;

    delay_short(1);





        /* AD值开始送出 */

        for (i = 0; i < 8; i++)

        {

        ucAD <<= 1;

                adc0832_clk_dr = 1;

                adc0832_clk_dr = 0;

                if (adc0832_data_sr_dr==1)

                {

            ucAD |= 0x01;

                }

        }



        /* 用于校验的AD值开始送出 */

        for (i = 0; i < 8; i++)

        {

        ucCheckAD >>= 1;

                if (adc0832_data_sr_dr==1)

                {

           ucCheckAD |= 0x80; 

                }

                adc0832_clk_dr = 1;

                adc0832_clk_dr = 0;

        }

        

        /* 片选信号置为高电平 */

        adc0832_cs_dr = 1;





        if(ucCheckAD==ucAD)  //检验相等

        {

        

            ulTemp=0;  //把char类型数据赋值给long类型数据之前，必须先清零

            ulTemp=ucAD; //把char类型数据赋值给long类型数据,参与乘除法运算的数据，为了避免运算结果溢出，我都用long类型



/* 注释一：

 * 因为保留3为小数点，这里的5000代表5.000V。ulTemp/255代表分辨率.

 * 有些书上说8位AD最高分辩可达到256级(0xff+1)，我认为这种说法是错误的。

 * 8位AD最高分辩应该是255级(0xff)，所以这里除以255，而不是256.

 */

            ulTemp=5000*ulTemp/255;  //进行电压换算

            ulV=ulTemp; //得到未经滤波处理的实时电压值

            ucWd1Part1Update=1; //局部更新显示未经滤波处理的电压





/* 注释二：

 * 以下连续判断N次一致性的滤波法，为了避免末尾小数点的数据偶尔跳动。

 * 这种滤波方法的原理跟我在按键扫描中的去抖动原理是一模一样的，被我频繁

 * 地应用在大量的工控项目中。

 * 具体原理：当某个采样变量发生变化时，有两种可能，一种可能是外界的一个瞬间干扰。

 * 另一种可能是变量确实发生变化。为了有效去除干扰，当发现变量有变化时，

 * 我会连续采集N次，如果连续N次都是一致的结果，我才认为不是干扰。如果中间

 * 只要出现一次不一致，我会马上把计数器清零，这一步是精华，很关键。

 * 

 */

                      if(ulTempFilterV!=ulTemp) //发现变量有变化

                     {

                        ucSamplingCnt++;    //计数器累加

                              if(ucSamplingCnt>const_N)  //如果连续N次都是一致的，则认为不是干扰。确实有数据需要更新显示。这里的const_N取值是8

                            {

                                ucSamplingCnt=0;



                                ulTempFilterV=ulTemp;   //及时保存更新了的数据，方便下一次有新数据对比做准备



                    ulFilterV=ulTempFilterV; //得到经过滤波处理的实时电压值

                    ucWd1Part2Update=1; //局部更新显示经过滤波处理的电压                         

                            }

                       }

                    else

                    {

                         ucSamplingCnt=0;  //只要出现一次不一致，我会马上把计数器清零，这一步是精华，很关键。

                    }







        

        }



}



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

{



                        if(ucWd1Part1Update==1)//未经滤波处理的实时电压更新显示

                        {

                           ucWd1Part1Update=0;



               ucTemp8=ulV%10000/1000;  //显示电压值个位

               ucTemp7=ulV%1000/100;    //显示电压值小数点后第1位

               ucTemp6=ulV%100/10;      //显示电压值小数点后第2位

               ucTemp5=ulV%10;          //显示电压值小数点后第3位





               ucDigShow8=ucTemp8; //数码管显示实际内容

               ucDigShow7=ucTemp7; 

               ucDigShow6=ucTemp6; 

               ucDigShow5=ucTemp5; 

                        }





                        if(ucWd1Part2Update==1)//经过滤波处理后的实时电压更新显示

                        {

                             ucWd1Part2Update=0;



               ucTemp4=ulFilterV%10000/1000;  //显示电压值个位

               ucTemp3=ulFilterV%1000/100;    //显示电压值小数点后第1位

               ucTemp2=ulFilterV%100/10;      //显示电压值小数点后第2位

               ucTemp1=ulFilterV%10;          //显示电压值小数点后第3位





               ucDigShow4=ucTemp4; //数码管显示实际内容

               ucDigShow3=ucTemp3; 

               ucDigShow2=ucTemp2; 

               ucDigShow1=ucTemp1; 

                        }





}







void display_drive(void)  

{

   //以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路

   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(void) interrupt 1   //定时中断

{

  TF0=0;  //清除中断标志

  TR0=0; //关中断





  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(void)  //第一区 初始化单片机

{

  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(void) //第二区 初始化外围

{



   ucDigDot8=1;   //显示未经过滤波电压的小数点

   ucDigDot7=0;  

   ucDigDot6=0; 

   ucDigDot5=0;  

   ucDigDot4=1;  //显示经过滤波后电压的小数点

   ucDigDot3=0;  

   ucDigDot2=0;

   ucDigDot1=0;



   EA=1;     //开总中断

   ET0=1;    //允许定时中断

   TR0=1;    //启动定时中断



}

#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();  //串口服务程序

   }



}



/* 注释一：

 * 以下函数说明了，在空函数里，可以插入很多个return语句。

 * 用return语句非常便于后续程序的升级修改。

 */

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

{



        



//     if(uiSendCnt>=const_receive_time&&ucSendLock==1) //原来的语句，现在被两个return语句替代了

//     {



       if(uiSendCnt<const_receive_time)  //延时还没超过规定时间，直接退出本程序，不执行return后的任何语句。

           {

              return;  //强行退出本子程序，不执行以下任何语句

           }



           if(ucSendLock==0)  //不是最新一次接受到串口数据，直接退出本程序，不执行return后的任何语句。

           {

              return;  //强行退出本子程序，不执行以下任何语句

           }

/* 注释二：

 * 以上两条return语句就相当于原来的一条if(uiSendCnt>=const_receive_time&&ucSendLock==1)语句。

 * 用了return语句后，就明显减少了一个if嵌套。

 */





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



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



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





 //           while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5)) //原来的语句，现在被两个return语句替代了

            while(1) //死循环可以被以下return或者break语句中断，return本身已经包含了break语句功能。

            {

               if(uiRcregTotal<5)  //串口接受到的数据太少

                           {

                              uiRcregTotal=0;  //清空缓冲的下标，方便下次重新从0下标开始接受新数据

                                  return;  //强行退出while(1)循环嵌套，直接退出本程序，不执行以下任何语句

                           }



                           if(uiRcMoveIndex>(uiRcregTotal-5)) //数组缓冲区的数据已经处理完

                           {

                              uiRcregTotal=0;  //清空缓冲的下标，方便下次重新从0下标开始接受新数据

                                  return;  //强行退出while(1)循环嵌套，直接退出本程序，不执行以下任何语句

                           }

/* 注释三：

 * 以上两条return语句就相当于原来的一条while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5))语句。

 * 以上两个return语句的用法，同时说明了return本身已经包含了break语句功能,不管当前处于几层的内部循环嵌套，

 * 都可以强行退出循环，并且直接退出本程序。

 */





               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;   //退出while(1)循环

               }

               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;    //启动定时中断



}