Adding LITTLEFS after esp_littlefs (IDF) is built-in (#4483)

Tools idea: https://github.com/lorol/arduino-esp32fs-plugin

.github/scripts/install-arduino-ide.sh

@@ -98,8 +98,8 @@ function build_sketch(){ # build_sketch <fqbn> <path-to-ino> [extra-options]
 		win_opts="-prefs=runtime.tools.ctags.path=$ARDUINO_IDE_PATH/tools-builder/ctags/$ctags_version -prefs=runtime.tools.arduino-preprocessor.path=$ARDUINO_IDE_PATH/tools-builder/arduino-preprocessor/$preprocessor_version"
 	fi
 
-	#echo ""
-	#echo "Compiling '"$(basename "$sketch")"' ..."
+	echo ""
+	echo "Compiling '"$(basename "$sketch")"' ..."
 	mkdir -p "$ARDUINO_BUILD_DIR"
 	mkdir -p "$ARDUINO_CACHE_DIR"
 	$ARDUINO_IDE_PATH/arduino-builder -compile -logger=human -core-api-version=10810 \
@@ -131,14 +131,14 @@ function count_sketches() # count_sketches <examples-path> <target-mcu>
         local sketchdir=$(dirname $sketch)
         local sketchdirname=$(basename $sketchdir)
         local sketchname=$(basename $sketch)
-        if [[ "$sketchdirname.ino" != "$sketchname" ]]; then
+        if [[ "${sketchdirname}.ino" != "$sketchname" ]]; then
             continue
-        elif [[ -f "$sketchdir/.skip.$target" ]]; then
+        fi;
+        if [[ -f "$sketchdir/.skip.$target" ]]; then
             continue
-        else
-        	echo $sketch >> sketches.txt
-        	sketchnum=$(($sketchnum + 1))
         fi
+        echo $sketch >> sketches.txt
+        sketchnum=$(($sketchnum + 1))
     done
     return $sketchnum
 }
@@ -168,13 +168,13 @@ function build_sketches() # build_sketches <fqbn> <target-mcu> <examples-path> <
 		echo "ERROR: Chunks count must be positive number"
 		return 1
 	fi
-	if [ "$chunk_idex" -ge "$chunks_num" ] && [ "$chunks_num" -ge 2 ]; then
+	if [ "$chunk_idex" -ge "$chunks_num" ]; then
 		echo "ERROR: Chunk index must be less than chunks count"
 		return 1
 	fi
 
 	set +e
-    count_sketches "$examples" "$target"
+    count_sketches "$examples"
     local sketchcount=$?
 	set -e
     local sketches=$(cat sketches.txt)
@@ -186,27 +186,19 @@ function build_sketches() # build_sketches <fqbn> <target-mcu> <examples-path> <
     	chunk_size=$(( $chunk_size + 1 ))
     fi
 
-    local start_index=0
-    local end_index=0
-    if [ "$chunk_idex" -ge "$chunks_num" ]; then
-    	start_index=$chunk_idex
-    	end_index=$sketchcount
-    else
-	    start_index=$(( $chunk_idex * $chunk_size ))
-	    if [ "$sketchcount" -le "$start_index" ]; then
-	    	echo "Skipping job"
-	    	return 0
-	    fi
+    local start_index=$(( $chunk_idex * $chunk_size ))
+    if [ "$sketchcount" -le "$start_index" ]; then
+    	echo "Skipping job"
+    	return 0
+    fi
 
-	    end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size ))
-	    if [ "$end_index" -gt "$sketchcount" ]; then
-	    	end_index=$sketchcount
-	    fi
-	fi
+    local end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size ))
+    if [ "$end_index" -gt "$sketchcount" ]; then
+    	end_index=$sketchcount
+    fi
 
     local start_num=$(( $start_index + 1 ))
-    echo "Found $sketchcount Sketches for target '$target'";
-    echo "Chunk Index : $chunk_idex"
+    echo "Found $sketchcount Sketches";
     echo "Chunk Count : $chunks_num"
     echo "Chunk Size  : $chunk_size"
     echo "Start Sketch: $start_num"
@@ -226,8 +218,6 @@ function build_sketches() # build_sketches <fqbn> <target-mcu> <examples-path> <
         || [ "$sketchnum" -gt "$end_index" ]; then
         	continue
         fi
-        echo ""
-        echo "Building Sketch Index $(($sketchnum - 1)) - $sketchdirname"
         build_sketch "$fqbn" "$sketch" "$xtra_opts"
         local result=$?
         if [ $result -ne 0 ]; then

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

@@ -1,43 +1,19 @@
 #!/bin/bash
 
 export PLATFORMIO_ESP32_PATH="$HOME/.platformio/packages/framework-arduinoespressif32"
-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"
+PLATFORMIO_ESP32_URL="https://github.com/platformio/platform-espressif32.git#feature/idf-v4.0"
 
 echo "Installing Python Wheel ..."
 pip install wheel > /dev/null 2>&1
 
 echo "Installing PlatformIO ..."
-pip install -U https://github.com/platformio/platformio/archive/master.zip > /dev/null 2>&1
+pip install -U https://github.com/platformio/platformio/archive/develop.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 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"
+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'] = '*'; del data['packages']['framework-arduinoespressif32']['owner']; fp.seek(0); fp.truncate(); json.dump(data, fp); fp.close()"
 
 if [ "$GITHUB_REPOSITORY" == "espressif/arduino-esp32" ];  then
 	echo "Linking Core..."

.github/scripts/on-pages.sh

@@ -85,59 +85,47 @@ function git_safe_upload_to_pages(){
     return $?
 }
 
-git_safe_upload_to_pages "index.md" "README.md"
+EVENT_JSON=`cat $GITHUB_EVENT_PATH`
 
-# 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[]'`
+pages_modified=`echo "$EVENT_JSON" | jq -r '.commits[].modified[]'`
+pages_removed=`echo "$EVENT_JSON" | jq -r '.commits[].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_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
+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/scripts/on-push.sh

@@ -24,7 +24,7 @@ BUILD_PIO=0
 if [ "$#" -lt 2 ] || [ "$CHUNKS_CNT" -le 0 ]; then
 	CHUNK_INDEX=0
 	CHUNKS_CNT=1
-elif [ "$CHUNK_INDEX" -gt "$CHUNKS_CNT" ] &&  [ "$CHUNKS_CNT" -ge 2 ]; then
+elif [ "$CHUNK_INDEX" -gt "$CHUNKS_CNT" ]; then
 	CHUNK_INDEX=$CHUNKS_CNT
 elif [ "$CHUNK_INDEX" -eq "$CHUNKS_CNT" ]; then
 	BUILD_PIO=1
@@ -69,19 +69,6 @@ if [ "$BUILD_PIO" -eq 0 ]; then
 	else
 		build_sketches "$FQBN" "$TARGET" "$ARDUINO_ESP32_PATH/libraries" "$CHUNK_INDEX" "$CHUNKS_CNT"
     fi
-
-	# ArduinoIDE ESP32C3 Test
-    TARGET="esp32c3"
-	FQBN="espressif:esp32:esp32c3:PartitionScheme=huge_app"
-	if [ "$OS_IS_WINDOWS" == "1" ]; then
-		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFi/examples/WiFiClient/WiFiClient.ino" && \
-		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino"
-	elif [ "$OS_IS_MACOS" == "1" ]; then
-		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFi/examples/WiFiClient/WiFiClient.ino" && \
-		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino"
-	else
-		build_sketches "$FQBN" "$TARGET" "$ARDUINO_ESP32_PATH/libraries" "$CHUNK_INDEX" "$CHUNKS_CNT"
-    fi
 else
 	source ./.github/scripts/install-platformio-esp32.sh
 	# PlatformIO ESP32 Test

.github/scripts/on-release.sh

@@ -183,7 +183,6 @@ cp -f  "$GITHUB_WORKSPACE/tools/gen_esp32part.py"  "$PKG_DIR/tools/"
 cp -f  "$GITHUB_WORKSPACE/tools/gen_esp32part.exe" "$PKG_DIR/tools/"
 cp -Rf "$GITHUB_WORKSPACE/tools/partitions"        "$PKG_DIR/tools/"
 cp -Rf "$GITHUB_WORKSPACE/tools/sdk"               "$PKG_DIR/tools/"
-cp -f  $GITHUB_WORKSPACE/tools/platformio-build*.py "$PKG_DIR/tools/"
 
 # Remove unnecessary files in the package folder
 echo "Cleaning up folders ..."
@@ -195,7 +194,6 @@ echo "Generating platform.txt..."
 cat "$GITHUB_WORKSPACE/platform.txt" | \
 sed "s/version=.*/version=$ver$extent/g" | \
 sed 's/runtime.tools.xtensa-esp32-elf-gcc.path={runtime.platform.path}\/tools\/xtensa-esp32-elf//g' | \
-sed 's/runtime.tools.xtensa-esp32s2-elf-gcc.path={runtime.platform.path}\/tools\/xtensa-esp32s2-elf//g' | \
 sed 's/tools.esptool_py.path={runtime.platform.path}\/tools\/esptool/tools.esptool_py.path=\{runtime.tools.esptool_py.path\}/g' \
  > "$PKG_DIR/platform.txt"
 
@@ -256,30 +254,17 @@ releasesJson=`curl -sH "Authorization: token $GITHUB_TOKEN" "https://api.github.
 if [ $? -ne 0 ]; then echo "ERROR: Get Releases Failed! ($?)"; exit 1; fi
 
 set +e
-prev_release=$(echo "$releasesJson" | jq -e -r ". | map(select(.draft == false and .prerelease == false)) | sort_by(.published_at | - fromdateiso8601) | .[0].tag_name")
-prev_any_release=$(echo "$releasesJson" | jq -e -r ". | map(select(.draft == false)) | sort_by(.published_at | - fromdateiso8601)  | .[0].tag_name")
-prev_branch_release=$(echo "$releasesJson" | jq -e -r ". | map(select(.draft == false and .prerelease == false and .target_commitish == \"$RELEASE_BRANCH\")) | sort_by(.published_at | - fromdateiso8601)  | .[0].tag_name")
-prev_branch_any_release=$(echo "$releasesJson" | jq -e -r ". | map(select(.draft == false and .target_commitish == \"$RELEASE_BRANCH\")) | sort_by(.published_at | - fromdateiso8601)  | .[0].tag_name")
+prev_release=$(echo "$releasesJson" | jq -e -r '. | map(select(.draft == false and .prerelease == false)) | sort_by(.created_at | - fromdateiso8601) | .[0].tag_name')
+prev_any_release=$(echo "$releasesJson" | jq -e -r '. | map(select(.draft == false)) | sort_by(.created_at | - fromdateiso8601)  | .[0].tag_name')
 shopt -s nocasematch
-if [ "$prev_release" == "$RELEASE_TAG" ]; then
-    prev_release=$(echo "$releasesJson" | jq -e -r ". | map(select(.draft == false and .prerelease == false)) | sort_by(.published_at | - fromdateiso8601) | .[1].tag_name")
-fi
 if [ "$prev_any_release" == "$RELEASE_TAG" ]; then
-    prev_any_release=$(echo "$releasesJson" | jq -e -r ". | map(select(.draft == false)) | sort_by(.published_at | - fromdateiso8601)  | .[1].tag_name")
-fi
-if [ "$prev_branch_release" == "$RELEASE_TAG" ]; then
-    prev_branch_release=$(echo "$releasesJson" | jq -e -r ". | map(select(.draft == false and .prerelease == false and .target_commitish == \"$RELEASE_BRANCH\")) | sort_by(.published_at | - fromdateiso8601)  | .[1].tag_name")
-fi
-if [ "$prev_branch_any_release" == "$RELEASE_TAG" ]; then
-    prev_branch_any_release=$(echo "$releasesJson" | jq -e -r ". | map(select(.draft == false and .target_commitish == \"$RELEASE_BRANCH\")) | sort_by(.published_at | - fromdateiso8601)  | .[1].tag_name")
+    prev_release=$(echo "$releasesJson" | jq -e -r '. | map(select(.draft == false and .prerelease == false)) | sort_by(.created_at | - fromdateiso8601) | .[1].tag_name')
+    prev_any_release=$(echo "$releasesJson" | jq -e -r '. | map(select(.draft == false)) | sort_by(.created_at | - fromdateiso8601)  | .[1].tag_name')
 fi
+COMMITS_SINCE_RELEASE="$prev_any_release"
 shopt -u nocasematch
 set -e
 
-echo "Previous Release: $prev_release"
-echo "Previous (any)release: $prev_any_release"
-echo
-
 # Merge package JSONs with previous releases
 if [ ! -z "$prev_any_release" ] && [ "$prev_any_release" != "null" ]; then
     echo "Merging with JSON from $prev_any_release ..."
@@ -287,12 +272,17 @@ if [ ! -z "$prev_any_release" ] && [ "$prev_any_release" != "null" ]; then
 fi
 
 if [ "$RELEASE_PRE" == "false" ]; then
+    COMMITS_SINCE_RELEASE="$prev_release"
     if [ ! -z "$prev_release" ] && [ "$prev_release" != "null" ]; then
         echo "Merging with JSON from $prev_release ..."
         merge_package_json "$prev_release/$PACKAGE_JSON_REL" "$OUTPUT_DIR/$PACKAGE_JSON_REL"
     fi
 fi
 
+echo "Previous Release: $prev_release"
+echo "Previous (any)release: $prev_any_release"
+echo
+
 # Upload package JSONs
 echo "Uploading $PACKAGE_JSON_DEV ..."
 echo "Download URL: "`git_safe_upload_asset "$OUTPUT_DIR/$PACKAGE_JSON_DEV"`
@@ -337,35 +327,21 @@ if [ $arrLen > 3 ] && [ "${msgArray[0]:0:3}" == "tag" ]; then
 fi
 
 # Append Commit Messages
-echo
-echo "Previous Branch Release: $prev_branch_release"
-echo "Previous Branch (any)release: $prev_branch_any_release"
-echo
-commitFile="$OUTPUT_DIR/commits.txt"
-COMMITS_SINCE_RELEASE="$prev_branch_any_release"
-if [ "$RELEASE_PRE" == "false" ]; then
-    COMMITS_SINCE_RELEASE="$prev_branch_release"
-fi
 if [ ! -z "$COMMITS_SINCE_RELEASE" ] && [ "$COMMITS_SINCE_RELEASE" != "null" ]; then
     echo "Getting commits since $COMMITS_SINCE_RELEASE ..."
-    git -C "$GITHUB_WORKSPACE" log --oneline -n 500 "$COMMITS_SINCE_RELEASE..HEAD" > "$commitFile"
-elif [ "$RELEASE_BRANCH" != "master" ]; then
-    echo "Getting all commits on branch '$RELEASE_BRANCH' ..."
-    git -C "$GITHUB_WORKSPACE" log --oneline -n 500 --cherry-pick --left-only --no-merges HEAD...origin/master > "$commitFile"
-else
-    echo "Getting all commits on master ..."
-    git -C "$GITHUB_WORKSPACE" log --oneline -n 500 --no-merges > "$commitFile"
+    commitFile=$OUTPUT_DIR/commits.txt
+    git -C "$GITHUB_WORKSPACE" log --oneline $COMMITS_SINCE_RELEASE.. > "$OUTPUT_DIR/commits.txt"
+    releaseNotes+=$'\r\n##### Commits\r\n'
+    IFS=$'\n'
+    for next in `cat $commitFile`
+    do
+        IFS=' ' read -r commitId commitMsg <<< "$next"
+        commitLine="- [$commitId](https://github.com/$GITHUB_REPOSITORY/commit/$commitId) $commitMsg"
+        releaseNotes+="$commitLine"
+        releaseNotes+=$'\r\n'
+    done
+    rm -f $commitFile
 fi
-releaseNotes+=$'\r\n##### Commits\r\n'
-IFS=$'\n'
-for next in `cat $commitFile`
-do
-    IFS=' ' read -r commitId commitMsg <<< "$next"
-    commitLine="- [$commitId](https://github.com/$GITHUB_REPOSITORY/commit/$commitId) $commitMsg"
-    releaseNotes+="$commitLine"
-    releaseNotes+=$'\r\n'
-done
-rm -f $commitFile
 
 # Prepend the original release body
 if [ "${RELEASE_BODY: -1}" == $'\r' ]; then         

.github/stale.yml

@@ -12,9 +12,12 @@ onlyLabels: []
 
 # Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
 exemptLabels:
-  - "Type: For reference"
-  - "Type: To be implemented"
-  - "Type: Feature request"
+  - pinned
+  - security
+  - "to be implemented"
+  - "for reference"
+  - "move to PR"
+  - "enhancement"
 
 # Set to true to ignore issues in a project (defaults to false)
 exemptProjects: false
@@ -26,7 +29,7 @@ exemptMilestones: false
 exemptAssignees: false
 
 # Label to use when marking as stale
-staleLabel: "Status: Stale"
+staleLabel: stale
 
 # Comment to post when marking as stale. Set to `false` to disable
 markComment: >

.github/workflows/gh-pages.yml

@@ -4,11 +4,9 @@ on:
   push:
     branches:
     - master
-    - pages
     paths:
     - 'README.md'
-    - '.github/scripts/on-pages.sh'
-    - '.github/workflows/gh-pages.yml'
+    - 'docs/**'
 
 jobs:
 

.github/workflows/release.yml

@@ -11,8 +11,6 @@ jobs:
 
     steps:
     - uses: actions/checkout@master
-      with:
-        fetch-depth: 0
     - uses: actions/setup-python@v1
       with:
         python-version: '3.x'

.gitignore

@@ -1,12 +1,10 @@
 tools/xtensa-esp32-elf
 tools/xtensa-esp32s2-elf
-tools/riscv32-esp-elf
 tools/dist
 tools/esptool
 tools/esptool.exe
-tools/mkspiffs
-tools/mklittlefs
-tools/mkfatfs.exe
+tools/mkspiffs/mkspiffs
+tools/mkspiffs/mkspiffs.exe
 .DS_Store
  
 #Ignore files built by Visual Studio/Visual Micro
@@ -18,6 +16,3 @@ __vm/
 .vscode/
 platform.sloeber.txt
 boards.sloeber.txt
-
-# Ignore docs build (Sphinx)
-docs/build

CMakeLists.txt

@@ -44,9 +44,6 @@ set(LIBRARY_SRCS
   libraries/ArduinoOTA/src/ArduinoOTA.cpp
   libraries/AsyncUDP/src/AsyncUDP.cpp
   libraries/BluetoothSerial/src/BluetoothSerial.cpp
-  libraries/BluetoothSerial/src/BTAddress.cpp
-  libraries/BluetoothSerial/src/BTAdvertisedDeviceSet.cpp
-  libraries/BluetoothSerial/src/BTScanResultsSet.cpp
   libraries/DNSServer/src/DNSServer.cpp
   libraries/EEPROM/src/EEPROM.cpp
   libraries/ESPmDNS/src/ESPmDNS.cpp
@@ -55,14 +52,9 @@ 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
-  libraries/RainMaker/src/RMakerNode.cpp
-  libraries/RainMaker/src/RMakerParam.cpp
-  libraries/RainMaker/src/RMakerDevice.cpp
-  libraries/RainMaker/src/RMakerType.cpp
   libraries/SD_MMC/src/SD_MMC.cpp
   libraries/SD/src/SD.cpp
   libraries/SD/src/sd_diskio.cpp
@@ -72,7 +64,6 @@ set(LIBRARY_SRCS
   libraries/SPI/src/SPI.cpp
   libraries/Ticker/src/Ticker.cpp
   libraries/Update/src/Updater.cpp
-  libraries/Update/src/HttpsOTAUpdate.cpp
   libraries/WebServer/src/WebServer.cpp
   libraries/WebServer/src/Parsing.cpp
   libraries/WebServer/src/detail/mimetable.cpp
@@ -84,11 +75,11 @@ set(LIBRARY_SRCS
   libraries/WiFi/src/WiFi.cpp
   libraries/WiFi/src/WiFiGeneric.cpp
   libraries/WiFi/src/WiFiMulti.cpp
+  libraries/WiFi/src/WiFiProv.cpp
   libraries/WiFi/src/WiFiScan.cpp
   libraries/WiFi/src/WiFiServer.cpp
   libraries/WiFi/src/WiFiSTA.cpp
   libraries/WiFi/src/WiFiUdp.cpp
-  libraries/WiFiProv/src/WiFiProv.cpp
   libraries/Wire/src/Wire.cpp
   )
 
@@ -126,7 +117,7 @@ set(BLE_SRCS
 
 
 set(includedirs
-  variants/${IDF_TARGET}/
+  variants/esp32/
   cores/esp32/
   libraries/ArduinoOTA/src
   libraries/AsyncUDP/src
@@ -140,10 +131,9 @@ 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
   libraries/SD_MMC/src
   libraries/SD/src
   libraries/SimpleBLE/src
@@ -154,57 +144,19 @@ set(includedirs
   libraries/WebServer/src
   libraries/WiFiClientSecure/src
   libraries/WiFi/src
-  libraries/WiFiProv/src
   libraries/Wire/src
   )
 
 set(srcs ${CORE_SRCS} ${LIBRARY_SRCS} ${BLE_SRCS})
 set(priv_includes cores/esp32/libb64)
-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)
+set(requires spi_flash mbedtls mdns esp_adc_cal)
+set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support openssl bt tinyusb main)
 
 idf_component_register(INCLUDE_DIRS ${includedirs} PRIV_INCLUDE_DIRS ${priv_includes} SRCS ${srcs} REQUIRES ${requires} PRIV_REQUIRES ${priv_requires})
 
-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")
+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)
 endif()
-
-# 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)
+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)
 endif()

CONTRIBUTING.rst

@@ -1,50 +0,0 @@
-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

Kconfig.projbuild

