add HID output endpoint support

Author: hathach

examples/hid_generic_inout/hid_generic_inout.ino

@@ -0,0 +1,85 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Ha Thach for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/* This example demonstrate HID Generic raw Input & Output.
+ * It will receive data from Host (In endpoint) and echo back (Out endpoint).
+ * HID Report descriptor use vendor for usage page (using template TUD_HID_REPORT_DESC_GENERIC_INOUT)
+ *
+ * Run 'python3 hid_test.py' on your PC to send and receive data to this device.
+ * Python and `hid` package is required, for installation please follow
+ * https://pypi.org/project/hid/
+ */
+
+#include "Adafruit_TinyUSB.h"
+
+// HID report descriptor using TinyUSB's template
+// Generic In Out with 64 bytes report (max)
+uint8_t const desc_hid_report[] =
+{
+  TUD_HID_REPORT_DESC_GENERIC_INOUT(64)
+};
+
+Adafruit_USBD_HID usb_hid;
+
+// the setup function runs once when you press reset or power the board
+void setup()
+{
+  usb_hid.enableOutEndpoint(true);
+  usb_hid.setPollInterval(2);
+  usb_hid.setReportDescriptor(desc_hid_report, sizeof(desc_hid_report));
+  usb_hid.setReportCallback(get_report_callback, set_report_callback);
+
+  usb_hid.begin();
+
+  Serial.begin(115200);
+  while ( !Serial ) delay(10);   // wait for native usb
+
+  Serial.println("Adafruit TinyUSB HID Generic In Out example");
+}
+
+void loop()
+{
+  // nothing to do
+}
+
+// Invoked when received GET_REPORT control request
+// Application must fill buffer report's content and return its length.
+// Return zero will cause the stack to STALL request
+uint16_t get_report_callback (uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)
+{
+  // not used in this example
+  return 0;
+}
+
+// Invoked when received SET_REPORT control request or
+// received data on OUT endpoint ( Report ID = 0, Type = 0 )
+void set_report_callback(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)
+{
+  // This example doesn't use multiple report and report ID
+  (void) report_id;
+  (void) report_type;
+
+  // echo back anything we received from host
+  usb_hid.sendReport(0, buffer, bufsize);
+}

examples/hid_generic_inout/hid_test.py

@@ -0,0 +1,18 @@
+# Install python3 HID package https://pypi.org/project/hid/
+import hid
+
+# default is Adafruit VID
+USB_VID = 0x239A
+
+print("Openning HID device with VID = 0x%X" % USB_VID)
+
+for dict in hid.enumerate(USB_VID):
+    print(dict)
+    dev = hid.Device(dict['vendor_id'], dict['product_id'])
+    if dev:
+        while True:
+            # Get input from console and encode to UTF8 for array of chars.
+            str_out = input("Send text to HID Device : ").encode('utf-8')
+            dev.write(str_out)
+            str_in = dev.read(64)
+            print("Received from HID Device:", str_in, '\n')

src/Adafruit_USBD_HID.cpp

@@ -24,21 +24,20 @@
 
 #include "Adafruit_USBD_HID.h"
 
-
-//--------------------------------------------------------------------+
-//
-//--------------------------------------------------------------------+
 #define EPOUT   0x00
 #define EPIN    0x80
 
 uint8_t const _ascii2keycode[128][2] =  { HID_ASCII_TO_KEYCODE };
 
+static Adafruit_USBD_HID* _hid_dev = NULL;
+
 //------------- IMPLEMENTATION -------------//
 Adafruit_USBD_HID::Adafruit_USBD_HID(void)
 {
   _interval_ms = 10;
   _protocol = HID_PROTOCOL_NONE;
 
+  _out_endpoint = false;
   _mouse_button = 0;
 
   _desc_report = NULL;
@@ -58,6 +57,11 @@ void Adafruit_USBD_HID::setBootProtocol(uint8_t protocol)
   _protocol = protocol;
 }
 
