EEPW论坛

第五十八节：指针的第五大好处，指针在众多数组中的中转站作用。

 

开场白：

    单个变量数据之间可以通过一条指令任意自由赋值转移，但是数组之间不能通过一条指令直接赋值转移，必须用for等循环指令挨个把数组的数据一个一个来赋值转移，如果一个 函数中，有很多数组需要赋值转移，那就非常麻烦了，要用很多for语句，耗时。还好C语言里有个指针，它可以非常高效地来切换我们所需要的数组，起到很好的中转站作用。这一节要教大家一个知识点：指针在众多数组中的中转站作用。

 

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

 

（1）硬件平台：

基于朱兆祺51单片机学习板。

 

（2）实现功能：

在第57节的串口收发程序基础上修改。在串口接收函数中，以下代码有略微修改：

while(uiRcregTotal>=4&&uiRcMoveIndex<=(uiRcregTotal-4)) //注意，这里是4，不是上一节的5，因为只有eb 00 55 xx这4个数据

 

通过上位机来调用下位机对应的数组数据。

通过电脑串口调试助手，往单片机发送EB 00 55 XX 指令，其中EB 00 55是数据头，XX的取值范围是0x01 至 0x05，每个不同的值代表调用下位机不同的数组数据。0x01调用第1组数据，0x02调用第2组数据，0x05调用第5组数据。

第1组：11 12 13 14 15

第2组：21 22 23 24 25

第3组：31 32 33 34 35

第4组：41 42 43 44 45

第5组：51 52 53 54 55

 

下位机返回21个数据，前面5个是第1种不带指针函数返回的数据。中间5个是第2种不带指针函数返回的数据。最后5个是第3种带指针函数返回的数据。期间2组EE EE EE是各函数返回的数据分割线，为了方便观察，没实际意义。

比如电脑发送：EB 00 55 02

单片机就返回：21 22 23 24 25 EE EE EE 21 22 23 24 25 EE EE EE 21 22 23 24 25

 

波特率是：9600 。

 

（3）源代码讲解如下：

 

#include "REG52.H"


#define const_array_size  5  //参与排序的数组大小

#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 delay_short(unsigned int uiDelayShort); 


void T0_time(void);  //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void);  //串口服务程序,在main函数里
void send_array_1(unsigned char ucArraySec);  //第1种函数，不带指针
void send_array_2(unsigned char ucArraySec);  //第2种函数，不带指针
void send_array_3(unsigned char ucArraySec);  //第3种函数，带指针
void eusart_send(unsigned char ucSendData);


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;  //用来解析数据协议的中间变量

const unsigned char array_0x01[]={0x11,0x12,0x13,0x14,0x15}; //第1个常量数组
const unsigned char array_0x02[]={0x21,0x22,0x23,0x24,0x25}; //第2个常量数组
const unsigned char array_0x03[]={0x31,0x32,0x33,0x34,0x35}; //第3个常量数组
const unsigned char array_0x04[]={0x41,0x42,0x43,0x44,0x45}; //第4个常量数组
const unsigned char array_0x05[]={0x51,0x52,0x53,0x54,0x55}; //第5个常量数组

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

}

/* 注释一：
 * 第1种函数，内部不带指针，根据上位机相关的指令，
 * 直接返回对应的数组。由于不带指针，因此多用了5个for循环来搬运数组。
 * 比较耗程序ROM容量，也不够简洁清晰。
 */
void send_array_1(unsigned char ucArraySec) 
{
   unsigned int i;
   switch(ucArraySec)
   {
      case 1:  //直接返回第1个常量数组
               for(i=0;i<5;i++)
                   {
                      eusart_send(array_0x01[i]);
                   }
               break;
      case 2:  //直接返回第2个常量数组
               for(i=0;i<5;i++)
                   {
                      eusart_send(array_0x02[i]);
                   }
               break;
      case 3:  //直接返回第3个常量数组
               for(i=0;i<5;i++)
                   {
                      eusart_send(array_0x03[i]);
                   }
               break;
      case 4:  //直接返回第4个常量数组
               for(i=0;i<5;i++)
                   {
                      eusart_send(array_0x04[i]);
                   }
               break;   
      case 5:  //直接返回第5个常量数组
               for(i=0;i<5;i++)
                   {
                      eusart_send(array_0x05[i]);
                   }
               break;

   }
  
}


/* 注释二：
 * 第2种函数，内部不带指针，根据上位机相关的指令，
 * 先转移对应的数组放到一个中间变量数组，然后发送数组。
 * 由于不带指针，因此多用了6个for循环来搬运数组。
 * 跟第1种函数一样，比较耗程序ROM容量，也不够简洁清晰。
 */
void send_array_2(unsigned char ucArraySec)  //第2种函数，不带指针
{
   unsigned int i;
   unsigned char array_temp[5]; //临时中间数组
   switch(ucArraySec)
   {
      case 1:  //直接返回第1个常量数组
               for(i=0;i<5;i++)
                   {
                          array_temp[i]=array_0x01[i]; //先挨个把对应的数组数据转移到中间数组里
                   }
               break;
      case 2:  //直接返回第2个常量数组
               for(i=0;i<5;i++)
                   {
                          array_temp[i]=array_0x02[i]; //先挨个把对应的数组数据转移到中间数组里
                   }
               break;
      case 3:  //直接返回第3个常量数组
               for(i=0;i<5;i++)
                   {
                          array_temp[i]=array_0x03[i]; //先挨个把对应的数组数据转移到中间数组里
                   }
               break;
      case 4:  //直接返回第4个常量数组
               for(i=0;i<5;i++)
                   {
                          array_temp[i]=array_0x04[i]; //先挨个把对应的数组数据转移到中间数组里
                   }
               break;   
      case 5:  //直接返回第5个常量数组
               for(i=0;i<5;i++)
                   {
                          array_temp[i]=array_0x05[i]; //先挨个把对应的数组数据转移到中间数组里
                   }
               break;

   }

   for(i=0;i<5;i++)
   {
           eusart_send(array_temp[i]);  //把临时存放在中间数组的数据全部发送出去
   }

}

/* 注释三：
 * 第3种函数，内部带指针，根据上位机相关的指令，
 * 先把对应的数组首地址传递给一个中间指针，然后再通过
 * 指针把整个数组的数据发送出去，由于带指针，切换转移数组的数据非常快，
 * 只需传递一下首地址给指针就可以，非常高效，整个函数只用了1个for循环。
 * 跟前面第1,2种函数相比，更加节省程序容量，处理速度更加快，更加简洁。
 */
void send_array_3(unsigned char ucArraySec)  //第3种函数，带指针
{
   unsigned int i;
   unsigned char *p_array; //临时中间指针，作为数组的中转站，非常高效
   switch(ucArraySec)
   {
      case 1:  //直接返回第1个常量数组
                   p_array=array_0x01;  //把数组的首地址传递给指针，一个指令就可以，不用for来挨个搬移数据，高效!
               break;
      case 2:  //直接返回第2个常量数组
                   p_array=array_0x02;  //把数组的首地址传递给指针，一个指令就可以，不用for来挨个搬移数据，高效!
               break;
      case 3:  //直接返回第3个常量数组
                   p_array=array_0x03;  //把数组的首地址传递给指针，一个指令就可以，不用for来挨个搬移数据，高效!
               break;
      case 4:  //直接返回第4个常量数组
                   p_array=array_0x04;  //把数组的首地址传递给指针，一个指令就可以，不用for来挨个搬移数据，高效!
               break;   
      case 5:  //直接返回第5个常量数组
                   p_array=array_0x05;  //把数组的首地址传递给指针，一个指令就可以，不用for来挨个搬移数据，高效!
               break;

   }

   for(i=0;i<5;i++)
   {
           eusart_send(p_array[i]);  //通过指针把数组的数据全部发送出去
   }

}

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

     unsigned char i=0;   
     unsigned char ucWhichArray;
     if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
     {

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

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

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

            while(uiRcregTotal>=4&&uiRcMoveIndex<=(uiRcregTotal-4)) //注意，这里是4，不是上一节的5，因为只有eb 00 55 xx这4个数据
            {
               if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
               {

                   ucWhichArray=ucRcregBuf[uiRcMoveIndex+3]; //上位机需要返回的某个数组

                   send_array_1(ucWhichArray); //第1种函数返回数组的5个数据，不带指针

                   eusart_send(0xee);  //为了方便上位机观察，多发送3个字节ee ee ee作为分割线
                   eusart_send(0xee); 
                   eusart_send(0xee); 

                   send_array_2(ucWhichArray); //第2种函数返回数组的5个数据，不带指针

                   eusart_send(0xee);  //为了方便上位机观察，多发送3个字节ee ee ee作为分割线
                   eusart_send(0xee); 
                   eusart_send(0xee); 

                   send_array_3(ucWhichArray); //第3种函数返回数组的5个数据，带指针


                   break;   //退出循环
               }
               uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
           }
                                         
           uiRcregTotal=0;  //清空缓冲的下标，方便下次重新从0下标开始接受新数据
  
     }
                         
}

void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{

  ES = 0; //关串口中断
  TI = 0; //清零串口发送完成中断请求标志
  SBUF =ucSendData; //发送一个字节

  delay_short(400);  //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整

  TI = 0; //清零串口发送完成中断请求标志
  ES = 1; //允许串口中断

}



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


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



  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  //发送中断，及时把发送中断标志位清零
   {
        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 delay_short(unsigned int uiDelayShort) 
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


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

}

 

总结陈词：

通过前面几节的学习，基本上讲完了我平时用指针的所有心得体会。

下一节开始讲新内容。在前面一些章节中，我提到为了防止中断函数把某些共享数据破坏，在主函数中更改某个数据变量时，应该先关闭中断，修改完后再打开中断；我也提到了网友“红金龙吸味”关于原子锁的建议。经过这段时间的思考和总结，我发现不管是关中断开中断，还是原子锁，其实本质上都是程序在多进程中临界点的数据处理，原子锁在程序员中有个专用名词叫互斥量，而我引以为豪的状态机程序框架，主函数的switch语句，外加一个定时中断，本质上就是2个独立进程在不断切换并行运行。我觉得这个临界点处理的知识很重要，也很容易忽略，所以我决定专门用两节内容来讲讲这方面的知识应用。欲知详情，请听下回分解-----关中断和开中断在多进程临界点的应用。

 

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

第五十九节：串口程序第40,44,45节中存在一个bug，特此紧急公告。
                                 
   经过网友“intech2008”的提醒，在我之前发表的第40,44,45节串口接收程序中，在计算检验和的地方，存在一个不容易发觉的bug。
   原来的是：


  for(i=0;i<(3+1+2+uiRcSize);i++) //计算校验累加和
  {
      ucRcregBuf[uiRcMoveIndex+6+uiRcSize]=ucRcregBuf[uiRcMoveIndex+6+uiRcSize]+ucRcregBuf[i];
  }    


  应该改成:
  for(i=0;i<(3+1+2+uiRcSize);i++) //计算校验累加和
  {
      ucRcregBuf[uiRcMoveIndex+6+uiRcSize]=ucRcregBuf[uiRcMoveIndex+6+uiRcSize]+ucRcregBuf[uiRcMoveIndex+i];
  }    


  由于本连载技术文章在各大论坛发布和被转载，我没法做到处处提醒，不得不专门用一节内容来告知各位读者。


  下节预告-----关中断和开中断在多进程临界点的应用。


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

第六十节：用关中断和互斥量来保护多线程共享的全局变量。

 

开场白：

在前面一些章节中，我提到为了防止中断函数把某些共享数据破坏，在主函数中更改某个数据变量时，应该先关闭中断，修改完后再打开中断；我也提到了网友“红金龙吸味”关于原子锁的建议。经过这段时间的思考和总结，我发现不管是关中断开中断，还是原子锁，其实本质上都是程序在多进程中临界点的数据处理，原子锁有个专用名词叫互斥量，而我引以为豪的状态机程序框架，主函数的switch语句，外加一个定时中断，本质上就是2个独立进程在不断切换并行运行。

为什么要保护多线程共享的全局变量？因为，多个线程同时访问同一个全局变量，如果都是读取操作，则不会出现问题。如果一个线程负责改变此变量的值，而其他线程负责同时读取变量内容，则不能保证读取到的数据是经过写线程修改后的。

这一节要教大家一个知识点：如何用关中断和互斥量来保护多线程共享的全局变量。

 

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

 

（1）硬件平台：

基于朱兆祺51单片机学习板。

 

（2）实现功能：

在第5节的基础上略作修改，让蜂鸣器在前面3秒发生一次短叫报警，在后面6秒发生一次长叫报警，如此反复循环。

 

（3）源代码讲解如下：

 

#include "REG52.H"


#define const_time_3s 1332   //3秒钟的时间需要的定时中断次数
#define const_time_6s 2664   //6秒钟的时间需要的定时中断次数

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

void initial_myself();    
void initial_peripheral();
void delay_long(unsigned int uiDelaylong);
void led_flicker();
void alarm_run();   
void T0_time();  //定时中断函数

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

unsigned char ucAlarmStep=0; //报警的步骤变量
unsigned int  uiTimeAlarmCnt=0; //报警统计定时中断次数的延时计数器

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

unsigned char ucLock=0;     //互斥量，俗称原子锁
void main() 
  {
   initial_myself();  
   delay_long(100);   
   initial_peripheral(); 
   while(1)  
   { 
      alarm_run();   //报警器定时报警
   }

}


/* 注释一：
 * 保护多线程共享全局变量的原理：
 * 多个线程同时访问同一个全局变量，如果都是读取操作，则不会出现问题。如果一个线程负责改变此变量的值，
 * 而其他线程负责同时读取变量内容，则不能保证读取到的数据是经过写线程修改后的。
 * 鸿哥的基本程序框架都是两线程为主，一个是main函数线程，一个是定时函数线程。
 */

void alarm_run() //报警器的应用程序
{
  
  switch(ucAlarmStep)
  {
     case 0:

           if(uiTimeAlarmCnt>=const_time_3s) //时间到
           {
/* 注释二：
 * 用关中断来保护多线程共享的全局变量：
 * 因为uiTimeAlarmCnt和uiVoiceCnt都是unsigned int类型，本质上是由两个字节组成。
 * 在C语言中uiTimeAlarmCnt=0和uiVoiceCnt=const_voice_short看似一条指令，
 * 实际上经过编译之后它不只一条汇编指令。由于另外一个定时中断线程里也会对这个变量
 * 进行判断和操作，如果不禁止定时中断或者采取其它措施，定时函数往往会在主函数还没有
 * 结束操作共享变量前就去访问或处理这个共享变量，这就会引起冲突，导致系统运行异常。
 */
              ET0=0;  //禁止定时中断
              uiTimeAlarmCnt=0; //时间计数器清零
              uiVoiceCnt=const_voice_short;  //蜂鸣器短叫
			  ET0=1; //开启允许定时中断
              ucAlarmStep=1; //切换到下一个步骤
           }
           break;
     case 1:
           if(uiTimeAlarmCnt>=const_time_6s) //时间到
           {
/* 注释三：
 * 用互斥量来保护多线程共享的全局变量：
 * 我觉得，在这种场合，用互斥量比前面用关中断的方法更加好。
 * 因为一旦关闭了定时中断，整个中断函数就会在那一刻停止运行了，
 * 而加一个互斥量，既能保护全局变量，又能让定时中断函数正常运行，
 * 真是一举两得。
 */
		      ucLock=1;  //互斥量加锁。 俗称原子锁
              uiTimeAlarmCnt=0; //时间计数器清零
              uiVoiceCnt=const_voice_long;  //蜂鸣器长叫
		      ucLock=0; //互斥量解锁。  俗称原子锁

              ucAlarmStep=0; //返回到上一个步骤
           }
           break;
  }

}

