STM32F10x 学习笔记7（USART实现串口通讯 3）

在上一篇学习笔记《STM32F10x 学习笔记6（USART实现串口通讯 2）》给出了个利用环形缓冲区的串口驱动。最近研究了uCOS-II在STM32上的移植。下面再给个利用uCOS-II的信号量的串口驱动。整个驱动的基本框架和上一篇没什么区别，所以不多介绍。直接贴代码：

整个驱动包含四个文件：

本文引用地址：http://www.eepw.com.cn/article/201611/318843.htm

uart.h

uart.c

COMMRTOS.H

COMMRTOS.c

其中前两个文件是对串口基本功能的封装。

uart.h 的代码如下：

1. #ifndef_UART_H_
2. #define_UART_H_
4. voidUSART1_Init(void);
5. voidUSART2_Init(void);
6. voidUART_PutChar(USART_TypeDef*USARTx,uint8_tData);
7. voidUART_PutStr(USART_TypeDef*USARTx,uint8_t*str);
8. uint8_tUART_GetChar(USART_TypeDef*USARTx);
10. #endif

uart.c 的代码

1. #include"stm32f10x.h"
3. voidUSART1_Init(void)
4. {
5. GPIO_InitTypeDefGPIO_InitStructure;
6. USART_InitTypeDefUSART_InitStructure;
7. NVIC_InitTypeDefNVIC_InitStructure;
9. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1,ENABLE);
11. /*ConfigureUSARTTxasalternatefunctionpush-pull*/
12. GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;
13. GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9;
14. GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
15. GPIO_Init(GPIOA,&GPIO_InitStructure);
17. /*ConfigureUSARTRxasinputfloating*/
18. GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;
19. GPIO_InitStructure.GPIO_Pin=GPIO_Pin_10;
20. GPIO_Init(GPIOA,&GPIO_InitStructure);
22. USART_InitStructure.USART_BaudRate=9600;
23. USART_InitStructure.USART_WordLength=USART_WordLength_8b;
24. USART_InitStructure.USART_StopBits=USART_StopBits_1;
25. USART_InitStructure.USART_Parity=USART_Parity_No;
26. USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
27. USART_InitStructure.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
28. USART_Init(USART1,&USART_InitStructure);
30. USART_Cmd(USART1,ENABLE);
32. NVIC_InitStructure.NVIC_IRQChannel=USART1_IRQn;
33. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;
34. NVIC_InitStructure.NVIC_IRQChannelSubPriority=0;
35. NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
36. NVIC_Init(&NVIC_InitStructure);
37. }
39. voidUSART2_Init(void)
40. {
41. GPIO_InitTypeDefGPIO_InitStructure;
42. USART_InitTypeDefUSART_InitStructure;
43. NVIC_InitTypeDefNVIC_InitStructure;
45. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO,ENABLE);
47. /*ConfigureUSARTTxasalternatefunctionpush-pull*/
48. GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;
49. GPIO_InitStructure.GPIO_Pin=GPIO_Pin_5;
50. GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
51. GPIO_Init(GPIOD,&GPIO_InitStructure);
53. /*ConfigureUSARTRxasinputfloating*/
54. GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;
55. GPIO_InitStructure.GPIO_Pin=GPIO_Pin_6;
56. GPIO_Init(GPIOD,&GPIO_InitStructure);
58. GPIO_PinRemapConfig(GPIO_Remap_USART2,ENABLE);
59. RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);
61. USART_InitStructure.USART_BaudRate=9600;
62. USART_InitStructure.USART_WordLength=USART_WordLength_8b;
63. USART_InitStructure.USART_StopBits=USART_StopBits_1;
64. USART_InitStructure.USART_Parity=USART_Parity_No;
65. USART_InitStructure.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
66. USART_InitStructure.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
67. USART_Init(USART2,&USART_InitStructure);
69. USART_Cmd(USART2,ENABLE);
71. NVIC_InitStructure.NVIC_IRQChannel=USART2_IRQn;
72. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;
73. NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
74. NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
75. NVIC_Init(&NVIC_InitStructure);
76. }
78. voidUART_PutChar(USART_TypeDef*USARTx,uint8_tData)
79. {
80. //while(USART_GetFlagStatus(USARTx,USART_FLAG_TC)==RESET){};
81. while((USARTx->SR&USART_FLAG_TXE)==0x00){};
82. //USART_SendData(USARTx,Data);
83. USARTx->DR=Data;
84. }
85. voidUART_PutStr(USART_TypeDef*USARTx,uint8_t*str)
86. {
87. while(0!=*str)
88. {
89. UART_PutChar(USARTx,*str);
90. str++;
91. }
92. }
94. uint8_tUART_GetChar(USART_TypeDef*USARTx)
95. {
96. //while(USART_GetFlagStatus(USARTx,USART_FLAG_RXNE)==RESET){};
97. while((USARTx->SR&USART_FLAG_RXNE)==0x00){};
98. //returnUSART_ReceiveData(USARTx);
99. return(USARTx->DR&0xff);
100. }

