linux下串口的阻塞和非阻塞操作

最新推荐文章于 2024-07-24 21:55:59 发布
最新推荐文章于 2024-07-24 21:55:59 发布
阅读量1.7k 收藏 4
点赞数
分类专栏： Linux
有两个可以进行控制串口阻塞性（同时控制read和write）：一个是在打开串口的时候，open函数是否带O_NDELAY；第二个是可以在打开串口之后通过fcntl()函数进行控制。

阻塞的定义：

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

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

非阻塞的定义：

对于read，no block指当串口输入缓冲区没有数据的时候，read函数立即返回，返回值为0。

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

[cpp] view plain copy
print ?
  1. static int set_opt(int fd, int nSpeed, int nBits, char nEvent, int nStop)     
  2. {     
  3.     struct termios newtio;     
  4.     struct termios oldtio;     
  5.          
  6.     if(tcgetattr(fd,&oldtio) != 0)     
  7.     {     
  8.         perror("SetupSerial 1");     
  9.         return -1;     
  10.     }     
  11.          
  12.     bzero(&newtio,sizeof(newtio));     
  13.     newtio.c_cflag |= CLOCAL |CREAD;     
  14.     newtio.c_cflag &= ~CSIZE;     
  15.       
  16. /***********数据位选择****************/      
  17.     switch(nBits)     
  18.     {     
  19.         case 7:     
  20.         newtio.c_cflag |= CS7;     
  21.         break;     
  22.         case 8:     
  23.         newtio.c_cflag |= CS8;     
  24.         break;         
  25.     }     
  26. /***********校验位选择****************/    
  27.     switch(nEvent)     
  28.     {     
  29.         case 'O':     
  30.         newtio.c_cflag |= PARENB;     
  31.         newtio.c_cflag |= PARODD;     
  32.         newtio.c_iflag |= (INPCK | ISTRIP);     
  33.             break;     
  34.         case 'E':     
  35.         newtio.c_iflag |= (INPCK |ISTRIP);     
  36.         newtio.c_cflag |= PARENB;     
  37.         newtio.c_cflag &= ~PARODD;     
  38.             break;     
  39.          case 'N':     
  40.         newtio.c_cflag &= ~PARENB;     
  41.             break;     
  42.     }     
  43. /***********波特率选择****************/     
  44.     switch(nSpeed)     
  45.     {     
  46.         case 2400:     
  47.         cfsetispeed(&newtio,B2400);     
  48.         cfsetospeed(&newtio,B2400);     
  49.             break;     
  50.          case 4800:     
  51.         cfsetispeed(&newtio,B4800);     
  52.         cfsetospeed(&newtio,B4800);     
  53.             break;     
  54.          case 9600:     
  55.         cfsetispeed(&newtio,B9600);     
  56.         cfsetospeed(&newtio,B9600);     
  57.             break;   
  58.          case 57600:     
  59.         cfsetispeed(&newtio,B57600);     
  60.         cfsetospeed(&newtio,B57600);     
  61.             break;     
  62.          case 115200:     
  63.         cfsetispeed(&newtio,B115200);     
  64.         cfsetospeed(&newtio,B115200);     
  65.             break;     
  66.          case 460800:     
  67.         cfsetispeed(&newtio,B460800);     
  68.         cfsetospeed(&newtio,B460800);     
  69.             break;               
  70.          default:     
  71.         cfsetispeed(&newtio,B9600);     
  72.         cfsetospeed(&newtio,B9600);     
  73.                 break;     
  74.     }     
  75. /***********停止位选择****************/    
  76.     if(nStop == 1){     
  77.         newtio.c_cflag &= ~CSTOPB;     
  78.     }     
  79.     else if(nStop ==2){     
  80.         newtio.c_cflag |= CSTOPB;     
  81.     }     
  82.     newtio.c_cc[VTIME] = 1;     
  83.     newtio.c_cc[VMIN] = FRAME_MAXSIZE;   //阻塞条件下有效  
  84.     
  85.     tcflush(fd,TCIFLUSH);     
  86.     if((tcsetattr(fd,TCSANOW,&newtio)) != 0)     
  87.     {     
  88.         perror("com set error");     
  89.         return -1;     
  90.     }     
  91.     printf("set done!\n");     
  92.     return 0;     
  93. }     
