急！！！！！！TQ2440 linux下使用串口扩展模块循环读取数据失败

我现在在做一个CC2430通信实验。两个CC2430分别连上PC机，使用串口调试助手完全正常。
但是若是我用一个CC2430连上PC机，串口助手自动写入数据发送，
然后另外一个CC2430连上TQ2440的串口扩展模块的COM3口，如此做通信实验时，出现一个现象：
TQ2440写串口数据，PC机端串口助手显示另外一个CC2430接收正常，但是TQ2440反复读取数据时，只能读取几次数据而已（read函数此后返回的字节数都是0）。下面是代码，望各位大侠帮忙解决，急！！！！！

1. serial_test.h
   
2. #define FALSE                0
   
3. #define TRUE                1
   
4. 
   
5. #define WORDLEN                32                //其他名称长度32字节（16个汉字）
   
6. 
   
7. struct serial_config
   
8. {
   
9.         unsigned char serial_dev[WORDLEN];
   
10.         unsigned int serial_speed;
    
11.         unsigned char databits;
    
12.         unsigned char stopbits;
    
13.         unsigned char parity;
    
14. };

复制代码

1. serial_test.c
   
2. #include <sys/types.h>
   
3. #include <sys/stat.h>
   
4. #include <fcntl.h>
   
5. #include <termios.h>
   
6. #include <errno.h>
   
7. #include <ctype.h>
   
8. #include <stdio.h>
   
9. #include <stdlib.h>
   
10. #include <string.h>
    
11. #include <time.h>
    
12. #include <unistd.h>
    
13. #include"pthread.h"
    
14. 
    
15. #include "serial_test.h"
    
16. 
    
17. 
    
18. struct serial_config serialread;
    
19. 
    
20. static int serial_fd,beep_fd;
    
21. 
    
22. int speed_arr[] = {B230400, B115200, B57600, B38400, B19200, B9600, B4800, B2400, B1200, B300,
    
23.                    B38400, B19200, B9600, B4800, B2400, B1200, B300};
    
24. 
    
25. int name_arr[] = {230400, 115200, 57600, 38400, 19200, 9600, 4800, 2400, 1200, 300,
    
26.                   38400, 19200, 9600, 4800, 2400, 1200, 300};
    
27. 
    
28. //-----------------------------------------------
    
29. //打印配置文件tq2440_serial.cfg的内容
    
30. //-----------------------------------------------
    
31. void print_serialread()
    
32. {
    
33.         printf("serialread.dev is %s\n",serialread.serial_dev);
    
34.         printf("serialread.speed is %d\n",serialread.serial_speed);
    
35.         printf("serialread.databits is %d\n",serialread.databits);
    
36.         printf("serialread.stopbits is %d\n",serialread.stopbits);
    
37.         printf("serialread.parity is %c\n",serialread.parity);
    
38. }
    
39. 
    
40. //-----------------------------------------------
    
41. //读取tq2440_serial.cfg文件并进行配置
    
42. //-----------------------------------------------
    
43. void readserialcfg()
    
44. {
    
45.         FILE *serial_fp;
    
46.         char j[10];
    
47.        
    
48.         printf("readserailcfg\n");
    
49. 
    
50.         serial_fp = fopen("/etc/tq2440_serial.cfg","r");
    
51.         if(NULL == serial_fp)
    
52.         {
    
53.                 printf("can't open /etc/tq2440_serial.cfg");
    
54.         }
    
55.         else
    
56.         {
    
57.                 fscanf(serial_fp, "DEV=%s\n", serialread.serial_dev);
    
58. 
    
59.                 fscanf(serial_fp, "SPEED=%s\n", j);
    
60.                 serialread.serial_speed = atoi(j);
    
61. 
    
62.                 fscanf(serial_fp, "DATABITS=%s\n", j);
    
63.                 serialread.databits = atoi(j);
    
64. 
    
65.                 fscanf(serial_fp, "STOPBITS=%s\n", j);
    
66.                 serialread.stopbits = atoi(j);
    
67. 
    
68.                 fscanf(serial_fp, "PARITY=%s\n", j);
    
69.                 serialread.parity = j[0];
    
70.         }
    
71. 
    
72.         fclose(serial_fp);
    
73. }
    