commrtos.h 的代码如下：

1. #ifndef_COMMRTOS_H_
2. #define_COMMRTOS_H_
4. #ifndefCFG_H
6. #defineCOMM_RX_BUF_SIZE64/*NumberofcharactersinRxringbuffer*/
7. #defineCOMM_TX_BUF_SIZE64/*NumberofcharactersinTxringbuffer*/
9. #endif
11. /*
12. *********************************************************************************************************
13. *CONSTANTS
14. *********************************************************************************************************
15. */
16. #ifndefFALSE
17. #defineFALSE0x00
18. #endif
20. #ifndefTRUE
21. #defineTRUE0xff
22. #endif
24. #ifndefNUL
25. #defineNUL0x00
26. #endif
28. #defineCOM10
29. #defineCOM21
31. /*ERRORCODES*/
32. #defineCOMM_NO_ERR0/*Functioncallwassuccessful*/
33. #defineCOMM_BAD_CH1/*Invalidcommunicationsportchannel*/
34. #defineCOMM_RX_EMPTY2/*Rxbufferisempty,nocharacteravailable*/
35. #defineCOMM_TX_FULL3/*Txbufferisfull,couldnotdepositcharacter*/
36. #defineCOMM_TX_EMPTY4/*IftheTxbufferisempty.*/
37. #defineCOMM_RX_TIMEOUT5/*Ifatimeoutoccurredwhilewaitingforacharacter*/
38. #defineCOMM_TX_TIMEOUT6/*Ifatimeoutoccurredwhilewaitingtosendachar.*/
41. #defineCOMM_PARITY_NONE0/*Definesforsettingparity*/
42. #defineCOMM_PARITY_ODD1
43. #defineCOMM_PARITY_EVEN2
45. unsignedcharCommGetChar(unsignedcharch,unsignedshortto,unsignedchar*err);
46. voidCOMInit(void);
47. unsignedcharCommIsEmpty(unsignedcharch);
48. unsignedcharCommIsFull(unsignedcharch);
49. unsignedcharCommPutChar(unsignedcharch,unsignedcharc,unsignedshortto);
50. voidCommPutStr(unsignedcharch,uint8_t*str);
52. #endif

commrtos.c 的代码如下：

