linux下如何模拟按键输入和模拟鼠标

迷南。 2024-02-17 17:07 67阅读 0赞

原地址：http://blog.chinaunix.net/uid-23381466-id-3883164.html  
  
  
[driver: linux下如何模拟按键输入和模拟鼠标][driver_ linux] *2013-09-04 09:02:18*

分类： LINUX

**概述：**  
查看/dev/input/eventX是什么类型的事件， cat /proc/bus/input/devices  
  
设备有着自己特殊的按键键码，我需要将一些标准的按键，比如0－9，X－Z等模拟成标准按键，比如KEY\_0,KEY-Z等，所以需要用到按键模拟，具体方法就是操作/dev/input/event1文件，向它写入个input\_event结构体就可以模拟按键的输入了。  
  
**input\_event 说明：**  
linux/input.h中有定义，这个文件还定义了标准按键的编码等

点击(此处)折叠或打开

1.  struct input\_event \{   
    
2.    
    
3.  struct timeval time; //按键时间  
    
4.    
    
5.  \_\_u16 type; //类型，在下面有定义  
    
6.    
    
7.  \_\_u16 code; //要模拟成什么按键  
    
8.    
    
9.  \_\_s32 value;//是按下还是释放  
    
10.   
    
11. \};

**code：**  
事件的代码.如果事件的类型代码是EV\_KEY,该代码code为设备键盘代码.代码植0~127为键盘上的按键代码,0x110~0x116 为鼠标上按键代码,其中0x110(BTN\_LEFT)为鼠标左键,0x111(BTN\_RIGHT)为鼠标右键,0x112(BTN\_ MIDDLE)为鼠标中键.其它代码含义请参看include/linux/input.h文件. 如果事件的类型代码是EV\_REL,code值表示轨迹的类型.如指示鼠标的X轴方向REL\_X(代码为0x00),指示鼠标的Y轴方向REL\_Y(代码为0x01),指示鼠标中轮子方向REL\_WHEEL(代码为0x08).  
  
**type:**   
EV\_KEY,键盘  
EV\_REL,相对坐标  
EV\_ABS,绝对坐标  
  
**value：**  
事件的值.如果事件的类型代码是EV\_KEY,当按键按下时值为1,松开时值为0; 如果事件的类型代码是EV\_ REL,value的正数值和负数值分别代表两个不同方向的值.  
  
/\*  
\* Eventtypes  
\*/  
\#defineEV\_SYN 0x00  
\#define EV\_KEY 0x01 //按键  
\#defineEV\_REL 0x02 //相对坐标(轨迹球)  
\#defineEV\_ABS 0x03 //绝对坐标  
\#defineEV\_MSC 0x04 //其他  
\#defineEV\_SW 0x05  
\#defineEV\_LED 0x11 //LED  
\#define EV\_SND0x12//声音  
\#defineEV\_REP 0x14//repeat  
\#defineEV\_FF 0x15   
\#defineEV\_PWR 0x16  
\#define EV\_FF\_STATUS 0x17  
\#define EV\_MAX 0x1f  
\#define EV\_CNT (EV\_MAX+1)  
  
**kernel里input模****块**

点击(此处)折叠或打开

1.  //input\_dev结构:  
    
2.  struct input\_dev  
    
3.  \{   
    
4.  void \*private;  
    
5.    
    
6.  const char \*name;  
    
7.  const char \*phys;  
    
8.  const char \*uniq;  
    
9.  struct input\_id id;  
    
10.   
    
11. /\*  
    
12. \* 根据各种输入信号的类型来建立类型为unsigned long 的数组,  
    
13. \* 数组的每1bit代表一种信号类型,  
    
14. \* 内核中会对其进行置位或清位操作来表示时间的发生和被处理.  
    
15. \*/  
    
16.   
    
17. unsigned long evbit\[NBITS(EV\_MAX)\];  
    
18. unsigned long keybit\[NBITS(KEY\_MAX)\];  
    
19. unsigned long relbit\[NBITS(REL\_MAX)\];  
    
20. unsigned long absbit\[NBITS(ABS\_MAX)\];  
    
21. unsigned long mscbit\[NBITS(MSC\_MAX)\];  
    
22. unsigned long ledbit\[NBITS(LED\_MAX)\];  
    
23. unsigned long sndbit\[NBITS(SND\_MAX)\];  
    
24. unsigned long ffbit\[NBITS(FF\_MAX)\];  
    
25. unsigned long swbit\[NBITS(SW\_MAX)\];  
    
26.   
    
27. .........................................  
    
28. \};  
    
