Difference between revisions of "Uinput"

From Ilianko
 
(10 intermediate revisions by the same user not shown)
Line 1: Line 1:
==uinput==
+
==Вход от потрeбителско ниво==
Вход от потрeбителско ниво
 
 
 
<!-- uinput is a linux kernel module that allows to handle the input subsystem from user land. It can be used to create and to handle input devices from an application. It creates a character device in /dev/input directory. The device is a virtual interface, it doesn't belong to a physical device.
 
 
 
In this document, we will see how to create a such input device and how it can be used. -->
 
  
 
Uinput е модул за linux ядрото, който позволява управление на системата за входни данни от приложения работещи на потребителско ниво. Модулът uinput създава виртуално входно устройство.  
 
Uinput е модул за linux ядрото, който позволява управление на системата за входни данни от приложения работещи на потребителско ниво. Модулът uinput създава виртуално входно устройство.  
 
  
 
===Създаване на входно устройство===
 
===Създаване на входно устройство===
Line 27: Line 21:
 
  }
 
  }
  
След като е отворено устройството трябва да се конфигурира. Първо трябва да се инициализират типовете входни събития, които ще се ползват. Типовете събития са дефинирани в /usr/include/linux/input.h. Примерно:
+
 
...
+
===Дефиниране на входни събития===
#define EV_KEY          0x01
+
След като е отворено устройството трябва да се конфигурира. Първо трябва да се инициализират типовете входни събития, които ще се ползват. Типовете събития са дефинирани в /usr/include/linux/input.h.
#define EV_REL          0x02
+
 
