Linux串口测试程序

seaquester

Linux串口测试程序
冷胜魁(Seaquester)
lengshengkui@gmail.com
2009-11-18

这是以前在做一个基于ARM的项目的时候，写的一个简单串口测试程序，同样也适用于X86平台。程序很简单，运行是通过参数指定程序是发送端还是接收端。接收端运行之后就简单的读取串口数据，打印到stdout。发送端则接受键盘输入，通过串口发送出去。如果直接回车则表示发送完毕，通知接收端退出。

1. 
   
2. /******************************************************************************
   
3. *
   
4. * FILENAME:
   
5. *     testcom.c
   
6. *
   
7. * DESCRIPTION:
   
8. *     A utility to read/write serial port
   
9. *     Usage: testcom <device> <baud> <databits> <parity> <stopbits> <read_or_write>
   
10. *        databits: 5, 6, 7, 8
    
11. *        parity: 0(None), 1(Odd), 2(Even)
    
12. *        stopbits: 1, 2
    
13. *        read_or_write: 0(read), 1(write)
    
14. *     Example: testcom /dev/ttyS0 9600 8 0 1 0
    
15. *
    
16. * REVISION(MM/DD/YYYY):
    
17. *     03/12/2008  Shengkui Leng (shengkui.leng@advantech.com.cn)
    
18. *     - Initial version
    
19. *
    
20. ******************************************************************************/
    
21. #include <stdio.h>
    
22. #include <stdlib.h>
    
23. #include <errno.h>
    
24. #include <unistd.h>
    
25. #include <fcntl.h>
    
26. #include <string.h>
    
27. #include <termio.h>
    
28. #include <time.h>
    
29. 
    
30. 
    
31. #define MAX_BUF_SIZE     2048
    
32. char buf[MAX_BUF_SIZE+2];
    
33. 
    
34. #define MY_END_CHAR      0x13
    
35. 
    
36. 
    
37. int setup_port(int fd, int baud, int databits, int parity, int stopbits);
    
38. int reset_port(int fd);
    
39. int read_data(int fd, void *buf, int len);
    
40. int write_data(int fd, void *buf, int len);
    
41. void print_usage(char *program_name);
    
42. 
    
43. 
    
44. int main(int argc, char *argv[])
    
45. {
    
46.     int fd;
    
47.     int baud;
    
48.     int len;
    
49.     int count;
    
50.     int i;
    
51.     int databits;
    
52.     int stopbits;
    
53.     int parity;
    
54.     int read_or_write;
    
55. 
    
56. 
    
57.     if (argc != 7) {
    
58.         print_usage(argv[0]);
    
59.         return 1;
    
60.     }
    
61. 
    
62.     baud = atoi(argv[2]);
    
63.     if ((baud < 0) || (baud > 921600)) {
    
64.         fprintf(stderr, "Invalid baudrate!\n");
    
65.         return 1;
    
66.     }
    
67. 
    
68.     databits = atoi(argv[3]);
    
69.     if ((databits < 5) || (databits > 8)) {
    
70.         fprintf(stderr, "Invalid databits!\n");
    
71.         return 1;
    
72.     }
    
73. 
    
74.     parity = atoi(argv[4]);
    
75.     if ((parity < 0) || (parity > 2)) {
    
76.         fprintf(stderr, "Invalid parity!\n");
    
77.         return 1;
    
78.     }
    
79. 
    
80.     stopbits = atoi(argv[5]);
    
81.     if ((stopbits < 1) || (stopbits > 2)) {
    
82.         fprintf(stderr, "Invalid stopbits!\n");
    
83.         return 1;
    
84.     }
    
85. 
    
86.     read_or_write = atoi(argv[6]);
    
87. 
    
88.     fd = open(argv[1], O_RDWR, 0);
    
89.     if (fd < 0) {
    
90.         fprintf(stderr, "open <%s> error %s\n", argv[1], strerror(errno));
    
91.         return 1;
    
92.     }
    
93. 
    
94.     if (setup_port(fd, baud, databits, parity, stopbits)) {
    
95.         fprintf(stderr, "setup_port error %s\n", strerror(errno));
    
96.         close(fd);
    
97.         return 1;
    
98.     }
    
99. 
    
100.     count = 0;
     
101. 
     
102.     if (read_or_write) {
     
103.         fprintf(stderr, "Begin to send:\n");
     
104. 
     
105.         while ( (len = read(0, buf, MAX_BUF_SIZE)) > 0 ) {
     
106.             if (len == 1) {
     
107.                 buf[0] = MY_END_CHAR;
     
108.                 buf[1] = 0;
     
109.                 write_data(fd, buf, len);
     
110.                 break;
     
111.             }
     
112. 
     
113.             /* send a pack */
     
114.             i = write_data(fd, buf, len);
     
115.             if (i == 0) {
     
116.                 fprintf(stderr, "Send data error!\n");
     
117.                 break;
     
118.             }
     
119. 
     
120.             //count += len;
     
121.             //fprintf(stderr, "Send %d bytes\n", len);
     
122.         }
     
123. 
     
124.     } else {
     
125. 
     
126.         fprintf(stderr, "Begin to recv:\n");
     
127. 
     
128.         len = MAX_BUF_SIZE;
     
129. 
     
130.         while (1) {
     
131.             /* read a pack */
     
132.             i = read_data(fd, buf, len);
     
133.             if (i > 0) {
     
134.                 //count += i;
     
135.                 //fprintf(stderr, "Recv %d byte\n", i);
     
136.                 printf("%s", buf);
     
137.                 if (buf[i-1] == MY_END_CHAR) {
     
138.                     break;
     
139.                 }
     
140.             }
     
141.         }
     
142.     }
     
143. 
     
144.     reset_port(fd);
     
145.     close(fd);
     
146. 
     
147.     return 0;
     
148. }
     
