gamepad.go 5.7 KB

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