void T0_time() interrupt 1
{
  TF0=0;  //清除中断标志
  TR0=0; //关中断
  
  if(ucLock==0) //互斥量判断
  {
     if(uiTimeAlarmCnt<0xffff)  //设定这个条件，防止uiTimeAlarmCnt超范围。
     {
         uiTimeAlarmCnt++;  //报警的时间计数器，累加定时中断的次数，
     }

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

  TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  TL0=0x2f;
  TR0=1;  //开中断
}


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()  //第一区 初始化单片机
{
  beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。

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


  TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  TL0=0x2f;

}
void initial_peripheral() //第二区 初始化外围
{
  EA=1;     //开总中断
  ET0=1;    //允许定时中断
  TR0=1;    //启动定时中断

}

 

总结陈词：

从下一节开始我准备用几章节的内容来讲常用的数学算法程序。这些程序经常要用在计算器，工控，以及高精度的仪器仪表等领域。C语言的语法中不是已经提供了+,-,*,/这些运算符号吗？为什么还要专门写算法程序？因为那些运算符只能进行简单的运算，一旦数据超过了unsigned long（4个字节）的范围就会出错。而解决这种问题的大数据算法程序是什么样的？欲知详情，请听下回分解----大数据的加法运算。

 

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

第六十一节：组合BCD码，非组合BCD码，以及数值三者之间的相互转换和关系。
开场白：

本来这一节打算讲大数据的加法运算的，但是考虑大数据运算的基础是非组合BCD码，所以多增加一节讲BCD码的内容。

计算机中的BCD码，经常使用的有两种格式，即组合BCD码，非组合BCD码。

组合BCD码，是将两位十进制数，存放在一个字节中，例如：十进制数51的存放格式是0101 0001。

非组合BCD码，是将一个字节的低四位编码表示十进制数的一位，而高4位都为0。例如：十进制数51的占用了两个字节的空间，存放格式为：00000101 00000001。
    这一节要教大家两个知识点：

第一个：如何编写组合BCD码，非组合BCD码，以及数值三者之间的相互转换函数。

第二个：通过转换函数的编写，重温前面几节所讲到的指针用法。

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

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

（2）实现功能：

波特率是：9600 。

通过电脑串口调试助手模拟上位机，往单片机发送EB 00 55 XX YY YY … YY YY  指令，其中EB 00 55是数据头，XX 是指令类型。YY是具体的数据。

指令类型01代表发送的是数值，需要转成组合BCD码和非组合BCD码，并且返回上位机显示。

指令类型02代表发送的是组合BCD码，需要转成数值和非组合BCD码，并且返回上位机显示。

指令类型03代表发送的是非组合BCD码，需要转成数值和组合BCD码，并且返回上位机显示。

返回上位机的数据中，中间3个数据EE EE EE是分割线，为了方便观察，没实际意义。

例如：十进制的数据52013140，它的十六进制数据是03 19 A8 54。

（a）上位机发送数据：eb 00 55 01 03 19 a8 54

单片机返回：52 01 31 40 EE EE EE 05 02 00 01 03 01 04 00

（b）上位机发送组合BCD码：eb 00 55 02 52 01 31 40

单片机返回：03 19 A8 54 EE EE EE 05 02 00 01 03 01 04 00

（c）发送非组合BCD码：eb 00 55 03 05 02 00 01 03 01 04 00

单片机返回：03 19 A8 54 EE EE EE 52 01 31 40

（3）源代码讲解如下：

 

#include "REG52.H"

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


/* 注释一：
 * 注意，此处的const_rc_size是20，比之前章节的缓冲区稍微改大了一点。
 */
#define const_rc_size  20  //接收串口中断数据的缓冲区数组大小

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

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


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


void eusart_send(unsigned char ucSendData);

void number_to_BCD4(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit4);//把数值转换成组合BCD码
void number_to_BCD8(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit8);//把数值转换成非组合BCD码
void BCD4_to_number(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucNumber); //组合BCD码转成数值
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD_bit8); //组合BCD码转成非组合BCD码
void BCD8_to_number(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucNumber); //非组合BCD码转成数值
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD_bit4); //非组合BCD码转成组合BCD码


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;  //用来解析数据协议的中间变量

/* 注释二：
 * 注意，本程序规定数值的最大范围是0至99999999
 * 数组中的数据。高位在数组下标大的方向，低位在数组下标小的方向。
 */
unsigned char ucBufferNumber[4]; //数值，用4个字节表示long类型的数值
unsigned char ucBufferBCB_bit4[4]; //组合BCD码
unsigned char ucBufferBCB_bit8[8]; //非组合BCD码

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

}

void number_to_BCD4(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit4)//把数值转换成组合BCD码
{
   unsigned long ulNumberTemp=0;
   unsigned char ucTemp=0;
   ulNumberTemp=p_ucNumber[3];  //把4个字节的数值合并成一个long类型数据
   ulNumberTemp=ulNumberTemp<<8;
   ulNumberTemp=ulNumberTemp+p_ucNumber[2];
   ulNumberTemp=ulNumberTemp<<8;
   ulNumberTemp=ulNumberTemp+p_ucNumber[1];
   ulNumberTemp=ulNumberTemp<<8;
   ulNumberTemp=ulNumberTemp+p_ucNumber[0];


   p_ucBCD_bit4[3]=ulNumberTemp%100000000/10000000;
   p_ucBCD_bit4[3]=p_ucBCD_bit4[3]<<4; //前半4位存第8位组合BCD码
   ucTemp=ulNumberTemp%10000000/1000000;
   p_ucBCD_bit4[3]=p_ucBCD_bit4[3]+ucTemp; //后半4位存第7位组合BCD码

   p_ucBCD_bit4[2]=ulNumberTemp%1000000/100000;
   p_ucBCD_bit4[2]=p_ucBCD_bit4[2]<<4; //前半4位存第6位组合BCD码
   ucTemp=ulNumberTemp%100000/10000;
   p_ucBCD_bit4[2]=p_ucBCD_bit4[2]+ucTemp;//后半4位存第5位组合BCD码

   p_ucBCD_bit4[1]=ulNumberTemp%10000/1000;
   p_ucBCD_bit4[1]=p_ucBCD_bit4[1]<<4; //前半4位存第4位组合BCD码
   ucTemp=ulNumberTemp%1000/100;
   p_ucBCD_bit4[1]=p_ucBCD_bit4[1]+ucTemp;//后半4位存第3位组合BCD码

   p_ucBCD_bit4[0]=ulNumberTemp%100/10;
   p_ucBCD_bit4[0]=p_ucBCD_bit4[0]<<4; //前半4位存第2位组合BCD码
   ucTemp=ulNumberTemp%10;
   p_ucBCD_bit4[0]=p_ucBCD_bit4[0]+ucTemp;//后半4位存第1位组合BCD码

}


void number_to_BCD8(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit8)//把数值转换成非组合BCD码
{
   unsigned long ulNumberTemp=0;
   ulNumberTemp=p_ucNumber[3];  //把4个字节的数值合并成一个long类型数据
   ulNumberTemp=ulNumberTemp<<8;
   ulNumberTemp=ulNumberTemp+p_ucNumber[2];
   ulNumberTemp=ulNumberTemp<<8;
   ulNumberTemp=ulNumberTemp+p_ucNumber[1];
   ulNumberTemp=ulNumberTemp<<8;
   ulNumberTemp=ulNumberTemp+p_ucNumber[0];

   p_ucBCD_bit8[7]=ulNumberTemp%100000000/10000000;//一个字节8位存储第8位非组合BCD码
   p_ucBCD_bit8[6]=ulNumberTemp%10000000/1000000;//一个字节8位存储第7位非组合BCD码
   p_ucBCD_bit8[5]=ulNumberTemp%1000000/100000;//一个字节8位存储第6位非组合BCD码
   p_ucBCD_bit8[4]=ulNumberTemp%100000/10000;//一个字节8位存储第5位非组合BCD码
   p_ucBCD_bit8[3]=ulNumberTemp%10000/1000;//一个字节8位存储第4位非组合BCD码
   p_ucBCD_bit8[2]=ulNumberTemp%1000/100;//一个字节8位存储第3位非组合BCD码
   p_ucBCD_bit8[1]=ulNumberTemp%100/10;//一个字节8位存储第2位非组合BCD码
   p_ucBCD_bit8[0]=ulNumberTemp%10;//一个字节8位存储第1位非组合BCD码

}


void BCD4_to_number(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucNumber) //组合BCD码转成数值
{
   unsigned long ulTmep;
   unsigned long ulSum;

   ulSum=0;  //累加和数值清零

   ulTmep=0;
   ulTmep=p_ucBCD_bit4[3];
   ulTmep=ulTmep>>4;  //把组合BCD码第8位分解出来
   ulTmep=ulTmep*10000000;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit4[3];
   ulTmep=ulTmep&0x0000000f;  //把组合BCD码第7位分解出来
   ulTmep=ulTmep*1000000;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit4[2];
   ulTmep=ulTmep>>4;  //把组合BCD码第6位分解出来
   ulTmep=ulTmep*100000;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit4[2];
   ulTmep=ulTmep&0x0000000f;  //把组合BCD码第5位分解出来
   ulTmep=ulTmep*10000;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit4[1];
   ulTmep=ulTmep>>4;  //把组合BCD码第4位分解出来
   ulTmep=ulTmep*1000;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit4[1];
   ulTmep=ulTmep&0x0000000f;  //把组合BCD码第3位分解出来
   ulTmep=ulTmep*100;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit4[0];
   ulTmep=ulTmep>>4;  //把组合BCD码第2位分解出来
   ulTmep=ulTmep*10;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit4[0];
   ulTmep=ulTmep&0x0000000f;  //把组合BCD码第1位分解出来
   ulTmep=ulTmep*1;
   ulSum=ulSum+ulTmep; //累加各位数值

   //以上代码非常有规律，有兴趣的读者也可以自己想办法把它压缩成一个for循环的函数，可以极大节省容量。

   p_ucNumber[3]=ulSum>>24;  //把long类型数据分解成4个字节
   p_ucNumber[2]=ulSum>>16;
   p_ucNumber[1]=ulSum>>8;
   p_ucNumber[0]=ulSum;
}



void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD_bit8) //组合BCD码转成非组合BCD码
{
   unsigned char ucTmep;

   ucTmep=p_ucBCD_bit4[3];
   p_ucBCD_bit8[7]=ucTmep>>4;    //把组合BCD码第8位分解出来
   p_ucBCD_bit8[6]=ucTmep&0x0f;  //把组合BCD码第7位分解出来

   ucTmep=p_ucBCD_bit4[2];
   p_ucBCD_bit8[5]=ucTmep>>4;    //把组合BCD码第6位分解出来
   p_ucBCD_bit8[4]=ucTmep&0x0f;  //把组合BCD码第5位分解出来

   ucTmep=p_ucBCD_bit4[1];
   p_ucBCD_bit8[3]=ucTmep>>4;    //把组合BCD码第4位分解出来
   p_ucBCD_bit8[2]=ucTmep&0x0f;  //把组合BCD码第3位分解出来

   ucTmep=p_ucBCD_bit4[0];
   p_ucBCD_bit8[1]=ucTmep>>4;    //把组合BCD码第2位分解出来
   p_ucBCD_bit8[0]=ucTmep&0x0f;  //把组合BCD码第1位分解出来

}



void BCD8_to_number(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucNumber) //非组合BCD码转成数值
{
   unsigned long ulTmep;
   unsigned long ulSum;

   ulSum=0;  //累加和数值清零

   ulTmep=0;
   ulTmep=p_ucBCD_bit8[7];
   ulTmep=ulTmep*10000000;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit8[6];
   ulTmep=ulTmep*1000000;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit8[5];
   ulTmep=ulTmep*100000;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit8[4];
   ulTmep=ulTmep*10000;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit8[3];
   ulTmep=ulTmep*1000;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit8[2];
   ulTmep=ulTmep*100;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit8[1];
   ulTmep=ulTmep*10;
   ulSum=ulSum+ulTmep; //累加各位数值

   ulTmep=0;
   ulTmep=p_ucBCD_bit8[0];
   ulTmep=ulTmep*1;
   ulSum=ulSum+ulTmep; //累加各位数值

   //以上代码非常有规律，有兴趣的读者也可以自己想办法把它压缩成一个for循环的函数，可以极大节省容量。

   p_ucNumber[3]=ulSum>>24;  //把long类型数据分解成4个字节
   p_ucNumber[2]=ulSum>>16;
   p_ucNumber[1]=ulSum>>8;
   p_ucNumber[0]=ulSum;
}



void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD_bit4) //非组合BCD码转成组合BCD码
{
   unsigned char ucTmep;

   ucTmep=p_ucBCD_bit8[7];    //把非组合BCD码第8位分解出来
   p_ucBCD_bit4[3]=ucTmep<<4;
   p_ucBCD_bit4[3]=p_ucBCD_bit4[3]+p_ucBCD_bit8[6];    //把非组合BCD码第7位分解出来

   ucTmep=p_ucBCD_bit8[5];    //把非组合BCD码第6位分解出来
   p_ucBCD_bit4[2]=ucTmep<<4;
   p_ucBCD_bit4[2]=p_ucBCD_bit4[2]+p_ucBCD_bit8[4];    //把非组合BCD码第5位分解出来

   ucTmep=p_ucBCD_bit8[3];    //把非组合BCD码第4位分解出来
   p_ucBCD_bit4[1]=ucTmep<<4;
   p_ucBCD_bit4[1]=p_ucBCD_bit4[1]+p_ucBCD_bit8[2];    //把非组合BCD码第3位分解出来

   ucTmep=p_ucBCD_bit8[1];    //把非组合BCD码第2位分解出来
   p_ucBCD_bit4[0]=ucTmep<<4;
   p_ucBCD_bit4[0]=p_ucBCD_bit4[0]+p_ucBCD_bit8[0];    //把非组合BCD码第1位分解出来
  
}

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

     unsigned char i=0;   

     if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
     {

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

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

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

            while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5)) 
            {
               if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
               {
                    switch(ucRcregBuf[uiRcMoveIndex+3])  //根据命令类型来进行不同的处理
					{
					   case 1:  //接收到的是数值，需要转成组合BCD码和非组合BCD码
                            for(i=0;i<4;i++)
                            {
                                ucBufferNumber[3-i]=ucRcregBuf[uiRcMoveIndex+4+i]; //从串口接收到的数据，注意，高位在数组下标大的方向
                            }
                            number_to_BCD4(ucBufferNumber,ucBufferBCB_bit4);//把数值转换成组合BCD码
                            number_to_BCD8(ucBufferNumber,ucBufferBCB_bit8);//把数值转换成非组合BCD码
                            for(i=0;i<4;i++)
                            {
                               eusart_send(ucBufferBCB_bit4[3-i]);  ////把组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
                            }
                            eusart_send(0xee);  //为了方便上位机观察，多发送3个字节ee ee ee作为分割线
                            eusart_send(0xee); 
                            eusart_send(0xee); 
                            for(i=0;i<8;i++)
                            {
                               eusart_send(ucBufferBCB_bit8[7-i]);  ////把非组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
                            }

					        break;
					   case 2:  //接收到的是组合BCD码，需要转成数值和非组合BCD码
                            for(i=0;i<4;i++)
                            {
                                ucBufferBCB_bit4[3-i]=ucRcregBuf[uiRcMoveIndex+4+i]; //从串口接收到的组合BCD码，注意，高位在数组下标大的方向
                            }
                            BCD4_to_number(ucBufferBCB_bit4,ucBufferNumber); //组合BCD码转成数值
                            BCD4_to_BCD8(ucBufferBCB_bit4,ucBufferBCB_bit8); //组合BCD码转成非组合BCD码
                            for(i=0;i<4;i++)
                            {
                               eusart_send(ucBufferNumber[3-i]);  ////把数值返回给上位机观察，注意，高位在数组下标大的方向
                            }
                            eusart_send(0xee);  //为了方便上位机观察，多发送3个字节ee ee ee作为分割线
                            eusart_send(0xee); 
                            eusart_send(0xee); 
                            for(i=0;i<8;i++)
                            {
                               eusart_send(ucBufferBCB_bit8[7-i]);  ////把非组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
                            }

					        break;
					   case 3:  //接收到的是非组合BCD码，需要转成数值和组合BCD码
                            for(i=0;i<8;i++)
                            {
                                ucBufferBCB_bit8[7-i]=ucRcregBuf[uiRcMoveIndex+4+i]; //从串口接收到的非组合BCD码，注意，高位在数组下标大的方向
                            }

                            BCD8_to_number(ucBufferBCB_bit8,ucBufferNumber); //非组合BCD码转成数值
                            BCD8_to_BCD4(ucBufferBCB_bit8,ucBufferBCB_bit4); //非组合BCD码转成组合BCD码
                            for(i=0;i<4;i++)
                            {
                               eusart_send(ucBufferNumber[3-i]);  ////把数值返回给上位机观察
                            }
                            eusart_send(0xee);  //为了方便上位机观察，多发送3个字节ee ee ee作为分割线，注意，高位在数组下标大的方向
                            eusart_send(0xee); 
                            eusart_send(0xee); 
                            for(i=0;i<4;i++)
                            {
                               eusart_send(ucBufferBCB_bit4[3-i]);  ////把组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
                            }

					        break;
					}

                    break;   //退出循环
               }
               uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
           }
                                         
           uiRcregTotal=0;  //清空缓冲的下标，方便下次重新从0下标开始接受新数据
  
     }
                         
}

