EEPW论坛

  开发板上S2为用户按键，按下按键会引起中断，中断服务程序会产生事件，该事件通过EVDEV返回到用户程序。我们在获取输入设备的事件时往往通过/dev/input/eventx来获取，通过open read操作完成。 通过命令捕获按键状态

使用下面的命令获取按键对应的事件名

1. $ cat /proc/bus/input/devices
   
2. ...省略无关显示
   
3. I: Bus=0019 Vendor=0001 Product=0001 Version=0100
   
4. N: Name="gpio-keys"
   
5. P: Phys=gpio-keys/input0
   
6. S: Sysfs=/devices/platform/gpio-keys/input/input2
   
7. U: Uniq=
   
8. H: Handlers=kbd event2
   
9. B: PROP=0
   
10. B: EV=3
    
11. B: KEY=4

从最后一段可知Name="gpio-keys"对应的是Handlers=kbd event2
访问event2的设备结点捕获按键状态

1. $ cat /dev/input/event2 | hexdump -C
   
2. 00000000  78 77 09 59 68 2e 03 00  01 00 02 00 00 00 00 00  |xw.Yh...........|
   
3. 00000010  78 77 09 59 68 2e 03 00  00 00 00 00 00 00 00 00  |xw.Yh...........|
   
4. 00000020  78 77 09 59 ef b9 0b 00  01 00 02 00 01 00 00 00  |xw.Y............|
   
5. 00000030  78 77 09 59 ef b9 0b 00  00 00 00 00 00 00 00 00  |xw.Y............|

命令执行后处于等待状态，按下按键后将上报事件 中间两块为收到的数据，共有16列

• 第1列到第8列为事件发生的时间
• 第9第10列为 1 表示为按键事件
• 第13-16列为0表示按键按下， 为1表示按键释放
  

通过程序捕获按键状态
用Go来获取按键状态时,先打开/dev/input/event2文件，在阻塞读取数据，并通过Go的通信机制通知应用程序
代码分解 程序开启两个goroutine，一个用于读取按键事件，另一个模拟应用，用于事件处理

1.     const keyEventFile = "/dev/input/event2"
   
2.     k, err := os.Open(keyEventFile)

定义文件名为常量，并打开文件

1. data := make([]byte, 16)
   
2. _, err := k.Read(data)

复制代码 阻塞读取上报的数据

1. var et uint16
   
2. buf := bytes.NewReader(data[8:10])
   
3. err = binary.Read(buf, binary.LittleEndian, &et)

提取事件类型，bytes用于处理数组切片，binary包用于字节序列和数据之间的转化，binary.LittleEndian表示采用小端方式处理

1.     if et == evKey {
   
2.         buf = bytes.NewReader(data[12:])
   
3.         err = binary.Read(buf, binary.LittleEndian, &value)
   
4.     }

如果事件类型为按键事件，继续读取4个字节数据，该数据表示是按下或释放按键

1.     ch := make(chan uint32)
   
2.     ch <- value

将收到的数据传递给应用程序，这里利用了Go提供的Channel通信机制, Channel是goroutine之间进行通信的一种方式

程序验证 交叉编译并在开发板上运行

• 按下按键后，控制台输出"Key Pressed"
• 释放按键后，控制台输出"Key released"。
  

完整代码

1. package main
   
2. 
   
3. import (
   
4.     "bytes"
   
5.     "encoding/binary"
   
6.     "fmt"
   
7.     "os"
   
8. )
   
9. 
   
10. const keyEventFile = "/dev/input/event2"
    
11. const evKey = 1
    
12. 
    
13. func main() {
    
14.     k, err := os.Open(keyEventFile)
    
15.     check(err)
    
16.     defer k.Close()
    
17.     ch := make(chan uint32)
    
18.     go func() {
    
19.         data := make([]byte, 16)
    
20.         for {
    
21.             _, err := k.Read(data)
    
22.             check(err)
    
23.             var et uint16
    
24.             buf := bytes.NewReader(data[8:10])
    
25.             err = binary.Read(buf, binary.LittleEndian, &et)
    
26.             check(err)
    
27.             var value uint32
    
28.             if et == evKey {
    
29.                 buf = bytes.NewReader(data[12:])
    
30.                 err = binary.Read(buf, binary.LittleEndian, &value)
    
31.                 check(err)
    
32.                 ch <- value
    
33.             }
    
34.         }
    
35.     }()
    
36. 
    
37.     go func() {
    
38.         for {
    
39.             value := <-ch
    
40.             if value == 0 {
    
41.                 fmt.Println("Key pressed")
    
42.             } else if value == 1 {
    
43.                 fmt.Println("Key released")
    
44.             }
    
45.         }
    
46.     }()
    
47. 
    
48.     fmt.Println("Press enter key to exit")
    
49.     var b [1]byte
    
50.     os.Stdin.Read(b[:])
    
51. }
    
52. 
    
53. func check(err error) {
    
54.     if err != nil {
    
55.         panic(err)
    
56.     }
    
57. }