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

jianhong_wu · 发表于 2014-8-26 00:44:44

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

开场白：
直接用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; //启动定时中断
}

复制代码

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

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

又一个暑假 · 发表于 2014-8-28 09:26:44

jianhong_wu 发表于 2014-8-21 21:39
再过五节左右就会讲到多文件编程的。

后期会涉及讲12864液晶屏的章节吗

jianhong_wu · 发表于 2014-8-28 11:21:48

又一个暑假发表于 2014-8-28 09:26
后期会涉及讲12864液晶屏的章节吗

会的。再过五节左右就会讲到12864液晶屏。

又一个暑假 · 发表于 2014-9-1 18:48:07

jianhong_wu 发表于 2014-8-4 13:27
第六十一节：组合BCD码，非组合BCD码，以及数值三者之间的相互转换和关系。
开场白：
本来这一节打算讲 ...

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码

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

这两种写法有没有什么区别或什么好处

jianhong_wu · 发表于 2014-9-2 09:40:11

又一个暑假发表于 2014-9-1 18:48
p_ucBCD_bit8[7]=ulNumberTemp%100000000/10000000;//一个字节8位存储第8位非组合BCD码
p_ucBCD_b ...

这两种写法实现的功能都一样的。没有什么区别，也没有优劣之分。

又一个暑假 · 发表于 2014-9-2 09:41:38

jianhong_wu 发表于 2014-9-2 09:40
这两种写法实现的功能都一样的。没有什么区别，也没有优劣之分。

OK

karo · 发表于 2014-9-4 16:39:19

顶一个，给力作品。值得收藏啊。。。。呵呵

jianhong_wu · 发表于 2014-9-4 16:58:06

karo 发表于 2014-9-4 16:39
顶一个，给力作品。值得收藏啊。。。。呵呵

感谢夸奖。

jianhong_wu · 发表于 2014-9-5 07:08:11

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

开场白：
直接用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; //启动定时中断
}

复制代码

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

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

jianhong_wu · 发表于 2014-9-9 09:35:25

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

开场白：
外部中断是单片机非常重要的内部资源，应用很广，它是单片机的高速开关感应器输入接口，它可以检测脉冲输入，可以接收红外遥控器的输入信号，可以检测高速运转的车轮或者电机圆周运动的反馈信号，可以检测输液器里瞬间即逝的水滴信号，可以接收模拟串口的数据信息，等等。
这一节要教大家两个知识点：
第一个：外部中断的初始化代码和中断函数的基本程序模板。
第二个：当系统存在两种中断以上时，如何设置外部中断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; //启动定时中断
}

复制代码

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

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

jianhong_wu · 发表于 2014-9-13 15:26:50

第六十七节：利用外部中断实现模拟串口数据的收发。

开场白：
鸿哥曾经亲自用外部中断做过红外遥控器的数据接收，步进电机圆周运动的光电反馈信号检测，输液器里瞬间即逝的水滴信号，以及本节的模拟串口数据的接收，其实这些项目的原理都大同小异，会一样即可触类旁通其它的。
这一节要教大家四个知识点：
第一个：如何利用外部中断实现模拟串口数据的收发。
第二个：在退出外部中断函数时，必须通过软件把外部中断标志位IE0清零，否则在接收到的数据包最后面会多收到一个无效的字节0xFF。
第三个：实际做项目的时候，尽量利用单片机内部自带的集成串口，不到万不得已尽量不要用自制的模拟串口，如果非要用本节讲的模拟串口，那么一次接收的数据包不要太长，尽可能越短越好，因为自己做的模拟串口在稳定性上肯定比不上单片机自带的串口。这种模拟串口在批量生产时容易因为晶振的误差，以及外界各地温度的温差而影响产品的一致性，是有隐患的。
第四个：用模拟串口时，尽量不要选用动态数码管的显示方案，因为单片机在收发串口数据时，只能专心干一件事，此时不能中途被动态数码管扫描程序占用。而动态数码管得不到均匀扫描，就会产生略微闪烁的现象瑕疵。

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

（1）硬件平台：
基于坚鸿51单片机学习板。当把程序下载到单片机之后，要做以下跳线处理：
单片机原来的P3.1引脚是TI串口输出引脚，P3.0是RI串口输入引脚，分别把P3.1和P3.0的黄颜色跳冒去掉，同时也把外部中断0的引脚P3.2和一根IO口P1.0引脚的换颜色跳冒去掉，把P3.2跳冒的右针连接到P3.0跳冒的左针，作为模拟串口的接收数据线。把P1.0跳冒的右针连接到P3.1跳冒的左针，作为模拟串口的发送数据线。