static int set_opt(int fd, int nSpeed, int nBits, char nEvent, int nStop)   
{   
    struct termios newtio;   
    struct termios oldtio;   
       
    if(tcgetattr(fd,&oldtio) != 0)   
    {   
        perror("SetupSerial 1");   
        return -1;   
    }   
       
    bzero(&newtio,sizeof(newtio));   
    newtio.c_cflag |= CLOCAL |CREAD;   
    newtio.c_cflag &= ~CSIZE;   
	
/***********数据位选择****************/    
    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 57600:   
        cfsetispeed(&newtio,B57600);   
        cfsetospeed(&newtio,B57600);   
        	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] = 1;   
    newtio.c_cc[VMIN] = FRAME_MAXSIZE;   //阻塞条件下有效
  
    tcflush(fd,TCIFLUSH);   
    if((tcsetattr(fd,TCSANOW,&newtio)) != 0)   
    {   
        perror("com set error");   
        return -1;   
    }   
    printf("set done!\n");   
    return 0;   
}

[cpp] view plain copy
print ?
  1. static int open_port(int fd,int comport)     
  2. {       
  3. /***********打开串口1****************/  
  4.     if(comport == 1)     
  5.     {     
  6.         fd = open("/dev/ttyAT1",O_RDWR|O_NOCTTY|O_NDELAY);     
  7.     if(fd == -1){     
  8.         perror("Can't Open Serial Port");     
  9.         return -1;     
  10.         }     
  11.     }     
  12.  /***********打开串口2****************/   
  13.     else if(comport == 2)     
  14.     {     
  15.         fd = open("/dev/ttyAT2",O_RDWR|O_NOCTTY|O_NDELAY);     
  16.         if(fd == -1){     
  17.             perror("Can't Open Serial Port");     
  18.             return -1;     
  19.         }     
  20.     }     
  21. /***********打开串口3****************/    
  22.     else if(comport == 3)     
  23.     {     
  24.         fd = open("/dev/ttyAT3",O_RDWR|O_NOCTTY|O_NDELAY);     
  25.         if(fd == -1){     
  26.             perror("Can't Open Serial Port");     
  27.             return -1;     
  28.         }     
  29.     }     
  30.     if(comport == 1)  
  31.     {  
  32.         if(fcntl(fd,F_SETFL,FNDELAY) < 0)//非阻塞，覆盖前面open的属性  
  33.         {     
  34.             printf("fcntl failed\n");     
  35.         }     
  36.         else{     
  37.         printf("fcntl=%d\n",fcntl(fd,F_SETFL,FNDELAY));     
  38.         }   
  39.     }  
  40.     else  
  41.     {  
  42.         if(fcntl(fd,F_SETFL,0) < 0){   //阻塞，即使前面在open串口设备时设置的是非阻塞的，这里设为阻塞后，以此为准  
  43.         printf("fcntl failed\n");     
  44.         }     
  45.         else{     
  46.         printf("fcntl=%d\n",fcntl(fd,F_SETFL,0));     
  47.         }   
  48.     }     
  49.     if(isatty(STDIN_FILENO) == 0){   
  50.         
  51.     printf("standard input is not a terminal device\n");     
  52.     }     
  53.     else{     
  54.           
  55.         printf("isatty sucess!\n");     
  56.     }    
  57.   
  58.     printf("fd-open=%d\n",fd);     
  59.     return fd;     
  60. }  