149. 
     
150. 
     
151. static int baudflag_arr[] = {
     
152.     B921600, B460800, B230400, B115200, B57600, B38400,
     
153.     B19200,  B9600,   B4800,   B2400,   B1800,  B1200,
     
154.     B600,    B300,    B150,    B110,    B75,    B50
     
155. };
     
156. static int speed_arr[] = {
     
157.     921600,  460800,  230400,  115200,  57600,  38400,
     
158.     19200,   9600,    4800,    2400,    1800,   1200,
     
159.     600,     300,     150,     110,     75,     50
     
160. };
     
161. 
     
162. 
     
163. /******************************************************************************
     
164. * NAME:
     
165. *      speed_to_flag
     
166. *
     
167. * DESCRIPTION:
     
168. *      Translate baudrate into flag
     
169. *
     
170. * PARAMETERS:
     
171. *      speed - The baudrate to convert
     
172. *
     
173. * RETURN:
     
174. *      The flag
     
175. ******************************************************************************/
     
176. int speed_to_flag(int speed)
     
177. {
     
178.     int i;
     
179. 
     
180.     for (i = 0;  i < sizeof(speed_arr)/sizeof(int);  i++) {
     
181.         if (speed == speed_arr[i]) {
     
182.             return baudflag_arr[i];
     
183.         }
     
184.     }
     
185. 
     
186.     fprintf(stderr, "Unsupported baudrate, use 9600 instead!\n");
     
187.     return B9600;
     
188. }
     
189. 
     
190. 
     
191. static struct termio oterm_attr;
     
192. 
     
193. /******************************************************************************
     
194. * NAME:
     
195. *      stup_port
     
196. *
     
197. * DESCRIPTION:
     
198. *      Set serial port (include baudrate, line control)
     
199. *
     
200. * PARAMETERS:
     
201. *      fd       - The fd of serial port to setup
     
202. *      baud     - Baudrate: 9600, ...
     
203. *      databits - Databits: 5, 6, 7, 8
     
204. *      parity   - Parity: 0(None), 1(Odd), 2(Even)
     
205. *      stopbits - Stopbits: 1, 2
     
206. *
     
207. * RETURN:
     
208. *      0 for OK; Others for ERROR
     
209. ******************************************************************************/
     
210. int setup_port(int fd, int baud, int databits, int parity, int stopbits)
     
211. {
     
212.     struct termio term_attr;
     
213. 
     
214.     /* Get current setting */
     
215.     if (ioctl(fd, TCGETA, &term_attr) < 0) {
     
216.         return -1;
     
217.     }
     
218. 
     
219.     /* Backup old setting */
     
220.     memcpy(&oterm_attr, &term_attr, sizeof(struct termio));
     
221. 
     
222.     term_attr.c_iflag &= ~(INLCR | IGNCR | ICRNL | ISTRIP);
     
223.     term_attr.c_oflag &= ~(OPOST | ONLCR | OCRNL);
     
224.     term_attr.c_lflag &= ~(ISIG | ECHO | ICANON | NOFLSH);
     
225.     term_attr.c_cflag &= ~CBAUD;
     
226.     term_attr.c_cflag |= CREAD | speed_to_flag(baud);
     
227. 
     
228.     /* Set databits */
     
229.     term_attr.c_cflag &= ~(CSIZE);
     
230.     switch (databits) {
     
231.         case 5:
     
232.             term_attr.c_cflag |= CS5;
     
233.             break;
     
234. 
     
235.         case 6:
     
236.             term_attr.c_cflag |= CS6;
     
237.             break;
     
238. 
     
239.         case 7:
     
240.             term_attr.c_cflag |= CS7;
     
241.             break;
     
242. 
     
243.         case 8:
     
244.         default:
     
245.             term_attr.c_cflag |= CS8;
     
246.             break;
     
247.     }
     
248. 
     
249.     /* Set parity */
     
250.     switch (parity) {
     
251.         case 1:   /* Odd parity */
     
252.             term_attr.c_cflag |= (PARENB | PARODD);
     
253.             break;
     
254. 
     
255.         case 2:   /* Even parity */
     
256.             term_attr.c_cflag |= PARENB;
     
257.             term_attr.c_cflag &= ~(PARODD);
     
258.             break;
     
259. 
     
260.         case 0:   /* None parity */
     
261.         default:
     
262.             term_attr.c_cflag &= ~(PARENB);
     
263.             break;
     
264.     }
     
265. 
     
266. 
     
267.     /* Set stopbits */
     
268.     switch (stopbits) {
     
269.         case 2:   /* 2 stopbits */
     
270.             term_attr.c_cflag |= CSTOPB;
     
271.             break;
     
272. 
     
273.         case 1:   /* 1 stopbits */
     
274.         default:
     
275.             term_attr.c_cflag &= ~CSTOPB;
     
276.             break;
     
277.     }
     
278. 
     
279.     term_attr.c_cc[VMIN] = 1;
     
280.     term_attr.c_cc[VTIME] = 0;
     
281. 
     
282.     if (ioctl(fd, TCSETAW, &term_attr) < 0) {
     
283.         return -1;
     
284.     }
     
285. 
     
286.     if (ioctl(fd, TCFLSH, 2) < 0) {
     
287.         return -1;
     
288.     }
     
289. 
     
290.     return 0;
     
291. }
     
