关于串口的问题

asert

我的测试环境是用PC的串口和另一台嵌入设备通信，我发送多少数据它就完整的返回多少数据；
现在出现的问题每向串口write几十次数据都会有一次write不成功，不成功的几率在%2;而且在write不成功时,write函数也不会返回错误值，这样我的程序就无法知道这次write是否成功了.
不知为什么会有这样的问题，该如何解决这个问题呢？哪位大虾能提供一点帮助

1. 
   
2. #include <stdio.h>  /*标准输入输出定义*/
   
3. #include <stdlib.h>  /*标准函数库定义*/
   
4. #include <string.h>
   
5. #include <unistd.h>  /*Unix 标准函数定义*/
   
6. #include <sys/types.h>
   
7. #include <sys/stat.h>
   
8. #include <fcntl.h>  /*文件控制定义*/
   
9. #include <errno.h>  /*错误号定义*/
   
10. #include <sys/ioctl.h>
    
11. #include <signal.h>
    
12. #include <termios.h>  /*PPSIX 终端控制定义*/
    
13. //
    
14. // 串口设备信息结构
    
15. //
    
16. typedef struct tty_info_t {
    
17.         int     fd;    // 串口设备ID
    
18.         char     name[24];  // 串口设备名称，例："/dev/ttyS0"
    
19.         struct termios  ntm;   // 新的串口设备选项
    
20.         struct termios  otm;   // 旧的串口设备选项
    
21. }
    
22. TTY_INFO;
    
23. 
    
24. ///////////////////////////////////////////////////////////////////////////////
    
25. // 初始化串口设备并进行原有设置的保存
    
26. TTY_INFO *readyTTY(int id) {
    
27.         TTY_INFO *ptty;
    
28. 
    
29.         ptty = (TTY_INFO *)malloc(sizeof(TTY_INFO));
    
30.         if(ptty == NULL)
    
31.                 return NULL;
    
32.         memset(ptty,0,sizeof(TTY_INFO));
    
33.         sprintf(ptty->name,"/dev/ttyS%d",id);
    
34. //
    
35. // 打开并且设置串口
    
36. //
    
37.         ptty->fd = open(ptty->name, O_RDWR | O_NOCTTY |O_NDELAY);
    
38.         if (ptty->fd <0) {
    
39.                 free(ptty);
    
40.                 return NULL;
    
41.         }
    
42. //
    
43. // 取得并且保存原来的设置
    
44. //
    
45.         tcgetattr(ptty->fd,&ptty->otm);
    
46.         return ptty;
    
47. }
    
48. 
    
49. ///////////////////////////////////////////////////////////////////////////////
    
50. // 清理串口设备资源
    
51. int cleanTTY(TTY_INFO *ptty) {
    
52. //
    
53. // 关闭打开的串口设备
    
54. //
    
55.         if(ptty->fd>0) {
    
56.                 tcsetattr(ptty->fd,TCSANOW,&ptty->otm);
    
57.                 close(ptty->fd);
    
58.                 ptty->fd = -1;
    
59.                 free(ptty);
    
60.                 ptty = NULL;
    
61.         }
    
62. 
    
63.         return 0;
    
64. }
    
65. 
    
66. int total_read = 0;
    
67. 
    
68. size_t readn(int fd,void *vptr,size_t len) {
    
69.         int nleft,nread;
    
70.         char *ptr;
    
71. 
    
72.         ptr = vptr;
    
73.         nleft = len;
    
74. 
    
75.         while(nleft > 0) {
    
76.                 ioctl(fd, FIONREAD, &nread);
    
77.                 if(nread > 0) {
    
78.                         if((nread = read(fd,ptr,nleft)) < 0) {
    
79.                                 if(errno == EINTR)
    
80.                                         nread = 0;
    
81.                                 else
    
82.                                         return -1;
    
83.                         } else if(nread == 0)
    
84.                                 break;
    
85. 
    
86.                         nleft-= nread;
    
87.                         ptr += nread;
    
88.                         printf("read %d bytes\n",nread);
    
89.                         total_read += nread;
    
90.                 } else {
    
91.                         usleep(100);
    
92.                 }
    
93.         }
    
94.         return len - nleft;
    
95. }
    
96. 
    
97. size_t writen(int fd,const void *vptr,size_t len) {
    
98.         int n;
    
99.         size_t left = len;
    
100.         const void *ptr = vptr;
     
101.         int i;
     
102. 
     
103.         for(i = 0; i < len; i++) {
     
104.                 unsigned char *c = (char *)(vptr + i);
     
105.                 printf("%x ",*c);
     
106.         }
     
107.         while(left > 0) {
     
108.                 if((n = write(fd,ptr,len)) > 0) {
     
109.                         left -= n;
     
110.                         ptr += n;
     
111.                 }
     
112.                 if(n < 0 && errno != EINTR) {
     
113.                         return -1;
     
114.                 }
     
115.         }
     
116.         return len;
     
117. }
     