static int open_port(int fd,int comport)   
{     
/***********打开串口1****************/
    if(comport == 1)   
    {   
        fd = open("/dev/ttyAT1",O_RDWR|O_NOCTTY|O_NDELAY);   
    if(fd == -1){   
        perror("Can't Open Serial Port");   
        return -1;   
        }   
    }   
 /***********打开串口2****************/ 
    else if(comport == 2)   
    {   
        fd = open("/dev/ttyAT2",O_RDWR|O_NOCTTY|O_NDELAY);   
        if(fd == -1){   
            perror("Can't Open Serial Port");   
            return -1;   
        }   
    }   
/***********打开串口3****************/  
    else if(comport == 3)   
    {   
        fd = open("/dev/ttyAT3",O_RDWR|O_NOCTTY|O_NDELAY);   
        if(fd == -1){   
            perror("Can't Open Serial Port");   
            return -1;   
        }   
    }   
	if(comport == 1)
	{
		if(fcntl(fd,F_SETFL,FNDELAY) < 0)//非阻塞，覆盖前面open的属性
		{   
			printf("fcntl failed\n");   
		}   
		else{   
		printf("fcntl=%d\n",fcntl(fd,F_SETFL,FNDELAY));   
		} 
	}
	else
	{
		if(fcntl(fd,F_SETFL,0) < 0){   //阻塞，即使前面在open串口设备时设置的是非阻塞的，这里设为阻塞后，以此为准
		printf("fcntl failed\n");   
		}   
		else{   
		printf("fcntl=%d\n",fcntl(fd,F_SETFL,0));   
		} 
	}   
    if(isatty(STDIN_FILENO) == 0){ 
	  
    printf("standard input is not a terminal device\n");   
    }   
    else{   
		
        printf("isatty sucess!\n");   
    }  

    printf("fd-open=%d\n",fd);   
    return fd;   
}

所以，Linux的串口的阻塞性通过fcntl()函数进行设置即可。


[cpp] view plain copy
print ?
  1. 阻塞：fcntl(fd,F_SETFL,0)  
阻塞：fcntl(fd,F_SETFL,0)
[cpp] view plain copy
print ?
  1. 非阻塞：fcntl(fd,F_SETFL,FNDELAY)  

