linux输入设备在应用层的多种读取方式

已于 2022-03-25 22:19:54 修改
阅读量698 收藏 2
点赞数 1
分类专栏： 嵌入式linux 文章标签： linux
于 2022-03-25 20:35:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49460450/article/details/123734884
版权

1）.查询方式与休眠唤醒方式（非阻塞方式与阻塞方式）

查询方式

APP调用open函数时，传入“O_NONBLOCK”表示“非阻塞”。

APP调用read函数读取数据时，如果驱动程序中有数据，那么APP的read函数会返回数据，否则也会立刻返回错误。

休眠唤醒方式

APP调用open函数时，不要传入“O_NONBLOCK”。

APP调用read函数读取数据时，如果驱动程序中有数据，那么APP的read函数会返回数据；否则APP就会在内核态休眠，当有数据时驱动程序会把APP唤醒，read函数恢复执行并返回数据给APP。

当应用程序调用read时，内核的evdev.c中的evdev_read会被调用

static ssize_t evdev_read(struct file *file, char __user *buffer,
              size_t count, loff_t *ppos)

{...

 struct input_event event;

....

}

我们需要在app中也定义一个struct input_event event;来接收输入设备信息

操作方式：当传入noblock时选择查询方式，当不传入noblock时选择休眠唤醒方式

/*eg:  ./01_get_input_info   /dev/input/event0  noblock */

    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 < 0)
    {
        printf("Open %s err!\n",argv[1]);
        return -1;    
    }

main（）中：

    while(1)
    {
        len = read(fd,&event,sizeof(event));将读到的输入设备信息放入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                                //如果没有读到数据
        {
            printf("read err %d\n",len);
        }
    }

在上层传入noblock时，即选择查询方式读取，等运行到read函数，当读到数据时打印数据，当没有读到数据时会一直打印read err xx 

在上层未传入noblock时，即选择休眠唤醒方式读取，等运行到read函数，当读到数据时打印数据，当没有读到数据时APP就会在内核态休眠，当有数据时驱动程序会把APP唤醒，read函数恢复执行并返回数据给APP。即当数据打印数据，无数据也不会执行到else然后打印err而是进入休眠等待唤醒。

源码：

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

/*eg:  ./01_get_input_info   /dev/input/event0  noblock */
int main(int argc,char **argv)
{
    int fd;
    int ret;
    struct input_id id;
    unsigned int evbit[2];
    int len;
    int i;
    unsigned char byte;
    int bit;
    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"        ,    
 "EV_LED"    ,    
 "EV_SND"    ,    
 "NULL"        ,   
 "EV_REP"    ,
 "EV_FF"    ,    
 "EV_PWR"    ,    
};
 struct input_event event;

    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 < 0)
    {
        printf("Open %s err!\n",argv[1]);
        return -1;    
    }

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

/*0表示读evbit，读的大小sizeof(evbit)，&evbit表示读到evbit*/
    len = ioctl(fd,EVIOCGBIT(0,sizeof(evbit)),&evbit);
    if( len > 0 && len <= sizeof(evbit))
    {
        printf("Suppport 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
        {
            printf("read err %d\n",len);
        }
    }
    return 0;
}

在linux下编译执行：

arm-buildroot-linux-gnueabihf-gcc -o 02_get_input_info_read get_input_info_read.c -Wall
 

 cp 02_get_input_info_read ~/nfs_rootfs/

在板子上运行可见，当没有加noblock没有读到数据时进入了休眠没有打印read err，而加入noblock没有读到时一直打印read err

2）.poll方式与select方式

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

简单地说，它们就是“定个闹钟”：在调用poll、select函数时可以传入“超时时间”。在这段时间内，条件合适时(比如有数据可读、有空间可写)就会立刻返回，否则等到“超时时间”结束时返回错误

poll方式：

APP先调用open函数时选择用查询（非阻塞）方式，这样当poll在定时时间到检查到有数据时read函数就可以一直读数据直到把数据读完，就可以等待下一次poll，而不用进入休眠状态，如果采用堵塞方式，当然有data也能全显示，但当没有data，app就进入了休眠，等待接收data唤醒，这样poll机制的定时查询特点就完全没有体现出来，因此采用非堵塞方式。

所以在open时采用非堵塞：

    fd  = open(argv[1],O_RDWR | O_NONBLOCK);

在调用poll函数时，要指明：

