串口收发数据

apleilx

串口收发数据

评估板自带了USB转串口，这个用起来方便多了，可以直接打印数据到电脑端。

下面上配置程序和收发处理。
用到资源UART2和TIMER6。准备之后连接modbus-RTU的所以占用一个定时器来判定接收报文结束

程序清单：
com_hal.h

1. #ifndef _COM_HAL_H_
   
2. #define        _COM_HAL_H_
   
3. 
   
4. #include "mytype.h"
   
5. #include "stdint.h"
   
6. 
   
7. #ifdef   _COM_HAL_MODULE_
   
8. #define  COM_EXT
   
9. #else
   
10. #define  COM_EXT  extern
    
11. #endif      
    
12. 
    
13. #define COM                       USART2
    
14. #define ComTIMER                  TIMER6
    
15. 
    
16. typedef enum {
    
17.     COM_RX_IDLE, //!< Receiver is in idle state.
    
18.     COM_RX_RCV, //!< Frame is beeing received.
    
19.     COM_RX_RCVEND, //!< Port Receive complete ,3.5T timer
    
20.     COM_RX_TIMEOUT //!< Time out ,Send a command and no data return after 500ms( --> system timer)
    
21. 
    
22. } ComRcvState_t;
    
23. 
    
24. typedef enum {
    
25.     COM_TX_IDLE, /*!< Transmitter is in idle state. */
    
26.     COM_TX_XMIT /*!< Transmitter is in transfer state. */
    
27. } ComSndState_t;
    
28. 
    
29. typedef enum {
    
30.     COM_PAR_NONE, /*!< No parity. */
    
31.     COM_PAR_ODD, /*!< Odd parity. */
    
32.     COM_PAR_EVEN /*!< Even parity. */
    
33. } ComParity_t;
    
34. 
    
35. typedef union {
    
36.     uint8_t St;
    
37. 
    
38.     struct {
    
39.         uint8_t PortSt : 1;
    
40.         uint8_t Connect : 1;
    
41.     } bits;
    
42. } COM_ST_Type;
    
43. 
    
44. #define COM_BUFF_SIZE             1024
    
45. 
    
46. COM_EXT uint8_t ComBuff[COM_BUFF_SIZE];
    
47. COM_EXT COM_ST_Type ComSt;
    
48. 
    
49. COM_EXT uint8_t *pComSndCur;
    
50. COM_EXT uint16_t ComSndCnt;
    
51. COM_EXT uint16_t ComRcvCnt;
    
52. 
    
53. COM_EXT volatile uint8_t ComErrSt;
    
54. COM_EXT volatile ComSndState_t ComSndSt;
    
55. COM_EXT volatile ComRcvState_t ComRcvSt;
    
56. 
    
57. void ComInit(uint32_t ulBaudRate, ComParity_t eParity);
    
58. void ComParity(ComParity_t eParity);
    
59. void ComStringSend(uint8_t * pData);
    
60. void ComDataSend(uint8_t * pData, uint16_t Len);
    
61. uint8_t ComStCheck(void); //端口空闲状态检查
    
62. 
    
63. #undef COM_EXT
    
64. 
    
65. #endif        /* _COM_HAL_H_ */
    

复制代码

com_hal.c

1. /* ------------------------------------------------------------------------*
   
2. *
   
3. * ------------------------------------------------------------------------*/
   
4. #include "osObjects.h"  
   
5. 
   
6. #define _COM_HAL_MODULE_
   
7. #include "com_hal.h"
   
8. #include "comtask.h"
   
9. 
   
10. //RS485 Dir-Pin
    
11. #define ComRxEnable()
    
12. #define ComTxEnable()
    
13. #define ComDE(x)  
    
14. 
    
15. 
    
16. static void ComEnable(uint8_t xRxEnable, uint8_t xTxEnable);
    
17. void ComTimerEnable(void);
    
18. void ComTimerDisable(void);
    
19. 
    
20. /*****************************************************************************//*!
    
21. * @brief UART2 TX interrupt routine.
    
22. * @brief   Uart interrupt.
    
23. *            
    
24. * @param   none
    
25. *
    
26. * @return  none
    
27. *
    
28. * @ Pass/ Fail criteria: none
    
29. *****************************************************************************/
    