from：http://blog.csdn.net/wuhengwudi/article/details/7454629
致守
关注
专栏目录
【linux】串口编程（二）——非阻塞接收
郭老二
10-11 2335
项目中很少会使用阻塞接收，一般都是select+read监听模式来实现非阻塞接收。 使用selece时，需要处理一些异常情况的返回，比如：系统中断产生EINTR错误；超时错误ETIMEDOUT。 使用read时，需要处理读取时可能出现的错误，比如：对方关闭连接（ECONNRESET），连接被拒绝（ECONNREFUSED），文件描述符错误（EBADF）等
linux 串口阻塞与非阻塞参数设置
weixin_34303897的博客
12-21 584
在串口设置中，有以下两个参数可以决定是否阻塞。 在打开串口时不加O_NODELAY,可用下面的第二种方法，来进行阻塞/非阻塞的设定  c_cc[VTIME] 非规范模式读取时的超时时间(单位:百毫秒),可以这么理解，从接收到后一个字节开始计时，如果超时，则退出READ  c_cc[VMIN]  非规范模式读取时的最小字符数，设为0则为非阻塞，如果设为其它值则阻塞，直到读到到对应的数据 关键...
STM32的HAL库串口阻塞接收和非阻塞接收的区别
最新发布
jacklood的博客
07-24 219
1、使用函数的区别：是否有超时时间值。
linux 串口阻塞和非阻塞
cogizh
09-03 5402
有两个可以进行控制串口阻塞性（同时控制read和write）：一个是在打开串口的时候，open函数是否带O_NDELAY；第二个是可以在打开串口之后通过fcntl()函数进行控制。 不过在一般的程序中我们使用O_NOBLOCK参数，O_NONBLOCK和O_NDELAY所产生的结果都是使I/O变成非搁置模式(non-blocking)，在读取不到数据或是写入缓冲区已满会马上return，而不会搁
linux gcc tty 串口非阻塞读取与发送
11-08
tty 串口非阻塞读取与发送 实例 好用的测试串口实例
linux下串口编程及非标准波特率的实现代码
01-14
总之，Linux下的串口编程是一个涉及操作系统、硬件接口和通信协议的综合实践。C语言提供的低级接口使我们能够灵活地控制串口，实现包括非标准波特率在内的各种功能。通过深入研究并实践，你将能够熟练掌握这一技能，...
串口通信非阻塞
08-24
在实现非阻塞串口通信时，通常会用到操作系统提供的异步I/O接口，如Linux下的`select`、`poll`或`epoll`，Windows下的`CreateIoCompletionPort`等。这些机制使得应用程序可以注册事件回调，当串口有数据可读或可写时...
linux 串口 o_nonblock o_ndelay,Linux阻塞与非阻塞串行读取
weixin_33236524的博客
05-08 1511
您提到的代码是IMO编码和评论不佳。该代码不符合POSIX实现的可移植性，如正确设置终端模式和POSIX操作系统的串行编程指南中所述。该代码未提及它使用非规范(又称原始)模式，并重用“阻塞”和“非阻塞”术语来描述VMIN和VTIME属性。(该代码的作者报告它早于POSIX标准，因此它不符合。这是可以理解的，但后来发布并提倡使用可能不可移植的旧代码(即在其他情况下按预期运行) )值得怀疑。)“阻塞”...
C++串口通信类(阻塞和非阻塞都支持)
01-09
C++串口通信类。 可以方便的进行串口通信，如果需要用串口可以试用一下哈。包括阻塞与非阻塞方法。
浅谈阻塞和非阻塞语句的本质区别
10-22
Verilog HDL是目前应用最为广泛的硬件描述语言。Verilog HDL可以用来进行各种层次的逻辑设计，也可以进行数字系统的逻辑综合，仿真验证和时序分析等。Verilog HDL适合算法级，寄存器级，逻辑级，门级和版图级等各个层次的设计和描述。Verilog HDL进行设计最大的优点是其工艺无关性。这使得工程师在功能设计，逻辑验证阶段可以不必过多考虑门级及工艺实现的具体细节，只需根据系统设计的要求施加不同的约束条件，即可设计出实际电路。Verilog HDL是一种硬件描述语言（hardware description language），为了制作数字电路而用来描述ASICs和FPGA的设
Linux串口阻塞与非阻塞
qq_37659294的博客
09-29 2727
Linux串口编程的阻塞与否可以在open函数中设置，例如： 打开时使用： fd = open(USAR1, O_RDWR | O_NOCTTY );//阻塞式读写 fd = open("/dev/ttyAT2",O_RDWR|O_NOCTTY|O_NDELAY); //非阻塞读写 除了用open函数之外还可以在open函数之后用fcntl函数来设置，代码如下： 打开后使用fcn...
linux串口阻塞与非阻塞控制
chongting7934的博客
10-11 277
有两种方法： 　　１.打开时，通过打开参数控制. open(COM_DEV_NAME, O_RDWR | O_NONBLOCK);//非阻塞 open(COM_DEV_NAME, O_RDWR);　　//阻塞 　　２.打开以后可以通过f...
Linux 设备驱动--- 阻塞型字符设备驱动 --- O_NONBLOCK --- 非阻塞标志【转】
weixin_33939380的博客
06-11 419
转自：http://blog.csdn.net/yikai2009/article/details/8653697 版权声明：本文为博主原创文章，未经博主允许不得转载。   目录(?)[-] 阻塞 阻塞操作 非阻塞操作 阻塞方式-read- 实现 阻塞方式-write- 实现 非阻塞方式的读写操作 实例 --- 读阻塞的实现 实例 --- 按键驱动阻塞...
Linux下串口程序开发
轻舞飞扬
07-23 1001
原文链接：http://blog.csdn.net/tianmo2010/article/details/6278992 2.1      读串口 读取串口数据使用文件操作read函数读取，如果设置为原始模式(Raw Mode)传输数据，那么read函数返回的字符数是实际串口收到的字符数。 char  buff[1024]; int    Len; int  readByte =
Linux串口编程详解(阻塞模式、非阻塞模式、select函数)
嵌入式Linux内核的博客
12-27 2691
之前一直觉得串口编程很简单，这两天仔细研究后发现串口里的各种参数还挺复杂，稍不注意就容易出错，这里总结一下网上的各种文章及自己的理解与实践。
linux 串口读数据阻塞
rensichao的博客
07-01 257
现象： 在虚拟机上调试linux串口时，当写入数据后，读数据时遇到阻塞。下面这篇博文对串口各个属性，都要详细介绍，mark一下为以后学习。
Linux下串口编程指南：配置与操作
"这篇教程是关于3dslicer软件中如何打开串口的操作指南，主要涉及Linux下的串口编程。文章提供了详细的步骤和示例代码，包括串口的打开、配置以及读写操作。" 在Linux操作系统中，串口通信是一种基础的硬件接口，常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值