mike8825
mike8825

input输入子系统整体流程

input输入子系统整体流程

本节分析input子系统在内核中的实现，包括输入子系统（Input Core），事件处理层（Event Handler）和设备驱动层。由于上节代码讲解了设备驱动层的写法，因此在开头部分会从设备驱动层做为线索，分析输入子系统和事件处理层是如何配合的，最后从用户角度出发，从“/dev/input/*”接口如何使用输入子系统提供的服务。

既然需要详细分析，有一个这样的流程图能够帮助我们在被绕进代码的过程中，找到出口，你能够知道你现在位于代码框架的什么位置，不会忘记正在分析的代码的“身份”。其实在初识输入子系统中已经贴出了这张图，我们再把它拿出来参考一下吧，见下图6。

input输入子系统整体流程_第1张图片

图6  linux输入子系统事件处理机制

1.1    设备驱动层注册到input子系统

在上一节分析了S3C2440触摸屏驱动的代码，初始化函数定义了struct input_devinput结构体，它用于描述一个输入子系统设备，任何驱动设备如果想标明自己是输入设备，都应该通过初始化这样的结构体，并且调用input_allocate_device（）函数进行注册。

了解这一过程，需要先看一下structinput_dev结构体的内容：

[cpp]  view plain copy
  1. struct input_dev {  
  2.   
  3.     void *private;              //输入设备私有指针，一般指向用于描述设备驱动层的设备结构  
  4.   
  5.     const char *name;           //提供给用户的输入设备的名称  
  6.     const char *phys;           //提供给编程者的设备节点的名称  
  7.     const char *uniq;           //指定唯一的ID号，就像MAC地址一样  
  8.     struct input_id id;         //输入设备标识ID，用于和事件处理层进行匹配  
  9.   
  10.     unsigned long evbit[NBITS(EV_MAX)];     //位图，记录设备支持的事件类型  
  11.     unsigned long keybit[NBITS(KEY_MAX)];       //位图，记录设备支持的按键类型  
  12.     unsigned long relbit[NBITS(REL_MAX)];       //位图，记录设备支持的相对坐标  
  13.     unsigned long absbit[NBITS(ABS_MAX)];       //位图，记录设备支持的绝对坐标  
  14.     unsigned long mscbit[NBITS(MSC_MAX)];   //位图，记录设备支持的其他功能  
  15.     unsigned long ledbit[NBITS(LED_MAX)];       //位图，记录设备支持的指示灯  
  16.     unsigned long sndbit[NBITS(SND_MAX)];       //位图，记录设备支持的声音或警报  
  17.     unsigned long ffbit[NBITS(FF_MAX)];     //位图，记录设备支持的作用力功能  
  18.     unsigned long swbit[NBITS(SW_MAX)];     //位图，记录设备支持的开关功能  
  19.   
  20.     unsigned int keycodemax;        //设备支持的最大按键值个数  
  21.     unsigned int keycodesize;       //每个按键的字节大小  
  22.     void *keycode;              //指向按键池，即指向按键值数组首地址  
  23.     int (*setkeycode)(struct input_dev *dev, int scancode, int keycode);    //修改按键值  
  24.     int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode);   //获取按键值  
  25.   
  26.     struct ff_device *ff;           //用于强制更新输入设备的部分内容  
  27.   
  28.     unsigned int repeat_key;        //重复按键的键值  
  29.     struct timer_list timer;        //设置当有连击时的延时定时器  
  30.   
  31.     int state;      //设备状态  
  32.   
  33.     int sync;       //同步事件完成标识，为1说明事件同步完成  
  34.   
  35.     int abs[ABS_MAX + 1];       //记录坐标的值  
  36.     int rep[REP_MAX + 1];       //记录重复按键的参数值  
  37.   
  38.     unsigned long key[NBITS(KEY_MAX)];      //位图，按键的状态  
  39.     unsigned long led[NBITS(LED_MAX)];      //位图，led的状态  
  40.     unsigned long snd[NBITS(SND_MAX)];      //位图，声音的状态  
  41.     unsigned long sw[NBITS(SW_MAX)];            //位图，开关的状态  
  42.   
  43.     int absmax[ABS_MAX + 1];                    //位图，记录坐标的最大值  
  44.     int absmin[ABS_MAX + 1];                    //位图，记录坐标的最小值  
  45.     int absfuzz[ABS_MAX + 1];                   //位图，记录坐标的分辨率  
  46.     int absflat[ABS_MAX + 1];                   //位图，记录坐标的基准值  
  47.   
  48.     int (*open)(struct input_dev *dev);         //输入设备打开函数  
  49.     void (*close)(struct input_dev *dev);           //输入设备关闭函数  
  50.     int (*flush)(struct input_dev *dev, struct file *file); //输入设备断开后刷新函数  
  51.     int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);   //事件处理  
  52.   
  53.     struct input_handle *grab;      //类似私有指针，可以直接访问到事件处理接口event  
  54.   
  55.     struct mutex mutex;     //用于open、close函数的连续访问互斥  
  56.     unsigned int users;     //设备使用计数  
  57.   
  58.     struct class_device cdev;   //输入设备的类信息  
  59.     union {             //设备结构体  
  60.         struct device *parent;  
  61.     } dev;  
  62.   
  63.     struct list_head    h_list; //handle链表  
  64.     struct list_head    node;   //input_dev链表  
  65. };  

也许就这样赤裸裸的看上面的结构体，会觉得摸不着头脑，但是有一点是确定的，我们在写输入设备驱动时会定义这样一个输入设备结构体，并调用input_allocate_device()函数，这个函数的功能是为新添加的输入设备分配内存，如果成功，将返回input_dev *的指针结构，因此在写驱动的时候应该接受返回值，作为驱动层获得了一个新的输入设备操作的接口。

那么input_allocate_device()函数做了什么呢？打开函数看一下（input.c中实现）：

[cpp]  view plain copy
  1. struct input_dev *input_allocate_device(void)  
  2. {  
  3.     struct input_dev *dev;  
  4.   
  5. //动态申请内存，使用GFP_KERNEL方式，注意GFP_KERNEL可能导致睡眠，不能在中断中调用这个函数  
  6.     dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);  
  7. //分配成功执行的代码，进行成员的默认填充  
  8.     if (dev) {  
  9.         dev->cdev.class = &input_class;          //支持热插拔的结构体  
  10.         dev->cdev.groups = input_dev_attr_groups; //描述设备的硬件信息和支持的事件类型  
  11.         class_device_initialize(&dev->cdev);     //类设备初始化，添加进input类设备模型中  
  12.         mutex_init(&dev->mutex);             //初始化互斥锁  
  13.         INIT_LIST_HEAD(&dev->h_list);        //初始化handle链表  
  14.         INIT_LIST_HEAD(&dev->node);          //初始化输入设备链表  
  15.   
  16.     }  
  17. }  

通过input_allocate_device()函数，我们设备驱动现在持有的input_dev里面就被赋予了input的“形象”，但是还需要我们去充实一下“内在”，因此，设备驱动程序，还需要为自己的设备增加自己的特性，才能创造独有的设备“形象”。拿上一节的代码举例如下：

[cpp]  view plain copy
  1. struct input_dev *input_dev = input_allocate_device();  
  2. input_dev->name = "s3c2410 Touchscreen";  
  3. input_dev->phys = "s3c2410ts/input0";  
  4. input_dev->id.bustype = BUS_HOST;  
  5. input_dev->id.vendor = 0x0001;  
  6. input_dev->id.product = 0x0002;  
  7. input_dev->id.version = 0x0100;  
  8. input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);  
  9. input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);   
  10. input_set_abs_params(input_dev, ABS_X, X_AXIS_MIN, X_AXIS_MAX, 0, 0);  
  11. input_set_abs_params(input_dev, ABS_Y, Y_AXIS_MIN, Y_AXIS_MAX, 0, 0);  
  12. input_set_abs_params(input_dev, ABS_PRESSURE, PRESSURE_MIN, PRESSURE_MAX, 0, 0);  

以上的内容在前一节触摸屏驱动的初始化代码中也有分析，完成了输入设备的初始化工作。但是这仅是初始化自己的“特点”，还需要通知输入子系统有这样一个新设备诞生了，这就需要调用输入子系统的注册函数input_register_device（input_dev）来完成。

input_register_device（）用于注册一个输入设备。那么注册过程是怎样的呢？这是一个重点，我们在下面的代码中进行注释分析：

[cpp]  view plain copy
  1. int input_register_device(struct input_dev *dev)  
  2. {  
  3.     /* 用于记录输入设备名称的索引值 */  
  4.     static atomic_t input_no = ATOMIC_INIT(0);  
  5.     /* 输入事件的处理接口指针，用于和设备的事件类型进行匹配 */  
  6.     struct input_handler *handler;  
  7.     const char *path;  
  8.     int error;  
  9.   
  10.     /* 默认所有的输入设备都支持EV_SYN同步事件 */  
  11.     set_bit(EV_SYN, dev->evbit);  
  12.   
  13.     /* 
  14.      * 如果设备驱动没有指定重复按键（连击），系统默认提供以下的支持 
  15.      * 其中init_timer为连击产生的定时器，时间到调用input_repeat_key函数 
  16.      * 上报，REP_DELAY用于设置重复按键的键值，REP_PERIOD设置延时时间 
  17.      */  
  18.     init_timer(&dev->timer);  
  19.     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {  
  20.         dev->timer.data = (long) dev;  
  21.         dev->timer.function = input_repeat_key;  
  22.         dev->rep[REP_DELAY] = 250;  
  23.         dev->rep[REP_PERIOD] = 33;  
  24.     }  
  25.   
  26.     /* 如果设备驱动没有设置自己的获取键值的函数，系统默认 */  
  27.     if (!dev->getkeycode)  
  28.         dev->getkeycode = input_default_getkeycode;  
  29.   
  30.     /* 如果设备驱动没有指定按键重置函数，系统默认 */  
  31.     if (!dev->setkeycode)  
  32.         dev->setkeycode = input_default_setkeycode;  
  33.   
  34.     /* 重要，把设备挂到全局的input子系统设备链表input_dev_list上 */  
  35.     list_add_tail(&dev->node, &input_dev_list);  
  36.   
  37.     /* 动态获取input设备的ID号，名称为input*，其中后面的“*”动态获得，唯一的 */  
  38.     snprintf(dev->cdev.class_id, sizeof(dev->cdev.class_id),  
  39.          "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);  
  40.   
  41.     /* 如果这个值没有设置，系统把输入设备挂入设备链表 */  
  42.     if (!dev->cdev.dev)  
  43.         dev->cdev.dev = dev->dev.parent;  
  44.   
  45.     /* 在/sys目录下创建设备目录和文件 */  
  46.     error = class_device_add(&dev->cdev);  
  47.     if (error)  
  48.         return error;  
  49.   
  50.     /* 获取并打印设备的绝对路径名称 */  
  51.     path = kobject_get_path(&dev->cdev.kobj, GFP_KERNEL);  
  52.     printk(KERN_INFO "input: %s as %s\n",  
  53.         dev->name ? dev->name : "Unspecified device", path ? path : "N/A");  
  54.     kfree(path);  
  55.   
  56.     /* 核心重点，input设备在增加到input_dev_list链表上之后，会查找 
  57.      * input_handler_list事件处理链表上的handler进行匹配，这里的匹配 
  58.      * 方式与设备模型的device和driver匹配过程很相似，所有的input 
  59.      * 都挂在input_dev_list上，所有类型的事件都挂在input_handler_list 
  60.      * 上，进行“匹配相亲”*/  
  61.     list_for_each_entry(handler, &input_handler_list, node)  
  62.         input_attach_handler(dev, handler);  
  63.   
  64.     input_wakeup_procfs_readers();  
  65.   
  66.     return 0;  
  67. }  

