Mike R / Mbed 2 deprecated Pinscape_Controller_V2

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

Fork of Pinscape_Controller by Mike R

USBJoystick/USBJoystick.cpp@52:8298b2a73eb2, 2016-03-05 (annotated)

Committer:
mjr
Date:
Sat Mar 05 00:16:52 2016 +0000
Revision:
52:8298b2a73eb2
Parent:
48:058ace2aed1d
Child:
53:9b2611964afc
New calibration procedure - attempt #1, with separate calibration release sensingi

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