29.   
    
30. /\*\*  
    
31. \* input\_set\_capability \- mark device as capable of a certain event  
    
32. \* @dev: device that is capable of emitting or accepting event  
    
33. \* @type: type of the event (EV\_KEY, EV\_REL, etc...)  
    
34. \* @code: event code  
    
35. \*  
    
36. \* In addition to setting up corresponding bit in appropriate capability  
    
37. \* bitmap the function also adjusts dev\->evbit.  
    
38. \*/  
    
39.   
    
40. /\* 记录本设备对于哪些事件感兴趣(对其进行处理)\*/  
    
41. void input\_set\_capability(struct input\_dev \*dev, unsigned int type, unsigned int code)  
    
42. \{   
    
43. switch (type)  
    
44. \{   
    
45. case EV\_KEY:  
    
46. \_\_set\_bit(code, dev\->keybit);//比如按键,应该对哪些键值的按键进行处理(对于其它按键不予理睬)  
    
47. break;  
    
48.   
    
49. case EV\_REL:  
    
50. \_\_set\_bit(code, dev\->relbit);  
    
51. break;  
    
52.   
    
53. case EV\_ABS:  
    
54. \_\_set\_bit(code, dev\->absbit);  
    
55. break;  
    
56.   
    
57. case EV\_MSC:  
    
58. \_\_set\_bit(code, dev\->mscbit);  
    
59. break;  
    
60.   
    
61. case EV\_SW:  
    
62. \_\_set\_bit(code, dev\->swbit);  
    
63. break;  
    
64.   
    
65. case EV\_LED:  
    
66. \_\_set\_bit(code, dev\->ledbit);  
    
67. break;  
    
68.   
    
69. case EV\_SND:  
    
70. \_\_set\_bit(code, dev\->sndbit);  
    
71. break;  
    
72.   
    
73. case EV\_FF:  
    
74. \_\_set\_bit(code, dev\->ffbit);  
    
75. break;  
    
76.   
    
77. default:  
    
78. printk(KERN\_ERR  
    
79. "input\_set\_capability: unknown type %u (code %u)\\n",  
    
80. type, code);  
    
81. dump\_stack();  
    
82. return;  
    
83. \}  
    
84.   
    
85. \_\_set\_bit(type, dev\->evbit);//感觉和前面重复了(前面一经配置过一次了)  
    
86. \}  
    
87. EXPORT\_SYMBOL(input\_set\_capability);  
    
88.   
    
89. static irqreturn\_t gpio\_keys\_isr(int irq, void \*dev\_id)  
    
90. \{   
    
91. int i;  
    
92. struct platform\_device \*pdev = dev\_id;  
    
93. struct gpio\_keys\_platform\_data \*pdata = pdev\->dev.platform\_data;  
    
94. struct input\_dev \*input = platform\_get\_drvdata(pdev);  
    
95.   
    
96. for (i = 0; i < pdata\->nbuttons; i\+\+)  
    
97. \{   
    
98. struct gpio\_keys\_button \*button = &pdata\->buttons\[i\];  
    
99. int gpio = button\->gpio;  
    
100.   
    
101. if (irq == gpio\_to\_irq(gpio)) //判断哪个键被按了?  
    
102. \{   
    
103. unsigned int type = button\->type ? : EV\_KEY;  
    
104. int state = (gpio\_get\_value(gpio) ? 1 : 0) ^ button\->active\_low;//记录按键状态  
    
105.   
    
106. input\_event(input, type, button\->code, !!state);//汇报输入事件  
    
107. input\_sync(input);//等待输入事件处理完成  
    
108. \}  
    
109. \}  
    
110.   
    
111. return IRQ\_HANDLED;  
    
112. \}  
    
