Added UM FeatherS2 Neo to boards.txt and added appropriate variants. (#5615)

Fixes: https://github.com/espressif/arduino-esp32/issues/5573

To reproduce:
1. Run any sample code that starts a BLE server, and does not call `setCallbacks`.
2. Connect to the device using the "LightBlue" app on iOS.
3. Observe crash shown in the issue linked above.

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,16 @@
+----------------------------------------------------------------------------------------------------------------------------------------------------
+This entire section can be deleted if all items are checked.
+
+*By completing this PR sufficiently, you help us to improve the quality of Release Notes*
+
+### Checklist
+
+1. [ ] Please provide specific title of the PR describing the change, including the component name (eg."Update of Documentation link on Readme.md")
+2. [ ] Please provide related links (eg. Issue, other Project, submodule PR..)
+----------------------------------------------------------------------------------------------------------------------------------------------------
+
+## Summary
+Please describe your proposed PR and what it contains.
+
+## Impact
+Please describe impact of your PR and it's function.

.github/scripts/install-platformio-esp32.sh

@@ -1,19 +1,43 @@
 #!/bin/bash
 
 export PLATFORMIO_ESP32_PATH="$HOME/.platformio/packages/framework-arduinoespressif32"
-PLATFORMIO_ESP32_URL="https://github.com/platformio/platform-espressif32.git#feature/idf-v4.0"
+PLATFORMIO_ESP32_URL="https://github.com/platformio/platform-espressif32.git#feature/arduino-idf-master"
+
+XTENSA32_TOOLCHAIN_VERSION="8.4.0+2021r1"
+XTENSA32S2_TOOLCHAIN_VERSION="8.4.0+2021r1"
+RISCV_TOOLCHAIN_VERSION="8.4.0+2021r1"
+ESPTOOLPY_VERSION="~1.30100.0"
+ESPRESSIF_ORGANIZATION_NAME="espressif"
 
 echo "Installing Python Wheel ..."
 pip install wheel > /dev/null 2>&1
 
 echo "Installing PlatformIO ..."
-pip install -U https://github.com/platformio/platformio/archive/develop.zip > /dev/null 2>&1
+pip install -U https://github.com/platformio/platformio/archive/master.zip > /dev/null 2>&1
 
 echo "Installing Platform ESP32 ..."
-python -m platformio platform install $PLATFORMIO_ESP32_URL > /dev/null 2>&1
+python -m platformio platform install $PLATFORMIO_ESP32_URL  > /dev/null 2>&1
 
-echo "Replacing the framework version ..."
-python -c "import json; import os; fp=open(os.path.expanduser('~/.platformio/platforms/espressif32/platform.json'), 'r+'); data=json.load(fp); data['packages']['framework-arduinoespressif32']['version'] = '*'; fp.seek(0); fp.truncate(); json.dump(data, fp); fp.close()"
+echo "Replacing the package versions ..."
+replace_script="import json; import os;"
+replace_script+="fp=open(os.path.expanduser('~/.platformio/platforms/espressif32/platform.json'), 'r+');"
+replace_script+="data=json.load(fp);"
+# Use framework sources from the repository
+replace_script+="data['packages']['framework-arduinoespressif32']['version'] = '*';"
+replace_script+="del data['packages']['framework-arduinoespressif32']['owner'];"
+# Use toolchain packages from the "espressif" organization
+replace_script+="data['packages']['toolchain-xtensa-esp32']['owner']='$ESPRESSIF_ORGANIZATION_NAME';"
+replace_script+="data['packages']['toolchain-xtensa-esp32s2']['owner']='$ESPRESSIF_ORGANIZATION_NAME';"
+replace_script+="data['packages']['toolchain-riscv32-esp']['owner']='$ESPRESSIF_ORGANIZATION_NAME';"
+# Update versions to use the upstream
+replace_script+="data['packages']['toolchain-xtensa-esp32']['version']='$XTENSA32_TOOLCHAIN_VERSION';"
+replace_script+="data['packages']['toolchain-xtensa-esp32s2']['version']='$XTENSA32S2_TOOLCHAIN_VERSION';"
+replace_script+="data['packages']['toolchain-riscv32-esp']['version']='$RISCV_TOOLCHAIN_VERSION';"
+# esptool.py may require an upstream version (for now platformio is the owner)
+replace_script+="data['packages']['tool-esptoolpy']['version']='$ESPTOOLPY_VERSION';"
+# Save results
+replace_script+="fp.seek(0);fp.truncate();json.dump(data, fp, indent=2);fp.close()"
+python -c "$replace_script"
 
 if [ "$GITHUB_REPOSITORY" == "espressif/arduino-esp32" ];  then
 	echo "Linking Core..."

.github/scripts/on-pages.sh

@@ -85,53 +85,59 @@ function git_safe_upload_to_pages(){
     return $?
 }
 
-EVENT_JSON=`cat $GITHUB_EVENT_PATH`
+git_safe_upload_to_pages "index.md" "README.md"
 
-echo "GITHUB_EVENT_PATH: $GITHUB_EVENT_PATH"
-echo "EVENT_JSON: $EVENT_JSON"
+# At some point github stopped providing a list of edited file
+# but we also stopped havong documentation in md format,
+# so we can skip this portion safely and update just the index
 
-pages_added=`echo "$EVENT_JSON" | jq -r '.commits[].added[]'`
-echo "added: $pages_added"
-pages_modified=`echo "$EVENT_JSON" | jq -r '.commits[].modified[]'`
-echo "modified: $pages_modified"
-pages_removed=`echo "$EVENT_JSON" | jq -r '.commits[].removed[]'`
-echo "removed: $pages_removed"
+# EVENT_JSON=`cat $GITHUB_EVENT_PATH`
 
-for page in $pages_added; do
-    if [[ $page != "README.md" && $page != "docs/"* ]]; then
-        continue
-    fi
-    echo "Adding '$page' to pages ..."
-    if [[ $page == "README.md" ]]; then
-        git_safe_upload_to_pages "index.md" "README.md"
-    else
-        git_safe_upload_to_pages "$page" "$page"
-    fi
-done
+# echo "GITHUB_EVENT_PATH: $GITHUB_EVENT_PATH"
+# echo "EVENT_JSON: $EVENT_JSON"
 
-for page in $pages_modified; do
-    if [[ $page != "README.md" && $page != "docs/"* ]]; then
-        continue
-    fi
-    echo "Modifying '$page' ..."
-    if [[ $page == "README.md" ]]; then
-        git_safe_upload_to_pages "index.md" "README.md"
-    else
-        git_safe_upload_to_pages "$page" "$page"
-    fi
-done
+# pages_added=`echo "$EVENT_JSON" | jq -r '.commits[].added[]'`
+# echo "added: $pages_added"
+# pages_modified=`echo "$EVENT_JSON" | jq -r '.commits[].modified[]'`
+# echo "modified: $pages_modified"
+# pages_removed=`echo "$EVENT_JSON" | jq -r '.commits[].removed[]'`
+# echo "removed: $pages_removed"
 
-for page in $pages_removed; do
-    if [[ $page != "README.md" && $page != "docs/"* ]]; then
-        continue
-    fi
-    echo "Removing '$page' from pages ..."
-    if [[ $page == "README.md" ]]; then
-        git_remove_from_pages "README.md" > /dev/null
-    else
-        git_remove_from_pages "$page" > /dev/null
-    fi
-done
+# for page in $pages_added; do
+#     if [[ $page != "README.md" && $page != "docs/"* ]]; then
+#         continue
+#     fi
+#     echo "Adding '$page' to pages ..."
+#     if [[ $page == "README.md" ]]; then
+#         git_safe_upload_to_pages "index.md" "README.md"
+#     else
+#         git_safe_upload_to_pages "$page" "$page"
+#     fi
+# done
+
+# for page in $pages_modified; do
+#     if [[ $page != "README.md" && $page != "docs/"* ]]; then
+#         continue
+#     fi
+#     echo "Modifying '$page' ..."
+#     if [[ $page == "README.md" ]]; then
+#         git_safe_upload_to_pages "index.md" "README.md"
+#     else
+#         git_safe_upload_to_pages "$page" "$page"
+#     fi
+# done
+
+# for page in $pages_removed; do
+#     if [[ $page != "README.md" && $page != "docs/"* ]]; then
+#         continue
+#     fi
+#     echo "Removing '$page' from pages ..."
+#     if [[ $page == "README.md" ]]; then
+#         git_remove_from_pages "README.md" > /dev/null
+#     else
+#         git_remove_from_pages "$page" > /dev/null
+#     fi
+# done
 
 echo
 echo "DONE!"

.github/stale.yml

@@ -26,7 +26,7 @@ exemptMilestones: false
 exemptAssignees: false
 
 # Label to use when marking as stale
-staleLabel: Status: Stale
+staleLabel: "Status: Stale"
 
 # Comment to post when marking as stale. Set to `false` to disable
 markComment: >

.github/workflows/docs.yml

@@ -0,0 +1,38 @@
+name: ReadTheDocs CI
+
+on:
+  push:
+    branches:
+    - master
+    - release/*
+    paths:
+    - 'docs/**'
+    - '.github/workflows/docs.yml'
+  pull_request:
+    paths:
+    - 'docs/**'
+    - '.github/workflows/docs.yml'
+
+jobs:
+
+  build-docs:
+    name: Build ReadTheDocs
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+    - uses: actions/setup-python@v2
+      with:
+        python-version: '3.x'
+    - name: Build
+      run: |
+        sudo apt update
+        sudo apt install python3-pip python3-setuptools
+        # GitHub CI installs pip3 and setuptools outside the path.
+        # Update the path to include them and run.
+        PATH=/home/runner/.local/bin:$PATH pip3 install --user -r ./docs/requirements.txt
+        cd ./docs && PATH=/home/runner/.local/bin:$PATH SPHINXOPTS="-W" make html

.github/workflows/gh-pages.yml

@@ -7,7 +7,6 @@ on:
     - pages
     paths:
     - 'README.md'
-    - 'docs/**'
     - '.github/scripts/on-pages.sh'
     - '.github/workflows/gh-pages.yml'
 

.gitignore

@@ -6,6 +6,7 @@ tools/esptool
 tools/esptool.exe
 tools/mkspiffs
 tools/mklittlefs
+tools/mkfatfs.exe
 .DS_Store
  
 #Ignore files built by Visual Studio/Visual Micro
@@ -17,4 +18,6 @@ __vm/
 .vscode/
 platform.sloeber.txt
 boards.sloeber.txt
-tools/mklittlefs
+
+# Ignore docs build (Sphinx)
+docs/build

CMakeLists.txt

@@ -7,7 +7,6 @@ set(CORE_SRCS
   cores/esp32/esp32-hal-dac.c
   cores/esp32/esp32-hal-gpio.c
   cores/esp32/esp32-hal-i2c.c
-  cores/esp32/esp32-hal-log.c
   cores/esp32/esp32-hal-ledc.c
   cores/esp32/esp32-hal-matrix.c
   cores/esp32/esp32-hal-misc.c
@@ -33,8 +32,12 @@ set(CORE_SRCS
   cores/esp32/stdlib_noniso.c
   cores/esp32/Stream.cpp
   cores/esp32/StreamString.cpp
+  cores/esp32/HWCDC.cpp
   cores/esp32/USB.cpp
   cores/esp32/USBCDC.cpp
+  cores/esp32/USBMSC.cpp
+  cores/esp32/FirmwareMSC.cpp
+  cores/esp32/firmware_msc_fat.c
   cores/esp32/wiring_pulse.c
   cores/esp32/wiring_shift.c
   cores/esp32/WMath.cpp
@@ -56,7 +59,7 @@ set(LIBRARY_SRCS
   libraries/FS/src/vfs_api.cpp
   libraries/HTTPClient/src/HTTPClient.cpp
   libraries/HTTPUpdate/src/HTTPUpdate.cpp
-  libraries/LITTLEFS/src/LITTLEFS.cpp
+  libraries/LittleFS/src/LittleFS.cpp
   libraries/NetBIOS/src/NetBIOS.cpp
   libraries/Preferences/src/Preferences.cpp
   libraries/RainMaker/src/RMaker.cpp
@@ -74,6 +77,14 @@ set(LIBRARY_SRCS
   libraries/Ticker/src/Ticker.cpp
   libraries/Update/src/Updater.cpp
   libraries/Update/src/HttpsOTAUpdate.cpp
+  libraries/USB/src/USBHID.cpp
+  libraries/USB/src/USBHIDMouse.cpp
+  libraries/USB/src/USBHIDKeyboard.cpp
+  libraries/USB/src/USBHIDGamepad.cpp
+  libraries/USB/src/USBHIDConsumerControl.cpp
+  libraries/USB/src/USBHIDSystemControl.cpp
+  libraries/USB/src/USBHIDVendor.cpp
+  libraries/USB/src/USBVendor.cpp
   libraries/WebServer/src/WebServer.cpp
   libraries/WebServer/src/Parsing.cpp
   libraries/WebServer/src/detail/mimetable.cpp
@@ -141,7 +152,7 @@ set(includedirs
   libraries/FS/src
   libraries/HTTPClient/src
   libraries/HTTPUpdate/src
-  libraries/LITTLEFS/src
+  libraries/LittleFS/src
   libraries/NetBIOS/src
   libraries/Preferences/src
   libraries/RainMaker/src
@@ -152,6 +163,7 @@ set(includedirs
   libraries/SPI/src
   libraries/Ticker/src
   libraries/Update/src
+  libraries/USB/src
   libraries/WebServer/src
   libraries/WiFiClientSecure/src
   libraries/WiFi/src
@@ -161,21 +173,51 @@ set(includedirs
 
 set(srcs ${CORE_SRCS} ${LIBRARY_SRCS} ${BLE_SRCS})
 set(priv_includes cores/esp32/libb64)
-set(requires spi_flash mbedtls mdns esp_adc_cal)
-set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support openssl bt arduino_tinyusb main)
-
-if(NOT CONFIG_ARDUINO_SELECTIVE_COMPILATION OR CONFIG_ARDUINO_SELECTIVE_ArduinoOTA)
-  list(APPEND priv_requires esp_https_ota)
-endif()
-if(NOT CONFIG_ARDUINO_SELECTIVE_COMPILATION OR CONFIG_ARDUINO_SELECTIVE_LITTLEFS)
-  list(APPEND priv_requires esp_littlefs)
-endif()
+set(requires spi_flash mbedtls mdns esp_adc_cal wifi_provisioning nghttp)
+set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support openssl bt esp_ipc)
 
 idf_component_register(INCLUDE_DIRS ${includedirs} PRIV_INCLUDE_DIRS ${priv_includes} SRCS ${srcs} REQUIRES ${requires} PRIV_REQUIRES ${priv_requires})
 
-if(IDF_TARGET STREQUAL "esp32")
-target_compile_options(${COMPONENT_TARGET} PUBLIC -DARDUINO=10812 -DARDUINO_ESP32_DEV -DARDUINO_ARCH_ESP32 -DARDUINO_BOARD="ESP32_DEV" -DARDUINO_VARIANT="esp32" -DESP32)
+string(TOUPPER ${CONFIG_IDF_TARGET} idf_target_caps)
+target_compile_options(${COMPONENT_TARGET} PUBLIC
+    -DARDUINO=10812
+    -DARDUINO_${idf_target_caps}_DEV
+    -DARDUINO_ARCH_ESP32
+    -DARDUINO_BOARD="${idf_target_caps}_DEV"
+    -DARDUINO_VARIANT="${CONFIG_IDF_TARGET}"
+    -DESP32)
+
+if(CONFIG_AUTOSTART_ARDUINO)
+    # in autostart mode, arduino-esp32 contains app_main() function and needs to
+    # reference setup() and loop() in the main component. If we add main
+    # component to priv_requires then we create a large circular dependency
+    # (arduino-esp32 -> main -> arduino-esp32) and can get linker errors, so
+    # instead we add setup() and loop() to the undefined symbols list so the
+    # linker will always include them.
+    #
+    # (As they are C++ symbol, we need to add the C++ mangled names.)
+    target_link_libraries(${COMPONENT_LIB} INTERFACE "-u _Z5setupv -u _Z4loopv")
 endif()
-if(IDF_TARGET STREQUAL "esp32s2")
-target_compile_options(${COMPONENT_TARGET} PUBLIC -DARDUINO=10812 -DARDUINO_ESP32S2_DEV -DARDUINO_ARCH_ESP32 -DARDUINO_BOARD="ESP32S2_DEV" -DARDUINO_VARIANT="esp32s2" -DESP32)
+
+# This function adds a dependency on the given component if the component is included into the build.
+function(maybe_add_component component_name)
+    idf_build_get_property(components BUILD_COMPONENTS)
+    if (${component_name} IN_LIST components)
+        idf_component_get_property(lib_name ${component_name} COMPONENT_LIB)
+        target_link_libraries(${COMPONENT_LIB} PUBLIC ${lib_name})
+    endif()
+endfunction()
+
+if(IDF_TARGET MATCHES "esp32" AND CONFIG_ESP_RMAKER_TASK_STACK)
+    maybe_add_component(esp_rainmaker)
+    maybe_add_component(qrcode)
+endif()
+if(IDF_TARGET MATCHES "esp32s2|esp32s3" AND CONFIG_TINYUSB_ENABLED)
+    maybe_add_component(arduino_tinyusb)
+endif()
+if(NOT CONFIG_ARDUINO_SELECTIVE_COMPILATION OR CONFIG_ARDUINO_SELECTIVE_ArduinoOTA)
+    maybe_add_component(esp_https_ota)
+endif()
+if(NOT CONFIG_ARDUINO_SELECTIVE_COMPILATION OR CONFIG_ARDUINO_SELECTIVE_LITTLEFS)
+    maybe_add_component(esp_littlefs)
 endif()

CONTRIBUTING.rst

@@ -0,0 +1,50 @@
+Contributions Guide
+===================
+
+We welcome contributions to the Arduino ESP32 project!
+
+How to Contribute
+-----------------
+
+Contributions to Arduino ESP32 - fixing bugs, adding features, adding documentation - are welcome. We accept contributions via `Github Pull Requests <https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests>`_.
+
+Before Contributing
+-------------------
+
+Before sending us a Pull Request, please consider this list of points:
+
+* Is the contribution entirely your own work, or already licensed under an LGPL 2.1 compatible Open Source License? If not then we unfortunately cannot accept it.
+
+* Is the code adequately commented for people to understand how it is structured?
+
+* Is there documentation or examples that go with code contributions? 
+
+* Are comments and documentation written in clear English, with no spelling or grammar errors?
+
+* Example contributions are also welcome.
+
+* If the contribution contains multiple commits, are they grouped together into logical changes (one major change per pull request)? Are any commits with names like "fixed typo" `squashed into previous commits <https://eli.thegreenplace.net/2014/02/19/squashing-github-pull-requests-into-a-single-commit/>`_?
+
+* If you're unsure about any of these points, please open the Pull Request anyhow and then ask us for feedback.
+
+Pull Request Process
+--------------------
+
+After you open the Pull Request, there will probably be some discussion in the comments field of the request itself.
+
+Once the Pull Request is ready to merge, it will first be merged into our internal git system for in-house automated testing.
+
+If this process passes, it will be merged onto the public github repository.
+
+Legal Part
+----------
+
+Before a contribution can be accepted, you will need to sign our :doc:`contributor-agreement`. You will be prompted for this automatically as part of the Pull Request process.
+
+Related Documents
+-----------------
+
+.. toctree::
+    :maxdepth: 1
+
+        contributor-agreement

README.md

@@ -1,35 +1,42 @@
 # Arduino core for the ESP32
-[![Build Status](https://travis-ci.org/espressif/arduino-esp32.svg?branch=master)](https://travis-ci.org/espressif/arduino-esp32) ![](https://github.com/espressif/arduino-esp32/workflows/ESP32%20Arduino%20CI/badge.svg)
+
+[![Build Status](https://travis-ci.org/espressif/arduino-esp32.svg?branch=master)](https://travis-ci.org/espressif/arduino-esp32) ![](https://github.com/espressif/arduino-esp32/workflows/ESP32%20Arduino%20CI/badge.svg) [![Documentation Status](https://readthedocs.com/projects/espressif-arduino-esp32/badge/?version=latest)](https://docs.espressif.com/projects/arduino-esp32/en/latest/?badge=latest)
 
 ### Need help or have a question? Join the chat at [![https://gitter.im/espressif/arduino-esp32](https://badges.gitter.im/espressif/arduino-esp32.svg)](https://gitter.im/espressif/arduino-esp32?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 ## Contents
+
+- [ESP32-S2 and ESP32-C3 Support](#esp32-s2-and-esp32-c3-support)
 - [Development Status](#development-status)
-- [Installation Instructions](#installation-instructions)
 - [Decoding Exceptions](#decoding-exceptions)
 - [Issue/Bug report template](#issuebug-report-template)
-- [ESP32Dev Board PINMAP](#esp32dev-board-pinmap)
+
+### ESP32-S2 and ESP32-C3 Support
+
+If you want to test ESP32-S2 and/or ESP32-C3 through the board manager, please use the development release link:
+
+```
+https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
+```
+
+Now you can install the latest 2.0.0 version from the boards manager.
 
 ### Development Status
 
 Latest Stable Release  [![Release Version](https://img.shields.io/github/release/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) [![Release Date](https://img.shields.io/github/release-date/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) [![Downloads](https://img.shields.io/github/downloads/espressif/arduino-esp32/latest/total.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/)
 
-Latest Development Release  [![Release Version](https://img.shields.io/github/release/espressif/arduino-esp32/all.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) [![Release Date](https://img.shields.io/github/release-date-pre/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) [![Downloads](https://img.shields.io/github/downloads-pre/espressif/arduino-esp32/latest/total.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/)
+Latest Development Release  [![Release Version](https://img.shields.io/github/release/espressif/arduino-esp32/all.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/) [![Release Date](https://img.shields.io/github/release-date-pre/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/) [![Downloads](https://img.shields.io/github/downloads-pre/espressif/arduino-esp32/latest/total.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/)
 
+### Documentation
 
-### Installation Instructions
-- Using Arduino IDE Boards Manager (preferred)
-  + [Instructions for Boards Manager](docs/arduino-ide/boards_manager.md)
-- Using Arduino IDE with the development repository
-  + [Instructions for Windows](docs/arduino-ide/windows.md)
-  + [Instructions for Mac](docs/arduino-ide/mac.md)
-  + [Instructions for Debian/Ubuntu Linux](docs/arduino-ide/debian_ubuntu.md)
-  + [Instructions for Fedora](docs/arduino-ide/fedora.md)
-  + [Instructions for openSUSE](docs/arduino-ide/opensuse.md)
-- [Using PlatformIO](docs/platformio.md)
-- [Building with make](docs/make.md)
-- [Using as ESP-IDF component](docs/esp-idf_component.md)
-- [Using OTAWebUpdater](docs/OTAWebUpdate/OTAWebUpdate.md)
+You can use [Arduino-ESP32 Online Documentation](https://docs.espressif.com/projects/arduino-esp32/en/latest/) to get all information about this project.
+
+* [Getting Started](https://docs.espressif.com/projects/arduino-esp32/en/latest/getting_started.html)
+* [Installing (Windows, Linux and macOS)](https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html)
+* [Libraries](https://docs.espressif.com/projects/arduino-esp32/en/latest/libraries.html)
+* [ESP-IDF as Component](https://docs.espressif.com/projects/arduino-esp32/en/latest/esp-idf_component.html)
+* [FAQ](https://docs.espressif.com/projects/arduino-esp32/en/latest/faq.html)
+* [Troubleshooting](https://docs.espressif.com/projects/arduino-esp32/en/latest/troubleshooting.html)
 
 ### Decoding exceptions
 
@@ -38,14 +45,10 @@ You can use [EspExceptionDecoder](https://github.com/me-no-dev/EspExceptionDecod
 ### Issue/Bug report template
 Before reporting an issue, make sure you've searched for similar one that was already created. Also make sure to go through all the issues labelled as [for reference](https://github.com/espressif/arduino-esp32/issues?utf8=%E2%9C%93&q=is%3Aissue%20label%3A%22for%20reference%22%20).
 
-Finally, if you are sure no one else had the issue, follow the [ISSUE_TEMPLATE](docs/ISSUE_TEMPLATE.md) while reporting any issue.
+Finally, if you are sure no one else had the issue, follow the [issue template](docs/ISSUE_TEMPLATE.md) while reporting any issue.
 
-### ESP32Dev Board PINMAP
+### Contributing
 
-![Pin Functions](docs/esp32_pinmap.png)
+We welcome contributions to the Arduino ESP32 project!
 
-![ESP32S2_Pinmap](docs/esp32s2_pinmap.png)
-
-### Tip
-
-Sometimes to program ESP32 via serial you must keep GPIO0 LOW during the programming process
+See [contributing](https://docs.espressif.com/projects/arduino-esp32/en/latest/contributing.html) in the documentation for more information on how to contribute to the project.

cores/esp32/Arduino.h

@@ -99,13 +99,23 @@
 #define bit(b) (1UL << (b))
 #define _BV(b) (1UL << (b))
 
-#define digitalPinToPort(pin)       (((pin)>31)?1:0)
-#define digitalPinToBitMask(pin)    (1UL << (((pin)>31)?((pin)-32):(pin)))
 #define digitalPinToTimer(pin)      (0)
 #define analogInPinToBit(P)         (P)
+#if SOC_GPIO_PIN_COUNT <= 32
+#define digitalPinToPort(pin)       (0)
+#define digitalPinToBitMask(pin)    (1UL << (pin))
+#define portOutputRegister(port)    ((volatile uint32_t*)GPIO_OUT_REG)
+#define portInputRegister(port)     ((volatile uint32_t*)GPIO_IN_REG)
+#define portModeRegister(port)      ((volatile uint32_t*)GPIO_ENABLE_REG)
+#elif SOC_GPIO_PIN_COUNT <= 64
+#define digitalPinToPort(pin)       (((pin)>31)?1:0)
+#define digitalPinToBitMask(pin)    (1UL << (((pin)>31)?((pin)-32):(pin)))
 #define portOutputRegister(port)    ((volatile uint32_t*)((port)?GPIO_OUT1_REG:GPIO_OUT_REG))
 #define portInputRegister(port)     ((volatile uint32_t*)((port)?GPIO_IN1_REG:GPIO_IN_REG))
 #define portModeRegister(port)      ((volatile uint32_t*)((port)?GPIO_ENABLE1_REG:GPIO_ENABLE_REG))
+#else
+#error SOC_GPIO_PIN_COUNT > 64 not implemented
+#endif
 
 #define NOT_A_PIN -1
 #define NOT_A_PORT -1
@@ -165,7 +175,7 @@ using std::min;
 using ::round;
 
 uint16_t makeWord(uint16_t w);
-uint16_t makeWord(byte h, byte l);
+uint16_t makeWord(uint8_t h, uint8_t l);
 
 #define word(...) makeWord(__VA_ARGS__)
 

cores/esp32/Esp.cpp

@@ -35,15 +35,19 @@ extern "C" {
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/spi_flash.h"
 #include "soc/efuse_reg.h"
+#define ESP_FLASH_IMAGE_BASE 0x1000     // Flash offset containing flash size and spi mode
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/spi_flash.h"
+#define ESP_FLASH_IMAGE_BASE 0x1000
 #elif CONFIG_IDF_TARGET_ESP32C3
 #include "esp32c3/rom/spi_flash.h"
+#define ESP_FLASH_IMAGE_BASE 0x0000     // Esp32c3 is located at 0x0000
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
 #else // ESP32 Before IDF 4.0
 #include "rom/spi_flash.h"
+#define ESP_FLASH_IMAGE_BASE 0x1000
 #endif
 
 /**
@@ -289,7 +293,7 @@ const char * EspClass::getSdkVersion(void)
 uint32_t EspClass::getFlashChipSize(void)
 {
     esp_image_header_t fhdr;
-    if(flashRead(0x1000, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
+    if(flashRead(ESP_FLASH_IMAGE_BASE, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
         return 0;
     }
     return magicFlashChipSize(fhdr.spi_size);
@@ -298,7 +302,7 @@ uint32_t EspClass::getFlashChipSize(void)
 uint32_t EspClass::getFlashChipSpeed(void)
 {
     esp_image_header_t fhdr;
-    if(flashRead(0x1000, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
+    if(flashRead(ESP_FLASH_IMAGE_BASE, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
         return 0;
     }
     return magicFlashChipSpeed(fhdr.spi_speed);
@@ -307,7 +311,7 @@ uint32_t EspClass::getFlashChipSpeed(void)
 FlashMode_t EspClass::getFlashChipMode(void)
 {
     esp_image_header_t fhdr;
-    if(flashRead(0x1000, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
+    if(flashRead(ESP_FLASH_IMAGE_BASE, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
         return FM_UNKNOWN;
     }
     return magicFlashChipMode(fhdr.spi_mode);

cores/esp32/Esp.h

@@ -22,6 +22,7 @@
 
 #include <Arduino.h>
 #include <esp_partition.h>
+#include <hal/cpu_hal.h>
 
 /**
  * AVR macros for WDT managment
@@ -110,9 +111,7 @@ public:
 
 uint32_t ARDUINO_ISR_ATTR EspClass::getCycleCount()
 {
-    uint32_t ccount;
-    __asm__ __volatile__("esync; rsr %0,ccount":"=a" (ccount));
-    return ccount;
+    return cpu_hal_get_cycle_count();
 }
 
 extern EspClass ESP;

cores/esp32/FirmwareMSC.cpp

@@ -0,0 +1,423 @@
+// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "FirmwareMSC.h"
+
+#if CONFIG_TINYUSB_MSC_ENABLED
+
+#include <cstring>
+#include "esp_partition.h"
+#include "esp_ota_ops.h"
+#include "esp32-hal.h"
+#include "pins_arduino.h"
+#include "firmware_msc_fat.h"
+
+#ifndef USB_FW_MSC_VENDOR_ID
+#define USB_FW_MSC_VENDOR_ID "ESP32" //max 8 chars
+#endif
+#ifndef USB_FW_MSC_PRODUCT_ID
+#define USB_FW_MSC_PRODUCT_ID "Firmware MSC"//max 16 chars
+#endif
+#ifndef USB_FW_MSC_PRODUCT_REVISION
+#define USB_FW_MSC_PRODUCT_REVISION "1.0" //max 4 chars
+#endif
+#ifndef USB_FW_MSC_VOLUME_NAME
+#define USB_FW_MSC_VOLUME_NAME "ESP32-FWMSC" //max 11 chars
+#endif
+#ifndef USB_FW_MSC_SERIAL_NUMBER
+#define USB_FW_MSC_SERIAL_NUMBER 0x00000000
+#endif
+
+ESP_EVENT_DEFINE_BASE(ARDUINO_FIRMWARE_MSC_EVENTS);
+esp_err_t arduino_usb_event_post(esp_event_base_t event_base, int32_t event_id, void *event_data, size_t event_data_size, TickType_t ticks_to_wait);
+esp_err_t arduino_usb_event_handler_register_with(esp_event_base_t event_base, int32_t event_id, esp_event_handler_t event_handler, void *event_handler_arg);
+
+//General Variables
+static uint8_t * msc_ram_disk = NULL;
+static fat_boot_sector_t * msc_boot = NULL;
+static uint8_t * msc_table = NULL;
+static uint16_t msc_table_sectors = 0;
+static uint16_t msc_total_sectors = 0;
+static bool mcs_is_fat16 = false;
+
+//Firmware Read
+static const esp_partition_t* msc_run_partition = NULL;
+static uint16_t fw_start_sector = 0;
+static uint16_t fw_end_sector = 0;
+static size_t fw_size = 0;
+static fat_dir_entry_t * fw_entry = NULL;
+
+//Firmware Write
+typedef enum {
+  MSC_UPDATE_IDLE,
+  MSC_UPDATE_STARTING,
+  MSC_UPDATE_RUNNING,
+  MSC_UPDATE_END
+} msc_update_state_t;
+
+static const esp_partition_t* msc_ota_partition = NULL;
+static msc_update_state_t msc_update_state = MSC_UPDATE_IDLE;
+static uint16_t msc_update_start_sector = 0;
+static uint32_t msc_update_bytes_written = 0;
+static fat_dir_entry_t * msc_update_entry = NULL;
+
+static uint32_t get_firmware_size(const esp_partition_t* partition){
+  esp_image_metadata_t data;
+  const esp_partition_pos_t running_pos  = {
+      .offset = partition->address,
+      .size = partition->size,
+  };
+  data.start_addr = running_pos.offset;
+  esp_image_verify(ESP_IMAGE_VERIFY, &running_pos, &data);
+  return data.image_len;
+}
+
+//Get number of sectors required based on the size of the firmware and OTA partition
+static size_t msc_update_get_required_disk_sectors(){
+  size_t data_sectors = 16;
+  size_t total_sectors = 0;
+  msc_run_partition = esp_ota_get_running_partition();
+  msc_ota_partition = esp_ota_get_next_update_partition(NULL);
+  if(msc_run_partition){
+    fw_size = get_firmware_size(msc_run_partition);
+    data_sectors += FAT_SIZE_TO_SECTORS(fw_size);
+    log_d("APP size: %u (%u sectors)", fw_size, FAT_SIZE_TO_SECTORS(fw_size));
+  } else {
+    log_w("APP partition not found. Reading disabled");
+  }
+  if(msc_ota_partition){
+    data_sectors += FAT_SIZE_TO_SECTORS(msc_ota_partition->size);
+    log_d("OTA size: %u (%u sectors)", msc_ota_partition->size, FAT_SIZE_TO_SECTORS(msc_ota_partition->size));
+  } else {
+    log_w("OTA partition not found. Writing disabled");
+  }
+  msc_table_sectors = fat_sectors_per_alloc_table(data_sectors, false);
+  total_sectors = data_sectors + msc_table_sectors + 2;
+  if(total_sectors > 0xFF4){
+    log_d("USING FAT16");
+    mcs_is_fat16 = true;
+    total_sectors -= msc_table_sectors;
+    msc_table_sectors = fat_sectors_per_alloc_table(data_sectors, true);
+    total_sectors += msc_table_sectors;
+  } else {
+    log_d("USING FAT12");
+    mcs_is_fat16 = false;
+  }
+  log_d("FAT data sectors: %u", data_sectors);
+  log_d("FAT table sectors: %u", msc_table_sectors);
+  log_d("FAT total sectors: %u (%uKB)", total_sectors, (total_sectors * DISK_SECTOR_SIZE) / 1024);
+  return total_sectors;
+}
+
+//setup the ramdisk and add the firmware download file
+static bool msc_update_setup_disk(const char * volume_label, uint32_t serial_number){
+  msc_total_sectors = msc_update_get_required_disk_sectors();
+  uint8_t ram_sectors = msc_table_sectors + 2;
+  msc_ram_disk = (uint8_t*)calloc(ram_sectors, DISK_SECTOR_SIZE);
+  if(!msc_ram_disk){
+    log_e("Failed to allocate RAM Disk: %u bytes", ram_sectors * DISK_SECTOR_SIZE);
+    return false;
+  }
+  fw_start_sector = ram_sectors;
+  fw_end_sector = fw_start_sector;
+  msc_boot = fat_add_boot_sector(msc_ram_disk, msc_total_sectors, msc_table_sectors, fat_file_system_type(mcs_is_fat16), volume_label, serial_number);
+  msc_table = fat_add_table(msc_ram_disk, msc_boot, mcs_is_fat16);
+  //fat_dir_entry_t * label = fat_add_label(msc_ram_disk, volume_label);
+  if(msc_run_partition){
+    fw_entry = fat_add_root_file(msc_ram_disk, 0, "FIRMWARE", "BIN", fw_size, 2, mcs_is_fat16);
+    fw_end_sector = FAT_SIZE_TO_SECTORS(fw_size) + fw_start_sector;
+  }
+  return true;
+}
+
+static void msc_update_delete_disk(){
+  fw_entry = NULL;
+  fw_size = 0;
+  fw_end_sector = 0;
+  fw_start_sector = 0;
+  msc_table = NULL;
+  msc_boot = NULL;
+  msc_table_sectors = 0;
+  msc_total_sectors = 0;
+  msc_run_partition = NULL;
+  msc_ota_partition = NULL;
+  msc_update_state = MSC_UPDATE_IDLE;
+  msc_update_start_sector = 0;
+  msc_update_bytes_written = 0;
+  msc_update_entry = NULL;
+  free(msc_ram_disk);
+  msc_ram_disk = NULL;
+}
+
+//filter out entries to only include BINs in the root folder
+static fat_dir_entry_t * msc_update_get_root_bin_entry(uint8_t index){
+  fat_dir_entry_t * entry = (fat_dir_entry_t *)(msc_ram_disk + ((msc_boot->sectors_per_alloc_table+1) * DISK_SECTOR_SIZE) + (index * sizeof(fat_dir_entry_t)));
+  fat_lfn_entry_t * lfn = (fat_lfn_entry_t*)entry;
+
+  //empty entry
+  if(entry->file_magic == 0){
+    return NULL;
+  }
+  //long file name
+  if(lfn->attr == 0x0F && lfn->type == 0x00 && lfn->first_cluster == 0x0000){
+    return NULL;
+  }
+  //only files marked as archives
+  if(entry->file_attr != FAT_FILE_ATTR_ARCHIVE){
+    return NULL;
+  }
+  //deleted
+  if(entry->file_magic == 0xE5 || entry->file_magic == 0x05){
+    return NULL;
+  }
+  //not bins
+  if(memcmp("BIN", entry->file_extension, 3)){
+    return NULL;
+  }
+  return entry;
+}
+
+//get an empty bin (the host will add an entry for file about to be written with size of zero)
+static fat_dir_entry_t * msc_update_find_new_bin(){
+  for(uint8_t i=16; i;){
+    i--;
+    fat_dir_entry_t * entry = msc_update_get_root_bin_entry(i);
+    if(entry && entry->file_size == 0){
+      return entry;
+    }
+  }
+  return NULL;
+}
+
+//get a bin starting from particular sector
+static fat_dir_entry_t * msc_update_find_bin(uint16_t sector){
+  for(uint8_t i=16; i; ){
+    i--;
+    fat_dir_entry_t * entry = msc_update_get_root_bin_entry(i);
+    if(entry && entry->data_start_sector == (sector - msc_boot->sectors_per_alloc_table)){
+      return entry;
+    }
+  }
+  return NULL;
+}
+
+//write the new data and erase the flash blocks when necessary
+static esp_err_t msc_update_write(const esp_partition_t *partition, uint32_t offset, void *data, size_t size){
+  esp_err_t err = ESP_OK;
+  if((offset & (SPI_FLASH_SEC_SIZE-1)) == 0){
+    err = esp_partition_erase_range(partition, offset, SPI_FLASH_SEC_SIZE);
+    log_v("ERASE[0x%08X]: %s", offset, (err != ESP_OK)?"FAIL":"OK");
+    if(err != ESP_OK){
+      return err;
+    }
+  }
+  return esp_partition_write(partition, offset, data, size);
+}
+
+//called when error was encountered while updating
+static void msc_update_error(){
+  log_e("UPDATE_ERROR: %u", msc_update_bytes_written);
+  arduino_firmware_msc_event_data_t p = {0};
+  p.error.size = msc_update_bytes_written;
+  arduino_usb_event_post(ARDUINO_FIRMWARE_MSC_EVENTS, ARDUINO_FIRMWARE_MSC_ERROR_EVENT, &p, sizeof(arduino_firmware_msc_event_data_t), portMAX_DELAY);
+  msc_update_state = MSC_UPDATE_IDLE;
+  msc_update_entry = NULL;
+  msc_update_bytes_written = 0;
+  msc_update_start_sector = 0;
+}
+
+//called when all firmware bytes have been received
+static void msc_update_end(){
+  log_d("UPDATE_END: %u", msc_update_entry->file_size);
+  msc_update_state = MSC_UPDATE_END;
+  size_t ota_size = get_firmware_size(msc_ota_partition);
+  if(ota_size != msc_update_entry->file_size){
+    log_e("OTA SIZE MISMATCH %u != %u", ota_size, msc_update_entry->file_size);
+    msc_update_error();
+    return;
+  }
+  if(!ota_size || esp_ota_set_boot_partition(msc_ota_partition) != ESP_OK){
+    log_e("ENABLING OTA PARTITION FAILED");
+    msc_update_error();
+    return;
+  }
+  arduino_firmware_msc_event_data_t p = {0};
+  p.end.size = msc_update_entry->file_size;
+  arduino_usb_event_post(ARDUINO_FIRMWARE_MSC_EVENTS, ARDUINO_FIRMWARE_MSC_END_EVENT, &p, sizeof(arduino_firmware_msc_event_data_t), portMAX_DELAY);
+}
+
+static int32_t msc_write(uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize){
+  //log_d("lba: %u, offset: %u, bufsize: %u", lba, offset, bufsize);
+  if(lba < fw_start_sector){
+    //write to sectors that are in RAM
+    memcpy(msc_ram_disk + (lba * DISK_SECTOR_SIZE) + offset, buffer, bufsize);
+    if(msc_ota_partition && lba == (fw_start_sector - 1)){
+      //monitor the root folder table
+      if(msc_update_state <= MSC_UPDATE_RUNNING){
+        fat_dir_entry_t * update_entry = msc_update_find_new_bin();
+        if(update_entry) {
+          if(msc_update_entry) {
+            log_v("REPLACING ENTRY");
+          } else {
+            log_v("ASSIGNING ENTRY");
+          }
+          if(msc_update_state <= MSC_UPDATE_STARTING){
+            msc_update_state = MSC_UPDATE_STARTING;
+            msc_update_bytes_written = 0;
+            msc_update_start_sector = 0;
+          }
+          msc_update_entry = update_entry;
+        } else if(msc_update_state == MSC_UPDATE_RUNNING){
+          if(!msc_update_entry && msc_update_start_sector){
+            msc_update_entry = msc_update_find_bin(msc_update_start_sector);
+          }
+          if(msc_update_entry && msc_update_bytes_written >= msc_update_entry->file_size){
+            msc_update_end();
+          }
+        }
+      }
+    }
+  } else if(msc_ota_partition && lba >= msc_update_start_sector){
+    //handle writes to the region where the new firmware will be uploaded
+    arduino_firmware_msc_event_data_t p = {0};
+    if(msc_update_state <= MSC_UPDATE_STARTING && buffer[0] == 0xE9){
+      msc_update_state = MSC_UPDATE_RUNNING;
+      msc_update_start_sector = lba;
+      msc_update_bytes_written = 0;
+      log_d("UPDATE_START: %u (0x%02X)", lba, lba - msc_boot->sectors_per_alloc_table);
+      arduino_usb_event_post(ARDUINO_FIRMWARE_MSC_EVENTS, ARDUINO_FIRMWARE_MSC_START_EVENT, &p, sizeof(arduino_firmware_msc_event_data_t), portMAX_DELAY);
+      if(msc_update_write(msc_ota_partition, ((lba - msc_update_start_sector) * DISK_SECTOR_SIZE) + offset, buffer, bufsize) == ESP_OK){
+        log_v("UPDATE_WRITE: %u %u", ((lba - msc_update_start_sector) * DISK_SECTOR_SIZE) + offset, bufsize);
+        msc_update_bytes_written = ((lba - msc_update_start_sector) * DISK_SECTOR_SIZE) + offset + bufsize;
+        p.write.offset = ((lba - msc_update_start_sector) * DISK_SECTOR_SIZE) + offset;
+        p.write.size = bufsize;
+        arduino_usb_event_post(ARDUINO_FIRMWARE_MSC_EVENTS, ARDUINO_FIRMWARE_MSC_WRITE_EVENT, &p, sizeof(arduino_firmware_msc_event_data_t), portMAX_DELAY);
+      } else {
+        msc_update_error();
+        return 0;
+      }
+    } else if(msc_update_state == MSC_UPDATE_RUNNING){
+      if(msc_update_entry && msc_update_entry->file_size && msc_update_bytes_written < msc_update_entry->file_size && (msc_update_bytes_written + bufsize) >= msc_update_entry->file_size){
+        bufsize = msc_update_entry->file_size - msc_update_bytes_written;
+      }
+      if(msc_update_write(msc_ota_partition, ((lba - msc_update_start_sector) * DISK_SECTOR_SIZE) + offset, buffer, bufsize) == ESP_OK){
+        log_v("UPDATE_WRITE: %u %u", ((lba - msc_update_start_sector) * DISK_SECTOR_SIZE) + offset, bufsize);
+        msc_update_bytes_written = ((lba - msc_update_start_sector) * DISK_SECTOR_SIZE) + offset + bufsize;
+        p.write.offset = ((lba - msc_update_start_sector) * DISK_SECTOR_SIZE) + offset;
+        p.write.size = bufsize;
+        arduino_usb_event_post(ARDUINO_FIRMWARE_MSC_EVENTS, ARDUINO_FIRMWARE_MSC_WRITE_EVENT, &p, sizeof(arduino_firmware_msc_event_data_t), portMAX_DELAY);
+        if(msc_update_entry && msc_update_entry->file_size && msc_update_bytes_written >= msc_update_entry->file_size){
+          msc_update_end();
+        }
+      } else {
+        msc_update_error();
+        return 0;
+      }
+    }
+  }
+  return bufsize;
+}
+
+static int32_t msc_read(uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize){
+  //log_d("lba: %u, offset: %u, bufsize: %u", lba, offset, bufsize);
+  if(lba < fw_start_sector){
+    memcpy(buffer, msc_ram_disk + (lba * DISK_SECTOR_SIZE) + offset, bufsize);
+  } else if(msc_run_partition && lba < fw_end_sector){
+    //read the currently running firmware
+    if(esp_partition_read(msc_run_partition, ((lba - fw_start_sector) * DISK_SECTOR_SIZE) + offset, buffer, bufsize) != ESP_OK){
+      return 0;
+    }
+  } else {
+    memset(buffer, 0, bufsize);
+  }
+  return bufsize;
+}
+
+static bool msc_start_stop(uint8_t power_condition, bool start, bool load_eject){
+  //log_d("power: %u, start: %u, eject: %u", power_condition, start, load_eject);
+  arduino_firmware_msc_event_data_t p = {0};
+  p.power.power_condition = power_condition;
+  p.power.start = start;
+  p.power.load_eject = load_eject;
+  arduino_usb_event_post(ARDUINO_FIRMWARE_MSC_EVENTS, ARDUINO_FIRMWARE_MSC_POWER_EVENT, &p, sizeof(arduino_firmware_msc_event_data_t), portMAX_DELAY);
+  return true;
+}
+
+static volatile TaskHandle_t msc_task_handle = NULL;
+static void msc_task(void *pvParameters){
+  for (;;) {
+    if(msc_update_state == MSC_UPDATE_END){
+      delay(100);
+      esp_restart();
+    }
+    delay(100);
+  }
+  msc_task_handle = NULL;
+  vTaskDelete(NULL);
+}
+
+FirmwareMSC::FirmwareMSC():msc(){}
+
+FirmwareMSC::~FirmwareMSC(){
+  end();
+}
+
+bool FirmwareMSC::begin(){
+  if(msc_ram_disk){
+    return true;
+  }
+
+  if(!msc_update_setup_disk(USB_FW_MSC_VOLUME_NAME, USB_FW_MSC_SERIAL_NUMBER)){
+    return false;
+  }
+
+  if(!msc_task_handle){
+    xTaskCreateUniversal(msc_task, "msc_disk", 1024, NULL, 2, (TaskHandle_t*)&msc_task_handle, 0);
+    if(!msc_task_handle){
+      msc_update_delete_disk();
+      return false;
+    }
+  }
+
+  msc.vendorID(USB_FW_MSC_VENDOR_ID);
+  msc.productID(USB_FW_MSC_PRODUCT_ID);
+  msc.productRevision(USB_FW_MSC_PRODUCT_REVISION);
+  msc.onStartStop(msc_start_stop);
+  msc.onRead(msc_read);
+  msc.onWrite(msc_write);
+  msc.mediaPresent(true);
+  msc.begin(msc_boot->fat12_sector_num, DISK_SECTOR_SIZE);
+  return true;
+}
+
+void FirmwareMSC::end(){
+  msc.end();
+  if(msc_task_handle){
+    vTaskDelete(msc_task_handle);
+    msc_task_handle = NULL;
+  }
+  msc_update_delete_disk();
+}
+
+void FirmwareMSC::onEvent(esp_event_handler_t callback){
+    onEvent(ARDUINO_FIRMWARE_MSC_ANY_EVENT, callback);
+}
+void FirmwareMSC::onEvent(arduino_firmware_msc_event_t event, esp_event_handler_t callback){
+    arduino_usb_event_handler_register_with(ARDUINO_FIRMWARE_MSC_EVENTS, event, callback, this);
+}
+
+#if ARDUINO_USB_MSC_ON_BOOT
+FirmwareMSC MSC_Update;
+#endif
+
+#endif /* CONFIG_USB_MSC_ENABLED */

cores/esp32/FirmwareMSC.h

@@ -0,0 +1,70 @@
+// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#include <stdbool.h>
+#include "USBMSC.h"
+
+#if CONFIG_TINYUSB_MSC_ENABLED
+
+#include "esp_event.h"
+
+ESP_EVENT_DECLARE_BASE(ARDUINO_FIRMWARE_MSC_EVENTS);
+
+typedef enum {
+    ARDUINO_FIRMWARE_MSC_ANY_EVENT = ESP_EVENT_ANY_ID,
+    ARDUINO_FIRMWARE_MSC_START_EVENT = 0,
+    ARDUINO_FIRMWARE_MSC_WRITE_EVENT,
+    ARDUINO_FIRMWARE_MSC_END_EVENT,
+    ARDUINO_FIRMWARE_MSC_ERROR_EVENT,
+    ARDUINO_FIRMWARE_MSC_POWER_EVENT,
+    ARDUINO_FIRMWARE_MSC_MAX_EVENT,
+} arduino_firmware_msc_event_t;
+
+typedef union {
+    struct {
+            size_t offset;
+            size_t size;
+    } write;
+    struct {
+            uint8_t power_condition;
+            bool start;
+            bool load_eject;
+    } power;
+    struct {
+            size_t size;
+    } end;
+    struct {
+            size_t size;
+    } error;
+} arduino_firmware_msc_event_data_t;
+
+class FirmwareMSC {
+private:
+  USBMSC msc;
+
+public:
+  FirmwareMSC();
+  ~FirmwareMSC();
+  bool begin();
+  void end();
+  void onEvent(esp_event_handler_t callback);
+  void onEvent(arduino_firmware_msc_event_t event, esp_event_handler_t callback);
+};
+
+#if ARDUINO_USB_MSC_ON_BOOT
+extern FirmwareMSC MSC_Update;
+#endif
+
+#endif /* CONFIG_TINYUSB_MSC_ENABLED */

cores/esp32/HWCDC.cpp

@@ -0,0 +1,283 @@
+// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "USB.h"
+#if CONFIG_IDF_TARGET_ESP32C3
+
+#include "esp32-hal.h"
+#include "HWCDC.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+#include "freertos/queue.h"
+#include "freertos/ringbuf.h"
+#include "esp_intr_alloc.h"
+#include "soc/periph_defs.h"
+#include "hal/usb_serial_jtag_ll.h"
+
+static RingbufHandle_t tx_ring_buf = NULL;
+static xQueueHandle rx_queue = NULL;
+static uint8_t rx_data_buf[64];
+static intr_handle_t intr_handle = NULL;
+static volatile bool initial_empty = false;
+
+static void hw_cdc_isr_handler(void *arg) {
+    portBASE_TYPE xTaskWoken = 0;
+    uint32_t usbjtag_intr_status = 0;
+    usbjtag_intr_status = usb_serial_jtag_ll_get_intsts_mask();
+
+    if (usbjtag_intr_status & USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY) {
+        // Interrupt tells us the host picked up the data we sent.
+        if (usb_serial_jtag_ll_txfifo_writable() == 1) {
+            // We disable the interrupt here so that the interrupt won't be triggered if there is no data to send.
+            usb_serial_jtag_ll_disable_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
+
+            if(!initial_empty){
+                initial_empty = true;
+                //send event?
+                //ets_printf("CONNECTED\n");
+            }
+            size_t queued_size;
+            uint8_t *queued_buff = (uint8_t *)xRingbufferReceiveUpToFromISR(tx_ring_buf, &queued_size, 64);
+            // If the hardware fifo is avaliable, write in it. Otherwise, do nothing.
+            if (queued_buff != NULL) {  //Although tx_queued_bytes may be larger than 0. We may have interrupt before xRingbufferSend() was called.
+                //Copy the queued buffer into the TX FIFO
+                usb_serial_jtag_ll_clr_intsts_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
+                usb_serial_jtag_ll_write_txfifo(queued_buff, queued_size);
+                usb_serial_jtag_ll_txfifo_flush();
+                vRingbufferReturnItemFromISR(tx_ring_buf, queued_buff, &xTaskWoken);
+                usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
+                //send event?
+                //ets_printf("TX:%u\n", queued_size);
+            }
+        } else {
+            usb_serial_jtag_ll_clr_intsts_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
+        }
+    }
+
+    if (usbjtag_intr_status & USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT) {
+        // read rx buffer(max length is 64), and send avaliable data to ringbuffer.
+        // Ensure the rx buffer size is larger than RX_MAX_SIZE.
+        usb_serial_jtag_ll_clr_intsts_mask(USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT);
+        uint32_t rx_fifo_len = usb_serial_jtag_ll_read_rxfifo(rx_data_buf, 64);
+        uint32_t i=0;
+        for(i=0; i<rx_fifo_len; i++){
+            if(rx_queue == NULL || !xQueueSendFromISR(rx_queue, rx_data_buf+i, &xTaskWoken)){
+                break;
+            }
+        }
+        //send event?
+        //ets_printf("RX:%u/%u\n", i, rx_fifo_len);
+    }
+
+    if (usbjtag_intr_status & USB_SERIAL_JTAG_INTR_BUS_RESET) {
+        usb_serial_jtag_ll_clr_intsts_mask(USB_SERIAL_JTAG_INTR_BUS_RESET);
+        initial_empty = false;
+        usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
+        //ets_printf("BUS_RESET\n");
+    }
+
+    if (xTaskWoken == pdTRUE) {
+        portYIELD_FROM_ISR();
+    }
+}
+
+static void ARDUINO_ISR_ATTR cdc0_write_char(char c) {
+    if(xPortInIsrContext()){
+        xRingbufferSendFromISR(tx_ring_buf, (void*) (&c), 1, NULL);
+    } else {
+        xRingbufferSend(tx_ring_buf, (void*) (&c), 1, 0);
+    }
+    usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
+}
+
+HWCDC::HWCDC() {
+    
+}
+
+HWCDC::~HWCDC(){
+    end();
+}
+
+HWCDC::operator bool() const
+{
+    return initial_empty;
+}
+
+void HWCDC::begin(unsigned long baud)
+{
+    setRxBufferSize(256);//default if not preset
+    setTxBufferSize(256);//default if not preset
+
+    usb_serial_jtag_ll_clr_intsts_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY | USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT | USB_SERIAL_JTAG_INTR_BUS_RESET);
+    usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY | USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT | USB_SERIAL_JTAG_INTR_BUS_RESET);
+    if(!intr_handle && esp_intr_alloc(ETS_USB_INTR_SOURCE/*ETS_USB_SERIAL_JTAG_INTR_SOURCE*/, 0, hw_cdc_isr_handler, NULL, &intr_handle) != ESP_OK){
+        isr_log_e("HW USB CDC failed to init interrupts");
+        end();
+    }
+}
+
+void HWCDC::end()
+{
+    //Disable tx/rx interrupt.
+    usb_serial_jtag_ll_disable_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY | USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT | USB_SERIAL_JTAG_INTR_BUS_RESET);
+    esp_intr_free(intr_handle);
+    intr_handle = NULL;
+    setRxBufferSize(0);
+    setTxBufferSize(0);
+}
+
+/*
+ * WRITING
+*/
+
+size_t HWCDC::setTxBufferSize(size_t tx_queue_len){
+    if(tx_ring_buf){
+        if(!tx_queue_len){
+            vRingbufferDelete(tx_ring_buf);
+            tx_ring_buf = NULL;
+        }
+        return 0;
+    }
+    tx_ring_buf = xRingbufferCreate(tx_queue_len, RINGBUF_TYPE_BYTEBUF);
+    if(!tx_ring_buf){
+        return 0;
+    }
+    return tx_queue_len;
+}
+
+int HWCDC::availableForWrite(void)
+{
+    if(tx_ring_buf == NULL){
+        return -1;
+    }
+    return xRingbufferGetCurFreeSize(tx_ring_buf);
+}
+
+size_t HWCDC::write(const uint8_t *buffer, size_t size)
+{
+    // Blocking method, Sending data to ringbuffer, and handle the data in ISR.
+    if(xRingbufferSend(tx_ring_buf, (void*) (buffer), size, 200 / portTICK_PERIOD_MS) != pdTRUE){
+        log_e("Write Failed");
+        return 0;
+    }
+    // Now trigger the ISR to read data from the ring buffer.
+    usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
+    return size;
+}
+
+size_t HWCDC::write(uint8_t c)
+{
+    return write(&c, 1);
+}
+
+void HWCDC::flush(void)
+{
+    if(tx_ring_buf == NULL){
+        return;
+    }
+    UBaseType_t uxItemsWaiting = 0;
+    vRingbufferGetInfo(tx_ring_buf, NULL, NULL, NULL, NULL, &uxItemsWaiting);
+    while(uxItemsWaiting){
+        delay(5);
+        vRingbufferGetInfo(tx_ring_buf, NULL, NULL, NULL, NULL, &uxItemsWaiting);
+    }
+}
+
+/*
+ * READING
+*/
+
+size_t HWCDC::setRxBufferSize(size_t rx_queue_len){
+    if(rx_queue){
+        if(!rx_queue_len){
+            vQueueDelete(rx_queue);
+            rx_queue = NULL;
+        }
+        return 0;
+    }
+    rx_queue = xQueueCreate(rx_queue_len, sizeof(uint8_t));
+    if(!rx_queue){
+        return 0;
+    }
+    if(!tx_ring_buf){
+        tx_ring_buf = xRingbufferCreate(rx_queue_len, RINGBUF_TYPE_BYTEBUF);
+    }
+    return rx_queue_len;
+}
+
+int HWCDC::available(void)
+{
+    if(rx_queue == NULL){
+        return -1;
+    }
+    return uxQueueMessagesWaiting(rx_queue);
+}
+
+int HWCDC::peek(void)
+{
+    if(rx_queue == NULL){
+        return -1;
+    }
+    uint8_t c;
+    if(xQueuePeek(rx_queue, &c, 0)) {
+        return c;
+    }
+    return -1;
+}
+
+int HWCDC::read(void)
+{
+    if(rx_queue == NULL){
+        return -1;
+    }
+    uint8_t c = 0;
+    if(xQueueReceive(rx_queue, &c, 0)) {
+        return c;
+    }
+    return -1;
+}
+
+size_t HWCDC::read(uint8_t *buffer, size_t size)
+{
+    if(rx_queue == NULL){
+        return -1;
+    }
+    uint8_t c = 0;
+    size_t count = 0;
+    while(count < size && xQueueReceive(rx_queue, &c, 0)){
+        buffer[count++] = c;
+    }
+    return count;
+}
+
+/*
+ * DEBUG
+*/
+
+void HWCDC::setDebugOutput(bool en)
+{
+    if(en) {
+        uartSetDebug(NULL);
+        ets_install_putc1((void (*)(char)) &cdc0_write_char);
+    } else {
+        ets_install_putc1(NULL);
+    }
+}
+
+#if ARDUINO_HW_CDC_ON_BOOT //Serial used for USB CDC
+HWCDC Serial;
+#else
+HWCDC USBSerial;
+#endif
+
+#endif /* CONFIG_TINYUSB_CDC_ENABLED */

