epoll机制读取linux串口数据

最新推荐文章于 2022-10-08 16:45:01 发布

coding__madman

最新推荐文章于 2022-10-08 16:45:01 发布

阅读量8.9k

点赞数 4

分类专栏： linux应用编程文章标签： epoll 串口 Linux 应用编程

本文链接：https://blog.csdn.net/coding__madman/article/details/51657944

版权

linux应用编程专栏收录该内容

18 篇文章 1 订阅

订阅专栏

1、基本知识

　　epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。

2、epoll接口

　　epoll操作过程需要三个接口，分别如下：

#include <sys/epoll.h>
int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

（1） int epoll_create(int size);
　　创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。

（2）int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
　　epoll的事件注册函数，它不同与select()是在监听事件时告诉内核要监听什么类型的事件epoll的事件注册函数，它不同与select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。第一个参数是epoll_create()的返回值，第二个参数表示动作，用三个宏来表示：
EPOLL_CTL_ADD：注册新的fd到epfd中；
EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
EPOLL_CTL_DEL：从epfd中删除一个fd；
第三个参数是需要监听的fd，第四个参数是告诉内核需要监听什么事，struct epoll_event结构如下：

struct epoll_event {
  __uint32_t events;  /* Epoll events */
  epoll_data_t data;  /* User data variable */
};

events可以是以下几个宏的集合：
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET：将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里

（3） int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
　　等待事件的产生，类似于select()调用。参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。该函数返回需要处理的事件数目，如返回0表示已超时。

3、工作模式

　　epoll对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下：

　　LT模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll_wait时，会再次响应应用程序并通知此事件。

　　ET模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll_wait时，不会再次响应应用程序并通知此事件。

　　ET模式在很大程度上减少了epoll事件被重复触发的次数，因此效率要比LT模式高。epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。

epoll和select相比，最大不同在于:
1epoll返回时已经明确的知道哪个sokcet fd发生了事件，不用再一个个比对。这样就提高了效率。
2select的FD_SETSIZE是有限止的，而epoll是没有限止的只与系统资源有关。

ET模式，即，边沿触发，类似于电平触发，epoll中的边沿触发的意思是只对新到的数据进行通知，而内核缓冲区中如果是旧数据则不进行通知，所以在read函数中应该使用如下循环，才能将内核缓冲区中的数据读完。

int len = 0;
int rdlen=0;
char * ReadBuff, const int ReadLen;
	while(true){
		rdlen = read(fd, ReadBuff + len, ReadLen);
		len+=rdlen;
		if(len==ReadLen){
			return len;
		}
	}

epoll有2种工作方式:LT和ET
LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表．