74. 
    
75. //-----------------------------------------------
    
76. //设置波特率
    
77. //-----------------------------------------------
    
78. void set_speed(int fd)
    
79. {
    
80.         int i;
    
81.         int status;
    
82.         struct termios Opt;
    
83.         struct termios oldOpt;
    
84.         tcgetattr(fd, &oldOpt);
    
85. //        printf("serialread.speed is %d\n",serialread.serial_speed);
    
86.         for( i = 0; i < sizeof(speed_arr)/sizeof(int); i++)
    
87.         {
    
88.                 if(serialread.serial_speed == name_arr[i])
    
89.                 {
    
90.                         tcflush(fd, TCIOFLUSH);
    
91.                         cfsetispeed(&Opt, speed_arr[i]);
    
92.                         cfsetospeed(&Opt, speed_arr[i]);
    
93.                         status = tcsetattr(fd, TCSANOW, &Opt);
    
94.                         if(status != 0)
    
95.                         {
    
96.                                 perror("tcsetattr fd1");
    
97.                                 return;
    
98.                         }
    
99.                         tcflush(fd, TCIOFLUSH);
    
100.                 }
     
101.         }
     
102. }
     
103. 
     
104. 
     
105. //-----------------------------------------------
     
106. //设置其他参数
     
107. //-----------------------------------------------
     
108. int set_Parity(int fd)
     
109. {
     
110.         struct termios options;
     
111.         struct termios oldoptions;
     
112.         if(tcgetattr(fd, &oldoptions) != 0)
     
113.         {
     
114.                 perror("SetupSerial 1");
     
115.                 return(FALSE);
     
116.         }
     
117. 
     
118.         options.c_cflag |= (CLOCAL|CREAD);
     
119.         options.c_cflag &=~CSIZE;
     
120. //        printf("serialread.databits is %d\n",serialread.databits);
     
121.         switch(serialread.databits)
     
122.         {
     
123.                 case 7:
     
124.                         options.c_cflag |= CS7;
     
125.                         break;
     
126.                 case 8:
     
127.                         options.c_cflag |= CS8;
     
128.                         break;
     
129.                 default:
     
130.                         options.c_cflag |= CS8;
     
131.                         fprintf(stderr, "Unsupported data size\n");
     
132.                         return(FALSE);
     
133.         }
     
134. //        printf("serialread.parity is %c\n",serialread.parity);
     
135.         switch(serialread.parity)
     
136.         {
     
137.                 case 'n':
     
138.                 case 'N':
     
139.                         options.c_cflag &= ~PARENB;
     
140.                         options.c_iflag &= ~INPCK;
     
141.                         break;
     
142.                 case 'o':
     
143.                 case 'O':
     
144.                         options.c_cflag |= (PARODD | PARENB);
     
145.                         options.c_iflag |= INPCK;
     
146.                         break;
     
147.                 case 'e':
     
148.                 case 'E':
     
149.                         options.c_cflag |= PARENB;
     
150.                         options.c_cflag &= ~PARODD;
     
151.                         options.c_iflag |= INPCK;
     
152.                         break;
     
153.                 default:
     
154.                         options.c_cflag &= ~PARENB;
     
155.                         options.c_iflag &= ~INPCK;
     
156.                         fprintf(stderr, "Unsupported parity\n");
     
157.                         return(FALSE);
     
158.         }
     
159. //        printf("serialread.stopbits is %d\n",serialread.stopbits);
     
160.         switch(serialread.stopbits)
     
161.         {
     
162.                 case 1:
     
163.                         options.c_cflag &= ~CSTOPB;
     
164.                         break;
     
165.                 case 2:
     
166.                         options.c_cflag |= CSTOPB;
     
167.                         break;
     
168.                 default:
     
169.                         options.c_cflag &= ~CSTOPB;
     
170.                         fprintf(stderr, "Unsupported stop bits\n");
     
171.                         return(FALSE);
     
172.         }
     
173.         if(serialread.parity != 'n')
     
174.                 options.c_iflag |= INPCK;
     
175.         options.c_cc[VTIME] = 150;        //150;                        //15 seconds
     
176.         options.c_cc[VMIN] = 0;
     
177. #if 1
     
178.         options.c_iflag |= IGNPAR|ICRNL;
     
179.         options.c_oflag |= OPOST;
     
180.         //options.c_iflag &= ~(IXON|IXOFF|IXANY);                     
     
181.         options.c_iflag |= IXOFF|IXON;
     
182. #endif
     
183.         tcflush(fd, TCIFLUSH);
     
184.         if(tcsetattr(fd, TCSANOW, &options) != 0)
     
185.         {
     
186.                 perror("SetupSerial 3");
     
187.                 return(FALSE);
     
188.         }
     
189.         return(TRUE);
     
190. }
     