① 你要监测哪一个文件：哪一个fd

② 你想监测这个文件的哪种事件：是POLLIN、还是POLLOUT

最后，在poll函数返回时，要判断状态

poll函数需要一个

 struct pollfd  fds[1];//用于poll函数
 nfds_t nfds = 1;      //poll次数

        fds[0].fd      = fd;
        fds[0].events  = POLLIN;
        fds[0].revents = 0;
        ret = poll( fds, nfds , 5000);//5000ms即5s poll一次

源码：

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

/*eg:  ./01_get_input_info   /dev/input/event0 */
int main(int argc,char **argv)
{
    int fd;
    int ret;
    struct input_id id;
    unsigned int evbit[2];
    int len;
    int i;
    unsigned char byte;
    int bit;
    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"        ,    
 "EV_LED"    ,    
 "EV_SND"    ,    
 "NULL"        ,   
 "EV_REP"    ,
 "EV_FF"    ,    
 "EV_PWR"    ,    
};
 struct input_event event;
 struct pollfd  fds[1];//用于poll函数接收data
 nfds_t nfds = 1;      //number

    if ( argc != 2 )
    {
        printf("Usage :%s <dev>\n",argv[0]);
        return -1;
    }


    fd  = open(argv[1],O_RDWR | O_NONBLOCK);
    
    if ( fd < 0)
    {
        printf("Open %s err!\n",argv[1]);
        return -1;    
    }

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

