Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Arduino/hardware/arduino/avr/cores/arduino/HID.cpp
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
518 lines (457 sloc)
13.4 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* Copyright (c) 2011, Peter Barrett | |
** | |
** Permission to use, copy, modify, and/or distribute this software for | |
** any purpose with or without fee is hereby granted, provided that the | |
** above copyright notice and this permission notice appear in all copies. | |
** | |
** THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL | |
** WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED | |
** WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR | |
** BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES | |
** OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, | |
** WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, | |
** ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS | |
** SOFTWARE. | |
*/ | |
#include "USBAPI.h" | |
#if defined(USBCON) | |
#ifdef HID_ENABLED | |
//#define RAWHID_ENABLED | |
// Singletons for mouse and keyboard | |
Mouse_ Mouse; | |
Keyboard_ Keyboard; | |
//================================================================================ | |
//================================================================================ | |
// HID report descriptor | |
#define LSB(_x) ((_x) & 0xFF) | |
#define MSB(_x) ((_x) >> 8) | |
#define RAWHID_USAGE_PAGE 0xFFC0 | |
#define RAWHID_USAGE 0x0C00 | |
#define RAWHID_TX_SIZE 64 | |
#define RAWHID_RX_SIZE 64 | |
extern const u8 _hidReportDescriptor[] PROGMEM; | |
const u8 _hidReportDescriptor[] = { | |
// Mouse | |
0x05, 0x01, // USAGE_PAGE (Generic Desktop) // 54 | |
0x09, 0x02, // USAGE (Mouse) | |
0xa1, 0x01, // COLLECTION (Application) | |
0x09, 0x01, // USAGE (Pointer) | |
0xa1, 0x00, // COLLECTION (Physical) | |
0x85, 0x01, // REPORT_ID (1) | |
0x05, 0x09, // USAGE_PAGE (Button) | |
0x19, 0x01, // USAGE_MINIMUM (Button 1) | |
0x29, 0x03, // USAGE_MAXIMUM (Button 3) | |
0x15, 0x00, // LOGICAL_MINIMUM (0) | |
0x25, 0x01, // LOGICAL_MAXIMUM (1) | |
0x95, 0x03, // REPORT_COUNT (3) | |
0x75, 0x01, // REPORT_SIZE (1) | |
0x81, 0x02, // INPUT (Data,Var,Abs) | |
0x95, 0x01, // REPORT_COUNT (1) | |
0x75, 0x05, // REPORT_SIZE (5) | |
0x81, 0x03, // INPUT (Cnst,Var,Abs) | |
0x05, 0x01, // USAGE_PAGE (Generic Desktop) | |
0x09, 0x30, // USAGE (X) | |
0x09, 0x31, // USAGE (Y) | |
0x09, 0x38, // USAGE (Wheel) | |
0x15, 0x81, // LOGICAL_MINIMUM (-127) | |
0x25, 0x7f, // LOGICAL_MAXIMUM (127) | |
0x75, 0x08, // REPORT_SIZE (8) | |
0x95, 0x03, // REPORT_COUNT (3) | |
0x81, 0x06, // INPUT (Data,Var,Rel) | |
0xc0, // END_COLLECTION | |
0xc0, // END_COLLECTION | |
// Keyboard | |
0x05, 0x01, // USAGE_PAGE (Generic Desktop) // 47 | |
0x09, 0x06, // USAGE (Keyboard) | |
0xa1, 0x01, // COLLECTION (Application) | |
0x85, 0x02, // REPORT_ID (2) | |
0x05, 0x07, // USAGE_PAGE (Keyboard) | |
0x19, 0xe0, // USAGE_MINIMUM (Keyboard LeftControl) | |
0x29, 0xe7, // USAGE_MAXIMUM (Keyboard Right GUI) | |
0x15, 0x00, // LOGICAL_MINIMUM (0) | |
0x25, 0x01, // LOGICAL_MAXIMUM (1) | |
0x75, 0x01, // REPORT_SIZE (1) | |
0x95, 0x08, // REPORT_COUNT (8) | |
0x81, 0x02, // INPUT (Data,Var,Abs) | |
0x95, 0x01, // REPORT_COUNT (1) | |
0x75, 0x08, // REPORT_SIZE (8) | |
0x81, 0x03, // INPUT (Cnst,Var,Abs) | |
0x95, 0x06, // REPORT_COUNT (6) | |
0x75, 0x08, // REPORT_SIZE (8) | |
0x15, 0x00, // LOGICAL_MINIMUM (0) | |
0x25, 0x65, // LOGICAL_MAXIMUM (101) | |
0x05, 0x07, // USAGE_PAGE (Keyboard) | |
0x19, 0x00, // USAGE_MINIMUM (Reserved (no event indicated)) | |
0x29, 0x65, // USAGE_MAXIMUM (Keyboard Application) | |
0x81, 0x00, // INPUT (Data,Ary,Abs) | |
0xc0, // END_COLLECTION | |
#ifdef RAWHID_ENABLED | |
// RAW HID | |
0x06, LSB(RAWHID_USAGE_PAGE), MSB(RAWHID_USAGE_PAGE), // 30 | |
0x0A, LSB(RAWHID_USAGE), MSB(RAWHID_USAGE), | |
0xA1, 0x01, // Collection 0x01 | |
0x85, 0x03, // REPORT_ID (3) | |
0x75, 0x08, // report size = 8 bits | |
0x15, 0x00, // logical minimum = 0 | |
0x26, 0xFF, 0x00, // logical maximum = 255 | |
0x95, 64, // report count TX | |
0x09, 0x01, // usage | |
0x81, 0x02, // Input (array) | |
0x95, 64, // report count RX | |
0x09, 0x02, // usage | |
0x91, 0x02, // Output (array) | |
0xC0 // end collection | |
#endif | |
}; | |
extern const HIDDescriptor _hidInterface PROGMEM; | |
const HIDDescriptor _hidInterface = | |
{ | |
D_INTERFACE(HID_INTERFACE,1,3,0,0), | |
D_HIDREPORT(sizeof(_hidReportDescriptor)), | |
D_ENDPOINT(USB_ENDPOINT_IN (HID_ENDPOINT_INT),USB_ENDPOINT_TYPE_INTERRUPT,0x40,0x01) | |
}; | |
//================================================================================ | |
//================================================================================ | |
// Driver | |
u8 _hid_protocol = 1; | |
u8 _hid_idle = 1; | |
#define WEAK __attribute__ ((weak)) | |
int WEAK HID_GetInterface(u8* interfaceNum) | |
{ | |
interfaceNum[0] += 1; // uses 1 | |
return USB_SendControl(TRANSFER_PGM,&_hidInterface,sizeof(_hidInterface)); | |
} | |
int WEAK HID_GetDescriptor(int /* i */) | |
{ | |
return USB_SendControl(TRANSFER_PGM,_hidReportDescriptor,sizeof(_hidReportDescriptor)); | |
} | |
void WEAK HID_SendReport(u8 id, const void* data, int len) | |
{ | |
USB_Send(HID_TX, &id, 1); | |
USB_Send(HID_TX | TRANSFER_RELEASE,data,len); | |
} | |
bool WEAK HID_Setup(Setup& setup) | |
{ | |
u8 r = setup.bRequest; | |
u8 requestType = setup.bmRequestType; | |
if (REQUEST_DEVICETOHOST_CLASS_INTERFACE == requestType) | |
{ | |
if (HID_GET_REPORT == r) | |
{ | |
//HID_GetReport(); | |
return true; | |
} | |
if (HID_GET_PROTOCOL == r) | |
{ | |
//Send8(_hid_protocol); // TODO | |
return true; | |
} | |
} | |
if (REQUEST_HOSTTODEVICE_CLASS_INTERFACE == requestType) | |
{ | |
if (HID_SET_PROTOCOL == r) | |
{ | |
_hid_protocol = setup.wValueL; | |
return true; | |
} | |
if (HID_SET_IDLE == r) | |
{ | |
_hid_idle = setup.wValueL; | |
return true; | |
} | |
} | |
return false; | |
} | |
//================================================================================ | |
//================================================================================ | |
// Mouse | |
Mouse_::Mouse_(void) : _buttons(0) | |
{ | |
} | |
void Mouse_::begin(void) | |
{ | |
} | |
void Mouse_::end(void) | |
{ | |
} | |
void Mouse_::click(uint8_t b) | |
{ | |
_buttons = b; | |
move(0,0,0); | |
_buttons = 0; | |
move(0,0,0); | |
} | |
void Mouse_::move(signed char x, signed char y, signed char wheel) | |
{ | |
u8 m[4]; | |
m[0] = _buttons; | |
m[1] = x; | |
m[2] = y; | |
m[3] = wheel; | |
HID_SendReport(1,m,4); | |
} | |
void Mouse_::buttons(uint8_t b) | |
{ | |
if (b != _buttons) | |
{ | |
_buttons = b; | |
move(0,0,0); | |
} | |
} | |
void Mouse_::press(uint8_t b) | |
{ | |
buttons(_buttons | b); | |
} | |
void Mouse_::release(uint8_t b) | |
{ | |
buttons(_buttons & ~b); | |
} | |
bool Mouse_::isPressed(uint8_t b) | |
{ | |
if ((b & _buttons) > 0) | |
return true; | |
return false; | |
} | |
//================================================================================ | |
//================================================================================ | |
// Keyboard | |
Keyboard_::Keyboard_(void) | |
{ | |
} | |
void Keyboard_::begin(void) | |
{ | |
} | |
void Keyboard_::end(void) | |
{ | |
} | |
void Keyboard_::sendReport(KeyReport* keys) | |
{ | |
HID_SendReport(2,keys,sizeof(KeyReport)); | |
} | |
extern | |
const uint8_t _asciimap[128] PROGMEM; | |
#define SHIFT 0x80 | |
const uint8_t _asciimap[128] = | |
{ | |
0x00, // NUL | |
0x00, // SOH | |
0x00, // STX | |
0x00, // ETX | |
0x00, // EOT | |
0x00, // ENQ | |
0x00, // ACK | |
0x00, // BEL | |
0x2a, // BS Backspace | |
0x2b, // TAB Tab | |
0x28, // LF Enter | |
0x00, // VT | |
0x00, // FF | |
0x00, // CR | |
0x00, // SO | |
0x00, // SI | |
0x00, // DEL | |
0x00, // DC1 | |
0x00, // DC2 | |
0x00, // DC3 | |
0x00, // DC4 | |
0x00, // NAK | |
0x00, // SYN | |
0x00, // ETB | |
0x00, // CAN | |
0x00, // EM | |
0x00, // SUB | |
0x00, // ESC | |
0x00, // FS | |
0x00, // GS | |
0x00, // RS | |
0x00, // US | |
0x2c, // ' ' | |
0x1e|SHIFT, // ! | |
0x34|SHIFT, // " | |
0x20|SHIFT, // # | |
0x21|SHIFT, // $ | |
0x22|SHIFT, // % | |
0x24|SHIFT, // & | |
0x34, // ' | |
0x26|SHIFT, // ( | |
0x27|SHIFT, // ) | |
0x25|SHIFT, // * | |
0x2e|SHIFT, // + | |
0x36, // , | |
0x2d, // - | |
0x37, // . | |
0x38, // / | |
0x27, // 0 | |
0x1e, // 1 | |
0x1f, // 2 | |
0x20, // 3 | |
0x21, // 4 | |
0x22, // 5 | |
0x23, // 6 | |
0x24, // 7 | |
0x25, // 8 | |
0x26, // 9 | |
0x33|SHIFT, // : | |
0x33, // ; | |
0x36|SHIFT, // < | |
0x2e, // = | |
0x37|SHIFT, // > | |
0x38|SHIFT, // ? | |
0x1f|SHIFT, // @ | |
0x04|SHIFT, // A | |
0x05|SHIFT, // B | |
0x06|SHIFT, // C | |
0x07|SHIFT, // D | |
0x08|SHIFT, // E | |
0x09|SHIFT, // F | |
0x0a|SHIFT, // G | |
0x0b|SHIFT, // H | |
0x0c|SHIFT, // I | |
0x0d|SHIFT, // J | |
0x0e|SHIFT, // K | |
0x0f|SHIFT, // L | |
0x10|SHIFT, // M | |
0x11|SHIFT, // N | |
0x12|SHIFT, // O | |
0x13|SHIFT, // P | |
0x14|SHIFT, // Q | |
0x15|SHIFT, // R | |
0x16|SHIFT, // S | |
0x17|SHIFT, // T | |
0x18|SHIFT, // U | |
0x19|SHIFT, // V | |
0x1a|SHIFT, // W | |
0x1b|SHIFT, // X | |
0x1c|SHIFT, // Y | |
0x1d|SHIFT, // Z | |
0x2f, // [ | |
0x31, // bslash | |
0x30, // ] | |
0x23|SHIFT, // ^ | |
0x2d|SHIFT, // _ | |
0x35, // ` | |
0x04, // a | |
0x05, // b | |
0x06, // c | |
0x07, // d | |
0x08, // e | |
0x09, // f | |
0x0a, // g | |
0x0b, // h | |
0x0c, // i | |
0x0d, // j | |
0x0e, // k | |
0x0f, // l | |
0x10, // m | |
0x11, // n | |
0x12, // o | |
0x13, // p | |
0x14, // q | |
0x15, // r | |
0x16, // s | |
0x17, // t | |
0x18, // u | |
0x19, // v | |
0x1a, // w | |
0x1b, // x | |
0x1c, // y | |
0x1d, // z | |
0x2f|SHIFT, // | |
0x31|SHIFT, // | | |
0x30|SHIFT, // } | |
0x35|SHIFT, // ~ | |
0 // DEL | |
}; | |
uint8_t USBPutChar(uint8_t c); | |
// press() adds the specified key (printing, non-printing, or modifier) | |
// to the persistent key report and sends the report. Because of the way | |
// USB HID works, the host acts like the key remains pressed until we | |
// call release(), releaseAll(), or otherwise clear the report and resend. | |
size_t Keyboard_::press(uint8_t k) | |
{ | |
uint8_t i; | |
if (k >= 136) { // it's a non-printing key (not a modifier) | |
k = k - 136; | |
} else if (k >= 128) { // it's a modifier key | |
_keyReport.modifiers |= (1<<(k-128)); | |
k = 0; | |
} else { // it's a printing key | |
k = pgm_read_byte(_asciimap + k); | |
if (!k) { | |
setWriteError(); | |
return 0; | |
} | |
if (k & 0x80) { // it's a capital letter or other character reached with shift | |
_keyReport.modifiers |= 0x02; // the left shift modifier | |
k &= 0x7F; | |
} | |
} | |
// Add k to the key report only if it's not already present | |
// and if there is an empty slot. | |
if (_keyReport.keys[0] != k && _keyReport.keys[1] != k && | |
_keyReport.keys[2] != k && _keyReport.keys[3] != k && | |
_keyReport.keys[4] != k && _keyReport.keys[5] != k) { | |
for (i=0; i<6; i++) { | |
if (_keyReport.keys[i] == 0x00) { | |
_keyReport.keys[i] = k; | |
break; | |
} | |
} | |
if (i == 6) { | |
setWriteError(); | |
return 0; | |
} | |
} | |
sendReport(&_keyReport); | |
return 1; | |
} | |
// release() takes the specified key out of the persistent key report and | |
// sends the report. This tells the OS the key is no longer pressed and that | |
// it shouldn't be repeated any more. | |
size_t Keyboard_::release(uint8_t k) | |
{ | |
uint8_t i; | |
if (k >= 136) { // it's a non-printing key (not a modifier) | |
k = k - 136; | |
} else if (k >= 128) { // it's a modifier key | |
_keyReport.modifiers &= ~(1<<(k-128)); | |
k = 0; | |
} else { // it's a printing key | |
k = pgm_read_byte(_asciimap + k); | |
if (!k) { | |
return 0; | |
} | |
if (k & 0x80) { // it's a capital letter or other character reached with shift | |
_keyReport.modifiers &= ~(0x02); // the left shift modifier | |
k &= 0x7F; | |
} | |
} | |
// Test the key report to see if k is present. Clear it if it exists. | |
// Check all positions in case the key is present more than once (which it shouldn't be) | |
for (i=0; i<6; i++) { | |
if (0 != k && _keyReport.keys[i] == k) { | |
_keyReport.keys[i] = 0x00; | |
} | |
} | |
sendReport(&_keyReport); | |
return 1; | |
} | |
void Keyboard_::releaseAll(void) | |
{ | |
_keyReport.keys[0] = 0; | |
_keyReport.keys[1] = 0; | |
_keyReport.keys[2] = 0; | |
_keyReport.keys[3] = 0; | |
_keyReport.keys[4] = 0; | |
_keyReport.keys[5] = 0; | |
_keyReport.modifiers = 0; | |
sendReport(&_keyReport); | |
} | |
size_t Keyboard_::write(uint8_t c) | |
{ | |
uint8_t p = press(c); // Keydown | |
release(c); // Keyup | |
return p; // just return the result of press() since release() almost always returns 1 | |
} | |
#endif | |
#endif /* if defined(USBCON) */ |