void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{

  ES = 0; //关串口中断
  TI = 0; //清零串口发送完成中断请求标志
  SBUF =ucSendData; //发送一个字节

  delay_short(400);  //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整

  TI = 0; //清零串口发送完成中断请求标志
  ES = 1; //允许串口中断

}



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


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



  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  //发送中断，及时把发送中断标志位清零
   {
        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 delay_short(unsigned int uiDelayShort) 
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


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

}

 

总结陈词：

有了这一节非组合BCD的基础知识，下一节就开始讲大数据的算法程序。这些算法程序经常要用在计算器，工控，以及高精度的仪器仪表等领域。C语言的语法中不是已经提供了+,-,*,/这些运算符号吗？为什么还要专门写算法程序？因为那些运算符只能进行简单的运算，一旦数据超过了unsigned long（4个字节）的范围就会出错。而这种大数据算法的程序是什么样的？欲知详情，请听下回分解----大数据的加法运算。

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

第六十二节：大数据的加法运算。

开场白：

直接用C语言的“+”运算符进行加法运算时，“被加数”，“加数”，“和”，这三个数据的最大范围是unsigned long 类型，也就是数据最大范围是4个字节，十进制的范围是0至4294967295。一旦超过了这个范围，则运算会出错。因此，当进行大数据加法运算时，我们要额外编程序，实现大数据的算法。其实这种算法并不难，就是我们在小学里学的四则运算算法。
      我们先要弄清楚一个新的概念。不考虑小数点的情况下，数据有两种表现形式。一种是常用的变量形式，另外一种是上一节讲到的BCD码数组形式。变量的最大范围有限，而BCD码数组的形式是无限的，正因为这个特点，所以我们可以进行大数据运算。
    这一节要教大家两个知识点：
第一个：如何通过用for循环语句改写上一节的组合BCD码跟非组合BCD码的转换函数。
第二个：如何编写涉及到大数据加法运算的算法程序函数，同时也复习了指针的用途。

第三个：如何在串口程序中通过关键字来截取所需要的数据。

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

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

（2）实现功能：
波特率是：9600 。

通过电脑串口调试助手模拟上位机，往单片机发送组合BCD码的被加数和加数。单片机把组合BCD码的运算结果返回到上位机。最大范围4位，从0到9999，如果超范围则返回EE EE EE报错。往单片机发送的数据格式：EB 00 55 XX XX 0d 0a  YY YY  0d 0a指令，其中EB 00 55是数据头，XX 是被加数，可以是1个字节，也可以是2个字节。YY是加数，可以是1个字节，也可以是2个字节。0d 0a是固定的结束标志。
例如：
（a）1234+5678=6912

上位机发送数据：eb 00 55 12 34 0d 0a 56 78 0d 0a

单片机返回：69 12

（b）9999+56=10055  超过4位的9999，所以报错

上位机发送数据：eb 00 55 99 99  0d 0a 56 0d 0a

单片机返回：EE EE EE  表示出错了

（3）源代码讲解如下：

#include "REG52.H"


/* 注释一：
 * 本系统中，规定最大运算位数是4位。
 * 由于STC89C52单片机的RAM只有256个，也就是说系统的变量数最大
 * 不能超过256个，如果超过了这个极限，编译器就会报错。如果这个算法
 * 移植到stm32或者PIC等RAM比较大的单片机上，那么就可以把这个运算位数
 * 设置得更加大一点。
 */

#define  BCD4_MAX     2  //本系统中，规定的组合BCD码最大字节数，一个字节包含2位，因此4位有效运算数
#define  BCD8_MAX    (BCD4_MAX*2)  //本系统中，规定的非组合BCD码最大字节数，一个字节包含1位，因此4位有效运算数

#define const_rc_size  30  //接收串口中断数据的缓冲区数组大小

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

#define uchar unsigned char    //方便移植平台
#define ulong unsigned long   //方便移植平台

//如果在VC的平台模拟此算法，则都定义成int类型，如下：
//#define uchar int  
//#define ulong int 

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


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


void eusart_send(unsigned char ucSendData);

void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt); 
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt);

void ClearAllData(uchar ucARRAY_MAX,uchar *destData);
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX);
uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData);

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 char ucDataBCD4_1[BCD4_MAX]; //接收到的第1个数组合BCD码数组形式  这里是指被加数
unsigned char ucDataBCD4_cnt_1=0;  //接收到的第1个数组合BCD码数组的有效数据长度

unsigned char ucDataBCD4_2[BCD4_MAX]; //接收到的第2个数组合BCD码数组形式  这里是指加数
unsigned char ucDataBCD4_cnt_2=0;  //接收到的第2个数组合BCD码数组的有效数据长度

unsigned char ucDataBCD4_3[BCD4_MAX]; //接收到的第3个数组合BCD码数组形式  这里是指和
unsigned char ucDataBCD4_cnt_3=0;  //接收到的第3个数组合BCD码数组的有效数据长度


unsigned char ucDataBCD8_1[BCD8_MAX]; //接收到的第1个数非组合BCD码数组形式   这里是指被加数
unsigned char ucDataBCD8_cnt_1=0;  //接收到的第1个数非组合BCD码数组的有效数据长度

unsigned char ucDataBCD8_2[BCD8_MAX]; //接收到的第2个数非组合BCD码数组形式   这里是指加数
unsigned char ucDataBCD8_cnt_2=0;  //接收到的第2个数非组合BCD码数组的有效数据长度

unsigned char ucDataBCD8_3[BCD8_MAX]; //接收到的第3个数非组合BCD码数组形式   这里是指和
unsigned char ucDataBCD8_cnt_3=0;  //接收到的第3个数非组合BCD码数组的有效数据长度

unsigned char ucResultFlag=11; //运算结果标志，10代表计算结果超出范围出错，11代表正常。

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

}

/* 注释二：
 * 组合BCD码转成非组合BCD码。
 * 这里的变量ucBCD4_cnt代表组合BCD码的有效字节数.
 * 这里的变量*p_ucBCD8_cnt代表经过转换后，非组合BCD码的有效字节数，记得加地址符号&传址进去
 * 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
 * 同时引进了组合BCD码的有效字节数变量。这样就不限定了数据的长度，
 * 可以让我们根据数据的实际大小灵活运用。
 */
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt) 
{
   unsigned char ucTmep;
   unsigned char i;

   for(i=0;i<BCD8_MAX;i++)   //先把即将保存转换结果的缓冲区清零
   {
      p_ucBCD_bit8[i]=0;
   } 


   *p_ucBCD8_cnt=ucBCD4_cnt*2; //转换成非组合BCD码后的有效数据长度  

   for(i=0;i<ucBCD4_cnt;i++)
   {
      ucTmep=p_ucBCD_bit4[ucBCD4_cnt-1-i];
      p_ucBCD_bit8[ucBCD4_cnt*2-i*2-1]=ucTmep>>4;    
      p_ucBCD_bit8[ucBCD4_cnt*2-i*2-2]=ucTmep&0x0f;  
   }

}


/* 注释三：
 * 非组合BCD码转成组合BCD码。
 * 这里的变量ucBCD8_cnt代表非组合BCD码的有效字节数.
 * 这里的变量*p_ucBCD4_cnt代表经过转换后，组合BCD码的有效字节数，记得加地址符号&传址进去
 * 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
 * 同时引进了非组合BCD码的有效字节数变量。这样就不限定了数据的长度，
 * 可以让我们根据数据的实际大小灵活运用。
 */
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt) 
{
   unsigned char ucTmep;
   unsigned char i;
   unsigned char ucBCD4_cnt; 

   for(i=0;i<BCD4_MAX;i++)   //先把即将保存转换结果的缓冲区清零
   {
      p_ucBCD_bit4[i]=0;
   } 

   ucBCD4_cnt=(ucBCD8_cnt+1)/2; //非组合BCD码转化成组合BCD码的有效数,这里+1避免非组合数据长度是奇数位
   *p_ucBCD4_cnt=ucBCD4_cnt; //把转换后的结果付给接口指针的数据，可以对外输出结果

   for(i=0;i<ucBCD4_cnt;i++)
   {
      ucTmep=p_ucBCD_bit8[ucBCD4_cnt*2-1-i*2];    //把非组合BCD码第8位分解出来
      p_ucBCD_bit4[ucBCD4_cnt-1-i]=ucTmep<<4;
      p_ucBCD_bit4[ucBCD4_cnt-1-i]=p_ucBCD_bit4[ucBCD4_cnt-1-i]+p_ucBCD_bit8[ucBCD4_cnt*2-2-i*2];    //把非组合BCD码第7位分解出来
   }
  
}

/* 注释四：
 *函数介绍：清零数组的全部数组数据
 *输入参数：ucARRAY_MAX代表数组定义的最大长度
 *输入输出参数：*destData--被清零的数组。
 */

void ClearAllData(uchar ucARRAY_MAX,uchar *destData)
{
  uchar i;

  for(i=0;i<ucARRAY_MAX;i++)
  {
     destData[i]=0;
  }

}


/* 注释五：
 *函数介绍：获取数组的有效长度
 *输入参数：*destData--被获取的数组。
 *输入参数：ucARRAY_MAX代表数组定义的最大长度
 *返回值  ：返回数组的有效长度。比如58786这个数据的有效长度是5
 *电子开发者作者：吴坚鸿
 */
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX)
{
  uchar i;
  uchar DataLength=ucARRAY_MAX;
  for(i=0;i<ucARRAY_MAX;i++)
  {
      if(0!=destData[ucARRAY_MAX-1-i])
          {
             break;
          }
          else
          {
             DataLength--;
          }

  }

  return DataLength;

}



/* 注释六：
*函数介绍：两个数相加
*输入参数：
*（1）*destData--被加数的数组。
*（2）*sourceData--加数的数组。
*（3）*resultData--和的数组。注意，调用本函数前，必须先把这个数组清零
*返回值  ：10代表计算结果超出范围出错，11代表正常。
*/
uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar addResult=11; //开始默认返回的运算结果是正常
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;
uchar carryData=0;  //进位
uchar maxCnt=0; //最大位数
uchar resultTemp=0; //存放临时运算结果的中间变量

//为什么不在本函数内先把resultData数组清零？因为后面章节中的乘法运算中要用到此函数实现连加功能。
//因此如果纯粹实现加法运算时，在调用本函数之前，必须先在外面把和的数组清零，否则会计算出错。

destCnt=GetDataLength(destData,BCD8_MAX);   //获取被加数的有效位数
sourceCnt=GetDataLength(sourceData,BCD8_MAX);  //获取加数的有效位数

if(destCnt>=sourceCnt)  //找出两个运算数据中最大的有效位数
{
   maxCnt=destCnt;
}
else 
{
   maxCnt=sourceCnt;
}

for(i=0;i<maxCnt;i++)
{
   resultTemp=destData[i]+sourceData[i]+carryData; //按位相加
   resultData[i]=resultTemp%10;   //截取最低位存放进保存结果的数组
   carryData=resultTemp/10;    //存放进位 
}

resultData[i]=carryData;

if((maxCnt==BCD8_MAX)&&(carryData==1))  //如果数组的有效位是最大值并且最后的进位是1，则计算溢出报错
{

  ClearAllData(BCD8_MAX,resultData);

  addResult=10;  //报错
}