30. 
    
31. void USART2_IRQHandler() {
    
32.     uint32_t IntSt;
    
33.     uint8_t Data;
    
34. 
    
35.     IntSt = USART_STAT0(USART2);
    
36. 
    
37.     if (IntSt & USART_STAT0_RBNE) {
    
38.         ComTimerEnable();
    
39. 
    
40.         Data = USART_DATA(USART2);
    
41. 
    
42.         if (COM_RX_RCVEND == ComRcvSt)
    
43.             return;
    
44. 
    
45.         if (ComRcvCnt > (COM_BUFF_SIZE - 1))
    
46.             return; //指针越界检查
    
47. 
    
48.         ComRcvSt = COM_RX_RCV; //指示正在接收数据
    
49. 
    
50.         if ((IntSt & USART_STAT0_ORERR) != 0) { //溢出 //只读，由硬件管理
    
51. 
    
52.         }
    
53. 
    
54. 
    
55.         if ((IntSt & (USART_STAT0_FERR | USART_STAT0_PERR)) != 0) { //帧错误 //只读，由硬件管理
    
56.             return;
    
57.         }
    
58. 
    
59.         if (ComRcvCnt < COM_BUFF_SIZE)
    
60.             ComBuff[ComRcvCnt++] = Data;
    
61.         else {
    
62.             //receive overflow
    
63.         }
    
64. 
    
65.     } else if (IntSt & USART_STAT0_TBE) {
    
66.         if ((0 == ComSndCnt) && (IntSt & USART_STAT0_TC)) {
    
67.             ComSndSt = COM_TX_IDLE; //发送结束
    
68.             ComEnable(ENABLE, DISABLE);
    
69.         } else if (ComSndCnt) {
    
70.             USART_DATA(COM) = *(pComSndCur++);
    
71.             ComSndCnt--;
    
72.             if (0 == ComSndCnt) //写缓冲区结束
    
73.             {
    
74.                 USART_CTL0(COM) &= ~(uint32_t) (USART_CTL0_TBEIE);
    
75.                 USART_CTL0(COM) |= (uint32_t) (USART_CTL0_TCIE);
    
76.             }
    
77.         } else {
    
78. 
    
79.         }
    
80.     }
    
81. }
    
82. 
    
83. /*****************************************************************************//*!
    
84. *
    
85. * @brief   com end timer.
    
86. *            
    
87. * @param   none
    
88. *
    
89. * @return  none
    
90. *
    
91. * @ Pass/ Fail criteria: none
    
92. *****************************************************************************/
    
93. 
    
94. void TIMER6_IRQHandler() {
    
95.     //关闭定时器
    
96.     ComTimerDisable();
    
97.     //清除更新中断标志
    
98.     TIMER_INTF(ComTIMER) &= ~((uint32_t) TIMER_INTF_UPIF);
    
99.     //
    
100.     if (COM_RX_RCV == ComRcvSt) {
     
101.         //端口接收结束，告诉数据处理单元可以处理数据
     
102.         ComRcvSt = COM_RX_RCVEND;
     
103. 
     
104.         /* Set bit 0 and bit 4 in xEventGroup. */
     
105.         xSemaphoreGiveFromISR(xSemCom, NULL);
     
106. 
     
107.     }
     
108. }
     
109. 
     
110. /*****************************************************************************//*!
     
111. *
     
112. * @brief   RTU timer enable.
     
113. *            
     
114. * @param   none
     
115. *
     
116. * @return  none
     
117. *
     
118. * @ Pass/ Fail criteria: none
     
119. *****************************************************************************/
     
120. 
     
121. void ComTimerEnable(void) {
     
122.     TIMER_CNT(ComTIMER) = 0;
     
123.     TIMER_CTL0(ComTIMER) |= ((uint32_t) TIMER_CTL0_CEN);
     
124. }
     
125. 
     
126. /*****************************************************************************//*!
     
127. *
     
128. * @brief   RTU timer disable.
     
129. *            
     
130. * @param   none
     
131. *
     
132. * @return  none
     
133. *
     
134. * @ Pass/ Fail criteria: none
     
135. *****************************************************************************/
     
136. 
     
