stm32RS485串口通信——中断接收发送数据

功能：通过PC机的串口调试助手发送数据给串口A，串口B接收到串口A发送的数据，再由串口B将接收到的数据返回给PC机的串口调试助手。

PC->串口A->串口B->PC。

实验平台：stm32f407

/*********************************************************************

本平台具有六个串口：

com1  485

com2  

com3  232 需一个管脚控制DTU

com4 485

com5  调试串口  TTL

com6  485

*********************************************************************/

本实验用的的串口A对应为com1，串口B对应为com4。

本程序的设计思路：

通过PC机串口调试助手发送数据，当串口A发现有数据过来时，产生串口接收中断，把数据保存到自定义的接收缓冲区中，然后串口接收函数去缓冲区中去取数据保存在发送缓冲区中，再将数据通过串口B发送给串口调试助手。

代码：

multiple_serial.h

1. #ifndef multiple_serial_H
2. #define multiple_serial_H
3. #define MAX_RECV_BUF_LEN (64)
4. #define MAX_RECV_DATA_MASK (0x3f)
5. #define MAX_COM_COUNT (6)
7. typedef signed char int8_t;
8. typedef signed short intint16_t;
9. typedef signed int int32_t;
11. typedef unsigned char uint8_t;
12. typedef unsigned short intuint16_t;
13. typedef unsigned int uint32_t;
15. #define NEXTAI_COM1_NAME"COM1"
16. #define NEXTAI_COM2_NAME"COM2"
17. #define NEXTAI_COM3_NAME"COM3"
18. #define NEXTAI_COM4_NAME"COM4"
19. #define NEXTAI_COM5_NAME"COM5"
20. #define NEXTAI_COM6_NAME"COM6"
22. enum{
23. NEXTAI_COM1_ID=1,
24. NEXTAI_COM2_ID,
25. NEXTAI_COM3_ID,
26. NEXTAI_COM4_ID,
27. NEXTAI_COM5_ID,
28. NEXTAI_COM6_ID
29. };
31. typedef struct _NEXTAI_CHANNEL_INFO_
32. {
33. uint8_t local_com_id;
34. //nextai_uint8 *databuf;
35. //nextai_uint16 data_read_p;
36. //nextai_uint16 data_write_p;
38. uint8_t used_flag;
39. }NEXTAI_CHANNEL_INFO;
41. /*******************************************************************************
42. * local_channel_data : 通道数据结构
43. * data_recv_flag : 是否有数据flag，1表示
44. *******************************************************************************/
45. typedef struct _NEXTAI_MGR_INFO_
46. {
47. NEXTAI_CHANNEL_INFO local_channel_data[MAX_COM_COUNT];
48. uint8_t data_recv_flag;
49. }NEXTAI_MGR_INFO;
51. static NEXTAI_MGR_INFO* local_com_mgr_p=0;
52. void serial_nvic_Configuration(uint8_t comID);
53. static void serial_gpio_configuration(uint8_t comID);
54. static void serial_rcc_configuration(uint8_t comID);
55. uint8_t serial_Configuration(uint8_t*comName);
56. uint8_t serial_send(uint8_t comID,uint8_t*databuf,uint32_t datalen);
57. uint32_t serial_recv(uint8_t comID,uint8_t*databuf,uint32_t datalen);
58. void clean_rebuff(void);
59. #endif

multiple_serial.c

