linux串口原始模式与_linux串口原始模式 - CSDN
  • 1: Linux原始串口通信与Linux终端通信不同,  终端通信都是以'\n'换行符作为一次通信的结束符,而原始串口没有这个约定. 2: 需要清除串口发送和接收缓冲区.  (1):打开串口后,最好清除一下接收和发送缓冲区: ...
    Linux环境下进行原始串口通信问题(tcflush())  


    1: Linux原始串口通信与Linux终端通信不同,
        终端通信都是以'\n'换行符作为一次通信的结束符,而原始串口没有这个约定.
    2: 需要清除串口发送和接收缓冲区.
       (1):打开串口后,最好清除一下接收和发送缓冲区:
           tcflush(fd, TCIOFLUSH);   
    3: 在向对端发送读命令时,一定要在发送前清除一下原来的杂乱数据。
       (1):问题代码
           write(fd, GET_PARAM, ..);   // 向串口发送读命令.
           read(fd, buf, ...);         //从串口接收队端返回的数据.
           因为串口接收缓冲区,可能存在以前的一些杂乱的数据,因此读回来的数据,不一定
           都是刚才接收到的。
       (2): 正确的代码
           tcflush(fd, TCIFLUSH);    //先清除接收缓冲区的数据.
           write(fd, GET_PARAM, ..);   // 向串口发送读命令,这里的读命令,指的是发送此命令后,对端会立即返回相应数据. 
           read(fd, buf, ...);         //从串口接收队端返回的数据.
    展开全文
  • 最近一直在学习串口,想把其中的原理搞清楚,现在... <br />原始模式: 所有被输入的字符都被当作普通字符看待,所有字符都被送到缓冲区,都被原封不动的传动过 去,此时你会发现当你按下“backspace”

    最近一直在学习串口,想把其中的原理搞清楚,现在似乎搞明白了串口中的所谓“标准输入模式”和“原始输入模式”
    标准模式: 这应该可以被叫做主控模式,是按行输入的,输入的数据首先被放置在一个缓冲区中,并且在接 收到一个回车换行符或者一个换行符号之前这些字符依然是可编辑的。个人认为,就是对用户输入的控制字符依然保留其功能。

    原始模式: 所有被输入的字符都被当作普通字符看待,所有字符都被送到缓冲区,都被原封不动的传动过 去,此时你会发现当你按下“backspace”或者“left”,“right”等等的,都已经看不到曾经的那些效果了……

    展开全文
  • 1.阻塞非阻塞1.1 阻塞的定义对于read,指当串口输入缓存区没有数据的时候,read函数将会阻塞在这里,直到串口输入缓存区中有数据可读取,read读到了需要的字节数之后,返回值为读到的字节数;对于write,指当串口...

    1.阻塞与非阻塞

    1.1 阻塞的定义

    对于read,指当串口输入缓存区没有数据的时候,read函数将会阻塞在这里,直到串口输入缓存区中有数据可读取,read读到了需要的字节数之后,返回值为读到的字节数;

    对于write,指当串口输出缓冲区满,或剩下的空间小于将要写入的字节数,则write将阻塞,一直到串口输出缓冲区中剩下的空间大于等于将要写入的字节数,执行写入操作,返回写入的字节数。

    1.2 非阻塞的定义

    对于read,指当串口输入缓冲区没有数据的时候,read函数立即返回,返回值为-1。

    对于write,指当串口输出缓冲区满,或剩下的空间小于将要写入的字节数,则write将进行写操作,写入当前串口输出缓冲区剩下空间允许的字节数,然后返回写入的字节数。

    1.3 阻塞与非阻塞模式的切换

    在打开串口文件时,打开模式加上O_NDELAY可以以非阻塞方式打开串口;反之,不加上O_NDEAY,默认以阻塞方式打开串口。

    打开串口之后,可以通过fcntl()函数进行控制。

    2 规模模式与非规范模式

    2.1 规范模式

    规范模式下,所有的输入是基于行进行处理。打开串口默认阻塞的情况下,下面两种情形造成读返回:

    First: 所要求的字节数已读到是时,读返回。无需读一个完整的行,如果只是读取了行缓存的一部分,也不会丢失信息,下一次将从前一次读的停止处开始。

    Second:.当读到一个行界定符时,读返回。其中,换行符CR和文件结束符EOF都被认为一行的终止。但是,除了EOF之外的行结束符(回车符等)与普通字符一样会被read()函数读到缓冲区中。

    2.2 非规范模式

    在非规范模式下,所有的输入是即时有效的,不需要用户另外输入行结束符,而且不可进行行编程。在非规范模式下,对参数MIN(c_cc[VMIN])和TIME(c_cc[VTIME])的设置决定read(0函数的调用方式。

    情形A:MIN>0,TIME>0

    TIME说明字节间的计时器,在接到第一个字节时才启动它。在该计时器超时之前,若已接收到MIN个字节,则read返回MIN个字节。如果在接收MIN个字节之前,该计时器已超时,则read返回已接收到的字节(因为只有在接收到第一个字节时才启动,所以在计时器超时时,至少返回了1个字节)。在这种情况下,在接到第一个字节之前,调用者阻塞。如果在调用read时数据已经可用,则这如同在read后数据立即被接收到一样。

    情形B:MIN>0,TIME==0

    直到接到MIN个字节时,read才返回。这可以造成read无限期地阻塞。

    情形C:MIN==0,TIME>0

    TIME指定了一个调用read时启动的读计时器。(与情形A相比较,两者是不同的。在情形A中,非0的TIME表示字节间的计时器,在接收第一字节时才启动它。)在接收到1个字节或者该计时器超时时,read即返回。如果是计时器超时,则read返回0。

    情形D:MIN==0,TIME==0

    如果有数据可用,则read最多返回所要求的字节数。如果无数据可用,则read立即返回0。

    在所有这些情形中,MIN只是最小值。如果程序要求的数据多于MIN个字节,那么它可能接受到所要求的字节数。这也适用于MIN为0的情形C和D。

    串口程序如下:

    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #include <termios.h>
    #include <unistd.h>
    
    int set_opt(int,int,int,char,int);
    int main(void)
    {
        int fd,ret,t=50;
        char *uart = "/dev/ttySAC3";
    	  char buffer_out[] = "hello world!\n";
    	  char buffer_read_finish[]="read finished!\n";
    	  char buffer_in[512];
    	
    	  memset(buffer_in,0,512);
    	  fd = open(uart,O_RDWR|O_NOCTTY);
    	  if(fd == -1)
    	  {
    		    printf("%s open failed\n",uart);
    	  }
    	  else
    	  {
            printf("%s open success\n",uart);
    		    ret = set_opt(fd,115200,8,'N',1);
    		    if(ret == -1)
            {
    			    exit(-1);
    		    }
            while(t--)
            {
                ret = write(fd,buffer_out,strlen(buffer_out));
    			      if(ret== -1)
    			      {
    				        printf("write failed\n");
    			      }
    			      else
    			      {
    				        printf("num bytes of write successfully :%d\n",ret);
                }
    			      ret = read(fd,buffer_in,10);
    			      printf("ret = %d\n",ret);
    			      if(ret>0)
    			      {
    				        printf("num bytes of read is %d\n",ret);
    				        buffer_in[ret]='\0';
    				        ret = write(fd,buffer_in,strlen(buffer_in));
    			      }
    			      sleep(1);
            }
    		    close(fd);
    	  }
    }
    
    int set_opt(int fd,int nSpeed,int nBits,char nEvent,int nStop)
    {
        struct termios newtio,oldtio;
    	  if(tcgetattr(fd,&oldtio)!=0)
    	  {
    		    perror("error:SetupSerial 3\n");
    		    return -1;
        }
    	  bzero(&newtio,sizeof(newtio));
    	  //使能串口接收
    	  newtio.c_cflag |= CLOCAL | CREAD;
    	  newtio.c_cflag &= ~CSIZE;
        newtio.c_lflag &=~ICANON;//原始模式  
        //newtio.c_lflag |=ICANON; //标准模式 
        
        //设置串口数据位
    	  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;
    		    case 460800:
    			      cfsetispeed(&newtio,B460800);
    			      cfsetospeed(&newtio,B460800);
    			      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] = 5;
    	  newtio.c_cc[VMIN] = 0;
    	  tcflush(fd,TCIFLUSH);
    	
        if(tcsetattr(fd,TCSANOW,&newtio)!=0)
    	  {
    		    perror("com set error\n");
    		    return -1;
    	  }
    	  return 0;
    }
    参考:《Unix高级编程(第二版)》

    展开全文
  • linux下编写终端程序时,有规范模式 ,非规范模式(原始模式特殊的非规范模式)之分。不用于终端,而是在串口这种使用情况下,一般设置为原始模式(非规范的一种特殊情况)。但用read()函数,希望从串口接收指定的...

     在linux下编写终端程序时,有规范模式 ,非规范模式(原始模式特殊的非规范模式)之分。不用于终端,而是在串口这种使用情况下,一般设置为原始模式(非规范的一种特殊情况)。但用read()函数,希望从串口接收指定的数量的字符时,往往接收到的实际字符数,都与指定的不同。如本人用read()希望接收 10 bytes的数据,但实验后发现,分了几次才接收到,俩次接收2bytes ,两次接收3bytes。


    查阅相关资料得知:


    一般地串口的读写模式有直接模式和缓存模式,在直接模式下,串口的读写都是单字节的,也就是说一次的read或write只能操作一个字节;

            但是大部份串口芯片都支持缓存模式,缓存模式一般同时支持中断聚合和超时机制,也就是说在有数据时,当缓存满或者超时时间到时,都会触发读或写中断。写的时候可以将要操作的数据先搬到缓存里,然后启动写操作,芯片会自动将一连串的数据写出,在读的时候类似,一次读到的是串口芯片缓存里的数据。串口设备的缓存一般有限,一次能read到的最大字节数就是缓存的容量。所以串口芯片的缓存容量决定了你一次能收到的字节数。本人用一个usb转232来充当串口接收时,发现一次可以接收8个bytes。

     

            对于具体一次传输多少字节也不去追究了,总之通讯过程中无法保证一次发送的数据肯定是一次接收的,所以必须写代码 来一次一次的接收,直到接收满足预定的为止,当然在此过程中得使用select/poll来避免超时接收。

     


    即从通讯的角度来说,接受方必须自己解决如何识别一个祯的问题。
    (操作串口相当于操作物理层,OSI/ISO模型中的第一层,解决祯同步问题是第二层的任务,所以我们需要自己搭一个第二层。
    也就是说:我们需要通过定义通讯协议,规定数据的内容自己分析什么时候收完了一次需要的数据。因为通讯过程中无法保证一次发送的数据肯定是一次接收的)

     

    下面来解决识别帧的问题:

     

               不是编写终端,我们一帮都采用原始模式;进行简单的串口编程,一般设置成阻塞模式,便可以了。但是在大多数应用场合,把串口设置成阻塞模式是很不实用的,如read()时,如果没有数据发来,这程序一直会阻塞在这里(除非用多线程)。因此一般把其设置为非阻塞模式。一般是需要用串口读取指定长度的数据,但是read函数实际读取的数据长度,往往会与指定的不同,所以必须自己编写一个读写N字节数据的函数:

                 很快想到用个循环,但是循环中必须有 ‘即使一直没有收到指定长度的数据但在一定时间后也必须跳出循环’的机制,否则就与阻塞模式的没有区别了(也就是让函数一直等,等到指定长度数据接收为止)。参考下APUE的程序清单14-11的readn()函数,此函数看似很好,但是它不适合用于串口的读取,因为它一旦if(nread = read(fd, ptr, nleft) < 0) 就立刻会跳出循环,没有丝毫的时间上的容限,而串口的接收必然没有这么快,如若波特率为1200,是比较慢的。俩个字节传输的间隔,其都会被判断为错误而跳出。当然该函数对于读写文件是非常好用的。

    ssize_t             /* Read "n" bytes from a descriptor  */
    readn(int fd, void *ptr, size_t n)
    {
     size_t  nleft;
     ssize_t  nread;


     nleft = n;
     while (nleft > 0) {
      if ((nread = read(fd, ptr, nleft)) < 0) {
       if (nleft == n)
        return(-1); /* error, return -1 */
       else
        break;      /* error, return amount read so far */
      } else if (nread == 0) {
       break;          /* EOF */
      }
      nleft -= nread;
      ptr   += nread;
     }
     return(n - nleft);      /* return >= 0 */
    }

             再次参考下APUE的tread() 和treadn()函数,这组函数结合了select函数,使得在放弃之前,有了个时间来阻塞。有了一定的时间容限。例如把select中的tv.tv_sec = 1;这样就不会把 原本正常的俩个字节的时间间隔,误判为错误了。


    ssize_t

    tread(int fd, void *buf, size_t nbytes, unsigned int timout)

    {


           int                         nfds;

           fd_set                   readfds;

           struct timeval  tv;

           tv.tv_sec = timout;

           tv.tv_usec = 0;

           FD_ZERO(&readfds);

           FD_SET(fd, &readfds);

           nfds = select(fd+1, &readfds, NULL, NULL, &tv);

           if (nfds <= 0) {

                  if (nfds == 0)

                         errno = ETIME;

                  return(-1);

           }

           return(read(fd, buf, nbytes));

    }


     ssize_t

    treadn(int fd, void *buf, size_t nbytes, unsigned int timout)


    {

           size_t      nleft;

           ssize_t     nread;

           nleft = nbytes;

           while (nleft > 0) {

                  if ((nread = tread(fd, buf, nleft, timout)) < 0) {

                         if (nleft == nbytes)

                                return(-1); /* error, return -1 */

                         else

                                break;      /* error, return amount read so far */

                  } else if (nread == 0) {

                         break;          /* EOF */

                  }

                  nleft -= nread;

                  buf += nread;

           }

           return(nbytes - nleft);      /* return >= 0 */

    }


    实际应用如:


    某个串口通信协议一帧为10个字节,linux 必须接收1帧后去解析该帧的命令。波特率1200 。在linux中必须有个读取一帧数据的函数,该函数不能‘一直等待接收10个字节’,而必须在一定时间内没有收到完整的一帧就放弃该帧,这样才能防止对方发送错误或者通信中的错误带来的问题。 利用treadn()很好的配合该思路的实现。可以定时限为10ms。如果超过10ms(可以设置长点)这treadn()也会返回,这时判断如果实际收到的数据小于10,则丢弃即可。本人用1200的波特率,tv设置成了500us,工作的很好。


     

    最后贴一个经典的串口编程基础:

     

    1.串口操作需要的头文件

    #include <stdio.h>         //标准输入输出定义
    #include <stdlib.h>        //标准函数库定义
    #include <unistd.h>       //Unix标准函数定义
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>          //文件控制定义
    #include <termios.h>     //POSIX中断控制定义
    #include <errno.h>        //错误号定义

    2.打开串口

    串口位于/dev中,可作为标准文件的形式打开,其中:
    串口1 /dev/ttyS0
    串口2 /dev/ttyS1
    代码如下:

    int fd;
    fd 
    = open(“/dev/
    ttyS0”, O_RDWR);
    if(fd == -1
    )
    {
        Perror(“串口1打开失败!”);
    }
    //
    else
        
    //fcntl(fd, F_SETFL, FNDELAY);
    除了使用O_RDWR标志之外,通常还会使用O_NOCTTY和O_NDELAY这两个标志。
    O_NOCTTY:告诉Unix这个程序不想成为“控制终端”控制的程序,不说明这个标志的话,任何输入都会影响你的程序。
    O_NDELAY:告诉Unix这个程序不关心DCD信号线状态,即其他端口是否运行,不说明这个标志的话,该程序就会在DCD信号线为低电平时停止。

    3.设置波特率

    最基本的串口设置包括波特率、校验位和停止位设置,且串口设置主要使用termios.h头文件中定义的termios结构,如下:
    struct termios
    {
       tcflag_t  c_iflag;   //输入模式标志
       tcflag_t  c_oflag;  //输出模式标志
       tcflag_t  c_cflag;  //控制模式标志
       tcflag_t  c_lflag;   //本地模式标志
       cc_t   c_line;              //line discipline
       cc_t   c_cc[NCC];    //control characters
    }
    代码如下:

    int speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300, B38400, B19200, B9600, B4800, B2400, B1200, B300, };
    int name_arr[] = {3840019200960048002400120030038400192009600480024001200300
    , };

    void SetSpeed(int fd, int
     speed)
    {
        
    int
     i;
        
    struct termios Opt;    //定义termios结构


        
    if(tcgetattr(fd, &Opt) != 0)
        {
            perror(“tcgetattr fd”);
            
    return
    ;
        }
        
    for(i = 0; i < sizeof(speed_arr) / sizeof(int); i++
    )
        {
            
    if(speed ==
     name_arr[i])
            {
                tcflush(fd, TCIOFLUSH);
                cfsetispeed(
    &
    Opt, speed_arr[i]);
                cfsetospeed(
    &
    Opt, speed_arr[i]);
                
    if(tcsetattr(fd, TCSANOW, &Opt) != 0
    )
                {
                    perror(“tcsetattr fd”);
                    
    return
    ;
                }
                tcflush(fd, TCIOFLUSH);
            }
        }
    }
    注意tcsetattr函数中使用的标志:
    TCSANOW:立即执行而不等待数据发送或者接受完成。
    TCSADRAIN:等待所有数据传递完成后执行。
    TCSAFLUSH:Flush input and output buffers and make the change

    4.设置数据位、停止位和校验位

    以下是几个数据位、停止位和校验位的设置方法:(以下均为1位停止位)
    8位数据位、无校验位:
    Opt.c_cflag &= ~PARENB;
    Opt.c_cflag &= ~CSTOPB;
    Opt.c_cflag &= ~CSIZE;
    Opt.c_cflag |= CS8;
    7位数据位、奇校验:
    Opt.c_cflag |= PARENB;
    Opt.c_cflag |= PARODD;
    Opt.c_cflag &= ~CSTOPB;
    Opt.c_cflag &= ~CSIZE;
    Opt.c_cflag |= CS7;
    7位数据位、偶校验:
    Opt.c_cflag |= PARENB;
    Opt.c_cflag &= ~PARODD;
    Opt.c_cflag &= ~CSTOPB;
    Opt.c_cflag &= ~CSIZE;
    Opt.c_cflag |= CS7;
    7位数据位、Space校验:
    Opt.c_cflag &= ~PARENB;
    Opt.c_cflag &= ~CSTOPB;
    Opt.c_cflag &= ~CSIZE;
    Opt.c_cflag |= CS7;
    代码如下:

    int SetParity(int fd, int databits, int stopbits, int parity)
    {
        
    struct
     termios Opt;
        
    if(tcgetattr(fd, &Opt) != 0
    )
        {
            perror(
    "tcgetattr fd"
    );
            
    return
     FALSE;
        }
       Opt.c_cflag 
    |= (CLOCAL | CREAD);        //一般必设置的标志


        
    switch(databits)        //设置数据位数
        {
        
    case 7
    :
            Opt.c_cflag 
    &= ~
    CSIZE;
            Opt.c_cflag 
    |=
     CS7;
            
    break
    ;
        
    case 8
    :
            Opt.c_cflag 
    &= ~
    CSIZE;
            Opt.c_cflag 
    |=
     CS8;
            berak;
        
    default
    :
            fprintf(stderr, 
    "Unsupported data size.\n"
    );
            
    return
     FALSE;
        }

        
    switch(parity)            //设置校验位

        {
        
    case 'n'
    :
        
    case 'N'
    :
            Opt.c_cflag 
    &= ~PARENB;        //清除校验位

            Opt.c_iflag &= ~INPCK;        //enable parity checking
            break;
        
    case 'o'
    :
        
    case 'O'
    :
            Opt.c_cflag 
    |= PARENB;        //enable parity

            Opt.c_cflag |= PARODD;        //奇校验
            Opt.c_iflag |= INPCK            //disable parity checking
            break;
        
    case 'e'
    :
        
    case 'E'
    :
            Opt.c_cflag 
    |= PARENB;        //enable parity

            Opt.c_cflag &= ~PARODD;        //偶校验
            Opt.c_iflag |= INPCK;            //disable pairty checking
            break;
        
    case 's'
    :
        
    case 'S'
    :
            Opt.c_cflag 
    &= ~PARENB;        //清除校验位

            Opt.c_cflag &= ~CSTOPB;        //??????????????
            Opt.c_iflag |= INPCK;            //disable pairty checking
            break;
        
    default
    :
            fprintf(stderr, 
    "Unsupported parity.\n"
    );
            
    return
     FALSE;    
        }

        
    switch(stopbits)        //设置停止位

        {
        
    case 1
    :
            Opt.c_cflag 
    &= ~
    CSTOPB;
            
    break
    ;
        
    case 2
    :
            Opt.c_cflag 
    |=
     CSTOPB;
            
    break
    ;
        
    default
    :
            fprintf(stderr, 
    "Unsupported stopbits.\n"
    );
            
    return
     FALSE;
        }

        opt.c_cflag 
    |= (CLOCAL |
     CREAD);

        opt.c_lflag 
    &= ~(ICANON | ECHO | ECHOE |
     ISIG);
     
        opt.c_oflag 
    &= ~
    OPOST;
        opt.c_oflag 
    &= ~(ONLCR | OCRNL);    //添加的

     
        opt.c_iflag 
    &= ~(ICRNL |
     INLCR);
        opt.c_iflag 
    &= ~(IXON | IXOFF | IXANY);    //添加的


        tcflush(fd, TCIFLUSH);
        Opt.c_cc[VTIME] 
    = 0;        //设置超时为15sec
        Opt.c_cc[VMIN] = 0;        //Update the Opt and do it now
        if(tcsetattr(fd, TCSANOW, &Opt) != 0)
        {
            perror(
    "tcsetattr fd"
    );
            
    return
     FALSE;
        }

        
    return
     TRUE;
    }

    5.某些设置项

    在第四步中我们看到一些比较特殊的设置,下面简述一下他们的作用。
    c_cc数组的VSTART和VSTOP元素被设定成DC1和DC3,代表ASCII标准的XON和XOFF字符,如果在传输这两个字符的时候就传不过去,需要把软件流控制屏蔽,即:
    Opt.c_iflag &= ~ (IXON | IXOFF | IXANY);
    有时候,在用write发送数据时没有键入回车,信息就发送不出去,这主要是因为我们在输入输出时是按照规范模式接收到回车或换行才发送,而更多情况下我们是不必键入回车或换行的。此时应转换到行方式输入,不经处理直接发送,设置如下:
    Opt.c_lflag &= ~ (ICANON | ECHO | ECHOE | ISIG);
    还存在这样的情况:发送字符0X0d的时候,往往接收端得到的字符是0X0a,原因是因为在串口设置中c_iflag和c_oflag中存在从NL-CR和CR-NL的映射,即串口能把回车和换行当成同一个字符,可以进行如下设置屏蔽之:
    Opt.c_iflag &= ~ (INLCR | ICRNL | IGNCR);
    Opt.c_oflag &= ~(ONLCR | OCRNL);

    6.读写串口

    发送数据方式如下,write函数将返回写的位数或者当错误时为-1。
    char buffer[1024];
    int length;
    int nByte;
    nByte = write(fd, buffer, length);
    读取数据方式如下,原始数据模式下每个read函数将返回实际串口收到的字符数,如果串口中没有字符可用,回叫将会阻塞直到以下几种情况:有字符进入;一个间隔计时器失效;错误发送。
    在打开串口成功后,使用fcntl(fd, F_SETFL, FNDELAY)语句,可以使read函数立即返回而不阻塞。FNDELAY选项使read函数在串口无字符时立即返回且为0。
    char buffer[1024];
    int length;
    int readByte;
    readByte = read(fd, buffer, len);
    注意:设置为原始模式传输数据的话,read函数返回的字符数是实际串口收到的字符数。Linux下直接用read读串口可能会造成堵塞,或者数据读出错误,此时可使用tcntl或者select等函数实现异步读取。用select先查询com口,再用read去读就可以避免上述错误。

    7.关闭串口

    串口作为文件来处理,所以一般的关闭文件函数即可:
    close(fd);

    8.例子

    这个例子中,需要打开串口1,设置9600波特率、8位数据位、1位停止位以及空校验,之后利用while语句循环判断串口中是否可以读出数据,将串口中数据连续读出后重新写回到串口中。
    该程序可与minicom联合测试。

    #include     <stdio.h>
    #include     
    <stdlib.h> 
    #include     
    <unistd.h>
      
    #include     
    <sys/types.h>

    #include     
    <sys/stat.h>
    #include     
    <fcntl.h> 
    #include     
    <termios.h>

    #include     
    <errno.h>
       
    main()
    {
        
    int fd;
        
    int
     i;
        
    int
     len;
        
    int n = 0
    ;      
        
    char read_buf[256
    ];
        
    char write_buf[256
    ];
        
    struct
     termios opt; 
        
        fd 
    = open("/dev/ttyS0", O_RDWR | O_NOCTTY);    //默认为阻塞读方式

        if(fd == -1)
        {
            perror(
    "open serial 0\n"
    );
            exit(
    0
    );
        }

        tcgetattr(fd, 
    &
    opt);      
        cfsetispeed(
    &
    opt, B9600);
        cfsetospeed(
    &
    opt, B9600);
        
        
    if(tcsetattr(fd, TCSANOW, &opt) != 0
     )
        {     
           perror(
    "tcsetattr error"
    );
           
    return -1
    ;
        }
        
        opt.c_cflag 
    &= ~
    CSIZE;  
        opt.c_cflag 
    |=
     CS8;   
        opt.c_cflag 
    &= ~
    CSTOPB; 
        opt.c_cflag 
    &= ~
    PARENB; 
        opt.c_cflag 
    &= ~
    INPCK;
        opt.c_cflag 
    |= (CLOCAL |
     CREAD);
     
        opt.c_lflag 
    &= ~(ICANON | ECHO | ECHOE |
     ISIG);
     
        opt.c_oflag 
    &= ~
    OPOST;
        opt.c_oflag 
    &= ~(ONLCR | OCRNL);    //添加的

     
        opt.c_iflag 
    &= ~(ICRNL |
     INLCR);
        opt.c_iflag 
    &= ~(IXON | IXOFF | IXANY);    //添加的

        
        opt.c_cc[VTIME] 
    = 0
    ;
        opt.c_cc[VMIN] 
    = 0
    ;
        
        tcflush(fd, TCIOFLUSH);
     
        printf(
    "configure complete\n"
    );
        
        
    if(tcsetattr(fd, TCSANOW, &opt) != 0
    )
        {
            perror(
    "serial error"
    );
            
    return -1
    ;
        }
        printf(
    "start send and receive data\n"
    );
      
        
    while(1
    )
        {    
            n 
    = 0
    ;
            len 
    = 0
    ;
            bzero(read_buf, 
    sizeof(read_buf));    //类似于memset

            bzero(write_buf, sizeof(write_buf));
     
            
    while( (n = read(fd, read_buf, sizeof(read_buf))) > 0
     )
            {
                
    for(i = len; i < (len + n); i++
    )
                {
                    write_buf[i] 
    = read_buf[i -
     len];
                }
                len 
    +=
     n;
            }
            write_buf[len] 
    = '\0'
    ;
                  
            printf(
    "Len %d \n"
    , len);
            printf(
    "%s \n"
    , write_buf);
     
            n 
    =
     write(fd, write_buf, len);
            printf(
    "write %d chars\n"
    ,n);
            
            sleep(
    2
    );
        }
    }


    9.附录

    c_cflag用于设置控制参数,除了波特率外还包含以下内容: 
    EXTA         External rate clock
    EXTB         External rate clock
    CSIZE         Bit mask for data bits
    CS5         5个数据位
    CS6         6个数据位
    CS7         7个数据位
    CS8         8个数据位
    CSTOPB         2个停止位(清除该标志表示1个停止位
    PARENB         允许校验位
    PARODD         使用奇校验(清除该标志表示使用偶校验)
    CREAD         Enable receiver
    HUPCL         Hangup (drop DTR) on last close
    CLOCAL         Local line – do not change “owner” of port
    LOBLK         Block job control outpu
    c_cflag标志可以定义CLOCAL和CREAD,这将确保该程序不被其他端口控制和信号干扰,同时串口驱动将读取进入的数据。CLOCAL和CREAD通常总是被是能的。

    c_lflag用于设置本地模式,决定串口驱动如何处理输入字符,设置内容如下:
    ISIG            Enable SIGINTR, SIGSUSP, SIGDSUSP, and SIGQUIT signals 
    ICANON         Enable canonical input (else raw) 
    XCASE         Map uppercase \lowercase (obsolete) 
    ECHO         Enable echoing of input characters 
    ECHOE         Echo erase character as BS-SP-BS 
    ECHOK         Echo NL after kill character 
    ECHONL         Echo NL 
    NOFLSH         Disable flushing of input buffers after interrupt or quit characters 
    IEXTEN         Enable extended functions 
    ECHOCTL         Echo control characters as ^char and delete as ~? 
    ECHOPRT         Echo erased character as character erased 
    ECHOKE         BS-SP-BS entire line on line kill 
    FLUSHO         Output being flushed 
    PENDIN         Retype pending input at next read or input char 
    TOSTOP         Send SIGTTOU for background output


    c_iflag用于设置如何处理串口上接收到的数据,包含如下内容:
    INPCK         Enable parity check 
    IGNPAR         Ignore parity errors 
    PARMRK      Mark parity errors 
    ISTRIP         Strip parity bits 
    IXON         Enable software flow control (outgoing) 
    IXOFF         Enable software flow control (incoming) 
    IXANY         Allow any character to start flow again 
    IGNBRK         Ignore break condition 
    BRKINT         Send a SIGINT when a break condition is detected 
    INLCR         Map NL to CR 
    IGNCR         Ignore CR 
    ICRNL         Map CR to NL 
    IUCLC         Map uppercase to lowercase 
    IMAXBEL      Echo BEL on input line too long

    c_oflag用于设置如何处理输出数据,包含如下内容:
    OPOST         Postprocess output (not set = raw output) 
    OLCUC         Map lowercase to uppercase 
    ONLCR         Map NL to CR-NL 
    OCRNL         Map CR to NL 
    NOCR         No CR output at column 0 
    ONLRET      NL performs CR function 
    OFILL         Use fill characters for delay 
    OFDEL         Fill character is DEL 
    NLDLY         Mask for delay time needed between lines 
    NL0            No delay for NLs 
    NL1            Delay further output after newline for 100 milliseconds 
    CRDLY      Mask for delay time needed to return carriage to left column 
    CR0            No delay for CRs 
    CR1            Delay after CRs depending on current column position 
    CR2            Delay 100 milliseconds after sending CRs 
    CR3            Delay 150 milliseconds after sending CRs 
    TABDLY      Mask for delay time needed after TABs 
    TAB0            No delay for TABs 
    TAB1         Delay after TABs depending on current column position 
    TAB2         Delay 100 milliseconds after sending TABs 
    TAB3         Expand TAB characters to spaces 
    BSDLY      Mask for delay time needed after BSs 
    BS0         No delay for BSs 
    BS1         Delay 50 milliseconds after sending BSs 
    VTDLY      Mask for delay time needed after VTs 
    VT0         No delay for VTs 
    VT1         Delay 2 seconds after sending VTs 
    FFDLY      Mask for delay time needed after FFs 
    FF0         No delay for FFs 
    FF1         Delay 2 seconds after sending FFs

    c_cc定义了控制字符,包含以下内容:
    VINTR  Interrupt  CTRL-C 
    VQUIT  Quit    CTRL-Z 
    VERASE   Erase    Backspace (BS) 
    VKILL   Kill-line   CTRL-U 
    VEOF   End-of-file   CTRL-D 
    VEOL   End-of-line   Carriage return (CR) 
    VEOL2   Second    end-of-line Line feed (LF) 
    VMIN   Minimum number of characters to read  
    VSTART   Start flow   CTRL-Q (XON) 
    VSTOP   Stop flow   CTRL-S (XOFF) 
    VTIME   Time to wait for data (tenths of seconds) 

    注意:控制符VTIME和VMIN之间有复杂的关系。VTIME定义要求等待的时间(百毫米,通常是unsigned char变量),而VMIN定义了要求等待的最小字节数(相比之下,read函数的第三个参数指定了要求读的最大字节数)。
    如果VTIME=0,VMIN=要求等待读取的最小字节数,read必须在读取了VMIN个字节的数据或者收到一个信号才会返回。
    如果VTIME=时间量,VMIN=0,不管能否读取到数据,read也要等待VTIME的时间量。
    如果VTIME=时间量,VMIN=要求等待读取的最小字节数,那么将从read读取第一个字节的数据时开始计时,并会在读取到VMIN个字节或者VTIME时间后返回。
    如果VTIME=0,VMIN=0,不管能否读取到数据,read都会立即返回。

    展开全文
  • linux串口API编程

    2014-10-28 13:54:41
    linux下编写终端程序时,有规范模式 ,非规范模式(原始模式特殊的非规范模式)之分。不用于终端,而是在串口这种使用情况下,一般设置为原始模式(非规范的一种特殊情况)。但用read()函数,希望从串口接收指定的...

        在linux下编写终端程序时,有规范模式 ,非规范模式(原始模式特殊的非规范模式)之分。不用于终端,而是在串口这种使用情况下,一般设置为原始模式(非规范的一种特殊情况)。但用read()函数,希望从串口接收指定的数量的字符时,往往接收到的实际字符数,都与指定的不同。如本人用read()希望接收 10 bytes的数据,但实验后发现,分了几次才接收到,俩次接收2bytes ,两次接收3bytes。

    查阅相关资料得知:

    一般地串口的读写模式有直接模式和缓存模式,在直接模式下,串口的读写都是单字节的,也就是说一次的read或write只能操作一个字节;
            但是大部份串口芯片都支持缓存模式,缓存模式一般同时支持中断聚合和超时机制,也就是说在有数据时,当缓存满或者超时时间到时,都会触发读或写中断。写的时候可以将要操作的数据先搬到缓存里,然后启动写操作,芯片会自动将一连串的数据写出,在读的时候类似,一次读到的是串口芯片缓存里的数据。串口设备的缓存一般有限,一次能read到的最大字节数就是缓存的容量。所以串口芯片的缓存容量决定了你一次能收到的字节数。本人用一个usb转232来充当串口接收时,发现一次可以接收8个bytes。
     
            对于具体一次传输多少字节也不去追究了,总之通讯过程中无法保证一次发送的数据肯定是一次接收的,所以必须写代码 来一次一次的接收,直到接收满足预定的为止,当然在此过程中得使用select/poll来避免超时接收。
     
    即从通讯的角度来说,接受方必须自己解决如何识别一个祯的问题。
    (操作串口相当于操作物理层,OSI/ISO模型中的第一层,解决祯同步问题是第二层的任务,所以我们需要自己搭一个第二层。
    也就是说:我们需要通过定义通讯协议,规定数据的内容自己分析什么时候收完了一次需要的数据。因为通讯过程中无法保证一次发送的数据肯定是一次接收的)
     
    下面来解决识别帧的问题:
     
               不是编写终端,我们一帮都采用原始模式;进行简单的串口编程,一般设置成阻塞模式,便可以了。但是在大多数应用场合,把串口设置成阻塞模式是很不实用的,如read()时,如果没有数据发来,这程序一直会阻塞在这里(除非用多线程)。因此一般把其设置为非阻塞模式。一般是需要用串口读取指定长度的数据,但是read函数实际读取的数据长度,往往会与指定的不同,所以必须自己编写一个读写N字节数据的函数:
                 很快想到用个循环,但是循环中必须有 ‘即使一直没有收到指定长度的数据但在一定时间后也必须跳出循环’的机制,否则就与阻塞模式的没有区别了(也就是让函数一直等,等到指定长度数据接收为止)。参考下APUE的程序清单14-11的readn()函数,此函数看似很好,但是它不适合用于串口的读取,因为它一旦if(nread = read(fd, ptr, nleft) < 0) 就立刻会跳出循环,没有丝毫的时间上的容限,而串口的接收必然没有这么快,如若波特率为1200,是比较慢的。俩个字节传输的间隔,其都会被判断为错误而跳出。当然该函数对于读写文件是非常好用的。
    ssize_t             /* Read "n" bytes from a descriptor  */
    readn(int fd, void *ptr, size_t n)
    {
     size_t  nleft;
     ssize_t  nread;
     nleft = n;
     while (nleft > 0) {
      if ((nread = read(fd, ptr, nleft)) < 0) {
       if (nleft == n)
        return(-1); /* error, return -1 */
       else
        break;      /* error, return amount read so far */
      } else if (nread == 0) {
       break;          /* EOF */
      }
      nleft -= nread;
      ptr   += nread;
     }
     return(n - nleft);      /* return >= 0 */
    }

             再次参考下APUE的tread() 和treadn()函数,这组函数结合了select函数,使得在放弃之前,有了个时间来阻塞。有了一定的时间容限。例如把select中的tv.tv_sec = 1;这样就不会把 原本正常的俩个字节的时间间隔,误判为错误了。

     

    ssize_t

    tread(int fd, void *buf, size_t nbytes, unsigned int timout)

    {

           int                         nfds;

           fd_set                   readfds;

           struct timeval  tv;

     

           tv.tv_sec = timout;

           tv.tv_usec = 0;

           FD_ZERO(&readfds);

           FD_SET(fd, &readfds);

           nfds = select(fd+1, &readfds, NULL, NULL, &tv);

           if (nfds <= 0) {

                  if (nfds == 0)

                         errno = ETIME;

                  return(-1);

           }

           return(read(fd, buf, nbytes));

    }

     ssize_t

    treadn(int fd, void *buf, size_t nbytes, unsigned int timout)

    {

           size_t      nleft;

           ssize_t     nread;

     

           nleft = nbytes;

           while (nleft > 0) {

                  if ((nread = tread(fd, buf, nleft, timout)) < 0) {

                         if (nleft == nbytes)

                                return(-1); /* error, return -1 */

                         else

                                break;      /* error, return amount read so far */

                  } else if (nread == 0) {

                         break;          /* EOF */

                  }

                  nleft -= nread;

                  buf += nread;

           }

           return(nbytes - nleft);      /* return >= 0 */

    }

    实际应用如:

    某个串口通信协议一帧为10个字节,linux 必须接收1帧后去解析该帧的命令。波特率1200 。在linux中必须有个读取一帧数据的函数,该函数不能‘一直等待接收10个字节’,而必须在一定时间内没有收到完整的一帧就放弃该帧,这样才能防止对方发送错误或者通信中的错误带来的问题。 利用treadn()很好的配合该思路的实现。可以定时限为10ms。如果超过10ms(可以设置长点)这treadn()也会返回,这时判断如果实际收到的数据小于10,则丢弃即可。本人用1200的波特率,tv设置成了500us,工作的很好。

     
    最后贴一个经典的串口编程基础:
     
    1.串口操作需要的头文件

    #include <stdio.h>         //标准输入输出定义
    #include <stdlib.h>        //标准函数库定义
    #include <unistd.h>       //Unix标准函数定义
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>          //文件控制定义
    #include <termios.h>     //POSIX中断控制定义
    #include <errno.h>        //错误号定义

    2.打开串口

    串口位于/dev中,可作为标准文件的形式打开,其中:
    串口1 /dev/ttyS0
    串口2 /dev/ttyS1
    代码如下:
    int fd;
    fd = open(“/dev/
    ttyS0”, O_RDWR);
    if(fd == -1
    )
    {
        Perror(“串口1打开失败!”);
    }
    //
    else
        
    //fcntl(fd, F_SETFL, FNDELAY);
    除了使用O_RDWR标志之外,通常还会使用O_NOCTTY和O_NDELAY这两个标志。
    O_NOCTTY:告诉Unix这个程序不想成为“控制终端”控制的程序,不说明这个标志的话,任何输入都会影响你的程序。
    O_NDELAY:告诉Unix这个程序不关心DCD信号线状态,即其他端口是否运行,不说明这个标志的话,该程序就会在DCD信号线为低电平时停止。

    3.设置波特率

    最基本的串口设置包括波特率、校验位和停止位设置,且串口设置主要使用termios.h头文件中定义的termios结构,如下:
    struct termios
    {
       tcflag_t  c_iflag;   //输入模式标志
       tcflag_t  c_oflag;  //输出模式标志
       tcflag_t  c_cflag;  //控制模式标志
       tcflag_t  c_lflag;   //本地模式标志
       cc_t   c_line;              //line discipline
       cc_t   c_cc[NCC];    //control characters
    }
    代码如下:
    int speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300, B38400, B19200, B9600, B4800, B2400, B1200, B300, };
    int name_arr[] = {38400, 19200, 9600, 4800, 2400, 1200, 300, 38400, 19200, 9600, 4800, 2400, 1200, 300
    , };

    void SetSpeed(int fd, int
     speed)
    {
        int
     i;
        struct termios Opt;    //定义termios结构


        if(tcgetattr(fd, &Opt) != 0)
        {
            perror(“tcgetattr fd”);
            return
    ;
        }
        for(i = 0; i < sizeof(speed_arr) / sizeof(int); i++
    )
        {
            if(speed ==
     name_arr[i])
            {
                tcflush(fd, TCIOFLUSH);
                cfsetispeed(&
    Opt, speed_arr[i]);
                cfsetospeed(&
    Opt, speed_arr[i]);
                if(tcsetattr(fd, TCSANOW, &Opt) != 0
    )
                {
                    perror(“tcsetattr fd”);
                    return
    ;
                }
                tcflush(fd, TCIOFLUSH);
            }
        }
    }
    注意tcsetattr函数中使用的标志:
    TCSANOW:立即执行而不等待数据发送或者接受完成。
    TCSADRAIN:等待所有数据传递完成后执行。
    TCSAFLUSH:Flush input and output buffers and make the change

    4.设置数据位、停止位和校验位

    以下是几个数据位、停止位和校验位的设置方法:(以下均为1位停止位)
    8位数据位、无校验位:
    Opt.c_cflag &= ~PARENB;
    Opt.c_cflag &= ~CSTOPB;
    Opt.c_cflag &= ~CSIZE;
    Opt.c_cflag |= CS8;
    7位数据位、奇校验:
    Opt.c_cflag |= PARENB;
    Opt.c_cflag |= PARODD;
    Opt.c_cflag &= ~CSTOPB;
    Opt.c_cflag &= ~CSIZE;
    Opt.c_cflag |= CS7;
    7位数据位、偶校验:
    Opt.c_cflag |= PARENB;
    Opt.c_cflag &= ~PARODD;
    Opt.c_cflag &= ~CSTOPB;
    Opt.c_cflag &= ~CSIZE;
    Opt.c_cflag |= CS7;
    7位数据位、Space校验:
    Opt.c_cflag &= ~PARENB;
    Opt.c_cflag &= ~CSTOPB;
    Opt.c_cflag &= ~CSIZE;
    Opt.c_cflag |= CS7;
    代码如下:
    int SetParity(int fd, int databits, int stopbits, int parity)
    {
        struct
     termios Opt;
        if(tcgetattr(fd, &Opt) != 0
    )
        {
            perror("tcgetattr fd"
    );
            return
     FALSE;
        }
       Opt.c_cflag |= (CLOCAL | CREAD);        //一般必设置的标志


        switch(databits)        //设置数据位数
        {
        case 7
    :
            Opt.c_cflag &= ~
    CSIZE;
            Opt.c_cflag |=
     CS7;
            break
    ;
        case 8
    :
            Opt.c_cflag &= ~
    CSIZE;
            Opt.c_cflag |=
     CS8;
            berak;
        default
    :
            fprintf(stderr, "Unsupported data size.\n"
    );
            return
     FALSE;
        }

        switch(parity)            //设置校验位

        {
        case 'n'
    :
        case 'N'
    :
            Opt.c_cflag &= ~PARENB;        //清除校验位

            Opt.c_iflag &= ~INPCK;        //enable parity checking
            break;
        case 'o'
    :
        case 'O'
    :
            Opt.c_cflag |= PARENB;        //enable parity

            Opt.c_cflag |= PARODD;        //奇校验
            Opt.c_iflag |= INPCK            //disable parity checking
            break;
        case 'e'
    :
        case 'E'
    :
            Opt.c_cflag |= PARENB;        //enable parity

            Opt.c_cflag &= ~PARODD;        //偶校验
            Opt.c_iflag |= INPCK;            //disable pairty checking
            break;
        case 's'
    :
        case 'S'
    :
            Opt.c_cflag &= ~PARENB;        //清除校验位

            Opt.c_cflag &= ~CSTOPB;        //??????????????
            Opt.c_iflag |= INPCK;            //disable pairty checking
            break;
        default
    :
            fprintf(stderr, "Unsupported parity.\n"
    );
            return
     FALSE;    
        }

        switch(stopbits)        //设置停止位

        {
        case 1
    :
            Opt.c_cflag &= ~
    CSTOPB;
            break
    ;
        case 2
    :
            Opt.c_cflag |=
     CSTOPB;
            break
    ;
        default
    :
            fprintf(stderr, "Unsupported stopbits.\n"
    );
            return
     FALSE;
        }

        opt.c_cflag |= (CLOCAL |
     CREAD);

        opt.c_lflag &= ~(ICANON | ECHO | ECHOE |
     ISIG);
     
        opt.c_oflag &= ~
    OPOST;
        opt.c_oflag &= ~(ONLCR | OCRNL);    //添加的

     
        opt.c_iflag &= ~(ICRNL |
     INLCR);
        opt.c_iflag &= ~(IXON | IXOFF | IXANY);    //添加的


        tcflush(fd, TCIFLUSH);
        Opt.c_cc[VTIME] 
    = 0;        //设置超时为15sec
        Opt.c_cc[VMIN] = 0;        //Update the Opt and do it now
        if(tcsetattr(fd, TCSANOW, &Opt) != 0)
        {
            perror("tcsetattr fd"
    );
            return
     FALSE;
        }

        return
     TRUE;
    }

    5.某些设置项

    在第四步中我们看到一些比较特殊的设置,下面简述一下他们的作用。
    c_cc数组的VSTART和VSTOP元素被设定成DC1和DC3,代表ASCII标准的XON和XOFF字符,如果在传输这两个字符的时候就传不过去,需要把软件流控制屏蔽,即:
    Opt.c_iflag &= ~ (IXON | IXOFF | IXANY);
    有时候,在用write发送数据时没有键入回车,信息就发送不出去,这主要是因为我们在输入输出时是按照规范模式接收到回车或换行才发送,而更多情况下我们是不必键入回车或换行的。此时应转换到行方式输入,不经处理直接发送,设置如下:
    Opt.c_lflag &= ~ (ICANON | ECHO | ECHOE | ISIG);
    还存在这样的情况:发送字符0X0d的时候,往往接收端得到的字符是0X0a,原因是因为在串口设置中c_iflag和c_oflag中存在从NL-CR和CR-NL的映射,即串口能把回车和换行当成同一个字符,可以进行如下设置屏蔽之:
    Opt.c_iflag &= ~ (INLCR | ICRNL | IGNCR);
    Opt.c_oflag &= ~(ONLCR | OCRNL);

    6.读写串口

    发送数据方式如下,write函数将返回写的位数或者当错误时为-1。
    char buffer[1024];
    int length;
    int nByte;
    nByte = write(fd, buffer, length);
    读取数据方式如下,原始数据模式下每个read函数将返回实际串口收到的字符数,如果串口中没有字符可用,回叫将会阻塞直到以下几种情况:有字符进入;一个间隔计时器失效;错误发送。
    在打开串口成功后,使用fcntl(fd, F_SETFL, FNDELAY)语句,可以使read函数立即返回而不阻塞。FNDELAY选项使read函数在串口无字符时立即返回且为0。
    char buffer[1024];
    int length;
    int readByte;
    readByte = read(fd, buffer, len);
    注意:设置为原始模式传输数据的话,read函数返回的字符数是实际串口收到的字符数。Linux下直接用read读串口可能会造成堵塞,或者数据读出错误,此时可使用tcntl或者select等函数实现异步读取。用select先查询com口,再用read去读就可以避免上述错误。

    7.关闭串口

    串口作为文件来处理,所以一般的关闭文件函数即可:
    close(fd);

    8.例子

    这个例子中,需要打开串口1,设置9600波特率、8位数据位、1位停止位以及空校验,之后利用while语句循环判断串口中是否可以读出数据,将串口中数据连续读出后重新写回到串口中。
    该程序可与minicom联合测试。
    #include     <stdio.h>
    #include     <stdlib.h> 
    #include     <unistd.h>
      
    #include     <sys/types.h>

    #include     <sys/stat.h>
    #include     <fcntl.h> 
    #include     <termios.h>

    #include     <errno.h>
       
    main()
    {
        
    int fd;
        int
     i;
        int
     len;
        int n = 0
    ;      
        char read_buf[256
    ];
        char write_buf[256
    ];
        struct
     termios opt; 
        
        fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY);    //默认为阻塞读方式

        if(fd == -1)
        {
            perror("open serial 0\n"
    );
            exit(0
    );
        }

        tcgetattr(fd, &
    opt);      
        cfsetispeed(&
    opt, B9600);
        cfsetospeed(&
    opt, B9600);
        
        if(tcsetattr(fd, TCSANOW, &opt) != 0
     )
        {     
           perror("tcsetattr error"
    );
           return -1
    ;
        }
        
        opt.c_cflag &= ~
    CSIZE;  
        opt.c_cflag |=
     CS8;   
        opt.c_cflag &= ~
    CSTOPB; 
        opt.c_cflag &= ~
    PARENB; 
        opt.c_cflag &= ~
    INPCK;
        opt.c_cflag |= (CLOCAL |
     CREAD);
     
        opt.c_lflag &= ~(ICANON | ECHO | ECHOE |
     ISIG);
     
        opt.c_oflag &= ~
    OPOST;
        opt.c_oflag &= ~(ONLCR | OCRNL);    //添加的

     
        opt.c_iflag &= ~(ICRNL |
     INLCR);
        opt.c_iflag &= ~(IXON | IXOFF | IXANY);    //添加的

        
        opt.c_cc[VTIME] = 0
    ;
        opt.c_cc[VMIN] = 0
    ;
        
        tcflush(fd, TCIOFLUSH);
     
        printf("configure complete\n"
    );
        
        if(tcsetattr(fd, TCSANOW, &opt) != 0
    )
        {
            perror("serial error"
    );
            return -1
    ;
        }
        printf("start send and receive data\n"
    );
      
        while(1
    )
        {    
            n = 0
    ;
            len = 0
    ;
            bzero(read_buf, sizeof(read_buf));    //类似于memset

            bzero(write_buf, sizeof(write_buf));
     
            while( (n = read(fd, read_buf, sizeof(read_buf))) > 0
     )
            {
                for(i = len; i < (len + n); i++
    )
                {
                    write_buf[i] = read_buf[i -
     len];
                }
                len +=
     n;
            }
            write_buf[len] = '\0'
    ;
                  
            printf("Len %d \n"
    , len);
            printf("%s \n"
    , write_buf);
     
            n =
     write(fd, write_buf, len);
            printf("write %d chars\n"
    ,n);
            
            sleep(2
    );
        }
    }


    9.附录

    c_cflag用于设置控制参数,除了波特率外还包含以下内容: 
    EXTA         External rate clock
    EXTB         External rate clock
    CSIZE         Bit mask for data bits
    CS5         5个数据位
    CS6         6个数据位
    CS7         7个数据位
    CS8         8个数据位
    CSTOPB         2个停止位(清除该标志表示1个停止位
    PARENB         允许校验位
    PARODD         使用奇校验(清除该标志表示使用偶校验)
    CREAD         Enable receiver
    HUPCL         Hangup (drop DTR) on last close
    CLOCAL         Local line – do not change “owner” of port
    LOBLK         Block job control outpu
    c_cflag标志可以定义CLOCAL和CREAD,这将确保该程序不被其他端口控制和信号干扰,同时串口驱动将读取进入的数据。CLOCAL和CREAD通常总是被是能的。

    c_lflag用于设置本地模式,决定串口驱动如何处理输入字符,设置内容如下:
    ISIG            Enable SIGINTR, SIGSUSP, SIGDSUSP, and SIGQUIT signals 
    ICANON         Enable canonical input (else raw) 
    XCASE         Map uppercase \lowercase (obsolete) 
    ECHO         Enable echoing of input characters 
    ECHOE         Echo erase character as BS-SP-BS 
    ECHOK         Echo NL after kill character 
    ECHONL         Echo NL 
    NOFLSH         Disable flushing of input buffers after interrupt or quit characters 
    IEXTEN         Enable extended functions 
    ECHOCTL         Echo control characters as ^char and delete as ~? 
    ECHOPRT         Echo erased character as character erased 
    ECHOKE         BS-SP-BS entire line on line kill 
    FLUSHO         Output being flushed 
    PENDIN         Retype pending input at next read or input char 
    TOSTOP         Send SIGTTOU for background output

    c_iflag用于设置如何处理串口上接收到的数据,包含如下内容:
    INPCK         Enable parity check 
    IGNPAR         Ignore parity errors 
    PARMRK      Mark parity errors 
    ISTRIP         Strip parity bits 
    IXON         Enable software flow control (outgoing) 
    IXOFF         Enable software flow control (incoming) 
    IXANY         Allow any character to start flow again 
    IGNBRK         Ignore break condition 
    BRKINT         Send a SIGINT when a break condition is detected 
    INLCR         Map NL to CR 
    IGNCR         Ignore CR 
    ICRNL         Map CR to NL 
    IUCLC         Map uppercase to lowercase 
    IMAXBEL      Echo BEL on input line too long

    c_oflag用于设置如何处理输出数据,包含如下内容:
    OPOST         Postprocess output (not set = raw output) 
    OLCUC         Map lowercase to uppercase 
    ONLCR         Map NL to CR-NL 
    OCRNL         Map CR to NL 
    NOCR         No CR output at column 0 
    ONLRET      NL performs CR function 
    OFILL         Use fill characters for delay 
    OFDEL         Fill character is DEL 
    NLDLY         Mask for delay time needed between lines 
    NL0            No delay for NLs 
    NL1            Delay further output after newline for 100 milliseconds 
    CRDLY      Mask for delay time needed to return carriage to left column 
    CR0            No delay for CRs 
    CR1            Delay after CRs depending on current column position 
    CR2            Delay 100 milliseconds after sending CRs 
    CR3            Delay 150 milliseconds after sending CRs 
    TABDLY      Mask for delay time needed after TABs 
    TAB0            No delay for TABs 
    TAB1         Delay after TABs depending on current column position 
    TAB2         Delay 100 milliseconds after sending TABs 
    TAB3         Expand TAB characters to spaces 
    BSDLY      Mask for delay time needed after BSs 
    BS0         No delay for BSs 
    BS1         Delay 50 milliseconds after sending BSs 
    VTDLY      Mask for delay time needed after VTs 
    VT0         No delay for VTs 
    VT1         Delay 2 seconds after sending VTs 
    FFDLY      Mask for delay time needed after FFs 
    FF0         No delay for FFs 
    FF1         Delay 2 seconds after sending FFs

    c_cc定义了控制字符,包含以下内容:
    VINTR  Interrupt  CTRL-C 
    VQUIT  Quit    CTRL-Z 
    VERASE   Erase    Backspace (BS) 
    VKILL   Kill-line   CTRL-U 
    VEOF   End-of-file   CTRL-D 
    VEOL   End-of-line   Carriage return (CR) 
    VEOL2   Second    end-of-line Line feed (LF) 
    VMIN   Minimum number of characters to read  
    VSTART   Start flow   CTRL-Q (XON) 
    VSTOP   Stop flow   CTRL-S (XOFF) 
    VTIME   Time to wait for data (tenths of seconds) 

    注意:控制符VTIME和VMIN之间有复杂的关系。VTIME定义要求等待的时间(百毫米,通常是unsigned char变量),而VMIN定义了要求等待的最小字节数(相比之下,read函数的第三个参数指定了要求读的最大字节数)。
    如果VTIME=0,VMIN=要求等待读取的最小字节数,read必须在读取了VMIN个字节的数据或者收到一个信号才会返回。
    如果VTIME=时间量,VMIN=0,不管能否读取到数据,read也要等待VTIME的时间量。
    如果VTIME=时间量,VMIN=要求等待读取的最小字节数,那么将从read读取第一个字节的数据时开始计时,并会在读取到VMIN个字节或者VTIME时间后返回。
    如果VTIME=0,VMIN=0,不管能否读取到数据,read都会立即返回。

    如何清除串口缓冲区中的数据

    tcflush函数清除串口输入缓存(终端驱动已接到,但用户尚未读取)或串口输出缓存(用户已经写如缓存,但尚未发送)。

    函数原型:

    int tcflush(int filedes,int quene)

    参数解释

    filedes:  描述符。

    quene取值及含义:

       *TCIFLUSH  清除输入队列
       *TCOFLUSH  清除输出队列
       *TCIOFLUSH 清除输入、输出队列

    举例:tcflush(fd,TCIOFLUSH);


    另加的说明:

    在打开串口后,用户其实其实已经可以开始从串口读取数据了,但如果用户没有读取,数据将被将保存在缓冲区里。如果用户不想要开始的一段数据,或者发现缓冲区数据有误,可以使用这个函数将缓冲区清空。


    应用举例:

    tcflush(fd, TCIOFLUSH);

    sleep(2);
    read_len = read(fd, buff, 10);

    这样,在sleep之前的输入输出队列中的数据都被清空了。


    展开全文
  • 串口的模式控制是通过options.c_lflag控制的,如:options.c_lflag &=~ICANON设置串口原始模式。在原始模式下,它们决定了read()函数在什么时候返 回。在标准的模式下,除非设置了非阻塞的模式(O_NONBLICK)选项,...
  • 串口操作需要的头文件 #include /*标准输入输出定义*/ #include /*标准函数库定义*/ #include /*Unix 标准函数定义*/ #include #include #include /*文件控制定义*/ ...在前面已经提到linux下的串口访问
  • linux串口控制read()

    2010-07-14 11:16:00
    linux串口控制read() 在数组c_cc中有两个下标(VTIME和VMIN)对应的元素不是控制符,并且只是在原始的模式下才有效。串口的模式控制是通过options.c_lflag控制的,如:options.c_lflag &=~ICANON设置串口为原始模式...
  • Linux串口收发通信

    2020-06-11 12:08:04
    Linux下编程的过程有些固定,很多都是比如打开、配置、关闭等等 串口通信流程:打开串口ttySn---&gt;初始化串口---&gt;读写(read、write)---&gt;关闭串口 最合适的指导书:...
  • 串口设置中,有以下两个参数可以决定是否阻塞。 O_NONBLOCK O_NDELAY O_NONBLOCK和O_NDELAY所产生的结果都是使I/O变成非搁置模式(non-blocking),在读取不到数据或是写入缓冲区已满会马上return,而不会搁置...
  • Linux对所有设备的访问是通过设备文件来进行的,串口也是这样,为了访问串口,只需打开其设备文件即可操作串口设备。在linux系统下面,每一个串口设备都有设备文件与其关联,设备文件位于系统的/dev目录下面。如...
  • 本程序通过传参的形式,指定串口设备节点和波特率,将串口...同时该示例程序也为以后linux使用串口时做参考。 如下代码亲测可用,由于使用了线程循环读数据存放到串口缓冲区,编译时需要链接-lpthread库 。 /...
  • linux串口编程 select

    2016-06-08 14:40:22
    1、串口的阻塞和非阻塞 阻塞的定义:  对于read,block指当串口输入缓冲区没有数据的时候,read函数将会阻塞在这里,一直到串口输入缓冲区中有数据可读取,read读到了需要的字节数之后,返回值为读到的字节数,...
  • Linux串口属性设置

    2019-06-15 13:56:32
    串口属于终端设备,其接口属性用termios结构描述,如程序清单13.9所示。 程序清单13.9 termios结构 structtermios{ tcflag_tc_cflag/*控制标志*/ tcflag_tc_iflag;/*输入标志*/ tcflag_tc_oflag;/*输出标志*/ ...
  • Linux串口编程详解

    2014-05-14 09:21:08
    虽然以太网接口和USB接口也是以一个串行流进行数据传送的,但是串口连接通常特指那些RS-232标准兼容的硬件或者调制解调器的接口。虽然现在在很多个人计算机上,原来用以连接外部设备的串口已经广泛的被USB和...
1 2 3 4 5 ... 20
收藏数 4,391
精华内容 1,756
关键字:

linux串口原始模式与