Skip to content

Commit 87a2b7a

Browse files
abratchikabratchik
abratchik
authored and
abratchik
committed
Enhanced HID protocol support for Arduino Leonardo & Pro Micro
1 parent 60f0d0b commit 87a2b7a

File tree

4 files changed

+200
-41
lines changed

4 files changed

+200
-41
lines changed

‎cores/arduino/USBAPI.h

+1
Original file line numberDiff line numberDiff line change
@@ -196,6 +196,7 @@ bool CDC_Setup(USBSetup& setup);
196196
int USB_SendControl(uint8_t flags, const void* d, int len);
197197
int USB_RecvControl(void* d, int len);
198198
int USB_RecvControlLong(void* d, int len);
199+
bool USB_SendStringDescriptor(const u8*, u8, uint8_t);
199200

200201
uint8_t USB_Available(uint8_t ep);
201202
uint8_t USB_SendSpace(uint8_t ep);

‎cores/arduino/USBCore.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -426,7 +426,7 @@ int USB_SendControl(u8 flags, const void* d, int len)
426426
// Send a USB descriptor string. The string is stored in PROGMEM as a
427427
// plain ASCII string but is sent out as UTF-16 with the correct 2-byte
428428
// prefix
429-
static bool USB_SendStringDescriptor(const u8*string_P, u8 string_len, uint8_t flags) {
429+
bool USB_SendStringDescriptor(const u8*string_P, u8 string_len, uint8_t flags) {
430430
SendControl(2 + string_len * 2);
431431
SendControl(3);
432432
bool pgm = flags & TRANSFER_PGM;

‎libraries/HID/src/HID.cpp

+132-19
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
/*
22
Copyright (c) 2015, Arduino LLC
33
Original code (pre-library): Copyright (c) 2011, Peter Barrett
4+
Modified code: Copyright (c) 2020, Aleksandr Bratchik
45
56
Permission to use, copy, modify, and/or distribute this software for
67
any purpose with or without fee is hereby granted, provided that the
@@ -30,18 +31,35 @@ int HID_::getInterface(uint8_t* interfaceCount)
3031
{
3132
*interfaceCount += 1; // uses 1
3233
HIDDescriptor hidInterface = {
33-
D_INTERFACE(pluggedInterface, 1, USB_DEVICE_CLASS_HUMAN_INTERFACE, HID_SUBCLASS_NONE, HID_PROTOCOL_NONE),
34+
D_INTERFACE(pluggedInterface, 2, USB_DEVICE_CLASS_HUMAN_INTERFACE, HID_SUBCLASS_NONE, HID_PROTOCOL_NONE),
3435
D_HIDREPORT(descriptorSize),
35-
D_ENDPOINT(USB_ENDPOINT_IN(pluggedEndpoint), USB_ENDPOINT_TYPE_INTERRUPT, USB_EP_SIZE, 0x01)
36+
D_ENDPOINT(USB_ENDPOINT_IN(HID_TX), USB_ENDPOINT_TYPE_INTERRUPT, USB_EP_SIZE, 0x14),
37+
D_ENDPOINT(USB_ENDPOINT_OUT(HID_RX), USB_ENDPOINT_TYPE_INTERRUPT, USB_EP_SIZE, 0x0A)
3638
};
3739
return USB_SendControl(0, &hidInterface, sizeof(hidInterface));
3840
}
3941

4042
int HID_::getDescriptor(USBSetup& setup)
4143
{
44+
45+
u8 t = setup.wValueH;
46+
47+
// HID-specific strings
48+
if(USB_STRING_DESCRIPTOR_TYPE == t) {
49+
50+
// we place all strings in the 0xFF00-0xFFFE range
51+
HIDReport* rep = GetFeature(0xFF00 | setup.wValueL );
52+
if(rep) {
53+
return USB_SendStringDescriptor((u8*)rep->data, strlen_P((char*)rep->data), TRANSFER_PGM);
54+
}
55+
else {
56+
return 0;
57+
}
58+
}
59+
4260
// Check if this is a HID Class Descriptor request
4361
if (setup.bmRequestType != REQUEST_DEVICETOHOST_STANDARD_INTERFACE) { return 0; }
44-
if (setup.wValueH != HID_REPORT_DESCRIPTOR_TYPE) { return 0; }
62+
if (HID_REPORT_DESCRIPTOR_TYPE != t) { return 0; }
4563

4664
// In a HID Class Descriptor wIndex cointains the interface number
4765
if (setup.wIndex != pluggedInterface) { return 0; }
@@ -64,12 +82,24 @@ int HID_::getDescriptor(USBSetup& setup)
6482

6583
uint8_t HID_::getShortName(char *name)
6684
{
85+
if(serial) {
86+
byte seriallen=min(strlen_P(serial), ISERIAL_MAX_LEN);
87+
for(byte i=0; i< seriallen; i++) {
88+
name[i] = pgm_read_byte_near(serial + i);
89+
}
90+
return seriallen;
91+
}
92+
else {
93+
94+
// default serial number
95+
6796
name[0] = 'H';
6897
name[1] = 'I';
6998
name[2] = 'D';
7099
name[3] = 'A' + (descriptorSize & 0x0F);
71100
name[4] = 'A' + ((descriptorSize >> 4) & 0x0F);
72101
return 5;
102+
}
73103
}
74104

75105
void HID_::AppendDescriptor(HIDSubDescriptor *node)
@@ -86,28 +116,102 @@ void HID_::AppendDescriptor(HIDSubDescriptor *node)
86116
descriptorSize += node->length;
87117
}
88118

89-
int HID_::SendReport(uint8_t id, const void* data, int len)
119+
int HID_::SetFeature(uint16_t id, const void* data, int len)
90120
{
91-
auto ret = USB_Send(pluggedEndpoint, &id, 1);
121+
if(!rootReport) {
122+
rootReport = new HIDReport(id, data, len);
123+
} else {
124+
HIDReport* current;
125+
int i=0;
126+
for ( current = rootReport; current; current = current->next, i++) {
127+
if(current->id == id) {
128+
return i;
129+
}
130+
// check if we are on the last report
131+
if(!current->next) {
132+
current->next = new HIDReport(id, data, len);
133+
break;
134+
}
135+
}
136+
137+
}
138+
139+
reportCount++;
140+
return reportCount;
141+
}
142+
143+
int HID_::SetStringFeature(uint8_t id, const uint8_t* index, const char* data) {
144+
145+
int res = SetFeature(id, index, 1);
146+
147+
if(res == 0) return 0;
148+
149+
res += SetFeature(0xFF00 | *index , data, strlen_P(data));
150+
151+
return res;
152+
}
153+
154+
bool HID_::LockFeature(uint16_t id, bool lock) {
155+
if(rootReport) {
156+
HIDReport* current;
157+
for(current = rootReport;current; current=current->next) {
158+
if(current->id == id) {
159+
current->lock = lock;
160+
return true;
161+
}
162+
}
163+
}
164+
return false;
165+
}
166+
167+
168+
int HID_::SendReport(uint16_t id, const void* data, int len)
169+
{
170+
auto ret = USB_Send(HID_TX, &id, 1);
92171
if (ret < 0) return ret;
93-
auto ret2 = USB_Send(pluggedEndpoint | TRANSFER_RELEASE, data, len);
172+
auto ret2 = USB_Send(HID_TX | TRANSFER_RELEASE, data, len);
94173
if (ret2 < 0) return ret2;
95174
return ret + ret2;
96175
}
97176

98-
bool HID_::setup(USBSetup& setup)
177+
HIDReport* HID_::GetFeature(uint16_t id)
99178
{
179+
HIDReport* current;
180+
int i=0;
181+
for(current=rootReport; current && i<reportCount; current=current->next, i++) {
182+
if(id == current->id) {
183+
return current;
184+
}
185+
}
186+
return (HIDReport*) NULL;
187+
}
188+
189+
bool HID_::setup(USBSetup& setup)
190+
{
100191
if (pluggedInterface != setup.wIndex) {
101192
return false;
102193
}
103194

104195
uint8_t request = setup.bRequest;
105196
uint8_t requestType = setup.bmRequestType;
106-
197+
107198
if (requestType == REQUEST_DEVICETOHOST_CLASS_INTERFACE)
108-
{
199+
{
109200
if (request == HID_GET_REPORT) {
110-
// TODO: HID_GetReport();
201+
202+
if(setup.wValueH == HID_REPORT_TYPE_FEATURE)
203+
{
204+
205+
HIDReport* current = GetFeature(setup.wValueL);
206+
if(current){
207+
if(USB_SendControl(0, &(current->id), 1)>0 &&
208+
USB_SendControl(0, current->data, current->length)>0)
209+
return true;
210+
}
211+
212+
return false;
213+
214+
}
111215
return true;
112216
}
113217
if (request == HID_GET_PROTOCOL) {
@@ -120,7 +224,7 @@ bool HID_::setup(USBSetup& setup)
120224
}
121225

122226
if (requestType == REQUEST_HOSTTODEVICE_CLASS_INTERFACE)
123-
{
227+
{
124228
if (request == HID_SET_PROTOCOL) {
125229
// The USB Host tells us if we are in boot or report mode.
126230
// This only works with a real boot compatible device.
@@ -133,24 +237,33 @@ bool HID_::setup(USBSetup& setup)
133237
}
134238
if (request == HID_SET_REPORT)
135239
{
136-
//uint8_t reportID = setup.wValueL;
137-
//uint16_t length = setup.wLength;
138-
//uint8_t data[length];
139-
// Make sure to not read more data than USB_EP_SIZE.
140-
// You can read multiple times through a loop.
141-
// The first byte (may!) contain the reportID on a multreport.
142-
//USB_RecvControl(data, length);
240+
if(setup.wValueH == HID_REPORT_TYPE_FEATURE)
241+
{
242+
243+
HIDReport* current = GetFeature(setup.wValueL);
244+
if(!current) return false;
245+
if(setup.wLength != current->length + 1) return false;
246+
uint8_t* data = new uint8_t[setup.wLength];
247+
USB_RecvControl(data, setup.wLength);
248+
if(*data != current->id) return false;
249+
memcpy((uint8_t*)current->data, data+1, current->length);
250+
delete[] data;
251+
return true;
252+
253+
}
254+
143255
}
144256
}
145257

146258
return false;
147259
}
148260

149-
HID_::HID_(void) : PluggableUSBModule(1, 1, epType),
261+
HID_::HID_(void) : PluggableUSBModule(2, 1, epType),
150262
rootNode(NULL), descriptorSize(0),
151263
protocol(HID_REPORT_PROTOCOL), idle(1)
152264
{
153265
epType[0] = EP_TYPE_INTERRUPT_IN;
266+
epType[1] = EP_TYPE_INTERRUPT_OUT;
154267
PluggableUSB().plug(this);
155268
}
156269

‎libraries/HID/src/HID.h

+66-21
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
/*
22
Copyright (c) 2015, Arduino LLC
33
Original code (pre-library): Copyright (c) 2011, Peter Barrett
4+
Modified code: Copyright (c) 2020, Aleksandr Bratchik
45
56
Permission to use, copy, modify, and/or distribute this software for
67
any purpose with or without fee is hereby granted, provided that the
@@ -21,7 +22,8 @@
2122

2223
#include <stdint.h>
2324
#include <Arduino.h>
24-
#include "PluggableUSB.h"
25+
#include <HardwareSerial.h>
26+
#include <PluggableUSB.h>
2527

2628
#if defined(USBCON)
2729

@@ -59,6 +61,14 @@
5961
#define HID_REPORT_TYPE_OUTPUT 2
6062
#define HID_REPORT_TYPE_FEATURE 3
6163

64+
#define HID_INTERFACE (CDC_ACM_INTERFACE + CDC_INTERFACE_COUNT) // HID Interface
65+
#define HID_FIRST_ENDPOINT (CDC_FIRST_ENDPOINT + CDC_ENPOINT_COUNT)
66+
#define HID_ENDPOINT_INT (HID_FIRST_ENDPOINT)
67+
#define HID_ENDPOINT_OUT (HID_FIRST_ENDPOINT+1)
68+
69+
#define HID_TX HID_ENDPOINT_INT
70+
#define HID_RX HID_ENDPOINT_OUT //++ EP HID_RX for ease of use with USB_Available & USB_Rec
71+
6272
typedef struct
6373
{
6474
uint8_t len; // 9
@@ -77,12 +87,24 @@ typedef struct
7787
InterfaceDescriptor hid;
7888
HIDDescDescriptor desc;
7989
EndpointDescriptor in;
90+
EndpointDescriptor out; //added
8091
} HIDDescriptor;
8192

93+
class HIDReport {
94+
public:
95+
HIDReport *next = NULL;
96+
HIDReport(uint16_t i, const void *d, uint8_t l) : id(i), data(d), length(l) {}
97+
98+
uint16_t id;
99+
const void* data;
100+
uint16_t length;
101+
bool lock;
102+
};
103+
82104
class HIDSubDescriptor {
83105
public:
84106
HIDSubDescriptor *next = NULL;
85-
HIDSubDescriptor(const void *d, const uint16_t l) : data(d), length(l) { }
107+
HIDSubDescriptor(const void *d, uint16_t l) : data(d), length(l) { }
86108

87109
const void* data;
88110
const uint16_t length;
@@ -91,34 +113,57 @@ class HIDSubDescriptor {
91113
class HID_ : public PluggableUSBModule
92114
{
93115
public:
94-
HID_(void);
95-
int begin(void);
96-
int SendReport(uint8_t id, const void* data, int len);
97-
void AppendDescriptor(HIDSubDescriptor* node);
98-
116+
HID_(void);
117+
int begin(void);
118+
int SendReport(uint16_t id, const void* data, int len);
119+
int SetFeature(uint16_t id, const void* data, int len);
120+
int SetStringFeature(uint8_t id, const uint8_t* index, const char* data);
121+
bool LockFeature(uint16_t id, bool lock);
122+
123+
void AppendDescriptor(HIDSubDescriptor* node);
124+
125+
void setOutput(Serial_& out) {
126+
dbg = &out;
127+
}
128+
129+
void setSerial(const char* s) {
130+
serial = s;
131+
}
132+
133+
HIDReport* GetFeature(uint16_t id);
134+
99135
protected:
100-
// Implementation of the PluggableUSBModule
101-
int getInterface(uint8_t* interfaceCount);
102-
int getDescriptor(USBSetup& setup);
103-
bool setup(USBSetup& setup);
104-
uint8_t getShortName(char* name);
105-
136+
// Implementation of the PluggableUSBModule
137+
int getInterface(uint8_t* interfaceCount);
138+
int getDescriptor(USBSetup& setup);
139+
bool setup(USBSetup& setup);
140+
uint8_t getShortName(char* name);
141+
106142
private:
107-
uint8_t epType[1];
108-
109-
HIDSubDescriptor* rootNode;
110-
uint16_t descriptorSize;
111-
112-
uint8_t protocol;
113-
uint8_t idle;
143+
uint8_t epType[2];
144+
145+
HIDSubDescriptor* rootNode;
146+
uint16_t descriptorSize;
147+
148+
uint8_t protocol;
149+
uint8_t idle;
150+
151+
// Buffer pointer to hold the feature data
152+
HIDReport* rootReport;
153+
uint16_t reportCount;
154+
155+
Serial_ *dbg;
156+
157+
const char *serial;
158+
114159
};
115160

116161
// Replacement for global singleton.
117162
// This function prevents static-initialization-order-fiasco
118163
// https://isocpp.org/wiki/faq/ctors#static-init-order-on-first-use
119164
HID_& HID();
120165

121-
#define D_HIDREPORT(length) { 9, 0x21, 0x01, 0x01, 0, 1, 0x22, lowByte(length), highByte(length) }
166+
#define D_HIDREPORT(length) { 9, 0x21, 0x01, 0x01, 0x21, 1, 0x22, lowByte(length), highByte(length) }
122167

123168
#endif // USBCON
124169

0 commit comments

Comments
 (0)