您的位置 首页 电源

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

开场白:直接用C语言的*运算符进行乘法运算时,被乘数,乘数,积,这三个数据的最大范围是unsignedlong类型,也就是数据最大范围是4

开场白:
直接用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”
  2. /* 注释一:
  3. * 本体系中的乘法运算,规则两个乘数的最大规模是0至99.
  4. * 由于STC89C52单片机的RAM只需256个,也便是说体系的变量数最大
  5. * 不能超越256个,假如超越了这个极限,编译器就会报错。由于51单片机RAM资源有限,
  6. * 因而规则乘数的最大规模不能超越99,假如这个算法移植到stm32或许PIC等RAM比较大
  7. * 的单片机上,那么就能够把这个运算位数设置得愈加大一点。调整下面 BCD4_MAX的巨细,
  8. * 能够调整运算的数据规模。
  9. */
  10. #defineBCD4_MAX 3//为了让乘法的成果不超越规模,因而把组合BCD码最大字节数从上一节的2改成3,一个字节包括2位,因而能够保存6位有用数
  11. #defineBCD8_MAX (BCD4_MAX*2)//本体系中,规则的非组合BCD码能保存的最大字节数,一个字节包括1位,因而能保存6位有用运管用
  12. #define const_rc_size30//接纳串口中止数据的缓冲区数组巨细
  13. #define const_receive_time5//假如超越这个时刻没有串口数据过来,就以为一串数据现已悉数接纳完,这个时刻依据实践情况来调整巨细
  14. #define uchar unsigned char //便利移植渠道
  15. #define ulong unsigned long //便利移植渠道
  16. //假如在VC的渠道模仿此算法,则都界说成int类型,如下:
  17. //#define uchar int
  18. //#define ulong int
  19. void initial_myself(void);
  20. void initial_peripheral(void);
  21. void delay_long(unsigned int uiDelaylong);
  22. void delay_short(unsigned int uiDelayShort);
  23. void T0_time(void);//守时中止函数
  24. void usart_receive(void); //串口接纳中止函数
  25. void usart_service(void);//串口服务程序,在main函数里
  26. void eusart_send(unsigned char ucSendData);
  27. void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt);
  28. void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt);
  29. void ClearAllData(uchar ucARRAY_MAX,uchar *destData);
  30. uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX);
  31. uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData);//两个数相加
  32. void EnlargeData(uchar *destData,uchar enlarge_cnt); //数组向大索引值移位,移一位适当于扩大10倍
  33. uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData); //两个数相乘
  34. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
  35. unsigned intuiSendCnt=0; //用来辨认串口是否接纳完一串数据的计时器
  36. unsigned char ucSendLock=1; //串口服务程序的自锁变量,每次接纳完一串数据只处理一次
  37. unsigned intuiRcregTotal=0;//代表当时缓冲区现已接纳了多少个数据
  38. unsigned char ucRcregBuf[const_rc_size]; //接纳串口中止数据的缓冲区数组
  39. unsigned intuiRcMoveIndex=0;//用来解析数据协议的中心变量
  40. unsigned char ucDataBCD4_1[BCD4_MAX]; //接纳到的第1个数组合BCD码数组方式这儿是指被乘数
  41. unsigned char ucDataBCD4_cnt_1=0;//接纳到的第1个数组合BCD码数组的有用数据长度
  42. unsigned char ucDataBCD4_2[BCD4_MAX]; //接纳到的第2个数组合BCD码数组方式这儿是指乘数
  43. unsigned char ucDataBCD4_cnt_2=0;//接纳到的第2个数组合BCD码数组的有用数据长度
  44. unsigned char ucDataBCD4_3[BCD4_MAX]; //接纳到的第3个数组合BCD码数组方式这儿是指积
  45. unsigned char ucDataBCD4_cnt_3=0;//接纳到的第3个数组合BCD码数组的有用数据长度
  46. unsigned char ucDataBCD8_1[BCD8_MAX]; //接纳到的第1个数非组合BCD码数组方式 这儿是指被乘数
  47. unsigned char ucDataBCD8_cnt_1=0;//接纳到的第1个数非组合BCD码数组的有用数据长度
  48. unsigned char ucDataBCD8_2[BCD8_MAX]; //接纳到的第2个数非组合BCD码数组方式 这儿是指乘数
  49. unsigned char ucDataBCD8_cnt_2=0;//接纳到的第2个数非组合BCD码数组的有用数据长度
  50. unsigned char ucDataBCD8_3[BCD8_MAX]; //接纳到的第3个数非组合BCD码数组方式 这儿是指积
  51. unsigned char ucDataBCD8_cnt_3=0;//接纳到的第3个数非组合BCD码数组的有用数据长度
  52. unsigned char ucResultFlag=11; //运算成果标志,10代表核算成果超出规模犯错,11代表正常。
  53. void main()
  54. {
  55. initial_myself();
  56. delay_long(100);
  57. initial_peripheral();
  58. while(1)
  59. {
  60. usart_service();//串口服务程序
  61. }
  62. }
  63. /* 注释二:
  64. * 组合BCD码转成非组合BCD码。
  65. * 这儿的变量ucBCD4_cnt代表组合BCD码的有用字节数.
  66. * 这儿的变量*p_ucBCD8_cnt代表经过转化后,非组合BCD码的有用字节数,记住加地址符号&传址进去
  67. * 本程序在上一节的基础上,略作修正,用循环for句子紧缩了代码,
  68. * 一起引进了组合BCD码的有用字节数变量。这样就不限制了数据的长度,
  69. * 能够让咱们依据数据的实践巨细灵活运用。
  70. */
  71. void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt)
  72. {
  73. unsigned char ucTmep;
  74. unsigned char i;
  75. for(i=0;i
  76. {
  77. p_ucBCD_bit8[i]=0;
  78. }
  79. *p_ucBCD8_cnt=ucBCD4_cnt*2; //转化成非组合BCD码后的有用数据长度
  80. for(i=0;i
  81. {
  82. ucTmep=p_ucBCD_bit4[ucBCD4_cnt-1-i];
  83. p_ucBCD_bit8[ucBCD4_cnt*2-i*2-1]=ucTmep>>4;
  84. p_ucBCD_bit8[ucBCD4_cnt*2-i*2-2]=ucTmep&0x0f;
  85. }
  86. }
  87. /* 注释三:
  88. * 非组合BCD码转成组合BCD码。
  89. * 这儿的变量ucBCD8_cnt代表非组合BCD码的有用字节数.
  90. * 这儿的变量*p_ucBCD4_cnt代表经过转化后,组合BCD码的有用字节数,记住加地址符号&传址进去
  91. * 本程序在上一节的基础上,略作修正,用循环for句子紧缩了代码,
  92. * 一起引进了非组合BCD码的有用字节数变量。这样就不限制了数据的长度,
  93. * 能够让咱们依据数据的实践巨细灵活运用。
  94. */
  95. void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt)
  96. {
  97. unsigned char ucTmep;
  98. unsigned char i;
  99. unsigned char ucBCD4_cnt;
  100. for(i=0;i
  101. {
  102. p_ucBCD_bit4[i]=0;
  103. }
  104. ucBCD4_cnt=(ucBCD8_cnt+1)/2; //非组合BCD码转化成组合BCD码的有用数,这儿+1防止非组合数据长度是奇数位
  105. *p_ucBCD4_cnt=ucBCD4_cnt; //把转化后的成果交给接口指针的数据,能够对外输出成果
  106. for(i=0;i
  107. {
  108. ucTmep=p_ucBCD_bit8[ucBCD4_cnt*2-1-i*2]; //把非组合BCD码第8位分化出来
  109. p_ucBCD_bit4[ucBCD4_cnt-1-i]=ucTmep<<4;
  110. 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位分化出来
  111. }
  112. }
  113. /* 注释四:
  114. *函数介绍:清零数组的悉数数组数据
  115. *输入参数:ucARRAY_MAX代表数组界说的最大长度
  116. *输入输出参数:*destData–被清零的数组。
  117. */
  118. void ClearAllData(uchar ucARRAY_MAX,uchar *destData)
  119. {
  120. uchar i;
  121. for(i=0;i
  122. {
  123. destData[i]=0;
  124. }
  125. }
  126. /* 注释五:
  127. *函数介绍:获取数组的有用长度
  128. *输入参数:*destData–被获取的数组。
  129. *输入参数:ucARRAY_MAX代表数组界说的最大长度
  130. *回来值:回来数组的有用长度。比方58786这个数据的有用长度是5
  131. *电子开发者作者:吴坚鸿
  132. */
  133. uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX)
  134. {
  135. uchar i;
  136. uchar DataLength=ucARRAY_MAX;
  137. for(i=0;i
  138. {
  139. if(0!=destData[ucARRAY_MAX-1-i])
  140. {
  141. break;
  142. }
  143. else
  144. {
  145. DataLength–;
  146. }
  147. }
  148. return DataLength;
  149. }
  150. /* 注释六:
  151. *函数介绍:两个数相加
  152. *输入参数:
  153. *(1)*destData–被加数的数组。
  154. *(2)*sourceData–加数的数组。
  155. *(3)*resultData–和的数组。留意,调用本函数前,有必要先把这个数组清零
  156. *回来值:10代表核算成果超出规模犯错,11代表正常。
  157. */
  158. uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData)
  159. {
  160. uchar addResult=11; //开端默许回来的运算成果是正常
  161. uchar destCnt=0;
  162. uchar sourceCnt=0;
  163. uchar i;
  164. uchar carryData=0;//进位
  165. uchar maxCnt=0; //最大位数
  166. uchar resultTemp=0; //寄存暂时运算成果的中心变量
  167. //为什么不在本函数内先把resultData数组清零?由于后边章节中的乘法运算中要用到此函数完结连加功用。
  168. //因而假如朴实完结加法运算时,在调用本函数之前,有必要先在外面把和的数组清零,不然管帐算犯错。
  169. destCnt=GetDataLength(destData,BCD8_MAX); //获取被加数的有用位数
  170. sourceCnt=GetDataLength(sourceData,BCD8_MAX);//获取加数的有用位数
  171. if(destCnt>=sourceCnt)//找出两个运管用据中最大的有用位数
  172. {
  173. maxCnt=destCnt;
  174. }
  175. else
  176. {
  177. maxCnt=sourceCnt;
  178. }
  179. for(i=0;i
  180. {
  181. resultTemp=destData[i]+sourceData[i]+carryData; //按位相加
  182. resultData[i]=resultTemp%10; //截取最低位寄存进保存成果的数组
  183. carryData=resultTemp/10; //寄存进位
  184. }
  185. resultData[i]=carryData;
  186. if((maxCnt==BCD8_MAX)&&(carryData==1))//假如数组的有用位是最大值而且最终的进位是1,则核算溢出报错
  187. {
  188. ClearAllData(BCD8_MAX,resultData);
  189. addResult=10;//报错
  190. }
  191. return addResult;
  192. }
  193. /* 注释七:
  194. *函数介绍:数组向大索引值移位,移一位适当于扩大10倍
  195. *输入参数:*destData–被移位的数组。
  196. *输入参数:enlarge_cnt–被移位的个数。
  197. */
  198. void EnlargeData(uchar *destData,uchar enlarge_cnt)
  199. {
  200. uchar i;
  201. if(enlarge_cnt!=0)
  202. {
  203. for(i=0;i<(BCD8_MAX-enlarge_cnt);i++)
  204. {
  205. destData[BCD8_MAX-1-i]=destData[BCD8_MAX-1-enlarge_cnt-i];
  206. }
  207. for(i=0;i
  208. {
  209. destData[i]=0;
  210. }
  211. }
  212. }
  213. /* 注释八:
  214. *函数介绍:两个数相乘
  215. *输入参数:
  216. *(1)*destData–被乘数的数组。
  217. *(2)*sourceData–乘数的数组。
  218. *(3)*resultData–积的数组。
  219. *回来值:10代表核算成果超出规模犯错,11代表正常。
  220. */
  221. uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData)
  222. {
  223. uchar multResult=11; //开端默许正常
  224. uchar destCnt=0;
  225. uchar sourceCnt=0;
  226. uchar i;
  227. uchar j;
  228. uchar carryData=0;//进位
  229. uchar resultTemp=0; //寄存暂时运算成果的中心变量
  230. uchar nc_add_result;//接纳相加的运算是否超出规模,这儿不必判别,由于不会溢出
  231. uchar multArrayTemp[BCD8_MAX]; //寄存暂时运算成果的数组中心变量
  232. destCnt=GetDataLength(destData,BCD8_MAX); //获取被乘数的长度
  233. sourceCnt=GetDataLength(sourceData,BCD8_MAX); //获取乘数的长度
  234. ClearAllData(BCD8_MAX,resultData); //清零存储的成果
  235. if((0==destCnt)||(0==sourceCnt)) //被乘数或许乘数为0,则成果为0
  236. {
  237. return multResult;
  238. }
  239. if((destCnt+sourceCnt+2)>BCD8_MAX)
  240. {
  241. multResult=10; //运算成果有或许超规模报错
  242. return multResult;
  243. }
  244. for(i=0;i
  245. {
  246. carryData=0; //清零进位
  247. ClearAllData(BCD8_MAX,multArrayTemp); //清零一位乘数相乘的成果中心变量数组
  248. for(j=0;j
  249. {
  250. resultTemp=destData[j]*sourceData[i]+carryData;//乘数的一位顺次与被乘数各位相乘,而且加进位
  251. multArrayTemp[j]=resultTemp%10;//存储一位乘数相乘的成果
  252. carryData=resultTemp/10; //保存进位
  253. }
  254. multArrayTemp[j]=carryData; //存储最终的进位
  255. EnlargeData(multArrayTemp,i); //移位。移一次适当于扩大10倍。
  256. nc_add_result=AddData(resultData,multArrayTemp,resultData); //把一位乘数相乘的成果存储进总成果
  257. }
  258. return multResult;
  259. }
  260. void usart_service(void)//串口服务程序,在main函数里
  261. {
  262. unsigned char i=0;
  263. unsigned char k=0;
  264. unsigned char ucGetDataStep=0;
  265. if(uiSendCnt>=const_receive_time&&ucSendLock==1) //阐明超越了必定的时刻内,再也没有新数据从串口来
  266. {
  267. ucSendLock=0; //处理一次就锁起来,不必每次都进来,除非有新接纳的数据
  268. //下面的代码进入数据协议解析和数据处理的阶段
  269. uiRcMoveIndex=0; //由所以判别数据头,所以下标移动变量从数组的0开端向最尾端移动
  270. while(uiRcMoveIndex
  271. {
  272. if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)//数据头eb 00 55的判别
  273. {
  274. i=0;
  275. ucGetDataStep=0;
  276. ucDataBCD4_cnt_1=0;//第1个数组合BCD码数组的有用数据长度
  277. ucDataBCD4_cnt_2=0;//第2个数组合BCD码数组的有用数据长度
  278. ClearAllData(BCD4_MAX,ucDataBCD4_1);//清零第1个参加运算的数据
  279. ClearAllData(BCD4_MAX,ucDataBCD4_2);//清零第2个参加运算的数据
  280. //以下while循环是经过要害字0x0d 0x0a来截取第1个和第2个参加运算的数据。
  281. while(i<(BCD8_MAX+4))//这儿+4是由于有2对0x0d 0x0a结束特殊符号,一个共4个字节
  282. {
  283. if(ucGetDataStep==0)//过程0,适当于我平常用的case 0,获取第1个数,在这儿是指被乘数
  284. {
  285. if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
  286. {
  287. for(k=0;k
  288. {
  289. ucDataBCD4_1[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //留意,接纳到的数组数据与实践存储的数组数据的下标方向是相反的
  290. }
  291. i=i+2; //越过 0x0d 0x0a 这两个字节,进行下一轮的要害字提取
  292. ucGetDataStep=1;//切换到下一个要害字提取的过程
  293. }
  294. else
  295. {
  296. i++;
  297. ucDataBCD4_cnt_1++;//计算第1个有用数据的长度
  298. }
  299. }
  300. else if(ucGetDataStep==1) //过程1,适当于我平常用的case 1,获取第2个参加运转的数,在这儿是乘数
  301. {
  302. if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
  303. {
  304. for(k=0;k
  305. {
  306. ucDataBCD4_2[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //留意,接纳到的数组数据与实践存储的数组数据的下标方向是相反的
  307. }
  308. break; //截取数据完结。直接跳出截取数据的while(i<(BCD8_MAX+4))循环
  309. }
  310. else
  311. {
  312. i++;
  313. ucDataBCD4_cnt_2++;//计算第2个有用数据的长度
  314. }
  315. }
  316. }
  317. //留意ucDataBCD8_cnt_1和ucDataBCD8_cnt_2要带地址符号&传址进去
  318. BCD4_to_BCD8(ucDataBCD4_1,ucDataBCD4_cnt_1,ucDataBCD8_1,&ucDataBCD8_cnt_1); //把接纳到的组合BCD码转化成非组合BCD码第1个数
  319. BCD4_to_BCD8(ucDataBCD4_2,ucDataBCD4_cnt_2,ucDataBCD8_2,&ucDataBCD8_cnt_2); //把接纳到的组合BCD码转化成非组合BCD码第2个数
  320. ClearAllData(BCD8_MAX,ucDataBCD8_3);//清零第3个参加运算的数据,用来接纳运转的成果
  321. ucResultFlag=MultData(ucDataBCD8_1,ucDataBCD8_2,ucDataBCD8_3); //相乘运算,成果放在ucDataBCD8_3数组里
  322. if(ucResultFlag==11) //表明运算成果没有超规模
  323. {
  324. ucDataBCD8_cnt_3=GetDataLength(ucDataBCD8_3,BCD8_MAX);//获取运算成果的有用字节数
  325. if(ucDataBCD8_cnt_3==0) //假如1个有用位数都没有,表明数组一切的数据都是0,这个时分的有用位数应该人为的默许是1,表明一个0
  326. {
  327. ucDataBCD8_cnt_3=1;
  328. }
  329. BCD8_to_BCD4(ucDataBCD8_3,ucDataBCD8_cnt_3,ucDataBCD4_3,&ucDataBCD4_cnt_3); //把非组合BCD码转成组合BCD码。留意,&ucDataBCD4_cnt_3带地址符号&
  330. for(k=0;k
  331. {
  332. eusart_send(ucDataBCD4_3[ucDataBCD4_cnt_3-1-k]); //往上位机发送一个字节的函数
  333. }
  334. }
  335. else //运算成果超规模,回来EE EE EE
  336. {
  337. eusart_send(0xee); //往上位机发送一个字节的函数
  338. eusart_send(0xee); //往上位机发送一个字节的函数
  339. eusart_send(0xee); //往上位机发送一个字节的函数
  340. }
  341. break; //退出循环
  342. }
  343. uiRcMoveIndex++; //由所以判别数据头,游标向着数组最尾端的方向移动
  344. }
  345. ucRcregBuf[0]=0; //把数据头清零,便利下次接纳判别新数据
  346. ucRcregBuf[1]=0;
  347. ucRcregBuf[2]=0;
  348. uiRcregTotal=0;//清空缓冲的下标,便利下次从头从0下标开端承受新数据
  349. }
  350. }
  351. void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
  352. {
  353. ES = 0; //关串口中止
  354. TI = 0; //清零串口发送完结中止请求标志
  355. SBUF =ucSendData; //发送一个字节
  356. delay_short(400);//每个字节之间的延时,这儿十分要害,也是最简单犯错的当地。延时的巨细请依据实践项目来调整
  357. TI = 0; //清零串口发送完结中止请求标志
  358. ES = 1; //答应串口中止
  359. }
  360. void T0_time(void) interrupt 1 //守时中止
  361. {
  362. TF0=0;//铲除中止标志
  363. TR0=0; //关中止
  364. if(uiSendCnt
  365. {
  366. uiSendCnt++; //表面上这个数据不断累加,可是在串口中止里,每接纳一个字节它都会被清零,除非这个中心没有串口数据过来
  367. ucSendLock=1; //开自锁标志
  368. }
  369. TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
  370. TL0=0x0b;
  371. TR0=1;//开中止
  372. }
  373. void usart_receive(void) interrupt 4 //串口接纳数据中止
  374. {
  375. if(RI==1)
  376. {
  377. RI = 0;
  378. ++uiRcregTotal;
  379. if(uiRcregTotal>const_rc_size)//超越缓冲区
  380. {
  381. uiRcregTotal=const_rc_size;
  382. }
  383. ucRcregBuf[uiRcregTotal-1]=SBUF; //将串口接纳到的数据缓存到接纳缓冲区里
  384. uiSendCnt=0;//及时喂狗,尽管main函数那儿不断在累加,可是只需串口的数据还没发送结束,那么它永久也长不大,由于每个中止都被清零。
  385. }
  386. else//发送中止,及时把发送中止标志位清零
  387. {
  388. TI = 0;
  389. }
  390. }
  391. void delay_long(unsigned int uiDelayLong)
  392. {
  393. unsigned int i;
  394. unsigned int j;
  395. for(i=0;i
  396. {
  397. for(j=0;j<500;j++)//内嵌循环的空指令数量
  398. {
  399. ; //一个分号适当于履行一条空句子
  400. }
  401. }
  402. }
  403. void delay_short(unsigned int uiDelayShort)
  404. {
  405. unsigned int i;
  406. for(i=0;i
  407. {
  408. ; //一个分号适当于履行一条空句子
  409. }
  410. }
  411. void initial_myself(void)//榜首区 初始化单片机
  412. {
  413. beep_dr=1; //用PNP三极管操控蜂鸣器,输出高电平常不叫。
  414. //装备守时器
  415. TMOD=0x01;//设置守时器0为工作方式1
  416. TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
  417. TL0=0x0b;
  418. //装备串口
  419. SCON=0x50;
  420. TMOD=0X21;
  421. TH1=TL1=-(11059200L/12/32/9600);//这段装备代码详细是什么意思,我也不太清楚,反正是跟串口波特率有关。
  422. TR1=1;
  423. }
  424. void initial_peripheral(void) //第二区 初始化外围
  425. {
  426. EA=1; //开总中止
  427. ES=1; //答应串口中止
  428. ET0=1; //答应守时中止
  429. TR0=1; //发动守时中止
  430. }

总结陈词:
已然这节讲了乘法程序,那么下一节接着讲常用的除法程序,这种大数据的除法程序是什么样的?欲知概况,请听下回分化—-大数据的除法运算。

声明:本文内容来自网络转载或用户投稿,文章版权归原作者和原出处所有。文中观点,不代表本站立场。若有侵权请联系本站删除(kf@86ic.com)https://www.86ic.net/dianyuan/262057.html

为您推荐

联系我们

联系我们

在线咨询: QQ交谈

邮箱: kf@86ic.com

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

返回顶部