1. #include"multiple_serial.h"
2. #include"stm32f4xx_gpio.h"
3. #include"stm32f4xx_usart.h"
4. #include
6. unsigned char uart_buf[MAX_RECV_BUF_LEN]={0};
8. uint8_t com1_recv_buf[MAX_RECV_BUF_LEN]={0};
9. int com1_gloabl_p=0;
10. int com1_read_p=0;
12. uint8_t com4_recv_buf[MAX_RECV_BUF_LEN]={0};
13. int com4_gloabl_p=0;
14. int com4_read_p=0;
16. uint8_t com5_recv_buf[MAX_RECV_BUF_LEN]={0};
17. int com5_gloabl_p=0;
18. int com5_read_p=0;
20. uint8_t com6_recv_buf[MAX_RECV_BUF_LEN]={0};
21. int com6_gloabl_p=0;
22. int com6_read_p=0;
24. //串口gpio的配置
25. static void serial_gpio_configuration(uint8_t comID)
26. {
27. GPIO_InitTypeDef GPIO_InitStructure;
28. RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
29. RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
30. RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
31. RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOF, ENABLE);
33. /* Configure USART Tx and Rx as alternate function push-pull */
34. if(comID == NEXTAI_COM1_ID)
35. {
36. GPIO_StructInit(&GPIO_InitStructure);
38. GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_USART1);
39. GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_USART1);
41. GPIO_InitStructure.GPIO_Mode= GPIO_Mode_AF;
42. GPIO_InitStructure.GPIO_Speed= GPIO_Speed_100MHz;
43. GPIO_InitStructure.GPIO_OType= GPIO_OType_PP;
44. GPIO_InitStructure.GPIO_PuPd= GPIO_PuPd_UP;
46. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_9;
47. GPIO_Init(GPIOA,&GPIO_InitStructure);
49. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_10;
50. GPIO_InitStructure.GPIO_PuPd= GPIO_PuPd_UP;
51. GPIO_Init(GPIOA,&GPIO_InitStructure);
53. GPIO_StructInit(&GPIO_InitStructure);
54. GPIO_InitStructure.GPIO_Mode= GPIO_Mode_OUT;
55. GPIO_InitStructure.GPIO_Speed= GPIO_Speed_100MHz;
56. GPIO_InitStructure.GPIO_OType= GPIO_OType_PP;
57. GPIO_InitStructure.GPIO_PuPd= GPIO_PuPd_UP;
58. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_4;
60. GPIO_Init(GPIOF,&GPIO_InitStructure);
61. }
62. elseif(comID== NEXTAI_COM4_ID)
63. {
64. GPIO_StructInit(&GPIO_InitStructure);
66. GPIO_PinAFConfig(GPIOA, GPIO_PinSource0, GPIO_AF_UART4);
67. GPIO_PinAFConfig(GPIOA, GPIO_PinSource1, GPIO_AF_UART4);
69. GPIO_InitStructure.GPIO_Mode= GPIO_Mode_AF;
70. GPIO_InitStructure.GPIO_Speed= GPIO_Speed_50MHz;
71. GPIO_InitStructure.GPIO_OType= GPIO_OType_PP;
72. GPIO_InitStructure.GPIO_PuPd= GPIO_PuPd_UP;
74. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_1;
75. GPIO_Init(GPIOA,&GPIO_InitStructure);
77. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_0;
78. GPIO_InitStructure.GPIO_PuPd= GPIO_PuPd_UP;
79. GPIO_Init(GPIOA,&GPIO_InitStructure);
81. GPIO_StructInit(&GPIO_InitStructure);
82. GPIO_InitStructure.GPIO_Mode= GPIO_Mode_OUT;
83. GPIO_InitStructure.GPIO_Speed= GPIO_Speed_50MHz;
84. GPIO_InitStructure.GPIO_OType= GPIO_OType_PP;
85. GPIO_InitStructure.GPIO_PuPd= GPIO_PuPd_UP;
86. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_7;
88. GPIO_Init(GPIOA,&GPIO_InitStructure);
89. }
90. elseif(comID== NEXTAI_COM5_ID)
91. {
92. GPIO_StructInit(&GPIO_InitStructure);
94. GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_UART5);
95. GPIO_PinAFConfig(GPIOD, GPIO_PinSource2, GPIO_AF_UART5);
97. GPIO_InitStructure.GPIO_Mode= GPIO_Mode_AF;
98. GPIO_InitStructure.GPIO_Speed= GPIO_Speed_50MHz;
99. GPIO_InitStructure.GPIO_OType= GPIO_OType_PP;
100. GPIO_InitStructure.GPIO_PuPd= GPIO_PuPd_UP;
102. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_2;
103. GPIO_Init(GPIOD,&GPIO_InitStructure);
105. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_12;
106. GPIO_InitStructure.GPIO_PuPd= GPIO_PuPd_UP;
107. GPIO_Init(GPIOC,&GPIO_InitStructure);
108. }
109. elseif(comID== NEXTAI_COM6_ID)
110. {
111. GPIO_StructInit(&GPIO_InitStructure);
113. GPIO_PinAFConfig(GPIOC, GPIO_PinSource6, GPIO_AF_USART6);
114. GPIO_PinAFConfig(GPIOC, GPIO_PinSource7, GPIO_AF_USART6);
116. GPIO_InitStructure.GPIO_Mode= GPIO_Mode_AF;
117. GPIO_InitStructure.GPIO_Speed= GPIO_Speed_100MHz;
118. GPIO_InitStructure.GPIO_OType= GPIO_OType_PP;
119. GPIO_InitStructure.GPIO_PuPd= GPIO_PuPd_UP;
121. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_6;
122. GPIO_InitStructure.GPIO_PuPd= GPIO_PuPd_UP;
123. GPIO_Init(GPIOC,&GPIO_InitStructure);
125. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_7;
126. GPIO_InitStructure.GPIO_PuPd= GPIO_PuPd_UP;
127. GPIO_Init(GPIOC,&GPIO_InitStructure);
129. GPIO_StructInit(&GPIO_InitStructure);
130. GPIO_InitStructure.GPIO_Mode= GPIO_Mode_OUT;
131. GPIO_InitStructure.GPIO_Speed= GPIO_Speed_50MHz;
132. GPIO_InitStructure.GPIO_OType= GPIO_OType_PP;
133. GPIO_InitStructure.GPIO_PuPd= GPIO_PuPd_UP;
135. GPIO_InitStructure.GPIO_Pin= GPIO_Pin_8;
136. GPIO_Init(GPIOC,&GPIO_InitStructure);
137. }
138. }
140. //串口时钟的配置
141. static void serial_rcc_configuration(uint8_t comID)
142. {
143. /* Enable USART clock */
144. if(comID== NEXTAI_COM1_ID)
145. {
146. RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
147. }
148. elseif(comID== NEXTAI_COM4_ID)
149. {
150. RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4,ENABLE);
151. }
152. elseif(comID== NEXTAI_COM5_ID)
153. {
154. RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART5,ENABLE);
155. }
156. elseif(comID== NEXTAI_COM6_ID)
157. {
158. RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART6, ENABLE);
159. }
160. }
162. //配置各个串口的中断处理函数，优先级相同
163. void serial_nvic_Configuration(uint8_t comID)
164. {
165. NVIC_InitTypeDef NVIC_InitStructure;
166. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
168. if(comID== NEXTAI_COM1_ID)
169. {
170. NVIC_InitStructure.NVIC_IRQChannel= USART1_IRQn;
171. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;
172. NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
173. NVIC_InitStructure.NVIC_IRQChannelCmd= ENABLE;
174. NVIC_Init(&NVIC_InitStructure);
175. }
176. elseif(comID== NEXTAI_COM4_ID)
177. {
178. NVIC_InitStructure.NVIC_IRQChannel= UART4_IRQn;
179. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;
180. NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
181. NVIC_InitStructure.NVIC_IRQChannelCmd= ENABLE;
182. NVIC_Init(&NVIC_InitStructure);
183. }
184. elseif(comID== NEXTAI_COM5_ID)
185. {
186. NVIC_InitStructure.NVIC_IRQChannel= UART5_IRQn;
187. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;
188. NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
189. NVIC_InitStructure.NVIC_IRQChannelCmd= ENABLE;
190. NVIC_Init(&NVIC_InitStructure);
191. }
192. elseif(comID== NEXTAI_COM6_ID)
193. {
194. NVIC_InitStructure.NVIC_IRQChannel= USART6_IRQn;
195. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1;
196. NVIC_InitStructure.NVIC_IRQChannelSubPriority=1;
197. NVIC_InitStructure.NVIC_IRQChannelCmd= ENABLE;
198. NVIC_Init(&NVIC_InitStructure);
199. }
200. }
203. /*串口参数配置*/
204. uint8_t serial_Configuration(uint8_t*comName)
205. {
206. USART_InitTypeDef USART_InitStructure;
207. uint8_t comID =0;
209. if(strcmp(NEXTAI_COM1_NAME,(constchar*)comName)==0)
210. {
211. comID= NEXTAI_COM1_ID;
212. }
213. elseif(strcmp(NEXTAI_COM4_NAME,(constchar*)comName)==0)
214. {
215. comID= NEXTAI_COM4_ID;
216. }
217. elseif(strcmp(NEXTAI_COM5_NAME,(constchar*)comName)==0)
218. {
219. comID= NEXTAI_COM5_ID;
220. }
221. elseif(strcmp(NEXTAI_COM6_NAME,(constchar*)comName)==0)
222. {
223. comID= NEXTAI_COM6_ID;
224. }
226. /* System Clocks Configuration */
227. serial_rcc_configuration(comID);
229. /* Configure the GPIO ports */
230. serial_gpio_configuration(comID);
232. USART_InitStructure.USART_WordLength= USART_WordLength_8b;
233. USART_InitStructure.USART_Parity= USART_Parity_No;
234. USART_InitStructure.USART_HardwareFlowControl= USART_HardwareFlowControl_None;
235. USART_InitStructure.USART_Mode= USART_Mode_Rx| USART_Mode_Tx;
237. if(comID== NEXTAI_COM1_ID)
238. {
239. USART_InitStructure.USART_BaudRate=9600;
240. USART_InitStructure.USART_StopBits= USART_StopBits_1;
241. USART_Init(USART1,&USART_InitStructure);
242. }
243. elseif(comID== NEXTAI_COM4_ID)
244. {
245. USART_InitStructure.USART_BaudRate=38400;
246. USART_InitStructure.USART_StopBits= USART_StopBits_1;
247. USART_Init(UART4,&USART_InitStructure);
248. }
249. elseif(comID== NEXTAI_COM5_ID)
250. {
251. USART_InitStructure.USART_BaudRate=115200;
252. USART_InitStructure.USART_StopBits= USART_StopBits_1;
253. USART_Init(UART5,&USART_InitStructure);
254. }
255. elseif(comID== NEXTAI_COM6_ID)
256. {
257. USART_InitStructure.USART_BaudRate=9600;
258. USART_InitStructure.USART_StopBits= USART_StopBits_1;
259. USART_Init(USART6,&USART_InitStructure);
260. }
262. serial_nvic_Configuration(comID);
264. if(comID== NEXTAI_COM1_ID)
265. {
266. USART_Cmd(USART1, ENABLE);
267. USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
268. }
269. elseif(comID== NEXTAI_COM4_ID)
270. {
271. USART_Cmd(UART4, ENABLE);
272. USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);
273. }
274. elseif(comID== NEXTAI_COM5_ID)
275. {
276. USART_Cmd(UART5, ENABLE);
277. USART_ITConfig(UART5, USART_IT_RXNE, ENABLE);
278. }
279. elseif(comID== NEXTAI_COM6_ID)
280. {
281. USART_Cmd(USART6, ENABLE);
282. USART_ITConfig(USART6, USART_IT_RXNE, ENABLE);
283. }
285. return comID;
286. }
288. /*******************************************************************************
289. * 函数名 : serial_send
290. * 描 述 : 发送某个端口的数据
291. * 输 入 : comID: 串口标识号
292. databuf: 发送数据缓冲区
293. datalen: 发送数据长度
294. * 输 出 : None
295. * 返 回 : None
296. *******************************************************************************/
297. uint8_t serial_send(uint8_t comID,uint8_t*databuf,uint32_t datalen)
298. {
299. int i =0;
300. uint8_t nextai_timer =0;
302. if(comID== NEXTAI_COM1_ID)
303. {
304. GPIO_SetBits(GPIOF, GPIO_Pin_4);
306. //清除标志位，否则第1位数据会丢失
307. USART_GetFlagStatus(USART1, USART_FLAG_TC);
309. for(i=0; i< datalen; i++)
310. {
311. //485 需添加超时检测
312. USART_SendData(USART1,databuf[i]);
314. while(USART_GetFlagStatus(USART1, USART_FLAG_TC)== RESET)
315. {
316. nextai_timer++;
317. if(nextai_timer>>8)
318. return0;
319. }
320. }
321. GPIO_ResetBits(GPIOF, GPIO_Pin_4);
322. }
323. elseif(comID== NEXTAI_COM4_ID)
324. {
325. GPIO_SetBits(GPIOA, GPIO_Pin_7);
327. //清除标志位，否则第1位数据会丢失
328. USART_GetFlagStatus(UART4, USART_FLAG_TC);
330. for(i=0; i< datalen; i++)
331. {
332. //485
333. USART_SendData(UART4,databuf[i]);

334. while(USART_GetFlagStatus(UART4, USART_FLAG_TC)== RESET)
335. {
336. nextai_timer++;
337. if(nextai_timer>>8)
338. return0;
339. }
340. }
341. GPIO_ResetBits(GPIOA, GPIO_Pin_7);
342. }
343. elseif(comID== NEXTAI_COM5_ID)
344. {
345. //清除标志位，否则第1位数据会丢失
346. USART_GetFlagStatus(UART5,USART_FLAG_TC);
347. for(i=0; i< datalen; i++)
348. {
349. while(USART_GetFlagStatus(UART5, USART_FLAG_TC)== RESET);
350. USART_SendData(UART5,databuf[i]);
351. while(USART_GetFlagStatus(UART5, USART_FLAG_TC)== RESET)
352. {
353. nextai_timer++;
354. if(nextai_timer>>8)
355. return0;
356. }
357. }
358. }
359. elseif(comID== NEXTAI_COM6_ID)
360. {
361. GPIO_SetBits(GPIOC, GPIO_Pin_8);
363. //清除标志位，否则第1位数据会丢失
364. USART_GetFlagStatus(USART6,USART_FLAG_TC);
365. for(i=0; i< datalen; i++)
366. {
367. //485
368. USART_SendData(USART6,databuf[i]);
369. while(USART_GetFlagStatus(USART6, USART_FLAG_TC)== RESET)
370. {
371. nextai_timer++;
372. if(nextai_timer>>8)
373. return0;
374. }
375. }
376. GPIO_ResetBits(GPIOC, GPIO_Pin_8);
377. }
379. return datalen;
380. }
382. /*******************************************************************************
383. * 函数名 : serial_recv
384. * 描 述 : 接收一定长度的数据（从内存中读取数据）
385. * 输 入 : comID: 串口标识号
386. databuf: 接收数据缓冲区
387. datalen: 需要接收数据长度
388. * 输 出 : None
389. * 返 回 : 实际接收到的数据长度
390. *******************************************************************************/
391. uint32_t serial_recv(uint8_t comID,uint8_t*databuf,uint32_t datalen)
392. {
393. uint16_t i =0, nextai_indx=0, j=0;
394. NEXTAI_MGR_INFO*me= local_com_mgr_p;
396. if((comID> NEXTAI_COM6_ID)||(comID< NEXTAI_COM1_ID))
397. return 0xffffffff;
398. nextai_indx= comID- NEXTAI_COM1_ID;
400. if(me->local_channel_data[nextai_indx].used_flag==0)
401. return 0xffffffff;
403. if(!(me->data_recv_flag&(1<< nextai_indx)))
404. return 0xffffffff;
406. if(comID== NEXTAI_COM1_ID)
407. {
408. i=0;
409. while(1)
410. {
411. if(com1_read_p== com1_gloabl_p)
412. break;
413. databuf[i]= com1_recv_buf[com1_read_p];
414. com1_read_p++;
415. com1_read_p&= MAX_RECV_DATA_MASK;
416. i++;
417. if(i>= datalen)
418. break;
419. for(j=0; j<100; j++);
420. }
421. me->data_recv_flag= me->data_recv_flag&(~(1<< nextai_indx));
422. }
424. if(comID== NEXTAI_COM4_ID)
425. {
426. i=0;
427. while(1)
428. {
429. if(com4_read_p== com4_gloabl_p)
430. break;
431. databuf[i]= com4_recv_buf[com4_read_p];
432. com4_read_p++;
433. com4_read_p&= MAX_RECV_DATA_MASK;
434. i++;
435. if(i>= datalen)
436. break;
437. for(j=0; j<100; j++);
438. }
439. me->data_recv_flag= me->data_recv_flag&(~(1<< nextai_indx));
440. }
442. if(comID== NEXTAI_COM5_ID)
443. {
444. i=0;
445. while(1)
446. {
447. if(com5_read_p== com5_gloabl_p)
448. break;
449. databuf[i]= com5_recv_buf[com5_read_p];
450. com5_read_p++;
451. com5_read_p&= MAX_RECV_DATA_MASK;
452. i++;
453. if(i>= datalen)
454. break;
455. for(j=0; j<100; j++);
456. }
457. me->data_recv_flag= me->data_recv_flag&(~(1<< nextai_indx));
458. }
460. if(comID== NEXTAI_COM6_ID)
461. {
462. i=0;
463. while(1)
464. {
465. if(com6_read_p== com6_gloabl_p)
466. break;
467. databuf[i]= com6_recv_buf[com6_read_p];
468. com6_read_p++;
469. com6_read_p&= MAX_RECV_DATA_MASK;
470. i++;
471. if(i>= datalen)
472. break;
473. for(j=0; j<100; j++);
474. }
475. me->data_recv_flag= me->data_recv_flag&(~(1<< nextai_indx));
476. }
478. return i;
479. }
481. //中断处理函数只是将发送过来的数据保存到内存
482. void USART1_IRQHandler(void)
483. {
484. NEXTAI_MGR_INFO*me= local_com_mgr_p;
486. if(USART_GetITStatus(USART1, USART_IT_RXNE)!= RESET)
487. {
488. USART_ClearITPendingBit(USART1,USART_IT_RXNE);
489. com1_recv_buf[com1_gloabl_p]= USART_ReceiveData(USART1);
490. com1_gloabl_p++;
491. com1_gloabl_p&= MAX_RECV_DATA_MASK;
492. }
494. me->data_recv_flag|=0x01;
495. }
496. 
     