137. void ComTimerDisable(void) {
     
138.     //停止计数
     
139.     TIMER_CTL0(ComTIMER) &= ~((uint32_t) TIMER_CTL0_CEN);
     
140. }
     
141. 
     
142. /*****************************************************************************//*!
     
143. *
     
144. * @brief   timer init.
     
145. *            
     
146. * @param   none
     
147. *
     
148. * @return  TURE
     
149. *
     
150. * @ Pass/ Fail criteria: none
     
151. *****************************************************************************/
     
152. 
     
153. uint8_t ComTimerInit(uint32_t ts50us) {
     
154.     uint32_t TimerClk;
     
155. 
     
156.     rcu_periph_clock_enable(RCU_TIMER6);
     
157.     rcu_periph_reset_enable(RCU_TIMER6RST);
     
158.     rcu_periph_reset_disable(RCU_TIMER6RST);
     
159. 
     
160.     TimerClk = rcu_clock_freq_get(CK_APB1);
     
161.     // 向上计数，仅溢出产生更新事件，单脉冲模式
     
162.     TIMER_CTL0(ComTIMER) = (uint32_t) (TIMER_CTL0_SPM | TIMER_CTL0_UPS);
     
163.     //预分频
     
164.     TIMER_PSC(ComTIMER) = TimerClk / 1000000 - 1;
     
165.     //装载值
     
166.     TIMER_CNT(ComTIMER) = 0;
     
167.     //周期
     
168.     TIMER_CAR(ComTIMER) = ts50us * 50 - 1; //auto reload value
     
169.     //禁止所有通道
     
170.     TIMER_CHCTL2(ComTIMER) = 0;
     
171.     //产生一次软件更新事件
     
172.     TIMER_SWEVG(ComTIMER) = TIMER_SWEVG_UPG; //update
     
173.     //清除更新中断标志
     
174.     TIMER_INTF(ComTIMER) &= ~((uint32_t) TIMER_INTF_UPIF);
     
175.     //更新事件产生中断
     
176.     TIMER_DMAINTEN(ComTIMER) = TIMER_DMAINTEN_UPIE;
     
177.     NVIC_SetPriority(TIMER6_IRQn, 0xFF);
     
178.     NVIC_ClearPendingIRQ(TIMER6_IRQn);
     
179.     NVIC_EnableIRQ(TIMER6_IRQn);
     
180. 
     
181.     return 1;
     
182. }
     
183. 
     
184. /*****************************************************************************//*!
     
185. * @brief           com modle init .
     
186. *               
     
187. * @param   none
     
188. *
     
189. * @return  none
     
190. *
     
191. * @ Pass/ Fail criteria: none
     
192. *****************************************************************************/
     
193. 
     
194. void ComInit(uint32_t ulBaudRate, ComParity_t eParity) {
     
195.     uint32_t usTimerT35_50us;
     
196. 
     
197.     // Enable USART APB clock
     
198.     rcu_periph_clock_enable(RCU_USART2);
     
199.     rcu_periph_reset_enable(RCU_USART2RST);
     
200.     rcu_periph_reset_disable(RCU_USART2RST);
     
201. 
     
202.     gpio_af_set(GPIOD, GPIO_AF_7, GPIO_PIN_8 | GPIO_PIN_9);
     
203.     gpio_mode_set(GPIOD, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_8);
     
204.     gpio_output_options_set(GPIOD, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_8);
     
205.     gpio_mode_set(GPIOD, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_9);
     
206.     gpio_output_options_set(GPIOD, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_9);
     
207. 
     
208.     usart_baudrate_set(COM, ulBaudRate);
     
209.     ComParity(eParity);
     
210. 
     
211.     //Timer init
     
212.     {
     
213.         if (ulBaudRate > 19200) {
     
214.             usTimerT35_50us = 35; /* 1800us. */
     
215.         } else {
     
216.             usTimerT35_50us = (7UL * 220000UL) / (2UL * ulBaudRate);
     
217.         }
     
218.         ComTimerInit(usTimerT35_50us);
     
219.     }
     
220. 
     
221.     ComSndSt = COM_TX_IDLE;
     
222.     ComRcvSt = COM_RX_IDLE;
     
223. 
     
224.     NVIC_SetPriority(USART2_IRQn, 0xFF);
     
225.     NVIC_ClearPendingIRQ(USART2_IRQn);
     
226.     NVIC_EnableIRQ(USART2_IRQn);
     
227. 
     
228.     ComEnable(ENABLE, DISABLE);
     
229. }
     