@@ -40,12 +40,6 @@ config ARDUINO_RUNNING_CORE
     default 1 if ARDUINO_RUN_CORE1
     default -1 if ARDUINO_RUN_NO_AFFINITY
 
-config ARDUINO_LOOP_STACK_SIZE
-    int "Loop thread stack size"
-    default 8192
-    help
-        Amount of stack available for the Arduino task.
-
 choice ARDUINO_EVENT_RUNNING_CORE
     bool "Core on which Arduino's event handler is running"
     default ARDUINO_EVENT_RUN_CORE1
@@ -82,12 +76,6 @@ choice ARDUINO_UDP_RUNNING_CORE
 
 endchoice
 
-config ARDUINO_UDP_TASK_PRIORITY
-    int "Priority of the UDP task"
-    default 3
-    help
-        Select at what priority you want the UDP task to run.
-
 config ARDUINO_UDP_RUNNING_CORE
     int
     default 0 if ARDUINO_UDP_RUN_CORE0
@@ -271,12 +259,6 @@ config ARDUINO_SELECTIVE_HTTPClient
     select ARDUINO_SELECTIVE_WiFiClientSecure
     default y
 
-config ARDUINO_SELECTIVE_LITTLEFS
-    bool "Enable LITTLEFS"
-    depends on ARDUINO_SELECTIVE_COMPILATION
-    select ARDUINO_SELECTIVE_FS
-    default y
-
 config ARDUINO_SELECTIVE_NetBIOS
     bool "Enable NetBIOS"
     depends on ARDUINO_SELECTIVE_COMPILATION
@@ -343,12 +325,6 @@ config ARDUINO_SELECTIVE_WiFiClientSecure
     select ARDUINO_SELECTIVE_WiFi
     default y
 
-config ARDUINO_SELECTIVE_WiFiProv
-    bool "Enable WiFiProv"
-    depends on ARDUINO_SELECTIVE_COMPILATION
-    select ARDUINO_SELECTIVE_WiFi
-    default y
-
 config ARDUINO_SELECTIVE_Wire
     bool "Enable Wire"
     depends on ARDUINO_SELECTIVE_COMPILATION

README.md

@@ -1,42 +1,33 @@
 # 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) [![Documentation Status](https://readthedocs.com/projects/espressif-arduino-esp32/badge/?version=latest)](https://docs.espressif.com/projects/arduino-esp32/en/latest/?badge=latest)