113.   
    
114.   
    
115. /\*  
    
116. \* input\_event() \- report new input event  
    
117. \* @dev: device that generated the event  
    
118. \* @type: type of the event  
    
119. \* @code: event code  
    
120. \* @value: value of the event  
    
121. \*  
    
122. \* This function should be used by drivers implementing various input devices  
    
123. \* See also input\_inject\_event()  
    
124. \*/  
    
125. void input\_event(struct input\_dev \*dev, unsigned int type, unsigned int code, int value)  
    
126. \{   
    
127. struct input\_handle \*handle;  
    
128.   
    
129. if (type > EV\_MAX || !test\_bit(type, dev\->evbit))//首先判断该事件类型是否有效且为该设备所接受  
    
130. return;  
    
131.   
    
132. add\_input\_randomness(type, code, value);  
    
133.   
    
134. switch (type)  
    
135. \{   
    
136.   
    
137. case EV\_SYN:  
    
138. switch (code)  
    
139. \{   
    
140. case SYN\_CONFIG:  
    
141. if (dev\->event)  
    
142. dev\->event(dev, type, code, value);  
    
143. break;  
    
144.   
    
145. case SYN\_REPORT:  
    
146. if (dev\->sync)  
    
147. return;  
    
148. dev\->sync = 1;  
    
149. break;  
    
150. \}  
    
151. break;  
    
152.   
    
153. case EV\_KEY:  
    
154. /\*  
    
155. \* 这里需要满足几个条件:  
    
156. \* 1: 键值有效(不超出定义的键值的有效范围)  
    
157. \* 2: 键值为设备所能接受(属于该设备所拥有的键值范围)  
    
158. \* 3: 按键状态改变了  
    
159. \*/  
    
160.   
    
161. if (code > KEY\_MAX || !test\_bit(code, dev\->keybit) || !!test\_bit(code, dev\->key) == value)  
    
162. return;  
    
163.   
    
164. if (value == 2)  
    
165. break;  
    
166.   
    
167. change\_bit(code, dev\->key);//改变对应按键的状态  
    
168.   
    
169. /\* 如果你希望按键未释放的时候不断汇报按键事件的话需要以下这个(在简单的gpio\_keys驱动中不需要这个,暂时不去分析) \*/  
    
170. if (test\_bit(EV\_REP, dev\->evbit) && dev\->rep\[REP\_PERIOD\] && dev\->rep\[REP\_DELAY\] && dev\->timer.data && value)  
    
171. \{   
    
172. dev\->repeat\_key = code;  
    
173. mod\_timer(&dev\->timer, jiffies \+ msecs\_to\_jiffies(dev\->rep\[REP\_DELAY\]));  
    
174. \}  
    
175.   
    
176. break;  
    
177. ........................................................  
    
178.   
    
179. if (type != EV\_SYN)  
    
180. dev\->sync = 0;  
    
181.   
    
182. if (dev\->grab)  
    
183. dev\->grab\->handler\->event(dev\->grab, type, code, value);  
    
184. else  
    
185. /\*  
    
186. \* 循环调用所有处理该设备的handle(event,mouse,ts,joy等),  
    
187. \* 如果有进程打开了这些handle(进行读写),则调用其对应的event接口向气汇报该输入事件.  
    
188. \*/  
    
189. list\_for\_each\_entry(handle, &dev\->h\_list, d\_node)  
    
190. if (handle\->open)  
    
191. handle\->handler\->event(handle, type, code, value);  
    
192. \}  
    
193. \}  
    
194. EXPORT\_SYMBOL(input\_event);  
    
195.   
    
196.   
    
197. //event层对于input层报告的这个键盘输入事件的处理:  
    
198. //drivers / input / evdev.c:  
    
199.   
    
200. static struct input\_handler evdev\_handler =  
    
201. \{   
    
202. .event = evdev\_event,  
    
203. .connect = evdev\_connect,  
    
204. .disconnect = evdev\_disconnect,  
    
205. .fops = &evdev\_fops,  
    
206. .minor = EVDEV\_MINOR\_BASE,  
    
207. .name = "evdev",  
    
208. .id\_table = evdev\_ids,  
    
209. \};