（2）实现功能：
波特率是：9600 。
通过电脑串口调试助手模拟上位机，往单片机任意发送一串不超过10个的数据包，单片机如实地返回接收到的整包数据给上位机。

例如：
(a)上位机发送数据：01 02 03 04 05 06 07 08 09 0A
单片机返回： 01 02 03 04 05 06 07 08 09 0A

(b)上位机发送数据： 05 07 EE A8 F9
单片机返回： 05 07 EE A8 F9

（3）源代码讲解如下：

#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
#define const_rc_size 20 //接收串口中断数据的缓冲区数组大小
#define const_receive_time 5 //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
/* 注释一：
* 以下时序脉冲延时参数我是在keil uVision2 平台下,Memory Model在small模式，Code Rom Size在Large模式下编译的，
* 如果在不同keil版本，不同的模式下，编译出来的程序有可能此参数会不一样。
* 以下的时序脉冲延时参数是需要一步一步慢慢调的。我一开始的时候先编写一个简单的发送数据测试程序，
* 先确调试出合适的发送时序延时数据。然后再编写串口接收数据的程序，从而调试出接收时序的延时参数。
* 比如：我第一步发送数据的测试程序是这样的：
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
// usart_service(); //串口服务程序
eusart_send(0x08); //测试程序，让它不断发送数据给上位机观察，确保发送延时时序的参数准确性
delay_long(300);
eusart_send(0xE5); //测试程序，让它不断发送数据给上位机观察，确保发送延时时序的参数准确性
delay_long(300);
}
}
*/
#define const_t_1 10 //发送时序延时1 第一步先调出此数据
#define const_t_2 9 //发送时序延时2 第一步先调出此数据
#define const_r_1 7 //接收时序延时1 第二步再调出此数据
#define const_r_2 9 //接收时序延时2 第二步再调出此数据
void initial_myself(void);
void initial_peripheral(void);
void delay_long(unsigned int uiDelaylong);
void delay_short(unsigned int uiDelayShort);
void delay_minimum(unsigned char ucDelayMinimum); //细分度最小的延时,用char类型一个字节
void T0_time(void); //定时中断函数
void INT0_int(void); //外部0中断函数，在本系统中是模拟串口的接收中断函数。
void usart_service(void); //串口服务程序,在main函数里
void eusart_send(unsigned char ucSendData);
unsigned char read_eusart_byte();//从串口读一个字节
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
sbit ti_dr=P1^0; //模拟串口发送数据的IO口
sbit ri_sr=P3^2; //模拟串口接收数据的IO口也是外部中断0的复用IO口
unsigned int uiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned int uiRcregTotal=0; //代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
unsigned char ucTest=0;
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口服务程序
}
}
void usart_service(void) //串口服务程序,在main函数里
{
unsigned char i=0;
if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
{
ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
//下面的代码进入数据协议解析和数据处理的阶段
for(i=0;i<uiRcregTotal;i++) //返回全部接收到的数据包
{
eusart_send(ucRcregBuf[i]);
}
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
}
}
//往串口发送一个字节
void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{
unsigned char i=8;
EA=0; //关总中断
ti_dr=0; //发送启始位
delay_minimum(const_t_1); //发送时序延时1 delay_minimum是本程序细分度最小的延时
while(i--)
{
ti_dr=ucSendData&0x01; //先传低位
delay_minimum(const_t_2); //发送时序延时2 delay_minimum是本程序细分度最小的延时
ucSendData=ucSendData>>1;
}
ti_dr=1; //发送结束位
delay_short(400); //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整
EA=1; //开总中断
}
//从串口读取一个字节
unsigned char read_eusart_byte()
{
unsigned char ucReadData=0;
unsigned char i=8;
delay_minimum(const_r_1); //接收时序延时1 。作用是等过起始位 delay_minimum是本程序细分度最小的延时
while(i--)
{
ucReadData >>=1;
if(ri_sr==1)
{
ucReadData|=0x80; //先收低位
}
if(ri_sr==0) //此处空指令，是为了让驱动时序的时间保持一致性
{
;
}
delay_minimum(const_r_2); //接收时序延时2 delay_minimum是本程序细分度最小的延时
}
return ucReadData;
}
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 INT0_int(void) interrupt 0 //INT0外部中断函数
{
EX0=0; //禁止外部0中断这个只是我个人的编程习惯，也可以不关闭
++uiRcregTotal;
if(uiRcregTotal>const_rc_size) //超过缓冲区
{
uiRcregTotal=const_rc_size;
}
ucRcregBuf[uiRcregTotal-1]=read_eusart_byte(); //将串口接收到的数据缓存到接收缓冲区里
uiSendCnt=0; //及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
/* 注释二：
* 注意，此处必须把IE0中断标志清零，否则在接收到的数据包最后面会多收到一个无效的字节0xFF。
*/
IE0=0; //外部中断0标志位清零，必须的！
EX0=1; //打开外部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++)
{
; //一个分号相当于执行一条空语句
}
}
/* 注释三：
* 由于IO口模拟的串口时序要求很高，所以用的延时函数尽可能细分度越高越好，以下用一个字节的延时计时器
*/
void delay_minimum(unsigned char ucDelayMinimum) //细分度最小的延时,用char类型一个字节
{
unsigned char i;
for(i=0;i<ucDelayMinimum;i++)
{
; //一个分号相当于执行一条空语句
}
}
void initial_myself(void) //第一区初始化单片机
{
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
//配置定时器
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
}
void initial_peripheral(void) //第二区初始化外围
{
EX0=1; //允许外部中断0
IT0=1; //下降沿触发外部中断0 如果是0代表低电平中断
IP=0x01; //设置外部中断0为最高优先级，可以打断低优先级中断服务。实现中断嵌套功能
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}