230. 
     
231. 
     
232. /*****************************************************************************//*!
     
233. * @brief           com parity set.
     
234. *               
     
235. * @param   none
     
236. *
     
237. * @return  none
     
238. *
     
239. * @ Pass/ Fail criteria: none
     
240. *****************************************************************************/
     
241. 
     
242. void ComParity(ComParity_t eParity) {
     
243.     USART_CTL0(COM) &= ~((uint32_t) USART_CTL0_UEN);
     
244.     switch (eParity) {
     
245.         case COM_PAR_NONE:
     
246.             USART_CTL0(COM) &= ~((uint32_t) (USART_CTL0_PCEN | USART_CTL0_PM | USART_CTL0_WL));
     
247.             USART_CTL1(COM) &= ~((uint32_t) USART_CTL1_STB);
     
248.             USART_CTL1(COM) |= (uint32_t) BIT(13);
     
249.             break;
     
250.         case COM_PAR_ODD:
     
251.             USART_CTL0(COM) &= ~((uint32_t) (USART_CTL0_PCEN | USART_CTL0_PM | USART_CTL0_WL));
     
252.             USART_CTL1(COM) &= ~((uint32_t) USART_CTL1_STB);
     
253.             USART_CTL0(COM) |= (uint32_t) (USART_CTL0_PCEN | USART_CTL0_PM | USART_CTL0_WL);
     
254.             break;
     
255.         case COM_PAR_EVEN:
     
256.             USART_CTL0(COM) &= ~((uint32_t) (USART_CTL0_PCEN | USART_CTL0_PM | USART_CTL0_WL));
     
257.             USART_CTL1(COM) &= ~((uint32_t) USART_CTL1_STB);
     
258.             USART_CTL0(COM) |= (uint32_t) (USART_CTL0_PCEN | USART_CTL0_WL);
     
259.             break;
     
260.         default:
     
261.             break;
     
262.     }
     
263.     USART_CTL0(COM) |= ((uint32_t) USART_CTL0_UEN);
     
264. }
     
265. 
     
266. /*****************************************************************************//*!
     
267. *
     
268. * @brief   Uart En or Dis.
     
269. *            
     
270. * @param   none
     
271. *
     
272. * @return  none
     
273. *
     
274. * @ Pass/ Fail criteria: none
     
275. *****************************************************************************/
     
276. 
     
277. static void ComEnable(uint8_t xRxEnable, uint8_t xTxEnable) {
     
278.     volatile uint8_t u8Temp;
     
279.     volatile uint32_t u32Temp;
     
280. 
     
281.     if (xRxEnable) {
     
282.         USART_CTL0(COM) &= ~((uint32_t) USART_CTL0_TCIE);
     
283.         USART_CTL0(COM) &= ~((uint32_t) USART_CTL0_TBEIE);
     
284. 
     
285.         ComRxEnable();
     
286. 
     
287.         USART_CTL0(COM) &= ~((uint32_t) USART_CTL0_TEN);
     
288.         USART_CTL0(COM) |= (uint32_t) USART_CTL0_REN;
     
289. 
     
290.         u8Temp = USART_DATA(COM);
     
291.         u32Temp = USART_STAT0(COM);
     
292.         while ((USART_STAT0(COM) & (USART_STAT0_RBNE | USART_STAT0_ORERR)) != 0) {
     
293.             u32Temp = USART_STAT0(COM);
     
294.             u8Temp = USART_DATA(COM);
     
295.         }
     
296. 
     
297.         USART_CTL0(COM) |= USART_CTL0_RBNEIE;
     
298. 
     
299.     } else if (xTxEnable) {
     
300.         USART_CTL0(COM) &= ~((uint32_t) USART_CTL0_RBNEIE);
     
301. 
     
302.         USART_CTL0(COM) &= ~((uint32_t) USART_CTL0_REN);
     
303.         USART_CTL0(COM) |= (uint32_t) USART_CTL0_TEN;
     
304.         ComTxEnable();
     
305. 
     
306.         ComSndCnt--;
     
307.         USART_DATA(COM) = *(pComSndCur++);
     
308.         USART_CTL0(COM) |= (uint32_t) (USART_CTL0_TBEIE);
     
309.     } else {
     
310. 
     
311.     }
     
312. }
     
