输入系统应用编程--APP访问硬件编程

Posted Heavy sea

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了输入系统应用编程--APP访问硬件编程相关的知识，希望对你有一定的参考价值。

一、输入系统框架

假设用户程序直接访问/dev/input/event0设备节点，或者使用tslib访问设备节点，数据的流程如下：

  • APP发起读操作，若无数据则休眠；
  • 用户操作设备，硬件上产生中断；
  • 输入系统驱动层对应的驱动程序处理中断：
    读取到数据，转换为标准的输入事件，向核心层汇报。
    所谓输入事件就是一个“struct input_event”结构体。
  • 核心层可以决定把输入事件转发给上面哪个handler来处理：
    从handler的名字来看，它就是用来处输入操作的。有多种handler，比如：evdev_handler、kbd_handler、joydev_handler等等。
    最常用的是evdev_handler：它只是把input_event结构体保存在内核buffer等，APP来读取时就原原本本地返回。它支持多个APP同时访问输入设备，每个APP都可以获得同一份输入事件。
    当APP正在等待数据时，evdev_handler会把它唤醒，这样APP就可以返回数据。
  • APP对输入事件的处理：
    APP获得数据的方法有2种：直接访问设备节点(比如/dev/input/event0,1,2,…)，或者通过tslib、libinput这类库来间接访问设备节点。这些库简化了对数据的处理。

APP得到的输入事件

输入事件结构体

struct input_event 
	struct timeval time;  // 发生的时间
	__u16 type;				// 哪类事件
	__u16 code;			// 哪个事件
	__s32 value;			// 事件值
;

事件类型：type
EV_KEY表示按键类、EV_REL表示相对位移(比如鼠标)，EV_ABS表示绝对位置(比如触摸屏)

/*
 * Event types
 */

#define EV_SYN			0x00   // 同步事件
#define EV_KEY			0x01
#define EV_REL			0x02
#define EV_ABS			0x03
#define EV_MSC			0x04
#define EV_SW			0x05
#define EV_LED			0x11
#define EV_SND			0x12
#define EV_REP			0x14
#define EV_FF			0x15
#define EV_PWR			0x16
#define EV_FF_STATUS		0x17
#define EV_MAX			0x1f
#define EV_CNT			(EV_MAX+1)

哪个具体事件：code
对于EV_KEY(按键)类事件，它表示键盘。键盘上有很多按键，比如数字键1、2、3，字母键A、B、C里等。

#define KEY_RESERVED		0
#define KEY_ESC			1
#define KEY_1			2
#define KEY_2			3
#define KEY_3			4
#define KEY_4			5
#define KEY_5			6
#define KEY_6			7
#define KEY_7			8

对于触摸屏，它提供的是绝对位置信息，有X方向、Y方向，还有压力值。所以code值有这些：

#define ABS_X			0x00
#define ABS_Y			0x01
#define ABS_Z			0x02
...........

事件值:value
对于按键，它的value可以是0(表示按键被松开)、1(表示按键被按下)、2(表示长按)；
对于触摸屏，它的value就是坐标值、压力值。

若驱动程序上报完所有数据后，会上报一个同步事件表示数据上报完毕。
同步事件的type、code、value都是0

内核中表示的输入设备

struct input_dev 
	const char *name;
	const char *phys;
	const char *uniq;
	struct input_id id;

	unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];
	
	// 支持哪类事件，支持哪些
	unsigned long evbit[BITS_TO_LONGS(EV_CNT)];
	unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];
	unsigned long relbit[BITS_TO_LONGS(REL_CNT)];
	unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];
	unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];
	unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];
	unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];
	unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
	unsigned long swbit[BITS_TO_LONGS(SW_CNT)];
	..............................