191. 
     
192. //-----------------------------------------------
     
193. //打开串口设备
     
194. //-----------------------------------------------
     
195. int OpenDev(char *Dev)
     
196. {
     
197.         int fd = open(Dev, O_RDWR);
     
198.         if(-1 == fd)
     
199.         {
     
200.                 perror("Can't Open Serial Port");
     
201.                 return -1;
     
202.         }
     
203.         else
     
204.                 return fd;
     
205. }
     
206. 
     
207. //--------------------------------------------------
     
208. //串口初始化
     
209. //--------------------------------------------------
     
210. void serial_init(void)
     
211. {
     
212.         char *Dev;
     
213. 
     
214.         int i;
     
215. 
     
216.         readserialcfg();
     
217.         print_serialread();
     
218. 
     
219.         Dev = serialread.serial_dev;
     
220.         //打开串口设备
     
221.         serial_fd = OpenDev(Dev);
     
222. 
     
223.         if(serial_fd > 0)
     
224.                 set_speed(serial_fd);                //设置波特率
     
225.         else
     
226.         {
     
227.                 printf("Can't Open Serial Port!\n");
     
228.                 exit(0);
     
229.         }
     
230.         //恢复串口未阻塞状态
     
231.         /*if(fcntl(serial_fd,F_SETFL,0)<0)        */
     
232.         if (fcntl(serial_fd, F_SETFL, fcntl(serial_fd,F_GETFL,0) | O_NONBLOCK) < 0)
     
233.         {
     
234.                 printf("fcntl failed!\n");
     
235.                 exit(0);
     
236.         }
     
237.         //检查是否是终端设备
     
238. #if 1        //如果屏蔽下面这段代码，在串口输入时不会有回显的情况，调用下面这段代码时会出现回显现象。
     
239.         if(isatty(STDIN_FILENO)==0)
     
240.         {
     
241.                 printf("standard input is not a terminal device\n");
     
242.         }
     
243.         else
     
244.                 printf("isatty success!\n");
     
245. #endif
     
246.         //设置串口参数
     
247.         if(set_Parity(serial_fd) == FALSE)
     
248.         {
     
249.                 printf("Set parity Error\n");
     
250.                 exit(1);
     
251.         }
     
252. 
     
253. }
     
254. 
     
255. int read_data(int fd, void *buf, int len)
     
256. {
     
257.     int count;
     
258.     int ret;
     
259. 
     
260.     ret = 0;
     
261.     count = 0;
     
262. 
     
263.     //while (len > 0) {
     
264. 
     
265. 
     
266.     ret = read(fd, (char*)buf + count, len);
     
267.     if (ret < 0) {
     
268.         fprintf(stderr, "Read error %s\n", strerror(errno));
     
269.         //break;
     
270. 
     
271.     }
     
272. 
     
273.     count += ret;
     
274.     len = len - ret;
     
275. 
     
276.     //}
     
277. 
     
278. 
     
279.     *((char*)buf + count) = 0;
     
280.     return count;
     
281. }
     