+[![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)
 
 ### 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)
-
-### 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.
+- [ESP32Dev Board PINMAP](#esp32dev-board-pinmap)
 
 ### Development Status
+[Latest stable release ![Release Version](https://img.shields.io/github/release/espressif/arduino-esp32.svg?style=plastic) ![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)
 
-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 ![Development Version](https://img.shields.io/github/release/espressif/arduino-esp32/all.svg?style=plastic) ![Development 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)
 
-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/)
-
-### Documentation
-
-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)
+### 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)
 
 ### Decoding exceptions
 
@@ -45,10 +36,12 @@ 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.
 
-### Contributing
+### ESP32Dev Board PINMAP
 
-We welcome contributions to the Arduino ESP32 project!
+![Pin Functions](docs/esp32_pinmap.png)
 
-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.
+### Tip
+
+Sometimes to program ESP32 via serial you must keep GPIO0 LOW during the programming process

cores/esp32/Arduino.h

@@ -29,7 +29,6 @@
 #include <string.h>
 #include <inttypes.h>
 
-#include "esp_arduino_version.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/semphr.h"
@@ -79,7 +78,7 @@
 #define interrupts() sei()
 #define noInterrupts() cli()
 
-#define clockCyclesPerMicrosecond() ( (long int)getCpuFrequencyMhz() )
+#define clockCyclesPerMicrosecond() ( F_CPU / 1000000L )
 #define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() )
 #define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() )
 
@@ -89,7 +88,7 @@
 #define bitRead(value, bit) (((value) >> (bit)) & 0x01)
 #define bitSet(value, bit) ((value) |= (1UL << (bit)))
 #define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
-#define bitWrite(value, bit, bitvalue) ((bitvalue) ? bitSet(value, bit) : bitClear(value, bit))
+#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))
 
 // avr-libc defines _NOP() since 1.6.2
 #ifndef _NOP
@@ -99,23 +98,13 @@
 #define bit(b) (1UL << (b))
 #define _BV(b) (1UL << (b))
 
-#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 digitalPinToTimer(pin)      (0)
+#define analogInPinToBit(P)         (P)
 #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
@@ -175,7 +164,7 @@ using std::min;
 using ::round;
 
 uint16_t makeWord(uint16_t w);
-uint16_t makeWord(uint8_t h, uint8_t l);
+uint16_t makeWord(byte h, byte l);
 
 #define word(...) makeWord(__VA_ARGS__)
 

cores/esp32/Esp.cpp

@@ -23,6 +23,7 @@
 #include "esp_spi_flash.h"
 #include <memory>
 #include <soc/soc.h>
+#include <soc/efuse_reg.h>
 #include <esp_partition.h>
 extern "C" {
 #include "esp_ota_ops.h"
@@ -34,20 +35,13 @@ extern "C" {
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #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
 
 /**
@@ -248,43 +242,6 @@ uint8_t EspClass::getChipRevision(void)
     return chip_info.revision;
 }
 
-const char * EspClass::getChipModel(void)
-{
-#if CONFIG_IDF_TARGET_ESP32
-    uint32_t chip_ver = REG_GET_FIELD(EFUSE_BLK0_RDATA3_REG, EFUSE_RD_CHIP_VER_PKG);
-    uint32_t pkg_ver = chip_ver & 0x7;
-    switch (pkg_ver) {
-        case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ6 :
-            return "ESP32-D0WDQ6";
-        case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ5 :
-            return "ESP32-D0WDQ5";
-        case EFUSE_RD_CHIP_VER_PKG_ESP32D2WDQ5 :
-            return "ESP32-D2WDQ5";
-        case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD2 :
-            return "ESP32-PICO-D2";
-        case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD4 :
-            return "ESP32-PICO-D4";
-        case EFUSE_RD_CHIP_VER_PKG_ESP32PICOV302 :
-            return "ESP32-PICO-V3-02";
-        default:
-            return "Unknown";
-    }
-#elif CONFIG_IDF_TARGET_ESP32S2
-    return "ESP32-S2";
-#elif CONFIG_IDF_TARGET_ESP32S3
-    return "ESP32-S3";
-#elif CONFIG_IDF_TARGET_ESP32C3
-    return "ESP32-C3";
-#endif
-}
-
-uint8_t EspClass::getChipCores(void)
-{
-    esp_chip_info_t chip_info;
-    esp_chip_info(&chip_info);
-    return chip_info.cores;
-}
-
 const char * EspClass::getSdkVersion(void)
 {
     return esp_get_idf_version();
@@ -293,7 +250,7 @@ const char * EspClass::getSdkVersion(void)
 uint32_t EspClass::getFlashChipSize(void)
 {
     esp_image_header_t fhdr;
-    if(flashRead(ESP_FLASH_IMAGE_BASE, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
+    if(flashRead(0x1000, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
         return 0;
     }
     return magicFlashChipSize(fhdr.spi_size);
@@ -302,7 +259,7 @@ uint32_t EspClass::getFlashChipSize(void)
 uint32_t EspClass::getFlashChipSpeed(void)
 {
     esp_image_header_t fhdr;
-    if(flashRead(ESP_FLASH_IMAGE_BASE, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
+    if(flashRead(0x1000, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
         return 0;
     }
     return magicFlashChipSpeed(fhdr.spi_speed);
@@ -311,7 +268,7 @@ uint32_t EspClass::getFlashChipSpeed(void)
 FlashMode_t EspClass::getFlashChipMode(void)
 {
     esp_image_header_t fhdr;
-    if(flashRead(ESP_FLASH_IMAGE_BASE, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
+    if(flashRead(0x1000, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
         return FM_UNKNOWN;
     }
     return magicFlashChipMode(fhdr.spi_mode);
@@ -376,20 +333,6 @@ bool EspClass::flashRead(uint32_t offset, uint32_t *data, size_t size)
     return spi_flash_read(offset, (uint32_t*) data, size) == ESP_OK;
 }
 
-bool EspClass::partitionEraseRange(const esp_partition_t *partition, uint32_t offset, size_t size) 
-{
-    return esp_partition_erase_range(partition, offset, size) == ESP_OK;
-}
-
-bool EspClass::partitionWrite(const esp_partition_t *partition, uint32_t offset, uint32_t *data, size_t size) 
-{
-    return esp_partition_write(partition, offset, data, size) == ESP_OK;
-}
-
-bool EspClass::partitionRead(const esp_partition_t *partition, uint32_t offset, uint32_t *data, size_t size) 
-{
-    return esp_partition_read(partition, offset, data, size) == ESP_OK;
-}
 
 uint64_t EspClass::getEfuseMac(void)
 {

cores/esp32/Esp.h

@@ -21,8 +21,6 @@
 #define ESP_H
 
 #include <Arduino.h>
-#include <esp_partition.h>
-#include <hal/cpu_hal.h>
 
 /**
  * AVR macros for WDT managment
@@ -77,8 +75,6 @@ public:
     uint32_t getMaxAllocPsram();
 
     uint8_t getChipRevision();
-    const char * getChipModel();
-    uint8_t getChipCores();
     uint32_t getCpuFreqMHz(){ return getCpuFrequencyMhz(); }
     inline uint32_t getCycleCount() __attribute__((always_inline));
     const char * getSdkVersion();
@@ -101,17 +97,15 @@ public:
     bool flashWrite(uint32_t offset, uint32_t *data, size_t size);
     bool flashRead(uint32_t offset, uint32_t *data, size_t size);
 
-    bool partitionEraseRange(const esp_partition_t *partition, uint32_t offset, size_t size);
-    bool partitionWrite(const esp_partition_t *partition, uint32_t offset, uint32_t *data, size_t size);
-    bool partitionRead(const esp_partition_t *partition, uint32_t offset, uint32_t *data, size_t size);
-
     uint64_t getEfuseMac();
 
 };
 
 uint32_t ARDUINO_ISR_ATTR EspClass::getCycleCount()
 {
-    return cpu_hal_get_cycle_count();
+    uint32_t ccount;
+    __asm__ __volatile__("esync; rsr %0,ccount":"=a" (ccount));
+    return ccount;
 }
 
 extern EspClass ESP;

cores/esp32/HardwareSerial.cpp

@@ -50,7 +50,7 @@ HardwareSerial Serial2(2);
 
 HardwareSerial::HardwareSerial(int uart_nr) : _uart_nr(uart_nr), _uart(NULL) {}
 
-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)
+void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert, unsigned long timeout_ms)
 {
     if(0 > _uart_nr || _uart_nr > 2) {
         log_e("Serial number is invalid, please use 0, 1 or 2");
@@ -66,9 +66,6 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
 #elif CONFIG_IDF_TARGET_ESP32S2
         rxPin = 44;
         txPin = 43;
-#elif CONFIG_IDF_TARGET_ESP32C3
-        rxPin = 20;
-        txPin = 21;
 #endif
     }
     if(_uart_nr == 1 && rxPin < 0 && txPin < 0) {
@@ -81,9 +78,7 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
         txPin = TX2;
     }
 #endif
-    _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, 256, invert, rxfifo_full_thrhd);
-    _tx_pin = txPin;
-    _rx_pin = rxPin;
+    _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, 256, invert);
 
     if(!baud) {
         uartStartDetectBaudrate(_uart);
@@ -97,12 +92,10 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
 
         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, 256, invert);
         } 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;
         }
     }
 }
@@ -117,9 +110,7 @@ void HardwareSerial::end()
     if(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;
 }
 
@@ -214,8 +205,3 @@ HardwareSerial::operator bool() const
 {
     return true;
 }
-
-void HardwareSerial::setRxInvert(bool invert)
-{
-    uartSetRxInvert(_uart, invert);
-}

cores/esp32/HardwareSerial.h

@@ -55,7 +55,7 @@ class HardwareSerial: public Stream
 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 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);
     void end();
     void updateBaudRate(unsigned long baud);
     int available(void);
@@ -100,14 +100,10 @@ public:
 
     size_t setRxBufferSize(size_t);
     void setDebugOutput(bool);
-    
-    void setRxInvert(bool);
 
 protected:
     int _uart_nr;
     uart_t* _uart;
-    uint8_t _tx_pin;
-    uint8_t _rx_pin;
 };
 
 extern void serialEventRun(void) __attribute__((weak));

cores/esp32/MD5Builder.h

@@ -28,8 +28,6 @@
 #include "esp32/rom/md5_hash.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/md5_hash.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/md5_hash.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif

cores/esp32/Print.cpp

@@ -110,37 +110,24 @@ size_t Print::print(unsigned int n, int base)
 }
 
 size_t Print::print(long n, int base)
-{
-    int t = 0;
-    if (base == 10 && n < 0) {
-        t = print('-');
-        n = -n;
-    }
-    return printNumber(static_cast<unsigned long>(n), base) + t;
-}
-
-size_t Print::print(unsigned long n, int base)
 {
     if(base == 0) {
         return write(n);
+    } else if(base == 10) {
+        if(n < 0) {
+            int t = print('-');
+            n = -n;
+            return printNumber(n, 10) + t;
+        }
+        return printNumber(n, 10);
     } else {
         return printNumber(n, base);
     }
 }
 
-size_t Print::print(long long n, int base)
+size_t Print::print(unsigned long n, int base)
 {
-    int t = 0;
-    if (base == 10 && n < 0) {
-        t = print('-');
-        n = -n;
-    }
-    return printNumber(static_cast<unsigned long long>(n), base) + t;
-}
-
-size_t Print::print(unsigned long long n, int base)
-{
-    if (base == 0) {
+    if(base == 0) {
         return write(n);
     } else {
         return printNumber(n, base);
@@ -239,20 +226,6 @@ size_t Print::println(unsigned long num, int base)
     return n;
 }
 
-size_t Print::println(long long num, int base)
-{
-    size_t n = print(num, base);
-    n += println();
-    return n;
-}
-
-size_t Print::println(unsigned long long num, int base)
-{
-    size_t n = print(num, base);
-    n += println();
-    return n;
-}
-
 size_t Print::println(double num, int digits)
 {
     size_t n = print(num, digits);
@@ -278,7 +251,7 @@ size_t Print::println(struct tm * timeinfo, const char * format)
 
 size_t Print::printNumber(unsigned long n, uint8_t base)
 {
-    char buf[8 * sizeof(n) + 1]; // Assumes 8-bit chars plus zero byte.
+    char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
     char *str = &buf[sizeof(buf) - 1];
 
     *str = '\0';
@@ -289,34 +262,11 @@ size_t Print::printNumber(unsigned long n, uint8_t base)
     }
 
     do {
-        char c = n % base;
-        n /= base;
-
-        *--str = c < 10 ? c + '0' : c + 'A' - 10;
-    } while (n);
-
-    return write(str);
-}
-
-size_t Print::printNumber(unsigned long long n, uint8_t base)
-{
-    char buf[8 * sizeof(n) + 1]; // Assumes 8-bit chars plus zero byte.
-    char* str = &buf[sizeof(buf) - 1];
-
-    *str = '\0';
-
-    // prevent crash if called with base == 1
-    if (base < 2) {
-        base = 10;
-    }
-
-    do {
-        auto m = n;
+        unsigned long m = n;
         n /= base;
         char c = m - base * n;
-
         *--str = c < 10 ? c + '0' : c + 'A' - 10;
-    } while (n);
+    } while(n);
 
     return write(str);
 }

cores/esp32/Print.h

@@ -36,7 +36,6 @@ class Print
 private:
     int write_error;
     size_t printNumber(unsigned long, uint8_t);
-    size_t printNumber(unsigned long long, uint8_t);
     size_t printFloat(double, uint8_t);
 protected:
     void setWriteError(int err = 1)
@@ -73,11 +72,6 @@ public:
     }
 
     size_t printf(const char * format, ...)  __attribute__ ((format (printf, 2, 3)));
-
-    // add availableForWrite to make compatible with Arduino Print.h
-    // default to zero, meaning "a single write may block"
-    // should be overriden by subclasses with buffering
-    virtual int availableForWrite() { return 0; }
     size_t print(const __FlashStringHelper *);
     size_t print(const String &);
     size_t print(const char[]);
@@ -87,8 +81,6 @@ public:
     size_t print(unsigned int, int = DEC);
     size_t print(long, int = DEC);
     size_t print(unsigned long, int = DEC);
-    size_t print(long long, int = DEC);
-    size_t print(unsigned long long, int = DEC);
     size_t print(double, int = 2);
     size_t print(const Printable&);
     size_t print(struct tm * timeinfo, const char * format = NULL);
@@ -102,8 +94,6 @@ public:
     size_t println(unsigned int, int = DEC);
     size_t println(long, int = DEC);
     size_t println(unsigned long, int = DEC);
-    size_t println(long long, int = DEC);
-    size_t println(unsigned long long, int = DEC);
     size_t println(double, int = 2);
     size_t println(const Printable&);
     size_t println(struct tm * timeinfo, const char * format = NULL);

cores/esp32/Stream.cpp

@@ -87,22 +87,22 @@ unsigned long Stream::getTimeout(void) {
 }
 
 // find returns true if the target string is found
-bool  Stream::find(const char *target)
+bool Stream::find(const char *target)
 {
-  return findUntil(target, strlen(target), NULL, 0);
+    return findUntil(target, (char*) "");
 }
 
 // reads data from the stream until the target string of given length is found
 // returns true if target string is found, false if timed out
 bool Stream::find(const char *target, size_t length)
 {
-  return findUntil(target, length, NULL, 0);
+    return findUntil(target, length, NULL, 0);
 }
 
 // as find but search ends if the terminator string is found
-bool  Stream::findUntil(const char *target, const char *terminator)
+bool Stream::findUntil(const char *target, const char *terminator)
 {
-  return findUntil(target, strlen(target), terminator, strlen(terminator));
+    return findUntil(target, strlen(target), terminator, strlen(terminator));
 }
 
 // reads data from the stream until the target string of the given length is found
@@ -110,78 +110,35 @@ bool  Stream::findUntil(const char *target, const char *terminator)
 // returns true if target string is found, false if terminated or timed out
 bool Stream::findUntil(const char *target, size_t targetLen, const char *terminator, size_t termLen)
 {
-  if (terminator == NULL) {
-    MultiTarget t[1] = {{target, targetLen, 0}};
-    return findMulti(t, 1) == 0 ? true : false;
-  } else {
-    MultiTarget t[2] = {{target, targetLen, 0}, {terminator, termLen, 0}};
-    return findMulti(t, 2) == 0 ? true : false;
-  }
-}
+    size_t index = 0;  // maximum target string length is 64k bytes!
+    size_t termIndex = 0;
+    int c;
 
-int Stream::findMulti( struct Stream::MultiTarget *targets, int tCount) {
-  // any zero length target string automatically matches and would make
-  // a mess of the rest of the algorithm.
-  for (struct MultiTarget *t = targets; t < targets+tCount; ++t) {
-    if (t->len <= 0)
-      return t - targets;
-  }
-
-  while (1) {
-    int c = timedRead();
-    if (c < 0)
-      return -1;
-
-    for (struct MultiTarget *t = targets; t < targets+tCount; ++t) {
-      // the simple case is if we match, deal with that first.
-      if (c == t->str[t->index]) {
-        if (++t->index == t->len)
-          return t - targets;
-        else
-          continue;
-      }
-
-      // if not we need to walk back and see if we could have matched further
-      // down the stream (ie '1112' doesn't match the first position in '11112'
-      // but it will match the second position so we can't just reset the current
-      // index to 0 when we find a mismatch.
-      if (t->index == 0)
-        continue;
-
-      int origIndex = t->index;
-      do {
-        --t->index;
-        // first check if current char works against the new current index
-        if (c != t->str[t->index])
-          continue;
-
-        // if it's the only char then we're good, nothing more to check
-        if (t->index == 0) {
-          t->index++;
-          break;
-        }
-
-        // otherwise we need to check the rest of the found string
-        int diff = origIndex - t->index;
-        size_t i;
-        for (i = 0; i < t->index; ++i) {
-          if (t->str[i] != t->str[i + diff])
-            break;
-        }
-
-        // if we successfully got through the previous loop then our current
-        // index is good.
-        if (i == t->index) {
-          t->index++;
-          break;
-        }
-
-        // otherwise we just try the next index
-      } while (t->index);
+    if(*target == 0) {
+        return true;    // return true if target is a null string
     }
-  }
-  // unreachable
-  return -1;
+    while((c = timedRead()) > 0) {
+
+        if(c != target[index]) {
+            index = 0;    // reset index if any char does not match
+        }
+
+        if(c == target[index]) {
+            //////Serial.print("found "); Serial.write(c); Serial.print("index now"); Serial.println(index+1);
+            if(++index >= targetLen) { // return true if all chars in the target match
+                return true;
+            }
+        }
+
+        if(termLen > 0 && c == terminator[termIndex]) {
+            if(++termIndex >= termLen) {
+                return false;    // return false if terminate string found before target string
+            }
+        } else {
+            termIndex = 0;
+        }
+    }
+    return false;
 }
 
 // returns the first valid (long) integer value from the current position.

cores/esp32/Stream.h

@@ -60,7 +60,6 @@ public:
 
     void setTimeout(unsigned long timeout);  // sets maximum milliseconds to wait for stream data, default is 1 second
     unsigned long getTimeout(void);
-      
     bool find(const char *target);   // reads data from the stream until the target string is found
     bool find(uint8_t *target)
     {
@@ -124,17 +123,6 @@ protected:
     // this allows format characters (typically commas) in values to be ignored
 
     float parseFloat(char skipChar);  // as above but the given skipChar is ignored
-  
-    struct MultiTarget {
-      const char *str;  // string you're searching for
-      size_t len;       // length of string you're searching for
-      size_t index;     // index used by the search routine.
-    };
-
-  // This allows you to search for an arbitrary number of strings.
-  // Returns index of the target that is found first or -1 if timeout occurs.
-  int findMulti(struct MultiTarget *targets, int tCount);
-
 };
 
 #endif

cores/esp32/USB.cpp

@@ -14,7 +14,7 @@
 #include "esp32-hal.h"
 #include "esp32-hal-tinyusb.h"
 #include "USB.h"
-#if CONFIG_TINYUSB_ENABLED
+#if CONFIG_USB_ENABLED
 
 #ifndef USB_VID
 #define USB_VID USB_ESPRESSIF_VID
@@ -32,7 +32,11 @@
 #define USB_SERIAL "0"
 #endif
 
-#if CFG_TUD_DFU_RUNTIME
+extern "C" {
+#include "tinyusb.h"
+}
+
+#if CFG_TUD_DFU_RT
 static uint16_t load_dfu_descriptor(uint8_t * dst, uint8_t * itf)
 {
 #define DFU_ATTR_CAN_DOWNLOAD              1
@@ -51,11 +55,11 @@ 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_runtime_reboot_to_dfu_cb(void)
+void tud_dfu_rt_reboot_to_dfu(void)
 {
     usb_persist_restart(RESTART_BOOTLOADER_DFU);
 }
-#endif /* CFG_TUD_DFU_RUNTIME */
+#endif /* CFG_TUD_DFU_RT */
 
 ESP_EVENT_DEFINE_BASE(ARDUINO_USB_EVENTS);
 
@@ -121,7 +125,7 @@ ESPUSB::ESPUSB(size_t task_stack_size, uint8_t event_task_priority)
 ,usb_attributes(TUSB_DESC_CONFIG_ATT_SELF_POWERED)
 ,usb_power_ma(500)
 ,webusb_enabled(false)
-,webusb_url("https://espressif.github.io/arduino-esp32/webusb.html")
+,webusb_url("espressif.github.io/arduino-esp32/webusb.html")
 ,_started(false)
 ,_task_stack_size(task_stack_size)
 ,_event_task_priority(event_task_priority)
@@ -183,9 +187,9 @@ ESPUSB::operator bool() const
 }
 
 bool ESPUSB::enableDFU(){
-#if CFG_TUD_DFU_RUNTIME
+#if CFG_TUD_DFU_RT
     return tinyusb_enable_interface(USB_INTERFACE_DFU, TUD_DFU_RT_DESC_LEN, load_dfu_descriptor) == ESP_OK;
-#endif /* CFG_TUD_DFU_RUNTIME */
+#endif /* CFG_TUD_DFU_RT */
     return false;
 }
 
@@ -282,9 +286,6 @@ 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;
 }
@@ -334,4 +335,4 @@ const char * ESPUSB::webUSBURL(void){
 
 ESPUSB USB;
 
-#endif /* CONFIG_TINYUSB_ENABLED */
+#endif /* CONFIG_USB_ENABLED */

cores/esp32/USB.h

@@ -14,7 +14,7 @@
 #pragma once
 
 #include "sdkconfig.h"
-#if CONFIG_TINYUSB_ENABLED
+#if CONFIG_USB_ENABLED
 
 #include "Arduino.h"
 #include "USBCDC.h"
@@ -115,4 +115,4 @@ class ESPUSB {
 
 extern ESPUSB USB;
 
-#endif /* CONFIG_TINYUSB_ENABLED */
+#endif /* CONFIG_USB_ENABLED */

cores/esp32/USBCDC.cpp

@@ -15,12 +15,16 @@
 #include "esp32-hal-tinyusb.h"
 #include "USB.h"
 #include "USBCDC.h"
-#if CONFIG_TINYUSB_ENABLED
+#if CONFIG_USB_ENABLED
 
 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);
 
+extern "C" {
+#include "tinyusb.h"
+}
+
 #if CFG_TUD_CDC
 #define MAX_USB_CDC_DEVICES 2
 USBCDC * devices[MAX_USB_CDC_DEVICES] = {NULL, NULL};
@@ -38,46 +42,27 @@ 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)
 {
-    //isr_log_v("itf: %u, dtr: %u, rts: %u", itf, dtr, rts);
     if(itf < MAX_USB_CDC_DEVICES && devices[itf] != NULL){
         devices[itf]->_onLineState(dtr, 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)
 {
-    //isr_log_v("itf: %u, bit_rate: %u, data_bits: %u, stop_bits: %u, parity: %u", itf, p_line_coding->bit_rate, p_line_coding->data_bits, p_line_coding->stop_bits, p_line_coding->parity);
     if(itf < MAX_USB_CDC_DEVICES && devices[itf] != NULL){
         devices[itf]->_onLineCoding(p_line_coding->bit_rate, p_line_coding->stop_bits, p_line_coding->parity, p_line_coding->data_bits);
     }
 }
 
-// Invoked when received new data
 void tud_cdc_rx_cb(uint8_t itf)
 {
-    //isr_log_v("itf: %u", itf);
     if(itf < MAX_USB_CDC_DEVICES && devices[itf] != NULL){
         devices[itf]->_onRX();
     }
 }
 
-// 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){
-    //isr_log_v("itf: %u", itf);
-    if(itf < MAX_USB_CDC_DEVICES && devices[itf] != 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){
@@ -103,7 +88,6 @@ 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;
 }
@@ -123,7 +107,6 @@ USBCDC::USBCDC(uint8_t itfn) : itf(itfn), bit_rate(0), stop_bits(0), parity(0),
     tinyusb_enable_interface(USB_INTERFACE_CDC, TUD_CDC_DESC_LEN, load_cdc_descriptor);
     if(itf < MAX_USB_CDC_DEVICES){
         devices[itf] = this;
-        tx_sem = NULL;
         arduino_usb_event_handler_register_with(ARDUINO_USB_EVENTS, ARDUINO_USB_STOPPED_EVENT, usb_unplugged_cb, this);
     }
 }
@@ -149,18 +132,10 @@ size_t USBCDC::setRxBufferSize(size_t rx_queue_len){
 void USBCDC::begin(unsigned long baud)
 {
     setRxBufferSize(256);//default if not preset
-    if(tx_sem == NULL){
-        tx_sem = xSemaphoreCreateBinary();
-        xSemaphoreTake(tx_sem, 0);
-    }
 }
 
 void USBCDC::end()
 {
-    if (tx_sem != NULL) {
-        vSemaphoreDelete(tx_sem);
-        tx_sem = NULL;
-    }
 }
 
 void USBCDC::_onUnplugged(void){
@@ -227,27 +202,22 @@ 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){
-        // ArduinoIDE sends LineCoding with 1200bps baud to reset the device
-        if(_bit_rate == 1200){
-            usb_persist_restart(RESTART_BOOTLOADER);
-        } else {
-            bit_rate = _bit_rate;
-            data_bits = _data_bits;
-            stop_bits = _stop_bits;
-            parity = _parity;
-            arduino_usb_cdc_event_data_t p = {0};
-            p.line_coding.bit_rate = bit_rate;
-            p.line_coding.data_bits = data_bits;
-            p.line_coding.stop_bits = stop_bits;
-            p.line_coding.parity = parity;
-            arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_LINE_CODING_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
-        }
+        bit_rate = _bit_rate;
+        data_bits = _data_bits;
+        stop_bits = _stop_bits;
+        parity = _parity;
+        arduino_usb_cdc_event_data_t p = {0};
+        p.line_coding.bit_rate = bit_rate;
+        p.line_coding.data_bits = data_bits;
+        p.line_coding.stop_bits = stop_bits;
+        p.line_coding.parity = parity;
+        arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_LINE_CODING_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
     }
 }
 
 void USBCDC::_onRX(){
-    uint8_t buf[CONFIG_TINYUSB_CDC_RX_BUFSIZE+1];
-    uint32_t count = tud_cdc_n_read(itf, buf, CONFIG_TINYUSB_CDC_RX_BUFSIZE);
+    uint8_t buf[CONFIG_USB_CDC_RX_BUFSIZE+1];
+    uint32_t count = tud_cdc_n_read(itf, buf, CONFIG_USB_CDC_RX_BUFSIZE);
     for(uint32_t i=0; i<count; i++){
         if(rx_queue == NULL || !xQueueSend(rx_queue, buf+i, 0)){
             return;
@@ -258,11 +228,6 @@ 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;
 }
@@ -368,6 +333,6 @@ USBCDC::operator bool() const
 USBCDC Serial(0);
 #endif
 
-#endif /* CONFIG_TINYUSB_CDC_ENABLED */
+#endif /* CONFIG_USB_CDC_ENABLED */
 
-#endif /* CONFIG_TINYUSB_ENABLED */
+#endif /* CONFIG_USB_ENABLED */

cores/esp32/USBCDC.h

@@ -17,7 +17,7 @@
 
 #include "Stream.h"
 #include "esp32-hal.h"
-#if CONFIG_TINYUSB_CDC_ENABLED
+#if CONFIG_USB_CDC_ENABLED
 
 #include "esp_event.h"
 
@@ -30,7 +30,6 @@ 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;
 
@@ -111,9 +110,7 @@ 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;
@@ -133,4 +130,4 @@ protected:
 extern USBCDC Serial;
 #endif
 
-#endif /* CONFIG_TINYUSB_CDC_ENABLED */
+#endif /* CONFIG_USB_CDC_ENABLED */

cores/esp32/Udp.h

@@ -43,7 +43,6 @@ class UDP: public Stream
 
 public:
     virtual uint8_t begin(uint16_t) =0;	// initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
-    virtual uint8_t beginMulticast(IPAddress, uint16_t) { return 0; }  // initialize, start listening on specified multicast IP address and port. Returns 1 if successful, 0 on failure
     virtual void stop() =0;  // Finish with the UDP socket
 
     // Sending UDP packets

cores/esp32/WMath.cpp

@@ -27,7 +27,6 @@ extern "C" {
 #include <stdlib.h>
 #include "esp_system.h"
 }
-#include "esp32-hal-log.h"
 
 void randomSeed(unsigned long seed)
 {
@@ -45,7 +44,7 @@ long random(long howbig)
         uint32_t t = -howbig;
         if (t >= howbig) {
             t -= howbig;
-            if (t >= howbig)
+            if (t >= howbig) 
                 t %= howbig;
         }
         while (l < t) {
@@ -67,22 +66,19 @@ long random(long howsmall, long howbig)
 }
 
 long map(long x, long in_min, long in_max, long out_min, long out_max) {
-    const long dividend = out_max - out_min;
-    const long divisor = in_max - in_min;
-    const long delta = x - in_min;
+    long divisor = (in_max - in_min);
     if(divisor == 0){
-        log_e("Invalid map input range, min == max");
         return -1; //AVR returns -1, SAM returns 0
     }
-    return (delta * dividend + (divisor / 2)) / divisor + out_min;
+    return (x - in_min) * (out_max - out_min) / divisor + out_min;
 }
 
-uint16_t makeWord(uint16_t w)
+unsigned int makeWord(unsigned int w)
 {
     return w;
 }
 
-uint16_t makeWord(uint8_t h, uint8_t l)
+unsigned int makeWord(unsigned char h, unsigned char l)
 {
     return (h << 8) | l;
 }

cores/esp32/WString.cpp

@@ -59,7 +59,9 @@ String::String(StringSumHelper &&rval) {
 
 String::String(char c) {
     init();
-    char buf[] = { c, '\0' };
+    char buf[2];
+    buf[0] = c;
+    buf[1] = 0;
     *this = buf;
 }
 
@@ -128,9 +130,9 @@ String::~String() {
 
 inline void String::init(void) {
     setSSO(false);
-    setBuffer(nullptr);
     setCapacity(0);
     setLen(0);
+    setBuffer(nullptr);
 }
 
 void String::invalidate(void) {
@@ -157,7 +159,7 @@ unsigned char String::changeBuffer(unsigned int maxStrLen) {
             // Already using SSO, nothing to do
 	    uint16_t oldLen = len();
             setSSO(true);
-            setLen(oldLen);
+	    setLen(oldLen);
             return 1;
         } else { // if bufptr && !isSSO()
             // Using bufptr, need to shrink into sso.buff
@@ -166,8 +168,8 @@ unsigned char String::changeBuffer(unsigned int maxStrLen) {
             free(wbuffer());
             uint16_t oldLen = len();
             setSSO(true);
+	    setLen(oldLen);
             memcpy(wbuffer(), temp, maxStrLen);
-            setLen(oldLen);
             return 1;
         }
     }
@@ -191,8 +193,8 @@ unsigned char String::changeBuffer(unsigned int maxStrLen) {
         }
         setSSO(false);
         setCapacity(newSize - 1);
-        setBuffer(newbuffer);
         setLen(oldLen); // Needed in case of SSO where len() never existed
+        setBuffer(newbuffer);
         return 1;
     }
     return 0;
@@ -207,8 +209,8 @@ String & String::copy(const char *cstr, unsigned int length) {
         invalidate();
         return *this;
     }
-    memmove(wbuffer(), cstr, length + 1);
     setLen(length);
+    memmove(wbuffer(), cstr, length + 1);
     return *this;
 }
 
@@ -217,8 +219,8 @@ String & String::copy(const __FlashStringHelper *pstr, unsigned int length) {
         invalidate();
         return *this;
     }
-    memcpy_P(wbuffer(), (PGM_P)pstr, length + 1); // We know wbuffer() cannot ever be in PROGMEM, so memcpy safe here
     setLen(length);
+    memcpy_P(wbuffer(), (PGM_P)pstr, length + 1); // We know wbuffer() cannot ever be in PROGMEM, so memcpy safe here
     return *this;
 }
 
@@ -248,8 +250,8 @@ void String::move(String &rhs) {
     setLen(rhs.len());
     rhs.setSSO(false);
     rhs.setCapacity(0);
-    rhs.setBuffer(nullptr);
     rhs.setLen(0);
+    rhs.setBuffer(nullptr);
 }
 #endif
 
@@ -288,11 +290,10 @@ 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;
 }
@@ -346,18 +347,22 @@ unsigned char String::concat(const char *cstr) {
 }
 
 unsigned char String::concat(char c) {
-    char buf[] = { c, '\0' };
+    char buf[2];
+    buf[0] = c;
+    buf[1] = 0;
     return concat(buf, 1);
 }
 
 unsigned char String::concat(unsigned char num) {
     char buf[1 + 3 * sizeof(unsigned char)];
-    return concat(buf, sprintf(buf, "%d", num));
+    sprintf(buf, "%d", num);
+    return concat(buf, strlen(buf));
 }
 
 unsigned char String::concat(int num) {
     char buf[2 + 3 * sizeof(int)];
-    return concat(buf, sprintf(buf, "%d", num));
+    sprintf(buf, "%d", num);
+    return concat(buf, strlen(buf));
 }
 
 unsigned char String::concat(unsigned int num) {
@@ -368,7 +373,8 @@ unsigned char String::concat(unsigned int num) {
 
 unsigned char String::concat(long num) {
     char buf[2 + 3 * sizeof(long)];
-    return concat(buf, sprintf(buf, "%ld", num));
+    sprintf(buf, "%ld", num);
+    return concat(buf, strlen(buf));
 }
 
 unsigned char String::concat(unsigned long num) {
@@ -549,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 lengths are the same and non-zero
+    //at this point lenghts are the same and non-zero
     const char *p1 = buffer();
     const char *p2 = s2.buffer();
     unsigned int equalchars = 0;
@@ -738,7 +744,6 @@ void String::replace(const String& find, const String& replace) {
         }
     } else if(diff < 0) {
         char *writeTo = wbuffer();
-        unsigned int l = len();
         while((foundAt = strstr(readFrom, find.buffer())) != NULL) {
             unsigned int n = foundAt - readFrom;
             memmove(writeTo, readFrom, n);
@@ -746,10 +751,9 @@ void String::replace(const String& find, const String& replace) {
             memmove(writeTo, replace.buffer(), replace.len());
             writeTo += replace.len();
             readFrom = foundAt + find.len();
-            l += diff;
+            setLen(len() + diff);
         }
         memmove(writeTo, readFrom, strlen(readFrom)+1);
-        setLen(l);
     } else {
         unsigned int size = len(); // compute size needed for result
         while((foundAt = strstr(readFrom, find.buffer())) != NULL) {
@@ -764,7 +768,7 @@ void String::replace(const String& find, const String& replace) {
         while(index >= 0 && (index = lastIndexOf(find, index)) >= 0) {
             readFrom = wbuffer() + index + find.len();
             memmove(readFrom + diff, readFrom, len() - (readFrom - buffer()));
-            int newLen = len() + diff;
+	    int newLen = len() + diff;
             memmove(wbuffer() + index, replace.buffer(), replace.len());
             setLen(newLen);
             wbuffer()[newLen] = 0;
@@ -792,8 +796,8 @@ void String::remove(unsigned int index, unsigned int count) {
     }
     char *writeTo = wbuffer() + index;
     unsigned int newlen = len() - count;
-    memmove(writeTo, wbuffer() + index + count, newlen - index);
     setLen(newlen);
+    memmove(writeTo, wbuffer() + index + count, newlen - index);
     wbuffer()[newlen] = 0;
 }
 
@@ -823,9 +827,9 @@ void String::trim(void) {
     while(isspace(*end) && end >= begin)
         end--;
     unsigned int newlen = end + 1 - begin;
+    setLen(newlen);
     if(begin > buffer())
         memmove(wbuffer(), begin, newlen);
-    setLen(newlen);
     wbuffer()[newlen] = 0;
 }
 

cores/esp32/WString.h

@@ -281,8 +281,8 @@ class String {
         // Contains the string info when we're not in SSO mode
         struct _ptr { 
             char *   buff;
-            uint32_t cap;
-            uint32_t len;
+            uint16_t cap;
+            uint16_t len;
         };
         // This allows strings up up to 11 (10 + \0 termination) without any extra space.
         enum { SSOSIZE = sizeof(struct _ptr) + 4 - 1 }; // Characters to allocate space for SSO, must be 12 or more
@@ -291,11 +291,7 @@ class String {
             unsigned char len   : 7; // Ensure only one byte is allocated by GCC for the bitfields
             unsigned char isSSO : 1;
         } __attribute__((packed)); // Ensure that GCC doesn't expand the flag byte to a 32-bit word for alignment issues
-#ifdef BOARD_HAS_PSRAM
-        enum { CAPACITY_MAX = 3145728 }; 
-#else
-        enum { CAPACITY_MAX = 65535 }; 
-#endif
+        enum { CAPACITY_MAX = 65535 }; // If typeof(cap) changed from uint16_t, be sure to update this enum to the max value storable in the type
         union {
             struct _ptr ptr;
             struct _sso sso;
@@ -305,19 +301,9 @@ class String {
         inline unsigned int len() const { return isSSO() ? sso.len : ptr.len; }
         inline unsigned int capacity() const { return isSSO() ? (unsigned int)SSOSIZE - 1 : ptr.cap; } // Size of max string not including terminal NUL
         inline void setSSO(bool set) { sso.isSSO = set; }
-        inline void setLen(int len) {
-            if (isSSO()) {
-                sso.len = len;
-                sso.buff[len] = 0;
-            } else {
-                ptr.len = len;
-                if (ptr.buff) {
-                    ptr.buff[len] = 0;
-                }
-            }
-        }
+        inline void setLen(int len) { if (isSSO()) sso.len = len; else ptr.len = len; }
         inline void setCapacity(int cap) { if (!isSSO()) ptr.cap = cap; }
-        inline void setBuffer(char *buff) { if (!isSSO()) ptr.buff = buff; }
+	inline void setBuffer(char *buff) { if (!isSSO()) ptr.buff = buff; }
         // Buffer accessor functions
         inline const char *buffer() const { return (const char *)(isSSO() ? sso.buff : ptr.buff); }
         inline char *wbuffer() const { return isSSO() ? const_cast<char *>(sso.buff) : ptr.buff; } // Writable version of buffer

cores/esp32/esp32-hal-adc.c

@@ -16,15 +16,16 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_attr.h"
+#include "soc/rtc_io_reg.h"
 #include "soc/rtc_cntl_reg.h"
+#include "soc/sens_reg.h"
+
 #include "driver/adc.h"
 
 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp_adc_cal.h"
-#include "soc/sens_reg.h"
-#include "soc/rtc_io_reg.h"
 #include "esp32/rom/ets_sys.h"
 #include "esp_intr_alloc.h"
 #define DEFAULT_VREF    1100
@@ -33,10 +34,6 @@ static uint16_t __analogVRef = 0;
 static uint8_t __analogVRefPin = 0;
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/ets_sys.h"
-#include "soc/sens_reg.h"
-#include "soc/rtc_io_reg.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -48,16 +45,13 @@ 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){
         clockDiv = 1;
     }
     __analogClockDiv = clockDiv;
-#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2
     adc_set_clk_div(__analogClockDiv);
-#endif
 }
 
 void __analogSetAttenuation(adc_attenuation_t attenuation)
@@ -87,9 +81,6 @@ 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)
@@ -104,7 +95,6 @@ void __analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation)
         adc1_config_channel_atten(channel, attenuation);
     }
     __analogInit();
-    __pin_attenuation[pin] = attenuation;
 }
 
 bool __adcAttachPin(uint8_t pin){
@@ -124,17 +114,14 @@ bool __adcAttachPin(uint8_t pin){
             WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG, touch);
         }
 #endif
-    }
-#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2
-    else if(pin == 25){
+    } else if(pin == 25){
         CLEAR_PERI_REG_MASK(RTC_IO_PAD_DAC1_REG, RTC_IO_PDAC1_XPD_DAC | RTC_IO_PDAC1_DAC_XPD_FORCE);//stop dac1
     } else if(pin == 26){
         CLEAR_PERI_REG_MASK(RTC_IO_PAD_DAC2_REG, RTC_IO_PDAC2_XPD_DAC | RTC_IO_PDAC2_DAC_XPD_FORCE);//stop dac2
     }
-#endif
 
     pinMode(pin, ANALOG);
-    __analogSetPinAttenuation(pin, (__pin_attenuation[pin] != ADC_ATTENDB_MAX)?__pin_attenuation[pin]:__analogAttenuation);
+    __analogSetPinAttenuation(pin, __analogAttenuation);
     return true;
 }
 
@@ -166,7 +153,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. 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));
+            log_e("GPIO%u: %s: ADC2 is in use by Wi-Fi.", pin, esp_err_to_name(r));
         } else {
             log_e("GPIO%u: %s", pin, esp_err_to_name(r));
         }
@@ -196,7 +183,7 @@ uint32_t __analogReadMilliVolts(uint8_t pin){
             __analogVRef = DEFAULT_VREF;
             if(__analogVRefPin){
                 esp_adc_cal_characteristics_t chars;
-                if(adc_vref_to_gpio(ADC_UNIT_2, __analogVRefPin) == ESP_OK){
+                if(adc2_vref_to_gpio(__analogVRefPin) == ESP_OK){
                     __analogVRef = __analogRead(__analogVRefPin);
                     esp_adc_cal_characterize(1, __analogAttenuation, __analogWidth, DEFAULT_VREF, &chars);
                     __analogVRef = esp_adc_cal_raw_to_voltage(__analogVRef, &chars);
@@ -250,12 +237,28 @@ void __analogSetVRefPin(uint8_t pin){
     __analogVRefPin = pin;
 }
 
-int __hallRead()    //hall sensor using idf read
+int __hallRead()    //hall sensor without LNA
 {
+    int Sens_Vp0;
+    int Sens_Vn0;
+    int Sens_Vp1;
+    int Sens_Vn1;
+
     pinMode(36, ANALOG);
     pinMode(39, ANALOG);
-    __analogSetWidth(12);
-    return hall_sensor_read();
+    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);
 }
 #endif
 

cores/esp32/esp32-hal-adc.h

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

cores/esp32/esp32-hal-bt.c

@@ -18,12 +18,11 @@
 
 bool btInUse(){ return true; }
 
+#ifdef CONFIG_BLUEDROID_ENABLED
 #include "esp_bt.h"
 
-#ifdef CONFIG_BTDM_CONTROLLER_MODE_BTDM
+#ifdef CONFIG_CLASSIC_BT_ENABLED
 #define BT_MODE ESP_BT_MODE_BTDM
-#elif defined(CONFIG_BTDM_CONTROLLER_MODE_BR_EDR_ONLY)
-#define BT_MODE ESP_BT_MODE_CLASSIC_BT
 #else
 #define BT_MODE ESP_BT_MODE_BLE
 #endif
@@ -80,7 +79,7 @@ bool btStop(){
     return false;
 }
 
-#else // CONFIG_BT_ENABLED
+#else
 bool btStarted()
 {
     return false;
@@ -95,6 +94,6 @@ bool btStop()
 {
     return false;
 }
-
-#endif // CONFIG_BT_ENABLED
+#endif
+#endif
 

cores/esp32/esp32-hal-cpu.c

@@ -16,6 +16,7 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
 #include "freertos/task.h"
+#include "freertos/xtensa_timer.h"
 #include "esp_attr.h"
 #include "esp_log.h"
 #include "soc/rtc.h"
@@ -28,13 +29,9 @@
 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "freertos/xtensa_timer.h"
 #include "esp32/rom/rtc.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
-#include "freertos/xtensa_timer.h"
 #include "esp32s2/rom/rtc.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/rtc.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -144,14 +141,10 @@ bool removeApbChangeCallback(void * arg, apb_change_cb_t cb){
 }
 
 static uint32_t calculateApb(rtc_cpu_freq_config_t * conf){
-#if CONFIG_IDF_TARGET_ESP32C3
-	return APB_CLK_FREQ;
-#else
     if(conf->freq_mhz >= 80){
         return 80 * MHZ;
     }
     return (conf->source_freq_mhz * MHZ) / conf->div;
-#endif
 }
 
 void esp_timer_impl_update_apb_freq(uint32_t apb_ticks_per_us); //private in IDF
@@ -226,12 +219,8 @@ bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz){
         esp_timer_impl_update_apb_freq(apb / MHZ);
     }
     //Update FreeRTOS Tick Divisor
-#if CONFIG_IDF_TARGET_ESP32C3
-
-#else
     uint32_t fcpu = (conf.freq_mhz >= 80)?(conf.freq_mhz * MHZ):(apb);
     _xt_tick_divisor = fcpu / XT_TICK_PER_SEC;
-#endif
     //Call peripheral functions after the APB change
     if(apb_change_callbacks){
         triggerApbChangeCallback(APB_AFTER_CHANGE, capb, apb);

cores/esp32/esp32-hal-dac.c

@@ -13,29 +13,24 @@
 // limitations under the License.
 
 #include "esp32-hal.h"
-
-#if CONFIG_IDF_TARGET_ESP32
-#include "soc/rtc_io_reg.h"
-#define DAC1 25
-#define DAC2 26
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/rtc_io_reg.h"
-#define DAC1 17
-#define DAC2 18
-#elif CONFIG_IDF_TARGET_ESP32C3
-#define NODAC
-#else
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-
-#ifndef NODAC
 #include "esp_attr.h"
+#include "soc/rtc_io_reg.h"
 #include "soc/rtc_cntl_reg.h"
 #include "soc/rtc_io_periph.h"
 #include "soc/sens_reg.h"
 #include "soc/sens_struct.h"
 #include "driver/dac.h"
 
+#if CONFIG_IDF_TARGET_ESP32
+#define DAC1 25
+#define DAC2 26
+#elif CONFIG_IDF_TARGET_ESP32S2
+#define DAC1 17
+#define DAC2 18
+#else
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+
 void ARDUINO_ISR_ATTR __dacWrite(uint8_t pin, uint8_t value)
 {
     if(pin < DAC1 || pin > DAC2){
@@ -59,5 +54,3 @@ void ARDUINO_ISR_ATTR __dacWrite(uint8_t pin, uint8_t value)
 }
 
 extern void dacWrite(uint8_t pin, uint8_t value) __attribute__ ((weak, alias("__dacWrite")));
-
-#endif

cores/esp32/esp32-hal-gpio.c

@@ -20,25 +20,23 @@
 #include "soc/gpio_reg.h"
 #include "soc/io_mux_reg.h"
 #include "soc/gpio_struct.h"
-#include "driver/gpio.h"
-#include "esp_system.h"
+#include "soc/rtc_io_reg.h"
 
+#include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/ets_sys.h"
 #include "esp32/rom/gpio.h"
 #include "esp_intr_alloc.h"
-#include "soc/rtc_io_reg.h"
 #define GPIO_FUNC 2
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/ets_sys.h"
 #include "esp32s2/rom/gpio.h"
 #include "esp_intr_alloc.h"
 #include "soc/periph_defs.h"
-#include "soc/rtc_io_reg.h"
 #define GPIO_FUNC 1
 #else 
-#define USE_ESP_IDF_GPIO 1
+#error Target CONFIG_IDF_TARGET is not supported
 #endif
 #else // ESP32 Before IDF 4.0
 #include "rom/ets_sys.h"
@@ -159,45 +157,7 @@ static InterruptHandle_t __pinInterruptHandlers[SOC_GPIO_PIN_COUNT] = {0,};
 
 extern void ARDUINO_ISR_ATTR __pinMode(uint8_t pin, uint8_t mode)
 {
-#if USE_ESP_IDF_GPIO
-	if (!GPIO_IS_VALID_GPIO(pin)) {
-		return;
-	}
-	gpio_config_t conf = {
-		    .pin_bit_mask = (1ULL<<pin),			/*!< GPIO pin: set with bit mask, each bit maps to a GPIO */
-		    .mode = GPIO_MODE_DISABLE,              /*!< GPIO mode: set input/output mode                     */
-		    .pull_up_en = GPIO_PULLUP_DISABLE,      /*!< GPIO pull-up                                         */
-		    .pull_down_en = GPIO_PULLDOWN_DISABLE,  /*!< GPIO pull-down                                       */
-		    .intr_type = GPIO_INTR_DISABLE      	/*!< GPIO interrupt type                                  */
-	};
-	if (mode < 0x20) {//io
-		conf.mode = mode & (INPUT | OUTPUT);
-		if (mode & OPEN_DRAIN) {
-			conf.mode |= GPIO_MODE_DEF_OD;
-		}
-		if (mode & PULLUP) {
-			conf.pull_up_en = GPIO_PULLUP_ENABLE;
-		}
-		if (mode & PULLDOWN) {
-			conf.pull_down_en = GPIO_PULLDOWN_ENABLE;
-		}
-	}
-	gpio_config(&conf);
 
-	if(mode == SPECIAL){
-#if CONFIG_IDF_TARGET_ESP32
-		PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[pin], (uint32_t)(((pin)==RX||(pin)==TX)?0:1));
-#elif CONFIG_IDF_TARGET_ESP32S2
-		PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[pin], (uint32_t)(((pin)==RX||(pin)==TX)?0:2));
-#endif
-	} else if(mode == ANALOG){
-#if !CONFIG_IDF_TARGET_ESP32C3
-		//adc_gpio_init(ADC_UNIT_1, ADC_CHANNEL_0);
-#endif
-	} else if(mode >= 0x20 && mode < ANALOG) {//function
-		PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[pin], mode >> 5);
-	}
-#else
     if(!digitalPinIsValid(pin)) {
         return;
     }
@@ -268,7 +228,11 @@ extern void ARDUINO_ISR_ATTR __pinMode(uint8_t pin, uint8_t mode)
     pinFunction |= FUN_IE;//input enable but required for output as well?
 
     if(mode & (INPUT | OUTPUT)) {
-        pinFunction |= ((uint32_t)PIN_FUNC_GPIO << MCU_SEL_S);
+#if CONFIG_IDF_TARGET_ESP32
+        pinFunction |= ((uint32_t)2 << MCU_SEL_S);
+#elif CONFIG_IDF_TARGET_ESP32S2
+        pinFunction |= ((uint32_t)1 << MCU_SEL_S);
+#endif
     } else if(mode == SPECIAL) {
 #if CONFIG_IDF_TARGET_ESP32
         pinFunction |= ((uint32_t)(((pin)==RX||(pin)==TX)?0:1) << MCU_SEL_S);
@@ -286,20 +250,10 @@ extern void ARDUINO_ISR_ATTR __pinMode(uint8_t pin, uint8_t mode)
     }
 
     GPIO.pin[pin].val = pinControl;
-#endif
 }
 
 extern void ARDUINO_ISR_ATTR __digitalWrite(uint8_t pin, uint8_t val)
 {
-#if USE_ESP_IDF_GPIO
-	gpio_set_level((gpio_num_t)pin, val);
-#elif CONFIG_IDF_TARGET_ESP32C3
-    if (val) {
-    	GPIO.out_w1ts.out_w1ts = (1 << pin);
-    } else {
-    	GPIO.out_w1tc.out_w1tc = (1 << pin);
-    }
-#else
     if(val) {
         if(pin < 32) {
             GPIO.out_w1ts = ((uint32_t)1 << pin);
@@ -313,37 +267,18 @@ extern void ARDUINO_ISR_ATTR __digitalWrite(uint8_t pin, uint8_t val)
             GPIO.out1_w1tc.val = ((uint32_t)1 << (pin - 32));
         }
     }
-#endif
 }
 
 extern int ARDUINO_ISR_ATTR __digitalRead(uint8_t pin)
 {
-#if USE_ESP_IDF_GPIO
-	return gpio_get_level((gpio_num_t)pin);
-#elif CONFIG_IDF_TARGET_ESP32C3
-	return (GPIO.in.data >> pin) & 0x1;
-#else
     if(pin < 32) {
         return (GPIO.in >> pin) & 0x1;
     } else if(pin < GPIO_PIN_COUNT) {
         return (GPIO.in1.val >> (pin - 32)) & 0x1;
     }
     return 0;
-#endif
 }
 
-#if USE_ESP_IDF_GPIO
-static void ARDUINO_ISR_ATTR __onPinInterrupt(void * arg) {
-	InterruptHandle_t * isr = (InterruptHandle_t*)arg;
-    if(isr->fn) {
-        if(isr->arg){
-            ((voidFuncPtrArg)isr->fn)(isr->arg);
-        } else {
-        	isr->fn();
-        }
-    }
-}
-#else
 static intr_handle_t gpio_intr_handle = NULL;
 
 static void ARDUINO_ISR_ATTR __onPinInterrupt()
@@ -385,7 +320,6 @@ static void ARDUINO_ISR_ATTR __onPinInterrupt()
         } while(++pin<GPIO_PIN_COUNT);
     }
 }
-#endif
 
 extern void cleanupFunctional(void* arg);
 
@@ -394,17 +328,8 @@ extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc,
     static bool interrupt_initialized = false;
 
     if(!interrupt_initialized) {
-#if USE_ESP_IDF_GPIO
-    	esp_err_t err = gpio_install_isr_service((int)ARDUINO_ISR_FLAG);
-    	interrupt_initialized = (err == ESP_OK) || (err == ESP_ERR_INVALID_STATE);
-#else
         interrupt_initialized = true;
         esp_intr_alloc(ETS_GPIO_INTR_SOURCE, (int)ARDUINO_ISR_FLAG, __onPinInterrupt, NULL, &gpio_intr_handle);
-#endif
-    }
-    if(!interrupt_initialized) {
-    	log_e("GPIO ISR Service Failed To Start");
-    	return;
     }
 
     // if new attach without detach remove old info
@@ -416,14 +341,6 @@ extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc,
     __pinInterruptHandlers[pin].arg = arg;
     __pinInterruptHandlers[pin].functional = functional;
 
-#if USE_ESP_IDF_GPIO
-    gpio_set_intr_type((gpio_num_t)pin, (gpio_int_type_t)(intr_type & 0x7));
-    if(intr_type & 0x8){
-    	gpio_wakeup_enable((gpio_num_t)pin, (gpio_int_type_t)(intr_type & 0x7));
-    }
-    gpio_isr_handler_add((gpio_num_t)pin, __onPinInterrupt, &__pinInterruptHandlers[pin]);
-    gpio_intr_enable((gpio_num_t)pin);
-#else
     esp_intr_disable(gpio_intr_handle);
 #if CONFIG_IDF_TARGET_ESP32
     if(esp_intr_get_cpu(gpio_intr_handle)) { //APP_CPU
@@ -436,7 +353,6 @@ extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc,
 #endif
     GPIO.pin[pin].int_type = intr_type;
     esp_intr_enable(gpio_intr_handle);
-#endif
 }
 
 extern void __attachInterruptArg(uint8_t pin, voidFuncPtrArg userFunc, void * arg, int intr_type)
@@ -450,13 +366,7 @@ extern void __attachInterrupt(uint8_t pin, voidFuncPtr userFunc, int intr_type)
 
 extern void __detachInterrupt(uint8_t pin)
 {
-#if USE_ESP_IDF_GPIO
-	gpio_intr_disable((gpio_num_t)pin);
-	gpio_isr_handler_remove((gpio_num_t)pin);
-	gpio_wakeup_disable((gpio_num_t)pin);
-#else
     esp_intr_disable(gpio_intr_handle);
-#endif
     if (__pinInterruptHandlers[pin].functional && __pinInterruptHandlers[pin].arg)
     {
     	cleanupFunctional(__pinInterruptHandlers[pin].arg);
@@ -465,13 +375,9 @@ extern void __detachInterrupt(uint8_t pin)
     __pinInterruptHandlers[pin].arg = NULL;
     __pinInterruptHandlers[pin].functional = false;
 
-#if USE_ESP_IDF_GPIO
-    gpio_set_intr_type((gpio_num_t)pin, GPIO_INTR_DISABLE);
-#else
     GPIO.pin[pin].int_ena = 0;
     GPIO.pin[pin].int_type = 0;
     esp_intr_enable(gpio_intr_handle);
-#endif
 }
 
 

cores/esp32/esp32-hal-gpio.h

@@ -28,7 +28,7 @@ extern "C" {
 #include "soc/soc_caps.h"
 
 #if (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
-#define NUM_OUPUT_PINS  46
+#define NUM_OUPUT_PINS  45
 #define PIN_DAC1        17
 #define PIN_DAC2        18
 #else

cores/esp32/esp32-hal-i2c.c

@@ -21,19 +21,16 @@
 #include "driver/periph_ctrl.h"
 #include "soc/i2c_reg.h"
 #include "soc/i2c_struct.h"
+#include "soc/dport_reg.h"
 #include "esp_attr.h"
 #include "esp32-hal-cpu.h" // cpu clock change support 31DEC2018
 
 #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"
 #elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/dport_reg.h"
 #include "esp32s2/rom/ets_sys.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -963,14 +960,6 @@ static void ARDUINO_ISR_ATTR i2c_isr_handler_default(void* arg)
             activeInt &=~I2C_RXFIFO_FULL_INT_ST;
         }
 
-        if(activeInt & I2C_RXFIFO_OVF_INT_ST) {
-            emptyRxFifo(p_i2c);
-            p_i2c->dev->int_clr.rx_fifo_full=1;
-            p_i2c->dev->int_ena.rx_fifo_full=1; //why?
-
-            activeInt &=~I2C_RXFIFO_OVF_INT_ST;
-        }
-
         if (activeInt & I2C_ACK_ERR_INT_ST_M) {//fatal error, abort i2c service
             if (p_i2c->mode == I2C_MASTER) {
                 i2c_update_error_byte_cnt(p_i2c); // calc which byte caused ack Error, check if address or data
@@ -1798,13 +1787,9 @@ struct i2c_struct_t {
 static i2c_t * i2c_ports[2] = {NULL, NULL};
 
 i2c_t * i2cInit(uint8_t i2c_num, int8_t sda, int8_t scl, uint32_t clk_speed){
-	if(i2c_num >= SOC_I2C_NUM){
+	if(i2c_num >= 2){
 		return NULL;
 	}
-	if(!clk_speed){
-	    //originally does not change the speed, but getFrequency and setFrequency need to be implemented first.
-	    clk_speed = 100000;
-	}
 	i2c_t * out = NULL;
 	if(i2c_ports[i2c_num] == NULL){
 		out = (i2c_t*)malloc(sizeof(i2c_t));
@@ -1819,7 +1804,7 @@ i2c_t * i2cInit(uint8_t i2c_num, int8_t sda, int8_t scl, uint32_t clk_speed){
 		i2c_driver_delete((i2c_port_t)i2c_num);
 	}
 
-    i2c_config_t conf = { };
+    i2c_config_t conf;
     conf.mode = I2C_MODE_MASTER;
     conf.scl_io_num = (gpio_num_t)scl;
     conf.sda_io_num = (gpio_num_t)sda;

cores/esp32/esp32-hal-ledc.c

@@ -17,25 +17,19 @@
 #include "freertos/task.h"
 #include "freertos/semphr.h"
 #include "esp32-hal-matrix.h"
+#include "soc/dport_reg.h"
 #include "soc/ledc_reg.h"
 #include "soc/ledc_struct.h"
-#include "driver/periph_ctrl.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"
 #define LAST_CHAN (15)
 #elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/dport_reg.h"
 #include "esp32s2/rom/ets_sys.h"
 #define LAST_CHAN (7)
 #define LEDC_DIV_NUM_HSTIMER0_V LEDC_CLK_DIV_LSTIMER0_V
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
-#define LAST_CHAN (7)
-#define LEDC_DIV_NUM_HSTIMER0_V LEDC_CLK_DIV_LSTIMER0_V
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -117,7 +111,8 @@ static void _ledcSetupTimer(uint8_t chan, uint32_t div_num, uint8_t bit_num, boo
     static uint16_t _activeChannels = 0;
     if(!tHasStarted) {
         tHasStarted = true;
-        periph_module_enable(PERIPH_LEDC_MODULE);
+        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_LEDC_CLK_EN);
+        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_LEDC_RST);
         LEDC.conf.apb_clk_sel = 1;//LS use apb clock
         addApbChangeCallback((void*)&_activeChannels, _on_apb_change);
 
@@ -307,7 +302,7 @@ void ledcAttachPin(uint8_t pin, uint8_t chan)
         return;
     }
     pinMode(pin, OUTPUT);
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
     pinMatrixOutAttach(pin, LEDC_LS_SIG_OUT0_IDX + chan, false, false);
 #else
     pinMatrixOutAttach(pin, ((chan/8)?LEDC_LS_SIG_OUT0_IDX:LEDC_HS_SIG_OUT0_IDX) + (chan%8), false, false);
@@ -318,12 +313,3 @@ void ledcDetachPin(uint8_t pin)
 {
     pinMatrixOutDetach(pin, false, false);
 }
-
-double ledcChangeFrequency(uint8_t chan, double freq, uint8_t bit_num)
-{
-    if (chan > 15) {
-        return 0;
-    }
-    double res_freq = _ledcSetupTimerFreq(chan, freq, bit_num);
-    return res_freq;
-}

cores/esp32/esp32-hal-ledc.h

@@ -35,7 +35,6 @@ uint32_t    ledcRead(uint8_t channel);
 double      ledcReadFreq(uint8_t channel);
 void        ledcAttachPin(uint8_t pin, uint8_t channel);
 void        ledcDetachPin(uint8_t pin);
-double      ledcChangeFrequency(uint8_t channel, double freq, uint8_t resolution_bits);
 
 
 #ifdef __cplusplus

cores/esp32/esp32-hal-log.h

@@ -37,9 +37,6 @@ extern "C"
 #define ARDUHAL_LOG_LEVEL CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL
 #else
 #define ARDUHAL_LOG_LEVEL CORE_DEBUG_LEVEL
-#ifdef USE_ESP_IDF_LOG
-#define LOG_LOCAL_LEVEL CORE_DEBUG_LEVEL
-#endif
 #endif
 
 #ifndef CONFIG_ARDUHAL_LOG_COLORS
@@ -75,8 +72,6 @@ extern "C"
 #define ARDUHAL_LOG_RESET_COLOR
 #endif
 
-
-
 const char * pathToFileName(const char * path);
 int log_printf(const char *fmt, ...);
 
@@ -84,91 +79,55 @@ int log_printf(const char *fmt, ...);
 #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__
 
 #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_VERBOSE
-#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__)
 #else
-#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)
-#endif
-#else
 #define log_v(format, ...)
 #define isr_log_v(format, ...)
 #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__)
 #else
-#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)
-#endif
-#else
 #define log_d(format, ...)
 #define isr_log_d(format, ...)
 #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__)
 #else
-#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)
-#endif
-#else
 #define log_i(format, ...)
 #define isr_log_i(format, ...)
 #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__)
 #else
-#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)
-#endif
-#else
 #define log_w(format, ...)
 #define isr_log_w(format, ...)
 #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__)
 #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)
-#endif
-#else
 #define log_e(format, ...)
 #define isr_log_e(format, ...)
 #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__)
 #else
-#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)
-#endif
-#else
 #define log_n(format, ...)
 #define isr_log_n(format, ...)
 #endif
 
 #include "esp_log.h"
 
-#ifdef USE_ESP_IDF_LOG
-#ifndef TAG
-#define TAG "ARDUINO"
-#endif
-//#define log_n(format, ...) myLog(ESP_LOG_NONE, format, ##__VA_ARGS__)
-#else
 #ifdef CONFIG_ARDUHAL_ESP_LOG
 #undef ESP_LOGE
 #undef ESP_LOGW
@@ -192,7 +151,6 @@ int log_printf(const char *fmt, ...);
 #define ESP_EARLY_LOGD(tag, ...)  isr_log_d(__VA_ARGS__)
 #define ESP_EARLY_LOGV(tag, ...)  isr_log_v(__VA_ARGS__)
 #endif
-#endif
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-matrix.c

@@ -21,8 +21,6 @@
 #include "esp32/rom/gpio.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/gpio.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/gpio.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif

cores/esp32/esp32-hal-misc.c

@@ -40,10 +40,6 @@
 #include "esp32/rom/rtc.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/rtc.h"
-#include "driver/temp_sensor.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/rtc.h"
-#include "driver/temp_sensor.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -53,25 +49,12 @@
 
 //Undocumented!!! Get chip temperature in Farenheit
 //Source: https://github.com/pcbreflux/espressif/blob/master/esp32/arduino/sketchbook/ESP32_int_temp_sensor/ESP32_int_temp_sensor.ino
-#ifdef CONFIG_IDF_TARGET_ESP32
 uint8_t temprature_sens_read();
 
 float temperatureRead()
 {
     return (temprature_sens_read() - 32) / 1.8;
 }
-#else
-float temperatureRead()
-{
-    float result = NAN;
-    temp_sensor_config_t tsens = TSENS_CONFIG_DEFAULT();
-    temp_sensor_set_config(tsens);
-    temp_sensor_start();
-    temp_sensor_read_celsius(&result); 
-    temp_sensor_stop();
-    return result;
-}
-#endif
 
 void __yield()
 {
@@ -177,15 +160,15 @@ void delay(uint32_t ms)
 
 void ARDUINO_ISR_ATTR delayMicroseconds(uint32_t us)
 {
-    uint64_t m = (uint64_t)esp_timer_get_time();
+    uint32_t m = micros();
     if(us){
-        uint64_t e = (m + us);
+        uint32_t e = (m + us);
         if(m > e){ //overflow
-            while((uint64_t)esp_timer_get_time() > e){
+            while(micros() > e){
                 NOP();
             }
         }
-        while((uint64_t)esp_timer_get_time() < e){
+        while(micros() < e){
             NOP();
         }
     }

cores/esp32/esp32-hal-psram.c

@@ -51,6 +51,7 @@ bool psramInit(){
         log_w("PSRAM not supported!");
         return false;
     }
+    esp_spiram_init_cache();
 #elif CONFIG_IDF_TARGET_ESP32S2
     extern void esp_config_data_cache_mode(void);
     esp_config_data_cache_mode();

cores/esp32/esp32-hal-rmt.c

@@ -28,27 +28,15 @@
  */
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #define MAX_CHANNELS 8
-#define MAX_DATA_PER_CHANNEL 64
-#define MAX_DATA_PER_ITTERATION 62
 #elif CONFIG_IDF_TARGET_ESP32S2
 #define MAX_CHANNELS 4
-#define MAX_DATA_PER_CHANNEL 64
-#define MAX_DATA_PER_ITTERATION 62
-#elif CONFIG_IDF_TARGET_ESP32C3
-#define MAX_CHANNELS 4
-#define MAX_DATA_PER_CHANNEL 48
-#define MAX_DATA_PER_ITTERATION 46
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
+#define MAX_DATA_PER_CHANNEL 64
+#define MAX_DATA_PER_ITTERATION 62
 #define _ABS(a) (a>0?a:-a)
 #define _LIMIT(a,b) (a>b?b:a)
-#if CONFIG_IDF_TARGET_ESP32C3
-#define _INT_TX_END(channel) (1<<(channel))
-#define _INT_RX_END(channel) (4<<(channel))
-#define _INT_ERROR(channel)  (16<<(channel))
-#define _INT_THR_EVNT(channel)  (256<<(channel))
-#else
 #define __INT_TX_END     (1)
 #define __INT_RX_END     (2)
 #define __INT_ERROR      (4)
@@ -58,7 +46,6 @@
 #define _INT_RX_END(channel) (__INT_RX_END<<(channel*3))
 #define _INT_ERROR(channel)  (__INT_ERROR<<(channel*3))
 #define _INT_THR_EVNT(channel)  ((__INT_THR_EVNT)<<(channel))
-#endif
 
 #if CONFIG_DISABLE_HAL_LOCKS
 # define RMT_MUTEX_LOCK(channel)
@@ -68,7 +55,7 @@
 # define RMT_MUTEX_UNLOCK(channel)  xSemaphoreGive(g_rmt_objlocks[channel])
 #endif /* CONFIG_DISABLE_HAL_LOCKS */
 
-//#define _RMT_INTERNAL_DEBUG
+#define _RMT_INTERNAL_DEBUG
 #ifdef _RMT_INTERNAL_DEBUG
 # define DEBUG_INTERRUPT_START(pin)    digitalWrite(pin, 1);
 # define DEBUG_INTERRUPT_END(pin)      digitalWrite(pin, 0);
@@ -109,7 +96,6 @@ struct rmt_obj_s
     transaction_state_t tx_state;
     rmt_rx_data_cb_t cb;
     bool data_alloc;
-    void * arg;
 };
 
 /**
@@ -123,15 +109,15 @@ static xSemaphoreHandle g_rmt_objlocks[MAX_CHANNELS] = {
 };
 
 static rmt_obj_t g_rmt_objects[MAX_CHANNELS] = {
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
 #if CONFIG_IDF_TARGET_ESP32
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
-    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false, NULL},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
 #endif
 };
 
@@ -175,17 +161,12 @@ bool rmtSetCarrier(rmt_obj_t* rmt, bool carrier_en, bool carrier_level, uint32_t
     size_t channel = rmt->channel;
 
     RMT_MUTEX_LOCK(channel);
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.tx_carrier[channel].low = low;
-    RMT.tx_carrier[channel].high = high;
-    RMT.rx_conf[channel].conf0.carrier_en = carrier_en;
-    RMT.rx_conf[channel].conf0.carrier_out_lv = carrier_level;
-#else
+
     RMT.carrier_duty_ch[channel].low = low;
     RMT.carrier_duty_ch[channel].high = high;
     RMT.conf_ch[channel].conf0.carrier_en = carrier_en;
     RMT.conf_ch[channel].conf0.carrier_out_lv = carrier_level;
-#endif
+
     RMT_MUTEX_UNLOCK(channel);
 
     return true;
@@ -201,13 +182,8 @@ bool rmtSetFilter(rmt_obj_t* rmt, bool filter_en, uint32_t filter_level)
 
     RMT_MUTEX_LOCK(channel);
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.rx_filter_thres = filter_level;
-    RMT.rx_conf[channel].conf1.rx_filter_en = filter_en;
-#else
     RMT.conf_ch[channel].conf1.rx_filter_thres = filter_level;
     RMT.conf_ch[channel].conf1.rx_filter_en = filter_en;
-#endif
 
     RMT_MUTEX_UNLOCK(channel);
 
@@ -223,11 +199,7 @@ bool rmtSetRxThreshold(rmt_obj_t* rmt, uint32_t value)
     size_t channel = rmt->channel;
 
     RMT_MUTEX_LOCK(channel);
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf0.idle_thres = value;
-#else
     RMT.conf_ch[channel].conf0.idle_thres = value;
-#endif
     RMT_MUTEX_UNLOCK(channel);
 
     return true;
@@ -292,7 +264,7 @@ bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
     int channel = rmt->channel;
     int allocated_size = MAX_DATA_PER_CHANNEL * rmt->buffers;
 
-    if (size > (allocated_size - 1)) {
+    if (size > allocated_size) {
 
         int half_tx_nr = MAX_DATA_PER_ITTERATION/2;
         RMT_MUTEX_LOCK(channel);
@@ -306,18 +278,6 @@ bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
         rmt->intr_mode = E_TX_INTR | E_TXTHR_INTR;
         rmt->tx_state = E_SET_CONTI | E_FIRST_HALF;
 
-#if CONFIG_IDF_TARGET_ESP32C3
-        //uint32_t val = RMT.tx_conf[channel].val;
-        // init the tx limit for interruption
-        RMT.tx_lim[channel].limit = half_tx_nr+2;
-        //RMT.tx_conf[channel].val = val;
-        //RMT.tx_conf[channel].conf_update = 1;
-        // reset memory pointer
-        RMT.tx_conf[channel].mem_rst = 1;
-        //RMT.tx_conf[channel].mem_rst = 0;
-        RMT.tx_conf[channel].mem_rd_rst = 1;
-        //RMT.tx_conf[channel].mem_rd_rst = 0;
-#else
         // init the tx limit for interruption
         RMT.tx_lim_ch[channel].limit = half_tx_nr+2;
         // reset memory pointer
@@ -327,9 +287,9 @@ bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
         RMT.conf_ch[channel].conf1.mem_rd_rst = 0;
         RMT.conf_ch[channel].conf1.mem_wr_rst = 1;
         RMT.conf_ch[channel].conf1.mem_wr_rst = 0;
-#endif
+
         // set the tx end mark
-        //RMTMEM.chan[channel].data32[MAX_DATA_PER_ITTERATION].val = 0;
+        RMTMEM.chan[channel].data32[MAX_DATA_PER_ITTERATION].val = 0;
 
         // clear and enable both Tx completed and half tx event
         RMT.int_clr.val = _INT_TX_END(channel);
@@ -343,7 +303,6 @@ bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
         RMT_MUTEX_UNLOCK(channel);
 
         // start the transation
-        //return _rmtSendOnce(rmt, data, MAX_DATA_PER_ITTERATION, true);
         return _rmtSendOnce(rmt, data, MAX_DATA_PER_ITTERATION, false);
     } else {
         // use one-go mode if data fits one buffer 
@@ -371,7 +330,6 @@ bool rmtReadData(rmt_obj_t* rmt, uint32_t* data, size_t size)
     return true;
 }
 
-
 bool rmtBeginReceive(rmt_obj_t* rmt)
 {
     if (!rmt) {
@@ -382,15 +340,10 @@ bool rmtBeginReceive(rmt_obj_t* rmt)
     RMT.int_clr.val = _INT_ERROR(channel);
     RMT.int_ena.val |= _INT_ERROR(channel);
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.mem_owner = 1;
-    RMT.rx_conf[channel].conf1.mem_wr_rst = 1;
-    RMT.rx_conf[channel].conf1.rx_en = 1;
-#else
     RMT.conf_ch[channel].conf1.mem_owner = 1;
     RMT.conf_ch[channel].conf1.mem_wr_rst = 1;
     RMT.conf_ch[channel].conf1.rx_en = 1;
-#endif
+
     return true;
 }
 
@@ -410,7 +363,7 @@ bool rmtReceiveCompleted(rmt_obj_t* rmt)
     }
 }
 
-bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb, void * arg)
+bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb)
 {
     if (!rmt && !cb) {
         return false;
@@ -418,7 +371,6 @@ bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb, void * arg)
     int channel = rmt->channel;
 
     RMT_MUTEX_LOCK(channel);
-    rmt->arg = arg;
     rmt->intr_mode = E_RX_INTR;
     rmt->tx_state = E_FIRST_HALF;
     rmt->cb = cb;
@@ -429,48 +381,22 @@ bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb, void * arg)
         rmt->data_alloc = true;
     }
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.mem_owner = 1;
-#else
     RMT.conf_ch[channel].conf1.mem_owner = 1;
-#endif
+
     RMT.int_clr.val = _INT_RX_END(channel);
     RMT.int_clr.val = _INT_ERROR(channel);
     
     RMT.int_ena.val |= _INT_RX_END(channel);
     RMT.int_ena.val |= _INT_ERROR(channel);
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.mem_wr_rst = 1;
-
-    RMT.rx_conf[channel].conf1.rx_en = 1;
-#else
     RMT.conf_ch[channel].conf1.mem_wr_rst = 1;
 
     RMT.conf_ch[channel].conf1.rx_en = 1;
-#endif
     RMT_MUTEX_UNLOCK(channel);
 
     return true;
 }
 
-bool rmtEnd(rmt_obj_t* rmt) {
-    if (!rmt) {
-        return false;
-    }
-    int channel = rmt->channel;
-
-    RMT_MUTEX_LOCK(channel);
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.rx_en = 1;
-#else
-    RMT.conf_ch[channel].conf1.rx_en = 1;
-#endif
-    RMT_MUTEX_UNLOCK(channel);
-
-    return  true;
-}
-
 bool rmtReadAsync(rmt_obj_t* rmt, rmt_data_t* data, size_t size, void* eventFlag, bool waitForData, uint32_t timeout)
 {
     if (!rmt) {
@@ -495,11 +421,7 @@ bool rmtReadAsync(rmt_obj_t* rmt, rmt_data_t* data, size_t size, void* eventFlag
     RMT_MUTEX_LOCK(channel);
     rmt->intr_mode = E_RX_INTR;
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.mem_owner = 1;
-#else
     RMT.conf_ch[channel].conf1.mem_owner = 1;
-#endif
 
     RMT.int_clr.val = _INT_RX_END(channel);
     RMT.int_clr.val = _INT_ERROR(channel);
@@ -507,15 +429,9 @@ bool rmtReadAsync(rmt_obj_t* rmt, rmt_data_t* data, size_t size, void* eventFlag
     RMT.int_ena.val |= _INT_RX_END(channel);
     RMT.int_ena.val |= _INT_ERROR(channel);
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.mem_wr_rst = 1;
-
-    RMT.rx_conf[channel].conf1.rx_en = 1;
-#else
     RMT.conf_ch[channel].conf1.mem_wr_rst = 1;
 
     RMT.conf_ch[channel].conf1.rx_en = 1;
-#endif
     RMT_MUTEX_UNLOCK(channel);
 
     // wait for data if requested so
@@ -542,20 +458,14 @@ float rmtSetTick(rmt_obj_t* rmt, float tick)
      * rmt tick for 1 MHz  -> 1us (1x)        div_cnt = 0x01
                               256us (256x)    div_cnt = 0x00
     */
+    int apb_div = _LIMIT(tick/12.5, 256);
+    int ref_div = _LIMIT(tick/1000, 256);
+
+    float apb_tick = 12.5 * apb_div;
+    float ref_tick = 1000.0 * ref_div;
     
     size_t channel = rmt->channel;
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    int apb_div = _LIMIT(tick/25.0, 256);
-    float apb_tick = 25.0 * apb_div;
-    RMT.tx_conf[channel].div_cnt = apb_div & 0xFF;
-    RMT.tx_conf[channel].conf_update = 1;
-    return apb_tick;
-#else
-    int apb_div = _LIMIT(tick/12.5, 256);
-    int ref_div = _LIMIT(tick/1000, 256);
-    float apb_tick = 12.5 * apb_div;
-    float ref_tick = 1000.0 * ref_div;
     if (_ABS(apb_tick - tick) < _ABS(ref_tick - tick)) {
         RMT.conf_ch[channel].conf0.div_cnt = apb_div & 0xFF;
         RMT.conf_ch[channel].conf1.ref_always_on = 1;
@@ -565,7 +475,6 @@ float rmtSetTick(rmt_obj_t* rmt, float tick)
         RMT.conf_ch[channel].conf1.ref_always_on = 0;
         return ref_tick;
     }
-#endif
 }
 
 rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
@@ -620,55 +529,12 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
     rmt->tx_not_rx = tx_not_rx;
     rmt->buffers =buffers;
     rmt->channel = channel;
-    rmt->arg = NULL;
-
     _initPin(pin, channel, tx_not_rx);
 
     // Initialize the registers in default mode:
     // - no carrier, filter
     // - timebase tick of 1us
     // - idle threshold set to 0x8000 (max pulse width + 1)
-#if CONFIG_IDF_TARGET_ESP32C3
-
-    RMT.sys_conf.fifo_mask = 1;
-
-    if (tx_not_rx) {
-    	RMT.tx_lim[channel].limit = MAX_DATA_PER_ITTERATION/2 + 2;
-    	RMT.tx_conf[channel].val = 0;
-//        RMT.tx_conf[channel].carrier_en = 0;
-//        RMT.tx_conf[channel].carrier_out_lv = 0;
-//        RMT.tx_conf[channel].tx_conti_mode = 0;
-//        RMT.tx_conf[channel].idle_out_lv = 0;     // signal level for idle
-//        RMT.tx_conf[channel].tx_start = 0;
-//        RMT.tx_conf[channel].tx_stop = 0;
-//        RMT.tx_conf[channel].carrier_eff_en = 0;
-//        RMT.tx_conf[channel].afifo_rst = 0;
-//        RMT.tx_conf[channel].conf_update = 0;
-//        RMT.tx_conf[channel].mem_tx_wrap_en = 0;
-//        RMT.tx_conf[channel].mem_rst = 1;
-
-        RMT.tx_conf[channel].idle_out_en = 1;     // enable idle
-        RMT.tx_conf[channel].div_cnt = 1;
-        RMT.tx_conf[channel].mem_size = buffers;
-        RMT.tx_conf[channel].mem_rd_rst = 1;
-        RMT.tx_conf[channel].conf_update = 1;
-    } else {
-        RMT.rx_conf[channel].conf0.div_cnt = 1;
-        RMT.rx_conf[channel].conf0.mem_size = buffers;
-        RMT.rx_conf[channel].conf0.carrier_en = 0;
-        RMT.rx_conf[channel].conf0.carrier_out_lv = 0;
-        RMT.rx_conf[channel].conf0.idle_thres = 0x80;
-        RMT.rx_conf[channel].conf1.rx_filter_en = 0;
-        RMT.rx_conf[channel].conf1.rx_filter_thres = 0;
-        RMT.rx_conf[channel].conf1.mem_rst = 0;
-        RMT.rx_conf[channel].conf1.mem_rx_wrap_en = 0;
-        RMT.rx_conf[channel].conf1.afifo_rst = 0;
-        RMT.rx_conf[channel].conf1.conf_update = 0;
-        RMT.rx_conf[channel].conf1.rx_en = 1;
-        RMT.rx_conf[channel].conf1.mem_owner = 1;
-        RMT.rx_conf[channel].conf1.mem_wr_rst = 1;
-    }
-#else
     RMT.conf_ch[channel].conf0.div_cnt = 1;
     RMT.conf_ch[channel].conf0.mem_size = buffers;
     RMT.conf_ch[channel].conf0.carrier_en = 0;
@@ -689,7 +555,6 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
     RMT.conf_ch[channel].conf1.idle_out_lv = 0;     // signal level for idle
     RMT.conf_ch[channel].conf1.idle_out_en = 1;     // enable idle
     RMT.conf_ch[channel].conf1.ref_always_on = 0;     // base clock
-
     RMT.apb_conf.fifo_mask = 1;
 
     if (tx_not_rx) {
@@ -701,7 +566,7 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
         RMT.conf_ch[channel].conf1.mem_owner = 1;
         RMT.conf_ch[channel].conf1.mem_wr_rst = 1;
     }
-#endif
+
     // install interrupt if at least one channel is active
     if (!intr_handle) {
         esp_intr_alloc(ETS_RMT_INTR_SOURCE, (int)ARDUINO_ISR_FLAG, _rmt_isr, NULL, &intr_handle);
@@ -720,11 +585,7 @@ bool _rmtSendOnce(rmt_obj_t* rmt, rmt_data_t* data, size_t size, bool continuous
         return false;
     }
     int channel = rmt->channel;
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.sys_conf.fifo_mask = 1;
-#else
     RMT.apb_conf.fifo_mask = 1;
-#endif
     if (data && size>0) {
         size_t i;
         volatile uint32_t* rmt_mem_ptr = &(RMTMEM.chan[channel].data32[0].val);
@@ -736,15 +597,9 @@ bool _rmtSendOnce(rmt_obj_t* rmt, rmt_data_t* data, size_t size, bool continuous
     }
 
     RMT_MUTEX_LOCK(channel);
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.tx_conf[channel].tx_conti_mode = continuous;
-    RMT.tx_conf[channel].mem_rd_rst = 1;
-    RMT.tx_conf[channel].tx_start = 1;
-#else
     RMT.conf_ch[channel].conf1.tx_conti_mode = continuous;
     RMT.conf_ch[channel].conf1.mem_rd_rst = 1;
     RMT.conf_ch[channel].conf1.tx_start = 1;
-#endif
     RMT_MUTEX_UNLOCK(channel);
 
     return true;
@@ -769,7 +624,6 @@ static void _initPin(int pin, int channel, bool tx_not_rx)
 {
     if (!periph_enabled) {
         periph_enabled = true;
-        periph_module_reset( PERIPH_RMT_MODULE );
         periph_module_enable( PERIPH_RMT_MODULE );
     }
     if (tx_not_rx) {
@@ -785,7 +639,6 @@ static void _initPin(int pin, int channel, bool tx_not_rx)
 
 static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
 {
-	//DEBUG_INTERRUPT_START(4);
     int intr_val = RMT.int_st.val;
     size_t ch;
     for (ch = 0; ch < MAX_CHANNELS; ch++) {
@@ -817,18 +670,12 @@ static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
                     }
                     if (g_rmt_objects[ch].cb) {
                         // actually received data ptr                        
-                        (g_rmt_objects[ch].cb)(data_received, _rmt_get_mem_len(ch), g_rmt_objects[ch].arg);
+                        (g_rmt_objects[ch].cb)(data_received, _rmt_get_mem_len(ch));
 
                         // restart the reception
-#if CONFIG_IDF_TARGET_ESP32C3
-                        RMT.rx_conf[ch].conf1.mem_owner = 1;
-                        RMT.rx_conf[ch].conf1.mem_wr_rst = 1;
-                        RMT.rx_conf[ch].conf1.rx_en = 1;
-#else
                         RMT.conf_ch[ch].conf1.mem_owner = 1;
                         RMT.conf_ch[ch].conf1.mem_wr_rst = 1;
                         RMT.conf_ch[ch].conf1.rx_en = 1;
-#endif
                         RMT.int_ena.val |= _INT_RX_END(ch);
                     } else {
                         // if not callback provide, expect only one Rx
@@ -854,17 +701,10 @@ static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
                 xEventGroupSetBits(g_rmt_objects[ch].events, RMT_FLAG_ERROR);
             }
             // reset memory
-#if CONFIG_IDF_TARGET_ESP32C3
-            RMT.tx_conf[ch].mem_rd_rst = 1;
-            RMT.tx_conf[ch].mem_rd_rst = 0;
-            RMT.rx_conf[ch].conf1.mem_wr_rst = 1;
-            RMT.rx_conf[ch].conf1.mem_wr_rst = 0;
-#else
             RMT.conf_ch[ch].conf1.mem_rd_rst = 1;
             RMT.conf_ch[ch].conf1.mem_rd_rst = 0;
             RMT.conf_ch[ch].conf1.mem_wr_rst = 1;
             RMT.conf_ch[ch].conf1.mem_wr_rst = 0;
-#endif
         }
 
         if (intr_val & _INT_TX_END(ch)) {
@@ -876,24 +716,15 @@ static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
         if (intr_val & _INT_THR_EVNT(ch)) {
             // clear the flag
             RMT.int_clr.val = _INT_THR_EVNT(ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-            //RMT.int_clr.val = _INT_TX_END(ch);
-            //RMT.int_ena.val |= _INT_TX_END(ch);
-#endif
 
             // initial setup of continuous mode
             if (g_rmt_objects[ch].tx_state & E_SET_CONTI) {
-#if CONFIG_IDF_TARGET_ESP32C3
-                RMT.tx_conf[ch].tx_conti_mode = 1;
-#else
                 RMT.conf_ch[ch].conf1.tx_conti_mode = 1;
-#endif
                 g_rmt_objects[ch].intr_mode &= ~E_SET_CONTI;
             }
             _rmt_tx_mem_first(ch);
         }
     }
-    //DEBUG_INTERRUPT_END(4);
 }
 
 static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch)
@@ -903,23 +734,14 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch)
     int half_tx_nr = MAX_DATA_PER_ITTERATION/2;
     int i;
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.tx_lim[ch].limit = half_tx_nr+2;
-#else
     RMT.tx_lim_ch[ch].limit = half_tx_nr+2;
-#endif
     RMT.int_clr.val = _INT_THR_EVNT(ch);
     RMT.int_ena.val |= _INT_THR_EVNT(ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-    //RMT.int_clr.val = _INT_TX_END(ch);
-    //RMT.int_ena.val &= ~_INT_TX_END(ch);
-#endif
 
     g_rmt_objects[ch].tx_state |= E_FIRST_HALF;
 
     if (data) {
         int remaining_size = g_rmt_objects[ch].data_size;
-        //ets_printf("RMT Tx[%d] %d\n", ch, remaining_size);
         // will the remaining data occupy the entire halfbuffer
         if (remaining_size > half_tx_nr) {
             for (i = 0; i < half_tx_nr; i++) {
@@ -938,30 +760,17 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch)
             g_rmt_objects[ch].data_ptr = NULL;
 
         }
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMTMEM.chan[ch].data32[half_tx_nr+i].val = 0;
-        RMT.tx_conf[ch].tx_start = 1;
-#endif
     } else if   ((!(g_rmt_objects[ch].tx_state & E_LAST_DATA)) &&
                  (!(g_rmt_objects[ch].tx_state & E_END_TRANS))) {
-        //ets_printf("RMT Tx finishing %d!\n", ch);
         for (i = 0; i < half_tx_nr; i++) {
             RMTMEM.chan[ch].data32[half_tx_nr+i].val = 0x000F000F;
         }
         RMTMEM.chan[ch].data32[half_tx_nr+i].val = 0;
         g_rmt_objects[ch].tx_state |= E_LAST_DATA;
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMT.tx_conf[ch].tx_conti_mode = 0;
-#else
         RMT.conf_ch[ch].conf1.tx_conti_mode = 0;
-#endif
     } else {
-        //ets_printf("RMT Tx finished %d!\n", ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMT.tx_conf[ch].tx_conti_mode = 0;
-#else
+        log_d("RMT Tx finished %d!\n", ch);
         RMT.conf_ch[ch].conf1.tx_conti_mode = 0;
-#endif
         RMT.int_ena.val &= ~_INT_TX_END(ch);
         RMT.int_ena.val &= ~_INT_THR_EVNT(ch);
         g_rmt_objects[ch].intr_mode = E_NO_INTR;
@@ -977,15 +786,10 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch)
     int half_tx_nr = MAX_DATA_PER_ITTERATION/2;
     int i;
     RMT.int_ena.val &= ~_INT_THR_EVNT(ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.tx_lim[ch].limit = 0;
-#else
     RMT.tx_lim_ch[ch].limit = 0;
-#endif
 
     if (data) {
         int remaining_size = g_rmt_objects[ch].data_size;
-        //ets_printf("RMT TxF[%d] %d\n", ch, remaining_size);
 
         // will the remaining data occupy the entire halfbuffer
         if (remaining_size > half_tx_nr) {
@@ -996,11 +800,7 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch)
             g_rmt_objects[ch].tx_state &= ~E_FIRST_HALF;
             // turn off the treshold interrupt
             RMT.int_ena.val &= ~_INT_THR_EVNT(ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-            RMT.tx_lim[ch].limit = 0;
-#else
             RMT.tx_lim_ch[ch].limit = 0;
-#endif
             g_rmt_objects[ch].data_size -= half_tx_nr;
             g_rmt_objects[ch].data_ptr += half_tx_nr;
         } else {
@@ -1017,37 +817,23 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch)
             g_rmt_objects[ch].data_ptr = NULL;
         }
     } else { 
-        //ets_printf("RMT TxF finished %d!\n", ch);
         for (i = 0; i < half_tx_nr; i++) {
             RMTMEM.chan[ch].data32[i].val = 0x000F000F;
         }
         RMTMEM.chan[ch].data32[i].val = 0;
 
         g_rmt_objects[ch].tx_state &= ~E_FIRST_HALF;
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMT.tx_lim[ch].limit = 0;
-#else
         RMT.tx_lim_ch[ch].limit = 0;
-#endif
         g_rmt_objects[ch].tx_state |= E_LAST_DATA;
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMT.tx_conf[ch].tx_conti_mode = 0;
-#else
         RMT.conf_ch[ch].conf1.tx_conti_mode = 0;
-#endif
     }
     DEBUG_INTERRUPT_END(2);
 }
 
 static int ARDUINO_ISR_ATTR _rmt_get_mem_len(uint8_t channel)
 {
-#if CONFIG_IDF_TARGET_ESP32C3
-    int block_num = RMT.rx_conf[channel].conf0.mem_size;
-    int item_block_len = block_num * 48;
-#else
     int block_num = RMT.conf_ch[channel].conf0.mem_size;
     int item_block_len = block_num * 64;
-#endif
     volatile rmt_item32_t* data = RMTMEM.chan[channel].data32;
     int idx;
     for(idx = 0; idx < item_block_len; idx++) {

cores/esp32/esp32-hal-rmt.h

@@ -40,7 +40,7 @@ typedef enum {
 
 typedef struct rmt_obj_s rmt_obj_t;
 
-typedef void (*rmt_rx_data_cb_t)(uint32_t *data, size_t len, void *arg);
+typedef void (*rmt_rx_data_cb_t)(uint32_t *data, size_t len);
 
 typedef struct {
     union {
@@ -90,13 +90,8 @@ bool rmtReadAsync(rmt_obj_t* rmt, rmt_data_t* data, size_t size, void* eventFlag
 *    and callback with data from ISR
 *
 */
-bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb, void * arg);
+bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb);
 
-/***
- * Ends async receive started with rmtRead(); but does not
- * rmtDeInit().
- */
-bool rmtEnd(rmt_obj_t* rmt);
 
 /*  Additional interface */
 

cores/esp32/esp32-hal-sigmadelta.c

@@ -26,8 +26,6 @@
 #include "esp32/rom/ets_sys.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/ets_sys.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif

cores/esp32/esp32-hal-spi.c

@@ -22,25 +22,19 @@
 #include "soc/spi_struct.h"
 #include "soc/io_mux_reg.h"
 #include "soc/gpio_sig_map.h"
+#include "soc/dport_reg.h"
 #include "soc/rtc.h"
-#include "driver/periph_ctrl.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/gpio.h"
 #include "esp_intr_alloc.h"
 #elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/dport_reg.h"
 #include "esp32s2/rom/ets_sys.h"
 #include "esp32s2/rom/gpio.h"
 #include "esp_intr_alloc.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
-#include "esp32c3/rom/gpio.h"
-#include "esp_intr_alloc.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -68,24 +62,11 @@ struct spi_struct_t {
 
 #define SPI_SPI_SS_IDX(n)   ((n==0)?SPICS0_OUT_IDX:((n==1)?SPICS1_OUT_IDX:0))
 #define SPI_HSPI_SS_IDX(n)  ((n==0)?SPI3_CS0_OUT_IDX:((n==1)?SPI3_CS1_OUT_IDX:((n==2)?SPI3_CS2_OUT_IDX:SPI3_CS0_OUT_IDX)))
-#define SPI_FSPI_SS_IDX(n)  ((n==0)?FSPICS0_OUT_IDX:((n==1)?FSPICS1_OUT_IDX:((n==2)?FSPICS2_OUT_IDX:FSPICS0_OUT_IDX)))
+#define SPI_FSPI_SS_IDX(n)  ((n==0)?FSPICS0_OUT_IDX:((n==1)?FSPICS1_OUT_IDX:((n==2)?FSPICS2_OUT_IDX:VSPICS0_OUT_IDX)))
 #define SPI_SS_IDX(p, n)    ((p==0)?SPI_SPI_SS_IDX(n):((p==1)?SPI_SPI_SS_IDX(n):((p==2)?SPI_HSPI_SS_IDX(n):0)))
 
 #define SPI_INTR_SOURCE(u)  ((u==0)?ETS_SPI1_INTR_SOURCE:((u==1)?ETS_SPI2_INTR_SOURCE:((u==2)?ETS_SPI3_INTR_SOURCE:0)))
 
-#elif CONFIG_IDF_TARGET_ESP32C3
-// ESP32S2
-#define SPI_COUNT           (1)
-
-#define SPI_CLK_IDX(p)      FSPICLK_OUT_IDX
-#define SPI_MISO_IDX(p)     FSPIQ_OUT_IDX
-#define SPI_MOSI_IDX(p)     FSPID_IN_IDX
-
-#define SPI_SPI_SS_IDX(n)   ((n==0)?FSPICS0_OUT_IDX:((n==1)?FSPICS1_OUT_IDX:((n==2)?FSPICS2_OUT_IDX:FSPICS0_OUT_IDX)))
-#define SPI_SS_IDX(p, n)    SPI_SPI_SS_IDX(n)
-
-#define SPI_INTR_SOURCE(u)  ETS_SPI2_INTR_SOURCE
-
 #else
 // ESP32
 #define SPI_COUNT           (4)
@@ -128,8 +109,6 @@ static spi_t _spi_bus_array[] = {
     {(volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 0},
     {(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 1},
     {(volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 2}
-#elif CONFIG_IDF_TARGET_ESP32C3
-    {(volatile spi_dev_t *)(&GPSPI2), NULL, FSPI}
 #else
     {(volatile spi_dev_t *)(DR_REG_SPI0_BASE), NULL, 0},
     {(volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 1},
@@ -152,7 +131,7 @@ void spiAttachSCK(spi_t * spi, int8_t sck)
             log_e("HSPI Does not have default pins on ESP32S2!");
             return;
         }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
         if(spi->num == HSPI) {
             sck = 14;
         } else if(spi->num == VSPI) {
@@ -160,9 +139,6 @@ void spiAttachSCK(spi_t * spi, int8_t sck)
         } else {
             sck = 6;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
     }
     pinMode(sck, OUTPUT);
@@ -182,7 +158,7 @@ void spiAttachMISO(spi_t * spi, int8_t miso)
             log_e("HSPI Does not have default pins on ESP32S2!");
             return;
         }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
         if(spi->num == HSPI) {
             miso = 12;
         } else if(spi->num == VSPI) {
@@ -190,9 +166,6 @@ void spiAttachMISO(spi_t * spi, int8_t miso)
         } else {
             miso = 7;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
     }
     SPI_MUTEX_LOCK();
@@ -214,7 +187,7 @@ void spiAttachMOSI(spi_t * spi, int8_t mosi)
             log_e("HSPI Does not have default pins on ESP32S2!");
             return;
         }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
         if(spi->num == HSPI) {
             mosi = 13;
         } else if(spi->num == VSPI) {
@@ -222,9 +195,6 @@ void spiAttachMOSI(spi_t * spi, int8_t mosi)
         } else {
             mosi = 8;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
     }
     pinMode(mosi, OUTPUT);
@@ -244,7 +214,7 @@ void spiDetachSCK(spi_t * spi, int8_t sck)
             log_e("HSPI Does not have default pins on ESP32S2!");
             return;
         }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
         if(spi->num == HSPI) {
             sck = 14;
         } else if(spi->num == VSPI) {
@@ -252,9 +222,6 @@ void spiDetachSCK(spi_t * spi, int8_t sck)
         } else {
             sck = 6;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
     }
     pinMatrixOutDetach(sck, false, false);
@@ -274,7 +241,7 @@ void spiDetachMISO(spi_t * spi, int8_t miso)
             log_e("HSPI Does not have default pins on ESP32S2!");
             return;
         }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
         if(spi->num == HSPI) {
             miso = 12;
         } else if(spi->num == VSPI) {
@@ -282,9 +249,6 @@ void spiDetachMISO(spi_t * spi, int8_t miso)
         } else {
             miso = 7;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
     }
     pinMatrixInDetach(SPI_MISO_IDX(spi->num), false, false);
@@ -304,7 +268,7 @@ void spiDetachMOSI(spi_t * spi, int8_t mosi)
             log_e("HSPI Does not have default pins on ESP32S2!");
             return;
         }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
         if(spi->num == HSPI) {
             mosi = 13;
         } else if(spi->num == VSPI) {
@@ -312,9 +276,6 @@ void spiDetachMOSI(spi_t * spi, int8_t mosi)
         } else {
             mosi = 8;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
     }
     pinMatrixOutDetach(mosi, false, false);
@@ -338,7 +299,7 @@ void spiAttachSS(spi_t * spi, uint8_t cs_num, int8_t ss)
             log_e("HSPI Does not have default pins on ESP32S2!");
             return;
         }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
         if(spi->num == HSPI) {
             ss = 15;
         } else if(spi->num == VSPI) {
@@ -346,9 +307,6 @@ void spiAttachSS(spi_t * spi, uint8_t cs_num, int8_t ss)
         } else {
             ss = 11;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
     }
     pinMode(ss, OUTPUT);
@@ -369,7 +327,7 @@ void spiDetachSS(spi_t * spi, int8_t ss)
             log_e("HSPI Does not have default pins on ESP32S2!");
             return;
         }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
         if(spi->num == HSPI) {
             ss = 15;
         } else if(spi->num == VSPI) {
@@ -377,9 +335,6 @@ void spiDetachSS(spi_t * spi, int8_t ss)
         } else {
             ss = 11;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
 #endif
     }
     pinMatrixOutDetach(ss, false, false);
@@ -392,7 +347,7 @@ void spiEnableSSPins(spi_t * spi, uint8_t cs_mask)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
     spi->dev->misc.val &= ~(cs_mask & SPI_CS_MASK_ALL);
 #else
     spi->dev->pin.val &= ~(cs_mask & SPI_CS_MASK_ALL);
@@ -406,7 +361,7 @@ void spiDisableSSPins(spi_t * spi, uint8_t cs_mask)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
     spi->dev->misc.val |= (cs_mask & SPI_CS_MASK_ALL);
 #else
     spi->dev->pin.val |= (cs_mask & SPI_CS_MASK_ALL);
@@ -442,7 +397,7 @@ void spiSSSet(spi_t * spi)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
     spi->dev->misc.cs_keep_active = 1;
 #else
     spi->dev->pin.cs_keep_active = 1;
@@ -456,7 +411,7 @@ void spiSSClear(spi_t * spi)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
     spi->dev->misc.cs_keep_active = 0;
 #else
     spi->dev->pin.cs_keep_active = 0;
@@ -487,7 +442,7 @@ uint8_t spiGetDataMode(spi_t * spi)
     if(!spi) {
         return 0;
     }
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
     bool idleEdge = spi->dev->misc.ck_idle_edge;
 #else
     bool idleEdge = spi->dev->pin.ck_idle_edge;
@@ -513,7 +468,7 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
     SPI_MUTEX_LOCK();
     switch (dataMode) {
     case SPI_MODE1:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
         spi->dev->misc.ck_idle_edge = 0;
 #else
         spi->dev->pin.ck_idle_edge = 0;
@@ -521,7 +476,7 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
         spi->dev->user.ck_out_edge = 1;
         break;
     case SPI_MODE2:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
         spi->dev->misc.ck_idle_edge = 1;
 #else
         spi->dev->pin.ck_idle_edge = 1;
@@ -529,7 +484,7 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
         spi->dev->user.ck_out_edge = 1;
         break;
     case SPI_MODE3:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
         spi->dev->misc.ck_idle_edge = 1;
 #else
         spi->dev->pin.ck_idle_edge = 1;
@@ -538,7 +493,7 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
         break;
     case SPI_MODE0:
     default:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
         spi->dev->misc.ck_idle_edge = 0;
 #else
         spi->dev->pin.ck_idle_edge = 0;
@@ -587,11 +542,9 @@ static void _on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb
 
 static void spiInitBus(spi_t * spi)
 {
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->slave.trans_done = 0;
-#endif
-    spi->dev->slave.val = 0;
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+    spi->dev->slave.slave_mode = 0;
+#if CONFIG_IDF_TARGET_ESP32S2
     spi->dev->misc.val = 0;
 #else
     spi->dev->pin.val = 0;
@@ -599,15 +552,8 @@ static void spiInitBus(spi_t * spi)
     spi->dev->user.val = 0;
     spi->dev->user1.val = 0;
     spi->dev->ctrl.val = 0;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->ctrl1.val = 0;
     spi->dev->ctrl2.val = 0;
-#else
-    spi->dev->clk_gate.val = 0;
-    spi->dev->dma_conf.val = 0;
-    spi->dev->dma_conf.rx_afifo_rst = 1;
-    spi->dev->dma_conf.buf_afifo_rst = 1;
-#endif
     spi->dev->clock.val = 0;
 }
 
@@ -616,9 +562,9 @@ void spiStopBus(spi_t * spi)
     if(!spi) {
         return;
     }
-
+    
     removeApbChangeCallback(spi, _on_apb_change);
-
+    
     SPI_MUTEX_LOCK();
     spiInitBus(spi);
     SPI_MUTEX_UNLOCK();
@@ -652,7 +598,7 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI01_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI01_RST);
     }
-#elif CONFIG_IDF_TARGET_ESP32
+#else
     if(spi_num == HSPI) {
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI2_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI2_RST);
@@ -663,24 +609,14 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI01_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI01_RST);
     }
-#elif CONFIG_IDF_TARGET_ESP32C3
-    periph_module_reset( PERIPH_SPI2_MODULE );
-    periph_module_enable( PERIPH_SPI2_MODULE );
 #endif
 
     SPI_MUTEX_LOCK();
     spiInitBus(spi);
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->clk_gate.clk_en = 1;
-    spi->dev->clk_gate.mst_clk_sel = 1;
-    spi->dev->clk_gate.mst_clk_active = 1;
-    spi->dev->dma_conf.tx_seg_trans_clr_en = 1;
-    spi->dev->dma_conf.rx_seg_trans_clr_en = 1;
-    spi->dev->dma_conf.dma_seg_trans_en = 0;
-#endif
     spi->dev->user.usr_mosi = 1;
     spi->dev->user.usr_miso = 1;
     spi->dev->user.doutdin = 1;
+
     int i;
     for(i=0; i<16; i++) {
         spi->dev->data_buf[i] = 0x00000000;
@@ -692,7 +628,6 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
     spiSetClockDiv(spi, clockDiv);
 
     addApbChangeCallback(spi, _on_apb_change);
-
     return spi;
 }
 
@@ -707,11 +642,6 @@ void spiWaitReady(spi_t * spi)
 #if CONFIG_IDF_TARGET_ESP32S2
 #define usr_mosi_dbitlen usr_mosi_bit_len
 #define usr_miso_dbitlen usr_miso_bit_len
-#elif CONFIG_IDF_TARGET_ESP32C3
-#define usr_mosi_dbitlen ms_data_bitlen
-#define usr_miso_dbitlen ms_data_bitlen
-#define mosi_dlen ms_dlen
-#define miso_dlen ms_dlen
 #endif
 
 void spiWrite(spi_t * spi, const uint32_t *data, uint8_t len)
@@ -725,16 +655,10 @@ void spiWrite(spi_t * spi, const uint32_t *data, uint8_t len)
     }
     SPI_MUTEX_LOCK();
     spi->dev->mosi_dlen.usr_mosi_dbitlen = (len * 32) - 1;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     for(i=0; i<len; i++) {
         spi->dev->data_buf[i] = data[i];
     }
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     SPI_MUTEX_UNLOCK();
@@ -755,10 +679,6 @@ void spiTransfer(spi_t * spi, uint32_t *data, uint8_t len)
     for(i=0; i<len; i++) {
         spi->dev->data_buf[i] = data[i];
     }
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     for(i=0; i<len; i++) {
@@ -774,14 +694,8 @@ void spiWriteByte(spi_t * spi, uint8_t data)
     }
     SPI_MUTEX_LOCK();
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     SPI_MUTEX_UNLOCK();
@@ -796,10 +710,6 @@ uint8_t spiTransferByte(spi_t * spi, uint8_t data)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
     spi->dev->miso_dlen.usr_miso_dbitlen = 7;
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0] & 0xFF;
@@ -827,14 +737,8 @@ void spiWriteWord(spi_t * spi, uint16_t data)
     }
     SPI_MUTEX_LOCK();
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     SPI_MUTEX_UNLOCK();
@@ -852,10 +756,6 @@ uint16_t spiTransferWord(spi_t * spi, uint16_t data)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
     spi->dev->miso_dlen.usr_miso_dbitlen = 15;
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0];
@@ -876,14 +776,8 @@ void spiWriteLong(spi_t * spi, uint32_t data)
     }
     SPI_MUTEX_LOCK();
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     SPI_MUTEX_UNLOCK();
@@ -901,10 +795,6 @@ uint32_t spiTransferLong(spi_t * spi, uint32_t data)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
     spi->dev->miso_dlen.usr_miso_dbitlen = 31;
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0];
@@ -944,10 +834,6 @@ static void __spiTransferBytes(spi_t * spi, const uint8_t * data, uint8_t * out,
         spi->dev->data_buf[i] = wordsBuf[i];    //copy buffer to spi fifo
     }
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
 
     while(spi->dev->cmd.usr);
@@ -1012,7 +898,7 @@ void spiTransaction(spi_t * spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bi
     spi->dev->clock.val = clockDiv;
     switch (dataMode) {
     case SPI_MODE1:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
         spi->dev->misc.ck_idle_edge = 0;
 #else
         spi->dev->pin.ck_idle_edge = 0;
@@ -1020,7 +906,7 @@ void spiTransaction(spi_t * spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bi
         spi->dev->user.ck_out_edge = 1;
         break;
     case SPI_MODE2:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
         spi->dev->misc.ck_idle_edge = 1;
 #else
         spi->dev->pin.ck_idle_edge = 1;
@@ -1028,7 +914,7 @@ void spiTransaction(spi_t * spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bi
         spi->dev->user.ck_out_edge = 1;
         break;
     case SPI_MODE3:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
         spi->dev->misc.ck_idle_edge = 1;
 #else
         spi->dev->pin.ck_idle_edge = 1;
@@ -1037,7 +923,7 @@ void spiTransaction(spi_t * spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bi
         break;
     case SPI_MODE0:
     default:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
+#if CONFIG_IDF_TARGET_ESP32S2
         spi->dev->misc.ck_idle_edge = 0;
 #else
         spi->dev->pin.ck_idle_edge = 0;
@@ -1076,14 +962,8 @@ void ARDUINO_ISR_ATTR spiWriteByteNL(spi_t * spi, uint8_t data)
         return;
     }
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
 }
@@ -1096,10 +976,6 @@ uint8_t spiTransferByteNL(spi_t * spi, uint8_t data)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
     spi->dev->miso_dlen.usr_miso_dbitlen = 7;
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0] & 0xFF;
@@ -1115,14 +991,8 @@ void ARDUINO_ISR_ATTR spiWriteShortNL(spi_t * spi, uint16_t data)
         MSB_16_SET(data, data);
     }
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
 }
@@ -1138,10 +1008,6 @@ uint16_t spiTransferShortNL(spi_t * spi, uint16_t data)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
     spi->dev->miso_dlen.usr_miso_dbitlen = 15;
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0] & 0xFFFF;
@@ -1160,14 +1026,8 @@ void ARDUINO_ISR_ATTR spiWriteLongNL(spi_t * spi, uint32_t data)
         MSB_32_SET(data, data);
     }
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
 }
@@ -1183,10 +1043,6 @@ uint32_t spiTransferLongNL(spi_t * spi, uint32_t data)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
     spi->dev->miso_dlen.usr_miso_dbitlen = 31;
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0];
@@ -1197,9 +1053,6 @@ uint32_t spiTransferLongNL(spi_t * spi, uint32_t data)
 }
 
 void spiWriteNL(spi_t * spi, const void * data_in, uint32_t len){
-    if(!spi) {
-        return;
-    }
     size_t longs = len >> 2;
     if(len & 3){
         longs++;
@@ -1212,16 +1065,10 @@ void spiWriteNL(spi_t * spi, const void * data_in, uint32_t len){
         c_longs = (longs > 16)?16:longs;
 
         spi->dev->mosi_dlen.usr_mosi_dbitlen = (c_len*8)-1;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
+        spi->dev->miso_dlen.usr_miso_dbitlen = 0;
         for (int i=0; i<c_longs; i++) {
             spi->dev->data_buf[i] = data[i];
         }
-#if CONFIG_IDF_TARGET_ESP32C3
-        spi->dev->cmd.update = 1;
-        while (spi->dev->cmd.update);
-#endif
         spi->dev->cmd.usr = 1;
         while(spi->dev->cmd.usr);
 
@@ -1258,27 +1105,11 @@ void spiTransferBytesNL(spi_t * spi, const void * data_in, uint8_t * data_out, u
                 spi->dev->data_buf[i] = 0xFFFFFFFF;
             }
         }
-#if CONFIG_IDF_TARGET_ESP32C3
-        spi->dev->cmd.update = 1;
-        while (spi->dev->cmd.update);
-#endif
         spi->dev->cmd.usr = 1;
         while(spi->dev->cmd.usr);
         if(result){
-            if(c_len & 3){
-                for (int i=0; i<(c_longs-1); i++) {
-                    result[i] = spi->dev->data_buf[i];
-                }
-                uint32_t last_data = spi->dev->data_buf[c_longs-1];
-                uint8_t * last_out8 = (uint8_t *)&result[c_longs-1];
-                uint8_t * last_data8 = (uint8_t *)&last_data;
-                for (int i=0; i<(c_len & 3); i++) {
-                    last_out8[i] = last_data8[i];
-                }
-            } else {
-                for (int i=0; i<c_longs; i++) {
-                    result[i] = spi->dev->data_buf[i];
-                }
+            for (int i=0; i<c_longs; i++) {
+                result[i] = spi->dev->data_buf[i];
             }
         }
         if(data){
@@ -1317,10 +1148,6 @@ void spiTransferBitsNL(spi_t * spi, uint32_t data, uint32_t * out, uint8_t bits)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = (bits - 1);
     spi->dev->miso_dlen.usr_miso_dbitlen = (bits - 1);
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0];
@@ -1353,9 +1180,7 @@ void ARDUINO_ISR_ATTR spiWritePixelsNL(spi_t * spi, const void * data_in, uint32
         l_bytes = (c_len & 3);
 
         spi->dev->mosi_dlen.usr_mosi_dbitlen = (c_len*8)-1;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
+        spi->dev->miso_dlen.usr_miso_dbitlen = 0;
         for (int i=0; i<c_longs; i++) {
             if(msb){
                 if(l_bytes && i == (c_longs - 1)){
@@ -1371,10 +1196,6 @@ void ARDUINO_ISR_ATTR spiWritePixelsNL(spi_t * spi, const void * data_in, uint32
                 spi->dev->data_buf[i] = data[i];
             }
         }
-#if CONFIG_IDF_TARGET_ESP32C3
-        spi->dev->cmd.update = 1;
-        while (spi->dev->cmd.update);
-#endif
         spi->dev->cmd.usr = 1;
         while(spi->dev->cmd.usr);
 
@@ -1397,12 +1218,7 @@ typedef union {
             uint32_t clkcnt_l:       6;                     /*it must be equal to spi_clkcnt_N.*/
             uint32_t clkcnt_h:       6;                     /*it must be floor((spi_clkcnt_N+1)/2-1).*/
             uint32_t clkcnt_n:       6;                     /*it is the divider of spi_clk. So spi_clk frequency is system/(spi_clkdiv_pre+1)/(spi_clkcnt_N+1)*/
-#if CONFIG_IDF_TARGET_ESP32C3
-            uint32_t clkdiv_pre:     4;                     /*it is pre-divider of spi_clk.*/
-            uint32_t reserved:       9;  					/*reserved*/
-#else
             uint32_t clkdiv_pre:    13;                     /*it is pre-divider of spi_clk.*/
-#endif
             uint32_t clk_equ_sysclk: 1;                     /*1: spi_clk is eqaul to system 0: spi_clk is divided from system clock.*/
     };
 } spiClk_t;
@@ -1444,13 +1260,8 @@ uint32_t spiFrequencyToClockDiv(uint32_t freq)
 
         while(calPreVari++ <= 1) {
             calPre = (((apb_freq / (reg.clkcnt_n + 1)) / freq) - 1) + calPreVari;
-#if CONFIG_IDF_TARGET_ESP32C3
-            if(calPre > 0xF) {
-                reg.clkdiv_pre = 0xF;
-#else
             if(calPre > 0x1FFF) {
                 reg.clkdiv_pre = 0x1FFF;
-#endif
             } else if(calPre <= 0) {
                 reg.clkdiv_pre = 0;
             } else {

cores/esp32/esp32-hal-spi.h

@@ -25,16 +25,11 @@ extern "C" {
 
 #define SPI_HAS_TRANSACTION
 
-#if CONFIG_IDF_TARGET_ESP32C3
-#define FSPI  0
-#define HSPI  1
-#else
 #define FSPI  1 //SPI bus attached to the flash (can use the same data lines but different SS)
 #define HSPI  2 //SPI bus normally mapped to pins 12 - 15, but can be matrixed to any pins
 #if CONFIG_IDF_TARGET_ESP32
 #define VSPI  3 //SPI bus normally attached to pins 5, 18, 19 and 23, but can be matrixed to any pins
 #endif
-#endif
 
 // This defines are not representing the real Divider of the ESP32
 // the Defines match to an AVR Arduino on 16MHz for better compatibility
@@ -62,7 +57,7 @@ extern "C" {
 struct spi_struct_t;
 typedef struct spi_struct_t spi_t;
 
-spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder);
+spi_t * spiStartBus(uint8_t spi_num, uint32_t freq, uint8_t dataMode, uint8_t bitOrder);
 void spiStopBus(spi_t * spi);
 
 //Attach/Detach Signal Pins

cores/esp32/esp32-hal-timer.c

@@ -14,12 +14,10 @@
 
 #include "esp32-hal-timer.h"
 #include "freertos/FreeRTOS.h"
-#ifndef CONFIG_IDF_TARGET_ESP32C3
 #include "freertos/xtensa_api.h"
-#include "soc/dport_reg.h"
-#endif
 #include "freertos/task.h"
 #include "soc/timer_group_struct.h"
+#include "soc/dport_reg.h"
 #include "esp_attr.h"
 #include "driver/periph_ctrl.h"
 
@@ -32,10 +30,6 @@
 #include "esp32s2/rom/ets_sys.h"
 #include "esp_intr_alloc.h"
 #include "soc/periph_defs.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
-#include "esp_intr_alloc.h"
-#include "soc/periph_defs.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -47,7 +41,7 @@
 #define HWTIMER_LOCK()      portENTER_CRITICAL(timer->lock)
 #define HWTIMER_UNLOCK()    portEXIT_CRITICAL(timer->lock)
 
-typedef volatile struct {
+typedef struct {
     union {
         struct {
             uint32_t reserved0:   10;
@@ -272,12 +266,9 @@ 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
+	// EDGE DOES NOT WORK CURRENTLY
+	edge = false;
+
     static bool initialized = false;
     static intr_handle_t intr_handle = NULL;
     if(intr_handle){
@@ -308,15 +299,12 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
         timer->dev->config.level_int_en = edge?0:1;//When set, an alarm will generate a level type interrupt.
         timer->dev->config.edge_int_en = edge?1:0;//When set, an alarm will generate an edge type interrupt.
         int intr_source = 0;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
         if(!edge){
-#endif
             if(timer->group){
                 intr_source = ETS_TG1_T0_LEVEL_INTR_SOURCE + timer->timer;
             } else {
                 intr_source = ETS_TG0_T0_LEVEL_INTR_SOURCE + timer->timer;
             }
-#ifndef CONFIG_IDF_TARGET_ESP32C3
         } else {
             if(timer->group){
                 intr_source = ETS_TG1_T0_EDGE_INTR_SOURCE + timer->timer;
@@ -324,7 +312,6 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
                 intr_source = ETS_TG0_T0_EDGE_INTR_SOURCE + timer->timer;
             }
         }
-#endif
         if(!initialized){
             initialized = true;
             esp_intr_alloc(intr_source, (int)(ARDUINO_ISR_FLAG|ESP_INTR_FLAG_LOWMED), __timerISR, NULL, &intr_handle);

cores/esp32/esp32-hal-tinyusb.c

@@ -1,8 +1,7 @@
 
 #include "sdkconfig.h"
-#if CONFIG_TINYUSB_ENABLED
+#if CONFIG_USB_ENABLED
 #include <stdlib.h>
-#include <stdbool.h>
 
 #include "esp_log.h"
 
@@ -13,14 +12,10 @@
 #include "soc/usb_reg.h"
 #include "soc/usb_wrap_reg.h"
 #include "soc/usb_wrap_struct.h"
-#include "soc/usb_periph.h"
 #include "soc/periph_defs.h"
 #include "soc/timer_group_struct.h"
 #include "soc/system_reg.h"
 
-#include "hal/usb_hal.h"
-#include "hal/gpio_ll.h"
-
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 
@@ -29,74 +24,12 @@
 
 #include "esp_efuse.h"
 #include "esp_efuse_table.h"
-#include "esp_rom_gpio.h"
 
+#include "tinyusb.h"
 #include "esp32-hal.h"
 
 #include "esp32-hal-tinyusb.h"
 #include "esp32s2/rom/usb/usb_persist.h"
-#include "esp32s2/rom/usb/usb_dc.h"
-#include "esp32s2/rom/usb/chip_usb_dw_wrapper.h"
-
-typedef enum{
-    TINYUSB_USBDEV_0,
-} tinyusb_usbdev_t;
-
-typedef char *tusb_desc_strarray_device_t[USB_STRING_DESCRIPTOR_ARRAY_SIZE];
-
-typedef struct {
-    bool external_phy;
-} tinyusb_config_t;
-
-static void configure_pins(usb_hal_context_t *usb)
-{
-    for (const usb_iopin_dsc_t *iopin = usb_periph_iopins; iopin->pin != -1; ++iopin) {
-        if ((usb->use_external_phy) || (iopin->ext_phy_only == 0)) {
-            esp_rom_gpio_pad_select_gpio(iopin->pin);
-            if (iopin->is_output) {
-                esp_rom_gpio_connect_out_signal(iopin->pin, iopin->func, false, false);
-            } else {
-                esp_rom_gpio_connect_in_signal(iopin->pin, iopin->func, false);
-                if ((iopin->pin != GPIO_FUNC_IN_LOW) && (iopin->pin != GPIO_FUNC_IN_HIGH)) {
-                    gpio_ll_input_enable(&GPIO, iopin->pin);
-                }
-            }
-            esp_rom_gpio_pad_unhold(iopin->pin);
-        }
-    }
-    if (!usb->use_external_phy) {
-        gpio_set_drive_capability(USBPHY_DM_NUM, GPIO_DRIVE_CAP_3);
-        gpio_set_drive_capability(USBPHY_DP_NUM, GPIO_DRIVE_CAP_3);
-    }
-}
-
-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;
-}
-
-
-
-
-
-
-
-
-
 
 typedef char tusb_str_t[127];
 
@@ -228,7 +161,7 @@ typedef struct TU_ATTR_PACKED {
 static tinyusb_desc_webusb_url_t tinyusb_url_descriptor = {
         .bLength         = 3,
         .bDescriptorType = 3, // WEBUSB URL type
-        .bScheme         = 255, // URL Scheme Prefix: 0: "http://", 1: "https://", 255: ""
+        .bScheme         = 1, // URL Scheme Prefix: 0: "http://", 1: "https://", 255: ""
         .url             = ""
 };
 
@@ -317,46 +250,51 @@ uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid)
  */
 uint8_t const * tud_descriptor_bos_cb(void)
 {
-    //log_v("");
+    //log_d("");
     return tinyusb_bos_descriptor;
 }
 
-__attribute__ ((weak)) bool tinyusb_vendor_control_request_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request){ return false; }
+__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; }
 
 /**
  * @brief Handle WebUSB and Vendor requests.
  */
-bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request)
+bool tud_vendor_control_request_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))){
-        // 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);
+        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);
         }
-        return true;
+        // 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);
     }
-    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);
+    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;
 }
 
 /*
  * Required Callbacks
  * */
 #if CFG_TUD_HID
-__attribute__ ((weak)) const uint8_t * tud_hid_descriptor_report_cb(uint8_t itf){return NULL;}
-__attribute__ ((weak)) uint16_t tud_hid_get_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen){return 0;}
-__attribute__ ((weak)) void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, const uint8_t * buffer, uint16_t bufsize){}
+__attribute__ ((weak)) const uint8_t * tud_hid_descriptor_report_cb(void){return NULL;}
+__attribute__ ((weak)) uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen){return 0;}
+__attribute__ ((weak)) void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, const uint8_t * buffer, uint16_t bufsize){}
 #endif
 #if CFG_TUD_MSC
 __attribute__ ((weak)) bool tud_msc_test_unit_ready_cb(uint8_t lun){return false;}
