Quote {build.source.path} to allow spaces in path (#4868)

Previously sketches or examples that had spaces anywhere in their absolute
path caused a total build failure. By adding quotes around the path in
platform.txt, they now build correctly

Co-authored-by: Me No Dev <me-no-dev@users.noreply.github.com>

.github/scripts/check-cmakelists.sh

@@ -15,9 +15,9 @@ git submodule update --init --recursive
 REPO_SRCS=`find cores/esp32/ libraries/ -name 'examples' -prune -o -name '*.c' -print -o -name '*.cpp' -print | sort`
 
 # find all source files named in CMakeLists.txt COMPONENT_SRCS
-CMAKE_SRCS=`cmake --trace-expand -C CMakeLists.txt 2>&1 | grep set\(srcs | cut -d'(' -f3 | sed 's/ )//' | sed 's/srcs //' | tr ' ;' '\n' | sort`
+CMAKE_SRCS=`cmake --trace-expand -C CMakeLists.txt 2>&1 | grep COMPONENT_SRCS | sed 's/.\+COMPONENT_SRCS //' | sed 's/ )//' | tr ' ;' '\n' | sort`
 
-if ! diff -u0 --label "Repo Files" --label "srcs" <(echo "$REPO_SRCS") <(echo "$CMAKE_SRCS"); then
+if ! diff -u0 --label "Repo Files" --label "COMPONENT_SRCS" <(echo "$REPO_SRCS") <(echo "$CMAKE_SRCS"); then
     echo "Source files in repo (-) and source files in CMakeLists.txt (+) don't match"
     echo "Edit CMakeLists.txt as appropriate to add/remove source files from COMPONENT_SRCS"
     exit 1

.github/scripts/install-arduino-core-esp32.sh

@@ -23,9 +23,9 @@ if [ ! -d "$ARDUINO_ESP32_PATH" ]; then
 		git clone https://github.com/espressif/arduino-esp32.git esp32 > /dev/null 2>&1
 	fi
 
-	#echo "Updating Submodules ..."
+	echo "Updating Submodules ..."
 	cd esp32
-	#git submodule update --init --recursive > /dev/null 2>&1
+	git submodule update --init --recursive > /dev/null 2>&1
 
 	echo "Installing Platform Tools ..."
 	cd tools && python get.py

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

@@ -116,10 +116,9 @@ function build_sketch(){ # build_sketch <fqbn> <path-to-ino> [extra-options]
 		$win_opts $xtra_opts "$sketch"
 }
 
-function count_sketches() # count_sketches <examples-path> <target-mcu>
+function count_sketches() # count_sketches <examples-path>
 {
 	local examples="$1"
-	local target="$2"
     rm -rf sketches.txt
 	if [ ! -d "$examples" ]; then
 		touch sketches.txt
@@ -134,7 +133,7 @@ function count_sketches() # count_sketches <examples-path> <target-mcu>
         if [[ "${sketchdirname}.ino" != "$sketchname" ]]; then
             continue
         fi;
-        if [[ -f "$sketchdir/.skip.$target" ]]; then
+        if [[ -f "$sketchdir/.test.skip" ]]; then
             continue
         fi
         echo $sketch >> sketches.txt
@@ -143,25 +142,24 @@ function count_sketches() # count_sketches <examples-path> <target-mcu>
     return $sketchnum
 }
 
-function build_sketches() # build_sketches <fqbn> <target-mcu> <examples-path> <chunk> <total-chunks> [extra-options]
+function build_sketches() # build_sketches <fqbn> <examples-path> <chunk> <total-chunks> [extra-options]
 {
     local fqbn=$1
-	local target="$2"
-    local examples=$3
-    local chunk_idex=$4
-    local chunks_num=$5
-    local xtra_opts=$6
+    local examples=$2
+    local chunk_idex=$3
+    local chunks_num=$4
+    local xtra_opts=$5
 
-    if [ "$#" -lt 3 ]; then
+    if [ "$#" -lt 2 ]; then
 		echo "ERROR: Illegal number of parameters"
-		echo "USAGE: build_sketches <fqbn> <target-mcu <examples-path> [<chunk> <total-chunks>] [extra-options]"
+		echo "USAGE: build_sketches <fqbn> <examples-path> [<chunk> <total-chunks>] [extra-options]"
 		return 1
 	fi
 
-    if [ "$#" -lt 5 ]; then
+    if [ "$#" -lt 4 ]; then
 		chunk_idex="0"
 		chunks_num="1"
-		xtra_opts=$4
+		xtra_opts=$3
 	fi
 
 	if [ "$chunks_num" -le 0 ]; then
@@ -210,7 +208,7 @@ function build_sketches() # build_sketches <fqbn> <target-mcu> <examples-path> <
         local sketchdirname=$(basename $sketchdir)
         local sketchname=$(basename $sketch)
         if [ "${sketchdirname}.ino" != "$sketchname" ] \
-        || [ -f "$sketchdir/.skip.$target" ]; then
+        || [ -f "$sketchdir/.test.skip" ]; then
             continue
         fi
         sketchnum=$(($sketchnum + 1))

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

@@ -1,7 +1,6 @@
 #!/bin/bash
 
 export PLATFORMIO_ESP32_PATH="$HOME/.platformio/packages/framework-arduinoespressif32"
-PLATFORMIO_ESP32_URL="https://github.com/platformio/platform-espressif32.git#feature/idf-v4.0"
 
 echo "Installing Python Wheel ..."
 pip install wheel > /dev/null 2>&1
@@ -10,10 +9,10 @@ echo "Installing PlatformIO ..."
 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 https://github.com/platformio/platform-espressif32.git > /dev/null 2>&1
 
 echo "Replacing the framework version ..."
-python -c "import json; import os; fp=open(os.path.expanduser('~/.platformio/platforms/espressif32/platform.json'), 'r+'); data=json.load(fp); data['packages']['framework-arduinoespressif32']['version'] = '*'; fp.seek(0); fp.truncate(); json.dump(data, fp); fp.close()"
+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..."
@@ -26,20 +25,19 @@ fi
 echo "PlatformIO for ESP32 has been installed"
 echo ""
 
-function build_pio_sketch(){ # build_pio_sketch <board> <options> <path-to-ino>
-    if [ "$#" -lt 3 ]; then
+function build_pio_sketch(){ # build_pio_sketch <board> <path-to-ino>
+    if [ "$#" -lt 2 ]; then
         echo "ERROR: Illegal number of parameters"
-        echo "USAGE: build_pio_sketch <board> <options> <path-to-ino>"
+        echo "USAGE: build_pio_sketch <board> <path-to-ino>"
         return 1
     fi
 
     local board="$1"
-    local options="$2"
-    local sketch="$3"
+    local sketch="$2"
     local sketch_dir=$(dirname "$sketch")
     echo ""
     echo "Compiling '"$(basename "$sketch")"' ..."
-    python -m platformio ci --board "$board" "$sketch_dir" --project-option="$options"
+    python -m platformio ci --board "$board" "$sketch_dir" --project-option="board_build.partitions = huge_app.csv"
 }
 
 function count_sketches() # count_sketches <examples-path>
@@ -68,21 +66,20 @@ function count_sketches() # count_sketches <examples-path>
     return $sketchnum
 }
 
-function build_pio_sketches() # build_pio_sketches <board> <options> <examples-path> <chunk> <total-chunks>
+function build_pio_sketches() # build_pio_sketches <board> <examples-path> <chunk> <total-chunks>
 {
-    if [ "$#" -lt 3 ]; then
+    if [ "$#" -lt 2 ]; then
         echo "ERROR: Illegal number of parameters"
-        echo "USAGE: build_pio_sketches <board> <options> <examples-path> [<chunk> <total-chunks>]"
+        echo "USAGE: build_pio_sketches <board> <examples-path> [<chunk> <total-chunks>]"
         return 1
     fi
 
     local board=$1
-    local options="$2"
-    local examples=$3
-    local chunk_idex=$4
-    local chunks_num=$5
+    local examples=$2
+    local chunk_idex=$3
+    local chunks_num=$4
 
-    if [ "$#" -lt 5 ]; then
+    if [ "$#" -lt 4 ]; then
         chunk_idex="0"
         chunks_num="1"
     fi
@@ -141,7 +138,7 @@ function build_pio_sketches() # build_pio_sketches <board> <options> <examples-p
         || [ "$sketchnum" -gt "$end_index" ]; then
             continue
         fi
-        build_pio_sketch "$board" "$options" "$sketch"
+        build_pio_sketch "$board" "$sketch"
         local result=$?
         if [ $result -ne 0 ]; then
             return $result

.github/scripts/on-pages.sh

@@ -87,9 +87,15 @@ function git_safe_upload_to_pages(){
 
 EVENT_JSON=`cat $GITHUB_EVENT_PATH`
 
+echo "GITHUB_EVENT_PATH: $GITHUB_EVENT_PATH"
+echo "EVENT_JSON: $EVENT_JSON"
+
 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

.github/scripts/on-push.sh

@@ -30,62 +30,42 @@ elif [ "$CHUNK_INDEX" -eq "$CHUNKS_CNT" ]; then
 	BUILD_PIO=1
 fi
 
-#echo "Updating submodules ..."
-#git -C "$GITHUB_WORKSPACE" submodule update --init --recursive > /dev/null 2>&1
+echo "Updating submodules ..."
+git -C "$GITHUB_WORKSPACE" submodule update --init --recursive > /dev/null 2>&1
 
 if [ "$BUILD_PIO" -eq 0 ]; then
-	# ArduinoIDE ESP32 Test
-    TARGET="esp32"
+	# ArduinoIDE Test
 	FQBN="espressif:esp32:esp32:PSRAM=enabled,PartitionScheme=huge_app"
 	source ./.github/scripts/install-arduino-ide.sh
 	source ./.github/scripts/install-arduino-core-esp32.sh
 	if [ "$OS_IS_WINDOWS" == "1" ]; then
 		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino" && \
 		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/BLE/examples/BLE_server/BLE_server.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/AzureIoT/examples/GetStarted/GetStarted.ino" && \
 		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.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" && \
 		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/BluetoothSerial/examples/SerialToSerialBT/SerialToSerialBT.ino" && \
 		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/BLE/examples/BLE_server/BLE_server.ino" && \
+		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/AzureIoT/examples/GetStarted/GetStarted.ino" && \
 		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino"
 	else
 		# CMake Test
 		if [ "$CHUNK_INDEX" -eq 0 ]; then
 			bash "$ARDUINO_ESP32_PATH/.github/scripts/check-cmakelists.sh"
 		fi
-		build_sketches "$FQBN" "$TARGET" "$ARDUINO_ESP32_PATH/libraries" "$CHUNK_INDEX" "$CHUNKS_CNT"
+		build_sketches "$FQBN" "$ARDUINO_ESP32_PATH/libraries" "$CHUNK_INDEX" "$CHUNKS_CNT"
 	fi
-
-	# ArduinoIDE ESP32S2 Test
-    TARGET="esp32s2"
-	FQBN="espressif:esp32:esp32s2:PSRAM=enabled,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
+	# PlatformIO Test
 	source ./.github/scripts/install-platformio-esp32.sh
-	# PlatformIO ESP32 Test
 	BOARD="esp32dev"
-    OPTIONS="board_build.partitions = huge_app.csv"
-	build_pio_sketch "$BOARD" "$OPTIONS" "$PLATFORMIO_ESP32_PATH/libraries/WiFi/examples/WiFiClient/WiFiClient.ino" && \
-	build_pio_sketch "$BOARD" "$OPTIONS" "$PLATFORMIO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino" && \
-	build_pio_sketch "$BOARD" "$OPTIONS" "$PLATFORMIO_ESP32_PATH/libraries/BluetoothSerial/examples/SerialToSerialBT/SerialToSerialBT.ino" && \
-	build_pio_sketch "$BOARD" "$OPTIONS" "$PLATFORMIO_ESP32_PATH/libraries/BLE/examples/BLE_server/BLE_server.ino" && \
-	build_pio_sketch "$BOARD" "$OPTIONS" "$PLATFORMIO_ESP32_PATH/libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino"
-	
-	# PlatformIO ESP32 Test
-    # OPTIONS="board_build.mcu = esp32s2"
-    # build_pio_sketch "$BOARD" "$OPTIONS" "$PLATFORMIO_ESP32_PATH/libraries/WiFi/examples/WiFiClient/WiFiClient.ino" && \
-    # build_pio_sketch "$BOARD" "$OPTIONS" "$PLATFORMIO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino"
-
-    python -m platformio ci --board "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/WiFi/examples/WiFiClient" --project-option="board_build.mcu = esp32s2" --project-option="board_build.partitions = huge_app.csv"
-    
-	#build_pio_sketches "$BOARD" "$OPTIONS" "$PLATFORMIO_ESP32_PATH/libraries"
+	build_pio_sketch "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/WiFi/examples/WiFiClient/WiFiClient.ino" && \
+	build_pio_sketch "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino" && \
+	build_pio_sketch "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/BluetoothSerial/examples/SerialToSerialBT/SerialToSerialBT.ino" && \
+	build_pio_sketch "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/BLE/examples/BLE_server/BLE_server.ino" && \
+	build_pio_sketch "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/AzureIoT/examples/GetStarted/GetStarted.ino" && \
+	build_pio_sketch "$BOARD" "$PLATFORMIO_ESP32_PATH/libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino"
+	#build_pio_sketches esp32dev "$PLATFORMIO_ESP32_PATH/libraries"
 fi

.github/scripts/on-release.sh

@@ -171,18 +171,19 @@ mkdir -p "$PKG_DIR/tools"
 
 # Copy all core files to the package folder
 echo "Copying files for packaging ..."
-cp -f  "$GITHUB_WORKSPACE/boards.txt"              "$PKG_DIR/"
-cp -f  "$GITHUB_WORKSPACE/programmers.txt"         "$PKG_DIR/"
-cp -Rf "$GITHUB_WORKSPACE/cores"                   "$PKG_DIR/"
-cp -Rf "$GITHUB_WORKSPACE/libraries"               "$PKG_DIR/"
-cp -Rf "$GITHUB_WORKSPACE/variants"                "$PKG_DIR/"
-cp -f  "$GITHUB_WORKSPACE/tools/espota.exe"        "$PKG_DIR/tools/"
-cp -f  "$GITHUB_WORKSPACE/tools/espota.py"         "$PKG_DIR/tools/"
-cp -f  "$GITHUB_WORKSPACE/tools/esptool.py"        "$PKG_DIR/tools/"
-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/boards.txt"                "$PKG_DIR/"
+cp -f  "$GITHUB_WORKSPACE/programmers.txt"           "$PKG_DIR/"
+cp -Rf "$GITHUB_WORKSPACE/cores"                     "$PKG_DIR/"
+cp -Rf "$GITHUB_WORKSPACE/libraries"                 "$PKG_DIR/"
+cp -Rf "$GITHUB_WORKSPACE/variants"                  "$PKG_DIR/"
+cp -f  "$GITHUB_WORKSPACE/tools/espota.exe"          "$PKG_DIR/tools/"
+cp -f  "$GITHUB_WORKSPACE/tools/espota.py"           "$PKG_DIR/tools/"
+cp -f  "$GITHUB_WORKSPACE/tools/esptool.py"          "$PKG_DIR/tools/"
+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 ..."
@@ -254,17 +255,30 @@ 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(.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')
+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")
 shopt -s nocasematch
-if [ "$prev_any_release" == "$RELEASE_TAG" ]; then
-    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')
+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")
 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 ..."
@@ -272,17 +286,12 @@ 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"`
@@ -327,21 +336,35 @@ 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 ..."
-    commitFile=$OUTPUT_DIR/commits.txt
-    git -C "$GITHUB_WORKSPACE" log --oneline "$COMMITS_SINCE_RELEASE..HEAD" > "$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
+    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"
 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,12 +12,9 @@ onlyLabels: []
 
 # Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
 exemptLabels:
-  - pinned
-  - security
-  - "to be implemented"
-  - "for reference"
-  - "move to PR"
-  - "enhancement"
+  - "Type: For reference"
+  - "Type: To be implemented"
+  - "Type: Feature request"
 
 # Set to true to ignore issues in a project (defaults to false)
 exemptProjects: false
@@ -29,7 +26,7 @@ exemptMilestones: false
 exemptAssignees: false
 
 # Label to use when marking as stale
-staleLabel: stale
+staleLabel: Status: Stale
 
 # Comment to post when marking as stale. Set to `false` to disable
 markComment: >

.github/workflows/gh-pages.yml

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

.github/workflows/release.yml

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

.gitignore

@@ -3,8 +3,8 @@ tools/xtensa-esp32s2-elf
 tools/dist
 tools/esptool
 tools/esptool.exe
-tools/mkspiffs/mkspiffs
-tools/mkspiffs/mkspiffs.exe
+tools/mkspiffs
+tools/mklittlefs
 .DS_Store
  
 #Ignore files built by Visual Studio/Visual Micro
@@ -14,6 +14,3 @@ tools/mkspiffs/mkspiffs.exe
 __vm/
 *.vcxproj*
 .vscode/
-platform.sloeber.txt
-boards.sloeber.txt
-tools/mklittlefs

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "libraries/AzureIoT"]
+	path = libraries/AzureIoT
+	url = https://github.com/VSChina/ESP32_AzureIoT_Arduino

CMakeLists.txt

@@ -7,6 +7,7 @@ set(CORE_SRCS
   cores/esp32/esp32-hal-dac.c
   cores/esp32/esp32-hal-gpio.c
   cores/esp32/esp32-hal-i2c.c
+  cores/esp32/esp32-hal-log.c
   cores/esp32/esp32-hal-ledc.c
   cores/esp32/esp32-hal-matrix.c
   cores/esp32/esp32-hal-misc.c
@@ -15,7 +16,6 @@ set(CORE_SRCS
   cores/esp32/esp32-hal-spi.c
   cores/esp32/esp32-hal-time.c
   cores/esp32/esp32-hal-timer.c
-  cores/esp32/esp32-hal-tinyusb.c
   cores/esp32/esp32-hal-touch.c
   cores/esp32/esp32-hal-uart.c
   cores/esp32/esp32-hal-rmt.c
@@ -32,8 +32,6 @@ set(CORE_SRCS
   cores/esp32/stdlib_noniso.c
   cores/esp32/Stream.cpp
   cores/esp32/StreamString.cpp
-  cores/esp32/USB.cpp
-  cores/esp32/USBCDC.cpp
   cores/esp32/wiring_pulse.c
   cores/esp32/wiring_shift.c
   cores/esp32/WMath.cpp
@@ -52,7 +50,6 @@ 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/NetBIOS/src/NetBIOS.cpp
   libraries/Preferences/src/Preferences.cpp
   libraries/SD_MMC/src/SD_MMC.cpp
@@ -84,6 +81,66 @@ set(LIBRARY_SRCS
   libraries/Wire/src/Wire.cpp
   )
 
+set(AZURE_SRCS
+  libraries/AzureIoT/src/az_iot/azureiotcerts.c
+  libraries/AzureIoT/src/az_iot/c-utility/pal/agenttime.c
+  libraries/AzureIoT/src/az_iot/c-utility/pal/dns_async.c
+  libraries/AzureIoT/src/az_iot/c-utility/pal/freertos/lock.c
+  libraries/AzureIoT/src/az_iot/c-utility/pal/freertos/threadapi.c
+  libraries/AzureIoT/src/az_iot/c-utility/pal/freertos/tickcounter.c
+  libraries/AzureIoT/src/az_iot/c-utility/pal/lwip/sntp_lwip.c
+  libraries/AzureIoT/src/az_iot/c-utility/pal/socket_async.c
+  libraries/AzureIoT/src/az_iot/c-utility/pal/src/platform_openssl_compact.c
+  libraries/AzureIoT/src/az_iot/c-utility/pal/src/tlsio_openssl_compact.c
+  libraries/AzureIoT/src/az_iot/c-utility/pal/tlsio_options.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/base64.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/buffer.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/connection_string_parser.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/consolelogger.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/constbuffer.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/constmap.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/crt_abstractions.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/doublylinkedlist.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/gballoc.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/gb_stdio.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/gb_time.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/hmac.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/hmacsha256.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/httpapiex.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/httpapiexsas.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/httpheaders.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/http_proxy_io.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/map.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/optionhandler.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/sastoken.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/sha1.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/sha224.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/sha384-512.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/singlylinkedlist.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/strings.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/string_tokenizer.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/urlencode.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/usha.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/vector.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/xio.c
+  libraries/AzureIoT/src/az_iot/c-utility/src/xlogging.c
+  libraries/AzureIoT/src/az_iot/iothub_client/src/blob.c
+  libraries/AzureIoT/src/az_iot/iothub_client/src/iothub_client_authorization.c
+  libraries/AzureIoT/src/az_iot/iothub_client/src/iothub_client.c
+  libraries/AzureIoT/src/az_iot/iothub_client/src/iothub_client_ll.c
+  libraries/AzureIoT/src/az_iot/iothub_client/src/iothub_client_retry_control.c
+  libraries/AzureIoT/src/az_iot/iothub_client/src/iothub_message.c
+  libraries/AzureIoT/src/az_iot/iothub_client/src/iothubtransport.c
+  libraries/AzureIoT/src/az_iot/iothub_client/src/iothubtransportmqtt.c
+  libraries/AzureIoT/src/az_iot/iothub_client/src/iothubtransport_mqtt_common.c
+  libraries/AzureIoT/src/az_iot/iothub_client/src/version.c
+  libraries/AzureIoT/src/az_iot/umqtt/src/mqtt_client.c
+  libraries/AzureIoT/src/az_iot/umqtt/src/mqtt_codec.c
+  libraries/AzureIoT/src/az_iot/umqtt/src/mqtt_message.c
+  libraries/AzureIoT/src/AzureIotHub.cpp
+  libraries/AzureIoT/src/Esp32MQTTClient.cpp
+  )
+
 set(BLE_SRCS
   libraries/BLE/src/BLE2902.cpp
   libraries/BLE/src/BLE2904.cpp
@@ -116,12 +173,14 @@ set(BLE_SRCS
   libraries/BLE/src/GeneralUtils.cpp
   )
 
+set(COMPONENT_SRCS ${CORE_SRCS} ${LIBRARY_SRCS} ${AZURE_SRCS} ${BLE_SRCS})
 
-set(includedirs
+set(COMPONENT_ADD_INCLUDEDIRS
   variants/esp32/
   cores/esp32/
   libraries/ArduinoOTA/src
   libraries/AsyncUDP/src
+  libraries/AzureIoT/src
   libraries/BLE/src
   libraries/BluetoothSerial/src
   libraries/DNSServer/src
@@ -132,7 +191,6 @@ set(includedirs
   libraries/FS/src
   libraries/HTTPClient/src
   libraries/HTTPUpdate/src
-  libraries/LITTLEFS/src
   libraries/NetBIOS/src
   libraries/Preferences/src
   libraries/SD_MMC/src
@@ -149,16 +207,14 @@ set(includedirs
   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)
-set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support openssl bt tinyusb main)
+set(COMPONENT_PRIV_INCLUDEDIRS cores/esp32/libb64)
 
-idf_component_register(INCLUDE_DIRS ${includedirs} PRIV_INCLUDE_DIRS ${priv_includes} SRCS ${srcs} REQUIRES ${requires} PRIV_REQUIRES ${priv_requires})
+set(COMPONENT_REQUIRES spi_flash mbedtls mdns ethernet esp_adc_cal wifi_provisioning)
+set(COMPONENT_PRIV_REQUIRES fatfs nvs_flash app_update spiffs bootloader_support openssl bt esp_http_client esp_https_ota)
 
-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()
-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()
+register_component()
+
+set_source_files_properties(libraries/AzureIoT/src/az_iot/iothub_client/src/iothubtransport_mqtt_common.c
+    PROPERTIES COMPILE_FLAGS
+    -Wno-maybe-uninitialized
+)

Kconfig.projbuild

@@ -5,7 +5,7 @@ config ENABLE_ARDUINO_DEPENDS
     select LWIP_SO_RCVBUF
     select ETHERNET
     select WIFI_ENABLED
-    select ESP32_PHY_CALIBRATION_AND_DATA_STORAGE if IDF_TARGET_ESP32
+    select ESP32_PHY_CALIBRATION_AND_DATA_STORAGE
     select MEMMAP_SMP
     default "y"
 
@@ -40,6 +40,12 @@ 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
@@ -88,16 +94,6 @@ config ARDUINO_UDP_RUNNING_CORE
     default 1 if ARDUINO_UDP_RUN_CORE1
     default -1 if ARDUINO_UDP_RUN_NO_AFFINITY
 
-config ARDUINO_ISR_IRAM
-    bool "Run interrupts in IRAM"
-    default "n"
-    help
-        Enabling this option will Attach all interrupts with the IRAm flag.
-        It will also make some HAL function, like, digitalRead/Write and more
-				be loaded into IRAM for access inside ISRs.
-				Beware that this is a very dangerous setting. Enable it only if you
-				are fully aware of the consequences.
-
 config DISABLE_HAL_LOCKS
     bool "Disable mutex locks for HAL"
     default "n"

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"
@@ -116,12 +115,10 @@ typedef bool boolean;
 typedef uint8_t byte;
 typedef unsigned int word;
 
-#ifdef __cplusplus
 void setup(void);
 void loop(void);
 
 long random(long, long);
-#endif
 void randomSeed(unsigned long);
 long map(long, long, long, long, long);
 

cores/esp32/Esp.cpp

@@ -19,10 +19,12 @@
 
 #include "Arduino.h"
 #include "Esp.h"
+#include "rom/spi_flash.h"
 #include "esp_sleep.h"
 #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"
@@ -30,20 +32,6 @@ extern "C" {
 }
 #include <MD5Builder.h>
 
-#include "esp_system.h"
-#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"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/spi_flash.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/spi_flash.h"
-#endif
-
 /**
  * User-defined Literals
  *  usage:
@@ -133,36 +121,24 @@ uint32_t EspClass::getMaxAllocHeap(void)
 
 uint32_t EspClass::getPsramSize(void)
 {
-	if(psramFound()){
-	    multi_heap_info_t info;
-	    heap_caps_get_info(&info, MALLOC_CAP_SPIRAM);
-	    return info.total_free_bytes + info.total_allocated_bytes;
-	}
-	return 0;
+    multi_heap_info_t info;
+    heap_caps_get_info(&info, MALLOC_CAP_SPIRAM);
+    return info.total_free_bytes + info.total_allocated_bytes;
 }
 
 uint32_t EspClass::getFreePsram(void)
 {
-	if(psramFound()){
-	    return heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
-	}
-	return 0;
+    return heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
 }
 
 uint32_t EspClass::getMinFreePsram(void)
 {
-	if(psramFound()){
-	    return heap_caps_get_minimum_free_size(MALLOC_CAP_SPIRAM);
-	}
-	return 0;
+    return heap_caps_get_minimum_free_size(MALLOC_CAP_SPIRAM);
 }
 
 uint32_t EspClass::getMaxAllocPsram(void)
 {
-	if(psramFound()){
-	    return heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM);
-	}
-	return 0;
+    return heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM);
 }
 
 static uint32_t sketchSize(sketchSize_t response) {
@@ -244,7 +220,6 @@ uint8_t EspClass::getChipRevision(void)
 
 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) {
@@ -258,14 +233,9 @@ const char * EspClass::getChipModel(void)
             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";
-#endif
 }
 
 uint8_t EspClass::getChipCores(void)

cores/esp32/Esp.h

@@ -108,7 +108,7 @@ public:
 
 };
 
-uint32_t ARDUINO_ISR_ATTR EspClass::getCycleCount()
+uint32_t IRAM_ATTR EspClass::getCycleCount()
 {
     uint32_t ccount;
     __asm__ __volatile__("esync; rsr %0,ccount":"=a" (ccount));

cores/esp32/FunctionalInterrupt.cpp

@@ -16,7 +16,7 @@ extern "C"
 	extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc, void * arg, int intr_type, bool functional);
 }
 
-void ARDUINO_ISR_ATTR interruptFunctional(void* arg)
+void IRAM_ATTR interruptFunctional(void* arg)
 {
     InterruptArgStructure* localArg = (InterruptArgStructure*)arg;
 	if (localArg->interruptFunction)

cores/esp32/HardwareSerial.cpp

@@ -6,8 +6,6 @@
 #include "pins_arduino.h"
 #include "HardwareSerial.h"
 
-#if CONFIG_IDF_TARGET_ESP32
-
 #ifndef RX1
 #define RX1 9
 #endif
@@ -24,29 +22,11 @@
 #define TX2 17
 #endif
 
-#else
-
-#ifndef RX1
-#define RX1 18
-#endif
-
-#ifndef TX1
-#define TX1 17
-#endif
-
-#endif
-
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL)
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
-HardwareSerial Serial0(0);
-#else
 HardwareSerial Serial(0);
-#endif
 HardwareSerial Serial1(1);
-#if CONFIG_IDF_TARGET_ESP32
 HardwareSerial Serial2(2);
 #endif
-#endif
 
 HardwareSerial::HardwareSerial(int uart_nr) : _uart_nr(uart_nr), _uart(NULL) {}
 
@@ -60,24 +40,18 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
         end();
     }
     if(_uart_nr == 0 && rxPin < 0 && txPin < 0) {
-#if CONFIG_IDF_TARGET_ESP32
         rxPin = 3;
         txPin = 1;
-#elif CONFIG_IDF_TARGET_ESP32S2
-        rxPin = 44;
-        txPin = 43;
-#endif
     }
     if(_uart_nr == 1 && rxPin < 0 && txPin < 0) {
         rxPin = RX1;
         txPin = TX1;
     }
-#if CONFIG_IDF_TARGET_ESP32
     if(_uart_nr == 2 && rxPin < 0 && txPin < 0) {
         rxPin = RX2;
         txPin = TX2;
     }
-#endif
+
     _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, 256, invert);
     _tx_pin = txPin;
     _rx_pin = rxPin;
@@ -132,7 +106,7 @@ void HardwareSerial::setDebugOutput(bool en)
         uartSetDebug(_uart);
     } else {
         if(uartGetDebug() == _uart_nr) {
-            uartSetDebug(NULL);
+            uartSetDebug(0);
         }
     }
 }

cores/esp32/HardwareSerial.h

@@ -113,20 +113,9 @@ protected:
 extern void serialEventRun(void) __attribute__((weak));
 
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL)
-#ifndef ARDUINO_SERIAL_PORT
-#define ARDUINO_SERIAL_PORT 0
-#endif
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
-#include "USB.h"
-#include "USBCDC.h"
-extern HardwareSerial Serial0;
-#else
 extern HardwareSerial Serial;
-#endif
 extern HardwareSerial Serial1;
-#if CONFIG_IDF_TARGET_ESP32
 extern HardwareSerial Serial2;
 #endif
-#endif
 
 #endif // HardwareSerial_h

cores/esp32/MD5Builder.h

@@ -21,19 +21,7 @@
 
 #include <WString.h>
 #include <Stream.h>
-
-#include "esp_system.h"
-#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "esp32/rom/md5_hash.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/md5_hash.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
 #include "rom/md5_hash.h"
-#endif
 
 class MD5Builder
 {

cores/esp32/Print.h

@@ -73,6 +73,11 @@ 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[]);

cores/esp32/USB.cpp

@@ -1,338 +0,0 @@
-// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#include "esp32-hal.h"
-#include "esp32-hal-tinyusb.h"
-#include "USB.h"
-#if CONFIG_USB_ENABLED
-
-#ifndef USB_VID
-#define USB_VID USB_ESPRESSIF_VID
-#endif
-#ifndef USB_PID
-#define USB_PID 0x0002
-#endif
-#ifndef USB_MANUFACTURER
-#define USB_MANUFACTURER "Espressif Systems"
-#endif
-#ifndef USB_PRODUCT
-#define USB_PRODUCT ARDUINO_BOARD
-#endif
-#ifndef USB_SERIAL
-#define USB_SERIAL "0"
-#endif
-
-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
-#define DFU_ATTR_CAN_UPLOAD                2
-#define DFU_ATTR_MANIFESTATION_TOLERANT    4
-#define DFU_ATTR_WILL_DETACH               8
-#define DFU_ATTRS (DFU_ATTR_CAN_DOWNLOAD | DFU_ATTR_CAN_UPLOAD | DFU_ATTR_MANIFESTATION_TOLERANT)
-
-    uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB DFU_RT");
-    uint8_t descriptor[TUD_DFU_RT_DESC_LEN] = {
-            // Interface number, string index, attributes, detach timeout, transfer size */
-            TUD_DFU_RT_DESCRIPTOR(*itf, str_index, DFU_ATTRS, 700, 64)
-    };
-    *itf+=1;
-    memcpy(dst, descriptor, TUD_DFU_RT_DESC_LEN);
-    return TUD_DFU_RT_DESC_LEN;
-}
-// Invoked on DFU_DETACH request to reboot to the bootloader
-void tud_dfu_rt_reboot_to_dfu(void)
-{
-    usb_persist_restart(RESTART_BOOTLOADER_DFU);
-}
-#endif /* CFG_TUD_DFU_RT */
-
-ESP_EVENT_DEFINE_BASE(ARDUINO_USB_EVENTS);
-
-static esp_event_loop_handle_t arduino_usb_event_loop_handle = NULL;
-
-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){
-    if(arduino_usb_event_loop_handle == NULL){
-        return ESP_FAIL;
-    }
-    return esp_event_post_to(arduino_usb_event_loop_handle, event_base, event_id, event_data, event_data_size, ticks_to_wait);
-}
-esp_err_t arduino_usb_event_handler_register_with(esp_event_base_t event_base, int32_t event_id, esp_event_handler_t event_handler, void *event_handler_arg){
-    if(arduino_usb_event_loop_handle == NULL){
-        return ESP_FAIL;
-    }
-    return esp_event_handler_register_with(arduino_usb_event_loop_handle, event_base, event_id, event_handler, event_handler_arg);
-}
-
-static bool tinyusb_device_mounted = false;
-static bool tinyusb_device_suspended = false;
-
-// Invoked when device is mounted (configured)
-void tud_mount_cb(void){
-    tinyusb_device_mounted = true;
-    arduino_usb_event_data_t p = {0};
-    arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_STARTED_EVENT, &p, sizeof(arduino_usb_event_data_t), portMAX_DELAY);
-}
-
-// Invoked when device is unmounted
-void tud_umount_cb(void){
-    tinyusb_device_mounted = false;
-    arduino_usb_event_data_t p = {0};
-    arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_STOPPED_EVENT, &p, sizeof(arduino_usb_event_data_t), portMAX_DELAY);
-}
-
-// Invoked when usb bus is suspended
-// Within 7ms, device must draw an average of current less than 2.5 mA from bus
-void tud_suspend_cb(bool remote_wakeup_en){
-    tinyusb_device_suspended = true;
-    arduino_usb_event_data_t p = {0};
-    p.suspend.remote_wakeup_en = remote_wakeup_en;
-    arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_SUSPEND_EVENT, &p, sizeof(arduino_usb_event_data_t), portMAX_DELAY);
-}
-
-// Invoked when usb bus is resumed
-void tud_resume_cb(void){
-    tinyusb_device_suspended = false;
-    arduino_usb_event_data_t p = {0};
-    arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_RESUME_EVENT, &p, sizeof(arduino_usb_event_data_t), portMAX_DELAY);
-}
-
-ESPUSB::ESPUSB(size_t task_stack_size, uint8_t event_task_priority)
-:vid(USB_VID)
-,pid(USB_PID)
-,product_name(USB_PRODUCT)
-,manufacturer_name(USB_MANUFACTURER)
-,serial_number(USB_SERIAL)
-,fw_version(0x0100)
-,usb_version(0x0200)// at least 2.1 or 3.x for BOS & webUSB
-,usb_class(TUSB_CLASS_MISC)
-,usb_subclass(MISC_SUBCLASS_COMMON)
-,usb_protocol(MISC_PROTOCOL_IAD)
-,usb_attributes(TUSB_DESC_CONFIG_ATT_SELF_POWERED)
-,usb_power_ma(500)
-,webusb_enabled(false)
-,webusb_url("espressif.github.io/arduino-esp32/webusb.html")
-,_started(false)
-,_task_stack_size(task_stack_size)
-,_event_task_priority(event_task_priority)
-{
-    if (!arduino_usb_event_loop_handle) {
-        esp_event_loop_args_t event_task_args = {
-            .queue_size = 5,
-            .task_name = "arduino_usb_events",
-            .task_priority = _event_task_priority,
-            .task_stack_size = _task_stack_size,
-            .task_core_id = tskNO_AFFINITY
-        };
-        if (esp_event_loop_create(&event_task_args, &arduino_usb_event_loop_handle) != ESP_OK) {
-            log_e("esp_event_loop_create failed");
-        }
-    }
-}
-
-ESPUSB::~ESPUSB(){
-    if (arduino_usb_event_loop_handle) {
-        esp_event_loop_delete(arduino_usb_event_loop_handle);
-        arduino_usb_event_loop_handle = NULL;
-    }
-}
-
-bool ESPUSB::begin(){
-    if(!_started){
-        tinyusb_device_config_t tinyusb_device_config = {
-                .vid = vid,
-                .pid = pid,
-                .product_name = product_name.c_str(),
-                .manufacturer_name = manufacturer_name.c_str(),
-                .serial_number = serial_number.c_str(),
-                .fw_version = fw_version,
-                .usb_version = usb_version,
-                .usb_class = usb_class,
-                .usb_subclass = usb_subclass,
-                .usb_protocol = usb_protocol,
-                .usb_attributes = usb_attributes,
-                .usb_power_ma = usb_power_ma,
-                .webusb_enabled = webusb_enabled,
-                .webusb_url = webusb_url.c_str()
-        };
-        _started = tinyusb_init(&tinyusb_device_config) == ESP_OK; 
-    }
-    return _started;
-}
-
-void ESPUSB::onEvent(esp_event_handler_t callback){
-    onEvent(ARDUINO_USB_ANY_EVENT, callback);
-}
-void ESPUSB::onEvent(arduino_usb_event_t event, esp_event_handler_t callback){
-    arduino_usb_event_handler_register_with(ARDUINO_USB_EVENTS, event, callback, this);
-}
-
-ESPUSB::operator bool() const
-{
-    return _started && tinyusb_device_mounted;
-}
-
-bool ESPUSB::enableDFU(){
-#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_RT */
-    return false;
-}
-
-bool ESPUSB::VID(uint16_t v){
-    if(!_started){
-        vid = v;
-    }
-    return !_started;
-}
-uint16_t ESPUSB::VID(void){
-    return vid;
-}
-
-bool ESPUSB::PID(uint16_t p){
-    if(!_started){
-        pid = p;
-    }
-    return !_started;
-}
-uint16_t ESPUSB::PID(void){
-    return pid;
-}
-
-bool ESPUSB::firmwareVersion(uint16_t version){
-    if(!_started){
-        fw_version = version;
-    }
-    return !_started;
-}
-uint16_t ESPUSB::firmwareVersion(void){
-    return fw_version;
-}
-
-bool ESPUSB::usbVersion(uint16_t version){
-    if(!_started){
-        usb_version = version;
-    }
-    return !_started;
-}
-uint16_t ESPUSB::usbVersion(void){
-    return usb_version;
-}
-
-bool ESPUSB::usbPower(uint16_t mA){
-    if(!_started){
-        usb_power_ma = mA;
-    }
-    return !_started;
-}
-uint16_t ESPUSB::usbPower(void){
-    return usb_power_ma;
-}
-
-bool ESPUSB::usbClass(uint8_t _class){
-    if(!_started){
-        usb_class = _class;
-    }
-    return !_started;
-}
-uint8_t ESPUSB::usbClass(void){
-    return usb_class;
-}
-
-bool ESPUSB::usbSubClass(uint8_t subClass){
-    if(!_started){
-        usb_subclass = subClass;
-    }
-    return !_started;
-}
-uint8_t ESPUSB::usbSubClass(void){
-    return usb_subclass;
-}
-
-bool ESPUSB::usbProtocol(uint8_t protocol){
-    if(!_started){
-        usb_protocol = protocol;
-    }
-    return !_started;
-}
-uint8_t ESPUSB::usbProtocol(void){
-    return usb_protocol;
-}
-
-bool ESPUSB::usbAttributes(uint8_t attr){
-    if(!_started){
-        usb_attributes = attr;
-    }
-    return !_started;
-}
-uint8_t ESPUSB::usbAttributes(void){
-    return usb_attributes;
-}
-
-bool ESPUSB::webUSB(bool enabled){
-    if(!_started){
-        webusb_enabled = enabled;
-    }
-    return !_started;
-}
-bool ESPUSB::webUSB(void){
-    return webusb_enabled;
-}
-
-bool ESPUSB::productName(const char * name){
-    if(!_started){
-        product_name = name;
-    }
-    return !_started;
-}
-const char * ESPUSB::productName(void){
-    return product_name.c_str();
-}
-
-bool ESPUSB::manufacturerName(const char * name){
-    if(!_started){
-        manufacturer_name = name;
-    }
-    return !_started;
-}
-const char * ESPUSB::manufacturerName(void){
-    return manufacturer_name.c_str();
-}
-
-bool ESPUSB::serialNumber(const char * name){
-    if(!_started){
-        serial_number = name;
-    }
-    return !_started;
-}
-const char * ESPUSB::serialNumber(void){
-    return serial_number.c_str();
-}
-
-bool ESPUSB::webUSBURL(const char * name){
-    if(!_started){
-        webusb_url = name;
-    }
-    return !_started;
-}
-const char * ESPUSB::webUSBURL(void){
-    return webusb_url.c_str();
-}
-
-ESPUSB USB;
-
-#endif /* CONFIG_USB_ENABLED */

cores/esp32/USB.h

@@ -1,118 +0,0 @@
-// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#pragma once
-
-#include "sdkconfig.h"
-#if CONFIG_USB_ENABLED
-
-#include "Arduino.h"
-#include "USBCDC.h"
-
-#include "esp_event.h"
-
-ESP_EVENT_DECLARE_BASE(ARDUINO_USB_EVENTS);
-
-typedef enum {
-    ARDUINO_USB_ANY_EVENT = ESP_EVENT_ANY_ID,
-    ARDUINO_USB_STARTED_EVENT = 0,
-    ARDUINO_USB_STOPPED_EVENT,
-    ARDUINO_USB_SUSPEND_EVENT,
-    ARDUINO_USB_RESUME_EVENT,
-    ARDUINO_USB_MAX_EVENT,
-} arduino_usb_event_t;
-
-typedef union {
-    struct {
-        bool remote_wakeup_en;
-    } suspend;
-} arduino_usb_event_data_t;
-
-class ESPUSB {
-    public:
-        ESPUSB(size_t event_task_stack_size=2048, uint8_t event_task_priority=5);
-        ~ESPUSB();
-        
-        void onEvent(esp_event_handler_t callback);
-        void onEvent(arduino_usb_event_t event, esp_event_handler_t callback);
-        
-        bool VID(uint16_t v);
-        uint16_t VID(void);
-
-        bool PID(uint16_t p);
-        uint16_t PID(void);
-
-        bool firmwareVersion(uint16_t version);
-        uint16_t firmwareVersion(void);
-
-        bool usbVersion(uint16_t version);
-        uint16_t usbVersion(void);
-
-        bool usbPower(uint16_t mA);
-        uint16_t usbPower(void);
-
-        bool usbClass(uint8_t _class);
-        uint8_t usbClass(void);
-
-        bool usbSubClass(uint8_t subClass);
-        uint8_t usbSubClass(void);
-
-        bool usbProtocol(uint8_t protocol);
-        uint8_t usbProtocol(void);
-
-        bool usbAttributes(uint8_t attr);
-        uint8_t usbAttributes(void);
-
-        bool webUSB(bool enabled);
-        bool webUSB(void);
-        
-        bool productName(const char * name);
-        const char * productName(void);
-
-        bool manufacturerName(const char * name);
-        const char * manufacturerName(void);
-
-        bool serialNumber(const char * name);
-        const char * serialNumber(void);
-
-        bool webUSBURL(const char * name);
-        const char * webUSBURL(void);
-
-        bool enableDFU();
-        bool begin();
-        operator bool() const;
-        
-    private:
-        uint16_t vid;
-        uint16_t pid;
-        String product_name;
-        String manufacturer_name;
-        String serial_number;
-        uint16_t fw_version;
-        uint16_t usb_version;
-        uint8_t usb_class;
-        uint8_t usb_subclass;
-        uint8_t usb_protocol;
-        uint8_t usb_attributes;
-        uint16_t usb_power_ma;
-        bool webusb_enabled;
-        String webusb_url;
-        
-        bool _started;
-        size_t _task_stack_size;
-        uint8_t _event_task_priority;
-};
-
-extern ESPUSB USB;
-
-#endif /* CONFIG_USB_ENABLED */

cores/esp32/USBCDC.cpp

@@ -1,338 +0,0 @@
-// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#include "esp32-hal.h"
-#include "esp32-hal-tinyusb.h"
-#include "USB.h"
-#include "USBCDC.h"
-#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};
-
-static uint16_t load_cdc_descriptor(uint8_t * dst, uint8_t * itf)
-{
-    uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB CDC");
-    // Interface number, string index, attributes, detach timeout, transfer size */
-    uint8_t descriptor[TUD_CDC_DESC_LEN] = {
-            // Interface number, string index, EP notification address and size, EP data address (out, in) and size.
-            TUD_CDC_DESCRIPTOR(*itf, str_index, 0x85, 64, 0x03, 0x84, 64)
-    };
-    *itf+=2;
-    memcpy(dst, descriptor, TUD_CDC_DESC_LEN);
-    return TUD_CDC_DESC_LEN;
-}
-
-void tud_cdc_line_state_cb(uint8_t itf, bool dtr, bool rts)
-{
-    if(itf < MAX_USB_CDC_DEVICES && devices[itf] != NULL){
-        devices[itf]->_onLineState(dtr, rts);
-    }
-}
-
-void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* p_line_coding)
-{
-    if(itf < MAX_USB_CDC_DEVICES && devices[itf] != NULL){
-        devices[itf]->_onLineCoding(p_line_coding->bit_rate, p_line_coding->stop_bits, p_line_coding->parity, p_line_coding->data_bits);
-    }
-}
-
-void tud_cdc_rx_cb(uint8_t itf)
-{
-    if(itf < MAX_USB_CDC_DEVICES && devices[itf] != NULL){
-        devices[itf]->_onRX();
-    }
-}
-
-
-static size_t tinyusb_cdc_write(uint8_t itf, const uint8_t *buffer, size_t size){
-    if(itf >= MAX_USB_CDC_DEVICES){
-        return 0;
-    }
-    if(!tud_cdc_n_connected(itf)){
-        return 0;
-    }
-    size_t tosend = size, sofar = 0;
-    while(tosend){
-        uint32_t space = tud_cdc_n_write_available(itf);
-        if(!space){
-            delay(1);
-            continue;
-        }
-        if(tosend < space){
-            space = tosend;
-        }
-        uint32_t sent = tud_cdc_n_write(itf, buffer + sofar, space);
-        if(!sent){
-            return sofar;
-        }
-        sofar += sent;
-        tosend -= sent;
-        tud_cdc_n_write_flush(itf);
-    }
-    return sofar;
-}
-
-static void ARDUINO_ISR_ATTR cdc0_write_char(char c)
-{
-    tinyusb_cdc_write(0, (const uint8_t *)&c, 1);
-}
-
-//void tud_cdc_rx_wanted_cb(uint8_t itf, char wanted_char);
-
-static void usb_unplugged_cb(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data){
-    ((USBCDC*)arg)->_onUnplugged();
-}
-
-USBCDC::USBCDC(uint8_t itfn) : itf(itfn), bit_rate(0), stop_bits(0), parity(0), data_bits(0), dtr(false),  rts(false), connected(false), reboot_enable(true), rx_queue(NULL) {
-    tinyusb_enable_interface(USB_INTERFACE_CDC, TUD_CDC_DESC_LEN, load_cdc_descriptor);
-    if(itf < MAX_USB_CDC_DEVICES){
-        devices[itf] = this;
-        arduino_usb_event_handler_register_with(ARDUINO_USB_EVENTS, ARDUINO_USB_STOPPED_EVENT, usb_unplugged_cb, this);
-    }
-}
-
-void USBCDC::onEvent(esp_event_handler_t callback){
-    onEvent(ARDUINO_USB_CDC_ANY_EVENT, callback);
-}
-void USBCDC::onEvent(arduino_usb_cdc_event_t event, esp_event_handler_t callback){
-    arduino_usb_event_handler_register_with(ARDUINO_USB_CDC_EVENTS, event, callback, this);
-}
-
-size_t USBCDC::setRxBufferSize(size_t rx_queue_len){
-    if(rx_queue){
-        return 0;
-    }
-    rx_queue = xQueueCreate(rx_queue_len, sizeof(uint8_t));
-    if(!rx_queue){
-        return 0;
-    }
-    return rx_queue_len;
-}
-
-void USBCDC::begin(unsigned long baud)
-{
-    setRxBufferSize(256);//default if not preset
-}
-
-void USBCDC::end()
-{
-}
-
-void USBCDC::_onUnplugged(void){
-    if(connected){
-        connected = false;
-        dtr = false;
-        rts = false;
-        arduino_usb_cdc_event_data_t p = {0};
-        arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_DISCONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
-    }
-}
-
-enum { CDC_LINE_IDLE, CDC_LINE_1, CDC_LINE_2, CDC_LINE_3 };
-void USBCDC::_onLineState(bool _dtr, bool _rts){
-    static uint8_t lineState = CDC_LINE_IDLE;
-    dtr = _dtr;
-    rts = _rts;
-
-    if(reboot_enable){
-        if(!dtr && rts){
-            if(lineState == CDC_LINE_IDLE){
-                lineState++;
-            } else {
-                lineState = CDC_LINE_IDLE;
-            }
-        } else if(dtr && rts){
-            if(lineState == CDC_LINE_1){
-                lineState++;
-            } else {
-                lineState = CDC_LINE_IDLE;
-            }
-        } else if(dtr && !rts){
-            if(lineState == CDC_LINE_2){
-                lineState++;
-            } else {
-                lineState = CDC_LINE_IDLE;
-            }
-        } else if(!dtr && !rts){
-            if(lineState == CDC_LINE_3){
-                usb_persist_restart(RESTART_BOOTLOADER);
-            } else {
-                lineState = CDC_LINE_IDLE;
-            }
-        }
-    }
-    
-    if(lineState == CDC_LINE_IDLE){
-        if(dtr && rts && !connected){
-            connected = true;
-            arduino_usb_cdc_event_data_t p = {0};
-            arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_CONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
-        } else if(!dtr && !rts && connected){
-            connected = false;
-            arduino_usb_cdc_event_data_t p = {0};
-            arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_DISCONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
-        }
-        arduino_usb_cdc_event_data_t l = {0};
-        l.line_state.dtr = dtr;
-        l.line_state.rts = rts;
-        arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_LINE_STATE_EVENT, &l, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
-    }
-
-}
-
-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){
-        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_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;
-        }
-    }
-    arduino_usb_cdc_event_data_t p = {0};
-    p.rx.len = count;
-    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::enableReboot(bool enable){
-    reboot_enable = enable;
-}
-bool  USBCDC::rebootEnabled(void){
-    return reboot_enable;
-}
-
-int USBCDC::available(void)
-{
-    if(itf >= MAX_USB_CDC_DEVICES || rx_queue == NULL){
-        return -1;
-    }
-    return uxQueueMessagesWaiting(rx_queue);
-}
-
-int USBCDC::peek(void)
-{
-    if(itf >= MAX_USB_CDC_DEVICES || rx_queue == NULL){
-        return -1;
-    }
-    uint8_t c;
-    if(xQueuePeek(rx_queue, &c, 0)) {
-        return c;
-    }
-    return -1;
-}
-
-int USBCDC::read(void)
-{
-    if(itf >= MAX_USB_CDC_DEVICES || rx_queue == NULL){
-        return -1;
-    }
-    uint8_t c = 0;
-    if(xQueueReceive(rx_queue, &c, 0)) {
-        return c;
-    }
-    return -1;
-}
-
-size_t USBCDC::read(uint8_t *buffer, size_t size)
-{
-    if(itf >= MAX_USB_CDC_DEVICES || rx_queue == NULL){
-        return -1;
-    }
-    uint8_t c = 0;
-    size_t count = 0;
-    while(count < size && xQueueReceive(rx_queue, &c, 0)){
-        buffer[count++] = c;
-    }
-    return count;
-}
-
-void USBCDC::flush(void)
-{
-    if(itf >= MAX_USB_CDC_DEVICES){
-        return;
-    }
-    tud_cdc_n_write_flush(itf);
-}
-
-int USBCDC::availableForWrite(void)
-{
-    if(itf >= MAX_USB_CDC_DEVICES){
-        return -1;
-    }
-    return tud_cdc_n_write_available(itf);
-}
-
-size_t USBCDC::write(const uint8_t *buffer, size_t size)
-{
-    return tinyusb_cdc_write(itf, buffer, size);
-}
-
-size_t USBCDC::write(uint8_t c)
-{
-    return write(&c, 1);
-}
-
-uint32_t  USBCDC::baudRate()
-{
-    return bit_rate;
-}
-
-void USBCDC::setDebugOutput(bool en)
-{
-    if(en) {
-        uartSetDebug(NULL);
-        ets_install_putc1((void (*)(char)) &cdc0_write_char);
-    } else {
-        ets_install_putc1(NULL);
-    }
-}
-
-USBCDC::operator bool() const
-{
-    if(itf >= MAX_USB_CDC_DEVICES){
-        return false;
-    }
-    return connected;
-}
-
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
-USBCDC Serial(0);
-#endif
-
-#endif /* CONFIG_USB_CDC_ENABLED */
-
-#endif /* CONFIG_USB_ENABLED */