313. 
     
314. /*****************************************************************************//*!
     
315. *
     
316. * @brief   Send a string.
     
317. *            
     
318. * @param   none
     
319. *
     
320. * @return  none
     
321. *
     
322. * @ Pass/ Fail criteria: none
     
323. *****************************************************************************/
     
324. 
     
325. void ComStringSend(uint8_t * pData) {
     
326.     if (COM_TX_IDLE == ComSndSt) {
     
327.         pComSndCur = pData;
     
328.         ComSndCnt = 0;
     
329.         while (*pData++)
     
330.             ComSndCnt++;
     
331.         ComSndSt = COM_TX_XMIT;
     
332.         ComEnable(DISABLE, ENABLE);
     
333.     } else {
     
334. 
     
335.     }
     
336. }
     
337. 
     
338. /*****************************************************************************//*!
     
339. *
     
340. * @brief   Send data.
     
341. *            
     
342. * @param   none
     
343. *
     
344. * @return  none
     
345. *
     
346. * @ Pass/ Fail criteria: none
     
347. *****************************************************************************/
     
348. 
     
349. void ComDataSend(uint8_t * pData, uint16_t Len) {
     
350.     if (ComStCheck()) {
     
351.         ComSndCnt = Len;
     
352.         ComSndSt = COM_TX_XMIT;
     
353.         pComSndCur = pData;
     
354.         ComEnable(DISABLE, ENABLE);
     
355.     } else {
     
356. 
     
357.     }
     
358. }
     
359. 
     
360. /*****************************************************************************//*!
     
361. *
     
362. * @brief   Port state check.
     
363. *            
     
364. * @param   none
     
365. *
     
366. * @return  none
     
367. *
     
368. * @ Pass/ Fail criteria: none
     
369. *****************************************************************************/
     
370. 
     
371. uint8_t ComStCheck(void) {
     
372.     if (ComSndSt != COM_TX_IDLE)
     
373.         return 0;
     
374.     if (ComRcvSt != COM_RX_IDLE)
     
375.         return 0;
     
376.     return 1;
     
377. }
     

复制代码

cominfo.h

1. #ifndef _COM_INFO_H_
   
2. #define        _COM_INFO_H_
   
3. 
   
4. #include "stdint.h"
   
5. 
   
6. extern uint8_t const ComInfo[][64];
   
7. 
   
8. #define   COM_INFO_TEST                    0
   
9. #define   COM_INFO_VER                     (COM_INFO_TEST + 1)
   
10. #define   COM_INFO_NOCMD                   (COM_INFO_VER + 1)
    
11. 
    
12. #endif        /* _COM_INFO_H_ */

复制代码

cominfo.c

1. /* ------------------------------------------------------------------------*
   
2. *
   
3. * ------------------------------------------------------------------------*/
   
4. #include "stdint.h"
   
5. uint8_t const ComInfo[][64] =
   
6. {
   
7.         "Communicate OK !\r\n\0",
   
8.         "System version : 0.01.\r\n\0",
   
9.         "No Command Received.\r\n\0"
   
10. };

复制代码

comtask.h

1. ifndef _COM_TASK_H_
   
2. #define        _COM_TASK_H_
   
3. 
   
4. #include "mytype.h"
   
5. #include "stdint.h"
   
6. 
   
7. #define   COM_EVENT_RCVEND                    (0x01UL)
   
8. #define   COM_EVENT_TIMOUT                    (0x02UL)
   
9. 
   
10. #define   COMDLYTIMEOUT                        3000
    
11. 
    
12. #define   CMD_START                           (':')
    
13. 
    
14. #endif        /* _COM_TASK_H_ */

复制代码

comtask.c

1. /* ------------------------------------------------------------------------*
   
2. *
   
3. * ------------------------------------------------------------------------*/
   
4. #include "com_hal.h"
   
