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@54:fd77a6b2f76c, 2016-04-30 (annotated)

Committer:
mjr
Date:
Sat Apr 30 17:43:38 2016 +0000
Revision:
54:fd77a6b2f76c
Parent:
53:9b2611964afc
Child:
61:3c7e6e9ec355
TLC5940 with SPI DMA setup in interrupt handler (not quite working)

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