cores/esp32/USBCDC.h

@@ -1,133 +0,0 @@
-// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#pragma once
-
-#include <inttypes.h>
-
-#include "Stream.h"
-#include "esp32-hal.h"
-#if CONFIG_USB_CDC_ENABLED
-
-#include "esp_event.h"
-
-ESP_EVENT_DECLARE_BASE(ARDUINO_USB_CDC_EVENTS);
-
-typedef enum {
-    ARDUINO_USB_CDC_ANY_EVENT = ESP_EVENT_ANY_ID,
-    ARDUINO_USB_CDC_CONNECTED_EVENT = 0,
-    ARDUINO_USB_CDC_DISCONNECTED_EVENT,
-    ARDUINO_USB_CDC_LINE_STATE_EVENT,
-    ARDUINO_USB_CDC_LINE_CODING_EVENT,
-    ARDUINO_USB_CDC_RX_EVENT,
-    ARDUINO_USB_CDC_MAX_EVENT,
-} arduino_usb_cdc_event_t;
-
-typedef union {
-    struct {
-            bool dtr;
-            bool rts;
-    } line_state;
-    struct {
-            uint32_t bit_rate;
-            uint8_t  stop_bits; ///< 0: 1 stop bit - 1: 1.5 stop bits - 2: 2 stop bits
-            uint8_t  parity;    ///< 0: None - 1: Odd - 2: Even - 3: Mark - 4: Space
-            uint8_t  data_bits; ///< can be 5, 6, 7, 8 or 16
-    } line_coding;
-    struct {
-            size_t len;
-    } rx;
-} arduino_usb_cdc_event_data_t;
-
-class USBCDC: public Stream
-{
-public:
-    USBCDC(uint8_t itf=0);
-
-    void onEvent(esp_event_handler_t callback);
-    void onEvent(arduino_usb_cdc_event_t event, esp_event_handler_t callback);
-
-    size_t setRxBufferSize(size_t);
-    void begin(unsigned long baud=0);
-    void end();
-    
-    int available(void);
-    int availableForWrite(void);
-    int peek(void);
-    int read(void);
-    size_t read(uint8_t *buffer, size_t size);
-    size_t write(uint8_t);
-    size_t write(const uint8_t *buffer, size_t size);
-    void flush(void);
-    
-    inline size_t read(char * buffer, size_t size)
-    {
-        return read((uint8_t*) buffer, size);
-    }
-    inline size_t write(const char * buffer, size_t size)
-    {
-        return write((uint8_t*) buffer, size);
-    }
-    inline size_t write(const char * s)
-    {
-        return write((uint8_t*) s, strlen(s));
-    }
-    inline size_t write(unsigned long n)
-    {
-        return write((uint8_t) n);
-    }
-    inline size_t write(long n)
-    {
-        return write((uint8_t) n);
-    }
-    inline size_t write(unsigned int n)
-    {
-        return write((uint8_t) n);
-    }
-    inline size_t write(int n)
-    {
-        return write((uint8_t) n);
-    }
-    uint32_t baudRate();
-    void setDebugOutput(bool);
-    operator bool() const;
-
-    void enableReboot(bool enable);
-    bool rebootEnabled(void);
-
-    //internal methods
-    void _onDFU(void);
-    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 _onUnplugged(void);
-    
-protected:
-    uint8_t  itf;
-    uint32_t bit_rate;
-    uint8_t  stop_bits; ///< 0: 1 stop bit - 1: 1.5 stop bits - 2: 2 stop bits
-    uint8_t  parity;    ///< 0: None - 1: Odd - 2: Even - 3: Mark - 4: Space
-    uint8_t  data_bits; ///< can be 5, 6, 7, 8 or 16
-    bool     dtr;
-    bool     rts;
-    bool     connected;
-    bool     reboot_enable;
-    xQueueHandle rx_queue;
-    
-};
-
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
-extern USBCDC Serial;
-#endif
-
-#endif /* CONFIG_USB_CDC_ENABLED */

cores/esp32/WMath.cpp

@@ -27,6 +27,7 @@ extern "C" {
 #include <stdlib.h>
 #include "esp_system.h"
 }
+#include "esp32-hal-log.h"
 
 void randomSeed(unsigned long seed)
 {
@@ -69,7 +70,10 @@ 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;
-
+    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;
 }
 

cores/esp32/WString.cpp

@@ -130,9 +130,9 @@ String::~String() {
 
 inline void String::init(void) {
     setSSO(false);
+    setBuffer(nullptr);
     setCapacity(0);
     setLen(0);
-    setBuffer(nullptr);
 }
 
 void String::invalidate(void) {
@@ -159,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
@@ -168,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;
         }
     }
@@ -193,8 +193,8 @@ unsigned char String::changeBuffer(unsigned int maxStrLen) {
         }
         setSSO(false);
         setCapacity(newSize - 1);
-        setLen(oldLen); // Needed in case of SSO where len() never existed
         setBuffer(newbuffer);
+        setLen(oldLen); // Needed in case of SSO where len() never existed
         return 1;
     }
     return 0;
@@ -209,8 +209,8 @@ String & String::copy(const char *cstr, unsigned int length) {
         invalidate();
         return *this;
     }
-    setLen(length);
     memmove(wbuffer(), cstr, length + 1);
+    setLen(length);
     return *this;
 }
 
@@ -219,8 +219,8 @@ String & String::copy(const __FlashStringHelper *pstr, unsigned int length) {
         invalidate();
         return *this;
     }
-    setLen(length);
     memcpy_P(wbuffer(), (PGM_P)pstr, length + 1); // We know wbuffer() cannot ever be in PROGMEM, so memcpy safe here
+    setLen(length);
     return *this;
 }
 
@@ -250,8 +250,8 @@ void String::move(String &rhs) {
     setLen(rhs.len());
     rhs.setSSO(false);
     rhs.setCapacity(0);
-    rhs.setLen(0);
     rhs.setBuffer(nullptr);
+    rhs.setLen(0);
 }
 #endif
 
@@ -744,6 +744,7 @@ 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);
@@ -751,9 +752,10 @@ void String::replace(const String& find, const String& replace) {
             memmove(writeTo, replace.buffer(), replace.len());
             writeTo += replace.len();
             readFrom = foundAt + find.len();
-            setLen(len() + diff);
+            l += 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) {
@@ -768,7 +770,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;
@@ -796,8 +798,8 @@ void String::remove(unsigned int index, unsigned int count) {
     }
     char *writeTo = wbuffer() + index;
     unsigned int newlen = len() - count;
-    setLen(newlen);
     memmove(writeTo, wbuffer() + index + count, newlen - index);
+    setLen(newlen);
     wbuffer()[newlen] = 0;
 }
 
@@ -827,9 +829,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

@@ -301,9 +301,19 @@ 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; else ptr.len = len; }
+        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 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

@@ -15,36 +15,33 @@
 #include "esp32-hal-adc.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
+#include "rom/ets_sys.h"
 #include "esp_attr.h"
+#include "esp_intr.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 "esp32/rom/ets_sys.h"
-#include "esp_intr_alloc.h"
+
 #define DEFAULT_VREF    1100
 static esp_adc_cal_characteristics_t *__analogCharacteristics[2] = {NULL, NULL};
-static uint16_t __analogVRef = 0;
-static uint8_t __analogVRefPin = 0;
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/ets_sys.h"
-#include "esp_intr.h"
-#endif
-
 static uint8_t __analogAttenuation = 3;//11db
 static uint8_t __analogWidth = 3;//12 bits
 static uint8_t __analogClockDiv = 1;
+static uint16_t __analogVRef = 0;
+static uint8_t __analogVRefPin = 0;
+
+void __analogSetWidth(uint8_t bits){
+    if(bits < 9){
+        bits = 9;
+    } else if(bits > 12){
+        bits = 12;
+    }
+    __analogWidth = bits - 9;
+    adc1_config_width(__analogWidth);
+}
 
 void __analogSetClockDiv(uint8_t clockDiv){
     if(!clockDiv){
@@ -59,18 +56,6 @@ void __analogSetAttenuation(adc_attenuation_t attenuation)
     __analogAttenuation = attenuation & 3;
 }
 
-#if CONFIG_IDF_TARGET_ESP32
-void __analogSetWidth(uint8_t bits){
-    if(bits < 9){
-        bits = 9;
-    } else if(bits > 12){
-        bits = 12;
-    }
-    __analogWidth = bits - 9;
-    adc1_config_width(__analogWidth);
-}
-#endif
-
 void __analogInit(){
     static bool initialized = false;
     if(initialized){
@@ -78,9 +63,7 @@ void __analogInit(){
     }
     initialized = true;
     __analogSetClockDiv(__analogClockDiv);
-#if CONFIG_IDF_TARGET_ESP32
     __analogSetWidth(__analogWidth + 9);//in bits
-#endif
 }
 
 void __analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation)
@@ -105,7 +88,6 @@ bool __adcAttachPin(uint8_t pin){
     }
     int8_t pad = digitalPinToTouchChannel(pin);
     if(pad >= 0){
-#if CONFIG_IDF_TARGET_ESP32
         uint32_t touch = READ_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG);
         if(touch & (1 << pad)){
             touch &= ~((1 << (pad + SENS_TOUCH_PAD_OUTEN2_S))
@@ -113,7 +95,6 @@ bool __adcAttachPin(uint8_t pin){
                     | (1 << (pad + SENS_TOUCH_PAD_WORKEN_S)));
             WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG, touch);
         }
-#endif
     } 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){
@@ -130,9 +111,7 @@ void __analogReadResolution(uint8_t bits)
     if(!bits || bits > 16){
         return;
     }
-#if CONFIG_IDF_TARGET_ESP32
     __analogSetWidth(bits);         // hadware from 9 to 12
-#endif
 }
 
 uint16_t __analogRead(uint8_t pin)