cores/esp32/HWCDC.h

@@ -0,0 +1,82 @@
+// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include "sdkconfig.h"
+#if CONFIG_IDF_TARGET_ESP32C3
+
+#include <inttypes.h>
+#include "Stream.h"
+
+class HWCDC: public Stream
+{
+public:
+    HWCDC();
+    ~HWCDC();
+
+    size_t setRxBufferSize(size_t);
+    size_t setTxBufferSize(size_t);
+    void begin(unsigned long baud=0);
+    void end();
+    
+    int available(void);
+    int availableForWrite(void);
+    int peek(void);
+    int read(void);
+    size_t read(uint8_t *buffer, size_t size);
+    size_t write(uint8_t);
+    size_t write(const uint8_t *buffer, size_t size);
+    void flush(void);
+    
+    inline size_t read(char * buffer, size_t size)
+    {
+        return read((uint8_t*) buffer, size);
+    }
+    inline size_t write(const char * buffer, size_t size)
+    {
+        return write((uint8_t*) buffer, size);
+    }
+    inline size_t write(const char * s)
+    {
+        return write((uint8_t*) s, strlen(s));
+    }
+    inline size_t write(unsigned long n)
+    {
+        return write((uint8_t) n);
+    }
+    inline size_t write(long n)
+    {
+        return write((uint8_t) n);
+    }
+    inline size_t write(unsigned int n)
+    {
+        return write((uint8_t) n);
+    }
+    inline size_t write(int n)
+    {
+        return write((uint8_t) n);
+    }
+    operator bool() const;
+    void setDebugOutput(bool);
+    uint32_t baudRate(){return 115200;}
+
+};
+
+#if ARDUINO_HW_CDC_ON_BOOT //Serial used for USB CDC
+extern HWCDC Serial;
+#else
+extern HWCDC USBSerial;
+#endif
+
+#endif /* CONFIG_IDF_TARGET_ESP32C3 */