复制代码

总结陈词：
这节讲完了外部中断的应用例子，下一节我会开始讲单片机C语言的多文件编程技巧。很多人也把多文件编程称作模块化编程，其实我觉得叫多文件编程会更加符合实际一些。多文件编程有两个最大的好处，一个是给我们的程序增加了目录，方便我们查找。另外一个好处是方便移植别人已经做好的功能程序模块，利用这个特点，特别适合团队一起做大型项目。很多初学者刚开始学多文件编程时，会经常遇到重复定义等问题，想知道怎么解决这些问题吗？欲知详情，请听下回分解----单片机C语言的多文件编程技巧。

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

waphaoyun · 发表于 2014-9-14 20:35:01

jianhong_wu 发表于 2014-9-13 15:26
第六十七节：利用外部中断实现模拟串口数据的收发。

开场白：

鸿哥辛苦了，我表示一直在看，

jianhong_wu · 发表于 2014-9-14 21:08:05

waphaoyun 发表于 2014-9-14 20:35
鸿哥辛苦了，我表示一直在看，

感谢你的鼓励。

jianhong_wu · 发表于 2014-9-17 13:39:45

第六十八节：单片机C语言的多文件编程技巧。

开场白：

很多人也把多文件编程称作模块化编程，其实我觉得叫多文件编程会更加符合实际一些。多文件编程有两个最大的好处，一个是给我们的程序增加了目录，方便我们查找。另外一个好处是方便移植别人已经做好的功能程序模块，利用这个特点，特别适合团队一起做大型项目。很多初学者刚开始学多文件编程时，会经常遇到重复定义等问题，想知道怎么解决这些问题吗？只要按照以下鸿哥教的规则来做，这些问题就不存在了。

第一个：每个文件保持成双成对出现。每个.c源文件必须有一个.h头文件跟它对应，每个.h头文件必须有一个.c源文件跟它对应。比如：main.c与main.h，delay.c与 delay.h。

第二个：.c源文件只负责函数的定义和变量的定义，但是不负责函数的声明和变量的声明。比如：

unsigned char ucLedStep=0; //这个是全局变量的定义

void led_flicker() //这个是函数的定义

{

//…里面是具体代码内容

}

第三个：.h头文件只负责函数的声明和变量的声明，以及常量和IO口的宏定义，但是不负责函数的定义和变量的定义。比如：

#define const_time_level 200 //这个是常量的宏定义

sbit led_dr=P3^5; //这个是IO口的宏定义

void led_flicker(); //这个是函数的声明

extern unsigned char ucLedStep; //这个是全局变量的声明，不能赋初始值

