虚拟机读写串口问题

麦哥哥

虚拟机装的是ubuntu，串口也已经添加上去了，通过minicom -s设置了一些参数（波特率，停止位，奇偶校验，数据位），为什么在另外一端接收的数据为空但是返回值证明有数据读到，返回值为读到的字节数）？大家有没遇到过这种情况，帮忙解决这个问题。

emmoblin

估计是程序的事，驱动应该没问题。
你可以试试如下命令
echo 123 > /dev/ttyS0
另一端
cat < /dev/ttyS0

看看能不能收到数据

麦哥哥

不行啊？收不到！！！

麦哥哥

大家再帮我看看，在Linux上读写串口是没有问题的！

麦哥哥

帮帮忙！

myforever

看这儿：

A Linux serial port test program

1. 
   
2. #include <termios.h>
   
3. #include <stdio.h>
   
4. #include <unistd.h>
   
5. #include <fcntl.h>
   
6. #include <sys/signal.h>
   
7. #include <sys/types.h>
   
8. 
   
9. #define BAUDRATE B38400
   
10. #define MODEMDEVICE "/dev/ttyS1"
    
11. #define _POSIX_SOURCE 1  //POSIX compliant source
    
12. #define FALSE 0
    
13. #define TRUE 1
    
14. 
    
15. volatile int STOP=FALSE;
    
16. 
    
17. void signal_handler_IO (int status);//definition of signal handler
    
18. int wait_flag=TRUE;     //TRUE while no signal received
    
19. char devicename[80];
    
20. long Baud_Rate = 38400;    //default Baud Rate (110 through 38400)
    
21. long BAUD;       //derived baud rate from command line
    
22. long DATABITS;
    
23. long STOPBITS;
    
24. long PARITYON;
    
25. long PARITY;
    
26. int Data_Bits = 8;     //Number of data bits
    
27. int Stop_Bits = 1;     //Number of stop bits
    
28. int Parity = 0;      //Parity as follows:
    
29.                   //00 = NONE, 01 = Odd, 02 = Even, 03 = Mark, 04 = Space
    
30. int Format = 4;
    
31. FILE *input;
    
32. FILE *output;
    
33. int status;
    
34. 
    
35. main(int Parm_Count, char *Parms[])
    