+void Adafruit_USBD_HID::enableOutEndpoint(bool enable)
+{
+  _out_endpoint = enable;
+}
+
 void Adafruit_USBD_HID::setReportDescriptor(uint8_t const* desc_report, uint16_t len)
 {
   _desc_report = desc_report;
@@ -74,18 +78,33 @@ uint16_t Adafruit_USBD_HID::getDescriptor(uint8_t* buf, uint16_t bufsize)
 {
   if ( !_desc_report_len ) return 0;
 
-  uint8_t desc[] = { TUD_HID_DESCRIPTOR(0, 0, _protocol, _desc_report_len, EPIN, 16, _interval_ms) };
-  uint16_t const len = sizeof(desc);
+  if ( _out_endpoint )
+  {
+    uint8_t desc[] = { TUD_HID_INOUT_DESCRIPTOR(0, 0, _protocol, _desc_report_len, EPIN, EPOUT, CFG_TUD_HID_BUFSIZE, _interval_ms) };
+    uint16_t const len = sizeof(desc);
+
+    if ( bufsize < len ) return 0;
+    memcpy(buf, desc, len);
+
+    return len;
+  }else
+  {
+    uint8_t desc[] = { TUD_HID_DESCRIPTOR(0, 0, _protocol, _desc_report_len, EPIN, CFG_TUD_HID_BUFSIZE, _interval_ms) };
+    uint16_t const len = sizeof(desc);
 
-  if ( bufsize < len ) return 0;
-  memcpy(buf, desc, len);
-  return len;
+    if ( bufsize < len ) return 0;
+    memcpy(buf, desc, len);
+
+    return len;
+  }
 }
 
 bool Adafruit_USBD_HID::begin(void)
 {
   if ( !USBDevice.addInterface(*this) ) return false;
+
   tud_desc_set.hid_report = _desc_report;
+  _hid_dev = this;
 
   return true;
 }
@@ -100,6 +119,31 @@ bool Adafruit_USBD_HID::sendReport(uint8_t report_id, void const* report, uint8_
   return tud_hid_report(report_id, report, len);
 }
 
+//------------- TinyUSB callbacks -------------//
+extern "C"
+{
+
+// Invoked when received GET_REPORT control request
+// Application must fill buffer report's content and return its length.
+// Return zero will cause the stack to STALL request
+uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)
+{
+  if ( !(_hid_dev && _hid_dev->_get_report_cb) ) return 0;
+
+  return _hid_dev->_get_report_cb(report_id, report_type, buffer, reqlen);
+}
+
+// Invoked when received SET_REPORT control request or
+// received data on OUT endpoint ( Report ID = 0, Type = 0 )
+void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)
+{
+  if ( !(_hid_dev && _hid_dev->_set_report_cb) ) return;
+
+  _hid_dev->_set_report_cb(report_id, report_type, buffer, bufsize);
+}
+
+} // extern "C"
+
 //--------------------------------------------------------------------+
 // Keyboard
 //--------------------------------------------------------------------+

src/Adafruit_USBD_HID.h

@@ -37,6 +37,7 @@ class Adafruit_USBD_HID : Adafruit_USBD_Interface
 
     void setPollInterval(uint8_t interval_ms);
     void setBootProtocol(uint8_t protocol); // 0: None, 1: Keyboard, 2:Mouse
+    void enableOutEndpoint(bool enable);
     void setReportDescriptor(uint8_t const* desc_report, uint16_t len);
     void setReportCallback(get_report_callback_t get_report, set_report_callback_t set_report);
 
@@ -63,13 +64,17 @@ class Adafruit_USBD_HID : Adafruit_USBD_Interface
   private:
     uint8_t _interval_ms;
     uint8_t _protocol;
+    bool    _out_endpoint;
     uint8_t _mouse_button;
 
     uint16_t _desc_report_len;
     uint8_t const* _desc_report;
 
     get_report_callback_t _get_report_cb;
     set_report_callback_t _set_report_cb;
+
+    friend uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen);
+    friend void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize);
 };
 
 #endif /* ADAFRUIT_USBD_HID_H_ */

src/Adafruit_USBD_MSC.cpp

@@ -83,6 +83,7 @@ bool Adafruit_USBD_MSC::begin(void)
   return true;
 }
 
+//------------- TinyUSB callbacks -------------//
 extern "C"
 {
 
@@ -180,5 +181,5 @@ void tud_msc_write10_complete_cb (uint8_t lun)
   return _msc_dev->_lun[lun].fl_cb();
 }
 
-}
+} // extern "C"