第四个：每个.h头文件都必须固定以#ifndef，#define，#endif语句为模板，此模板是用来避免编译时由于重复包含头文件里面的内容而导致出错。其中标志变量_XXX_鸿哥建议用它本身的文件名称加前后下划线_。

比如：

#ifndef _LED_ //标志变量_LED_是用它本身的文件名称命名

#define _LED_ //标志变量_LED_是用它本身的文件名称命名

#define const_time_level 200 //这个是常量的宏定义

sbit led_dr=P3^5; //这个是IO口的宏定义

void led_flicker(); //这个是函数的声明

extern unsigned char ucLedStep; //这个是全局变量的声明，不能赋初始值

#endif

第五个：每个.h头文件里都必须声明它对应的.c源文件里的所有定义函数和全局变量，注意：.c源文件里所有的全局变量都要在它所对应的.h头文件里声明一次，不仅仅是函数，这个地方很容易被人忽略。

比如：在led.h头文件中:

void led_flicker(); //这个是函数的声明,因为在这个函数在led.c文件里定义了。

extern unsigned char ucLedStep; //这个是全局变量的声明，不许赋初值

第六个：每个.c源文件里都必须包含两个文件，一个是单片机的系统头文件REG52.H，另外一个是它自己本身的头文件比如initial.h.剩下其它的头文件看实际情况来决定是否调用，我们用到了哪些文件的函数，全局变量或者宏定义，就需要调用对应的头文件。

比如：在initial.c源文件中:

#include"REG52.H" //必须包含的单片机系统头文件

#include"initial.h" //必须包含它本身的头文件

/* 注释：

由于本源文件中用到了led_dr的语句，而led_dr是在led.h文件里宏定义的，所以必须把led.h也包含进来

*/

#include"led.h" //由于本源文件中用到了led_dr的语句，所以必须把led.h也包含进来

void initial_myself() //这个是函数定义

{

led_dr=0; //led_dr是在led文件里定义和声明的

}

第七个：声明一个全局变量必须加extern关键字，同时千万不能在声明全局变量的时候赋初始值，比如：

extern unsigned char ucLedStep=0; //这样是绝对错误的。

extern unsigned char ucLedStep; //这个是全局变量的声明，这个才是正确的

第八个：对于函数与全局变量的声明，编译器都不分配内存空间。对于函数与全局变量的定义，编译器都分配内存空间。函数与全局变量的定义只能在一个.c源文件中出现一次，而函数与全局变量的声明可以在多个.h文件中出现。

具体内容，请看源代码讲解，本程序例程是直接把前面第四节一个源文件更改成多文件编程方式。

（1）硬件平台：
基于朱兆祺51单片机学习板。把前面第四节一个源文件更改成多文件编程方式。

（2）实现功能：跟前面第四节的功能一模一样，让一个LED闪烁。

（3）keil多文件编程的截图预览：

（4）整个源代码讲解工程文件下载：

more_file_4.rar (23.69 KB, 下载次数: 2763)

（5）源代码讲解如下（注意，以下代码不能直接放到一个源文件里编译）：

/*以下是 main.h 的内容*/

/* 注释一：
  每个头文件都是固定以#ifndef，#define，#endif
  为模板，其中标志变量_XXX_我建议用它本身的文件名称加前后下划线_。
  此标志变量名称是用来预防多次包含出错的，详细讲解请看注释二。
  每个头文件只做函数的声明和变量的声明，以及常量和IO口的宏定义，不做
  函数的定义与变量的定义。
*/
#ifndef _MAIN_ //标志变量_MAIN_是用它本身的文件名称命名
#define _MAIN_ //标志变量_MAIN_是用它本身的文件名称命名

void main();  //这个是函数的声明

#endif

/* 注释二：
以上语句
#ifndef
#define
插入其它内容...
#endif

类似于把_MAIN_看成是一个标志变量
if(_MAIN_==0)  // 相当于#ifndef _MAIN_
{
_MAIN_=1;  // 相当于#define _MAIN_
   插入其它内容...

}             //相当于#endif

目的是通过一个标志位变量的赋值，让编译器在编译的时候，只包含一次此头文件，避免多次包含出错
*/

/*------分割线--------------------------------------------------*/

/*以下是 main.c 的内容*/

/* 注释一：
  每个源文件都必须包含两个文件，一个是单片机的系统头文件REG52.H，
  另外一个是它自己本身的头文件main.h.剩下其它的头文件看实际情况来
  决定是否调用，我们用到了哪些文件的函数，全局变量或者宏定义，就需要调用对应的头文件。
  每个源文件只做函数的定义和变量的定义，不做函数的声明和变量的声明。
*/