@@ -163,13 +142,19 @@ uint16_t __analogRead(uint8_t pin)
     return value;
 }
 
+void __analogSetVRefPin(uint8_t pin){
+    if(pin <25 || pin > 27){
+        pin = 0;
+    }
+    __analogVRefPin = pin;
+}
+
 uint32_t __analogReadMilliVolts(uint8_t pin){
     int8_t channel = digitalPinToAnalogChannel(pin);
     if(channel < 0){
         log_e("Pin %u is not ADC pin!", pin);
         return 0;
     }
-#if CONFIG_IDF_TARGET_ESP32
     if(!__analogVRef){
         if (esp_adc_cal_check_efuse(ESP_ADC_CAL_VAL_EFUSE_TP) == ESP_OK) {
             log_d("eFuse Two Point: Supported");
@@ -183,7 +168,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);
@@ -214,27 +199,6 @@ uint32_t __analogReadMilliVolts(uint8_t pin){
         }
     }
     return esp_adc_cal_raw_to_voltage(adc_reading, __analogCharacteristics[unit - 1]);
-#else
-    uint16_t adc_reading = __analogRead(pin);
-    uint16_t max_reading = 8191;
-    uint16_t max_mv = 1100;
-    switch(__analogAttenuation){
-        case 3: max_mv = 3900; break;
-        case 2: max_mv = 2200; break;
-        case 1: max_mv = 1500; break;
-        default: break;
-    }
-    return (adc_reading * max_mv) / max_reading;
-#endif
-}
-
-#if CONFIG_IDF_TARGET_ESP32
-
-void __analogSetVRefPin(uint8_t pin){
-    if(pin <25 || pin > 27){
-        pin = 0;
-    }
-    __analogVRefPin = pin;
 }
 
 int __hallRead()    //hall sensor without LNA
@@ -260,20 +224,16 @@ int __hallRead()    //hall sensor without LNA
     CLEAR_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL1_REG, SENS_HALL_PHASE_FORCE);
     return (Sens_Vp1 - Sens_Vp0) - (Sens_Vn1 - Sens_Vn0);
 }
-#endif
 
 extern uint16_t analogRead(uint8_t pin) __attribute__ ((weak, alias("__analogRead")));
-extern uint32_t analogReadMilliVolts(uint8_t pin) __attribute__ ((weak, alias("__analogReadMilliVolts")));
 extern void analogReadResolution(uint8_t bits) __attribute__ ((weak, alias("__analogReadResolution")));
+extern void analogSetWidth(uint8_t bits) __attribute__ ((weak, alias("__analogSetWidth")));
 extern void analogSetClockDiv(uint8_t clockDiv) __attribute__ ((weak, alias("__analogSetClockDiv")));
 extern void analogSetAttenuation(adc_attenuation_t attenuation) __attribute__ ((weak, alias("__analogSetAttenuation")));
 extern void analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation) __attribute__ ((weak, alias("__analogSetPinAttenuation")));
+extern int hallRead() __attribute__ ((weak, alias("__hallRead")));
 
 extern bool adcAttachPin(uint8_t pin) __attribute__ ((weak, alias("__adcAttachPin")));
 
-#if CONFIG_IDF_TARGET_ESP32
 extern void analogSetVRefPin(uint8_t pin) __attribute__ ((weak, alias("__analogSetVRefPin")));
-extern void analogSetWidth(uint8_t bits) __attribute__ ((weak, alias("__analogSetWidth")));
-extern int hallRead() __attribute__ ((weak, alias("__hallRead")));
-#endif
-
+extern uint32_t analogReadMilliVolts(uint8_t pin) __attribute__ ((weak, alias("__analogReadMilliVolts")));

cores/esp32/esp32-hal-adc.h