return addResult;
}




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

     unsigned char i=0;   
     unsigned char k=0;   
	 unsigned char ucGetDataStep=0;

     if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
     {

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

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

            uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
            while(uiRcMoveIndex<uiRcregTotal)  //说明还没有把缓冲区的数据读取完
            {
               if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
               {
                    
				   i=0;
				   ucGetDataStep=0;
                   ucDataBCD4_cnt_1=0;  //第1个数组合BCD码数组的有效数据长度
                   ucDataBCD4_cnt_2=0;  //第2个数组合BCD码数组的有效数据长度

				   ClearAllData(BCD4_MAX,ucDataBCD4_1);  //清零第1个参与运算的数据
				   ClearAllData(BCD4_MAX,ucDataBCD4_2);  //清零第2个参与运算的数据

                   //以下while循环是通过关键字0x0d 0x0a来截取第1个和第2个参与运算的数据。
				   while(i<(BCD8_MAX+4))//这里+4是因为有2对0x0d 0x0a结尾特殊符号，一个共4个字节
				   {
					   if(ucGetDataStep==0)//步骤0，相当于我平时用的case 0,获取第1个数，在这里是指被加数
					   {
							 if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
							 {
                                for(k=0;k<ucDataBCD4_cnt_1;k++) //提取第1个参与运算的数组数据
								{
								   ucDataBCD4_1[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的 
								}
																			
								i=i+2; //跳过 0x0d 0x0a 这两个字节，进行下一轮的关键字提取
							    ucGetDataStep=1;  //切换到下一个关键字提取的步骤

                             }
							 else
							 {
								i++;
								ucDataBCD4_cnt_1++;  //统计第1个有效数据的长度
                             }
															 
					     }
						 else if(ucGetDataStep==1) //步骤1，相当于我平时用的case 1,获取第2个参与运行的数，在这里是加数
						 {
						 	 if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
							 {
                                for(k=0;k<ucDataBCD4_cnt_2;k++) //提取第2个参与运算的数组数据
								{
								   ucDataBCD4_2[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的 
								}
																			
                                break; //截取数据完成。直接跳出截取数据的while(i<(BCD8_MAX+4))循环

                             }
							 else
							 {
								i++;
								ucDataBCD4_cnt_2++;  //统计第2个有效数据的长度
                             }
                         }
                    }


                    //注意ucDataBCD8_cnt_1和ucDataBCD8_cnt_2要带地址符号&传址进去
                    BCD4_to_BCD8(ucDataBCD4_1,ucDataBCD4_cnt_1,ucDataBCD8_1,&ucDataBCD8_cnt_1); //把接收到的组合BCD码转换成非组合BCD码  第1个数 
                    BCD4_to_BCD8(ucDataBCD4_2,ucDataBCD4_cnt_2,ucDataBCD8_2,&ucDataBCD8_cnt_2); //把接收到的组合BCD码转换成非组合BCD码  第2个数


				    ClearAllData(BCD8_MAX,ucDataBCD8_3);  //清零第3个参与运算的数据,用来接收运行的结果
					ucResultFlag=AddData(ucDataBCD8_1,ucDataBCD8_2,ucDataBCD8_3); //相加运算，结果放在ucDataBCD8_3数组里

					if(ucResultFlag==11) //表示运算结果没有超范围
					{
                       ucDataBCD8_cnt_3=GetDataLength(ucDataBCD8_3,BCD8_MAX);  //获取和的有效字节数
					   BCD8_to_BCD4(ucDataBCD8_3,ucDataBCD8_cnt_3,ucDataBCD4_3,&ucDataBCD4_cnt_3); //把非组合BCD码转成组合BCD码。注意，&ucDataBCD4_cnt_3带地址符号&
                       for(k=0;k<ucDataBCD4_cnt_3;k++) //返回运算结果到上位机上观察。看到的是组合BCD码形式。返回的时候注意数组下标的顺序要反过来发送，先发高位的下标数组
				 	   {
				  	      eusart_send(ucDataBCD4_3[ucDataBCD4_cnt_3-1-k]); //往上位机发送一个字节的函数
					   }
					}
					else //运算结果超范围，返回EE EE EE
					{
				  	   eusart_send(0xee); //往上位机发送一个字节的函数
				  	   eusart_send(0xee); //往上位机发送一个字节的函数
				  	   eusart_send(0xee); //往上位机发送一个字节的函数
					}

                    break;   //退出循环
               }
               uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
           }

           ucRcregBuf[0]=0; //把数据头清零，方便下次接收判断新数据
		   ucRcregBuf[1]=0;
		   ucRcregBuf[2]=0;          
                  
           uiRcregTotal=0;  //清空缓冲的下标，方便下次重新从0下标开始接受新数据
  
     }
                         
}

void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{

  ES = 0; //关串口中断
  TI = 0; //清零串口发送完成中断请求标志
  SBUF =ucSendData; //发送一个字节

  delay_short(400);  //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整

  TI = 0; //清零串口发送完成中断请求标志
  ES = 1; //允许串口中断

}



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


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



  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  //发送中断，及时把发送中断标志位清零
   {
        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 delay_short(unsigned int uiDelayShort) 
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


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

}

 

总结陈词： 

既然这节讲了加法程序，那么下一节接着讲常用的减法程序，这种大数据的减法程序是什么样的？欲知详情，请听下回分解----大数据的减法运算。

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

第六十三节：大数据的减法运算。

开场白：

直接用C语言的“-”运算符进行加法运算时，“被减数”，“ 减数”，“差”，这三个数据的最大范围是unsigned long 类型，也就是数据最大范围是4个字节，十进制的范围是0至4294967295。一旦超过了这个范围，则运算会出错。因此，当进行大数据减法运算时，我们要额外编程序，实现大数据的算法。其实这种算法并不难，就是我们在小学里学的四则运算算法。
      我们先要弄清楚一个新的概念。不考虑小数点的情况下，数据有两种表现形式。一种是常用的变量形式，另外一种是BCD码数组形式。变量的最大范围有限，而BCD码数组的形式是无限的，正因为这个特点，所以我们可以进行大数据运算。
    这一节要教大家两个知识点：

第一个：如何编写比较两个非组合BCD码数据的大小。
第二个：如何编写涉及到大数据减法运算的算法程序函数，同时也复习了指针的用途。

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

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

（2）实现功能：
波特率是：9600 。

通过电脑串口调试助手模拟上位机，往单片机发送组合BCD码的被减数和减数。单片机把组合BCD码的运算结果返回到上位机。最大范围4位，从0到9999，如果被减数小于减数则返回EE EE EE报错。往单片机发送的数据格式：EB 00 55 XX XX 0d 0a  YY YY  0d 0a指令，其中EB 00 55是数据头，XX 是被减数，可以是1个字节，也可以是2个字节。YY是减数，可以是1个字节，也可以是2个字节。0d 0a是固定的结束标志。
例如：
（a）8259 – 5267 = 2992

上位机发送数据：eb 00 55 82 59 0d 0a  52 67 0d 0a

单片机返回：29 92

（b）5267 - 8259=小于0  所以报错

上位机发送数据：eb 00 55  52 67 0d 0a  82 59 0d 0a

单片机返回：EE EE EE  表示出错了

（3）源代码讲解如下：

#include "REG52.H"


/* 注释一：
 * 本系统中，规定最大运算位数是4位。
 * 由于STC89C52单片机的RAM只有256个，也就是说系统的变量数最大
 * 不能超过256个，如果超过了这个极限，编译器就会报错。如果这个算法
 * 移植到stm32或者PIC等RAM比较大的单片机上，那么就可以把这个运算位数
 * 设置得更加大一点。
 */

#define  BCD4_MAX     2  //本系统中，规定的组合BCD码最大字节数，一个字节包含2位，因此4位有效运算数
#define  BCD8_MAX    (BCD4_MAX*2)  //本系统中，规定的非组合BCD码最大字节数，一个字节包含1位，因此4位有效运算数

#define const_rc_size  30  //接收串口中断数据的缓冲区数组大小

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

#define uchar unsigned char    //方便移植平台
#define ulong unsigned long   //方便移植平台

//如果在VC的平台模拟此算法，则都定义成int类型，如下：
//#define uchar int  
//#define ulong int 

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


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


void eusart_send(unsigned char ucSendData);

void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt); 
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt);

void ClearAllData(uchar ucARRAY_MAX,uchar *destData);
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX);
uchar CmpData(const uchar *destData,const uchar *sourceData); //比较两个数的大小
uchar SubData(const uchar *destData,const uchar *sourceData,uchar *resultData);//两个数相减

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 char ucDataBCD4_1[BCD4_MAX]; //接收到的第1个数组合BCD码数组形式  这里是指被减数
unsigned char ucDataBCD4_cnt_1=0;  //接收到的第1个数组合BCD码数组的有效数据长度

unsigned char ucDataBCD4_2[BCD4_MAX]; //接收到的第2个数组合BCD码数组形式  这里是指减数
unsigned char ucDataBCD4_cnt_2=0;  //接收到的第2个数组合BCD码数组的有效数据长度

unsigned char ucDataBCD4_3[BCD4_MAX]; //接收到的第3个数组合BCD码数组形式  这里是指差
unsigned char ucDataBCD4_cnt_3=0;  //接收到的第3个数组合BCD码数组的有效数据长度


unsigned char ucDataBCD8_1[BCD8_MAX]; //接收到的第1个数非组合BCD码数组形式   这里是指被减数
unsigned char ucDataBCD8_cnt_1=0;  //接收到的第1个数非组合BCD码数组的有效数据长度

unsigned char ucDataBCD8_2[BCD8_MAX]; //接收到的第2个数非组合BCD码数组形式   这里是指减数
unsigned char ucDataBCD8_cnt_2=0;  //接收到的第2个数非组合BCD码数组的有效数据长度

unsigned char ucDataBCD8_3[BCD8_MAX]; //接收到的第3个数非组合BCD码数组形式   这里是指差
unsigned char ucDataBCD8_cnt_3=0;  //接收到的第3个数非组合BCD码数组的有效数据长度

unsigned char ucResultFlag=11; //运算结果标志，10代表计算结果超出范围出错，11代表正常。

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

}

/* 注释二：
 * 组合BCD码转成非组合BCD码。
 * 这里的变量ucBCD4_cnt代表组合BCD码的有效字节数.
 * 这里的变量*p_ucBCD8_cnt代表经过转换后，非组合BCD码的有效字节数，记得加地址符号&传址进去
 * 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
 * 同时引进了组合BCD码的有效字节数变量。这样就不限定了数据的长度，
 * 可以让我们根据数据的实际大小灵活运用。
 */
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt) 
{
   unsigned char ucTmep;
   unsigned char i;

   for(i=0;i<BCD8_MAX;i++)   //先把即将保存转换结果的缓冲区清零
   {
      p_ucBCD_bit8[i]=0;
   } 


   *p_ucBCD8_cnt=ucBCD4_cnt*2; //转换成非组合BCD码后的有效数据长度  

   for(i=0;i<ucBCD4_cnt;i++)
   {
      ucTmep=p_ucBCD_bit4[ucBCD4_cnt-1-i];
      p_ucBCD_bit8[ucBCD4_cnt*2-i*2-1]=ucTmep>>4;    
      p_ucBCD_bit8[ucBCD4_cnt*2-i*2-2]=ucTmep&0x0f;  
   }

}


/* 注释三：
 * 非组合BCD码转成组合BCD码。
 * 这里的变量ucBCD8_cnt代表非组合BCD码的有效字节数.
 * 这里的变量*p_ucBCD4_cnt代表经过转换后，组合BCD码的有效字节数，记得加地址符号&传址进去
 * 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
 * 同时引进了非组合BCD码的有效字节数变量。这样就不限定了数据的长度，
 * 可以让我们根据数据的实际大小灵活运用。
 */
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt) 
{
   unsigned char ucTmep;
   unsigned char i;
   unsigned char ucBCD4_cnt; 

   for(i=0;i<BCD4_MAX;i++)   //先把即将保存转换结果的缓冲区清零
   {
      p_ucBCD_bit4[i]=0;
   } 

   ucBCD4_cnt=(ucBCD8_cnt+1)/2; //非组合BCD码转化成组合BCD码的有效数,这里+1避免非组合数据长度是奇数位
   *p_ucBCD4_cnt=ucBCD4_cnt; //把转换后的结果付给接口指针的数据，可以对外输出结果

   for(i=0;i<ucBCD4_cnt;i++)
   {
      ucTmep=p_ucBCD_bit8[ucBCD4_cnt*2-1-i*2];    //把非组合BCD码第8位分解出来
      p_ucBCD_bit4[ucBCD4_cnt-1-i]=ucTmep<<4;
      p_ucBCD_bit4[ucBCD4_cnt-1-i]=p_ucBCD_bit4[ucBCD4_cnt-1-i]+p_ucBCD_bit8[ucBCD4_cnt*2-2-i*2];    //把非组合BCD码第7位分解出来
   }
  
}

/* 注释四：
 *函数介绍：清零数组的全部数组数据
 *输入参数：ucARRAY_MAX代表数组定义的最大长度
 *输入输出参数：*destData--被清零的数组。
 */

void ClearAllData(uchar ucARRAY_MAX,uchar *destData)
{
  uchar i;

  for(i=0;i<ucARRAY_MAX;i++)
  {
     destData[i]=0;
  }

}


/* 注释五：
 *函数介绍：获取数组的有效长度
 *输入参数：*destData--被获取的数组。
 *输入参数：ucARRAY_MAX代表数组定义的最大长度
 *返回值  ：返回数组的有效长度。比如58786这个数据的有效长度是5
 *电子开发者作者：吴坚鸿
 */
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX)
{
  uchar i;
  uchar DataLength=ucARRAY_MAX;
  for(i=0;i<ucARRAY_MAX;i++)
  {
      if(0!=destData[ucARRAY_MAX-1-i])
          {
             break;
          }
          else
          {
             DataLength--;
          }

  }

  return DataLength;

}



/* 注释六：
*函数介绍：比较两个数的大小
*输入参数：
*（1）*destData--被比较数的数组。
*（2）*sourceData--比较数的数组。
*返回值  ：9代表小于，10代表相等，11代表大于。
*/
uchar CmpData(const uchar *destData,const uchar *sourceData)
{
uchar cmpResult=10; //开始默认相等
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;

destCnt=GetDataLength(destData,BCD8_MAX);
sourceCnt=GetDataLength(sourceData,BCD8_MAX);

if(destCnt>sourceCnt)  //大于
{
  cmpResult=11;
}
else if(destCnt<sourceCnt) //小于
{
  cmpResult=9;
}
else if((destCnt==0)&&(sourceCnt==0))  //如果都是等于0则等于
{
  cmpResult=10;
}
else  //否则就要继续判断
{
  for(i=0;i<destCnt;i++)
  {
     if(destData[destCnt-1-i]>sourceData[destCnt-1-i])   //从最高位开始判断,如果最高位大于则大于
	 {
	   cmpResult=11;
	   break;
	 }
     else if(destData[destCnt-1-i]<sourceData[destCnt-1-i])  //从最高位开始判断,如果最高位小于则小于
	 {
	   cmpResult=9;
	   break;
	 }

     //否则继续判断下一位
  }
}


return cmpResult;
}