282. 
     
283. 
     
284. int write_data(int fd, void *buf, int len)
     
285. {
     
286.     int count;
     
287.     int ret;
     
288. 
     
289.     ret = 0;
     
290.     count = 0;
     
291. 
     
292.     while (len > 0) {
     
293. 
     
294.         ret = write(fd, (char*)buf + count, len);
     
295.         if (ret < 1) {
     
296.             fprintf(stderr, "Write error %s\n", strerror(errno));
     
297.             break;
     
298.         }
     
299. 
     
300.         count += ret;
     
301.         len = len - ret;
     
302.     }
     
303. 
     
304.     return count;
     
305. }
     
306. 
     
307. void serial_rw()
     
308. {
     
309.         int i=0;
     
310.         char buff[512];
     
311.         char buff2[]="hello,TQ2440!\n";
     
312.         int nread,nwrite;
     
313.         struct timeval tv;
     
314.         fd_set rfds;
     
315.        
     
316.         tv.tv_sec=0;
     
317.         tv.tv_usec=30;
     
318.        
     
319.         nwrite=write_data(serial_fd,buff2,sizeof(buff2));
     
320.         printf("nwrite=%d\n",nwrite);
     
321.         while(1){
     
322.                 printf("waiting........!\n");
     
323.                 /*if (fcntl(serial_fd, F_SETFL, fcntl(serial_fd,F_GETFL,0) | O_NONBLOCK) < 0)
     
324.                 {
     
325.                         printf("fcntl failed!\n");
     
326.                         exit(0);
     
327.                 }
     
328.                 nread=read_data(serial_fd,buff,50);
     
329.                 printf("readlength=%d\n",nread);
     
330.                 buff[nread]='\0';
     
331.                 printf("%s\n",buff);
     
332.                 sleep(2);*/
     
333.                
     
334.                 FD_ZERO(&rfds);
     
335.                 FD_SET(serial_fd,&rfds);
     
336.                 if(select(serial_fd+1,&rfds,NULL,NULL,&tv)>0)
     
337.                 {
     
338.                         printf("enter select()!\n");
     
339.                         if(FD_ISSET(serial_fd,&rfds))
     
340.                         {
     
341.                                 printf("reading!\n");
     
342.                                 nread=read_data(serial_fd,buff,10);
     
343.                                 printf("readlength=%d\n",nread);
     
344.                        
     
345.                                 printf("i=%d\n",++i);
     
346.                                 buff[nread]='\0';
     
347.                                 printf("%s\n",buff);
     
348.                                 memset(buff,'\0',sizeof(buff));
     
349.                                 //tcflush(serial_fd, TCIFLUSH);
     
350.                         }
     
351.                
     
352.                 }
     
353.                 sleep(2);               
     
354.                
     
355.         }
     
356.         close(serial_fd);
     
357. 
     
358. }
     
359. 
     
360. int main(int argc, char **argv)
     
361. {
     
362.         serial_init();
     
363.         serial_rw();       
     
364.         return 0;
     
365. //        close(serialread.serial_dev);
     
366. //        serial_test(telnum, telmoney);
     
367. }
     

复制代码

如下是运行效果：
readserailcfg
serialread.dev is /dev/tq2440_serial2
serialread.speed is 38400
serialread.databits is 8
serialread.stopbits is 1
serialread.parity is N
isatty success!
nwrite=15
waiting........!
waiting........!
enter select()!
reading!
readlength=128
i=1
98745698745698745698745698745698745698745698745698745698745698745698745698745698745698745698745698745698745698745698745698745698
waiting........!
waiting........!
waiting........!
waiting........!

怎么没有人回复啊！！！！！

tv.tv_sec=0;
        tv.tv_usec=30;
你把这个超时加长些看看

这样也没有用！我试过的