急！！linux下串口通讯编程，read()不能读数据的原因？

happybgt

急！！linux下串口通讯编程，read()不能读数据的原因？
！！本人菜鸟一个，刚编写了一段串口通讯程序，但是只能发送数据，不能接收数据，这是什么原因啊？请个位大侠不吝赐教，万分感谢！！
主函数代码如下：
volatile int STOP=FALSE;  
int main(void)
{       int i;
        int fd;
        char send_buff[8]="OPEn";
        int send_length;
        int byteswrite;

        char rcv_buff[8];
        int rcv_length;
        int bytesread;

        char *dev = "/dev/ttyS1";
        fd = OpenDev(dev);  // fd= open("/dev/ttyS1",O_RDWR | O_NOCTTY);
        
        set_speed(fd,2400);  //波特率2400
        if(set_Parity(fd,8,1,'N') == FALSE) //设置8，1，n
        {
                printf("Set Parity Error\n") ;
                exit(0);
        }
         
       bzero(rcv_buff,sizeof(rcv_buff));

       //发送数据,这里功能正常，能发送出数据“OPEn”
        for(i=0;i<10;i++)
        byteswrite=write(fd,send_buff,8 ) ; //成功返回写入数据的字节数,该值通常等于length，如果写入失败返回-1
        if(byteswrite==-1)
        {
                printf("write device %s error\n",*dev);
        }
               
        //读取数据！！这里的功能不能实现！！
        while (STOP==FALSE)
        {   
                    bytesread =read(fd,rcv_buff,8 ) ; //读操作成功读取返回读取的字节数，失败则返回-1
                    rcv_buff[bytesread+1]='\0';        /* 设定字串终止字元, 所以我们能用 printf */
                    printf("%s，%d\n",rcv_buff, bytesread);
                    if (rcv_buff[0]=='z')
                                STOP=TRUE;
        }

                     
        if(close(fd)!=0)
        {
                printf("close device %s error",*dev);
        }
        return;
}　

mayanjun

while (STOP==FALSE)
{
bytesread =read(fd,rcv_buff,8 ) ; //读操作成功读取返回读取的字节数，失败则返回-1 此處讀了8個？？
rcv_buff[bytesread+1]='\0'; /* 设定字串终止字元, 所以我们能用 printf */如果再寫\0是不是9個了？？？超範圍了
printf("%s，%d\n",rcv_buff, bytesread);
if (rcv_buff[0]=='z')
STOP=TRUE;
}

MyForever

引用于：www.2beanet.com
A Linux serial port test program


Below is a Linux serial test program which requires the command parameters to be entered on the command line when the program is started. This program will send output typed on the computer keyboard after the program is started, through the serial port specified.

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

复制代码

An example invocation of this program
This program will allow a user to communicate from one computer to another using two serial lines. It is intended only as a test for the serial connection allowing any possible serial setting. This program is named com when compiled. To use it, the following is an example command line:

1. 
   
2. com /dev/ttyS0 38400 8 1 0 4
   

复制代码

This line works for com1 at 38400 baud, 8 data bits. I make it a file, call it "fcom1" and put it in my system path and invoke it as a script program.