串口编译求解

15721445669

刚接触Linux，老师傅让我用C 在Linux串口程序实现（linux系统函数实现，必须使用多线程）能正常收发AT指令，这个真是一点头绪和方向都没有啊，看网上相关的写了半天才写了个打开USB然后配置串口，再往下什么读写怎么弄一点都不会啊，百度什么的都是相同的文章，或者写的对我这个初学者来说看不懂，想借鉴也不会啊。。有大神指教或者帮我编写下嘛



#include<stdio.h>      /*标准输入输出定义*/  
#include<stdlib.h>     /*标准函数库定义*/  
#include<unistd.h>     /*Unix 标准函数定义*/  
#include<sys/types.h>   
#include<sys/stat.h>     
#include<fcntl.h>      /*文件控制定义*/  
#include<termios.h>    /*PPSIX 终端控制定义*/  
#include<errno.h>      /*错误号定义*/  
#include<string.h>  
#define FALSE  -1  
#define TRUE   0

int main(int argc,char** argv)  
{  
   int fd;
   char read_buf[256];
   char write_buf[256];
   struct termios opt;
   fd = open( "/dev/ttyUSB0", O_RDWR|O_NOCTTY|O_NDELAY);  
   if (FALSE == fd)  
   {  
   perror("Can't Open Serial Port";  
   return(FALSE);  
   }
   else
   printf("open ttyUSB0 success!\n";
   cfsetispeed(&opt,B115200);
   cfsetospeed(&opt,B115200);
   opt.c_cflag&=CS8;
   opt.c_cflag&=~CSIZE;
   opt.c_cflag|=~CSTOPB;
   opt.c_cflag&=~PARENB;
   tcsetattr(fd,TCSANOW,&opt);
}

idi0t

多线程用来干嘛？
==========
给个例子你吧
#tip /dev/ttyUSB0
#>at+csq
.......
==========
源码:

1. /*****************************************************************************/
   
2. 
   
3. /*
   
4. *      tip.c -- simple tip/cu program.
   
5. *
   
6. *      (C) Copyright 1999-2002, Greg Ungerer (gerg@snapgear.com)
   
7. *      (C) Copyright 2002, SnapGear Inc (www.snapgear.com)
   
8. *      (C) Copyright 2000-2001, Lineo Inc. (www.lineo.com)
   
9. *
   
10. *      Modified 5 May 2000, Rick Stevenson.
    
11. *              Added -f option to pass XON/XOFF characters through
    
12. *              to remote end.
    
13. *
    
14. *      Modified 020131, Heiko Degenhardt (heiko.degenhardt@sentec-elektronik.de)
    
15. *              - Added signal handler to restore the termios
    
16. *              - Introduced SaveRemoteTermIOs/RestoreRemoteTermIOs to
    
17. *                correctly leave the remote side.
    
18. *              - Introduced a global var that holds the file pointer
    
19. *                (FIXME: Don't know if a global var is the right thing!)
    
20. *
    
21. *      Modified March 8, 2004, Mike Risi.
    
22. *      Added call to cfmakeraw in setlocaltermios().  The comment above
    
23. *      setlocaltermios() claimed this was done, but it wasn't.
    
24. *
    
25. */
    
26. 
    
27. /*****************************************************************************/
    
28. 
    
29. #include <stdio.h>
    
30. #include <unistd.h>
    
31. #include <stdlib.h>
    
32. #include <fcntl.h>
    
33. #include <getopt.h>
    
34. #include <errno.h>
    
35. #include <sys/types.h>
    
36. #include <sys/termios.h>
    
37. #include <sys/time.h>
    
38. #include <string.h>
    
39. #include <signal.h>
    
40. 
    
41. #ifndef EMBED
    
42. #include <sys/select.h>
    
43. #endif
    
44. 
    
45. /*****************************************************************************/
    
46. 
    
47. char *version = "1.0.2a";
    
48. 
    
49. /*****************************************************************************/
    
50. 
    
51. /*
    
52. *      Define some parity flags, internal use only.
    
53. */
    
54. #define PARITY_NONE     0
    
55. #define PARITY_EVEN     1
    
56. #define PARITY_ODD      2
    
57. 
    
58. /*
    
59. *      Default port settings.
    
60. */
    
61. int             clocal;
    
62. int             hardware;
    
63. int             software;
    
64. int             passflow;
    
65. int             parity = PARITY_NONE;
    
66. int             databits = 8;
    
67. unsigned int    baud = 9600;
    
68. 
    
69. int             translate;
    
70. int             ocasemode, icasemode;
    
71. 
    
72. char            *devname;
    
73. int             gotdevice;
    
74. int             rfd;
    
75. 
    
76. /*
    
77. *      Working termios settings.
    
78. */
    
79. struct termios  savetio_local;
    
80. struct termios  savetio_remote;
    
81. 
    
82. /*
    
83. *      Signal handling.
    
84. */
    
85. struct sigaction        sact;
    
86. 
    
87. /*
    
88. *      Temporary buffer to use when working.
    
89. */
    
90. unsigned char   ibuf[512];
    
91. unsigned char   obuf[1024];
    
92. 
    
93. /*****************************************************************************/
    
94. 
    
95. /*
    
96. *      Baud rate table for baud rate conversions.
    
97. */
    
98. typedef struct baudmap {
    
99.         unsigned int    baud;
    
100.         unsigned int    flag;
     
101. } baudmap_t;
     
102. 
     
103. 
     
104. struct baudmap  baudtable[] = {
     
105.         { 0, B0 },
     
106.         { 50, B50 },
     
107.         { 75, B75 },
     
108.         { 110, B110 },
     
109.         { 134, B134 },
     
110.         { 150, B150 },
     
111.         { 200, B200 },
     
112.         { 300, B300 },
     
113.         { 600, B600 },
     
114.         { 1200, B1200 },
     
115.         { 1800, B1800 },
     
116.         { 2400, B2400 },
     
117.         { 4800, B4800 },
     
118.         { 9600, B9600 },
     
119.         { 19200, B19200 },
     
120.         { 38400, B38400 },
     
121.         { 57600, B57600 },
     
122.         { 115200, B115200 },
     
123.         { 230400, B230400 },
     
124.         { 460800, B460800 }
     
125. };
     
126. 
     
127. #define NRBAUDS         (sizeof(baudtable) / sizeof(struct baudmap))
     
128. 
     
129. /*****************************************************************************/
     
130. 
     
131. /*
     
132. *      Verify that the supplied baud rate is valid.
     
133. */
     
134. 
     
135. int baud2flag(unsigned int speed)
     
136. {
     
137.         int     i;
     
138. 
     
139.         for (i = 0; (i < NRBAUDS); i++) {
     
140.                 if (speed == baudtable[i].baud)
     
141.                         return(baudtable[i].flag);
     
142.         }
     
143.         return(-1);
     
144. }
     
145. 
     
146. /*****************************************************************************/
     
147. 
     
148. void restorelocaltermios(void)
     
149. {
     
150.         if (tcsetattr(1, TCSAFLUSH, &savetio_local) < 0) {
     
151.                 fprintf(stderr, "ERROR: ioctl(TCSETA) failed, errno=%d\n",
     
152.                         errno);
     
153.                 exit(0);
     
154.         }
     
155. }
     
156. 
     
157. /*****************************************************************************/
     
158. 
     
159. void savelocaltermios(void)
     
160. {
     
161.         if (tcgetattr(1, &savetio_local) < 0) {
     
162.                 fprintf(stderr, "ERROR: ioctl(TCGETA) failed, errno=%d\n",
     
163.                         errno);
     
164.                 exit(0);
     
165.         }
     
166. }
     
167. 
     
168. /*****************************************************************************/
     
169. 
     
170. void restoreremotetermios(void)
     
171. {
     
172.         if (tcsetattr(rfd, TCSAFLUSH, &savetio_remote) < 0) {
     
173.                 fprintf(stderr, "ERROR: ioctl(TCSETA) failed, errno=%d\n",
     
174.                         errno);
     
175.                 exit(0);
     
176.         }
     
177. }
     
178. 
     
179. /*****************************************************************************/
     
180. 
     
181. void saveremotetermios(void)
     
182. {
     
183.         if (tcgetattr(rfd, &savetio_remote) < 0) {
     
184.                 fprintf(stderr, "ERROR: ioctl(TCGETA) failed, errno=%d\n",
     
185.                         errno);
     
186.                 exit(0);
     
187.         }
     
188. }
     
189. 
     
190. /*****************************************************************************/
     
191. 
     
192. /*
     
193. *      Set local port to raw mode, no input mappings.
     
194. */
     
195. 
     
196. int setlocaltermios()
     
197. {
     
198.         struct termios  tio;
     
199. 
     
200.         if (tcgetattr(1, &tio) < 0) {
     
201.                 fprintf(stderr, "ERROR: ioctl(TCGETA) failed, errno=%d\n",
     
202.                         errno);
     
203.                 exit(1);
     
204.         }
     
205. 
     
206.     /* make the local port raw */
     
207.     cfmakeraw(&tio);
     
208. 
     
209.         if (passflow)
     
210.                 tio.c_iflag &= ~(ICRNL|IXON);
     
211.         else
     
212.                 tio.c_iflag &= ~ICRNL;
     
213.         tio.c_lflag = 0;
     
214.         tio.c_cc[VMIN] = 1;
     
215.         tio.c_cc[VTIME] = 0;
     
216. 
     
217.         if (tcsetattr(1, TCSAFLUSH, &tio) < 0) {
     
218.                 fprintf(stderr, "ERROR: ioctl(TCSETA) failed, errno=%d\n",
     
219.                         errno);
     
220.                 exit(1);
     
221.         }
     
222.         return(0);
     
223. }
     
224. 
     
225. /*****************************************************************************/
     
226. 
     
227. /*
     
228. *      Set up remote (connect) port termio settings according to
     
229. *      user specification.
     
230. */
     
231. 
     
232. int setremotetermios()
     
233. {
     
234.         struct termios  tio;
     
235. 
     
236.         memset(&tio, 0, sizeof(tio));
     
237.         tio.c_cflag = CREAD | HUPCL | baud2flag(baud);
     
238. 
     
239.         if (clocal)
     
240.                 tio.c_cflag |= CLOCAL;
     
241. 
     
242.         switch (parity) {
     
243.         case PARITY_ODD:        tio.c_cflag |= PARENB | PARODD; break;
     
244.         case PARITY_EVEN:       tio.c_cflag |= PARENB; break;
     
245.         default:                break;
     
246.         }
     
247. 
     
248.         switch (databits) {
     
249.         case 5:         tio.c_cflag |= CS5; break;
     
250.         case 6:         tio.c_cflag |= CS6; break;
     
251.         case 7:         tio.c_cflag |= CS7; break;
     
252.         default:        tio.c_cflag |= CS8; break;
     
253.         }
     
254. 
     
255.         if (software)
     
256.                 tio.c_iflag |= IXON | IXOFF;
     
257.         if (hardware)
     
258.                 tio.c_cflag |= CRTSCTS;
     
259. 
     
260.         tio.c_cc[VMIN] = 1;
     
261.         tio.c_cc[VTIME] = 0;
     
262. 
     
263.         if (tcsetattr(rfd, TCSAFLUSH, &tio) < 0) {
     
264.                 fprintf(stderr, "ERROR: ioctl(TCSETS) failed, errno=%d\n",
     
265.                         errno);
     
266.                 exit(1);
     
267.         }
     
268.         return(0);
     
269. }
     
270. 
     
271. /*****************************************************************************/
     
272. 
     
273. void SigHandler(int signal)
     
274. {
     
275.         printf("\n\nGot signal %i!\n", signal);
     
276.         printf("Cleaning up...\n");
     
277.         restorelocaltermios();
     
278.         restoreremotetermios();
     
279.         close(rfd);
     
280.         printf("Done.\n\n");
     
281.         exit(1);
     
282. }
     
283. 
     
284. /*****************************************************************************/
     
285. 
     
286. /*
     
287. *      Code to support 5bit translation to ascii.
     
288. *      Whacky 5 bit system used on some older teletype equipment.
     
289. */
     
290. unsigned char   ascii2code[128] = {
     
291.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9a,
     
292.         0x00, 0x00, 0x08, 0x00, 0x00, 0x02, 0x00, 0x00,
     
293.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     
294.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     
295.         0x04, 0x00, 0x00, 0x00, 0x85, 0x96, 0x00, 0x94,
     
296.         0x97, 0x89, 0x00, 0x91, 0x86, 0x98, 0x87, 0x97,
     
297.         0x8d, 0x9d, 0x99, 0x90, 0x8a, 0x81, 0x95, 0x9c,
     
298.         0x8c, 0x83, 0x8e, 0x00, 0x00, 0x8f, 0x00, 0x93,
     
299.         0x8b, 0x18, 0x13, 0x0e, 0x12, 0x10, 0x16, 0x0a,
     
300.         0x05, 0x0c, 0x1a, 0x1e, 0x09, 0x07, 0x06, 0x03,
     
301.         0x0d, 0x1d, 0x0a, 0x14, 0x01, 0x1c, 0x0f, 0x19,
     
302.         0x17, 0x15, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00,
     
303.         0x00, 0x18, 0x13, 0x0e, 0x12, 0x10, 0x16, 0x0a,
     
304.         0x05, 0x0c, 0x1a, 0x1e, 0x09, 0x07, 0x06, 0x03,
     
305.         0x0d, 0x1d, 0x0a, 0x14, 0x01, 0x1c, 0x0f, 0x19,
     
306.         0x17, 0x15, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00,
     
307. };
     
308. 
     
309. unsigned char   lower2ascii[32] = {
     
310.         0x00, 0x74, 0x0d, 0x6f, 0x20, 0x68, 0x6e, 0x6d,
     
311.         0x0a, 0x6c, 0x72, 0x67, 0x69, 0x70, 0x63, 0x76,
     
312.         0x65, 0x7a, 0x64, 0x62, 0x73, 0x79, 0x66, 0x78,
     
313.         0x61, 0x77, 0x6a, 0x80, 0x75, 0x71, 0x6b, 0x80,
     
314. };
     
315. 
     
316. unsigned char   upper2ascii[32] = {
     
317.         0x00, 0x35, 0x0d, 0x39, 0x20, 0x24, 0x2c, 0x2e,
     
318.         0x0a, 0x29, 0x34, 0x40, 0x38, 0x30, 0x3a, 0x3d,
     
319.         0x33, 0x2b, 0x00, 0x3f, 0x27, 0x36, 0x25, 0x2f,
     
320.         0x2d, 0x32, 0x07, 0x80, 0x37, 0x31, 0x28, 0x80,
     
321. };
     
322. 
     
323. int translateread(unsigned char *ip, unsigned char *op, int n)
     
324. {
     
325.         unsigned char   *sop, c;
     
326.         int             i;
     
327. 
     
328.         for (sop = op, i = 0; (i < n); i++) {
     
329.                 c = *ip++;
     
330.                 if (c == 0x1f)
     
331.                         icasemode = 0;
     
332.                 else if (c == 0x1b)
     
333.                         icasemode = 1;
     
334.                 else
     
335.                         c = (icasemode) ? upper2ascii[c] : lower2ascii[c];
     
336.                 *op++ = c;
     
337.         }
     
338.         return(op - sop);
     
339. }
     
340. 
     
341. int translatewrite(unsigned char *ip, unsigned char *op, int n)
     
342. {
     
343.         unsigned char   *sop, c;
     
344.         int             i;
     
345. 
     
346.         for (sop = op, i = 0; (i < n); i++) {
     
347.                 c = *ip++;
     
348.                 c = ascii2code[c & 0x7f];
     
349.                 if (ocasemode && ((c & 0x80) == 0)) {
     
350.                         *op++ = 0x1f;
     
351.                         ocasemode = 0;
     
352.                 }
     
353.                 if ((ocasemode == 0) && (c & 0x80)) {
     
354.                         *op++ = 0x1b;
     
355.                         ocasemode = 1;
     
356.                 }
     
357.                 *op++ = (c & 0x1f);
     
358.         }
     
359.         return(op - sop);
     
360. }
     
361. 
     
362. /*****************************************************************************/
     
363. 
     
364. /*
     
365. *      Do the connection session. Pass data between local and remote
     
366. *      ports.
     
367. */
     
368. 
     
369. int loopit()
     
370. {
     
371.         fd_set  infds;
     
372.         char    *bp;
     
373.         int     maxfd, n;
     
374.         int     partialescape = 0;
     
375. 
     
376.         maxfd = rfd + 1;
     
377. 
     
378.         for (;;) {
     
379.                 FD_ZERO(&infds);
     
380.                 FD_SET(1, &infds);
     
381.                 FD_SET(rfd, &infds);
     
382. 
     
383.                 if (select(maxfd, &infds, NULL, NULL, NULL) < 0) {
     
384.                         fprintf(stderr, "ERROR: select() failed, errno=%d\n",
     
385.                                 errno);
     
386.                         exit(1);
     
387.                 }
     
388. 
     
389.                 if (FD_ISSET(rfd, &infds)) {
     
390.                         bp = ibuf;
     
391.                         if ((n = read(rfd, ibuf, sizeof(ibuf))) < 0) {
     
392.                                 fprintf(stderr, "ERROR: read(fd=%d) failed, "
     
393.                                         "errno=%d\n", rfd, errno);
     
394.                                 exit(1);
     
395.                         }
     
396.                         if (n == 0)
     
397.                                 break;
     
398.                         if (translate) {
     
399.                                 n = translateread(ibuf, obuf, n);
     
400.                                 bp = obuf;
     
401.                         }
     
402.                         if (write(1, bp, n) < 0) {
     
403.                                 fprintf(stderr, "ERROR: write(fd=%d) failed, "
     
404.                                         "errno=%d\n", 1, errno);
     
405.                                 exit(1);
     
406.                         }
     
407.                 }
     
408. 
     
409.                 if (FD_ISSET(1, &infds)) {
     
410.                         bp = ibuf;
     
411.                         if ((n = read(1, ibuf, sizeof(ibuf))) < 0) {
     
412.                                 fprintf(stderr, "ERROR: read(fd=%d) failed, "
     
413.                                         "errno=%d\n", 1, errno);
     
414.                                 exit(1);
     
415.                         }
     
416. 
     
417.                         if (n == 0)
     
418.                                 break;
     
419.                         if ((n == 1) && (*bp == 0x1d))
     
420.                                 break;
     
421.                         if ((n == 1) && (*bp == 0x1))
     
422.                                 break;
     
423.                         if (partialescape) {
     
424.                                 if (*bp == '.')
     
425.                                         break;
     
426.                                 partialescape = 0;
     
427.                         } else {
     
428.                                 partialescape = ((n == 1) && (*bp == '~')) ? 1 : 0;
     
429.                         }
     
430. 
     
431.                         if (translate) {
     
432.                                 n = translatewrite(ibuf, obuf, n);
     
433.                                 bp = obuf;
     
434.                         }
     
435. 
     
436. 
     
437.                         if (write(rfd, bp, n) < 0) {
     
438.                                 fprintf(stderr, "ERROR: write(rfd=%d) failed, "
     
439.                                         "errno=%d\n", rfd, errno);
     
440.                                 exit(1);
     
441.                         }
     
442.                 }
     
443.         }
     
444.         return (0);
     
445. }
     
446. 
     
447. /*****************************************************************************/
     
448. 
     
449. void usage(FILE *fp, int rc)
     
450. {
     
451.         fprintf(fp, "Usage: tip [-h?eonxrct5678] [-s speed] "
     
452.                 "[-l device] [device]\n\n"
     
453.                 "\t-h?\tthis help\n"
     
454.                 "\t-5\t5 data bits\n"
     
455.                 "\t-6\t6 data bits\n"
     
456.                 "\t-7\t7 data bits\n"
     
457.                 "\t-8\t8 data bits (default)\n"
     
458.                 "\t-e\teven parity\n"
     
459.                 "\t-o\todd parity\n"
     
460.                 "\t-n\tno parity (default)\n"
     
461.                 "\t-s\tbaud rate (default 9600)\n"
     
462.                 "\t-c\tuse clocal mode (no disconnect)\n"
     
463.                 "\t-t\ttranslate 5 bit codes to ascii\n"
     
464.                 "\t-l\tdevice to use\n"
     
465.                 "\t-x\tuse software flow (xon/xoff)\n"
     
466.                 "\t-r\tuse hardware flow (rts/cts)\n"
     
467.                 "\t-f\tpass xon/xoff flow control to remote\n");
     
468.         exit(rc);
     
469. }
     
470. 
     
471. /*****************************************************************************/
     
472. 
     
473. int main(int argc, char *argv[])
     
474. {
     
475.         int     c;
     
476. 
     
477.         gotdevice = 0;
     
478. 
     
479.         while ((c = getopt(argc, argv, "eonxrctf5678h?s:l:")) > 0) {
     
480.                 switch (c) {
     
481.                 case 'v':
     
482.                         printf("%s: version %s\n", argv[0], version);
     
483.                         exit(0);
     
484.                 case '5':
     
485.                         databits = 5;
     
486.                         break;
     
487.                 case '6':
     
488.                         databits = 6;
     
489.                         break;
     
490.                 case '7':
     
491.                         databits = 7;
     
492.                         break;
     
493.                 case '8':
     
494.                         databits = 8;
     
495.                         break;
     
496.                 case 't':
     
497.                         translate++;
     
498.                         break;
     
499.                 case 'r':
     
500.                         hardware++;
     
501.                         break;
     
502.                 case 'x':
     
503.                         software++;
     
504.                         break;
     
505.                 case 'f':
     
506.                         passflow++;
     
507.                         break;
     
508.                 case 'o':
     
509.                         parity = PARITY_ODD;
     
510.                         break;
     
511.                 case 'e':
     
512.                         parity = PARITY_EVEN;
     
513.                         break;
     
514.                 case 'n':
     
515.                         parity = PARITY_NONE;
     
516.                         break;
     
517.                 case 's':
     
518.                         baud = atoi(optarg);
     
519.                         if (baud2flag(baud) < 0) {
     
520.                                 fprintf(stderr,
     
521.                                         "ERROR: baud speed specified %d\n",
     
522.                                         baud);
     
523.                                 exit(1);
     
524.                         }
     
525.                         break;
     
526.                 case 'c':
     
527.                         clocal++;
     
528.                         break;
     
529.                 case 'l':
     
530.                         gotdevice++;
     
531.                         devname = optarg;
     
532.                         break;
     
533.                 case 'h':
     
534.                 case '?':
     
535.                         usage(stdout, 0);
     
536.                         break;
     
537.                 default:
     
538.                         fprintf(stderr, "ERROR: unkown option '%c'\n", c);
     
539.                         usage(stderr, 1);
     
540.                         break;
     
541.                 }
     
542.         }
     
543. 
     
544.         if ((optind < argc) && (gotdevice == 0)) {
     
545.                 gotdevice++;
     
546.                 devname = argv[optind++];
     
547.         }
     
548. 
     
549.         if (gotdevice == 0) {
     
550.                 fprintf(stderr, "ERROR: no device specified\n");
     
551.                 usage(stderr, 1);
     
552.         }
     
553.         if (optind < argc) {
     
554.                 fprintf(stderr, "ERROR: too many arguments\n");
     
555.                 usage(stderr, 1);
     
556.         }
     
557. 
     
558.         /*
     
559.          *      Check device is real, and open it.
     
560.          */
     
561.         if ((rfd = open(devname, (O_RDWR | O_NDELAY))) < 0) {
     
562.                 fprintf(stderr, "ERROR: failed to open %s, errno=%d\n",
     
563.                         devname, errno);
     
564.                 exit(0);
     
565.         }
     
566. 
     
567.         savelocaltermios();
     
568.         setlocaltermios();
     
569.         saveremotetermios();
     
570.         setremotetermios();
     
571. 
     
572.         /*
     
573.          *      Set the signal handler to restore the old termios .
     
574.          */
     
575.         sact.sa_handler = SigHandler;
     
576.         sigaction(SIGHUP, &sact, NULL);
     
577.         sigaction(SIGINT, &sact, NULL);
     
578.         sigaction(SIGQUIT, &sact, NULL);
     
579.         sigaction(SIGPIPE, &sact, NULL);
     
580.         sigaction(SIGTERM, &sact, NULL);
     
581. 
     
582.         printf("Connected.\n");
     
583.         loopit();
     
584. 
     
585.         restoreremotetermios();
     
586.         restorelocaltermios();
     
587.         close(rfd);
     
588.         printf("Disconnected.\n");
     
589.         exit(0);
     
590. }
     
591. 
     
592. /*****************************************************************************/
     

复制代码

15721445669

看了一眼，眼前好黑= =  啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊要死要死啊回复 2# idi0t


   

15721445669

我就是想写一个波特率什么的既定好的，也不用像minicom那样需要重新设置波特率啊什么的，这些都是固定的一个值，因为我用的对象也就一个吗，老师傅的意思就是让我自己写一个串口工具来用来发AT指令给模块，然后看返回值，看着好晕啊， 人生一片灰暗啊= = 回复 2# idi0t