5. #include "comtask.h"
   
6. #include "osObjects.h"   
   
7. #include "cominfo.h"
   
8. #include "dataproc.h"
   
9. 
   
10. 
    
11. void CmdProc(void);
    
12. void WifiCmd(void);
    
13. void Cifsr(void);
    
14. void ComStringHandle(void);
    
15. 
    
16. 
    
17. /*****************************************************************************//*!
    
18. * @brief           com task init .
    
19. *               
    
20. * @param   none
    
21. *
    
22. * @return  none
    
23. *
    
24. * @ Pass/ Fail criteria: none
    
25. *****************************************************************************/
    
26. 
    
27. void ComTask(void *argument) {
    
28. 
    
29.     ComInit(9600, COM_PAR_EVEN);
    
30. 
    
31.     for(;;){
    
32.         vTaskDelay(10);
    
33. 
    
34.         if (pdFALSE == xSemaphoreTake(xSemCom, 3000)) {
    
35.             TimeToAscii(&TimeCur, ComBuff);
    
36.             ComBuff[19] = '\r';
    
37.             ComBuff[20] = '\n';
    
38.             ComBuff[21] = 0;
    
39.             ComStringSend(ComBuff);
    
40.         } else {
    
41.             ComStringHandle();
    
42.         }
    
43.     }
    
44. }
    
45. 
    
46. /*****************************************************************************//*!
    
47. * @brief           String Handle .
    
48. *               
    
49. * @param   none
    
50. *
    
51. * @return  none
    
52. *
    
53. * @ Pass/ Fail criteria: none
    
54. *****************************************************************************/
    
55. 
    
56. void ComStringHandle(void) {
    
57.     switch (ComBuff[0]) {
    
58.             //case 'A': WifiCmd();break;
    
59.         case ':': CmdProc();
    
60.             break;
    
61.         default: break;
    
62.     }
    
63. 
    
64.     ComRcvSt = COM_RX_IDLE;
    
65.     ComRcvCnt = 0;
    
66. }
    
67. 
    
68. /*****************************************************************************//*!
    
69. * @brief           Data Handle .
    
70. *               
    
71. * @param   none
    
72. *
    
73. * @return  none
    
74. *
    
75. * @ Pass/ Fail criteria: none
    
76. *****************************************************************************/
    
77. 
    
78. void ComDataHandle(void) {
    
79. 
    
80. }
    
81. 
    
82. /*****************************************************************************//*!
    
83. * @brief   Command Proc .
    
84. *               
    
85. * @param   none
    
86. *
    
87. * @return  none
    
88. *
    
89. * @ Pass/ Fail criteria: none
    
90. *****************************************************************************/
    
91. 
    
92. void CmdProc() {
    
93.     uint8_t Cnt;
    
94. 
    
95.     if (CMD_START != ComBuff[0])
    
96.         return;
    
97. 
    
98.     switch (ComBuff[1]) {
    
99.         case 'T': Cnt = 0;
    
100.             while (ComInfo[COM_INFO_TEST][Cnt]) {
     
101.                 ComBuff[Cnt] = ComInfo[COM_INFO_TEST][Cnt];
     
102.                 Cnt++;
     
103.             }
     
104.             ComBuff[Cnt] = 0;
     
105.             ComStringSend(ComBuff);
     
106.             break;
     
107.         case 'V': Cnt = 0;
     
108.             while (ComInfo[COM_INFO_VER][Cnt]) {
     
109.                 ComBuff[Cnt] = ComInfo[COM_INFO_VER][Cnt];
     
110.                 Cnt++;
     
111.             }
     
112.             ComBuff[Cnt] = 0;
     
113.             ComStringSend(ComBuff);
     
114.             break;
     
115.         default: break;
     
116.     }
     
117. }
     
118. 
     

复制代码

工程使用了freertos系统，串口收发需要创建一个任务和用于同步的信号量
创建任务
if(pdPASS != xTaskCreate( ComTask, "Com", COM_TASK_STACK_SIZE, NULL, COM_TASK_PRIORITY, NULL )) while(1);
创建信号量
vSemaphoreCreateBinary( xSemCom );
if(NULL == xSemCom) while(1);

feixiang20