/* 注释七：
*函数介绍：两个数相减
*输入参数：
*（1）*destData--被减数的数组。
*（2）*sourceData--减数的数组。
*（3）*resultData--差的数组。注意，调用本函数前，必须先把这个数组清零
*返回值  ：10代表计算结果是负数或者超出范围出错，11代表正常。
*/
uchar SubData(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar subResult=11; //开始默认正常
uchar destCnt=0;

uchar i;
uchar carryData=0;  //进位
uchar maxCnt=0; //最大位数
uchar resultTemp=0; //存放临时运算结果的中间变量

//为什么不在本函数内先把resultData数组清零？因为后面章节中的除法运算中要用到此函数实现连减功能。
//因此如果纯粹实现减法运算时，在调用本函数之前，必须先在外面把差的数组清零，否则会计算出错。

if(CmpData(destData,sourceData)==9)  //被减数小于减数，报错
{
   subResult=10;
   return subResult;  //返回判断结果，并且退出本程序，不往下执行本程序余下代码
}

destCnt=GetDataLength(destData,BCD8_MAX);  //获取被减数的有效数据长度
maxCnt=destCnt;


for(i=0;i<maxCnt;i++)
{

   resultTemp=sourceData[i]+carryData; //按位相加
   if(resultTemp>destData[i])
   {
      resultData[i]=destData[i]+10-sourceData[i]-carryData;    //借位
	  carryData=1;
   }
   else
   {
      resultData[i]=destData[i]-sourceData[i]-carryData;    //不用借位
	  carryData=0;
   }

}


return subResult;
}



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

     unsigned char i=0;   
     unsigned char k=0;   
         unsigned char ucGetDataStep=0;

     if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
     {

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

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

            uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
            while(uiRcMoveIndex<uiRcregTotal)  //说明还没有把缓冲区的数据读取完
            {
               if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
               {
                    
                   i=0;
                   ucGetDataStep=0;
                   ucDataBCD4_cnt_1=0;  //第1个数组合BCD码数组的有效数据长度
                   ucDataBCD4_cnt_2=0;  //第2个数组合BCD码数组的有效数据长度

                   ClearAllData(BCD4_MAX,ucDataBCD4_1);  //清零第1个参与运算的数据
                   ClearAllData(BCD4_MAX,ucDataBCD4_2);  //清零第2个参与运算的数据

                   //以下while循环是通过关键字0x0d 0x0a来截取第1个和第2个参与运算的数据。
                   while(i<(BCD8_MAX+4))//这里+4是因为有2对0x0d 0x0a结尾特殊符号，一个共4个字节
                   {
                      if(ucGetDataStep==0)//步骤0，相当于我平时用的case 0,获取第1个数，在这里是指被加数
                      {
                           if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
                           {
                                for(k=0;k<ucDataBCD4_cnt_1;k++) //提取第1个参与运算的数组数据
                                {
                                    ucDataBCD4_1[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的 
                                }                                                                                                               
                                i=i+2; //跳过 0x0d 0x0a 这两个字节，进行下一轮的关键字提取
                                ucGetDataStep=1;  //切换到下一个关键字提取的步骤

                           }
                           else
                           {
                                i++;
                                ucDataBCD4_cnt_1++;  //统计第1个有效数据的长度
                           }
                                                                                                                         
                       }
                       else if(ucGetDataStep==1) //步骤1，相当于我平时用的case 1,获取第2个参与运行的数，在这里是加数
                       {
                           if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
                           {
                                for(k=0;k<ucDataBCD4_cnt_2;k++) //提取第2个参与运算的数组数据
                                {
                                    ucDataBCD4_2[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的 
                                }
                                                                                                                                                        
                                break; //截取数据完成。直接跳出截取数据的while(i<(BCD8_MAX+4))循环

                            }
                            else
                            {
                                i++;
                                ucDataBCD4_cnt_2++;  //统计第2个有效数据的长度
                            }
                       }
                    }


                    //注意ucDataBCD8_cnt_1和ucDataBCD8_cnt_2要带地址符号&传址进去
                    BCD4_to_BCD8(ucDataBCD4_1,ucDataBCD4_cnt_1,ucDataBCD8_1,&ucDataBCD8_cnt_1); //把接收到的组合BCD码转换成非组合BCD码  第1个数 
                    BCD4_to_BCD8(ucDataBCD4_2,ucDataBCD4_cnt_2,ucDataBCD8_2,&ucDataBCD8_cnt_2); //把接收到的组合BCD码转换成非组合BCD码  第2个数


                    ClearAllData(BCD8_MAX,ucDataBCD8_3);  //清零第3个参与运算的数据,用来接收运行的结果
                    ucResultFlag=SubData(ucDataBCD8_1,ucDataBCD8_2,ucDataBCD8_3); //相减运算，结果放在ucDataBCD8_3数组里
                    if(ucResultFlag==11) //表示运算结果没有超范围
                    {
                       ucDataBCD8_cnt_3=GetDataLength(ucDataBCD8_3,BCD8_MAX);  //获取运算结果的有效字节数
                       BCD8_to_BCD4(ucDataBCD8_3,ucDataBCD8_cnt_3,ucDataBCD4_3,&ucDataBCD4_cnt_3); //把非组合BCD码转成组合BCD码。注意，&ucDataBCD4_cnt_3带地址符号&
                       for(k=0;k<ucDataBCD4_cnt_3;k++) //返回运算结果到上位机上观察。看到的是组合BCD码形式。返回的时候注意数组下标的顺序要反过来发送，先发高位的下标数组
                       {
                          eusart_send(ucDataBCD4_3[ucDataBCD4_cnt_3-1-k]); //往上位机发送一个字节的函数
                       }
                    }
                    else //运算结果超范围，返回EE EE EE
                    {
                       eusart_send(0xee); //往上位机发送一个字节的函数
                       eusart_send(0xee); //往上位机发送一个字节的函数
                       eusart_send(0xee); //往上位机发送一个字节的函数
                    }

                    break;   //退出循环
               }
               uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
           }

           ucRcregBuf[0]=0; //把数据头清零，方便下次接收判断新数据
           ucRcregBuf[1]=0;
           ucRcregBuf[2]=0;          
                  
           uiRcregTotal=0;  //清空缓冲的下标，方便下次重新从0下标开始接受新数据
  
     }
                         
}

void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{

  ES = 0; //关串口中断
  TI = 0; //清零串口发送完成中断请求标志
  SBUF =ucSendData; //发送一个字节

  delay_short(400);  //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整

  TI = 0; //清零串口发送完成中断请求标志
  ES = 1; //允许串口中断

}



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


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



  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  //发送中断，及时把发送中断标志位清零
   {
        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 delay_short(unsigned int uiDelayShort) 
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


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

}

 

总结陈词： 

既然这节讲了减法程序，那么下一节接着讲常用的乘法程序，这种大数据的乘法程序是什么样的？欲知详情，请听下回分解----大数据的乘法运算。

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

第六十四节：大数据的乘法运算。

开场白：

直接用C语言的“*”运算符进行乘法运算时，“被乘数”，“ 乘数”，“积”，这三个数据的最大范围是unsigned long 类型，也就是数据最大范围是4个字节，十进制的范围是0至4294967295。一旦超过了这个范围，则运算会出错。因此，当进行大数据乘法运算时，我们要额外编程序，实现大数据的算法。其实这种算法并不难，就是我们在小学里学的四则运算算法。
      我们先要弄清楚一个新的概念。不考虑小数点的情况下，数据有两种表现形式。一种是常用的变量形式，另外一种是BCD码数组形式。变量的最大范围有限，而BCD码数组的形式是无限的，正因为这个特点，所以我们可以进行大数据运算。
    这一节要教大家一个知识点：
   第一个：如何编写涉及到大数据乘法运算的算法程序函数，同时也复习了指针的用途。

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

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

（2）实现功能：
波特率是：9600 。

通过电脑串口调试助手模拟上位机，往单片机发送组合BCD码的被乘数和乘数，单片机把组合BCD码的运算结果返回到上位机。被乘数与乘数的最大范围都是从0到99，如果运算的乘积超过允许保存的最大位数范围则返回EE EE EE报错。

往单片机发送的数据格式：EB 00 55 XX  0d  0a  YY  0d  0a指令，其中EB 00 55是数据头，XX 是被乘数，是1个字节的组合BCD码。YY是乘数，可以是1个字节的组合BCD码。0d 0a是固定的结束标志。
例如：
（a）83 x 98 = 8134

上位机发送数据：eb 00 55 83 0d 0a 98 0d 0a

单片机返回：81 34

（3）源代码讲解如下：

#include "REG52.H"


/* 注释一：
 * 本系统中的乘法运算，规定两个乘数的最大范围是0至99.
 * 由于STC89C52单片机的RAM只有256个，也就是说系统的变量数最大
 * 不能超过256个，如果超过了这个极限，编译器就会报错。由于51单片机RAM资源有限，
 * 因此规定乘数的最大范围不能超过99，如果这个算法移植到stm32或者PIC等RAM比较大
 * 的单片机上，那么就可以把这个运算位数设置得更加大一点。调整下面 BCD4_MAX的大小，
 * 可以调整运算的数据范围。
 */

#define  BCD4_MAX     3  //为了让乘法的结果不超过范围，因此把组合BCD码最大字节数从上一节的2改成3，一个字节包含2位，因此可以保存6位有效数
#define  BCD8_MAX    (BCD4_MAX*2)  //本系统中，规定的非组合BCD码能保存的最大字节数，一个字节包含1位，因此能保存6位有效运算数

#define const_rc_size  30  //接收串口中断数据的缓冲区数组大小

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

#define uchar unsigned char    //方便移植平台
#define ulong unsigned long   //方便移植平台

//如果在VC的平台模拟此算法，则都定义成int类型，如下：
//#define uchar int  
//#define ulong int 

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


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


void eusart_send(unsigned char ucSendData);

void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt); 
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt);

void ClearAllData(uchar ucARRAY_MAX,uchar *destData);
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX);
uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData);  //两个数相加
void EnlargeData(uchar *destData,uchar enlarge_cnt); //数组向大索引值移位，移一位相当于放大10倍
uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData); //两个数相乘

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 char ucDataBCD4_1[BCD4_MAX]; //接收到的第1个数组合BCD码数组形式  这里是指被乘数
unsigned char ucDataBCD4_cnt_1=0;  //接收到的第1个数组合BCD码数组的有效数据长度

unsigned char ucDataBCD4_2[BCD4_MAX]; //接收到的第2个数组合BCD码数组形式  这里是指乘数
unsigned char ucDataBCD4_cnt_2=0;  //接收到的第2个数组合BCD码数组的有效数据长度

unsigned char ucDataBCD4_3[BCD4_MAX]; //接收到的第3个数组合BCD码数组形式  这里是指积
unsigned char ucDataBCD4_cnt_3=0;  //接收到的第3个数组合BCD码数组的有效数据长度


unsigned char ucDataBCD8_1[BCD8_MAX]; //接收到的第1个数非组合BCD码数组形式   这里是指被乘数
unsigned char ucDataBCD8_cnt_1=0;  //接收到的第1个数非组合BCD码数组的有效数据长度

unsigned char ucDataBCD8_2[BCD8_MAX]; //接收到的第2个数非组合BCD码数组形式   这里是指乘数
unsigned char ucDataBCD8_cnt_2=0;  //接收到的第2个数非组合BCD码数组的有效数据长度

unsigned char ucDataBCD8_3[BCD8_MAX]; //接收到的第3个数非组合BCD码数组形式   这里是指积
unsigned char ucDataBCD8_cnt_3=0;  //接收到的第3个数非组合BCD码数组的有效数据长度

unsigned char ucResultFlag=11; //运算结果标志，10代表计算结果超出范围出错，11代表正常。

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

}

/* 注释二：
 * 组合BCD码转成非组合BCD码。
 * 这里的变量ucBCD4_cnt代表组合BCD码的有效字节数.
 * 这里的变量*p_ucBCD8_cnt代表经过转换后，非组合BCD码的有效字节数，记得加地址符号&传址进去
 * 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
 * 同时引进了组合BCD码的有效字节数变量。这样就不限定了数据的长度，
 * 可以让我们根据数据的实际大小灵活运用。
 */
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt) 
{
   unsigned char ucTmep;
   unsigned char i;

   for(i=0;i<BCD8_MAX;i++)   //先把即将保存转换结果的缓冲区清零
   {
      p_ucBCD_bit8[i]=0;
   } 


   *p_ucBCD8_cnt=ucBCD4_cnt*2; //转换成非组合BCD码后的有效数据长度  

   for(i=0;i<ucBCD4_cnt;i++)
   {
      ucTmep=p_ucBCD_bit4[ucBCD4_cnt-1-i];
      p_ucBCD_bit8[ucBCD4_cnt*2-i*2-1]=ucTmep>>4;    
      p_ucBCD_bit8[ucBCD4_cnt*2-i*2-2]=ucTmep&0x0f;  
   }

}


/* 注释三：
 * 非组合BCD码转成组合BCD码。
 * 这里的变量ucBCD8_cnt代表非组合BCD码的有效字节数.
 * 这里的变量*p_ucBCD4_cnt代表经过转换后，组合BCD码的有效字节数，记得加地址符号&传址进去
 * 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
 * 同时引进了非组合BCD码的有效字节数变量。这样就不限定了数据的长度，
 * 可以让我们根据数据的实际大小灵活运用。
 */
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt) 
{
   unsigned char ucTmep;
   unsigned char i;
   unsigned char ucBCD4_cnt; 

   for(i=0;i<BCD4_MAX;i++)   //先把即将保存转换结果的缓冲区清零
   {
      p_ucBCD_bit4[i]=0;
   } 

   ucBCD4_cnt=(ucBCD8_cnt+1)/2; //非组合BCD码转化成组合BCD码的有效数,这里+1避免非组合数据长度是奇数位
   *p_ucBCD4_cnt=ucBCD4_cnt; //把转换后的结果付给接口指针的数据，可以对外输出结果

   for(i=0;i<ucBCD4_cnt;i++)
   {
      ucTmep=p_ucBCD_bit8[ucBCD4_cnt*2-1-i*2];    //把非组合BCD码第8位分解出来
      p_ucBCD_bit4[ucBCD4_cnt-1-i]=ucTmep<<4;
      p_ucBCD_bit4[ucBCD4_cnt-1-i]=p_ucBCD_bit4[ucBCD4_cnt-1-i]+p_ucBCD_bit8[ucBCD4_cnt*2-2-i*2];    //把非组合BCD码第7位分解出来
   }
  
}

/* 注释四：
 *函数介绍：清零数组的全部数组数据
 *输入参数：ucARRAY_MAX代表数组定义的最大长度
 *输入输出参数：*destData--被清零的数组。
 */

void ClearAllData(uchar ucARRAY_MAX,uchar *destData)
{
  uchar i;

  for(i=0;i<ucARRAY_MAX;i++)
  {
     destData[i]=0;
  }

}


/* 注释五：
 *函数介绍：获取数组的有效长度
 *输入参数：*destData--被获取的数组。
 *输入参数：ucARRAY_MAX代表数组定义的最大长度
 *返回值  ：返回数组的有效长度。比如58786这个数据的有效长度是5
 *电子开发者作者：吴坚鸿
 */
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX)
{
  uchar i;
  uchar DataLength=ucARRAY_MAX;
  for(i=0;i<ucARRAY_MAX;i++)
  {
      if(0!=destData[ucARRAY_MAX-1-i])
          {
             break;
          }
          else
          {
             DataLength--;
          }

  }

  return DataLength;

}



/* 注释六：
*函数介绍：两个数相加
*输入参数：
*（1）*destData--被加数的数组。
*（2）*sourceData--加数的数组。
*（3）*resultData--和的数组。注意，调用本函数前，必须先把这个数组清零
*返回值  ：10代表计算结果超出范围出错，11代表正常。
*/
uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar addResult=11; //开始默认返回的运算结果是正常
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;
uchar carryData=0;  //进位
uchar maxCnt=0; //最大位数
uchar resultTemp=0; //存放临时运算结果的中间变量

//为什么不在本函数内先把resultData数组清零？因为后面章节中的乘法运算中要用到此函数实现连加功能。
//因此如果纯粹实现加法运算时，在调用本函数之前，必须先在外面把和的数组清零，否则会计算出错。

destCnt=GetDataLength(destData,BCD8_MAX);   //获取被加数的有效位数
sourceCnt=GetDataLength(sourceData,BCD8_MAX);  //获取加数的有效位数

if(destCnt>=sourceCnt)  //找出两个运算数据中最大的有效位数
{
   maxCnt=destCnt;
}
else 
{
   maxCnt=sourceCnt;
}

for(i=0;i<maxCnt;i++)
{
   resultTemp=destData[i]+sourceData[i]+carryData; //按位相加
   resultData[i]=resultTemp%10;   //截取最低位存放进保存结果的数组
   carryData=resultTemp/10;    //存放进位 
}

resultData[i]=carryData;

if((maxCnt==BCD8_MAX)&&(carryData==1))  //如果数组的有效位是最大值并且最后的进位是1，则计算溢出报错
{

  ClearAllData(BCD8_MAX,resultData);

  addResult=10;  //报错
}


return addResult;
}



/* 注释七：
*函数介绍：数组向大索引值移位，移一位相当于放大10倍
*输入参数：*destData--被移位的数组。
*输入参数：enlarge_cnt--被移位的个数。
*/
void EnlargeData(uchar *destData,uchar enlarge_cnt)
{
  uchar i;

  if(enlarge_cnt!=0)
  {
    for(i=0;i<(BCD8_MAX-enlarge_cnt);i++)
	{
       destData[BCD8_MAX-1-i]=destData[BCD8_MAX-1-enlarge_cnt-i];
	}

    for(i=0;i<enlarge_cnt;i++) //最低位被移空的补上0
	{
      destData[i]=0;
	}
  }

}