497. //void UART5_IRQHandler(void)
498. //{
499. // uint8_t temp;
500. // if(USART_GetITStatus(UART5, USART_IT_RXNE)!= RESET)
501. // {
502. // temp= USART_ReceiveData(UART5);
503. // USART_SendData(UART5,temp);
504. // }
505. //}
507. void UART4_IRQHandler(void)
508. {
509. NEXTAI_MGR_INFO*me= local_com_mgr_p;
511. if(USART_GetITStatus(UART4, USART_IT_RXNE)!= RESET)
512. {
513. com4_recv_buf[com4_gloabl_p++]= USART_ReceiveData(UART4);
514. com4_gloabl_p&= MAX_RECV_DATA_MASK;
515. }
517. me->data_recv_flag|=0x08;
518. }
520. void UART5_IRQHandler(void)
521. {
522. NEXTAI_MGR_INFO *me = local_com_mgr_p;
524. if(USART_GetITStatus(UART5, USART_IT_RXNE) != RESET)
525. {
526. com5_recv_buf[com5_gloabl_p++] = USART_ReceiveData(UART5);
527. com5_gloabl_p &= MAX_RECV_DATA_MASK;
528. }
530. me->data_recv_flag |= 0x10;
531. }
533. void USART6_IRQHandler(void)
534. {
535. NEXTAI_MGR_INFO*me= local_com_mgr_p;
537. if(USART_GetITStatus(USART6, USART_IT_RXNE)!= RESET)
538. {
539. com6_recv_buf[com6_gloabl_p++]= USART_ReceiveData(USART6);
540. com6_gloabl_p&= MAX_RECV_DATA_MASK;
541. }
543. me->data_recv_flag|=0x20;
544. }