1. #include"stm32f10x_usart.h"
2. #include"includes.h"
3. #include"COMMRTOS.H"
5. /*
6. *DATATYPES
7. */
8. typedefstruct{
9. unsignedshortRingBufRxCtr;/*NumberofcharactersintheRxringbuffer*/
10. OS_EVENT*RingBufRxSem;/*PointertoRxsemaphore*/
11. unsignedchar*RingBufRxInPtr;/*Pointertowherenextcharacterwillbeinserted*/
12. unsignedchar*RingBufRxOutPtr;/*Pointerfromwherenextcharacterwillbeextracted*/
13. unsignedcharRingBufRx[COMM_RX_BUF_SIZE];/*Ringbuffercharacterstorage(Rx)*/
14. unsignedshortRingBufTxCtr;/*NumberofcharactersintheTxringbuffer*/
15. OS_EVENT*RingBufTxSem;/*PointertoTxsemaphore*/
16. unsignedchar*RingBufTxInPtr;/*Pointertowherenextcharacterwillbeinserted*/
17. unsignedchar*RingBufTxOutPtr;/*Pointerfromwherenextcharacterwillbeextracted*/
18. unsignedcharRingBufTx[COMM_TX_BUF_SIZE];/*Ringbuffercharacterstorage(Tx)*/
19. }COMM_RING_BUF;
21. /*
22. *GLOBALVARIABLES
23. */
24. COMM_RING_BUFComm1Buf;
25. COMM_RING_BUFComm2Buf;
27. staticvoidCOMEnableTxInt(unsignedcharport)
28. {
29. staticUSART_TypeDef*map[2]={USART1,USART2};
30. //USART_ITConfig(map[port],USART_IT_TXE,ENABLE);
31. map[port]->CR1|=USART_FLAG_TXE;
32. }
34. /*
35. *********************************************************************************************************
36. *REMOVECHARACTERFROMRINGBUFFER
37. *
38. *
39. *Description:Thisfunctioniscalledbyyourapplicationtoobtainacharacterfromthecommunications
40. *channel.Thefunctionwillwaitforacharactertobereceivedontheserialchannelor
41. *untilthefunctiontimesout.
42. *Arguments:chistheCOMMportchannelnumberandcaneitherbe:
43. *COMM1
44. *COMM2
45. *toistheamountoftime(inclockticks)thatthecallingfunctioniswillingto
46. *waitforacharactertoarrive.Ifyouspecifyatimeoutof0,thefunctionwill
47. *waitforeverforacharactertoarrive.
48. *errisapointertowhereanerrorcodewillbeplaced:
49. **errissettoCOMM_NO_ERRifacharacterhasbeenreceived
50. **errissettoCOMM_RX_TIMEOUTifatimeoutoccurred
51. **errissettoCOMM_BAD_CHifyouspecifyaninvalidchannelnumber
52. *Returns:Thecharacterinthebuffer(orNULifatimeoutoccurred)
53. *********************************************************************************************************
54. */
56. unsignedcharCommGetChar(unsignedcharch,unsignedshortto,unsignedchar*err)
57. {
58. unsignedcharc;
59. unsignedcharoserr;
60. COMM_RING_BUF*pbuf;
61. OS_CPU_SRcpu_sr;
63. switch(ch)
64. {/*Obtainpointertocommunicationschannel*/
65. caseCOM1:
66. pbuf=&Comm1Buf;
67. break;
69. caseCOM2:
70. pbuf=&Comm2Buf;
71. break;
73. default:
74. *err=COMM_BAD_CH;
75. return(NUL);
76. }
77. OSSemPend(pbuf->RingBufRxSem,to,&oserr);/*Waitforcharactertoarrive*/
78. if(oserr==OS_TIMEOUT)
79. {/*Seeifcharactersreceivedwithintimeout*/
80. *err=COMM_RX_TIMEOUT;/*No,returnerrorcode*/
81. return(NUL);
82. }
83. else
84. {
85. OS_ENTER_CRITICAL();
86. pbuf->RingBufRxCtr--;/*Yes,decrementcharactercount*/
87. c=*pbuf->RingBufRxOutPtr++;/*Getcharacterfrombuffer*/
88. if(pbuf->RingBufRxOutPtr==&pbuf->RingBufRx[COMM_RX_BUF_SIZE])
89. {/*WrapOUTpointer*/
90. pbuf->RingBufRxOutPtr=&pbuf->RingBufRx[0];
91. }
92. OS_EXIT_CRITICAL();
93. *err=COMM_NO_ERR;
94. return(c);
95. }
96. }
98. voidCommPutStr(unsignedcharch,uint8_t*str)
99. {
100. while(0!=*str)
101. {
102. CommPutChar(ch,*str,0);
103. str++;
104. }
105. }
106. staticunsignedcharCOMGetTxChar(unsignedcharch,unsignedchar*err)
107. {
108. unsignedcharc;
109. COMM_RING_BUF*pbuf;
111. switch(ch)
112. {/*Obtainpointertocommunicationschannel*/
113. caseCOM1:
114. pbuf=&Comm1Buf;
115. break;
117. caseCOM2:
118. pbuf=&Comm2Buf;
119. break;
121. default:
122. *err=COMM_BAD_CH;
123. return(NUL);
124. }
125. if(pbuf->RingBufTxCtr>0)
126. {/*Seeifbufferisempty*/
127. pbuf->RingBufTxCtr--;/*No,decrementcharactercount*/
128. c=*pbuf->RingBufTxOutPtr++;/*Getcharacterfrombuffer*/
129. if(pbuf->RingBufTxOutPtr==&pbuf->RingBufTx[COMM_TX_BUF_SIZE])
130. {/*WrapOUTpointer*/
131. pbuf->RingBufTxOutPtr=&pbuf->RingBufTx[0];
132. }
133. OSSemPost(pbuf->RingBufTxSem);/*Indicatethatcharacterwillbesent*/
134. *err=COMM_NO_ERR;
135. return(c);/*Charactersarestillavailable*/
136. }
137. else
138. {
139. *err=COMM_TX_EMPTY;
140. return(NUL);/*Bufferisempty*/
141. }
142. }
144. /*
145. *********************************************************************************************************
146. *INITIALIZECOMMUNICATIONSMODULE
147. *Description:Thisfunctioniscalledbyyourapplicationtoinitializethecommunicationsmodule.You
148. *mustcallthisfunctionbeforecallinganyotherfunctions.
149. *Arguments:none
150. *********************************************************************************************************
151. */
153. voidCOMInit(void)
154. {
155. COMM_RING_BUF*pbuf;
157. pbuf=&Comm1Buf;/*InitializetheringbufferforCOMM1*/
158. pbuf->RingBufRxCtr=0;
159. pbuf->RingBufRxInPtr=&pbuf->RingBufRx[0];
160. pbuf->RingBufRxOutPtr=&pbuf->RingBufRx[0];
161. pbuf->RingBufRxSem=OSSemCreate(0);
162. pbuf->RingBufTxCtr=0;
163. pbuf->RingBufTxInPtr=&pbuf->RingBufTx[0];
164. pbuf->RingBufTxOutPtr=&pbuf->RingBufTx[0];
165. pbuf->RingBufTxSem=OSSemCreate(COMM_TX_BUF_SIZE);
167. pbuf=&Comm2Buf;/*InitializetheringbufferforCOMM2*/
168. pbuf->RingBufRxCtr=0;
169. pbuf->RingBufRxInPtr=&pbuf->RingBufRx[0];
170. pbuf->RingBufRxOutPtr=&pbuf->RingBufRx[0];
171. pbuf->RingBufRxSem=OSSemCreate(0);
172. pbuf->RingBufTxCtr=0;
173. pbuf->RingBufTxInPtr=&pbuf->RingBufTx[0];
174. pbuf->RingBufTxOutPtr=&pbuf->RingBufTx[0];
175. pbuf->RingBufTxSem=OSSemCreate(COMM_TX_BUF_SIZE);
176. }
178. /*
179. *********************************************************************************************************
180. *SEEIFRXCHARACTERBUFFERISEMPTY
181. *
182. *
183. *Description:Thisfunctioniscalledbyyourapplicationtoseeifanycharacterisavailablefromthe
184. *communicationschannel.Ifatleastonecharacterisavailable,thefunctionreturns
185. *FALSEotherwise,thefunctionreturnsTRUE.
186. *Arguments:chistheCOMMportchannelnumberandcaneitherbe:
187. *COMM1
188. *COMM2
189. *Returns:TRUEifthebufferISempty.
190. *FALSEifthebufferISNOTemptyoryouhavespecifiedanincorrectchannel.
191. *********************************************************************************************************
192. */
194. unsignedcharCommIsEmpty(unsignedcharch)
195. {
196. unsignedcharempty;
197. COMM_RING_BUF*pbuf;
198. OS_CPU_SRcpu_sr;
200. switch(ch)
201. {/*Obtainpointertocommunicationschannel*/
202. caseCOM1:
203. pbuf=&Comm1Buf;
204. break;
206. caseCOM2:
207. pbuf=&Comm2Buf;
208. break;
210. default:
211. return(TRUE);
212. }
213. OS_ENTER_CRITICAL();
214. if(pbuf->RingBufRxCtr>0)
215. {/*Seeifbufferisempty*/
216. empty=FALSE;/*BufferisNOTempty*/
217. }
218. else
219. {
220. empty=TRUE;/*Bufferisempty*/
221. }
222. OS_EXIT_CRITICAL();
223. return(empty);
224. }
227. /*
228. *********************************************************************************************************
229. *SEEIFTXCHARACTERBUFFERISFULL
230. *Description:Thisfunctioniscalledbyyourapplicationtoseeifanymorecharacterscanbeplaced
231. *intheTxbuffer.Inotherwords,thisfunctionchecktoseeiftheTxbufferisfull.
232. *Ifthebufferisfull,thefunctionreturnsTRUEotherwise,thefunctionreturnsFALSE.
233. *Arguments:chistheCOMMportchannelnumberandcaneitherbe:
234. *COMM1
235. *COMM2
236. *Returns:TRUEifthebufferISfull.
237. *FALSEifthebufferISNOTfulloryouhavespecifiedanincorrectchannel.
238. *********************************************************************************************************
239. */
241. unsignedcharCommIsFull(unsignedcharch)
242. {
243. unsignedcharfull;
244. COMM_RING_BUF*pbuf;
245. OS_CPU_SRcpu_sr;
247. switch(ch)
248. {/*Obtainpointertocommunicationschannel*/
249. caseCOM1:
250. pbuf=&Comm1Buf;
251. break;
253. caseCOM2:
254. pbuf=&Comm2Buf;
255. break;
257. default:
258. return(TRUE);
259. }
260. OS_ENTER_CRITICAL();
261. if(pbuf->RingBufTxCtr
262. {/*Seeifbufferisfull*/
263. full=FALSE;/*BufferisNOTfull*/
264. }
265. else
266. {
267. full=TRUE;/*Bufferisfull*/
268. }
269. OS_EXIT_CRITICAL();
270. return(full);
271. }
273. /*
274. *********************************************************************************************************
275. *OUTPUTCHARACTER
276. *
277. *
278. *Description:Thisfunctioniscalledbyyourapplicationtosendacharacteronthecommunications
279. *channel.Thefunctionwillwaitforthebuffertoemptyoutifthebufferisfull.
280. *Thefunctionreturnstoyourapplicationifthebufferdoesntemptywithinthespecified
281. *timeout.Atimeoutvalueof0meansthatthecallingfunctionwillwaitforeverforthe
282. *buffertoemptyout.ThecharactertosendisfirstinsertedintotheTxbufferandwill
283. *besentbytheTxISR.Ifthisisthefirstcharacterplacedintothebuffer,theTxISR
284. *willbeenabled.
285. *Arguments:chistheCOMMportchannelnumberandcaneitherbe:
286. *COMM1
287. *COMM2
288. *cisthecharactertosend.
289. *toisthetimeout(inclockticks)towaitincasethebufferisfull.Ifyou
290. *specifyatimeoutof0,thefunctionwillwaitforeverforthebuffertoempty.
291. *Returns:COMM_NO_ERRifthecharacterwasplacedintheTxbuffer
292. *COMM_TX_TIMEOUTifthebufferdidntemptywithinthespecifiedtimeoutperiod
293. *COMM_BAD_CHifyouspecifyaninvalidchannelnumber
294. *********************************************************************************************************
295. */
297. unsignedcharCommPutChar(unsignedcharch,unsignedcharc,unsignedshortto)
298. {
299. unsignedcharoserr;
300. COMM_RING_BUF*pbuf;
301. OS_CPU_SRcpu_sr;
303. switch(ch)
304. {/*Obtainpointertocommunicationschannel*/
305. caseCOM1:
306. pbuf=&Comm1Buf;
307. break;
309. caseCOM2:
310. pbuf=&Comm2Buf;
311. break;
313. default:
314. return(COMM_BAD_CH);
315. }
316. OSSemPend(pbuf->RingBufTxSem,to,&oserr);/*WaitforspaceinTxbuffer*/
317. if(oserr==OS_TIMEOUT)
318. {
319. return(COMM_TX_TIMEOUT);/*Timedout,returnerrorcode*/
320. }
321. OS_ENTER_CRITICAL();
322. pbuf->RingBufTxCtr++;/*No,incrementcharactercount*/
323. *pbuf->RingBufTxInPtr++=c;/*Putcharacterintobuffer*/
324. if(pbuf->RingBufTxInPtr==&pbuf->RingBufTx[COMM_TX_BUF_SIZE])
325. {/*WrapINpointer*/
326. pbuf->RingBufTxInPtr=&pbuf->RingBufTx[0];
327. }
328. if(pbuf->RingBufTxCtr==1)
329. {/*Seeifthisisthefirstcharacter*/
330. COMEnableTxInt(ch);/*Yes,EnableTxinterrupts*/
331. }
332. OS_EXIT_CRITICAL();
333. return(COMM_NO_ERR);
334. }
337. /*
338. *********************************************************************************************************
339. *INSERTCHARACTERINTORINGBUFFER
340. *
341. *
342. *Description:ThisfunctioniscalledbytheRxISRtoinsertacharacterintothereceiveringbuffer.
343. *Arguments:chistheCOMMportchannelnumberandcaneitherbe:
344. *COMM1
345. *COMM2
346. *cisthecharactertoinsertintotheringbuffer.Ifthebufferisfull,the
347. *characterwillnotbeinserted,itwillbelost.
348. *********************************************************************************************************
349. */
350. staticvoidCOMPutRxChar(unsignedcharch,unsignedcharc)
351. {
352. COMM_RING_BUF*pbuf;
355. switch(ch)
356. {/*Obtainpointertocommunicationschannel*/
357. caseCOM1:
358. pbuf=&Comm1Buf;
359. break;
361. caseCOM2:
362. pbuf=&Comm2Buf;
363. break;
365. default:
366. return;
367. }
368. if(pbuf->RingBufRxCtr
369. {/*Seeifbufferisfull*/
370. pbuf->RingBufRxCtr++;/*No,incrementcharactercount*/
371. *pbuf->RingBufRxInPtr++=c;/*Putcharacterintobuffer*/
372. if(pbuf->RingBufRxInPtr==&pbuf->RingBufRx[COMM_RX_BUF_SIZE])
373. {/*WrapINpointer*/
374. pbuf->RingBufRxInPtr=&pbuf->RingBufRx[0];
375. }
376. OSSemPost(pbuf->RingBufRxSem);/*Indicatethatcharacterwasreceived*/
377. }
378. }
379. //ThisfunctioniscalledbytheRxISRtoinsertacharacterintothereceiveringbuffer.
382. voidUSART1_IRQHandler(void)
383. {
384. unsignedintdata;
385. unsignedcharerr;
386. OS_CPU_SRcpu_sr;
388. OS_ENTER_CRITICAL();/*TelluC/OS-IIthatwearestartinganISR*/
389. OSIntNesting++;
390. OS_EXIT_CRITICAL();
392. if(USART1->SR&0x0F)
393. {
394. //Seeifwehavesomekindoferror
395. //Clearinterrupt(donothingaboutit!)
396. data=USART1->DR;
397. }
398. elseif(USART1->SR&USART_FLAG_RXNE)//ReceiveDataRegFullFlag
399. {
400. data=USART1->DR;
401. COMPutRxChar(COM1,data);//Insertreceivedcharacterintobuffer
402. }
403. elseif(USART1->SR&USART_FLAG_TXE)
404. {
405. data=COMGetTxChar(COM1,&err);//Getnextcharactertosend.
406. if(err==COMM_TX_EMPTY)
407. {//Dowehaveanymorecharacterstosend?
408. //No,DisableTxinterrupts
409. //USART_ITConfig(USART1,USART_IT_TXE|USART_IT_TC,DISABLE);
410. USART1->CR1&=~USART_FLAG_TXE|USART_FLAG_TC;
411. }
412. else
413. {
414. USART1->DR=data;//Yes,Sendcharacter
415. }
416. }
417. OSIntExit();
418. }
420. voidUSART2_IRQHandler(void)
421. {
422. unsignedintdata;
423. unsignedcharerr;
424. OS_CPU_SRcpu_sr;
426. OS_ENTER_CRITICAL();/*TelluC/OS-IIthatwearestartinganISR*/
427. OSIntNesting++;
428. OS_EXIT_CRITICAL();
430. if(USART2->SR&0x0F)
431. {
432. //Seeifwehavesomekindoferror
433. //Clearinterrupt(donothingaboutit!)
434. data=USART2->DR;
435. }
436. elseif(USART2->SR&USART_FLAG_RXNE)//ReceiveDataRegFullFlag
437. {
438. data=USART2->DR;
439. COMPutRxChar(COM2,data);//Insertreceivedcharacterintobuffer
440. }
441. elseif(USART2->SR&USART_FLAG_TXE)
442. {
443. data=COMGetTxChar(COM2,&err);//Getnextcharactertosend.
444. if(err==COMM_TX_EMPTY)
445. {//Dowehaveanymorecharacterstosend?
446. //No,DisableTxinterrupts
447. //USART_ITConfig(USART2,USART_IT_TXE|USART_IT_TC,DISABLE);
448. USART2->CR1&=~USART_FLAG_TXE|USART_FLAG_TC;
449. }
450. else
451. {
452. USART2->DR=data;//Yes,Sendcharacter
453. }
454. }
455. OSIntExit();
456. }

下面再给出个测试代码：

1. #include"stm32f10x.h"
2. #include"uart.h"
3. #include"led.h"
4. #include"COMMRTOS.H"
5. #include"ucos_ii.h"
7. #defineTASK_STK_SIZE128
8. OS_STKTaskStartStk[TASK_STK_SIZE];
9. OS_STKTaskUartReadStk[TASK_STK_SIZE];
11. voidTaskUartRead(void*pdata)
12. {
13. unsignedcharerr;
14. unsignedcharc;
16. for(;;)
17. {
18. c=CommGetChar(COM2,0,&err);
19. if(err==COMM_NO_ERR)
20. CommPutChar(COM2,c,0);
21. }
22. }
23. voidTaskStart(void*pdata)
24. {
25. SysTick_Config(SystemCoreClock/10);
26. USART1_Init();
27. USART2_Init();
28. COMInit();
29. //USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
30. //USART_ITConfig(USART2,USART_IT_RXNE,ENABLE);
31. USART1->CR1|=USART_FLAG_RXNE;
32. USART2->CR1|=USART_FLAG_RXNE;
34. OSTaskCreate(TaskUartRead,(void*)0,&(TaskUartReadStk[TASK_STK_SIZE-1]),2);
36. UART_PutStr(USART2,"USART2HelloWorld!nr");
37. //CommPutChar(COM2,+,0);
38. CommPutStr(COM2,"CommPutCharBnr");
39. for(;;)
40. {
41. LED_Spark();
42. CommPutChar(COM2,+,0);
43. OSTimeDly(10);
44. }
45. }
47. intmain(void)
48. {
49. SystemInit();
50. LED_Init();
51. OSInit();
52. OSTaskCreate(TaskStart,(void*)0,&(TaskStartStk[TASK_STK_SIZE-1]),1);
53. OSStart();
54. for(;;)
55. {
57. }
58. }