上面的代码主要的功能有以下几个功能，也是设备驱动注册为输入设备委托内核做的事情：

  • 进一步初始化输入设备，例如连击事件；
  • 注册输入设备到input类中；
  • 把输入设备挂到输入设备链表input_dev_list中；
  • 查找并匹配输入设备对应的事件处理层，通过input_handler_list链表

我们需要再分析下这个匹配的过程，“相亲”这种事情还是很有意思的，但是需要注意的是下面分析的代码是我们暂时无法分析的，因为那样会使得情况变得更加复杂，当我们从应用层往下分析的时候一切都会明白。input_attach_handler匹配过程如下：

[cpp]  view plain copy
  1. const struct input_device_id *id;  
  2.     int error;  
  3.   
  4. /* 如果handler的blacklist被赋值了并且则优先匹配 */  
  5.     if (handler->blacklist && input_match_device(handler->blacklist, dev))  
  6.         return -ENODEV;  
  7.   
  8.     /* 否则利用handler->id_table和dev进行匹配，后面讲述匹配什么和过程 */  
  9.     id = input_match_device(handler->id_table, dev);  
  10.     if (!id)  
  11.         return -ENODEV;  
  12.   
  13.     /* 这是一根“红线”，虽然你可能觉的是黑色的，但不可否认，他们真的匹配上了 
  14.          * 调用handler->connnect函数进行匹配，匹配详细过程后面讲述 
  15.         */  
  16.     error = handler->connect(handler, dev, id);  
  17.     if (error && error != -ENODEV)  
  18.         printk(KERN_ERR  
  19.             "input: failed to attach handler %s to device %s, "  
  20.             "error: %d\n",  
  21.             handler->name, kobject_name(&dev->cdev.kobj), error);  
  22.   
  23.     return error;  

我们先来看下input_match_device（）函数，看一下这个匹配的条件是什么，如何匹配的过程是怎样的，匹配的结果会是什么？