/* 注释八：
*函数介绍：两个数相乘
*输入参数：
*（1）*destData--被乘数的数组。
*（2）*sourceData--乘数的数组。
*（3）*resultData--积的数组。
*返回值  ：10代表计算结果超出范围出错，11代表正常。
*/
uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar multResult=11; //开始默认正常
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;
uchar j;
uchar carryData=0;  //进位

uchar resultTemp=0; //存放临时运算结果的中间变量

uchar nc_add_result;  //接收相加的运算是否超出范围，这里不用判断，因为不会溢出

uchar multArrayTemp[BCD8_MAX]; //存放临时运算结果的数组中间变量



destCnt=GetDataLength(destData,BCD8_MAX);      //获取被乘数的长度
sourceCnt=GetDataLength(sourceData,BCD8_MAX);   //获取乘数的长度

ClearAllData(BCD8_MAX,resultData);   //清零存储的结果
if((0==destCnt)||(0==sourceCnt)) //被乘数或者乘数为0，则结果为0
{
   return multResult;
}


if((destCnt+sourceCnt+2)>BCD8_MAX)
{
   multResult=10; //运算结果有可能超范围报错
   return multResult;
}

for(i=0;i<sourceCnt;i++)  //乘数
{
   carryData=0; //清零进位
   ClearAllData(BCD8_MAX,multArrayTemp); //清零一位乘数相乘的结果中间变量数组
   for(j=0;j<destCnt;j++) //被乘数
   {
      resultTemp=destData[j]*sourceData[i]+carryData;  //乘数的一位依次与被乘数各位相乘,并且加进位
      multArrayTemp[j]=resultTemp%10;  //存储一位乘数相乘的结果
	  carryData=resultTemp/10; //保存进位
   }
   multArrayTemp[j]=carryData; //存储最后的进位
   EnlargeData(multArrayTemp,i); //移位。移一次相当于放大10倍。
   nc_add_result=AddData(resultData,multArrayTemp,resultData); //把一位乘数相乘的结果存储进总结果

}


return multResult;
}



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

     unsigned char i=0;   
     unsigned char k=0;   
         unsigned char ucGetDataStep=0;

     if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
     {

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

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

            uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
            while(uiRcMoveIndex<uiRcregTotal)  //说明还没有把缓冲区的数据读取完
            {
               if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
               {
                    
                   i=0;
                   ucGetDataStep=0;
                   ucDataBCD4_cnt_1=0;  //第1个数组合BCD码数组的有效数据长度
                   ucDataBCD4_cnt_2=0;  //第2个数组合BCD码数组的有效数据长度

                   ClearAllData(BCD4_MAX,ucDataBCD4_1);  //清零第1个参与运算的数据
                   ClearAllData(BCD4_MAX,ucDataBCD4_2);  //清零第2个参与运算的数据

                   //以下while循环是通过关键字0x0d 0x0a来截取第1个和第2个参与运算的数据。
                   while(i<(BCD8_MAX+4))//这里+4是因为有2对0x0d 0x0a结尾特殊符号，一个共4个字节
                   {
                      if(ucGetDataStep==0)//步骤0，相当于我平时用的case 0,获取第1个数，在这里是指被乘数
                      {
                           if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
                           {
                                for(k=0;k<ucDataBCD4_cnt_1;k++) //提取第1个参与运算的数组数据
                                {
                                    ucDataBCD4_1[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的 
                                }                                                                                                               
                                i=i+2; //跳过 0x0d 0x0a 这两个字节，进行下一轮的关键字提取
                                ucGetDataStep=1;  //切换到下一个关键字提取的步骤

                           }
                           else
                           {
                                i++;
                                ucDataBCD4_cnt_1++;  //统计第1个有效数据的长度
                           }
                                                                                                                         
                       }
                       else if(ucGetDataStep==1) //步骤1，相当于我平时用的case 1,获取第2个参与运行的数，在这里是乘数
                       {
                           if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
                           {
                                for(k=0;k<ucDataBCD4_cnt_2;k++) //提取第2个参与运算的数组数据
                                {
                                    ucDataBCD4_2[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的 
                                }
                                                                                                                                                        
                                break; //截取数据完成。直接跳出截取数据的while(i<(BCD8_MAX+4))循环

                            }
                            else
                            {
                                i++;
                                ucDataBCD4_cnt_2++;  //统计第2个有效数据的长度
                            }
                       }
                    }


                    //注意ucDataBCD8_cnt_1和ucDataBCD8_cnt_2要带地址符号&传址进去
                    BCD4_to_BCD8(ucDataBCD4_1,ucDataBCD4_cnt_1,ucDataBCD8_1,&ucDataBCD8_cnt_1); //把接收到的组合BCD码转换成非组合BCD码  第1个数 
                    BCD4_to_BCD8(ucDataBCD4_2,ucDataBCD4_cnt_2,ucDataBCD8_2,&ucDataBCD8_cnt_2); //把接收到的组合BCD码转换成非组合BCD码  第2个数


                    ClearAllData(BCD8_MAX,ucDataBCD8_3);  //清零第3个参与运算的数据,用来接收运行的结果
                    ucResultFlag=MultData(ucDataBCD8_1,ucDataBCD8_2,ucDataBCD8_3); //相乘运算，结果放在ucDataBCD8_3数组里
                    if(ucResultFlag==11) //表示运算结果没有超范围
                    {
                       ucDataBCD8_cnt_3=GetDataLength(ucDataBCD8_3,BCD8_MAX);  //获取运算结果的有效字节数
                       if(ucDataBCD8_cnt_3==0) //如果1个有效位数都没有，表示数组所有的数据都是0，这个时候的有效位数应该人为的默认是1,表示一个0
					   {
					       ucDataBCD8_cnt_3=1;
					   }

                       BCD8_to_BCD4(ucDataBCD8_3,ucDataBCD8_cnt_3,ucDataBCD4_3,&ucDataBCD4_cnt_3); //把非组合BCD码转成组合BCD码。注意，&ucDataBCD4_cnt_3带地址符号&
                       for(k=0;k<ucDataBCD4_cnt_3;k++) //返回运算结果到上位机上观察。看到的是组合BCD码形式。返回的时候注意数组下标的顺序要反过来发送，先发高位的下标数组
                       {
                          eusart_send(ucDataBCD4_3[ucDataBCD4_cnt_3-1-k]); //往上位机发送一个字节的函数
                       }
                    }
                    else //运算结果超范围，返回EE EE EE
                    {
                       eusart_send(0xee); //往上位机发送一个字节的函数
                       eusart_send(0xee); //往上位机发送一个字节的函数
                       eusart_send(0xee); //往上位机发送一个字节的函数
                    }

                    break;   //退出循环
               }
               uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
           }

           ucRcregBuf[0]=0; //把数据头清零，方便下次接收判断新数据
           ucRcregBuf[1]=0;
           ucRcregBuf[2]=0;          
                  
           uiRcregTotal=0;  //清空缓冲的下标，方便下次重新从0下标开始接受新数据
  
     }
                         
}

void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{

  ES = 0; //关串口中断
  TI = 0; //清零串口发送完成中断请求标志
  SBUF =ucSendData; //发送一个字节

  delay_short(400);  //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整

  TI = 0; //清零串口发送完成中断请求标志
  ES = 1; //允许串口中断

}



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


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



  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  //发送中断，及时把发送中断标志位清零
   {
        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 delay_short(unsigned int uiDelayShort) 
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


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

}

 

总结陈词： 

既然这节讲了乘法程序，那么下一节接着讲常用的除法程序，这种大数据的除法程序是什么样的？欲知详情，请听下回分解----大数据的除法运算。

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

第六十五节：大数据的除法运算。

开场白：

直接用C语言的“/”运算符进行除法运算时，“被除数”，“ 除数”，“商”，这三个数据的最大范围是unsigned long 类型，也就是数据最大范围是4个字节，十进制的范围是0至4294967295。一旦超过了这个范围，则运算会出错。因此，当进行大数据除法运算时，我们要额外编程序，实现大数据的算法。其实这种算法并不难，就是我们在小学里学的四则运算算法。
      我们先要弄清楚一个新的概念。不考虑小数点的情况下，数据有两种表现形式。一种是常用的变量形式，另外一种是BCD码数组形式。变量的最大范围有限，而BCD码数组的形式是无限的，正因为这个特点，所以我们可以进行大数据运算。
    这一节要教大家一个知识点：
   第一个：如何编写涉及到大数据除法运算的算法程序函数，同时也复习了指针的用途。

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

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

（2）实现功能：
波特率是：9600 。

通过电脑串口调试助手模拟上位机，往单片机发送组合BCD码的被除数和除数，单片机把组合BCD码的运算结果返回到上位机。被除数与除数的最大范围都是从0到9999，如果运算的商超过允许保存的最大位数范围或者除数为0，则返回EE EE EE报错。

往单片机发送的数据格式：EB 00 55 XX XX 0d  0a  YY YY 0d  0a指令，其中EB 00 55是数据头，XX XX是被除数，是1到2个字节的组合BCD码。YY YY是除数，是1到2个字节的组合BCD码。0d 0a是固定的结束标志。
例如：
（a）9816 ÷ 8= 1227

上位机发送数据：eb 00 55 98 16 0d 0a 08 0d 0a

单片机返回：12 27

（b）9816 ÷ 0= 出错了，除数不能为0。

上位机发送数据：eb 00 55 98 16 0d 0a 00 0d 0a

单片机返回：EE EE EE   

（3）源代码讲解如下：

#include "REG52.H"


/* 注释一：
 * 本系统中的除法运算，规定被除数和除数的最大范围是0至9999.
 * 由于STC89C52单片机的RAM只有256个，也就是说系统的变量数最大
 * 不能超过256个，如果超过了这个极限，编译器就会报错。由于51单片机RAM资源有限，
 * 因此规定除数的最大范围不能超过9999，如果这个算法移植到stm32或者PIC等RAM比较大
 * 的单片机上，那么就可以把这个运算位数设置得更加大一点。调整下面 BCD4_MAX的大小，
 * 可以调整运算的数据范围。
 */

#define  BCD4_MAX     3  //调整BCD4_MAX的大小，可以调整运算的数据范围。
#define  BCD8_MAX    (BCD4_MAX*2)  //本系统中，规定的非组合BCD码能保存的最大字节数，一个字节包含1位有效运算数

#define const_rc_size  30  //接收串口中断数据的缓冲区数组大小

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

#define uchar unsigned char    //方便移植平台
#define ulong unsigned long   //方便移植平台

//如果在VC的平台模拟此算法，则都定义成int类型，如下：
//#define uchar int  
//#define ulong int 

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


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


void eusart_send(unsigned char ucSendData);

void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt); 
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt);

void ClearAllData(uchar ucARRAY_MAX,uchar *destData);
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX);
uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData);  //两个数相加
uchar CmpData(const uchar *destData,const uchar *sourceData); //比较两个数的大小
uchar SubData(const uchar *destData,const uchar *sourceData,uchar *resultData);//两个数相减
void EnlargeData(uchar *destData,uchar enlarge_cnt); //数组向大索引值移位，移一位相当于放大10倍
uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData); //两个数相乘

uchar DivLessTenData(const uchar *destData,const uchar *sourceData,uchar *resultData,uchar *remData);//局部两个数相除，商不超过10。当商为0时，余数等于被除数
uchar Div(const uchar *destData,const uchar *sourceData,uchar *resultData);//两个数相除

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 char ucDataBCD4_1[BCD4_MAX]; //接收到的第1个数组合BCD码数组形式  这里是指被乘数
unsigned char ucDataBCD4_cnt_1=0;  //接收到的第1个数组合BCD码数组的有效数据长度

unsigned char ucDataBCD4_2[BCD4_MAX]; //接收到的第2个数组合BCD码数组形式  这里是指乘数
unsigned char ucDataBCD4_cnt_2=0;  //接收到的第2个数组合BCD码数组的有效数据长度

unsigned char ucDataBCD4_3[BCD4_MAX]; //接收到的第3个数组合BCD码数组形式  这里是指积
unsigned char ucDataBCD4_cnt_3=0;  //接收到的第3个数组合BCD码数组的有效数据长度


unsigned char ucDataBCD8_1[BCD8_MAX]; //接收到的第1个数非组合BCD码数组形式   这里是指被乘数
unsigned char ucDataBCD8_cnt_1=0;  //接收到的第1个数非组合BCD码数组的有效数据长度

unsigned char ucDataBCD8_2[BCD8_MAX]; //接收到的第2个数非组合BCD码数组形式   这里是指乘数
unsigned char ucDataBCD8_cnt_2=0;  //接收到的第2个数非组合BCD码数组的有效数据长度

unsigned char ucDataBCD8_3[BCD8_MAX]; //接收到的第3个数非组合BCD码数组形式   这里是指积
unsigned char ucDataBCD8_cnt_3=0;  //接收到的第3个数非组合BCD码数组的有效数据长度

unsigned char ucResultFlag=11; //运算结果标志，10代表计算结果超出范围出错，11代表正常。

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

}

/* 注释二：
 * 组合BCD码转成非组合BCD码。
 * 这里的变量ucBCD4_cnt代表组合BCD码的有效字节数.
 * 这里的变量*p_ucBCD8_cnt代表经过转换后，非组合BCD码的有效字节数，记得加地址符号&传址进去
 * 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
 * 同时引进了组合BCD码的有效字节数变量。这样就不限定了数据的长度，
 * 可以让我们根据数据的实际大小灵活运用。
 */
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt) 
{
   unsigned char ucTmep;
   unsigned char i;

   for(i=0;i<BCD8_MAX;i++)   //先把即将保存转换结果的缓冲区清零
   {
      p_ucBCD_bit8[i]=0;
   } 


   *p_ucBCD8_cnt=ucBCD4_cnt*2; //转换成非组合BCD码后的有效数据长度  

   for(i=0;i<ucBCD4_cnt;i++)
   {
      ucTmep=p_ucBCD_bit4[ucBCD4_cnt-1-i];
      p_ucBCD_bit8[ucBCD4_cnt*2-i*2-1]=ucTmep>>4;    
      p_ucBCD_bit8[ucBCD4_cnt*2-i*2-2]=ucTmep&0x0f;  
   }

}


/* 注释三：
 * 非组合BCD码转成组合BCD码。
 * 这里的变量ucBCD8_cnt代表非组合BCD码的有效字节数.
 * 这里的变量*p_ucBCD4_cnt代表经过转换后，组合BCD码的有效字节数，记得加地址符号&传址进去
 * 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
 * 同时引进了非组合BCD码的有效字节数变量。这样就不限定了数据的长度，
 * 可以让我们根据数据的实际大小灵活运用。
 */
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt) 
{
   unsigned char ucTmep;
   unsigned char i;
   unsigned char ucBCD4_cnt; 

   for(i=0;i<BCD4_MAX;i++)   //先把即将保存转换结果的缓冲区清零
   {
      p_ucBCD_bit4[i]=0;
   } 

   ucBCD4_cnt=(ucBCD8_cnt+1)/2; //非组合BCD码转化成组合BCD码的有效数,这里+1避免非组合数据长度是奇数位
   *p_ucBCD4_cnt=ucBCD4_cnt; //把转换后的结果付给接口指针的数据，可以对外输出结果

   for(i=0;i<ucBCD4_cnt;i++)
   {
      ucTmep=p_ucBCD_bit8[ucBCD4_cnt*2-1-i*2];    //把非组合BCD码第8位分解出来
      p_ucBCD_bit4[ucBCD4_cnt-1-i]=ucTmep<<4;
      p_ucBCD_bit4[ucBCD4_cnt-1-i]=p_ucBCD_bit4[ucBCD4_cnt-1-i]+p_ucBCD_bit8[ucBCD4_cnt*2-2-i*2];    //把非组合BCD码第7位分解出来
   }
  
}