Linux 有自己的 input 子系统，可以统一管理鼠标和键盘事件。基于输入子系统 实现的 uinput 可以方便的在用户空间模拟鼠标和键盘事件。  
当然，也可以自己造轮子， 做一个字符设备接收用户输入，根据输入，投递 input 事件。  
还有一种方式就是直接 往 evnent 里写入数据， 都可以达到控制鼠标键盘的功能。

本篇文章就是演示直接写入 event 的方法。

**1。模拟按键输****入**

点击(此处)折叠或打开

1.  //其中0表示释放，1按键按下，2表示一直按下  
    
2.  //0  for EV\_KEY for release, 1 for keypress and 2 for autorepeat.  
    
3.    
    
4.  void simulate\_key(int fd, int value)  
    
5.  \{   
    
6.  struct input\_event event;  
    
7.  event.type  = EV\_KEY;  
    
8.  //event.code = KEY\_0;//要模拟成什么按键  
    
9.  event.value  = value;//是按下还是释放按键或者重复  
    
10. gettimeofday(&event.time, 0);  
    
11. if(write(fd, &event, sizeof(event)) < 0)  
    
12. \{   
    
13. dprintk("simulate key error~~~\\n");  
    
14. return ;  
    
15. \}  
    
16. \}

**2。模拟鼠标输入（轨迹球****）**

点击(此处)折叠或打开

1.  void simulate\_mouse(int fd, char buf\[4\])  
    
2.  \{   
    
3.  int rel\_x, rel\_y;  
    
4.  static struct input\_event event, ev;  
    
5.    
    
6.  //buf\[0\],buf\[2\],小于0则为左移，大于0则为右移  
    
7.  //buf\[1\],buf\[3\],小于0则为下移，大于0则为上移  
    
8.    
    
9.  dprintk("MOUSE TOUCH: x1=%d,y1=%d,x2=%d,y2=%d\\n", buf\[0\], buf\[1\], buf\[2\], buf\[3\]);  
    
10. rel\_x = (buf\[0\] \+ buf\[2\]) / 2;  
    
11. rel\_y = \-(buf\[1\] \+ buf\[3\]) / 2;  //和我们的鼠标是相反的方向，所以取反  
    
12. event.type  = EV\_REL;  
    
13. event.code  = REL\_X;  
    
14. event.value  = rel\_x;  
    
15. gettimeofday(&event.time, 0);  
    
16. if( write(fd, &event, sizeof(event)) != sizeof(event))  
    
17. dprintk("rel\_x error~~~:%s\\n", strerror(errno));  
    
18. event.code  = REL\_Y;  
    
19. event.value  = rel\_y;  
    
20. gettimeofday(&event.time, 0);  
    
21. if( write(fd, &event, sizeof(event)) != sizeof(event))  
    
22. dprintk("rel\_y error~~~:%s\\n", strerror(errno));  
    
23.   
    
24. //一定要刷新空的  
    
25. write(fd, &ev, sizeof(ev));  
    
26. \}

**鼠标和键盘文件打开方法：**

点击(此处)折叠或打开

1.  int fd\_kbd; //  /dev/input/event1  
    
2.  int fd\_mouse; //dev/input/mouse2  
    
3.    
    
4.  fd\_kbd = open("/dev/input/event1", O\_RDWR);  
    
5.    
    
6.  if(fd\_kbd <= 0)  
    
7.  \{   
    
8.  printf("error open keyboard:%s\\n", strerror(errno));  
    
9.  return \-1;  
    
10. \}  
    
11.   
    
12. fd\_mouse = open("/dev/input/event3", O\_RDWR); //如果不行的话，那试试/dev/input/mice  
    
13. if(fd\_mouse <= 0)  
    
14. \{   
    
15. printf("error open mouse:%s\\n", strerror(errno));  
    
16. return \-2;  
    
17. \}

