第61節：組合和非組合BCD碼以及數值相互轉換

第六十一節：組合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個字節）的范圍就會出錯。而這種大數據算法的程序是什么樣的？欲知詳情，請聽下回分解----大數據的加法運算。