/* 注释四：
 *函数介绍：清零数组的全部数组数据
 *输入参数：ucARRAY_MAX代表数组定义的最大长度
 *输入输出参数：*destData--被清零的数组。
 */

void ClearAllData(uchar ucARRAY_MAX,uchar *destData)
{
  uchar i;

  for(i=0;i<ucARRAY_MAX;i++)
  {
     destData[i]=0;
  }

}


/* 注释五：
 *函数介绍：获取数组的有效长度
 *输入参数：*destData--被获取的数组。
 *输入参数：ucARRAY_MAX代表数组定义的最大长度
 *返回值  ：返回数组的有效长度。比如58786这个数据的有效长度是5
 *电子开发者作者：吴坚鸿
 */
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX)
{
  uchar i;
  uchar DataLength=ucARRAY_MAX;
  for(i=0;i<ucARRAY_MAX;i++)
  {
      if(0!=destData[ucARRAY_MAX-1-i])
          {
             break;
          }
          else
          {
             DataLength--;
          }

  }

  return DataLength;

}


/* 注释六：
*函数介绍：比较两个数的大小
*输入参数：
*（1）*destData--被比较数的数组。
*（2）*sourceData--比较数的数组。
*返回值  ：9代表小于，10代表相等，11代表大于。
*/
uchar CmpData(const uchar *destData,const uchar *sourceData)
{
uchar cmpResult=10; //开始默认相等
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;

destCnt=GetDataLength(destData,BCD8_MAX);
sourceCnt=GetDataLength(sourceData,BCD8_MAX);

if(destCnt>sourceCnt)  //大于
{
  cmpResult=11;
}
else if(destCnt<sourceCnt) //小于
{
  cmpResult=9;
}
else if((destCnt==0)&&(sourceCnt==0))  //如果都是等于0则等于
{
  cmpResult=10;
}
else  //否则就要继续判断
{
  for(i=0;i<destCnt;i++)
  {
     if(destData[destCnt-1-i]>sourceData[destCnt-1-i])   //从最高位开始判断,如果最高位大于则大于
         {
           cmpResult=11;
           break;
         }
     else if(destData[destCnt-1-i]<sourceData[destCnt-1-i])  //从最高位开始判断,如果最高位小于则小于
         {
           cmpResult=9;
           break;
         }

     //否则继续判断下一位
  }
}


return cmpResult;
}


/* 注释七：
*函数介绍：两个数相减
*输入参数：
*（1）*destData--被减数的数组。
*（2）*sourceData--减数的数组。
*（3）*resultData--差的数组。注意，调用本函数前，必须先把这个数组清零
*返回值  ：10代表计算结果是负数或者超出范围出错，11代表正常。
*/
uchar SubData(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar subResult=11; //开始默认正常
uchar destCnt=0;

uchar i;
uchar carryData=0;  //进位
uchar maxCnt=0; //最大位数
uchar resultTemp=0; //存放临时运算结果的中间变量

//为什么不在本函数内先把resultData数组清零？因为后面章节中的除法运算中要用到此函数实现连减功能。
//因此如果纯粹实现减法运算时，在调用本函数之前，必须先在外面把差的数组清零，否则会计算出错。

if(CmpData(destData,sourceData)==9)  //被减数小于减数，报错
{
   subResult=10;
   return subResult;  //返回判断结果，并且退出本程序，不往下执行本程序余下代码
}

destCnt=GetDataLength(destData,BCD8_MAX);  //获取被减数的有效数据长度
maxCnt=destCnt;


for(i=0;i<maxCnt;i++)
{

   resultTemp=sourceData[i]+carryData; //按位相加
   if(resultTemp>destData[i])
   {
      resultData[i]=destData[i]+10-sourceData[i]-carryData;    //借位
          carryData=1;
   }
   else
   {
      resultData[i]=destData[i]-sourceData[i]-carryData;    //不用借位
          carryData=0;
   }

}


return subResult;
}


/* 注释八：
*函数介绍：两个数相加
*输入参数：
*（1）*destData--被加数的数组。
*（2）*sourceData--加数的数组。
*（3）*resultData--和的数组。注意，调用本函数前，必须先把这个数组清零
*返回值  ：10代表计算结果超出范围出错，11代表正常。
*/
uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar addResult=11; //开始默认返回的运算结果是正常
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;
uchar carryData=0;  //进位
uchar maxCnt=0; //最大位数
uchar resultTemp=0; //存放临时运算结果的中间变量

//为什么不在本函数内先把resultData数组清零？因为后面章节中的乘法运算中要用到此函数实现连加功能。
//因此如果纯粹实现加法运算时，在调用本函数之前，必须先在外面把和的数组清零，否则会计算出错。

destCnt=GetDataLength(destData,BCD8_MAX);   //获取被加数的有效位数
sourceCnt=GetDataLength(sourceData,BCD8_MAX);  //获取加数的有效位数

if(destCnt>=sourceCnt)  //找出两个运算数据中最大的有效位数
{
   maxCnt=destCnt;
}
else 
{
   maxCnt=sourceCnt;
}

for(i=0;i<maxCnt;i++)
{
   resultTemp=destData[i]+sourceData[i]+carryData; //按位相加
   resultData[i]=resultTemp%10;   //截取最低位存放进保存结果的数组
   carryData=resultTemp/10;    //存放进位 
}

resultData[i]=carryData;

if((maxCnt==BCD8_MAX)&&(carryData==1))  //如果数组的有效位是最大值并且最后的进位是1，则计算溢出报错
{

  ClearAllData(BCD8_MAX,resultData);

  addResult=10;  //报错
}


return addResult;
}



/* 注释九：
*函数介绍：数组向大索引值移位，移一位相当于放大10倍
*输入参数：*destData--被移位的数组。
*输入参数：enlarge_cnt--被移位的个数。
*/
void EnlargeData(uchar *destData,uchar enlarge_cnt)
{
  uchar i;

  if(enlarge_cnt!=0)
  {
    for(i=0;i<(BCD8_MAX-enlarge_cnt);i++)
        {
       destData[BCD8_MAX-1-i]=destData[BCD8_MAX-1-enlarge_cnt-i];
        }

    for(i=0;i<enlarge_cnt;i++) //最低位被移空的补上0
        {
      destData[i]=0;
        }
  }

}




/* 注释十：
*函数介绍：两个数相乘
*输入参数：
*（1）*destData--被乘数的数组。
*（2）*sourceData--乘数的数组。
*（3）*resultData--积的数组。
*返回值  ：10代表计算结果超出范围出错，11代表正常。
*/
uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar multResult=11; //开始默认正常
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;
uchar j;
uchar carryData=0;  //进位

uchar resultTemp=0; //存放临时运算结果的中间变量

uchar nc_add_result;  //接收相加的运算是否超出范围，这里不用判断，因为不会溢出

uchar multArrayTemp[BCD8_MAX]; //存放临时运算结果的数组中间变量



destCnt=GetDataLength(destData,BCD8_MAX);      //获取被乘数的长度
sourceCnt=GetDataLength(sourceData,BCD8_MAX);   //获取乘数的长度

ClearAllData(BCD8_MAX,resultData);   //清零存储的结果
if((0==destCnt)||(0==sourceCnt)) //被乘数或者乘数为0，则结果为0
{
   return multResult;
}


if((destCnt+sourceCnt+2)>BCD8_MAX)
{
   multResult=10; //运算结果有可能超范围报错
   return multResult;
}

for(i=0;i<sourceCnt;i++)  //乘数
{
   carryData=0; //清零进位
   ClearAllData(BCD8_MAX,multArrayTemp); //清零一位乘数相乘的结果中间变量数组
   for(j=0;j<destCnt;j++) //被乘数
   {
      resultTemp=destData[j]*sourceData[i]+carryData;  //乘数的一位依次与被乘数各位相乘,并且加进位
      multArrayTemp[j]=resultTemp%10;  //存储一位乘数相乘的结果
          carryData=resultTemp/10; //保存进位
   }
   multArrayTemp[j]=carryData; //存储最后的进位
   EnlargeData(multArrayTemp,i); //移位。移一次相当于放大10倍。
   nc_add_result=AddData(resultData,multArrayTemp,resultData); //把一位乘数相乘的结果存储进总结果

}


return multResult;
}



/* 注释十一：
*函数介绍：局部两个数相除，商不超过10。当商为0时，余数是被除数
*原理精髓：根据手工除法的原理，我们都是从高位开始借位相除，此时是局部相除，因此商都不超过10，剩下的余数继续借位
*依次除下去。这个程序的除法原理是挨个猜值，反正商是从0，1,2.。。。9这10个数中的其中一个，为了快速找到我们想要的那个商，我是
*利用中间法则进行寻找，先猜是5，然后判断一下是大了还是小了，如果是大了，就猜是3，如果小了就猜是7，最后肯定会找到商。
*输入参数：
*（1）*destData--被除数的数组。
*（2）*sourceData--除数的数组。
*（3）*resultData--商的数,不是数组，传址进去，是0,1,2到9中的某个数
*（4）*remData--余数的数组。
*返回值  ：10代表计算结果超出范围出错，11代表正常。
*/
uchar DivLessTenData(const uchar *destData,const uchar *sourceData,uchar *resultData,uchar *remData)
{
uchar DivLessTenResult=11; //开始默认正常
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;



uchar resultRunStep=5;  
uchar cmpError=10;
uchar DivLessTenArrayTemp[BCD8_MAX]; //存放临时运算结果的数组中间变量
uchar DivLessTenArrayResult[BCD8_MAX]; //存放临时运算结果的数组中间变量的结果
uchar DivLessTenArrayBackup[BCD8_MAX]; //存放临时运算结果的数组中间变量的备份
uchar while_flag=0;  //结束猜算的中间变量
uchar multError=11;
uchar subError=11;

destCnt=GetDataLength(destData,BCD8_MAX);     //获取被除数的数据有效长度
sourceCnt=GetDataLength(sourceData,BCD8_MAX); //获取除数的数据有效长度

cmpError=CmpData(destData,sourceData); //比较被除数和除数的大小

ClearAllData(BCD8_MAX,remData); //清空余数,余数为0

if(cmpError==9) //被除数比除数小
{
   *resultData=0;   //商肯定为0
   for(i=0;i<destCnt;i++)
   {
     remData[i]=destData[i]; //余数等于被除数
   }
   return DivLessTenResult;
}
else if(cmpError==10) //被除数与除数相等
{

   *resultData=1; //商等于1余数为0
   return DivLessTenResult;
}
else  //开始猜值
{
   resultRunStep=5;  //先猜是5  ,从这里开始直接看以下 case 5 的详细讲解，其他case原理相同
   while_flag=0;
   while(1)
   {
      switch(resultRunStep)
	  {

		 case 1:
			 ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
			 ClearAllData(BCD8_MAX,DivLessTenArrayResult);
             DivLessTenArrayTemp[0]=resultRunStep; 
			 multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);

             subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
             *resultData=1; //商等于1
		     while_flag=1; //退出循环
			 break;
		 case 2:
			 ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
			 ClearAllData(BCD8_MAX,DivLessTenArrayResult);
             DivLessTenArrayTemp[0]=resultRunStep; 
			 multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
             cmpError=CmpData(DivLessTenArrayResult,destData);
			 if(cmpError==10) //等于
			 {
                 *resultData=2; //商等于2余数为0
				 while_flag=1; //退出循环
			 }
			 else if(cmpError==11) //大于
			 {
                 resultRunStep=1;
			 }
			 else             //小于
			 {
                 subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
                 *resultData=2; //商等于2
				 while_flag=1; //退出循环
			 }




			 break;
		 case 3:
			 ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
			 ClearAllData(BCD8_MAX,DivLessTenArrayResult);
             DivLessTenArrayTemp[0]=resultRunStep; 
			 multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
             cmpError=CmpData(DivLessTenArrayResult,destData);
			 if(cmpError==10) //等于
			 {
                 *resultData=3; //商等于3余数为0
				 while_flag=1; //退出循环
			 }
			 else if(cmpError==11) //大于
			 {
                resultRunStep=2;
			 }
			 else             //小于
			 {
                resultRunStep=4;

			    ClearAllData(BCD8_MAX,DivLessTenArrayBackup);
			    for(i=0;i<BCD8_MAX;i++) //备份
				{
			      DivLessTenArrayBackup[i]=DivLessTenArrayResult[i];
				}
			 }



			 break;
		 case 4:
			 ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
			 ClearAllData(BCD8_MAX,DivLessTenArrayResult);
             DivLessTenArrayTemp[0]=resultRunStep; 
			 multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
             cmpError=CmpData(DivLessTenArrayResult,destData);
			 if(cmpError==10) //等于
			 {
                 *resultData=4; //商等于4余数为0
				 while_flag=1; //退出循环
			 }
			 else if(cmpError==11) //大于
			 {
                 subError=SubData(destData,DivLessTenArrayBackup,remData);//求余数
                 *resultData=3; //商等于3
				 while_flag=1; //退出循环
			 }
			 else             //小于
			 {
                 subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
                 *resultData=4; //商等于4
				 while_flag=1; //退出循环
			 }



			 break;
		 case 5:    //重点讲解一下case 5，其它case 原理相同，不多讲
			 ClearAllData(BCD8_MAX,DivLessTenArrayTemp); //清空运算中需要用到的中间数组变量
			 ClearAllData(BCD8_MAX,DivLessTenArrayResult); //清空运算中需要用到的中间数组变量
             DivLessTenArrayTemp[0]=resultRunStep;  //把猜的变量形式的商传递给数组形式的变量
			 multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);  //猜的商跟除数像乘，看看结果跟被除数谁大。
             cmpError=CmpData(DivLessTenArrayResult,destData); //猜的商跟除数像乘，看看结果跟被除数谁大。
			 if(cmpError==10) //等于 恭喜猜中是5
			 {
                 *resultData=5; //商等于5余数为0
				 while_flag=1; //退出循环
			 }
			 else if(cmpError==11) //大于   猜不中，大了，就继续往小的猜，看看有没有可能是3
			 {
                resultRunStep=3;
			 }
			 else             //小于        猜不中，小了，就继续往大的猜，看看有没有可能是7
			 {
                resultRunStep=7;

			    ClearAllData(BCD8_MAX,DivLessTenArrayBackup);
			    for(i=0;i<BCD8_MAX;i++) //备份
				{
			       DivLessTenArrayBackup[i]=DivLessTenArrayResult[i];
				}
			 }


			 break;
		 case 6:
			 ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
			 ClearAllData(BCD8_MAX,DivLessTenArrayResult);
             DivLessTenArrayTemp[0]=resultRunStep; 
			 multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
             cmpError=CmpData(DivLessTenArrayResult,destData);
			 if(cmpError==10) //等于
			 {
                 *resultData=6; //商等于6余数为0
				 while_flag=1; //退出循环
			 }
			 else if(cmpError==11) //大于
			 {
                 subError=SubData(destData,DivLessTenArrayBackup,remData);//求余数
                 *resultData=5; //商等于5
				 while_flag=1; //退出循环
			 }
			 else             //小于
			 {
                 subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
                 *resultData=6; //商等于6
				 while_flag=1; //退出循环
			 }


			 break;
		 case 7:
			 ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
			 ClearAllData(BCD8_MAX,DivLessTenArrayResult);
             DivLessTenArrayTemp[0]=resultRunStep; 
			 multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
             cmpError=CmpData(DivLessTenArrayResult,destData);
			 if(cmpError==10) //等于
			 {
                 *resultData=7; //商等于7余数为0
				 while_flag=1; //退出循环
			 }
			 else if(cmpError==11) //大于
			 {
                resultRunStep=6;
			 }
			 else             //小于
			 {
                resultRunStep=8;

		  	    ClearAllData(BCD8_MAX,DivLessTenArrayBackup);
			    for(i=0;i<BCD8_MAX;i++) //备份
				{
			       DivLessTenArrayBackup[i]=DivLessTenArrayResult[i];
				}
			 }



			 break;
		 case 8:
			 ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
			 ClearAllData(BCD8_MAX,DivLessTenArrayResult);
             DivLessTenArrayTemp[0]=resultRunStep; 
			 multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
             cmpError=CmpData(DivLessTenArrayResult,destData);
			 if(cmpError==10) //等于
			 {
                 *resultData=8; //商等于8余数为0
				 while_flag=1; //退出循环
			 }
			 else if(cmpError==11) //大于
			 {
                 subError=SubData(destData,DivLessTenArrayBackup,remData);//求余数
                 *resultData=7; //商等于7
				 while_flag=1; //退出循环
			 }
			 else             //小于
			 {
                resultRunStep=9;

		  	    ClearAllData(BCD8_MAX,DivLessTenArrayBackup);
			    for(i=0;i<BCD8_MAX;i++) //备份
				{
			       DivLessTenArrayBackup[i]=DivLessTenArrayResult[i];
				}
			 }

			 break;
		 case 9:
			 ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
			 ClearAllData(BCD8_MAX,DivLessTenArrayResult);
             DivLessTenArrayTemp[0]=resultRunStep; 
			 multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
             cmpError=CmpData(DivLessTenArrayResult,destData);
			 if(cmpError==10) //等于
			 {
                 *resultData=9; //商等于9余数为0
				 while_flag=1; //退出循环
			 }
			 else if(cmpError==11) //大于
			 {
                 subError=SubData(destData,DivLessTenArrayBackup,remData);//求余数
                 *resultData=8; //商等于8
				 while_flag=1; //退出循环
			 }
			 else             //小于
			 {
                 subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
                 *resultData=9; //商等于9
				 while_flag=1; //退出循环
			 }
			 break;

	  }
   
      if(while_flag==1)  //猜中了就退出循环
	  {
	     break;
	  }
   }

}