/dev/input/mice是鼠标的抽象，代表的是鼠标，也许是/dev/input/mouse,/dev/input/mouse1，或者空， 这个文件一直会存在。 这里你也许会问，我怎么知道/dev/input/eventX这些事件到底是什么事件阿，是鼠标还是键盘或者别的， eventX代表的是所有输入设备(input核心)的事件，比如按键按下，或者鼠标移动，或者游戏遥控器等等， 在系统查看的方法是 cat /proc/bus/input/devices 就可以看到每个eventX是什么设备的事件了。

**下面是一个模拟鼠标和键盘输入的例子****：**  
**关于这里 open 哪个 event ， 可以通过 cat /proc/bus/input/devices**

点击(此处)折叠或打开

1.  \#include <string.h>  
    
2.  \#include <stdio.h>  
    
3.  \#include <sys/types.h>  
    
4.  \#include <sys/stat.h>  
    
5.  \#include <fcntl.h>  
    
6.  \#include <linux/input.h>  
    
7.  \#include <linux/uinput.h>  
    
8.  \#include <stdio.h>  
    
9.  \#include <sys/time.h>  
    
10. \#include <sys/types.h>  
    
11. \#include <unistd.h>  
    
12.   
    
13. void simulate\_key(int fd, int kval)  
    
14. \{   
    
15. struct input\_event event;  
    
16. event.type  = EV\_KEY;  
    
17. event.value  = 1;  
    
18. event.code  = kval;  
    
19. gettimeofday(&event.time, 0);  
    
20. write(fd, &event, sizeof(event)) ;  
    
21. event.type  = EV\_SYN;  
    
22. event.code  = SYN\_REPORT;  
    
23. event.value  = 0;  
    
24. write(fd, &event, sizeof(event));  
    
25.   
    
26. memset(&event, 0, sizeof(event));  
    
27. gettimeofday(&event.time, NULL);  
    
28. event.type  = EV\_KEY;  
    
29. event.code  = kval;  
    
30. event.value  = 0;  
    
31. write(fd, &event, sizeof(event));  
    
32. event.type  = EV\_SYN;  
    
33. event.code  = SYN\_REPORT;  
    
34. event.value  = 0;  
    
35. write(fd, &event, sizeof(event));  
    
36. \}  
    
37.   
    
38. void simulate\_mouse(int fd)  
    
39. \{   
    
40. struct input\_event event;  
    
41. memset(&event, 0, sizeof(event));  
    
42. gettimeofday(&event.time, NULL);  
    
43. event.type  = EV\_REL;  
    
44. event.code  = REL\_X;  
    
45. event.value  = 10;  
    
46. write(fd, &event, sizeof(event));  
    
47. event.type  = EV\_REL;  
    
48. event.code  = REL\_Y;  
    
49. event.value  = 10;  
    
50. write(fd, &event, sizeof(event));  
    
51. event.type  = EV\_SYN;  
    
52. event.code  = SYN\_REPORT;  
    
53. event.value  = 0;  
    
54. write(fd, &event, sizeof(event));  
    
55. \}  
    
56.   
    
57. int main()  
    
58. \{   
    
59. int fd\_kbd;  
    
60. int fd\_mouse;  
    
61. fd\_kbd = open("/dev/input/event1", O\_RDWR);  
    
62. if(fd\_kbd <= 0)  
    
63. \{   
    
64. printf("error open keyboard:\\n");  
    
65. return \-1;  
    
66. \}  
    
67. fd\_mouse = open("/dev/input/event2", O\_RDWR);  
    
68. if(fd\_mouse <= 0)  
    
69. \{   
    
70. printf("error open mouse\\n");  
    
71. return \-2;  
    
72. \}  
    
73. int i = 0;  
    
74. for(i = 0; i  < 10; i\+\+)  
    
75. \{   
    
76. simulate\_key(fd\_kbd, KEY\_A \+ i);  
    
77. simulate\_mouse(fd\_mouse);  
    
78. sleep(1);  
    
79. \}  
    
80. close(fd\_kbd);  
    
81. \}

**下面是一个读取 鼠标和键盘事件的例子****：**

点击(此处)折叠或打开

1.  \#include <stdio.h>  
    
2.  \#include <stdlib.h>  
    
3.  \#include <linux/input.h>  
    
4.  \#include <sys/types.h>  
    
