gamepad.go 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266
  1. package gamepad
  2. import (
  3. "fmt"
  4. "log"
  5. "github.com/gvalkov/golang-evdev"
  6. )
  7. // event types
  8. const (
  9. Button = iota
  10. AxisX
  11. AxisY
  12. AxisZ
  13. )
  14. type Event struct {
  15. Type int
  16. Value int32
  17. }
  18. func (e Event) IsAxis() bool {
  19. switch e.Type {
  20. case AxisX, AxisY, AxisZ:
  21. return true
  22. default:
  23. return false
  24. }
  25. }
  26. func (e Event) IsAxisX() bool {
  27. return e.Type == AxisX
  28. }
  29. func (e Event) IsAxisY() bool {
  30. return e.Type == AxisY
  31. }
  32. func (e Event) IsAxisZ() bool {
  33. return e.Type == AxisZ
  34. }
  35. func (e Event) IsButton() bool {
  36. return e.Type == Button
  37. }
  38. func (e Event) IsButtonPress() bool {
  39. if e.IsButton() && e.Value > 0 {
  40. return true
  41. }
  42. return false
  43. }
  44. func (e Event) String() string {
  45. var code string
  46. switch e.Type {
  47. case Button:
  48. code = "button"
  49. case AxisX:
  50. code = "X"
  51. case AxisY:
  52. code = "Y"
  53. case AxisZ:
  54. code = "Z"
  55. }
  56. return fmt.Sprintf("%v %v", code, e.Value)
  57. }
  58. // Logitech gamepad button channels
  59. const (
  60. LeftAnalog = 0x001
  61. RightAnalog = 0x002
  62. DPad = 0x004
  63. A = 0x008
  64. B = 0x010
  65. X = 0x020
  66. Y = 0x040
  67. Left = 0x080
  68. Right = 0x100
  69. Back = 0x200
  70. Start = 0x400
  71. Logitech = 0x800
  72. All = 0xfff
  73. )
  74. const channelBufferSize = 16
  75. type Gamepad struct {
  76. channels int16
  77. device *evdev.InputDevice
  78. LeftAnalog, RightAnalog, DPad chan Event
  79. A, B, X, Y chan Event
  80. Left, Right chan Event
  81. Back, Start, Logitech chan Event
  82. }
  83. func NewGamepad(device string, channels int16) (*Gamepad, error) {
  84. g := &Gamepad{channels: channels}
  85. if !evdev.IsInputDevice(device) {
  86. return nil, fmt.Errorf("%v is not an input device", device)
  87. }
  88. var err error
  89. g.device, err = evdev.Open(device)
  90. if err != nil {
  91. return nil, err
  92. }
  93. if channels&LeftAnalog != 0 {
  94. g.LeftAnalog = make(chan Event, channelBufferSize)
  95. }
  96. if channels&RightAnalog != 0 {
  97. g.RightAnalog = make(chan Event, channelBufferSize)
  98. }
  99. if channels&DPad != 0 {
  100. g.DPad = make(chan Event, channelBufferSize)
  101. }
  102. if channels&A != 0 {
  103. g.A = make(chan Event, channelBufferSize)
  104. }
  105. if channels&B != 0 {
  106. g.B = make(chan Event, channelBufferSize)
  107. }
  108. if channels&X != 0 {
  109. g.X = make(chan Event, channelBufferSize)
  110. }
  111. if channels&Y != 0 {
  112. g.Y = make(chan Event, channelBufferSize)
  113. }
  114. if channels&Left != 0 {
  115. g.Left = make(chan Event, channelBufferSize)
  116. }
  117. if channels&Right != 0 {
  118. g.Right = make(chan Event, channelBufferSize)
  119. }
  120. if channels&Back != 0 {
  121. g.Back = make(chan Event, channelBufferSize)
  122. }
  123. if channels&Start != 0 {
  124. g.Start = make(chan Event, channelBufferSize)
  125. }
  126. if channels&Logitech != 0 {
  127. g.Logitech = make(chan Event, channelBufferSize)
  128. }
  129. return g, nil
  130. }
  131. // Logitech gamepad codes
  132. const (
  133. leftAnalogX = 0
  134. leftAnalogY = 1
  135. leftAnalogZ = 2
  136. rightAnalogX = 3
  137. rightAnalogY = 4
  138. rightAnalogZ = 5
  139. dPadX = 16
  140. dPadY = 17
  141. a = 304
  142. b = 305
  143. x = 307
  144. y = 308
  145. left = 310
  146. right = 311
  147. back = 314
  148. start = 315
  149. logitech = 316
  150. leftAnalog = 317
  151. rightAnalog = 318
  152. )
  153. func (g *Gamepad) Read() error {
  154. log.Print("gamepad read loop started")
  155. for {
  156. e, err := g.device.ReadOne()
  157. if err != nil {
  158. return err
  159. }
  160. switch e.Type {
  161. case evdev.EV_ABS:
  162. switch e.Code {
  163. case leftAnalogX:
  164. if g.channels&LeftAnalog != 0 {
  165. g.LeftAnalog <- Event{Type: AxisX, Value: e.Value}
  166. }
  167. case leftAnalogY:
  168. if g.channels&LeftAnalog != 0 {
  169. g.LeftAnalog <- Event{Type: AxisY, Value: e.Value}
  170. }
  171. case leftAnalogZ:
  172. if g.channels&LeftAnalog != 0 {
  173. g.LeftAnalog <- Event{Type: AxisZ, Value: e.Value}
  174. }
  175. case rightAnalogX:
  176. if g.channels&RightAnalog != 0 {
  177. g.RightAnalog <- Event{Type: AxisX, Value: e.Value}
  178. }
  179. case rightAnalogY:
  180. if g.channels&RightAnalog != 0 {
  181. g.RightAnalog <- Event{Type: AxisY, Value: e.Value}
  182. }
  183. case rightAnalogZ:
  184. if g.channels&RightAnalog != 0 {
  185. g.RightAnalog <- Event{Type: AxisZ, Value: e.Value}
  186. }
  187. case dPadX:
  188. if g.channels&DPad != 0 {
  189. g.DPad <- Event{Type: AxisX, Value: e.Value}
  190. }
  191. case dPadY:
  192. if g.channels&DPad != 0 {
  193. g.DPad <- Event{Type: AxisY, Value: e.Value}
  194. }
  195. }
  196. case evdev.EV_KEY:
  197. switch e.Code {
  198. case a:
  199. if g.channels&A != 0 {
  200. g.A <- Event{Type: Button, Value: e.Value}
  201. }
  202. case b:
  203. if g.channels&B != 0 {
  204. g.B <- Event{Type: Button, Value: e.Value}
  205. }
  206. case x:
  207. if g.channels&X != 0 {
  208. g.X <- Event{Type: Button, Value: e.Value}
  209. }
  210. case y:
  211. if g.channels&Y != 0 {
  212. g.Y <- Event{Type: Button, Value: e.Value}
  213. }
  214. case left:
  215. if g.channels&Left != 0 {
  216. g.Left <- Event{Type: Button, Value: e.Value}
  217. }
  218. case right:
  219. if g.channels&Right != 0 {
  220. g.Right <- Event{Type: Button, Value: e.Value}
  221. }
  222. case back:
  223. if g.channels&Back != 0 {
  224. g.Back <- Event{Type: Button, Value: e.Value}
  225. }
  226. case start:
  227. if g.channels&Start != 0 {
  228. g.Start <- Event{Type: Button, Value: e.Value}
  229. }
  230. case logitech:
  231. if g.channels&Logitech != 0 {
  232. g.Logitech <- Event{Type: Button, Value: e.Value}
  233. }
  234. case leftAnalog:
  235. if g.channels&LeftAnalog != 0 {
  236. g.LeftAnalog <- Event{Type: Button, Value: e.Value}
  237. }
  238. case rightAnalog:
  239. if g.channels&LeftAnalog != 0 {
  240. g.RightAnalog <- Event{Type: Button, Value: e.Value}
  241. }
  242. }
  243. }
  244. }
  245. }