二、常用命令

  • 查看设备节点：ls /dev/input/* -l
  • 查看设备节点对应硬件信息：cat /proc/bus/input/devices
    信息对应内核中表示的输入设备信息

    上图中“B: EV=b”用来表示该设备支持哪类输入事件。b的二进制是1011，bit0、1、3为1，表示该设备支持0、1、3这三类事件，即EV_SYN、EV_KEY、EV_ABS。
  • 使用命令读取数据：hexdump /dev/input/event1（我这里event1表示触摸屏）
    在开发板上执行读取屏幕数据命令后，先会阻塞，点击或滑动触摸屏后，会打印信息。

三、获取输入设备信息


要想打印出struct input_id 中的数据即硬件本身信息，根据linux源码中evdev.c文件中相关函数，可知ioctl的request要写为EVIOCGID。

要想获取硬件支持哪类事件（如相对位移事件，绝对位移事件），就要读取输入设备的evbit，ioctl的request要写为“EVIOCGBIT(0, size)”，size的大小可以由你决定：你想读多少字节就设置为多少。

#include <stdio.h>
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

/*获取输入设备信息*/
/* ./get_input_info /dev/input/event0 */
int main(int argc,char **argv)
   
    struct input_id id;
    int fd;
    int err;
    int len;
    int i;
    int bit;
    unsigned int evbit[2];
    unsigned char byte;
	
	// 支持事件的类型
    char *ev_names[] = 
        "EV_SYN",			
        "EV_KEY",			
        "EV_REL",			
        "EV_ABS",			
        "EV_MSC",			
        "EV_SW",			
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "EV_LED",			
        "EV_SND",			
        "NULL",
        "EV_REP",			
        "EV_FF",			
        "EV_PWR"				
  
    ;
    
    if(argc!=2)
        printf("Usage:%s <dev>\\n",argv[1]);
        return -1;
    

    fd = open(argv[1],O_RDWR);
    if(fd==-1)
        printf("open error\\n");
        return -1;
    

    err = ioctl(fd,EVIOCGID,&id);
    if(err==0)
        printf("bustype is 0x%x\\n",id.bustype);
        printf("vendor is 0x%x\\n" ,id.vendor);
        printf("product is 0x%x\\n",id.product);
        printf("version is 0x%x\\n",id.version);
    

    len = ioctl(fd,EVIOCGBIT(0, sizeof(evbit)),&evbit);
    if(len>0 && len<=sizeof(evbit))
        printf("support ev type:");
        
        for(i=0;i<len;i++)
            byte = ((unsigned char*)evbit)[i];
            
            for(bit=0;bit<8;bit++)
                if(byte & (1<<bit))
                    printf("%s ",ev_names[i*8+bit]);
                
            
        
        printf("\\n");
    
    return 0;

四、APP访问硬件的四种方式

  • 查询方式
  • 休眠-唤醒
  • POLL和select方式
  • 异步通知

在上面获取输入设备的代码基础上实现完成APP访问硬件的编程

1.查询方式和休眠-唤醒方式

1.1介绍

查询方式：应用程序不停地去读取硬件信息，即使没有硬件信息发生
反映到程序上就是用open函数以不阻塞的方式打开设备，触摸屏没有发生事件，打印err,触摸屏发生滑动或点击等事件就打印相应信息。

休眠-唤醒方式：当发生硬件信息，应用程序才会访问硬件
反映到程序上就是用open函数以阻塞的方式（默认方式）打开设备。

1.2代码

#include <stdio.h>
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>

/*获取输入设备信息*/
/*查询方式 休眠-唤醒方式*/
/* ./get_input_info /dev/input/event1 noblock*/
int main(int argc,char **argv)
   
    struct input_id id;
    int fd;
    int err;
    int len;
    int i;
    int bit;
    unsigned int evbit[2];
    unsigned char byte;

    struct input_event event;
    
    char *ev_names[] = 
        "EV_SYN",			
        "EV_KEY",			
        "EV_REL",			
        "EV_ABS",			
        "EV_MSC",			
        "EV_SW",			
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "EV_LED",			
        "EV_SND",			
        "NULL",
        "EV_REP",			
        "EV_FF",			
        "EV_PWR"				
  
    ;
    
    if(argc<2)
        printf("Usage:%s <dev> [noblock]\\n",argv[0]);
        return -1;
    

    if(argc == 3 && !strcmp(argv[2],"noblock"))
        fd = open(argv[1],O_RDWR|O_NONBLOCK);
    else
        fd = open(argv[1],O_RDWR);
    
    
    if(fd==-1)
        printf("open error\\n");
        return -1;
    

    err = ioctl(fd,EVIOCGID,&id);
    if(err==0)
        printf("bustype is 0x%x\\n",id.bustype);
        printf("vendor is 0x%x\\n" ,id.vendor);
        printf("product is 0x%x\\n",id.product);
        printf("version is 0x%x\\n",id.version);
    

    len = ioctl(fd,EVIOCGBIT(0, sizeof(evbit)),&evbit);
    if(len>0 && len<=sizeof(evbit))
        printf("support ev type:");
        
        for(i=0;i<len;i++)
            byte = ((unsigned char*)evbit)[i];
            
            for(bit=0;bit<8;bit++)
                if(byte & (1<<bit))
                    printf("%s ",ev_names[i*8+bit]);
                
            
        
        printf("\\n");
    

    while(1)
    
        len = read(fd,&event,sizeof(event));
        if(len == sizeof(event))
            printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\\n", event.type, event.code, event.value);	 
        else
            sleep(3);
            printf("err\\n");
        
    
    return 0;



