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

第64节：大数据的乘法运算

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

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

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

（2）实现功能：
波特率是：9600 。
通过电脑串口调试助手模拟上位机，往单片机发送组合BCD码的被乘数和乘数，单片机把组合BCD码的运算结果返回到上位机。被乘数与乘数的最大范围都是从0到99，如果运算的乘积超过允许保存的最大位数范围则返回EE EE EE报错。
往单片机发送的数据格式：EB 00 55 XX0d0aYY0d0a指令，其中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）源代码讲解如下：
  1. #include "REG52.H"
  4. /* 注释一：
  5. * 本系统中的乘法运算，规定两个乘数的最大范围是0至99.
  6. * 由于STC89C52单片机的RAM只有256个，也就是说系统的变量数最大
  7. * 不能超过256个，如果超过了这个极限，编译器就会报错。由于51单片机RAM资源有限，
  8. * 因此规定乘数的最大范围不能超过99，如果这个算法移植到stm32或者PIC等RAM比较大
  9. * 的单片机上，那么就可以把这个运算位数设置得更加大一点。调整下面 BCD4_MAX的大小，
  10. * 可以调整运算的数据范围。
  11. */
  13. #defineBCD4_MAX 3//为了让乘法的结果不超过范围，因此把组合BCD码最大字节数从上一节的2改成3，一个字节包含2位，因此可以保存6位有效数
  14. #defineBCD8_MAX (BCD4_MAX*2)//本系统中，规定的非组合BCD码能保存的最大字节数，一个字节包含1位，因此能保存6位有效运算数
  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. void EnlargeData(uchar *destData,uchar enlarge_cnt); //数组向大索引值移位，移一位相当于放大10倍
  47. uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData); //两个数相乘
  49. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
  51. unsigned intuiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
  52. unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
  53. unsigned intuiRcregTotal=0;//代表当前缓冲区已经接收了多少个数据
  54. unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
  55. unsigned intuiRcMoveIndex=0;//用来解析数据协议的中间变量
  58. unsigned char ucDataBCD4_1[BCD4_MAX]; //接收到的第1个数组合BCD码数组形式这里是指被乘数
  59. unsigned char ucDataBCD4_cnt_1=0;//接收到的第1个数组合BCD码数组的有效数据长度
  61. unsigned char ucDataBCD4_2[BCD4_MAX]; //接收到的第2个数组合BCD码数组形式这里是指乘数
  62. unsigned char ucDataBCD4_cnt_2=0;//接收到的第2个数组合BCD码数组的有效数据长度
  64. unsigned char ucDataBCD4_3[BCD4_MAX]; //接收到的第3个数组合BCD码数组形式这里是指积
  65. unsigned char ucDataBCD4_cnt_3=0;//接收到的第3个数组合BCD码数组的有效数据长度
  68. unsigned char ucDataBCD8_1[BCD8_MAX]; //接收到的第1个数非组合BCD码数组形式 这里是指被乘数
  69. unsigned char ucDataBCD8_cnt_1=0;//接收到的第1个数非组合BCD码数组的有效数据长度
  71. unsigned char ucDataBCD8_2[BCD8_MAX]; //接收到的第2个数非组合BCD码数组形式 这里是指乘数
  72. unsigned char ucDataBCD8_cnt_2=0;//接收到的第2个数非组合BCD码数组的有效数据长度
  74. unsigned char ucDataBCD8_3[BCD8_MAX]; //接收到的第3个数非组合BCD码数组形式 这里是指积
  75. unsigned char ucDataBCD8_cnt_3=0;//接收到的第3个数非组合BCD码数组的有效数据长度
  77. unsigned char ucResultFlag=11; //运算结果标志，10代表计算结果超出范围出错，11代表正常。
  79. void main()
  80. {
  81. initial_myself();
  82. delay_long(100);
  83. initial_peripheral();
  84. while(1)
  85. {
  86. usart_service();//串口服务程序
  87. }
  89. }
  91. /* 注释二：
  92. * 组合BCD码转成非组合BCD码。
  93. * 这里的变量ucBCD4_cnt代表组合BCD码的有效字节数.
  94. * 这里的变量*p_ucBCD8_cnt代表经过转换后，非组合BCD码的有效字节数，记得加地址符号&传址进去
  95. * 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
  96. * 同时引进了组合BCD码的有效字节数变量。这样就不限定了数据的长度，
  97. * 可以让我们根据数据的实际大小灵活运用。
  98. */
  99. void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt)
  100. {
  101. unsigned char ucTmep;
  102. unsigned char i;
  104. for(i=0;i
  105. {
  106. p_ucBCD_bit8[i]=0;
  107. }
  110. *p_ucBCD8_cnt=ucBCD4_cnt*2; //转换成非组合BCD码后的有效数据长度
  112. for(i=0;i
  113. {
  114. ucTmep=p_ucBCD_bit4[ucBCD4_cnt-1-i];
  115. p_ucBCD_bit8[ucBCD4_cnt*2-i*2-1]=ucTmep>>4;
  116. p_ucBCD_bit8[ucBCD4_cnt*2-i*2-2]=ucTmep&0x0f;
  117. }
  119. }
  122. /* 注释三：
  123. * 非组合BCD码转成组合BCD码。
  124. * 这里的变量ucBCD8_cnt代表非组合BCD码的有效字节数.
  125. * 这里的变量*p_ucBCD4_cnt代表经过转换后，组合BCD码的有效字节数，记得加地址符号&传址进去
  126. * 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
  127. * 同时引进了非组合BCD码的有效字节数变量。这样就不限定了数据的长度，
  128. * 可以让我们根据数据的实际大小灵活运用。
  129. */
  130. void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt)
  131. {
  132. unsigned char ucTmep;
  133. unsigned char i;
  134. unsigned char ucBCD4_cnt;
  136. for(i=0;i
  137. {
  138. p_ucBCD_bit4[i]=0;
  139. }
  141. ucBCD4_cnt=(ucBCD8_cnt+1)/2; //非组合BCD码转化成组合BCD码的有效数,这里+1避免非组合数据长度是奇数位
  142. *p_ucBCD4_cnt=ucBCD4_cnt; //把转换后的结果付给接口指针的数据，可以对外输出结果
  144. for(i=0;i
  145. {
  146. ucTmep=p_ucBCD_bit8[ucBCD4_cnt*2-1-i*2]; //把非组合BCD码第8位分解出来
  147. p_ucBCD_bit4[ucBCD4_cnt-1-i]=ucTmep<<4;
  148. 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位分解出来
  149. }
  151. }
  153. /* 注释四：
  154. *函数介绍：清零数组的全部数组数据
  155. *输入参数：ucARRAY_MAX代表数组定义的最大长度
  156. *输入输出参数：*destData--被清零的数组。
  157. */
  159. void ClearAllData(uchar ucARRAY_MAX,uchar *destData)
  160. {
  161. uchar i;
  163. for(i=0;i
  164. {
  165. destData[i]=0;
  166. }
  168. }
  171. /* 注释五：
  172. *函数介绍：获取数组的有效长度
  173. *输入参数：*destData--被获取的数组。
  174. *输入参数：ucARRAY_MAX代表数组定义的最大长度
  175. *返回值：返回数组的有效长度。比如58786这个数据的有效长度是5
  176. *电子开发者作者：吴坚鸿
  177. */
  178. uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX)
  179. {
  180. uchar i;
  181. uchar DataLength=ucARRAY_MAX;
  182. for(i=0;i
  183. {
  184. if(0!=destData[ucARRAY_MAX-1-i])
  185. {
  186. break;
  187. }
  188. else
  189. {
  190. DataLength--;
  191. }
  193. }
  195. return DataLength;
  197. }
  201. /* 注释六：
  202. *函数介绍：两个数相加
  203. *输入参数：
  204. *（1）*destData--被加数的数组。
  205. *（2）*sourceData--加数的数组。
  206. *（3）*resultData--和的数组。注意，调用本函数前，必须先把这个数组清零
  207. *返回值：10代表计算结果超出范围出错，11代表正常。
  208. */
  209. uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData)
  210. {
  211. uchar addResult=11; //开始默认返回的运算结果是正常
  212. uchar destCnt=0;
  213. uchar sourceCnt=0;
  214. uchar i;
  215. uchar carryData=0;//进位
  216. uchar maxCnt=0; //最大位数
  217. uchar resultTemp=0; //存放临时运算结果的中间变量
  219. //为什么不在本函数内先把resultData数组清零？因为后面章节中的乘法运算中要用到此函数实现连加功能。
  220. //因此如果纯粹实现加法运算时，在调用本函数之前，必须先在外面把和的数组清零，否则会计算出错。
  222. destCnt=GetDataLength(destData,BCD8_MAX); //获取被加数的有效位数
  223. sourceCnt=GetDataLength(sourceData,BCD8_MAX);//获取加数的有效位数
  225. if(destCnt>=sourceCnt)//找出两个运算数据中最大的有效位数
  226. {
  227. maxCnt=destCnt;
  228. }
  229. else
  230. {
  231. maxCnt=sourceCnt;
  232. }
  234. for(i=0;i
  235. {
  236. resultTemp=destData[i]+sourceData[i]+carryData; //按位相加
  237. resultData[i]=resultTemp%10; //截取最低位存放进保存结果的数组
  238. carryData=resultTemp/10; //存放进位
  239. }
  241. resultData[i]=carryData;
  243. if((maxCnt==BCD8_MAX)&&(carryData==1))//如果数组的有效位是最大值并且最后的进位是1，则计算溢出报错
  244. {
  246. ClearAllData(BCD8_MAX,resultData);
  248. addResult=10;//报错
  249. }
  252. return addResult;
  253. }
  257. /* 注释七：
  258. *函数介绍：数组向大索引值移位，移一位相当于放大10倍
  259. *输入参数：*destData--被移位的数组。
  260. *输入参数：enlarge_cnt--被移位的个数。
  261. */
  262. void EnlargeData(uchar *destData,uchar enlarge_cnt)
  263. {
  264. uchar i;
  266. if(enlarge_cnt!=0)
  267. {
  268. for(i=0;i
  269. {
  270. destData[BCD8_MAX-1-i]=destData[BCD8_MAX-1-enlarge_cnt-i];
  271. }
  273. for(i=0;i
  274. {
  275. destData[i]=0;
  276. }
  277. }
  279. }
  284. /* 注释八：
  285. *函数介绍：两个数相乘
  286. *输入参数：
  287. *（1）*destData--被乘数的数组。
  288. *（2）*sourceData--乘数的数组。
  289. *（3）*resultData--积的数组。
  290. *返回值：10代表计算结果超出范围出错，11代表正常。
  291. */
  292. uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData)
  293. {
  294. uchar multResult=11; //开始默认正常
  295. uchar destCnt=0;
  296. uchar sourceCnt=0;
  297. uchar i;
  298. uchar j;
  299. uchar carryData=0;//进位
  301. uchar resultTemp=0; //存放临时运算结果的中间变量
  303. uchar nc_add_result;//接收相加的运算是否超出范围，这里不用判断，因为不会溢出
  305. uchar multArrayTemp[BCD8_MAX]; //存放临时运算结果的数组中间变量
  309. destCnt=GetDataLength(destData,BCD8_MAX); //获取被乘数的长度
  310. sourceCnt=GetDataLength(sourceData,BCD8_MAX); //获取乘数的长度
  312. ClearAllData(BCD8_MAX,resultData); //清零存储的结果
  313. if((0==destCnt)||(0==sourceCnt)) //被乘数或者乘数为0，则结果为0
  314. {
  315. return multResult;
  316. }
  319. if((destCnt+sourceCnt+2)>BCD8_MAX)
  320. {
  321. multResult=10; //运算结果有可能超范围报错
  322. return multResult;
  323. }
  325. for(i=0;i
  326. {
  327. carryData=0; //清零进位
  328. ClearAllData(BCD8_MAX,multArrayTemp); //清零一位乘数相乘的结果中间变量数组
  329. for(j=0;j
  330. {
  331. resultTemp=destData[j]*sourceData[i]+carryData;//乘数的一位依次与被乘数各位相乘,并且加进位
  332. multArrayTemp[j]=resultTemp%10;//存储一位乘数相乘的结果
  333. carryData=resultTemp/10; //保存进位
  334. }
  335. multArrayTemp[j]=carryData; //存储最后的进位
  336. EnlargeData(multArrayTemp,i); //移位。移一次相当于放大10倍。
  337. nc_add_result=AddData(resultData,multArrayTemp,resultData); //把一位乘数相乘的结果存储进总结果
  339. }
  342. return multResult;
  343. }
  347. void usart_service(void)//串口服务程序,在main函数里
  348. {
  350. unsigned char i=0;
  351. unsigned char k=0;
  352. unsigned char ucGetDataStep=0;
  354. if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
  355. {
  357. ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
  359. //下面的代码进入数据协议解析和数据处理的阶段
  361. uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
  362. while(uiRcMoveIndex
  363. {
  364. if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)//数据头eb 00 55的判断
  365. {
  367. i=0;
  368. ucGetDataStep=0;
  369. ucDataBCD4_cnt_1=0;//第1个数组合BCD码数组的有效数据长度
  370. ucDataBCD4_cnt_2=0;//第2个数组合BCD码数组的有效数据长度
  372. ClearAllData(BCD4_MAX,ucDataBCD4_1);//清零第1个参与运算的数据
  373. ClearAllData(BCD4_MAX,ucDataBCD4_2);//清零第2个参与运算的数据
  375. //以下while循环是通过关键字0x0d 0x0a来截取第1个和第2个参与运算的数据。
  376. while(i
  377. {
  378. if(ucGetDataStep==0)//步骤0，相当于我平时用的case 0,获取第1个数，在这里是指被乘数
  379. {
  380. if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
  381. {
  382. for(k=0;k
  383. {
  384. ucDataBCD4_1[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
  385. }
  386. i=i+2; //跳过 0x0d 0x0a 这两个字节，进行下一轮的关键字提取
  387. ucGetDataStep=1;//切换到下一个关键字提取的步骤
  389. }
  390. else
  391. {
  392. i++;
  393. ucDataBCD4_cnt_1++;//统计第1个有效数据的长度
  394. }
  396. }
  397. else if(ucGetDataStep==1) //步骤1，相当于我平时用的case 1,获取第2个参与运行的数，在这里是乘数
  398. {
  399. if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
  400. {
  401. for(k=0;k
  402. {
  403. ucDataBCD4_2[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
  404. }
  406. break; //截取数据完成。直接跳出截取数据的while(i
  408. }
  409. else
  410. {
  411. i++;
  412. ucDataBCD4_cnt_2++;//统计第2个有效数据的长度
  413. }
  414. }
  415. }
  418. //注意ucDataBCD8_cnt_1和ucDataBCD8_cnt_2要带地址符号&传址进去
  419. BCD4_to_BCD8(ucDataBCD4_1,ucDataBCD4_cnt_1,ucDataBCD8_1,&ucDataBCD8_cnt_1); //把接收到的组合BCD码转换成非组合BCD码第1个数
  420. BCD4_to_BCD8(ucDataBCD4_2,ucDataBCD4_cnt_2,ucDataBCD8_2,&ucDataBCD8_cnt_2); //把接收到的组合BCD码转换成非组合BCD码第2个数
  423. ClearAllData(BCD8_MAX,ucDataBCD8_3);//清零第3个参与运算的数据,用来接收运行的结果
  424. ucResultFlag=MultData(ucDataBCD8_1,ucDataBCD8_2,ucDataBCD8_3); //相乘运算，结果放在ucDataBCD8_3数组里
  425. if(ucResultFlag==11) //表示运算结果没有超范围
  426. {
  427. ucDataBCD8_cnt_3=GetDataLength(ucDataBCD8_3,BCD8_MAX);//获取运算结果的有效字节数
  428. if(ucDataBCD8_cnt_3==0) //如果1个有效位数都没有，表示数组所有的数据都是0，这个时候的有效位数应该人为的默认是1,表示一个0
  429. {
  430. ucDataBCD8_cnt_3=1;
  431. }
  433. BCD8_to_BCD4(ucDataBCD8_3,ucDataBCD8_cnt_3,ucDataBCD4_3,&ucDataBCD4_cnt_3); //把非组合BCD码转成组合BCD码。注意，&ucDataBCD4_cnt_3带地址符号&
  434. for(k=0;k
  435. {
  436. eusart_send(ucDataBCD4_3[ucDataBCD4_cnt_3-1-k]); //往上位机发送一个字节的函数
  437. }
  438. }
  439. else //运算结果超范围，返回EE EE EE
  440. {
  441. eusart_send(0xee); //往上位机发送一个字节的函数
  442. eusart_send(0xee); //往上位机发送一个字节的函数
  443. eusart_send(0xee); //往上位机发送一个字节的函数
  444. }
  446. break; //退出循环
  447. }
  448. uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
  449. }
  451. ucRcregBuf[0]=0; //把数据头清零，方便下次接收判断新数据
  452. ucRcregBuf[1]=0;
  453. ucRcregBuf[2]=0;
  455. uiRcregTotal=0;//清空缓冲的下标，方便下次重新从0下标开始接受新数据
  457. }
  459. }
  461. void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
  462. {
  464. ES = 0; //关串口中断
  465. TI = 0; //清零串口发送完成中断请求标志
  466. SBUF =ucSendData; //发送一个字节
  468. delay_short(400);//每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整
  470. TI = 0; //清零串口发送完成中断请求标志
  471. ES = 1; //允许串口中断
  473. }
  477. void T0_time(void) interrupt 1 //定时中断
  478. {
  479. TF0=0;//清除中断标志
  480. TR0=0; //关中断
  483. if(uiSendCnt
  484. {
  485. uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
  486. ucSendLock=1; //开自锁标志
  487. }
  491. TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
  492. TL0=0x0b;
  493. TR0=1;//开中断
  494. }
  497. void usart_receive(void) interrupt 4 //串口接收数据中断
  498. {
  500. if(RI==1)
  501. {
  502. RI = 0;
  504. ++uiRcregTotal;
  505. if(uiRcregTotal>const_rc_size)//超过缓冲区
  506. {
  507. uiRcregTotal=const_rc_size;
  508. }
  509. ucRcregBuf[uiRcregTotal-1]=SBUF; //将串口接收到的数据缓存到接收缓冲区里
  510. uiSendCnt=0;//及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
  512. }
  513. else//发送中断，及时把发送中断标志位清零
  514. {
  515. TI = 0;
  516. }
  518. }
  521. void delay_long(unsigned int uiDelayLong)
  522. {
  523. unsigned int i;
  524. unsigned int j;
  525. for(i=0;i
  526. {
  527. for(j=0;j<500;j++)//内嵌循环的空指令数量
  528. {
  529. ; //一个分号相当于执行一条空语句
  530. }
  531. }
  532. }
  534. void delay_short(unsigned int uiDelayShort)
  535. {
  536. unsigned int i;
  537. for(i=0;i
  538. {
  539. ; //一个分号相当于执行一条空语句
  540. }
  541. }
  544. void initial_myself(void)//第一区 初始化单片机
  545. {
  547. beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
  549. //配置定时器
  550. TMOD=0x01;//设置定时器0为工作方式1
  551. TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
  552. TL0=0x0b;
  555. //配置串口
  556. SCON=0x50;
  557. TMOD=0X21;
  558. TH1=TL1=-(11059200L/12/32/9600);//这段配置代码具体是什么意思，我也不太清楚，反正是跟串口波特率有关。
  559. TR1=1;
  561. }
  563. void initial_peripheral(void) //第二区 初始化外围
  564. {
  566. EA=1; //开总中断
  567. ES=1; //允许串口中断
  568. ET0=1; //允许定时中断
  569. TR0=1; //启动定时中断
  571. }

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

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

上一篇:第63节：大数据的减法运算 下一篇:第65节：大数据的除法运算

相关推荐

热门文章 更多
ARM入门篇之(一)概念

技术

硬件开发 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.