@@ -38,11 +38,6 @@ typedef enum {
  * */
 uint16_t analogRead(uint8_t pin);
 
-/*
- * Get MilliVolts value for pin
- * */
-uint32_t analogReadMilliVolts(uint8_t pin);
-
 /*
  * Set the resolution of analogRead return values. Default is 12 bits (range from 0 to 4096).
  * If between 9 and 12, it will equal the set hardware resolution, else value will be shifted.
@@ -52,6 +47,13 @@ uint32_t analogReadMilliVolts(uint8_t pin);
  */
 void analogReadResolution(uint8_t bits);
 
+/*
+ * Sets the sample bits and read resolution
+ * Default is 12bit (0 - 4095)
+ * Range is 9 - 12
+ * */
+void analogSetWidth(uint8_t bits);
+
 /*
  * Set the divider for the ADC clock.
  * Default is 1
@@ -71,30 +73,26 @@ void analogSetAttenuation(adc_attenuation_t attenuation);
  * */
 void analogSetPinAttenuation(uint8_t pin, adc_attenuation_t attenuation);
 
+/*
+ * Get value for HALL sensor (without LNA)
+ * connected to pins 36(SVP) and 39(SVN)
+ * */
+int hallRead();
+
 /*
  * Attach pin to ADC (will also clear any other analog mode that could be on)
  * */
 bool adcAttachPin(uint8_t pin);
 
-#if CONFIG_IDF_TARGET_ESP32
-/*
- * Sets the sample bits and read resolution
- * Default is 12bit (0 - 4095)
- * Range is 9 - 12
- * */
-void analogSetWidth(uint8_t bits);
-
 /*
  * Set pin to use for ADC calibration if the esp is not already calibrated (25, 26 or 27)
  * */
 void analogSetVRefPin(uint8_t pin);
 
 /*
- * Get value for HALL sensor (without LNA)
- * connected to pins 36(SVP) and 39(SVN)
+ * Get MilliVolts value for pin
  * */
-int hallRead();
-#endif
+uint32_t analogReadMilliVolts(uint8_t pin);
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-bt.c

@@ -18,11 +18,12 @@
 
 bool btInUse(){ return true; }
 
-#ifdef CONFIG_BLUEDROID_ENABLED
 #include "esp_bt.h"
 
-#ifdef CONFIG_CLASSIC_BT_ENABLED
+#ifdef CONFIG_BTDM_CONTROLLER_MODE_BTDM
 #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
@@ -79,7 +80,7 @@ bool btStop(){
     return false;
 }
 
-#else
+#else // CONFIG_BT_ENABLED
 bool btStarted()
 {
     return false;
@@ -94,6 +95,6 @@ bool btStop()
 {
     return false;
 }
-#endif
-#endif
+
+#endif // CONFIG_BT_ENABLED
 

cores/esp32/esp32-hal-cpu.c

@@ -21,24 +21,12 @@
 #include "esp_log.h"
 #include "soc/rtc.h"
 #include "soc/rtc_cntl_reg.h"
+#include "rom/rtc.h"
 #include "soc/apb_ctrl_reg.h"
 #include "soc/efuse_reg.h"
 #include "esp32-hal.h"
 #include "esp32-hal-cpu.h"
 
-#include "esp_system.h"
-#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "esp32/rom/rtc.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/rtc.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/rtc.h"
-#endif
-
 typedef struct apb_change_cb_s {
         struct apb_change_cb_s * prev;
         struct apb_change_cb_s * next;
@@ -46,6 +34,7 @@ typedef struct apb_change_cb_s {
         apb_change_cb_t cb;
 } apb_change_t;
 
+const uint32_t MHZ = 1000000;
 
 static apb_change_t * apb_change_callbacks = NULL;
 static xSemaphoreHandle apb_change_lock = NULL;
@@ -154,7 +143,6 @@ bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz){
     uint32_t capb, apb;
     //Get XTAL Frequency and calculate min CPU MHz
     rtc_xtal_freq_t xtal = rtc_clk_xtal_freq_get();
-#if CONFIG_IDF_TARGET_ESP32
     if(xtal > RTC_XTAL_FREQ_AUTO){
         if(xtal < RTC_XTAL_FREQ_40M) {
             if(cpu_freq_mhz <= xtal && cpu_freq_mhz != xtal && cpu_freq_mhz != (xtal/2)){
@@ -166,7 +154,6 @@ bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz){
             return false;
         }
     }
-#endif
     if(cpu_freq_mhz > xtal && cpu_freq_mhz != 240 && cpu_freq_mhz != 160 && cpu_freq_mhz != 80){
         if(xtal >= RTC_XTAL_FREQ_40M){
             log_e("Bad frequency: %u MHz! Options are: 240, 160, 80, %u, %u and %u MHz", cpu_freq_mhz, xtal, xtal/2, xtal/4);
@@ -175,7 +162,6 @@ bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz){
         }
         return false;
     }
-#if CONFIG_IDF_TARGET_ESP32
     //check if cpu supports the frequency
     if(cpu_freq_mhz == 240){
         //Check if ESP32 is rated for a CPU frequency of 160MHz only
@@ -185,7 +171,6 @@ bool setCpuFrequencyMhz(uint32_t cpu_freq_mhz){
             cpu_freq_mhz = 160;
         }
     }
-#endif
     //Get current CPU clock configuration
     rtc_clk_cpu_freq_get_config(&cconf);
     //return if frequency has not changed

cores/esp32/esp32-hal-dac.c

@@ -12,45 +12,43 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "esp32-hal.h"
+#include "esp32-hal-dac.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "rom/ets_sys.h"
 #include "esp_attr.h"
+#include "esp_intr.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)
+void IRAM_ATTR __dacWrite(uint8_t pin, uint8_t value)
 {
-    if(pin < DAC1 || pin > DAC2){
+    if(pin < 25 || pin > 26){
         return;//not dac pin
     }
     pinMode(pin, ANALOG);
-    uint8_t channel = pin - DAC1;
-#if CONFIG_IDF_TARGET_ESP32
+    uint8_t channel = pin - 25;
+
+
+    //Disable Tone
     CLEAR_PERI_REG_MASK(SENS_SAR_DAC_CTRL1_REG, SENS_SW_TONE_EN);
-#elif CONFIG_IDF_TARGET_ESP32S2
-    SENS.sar_dac_ctrl1.dac_clkgate_en = 1;
-#endif
-    RTCIO.pad_dac[channel].dac_xpd_force = 1;
-    RTCIO.pad_dac[channel].xpd_dac = 1;
-    if (channel == 0) {
-        SENS.sar_dac_ctrl2.dac_cw_en1 = 0;
-    } else if (channel == 1) {
-        SENS.sar_dac_ctrl2.dac_cw_en2 = 0;
+
+    if (channel) {
+        //Disable Channel Tone
+        CLEAR_PERI_REG_MASK(SENS_SAR_DAC_CTRL2_REG, SENS_DAC_CW_EN2_M);
+        //Set the Dac value
+        SET_PERI_REG_BITS(RTC_IO_PAD_DAC2_REG, RTC_IO_PDAC2_DAC, value, RTC_IO_PDAC2_DAC_S);   //dac_output
+        //Channel output enable
+        SET_PERI_REG_MASK(RTC_IO_PAD_DAC2_REG, RTC_IO_PDAC2_XPD_DAC | RTC_IO_PDAC2_DAC_XPD_FORCE);
+    } else {
+        //Disable Channel Tone
+        CLEAR_PERI_REG_MASK(SENS_SAR_DAC_CTRL2_REG, SENS_DAC_CW_EN1_M);
+        //Set the Dac value
+        SET_PERI_REG_BITS(RTC_IO_PAD_DAC1_REG, RTC_IO_PDAC1_DAC, value, RTC_IO_PDAC1_DAC_S);   //dac_output
+        //Channel output enable
+        SET_PERI_REG_MASK(RTC_IO_PAD_DAC1_REG, RTC_IO_PDAC1_XPD_DAC | RTC_IO_PDAC1_DAC_XPD_FORCE);
     }
-    RTCIO.pad_dac[channel].dac = value;
 }
 
 extern void dacWrite(uint8_t pin, uint8_t value) __attribute__ ((weak, alias("__dacWrite")));

cores/esp32/esp32-hal-gpio.c

@@ -13,45 +13,20 @@
 // limitations under the License.
 
 #include "esp32-hal-gpio.h"
-#include "pins_arduino.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
+#include "rom/ets_sys.h"
 #include "esp_attr.h"
+#include "esp_intr.h"
+#include "rom/gpio.h"
 #include "soc/gpio_reg.h"
 #include "soc/io_mux_reg.h"
 #include "soc/gpio_struct.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"
-#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"
-#define GPIO_FUNC 1
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/ets_sys.h"
-#include "rom/gpio.h"
-#include "esp_intr.h"
-#endif
-
-#if CONFIG_IDF_TARGET_ESP32
 const int8_t esp32_adc2gpio[20] = {36, 37, 38, 39, 32, 33, 34, 35, -1, -1, 4, 0, 2, 15, 13, 12, 14, 27, 25, 26};
-#elif CONFIG_IDF_TARGET_ESP32S2
-const int8_t esp32_adc2gpio[20] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
-#endif
 
-const DRAM_ATTR esp32_gpioMux_t esp32_gpioMux[SOC_GPIO_PIN_COUNT]={
-#if CONFIG_IDF_TARGET_ESP32
+const DRAM_ATTR esp32_gpioMux_t esp32_gpioMux[GPIO_PIN_COUNT]={
     {0x44, 11, 11, 1},
     {0x88, -1, -1, -1},
     {0x40, 12, 12, 2},
@@ -92,56 +67,6 @@ const DRAM_ATTR esp32_gpioMux_t esp32_gpioMux[SOC_GPIO_PIN_COUNT]={
     {0x08, 1, 1, -1},
     {0x0c, 2, 2, -1},
     {0x10, 3, 3, -1}
-#elif CONFIG_IDF_TARGET_ESP32S2
-    {0x04,  0, -1, -1},
-    {0x08,  1,  0,  1},
-    {0x0c,  2,  1,  2},
-    {0x10,  3,  2,  3},
-    {0x14,  4,  3,  4},
-    {0x18,  5,  4,  5},
-    {0x1c,  6,  5,  6},
-    {0x20,  7,  6,  7},
-    {0x24,  8,  7,  8},
-    {0x28,  9,  8,  9},//FSPI_HD
-    {0x2c, 10,  9, 10},//FSPI_CS0 / FSPI_D4
-    {0x30, 11, 10, 11},//FSPI_D / FSPI_D5
-    {0x34, 12, 11, 12},//FSPI_CLK / FSPI_D6
-    {0x38, 13, 12, 13},//FSPI_Q / FSPI_D7
-    {0x3c, 14, 13, 14},//FSPI_WP / FSPI_DQS
-    {0x40, 15, 14, -1},//32K+ / RTS0
-    {0x44, 16, 15, -1},//32K- / CTS0
-    {0x48, 17, 16, -1},//DAC1 / TXD1
-    {0x4c, 18, 17, -1},//DAC2 / RXD1
-    {0x50, 19, 18, -1},//USB D- / RTS1
-    {0x54, 20, 19, -1},//USB D+ / CTS1
-    {0x58, 21, -1, -1},//SDA?
-    {   0, -1, -1, -1},//UNAVAILABLE
-    {   0, -1, -1, -1},//UNAVAILABLE
-    {   0, -1, -1, -1},//UNAVAILABLE
-    {   0, -1, -1, -1},//UNAVAILABLE
-    {0x6c, -1, -1, -1},//RESERVED SPI_CS1
-    {0x70, -1, -1, -1},//RESERVED SPI_HD
-    {0x74, -1, -1, -1},//RESERVED SPI_WP
-    {0x78, -1, -1, -1},//RESERVED SPI_CS0
-    {0x7c, -1, -1, -1},//RESERVED SPI_CLK
-    {0x80, -1, -1, -1},//RESERVED SPI_Q
-    {0x84, -1, -1, -1},//RESERVED SPI_D
-    {0x88, -1, -1, -1},//FSPI_HD
-    {0x8c, -1, -1, -1},//FSPI_CS0
-    {0x90, -1, -1, -1},//FSPI_D
-    {0x94, -1, -1, -1},//FSPI_CLK
-    {0x98, -1, -1, -1},//FSPI_Q
-    {0x9c, -1, -1, -1},//FSPI_WP
-    {0xa0, -1, -1, -1},//MTCK
-    {0xa4, -1, -1, -1},//MTDO
-    {0xa8, -1, -1, -1},//MTDI
-    {0xac, -1, -1, -1},//MTMS
-    {0xb0, -1, -1, -1},//TXD0
-    {0xb4, -1, -1, -1},//RXD0
-    {0xb8, -1, -1, -1},//SCL?
-    {0xbc, -1, -1, -1},//INPUT ONLY
-    {0, -1, -1, -1}
-#endif
 };
 
 typedef void (*voidFuncPtr)(void);
@@ -151,57 +76,56 @@ typedef struct {
     void* arg;
     bool functional;
 } InterruptHandle_t;
-static InterruptHandle_t __pinInterruptHandlers[SOC_GPIO_PIN_COUNT] = {0,};
+static InterruptHandle_t __pinInterruptHandlers[GPIO_PIN_COUNT] = {0,};
 
 #include "driver/rtc_io.h"
 
-extern void ARDUINO_ISR_ATTR __pinMode(uint8_t pin, uint8_t mode)
+extern void IRAM_ATTR __pinMode(uint8_t pin, uint8_t mode)
 {
 
     if(!digitalPinIsValid(pin)) {
         return;
     }
 
-    int8_t rtc_io = esp32_gpioMux[pin].rtc;
-    uint32_t rtc_reg = (rtc_io != -1)?rtc_io_desc[rtc_io].reg:0;
+    uint32_t rtc_reg = rtc_gpio_desc[pin].reg;
     if(mode == ANALOG) {
         if(!rtc_reg) {
             return;//not rtc pin
         }
-#if CONFIG_IDF_TARGET_ESP32S2
-        SENS.sar_io_mux_conf.iomux_clk_gate_en = 1;
-#endif
-        SET_PERI_REG_MASK(rtc_io_desc[rtc_io].reg, (rtc_io_desc[rtc_io].mux));
-        SET_PERI_REG_BITS(rtc_io_desc[rtc_io].reg, RTC_IO_TOUCH_PAD1_FUN_SEL_V, 0, rtc_io_desc[rtc_io].func);
-
-        RTCIO.pin[rtc_io].pad_driver = 0;//OD = 1
-        RTCIO.enable_w1tc.w1tc = (1U << rtc_io);
-        CLEAR_PERI_REG_MASK(rtc_io_desc[rtc_io].reg, rtc_io_desc[rtc_io].ie);
-
-        if (rtc_io_desc[rtc_io].pullup) {
-            CLEAR_PERI_REG_MASK(rtc_io_desc[rtc_io].reg, rtc_io_desc[rtc_io].pullup);
+        //lock rtc
+        uint32_t reg_val = ESP_REG(rtc_reg);
+        if(reg_val & rtc_gpio_desc[pin].mux){
+            return;//already in adc mode
         }
-        if (rtc_io_desc[rtc_io].pulldown) {
-            CLEAR_PERI_REG_MASK(rtc_io_desc[rtc_io].reg, rtc_io_desc[rtc_io].pulldown);
-        }
-        ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioMux[pin].reg) = ((uint32_t)GPIO_FUNC << MCU_SEL_S) | ((uint32_t)2 << FUN_DRV_S) | FUN_IE;
+        reg_val &= ~(
+                (RTC_IO_TOUCH_PAD1_FUN_SEL_V << rtc_gpio_desc[pin].func)
+                |rtc_gpio_desc[pin].ie
+                |rtc_gpio_desc[pin].pullup
+                |rtc_gpio_desc[pin].pulldown);
+        ESP_REG(RTC_GPIO_ENABLE_W1TC_REG) = (1 << (rtc_gpio_desc[pin].rtc_num + RTC_GPIO_ENABLE_W1TC_S));
+        ESP_REG(rtc_reg) = reg_val | rtc_gpio_desc[pin].mux;
+        //unlock rtc
+        ESP_REG(DR_REG_IO_MUX_BASE + esp32_gpioMux[pin].reg) = ((uint32_t)2 << MCU_SEL_S) | ((uint32_t)2 << FUN_DRV_S) | FUN_IE;
         return;
     }
 
     //RTC pins PULL settings
     if(rtc_reg) {
-        ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_io_desc[rtc_io].mux);
+        //lock rtc
+        ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].mux);
         if(mode & PULLUP) {
-            ESP_REG(rtc_reg) = (ESP_REG(rtc_reg) | rtc_io_desc[rtc_io].pullup) & ~(rtc_io_desc[rtc_io].pulldown);
+            ESP_REG(rtc_reg) = (ESP_REG(rtc_reg) | rtc_gpio_desc[pin].pullup) & ~(rtc_gpio_desc[pin].pulldown);
         } else if(mode & PULLDOWN) {
-            ESP_REG(rtc_reg) = (ESP_REG(rtc_reg) | rtc_io_desc[rtc_io].pulldown) & ~(rtc_io_desc[rtc_io].pullup);
+            ESP_REG(rtc_reg) = (ESP_REG(rtc_reg) | rtc_gpio_desc[pin].pulldown) & ~(rtc_gpio_desc[pin].pullup);
         } else {
-            ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_io_desc[rtc_io].pullup | rtc_io_desc[rtc_io].pulldown);
+            ESP_REG(rtc_reg) = ESP_REG(rtc_reg) & ~(rtc_gpio_desc[pin].pullup | rtc_gpio_desc[pin].pulldown);
         }
+        //unlock rtc
     }
 
     uint32_t pinFunction = 0, pinControl = 0;
 
+    //lock gpio
     if(mode & INPUT) {
         if(pin < 32) {
             GPIO.enable_w1tc = ((uint32_t)1 << pin);
@@ -209,8 +133,9 @@ extern void ARDUINO_ISR_ATTR __pinMode(uint8_t pin, uint8_t mode)
             GPIO.enable1_w1tc.val = ((uint32_t)1 << (pin - 32));
         }
     } else if(mode & OUTPUT) {
-        if(pin >= NUM_OUPUT_PINS){
-            return;
+        if(pin > 33){
+            //unlock gpio
+            return;//pins above 33 can be only inputs
         } else if(pin < 32) {
             GPIO.enable_w1ts = ((uint32_t)1 << pin);
         } else {
@@ -228,17 +153,9 @@ 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)) {
-#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);
-#elif CONFIG_IDF_TARGET_ESP32S2
-        pinFunction |= ((uint32_t)(((pin)==RX||(pin)==TX)?0:2) << MCU_SEL_S);
-#endif
+        pinFunction |= ((uint32_t)(((pin)==1||(pin)==3)?0:1) << MCU_SEL_S);
     } else {
         pinFunction |= ((uint32_t)(mode >> 5) << MCU_SEL_S);
     }
@@ -250,30 +167,31 @@ extern void ARDUINO_ISR_ATTR __pinMode(uint8_t pin, uint8_t mode)
     }
 
     GPIO.pin[pin].val = pinControl;
+    //unlock gpio
 }
 
-extern void ARDUINO_ISR_ATTR __digitalWrite(uint8_t pin, uint8_t val)
+extern void IRAM_ATTR __digitalWrite(uint8_t pin, uint8_t val)
 {
     if(val) {
         if(pin < 32) {
             GPIO.out_w1ts = ((uint32_t)1 << pin);
-        } else if(pin < NUM_OUPUT_PINS) {
+        } else if(pin < 34) {
             GPIO.out1_w1ts.val = ((uint32_t)1 << (pin - 32));
         }
     } else {
         if(pin < 32) {
             GPIO.out_w1tc = ((uint32_t)1 << pin);
-        } else if(pin < NUM_OUPUT_PINS) {
+        } else if(pin < 34) {
             GPIO.out1_w1tc.val = ((uint32_t)1 << (pin - 32));
         }
     }
 }
 
-extern int ARDUINO_ISR_ATTR __digitalRead(uint8_t pin)
+extern int IRAM_ATTR __digitalRead(uint8_t pin)
 {
     if(pin < 32) {
         return (GPIO.in >> pin) & 0x1;
-    } else if(pin < GPIO_PIN_COUNT) {
+    } else if(pin < 40) {
         return (GPIO.in1.val >> (pin - 32)) & 0x1;
     }
     return 0;
@@ -281,7 +199,7 @@ extern int ARDUINO_ISR_ATTR __digitalRead(uint8_t pin)
 
 static intr_handle_t gpio_intr_handle = NULL;
 
-static void ARDUINO_ISR_ATTR __onPinInterrupt()
+static void IRAM_ATTR __onPinInterrupt()
 {
     uint32_t gpio_intr_status_l=0;
     uint32_t gpio_intr_status_h=0;
@@ -329,7 +247,7 @@ extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc,
 
     if(!interrupt_initialized) {
         interrupt_initialized = true;
-        esp_intr_alloc(ETS_GPIO_INTR_SOURCE, (int)ARDUINO_ISR_FLAG, __onPinInterrupt, NULL, &gpio_intr_handle);
+        esp_intr_alloc(ETS_GPIO_INTR_SOURCE, (int)ESP_INTR_FLAG_IRAM, __onPinInterrupt, NULL, &gpio_intr_handle);
     }
 
     // if new attach without detach remove old info
@@ -342,15 +260,11 @@ extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc,
     __pinInterruptHandlers[pin].functional = functional;
 
     esp_intr_disable(gpio_intr_handle);
-#if CONFIG_IDF_TARGET_ESP32
     if(esp_intr_get_cpu(gpio_intr_handle)) { //APP_CPU
-#endif
         GPIO.pin[pin].int_ena = 1;
-#if CONFIG_IDF_TARGET_ESP32
     } else { //PRO_CPU
         GPIO.pin[pin].int_ena = 4;
     }
-#endif
     GPIO.pin[pin].int_type = intr_type;
     esp_intr_enable(gpio_intr_handle);
 }

cores/esp32/esp32-hal-gpio.h

@@ -25,17 +25,6 @@ extern "C" {
 #endif
 
 #include "esp32-hal.h"
-#include "soc/soc_caps.h"
-
-#if (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
-#define NUM_OUPUT_PINS  45
-#define PIN_DAC1        17
-#define PIN_DAC2        18
-#else
-#define NUM_OUPUT_PINS  34
-#define PIN_DAC1        25
-#define PIN_DAC2        26
-#endif
 
 #define LOW               0x0
 #define HIGH              0x1
@@ -75,15 +64,15 @@ typedef struct {
     int8_t touch;     /*!< Touch Channel number (-1 if not Touch pin) */
 } esp32_gpioMux_t;
 
-extern const esp32_gpioMux_t esp32_gpioMux[SOC_GPIO_PIN_COUNT];
+extern const esp32_gpioMux_t esp32_gpioMux[40];
 extern const int8_t esp32_adc2gpio[20];
 
-#define digitalPinIsValid(pin)          ((pin) < SOC_GPIO_PIN_COUNT && esp32_gpioMux[(pin)].reg)
-#define digitalPinCanOutput(pin)        ((pin) < NUM_OUPUT_PINS && esp32_gpioMux[(pin)].reg)
-#define digitalPinToRtcPin(pin)         (((pin) < SOC_GPIO_PIN_COUNT)?esp32_gpioMux[(pin)].rtc:-1)
-#define digitalPinToAnalogChannel(pin)  (((pin) < SOC_GPIO_PIN_COUNT)?esp32_gpioMux[(pin)].adc:-1)
-#define digitalPinToTouchChannel(pin)   (((pin) < SOC_GPIO_PIN_COUNT)?esp32_gpioMux[(pin)].touch:-1)
-#define digitalPinToDacChannel(pin)     (((pin) == PIN_DAC1)?0:((pin) == PIN_DAC2)?1:-1)
+#define digitalPinIsValid(pin)          ((pin) < 40 && esp32_gpioMux[(pin)].reg)
+#define digitalPinCanOutput(pin)        ((pin) < 34 && esp32_gpioMux[(pin)].reg)
+#define digitalPinToRtcPin(pin)         (((pin) < 40)?esp32_gpioMux[(pin)].rtc:-1)
+#define digitalPinToAnalogChannel(pin)  (((pin) < 40)?esp32_gpioMux[(pin)].adc:-1)
+#define digitalPinToTouchChannel(pin)   (((pin) < 40)?esp32_gpioMux[(pin)].touch:-1)
+#define digitalPinToDacChannel(pin)     (((pin) == 25)?0:((pin) == 26)?1:-1)
 
 void pinMode(uint8_t pin, uint8_t mode);
 void digitalWrite(uint8_t pin, uint8_t val);

cores/esp32/esp32-hal-i2c.c

@@ -18,28 +18,13 @@
 #include "freertos/task.h"
 #include "freertos/semphr.h"
 #include "freertos/event_groups.h"
+#include "rom/ets_sys.h"
 #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 "esp32/rom/ets_sys.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/ets_sys.h"
-#endif
-
-
-#if CONFIG_IDF_TARGET_ESP32
 //#define I2C_DEV(i)   (volatile i2c_dev_t *)((i)?DR_REG_I2C1_EXT_BASE:DR_REG_I2C_EXT_BASE)
 //#define I2C_DEV(i)   ((i2c_dev_t *)(REG_I2C_BASE(i)))
 #define I2C_SCL_IDX(p)  ((p==0)?I2CEXT0_SCL_OUT_IDX:((p==1)?I2CEXT1_SCL_OUT_IDX:0))
@@ -242,7 +227,7 @@ static i2c_t _i2c_bus_array[2] = {
 
 /* Stickbreaker ISR mode debug support
  */
-static void ARDUINO_ISR_ATTR i2cDumpCmdQueue(i2c_t *i2c)
+static void IRAM_ATTR i2cDumpCmdQueue(i2c_t *i2c)
 {
 #if (ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_ERROR)&&(defined ENABLE_I2C_DEBUG_BUFFER)
     static const char * const cmdName[] ={"RSTART","WRITE","READ","STOP","END"};
@@ -372,7 +357,7 @@ static void i2cDumpInts(uint8_t num)
 #endif
 
 #if (ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO)&&(defined ENABLE_I2C_DEBUG_BUFFER)
-static void ARDUINO_ISR_ATTR i2cDumpStatus(i2c_t * i2c){
+static void IRAM_ATTR i2cDumpStatus(i2c_t * i2c){
     typedef union {
         struct {
             uint32_t ack_rec:             1;        /*This register stores the value of ACK bit.*/
@@ -446,7 +431,7 @@ if(i != fifoPos){// actual data
 }
 #endif
 
-static void ARDUINO_ISR_ATTR i2cTriggerDumps(i2c_t * i2c, uint8_t trigger, const char locus[]){
+static void IRAM_ATTR i2cTriggerDumps(i2c_t * i2c, uint8_t trigger, const char locus[]){
 #if (ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO)&&(defined ENABLE_I2C_DEBUG_BUFFER)
     if( trigger ){
       log_i("%s",locus);      
@@ -493,7 +478,7 @@ static void i2cApbChangeCallback(void * arg, apb_change_ev_t ev_type, uint32_t o
 }
 /* End of CPU Clock change Support
 */ 
-static void ARDUINO_ISR_ATTR i2cSetCmd(i2c_t * i2c, uint8_t index, uint8_t op_code, uint8_t byte_num, bool ack_val, bool ack_exp, bool ack_check)
+static void IRAM_ATTR i2cSetCmd(i2c_t * i2c, uint8_t index, uint8_t op_code, uint8_t byte_num, bool ack_val, bool ack_exp, bool ack_check)
 {
     I2C_COMMAND_t cmd;
     cmd.val=0;
@@ -506,7 +491,7 @@ static void ARDUINO_ISR_ATTR i2cSetCmd(i2c_t * i2c, uint8_t index, uint8_t op_co
 }
  
 
-static void ARDUINO_ISR_ATTR fillCmdQueue(i2c_t * i2c, bool INTS)
+static void IRAM_ATTR fillCmdQueue(i2c_t * i2c, bool INTS)
 {
     /* this function is called on initial i2cProcQueue() or when a I2C_END_DETECT_INT occurs
      */
@@ -664,7 +649,7 @@ static void ARDUINO_ISR_ATTR fillCmdQueue(i2c_t * i2c, bool INTS)
     }
 }
 
-static void ARDUINO_ISR_ATTR fillTxFifo(i2c_t * i2c)
+static void IRAM_ATTR fillTxFifo(i2c_t * i2c)
 {
     /*
     12/01/2017 The Fifo's are independent, 32 bytes of tx and 32 bytes of Rx.
@@ -756,7 +741,7 @@ static void ARDUINO_ISR_ATTR fillTxFifo(i2c_t * i2c)
 }
 
 
-static void ARDUINO_ISR_ATTR emptyRxFifo(i2c_t * i2c)
+static void IRAM_ATTR emptyRxFifo(i2c_t * i2c)
 {
     uint32_t d, cnt=0, moveCnt;
     
@@ -815,7 +800,7 @@ static void ARDUINO_ISR_ATTR emptyRxFifo(i2c_t * i2c)
 #endif
 }
 
-static void ARDUINO_ISR_ATTR i2cIsrExit(i2c_t * i2c,const uint32_t eventCode,bool Fatal)
+static void IRAM_ATTR i2cIsrExit(i2c_t * i2c,const uint32_t eventCode,bool Fatal)
 {
 
     switch(eventCode) {
@@ -860,7 +845,7 @@ static void ARDUINO_ISR_ATTR i2cIsrExit(i2c_t * i2c,const uint32_t eventCode,boo
 
 }
 
-static void ARDUINO_ISR_ATTR i2c_update_error_byte_cnt(i2c_t * i2c)
+static void IRAM_ATTR i2c_update_error_byte_cnt(i2c_t * i2c)
 {
 /* i2c_update_error_byte_cnt 07/18/2018
   Only called after an error has occurred, so, most of the time this function is never used.
@@ -907,7 +892,7 @@ static void ARDUINO_ISR_ATTR i2c_update_error_byte_cnt(i2c_t * i2c)
     i2c->errorByteCnt = bc;
  }
 
-static void ARDUINO_ISR_ATTR i2c_isr_handler_default(void* arg)
+static void IRAM_ATTR i2c_isr_handler_default(void* arg)
 {
     i2c_t* p_i2c = (i2c_t*) arg; // recover data
     uint32_t activeInt = p_i2c->dev->int_status.val&0x7FF;
@@ -1262,7 +1247,7 @@ i2c_err_t i2cProcQueue(i2c_t * i2c, uint32_t *readCount, uint16_t timeOutMillis)
     if(!i2c->intr_handle) { // create ISR for either peripheral
         // log_i("create ISR %d",i2c->num);
         uint32_t ret = 0;
-        uint32_t flags = ARDUINO_ISR_FLAG |  //< ISR can be called if cache is disabled
+        uint32_t flags = ESP_INTR_FLAG_IRAM |  //< ISR can be called if cache is disabled
           ESP_INTR_FLAG_LOWMED |   //< Low and medium prio interrupts. These can be handled in C.
           ESP_INTR_FLAG_SHARED; //< Reduce resource requirements, Share interrupts
       
@@ -1780,137 +1765,7 @@ uint32_t i2cGetStatus(i2c_t * i2c){
     }
     else return 0;
 }
-#else
-#include "driver/i2c.h"
 
-#define ACK_CHECK_EN                1                   /*!< I2C master will check ack from slave*/
-#define ACK_CHECK_DIS               0                   /*!< I2C master will not check ack from slave */
-#define ACK_VAL                     0x0                 /*!< I2C ack value */
-#define NACK_VAL                    0x1                 /*!< I2C nack value */
-
-struct i2c_struct_t {
-	i2c_port_t num;
-};
-
-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 >= 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));
-		if(out == NULL){
-			log_e("malloc failed");
-			return NULL;
-		}
-		out->num = (i2c_port_t)i2c_num;
-		i2c_ports[i2c_num] = out;
-	} else {
-		out = i2c_ports[i2c_num];
-		i2c_driver_delete((i2c_port_t)i2c_num);
-	}
-
-    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;
-    conf.scl_pullup_en = GPIO_PULLUP_ENABLE;
-    conf.sda_pullup_en = GPIO_PULLUP_ENABLE;
-    conf.master.clk_speed = clk_speed;
-    esp_err_t ret = i2c_param_config(out->num, &conf);
-    if (ret != ESP_OK) {
-        log_e("i2c_param_config failed");
-        free(out);
-        i2c_ports[i2c_num] = NULL;
-        return NULL;
-    }
-    ret = i2c_driver_install(out->num, conf.mode, 0, 0, 0);
-    if (ret != ESP_OK) {
-        log_e("i2c_driver_install failed");
-        free(out);
-        i2c_ports[i2c_num] = NULL;
-        return NULL;
-    }
-    return out;
-}
-
-i2c_err_t i2cWrite(i2c_t * i2c, uint16_t address, uint8_t* buff, uint16_t size, bool sendStop, uint16_t timeOutMillis){
-	esp_err_t ret = ESP_OK;
-    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-    i2c_master_start(cmd);
-    i2c_master_write_byte(cmd, (address << 1) | I2C_MASTER_WRITE, ACK_CHECK_EN);
-    i2c_master_write(cmd, buff, size, ACK_CHECK_EN);
-    //if send stop?
-    i2c_master_stop(cmd);
-    ret = i2c_master_cmd_begin(i2c->num, cmd, timeOutMillis / portTICK_RATE_MS);
-    i2c_cmd_link_delete(cmd);
-    return ret;
-}
-
-i2c_err_t i2cRead(i2c_t * i2c, uint16_t address, uint8_t* buff, uint16_t size, bool sendStop, uint16_t timeOutMillis, uint32_t *readCount){
-	esp_err_t ret = ESP_OK;
-    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
-    i2c_master_start(cmd);
-    i2c_master_write_byte(cmd, (address << 1) | I2C_MASTER_READ, ACK_CHECK_EN);
-    if (size > 1) {
-        i2c_master_read(cmd, buff, size - 1, ACK_VAL);
-    }
-    i2c_master_read_byte(cmd, buff + size - 1, NACK_VAL);
-    i2c_master_stop(cmd);
-    ret = i2c_master_cmd_begin(i2c->num, cmd, timeOutMillis / portTICK_RATE_MS);
-    i2c_cmd_link_delete(cmd);
-    if(ret == ESP_OK){
-    	*readCount = size;
-    }
-    return ret;
-}
-
-void i2cRelease(i2c_t *i2c){
-	log_w("");
-    return;
-}
-i2c_err_t i2cFlush(i2c_t *i2c){
-	esp_err_t ret = i2c_reset_tx_fifo(i2c->num);
-    if(ret != ESP_OK){
-    	return ret;
-    }
-    return i2c_reset_rx_fifo(i2c->num);
-}
-i2c_err_t i2cSetFrequency(i2c_t * i2c, uint32_t clk_speed){
-	log_w("");
-    return ESP_OK;
-}
-uint32_t i2cGetFrequency(i2c_t * i2c){
-	log_w("");
-    return 0;
-}
-uint32_t i2cGetStatus(i2c_t * i2c){
-	log_w("");
-    return 0;
-}
-
-//Functions below should be used only if well understood
-//Might be deprecated and removed in future
-i2c_err_t i2cAttachSCL(i2c_t * i2c, int8_t scl){
-    return ESP_FAIL;
-}
-i2c_err_t i2cDetachSCL(i2c_t * i2c, int8_t scl){
-    return ESP_FAIL;
-}
-i2c_err_t i2cAttachSDA(i2c_t * i2c, int8_t sda){
-    return ESP_FAIL;
-}
-i2c_err_t i2cDetachSDA(i2c_t * i2c, int8_t sda){
-    return ESP_FAIL;
-}
-
-#endif /* CONFIG_IDF_TARGET_ESP32 */
 
 /* todo
   22JUL18

cores/esp32/esp32-hal-ledc.c

@@ -16,27 +16,12 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/semphr.h"
+#include "rom/ets_sys.h"
 #include "esp32-hal-matrix.h"
 #include "soc/dport_reg.h"
 #include "soc/ledc_reg.h"
 #include "soc/ledc_struct.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"
-#define LAST_CHAN (15)
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/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
-#else // ESP32 Before IDF 4.0
-#include "rom/ets_sys.h"
-#endif
-
 #if CONFIG_DISABLE_HAL_LOCKS
 #define LEDC_MUTEX_LOCK()
 #define LEDC_MUTEX_UNLOCK()
@@ -124,13 +109,9 @@ static void _ledcSetupTimer(uint8_t chan, uint32_t div_num, uint8_t bit_num, boo
     LEDC_TIMER(group, timer).conf.clock_divider = div_num;//18 bit (10.8) This register is used to configure parameter for divider in timer the least significant eight bits represent the decimal part.
     LEDC_TIMER(group, timer).conf.duty_resolution = bit_num;//5 bit This register controls the range of the counter in timer. the counter range is [0 2**bit_num] the max bit width for counter is 20.
     LEDC_TIMER(group, timer).conf.tick_sel = apb_clk;//apb clock
-#if CONFIG_IDF_TARGET_ESP32
     if(group) {
-#endif
         LEDC_TIMER(group, timer).conf.low_speed_update = 1;//This bit is only useful for low speed timer channels, reserved for high speed timers
-#if CONFIG_IDF_TARGET_ESP32
     }
-#endif
     LEDC_TIMER(group, timer).conf.pause = 0;
     LEDC_TIMER(group, timer).conf.rst = 1;//This bit is used to reset timer the counter will be 0 after reset.
     LEDC_TIMER(group, timer).conf.rst = 0;
@@ -195,21 +176,17 @@ static void _ledcSetupChannel(uint8_t chan, uint8_t idle_level)
     LEDC_CHAN(group, channel).duty.duty = 0;
     LEDC_CHAN(group, channel).conf0.sig_out_en = 0;//This is the output enable control bit for channel
     LEDC_CHAN(group, channel).conf1.duty_start = 0;//When duty_num duty_cycle and duty_scale has been configured. these register won't take effect until set duty_start. this bit is automatically cleared by hardware.
-#if CONFIG_IDF_TARGET_ESP32
     if(group) {
-#endif
         LEDC_CHAN(group, channel).conf0.low_speed_update = 1;
-#if CONFIG_IDF_TARGET_ESP32
     } else {
         LEDC_CHAN(group, channel).conf0.clk_en = 0;
     }
-#endif
     LEDC_MUTEX_UNLOCK();
 }
 
 double ledcSetup(uint8_t chan, double freq, uint8_t bit_num)
 {
-    if(chan > LAST_CHAN) {
+    if(chan > 15) {
         return 0;
     }
     double res_freq = _ledcSetupTimerFreq(chan, freq, bit_num);
@@ -219,7 +196,7 @@ double ledcSetup(uint8_t chan, double freq, uint8_t bit_num)
 
 void ledcWrite(uint8_t chan, uint32_t duty)
 {
-    if(chan > LAST_CHAN) {
+    if(chan > 15) {
         return;
     }
     uint8_t group=(chan/8), channel=(chan%8);
@@ -228,34 +205,26 @@ void ledcWrite(uint8_t chan, uint32_t duty)
     if(duty) {
         LEDC_CHAN(group, channel).conf0.sig_out_en = 1;//This is the output enable control bit for channel
         LEDC_CHAN(group, channel).conf1.duty_start = 1;//When duty_num duty_cycle and duty_scale has been configured. these register won't take effect until set duty_start. this bit is automatically cleared by hardware.
-#if CONFIG_IDF_TARGET_ESP32
         if(group) {
-#endif
             LEDC_CHAN(group, channel).conf0.low_speed_update = 1;
-#if CONFIG_IDF_TARGET_ESP32
         } else {
             LEDC_CHAN(group, channel).conf0.clk_en = 1;
         }
-#endif
     } else {
         LEDC_CHAN(group, channel).conf0.sig_out_en = 0;//This is the output enable control bit for channel
         LEDC_CHAN(group, channel).conf1.duty_start = 0;//When duty_num duty_cycle and duty_scale has been configured. these register won't take effect until set duty_start. this bit is automatically cleared by hardware.
-#if CONFIG_IDF_TARGET_ESP32
         if(group) {
-#endif
             LEDC_CHAN(group, channel).conf0.low_speed_update = 1;
-#if CONFIG_IDF_TARGET_ESP32
         } else {
             LEDC_CHAN(group, channel).conf0.clk_en = 0;
         }
-#endif
     }
     LEDC_MUTEX_UNLOCK();
 }
 
 uint32_t ledcRead(uint8_t chan)
 {
-    if(chan > LAST_CHAN) {
+    if(chan > 15) {
         return 0;
     }
     return LEDC.channel_group[chan/8].channel[chan%8].duty.duty >> 4;
@@ -271,7 +240,7 @@ double ledcReadFreq(uint8_t chan)
 
 double ledcWriteTone(uint8_t chan, double freq)
 {
-    if(chan > LAST_CHAN) {
+    if(chan > 15) {
         return 0;
     }
     if(!freq) {
@@ -298,15 +267,11 @@ double ledcWriteNote(uint8_t chan, note_t note, uint8_t octave){
 
 void ledcAttachPin(uint8_t pin, uint8_t chan)
 {
-    if(chan > LAST_CHAN) {
+    if(chan > 15) {
         return;
     }
     pinMode(pin, OUTPUT);
-#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);
-#endif
 }
 
 void ledcDetachPin(uint8_t pin)

cores/esp32/esp32-hal-log.c

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

cores/esp32/esp32-hal-log.h

@@ -20,7 +20,6 @@ extern "C"
 #endif
 
 #include "sdkconfig.h"
-#include "esp_timer.h"
 
 #define ARDUHAL_LOG_LEVEL_NONE       (0)
 #define ARDUHAL_LOG_LEVEL_ERROR      (1)
@@ -37,6 +36,9 @@ 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
@@ -72,62 +74,101 @@ extern "C"
 #define ARDUHAL_LOG_RESET_COLOR
 #endif
 
+
+
 const char * pathToFileName(const char * path);
 int log_printf(const char *fmt, ...);
 
 #define ARDUHAL_SHORT_LOG_FORMAT(letter, format)  ARDUHAL_LOG_COLOR_ ## letter format ARDUHAL_LOG_RESET_COLOR "\r\n"
-#define ARDUHAL_LOG_FORMAT(letter, format)  ARDUHAL_LOG_COLOR_ ## letter "[%6u][" #letter "][%s:%u] %s(): " format ARDUHAL_LOG_RESET_COLOR "\r\n", (unsigned long) (esp_timer_get_time() / 1000ULL), pathToFileName(__FILE__), __LINE__, __FUNCTION__
+#define ARDUHAL_LOG_FORMAT(letter, format)  ARDUHAL_LOG_COLOR_ ## letter "[" #letter "][%s:%u] %s(): " format ARDUHAL_LOG_RESET_COLOR "\r\n", 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 {log_to_esp(TAG, ESP_LOG_VERBOSE, 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 {log_to_esp(TAG, ESP_LOG_DEBUG, 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 {log_to_esp(TAG, ESP_LOG_INFO, 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 {log_to_esp(TAG, ESP_LOG_WARN, 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 {log_to_esp(TAG, ESP_LOG_ERROR, 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
+void log_to_esp(char* tag, esp_log_level_t level, const char* format, ...);
+//#define log_n(format, ...) myLog(ESP_LOG_NONE, format, ##__VA_ARGS__)
+#else
 #ifdef CONFIG_ARDUHAL_ESP_LOG
 #undef ESP_LOGE
 #undef ESP_LOGW
@@ -151,6 +192,7 @@ 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

@@ -14,45 +14,33 @@
 
 #include "esp32-hal-matrix.h"
 #include "esp_attr.h"
-
-#include "esp_system.h"
-#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "esp32/rom/gpio.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/gpio.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
 #include "rom/gpio.h"
-#endif
 
 #define MATRIX_DETACH_OUT_SIG 0x100
 #define MATRIX_DETACH_IN_LOW_PIN 0x30
 #define MATRIX_DETACH_IN_LOW_HIGH 0x38
 
-void ARDUINO_ISR_ATTR pinMatrixOutAttach(uint8_t pin, uint8_t function, bool invertOut, bool invertEnable)
+void IRAM_ATTR pinMatrixOutAttach(uint8_t pin, uint8_t function, bool invertOut, bool invertEnable)
 {
     gpio_matrix_out(pin, function, invertOut, invertEnable);
 }
 
-void ARDUINO_ISR_ATTR pinMatrixOutDetach(uint8_t pin, bool invertOut, bool invertEnable)
+void IRAM_ATTR pinMatrixOutDetach(uint8_t pin, bool invertOut, bool invertEnable)
 {
     gpio_matrix_out(pin, MATRIX_DETACH_OUT_SIG, invertOut, invertEnable);
 }
 
-void ARDUINO_ISR_ATTR pinMatrixInAttach(uint8_t pin, uint8_t signal, bool inverted)
+void IRAM_ATTR pinMatrixInAttach(uint8_t pin, uint8_t signal, bool inverted)
 {
     gpio_matrix_in(pin, signal, inverted);
 }
 
-void ARDUINO_ISR_ATTR pinMatrixInDetach(uint8_t signal, bool high, bool inverted)
+void IRAM_ATTR pinMatrixInDetach(uint8_t signal, bool high, bool inverted)
 {
     gpio_matrix_in(high?MATRIX_DETACH_IN_LOW_HIGH:MATRIX_DETACH_IN_LOW_PIN, signal, inverted);
 }
 /*
-void ARDUINO_ISR_ATTR intrMatrixAttach(uint32_t source, uint32_t inum){
+void IRAM_ATTR intrMatrixAttach(uint32_t source, uint32_t inum){
   intr_matrix_set(PRO_CPU_NUM, source, inum);
 }
 */

cores/esp32/esp32-hal-misc.c

@@ -31,22 +31,10 @@
 #include "soc/rtc.h"
 #include "soc/rtc_cntl_reg.h"
 #include "soc/apb_ctrl_reg.h"
+#include "rom/rtc.h"
 #include "esp_task_wdt.h"
 #include "esp32-hal.h"
 
-#include "esp_system.h"
-#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "esp32/rom/rtc.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/rtc.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/rtc.h"
-#endif
-
 //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
 uint8_t temprature_sens_read();
@@ -143,12 +131,12 @@ BaseType_t xTaskCreateUniversal( TaskFunction_t pxTaskCode,
 #endif
 }
 
-unsigned long ARDUINO_ISR_ATTR micros()
+unsigned long IRAM_ATTR micros()
 {
     return (unsigned long) (esp_timer_get_time());
 }
 
-unsigned long ARDUINO_ISR_ATTR millis()
+unsigned long IRAM_ATTR millis()
 {
     return (unsigned long) (esp_timer_get_time() / 1000ULL);
 }
@@ -158,7 +146,7 @@ void delay(uint32_t ms)
     vTaskDelay(ms / portTICK_PERIOD_MS);
 }
 
-void ARDUINO_ISR_ATTR delayMicroseconds(uint32_t us)
+void IRAM_ATTR delayMicroseconds(uint32_t us)
 {
     uint32_t m = micros();
     if(us){
@@ -210,7 +198,7 @@ void initArduino()
 #ifdef F_CPU
     setCpuFrequencyMhz(F_CPU/1000000);
 #endif
-#if CONFIG_SPIRAM_SUPPORT || CONFIG_SPIRAM
+#if CONFIG_SPIRAM_SUPPORT
     psramInit();
 #endif
     esp_log_level_set("*", CONFIG_LOG_DEFAULT_LEVEL);
@@ -239,7 +227,7 @@ void initArduino()
 }
 
 //used by hal log
-const char * ARDUINO_ISR_ATTR pathToFileName(const char * path)
+const char * IRAM_ATTR pathToFileName(const char * path)
 {
     size_t i = 0;
     size_t pos = 0;

cores/esp32/esp32-hal-psram.c

@@ -1,37 +1,11 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
 
 #include "esp32-hal.h"
 
-#if CONFIG_SPIRAM_SUPPORT || CONFIG_SPIRAM
+#if CONFIG_SPIRAM_SUPPORT
+#include "esp_spiram.h"
 #include "soc/efuse_reg.h"
 #include "esp_heap_caps.h"
 
-#include "esp_system.h"
-#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "esp32/spiram.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/spiram.h"
-#include "esp32s2/rom/cache.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "esp_spiram.h"
-#endif
-
 static volatile bool spiramDetected = false;
 static volatile bool spiramFailed = false;
 
@@ -43,7 +17,6 @@ bool psramInit(){
     if (spiramFailed) {
         return false;
     }
-#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;
     if (pkg_ver == EFUSE_RD_CHIP_VER_PKG_ESP32D2WDQ5 || pkg_ver == EFUSE_RD_CHIP_VER_PKG_ESP32PICOD2) {
@@ -51,21 +24,14 @@ bool psramInit(){
         log_w("PSRAM not supported!");
         return false;
     }
-#elif CONFIG_IDF_TARGET_ESP32S2
-    extern void esp_config_data_cache_mode(void);
-    esp_config_data_cache_mode();
-    Cache_Enable_DCache(0);
-#endif
+    esp_spiram_init_cache();
     if (esp_spiram_init() != ESP_OK) {
         spiramFailed = true;
         log_w("PSRAM init failed!");
-#if CONFIG_IDF_TARGET_ESP32
         pinMatrixOutDetach(16, false, false);
         pinMatrixOutDetach(17, false, false);
-#endif
         return false;
     }
-    esp_spiram_init_cache();
     if (!esp_spiram_test()) {
         spiramFailed = true;
         log_e("PSRAM test failed!");
@@ -76,34 +42,31 @@ bool psramInit(){
         log_e("PSRAM could not be added to the heap!");
         return false;
     }
-#if CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL && !CONFIG_ARDUINO_ISR_IRAM
-        heap_caps_malloc_extmem_enable(CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL);
-#endif
 #endif
     spiramDetected = true;
     log_d("PSRAM enabled");
     return true;
 }
 
-bool ARDUINO_ISR_ATTR psramFound(){
+bool IRAM_ATTR psramFound(){
     return spiramDetected;
 }
 
-void ARDUINO_ISR_ATTR *ps_malloc(size_t size){
+void IRAM_ATTR *ps_malloc(size_t size){
     if(!spiramDetected){
         return NULL;
     }
     return heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
 }
 
-void ARDUINO_ISR_ATTR *ps_calloc(size_t n, size_t size){
+void IRAM_ATTR *ps_calloc(size_t n, size_t size){
     if(!spiramDetected){
         return NULL;
     }
     return heap_caps_calloc(n, size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
 }
 
-void ARDUINO_ISR_ATTR *ps_realloc(void *ptr, size_t size){
+void IRAM_ATTR *ps_realloc(void *ptr, size_t size){
     if(!spiramDetected){
         return NULL;
     }
@@ -116,19 +79,19 @@ bool psramInit(){
     return false;
 }
 
-bool ARDUINO_ISR_ATTR psramFound(){
+bool IRAM_ATTR psramFound(){
     return false;
 }
 
-void ARDUINO_ISR_ATTR *ps_malloc(size_t size){
+void IRAM_ATTR *ps_malloc(size_t size){
     return NULL;
 }
 
-void ARDUINO_ISR_ATTR *ps_calloc(size_t n, size_t size){
+void IRAM_ATTR *ps_calloc(size_t n, size_t size){
     return NULL;
 }
 
-void ARDUINO_ISR_ATTR *ps_realloc(void *ptr, size_t size){
+void IRAM_ATTR *ps_realloc(void *ptr, size_t size){
     return NULL;
 }
 

cores/esp32/esp32-hal-psram.h

@@ -19,17 +19,6 @@
 extern "C" {
 #endif
 
-#include "sdkconfig.h"
-
-#ifndef BOARD_HAS_PSRAM
-#ifdef CONFIG_SPIRAM_SUPPORT
-#undef CONFIG_SPIRAM_SUPPORT
-#endif
-#ifdef CONFIG_SPIRAM
-#undef CONFIG_SPIRAM
-#endif
-#endif
-
 bool psramInit();
 bool psramFound();
 

cores/esp32/esp32-hal-rmt.c

@@ -19,20 +19,18 @@
 #include "esp32-hal.h"
 #include "esp8266-compat.h"
 #include "soc/gpio_reg.h"
-#include "soc/rmt_struct.h"
+#include "soc/gpio_reg.h"
+
+#include "esp32-hal-rmt.h"
 #include "driver/periph_ctrl.h"
+
+#include "soc/rmt_struct.h"
 #include "esp_intr_alloc.h"
 
 /**
  * Internal macros
  */
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #define MAX_CHANNELS 8
-#elif CONFIG_IDF_TARGET_ESP32S2
-#define MAX_CHANNELS 4
-#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)
@@ -103,10 +101,7 @@ struct rmt_obj_s
  * Internal variables for channel descriptors
  */
 static xSemaphoreHandle g_rmt_objlocks[MAX_CHANNELS] = {
-    NULL, NULL, NULL, NULL, 
-#if CONFIG_IDF_TARGET_ESP32
-    NULL, NULL, NULL, NULL
-#endif
+    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
 };
 
 static rmt_obj_t g_rmt_objects[MAX_CHANNELS] = {
@@ -114,12 +109,10 @@ 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},
-#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},
-#endif
 };
 
 /**
@@ -138,17 +131,17 @@ static void _initPin(int pin, int channel, bool tx_not_rx);
 
 static bool _rmtSendOnce(rmt_obj_t* rmt, rmt_data_t* data, size_t size, bool continuous);
 
-static void ARDUINO_ISR_ATTR _rmt_isr(void* arg);
+static void IRAM_ATTR _rmt_isr(void* arg);
 
 static rmt_obj_t* _rmtAllocate(int pin, int from, int size);
 
 static void _initPin(int pin, int channel, bool tx_not_rx);
 
-static int ARDUINO_ISR_ATTR _rmt_get_mem_len(uint8_t channel);
+static int IRAM_ATTR _rmt_get_mem_len(uint8_t channel);
 
-static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch);
+static void IRAM_ATTR _rmt_tx_mem_first(uint8_t ch);
 
-static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch);
+static void IRAM_ATTR _rmt_tx_mem_second(uint8_t ch);
 
 
 /**
@@ -271,7 +264,7 @@ bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
         RMT_MUTEX_LOCK(channel);
         // setup interrupt handler if not yet installed for half and full tx
         if (!intr_handle) {
-            esp_intr_alloc(ETS_RMT_INTR_SOURCE, (int)ARDUINO_ISR_FLAG, _rmt_isr, NULL, &intr_handle);
+            esp_intr_alloc(ETS_RMT_INTR_SOURCE, (int)ESP_INTR_FLAG_IRAM, _rmt_isr, NULL, &intr_handle);
         }
 
         rmt->data_size = size - MAX_DATA_PER_ITTERATION;
@@ -557,17 +550,12 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
     RMT.conf_ch[channel].conf0.mem_size = buffers;
     RMT.conf_ch[channel].conf0.carrier_en = 0;
     RMT.conf_ch[channel].conf0.carrier_out_lv = 0;
-#if CONFIG_IDF_TARGET_ESP32
     RMT.conf_ch[channel].conf0.mem_pd = 0;
-#endif
+
     RMT.conf_ch[channel].conf0.idle_thres = 0x80;
     RMT.conf_ch[channel].conf1.rx_en = 0;
     RMT.conf_ch[channel].conf1.tx_conti_mode = 0;
-#if CONFIG_IDF_TARGET_ESP32
     RMT.conf_ch[channel].conf1.ref_cnt_rst = 0;
-#else
-    RMT.conf_ch[channel].conf1.chk_rx_carrier_en = 0;
-#endif
     RMT.conf_ch[channel].conf1.rx_filter_en = 0;
     RMT.conf_ch[channel].conf1.rx_filter_thres = 0;
     RMT.conf_ch[channel].conf1.idle_out_lv = 0;     // signal level for idle
@@ -588,7 +576,7 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
 
     // 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);
+        esp_intr_alloc(ETS_RMT_INTR_SOURCE, (int)ESP_INTR_FLAG_IRAM, _rmt_isr, NULL, &intr_handle);
     }
     RMT_MUTEX_UNLOCK(channel);
 
@@ -656,7 +644,7 @@ static void _initPin(int pin, int channel, bool tx_not_rx)
 }
 
 
-static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
+static void IRAM_ATTR _rmt_isr(void* arg)
 {
     int intr_val = RMT.int_st.val;
     size_t ch;
@@ -746,7 +734,7 @@ static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
     }
 }
 
-static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch)
+static void IRAM_ATTR _rmt_tx_mem_second(uint8_t ch)
 {
     DEBUG_INTERRUPT_START(4)
     uint32_t* data = g_rmt_objects[ch].data_ptr;
@@ -798,7 +786,7 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch)
     DEBUG_INTERRUPT_END(4);
 }
 
-static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch)
+static void IRAM_ATTR _rmt_tx_mem_first(uint8_t ch)
 {
     DEBUG_INTERRUPT_START(2);
     uint32_t* data = g_rmt_objects[ch].data_ptr;
@@ -849,7 +837,7 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch)
     DEBUG_INTERRUPT_END(2);
 }
 
-static int ARDUINO_ISR_ATTR _rmt_get_mem_len(uint8_t channel)
+static int IRAM_ATTR _rmt_get_mem_len(uint8_t channel)
 {
     int block_num = RMT.conf_ch[channel].conf0.mem_size;
     int item_block_len = block_num * 64;

cores/esp32/esp32-hal-sigmadelta.c

@@ -16,23 +16,11 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/semphr.h"
+#include "rom/ets_sys.h"
 #include "esp32-hal-matrix.h"
 #include "soc/gpio_sd_reg.h"
 #include "soc/gpio_sd_struct.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"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/ets_sys.h"
-#endif
-
 
 #if CONFIG_DISABLE_HAL_LOCKS
 #define SD_MUTEX_LOCK()
@@ -81,9 +69,6 @@ uint32_t sigmaDeltaSetup(uint8_t channel, uint32_t freq) //chan 0-7 freq 1220-31
         prescale = 0xFF;
     }
     SD_MUTEX_LOCK();
-#ifndef CONFIG_IDF_TARGET_ESP32
-    SIGMADELTA.misc.function_clk_en = 1;
-#endif
     SIGMADELTA.channel[channel].prescale = prescale;
     SIGMADELTA.cg.clk_en = 0;
     SIGMADELTA.cg.clk_en = 1;

cores/esp32/esp32-hal-spi.c

@@ -17,7 +17,10 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/semphr.h"
+#include "rom/ets_sys.h"
 #include "esp_attr.h"
+#include "esp_intr.h"
+#include "rom/gpio.h"
 #include "soc/spi_reg.h"
 #include "soc/spi_struct.h"
 #include "soc/io_mux_reg.h"
@@ -25,24 +28,17 @@
 #include "soc/dport_reg.h"
 #include "soc/rtc.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"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
-#include "esp32s2/rom/gpio.h"
-#include "esp_intr_alloc.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/ets_sys.h"
-#include "rom/gpio.h"
-#include "esp_intr.h"
-#endif
+#define SPI_CLK_IDX(p)  ((p==0)?SPICLK_OUT_IDX:((p==1)?SPICLK_OUT_IDX:((p==2)?HSPICLK_OUT_IDX:((p==3)?VSPICLK_OUT_IDX:0))))
+#define SPI_MISO_IDX(p) ((p==0)?SPIQ_OUT_IDX:((p==1)?SPIQ_OUT_IDX:((p==2)?HSPIQ_OUT_IDX:((p==3)?VSPIQ_OUT_IDX:0))))
+#define SPI_MOSI_IDX(p) ((p==0)?SPID_IN_IDX:((p==1)?SPID_IN_IDX:((p==2)?HSPID_IN_IDX:((p==3)?VSPID_IN_IDX:0))))
+
+#define SPI_SPI_SS_IDX(n)   ((n==0)?SPICS0_OUT_IDX:((n==1)?SPICS1_OUT_IDX:((n==2)?SPICS2_OUT_IDX:SPICS0_OUT_IDX)))
+#define SPI_HSPI_SS_IDX(n)   ((n==0)?HSPICS0_OUT_IDX:((n==1)?HSPICS1_OUT_IDX:((n==2)?HSPICS2_OUT_IDX:HSPICS0_OUT_IDX)))
+#define SPI_VSPI_SS_IDX(n)   ((n==0)?VSPICS0_OUT_IDX:((n==1)?VSPICS1_OUT_IDX:((n==2)?VSPICS2_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):((p==3)?SPI_VSPI_SS_IDX(n):0))))
+
+#define SPI_INUM(u)        (2)
+#define SPI_INTR_SOURCE(u) ((u==0)?ETS_SPI0_INTR_SOURCE:((u==1)?ETS_SPI1_INTR_SOURCE:((u==2)?ETS_SPI2_INTR_SOURCE:((p==3)?ETS_SPI3_INTR_SOURCE:0))))
 
 struct spi_struct_t {
     spi_dev_t * dev;
@@ -52,69 +48,25 @@ struct spi_struct_t {
     uint8_t num;
 };
 
-#if CONFIG_IDF_TARGET_ESP32S2
-// ESP32S2
-#define SPI_COUNT           (3)
-
-#define SPI_CLK_IDX(p)      ((p==0)?SPICLK_OUT_MUX_IDX:((p==1)?FSPICLK_OUT_MUX_IDX:((p==2)?SPI3_CLK_OUT_MUX_IDX:0)))
-#define SPI_MISO_IDX(p)     ((p==0)?SPIQ_OUT_IDX:((p==1)?FSPIQ_OUT_IDX:((p==2)?SPI3_Q_OUT_IDX:0)))
-#define SPI_MOSI_IDX(p)     ((p==0)?SPID_IN_IDX:((p==1)?FSPID_IN_IDX:((p==2)?SPI3_D_IN_IDX:0)))
-
-#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: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)))
-
-#else
-// ESP32
-#define SPI_COUNT           (4)
-
-#define SPI_CLK_IDX(p)      ((p==0)?SPICLK_OUT_IDX:((p==1)?SPICLK_OUT_IDX:((p==2)?HSPICLK_OUT_IDX:((p==3)?VSPICLK_OUT_IDX:0))))
-#define SPI_MISO_IDX(p)     ((p==0)?SPIQ_OUT_IDX:((p==1)?SPIQ_OUT_IDX:((p==2)?HSPIQ_OUT_IDX:((p==3)?VSPIQ_OUT_IDX:0))))
-#define SPI_MOSI_IDX(p)     ((p==0)?SPID_IN_IDX:((p==1)?SPID_IN_IDX:((p==2)?HSPID_IN_IDX:((p==3)?VSPID_IN_IDX:0))))
-
-#define SPI_SPI_SS_IDX(n)   ((n==0)?SPICS0_OUT_IDX:((n==1)?SPICS1_OUT_IDX:((n==2)?SPICS2_OUT_IDX:SPICS0_OUT_IDX)))
-#define SPI_HSPI_SS_IDX(n)  ((n==0)?HSPICS0_OUT_IDX:((n==1)?HSPICS1_OUT_IDX:((n==2)?HSPICS2_OUT_IDX:HSPICS0_OUT_IDX)))
-#define SPI_VSPI_SS_IDX(n)  ((n==0)?VSPICS0_OUT_IDX:((n==1)?VSPICS1_OUT_IDX:((n==2)?VSPICS2_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):((p==3)?SPI_VSPI_SS_IDX(n):0))))
-
-#define SPI_INTR_SOURCE(u)  ((u==0)?ETS_SPI0_INTR_SOURCE:((u==1)?ETS_SPI1_INTR_SOURCE:((u==2)?ETS_SPI2_INTR_SOURCE:((p==3)?ETS_SPI3_INTR_SOURCE:0))))
-
-#endif
-
 #if CONFIG_DISABLE_HAL_LOCKS
 #define SPI_MUTEX_LOCK()
 #define SPI_MUTEX_UNLOCK()
 
-static spi_t _spi_bus_array[] = {
-#if CONFIG_IDF_TARGET_ESP32S2
-    {(volatile spi_dev_t *)(DR_REG_SPI1_BASE), 0},
-    {(volatile spi_dev_t *)(DR_REG_SPI2_BASE), 1},
-    {(volatile spi_dev_t *)(DR_REG_SPI3_BASE), 2}
-#else
+static spi_t _spi_bus_array[4] = {
     {(volatile spi_dev_t *)(DR_REG_SPI0_BASE), 0},
     {(volatile spi_dev_t *)(DR_REG_SPI1_BASE), 1},
     {(volatile spi_dev_t *)(DR_REG_SPI2_BASE), 2},
     {(volatile spi_dev_t *)(DR_REG_SPI3_BASE), 3}
-#endif
 };
 #else
 #define SPI_MUTEX_LOCK()    do {} while (xSemaphoreTake(spi->lock, portMAX_DELAY) != pdPASS)
 #define SPI_MUTEX_UNLOCK()  xSemaphoreGive(spi->lock)
 
-static spi_t _spi_bus_array[] = {
-#if CONFIG_IDF_TARGET_ESP32S2
-    {(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}
-#else
+static spi_t _spi_bus_array[4] = {
     {(volatile spi_dev_t *)(DR_REG_SPI0_BASE), NULL, 0},
     {(volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 1},
     {(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 2},
     {(volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 3}
-#endif
 };
 #endif
 
@@ -124,14 +76,6 @@ void spiAttachSCK(spi_t * spi, int8_t sck)
         return;
     }
     if(sck < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            sck = 36;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             sck = 14;
         } else if(spi->num == VSPI) {
@@ -139,7 +83,6 @@ void spiAttachSCK(spi_t * spi, int8_t sck)
         } else {
             sck = 6;
         }
-#endif
     }
     pinMode(sck, OUTPUT);
     pinMatrixOutAttach(sck, SPI_CLK_IDX(spi->num), false, false);
@@ -151,14 +94,6 @@ void spiAttachMISO(spi_t * spi, int8_t miso)
         return;
     }
     if(miso < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            miso = 37;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             miso = 12;
         } else if(spi->num == VSPI) {
@@ -166,7 +101,6 @@ void spiAttachMISO(spi_t * spi, int8_t miso)
         } else {
             miso = 7;
         }
-#endif
     }
     SPI_MUTEX_LOCK();
     pinMode(miso, INPUT);
@@ -180,14 +114,6 @@ void spiAttachMOSI(spi_t * spi, int8_t mosi)
         return;
     }
     if(mosi < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            mosi = 35;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             mosi = 13;
         } else if(spi->num == VSPI) {
@@ -195,7 +121,6 @@ void spiAttachMOSI(spi_t * spi, int8_t mosi)
         } else {
             mosi = 8;
         }
-#endif
     }
     pinMode(mosi, OUTPUT);
     pinMatrixOutAttach(mosi, SPI_MOSI_IDX(spi->num), false, false);
@@ -207,14 +132,6 @@ void spiDetachSCK(spi_t * spi, int8_t sck)
         return;
     }
     if(sck < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            sck = 36;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             sck = 14;
         } else if(spi->num == VSPI) {
@@ -222,7 +139,6 @@ void spiDetachSCK(spi_t * spi, int8_t sck)
         } else {
             sck = 6;
         }
-#endif
     }
     pinMatrixOutDetach(sck, false, false);
     pinMode(sck, INPUT);
@@ -234,14 +150,6 @@ void spiDetachMISO(spi_t * spi, int8_t miso)
         return;
     }
     if(miso < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            miso = 37;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             miso = 12;
         } else if(spi->num == VSPI) {
@@ -249,7 +157,6 @@ void spiDetachMISO(spi_t * spi, int8_t miso)
         } else {
             miso = 7;
         }
-#endif
     }
     pinMatrixInDetach(SPI_MISO_IDX(spi->num), false, false);
     pinMode(miso, INPUT);
@@ -261,14 +168,6 @@ void spiDetachMOSI(spi_t * spi, int8_t mosi)
         return;
     }
     if(mosi < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            mosi = 35;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             mosi = 13;
         } else if(spi->num == VSPI) {
@@ -276,7 +175,6 @@ void spiDetachMOSI(spi_t * spi, int8_t mosi)
         } else {
             mosi = 8;
         }
-#endif
     }
     pinMatrixOutDetach(mosi, false, false);
     pinMode(mosi, INPUT);
@@ -292,14 +190,6 @@ void spiAttachSS(spi_t * spi, uint8_t cs_num, int8_t ss)
     }
     if(ss < 0) {
         cs_num = 0;
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            ss = 34;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             ss = 15;
         } else if(spi->num == VSPI) {
@@ -307,7 +197,6 @@ void spiAttachSS(spi_t * spi, uint8_t cs_num, int8_t ss)
         } else {
             ss = 11;
         }
-#endif
     }
     pinMode(ss, OUTPUT);
     pinMatrixOutAttach(ss, SPI_SS_IDX(spi->num, cs_num), false, false);
@@ -320,14 +209,6 @@ void spiDetachSS(spi_t * spi, int8_t ss)
         return;
     }
     if(ss < 0) {
-#if CONFIG_IDF_TARGET_ESP32S2
-        if(spi->num == FSPI) {
-            ss = 34;
-        } else {
-            log_e("HSPI Does not have default pins on ESP32S2!");
-            return;
-        }
-#else
         if(spi->num == HSPI) {
             ss = 15;
         } else if(spi->num == VSPI) {
@@ -335,7 +216,6 @@ void spiDetachSS(spi_t * spi, int8_t ss)
         } else {
             ss = 11;
         }
-#endif
     }
     pinMatrixOutDetach(ss, false, false);
     pinMode(ss, INPUT);
@@ -347,11 +227,7 @@ void spiEnableSSPins(spi_t * spi, uint8_t cs_mask)
         return;
     }
     SPI_MUTEX_LOCK();
-#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);
-#endif
     SPI_MUTEX_UNLOCK();
 }
 
@@ -361,11 +237,7 @@ void spiDisableSSPins(spi_t * spi, uint8_t cs_mask)
         return;
     }
     SPI_MUTEX_LOCK();
-#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);
-#endif
     SPI_MUTEX_UNLOCK();
 }
 
@@ -397,11 +269,7 @@ void spiSSSet(spi_t * spi)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2
-    spi->dev->misc.cs_keep_active = 1;
-#else
     spi->dev->pin.cs_keep_active = 1;
-#endif
     SPI_MUTEX_UNLOCK();
 }
 
@@ -411,11 +279,7 @@ void spiSSClear(spi_t * spi)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2
-    spi->dev->misc.cs_keep_active = 0;
-#else
     spi->dev->pin.cs_keep_active = 0;
-#endif
     SPI_MUTEX_UNLOCK();
 }
 
@@ -442,11 +306,7 @@ uint8_t spiGetDataMode(spi_t * spi)
     if(!spi) {
         return 0;
     }
-#if CONFIG_IDF_TARGET_ESP32S2
-    bool idleEdge = spi->dev->misc.ck_idle_edge;
-#else
     bool idleEdge = spi->dev->pin.ck_idle_edge;
-#endif
     bool outEdge = spi->dev->user.ck_out_edge;
     if(idleEdge) {
         if(outEdge) {
@@ -468,36 +328,20 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
     SPI_MUTEX_LOCK();
     switch (dataMode) {
     case SPI_MODE1:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 0;
-#else
         spi->dev->pin.ck_idle_edge = 0;
-#endif
         spi->dev->user.ck_out_edge = 1;
         break;
     case SPI_MODE2:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 1;
-#else
         spi->dev->pin.ck_idle_edge = 1;
-#endif
         spi->dev->user.ck_out_edge = 1;
         break;
     case SPI_MODE3:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 1;
-#else
         spi->dev->pin.ck_idle_edge = 1;
-#endif
         spi->dev->user.ck_out_edge = 0;
         break;
     case SPI_MODE0:
     default:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 0;
-#else
         spi->dev->pin.ck_idle_edge = 0;
-#endif
         spi->dev->user.ck_out_edge = 0;
         break;
     }
@@ -544,11 +388,7 @@ static void spiInitBus(spi_t * spi)
 {
     spi->dev->slave.trans_done = 0;
     spi->dev->slave.slave_mode = 0;
-#if CONFIG_IDF_TARGET_ESP32S2
-    spi->dev->misc.val = 0;
-#else
     spi->dev->pin.val = 0;
-#endif
     spi->dev->user.val = 0;
     spi->dev->user1.val = 0;
     spi->dev->ctrl.val = 0;
@@ -562,9 +402,9 @@ void spiStopBus(spi_t * spi)
     if(!spi) {
         return;
     }
-    
+
     removeApbChangeCallback(spi, _on_apb_change);
-    
+
     SPI_MUTEX_LOCK();
     spiInitBus(spi);
     SPI_MUTEX_UNLOCK();
@@ -572,7 +412,7 @@ void spiStopBus(spi_t * spi)
 
 spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_t bitOrder)
 {
-    if(spi_num >= SPI_COUNT){
+    if(spi_num > 3){
         return NULL;
     }
 
@@ -587,18 +427,6 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
     }
 #endif
 
-#if CONFIG_IDF_TARGET_ESP32S2
-    if(spi_num == FSPI) {
-        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);
-    } else if(spi_num == HSPI) {
-        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI3_CLK_EN);
-        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI3_RST);
-    } else {
-        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);
-    }
-#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);
@@ -609,7 +437,6 @@ 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);
     }
-#endif
 
     SPI_MUTEX_LOCK();
     spiInitBus(spi);
@@ -639,11 +466,6 @@ void spiWaitReady(spi_t * spi)
     while(spi->dev->cmd.usr);
 }
 
-#if CONFIG_IDF_TARGET_ESP32S2
-#define usr_mosi_dbitlen usr_mosi_bit_len
-#define usr_miso_dbitlen usr_miso_bit_len
-#endif
-
 void spiWrite(spi_t * spi, const uint32_t *data, uint8_t len)
 {
     if(!spi) {
@@ -897,39 +719,23 @@ void spiTransaction(spi_t * spi, uint32_t clockDiv, uint8_t dataMode, uint8_t bi
     SPI_MUTEX_LOCK();
     spi->dev->clock.val = clockDiv;
     switch (dataMode) {
-    case SPI_MODE1:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 0;
-#else
-        spi->dev->pin.ck_idle_edge = 0;
-#endif
-        spi->dev->user.ck_out_edge = 1;
-        break;
-    case SPI_MODE2:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 1;
-#else
-        spi->dev->pin.ck_idle_edge = 1;
-#endif
-        spi->dev->user.ck_out_edge = 1;
-        break;
-    case SPI_MODE3:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 1;
-#else
-        spi->dev->pin.ck_idle_edge = 1;
-#endif
-        spi->dev->user.ck_out_edge = 0;
-        break;
-    case SPI_MODE0:
-    default:
-#if CONFIG_IDF_TARGET_ESP32S2
-        spi->dev->misc.ck_idle_edge = 0;
-#else
-        spi->dev->pin.ck_idle_edge = 0;
-#endif
-        spi->dev->user.ck_out_edge = 0;
-        break;
+        case SPI_MODE1:
+            spi->dev->pin.ck_idle_edge = 0;
+            spi->dev->user.ck_out_edge = 1;
+            break;
+        case SPI_MODE2:
+            spi->dev->pin.ck_idle_edge = 1;
+            spi->dev->user.ck_out_edge = 1;
+            break;
+        case SPI_MODE3:
+            spi->dev->pin.ck_idle_edge = 1;
+            spi->dev->user.ck_out_edge = 0;
+            break;
+        case SPI_MODE0:
+        default:
+            spi->dev->pin.ck_idle_edge = 0;
+            spi->dev->user.ck_out_edge = 0;
+            break;
     }
     if (SPI_MSBFIRST == bitOrder) {
         spi->dev->ctrl.wr_bit_order = 0;
@@ -956,7 +762,7 @@ void spiEndTransaction(spi_t * spi)
     SPI_MUTEX_UNLOCK();
 }
 
-void ARDUINO_ISR_ATTR spiWriteByteNL(spi_t * spi, uint8_t data)
+void IRAM_ATTR spiWriteByteNL(spi_t * spi, uint8_t data)
 {
     if(!spi) {
         return;
@@ -982,7 +788,7 @@ uint8_t spiTransferByteNL(spi_t * spi, uint8_t data)
     return data;
 }
 
-void ARDUINO_ISR_ATTR spiWriteShortNL(spi_t * spi, uint16_t data)
+void IRAM_ATTR spiWriteShortNL(spi_t * spi, uint16_t data)
 {
     if(!spi) {
         return;
@@ -1017,7 +823,7 @@ uint16_t spiTransferShortNL(spi_t * spi, uint16_t data)
     return data;
 }
 
-void ARDUINO_ISR_ATTR spiWriteLongNL(spi_t * spi, uint32_t data)
+void IRAM_ATTR spiWriteLongNL(spi_t * spi, uint32_t data)
 {
     if(!spi) {
         return;
@@ -1108,8 +914,20 @@ void spiTransferBytesNL(spi_t * spi, const void * data_in, uint8_t * data_out, u
         spi->dev->cmd.usr = 1;
         while(spi->dev->cmd.usr);
         if(result){
-            for (int i=0; i<c_longs; i++) {
-                result[i] = spi->dev->data_buf[i];
+            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 = &result[c_longs-1];
+                uint8_t * last_data8 = &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];
+                }
             }
         }
         if(data){
@@ -1165,7 +983,7 @@ void spiTransferBitsNL(spi_t * spi, uint32_t data, uint32_t * out, uint8_t bits)
     }
 }
 
-void ARDUINO_ISR_ATTR spiWritePixelsNL(spi_t * spi, const void * data_in, uint32_t len){
+void IRAM_ATTR spiWritePixelsNL(spi_t * spi, const void * data_in, uint32_t len){
     size_t longs = len >> 2;
     if(len & 3){
         longs++;

cores/esp32/esp32-hal-spi.h

@@ -19,7 +19,6 @@
 extern "C" {
 #endif
 
-#include "sdkconfig.h"
 #include <stdint.h>
 #include <stdbool.h>
 
@@ -27,9 +26,7 @@ extern "C" {
 
 #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
 
 // This defines are not representing the real Divider of the ESP32
 // the Defines match to an AVR Arduino on 16MHz for better compatibility

cores/esp32/esp32-hal-time.c

@@ -14,8 +14,7 @@
 
 #include "esp32-hal.h"
 #include "lwip/apps/sntp.h"
-//#include "tcpip_adapter.h"
-#include "esp_netif.h"
+#include "tcpip_adapter.h"
 
 static void setTimeZone(long offset, int daylight)
 {
@@ -47,8 +46,7 @@ static void setTimeZone(long offset, int daylight)
  * */
 void configTime(long gmtOffset_sec, int daylightOffset_sec, const char* server1, const char* server2, const char* server3)
 {
-    //tcpip_adapter_init();  // Should not hurt anything if already inited
-    esp_netif_init();
+    tcpip_adapter_init();  // Should not hurt anything if already inited
     if(sntp_enabled()){
         sntp_stop();
     }
@@ -66,8 +64,7 @@ void configTime(long gmtOffset_sec, int daylightOffset_sec, const char* server1,
  * */
 void configTzTime(const char* tz, const char* server1, const char* server2, const char* server3)
 {
-    //tcpip_adapter_init();  // Should not hurt anything if already inited
-    esp_netif_init();
+    tcpip_adapter_init();  // Should not hurt anything if already inited
     if(sntp_enabled()){
         sntp_stop();
     }

cores/esp32/esp32-hal-timer.c

@@ -16,27 +16,11 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/xtensa_api.h"
 #include "freertos/task.h"
+#include "rom/ets_sys.h"
 #include "soc/timer_group_struct.h"
 #include "soc/dport_reg.h"
 #include "esp_attr.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 "esp32/rom/ets_sys.h"
-#include "esp_intr_alloc.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
-#include "esp_intr_alloc.h"
-#include "soc/periph_defs.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/ets_sys.h"
 #include "esp_intr.h"
-#endif
 
 #define HWTIMER_LOCK()      portENTER_CRITICAL(timer->lock)
 #define HWTIMER_UNLOCK()    portEXIT_CRITICAL(timer->lock)
@@ -83,18 +67,11 @@ static hw_timer_t hw_timer[4] = {
 typedef void (*voidFuncPtr)(void);
 static voidFuncPtr __timerInterruptHandlers[4] = {0,0,0,0};
 
-void ARDUINO_ISR_ATTR __timerISR(void * arg){
-#if CONFIG_IDF_TARGET_ESP32
+void IRAM_ATTR __timerISR(void * arg){
     uint32_t s0 = TIMERG0.int_st_timers.val;
     uint32_t s1 = TIMERG1.int_st_timers.val;
     TIMERG0.int_clr_timers.val = s0;
     TIMERG1.int_clr_timers.val = s1;
-#else
-    uint32_t s0 = TIMERG0.int_st.val;
-    uint32_t s1 = TIMERG1.int_st.val;
-    TIMERG0.int_clr.val = s0;
-    TIMERG1.int_clr.val = s1;
-#endif
     uint8_t status = (s1 & 3) << 2 | (s0 & 3);
     uint8_t i = 4;
     //restart the timers that should autoreload
@@ -113,56 +90,56 @@ void ARDUINO_ISR_ATTR __timerISR(void * arg){
     }
 }
 
-uint64_t timerRead(hw_timer_t *timer){
+uint64_t IRAM_ATTR timerRead(hw_timer_t *timer){
     timer->dev->update = 1;
     uint64_t h = timer->dev->cnt_high;
     uint64_t l = timer->dev->cnt_low;
     return (h << 32) | l;
 }
 
-uint64_t timerAlarmRead(hw_timer_t *timer){
+uint64_t IRAM_ATTR timerAlarmRead(hw_timer_t *timer){
     uint64_t h = timer->dev->alarm_high;
     uint64_t l = timer->dev->alarm_low;
     return (h << 32) | l;
 }
 
-void timerWrite(hw_timer_t *timer, uint64_t val){
+void IRAM_ATTR timerWrite(hw_timer_t *timer, uint64_t val){
     timer->dev->load_high = (uint32_t) (val >> 32);
     timer->dev->load_low = (uint32_t) (val);
     timer->dev->reload = 1;
 }
 
-void timerAlarmWrite(hw_timer_t *timer, uint64_t alarm_value, bool autoreload){
+void IRAM_ATTR timerAlarmWrite(hw_timer_t *timer, uint64_t alarm_value, bool autoreload){
     timer->dev->alarm_high = (uint32_t) (alarm_value >> 32);
     timer->dev->alarm_low = (uint32_t) alarm_value;
     timer->dev->config.autoreload = autoreload;
 }
 
-void timerSetConfig(hw_timer_t *timer, uint32_t config){
+void IRAM_ATTR timerSetConfig(hw_timer_t *timer, uint32_t config){
     timer->dev->config.val = config;
 }
 
-uint32_t timerGetConfig(hw_timer_t *timer){
+uint32_t IRAM_ATTR timerGetConfig(hw_timer_t *timer){
     return timer->dev->config.val;
 }
 
-void timerSetCountUp(hw_timer_t *timer, bool countUp){
+void IRAM_ATTR timerSetCountUp(hw_timer_t *timer, bool countUp){
     timer->dev->config.increase = countUp;
 }
 
-bool timerGetCountUp(hw_timer_t *timer){
+bool IRAM_ATTR timerGetCountUp(hw_timer_t *timer){
     return timer->dev->config.increase;
 }
 
-void timerSetAutoReload(hw_timer_t *timer, bool autoreload){
+void IRAM_ATTR timerSetAutoReload(hw_timer_t *timer, bool autoreload){
     timer->dev->config.autoreload = autoreload;
 }
 
-bool timerGetAutoReload(hw_timer_t *timer){
+bool IRAM_ATTR timerGetAutoReload(hw_timer_t *timer){
     return timer->dev->config.autoreload;
 }
 
-void timerSetDivider(hw_timer_t *timer, uint16_t divider){//2 to 65536
+void IRAM_ATTR timerSetDivider(hw_timer_t *timer, uint16_t divider){//2 to 65536
     if(!divider){
         divider = 0xFFFF;
     } else if(divider == 1){
@@ -174,41 +151,41 @@ void timerSetDivider(hw_timer_t *timer, uint16_t divider){//2 to 65536
     timer->dev->config.enable = timer_en;
 }
 
-uint16_t timerGetDivider(hw_timer_t *timer){
+uint16_t IRAM_ATTR timerGetDivider(hw_timer_t *timer){
     return timer->dev->config.divider;
 }
 
-void timerStart(hw_timer_t *timer){
+void IRAM_ATTR timerStart(hw_timer_t *timer){
     timer->dev->config.enable = 1;
 }
 
-void timerStop(hw_timer_t *timer){
+void IRAM_ATTR timerStop(hw_timer_t *timer){
     timer->dev->config.enable = 0;
 }
 
-void timerRestart(hw_timer_t *timer){
+void IRAM_ATTR timerRestart(hw_timer_t *timer){
     timer->dev->config.enable = 0;
     timer->dev->reload = 1;
     timer->dev->config.enable = 1;
 }
 
-bool timerStarted(hw_timer_t *timer){
+bool IRAM_ATTR timerStarted(hw_timer_t *timer){
     return timer->dev->config.enable;
 }
 
-void timerAlarmEnable(hw_timer_t *timer){
+void IRAM_ATTR timerAlarmEnable(hw_timer_t *timer){
     timer->dev->config.alarm_en = 1;
 }
 
-void timerAlarmDisable(hw_timer_t *timer){
+void IRAM_ATTR timerAlarmDisable(hw_timer_t *timer){
     timer->dev->config.alarm_en = 0;
 }
 
-bool timerAlarmEnabled(hw_timer_t *timer){
+bool IRAM_ATTR timerAlarmEnabled(hw_timer_t *timer){
     return timer->dev->config.alarm_en;
 }
 
-static void _on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb){
+static void IRAM_ATTR _on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb){
     hw_timer_t * timer = (hw_timer_t *)arg;
     if(ev_type == APB_BEFORE_CHANGE){
         timer->dev->config.enable = 0;
@@ -220,35 +197,21 @@ static void _on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb
     }
 }
 
-hw_timer_t * timerBegin(uint8_t num, uint16_t divider, bool countUp){
+hw_timer_t * IRAM_ATTR timerBegin(uint8_t num, uint16_t divider, bool countUp){
     if(num > 3){
         return NULL;
     }
     hw_timer_t * timer = &hw_timer[num];
     if(timer->group) {
-    	periph_module_enable(PERIPH_TIMG1_MODULE);
+        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_TIMERGROUP1_CLK_EN);
+        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_TIMERGROUP1_RST);
+        TIMERG1.int_ena.val &= ~BIT(timer->timer);
     } else {
-    	periph_module_enable(PERIPH_TIMG0_MODULE);
+        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_TIMERGROUP_CLK_EN);
+        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_TIMERGROUP_RST);
+        TIMERG0.int_ena.val &= ~BIT(timer->timer);
     }
     timer->dev->config.enable = 0;
-    if(timer->group) {
-        TIMERG1.int_ena.val &= ~BIT(timer->timer);
-#if CONFIG_IDF_TARGET_ESP32
-            TIMERG1.int_clr_timers.val |= BIT(timer->timer);
-#else
-            TIMERG1.int_clr.val = BIT(timer->timer);
-#endif
-    } else {
-        TIMERG0.int_ena.val &= ~BIT(timer->timer);
-#if CONFIG_IDF_TARGET_ESP32
-            TIMERG0.int_clr_timers.val |= BIT(timer->timer);
-#else
-            TIMERG0.int_clr.val = BIT(timer->timer);
-#endif
-    }
-#ifdef TIMER_GROUP_SUPPORTS_XTAL_CLOCK
-    timer->dev->config.use_xtal = 0;
-#endif
     timerSetDivider(timer, divider);
     timerSetCountUp(timer, countUp);
     timerSetAutoReload(timer, false);
@@ -259,16 +222,13 @@ hw_timer_t * timerBegin(uint8_t num, uint16_t divider, bool countUp){
     return timer;
 }
 
-void timerEnd(hw_timer_t *timer){
+void IRAM_ATTR timerEnd(hw_timer_t *timer){
     timer->dev->config.enable = 0;
     timerAttachInterrupt(timer, NULL, false);
     removeApbChangeCallback(timer, _on_apb_change);
 }
 
-void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
-	// EDGE DOES NOT WORK CURRENTLY
-	edge = false;
-
+void IRAM_ATTR timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
     static bool initialized = false;
     static intr_handle_t intr_handle = NULL;
     if(intr_handle){
@@ -280,18 +240,8 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
         timer->dev->config.alarm_en = 0;
         if(timer->num & 2){
             TIMERG1.int_ena.val &= ~BIT(timer->timer);
-#if CONFIG_IDF_TARGET_ESP32
-            TIMERG1.int_clr_timers.val |= BIT(timer->timer);
-#else
-            TIMERG1.int_clr.val = BIT(timer->timer);
-#endif
         } else {
             TIMERG0.int_ena.val &= ~BIT(timer->timer);
-#if CONFIG_IDF_TARGET_ESP32
-            TIMERG0.int_clr_timers.val |= BIT(timer->timer);
-#else
-            TIMERG0.int_clr.val = BIT(timer->timer);
-#endif
         }
         __timerInterruptHandlers[timer->num] = NULL;
     } else {
@@ -314,7 +264,7 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
         }
         if(!initialized){
             initialized = true;
-            esp_intr_alloc(intr_source, (int)(ARDUINO_ISR_FLAG|ESP_INTR_FLAG_LOWMED), __timerISR, NULL, &intr_handle);
+            esp_intr_alloc(intr_source, (int)(ESP_INTR_FLAG_IRAM|ESP_INTR_FLAG_LOWMED|ESP_INTR_FLAG_EDGE), __timerISR, NULL, &intr_handle);
         } else {
             intr_matrix_set(esp_intr_get_cpu(intr_handle), intr_source, esp_intr_get_intno(intr_handle));
         }
@@ -329,29 +279,29 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
     }
 }
 
-void timerDetachInterrupt(hw_timer_t *timer){
+void IRAM_ATTR timerDetachInterrupt(hw_timer_t *timer){
     timerAttachInterrupt(timer, NULL, false);
 }
 
-uint64_t timerReadMicros(hw_timer_t *timer){
+uint64_t IRAM_ATTR timerReadMicros(hw_timer_t *timer){
     uint64_t timer_val = timerRead(timer);
     uint16_t div = timerGetDivider(timer);
     return timer_val * div / (getApbFrequency() / 1000000);
 }
 
-double timerReadSeconds(hw_timer_t *timer){
+double IRAM_ATTR timerReadSeconds(hw_timer_t *timer){
     uint64_t timer_val = timerRead(timer);
     uint16_t div = timerGetDivider(timer);
     return (double)timer_val * div / getApbFrequency();
 }
 
-uint64_t timerAlarmReadMicros(hw_timer_t *timer){
+uint64_t IRAM_ATTR timerAlarmReadMicros(hw_timer_t *timer){
     uint64_t timer_val = timerAlarmRead(timer);
     uint16_t div = timerGetDivider(timer);
     return timer_val * div / (getApbFrequency() / 1000000);
 }
 
-double timerAlarmReadSeconds(hw_timer_t *timer){
+double IRAM_ATTR timerAlarmReadSeconds(hw_timer_t *timer){
     uint64_t timer_val = timerAlarmRead(timer);
     uint16_t div = timerGetDivider(timer);
     return (double)timer_val * div / getApbFrequency();

cores/esp32/esp32-hal-tinyusb.c

@@ -1,697 +0,0 @@
-
-#include "sdkconfig.h"
-#if CONFIG_USB_ENABLED
-#include <stdlib.h>
-
-#include "esp_log.h"
-
-#include "soc/soc.h"
-#include "soc/efuse_reg.h"
-#include "soc/rtc_cntl_reg.h"
-#include "soc/usb_struct.h"
-#include "soc/usb_reg.h"
-#include "soc/usb_wrap_reg.h"
-#include "soc/usb_wrap_struct.h"
-#include "soc/periph_defs.h"
-#include "soc/timer_group_struct.h"
-#include "soc/system_reg.h"
-
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-
-#include "driver/gpio.h"
-#include "driver/periph_ctrl.h"
-
-#include "esp_efuse.h"
-#include "esp_efuse_table.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 char tusb_str_t[127];
-
-static bool WEBUSB_ENABLED                = false;
-
-static tusb_str_t WEBUSB_URL              = "";
-static tusb_str_t USB_DEVICE_PRODUCT      = "";
-static tusb_str_t USB_DEVICE_MANUFACTURER = "";
-static tusb_str_t USB_DEVICE_SERIAL       = "";
-
-static uint8_t USB_DEVICE_ATTRIBUTES     = 0;
-static uint16_t USB_DEVICE_POWER         = 0;
-
-/*
- * Device Descriptor
- * */
-static tusb_desc_device_t tinyusb_device_descriptor = {
-        .bLength = sizeof(tusb_desc_device_t),
-        .bDescriptorType = TUSB_DESC_DEVICE,
-        .bcdUSB = 0,
-        .bDeviceClass = 0,
-        .bDeviceSubClass = 0,
-        .bDeviceProtocol = 0,
-        .bMaxPacketSize0 = CFG_TUD_ENDOINT0_SIZE,
-
-        .idVendor = 0,
-        .idProduct = 0,
-        .bcdDevice = 0,
-
-        .iManufacturer = 0x01,
-        .iProduct = 0x02,
-        .iSerialNumber = 0x03,
-
-        .bNumConfigurations = 0x01
-};
-
-/*
- * String Descriptors
- * */
-#define MAX_STRING_DESCRIPTORS 20
-static uint32_t tinyusb_string_descriptor_len = 4;
-static char * tinyusb_string_descriptor[MAX_STRING_DESCRIPTORS] = {
-        // array of pointer to string descriptors
-        "\x09\x04",   // 0: is supported language is English (0x0409)
-        USB_DEVICE_MANUFACTURER,// 1: Manufacturer
-        USB_DEVICE_PRODUCT,     // 2: Product
-        USB_DEVICE_SERIAL,      // 3: Serials, should use chip ID
-};
-
-
-/* Microsoft OS 2.0 registry property descriptor
-Per MS requirements https://msdn.microsoft.com/en-us/library/windows/hardware/hh450799(v=vs.85).aspx
-device should create DeviceInterfaceGUIDs. It can be done by driver and
-in case of real PnP solution device should expose MS "Microsoft OS 2.0
-registry property descriptor". Such descriptor can insert any record
-into Windows registry per device/configuration/interface. In our case it
-will insert "DeviceInterfaceGUIDs" multistring property.
-
-GUID is freshly generated and should be OK to use.
-
-https://developers.google.com/web/fundamentals/native-hardware/build-for-webusb/
-(Section Microsoft OS compatibility descriptors)
- */
-
-#define MS_OS_20_DESC_LEN  0xB2
-
-static uint8_t const tinyusb_ms_os_20_descriptor[] =
-{
-        // Set header: length, type, windows version, total length
-        U16_TO_U8S_LE(0x000A), U16_TO_U8S_LE(MS_OS_20_SET_HEADER_DESCRIPTOR), U32_TO_U8S_LE(0x06030000), U16_TO_U8S_LE(MS_OS_20_DESC_LEN),
-
-        // Configuration subset header: length, type, configuration index, reserved, configuration total length
-        U16_TO_U8S_LE(0x0008), U16_TO_U8S_LE(MS_OS_20_SUBSET_HEADER_CONFIGURATION), 0, 0, U16_TO_U8S_LE(MS_OS_20_DESC_LEN-0x0A),
-
-        // Function Subset header: length, type, first interface, reserved, subset length
-        U16_TO_U8S_LE(0x0008), U16_TO_U8S_LE(MS_OS_20_SUBSET_HEADER_FUNCTION), 0, 0, U16_TO_U8S_LE(MS_OS_20_DESC_LEN-0x0A-0x08),
-
-        // MS OS 2.0 Compatible ID descriptor: length, type, compatible ID, sub compatible ID
-        U16_TO_U8S_LE(0x0014), U16_TO_U8S_LE(MS_OS_20_FEATURE_COMPATBLE_ID), 'W', 'I', 'N', 'U', 'S', 'B', 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // sub-compatible
-
-        // MS OS 2.0 Registry property descriptor: length, type
-        U16_TO_U8S_LE(MS_OS_20_DESC_LEN-0x0A-0x08-0x08-0x14), U16_TO_U8S_LE(MS_OS_20_FEATURE_REG_PROPERTY),
-        U16_TO_U8S_LE(0x0007), U16_TO_U8S_LE(0x002A), // wPropertyDataType, wPropertyNameLength and PropertyName "DeviceInterfaceGUIDs\0" in UTF-16
-        'D', 0x00, 'e', 0x00, 'v', 0x00, 'i', 0x00, 'c', 0x00, 'e', 0x00, 'I', 0x00, 'n', 0x00, 't', 0x00, 'e', 0x00,
-        'r', 0x00, 'f', 0x00, 'a', 0x00, 'c', 0x00, 'e', 0x00, 'G', 0x00, 'U', 0x00, 'I', 0x00, 'D', 0x00, 's', 0x00, 0x00, 0x00,
-        U16_TO_U8S_LE(0x0050), // wPropertyDataLength
-        //bPropertyData: “{975F44D9-0D08-43FD-8B3E-127CA8AFFF9D}”.
-        '{', 0x00, '9', 0x00, '7', 0x00, '5', 0x00, 'F', 0x00, '4', 0x00, '4', 0x00, 'D', 0x00, '9', 0x00, '-', 0x00,
-        '0', 0x00, 'D', 0x00, '0', 0x00, '8', 0x00, '-', 0x00, '4', 0x00, '3', 0x00, 'F', 0x00, 'D', 0x00, '-', 0x00,
-        '8', 0x00, 'B', 0x00, '3', 0x00, 'E', 0x00, '-', 0x00, '1', 0x00, '2', 0x00, '7', 0x00, 'C', 0x00, 'A', 0x00,
-        '8', 0x00, 'A', 0x00, 'F', 0x00, 'F', 0x00, 'F', 0x00, '9', 0x00, 'D', 0x00, '}', 0x00, 0x00, 0x00, 0x00, 0x00
-};
-
-TU_VERIFY_STATIC(sizeof(tinyusb_ms_os_20_descriptor) == MS_OS_20_DESC_LEN, "Incorrect size");
-
-
-/*
- * BOS Descriptor (required for webUSB)
- * */
-#define BOS_TOTAL_LEN      (TUD_BOS_DESC_LEN + TUD_BOS_WEBUSB_DESC_LEN + TUD_BOS_MICROSOFT_OS_DESC_LEN)
-
-enum {
-    VENDOR_REQUEST_WEBUSB = 1,
-    VENDOR_REQUEST_MICROSOFT = 2
-};
-
-static uint8_t const tinyusb_bos_descriptor[] = {
-        // total length, number of device caps
-        TUD_BOS_DESCRIPTOR(BOS_TOTAL_LEN, 2),
-
-        // Vendor Code, iLandingPage
-        TUD_BOS_WEBUSB_DESCRIPTOR(VENDOR_REQUEST_WEBUSB, 1),
-
-        // Microsoft OS 2.0 descriptor
-        TUD_BOS_MS_OS_20_DESCRIPTOR(MS_OS_20_DESC_LEN, VENDOR_REQUEST_MICROSOFT)
-};
-
-/*
- * URL Descriptor (required for webUSB)
- * */
-typedef struct TU_ATTR_PACKED {
-  uint8_t bLength;
-  uint8_t bDescriptorType;
-  uint8_t bScheme;
-  char    url[127];
-} tinyusb_desc_webusb_url_t;
-
-static tinyusb_desc_webusb_url_t tinyusb_url_descriptor = {
-        .bLength         = 3,
-        .bDescriptorType = 3, // WEBUSB URL type
-        .bScheme         = 1, // URL Scheme Prefix: 0: "http://", 1: "https://", 255: ""
-        .url             = ""
-};
-
-/*
- * Configuration Descriptor
- * */
-
-static tinyusb_descriptor_cb_t tinyusb_loaded_interfaces_callbacks[USB_INTERFACE_MAX];
-static uint32_t tinyusb_loaded_interfaces_mask = 0;
-static uint8_t tinyusb_loaded_interfaces_num = 0;
-static uint16_t tinyusb_config_descriptor_len = 0;
-static uint8_t * tinyusb_config_descriptor = NULL;
-
-/*
- * Endpoint Usage Tracking
- * */
-typedef union {
-        struct {
-                uint32_t in:16;
-                uint32_t out:16;
-        };
-        uint32_t val;
-} tinyusb_endpoints_usage_t;
-
-static tinyusb_endpoints_usage_t tinyusb_endpoints;
-
-
-/*
- * TinyUSB Callbacks
- * */
-
-/**
- * @brief Invoked when received GET CONFIGURATION DESCRIPTOR.
- */
-uint8_t const *tud_descriptor_configuration_cb(uint8_t index)
-{
-    //log_d("%u", index);
-    return tinyusb_config_descriptor;
-}
-
-/**
- * @brief Invoked when received GET DEVICE DESCRIPTOR.
- */
-uint8_t const *tud_descriptor_device_cb(void)
-{
-    //log_d("");
-    return (uint8_t const *)&tinyusb_device_descriptor;
-}
-
-/**
- * @brief Invoked when received GET STRING DESCRIPTOR request.
- */
-uint16_t const *tud_descriptor_string_cb(uint8_t index, uint16_t langid)
-{
-    //log_d("%u (0x%x)", index, langid);
-    static uint16_t _desc_str[127];
-    uint8_t chr_count;
-
-    if (index == 0) {
-        memcpy(&_desc_str[1], tinyusb_string_descriptor[0], 2);
-        chr_count = 1;
-    } else {
-        // Convert ASCII string into UTF-16
-        if (index >= tinyusb_string_descriptor_len) {
-            return NULL;
-        }
-        const char *str = tinyusb_string_descriptor[index];
-        // Cap at max char
-        chr_count = strlen(str);
-        if (chr_count > 126) {
-            chr_count = 126;
-        }
-        for (uint8_t i = 0; i < chr_count; i++) {
-            _desc_str[1 + i] = str[i];
-        }
-    }
-
-    // first byte is len, second byte is string type
-    _desc_str[0] = (TUSB_DESC_STRING << 8 ) | (2*chr_count + 2);
-
-    return _desc_str;
-}
-
-/**
- * @brief Invoked when received GET BOS DESCRIPTOR request.
- */
-uint8_t const * tud_descriptor_bos_cb(void)
-{
-    //log_d("");
-    return tinyusb_bos_descriptor;
-}
-
-__attribute__ ((weak)) bool tinyusb_vendor_control_request_cb(uint8_t rhport, tusb_control_request_t const * request){ return false; }
-__attribute__ ((weak)) bool tinyusb_vendor_control_complete_cb(uint8_t rhport, tusb_control_request_t const * request){ return true; }
-
-/**
- * @brief Handle WebUSB and Vendor requests.
- */
-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))){
-        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);
-    }
-    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(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;}
-__attribute__ ((weak)) void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t product_id[16], uint8_t product_rev[4]){}
-__attribute__ ((weak)) void tud_msc_capacity_cb(uint8_t lun, uint32_t* block_count, uint16_t* block_size){}
-__attribute__ ((weak)) int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba, uint32_t offset, void* buffer, uint32_t bufsize){return -1;}
-__attribute__ ((weak)) int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_t bufsize){return -1;}
-__attribute__ ((weak)) int32_t tud_msc_scsi_cb (uint8_t lun, uint8_t const scsi_cmd[16], void* buffer, uint16_t bufsize){return -1;}
-#endif
-
-
-/*
- * Private API
- * */
-static bool usb_persist_enabled = false;
-static restart_type_t usb_persist_mode = RESTART_NO_PERSIST;
-
-static bool tinyusb_reserve_in_endpoint(uint8_t endpoint){
-    if(endpoint > 6 || (tinyusb_endpoints.in & BIT(endpoint)) != 0){
-        return false;
-    }
-    tinyusb_endpoints.in |= BIT(endpoint);
-    return true;
-}
-
-static bool tinyusb_reserve_out_endpoint(uint8_t endpoint){
-    if(endpoint > 6 || (tinyusb_endpoints.out & BIT(endpoint)) != 0){
-        return false;
-    }
-    tinyusb_endpoints.out |= BIT(endpoint);
-    return true;
-}
-
-static bool tinyusb_has_available_fifos(void){
-    uint8_t max_endpoints = 4, active_endpoints = 0;
-    if (tinyusb_loaded_interfaces_mask & BIT(USB_INTERFACE_CDC)) {
-        max_endpoints = 5; //CDC endpoint 0x85 is actually not linked to FIFO and not used
-    }
-    for(uint8_t i=1; i<7; i++){
-        if((tinyusb_endpoints.in & BIT(i)) != 0){
-            active_endpoints++;
-        }
-    }
-
-    return active_endpoints < max_endpoints;
-}
-
-static uint16_t tinyusb_load_descriptor(tinyusb_interface_t interface, uint8_t * dst, uint8_t * itf)
-{
-    if(tinyusb_loaded_interfaces_callbacks[interface]){
-        return tinyusb_loaded_interfaces_callbacks[interface](dst, itf);
-    }
-    return 0;
-}
-
-static bool tinyusb_load_enabled_interfaces(){
-    tinyusb_config_descriptor_len += TUD_CONFIG_DESC_LEN;
-    tinyusb_config_descriptor = (uint8_t *)malloc(tinyusb_config_descriptor_len);
-    if (tinyusb_config_descriptor == NULL) {
-        log_e("Descriptor Malloc Failed");
-        return false;
-    }
-    uint8_t * dst = tinyusb_config_descriptor + TUD_CONFIG_DESC_LEN;
-
-    for(int i=0; i<USB_INTERFACE_MAX; i++){
-        if (tinyusb_loaded_interfaces_mask & (1U << i)) {
-            uint16_t len = tinyusb_load_descriptor((tinyusb_interface_t)i, dst, &tinyusb_loaded_interfaces_num);
-            if (!len) {
-                log_e("Descriptor Load Failed");
-                return false;
-            } else {
-                if(i == USB_INTERFACE_CDC){
-                    if(!tinyusb_reserve_out_endpoint(3) ||!tinyusb_reserve_in_endpoint(4) || !tinyusb_reserve_in_endpoint(5)){
-                        log_e("CDC Reserve Endpoints Failed");
-                        return false;
-                    }
-                }
-                dst += len;
-            }
-        }
-    }
-    uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB Device");
-    uint8_t descriptor[TUD_CONFIG_DESC_LEN] = {
-            //num configs, interface count, string index, total length, attribute, power in mA
-            TUD_CONFIG_DESCRIPTOR(1, tinyusb_loaded_interfaces_num, str_index, tinyusb_config_descriptor_len, USB_DEVICE_ATTRIBUTES, USB_DEVICE_POWER)
-    };
-    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");
-    }
-    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;
-}
-
-static inline char nibble_to_hex_char(uint8_t b)
-{
-    if (b < 0xa) {
-        return '0' + b;
-    } else {
-        return 'a' + b - 0xa;
-    }
-}
-
-static void set_usb_serial_num(void)
-{
-    /* Get the MAC address */
-    const uint32_t mac0 = REG_GET_FIELD(EFUSE_RD_MAC_SPI_SYS_0_REG, EFUSE_MAC_0);
-    const uint32_t mac1 = REG_GET_FIELD(EFUSE_RD_MAC_SPI_SYS_1_REG, EFUSE_MAC_1);
-    uint8_t mac_bytes[6];
-    memcpy(mac_bytes, &mac0, 4);
-    memcpy(mac_bytes + 4, &mac1, 2);
-
-    /* Convert to UTF16 string */
-    uint8_t* srl = (uint8_t*)USB_DEVICE_SERIAL;
-    for (int i = 0; i < 6; ++i) {
-        uint8_t b = mac_bytes[5 - i]; /* printing from the MSB */
-        if (i) {
-            *srl++ = ':';
-        }
-        *srl++ = nibble_to_hex_char(b >> 4);
-        *srl++ = nibble_to_hex_char(b & 0xf);
-    }
-    *srl++ = '\0';
-}
-
-static void tinyusb_apply_device_config(tinyusb_device_config_t *config){
-    if(config->product_name){
-        snprintf(USB_DEVICE_PRODUCT, 126, "%s", config->product_name);
-    }
-    
-    if(config->manufacturer_name){
-        snprintf(USB_DEVICE_MANUFACTURER, 126, "%s", config->manufacturer_name);
-    }
-    
-    if(config->serial_number && config->serial_number[0]){
-        snprintf(USB_DEVICE_SERIAL, 126, "%s", config->serial_number);
-    } else {
-        set_usb_serial_num();
-    }
-    
-    if(config->webusb_url){
-        snprintf(WEBUSB_URL, 126, "%s", config->webusb_url);
-    }
-
-    WEBUSB_ENABLED            = config->webusb_enabled;
-    USB_DEVICE_ATTRIBUTES     = config->usb_attributes;
-    USB_DEVICE_POWER          = config->usb_power_ma;
-    
-    tinyusb_device_descriptor.bcdUSB = config->usb_version;
-    tinyusb_device_descriptor.idVendor = config->vid;
-    tinyusb_device_descriptor.idProduct = config->pid;
-    tinyusb_device_descriptor.bcdDevice = config->fw_version;
-    tinyusb_device_descriptor.bDeviceClass = config->usb_class;
-    tinyusb_device_descriptor.bDeviceSubClass = config->usb_subclass;
-    tinyusb_device_descriptor.bDeviceProtocol = config->usb_protocol;
-}
-
-static void IRAM_ATTR usb_persist_shutdown_handler(void)
-{
-    if(usb_persist_mode != RESTART_NO_PERSIST){
-        if (usb_persist_enabled) {
-            usb_dc_prepare_persist();
-        }
-        if (usb_persist_mode == RESTART_BOOTLOADER) {
-            //USB CDC Download
-            if (usb_persist_enabled) {
-                chip_usb_set_persist_flags(USBDC_PERSIST_ENA);
-            }
-            REG_WRITE(RTC_CNTL_OPTION1_REG, RTC_CNTL_FORCE_DOWNLOAD_BOOT);
-        } else if (usb_persist_mode == RESTART_BOOTLOADER_DFU) {
-            //DFU Download
-            chip_usb_set_persist_flags(USBDC_BOOT_DFU);
-            REG_WRITE(RTC_CNTL_OPTION1_REG, RTC_CNTL_FORCE_DOWNLOAD_BOOT);
-        } else if (usb_persist_enabled) {
-            //USB Persist reboot
-            chip_usb_set_persist_flags(USBDC_PERSIST_ENA);
-        }
-    }
-}
-
-// USB Device Driver task
-// This top level thread processes all usb events and invokes callbacks
-static void usb_device_task(void *param) {
-    (void)param;
-    while(1) tud_task(); // RTOS forever loop
-}
-
-/*
- * PUBLIC API
- * */
-
-esp_err_t tinyusb_enable_interface(tinyusb_interface_t interface, uint16_t descriptor_len, tinyusb_descriptor_cb_t cb)
-{
-    if((interface >= USB_INTERFACE_MAX) || (tinyusb_loaded_interfaces_mask & (1U << interface))){
-        log_e("Interface %u not enabled", interface);
-        return ESP_FAIL;
-    }
-    tinyusb_loaded_interfaces_mask |= (1U << interface);
-    tinyusb_config_descriptor_len += descriptor_len;
-    tinyusb_loaded_interfaces_callbacks[interface] = cb;
-    log_d("Interface %u enabled", interface);
-    return ESP_OK;
-}
-
-esp_err_t tinyusb_init(tinyusb_device_config_t *config) {
-    static bool initialized = false;
-    if(initialized){
-        return ESP_OK;
-    }
-    initialized = true;
-    
-    tinyusb_endpoints.val = 0;
-    tinyusb_apply_device_config(config);
-    if (!tinyusb_load_enabled_interfaces()) {
-        initialized = false;
-        return ESP_FAIL;
-    }
-
-    bool usb_did_persist = (USB_WRAP.date.val == USBDC_PERSIST_ENA);
-
-    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 {
-        // 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) {
-        initialized = false;
-        return ESP_FAIL;
-    }
-
-    tinyusb_config_t tusb_cfg = {
-            .external_phy = false // In the most cases you need to use a `false` value
-    };
-    esp_err_t err = tinyusb_driver_install(&tusb_cfg);
-    if (err != ESP_OK) {
-        initialized = false;
-        return err;
-    }
-    xTaskCreate(usb_device_task, "usbd", 4096, NULL, configMAX_PRIORITIES - 1, NULL);
-    return err;
-}
-
-void usb_persist_restart(restart_type_t mode)
-{
-    if (mode < RESTART_TYPE_MAX) {
-        usb_persist_mode = mode;
-        esp_restart();
-    }
-}
-
-uint8_t tinyusb_add_string_descriptor(const char * str){
-    if(str == NULL || tinyusb_string_descriptor_len >= MAX_STRING_DESCRIPTORS){
-        return 0;
-    }
-    uint8_t index = tinyusb_string_descriptor_len;
-    tinyusb_string_descriptor[tinyusb_string_descriptor_len++] = (char*)str;
-    return index;
-}
-
-uint8_t tinyusb_get_free_duplex_endpoint(void){
-    if(!tinyusb_has_available_fifos()){
-        log_e("No available IN endpoints");
-        return 0;
-    }
-    for(uint8_t i=1; i<7; i++){
-        if((tinyusb_endpoints.in & BIT(i)) == 0 && (tinyusb_endpoints.out & BIT(i)) == 0){
-            tinyusb_endpoints.in |= BIT(i);
-            tinyusb_endpoints.out |= BIT(i);
-            return i;
-        }
-    }
-    log_e("No available duplex endpoints");
-    return 0;
-}
-
-uint8_t tinyusb_get_free_in_endpoint(void){
-    if(!tinyusb_has_available_fifos()){
-        log_e("No available IN endpoints");
-        return 0;
-    }
-    for(uint8_t i=1; i<7; i++){
-        if((tinyusb_endpoints.in & BIT(i)) == 0 && (tinyusb_endpoints.out & BIT(i)) != 0){
-            tinyusb_endpoints.in |= BIT(i);
-            return i;
-        }
-    }
-    for(uint8_t i=1; i<7; i++){
-        if((tinyusb_endpoints.in & BIT(i)) == 0){
-            tinyusb_endpoints.in |= BIT(i);
-            return i;
-        }
-    }
-    return 0;
-}
-
-uint8_t tinyusb_get_free_out_endpoint(void){
-    for(uint8_t i=1; i<7; i++){
-        if((tinyusb_endpoints.out & BIT(i)) == 0 && (tinyusb_endpoints.in & BIT(i)) != 0){
-            tinyusb_endpoints.out |= BIT(i);
-            return i;
-        }
-    }
-    for(uint8_t i=1; i<7; i++){
-        if((tinyusb_endpoints.out & BIT(i)) == 0){
-            tinyusb_endpoints.out |= BIT(i);
-            return i;
-        }
-    }
-    return 0;
-}
-
-/*
-void usb_dw_reg_dump(void)
-{
-#define USB_PRINT_REG(r) printf("USB0." #r " = 0x%x;\n", USB0.r)
-#define USB_PRINT_IREG(i, r) printf("USB0.in_ep_reg[%u]." #r " = 0x%x;\n", i, USB0.in_ep_reg[i].r)
-#define USB_PRINT_OREG(i, r) printf("USB0.out_ep_reg[%u]." #r " = 0x%x;\n", i, USB0.out_ep_reg[i].r)
-    uint8_t i;
-    USB_PRINT_REG(gotgctl);
-    USB_PRINT_REG(gotgint);
-    USB_PRINT_REG(gahbcfg);
-    USB_PRINT_REG(gusbcfg);
-    USB_PRINT_REG(grstctl);
-    USB_PRINT_REG(gintsts);
-    USB_PRINT_REG(gintmsk);
-    USB_PRINT_REG(grxstsr);
-    USB_PRINT_REG(grxstsp);
-    USB_PRINT_REG(grxfsiz);
-    USB_PRINT_REG(gnptxsts);
-    USB_PRINT_REG(gpvndctl);
-    USB_PRINT_REG(ggpio);
-    USB_PRINT_REG(guid);
-    USB_PRINT_REG(gsnpsid);
-    USB_PRINT_REG(ghwcfg1);
-    USB_PRINT_REG(ghwcfg2);
-    USB_PRINT_REG(ghwcfg3);
-    USB_PRINT_REG(ghwcfg4);
-    USB_PRINT_REG(glpmcfg);
-    USB_PRINT_REG(gpwrdn);
-    USB_PRINT_REG(gdfifocfg);
-    USB_PRINT_REG(gadpctl);
-    USB_PRINT_REG(hptxfsiz);
-    USB_PRINT_REG(hcfg);
-    USB_PRINT_REG(hfir);
-    USB_PRINT_REG(hfnum);
-    USB_PRINT_REG(hptxsts);
-    USB_PRINT_REG(haint);
-    USB_PRINT_REG(haintmsk);
-    USB_PRINT_REG(hflbaddr);
-    USB_PRINT_REG(hprt);
-    USB_PRINT_REG(dcfg);
-    USB_PRINT_REG(dctl);
-    USB_PRINT_REG(dsts);
-    USB_PRINT_REG(diepmsk);
-    USB_PRINT_REG(doepmsk);
-    USB_PRINT_REG(daint);
-    USB_PRINT_REG(daintmsk);
-    USB_PRINT_REG(dtknqr1);
-    USB_PRINT_REG(dtknqr2);
-    USB_PRINT_REG(dvbusdis);
-    USB_PRINT_REG(dvbuspulse);
-    USB_PRINT_REG(dtknqr3_dthrctl);
-    USB_PRINT_REG(dtknqr4_fifoemptymsk);
-    USB_PRINT_REG(deachint);
-    USB_PRINT_REG(deachintmsk);
-    USB_PRINT_REG(pcgctrl);
-    USB_PRINT_REG(pcgctrl1);
-    USB_PRINT_REG(gnptxfsiz);
-    for (i = 0; i < 4; i++) {
-        printf("USB0.dieptxf[%u] = 0x%x;\n", i, USB0.dieptxf[i]);
-    }
-//    for (i = 0; i < 16; i++) {
-//        printf("USB0.diepeachintmsk[%u] = 0x%x;\n", i, USB0.diepeachintmsk[i]);
-//    }
-//    for (i = 0; i < 16; i++) {
-//        printf("USB0.doepeachintmsk[%u] = 0x%x;\n", i, USB0.doepeachintmsk[i]);
-//    }
-    for (i = 0; i < 7; i++) {
-        printf("// EP %u:\n", i);
-        USB_PRINT_IREG(i, diepctl);
-        USB_PRINT_IREG(i, diepint);
-        USB_PRINT_IREG(i, dieptsiz);
-        USB_PRINT_IREG(i, diepdma);
-        USB_PRINT_IREG(i, dtxfsts);
-        USB_PRINT_OREG(i, doepctl);
-        USB_PRINT_OREG(i, doepint);
-        USB_PRINT_OREG(i, doeptsiz);
-        USB_PRINT_OREG(i, doepdma);
-    }
-}
- */
-#endif /* CONFIG_USB_ENABLED */

cores/esp32/esp32-hal-tinyusb.h

@@ -1,103 +0,0 @@
-// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#pragma once
-
-#include "esp32-hal.h"
-
-#if CONFIG_IDF_TARGET_ESP32S2
-#if CONFIG_USB_ENABLED
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "tinyusb.h"
-
-typedef struct {
-        uint16_t vid;
-        uint16_t pid;
-        const char * product_name;
-        const char * manufacturer_name;
-        const char * serial_number;
-        uint16_t fw_version;
-        
-        uint16_t usb_version;
-        uint8_t usb_class;
-        uint8_t usb_subclass;
-        uint8_t usb_protocol;
-        uint8_t usb_attributes;
-        uint16_t usb_power_ma;
-        
-        bool webusb_enabled;
-        const char * webusb_url;
-} tinyusb_device_config_t;
-
-#define TINYUSB_CONFIG_DEFAULT() {                                      \
-        .vid = USB_ESPRESSIF_VID,                                       \
-        .pid = 0x0002,                                                  \
-        .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,                           \
-        .usb_protocol = MISC_PROTOCOL_IAD,                              \
-        .usb_attributes = TUSB_DESC_CONFIG_ATT_SELF_POWERED,            \
-        .usb_power_ma = 500,                                            \
-        .webusb_enabled = false,                                        \
-        .webusb_url = "espressif.github.io/arduino-esp32/webusb.html"   \
-}
-
-esp_err_t tinyusb_init(tinyusb_device_config_t *config);
-
-/*
- * USB Persistence API
- * */
-typedef enum {
-    RESTART_NO_PERSIST,
-    RESTART_PERSIST,
-    RESTART_BOOTLOADER,
-    RESTART_BOOTLOADER_DFU,
-    RESTART_TYPE_MAX
-} restart_type_t;
-
-void usb_persist_restart(restart_type_t mode);
-
-// The following definitions and functions are to be used only by the drivers
-typedef enum {
-    USB_INTERFACE_CDC,
-    USB_INTERFACE_DFU,
-    USB_INTERFACE_HID,
-    USB_INTERFACE_VENDOR,
-    USB_INTERFACE_MSC,
-    USB_INTERFACE_MIDI,
-    USB_INTERFACE_CUSTOM,
-    USB_INTERFACE_MAX
-} tinyusb_interface_t;
-
-typedef uint16_t (*tinyusb_descriptor_cb_t)(uint8_t * dst, uint8_t * itf);
-
-esp_err_t tinyusb_enable_interface(tinyusb_interface_t interface, uint16_t descriptor_len, tinyusb_descriptor_cb_t cb);
-uint8_t tinyusb_add_string_descriptor(const char * str);
-uint8_t tinyusb_get_free_duplex_endpoint(void);
-uint8_t tinyusb_get_free_in_endpoint(void);
-uint8_t tinyusb_get_free_out_endpoint(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* CONFIG_USB_ENABLED */
-#endif /* CONFIG_IDF_TARGET_ESP32S2 */

cores/esp32/esp32-hal-touch.c

@@ -15,29 +15,12 @@
 #include "esp32-hal-touch.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
+#include "rom/ets_sys.h"
 #include "esp_attr.h"
+#include "esp_intr.h"
 #include "soc/rtc_io_reg.h"
 #include "soc/rtc_cntl_reg.h"
 #include "soc/sens_reg.h"
-#include "soc/sens_struct.h"
-#include "driver/touch_sensor.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 "esp_intr_alloc.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
-#include "esp_intr_alloc.h"
-#include "soc/periph_defs.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/ets_sys.h"
-#include "esp_intr.h"
-#endif
 
 static uint16_t __touchSleepCycles = 0x1000;
 static uint16_t __touchMeasureCycles = 0x1000;
@@ -46,9 +29,8 @@ typedef void (*voidFuncPtr)(void);
 static voidFuncPtr __touchInterruptHandlers[10] = {0,};
 static intr_handle_t touch_intr_handle = NULL;
 
-void ARDUINO_ISR_ATTR __touchISR(void * arg)
+void IRAM_ATTR __touchISR(void * arg)
 {
-#if CONFIG_IDF_TARGET_ESP32
     uint32_t pad_intr = READ_PERI_REG(SENS_SAR_TOUCH_CTRL2_REG) & 0x3ff;
     uint32_t rtc_intr = READ_PERI_REG(RTC_CNTL_INT_ST_REG);
     uint8_t i = 0;
@@ -65,21 +47,16 @@ void ARDUINO_ISR_ATTR __touchISR(void * arg)
             }
         }
     }
-#endif
 }
 
 void __touchSetCycles(uint16_t measure, uint16_t sleep)
 {
     __touchSleepCycles = sleep;
     __touchMeasureCycles = measure;
-#if CONFIG_IDF_TARGET_ESP32
     //Touch pad SleepCycle Time
     SET_PERI_REG_BITS(SENS_SAR_TOUCH_CTRL2_REG, SENS_TOUCH_SLEEP_CYCLES, __touchSleepCycles, SENS_TOUCH_SLEEP_CYCLES_S);
     //Touch Pad Measure Time
     SET_PERI_REG_BITS(SENS_SAR_TOUCH_CTRL1_REG, SENS_TOUCH_MEAS_DELAY, __touchMeasureCycles, SENS_TOUCH_MEAS_DELAY_S);
-#else
-    touch_pad_set_meas_time(sleep, measure);
-#endif
 }
 
 void __touchInit()
@@ -89,27 +66,15 @@ void __touchInit()
         return;
     }
     initialized = true;
-#if CONFIG_IDF_TARGET_ESP32
     SET_PERI_REG_BITS(RTC_IO_TOUCH_CFG_REG, RTC_IO_TOUCH_XPD_BIAS, 1, RTC_IO_TOUCH_XPD_BIAS_S);
     SET_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL2_REG, SENS_TOUCH_MEAS_EN_CLR);
     //clear touch enable
     WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG, 0x0);
+    SET_PERI_REG_MASK(RTC_CNTL_STATE0_REG, RTC_CNTL_TOUCH_SLP_TIMER_EN);
+
     __touchSetCycles(__touchMeasureCycles, __touchSleepCycles);
-    esp_intr_alloc(ETS_RTC_CORE_INTR_SOURCE, (int)ARDUINO_ISR_FLAG, __touchISR, NULL, &touch_intr_handle);
-#else
-    touch_pad_init();
-    touch_pad_set_voltage(TOUCH_HVOLT_2V7, TOUCH_LVOLT_0V5, TOUCH_HVOLT_ATTEN_0V5);
-    touch_pad_set_idle_channel_connect(TOUCH_PAD_CONN_GND);
-    __touchSetCycles(__touchMeasureCycles, __touchSleepCycles);
-    touch_pad_denoise_t denoise = {
-        .grade = TOUCH_PAD_DENOISE_BIT4,
-        .cap_level = TOUCH_PAD_DENOISE_CAP_L4,
-    };
-    touch_pad_denoise_set_config(&denoise);
-    touch_pad_denoise_enable();
-    touch_pad_set_fsm_mode(TOUCH_FSM_MODE_TIMER);
-    touch_pad_fsm_start();
-#endif
+
+    esp_intr_alloc(ETS_RTC_CORE_INTR_SOURCE, (int)ESP_INTR_FLAG_IRAM, __touchISR, NULL, &touch_intr_handle);
 }
 
 uint16_t __touchRead(uint8_t pin)
@@ -123,7 +88,6 @@ uint16_t __touchRead(uint8_t pin)
 
     __touchInit();
 
-#if CONFIG_IDF_TARGET_ESP32
     uint32_t v0 = READ_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG);
     //Disable Intr & enable touch pad
     WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG,
@@ -155,25 +119,6 @@ uint16_t __touchRead(uint8_t pin)
     //restore previous value
     WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG, v0);
     return touch_value;
-#else
-    static uint32_t chan_mask = 0;
-    uint32_t value = 0;
-    if((chan_mask & (1 << pad)) == 0){
-        if(touch_pad_set_thresh((touch_pad_t)pad, TOUCH_PAD_THRESHOLD_MAX) != ESP_OK){
-        	log_e("touch_pad_set_thresh failed");
-        } else if(touch_pad_config((touch_pad_t)pad) != ESP_OK){
-        	log_e("touch_pad_config failed");
-        } else {
-        	chan_mask |= (1 << pad);
-        }
-    }
-    if((chan_mask & (1 << pad)) != 0) {
-        if(touch_pad_read_raw_data((touch_pad_t)pad, &value) != ESP_OK){
-        	log_e("touch_pad_read_raw_data failed");
-        }
-    }
-    return value;
-#endif
 }
 
 void __touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), uint16_t threshold)
@@ -189,7 +134,6 @@ void __touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), uint16_t thresh
 
     __touchInterruptHandlers[pad] = userFunc;
 
-#if CONFIG_IDF_TARGET_ESP32
     //clear touch force ,select the Touch mode is Timer
     CLEAR_PERI_REG_MASK(SENS_SAR_TOUCH_CTRL2_REG, SENS_TOUCH_START_EN_M|SENS_TOUCH_START_FORCE_M);
 
@@ -217,9 +161,6 @@ void __touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), uint16_t thresh
                       (1 << (pad + SENS_TOUCH_PAD_WORKEN_S)) | \
                       (1 << (pad + SENS_TOUCH_PAD_OUTEN2_S)) | \
                       (1 << (pad + SENS_TOUCH_PAD_OUTEN1_S)));
-#else
-
-#endif
 }
 
 extern uint16_t touchRead(uint8_t pin) __attribute__ ((weak, alias("__touchRead")));

cores/esp32/esp32-hal-uart.c

@@ -18,7 +18,10 @@
 #include "freertos/task.h"
 #include "freertos/queue.h"
 #include "freertos/semphr.h"
+#include "rom/ets_sys.h"
 #include "esp_attr.h"
+#include "esp_intr.h"
+#include "rom/uart.h"
 #include "soc/uart_reg.h"
 #include "soc/uart_struct.h"
 #include "soc/io_mux_reg.h"
@@ -27,37 +30,10 @@
 #include "soc/rtc.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 "esp32/rom/ets_sys.h"
-#include "esp32/rom/uart.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
-#include "esp32s2/rom/uart.h"
-#include "soc/periph_defs.h"
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
-#else // ESP32 Before IDF 4.0
-#include "rom/ets_sys.h"
-#include "rom/uart.h"
-#include "esp_intr.h"
-#endif
-
-#if CONFIG_IDF_TARGET_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 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;
 
@@ -75,35 +51,31 @@ struct uart_struct_t {
 #define UART_MUTEX_LOCK()
 #define UART_MUTEX_UNLOCK()
 
-static uart_t _uart_bus_array[] = {
-    {&UART0, 0, NULL, NULL},
-    {&UART1, 1, NULL, NULL},
-#if CONFIG_IDF_TARGET_ESP32
-    {&UART2, 2, NULL, NULL}
-#endif
+static uart_t _uart_bus_array[3] = {
+    {(volatile uart_dev_t *)(DR_REG_UART_BASE), 0, NULL, NULL},
+    {(volatile uart_dev_t *)(DR_REG_UART1_BASE), 1, NULL, NULL},
+    {(volatile uart_dev_t *)(DR_REG_UART2_BASE), 2, NULL, NULL}
 };
 #else
 #define UART_MUTEX_LOCK()    do {} while (xSemaphoreTake(uart->lock, portMAX_DELAY) != pdPASS)
 #define UART_MUTEX_UNLOCK()  xSemaphoreGive(uart->lock)
 
-static uart_t _uart_bus_array[] = {
-    {&UART0, NULL, 0, NULL, NULL},
-    {&UART1, NULL, 1, NULL, NULL},
-#if CONFIG_IDF_TARGET_ESP32
-    {&UART2, NULL, 2, NULL, NULL}
-#endif
+static uart_t _uart_bus_array[3] = {
+    {(volatile uart_dev_t *)(DR_REG_UART_BASE), NULL, 0, NULL, NULL},
+    {(volatile uart_dev_t *)(DR_REG_UART1_BASE), NULL, 1, NULL, NULL},
+    {(volatile uart_dev_t *)(DR_REG_UART2_BASE), NULL, 2, NULL, NULL}
 };
 #endif
 
 static void uart_on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb);
 
-static void ARDUINO_ISR_ATTR _uart_isr(void *arg)
+static void IRAM_ATTR _uart_isr(void *arg)
 {
     uint8_t i, c;
     BaseType_t xHigherPriorityTaskWoken;
     uart_t* uart;
 
-    for(i=0;i<UART_PORTS_NUM;i++){
+    for(i=0;i<3;i++){
         uart = &_uart_bus_array[i];
         if(uart->intr_handle == NULL){
             continue;
@@ -111,15 +83,9 @@ static void ARDUINO_ISR_ATTR _uart_isr(void *arg)
         uart->dev->int_clr.rxfifo_full = 1;
         uart->dev->int_clr.frm_err = 1;
         uart->dev->int_clr.rxfifo_tout = 1;
-#if CONFIG_IDF_TARGET_ESP32
         while(uart->dev->status.rxfifo_cnt || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
             c = uart->dev->fifo.rw_byte;
-#else
-        uint32_t fifo_reg = UART_FIFO_AHB_REG(i);
-        while(uart->dev->status.rxfifo_cnt) {
-        	c = ESP_REG(fifo_reg);
-#endif
-            if(uart->queue != NULL) {
+            if(uart->queue != NULL)  {
                 xQueueSendFromISR(uart->queue, &c, &xHigherPriorityTaskWoken);
             }
         }
@@ -134,18 +100,14 @@ void uartEnableInterrupt(uart_t* uart)
 {
     UART_MUTEX_LOCK();
     uart->dev->conf1.rxfifo_full_thrhd = 112;
-#if CONFIG_IDF_TARGET_ESP32
     uart->dev->conf1.rx_tout_thrhd = 2;
-#else
-    uart->dev->mem_conf.rx_tout_thrhd = 2;
-#endif
     uart->dev->conf1.rx_tout_en = 1;
     uart->dev->int_ena.rxfifo_full = 1;
     uart->dev->int_ena.frm_err = 1;
     uart->dev->int_ena.rxfifo_tout = 1;
     uart->dev->int_clr.val = 0xffffffff;
 
-    esp_intr_alloc(UART_INTR_SOURCE(uart->num), (int)ARDUINO_ISR_FLAG, _uart_isr, NULL, &uart->intr_handle);
+    esp_intr_alloc(UART_INTR_SOURCE(uart->num), (int)ESP_INTR_FLAG_IRAM, _uart_isr, NULL, &uart->intr_handle);
     UART_MUTEX_UNLOCK();
 }
 
@@ -181,17 +143,17 @@ void uartDetachTx(uart_t* uart, uint8_t txPin)
 
 void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted)
 {
-    if(uart == NULL || rxPin >= GPIO_PIN_COUNT) {
+    if(uart == NULL || rxPin > 39) {
         return;
     }
     pinMode(rxPin, INPUT);
-    uartEnableInterrupt(uart);
     pinMatrixInAttach(rxPin, UART_RXD_IDX(uart->num), inverted);
+    uartEnableInterrupt(uart);
 }
 
 void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
 {
-    if(uart == NULL || txPin >= GPIO_PIN_COUNT) {
+    if(uart == NULL || txPin > 39) {
         return;
     }
     pinMode(txPin, OUTPUT);
@@ -200,7 +162,7 @@ void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
 
 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) {
+    if(uart_nr > 2) {
         return NULL;
     }
 
@@ -228,11 +190,9 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
     if(uart_nr == 1){
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART1_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART1_RST);
-#if CONFIG_IDF_TARGET_ESP32
     } else if(uart_nr == 2){
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART2_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART2_RST);
-#endif
     } else {
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART_RST);
@@ -298,7 +258,7 @@ size_t uartResizeRxBuffer(uart_t * uart, size_t new_size) {
         uart->queue = xQueueCreate(new_size, sizeof(uint8_t));
         if(uart->queue == NULL) {
             UART_MUTEX_UNLOCK();
-            return 0;
+            return NULL;
         }
     }
     UART_MUTEX_UNLOCK();
@@ -340,14 +300,8 @@ void uartRxFifoToQueue(uart_t* uart)
 	//disable interrupts
 	uart->dev->int_ena.val = 0;
 	uart->dev->int_clr.val = 0xffffffff;
-#if CONFIG_IDF_TARGET_ESP32
 	while (uart->dev->status.rxfifo_cnt || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
 		c = uart->dev->fifo.rw_byte;
-#else
-	uint32_t fifo_reg = UART_FIFO_AHB_REG(uart->num);
-	while (uart->dev->status.rxfifo_cnt) {
-		c = ESP_REG(fifo_reg);
-#endif
 		xQueueSend(uart->queue, &c, 0);
 	}
 	//enable interrupts
@@ -397,11 +351,7 @@ void uartWrite(uart_t* uart, uint8_t c)
     }
     UART_MUTEX_LOCK();
     while(uart->dev->status.txfifo_cnt == 0x7F);
-#if CONFIG_IDF_TARGET_ESP32
     uart->dev->fifo.rw_byte = c;
-#else
-    ESP_REG(UART_FIFO_AHB_REG(uart->num)) = c;
-#endif
     UART_MUTEX_UNLOCK();
 }
 
@@ -411,16 +361,9 @@ void uartWriteBuf(uart_t* uart, const uint8_t * data, size_t len)
         return;
     }
     UART_MUTEX_LOCK();
-#ifndef CONFIG_IDF_TARGET_ESP32
-    uint32_t fifo_reg = UART_FIFO_AHB_REG(uart->num);
-#endif
     while(len) {
         while(uart->dev->status.txfifo_cnt == 0x7F);
-#if CONFIG_IDF_TARGET_ESP32
         uart->dev->fifo.rw_byte = *data++;
-#else
-        ESP_REG(fifo_reg) = *data++;
-#endif
         len--;
     }
     UART_MUTEX_UNLOCK();
@@ -438,7 +381,6 @@ void uartFlushTxOnly(uart_t* uart, bool txOnly)
     }
 
     UART_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32
     while(uart->dev->status.txfifo_cnt || uart->dev->status.st_utx_out);
     
     if( !txOnly ){
@@ -452,11 +394,6 @@ void uartFlushTxOnly(uart_t* uart, bool txOnly)
 
         xQueueReset(uart->queue);
     }
-#else
-    while(uart->dev->status.txfifo_cnt);
-    uart->dev->conf0.txfifo_rst = 1;
-    uart->dev->conf0.txfifo_rst = 0;
-#endif
     
     UART_MUTEX_UNLOCK();
 }
@@ -484,14 +421,8 @@ static void uart_on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old
         // read RX fifo
         uint8_t c;
    //     BaseType_t xHigherPriorityTaskWoken;
-#if CONFIG_IDF_TARGET_ESP32
         while(uart->dev->status.rxfifo_cnt != 0 || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
             c = uart->dev->fifo.rw_byte;
-#else
-        uint32_t fifo_reg = UART_FIFO_AHB_REG(uart->num);
-        while(uart->dev->status.rxfifo_cnt != 0) {
-            c = ESP_REG(fifo_reg);
-#endif
             if(uart->queue != NULL ) {
                 xQueueSend(uart->queue, &c, 1); //&xHigherPriorityTaskWoken);
             }
@@ -499,11 +430,7 @@ static void uart_on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old
         UART_MUTEX_UNLOCK();
  
         // wait TX empty
-#if CONFIG_IDF_TARGET_ESP32
         while(uart->dev->status.txfifo_cnt || uart->dev->status.st_utx_out);
-#else
-        while(uart->dev->status.txfifo_cnt);
-#endif
     } else {
         //todo:
         // set baudrate
@@ -536,35 +463,23 @@ uint32_t uartGetBaudRate(uart_t* uart)
     return ((getApbFrequency()<<4)/clk_div);
 }
 
-static void ARDUINO_ISR_ATTR uart0_write_char(char c)
+static void IRAM_ATTR uart0_write_char(char c)
 {
-#if CONFIG_IDF_TARGET_ESP32
     while(((ESP_REG(0x01C+DR_REG_UART_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
     ESP_REG(DR_REG_UART_BASE) = c;
-#else
-    while(UART0.status.txfifo_cnt == 0x7F);
-    WRITE_PERI_REG(UART_FIFO_AHB_REG(0), c);
-#endif
 }
 
-static void ARDUINO_ISR_ATTR uart1_write_char(char c)
+static void IRAM_ATTR uart1_write_char(char c)
 {
-#if CONFIG_IDF_TARGET_ESP32
     while(((ESP_REG(0x01C+DR_REG_UART1_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
     ESP_REG(DR_REG_UART1_BASE) = c;
-#else
-    while(UART1.status.txfifo_cnt == 0x7F);
-    WRITE_PERI_REG(UART_FIFO_AHB_REG(1), c);
-#endif
 }
 
-#if CONFIG_IDF_TARGET_ESP32
-static void ARDUINO_ISR_ATTR uart2_write_char(char c)
+static void IRAM_ATTR uart2_write_char(char c)
 {
     while(((ESP_REG(0x01C+DR_REG_UART2_BASE) >> UART_TXFIFO_CNT_S) & 0x7F) == 0x7F);
     ESP_REG(DR_REG_UART2_BASE) = c;
 }
-#endif
 
 void uart_install_putc()
 {
@@ -575,11 +490,9 @@ void uart_install_putc()
     case 1:
         ets_install_putc1((void (*)(char)) &uart1_write_char);
         break;
-#if CONFIG_IDF_TARGET_ESP32
     case 2:
         ets_install_putc1((void (*)(char)) &uart2_write_char);
         break;
-#endif
     default:
         ets_install_putc1(NULL);
         break;
@@ -588,7 +501,7 @@ void uart_install_putc()
 
 void uartSetDebug(uart_t* uart)
 {
-    if(uart == NULL || uart->num >= UART_PORTS_NUM) {
+    if(uart == NULL || uart->num > 2) {
         s_uart_debug_nr = -1;
         //ets_install_putc1(NULL);
         //return;
@@ -607,6 +520,9 @@ int uartGetDebug()
 
 int log_printf(const char *format, ...)
 {
+    if(s_uart_debug_nr < 0){
+        return 0;
+    }
     static char loc_buf[64];
     char * temp = loc_buf;
     int len;
@@ -624,7 +540,7 @@ int log_printf(const char *format, ...)
     }
     vsnprintf(temp, len+1, format, arg);
 #if !CONFIG_DISABLE_HAL_LOCKS
-    if(s_uart_debug_nr != -1 && _uart_bus_array[s_uart_debug_nr].lock){
+    if(_uart_bus_array[s_uart_debug_nr].lock){
         xSemaphoreTake(_uart_bus_array[s_uart_debug_nr].lock, portMAX_DELAY);
         ets_printf("%s", temp);
         xSemaphoreGive(_uart_bus_array[s_uart_debug_nr].lock);
@@ -715,9 +631,5 @@ uartDetectBaudrate(uart_t *uart)
  * Returns the status of the RX state machine, if the value is non-zero the state machine is active.
  */
 bool uartRxActive(uart_t* uart) {
-#if CONFIG_IDF_TARGET_ESP32
     return uart->dev->status.st_urx_out != 0;
-#else
-    return 0;
-#endif
 }

cores/esp32/esp32-hal.h

@@ -20,6 +20,10 @@
 #ifndef HAL_ESP32_HAL_H_
 #define HAL_ESP32_HAL_H_
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdio.h>
@@ -30,34 +34,9 @@
 #include <math.h>
 #include "sdkconfig.h"
 #include "esp_system.h"
-#include "esp_sleep.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
 
 #ifndef F_CPU
-#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #define F_CPU (CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ * 1000000U)
-#elif CONFIG_IDF_TARGET_ESP32S2
-#define F_CPU (CONFIG_ESP32S2_DEFAULT_CPU_FREQ_MHZ * 1000000U)
-#endif
-#endif
-
-#if CONFIG_ARDUINO_ISR_IRAM
-#define ARDUINO_ISR_ATTR IRAM_ATTR
-#define ARDUINO_ISR_FLAG ESP_INTR_FLAG_IRAM
-#else
-#define ARDUINO_ISR_ATTR
-#define ARDUINO_ISR_FLAG (0)
-#endif
-
-#ifndef ARDUINO_RUNNING_CORE
-#define ARDUINO_RUNNING_CORE CONFIG_ARDUINO_RUNNING_CORE
-#endif
-
-#ifndef ARDUINO_EVENT_RUNNING_CORE
-#define ARDUINO_EVENT_RUNNING_CORE CONFIG_ARDUINO_EVENT_RUNNING_CORE
 #endif
 
 //forward declaration from freertos/portmacro.h
@@ -85,6 +64,12 @@ void yield(void);
 #include "esp32-hal-psram.h"
 #include "esp32-hal-cpu.h"
 
+#ifndef BOARD_HAS_PSRAM
+#ifdef CONFIG_SPIRAM_SUPPORT
+#undef CONFIG_SPIRAM_SUPPORT
+#endif
+#endif
+
 //returns chip temperature in Celsius
 float temperatureRead();
 

cores/esp32/esp8266-compat.h

@@ -18,7 +18,7 @@
 #define _ESP8266_COMPAT_H_
 
 #define ICACHE_FLASH_ATTR
-#define ICACHE_RAM_ATTR ARDUINO_ISR_ATTR
+#define ICACHE_RAM_ATTR IRAM_ATTR
 
 
 #endif /* _ESP8266_COMPAT_H_ */

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

@@ -2,23 +2,14 @@
 #include "freertos/task.h"
 #include "esp_task_wdt.h"
 #include "Arduino.h"
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
-#include "USB.h"
+
+#ifndef CONFIG_ARDUINO_LOOP_STACK_SIZE
+#define CONFIG_ARDUINO_LOOP_STACK_SIZE 8192
 #endif
 
 TaskHandle_t loopTaskHandle = NULL;
 
 #if CONFIG_AUTOSTART_ARDUINO
-#if CONFIG_FREERTOS_UNICORE
-void yieldIfNecessary(void){
-    static uint64_t lastYield = 0;
-    uint64_t now = millis();
-    if((now - lastYield) > 2000) {
-        lastYield = now;
-        vTaskDelay(5); //delay 1 RTOS tick
-    }
-}
-#endif
 
 bool loopTaskWDTEnabled;
 
@@ -26,9 +17,6 @@ void loopTask(void *pvParameters)
 {
     setup();
     for(;;) {
-#if CONFIG_FREERTOS_UNICORE
-        yieldIfNecessary();
-#endif
         if(loopTaskWDTEnabled){
             esp_task_wdt_reset();
         }
@@ -39,12 +27,9 @@ void loopTask(void *pvParameters)
 
 extern "C" void app_main()
 {
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
-    USB.begin();
-#endif
     loopTaskWDTEnabled = false;
     initArduino();
-    xTaskCreateUniversal(loopTask, "loopTask", 8192, NULL, 1, &loopTaskHandle, ARDUINO_RUNNING_CORE);
+    xTaskCreateUniversal(loopTask, "loopTask", CONFIG_ARDUINO_LOOP_STACK_SIZE, NULL, 1, &loopTaskHandle, CONFIG_ARDUINO_RUNNING_CORE);
 }
 
 #endif

docs/arduino-ide/debian_ubuntu.md

@@ -8,8 +8,8 @@ Installation instructions for Debian / Ubuntu OS
   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 && \
+  sudo python3 get-pip.py && \
+  sudo pip3 install pyserial && \
   mkdir -p ~/Arduino/hardware/espressif && \
   cd ~/Arduino/hardware/espressif && \
   git clone https://github.com/espressif/arduino-esp32.git esp32 && \

libraries/AsyncUDP/src/AsyncUDP.cpp

@@ -277,6 +277,22 @@ void AsyncUDPMessage::flush()
     _index = 0;
 }
 
+AsyncUDPPacket::AsyncUDPPacket(AsyncUDPPacket &packet){
+    _udp = packet._udp;
+    _pb = packet._pb;
+    _if = packet._if;
+    _data = packet._data;
+    _len = packet._len;
+    _index = 0;
+
+    memcpy(&_remoteIp, &packet._remoteIp, sizeof(ip_addr_t));
+    memcpy(&_localIp, &packet._localIp, sizeof(ip_addr_t));
+    _localPort = packet._localPort;
+    _remotePort = packet._remotePort;
+    memcpy(_remoteMac, packet._remoteMac, 6);
+
+    pbuf_ref(_pb);
+}
 
 AsyncUDPPacket::AsyncUDPPacket(AsyncUDP *udp, pbuf *pb, const ip_addr_t *raddr, uint16_t rport, struct netif * ntif)
 {
@@ -294,18 +310,18 @@ AsyncUDPPacket::AsyncUDPPacket(AsyncUDP *udp, pbuf *pb, const ip_addr_t *raddr,
     _localIp.type = _remoteIp.type;
 
     eth_hdr* eth = NULL;
-    udp_hdr* udphdr = reinterpret_cast<udp_hdr*>(_data - UDP_HLEN);
+    udp_hdr* udphdr = (udp_hdr *)(_data - UDP_HLEN);
     _localPort = ntohs(udphdr->dest);
     _remotePort = ntohs(udphdr->src);
 
     if (_remoteIp.type == IPADDR_TYPE_V4) {
-        eth = (eth_hdr *)(((uint8_t *)(pb->payload)) - UDP_HLEN - IP_HLEN - SIZEOF_ETH_HDR);
-        struct ip_hdr * iphdr = (struct ip_hdr *)(((uint8_t *)(pb->payload)) - UDP_HLEN - IP_HLEN);
+        eth = (eth_hdr *)(_data - UDP_HLEN - IP_HLEN - SIZEOF_ETH_HDR);
+        struct ip_hdr * iphdr = (struct ip_hdr *)(_data - UDP_HLEN - IP_HLEN);
         _localIp.u_addr.ip4.addr = iphdr->dest.addr;
         _remoteIp.u_addr.ip4.addr = iphdr->src.addr;
     } else {
-        eth = (eth_hdr *)(((uint8_t *)(pb->payload)) - UDP_HLEN - IP6_HLEN - SIZEOF_ETH_HDR);
-        struct ip6_hdr * ip6hdr = (struct ip6_hdr *)(((uint8_t *)(pb->payload)) - UDP_HLEN - IP6_HLEN);
+        eth = (eth_hdr *)(_data - UDP_HLEN - IP6_HLEN - SIZEOF_ETH_HDR);
+        struct ip6_hdr * ip6hdr = (struct ip6_hdr *)(_data - UDP_HLEN - IP6_HLEN);
         memcpy(&_localIp.u_addr.ip6.addr, (uint8_t *)ip6hdr->dest.addr, 16);
         memcpy(&_remoteIp.u_addr.ip6.addr, (uint8_t *)ip6hdr->src.addr, 16);
     }
@@ -479,6 +495,7 @@ AsyncUDP::AsyncUDP()
 {
     _pcb = NULL;
     _connected = false;
+	_lastErr = ERR_OK;
     _handler = NULL;
 }
 
@@ -517,8 +534,8 @@ bool AsyncUDP::connect(const ip_addr_t *addr, uint16_t port)
     }
     close();
     UDP_MUTEX_LOCK();
-    err_t err = _udp_connect(_pcb, addr, port);
-    if(err != ERR_OK) {
+    _lastErr = _udp_connect(_pcb, addr, port);
+    if(_lastErr != ERR_OK) {
         UDP_MUTEX_UNLOCK();
         return false;
     }
@@ -646,7 +663,7 @@ size_t AsyncUDP::writeTo(const uint8_t * data, size_t len, const ip_addr_t * add
     if(len > CONFIG_TCP_MSS) {
         len = CONFIG_TCP_MSS;
     }
-    err_t err = ERR_OK;
+    _lastErr = ERR_OK;
     pbuf* pbt = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);
     if(pbt != NULL) {
         uint8_t* dst = reinterpret_cast<uint8_t*>(pbt->payload);
@@ -656,16 +673,16 @@ size_t AsyncUDP::writeTo(const uint8_t * data, size_t len, const ip_addr_t * add
             void * nif = NULL;
             tcpip_adapter_get_netif((tcpip_adapter_if_t)tcpip_if, &nif);
             if(!nif){
-                err = _udp_sendto(_pcb, pbt, addr, port);
+                _lastErr = _udp_sendto(_pcb, pbt, addr, port);
             } else {
-                err = _udp_sendto_if(_pcb, pbt, addr, port, (struct netif *)nif);
+                _lastErr = _udp_sendto_if(_pcb, pbt, addr, port, (struct netif *)nif);
             }
         } else {
-            err = _udp_sendto(_pcb, pbt, addr, port);
+            _lastErr = _udp_sendto(_pcb, pbt, addr, port);
         }
         UDP_MUTEX_UNLOCK();
         pbuf_free(pbt);
-        if(err < ERR_OK) {
+        if(_lastErr < ERR_OK) {
             return 0;
         }
         return len;
@@ -682,9 +699,8 @@ void AsyncUDP::_recv(udp_pcb *upcb, pbuf *pb, const ip_addr_t *addr, uint16_t po
         if(_handler) {
             AsyncUDPPacket packet(this, this_pb, addr, port, netif);
             _handler(packet);
-        } else {
-            pbuf_free(this_pb);
         }
+        pbuf_free(this_pb);
     }
 }
 
@@ -870,6 +886,10 @@ bool AsyncUDP::connected()
     return _connected;
 }
 
+esp_err_t AsyncUDP::lastErr() {
+	return _lastErr;
+}
+
 void AsyncUDP::onPacket(AuPacketHandlerFunctionWithArg cb, void * arg)
 {
     onPacket(std::bind(cb, arg, std::placeholders::_1));

libraries/AsyncUDP/src/AsyncUDP.h

@@ -7,7 +7,7 @@
 #include <functional>
 extern "C" {
 #include "lwip/ip_addr.h"
-#include "esp_netif.h"
+#include <tcpip_adapter.h>
 #include "freertos/queue.h"
 #include "freertos/semphr.h"
 }
@@ -58,6 +58,7 @@ protected:
     size_t _len;
     size_t _index;
 public:
+    AsyncUDPPacket(AsyncUDPPacket &packet);
     AsyncUDPPacket(AsyncUDP *udp, pbuf *pb, const ip_addr_t *addr, uint16_t port, struct netif * netif);
     virtual ~AsyncUDPPacket();
 
@@ -95,6 +96,7 @@ protected:
     udp_pcb *_pcb;
     //xSemaphoreHandle _lock;
     bool _connected;
+	esp_err_t _lastErr;
     AuPacketHandlerFunction _handler;
 
     bool _init();
@@ -144,6 +146,7 @@ public:
     IPAddress listenIP();
     IPv6Address listenIPv6();
     bool connected();
+	esp_err_t lastErr();
     operator bool();
 
     static void _s_recv(void *arg, udp_pcb *upcb, pbuf *p, const ip_addr_t *addr, uint16_t port, struct netif * netif);

libraries/BLE/src/BLE2902.cpp

@@ -10,7 +10,7 @@
  * https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.descriptor.gatt.client_characteristic_configuration.xml
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 
 #include "BLE2902.h"
 

libraries/BLE/src/BLE2902.h

@@ -8,7 +8,7 @@
 #ifndef COMPONENTS_CPP_UTILS_BLE2902_H_
 #define COMPONENTS_CPP_UTILS_BLE2902_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 
 #include "BLEDescriptor.h"
 
@@ -30,5 +30,5 @@ public:
 
 }; // BLE2902
 
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_CPP_UTILS_BLE2902_H_ */

libraries/BLE/src/BLE2904.cpp

@@ -10,7 +10,7 @@
  * https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.descriptor.gatt.characteristic_presentation_format.xml
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 
 #include "BLE2904.h"
 

libraries/BLE/src/BLE2904.h

@@ -8,7 +8,7 @@
 #ifndef COMPONENTS_CPP_UTILS_BLE2904_H_
 #define COMPONENTS_CPP_UTILS_BLE2904_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 
 #include "BLEDescriptor.h"
 
@@ -70,5 +70,5 @@ private:
 	BLE2904_Data m_data;
 }; // BLE2904
 
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_CPP_UTILS_BLE2904_H_ */

libraries/BLE/src/BLEAddress.cpp

@@ -5,7 +5,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 
 #include "BLEAddress.h"
 #include <string>
@@ -59,14 +59,37 @@ BLEAddress::BLEAddress(std::string stringAddress) {
  * @return True if the addresses are equal.
  */
 bool BLEAddress::equals(BLEAddress otherAddress) {
-	return memcmp(otherAddress.getNative(), m_address, 6) == 0;
+	return memcmp(otherAddress.getNative(), m_address, ESP_BD_ADDR_LEN) == 0;
 } // equals
 
+bool BLEAddress::operator==(const BLEAddress& otherAddress) const {
+	return memcmp(otherAddress.m_address, m_address, ESP_BD_ADDR_LEN) == 0;
+}
+
+bool BLEAddress::operator!=(const BLEAddress& otherAddress) const {
+  return !(*this == otherAddress);
+}
+
+bool BLEAddress::operator<(const BLEAddress& otherAddress) const {
+  return memcmp(otherAddress.m_address, m_address, ESP_BD_ADDR_LEN) < 0;
+}
+
+bool BLEAddress::operator<=(const BLEAddress& otherAddress) const {
+  return !(*this > otherAddress);
+}
+
+bool BLEAddress::operator>=(const BLEAddress& otherAddress) const {
+  return !(*this < otherAddress);
+}
+
+bool BLEAddress::operator>(const BLEAddress& otherAddress) const {
+  return memcmp(otherAddress.m_address, m_address, ESP_BD_ADDR_LEN) > 0;
+}
 
 /**
  * @brief Return the native representation of the address.
  * @return The native representation of the address.
- */
+ */   
 esp_bd_addr_t *BLEAddress::getNative() {
 	return &m_address;
 } // getNative

libraries/BLE/src/BLEAddress.h

@@ -8,7 +8,7 @@
 #ifndef COMPONENTS_CPP_UTILS_BLEADDRESS_H_
 #define COMPONENTS_CPP_UTILS_BLEADDRESS_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <esp_gap_ble_api.h> // ESP32 BLE
 #include <string>
 
@@ -23,6 +23,12 @@ public:
 	BLEAddress(esp_bd_addr_t address);
 	BLEAddress(std::string stringAddress);
 	bool           equals(BLEAddress otherAddress);
+  bool           operator==(const BLEAddress& otherAddress) const;
+  bool           operator!=(const BLEAddress& otherAddress) const;
+  bool           operator<(const BLEAddress& otherAddress) const;
+  bool           operator<=(const BLEAddress& otherAddress) const;
+  bool           operator>(const BLEAddress& otherAddress) const;
+  bool           operator>=(const BLEAddress& otherAddress) const;
 	esp_bd_addr_t* getNative();
 	std::string    toString();
 
@@ -30,5 +36,5 @@ private:
 	esp_bd_addr_t m_address;
 };
 
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_CPP_UTILS_BLEADDRESS_H_ */

libraries/BLE/src/BLEAdvertisedDevice.cpp

@@ -12,7 +12,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <sstream>
 #include "BLEAdvertisedDevice.h"
 #include "BLEUtils.h"
@@ -25,6 +25,7 @@ BLEAdvertisedDevice::BLEAdvertisedDevice() {
 	m_manufacturerData = "";
 	m_name             = "";
 	m_rssi             = -9999;
+	m_serviceUUIDs     = {};
 	m_serviceData      = {};
 	m_serviceDataUUIDs = {};
 	m_txPower          = 0;
@@ -34,8 +35,6 @@ BLEAdvertisedDevice::BLEAdvertisedDevice() {
 	m_haveManufacturerData = false;
 	m_haveName             = false;
 	m_haveRSSI             = false;
-	m_haveServiceData      = false;
-	m_haveServiceUUID      = false;
 	m_haveTXPower          = false;
 
 } // BLEAdvertisedDevice
@@ -107,11 +106,7 @@ BLEScan* BLEAdvertisedDevice::getScan() {
  * @return Number of service data discovered.
  */
 int BLEAdvertisedDevice::getServiceDataCount() {
-	if (m_haveServiceData)
-		return m_serviceData.size();
-	else
-		return 0;
-
+	return m_serviceData.size();
 } //getServiceDataCount
 
 /**
@@ -119,7 +114,7 @@ int BLEAdvertisedDevice::getServiceDataCount() {
  * @return The ServiceData of the advertised device.
  */
 std::string BLEAdvertisedDevice::getServiceData() {
-	return m_serviceData[0];
+	return m_serviceData.empty() ? std::string() : m_serviceData.front();
 } //getServiceData
 
 /**
@@ -130,12 +125,20 @@ std::string BLEAdvertisedDevice::getServiceData(int i) {
 	return m_serviceData[i];
 } //getServiceData
 
+/**
+ * @brief Get the number of service data UUIDs.
+ * @return Number of service data UUIDs discovered.
+ */
+int BLEAdvertisedDevice::getServiceDataUUIDCount() {
+	return m_serviceDataUUIDs.size();
+} //getServiceDataUUIDCount
+
 /**
  * @brief Get the service data UUID.
  * @return The service data UUID.
  */
 BLEUUID BLEAdvertisedDevice::getServiceDataUUID() {
-	return m_serviceDataUUIDs[0];
+	return m_serviceDataUUIDs.empty() ? BLEUUID() : m_serviceDataUUIDs.front();
 } // getServiceDataUUID
 
 /**
@@ -146,12 +149,20 @@ BLEUUID BLEAdvertisedDevice::getServiceDataUUID(int i) {
 	return m_serviceDataUUIDs[i];
 } // getServiceDataUUID
 
+/**
+ * @brief Get the number of service UUIDs.
+ * @return Number of service UUIDs discovered.
+ */
+int BLEAdvertisedDevice::getServiceUUIDCount() {
+	return m_serviceUUIDs.size();
+} //getServiceUUIDCount
+
 /**
  * @brief Get the Service UUID.
  * @return The Service UUID of the advertised device.
  */
 BLEUUID BLEAdvertisedDevice::getServiceUUID() {
-	return m_serviceUUIDs[0];
+	return m_serviceUUIDs.empty() ? BLEUUID() : m_serviceUUIDs.front();
 } // getServiceUUID
 
 /**
@@ -167,7 +178,7 @@ BLEUUID BLEAdvertisedDevice::getServiceUUID(int i) {
  * @return Return true if service is advertised
  */
 bool BLEAdvertisedDevice::isAdvertisingService(BLEUUID uuid){
-	for (int i = 0; i < m_serviceUUIDs.size(); i++) {
+	for (int i = 0; i < getServiceUUIDCount(); i++) {
 		if (m_serviceUUIDs[i].equals(uuid)) return true;
 	}
 	return false;
@@ -224,7 +235,7 @@ bool BLEAdvertisedDevice::haveRSSI() {
  * @return True if there is a service data value present.
  */
 bool BLEAdvertisedDevice::haveServiceData() {
-	return m_haveServiceData;
+	return !m_serviceData.empty();
 } // haveServiceData
 
 
@@ -233,7 +244,7 @@ bool BLEAdvertisedDevice::haveServiceData() {
  * @return True if there is a service UUID value present.
  */
 bool BLEAdvertisedDevice::haveServiceUUID() {
-	return m_haveServiceUUID;
+	return !m_serviceUUIDs.empty();
 } // haveServiceUUID
 
 
@@ -486,7 +497,6 @@ void BLEAdvertisedDevice::setServiceUUID(const char* serviceUUID) {
  */
 void BLEAdvertisedDevice::setServiceUUID(BLEUUID serviceUUID) {
 	m_serviceUUIDs.push_back(serviceUUID);
-	m_haveServiceUUID = true;
 	log_d("- addServiceUUID(): serviceUUID: %s", serviceUUID.toString().c_str());
 } // setServiceUUID
 
@@ -496,7 +506,6 @@ void BLEAdvertisedDevice::setServiceUUID(BLEUUID serviceUUID) {
  * @param [in] data ServiceData value.
  */
 void BLEAdvertisedDevice::setServiceData(std::string serviceData) {
-	m_haveServiceData = true;         // Set the flag that indicates we have service data.
 	m_serviceData.push_back(serviceData); // Save the service data that we received.
 } //setServiceData
 
@@ -506,7 +515,6 @@ void BLEAdvertisedDevice::setServiceData(std::string serviceData) {
  * @param [in] data ServiceDataUUID value.
  */
 void BLEAdvertisedDevice::setServiceDataUUID(BLEUUID uuid) {
-	m_haveServiceData = true;         // Set the flag that indicates we have service data.
 	m_serviceDataUUIDs.push_back(uuid);
 	log_d("- addServiceDataUUID(): serviceDataUUID: %s", uuid.toString().c_str());
 } // setServiceDataUUID
@@ -542,12 +550,12 @@ std::string BLEAdvertisedDevice::toString() {
 		free(pHex);
 	}
 	if (haveServiceUUID()) {
-		for (int i=0; i < m_serviceUUIDs.size(); i++) {
+		for (int i=0; i < getServiceUUIDCount(); i++) {
 		    res += ", serviceUUID: " + getServiceUUID(i).toString();
 		}
 	}
 	if (haveTXPower()) {
-		char val[6];
+		char val[4];
 		snprintf(val, sizeof(val), "%d", getTXPower());
 		res += ", txPower: ";
 		res += val;
@@ -571,5 +579,5 @@ size_t BLEAdvertisedDevice::getPayloadLength() {
 	return m_payloadLength;
 }
 
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */
 

libraries/BLE/src/BLEAdvertisedDevice.h

@@ -8,7 +8,7 @@
 #ifndef COMPONENTS_CPP_UTILS_BLEADVERTISEDDEVICE_H_
 #define COMPONENTS_CPP_UTILS_BLEADVERTISEDDEVICE_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <esp_gattc_api.h>
 
 #include <map>
@@ -42,6 +42,8 @@ public:
 	BLEUUID     getServiceUUID();
 	BLEUUID     getServiceUUID(int i);
 	int         getServiceDataCount();
+	int         getServiceDataUUIDCount();
+	int         getServiceUUIDCount();
 	int8_t      getTXPower();
 	uint8_t* 	getPayload();
 	size_t		getPayloadLength();
@@ -83,8 +85,6 @@ private:
 	bool m_haveManufacturerData;
 	bool m_haveName;
 	bool m_haveRSSI;
-	bool m_haveServiceData;
-	bool m_haveServiceUUID;
 	bool m_haveTXPower;
 
 
@@ -124,5 +124,5 @@ public:
 	virtual void onResult(BLEAdvertisedDevice advertisedDevice) = 0;
 };
 
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_CPP_UTILS_BLEADVERTISEDDEVICE_H_ */

libraries/BLE/src/BLEAdvertising.cpp

@@ -17,7 +17,7 @@
  *
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include "BLEAdvertising.h"
 #include <esp_err.h>
 #include "BLEUtils.h"
@@ -91,6 +91,10 @@ void BLEAdvertising::setAdvertisementType(esp_ble_adv_type_t adv_type){
 	m_advParams.adv_type = adv_type;
 } // setAdvertisementType
 
+void BLEAdvertising::setAdvertisementChannelMap(esp_ble_adv_channel_t channel_map) {
+	m_advParams.channel_map = channel_map;
+} // setAdvertisementChannelMap
+
 void BLEAdvertising::setMinInterval(uint16_t mininterval) {
 	m_advParams.adv_int_min = mininterval;
 } // setMinInterval
@@ -525,4 +529,4 @@ void BLEAdvertising::handleGAPEvent(
 }
 
 
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */

libraries/BLE/src/BLEAdvertising.h

@@ -8,11 +8,11 @@
 #ifndef COMPONENTS_CPP_UTILS_BLEADVERTISING_H_
 #define COMPONENTS_CPP_UTILS_BLEADVERTISING_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <esp_gap_ble_api.h>
 #include "BLEUUID.h"
 #include <vector>
-#include "RTOS.h"
+#include "FreeRTOS.h"
 
 /**
  * @brief Advertisement data set by the programmer to be published by the %BLE server.
@@ -53,6 +53,7 @@ public:
 	void stop();
 	void setAppearance(uint16_t appearance);
 	void setAdvertisementType(esp_ble_adv_type_t adv_type);
+	void setAdvertisementChannelMap(esp_ble_adv_channel_t channel_map);
 	void setMaxInterval(uint16_t maxinterval);
 	void setMinInterval(uint16_t mininterval);
 	void setAdvertisementData(BLEAdvertisementData& advertisementData);
@@ -77,5 +78,5 @@ private:
 	bool                 m_scanResp = true;
 
 };
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_CPP_UTILS_BLEADVERTISING_H_ */

libraries/BLE/src/BLEBeacon.cpp

@@ -5,7 +5,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <string.h>
 #include "BLEBeacon.h"
 #include "esp32-hal-log.h"

libraries/BLE/src/BLECharacteristic.cpp

@@ -5,7 +5,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <sstream>
 #include <string.h>
 #include <iomanip>
@@ -800,4 +800,4 @@ void BLECharacteristicCallbacks::onStatus(BLECharacteristic* pCharacteristic, St
 } // onStatus
 
 
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */

libraries/BLE/src/BLECharacteristic.h

@@ -8,7 +8,7 @@
 #ifndef COMPONENTS_CPP_UTILS_BLECHARACTERISTIC_H_
 #define COMPONENTS_CPP_UTILS_BLECHARACTERISTIC_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <string>
 #include <map>
 #include "BLEUUID.h"
@@ -16,7 +16,7 @@
 #include <esp_gap_ble_api.h>
 #include "BLEDescriptor.h"
 #include "BLEValue.h"
-#include "RTOS.h"
+#include "FreeRTOS.h"
 
 class BLEService;
 class BLEDescriptor;
@@ -150,5 +150,5 @@ public:
 	virtual void onNotify(BLECharacteristic* pCharacteristic);
 	virtual void onStatus(BLECharacteristic* pCharacteristic, Status s, uint32_t code);
 };
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_CPP_UTILS_BLECHARACTERISTIC_H_ */

libraries/BLE/src/BLECharacteristicMap.cpp

@@ -5,7 +5,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <sstream>
 #include <iomanip>
 #include "BLEService.h"
@@ -131,4 +131,4 @@ std::string BLECharacteristicMap::toString() {
 } // toString
 
 
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */

libraries/BLE/src/BLEClient.cpp

@@ -5,7 +5,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <esp_bt.h>
 #include <esp_bt_main.h>
 #include <esp_gap_ble_api.h>
@@ -60,6 +60,7 @@ BLEClient::~BLEClient() {
 	   delete myPair.second;
 	}
 	m_servicesMap.clear();
+	m_servicesMapByInstID.clear();
 } // ~BLEClient
 
 
@@ -109,7 +110,17 @@ bool BLEClient::connect(BLEAddress address, esp_ble_addr_type_t type) {
 		return false;
 	}
 
-	m_semaphoreRegEvt.wait("connect");
+	uint32_t rc = m_semaphoreRegEvt.wait("connect");
+
+	if (rc != ESP_GATT_OK) {
+		// fixes ESP_GATT_NO_RESOURCES error mostly
+		log_e("esp_ble_gattc_app_register_error: rc=%d", rc);
+		BLEDevice::removePeerDevice(m_appId, true);
+		// not sure if this is needed here
+		// esp_ble_gattc_app_unregister(m_gattc_if);
+		// m_gattc_if = ESP_GATT_IF_NONE;
+		return false;
+	}
 
 	m_peerAddress = address;
 
@@ -127,7 +138,13 @@ bool BLEClient::connect(BLEAddress address, esp_ble_addr_type_t type) {
 		return false;
 	}
 
-	uint32_t rc = m_semaphoreOpenEvt.wait("connect");   // Wait for the connection to complete.
+	rc = m_semaphoreOpenEvt.wait("connect");   // Wait for the connection to complete.
+	// check the status of the connection and cleanup in case of failure
+	if (rc != ESP_GATT_OK) {
+		BLEDevice::removePeerDevice(m_appId, true);
+		esp_ble_gattc_app_unregister(m_gattc_if);
+		m_gattc_if = ESP_GATT_IF_NONE;
+	}
 	log_v("<< connect(), rc=%d", rc==ESP_GATT_OK);
 	return rc == ESP_GATT_OK;
 } // connect
@@ -159,6 +176,11 @@ void BLEClient::gattClientEventHandler(
 	log_d("gattClientEventHandler [esp_gatt_if: %d] ... %s",
 		gattc_if, BLEUtils::gattClientEventTypeToString(event).c_str());
 
+	// it is possible to receive events from other connections while waiting for registration
+	if (m_gattc_if == ESP_GATT_IF_NONE && event != ESP_GATTC_REG_EVT) {
+		return;
+	}
+
 	// Execute handler code based on the type of event received.
 	switch(event) {
 
@@ -183,15 +205,17 @@ void BLEClient::gattClientEventHandler(
 				if (evtParam->disconnect.conn_id != getConnId()) break;
 				// If we receive a disconnect event, set the class flag that indicates that we are
 				// no longer connected.
-				if (m_isConnected && m_pClientCallbacks != nullptr) {
-					m_pClientCallbacks->onDisconnect(this);
-				}
+				bool m_wasConnected = m_isConnected;
 				m_isConnected = false;
 				esp_ble_gattc_app_unregister(m_gattc_if);
+				m_gattc_if = ESP_GATT_IF_NONE;
 				m_semaphoreOpenEvt.give(ESP_GATT_IF_NONE);
 				m_semaphoreRssiCmplEvt.give();
 				m_semaphoreSearchCmplEvt.give(1);
 				BLEDevice::removePeerDevice(m_appId, true);
+				if (m_wasConnected && m_pClientCallbacks != nullptr) {
+					m_pClientCallbacks->onDisconnect(this);
+				}
 				break;
 		} // ESP_GATTC_DISCONNECT_EVT
 
@@ -227,7 +251,8 @@ void BLEClient::gattClientEventHandler(
 		//
 		case ESP_GATTC_REG_EVT: {
 			m_gattc_if = gattc_if;
-			m_semaphoreRegEvt.give();
+			// pass on the registration status result, in case of failure
+			m_semaphoreRegEvt.give(evtParam->reg.status);
 			break;
 		} // ESP_GATTC_REG_EVT
 
@@ -535,4 +560,4 @@ std::string BLEClient::toString() {
 } // toString
 
 
-#endif // CONFIG_BLUEDROID_ENABLED
+#endif // CONFIG_BT_ENABLED

libraries/BLE/src/BLEClient.h

@@ -9,7 +9,7 @@
 #define MAIN_BLEDEVICE_H_
 
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 
 #include <esp_gattc_api.h>
 #include <string.h>
@@ -99,5 +99,5 @@ public:
 	virtual void onDisconnect(BLEClient *pClient) = 0;
 };
 
-#endif // CONFIG_BLUEDROID_ENABLED
+#endif // CONFIG_BT_ENABLED
 #endif /* MAIN_BLEDEVICE_H_ */

libraries/BLE/src/BLEDescriptor.cpp

@@ -5,7 +5,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <sstream>
 #include <string.h>
 #include <iomanip>
@@ -284,4 +284,4 @@ void BLEDescriptorCallbacks::onWrite(BLEDescriptor* pDescriptor) {
 } // onWrite
 
 
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */

libraries/BLE/src/BLEDescriptor.h

@@ -8,12 +8,12 @@
 #ifndef COMPONENTS_CPP_UTILS_BLEDESCRIPTOR_H_
 #define COMPONENTS_CPP_UTILS_BLEDESCRIPTOR_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <string>
 #include "BLEUUID.h"
 #include "BLECharacteristic.h"
 #include <esp_gatts_api.h>
-#include "RTOS.h"
+#include "FreeRTOS.h"
 
 class BLEService;
 class BLECharacteristic;
@@ -73,5 +73,5 @@ public:
 	virtual void onRead(BLEDescriptor* pDescriptor);
 	virtual void onWrite(BLEDescriptor* pDescriptor);
 };
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */
 #endif /* COMPONENTS_CPP_UTILS_BLEDESCRIPTOR_H_ */

libraries/BLE/src/BLEDescriptorMap.cpp

@@ -5,7 +5,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <sstream>
 #include <iomanip>
 #include "BLECharacteristic.h"
@@ -145,4 +145,4 @@ BLEDescriptor* BLEDescriptorMap::getNext() {
 	m_iterator++;
 	return pRet;
 } // getNext
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */

libraries/BLE/src/BLEDevice.cpp

@@ -5,7 +5,7 @@
  *      Author: kolban
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <freertos/FreeRTOS.h>
 #include <freertos/event_groups.h>
 #include <freertos/task.h>
@@ -499,11 +499,7 @@ gatts_event_handler BLEDevice::m_customGattsHandler = nullptr;
  */
 void BLEDevice::whiteListAdd(BLEAddress address) {
 	log_v(">> whiteListAdd: %s", address.toString().c_str());
-#ifdef ESP_IDF_VERSION_MAJOR
-    esp_err_t errRc = esp_ble_gap_update_whitelist(true, *address.getNative(), BLE_WL_ADDR_TYPE_PUBLIC);  // HACK!!! True to add an entry.
-#else
-    esp_err_t errRc = esp_ble_gap_update_whitelist(true, *address.getNative());  // True to add an entry.
-#endif
+	esp_err_t errRc = esp_ble_gap_update_whitelist(true, *address.getNative());  // True to add an entry.
 	if (errRc != ESP_OK) {
 		log_e("esp_ble_gap_update_whitelist: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 	}
@@ -517,11 +513,7 @@ void BLEDevice::whiteListAdd(BLEAddress address) {
  */
 void BLEDevice::whiteListRemove(BLEAddress address) {
 	log_v(">> whiteListRemove: %s", address.toString().c_str());
-#ifdef ESP_IDF_VERSION_MAJOR
-    esp_err_t errRc = esp_ble_gap_update_whitelist(false, *address.getNative(), BLE_WL_ADDR_TYPE_PUBLIC);  // HACK!!! False to remove an entry.
-#else
-    esp_err_t errRc = esp_ble_gap_update_whitelist(false, *address.getNative());  // False to remove an entry.
-#endif
+	esp_err_t errRc = esp_ble_gap_update_whitelist(false, *address.getNative());  // False to remove an entry.
 	if (errRc != ESP_OK) {
 		log_e("esp_ble_gap_update_whitelist: rc=%d %s", errRc, GeneralUtils::errorToString(errRc));
 	}
@@ -669,4 +661,4 @@ void BLEDevice::setCustomGattsHandler(gatts_event_handler handler) {
 	m_customGattsHandler = handler;
 }
 
-#endif // CONFIG_BLUEDROID_ENABLED
+#endif // CONFIG_BT_ENABLED

libraries/BLE/src/BLEDevice.h

@@ -8,7 +8,7 @@
 #ifndef MAIN_BLEDevice_H_
 #define MAIN_BLEDevice_H_
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <esp_gap_ble_api.h> // ESP32 BLE
 #include <esp_gattc_api.h>   // ESP32 BLE
 #include <map>               // Part of C++ STL
@@ -96,5 +96,5 @@ public:
 
 }; // class BLE
 
-#endif // CONFIG_BLUEDROID_ENABLED
+#endif // CONFIG_BT_ENABLED
 #endif /* MAIN_BLEDevice_H_ */

libraries/BLE/src/BLEEddystoneTLM.cpp

@@ -10,7 +10,7 @@
  * 
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <string.h>
 #include <stdio.h>
 #include "esp32-hal-log.h"

libraries/BLE/src/BLEEddystoneURL.cpp

@@ -5,7 +5,7 @@
  *      Author: pcbreflux
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 #include <string.h>
 #include "esp32-hal-log.h"
 #include "BLEEddystoneURL.h"

libraries/BLE/src/BLEHIDDevice.cpp

@@ -5,7 +5,7 @@
  *      Author: chegewara
  */
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 
 #include "BLEHIDDevice.h"
 #include "BLE2904.h"
@@ -240,5 +240,5 @@ BLEService* BLEHIDDevice::batteryService() {
 	return m_batteryService;
 }
 
-#endif // CONFIG_BLUEDROID_ENABLED
+#endif // CONFIG_BT_ENABLED
 

libraries/BLE/src/BLEHIDDevice.h

@@ -9,7 +9,7 @@
 #define _BLEHIDDEVICE_H_
 
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 
 #include "BLECharacteristic.h"
 #include "BLEService.h"
@@ -71,5 +71,5 @@ private:
 	BLECharacteristic* 	m_protocolModeCharacteristic;	//0x2a4e
 	BLECharacteristic*	m_batteryLevelCharacteristic;	//0x2a19
 };
-#endif // CONFIG_BLUEDROID_ENABLED
+#endif // CONFIG_BT_ENABLED
 #endif /* _BLEHIDDEVICE_H_ */

libraries/BLE/src/BLERemoteCharacteristic.cpp

@@ -8,7 +8,7 @@
 #include "BLERemoteCharacteristic.h"
 
 #include "sdkconfig.h"
-#if defined(CONFIG_BLUEDROID_ENABLED)
+#if defined(CONFIG_BT_ENABLED)
 
 #include <esp_gattc_api.h>
 #include <esp_err.h>
@@ -52,6 +52,7 @@ BLERemoteCharacteristic::BLERemoteCharacteristic(
  */
 BLERemoteCharacteristic::~BLERemoteCharacteristic() {
 	removeDescriptors();   // Release resources for any descriptor information we may have allocated.
+	free(m_rawData);
 } // ~BLERemoteCharacteristic
 
 
@@ -245,6 +246,10 @@ void BLERemoteCharacteristic::gattClientEventHandler(esp_gattc_cb_event_t event,
 			}
 			break;
 
+		case ESP_GATTC_DISCONNECT_EVT:
+			m_semaphoreWriteCharEvt.give(1);
+			break;
+			
 		default:
 			break;
 	} // End switch
@@ -453,7 +458,7 @@ std::string BLERemoteCharacteristic::readValue() {
  * unregistering a notification.
  * @return N/A.
  */
-void BLERemoteCharacteristic::registerForNotify(notify_callback notifyCallback, bool notifications) {
+void BLERemoteCharacteristic::registerForNotify(notify_callback notifyCallback, bool notifications, bool descriptorRequiresRegistration) {
 	log_v(">> registerForNotify(): %s", toString().c_str());
 
 	m_notifyCallback = notifyCallback;   // Save the notification callback.
@@ -474,7 +479,7 @@ void BLERemoteCharacteristic::registerForNotify(notify_callback notifyCallback,
 		uint8_t val[] = {0x01, 0x00};
 		if(!notifications) val[0] = 0x02;
 		BLERemoteDescriptor* desc = getDescriptor(BLEUUID((uint16_t)0x2902));
-		if (desc != nullptr)
+		if (desc != nullptr && descriptorRequiresRegistration)
 			desc->writeValue(val, 2, true);
 	} // End Register
 	else {   // If we weren't passed a callback function, then this is an unregistration.
@@ -490,7 +495,7 @@ void BLERemoteCharacteristic::registerForNotify(notify_callback notifyCallback,
 
 		uint8_t val[] = {0x00, 0x00};
 		BLERemoteDescriptor* desc = getDescriptor((uint16_t)0x2902);
-		if (desc != nullptr)
+		if (desc != nullptr && descriptorRequiresRegistration)
 			desc->writeValue(val, 2, true);
 	} // End Unregister
 
@@ -613,4 +618,4 @@ void BLERemoteCharacteristic::setAuth(esp_gatt_auth_req_t auth) {
     m_auth = auth;
 }
 
-#endif /* CONFIG_BLUEDROID_ENABLED */
+#endif /* CONFIG_BT_ENABLED */