/*0表示读evbit，读的大小sizeof(evbit)，&evbit表示读到evbit*/
    len = ioctl(fd,EVIOCGBIT(0,sizeof(evbit)),&evbit);
    if( len > 0 && len <= sizeof(evbit))
    {
        printf("Suppport 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);//5000ms即5s

        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;
}
 

在linux下编译，板子上实验：

linux下执行：

arm-buildroot-linux-gnueabihf-gcc -o 03_get_input_info_read_poll get_input_info_read_poll.c -Wall
 

cp 03_get_input_info_read_poll ~/nfs_rootfs/
 

板子上挂在nfs 后运行：

 可以看见当没有触摸屏幕，到了5s就会提示 time out 而当触摸屏幕就会打印data

select方式：

 struct timeval tv; // 设置超时时间

        /* 设置超时时间 */
        tv.tv_sec  = 5;/* seconds */
        tv.tv_usec = 0;/* microseconds */

        /* 想监测哪些文件? */

        fd_set readfds; 
         FD_ZERO(&readfds);    /* 先全部清零 */
         FD_SET(fd, &readfds); /* 想监测fd */

         int nfds;

        nfds = fd + 1;/* nfds 是最大的文件句柄+1, 注意: 不是文件个数, 这与poll不一样 */

        /* 函数原型为:
            int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);
         * 我们为了"read"而监测, 所以只需要提供readfds
         */

ret = select(nfds, &readfds, NULL, NULL, &tv);

if (FD_ISSET(fd, &readfds))/* 再次确认fd有数据 */

源码：

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

/*eg:  ./01_get_input_info   /dev/input/event0 */
int main(int argc,char **argv)
{
    int fd;
    int ret;
    struct input_id id;
    unsigned int evbit[2];
    int len;
    int i;
    unsigned char byte;
    int bit;
    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"        ,    
 "EV_LED"    ,    
 "EV_SND"    ,    
 "NULL"        ,   
 "EV_REP"    ,
 "EV_FF"    ,    
 "EV_PWR"    ,    
};
 struct input_event event;

 struct timeval tv; // 设置超时时间
 fd_set readfds;    
 int nfds;/* nfds 是最大的文件句柄+1, 注意: 不是文件个数, 这与poll不一样 */

    if ( argc != 2 )
    {
        printf("Usage :%s <dev>\n",argv[0]);
        return -1;
    }


    fd  = open(argv[1],O_RDWR | O_NONBLOCK);
    
    if ( fd < 0)
    {
        printf("Open %s err!\n",argv[1]);
        return -1;    
    }

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

/*0表示读evbit，读的大小sizeof(evbit)，&evbit表示读到evbit*/
    len = ioctl(fd,EVIOCGBIT(0,sizeof(evbit)),&evbit);
    if( len > 0 && len <= sizeof(evbit))
    {
        printf("Suppport 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)
    {
        /* 设置超时时间 */
        tv.tv_sec  = 5;/* seconds */
        tv.tv_usec = 0;/* microseconds */
        
        /* Watch stdin (fd 0) to see when it has input. */

        /* 想监测哪些文件? */
         FD_ZERO(&readfds);    /* 先全部清零 */
         FD_SET(fd, &readfds); /* 想监测fd */

        /* 函数原型为:
            int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);
         * 我们为了"read"而监测, 所以只需要提供readfds
         */
        nfds = fd + 1;/* nfds 是最大的文件句柄+1, 注意: 不是文件个数, 这与poll不一样 */
        ret = select(nfds, &readfds, NULL, NULL, &tv);

        if ( ret > 0 )
        {
            if (FD_ISSET(fd, &readfds))/* 再次确认fd有数据 */
            {
                    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;
}

上机实验与poll方式一样

3）.异步通知方式

所谓同步，就是“你慢我等你”。

那么异步就是：你慢那你就自己玩，我做自己的事去了，有情况再通知我。

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

仔细想想“发信号”，这只有3个字，却可以引发很多问题：

① 谁发：驱动程序发

② 发什么：信号

③ 发什么信号：SIGIO

④ 怎么发：内核里提供有函数

⑤ 发给谁：APP，APP要把自己告诉驱动

⑥ APP收到后做什么：执行信号处理函数

⑦ 信号处理函数和信号，之间怎么挂钩：APP注册信号处理函数

Linux系统中也有很多信号，在Linux内核源文件include\uapi\asm-generic\signal.h中，有很多信号的宏定义：

 

驱动程序通知APP时，它会发出“SIGIO”这个信号，表示有“IO事件”要处理。

就APP而言，你想处理SIGIO信息，那么需要提供信号处理函数，并且要跟SIGIO挂钩。这可以通过一个signal函数来“给某个信号注册处理函数”，用法如下：

 

除了注册SIGIO的处理函数，APP还要做什么事？想想这几个问题：

① 内核里有那么多驱动，你想让哪一个驱动给你发SIGIO信号？

APP要打开驱动程序的设备节点。

② 驱动程序怎么知道要发信号给你而不是别人？

APP要把自己的进程ID告诉驱动程序。

③ APP有时候想收到信号，有时候又不想收到信号：

应该可以把APP的意愿告诉驱动：设置Flag里面的FASYNC位为1，使能“异步通知”。

① 编写信号处理函数：

static void sig_func(int sig)

{

    int val;

    read(fd, &val, 4);

    printf("get button : 0x%x\n", val);

}

② 注册信号处理函数：

signal(SIGIO, sig_func);

③ 打开驱动：

fd  = open(argv[1],O_RDWR | O_NONBLOCK);

//异步通知方式使用非堵塞来打开，防止read后休眠而没有返回到while(1)中的程序执行

，也就是防止回不去原本任务

④ 把进程ID告诉驱动：

fcntl(fd, F_SETOWN, getpid());

⑤ 使能驱动的FASYNC功能：

flags = fcntl(fd, F_GETFL);

fcntl(fd, F_SETFL, flags | FASYNC);

源码：

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

static int fd;
static struct input_event event;

//① 编写信号处理函数：
static void sig_func(int sig)
{
    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);
    }

}


/*eg:  ./05_get_input_info_read_fasync   /dev/input/event0 */
int main(int argc,char **argv)
{
    
    int ret;
    struct input_id id;
    unsigned int evbit[2];
    int len;
    int i;
    unsigned char byte;
    int bit;
    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"        ,    
 "EV_LED"    ,    
 "EV_SND"    ,    
 "NULL"        ,   
 "EV_REP"    ,
 "EV_FF"    ,    
 "EV_PWR"    ,    
};
 int count = 0;
 int flags;

    if ( argc != 2 )
    {
        printf("Usage :%s <dev>\n",argv[0]);
        return -1;
    }
    
    //② 注册信号处理函数：
    signal(SIGIO, sig_func);
    //③ 打开驱动：
    fd  = open(argv[1],O_RDWR | O_NONBLOCK);
    
    if ( fd < 0)
    {
        printf("Open %s err!\n",argv[1]);
        return -1;    
    }
    //④ 把进程ID告诉驱动：
    fcntl(fd, F_SETOWN, getpid());
    //⑤ 使能驱动的FASYNC功能：
    flags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, flags | FASYNC);

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

/*0表示读evbit，读的大小sizeof(evbit)，&evbit表示读到evbit*/
    len = ioctl(fd,EVIOCGBIT(0,sizeof(evbit)),&evbit);
    if( len > 0 && len <= sizeof(evbit))
    {
        printf("Suppport 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)
    {
        printf("count:%d\n",count++);
        sleep(2);
    }
    return 0;
}

上机实验与poll方式实验方式一样

嵌入式linux爱好者
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
入门学习Linux常用必会60个命令实例详解doc/txt
06-09
在Linux中，如果要使用硬盘、光驱等储存设备，就得先将它加载，当储存设备挂上了之后，就可以把它当成一个目录来访问。挂上一个设备使用mount命令。在使用mount这个指令时，至少要先知道下列三种信息：要加载对象的...
Android App层通过JNI从驱动获取Input Event
jack_a8的专栏
01-25 2751
1 概述   尝试在App层直接读取驱动的Input Event，获取触屏事件（本文获取的是电磁笔触屏事件），而不通过Android的Input Framework.     2 架构 3 实现 3.1 JNI层 共有以下几个文件：   3.1.1 input_pen.h   首先看input_
【Linux】输入系统详述 + 触摸屏应用实战（tslib）
希希雾里
04-22 4627
输入系统应用编程（韦老师课程）
Linux驱动入门（2）hello驱动---驱动层与应用层通讯，以及自动产生设备节点
在嵌入式嵌入式领域奋斗的程序猿的博客
05-16 1611
详细介绍了驱动层与应用层通讯，以及自动产生设备节点代码
linux 内核 input,手把手教你写Linux设备驱动---input子系统(一)--input事件应用程序的读写实现(基于...
weixin_32712615的博客
04-30 177
#include /*struct input_event {struct timeval time;__u16 type;__u16 code;__s32 value;};*//*Event types#define EV_SYN 0x00#define EV_KEY 0x01#define EV_REL ...
android apk getevent,Android App层经过JNI从驱动获取Input Event
weixin_39653448的博客
05-28 459
Android App层通过JNI从驱动获取Input Event1概述尝试在App层直接读取驱动的InputEvent，获取触屏事件(本文获取的是电磁笔触屏事件)，而不通过Android的InputFramework.2架构3实现3.1JNI层共有以下几个文件：3.1.1input_pen.h首先看input_pen.h#ifndef _INPUT_PEN_H#define _IN...
Linux高级bash编程
07-28
使用getopts命令来读取传递给脚本的选项/参数. 11-20. "Including"一个数据文件 11-21. 一个没什么用的,source自身的脚本 11-22. exec的效果 11-23. 一个exec自身的脚本 11-24. 在继续处理之前,等待一个进程的结束 ...
JAVA上百实例源码以及开源项目
01-03
　数字证书：从文件中读取数字证书，生成文件输入流,输入文件为c:/mycert.cer，获取一个处理X.509证书的证书工厂…… Java+ajax写的登录实例 1个目标文件 内容索引:Java源码,初学实例,ajax,登录 　一个Java+ajax写...
计算机基础知识(4).doc
06-04
1600x1200 &&H&& A B C D &&D&& D 计算机中数据输入输出的控制方式有多种，"中断"方式的优点不包括( ) 。 A．I/O与CPU并行处理 B．并行处理多种I/O C．实时响应突发事件 D．批量传送数据 &&H&& A B C D &&D&& D ...
新版Android开发教程.rar
12-14
设备商通过卖设备、内置特色应用来获得盈利。也可以兼职专业软件开发者进行赢利。 Google 自身通过基于统一平台为用户提供信息来盈利。 Android Android Android Android 的优势 � 源代码完全开放，便于开发人员更...
Linux如何查看与/dev/input目录下的event对应的设备
hddghhfd的博客
11-11 1470
Linux如何查看与/dev/input目录下的event对应的设备
再谈谈linux input 子系统事件类型
sinat_36116187的博客
09-25 1624
/* 向上层上报一个scancode */ input_event(dev, EV_MSC, MSC_SCAN, code); 将事件上报给事件处理句柄意味这事件将真正到达事件处理层，对于PC keyboard的event handle就是sysrq，kbd，eventX，这些handle对应的handler分别是sysrq_handler，kbd_handler，evdev_handler。每次上报一个事件，都会由input_pass_event函数去遍历这些event handle再有这些even.
嵌入式linux/鸿蒙开发板(IMX6ULL）开发（十五）输入系统应用编程
da.的博客
03-12 5839
文章目录1.输入系统应用编程1.1 什么是输入系统1.2 输入系统框架及调试1.2.1 框架概述1.2.2 编写APP需要掌握的知识1.2.3 调试技巧1.3 不使用库的应用程序示例1.3.1 输入系统支持完整的API操作1.3.2 APP访问硬件的4种方式：妈妈怎么知道孩子醒了1.3.3 获取设备信息1.3.4 查询方式1.3.5 休眠-唤醒方式1.3.6 POLL/SELECT方式1.4 电阻屏和电容屏1.4.1 电阻屏1.5 tslib1.5.1 tslib框架分析1.5.2 交叉编译、测试tslib
Linux下查看输入设备、获取输入事件的详细方法
phmatthaus的专栏
11-08 7918
Linux下查看输入设备、获取输入事件的详细方法
linux输入设备-应用程序如何获取到id及evbit
weixin_49460450的博客
03-24 1481
linux中每一个输入设备都用一个struct input_dev来表示 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)];//...
Linux应用层例程3 输入设备应用编程
internetv的博客
11-09 567
首先要知道什么是输入设备？输入设备其实就是能够产生输入事件的设备就称为输入设备，，它们都能够产生输入事件，产生输入数据给计算机系统。对于输入设备的应用编程其主要是等，譬如获取触摸屏当前触摸点的 X、Y轴位置信息以及触摸屏当前处于按下还是松开状态。
Linux输入事件编码
阙靖的博客
10-10 1643
Linux中的输入协议采用一系列的类型和编码向用户空间表示输入设备的值。 单一的硬件事件可以产生多个输入事件，每个输入事件包含新的单个数据项值。使用一个特殊的事件类型EV_SYNC将输入事件分成不同的数据包，数据包中输入数据的改变在时间上是在同一时刻出现的。在下文中，术语“事件”是指单个输入事件，包括类型，编码和值。 输入协议是一种状态性的协议，只有在事件编码的值改变之后才需要发送事件。尽管如此，...
Linux中如何获取输入设备（如触摸屏、按键等）的事件信息
最新发布
__Benco的博客
09-15 1517
在上述示例中，首先定义了输入设备文件路径`inputDevicePath`，然后使用`open()`函数打开该输入设备文件，并将返回的文件描述符存储在`inputDeviceFd`中。通过调用`read()`函数从输入设备文件中读取事件数据，并将其存储在`event`结构体中。输入设备文件通常位于`/dev/input/`目录下，以`eventX`的形式命名，其中`X`是数字标识符。在Linux中，可以使用`getevent`命令来获取输入设备（如触摸屏、按键等）的事件信息。
linux input读取键盘,Linux键盘原始阅读，有什么更好的，从/ dev / input / event0读取或从标准输入读取？(Linux keyboard raw reading, wh...
weixin_42314399的博客
05-15 567
Linux键盘原始阅读，有什么更好的，从/ dev / input / event0读取或从标准输入读取？(Linux keyboard raw reading, what's better, reading from /dev/input/event0 or reading from stdin?)我正在为Raspberry Pi制作一个小型C视频游戏库。 我从头开始对输入系统进行编码，在阅读了...
linux驱动层上报应用层
08-17
在Linux系统中，驱动层向应用层上报信息通常通过一些特定的机制来实现。下面是一些常用的方法： 1. ioctl：驱动程序可以通过ioctl系统调用与应用程序进行通信。通过定义一些特定的命令码，应用程序可以向驱动程序发送请求，驱动程序则可以通过这些请求来上报信息给应用程序。 2. sysfs：sysfs是一种虚拟文件系统，驱动程序可以通过创建文件和目录的方式在sysfs中暴露设备的状态信息。应用程序可以通过读取这些文件来获取驱动程序上报的信息。 3. procfs：类似于sysfs，procfs也是一个虚拟文件系统，驱动程序可以通过在/proc文件夹下创建文件或目录来上报信息。应用程序可以通过读取这些文件来获取驱动程序上报的信息。 4. netlink套接字：netlink是Linux内核提供的一种通信机制，驱动程序可以使用netlink套接字与应用程序进行通信。驱动程序可以通过发送netlink消息来上报信息给应用程序，而应用程序则可以通过监听和接收这些消息来获取信息。 这些方法只是一些常见的方式，具体的实现方式取决于驱动程序的设计和需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值