5.  \#include <sys/stat.h>  
    
6.  \#include <fcntl.h>  
    
7.  \#include <unistd.h>  
    
8.  \#include <errno.h>  
    
9.    
    
10. static void show\_event(struct input\_event\* event)  
    
11. \{   
    
12. printf("%d %d %d\\n", event\->type, event\->code, event\->value);  
    
13. return;  
    
14. \}  
    
15.   
    
16. int main(int argc, char\* argv\[\])  
    
17. \{   
    
18. struct input\_event event =  \{ \{ 0\}, 0\};  
    
19. const char\* file\_name = argc == 2 ? argv\[1\] : "/dev/input/event2";  
    
20. int fd = open(file\_name, O\_RDWR);  
    
21.   
    
22. if(fd > 0)  
    
23. \{   
    
24. while(1)  
    
25. \{   
    
26. int ret  = read(fd, &event, sizeof(event));  
    
27. if(ret == sizeof(event))  
    
28. \{   
    
29. show\_event(&event);  
    
30. \}  
    
31. else  
    
32. \{   
    
33. break;  
    
34. \}  
    
35. \}  
    
36. close(fd);  
    
37. \}  
    
38. return 0;  
    
39. \}

**很多人对于 如何模拟 CTRL + SPACE 感兴趣， 下面也给个例子，呵呵****。**

点击(此处)折叠或打开

1.  void simulate\_ctrl\_space(int fd)  
    
2.  \{   
    
3.  struct input\_event event;  
    
4.  //先发送一个 CTRL 按下去的事件。  
    
5.  event.type  = EV\_KEY;  
    
6.  event.value  = 1;  
    
7.  event.code  = KEY\_LEFTCTRL;  
    
8.  gettimeofday(&event.time, 0);  
    
9.  write(fd, &event, sizeof(event)) ;  
    
10. event.type  = EV\_SYN;  
    
11. event.code  = SYN\_REPORT;  
    
12. event.value  = 0;  
    
13. write(fd, &event, sizeof(event));  
    
14. //先发送一个 SPACE 按下去的事件。  
    
15. event.type  = EV\_KEY;  
    
16. event.value  = 1;  
    
17. event.code  = KEY\_SPACE;  
    
18. gettimeofday(&event.time, 0);  
    
19. write(fd, &event, sizeof(event)) ;  
    
20. //发送一个 释放 SPACE 的事件  
    
21. memset(&event, 0, sizeof(event));  
    
22. gettimeofday(&event.time, NULL);  
    
23. event.type  = EV\_KEY;  
    
24. event.code  = KEY\_SPACE;  
    
25. event.value  = 0;  
    
26. write(fd, &event, sizeof(event));  
    
27. event.type  = EV\_SYN;  
    
28. event.code  = SYN\_REPORT;  
    
29. event.value  = 0;  
    
30. write(fd, &event, sizeof(event));  
    
31.   
    
32. //发送一个 释放 CTRL 的事件  
    
33. memset(&event, 0, sizeof(event));  
    
34. gettimeofday(&event.time, NULL);  
    
35. event.type  = EV\_KEY;  
    
36. event.code  = KEY\_LEFTCTRL;  
    
37. event.value  = 0;  
    
38. write(fd, &event, sizeof(event));  
    
39.   
    
40. event.type  = EV\_SYN;  
    
41. event.code  = SYN\_REPORT;  
    
42. event.value  = 0;  
    
43. write(fd, &event, sizeof(event));  
    
44. \}

**浅析****linux****中鼠标数据读取**

点击(此处)折叠或打开

1.  //我们就是去读/dev/input/mice设备节点,源码如下：  
    
2.  \#include <stdio.h>  
    
3.  \#include <errno.h>  
    
4.  \#include <fcntl.h>  
    
5.  \#include <sys/select.h>  
    
6.  \#include <string.h>  
    
7.    
    
8.  /\* Mouse button bits\*/  
    
9.  \#define WHEEL\_UP 0x10  
    
10. \#define WHEEL\_DOWN 0x08  
    
11.   
    
12. \#define BUTTON\_L 0x04  
    
13. \#define BUTTON\_M 0x02  
    
