USBMouseKeyboard.cpp

00001 /* Copyright (c) 2010-2011 mbed.org, MIT License
00002 *
00003 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
00004 * and associated documentation files (the "Software"), to deal in the Software without
00005 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
00006 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
00007 * Software is furnished to do so, subject to the following conditions:
00008 *
00009 * The above copyright notice and this permission notice shall be included in all copies or
00010 * substantial portions of the Software.
00011 *
00012 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
00013 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
00014 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
00015 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00016 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00017 */
00018 
00019 #include "stdint.h"
00020 #include "USBMouseKeyboard.h"
00021 
00022 typedef struct
00023 {
00024     unsigned char usage;
00025     unsigned char modifier;
00026 } KEYMAP;
00027 
00028 #ifdef US_KEYBOARD
00029 /* US keyboard (as HID standard) */
00030 #define KEYMAP_SIZE (152)
00031 const KEYMAP keymap[KEYMAP_SIZE] =
00032 {
00033     {0, 0},             /* NUL */
00034     {0, 0},             /* SOH */
00035     {0, 0},             /* STX */
00036     {0, 0},             /* ETX */
00037     {0, 0},             /* EOT */
00038     {0, 0},             /* ENQ */
00039     {0, 0},             /* ACK */
00040     {0, 0},             /* BEL */
00041     {0x2a, 0},          /* BS  */  /* Keyboard Delete (Backspace) */
00042     {0x2b, 0},          /* TAB */  /* Keyboard Tab */
00043     {0x28, 0},          /* LF  */  /* Keyboard Return (Enter) */
00044     {0, 0},             /* VT  */
00045     {0, 0},             /* FF  */
00046     {0, 0},             /* CR  */
00047     {0, 0},             /* SO  */
00048     {0, 0},             /* SI  */
00049     {0, 0},             /* DEL */
00050     {0, 0},             /* DC1 */
00051     {0, 0},             /* DC2 */
00052     {0, 0},             /* DC3 */
00053     {0, 0},             /* DC4 */
00054     {0, 0},             /* NAK */
00055     {0, 0},             /* SYN */
00056     {0, 0},             /* ETB */
00057     {0, 0},             /* CAN */
00058     {0, 0},             /* EM  */
00059     {0, 0},             /* SUB */
00060     {0, 0},             /* ESC */
00061     {0, 0},             /* FS  */
00062     {0, 0},             /* GS  */
00063     {0, 0},             /* RS  */
00064     {0, 0},             /* US  */
00065     {0x2c, 0},          /*   */
00066     {0x1e, KEY_SHIFT},      /* ! */
00067     {0x34, KEY_SHIFT},      /* " */
00068     {0x20, KEY_SHIFT},      /* # */
00069     {0x21, KEY_SHIFT},      /* $ */
00070     {0x22, KEY_SHIFT},      /* % */
00071     {0x24, KEY_SHIFT},      /* & */
00072     {0x34, 0},          /* ' */
00073     {0x26, KEY_SHIFT},      /* ( */
00074     {0x27, KEY_SHIFT},      /* ) */
00075     {0x25, KEY_SHIFT},      /* * */
00076     {0x2e, KEY_SHIFT},      /* + */
00077     {0x36, 0},          /* , */
00078     {0x2d, 0},          /* - */
00079     {0x37, 0},          /* . */
00080     {0x38, 0},          /* / */
00081     {0x27, 0},          /* 0 */
00082     {0x1e, 0},          /* 1 */
00083     {0x1f, 0},          /* 2 */
00084     {0x20, 0},          /* 3 */
00085     {0x21, 0},          /* 4 */
00086     {0x22, 0},          /* 5 */
00087     {0x23, 0},          /* 6 */
00088     {0x24, 0},          /* 7 */
00089     {0x25, 0},          /* 8 */
00090     {0x26, 0},          /* 9 */
00091     {0x33, KEY_SHIFT},      /* : */
00092     {0x33, 0},          /* ; */
00093     {0x36, KEY_SHIFT},      /* < */
00094     {0x2e, 0},          /* = */
00095     {0x37, KEY_SHIFT},      /* > */
00096     {0x38, KEY_SHIFT},      /* ? */
00097     {0x1f, KEY_SHIFT},      /* @ */
00098     {0x04, KEY_SHIFT},      /* A */
00099     {0x05, KEY_SHIFT},      /* B */
00100     {0x06, KEY_SHIFT},      /* C */
00101     {0x07, KEY_SHIFT},      /* D */
00102     {0x08, KEY_SHIFT},      /* E */
00103     {0x09, KEY_SHIFT},      /* F */
00104     {0x0a, KEY_SHIFT},      /* G */
00105     {0x0b, KEY_SHIFT},      /* H */
00106     {0x0c, KEY_SHIFT},      /* I */
00107     {0x0d, KEY_SHIFT},      /* J */
00108     {0x0e, KEY_SHIFT},      /* K */
00109     {0x0f, KEY_SHIFT},      /* L */
00110     {0x10, KEY_SHIFT},      /* M */
00111     {0x11, KEY_SHIFT},      /* N */
00112     {0x12, KEY_SHIFT},      /* O */
00113     {0x13, KEY_SHIFT},      /* P */
00114     {0x14, KEY_SHIFT},      /* Q */
00115     {0x15, KEY_SHIFT},      /* R */
00116     {0x16, KEY_SHIFT},      /* S */
00117     {0x17, KEY_SHIFT},      /* T */
00118     {0x18, KEY_SHIFT},      /* U */
00119     {0x19, KEY_SHIFT},      /* V */
00120     {0x1a, KEY_SHIFT},      /* W */
00121     {0x1b, KEY_SHIFT},      /* X */
00122     {0x1c, KEY_SHIFT},      /* Y */
00123     {0x1d, KEY_SHIFT},      /* Z */
00124     {0x2f, 0},          /* [ */
00125     {0x31, 0},          /* \ */
00126     {0x30, 0},          /* ] */
00127     {0x23, KEY_SHIFT},      /* ^ */
00128     {0x2d, KEY_SHIFT},      /* _ */
00129     {0x35, 0},          /* ` */
00130     {0x04, 0},          /* a */
00131     {0x05, 0},          /* b */
00132     {0x06, 0},          /* c */
00133     {0x07, 0},          /* d */
00134     {0x08, 0},          /* e */
00135     {0x09, 0},          /* f */
00136     {0x0a, 0},          /* g */
00137     {0x0b, 0},          /* h */
00138     {0x0c, 0},          /* i */
00139     {0x0d, 0},          /* j */
00140     {0x0e, 0},          /* k */
00141     {0x0f, 0},          /* l */
00142     {0x10, 0},          /* m */
00143     {0x11, 0},          /* n */
00144     {0x12, 0},          /* o */
00145     {0x13, 0},          /* p */
00146     {0x14, 0},          /* q */
00147     {0x15, 0},          /* r */
00148     {0x16, 0},          /* s */
00149     {0x17, 0},          /* t */
00150     {0x18, 0},          /* u */
00151     {0x19, 0},          /* v */
00152     {0x1a, 0},          /* w */
00153     {0x1b, 0},          /* x */
00154     {0x1c, 0},          /* y */
00155     {0x1d, 0},          /* z */
00156     {0x2f, KEY_SHIFT},      /* { */
00157     {0x31, KEY_SHIFT},      /* | */
00158     {0x30, KEY_SHIFT},      /* } */
00159     {0x35, KEY_SHIFT},      /* ~ */
00160     {0, 0},             /* DEL */
00161 
00162     {0x3a, 0},          /* F1 */
00163     {0x3b, 0},          /* F2 */
00164     {0x3c, 0},          /* F3 */
00165     {0x3d, 0},          /* F4 */
00166     {0x3e, 0},          /* F5 */
00167     {0x3f, 0},          /* F6 */
00168     {0x40, 0},          /* F7 */
00169     {0x41, 0},          /* F8 */
00170     {0x42, 0},          /* F9 */
00171     {0x43, 0},          /* F10 */
00172     {0x44, 0},          /* F11 */
00173     {0x45, 0},          /* F12 */
00174 
00175     {0x46, 0},          /* PRINT_SCREEN */
00176     {0x47, 0},          /* SCROLL_LOCK */
00177     {0x39, 0},          /* CAPS_LOCK */
00178     {0x53, 0},          /* NUM_LOCK */
00179     {0x49, 0},          /* INSERT */
00180     {0x4a, 0},          /* HOME */
00181     {0x4b, 0},          /* PAGE_UP */
00182     {0x4e, 0},          /* PAGE_DOWN */
00183 
00184     {0x4f, 0},          /* RIGHT_ARROW */
00185     {0x50, 0},          /* LEFT_ARROW */
00186     {0x51, 0},          /* DOWN_ARROW */
00187     {0x52, 0},          /* UP_ARROW */
00188 };
00189 
00190 #else
00191 /* UK keyboard */
00192 #define KEYMAP_SIZE (152)
00193 const KEYMAP keymap[KEYMAP_SIZE] =
00194 {
00195     {0, 0},             /* NUL */
00196     {0, 0},             /* SOH */
00197     {0, 0},             /* STX */
00198     {0, 0},             /* ETX */
00199     {0, 0},             /* EOT */
00200     {0, 0},             /* ENQ */
00201     {0, 0},             /* ACK */
00202     {0, 0},             /* BEL */
00203     {0x2a, 0},          /* BS  */  /* Keyboard Delete (Backspace) */
00204     {0x2b, 0},          /* TAB */  /* Keyboard Tab */
00205     {0x28, 0},          /* LF  */  /* Keyboard Return (Enter) */
00206     {0, 0},             /* VT  */
00207     {0, 0},             /* FF  */
00208     {0, 0},             /* CR  */
00209     {0, 0},             /* SO  */
00210     {0, 0},             /* SI  */
00211     {0, 0},             /* DEL */
00212     {0, 0},             /* DC1 */
00213     {0, 0},             /* DC2 */
00214     {0, 0},             /* DC3 */
00215     {0, 0},             /* DC4 */
00216     {0, 0},             /* NAK */
00217     {0, 0},             /* SYN */
00218     {0, 0},             /* ETB */
00219     {0, 0},             /* CAN */
00220     {0, 0},             /* EM  */
00221     {0, 0},             /* SUB */
00222     {0, 0},             /* ESC */
00223     {0, 0},             /* FS  */
00224     {0, 0},             /* GS  */
00225     {0, 0},             /* RS  */
00226     {0, 0},             /* US  */
00227     {0x2c, 0},          /*   */
00228     {0x1e, KEY_SHIFT},      /* ! */
00229     {0x1f, KEY_SHIFT},      /* " */
00230     {0x32, 0},          /* # */
00231     {0x21, KEY_SHIFT},      /* $ */
00232     {0x22, KEY_SHIFT},      /* % */
00233     {0x24, KEY_SHIFT},      /* & */
00234     {0x34, 0},          /* ' */
00235     {0x26, KEY_SHIFT},      /* ( */
00236     {0x27, KEY_SHIFT},      /* ) */
00237     {0x25, KEY_SHIFT},      /* * */
00238     {0x2e, KEY_SHIFT},      /* + */
00239     {0x36, 0},          /* , */
00240     {0x2d, 0},          /* - */
00241     {0x37, 0},          /* . */
00242     {0x38, 0},          /* / */
00243     {0x27, 0},          /* 0 */
00244     {0x1e, 0},          /* 1 */
00245     {0x1f, 0},          /* 2 */
00246     {0x20, 0},          /* 3 */
00247     {0x21, 0},          /* 4 */
00248     {0x22, 0},          /* 5 */
00249     {0x23, 0},          /* 6 */
00250     {0x24, 0},          /* 7 */
00251     {0x25, 0},          /* 8 */
00252     {0x26, 0},          /* 9 */
00253     {0x33, KEY_SHIFT},      /* : */
00254     {0x33, 0},          /* ; */
00255     {0x36, KEY_SHIFT},      /* < */
00256     {0x2e, 0},          /* = */
00257     {0x37, KEY_SHIFT},      /* > */
00258     {0x38, KEY_SHIFT},      /* ? */
00259     {0x34, KEY_SHIFT},      /* @ */
00260     {0x04, KEY_SHIFT},      /* A */
00261     {0x05, KEY_SHIFT},      /* B */
00262     {0x06, KEY_SHIFT},      /* C */
00263     {0x07, KEY_SHIFT},      /* D */
00264     {0x08, KEY_SHIFT},      /* E */
00265     {0x09, KEY_SHIFT},      /* F */
00266     {0x0a, KEY_SHIFT},      /* G */
00267     {0x0b, KEY_SHIFT},      /* H */
00268     {0x0c, KEY_SHIFT},      /* I */
00269     {0x0d, KEY_SHIFT},      /* J */
00270     {0x0e, KEY_SHIFT},      /* K */
00271     {0x0f, KEY_SHIFT},      /* L */
00272     {0x10, KEY_SHIFT},      /* M */
00273     {0x11, KEY_SHIFT},      /* N */
00274     {0x12, KEY_SHIFT},      /* O */
00275     {0x13, KEY_SHIFT},      /* P */
00276     {0x14, KEY_SHIFT},      /* Q */
00277     {0x15, KEY_SHIFT},      /* R */
00278     {0x16, KEY_SHIFT},      /* S */
00279     {0x17, KEY_SHIFT},      /* T */
00280     {0x18, KEY_SHIFT},      /* U */
00281     {0x19, KEY_SHIFT},      /* V */
00282     {0x1a, KEY_SHIFT},      /* W */
00283     {0x1b, KEY_SHIFT},      /* X */
00284     {0x1c, KEY_SHIFT},      /* Y */
00285     {0x1d, KEY_SHIFT},      /* Z */
00286     {0x2f, 0},          /* [ */
00287     {0x64, 0},          /* \ */
00288     {0x30, 0},          /* ] */
00289     {0x23, KEY_SHIFT},      /* ^ */
00290     {0x2d, KEY_SHIFT},      /* _ */
00291     {0x35, 0},          /* ` */
00292     {0x04, 0},          /* a */
00293     {0x05, 0},          /* b */
00294     {0x06, 0},          /* c */
00295     {0x07, 0},          /* d */
00296     {0x08, 0},          /* e */
00297     {0x09, 0},          /* f */
00298     {0x0a, 0},          /* g */
00299     {0x0b, 0},          /* h */
00300     {0x0c, 0},          /* i */
00301     {0x0d, 0},          /* j */
00302     {0x0e, 0},          /* k */
00303     {0x0f, 0},          /* l */
00304     {0x10, 0},          /* m */
00305     {0x11, 0},          /* n */
00306     {0x12, 0},          /* o */
00307     {0x13, 0},          /* p */
00308     {0x14, 0},          /* q */
00309     {0x15, 0},          /* r */
00310     {0x16, 0},          /* s */
00311     {0x17, 0},          /* t */
00312     {0x18, 0},          /* u */
00313     {0x19, 0},          /* v */
00314     {0x1a, 0},          /* w */
00315     {0x1b, 0},          /* x */
00316     {0x1c, 0},          /* y */
00317     {0x1d, 0},          /* z */
00318     {0x2f, KEY_SHIFT},      /* { */
00319     {0x64, KEY_SHIFT},      /* | */
00320     {0x30, KEY_SHIFT},      /* } */
00321     {0x32, KEY_SHIFT},      /* ~ */
00322     {0, 0},            /* DEL */
00323 
00324     {0x3a, 0},          /* F1 */
00325     {0x3b, 0},          /* F2 */
00326     {0x3c, 0},          /* F3 */
00327     {0x3d, 0},          /* F4 */
00328     {0x3e, 0},          /* F5 */
00329     {0x3f, 0},          /* F6 */
00330     {0x40, 0},          /* F7 */
00331     {0x41, 0},          /* F8 */
00332     {0x42, 0},          /* F9 */
00333     {0x43, 0},          /* F10 */
00334     {0x44, 0},          /* F11 */
00335     {0x45, 0},          /* F12 */
00336 
00337     {0x46, 0},          /* PRINT_SCREEN */
00338     {0x47, 0},          /* SCROLL_LOCK */
00339     {0x39, 0},          /* CAPS_LOCK */
00340     {0x53, 0},          /* NUM_LOCK */
00341     {0x49, 0},          /* INSERT */
00342     {0x4a, 0},          /* HOME */
00343     {0x4b, 0},          /* PAGE_UP */
00344     {0x4e, 0},          /* PAGE_DOWN */
00345 
00346     {0x4f, 0},          /* RIGHT_ARROW */
00347     {0x50, 0},          /* LEFT_ARROW */
00348     {0x51, 0},          /* DOWN_ARROW */
00349     {0x52, 0},          /* UP_ARROW */
00350 };
00351 #endif
00352 
00353 
00354 uint8_t *USBMouseKeyboard::reportDesc()
00355 {
00356     if ( mouse_type == REL_MOUSE )
00357     {
00358         static uint8_t reportDescriptor[] =
00359         {
00360             // Keyboard
00361             USAGE_PAGE( 1 ),      0x01,
00362             USAGE( 1 ),           0x06,
00363             COLLECTION( 1 ),      0x01,
00364             REPORT_ID( 1 ),       REPORT_ID_KEYBOARD,
00365             USAGE_PAGE( 1 ),      0x07,
00366             USAGE_MINIMUM( 1 ),       0xE0,
00367             USAGE_MAXIMUM( 1 ),       0xE7,
00368             LOGICAL_MINIMUM( 1 ),     0x00,
00369             LOGICAL_MAXIMUM( 1 ),     0x01,
00370             REPORT_SIZE( 1 ),     0x01,
00371             REPORT_COUNT( 1 ),    0x08,
00372             INPUT( 1 ),           0x02,
00373             REPORT_COUNT( 1 ),    0x01,
00374             REPORT_SIZE( 1 ),     0x08,
00375             INPUT( 1 ),           0x01,
00376             REPORT_COUNT( 1 ),    0x05,
00377             REPORT_SIZE( 1 ),     0x01,
00378             USAGE_PAGE( 1 ),      0x08,
00379             USAGE_MINIMUM( 1 ),       0x01,
00380             USAGE_MAXIMUM( 1 ),       0x05,
00381             OUTPUT( 1 ),          0x02,
00382             REPORT_COUNT( 1 ),    0x01,
00383             REPORT_SIZE( 1 ),     0x03,
00384             OUTPUT( 1 ),          0x01,
00385             REPORT_COUNT( 1 ),    0x06,
00386             REPORT_SIZE( 1 ),     0x08,
00387             LOGICAL_MINIMUM( 1 ),     0x00,
00388             LOGICAL_MAXIMUM( 2 ),     0xff, 0x00,
00389             USAGE_PAGE( 1 ),      0x07,
00390             USAGE_MINIMUM( 1 ),       0x00,
00391             USAGE_MAXIMUM( 2 ),       0xff, 0x00,
00392             INPUT( 1 ),           0x00,
00393             END_COLLECTION( 0 ),
00394 
00395             // Mouse
00396             USAGE_PAGE( 1 ),      0x01,         // Generic Desktop
00397             USAGE( 1 ),           0x02,         // Mouse
00398             COLLECTION( 1 ),      0x01,         // Application
00399             USAGE( 1 ),           0x01,         // Pointer
00400             COLLECTION( 1 ),      0x00,         // Physical
00401             REPORT_ID( 1 ),       REPORT_ID_MOUSE,
00402             REPORT_COUNT( 1 ),    0x03,
00403             REPORT_SIZE( 1 ),     0x01,
00404             USAGE_PAGE( 1 ),      0x09,         // Buttons
00405             USAGE_MINIMUM( 1 ),       0x1,
00406             USAGE_MAXIMUM( 1 ),       0x3,
00407             LOGICAL_MINIMUM( 1 ),     0x00,
00408             LOGICAL_MAXIMUM( 1 ),     0x01,
00409             INPUT( 1 ),           0x02,
00410             REPORT_COUNT( 1 ),    0x01,
00411             REPORT_SIZE( 1 ),     0x05,
00412             INPUT( 1 ),           0x01,
00413             REPORT_COUNT( 1 ),    0x03,
00414             REPORT_SIZE( 1 ),     0x08,
00415             USAGE_PAGE( 1 ),      0x01,
00416             USAGE( 1 ),           0x30,         // X
00417             USAGE( 1 ),           0x31,         // Y
00418             USAGE( 1 ),           0x38,         // scroll
00419             LOGICAL_MINIMUM( 1 ),     0x81,
00420             LOGICAL_MAXIMUM( 1 ),     0x7f,
00421             INPUT( 1 ),           0x06,
00422             END_COLLECTION( 0 ),
00423             END_COLLECTION( 0 ),
00424 
00425 
00426             // Media Control
00427             USAGE_PAGE( 1 ), 0x0C,
00428             USAGE( 1 ), 0x01,
00429             COLLECTION( 1 ), 0x01,
00430             REPORT_ID( 1 ), REPORT_ID_VOLUME,
00431             USAGE_PAGE( 1 ), 0x0C,
00432             LOGICAL_MINIMUM( 1 ), 0x00,
00433             LOGICAL_MAXIMUM( 1 ), 0x01,
00434             REPORT_SIZE( 1 ), 0x01,
00435             REPORT_COUNT( 1 ), 0x07,
00436             USAGE( 1 ), 0xB5,           // Next Track
00437             USAGE( 1 ), 0xB6,           // Previous Track
00438             USAGE( 1 ), 0xB7,           // Stop
00439             USAGE( 1 ), 0xCD,           // Play / Pause
00440             USAGE( 1 ), 0xE2,           // Mute
00441             USAGE( 1 ), 0xE9,           // Volume Up
00442             USAGE( 1 ), 0xEA,           // Volume Down
00443             INPUT( 1 ), 0x02,           // Input (Data, Variable, Absolute)
00444             REPORT_COUNT( 1 ), 0x01,
00445             INPUT( 1 ), 0x01,
00446             END_COLLECTION( 0 ),
00447         };
00448         reportLength = sizeof( reportDescriptor );
00449         return reportDescriptor;
00450     }
00451     else if ( mouse_type == ABS_MOUSE )
00452     {
00453         static uint8_t reportDescriptor[] =
00454         {
00455 
00456             // Keyboard
00457             USAGE_PAGE( 1 ),      0x01,
00458             USAGE( 1 ),           0x06,
00459             COLLECTION( 1 ),      0x01,
00460             REPORT_ID( 1 ),       REPORT_ID_KEYBOARD,
00461             USAGE_PAGE( 1 ),      0x07,
00462             USAGE_MINIMUM( 1 ),       0xE0,
00463             USAGE_MAXIMUM( 1 ),       0xE7,
00464             LOGICAL_MINIMUM( 1 ),     0x00,
00465             LOGICAL_MAXIMUM( 1 ),     0x01,
00466             REPORT_SIZE( 1 ),     0x01,
00467             REPORT_COUNT( 1 ),    0x08,
00468             INPUT( 1 ),           0x02,
00469             REPORT_COUNT( 1 ),    0x01,
00470             REPORT_SIZE( 1 ),     0x08,
00471             INPUT( 1 ),           0x01,
00472             REPORT_COUNT( 1 ),    0x05,
00473             REPORT_SIZE( 1 ),     0x01,
00474             USAGE_PAGE( 1 ),      0x08,
00475             USAGE_MINIMUM( 1 ),       0x01,
00476             USAGE_MAXIMUM( 1 ),       0x05,
00477             OUTPUT( 1 ),          0x02,
00478             REPORT_COUNT( 1 ),    0x01,
00479             REPORT_SIZE( 1 ),     0x03,
00480             OUTPUT( 1 ),          0x01,
00481             REPORT_COUNT( 1 ),    0x06,
00482             REPORT_SIZE( 1 ),     0x08,
00483             LOGICAL_MINIMUM( 1 ),     0x00,
00484             LOGICAL_MAXIMUM( 2 ),     0xff, 0x00,
00485             USAGE_PAGE( 1 ),      0x07,
00486             USAGE_MINIMUM( 1 ),       0x00,
00487             USAGE_MAXIMUM( 2 ),       0xff, 0x00,
00488             INPUT( 1 ),           0x00,
00489             END_COLLECTION( 0 ),
00490 
00491             // Mouse
00492             USAGE_PAGE( 1 ), 0x01,             // Generic Desktop
00493             USAGE( 1 ), 0x02,                  // Mouse
00494             COLLECTION( 1 ), 0x01,             // Application
00495             USAGE( 1 ), 0x01,                  // Pointer
00496             COLLECTION( 1 ), 0x00,             // Physical
00497             REPORT_ID( 1 ),       REPORT_ID_MOUSE,
00498 
00499             USAGE_PAGE( 1 ), 0x01,              // Generic Desktop
00500             USAGE( 1 ), 0x30,                   // X
00501             USAGE( 1 ), 0x31,                   // Y
00502             LOGICAL_MINIMUM( 1 ), 0x00,         // 0
00503             LOGICAL_MAXIMUM( 2 ), 0xff, 0x7f,   // 32767
00504             REPORT_SIZE( 1 ), 0x10,
00505             REPORT_COUNT( 1 ), 0x02,
00506             INPUT( 1 ), 0x02,                   // Data, Variable, Absolute
00507 
00508             USAGE_PAGE( 1 ), 0x01,              // Generic Desktop
00509             USAGE( 1 ), 0x38,                   // scroll
00510             LOGICAL_MINIMUM( 1 ), 0x81,         // -127
00511             LOGICAL_MAXIMUM( 1 ), 0x7f,         // 127
00512             REPORT_SIZE( 1 ), 0x08,
00513             REPORT_COUNT( 1 ), 0x01,
00514             INPUT( 1 ), 0x06,                   // Data, Variable, Relative
00515 
00516             USAGE_PAGE( 1 ), 0x09,              // Buttons
00517             USAGE_MINIMUM( 1 ), 0x01,
00518             USAGE_MAXIMUM( 1 ), 0x03,
00519             LOGICAL_MINIMUM( 1 ), 0x00,         // 0
00520             LOGICAL_MAXIMUM( 1 ), 0x01,         // 1
00521             REPORT_COUNT( 1 ), 0x03,
00522             REPORT_SIZE( 1 ), 0x01,
00523             INPUT( 1 ), 0x02,                   // Data, Variable, Absolute
00524             REPORT_COUNT( 1 ), 0x01,
00525             REPORT_SIZE( 1 ), 0x05,
00526             INPUT( 1 ), 0x01,                   // Constant
00527 
00528             END_COLLECTION( 0 ),
00529             END_COLLECTION( 0 ),
00530 
00531             // Media Control
00532             USAGE_PAGE( 1 ), 0x0C,
00533             USAGE( 1 ), 0x01,
00534             COLLECTION( 1 ), 0x01,
00535             REPORT_ID( 1 ), REPORT_ID_VOLUME,
00536             USAGE_PAGE( 1 ), 0x0C,
00537             LOGICAL_MINIMUM( 1 ), 0x00,
00538             LOGICAL_MAXIMUM( 1 ), 0x01,
00539             REPORT_SIZE( 1 ), 0x01,
00540             REPORT_COUNT( 1 ), 0x07,
00541             USAGE( 1 ), 0xB5,           // Next Track
00542             USAGE( 1 ), 0xB6,           // Previous Track
00543             USAGE( 1 ), 0xB7,           // Stop
00544             USAGE( 1 ), 0xCD,           // Play / Pause
00545             USAGE( 1 ), 0xE2,           // Mute
00546             USAGE( 1 ), 0xE9,           // Volume Up
00547             USAGE( 1 ), 0xEA,           // Volume Down
00548             INPUT( 1 ), 0x02,           // Input (Data, Variable, Absolute)
00549             REPORT_COUNT( 1 ), 0x01,
00550             INPUT( 1 ), 0x01,
00551             END_COLLECTION( 0 ),
00552         };
00553         reportLength = sizeof( reportDescriptor );
00554         return reportDescriptor;
00555     }
00556 
00557     return NULL;
00558 }
00559 
00560 bool USBMouseKeyboard::EP1_OUT_callback()
00561 {
00562     uint32_t bytesRead = 0;
00563     uint8_t led[65];
00564     USBDevice::readEP( EPINT_OUT, led, &bytesRead, MAX_HID_REPORT_SIZE );
00565     // we take led[1] because led[0] is the report ID
00566     lock_status = led[1] & 0x07;
00567 
00568     // We activate the endpoint to be able to recceive data
00569     if ( !readStart( EPINT_OUT, MAX_HID_REPORT_SIZE ) )
00570     {
00571         return false;
00572     }
00573 
00574     return true;
00575 }
00576 
00577 uint8_t USBMouseKeyboard::lockStatus()
00578 {
00579     return lock_status;
00580 }
00581 
00582 bool USBMouseKeyboard::update( int16_t x, int16_t y, uint8_t button, int8_t z )
00583 {
00584     switch ( mouse_type )
00585     {
00586         case REL_MOUSE:
00587             while ( x > 127 )
00588             {
00589                 if ( !mouseSend( 127, 0, button, z ) )
00590                 {
00591                     return false;
00592                 }
00593 
00594                 x = x - 127;
00595             }
00596 
00597             while ( x < -128 )
00598             {
00599                 if ( !mouseSend( -128, 0, button, z ) )
00600                 {
00601                     return false;
00602                 }
00603 
00604                 x = x + 128;
00605             }
00606 
00607             while ( y > 127 )
00608             {
00609                 if ( !mouseSend( 0, 127, button, z ) )
00610                 {
00611                     return false;
00612                 }
00613 
00614                 y = y - 127;
00615             }
00616 
00617             while ( y < -128 )
00618             {
00619                 if ( !mouseSend( 0, -128, button, z ) )
00620                 {
00621                     return false;
00622                 }
00623 
00624                 y = y + 128;
00625             }
00626 
00627             return mouseSend( x, y, button, z );
00628 
00629         case ABS_MOUSE:
00630             HID_REPORT report;
00631             report.data[0] = REPORT_ID_MOUSE;
00632             report.data[1] = x & 0xff;
00633             report.data[2] = ( x >> 8 ) & 0xff;
00634             report.data[3] = y & 0xff;
00635             report.data[4] = ( y >> 8 ) & 0xff;
00636             report.data[5] = -z;
00637             report.data[6] = button & 0x07;
00638             report.length = 7;
00639             return send( &report );
00640 
00641         default:
00642             return false;
00643     }
00644 }
00645 
00646 bool USBMouseKeyboard::mouseSend( int8_t x, int8_t y, uint8_t buttons, int8_t z )
00647 {
00648     HID_REPORT report;
00649     report.data[0] = REPORT_ID_MOUSE;
00650     report.data[1] = buttons & 0x07;
00651     report.data[2] = x;
00652     report.data[3] = y;
00653     report.data[4] = -z; // >0 to scroll down, <0 to scroll up
00654     report.length = 5;
00655     return send( &report );
00656 }
00657 
00658 bool USBMouseKeyboard::move( int16_t x, int16_t y )
00659 {
00660     return update( x, y, button, 0 );
00661 }
00662 
00663 bool USBMouseKeyboard::scroll( int8_t z )
00664 {
00665     return update( 0, 0, button, z );
00666 }
00667 
00668 bool USBMouseKeyboard::doubleClick()
00669 {
00670     if ( !click( MOUSE_LEFT ) )
00671     {
00672         return false;
00673     }
00674 
00675     wait( 0.1 );
00676     return click( MOUSE_LEFT );
00677 }
00678 
00679 bool USBMouseKeyboard::click( uint8_t button )
00680 {
00681     if ( !update( 0, 0, button, 0 ) )
00682     {
00683         return false;
00684     }
00685 
00686     wait( 0.01 );
00687     return update( 0, 0, 0, 0 );
00688 }
00689 
00690 bool USBMouseKeyboard::press( uint8_t button_ )
00691 {
00692     button = button_ & 0x07;
00693     return update( 0, 0, button, 0 );
00694 }
00695 
00696 bool USBMouseKeyboard::release( uint8_t button_ )
00697 {
00698     button = ( button & ( ~button_ ) ) & 0x07;
00699     return update( 0, 0, button, 0 );
00700 }
00701 
00702 int USBMouseKeyboard::_putc( int c )
00703 {
00704     return keyCode( c, keymap[c].modifier );
00705 }
00706 
00707 bool USBMouseKeyboard::keyCode( uint8_t key, uint8_t modifier )
00708 {
00709     // Send a simulated keyboard keypress. Returns true if successful.
00710     HID_REPORT report;
00711     report.data[0] = REPORT_ID_KEYBOARD;
00712     report.data[1] = modifier;
00713     report.data[2] = 0;
00714     report.data[3] = keymap[key].usage;
00715     report.data[4] = 0;
00716     report.data[5] = 0;
00717     report.data[6] = 0;
00718     report.data[7] = 0;
00719     report.data[8] = 0;
00720     report.length = 9;
00721 
00722     if ( !send( &report ) )
00723     {
00724         return false;
00725     }
00726 
00727     report.data[1] = 0;
00728     report.data[3] = 0;
00729 
00730     if ( !send( &report ) )
00731     {
00732         return false;
00733     }
00734 
00735     return true;
00736 }
00737 
00738 
00739 bool USBMouseKeyboard::mediaControl( MEDIA_KEY key )
00740 {
00741     HID_REPORT report;
00742     report.data[0] = REPORT_ID_VOLUME;
00743     report.data[1] = ( 1 << key ) & 0x7f;
00744     report.length = 2;
00745     send( &report );
00746     report.data[0] = REPORT_ID_VOLUME;
00747     report.data[1] = 0;
00748     report.length = 2;
00749     return send( &report );
00750 }
00751