cores/esp32/HardwareSerial.cpp

@@ -5,87 +5,141 @@
 
 #include "pins_arduino.h"
 #include "HardwareSerial.h"
+#include "soc/soc_caps.h"
 
+#ifndef SOC_RX0
 #if CONFIG_IDF_TARGET_ESP32
+#define SOC_RX0 3
+#elif CONFIG_IDF_TARGET_ESP32S2
+#define SOC_RX0 44
+#elif CONFIG_IDF_TARGET_ESP32C3
+#define SOC_RX0 20
+#endif
+#endif
+
+#ifndef SOC_TX0
+#if CONFIG_IDF_TARGET_ESP32
+#define SOC_TX0 1
+#elif CONFIG_IDF_TARGET_ESP32S2
+#define SOC_TX0 43
+#elif CONFIG_IDF_TARGET_ESP32C3
+#define SOC_TX0 21
+#endif
+#endif
+
+void serialEvent(void) __attribute__((weak));
+void serialEvent(void) {}
+
+#if SOC_UART_NUM > 1
 
 #ifndef RX1
+#if CONFIG_IDF_TARGET_ESP32
 #define RX1 9
+#elif CONFIG_IDF_TARGET_ESP32S2
+#define RX1 18
+#elif CONFIG_IDF_TARGET_ESP32C3
+#define RX1 18
+#endif
 #endif
 
 #ifndef TX1
+#if CONFIG_IDF_TARGET_ESP32
 #define TX1 10
+#elif CONFIG_IDF_TARGET_ESP32S2
+#define TX1 17
+#elif CONFIG_IDF_TARGET_ESP32C3
+#define TX1 19
+#endif
 #endif
 
+void serialEvent1(void) __attribute__((weak));
+void serialEvent1(void) {}
+#endif /* SOC_UART_NUM > 1 */
+
+#if SOC_UART_NUM > 2
 #ifndef RX2
+#if CONFIG_IDF_TARGET_ESP32
 #define RX2 16
 #endif
+#endif
 
 #ifndef TX2
+#if CONFIG_IDF_TARGET_ESP32
 #define TX2 17
 #endif
-
-#else
-
-#ifndef RX1
-#define RX1 18
 #endif
 
-#ifndef TX1
-#define TX1 17
-#endif
-
-#endif
+void serialEvent2(void) __attribute__((weak));
+void serialEvent2(void) {}
+#endif /* SOC_UART_NUM > 2 */
 
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL)
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
+#if ARDUINO_USB_CDC_ON_BOOT //Serial used for USB CDC
+HardwareSerial Serial0(0);
+#elif ARDUINO_HW_CDC_ON_BOOT
 HardwareSerial Serial0(0);
 #else
 HardwareSerial Serial(0);
 #endif
+#if SOC_UART_NUM > 1
 HardwareSerial Serial1(1);
-#if CONFIG_IDF_TARGET_ESP32
+#endif
+#if SOC_UART_NUM > 2
 HardwareSerial Serial2(2);
 #endif
 #endif
 
-HardwareSerial::HardwareSerial(int uart_nr) : _uart_nr(uart_nr), _uart(NULL) {}
+void serialEventRun(void)
+{
+#if ARDUINO_USB_CDC_ON_BOOT //Serial used for USB CDC
+    if(Serial0.available()) serialEvent();
+#elif ARDUINO_HW_CDC_ON_BOOT
+    if(Serial0.available()) serialEvent();
+#else
+    if(Serial.available()) serialEvent();
+#endif
+#if SOC_UART_NUM > 1
+    if(Serial1.available()) serialEvent1();
+#endif
+#if SOC_UART_NUM > 2
+    if(Serial2.available()) serialEvent2();
+#endif
+}
+
+
+HardwareSerial::HardwareSerial(int uart_nr) : _uart_nr(uart_nr), _uart(NULL), _rxBufferSize(256) {}
 
 void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert, unsigned long timeout_ms, uint8_t rxfifo_full_thrhd)
 {
-    if(0 > _uart_nr || _uart_nr > 2) {
-        log_e("Serial number is invalid, please use 0, 1 or 2");
+    if(0 > _uart_nr || _uart_nr >= SOC_UART_NUM) {
+        log_e("Serial number is invalid, please use numers from 0 to %u", SOC_UART_NUM - 1);
         return;
     }
     if(_uart) {
-        end();
+        // in this case it is a begin() over a previous begin() - maybe to change baud rate
+        // thus do not disable debug output
+        end(false);
     }
     if(_uart_nr == 0 && rxPin < 0 && txPin < 0) {
-#if CONFIG_IDF_TARGET_ESP32
-        rxPin = 3;
-        txPin = 1;
-#elif CONFIG_IDF_TARGET_ESP32S2
-        rxPin = 44;
-        txPin = 43;
-#elif CONFIG_IDF_TARGET_ESP32C3
-        rxPin = 20;
-        txPin = 21;
-#endif
+        rxPin = SOC_RX0;
+        txPin = SOC_TX0;
     }
+#if SOC_UART_NUM > 1
     if(_uart_nr == 1 && rxPin < 0 && txPin < 0) {
         rxPin = RX1;
         txPin = TX1;
     }
-#if CONFIG_IDF_TARGET_ESP32
+#endif
+#if SOC_UART_NUM > 2
     if(_uart_nr == 2 && rxPin < 0 && txPin < 0) {
         rxPin = RX2;
         txPin = TX2;
     }
 #endif
-    _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, 256, invert, rxfifo_full_thrhd);
-    _tx_pin = txPin;
-    _rx_pin = rxPin;
 
-    if(!baud) {
+    _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, _rxBufferSize, invert, rxfifo_full_thrhd);
+    if (!baud) {
+        // using baud rate as zero, forces it to try to detect the current baud rate in place
         uartStartDetectBaudrate(_uart);
         time_t startMillis = millis();
         unsigned long detectedBaudRate = 0;
@@ -93,16 +147,14 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
             yield();
         }
 
-        end();
+        end(false);
 
         if(detectedBaudRate) {
             delay(100); // Give some time...
-            _uart = uartBegin(_uart_nr, detectedBaudRate, config, rxPin, txPin, 256, invert, rxfifo_full_thrhd);
+            _uart = uartBegin(_uart_nr, detectedBaudRate, config, rxPin, txPin, _rxBufferSize, invert, rxfifo_full_thrhd);
         } else {
             log_e("Could not detect baudrate. Serial data at the port must be present within the timeout for detection to be possible");
             _uart = NULL;
-            _tx_pin = 255;
-            _rx_pin = 255;
         }
     }
 }
@@ -112,21 +164,16 @@ void HardwareSerial::updateBaudRate(unsigned long baud)
 	uartSetBaudRate(_uart, baud);
 }
 