[cpp]  view plain copy
  1. /* 事件处理层中的对应flags如果设置或者driver_info被设置则进行匹配 */  
  2.     for (; id->flags || id->driver_info; id++) {  
  3.         /* 以下通过flags中设置的位来匹配设备的总线类型、经销商、生产ID和版本ID 
  4.           如果没有匹配上将进行MATCH_BIT匹配 */  
  5.         if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)  
  6.             if (id->bustype != dev->id.bustype)  
  7.                 continue;  
  8.   
  9.         if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)  
  10.             if (id->vendor != dev->id.vendor)  
  11.                 continue;  
  12.   
  13.         if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)  
  14.             if (id->product != dev->id.product)  
  15.                 continue;  
  16.   
  17.         if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)  
  18.             if (id->version != dev->id.version)  
  19.                 continue;  
  20.           
  21.         /* MATCH_BIT用于匹配设备驱动中是否设置了这些为，MATCH_BIT的宏 
  22.         * 被定义在input.c中，我们在设备驱动中设置的事件类型会与事件链表中的 
  23.         * 所有事件类型进行比较，匹配成功了将返回id，证明真的很合适，否则NULL 
  24.         */  
  25.         MATCH_BIT(evbit,  EV_MAX);  
  26.         MATCH_BIT(keybit, KEY_MAX);  
  27.         MATCH_BIT(relbit, REL_MAX);  
  28.         MATCH_BIT(absbit, ABS_MAX);  
  29.         MATCH_BIT(mscbit, MSC_MAX);  
  30.         MATCH_BIT(ledbit, LED_MAX);  
  31.         MATCH_BIT(sndbit, SND_MAX);  
  32.         MATCH_BIT(ffbit,  FF_MAX);  
  33.         MATCH_BIT(swbit,  SW_MAX);  
  34.   
  35.         return id;  
  36.     }  
  37.   
  38.     return NULL;  

既然证明是合适的，接下来就应该登记注册，并公证了。还记得handler->connect(handler, dev, id)函数吧，当input_match_device（）找到最合适的事件处理层驱动时，便执行handler->connect函数进行公证了，看下面这部分代码（假如说找到了evdev类型的驱动，在input/evdev.c中）：

[cpp]  view plain copy
  1. struct evdev *evdev;  
  2.     struct class_device *cdev;  
  3.     dev_t devt;  
  4.     int minor;  
  5.     int error;  
  6.   
  7.     /* EVDEV_MINORS为32，代表共能容纳32个evdev事件层设备，下面代码在找到空的地方，用于保存evdev事件层的数据，即上面定义的evdev */  
  8.     for (minor = 0; minor < EVDEV_MINORS && evdev_table[minor]; minor++);  
  9.     /* 这说明内核已经没办法再分配这种类型的设备了 */  
  10.     if (minor == EVDEV_MINORS) {  
  11.         printk(KERN_ERR "evdev: no more free evdev devices\n");  
  12.         return -ENFILE;  
  13.     }  
  14.     /* 开始给evdev事件层驱动分配空间了 */  
  15.     evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);  
  16.     if (!evdev)  
  17.         return -ENOMEM;  
  18.   
  19.     /* 初始化client_list列表和evdev_wait队列，后面介绍 */  
  20.     INIT_LIST_HEAD(&evdev->client_list);  
  21.     init_waitqueue_head(&evdev->wait);  
  22.   
  23.     /* 初始化evdev结构体，其中handle为输入设备和事件处理的关联接口 */  
  24.     evdev->exist = 1;  
  25.     evdev->minor = minor;  
  26.     evdev->handle.dev = dev;  
  27.     evdev->handle.name = evdev->name;  
  28.     evdev->handle.handler = handler;  
  29.     evdev->handle.private = evdev;  
  30.     sprintf(evdev->name, "event%d", minor);  
  31.   
  32.     /* 重要，上层访问时通过次设备号找到事件处理的接口 */  
  33.     evdev_table[minor] = evdev;  
  34.   
  35.     /* evdev事件设备的此设备号的基准值INPUT_MAJOR, EVDEV_MINOR_BASE */  
  36.     devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),  
  37.   
  38.     /* 创建用户事件驱动层设备访问接口/dev/input/event* */  
  39.     cdev = class_device_create(&input_class, &dev->cdev, devt,  
  40.                    dev->cdev.dev, evdev->name);  
  41.     if (IS_ERR(cdev)) {  
  42.         error = PTR_ERR(cdev);  
  43.         goto err_free_evdev;  
  44.     }  
  45.   
  46.     /* 提供/sys目录的用户空间接口 */  
  47.     error = sysfs_create_link(&input_class.subsys.kobj,  
  48.                   &cdev->kobj, evdev->name);  
  49.     if (error)  
  50.         goto err_cdev_destroy;  
  51.   
  52.     /* input_dev设备驱动和handler事件处理层的关联，由handle完成 */  
  53.     error = input_register_handle(&evdev->handle);  

通过上述代码的执行，最终，输入设备在input_register_handle（）的关联下与已经匹配上的handler结合，代码如下：

[cpp]  view plain copy
  1. struct input_handler *handler = handle->handler;  
  2.     /* 将d_node链接到输入设备的h_list，h_node链接到事件层的h_list链表上 
  3.     * 因此，在handle中是输入设备和事件层的关联结构体，通过输入设备可以 
  4.     * 找到对应的事件处理层接口，通过事件处理层也可找到匹配的输入设备 
  5.     */  
  6.     list_add_tail(&handle->d_node, &handle->dev->h_list);  
  7.     list_add_tail(&handle->h_node, &handler->h_list);  
  8.   
  9.     /* 如果start函数有定义则调用，但是evdev结构体中并未初始化这个函数 */  
  10.     if (handler->start)  
  11.         handler->start(handle);  

以上是输入设备驱动注册的全过程，牵涉的代码比较多，需要从宏观上理顺。纵观整个过程，输入设备驱动最终的目的就是能够与事件处理层的事件驱动相互匹配，但是在drivers/input目录下有evdev.c事件驱动、mousedev.c事件驱动、joydev.c事件驱动等等，我们的输入设备产生的事件应该最终上报给谁，然后让事件驱动再去处理呢？知道了这么个原因再看上面代码就会明白，其实evdev.c、mousedev.c等根据硬件输入设备的处理方式的不同抽象出了不同的事件处理接口帮助上层去调用，而我们写的设备驱动程序只不过是完成了硬件寄存器中数据的读写，但提交给用户的事件必须是经过事件处理层的封装和同步才能够完成的，事件处理层提供给用户一个统一的界面来操作。

由于以上的这些原因，才有了上述代码的关联过程，通过下图7，看一下整个关联注册的过程：

input输入子系统整体流程_第2张图片

图7  input_dev与handler关联图

通过上图我们可以看到input输入设备匹配关联的关键过程以及涉及到的关键函数和数据。这一节主要是从input设备驱动程序的角度去看输入子系统的注册过程和三层之间的关联，下一节将从应用层的角度分析事件的接受过程和处理过程以及三层之间是如何配合处理输入事件的。

1.2    从应用层的角度出发看input子系统

以上部分已经借助input子系统把input设备驱动层与事件驱动层进行了关联，我们以前面几节所介绍的s3c2440_ts.c（输入设备层驱动）和evdev.c（事件处理层驱动）为例，来分析这一过程。

