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

Posted 2021-10-26 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
POLLRDBAND	Priority band data can be read，有优先级较较高的“band data”可读
POLLPRI	高优先级数据可读
POLLOUT	可以写数据
POLLWRNORM	等同于POLLOUT
POLLWRBAND	Priority 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子系统