@@ -445,8 +383,8 @@ static bool tinyusb_load_enabled_interfaces(){
     };
     memcpy(tinyusb_config_descriptor, descriptor, TUD_CONFIG_DESC_LEN);
     if ((tinyusb_loaded_interfaces_mask == (BIT(USB_INTERFACE_CDC) | BIT(USB_INTERFACE_DFU))) || (tinyusb_loaded_interfaces_mask == BIT(USB_INTERFACE_CDC))) {
-        //usb_persist_enabled = true;
-        //log_d("USB Persist enabled");
+        usb_persist_enabled = true;
+        log_d("USB Persist enabled");
     }
     log_d("Load Done: if_num: %u, descr_len: %u, if_mask: 0x%x", tinyusb_loaded_interfaces_num, tinyusb_config_descriptor_len, tinyusb_loaded_interfaces_mask);
     return true;
@@ -502,15 +440,6 @@ 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;
-    }
-
     WEBUSB_ENABLED            = config->webusb_enabled;
     USB_DEVICE_ATTRIBUTES     = config->usb_attributes;
     USB_DEVICE_POWER          = config->usb_power_ma;
@@ -528,28 +457,27 @@ static void IRAM_ATTR usb_persist_shutdown_handler(void)
 {
     if(usb_persist_mode != RESTART_NO_PERSIST){
         if (usb_persist_enabled) {
-            usb_dc_prepare_persist();
+            REG_SET_BIT(RTC_CNTL_USB_CONF_REG, RTC_CNTL_IO_MUX_RESET_DISABLE);
+            REG_SET_BIT(RTC_CNTL_USB_CONF_REG, RTC_CNTL_USB_RESET_DISABLE);
         }
         if (usb_persist_mode == RESTART_BOOTLOADER) {
             //USB CDC Download
             if (usb_persist_enabled) {
-                chip_usb_set_persist_flags(USBDC_PERSIST_ENA);
-            } else {
-                periph_module_reset(PERIPH_USB_MODULE);
-                periph_module_enable(PERIPH_USB_MODULE);
+                USB_WRAP.date.val = USBDC_PERSIST_ENA;
             }
             REG_WRITE(RTC_CNTL_OPTION1_REG, RTC_CNTL_FORCE_DOWNLOAD_BOOT);
+            periph_module_disable(PERIPH_TIMG1_MODULE);
         } 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);
+            USB_WRAP.date.val = USBDC_BOOT_DFU;
             REG_WRITE(RTC_CNTL_OPTION1_REG, RTC_CNTL_FORCE_DOWNLOAD_BOOT);
+            periph_module_disable(PERIPH_TIMG0_MODULE);
+            periph_module_disable(PERIPH_TIMG1_MODULE);
         } else if (usb_persist_enabled) {
             //USB Persist reboot
-            chip_usb_set_persist_flags(USBDC_PERSIST_ENA);
+            USB_WRAP.date.val = USBDC_PERSIST_ENA;
         }
