Prvni ulozeni z chegewara githubu

libraries/USB/examples/CompositeDevice/CompositeDevice.ino

@@ -0,0 +1,222 @@
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+#include "USB.h"
+#include "USBHIDMouse.h"
+#include "USBHIDKeyboard.h"
+#include "USBHIDGamepad.h"
+#include "USBHIDConsumerControl.h"
+#include "USBHIDSystemControl.h"
+#include "USBHIDVendor.h"
+#include "FirmwareMSC.h"
+
+#if !ARDUINO_USB_MSC_ON_BOOT
+FirmwareMSC MSC_Update;
+#endif
+#if ARDUINO_USB_CDC_ON_BOOT
+#define HWSerial Serial0
+#define USBSerial Serial
+#else
+#define HWSerial Serial
+USBCDC USBSerial;
+#endif
+
+USBHID HID;
+USBHIDKeyboard Keyboard;
+USBHIDMouse Mouse;
+USBHIDGamepad Gamepad;
+USBHIDConsumerControl ConsumerControl;
+USBHIDSystemControl SystemControl;
+USBHIDVendor Vendor;
+
+const int buttonPin = 0;
+int previousButtonState = HIGH;
+
+static void usbEventCallback(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data){
+  if(event_base == ARDUINO_USB_EVENTS){
+    arduino_usb_event_data_t * data = (arduino_usb_event_data_t*)event_data;
+    switch (event_id){
+      case ARDUINO_USB_STARTED_EVENT:
+        HWSerial.println("USB PLUGGED");
+        break;
+      case ARDUINO_USB_STOPPED_EVENT:
+        HWSerial.println("USB UNPLUGGED");
+        break;
+      case ARDUINO_USB_SUSPEND_EVENT:
+        HWSerial.printf("USB SUSPENDED: remote_wakeup_en: %u\n", data->suspend.remote_wakeup_en);
+        break;
+      case ARDUINO_USB_RESUME_EVENT:
+        HWSerial.println("USB RESUMED");
+        break;
+      
+      default:
+        break;
+    }
+  } else if(event_base == ARDUINO_USB_CDC_EVENTS){
+    arduino_usb_cdc_event_data_t * data = (arduino_usb_cdc_event_data_t*)event_data;
+    switch (event_id){
+      case ARDUINO_USB_CDC_CONNECTED_EVENT:
+        HWSerial.println("CDC CONNECTED");
+        break;
+      case ARDUINO_USB_CDC_DISCONNECTED_EVENT:
+        HWSerial.println("CDC DISCONNECTED");
+        break;
+      case ARDUINO_USB_CDC_LINE_STATE_EVENT:
+        HWSerial.printf("CDC LINE STATE: dtr: %u, rts: %u\n", data->line_state.dtr, data->line_state.rts);
+        break;
+      case ARDUINO_USB_CDC_LINE_CODING_EVENT:
+        HWSerial.printf("CDC LINE CODING: bit_rate: %u, data_bits: %u, stop_bits: %u, parity: %u\n", data->line_coding.bit_rate, data->line_coding.data_bits, data->line_coding.stop_bits, data->line_coding.parity);
+        break;
+      case ARDUINO_USB_CDC_RX_EVENT:
+        HWSerial.printf("CDC RX [%u]:", data->rx.len);
+        {
+            uint8_t buf[data->rx.len];
+            size_t len = USBSerial.read(buf, data->rx.len);
+            HWSerial.write(buf, len);
+        }
+        HWSerial.println();
+        break;
+      case ARDUINO_USB_CDC_RX_OVERFLOW_EVENT:
+        HWSerial.printf("CDC RX Overflow of %d bytes", data->rx_overflow.dropped_bytes);
+        break;
+
+      default:
+        break;
+    }
+  } else if(event_base == ARDUINO_FIRMWARE_MSC_EVENTS){
+    arduino_firmware_msc_event_data_t * data = (arduino_firmware_msc_event_data_t*)event_data;
+    switch (event_id){
+      case ARDUINO_FIRMWARE_MSC_START_EVENT:
+        HWSerial.println("MSC Update Start");
+        break;
+      case ARDUINO_FIRMWARE_MSC_WRITE_EVENT:
+        //HWSerial.printf("MSC Update Write %u bytes at offset %u\n", data->write.size, data->write.offset);
+        HWSerial.print(".");
+        break;
+      case ARDUINO_FIRMWARE_MSC_END_EVENT:
+        HWSerial.printf("\nMSC Update End: %u bytes\n", data->end.size);
+        break;
+      case ARDUINO_FIRMWARE_MSC_ERROR_EVENT:
+        HWSerial.printf("MSC Update ERROR! Progress: %u bytes\n", data->error.size);
+        break;
+      case ARDUINO_FIRMWARE_MSC_POWER_EVENT:
+        HWSerial.printf("MSC Update Power: power: %u, start: %u, eject: %u\n", data->power.power_condition, data->power.start, data->power.load_eject);
+        break;
+      
+      default:
+        break;
+    }
+  } else if(event_base == ARDUINO_USB_HID_EVENTS){
+    arduino_usb_hid_event_data_t * data = (arduino_usb_hid_event_data_t*)event_data;
+    switch (event_id){
+      case ARDUINO_USB_HID_SET_PROTOCOL_EVENT:
+        HWSerial.printf("HID SET PROTOCOL: %s\n", data->set_protocol.protocol?"REPORT":"BOOT");
+        break;
+      case ARDUINO_USB_HID_SET_IDLE_EVENT:
+        HWSerial.printf("HID SET IDLE: %u\n", data->set_idle.idle_rate);
+        break;
+      
+      default:
+        break;
+    }
+  } else if(event_base == ARDUINO_USB_HID_KEYBOARD_EVENTS){
+    arduino_usb_hid_keyboard_event_data_t * data = (arduino_usb_hid_keyboard_event_data_t*)event_data;
+    switch (event_id){
+      case ARDUINO_USB_HID_KEYBOARD_LED_EVENT:
+        HWSerial.printf("HID KEYBOARD LED: NumLock:%u, CapsLock:%u, ScrollLock:%u\n", data->numlock, data->capslock, data->scrolllock);
+        break;
+      
+      default:
+        break;
+    }
+  } else if(event_base == ARDUINO_USB_HID_VENDOR_EVENTS){
+    arduino_usb_hid_vendor_event_data_t * data = (arduino_usb_hid_vendor_event_data_t*)event_data;
+    switch (event_id){
+      case ARDUINO_USB_HID_VENDOR_GET_FEATURE_EVENT:
+        HWSerial.printf("HID VENDOR GET FEATURE: len:%u\n", data->len);
+        for(uint16_t i=0; i<data->len; i++){
+          HWSerial.write(data->buffer[i]?data->buffer[i]:'.');
+        }
+        HWSerial.println();
+        break;
+      case ARDUINO_USB_HID_VENDOR_SET_FEATURE_EVENT:
+        HWSerial.printf("HID VENDOR SET FEATURE: len:%u\n", data->len);
+        for(uint16_t i=0; i<data->len; i++){
+          HWSerial.write(data->buffer[i]?data->buffer[i]:'.');
+        }
+        HWSerial.println();
+        break;
+      case ARDUINO_USB_HID_VENDOR_OUTPUT_EVENT:
+        HWSerial.printf("HID VENDOR OUTPUT: len:%u\n", data->len);
+        for(uint16_t i=0; i<data->len; i++){
+          HWSerial.write(Vendor.read());
+        }
+        HWSerial.println();
+        break;
+      
+      default:
+        break;
+    }
+  }
+}
+
+void setup() {
+  HWSerial.begin(115200);
+  HWSerial.setDebugOutput(true);
+  
+  USB.onEvent(usbEventCallback);
+  USBSerial.onEvent(usbEventCallback);
+  MSC_Update.onEvent(usbEventCallback);
+  HID.onEvent(usbEventCallback);
+  Keyboard.onEvent(usbEventCallback);
+  Vendor.onEvent(usbEventCallback);
+  
+  USBSerial.begin();
+  MSC_Update.begin();
+  Vendor.begin();
+  Mouse.begin();
+  Keyboard.begin();
+  Gamepad.begin();
+  ConsumerControl.begin();
+  SystemControl.begin();
+  USB.begin();
+}
+
+void loop() {
+  int buttonState = digitalRead(buttonPin);
+  if (HID.ready() && buttonState != previousButtonState) {
+    previousButtonState = buttonState;
+    if (buttonState == LOW) {
+      HWSerial.println("Button Pressed");
+      USBSerial.println("Button Pressed");
+      Vendor.println("Button Pressed");
+      Mouse.move(10,10);
+      Keyboard.pressRaw(HID_KEY_CAPS_LOCK);
+      Gamepad.leftStick(100,100);
+      ConsumerControl.press(CONSUMER_CONTROL_VOLUME_INCREMENT);
+      //SystemControl.press(SYSTEM_CONTROL_POWER_OFF);
+    } else {
+      Keyboard.releaseRaw(HID_KEY_CAPS_LOCK);
+      Gamepad.leftStick(0,0);
+      ConsumerControl.release();
+      //SystemControl.release();
+      Vendor.println("Button Released");
+      USBSerial.println("Button Released");
+      HWSerial.println("Button Released");
+    }
+    delay(100);
+  }
+  
+  while(HWSerial.available()){
+    size_t l = HWSerial.available();
+    uint8_t b[l];
+    l = HWSerial.read(b, l);
+    USBSerial.write(b, l);
+    if(HID.ready()){
+      Vendor.write(b,l);
+    }
+  }
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/ConsumerControl/ConsumerControl.ino

@@ -0,0 +1,27 @@
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+#include "USB.h"
+#include "USBHIDConsumerControl.h"
+USBHIDConsumerControl ConsumerControl;
+
+const int buttonPin = 0;
+int previousButtonState = HIGH;
+
+void setup() {
+  pinMode(buttonPin, INPUT_PULLUP);
+  ConsumerControl.begin();
+  USB.begin();
+}
+
+void loop() {
+  int buttonState = digitalRead(buttonPin);
+  if ((buttonState != previousButtonState) && (buttonState == LOW)) {
+    ConsumerControl.press(CONSUMER_CONTROL_VOLUME_INCREMENT);
+    ConsumerControl.release();
+  }
+  previousButtonState = buttonState;
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/CustomHIDDevice/CustomHIDDevice.ino

@@ -0,0 +1,85 @@
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+#include "USB.h"
+#include "USBHID.h"
+USBHID HID;
+
+static const uint8_t report_descriptor[] = { // 8 axis
+    0x05, 0x01,        // Usage Page (Generic Desktop Ctrls)
+    0x09, 0x04,        // Usage (Joystick)
+    0xa1, 0x01,        // Collection (Application)
+    0xa1, 0x00,        //   Collection (Physical)
+    0x05, 0x01,        //   Usage Page (Generic Desktop Ctrls)
+    0x09, 0x30,        //     Usage (X)
+    0x09, 0x31,        //     Usage (Y)
+    0x09, 0x32,        //     Usage (Z)
+    0x09, 0x33,        //     Usage (Rx)
+    0x09, 0x34,        //     Usage (Ry)
+    0x09, 0x35,        //     Usage (Rz)
+    0x09, 0x36,        //     Usage (Slider)
+    0x09, 0x36,        //     Usage (Slider)
+    0x15, 0x81,        //     Logical Minimum (-127)
+    0x25, 0x7f,        //     Logical Maximum (127)
+    0x75, 0x08,        //     Report Size (8)
+    0x95, 0x08,        //     Report Count (8)
+    0x81, 0x02,        //     Input (Data,Var,Abs,No Wrap,Linear,Preferred State,No Null Position)
+    0xC0,              //   End Collection
+    0xC0,              // End Collection
+};
+
+class CustomHIDDevice: public USBHIDDevice {
+public:
+  CustomHIDDevice(void){
+    static bool initialized = false;
+    if(!initialized){
+      initialized = true;
+      HID.addDevice(this, sizeof(report_descriptor));
+    }
+  }
+  
+  void begin(void){
+    HID.begin();
+  }
+    
+  uint16_t _onGetDescriptor(uint8_t* buffer){
+    memcpy(buffer, report_descriptor, sizeof(report_descriptor));
+    return sizeof(report_descriptor);
+  }
+
+  bool send(uint8_t * value){
+    return HID.SendReport(0, value, 8);
+  }
+};
+
+CustomHIDDevice Device;
+#endif /* ARDUINO_USB_MODE */
+
+const int buttonPin = 0;
+int previousButtonState = HIGH;
+uint8_t axis[8];
+
+void setup() {
+  Serial.begin(115200);
+  Serial.setDebugOutput(true);
+  pinMode(buttonPin, INPUT_PULLUP);
+  Device.begin();
+  USB.begin();
+}
+
+void loop() {
+  int buttonState = digitalRead(buttonPin);
+  if (HID.ready() && buttonState != previousButtonState) {
+    previousButtonState = buttonState;
+    if (buttonState == LOW) {
+      Serial.println("Button Pressed");
+      axis[0] = random() & 0xFF;
+      Device.send(axis);
+    } else {
+      Serial.println("Button Released");
+    }
+    delay(100);
+  }
+}

libraries/USB/examples/FirmwareMSC/FirmwareMSC.ino

@@ -0,0 +1,80 @@
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+#include "USB.h"
+#include "FirmwareMSC.h"
+
+#if !ARDUINO_USB_MSC_ON_BOOT
+FirmwareMSC MSC_Update;
+#endif
+#if ARDUINO_USB_CDC_ON_BOOT
+#define HWSerial Serial0
+#define USBSerial Serial
+#else
+#define HWSerial Serial
+USBCDC USBSerial;
+#endif
+
+static void usbEventCallback(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data){
+  if(event_base == ARDUINO_USB_EVENTS){
+    arduino_usb_event_data_t * data = (arduino_usb_event_data_t*)event_data;
+    switch (event_id){
+      case ARDUINO_USB_STARTED_EVENT:
+        HWSerial.println("USB PLUGGED");
+        break;
+      case ARDUINO_USB_STOPPED_EVENT:
+        HWSerial.println("USB UNPLUGGED");
+        break;
+      case ARDUINO_USB_SUSPEND_EVENT:
+        HWSerial.printf("USB SUSPENDED: remote_wakeup_en: %u\n", data->suspend.remote_wakeup_en);
+        break;
+      case ARDUINO_USB_RESUME_EVENT:
+        HWSerial.println("USB RESUMED");
+        break;
+      
+      default:
+        break;
+    }
+  } else if(event_base == ARDUINO_FIRMWARE_MSC_EVENTS){
+    arduino_firmware_msc_event_data_t * data = (arduino_firmware_msc_event_data_t*)event_data;
+    switch (event_id){
+      case ARDUINO_FIRMWARE_MSC_START_EVENT:
+        HWSerial.println("MSC Update Start");
+        break;
+      case ARDUINO_FIRMWARE_MSC_WRITE_EVENT:
+        //HWSerial.printf("MSC Update Write %u bytes at offset %u\n", data->write.size, data->write.offset);
+        HWSerial.print(".");
+        break;
+      case ARDUINO_FIRMWARE_MSC_END_EVENT:
+        HWSerial.printf("\nMSC Update End: %u bytes\n", data->end.size);
+        break;
+      case ARDUINO_FIRMWARE_MSC_ERROR_EVENT:
+        HWSerial.printf("MSC Update ERROR! Progress: %u bytes\n", data->error.size);
+        break;
+      case ARDUINO_FIRMWARE_MSC_POWER_EVENT:
+        HWSerial.printf("MSC Update Power: power: %u, start: %u, eject: %u", data->power.power_condition, data->power.start, data->power.load_eject);
+        break;
+      
+      default:
+        break;
+    }
+  }
+}
+
+void setup() {
+  HWSerial.begin(115200);
+  HWSerial.setDebugOutput(true);
+
+  USB.onEvent(usbEventCallback);
+  MSC_Update.onEvent(usbEventCallback);
+  MSC_Update.begin();
+  USBSerial.begin();
+  USB.begin();
+}
+
+void loop() {
+  // put your main code here, to run repeatedly
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/Gamepad/Gamepad.ino

@@ -0,0 +1,27 @@
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+#include "USB.h"
+#include "USBHIDGamepad.h"
+USBHIDGamepad Gamepad;
+
+const int buttonPin = 0;
+int previousButtonState = HIGH;
+
+void setup() {
+  pinMode(buttonPin, INPUT_PULLUP);
+  Gamepad.begin();
+  USB.begin();
+}
+
+void loop() {
+  int buttonState = digitalRead(buttonPin);
+  if ((buttonState != previousButtonState) && (buttonState == LOW)) {
+    Gamepad.pressButton(BUTTON_START);
+    Gamepad.releaseButton(BUTTON_START);
+  }
+  previousButtonState = buttonState;
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/HIDVendor/HIDVendor.ino

@@ -0,0 +1,58 @@
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+#include "USB.h"
+#include "USBHIDVendor.h"
+USBHIDVendor Vendor;
+
+const int buttonPin = 0;
+int previousButtonState = HIGH;
+
+static void vendorEventCallback(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data){
+  if(event_base == ARDUINO_USB_HID_VENDOR_EVENTS){
+    arduino_usb_hid_vendor_event_data_t * data = (arduino_usb_hid_vendor_event_data_t*)event_data;
+    switch (event_id){
+      case ARDUINO_USB_HID_VENDOR_GET_FEATURE_EVENT:
+        Serial.printf("HID VENDOR GET FEATURE: len:%u\n", data->len);
+        break;
+      case ARDUINO_USB_HID_VENDOR_SET_FEATURE_EVENT:
+        Serial.printf("HID VENDOR SET FEATURE: len:%u\n", data->len);
+        for(uint16_t i=0; i<data->len; i++){
+          Serial.printf("0x%02X ",*(data->buffer));
+        }
+        Serial.println();
+        break;
+      case ARDUINO_USB_HID_VENDOR_OUTPUT_EVENT:
+        Serial.printf("HID VENDOR OUTPUT: len:%u\n", data->len);
+        // for(uint16_t i=0; i<data->len; i++){
+        //   Serial.write(Vendor.read());
+        // }
+        break;
+      
+      default:
+        break;
+    }
+  }
+}
+
+void setup() {
+  pinMode(buttonPin, INPUT_PULLUP);
+  Serial.begin(115200);
+  Vendor.onEvent(vendorEventCallback);
+  Vendor.begin();
+  USB.begin();
+}
+
+void loop() {
+  int buttonState = digitalRead(buttonPin);
+  if ((buttonState != previousButtonState) && (buttonState == LOW)) {
+    Vendor.println("Hello World!");
+  }
+  previousButtonState = buttonState;
+  while(Vendor.available()){
+    Serial.write(Vendor.read());
+  }
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/Keyboard/KeyboardLogout/KeyboardLogout.ino

@@ -0,0 +1,98 @@
+/*
+  Keyboard logout
+
+  This sketch demonstrates the Keyboard library.
+
+  When you connect pin 2 to ground, it performs a logout.
+  It uses keyboard combinations to do this, as follows:
+
+  On Windows, CTRL-ALT-DEL followed by ALT-l
+  On Ubuntu, CTRL-ALT-DEL, and ENTER
+  On OSX, CMD-SHIFT-q
+
+  To wake: Spacebar.
+
+  Circuit:
+  - Arduino Leonardo or Micro
+  - wire to connect D2 to ground
+
+  created 6 Mar 2012
+  modified 27 Mar 2012
+  by Tom Igoe
+
+  This example is in the public domain.
+
+  http://www.arduino.cc/en/Tutorial/KeyboardLogout
+*/
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+
+#define OSX 0
+#define WINDOWS 1
+#define UBUNTU 2
+
+#include "USB.h"
+#include "USBHIDKeyboard.h"
+USBHIDKeyboard Keyboard;
+
+// change this to match your platform:
+int platform = OSX;
+
+void setup() {
+  // make pin 0 an input and turn on the pull-up resistor so it goes high unless
+  // connected to ground:
+  pinMode(0, INPUT_PULLUP);
+  Keyboard.begin();
+  USB.begin();
+}
+
+void loop() {
+  while (digitalRead(0) == HIGH) {
+    // do nothing until pin 2 goes low
+    delay(500);
+  }
+  delay(1000);
+
+  switch (platform) {
+    case OSX:
+      Keyboard.press(KEY_LEFT_GUI);
+      // Shift-Q logs out:
+      Keyboard.press(KEY_LEFT_SHIFT);
+      Keyboard.press('Q');
+      delay(100);
+      Keyboard.releaseAll();
+      // enter:
+      Keyboard.write(KEY_RETURN);
+      break;
+    case WINDOWS:
+      // CTRL-ALT-DEL:
+      Keyboard.press(KEY_LEFT_CTRL);
+      Keyboard.press(KEY_LEFT_ALT);
+      Keyboard.press(KEY_DELETE);
+      delay(100);
+      Keyboard.releaseAll();
+      // ALT-l:
+      delay(2000);
+      Keyboard.press(KEY_LEFT_ALT);
+      Keyboard.press('l');
+      Keyboard.releaseAll();
+      break;
+    case UBUNTU:
+      // CTRL-ALT-DEL:
+      Keyboard.press(KEY_LEFT_CTRL);
+      Keyboard.press(KEY_LEFT_ALT);
+      Keyboard.press(KEY_DELETE);
+      delay(1000);
+      Keyboard.releaseAll();
+      // Enter to confirm logout:
+      Keyboard.write(KEY_RETURN);
+      break;
+  }
+
+  // do nothing:
+  while (true) delay(1000);
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/Keyboard/KeyboardMessage/KeyboardMessage.ino

@@ -0,0 +1,61 @@
+/*
+  Keyboard Message test
+
+  For the Arduino Leonardo and Micro.
+
+  Sends a text string when a button is pressed.
+
+  The circuit:
+  - pushbutton attached from pin 0 to ground
+  - 10 kilohm resistor attached from pin 0 to +5V
+
+  created 24 Oct 2011
+  modified 27 Mar 2012
+  by Tom Igoe
+  modified 11 Nov 2013
+  by Scott Fitzgerald
+
+  This example code is in the public domain.
+
+  http://www.arduino.cc/en/Tutorial/KeyboardMessage
+*/
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+
+#include "USB.h"
+#include "USBHIDKeyboard.h"
+USBHIDKeyboard Keyboard;
+
+const int buttonPin = 0;          // input pin for pushbutton
+int previousButtonState = HIGH;   // for checking the state of a pushButton
+int counter = 0;                  // button push counter
+
+void setup() {
+  // make the pushButton pin an input:
+  pinMode(buttonPin, INPUT_PULLUP);
+  // initialize control over the keyboard:
+  Keyboard.begin();
+  USB.begin();
+}
+
+void loop() {
+  // read the pushbutton:
+  int buttonState = digitalRead(buttonPin);
+  // if the button state has changed,
+  if ((buttonState != previousButtonState)
+      // and it's currently pressed:
+      && (buttonState == LOW)) {
+    // increment the button counter
+    counter++;
+    // type out a message
+    Keyboard.print("You pressed the button ");
+    Keyboard.print(counter);
+    Keyboard.println(" times.");
+  }
+  // save the current button state for comparison next time:
+  previousButtonState = buttonState;
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/Keyboard/KeyboardReprogram/KeyboardReprogram.ino

@@ -0,0 +1,112 @@
+/*
+  Arduino Programs Blink
+
+  This sketch demonstrates the Keyboard library.
+
+  For Leonardo and Due boards only.
+
+  When you connect pin 2 to ground, it creates a new window with a key
+  combination (CTRL-N), then types in the Blink sketch, then auto-formats the
+  text using another key combination (CTRL-T), then uploads the sketch to the
+  currently selected Arduino using a final key combination (CTRL-U).
+
+  Circuit:
+  - Arduino Leonardo, Micro, Due, LilyPad USB, or Yún
+  - wire to connect D2 to ground
+
+  created 5 Mar 2012
+  modified 29 Mar 2012
+  by Tom Igoe
+  modified 3 May 2014
+  by Scott Fitzgerald
+
+  This example is in the public domain.
+
+  http://www.arduino.cc/en/Tutorial/KeyboardReprogram
+*/
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+
+#include "USB.h"
+#include "USBHIDKeyboard.h"
+USBHIDKeyboard Keyboard;
+
+// use this option for OSX.
+// Comment it out if using Windows or Linux:
+char ctrlKey = KEY_LEFT_GUI;
+// use this option for Windows and Linux.
+// leave commented out if using OSX:
+//  char ctrlKey = KEY_LEFT_CTRL;
+
+
+void setup() {
+  // make pin 0 an input and turn on the pull-up resistor so it goes high unless
+  // connected to ground:
+  pinMode(0, INPUT_PULLUP);
+  // initialize control over the keyboard:
+  Keyboard.begin();
+  USB.begin();
+}
+
+void loop() {
+  while (digitalRead(0) == HIGH) {
+    // do nothing until pin 0 goes low
+    delay(500);
+  }
+  delay(1000);
+  // new document:
+  Keyboard.press(ctrlKey);
+  Keyboard.press('n');
+  delay(100);
+  Keyboard.releaseAll();
+  // wait for new window to open:
+  delay(1000);
+
+  // versions of the Arduino IDE after 1.5 pre-populate new sketches with
+  // setup() and loop() functions let's clear the window before typing anything new
+  // select all
+  Keyboard.press(ctrlKey);
+  Keyboard.press('a');
+  delay(500);
+  Keyboard.releaseAll();
+  // delete the selected text
+  Keyboard.write(KEY_BACKSPACE);
+  delay(500);
+
+  // Type out "blink":
+  Keyboard.println("void setup() {");
+  Keyboard.println("pinMode(13, OUTPUT);");
+  Keyboard.println("}");
+  Keyboard.println();
+  Keyboard.println("void loop() {");
+  Keyboard.println("digitalWrite(13, HIGH);");
+  Keyboard.print("delay(3000);");
+  // 3000 ms is too long. Delete it:
+  for (int keystrokes = 0; keystrokes < 6; keystrokes++) {
+    delay(500);
+    Keyboard.write(KEY_BACKSPACE);
+  }
+  // make it 1000 instead:
+  Keyboard.println("1000);");
+  Keyboard.println("digitalWrite(13, LOW);");
+  Keyboard.println("delay(1000);");
+  Keyboard.println("}");
+  // tidy up:
+  Keyboard.press(ctrlKey);
+  Keyboard.press('t');
+  delay(100);
+  Keyboard.releaseAll();
+  delay(3000);
+  // upload code:
+  Keyboard.press(ctrlKey);
+  Keyboard.press('u');
+  delay(100);
+  Keyboard.releaseAll();
+
+  // wait for the sweet oblivion of reprogramming:
+  while (true)delay(1000);
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/Keyboard/KeyboardSerial/KeyboardSerial.ino

@@ -0,0 +1,46 @@
+/*
+  Keyboard test
+
+  Reads a byte from the serial port, sends a keystroke back.
+  The sent keystroke is one higher than what's received, e.g. if you send a,
+  you get b, send A you get B, and so forth.
+
+  The circuit:
+  - none
+
+  created 21 Oct 2011
+  modified 27 Mar 2012
+  by Tom Igoe
+
+  This example code is in the public domain.
+
+  http://www.arduino.cc/en/Tutorial/KeyboardSerial
+*/
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+
+#include "USB.h"
+#include "USBHIDKeyboard.h"
+USBHIDKeyboard Keyboard;
+
+void setup() {
+  // open the serial port:
+  Serial.begin(115200);
+  // initialize control over the keyboard:
+  Keyboard.begin();
+  USB.begin();
+}
+
+void loop() {
+  // check for incoming serial data:
+  if (Serial.available() > 0) {
+    // read incoming serial data:
+    char inChar = Serial.read();
+    // Type the next ASCII value from what you received:
+    Keyboard.write(inChar + 1);
+  }
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/KeyboardAndMouseControl/KeyboardAndMouseControl.ino

@@ -0,0 +1,101 @@
+/*
+  KeyboardAndMouseControl
+
+  Hardware:
+  - five pushbuttons attached to D12, D13, D14, D15, D0
+
+  The mouse movement is always relative. This sketch reads four pushbuttons, and
+  uses them to set the movement of the mouse.
+
+  WARNING: When you use the Mouse.move() command, the Arduino takes over your
+  mouse! Make sure you have control before you use the mouse commands.
+
+  created 15 Mar 2012
+  modified 27 Mar 2012
+  by Tom Igoe
+
+  This example code is in the public domain.
+
+  http://www.arduino.cc/en/Tutorial/KeyboardAndMouseControl
+*/
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+
+#include "USB.h"
+#include "USBHIDMouse.h"
+#include "USBHIDKeyboard.h"
+USBHIDMouse Mouse;
+USBHIDKeyboard Keyboard;
+
+// set pin numbers for the five buttons:
+const int upButton = 12;
+const int downButton = 13;
+const int leftButton = 14;
+const int rightButton = 15;
+const int mouseButton = 0;
+
+void setup() { // initialize the buttons' inputs:
+  pinMode(upButton, INPUT_PULLUP);
+  pinMode(downButton, INPUT_PULLUP);
+  pinMode(leftButton, INPUT_PULLUP);
+  pinMode(rightButton, INPUT_PULLUP);
+  pinMode(mouseButton, INPUT_PULLUP);
+
+  Serial.begin(115200);
+  // initialize mouse control:
+  Mouse.begin();
+  Keyboard.begin();
+  USB.begin();
+}
+
+void loop() {
+  // use serial input to control the mouse:
+  if (Serial.available() > 0) {
+    char inChar = Serial.read();
+
+    switch (inChar) {
+      case 'u':
+        // move mouse up
+        Mouse.move(0, -40);
+        break;
+      case 'd':
+        // move mouse down
+        Mouse.move(0, 40);
+        break;
+      case 'l':
+        // move mouse left
+        Mouse.move(-40, 0);
+        break;
+      case 'r':
+        // move mouse right
+        Mouse.move(40, 0);
+        break;
+      case 'm':
+        // perform mouse left click
+        Mouse.click(MOUSE_LEFT);
+        break;
+    }
+  }
+
+  // use the pushbuttons to control the keyboard:
+  if (digitalRead(upButton) == LOW) {
+    Keyboard.write('u');
+  }
+  if (digitalRead(downButton) == LOW) {
+    Keyboard.write('d');
+  }
+  if (digitalRead(leftButton) == LOW) {
+    Keyboard.write('l');
+  }
+  if (digitalRead(rightButton) == LOW) {
+    Keyboard.write('r');
+  }
+  if (digitalRead(mouseButton) == LOW) {
+    Keyboard.write('m');
+  }
+  delay(5);
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/Mouse/ButtonMouseControl/ButtonMouseControl.ino

@@ -0,0 +1,92 @@
+/*
+  ButtonMouseControl
+
+  Controls the mouse from five pushbuttons on an Arduino Leonardo, Micro or Due.
+
+  Hardware:
+  - five pushbuttons attached to D12, D13, D14, D15, D0
+
+  The mouse movement is always relative. This sketch reads four pushbuttons,
+  and uses them to set the movement of the mouse.
+
+  WARNING: When you use the Mouse.move() command, the Arduino takes over your
+  mouse! Make sure you have control before you use the mouse commands.
+
+  created 15 Mar 2012
+  modified 27 Mar 2012
+  by Tom Igoe
+
+  This example code is in the public domain.
+
+  http://www.arduino.cc/en/Tutorial/ButtonMouseControl
+*/
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+
+#include "USB.h"
+#include "USBHIDMouse.h"
+USBHIDMouse Mouse;
+
+
+// set pin numbers for the five buttons:
+const int upButton = 12;
+const int downButton = 13;
+const int leftButton = 14;
+const int rightButton = 15;
+const int mouseButton = 0;
+
+int range = 5;              // output range of X or Y movement; affects movement speed
+int responseDelay = 10;     // response delay of the mouse, in ms
+
+
+void setup() {
+  // initialize the buttons' inputs:
+  pinMode(upButton, INPUT_PULLUP);
+  pinMode(downButton, INPUT_PULLUP);
+  pinMode(leftButton, INPUT_PULLUP);
+  pinMode(rightButton, INPUT_PULLUP);
+  pinMode(mouseButton, INPUT_PULLUP);
+  // initialize mouse control:
+  Mouse.begin();
+  USB.begin();
+}
+
+void loop() {
+  // read the buttons:
+  int upState = digitalRead(upButton);
+  int downState = digitalRead(downButton);
+  int rightState = digitalRead(rightButton);
+  int leftState = digitalRead(leftButton);
+  int clickState = digitalRead(mouseButton);
+
+  // calculate the movement distance based on the button states:
+  int  xDistance = (leftState - rightState) * range;
+  int  yDistance = (upState - downState) * range;
+
+  // if X or Y is non-zero, move:
+  if ((xDistance != 0) || (yDistance != 0)) {
+    Mouse.move(xDistance, yDistance, 0);
+  }
+
+  // if the mouse button is pressed:
+  if (clickState == LOW) {
+    // if the mouse is not pressed, press it:
+    if (!Mouse.isPressed(MOUSE_LEFT)) {
+      Mouse.press(MOUSE_LEFT);
+    }
+  }
+  // else the mouse button is not pressed:
+  else {
+    // if the mouse is pressed, release it:
+    if (Mouse.isPressed(MOUSE_LEFT)) {
+      Mouse.release(MOUSE_LEFT);
+    }
+  }
+
+  // a delay so the mouse doesn't move too fast:
+  delay(responseDelay);
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/SystemControl/SystemControl.ino

@@ -0,0 +1,27 @@
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+#include "USB.h"
+#include "USBHIDSystemControl.h"
+USBHIDSystemControl SystemControl;
+
+const int buttonPin = 0;
+int previousButtonState = HIGH;
+
+void setup() {
+  pinMode(buttonPin, INPUT_PULLUP);
+  SystemControl.begin();
+  USB.begin();
+}
+
+void loop() {
+  int buttonState = digitalRead(buttonPin);
+  if ((buttonState != previousButtonState) && (buttonState == LOW)) {
+    SystemControl.press(SYSTEM_CONTROL_POWER_OFF);
+    SystemControl.release();
+  }
+  previousButtonState = buttonState;
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/USBMSC/USBMSC.ino

@@ -0,0 +1,198 @@
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+#include "USB.h"
+#include "USBMSC.h"
+
+#if ARDUINO_USB_CDC_ON_BOOT
+#define HWSerial Serial0
+#define USBSerial Serial
+#else
+#define HWSerial Serial
+USBCDC USBSerial;
+#endif
+
+USBMSC MSC;
+
+#define FAT_U8(v) ((v) & 0xFF)
+#define FAT_U16(v) FAT_U8(v), FAT_U8((v) >> 8)
+#define FAT_U32(v) FAT_U8(v), FAT_U8((v) >> 8), FAT_U8((v) >> 16), FAT_U8((v) >> 24)
+#define FAT_MS2B(s,ms)    FAT_U8(((((s) & 0x1) * 1000) + (ms)) / 10)
+#define FAT_HMS2B(h,m,s)  FAT_U8(((s) >> 1)|(((m) & 0x7) << 5)),      FAT_U8((((m) >> 3) & 0x7)|((h) << 3))
+#define FAT_YMD2B(y,m,d)  FAT_U8(((d) & 0x1F)|(((m) & 0x7) << 5)),    FAT_U8((((m) >> 3) & 0x1)|((((y) - 1980) & 0x7F) << 1))
+#define FAT_TBL2B(l,h)    FAT_U8(l), FAT_U8(((l >> 8) & 0xF) | ((h << 4) & 0xF0)), FAT_U8(h >> 4)
+
+#define README_CONTENTS "This is tinyusb's MassStorage Class demo.\r\n\r\nIf you find any bugs or get any questions, feel free to file an\r\nissue at github.com/hathach/tinyusb"
+
+static const uint32_t DISK_SECTOR_COUNT = 2 * 8; // 8KB is the smallest size that windows allow to mount
+static const uint16_t DISK_SECTOR_SIZE = 512;    // Should be 512
+static const uint16_t DISC_SECTORS_PER_TABLE = 1; //each table sector can fit 170KB (340 sectors)
+
+static uint8_t msc_disk[DISK_SECTOR_COUNT][DISK_SECTOR_SIZE] =
+{
+  //------------- Block0: Boot Sector -------------//
+  {
+    // Header (62 bytes)
+    0xEB, 0x3C, 0x90, //jump_instruction
+    'M' , 'S' , 'D' , 'O' , 'S' , '5' , '.' , '0' , //oem_name
+    FAT_U16(DISK_SECTOR_SIZE), //bytes_per_sector
+    FAT_U8(1),    //sectors_per_cluster
+    FAT_U16(1),   //reserved_sectors_count
+    FAT_U8(1),    //file_alloc_tables_num
+    FAT_U16(16),  //max_root_dir_entries
+    FAT_U16(DISK_SECTOR_COUNT), //fat12_sector_num
+    0xF8,         //media_descriptor
+    FAT_U16(DISC_SECTORS_PER_TABLE),   //sectors_per_alloc_table;//FAT12 and FAT16
+    FAT_U16(1),   //sectors_per_track;//A value of 0 may indicate LBA-only access
+    FAT_U16(1),   //num_heads
+    FAT_U32(0),   //hidden_sectors_count
+    FAT_U32(0),   //total_sectors_32
+    0x00,         //physical_drive_number;0x00 for (first) removable media, 0x80 for (first) fixed disk
+    0x00,         //reserved
+    0x29,         //extended_boot_signature;//should be 0x29
+    FAT_U32(0x1234), //serial_number: 0x1234 => 1234
+    'T' , 'i' , 'n' , 'y' , 'U' , 'S' , 'B' , ' ' , 'M' , 'S' , 'C' , //volume_label padded with spaces (0x20)
+    'F' , 'A' , 'T' , '1' , '2' , ' ' , ' ' , ' ' ,  //file_system_type padded with spaces (0x20)
+
+    // Zero up to 2 last bytes of FAT magic code (448 bytes)
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+
+     //boot signature (2 bytes)
+    0x55, 0xAA
+  },
+
+  //------------- Block1: FAT12 Table -------------//
+  {
+    FAT_TBL2B(0xFF8, 0xFFF), FAT_TBL2B(0xFFF, 0x000) // first 2 entries must be 0xFF8 0xFFF, third entry is cluster end of readme file
+  },
+
+  //------------- Block2: Root Directory -------------//
+  {
+    // first entry is volume label
+    'E' , 'S' , 'P' , '3' , '2' , 'S' , '2' , ' ' , 
+    'M' , 'S' , 'C' , 
+    0x08, //FILE_ATTR_VOLUME_LABEL
+    0x00, 
+    FAT_MS2B(0,0), 
+    FAT_HMS2B(0,0,0),
+    FAT_YMD2B(0,0,0), 
+    FAT_YMD2B(0,0,0), 
+    FAT_U16(0), 
+    FAT_HMS2B(13,42,30),  //last_modified_hms
+    FAT_YMD2B(2018,11,5), //last_modified_ymd
+    FAT_U16(0), 
+    FAT_U32(0),
+    
+    // second entry is readme file
+    'R' , 'E' , 'A' , 'D' , 'M' , 'E' , ' ' , ' ' ,//file_name[8]; padded with spaces (0x20)
+    'T' , 'X' , 'T' ,     //file_extension[3]; padded with spaces (0x20)
+    0x20,                 //file attributes: FILE_ATTR_ARCHIVE
+    0x00,                 //ignore
+    FAT_MS2B(1,980),      //creation_time_10_ms (max 199x10 = 1s 990ms)
+    FAT_HMS2B(13,42,36),  //create_time_hms [5:6:5] => h:m:(s/2)
+    FAT_YMD2B(2018,11,5), //create_time_ymd [7:4:5] => (y+1980):m:d
+    FAT_YMD2B(2020,11,5), //last_access_ymd
+    FAT_U16(0),           //extended_attributes
+    FAT_HMS2B(13,44,16),  //last_modified_hms
+    FAT_YMD2B(2019,11,5), //last_modified_ymd
+    FAT_U16(2),           //start of file in cluster
+    FAT_U32(sizeof(README_CONTENTS) - 1) //file size
+  },
+
+  //------------- Block3: Readme Content -------------//
+  README_CONTENTS
+};
+
+static int32_t onWrite(uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize){
+  HWSerial.printf("MSC WRITE: lba: %u, offset: %u, bufsize: %u\n", lba, offset, bufsize);
+  memcpy(msc_disk[lba] + offset, buffer, bufsize);
+  return bufsize;
+}
+
+static int32_t onRead(uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize){
+  HWSerial.printf("MSC READ: lba: %u, offset: %u, bufsize: %u\n", lba, offset, bufsize);
+  memcpy(buffer, msc_disk[lba] + offset, bufsize);
+  return bufsize;
+}
+
+static bool onStartStop(uint8_t power_condition, bool start, bool load_eject){
+  HWSerial.printf("MSC START/STOP: power: %u, start: %u, eject: %u\n", power_condition, start, load_eject);
+  return true;
+}
+
+static void usbEventCallback(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data){
+  if(event_base == ARDUINO_USB_EVENTS){
+    arduino_usb_event_data_t * data = (arduino_usb_event_data_t*)event_data;
+    switch (event_id){
+      case ARDUINO_USB_STARTED_EVENT:
+        HWSerial.println("USB PLUGGED");
+        break;
+      case ARDUINO_USB_STOPPED_EVENT:
+        HWSerial.println("USB UNPLUGGED");
+        break;
+      case ARDUINO_USB_SUSPEND_EVENT:
+        HWSerial.printf("USB SUSPENDED: remote_wakeup_en: %u\n", data->suspend.remote_wakeup_en);
+        break;
+      case ARDUINO_USB_RESUME_EVENT:
+        HWSerial.println("USB RESUMED");
+        break;
+      
+      default:
+        break;
+    }
+  }
+}
+
+void setup() {
+  HWSerial.begin(115200);
+  HWSerial.setDebugOutput(true);
+
+  USB.onEvent(usbEventCallback);
+  MSC.vendorID("ESP32");//max 8 chars
+  MSC.productID("USB_MSC");//max 16 chars
+  MSC.productRevision("1.0");//max 4 chars
+  MSC.onStartStop(onStartStop);
+  MSC.onRead(onRead);
+  MSC.onWrite(onWrite);
+  MSC.mediaPresent(true);
+  MSC.begin(DISK_SECTOR_COUNT, DISK_SECTOR_SIZE);
+  USBSerial.begin();
+  USB.begin();
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/USBSerial/USBSerial.ino

@@ -0,0 +1,89 @@
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+#include "USB.h"
+
+#if ARDUINO_USB_CDC_ON_BOOT
+#define HWSerial Serial0
+#define USBSerial Serial
+#else
+#define HWSerial Serial
+USBCDC USBSerial;
+#endif
+
+static void usbEventCallback(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data){
+  if(event_base == ARDUINO_USB_EVENTS){
+    arduino_usb_event_data_t * data = (arduino_usb_event_data_t*)event_data;
+    switch (event_id){
+      case ARDUINO_USB_STARTED_EVENT:
+        HWSerial.println("USB PLUGGED");
+        break;
+      case ARDUINO_USB_STOPPED_EVENT:
+        HWSerial.println("USB UNPLUGGED");
+        break;
+      case ARDUINO_USB_SUSPEND_EVENT:
+        HWSerial.printf("USB SUSPENDED: remote_wakeup_en: %u\n", data->suspend.remote_wakeup_en);
+        break;
+      case ARDUINO_USB_RESUME_EVENT:
+        HWSerial.println("USB RESUMED");
+        break;
+      
+      default:
+        break;
+    }
+  } else if(event_base == ARDUINO_USB_CDC_EVENTS){
+    arduino_usb_cdc_event_data_t * data = (arduino_usb_cdc_event_data_t*)event_data;
+    switch (event_id){
+      case ARDUINO_USB_CDC_CONNECTED_EVENT:
+        HWSerial.println("CDC CONNECTED");
+        break;
+      case ARDUINO_USB_CDC_DISCONNECTED_EVENT:
+        HWSerial.println("CDC DISCONNECTED");
+        break;
+      case ARDUINO_USB_CDC_LINE_STATE_EVENT:
+        HWSerial.printf("CDC LINE STATE: dtr: %u, rts: %u\n", data->line_state.dtr, data->line_state.rts);
+        break;
+      case ARDUINO_USB_CDC_LINE_CODING_EVENT:
+        HWSerial.printf("CDC LINE CODING: bit_rate: %u, data_bits: %u, stop_bits: %u, parity: %u\n", data->line_coding.bit_rate, data->line_coding.data_bits, data->line_coding.stop_bits, data->line_coding.parity);
+        break;
+      case ARDUINO_USB_CDC_RX_EVENT:
+        HWSerial.printf("CDC RX [%u]:", data->rx.len);
+        {
+            uint8_t buf[data->rx.len];
+            size_t len = USBSerial.read(buf, data->rx.len);
+            HWSerial.write(buf, len);
+        }
+        HWSerial.println();
+        break;
+       case ARDUINO_USB_CDC_RX_OVERFLOW_EVENT:
+        HWSerial.printf("CDC RX Overflow of %d bytes", data->rx_overflow.dropped_bytes);
+        break;
+     
+      default:
+        break;
+    }
+  }
+}
+
+void setup() {
+  HWSerial.begin(115200);
+  HWSerial.setDebugOutput(true);
+  
+  USB.onEvent(usbEventCallback);
+  USBSerial.onEvent(usbEventCallback);
+  
+  USBSerial.begin();
+  USB.begin();
+}
+
+void loop() {
+  while(HWSerial.available()){
+    size_t l = HWSerial.available();
+    uint8_t b[l];
+    l = HWSerial.read(b, l);
+    USBSerial.write(b, l);
+  }
+}
+#endif /* ARDUINO_USB_MODE */

libraries/USB/examples/USBVendor/USBVendor.ino

@@ -0,0 +1,197 @@
+#if ARDUINO_USB_MODE
+#warning This sketch should be used when USB is in OTG mode
+void setup(){}
+void loop(){}
+#else
+#include "USB.h"
+#include "USBVendor.h"
+
+#if ARDUINO_USB_CDC_ON_BOOT
+#define HWSerial Serial0
+#else
+#define HWSerial Serial
+#endif
+
+USBVendor Vendor;
+const int buttonPin = 0;
+
+//CDC Control Requests
+#define REQUEST_SET_LINE_CODING 0x20
+#define REQUEST_GET_LINE_CODING 0x21
+#define REQUEST_SET_CONTROL_LINE_STATE 0x22
+
+//CDC Line Coding Control Request Structure
+typedef struct __attribute__ ((packed)) {
+  uint32_t bit_rate;
+  uint8_t  stop_bits; //0: 1 stop bit, 1: 1.5 stop bits, 2: 2 stop bits
+  uint8_t  parity;    //0: None, 1: Odd, 2: Even, 3: Mark, 4: Space
+  uint8_t  data_bits; //5, 6, 7, 8 or 16
+} request_line_coding_t;
+
+static request_line_coding_t vendor_line_coding = {9600, 0, 0, 8};
+
+// Bit 0:  DTR (Data Terminal Ready), Bit 1: RTS (Request to Send)
+static uint8_t vendor_line_state = 0;
+
+//USB and Vendor events
+static void usbEventCallback(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) {
+  if (event_base == ARDUINO_USB_EVENTS) {
+    arduino_usb_event_data_t * data = (arduino_usb_event_data_t*)event_data;
+    switch (event_id) {
+      case ARDUINO_USB_STARTED_EVENT:
+        HWSerial.println("USB PLUGGED");
+        break;
+      case ARDUINO_USB_STOPPED_EVENT:
+        HWSerial.println("USB UNPLUGGED");
+        break;
+      case ARDUINO_USB_SUSPEND_EVENT:
+        HWSerial.printf("USB SUSPENDED: remote_wakeup_en: %u\n", data->suspend.remote_wakeup_en);
+        break;
+      case ARDUINO_USB_RESUME_EVENT:
+        HWSerial.println("USB RESUMED");
+        break;
+
+      default:
+        break;
+    }
+  } else if (event_base == ARDUINO_USB_VENDOR_EVENTS) {
+    arduino_usb_vendor_event_data_t * data = (arduino_usb_vendor_event_data_t*)event_data;
+    switch (event_id) {
+      case ARDUINO_USB_VENDOR_DATA_EVENT:
+        HWSerial.printf("Vendor RX: len:%u\n", data->data.len);
+        for (uint16_t i = 0; i < data->data.len; i++) {
+          HWSerial.write(Vendor.read());
+        }
+        HWSerial.println();
+        break;
+
+      default:
+        break;
+    }
+  }
+}
+
+static const char * strRequestDirections[] = {"OUT", "IN"};
+static const char * strRequestTypes[] = {"STANDARD", "CLASS", "VENDOR", "INVALID"};
+static const char * strRequestRecipients[] = {"DEVICE", "INTERFACE", "ENDPOINT", "OTHER"};
+static const char * strRequestStages[] = {"SETUP", "DATA", "ACK"};
+
+//Handle USB requests to the vendor interface
+bool vendorRequestCallback(uint8_t rhport, uint8_t requestStage, arduino_usb_control_request_t const * request) {
+  HWSerial.printf("Vendor Request: Stage: %5s, Direction: %3s, Type: %8s, Recipient: %9s, bRequest: 0x%02x, wValue: 0x%04x, wIndex: %u, wLength: %u\n", 
+    strRequestStages[requestStage],
+    strRequestDirections[request->bmRequestDirection],
+    strRequestTypes[request->bmRequestType],
+    strRequestRecipients[request->bmRequestRecipient],
+    request->bRequest, request->wValue, request->wIndex, request->wLength);
+
+  bool result = false;
+
+  if (request->bmRequestDirection == REQUEST_DIRECTION_OUT &&
+      request->bmRequestType == REQUEST_TYPE_STANDARD &&
+      request->bmRequestRecipient == REQUEST_RECIPIENT_INTERFACE &&
+      request->bRequest == 0x0b
+     ) {
+    if (requestStage == REQUEST_STAGE_SETUP) {
+      // response with status OK
+      result = Vendor.sendResponse(rhport, request);
+    } else {
+      result = true;
+    }
+  } else
+    //Implement CDC Control Requests
+    if (request->bmRequestType == REQUEST_TYPE_CLASS && request->bmRequestRecipient == REQUEST_RECIPIENT_DEVICE) {
+      switch (request->bRequest) {
+
+        case REQUEST_SET_LINE_CODING: //0x20
+          // Accept only direction OUT with data size 7
+          if (request->wLength != sizeof(request_line_coding_t) || request->bmRequestDirection != REQUEST_DIRECTION_OUT) {
+            break;
+          }
+          if (requestStage == REQUEST_STAGE_SETUP) {
+            //Send the response in setup stage (it will write the data to vendor_line_coding in the DATA stage)
+            result = Vendor.sendResponse(rhport, request, (void*) &vendor_line_coding, sizeof(request_line_coding_t));
+          } else if (requestStage == REQUEST_STAGE_ACK) {
+            //In the ACK stage the response is complete
+            HWSerial.printf("Vendor Line Coding: bit_rate: %u, data_bits: %u, stop_bits: %u, parity: %u\n", vendor_line_coding.bit_rate, vendor_line_coding.data_bits, vendor_line_coding.stop_bits, vendor_line_coding.parity);
+          }
+          result = true;
+          break;
+
+        case REQUEST_GET_LINE_CODING: //0x21
+          // Accept only direction IN with data size 7
+          if (request->wLength != sizeof(request_line_coding_t) || request->bmRequestDirection != REQUEST_DIRECTION_IN) {
+            break;
+          }
+          if (requestStage == REQUEST_STAGE_SETUP) {
+            //Send the response in setup stage (it will write the data to vendor_line_coding in the DATA stage)
+            result = Vendor.sendResponse(rhport, request, (void*) &vendor_line_coding, sizeof(request_line_coding_t));
+          }
+          result = true;
+          break;
+
+        case REQUEST_SET_CONTROL_LINE_STATE: //0x22
+          // Accept only direction OUT with data size 0
+          if (request->wLength != 0 || request->bmRequestDirection != REQUEST_DIRECTION_OUT) {
+            break;
+          }
+          if (requestStage == REQUEST_STAGE_SETUP) {
+            //Send the response in setup stage
+            vendor_line_state = request->wValue;
+            result = Vendor.sendResponse(rhport, request);
+          } else if (requestStage == REQUEST_STAGE_ACK) {
+            //In the ACK stage the response is complete
+            bool dtr = (vendor_line_state & 1) != 0;
+            bool rts = (vendor_line_state & 2) != 0;
+            HWSerial.printf("Vendor Line State: dtr: %u, rts: %u\n", dtr, rts);
+          }
+          result = true;
+          break;
+
+        default:
+          // stall unknown request
+          break;
+      }
+    }
+
+  return result;
+}
+
+void setup() {
+  pinMode(buttonPin, INPUT_PULLUP);
+  HWSerial.begin(115200);
+  HWSerial.setDebugOutput(true);
+
+  Vendor.onEvent(usbEventCallback);
+  Vendor.onRequest(vendorRequestCallback);
+  Vendor.begin();
+
+  USB.onEvent(usbEventCallback);
+  USB.webUSB(true);
+  USB.webUSBURL("http://localhost/webusb");
+  USB.begin();
+}
+
+void loop() {
+  static int previousButtonState = HIGH;
+  int buttonState = digitalRead(buttonPin);
+  if (buttonState != previousButtonState) {
+    previousButtonState = buttonState;
+    if (buttonState == LOW) {
+      HWSerial.println("Button Pressed");
+      Vendor.println("Button Pressed");
+    } else {
+      Vendor.println("Button Released");
+      HWSerial.println("Button Released");
+    }
+    delay(100);
+  }
+
+  while (HWSerial.available()) {
+    size_t l = HWSerial.available();
+    uint8_t b[l];
+    l = HWSerial.read(b, l);
+    Vendor.write(b, l);
+  }
+}
+#endif /* ARDUINO_USB_MODE */