-void HardwareSerial::end()
+void HardwareSerial::end(bool turnOffDebug)
 {
-    if(uartGetDebug() == _uart_nr) {
+    if(turnOffDebug && uartGetDebug() == _uart_nr) {
         uartSetDebug(0);
     }
     delay(10);
-    log_v("pins %d %d",_tx_pin, _rx_pin);
-    uartEnd(_uart, _tx_pin, _rx_pin);
+    uartEnd(_uart);
     _uart = 0;
 }
 
-size_t HardwareSerial::setRxBufferSize(size_t new_size) {
-    return uartResizeRxBuffer(_uart, new_size);
-}
-
 void HardwareSerial::setDebugOutput(bool en)
 {
     if(_uart == 0) {
@@ -212,10 +259,31 @@ uint32_t  HardwareSerial::baudRate()
 }
 HardwareSerial::operator bool() const
 {
-    return true;
+    return uartIsDriverInstalled(_uart);
 }
 
 void HardwareSerial::setRxInvert(bool invert)
 {
     uartSetRxInvert(_uart, invert);
 }
+
+void HardwareSerial::setPins(uint8_t rxPin, uint8_t txPin)
+{
+    uartSetPins(_uart, rxPin, txPin);
+}
+
+size_t HardwareSerial::setRxBufferSize(size_t new_size) {
+
+    if (_uart) {
+        log_e("RX Buffer can't be resized when Serial is already running.\n");
+        return 0;
+    }
+
+    if (new_size <= SOC_UART_FIFO_LEN) {
+        log_e("RX Buffer must be higher than %d.\n", SOC_UART_FIFO_LEN);
+        return 0;
+    }
+
+    _rxBufferSize = new_size;
+    return _rxBufferSize;
+}

cores/esp32/HardwareSerial.h

@@ -49,6 +49,8 @@
 
 #include "Stream.h"
 #include "esp32-hal.h"
+#include "soc/soc_caps.h"
+#include "HWCDC.h"
 
 class HardwareSerial: public Stream
 {
@@ -56,7 +58,7 @@ public:
     HardwareSerial(int uart_nr);
 
     void begin(unsigned long baud, uint32_t config=SERIAL_8N1, int8_t rxPin=-1, int8_t txPin=-1, bool invert=false, unsigned long timeout_ms = 20000UL, uint8_t rxfifo_full_thrhd = 112);
-    void end();
+    void end(bool turnOffDebug = true);
     void updateBaudRate(unsigned long baud);
     int available(void);
     int availableForWrite(void);
@@ -98,33 +100,37 @@ public:
     uint32_t baudRate();
     operator bool() const;
 
-    size_t setRxBufferSize(size_t);
     void setDebugOutput(bool);
     
     void setRxInvert(bool);
+    void setPins(uint8_t rxPin, uint8_t txPin);
+    size_t setRxBufferSize(size_t new_size);
 
 protected:
     int _uart_nr;
     uart_t* _uart;
-    uint8_t _tx_pin;
-    uint8_t _rx_pin;
+    size_t _rxBufferSize;
 };
 
 extern void serialEventRun(void) __attribute__((weak));
 
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL)
-#ifndef ARDUINO_SERIAL_PORT
-#define ARDUINO_SERIAL_PORT 0
+#ifndef ARDUINO_USB_CDC_ON_BOOT
+#define ARDUINO_USB_CDC_ON_BOOT 0
 #endif
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
+#if ARDUINO_USB_CDC_ON_BOOT //Serial used for USB CDC
 #include "USB.h"
 #include "USBCDC.h"
 extern HardwareSerial Serial0;
+#elif ARDUINO_HW_CDC_ON_BOOT
+extern HardwareSerial Serial0;
 #else
 extern HardwareSerial Serial;
 #endif
+#if SOC_UART_NUM > 1
 extern HardwareSerial Serial1;
-#if CONFIG_IDF_TARGET_ESP32
+#endif
+#if SOC_UART_NUM > 2
 extern HardwareSerial Serial2;
 #endif
 #endif

cores/esp32/USB.cpp

@@ -11,10 +11,13 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+#include "USB.h"
+
+#if CONFIG_TINYUSB_ENABLED
+
 #include "esp32-hal.h"
 #include "esp32-hal-tinyusb.h"
-#include "USB.h"
-#if CONFIG_TINYUSB_ENABLED
+#include "common/tusb_common.h"
 
 #ifndef USB_VID
 #define USB_VID USB_ESPRESSIF_VID
@@ -31,14 +34,16 @@
 #ifndef USB_SERIAL
 #define USB_SERIAL "0"
 #endif
+#ifndef USB_WEBUSB_ENABLED
+#define USB_WEBUSB_ENABLED false
+#endif
+#ifndef USB_WEBUSB_URL
+#define USB_WEBUSB_URL "https://espressif.github.io/arduino-esp32/webusb.html"
+#endif
 
 #if CFG_TUD_DFU_RUNTIME
 static uint16_t load_dfu_descriptor(uint8_t * dst, uint8_t * itf)
 {
-#define DFU_ATTR_CAN_DOWNLOAD              1
-#define DFU_ATTR_CAN_UPLOAD                2
-#define DFU_ATTR_MANIFESTATION_TOLERANT    4
-#define DFU_ATTR_WILL_DETACH               8
 #define DFU_ATTRS (DFU_ATTR_CAN_DOWNLOAD | DFU_ATTR_CAN_UPLOAD | DFU_ATTR_MANIFESTATION_TOLERANT)
 
     uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB DFU_RT");
@@ -51,7 +56,7 @@ static uint16_t load_dfu_descriptor(uint8_t * dst, uint8_t * itf)
     return TUD_DFU_RT_DESC_LEN;
 }
 // Invoked on DFU_DETACH request to reboot to the bootloader
-void tud_dfu_rt_reboot_to_dfu(void)
+void tud_dfu_runtime_reboot_to_dfu_cb(void)
 {
     usb_persist_restart(RESTART_BOOTLOADER_DFU);
 }
@@ -120,8 +125,8 @@ ESPUSB::ESPUSB(size_t task_stack_size, uint8_t event_task_priority)
 ,usb_protocol(MISC_PROTOCOL_IAD)
 ,usb_attributes(TUSB_DESC_CONFIG_ATT_SELF_POWERED)
 ,usb_power_ma(500)
-,webusb_enabled(false)
-,webusb_url("espressif.github.io/arduino-esp32/webusb.html")
+,webusb_enabled(USB_WEBUSB_ENABLED)
+,webusb_url(USB_WEBUSB_URL)
 ,_started(false)
 ,_task_stack_size(task_stack_size)
 ,_event_task_priority(event_task_priority)
@@ -282,6 +287,9 @@ uint8_t ESPUSB::usbAttributes(void){
 bool ESPUSB::webUSB(bool enabled){
     if(!_started){
         webusb_enabled = enabled;
+        if(enabled && usb_version < 0x0210){
+            usb_version = 0x0210;
+        }
     }
     return !_started;
 }

cores/esp32/USB.h

@@ -14,12 +14,13 @@
 #pragma once
 
 #include "sdkconfig.h"
+
 #if CONFIG_TINYUSB_ENABLED
 
-#include "Arduino.h"
+#include "esp_event.h"
 #include "USBCDC.h"
 
-#include "esp_event.h"
+#define ARDUINO_USB_ON_BOOT (ARDUINO_USB_CDC_ON_BOOT|ARDUINO_USB_MSC_ON_BOOT|ARDUINO_USB_DFU_ON_BOOT)
 
 ESP_EVENT_DECLARE_BASE(ARDUINO_USB_EVENTS);
 

cores/esp32/USBCDC.cpp

@@ -11,24 +11,22 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#include "esp32-hal.h"
-#include "esp32-hal-tinyusb.h"
 #include "USB.h"
+#if CONFIG_TINYUSB_CDC_ENABLED
+
 #include "USBCDC.h"
-#if CONFIG_TINYUSB_ENABLED
+#include "esp32-hal-tinyusb.h"
 
 ESP_EVENT_DEFINE_BASE(ARDUINO_USB_CDC_EVENTS);
 esp_err_t arduino_usb_event_post(esp_event_base_t event_base, int32_t event_id, void *event_data, size_t event_data_size, TickType_t ticks_to_wait);
 esp_err_t arduino_usb_event_handler_register_with(esp_event_base_t event_base, int32_t event_id, esp_event_handler_t event_handler, void *event_handler_arg);
 
-#if CFG_TUD_CDC
 #define MAX_USB_CDC_DEVICES 2
 USBCDC * devices[MAX_USB_CDC_DEVICES] = {NULL, NULL};
 
 static uint16_t load_cdc_descriptor(uint8_t * dst, uint8_t * itf)
 {
     uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB CDC");
-    // Interface number, string index, attributes, detach timeout, transfer size */
     uint8_t descriptor[TUD_CDC_DESC_LEN] = {
             // Interface number, string index, EP notification address and size, EP data address (out, in) and size.
             TUD_CDC_DESCRIPTOR(*itf, str_index, 0x85, 64, 0x03, 0x84, 64)
@@ -38,6 +36,7 @@ static uint16_t load_cdc_descriptor(uint8_t * dst, uint8_t * itf)
     return TUD_CDC_DESC_LEN;
 }
 
+// Invoked when line state DTR & RTS are changed via SET_CONTROL_LINE_STATE
 void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
 {
     if(itf < MAX_USB_CDC_DEVICES && devices[itf] != NULL){
@@ -45,6 +44,7 @@ void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
     }
 }
 
+// Invoked when line coding is change via SET_LINE_CODING
 void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* p_line_coding)
 {
     if(itf < MAX_USB_CDC_DEVICES && devices[itf] != NULL){
@@ -52,6 +52,7 @@ void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* p_line_coding)
     }
 }
 
+// Invoked when received new data
 void tud_cdc_rx_cb(uint8_t itf)
 {
     if(itf < MAX_USB_CDC_DEVICES && devices[itf] != NULL){
@@ -59,9 +60,21 @@ void tud_cdc_rx_cb(uint8_t itf)
     }
 }
 
+// Invoked when received send break
+void tud_cdc_send_break_cb(uint8_t itf, uint16_t duration_ms){
+    //isr_log_v("itf: %u, duration_ms: %u", itf, duration_ms);
+}
+
+// Invoked when space becomes available in TX buffer
+void tud_cdc_tx_complete_cb(uint8_t itf){
+    if(itf < MAX_USB_CDC_DEVICES && devices[itf] != NULL && devices[itf]->tx_sem != NULL){
+        xSemaphoreGive(devices[itf]->tx_sem);
+        devices[itf]->_onTX();
+    }
+}
 
 static size_t tinyusb_cdc_write(uint8_t itf, const uint8_t *buffer, size_t size){
-    if(itf >= MAX_USB_CDC_DEVICES){
+    if(itf >= MAX_USB_CDC_DEVICES || devices[itf] == NULL || devices[itf]->tx_sem == NULL){
         return 0;
     }
     if(!tud_cdc_n_connected(itf)){
@@ -71,8 +84,15 @@ static size_t tinyusb_cdc_write(uint8_t itf, const uint8_t *buffer, size_t size)
     while(tosend){
         uint32_t space = tud_cdc_n_write_available(itf);
         if(!space){
-            delay(1);
-            continue;
+            //make sure that we do not get previous semaphore
+            xSemaphoreTake(devices[itf]->tx_sem, 0);
+            //wait for tx_complete
+            if(xSemaphoreTake(devices[itf]->tx_sem, 200 / portTICK_PERIOD_MS) == pdTRUE){
+                space = tud_cdc_n_write_available(itf);
+            }
+            if(!space){
+                return sofar;
+            }
         }
         if(tosend < space){
             space = tosend;
@@ -84,6 +104,7 @@ static size_t tinyusb_cdc_write(uint8_t itf, const uint8_t *buffer, size_t size)
         sofar += sent;
         tosend -= sent;
         tud_cdc_n_write_flush(itf);
+        //xSemaphoreTake(devices[itf]->tx_sem, portMAX_DELAY);
     }
     return sofar;
 }
@@ -93,20 +114,21 @@ static void ARDUINO_ISR_ATTR cdc0_write_char(char c)
     tinyusb_cdc_write(0, (const uint8_t *)&c, 1);
 }
 
-//void tud_cdc_rx_wanted_cb(uint8_t itf, char wanted_char);
-
 static void usb_unplugged_cb(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data){
     ((USBCDC*)arg)->_onUnplugged();
 }
 
-USBCDC::USBCDC(uint8_t itfn) : itf(itfn), bit_rate(0), stop_bits(0), parity(0), data_bits(0), dtr(false),  rts(false), connected(false), reboot_enable(true), rx_queue(NULL) {
+USBCDC::USBCDC(uint8_t itfn) : itf(itfn), bit_rate(0), stop_bits(0), parity(0), data_bits(0), dtr(false),  rts(false), connected(false), reboot_enable(true), rx_queue(NULL), tx_sem(NULL) {
     tinyusb_enable_interface(USB_INTERFACE_CDC, TUD_CDC_DESC_LEN, load_cdc_descriptor);
     if(itf < MAX_USB_CDC_DEVICES){
-        devices[itf] = this;
         arduino_usb_event_handler_register_with(ARDUINO_USB_EVENTS, ARDUINO_USB_STOPPED_EVENT, usb_unplugged_cb, this);
     }
 }
 
+USBCDC::~USBCDC(){
+    end();
+}
+
 void USBCDC::onEvent(esp_event_handler_t callback){
     onEvent(ARDUINO_USB_CDC_ANY_EVENT, callback);
 }
@@ -116,6 +138,10 @@ void USBCDC::onEvent(arduino_usb_cdc_event_t event, esp_event_handler_t callback
 
 size_t USBCDC::setRxBufferSize(size_t rx_queue_len){
     if(rx_queue){
+        if(!rx_queue_len){
+            vQueueDelete(rx_queue);
+            rx_queue = NULL;
+        }
         return 0;
     }
     rx_queue = xQueueCreate(rx_queue_len, sizeof(uint8_t));
@@ -127,11 +153,23 @@ size_t USBCDC::setRxBufferSize(size_t rx_queue_len){
 
 void USBCDC::begin(unsigned long baud)
 {
+    if(tx_sem == NULL){
+        tx_sem = xSemaphoreCreateBinary();
+        xSemaphoreTake(tx_sem, 0);
+    }
     setRxBufferSize(256);//default if not preset
+    devices[itf] = this;
 }
 
 void USBCDC::end()
 {
+    connected = false;
+    devices[itf] = NULL;
+    setRxBufferSize(0);
+    if (tx_sem != NULL) {
+        vSemaphoreDelete(tx_sem);
+        tx_sem = NULL;
+    }
 }
 
 void USBCDC::_onUnplugged(void){
@@ -147,6 +185,11 @@ void USBCDC::_onUnplugged(void){
 enum { CDC_LINE_IDLE, CDC_LINE_1, CDC_LINE_2, CDC_LINE_3 };
 void USBCDC::_onLineState(bool _dtr, bool _rts){
     static uint8_t lineState = CDC_LINE_IDLE;
+
+    if(dtr == _dtr && rts == _rts){
+        return; // Skip duplicate events
+    }
+
     dtr = _dtr;
     rts = _rts;
 
@@ -154,6 +197,11 @@ void USBCDC::_onLineState(bool _dtr, bool _rts){
         if(!dtr && rts){
             if(lineState == CDC_LINE_IDLE){
                 lineState++;
+                if(connected){
+                    connected = false;
+                    arduino_usb_cdc_event_data_t p = {0};
+                    arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_DISCONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
+                }
             } else {
                 lineState = CDC_LINE_IDLE;
             }
@@ -183,7 +231,7 @@ void USBCDC::_onLineState(bool _dtr, bool _rts){
             connected = true;
             arduino_usb_cdc_event_data_t p = {0};
             arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_CONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
-        } else if(!dtr && !rts && connected){
+        } else if(!dtr && connected){
             connected = false;
             arduino_usb_cdc_event_data_t p = {0};
             arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_DISCONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
@@ -198,7 +246,8 @@ void USBCDC::_onLineState(bool _dtr, bool _rts){
 
 void USBCDC::_onLineCoding(uint32_t _bit_rate, uint8_t _stop_bits, uint8_t _parity, uint8_t _data_bits){
     if(bit_rate != _bit_rate || data_bits != _data_bits || stop_bits != _stop_bits || parity != _parity){
-        if(bit_rate == 9600 && _bit_rate == 1200){
+        // ArduinoIDE sends LineCoding with 1200bps baud to reset the device
+        if(reboot_enable && _bit_rate == 1200){
             usb_persist_restart(RESTART_BOOTLOADER);
         } else {
             bit_rate = _bit_rate;
@@ -228,6 +277,11 @@ void USBCDC::_onRX(){
     arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_RX_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
 }
 
+void USBCDC::_onTX(){
+    arduino_usb_cdc_event_data_t p = {0};
+    arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_TX_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
+}
+
 void  USBCDC::enableReboot(bool enable){
     reboot_enable = enable;
 }
@@ -282,7 +336,7 @@ size_t USBCDC::read(uint8_t *buffer, size_t size)
 
 void USBCDC::flush(void)
 {
-    if(itf >= MAX_USB_CDC_DEVICES){
+    if(itf >= MAX_USB_CDC_DEVICES || tx_sem == NULL){
         return;
     }
     tud_cdc_n_write_flush(itf);
@@ -290,7 +344,7 @@ void USBCDC::flush(void)
 
 int USBCDC::availableForWrite(void)
 {
-    if(itf >= MAX_USB_CDC_DEVICES){
+    if(itf >= MAX_USB_CDC_DEVICES || tx_sem == NULL){
         return -1;
     }
     return tud_cdc_n_write_available(itf);
@@ -329,10 +383,8 @@ USBCDC::operator bool() const
     return connected;
 }
 
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
+#if ARDUINO_USB_CDC_ON_BOOT //Serial used for USB CDC
 USBCDC Serial(0);
 #endif
 
 #endif /* CONFIG_TINYUSB_CDC_ENABLED */
-
-#endif /* CONFIG_TINYUSB_ENABLED */

cores/esp32/USBCDC.h

@@ -13,13 +13,12 @@
 // limitations under the License.
 #pragma once
 
-#include <inttypes.h>
-
-#include "Stream.h"
-#include "esp32-hal.h"
+#include "sdkconfig.h"
 #if CONFIG_TINYUSB_CDC_ENABLED
 
+#include <inttypes.h>
 #include "esp_event.h"
+#include "Stream.h"
 
 ESP_EVENT_DECLARE_BASE(ARDUINO_USB_CDC_EVENTS);
 
@@ -30,6 +29,7 @@ typedef enum {
     ARDUINO_USB_CDC_LINE_STATE_EVENT,
     ARDUINO_USB_CDC_LINE_CODING_EVENT,
     ARDUINO_USB_CDC_RX_EVENT,
+    ARDUINO_USB_CDC_TX_EVENT,
     ARDUINO_USB_CDC_MAX_EVENT,
 } arduino_usb_cdc_event_t;
 
@@ -53,6 +53,7 @@ class USBCDC: public Stream
 {
 public:
     USBCDC(uint8_t itf=0);
+    ~USBCDC();
 
     void onEvent(esp_event_handler_t callback);
     void onEvent(arduino_usb_cdc_event_t event, esp_event_handler_t callback);
@@ -110,7 +111,9 @@ public:
     void _onLineState(bool _dtr, bool _rts);
     void _onLineCoding(uint32_t _bit_rate, uint8_t _stop_bits, uint8_t _parity, uint8_t _data_bits);
     void _onRX(void);
+    void _onTX(void);
     void _onUnplugged(void);
+    xSemaphoreHandle tx_sem;
     
 protected:
     uint8_t  itf;
@@ -126,7 +129,7 @@ protected:
     
 };
 
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
+#if ARDUINO_USB_CDC_ON_BOOT //Serial used for USB CDC
 extern USBCDC Serial;
 #endif
 

cores/esp32/USBMSC.cpp

@@ -0,0 +1,260 @@
+// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "USBMSC.h"
+
+#if CONFIG_TINYUSB_MSC_ENABLED
+
+#include "esp32-hal-tinyusb.h"
+
+extern "C" uint16_t tusb_msc_load_descriptor(uint8_t * dst, uint8_t * itf)
+{
+    uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB MSC");
+    uint8_t ep_num = tinyusb_get_free_duplex_endpoint();
+    TU_VERIFY (ep_num != 0);
+    uint8_t descriptor[TUD_MSC_DESC_LEN] = {
+        // Interface number, string index, EP Out & EP In address, EP size
+        TUD_MSC_DESCRIPTOR(*itf, str_index, ep_num, (uint8_t)(0x80 | ep_num), 64)
+    };
+    *itf+=1;
+    memcpy(dst, descriptor, TUD_MSC_DESC_LEN);
+    return TUD_MSC_DESC_LEN;
+}
+
+typedef struct {
+    bool media_present;
+    uint8_t vendor_id[8];
+    uint8_t product_id[16];
+    uint8_t product_rev[4];
+    uint16_t block_size;
+    uint32_t block_count;
+    bool (*start_stop)(uint8_t power_condition, bool start, bool load_eject);
+    int32_t (*read)(uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize);
+    int32_t (*write)(uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize);
+} msc_lun_t;
+
+static const uint8_t MSC_MAX_LUN = 3;
+static uint8_t MSC_ACTIVE_LUN = 0;
+static msc_lun_t msc_luns[MSC_MAX_LUN];
+
+static void cplstr(void *dst, const void * src, size_t max_len){
+    if(!src || !dst || !max_len){
+        return;
+    }
+    size_t l = strlen((const char *)src);
+    if(l > max_len){
+        l = max_len;
+    }
+    memcpy(dst, src, l);
+}
+
+// Invoked when received GET_MAX_LUN request, required for multiple LUNs implementation
+uint8_t tud_msc_get_maxlun_cb(void)
+{
+    log_v("%u", MSC_ACTIVE_LUN);
+    return MSC_ACTIVE_LUN;
+}
+
+// Invoked when received SCSI_CMD_INQUIRY
+// Application fill vendor id, product id and revision with string up to 8, 16, 4 characters respectively
+void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t product_id[16], uint8_t product_rev[4])
+{
+    log_v("[%u]", lun);
+    cplstr(vendor_id  , msc_luns[lun].vendor_id, 8);
+    cplstr(product_id , msc_luns[lun].product_id, 16);
+    cplstr(product_rev, msc_luns[lun].product_rev, 4);
+}
+
+// Invoked when received Test Unit Ready command.
+// return true allowing host to read/write this LUN e.g SD card inserted
+bool tud_msc_test_unit_ready_cb(uint8_t lun)
+{
+    log_v("[%u]: %u", lun, msc_luns[lun].media_present);
+    return msc_luns[lun].media_present; // RAM disk is always ready
+}
+
+// Invoked when received SCSI_CMD_READ_CAPACITY_10 and SCSI_CMD_READ_FORMAT_CAPACITY to determine the disk size
+// Application update block count and block size
+void tud_msc_capacity_cb(uint8_t lun, uint32_t* block_count, uint16_t* block_size)
+{
+    log_v("[%u]", lun);
+    if(!msc_luns[lun].media_present){
+        *block_count = 0;
+        *block_size  = 0;
+        return;
+    }
+
+    *block_count = msc_luns[lun].block_count;
+    *block_size  = msc_luns[lun].block_size;
+}
+
+// Invoked when received Start Stop Unit command
+// - Start = 0 : stopped power mode, if load_eject = 1 : unload disk storage
+// - Start = 1 : active mode, if load_eject = 1 : load disk storage
+bool tud_msc_start_stop_cb(uint8_t lun, uint8_t power_condition, bool start, bool load_eject)
+{
+    log_v("[%u] power: %u, start: %u, eject: %u", lun, power_condition, start, load_eject);
+    if(msc_luns[lun].start_stop){
+        return msc_luns[lun].start_stop(power_condition, start, load_eject);
+    }
+    return true;
+}
+
+// Callback invoked when received READ10 command.
+// Copy disk's data to buffer (up to bufsize) and return number of copied bytes.
+int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize)
+{
+    log_v("[%u], lba: %u, offset: %u, bufsize: %u", lun, lba, offset, bufsize);
+    if(!msc_luns[lun].media_present){
+        return 0;
+    }
+    if(msc_luns[lun].read){
+        return msc_luns[lun].read(lba, offset, buffer, bufsize);
+    }
+    return 0;
+}
+
+// Callback invoked when received WRITE10 command.
+// Process data in buffer to disk's storage and return number of written bytes
+int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize)
+{
+    log_v("[%u], lba: %u, offset: %u, bufsize: %u", lun, lba, offset, bufsize);
+    if(!msc_luns[lun].media_present){
+        return 0;
+    }
+    if(msc_luns[lun].write){
+        return msc_luns[lun].write(lba, offset, buffer, bufsize);
+    }
+    return 0;
+}
+
+// Callback invoked when received an SCSI command not in built-in list below
+// - READ_CAPACITY10, READ_FORMAT_CAPACITY, INQUIRY, MODE_SENSE6, REQUEST_SENSE
+// - READ10 and WRITE10 has their own callbacks
+int32_t tud_msc_scsi_cb (uint8_t lun, uint8_t const scsi_cmd[16], void* buffer, uint16_t bufsize)
+{
+    // read10 & write10 has their own callback and MUST not be handled here
+    log_v("[%u] cmd: %u, bufsize: %u", lun, scsi_cmd[0], bufsize);
+
+    void const* response = NULL;
+    uint16_t resplen = 0;
+
+    // most scsi handled is input
+    bool in_xfer = true;
+    
+    if(!msc_luns[lun].media_present){
+        return -1;
+    }
+
+    switch (scsi_cmd[0]) {
+        case SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
+            // Host is about to read/write etc ... better not to disconnect disk
+            resplen = 0;
+            break;
+
+        default:
+            // Set Sense = Invalid Command Operation
+            tud_msc_set_sense(lun, SCSI_SENSE_ILLEGAL_REQUEST, 0x20, 0x00);
+
+            // negative means error -> tinyusb could stall and/or response with failed status
+            resplen = -1;
+            break;
+    }
+
+    // return resplen must not larger than bufsize
+    if (resplen > bufsize) resplen = bufsize;
+
+    if (response && (resplen > 0)) {
+        if (in_xfer) {
+            memcpy(buffer, response, resplen);
+        } else {
+            // SCSI output
+        }
+    }
+
+    return resplen;
+}
+
+USBMSC::USBMSC(){
+    if(MSC_ACTIVE_LUN < MSC_MAX_LUN){
+        _lun = MSC_ACTIVE_LUN;
+        MSC_ACTIVE_LUN++;
+        msc_luns[_lun].media_present = false;
+        msc_luns[_lun].vendor_id[0] = 0;
+        msc_luns[_lun].product_id[0] = 0;
+        msc_luns[_lun].product_rev[0] = 0;
+        msc_luns[_lun].block_size = 0;
+        msc_luns[_lun].block_count = 0;
+        msc_luns[_lun].start_stop = NULL;
+        msc_luns[_lun].read = NULL;
+        msc_luns[_lun].write = NULL;
+    }
+    if(_lun == 0){
+        tinyusb_enable_interface(USB_INTERFACE_MSC, TUD_MSC_DESC_LEN, tusb_msc_load_descriptor);
+    }
+}
+
+USBMSC::~USBMSC(){
+  end();
+}
+
+bool USBMSC::begin(uint32_t block_count, uint16_t block_size){
+    msc_luns[_lun].block_size = block_size;
+    msc_luns[_lun].block_count = block_count;
+    if(!msc_luns[_lun].block_size || !msc_luns[_lun].block_count || !msc_luns[_lun].read || !msc_luns[_lun].write){
+        return false;
+    }
+    return true;
+}
+
+void USBMSC::end(){
+    msc_luns[_lun].media_present = false;
+    msc_luns[_lun].vendor_id[0] = 0;
+    msc_luns[_lun].product_id[0] = 0;
+    msc_luns[_lun].product_rev[0] = 0;
+    msc_luns[_lun].block_size = 0;
+    msc_luns[_lun].block_count = 0;
+    msc_luns[_lun].start_stop = NULL;
+    msc_luns[_lun].read = NULL;
+    msc_luns[_lun].write = NULL;
+}
+
+void USBMSC::vendorID(const char * vid){
+    cplstr(msc_luns[_lun].vendor_id, vid, 8);
+}
+
+void USBMSC::productID(const char * pid){
+    cplstr(msc_luns[_lun].product_id, pid, 16);
+}
+
+void USBMSC::productRevision(const char * rev){
+    cplstr(msc_luns[_lun].product_rev, rev, 4);
+}
+
+void USBMSC::onStartStop(msc_start_stop_cb cb){
+    msc_luns[_lun].start_stop = cb;
+}
+
+void USBMSC::onRead(msc_read_cb cb){
+    msc_luns[_lun].read = cb;
+}
+
+void USBMSC::onWrite(msc_write_cb cb){
+    msc_luns[_lun].write = cb;
+}
+
+void USBMSC::mediaPresent(bool media_present){
+    msc_luns[_lun].media_present = media_present;
+}
+
+#endif /* CONFIG_TINYUSB_MSC_ENABLED */

cores/esp32/USBMSC.h

@@ -0,0 +1,51 @@
+// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#include <stdint.h>
+#include <stdbool.h>
+#include "sdkconfig.h"
+
+#if CONFIG_TINYUSB_MSC_ENABLED
+
+// Invoked when received Start Stop Unit command
+// - Start = 0 : stopped power mode, if load_eject = 1 : unload disk storage
+// - Start = 1 : active mode, if load_eject = 1 : load disk storage
+typedef bool (*msc_start_stop_cb)(uint8_t power_condition, bool start, bool load_eject);
+
+// Copy disk's data to buffer (up to bufsize) and return number of copied bytes.
+typedef int32_t (*msc_read_cb)(uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize);
+
+// Process data in buffer to disk's storage and return number of written bytes
+typedef int32_t (*msc_write_cb)(uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize);
+
+class USBMSC
+{
+public:
+    USBMSC();
+    ~USBMSC();
+    bool begin(uint32_t block_count, uint16_t block_size);
+    void end();
+    void vendorID(const char * vid);//max 8 chars
+    void productID(const char * pid);//max 16 chars
+    void productRevision(const char * ver);//max 4 chars
+    void mediaPresent(bool media_present);
+    void onStartStop(msc_start_stop_cb cb);
+    void onRead(msc_read_cb cb);
+    void onWrite(msc_write_cb cb);
+private:
+	uint8_t _lun;
+};
+
+#endif /* CONFIG_TINYUSB_MSC_ENABLED */

cores/esp32/WMath.cpp

@@ -77,12 +77,12 @@ long map(long x, long in_min, long in_max, long out_min, long out_max) {
     return (delta * dividend + (divisor / 2)) / divisor + out_min;
 }
 
-unsigned int makeWord(unsigned int w)
+uint16_t makeWord(uint16_t w)
 {
     return w;
 }
 
-unsigned int makeWord(unsigned char h, unsigned char l)
+uint16_t makeWord(uint8_t h, uint8_t l)
 {
     return (h << 8) | l;
 }

cores/esp32/WString.cpp

@@ -35,6 +35,12 @@ String::String(const char *cstr) {
         copy(cstr, strlen(cstr));
 }
 
+String::String(const char *cstr, unsigned int length) {
+    init();
+    if (cstr)
+        copy(cstr, length);
+}
+
 String::String(const String &value) {
     init();
     *this = value;
@@ -59,9 +65,7 @@ String::String(StringSumHelper &&rval) {
 
 String::String(char c) {
     init();
-    char buf[2];
-    buf[0] = c;
-    buf[1] = 0;
+    char buf[] = { c, '\0' };
     *this = buf;
 }
 
@@ -290,10 +294,11 @@ String & String::operator =(const char *cstr) {
     return *this;
 }
 
-String & String::operator = (const __FlashStringHelper *pstr)
-{
-    if (pstr) copy(pstr, strlen_P((PGM_P)pstr));
-    else invalidate();
+String & String::operator =(const __FlashStringHelper *pstr) {
+    if(pstr)
+        copy(pstr, strlen_P((PGM_P)pstr));
+    else
+        invalidate();
 
     return *this;
 }
@@ -347,22 +352,18 @@ unsigned char String::concat(const char *cstr) {
 }
 
 unsigned char String::concat(char c) {
-    char buf[2];
-    buf[0] = c;
-    buf[1] = 0;
+    char buf[] = { c, '\0' };
     return concat(buf, 1);
 }
 
 unsigned char String::concat(unsigned char num) {
     char buf[1 + 3 * sizeof(unsigned char)];
-    sprintf(buf, "%d", num);
-    return concat(buf, strlen(buf));
+    return concat(buf, sprintf(buf, "%d", num));
 }
 
 unsigned char String::concat(int num) {
     char buf[2 + 3 * sizeof(int)];
-    sprintf(buf, "%d", num);
-    return concat(buf, strlen(buf));
+    return concat(buf, sprintf(buf, "%d", num));
 }
 
 unsigned char String::concat(unsigned int num) {
@@ -373,8 +374,7 @@ unsigned char String::concat(unsigned int num) {
 
 unsigned char String::concat(long num) {
     char buf[2 + 3 * sizeof(long)];
-    sprintf(buf, "%ld", num);
-    return concat(buf, strlen(buf));
+    return concat(buf, sprintf(buf, "%ld", num));
 }
 
 unsigned char String::concat(unsigned long num) {
@@ -555,7 +555,7 @@ unsigned char String::equalsConstantTime(const String &s2) const {
     //at this point lengths are the same
     if(len() == 0)
         return 1;
-    //at this point lenghts are the same and non-zero
+    //at this point lengths are the same and non-zero
     const char *p1 = buffer();
     const char *p2 = s2.buffer();
     unsigned int equalchars = 0;
@@ -711,10 +711,7 @@ String String::substring(unsigned int left, unsigned int right) const {
         return out;
     if(right > len())
         right = len();
-    char temp = buffer()[right];  // save the replaced character
-    wbuffer()[right] = '\0';
-    out = wbuffer() + left;  // pointer arithmetic
-    wbuffer()[right] = temp;  //restore character
+    out.copy(buffer() + left, right - left);
     return out;
 }
 

cores/esp32/WString.h

@@ -55,6 +55,10 @@ class String {
         // fails, the string will be marked as invalid (i.e. "if (s)" will
         // be false).
         String(const char *cstr = "");
+        String(const char *cstr, unsigned int length);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+        String(const uint8_t *cstr, unsigned int length) : String((const char*)cstr, length) {}
+#endif
         String(const String &str);
         String(const __FlashStringHelper *str);
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
@@ -108,6 +112,8 @@ class String {
         // concatenation is considered unsuccessful.
         unsigned char concat(const String &str);
         unsigned char concat(const char *cstr);
+        unsigned char concat(const char *cstr, unsigned int length);
+        unsigned char concat(const uint8_t *cstr, unsigned int length) {return concat((const char*)cstr, length);}
         unsigned char concat(char c);
         unsigned char concat(unsigned char c);
         unsigned char concat(int num);
@@ -326,7 +332,6 @@ class String {
         void init(void);
         void invalidate(void);
         unsigned char changeBuffer(unsigned int maxStrLen);
-        unsigned char concat(const char *cstr, unsigned int length);
 
         // copy and move
         String & copy(const char *cstr, unsigned int length);

cores/esp32/esp32-hal-adc.c

@@ -48,6 +48,7 @@ static uint8_t __analogVRefPin = 0;
 static uint8_t __analogAttenuation = 3;//11db
 static uint8_t __analogWidth = 3;//12 bits
 static uint8_t __analogClockDiv = 1;
+static adc_attenuation_t __pin_attenuation[SOC_GPIO_PIN_COUNT];
 
 void __analogSetClockDiv(uint8_t clockDiv){
     if(!clockDiv){
@@ -86,6 +87,9 @@ void __analogInit(){
 #if CONFIG_IDF_TARGET_ESP32
     __analogSetWidth(__analogWidth + 9);//in bits
 #endif
+    for(int i=0; i<SOC_GPIO_PIN_COUNT; i++){
+        __pin_attenuation[i] = ADC_ATTENDB_MAX;
+    }
 }
 
 void __analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation)
@@ -100,6 +104,9 @@ void __analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation)
         adc1_config_channel_atten(channel, attenuation);
     }
     __analogInit();
+    if((__pin_attenuation[pin] != ADC_ATTENDB_MAX) || (attenuation != __analogAttenuation)){
+        __pin_attenuation[pin] = attenuation;
+    }
 }
 
 bool __adcAttachPin(uint8_t pin){
@@ -108,6 +115,7 @@ bool __adcAttachPin(uint8_t pin){
         log_e("Pin %u is not ADC pin!", pin);
         return false;
     }
+    __analogInit();
     int8_t pad = digitalPinToTouchChannel(pin);
     if(pad >= 0){
 #if CONFIG_IDF_TARGET_ESP32
@@ -129,7 +137,7 @@ bool __adcAttachPin(uint8_t pin){
 #endif
 
     pinMode(pin, ANALOG);
-    __analogSetPinAttenuation(pin, __analogAttenuation);
+    __analogSetPinAttenuation(pin, (__pin_attenuation[pin] != ADC_ATTENDB_MAX)?__pin_attenuation[pin]:__analogAttenuation);
     return true;
 }
 
@@ -161,7 +169,7 @@ uint16_t __analogRead(uint8_t pin)
         } else if ( r == ESP_ERR_INVALID_STATE ) {
             log_e("GPIO%u: %s: ADC2 not initialized yet.", pin, esp_err_to_name(r));
         } else if ( r == ESP_ERR_TIMEOUT ) {
-            log_e("GPIO%u: %s: ADC2 is in use by Wi-Fi.", pin, esp_err_to_name(r));
+            log_e("GPIO%u: %s: ADC2 is in use by Wi-Fi. Please see https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/adc.html#adc-limitations for more info", pin, esp_err_to_name(r));
         } else {
             log_e("GPIO%u: %s", pin, esp_err_to_name(r));
         }
@@ -245,28 +253,12 @@ void __analogSetVRefPin(uint8_t pin){
     __analogVRefPin = pin;
 }
 
-int __hallRead()    //hall sensor without LNA
+int __hallRead()    //hall sensor using idf read
 {
-    int Sens_Vp0;
-    int Sens_Vn0;
-    int Sens_Vp1;
-    int Sens_Vn1;
-
     pinMode(36, ANALOG);
     pinMode(39, ANALOG);
-    SET_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL1_REG, SENS_XPD_HALL_FORCE_M);     // hall sens force enable
-    SET_PERI_REG_MASK(RTC_IO_HALL_SENS_REG, RTC_IO_XPD_HALL);               // xpd hall
-    SET_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL1_REG, SENS_HALL_PHASE_FORCE_M);   // phase force
-    CLEAR_PERI_REG_MASK(RTC_IO_HALL_SENS_REG, RTC_IO_HALL_PHASE);           // hall phase
-    Sens_Vp0 = __analogRead(36);
-    Sens_Vn0 = __analogRead(39);
-    SET_PERI_REG_MASK(RTC_IO_HALL_SENS_REG, RTC_IO_HALL_PHASE);
-    Sens_Vp1 = __analogRead(36);
-    Sens_Vn1 = __analogRead(39);
-    SET_PERI_REG_BITS(SENS_SAR_MEAS_WAIT2_REG, SENS_FORCE_XPD_SAR, 0, SENS_FORCE_XPD_SAR_S);
-    CLEAR_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL1_REG, SENS_XPD_HALL_FORCE);
-    CLEAR_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL1_REG, SENS_HALL_PHASE_FORCE);
-    return (Sens_Vp1 - Sens_Vp0) - (Sens_Vn1 - Sens_Vn0);
+    __analogSetWidth(12);
+    return hall_sensor_read();
 }
 #endif
 

cores/esp32/esp32-hal-adc.h

@@ -30,7 +30,8 @@ typedef enum {
     ADC_0db,
     ADC_2_5db,
     ADC_6db,
-    ADC_11db
+    ADC_11db,
+    ADC_ATTENDB_MAX
 } adc_attenuation_t;
 
 /*

cores/esp32/esp32-hal-i2c.c

@@ -1844,11 +1844,13 @@ i2c_t * i2cInit(uint8_t i2c_num, int8_t sda, int8_t scl, uint32_t clk_speed){
 }
 
 i2c_err_t i2cWrite(i2c_t * i2c, uint16_t address, uint8_t* buff, uint16_t size, bool sendStop, uint16_t timeOutMillis){
-	esp_err_t ret = ESP_OK;
+    esp_err_t ret = ESP_OK;
     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
     i2c_master_start(cmd);
     i2c_master_write_byte(cmd, (address << 1) | I2C_MASTER_WRITE, ACK_CHECK_EN);
-    i2c_master_write(cmd, buff, size, ACK_CHECK_EN);
+    if(size){
+        i2c_master_write(cmd, buff, size, ACK_CHECK_EN);
+    }
     //if send stop?
     i2c_master_stop(cmd);
     ret = i2c_master_cmd_begin(i2c->num, cmd, timeOutMillis / portTICK_RATE_MS);

cores/esp32/esp32-hal-ledc.c

@@ -115,6 +115,10 @@ static void _ledcSetupTimer(uint8_t chan, uint32_t div_num, uint8_t bit_num, boo
     uint8_t group=(chan/8), timer=((chan/2)%4);
     static bool tHasStarted = false;
     static uint16_t _activeChannels = 0;
+#if CONFIG_IDF_TARGET_ESP32S2
+// ESP32-S2 TRM v1.0 on Page 789 -> BIT LEDC_TICK_SEL_TIMERx is 0 for LEDC_PWM_CLK and 1 for REF_TICK
+    apb_clk = 0;        
+#endif
     if(!tHasStarted) {
         tHasStarted = true;
         periph_module_enable(PERIPH_LEDC_MODULE);

cores/esp32/esp32-hal-log.c

@@ -1,19 +0,0 @@
-#ifndef __MY_LOG__
-#define __MY_LOG__
-#include "stdio.h"
-#include "esp32-hal-log.h"
-void log_to_esp(char* tag, esp_log_level_t level, const char *format, ...)
-{
-    va_list va_args;
-    va_start(va_args, format);
-
-    char log_buffer[512];
-    int len = vsnprintf(log_buffer, sizeof(log_buffer), format, va_args);
-    if (len > 0)
-    {
-        ESP_LOG_LEVEL_LOCAL(level, tag, "%s", log_buffer);
-    }
-
-    va_end(va_args);
-}
-#endif

cores/esp32/esp32-hal-log.h

@@ -66,6 +66,8 @@ extern "C"
 #define ARDUHAL_LOG_COLOR_I       ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_GREEN)
 #define ARDUHAL_LOG_COLOR_D       ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_CYAN)
 #define ARDUHAL_LOG_COLOR_V       ARDUHAL_LOG_COLOR(ARDUHAL_LOG_COLOR_GRAY)
+#define ARDUHAL_LOG_COLOR_PRINT(letter) log_printf(ARDUHAL_LOG_COLOR_ ## letter)
+#define ARDUHAL_LOG_COLOR_PRINT_END log_printf(ARDUHAL_LOG_RESET_COLOR)
 #else
 #define ARDUHAL_LOG_COLOR_E
 #define ARDUHAL_LOG_COLOR_W
@@ -73,12 +75,15 @@ extern "C"
 #define ARDUHAL_LOG_COLOR_D
 #define ARDUHAL_LOG_COLOR_V
 #define ARDUHAL_LOG_RESET_COLOR
+#define ARDUHAL_LOG_COLOR_PRINT(letter)
+#define ARDUHAL_LOG_COLOR_PRINT_END
 #endif
 
 
 
 const char * pathToFileName(const char * path);
 int log_printf(const char *fmt, ...);
+void log_print_buf(const uint8_t *b, size_t len);
 
 #define ARDUHAL_SHORT_LOG_FORMAT(letter, format)  ARDUHAL_LOG_COLOR_ ## letter format ARDUHAL_LOG_RESET_COLOR "\r\n"
 #define ARDUHAL_LOG_FORMAT(letter, format)  ARDUHAL_LOG_COLOR_ ## letter "[%6u][" #letter "][%s:%u] %s(): " format ARDUHAL_LOG_RESET_COLOR "\r\n", (unsigned long) (esp_timer_get_time() / 1000ULL), pathToFileName(__FILE__), __LINE__, __FUNCTION__
@@ -87,78 +92,96 @@ int log_printf(const char *fmt, ...);
 #ifndef USE_ESP_IDF_LOG
 #define log_v(format, ...) log_printf(ARDUHAL_LOG_FORMAT(V, format), ##__VA_ARGS__)
 #define isr_log_v(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(V, format), ##__VA_ARGS__)
+#define log_buf_v(b,l) do{ARDUHAL_LOG_COLOR_PRINT(V);log_print_buf(b,l);ARDUHAL_LOG_COLOR_PRINT_END;}while(0)
 #else
-#define log_v(format, ...) do {log_to_esp(TAG, ESP_LOG_VERBOSE, format, ##__VA_ARGS__);}while(0)
+#define log_v(format, ...) do {ESP_LOG_LEVEL_LOCAL(ESP_LOG_VERBOSE, TAG, format, ##__VA_ARGS__);}while(0)
 #define isr_log_v(format, ...) do {ets_printf(LOG_FORMAT(V, format), esp_log_timestamp(), TAG, ##__VA_ARGS__);}while(0)
+#define log_buf_v(b,l) do {ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_VERBOSE);}while(0)
 #endif
 #else
 #define log_v(format, ...)
 #define isr_log_v(format, ...)
+#define log_buf_v(b,l)
 #endif
 
 #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG
 #ifndef USE_ESP_IDF_LOG
 #define log_d(format, ...) log_printf(ARDUHAL_LOG_FORMAT(D, format), ##__VA_ARGS__)
 #define isr_log_d(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(D, format), ##__VA_ARGS__)
+#define log_buf_d(b,l) do{ARDUHAL_LOG_COLOR_PRINT(D);log_print_buf(b,l);ARDUHAL_LOG_COLOR_PRINT_END;}while(0)
 #else
-#define log_d(format, ...) do {log_to_esp(TAG, ESP_LOG_DEBUG, format, ##__VA_ARGS__);}while(0)
+#define log_d(format, ...) do {ESP_LOG_LEVEL_LOCAL(ESP_LOG_DEBUG, TAG, format, ##__VA_ARGS__);}while(0)
 #define isr_log_d(format, ...) do {ets_printf(LOG_FORMAT(D, format), esp_log_timestamp(), TAG, ##__VA_ARGS__);}while(0)
+#define log_buf_d(b,l) do {ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_DEBUG);}while(0)
 #endif
 #else
 #define log_d(format, ...)
 #define isr_log_d(format, ...)
+#define log_buf_d(b,l)
 #endif
 
 #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO
 #ifndef USE_ESP_IDF_LOG
 #define log_i(format, ...) log_printf(ARDUHAL_LOG_FORMAT(I, format), ##__VA_ARGS__)
 #define isr_log_i(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(I, format), ##__VA_ARGS__)
+#define log_buf_i(b,l) do{ARDUHAL_LOG_COLOR_PRINT(I);log_print_buf(b,l);ARDUHAL_LOG_COLOR_PRINT_END;}while(0)
 #else
-#define log_i(format, ...) do {log_to_esp(TAG, ESP_LOG_INFO, format, ##__VA_ARGS__);}while(0)
+#define log_i(format, ...) do {ESP_LOG_LEVEL_LOCAL(ESP_LOG_INFO, TAG, format, ##__VA_ARGS__);}while(0)
 #define isr_log_i(format, ...) do {ets_printf(LOG_FORMAT(I, format), esp_log_timestamp(), TAG, ##__VA_ARGS__);}while(0)
+#define log_buf_i(b,l) do {ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_INFO);}while(0)
 #endif
 #else
 #define log_i(format, ...)
 #define isr_log_i(format, ...)
+#define log_buf_i(b,l)
 #endif
 
 #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_WARN
 #ifndef USE_ESP_IDF_LOG
 #define log_w(format, ...) log_printf(ARDUHAL_LOG_FORMAT(W, format), ##__VA_ARGS__)
 #define isr_log_w(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(W, format), ##__VA_ARGS__)
+#define log_buf_w(b,l) do{ARDUHAL_LOG_COLOR_PRINT(W);log_print_buf(b,l);ARDUHAL_LOG_COLOR_PRINT_END;}while(0)
 #else
-#define log_w(format, ...) do {log_to_esp(TAG, ESP_LOG_WARN, format, ##__VA_ARGS__);}while(0)
+#define log_w(format, ...) do {ESP_LOG_LEVEL_LOCAL(ESP_LOG_WARN, TAG, format, ##__VA_ARGS__);}while(0)
 #define isr_log_w(format, ...) do {ets_printf(LOG_FORMAT(W, format), esp_log_timestamp(), TAG, ##__VA_ARGS__);}while(0)
+#define log_buf_w(b,l) do {ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_WARN);}while(0)
 #endif
 #else
 #define log_w(format, ...)
 #define isr_log_w(format, ...)
+#define log_buf_w(b,l)
 #endif
 
 #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_ERROR
 #ifndef USE_ESP_IDF_LOG
 #define log_e(format, ...) log_printf(ARDUHAL_LOG_FORMAT(E, format), ##__VA_ARGS__)
 #define isr_log_e(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(E, format), ##__VA_ARGS__)
+#define log_buf_e(b,l) do{ARDUHAL_LOG_COLOR_PRINT(E);log_print_buf(b,l);ARDUHAL_LOG_COLOR_PRINT_END;}while(0)
 #else
 #define log_e(format, ...) do {log_to_esp(TAG, ESP_LOG_ERROR, format, ##__VA_ARGS__);}while(0)
 #define isr_log_e(format, ...) do {ets_printf(LOG_FORMAT(E, format), esp_log_timestamp(), TAG, ##__VA_ARGS__);}while(0)
+#define log_buf_e(b,l) do {ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_ERROR);}while(0)
 #endif
 #else
 #define log_e(format, ...)
 #define isr_log_e(format, ...)
+#define log_buf_e(b,l)
 #endif
 
 #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_NONE
 #ifndef USE_ESP_IDF_LOG
 #define log_n(format, ...) log_printf(ARDUHAL_LOG_FORMAT(E, format), ##__VA_ARGS__)
 #define isr_log_n(format, ...) ets_printf(ARDUHAL_LOG_FORMAT(E, format), ##__VA_ARGS__)
+#define log_buf_n(b,l) do{ARDUHAL_LOG_COLOR_PRINT(E);log_print_buf(b,l);ARDUHAL_LOG_COLOR_PRINT_END;}while(0)
 #else
-#define log_n(format, ...) do {log_to_esp(TAG, ESP_LOG_ERROR, format, ##__VA_ARGS__);}while(0)
+#define log_n(format, ...) do {ESP_LOG_LEVEL_LOCAL(ESP_LOG_ERROR, TAG, format, ##__VA_ARGS__);}while(0)
 #define isr_log_n(format, ...) do {ets_printf(LOG_FORMAT(E, format), esp_log_timestamp(), TAG, ##__VA_ARGS__);}while(0)
+#define log_buf_n(b,l) do {ESP_LOG_BUFFER_HEXDUMP(TAG, b, l, ESP_LOG_ERROR);}while(0)
 #endif
 #else
 #define log_n(format, ...)
 #define isr_log_n(format, ...)
+#define log_buf_n(b,l)
 #endif
 
 #include "esp_log.h"
@@ -167,7 +190,6 @@ int log_printf(const char *fmt, ...);
 #ifndef TAG
 #define TAG "ARDUINO"
 #endif
-void log_to_esp(char* tag, esp_log_level_t level, const char* format, ...);
 //#define log_n(format, ...) myLog(ESP_LOG_NONE, format, ##__VA_ARGS__)
 #else
 #ifdef CONFIG_ARDUHAL_ESP_LOG

cores/esp32/esp32-hal-time.c

@@ -44,6 +44,8 @@ static void setTimeZone(long offset, int daylight)
 /*
  * configTime
  * Source: https://github.com/esp8266/Arduino/blob/master/cores/esp8266/time.c
+ * Note: Bundled Arduino lwip supports only ONE ntp server, 2nd and 3rd options are silently ignored
+ *       see CONFIG_LWIP_DHCP_MAX_NTP_SERVERS define in ./tools/sdk/esp32/sdkconfig
  * */
 void configTime(long gmtOffset_sec, int daylightOffset_sec, const char* server1, const char* server2, const char* server3)
 {
@@ -63,6 +65,8 @@ void configTime(long gmtOffset_sec, int daylightOffset_sec, const char* server1,
 /*
  * configTzTime
  * sntp setup using TZ environment variable
+ * Note: Bundled Arduino lwip supports only ONE ntp server, 2nd and 3rd options are silently ignored
+ *       see CONFIG_LWIP_DHCP_MAX_NTP_SERVERS define in ./tools/sdk/esp32/sdkconfig
  * */
 void configTzTime(const char* tz, const char* server1, const char* server2, const char* server3)
 {

cores/esp32/esp32-hal-timer.c

@@ -47,7 +47,7 @@
 #define HWTIMER_LOCK()      portENTER_CRITICAL(timer->lock)
 #define HWTIMER_UNLOCK()    portEXIT_CRITICAL(timer->lock)
 
-typedef struct {
+typedef volatile struct {
     union {
         struct {
             uint32_t reserved0:   10;
@@ -119,8 +119,9 @@ void ARDUINO_ISR_ATTR __timerISR(void * arg){
     }
 }
 
-uint64_t timerRead(hw_timer_t *timer){
+uint64_t inline timerRead(hw_timer_t *timer){
     timer->dev->update = 1;
+    while (timer->dev->update) {};
     uint64_t h = timer->dev->cnt_high;
     uint64_t l = timer->dev->cnt_low;
     return (h << 32) | l;
@@ -272,6 +273,12 @@ void timerEnd(hw_timer_t *timer){
 }
 
 void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
+#if CONFIG_IDF_TARGET_ESP32
+    if(edge){
+        log_w("EDGE timer interrupt does not work properly on ESP32! Setting to LEVEL...");
+        edge = false;
+    }
+#endif
     static bool initialized = false;
     static intr_handle_t intr_handle = NULL;
     if(intr_handle){

cores/esp32/esp32-hal-tinyusb.c

@@ -72,20 +72,15 @@ static void configure_pins(usb_hal_context_t *usb)
 
 esp_err_t tinyusb_driver_install(const tinyusb_config_t *config)
 {
-    log_i("Driver installation...");
-
-    // Hal init
     usb_hal_context_t hal = {
         .use_external_phy = config->external_phy
     };
     usb_hal_init(&hal);
     configure_pins(&hal);
-
     if (!tusb_init()) {
         log_e("Can't initialize the TinyUSB stack.");
         return ESP_FAIL;
     }
-    log_i("Driver installed");
     return ESP_OK;
 }
 
@@ -106,6 +101,7 @@ static tusb_str_t WEBUSB_URL              = "";
 static tusb_str_t USB_DEVICE_PRODUCT      = "";
 static tusb_str_t USB_DEVICE_MANUFACTURER = "";
 static tusb_str_t USB_DEVICE_SERIAL       = "";
+static tusb_str_t USB_DEVICE_LANGUAGE     = "\x09\x04";//English (0x0409)
 
 static uint8_t USB_DEVICE_ATTRIBUTES     = 0;
 static uint16_t USB_DEVICE_POWER         = 0;
@@ -140,7 +136,7 @@ static tusb_desc_device_t tinyusb_device_descriptor = {
 static uint32_t tinyusb_string_descriptor_len = 4;
 static char * tinyusb_string_descriptor[MAX_STRING_DESCRIPTORS] = {
         // array of pointer to string descriptors
-        "\x09\x04",   // 0: is supported language is English (0x0409)
+        USB_DEVICE_LANGUAGE,    // 0: is supported language
         USB_DEVICE_MANUFACTURER,// 1: Manufacturer
         USB_DEVICE_PRODUCT,     // 2: Product
         USB_DEVICE_SERIAL,      // 3: Serials, should use chip ID
@@ -228,7 +224,7 @@ typedef struct TU_ATTR_PACKED {
 static tinyusb_desc_webusb_url_t tinyusb_url_descriptor = {
         .bLength         = 3,
         .bDescriptorType = 3, // WEBUSB URL type
-        .bScheme         = 1, // URL Scheme Prefix: 0: "http://", 1: "https://", 255: ""
+        .bScheme         = 255, // URL Scheme Prefix: 0: "http://", 1: "https://", 255: ""
         .url             = ""
 };
 
@@ -263,7 +259,7 @@ static tinyusb_endpoints_usage_t tinyusb_endpoints;
 /**
  * @brief Invoked when received GET CONFIGURATION DESCRIPTOR.
  */
-uint8_t const *tud_descriptor_configuration_cb(uint8_t index)
+__attribute__ ((weak)) uint8_t const *tud_descriptor_configuration_cb(uint8_t index)
 {
     //log_d("%u", index);
     return tinyusb_config_descriptor;
@@ -272,7 +268,7 @@ uint8_t const *tud_descriptor_configuration_cb(uint8_t index)
 /**
  * @brief Invoked when received GET DEVICE DESCRIPTOR.
  */
-uint8_t const *tud_descriptor_device_cb(void)
+__attribute__ ((weak)) uint8_t const *tud_descriptor_device_cb(void)
 {
     //log_d("");
     return (uint8_t const *)&tinyusb_device_descriptor;
@@ -281,7 +277,7 @@ uint8_t const *tud_descriptor_device_cb(void)
 /**
  * @brief Invoked when received GET STRING DESCRIPTOR request.
  */
-uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid)
+__attribute__ ((weak)) uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid)
 {
     //log_d("%u (0x%x)", index, langid);
     static uint16_t _desc_str[127];
@@ -317,42 +313,37 @@ uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid)
  */
 uint8_t const * tud_descriptor_bos_cb(void)
 {
-    //log_d("");
+    //log_v("");
     return tinyusb_bos_descriptor;
 }
 
-__attribute__ ((weak)) bool tinyusb_vendor_control_request_cb(uint8_t rhport, tusb_control_request_t const * request){ return false; }
-__attribute__ ((weak)) bool tinyusb_vendor_control_complete_cb(uint8_t rhport, tusb_control_request_t const * request){ return true; }
+__attribute__ ((weak)) bool tinyusb_vendor_control_request_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request){ return false; }
 
 /**
  * @brief Handle WebUSB and Vendor requests.
  */
-bool tud_vendor_control_request_cb(uint8_t rhport, tusb_control_request_t const * request)
+bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request)
 {
     if(WEBUSB_ENABLED && (request->bRequest == VENDOR_REQUEST_WEBUSB
             || (request->bRequest == VENDOR_REQUEST_MICROSOFT && request->wIndex == 7))){
-        if(request->bRequest == VENDOR_REQUEST_WEBUSB){
-            // match vendor request in BOS descriptor
-            // Get landing page url
-            tinyusb_url_descriptor.bLength = 3 + strlen(WEBUSB_URL);
-            snprintf(tinyusb_url_descriptor.url, 127, "%s", WEBUSB_URL);
-            return tud_control_xfer(rhport, request, (void*) &tinyusb_url_descriptor, tinyusb_url_descriptor.bLength);
+        // we only care for SETUP stage
+        if (stage == CONTROL_STAGE_SETUP) {
+            if(request->bRequest == VENDOR_REQUEST_WEBUSB){
+                // match vendor request in BOS descriptor
+                // Get landing page url
+                tinyusb_url_descriptor.bLength = 3 + strlen(WEBUSB_URL);
+                snprintf(tinyusb_url_descriptor.url, 127, "%s", WEBUSB_URL);
+                return tud_control_xfer(rhport, request, (void*) &tinyusb_url_descriptor, tinyusb_url_descriptor.bLength);
+            }
+            // Get Microsoft OS 2.0 compatible descriptor
+            uint16_t total_len;
+            memcpy(&total_len, tinyusb_ms_os_20_descriptor + 8, 2);
+            return tud_control_xfer(rhport, request, (void*) tinyusb_ms_os_20_descriptor, total_len);
         }
-        // Get Microsoft OS 2.0 compatible descriptor
-        uint16_t total_len;
-        memcpy(&total_len, tinyusb_ms_os_20_descriptor + 8, 2);
-        return tud_control_xfer(rhport, request, (void*) tinyusb_ms_os_20_descriptor, total_len);
+        return true;
     }
-    return tinyusb_vendor_control_request_cb(rhport, request);
-}
-
-bool tud_vendor_control_complete_cb(uint8_t rhport, tusb_control_request_t const * request)
-{
-    if(!WEBUSB_ENABLED || !(request->bRequest == VENDOR_REQUEST_WEBUSB
-            || (request->bRequest == VENDOR_REQUEST_MICROSOFT && request->wIndex == 7))){
-        return tinyusb_vendor_control_complete_cb(rhport, request);
-    }
-    return true;
+    log_v("rhport: %u, stage: %u, type: 0x%x, request: 0x%x", rhport, stage, request->bmRequestType_bit.type, request->bRequest);
+    return tinyusb_vendor_control_request_cb(rhport, stage, request);
 }
 
 /*
@@ -433,12 +424,6 @@ static bool tinyusb_load_enabled_interfaces(){
                 log_e("Descriptor Load Failed");
                 return false;
             } else {
-                if(i == USB_INTERFACE_CDC){
-                    if(!tinyusb_reserve_out_endpoint(3) ||!tinyusb_reserve_in_endpoint(4) || !tinyusb_reserve_in_endpoint(5)){
-                        log_e("CDC Reserve Endpoints Failed");
-                        return false;
-                    }
-                }
                 dst += len;
             }
         }
@@ -507,6 +492,16 @@ static void tinyusb_apply_device_config(tinyusb_device_config_t *config){
         snprintf(WEBUSB_URL, 126, "%s", config->webusb_url);
     }
 
+    // Windows 10 will not recognize the CDC device if WebUSB is enabled and USB Class is not 2 (CDC)
+    if(
+        (tinyusb_loaded_interfaces_mask & BIT(USB_INTERFACE_CDC)) 
+        && config->webusb_enabled 
+        && (config->usb_class != TUSB_CLASS_CDC)
+    ){
+        config->usb_class = TUSB_CLASS_CDC;
+        config->usb_protocol = 0x00;
+    }
+
     WEBUSB_ENABLED            = config->webusb_enabled;
     USB_DEVICE_ATTRIBUTES     = config->usb_attributes;
     USB_DEVICE_POWER          = config->usb_power_ma;
@@ -537,6 +532,9 @@ static void IRAM_ATTR usb_persist_shutdown_handler(void)
             REG_WRITE(RTC_CNTL_OPTION1_REG, RTC_CNTL_FORCE_DOWNLOAD_BOOT);
         } else if (usb_persist_mode == RESTART_BOOTLOADER_DFU) {
             //DFU Download
+            // Reset USB Core
+            USB0.grstctl |= USB_CSFTRST;
+            while ((USB0.grstctl & USB_CSFTRST) == USB_CSFTRST){}
             chip_usb_set_persist_flags(USBDC_BOOT_DFU);
             REG_WRITE(RTC_CNTL_OPTION1_REG, RTC_CNTL_FORCE_DOWNLOAD_BOOT);
         } else if (usb_persist_enabled) {
@@ -556,31 +554,43 @@ static void usb_device_task(void *param) {
 /*
  * PUBLIC API
  * */
+static const char *tinyusb_interface_names[USB_INTERFACE_MAX] = {"MSC", "DFU", "HID", "VENDOR", "CDC", "MIDI", "CUSTOM"};
+
+static bool tinyusb_is_initialized = false;
 
 esp_err_t tinyusb_enable_interface(tinyusb_interface_t interface, uint16_t descriptor_len, tinyusb_descriptor_cb_t cb)
 {
-    if((interface >= USB_INTERFACE_MAX) || (tinyusb_loaded_interfaces_mask & (1U << interface))){
-        log_e("Interface %u not enabled", interface);
+    if(tinyusb_is_initialized){
+        log_e("TinyUSB has already started! Interface %s not enabled", (interface >= USB_INTERFACE_MAX)?"":tinyusb_interface_names[interface]);
         return ESP_FAIL;
     }
+    if((interface >= USB_INTERFACE_MAX) || (tinyusb_loaded_interfaces_mask & (1U << interface))){
+        log_e("Interface %s invalid or already enabled", (interface >= USB_INTERFACE_MAX)?"":tinyusb_interface_names[interface]);
+        return ESP_FAIL;
+    }
+    if(interface == USB_INTERFACE_CDC){
+        if(!tinyusb_reserve_out_endpoint(3) ||!tinyusb_reserve_in_endpoint(4) || !tinyusb_reserve_in_endpoint(5)){
+            log_e("CDC Reserve Endpoints Failed");
+            return ESP_FAIL;
+        }
+    }
     tinyusb_loaded_interfaces_mask |= (1U << interface);
     tinyusb_config_descriptor_len += descriptor_len;
     tinyusb_loaded_interfaces_callbacks[interface] = cb;
-    log_d("Interface %u enabled", interface);
+    log_d("Interface %s enabled", tinyusb_interface_names[interface]);
     return ESP_OK;
 }
 
 esp_err_t tinyusb_init(tinyusb_device_config_t *config) {
-    static bool initialized = false;
-    if(initialized){
+    if(tinyusb_is_initialized){
         return ESP_OK;
     }
-    initialized = true;
+    tinyusb_is_initialized = true;
     
-    tinyusb_endpoints.val = 0;
+    //tinyusb_endpoints.val = 0;
     tinyusb_apply_device_config(config);
     if (!tinyusb_load_enabled_interfaces()) {
-        initialized = false;
+        tinyusb_is_initialized = false;
         return ESP_FAIL;
     }
 
@@ -598,7 +608,7 @@ esp_err_t tinyusb_init(tinyusb_device_config_t *config) {
     }
 
     if (esp_register_shutdown_handler(usb_persist_shutdown_handler) != ESP_OK) {
-        initialized = false;
+        tinyusb_is_initialized = false;
         return ESP_FAIL;
     }
 
@@ -607,7 +617,7 @@ esp_err_t tinyusb_init(tinyusb_device_config_t *config) {
     };
     esp_err_t err = tinyusb_driver_install(&tusb_cfg);
     if (err != ESP_OK) {
-        initialized = false;
+        tinyusb_is_initialized = false;
         return err;
     }
     xTaskCreate(usb_device_task, "usbd", 4096, NULL, configMAX_PRIORITIES - 1, NULL);
@@ -683,84 +693,4 @@ uint8_t tinyusb_get_free_out_endpoint(void){
     return 0;
 }
 
-/*
-void usb_dw_reg_dump(void)
-{
-#define USB_PRINT_REG(r) printf("USB0." #r " = 0x%x;\n", USB0.r)
-#define USB_PRINT_IREG(i, r) printf("USB0.in_ep_reg[%u]." #r " = 0x%x;\n", i, USB0.in_ep_reg[i].r)
-#define USB_PRINT_OREG(i, r) printf("USB0.out_ep_reg[%u]." #r " = 0x%x;\n", i, USB0.out_ep_reg[i].r)
-    uint8_t i;
-    USB_PRINT_REG(gotgctl);
-    USB_PRINT_REG(gotgint);
-    USB_PRINT_REG(gahbcfg);
-    USB_PRINT_REG(gusbcfg);
-    USB_PRINT_REG(grstctl);
-    USB_PRINT_REG(gintsts);
-    USB_PRINT_REG(gintmsk);
-    USB_PRINT_REG(grxstsr);
-    USB_PRINT_REG(grxstsp);
-    USB_PRINT_REG(grxfsiz);
-    USB_PRINT_REG(gnptxsts);
-    USB_PRINT_REG(gpvndctl);
-    USB_PRINT_REG(ggpio);
-    USB_PRINT_REG(guid);
-    USB_PRINT_REG(gsnpsid);
-    USB_PRINT_REG(ghwcfg1);
-    USB_PRINT_REG(ghwcfg2);
-    USB_PRINT_REG(ghwcfg3);
-    USB_PRINT_REG(ghwcfg4);
-    USB_PRINT_REG(glpmcfg);
-    USB_PRINT_REG(gpwrdn);
-    USB_PRINT_REG(gdfifocfg);
-    USB_PRINT_REG(gadpctl);
-    USB_PRINT_REG(hptxfsiz);
-    USB_PRINT_REG(hcfg);
-    USB_PRINT_REG(hfir);
-    USB_PRINT_REG(hfnum);
-    USB_PRINT_REG(hptxsts);
-    USB_PRINT_REG(haint);
-    USB_PRINT_REG(haintmsk);
-    USB_PRINT_REG(hflbaddr);
-    USB_PRINT_REG(hprt);
-    USB_PRINT_REG(dcfg);
-    USB_PRINT_REG(dctl);
-    USB_PRINT_REG(dsts);
-    USB_PRINT_REG(diepmsk);
-    USB_PRINT_REG(doepmsk);
-    USB_PRINT_REG(daint);
-    USB_PRINT_REG(daintmsk);
-    USB_PRINT_REG(dtknqr1);
-    USB_PRINT_REG(dtknqr2);
-    USB_PRINT_REG(dvbusdis);
-    USB_PRINT_REG(dvbuspulse);
-    USB_PRINT_REG(dtknqr3_dthrctl);
-    USB_PRINT_REG(dtknqr4_fifoemptymsk);
-    USB_PRINT_REG(deachint);
-    USB_PRINT_REG(deachintmsk);
-    USB_PRINT_REG(pcgctrl);
-    USB_PRINT_REG(pcgctrl1);
-    USB_PRINT_REG(gnptxfsiz);
-    for (i = 0; i < 4; i++) {
-        printf("USB0.dieptxf[%u] = 0x%x;\n", i, USB0.dieptxf[i]);
-    }
-//    for (i = 0; i < 16; i++) {
-//        printf("USB0.diepeachintmsk[%u] = 0x%x;\n", i, USB0.diepeachintmsk[i]);
-//    }
-//    for (i = 0; i < 16; i++) {
-//        printf("USB0.doepeachintmsk[%u] = 0x%x;\n", i, USB0.doepeachintmsk[i]);
-//    }
-    for (i = 0; i < 7; i++) {
-        printf("// EP %u:\n", i);
-        USB_PRINT_IREG(i, diepctl);
-        USB_PRINT_IREG(i, diepint);
-        USB_PRINT_IREG(i, dieptsiz);
-        USB_PRINT_IREG(i, diepdma);
-        USB_PRINT_IREG(i, dtxfsts);
-        USB_PRINT_OREG(i, doepctl);
-        USB_PRINT_OREG(i, doepint);
-        USB_PRINT_OREG(i, doeptsiz);
-        USB_PRINT_OREG(i, doepdma);
-    }
-}
- */
 #endif /* CONFIG_TINYUSB_ENABLED */

cores/esp32/esp32-hal-tinyusb.h

@@ -82,11 +82,11 @@ void usb_persist_restart(restart_type_t mode);
 
 // The following definitions and functions are to be used only by the drivers
 typedef enum {
-    USB_INTERFACE_CDC,
+    USB_INTERFACE_MSC,
     USB_INTERFACE_DFU,
     USB_INTERFACE_HID,
     USB_INTERFACE_VENDOR,
-    USB_INTERFACE_MSC,
+    USB_INTERFACE_CDC,
     USB_INTERFACE_MIDI,
     USB_INTERFACE_CUSTOM,
     USB_INTERFACE_MAX

cores/esp32/esp32-hal-touch.c

@@ -95,6 +95,7 @@ void __touchInit()
     SET_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL2_REG, SENS_TOUCH_MEAS_EN_CLR);
     //clear touch enable
     WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG, 0x0);
+    SET_PERI_REG_MASK(RTC_CNTL_STATE0_REG, RTC_CNTL_TOUCH_SLP_TIMER_EN);
     __touchSetCycles(__touchMeasureCycles, __touchSleepCycles);
     esp_intr_alloc(ETS_RTC_CORE_INTR_SOURCE, (int)ARDUINO_ISR_FLAG, __touchISR, NULL, &touch_intr_handle);
 #else

cores/esp32/esp32-hal-uart.c

@@ -14,205 +14,88 @@
 
 #include "esp32-hal-uart.h"
 #include "esp32-hal.h"
+
 #include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "freertos/queue.h"
 #include "freertos/semphr.h"
-#include "esp_attr.h"
-#include "soc/uart_reg.h"
-#include "soc/uart_struct.h"
-#include "soc/io_mux_reg.h"
-#include "soc/gpio_sig_map.h"
-#include "soc/rtc.h"
+
+#include "driver/uart.h"
 #include "hal/uart_ll.h"
-#include "esp_intr_alloc.h"
-
-#include "esp_system.h"
-#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "soc/dport_reg.h"
-#include "esp32/rom/ets_sys.h"
-#include "esp32/rom/uart.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/dport_reg.h"
-#include "esp32s2/rom/ets_sys.h"
-#include "esp32s2/rom/uart.h"
-#include "soc/periph_defs.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
-#include "esp32c3/rom/uart.h"
-#include "soc/periph_defs.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/ets_sys.h"
-#include "rom/uart.h"
-#include "esp_intr.h"
-#endif
-
-#if CONFIG_IDF_TARGET_ESP32
-#define UART_PORTS_NUM 3
-#define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:(    (u==2)?DR_REG_UART2_BASE:0)))
-#define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:(         (u==2)?U2RXD_IN_IDX:0)))
-#define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:(        (u==2)?U2TXD_OUT_IDX:0)))
-#define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:((u==2)?ETS_UART2_INTR_SOURCE:0)))
-#elif CONFIG_IDF_TARGET_ESP32S2
-#define UART_PORTS_NUM 2
-#define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:0))
-#define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:0))
-#define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:0))
-#define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:0))
-#else
-#define UART_PORTS_NUM 2
-#define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:0))
-#define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:0))
-#define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:0))
-#define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:0))
-#endif
+#include "soc/soc_caps.h"
+#include "soc/uart_struct.h"
 
 static int s_uart_debug_nr = 0;
 
 struct uart_struct_t {
-    uart_dev_t * dev;
+
 #if !CONFIG_DISABLE_HAL_LOCKS
     xSemaphoreHandle lock;
 #endif
+
     uint8_t num;
-    xQueueHandle queue;
-    intr_handle_t intr_handle;
+    bool has_peek;
+    uint8_t peek_byte;
+
 };
 
 #if CONFIG_DISABLE_HAL_LOCKS
+
 #define UART_MUTEX_LOCK()
 #define UART_MUTEX_UNLOCK()
 
 static uart_t _uart_bus_array[] = {
-    {&UART0, 0, NULL, NULL},
-    {&UART1, 1, NULL, NULL},
-#if CONFIG_IDF_TARGET_ESP32
-    {&UART2, 2, NULL, NULL}
+    {0, false, 0},
+#if SOC_UART_NUM > 1
+    {1, false, 0},
+#endif
+#if SOC_UART_NUM > 2
+    {2, false, 0},
 #endif
 };
+
 #else
+
 #define UART_MUTEX_LOCK()    do {} while (xSemaphoreTake(uart->lock, portMAX_DELAY) != pdPASS)
 #define UART_MUTEX_UNLOCK()  xSemaphoreGive(uart->lock)
 
 static uart_t _uart_bus_array[] = {
-    {&UART0, NULL, 0, NULL, NULL},
-    {&UART1, NULL, 1, NULL, NULL},
-#if CONFIG_IDF_TARGET_ESP32
-    {&UART2, NULL, 2, NULL, NULL}
+    {NULL, 0, false, 0},
+#if SOC_UART_NUM > 1
+    {NULL, 1, false, 0},
+#endif
+#if SOC_UART_NUM > 2
+    {NULL, 2, false, 0},
 #endif
 };
+
 #endif
 
-static void uart_on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb);
-
-static void ARDUINO_ISR_ATTR _uart_isr(void *arg)
-{
-    uint8_t i, c;
-    BaseType_t xHigherPriorityTaskWoken;
-    uart_t* uart;
-
-    for(i=0;i<UART_PORTS_NUM;i++){
-        uart = &_uart_bus_array[i];
-        if(uart->intr_handle == NULL){
-            continue;
-        }
-        uart->dev->int_clr.rxfifo_full = 1;
-        uart->dev->int_clr.frm_err = 1;
-        uart->dev->int_clr.rxfifo_tout = 1;
-#if CONFIG_IDF_TARGET_ESP32
-        while(uart->dev->status.rxfifo_cnt || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
-            c = uart->dev->fifo.rw_byte;
-#else
-        uint32_t fifo_reg = UART_FIFO_AHB_REG(i);
-        while(uart->dev->status.rxfifo_cnt) {
-        	c = ESP_REG(fifo_reg);
-#endif
-            if(uart->queue != NULL) {
-                xQueueSendFromISR(uart->queue, &c, &xHigherPriorityTaskWoken);
-            }
-        }
-    }
-
-    if (xHigherPriorityTaskWoken) {
-        portYIELD_FROM_ISR();
-    }
-}
-
-static void uartEnableInterrupt(uart_t* uart, uint8_t rxfifo_full_thrhd)
-{
-    UART_MUTEX_LOCK();
-    uart->dev->conf1.rxfifo_full_thrhd = rxfifo_full_thrhd;
-#if CONFIG_IDF_TARGET_ESP32
-    uart->dev->conf1.rx_tout_thrhd = 2;
-#else
-    uart->dev->mem_conf.rx_tout_thrhd = 2;
-#endif
-    uart->dev->conf1.rx_tout_en = 1;
-    uart->dev->int_ena.rxfifo_full = 1;
-    uart->dev->int_ena.frm_err = 1;
-    uart->dev->int_ena.rxfifo_tout = 1;
-    uart->dev->int_clr.val = 0xffffffff;
-
-    esp_intr_alloc(UART_INTR_SOURCE(uart->num), (int)ARDUINO_ISR_FLAG, _uart_isr, NULL, &uart->intr_handle);
-    UART_MUTEX_UNLOCK();
-}
-
-static void uartDisableInterrupt(uart_t* uart)
-{
-    UART_MUTEX_LOCK();
-    uart->dev->conf1.val = 0;
-    uart->dev->int_ena.val = 0;
-    uart->dev->int_clr.val = 0xffffffff;
-
-    esp_intr_free(uart->intr_handle);
-    uart->intr_handle = NULL;
-
-    UART_MUTEX_UNLOCK();
-}
-
-static void uartDetachRx(uart_t* uart, uint8_t rxPin)
+bool uartIsDriverInstalled(uart_t* uart) 
 {
     if(uart == NULL) {
-        return;
+        return 0;
     }
-    pinMatrixInDetach(rxPin, false, false);
-    uartDisableInterrupt(uart);
+
+    if (uart_is_driver_installed(uart->num)) {
+        return true;
+    }
+    return false;
 }
 
-static void uartDetachTx(uart_t* uart, uint8_t txPin)
+void uartSetPins(uart_t* uart, uint8_t rxPin, uint8_t txPin)
 {
-    if(uart == NULL) {
+    if(uart == NULL || rxPin >= SOC_GPIO_PIN_COUNT || txPin >= SOC_GPIO_PIN_COUNT) {
         return;
     }
-    pinMatrixOutDetach(txPin, false, false);
+    UART_MUTEX_LOCK();
+    ESP_ERROR_CHECK(uart_set_pin(uart->num, txPin, rxPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE)); 
+    UART_MUTEX_UNLOCK();
+    
 }
 
-static void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted, uint8_t rxfifo_full_thrhd)
-{
-    if(uart == NULL || rxPin >= GPIO_PIN_COUNT) {
-        return;
-    }
-    pinMode(rxPin, INPUT);
-    uartEnableInterrupt(uart, rxfifo_full_thrhd);
-    pinMatrixInAttach(rxPin, UART_RXD_IDX(uart->num), inverted);
-}
-
-static void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
-{
-    if(uart == NULL || txPin >= GPIO_PIN_COUNT) {
-        return;
-    }
-    pinMode(txPin, OUTPUT);
-    pinMatrixOutAttach(txPin, UART_TXD_IDX(uart->num), inverted, false);
-}
 
 uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted, uint8_t rxfifo_full_thrhd)
 {
-    if(uart_nr >= UART_PORTS_NUM) {
+    if(uart_nr >= SOC_UART_NUM) {
         return NULL;
     }
 
@@ -222,6 +105,10 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
 
     uart_t* uart = &_uart_bus_array[uart_nr];
 
+    if (uart_is_driver_installed(uart_nr)) {
+        uartEnd(uart);
+    }
+
 #if !CONFIG_DISABLE_HAL_LOCKS
     if(uart->lock == NULL) {
         uart->lock = xSemaphoreCreateMutex();
@@ -231,189 +118,143 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
     }
 #endif
 
-    if(queueLen && uart->queue == NULL) {
-        uart->queue = xQueueCreate(queueLen, sizeof(uint8_t)); //initialize the queue
-        if(uart->queue == NULL) {
-            return NULL;
-        }
-    }
-#if CONFIG_IDF_TARGET_ESP32C3
-
-#else
-    if(uart_nr == 1){
-        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART1_CLK_EN);
-        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART1_RST);
-#if CONFIG_IDF_TARGET_ESP32
-    } else if(uart_nr == 2){
-        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART2_CLK_EN);
-        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART2_RST);
-#endif
-    } else {
-        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART_CLK_EN);
-        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART_RST);
-    }
-#endif
-    uartFlush(uart);
-    uartSetBaudRate(uart, baudrate);
     UART_MUTEX_LOCK();
-    uart->dev->conf0.val = config;
-    #define TWO_STOP_BITS_CONF 0x3
-    #define ONE_STOP_BITS_CONF 0x1
 
-    if ( uart->dev->conf0.stop_bit_num == TWO_STOP_BITS_CONF) {
-        uart->dev->conf0.stop_bit_num = ONE_STOP_BITS_CONF;
-        uart->dev->rs485_conf.dl1_en = 1;
+    uart_config_t uart_config;
+    uart_config.baud_rate = baudrate;
+    uart_config.data_bits = (config & 0xc) >> 2;
+    uart_config.parity = (config & 0x3);
+    uart_config.stop_bits = (config & 0x30) >> 4;
+    uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
+    uart_config.rx_flow_ctrl_thresh = rxfifo_full_thrhd;
+    uart_config.source_clk = UART_SCLK_APB;
+
+
+    ESP_ERROR_CHECK(uart_driver_install(uart_nr, 2*queueLen, 0, 0, NULL, 0));
+    ESP_ERROR_CHECK(uart_param_config(uart_nr, &uart_config));
+    ESP_ERROR_CHECK(uart_set_pin(uart_nr, txPin, rxPin, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));
+
+    // Is it right or the idea is to swap rx and tx pins? 
+    if (inverted) {
+        // invert signal for both Rx and Tx
+        ESP_ERROR_CHECK(uart_set_line_inverse(uart_nr, UART_SIGNAL_TXD_INV | UART_SIGNAL_RXD_INV));    
     }
 
-    // tx_idle_num : idle interval after tx FIFO is empty(unit: the time it takes to send one bit under current baudrate)
-    // Setting it to 0 prevents line idle time/delays when sending messages with small intervals
-    uart->dev->idle_conf.tx_idle_num = 0;  //
-
     UART_MUTEX_UNLOCK();
 
-    if(rxPin != -1) {
-        uartAttachRx(uart, rxPin, inverted, rxfifo_full_thrhd);
-    }
-
-    if(txPin != -1) {
-        uartAttachTx(uart, txPin, inverted);
-    }
-    addApbChangeCallback(uart, uart_on_apb_change);
+    uartFlush(uart);
     return uart;
 }
 
-void uartEnd(uart_t* uart, uint8_t txPin, uint8_t rxPin)
+void uartEnd(uart_t* uart)
 {
     if(uart == NULL) {
         return;
     }
-    removeApbChangeCallback(uart, uart_on_apb_change);
-
+   
     UART_MUTEX_LOCK();
-    if(uart->queue != NULL) {
-        vQueueDelete(uart->queue);
-        uart->queue = NULL;
-    }
-
-    uart->dev->conf0.val = 0;
-
+    uart_driver_delete(uart->num);
     UART_MUTEX_UNLOCK();
-
-    uartDetachRx(uart, rxPin);
-    uartDetachTx(uart, txPin);
 }
 
-size_t uartResizeRxBuffer(uart_t * uart, size_t new_size) {
-    if(uart == NULL) {
-        return 0;
-    }
-
-    UART_MUTEX_LOCK();
-    if(uart->queue != NULL) {
-        vQueueDelete(uart->queue);
-        uart->queue = xQueueCreate(new_size, sizeof(uint8_t));
-        if(uart->queue == NULL) {
-            UART_MUTEX_UNLOCK();
-            return 0;
-        }
-    }
-    UART_MUTEX_UNLOCK();
-
-    return new_size;
-}
 
 void uartSetRxInvert(uart_t* uart, bool invert)
 {
     if (uart == NULL)
         return;
-    
+#if 0
+    // POTENTIAL ISSUE :: original code only set/reset rxd_inv bit 
+    // IDF or LL set/reset the whole inv_mask!
     if (invert)
-        uart->dev->conf0.rxd_inv = 1;
+        ESP_ERROR_CHECK(uart_set_line_inverse(uart->num, UART_SIGNAL_RXD_INV));
     else
-        uart->dev->conf0.rxd_inv = 0;
+        ESP_ERROR_CHECK(uart_set_line_inverse(uart->num, UART_SIGNAL_INV_DISABLE));
+    
+#else
+    // this implementation is better over IDF API because it only affects RXD
+    // this is supported in ESP32, ESP32-S2 and ESP32-C3
+    uart_dev_t *hw = UART_LL_GET_HW(uart->num);
+    if (invert)
+        hw->conf0.rxd_inv = 1;
+    else
+        hw->conf0.rxd_inv = 0;
+#endif 
 }
 
+
 uint32_t uartAvailable(uart_t* uart)
 {
-    if(uart == NULL || uart->queue == NULL) {
+
+    if(uart == NULL) {
         return 0;
     }
-#ifdef UART_READ_RX_FIFO
-    return (uxQueueMessagesWaiting(uart->queue) + uart->dev->status.rxfifo_cnt) ;
-#else
-    return uxQueueMessagesWaiting(uart->queue);
-#endif
+
+    UART_MUTEX_LOCK();
+    size_t available;
+    uart_get_buffered_data_len(uart->num, &available);
+    if (uart->has_peek) available++;
+    UART_MUTEX_UNLOCK();
+    return available;
 }
 
+
 uint32_t uartAvailableForWrite(uart_t* uart)
 {
     if(uart == NULL) {
         return 0;
     }
-    return 0x7f - uart->dev->status.txfifo_cnt;
+    UART_MUTEX_LOCK();
+    uint32_t available =  uart_ll_get_txfifo_len(UART_LL_GET_HW(uart->num));  
+    UART_MUTEX_UNLOCK();
+    return available;
 }
 
-#ifdef UART_READ_RX_FIFO
-void uartRxFifoToQueue(uart_t* uart)
-{
-	uint8_t c;
-    UART_MUTEX_LOCK();
-	//disable interrupts
-	uart->dev->int_ena.val = 0;
-	uart->dev->int_clr.val = 0xffffffff;
-#if CONFIG_IDF_TARGET_ESP32
-	while (uart->dev->status.rxfifo_cnt || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
-		c = uart->dev->fifo.rw_byte;
-#else
-	uint32_t fifo_reg = UART_FIFO_AHB_REG(uart->num);
-	while (uart->dev->status.rxfifo_cnt) {
-		c = ESP_REG(fifo_reg);
-#endif
-		xQueueSend(uart->queue, &c, 0);
-	}
-	//enable interrupts
-	uart->dev->int_ena.rxfifo_full = 1;
-	uart->dev->int_ena.frm_err = 1;
-	uart->dev->int_ena.rxfifo_tout = 1;
-	uart->dev->int_clr.val = 0xffffffff;
-    UART_MUTEX_UNLOCK();
-}
-#endif
 
 uint8_t uartRead(uart_t* uart)
 {
-    if(uart == NULL || uart->queue == NULL) {
+    if(uart == NULL) {
         return 0;
     }
-    uint8_t c;
-#ifdef UART_READ_RX_FIFO
-    if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
-    {
-    	uartRxFifoToQueue(uart);
+    uint8_t c = 0;
+
+    UART_MUTEX_LOCK();
+
+    if (uart->has_peek) {
+      uart->has_peek = false;
+      c = uart->peek_byte;
+    } else {
+
+        int len = uart_read_bytes(uart->num, &c, 1, 20 / portTICK_RATE_MS);
+        if (len == 0) {
+            c  = 0;
+        }
     }
-#endif
-    if(xQueueReceive(uart->queue, &c, 0)) {
-        return c;
-    }
-    return 0;
+    UART_MUTEX_UNLOCK();
+    return c;
 }
 
 uint8_t uartPeek(uart_t* uart)
 {
-    if(uart == NULL || uart->queue == NULL) {
+    if(uart == NULL) {
         return 0;
     }
-    uint8_t c;
-#ifdef UART_READ_RX_FIFO
-    if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
-    {
-    	uartRxFifoToQueue(uart);
+    uint8_t c = 0;
+
+    UART_MUTEX_LOCK();
+
+    if (uart->has_peek) {
+      c = uart->peek_byte;
+    } else {
+        int len = uart_read_bytes(uart->num, &c, 1, 20 / portTICK_RATE_MS);
+        if (len == 0) {
+            c  = 0;
+        } else {
+            uart->has_peek = true;
+            uart->peek_byte = c;
+        }
     }
-#endif
-    if(xQueuePeek(uart->queue, &c, 0)) {
-        return c;
-    }
-    return 0;
+    UART_MUTEX_UNLOCK();
+    return c;
 }
 
 void uartWrite(uart_t* uart, uint8_t c)
@@ -422,12 +263,7 @@ void uartWrite(uart_t* uart, uint8_t c)
         return;
     }
     UART_MUTEX_LOCK();
-    while(uart->dev->status.txfifo_cnt == 0x7F);
-#if CONFIG_IDF_TARGET_ESP32
-    uart->dev->fifo.rw_byte = c;
-#else
-    ESP_REG(UART_FIFO_AHB_REG(uart->num)) = c;
-#endif
+    uart_write_bytes(uart->num, &c, 1);
     UART_MUTEX_UNLOCK();
 }
 
@@ -436,25 +272,15 @@ void uartWriteBuf(uart_t* uart, const uint8_t * data, size_t len)
     if(uart == NULL) {
         return;
     }
+
     UART_MUTEX_LOCK();
-#ifndef CONFIG_IDF_TARGET_ESP32
-    uint32_t fifo_reg = UART_FIFO_AHB_REG(uart->num);
-#endif
-    while(len) {
-        while(uart->dev->status.txfifo_cnt == 0x7F);
-#if CONFIG_IDF_TARGET_ESP32
-        uart->dev->fifo.rw_byte = *data++;
-#else
-        ESP_REG(fifo_reg) = *data++;
-#endif
-        len--;
-    }
+    uart_write_bytes(uart->num, data, len);
     UART_MUTEX_UNLOCK();
 }
 
 void uartFlush(uart_t* uart)
 {
-    uartFlushTxOnly(uart,true);
+    uartFlushTxOnly(uart, true);
 }
 
 void uartFlushTxOnly(uart_t* uart, bool txOnly)
@@ -462,28 +288,13 @@ void uartFlushTxOnly(uart_t* uart, bool txOnly)
     if(uart == NULL) {
         return;
     }
-
+    
     UART_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32
-    while(uart->dev->status.txfifo_cnt || uart->dev->status.st_utx_out);
-    
-    if( !txOnly ){
-        //Due to hardware issue, we can not use fifo_rst to reset uart fifo.
-        //See description about UART_TXFIFO_RST and UART_RXFIFO_RST in <<esp32_technical_reference_manual>> v2.6 or later.
+    ESP_ERROR_CHECK(uart_wait_tx_done(uart->num, portMAX_DELAY));
 
-        // we read the data out and make `fifo_len == 0 && rd_addr == wr_addr`.
-        while(uart->dev->status.rxfifo_cnt != 0 || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
-            READ_PERI_REG(UART_FIFO_REG(uart->num));
-        }
-
-        xQueueReset(uart->queue);
+    if ( !txOnly ) {
+        ESP_ERROR_CHECK(uart_flush_input(uart->num));
     }
-#else
-    while(uart->dev->status.txfifo_cnt);
-    uart->dev->conf0.txfifo_rst = 1;
-    uart->dev->conf0.txfifo_rst = 0;
-#endif
-    
     UART_MUTEX_UNLOCK();
 }
 
@@ -493,100 +304,41 @@ void uartSetBaudRate(uart_t* uart, uint32_t baud_rate)
         return;
     }
     UART_MUTEX_LOCK();
-    uart_ll_set_baudrate(uart->dev, baud_rate);
+    uart_ll_set_baudrate(UART_LL_GET_HW(uart->num), baud_rate);
     UART_MUTEX_UNLOCK();
 }
 
-static void uart_on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb)
-{
-    uart_t* uart = (uart_t*)arg;
-    if(ev_type == APB_BEFORE_CHANGE){
-        UART_MUTEX_LOCK();
-        //disabple interrupt
-        uart->dev->int_ena.val = 0;
-        uart->dev->int_clr.val = 0xffffffff;
-        // read RX fifo
-        uint8_t c;
-   //     BaseType_t xHigherPriorityTaskWoken;
-#if CONFIG_IDF_TARGET_ESP32
-        while(uart->dev->status.rxfifo_cnt != 0 || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
-            c = uart->dev->fifo.rw_byte;
-#else
-        uint32_t fifo_reg = UART_FIFO_AHB_REG(uart->num);
-        while(uart->dev->status.rxfifo_cnt != 0) {
-            c = ESP_REG(fifo_reg);
-#endif
-            if(uart->queue != NULL ) {
-                xQueueSend(uart->queue, &c, 1); //&xHigherPriorityTaskWoken);
-            }
-        }
-        UART_MUTEX_UNLOCK();
- 
-        // wait TX empty
-#if CONFIG_IDF_TARGET_ESP32
-        while(uart->dev->status.txfifo_cnt || uart->dev->status.st_utx_out);
-#else
-        while(uart->dev->status.txfifo_cnt);
-#endif
-    } else {
-        //todo:
-        // set baudrate
-        UART_MUTEX_LOCK();
-        uint32_t clk_div = (uart->dev->clk_div.div_int << 4) | (uart->dev->clk_div.div_frag & 0x0F);
-        uint32_t baud_rate = ((old_apb<<4)/clk_div);
-        clk_div = ((new_apb<<4)/baud_rate);
-        uart->dev->clk_div.div_int = clk_div>>4 ;
-        uart->dev->clk_div.div_frag = clk_div & 0xf;
-        //enable interrupts
-        uart->dev->int_ena.rxfifo_full = 1;
-        uart->dev->int_ena.frm_err = 1;
-        uart->dev->int_ena.rxfifo_tout = 1;
-        uart->dev->int_clr.val = 0xffffffff;
-        UART_MUTEX_UNLOCK();
-    }
-}
-
 uint32_t uartGetBaudRate(uart_t* uart)
 {
     if(uart == NULL) {
         return 0;
     }
 
-    uint32_t clk_div = (uart->dev->clk_div.div_int << 4) | (uart->dev->clk_div.div_frag & 0x0F);
-    if(!clk_div) {
-        return 0;
-    }
-
-    return ((getApbFrequency()<<4)/clk_div);
+    UART_MUTEX_LOCK();
+    uint32_t baud_rate = uart_ll_get_baudrate(UART_LL_GET_HW(uart->num));
+    UART_MUTEX_UNLOCK();
+    return baud_rate;
 }
 
 static void ARDUINO_ISR_ATTR uart0_write_char(char c)
 {
-#if CONFIG_IDF_TARGET_ESP32
-    while(((ESP_REG(0x01C+DR_REG_UART_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
-    ESP_REG(DR_REG_UART_BASE) = c;
-#else
-    while(UART0.status.txfifo_cnt == 0x7F);
-    WRITE_PERI_REG(UART_FIFO_AHB_REG(0), c);
-#endif
+    while (uart_ll_get_txfifo_len(&UART0) == 0);
+    uart_ll_write_txfifo(&UART0, (const uint8_t *) &c, 1);
 }
 
+#if SOC_UART_NUM > 1
 static void ARDUINO_ISR_ATTR uart1_write_char(char c)
 {
-#if CONFIG_IDF_TARGET_ESP32
-    while(((ESP_REG(0x01C+DR_REG_UART1_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
-    ESP_REG(DR_REG_UART1_BASE) = c;
-#else
-    while(UART1.status.txfifo_cnt == 0x7F);
-    WRITE_PERI_REG(UART_FIFO_AHB_REG(1), c);
-#endif
+    while (uart_ll_get_txfifo_len(&UART1) == 0);
+    uart_ll_write_txfifo(&UART1, (const uint8_t *) &c, 1);
 }
+#endif
 
-#if CONFIG_IDF_TARGET_ESP32
+#if SOC_UART_NUM > 2
 static void ARDUINO_ISR_ATTR uart2_write_char(char c)
 {
-    while(((ESP_REG(0x01C+DR_REG_UART2_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
-    ESP_REG(DR_REG_UART2_BASE) = c;
+    while (uart_ll_get_txfifo_len(&UART2) == 0);
+    uart_ll_write_txfifo(&UART2, (const uint8_t *) &c, 1);
 }
 #endif
 
@@ -596,10 +348,12 @@ void uart_install_putc()
     case 0:
         ets_install_putc1((void (*)(char)) &uart0_write_char);
         break;
+#if SOC_UART_NUM > 1
     case 1:
         ets_install_putc1((void (*)(char)) &uart1_write_char);
         break;
-#if CONFIG_IDF_TARGET_ESP32
+#endif
+#if SOC_UART_NUM > 2
     case 2:
         ets_install_putc1((void (*)(char)) &uart2_write_char);
         break;
@@ -612,7 +366,7 @@ void uart_install_putc()
 
 void uartSetDebug(uart_t* uart)
 {
-    if(uart == NULL || uart->num >= UART_PORTS_NUM) {
+    if(uart == NULL || uart->num >= SOC_UART_NUM) {
         s_uart_debug_nr = -1;
         //ets_install_putc1(NULL);
         //return;
@@ -646,17 +400,19 @@ int log_printf(const char *format, ...)
             return 0;
         }
     }
-    vsnprintf(temp, len+1, format, arg);
 #if !CONFIG_DISABLE_HAL_LOCKS
     if(s_uart_debug_nr != -1 && _uart_bus_array[s_uart_debug_nr].lock){
         xSemaphoreTake(_uart_bus_array[s_uart_debug_nr].lock, portMAX_DELAY);
-        ets_printf("%s", temp);
-        xSemaphoreGive(_uart_bus_array[s_uart_debug_nr].lock);
-    } else {
-        ets_printf("%s", temp);
     }
-#else
+#endif
+    
+    vsnprintf(temp, len+1, format, arg);
     ets_printf("%s", temp);
+
+#if !CONFIG_DISABLE_HAL_LOCKS
+    if(s_uart_debug_nr != -1 && _uart_bus_array[s_uart_debug_nr].lock){
+        xSemaphoreGive(_uart_bus_array[s_uart_debug_nr].lock);
+    }
 #endif
     va_end(arg);
     if(len >= sizeof(loc_buf)){
@@ -665,48 +421,126 @@ int log_printf(const char *format, ...)
     return len;
 }
 
+
+static void log_print_buf_line(const uint8_t *b, size_t len, size_t total_len){
+    for(size_t i = 0; i<len; i++){
+        log_printf("%s0x%02x,",i?" ":"", b[i]);
+    }
+    if(total_len > 16){
+        for(size_t i = len; i<16; i++){
+            log_printf("      ");
+        }
+        log_printf("    // ");
+    } else {
+        log_printf(" // ");
+    }
+    for(size_t i = 0; i<len; i++){
+        log_printf("%c",((b[i] >= 0x20) && (b[i] < 0x80))?b[i]:'.');
+    }
+    log_printf("\n");
+}
+
+void log_print_buf(const uint8_t *b, size_t len){
+    if(!len || !b){
+        return;
+    }
+    for(size_t i = 0; i<len; i+=16){
+        if(len > 16){
+            log_printf("/* 0x%04X */ ", i);
+        }
+        log_print_buf_line(b+i, ((len-i)<16)?(len - i):16, len);
+    }
+}
+
 /*
  * if enough pulses are detected return the minimum high pulse duration + minimum low pulse duration divided by two. 
  * This equals one bit period. If flag is true the function return inmediately, otherwise it waits for enough pulses.
  */
 unsigned long uartBaudrateDetect(uart_t *uart, bool flg)
 {
-    while(uart->dev->rxd_cnt.edge_cnt < 30) { // UART_PULSE_NUM(uart_num)
+    if(uart == NULL) {
+        return 0;
+    }
+
+    uart_dev_t *hw = UART_LL_GET_HW(uart->num);
+
+    while(hw->rxd_cnt.edge_cnt < 30) { // UART_PULSE_NUM(uart_num)
         if(flg) return 0;
         ets_delay_us(1000);
     }
 
     UART_MUTEX_LOCK();
-    unsigned long ret = ((uart->dev->lowpulse.min_cnt + uart->dev->highpulse.min_cnt) >> 1) + 12;
+    //log_i("lowpulse_min_cnt = %d hightpulse_min_cnt = %d", hw->lowpulse.min_cnt, hw->highpulse.min_cnt);
+    unsigned long ret = ((hw->lowpulse.min_cnt + hw->highpulse.min_cnt) >> 1);
     UART_MUTEX_UNLOCK();
 
     return ret;
 }
 
+
 /*
  * To start detection of baud rate with the uart the auto_baud.en bit needs to be cleared and set. The bit period is 
  * detected calling uartBadrateDetect(). The raw baudrate is computed using the UART_CLK_FREQ. The raw baudrate is 
  * rounded to the closed real baudrate.
+ * 
+ * ESP32-C3 reports wrong baud rate detection as shown below:
+ * 
+ * This will help in a future recall for the C3.
+ * Baud Sent:          Baud Read:
+ *  300        -->       19536
+ * 2400        -->       19536
+ * 4800        -->       19536 
+ * 9600        -->       28818 
+ * 19200       -->       57678
+ * 38400       -->       115440
+ * 57600       -->       173535
+ * 115200      -->       347826
+ * 230400      -->       701754
+ * 
+ * 
 */
 void uartStartDetectBaudrate(uart_t *uart) {
-  if(!uart) return;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
-  uart->dev->auto_baud.glitch_filt = 0x08;
-  uart->dev->auto_baud.en = 0;
-  uart->dev->auto_baud.en = 1;
+    if(uart == NULL) {
+        return;
+    }
+
+    uart_dev_t *hw = UART_LL_GET_HW(uart->num);
+
+#ifdef CONFIG_IDF_TARGET_ESP32C3
+    
+    // ESP32-C3 requires further testing
+    // Baud rate detection returns wrong values 
+   
+    log_e("ESP32-C3 baud rate detection is not supported.");
+    return;
+
+    // Code bellow for C3 kept for future recall
+    //hw->rx_filt.glitch_filt = 0x08;
+    //hw->rx_filt.glitch_filt_en = 1;
+    //hw->conf0.autobaud_en = 0;
+    //hw->conf0.autobaud_en = 1;
+
+#else
+    hw->auto_baud.glitch_filt = 0x08;
+    hw->auto_baud.en = 0;
+    hw->auto_baud.en = 1;
 #endif
 }
-
+ 
 unsigned long
 uartDetectBaudrate(uart_t *uart)
 {
-#ifndef CONFIG_IDF_TARGET_ESP32C3
+    if(uart == NULL) {
+        return 0;
+    }
+
+#ifndef CONFIG_IDF_TARGET_ESP32C3    // ESP32-C3 requires further testing - Baud rate detection returns wrong values 
+
     static bool uartStateDetectingBaudrate = false;
+    uart_dev_t *hw = UART_LL_GET_HW(uart->num);
 
     if(!uartStateDetectingBaudrate) {
-        uart->dev->auto_baud.glitch_filt = 0x08;
-        uart->dev->auto_baud.en = 0;
-        uart->dev->auto_baud.en = 1;
+        uartStartDetectBaudrate(uart);
         uartStateDetectingBaudrate = true;
     }
 
@@ -714,11 +548,21 @@ uartDetectBaudrate(uart_t *uart)
     if (!divisor) {
         return 0;
     }
+    //  log_i(...) below has been used to check C3 baud rate detection results
+    //log_i("Divisor = %d\n", divisor);
+    //log_i("BAUD RATE based on Positive Pulse %d\n", getApbFrequency()/((hw->pospulse.min_cnt + 1)/2));
+    //log_i("BAUD RATE based on Negative Pulse %d\n", getApbFrequency()/((hw->negpulse.min_cnt + 1)/2));
 
-    uart->dev->auto_baud.en = 0;
+
+#ifdef CONFIG_IDF_TARGET_ESP32C3
+    //hw->conf0.autobaud_en = 0;
+#else
+    hw->auto_baud.en = 0;
+#endif
     uartStateDetectingBaudrate = false; // Initialize for the next round
 
     unsigned long baudrate = getApbFrequency() / divisor;
+    //log_i("APB_FREQ = %d\nraw baudrate detected = %d", getApbFrequency(), baudrate);
 
     static const unsigned long default_rates[] = {300, 600, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 74880, 115200, 230400, 256000, 460800, 921600, 1843200, 3686400};
 
@@ -736,17 +580,7 @@ uartDetectBaudrate(uart_t *uart)
 
     return default_rates[i];
 #else
-    return 0;
-#endif
-}
-
-/*
- * Returns the status of the RX state machine, if the value is non-zero the state machine is active.
- */
-bool uartRxActive(uart_t* uart) {
-#if CONFIG_IDF_TARGET_ESP32
-    return uart->dev->status.st_urx_out != 0;
-#else
+    log_e("ESP32-C3 baud rate detection is not supported.");
     return 0;
 #endif
 }

cores/esp32/esp32-hal-uart.h

@@ -52,7 +52,7 @@ struct uart_struct_t;
 typedef struct uart_struct_t uart_t;
 
 uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted, uint8_t rxfifo_full_thrhd);
-void uartEnd(uart_t* uart, uint8_t rxPin, uint8_t txPin);
+void uartEnd(uart_t* uart);
 
 uint32_t uartAvailable(uart_t* uart);
 uint32_t uartAvailableForWrite(uart_t* uart);
@@ -68,17 +68,17 @@ void uartFlushTxOnly(uart_t* uart, bool txOnly );
 void uartSetBaudRate(uart_t* uart, uint32_t baud_rate);
 uint32_t uartGetBaudRate(uart_t* uart);
 
-size_t uartResizeRxBuffer(uart_t* uart, size_t new_size);
-
 void uartSetRxInvert(uart_t* uart, bool invert);
 
 void uartSetDebug(uart_t* uart);
 int uartGetDebug();
 
+bool uartIsDriverInstalled(uart_t* uart);
+void uartSetPins(uart_t* uart, uint8_t rxPin, uint8_t txPin);
+
 void uartStartDetectBaudrate(uart_t *uart);
 unsigned long uartDetectBaudrate(uart_t *uart);
 
-bool uartRxActive(uart_t* uart);
 
 #ifdef __cplusplus
 }

cores/esp32/firmware_msc_fat.c

@@ -0,0 +1,204 @@
+// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "firmware_msc_fat.h"
+//copy up to max_len chars from src to dst and do not terminate
+static size_t cplstr(void *dst, const void * src, size_t max_len){
+    if(!src || !dst || !max_len){
+        return 0;
+    }
+    size_t l = strlen((const char *)src);
+    if(l > max_len){
+        l = max_len;
+    }
+    memcpy(dst, src, l);
+    return l;
+}
+
+//copy up to max_len chars from src to dst, adding spaces up to max_len. do not terminate
+static void cplstrsp(void *dst, const void * src, size_t max_len){
+    size_t l = cplstr(dst, src, max_len);
+    for(; l < max_len; l++){
+      ((uint8_t*)dst)[l] = 0x20;
+    }
+}
+
+// FAT12
+static const char * FAT12_FILE_SYSTEM_TYPE = "FAT12";
+
+static uint16_t fat12_sectors_per_alloc_table(uint32_t sector_num){
+  uint32_t required_bytes = (((sector_num * 3)+1)/2);
+  return (required_bytes / DISK_SECTOR_SIZE) + ((required_bytes & DISK_SECTOR_SIZE)?1:0);
+}
+
+static uint8_t * fat12_add_table(uint8_t * dst, fat_boot_sector_t * boot){
+  memset(dst+DISK_SECTOR_SIZE, 0, boot->sectors_per_alloc_table * DISK_SECTOR_SIZE);
+  uint8_t * d = dst + DISK_SECTOR_SIZE;
+  d[0] = 0xF8;
+  d[1] = 0xFF;
+  d[2] = 0xFF;
+  return d;
+}
+
+static void fat12_set_table_index(uint8_t * table, uint16_t index, uint16_t value){
+  uint16_t offset = (index >> 1) * 3;
+  uint8_t * data = table + offset;
+  if(index & 1){
+    data[2] = (value >> 4) & 0xFF;
+    data[1] = (data[1] & 0xF) | ((value & 0xF) << 4);
+  } else {
+    data[0] = value & 0xFF;
+    data[1] = (data[1] & 0xF0) | ((value >> 8) & 0xF);
+  }
+}
+
+//FAT16
+static const char * FAT16_FILE_SYSTEM_TYPE = "FAT16";
+
+static uint16_t fat16_sectors_per_alloc_table(uint32_t sector_num){
+  uint32_t required_bytes = sector_num * 2;
+  return (required_bytes / DISK_SECTOR_SIZE) + ((required_bytes & DISK_SECTOR_SIZE)?1:0);
+}
+
+static uint8_t * fat16_add_table(uint8_t * dst, fat_boot_sector_t * boot){
+  memset(dst+DISK_SECTOR_SIZE, 0, boot->sectors_per_alloc_table * DISK_SECTOR_SIZE);
+  uint16_t * d = (uint16_t *)(dst + DISK_SECTOR_SIZE);
+  d[0] = 0xFFF8;
+  d[1] = 0xFFFF;
+  return (uint8_t *)d;
+}
+
+static void fat16_set_table_index(uint8_t * table, uint16_t index, uint16_t value){
+  uint16_t offset = index * 2;
+  *(uint16_t *)(table + offset) = value;
+}
+
+//Interface
+const char * fat_file_system_type(bool fat16) {
+	return ((fat16)?FAT16_FILE_SYSTEM_TYPE:FAT12_FILE_SYSTEM_TYPE);
+}
+
+uint16_t fat_sectors_per_alloc_table(uint32_t sector_num, bool fat16){
+  if(fat16){
+    return fat16_sectors_per_alloc_table(sector_num);
+  }
+  return fat12_sectors_per_alloc_table(sector_num);
+}
+
+uint8_t * fat_add_table(uint8_t * dst, fat_boot_sector_t * boot, bool fat16){
+  if(fat16){
+    return fat16_add_table(dst, boot);
+  }
+  return fat12_add_table(dst, boot);
+}
+
+void fat_set_table_index(uint8_t * table, uint16_t index, uint16_t value, bool fat16){
+  if(fat16){
+    fat16_set_table_index(table, index, value);
+  } else {
+    fat12_set_table_index(table, index, value);
+  }
+}
+
+fat_boot_sector_t * fat_add_boot_sector(uint8_t * dst, uint16_t sector_num, uint16_t table_sectors, const char * file_system_type, const char * volume_label, uint32_t serial_number){
+  fat_boot_sector_t *boot = (fat_boot_sector_t*)dst;
+  boot->jump_instruction[0] = 0xEB;
+  boot->jump_instruction[1] = 0x3C;
+  boot->jump_instruction[2] = 0x90;
+  cplstr(boot->oem_name, "MSDOS5.0", 8);
+  boot->bytes_per_sector = DISK_SECTOR_SIZE;
+  boot->sectors_per_cluster = 1;
+  boot->reserved_sectors_count = 1;
+  boot->file_alloc_tables_num = 1;
+  boot->max_root_dir_entries = 16;
+  boot->fat12_sector_num = sector_num;
+  boot->media_descriptor = 0xF8;
+  boot->sectors_per_alloc_table = table_sectors;
+  boot->sectors_per_track = 1;
+  boot->num_heads = 1;
+  boot->hidden_sectors_count = 0;
+  boot->total_sectors_32 = 0;
+  boot->physical_drive_number = 0x00;
+  boot->reserved0 = 0x00;
+  boot->extended_boot_signature = 0x29;
+  boot->serial_number = serial_number;
+  cplstrsp(boot->volume_label, volume_label, 11);
+  memset(boot->reserved, 0, 448);
+  cplstrsp(boot->file_system_type, file_system_type, 8);
+  boot->signature = 0xAA55;
+  return boot;
+}
+
+fat_dir_entry_t * fat_add_label(uint8_t * dst, const char * volume_label){
+  fat_boot_sector_t * boot = (fat_boot_sector_t *)dst;
+  fat_dir_entry_t * entry = (fat_dir_entry_t *)(dst + ((boot->sectors_per_alloc_table+1) * DISK_SECTOR_SIZE));
+  memset(entry, 0, sizeof(fat_dir_entry_t));
+  cplstrsp(entry->volume_label, volume_label, 11);
+  entry->file_attr = FAT_FILE_ATTR_VOLUME_LABEL;
+  return entry;
+}
+
+fat_dir_entry_t * fat_add_root_file(uint8_t * dst, uint8_t index, const char * file_name, const char * file_extension, size_t file_size, uint16_t data_start_sector, bool is_fat16){
+  fat_boot_sector_t * boot = (fat_boot_sector_t *)dst;
+  uint8_t * table = dst + DISK_SECTOR_SIZE;
+  fat_dir_entry_t * entry = (fat_dir_entry_t *)(dst + ((boot->sectors_per_alloc_table+1) * DISK_SECTOR_SIZE) + (index * sizeof(fat_dir_entry_t)));
+  memset(entry, 0, sizeof(fat_dir_entry_t));
+  cplstrsp(entry->file_name, file_name, 8);
+  cplstrsp(entry->file_extension, file_extension, 3);
+  entry->file_attr = FAT_FILE_ATTR_ARCHIVE;
+  entry->file_size = file_size;
+  entry->data_start_sector = data_start_sector;
+  entry->extended_attr = 0;
+
+  uint16_t file_sectors = file_size / DISK_SECTOR_SIZE;
+  if(file_size % DISK_SECTOR_SIZE){
+    file_sectors++;
+  }
+
+  uint16_t data_end_sector = data_start_sector + file_sectors;
+  for(uint16_t i=data_start_sector; i<(data_end_sector-1); i++){
+    fat_set_table_index(table, i, i+1, is_fat16);
+  }
+  fat_set_table_index(table, data_end_sector-1, 0xFFFF, is_fat16);
+
+  //Set Firmware Date based on the build time
+  static const char * month_names_short[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+  char mstr[8] = {'\0',};
+  const char *str = __DATE__ " " __TIME__;
+  int ms=0, seconds=0, minutes=0, hours=0, year=0, date=0, month=0;
+  int r = sscanf(str,"%s %d %d %d:%d:%d", mstr, &date, &year, &hours, &minutes, &seconds);
+  if(r >= 0){
+    for(int i=0; i<12; i++){
+      if(!strcmp(mstr, month_names_short[i])){
+        month = i;
+        break;
+      }
+    }
+    entry->creation_time_ms = FAT_MS2V(seconds, ms);
+    entry->creation_time_hms = FAT_HMS2V(hours, minutes, seconds);
+    entry->creation_time_ymd = FAT_YMD2V(year, month, date);
+    entry->last_access_ymd = entry->creation_time_ymd;
+    entry->last_modified_hms = entry->creation_time_hms;
+    entry->last_modified_ymd = entry->creation_time_ymd;
+  }
+  return entry;
+}
+
+uint8_t fat_lfn_checksum(const uint8_t *short_filename){
+   uint8_t sum = 0;
+   for (uint8_t i = 11; i; i--) {
+      sum = ((sum & 1) << 7) + (sum >> 1) + *short_filename++;
+   }
+   return sum;
+}

cores/esp32/firmware_msc_fat.h

@@ -0,0 +1,141 @@
+// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+ extern "C" {
+#endif
+
+#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 FAT12_TBL2B(l,h)    FAT_U8(l), FAT_U8(((l >> 8) & 0xF) | ((h << 4) & 0xF0)), FAT_U8(h >> 4)
+
+#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_MS2V(s,ms)    FAT_U8(((((s) & 0x1) * 1000) + (ms)) / 10)
+#define FAT_HMS2V(h,m,s)  (FAT_U8(((s) >> 1)|(((m) & 0x7) << 5)) | (FAT_U8((((m) >> 3) & 0x7)|((h) << 3)) << 8))
+#define FAT_YMD2V(y,m,d)  (FAT_U8(((d) & 0x1F)|(((m) & 0x7) << 5)) | (FAT_U8((((m) >> 3) & 0x1)|((((y) - 1980) & 0x7F) << 1)) << 8))
+
+#define FAT_B2HMS(hms)    ((hms >> 11) & 0x1F), ((hms >> 5) & 0x3F), ((hms & 0x1F) << 1)
+#define FAT_B2YMD(ymd)    (((ymd >> 9) & 0x7F) + 1980), ((ymd >> 5) & 0x0F), (ymd & 0x1F)
+
+#define FAT_FILE_ATTR_READ_ONLY     0x01
+#define FAT_FILE_ATTR_HIDDEN        0x02
+#define FAT_FILE_ATTR_SYSTEM        0x04
+#define FAT_FILE_ATTR_VOLUME_LABEL  0x08
+#define FAT_FILE_ATTR_SUBDIRECTORY  0x10
+#define FAT_FILE_ATTR_ARCHIVE       0x20
+#define FAT_FILE_ATTR_DEVICE        0x40
+
+static const uint16_t DISK_SECTOR_SIZE = 512;
+
+#define FAT_SIZE_TO_SECTORS(bytes) ((bytes) / DISK_SECTOR_SIZE) + (((bytes) % DISK_SECTOR_SIZE)?1:0)
+
+typedef struct __attribute__ ((packed)) {
+  uint8_t jump_instruction[3];
+  char oem_name[8];//padded with spaces (0x20)
+  uint16_t bytes_per_sector;//DISK_SECTOR_SIZE usually 512
+  uint8_t sectors_per_cluster;//Allowed values are 1, 2, 4, 8, 16, 32, 64, and 128
+  uint16_t reserved_sectors_count;//At least 1 for this sector, usually 32 for FAT32
+  uint8_t file_alloc_tables_num;//Almost always 2; RAM disks might use 1
+  uint16_t max_root_dir_entries;//FAT12 and FAT16
+  uint16_t fat12_sector_num;//DISK_SECTOR_NUM FAT12 and FAT16
+  uint8_t media_descriptor;
+  uint16_t sectors_per_alloc_table;//FAT12 and FAT16
+  uint16_t sectors_per_track;//A value of 0 may indicate LBA-only access
+  uint16_t num_heads;
+  uint32_t hidden_sectors_count;
+  uint32_t total_sectors_32;
+  uint8_t physical_drive_number;//0x00 for (first) removable media, 0x80 for (first) fixed disk
+  uint8_t reserved0;
+  uint8_t extended_boot_signature;//should be 0x29
+  uint32_t serial_number;//0x1234 => 1234
+  char volume_label[11];//padded with spaces (0x20)
+  char file_system_type[8];//padded with spaces (0x20)
+  uint8_t reserved[448];
+  uint16_t signature;//should be 0xAA55
+} fat_boot_sector_t;
+
+typedef struct __attribute__ ((packed)) {
+  union {
+    struct {
+      char file_name[8];//padded with spaces (0x20)
+      char file_extension[3];//padded with spaces (0x20)
+    };
+    struct {
+      uint8_t file_magic;// 0xE5:deleted, 0x05:will_be_deleted, 0x00:end_marker, 0x2E:dot_marker(. or ..)
+      char file_magic_data[10];
+    };
+    char volume_label[11];//padded with spaces (0x20)
+  };
+  uint8_t file_attr;//mask of FAT_FILE_ATTR_*
+  uint8_t reserved;//always 0
+  uint8_t creation_time_ms;//ms * 10; max 1990 (1s 990ms)
+  uint16_t creation_time_hms; // [5:6:5] => h:m:(s/2)
+  uint16_t creation_time_ymd; // [7:4:5] => (y+1980):m:d
+  uint16_t last_access_ymd;
+  uint16_t extended_attr;
+  uint16_t last_modified_hms;
+  uint16_t last_modified_ymd;
+  uint16_t data_start_sector;
+  uint32_t file_size;
+} fat_dir_entry_t;
+
+typedef struct __attribute__ ((packed)) {
+  union {
+    struct {
+      uint8_t number:5;
+      uint8_t reserved0:1;
+      uint8_t llfp:1;
+      uint8_t reserved1:1;
+    } seq;
+    uint8_t seq_num; //0xE5: Deleted Entry
+  };
+  uint16_t name0[5];
+  uint8_t attr; //ALWAYS 0x0F
+  uint8_t type; //ALWAYS 0x00
+  uint8_t dos_checksum;
+  uint16_t name1[6];
+  uint16_t first_cluster; //ALWAYS 0x0000
+  uint16_t name2[2];
+} fat_lfn_entry_t;
+
+typedef union {
+  fat_dir_entry_t dir;
+  fat_lfn_entry_t lfn;
+} fat_entry_t;
+
+const char * fat_file_system_type(bool fat16);
+uint16_t fat_sectors_per_alloc_table(uint32_t sector_num, bool fat16);
+uint8_t * fat_add_table(uint8_t * dst, fat_boot_sector_t * boot, bool fat16);
+void fat_set_table_index(uint8_t * table, uint16_t index, uint16_t value, bool fat16);
+fat_boot_sector_t * fat_add_boot_sector(uint8_t * dst, uint16_t sector_num, uint16_t table_sectors, const char * file_system_type, const char * volume_label, uint32_t serial_number);
+fat_dir_entry_t * fat_add_label(uint8_t * dst, const char * volume_label);
+fat_dir_entry_t * fat_add_root_file(uint8_t * dst, uint8_t index, const char * file_name, const char * file_extension, size_t file_size, uint16_t data_start_sector, bool is_fat16);
+uint8_t fat_lfn_checksum(const uint8_t *short_filename);
+
+#ifdef __cplusplus
+ }
+#endif

cores/esp32/main.cpp

@@ -2,12 +2,19 @@
 #include "freertos/task.h"
 #include "esp_task_wdt.h"
 #include "Arduino.h"
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
+#if (ARDUINO_USB_CDC_ON_BOOT|ARDUINO_USB_MSC_ON_BOOT|ARDUINO_USB_DFU_ON_BOOT)
 #include "USB.h"
+#if ARDUINO_USB_MSC_ON_BOOT
+#include "FirmwareMSC.h"
+#endif
 #endif
 
+#ifndef ARDUINO_LOOP_STACK_SIZE
 #ifndef CONFIG_ARDUINO_LOOP_STACK_SIZE
-#define CONFIG_ARDUINO_LOOP_STACK_SIZE 8192
+#define ARDUINO_LOOP_STACK_SIZE 8192
+#else
+#define ARDUINO_LOOP_STACK_SIZE CONFIG_ARDUINO_LOOP_STACK_SIZE
+#endif
 #endif
 
 TaskHandle_t loopTaskHandle = NULL;
@@ -43,12 +50,21 @@ void loopTask(void *pvParameters)
 
 extern "C" void app_main()
 {
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
+#if ARDUINO_USB_CDC_ON_BOOT
+    Serial.begin();
+#endif
+#if ARDUINO_USB_MSC_ON_BOOT
+    MSC_Update.begin();
+#endif
+#if ARDUINO_USB_DFU_ON_BOOT
+    USB.enableDFU();
+#endif
+#if ARDUINO_USB_ON_BOOT
     USB.begin();
 #endif
     loopTaskWDTEnabled = false;
     initArduino();
-    xTaskCreateUniversal(loopTask, "loopTask", CONFIG_ARDUINO_LOOP_STACK_SIZE, NULL, 1, &loopTaskHandle, ARDUINO_RUNNING_CORE);
+    xTaskCreateUniversal(loopTask, "loopTask", ARDUINO_LOOP_STACK_SIZE, NULL, 1, &loopTaskHandle, ARDUINO_RUNNING_CORE);
 }
 
 #endif

cores/esp32/stdlib_noniso.c

@@ -28,8 +28,9 @@
 #include <stdint.h>
 #include <math.h>
 #include "stdlib_noniso.h"
+#include "esp_system.h"
 
-void reverse(char* begin, char* end) {
+static void reverse(char* begin, char* end) {
     char *is = begin;
     char *ie = end - 1;
     while(is < ie) {

cores/esp32/wiring_pulse.c

@@ -17,13 +17,11 @@
 //#include <limits.h>
 #include "wiring_private.h"
 #include "pins_arduino.h"
-
-
-extern uint32_t xthal_get_ccount();
+#include <hal/cpu_hal.h>
 
 #define WAIT_FOR_PIN_STATE(state) \
     while (digitalRead(pin) != (state)) { \
-        if (xthal_get_ccount() - start_cycle_count > timeout_cycles) { \
+        if (cpu_hal_get_cycle_count() - start_cycle_count > timeout_cycles) { \
             return 0; \
         } \
     }
@@ -36,12 +34,12 @@ unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout)
         timeout = max_timeout_us;
     }
     const uint32_t timeout_cycles = microsecondsToClockCycles(timeout);
-    const uint32_t start_cycle_count = xthal_get_ccount();
+    const uint32_t start_cycle_count = cpu_hal_get_cycle_count();
     WAIT_FOR_PIN_STATE(!state);
     WAIT_FOR_PIN_STATE(state);
-    const uint32_t pulse_start_cycle_count = xthal_get_ccount();
+    const uint32_t pulse_start_cycle_count = cpu_hal_get_cycle_count();
     WAIT_FOR_PIN_STATE(!state);
-    return clockCyclesToMicroseconds(xthal_get_ccount() - pulse_start_cycle_count);
+    return clockCyclesToMicroseconds(cpu_hal_get_cycle_count() - pulse_start_cycle_count);
 }
 
 unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout)

docs/EXAMPLE_README_TEMPLATE.md

@@ -0,0 +1,122 @@
+# Arduino-ESP32 Example/Library Name ==(REQUIRED)==
+
+==*Add a brief description about this example/library here!*==
+
+This example/library demonstrates how to create a new example README file.
+
+# Supported Targets ==(REQUIRED)==
+
+==*Add the supported devices here!*==
+
+Currently, this example supports the following targets.
+
+| Supported Targets | ESP32 | ESP32-S2 | ESP32-C3 |
+| ----------------- | ----- | -------- | -------- |
+
+## How to Use Example/Library ==(OPTIONAL)==
+
+==*Add a brief description on how to use this example.*==
+
+* How to install the Arduino IDE: [Install Arduino IDE](https://github.com/espressif/arduino-esp32/tree/master/docs/arduino-ide).
+
+### Hardware Connection ==(OPTIONAL)==
+
+==*Add a brief description about wiring or any other hardware specific connection.*==
+
+To use this example, you need to connect the LED to the `GPIOx`.
+
+SDCard GPIO connection scheme:
+
+| SDCard Pin | Function | GPIO |
+| ----------- | -------- | ------ |
+| 1 | CS | GPIO5 |
+| 2 | DI/MOSI | GPIO23 |
+| 3 | VSS/GND | GND |
+| 4 | VDD/3V3 | 3V3 |
+| 5 | SCLK | GPIO18 |
+| 6 | VSS/GND | GND |
+| 7 | DO/MISO | GPIO19 |
+
+To add images, please create a folder `_asset` inside the example folder to add the relevant images.
+
+### Configure the Project ==(OPTIONAL)==
+
+==*Add a brief description about this example here!*==
+
+Set the LED GPIO by changing the `LED_BUILTIN` value in the function `pinMode(LED_BUILTIN, OUTPUT);`. By default, the GPIO is: `GPIOx`.
+
+#### Example for the GPIO4:
+
+==*Add some code explanation if relevant to the example.*==
+
+```cpp
+// the setup function runs once when you press reset or power the board
+void setup() {
+// initialize digital pin 4 as an output.
+pinMode(4, OUTPUT);
+}
+```
+
+#### Using Arduino IDE
+
+To get more information about the Espressif boards see [Espressif Development Kits](https://www.espressif.com/en/products/devkits).
+
+* Before Compile/Verify, select the correct board: `Tools -> Board`.
+* Select the COM port: `Tools -> Port: xxx` where the `xxx` is the detected COM port.
+
+#### Using Platform IO
+
+* Select the COM port: `Devices` or setting the `upload_port` option on the `platformio.ini` file.
+
+## Example/Log Output ==(OPTIONAL)==
+
+==*Add the log/serial output here!*==
+
+```
+ets Jul 29 2019 12:21:46
+
+rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
+configsip: 0, SPIWP:0xee
+clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
+mode:DIO, clock div:1
+load:0x3fff0030,len:1412
+load:0x40078000,len:13400
+load:0x40080400,len:3672
+entry 0x400805f8
+ESP32 Chip model = ESP32-D0WDQ5 Rev 3
+This chip has 2 cores
+Chip ID: 3957392
+```
+
+## Troubleshooting ==(REQUIRED)==
+
+==*Add specific issues you may find by using this example here!*==
+
+***Important: Make sure you are using a good quality USB cable and that you have a reliable power source***
+
+* **LED not blinking:** Check the wiring connection and the IO selection.
+* **Programming Fail:** If the programming/flash procedure fails, try reducing the serial connection speed.
+* **COM port not detected:** Check the USB cable and the USB to Serial driver installation.
+
+If the error persist, you can ask for help at the official [ESP32 forum](https://esp32.com) or see [Contribute](#contribute).
+
+## Contribute ==(REQUIRED)==
+
+==*Do not change! Keep as is.*==
+
+To know how to contribute to this project, see [How to contribute.](https://github.com/espressif/arduino-esp32/blob/master/CONTRIBUTING.rst)
+
+If you have any **feedback** or **issue** to report on this example/library, please open an issue or fix it by creating a new PR. Contributions are more than welcome!
+
+Before creating a new issue, be sure to try the Troubleshooting and to check if the same issue was already created by someone else.
+
+## Resources ==(REQUIRED)==
+
+==*Do not change here! Keep as is or add only relevant documents/info for this example. Do not add any purchase link/marketing stuff*==
+
+* Official ESP32 Forum: [Link](https://esp32.com)
+* Arduino-ESP32 Official Repository: [espressif/arduino-esp32](https://github.com/espressif/arduino-esp32)
+* ESP32 Datasheet: [Link to datasheet](https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf)
+* ESP32-S2 Datasheet: [Link to datasheet](https://www.espressif.com/sites/default/files/documentation/esp32-s2_datasheet_en.pdf)
+* ESP32-C3 Datasheet: [Link to datasheet](https://www.espressif.com/sites/default/files/documentation/esp32-c3_datasheet_en.pdf)
+* Official ESP-IDF documentation: [ESP-IDF](https://idf.espressif.com)

docs/Makefile

@@ -0,0 +1,28 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+LINKCHECKDIR  = build/linkcheck
+
+.PHONY: checklinks
+	checklinks:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(LINKCHECKDIR)
+	@echo
+	@echo "Check finished. Report is in $(LINKCHECKDIR)."
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/OTAWebUpdate/OTAWebUpdate.md

@@ -1,59 +0,0 @@
-# Over the Air through Web browser
-OTAWebUpdate is done with a web browser that can be useful in the following typical scenarios:
-- Once the application developed and loading directly from Arduino IDE is inconvenient or not possible
-- after deployment if user is unable to expose Firmware for OTA from external update server
-- provide updates after deployment to small quantity of modules when setting an update server is not practicable
-
-## Requirements
-- The ESP and the computer must be connected to the same network
-
-## Implementation
-The sample implementation has been done using:
-- example sketch OTAWebUpdater.ino
-- ESP32 (Dev Module)
-
-You can use another module also if it meets Flash chip size of the sketch
-
-1-Before you begin, please make sure that you have the following software installed:
- - Arduino IDE
- - Host software depending on O/S you use:
-   - Avahi http://avahi.org/ for Linux
-   - Bonjour http://www.apple.com/support/bonjour/ for Windows
-   - Mac OSX and iOS - support is already built in / no any extra s/w is required
-
-Prepare the sketch and configuration for initial upload with a serial port
-- Start Arduino IDE and load sketch OTAWebUpdater.ino available under File > Examples > OTAWebUpdater.ino
-- Update ssid and pass in the sketch so the module can join your Wi-Fi network
-- Open File > Preferences, look for “Show verbose output during:” and check out “compilation” option
-
-![verbrose](esp32verbose.PNG)
-
-- Upload sketch (Ctrl+U)
-- Now open web browser and enter the url, i.e. http://esp32.local. Once entered, browser should display a form
-
-![login](esp32login.PNG)
-
-> username= admin
-
-> password= admin
-
-**Note**-*If entering “http://ESP32.local” does not work, try replacing “ESP32” with module’s IP address.This workaround is useful in case the host software installed does not work*. 
-
-Now click on Login button and browser will display a upload form
-
-![upload](esp32upload.PNG)
-
-For Uploading the New Firmware you need to provide the Binary File of your Code.
-
-Exporting Binary file of the Firmware (Code)
-- Open up the Arduino IDE
-- Open up the Code, for Exporting up Binary file
-- Now go to Sketch > export compiled Binary
-![export](exportTobinary.PNG)
-
-- Binary file is exported to the same Directory where your code is present
-
-Once you are comfortable with this procedure go ahead and modify OTAWebUpdater.ino sketch to print some additional messages, compile it, Export new binary file and upload it using web browser to see entered changes on a Serial Monitor
-
-
-

docs/arduino-ide/boards_manager.md

@@ -1,12 +0,0 @@
-## Installation instructions using Arduino IDE Boards Manager
-### ==========================================================
-
-- Stable release link: `https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json`
-- Development release link: `https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json`
-
-Starting with 1.6.4, Arduino allows installation of third-party platform packages using Boards Manager. We have packages available for Windows, Mac OS, and Linux (x86, amd64, armhf and arm64).
-
-- Install the current upstream Arduino IDE at the 1.8 level or later. The current version is at the [Arduino website](http://www.arduino.cc/en/main/software).
-- Start Arduino and open Preferences window.
-- Enter one of the release links above into *Additional Board Manager URLs* field. You can add multiple URLs, separating them with commas.
-- Open Boards Manager from Tools > Board menu and install *esp32* platform (and don't forget to select your ESP32 board from Tools > Board menu after installation).

docs/arduino-ide/debian_ubuntu.md

@@ -1,36 +0,0 @@
-Installation instructions for Debian / Ubuntu OS
-=================================================
-
-- Install latest Arduino IDE from [arduino.cc](https://www.arduino.cc/en/Main/Software)
-- Open Terminal and execute the following command (copy->paste and hit enter):
-
-  ```bash
-  sudo usermod -a -G dialout $USER && \
-  sudo apt-get install git && \
-  wget https://bootstrap.pypa.io/get-pip.py && \
-  sudo python3 get-pip.py && \
-  sudo pip3 install pyserial && \
-  mkdir -p ~/Arduino/hardware/espressif && \
-  cd ~/Arduino/hardware/espressif && \
-  git clone https://github.com/espressif/arduino-esp32.git esp32 && \
-  cd esp32 && \
-  git submodule update --init --recursive && \
-  cd tools && \
-  python3 get.py
-  ```
-- Restart Arduino IDE
-
-
-
-- If you have Arduino installed to ~/, modify the installation as follows, beginning at `mkdir -p ~/Arduino/hardware`:
-
-  ```bash
-  cd ~/Arduino/hardware
-  mkdir -p espressif && \
-  cd espressif && \
-  git clone https://github.com/espressif/arduino-esp32.git esp32 && \
-  cd esp32 && \
-  git submodule update --init --recursive && \
-  cd tools && \
-  python3 get.py
-  ```

docs/arduino-ide/fedora.md

@@ -1,18 +0,0 @@
-Installation instructions for Fedora
-=====================================
-
-- Install the latest Arduino IDE from [arduino.cc](https://www.arduino.cc/en/Main/Software). `$ sudo dnf -y install arduino` will most likely install an older release.
-- Open Terminal and execute the following command (copy->paste and hit enter):
-
-  ```bash
-  sudo usermod -a -G dialout $USER && \
-  sudo dnf install git python3-pip python3-pyserial && \
-  mkdir -p ~/Arduino/hardware/espressif && \
-  cd ~/Arduino/hardware/espressif && \
-  git clone https://github.com/espressif/arduino-esp32.git esp32 && \
-  cd esp32 && \
-  git submodule update --init --recursive && \
-  cd tools && \
-  python get.py
-  ```
-- Restart Arduino IDE

docs/arduino-ide/mac.md

@@ -1,29 +0,0 @@
-Installation instructions for Mac OS
-=====================================
-
-- Install latest Arduino IDE from [arduino.cc](https://www.arduino.cc/en/Main/Software)
-- Open Terminal and execute the following command (copy->paste and hit enter):
-
-  ```bash
-  mkdir -p ~/Documents/Arduino/hardware/espressif && \
-  cd ~/Documents/Arduino/hardware/espressif && \
-  git clone https://github.com/espressif/arduino-esp32.git esp32 --depth 1 && \
-  cd esp32 && \
-  git submodule update --init --recursive --depth 1 && \
-  cd tools && \
-  python get.py 
-  ```
-  Where `~/Documents/Arduino` represents your sketch book location as per "Arduino" > "Preferences" > "Sketchbook location" (in the IDE once started). Adjust the command above accordingly if necessary!
-  
-- If you get the error below. Install the command line dev tools with xcode-select --install and try the command above again:
-  
-  ```xcrun: error: invalid active developer path (/Library/Developer/CommandLineTools), missing xcrun at: /Library/Developer/CommandLineTools/usr/bin/xcrun```
-  
-  ```xcode-select --install```
-  
-- Try `python3` instead of `python` if you get the error: `IOError: [Errno socket error] [SSL: TLSV1_ALERT_PROTOCOL_VERSION] tlsv1 alert protocol version (_ssl.c:590)` when running `python get.py`
-
-- If you get the following error when running `python get.py` urllib.error.URLError: <urlopen error SSL: CERTIFICATE_VERIFY_FAILED, go to Macintosh HD > Applications > Python3.6 folder (or any other python version), and run the following scripts: Install Certificates.command and Update Shell Profile.command
-
-- Restart Arduino IDE
-

docs/arduino-ide/opensuse.md

@@ -1,22 +0,0 @@
-Installation instructions for openSUSE
-======================================
-
-- Install the latest Arduino IDE from [arduino.cc](https://www.arduino.cc/en/Main/Software).
-- Open Terminal and execute the following command (copy->paste and hit enter):
-
-  ```bash
-  sudo usermod -a -G dialout $USER && \
-  if [ `python --version 2>&1 | grep '2.7' | wc -l` = "1" ]; then \
-  sudo zypper install git python-pip python-pyserial; \
-  else \
-  sudo zypper install git python3-pip python3-pyserial; \
-  fi && \
-  mkdir -p ~/Arduino/hardware/espressif && \
-  cd ~/Arduino/hardware/espressif && \
-  git clone https://github.com/espressif/arduino-esp32.git esp32 && \
-  cd esp32 && \
-  git submodule update --init --recursive && \
-  cd tools && \
-  python get.py
-  ```
-- Restart Arduino IDE

docs/arduino-ide/windows.md

@@ -1,49 +0,0 @@
-## Steps to install Arduino ESP32 support on Windows
-### Tested on 32 and 64 bit Windows 10 machines
-
-1. Download and install the latest Arduino IDE ```Windows Installer``` from [arduino.cc](https://www.arduino.cc/en/Main/Software)
-2. Download and install Git from [git-scm.com](https://git-scm.com/download/win)
-3. Start ```Git GUI``` and run through the following steps:
-    - Select ```Clone Existing Repository```
-
-        ![Step 1](win-screenshots/win-gui-1.png)
-
-    - Select source and destination
-        - Sketchbook Directory: Usually ```C:/Users/[YOUR_USER_NAME]/Documents/Arduino``` and is listed underneath the "Sketchbook location" in Arduino preferences.
-        - Source Location: ```https://github.com/espressif/arduino-esp32.git```
-        - Target Directory: ```[ARDUINO_SKETCHBOOK_DIR]/hardware/espressif/esp32```
-        - Click ```Clone``` to start cloning the repository
-
-            ![Step 2](win-screenshots/win-gui-2.png)
-            ![Step 3](win-screenshots/win-gui-3.png)
-    - open a `Git Bash` session pointing to ```[ARDUINO_SKETCHBOOK_DIR]/hardware/espressif/esp32``` and execute ```git submodule update --init --recursive``` 
-    - Open ```[ARDUINO_SKETCHBOOK_DIR]/hardware/espressif/esp32/tools``` and double-click ```get.exe```
-
-        ![Step 4](win-screenshots/win-gui-4.png)
-
-    - When ```get.exe``` finishes, you should see the following files in the directory
-
-        ![Step 5](win-screenshots/win-gui-5.png)
-
-4. Plug your ESP32 board and wait for the drivers to install (or install manually any that might be required)
-5. Start Arduino IDE
-6. Select your board in ```Tools > Board``` menu
-7. Select the COM port that the board is attached to
-8. Compile and upload (You might need to hold the boot button while uploading)
-
-    ![Arduino IDE Example](win-screenshots/arduino-ide.png)
-
-### How to update to the latest code
-
-1. Start ```Git GUI``` and you should see the repository under ```Open Recent Repository```. Click on it!
-
-    ![Update Step 1](win-screenshots/win-gui-update-1.png)
-
-2. From menu ```Remote``` select ```Fetch from``` > ```origin```
-
-    ![Update Step 2](win-screenshots/win-gui-update-2.png)
-
-3. Wait for git to pull any changes and close ```Git GUI```
-4. Open ```[ARDUINO_SKETCHBOOK_DIR]/hardware/espressif/esp32/tools``` and double-click ```get.exe```
-
-    ![Step 4](win-screenshots/win-gui-4.png)

docs/esp-idf_component.md

@@ -1,82 +0,0 @@
-To use as a component of ESP-IDF
-=================================================
-
-## esp32-arduino-lib-builder
-
-For a simplified method, see [lib-builder](lib_builder.md)
-
-## Installation
-
-- Download and install [esp-idf](https://github.com/espressif/esp-idf)
-- Create blank idf project (from one of the examples)
-- in the project folder, create a folder called components and clone this repository inside
-
-    ```bash
-    mkdir -p components && \
-    cd components && \
-    git clone https://github.com/espressif/arduino-esp32.git arduino && \
-    cd arduino && \
-    git submodule update --init --recursive && \
-    cd ../.. && \
-    make menuconfig
-  ```
-- ```make menuconfig``` has some Arduino options
-    - "Autostart Arduino setup and loop on boot"
-        - If you enable this options, your main.cpp should be formated like any other sketch
-
-          ```arduino
-          //file: main.cpp
-          #include "Arduino.h"
-
-          void setup(){
-            Serial.begin(115200);
-          }
-
-          void loop(){
-            Serial.println("loop");
-            delay(1000);
-          }
-          ```
-
-        - Else you need to implement ```app_main()``` and call ```initArduino();``` in it.
-
-          Keep in mind that setup() and loop() will not be called in this case.
-          If you plan to base your code on examples provided in [esp-idf](https://github.com/espressif/esp-idf/tree/master/examples), please make sure move the app_main() function in main.cpp from the files in the example.
-
-          ```arduino
-          //file: main.cpp
-          #include "Arduino.h"
-
-          extern "C" void app_main()
-          {
-              initArduino();
-              pinMode(4, OUTPUT);
-              digitalWrite(4, HIGH);
-              //do your own thing
-          }
-          ```
-    - "Disable mutex locks for HAL"
-        - If enabled, there will be no protection on the drivers from concurently accessing them from another thread/interrupt/core
-    - "Autoconnect WiFi on boot"
-        - If enabled, WiFi will start with the last known configuration
-        - Else it will wait for WiFi.begin
-- ```make flash monitor``` will build, upload and open serial monitor to your board
-
-## Logging To Serial
-
-If you are writing code that does not require Arduino to compile and you want your `ESP_LOGx` macros to work in Arduino IDE, you can enable the compatibility by adding the following lines after your includes:
-
-```cpp
-#ifdef ARDUINO_ARCH_ESP32
-#include "esp32-hal-log.h"
-#endif
-```
-
-## FreeRTOS Tick Rate (Hz)
-
-You might notice that Arduino-esp32's `delay()` function will only work in multiples of 10ms. That is because, by default, esp-idf handles task events 100 times per second.
-To fix that behavior you need to set FreeRTOS tick rate to 1000Hz in `make menuconfig` -> `Component config` -> `FreeRTOS` -> `Tick rate`.
-
-## Compilation Errors
-
-As commits are made to esp-idf and submodules, the codebases can develop incompatibilities which cause compilation errors.  If you have problems compiling, follow the instructions in [Issue #1142](https://github.com/espressif/arduino-esp32/issues/1142) to roll esp-idf back to a known good version.

docs/lib_builder.md

@@ -1,14 +0,0 @@
-## Using esp32-arduino-lib-builder to compile custom libraries
-
-Espressif has provided a [tool](https://github.com/espressif/esp32-arduino-lib-builder) to simplify building your own compiled libraries for use in Arduino IDE (or your favorite IDE).
-To use it to generate custom libraries, follow these steps:
-1. `git clone https://github.com/espressif/esp32-arduino-lib-builder`
-2. `cd esp32-arduino-lib-builder`
-3. `./tools/update-components.sh`
-4. `./tools/install-esp-idf.sh` (if you already have an $IDF_PATH defined, it will use your local copy of the repository)
-5. `make menuconfig` or directly edit sdkconfig.
-6. `./build.sh`
-
-The script automates the process of building [arduino as an ESP-IDF component](https://github.com/espressif/arduino-esp32/blob/master/docs/esp-idf_component.md).
-Once it is complete, you can cherry pick the needed libraries from `out/tools/sdk/lib`, or run `tools/copy-to-arduino.sh` to copy the entire built system.
-`tools/config.sh` contains a number of variables that control the process, particularly the $IDF_BRANCH variable.  You can adjust this to try building against newer versions, but there are absolutely no guarantees that any components will work or even successfully compile against a newer IDF.

docs/make.bat

@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

docs/make.md

@@ -1,4 +0,0 @@
-To use make
-============
-
- [makeEspArduino](https://github.com/plerup/makeEspArduino) is a generic makefile for any ESP8266/ESP32 Arduino project.Using make instead of the Arduino IDE makes it easier to do automated and production builds.

docs/platformio.md

@@ -1,11 +0,0 @@
-Installation instructions for using PlatformIO
-=================================================
-
-- [What is PlatformIO?](https://docs.platformio.org/en/latest/what-is-platformio.html?utm_source=github&utm_medium=arduino-esp32)
-- [PlatformIO IDE](https://platformio.org/platformio-ide?utm_source=github&utm_medium=arduino-esp32)
-- [PlatformIO Core](https://docs.platformio.org/en/latest/core.html?utm_source=github&utm_medium=arduino-esp32) (command line tool)
-- [Advanced usage](https://docs.platformio.org/en/latest/platforms/espressif32.html?utm_source=github&utm_medium=arduino-esp32) -
-  custom settings, uploading to SPIFFS, Over-the-Air (OTA), staging version
-- [Integration with Cloud and Standalone IDEs](https://docs.platformio.org/en/latest/ide.html?utm_source=github&utm_medium=arduino-esp32) -
-  Cloud9, Codeanywhere, Eclipse Che (Codenvy), Atom, CLion, Eclipse, Emacs, NetBeans, Qt Creator, Sublime Text, VIM, Visual Studio, and VSCode
-- [Project Examples](https://docs.platformio.org/en/latest/platforms/espressif32.html?utm_source=github&utm_medium=arduino-esp32#examples)

docs/requirements.txt

@@ -0,0 +1,5 @@
+# This is a list of python packages used to generate documentation. This file is used with pip:
+# pip install --user -r requirements.txt
+#
+# matplotlib is currently required only by the script generate_chart.py
+sphinx-copybutton==0.3.0

docs/source/advanced_utils.rst

@@ -0,0 +1,11 @@
+##################
+Advanced Utilities
+##################
+
+.. toctree::
+    :maxdepth: 2
+
+    Library Builder <lib_builder>
+    ESP-IDF as Component <esp-idf_component>
+    OTA Web Update <ota_web_update>
+    makeEspArduino <make>

docs/source/api/bluetooth.rst

@@ -0,0 +1,3 @@
+#############
+Bluetooth API
+#############

docs/source/api/deepsleep.rst

@@ -0,0 +1,3 @@
+##########
+Deep Sleep
+##########

docs/source/api/espnow.rst

@@ -0,0 +1,16 @@
+#######
+ESP-NOW
+#######
+
+ESP-NOW is a fast, connectionless communication technology featuring a short packet transmission.
+ESP-NOW is ideal for smart lights, remote control devices, sensors and other applications. 
+
+Example
+-------
+
+Resources
+---------
+
+* `ESP-NOW`_ (User Guide)
+
+.. _ESP-NOW: https://www.espressif.com/sites/default/files/documentation/esp-now_user_guide_en.pdf

docs/source/api/gpio.rst

@@ -0,0 +1,3 @@
+####
+GPIO
+####

docs/source/api/rainmaker.rst

@@ -0,0 +1,3 @@
+#########
+RainMaker
+#########

docs/source/api/reset_reason.rst

@@ -0,0 +1,3 @@
+############
+Reset Reason
+############

docs/source/api/wifi.rst

@@ -0,0 +1,512 @@
+#########
+Wi-Fi API
+#########
+
+About
+-----
+
+The Wi-Fi API provides support for the 802.11b/g/n protocol driver. This API includes:
+
+* Station mode (STA mode or Wi-Fi client mode). ESP32 connects to an access point
+
+* AP mode (aka Soft-AP mode or Access Point mode). Devices connect to the ESP32
+
+* Security modes (WPA, WPA2, WEP, etc.)
+
+* Scanning for access points
+
+Working as AP
+*************
+
+In this mode, the ESP32 is configured as an Access Point (AP) and it's capable of receiving incoming connections from other devices (stations) by providing
+a Wi-Fi network.
+
+.. figure:: ../_static/wifi_esp32_ap.png
+    :align: center
+    :width: 520
+    :figclass: align-center
+
+This mode can be used for serving a HTTP or HTTPS server inside the ESP32, for example.
+
+Working as STA
+**************
+
+The STA mode is used to connect the ESP32 to a Wi-Fi network, provided by an Access Point.
+
+.. figure:: ../_static/wifi_esp32_sta.png
+    :align: center
+    :width: 520
+    :figclass: align-center
+
+If you need to connect your project to the Internet, this is the mode you are looking for.
+
+API Description
+---------------
+
+Here is the description about the WiFi API.
+
+WiFiAP
+------
+
+The ``WiFiAP`` is used to configure and manage the Wi-Fi as an Access Point. This is where you can find the related functions for the AP.
+
+Basic Usage
+***********
+
+To start the Wi-Fi as an Access Point.
+
+.. code-block:: arduino
+
+    WiFi.softAP(ssid, password);
+
+Please see the full WiFiAP example in: `ap example`_.
+
+AP Configuration
+----------------
+
+softAP
+******
+
+Use the function ``softAP`` to configure the Wi-Fi AP characteristics:
+
+.. code-block:: arduino
+
+    bool softAP(const char* ssid, const char* passphrase = NULL, int channel = 1, int ssid_hidden = 0, int max_connection = 4, bool ftm_responder = false);
+
+Where:
+
+* ``ssid`` sets the Wi-Fi network SSID.
+* ``passphrase`` sets the Wi-Fi network password. If the network is open, set as ``NULL``. 
+* ``channel`` configures the Wi-Fi channel.
+* ``ssid_hidden`` sets the network as hidden.
+* ``max_connection`` sets the maximum number of simultaneous connections. The default is 4.
+* ``ftm_responder`` sets the Wi-Fi FTM responder feature. **Only for ESP32-S2 and ESP32-C3 SoC!**
+
+Return ``true`` if the configuration was successful.
+
+softAPConfig
+************
+
+Function used to configure the IP as static (fixed) as well as the gateway and subnet.
+
+.. code-block:: arduino
+
+    bool softAPConfig(IPAddress local_ip, IPAddress gateway, IPAddress subnet);
+
+Where:
+
+* ``local_ip`` sets the local IP address.
+* ``gateway`` sets the gateway IP.
+* ``subnet`` sets the subnet mask.
+
+The function will return ``true`` if the configuration is successful.
+
+AP Connection
+-------------
+
+softAPdisconnect
+****************
+
+Function used to force the AP disconnection.
+
+.. code-block:: arduino
+
+    bool softAPdisconnect(bool wifioff = false);
+
+Where:
+
+* ``wifioff`` sets the Wi-Fi off if ``true``.
+
+The function will return ``true`` if the configuration is successful.
+
+
+softAPgetStationNum
+*******************
+
+This function returns the number of clients connected to the AP.
+
+.. code-block:: arduino
+
+    uint8_t softAPgetStationNum();
+
+softAPIP
+********
+
+Function to get the AP IPv4 address.
+
+.. code-block:: arduino
+
+    IPAddress softAPIP();
+
+The function will return the AP IP address in ``IPAddress`` format.
+
+softAPBroadcastIP
+*****************
+
+Function to get the AP IPv4 broadcast address.
+
+.. code-block:: arduino
+
+    IPAddress softAPBroadcastIP();
+
+The function will return the AP broadcast address in ``IPAddress`` format.
+
+softAPNetworkID
+***************
+
+Get the softAP network ID.
+
+.. code-block:: arduino
+
+    IPAddress softAPNetworkID();
+
+The function will return the AP network address in ``IPAddress`` format.
+
+softAPSubnetCIDR
+****************
+
+Get the softAP subnet CIDR.
+
+.. code-block:: arduino
+
+    uint8_t softAPSubnetCIDR();
+
+softAPenableIpV6
+****************
+
+Function used to enable the IPv6 support.
+
+.. code-block:: arduino
+
+    bool softAPenableIpV6();
+
+The function will return ``true`` if the configuration is successful.
+
+softAPIPv6
+**********
+
+Function to get the IPv6 address.
+
+.. code-block:: arduino
+
+    IPv6Address softAPIPv6();
+
+The function will return the AP IPv6 address in ``IPv6Address`` format.
+
+softAPgetHostname
+*****************
+
+Function to get the AP hostname.
+
+.. code-block:: arduino
+
+    const char * softAPgetHostname();
+
+softAPsetHostname
+*****************
+
+Function to set the AP hostname.
+
+.. code-block:: arduino
+
+    bool softAPsetHostname(const char * hostname);
+
+Where:
+
+* ``hostname`` sets the device hostname.
+
+The function will return ``true`` if the configuration is successful.
+
+
+softAPmacAddress
+****************
+
+Function to define the AP MAC address.
+
+.. code-block:: arduino
+
+    uint8_t* softAPmacAddress(uint8_t* mac);
+
+Where:
+
+* ``mac`` sets the new MAC address.
+
+Function to get the AP MAC address.
+
+.. code-block:: arduino
+
+    String softAPmacAddress(void);
+
+softAPSSID
+**********
+
+Function to get the AP SSID.
+
+.. code-block:: arduino
+
+    String softAPSSID(void) const;
+
+Returns the AP SSID.
+
+WiFiSTA
+-------
+
+The ``WiFiSTA`` is used to configure and manage the Wi-Fi as Station. The related functions for the STA are here.
+
+Basic Usage
+***********
+
+The following code shows the basic usage of the WifiSTA functionality.
+
+.. code-block:: arduino
+
+    WiFi.begin(ssid, password);
+
+Where the ``ssid`` and ``password`` are from the network you want to connect the ESP32.
+
+To check if the connection is successful, you can use:
+
+.. code-block:: arduino
+
+    while (WiFi.status() != WL_CONNECTED) {
+        delay(500);
+        Serial.print(".");
+    }
+
+After a successful connection, you can print the IP address given by the network.
+
+.. code-block:: arduino
+
+    Serial.println("IP address: ");
+    Serial.println(WiFi.localIP());
+
+Please see the full example of the WiFiSTA in: `sta example`_.
+
+STA Configuration
+-----------------
+
+begin
+*****
+
+- Functions ``begin`` are used to configure and start the Wi-Fi.
+
+.. code-block:: arduino
+
+    wl_status_t begin(const char* ssid, const char *passphrase = NULL, int32_t channel = 0, const uint8_t* bssid = NULL, bool connect = true);
+
+Where:
+
+* ``ssid`` sets the AP SSID.
+* ``passphrase`` sets the AP password. Set as ``NULL`` for open networks.
+* ``channel`` sets the Wi-Fi channel.
+* ``uint8_t* bssid`` sets the AP BSSID.
+* ``connect`` sets ``true`` to connect to the configured network automatically.
+
+.. code-block:: arduino
+
+    wl_status_t begin(char* ssid, char *passphrase = NULL, int32_t channel = 0, const uint8_t* bssid = NULL, bool connect = true);
+
+Where:
+
+* ``ssid`` sets the AP SSID.
+* ``passphrase`` sets the AP password. Set as ``NULL`` for open networks.
+* ``channel`` sets the Wi-Fi channel.
+* ``bssid`` sets the AP BSSID.
+* ``connect`` sets ``true`` to connect to the configured network automatically.
+
+Function to start the connection after being configured.
+
+.. code-block:: arduino
+
+    wl_status_t begin();
+
+config
+******
+
+Function ``config`` is used to configure Wi-Fi. After configuring, you can call function ``begin`` to start the Wi-Fi process.
+
+.. code-block:: arduino
+
+    bool config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1 = (uint32_t)0x00000000, IPAddress dns2 = (uint32_t)0x00000000);
+
+Where:
+
+* ``local_ip`` sets the local IP.
+* ``gateway`` sets the gateway IP.
+* ``subnet`` sets the subnet mask.
+* ``dns1`` sets the DNS.
+* ``dns2`` sets the DNS alternative option.
+
+The function will return ``true`` if the configuration is successful.
+
+The ``IPAddress`` format is defined by 4 bytes as described here:
+
+.. code-block:: arduino
+
+    IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet);
+
+Example:
+
+.. code-block:: arduino
+
+    IPAddress local_ip(192, 168, 10, 20);
+
+See the ``WiFiClientStaticIP.ino`` for more details on how to use this feature.
+
+STA Connection
+--------------
+
+reconnect
+*********
+
+Function used to reconnect the Wi-Fi connection.
+
+.. code-block:: arduino
+
+    bool reconnect();
+
+disconnect
+**********
+
+Function to force disconnection.
+
+.. code-block:: arduino
+
+    bool disconnect(bool wifioff = false, bool eraseap = false);
+
+Where:
+
+* ``wifioff`` use ``true`` to turn the Wi-Fi radio off.
+* ``eraseap`` use ``true`` to erase the AP configuration from the NVS memory.
+
+The function will return ``true`` if the configuration is successful.
+
+isConnected
+***********
+
+Function used to get the connection state.
+
+.. code-block:: arduino
+
+    bool isConnected();
+
+Return the connection state.
+
+setAutoConnect
+**************
+
+Function used to set the automatic connection.
+
+.. code-block:: arduino
+
+    bool setAutoConnect(bool autoConnect);
+
+Where:
+
+* ``bool autoConnect`` is set to ``true`` to enable this option.
+
+getAutoConnect
+**************
+
+Function used to get the automatic connection setting value.
+
+.. code-block:: arduino
+
+    bool getAutoConnect();
+
+The function will return ``true`` if the setting is enabled.
+
+setAutoReconnect
+****************
+
+Function used to set the automatic reconnection if the connection is lost.
+
+.. code-block:: arduino
+
+    bool setAutoReconnect(bool autoReconnect);
+
+Where:
+
+* ``autoConnect`` is set to ``true`` to enable this option.
+
+getAutoReconnect
+****************
+
+Function used to get the automatic reconnection if the connection is lost.
+.. code-block:: arduino
+
+    bool getAutoReconnect();
+
+    The function will return ``true`` if this setting is enabled.
+
+WiFiMulti
+---------
+
+The ``WiFiMulti`` allows you to add more than one option for the AP connection while running as a station.
+
+To add the AP, use the following function. You can add multiple AP's and this library will handle the connection.
+
+.. code-block:: arduino
+
+    bool addAP(const char* ssid, const char *passphrase = NULL);
+
+After adding the AP's, run by the following function.
+
+.. code-block:: arduino
+
+    uint8_t run(uint32_t connectTimeout=5000);
+
+To see how to use the ``WiFiMulti``, take a look at the ``WiFiMulti.ino`` example available.
+
+WiFiScan
+--------
+
+To perform the Wi-Fi scan for networks, you can use the following functions:
+
+Start scan WiFi networks available.
+
+.. code-block:: arduino
+
+    int16_t scanNetworks(bool async = false, bool show_hidden = false, bool passive = false, uint32_t max_ms_per_chan = 300, uint8_t channel = 0);
+
+Called to get the scan state in Async mode.
+
+.. code-block:: arduino
+
+    int16_t scanComplete();
+
+Delete last scan result from RAM.
+
+.. code-block:: arduino
+
+    void scanDelete();
+
+Loads all infos from a scanned wifi in to the ptr parameters.
+
+.. code-block:: arduino
+
+    bool getNetworkInfo(uint8_t networkItem, String &ssid, uint8_t &encryptionType, int32_t &RSSI, uint8_t* &BSSID, int32_t &channel);
+
+To see how to use the ``WiFiScan``, take a look at the ``WiFiScan.ino`` example available.
+
+Examples
+--------
+
+.. _ap example:
+
+Wi-Fi AP Example
+****************
+
+.. literalinclude:: ../../../libraries/WiFi/examples/WiFiAccessPoint/WiFiAccessPoint.ino
+    :language: arduino
+
+.. _sta example:
+
+Wi-Fi STA Example
+*****************
+
+.. literalinclude:: ../../../libraries/WiFi/examples/WiFiClient/WiFiClient.ino
+    :language: arduino
+
+References
+----------

docs/source/boards/ESP32-C3-DevKitM-1.rst

@@ -0,0 +1,120 @@
+##################
+ESP32-C3-DevKitM-1
+##################
+
+The ESP32-C3-DevKitM-1 development board is one of Espressif's official boards. This board is based on the `ESP32-C3-MINI-1`_ module, with the `ESP32-C3`_ as the core.
+
+Specifications
+--------------
+
+- Small­ sized 2.4 GHz Wi­Fi (802.11 b/g/n) and Bluetooth® 5 module
+- Built around ESP32­C3 series of SoCs, RISC­V single­core microprocessor
+- 4 MB flash in chip package
+- 15 available GPIOs (module)
+- Peripherals
+    - 22 × programmable GPIOs
+    - Digital interfaces:
+    - 3 × SPI
+    - 2 × UART
+    - 1 × I2C
+    - 1 × I2S
+    - Remote control peripheral, with 2 transmit channels and 2 receive channels
+    - LED PWM controller, with up to 6 channels
+    - Full-speed USB Serial/JTAG controller
+    - General DMA controller (GDMA), with 3 transmit channels and 3 receive channels
+    - 1 × TWAI® controller (compatible with ISO 11898-1)
+    - Analog interfaces:
+        - 2 × 12-bit SAR ADCs, up to 6 channels
+        - 1 × temperature sensor
+    - Timers:
+        - 2 × 54-bit general-purpose timers
+        - 3 × watchdog timers
+        - 1 × 52-bit system timer
+- On­board PCB antenna or external antenna connector
+
+Header Block
+------------
+
+.. note::
+    Not all of the chip pins are exposed to the pin headers.
+
+J1
+^^^
+===  ====  ==========  ===================================
+No.  Name  Type [1]_   Function
+===  ====  ==========  ===================================
+1    GND   G           Ground
+2    3V3   P           3.3 V power supply
+3    3V3   P           3.3 V power supply
+4    IO2   I/O/T       GPIO2 [2]_, ADC1_CH2, FSPIQ
+5    IO3   I/O/T       GPIO3, ADC1_CH3
+6    GND   G           Ground
+7    RST   I           CHIP_PU
+8    GND   G           Ground
+9    IO0   I/O/T       GPIO0, ADC1_CH0, XTAL_32K_P
+10   IO1   I/O/T       GPIO1, ADC1_CH1, XTAL_32K_N
+11   IO10  I/O/T       GPIO10, FSPICS0
+12   GND   G           Ground
+13   5V    P           5 V power supply
+14   5V    P           5 V power supply
+15   GND   G           Ground
+===  ====  ==========  ===================================
+
+J3
+^^^
+===  ====  ==========  ====================================
+No.  Name  Type [1]_   Function
+===  ====  ==========  ====================================
+1    GND   G           Ground
+2    TX    I/O/T       GPIO21, U0TXD
+3    RX    I/O/T       GPIO20, U0RXD
+4    GND   G           Ground
+5    IO9   I/O/T       GPIO9 [2]_
+6    IO8   I/O/T       GPIO8 [2]_, RGB LED
+7    GND   G           Ground
+8    IO7   I/O/T       GPIO7, FSPID, MTDO
+9    IO6   I/O/T       GPIO6, FSPICLK, MTCK
+10   IO5   I/O/T       GPIO5, ADC2_CH0, FSPIWP, MTDI
+11   IO4   I/O/T       GPIO4, ADC1_CH4, FSPIHD, MTMS
+12   GND   G           Ground
+13   IO18  I/O/T       GPIO18, USB_D-
+14   IO19  I/O/T       GPIO19, USB_D+
+15   GND   G           Ground
+===  ====  ==========  ====================================
+
+.. [1] P: Power supply; I: Input; O: Output; T: High impedance.
+.. [2] GPIO2, GPIO8, and GPIO9 are strapping pins of the ESP32-C3FN4 chip. During the chip's system reset, the latches of the strapping pins sample the voltage level as strapping bits, and hold these bits until the chip is powered down or shut down. 
+
+Pin Layout
+----------
+
+.. figure:: ../_static/esp32-c3_devkitM-1_pinlayout.png
+    :align: center
+    :width: 600
+    :alt: ESP32-C3-DevKitM-1 (click to enlarge)
+    :figclass: align-center
+
+Strapping Pins
+--------------
+
+Some of the GPIO's have important features during the booting process. Here is the list of the strapping pins on the `ESP32-C3`_.
+
+====  =========  =====================================================================  ================  =================
+GPIO   Default    Function                                                               Pull-up          Pull-down
+====  =========  =====================================================================  ================  =================
+IO2   N/A        Booting Mode                                                           See `ESP32-C3`_   See `ESP32-C3`_
+IO9   Pull-up    Booting Mode                                                           SPI Boot          Download Boot
+IO8   N/A        Booting Mode                                                           Don't Care        Download Boot
+IO8   Pull-up    Enabling/Disabling Log Print                                           See `ESP32-C3`_   See `ESP32-C3`_
+====  =========  =====================================================================  ================  =================
+
+For more detailed information, see the `ESP32-C3`_ datasheet.
+
+Resources
+---------
+
+* `ESP32-C3`_ (Datasheet)
+* `ESP32-C3-MINI-1`_ (Datasheet)
+
+.. _ESP32-C3: https://www.espressif.com/sites/default/files/documentation/esp32-c3_datasheet_en.pdf
+.. _ESP32-C3-MINI-1: https://www.espressif.com/sites/default/files/documentation/esp32-c3-mini-1_datasheet_en.pdf