292. 
     
293. 
     
294. /******************************************************************************
     
295. * NAME:
     
296. *      read_data
     
297. *
     
298. * DESCRIPTION:
     
299. *      Read data from serial port
     
300. *
     
301. *
     
302. * PARAMETERS:
     
303. *      fd   - The fd of serial port to read
     
304. *      buf  - The buffer to keep readed data
     
305. *      len  - The max count to read
     
306. *
     
307. * RETURN:
     
308. *      Count of readed data
     
309. ******************************************************************************/
     
310. int read_data(int fd, void *buf, int len)
     
311. {
     
312.     int count;
     
313.     int ret;
     
314. 
     
315.     ret = 0;
     
316.     count = 0;
     
317. 
     
318.     //while (len > 0) {
     
319. 
     
320.     ret = read(fd, (char*)buf + count, len);
     
321.     if (ret < 1) {
     
322.         fprintf(stderr, "Read error %s\n", strerror(errno));
     
323.         //break;
     
324.     }
     
325. 
     
326.     count += ret;
     
327.     len = len - ret;
     
328. 
     
329.     //}
     
330. 
     
331.     *((char*)buf + count) = 0;
     
332.     return count;
     
333. }
     
334. 
     
335. 
     
336. /******************************************************************************
     
337. * NAME:
     
338. *      write_data
     
339. *
     
340. * DESCRIPTION:
     
341. *      Write data to serial port
     
342. *
     
343. *
     
344. * PARAMETERS:
     
345. *      fd   - The fd of serial port to write
     
346. *      buf  - The buffer to keep data
     
347. *      len  - The count of data
     
348. *
     
349. * RETURN:
     
350. *      Count of data wrote
     
351. ******************************************************************************/
     
352. int write_data(int fd, void *buf, int len)
     
353. {
     
354.     int count;
     
355.     int ret;
     
356. 
     
357.     ret = 0;
     
358.     count = 0;
     
359. 
     
360.     while (len > 0) {
     
361. 
     
362.         ret = write(fd, (char*)buf + count, len);
     
363.         if (ret < 1) {
     
364.             fprintf(stderr, "Write error %s\n", strerror(errno));
     
365.             break;
     
366.         }
     
367. 
     
368.         count += ret;
     
369.         len = len - ret;
     
370.     }
     
371. 
     
372.     return count;
     
373. }
     
374. 
     
375. 
     
376. /******************************************************************************
     
377. * NAME:
     
378. *      print_usage
     
379. *
     
380. * DESCRIPTION:
     
381. *      print usage info
     
382. *
     
383. * PARAMETERS:
     
384. *      program_name - The name of the program
     
385. *
     
386. * RETURN:
     
387. *      None
     
388. ******************************************************************************/
     
389. void print_usage(char *program_name)
     
390. {
     
391.     fprintf(stderr,
     
392.             "*************************************\n"
     
393.             "  A Simple Serial Port Test Utility\n"
     
394.             "*************************************\n\n"
     
395.             "Usage:\n  %s <device> <baud> <databits> <parity> <stopbits> <read_or_write>\n"
     
396.             "       databits: 5, 6, 7, 8\n"
     
397.             "       parity: 0(None), 1(Odd), 2(Even)\n"
     
398.             "       stopbits: 1, 2\n"
     
399.             "       read_or_write: 0(read), 1(write)\n"
     
400.             "Example:\n  %s /dev/ttyS0 9600 8 0 1 0\n\n",
     
401.             program_name, program_name
     
402.            );
     
403. }
     
404. 
     
405. 
     
406. /******************************************************************************
     
407. * NAME:
     
408. *      reset_port
     
409. *
     
410. * DESCRIPTION:
     
411. *      Restore original setting of serial port
     
412. *
     
413. * PARAMETERS:
     
414. *      fd - The fd of the serial port
     
415. *
     
416. * RETURN:
     
417. *      0 for OK; Others for ERROR
     
418. ******************************************************************************/
     
419. int reset_port(int fd)
     
420. {
     
421.     if (ioctl(fd, TCSETAW, &oterm_attr) < 0) {
     
422.         return -1;
     
423.     }
     
424. 
     
425.     return 0;
     
426. }
     

复制代码

               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u2/73823/showart_2097571.html