#include "REG52.H"  //必须包含的单片机系统头文件
#include "main.h"  //必须包含它本身的头文件

/* 注释二：
(1)由于本源文件中调用initial_myself()和initial_peripheral()函数，而这两个函数
   都是在initial文件里定义和声明的，所以必须把initial.h也包含进来。
(2)由于本源文件中调用delay_long(100)函数，而这个函数
   是在delay文件里定义和声明的，所以必须把delay.h也包含进来。
(2)由于本源文件中调用led_flicker()函数，而这个函数
   是在led文件里定义和声明的，所以必须把led.h也包含进来。
*/

#include "initial.h"  //由于本源文件中用到了initial_myself()和initial_peripheral()函数，所以必须把initial.h也包含进来
#include "delay.h"  //由于本源文件中用到了delay_long(100)函数，所以必须把delay.h也包含进来
#include "led.h"  //由于本源文件中用到了led_flicker()函数，所以必须把led.h也包含进来

void main()  //这个是函数的定义
  {
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
   led_flicker();
}

}

/*------分割线--------------------------------------------------*/

/*以下是 delay.h 的内容*/

#ifndef _DELAY_ //标志变量_DELAY_是用它本身的文件名称命名
#define _DELAY_ //标志变量_DELAY_是用它本身的文件名称命名

void delay_long(unsigned int uiDelaylong); //这个是函数的声明，每一个源文件里的函数都要在它的头文件里声明

#endif

/*------分割线--------------------------------------------------*/

/*以下是 delay.c 的内容*/

#include "REG52.H"  //必须包含的单片机系统头文件
#include "delay.h"  //必须包含它本身的头文件

void delay_long(unsigned int uiDelayLong)  //这个是函数的定义
{
unsigned int i; //这个是局部变量的定义
unsigned int j; //这个是局部变量的定义
for(i=0;i<uiDelayLong;i++)
{
   for(j=0;j<500;j++)
      {
         ;
      }
}
}
/*------分割线--------------------------------------------------*/
/*以下是 initial.h 的内容*/

#ifndef _INITIAL_ //标志变量_INITIAL_是用它本身的文件名称命名
#define _INITIAL_ //标志变量_INITIAL_是用它本身的文件名称命名

void initial_myself(); //这个是函数声明，每一个源文件里的函数都要在它的头文件里声明
void initial_peripheral(); //这个是函数声明，每一个源文件里的函数都要在它的头文件里声明

#endif

/*------分割线--------------------------------------------------*/
/*以下是 initial.c 的内容*/

#include "REG52.H"  //必须包含的单片机系统头文件
#include "initial.h"  //必须包含它本身的头文件

/* 注释一：
由于本源文件中用到了led_dr的语句，而led_dr是在led文件里宏定义的，所以必须把led.h也包含进来
*/
#include "led.h"  //由于本源文件中用到了led_dr的语句，所以必须把led.h也包含进来

void initial_myself()  //这个是函数定义
{

  TMOD=0x01;  //以下能直接用TMOD,TH0,TL0,EA,ET0,TR0这些寄存器关键字，是因为包含了REG52.H头文件

  TH0=0xf8;
  TL0=0x2f;

  led_dr=0;  //led_dr是在led文件里定义和声明的
}

void initial_peripheral() //这个是函数定义
{
  EA=1;
  ET0=1;
  TR0=1;

}

/*------分割线--------------------------------------------------*/
/*以下是 interrupt.h 的内容*/

#ifndef _INTERRUPT_ //标志变量_INTERRUPT_是用它本身的文件名称命名
#define _INTERRUPT_ //标志变量_INTERRUPT_是用它本身的文件名称命名

void T0_time();  //这个是函数声明，每一个源文件里的函数都要在它的头文件里声明

/* 注释一：
声明一个外部全局变量必须加extern关键字，同时千万不能在声明全局变量的时候赋初始值，比如：
extern unsigned int uiTimeCnt=0; 这样是绝对错误的。
*/
extern unsigned int uiTimeCnt; //这个是全局变量的声明，不能赋初始值

#endif

/*------分割线--------------------------------------------------*/
/*以下是 interrupt.c 的内容*/