+        SET_PERI_REG_MASK(RTC_CNTL_OPTIONS0_REG, RTC_CNTL_SW_PROCPU_RST);
     }
 }
 
@@ -593,18 +521,17 @@ esp_err_t tinyusb_init(tinyusb_device_config_t *config) {
 
     bool usb_did_persist = (USB_WRAP.date.val == USBDC_PERSIST_ENA);
 
-    //if(usb_did_persist && usb_persist_enabled){
+    if(usb_did_persist && usb_persist_enabled){
         // Enable USB/IO_MUX peripheral reset, if coming from persistent reboot
         REG_CLR_BIT(RTC_CNTL_USB_CONF_REG, RTC_CNTL_IO_MUX_RESET_DISABLE);
         REG_CLR_BIT(RTC_CNTL_USB_CONF_REG, RTC_CNTL_USB_RESET_DISABLE);
-    //} else 
-    if(!usb_did_persist || !usb_persist_enabled){
+    } else {
         // Reset USB module
         periph_module_reset(PERIPH_USB_MODULE);
         periph_module_enable(PERIPH_USB_MODULE);
     }
 
-    if (esp_register_shutdown_handler(usb_persist_shutdown_handler) != ESP_OK) {
+    if (usb_persist_enabled && esp_register_shutdown_handler(usb_persist_shutdown_handler) != ESP_OK) {
         initialized = false;
         return ESP_FAIL;
     }
@@ -623,9 +550,11 @@ esp_err_t tinyusb_init(tinyusb_device_config_t *config) {
 
 void usb_persist_restart(restart_type_t mode)
 {
-    if (mode < RESTART_TYPE_MAX) {
+    if (usb_persist_enabled && mode < RESTART_TYPE_MAX) {
         usb_persist_mode = mode;
         esp_restart();
+    } else {
+        log_e("Persistence is not enabled");
     }
 }
 
@@ -770,4 +699,4 @@ void usb_dw_reg_dump(void)
     }
 }
  */
-#endif /* CONFIG_TINYUSB_ENABLED */
+#endif /* CONFIG_USB_ENABLED */

cores/esp32/esp32-hal-tinyusb.h

@@ -16,18 +16,13 @@
 #include "esp32-hal.h"
 
 #if CONFIG_IDF_TARGET_ESP32S2
-#if CONFIG_TINYUSB_ENABLED
+#if CONFIG_USB_ENABLED
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "tusb.h"
-#include "tusb_option.h"
-#include "tusb_config.h"
-
-#define USB_ESPRESSIF_VID 0x303A
-#define USB_STRING_DESCRIPTOR_ARRAY_SIZE 10
+#include "tinyusb.h"
 
 typedef struct {
         uint16_t vid;
@@ -51,10 +46,10 @@ typedef struct {
 #define TINYUSB_CONFIG_DEFAULT() {                                      \
         .vid = USB_ESPRESSIF_VID,                                       \
         .pid = 0x0002,                                                  \
-        .product_name = CONFIG_TINYUSB_DESC_PRODUCT_STRING,                 \
-        .manufacturer_name = CONFIG_TINYUSB_DESC_MANUFACTURER_STRING,       \
-        .serial_number = CONFIG_TINYUSB_DESC_SERIAL_STRING,                 \
-        .fw_version = CONFIG_TINYUSB_DESC_BCDDEVICE,                        \
+        .product_name = CONFIG_USB_DESC_PRODUCT_STRING,                 \
+        .manufacturer_name = CONFIG_USB_DESC_MANUFACTURER_STRING,       \
+        .serial_number = CONFIG_USB_DESC_SERIAL_STRING,                 \
+        .fw_version = CONFIG_USB_DESC_BCDDEVICE,                        \
         .usb_version = 0x0200,                                          \
         .usb_class = TUSB_CLASS_MISC,                                   \
         .usb_subclass = MISC_SUBCLASS_COMMON,                           \
@@ -104,5 +99,5 @@ uint8_t tinyusb_get_free_out_endpoint(void);
 }
 #endif
 
-#endif /* CONFIG_TINYUSB_ENABLED */
+#endif /* CONFIG_USB_ENABLED */
 #endif /* CONFIG_IDF_TARGET_ESP32S2 */

cores/esp32/esp32-hal-touch.c

@@ -13,14 +13,13 @@
 // limitations under the License.
 
 #include "esp32-hal-touch.h"
-#ifndef CONFIG_IDF_TARGET_ESP32C3
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_attr.h"
 #include "soc/rtc_io_reg.h"
+#include "soc/rtc_cntl_reg.h"
 #include "soc/sens_reg.h"
 #include "soc/sens_struct.h"
-#include "soc/rtc_cntl_reg.h"
 #include "driver/touch_sensor.h"
 
 #include "esp_system.h"
@@ -226,4 +225,3 @@ void __touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), uint16_t thresh
 extern uint16_t touchRead(uint8_t pin) __attribute__ ((weak, alias("__touchRead")));
 extern void touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), uint16_t threshold) __attribute__ ((weak, alias("__touchAttachInterrupt")));
 extern void touchSetCycles(uint16_t measure, uint16_t sleep) __attribute__ ((weak, alias("__touchSetCycles")));
-#endif

cores/esp32/esp32-hal-uart.c

@@ -23,25 +23,19 @@
 #include "soc/uart_struct.h"
 #include "soc/io_mux_reg.h"
 #include "soc/gpio_sig_map.h"
+#include "soc/dport_reg.h"
 #include "soc/rtc.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
@@ -51,24 +45,18 @@
 #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
+#if 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))
+#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)))
 #endif
 
 static int s_uart_debug_nr = 0;
@@ -131,7 +119,7 @@ static void ARDUINO_ISR_ATTR _uart_isr(void *arg)
         while(uart->dev->status.rxfifo_cnt) {
         	c = ESP_REG(fifo_reg);
 #endif
-            if(uart->queue != NULL) {
+            if(uart->queue != NULL)  {
                 xQueueSendFromISR(uart->queue, &c, &xHigherPriorityTaskWoken);
             }
         }
@@ -142,10 +130,10 @@ static void ARDUINO_ISR_ATTR _uart_isr(void *arg)
     }
 }
 