由于s3c2440_ts.c中上报的事件类型为按键、绝对值坐标，而evdev事件驱动程序是全匹配的，因此早在s3c2440_ts.c注册的过程中，就会创建设备节点/dev/input/event0（假设内核中没有其他的event类型的输入设备，这里就是event0），当然由于我的内核是2.6.22，这个节点的名字是/dev/event0。因此需要注意你的内核版本，以确定设备节点的位置，我们以“/dev/event0”为例来说明。

我们知道，应用层使用设备的第一步，是open(“/dev/event0”)，因此这里event0的主设备号成为关键，因为主设备号将表明你是什么设备，我们ls -l查看/dev/event0发现：

crw-r-----1 root root 13, 64 2012-07-26 14:32 /dev/input/event0

由此可见主设备是13，输入命令cat /proc/devices查看主设备为13的是input设备，因此可以确定当我们执行open函数打开event0设备的时候，会调用input设备的open驱动函数，这个函数在input.c中，为了说明这一问题，需要从input驱动注册过程开始，还是input.c文件：

[cpp]  view plain copy
  1. /* 输入设备初始化函数 */  
  2. static int __init input_init(void)  
  3. {  
  4.        class_register(&input_class);  
  5.        input_proc_init();  
  6.        register_chrdev(INPUT_MAJOR,"input", &input_fops);  
  7. }  

可以看到，输入设备初始化的过程首先建立了input类，初始化input在proc下的节点，然后注册input设备，设备名称为input，操作接口是input_fops，主设备号是INPUT_MAJOR=13。

由以上可知，只要是主设备号为13的设备驱动程序，都是用input_fops接口，即当event0设备使用open函数打开时，会调用到input_fops接口中的open驱动函数，这个结构体的初始化为：

[cpp]  view plain copy
  1. static const struct file_operations input_fops = {  
  2.        .owner = THIS_MODULE,  
  3.        .open = input_open_file,  
  4. };  

可以看到，只实现了一个open功能字段，再看input_open_file的实现：

[cpp]  view plain copy
  1. static int input_open_file(struct inode *inode, struct file *file)  
  2. {  
  3.        struct input_handler *handler =input_table[iminor(inode) >> 5];  
  4.        const struct file_operations *old_fops,*new_fops = NULL;  
  5.        if (!handler || !(new_fops =fops_get(handler->fops)))  
  6.               return -ENODEV;  
  7.        old_fops = file->f_op;  
  8.        file->f_op = new_fops;  
  9.        new_fops->open(inode, file);  
  10. }  

以上代码的功能为找到对应事件驱动层的fops，即进行fops的接口转换，指向对应设备的事件处理接口。其中input_table[iminor(inode)]>>5的input_table是一个全局的input_handler类型的数组，iminor(inode)取得次设备号，并且右移5位索引input_table表中对应的位置，为什么这样做呢？这是因为这个表格中填写的就是事件处理的指针，我们待会分析，先继续查看下面的代码。if中将判断是否为空并且事件处理层中的fops有没有初始化，如果没有就不能进行接口转换，报出设备不存在的错误，如果设备存在则把input设备的f_op驱动接口指向input_table表中存在的接口，并调用其open函数。那么这个input_table里面到底存放了什么呢？我们还是拿触摸屏驱动来讲解。由于触摸屏驱动已经完成了和evdev.c事件处理层的匹配，且次设备号为64，设备名称为/dev/event0，这是我们通过分析驱动注册中获得的内容，既然input核心设备注册了，s3c2440触摸屏驱动也注册了，那会不会evdev设备也会注册了呢？答案是肯定的，要想知道input_table里面放了什么，必须要去查看evdev设备的注册过程，打开input/evdev.c查看它的注册过程：

[cpp]  view plain copy
  1. static struct input_handler evdev_handler = {  
  2.        .event =   evdev_event,                               //事件处理  
  3.        .connect =      evdev_connect,                    //设备连接  
  4.        .disconnect =  evdev_disconnect,                //注销连接  
  5.        .fops =           &evdev_fops,                      //驱动功能接口  
  6.        .minor =  EVDEV_MINOR_BASE,              //evdev的值为64  
  7.        .name =          "evdev",                              //设备名称  
  8.        .id_table =      evdev_ids,                           //用于匹配设备驱动的数组  
  9. };  
  10.    
  11. static int __init evdev_init(void)  
  12. {  
  13.        return input_register_handler(&evdev_handler);          //evdev设备驱动注册  
  14. }  

由以上的内容可以知道evdev_handler也被作为一个设备来操作，但是它属于input handler事件处理设备，然而我们在evdev_handler结构体的.fops字段又发现它的驱动接口为字符设备类型，在input中，如果input_table匹配到了evdev_handler，将会把file->f_op=&evdev_fops，那么如果使用read、write等函数操作，将会调用到evdev_fops中的read、write。

为了进一步查看input_table表中的内容是如何填充的，还需要查看这个注册的过程：

[cpp]  view plain copy
  1. int input_register_handler(struct input_handler *handler)  
  2. {  
  3.     ……  
  4.            input_table[handler->minor>> 5] = handler;  
  5.     ……  
  6. }  

当然这个注册过程并不是只有这么一句话，看到这条语句，相信你应该知道什么意思了。在input的open函数执行之前，即我们的open代码打开之前，input_table中的字段已经被事件处理层填充了。由于evdev的次设备号在初始化的时候就设置成了64，因此这里相当于：

[cpp]  view plain copy
  1. input_table[2]=&evdev_handler；  

回到input_open_file函数查看new_fops->open(inode, file)你便知道了调用的是:

[cpp]  view plain copy
  1. evdev_handler.evdev_fops.open（inode, file）；  

在分析open函数之前，解释一下为什么要右移5位，这说明一个问题，次设备号的低5位被忽略，这说明evdev的最大支持的输入设备驱动个数为2^5次方等于32个，你可能会看到你的/dev目录下面有event0、event1、event2等设备，他们的次设备号分别为64、65、66等等。但最大是64+32-1，因此input_table为这些输入设备增加的一个统一接口，通过上层打开设备时，只要次设备号在64+32-1之间的设备都会重新定位到evdev_handler中，即event*设备打开后执行的底层函数将被重新定义到evdev_handler中。

相信上面的问题已经描述清楚，如果还是不明白，你最起码应该知道的是，input设备中的open函数只是一个接口，通过次设备号才找到了真正的事件处理接口。接下来要看新的open接口的实现了，evdev_handler-> fops->open实现如下：

