summaryrefslogtreecommitdiff
path: root/lib/usbhost/USB_Host_Shield_2.0/XBOXRECV.h
blob: 4f9214653c7da689035031d1cda9dc4bedb04268 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
/* Copyright (C) 2012 Kristian Lauszus, TKJ Electronics. All rights reserved.

 This software may be distributed and modified under the terms of the GNU
 General Public License version 2 (GPL2) as published by the Free Software
 Foundation and appearing in the file GPL2.TXT included in the packaging of
 this file. Please note that GPL2 Section 2[b] requires that all works based
 on this software must also be made publicly available under the terms of
 the GPL2 ("Copyleft").

 Contact information
 -------------------

 Kristian Lauszus, TKJ Electronics
 Web      :  http://www.tkjelectronics.com
 e-mail   :  kristianl@tkjelectronics.com

 getBatteryLevel and checkStatus functions made by timstamp.co.uk found using BusHound from Perisoft.net
 */

#ifndef _xboxrecv_h_
#define _xboxrecv_h_

#include "Usb.h"
#include "xboxEnums.h"

/* Data Xbox 360 taken from descriptors */
#define EP_MAXPKTSIZE       32 // max size for data via USB

/* Names we give to the 9 Xbox360 pipes */
#define XBOX_CONTROL_PIPE   0
#define XBOX_INPUT_PIPE_1   1
#define XBOX_OUTPUT_PIPE_1  2
#define XBOX_INPUT_PIPE_2   3
#define XBOX_OUTPUT_PIPE_2  4
#define XBOX_INPUT_PIPE_3   5
#define XBOX_OUTPUT_PIPE_3  6
#define XBOX_INPUT_PIPE_4   7
#define XBOX_OUTPUT_PIPE_4  8

// PID and VID of the different devices
#define XBOX_VID                                0x045E  // Microsoft Corporation
#define MADCATZ_VID                             0x1BAD  // For unofficial Mad Catz receivers
#define JOYTECH_VID                             0x162E  // For unofficial Joytech controllers

#define XBOX_WIRELESS_RECEIVER_PID              0x0719  // Microsoft Wireless Gaming Receiver
#define XBOX_WIRELESS_RECEIVER_THIRD_PARTY_PID  0x0291  // Third party Wireless Gaming Receiver

#define XBOX_MAX_ENDPOINTS   9

/**
 * This class implements support for a Xbox Wireless receiver.
 *
 * Up to four controllers can connect to one receiver, if more is needed one can use a second receiver via the USBHub class.
 */
class XBOXRECV : public USBDeviceConfig {
public:
        /**
         * Constructor for the XBOXRECV class.
         * @param  pUsb   Pointer to USB class instance.
         */
        XBOXRECV(USB *pUsb);

        /** @name USBDeviceConfig implementation */
        /**
         * Address assignment and basic initilization is done here.
         * @param  parent   Hub number.
         * @param  port     Port number on the hub.
         * @param  lowspeed Speed of the device.
         * @return          0 on success.
         */
        uint8_t ConfigureDevice(uint8_t parent, uint8_t port, bool lowspeed);
        /**
         * Initialize the Xbox wireless receiver.
         * @param  parent   Hub number.
         * @param  port     Port number on the hub.
         * @param  lowspeed Speed of the device.
         * @return          0 on success.
         */
        uint8_t Init(uint8_t parent, uint8_t port, bool lowspeed);
        /**
         * Release the USB device.
         * @return 0 on success.
         */
        uint8_t Release();
        /**
         * Poll the USB Input endpoins and run the state machines.
         * @return 0 on success.
         */
        uint8_t Poll();

        /**
         * Get the device address.
         * @return The device address.
         */
        virtual uint8_t GetAddress() {
                return bAddress;
        };

        /**
         * Used to check if the controller has been initialized.
         * @return True if it's ready.
         */
        virtual bool isReady() {
                return bPollEnable;
        };

        /**
         * Used by the USB core to check what this driver support.
         * @param  vid The device's VID.
         * @param  pid The device's PID.
         * @return     Returns true if the device's VID and PID matches this driver.
         */
        virtual bool VIDPIDOK(uint16_t vid, uint16_t pid) {
                return ((vid == XBOX_VID || vid == MADCATZ_VID || vid == JOYTECH_VID) && (pid == XBOX_WIRELESS_RECEIVER_PID || pid == XBOX_WIRELESS_RECEIVER_THIRD_PARTY_PID));
        };
        /**@}*/

        /** @name Xbox Controller functions */
        /**
         * getButtonPress(uint8_t controller, ButtonEnum b) will return true as long as the button is held down.
         *
         * While getButtonClick(uint8_t controller, ButtonEnum b) will only return it once.
         *
         * So you instance if you need to increase a variable once you would use getButtonClick(uint8_t controller, ButtonEnum b),
         * but if you need to drive a robot forward you would use getButtonPress(uint8_t controller, ButtonEnum b).
         * @param  b          ::ButtonEnum to read.
         * @param  controller The controller to read from. Default to 0.
         * @return            getButtonClick(uint8_t controller, ButtonEnum b) will return a bool, while getButtonPress(uint8_t controller, ButtonEnum b) will return a byte if reading ::L2 or ::R2.
         */
        uint8_t getButtonPress(ButtonEnum b, uint8_t controller = 0);
        bool getButtonClick(ButtonEnum b, uint8_t controller = 0);
        /**@}*/