14. \#define BUTTON\_R 0x01  
    
15. \#define SCALE 3 /\* default scaling factor for acceleration \*/  
    
16. \#define THRESH 5 /\* default threshhold for acceleration \*/  
    
17.   
    
18. static int xpos; /\* current x position of mouse \*/  
    
19. static int ypos; /\* current y position of mouse \*/  
    
20. static int minx; /\* minimum allowed x position \*/  
    
21. static int maxx; /\* maximum allowed x position \*/  
    
22. static int miny; /\* minimum allowed y position \*/  
    
23. static int maxy; /\* maximum allowed y position \*/  
    
24. static int buttons; /\* current state of buttons \*/  
    
25. static int scale  = SCALE; /\* acceleration scale factor \*/  
    
26. static int thresh  = THRESH;/\* acceleration threshhold \*/  
    
27.   
    
28. static int mouse\_update(int dx, int dy,  int dz);  
    
29. static int IMPS2\_Read  (int \*dx, int \*dy, int \*dz, int \*bp);  
    
30. static void mouse\_setposition (int newx, int newy);  
    
31. static void mouse\_setrange (int newminx, int newminy, int newmaxx, int newmaxy);  
    
32.   
    
33. int mouse\_fd;  
    
34.   
    
35. int main(void)  
    
36. \{   
    
37. int dx, dy, dz;  
    
38. static unsigned char imps2\_param \[\] = \{ 243, 200, 243, 100, 243, 80\};  //,242\};  
    
39. // 来自vnc4的xc/programs/Xserver/hw/xfree86/input/mouse/mouse.c==>PROT\_IMPS2  
    
40. const char  \*mdev = "/dev/input/mice";  
    
41.   
    
42. mouse\_fd = open  (mdev, O\_RDWR); //  | O\_NONBLOCK);  
    
43. if (mouse\_fd < 0)  
    
44. \{   
    
45. printf("\[luther.gliethttp\]: RW error \[please use root user\]: %s\\n", mdev);  
    
46. mouse\_fd = open  (mdev, O\_RDONLY); //  | O\_NONBLOCK);  
    
47. if (mouse\_fd < 0)  
    
48. return \-1;  
    
49. \}  
    
50. else  
    
51. \{   
    
52. write (mouse\_fd, imps2\_param, sizeof (imps2\_param)); // 初始化序列, 这样可以读取4个字节数据  
    
53. // 0x80用来表示滚轮向上还是向下滚动  
    
54. // 0xa0表示滚轮向上滚动的同时中键按下  
    
55. printf("\[luther.gliethttp\]: imps2\_param ok!\\n");  
    
56. \}  
    
57.   
    
58. mouse\_setrange(0, 0, 1024, 768);  
    
59.   
    
60. for (;;)  
    
61. \{   
    
62. IMPS2\_Read(&dx, &dy,  &dz, &buttons);  
    
63. mouse\_update(dx, dy, dz);  
    
64. mouse\_setposition(xpos, ypos);  
    
65. printf("\[%04d,%04d,0x%04x\]\\n", xpos, ypos, buttons);  
    
66. \}  
    
67.   
    
68. return 0;  
    
69. \}  
    
70.   
    
71. static int IMPS2\_Read  (int \*dx, int \*dy, int \*dz, int \*bp)  
    