#include "REG52.H"  //必须包含的单片机系统头文件
#include "interrupt.h"  //必须包含它本身的头文件

unsigned int uiTimeCnt=0; //这个是全局变量的定义，可以赋初值

void T0_time() interrupt 1  //这个是函数定义
{
  TF0=0; //以下能直接用TF0,TR0,TH0,TL0这些寄存器关键字，是因为包含了REG52.H头文件
  TR0=0;

  if(uiTimeCnt<0xffff)
  {
   uiTimeCnt++;
  }

  TH0=0xf8;
  TL0=0x2f;
  TR0=1;
}

/*------分割线--------------------------------------------------*/
/*以下是 led.h 的内容*/

#ifndef _LED_ //标志变量_LED_是用它本身的文件名称命名
#define _LED_ //标志变量_LED_是用它本身的文件名称命名

#define const_time_level 200 //宏定义都放在头文件里

/* 注释一：
  IO口的宏定义也放在头文件里，
  如果是PIC单片机，以下IO口定义相当于宏定义 #define  led_dr LATBbits.LATB4等语句
*/
sbit led_dr=P3^5; //如果是PIC单片机，相当于宏定义 #define  led_dr LATBbits.LATB4等语句

void led_flicker(); //这个是函数的声明，每一个源文件里的函数都要在它的头文件里声明

/* 注释三：
声明一个全局变量必须加extern关键字，同时千万不能在声明全局变量的时候赋初始值，比如：
extern unsigned char ucLedStep=0; 这样是绝对错误的。
*/
extern unsigned char ucLedStep; //这个是全局变量的声明

#endif

/*------分割线--------------------------------------------------*/
/*以下是 led.c 的内容*/

#include "REG52.H"  //必须包含的单片机系统头文件
#include "led.h"  //必须包含它本身的头文件

/* 注释一：
由于本源文件中用到了uiTimeCnt全局变量，而uiTimeCnt是在interrupt文件里声明和定义的，
所以必须把interrupt.h也包含进来
*/
#include "interrupt.h"  //必须包含它本身的头文件

unsigned char ucLedStep=0; //这个是全局变量的定义，可以赋初值

void led_flicker() //这个是函数的定义
{
  switch(ucLedStep)
  {
   case 0:

      if(uiTimeCnt>=const_time_level)
      {

         ET0=0;  //以下能直接用ET0寄存器关键字，是因为包含了REG52.H头文件
         uiTimeCnt=0; //uiTimeCnt此变量是在interrupt文件里声明和定义的，所以必须把interrupt.h也包含进来
         ET0=1;
         led_dr=1;  //此IO口定义已经在led.h头文件中定义了
         ucLedStep=1; //切换到下一个步骤
      }
      break;
   case 1:
      if(uiTimeCnt>=const_time_level)
      {
         ET0=0;
         uiTimeCnt=0;
         ET0=1;
         led_dr=0;
         ucLedStep=0; //返回到上一个步骤
      }
      break;

  }

}

/*------分割线--------------------------------------------------*/

总结陈词：

下一节开始讲液晶屏显示方面的内容。欲知详情，请听下回分解----带字库12864液晶屏的常用点阵字体程序。

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

admin · 发表于 2014-9-17 15:09:12

感谢分享，继续加油。

admin · 发表于 2014-9-17 15:13:14

很好。非常好。

测试01 · 发表于 2014-9-17 16:00:58

内容很好。太给力了。

jianhong_wu · 发表于 2014-9-18 12:51:27

第六十九节：使用static关键字可以减少全局变量的使用

开场白：
本来这一节打算开始讲液晶屏的，但是昨天经过网友“任军”的点拨，我发现了一个惊天秘密，原来static关键字是这么好的东西我却错过了那么多年。以前就有一些网友抱怨，鸿哥的程序好是好，就是全局变量满天飞，当时我觉得我也没招呀，C语言就全局变量和局部变量，单单靠局部变量肯定不行，局部变量每次进入函数内部数值都会被初始化改变，所以我在很多场合也只能靠全局变量了。但是自从昨天知道了static关键字的秘密后，我恍然大悟，很多场合只要在局部变量前面加上static关键字，就可以大大减少全局变量的使用了。
这一节要教会大家一个知识点：
  大家都知道，普通的局部变量在每次程序执行到函数内部的时候，数值都会被重新初始化，数值会发生变化，不能保持之前的数值。但是在局部变量加上static关键字后，系统在刚上电的时候就已经把带static的局部变量赋初始值了，从此程序每次进入函数内部，都不会初始化带static关键字的局部变量，它会保持最近一次被程序执行更改的数值不变，像全局变量一样。跟全局变量唯一的差别是，带static关键字的局部变量的作用域仅仅在函数内部，而普通全局变量的作用域是整个工程。