        /** @name Xbox Controller functions */
        /**
         * Return the analog value from the joysticks on the controller.
         * @param  a          Either ::LeftHatX, ::LeftHatY, ::RightHatX or ::RightHatY.
         * @param  controller The controller to read from. Default to 0.
         * @return            Returns a signed 16-bit integer.
         */
        int16_t getAnalogHat(AnalogHatEnum a, uint8_t controller = 0);

        /**
         * Used to disconnect any of the controllers.
         * @param controller The controller to disconnect. Default to 0.
         */
        void disconnect(uint8_t controller = 0);

        /**
         * Turn rumble off and all the LEDs on the specific controller.
         * @param  controller The controller to write to. Default to 0.
         */
        void setAllOff(uint8_t controller = 0) {
                setRumbleOn(0, 0, controller);
                setLedOff(controller);
        };

        /**
         * Turn rumble off the specific controller.
         * @param  controller The controller to write to. Default to 0.
         */
        void setRumbleOff(uint8_t controller = 0) {
                setRumbleOn(0, 0, controller);
        };
        /**
         * Turn rumble on.
         * @param lValue     Left motor (big weight) inside the controller.
         * @param rValue     Right motor (small weight) inside the controller.
         * @param controller The controller to write to. Default to 0.
         */
        void setRumbleOn(uint8_t lValue, uint8_t rValue, uint8_t controller = 0);
        /**
         * Set LED value. Without using the ::LEDEnum or ::LEDModeEnum.
         * @param value      See:
         * setLedOff(uint8_t controller), setLedOn(uint8_t controller, LED l),
         * setLedBlink(uint8_t controller, LED l), and setLedMode(uint8_t controller, LEDMode lm).
         * @param controller The controller to write to. Default to 0.
         */
        void setLedRaw(uint8_t value, uint8_t controller = 0);

        /**
         * Turn all LEDs off the specific controller.
         * @param controller The controller to write to. Default to 0.
         */
        void setLedOff(uint8_t controller = 0) {
                setLedRaw(0, controller);
        };
        /**
         * Turn on a LED by using ::LEDEnum.
         * @param l          ::OFF, ::LED1, ::LED2, ::LED3 and ::LED4 is supported by the Xbox controller.
         * @param controller The controller to write to. Default to 0.
         */
        void setLedOn(LEDEnum l, uint8_t controller = 0);
        /**
         * Turn on a LED by using ::LEDEnum.
         * @param l          ::ALL, ::LED1, ::LED2, ::LED3 and ::LED4 is supported by the Xbox controller.
         * @param controller The controller to write to. Default to 0.
         */
        void setLedBlink(LEDEnum l, uint8_t controller = 0);
        /**
         * Used to set special LED modes supported by the Xbox controller.
         * @param lm         See ::LEDModeEnum.
         * @param controller The controller to write to. Default to 0.
         */
        void setLedMode(LEDModeEnum lm, uint8_t controller = 0);
        /**
         * Used to get the battery level from the controller.
         * @param  controller The controller to read from. Default to 0.
         * @return            Returns the battery level as an integer in the range of 0-3.
         */
        uint8_t getBatteryLevel(uint8_t controller = 0);
        /**
         * Used to check if a button has changed.
         * @param  controller The controller to read from. Default to 0.
         * @return            True if a button has changed.
         */
        bool buttonChanged(uint8_t controller = 0);

        /**
         * Used to call your own function when the controller is successfully initialized.
         * @param funcOnInit Function to call.
         */
        void attachOnInit(void (*funcOnInit)(void)) {
                pFuncOnInit = funcOnInit;
        };
        /**@}*/

        /** True if a wireless receiver is connected. */
        bool XboxReceiverConnected;
        /** Variable used to indicate if the XBOX 360 controller is successfully connected. */
        uint8_t Xbox360Connected[4];

protected:
        /** Pointer to USB class instance. */
        USB *pUsb;
        /** Device address. */
        uint8_t bAddress;
        /** Endpoint info structure. */
        EpInfo epInfo[XBOX_MAX_ENDPOINTS];

private:
        /**
         * Called when the controller is successfully initialized.
         * Use attachOnInit(void (*funcOnInit)(void)) to call your own function.
         * This is useful for instance if you want to set the LEDs in a specific way.
         * @param controller The initialized controller.
         */
        void onInit(uint8_t controller);
        void (*pFuncOnInit)(void); // Pointer to function called in onInit()

        bool bPollEnable;

        /* Variables to store the buttons */
        uint32_t ButtonState[4];
        uint32_t OldButtonState[4];
        uint16_t ButtonClickState[4];
        int16_t hatValue[4][4];
        uint16_t controllerStatus[4];
        bool buttonStateChanged[4]; // True if a button has changed

        bool L2Clicked[4]; // These buttons are analog, so we use we use these bools to check if they where clicked or not
        bool R2Clicked[4];

        uint32_t checkStatusTimer; // Timing for checkStatus() signals

        uint8_t readBuf[EP_MAXPKTSIZE]; // General purpose buffer for input data
        uint8_t writeBuf[7]; // General purpose buffer for output data

        void readReport(uint8_t controller); // read incoming data
        void printReport(uint8_t controller, uint8_t nBytes); // print incoming date - Uncomment for debugging

        /* Private commands */
        void XboxCommand(uint8_t controller, uint8_t* data, uint16_t nbytes);
        void checkStatus();
};
#endif