// 查询方式
./get_input_info     /dev/input/event1    noblock
//	休眠-唤醒方式
./get_input_info     /dev/input/event1

2.POLL方式及select方式

2.1 说明

APP不是直接调用read函数，而是先调用poll或select函数，这2个函数中可以传入“超时时间”。它们的作用是：如果驱动程序中有数据，则立刻返回；否则就休眠。在休眠期间，如果有人操作了硬件，驱动程序获得数据后就会把APP唤醒，导致poll或select立刻返回；如果在“超时时间”内无人操作硬件，则时间到后poll或select函数也会返回

poll/select函数可以监测多个文件，可以监测多种事件：

事件类型说明
POLLIN有数据可读
POLLRDNORM等同于POLLIN
POLLRDBANDPriority band data can be read，有优先级较较高的“band data”可读
POLLPRI高优先级数据可读
POLLOUT可以写数据
POLLWRNORM等同于POLLOUT
POLLWRBANDPriority data may be written
POLLERR发生了错误
POLLHUP挂起
POLLNVAL无效的请求，一般是fd未open

2.2 poll函数

#include <poll.h>

int poll(struct pollfd fds[], nfds_t nfds, int timeout)；
nfds：nfds_t类型的参数，用于标记数组fds中的结构体元素的总数量；
timeout：是poll函数调用阻塞的时间，单位：毫秒；
返回值为0表示超时
struct pollfd
int fd; /文件描述符/
short events; /* 等待的需要测试事件 /
short revents; / 实际发生了的事件，也就是返回结果 */
;

2.3 poll方式代码

#include <stdio.h>
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <poll.h>

/*poll方式*/
/* ./input_read_poll /dev/input/event0 */
int main(int argc,char **argv)
   
    struct input_id id;
    int fd;
    int err;
    int len;
    int i;
    int bit;
    int ret;
    nfds_t nfds = 1;
    unsigned int evbit[2];
    unsigned char byte;

    struct input_event event;
    struct pollfd fds[1];
    
    char *ev_names[] = 
        "EV_SYN",			
        "EV_KEY",			
        "EV_REL",			
        "EV_ABS",			
        "EV_MSC",			
        "EV_SW",			
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "EV_LED",			
        "EV_SND",			
        "NULL",
        "EV_REP",			
        "EV_FF",			
        "EV_PWR"				
  
    ;
    
    if(argc!=2)
        printf("Usage:%s <dev>\\n",argv[0]);
        return -1;
    

    fd = open(argv[1],O_RDWR|O_NONBLOCK);
    
    if(fd==-1)
        printf("open error\\n");
        return -1;
    

    err = ioctl(fd,EVIOCGID,&id);
    if(err==0)
        printf("bustype is 0x%x\\n",id.bustype);
        printf("vendor is 0x%x\\n" ,id.vendor);
        printf("product is 0x%x\\n",id.product);
        printf("version is 0x%x\\n",id.version);
    

    len = ioctl(fd,EVIOCGBIT(0, sizeof(evbit)),&evbit);
    if(len>0 && len<=sizeof(evbit))
        printf("support ev type:");
        
        for(i=0;i<len;i++)
            byte = ((unsigned char*)evbit)[i];
            
            for(bit=0;bit<8;bit++)
                if(byte & (1<<bit))
                    printf("%s ",ev_names[i*8+bit]);
                
            
        
        printf("\\n");
    

    while(1)
       
        fds[0].fd = fd;
        // 监测的文件事件是数据可读
        fds[0].events = POLLIN;
        fds[0].revents = 0;

        ret = poll(fds,nfds,5000);
        if(ret>0)
       
            
            if(fds[0].revents == POLLIN)
            
                
                while(read(fd,&event,sizeof(event))==sizeof(event))
                
                    printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\\n", event.type, event.code, event.value);
                
                       
        
        else if(ret==0)
        
            printf("time out\\n");
        
        else
        
            printf("poll err\\n");
        
        
    
    return 0;

