新闻中心

EEPW首页 > 嵌入式系统 > 设计应用 > 第61节：组合和非组合BCD码以及数值相互转换

第61节：组合和非组合BCD码以及数值相互转换

作者： 时间：2016-11-22 来源：网络
收藏
第六十一节：组合BCD码，非组合BCD码，以及数值三者之间的相互转换和关系。
开场白：
本来这一节打算讲大数据的加法运算的，但是考虑大数据运算的基础是非组合BCD码，所以多增加一节讲BCD码的内容。
计算机中的BCD码，经常使用的有两种格式，即组合BCD码，非组合BCD码。
组合BCD码，是将两位十进制数，存放在一个字节中，例如：十进制数51的存放格式是0101 0001。
非组合BCD码，是将一个字节的低四位编码表示十进制数的一位，而高4位都为0。例如：十进制数51的占用了两个字节的空间，存放格式为：00000101 00000001。
这一节要教大家两个知识点：
第一个：如何编写组合BCD码，非组合BCD码，以及数值三者之间的相互转换函数。
第二个：通过转换函数的编写，重温前面几节所讲到的指针用法。

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

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

（2）实现功能：
波特率是：9600 。
通过电脑串口调试助手模拟上位机，往单片机发送EB 00 55 XX YY YY … YY YY指令，其中EB 00 55是数据头，XX 是指令类型。YY是具体的数据。
指令类型01代表发送的是数值，需要转成组合BCD码和非组合BCD码，并且返回上位机显示。
指令类型02代表发送的是组合BCD码，需要转成数值和非组合BCD码，并且返回上位机显示。
指令类型03代表发送的是非组合BCD码，需要转成数值和组合BCD码，并且返回上位机显示。

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

例如：十进制的数据52013140，它的十六进制数据是03 19 A8 54。
（a）上位机发送数据：eb 00 55 01 03 19 a8 54
单片机返回：52 01 31 40 EE EE EE 05 02 00 01 03 01 04 00
（b）上位机发送组合BCD码：eb 00 55 02 52 01 31 40
单片机返回：03 19 A8 54 EE EE EE 05 02 00 01 03 01 04 00
（c）发送非组合BCD码：eb 00 55 03 05 02 00 01 03 01 04 00
单片机返回：03 19 A8 54 EE EE EE 52 01 31 40