-static void uartEnableInterrupt(uart_t* uart, uint8_t rxfifo_full_thrhd)
+void uartEnableInterrupt(uart_t* uart)
 {
     UART_MUTEX_LOCK();
-    uart->dev->conf1.rxfifo_full_thrhd = rxfifo_full_thrhd;
+    uart->dev->conf1.rxfifo_full_thrhd = 112;
 #if CONFIG_IDF_TARGET_ESP32
     uart->dev->conf1.rx_tout_thrhd = 2;
 #else
@@ -161,7 +149,7 @@ static void uartEnableInterrupt(uart_t* uart, uint8_t rxfifo_full_thrhd)
     UART_MUTEX_UNLOCK();
 }
 
-static void uartDisableInterrupt(uart_t* uart)
+void uartDisableInterrupt(uart_t* uart)
 {
     UART_MUTEX_LOCK();
     uart->dev->conf1.val = 0;
@@ -174,7 +162,7 @@ static void uartDisableInterrupt(uart_t* uart)
     UART_MUTEX_UNLOCK();
 }
 
-static void uartDetachRx(uart_t* uart, uint8_t rxPin)
+void uartDetachRx(uart_t* uart)
 {
     if(uart == NULL) {
         return;
@@ -183,25 +171,25 @@ static void uartDetachRx(uart_t* uart, uint8_t rxPin)
     uartDisableInterrupt(uart);
 }
 
-static void uartDetachTx(uart_t* uart, uint8_t txPin)
+void uartDetachTx(uart_t* uart)
 {
     if(uart == NULL) {
         return;
     }
-    pinMatrixOutDetach(txPin, false, false);
+    pinMatrixOutDetach(UART_TXD_IDX(uart->num), false, false);
 }
 
-static void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted, uint8_t rxfifo_full_thrhd)
+void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted)
 {
     if(uart == NULL || rxPin >= GPIO_PIN_COUNT) {
         return;
     }
     pinMode(rxPin, INPUT);
-    uartEnableInterrupt(uart, rxfifo_full_thrhd);
     pinMatrixInAttach(rxPin, UART_RXD_IDX(uart->num), inverted);
+    uartEnableInterrupt(uart);
 }
 
