串口读不到数据问题?（很紧急！！）

hacktao

用GPRS做开发，写好程序后放到arm板子上跑，打电话的功能都能实现，就是收不到任何信息，别人打电话给我，或是发短信给我，我收不到任何数据
调试了好久没弄好，我实在没办法了，这个项目要交了，各位大哥，朋友帮帮忙啊！
    串口问题：能发信息，收不到信息.


    我直接贴我串口的代码，大家看看那里有问题！

   #include "serial.h"

MySerial::MySerial( )
{
}

MySerial::~MySerial()
{

}
//这里是设置串口参数
int MySerial::set_opt(int fd,int nSpeed, int nBits, char nEvent, int nStop)
{
        struct termios newtio,oldtio;
        if  ( tcgetattr( fd,&oldtio)  !=  0) {
                perror("SetupSerial 1";
                return -1;
        }
        bzero( &newtio, sizeof( newtio ) );
        newtio.c_cflag  |=  CLOCAL | CREAD;
        newtio.c_cflag &= ~CSIZE;
//        newtio.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
//        newtio.c_oflag &= ~OPOST;
        switch( nBits )
        {
        case 7:
                newtio.c_cflag |= CS7;
                break;
        case 8:
                newtio.c_cflag |= CS8;
                break;
        }

        switch( nEvent )
        {
        case 'O':
                newtio.c_cflag |= PARENB;
                newtio.c_cflag |= PARODD;
                newtio.c_iflag |= (INPCK | ISTRIP);
                break;
        case 'E':
                newtio.c_iflag |= (INPCK | ISTRIP);
                newtio.c_cflag |= PARENB;
                newtio.c_cflag &= ~PARODD;
                break;
        case 'N':
                newtio.c_cflag &= ~PARENB;
                break;
        }

        switch( nSpeed )
        {
        case 2400:
                cfsetispeed(&newtio, B2400);
                cfsetospeed(&newtio, B2400);
                break;
        case 4800:
                cfsetispeed(&newtio, B4800);
                cfsetospeed(&newtio, B4800);
                break;
        case 9600:
                cfsetispeed(&newtio, B9600);
                cfsetospeed(&newtio, B9600);
                break;
        case 115200:
                cfsetispeed(&newtio, B115200);
                cfsetospeed(&newtio, B115200);
                break;
        default:
                cfsetispeed(&newtio, B9600);
                cfsetospeed(&newtio, B9600);
                break;
        }
        if( nStop == 1 )
                newtio.c_cflag &=  ~CSTOPB;
        else if ( nStop == 2 )
        newtio.c_cflag |=  CSTOPB;
        newtio.c_cc[VTIME]  = 0;
        newtio.c_cc[VMIN] = 0;
        tcflush(fd,TCIFLUSH);
        if((tcsetattr(fd,TCSANOW,&newtio))!=0)
        {
                perror("com set error";
                return -1;
        }
        return 0;
}
//这里是打开串口
int MySerial:pen_port(int fd,int comport)
{
        if (comport==1)
        {        fd = open( "/dev/ttyS0", O_RDWR|O_NOCTTY|O_NDELAY);
                if (-1 == fd){
                        perror("Can't Open Serial /dev/ttyS0 Port";
                        return(-1);
                }
        }
        else if(comport==2)
        {        fd = open( "/dev/ttyS1", O_RDWR|O_NOCTTY|O_NDELAY);
                if (-1 == fd){
                        perror("Can't Open Serial /dev/ttyS1 Port";
                        return(-1);
                }
        }
        else if (comport==3)
        {
                fd = open( "/dev/ttyS2", O_RDWR|O_NOCTTY|O_NDELAY);
                if (-1 == fd){
                        perror("Can't Open Serial /dev/ttyS2 Port";
                        return(-1);
                }
        }
        if(fcntl(fd, F_SETFL, 0)<0)
                perror("fcntl failed!";
        if(isatty(STDIN_FILENO)==0)
                perror("standard input is not a terminal device";
        return fd;
}


大家看看上面那里有问题，
我是这个样子读数据的
if(read(fd,buff,sizeof(buff))!=0)
{
  .......
}


大家帮帮忙啊，谢谢！分不够的话我再送啊！

T-Bagwell

原帖由 hacktao 于 2009-12-9 10:32 发表
谢谢T-Bagwell !我看看这个程序！

肯定好使
不过我这个程序有bug
仅供参考
直接把分给我吧

T-Bagwell

每次读串口数据的时候最好间隔一小段时间，因为串口数据传输肯定没有咱们的程序的指令跑的快

hacktao

我用了一个定时器，
定时一段时间读取一次。
qt程序：

TimerRead = new QTimer;

TimerRead->start(200);
QObject::connect( TimerRead, SIGNAL(timeout()), this, SLOT(read_timeout_slot()) );  //read_timeout_slot里面包含了read的函数。

然后我在read_timeout_slot
里这样写的：
void MainWindow::read_timeout_slot()
｛
     TimerRead->stop();
。。。。。。。。。。。。。。。。。
。。。。。。。。。。。。。。。。

  if(read(fd,buff,sizeof(buff))!=0)
{
  .......
}
。。。。。。。。。。。。。。。。。。

     TimerRead->start(200);
｝
我觉得是不是自己的串口程序写的不好，写都可以，读确不行，想不明白～～

T-Bagwell

1. 
   
2. int set_sms_text_mode()
   
3. {
   
4.         int ret=0;
   
5.         int i;
   
6.         char *send_buf,recv_buf[BUFFER_SIZE];
   
7. 
   
8.         send_buf="AT+CMGF=1\r\0";
   
9. 
   
10.         for (i=0;i<RETRY;i++)
    
11.         {
    
12.                 usleep(5000);
    
13.                 ret=serial_recv(send_buf,strlen(send_buf),recv_buf,5,0,1,0);
    
14.                 if (ret<0)
    
15.                 {
    
16.                         printf("AT+CMGF:SERIAL SEND AND RECEIVE ERROR!\n");
    
17.                         return SETSMSTEXTMODE_ERR;
    
18.                 }
    
19.                 else
    
20.                 {
    
21.                         if (check_OK(recv_buf,ret)==0)
    
22.                                 return 0;
    
23.                 }
    
24.         }
    
25.         return SETSMSTEXTMODE_ERR;
    
26. }
    
27. 
    
28. int sms_send (unsigned char *sms_des,unsigned char *sms_content)
    
29. {
    
30.         int ret=0;
    
31.         int i;
    
32.         char send_buf[BUFFER_SIZE],recv_buf[BUFFER_SIZE],content_buf[BUFFER_SIZE];
    
33.         char *des_head="AT+CMGS=";
    
34.         char *des_tail="\r\0";
    
35.         char content_tail[2]={0x1a,0x0};
    
36. 
    
37.         memcpy (send_buf, des_head, strlen(des_head));
    
38.         memcpy (send_buf+strlen(des_head), sms_des, strlen(sms_des));
    
39.         memcpy (send_buf+strlen(des_head)+strlen(sms_des),des_tail,strlen(des_tail)+1);
    
40. 
    
41.         memcpy (content_buf,sms_content,strlen(sms_content));
    
42.         memcpy (content_buf+strlen(sms_content),content_tail,strlen(content_tail)+1);
    
43. 
    
44.         for (i=0;i<RETRY;i++)
    
45.         {
    
46.                 usleep(5000);
    
47.                 while (serial_busy) usleep(1);
    
48.                 serial_busy=1;
    
49.                 ret=serial_send_recv(send_buf,strlen(send_buf),content_buf,strlen(content_buf),recv_buf,20,0,5,0);
    
50.                 serial_busy=0;
    
51.                 if (ret<0)
    
52.                 {
    
53.                         printf("AT+CMGS:SERIAL SEND AND RECEIVE ERROR!\n");
    
54.                         return SMSSEND_ERR;
    
55.                 }
    
56.                 else
    
57.                 {
    
58.                         if (check_OK(recv_buf,ret)==0)
    
59.                                 return 0;
    
60.                 }
    
61.         }
    
62.         return SMSSEND_ERR;
    
63. }
    
64. 
    
65. int check_cmgl(unsigned char *recv_buf,unsigned int recv_buf_len)
    
66. {
    
67.         int i,j,ret;
    
68.         unsigned int head=0;
    
69.         unsigned int tail=0;
    
70.         ret=0;
    
71.         i=0;
    
72.         while (i<recv_buf_len)
    
73.         {
    
74.                 if ((recv_buf[i]=='+')&&
    
75.                         (recv_buf[i+1]=='C')&&
    
76.                         (recv_buf[i+2]=='M')&&
    
77.                         (recv_buf[i+3]=='G')&&
    
78.                         (recv_buf[i+4]=='L')&&
    
79.                         (recv_buf[i+5]==':')&&
    
80.                         (recv_buf[i+6]==0x20))
    
81.                 {
    
82.                         head=i+7;
    
83.                         for(j=head;j<recv_buf_len;j++)
    
84.                         {
    
85.                                 if(recv_buf[j]==',')
    
86.                                 {
    
87.                                         tail=j;
    
88.                                         break;
    
89.                                 }
    
90.                         }
    
91.                         memcpy (sms[ret].pos,recv_buf+head,(tail-head));
    
92.                         sms[ret].pos[tail-head]='\0';
    
93.                         head=tail+2;
    
94.                         for(j=head;j<recv_buf_len;j++)
    
95.                         {
    
96.                                 if(recv_buf[j]=='"')
    
97.                                 {
    
98.                                         tail=j;
    
99.                                         break;
    
100.                                 }
     
101.                         };
     
102.                         memcpy (sms[ret].read_flag,recv_buf+head,(tail-head));
     
103.                         sms[ret].read_flag[tail-head]='\0';
     
104.                         head=tail+3;
     
105.                         for(j=head;j<recv_buf_len;j++)
     
106.                         {
     
107.                                 if(recv_buf[j]=='"')
     
108.                                 {
     
109.                                         tail=j;
     
110.                                         break;
     
111.                                 }
     
112.                         }
     
113.                         memcpy (sms[ret].sms_from,recv_buf+head,(tail-head));
     
114.                         sms[ret].sms_from[tail-head]='\0';
     
115.                         head=tail+4;
     
116.                         for (j=head;j<recv_buf_len;j++)
     
117.                         {
     
118.                                 if(recv_buf[j]=='"')
     
119.                                 {
     
120.                                         tail=j;
     
121.                                         break;
     
122.                                 }
     
123.                         }
     
124.                         memcpy (sms[ret].recv_time,recv_buf+head,(tail-head));
     
125.                         sms[ret].recv_time[tail-head]='\0';
     
126.                         head=tail+3;
     
127.                         for (j=head;j<recv_buf_len;j++)
     
128.                         {
     
129.                                 if(recv_buf[j]=='\r')
     
130.                                 {
     
131.                                         tail=j;
     
132.                                         break;
     
133.                                 }
     
134.                         }
     
135.                         memcpy (sms[ret].sms_content,recv_buf+head,(tail-head));
     
136.                         sms[ret].sms_content[tail-head]='\0';
     
137.                         sms[ret].flag=1;
     
138.                         i=tail;
     
139.                         ret++;
     
140.                 }
     
141.                 else i++;
     
142.         }
     
143.         return ret;
     
144. }
     

复制代码

1. 
   
2. #include <stdio.h>     
   
3. #include <stdlib.h>   
   
4. #include <unistd.h>
   
5. #include <sys/types.h>  
   
6. #include <sys/stat.h>   
   
7. #include <fcntl.h>     
   
8. #include <termios.h>   
   
9. #include <errno.h>     
   
10. #include <string.h>
    
11. 
    
12. #include "serial_receive.h"
    
13. 
    
14. #define DEBUG 0
    
15. 
    
16. void setTermios(struct termios * pNewtio, U16 uBaudRate)
    
17. {
    
18.         bzero(pNewtio, sizeof(struct termios)); /* clear struct for new port settings */
    
19. 
    
20.         //8N1
    
21.         pNewtio->c_cflag = uBaudRate | CS8 |  CREAD | CLOCAL;
    
22.         pNewtio->c_iflag = IGNPAR;
    
23.                
    
24.         pNewtio->c_oflag = 0;
    
25.         pNewtio->c_lflag = 0; //non ICANON
    
26. 
    
27.         pNewtio->c_cc[VINTR]    = 0;
    
28.         pNewtio->c_cc[VQUIT]    = 0;
    
29.         pNewtio->c_cc[VERASE]   = 0;  
    
30.         pNewtio->c_cc[VKILL]    = 0;
    
31.         pNewtio->c_cc[VEOF]     = 4;
    
32.         pNewtio->c_cc[VTIME]    = 5;
    
33.         pNewtio->c_cc[VMIN]     = 0;
    
34.         pNewtio->c_cc[VSWTC]    = 0;
    
35.         pNewtio->c_cc[VSTART]   = 0;
    
36.         pNewtio->c_cc[VSTOP]    = 0;
    
37.         pNewtio->c_cc[VSUSP]    = 0;
    
38.         pNewtio->c_cc[VEOL]     = 0;
    
39.         pNewtio->c_cc[VREPRINT] = 0;
    
40.         pNewtio->c_cc[VDISCARD] = 0;
    
41.         pNewtio->c_cc[VWERASE]  = 0;
    
42.         pNewtio->c_cc[VLNEXT]   = 0;
    
43.         pNewtio->c_cc[VEOL2]    = 0;
    
44. }
    
45. 
    
46. 
    
47. int serial_recv(char *send_buf,int send_len,char *recv_buf,int timeout_s,int timeout_us,int wait_s,int wait_us)
    
48. {
    
49.         int fd;
    
50.         int nread=0;
    
51.         int nwrite=0;
    
52.         char buff[BUFSIZE];
    
53.         struct termios oldtio,newtio;
    
54.            struct timeval tv;
    
55.         char *dev ="/dev/tts/0";
    
56.         fd_set rfds;
    
57. 
    
58.         if ( (fd = open(dev,O_RDWR | O_NOCTTY ))<0)
    
59.         {
    
60.                 printf("Can't Open Serial Port!\n");
    
61.                 return -1;
    
62.         }
    
63. 
    
64.         tcgetattr(fd,&oldtio);
    
65.         setTermios(&newtio,B115200);         tcflush(fd, TCIFLUSH);
    
66.         tcsetattr(fd,TCSANOW,&newtio);
    
67. 
    
68.         tv.tv_sec=timeout_s;
    
69.         tv.tv_usec=timeout_us;
    
70. 
    
71.         nwrite=write(fd, send_buf, send_len);
    
72.         if(nwrite<send_len)
    
73.         {
    
74.                 printf("Serial Write error!\n");
    
75.                 return -1;
    
76.         }
    
77.         FD_ZERO(&rfds);
    
78.         FD_SET(fd,&rfds);
    
79.         if (select(1+fd,&rfds,NULL,NULL,&tv)>0)
    
80.         {
    
81.                 if(FD_ISSET(fd,&rfds))
    
82.                 {       
    
83.                         sleep(wait_s);
    
84.                         usleep(wait_us);
    
85.                         nread=read(fd, buff, BUFSIZE);
    
86.                         if(nread<0)
    
87.                         {       
    
88.                                 printf("serial read error!\n");
    
89.                                 return -1;
    
90.                         }
    
91.                         memcpy(recv_buf,buff,nread);
    
92.                 }
    
93.         }
    
94. #ifdef DEBUG
    
95.         buff[nread]='\0';
    
96.         printf("RECEIVED::%s\n",buff);
    
97. #endif
    
98.         tcsetattr(fd,TCSANOW,&oldtio);
    
99.         close(fd);
    
100.         return nread;
     
101. }
     
102. 
     
103. 
     
104. int serial_send_recv(char *send_buf,int send_len,char *send_content,int content_len,char *recv_buf,int timeout_s,int timeout_us,int wait_s,int wait_us)
     
105. {
     
106.         int fd;
     
107.         int nread=0;
     
108.         int nwrite=0;
     
109.         char buff[BUFSIZE];
     
110.         struct termios oldtio,newtio;
     
111.            struct timeval tv;
     
112.         char *dev ="/dev/tts/0";
     
113.         fd_set rfds;
     
114. 
     
115.         if ( (fd = open(dev,O_RDWR | O_NOCTTY ))<0)
     
116.         {
     
117.                 printf("Can't Open Serial Port!\n");
     
118.                 return -1;
     
119.         }
     
120.         tcgetattr(fd,&oldtio);
     
121.         setTermios(&newtio,B115200);         tcflush(fd, TCIFLUSH);
     
122.         tcsetattr(fd,TCSANOW,&newtio);
     
123. 
     
124.         tv.tv_sec=timeout_s;
     
125.         tv.tv_usec=timeout_us;
     
126.         nwrite=write(fd, send_buf, send_len);
     
127.         if(nwrite<send_len)
     
128.         {
     
129.                 printf("Serial Write error!\n");
     
130.                 return -1;
     
131.         }
     
132.         FD_ZERO(&rfds);
     
133.         FD_SET(fd,&rfds);
     
134.         if (select(1+fd,&rfds,NULL,NULL,&tv)>0)
     
135.         {
     
136.                 if(FD_ISSET(fd,&rfds))
     
137.                 {       
     
138.                         sleep(1);
     
139.                         usleep(wait_us);
     
140.                         nread=read(fd, buff, BUFSIZE);
     
141.                         if(nread<0)
     
142.                         {       
     
143.                                 printf("serial read error!\n");
     
144.                                 return -1;
     
145.                         }
     
146.                         memcpy(recv_buf,buff,nread);
     
147.                 }
     
148.         }
     
149. #ifdef DEBUG
     
150.         buff[nread]='\0';
     
151.         printf("RECEIVED::%s\n",buff);
     
152. #endif
     
153.         sleep(1);
     
154.         tv.tv_sec=timeout_s;
     
155.         tv.tv_usec=timeout_us;
     
156.         nwrite=write(fd, send_content, content_len);
     
157.         if(nwrite<content_len)
     
158.         {
     
159.                 printf("Serial Write error!\n");
     
160.                 return -1;
     
161.         }
     
162.         FD_ZERO(&rfds);
     
163.         FD_SET(fd,&rfds);
     
164.         if (select(1+fd,&rfds,NULL,NULL,&tv)>0)
     
165.         {
     
166.                 if(FD_ISSET(fd,&rfds))
     
167.                 {       
     
168.                         sleep(wait_s);
     
169.                         usleep(wait_us);
     
170.                         nread=read(fd, buff, BUFSIZE);
     
171.                         if(nread<0)
     
172.                         {       
     
173.                                 printf("serial read error!\n");
     
174.                                 return -1;
     
175.                         }
     
176.                         memcpy(recv_buf,buff,nread);
     
177.                 }
     
178.         }
     
179. #ifdef DEBUG
     
180.         buff[nread]='\0';
     
181.         printf("RECEIVED::%s\n",buff);
     
182. #endif
     
183.         tcsetattr(fd,TCSANOW,&oldtio);
     
184.         close(fd);
     
185.         return nread;
     
186. }
     
187. 
     

复制代码

参考一下吧

hacktao

谢谢T-Bagwell !我看看这个程序！

feiyinziiu

网上有课串口库，这个库程序是C写的，拿过来直接用，接口都给你写好了的。。

feiyinziiu

斑竹是好人，我正需要这个GPRS的代码。之前自己写的GSM短信猫的程序，只实现了通过GSM短信猫发短信。对于接收部分还没实现。
收下了。谢谢