Arnaud VALLEY / Mbed 2 deprecated Pinscape_Controller_V2_arnoz

Mirror with some correction

Dependencies:   mbed FastIO FastPWM USBDevice

USBJoystick/USBJoystick.cpp@77:0b96f6867312, 2017-03-17 (annotated)

Committer:
mjr
Date:
Fri Mar 17 22:02:08 2017 +0000
Revision:
77:0b96f6867312
Parent:
75:677892300e7a
Child:
78:1e00b3fa11af
New memory pool management; keeping old ones as #ifdefs for now for reference.

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