118. 
     
119. static int setTTYArbitraryAttrib(TTY_INFO *ptty) {
     
120.         struct termios *newtio = &ptty->ntm;
     
121.        
     
122.         if(tcgetattr(ptty->fd,newtio) != 0) {
     
123.                 perror("tcgetattr");
     
124.                 return -1;
     
125.         }
     
126.        
     
127.         bzero(newtio,sizeof(struct termios));
     
128.         newtio->c_cflag &=~CSIZE;
     
129.         newtio->c_cflag |= CS8; //8位数据位
     
130. 
     
131.         newtio->c_cflag &= ~PARENB; /* Clear parity enable */
     
132.         newtio->c_iflag &= ~INPCK; /* Enable parity checking */
     
133. 
     
134.         newtio->c_cflag &= ~CSTOPB;
     
135. 
     
136.         newtio->c_cc[VTIME] = 0;
     
137.         newtio->c_cc[VMIN] = 1;
     
138.         newtio->c_cflag |= (CLOCAL|CREAD);
     
139.         newtio->c_cflag |= CLOCAL | CREAD;
     
140.         newtio->c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
     
141.         newtio->c_oflag &= ~OPOST;
     
142.         newtio->c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
     
143. 
     
144.         cfsetispeed(newtio,B9600);
     
145.         cfsetospeed(newtio,B9600);
     
146.         tcflush(ptty->fd,TCIFLUSH);
     
147.         if(tcsetattr(ptty->fd,TCSANOW,newtio) != 0) {
     
148.                 perror("tcsetattr");
     
149.                 return -1;
     
150.         }
     
151.         return 0;
     
152. }
     
153. 
     
154. static void sig_int(int n) {
     
155.         printf("total_read:%d\n",total_read);
     
156.         exit(0);
     
157. }
     
158. 
     
159. int main(int argc,char **argv) {
     
160.         TTY_INFO *ptty;
     
161.         int nbyte,i;
     
162.         char send_buf[] = {
     
163.                             0xFF,0xFF,0xFF,0xFF,
     
164.                             0x11,0x11,
     
165.                             0x22,
     
166.                             0x00,0x01,
     
167.                             0x05,
     
168.                             0x00,
     
169.                             0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
     
170.                             0x05,
     
171.                             0x53,0x02,0x02,0x01,0x01,
     
172.                             0x03
     
173.                           };
     
174. 
     
175. 
     
176.         char recv_buf[26];
     
177. 
     
178.         signal(SIGINT,sig_int);
     
179.         ptty = readyTTY(0);
     
180.         if(ptty == NULL) {
     
181.                 printf("readyTTY(0)  error\n");
     
182.                 return 1;
     
183.         }
     
184. 
     
185.         setTTYArbitraryAttrib(ptty);
     
186.         while(1) {
     
187.                 if(writen(ptty->fd,send_buf,sizeof(send_buf)) < 0) {
     
188.                         printf("writen failed\n");
     
189.                         return -1;
     
190.                 } else {
     
191.                         printf("writen successfully\n");
     
192.                 }
     
193. 
     
194.                 nbyte = readn(ptty->fd,recv_buf,sizeof(recv_buf));
     
195.                 if(nbyte < 0) {
     
196.                         perror("readn");
     
197.                         return -1;
     
198.                 }
     
199. 
     
200.                 for(i = 0; i < nbyte; i++) {
     
201.                         unsigned char c = recv_buf[i];
     
202.                         printf("%x ",c);
     
203.                 }
     
204.                 printf("\n");
     
205.         }
     
206.         cleanTTY(ptty);
     
207.         return 0;
     
208. }
     

复制代码

windwiny

无限循环？  速率太快了吧

minuet

是程序循环比硬件发送快，导致发送缓冲区满，继续write将丢失数据。linux可以通过ioctl(fd,FIONREAD,&noread)来获取接收缓冲区内字节数，却没有ioctl(fd,FIONWRITE,&nowrite)获取发送缓冲区内字节数，而vxWorks是有的！很不方便，现在我是write完后usleep固定延时的，但总觉得不好！希望大侠能提供帮助！

asert

Post by minuet
是程序循环比硬件发送快，导致发送缓冲区满，继续write将丢失数据。linux可以通过ioctl(fd,FIONREAD,&noread)来获取接收缓冲区内字节数，却没有ioctl(fd,FIONWRITE,&nowrite)获取发送缓冲区内字节数，而vxWorks是有的！很不方便，现在我是write完后usleep固定延时的，但总觉得不好！希望大侠能提供帮助！

我现在的解决方式是每写1个字节睡眠100微妙，这样才能保证串口输出的稳定,我看了cutecom的源代码，它是默认每写1个字节睡眠1毫妙