第65節(jié)：大數(shù)據(jù)的除法運算

開場白：
直接用C語言的“/”運算符進行除法運算時，“被除數(shù)”，“ 除數(shù)”，“商”，這三個數(shù)據(jù)的最大范圍是unsigned long 類型，也就是數(shù)據(jù)最大范圍是4個字節(jié)，十進制的范圍是0至4294967295。一旦超過了這個范圍，則運算會出錯。因此，當(dāng)進行大數(shù)據(jù)除法運算時，我們要額外編程序，實現(xiàn)大數(shù)據(jù)的算法。其實這種算法并不難，就是我們在小學(xué)里學(xué)的四則運算算法。
我們先要弄清楚一個新的概念。不考慮小數(shù)點的情況下，數(shù)據(jù)有兩種表現(xiàn)形式。一種是常用的變量形式，另外一種是BCD碼數(shù)組形式。變量的最大范圍有限，而BCD碼數(shù)組的形式是無限的，正因為這個特點，所以我們可以進行大數(shù)據(jù)運算。
這一節(jié)要教大家一個知識點：
第一個：如何編寫涉及到大數(shù)據(jù)除法運算的算法程序函數(shù)，同時也復(fù)習(xí)了指針的用途。

具體內(nèi)容，請看源代碼講解。

（1）硬件平臺：
基于朱兆祺51單片機學(xué)習(xí)板。

（2）實現(xiàn)功能：
波特率是：9600 。
通過電腦串口調(diào)試助手模擬上位機，往單片機發(fā)送組合BCD碼的被除數(shù)和除數(shù)，單片機把組合BCD碼的運算結(jié)果返回到上位機。被除數(shù)與除數(shù)的最大范圍都是從0到9999，如果運算的商超過允許保存的最大位數(shù)范圍或者除數(shù)為0，則返回EE EE EE報錯。
往單片機發(fā)送的數(shù)據(jù)格式：EB 00 55 XX XX 0d0aYY YY 0d0a指令，其中EB 00 55是數(shù)據(jù)頭，XX XX是被除數(shù)，是1到2個字節(jié)的組合BCD碼。YY YY是除數(shù)，是1到2個字節(jié)的組合BCD碼。0d 0a是固定的結(jié)束標(biāo)志。
例如：
（a）9816 ÷ 8= 1227
上位機發(fā)送數(shù)據(jù)：eb 00 55 98 16 0d 0a 08 0d 0a
單片機返回：12 27
（b）9816 ÷ 0= 出錯了，除數(shù)不能為0。
上位機發(fā)送數(shù)據(jù)：eb 00 55 98 16 0d 0a 00 0d 0a
單片機返回：EE EE EE

（3）源代碼講解如下：