-static void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
+void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
 {
     if(uart == NULL || txPin >= GPIO_PIN_COUNT) {
         return;
@@ -210,7 +198,7 @@ static void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
     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)
+uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted)
 {
     if(uart_nr >= UART_PORTS_NUM) {
         return NULL;
@@ -237,9 +225,6 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
             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);
@@ -252,7 +237,6 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
         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();
@@ -272,7 +256,7 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
     UART_MUTEX_UNLOCK();
 
     if(rxPin != -1) {
-        uartAttachRx(uart, rxPin, inverted, rxfifo_full_thrhd);
+        uartAttachRx(uart, rxPin, inverted);
     }
 
     if(txPin != -1) {
@@ -282,7 +266,7 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
     return uart;
 }
 
-void uartEnd(uart_t* uart, uint8_t txPin, uint8_t rxPin)
+void uartEnd(uart_t* uart)
 {
     if(uart == NULL) {
         return;
@@ -299,8 +283,8 @@ void uartEnd(uart_t* uart, uint8_t txPin, uint8_t rxPin)
 
     UART_MUTEX_UNLOCK();
 
-    uartDetachRx(uart, rxPin);
-    uartDetachTx(uart, txPin);
+    uartDetachRx(uart);
+    uartDetachTx(uart);
 }
 
 size_t uartResizeRxBuffer(uart_t * uart, size_t new_size) {
@@ -313,7 +297,6 @@ size_t uartResizeRxBuffer(uart_t * uart, size_t new_size) {
         vQueueDelete(uart->queue);
         uart->queue = xQueueCreate(new_size, sizeof(uint8_t));
         if(uart->queue == NULL) {
-            UART_MUTEX_UNLOCK();
             return 0;
         }
     }
@@ -322,27 +305,12 @@ size_t uartResizeRxBuffer(uart_t * uart, size_t new_size) {
     return new_size;
 }
 
-void uartSetRxInvert(uart_t* uart, bool invert)
-{
-    if (uart == NULL)
-        return;
-    
-    if (invert)
-        uart->dev->conf0.rxd_inv = 1;
-    else
-        uart->dev->conf0.rxd_inv = 0;
-}
-
 uint32_t uartAvailable(uart_t* uart)
 {
     if(uart == NULL || uart->queue == NULL) {
         return 0;
     }
-#ifdef UART_READ_RX_FIFO
     return (uxQueueMessagesWaiting(uart->queue) + uart->dev->status.rxfifo_cnt) ;
-#else
-    return uxQueueMessagesWaiting(uart->queue);
-#endif
 }
 
 uint32_t uartAvailableForWrite(uart_t* uart)
@@ -353,7 +321,6 @@ uint32_t uartAvailableForWrite(uart_t* uart)
     return 0x7f - uart->dev->status.txfifo_cnt;
 }
 
-#ifdef UART_READ_RX_FIFO
 void uartRxFifoToQueue(uart_t* uart)
 {
 	uint8_t c;
@@ -378,7 +345,6 @@ void uartRxFifoToQueue(uart_t* uart)
 	uart->dev->int_clr.val = 0xffffffff;
     UART_MUTEX_UNLOCK();
 }
-#endif
 
 uint8_t uartRead(uart_t* uart)
 {
@@ -386,12 +352,10 @@ uint8_t uartRead(uart_t* uart)
         return 0;
     }
     uint8_t c;
-#ifdef UART_READ_RX_FIFO
     if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
     {
     	uartRxFifoToQueue(uart);
     }
-#endif
     if(xQueueReceive(uart->queue, &c, 0)) {
         return c;
     }
@@ -404,12 +368,10 @@ uint8_t uartPeek(uart_t* uart)
         return 0;
     }
     uint8_t c;
-#ifdef UART_READ_RX_FIFO
     if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
     {
     	uartRxFifoToQueue(uart);
     }
-#endif
     if(xQueuePeek(uart->queue, &c, 0)) {
         return c;
     }
@@ -422,7 +384,7 @@ void uartWrite(uart_t* uart, uint8_t c)
         return;
     }
     UART_MUTEX_LOCK();
