Arnaud VALLEY / Mbed 2 deprecated Pinscape_Controller_V2_arnoz

Mirror with some correction

Dependencies:   mbed FastIO FastPWM USBDevice

USBJoystick/USBJoystick.cpp@116:7a67265d7c19, 2021-10-01 (annotated)

Committer:
arnoz
Date:
Fri Oct 01 08:19:46 2021 +0000
Revision:
116:7a67265d7c19
Parent:
113:7330439f2ffc 
- Correct information regarding your last merge

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