1. #include "REG52.H"
4. /* 注釋一：
5. * 本系統(tǒng)中的除法運算，規(guī)定被除數(shù)和除數(shù)的最大范圍是0至9999.
6. * 由于STC89C52單片機的RAM只有256個，也就是說系統(tǒng)的變量數(shù)最大
7. * 不能超過256個，如果超過了這個極限，編譯器就會報錯。由于51單片機RAM資源有限，
8. * 因此規(guī)定除數(shù)的最大范圍不能超過9999，如果這個算法移植到stm32或者PIC等RAM比較大
9. * 的單片機上，那么就可以把這個運算位數(shù)設(shè)置得更加大一點。調(diào)整下面 BCD4_MAX的大小，
10. * 可以調(diào)整運算的數(shù)據(jù)范圍。
11. */
13. #defineBCD4_MAX 3//調(diào)整BCD4_MAX的大小，可以調(diào)整運算的數(shù)據(jù)范圍。
14. #defineBCD8_MAX (BCD4_MAX*2)//本系統(tǒng)中，規(guī)定的非組合BCD碼能保存的最大字節(jié)數(shù)，一個字節(jié)包含1位有效運算數(shù)
16. #define const_rc_size30//接收串口中斷數(shù)據(jù)的緩沖區(qū)數(shù)組大小
18. #define const_receive_time5//如果超過這個時間沒有串口數(shù)據(jù)過來，就認為一串?dāng)?shù)據(jù)已經(jīng)全部接收完，這個時間根據(jù)實際情況來調(diào)整大小
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);//定時中斷函數(shù)
34. void usart_receive(void); //串口接收中斷函數(shù)
35. void usart_service(void);//串口服務(wù)程序,在main函數(shù)里
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);//兩個數(shù)相加
46. uchar CmpData(const uchar *destData,const uchar *sourceData); //比較兩個數(shù)的大小
47. uchar SubData(const uchar *destData,const uchar *sourceData,uchar *resultData);//兩個數(shù)相減
48. void EnlargeData(uchar *destData,uchar enlarge_cnt); //數(shù)組向大索引值移位，移一位相當(dāng)于放大10倍
49. uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData); //兩個數(shù)相乘
51. uchar DivLessTenData(const uchar *destData,const uchar *sourceData,uchar *resultData,uchar *remData);//局部兩個數(shù)相除，商不超過10。當(dāng)商為0時，余數(shù)等于被除數(shù)
52. uchar Div(const uchar *destData,const uchar *sourceData,uchar *resultData);//兩個數(shù)相除
54. sbit beep_dr=P2^7; //蜂鳴器的驅(qū)動IO口
56. unsigned intuiSendCnt=0; //用來識別串口是否接收完一串?dāng)?shù)據(jù)的計時器
57. unsigned char ucSendLock=1; //串口服務(wù)程序的自鎖變量，每次接收完一串?dāng)?shù)據(jù)只處理一次
58. unsigned intuiRcregTotal=0;//代表當(dāng)前緩沖區(qū)已經(jīng)接收了多少個數(shù)據(jù)
59. unsigned char ucRcregBuf[const_rc_size]; //接收串口中斷數(shù)據(jù)的緩沖區(qū)數(shù)組
60. unsigned intuiRcMoveIndex=0;//用來解析數(shù)據(jù)協(xié)議的中間變量
63. unsigned char ucDataBCD4_1[BCD4_MAX]; //接收到的第1個數(shù)組合BCD碼數(shù)組形式這里是指被乘數(shù)
64. unsigned char ucDataBCD4_cnt_1=0;//接收到的第1個數(shù)組合BCD碼數(shù)組的有效數(shù)據(jù)長度
66. unsigned char ucDataBCD4_2[BCD4_MAX]; //接收到的第2個數(shù)組合BCD碼數(shù)組形式這里是指乘數(shù)
67. unsigned char ucDataBCD4_cnt_2=0;//接收到的第2個數(shù)組合BCD碼數(shù)組的有效數(shù)據(jù)長度
69. unsigned char ucDataBCD4_3[BCD4_MAX]; //接收到的第3個數(shù)組合BCD碼數(shù)組形式這里是指積
70. unsigned char ucDataBCD4_cnt_3=0;//接收到的第3個數(shù)組合BCD碼數(shù)組的有效數(shù)據(jù)長度
73. unsigned char ucDataBCD8_1[BCD8_MAX]; //接收到的第1個數(shù)非組合BCD碼數(shù)組形式 這里是指被乘數(shù)
74. unsigned char ucDataBCD8_cnt_1=0;//接收到的第1個數(shù)非組合BCD碼數(shù)組的有效數(shù)據(jù)長度
76. unsigned char ucDataBCD8_2[BCD8_MAX]; //接收到的第2個數(shù)非組合BCD碼數(shù)組形式 這里是指乘數(shù)
77. unsigned char ucDataBCD8_cnt_2=0;//接收到的第2個數(shù)非組合BCD碼數(shù)組的有效數(shù)據(jù)長度
79. unsigned char ucDataBCD8_3[BCD8_MAX]; //接收到的第3個數(shù)非組合BCD碼數(shù)組形式 這里是指積
80. unsigned char ucDataBCD8_cnt_3=0;//接收到的第3個數(shù)非組合BCD碼數(shù)組的有效數(shù)據(jù)長度
82. unsigned char ucResultFlag=11; //運算結(jié)果標(biāo)志，10代表計算結(jié)果超出范圍出錯，11代表正常。
84. void main()
85. {
86. initial_myself();
87. delay_long(100);
88. initial_peripheral();
89. while(1)
90. {
91. usart_service();//串口服務(wù)程序
92. }
94. }
96. /* 注釋二：
97. * 組合BCD碼轉(zhuǎn)成非組合BCD碼。
98. * 這里的變量ucBCD4_cnt代表組合BCD碼的有效字節(jié)數(shù).
99. * 這里的變量*p_ucBCD8_cnt代表經(jīng)過轉(zhuǎn)換后，非組合BCD碼的有效字節(jié)數(shù)，記得加地址符號&傳址進去
100. * 本程序在上一節(jié)的基礎(chǔ)上，略作修改，用循環(huán)for語句壓縮了代碼，
101. * 同時引進了組合BCD碼的有效字節(jié)數(shù)變量。這樣就不限定了數(shù)據(jù)的長度，
102. * 可以讓我們根據(jù)數(shù)據(jù)的實際大小靈活運用。
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; //轉(zhuǎn)換成非組合BCD碼后的有效數(shù)據(jù)長度
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碼轉(zhuǎn)成組合BCD碼。
129. * 這里的變量ucBCD8_cnt代表非組合BCD碼的有效字節(jié)數(shù).
130. * 這里的變量*p_ucBCD4_cnt代表經(jīng)過轉(zhuǎn)換后，組合BCD碼的有效字節(jié)數(shù)，記得加地址符號&傳址進去
131. * 本程序在上一節(jié)的基礎(chǔ)上，略作修改，用循環(huán)for語句壓縮了代碼，
132. * 同時引進了非組合BCD碼的有效字節(jié)數(shù)變量。這樣就不限定了數(shù)據(jù)的長度，
133. * 可以讓我們根據(jù)數(shù)據(jù)的實際大小靈活運用。
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碼轉(zhuǎn)化成組合BCD碼的有效數(shù),這里+1避免非組合數(shù)據(jù)長度是奇數(shù)位
147. *p_ucBCD4_cnt=ucBCD4_cnt; //把轉(zhuǎn)換后的結(jié)果付給接口指針的數(shù)據(jù)，可以對外輸出結(jié)果
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. *函數(shù)介紹：清零數(shù)組的全部數(shù)組數(shù)據(jù)
160. *輸入?yún)?shù)：ucARRAY_MAX代表數(shù)組定義的最大長度
161. *輸入輸出參數(shù)：*destData--被清零的數(shù)組。
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. *函數(shù)介紹：獲取數(shù)組的有效長度
178. *輸入?yún)?shù)：*destData--被獲取的數(shù)組。
179. *輸入?yún)?shù)：ucARRAY_MAX代表數(shù)組定義的最大長度
180. *返回值：返回數(shù)組的有效長度。比如58786這個數(shù)據(jù)的有效長度是5
181. *電子開發(fā)者作者：吳堅鴻
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. *函數(shù)介紹：比較兩個數(shù)的大小
207. *輸入?yún)?shù)：
208. *（1）*destData--被比較數(shù)的數(shù)組。
209. *（2）*sourceData--比較數(shù)的數(shù)組。
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//否則就要繼續(xù)判斷
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. //否則繼續(xù)判斷下一位
250. }
251. }
254. return cmpResult;
255. }
258. /* 注釋七：
259. *函數(shù)介紹：兩個數(shù)相減
260. *輸入?yún)?shù)：
261. *（1）*destData--被減數(shù)的數(shù)組。
262. *（2）*sourceData--減數(shù)的數(shù)組。
263. *（3）*resultData--差的數(shù)組。注意，調(diào)用本函數(shù)前，必須先把這個數(shù)組清零
264. *返回值：10代表計算結(jié)果是負數(shù)或者超出范圍出錯，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; //最大位數(shù)
274. uchar resultTemp=0; //存放臨時運算結(jié)果的中間變量
276. //為什么不在本函數(shù)內(nèi)先把resultData數(shù)組清零？因為后面章節(jié)中的除法運算中要用到此函數(shù)實現(xiàn)連減功能。
277. //因此如果純粹實現(xiàn)減法運算時，在調(diào)用本函數(shù)之前，必須先在外面把差的數(shù)組清零，否則會計算出錯。
279. if(CmpData(destData,sourceData)==9)//被減數(shù)小于減數(shù)，報錯
280. {
281. subResult=10;
282. return subResult;//返回判斷結(jié)果，并且退出本程序，不往下執(zhí)行本程序余下代碼
283. }
285. destCnt=GetDataLength(destData,BCD8_MAX);//獲取被減數(shù)的有效數(shù)據(jù)長度
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. *函數(shù)介紹：兩個數(shù)相加
313. *輸入?yún)?shù)：
314. *（1）*destData--被加數(shù)的數(shù)組。
315. *（2）*sourceData--加數(shù)的數(shù)組。
316. *（3）*resultData--和的數(shù)組。注意，調(diào)用本函數(shù)前，必須先把這個數(shù)組清零
317. *返回值：10代表計算結(jié)果超出范圍出錯，11代表正常。
318. */
319. uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData)
320. {
321. uchar addResult=11; //開始默認返回的運算結(jié)果是正常
322. uchar destCnt=0;
323. uchar sourceCnt=0;
324. uchar i;
325. uchar carryData=0;//進位
326. uchar maxCnt=0; //最大位數(shù)
327. uchar resultTemp=0; //存放臨時運算結(jié)果的中間變量
329. //為什么不在本函數(shù)內(nèi)先把resultData數(shù)組清零？因為后面章節(jié)中的乘法運算中要用到此函數(shù)實現(xiàn)連加功能。
330. //因此如果純粹實現(xiàn)加法運算時，在調(diào)用本函數(shù)之前，必須先在外面把和的數(shù)組清零，否則會計算出錯。
332. destCnt=GetDataLength(destData,BCD8_MAX); //獲取被加數(shù)的有效位數(shù)
333. sourceCnt=GetDataLength(sourceData,BCD8_MAX);//獲取加數(shù)的有效位數(shù)
335. if(destCnt>=sourceCnt)//找出兩個運算數(shù)據(jù)中最大的有效位數(shù)
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; //截取最低位存放進保存結(jié)果的數(shù)組
348. carryData=resultTemp/10; //存放進位
349. }
351. resultData[i]=carryData;
353. if((maxCnt==BCD8_MAX)&&(carryData==1))//如果數(shù)組的有效位是最大值并且最后的進位是1，則計算溢出報錯
354. {
356. ClearAllData(BCD8_MAX,resultData);
358. addResult=10;//報錯
359. }
362. return addResult;
363. }
367. /* 注釋九：
368. *函數(shù)介紹：數(shù)組向大索引值移位，移一位相當(dāng)于放大10倍
369. *輸入?yún)?shù)：*destData--被移位的數(shù)組。
370. *輸入?yún)?shù)：enlarge_cnt--被移位的個數(shù)。
371. */
372. void EnlargeData(uchar *destData,uchar enlarge_cnt)
373. {
374. uchar i;
376. if(enlarge_cnt!=0)
377. {
378. for(i=0;i<(BCD8_MAX-enlarge_cnt);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. *函數(shù)介紹：兩個數(shù)相乘
396. *輸入?yún)?shù)：
397. *（1）*destData--被乘數(shù)的數(shù)組。
398. *（2）*sourceData--乘數(shù)的數(shù)組。
399. *（3）*resultData--積的數(shù)組。
400. *返回值：10代表計算結(jié)果超出范圍出錯，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; //存放臨時運算結(jié)果的中間變量
413. uchar nc_add_result;//接收相加的運算是否超出范圍，這里不用判斷，因為不會溢出
415. uchar multArrayTemp[BCD8_MAX]; //存放臨時運算結(jié)果的數(shù)組中間變量
419. destCnt=GetDataLength(destData,BCD8_MAX); //獲取被乘數(shù)的長度
420. sourceCnt=GetDataLength(sourceData,BCD8_MAX); //獲取乘數(shù)的長度
422. ClearAllData(BCD8_MAX,resultData); //清零存儲的結(jié)果
423. if((0==destCnt)||(0==sourceCnt)) //被乘數(shù)或者乘數(shù)為0，則結(jié)果為0
424. {
425. return multResult;
426. }
429. if((destCnt+sourceCnt+2)>BCD8_MAX)
430. {
431. multResult=10; //運算結(jié)果有可能超范圍報錯
432. return multResult;
433. }
435. for(i=0;i
436. {
437. carryData=0; //清零進位
438. ClearAllData(BCD8_MAX,multArrayTemp); //清零一位乘數(shù)相乘的結(jié)果中間變量數(shù)組
439. for(j=0;j
440. {
441. resultTemp=destData[j]*sourceData[i]+carryData;//乘數(shù)的一位依次與被乘數(shù)各位相乘,并且加進位
442. multArrayTemp[j]=resultTemp%10;//存儲一位乘數(shù)相乘的結(jié)果
443. carryData=resultTemp/10; //保存進位
444. }
445. multArrayTemp[j]=carryData; //存儲最后的進位
446. EnlargeData(multArrayTemp,i); //移位。移一次相當(dāng)于放大10倍。
447. nc_add_result=AddData(resultData,multArrayTemp,resultData); //把一位乘數(shù)相乘的結(jié)果存儲進總結(jié)果
449. }
452. return multResult;
453. }
457. /* 注釋十一：
458. *函數(shù)介紹：局部兩個數(shù)相除，商不超過10。當(dāng)商為0時，余數(shù)是被除數(shù)
459. *原理精髓：根據(jù)手工除法的原理，我們都是從高位開始借位相除，此時是局部相除，因此商都不超過10，剩下的余數(shù)繼續(xù)借位
460. *依次除下去。這個程序的除法原理是挨個猜值，反正商是從0，1,2.。。。9這10個數(shù)中的其中一個，為了快速找到我們想要的那個商，我是
461. *利用中間法則進行尋找，先猜是5，然后判斷一下是大了還是小了，如果是大了，就猜是3，如果小了就猜是7，最后肯定會找到商。
462. *輸入?yún)?shù)：
463. *（1）*destData--被除數(shù)的數(shù)組。
464. *（2）*sourceData--除數(shù)的數(shù)組。
465. *（3）*resultData--商的數(shù),不是數(shù)組，傳址進去，是0,1,2到9中的某個數(shù)
466. *（4）*remData--余數(shù)的數(shù)組。
467. *返回值：10代表計算結(jié)果超出范圍出錯，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]; //存放臨時運算結(jié)果的數(shù)組中間變量
481. uchar DivLessTenArrayResult[BCD8_MAX]; //存放臨時運算結(jié)果的數(shù)組中間變量的結(jié)果
482. uchar DivLessTenArrayBackup[BCD8_MAX]; //存放臨時運算結(jié)果的數(shù)組中間變量的備份
483. uchar while_flag=0;//結(jié)束猜算的中間變量
484. uchar multError=11;
485. uchar subError=11;
487. destCnt=GetDataLength(destData,BCD8_MAX); //獲取被除數(shù)的數(shù)據(jù)有效長度
488. sourceCnt=GetDataLength(sourceData,BCD8_MAX); //獲取除數(shù)的數(shù)據(jù)有效長度
490. cmpError=CmpData(destData,sourceData); //比較被除數(shù)和除數(shù)的大小
492. ClearAllData(BCD8_MAX,remData); //清空余數(shù),余數(shù)為0
494. if(cmpError==9) //被除數(shù)比除數(shù)小
495. {
496. *resultData=0; //商肯定為0
497. for(i=0;i
498. {
499. remData[i]=destData[i]; //余數(shù)等于被除數(shù)
500. }
501. return DivLessTenResult;
502. }
503. else if(cmpError==10) //被除數(shù)與除數(shù)相等
504. {
506. *resultData=1; //商等于1余數(shù)為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);//求余數(shù)
525. *resultData=1; //商等于1
526. while_flag=1; //退出循環(huán)
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余數(shù)為0
537. while_flag=1; //退出循環(huán)
538. }
539. else if(cmpError==11) //大于
540. {
541. resultRunStep=1;
542. }
543. else //小于
544. {
545. subError=SubData(destData,DivLessTenArrayResult,remData);//求余數(shù)
546. *resultData=2; //商等于2
547. while_flag=1; //退出循環(huán)
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余數(shù)為0
563. while_flag=1; //退出循環(huán)
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余數(shù)為0
592. while_flag=1; //退出循環(huán)
593. }
594. else if(cmpError==11) //大于
595. {
596. subError=SubData(destData,DivLessTenArrayBackup,remData);//求余數(shù)
597. *resultData=3; //商等于3
598. while_flag=1; //退出循環(huán)
599. }
600. else //小于
601. {
602. subError=SubData(destData,DivLessTenArrayResult,remData);//求余數(shù)
603. *resultData=4; //商等于4
604. while_flag=1; //退出循環(huán)
605. }
609. break;
610. case 5: //重點講解一下case 5，其它case 原理相同，不多講
611. ClearAllData(BCD8_MAX,DivLessTenArrayTemp); //清空運算中需要用到的中間數(shù)組變量
612. ClearAllData(BCD8_MAX,DivLessTenArrayResult); //清空運算中需要用到的中間數(shù)組變量
613. DivLessTenArrayTemp[0]=resultRunStep;//把猜的變量形式的商傳遞給數(shù)組形式的變量
614. multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);//猜的商跟除數(shù)像乘，看看結(jié)果跟被除數(shù)誰大。
615. cmpError=CmpData(DivLessTenArrayResult,destData); //猜的商跟除數(shù)像乘，看看結(jié)果跟被除數(shù)誰大。
616. if(cmpError==10) //等于 恭喜猜中是5
617. {
618. *resultData=5; //商等于5余數(shù)為0
619. while_flag=1; //退出循環(huán)
620. }
621. else if(cmpError==11) //大于 猜不中，大了，就繼續(xù)往小的猜，看看有沒有可能是3
622. {
623. resultRunStep=3;
624. }
625. else //小于 猜不中，小了，就繼續(xù)往大的猜，看看有沒有可能是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余數(shù)為0
647. while_flag=1; //退出循環(huán)
648. }
649. else if(cmpError==11) //大于
650. {
651. subError=SubData(destData,DivLessTenArrayBackup,remData);//求余數(shù)
652. *resultData=5; //商等于5
653. while_flag=1; //退出循環(huán)
654. }
655. else //小于
656. {
657. subError=SubData(destData,DivLessTenArrayResult,remData);//求余數(shù)
658. *resultData=6; //商等于6
659. while_flag=1; //退出循環(huán)
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余數(shù)為0
673. while_flag=1; //退出循環(huán)
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余數(shù)為0
702. while_flag=1; //退出循環(huán)
703. }
704. else if(cmpError==11) //大于
705. {
706. subError=SubData(destData,DivLessTenArrayBackup,remData);//求余數(shù)
707. *resultData=7; //商等于7
708. while_flag=1; //退出循環(huán)
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余數(shù)為0
731. while_flag=1; //退出循環(huán)
732. }
733. else if(cmpError==11) //大于
734. {
735. subError=SubData(destData,DivLessTenArrayBackup,remData);//求余數(shù)
736. *resultData=8; //商等于8
737. while_flag=1; //退出循環(huán)
738. }
739. else //小于
740. {
741. subError=SubData(destData,DivLessTenArrayResult,remData);//求余數(shù)
742. *resultData=9; //商等于9
743. while_flag=1; //退出循環(huán)
744. }
745. break;
747. }
749. if(while_flag==1)//猜中了就退出循環(huán)
750. {
751. break;
752. }
753. }
755. }
757. return DivLessTenResult;
758. }
762. /* 注釋十二：
763. *函數(shù)介紹：兩個數(shù)相除
764. *輸入?yún)?shù)：
765. *（1）*destData--被除數(shù)的數(shù)組。
766. *（2）*sourceData--除數(shù)的數(shù)組。
767. *（3）*resultData--商的數(shù)組
768. *返回值：10代表計算結(jié)果超出范圍出錯，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; //存放臨時運算結(jié)果的中間變量
778. uchar DivArrayTemp[BCD8_MAX]; //存放臨時運算結(jié)果的數(shù)組中間變量
779. uchar DivArrayResult[BCD8_MAX]; //存放臨時運算結(jié)果的數(shù)組中間變量的結(jié)果
780. uchar divError=11;
784. destCnt=GetDataLength(destData,BCD8_MAX); //獲取被除數(shù)的數(shù)據(jù)有效長度
785. sourceCnt=GetDataLength(sourceData,BCD8_MAX); //獲取除數(shù)的數(shù)據(jù)有效長度
788. ClearAllData(BCD8_MAX,resultData); //把結(jié)果清零
790. if(sourceCnt==0)//除數(shù)為0，報錯
791. {
792. DivResult=10; //報錯
793. }
794. else
795. {
796. ClearAllData(BCD8_MAX,DivArrayTemp); //清零局部被除數(shù)的數(shù)組
797. for(i=0;i
798. {
799. DivArrayTemp[0]=destData[destCnt-1-i];//從被除數(shù)的高位開始借位,放到局部被除數(shù)的個位
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<(destCnt-1);j++)//把余數(shù)移一次位,相當(dāng)于放大十倍,重新放進DivArrayTemp數(shù)組對應(yīng)的位
811. {
812. DivArrayTemp[j+1]=DivArrayResult[j];
813. }
814. }
816. }
818. }
822. return DivResult;
823. }
827. void usart_service(void)//串口服務(wù)程序,在main函數(shù)里
828. {
830. unsigned char i=0;
831. unsigned char k=0;
832. unsigned char ucGetDataStep=0;
834. if(uiSendCnt>=const_receive_time&&ucSendLock==1) //說明超過了一定的時間內(nèi)，再也沒有新數(shù)據(jù)從串口來
835. {
837. ucSendLock=0; //處理一次就鎖起來，不用每次都進來,除非有新接收的數(shù)據(jù)
839. //下面的代碼進入數(shù)據(jù)協(xié)議解析和數(shù)據(jù)處理的階段
841. uiRcMoveIndex=0; //由于是判斷數(shù)據(jù)頭，所以下標(biāo)移動變量從數(shù)組的0開始向最尾端移動
842. while(uiRcMoveIndex
843. {
844. if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55)//數(shù)據(jù)頭eb 00 55的判斷
845. {
847. i=0;
848. ucGetDataStep=0;
849. ucDataBCD4_cnt_1=0;//第1個數(shù)組合BCD碼數(shù)組的有效數(shù)據(jù)長度
850. ucDataBCD4_cnt_2=0;//第2個數(shù)組合BCD碼數(shù)組的有效數(shù)據(jù)長度
852. ClearAllData(BCD4_MAX,ucDataBCD4_1);//清零第1個參與運算的數(shù)據(jù)
853. ClearAllData(BCD4_MAX,ucDataBCD4_2);//清零第2個參與運算的數(shù)據(jù)
855. //以下while循環(huán)是通過關(guān)鍵字0x0d 0x0a來截取第1個和第2個參與運算的數(shù)據(jù)。
856. while(i<(BCD8_MAX+4))//這里+4是因為有2對0x0d 0x0a結(jié)尾特殊符號，一個共4個字節(jié)
857. {
858. if(ucGetDataStep==0)//步驟0，相當(dāng)于我平時用的case 0,獲取第1個數(shù)，在這里是指被除數(shù)
859. {
860. if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //結(jié)束標(biāo)志
861. {
862. for(k=0;k
863. {
864. ucDataBCD4_1[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的數(shù)組數(shù)據(jù)與實際存儲的數(shù)組數(shù)據(jù)的下標(biāo)方向是相反的
865. }
866. i=i+2; //跳過 0x0d 0x0a 這兩個字節(jié)，進行下一輪的關(guān)鍵字提取
867. ucGetDataStep=1;//切換到下一個關(guān)鍵字提取的步驟
869. }
870. else
871. {
872. i++;
873. ucDataBCD4_cnt_1++;//統(tǒng)計第1個有效數(shù)據(jù)的長度
874. }
876. }
877. else if(ucGetDataStep==1) //步驟1，相當(dāng)于我平時用的case 1,獲取第2個參與運行的數(shù)，在這里是除數(shù)
878. {
879. if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //結(jié)束標(biāo)志
880. {
881. for(k=0;k
882. {
883. ucDataBCD4_2[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的數(shù)組數(shù)據(jù)與實際存儲的數(shù)組數(shù)據(jù)的下標(biāo)方向是相反的
884. }
886. break; //截取數(shù)據(jù)完成。直接跳出截取數(shù)據(jù)的while(i<(BCD8_MAX+4))循環(huán)
888. }
889. else
890. {
891. i++;
892. ucDataBCD4_cnt_2++;//統(tǒng)計第2個有效數(shù)據(jù)的長度
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碼轉(zhuǎn)換成非組合BCD碼第1個數(shù)
900. BCD4_to_BCD8(ucDataBCD4_2,ucDataBCD4_cnt_2,ucDataBCD8_2,&ucDataBCD8_cnt_2); //把接收到的組合BCD碼轉(zhuǎn)換成非組合BCD碼第2個數(shù)
903. ClearAllData(BCD8_MAX,ucDataBCD8_3);//清零第3個參與運算的數(shù)據(jù),用來接收運行的結(jié)果
904. ucResultFlag=Div(ucDataBCD8_1,ucDataBCD8_2,ucDataBCD8_3); //相除運算，結(jié)果放在ucDataBCD8_3數(shù)組里
905. if(ucResultFlag==11) //表示運算結(jié)果沒有超范圍
906. {
907. ucDataBCD8_cnt_3=GetDataLength(ucDataBCD8_3,BCD8_MAX);//獲取運算結(jié)果的有效字節(jié)數(shù)
908. if(ucDataBCD8_cnt_3==0) //如果1個有效位數(shù)都沒有，表示數(shù)組所有的數(shù)據(jù)都是0，這個時候的有效位數(shù)應(yīng)該人為的默認是1位數(shù)據(jù),表示一個0
909. {
910. ucDataBCD8_cnt_3=1;
911. }
913. BCD8_to_BCD4(ucDataBCD8_3,ucDataBCD8_cnt_3,ucDataBCD4_3,&ucDataBCD4_cnt_3); //把非組合BCD碼轉(zhuǎn)成組合BCD碼。注意，&ucDataBCD4_cnt_3帶地址符號&
914. for(k=0;k
915. {
916. eusart_send(ucDataBCD4_3[ucDataBCD4_cnt_3-1-k]); //往上位機發(fā)送一個字節(jié)的函數(shù)
917. }
918. }
919. else //運算結(jié)果超范圍，返回EE EE EE
920. {
921. eusart_send(0xee); //往上位機發(fā)送一個字節(jié)的函數(shù)
922. eusart_send(0xee); //往上位機發(fā)送一個字節(jié)的函數(shù)
923. eusart_send(0xee); //往上位機發(fā)送一個字節(jié)的函數(shù)
924. }
926. break; //退出循環(huán)
927. }
928. uiRcMoveIndex++; //因為是判斷數(shù)據(jù)頭，游標(biāo)向著數(shù)組最尾端的方向移動
929. }
931. ucRcregBuf[0]=0; //把數(shù)據(jù)頭清零，方便下次接收判斷新數(shù)據(jù)
932. ucRcregBuf[1]=0;
933. ucRcregBuf[2]=0;
935. uiRcregTotal=0;//清空緩沖的下標(biāo)，方便下次重新從0下標(biāo)開始接受新數(shù)據(jù)
937. }
939. }
941. void eusart_send(unsigned char ucSendData) //往上位機發(fā)送一個字節(jié)的函數(shù)
942. {
944. ES = 0; //關(guān)串口中斷
945. TI = 0; //清零串口發(fā)送完成中斷請求標(biāo)志
946. SBUF =ucSendData; //發(fā)送一個字節(jié)
948. delay_short(400);//每個字節(jié)之間的延時，這里非常關(guān)鍵，也是最容易出錯的地方。延時的大小請根據(jù)實際項目來調(diào)整
950. TI = 0; //清零串口發(fā)送完成中斷請求標(biāo)志
951. ES = 1; //允許串口中斷
953. }
957. void T0_time(void) interrupt 1 //定時中斷
958. {
959. TF0=0;//清除中斷標(biāo)志
960. TR0=0; //關(guān)中斷
963. if(uiSendCnt
964. {
965. uiSendCnt++; //表面上這個數(shù)據(jù)不斷累加，但是在串口中斷里，每接收一個字節(jié)它都會被清零，除非這個中間沒有串口數(shù)據(jù)過來
966. ucSendLock=1; //開自鎖標(biāo)志
967. }
971. TH0=0xfe; //重裝初始值(65535-500)=65035=0xfe0b
972. TL0=0x0b;
973. TR0=1;//開中斷
974. }
977. void usart_receive(void) interrupt 4 //串口接收數(shù)據(jù)中斷
978. {
980. if(RI==1)
981. {
982. RI = 0;
984. ++uiRcregTotal;
985. if(uiRcregTotal>const_rc_size)//超過緩沖區(qū)
986. {
987. uiRcregTotal=const_rc_size;
988. }
989. ucRcregBuf[uiRcregTotal-1]=SBUF; //將串口接收到的數(shù)據(jù)緩存到接收緩沖區(qū)里
990. uiSendCnt=0;//及時喂狗，雖然main函數(shù)那邊不斷在累加，但是只要串口的數(shù)據(jù)還沒發(fā)送完畢，那么它永遠也長不大,因為每個中斷都被清零。
992. }
993. else//發(fā)送中斷，及時把發(fā)送中斷標(biāo)志位清零
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++)//內(nèi)嵌循環(huán)的空指令數(shù)量
1008. {
1009. ; //一個分號相當(dāng)于執(zhí)行一條空語句
1010. }
1011. }
1012. }
1014. void delay_short(unsigned int uiDelayShort)
1015. {
1016. unsigned int i;
1017. for(i=0;i
1018. {
1019. ; //一個分號相當(dāng)于執(zhí)行一條空語句
1020. }
1021. }
1024. void initial_myself(void)//第一區(qū) 初始化單片機
1025. {
1027. beep_dr=1; //用PNP三極管控制蜂鳴器，輸出高電平時不叫。
1029. //配置定時器
1030. TMOD=0x01;//設(shè)置定時器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);//這段配置代碼具體是什么意思，我也不太清楚，反正是跟串口波特率有關(guān)。
1039. TR1=1;
1041. }
1043. void initial_peripheral(void) //第二區(qū) 初始化外圍
1044. {
1046. EA=1; //開總中斷
1047. ES=1; //允許串口中斷
1048. ET0=1; //允許定時中斷
1049. TR0=1; //啟動定時中斷
1051. }

總結(jié)陳詞：
前面四個章節(jié)講完了四則運算的大數(shù)據(jù)算法，下一節(jié)講單片機的外部中斷功能。外部中斷是單片機非常重要的內(nèi)部資源，應(yīng)用很廣，它是單片機的高速開關(guān)感應(yīng)器輸入接口，它可以檢測脈沖輸入，可以接收紅外遙控器的輸入信號，可以檢測高速運轉(zhuǎn)的車輪或者電機圓周運動的反饋信號，可以檢測輸液器里瞬間即逝的水滴信號，可以接收模擬串口的數(shù)據(jù)信息，等等。單片機外部中斷的有什么特點？欲知詳情，請聽下回分解----單片機外部中斷的基礎(chǔ)。