#define EV_ABS          0x03
+
Активиране на събития чрез [http://en.wikipedia.org/wiki/Ioctl ioctl]. Следните редове активират събития натискане/отпускане на бутон и синхронизация.
...
+
 
  
 
*EV_KEY събитие за натиснат или отпуснат бутон от клавиатурата,
 
*EV_KEY събитие за натиснат или отпуснат бутон от клавиатурата,
 
*EV_REL събитие за относително отместване (преместване на мишка),
 
*EV_REL събитие за относително отместване (преместване на мишка),
 
*EV_ABS събитие за абсолютно отместване  (позиция от сензорен екран).
 
*EV_ABS събитие за абсолютно отместване  (позиция от сензорен екран).
 +
*EV_SYN синхронизиращо събитие (изпраща се винаги след движение по относителни координати (мишка)
 +
*EV_REP повтаряне на бутон ???
  
===Дефиниране на събития===
 
 
Активиране на събития чрез [http://en.wikipedia.org/wiki/Ioctl ioctl]. Следните редове активират събития натискане/отпускане на бутон и синхронизация.
 
 
  ioctl(fd, UI_SET_EVBIT, EV_KEY);
 
  ioctl(fd, UI_SET_EVBIT, EV_KEY);
 
  ioctl(fd, UI_SET_EVBIT, EV_SYN);
 
  ioctl(fd, UI_SET_EVBIT, EV_SYN);
 +
ioctl(fd, UI_SET_EVBIT, EV_ABS);
 +
ioctl(fd, UI_SET_EVBIT, EV_REL);
 +
ioctl(fd, UI_SET_EVBIT, EV_REP);
  
При активиране на ЕV_KEY събитие, трябва да се опишат и възможните бутони, които ще бъдат изпращани. За 'd' се дефинира по следния начин:
+
===Дефиниране на състояния на събитие===
ret = ioctl(fd, UI_SET_KEYBIT, KEY_D);
 
  
Now some basic features have been enabled, we need to finish the configuration by using the struct uinput_user_dev from linux/uinput.h. This structure is defined as:
+
====EV_KEY====
 +
При активиране на ЕV_KEY събитие, трябва да се опишат и възможните бутони, които ще бъдат изпращани. За 'd' се дефинира по следния начин:
 +
 +
ioctl(fd, UI_SET_KEYBIT, KEY_D);
  
/usr/include/linux/uinput.h
+
Дефиниране на поддръжка на всички възможни бутони
  #define UINPUT_MAX_NAME_SIZE    80
+
  for (i = 0; i < KEY_MAX; i++) {
struct uinput_user_dev {
+
         if (ioctl(fd, UI_SET_KEYBIT, i) == -1)
    char name[UINPUT_MAX_NAME_SIZE];
+
            exit(11);
    struct input_id id;
+
    }
         int ff_effects_max;
+
====EV_REL====
        int absmax[ABS_MAX + 1];
+
Дефиниране на отместване по x i y.
        int absmin[ABS_MAX + 1];
+
ioctl(fd, UI_SET_RELBIT, REL_X);
        int absfuzz[ABS_MAX + 1];
+
  ioctl(fd, UI_SET_RELBIT, REL_Y);
        int absflat[ABS_MAX + 1];
 
  };
 
  
The most important fields are:
+
====EV_ABS====
*name is the given name to the input device we will create,
+
Дефиниране на отместване по абсолютни координати. Може да работи или относително или абсолютно отместванепо.
*id is a linux internal structure that describes the device bustype, vendor id, product id and version,
+
ioctl(fd, UI_SET_ABSBIT, ABS_X)
*absmin and absmax are integer array that defines mininal and maximal values for an absolute axis (i.e *absmin[ABS_X] = 0, absmax[ABS_X] = 1024 for the X axis on a touchscreen device).
+
ioctl(fd, UI_SET_ABSBIT, ABS_Y)
 +
ioctl(fd, UI_SET_ABSBIT, 0)
 +
 
 +
===Допълнително конфигуриране===
 +
Задават се:
 +
*Име на входното устойство
 +
*id - описва типа на шината, ...
 +
*absmin and absmax цели числа описващи минимална и максимална координати.
 +
 
 +
struct uinput_user_dev udev
  
Now, we can fill this structure with appropriate values:
 
struct uinput_user_dev uidev;
 
 
  memset(&uidev, 0, sizeof(uidev));
 
  memset(&uidev, 0, sizeof(uidev));
 
 
  snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
 
  snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
 
  uidev.id.bustype = BUS_USB;
 
  uidev.id.bustype = BUS_USB;
  uidev.id.vendor  = 0x1234;
+
  uidev.id.vendor  = 0x1;
  uidev.id.product = 0xfedc;
+
  uidev.id.product = 0x1;
 
  uidev.id.version = 1;
 
  uidev.id.version = 1;
 +
 +
/* необходими само ако се работи с абсолютни координати
 +
uidev.absmin[ABS_X] = -600; //Минимална координата
 +
uidev.absmax[ABS_X] = 600;
 +
uidev.absfuzz[ABS_X] = 0;
 +
uidev.absflat[ABS_X] = 0;
  
Then, we write this structure in the uinput file descriptor.
+
uidev.absmin[ABS_Y] = -400;
 +
uidev.absmax[ABS_Y] = 400;
 +
uidev.absfuzz[ABS_Y] = 0;
 +
uidev.absflat[ABS_Y] = 0;
 +
*/
 +
write(fd, &uidev, sizeof(uidev)
  
  ret = write(fd, &uidev, sizeof(uidev));
+
===Създаване на устройството===
 +
   
 +
ioctl(fd, UI_DEV_CREATE);
  
Last step is to request the creation of the device via the UI_DEV_CREATE ioctl request on the file descriptor:
+
===Генериране на събитие===
  
ret = ioctl(fd, UI_DEV_CREATE);
 
  
Now, the file descriptor fd represents the end-point file descriptor of the new input device.
+
*type: EV_KEY, EV_ABS, EV_REL, EV_SYN;
 +
*code: EV_KEY, EV_ABS, EV_REL, SYN_REPORT;
 +
*value: 1 (натискане), 0 (отпускане), (2) задаържане за EV_KEY, или цели числа за EV_ABS и EV_REL.
  
===Injecting events in the input subsystem===
+
Инжектиране:
 +
  struct input_event event;
 +
  memset(&event, 0, sizeof(event));
 +
  gettimeofday(&event.time, 0); /* This should not be able to fail ever.. */
 +
  event.type = type;
 +
  event.code = code;
 +
  event.value = value;
 +
  write(uinput_fd, &event, sizeof(event)
  
The following block code injects a key press event in the input subsystem. The input_event structure contains 3 important fields:
+
!! След събитие за отнисително движение се изпраща, събитие за синхронизация
*type: is an event type (EV_KEY, EV_ABS, EV_REL, ...),
+
!! След събитие за натискане на бутон, трябва да се изпрати събитие за отпускане
*code: could be either a key code when using EV_KEY, or an axis for EV_ABS and EV_REL,
 
*value: may be 1 (press) or 0 (release) for EV_KEY, or any values for others (positive integer for EV_ABS, signed integer for EV_REL, etc…).
 
  
To inject a press event on the 'd' key:
+
=== Затваряне на устройството ===
struct input_event ev;
+
  ioctl(fd, UI_DEV_DESTROY);
memset(&ev, 0, sizeof(ev));
 
ev.type = EV_KEY;
 
ev.code = KEY_D;
 
ev.value = 1;
 
ret = write(fd, &ev, sizeof(ev));
 
===Destroying an input device===
 
  ret = ioctl(fd, UI_DEV_DESTROY);
 
  
===Handling absolute axis events===
+
== Виртуално устройство ==
 
 
If we want to inject absolute events, we first need to activate EV_ABS event and the desired axes support with ioctl requests. The following ioctl requests enable X and Y absolute axes:
 
 
 
ret = ioctl(fd, UI_SET_EVBIT, EV_ABS);
 
...
 
ret = ioctl(fd, UI_SET_ABSBIT, ABS_X);
 
...
 
ret = ioctl(fd, UI_SET_ABSBIT, ABS_Y);
 
 
 
Then we need to defined a range of values for each axis with absmin and absmax fields from the uinput_user_dev structure:
 
 
 
uidev.absmin[ABS_X] = 0;
 
uidev.absmax[ABS_X] = 1023;
 
 
 
Event injection follows the same method as for any other events.
 
struct input_event ev[2];
 
memset(ev, 0, sizeof(ev));
 
ev[0].type = EV_ABS;
 
ev[0].code = ABS_X;
 
ev[0].value = 1023;
 
ev[1].type = EV_ABS;
 
ev[1].code = ABS_Y;
 
ev[1].value = 767;
 
ret = write(fd, ev, sizeof(ev));
 
 
 
== Виртуална мишка ==
 
  
 
<code><pre>
 
<code><pre>
 
#include <stdio.h>
 
#include <stdio.h>
 +
#include <string.h>
 
#include <stdlib.h>
 
#include <stdlib.h>
#include <string.h>
 
 
#include <unistd.h>
 
#include <unistd.h>
 
#include <fcntl.h>
 
#include <fcntl.h>
#include <errno.h>
 
#include <linux/input.h>
 
 
#include <linux/uinput.h>
 
#include <linux/uinput.h>
 +
#include <stdint.h>
  
int main(void)
+
int suinput_write(int uinput_fd, uint16_t type, uint16_t code, int32_t value)
 
{
 
{
     int                    fd;
+
     //генериране на събитие
     struct uinput_user_dev uidev;
+
    struct input_event event;
     struct input_event     ev;
+
    memset(&event, 0, sizeof(event));
     int                   dx, dy;
+
    gettimeofday(&event.time, 0); /* This should not be able to fail ever.. */
 +
    event.type = type;
 +
    event.code = code;
 +
    event.value = value;
 +
     if (write(uinput_fd, &event, sizeof(event)) != sizeof(event))
 +
        return -1;
 +
     return 0;
 +
}
 +
 
 +
int suinput_write_syn(int uinput_fd,
 +
                            uint16_t type, uint16_t code, int32_t value)
 +
{ // синхронизиращо събитир
 +
     if (suinput_write(uinput_fd, type, code, value))
 +
        return -1;
 +
     return suinput_write(uinput_fd, EV_SYN, SYN_REPORT, 0);
 +
}
 +
 
 +
int suinput_move_pointer(int uinput_fd, int32_t x, int32_t y)
 +
{ //относително отместване
 +
    if (suinput_write(uinput_fd, EV_REL, REL_X, x))
 +
        return -1;
 +
    return suinput_write_syn(uinput_fd, EV_REL, REL_Y, y);
 +
}
  
    fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
 
        if(fd < 0) exit(0);
 
       
 
    ioctl(fd, UI_SET_EVBIT, EV_KEY);
 
    ioctl(fd, UI_SET_KEYBIT, BTN_LEFT);
 
   
 
    ioctl(fd, UI_SET_EVBIT, EV_REL);
 
    ioctl(fd, UI_SET_RELBIT, REL_X);
 
    ioctl(fd, UI_SET_RELBIT, REL_Y);
 
   
 
   
 
  
    memset(&uidev, 0, sizeof(uidev));
+
int suinput_open(const char* device_name, int abs)
 +
{
 +
//създаване на устройство
 +
  int fd, i;
 +
  struct uinput_user_dev uidev;
 +
 +
  fd = open( device_name, O_WRONLY | O_NONBLOCK);
 +
  if (fd == -1)
 +
        exit(1);
 +
 
 +
  memset(&uidev, 0, sizeof(uidev));
 
     snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
 
     snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
 
     uidev.id.bustype = BUS_USB;
 
     uidev.id.bustype = BUS_USB;
Line 166: Line 174:
 
     uidev.id.product = 0x1;
 
     uidev.id.product = 0x1;
 
     uidev.id.version = 1;
 
     uidev.id.version = 1;
 +
  /* Set device to handle following types of events: */
 +
 +
  /* Key and button events */
 +
  if (ioctl(fd, UI_SET_EVBIT, EV_KEY) == -1)
 +
      exit(2);
 +
 +
  /* Key and button repetition events */
 +
  if (ioctl(fd, UI_SET_EVBIT, EV_REP) == -1)
 +
      exit(3);
 +
 
 +
  /* Synchronization events, this is probably set implicitely too. */
 +
    if (ioctl(fd, UI_SET_EVBIT, EV_SYN) == -1)
 +
        exit(3);
  
    write(fd, &uidev, sizeof(uidev));
+
if (abs)
    ioctl(fd, UI_DEV_CREATE);
+
{
 +
if (ioctl(fd, UI_SET_EVBIT, EV_REL) == -1)
 +
        exit(3);
  
    sleep(3);
+
/* Configure device to handle relative x and y axis. */
 +
if (ioctl(fd, UI_SET_RELBIT, REL_X) == -1)
 +
exit(3);
 +
   
 +
if (ioctl(fd, UI_SET_RELBIT, REL_Y) == -1)
 +
exit(3);
 +
 +
}
 +
else
 +
{/* Configure device to handle absolute x and y axis. */
 +
if (ioctl(fd, UI_SET_EVBIT, EV_ABS) == -1)
 +
exit(4);
 +
 +
if (ioctl(fd, UI_SET_ABSBIT, ABS_X) == -1)
 +
exit(4);
 +
if (ioctl(fd, UI_SET_ABSBIT, ABS_Y) == -1)
 +
        exit(4);
 +
if (ioctl(fd, UI_SET_ABSBIT, 0) == -1)
 +
exit(4);
 +
 +
uidev.absmin[ABS_X] = -600;
 +
uidev.absmax[ABS_X] = 600;
 +
uidev.absfuzz[ABS_X] = 0;
 +
uidev.absflat[ABS_X] = 0;
  
    dx = -100;
+
uidev.absmin[ABS_Y] = -400;
    dy = -10;
+
uidev.absmax[ABS_Y] = 400;
         
+
uidev.absfuzz[ABS_Y] = 0;
    memset(&ev, 0, sizeof(struct input_event));
+
uidev.absflat[ABS_Y] = 0;
    ev.type = EV_REL;
+
}
    ev.code = REL_X;
 
    ev.value = dx;
 
    write(fd, &ev, sizeof(struct input_event));
 
       
 
    memset(&ev, 0, sizeof(struct input_event));
 
    ev.type = EV_REL;
 
    ev.code = REL_Y;
 
    ev.value = dy;
 
    write(fd, &ev, sizeof(struct input_event));
 
  
     нулиране
+
     /* Configure device to handle all keys, see linux/input.h. */
     memset(&ev, 0, sizeof(struct input_event));
+
    for (i = 0; i < KEY_MAX; i++) {
     ev.type = BTN_LEFT;
+
        if (ioctl(fd, UI_SET_KEYBIT, i) == -1)
     ev.code = 0;
+
            exit(11);
     ev.value = 0;
+
    }
     write(fd, &ev, sizeof(struct input_event));
+
 
 +
     if(write(fd, &uidev, sizeof(uidev)) < 0)
 +
        exit(10);
 +
   
 +
    if(ioctl(fd, UI_DEV_CREATE) < 0)
 +
        exit(12);
 +
   
 +
    /*
 +
  The reason for generating a small delay is that creating succesfully
 +
  an uinput device does not guarantee that the device is ready to process
 +
  input events. It's probably due the asynchronous nature of the udev.
 +
  However, my experiments show that the device is not ready to process input
 +
  events even after a device creation event is received from udev.
 +
  */
 +
    sleep(2);   return fd;
 +
}
 +
 
 +
int suinput_press(int uinput_fd, uint16_t code)
 +
{
 +
     return suinput_write(uinput_fd, EV_KEY, code, 1);
 +
}
 +
 
 +
int suinput_release(int uinput_fd, uint16_t code)
 +
{
 +
     return suinput_write_syn(uinput_fd, EV_KEY, code, 0);
 +
}
 +
 
 +
 
 +
int suinput_set_pointer(int uinput_fd, int32_t x, int32_t y)
 +
{
 +
    if (suinput_write(uinput_fd, EV_ABS, ABS_X, x))
 +
        return -1;
 +
    return suinput_write_syn(uinput_fd, EV_ABS, ABS_Y, y);
 +
}
 +
 
 +
int suinput_click(int uinput_fd, uint16_t code)
 +
{
 +
    if (suinput_press(uinput_fd, code))
 +
        return -1;
 +
     return suinput_release(uinput_fd, code);
 +
}
 +
 
 +
int suinput_close(int uinput_fd)
 +
{
 +
    /*
 +
    Sleep before destroying the device because there still can be some
 +
    unprocessed events. This is not the right way, but I am still
 +
    looking for better ways. The question is: how to know whether there
 +
    are any unprocessed uinput events?
 +
  */
 +
    //sleep(2);
 +
 
 +
    if (ioctl(uinput_fd, UI_DEV_DESTROY) == -1) {
 +
        close(uinput_fd);
 +
        return -1;
 +
     }
 +
 
 +
    if (close(uinput_fd) == -1)
 +
        return -1;
  
    ioctl(fd, UI_DEV_DESTROY);
 
    close(fd);
 
 
     return 0;
 
     return 0;
 +
}
 +
 +
 +
int main(void)
 +
{
 +
     
 +
  int  fd;
 +
  fd = suinput_open("/dev/uinput", 0); // 0 - absolute , 1 relative
 +
     
 +
     
 +
  //suinput_move_pointer(fd, 130,130);
 +
  suinput_set_pointer(fd, 60, 60);
 +
 
 +
  suinput_press(fd, 2);
 +
  suinput_release(fd, 2);
 +
  usleep(10000);
 +
  suinput_click(fd,  BTN_LEFT);
 +
 
 +
  usleep(10000);
 +
 
 +
  // suinput_click(fd,  BTN_RIGHT);
 +
  suinput_set_pointer(fd, -60, -60);
 +
  usleep(10000);
 +
 
 +
  suinput_click(fd,  BTN_LEFT);
 +
     
 +
  suinput_press(fd, 3);
 +
  suinput_press(fd, 5);
 +
     
 +
  suinput_close(fd);
 +
 
 +
  return 0;
 
}
 
}
 
</pre></code>
 
</pre></code>
  
 +
 +
== Да се създаде виртуална мишка, която да се управлява чрез стрелките ==
 +
 +
Използвайте директен достъп до клавитурата:
 
<code><pre>
 
<code><pre>
 
#include <linux/input.h>
 
#include <linux/input.h>
Line 231: Line 360:
 
</pre></code>
 
</pre></code>
  
 +
 +
==Връзки==
 +
*[http://thiemonge.org/getting-started-with-uinput Getting started with uinput: the user level input subsystem]
 +
*http://remoteroid.googlecode.com/svn-history/r277/trunk/android/jni/suinput.cpp
  
 
[[Category:Компютърна периферия]]
 
[[Category:Компютърна периферия]]

Latest revision as of 10:11, 31 March 2013

Вход от потрeбителско ниво

Uinput е модул за linux ядрото, който позволява управление на системата за входни данни от приложения работещи на потребителско ниво. Модулът uinput създава виртуално входно устройство.

Създаване на входно устройство

След инсталиране на модула uinput (чрез modprobe или insmod) се създава устройство от буквен тип с име /dev/input/uinput (или /dev/uinput). Това устройство представлява интерфейса между приложението и системата за входни данни на ядрото.

За да се използва uinput, то устройството трябва трябва да се отвори само за запис и в неблокиращ режим.

#include <linux/input.h>
#include <linux/uinput.h>
...

int fd;

fd = open("/dev/input/uinput", O_WRONLY | O_NONBLOCK);
if(fd < 0) {
   ...
   exit(EXIT_FAILURE);
}


Дефиниране на входни събития

След като е отворено устройството трябва да се конфигурира. Първо трябва да се инициализират типовете входни събития, които ще се ползват. Типовете събития са дефинирани в /usr/include/linux/input.h.

Активиране на събития чрез ioctl. Следните редове активират събития натискане/отпускане на бутон и синхронизация.


  • EV_KEY събитие за натиснат или отпуснат бутон от клавиатурата,
  • EV_REL събитие за относително отместване (преместване на мишка),
  • EV_ABS събитие за абсолютно отместване (позиция от сензорен екран).
  • EV_SYN синхронизиращо събитие (изпраща се винаги след движение по относителни координати (мишка)
  • EV_REP повтаряне на бутон ???
ioctl(fd, UI_SET_EVBIT, EV_KEY);
ioctl(fd, UI_SET_EVBIT, EV_SYN);
ioctl(fd, UI_SET_EVBIT, EV_ABS); 
ioctl(fd, UI_SET_EVBIT, EV_REL);
ioctl(fd, UI_SET_EVBIT, EV_REP);

Дефиниране на състояния на събитие

EV_KEY

При активиране на ЕV_KEY събитие, трябва да се опишат и възможните бутони, които ще бъдат изпращани. За 'd' се дефинира по следния начин:

ioctl(fd, UI_SET_KEYBIT, KEY_D);

Дефиниране на поддръжка на всички възможни бутони

for (i = 0; i < KEY_MAX; i++) {
       if (ioctl(fd, UI_SET_KEYBIT, i) == -1)
           exit(11);
   }

EV_REL

Дефиниране на отместване по x i y.

ioctl(fd, UI_SET_RELBIT, REL_X);
ioctl(fd, UI_SET_RELBIT, REL_Y);

EV_ABS

Дефиниране на отместване по абсолютни координати. Може да работи или относително или абсолютно отместванепо.

ioctl(fd, UI_SET_ABSBIT, ABS_X)
ioctl(fd, UI_SET_ABSBIT, ABS_Y)
ioctl(fd, UI_SET_ABSBIT, 0)

Допълнително конфигуриране

Задават се:

  • Име на входното устойство
  • id - описва типа на шината, ...
  • absmin and absmax цели числа описващи минимална и максимална координати.
struct uinput_user_dev udev
memset(&uidev, 0, sizeof(uidev));
snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
uidev.id.bustype = BUS_USB;
uidev.id.vendor  = 0x1;
uidev.id.product = 0x1;
uidev.id.version = 1;

/* необходими само ако се работи с абсолютни координати 
uidev.absmin[ABS_X] = -600; //Минимална координата
uidev.absmax[ABS_X] = 600;
uidev.absfuzz[ABS_X] = 0;
uidev.absflat[ABS_X] = 0;
uidev.absmin[ABS_Y] = -400;
uidev.absmax[ABS_Y] = 400;
uidev.absfuzz[ABS_Y] = 0;
uidev.absflat[ABS_Y] = 0;	
*/
write(fd, &uidev, sizeof(uidev)

Създаване на устройството

ioctl(fd, UI_DEV_CREATE);

Генериране на събитие

  • type: EV_KEY, EV_ABS, EV_REL, EV_SYN;
  • code: EV_KEY, EV_ABS, EV_REL, SYN_REPORT;
  • value: 1 (натискане), 0 (отпускане), (2) задаържане за EV_KEY, или цели числа за EV_ABS и EV_REL.

Инжектиране:

 struct input_event event;
 memset(&event, 0, sizeof(event));
 gettimeofday(&event.time, 0); /* This should not be able to fail ever.. */
 event.type = type;
 event.code = code;
 event.value = value;
 write(uinput_fd, &event, sizeof(event)

!! След събитие за отнисително движение се изпраща, събитие за синхронизация !! След събитие за натискане на бутон, трябва да се изпрати събитие за отпускане

Затваряне на устройството

ioctl(fd, UI_DEV_DESTROY);

Виртуално устройство

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <linux/uinput.h>
#include <stdint.h>

int suinput_write(int uinput_fd, uint16_t type, uint16_t code, int32_t value)
{
    //генериране на събитие
    struct input_event event;
    memset(&event, 0, sizeof(event));
    gettimeofday(&event.time, 0); /* This should not be able to fail ever.. */
    event.type = type;
    event.code = code;
    event.value = value;
    if (write(uinput_fd, &event, sizeof(event)) != sizeof(event))
        return -1;
    return 0;
}

int suinput_write_syn(int uinput_fd, 
                             uint16_t type, uint16_t code, int32_t value)
{	// синхронизиращо събитир
    if (suinput_write(uinput_fd, type, code, value))
        return -1;
    return suinput_write(uinput_fd, EV_SYN, SYN_REPORT, 0);
}

int suinput_move_pointer(int uinput_fd, int32_t x, int32_t y)
{	//относително отместване
    if (suinput_write(uinput_fd, EV_REL, REL_X, x))
        return -1;
    return suinput_write_syn(uinput_fd, EV_REL, REL_Y, y);
}


int suinput_open(const char* device_name, int abs)
{	
	//създаване на устройство
   int fd, i;
   struct uinput_user_dev uidev;
 
   fd = open( device_name, O_WRONLY | O_NONBLOCK);
   if (fd == -1)
        exit(1);
   
   memset(&uidev, 0, sizeof(uidev));
    snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
    uidev.id.bustype = BUS_USB;
    uidev.id.vendor  = 0x1;
    uidev.id.product = 0x1;
    uidev.id.version = 1;
   /* Set device to handle following types of events: */

   /* Key and button events */
   if (ioctl(fd, UI_SET_EVBIT, EV_KEY) == -1)
       exit(2);

   /* Key and button repetition events */
   if (ioctl(fd, UI_SET_EVBIT, EV_REP) == -1)
       exit(3);
  
   /* Synchronization events, this is probably set implicitely too. */
    if (ioctl(fd, UI_SET_EVBIT, EV_SYN) == -1)
        exit(3);

	if (abs)
	{
		if (ioctl(fd, UI_SET_EVBIT, EV_REL) == -1)
        exit(3);

		/* Configure device to handle relative x and y axis. */
		if (ioctl(fd, UI_SET_RELBIT, REL_X) == -1)
		exit(3);
     
		if (ioctl(fd, UI_SET_RELBIT, REL_Y) == -1)
		exit(3);
	
	}
	else
	{/* Configure device to handle absolute x and y axis. */
		if (ioctl(fd, UI_SET_EVBIT, EV_ABS) == -1)
		exit(4);
		
		if (ioctl(fd, UI_SET_ABSBIT, ABS_X) == -1)
		exit(4);
		if (ioctl(fd, UI_SET_ABSBIT, ABS_Y) == -1)
        exit(4);
		if (ioctl(fd, UI_SET_ABSBIT, 0) == -1)
		exit(4);
	
		uidev.absmin[ABS_X] = -600;
		uidev.absmax[ABS_X] = 600;
		uidev.absfuzz[ABS_X] = 0;
		uidev.absflat[ABS_X] = 0;

		uidev.absmin[ABS_Y] = -400;
		uidev.absmax[ABS_Y] = 400;
		uidev.absfuzz[ABS_Y] = 0;
		uidev.absflat[ABS_Y] = 0;	
	}

    /* Configure device to handle all keys, see linux/input.h. */
    for (i = 0; i < KEY_MAX; i++) {
        if (ioctl(fd, UI_SET_KEYBIT, i) == -1)
            exit(11);
    }

    if(write(fd, &uidev, sizeof(uidev)) < 0)
        exit(10);
    
    if(ioctl(fd, UI_DEV_CREATE) < 0)
        exit(12);
    
    /*
  The reason for generating a small delay is that creating succesfully
  an uinput device does not guarantee that the device is ready to process
  input events. It's probably due the asynchronous nature of the udev.
  However, my experiments show that the device is not ready to process input
  events even after a device creation event is received from udev.
  */
    sleep(2);    return fd;
}

int suinput_press(int uinput_fd, uint16_t code)
{
    return suinput_write(uinput_fd, EV_KEY, code, 1);
}

int suinput_release(int uinput_fd, uint16_t code)
{
    return suinput_write_syn(uinput_fd, EV_KEY, code, 0);
}


int suinput_set_pointer(int uinput_fd, int32_t x, int32_t y)
{
    if (suinput_write(uinput_fd, EV_ABS, ABS_X, x))
        return -1;
    return suinput_write_syn(uinput_fd, EV_ABS, ABS_Y, y);
}

int suinput_click(int uinput_fd, uint16_t code)
{
    if (suinput_press(uinput_fd, code))
        return -1;
    return suinput_release(uinput_fd, code);
}

int suinput_close(int uinput_fd)
{
    /*
    Sleep before destroying the device because there still can be some
    unprocessed events. This is not the right way, but I am still
    looking for better ways. The question is: how to know whether there
    are any unprocessed uinput events?
   */
    //sleep(2);

    if (ioctl(uinput_fd, UI_DEV_DESTROY) == -1) {
        close(uinput_fd);
        return -1;
    }

    if (close(uinput_fd) == -1)
        return -1;

    return 0;
}


int main(void)
{
      
   int  fd;
   fd = suinput_open("/dev/uinput", 0); // 0 - absolute , 1 relative
      
      
   //suinput_move_pointer(fd, 130,130);
   suinput_set_pointer(fd, 60, 60);
   
   suinput_press(fd, 2);
   suinput_release(fd, 2);
   usleep(10000);
   suinput_click(fd,  BTN_LEFT);
   
   usleep(10000);
   
  // suinput_click(fd,  BTN_RIGHT);
   suinput_set_pointer(fd, -60, -60);
   usleep(10000);
   
   suinput_click(fd,  BTN_LEFT);
       
   suinput_press(fd, 3);
   suinput_press(fd, 5);
      
   suinput_close(fd);
  
   return 0;
}


Да се създаде виртуална мишка, която да се управлява чрез стрелките

Използвайте директен достъп до клавитурата:

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

int main()
{
    int fd;
    struct input_event ev;

    fd = open("/dev/input/event3", O_RDONLY);
    if(fd < 0) {
        printf("error openning");
        return 1;
    }
    
    
    while (1)
    {
    read(fd, &ev, sizeof(struct input_event));

    if(ev.type == 1)
        printf("key %i state %i\n", ev.code, ev.value);

    }
}


Връзки