（3）源代码讲解如下：
  1. #include "REG52.H"
  3. #define const_voice_short40 //蜂鸣器短叫的持续时间
  6. /* 注释一：
  7. * 注意，此处的const_rc_size是20，比之前章节的缓冲区稍微改大了一点。
  8. */
  9. #define const_rc_size20//接收串口中断数据的缓冲区数组大小
  11. #define const_receive_time5//如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
  13. void initial_myself(void);
  14. void initial_peripheral(void);
  15. void delay_long(unsigned int uiDelaylong);
  16. void delay_short(unsigned int uiDelayShort);
  19. void T0_time(void);//定时中断函数
  20. void usart_receive(void); //串口接收中断函数
  21. void usart_service(void);//串口服务程序,在main函数里
  24. void eusart_send(unsigned char ucSendData);
  26. void number_to_BCD4(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit4);//把数值转换成组合BCD码
  27. void number_to_BCD8(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit8);//把数值转换成非组合BCD码
  28. void BCD4_to_number(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucNumber); //组合BCD码转成数值
  29. void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD_bit8); //组合BCD码转成非组合BCD码
  30. void BCD8_to_number(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucNumber); //非组合BCD码转成数值
  31. void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD_bit4); //非组合BCD码转成组合BCD码
  34. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
  36. unsigned intuiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
  37. unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
  38. unsigned intuiRcregTotal=0;//代表当前缓冲区已经接收了多少个数据
  39. unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
  40. unsigned intuiRcMoveIndex=0;//用来解析数据协议的中间变量
  42. /* 注释二：
  43. * 注意，本程序规定数值的最大范围是0至99999999
  44. * 数组中的数据。高位在数组下标大的方向，低位在数组下标小的方向。
  45. */
  46. unsigned char ucBufferNumber[4]; //数值，用4个字节表示long类型的数值
  47. unsigned char ucBufferBCB_bit4[4]; //组合BCD码
  48. unsigned char ucBufferBCB_bit8[8]; //非组合BCD码
  50. void main()
  51. {
  52. initial_myself();
  53. delay_long(100);
  54. initial_peripheral();
  55. while(1)
  56. {
  57. usart_service();//串口服务程序
  58. }
  60. }
  62. void number_to_BCD4(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit4)//把数值转换成组合BCD码
  63. {
  64. unsigned long ulNumberTemp=0;
  65. unsigned char ucTemp=0;
  66. ulNumberTemp=p_ucNumber[3];//把4个字节的数值合并成一个long类型数据
  67. ulNumberTemp=ulNumberTemp<<8;
  68. ulNumberTemp=ulNumberTemp+p_ucNumber[2];
  69. ulNumberTemp=ulNumberTemp<<8;
  70. ulNumberTemp=ulNumberTemp+p_ucNumber[1];
  71. ulNumberTemp=ulNumberTemp<<8;
  72. ulNumberTemp=ulNumberTemp+p_ucNumber[0];
  75. p_ucBCD_bit4[3]=ulNumberTemp%100000000/10000000;
  76. p_ucBCD_bit4[3]=p_ucBCD_bit4[3]<<4; //前半4位存第8位组合BCD码
  77. ucTemp=ulNumberTemp%10000000/1000000;
  78. p_ucBCD_bit4[3]=p_ucBCD_bit4[3]+ucTemp; //后半4位存第7位组合BCD码
  80. p_ucBCD_bit4[2]=ulNumberTemp%1000000/100000;
  81. p_ucBCD_bit4[2]=p_ucBCD_bit4[2]<<4; //前半4位存第6位组合BCD码
  82. ucTemp=ulNumberTemp%100000/10000;
  83. p_ucBCD_bit4[2]=p_ucBCD_bit4[2]+ucTemp;//后半4位存第5位组合BCD码
  85. p_ucBCD_bit4[1]=ulNumberTemp%10000/1000;
  86. p_ucBCD_bit4[1]=p_ucBCD_bit4[1]<<4; //前半4位存第4位组合BCD码
  87. ucTemp=ulNumberTemp%1000/100;
  88. p_ucBCD_bit4[1]=p_ucBCD_bit4[1]+ucTemp;//后半4位存第3位组合BCD码
  90. p_ucBCD_bit4[0]=ulNumberTemp%100/10;
  91. p_ucBCD_bit4[0]=p_ucBCD_bit4[0]<<4; //前半4位存第2位组合BCD码
  92. ucTemp=ulNumberTemp%10;
  93. p_ucBCD_bit4[0]=p_ucBCD_bit4[0]+ucTemp;//后半4位存第1位组合BCD码
  95. }
  98. void number_to_BCD8(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit8)//把数值转换成非组合BCD码
  99. {
  100. unsigned long ulNumberTemp=0;
  101. ulNumberTemp=p_ucNumber[3];//把4个字节的数值合并成一个long类型数据
  102. ulNumberTemp=ulNumberTemp<<8;
  103. ulNumberTemp=ulNumberTemp+p_ucNumber[2];
  104. ulNumberTemp=ulNumberTemp<<8;
  105. ulNumberTemp=ulNumberTemp+p_ucNumber[1];
  106. ulNumberTemp=ulNumberTemp<<8;
  107. ulNumberTemp=ulNumberTemp+p_ucNumber[0];
  109. p_ucBCD_bit8[7]=ulNumberTemp%100000000/10000000;//一个字节8位存储第8位非组合BCD码
  110. p_ucBCD_bit8[6]=ulNumberTemp%10000000/1000000;//一个字节8位存储第7位非组合BCD码
  111. p_ucBCD_bit8[5]=ulNumberTemp%1000000/100000;//一个字节8位存储第6位非组合BCD码
  112. p_ucBCD_bit8[4]=ulNumberTemp%100000/10000;//一个字节8位存储第5位非组合BCD码
  113. p_ucBCD_bit8[3]=ulNumberTemp%10000/1000;//一个字节8位存储第4位非组合BCD码
  114. p_ucBCD_bit8[2]=ulNumberTemp%1000/100;//一个字节8位存储第3位非组合BCD码
  115. p_ucBCD_bit8[1]=ulNumberTemp%100/10;//一个字节8位存储第2位非组合BCD码
  116. p_ucBCD_bit8[0]=ulNumberTemp%10;//一个字节8位存储第1位非组合BCD码
  118. }
  121. void BCD4_to_number(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucNumber) //组合BCD码转成数值
  122. {
  123. unsigned long ulTmep;
  124. unsigned long ulSum;
  126. ulSum=0;//累加和数值清零
  128. ulTmep=0;
  129. ulTmep=p_ucBCD_bit4[3];
  130. ulTmep=ulTmep>>4;//把组合BCD码第8位分解出来
  131. ulTmep=ulTmep*10000000;
  132. ulSum=ulSum+ulTmep; //累加各位数值
  134. ulTmep=0;
  135. ulTmep=p_ucBCD_bit4[3];
  136. ulTmep=ulTmep&0x0000000f;//把组合BCD码第7位分解出来
  137. ulTmep=ulTmep*1000000;
  138. ulSum=ulSum+ulTmep; //累加各位数值
  140. ulTmep=0;
  141. ulTmep=p_ucBCD_bit4[2];
  142. ulTmep=ulTmep>>4;//把组合BCD码第6位分解出来
  143. ulTmep=ulTmep*100000;
  144. ulSum=ulSum+ulTmep; //累加各位数值
  146. ulTmep=0;
  147. ulTmep=p_ucBCD_bit4[2];
  148. ulTmep=ulTmep&0x0000000f;//把组合BCD码第5位分解出来
  149. ulTmep=ulTmep*10000;
  150. ulSum=ulSum+ulTmep; //累加各位数值
  152. ulTmep=0;
  153. ulTmep=p_ucBCD_bit4[1];
  154. ulTmep=ulTmep>>4;//把组合BCD码第4位分解出来
  155. ulTmep=ulTmep*1000;
  156. ulSum=ulSum+ulTmep; //累加各位数值
  158. ulTmep=0;
  159. ulTmep=p_ucBCD_bit4[1];
  160. ulTmep=ulTmep&0x0000000f;//把组合BCD码第3位分解出来
  161. ulTmep=ulTmep*100;
  162. ulSum=ulSum+ulTmep; //累加各位数值
  164. ulTmep=0;
  165. ulTmep=p_ucBCD_bit4[0];
  166. ulTmep=ulTmep>>4;//把组合BCD码第2位分解出来
  167. ulTmep=ulTmep*10;
  168. ulSum=ulSum+ulTmep; //累加各位数值
  170. ulTmep=0;
  171. ulTmep=p_ucBCD_bit4[0];
  172. ulTmep=ulTmep&0x0000000f;//把组合BCD码第1位分解出来
  173. ulTmep=ulTmep*1;
  174. ulSum=ulSum+ulTmep; //累加各位数值
  176. //以上代码非常有规律，有兴趣的读者也可以自己想办法把它压缩成一个for循环的函数，可以极大节省容量。
  178. p_ucNumber[3]=ulSum>>24;//把long类型数据分解成4个字节
  179. p_ucNumber[2]=ulSum>>16;
  180. p_ucNumber[1]=ulSum>>8;
  181. p_ucNumber[0]=ulSum;
  182. }
  186. void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD_bit8) //组合BCD码转成非组合BCD码
  187. {
  188. unsigned char ucTmep;
  190. ucTmep=p_ucBCD_bit4[3];
  191. p_ucBCD_bit8[7]=ucTmep>>4; //把组合BCD码第8位分解出来
  192. p_ucBCD_bit8[6]=ucTmep&0x0f;//把组合BCD码第7位分解出来
  194. ucTmep=p_ucBCD_bit4[2];
  195. p_ucBCD_bit8[5]=ucTmep>>4; //把组合BCD码第6位分解出来
  196. p_ucBCD_bit8[4]=ucTmep&0x0f;//把组合BCD码第5位分解出来
  198. ucTmep=p_ucBCD_bit4[1];
  199. p_ucBCD_bit8[3]=ucTmep>>4; //把组合BCD码第4位分解出来
  200. p_ucBCD_bit8[2]=ucTmep&0x0f;//把组合BCD码第3位分解出来
  202. ucTmep=p_ucBCD_bit4[0];
  203. p_ucBCD_bit8[1]=ucTmep>>4; //把组合BCD码第2位分解出来
  204. p_ucBCD_bit8[0]=ucTmep&0x0f;//把组合BCD码第1位分解出来
  206. }
  210. void BCD8_to_number(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucNumber) //非组合BCD码转成数值
  211. {
  212. unsigned long ulTmep;
  213. unsigned long ulSum;
  215. ulSum=0;//累加和数值清零
  217. ulTmep=0;
  218. ulTmep=p_ucBCD_bit8[7];
  219. ulTmep=ulTmep*10000000;
  220. ulSum=ulSum+ulTmep; //累加各位数值
  222. ulTmep=0;
  223. ulTmep=p_ucBCD_bit8[6];
  224. ulTmep=ulTmep*1000000;
  225. ulSum=ulSum+ulTmep; //累加各位数值
  227. ulTmep=0;
  228. ulTmep=p_ucBCD_bit8[5];
  229. ulTmep=ulTmep*100000;
  230. ulSum=ulSum+ulTmep; //累加各位数值
  232. ulTmep=0;
  233. ulTmep=p_ucBCD_bit8[4];
  234. ulTmep=ulTmep*10000;
  235. ulSum=ulSum+ulTmep; //累加各位数值
  237. ulTmep=0;
  238. ulTmep=p_ucBCD_bit8[3];
  239. ulTmep=ulTmep*1000;
  240. ulSum=ulSum+ulTmep; //累加各位数值
  242. ulTmep=0;
  243. ulTmep=p_ucBCD_bit8[2];
  244. ulTmep=ulTmep*100;
  245. ulSum=ulSum+ulTmep; //累加各位数值
  247. ulTmep=0;
  248. ulTmep=p_ucBCD_bit8[1];
  249. ulTmep=ulTmep*10;
  250. ulSum=ulSum+ulTmep; //累加各位数值
  252. ulTmep=0;
  253. ulTmep=p_ucBCD_bit8[0];
  254. ulTmep=ulTmep*1;
  255. ulSum=ulSum+ulTmep; //累加各位数值
  257. //以上代码非常有规律，有兴趣的读者也可以自己想办法把它压缩成一个for循环的函数，可以极大节省容量。
  259. p_ucNumber[3]=ulSum>>24;//把long类型数据分解成4个字节
  260. p_ucNumber[2]=ulSum>>16;
  261. p_ucNumber[1]=ulSum>>8;
  262. p_ucNumber[0]=ulSum;
  263. }
  267. void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD_bit4) //非组合BCD码转成组合BCD码
  268. {
  269. unsigned char ucTmep;
  271. ucTmep=p_ucBCD_bit8[7]; //把非组合BCD码第8位分解出来
  272. p_ucBCD_bit4[3]=ucTmep<<4;
  273. p_ucBCD_bit4[3]=p_ucBCD_bit4[3]+p_ucBCD_bit8[6]; //把非组合BCD码第7位分解出来
  275. ucTmep=p_ucBCD_bit8[5]; //把非组合BCD码第6位分解出来
  276. p_ucBCD_bit4[2]=ucTmep<<4;
  277. p_ucBCD_bit4[2]=p_ucBCD_bit4[2]+p_ucBCD_bit8[4]; //把非组合BCD码第5位分解出来
  279. ucTmep=p_ucBCD_bit8[3]; //把非组合BCD码第4位分解出来
  280. p_ucBCD_bit4[1]=ucTmep<<4;
  281. p_ucBCD_bit4[1]=p_ucBCD_bit4[1]+p_ucBCD_bit8[2]; //把非组合BCD码第3位分解出来
  283. ucTmep=p_ucBCD_bit8[1]; //把非组合BCD码第2位分解出来
  284. p_ucBCD_bit4[0]=ucTmep<<4;
  285. p_ucBCD_bit4[0]=p_ucBCD_bit4[0]+p_ucBCD_bit8[0]; //把非组合BCD码第1位分解出来
  287. }
  289. void usart_service(void)//串口服务程序,在main函数里
  290. {
  292. unsigned char i=0;
  294. if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
  295. {
  297. ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
  299. //下面的代码进入数据协议解析和数据处理的阶段
  301. uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
  303. while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5))
  304. {
  305. if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)//数据头eb 00 55的判断
  306. {
  307. switch(ucRcregBuf[uiRcMoveIndex+3])//根据命令类型来进行不同的处理
  308. {
  309. case 1://接收到的是数值，需要转成组合BCD码和非组合BCD码
  310. for(i=0;i<4;i++)
  311. {
  312. ucBufferNumber[3-i]=ucRcregBuf[uiRcMoveIndex+4+i]; //从串口接收到的数据，注意，高位在数组下标大的方向
  313. }
  314. number_to_BCD4(ucBufferNumber,ucBufferBCB_bit4);//把数值转换成组合BCD码
  315. number_to_BCD8(ucBufferNumber,ucBufferBCB_bit8);//把数值转换成非组合BCD码
  316. for(i=0;i<4;i++)
  317. {
  318. eusart_send(ucBufferBCB_bit4[3-i]);////把组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
  319. }
  320. eusart_send(0xee);//为了方便上位机观察，多发送3个字节ee ee ee作为分割线
  321. eusart_send(0xee);
  322. eusart_send(0xee);
  323. for(i=0;i<8;i++)
  324. {
  325. eusart_send(ucBufferBCB_bit8[7-i]);////把非组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
  326. }
  328. break;
  329. case 2://接收到的是组合BCD码，需要转成数值和非组合BCD码
  330. for(i=0;i<4;i++)
  331. {
  332. ucBufferBCB_bit4[3-i]=ucRcregBuf[uiRcMoveIndex+4+i]; //从串口接收到的组合BCD码，注意，高位在数组下标大的方向
  333. }
  334. BCD4_to_number(ucBufferBCB_bit4,ucBufferNumber); //组合BCD码转成数值
  335. BCD4_to_BCD8(ucBufferBCB_bit4,ucBufferBCB_bit8); //组合BCD码转成非组合BCD码
  336. for(i=0;i<4;i++)
  337. {
  338. eusart_send(ucBufferNumber[3-i]);////把数值返回给上位机观察，注意，高位在数组下标大的方向
  339. }
  340. eusart_send(0xee);//为了方便上位机观察，多发送3个字节ee ee ee作为分割线
  341. eusart_send(0xee);
  342. eusart_send(0xee);
  343. for(i=0;i<8;i++)
  344. {
  345. eusart_send(ucBufferBCB_bit8[7-i]);////把非组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
  346. }
  348. break;
  349. case 3://接收到的是非组合BCD码，需要转成数值和组合BCD码
  350. for(i=0;i<8;i++)
  351. {
  352. ucBufferBCB_bit8[7-i]=ucRcregBuf[uiRcMoveIndex+4+i]; //从串口接收到的非组合BCD码，注意，高位在数组下标大的方向
  353. }
  355. BCD8_to_number(ucBufferBCB_bit8,ucBufferNumber); //非组合BCD码转成数值
  356. BCD8_to_BCD4(ucBufferBCB_bit8,ucBufferBCB_bit4); //非组合BCD码转成组合BCD码
  357. for(i=0;i<4;i++)
  358. {
  359. eusart_send(ucBufferNumber[3-i]);////把数值返回给上位机观察
  360. }
  361. eusart_send(0xee);//为了方便上位机观察，多发送3个字节ee ee ee作为分割线，注意，高位在数组下标大的方向
  362. eusart_send(0xee);
  363. eusart_send(0xee);
  364. for(i=0;i<4;i++)
  365. {
  366. eusart_send(ucBufferBCB_bit4[3-i]);////把组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
  367. }
  369. break;
  370. }
  372. break; //退出循环
  373. }
  374. uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
  375. }
  377. uiRcregTotal=0;//清空缓冲的下标，方便下次重新从0下标开始接受新数据
  379. }
  381. }
  383. void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
  384. {
  386. ES = 0; //关串口中断
  387. TI = 0; //清零串口发送完成中断请求标志
  388. SBUF =ucSendData; //发送一个字节
  390. delay_short(400);//每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整
  392. TI = 0; //清零串口发送完成中断请求标志
  393. ES = 1; //允许串口中断
  395. }
  399. void T0_time(void) interrupt 1 //定时中断
  400. {
  401. TF0=0;//清除中断标志
  402. TR0=0; //关中断
  405. if(uiSendCnt
  406. {
  407. uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
  408. ucSendLock=1; //开自锁标志
  409. }
  413. TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
  414. TL0=0x0b;
  415. TR0=1;//开中断
  416. }
  419. void usart_receive(void) interrupt 4 //串口接收数据中断
  420. {
  422. if(RI==1)
  423. {
  424. RI = 0;
  426. ++uiRcregTotal;
  427. if(uiRcregTotal>const_rc_size)//超过缓冲区
  428. {
  429. uiRcregTotal=const_rc_size;
  430. }
  431. ucRcregBuf[uiRcregTotal-1]=SBUF; //将串口接收到的数据缓存到接收缓冲区里
  432. uiSendCnt=0;//及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
  434. }
  435. else//发送中断，及时把发送中断标志位清零
  436. {
  437. TI = 0;
  438. }
  440. }
  443. void delay_long(unsigned int uiDelayLong)
  444. {
  445. unsigned int i;
  446. unsigned int j;
  447. for(i=0;i
  448. {
  449. for(j=0;j<500;j++)//内嵌循环的空指令数量
  450. {
  451. ; //一个分号相当于执行一条空语句
  452. }
  453. }
  454. }
  456. void delay_short(unsigned int uiDelayShort)
  457. {
  458. unsigned int i;
  459. for(i=0;i
  460. {
  461. ; //一个分号相当于执行一条空语句
  462. }
  463. }
  466. void initial_myself(void)//第一区 初始化单片机
  467. {
  469. beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
  471. //配置定时器
  472. TMOD=0x01;//设置定时器0为工作方式1
  473. TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
  474. TL0=0x0b;
  477. //配置串口
  478. SCON=0x50;
  479. TMOD=0X21;
  480. TH1=TL1=-(11059200L/12/32/9600);//这段配置代码具体是什么意思，我也不太清楚，反正是跟串口波特率有关。
  481. TR1=1;
  483. }
  485. void initial_peripheral(void) //第二区 初始化外围
  486. {
  488. EA=1; //开总中断
  489. ES=1; //允许串口中断
  490. ET0=1; //允许定时中断
  491. TR0=1; //启动定时中断
  493. }

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

关键词： 组合非组合BCD码数值相互转

评论


相关推荐

技术专区

关闭