return DivLessTenResult;
}



/* 注释十二：
*函数介绍：两个数相除
*输入参数：
*（1）*destData--被除数的数组。
*（2）*sourceData--除数的数组。
*（3）*resultData--商的数组
*返回值  ：10代表计算结果超出范围出错，11代表正常。
*/
uchar Div(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar DivResult=11; //开始默认正常
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;
uchar j;
uchar resultTemp=0; //存放临时运算结果的中间变量
uchar DivArrayTemp[BCD8_MAX]; //存放临时运算结果的数组中间变量
uchar DivArrayResult[BCD8_MAX]; //存放临时运算结果的数组中间变量的结果
uchar divError=11;



destCnt=GetDataLength(destData,BCD8_MAX);   //获取被除数的数据有效长度
sourceCnt=GetDataLength(sourceData,BCD8_MAX);   //获取除数的数据有效长度


ClearAllData(BCD8_MAX,resultData);   //把结果清零

if(sourceCnt==0)  //除数为0，报错
{
   DivResult=10; //报错
}
else
{
   ClearAllData(BCD8_MAX,DivArrayTemp); //清零局部被除数的数组
   for(i=0;i<destCnt;i++)
   {
      DivArrayTemp[0]=destData[destCnt-1-i];  //从被除数的高位开始借位,放到局部被除数的个位
      divError=DivLessTenData(DivArrayTemp,sourceData,&resultTemp,DivArrayResult);  //局部相除，求商resultTemp，此商resultTemp不超过10
	  if(divError==10)  //报错
	  {
		DivResult=10;
	    break;
	  }
	  else
	  {
        resultData[destCnt-1-i]=resultTemp;  //保存商

	    for(j=0;j<(destCnt-1);j++)  //把余数移一次位,相当于放大十倍,重新放进DivArrayTemp数组对应的位
		{
	      DivArrayTemp[j+1]=DivArrayResult[j];
		}
	  }

   }

}



return DivResult;
}



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

     unsigned char i=0;   
     unsigned char k=0;   
         unsigned char ucGetDataStep=0;

     if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
     {

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

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

            uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
            while(uiRcMoveIndex<uiRcregTotal)  //说明还没有把缓冲区的数据读取完
            {
               if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)  //数据头eb 00 55的判断
               {
                    
                   i=0;
                   ucGetDataStep=0;
                   ucDataBCD4_cnt_1=0;  //第1个数组合BCD码数组的有效数据长度
                   ucDataBCD4_cnt_2=0;  //第2个数组合BCD码数组的有效数据长度

                   ClearAllData(BCD4_MAX,ucDataBCD4_1);  //清零第1个参与运算的数据
                   ClearAllData(BCD4_MAX,ucDataBCD4_2);  //清零第2个参与运算的数据

                   //以下while循环是通过关键字0x0d 0x0a来截取第1个和第2个参与运算的数据。
                   while(i<(BCD8_MAX+4))//这里+4是因为有2对0x0d 0x0a结尾特殊符号，一个共4个字节
                   {
                      if(ucGetDataStep==0)//步骤0，相当于我平时用的case 0,获取第1个数，在这里是指被除数
                      {
                           if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
                           {
                                for(k=0;k<ucDataBCD4_cnt_1;k++) //提取第1个参与运算的数组数据
                                {
                                    ucDataBCD4_1[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的 
                                }                                                                                                               
                                i=i+2; //跳过 0x0d 0x0a 这两个字节，进行下一轮的关键字提取
                                ucGetDataStep=1;  //切换到下一个关键字提取的步骤

                           }
                           else
                           {
                                i++;
                                ucDataBCD4_cnt_1++;  //统计第1个有效数据的长度
                           }
                                                                                                                         
                       }
                       else if(ucGetDataStep==1) //步骤1，相当于我平时用的case 1,获取第2个参与运行的数，在这里是除数
                       {
                           if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
                           {
                                for(k=0;k<ucDataBCD4_cnt_2;k++) //提取第2个参与运算的数组数据
                                {
                                    ucDataBCD4_2[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的 
                                }
                                                                                                                                                        
                                break; //截取数据完成。直接跳出截取数据的while(i<(BCD8_MAX+4))循环

                            }
                            else
                            {
                                i++;
                                ucDataBCD4_cnt_2++;  //统计第2个有效数据的长度
                            }
                       }
                    }


                    //注意ucDataBCD8_cnt_1和ucDataBCD8_cnt_2要带地址符号&传址进去
                    BCD4_to_BCD8(ucDataBCD4_1,ucDataBCD4_cnt_1,ucDataBCD8_1,&ucDataBCD8_cnt_1); //把接收到的组合BCD码转换成非组合BCD码  第1个数 
                    BCD4_to_BCD8(ucDataBCD4_2,ucDataBCD4_cnt_2,ucDataBCD8_2,&ucDataBCD8_cnt_2); //把接收到的组合BCD码转换成非组合BCD码  第2个数


                    ClearAllData(BCD8_MAX,ucDataBCD8_3);  //清零第3个参与运算的数据,用来接收运行的结果
                    ucResultFlag=Div(ucDataBCD8_1,ucDataBCD8_2,ucDataBCD8_3); //相除运算，结果放在ucDataBCD8_3数组里
                    if(ucResultFlag==11) //表示运算结果没有超范围
                    {
                       ucDataBCD8_cnt_3=GetDataLength(ucDataBCD8_3,BCD8_MAX);  //获取运算结果的有效字节数
                       if(ucDataBCD8_cnt_3==0) //如果1个有效位数都没有，表示数组所有的数据都是0，这个时候的有效位数应该人为的默认是1位数据,表示一个0
                       {
                          ucDataBCD8_cnt_3=1;
                       }

                       BCD8_to_BCD4(ucDataBCD8_3,ucDataBCD8_cnt_3,ucDataBCD4_3,&ucDataBCD4_cnt_3); //把非组合BCD码转成组合BCD码。注意，&ucDataBCD4_cnt_3带地址符号&
                       for(k=0;k<ucDataBCD4_cnt_3;k++) //返回运算结果到上位机上观察。看到的是组合BCD码形式。返回的时候注意数组下标的顺序要反过来发送，先发高位的下标数组
                       {
                          eusart_send(ucDataBCD4_3[ucDataBCD4_cnt_3-1-k]); //往上位机发送一个字节的函数
                       }
                    }
                    else //运算结果超范围，返回EE EE EE
                    {
                       eusart_send(0xee); //往上位机发送一个字节的函数
                       eusart_send(0xee); //往上位机发送一个字节的函数
                       eusart_send(0xee); //往上位机发送一个字节的函数
                    }

                    break;   //退出循环
               }
               uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
           }

           ucRcregBuf[0]=0; //把数据头清零，方便下次接收判断新数据
           ucRcregBuf[1]=0;
           ucRcregBuf[2]=0;          
                  
           uiRcregTotal=0;  //清空缓冲的下标，方便下次重新从0下标开始接受新数据
  
     }
                         
}

void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{

  ES = 0; //关串口中断
  TI = 0; //清零串口发送完成中断请求标志
  SBUF =ucSendData; //发送一个字节

  delay_short(400);  //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整

  TI = 0; //清零串口发送完成中断请求标志
  ES = 1; //允许串口中断

}



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


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



  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  //发送中断，及时把发送中断标志位清零
   {
        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 delay_short(unsigned int uiDelayShort) 
{
   unsigned int i;  
   for(i=0;i<uiDelayShort;i++)
   {
     ;   //一个分号相当于执行一条空语句
   }
}


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

}

 

总结陈词： 

前面四个章节讲完了四则运算的大数据算法，下一节讲单片机的外部中断功能。外部中断是单片机非常重要的内部资源，应用很广，它是单片机的高速开关感应器输入接口，它可以检测脉冲输入，可以接收红外遥控器的输入信号，可以检测高速运转的车轮或者电机圆周运动的反馈信号，可以检测输液器里瞬间即逝的水滴信号，可以接收模拟串口的数据信息，等等。单片机外部中断的有什么特点？欲知详情，请听下回分解----单片机外部中断的基础。

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

第六十六节：单片机外部中断的基础。

开场白：

外部中断是单片机非常重要的内部资源，应用很广，它是单片机的高速开关感应器输入接口，它可以检测脉冲输入，可以接收红外遥控器的输入信号，可以检测高速运转的车轮或者电机圆周运动的反馈信号，可以检测输液器里瞬间即逝的水滴信号，可以接收模拟串口的数据信息，等等。
    这一节要教大家两个知识点：
   第一个：外部中断的初始化代码和中断函数的基本程序模板。

   第二个：当系统存在两种中断以上时，如何设置外部中断0为最高优先级，实现中断嵌套功能。

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

（1）硬件平台：
    基于朱兆祺51单片机学习板。用S1按键作为模拟外部中断0的下降沿脉冲输入。原来S1按键是直接连接到P0^0口的，因此必须通过跳线把P0^0口连接到单片机外部中断0专用IO口P3^2上，只需把P0^0和P3^2的两根黄颜色跳冒去掉，通过一根线把P0^0和P3^2相互连接起来即可。这时每按下一次S1按键，就会给P3^2口产生一个下降沿的脉冲，然后程序会自动跳到中断函数中执行一次。

（2）实现功能：
    用数码管低4位显示记录当前的下降沿脉冲数。用S1按键经过跳线后模拟外部中断0的下降沿输入，每按一次数码管就会显示往上累加的脉冲数。由于按键按下去的时候有抖动，也就按一次可能产生几个脉冲，所以按一次往往看到数据一次加了三四个，这种实验现象都是正常的。

（3）源代码讲解如下：

#include "REG52.H"

#define const_voice_short  40   //蜂鸣器短叫的持续时间
#define const_key_time1  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 INT0_int();//外部0中断函数



sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平
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;  


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 ucWd=1;  //本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。本程序只有一个显示窗口
unsigned int  uiPluseCnt=0;  //本程序中累加中断脉冲数的变量

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)  
   { 
       display_service(); //显示的窗口菜单服务程序
   }
}


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位数码管显示无

              //先分解数据
               ucTemp4=uiPluseCnt/1000;     
               ucTemp3=uiPluseCnt%1000/100;
               ucTemp2=uiPluseCnt%100/10;
               ucTemp1=uiPluseCnt%10;
  
             //再过渡需要显示的数据到缓冲变量里，让过渡的时间越短越好

              //以下增加的if判断就是略作修改，把整个4位数据中高位为0的去掉不显示。
               if(uiPluseCnt<1000)   
               {
                   ucDigShow4=10;  //如果小于1000，千位显示无
               }
               else
               {
                  ucDigShow4=ucTemp4;  //第4位数码管要显示的内容
               }
               if(uiPluseCnt<100)
               {
                  ucDigShow3=10;  //如果小于100，百位显示无
               }
               else
               {
                  ucDigShow3=ucTemp3;  //第3位数码管要显示的内容
               }
               if(uiPluseCnt<10)
               {
                  ucDigShow2=10;  //如果小于10，十位显示无
               }
               else
               {
                  ucDigShow2=ucTemp2;  //第2位数码管要显示的内容
               }
               ucDigShow1=ucTemp1;  //第1位数码管要显示的内容
            }
            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;
}

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

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

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


/* 注释一：
 * 用朱兆祺51学习板中的S1按键作为模拟外部中断0的下降沿脉冲输入。
 * 原来S1按键是直接连接到P0^0口的，因此必须通过跳线把P0^0口连接到
 * 单片机外部中断0专用IO口P3^2上，只需把P0^0和P3^2的两个黄颜色跳冒去掉，通过一根
 * 线把P0^0和P3^2相互连接起来即可。这时每按下一次S1按键，就会给P3^2口
 * 产生一个下降沿的脉冲，然后程序会自动跳到以下中断函数中执行一次。
 * 由于按键按下去的时候有抖动，也就按一次可能产生几个脉冲，所以按一次往往看到数据一次加了三四个，
 * 这种实验现象都是正常的。
 */

void  INT0_int(void) interrupt 0  //INT0外部中断函数
{
   EX0=0;   //禁止外部0中断 这个只是我个人的编程习惯，也可以不关闭

   uiPluseCnt++;  //累计外部中断下降沿的脉冲数
   ucWd1Update=1;  //窗口1更新显示

   EX0=1;  //打开外部0中断
}

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就是本程序中用到的一个独立按键。S1经过跳线后
* 连接到单片机的外部中断专用接口P3^2上，用来模拟外部下降沿脉冲输入。
*/
  key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平
  beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。

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

void initial_peripheral() //初始化外围
{

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

   EX0=1; //允许外部中断0
   IT0=1;  //下降沿触发外部中断0   如果是0代表低电平中断

/* 注释三：
 * 注意，由于本系统中用了2个中断，一个是定时中断，一个是外部中断，
 * 因此必须设置IP寄存器，让外部中断0为最高优先级，让外部中断0可以打断
 * 定时中断。
 */

   IP=0x01; //设置外部中断0为最高优先级，可以打断低优先级中断服务。实现中断嵌套功能

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


}

 

总结陈词： 

    这节讲了外部中断的基本程序模板，下一节我会讲一个外部中断的实际应用项目例子。欲知详情，请听下回分解----利用外部中断实现模拟串口数据的收发。

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