ET (edge-triggered)是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了(比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK 错误）。但是请注意，如果一直不对这个fd作IO操作(从而导致它再次变成未就绪)，内核不会发送更多的通知(only once),不过在TCP协议中，ET模式的加速效用仍需要更多的benchmark确认。

下面是一个自己编写的简单测试例程，向串口发指令然后接在串口上的设备返回数据，这里读取8个有效字节！只读取一个串口！

com.c

#include "com.h"

int openSerial(char *cSerialName)
{
    int iFd;

    struct termios opt; 

    iFd = open(cSerialName, O_RDWR | O_NOCTTY |O_NONBLOCK);
	//iFd = open(cSerialName, O_RDWR | O_NOCTTY | O_NDELAY);//阻塞 |O_RSYNC
    if(iFd < 0) {
        perror(cSerialName);
        return -1;
    }

    tcgetattr(iFd, &opt);      

    cfsetispeed(&opt, B9600);
    cfsetospeed(&opt, B9600);

    
    /*
     * raw mode
     */
    opt.c_lflag   &=   ~(ECHO   |   ICANON   |   IEXTEN   |   ISIG);
    opt.c_iflag   &=   ~(BRKINT   |   ICRNL   |   INPCK   |   ISTRIP   |   IXON);
    opt.c_oflag   &=   ~(OPOST);
    opt.c_cflag   &=   ~(CSIZE   |   PARENB);
    opt.c_cflag   |=   CS8;

    /*
     * 'DATA_LEN' bytes can be read by serial
     */
    opt.c_cc[VMIN]   =   DATA_LEN;                                      
    opt.c_cc[VTIME]  =   150;

    if (tcsetattr(iFd,   TCSANOW,   &opt)<0) {
        return   -1;
    }


    return iFd;
}


int EpollInit(int cfd)
{
	epid = epoll_create(6);//放在初始化
	
	event.events = EPOLLET | EPOLLIN;
	event.data.fd = cfd;
	if (epoll_ctl(epid, EPOLL_CTL_ADD, cfd, &event) != 0) {//将读事件添加到epoll的事件队列中
		printf("set epoll error!\n");
		return 0;
	}
	printf("set epoll ok!\n");
	
	return 1;
}

int ComRead(char * ReadBuff,const int ReadLen)
{
	
	int read_len = 0;
	int len = 0;

	//下面开始epoll等待
	int i =0,witeNum= 0;
	while (1) 
	{
		witeNum = epoll_wait(epid, events, 1, 50);
		printf("witeNum0 = %d\n   ", witeNum);
		if( witeNum == 0)
				return 0;
		//printf("witeNum = %d\n", witeNum);
		
		for (i = 0; i < witeNum; i++) 
		{

			if ((events[i].events & EPOLLERR)
					|| (events[i].events & EPOLLHUP)
					|| (!(events[i].events & EPOLLIN))) 
			{
				printf("no data!\n");
				break;
			} 
			else if (events[i].events & EPOLLIN) 
			{//有数据进入  接受数据
				len = read(events[i].data.fd, ReadBuff, ReadLen);
				tcdrain(fd);
			    tcflush(fd,TCIOFLUSH);

				if(len != ReadLen) //如何保证每次都读到这些字节又不阻塞！ 
				{
					bzero(ReadBuff,15);
				}
				
				if( len == ReadLen)
				 return len;
		 
			}
		}
	}

	return len ;
}

com.h

#ifndef _COM_H_
#define _COM_H_

#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>   
#include <limits.h> 
#include <asm/ioctls.h>
#include <time.h>
#include <pthread.h>
#include <sys/ioctl.h>
#include <sys/epoll.h> 
#include <string.h>

//#define MAXLEN 15

#define DATA_LEN                0xFF         

int fd;//文件描述符
int epid; //epoll标识符
struct epoll_event event;
struct epoll_event events[6];//事件集合
//char RecvBuff[MAXLEN];//接受到的数据

int ComRead(char * ReadBuff,const int ReadLen);//com口读数据
int EpollInit(int cfd);

int  openSerial(char *cSerialName);


#endif

main.c

#include <stdio.h>
#include "com.h"

int main(void)
{
	char tmp[15] = {0};
	int rl;
	int write_len;
	char* text = ".P\r\n" ;
	int i;

	fd = openSerial("/dev/ttySP2");
	
	if(fd < 0)
	{
		printf("open com fail!\n");
		return 0;
	}
	
	EpollInit(fd);
	
	while(1)
	{
		bzero(tmp,sizeof(tmp));
	    tcflush(fd,TCIOFLUSH);//清空串口输入输出缓存
		
		write_len = write(fd, text, strlen(".P\r\n"));//向串口发送指令
		
		if(write_len != 4)
		{
			printf("write fail!\n");
			return 0;
		}
		
		rl = ComRead(tmp,8);//读取8个字节放到缓存
         
		//打印读到的数据
		printf("write_len = %d,  read_len = %d\n", write_len, rl);
		tmp[rl] = '\0';
		printf("read: %s\n", tmp);	
		for(i = 0; i < rl; i++)
			printf(" %d", tmp[i]);
		printf("\n\n");
		
		if(rl != 8)
		{
			printf("read fail!\n");
		}
	
	}
	
	close(epid);
	close(fd);
	
	return 0;
}

makefile

EXEC	= TEST
OBJS    = com.o main.o 
SRC     = com.c main.c

CROSS	= arm-fsl-linux-gnueabi-
CC	     = $(CROSS)gcc 
STRIP	= $(CROSS)strip
CFLAGS	= -g -Wall
LDFLAGS +=

all:  clean $(EXEC)

$(EXEC):$(OBJS)
	$(CC) $(LDFLAGS) -o $@ $(OBJS) -lm  -pthread
	$(STRIP) $@
%.o:%.c
	$(CC) $(CFLAGS) -c $< -o $@ 

clean:
	-rm -f $(EXEC) *.o

程序能完好运行！但是还有一个BUG，比如一次读取多个字节（大于8个字节）会有数据丢失的情况，比如读取9个字节，三次读到的字节数为9、8、8

然后就一直9、8、8这样循环，原因暂时还没搞明白！串口用的是非阻塞模式打开的！

coding__madman

关注

4
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
epoll机制读取linux串口数据

epoll和select相比，最大不同在于:1epoll返回时已经明确的知道哪个sokcet fd发生了事件，不用再一个个比对。这样就提高了效率。2select的FD_SETSIZE是有限止的，而epoll是没有限止的只与系统资源有关。
复制链接

扫一扫