×
嵌入式 > 嵌入式开发 > 详情

第65节：大数据的除法运算

发布时间：2020-08-18 发布时间：
|
开场白：
直接用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 0d0aYY YY 0d0a指令，其中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）源代码讲解如下：
  1. #include "REG52.H"
  4. /* 注释一：
  5. * 本系统中的除法运算，规定被除数和除数的最大范围是0至9999.
  6. * 由于STC89C52单片机的RAM只有256个，也就是说系统的变量数最大
  7. * 不能超过256个，如果超过了这个极限，编译器就会报错。由于51单片机RAM资源有限，
  8. * 因此规定除数的最大范围不能超过9999，如果这个算法移植到stm32或者PIC等RAM比较大
  9. * 的单片机上，那么就可以把这个运算位数设置得更加大一点。调整下面 BCD4_MAX的大小，
  10. * 可以调整运算的数据范围。
  11. */
  13. #defineBCD4_MAX 3//调整BCD4_MAX的大小，可以调整运算的数据范围。
  14. #defineBCD8_MAX (BCD4_MAX*2)//本系统中，规定的非组合BCD码能保存的最大字节数，一个字节包含1位有效运算数
  16. #define const_rc_size30//接收串口中断数据的缓冲区数组大小
  18. #define const_receive_time5//如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
  20. #define uchar unsigned char //方便移植平台
  21. #define ulong unsigned long //方便移植平台
  23. //如果在VC的平台模拟此算法，则都定义成int类型，如下：
  24. //#define uchar int
  25. //#define ulong int
  27. void initial_myself(void);
  28. void initial_peripheral(void);
  29. void delay_long(unsigned int uiDelaylong);
  30. void delay_short(unsigned int uiDelayShort);
  33. void T0_time(void);//定时中断函数
  34. void usart_receive(void); //串口接收中断函数
  35. void usart_service(void);//串口服务程序,在main函数里
  38. void eusart_send(unsigned char ucSendData);
  40. void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt);
  41. void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt);
  43. void ClearAllData(uchar ucARRAY_MAX,uchar *destData);
  44. uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX);
  45. uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData);//两个数相加
  46. uchar CmpData(const uchar *destData,const uchar *sourceData); //比较两个数的大小
  47. uchar SubData(const uchar *destData,const uchar *sourceData,uchar *resultData);//两个数相减
  48. void EnlargeData(uchar *destData,uchar enlarge_cnt); //数组向大索引值移位，移一位相当于放大10倍
  49. uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData); //两个数相乘
  51. uchar DivLessTenData(const uchar *destData,const uchar *sourceData,uchar *resultData,uchar *remData);//局部两个数相除，商不超过10。当商为0时，余数等于被除数
  52. uchar Div(const uchar *destData,const uchar *sourceData,uchar *resultData);//两个数相除
  54. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
  56. unsigned intuiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
  57. unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
  58. unsigned intuiRcregTotal=0;//代表当前缓冲区已经接收了多少个数据
  59. unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
  60. unsigned intuiRcMoveIndex=0;//用来解析数据协议的中间变量
  63. unsigned char ucDataBCD4_1[BCD4_MAX]; //接收到的第1个数组合BCD码数组形式这里是指被乘数
  64. unsigned char ucDataBCD4_cnt_1=0;//接收到的第1个数组合BCD码数组的有效数据长度
  66. unsigned char ucDataBCD4_2[BCD4_MAX]; //接收到的第2个数组合BCD码数组形式这里是指乘数
  67. unsigned char ucDataBCD4_cnt_2=0;//接收到的第2个数组合BCD码数组的有效数据长度
  69. unsigned char ucDataBCD4_3[BCD4_MAX]; //接收到的第3个数组合BCD码数组形式这里是指积
  70. unsigned char ucDataBCD4_cnt_3=0;//接收到的第3个数组合BCD码数组的有效数据长度
  73. unsigned char ucDataBCD8_1[BCD8_MAX]; //接收到的第1个数非组合BCD码数组形式 这里是指被乘数
  74. unsigned char ucDataBCD8_cnt_1=0;//接收到的第1个数非组合BCD码数组的有效数据长度
  76. unsigned char ucDataBCD8_2[BCD8_MAX]; //接收到的第2个数非组合BCD码数组形式 这里是指乘数
  77. unsigned char ucDataBCD8_cnt_2=0;//接收到的第2个数非组合BCD码数组的有效数据长度
  79. unsigned char ucDataBCD8_3[BCD8_MAX]; //接收到的第3个数非组合BCD码数组形式 这里是指积
  80. unsigned char ucDataBCD8_cnt_3=0;//接收到的第3个数非组合BCD码数组的有效数据长度
  82. unsigned char ucResultFlag=11; //运算结果标志，10代表计算结果超出范围出错，11代表正常。
  84. void main()
  85. {
  86. initial_myself();
  87. delay_long(100);
  88. initial_peripheral();
  89. while(1)
  90. {
  91. usart_service();//串口服务程序
  92. }
  94. }
  96. /* 注释二：
  97. * 组合BCD码转成非组合BCD码。
  98. * 这里的变量ucBCD4_cnt代表组合BCD码的有效字节数.
  99. * 这里的变量*p_ucBCD8_cnt代表经过转换后，非组合BCD码的有效字节数，记得加地址符号&传址进去
  100. * 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
  101. * 同时引进了组合BCD码的有效字节数变量。这样就不限定了数据的长度，
  102. * 可以让我们根据数据的实际大小灵活运用。
  103. */
  104. void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt)
  105. {
  106. unsigned char ucTmep;
  107. unsigned char i;
  109. for(i=0;i
  110. {
  111. p_ucBCD_bit8[i]=0;
  112. }
  115. *p_ucBCD8_cnt=ucBCD4_cnt*2; //转换成非组合BCD码后的有效数据长度
  117. for(i=0;i
  118. {
  119. ucTmep=p_ucBCD_bit4[ucBCD4_cnt-1-i];
  120. p_ucBCD_bit8[ucBCD4_cnt*2-i*2-1]=ucTmep>>4;
  121. p_ucBCD_bit8[ucBCD4_cnt*2-i*2-2]=ucTmep&0x0f;
  122. }
  124. }
  127. /* 注释三：
  128. * 非组合BCD码转成组合BCD码。
  129. * 这里的变量ucBCD8_cnt代表非组合BCD码的有效字节数.
  130. * 这里的变量*p_ucBCD4_cnt代表经过转换后，组合BCD码的有效字节数，记得加地址符号&传址进去
  131. * 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
  132. * 同时引进了非组合BCD码的有效字节数变量。这样就不限定了数据的长度，
  133. * 可以让我们根据数据的实际大小灵活运用。
  134. */
  135. void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt)
  136. {
  137. unsigned char ucTmep;
  138. unsigned char i;
  139. unsigned char ucBCD4_cnt;
  141. for(i=0;i
  142. {
  143. p_ucBCD_bit4[i]=0;
  144. }
  146. ucBCD4_cnt=(ucBCD8_cnt+1)/2; //非组合BCD码转化成组合BCD码的有效数,这里+1避免非组合数据长度是奇数位
  147. *p_ucBCD4_cnt=ucBCD4_cnt; //把转换后的结果付给接口指针的数据，可以对外输出结果
  149. for(i=0;i
  150. {
  151. ucTmep=p_ucBCD_bit8[ucBCD4_cnt*2-1-i*2]; //把非组合BCD码第8位分解出来
  152. p_ucBCD_bit4[ucBCD4_cnt-1-i]=ucTmep<<4;
  153. 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位分解出来
  154. }
  156. }
  158. /* 注释四：
  159. *函数介绍：清零数组的全部数组数据
  160. *输入参数：ucARRAY_MAX代表数组定义的最大长度
  161. *输入输出参数：*destData--被清零的数组。
  162. */
  164. void ClearAllData(uchar ucARRAY_MAX,uchar *destData)
  165. {
  166. uchar i;
  168. for(i=0;i
  169. {
  170. destData[i]=0;
  171. }
  173. }
  176. /* 注释五：
  177. *函数介绍：获取数组的有效长度
  178. *输入参数：*destData--被获取的数组。
  179. *输入参数：ucARRAY_MAX代表数组定义的最大长度
  180. *返回值：返回数组的有效长度。比如58786这个数据的有效长度是5
  181. *电子开发者作者：吴坚鸿
  182. */
  183. uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX)
  184. {
  185. uchar i;
  186. uchar DataLength=ucARRAY_MAX;
  187. for(i=0;i
  188. {
  189. if(0!=destData[ucARRAY_MAX-1-i])
  190. {
  191. break;
  192. }
  193. else
  194. {
  195. DataLength--;
  196. }
  198. }
  200. return DataLength;
  202. }
  205. /* 注释六：
  206. *函数介绍：比较两个数的大小
  207. *输入参数：
  208. *（1）*destData--被比较数的数组。
  209. *（2）*sourceData--比较数的数组。
  210. *返回值：9代表小于，10代表相等，11代表大于。
  211. */
  212. uchar CmpData(const uchar *destData,const uchar *sourceData)
  213. {
  214. uchar cmpResult=10; //开始默认相等
  215. uchar destCnt=0;
  216. uchar sourceCnt=0;
  217. uchar i;
  219. destCnt=GetDataLength(destData,BCD8_MAX);
  220. sourceCnt=GetDataLength(sourceData,BCD8_MAX);
  222. if(destCnt>sourceCnt)//大于
  223. {
  224. cmpResult=11;
  225. }
  226. else if(destCnt
  227. {
  228. cmpResult=9;
  229. }
  230. else if((destCnt==0)&&(sourceCnt==0))//如果都是等于0则等于
  231. {
  232. cmpResult=10;
  233. }
  234. else//否则就要继续判断
  235. {
  236. for(i=0;i
  237. {
  238. if(destData[destCnt-1-i]>sourceData[destCnt-1-i]) //从最高位开始判断,如果最高位大于则大于
  239. {
  240. cmpResult=11;
  241. break;
  242. }
  243. else if(destData[destCnt-1-i]
  244. {
  245. cmpResult=9;
  246. break;
  247. }
  249. //否则继续判断下一位
  250. }
  251. }
  254. return cmpResult;
  255. }
  258. /* 注释七：
  259. *函数介绍：两个数相减
  260. *输入参数：
  261. *（1）*destData--被减数的数组。
  262. *（2）*sourceData--减数的数组。
  263. *（3）*resultData--差的数组。注意，调用本函数前，必须先把这个数组清零
  264. *返回值：10代表计算结果是负数或者超出范围出错，11代表正常。
  265. */
  266. uchar SubData(const uchar *destData,const uchar *sourceData,uchar *resultData)
  267. {
  268. uchar subResult=11; //开始默认正常
  269. uchar destCnt=0;
  271. uchar i;
  272. uchar carryData=0;//进位
  273. uchar maxCnt=0; //最大位数
  274. uchar resultTemp=0; //存放临时运算结果的中间变量
  276. //为什么不在本函数内先把resultData数组清零？因为后面章节中的除法运算中要用到此函数实现连减功能。
  277. //因此如果纯粹实现减法运算时，在调用本函数之前，必须先在外面把差的数组清零，否则会计算出错。
  279. if(CmpData(destData,sourceData)==9)//被减数小于减数，报错
  280. {
  281. subResult=10;
  282. return subResult;//返回判断结果，并且退出本程序，不往下执行本程序余下代码
  283. }
  285. destCnt=GetDataLength(destData,BCD8_MAX);//获取被减数的有效数据长度
  286. maxCnt=destCnt;
  289. for(i=0;i
  290. {
  292. resultTemp=sourceData[i]+carryData; //按位相加
  293. if(resultTemp>destData[i])
  294. {
  295. resultData[i]=destData[i]+10-sourceData[i]-carryData; //借位
  296. carryData=1;
  297. }
  298. else
  299. {
  300. resultData[i]=destData[i]-sourceData[i]-carryData; //不用借位
  301. carryData=0;
  302. }
  304. }
  307. return subResult;
  308. }
  311. /* 注释八：
  312. *函数介绍：两个数相加
  313. *输入参数：
  314. *（1）*destData--被加数的数组。
  315. *（2）*sourceData--加数的数组。
  316. *（3）*resultData--和的数组。注意，调用本函数前，必须先把这个数组清零
  317. *返回值：10代表计算结果超出范围出错，11代表正常。
  318. */
  319. uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData)
  320. {
  321. uchar addResult=11; //开始默认返回的运算结果是正常
  322. uchar destCnt=0;
  323. uchar sourceCnt=0;
  324. uchar i;
  325. uchar carryData=0;//进位
  326. uchar maxCnt=0; //最大位数
  327. uchar resultTemp=0; //存放临时运算结果的中间变量
  329. //为什么不在本函数内先把resultData数组清零？因为后面章节中的乘法运算中要用到此函数实现连加功能。
  330. //因此如果纯粹实现加法运算时，在调用本函数之前，必须先在外面把和的数组清零，否则会计算出错。
  332. destCnt=GetDataLength(destData,BCD8_MAX); //获取被加数的有效位数
  333. sourceCnt=GetDataLength(sourceData,BCD8_MAX);//获取加数的有效位数
  335. if(destCnt>=sourceCnt)//找出两个运算数据中最大的有效位数
  336. {
  337. maxCnt=destCnt;
  338. }
  339. else
  340. {
  341. maxCnt=sourceCnt;
  342. }
  344. for(i=0;i
  345. {
  346. resultTemp=destData[i]+sourceData[i]+carryData; //按位相加
  347. resultData[i]=resultTemp%10; //截取最低位存放进保存结果的数组
  348. carryData=resultTemp/10; //存放进位
  349. }
  351. resultData[i]=carryData;
  353. if((maxCnt==BCD8_MAX)&&(carryData==1))//如果数组的有效位是最大值并且最后的进位是1，则计算溢出报错
  354. {
  356. ClearAllData(BCD8_MAX,resultData);
  358. addResult=10;//报错
  359. }
  362. return addResult;
  363. }
  367. /* 注释九：
  368. *函数介绍：数组向大索引值移位，移一位相当于放大10倍
  369. *输入参数：*destData--被移位的数组。
  370. *输入参数：enlarge_cnt--被移位的个数。
  371. */
  372. void EnlargeData(uchar *destData,uchar enlarge_cnt)
  373. {
  374. uchar i;
  376. if(enlarge_cnt!=0)
  377. {
  378. for(i=0;i
  379. {
  380. destData[BCD8_MAX-1-i]=destData[BCD8_MAX-1-enlarge_cnt-i];
  381. }
  383. for(i=0;i
  384. {
  385. destData[i]=0;
  386. }
  387. }
  389. }
  394. /* 注释十：
  395. *函数介绍：两个数相乘
  396. *输入参数：
  397. *（1）*destData--被乘数的数组。
  398. *（2）*sourceData--乘数的数组。
  399. *（3）*resultData--积的数组。
  400. *返回值：10代表计算结果超出范围出错，11代表正常。
  401. */
  402. uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData)
  403. {
  404. uchar multResult=11; //开始默认正常
  405. uchar destCnt=0;
  406. uchar sourceCnt=0;
  407. uchar i;
  408. uchar j;
  409. uchar carryData=0;//进位
  411. uchar resultTemp=0; //存放临时运算结果的中间变量
  413. uchar nc_add_result;//接收相加的运算是否超出范围，这里不用判断，因为不会溢出
  415. uchar multArrayTemp[BCD8_MAX]; //存放临时运算结果的数组中间变量
  419. destCnt=GetDataLength(destData,BCD8_MAX); //获取被乘数的长度
  420. sourceCnt=GetDataLength(sourceData,BCD8_MAX); //获取乘数的长度
  422. ClearAllData(BCD8_MAX,resultData); //清零存储的结果
  423. if((0==destCnt)||(0==sourceCnt)) //被乘数或者乘数为0，则结果为0
  424. {
  425. return multResult;
  426. }
  429. if((destCnt+sourceCnt+2)>BCD8_MAX)
  430. {
  431. multResult=10; //运算结果有可能超范围报错
  432. return multResult;
  433. }
  435. for(i=0;i
  436. {
  437. carryData=0; //清零进位
  438. ClearAllData(BCD8_MAX,multArrayTemp); //清零一位乘数相乘的结果中间变量数组
  439. for(j=0;j
  440. {
  441. resultTemp=destData[j]*sourceData[i]+carryData;//乘数的一位依次与被乘数各位相乘,并且加进位
  442. multArrayTemp[j]=resultTemp%10;//存储一位乘数相乘的结果
  443. carryData=resultTemp/10; //保存进位
  444. }
  445. multArrayTemp[j]=carryData; //存储最后的进位
  446. EnlargeData(multArrayTemp,i); //移位。移一次相当于放大10倍。
  447. nc_add_result=AddData(resultData,multArrayTemp,resultData); //把一位乘数相乘的结果存储进总结果
  449. }
  452. return multResult;
  453. }
  457. /* 注释十一：
  458. *函数介绍：局部两个数相除，商不超过10。当商为0时，余数是被除数
  459. *原理精髓：根据手工除法的原理，我们都是从高位开始借位相除，此时是局部相除，因此商都不超过10，剩下的余数继续借位
  460. *依次除下去。这个程序的除法原理是挨个猜值，反正商是从0，1,2.。。。9这10个数中的其中一个，为了快速找到我们想要的那个商，我是
  461. *利用中间法则进行寻找，先猜是5，然后判断一下是大了还是小了，如果是大了，就猜是3，如果小了就猜是7，最后肯定会找到商。
  462. *输入参数：
  463. *（1）*destData--被除数的数组。
  464. *（2）*sourceData--除数的数组。
  465. *（3）*resultData--商的数,不是数组，传址进去，是0,1,2到9中的某个数
  466. *（4）*remData--余数的数组。
  467. *返回值：10代表计算结果超出范围出错，11代表正常。
  468. */
  469. uchar DivLessTenData(const uchar *destData,const uchar *sourceData,uchar *resultData,uchar *remData)
  470. {
  471. uchar DivLessTenResult=11; //开始默认正常
  472. uchar destCnt=0;
  473. uchar sourceCnt=0;
  474. uchar i;
  478. uchar resultRunStep=5;
  479. uchar cmpError=10;
  480. uchar DivLessTenArrayTemp[BCD8_MAX]; //存放临时运算结果的数组中间变量
  481. uchar DivLessTenArrayResult[BCD8_MAX]; //存放临时运算结果的数组中间变量的结果
  482. uchar DivLessTenArrayBackup[BCD8_MAX]; //存放临时运算结果的数组中间变量的备份
  483. uchar while_flag=0;//结束猜算的中间变量
  484. uchar multError=11;
  485. uchar subError=11;
  487. destCnt=GetDataLength(destData,BCD8_MAX); //获取被除数的数据有效长度
  488. sourceCnt=GetDataLength(sourceData,BCD8_MAX); //获取除数的数据有效长度
  490. cmpError=CmpData(destData,sourceData); //比较被除数和除数的大小
  492. ClearAllData(BCD8_MAX,remData); //清空余数,余数为0
  494. if(cmpError==9) //被除数比除数小
  495. {
  496. *resultData=0; //商肯定为0
  497. for(i=0;i
  498. {
  499. remData[i]=destData[i]; //余数等于被除数
  500. }
  501. return DivLessTenResult;
  502. }
  503. else if(cmpError==10) //被除数与除数相等
  504. {
  506. *resultData=1; //商等于1余数为0
  507. return DivLessTenResult;
  508. }
  509. else//开始猜值
  510. {
  511. resultRunStep=5;//先猜是5,从这里开始直接看以下 case 5 的详细讲解，其他case原理相同
  512. while_flag=0;
  513. while(1)
  514. {
  515. switch(resultRunStep)
  516. {
  518. case 1:
  519. ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
  520. ClearAllData(BCD8_MAX,DivLessTenArrayResult);
  521. DivLessTenArrayTemp[0]=resultRunStep;
  522. multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
  524. subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
  525. *resultData=1; //商等于1
  526. while_flag=1; //退出循环
  527. break;
  528. case 2:
  529. ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
  530. ClearAllData(BCD8_MAX,DivLessTenArrayResult);
  531. DivLessTenArrayTemp[0]=resultRunStep;
  532. multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
  533. cmpError=CmpData(DivLessTenArrayResult,destData);
  534. if(cmpError==10) //等于
  535. {
  536. *resultData=2; //商等于2余数为0
  537. while_flag=1; //退出循环
  538. }
  539. else if(cmpError==11) //大于
  540. {
  541. resultRunStep=1;
  542. }
  543. else //小于
  544. {
  545. subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
  546. *resultData=2; //商等于2
  547. while_flag=1; //退出循环
  548. }
  553. break;
  554. case 3:
  555. ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
  556. ClearAllData(BCD8_MAX,DivLessTenArrayResult);
  557. DivLessTenArrayTemp[0]=resultRunStep;
  558. multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
  559. cmpError=CmpData(DivLessTenArrayResult,destData);
  560. if(cmpError==10) //等于
  561. {
  562. *resultData=3; //商等于3余数为0
  563. while_flag=1; //退出循环
  564. }
  565. else if(cmpError==11) //大于
  566. {
  567. resultRunStep=2;
  568. }
  569. else //小于
  570. {
  571. resultRunStep=4;
  573. ClearAllData(BCD8_MAX,DivLessTenArrayBackup);
  574. for(i=0;i
  575. {
  576. DivLessTenArrayBackup[i]=DivLessTenArrayResult[i];
  577. }
  578. }
  582. break;
  583. case 4:
  584. ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
  585. ClearAllData(BCD8_MAX,DivLessTenArrayResult);
  586. DivLessTenArrayTemp[0]=resultRunStep;
  587. multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
  588. cmpError=CmpData(DivLessTenArrayResult,destData);
  589. if(cmpError==10) //等于
  590. {
  591. *resultData=4; //商等于4余数为0
  592. while_flag=1; //退出循环
  593. }
  594. else if(cmpError==11) //大于
  595. {
  596. subError=SubData(destData,DivLessTenArrayBackup,remData);//求余数
  597. *resultData=3; //商等于3
  598. while_flag=1; //退出循环
  599. }
  600. else //小于
  601. {
  602. subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
  603. *resultData=4; //商等于4
  604. while_flag=1; //退出循环
  605. }
  609. break;
  610. case 5: //重点讲解一下case 5，其它case 原理相同，不多讲
  611. ClearAllData(BCD8_MAX,DivLessTenArrayTemp); //清空运算中需要用到的中间数组变量
  612. ClearAllData(BCD8_MAX,DivLessTenArrayResult); //清空运算中需要用到的中间数组变量
  613. DivLessTenArrayTemp[0]=resultRunStep;//把猜的变量形式的商传递给数组形式的变量
  614. multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);//猜的商跟除数像乘，看看结果跟被除数谁大。
  615. cmpError=CmpData(DivLessTenArrayResult,destData); //猜的商跟除数像乘，看看结果跟被除数谁大。
  616. if(cmpError==10) //等于 恭喜猜中是5
  617. {
  618. *resultData=5; //商等于5余数为0
  619. while_flag=1; //退出循环
  620. }
  621. else if(cmpError==11) //大于 猜不中，大了，就继续往小的猜，看看有没有可能是3
  622. {
  623. resultRunStep=3;
  624. }
  625. else //小于 猜不中，小了，就继续往大的猜，看看有没有可能是7
  626. {
  627. resultRunStep=7;
  629. ClearAllData(BCD8_MAX,DivLessTenArrayBackup);
  630. for(i=0;i
  631. {
  632. DivLessTenArrayBackup[i]=DivLessTenArrayResult[i];
  633. }
  634. }
  637. break;
  638. case 6:
  639. ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
  640. ClearAllData(BCD8_MAX,DivLessTenArrayResult);
  641. DivLessTenArrayTemp[0]=resultRunStep;
  642. multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
  643. cmpError=CmpData(DivLessTenArrayResult,destData);
  644. if(cmpError==10) //等于
  645. {
  646. *resultData=6; //商等于6余数为0
  647. while_flag=1; //退出循环
  648. }
  649. else if(cmpError==11) //大于
  650. {
  651. subError=SubData(destData,DivLessTenArrayBackup,remData);//求余数
  652. *resultData=5; //商等于5
  653. while_flag=1; //退出循环
  654. }
  655. else //小于
  656. {
  657. subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
  658. *resultData=6; //商等于6
  659. while_flag=1; //退出循环
  660. }
  663. break;
  664. case 7:
  665. ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
  666. ClearAllData(BCD8_MAX,DivLessTenArrayResult);
  667. DivLessTenArrayTemp[0]=resultRunStep;
  668. multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
  669. cmpError=CmpData(DivLessTenArrayResult,destData);
  670. if(cmpError==10) //等于
  671. {
  672. *resultData=7; //商等于7余数为0
  673. while_flag=1; //退出循环
  674. }
  675. else if(cmpError==11) //大于
  676. {
  677. resultRunStep=6;
  678. }
  679. else //小于
  680. {
  681. resultRunStep=8;
  683. ClearAllData(BCD8_MAX,DivLessTenArrayBackup);
  684. for(i=0;i
  685. {
  686. DivLessTenArrayBackup[i]=DivLessTenArrayResult[i];
  687. }
  688. }
  692. break;
  693. case 8:
  694. ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
  695. ClearAllData(BCD8_MAX,DivLessTenArrayResult);
  696. DivLessTenArrayTemp[0]=resultRunStep;
  697. multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
  698. cmpError=CmpData(DivLessTenArrayResult,destData);
  699. if(cmpError==10) //等于
  700. {
  701. *resultData=8; //商等于8余数为0
  702. while_flag=1; //退出循环
  703. }
  704. else if(cmpError==11) //大于
  705. {
  706. subError=SubData(destData,DivLessTenArrayBackup,remData);//求余数
  707. *resultData=7; //商等于7
  708. while_flag=1; //退出循环
  709. }
  710. else //小于
  711. {
  712. resultRunStep=9;
  714. ClearAllData(BCD8_MAX,DivLessTenArrayBackup);
  715. for(i=0;i
  716. {
  717. DivLessTenArrayBackup[i]=DivLessTenArrayResult[i];
  718. }
  719. }
  721. break;
  722. case 9:
  723. ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
  724. ClearAllData(BCD8_MAX,DivLessTenArrayResult);
  725. DivLessTenArrayTemp[0]=resultRunStep;
  726. multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
  727. cmpError=CmpData(DivLessTenArrayResult,destData);
  728. if(cmpError==10) //等于
  729. {
  730. *resultData=9; //商等于9余数为0
  731. while_flag=1; //退出循环
  732. }
  733. else if(cmpError==11) //大于
  734. {
  735. subError=SubData(destData,DivLessTenArrayBackup,remData);//求余数
  736. *resultData=8; //商等于8
  737. while_flag=1; //退出循环
  738. }
  739. else //小于
  740. {
  741. subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
  742. *resultData=9; //商等于9
  743. while_flag=1; //退出循环
  744. }
  745. break;
  747. }
  749. if(while_flag==1)//猜中了就退出循环
  750. {
  751. break;
  752. }
  753. }
  755. }
  757. return DivLessTenResult;
  758. }
  762. /* 注释十二：
  763. *函数介绍：两个数相除
  764. *输入参数：
  765. *（1）*destData--被除数的数组。
  766. *（2）*sourceData--除数的数组。
  767. *（3）*resultData--商的数组
  768. *返回值：10代表计算结果超出范围出错，11代表正常。
  769. */
  770. uchar Div(const uchar *destData,const uchar *sourceData,uchar *resultData)
  771. {
  772. uchar DivResult=11; //开始默认正常
  773. uchar destCnt=0;
  774. uchar sourceCnt=0;
  775. uchar i;
  776. uchar j;
  777. uchar resultTemp=0; //存放临时运算结果的中间变量
  778. uchar DivArrayTemp[BCD8_MAX]; //存放临时运算结果的数组中间变量
  779. uchar DivArrayResult[BCD8_MAX]; //存放临时运算结果的数组中间变量的结果
  780. uchar divError=11;
  784. destCnt=GetDataLength(destData,BCD8_MAX); //获取被除数的数据有效长度
  785. sourceCnt=GetDataLength(sourceData,BCD8_MAX); //获取除数的数据有效长度
  788. ClearAllData(BCD8_MAX,resultData); //把结果清零
  790. if(sourceCnt==0)//除数为0，报错
  791. {
  792. DivResult=10; //报错
  793. }
  794. else
  795. {
  796. ClearAllData(BCD8_MAX,DivArrayTemp); //清零局部被除数的数组
  797. for(i=0;i
  798. {
  799. DivArrayTemp[0]=destData[destCnt-1-i];//从被除数的高位开始借位,放到局部被除数的个位
  800. divError=DivLessTenData(DivArrayTemp,sourceData,&resultTemp,DivArrayResult);//局部相除，求商resultTemp，此商resultTemp不超过10
  801. if(divError==10)//报错
  802. {
  803. DivResult=10;
  804. break;
  805. }
  806. else
  807. {
  808. resultData[destCnt-1-i]=resultTemp;//保存商
  810. for(j=0;j
  811. {
  812. DivArrayTemp[j+1]=DivArrayResult[j];
  813. }
  814. }
  816. }
  818. }
  822. return DivResult;
  823. }
  827. void usart_service(void)//串口服务程序,在main函数里
  828. {
  830. unsigned char i=0;
  831. unsigned char k=0;
  832. unsigned char ucGetDataStep=0;
  834. if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
  835. {
  837. ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
  839. //下面的代码进入数据协议解析和数据处理的阶段
  841. uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
  842. while(uiRcMoveIndex
  843. {
  844. if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)//数据头eb 00 55的判断
  845. {
  847. i=0;
  848. ucGetDataStep=0;
  849. ucDataBCD4_cnt_1=0;//第1个数组合BCD码数组的有效数据长度
  850. ucDataBCD4_cnt_2=0;//第2个数组合BCD码数组的有效数据长度
  852. ClearAllData(BCD4_MAX,ucDataBCD4_1);//清零第1个参与运算的数据
  853. ClearAllData(BCD4_MAX,ucDataBCD4_2);//清零第2个参与运算的数据
  855. //以下while循环是通过关键字0x0d 0x0a来截取第1个和第2个参与运算的数据。
  856. while(i
  857. {
  858. if(ucGetDataStep==0)//步骤0，相当于我平时用的case 0,获取第1个数，在这里是指被除数
  859. {
  860. if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
  861. {
  862. for(k=0;k
  863. {
  864. ucDataBCD4_1[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
  865. }
  866. i=i+2; //跳过 0x0d 0x0a 这两个字节，进行下一轮的关键字提取
  867. ucGetDataStep=1;//切换到下一个关键字提取的步骤
  869. }
  870. else
  871. {
  872. i++;
  873. ucDataBCD4_cnt_1++;//统计第1个有效数据的长度
  874. }
  876. }
  877. else if(ucGetDataStep==1) //步骤1，相当于我平时用的case 1,获取第2个参与运行的数，在这里是除数
  878. {
  879. if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
  880. {
  881. for(k=0;k
  882. {
  883. ucDataBCD4_2[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
  884. }
  886. break; //截取数据完成。直接跳出截取数据的while(i
  888. }
  889. else
  890. {
  891. i++;
  892. ucDataBCD4_cnt_2++;//统计第2个有效数据的长度
  893. }
  894. }
  895. }
  898. //注意ucDataBCD8_cnt_1和ucDataBCD8_cnt_2要带地址符号&传址进去
  899. BCD4_to_BCD8(ucDataBCD4_1,ucDataBCD4_cnt_1,ucDataBCD8_1,&ucDataBCD8_cnt_1); //把接收到的组合BCD码转换成非组合BCD码第1个数
  900. BCD4_to_BCD8(ucDataBCD4_2,ucDataBCD4_cnt_2,ucDataBCD8_2,&ucDataBCD8_cnt_2); //把接收到的组合BCD码转换成非组合BCD码第2个数
  903. ClearAllData(BCD8_MAX,ucDataBCD8_3);//清零第3个参与运算的数据,用来接收运行的结果
  904. ucResultFlag=Div(ucDataBCD8_1,ucDataBCD8_2,ucDataBCD8_3); //相除运算，结果放在ucDataBCD8_3数组里
  905. if(ucResultFlag==11) //表示运算结果没有超范围
  906. {
  907. ucDataBCD8_cnt_3=GetDataLength(ucDataBCD8_3,BCD8_MAX);//获取运算结果的有效字节数
  908. if(ucDataBCD8_cnt_3==0) //如果1个有效位数都没有，表示数组所有的数据都是0，这个时候的有效位数应该人为的默认是1位数据,表示一个0
  909. {
  910. ucDataBCD8_cnt_3=1;
  911. }
  913. BCD8_to_BCD4(ucDataBCD8_3,ucDataBCD8_cnt_3,ucDataBCD4_3,&ucDataBCD4_cnt_3); //把非组合BCD码转成组合BCD码。注意，&ucDataBCD4_cnt_3带地址符号&
  914. for(k=0;k
  915. {
  916. eusart_send(ucDataBCD4_3[ucDataBCD4_cnt_3-1-k]); //往上位机发送一个字节的函数
  917. }
  918. }
  919. else //运算结果超范围，返回EE EE EE
  920. {
  921. eusart_send(0xee); //往上位机发送一个字节的函数
  922. eusart_send(0xee); //往上位机发送一个字节的函数
  923. eusart_send(0xee); //往上位机发送一个字节的函数
  924. }
  926. break; //退出循环
  927. }
  928. uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
  929. }
  931. ucRcregBuf[0]=0; //把数据头清零，方便下次接收判断新数据
  932. ucRcregBuf[1]=0;
  933. ucRcregBuf[2]=0;
  935. uiRcregTotal=0;//清空缓冲的下标，方便下次重新从0下标开始接受新数据
  937. }
  939. }
  941. void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
  942. {
  944. ES = 0; //关串口中断
  945. TI = 0; //清零串口发送完成中断请求标志
  946. SBUF =ucSendData; //发送一个字节
  948. delay_short(400);//每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整
  950. TI = 0; //清零串口发送完成中断请求标志
  951. ES = 1; //允许串口中断
  953. }
  957. void T0_time(void) interrupt 1 //定时中断
  958. {
  959. TF0=0;//清除中断标志
  960. TR0=0; //关中断
  963. if(uiSendCnt
  964. {
  965. uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
  966. ucSendLock=1; //开自锁标志
  967. }
  971. TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
  972. TL0=0x0b;
  973. TR0=1;//开中断
  974. }
  977. void usart_receive(void) interrupt 4 //串口接收数据中断
  978. {
  980. if(RI==1)
  981. {
  982. RI = 0;
  984. ++uiRcregTotal;
  985. if(uiRcregTotal>const_rc_size)//超过缓冲区
  986. {
  987. uiRcregTotal=const_rc_size;
  988. }
  989. ucRcregBuf[uiRcregTotal-1]=SBUF; //将串口接收到的数据缓存到接收缓冲区里
  990. uiSendCnt=0;//及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
  992. }
  993. else//发送中断，及时把发送中断标志位清零
  994. {
  995. TI = 0;
  996. }
  998. }
  1001. void delay_long(unsigned int uiDelayLong)
  1002. {
  1003. unsigned int i;
  1004. unsigned int j;
  1005. for(i=0;i
  1006. {
  1007. for(j=0;j<500;j++)//内嵌循环的空指令数量
  1008. {
  1009. ; //一个分号相当于执行一条空语句
  1010. }
  1011. }
  1012. }
  1014. void delay_short(unsigned int uiDelayShort)
  1015. {
  1016. unsigned int i;
  1017. for(i=0;i
  1018. {
  1019. ; //一个分号相当于执行一条空语句
  1020. }
  1021. }
  1024. void initial_myself(void)//第一区 初始化单片机
  1025. {
  1027. beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
  1029. //配置定时器
  1030. TMOD=0x01;//设置定时器0为工作方式1
  1031. TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
  1032. TL0=0x0b;
  1035. //配置串口
  1036. SCON=0x50;
  1037. TMOD=0X21;
  1038. TH1=TL1=-(11059200L/12/32/9600);//这段配置代码具体是什么意思，我也不太清楚，反正是跟串口波特率有关。
  1039. TR1=1;
  1041. }
  1043. void initial_peripheral(void) //第二区 初始化外围
  1044. {
  1046. EA=1; //开总中断
  1047. ES=1; //允许串口中断
  1048. ET0=1; //允许定时中断
  1049. TR0=1; //启动定时中断
  1051. }

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

『本文转载自网络,版权归原作者所有,如有侵权请联系删除』

上一篇:第64节：大数据的乘法运算 下一篇:第67节：利用外部中断实现模拟串口数据的收发

相关推荐

热门文章 更多
CC-Link现场总线及应用实例

技术

硬件开发 EMC IC封装设计 射频RF 单片机IMCU 信号完整性 FPGA 电源 PCB设计 物联网 PCB工艺 PCBA

阅读

电子汇 最新资讯 EDA365原创吧

资源

公开课 研讨会 在线计算器

互动

论坛 外包
电巢APP下载电巢APP下载
关于我们 ｜ 手机版 ｜ EDA365电子论坛网 (粤ICP备18020198号)
GMT, 2020-03-13 09:00 , Processed in 0.109375 second(s), 13 queries , Gzip On.