2.4 select说明

select 方式
POLL机制、SELECT机制是完全一样的，只是APP接口函数不一样

int select(nfds, readfds, writefds, exceptfds, timeout)
nfds：select监视的文件句柄数，视进程中打开的文件数而定,一般设为你要监视各文件中的最大文件号加一。
readfds：select监视的可读文件句柄集合。
writefds: select监视的可写文件句柄集合。
exceptfds：select监视的异常文件句柄集合。
timeout：本次select()的超时结束时间
FD_ZERO(fd_set *fdset)：清空fdset与所有文件句柄的联系。
FD_SET(int fd, fd_set *fdset)：建立文件句柄fd与fdset的联系。
FD_CLR(int fd, fd_set *fdset)：清除文件句柄fd与fdset的联系。
FD_ISSET(int fd, fd_set *fdset)：检查fdset联系的文件句柄fd是否
可读写，当>0表示可读写。

2.4 select方式代码

#include <stdio.h>
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <sys/select.h>


/*select方式*/
/* ./input_read_select /dev/input/event0 */
int main(int argc,char **argv)
   
    struct input_id id;
    int fd;
    int err;
    int len;
    int i;
    int bit;
    int ret;
    // 最大的文件句柄数+1
    int nfds = fd+1;
    fd_set readfds[1] = fd;
   
    unsigned int evbit[2];
    unsigned char byte;

    struct input_event event;
    struct timeval time;
    
    char *ev_names[] = 
        "EV_SYN",			
        "EV_KEY",			
        "EV_REL",			
        "EV_ABS",			
        "EV_MSC",			
        "EV_SW",			
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "EV_LED",			
        "EV_SND",			
        "NULL",
        "EV_REP",			
        "EV_FF",			
        "EV_PWR"				
  
    ;
    
    if(argc!=2)
        printf("Usage:%s <dev>\\n",argv[0]);
        return -1;
    

    fd = open(argv[1],O_RDWR|O_NONBLOCK);
    
    if(fd==-1)
        printf("open error\\n");
        return -1;
    

    err = ioctl(fd,EVIOCGID,&id);
    if(err==0)
        printf("bustype is 0x%x\\n",id.bustype);
        printf("vendor is 0x%x\\n" ,id.vendor);
        printf("product is 0x%x\\n",id.product);
        printf("version is 0x%x\\n",id.version);
    

    len = ioctl(fd,EVIOCGBIT(0, sizeof(evbit)),&evbit);
    if(len>0 && len<=sizeof(evbit))
        printf("support ev type:");
        
        for(i=0;i<len;i++)
            byte = ((unsigned char*)evbit)[i];
            
            for(bit=0;bit<8;bit++)
                if(byte & (1<<bit))
                    printf("%s ",ev_names[i*8+bit]);
                
            
        
        printf("\\n");
    

    while(1)
       
        // 清零
        FD_ZERO(readfds);
        // 建立文件句柄fd与readfds的联系
        FD_SET(fd, readfds);

        // 设置超时时间
        time.tv_sec = 5;
        time.tv_usec = 0;
        
        ret = select(nfds,readfds,NULL,NULL,&time);
        if(ret>0)
       
            //再次确认fd有数据
            if(FD_ISSET(fd, readfds))
            
                memset(&event,0,sizeof(event));
                while(read(fd,&event,sizeof(event))==sizeof(event))
                
                    printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\\n", event.type, event.code, event.value);
                
                       
        
        else if(ret==0)
        
            printf("time out\\n");
        
        else
        
            printf("select err\\n");
        
        
    
    return 0;

