Arnaud VALLEY / Mbed 2 deprecated Pinscape_Controller_V2_arnoz

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed FastIO FastPWM USBDevice

USBJoystick/USBJoystick.cpp@40:cc0d9814522b, 2016-02-03 (annotated)

Committer:
mjr
Date:
Wed Feb 03 22:57:25 2016 +0000
Revision:
40:cc0d9814522b
Parent:
39:b3815a1c3802
Child:
47:df7a88cd249c
Gamma correction option for outputs; work in progress on new config program

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mjr 3:3514575d4f86 1 /* Copyright (c) 2010-2011 mbed.org, MIT License
mjr 3:3514575d4f86 2 * Modified Mouse code for Joystick - WH 2012
mjr 3:3514575d4f86 3 *
mjr 3:3514575d4f86 4 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
mjr 3:3514575d4f86 5 * and associated documentation files (the "Software"), to deal in the Software without
mjr 3:3514575d4f86 6 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
mjr 3:3514575d4f86 7 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
mjr 3:3514575d4f86 8 * Software is furnished to do so, subject to the following conditions:
mjr 3:3514575d4f86 9 *
mjr 3:3514575d4f86 10 * The above copyright notice and this permission notice shall be included in all copies or
mjr 3:3514575d4f86 11 * substantial portions of the Software.
mjr 3:3514575d4f86 12 *
mjr 3:3514575d4f86 13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
mjr 3:3514575d4f86 14 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
mjr 3:3514575d4f86 15 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
mjr 3:3514575d4f86 16 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
mjr 3:3514575d4f86 17 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
mjr 3:3514575d4f86 18 */
mjr 3:3514575d4f86 19
mjr 3:3514575d4f86 20 #include "stdint.h"
mjr 3:3514575d4f86 21 #include "USBJoystick.h"
mjr 21:5048e16cc9ef 22
mjr 21:5048e16cc9ef 23 #include "config.h" // Pinscape configuration
mjr 21:5048e16cc9ef 24
mjr 35:e959ffba78fd 25
mjr 35:e959ffba78fd 26
mjr 21:5048e16cc9ef 27 // Length of our joystick reports. Important: This must be kept in sync
mjr 21:5048e16cc9ef 28 // with the actual joystick report format sent in update().
mjr 21:5048e16cc9ef 29 const int reportLen = 14;
mjr 21:5048e16cc9ef 30
mjr 11:bd9da7088e6e 31 bool USBJoystick::update(int16_t x, int16_t y, int16_t z, uint32_t buttons, uint16_t status)
mjr 3:3514575d4f86 32 {
mjr 3:3514575d4f86 33 _x = x;
mjr 3:3514575d4f86 34 _y = y;
mjr 3:3514575d4f86 35 _z = z;
mjr 11:bd9da7088e6e 36 _buttonsLo = (uint16_t)(buttons & 0xffff);
mjr 11:bd9da7088e6e 37 _buttonsHi = (uint16_t)((buttons >> 16) & 0xffff);
mjr 10:976666ffa4ef 38 _status = status;
mjr 3:3514575d4f86 39
mjr 3:3514575d4f86 40 // send the report
mjr 3:3514575d4f86 41 return update();
mjr 3:3514575d4f86 42 }
mjr 35:e959ffba78fd 43
mjr 11:bd9da7088e6e 44 bool USBJoystick::update()
mjr 11:bd9da7088e6e 45 {
mjr 3:3514575d4f86 46 HID_REPORT report;
mjr 11:bd9da7088e6e 47
mjr 3:3514575d4f86 48 // Fill the report according to the Joystick Descriptor
mjr 6:cc35eb643e8f 49 #define put(idx, val) (report.data[idx] = (val) & 0xff, report.data[(idx)+1] = ((val) >> 8) & 0xff)
mjr 40:cc0d9814522b 50 #define putl(idx, val) (put(idx, val), put((idx)+2, (val) >> 16))
mjr 10:976666ffa4ef 51 put(0, _status);
mjr 40:cc0d9814522b 52 put(2, 0); // second word of status - zero in high bit identifies as normal joystick report
mjr 11:bd9da7088e6e 53 put(4, _buttonsLo);
mjr 11:bd9da7088e6e 54 put(6, _buttonsHi);
mjr 11:bd9da7088e6e 55 put(8, _x);
mjr 11:bd9da7088e6e 56 put(10, _y);
mjr 11:bd9da7088e6e 57 put(12, _z);
mjr 21:5048e16cc9ef 58
mjr 21:5048e16cc9ef 59 // important: keep reportLen in sync with the actual byte length of
mjr 21:5048e16cc9ef 60 // the reports we build here
mjr 11:bd9da7088e6e 61 report.length = reportLen;
mjr 3:3514575d4f86 62
mjr 5:a70c0bce770d 63 // send the report
mjr 10:976666ffa4ef 64 return sendTO(&report, 100);
mjr 10:976666ffa4ef 65 }
mjr 10:976666ffa4ef 66
mjr 35:e959ffba78fd 67 bool USBJoystick::kbUpdate(uint8_t data[8])
mjr 35:e959ffba78fd 68 {
mjr 35:e959ffba78fd 69 // set up the report
mjr 35:e959ffba78fd 70 HID_REPORT report;
mjr 35:e959ffba78fd 71 report.data[0] = REPORT_ID_KB; // report ID = keyboard
mjr 35:e959ffba78fd 72 memcpy(&report.data[1], data, 8); // copy the kb report data
mjr 35:e959ffba78fd 73 report.length = 9; // length = ID prefix + kb report length
mjr 35:e959ffba78fd 74
mjr 35:e959ffba78fd 75 // send it to endpoint 4 (the keyboard interface endpoint)
mjr 35:e959ffba78fd 76 return writeTO(EP4IN, report.data, report.length, MAX_PACKET_SIZE_EPINT, 100);
mjr 35:e959ffba78fd 77 }
mjr 35:e959ffba78fd 78
mjr 35:e959ffba78fd 79 bool USBJoystick::mediaUpdate(uint8_t data)
mjr 35:e959ffba78fd 80 {
mjr 35:e959ffba78fd 81 // set up the report
mjr 35:e959ffba78fd 82 HID_REPORT report;
mjr 35:e959ffba78fd 83 report.data[0] = REPORT_ID_MEDIA; // report ID = media
mjr 35:e959ffba78fd 84 report.data[1] = data; // key pressed bits
mjr 35:e959ffba78fd 85 report.length = 2;
mjr 35:e959ffba78fd 86
mjr 35:e959ffba78fd 87 // send it
mjr 35:e959ffba78fd 88 return writeTO(EP4IN, report.data, report.length, MAX_PACKET_SIZE_EPINT, 100);
mjr 35:e959ffba78fd 89 }
mjr 35:e959ffba78fd 90
mjr 10:976666ffa4ef 91 bool USBJoystick::updateExposure(int &idx, int npix, const uint16_t *pix)
mjr 10:976666ffa4ef 92 {
mjr 10:976666ffa4ef 93 HID_REPORT report;
mjr 10:976666ffa4ef 94
mjr 10:976666ffa4ef 95 // Set the special status bits to indicate it's an exposure report.
mjr 10:976666ffa4ef 96 // The high 5 bits of the status word are set to 10000, and the
mjr 10:976666ffa4ef 97 // low 11 bits are the current pixel index.
mjr 10:976666ffa4ef 98 uint16_t s = idx | 0x8000;
mjr 10:976666ffa4ef 99 put(0, s);
mjr 25:e22b88bd783a 100
mjr 25:e22b88bd783a 101 // start at the second byte
mjr 25:e22b88bd783a 102 int ofs = 2;
mjr 25:e22b88bd783a 103
mjr 25:e22b88bd783a 104 // in the first report, add the total pixel count as the next two bytes
mjr 25:e22b88bd783a 105 if (idx == 0)
mjr 25:e22b88bd783a 106 {
mjr 25:e22b88bd783a 107 put(ofs, npix);
mjr 25:e22b88bd783a 108 ofs += 2;
mjr 25:e22b88bd783a 109 }
mjr 10:976666ffa4ef 110
mjr 10:976666ffa4ef 111 // now fill out the remaining words with exposure values
mjr 11:bd9da7088e6e 112 report.length = reportLen;
mjr 25:e22b88bd783a 113 for ( ; ofs + 1 < report.length ; ofs += 2)
mjr 10:976666ffa4ef 114 {
mjr 10:976666ffa4ef 115 uint16_t p = (idx < npix ? pix[idx++] : 0);
mjr 10:976666ffa4ef 116 put(ofs, p);
mjr 10:976666ffa4ef 117 }
mjr 10:976666ffa4ef 118
mjr 10:976666ffa4ef 119 // send the report
mjr 35:e959ffba78fd 120 return sendTO(&report, 100);
mjr 3:3514575d4f86 121 }
mjr 9:fd65b0a94720 122
mjr 40:cc0d9814522b 123 bool USBJoystick::reportID()
mjr 40:cc0d9814522b 124 {
mjr 40:cc0d9814522b 125 HID_REPORT report;
mjr 40:cc0d9814522b 126
mjr 40:cc0d9814522b 127 // initially fill the report with zeros
mjr 40:cc0d9814522b 128 memset(report.data, 0, sizeof(report.data));
mjr 40:cc0d9814522b 129
mjr 40:cc0d9814522b 130 // Set the special status bits to indicate that it's an ID report
mjr 40:cc0d9814522b 131 uint16_t s = 0x9000;
mjr 40:cc0d9814522b 132 put(0, s);
mjr 40:cc0d9814522b 133
mjr 40:cc0d9814522b 134 // write the 80-bit ID
mjr 40:cc0d9814522b 135 put(2, SIM->UIDMH);
mjr 40:cc0d9814522b 136 putl(4, SIM->UIDML);
mjr 40:cc0d9814522b 137 putl(8, SIM->UIDL);
mjr 40:cc0d9814522b 138
mjr 40:cc0d9814522b 139 // send the report
mjr 40:cc0d9814522b 140 report.length = reportLen;
mjr 40:cc0d9814522b 141 return sendTO(&report, 100);
mjr 40:cc0d9814522b 142 }
mjr 40:cc0d9814522b 143
mjr 40:cc0d9814522b 144 bool USBJoystick::reportConfig(int numOutputs, int unitNo, int plungerZero, int plungerMax, bool configured)
mjr 33:d832bcab089e 145 {
mjr 33:d832bcab089e 146 HID_REPORT report;
mjr 33:d832bcab089e 147
mjr 33:d832bcab089e 148 // initially fill the report with zeros
mjr 33:d832bcab089e 149 memset(report.data, 0, sizeof(report.data));
mjr 33:d832bcab089e 150
mjr 33:d832bcab089e 151 // Set the special status bits to indicate that it's a config report.
mjr 33:d832bcab089e 152 uint16_t s = 0x8800;
mjr 33:d832bcab089e 153 put(0, s);
mjr 33:d832bcab089e 154
mjr 33:d832bcab089e 155 // write the number of configured outputs
mjr 33:d832bcab089e 156 put(2, numOutputs);
mjr 33:d832bcab089e 157
mjr 33:d832bcab089e 158 // write the unit number
mjr 33:d832bcab089e 159 put(4, unitNo);
mjr 33:d832bcab089e 160
mjr 35:e959ffba78fd 161 // write the plunger zero and max values
mjr 35:e959ffba78fd 162 put(6, plungerZero);
mjr 35:e959ffba78fd 163 put(8, plungerMax);
mjr 35:e959ffba78fd 164
mjr 40:cc0d9814522b 165 // write the status bits:
mjr 40:cc0d9814522b 166 // 0x01 -> configuration loaded
mjr 40:cc0d9814522b 167 report.data[10] = (configured ? 0x01 : 0x00);
mjr 40:cc0d9814522b 168
mjr 33:d832bcab089e 169 // send the report
mjr 33:d832bcab089e 170 report.length = reportLen;
mjr 35:e959ffba78fd 171 return sendTO(&report, 100);
mjr 33:d832bcab089e 172 }
mjr 33:d832bcab089e 173
mjr 33:d832bcab089e 174 bool USBJoystick::move(int16_t x, int16_t y)
mjr 33:d832bcab089e 175 {
mjr 3:3514575d4f86 176 _x = x;
mjr 3:3514575d4f86 177 _y = y;
mjr 3:3514575d4f86 178 return update();
mjr 3:3514575d4f86 179 }
mjr 3:3514575d4f86 180
mjr 33:d832bcab089e 181 bool USBJoystick::setZ(int16_t z)
mjr 33:d832bcab089e 182 {
mjr 3:3514575d4f86 183 _z = z;
mjr 3:3514575d4f86 184 return update();
mjr 3:3514575d4f86 185 }
mjr 3:3514575d4f86 186
mjr 33:d832bcab089e 187 bool USBJoystick::buttons(uint32_t buttons)
mjr 33:d832bcab089e 188 {
mjr 11:bd9da7088e6e 189 _buttonsLo = (uint16_t)(buttons & 0xffff);
mjr 11:bd9da7088e6e 190 _buttonsHi = (uint16_t)((buttons >> 16) & 0xffff);
mjr 3:3514575d4f86 191 return update();
mjr 3:3514575d4f86 192 }
mjr 21:5048e16cc9ef 193
mjr 21:5048e16cc9ef 194 bool USBJoystick::updateStatus(uint32_t status)
mjr 21:5048e16cc9ef 195 {
mjr 21:5048e16cc9ef 196 HID_REPORT report;
mjr 21:5048e16cc9ef 197
mjr 21:5048e16cc9ef 198 // Fill the report according to the Joystick Descriptor
mjr 21:5048e16cc9ef 199 #define put(idx, val) (report.data[idx] = (val) & 0xff, report.data[(idx)+1] = ((val) >> 8) & 0xff)
mjr 21:5048e16cc9ef 200 memset(report.data, 0, reportLen);
mjr 21:5048e16cc9ef 201 put(0, status);
mjr 21:5048e16cc9ef 202 report.length = reportLen;
mjr 21:5048e16cc9ef 203
mjr 21:5048e16cc9ef 204 // send the report
mjr 21:5048e16cc9ef 205 return sendTO(&report, 100);
mjr 21:5048e16cc9ef 206 }
mjr 21:5048e16cc9ef 207
mjr 3:3514575d4f86 208 void USBJoystick::_init() {
mjr 3:3514575d4f86 209
mjr 3:3514575d4f86 210 _x = 0;
mjr 3:3514575d4f86 211 _y = 0;
mjr 3:3514575d4f86 212 _z = 0;
mjr 11:bd9da7088e6e 213 _buttonsLo = 0x0000;
mjr 11:bd9da7088e6e 214 _buttonsHi = 0x0000;
mjr 9:fd65b0a94720 215 _status = 0;
mjr 3:3514575d4f86 216 }
mjr 3:3514575d4f86 217
mjr 3:3514575d4f86 218
mjr 35:e959ffba78fd 219 // --------------------------------------------------------------------------
mjr 35:e959ffba78fd 220 //
mjr 35:e959ffba78fd 221 // USB HID Report Descriptor - Joystick
mjr 35:e959ffba78fd 222 //
mjr 35:e959ffba78fd 223 static uint8_t reportDescriptorJS[] =
mjr 35:e959ffba78fd 224 {
mjr 35:e959ffba78fd 225 USAGE_PAGE(1), 0x01, // Generic desktop
mjr 35:e959ffba78fd 226 USAGE(1), 0x04, // Joystick
mjr 35:e959ffba78fd 227 COLLECTION(1), 0x01, // Application
mjr 35:e959ffba78fd 228
mjr 35:e959ffba78fd 229 // input report (device to host)
mjr 35:e959ffba78fd 230
mjr 35:e959ffba78fd 231 USAGE_PAGE(1), 0x06, // generic device controls - for config status
mjr 35:e959ffba78fd 232 USAGE(1), 0x00, // undefined device control
mjr 35:e959ffba78fd 233 LOGICAL_MINIMUM(1), 0x00, // 8-bit values
mjr 35:e959ffba78fd 234 LOGICAL_MAXIMUM(1), 0xFF,
mjr 35:e959ffba78fd 235 REPORT_SIZE(1), 0x08, // 8 bits per report
mjr 35:e959ffba78fd 236 REPORT_COUNT(1), 0x04, // 4 reports (4 bytes)
mjr 35:e959ffba78fd 237 INPUT(1), 0x02, // Data, Variable, Absolute
mjr 35:e959ffba78fd 238
mjr 35:e959ffba78fd 239 USAGE_PAGE(1), 0x09, // Buttons
mjr 35:e959ffba78fd 240 USAGE_MINIMUM(1), 0x01, // { buttons }
mjr 35:e959ffba78fd 241 USAGE_MAXIMUM(1), 0x20, // { 1-32 }
mjr 35:e959ffba78fd 242 LOGICAL_MINIMUM(1), 0x00, // 1-bit buttons - 0...
mjr 35:e959ffba78fd 243 LOGICAL_MAXIMUM(1), 0x01, // ...to 1
mjr 35:e959ffba78fd 244 REPORT_SIZE(1), 0x01, // 1 bit per report
mjr 35:e959ffba78fd 245 REPORT_COUNT(1), 0x20, // 32 reports
mjr 35:e959ffba78fd 246 UNIT_EXPONENT(1), 0x00, // Unit_Exponent (0)
mjr 35:e959ffba78fd 247 UNIT(1), 0x00, // Unit (None)
mjr 35:e959ffba78fd 248 INPUT(1), 0x02, // Data, Variable, Absolute
mjr 35:e959ffba78fd 249
mjr 35:e959ffba78fd 250 USAGE_PAGE(1), 0x01, // Generic desktop
mjr 35:e959ffba78fd 251 USAGE(1), 0x30, // X axis
mjr 35:e959ffba78fd 252 USAGE(1), 0x31, // Y axis
mjr 35:e959ffba78fd 253 USAGE(1), 0x32, // Z axis
mjr 35:e959ffba78fd 254 LOGICAL_MINIMUM(2), 0x00,0xF0, // each value ranges -4096
mjr 35:e959ffba78fd 255 LOGICAL_MAXIMUM(2), 0x00,0x10, // ...to +4096
mjr 35:e959ffba78fd 256 REPORT_SIZE(1), 0x10, // 16 bits per report
mjr 35:e959ffba78fd 257 REPORT_COUNT(1), 0x03, // 3 reports (X, Y, Z)
mjr 35:e959ffba78fd 258 INPUT(1), 0x02, // Data, Variable, Absolute
mjr 9:fd65b0a94720 259
mjr 35:e959ffba78fd 260 // output report (host to device)
mjr 35:e959ffba78fd 261 REPORT_SIZE(1), 0x08, // 8 bits per report
mjr 35:e959ffba78fd 262 REPORT_COUNT(1), 0x08, // output report count - 8-byte LedWiz format
mjr 35:e959ffba78fd 263 0x09, 0x01, // usage
mjr 35:e959ffba78fd 264 0x91, 0x01, // Output (array)
mjr 35:e959ffba78fd 265
mjr 35:e959ffba78fd 266 END_COLLECTION(0)
mjr 35:e959ffba78fd 267 };
mjr 35:e959ffba78fd 268
mjr 35:e959ffba78fd 269 //
mjr 35:e959ffba78fd 270 // USB HID Report Descriptor - Keyboard/Media Control
mjr 35:e959ffba78fd 271 //
mjr 35:e959ffba78fd 272 static uint8_t reportDescriptorKB[] =
mjr 35:e959ffba78fd 273 {
mjr 35:e959ffba78fd 274 USAGE_PAGE(1), 0x01, // Generic Desktop
mjr 35:e959ffba78fd 275 USAGE(1), 0x06, // Keyboard
mjr 35:e959ffba78fd 276 COLLECTION(1), 0x01, // Application
mjr 35:e959ffba78fd 277 REPORT_ID(1), REPORT_ID_KB,
mjr 10:976666ffa4ef 278
mjr 35:e959ffba78fd 279 USAGE_PAGE(1), 0x07, // Key Codes
mjr 35:e959ffba78fd 280 USAGE_MINIMUM(1), 0xE0,
mjr 35:e959ffba78fd 281 USAGE_MAXIMUM(1), 0xE7,
mjr 35:e959ffba78fd 282 LOGICAL_MINIMUM(1), 0x00,
mjr 35:e959ffba78fd 283 LOGICAL_MAXIMUM(1), 0x01,
mjr 35:e959ffba78fd 284 REPORT_SIZE(1), 0x01,
mjr 35:e959ffba78fd 285 REPORT_COUNT(1), 0x08,
mjr 35:e959ffba78fd 286 INPUT(1), 0x02, // Data, Variable, Absolute
mjr 35:e959ffba78fd 287 REPORT_COUNT(1), 0x01,
mjr 35:e959ffba78fd 288 REPORT_SIZE(1), 0x08,
mjr 35:e959ffba78fd 289 INPUT(1), 0x01, // Constant
mjr 35:e959ffba78fd 290
mjr 35:e959ffba78fd 291 REPORT_COUNT(1), 0x05,
mjr 35:e959ffba78fd 292 REPORT_SIZE(1), 0x01,
mjr 35:e959ffba78fd 293 USAGE_PAGE(1), 0x08, // LEDs
mjr 35:e959ffba78fd 294 USAGE_MINIMUM(1), 0x01,
mjr 35:e959ffba78fd 295 USAGE_MAXIMUM(1), 0x05,
mjr 35:e959ffba78fd 296 OUTPUT(1), 0x02, // Data, Variable, Absolute
mjr 35:e959ffba78fd 297 REPORT_COUNT(1), 0x01,
mjr 35:e959ffba78fd 298 REPORT_SIZE(1), 0x03,
mjr 35:e959ffba78fd 299 OUTPUT(1), 0x01, // Constant
mjr 10:976666ffa4ef 300
mjr 35:e959ffba78fd 301 REPORT_COUNT(1), 0x06,
mjr 35:e959ffba78fd 302 REPORT_SIZE(1), 0x08,
mjr 35:e959ffba78fd 303 LOGICAL_MINIMUM(1), 0x00,
mjr 35:e959ffba78fd 304 LOGICAL_MAXIMUM(1), 0x65,
mjr 35:e959ffba78fd 305 USAGE_PAGE(1), 0x07, // Key Codes
mjr 35:e959ffba78fd 306 USAGE_MINIMUM(1), 0x00,
mjr 35:e959ffba78fd 307 USAGE_MAXIMUM(1), 0x65,
mjr 35:e959ffba78fd 308 INPUT(1), 0x00, // Data, Array
mjr 35:e959ffba78fd 309 END_COLLECTION(0),
mjr 3:3514575d4f86 310
mjr 35:e959ffba78fd 311 // Media Control
mjr 35:e959ffba78fd 312 USAGE_PAGE(1), 0x0C,
mjr 35:e959ffba78fd 313 USAGE(1), 0x01,
mjr 35:e959ffba78fd 314 COLLECTION(1), 0x01,
mjr 35:e959ffba78fd 315 REPORT_ID(1), REPORT_ID_MEDIA,
mjr 35:e959ffba78fd 316 USAGE_PAGE(1), 0x0C,
mjr 35:e959ffba78fd 317 LOGICAL_MINIMUM(1), 0x00,
mjr 35:e959ffba78fd 318 LOGICAL_MAXIMUM(1), 0x01,
mjr 35:e959ffba78fd 319 REPORT_SIZE(1), 0x01,
mjr 35:e959ffba78fd 320 REPORT_COUNT(1), 0x07,
mjr 35:e959ffba78fd 321 USAGE(1), 0xE9, // Volume Up
mjr 35:e959ffba78fd 322 USAGE(1), 0xEA, // Volume Down
mjr 35:e959ffba78fd 323 USAGE(1), 0xE2, // Mute
mjr 35:e959ffba78fd 324 USAGE(1), 0xB5, // Next Track
mjr 35:e959ffba78fd 325 USAGE(1), 0xB6, // Previous Track
mjr 35:e959ffba78fd 326 USAGE(1), 0xB7, // Stop
mjr 35:e959ffba78fd 327 USAGE(1), 0xCD, // Play / Pause
mjr 35:e959ffba78fd 328 INPUT(1), 0x02, // Input (Data, Variable, Absolute)
mjr 35:e959ffba78fd 329 REPORT_COUNT(1), 0x01,
mjr 35:e959ffba78fd 330 INPUT(1), 0x01,
mjr 35:e959ffba78fd 331 END_COLLECTION(0),
mjr 35:e959ffba78fd 332 };
mjr 29:582472d0bc57 333
mjr 35:e959ffba78fd 334 //
mjr 35:e959ffba78fd 335 // USB HID Report Descriptor - LedWiz only, with no joystick or keyboard
mjr 35:e959ffba78fd 336 // input reporting
mjr 35:e959ffba78fd 337 //
mjr 35:e959ffba78fd 338 static uint8_t reportDescriptorLW[] =
mjr 35:e959ffba78fd 339 {
mjr 35:e959ffba78fd 340 USAGE_PAGE(1), 0x01, // Generic desktop
mjr 35:e959ffba78fd 341 USAGE(1), 0x00, // Undefined
mjr 21:5048e16cc9ef 342
mjr 35:e959ffba78fd 343 COLLECTION(1), 0x01, // Application
mjr 21:5048e16cc9ef 344
mjr 35:e959ffba78fd 345 // input report (device to host)
mjr 35:e959ffba78fd 346 USAGE_PAGE(1), 0x06, // generic device controls - for config status
mjr 35:e959ffba78fd 347 USAGE(1), 0x00, // undefined device control
mjr 35:e959ffba78fd 348 LOGICAL_MINIMUM(1), 0x00, // 8-bit values
mjr 35:e959ffba78fd 349 LOGICAL_MAXIMUM(1), 0xFF,
mjr 35:e959ffba78fd 350 REPORT_SIZE(1), 0x08, // 8 bits per report
mjr 35:e959ffba78fd 351 REPORT_COUNT(1), reportLen, // standard report length (same as if we were in joystick mode)
mjr 35:e959ffba78fd 352 INPUT(1), 0x02, // Data, Variable, Absolute
mjr 35:e959ffba78fd 353
mjr 35:e959ffba78fd 354 // output report (host to device)
mjr 35:e959ffba78fd 355 REPORT_SIZE(1), 0x08, // 8 bits per report
mjr 35:e959ffba78fd 356 REPORT_COUNT(1), 0x08, // output report count (LEDWiz messages)
mjr 35:e959ffba78fd 357 0x09, 0x01, // usage
mjr 35:e959ffba78fd 358 0x91, 0x01, // Output (array)
mjr 35:e959ffba78fd 359
mjr 35:e959ffba78fd 360 END_COLLECTION(0)
mjr 35:e959ffba78fd 361 };
mjr 35:e959ffba78fd 362
mjr 21:5048e16cc9ef 363
mjr 35:e959ffba78fd 364 uint8_t * USBJoystick::reportDescN(int idx)
mjr 35:e959ffba78fd 365 {
mjr 35:e959ffba78fd 366 if (enableJoystick)
mjr 35:e959ffba78fd 367 {
mjr 35:e959ffba78fd 368 // Joystick reports are enabled. Use the full joystick report
mjr 35:e959ffba78fd 369 // format, or full keyboard report format, depending on which
mjr 35:e959ffba78fd 370 // interface is being requested.
mjr 35:e959ffba78fd 371 switch (idx)
mjr 35:e959ffba78fd 372 {
mjr 35:e959ffba78fd 373 case 0:
mjr 35:e959ffba78fd 374 // joystick interface
mjr 35:e959ffba78fd 375 reportLength = sizeof(reportDescriptorJS);
mjr 35:e959ffba78fd 376 return reportDescriptorJS;
mjr 35:e959ffba78fd 377
mjr 35:e959ffba78fd 378 case 1:
mjr 35:e959ffba78fd 379 // keyboard interface
mjr 35:e959ffba78fd 380 reportLength = sizeof(reportDescriptorKB);
mjr 35:e959ffba78fd 381 return reportDescriptorKB;
mjr 35:e959ffba78fd 382
mjr 35:e959ffba78fd 383 default:
mjr 35:e959ffba78fd 384 // unknown interface
mjr 35:e959ffba78fd 385 reportLength = 0;
mjr 35:e959ffba78fd 386 return 0;
mjr 35:e959ffba78fd 387 }
mjr 35:e959ffba78fd 388 }
mjr 35:e959ffba78fd 389 else
mjr 35:e959ffba78fd 390 {
mjr 35:e959ffba78fd 391 // Joystick reports are disabled. Use the LedWiz-only format.
mjr 35:e959ffba78fd 392 reportLength = sizeof(reportDescriptorLW);
mjr 35:e959ffba78fd 393 return reportDescriptorLW;
mjr 35:e959ffba78fd 394 }
mjr 35:e959ffba78fd 395 }
mjr 3:3514575d4f86 396
mjr 3:3514575d4f86 397 uint8_t * USBJoystick::stringImanufacturerDesc() {
mjr 3:3514575d4f86 398 static uint8_t stringImanufacturerDescriptor[] = {
mjr 3:3514575d4f86 399 0x10, /*bLength*/
mjr 3:3514575d4f86 400 STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
mjr 3:3514575d4f86 401 'm',0,'j',0,'r',0,'c',0,'o',0,'r',0,'p',0 /*bString iManufacturer - mjrcorp*/
mjr 3:3514575d4f86 402 };
mjr 3:3514575d4f86 403 return stringImanufacturerDescriptor;
mjr 3:3514575d4f86 404 }
mjr 3:3514575d4f86 405
mjr 3:3514575d4f86 406 uint8_t * USBJoystick::stringIserialDesc() {
mjr 3:3514575d4f86 407 static uint8_t stringIserialDescriptor[] = {
mjr 3:3514575d4f86 408 0x16, /*bLength*/
mjr 3:3514575d4f86 409 STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
mjr 3:3514575d4f86 410 '0',0,'1',0,'2',0,'3',0,'4',0,'5',0,'6',0,'7',0,'8',0,'9',0, /*bString iSerial - 0123456789*/
mjr 3:3514575d4f86 411 };
mjr 3:3514575d4f86 412 return stringIserialDescriptor;
mjr 3:3514575d4f86 413 }
mjr 3:3514575d4f86 414
mjr 3:3514575d4f86 415 uint8_t * USBJoystick::stringIproductDesc() {
mjr 3:3514575d4f86 416 static uint8_t stringIproductDescriptor[] = {
mjr 9:fd65b0a94720 417 0x28, /*bLength*/
mjr 3:3514575d4f86 418 STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
mjr 3:3514575d4f86 419 'P',0,'i',0,'n',0,'s',0,'c',0,'a',0,'p',0,'e',0,
mjr 3:3514575d4f86 420 ' ',0,'C',0,'o',0,'n',0,'t',0,'r',0,'o',0,'l',0,
mjr 3:3514575d4f86 421 'l',0,'e',0,'r',0 /*String iProduct */
mjr 3:3514575d4f86 422 };
mjr 3:3514575d4f86 423 return stringIproductDescriptor;
mjr 3:3514575d4f86 424 }
mjr 35:e959ffba78fd 425
mjr 35:e959ffba78fd 426 #define DEFAULT_CONFIGURATION (1)
mjr 35:e959ffba78fd 427
mjr 35:e959ffba78fd 428 uint8_t * USBJoystick::configurationDesc()
mjr 35:e959ffba78fd 429 {
mjr 35:e959ffba78fd 430 int rptlen0 = reportDescLengthN(0);
mjr 35:e959ffba78fd 431 int rptlen1 = reportDescLengthN(1);
mjr 35:e959ffba78fd 432 if (useKB)
mjr 35:e959ffba78fd 433 {
mjr 35:e959ffba78fd 434 int cfglenKB = ((1 * CONFIGURATION_DESCRIPTOR_LENGTH)
mjr 35:e959ffba78fd 435 + (2 * INTERFACE_DESCRIPTOR_LENGTH)
mjr 35:e959ffba78fd 436 + (2 * HID_DESCRIPTOR_LENGTH)
mjr 35:e959ffba78fd 437 + (4 * ENDPOINT_DESCRIPTOR_LENGTH));
mjr 35:e959ffba78fd 438 static uint8_t configurationDescriptorWithKB[] =
mjr 35:e959ffba78fd 439 {
mjr 35:e959ffba78fd 440 CONFIGURATION_DESCRIPTOR_LENGTH,// bLength
mjr 35:e959ffba78fd 441 CONFIGURATION_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 442 LSB(cfglenKB), // wTotalLength (LSB)
mjr 35:e959ffba78fd 443 MSB(cfglenKB), // wTotalLength (MSB)
mjr 35:e959ffba78fd 444 0x02, // bNumInterfaces - TWO INTERFACES (JOYSTICK + KEYBOARD)
mjr 35:e959ffba78fd 445 DEFAULT_CONFIGURATION, // bConfigurationValue
mjr 35:e959ffba78fd 446 0x00, // iConfiguration
mjr 35:e959ffba78fd 447 C_RESERVED | C_SELF_POWERED, // bmAttributes
mjr 35:e959ffba78fd 448 C_POWER(0), // bMaxPowerHello World from Mbed
mjr 35:e959ffba78fd 449
mjr 39:b3815a1c3802 450 // ***** INTERFACE 0 - JOYSTICK/LEDWIZ ******
mjr 35:e959ffba78fd 451 INTERFACE_DESCRIPTOR_LENGTH, // bLength
mjr 35:e959ffba78fd 452 INTERFACE_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 453 0x00, // bInterfaceNumber - first interface = 0
mjr 35:e959ffba78fd 454 0x00, // bAlternateSetting
mjr 35:e959ffba78fd 455 0x02, // bNumEndpoints
mjr 35:e959ffba78fd 456 HID_CLASS, // bInterfaceClass
mjr 35:e959ffba78fd 457 HID_SUBCLASS_NONE, // bInterfaceSubClass
mjr 35:e959ffba78fd 458 HID_PROTOCOL_NONE, // bInterfaceProtocol
mjr 35:e959ffba78fd 459 0x00, // iInterface
mjr 35:e959ffba78fd 460
mjr 35:e959ffba78fd 461 HID_DESCRIPTOR_LENGTH, // bLength
mjr 35:e959ffba78fd 462 HID_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 463 LSB(HID_VERSION_1_11), // bcdHID (LSB)
mjr 35:e959ffba78fd 464 MSB(HID_VERSION_1_11), // bcdHID (MSB)
mjr 35:e959ffba78fd 465 0x00, // bCountryCode
mjr 35:e959ffba78fd 466 0x01, // bNumDescriptors
mjr 35:e959ffba78fd 467 REPORT_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 468 LSB(rptlen0), // wDescriptorLength (LSB)
mjr 35:e959ffba78fd 469 MSB(rptlen0), // wDescriptorLength (MSB)
mjr 35:e959ffba78fd 470
mjr 35:e959ffba78fd 471 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
mjr 35:e959ffba78fd 472 ENDPOINT_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 473 PHY_TO_DESC(EPINT_IN), // bEndpointAddress - EPINT == EP1
mjr 35:e959ffba78fd 474 E_INTERRUPT, // bmAttributes
mjr 35:e959ffba78fd 475 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
mjr 35:e959ffba78fd 476 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
mjr 35:e959ffba78fd 477 1, // bInterval (milliseconds)
mjr 35:e959ffba78fd 478
mjr 35:e959ffba78fd 479 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
mjr 35:e959ffba78fd 480 ENDPOINT_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 481 PHY_TO_DESC(EPINT_OUT), // bEndpointAddress - EPINT == EP1
mjr 35:e959ffba78fd 482 E_INTERRUPT, // bmAttributes
mjr 35:e959ffba78fd 483 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
mjr 35:e959ffba78fd 484 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
mjr 35:e959ffba78fd 485 1, // bInterval (milliseconds)
mjr 35:e959ffba78fd 486
mjr 39:b3815a1c3802 487 // ****** INTERFACE 1 - KEYBOARD ******
mjr 35:e959ffba78fd 488 INTERFACE_DESCRIPTOR_LENGTH, // bLength
mjr 35:e959ffba78fd 489 INTERFACE_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 490 0x01, // bInterfaceNumber - second interface = 1
mjr 35:e959ffba78fd 491 0x00, // bAlternateSetting
mjr 35:e959ffba78fd 492 0x02, // bNumEndpoints
mjr 35:e959ffba78fd 493 HID_CLASS, // bInterfaceClass
mjr 35:e959ffba78fd 494 1, // bInterfaceSubClass - KEYBOARD
mjr 35:e959ffba78fd 495 1, // bInterfaceProtocol - KEYBOARD
mjr 35:e959ffba78fd 496 0x00, // iInterface
mjr 35:e959ffba78fd 497
mjr 35:e959ffba78fd 498 HID_DESCRIPTOR_LENGTH, // bLength
mjr 35:e959ffba78fd 499 HID_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 500 LSB(HID_VERSION_1_11), // bcdHID (LSB)
mjr 35:e959ffba78fd 501 MSB(HID_VERSION_1_11), // bcdHID (MSB)
mjr 35:e959ffba78fd 502 0x00, // bCountryCode
mjr 35:e959ffba78fd 503 0x01, // bNumDescriptors
mjr 35:e959ffba78fd 504 REPORT_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 505 LSB(rptlen1), // wDescriptorLength (LSB)
mjr 35:e959ffba78fd 506 MSB(rptlen1), // wDescriptorLength (MSB)
mjr 35:e959ffba78fd 507
mjr 35:e959ffba78fd 508 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
mjr 35:e959ffba78fd 509 ENDPOINT_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 510 PHY_TO_DESC(EP4IN), // bEndpointAddress
mjr 35:e959ffba78fd 511 E_INTERRUPT, // bmAttributes
mjr 35:e959ffba78fd 512 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
mjr 35:e959ffba78fd 513 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
mjr 35:e959ffba78fd 514 1, // bInterval (milliseconds)
mjr 35:e959ffba78fd 515
mjr 35:e959ffba78fd 516 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
mjr 35:e959ffba78fd 517 ENDPOINT_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 518 PHY_TO_DESC(EP4OUT), // bEndpointAddress
mjr 35:e959ffba78fd 519 E_INTERRUPT, // bmAttributes
mjr 35:e959ffba78fd 520 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
mjr 35:e959ffba78fd 521 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
mjr 35:e959ffba78fd 522 1, // bInterval (milliseconds)
mjr 35:e959ffba78fd 523 };
mjr 35:e959ffba78fd 524
mjr 35:e959ffba78fd 525 // Keyboard + joystick interfaces
mjr 35:e959ffba78fd 526 return configurationDescriptorWithKB;
mjr 35:e959ffba78fd 527 }
mjr 35:e959ffba78fd 528 else
mjr 35:e959ffba78fd 529 {
mjr 35:e959ffba78fd 530 // No keyboard - joystick interface only
mjr 35:e959ffba78fd 531 int cfglenNoKB = ((1 * CONFIGURATION_DESCRIPTOR_LENGTH)
mjr 35:e959ffba78fd 532 + (1 * INTERFACE_DESCRIPTOR_LENGTH)
mjr 35:e959ffba78fd 533 + (1 * HID_DESCRIPTOR_LENGTH)
mjr 35:e959ffba78fd 534 + (2 * ENDPOINT_DESCRIPTOR_LENGTH));
mjr 35:e959ffba78fd 535 static uint8_t configurationDescriptorNoKB[] =
mjr 35:e959ffba78fd 536 {
mjr 35:e959ffba78fd 537 CONFIGURATION_DESCRIPTOR_LENGTH,// bLength
mjr 35:e959ffba78fd 538 CONFIGURATION_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 539 LSB(cfglenNoKB), // wTotalLength (LSB)
mjr 35:e959ffba78fd 540 MSB(cfglenNoKB), // wTotalLength (MSB)
mjr 35:e959ffba78fd 541 0x01, // bNumInterfaces
mjr 35:e959ffba78fd 542 DEFAULT_CONFIGURATION, // bConfigurationValue
mjr 35:e959ffba78fd 543 0x00, // iConfiguration
mjr 35:e959ffba78fd 544 C_RESERVED | C_SELF_POWERED, // bmAttributes
mjr 35:e959ffba78fd 545 C_POWER(0), // bMaxPowerHello World from Mbed
mjr 35:e959ffba78fd 546
mjr 35:e959ffba78fd 547 INTERFACE_DESCRIPTOR_LENGTH, // bLength
mjr 35:e959ffba78fd 548 INTERFACE_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 549 0x00, // bInterfaceNumber
mjr 35:e959ffba78fd 550 0x00, // bAlternateSetting
mjr 35:e959ffba78fd 551 0x02, // bNumEndpoints
mjr 35:e959ffba78fd 552 HID_CLASS, // bInterfaceClass
mjr 35:e959ffba78fd 553 1, // bInterfaceSubClass
mjr 35:e959ffba78fd 554 1, // bInterfaceProtocol (keyboard)
mjr 35:e959ffba78fd 555 0x00, // iInterface
mjr 35:e959ffba78fd 556
mjr 35:e959ffba78fd 557 HID_DESCRIPTOR_LENGTH, // bLength
mjr 35:e959ffba78fd 558 HID_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 559 LSB(HID_VERSION_1_11), // bcdHID (LSB)
mjr 35:e959ffba78fd 560 MSB(HID_VERSION_1_11), // bcdHID (MSB)
mjr 35:e959ffba78fd 561 0x00, // bCountryCode
mjr 35:e959ffba78fd 562 0x01, // bNumDescriptors
mjr 35:e959ffba78fd 563 REPORT_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 564 (uint8_t)(LSB(rptlen0)), // wDescriptorLength (LSB)
mjr 35:e959ffba78fd 565 (uint8_t)(MSB(rptlen0)), // wDescriptorLength (MSB)
mjr 35:e959ffba78fd 566
mjr 35:e959ffba78fd 567 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
mjr 35:e959ffba78fd 568 ENDPOINT_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 569 PHY_TO_DESC(EPINT_IN), // bEndpointAddress
mjr 35:e959ffba78fd 570 E_INTERRUPT, // bmAttributes
mjr 35:e959ffba78fd 571 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
mjr 35:e959ffba78fd 572 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
mjr 35:e959ffba78fd 573 1, // bInterval (milliseconds)
mjr 35:e959ffba78fd 574
mjr 35:e959ffba78fd 575 ENDPOINT_DESCRIPTOR_LENGTH, // bLength
mjr 35:e959ffba78fd 576 ENDPOINT_DESCRIPTOR, // bDescriptorType
mjr 35:e959ffba78fd 577 PHY_TO_DESC(EPINT_OUT), // bEndpointAddress
mjr 35:e959ffba78fd 578 E_INTERRUPT, // bmAttributes
mjr 35:e959ffba78fd 579 LSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (LSB)
mjr 35:e959ffba78fd 580 MSB(MAX_PACKET_SIZE_EPINT), // wMaxPacketSize (MSB)
mjr 35:e959ffba78fd 581 1, // bInterval (milliseconds)
mjr 35:e959ffba78fd 582 };
mjr 35:e959ffba78fd 583
mjr 35:e959ffba78fd 584 return configurationDescriptorNoKB;
mjr 35:e959ffba78fd 585 }
mjr 35:e959ffba78fd 586 }
mjr 35:e959ffba78fd 587
mjr 35:e959ffba78fd 588 // Set the configuration. We need to set up the endpoints for
mjr 35:e959ffba78fd 589 // our active interfaces.
mjr 35:e959ffba78fd 590 bool USBJoystick::USBCallback_setConfiguration(uint8_t configuration)
mjr 35:e959ffba78fd 591 {
mjr 35:e959ffba78fd 592 // we only have one valid configuration
mjr 35:e959ffba78fd 593 if (configuration != DEFAULT_CONFIGURATION)
mjr 35:e959ffba78fd 594 return false;
mjr 35:e959ffba78fd 595
mjr 35:e959ffba78fd 596 // Configure endpoint 1 - we use this in all cases, for either
mjr 35:e959ffba78fd 597 // the combined joystick/ledwiz interface or just the ledwiz interface
mjr 35:e959ffba78fd 598 addEndpoint(EPINT_IN, MAX_PACKET_SIZE_EPINT);
mjr 35:e959ffba78fd 599 addEndpoint(EPINT_OUT, MAX_PACKET_SIZE_EPINT);
mjr 35:e959ffba78fd 600 readStart(EPINT_OUT, MAX_HID_REPORT_SIZE);
mjr 35:e959ffba78fd 601
mjr 35:e959ffba78fd 602 // if the keyboard is enabled, configure endpoint 4 for the kb interface
mjr 35:e959ffba78fd 603 if (useKB)
mjr 35:e959ffba78fd 604 {
mjr 35:e959ffba78fd 605 addEndpoint(EP4IN, MAX_PACKET_SIZE_EPINT);
mjr 35:e959ffba78fd 606 addEndpoint(EP4OUT, MAX_PACKET_SIZE_EPINT);
mjr 35:e959ffba78fd 607 readStart(EP4OUT, MAX_PACKET_SIZE_EPINT);
mjr 35:e959ffba78fd 608 }
mjr 35:e959ffba78fd 609
mjr 35:e959ffba78fd 610 // success
mjr 35:e959ffba78fd 611 return true;
mjr 35:e959ffba78fd 612 }
mjr 35:e959ffba78fd 613
mjr 38:091e511ce8a0 614 // Handle incoming messages on the joystick/LedWiz interface = endpoint 1.
mjr 38:091e511ce8a0 615 // This interface receives LedWiz protocol commands and commands using our
mjr 38:091e511ce8a0 616 // custom LedWiz protocol extensions.
mjr 38:091e511ce8a0 617 //
mjr 38:091e511ce8a0 618 // We simply queue the messages in our circular buffer for processing in
mjr 38:091e511ce8a0 619 // the main loop. The circular buffer object is designed for safe access
mjr 38:091e511ce8a0 620 // from the interrupt handler using the rule that only the interrupt
mjr 38:091e511ce8a0 621 // handler can change the write pointer, and only the regular code can
mjr 38:091e511ce8a0 622 // change the read pointer.
mjr 38:091e511ce8a0 623 bool USBJoystick::EP1_OUT_callback()
mjr 38:091e511ce8a0 624 {
mjr 38:091e511ce8a0 625 // Read this message
mjr 38:091e511ce8a0 626 union {
mjr 38:091e511ce8a0 627 LedWizMsg msg;
mjr 38:091e511ce8a0 628 uint8_t buf[MAX_HID_REPORT_SIZE];
mjr 38:091e511ce8a0 629 } buf;
mjr 38:091e511ce8a0 630 uint32_t bytesRead = 0;
mjr 38:091e511ce8a0 631 USBDevice::readEP(EP1OUT, buf.buf, &bytesRead, MAX_HID_REPORT_SIZE);
mjr 38:091e511ce8a0 632
mjr 39:b3815a1c3802 633 // printf("joy.read len=%d [%2x %2x %2x %2x %2x %2x %2x %2x], msg=[%2x %2x %2x %2x %2x %2x %2x %2x]\r\n", bytesRead,
mjr 39:b3815a1c3802 634 // buf.buf[0], buf.buf[1], buf.buf[2], buf.buf[3], buf.buf[4], buf.buf[5], buf.buf[6], buf.buf[7],
mjr 39:b3815a1c3802 635 // buf.msg.data[0], buf.msg.data[1], buf.msg.data[2], buf.msg.data[3], buf.msg.data[4], buf.msg.data[5], buf.msg.data[6], buf.msg.data[7]);
mjr 39:b3815a1c3802 636
mjr 38:091e511ce8a0 637 // if it's the right length, queue it to our circular buffer
mjr 38:091e511ce8a0 638 if (bytesRead == 8)
mjr 38:091e511ce8a0 639 lwbuf.write(buf.msg);
mjr 38:091e511ce8a0 640
mjr 38:091e511ce8a0 641 // start the next read
mjr 39:b3815a1c3802 642 return readStart(EP1OUT, MAX_HID_REPORT_SIZE);
mjr 38:091e511ce8a0 643 }
mjr 38:091e511ce8a0 644
mjr 38:091e511ce8a0 645 // Handle incoming messages on the keyboard interface = endpoint 4.
mjr 35:e959ffba78fd 646 // The host uses this to send updates for the keyboard indicator LEDs
mjr 35:e959ffba78fd 647 // (caps lock, num lock, etc). We don't do anything with these, but
mjr 37:ed52738445fc 648 // we have to read them to keep the pipe open.
mjr 35:e959ffba78fd 649 bool USBJoystick::EP4_OUT_callback()
mjr 35:e959ffba78fd 650 {
mjr 35:e959ffba78fd 651 // read this message
mjr 35:e959ffba78fd 652 uint32_t bytesRead = 0;
mjr 37:ed52738445fc 653 uint8_t led[MAX_HID_REPORT_SIZE];
mjr 35:e959ffba78fd 654 USBDevice::readEP(EP4OUT, led, &bytesRead, MAX_HID_REPORT_SIZE);
mjr 35:e959ffba78fd 655
mjr 35:e959ffba78fd 656 // start the next read
mjr 35:e959ffba78fd 657 return readStart(EP4OUT, MAX_HID_REPORT_SIZE);
mjr 35:e959ffba78fd 658 }
mjr 39:b3815a1c3802 659