main.c

1. #include"multiple_serial.h"
2. #include"stm32f4xx_gpio.h"
3. #include"stm32f4xx_usart.h"
4. #include
5. #include
7. int main()
8. {
9. char*COM1="COM1";
10. char*COM4="COM4";
12. serial_Configuration((uint8_t*)COM1);
13. serial_Configuration((uint8_t*)COM4);
14. 
    
15. extern unsigned char uart_buf[64];
16. 
    
17. int i=0,j;
19. unsigned char printf_buf[128]={0};
21. uint8_t flag=0;
23. while(1)
24. {
25. flag= serial_recv(1, uart_buf,64);
26. //延时让serial_recv函数接收完PC机串口调试助手发来的全部数据
27. for(i=10000;i!=0;i--)
28. for(j=3000;j!=0;j--);
30. if(flag>0)
31. {
32. sprintf((char*)printf_buf,"receive data len is %d\n", flag);//将字符串写入printf_buf中
33. serial_send(4, printf_buf, strlen((char*)printf_buf));//发送printf_buf中的内容到串口
34. 
    
35. serial_send(4, uart_buf, flag+1);
37. }
38. 
    
39.    }
41. return 0;
42. }

测试结果如下图所示：

刚才改了下程序：

main.c

1. #include"multiple_serial.h"
2. #include"stm32f4xx_gpio.h"
3. #include"stm32f4xx_usart.h"
4. #include
5. #include
7. int main()
8. {
9. char*COM1="COM1";
10. char*COM4="COM4";
11. char*COM5="COM5";
12. char*COM6="COM6";
14. serial_Configuration((uint8_t*)COM1);
15. serial_Configuration((uint8_t*)COM6);
16. extern unsigned char uart_buf[64];
17.         int i=0,j;
18. unsigned char printf_buf[128]={0};
19.         uint8_t flag=0;
21. while(1)
22. {
23. //从串口调试助手发送数据，串口A接收到数据后产生中断，在中断函数中将数据保存到com6_recv_buf中，
24.      //然后通过serial_recv函数将数据从com6_recv_buf中保存到接收uart_buf中，最后调用serial_send回传给串口调试助手。
25. flag= serial_recv(1, uart_buf,64);
27. if(flag>0)
28. {
29. serial_send(4, uart_buf, flag+1);
30. }
31. }
33. return0;
34. }

测试结果如下图所示：

通过发送和接收的数据对比，发现程序设计的还是比较稳定的，没有出现数据丢失的现象。