[cpp]  view plain copy
  1. /*evdev字符设备驱动接口 */  
  2. static const struct file_operations evdev_fops = {  
  3.        .owner = THIS_MODULE,  
  4.        .read =           evdev_read,  
  5.        .write =   evdev_write,  
  6.        .poll =            evdev_poll,  
  7.        .open =          evdev_open,  
  8.        .release = evdev_release,  
  9.        .unlocked_ioctl = evdev_ioctl,  
  10. #ifdef CONFIG_COMPAT  
  11.        .compat_ioctl =      evdev_ioctl_compat,  
  12. #endif  
  13.        .fasync = evdev_fasync,  
  14.        .flush =   evdev_flush  
  15. };  
  16. /*evdev设备open函数的实现过程 */  
  17. static int evdev_open(struct inode *inode, struct file *file)  
  18. {  
  19.        struct evdev_client *client;  
  20.        struct evdev *evdev;  
  21.        /* 如果是event0，对于evdev设备来说，次设备号当然是0 */  
  22.        int i = iminor(inode) - EVDEV_MINOR_BASE;  
  23.        int error;  
  24.        /* 如果大于32，说明超出了evdev能够容纳的最大输入设备个数 */  
  25.        if (i >= EVDEV_MINORS)  
  26.               return -ENODEV;  
  27.        /* 由于evdev中能容纳32个输入设备，因此通过设备号event0中的0定位到是要处理的是哪一个输入设备，evdev_table中的内容在输入设备驱动注册时通过evdev_connect填充 */  
  28.        evdev = evdev_table[i];  
  29.        /* 判断是否设备接口存在，evdev_exist也是在evdev_connect填充为1 */  
  30.        if (!evdev || !evdev->exist)  
  31.               return -ENODEV;  
  32.        /* 存在则分配evdev中的client来处理event* */  
  33.        client = kzalloc(sizeof(struct evdev_client),GFP_KERNEL);  
  34.        if (!client)  
  35.               return -ENOMEM;  
  36.    
  37.        /* 把event*中的接口指向evdev_table中对应项 */  
  38.        client->evdev = evdev;  
  39.        /* 把client->node链接到evdev子集中 */  
  40.        list_add_tail(&client->node,&evdev->client_list);  
  41.        /* 如果open是第一个打开，则会执行input_open_device*/  
  42.        if (!evdev->open++ &&evdev->exist) {  
  43.               error =input_open_device(&evdev->handle);  
  44.               if (error) {  
  45.                      list_del(&client->node);  
  46.                      kfree(client);  
  47.                      return error;  
  48.               }  
  49.        }  
  50.        /* 将file私有指针指向client*/  
  51.        file->private_data = client;  
  52.        return 0;  
  53. }  
  54. 由上的代码可以看出，最终是要执行input_open_device去执行设备驱动程序中的代码，然而我们在定义设备驱动的时候并没有给input_dev中的open字段填充内容，因此可以看到input_open_device函数的执行过程：  
  55. if(!dev->users++ && dev->open)  
  56.               err = dev->open(dev);  
  57.    
  58.        if (err)  
  59.               handle->open--;  

上面截取了片段，并没有执行到open函数，open进行自减操作，表示没有调用过open，这个值主要是为了close中判断open为0时释放资源使用。

不仅如此，我们在触摸屏驱动中也没有定义read、write，那当触摸屏上报事件时，是如何处理的呢？我们需要先到触摸屏驱动程序中找到上报事件的函数再做进一步分析。

1.3    输入设备上报事件的处理过程

触摸屏驱动程序上报事件的函数为：

[cpp]  view plain copy
  1. input_report_abs(dev,ABS_X, s3c2440_ts->tc.xp);  
  2. input_report_abs(dev,ABS_Y, s3c2440_ts->tc.yp);  
  3. input_report_abs(dev,ABS_PRESSURE, s3c2440_ts->tc.pressure);  
  4. input_report_key(dev,BTN_TOUCH, s3c2440_ts->pendown);  
  5. input_sync(dev);  

然而他们其实是input_event函数的封装，调用的都是input_event函数，这一函数在input.c中实现如下：

[cpp]  view plain copy
  1. void input_event(struct input_dev *dev, unsigned int type, unsigned int code, intvalue)  
  2. {  
  3.        struct input_handle *handle;  
  4.    
  5.        if (type > EV_MAX || !test_bit(type,dev->evbit))  
  6.               return;  
  7.        switch (type) {  
  8.               case EV_SYN:  
  9.                      switch (code) {  
  10.                             case SYN_CONFIG:  
  11.                                    if(dev->event)  
  12.                                           dev->event(dev,type, code, value);  
  13.                                    break;  
  14.                             case SYN_REPORT:  
  15.                                    if(dev->sync)  
  16.                                           return;  
  17.                                    dev->sync= 1;  
  18.                                    break;  
  19.                      }  
  20.                      break;  
  21.               case EV_KEY:  
  22.               case EV_SW:  
  23.               case EV_ABS:  
  24.               case EV_REL:  
  25.               case EV_MSC:  
  26.               case EV_LED:  
  27.               case EV_SND:  
  28.               case EV_REP:  
  29.               case EV_FF:  
  30.        }  
  31.    
  32.        if (type != EV_SYN)  
  33.               dev->sync = 0;  
  34.    
  35.        if (dev->grab)  
  36.               dev->grab->handler->event(dev->grab,type, code, value);  
  37.        else  
  38.               list_for_each_entry(handle,&dev->h_list, d_node)  
  39.                      if (handle->open)  
  40.                             handle->handler->event(handle,type, code, value);  
  41. }  

代码被做了精简，其中就是在匹配上报的事件，并根据事件的类型调用驱动程序中相应的函数来完成，但是由于我们并，没有定义过这些函数，因此执行最后的handle_handler_event函数，由事件处理层evdev_event函数来完成事件的保存工作，具体过程如下：

[cpp]  view plain copy
  1. list_for_each_entry(client,&evdev->client_list, node) {  
  2. client->buffer[client->head].type= type;  
  3. client->buffer[client->head].code= code;  
  4. client->buffer[client->head].value= value;  
  5. client->head= (client->head + 1) & (EVDEV_BUFFER_SIZE - 1);  
  6. }  

这里列举了关键代码，即上报的事件被保存到了client_buffer中，其中client_buffer是一个循环缓冲区，client->head表示当前数据的位置，因此每次都写到client->head的位置，而读数据时需要到client_tail中读取。因为在open的时候，client已经被链入到了evdev->client_list中，因此通过可以通过list_for_each_entry重evdev->client_list中找到对应的client。

事件的上报都会把数据保存到client->buffer中，以便上层通过read和write进行读去和写入。

1.4    通过设备节点读取输入事件

还是以触摸屏驱动程序和evdev事件处理层驱动来分析：

[cpp]  view plain copy
  1. static ssize_t evdev_read(struct file *file, char __user *buffer, size_t count, loff_t*ppos)  
  2. {  
  3.        struct evdev_client *client =file->private_data;  
  4.        struct evdev *evdev = client->evdev;  
  5.        int retval;  
  6.    
  7.        /* 判断用户给的count是否能够容纳事件数据的大小*/  
  8.        if (count < evdev_event_size())  
  9.               return -EINVAL;  
  10.    
  11.        /* 如果数据不为空并且设备存在并且是阻塞访问方式才能继续执行 */  
  12.        if (client->head == client->tail&& evdev->exist && (file->f_flags & O_NONBLOCK))  
  13.               return -EAGAIN;  
  14.    
  15.        /* 如果数据为空，设置进程等待底层驱动层上报事件到client->buffer中 */  
  16.        retval =wait_event_interruptible(evdev->wait,  
  17.               client->head != client->tail|| !evdev->exist);  
  18.        if (retval)  
  19.               return retval;  
  20.    
  21.        if (!evdev->exist)  
  22.               return -ENODEV;  
  23.    
  24.        /* 循环读取数据 */  
  25.        while (client->head != client->tail&& retval + evdev_event_size() <= count) {  
  26.    
  27.               struct input_event *event =(struct input_event *) client->buffer + client->tail;  
  28.    
  29.               if (evdev_event_to_user(buffer +retval, event))  
  30.                      return -EFAULT;  
  31.    
  32.               client->tail = (client->tail+ 1) & (EVDEV_BUFFER_SIZE - 1);  
  33.               retval += evdev_event_size();  
  34.        }  
  35.    
  36.        return retval;  
  37. }  

