gcc4mbed/samples/MSTest/USBDevice/USBHID/USBMouseKeyboard.cpp

   1 /* Copyright (c) 2010-2011 mbed.org, MIT License
   2 *
   3 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
   4 * and associated documentation files (the "Software"), to deal in the Software without
   5 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
   6 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
   7 * Software is furnished to do so, subject to the following conditions:
   8 *
   9 * The above copyright notice and this permission notice shall be included in all copies or
  10 * substantial portions of the Software.
  11 *
  12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
  13 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  14 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  15 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  16 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  17 */
  18
  19 #include "stdint.h"
  20 #include "USBMouseKeyboard.h"
  21
  22 typedef struct {
  23     unsigned char usage;
  24     unsigned char modifier;
  25 } KEYMAP;
  26
  27 #ifdef US_KEYBOARD
  28 /* US keyboard (as HID standard) */
  29 #define KEYMAP_SIZE (148)
  30 const KEYMAP keymap[KEYMAP_SIZE] = {
  31     {0, 0},             /* NUL */
  32     {0, 0},             /* SOH */
  33     {0, 0},             /* STX */
  34     {0, 0},             /* ETX */
  35     {0, 0},             /* EOT */
  36     {0, 0},             /* ENQ */
  37     {0, 0},             /* ACK */
  38     {0, 0},             /* BEL */
  39     {0x2a, 0},          /* BS  */  /* Keyboard Delete (Backspace) */
  40     {0x2b, 0},          /* TAB */  /* Keyboard Tab */
  41     {0x28, 0},          /* LF  */  /* Keyboard Return (Enter) */
  42     {0, 0},             /* VT  */
  43     {0, 0},             /* FF  */
  44     {0, 0},             /* CR  */
  45     {0, 0},             /* SO  */
  46     {0, 0},             /* SI  */
  47     {0, 0},             /* DEL */
  48     {0, 0},             /* DC1 */
  49     {0, 0},             /* DC2 */
  50     {0, 0},             /* DC3 */
  51     {0, 0},             /* DC4 */
  52     {0, 0},             /* NAK */
  53     {0, 0},             /* SYN */
  54     {0, 0},             /* ETB */
  55     {0, 0},             /* CAN */
  56     {0, 0},             /* EM  */
  57     {0, 0},             /* SUB */
  58     {0, 0},             /* ESC */
  59     {0, 0},             /* FS  */
  60     {0, 0},             /* GS  */
  61     {0, 0},             /* RS  */
  62     {0, 0},             /* US  */
  63     {0x2c, 0},          /*   */
  64     {0x1e, KEY_SHIFT},      /* ! */
  65     {0x34, KEY_SHIFT},      /* " */
  66     {0x20, KEY_SHIFT},      /* # */
  67     {0x21, KEY_SHIFT},      /* $ */
  68     {0x22, KEY_SHIFT},      /* % */
  69     {0x24, KEY_SHIFT},      /* & */
  70     {0x34, 0},          /* ' */
  71     {0x26, KEY_SHIFT},      /* ( */
  72     {0x27, KEY_SHIFT},      /* ) */
  73     {0x25, KEY_SHIFT},      /* * */
  74     {0x2e, KEY_SHIFT},      /* + */
  75     {0x36, 0},          /* , */
  76     {0x2d, 0},          /* - */
  77     {0x37, 0},          /* . */
  78     {0x38, 0},          /* / */
  79     {0x27, 0},          /* 0 */
  80     {0x1e, 0},          /* 1 */
  81     {0x1f, 0},          /* 2 */
  82     {0x20, 0},          /* 3 */
  83     {0x21, 0},          /* 4 */
  84     {0x22, 0},          /* 5 */
  85     {0x23, 0},          /* 6 */
  86     {0x24, 0},          /* 7 */
  87     {0x25, 0},          /* 8 */
  88     {0x26, 0},          /* 9 */
  89     {0x33, KEY_SHIFT},      /* : */
  90     {0x33, 0},          /* ; */
  91     {0x36, KEY_SHIFT},      /* < */
  92     {0x2e, 0},          /* = */
  93     {0x37, KEY_SHIFT},      /* > */
  94     {0x38, KEY_SHIFT},      /* ? */
  95     {0x1f, KEY_SHIFT},      /* @ */
  96     {0x04, KEY_SHIFT},      /* A */
  97     {0x05, KEY_SHIFT},      /* B */
  98     {0x06, KEY_SHIFT},      /* C */
  99     {0x07, KEY_SHIFT},      /* D */
 100     {0x08, KEY_SHIFT},      /* E */
 101     {0x09, KEY_SHIFT},      /* F */
 102     {0x0a, KEY_SHIFT},      /* G */
 103     {0x0b, KEY_SHIFT},      /* H */
 104     {0x0c, KEY_SHIFT},      /* I */
 105     {0x0d, KEY_SHIFT},      /* J */
 106     {0x0e, KEY_SHIFT},      /* K */
 107     {0x0f, KEY_SHIFT},      /* L */
 108     {0x10, KEY_SHIFT},      /* M */
 109     {0x11, KEY_SHIFT},      /* N */
 110     {0x12, KEY_SHIFT},      /* O */
 111     {0x13, KEY_SHIFT},      /* P */
 112     {0x14, KEY_SHIFT},      /* Q */
 113     {0x15, KEY_SHIFT},      /* R */
 114     {0x16, KEY_SHIFT},      /* S */
 115     {0x17, KEY_SHIFT},      /* T */
 116     {0x18, KEY_SHIFT},      /* U */
 117     {0x19, KEY_SHIFT},      /* V */
 118     {0x1a, KEY_SHIFT},      /* W */
 119     {0x1b, KEY_SHIFT},      /* X */
 120     {0x1c, KEY_SHIFT},      /* Y */
 121     {0x1d, KEY_SHIFT},      /* Z */
 122     {0x2f, 0},          /* [ */
 123     {0x31, 0},          /* \ */
 124     {0x30, 0},          /* ] */
 125     {0x23, KEY_SHIFT},      /* ^ */
 126     {0x2d, KEY_SHIFT},      /* _ */
 127     {0x35, 0},          /* ` */
 128     {0x04, 0},          /* a */
 129     {0x05, 0},          /* b */
 130     {0x06, 0},          /* c */
 131     {0x07, 0},          /* d */
 132     {0x08, 0},          /* e */
 133     {0x09, 0},          /* f */
 134     {0x0a, 0},          /* g */
 135     {0x0b, 0},          /* h */
 136     {0x0c, 0},          /* i */
 137     {0x0d, 0},          /* j */
 138     {0x0e, 0},          /* k */
 139     {0x0f, 0},          /* l */
 140     {0x10, 0},          /* m */
 141     {0x11, 0},          /* n */
 142     {0x12, 0},          /* o */
 143     {0x13, 0},          /* p */
 144     {0x14, 0},          /* q */
 145     {0x15, 0},          /* r */
 146     {0x16, 0},          /* s */
 147     {0x17, 0},          /* t */
 148     {0x18, 0},          /* u */
 149     {0x19, 0},          /* v */
 150     {0x1a, 0},          /* w */
 151     {0x1b, 0},          /* x */
 152     {0x1c, 0},          /* y */
 153     {0x1d, 0},          /* z */
 154     {0x2f, KEY_SHIFT},      /* { */
 155     {0x31, KEY_SHIFT},      /* | */
 156     {0x30, KEY_SHIFT},      /* } */
 157     {0x35, KEY_SHIFT},      /* ~ */
 158     {0,0},              /* DEL */
 159
 160     {0x3a, 0},          /* F1 */
 161     {0x3b, 0},          /* F2 */
 162     {0x3c, 0},          /* F3 */
 163     {0x3d, 0},          /* F4 */
 164     {0x3e, 0},          /* F5 */
 165     {0x3f, 0},          /* F6 */
 166     {0x40, 0},          /* F7 */
 167     {0x41, 0},          /* F8 */
 168     {0x42, 0},          /* F9 */
 169     {0x43, 0},          /* F10 */
 170     {0x44, 0},          /* F11 */
 171     {0x45, 0},          /* F12 */
 172
 173     {0x46, 0},          /* PRINT_SCREEN */
 174     {0x47, 0},          /* SCROLL_LOCK */
 175     {0x39, 0},          /* CAPS_LOCK */
 176     {0x53, 0},          /* NUM_LOCK */
 177     {0x49, 0},          /* INSERT */
 178     {0x4a, 0},          /* HOME */
 179     {0x4b, 0},          /* PAGE_UP */
 180     {0x4e, 0},          /* PAGE_DOWN */
 181 };
 182
 183 #else
 184 /* UK keyboard */
 185 #define KEYMAP_SIZE (148)
 186 const KEYMAP keymap[KEYMAP_SIZE] = {
 187     {0, 0},             /* NUL */
 188     {0, 0},             /* SOH */
 189     {0, 0},             /* STX */
 190     {0, 0},             /* ETX */
 191     {0, 0},             /* EOT */
 192     {0, 0},             /* ENQ */
 193     {0, 0},             /* ACK */
 194     {0, 0},             /* BEL */
 195     {0x2a, 0},          /* BS  */  /* Keyboard Delete (Backspace) */
 196     {0x2b, 0},          /* TAB */  /* Keyboard Tab */
 197     {0x28, 0},          /* LF  */  /* Keyboard Return (Enter) */
 198     {0, 0},             /* VT  */
 199     {0, 0},             /* FF  */
 200     {0, 0},             /* CR  */
 201     {0, 0},             /* SO  */
 202     {0, 0},             /* SI  */
 203     {0, 0},             /* DEL */
 204     {0, 0},             /* DC1 */
 205     {0, 0},             /* DC2 */
 206     {0, 0},             /* DC3 */
 207     {0, 0},             /* DC4 */
 208     {0, 0},             /* NAK */
 209     {0, 0},             /* SYN */
 210     {0, 0},             /* ETB */
 211     {0, 0},             /* CAN */
 212     {0, 0},             /* EM  */
 213     {0, 0},             /* SUB */
 214     {0, 0},             /* ESC */
 215     {0, 0},             /* FS  */
 216     {0, 0},             /* GS  */
 217     {0, 0},             /* RS  */
 218     {0, 0},             /* US  */
 219     {0x2c, 0},          /*   */
 220     {0x1e, KEY_SHIFT},      /* ! */
 221     {0x1f, KEY_SHIFT},      /* " */
 222     {0x32, 0},          /* # */
 223     {0x21, KEY_SHIFT},      /* $ */
 224     {0x22, KEY_SHIFT},      /* % */
 225     {0x24, KEY_SHIFT},      /* & */
 226     {0x34, 0},          /* ' */
 227     {0x26, KEY_SHIFT},      /* ( */
 228     {0x27, KEY_SHIFT},      /* ) */
 229     {0x25, KEY_SHIFT},      /* * */
 230     {0x2e, KEY_SHIFT},      /* + */
 231     {0x36, 0},          /* , */
 232     {0x2d, 0},          /* - */
 233     {0x37, 0},          /* . */
 234     {0x38, 0},          /* / */
 235     {0x27, 0},          /* 0 */
 236     {0x1e, 0},          /* 1 */
 237     {0x1f, 0},          /* 2 */
 238     {0x20, 0},          /* 3 */
 239     {0x21, 0},          /* 4 */
 240     {0x22, 0},          /* 5 */
 241     {0x23, 0},          /* 6 */
 242     {0x24, 0},          /* 7 */
 243     {0x25, 0},          /* 8 */
 244     {0x26, 0},          /* 9 */
 245     {0x33, KEY_SHIFT},      /* : */
 246     {0x33, 0},          /* ; */
 247     {0x36, KEY_SHIFT},      /* < */
 248     {0x2e, 0},          /* = */
 249     {0x37, KEY_SHIFT},      /* > */
 250     {0x38, KEY_SHIFT},      /* ? */
 251     {0x34, KEY_SHIFT},      /* @ */
 252     {0x04, KEY_SHIFT},      /* A */
 253     {0x05, KEY_SHIFT},      /* B */
 254     {0x06, KEY_SHIFT},      /* C */
 255     {0x07, KEY_SHIFT},      /* D */
 256     {0x08, KEY_SHIFT},      /* E */
 257     {0x09, KEY_SHIFT},      /* F */
 258     {0x0a, KEY_SHIFT},      /* G */
 259     {0x0b, KEY_SHIFT},      /* H */
 260     {0x0c, KEY_SHIFT},      /* I */
 261     {0x0d, KEY_SHIFT},      /* J */
 262     {0x0e, KEY_SHIFT},      /* K */
 263     {0x0f, KEY_SHIFT},      /* L */
 264     {0x10, KEY_SHIFT},      /* M */
 265     {0x11, KEY_SHIFT},      /* N */
 266     {0x12, KEY_SHIFT},      /* O */
 267     {0x13, KEY_SHIFT},      /* P */
 268     {0x14, KEY_SHIFT},      /* Q */
 269     {0x15, KEY_SHIFT},      /* R */
 270     {0x16, KEY_SHIFT},      /* S */
 271     {0x17, KEY_SHIFT},      /* T */
 272     {0x18, KEY_SHIFT},      /* U */
 273     {0x19, KEY_SHIFT},      /* V */
 274     {0x1a, KEY_SHIFT},      /* W */
 275     {0x1b, KEY_SHIFT},      /* X */
 276     {0x1c, KEY_SHIFT},      /* Y */
 277     {0x1d, KEY_SHIFT},      /* Z */
 278     {0x2f, 0},          /* [ */
 279     {0x64, 0},          /* \ */
 280     {0x30, 0},          /* ] */
 281     {0x23, KEY_SHIFT},      /* ^ */
 282     {0x2d, KEY_SHIFT},      /* _ */
 283     {0x35, 0},          /* ` */
 284     {0x04, 0},          /* a */
 285     {0x05, 0},          /* b */
 286     {0x06, 0},          /* c */
 287     {0x07, 0},          /* d */
 288     {0x08, 0},          /* e */
 289     {0x09, 0},          /* f */
 290     {0x0a, 0},          /* g */
 291     {0x0b, 0},          /* h */
 292     {0x0c, 0},          /* i */
 293     {0x0d, 0},          /* j */
 294     {0x0e, 0},          /* k */
 295     {0x0f, 0},          /* l */
 296     {0x10, 0},          /* m */
 297     {0x11, 0},          /* n */
 298     {0x12, 0},          /* o */
 299     {0x13, 0},          /* p */
 300     {0x14, 0},          /* q */
 301     {0x15, 0},          /* r */
 302     {0x16, 0},          /* s */
 303     {0x17, 0},          /* t */
 304     {0x18, 0},          /* u */
 305     {0x19, 0},          /* v */
 306     {0x1a, 0},          /* w */
 307     {0x1b, 0},          /* x */
 308     {0x1c, 0},          /* y */
 309     {0x1d, 0},          /* z */
 310     {0x2f, KEY_SHIFT},      /* { */
 311     {0x64, KEY_SHIFT},      /* | */
 312     {0x30, KEY_SHIFT},      /* } */
 313     {0x32, KEY_SHIFT},      /* ~ */
 314     {0,0},             /* DEL */
 315
 316     {0x3a, 0},          /* F1 */
 317     {0x3b, 0},          /* F2 */
 318     {0x3c, 0},          /* F3 */
 319     {0x3d, 0},          /* F4 */
 320     {0x3e, 0},          /* F5 */
 321     {0x3f, 0},          /* F6 */
 322     {0x40, 0},          /* F7 */
 323     {0x41, 0},          /* F8 */
 324     {0x42, 0},          /* F9 */
 325     {0x43, 0},          /* F10 */
 326     {0x44, 0},          /* F11 */
 327     {0x45, 0},          /* F12 */
 328
 329     {0x46, 0},          /* PRINT_SCREEN */
 330     {0x47, 0},          /* SCROLL_LOCK */
 331     {0x39, 0},          /* CAPS_LOCK */
 332     {0x53, 0},          /* NUM_LOCK */
 333     {0x49, 0},          /* INSERT */
 334     {0x4a, 0},          /* HOME */
 335     {0x4b, 0},          /* PAGE_UP */
 336     {0x4e, 0},          /* PAGE_DOWN */
 337 };
 338 #endif
 339
 340
 341 uint8_t * USBMouseKeyboard::reportDesc() {
 342     if (mouse_type == REL_MOUSE) {
 343         static uint8_t reportDescriptor[] = {
 344                 // Keyboard
 345                 USAGE_PAGE(1),      0x01,
 346                 USAGE(1),           0x06,
 347                 COLLECTION(1),      0x01,
 348                 REPORT_ID(1),       REPORT_ID_KEYBOARD,
 349                 USAGE_PAGE(1),      0x07,
 350                 USAGE_MINIMUM(1),       0xE0,
 351                 USAGE_MAXIMUM(1),       0xE7,
 352                 LOGICAL_MINIMUM(1),     0x00,
 353                 LOGICAL_MAXIMUM(1),     0x01,
 354                 REPORT_SIZE(1),     0x01,
 355                 REPORT_COUNT(1),    0x08,
 356                 INPUT(1),           0x02,
 357                 REPORT_COUNT(1),    0x01,
 358                 REPORT_SIZE(1),     0x08,
 359                 INPUT(1),           0x01,
 360                 REPORT_COUNT(1),    0x05,
 361                 REPORT_SIZE(1),     0x01,
 362                 USAGE_PAGE(1),      0x08,
 363                 USAGE_MINIMUM(1),       0x01,
 364                 USAGE_MAXIMUM(1),       0x05,
 365                 OUTPUT(1),          0x02,
 366                 REPORT_COUNT(1),    0x01,
 367                 REPORT_SIZE(1),     0x03,
 368                 OUTPUT(1),          0x01,
 369                 REPORT_COUNT(1),    0x06,
 370                 REPORT_SIZE(1),     0x08,
 371                 LOGICAL_MINIMUM(1),     0x00,
 372                 LOGICAL_MAXIMUM(2),     0xff, 0x00,
 373                 USAGE_PAGE(1),      0x07,
 374                 USAGE_MINIMUM(1),       0x00,
 375                 USAGE_MAXIMUM(2),       0xff, 0x00,
 376                 INPUT(1),           0x00,
 377                 END_COLLECTION(0),
 378
 379                 // Mouse
 380                 USAGE_PAGE(1),      0x01,           // Generic Desktop
 381                 USAGE(1),           0x02,           // Mouse
 382                 COLLECTION(1),      0x01,           // Application
 383                 USAGE(1),           0x01,           // Pointer
 384                 COLLECTION(1),      0x00,           // Physical
 385                 REPORT_ID(1),       REPORT_ID_MOUSE,
 386                 REPORT_COUNT(1),    0x03,
 387                 REPORT_SIZE(1),     0x01,
 388                 USAGE_PAGE(1),      0x09,           // Buttons
 389                 USAGE_MINIMUM(1),       0x1,
 390                 USAGE_MAXIMUM(1),       0x3,
 391                 LOGICAL_MINIMUM(1),     0x00,
 392                 LOGICAL_MAXIMUM(1),     0x01,
 393                 INPUT(1),           0x02,
 394                 REPORT_COUNT(1),    0x01,
 395                 REPORT_SIZE(1),     0x05,
 396                 INPUT(1),           0x01,
 397                 REPORT_COUNT(1),    0x03,
 398                 REPORT_SIZE(1),     0x08,
 399                 USAGE_PAGE(1),      0x01,
 400                 USAGE(1),           0x30,           // X
 401                 USAGE(1),           0x31,           // Y
 402                 USAGE(1),           0x38,           // scroll
 403                 LOGICAL_MINIMUM(1),     0x81,
 404                 LOGICAL_MAXIMUM(1),     0x7f,
 405                 INPUT(1),           0x06,
 406                 END_COLLECTION(0),
 407                 END_COLLECTION(0),
 408
 409
 410                 // Media Control
 411                 USAGE_PAGE(1), 0x0C,
 412                 USAGE(1), 0x01,
 413                 COLLECTION(1), 0x01,
 414                 REPORT_ID(1), REPORT_ID_VOLUME,
 415                 USAGE_PAGE(1), 0x0C,
 416                 LOGICAL_MINIMUM(1), 0x00,
 417                 LOGICAL_MAXIMUM(1), 0x01,
 418                 REPORT_SIZE(1), 0x01,
 419                 REPORT_COUNT(1), 0x07,
 420                 USAGE(1), 0xB5,             // Next Track
 421                 USAGE(1), 0xB6,             // Previous Track
 422                 USAGE(1), 0xB7,             // Stop
 423                 USAGE(1), 0xCD,             // Play / Pause
 424                 USAGE(1), 0xE2,             // Mute
 425                 USAGE(1), 0xE9,             // Volume Up
 426                 USAGE(1), 0xEA,             // Volume Down
 427                 INPUT(1), 0x02,             // Input (Data, Variable, Absolute)
 428                 REPORT_COUNT(1), 0x01,
 429                 INPUT(1), 0x01,
 430                 END_COLLECTION(0),
 431         };
 432         reportLength = sizeof(reportDescriptor);
 433         return reportDescriptor;
 434     } else if (mouse_type == ABS_MOUSE) {
 435         static uint8_t reportDescriptor[] = {
 436
 437                 // Keyboard
 438                 USAGE_PAGE(1),      0x01,
 439                 USAGE(1),           0x06,
 440                 COLLECTION(1),      0x01,
 441                 REPORT_ID(1),       REPORT_ID_KEYBOARD,
 442                 USAGE_PAGE(1),      0x07,
 443                 USAGE_MINIMUM(1),       0xE0,
 444                 USAGE_MAXIMUM(1),       0xE7,
 445                 LOGICAL_MINIMUM(1),     0x00,
 446                 LOGICAL_MAXIMUM(1),     0x01,
 447                 REPORT_SIZE(1),     0x01,
 448                 REPORT_COUNT(1),    0x08,
 449                 INPUT(1),           0x02,
 450                 REPORT_COUNT(1),    0x01,
 451                 REPORT_SIZE(1),     0x08,
 452                 INPUT(1),           0x01,
 453                 REPORT_COUNT(1),    0x05,
 454                 REPORT_SIZE(1),     0x01,
 455                 USAGE_PAGE(1),      0x08,
 456                 USAGE_MINIMUM(1),       0x01,
 457                 USAGE_MAXIMUM(1),       0x05,
 458                 OUTPUT(1),          0x02,
 459                 REPORT_COUNT(1),    0x01,
 460                 REPORT_SIZE(1),     0x03,
 461                 OUTPUT(1),          0x01,
 462                 REPORT_COUNT(1),    0x06,
 463                 REPORT_SIZE(1),     0x08,
 464                 LOGICAL_MINIMUM(1),     0x00,
 465                 LOGICAL_MAXIMUM(2),     0xff, 0x00,
 466                 USAGE_PAGE(1),      0x07,
 467                 USAGE_MINIMUM(1),       0x00,
 468                 USAGE_MAXIMUM(2),       0xff, 0x00,
 469                 INPUT(1),           0x00,
 470                 END_COLLECTION(0),
 471
 472                 // Mouse
 473                 USAGE_PAGE(1), 0x01,               // Generic Desktop
 474                 USAGE(1), 0x02,                    // Mouse
 475                 COLLECTION(1), 0x01,               // Application
 476                 USAGE(1), 0x01,                    // Pointer
 477                 COLLECTION(1), 0x00,               // Physical
 478                 REPORT_ID(1),       REPORT_ID_MOUSE,
 479
 480                 USAGE_PAGE(1), 0x01,                // Generic Desktop
 481                 USAGE(1), 0x30,                     // X
 482                 USAGE(1), 0x31,                     // Y
 483                 LOGICAL_MINIMUM(1), 0x00,           // 0
 484                 LOGICAL_MAXIMUM(2), 0xff, 0x7f,     // 32767
 485                 REPORT_SIZE(1), 0x10,
 486                 REPORT_COUNT(1), 0x02,
 487                 INPUT(1), 0x02,                     // Data, Variable, Absolute
 488
 489                 USAGE_PAGE(1), 0x01,                // Generic Desktop
 490                 USAGE(1), 0x38,                     // scroll
 491                 LOGICAL_MINIMUM(1), 0x81,           // -127
 492                 LOGICAL_MAXIMUM(1), 0x7f,           // 127
 493                 REPORT_SIZE(1), 0x08,
 494                 REPORT_COUNT(1), 0x01,
 495                 INPUT(1), 0x06,                     // Data, Variable, Relative
 496
 497                 USAGE_PAGE(1), 0x09,                // Buttons
 498                 USAGE_MINIMUM(1), 0x01,
 499                 USAGE_MAXIMUM(1), 0x03,
 500                 LOGICAL_MINIMUM(1), 0x00,           // 0
 501                 LOGICAL_MAXIMUM(1), 0x01,           // 1
 502                 REPORT_COUNT(1), 0x03,
 503                 REPORT_SIZE(1), 0x01,
 504                 INPUT(1), 0x02,                     // Data, Variable, Absolute
 505                 REPORT_COUNT(1), 0x01,
 506                 REPORT_SIZE(1), 0x05,
 507                 INPUT(1), 0x01,                     // Constant
 508
 509                 END_COLLECTION(0),
 510                 END_COLLECTION(0),
 511
 512                 // Media Control
 513                 USAGE_PAGE(1), 0x0C,
 514                 USAGE(1), 0x01,
 515                 COLLECTION(1), 0x01,
 516                 REPORT_ID(1), REPORT_ID_VOLUME,
 517                 USAGE_PAGE(1), 0x0C,
 518                 LOGICAL_MINIMUM(1), 0x00,
 519                 LOGICAL_MAXIMUM(1), 0x01,
 520                 REPORT_SIZE(1), 0x01,
 521                 REPORT_COUNT(1), 0x07,
 522                 USAGE(1), 0xB5,             // Next Track
 523                 USAGE(1), 0xB6,             // Previous Track
 524                 USAGE(1), 0xB7,             // Stop
 525                 USAGE(1), 0xCD,             // Play / Pause
 526                 USAGE(1), 0xE2,             // Mute
 527                 USAGE(1), 0xE9,             // Volume Up
 528                 USAGE(1), 0xEA,             // Volume Down
 529                 INPUT(1), 0x02,             // Input (Data, Variable, Absolute)
 530                 REPORT_COUNT(1), 0x01,
 531                 INPUT(1), 0x01,
 532                 END_COLLECTION(0),
 533         };
 534         reportLength = sizeof(reportDescriptor);
 535         return reportDescriptor;
 536     }
 537
 538     return NULL;
 539 }
 540
 541 bool USBMouseKeyboard::EP1_OUT_callback() {
 542     uint16_t bytesRead = 0;
 543     uint8_t led[65];
 544     USBDevice::readEP(EPINT_OUT, led, &bytesRead, MAX_HID_REPORT_SIZE);
 545
 546     // we take led[1] because led[0] is the report ID
 547     lock_status = led[1] & 0x07;
 548
 549     // We activate the endpoint to be able to recceive data
 550     if (!readStart(EPINT_OUT, MAX_HID_REPORT_SIZE))
 551         return false;
 552     return true;
 553 }
 554
 555 uint8_t USBMouseKeyboard::lockStatus() {
 556     return lock_status;
 557 }
 558
 559 bool USBMouseKeyboard::update(int16_t x, int16_t y, uint8_t button, int8_t z) {
 560     switch (mouse_type) {
 561     case REL_MOUSE:
 562         while (x > 127) {
 563             if (!mouseSend(127, 0, button, z)) return false;
 564             x = x - 127;
 565         }
 566         while (x < -128) {
 567             if (!mouseSend(-128, 0, button, z)) return false;
 568             x = x + 128;
 569         }
 570         while (y > 127) {
 571             if (!mouseSend(0, 127, button, z)) return false;
 572             y = y - 127;
 573         }
 574         while (y < -128) {
 575             if (!mouseSend(0, -128, button, z)) return false;
 576             y = y + 128;
 577         }
 578         return mouseSend(x, y, button, z);
 579     case ABS_MOUSE:
 580         HID_REPORT report;
 581
 582         report.data[0] = REPORT_ID_MOUSE;
 583         report.data[1] = x & 0xff;
 584         report.data[2] = (x >> 8) & 0xff;
 585         report.data[3] = y & 0xff;
 586         report.data[4] = (y >> 8) & 0xff;
 587         report.data[5] = -z;
 588         report.data[6] = button & 0x07;
 589
 590         report.length = 7;
 591
 592         return send(&report);
 593     default:
 594         return false;
 595     }
 596 }
 597
 598 bool USBMouseKeyboard::mouseSend(int8_t x, int8_t y, uint8_t buttons, int8_t z) {
 599     HID_REPORT report;
 600     report.data[0] = REPORT_ID_MOUSE;
 601     report.data[1] = buttons & 0x07;
 602     report.data[2] = x;
 603     report.data[3] = y;
 604     report.data[4] = -z; // >0 to scroll down, <0 to scroll up
 605
 606     report.length = 5;
 607
 608     return send(&report);
 609 }
 610
 611 bool USBMouseKeyboard::move(int16_t x, int16_t y) {
 612     return update(x, y, button, 0);
 613 }
 614
 615 bool USBMouseKeyboard::scroll(int8_t z) {
 616     return update(0, 0, button, z);
 617 }
 618
 619 bool USBMouseKeyboard::doubleClick() {
 620     if (!click(MOUSE_LEFT))
 621         return false;
 622     wait(0.1);
 623     return click(MOUSE_LEFT);
 624 }
 625
 626 bool USBMouseKeyboard::click(uint8_t button) {
 627     if (!update(0, 0, button, 0))
 628         return false;
 629     wait(0.01);
 630     return update(0, 0, 0, 0);
 631 }
 632
 633 bool USBMouseKeyboard::press(uint8_t button_) {
 634     button = button_ & 0x07;
 635     return update(0, 0, button, 0);
 636 }
 637
 638 bool USBMouseKeyboard::release(uint8_t button_) {
 639     button = (button & (~button_)) & 0x07;
 640     return update(0, 0, button, 0);
 641 }
 642
 643 int USBMouseKeyboard::_putc(int c) {
 644     return keyCode(c, keymap[c].modifier);
 645 }
 646
 647 bool USBMouseKeyboard::keyCode(uint8_t key, uint8_t modifier) {
 648     // Send a simulated keyboard keypress. Returns true if successful.
 649
 650     HID_REPORT report;
 651
 652     report.data[0] = REPORT_ID_KEYBOARD;
 653     report.data[1] = modifier;
 654     report.data[2] = 0;
 655     report.data[3] = keymap[key].usage;
 656     report.data[4] = 0;
 657     report.data[5] = 0;
 658     report.data[6] = 0;
 659     report.data[7] = 0;
 660     report.data[8] = 0;
 661
 662     report.length = 9;
 663
 664     if (!send(&report)) {
 665         return false;
 666     }
 667
 668     report.data[1] = 0;
 669     report.data[3] = 0;
 670
 671     if (!send(&report)) {
 672         return false;
 673     }
 674
 675     return true;
 676
 677 }
 678
 679
 680 bool USBMouseKeyboard::mediaControl(MEDIA_KEY key) {
 681     HID_REPORT report;
 682
 683     report.data[0] = REPORT_ID_VOLUME;
 684     report.data[1] = (1 << key) & 0x7f;
 685
 686     report.length = 2;
 687
 688     send(&report);
 689
 690     report.data[0] = REPORT_ID_VOLUME;
 691     report.data[1] = 0;
 692
 693     report.length = 2;
 694
 695     return send(&report);
 696 }