-    while(uart->dev->status.txfifo_cnt >= 0x7E);
+    while(uart->dev->status.txfifo_cnt == 0x7F);
 #if CONFIG_IDF_TARGET_ESP32
     uart->dev->fifo.rw_byte = c;
 #else
@@ -441,7 +403,7 @@ void uartWriteBuf(uart_t* uart, const uint8_t * data, size_t len)
     uint32_t fifo_reg = UART_FIFO_AHB_REG(uart->num);
 #endif
     while(len) {
-        while(uart->dev->status.txfifo_cnt >= 0x7E);
+        while(uart->dev->status.txfifo_cnt == 0x7F);
 #if CONFIG_IDF_TARGET_ESP32
         uart->dev->fifo.rw_byte = *data++;
 #else
@@ -454,7 +416,7 @@ void uartWriteBuf(uart_t* uart, const uint8_t * data, size_t len)
 
 void uartFlush(uart_t* uart)
 {
-    uartFlushTxOnly(uart,true);
+    uartFlushTxOnly(uart,false);
 }
 
 void uartFlushTxOnly(uart_t* uart, bool txOnly)
@@ -493,7 +455,9 @@ void uartSetBaudRate(uart_t* uart, uint32_t baud_rate)
         return;
     }
     UART_MUTEX_LOCK();
-    uart_ll_set_baudrate(uart->dev, baud_rate);
+    uint32_t clk_div = ((getApbFrequency()<<4)/baud_rate);
+    uart->dev->clk_div.div_int = clk_div>>4 ;
+    uart->dev->clk_div.div_frag = clk_div & 0xf;
     UART_MUTEX_UNLOCK();
 }
 
@@ -563,7 +527,7 @@ uint32_t uartGetBaudRate(uart_t* uart)
 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) >= 0x7E);
+    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);
@@ -574,7 +538,7 @@ static void ARDUINO_ISR_ATTR uart0_write_char(char c)
 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) >= 0x7E);
+    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);
@@ -585,7 +549,7 @@ static void ARDUINO_ISR_ATTR uart1_write_char(char c)
 #if CONFIG_IDF_TARGET_ESP32
 static void ARDUINO_ISR_ATTR uart2_write_char(char c)
 {
-    while(((ESP_REG(0x01C+DR_REG_UART2_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) >= 0x7E);
+    while(((ESP_REG(0x01C+DR_REG_UART2_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
     ESP_REG(DR_REG_UART2_BASE) = c;
 }
 #endif
@@ -690,17 +654,15 @@ unsigned long uartBaudrateDetect(uart_t *uart, bool flg)
 */
 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;
-#endif
 }
 
 unsigned long
 uartDetectBaudrate(uart_t *uart)
 {
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     static bool uartStateDetectingBaudrate = false;
 
     if(!uartStateDetectingBaudrate) {
@@ -735,9 +697,6 @@ uartDetectBaudrate(uart_t *uart)
     }
 
     return default_rates[i];
-#else
-    return 0;
-#endif
 }
 
 /*

cores/esp32/esp32-hal-uart.h

@@ -51,8 +51,8 @@ extern "C" {
 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);
+uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted);
+void uartEnd(uart_t* uart);
 
 uint32_t uartAvailable(uart_t* uart);
 uint32_t uartAvailableForWrite(uart_t* uart);
@@ -70,8 +70,6 @@ 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();
 

cores/esp32/esp_arduino_version.h

@@ -1,46 +0,0 @@
-// Copyright 2019 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
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** Major version number (X.x.x) */
-#define ESP_ARDUINO_VERSION_MAJOR   2
-/** Minor version number (x.X.x) */
-#define ESP_ARDUINO_VERSION_MINOR   0
-/** Patch version number (x.x.X) */
-#define ESP_ARDUINO_VERSION_PATCH   0
-
-/**
- * Macro to convert ARDUINO version number into an integer
- *
- * To be used in comparisons, such as ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(2, 0, 0)
- */
-#define ESP_ARDUINO_VERSION_VAL(major, minor, patch) ((major << 16) | (minor << 8) | (patch))
-
-/**
- * Current ARDUINO version, as an integer
- *
- * To be used in comparisons, such as ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(2, 0, 0)
- */
-#define ESP_ARDUINO_VERSION  ESP_ARDUINO_VERSION_VAL(ESP_ARDUINO_VERSION_MAJOR, \
-                                             ESP_ARDUINO_VERSION_MINOR, \
-                                             ESP_ARDUINO_VERSION_PATCH)
-
-#ifdef __cplusplus
-}
-#endif

cores/esp32/main.cpp

@@ -6,14 +6,6 @@
 #include "USB.h"
 #endif
 
-#ifndef ARDUINO_LOOP_STACK_SIZE
-#ifndef CONFIG_ARDUINO_LOOP_STACK_SIZE
-#define ARDUINO_LOOP_STACK_SIZE 8192
-#else
-#define ARDUINO_LOOP_STACK_SIZE CONFIG_ARDUINO_LOOP_STACK_SIZE
-#endif
-#endif
-
 TaskHandle_t loopTaskHandle = NULL;
 
 #if CONFIG_AUTOSTART_ARDUINO
@@ -49,11 +41,10 @@ extern "C" void app_main()
 {
 #if ARDUINO_SERIAL_PORT //Serial used for USB CDC
     USB.begin();
-    Serial.begin();
 #endif
     loopTaskWDTEnabled = false;
     initArduino();
-    xTaskCreateUniversal(loopTask, "loopTask", ARDUINO_LOOP_STACK_SIZE, NULL, 1, &loopTaskHandle, ARDUINO_RUNNING_CORE);
+    xTaskCreateUniversal(loopTask, "loopTask", 8192, NULL, 1, &loopTaskHandle, ARDUINO_RUNNING_CORE);
 }
 
 #endif

cores/esp32/pgmspace.h

@@ -53,8 +53,6 @@ typedef unsigned long prog_uint32_t;
   *(void * const *)(_addr); \
 })
 
-#define pgm_get_far_address(x) ((uint32_t)(&(x)))
-
 #define pgm_read_byte_near(addr)  pgm_read_byte(addr)
 #define pgm_read_word_near(addr)  pgm_read_word(addr)
 #define pgm_read_dword_near(addr) pgm_read_dword(addr)

cores/esp32/stdlib_noniso.c

@@ -28,9 +28,7 @@
 #include <stdint.h>
 #include <math.h>
 #include "stdlib_noniso.h"
-#include "esp_system.h"
 
-#if !CONFIG_DSP_ANSI && !CONFIG_DSP_OPTIMIZED
 void reverse(char* begin, char* end) {
     char *is = begin;
     char *ie = end - 1;
@@ -42,9 +40,6 @@ void reverse(char* begin, char* end) {
         --ie;
     }
 }
-#else
-void reverse(char* begin, char* end);
-#endif
 
 char* ltoa(long value, char* result, int base) {
     if(base < 2 || base > 16) {

cores/esp32/wiring_shift.c

@@ -16,7 +16,7 @@
  Boston, MA  02111-1307  USA
  $Id: wiring.c 248 2007-02-03 15:36:30Z mellis $
  */
-
+ 
 #include "esp32-hal.h"
 #include "wiring_private.h"
 

docs/EXAMPLE_README_TEMPLATE.md

@@ -1,122 +0,0 @@
-# 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/ISSUE_TEMPLATE.md

@@ -1,28 +1,26 @@
 Make your question, not a Statement, inclusive. Include all pertinent information:
 
-What you are trying to do  
-Describe your system (Hardware, computer, O/S, core version, environment)  
-Describe what is failing  
-Show the shortest possible code that will duplicate the error  
-Show the EXACT error message (it doesn't work is not enough)  
+What you are trying to do.
+Describe your system( Hardware, computer, O/S, core version, environment)
+Describe what is failing
+Show the shortest possible code that will duplicate the error
+Show the EXACT error message(it doesn't work is not enough)
 Then if someone is interested and knowledgeable you might get a answer.  All of this work on your part shows us that you have worked to solve YOUR problem. The more complete your issue posting is, the more likely someone will volunteer their time to help you.
 
 If you have a Guru Meditation Error or Backtrace, ***please decode it***:
-[ExceptionDecoder](https://github.com/me-no-dev/EspExceptionDecoder)
+https://github.com/me-no-dev/EspExceptionDecoder
 
 ----------------------------- Remove above -----------------------------
 
 
 ### Hardware:
-|||||||
-|:---|---|---|---|---|---|
-|<B>Board</B>|ESP32 Dev Module|node32|ttgo_lora|ESP32-S2-Saola|Custom w/ ESP32-S2-WROVER 16MB|
-|<B>Version/Date</B>|1.0.4|2.0.0|0badbeef|11/jul/2017|today's master|
-|<B>IDE name</B>|Arduino IDE|Atom + Platform.io|IDF component|VSCode|
-|<B>Flash Frequency</B>|40Mhz|80Mhz|
-|<B>PSRAM enabled</B>|yes|no|
-|<B>Upload Speed</B>|115200|
-|<B>Computer OS</B>|Windows 10|Mac OSX|Ubuntu|
+Board:							?ESP32 Dev Module? ?node32? ?ttgo_lora?
+Core Installation/update date:			?11/jul/2017?
+IDE name:							?Arduino IDE? ?Platform.io? ?IDF component?
+Flash Frequency:					?40Mhz?
+PSRAM enabled:                                          ?no?
+Upload Speed:						?115200?
+Computer OS:                                            ?Windows 10? ?Mac OSX? ?Ubuntu?
 
 ### Description:
 Describe your problem here

docs/Makefile

@@ -1,28 +0,0 @@
-# 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

@@ -0,0 +1,59 @@
+# 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

@@ -0,0 +1,12 @@
+## 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 (32, 64 bit and ARM).
+
+- 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

@@ -0,0 +1,36 @@
+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 python get-pip.py && \
+  sudo pip 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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,29 @@
+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 && \
+  cd esp32 && \
+  git submodule update --init --recursive && \
+  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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,49 @@
+## 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

@@ -0,0 +1,77 @@
+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
+```
+
+## 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

@@ -0,0 +1,14 @@
+## 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

@@ -1,35 +0,0 @@
-@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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -1,5 +0,0 @@
-# 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