这里如果没有数据，进程会睡眠，那由谁来唤醒呢？细心的话可以发现，当设备驱动层调用input_event上报事件调用相应的event函数进行事件写入时，是会唤醒阻塞等待的进程的。

1.5    通过设备节点写入输入事件

写入过程：

[cpp]  view plain copy
  1. static ssize_t evdev_write(struct file *file, const char __user *buffer, size_t count,loff_t *ppos)  
  2. {  
  3.        /* 循环写入，调用input_inject_event函数 */  
  4.        while (retval < count) {  
  5.    
  6.               if (evdev_event_from_user(buffer +retval, &event))  
  7.                      return -EFAULT;  
  8.               input_inject_event(&evdev->handle,event.type, event.code, event.value);  
  9.               retval += evdev_event_size();  
  10.        }  
  11.    
  12.        return retval;  
  13. }  

上述代码中的event是input_event数组，包含了事件的类型、键值，通过input_inject_event把数据写入循环数组client->buffer中，input_inject_event调用的是input_event函数。

1.6    总结

本节对input子系统的整个过程做了分析，并从两个角度进行考虑，对于写输入设备驱动程序的来说，需要掌握的是设备应该上报事件的类型，这样才能匹配到对应的事件层驱动帮助你保存对应的数据，而对于设备上层开发者来说，应该先使用cat /proc/bus/input/devices查看你操作的设备类型和处理接口，以帮助你更好的对设备操作。