36. {
    
37.    char version[80] = "POSIX compliant Communications test program version 1.00 4-25-1999\r\n";
    
38.    char version1[80] = "Copyright(C) Mark Zehner/Peter Baumann 1999\r\n";
    
39.    char version2[80] = "This code is based on a DOS based test program by Mark Zehner and a Serial\r\n";
    
40.    char version3[80] = "Programming POSIX howto by Peter Baumann, integrated by Mark Zehner\r\n";
    
41.    char version4[80] = "This program allows you to send characters out the specified port by typing\r\n";
    
42.    char version5[80] = "on the keyboard.  Characters typed will be echoed to the console, and \r\n";
    
43.    char version6[80] = "characters received will be echoed to the console.\r\n";
    
44.    char version7[80] = "The setup parameters for the device name, receive data format, baud rate\r\n";
    
45.    char version8[80] = "and other serial port parameters must be entered on the command line \r\n";
    
46.    char version9[80] = "To see how to do this, just type the name of this program. \r\n";
    
47.    char version10[80] = "This program is free software; you can redistribute it and/or modify it\r\n";
    
48.    char version11[80] = "under the terms of the GNU General Public License as published by the \r\n";
    
49.    char version12[80] = "Free Software Foundation, version 2.\r\n";
    
50.    char version13[80] = "This program comes with ABSOLUTELY NO WARRANTY.\r\n";
    
51.    char instr[100] ="\r\nOn the command you must include six items in the following order, they are:\r\n";
    
52.    char instr1[80] ="   1.  The device name      Ex: ttyS0 for com1, ttyS1 for com2, etc\r\n";
    
53.    char instr2[80] ="   2.  Baud Rate            Ex: 38400 \r\n";
    
54.    char instr3[80] ="   3.  Number of Data Bits  Ex: 8 \r\n";
    
55.    char instr4[80] ="   4.  Number of Stop Bits  Ex: 0 or 1\r\n";
    
56.    char instr5[80] ="   5.  Parity               Ex: 0=none, 1=odd, 2=even\r\n";
    
57.    char instr6[80] ="   6.  Format of data received:  1=hex, 2=dec, 3=hex/asc, 4=dec/asc, 5=asc\r\n";
    
58.    char instr7[80] =" Example command line:  com ttyS0 38400 8 0 0 4 \r\n";
    
59.    char Param_strings[7][80];
    
60.    char message[90];
    
61. 
    
62.    int fd, tty, c, res, i, error;
    
63.    char In1, Key;
    
64.    struct termios oldtio, newtio;       //place for old and new port settings for serial port
    
65.    struct termios oldkey, newkey;       //place tor old and new port settings for keyboard teletype
    
66.    struct sigaction saio;               //definition of signal action
    
67.    char buf[255];                       //buffer for where data is put
    
68. 
    
69.    input = fopen("/dev/tty", "r");      //open the terminal keyboard
    
70.    output = fopen("/dev/tty", "w");     //open the terminal screen
    
71. 
    
72.    if (!input || !output)
    
73.    {
    
74.       fprintf(stderr, "Unable to open /dev/tty\n");
    
75.       exit(1);
    
76.    }
    
77. 
    
78.    error=0;
    
79.    fputs(version,output);               //display the program introduction
    
80.    fputs(version1,output);
    
81.    fputs(version2,output);
    
82.    fputs(version3,output);
    
83.    fputs(version4,output);
    
84.    fputs(version5,output);
    
85.    fputs(version6,output);
    
86.    fputs(version7,output);
    
87.    fputs(version8,output);
    
88.    fputs(version9,output);
    
89.    fputs(version10,output);
    
90.    fputs(version11,output);
    
91.    fputs(version12,output);
    
92.    fputs(version13,output);
    
93.    //read the parameters from the command line
    
94.    if (Parm_Count==7)  //if there are the right number of parameters on the command line
    
95.    {
    
96.       for (i=1; i<Parm_Count; i++)  // for all wild search parameters
    
97.       {
    
98.          strcpy(Param_strings,Parms);
    
99.       }
    
100.       i=sscanf(Param_strings[0],"%s",devicename);
     
101.       if (i != 1) error=1;
     
102.       i=sscanf(Param_strings[1],"%li",&Baud_Rate);
     
103.       if (i != 1) error=1;
     
104.       i=sscanf(Param_strings[2],"%i",&Data_Bits);
     
105.       if (i != 1) error=1;
     
106.       i=sscanf(Param_strings[3],"%i",&Stop_Bits);
     
107.       if (i != 1) error=1;
     
108.       i=sscanf(Param_strings[4],"%i",&Parity);
     
109.       if (i != 1) error=1;
     
110.       i=sscanf(Param_strings[5],"%i",&Format);
     
111.       if (i != 1) error=1;
     
112.    //output the received setup parameters
     
113.       sprintf(message,"Device=%s, Baud=%li\r\n",devicename, Baud_Rate);
     
114.       fputs(message,output);
     
115.       sprintf(message,"Data Bits=%i  Stop Bits=%i  Parity=%i  Format=%i\r\n",
     
116.     Data_Bits, Stop_Bits, Parity, Format);
     
117.       fputs(message,output);
     
118.    }  //end of if param_count==7
     
119.    if ((Parm_Count==7) && (error==0))  //if the command line entries were correct
     
120.    {                                    //run the program
     
121.       tty = open("/dev/tty", O_RDWR | O_NOCTTY | O_NONBLOCK);//set the user console port up
     
122.       tcgetattr(tty,&oldkey); // save current port settings
     
123.    //so commands are interpreted right for this program
     
124.       //set new port settings for non-canonical input processing  //must be NOCTTY
     
125.       newkey.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
     
126.       newkey.c_iflag = IGNPAR;
     
127.       newkey.c_oflag = 0;
     
128.       newkey.c_lflag = 0;       //ICANON;
     
129.       newkey.c_cc[VMIN]=1;
     
130.       newkey.c_cc[VTIME]=0;
     
131.       tcflush(tty, TCIFLUSH);
     
132.       tcsetattr(tty,TCSANOW,&newkey);
     
133. 
     
134.       switch (Baud_Rate)
     
135.       {
     
136.          case 38400:
     
137.          default:
     
138.             BAUD = B38400;
     
139.             break;
     
140.          case 19200:
     
141.             BAUD  = B19200;
     
142.             break;
     
143.          case 9600:
     
144.             BAUD  = B9600;
     
145.             break;
     
146.          case 4800:
     
147.             BAUD  = B4800;
     
148.             break;
     
149.          case 2400:
     
150.             BAUD  = B2400;
     
151.             break;
     
152.          case 1800:
     
153.             BAUD  = B1800;
     
154.             break;
     
155.          case 1200:
     
156.             BAUD  = B1200;
     
157.             break;
     
158.          case 600:
     
159.             BAUD  = B600;
     
160.             break;
     
161.          case 300:
     
162.             BAUD  = B300;
     
163.             break;
     
164.          case 200:
     
165.             BAUD  = B200;
     
166.             break;
     
167.          case 150:
     
168.             BAUD  = B150;
     
169.             break;
     
170.          case 134:
     
171.             BAUD  = B134;
     
172.             break;
     
173.          case 110:
     
174.             BAUD  = B110;
     
175.             break;
     
176.          case 75:
     
177.             BAUD  = B75;
     
178.             break;
     
179.          case 50:
     
180.             BAUD  = B50;
     
181.             break;
     
182.       }  //end of switch baud_rate
     
183.       switch (Data_Bits)
     
184.       {
     
185.          case 8:
     
186.          default:
     
187.             DATABITS = CS8;
     
188.             break;
     
189.          case 7:
     
190.             DATABITS = CS7;
     
191.             break;
     
192.          case 6:
     
193.             DATABITS = CS6;
     
194.             break;
     
195.          case 5:
     
196.             DATABITS = CS5;
     
197.             break;
     
198.       }  //end of switch data_bits
     
199.       switch (Stop_Bits)
     
200.       {
     
201.          case 1:
     
202.          default:
     
203.             STOPBITS = 0;
     
204.             break;
     
205.          case 2:
     
206.             STOPBITS = CSTOPB;
     
207.             break;
     
208.       }  //end of switch stop bits
     
209.       switch (Parity)
     
210.       {
     
211.          case 0:
     
212.          default:                       //none
     
213.             PARITYON = 0;
     
214.             PARITY = 0;
     
215.             break;
     
216.          case 1:                        //odd
     
217.             PARITYON = PARENB;
     
218.             PARITY = PARODD;
     
219.             break;
     
220.          case 2:                        //even
     
221.             PARITYON = PARENB;
     
222.             PARITY = 0;
     
223.             break;
     
224.       }  //end of switch parity
     
225. 
     
226.       //open the device(com port) to be non-blocking (read will return immediately)
     
227.       fd = open(devicename, O_RDWR | O_NOCTTY | O_NONBLOCK);
     
228.       if (fd < 0)
     
229.       {
     
230.          perror(devicename);
     
231.          exit(-1);
     
232.       }
     
233. 
     
234.       //install the serial handler before making the device asynchronous
     
235.       saio.sa_handler = signal_handler_IO;
     
236.       sigemptyset(&saio.sa_mask);   //saio.sa_mask = 0;
     
237.       saio.sa_flags = 0;
     
238.       saio.sa_restorer = NULL;
     
239.       sigaction(SIGIO,&saio,NULL);
     
240. 
     
241.       // allow the process to receive SIGIO
     
242.       fcntl(fd, F_SETOWN, getpid());
     
243.       // Make the file descriptor asynchronous (the manual page says only
     
244.       // O_APPEND and O_NONBLOCK, will work with F_SETFL)
     
245.       fcntl(fd, F_SETFL, FASYNC);
     
246. 
     
247.       tcgetattr(fd,&oldtio); // save current port settings
     
248.       // set new port settings for canonical input processing
     
249.       newtio.c_cflag = BAUD | CRTSCTS | DATABITS | STOPBITS | PARITYON | PARITY | CLOCAL | CREAD;
     
250.       newtio.c_iflag = IGNPAR;
     
251.       newtio.c_oflag = 0;
     
252.       newtio.c_lflag = 0;       //ICANON;
     
253.       newtio.c_cc[VMIN]=1;
     
254.       newtio.c_cc[VTIME]=0;
     
255.       tcflush(fd, TCIFLUSH);
     
256.       tcsetattr(fd,TCSANOW,&newtio);
     
257. 
     
258.       // loop while waiting for input. normally we would do something useful here
     
259.       while (STOP==FALSE)
     
260.       {
     
261.          status = fread(&Key,1,1,input);
     
262.          if (status==1)  //if a key was hit
     
263.          {
     
264.             switch (Key)
     
265.             { /* branch to appropiate key handler */
     
266.                case 0x1b: /* Esc */
     
267.                   STOP=TRUE;
     
268.                   break;
     
269.                default:
     
270.                   fputc((int) Key,output);
     
271. //                  sprintf(message,"%x ",Key);  //debug
     
272. //                  fputs(message,output);
     
273.                   write(fd,&Key,1);          //write 1 byte to the port
     
274.                   break;
     
275.             }  //end of switch key
     
276.          }  //end if a key was hit
     
277.          // after receiving SIGIO, wait_flag = FALSE, input is available and can be read
     
278.          if (wait_flag==FALSE)  //if input is available
     
279.          {
     
280.             res = read(fd,buf,255);
     
281.             if (res?)
     
282.             {
     
283.                for (i=0; i<res; i++)  //for all chars in string
     
284.                {
     
285.                   In1 = buf;
     
286.                   switch (Format)
     
287.                   {
     
288.                      case 1:         //hex
     
289.                         sprintf(message,"%x ",In1);
     
290.                         fputs(message,output);
     
291.                         break;
     
292.                      case 2:         //decimal
     
293.                         sprintf(message,"%d ",In1);
     
294.                         fputs(message,output);
     
295.                         break;
     
296.                      case 3:         //hex and asc
     
297.                         if ((In1?) || (In1?))
     
298.                         {
     
299.                            sprintf(message,"%x",In1);
     
300.                            fputs(message,output);
     
301.                         }
     
302.                         else fputc ((int) In1, output);
     
303.                         break;
     
304.                      case 4:         //decimal and asc
     
305.                      default:
     
306.                         if ((In1?) || (In1?))
     
307.                         {
     
308.                            sprintf(message,"%d",In1);
     
309.                            fputs(message,output);
     
310.                         }
     
311.                         else fputc ((int) In1, output);
     
312.                         break;
     
313.                      case 5:         //asc
     
314.                         fputc ((int) In1, output);
     
315.                         break;
     
316.                   }  //end of switch format
     
317.                }  //end of for all chars in string
     
318.             }  //end if res?
     
319. //            buf[res]=0;
     
320. //            printf(":%s:%d\n", buf, res);
     
321. //            if (res==1) STOP=TRUE; /* stop loop if only a CR was input */
     
322.             wait_flag = TRUE;      /* wait for new input */
     
323.          }  //end if wait flag == FALSE
     
324. 
     
325.       }  //while stop==FALSE
     
326.       // restore old port settings
     
327.       tcsetattr(fd,TCSANOW,&oldtio);
     
328.       tcsetattr(tty,TCSANOW,&oldkey);
     
329.       close(tty);
     
330.       close(fd);        //close the com port
     
331.    }  //end if command line entrys were correct
     
332.    else  //give instructions on how to use the command line
     
333.    {
     
334.       fputs(instr,output);
     
335.       fputs(instr1,output);
     
336.       fputs(instr2,output);
     
337.       fputs(instr3,output);
     
338.       fputs(instr4,output);
     
339.       fputs(instr5,output);
     
340.       fputs(instr6,output);
     
341.       fputs(instr7,output);
     
342.    }
     
343.    fclose(input);
     
344.    fclose(output);
     
345. }  //end of main
     
346. 
     
347. /***************************************************************************
     
348. * signal handler. sets wait_flag to FALSE, to indicate above loop that     *
     
349. * characters have been received.                                           *
     
350. ***************************************************************************/
     
351. 
     
352. void signal_handler_IO (int status)
     
353. {
     
354. //    printf("received SIGIO signal.\n");
     
355.    wait_flag = FALSE;
     
356. }
     
357. 
     
358. 
     

复制代码

myforever

还可能是回环问题