本程序例程是直接在第八节程序上修改，大大减少了全局变量的使用。具体内容，请看源代码讲解。

（1）硬件平台：
   基于坚鸿51单片机学习板。用矩阵键盘中的S1和S5号键作为独立按键，记得把输出线P0.4一直输出低电平，模拟独立按键的触发地GND。

（2）实现功能：跟前面第八节的功能一模一样，有两个独立按键，每按一个独立按键，蜂鸣器发出“滴”的一声后就停。

（3）源代码讲解如下：

#include "REG52.H"

#define const_voice_short  40

#define const_key_time1  20
#define const_key_time2  20

void initial_myself();
void initial_peripheral();
void delay_long(unsigned int uiDelaylong);
void T0_time();
void key_service();
void key_scan();

sbit key_sr1=P0^0;
sbit key_sr2=P0^1;
sbit key_gnd_dr=P0^4;

sbit beep_dr=P2^7;

unsigned char ucKeySec=0; //一些需要在不同函数之间使用的核心变量，只能用全局变量
unsigned int  uiVoiceCnt=0;  //一些需要在不同函数之间使用的核心变量，只能用全局变量

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

}

void key_scan()
{
/* 注释一：
(1)大家都知道，普通的局部变量在每次程序执行到函数内部的时候，数值都会被重新初始化，
数值会发生变化，不能保持之前的数值。
(2)但是在局部变量加上static关键字后，系统在刚上电的时候就已经把带static的局部变量
赋初始值了，从此程序每次进入函数内部，都不会初始化带static关键字的局部变量，它会保持
最近一次被程序执行更改的数值不变，像全局变量一样。跟全局变量唯一的差别是，带static关键字
的局部变量的作用域仅仅在函数内部，而普通全局变量的作用域是整个工程。
(3)以下这些变量我原来在第八节是用普通全局变量的，现在改成用static的局部变量了，减少了全局变量
的使用，让程序阅读起来更加简洁。大家也可以试试把以下变量的static去掉试试，结果会发现去掉了static后，
按键就不会被触发了。
*/

static unsigned int  uiKeyTimeCnt1=0; //带static的局部变量
static unsigned char ucKeyLock1=0;
static unsigned int  uiKeyTimeCnt2=0;
static unsigned char ucKeyLock2=0;

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

  if(key_sr2==1)
  {
   ucKeyLock2=0;
      uiKeyTimeCnt2=0;
  }
  else if(ucKeyLock2==0)
  {
   uiKeyTimeCnt2++;
   if(uiKeyTimeCnt2>const_key_time2)
   {
      uiKeyTimeCnt2=0;
      ucKeyLock2=1;
      ucKeySec=2;
   }
  }

}

void key_service()
{
  switch(ucKeySec)
  {
case 1:

      uiVoiceCnt=const_voice_short;
      ucKeySec=0;
      break;
case 2:
      uiVoiceCnt=const_voice_short;
      ucKeySec=0;
      break;
  }
}

void T0_time() interrupt 1
{
  TF0=0;
  TR0=0;

  key_scan();

  if(uiVoiceCnt!=0)
  {
   uiVoiceCnt--;
   beep_dr=0;
  }
  else
  {
   ;
   beep_dr=1;
  }

  TH0=0xf8;
  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()
{

  key_gnd_dr=0;

  beep_dr=1;

  TMOD=0x01;

  TH0=0xf8;
  TL0=0x2f;

}
void initial_peripheral()
{
  EA=1;
  ET0=1;
  TR0=1;
}
总结陈词：
下一节开始讲液晶屏显示方面的内容。欲知详情，请听下回分解----带字库12864液晶屏的常用点阵字体程序。

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

KR770906 · 发表于 2014-9-21 08:58:11

贴合实战，膜拜鸿哥。

jianhong_wu · 发表于 2014-9-22 00:43:18

KR770906 发表于 2014-9-21 08:58
贴合实战，膜拜鸿哥。

感谢支持。

帐号		自动登录	找回密码
密码			立即注册

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