你可能感兴趣的:(input输入子系统整体流程)

  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • 每日一题——第八十二题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
  • 每日一题——第八十三题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记 爱吃丸子的小樱桃
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • 闲鱼鱼小铺怎么开通？鱼小铺开通需要哪些流程？ 高省APP大九
    闲鱼鱼小铺是平台推出的一个专业程度的店铺，与普通店铺相比会有更多的权益，比如说发布的商品数量从50增加到500；拥有专业的店铺数据看板与分析的功能，这对于专门在闲鱼做生意的用户来说是非常有帮助的，那么鱼小铺每个人都能开通吗？大家好，我是高省APP联合创始人蓓蓓导师，高省APP是2021年推出的电商导购平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个可省钱佣金高，能
  • 高级 ECharts 技巧：自定义图表主题与样式 SnowMan1993 echarts信息可视化数据分析
    ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • Low Power概念介绍-Voltage Area 飞奔的大虎
    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 下一站深圳 默琊
    昨天已经买好3/15到深圳的机票了，原本上周还有点拖延症发作，不太积极，所以昨天就直接逼迫自己买机票，然后在订房，下周就是确认行业和把具体的面谈日程定下来。行业的选择上目前没有太大的偏好，上一份工作主要是风控和客服，客服部分也算是个小组长，有负责培训和一些案件SOP流程的制定等工作。总感觉客服这个职位的职涯发展只能是垂直的往更高的管理层走，对于横向发展似乎不容易，而鉴于做客服1年的感受，我不太喜欢
  • TDengine 签约前晨汽车，解锁智能出行的无限潜力 涛思数据（TDengine） tdengine汽车大数据
    在全球汽车产业转型升级的背景下，智能网联和新能源技术正迅速成为商用车行业的重要发展方向。随着市场对环保和智能化需求的日益增强，企业必须在技术创新和数据管理上不断突破，以满足客户对高效、安全和智能出行的期待。在这一背景下，前晨汽车凭借其在新能源智能商用车领域的前瞻性布局和技术实力，成为行业中的佼佼者。前晨汽车采用整车数据采集和全车数据打通策略，能够实时将数据推送至APP端客户。然而，这导致整体写入和
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
    importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
  • 用Python实现简单的猜数字游戏 程序媛了了 python游戏java
    猜数字游戏代码：importrandomdefpythonit():a=random.randint(1,100)n=int(input("输入你猜想的数字："))whilen!=a:ifn>a:print("很遗憾，猜大了")n=int(input("请再次输入你猜想的数字："))elifna::如果玩家猜的数字n大于随机数字a，则输出"很遗憾，猜大了"，并提示玩家再次输入。elifn
  • 网络通信流程 记得开心一点啊 服务器网络运维
    目录♫IP地址♫子网掩码♫MAC地址♫相关设备♫ARP寻址♫网络通信流程♫IP地址我们已经知道IP地址由网络号+主机号组成，根据IP地址的不同可以有5钟划分网络号和主机号的方案：其中，各类地址的表示范围是：分类范围适用网络网络数量主机最大连接数A类0.0.0.0~127.255.255.255大型网络12616777214【(2^24)-2】B类128.0.0.0~191.255.255.255中
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • 科幻游戏 《外卖员模拟器》 主要地理环境设定 (1) 穷人小水滴 游戏科幻设计
    游戏名称:《外卖员模拟器》(英文名称:waimai_se)作者:穷人小水滴本故事纯属虚构,如有雷同实属巧合.故事发生在一个(架空)平行宇宙的地球,21世纪(超低空科幻流派).相关文章:https://blog.csdn.net/secext2022/article/details/141790630目录1星球整体地理设定2巨蛇国主要设定3海蛇市主要设定3.1主要地标建筑3.2交通3.3能源(电力)
  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程 极客小张 stm32qt机器人物联网人机交互毕业设计c语言
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
  • 基于STM32的汽车仪表显示系统：集成CAN、UART与I2C总线设计流程 极客小张 stm32汽车嵌入式硬件物联网单片机c语言
    一、项目概述项目目标与用途本项目旨在设计和实现一个基于STM32微控制器的汽车仪表显示系统。该系统能够实时显示汽车的速度、转速、油量等关键信息，并通过CAN总线与其他汽车控制单元进行通信。这种仪表显示系统不仅提高了驾驶的安全性和便捷性，还能为汽车提供更智能的用户体验。技术栈关键词微控制器：STM32显示技术：TFTLCD/OLED传感器：速度传感器、温度传感器、油量传感器通信协议：CAN总线、UA
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • 亮剑的背后 晖晖晓
    今天是2018年12月21日是【晓晖有话说】陪伴你的第七百一十七天【亮剑的背后】：重新看《亮剑》的小说，沉重大过于狂乱的心情。历史的前进不是直线，不是渐进，可能是进很多步，退很多步，低速的螺旋上升。上升的方向却不明朗，或者是我们人为的设定好了前方的目的，但是整体人类文明的发展却总是产生种种意外，小进步小倒退，小倒退，小进步，我们还年轻。
  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能 小康师兄 ESP32-C3入门教程https服务器esp32OTAMQTT
    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
  • 项目：事半功倍的法宝 小小效能
    行动的三大流程：记录、排程和执行，也讲了易效能的4D原则以及T-step标签法。这些流程和方法能够解决我们眼前的一地鸡毛，让我们有更多时间和精力去关注更为长远的事情，完成工作、生活和人生中重要的项目。项目管理能够让我们围绕结果去做事情，达成事半功倍的效果，也就是做更少的事情，但达成更好的效果。如果我们能够不断地达成一个又一个的项目，那么我们的人生无疑会像滚雪球一样，在长坡道上面不断积累。一、项目的
  • Table列表复现框实现【勾选-搜索-再勾选】 ～四时春～ java开发语言elementuivue
    Table列表复现框实现【勾选-搜索-再勾选】概要整体架构流程代码实现技术细节注意参考文献概要最近在开发时遇到一个问题，在进行表单渲染时，正常选中没有问题，单如果需要搜索选中时，一个是已选中的不会回填，二是在搜索的结果中进行选中，没有实现，经过排查，查找资料后实现。例如：整体架构流程具体的实现效果如下：代码实现{{scope.row.userName}}已选区{{userItem.userName
  • vue+el-table 可输入表格使用上下键进行input框切换 以对_ vue学习记录vue.jsjavascript前端
    使用上下键进行完工数量这一列的切换-->//键盘触发事件show(ev,index){letnewIndex;letinputAll=document.querySelectorAll('.table_inputinput');//向上=38if(ev.keyCode==38){if(index==0){//如果是第一行,回到最后一个newIndex=inputAll.length-1}elsei
  • 分享十个渠道：高仿手表在哪里买最好的优选渠道 百奢之家
    1、工厂购买，推荐靠谱手表商家微信:【15266277】目前买的人最多的渠道。2、某宝购买，价格较高，质量没有保障。3、拼夕夕，价格是便宜，但是质量不敢想象。4、专柜购买，数量较少，经常断货，价格也太高不好接受。5、批发市场购买，可遇不可求，一般生活在批发市场附近的，根本不用考虑在哪里买手表作为一件配饰品，不仅可以提升整体造型品味，还能展现个人的时尚态度。而对于很多人来说，高仿手表是一种经济实惠又
  • apache 安装linux windows 墙头上一根草 apacheinuxwindows
    linux安装Apache 有两种方式一种是手动安装通过二进制的文件进行安装，另外一种就是通过yum 安装，此中安装方式，需要物理机联网。以下分别介绍两种的安装方式     通过二进制文件安装Apache需要的软件有apr,apr-util,pcre  1，安装 apr        下载地址：htt
  • fill_parent、wrap_content和match_parent的区别 Cb123456 match_parentfill_parent
    fill_parent、wrap_content和match_parent的区别:   1）fill_parent   设置一个构件的布局为fill_parent将强制性地使构件扩展，以填充布局单元内尽可能多的空间。这跟Windows控件的dockstyle属性大体一致。设置一个顶部布局或控件为fill_parent将强制性让它布满整个屏幕。 2） wrap_conte
  • 网页自适应设计 天子之骄 htmlcss响应式设计页面自适应
    网页自适应设计        网页对浏览器窗口的自适应支持变得越来越重要了。自适应响应设计更是异常火爆。再加上移动端的崛起，更是如日中天。以前为了适应不同屏幕分布率和浏览器窗口的扩大和缩小，需要设计几套css样式，用js脚本判断窗口大小，选择加载。结构臃肿，加载负担较大。现笔者经过一定时间的学习，有所心得，故分享于此，加强交流，共同进步。同时希望对大家有所
  • [sql server] 分组取最大最小常用sql 一炮送你回车库 SQL Server
    --分组取最大最小常用sql--测试环境if OBJECT_ID('tb') is not null drop table tb;gocreate table tb( col1 int, col2 int, Fcount int)insert into tbselect 11,20,1 union allselect 11,22,1 union allselect 1
  • ImageIO写图片输出到硬盘 3213213333332132 javaimage
    package awt; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import javax.imagei
  • 自己的String动态数组 宝剑锋梅花香 java动态数组数组
    数组还是好说，学过一两门编程语言的就知道，需要注意的是数组声明时需要把大小给它定下来，比如声明一个字符串类型的数组：String str[]=new String[10];    但是问题就来了，每次都是大小确定的数组，我需要数组大小不固定随时变化怎么办呢？  动态数组就这样应运而生，龙哥给我们讲的是自己用代码写动态数组，并非用的ArrayList 看看字符
  • pinyin4j工具类 darkranger .net
    pinyin4j工具类Java工具类 2010-04-24 00:47:00 阅读69 评论0 字号：大中小 引入pinyin4j-2.5.0.jar包: pinyin4j是一个功能强悍的汉语拼音工具包，主要是从汉语获取各种格式和需求的拼音，功能强悍，下面看看如何使用pinyin4j。 本人以前用AscII编码提取工具，效果不理想，现在用pinyin4j简单实现了一个。功能还不是很完美，
  • StarUML学习笔记----基本概念 aijuans UML建模
    介绍StarUML的基本概念，这些都是有效运用StarUML?所需要的。包括对模型、视图、图、项目、单元、方法、框架、模型块及其差异以及UML轮廓。         模型、视与图（Model, View and Diagram）        &
  • Activiti最终总结 avords Activiti id 工作流
    1、流程定义ID：ProcessDefinitionId，当定义一个流程就会产生。 2、流程实例ID：ProcessInstanceId，当开始一个具体的流程时就会产生，也就是不同的流程实例ID可能有相同的流程定义ID。 3、TaskId，每一个userTask都会有一个Id这个是存在于流程实例上的。 4、TaskDefinitionKey和（ActivityImpl activityId
  • 从省市区多重级联想到的，react和jquery的差别 bee1314 jqueryUIreact
    在我们的前端项目里经常会用到级联的select，比如省市区这样。通常这种级联大多是动态的。比如先加载了省，点击省加载市，点击市加载区。然后数据通常ajax返回。如果没有数据则说明到了叶子节点。   针对这种场景，如果我们使用jquery来实现，要考虑很多的问题，数据部分，以及大量的dom操作。比如这个页面上显示了某个区，这时候我切换省，要把市重新初始化数据，然后区域的部分要从页面
  • Eclipse快捷键大全 bijian1013 javaeclipse快捷键
    Ctrl+1 快速修复(最经典的快捷键,就不用多说了)Ctrl+D: 删除当前行 Ctrl+Alt+↓ 复制当前行到下一行(复制增加)Ctrl+Alt+↑ 复制当前行到上一行(复制增加)Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)Alt+↑ 当前行和上面一行交互位置(同上)Alt+← 前一个编辑的页面Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)Alt+En
  • js 笔记 函数 征客丶 JavaScript
    一、函数的使用 1.1、定义函数变量 var vName = funcation(params){ } 1.2、函数的调用 函数变量的调用：      vName(params); 函数定义时自发调用：(function(params){})(params); 1.3、函数中变量赋值 var a = 'a'; var ff
  • 【Scala四】分析Spark源代码总结的Scala语法二 bit1129 scala
    1. Some操作   在下面的代码中，使用了Some操作：if (self.partitioner == Some(partitioner))，那么Some(partitioner)表示什么含义？首先partitioner是方法combineByKey传入的变量， Some的文档说明：   /** Class `Some[A]` represents existin
  • java 匿名内部类 BlueSkator java匿名内部类
    组合优先于继承 Java的匿名类，就是提供了一个快捷方便的手段，令继承关系可以方便地变成组合关系 继承只有一个时候才能用，当你要求子类的实例可以替代父类实例的位置时才可以用继承。   在Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。 内部类不是很好理解，但说白了其实也就是一个类中还包含着另外一个类如同一个人是由大脑、肢体、器官等身体结果组成，而内部类相
  • 盗版win装在MAC有害发热，苹果的东西不值得买，win应该不用 ljy325 游戏applewindowsXPOS
    Mac mini 型号: MC270CH-A RMB:5,688   Apple 对windows的产品支持不好,有以下问题:   1.装完了xp,发现机身很热虽然没有运行任何程序！貌似显卡跑游戏发热一样，按照那样的发热量,那部机子损耗很大,使用寿命受到严重的影响!   2.反观安装了Mac os的展示机，发热量很小，运行了1天温度也没有那么高 &nbs
  • 读《研磨设计模式》-代码笔记-生成器模式-Builder bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * 生成器模式的意图在于将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示（GoF） * 个人理解： * 构建一个复杂的对象，对于创建者（Builder）来说，一是要有数据来源(rawData)，二是要返回构
  • JIRA与SVN插件安装 chenyu19891124 SVNjira
    JIRA安装好后提交代码并要显示在JIRA上，这得需要用SVN的插件才能看见开发人员提交的代码。 1.下载svn与jira插件安装包，解压后在安装包(atlassian-jira-subversion-plugin-0.10.1) 2.解压出来的包里下的lib文件夹下的jar拷贝到(C:\Program Files\Atlassian\JIRA 4.3.4\atlassian-jira\WEB
  • 常用数学思想方法 comsci 工作
      对于搞工程和技术的朋友来讲，在工作中常常遇到一些实际问题，而采用常规的思维方式无法很好的解决这些问题，那么这个时候我们就需要用数学语言和数学工具，而使用数学工具的前提却是用数学思想的方法来描述问题。。下面转帖几种常用的数学思想方法，仅供学习和参考   函数思想 　　把某一数学问题用函数表示出来，并且利用函数探究这个问题的一般规律。这是最基本、最常用的数学方法
  • pl/sql集合类型 daizj oracle集合typepl/sql
    --集合类型 /*   单行单列的数据，使用标量变量   单行多列数据，使用记录   单列多行数据，使用集合（。。。）   *集合：类似于数组也就是。pl/sql集合类型包括索引表（pl/sql table）、嵌套表（Nested Table）、变长数组（VARRAY）等 */ /*     --集合方法 &n
  • [Ofbiz]ofbiz初用 dinguangx 电商ofbiz
    从github下载最新的ofbiz（截止2015-7-13），从源码进行ofbiz的试用 1. 加载测试库 ofbiz内置derby，通过下面的命令初始化测试库 ./ant load-demo (与load-seed有一些区别)   2. 启动内置tomcat ./ant start 或 ./startofbiz.sh 或 java -jar ofbiz.jar &
  • 结构体中最后一个元素是长度为0的数组 dcj3sjt126com cgcc
    在Linux源代码中，有很多的结构体最后都定义了一个元素个数为0个的数组，如/usr/include/linux/if_pppox.h中有这样一个结构体： struct pppoe_tag {     __u16 tag_type;     __u16 tag_len;   &n
  • Linux cp 实现强行覆盖 dcj3sjt126com linux
    发现在Fedora 10 /ubutun 里面用cp -fr src dest，即使加了-f也是不能强行覆盖的，这时怎么回事的呢？一两个文件还好说，就输几个yes吧，但是要是n多文件怎么办，那还不输死人呢？下面提供三种解决办法。 方法一 我们输入alias命令，看看系统给cp起了一个什么别名。 [root@localhost ~]# aliasalias cp=’cp -i’a
  • Memcached(一)、HelloWorld frank1234 memcached
    一、简介 高性能的架构离不开缓存，分布式缓存中的佼佼者当属memcached，它通过客户端将不同的key hash到不同的memcached服务器中，而获取的时候也到相同的服务器中获取，由于不需要做集群同步，也就省去了集群间同步的开销和延迟，所以它相对于ehcache等缓存来说能更好的支持分布式应用，具有更强的横向伸缩能力。 二、客户端 选择一个memcached客户端，我这里用的是memc
  • Search in Rotated Sorted Array II hcx2013 search
    Follow up for "Search in Rotated Sorted Array":What if duplicates are allowed? Would this affect the run-time complexity? How and why? Write a function to determine if a given ta
  • Spring4新特性——更好的Java泛型操作API jinnianshilongnian spring4generic type
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • CentOS安装JDK liuxingguome centos
    1、行卸载原来的： [root@localhost opt]# rpm -qa | grep java tzdata-java-2014g-1.el6.noarch java-1.7.0-openjdk-1.7.0.65-2.5.1.2.el6_5.x86_64 java-1.6.0-openjdk-1.6.0.0-11.1.13.4.el6.x86_64 [root@localhost
  • 二分搜索专题2-在有序二维数组中搜索一个元素 OpenMind 二维数组算法二分搜索
    1,设二维数组p的每行每列都按照下标递增的顺序递增。 用数学语言描述如下：p满足 (1),对任意的x1，x2，y，如果x1<x2,则p(x1,y)<p(x2,y); (2),对任意的x，y1,y2, 如果y1<y2,则p(x,y1)<p(x,y2); 2,问题： 给定满足1的数组p和一个整数k，求是否存在x0,y0使得p(x0,y0)=k? 3,算法分析： (
  • java 随机数 Math与Random SaraWon javaMathRandom
    今天需要在程序中产生随机数，知道有两种方法可以使用，但是使用Math和Random的区别还不是特别清楚，看到一篇文章是关于的，觉得写的还挺不错的，原文地址是 http://www.oschina.net/question/157182_45274?sort=default&p=1#answers 产生1到10之间的随机数的两种实现方式： //Math Math.roun
  • oracle创建表空间 tugn oracle
    create temporary tablespace TXSJ_TEMP   tempfile 'E:\Oracle\oradata\TXSJ_TEMP.dbf'   size 32m   autoextend on   next 32m maxsize 2048m   extent m
  • 使用Java8实现自己的个性化搜索引擎 yangshangchuan javasuperword搜索引擎java8全文检索
    需要对249本软件著作实现句子级别全文检索，这些著作均为PDF文件，不使用现有的框架如lucene，自己实现的方法如下： 1、从PDF文件中提取文本，这里的重点是如何最大可能地还原文本。提取之后的文本，一个句子一行保存为文本文件。 2、将所有文本文件合并为一个单一的文本文件，这样，每一个句子就有一个唯一行号。 3、对每一行文本进行分词，建立倒排表，倒排表的格式为：词=包含该词的总行数N=行号
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他