3.异步通信方式

3.1 说明

异步通知，就是APP可以忙自己的事，当驱动程序用数据时它会主动给APP发信号，这会导致APP执行信号处理函数。

驱动程序通知APP时，它会发出“SIGIO”这个信号，表示有“IO事件”要处理。
就APP而言，你想处理SIGIO信息，那么需要提供信号处理函数，并且要跟SIGIO挂钩。这可以通过一个signal函数来“给某个信号注册处理函数”

linux信号具体介绍可参照这里

#include <signal.h>
typedef void (*sighandler_t)(int);
 sighandler_t signal(int signum, sighandler_t handler);

在编程时需要注意以下几点：

  • 内核里有那么多驱动，你想让哪一个驱动给你发SIGIO信号？
    APP要打开驱动程序的设备节点。
  • 驱动程序怎么知道要发信号给你而不是别人？
    APP要把自己的进程ID告诉驱动程序。
  • APP有时候想收到信号，有时候又不想收到信号：
    应该可以把APP的意愿告诉驱动：设置Flag里面的FASYNC位为1，使能“异步通知”。

linux fcntl函数详解可参照这里

3.2 代码

#include <stdio.h>
#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>

int fd;

void sig_hanler()
   
    struct input_event event;

    memset(&event,0,sizeof(event));
    while(read(fd,&event,sizeof(event))==sizeof(event))
    
        printf("get event: type = 0x%x, code = 0x%x, value = 0x%x\\n", event.type, event.code, event.value);
    


/*异步通信*/
/* ./input_read_fasync /dev/input/event1 */
int main(int argc,char **argv)
   
    struct input_id id;
    int err;
    int len;
    int i;
    int bit;
    int count = 1;
    int flags;
    unsigned int evbit[2];
    unsigned char byte;
    
    char *ev_names[] = 
        "EV_SYN",			
        "EV_KEY",			
        "EV_REL",			
        "EV_ABS",			
        "EV_MSC",			
        "EV_SW",			
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "NULL",
        "EV_LED",			
        "EV_SND",			
        "NULL",
        "EV_REP",			
        "EV_FF",			
        "EV_PWR"				
  
    ;
    
    if(argc!=2)
    
        printf("Usage:%s <dev>\\n",argv[0]);
        return -1;
    

    fd = open(argv[1],O_RDWR|O_NONBLOCK);
    
    if(fd==-1)
    
        printf("open error\\n");
        return -1;
    

    err = ioctl(fd,EVIOCGID,&id);
    if(err==0)
    
        printf("bustype is 0x%x\\n",id.bustype);
        printf("vendor is 0x%x\\n" ,id.vendor);
        printf("product is 0x%x\\n",id.product);
        printf("version is 0x%x\\n",id.version);
    

    len = ioctl(fd,EVIOCGBIT(0, sizeof(evbit)),&evbit);
    if(len>0 && len<=sizeof(evbit))
    
        printf("support ev type:");
        
        for(i=0;i<len;i++)
        
            byte = ((unsigned char*)evbit)[i];
            
            for(bit=0;bit<8;bit++)
            
                if(byte & (1<<bit))
                
                    printf("%s ",ev_names[i*8+bit]);
                
            
        
        printf("\\n");
    

    signal(SIGIO,sig_hanler);

    // 把进程ID告诉驱动
    fcntl(fd,F_SETOWN,getpid());

    // 使能驱动FASYNC
    flags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, flags | FASYNC);

    while(1)
       
        sleep(3);
        printf("main loop:%d\\n",count);
        count++;
    
    
    return 0;

以上是关于输入系统应用编程--APP访问硬件编程的主要内容，如果未能解决你的问题，请参考以下文章

输入系统应用编程--APP访问硬件编程

Linux系统编程应用 Linux Input子系统

python并发编程

计算机硬件--整理

计算机的软件硬件及工作原理

Linux input子系统input设备应用编程