72. \{   
    
73. static unsigned char buf\[5\];  
    
74. static int buttons\[7\] = \{  0, 1, 3, 0, 2, 0, 0\}; // 1左键,2中键,3右键  
    
75. static int nbytes;  
    
76. int n;  
    
77.   
    
78. while ((n = read (mouse\_fd, &buf \[nbytes\], 4 \- nbytes)))  
    
79. \{   
    
80. if (n < 0)  
    
81. \{   
    
82. if  (errno == EINTR)  
    
83. continue;  
    
84. else  
    
85. return \-1;  
    
86. \}  
    
87.   
    
88. nbytes \+= n;  
    
89.   
    
90. if (nbytes == 4)  
    
91. \{   
    
92. int wheel;  
    
93. // printf("\[luther.gliethttp\]: %02x %02x %02x %02x\\n", buf\[0\], buf\[1\], buf\[2\], buf\[3\]);  
    
94. if  ((buf\[0\] & 0xc0)  != 0)  
    
95. \{   
    
96. buf\[0\] = buf\[1\];  
    
97. buf\[1\] = buf\[2\];  
    
98. buf\[2\] = buf\[3\];  
    
99. nbytes = 3;  
    
100. return \-1;  
    
101. \}  
    
102.   
    
103. /\* FORM XFree86 4.0.1 \*/  
    
104. \*bp  = buttons\[(buf\[0\] & 0x07)\];  
    
105. \*dx  = (buf\[0\] & 0x10)  ? buf\[1\] \- 256 : buf\[1\];  
    
106. \*dy  = (buf\[0\] & 0x20)  ? \-(buf\[2\] \- 256)  : \-buf\[2\];  
    
107.   
    
108. /\* Is a wheel event? \*/  
    
109. if  ((wheel = buf\[3\]) != 0)  
    
110. \{   
    
111. if(wheel > 0x7f)  
    
112. \{   
    
113. \*bp  |= WHEEL\_UP;  
    
114. \}  
    
115. else  
    
116. \{   
    
117. \*bp  |= WHEEL\_DOWN;  
    
118. \}  
    
119. \}  
    
120.   
    
121. \*dz  = 0;  
    
122. nbytes = 0;  
    
123. return 1;  
    
124. \}  
    
125. \}  
    
126. return 0;  
    
127. \}  
    
128.   
    
129. static int mouse\_update(int dx, int dy,  int dz)  
    
130. \{   
    
131. int r;  
    
132. int sign;  
    
133.   
    
134. sign = 1;  
    
135. if (dx < 0)  
    
136. \{   
    
137. sign =  \-1;  
    
138. dx = \-dx;  
    
139. \}  
    
140. if (dx > thresh)  
    
141. dx = thresh  \+ (dx \- thresh) \* scale;  
    
142. dx \*= sign;  
    
143. xpos \+= dx;  
    
144. if( xpos < minx )  
    
145. xpos = minx;  
    
146. if( xpos > maxx )  
    
147. xpos = maxx;  
    
148.   
    
149. sign = 1;  
    
150. if (dy < 0)  
    
151. \{   
    
152. sign =  \-1;  
    
153. dy = \-dy;  
    
154. \}  
    
155. if (dy > thresh)  
    
156. dy = thresh  \+ (dy \- thresh) \* scale;  
    
157. dy \*= sign;  
    
158. ypos \+= dy;  
    
159. if ( ypos < miny )  
    
160. ypos = miny;  
    
161. if ( ypos > maxy )  
    
162. ypos = maxy;  
    
163.   
    
164. return 1;  
    
165. \}  
    
166.   
    
167. static void mouse\_setposition (int newx, int newy)  
    
168. \{   
    
169. if (newx < minx)  
    
170. newx = minx;  
    
171. if (newx > maxx)  
    
172. newx = maxx;  
    
173. if (newy < miny)  
    
174. newy = miny;  
    
175. if (newy > maxy)  
    
176. newy = maxy;  
    
177. if (newx == xpos  && newy == ypos)  
    
178. return;  
    
179. xpos = newx;  
    
180. ypos = newy;  
    
181. \}  
    
182.   
    
183. static void mouse\_setrange (int newminx, int newminy, int newmaxx, int newmaxy)  
    
184. \{   
    
185. minx = newminx;  
    
186. miny = newminy;  
    
187. maxx = newmaxx;  
    
188. maxy = newmaxy;  
    
189. mouse\_setposition ((newminx \+ newmaxx)  / 2, (newminy \+ newmaxy)  / 2);  
    
190. \}  
    
191.   
    
192. static int mouse\_getbutton  (void)  
    
193. \{   
    
194. return buttons;  
    
195. \}  
    
196.   
    
197. static void mouse\_getxy (int\* x, int\* y)  
    
198. \{   
    
199. \*x = xpos;  
    
200. \*y = ypos;  
    
201. \}

[driver_ linux]: http://blog.chinaunix.net/uid-23381466-id-3883164.html