Missing include in BLE header causes compilation to fail (#3865)

SmartConfig and ETH need some work to adapt to the new API

.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-ide.sh

@@ -48,22 +48,16 @@ else
 	export ARDUINO_USR_PATH="$HOME/Arduino"
 fi
 
-# Updated as of Nov 3rd 2020
-ARDUINO_IDE_URL="https://github.com/espressif/arduino-esp32/releases/download/1.0.4/arduino-nightly-"
-
-# Currently not working
-#ARDUINO_IDE_URL="https://www.arduino.cc/download.php?f=/arduino-nightly-"
-
 if [ ! -d "$ARDUINO_IDE_PATH" ]; then
 	echo "Installing Arduino IDE on $OS_NAME ..."
-	echo "Downloading '$ARDUINO_IDE_URL$OS_NAME.$ARCHIVE_FORMAT' to 'arduino.$ARCHIVE_FORMAT' ..."
+	echo "Downloading 'arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT' to 'arduino.$ARCHIVE_FORMAT' ..."
 	if [ "$OS_IS_LINUX" == "1" ]; then
-		wget -O "arduino.$ARCHIVE_FORMAT" "$ARDUINO_IDE_URL$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
+		wget -O "arduino.$ARCHIVE_FORMAT" "https://www.arduino.cc/download.php?f=/arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
 		echo "Extracting 'arduino.$ARCHIVE_FORMAT' ..."
 		tar xf "arduino.$ARCHIVE_FORMAT" > /dev/null
 		mv arduino-nightly "$ARDUINO_IDE_PATH"
 	else
-		curl -o "arduino.$ARCHIVE_FORMAT" -L "$ARDUINO_IDE_URL$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
+		curl -o "arduino.$ARCHIVE_FORMAT" -L "https://www.arduino.cc/download.php?f=/arduino-nightly-$OS_NAME.$ARCHIVE_FORMAT" > /dev/null 2>&1
 		echo "Extracting 'arduino.$ARCHIVE_FORMAT' ..."
 		unzip "arduino.$ARCHIVE_FORMAT" > /dev/null
 		if [ "$OS_IS_MACOS" == "1" ]; then
@@ -98,8 +92,8 @@ function build_sketch(){ # build_sketch <fqbn> <path-to-ino> [extra-options]
 		win_opts="-prefs=runtime.tools.ctags.path=$ARDUINO_IDE_PATH/tools-builder/ctags/$ctags_version -prefs=runtime.tools.arduino-preprocessor.path=$ARDUINO_IDE_PATH/tools-builder/arduino-preprocessor/$preprocessor_version"
 	fi
 
-	#echo ""
-	#echo "Compiling '"$(basename "$sketch")"' ..."
+	echo ""
+	echo "Compiling '"$(basename "$sketch")"' ..."
 	mkdir -p "$ARDUINO_BUILD_DIR"
 	mkdir -p "$ARDUINO_CACHE_DIR"
 	$ARDUINO_IDE_PATH/arduino-builder -compile -logger=human -core-api-version=10810 \
@@ -116,10 +110,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
@@ -131,50 +124,49 @@ function count_sketches() # count_sketches <examples-path> <target-mcu>
         local sketchdir=$(dirname $sketch)
         local sketchdirname=$(basename $sketchdir)
         local sketchname=$(basename $sketch)
-        if [[ "$sketchdirname.ino" != "$sketchname" ]]; then
+        if [[ "${sketchdirname}.ino" != "$sketchname" ]]; then
             continue
-        elif [[ -f "$sketchdir/.skip.$target" ]]; then
+        fi;
+        if [[ -f "$sketchdir/.test.skip" ]]; then
             continue
-        else
-        	echo $sketch >> sketches.txt
-        	sketchnum=$(($sketchnum + 1))
         fi
+        echo $sketch >> sketches.txt
+        sketchnum=$(($sketchnum + 1))
     done
     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
 		echo "ERROR: Chunks count must be positive number"
 		return 1
 	fi
-	if [ "$chunk_idex" -ge "$chunks_num" ] && [ "$chunks_num" -ge 2 ]; then
+	if [ "$chunk_idex" -ge "$chunks_num" ]; then
 		echo "ERROR: Chunk index must be less than chunks count"
 		return 1
 	fi
 
 	set +e
-    count_sketches "$examples" "$target"
+    count_sketches "$examples"
     local sketchcount=$?
 	set -e
     local sketches=$(cat sketches.txt)
@@ -186,27 +178,19 @@ function build_sketches() # build_sketches <fqbn> <target-mcu> <examples-path> <
     	chunk_size=$(( $chunk_size + 1 ))
     fi
 
-    local start_index=0
-    local end_index=0
-    if [ "$chunk_idex" -ge "$chunks_num" ]; then
-    	start_index=$chunk_idex
-    	end_index=$sketchcount
-    else
-	    start_index=$(( $chunk_idex * $chunk_size ))
-	    if [ "$sketchcount" -le "$start_index" ]; then
-	    	echo "Skipping job"
-	    	return 0
-	    fi
+    local start_index=$(( $chunk_idex * $chunk_size ))
+    if [ "$sketchcount" -le "$start_index" ]; then
+    	echo "Skipping job"
+    	return 0
+    fi
 
-	    end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size ))
-	    if [ "$end_index" -gt "$sketchcount" ]; then
-	    	end_index=$sketchcount
-	    fi
-	fi
+    local end_index=$(( $(( $chunk_idex + 1 )) * $chunk_size ))
+    if [ "$end_index" -gt "$sketchcount" ]; then
+    	end_index=$sketchcount
+    fi
 
     local start_num=$(( $start_index + 1 ))
-    echo "Found $sketchcount Sketches for target '$target'";
-    echo "Chunk Index : $chunk_idex"
+    echo "Found $sketchcount Sketches";
     echo "Chunk Count : $chunks_num"
     echo "Chunk Size  : $chunk_size"
     echo "Start Sketch: $start_num"
@@ -218,7 +202,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))
@@ -226,8 +210,6 @@ function build_sketches() # build_sketches <fqbn> <target-mcu> <examples-path> <
         || [ "$sketchnum" -gt "$end_index" ]; then
         	continue
         fi
-        echo ""
-        echo "Building Sketch Index $(($sketchnum - 1)) - $sketchdirname"
         build_sketch "$fqbn" "$sketch" "$xtra_opts"
         local result=$?
         if [ $result -ne 0 ]; then

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

@@ -1,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,36 +9,40 @@ 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#feature/stage > /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()"
+if [[ "$OSTYPE" == "darwin"* ]]; then
+	sed 's/https:\/\/github\.com\/espressif\/arduino-esp32\.git/*/' "$HOME/.platformio/platforms/espressif32/platform.json" > "platform.json"
+	mv -f "platform.json" "$HOME/.platformio/platforms/espressif32/platform.json"
+else
+	sed -i 's/https:\/\/github\.com\/espressif\/arduino-esp32\.git/*/' "$HOME/.platformio/platforms/espressif32/platform.json"
+fi
 
 if [ "$GITHUB_REPOSITORY" == "espressif/arduino-esp32" ];  then
 	echo "Linking Core..."
 	ln -s $GITHUB_WORKSPACE "$PLATFORMIO_ESP32_PATH"
 else
 	echo "Cloning Core Repository ..."
-	git clone --recursive https://github.com/espressif/arduino-esp32.git "$PLATFORMIO_ESP32_PATH" > /dev/null 2>&1
+	git clone https://github.com/espressif/arduino-esp32.git "$PLATFORMIO_ESP32_PATH" > /dev/null 2>&1
 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 +71,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 +143,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,15 +87,9 @@ 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

@@ -24,7 +24,7 @@ BUILD_PIO=0
 if [ "$#" -lt 2 ] || [ "$CHUNKS_CNT" -le 0 ]; then
 	CHUNK_INDEX=0
 	CHUNKS_CNT=1
-elif [ "$CHUNK_INDEX" -gt "$CHUNKS_CNT" ] &&  [ "$CHUNKS_CNT" -ge 2 ]; then
+elif [ "$CHUNK_INDEX" -gt "$CHUNKS_CNT" ]; then
 	CHUNK_INDEX=$CHUNKS_CNT
 elif [ "$CHUNK_INDEX" -eq "$CHUNKS_CNT" ]; then
 	BUILD_PIO=1
@@ -34,8 +34,7 @@ fi
 #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
@@ -54,51 +53,16 @@ if [ "$BUILD_PIO" -eq 0 ]; then
 		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
-
-	# ArduinoIDE ESP32C3 Test
-    TARGET="esp32c3"
-	FQBN="espressif:esp32:esp32c3:PartitionScheme=huge_app"
-	if [ "$OS_IS_WINDOWS" == "1" ]; then
-		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFi/examples/WiFiClient/WiFiClient.ino" && \
-		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino"
-	elif [ "$OS_IS_MACOS" == "1" ]; then
-		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFi/examples/WiFiClient/WiFiClient.ino" && \
-		build_sketch "$FQBN" "$ARDUINO_ESP32_PATH/libraries/WiFiClientSecure/examples/WiFiClientSecure/WiFiClientSecure.ino"
-	else
-		build_sketches "$FQBN" "$TARGET" "$ARDUINO_ESP32_PATH/libraries" "$CHUNK_INDEX" "$CHUNKS_CNT"
-    fi
 else
+	# 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/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino"
+	#build_pio_sketches esp32dev "$PLATFORMIO_ESP32_PATH/libraries"
 fi

.github/scripts/on-release.sh

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

.github/stale.yml

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

.github/workflows/gh-pages.yml

@@ -4,12 +4,9 @@ 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,8 +11,6 @@ jobs:
 
     steps:
     - uses: actions/checkout@master
-      with:
-        fetch-depth: 0
     - uses: actions/setup-python@v1
       with:
         python-version: '3.x'

.gitignore

@@ -1,11 +1,9 @@
 tools/xtensa-esp32-elf
-tools/xtensa-esp32s2-elf
-tools/riscv32-esp-elf
 tools/dist
 tools/esptool
 tools/esptool.exe
-tools/mkspiffs
-tools/mklittlefs
+tools/mkspiffs/mkspiffs
+tools/mkspiffs/mkspiffs.exe
 .DS_Store
  
 #Ignore files built by Visual Studio/Visual Micro
@@ -14,7 +12,3 @@ tools/mklittlefs
 .vs/
 __vm/
 *.vcxproj*
-.vscode/
-platform.sloeber.txt
-boards.sloeber.txt
-tools/mklittlefs

CMakeLists.txt

@@ -7,7 +7,6 @@ set(CORE_SRCS
   cores/esp32/esp32-hal-dac.c
   cores/esp32/esp32-hal-gpio.c
   cores/esp32/esp32-hal-i2c.c
-  cores/esp32/esp32-hal-log.c
   cores/esp32/esp32-hal-ledc.c
   cores/esp32/esp32-hal-matrix.c
   cores/esp32/esp32-hal-misc.c
@@ -16,7 +15,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
@@ -33,8 +31,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
@@ -45,9 +41,6 @@ set(LIBRARY_SRCS
   libraries/ArduinoOTA/src/ArduinoOTA.cpp
   libraries/AsyncUDP/src/AsyncUDP.cpp
   libraries/BluetoothSerial/src/BluetoothSerial.cpp
-  libraries/BluetoothSerial/src/BTAddress.cpp
-  libraries/BluetoothSerial/src/BTAdvertisedDeviceSet.cpp
-  libraries/BluetoothSerial/src/BTScanResultsSet.cpp
   libraries/DNSServer/src/DNSServer.cpp
   libraries/EEPROM/src/EEPROM.cpp
   libraries/ESPmDNS/src/ESPmDNS.cpp
@@ -56,14 +49,8 @@ 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/RainMaker/src/RMaker.cpp
-  libraries/RainMaker/src/RMakerNode.cpp
-  libraries/RainMaker/src/RMakerParam.cpp
-  libraries/RainMaker/src/RMakerDevice.cpp
-  libraries/RainMaker/src/RMakerType.cpp
   libraries/SD_MMC/src/SD_MMC.cpp
   libraries/SD/src/SD.cpp
   libraries/SD/src/sd_diskio.cpp
@@ -73,7 +60,6 @@ set(LIBRARY_SRCS
   libraries/SPI/src/SPI.cpp
   libraries/Ticker/src/Ticker.cpp
   libraries/Update/src/Updater.cpp
-  libraries/Update/src/HttpsOTAUpdate.cpp
   libraries/WebServer/src/WebServer.cpp
   libraries/WebServer/src/Parsing.cpp
   libraries/WebServer/src/detail/mimetable.cpp
@@ -89,7 +75,6 @@ set(LIBRARY_SRCS
   libraries/WiFi/src/WiFiServer.cpp
   libraries/WiFi/src/WiFiSTA.cpp
   libraries/WiFi/src/WiFiUdp.cpp
-  libraries/WiFiProv/src/WiFiProv.cpp
   libraries/Wire/src/Wire.cpp
   )
 
@@ -125,9 +110,10 @@ set(BLE_SRCS
   libraries/BLE/src/GeneralUtils.cpp
   )
 
+set(COMPONENT_SRCS ${CORE_SRCS} ${LIBRARY_SRCS} ${BLE_SRCS})
 
-set(includedirs
-  variants/${IDF_TARGET}/
+set(COMPONENT_ADD_INCLUDEDIRS
+  variants/esp32/
   cores/esp32/
   libraries/ArduinoOTA/src
   libraries/AsyncUDP/src
@@ -141,10 +127,8 @@ set(includedirs
   libraries/FS/src
   libraries/HTTPClient/src
   libraries/HTTPUpdate/src
-  libraries/LITTLEFS/src
   libraries/NetBIOS/src
   libraries/Preferences/src
-  libraries/RainMaker/src
   libraries/SD_MMC/src
   libraries/SD/src
   libraries/SimpleBLE/src
@@ -155,27 +139,12 @@ set(includedirs
   libraries/WebServer/src
   libraries/WiFiClientSecure/src
   libraries/WiFi/src
-  libraries/WiFiProv/src
   libraries/Wire/src
   )
 
-set(srcs ${CORE_SRCS} ${LIBRARY_SRCS} ${BLE_SRCS})
-set(priv_includes cores/esp32/libb64)
-set(requires spi_flash mbedtls mdns esp_adc_cal)
-set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support openssl bt arduino_tinyusb main)
+set(COMPONENT_PRIV_INCLUDEDIRS cores/esp32/libb64)
 
-if(NOT CONFIG_ARDUINO_SELECTIVE_COMPILATION OR CONFIG_ARDUINO_SELECTIVE_ArduinoOTA)
-  list(APPEND priv_requires esp_https_ota)
-endif()
-if(NOT CONFIG_ARDUINO_SELECTIVE_COMPILATION OR CONFIG_ARDUINO_SELECTIVE_LITTLEFS)
-  list(APPEND priv_requires esp_littlefs)
-endif()
+set(COMPONENT_REQUIRES spi_flash mbedtls mdns esp_adc_cal)
+set(COMPONENT_PRIV_REQUIRES fatfs nvs_flash app_update spiffs bootloader_support openssl bt)
 
-idf_component_register(INCLUDE_DIRS ${includedirs} PRIV_INCLUDE_DIRS ${priv_includes} SRCS ${srcs} REQUIRES ${requires} PRIV_REQUIRES ${priv_requires})
-
-if(IDF_TARGET STREQUAL "esp32")
-target_compile_options(${COMPONENT_TARGET} PUBLIC -DARDUINO=10812 -DARDUINO_ESP32_DEV -DARDUINO_ARCH_ESP32 -DARDUINO_BOARD="ESP32_DEV" -DARDUINO_VARIANT="esp32" -DESP32)
-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()

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

README.md

@@ -11,11 +11,9 @@
 - [ESP32Dev Board PINMAP](#esp32dev-board-pinmap)
 
 ### Development Status
+[Latest stable release ![Release Version](https://img.shields.io/github/release/espressif/arduino-esp32.svg?style=plastic) ![Release Date](https://img.shields.io/github/release-date/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) ![Downloads](https://img.shields.io/github/downloads/espressif/arduino-esp32/latest/total.svg?style=plastic)
 
-Latest Stable Release  [![Release Version](https://img.shields.io/github/release/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) [![Release Date](https://img.shields.io/github/release-date/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) [![Downloads](https://img.shields.io/github/downloads/espressif/arduino-esp32/latest/total.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/)
-
-Latest Development Release  [![Release Version](https://img.shields.io/github/release/espressif/arduino-esp32/all.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) [![Release Date](https://img.shields.io/github/release-date-pre/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) [![Downloads](https://img.shields.io/github/downloads-pre/espressif/arduino-esp32/latest/total.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/)
-
+[Latest development release ![Development Version](https://img.shields.io/github/release/espressif/arduino-esp32/all.svg?style=plastic) ![Development Date](https://img.shields.io/github/release-date-pre/espressif/arduino-esp32.svg?style=plastic)](https://github.com/espressif/arduino-esp32/releases/latest/) ![Downloads](https://img.shields.io/github/downloads-pre/espressif/arduino-esp32/latest/total.svg?style=plastic)
 
 ### Installation Instructions
 - Using Arduino IDE Boards Manager (preferred)
@@ -44,8 +42,6 @@ Finally, if you are sure no one else had the issue, follow the [ISSUE_TEMPLATE](
 
 ![Pin Functions](docs/esp32_pinmap.png)
 
-![ESP32S2_Pinmap](docs/esp32s2_pinmap.png)
-
 ### Tip
 
 Sometimes to program ESP32 via serial you must keep GPIO0 LOW during the programming process

cores/esp32/Arduino.h

@@ -29,7 +29,6 @@
 #include <string.h>
 #include <inttypes.h>
 
-#include "esp_arduino_version.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "freertos/semphr.h"
@@ -79,7 +78,7 @@
 #define interrupts() sei()
 #define noInterrupts() cli()
 
-#define clockCyclesPerMicrosecond() ( (long int)getCpuFrequencyMhz() )
+#define clockCyclesPerMicrosecond() ( F_CPU / 1000000L )
 #define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() )
 #define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() )
 
@@ -89,7 +88,7 @@
 #define bitRead(value, bit) (((value) >> (bit)) & 0x01)
 #define bitSet(value, bit) ((value) |= (1UL << (bit)))
 #define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
-#define bitWrite(value, bit, bitvalue) ((bitvalue) ? bitSet(value, bit) : bitClear(value, bit))
+#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))
 
 // avr-libc defines _NOP() since 1.6.2
 #ifndef _NOP
@@ -116,10 +115,10 @@ typedef bool boolean;
 typedef uint8_t byte;
 typedef unsigned int word;
 
-#ifdef __cplusplus
 void setup(void);
 void loop(void);
 
+#ifdef __cplusplus
 long random(long, long);
 #endif
 void randomSeed(unsigned long);

cores/esp32/Esp.cpp

@@ -23,6 +23,7 @@
 #include "esp_spi_flash.h"
 #include <memory>
 #include <soc/soc.h>
+#include <soc/efuse_reg.h>
 #include <esp_partition.h>
 extern "C" {
 #include "esp_ota_ops.h"
@@ -34,11 +35,6 @@ extern "C" {
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/spi_flash.h"
-#include "soc/efuse_reg.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/spi_flash.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/spi_flash.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -135,36 +131,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,43 +228,6 @@ uint8_t EspClass::getChipRevision(void)
     return chip_info.revision;
 }
 
-const char * EspClass::getChipModel(void)
-{
-#if CONFIG_IDF_TARGET_ESP32
-    uint32_t chip_ver = REG_GET_FIELD(EFUSE_BLK0_RDATA3_REG, EFUSE_RD_CHIP_VER_PKG);
-    uint32_t pkg_ver = chip_ver & 0x7;
-    switch (pkg_ver) {
-        case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ6 :
-            return "ESP32-D0WDQ6";
-        case EFUSE_RD_CHIP_VER_PKG_ESP32D0WDQ5 :
-            return "ESP32-D0WDQ5";
-        case EFUSE_RD_CHIP_VER_PKG_ESP32D2WDQ5 :
-            return "ESP32-D2WDQ5";
-        case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD2 :
-            return "ESP32-PICO-D2";
-        case EFUSE_RD_CHIP_VER_PKG_ESP32PICOD4 :
-            return "ESP32-PICO-D4";
-        case EFUSE_RD_CHIP_VER_PKG_ESP32PICOV302 :
-            return "ESP32-PICO-V3-02";
-        default:
-            return "Unknown";
-    }
-#elif CONFIG_IDF_TARGET_ESP32S2
-    return "ESP32-S2";
-#elif CONFIG_IDF_TARGET_ESP32S3
-    return "ESP32-S3";
-#elif CONFIG_IDF_TARGET_ESP32C3
-    return "ESP32-C3";
-#endif
-}
-
-uint8_t EspClass::getChipCores(void)
-{
-    esp_chip_info_t chip_info;
-    esp_chip_info(&chip_info);
-    return chip_info.cores;
-}
-
 const char * EspClass::getSdkVersion(void)
 {
     return esp_get_idf_version();
@@ -372,20 +319,6 @@ bool EspClass::flashRead(uint32_t offset, uint32_t *data, size_t size)
     return spi_flash_read(offset, (uint32_t*) data, size) == ESP_OK;
 }
 
-bool EspClass::partitionEraseRange(const esp_partition_t *partition, uint32_t offset, size_t size) 
-{
-    return esp_partition_erase_range(partition, offset, size) == ESP_OK;
-}
-
-bool EspClass::partitionWrite(const esp_partition_t *partition, uint32_t offset, uint32_t *data, size_t size) 
-{
-    return esp_partition_write(partition, offset, data, size) == ESP_OK;
-}
-
-bool EspClass::partitionRead(const esp_partition_t *partition, uint32_t offset, uint32_t *data, size_t size) 
-{
-    return esp_partition_read(partition, offset, data, size) == ESP_OK;
-}
 
 uint64_t EspClass::getEfuseMac(void)
 {

cores/esp32/Esp.h

@@ -21,7 +21,6 @@
 #define ESP_H
 
 #include <Arduino.h>
-#include <esp_partition.h>
 
 /**
  * AVR macros for WDT managment
@@ -76,8 +75,6 @@ public:
     uint32_t getMaxAllocPsram();
 
     uint8_t getChipRevision();
-    const char * getChipModel();
-    uint8_t getChipCores();
     uint32_t getCpuFreqMHz(){ return getCpuFrequencyMhz(); }
     inline uint32_t getCycleCount() __attribute__((always_inline));
     const char * getSdkVersion();
@@ -100,15 +97,11 @@ public:
     bool flashWrite(uint32_t offset, uint32_t *data, size_t size);
     bool flashRead(uint32_t offset, uint32_t *data, size_t size);
 
-    bool partitionEraseRange(const esp_partition_t *partition, uint32_t offset, size_t size);
-    bool partitionWrite(const esp_partition_t *partition, uint32_t offset, uint32_t *data, size_t size);
-    bool partitionRead(const esp_partition_t *partition, uint32_t offset, uint32_t *data, size_t size);
-
     uint64_t getEfuseMac();
 
 };
 
-uint32_t ARDUINO_ISR_ATTR EspClass::getCycleCount()
+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,33 +22,15 @@
 #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) {}
 
-void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert, unsigned long timeout_ms, uint8_t rxfifo_full_thrhd)
+void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert, unsigned long timeout_ms)
 {
     if(0 > _uart_nr || _uart_nr > 2) {
         log_e("Serial number is invalid, please use 0, 1 or 2");
@@ -60,30 +40,19 @@ 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;
-#elif CONFIG_IDF_TARGET_ESP32C3
-        rxPin = 20;
-        txPin = 21;
-#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, rxfifo_full_thrhd);
-    _tx_pin = txPin;
-    _rx_pin = rxPin;
+
+    _uart = uartBegin(_uart_nr, baud ? baud : 9600, config, rxPin, txPin, 256, invert);
 
     if(!baud) {
         uartStartDetectBaudrate(_uart);
@@ -97,12 +66,10 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
 
         if(detectedBaudRate) {
             delay(100); // Give some time...
-            _uart = uartBegin(_uart_nr, detectedBaudRate, config, rxPin, txPin, 256, invert, rxfifo_full_thrhd);
+            _uart = uartBegin(_uart_nr, detectedBaudRate, config, rxPin, txPin, 256, invert);
         } else {
             log_e("Could not detect baudrate. Serial data at the port must be present within the timeout for detection to be possible");
             _uart = NULL;
-            _tx_pin = 255;
-            _rx_pin = 255;
         }
     }
 }
@@ -117,9 +84,7 @@ void HardwareSerial::end()
     if(uartGetDebug() == _uart_nr) {
         uartSetDebug(0);
     }
-    delay(10);
-    log_v("pins %d %d",_tx_pin, _rx_pin);
-    uartEnd(_uart, _tx_pin, _rx_pin);
+    uartEnd(_uart);
     _uart = 0;
 }
 
@@ -136,7 +101,7 @@ void HardwareSerial::setDebugOutput(bool en)
         uartSetDebug(_uart);
     } else {
         if(uartGetDebug() == _uart_nr) {
-            uartSetDebug(NULL);
+            uartSetDebug(0);
         }
     }
 }
@@ -214,8 +179,3 @@ HardwareSerial::operator bool() const
 {
     return true;
 }
-
-void HardwareSerial::setRxInvert(bool invert)
-{
-    uartSetRxInvert(_uart, invert);
-}

cores/esp32/HardwareSerial.h

@@ -55,7 +55,7 @@ class HardwareSerial: public Stream
 public:
     HardwareSerial(int uart_nr);
 
-    void begin(unsigned long baud, uint32_t config=SERIAL_8N1, int8_t rxPin=-1, int8_t txPin=-1, bool invert=false, unsigned long timeout_ms = 20000UL, uint8_t rxfifo_full_thrhd = 112);
+    void begin(unsigned long baud, uint32_t config=SERIAL_8N1, int8_t rxPin=-1, int8_t txPin=-1, bool invert=false, unsigned long timeout_ms = 20000UL);
     void end();
     void updateBaudRate(unsigned long baud);
     int available(void);
@@ -100,33 +100,18 @@ public:
 
     size_t setRxBufferSize(size_t);
     void setDebugOutput(bool);
-    
-    void setRxInvert(bool);
 
 protected:
     int _uart_nr;
     uart_t* _uart;
-    uint8_t _tx_pin;
-    uint8_t _rx_pin;
 };
 
 extern void serialEventRun(void) __attribute__((weak));
 
 #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

@@ -26,10 +26,6 @@
 #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"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/md5_hash.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif

cores/esp32/Print.cpp

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

cores/esp32/Print.h

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

cores/esp32/Stream.cpp

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

cores/esp32/Stream.h

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

cores/esp32/USB.cpp

@@ -1,334 +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_TINYUSB_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
-
-#if CFG_TUD_DFU_RUNTIME
-static uint16_t load_dfu_descriptor(uint8_t * dst, uint8_t * itf)
-{
-#define DFU_ATTR_CAN_DOWNLOAD              1
-#define DFU_ATTR_CAN_UPLOAD                2
-#define DFU_ATTR_MANIFESTATION_TOLERANT    4
-#define DFU_ATTR_WILL_DETACH               8
-#define DFU_ATTRS (DFU_ATTR_CAN_DOWNLOAD | DFU_ATTR_CAN_UPLOAD | DFU_ATTR_MANIFESTATION_TOLERANT)
-
-    uint8_t str_index = tinyusb_add_string_descriptor("TinyUSB DFU_RT");
-    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_RUNTIME */
-
-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_RUNTIME
-    return tinyusb_enable_interface(USB_INTERFACE_DFU, TUD_DFU_RT_DESC_LEN, load_dfu_descriptor) == ESP_OK;
-#endif /* CFG_TUD_DFU_RUNTIME */
-    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_TINYUSB_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_TINYUSB_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_TINYUSB_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_TINYUSB_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);
-
-#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){
-        if(bit_rate == 9600 && _bit_rate == 1200){
-            usb_persist_restart(RESTART_BOOTLOADER);
-        } else {
-            bit_rate = _bit_rate;
-            data_bits = _data_bits;
-            stop_bits = _stop_bits;
-            parity = _parity;
-            arduino_usb_cdc_event_data_t p = {0};
-            p.line_coding.bit_rate = bit_rate;
-            p.line_coding.data_bits = data_bits;
-            p.line_coding.stop_bits = stop_bits;
-            p.line_coding.parity = parity;
-            arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_LINE_CODING_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
-        }
-    }
-}
-
-void USBCDC::_onRX(){
-    uint8_t buf[CONFIG_TINYUSB_CDC_RX_BUFSIZE+1];
-    uint32_t count = tud_cdc_n_read(itf, buf, CONFIG_TINYUSB_CDC_RX_BUFSIZE);
-    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_TINYUSB_CDC_ENABLED */
-
-#endif /* CONFIG_TINYUSB_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_TINYUSB_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_TINYUSB_CDC_ENABLED */

cores/esp32/Udp.h

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

cores/esp32/WMath.cpp

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

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);
-        setBuffer(newbuffer);
         setLen(oldLen); // Needed in case of SSO where len() never existed
+        setBuffer(newbuffer);
         return 1;
     }
     return 0;
@@ -209,8 +209,8 @@ String & String::copy(const char *cstr, unsigned int length) {
         invalidate();
         return *this;
     }
-    memmove(wbuffer(), cstr, length + 1);
     setLen(length);
+    memmove(wbuffer(), cstr, length + 1);
     return *this;
 }
 
@@ -219,8 +219,8 @@ String & String::copy(const __FlashStringHelper *pstr, unsigned int length) {
         invalidate();
         return *this;
     }
-    memcpy_P(wbuffer(), (PGM_P)pstr, length + 1); // We know wbuffer() cannot ever be in PROGMEM, so memcpy safe here
     setLen(length);
+    memcpy_P(wbuffer(), (PGM_P)pstr, length + 1); // We know wbuffer() cannot ever be in PROGMEM, so memcpy safe here
     return *this;
 }
 
@@ -250,8 +250,8 @@ void String::move(String &rhs) {
     setLen(rhs.len());
     rhs.setSSO(false);
     rhs.setCapacity(0);
-    rhs.setBuffer(nullptr);
     rhs.setLen(0);
+    rhs.setBuffer(nullptr);
 }
 #endif
 
@@ -744,7 +744,6 @@ void String::replace(const String& find, const String& replace) {
         }
     } else if(diff < 0) {
         char *writeTo = wbuffer();
-        unsigned int l = len();
         while((foundAt = strstr(readFrom, find.buffer())) != NULL) {
             unsigned int n = foundAt - readFrom;
             memmove(writeTo, readFrom, n);
@@ -752,10 +751,9 @@ void String::replace(const String& find, const String& replace) {
             memmove(writeTo, replace.buffer(), replace.len());
             writeTo += replace.len();
             readFrom = foundAt + find.len();
-            l += diff;
+            setLen(len() + diff);
         }
         memmove(writeTo, readFrom, strlen(readFrom)+1);
-        setLen(l);
     } else {
         unsigned int size = len(); // compute size needed for result
         while((foundAt = strstr(readFrom, find.buffer())) != NULL) {
@@ -770,7 +768,7 @@ void String::replace(const String& find, const String& replace) {
         while(index >= 0 && (index = lastIndexOf(find, index)) >= 0) {
             readFrom = wbuffer() + index + find.len();
             memmove(readFrom + diff, readFrom, len() - (readFrom - buffer()));
-            int newLen = len() + diff;
+	    int newLen = len() + diff;
             memmove(wbuffer() + index, replace.buffer(), replace.len());
             setLen(newLen);
             wbuffer()[newLen] = 0;
@@ -798,8 +796,8 @@ void String::remove(unsigned int index, unsigned int count) {
     }
     char *writeTo = wbuffer() + index;
     unsigned int newlen = len() - count;
-    memmove(writeTo, wbuffer() + index + count, newlen - index);
     setLen(newlen);
+    memmove(writeTo, wbuffer() + index + count, newlen - index);
     wbuffer()[newlen] = 0;
 }
 
@@ -829,9 +827,9 @@ void String::trim(void) {
     while(isspace(*end) && end >= begin)
         end--;
     unsigned int newlen = end + 1 - begin;
+    setLen(newlen);
     if(begin > buffer())
         memmove(wbuffer(), begin, newlen);
-    setLen(newlen);
     wbuffer()[newlen] = 0;
 }
 

cores/esp32/WString.h

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

cores/esp32/esp32-hal-adc.c

@@ -16,27 +16,18 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_attr.h"
+#include "soc/rtc_io_reg.h"
 #include "soc/rtc_cntl_reg.h"
+#include "soc/sens_reg.h"
+
 #include "driver/adc.h"
+#include "esp_adc_cal.h"
 
 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "esp_adc_cal.h"
-#include "soc/sens_reg.h"
-#include "soc/rtc_io_reg.h"
 #include "esp32/rom/ets_sys.h"
 #include "esp_intr_alloc.h"
-#define DEFAULT_VREF    1100
-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"
-#include "soc/sens_reg.h"
-#include "soc/rtc_io_reg.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -45,26 +36,14 @@ static uint8_t __analogVRefPin = 0;
 #include "esp_intr.h"
 #endif
 
+#define DEFAULT_VREF    1100
+static esp_adc_cal_characteristics_t *__analogCharacteristics[2] = {NULL, NULL};
 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 __analogSetClockDiv(uint8_t clockDiv){
-    if(!clockDiv){
-        clockDiv = 1;
-    }
-    __analogClockDiv = clockDiv;
-#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2
-    adc_set_clk_div(__analogClockDiv);
-#endif
-}
-
-void __analogSetAttenuation(adc_attenuation_t attenuation)
-{
-    __analogAttenuation = attenuation & 3;
-}
-
-#if CONFIG_IDF_TARGET_ESP32
 void __analogSetWidth(uint8_t bits){
     if(bits < 9){
         bits = 9;
@@ -74,7 +53,19 @@ void __analogSetWidth(uint8_t bits){
     __analogWidth = bits - 9;
     adc1_config_width(__analogWidth);
 }
-#endif
+
+void __analogSetClockDiv(uint8_t clockDiv){
+    if(!clockDiv){
+        clockDiv = 1;
+    }
+    __analogClockDiv = clockDiv;
+    adc_set_clk_div(__analogClockDiv);
+}
+
+void __analogSetAttenuation(adc_attenuation_t attenuation)
+{
+    __analogAttenuation = attenuation & 3;
+}
 
 void __analogInit(){
     static bool initialized = false;
@@ -83,9 +74,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)
@@ -110,7 +99,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))
@@ -118,15 +106,11 @@ bool __adcAttachPin(uint8_t pin){
                     | (1 << (pad + SENS_TOUCH_PAD_WORKEN_S)));
             WRITE_PERI_REG(SENS_SAR_TOUCH_ENABLE_REG, touch);
         }
-#endif
-    }
-#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2
-    else if(pin == 25){
+    } else if(pin == 25){
         CLEAR_PERI_REG_MASK(RTC_IO_PAD_DAC1_REG, RTC_IO_PDAC1_XPD_DAC | RTC_IO_PDAC1_DAC_XPD_FORCE);//stop dac1
     } else if(pin == 26){
         CLEAR_PERI_REG_MASK(RTC_IO_PAD_DAC2_REG, RTC_IO_PDAC2_XPD_DAC | RTC_IO_PDAC2_DAC_XPD_FORCE);//stop dac2
     }
-#endif
 
     pinMode(pin, ANALOG);
     __analogSetPinAttenuation(pin, __analogAttenuation);
@@ -138,9 +122,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)
@@ -171,13 +153,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");
@@ -191,7 +179,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);
@@ -222,27 +210,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
@@ -268,20 +235,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,12 +18,11 @@
 
 bool btInUse(){ return true; }
 
+#ifdef CONFIG_BLUEDROID_ENABLED
 #include "esp_bt.h"
 
-#ifdef CONFIG_BTDM_CONTROLLER_MODE_BTDM
+#ifdef CONFIG_CLASSIC_BT_ENABLED
 #define BT_MODE ESP_BT_MODE_BTDM
-#elif defined(CONFIG_BTDM_CONTROLLER_MODE_BR_EDR_ONLY)
-#define BT_MODE ESP_BT_MODE_CLASSIC_BT
 #else
 #define BT_MODE ESP_BT_MODE_BLE
 #endif
@@ -80,7 +79,7 @@ bool btStop(){
     return false;
 }
 
-#else // CONFIG_BT_ENABLED
+#else
 bool btStarted()
 {
     return false;
@@ -95,6 +94,6 @@ bool btStop()
 {
     return false;
 }
-
-#endif // CONFIG_BT_ENABLED
+#endif
+#endif
 

cores/esp32/esp32-hal-cpu.c

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

cores/esp32/esp32-hal-dac.c

@@ -12,52 +12,54 @@
 // 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 "esp_attr.h"
+#include "soc/rtc_io_reg.h"
+#include "soc/rtc_cntl_reg.h"
+#include "soc/sens_reg.h"
 
-#if CONFIG_IDF_TARGET_ESP32
-#include "soc/rtc_io_reg.h"
-#define DAC1 25
-#define DAC2 26
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/rtc_io_reg.h"
-#define DAC1 17
-#define DAC2 18
-#elif CONFIG_IDF_TARGET_ESP32C3
-#define NODAC
-#else
+#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"
+#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
 
-#ifndef NODAC
-#include "esp_attr.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"
-
-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")));
-
-#endif

cores/esp32/esp32-hal-gpio.c

@@ -13,32 +13,22 @@
 // limitations under the License.
 
 #include "esp32-hal-gpio.h"
-#include "pins_arduino.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_attr.h"
 #include "soc/gpio_reg.h"
 #include "soc/io_mux_reg.h"
 #include "soc/gpio_struct.h"
-#include "driver/gpio.h"
-#include "esp_system.h"
+#include "soc/rtc_io_reg.h"
 
+#include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
 #include "esp32/rom/ets_sys.h"
 #include "esp32/rom/gpio.h"
 #include "esp_intr_alloc.h"
-#include "soc/rtc_io_reg.h"
-#define GPIO_FUNC 2
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "esp32s2/rom/ets_sys.h"
-#include "esp32s2/rom/gpio.h"
-#include "esp_intr_alloc.h"
-#include "soc/periph_defs.h"
-#include "soc/rtc_io_reg.h"
-#define GPIO_FUNC 1
 #else 
-#define USE_ESP_IDF_GPIO 1
+#error Target CONFIG_IDF_TARGET is not supported
 #endif
 #else // ESP32 Before IDF 4.0
 #include "rom/ets_sys.h"
@@ -46,14 +36,9 @@
 #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},
@@ -94,56 +79,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);
@@ -153,95 +88,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 USE_ESP_IDF_GPIO
-	if (!GPIO_IS_VALID_GPIO(pin)) {
-		return;
-	}
-	gpio_config_t conf = {
-		    .pin_bit_mask = (1ULL<<pin),			/*!< GPIO pin: set with bit mask, each bit maps to a GPIO */
-		    .mode = GPIO_MODE_DISABLE,              /*!< GPIO mode: set input/output mode                     */
-		    .pull_up_en = GPIO_PULLUP_DISABLE,      /*!< GPIO pull-up                                         */
-		    .pull_down_en = GPIO_PULLDOWN_DISABLE,  /*!< GPIO pull-down                                       */
-		    .intr_type = GPIO_INTR_DISABLE      	/*!< GPIO interrupt type                                  */
-	};
-	if (mode < 0x20) {//io
-		conf.mode = mode & (INPUT | OUTPUT);
-		if (mode & OPEN_DRAIN) {
-			conf.mode |= GPIO_MODE_DEF_OD;
-		}
-		if (mode & PULLUP) {
-			conf.pull_up_en = GPIO_PULLUP_ENABLE;
-		}
-		if (mode & PULLDOWN) {
-			conf.pull_down_en = GPIO_PULLDOWN_ENABLE;
-		}
-	}
-	gpio_config(&conf);
 
-	if(mode == SPECIAL){
-#if CONFIG_IDF_TARGET_ESP32
-		PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[pin], (uint32_t)(((pin)==RX||(pin)==TX)?0:1));
-#elif CONFIG_IDF_TARGET_ESP32S2
-		PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[pin], (uint32_t)(((pin)==RX||(pin)==TX)?0:2));
-#endif
-	} else if(mode == ANALOG){
-#if !CONFIG_IDF_TARGET_ESP32C3
-		//adc_gpio_init(ADC_UNIT_1, ADC_CHANNEL_0);
-#endif
-	} else if(mode >= 0x20 && mode < ANALOG) {//function
-		PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[pin], mode >> 5);
-	}
-#else
     if(!digitalPinIsValid(pin)) {
         return;
     }
 
-    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);
@@ -249,8 +145,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 {
@@ -268,13 +165,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)) {
-        pinFunction |= ((uint32_t)PIN_FUNC_GPIO << MCU_SEL_S);
+        pinFunction |= ((uint32_t)2 << MCU_SEL_S);
     } 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);
     }
@@ -286,67 +179,39 @@ extern void ARDUINO_ISR_ATTR __pinMode(uint8_t pin, uint8_t mode)
     }
 
     GPIO.pin[pin].val = pinControl;
-#endif
+    //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 USE_ESP_IDF_GPIO
-	gpio_set_level((gpio_num_t)pin, val);
-#elif CONFIG_IDF_TARGET_ESP32C3
-    if (val) {
-    	GPIO.out_w1ts.out_w1ts = (1 << pin);
-    } else {
-    	GPIO.out_w1tc.out_w1tc = (1 << pin);
-    }
-#else
     if(val) {
         if(pin < 32) {
             GPIO.out_w1ts = ((uint32_t)1 << pin);
-        } 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));
         }
     }
-#endif
 }
 
-extern int ARDUINO_ISR_ATTR __digitalRead(uint8_t pin)
+extern int IRAM_ATTR __digitalRead(uint8_t pin)
 {
-#if USE_ESP_IDF_GPIO
-	return gpio_get_level((gpio_num_t)pin);
-#elif CONFIG_IDF_TARGET_ESP32C3
-	return (GPIO.in.data >> pin) & 0x1;
-#else
     if(pin < 32) {
         return (GPIO.in >> pin) & 0x1;
-    } else if(pin < GPIO_PIN_COUNT) {
+    } else if(pin < 40) {
         return (GPIO.in1.val >> (pin - 32)) & 0x1;
     }
     return 0;
-#endif
 }
 
-#if USE_ESP_IDF_GPIO
-static void ARDUINO_ISR_ATTR __onPinInterrupt(void * arg) {
-	InterruptHandle_t * isr = (InterruptHandle_t*)arg;
-    if(isr->fn) {
-        if(isr->arg){
-            ((voidFuncPtrArg)isr->fn)(isr->arg);
-        } else {
-        	isr->fn();
-        }
-    }
-}
-#else
 static intr_handle_t gpio_intr_handle = NULL;
 
-static void ARDUINO_ISR_ATTR __onPinInterrupt()
+static void IRAM_ATTR __onPinInterrupt()
 {
     uint32_t gpio_intr_status_l=0;
     uint32_t gpio_intr_status_h=0;
@@ -385,7 +250,6 @@ static void ARDUINO_ISR_ATTR __onPinInterrupt()
         } while(++pin<GPIO_PIN_COUNT);
     }
 }
-#endif
 
 extern void cleanupFunctional(void* arg);
 
@@ -394,17 +258,8 @@ extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc,
     static bool interrupt_initialized = false;
 
     if(!interrupt_initialized) {
-#if USE_ESP_IDF_GPIO
-    	esp_err_t err = gpio_install_isr_service((int)ARDUINO_ISR_FLAG);
-    	interrupt_initialized = (err == ESP_OK) || (err == ESP_ERR_INVALID_STATE);
-#else
         interrupt_initialized = true;
-        esp_intr_alloc(ETS_GPIO_INTR_SOURCE, (int)ARDUINO_ISR_FLAG, __onPinInterrupt, NULL, &gpio_intr_handle);
-#endif
-    }
-    if(!interrupt_initialized) {
-    	log_e("GPIO ISR Service Failed To Start");
-    	return;
+        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
@@ -416,27 +271,14 @@ extern void __attachInterruptFunctionalArg(uint8_t pin, voidFuncPtrArg userFunc,
     __pinInterruptHandlers[pin].arg = arg;
     __pinInterruptHandlers[pin].functional = functional;
 
-#if USE_ESP_IDF_GPIO
-    gpio_set_intr_type((gpio_num_t)pin, (gpio_int_type_t)(intr_type & 0x7));
-    if(intr_type & 0x8){
-    	gpio_wakeup_enable((gpio_num_t)pin, (gpio_int_type_t)(intr_type & 0x7));
-    }
-    gpio_isr_handler_add((gpio_num_t)pin, __onPinInterrupt, &__pinInterruptHandlers[pin]);
-    gpio_intr_enable((gpio_num_t)pin);
-#else
     esp_intr_disable(gpio_intr_handle);
-#if CONFIG_IDF_TARGET_ESP32
     if(esp_intr_get_cpu(gpio_intr_handle)) { //APP_CPU
-#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);
-#endif
 }
 
 extern void __attachInterruptArg(uint8_t pin, voidFuncPtrArg userFunc, void * arg, int intr_type)
@@ -450,13 +292,7 @@ extern void __attachInterrupt(uint8_t pin, voidFuncPtr userFunc, int intr_type)
 
 extern void __detachInterrupt(uint8_t pin)
 {
-#if USE_ESP_IDF_GPIO
-	gpio_intr_disable((gpio_num_t)pin);
-	gpio_isr_handler_remove((gpio_num_t)pin);
-	gpio_wakeup_disable((gpio_num_t)pin);
-#else
     esp_intr_disable(gpio_intr_handle);
-#endif
     if (__pinInterruptHandlers[pin].functional && __pinInterruptHandlers[pin].arg)
     {
     	cleanupFunctional(__pinInterruptHandlers[pin].arg);
@@ -465,13 +301,9 @@ extern void __detachInterrupt(uint8_t pin)
     __pinInterruptHandlers[pin].arg = NULL;
     __pinInterruptHandlers[pin].functional = false;
 
-#if USE_ESP_IDF_GPIO
-    gpio_set_intr_type((gpio_num_t)pin, GPIO_INTR_DISABLE);
-#else
     GPIO.pin[pin].int_ena = 0;
     GPIO.pin[pin].int_type = 0;
     esp_intr_enable(gpio_intr_handle);
-#endif
 }
 
 

cores/esp32/esp32-hal-gpio.h

@@ -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  46
-#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

@@ -21,19 +21,14 @@
 #include "driver/periph_ctrl.h"
 #include "soc/i2c_reg.h"
 #include "soc/i2c_struct.h"
+#include "soc/dport_reg.h"
 #include "esp_attr.h"
 #include "esp32-hal-cpu.h" // cpu clock change support 31DEC2018
 
 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "soc/dport_reg.h"
 #include "esp32/rom/ets_sys.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/dport_reg.h"
-#include "esp32s2/rom/ets_sys.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -42,7 +37,6 @@
 #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))
@@ -245,7 +239,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"};
@@ -375,7 +369,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.*/
@@ -449,7 +443,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);      
@@ -496,7 +490,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;
@@ -509,7 +503,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
      */
@@ -667,7 +661,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.
@@ -759,7 +753,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;
     
@@ -818,7 +812,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) {
@@ -863,7 +857,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.
@@ -910,7 +904,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;
@@ -963,14 +957,6 @@ static void ARDUINO_ISR_ATTR i2c_isr_handler_default(void* arg)
             activeInt &=~I2C_RXFIFO_FULL_INT_ST;
         }
 
-        if(activeInt & I2C_RXFIFO_OVF_INT_ST) {
-            emptyRxFifo(p_i2c);
-            p_i2c->dev->int_clr.rx_fifo_full=1;
-            p_i2c->dev->int_ena.rx_fifo_full=1; //why?
-
-            activeInt &=~I2C_RXFIFO_OVF_INT_ST;
-        }
-
         if (activeInt & I2C_ACK_ERR_INT_ST_M) {//fatal error, abort i2c service
             if (p_i2c->mode == I2C_MASTER) {
                 i2c_update_error_byte_cnt(p_i2c); // calc which byte caused ack Error, check if address or data
@@ -1265,7 +1251,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
       
@@ -1783,137 +1769,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 >= SOC_I2C_NUM){
-		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

@@ -17,25 +17,14 @@
 #include "freertos/task.h"
 #include "freertos/semphr.h"
 #include "esp32-hal-matrix.h"
+#include "soc/dport_reg.h"
 #include "soc/ledc_reg.h"
 #include "soc/ledc_struct.h"
-#include "driver/periph_ctrl.h"
 
 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "soc/dport_reg.h"
 #include "esp32/rom/ets_sys.h"
-#define LAST_CHAN (15)
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/dport_reg.h"
-#include "esp32s2/rom/ets_sys.h"
-#define LAST_CHAN (7)
-#define LEDC_DIV_NUM_HSTIMER0_V LEDC_CLK_DIV_LSTIMER0_V
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
-#define LAST_CHAN (7)
-#define LEDC_DIV_NUM_HSTIMER0_V LEDC_CLK_DIV_LSTIMER0_V
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -117,7 +106,8 @@ static void _ledcSetupTimer(uint8_t chan, uint32_t div_num, uint8_t bit_num, boo
     static uint16_t _activeChannels = 0;
     if(!tHasStarted) {
         tHasStarted = true;
-        periph_module_enable(PERIPH_LEDC_MODULE);
+        DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_LEDC_CLK_EN);
+        DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_LEDC_RST);
         LEDC.conf.apb_clk_sel = 1;//LS use apb clock
         addApbChangeCallback((void*)&_activeChannels, _on_apb_change);
 
@@ -129,13 +119,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;
@@ -200,21 +186,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);
@@ -224,7 +206,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);
@@ -233,34 +215,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;
@@ -276,7 +250,7 @@ double ledcReadFreq(uint8_t chan)
 
 double ledcWriteTone(uint8_t chan, double freq)
 {
-    if(chan > LAST_CHAN) {
+    if(chan > 15) {
         return 0;
     }
     if(!freq) {
@@ -303,27 +277,14 @@ 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 || CONFIG_IDF_TARGET_ESP32C3
-    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)
 {
     pinMatrixOutDetach(pin, false, false);
 }
-
-double ledcChangeFrequency(uint8_t chan, double freq, uint8_t bit_num)
-{
-    if (chan > 15) {
-        return 0;
-    }
-    double res_freq = _ledcSetupTimerFreq(chan, freq, bit_num);
-    return res_freq;
-}

cores/esp32/esp32-hal-ledc.h

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

cores/esp32/esp32-hal-log.c

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

cores/esp32/esp32-hal-log.h

@@ -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,9 +36,6 @@ extern "C"
 #define ARDUHAL_LOG_LEVEL CONFIG_ARDUHAL_LOG_DEFAULT_LEVEL
 #else
 #define ARDUHAL_LOG_LEVEL CORE_DEBUG_LEVEL
-#ifdef USE_ESP_IDF_LOG
-#define LOG_LOCAL_LEVEL CORE_DEBUG_LEVEL
-#endif
 #endif
 
 #ifndef CONFIG_ARDUHAL_LOG_COLORS
@@ -75,101 +71,62 @@ 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
@@ -193,7 +150,6 @@ void log_to_esp(char* tag, esp_log_level_t level, const char* format, ...);
 #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

@@ -19,10 +19,6 @@
 #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"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/gpio.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -34,27 +30,27 @@
 #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

@@ -38,12 +38,6 @@
 #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"
-#include "driver/temp_sensor.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/rtc.h"
-#include "driver/temp_sensor.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -53,25 +47,12 @@
 
 //Undocumented!!! Get chip temperature in Farenheit
 //Source: https://github.com/pcbreflux/espressif/blob/master/esp32/arduino/sketchbook/ESP32_int_temp_sensor/ESP32_int_temp_sensor.ino
-#ifdef CONFIG_IDF_TARGET_ESP32
 uint8_t temprature_sens_read();
 
 float temperatureRead()
 {
     return (temprature_sens_read() - 32) / 1.8;
 }
-#else
-float temperatureRead()
-{
-    float result = NAN;
-    temp_sensor_config_t tsens = TSENS_CONFIG_DEFAULT();
-    temp_sensor_set_config(tsens);
-    temp_sensor_start();
-    temp_sensor_read_celsius(&result); 
-    temp_sensor_stop();
-    return result;
-}
-#endif
 
 void __yield()
 {
@@ -160,12 +141,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);
 }
@@ -175,17 +156,17 @@ 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)
 {
-    uint64_t m = (uint64_t)esp_timer_get_time();
+    uint32_t m = micros();
     if(us){
-        uint64_t e = (m + us);
+        uint32_t e = (m + us);
         if(m > e){ //overflow
-            while((uint64_t)esp_timer_get_time() > e){
+            while(micros() > e){
                 NOP();
             }
         }
-        while((uint64_t)esp_timer_get_time() < e){
+        while(micros() < e){
             NOP();
         }
     }
@@ -227,7 +208,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);
@@ -256,7 +237,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

@@ -14,7 +14,7 @@
 
 #include "esp32-hal.h"
 
-#if CONFIG_SPIRAM_SUPPORT || CONFIG_SPIRAM
+#if CONFIG_SPIRAM_SUPPORT
 #include "soc/efuse_reg.h"
 #include "esp_heap_caps.h"
 
@@ -22,9 +22,6 @@
 #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
@@ -43,7 +40,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 +47,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 +65,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 +102,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,36 +19,22 @@
 #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
 #define MAX_DATA_PER_CHANNEL 64
 #define MAX_DATA_PER_ITTERATION 62
-#elif CONFIG_IDF_TARGET_ESP32S2
-#define MAX_CHANNELS 4
-#define MAX_DATA_PER_CHANNEL 64
-#define MAX_DATA_PER_ITTERATION 62
-#elif CONFIG_IDF_TARGET_ESP32C3
-#define MAX_CHANNELS 4
-#define MAX_DATA_PER_CHANNEL 48
-#define MAX_DATA_PER_ITTERATION 46
-#else 
-#error Target CONFIG_IDF_TARGET is not supported
-#endif
 #define _ABS(a) (a>0?a:-a)
 #define _LIMIT(a,b) (a>b?b:a)
-#if CONFIG_IDF_TARGET_ESP32C3
-#define _INT_TX_END(channel) (1<<(channel))
-#define _INT_RX_END(channel) (4<<(channel))
-#define _INT_ERROR(channel)  (16<<(channel))
-#define _INT_THR_EVNT(channel)  (256<<(channel))
-#else
 #define __INT_TX_END     (1)
 #define __INT_RX_END     (2)
 #define __INT_ERROR      (4)
@@ -58,7 +44,6 @@
 #define _INT_RX_END(channel) (__INT_RX_END<<(channel*3))
 #define _INT_ERROR(channel)  (__INT_ERROR<<(channel*3))
 #define _INT_THR_EVNT(channel)  ((__INT_THR_EVNT)<<(channel))
-#endif
 
 #if CONFIG_DISABLE_HAL_LOCKS
 # define RMT_MUTEX_LOCK(channel)
@@ -68,7 +53,7 @@
 # define RMT_MUTEX_UNLOCK(channel)  xSemaphoreGive(g_rmt_objlocks[channel])
 #endif /* CONFIG_DISABLE_HAL_LOCKS */
 
-//#define _RMT_INTERNAL_DEBUG
+#define _RMT_INTERNAL_DEBUG
 #ifdef _RMT_INTERNAL_DEBUG
 # define DEBUG_INTERRUPT_START(pin)    digitalWrite(pin, 1);
 # define DEBUG_INTERRUPT_END(pin)      digitalWrite(pin, 0);
@@ -109,30 +94,24 @@ struct rmt_obj_s
     transaction_state_t tx_state;
     rmt_rx_data_cb_t cb;
     bool data_alloc;
-    void * arg;
 };
 
 /**
  * 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] = {
-    { 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},
-#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
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
+    { false, NULL, 0, 0, 0, 0, 0, NULL, E_NO_INTR, E_INACTIVE, NULL, false},
 };
 
 /**
@@ -151,17 +130,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);
 
 
 /**
@@ -175,17 +154,12 @@ bool rmtSetCarrier(rmt_obj_t* rmt, bool carrier_en, bool carrier_level, uint32_t
     size_t channel = rmt->channel;
 
     RMT_MUTEX_LOCK(channel);
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.tx_carrier[channel].low = low;
-    RMT.tx_carrier[channel].high = high;
-    RMT.rx_conf[channel].conf0.carrier_en = carrier_en;
-    RMT.rx_conf[channel].conf0.carrier_out_lv = carrier_level;
-#else
+
     RMT.carrier_duty_ch[channel].low = low;
     RMT.carrier_duty_ch[channel].high = high;
     RMT.conf_ch[channel].conf0.carrier_en = carrier_en;
     RMT.conf_ch[channel].conf0.carrier_out_lv = carrier_level;
-#endif
+
     RMT_MUTEX_UNLOCK(channel);
 
     return true;
@@ -201,13 +175,8 @@ bool rmtSetFilter(rmt_obj_t* rmt, bool filter_en, uint32_t filter_level)
 
     RMT_MUTEX_LOCK(channel);
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.rx_filter_thres = filter_level;
-    RMT.rx_conf[channel].conf1.rx_filter_en = filter_en;
-#else
     RMT.conf_ch[channel].conf1.rx_filter_thres = filter_level;
     RMT.conf_ch[channel].conf1.rx_filter_en = filter_en;
-#endif
 
     RMT_MUTEX_UNLOCK(channel);
 
@@ -223,11 +192,7 @@ bool rmtSetRxThreshold(rmt_obj_t* rmt, uint32_t value)
     size_t channel = rmt->channel;
 
     RMT_MUTEX_LOCK(channel);
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf0.idle_thres = value;
-#else
     RMT.conf_ch[channel].conf0.idle_thres = value;
-#endif
     RMT_MUTEX_UNLOCK(channel);
 
     return true;
@@ -292,13 +257,13 @@ bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
     int channel = rmt->channel;
     int allocated_size = MAX_DATA_PER_CHANNEL * rmt->buffers;
 
-    if (size > (allocated_size - 1)) {
+    if (size > allocated_size) {
 
         int half_tx_nr = MAX_DATA_PER_ITTERATION/2;
         RMT_MUTEX_LOCK(channel);
         // 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;
@@ -306,18 +271,6 @@ bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
         rmt->intr_mode = E_TX_INTR | E_TXTHR_INTR;
         rmt->tx_state = E_SET_CONTI | E_FIRST_HALF;
 
-#if CONFIG_IDF_TARGET_ESP32C3
-        //uint32_t val = RMT.tx_conf[channel].val;
-        // init the tx limit for interruption
-        RMT.tx_lim[channel].limit = half_tx_nr+2;
-        //RMT.tx_conf[channel].val = val;
-        //RMT.tx_conf[channel].conf_update = 1;
-        // reset memory pointer
-        RMT.tx_conf[channel].mem_rst = 1;
-        //RMT.tx_conf[channel].mem_rst = 0;
-        RMT.tx_conf[channel].mem_rd_rst = 1;
-        //RMT.tx_conf[channel].mem_rd_rst = 0;
-#else
         // init the tx limit for interruption
         RMT.tx_lim_ch[channel].limit = half_tx_nr+2;
         // reset memory pointer
@@ -327,9 +280,9 @@ bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
         RMT.conf_ch[channel].conf1.mem_rd_rst = 0;
         RMT.conf_ch[channel].conf1.mem_wr_rst = 1;
         RMT.conf_ch[channel].conf1.mem_wr_rst = 0;
-#endif
+
         // set the tx end mark
-        //RMTMEM.chan[channel].data32[MAX_DATA_PER_ITTERATION].val = 0;
+        RMTMEM.chan[channel].data32[MAX_DATA_PER_ITTERATION].val = 0;
 
         // clear and enable both Tx completed and half tx event
         RMT.int_clr.val = _INT_TX_END(channel);
@@ -343,7 +296,6 @@ bool rmtWrite(rmt_obj_t* rmt, rmt_data_t* data, size_t size)
         RMT_MUTEX_UNLOCK(channel);
 
         // start the transation
-        //return _rmtSendOnce(rmt, data, MAX_DATA_PER_ITTERATION, true);
         return _rmtSendOnce(rmt, data, MAX_DATA_PER_ITTERATION, false);
     } else {
         // use one-go mode if data fits one buffer 
@@ -371,7 +323,6 @@ bool rmtReadData(rmt_obj_t* rmt, uint32_t* data, size_t size)
     return true;
 }
 
-
 bool rmtBeginReceive(rmt_obj_t* rmt)
 {
     if (!rmt) {
@@ -382,15 +333,10 @@ bool rmtBeginReceive(rmt_obj_t* rmt)
     RMT.int_clr.val = _INT_ERROR(channel);
     RMT.int_ena.val |= _INT_ERROR(channel);
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.mem_owner = 1;
-    RMT.rx_conf[channel].conf1.mem_wr_rst = 1;
-    RMT.rx_conf[channel].conf1.rx_en = 1;
-#else
     RMT.conf_ch[channel].conf1.mem_owner = 1;
     RMT.conf_ch[channel].conf1.mem_wr_rst = 1;
     RMT.conf_ch[channel].conf1.rx_en = 1;
-#endif
+
     return true;
 }
 
@@ -410,7 +356,7 @@ bool rmtReceiveCompleted(rmt_obj_t* rmt)
     }
 }
 
-bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb, void * arg)
+bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb)
 {
     if (!rmt && !cb) {
         return false;
@@ -418,7 +364,6 @@ bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb, void * arg)
     int channel = rmt->channel;
 
     RMT_MUTEX_LOCK(channel);
-    rmt->arg = arg;
     rmt->intr_mode = E_RX_INTR;
     rmt->tx_state = E_FIRST_HALF;
     rmt->cb = cb;
@@ -429,48 +374,22 @@ bool rmtRead(rmt_obj_t* rmt, rmt_rx_data_cb_t cb, void * arg)
         rmt->data_alloc = true;
     }
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.mem_owner = 1;
-#else
     RMT.conf_ch[channel].conf1.mem_owner = 1;
-#endif
+
     RMT.int_clr.val = _INT_RX_END(channel);
     RMT.int_clr.val = _INT_ERROR(channel);
     
     RMT.int_ena.val |= _INT_RX_END(channel);
     RMT.int_ena.val |= _INT_ERROR(channel);
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.mem_wr_rst = 1;
-
-    RMT.rx_conf[channel].conf1.rx_en = 1;
-#else
     RMT.conf_ch[channel].conf1.mem_wr_rst = 1;
 
     RMT.conf_ch[channel].conf1.rx_en = 1;
-#endif
     RMT_MUTEX_UNLOCK(channel);
 
     return true;
 }
 
-bool rmtEnd(rmt_obj_t* rmt) {
-    if (!rmt) {
-        return false;
-    }
-    int channel = rmt->channel;
-
-    RMT_MUTEX_LOCK(channel);
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.rx_en = 1;
-#else
-    RMT.conf_ch[channel].conf1.rx_en = 1;
-#endif
-    RMT_MUTEX_UNLOCK(channel);
-
-    return  true;
-}
-
 bool rmtReadAsync(rmt_obj_t* rmt, rmt_data_t* data, size_t size, void* eventFlag, bool waitForData, uint32_t timeout)
 {
     if (!rmt) {
@@ -495,11 +414,7 @@ bool rmtReadAsync(rmt_obj_t* rmt, rmt_data_t* data, size_t size, void* eventFlag
     RMT_MUTEX_LOCK(channel);
     rmt->intr_mode = E_RX_INTR;
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.mem_owner = 1;
-#else
     RMT.conf_ch[channel].conf1.mem_owner = 1;
-#endif
 
     RMT.int_clr.val = _INT_RX_END(channel);
     RMT.int_clr.val = _INT_ERROR(channel);
@@ -507,15 +422,9 @@ bool rmtReadAsync(rmt_obj_t* rmt, rmt_data_t* data, size_t size, void* eventFlag
     RMT.int_ena.val |= _INT_RX_END(channel);
     RMT.int_ena.val |= _INT_ERROR(channel);
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.rx_conf[channel].conf1.mem_wr_rst = 1;
-
-    RMT.rx_conf[channel].conf1.rx_en = 1;
-#else
     RMT.conf_ch[channel].conf1.mem_wr_rst = 1;
 
     RMT.conf_ch[channel].conf1.rx_en = 1;
-#endif
     RMT_MUTEX_UNLOCK(channel);
 
     // wait for data if requested so
@@ -542,20 +451,14 @@ float rmtSetTick(rmt_obj_t* rmt, float tick)
      * rmt tick for 1 MHz  -> 1us (1x)        div_cnt = 0x01
                               256us (256x)    div_cnt = 0x00
     */
+    int apb_div = _LIMIT(tick/12.5, 256);
+    int ref_div = _LIMIT(tick/1000, 256);
+
+    float apb_tick = 12.5 * apb_div;
+    float ref_tick = 1000.0 * ref_div;
     
     size_t channel = rmt->channel;
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    int apb_div = _LIMIT(tick/25.0, 256);
-    float apb_tick = 25.0 * apb_div;
-    RMT.tx_conf[channel].div_cnt = apb_div & 0xFF;
-    RMT.tx_conf[channel].conf_update = 1;
-    return apb_tick;
-#else
-    int apb_div = _LIMIT(tick/12.5, 256);
-    int ref_div = _LIMIT(tick/1000, 256);
-    float apb_tick = 12.5 * apb_div;
-    float ref_tick = 1000.0 * ref_div;
     if (_ABS(apb_tick - tick) < _ABS(ref_tick - tick)) {
         RMT.conf_ch[channel].conf0.div_cnt = apb_div & 0xFF;
         RMT.conf_ch[channel].conf1.ref_always_on = 1;
@@ -565,7 +468,6 @@ float rmtSetTick(rmt_obj_t* rmt, float tick)
         RMT.conf_ch[channel].conf1.ref_always_on = 0;
         return ref_tick;
     }
-#endif
 }
 
 rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
@@ -620,76 +522,27 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
     rmt->tx_not_rx = tx_not_rx;
     rmt->buffers =buffers;
     rmt->channel = channel;
-    rmt->arg = NULL;
-
     _initPin(pin, channel, tx_not_rx);
 
     // Initialize the registers in default mode:
     // - no carrier, filter
     // - timebase tick of 1us
     // - idle threshold set to 0x8000 (max pulse width + 1)
-#if CONFIG_IDF_TARGET_ESP32C3
-
-    RMT.sys_conf.fifo_mask = 1;
-
-    if (tx_not_rx) {
-    	RMT.tx_lim[channel].limit = MAX_DATA_PER_ITTERATION/2 + 2;
-    	RMT.tx_conf[channel].val = 0;
-//        RMT.tx_conf[channel].carrier_en = 0;
-//        RMT.tx_conf[channel].carrier_out_lv = 0;
-//        RMT.tx_conf[channel].tx_conti_mode = 0;
-//        RMT.tx_conf[channel].idle_out_lv = 0;     // signal level for idle
-//        RMT.tx_conf[channel].tx_start = 0;
-//        RMT.tx_conf[channel].tx_stop = 0;
-//        RMT.tx_conf[channel].carrier_eff_en = 0;
-//        RMT.tx_conf[channel].afifo_rst = 0;
-//        RMT.tx_conf[channel].conf_update = 0;
-//        RMT.tx_conf[channel].mem_tx_wrap_en = 0;
-//        RMT.tx_conf[channel].mem_rst = 1;
-
-        RMT.tx_conf[channel].idle_out_en = 1;     // enable idle
-        RMT.tx_conf[channel].div_cnt = 1;
-        RMT.tx_conf[channel].mem_size = buffers;
-        RMT.tx_conf[channel].mem_rd_rst = 1;
-        RMT.tx_conf[channel].conf_update = 1;
-    } else {
-        RMT.rx_conf[channel].conf0.div_cnt = 1;
-        RMT.rx_conf[channel].conf0.mem_size = buffers;
-        RMT.rx_conf[channel].conf0.carrier_en = 0;
-        RMT.rx_conf[channel].conf0.carrier_out_lv = 0;
-        RMT.rx_conf[channel].conf0.idle_thres = 0x80;
-        RMT.rx_conf[channel].conf1.rx_filter_en = 0;
-        RMT.rx_conf[channel].conf1.rx_filter_thres = 0;
-        RMT.rx_conf[channel].conf1.mem_rst = 0;
-        RMT.rx_conf[channel].conf1.mem_rx_wrap_en = 0;
-        RMT.rx_conf[channel].conf1.afifo_rst = 0;
-        RMT.rx_conf[channel].conf1.conf_update = 0;
-        RMT.rx_conf[channel].conf1.rx_en = 1;
-        RMT.rx_conf[channel].conf1.mem_owner = 1;
-        RMT.rx_conf[channel].conf1.mem_wr_rst = 1;
-    }
-#else
     RMT.conf_ch[channel].conf0.div_cnt = 1;
     RMT.conf_ch[channel].conf0.mem_size = buffers;
     RMT.conf_ch[channel].conf0.carrier_en = 0;
     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
     RMT.conf_ch[channel].conf1.idle_out_en = 1;     // enable idle
     RMT.conf_ch[channel].conf1.ref_always_on = 0;     // base clock
-
     RMT.apb_conf.fifo_mask = 1;
 
     if (tx_not_rx) {
@@ -701,10 +554,10 @@ rmt_obj_t* rmtInit(int pin, bool tx_not_rx, rmt_reserve_memsize_t memsize)
         RMT.conf_ch[channel].conf1.mem_owner = 1;
         RMT.conf_ch[channel].conf1.mem_wr_rst = 1;
     }
-#endif
+
     // install interrupt if at least one channel is active
     if (!intr_handle) {
-        esp_intr_alloc(ETS_RMT_INTR_SOURCE, (int)ARDUINO_ISR_FLAG, _rmt_isr, NULL, &intr_handle);
+        esp_intr_alloc(ETS_RMT_INTR_SOURCE, (int)ESP_INTR_FLAG_IRAM, _rmt_isr, NULL, &intr_handle);
     }
     RMT_MUTEX_UNLOCK(channel);
 
@@ -720,11 +573,7 @@ bool _rmtSendOnce(rmt_obj_t* rmt, rmt_data_t* data, size_t size, bool continuous
         return false;
     }
     int channel = rmt->channel;
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.sys_conf.fifo_mask = 1;
-#else
     RMT.apb_conf.fifo_mask = 1;
-#endif
     if (data && size>0) {
         size_t i;
         volatile uint32_t* rmt_mem_ptr = &(RMTMEM.chan[channel].data32[0].val);
@@ -736,15 +585,9 @@ bool _rmtSendOnce(rmt_obj_t* rmt, rmt_data_t* data, size_t size, bool continuous
     }
 
     RMT_MUTEX_LOCK(channel);
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.tx_conf[channel].tx_conti_mode = continuous;
-    RMT.tx_conf[channel].mem_rd_rst = 1;
-    RMT.tx_conf[channel].tx_start = 1;
-#else
     RMT.conf_ch[channel].conf1.tx_conti_mode = continuous;
     RMT.conf_ch[channel].conf1.mem_rd_rst = 1;
     RMT.conf_ch[channel].conf1.tx_start = 1;
-#endif
     RMT_MUTEX_UNLOCK(channel);
 
     return true;
@@ -769,7 +612,6 @@ static void _initPin(int pin, int channel, bool tx_not_rx)
 {
     if (!periph_enabled) {
         periph_enabled = true;
-        periph_module_reset( PERIPH_RMT_MODULE );
         periph_module_enable( PERIPH_RMT_MODULE );
     }
     if (tx_not_rx) {
@@ -783,9 +625,8 @@ 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)
 {
-	//DEBUG_INTERRUPT_START(4);
     int intr_val = RMT.int_st.val;
     size_t ch;
     for (ch = 0; ch < MAX_CHANNELS; ch++) {
@@ -817,18 +658,12 @@ static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
                     }
                     if (g_rmt_objects[ch].cb) {
                         // actually received data ptr                        
-                        (g_rmt_objects[ch].cb)(data_received, _rmt_get_mem_len(ch), g_rmt_objects[ch].arg);
+                        (g_rmt_objects[ch].cb)(data_received, _rmt_get_mem_len(ch));
 
                         // restart the reception
-#if CONFIG_IDF_TARGET_ESP32C3
-                        RMT.rx_conf[ch].conf1.mem_owner = 1;
-                        RMT.rx_conf[ch].conf1.mem_wr_rst = 1;
-                        RMT.rx_conf[ch].conf1.rx_en = 1;
-#else
                         RMT.conf_ch[ch].conf1.mem_owner = 1;
                         RMT.conf_ch[ch].conf1.mem_wr_rst = 1;
                         RMT.conf_ch[ch].conf1.rx_en = 1;
-#endif
                         RMT.int_ena.val |= _INT_RX_END(ch);
                     } else {
                         // if not callback provide, expect only one Rx
@@ -854,17 +689,10 @@ static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
                 xEventGroupSetBits(g_rmt_objects[ch].events, RMT_FLAG_ERROR);
             }
             // reset memory
-#if CONFIG_IDF_TARGET_ESP32C3
-            RMT.tx_conf[ch].mem_rd_rst = 1;
-            RMT.tx_conf[ch].mem_rd_rst = 0;
-            RMT.rx_conf[ch].conf1.mem_wr_rst = 1;
-            RMT.rx_conf[ch].conf1.mem_wr_rst = 0;
-#else
             RMT.conf_ch[ch].conf1.mem_rd_rst = 1;
             RMT.conf_ch[ch].conf1.mem_rd_rst = 0;
             RMT.conf_ch[ch].conf1.mem_wr_rst = 1;
             RMT.conf_ch[ch].conf1.mem_wr_rst = 0;
-#endif
         }
 
         if (intr_val & _INT_TX_END(ch)) {
@@ -876,50 +704,32 @@ static void ARDUINO_ISR_ATTR _rmt_isr(void* arg)
         if (intr_val & _INT_THR_EVNT(ch)) {
             // clear the flag
             RMT.int_clr.val = _INT_THR_EVNT(ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-            //RMT.int_clr.val = _INT_TX_END(ch);
-            //RMT.int_ena.val |= _INT_TX_END(ch);
-#endif
 
             // initial setup of continuous mode
             if (g_rmt_objects[ch].tx_state & E_SET_CONTI) {
-#if CONFIG_IDF_TARGET_ESP32C3
-                RMT.tx_conf[ch].tx_conti_mode = 1;
-#else
                 RMT.conf_ch[ch].conf1.tx_conti_mode = 1;
-#endif
                 g_rmt_objects[ch].intr_mode &= ~E_SET_CONTI;
             }
             _rmt_tx_mem_first(ch);
         }
     }
-    //DEBUG_INTERRUPT_END(4);
 }
 
-static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch)
+static void IRAM_ATTR _rmt_tx_mem_second(uint8_t ch)
 {
     DEBUG_INTERRUPT_START(4)
     uint32_t* data = g_rmt_objects[ch].data_ptr;
     int half_tx_nr = MAX_DATA_PER_ITTERATION/2;
     int i;
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.tx_lim[ch].limit = half_tx_nr+2;
-#else
     RMT.tx_lim_ch[ch].limit = half_tx_nr+2;
-#endif
     RMT.int_clr.val = _INT_THR_EVNT(ch);
     RMT.int_ena.val |= _INT_THR_EVNT(ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-    //RMT.int_clr.val = _INT_TX_END(ch);
-    //RMT.int_ena.val &= ~_INT_TX_END(ch);
-#endif
 
     g_rmt_objects[ch].tx_state |= E_FIRST_HALF;
 
     if (data) {
         int remaining_size = g_rmt_objects[ch].data_size;
-        //ets_printf("RMT Tx[%d] %d\n", ch, remaining_size);
         // will the remaining data occupy the entire halfbuffer
         if (remaining_size > half_tx_nr) {
             for (i = 0; i < half_tx_nr; i++) {
@@ -938,30 +748,17 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_second(uint8_t ch)
             g_rmt_objects[ch].data_ptr = NULL;
 
         }
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMTMEM.chan[ch].data32[half_tx_nr+i].val = 0;
-        RMT.tx_conf[ch].tx_start = 1;
-#endif
     } else if   ((!(g_rmt_objects[ch].tx_state & E_LAST_DATA)) &&
                  (!(g_rmt_objects[ch].tx_state & E_END_TRANS))) {
-        //ets_printf("RMT Tx finishing %d!\n", ch);
         for (i = 0; i < half_tx_nr; i++) {
             RMTMEM.chan[ch].data32[half_tx_nr+i].val = 0x000F000F;
         }
         RMTMEM.chan[ch].data32[half_tx_nr+i].val = 0;
         g_rmt_objects[ch].tx_state |= E_LAST_DATA;
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMT.tx_conf[ch].tx_conti_mode = 0;
-#else
         RMT.conf_ch[ch].conf1.tx_conti_mode = 0;
-#endif
     } else {
-        //ets_printf("RMT Tx finished %d!\n", ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMT.tx_conf[ch].tx_conti_mode = 0;
-#else
+        log_d("RMT Tx finished %d!\n", ch);
         RMT.conf_ch[ch].conf1.tx_conti_mode = 0;
-#endif
         RMT.int_ena.val &= ~_INT_TX_END(ch);
         RMT.int_ena.val &= ~_INT_THR_EVNT(ch);
         g_rmt_objects[ch].intr_mode = E_NO_INTR;
@@ -970,22 +767,17 @@ 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;
     int half_tx_nr = MAX_DATA_PER_ITTERATION/2;
     int i;
     RMT.int_ena.val &= ~_INT_THR_EVNT(ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-    RMT.tx_lim[ch].limit = 0;
-#else
     RMT.tx_lim_ch[ch].limit = 0;
-#endif
 
     if (data) {
         int remaining_size = g_rmt_objects[ch].data_size;
-        //ets_printf("RMT TxF[%d] %d\n", ch, remaining_size);
 
         // will the remaining data occupy the entire halfbuffer
         if (remaining_size > half_tx_nr) {
@@ -996,11 +788,7 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch)
             g_rmt_objects[ch].tx_state &= ~E_FIRST_HALF;
             // turn off the treshold interrupt
             RMT.int_ena.val &= ~_INT_THR_EVNT(ch);
-#if CONFIG_IDF_TARGET_ESP32C3
-            RMT.tx_lim[ch].limit = 0;
-#else
             RMT.tx_lim_ch[ch].limit = 0;
-#endif
             g_rmt_objects[ch].data_size -= half_tx_nr;
             g_rmt_objects[ch].data_ptr += half_tx_nr;
         } else {
@@ -1017,37 +805,23 @@ static void ARDUINO_ISR_ATTR _rmt_tx_mem_first(uint8_t ch)
             g_rmt_objects[ch].data_ptr = NULL;
         }
     } else { 
-        //ets_printf("RMT TxF finished %d!\n", ch);
         for (i = 0; i < half_tx_nr; i++) {
             RMTMEM.chan[ch].data32[i].val = 0x000F000F;
         }
         RMTMEM.chan[ch].data32[i].val = 0;
 
         g_rmt_objects[ch].tx_state &= ~E_FIRST_HALF;
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMT.tx_lim[ch].limit = 0;
-#else
         RMT.tx_lim_ch[ch].limit = 0;
-#endif
         g_rmt_objects[ch].tx_state |= E_LAST_DATA;
-#if CONFIG_IDF_TARGET_ESP32C3
-        RMT.tx_conf[ch].tx_conti_mode = 0;
-#else
         RMT.conf_ch[ch].conf1.tx_conti_mode = 0;
-#endif
     }
     DEBUG_INTERRUPT_END(2);
 }
 
-static int ARDUINO_ISR_ATTR _rmt_get_mem_len(uint8_t channel)
+static int IRAM_ATTR _rmt_get_mem_len(uint8_t channel)
 {
-#if CONFIG_IDF_TARGET_ESP32C3
-    int block_num = RMT.rx_conf[channel].conf0.mem_size;
-    int item_block_len = block_num * 48;
-#else
     int block_num = RMT.conf_ch[channel].conf0.mem_size;
     int item_block_len = block_num * 64;
-#endif
     volatile rmt_item32_t* data = RMTMEM.chan[channel].data32;
     int idx;
     for(idx = 0; idx < item_block_len; idx++) {

cores/esp32/esp32-hal-rmt.h

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

cores/esp32/esp32-hal-sigmadelta.c

@@ -24,10 +24,6 @@
 #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"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -83,9 +79,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

@@ -22,25 +22,15 @@
 #include "soc/spi_struct.h"
 #include "soc/io_mux_reg.h"
 #include "soc/gpio_sig_map.h"
+#include "soc/dport_reg.h"
 #include "soc/rtc.h"
-#include "driver/periph_ctrl.h"
 
 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "soc/dport_reg.h"
 #include "esp32/rom/ets_sys.h"
 #include "esp32/rom/gpio.h"
 #include "esp_intr_alloc.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/dport_reg.h"
-#include "esp32s2/rom/ets_sys.h"
-#include "esp32s2/rom/gpio.h"
-#include "esp_intr_alloc.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
-#include "esp32c3/rom/gpio.h"
-#include "esp_intr_alloc.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -50,6 +40,18 @@
 #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;
 #if !CONFIG_DISABLE_HAL_LOCKS
@@ -58,84 +60,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:FSPICS0_OUT_IDX)))
-#define SPI_SS_IDX(p, n)    ((p==0)?SPI_SPI_SS_IDX(n):((p==1)?SPI_SPI_SS_IDX(n):((p==2)?SPI_HSPI_SS_IDX(n):0)))
-
-#define SPI_INTR_SOURCE(u)  ((u==0)?ETS_SPI1_INTR_SOURCE:((u==1)?ETS_SPI2_INTR_SOURCE:((u==2)?ETS_SPI3_INTR_SOURCE:0)))
-
-#elif CONFIG_IDF_TARGET_ESP32C3
-// ESP32S2
-#define SPI_COUNT           (1)
-
-#define SPI_CLK_IDX(p)      FSPICLK_OUT_IDX
-#define SPI_MISO_IDX(p)     FSPIQ_OUT_IDX
-#define SPI_MOSI_IDX(p)     FSPID_IN_IDX
-
-#define SPI_SPI_SS_IDX(n)   ((n==0)?FSPICS0_OUT_IDX:((n==1)?FSPICS1_OUT_IDX:((n==2)?FSPICS2_OUT_IDX:FSPICS0_OUT_IDX)))
-#define SPI_SS_IDX(p, n)    SPI_SPI_SS_IDX(n)
-
-#define SPI_INTR_SOURCE(u)  ETS_SPI2_INTR_SOURCE
-
-#else
-// ESP32
-#define SPI_COUNT           (4)
-
-#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}
-#elif CONFIG_IDF_TARGET_ESP32C3
-    {(volatile spi_dev_t *)(&GPSPI2), NULL, FSPI}
-#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
 
@@ -145,14 +88,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;
-        }
-#elif CONFIG_IDF_TARGET_ESP32
         if(spi->num == HSPI) {
             sck = 14;
         } else if(spi->num == VSPI) {
@@ -160,10 +95,6 @@ void spiAttachSCK(spi_t * spi, int8_t sck)
         } else {
             sck = 6;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
-#endif
     }
     pinMode(sck, OUTPUT);
     pinMatrixOutAttach(sck, SPI_CLK_IDX(spi->num), false, false);
@@ -175,14 +106,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;
-        }
-#elif CONFIG_IDF_TARGET_ESP32
         if(spi->num == HSPI) {
             miso = 12;
         } else if(spi->num == VSPI) {
@@ -190,10 +113,6 @@ void spiAttachMISO(spi_t * spi, int8_t miso)
         } else {
             miso = 7;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
-#endif
     }
     SPI_MUTEX_LOCK();
     pinMode(miso, INPUT);
@@ -207,14 +126,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;
-        }
-#elif CONFIG_IDF_TARGET_ESP32
         if(spi->num == HSPI) {
             mosi = 13;
         } else if(spi->num == VSPI) {
@@ -222,10 +133,6 @@ void spiAttachMOSI(spi_t * spi, int8_t mosi)
         } else {
             mosi = 8;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
-#endif
     }
     pinMode(mosi, OUTPUT);
     pinMatrixOutAttach(mosi, SPI_MOSI_IDX(spi->num), false, false);
@@ -237,14 +144,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;
-        }
-#elif CONFIG_IDF_TARGET_ESP32
         if(spi->num == HSPI) {
             sck = 14;
         } else if(spi->num == VSPI) {
@@ -252,10 +151,6 @@ void spiDetachSCK(spi_t * spi, int8_t sck)
         } else {
             sck = 6;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
-#endif
     }
     pinMatrixOutDetach(sck, false, false);
     pinMode(sck, INPUT);
@@ -267,14 +162,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;
-        }
-#elif CONFIG_IDF_TARGET_ESP32
         if(spi->num == HSPI) {
             miso = 12;
         } else if(spi->num == VSPI) {
@@ -282,10 +169,6 @@ void spiDetachMISO(spi_t * spi, int8_t miso)
         } else {
             miso = 7;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
-#endif
     }
     pinMatrixInDetach(SPI_MISO_IDX(spi->num), false, false);
     pinMode(miso, INPUT);
@@ -297,14 +180,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;
-        }
-#elif CONFIG_IDF_TARGET_ESP32
         if(spi->num == HSPI) {
             mosi = 13;
         } else if(spi->num == VSPI) {
@@ -312,10 +187,6 @@ void spiDetachMOSI(spi_t * spi, int8_t mosi)
         } else {
             mosi = 8;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
-#endif
     }
     pinMatrixOutDetach(mosi, false, false);
     pinMode(mosi, INPUT);
@@ -331,14 +202,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;
-        }
-#elif CONFIG_IDF_TARGET_ESP32
         if(spi->num == HSPI) {
             ss = 15;
         } else if(spi->num == VSPI) {
@@ -346,10 +209,6 @@ void spiAttachSS(spi_t * spi, uint8_t cs_num, int8_t ss)
         } else {
             ss = 11;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
-#endif
     }
     pinMode(ss, OUTPUT);
     pinMatrixOutAttach(ss, SPI_SS_IDX(spi->num, cs_num), false, false);
@@ -362,14 +221,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;
-        }
-#elif CONFIG_IDF_TARGET_ESP32
         if(spi->num == HSPI) {
             ss = 15;
         } else if(spi->num == VSPI) {
@@ -377,10 +228,6 @@ void spiDetachSS(spi_t * spi, int8_t ss)
         } else {
             ss = 11;
         }
-#elif CONFIG_IDF_TARGET_ESP32C3
-        log_e("SPI Does not have default pins on ESP32C3!");
-        return;
-#endif
     }
     pinMatrixOutDetach(ss, false, false);
     pinMode(ss, INPUT);
@@ -392,11 +239,7 @@ void spiEnableSSPins(spi_t * spi, uint8_t cs_mask)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
-    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();
 }
 
@@ -406,11 +249,7 @@ void spiDisableSSPins(spi_t * spi, uint8_t cs_mask)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
-    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();
 }
 
@@ -442,11 +281,7 @@ void spiSSSet(spi_t * spi)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->misc.cs_keep_active = 1;
-#else
     spi->dev->pin.cs_keep_active = 1;
-#endif
     SPI_MUTEX_UNLOCK();
 }
 
@@ -456,11 +291,7 @@ void spiSSClear(spi_t * spi)
         return;
     }
     SPI_MUTEX_LOCK();
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->misc.cs_keep_active = 0;
-#else
     spi->dev->pin.cs_keep_active = 0;
-#endif
     SPI_MUTEX_UNLOCK();
 }
 
@@ -487,11 +318,7 @@ uint8_t spiGetDataMode(spi_t * spi)
     if(!spi) {
         return 0;
     }
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
-    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) {
@@ -513,36 +340,20 @@ void spiSetDataMode(spi_t * spi, uint8_t dataMode)
     SPI_MUTEX_LOCK();
     switch (dataMode) {
     case SPI_MODE1:
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
-        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 || CONFIG_IDF_TARGET_ESP32C3
-        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 || CONFIG_IDF_TARGET_ESP32C3
-        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 || CONFIG_IDF_TARGET_ESP32C3
-        spi->dev->misc.ck_idle_edge = 0;
-#else
         spi->dev->pin.ck_idle_edge = 0;
-#endif
         spi->dev->user.ck_out_edge = 0;
         break;
     }
@@ -585,48 +396,28 @@ static void _on_apb_change(void * arg, apb_change_ev_t ev_type, uint32_t old_apb
     }
 }
 
-static void spiInitBus(spi_t * spi)
-{
-#ifndef CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->slave.trans_done = 0;
-#endif
-    spi->dev->slave.val = 0;
-#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->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;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->ctrl1.val = 0;
-    spi->dev->ctrl2.val = 0;
-#else
-    spi->dev->clk_gate.val = 0;
-    spi->dev->dma_conf.val = 0;
-    spi->dev->dma_conf.rx_afifo_rst = 1;
-    spi->dev->dma_conf.buf_afifo_rst = 1;
-#endif
-    spi->dev->clock.val = 0;
-}
-
 void spiStopBus(spi_t * spi)
 {
     if(!spi) {
         return;
     }
-
-    removeApbChangeCallback(spi, _on_apb_change);
-
     SPI_MUTEX_LOCK();
-    spiInitBus(spi);
+    spi->dev->slave.trans_done = 0;
+    spi->dev->slave.slave_mode = 0;
+    spi->dev->pin.val = 0;
+    spi->dev->user.val = 0;
+    spi->dev->user1.val = 0;
+    spi->dev->ctrl.val = 0;
+    spi->dev->ctrl1.val = 0;
+    spi->dev->ctrl2.val = 0;
+    spi->dev->clock.val = 0;
     SPI_MUTEX_UNLOCK();
+    removeApbChangeCallback(spi, _on_apb_change);
 }
 
 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;
     }
 
@@ -641,18 +432,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);
-    }
-#elif CONFIG_IDF_TARGET_ESP32
     if(spi_num == HSPI) {
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI2_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI2_RST);
@@ -663,36 +442,24 @@ spi_t * spiStartBus(uint8_t spi_num, uint32_t clockDiv, uint8_t dataMode, uint8_
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI01_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI01_RST);
     }
-#elif CONFIG_IDF_TARGET_ESP32C3
-    periph_module_reset( PERIPH_SPI2_MODULE );
-    periph_module_enable( PERIPH_SPI2_MODULE );
-#endif
+
+    spiStopBus(spi);
+    spiSetDataMode(spi, dataMode);
+    spiSetBitOrder(spi, bitOrder);
+    spiSetClockDiv(spi, clockDiv);
 
     SPI_MUTEX_LOCK();
-    spiInitBus(spi);
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->clk_gate.clk_en = 1;
-    spi->dev->clk_gate.mst_clk_sel = 1;
-    spi->dev->clk_gate.mst_clk_active = 1;
-    spi->dev->dma_conf.tx_seg_trans_clr_en = 1;
-    spi->dev->dma_conf.rx_seg_trans_clr_en = 1;
-    spi->dev->dma_conf.dma_seg_trans_en = 0;
-#endif
     spi->dev->user.usr_mosi = 1;
     spi->dev->user.usr_miso = 1;
     spi->dev->user.doutdin = 1;
+
     int i;
     for(i=0; i<16; i++) {
         spi->dev->data_buf[i] = 0x00000000;
     }
     SPI_MUTEX_UNLOCK();
 
-    spiSetDataMode(spi, dataMode);
-    spiSetBitOrder(spi, bitOrder);
-    spiSetClockDiv(spi, clockDiv);
-
     addApbChangeCallback(spi, _on_apb_change);
-
     return spi;
 }
 
@@ -704,16 +471,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
-#elif CONFIG_IDF_TARGET_ESP32C3
-#define usr_mosi_dbitlen ms_data_bitlen
-#define usr_miso_dbitlen ms_data_bitlen
-#define mosi_dlen ms_dlen
-#define miso_dlen ms_dlen
-#endif
-
 void spiWrite(spi_t * spi, const uint32_t *data, uint8_t len)
 {
     if(!spi) {
@@ -725,16 +482,10 @@ void spiWrite(spi_t * spi, const uint32_t *data, uint8_t len)
     }
     SPI_MUTEX_LOCK();
     spi->dev->mosi_dlen.usr_mosi_dbitlen = (len * 32) - 1;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     for(i=0; i<len; i++) {
         spi->dev->data_buf[i] = data[i];
     }
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     SPI_MUTEX_UNLOCK();
@@ -755,10 +506,6 @@ void spiTransfer(spi_t * spi, uint32_t *data, uint8_t len)
     for(i=0; i<len; i++) {
         spi->dev->data_buf[i] = data[i];
     }
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     for(i=0; i<len; i++) {
@@ -774,14 +521,8 @@ void spiWriteByte(spi_t * spi, uint8_t data)
     }
     SPI_MUTEX_LOCK();
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     SPI_MUTEX_UNLOCK();
@@ -796,10 +537,6 @@ uint8_t spiTransferByte(spi_t * spi, uint8_t data)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
     spi->dev->miso_dlen.usr_miso_dbitlen = 7;
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0] & 0xFF;
@@ -827,14 +564,8 @@ void spiWriteWord(spi_t * spi, uint16_t data)
     }
     SPI_MUTEX_LOCK();
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     SPI_MUTEX_UNLOCK();
@@ -852,10 +583,6 @@ uint16_t spiTransferWord(spi_t * spi, uint16_t data)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
     spi->dev->miso_dlen.usr_miso_dbitlen = 15;
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0];
@@ -876,14 +603,8 @@ void spiWriteLong(spi_t * spi, uint32_t data)
     }
     SPI_MUTEX_LOCK();
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     SPI_MUTEX_UNLOCK();
@@ -901,10 +622,6 @@ uint32_t spiTransferLong(spi_t * spi, uint32_t data)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
     spi->dev->miso_dlen.usr_miso_dbitlen = 31;
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0];
@@ -944,10 +661,6 @@ static void __spiTransferBytes(spi_t * spi, const uint8_t * data, uint8_t * out,
         spi->dev->data_buf[i] = wordsBuf[i];    //copy buffer to spi fifo
     }
 
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
 
     while(spi->dev->cmd.usr);
@@ -1011,39 +724,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 || CONFIG_IDF_TARGET_ESP32C3
-        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 || CONFIG_IDF_TARGET_ESP32C3
-        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 || CONFIG_IDF_TARGET_ESP32C3
-        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 || CONFIG_IDF_TARGET_ESP32C3
-        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;
@@ -1070,20 +767,14 @@ 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;
     }
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
 }
@@ -1096,17 +787,13 @@ uint8_t spiTransferByteNL(spi_t * spi, uint8_t data)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 7;
     spi->dev->miso_dlen.usr_miso_dbitlen = 7;
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0] & 0xFF;
     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;
@@ -1115,14 +802,8 @@ void ARDUINO_ISR_ATTR spiWriteShortNL(spi_t * spi, uint16_t data)
         MSB_16_SET(data, data);
     }
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
 }
@@ -1138,10 +819,6 @@ uint16_t spiTransferShortNL(spi_t * spi, uint16_t data)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 15;
     spi->dev->miso_dlen.usr_miso_dbitlen = 15;
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0] & 0xFFFF;
@@ -1151,7 +828,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;
@@ -1160,14 +837,8 @@ void ARDUINO_ISR_ATTR spiWriteLongNL(spi_t * spi, uint32_t data)
         MSB_32_SET(data, data);
     }
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
 }
@@ -1183,10 +854,6 @@ uint32_t spiTransferLongNL(spi_t * spi, uint32_t data)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = 31;
     spi->dev->miso_dlen.usr_miso_dbitlen = 31;
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0];
@@ -1197,9 +864,6 @@ uint32_t spiTransferLongNL(spi_t * spi, uint32_t data)
 }
 
 void spiWriteNL(spi_t * spi, const void * data_in, uint32_t len){
-    if(!spi) {
-        return;
-    }
     size_t longs = len >> 2;
     if(len & 3){
         longs++;
@@ -1212,16 +876,10 @@ void spiWriteNL(spi_t * spi, const void * data_in, uint32_t len){
         c_longs = (longs > 16)?16:longs;
 
         spi->dev->mosi_dlen.usr_mosi_dbitlen = (c_len*8)-1;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
+        spi->dev->miso_dlen.usr_miso_dbitlen = 0;
         for (int i=0; i<c_longs; i++) {
             spi->dev->data_buf[i] = data[i];
         }
-#if CONFIG_IDF_TARGET_ESP32C3
-        spi->dev->cmd.update = 1;
-        while (spi->dev->cmd.update);
-#endif
         spi->dev->cmd.usr = 1;
         while(spi->dev->cmd.usr);
 
@@ -1258,27 +916,11 @@ void spiTransferBytesNL(spi_t * spi, const void * data_in, uint8_t * data_out, u
                 spi->dev->data_buf[i] = 0xFFFFFFFF;
             }
         }
-#if CONFIG_IDF_TARGET_ESP32C3
-        spi->dev->cmd.update = 1;
-        while (spi->dev->cmd.update);
-#endif
         spi->dev->cmd.usr = 1;
         while(spi->dev->cmd.usr);
         if(result){
-            if(c_len & 3){
-                for (int i=0; i<(c_longs-1); i++) {
-                    result[i] = spi->dev->data_buf[i];
-                }
-                uint32_t last_data = spi->dev->data_buf[c_longs-1];
-                uint8_t * last_out8 = (uint8_t *)&result[c_longs-1];
-                uint8_t * last_data8 = (uint8_t *)&last_data;
-                for (int i=0; i<(c_len & 3); i++) {
-                    last_out8[i] = last_data8[i];
-                }
-            } else {
-                for (int i=0; i<c_longs; i++) {
-                    result[i] = spi->dev->data_buf[i];
-                }
+            for (int i=0; i<c_longs; i++) {
+                result[i] = spi->dev->data_buf[i];
             }
         }
         if(data){
@@ -1317,10 +959,6 @@ void spiTransferBitsNL(spi_t * spi, uint32_t data, uint32_t * out, uint8_t bits)
     spi->dev->mosi_dlen.usr_mosi_dbitlen = (bits - 1);
     spi->dev->miso_dlen.usr_miso_dbitlen = (bits - 1);
     spi->dev->data_buf[0] = data;
-#if CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->cmd.update = 1;
-    while (spi->dev->cmd.update);
-#endif
     spi->dev->cmd.usr = 1;
     while(spi->dev->cmd.usr);
     data = spi->dev->data_buf[0];
@@ -1338,7 +976,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++;
@@ -1353,9 +991,7 @@ void ARDUINO_ISR_ATTR spiWritePixelsNL(spi_t * spi, const void * data_in, uint32
         l_bytes = (c_len & 3);
 
         spi->dev->mosi_dlen.usr_mosi_dbitlen = (c_len*8)-1;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
-    spi->dev->miso_dlen.usr_miso_dbitlen = 0;
-#endif
+        spi->dev->miso_dlen.usr_miso_dbitlen = 0;
         for (int i=0; i<c_longs; i++) {
             if(msb){
                 if(l_bytes && i == (c_longs - 1)){
@@ -1371,10 +1007,6 @@ void ARDUINO_ISR_ATTR spiWritePixelsNL(spi_t * spi, const void * data_in, uint32
                 spi->dev->data_buf[i] = data[i];
             }
         }
-#if CONFIG_IDF_TARGET_ESP32C3
-        spi->dev->cmd.update = 1;
-        while (spi->dev->cmd.update);
-#endif
         spi->dev->cmd.usr = 1;
         while(spi->dev->cmd.usr);
 
@@ -1397,12 +1029,7 @@ typedef union {
             uint32_t clkcnt_l:       6;                     /*it must be equal to spi_clkcnt_N.*/
             uint32_t clkcnt_h:       6;                     /*it must be floor((spi_clkcnt_N+1)/2-1).*/
             uint32_t clkcnt_n:       6;                     /*it is the divider of spi_clk. So spi_clk frequency is system/(spi_clkdiv_pre+1)/(spi_clkcnt_N+1)*/
-#if CONFIG_IDF_TARGET_ESP32C3
-            uint32_t clkdiv_pre:     4;                     /*it is pre-divider of spi_clk.*/
-            uint32_t reserved:       9;  					/*reserved*/
-#else
             uint32_t clkdiv_pre:    13;                     /*it is pre-divider of spi_clk.*/
-#endif
             uint32_t clk_equ_sysclk: 1;                     /*1: spi_clk is eqaul to system 0: spi_clk is divided from system clock.*/
     };
 } spiClk_t;
@@ -1444,13 +1071,8 @@ uint32_t spiFrequencyToClockDiv(uint32_t freq)
 
         while(calPreVari++ <= 1) {
             calPre = (((apb_freq / (reg.clkcnt_n + 1)) / freq) - 1) + calPreVari;
-#if CONFIG_IDF_TARGET_ESP32C3
-            if(calPre > 0xF) {
-                reg.clkdiv_pre = 0xF;
-#else
             if(calPre > 0x1FFF) {
                 reg.clkdiv_pre = 0x1FFF;
-#endif
             } else if(calPre <= 0) {
                 reg.clkdiv_pre = 0;
             } else {

cores/esp32/esp32-hal-spi.h

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

cores/esp32/esp32-hal-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

@@ -14,28 +14,17 @@
 
 #include "esp32-hal-timer.h"
 #include "freertos/FreeRTOS.h"
-#ifndef CONFIG_IDF_TARGET_ESP32C3
 #include "freertos/xtensa_api.h"
-#include "soc/dport_reg.h"
-#endif
 #include "freertos/task.h"
 #include "soc/timer_group_struct.h"
+#include "soc/dport_reg.h"
 #include "esp_attr.h"
-#include "driver/periph_ctrl.h"
 
 #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"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
-#include "esp_intr_alloc.h"
-#include "soc/periph_defs.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -89,18 +78,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
@@ -232,29 +214,15 @@ hw_timer_t * timerBegin(uint8_t num, uint16_t divider, bool countUp){
     }
     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);
@@ -283,18 +251,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 {
@@ -302,15 +260,12 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
         timer->dev->config.level_int_en = edge?0:1;//When set, an alarm will generate a level type interrupt.
         timer->dev->config.edge_int_en = edge?1:0;//When set, an alarm will generate an edge type interrupt.
         int intr_source = 0;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
         if(!edge){
-#endif
             if(timer->group){
                 intr_source = ETS_TG1_T0_LEVEL_INTR_SOURCE + timer->timer;
             } else {
                 intr_source = ETS_TG0_T0_LEVEL_INTR_SOURCE + timer->timer;
             }
-#ifndef CONFIG_IDF_TARGET_ESP32C3
         } else {
             if(timer->group){
                 intr_source = ETS_TG1_T0_EDGE_INTR_SOURCE + timer->timer;
@@ -318,10 +273,9 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
                 intr_source = ETS_TG0_T0_EDGE_INTR_SOURCE + timer->timer;
             }
         }
-#endif
         if(!initialized){
             initialized = true;
-            esp_intr_alloc(intr_source, (int)(ARDUINO_ISR_FLAG|ESP_INTR_FLAG_LOWMED), __timerISR, NULL, &intr_handle);
+            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));
         }

cores/esp32/esp32-hal-tinyusb.c

@@ -1,766 +0,0 @@
-
-#include "sdkconfig.h"
-#if CONFIG_TINYUSB_ENABLED
-#include <stdlib.h>
-#include <stdbool.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/usb_periph.h"
-#include "soc/periph_defs.h"
-#include "soc/timer_group_struct.h"
-#include "soc/system_reg.h"
-
-#include "hal/usb_hal.h"
-#include "hal/gpio_ll.h"
-
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-
-#include "driver/gpio.h"
-#include "driver/periph_ctrl.h"
-
-#include "esp_efuse.h"
-#include "esp_efuse_table.h"
-#include "esp_rom_gpio.h"
-
-#include "esp32-hal.h"
-
-#include "esp32-hal-tinyusb.h"
-#include "esp32s2/rom/usb/usb_persist.h"
-#include "esp32s2/rom/usb/usb_dc.h"
-#include "esp32s2/rom/usb/chip_usb_dw_wrapper.h"
-
-typedef enum{
-    TINYUSB_USBDEV_0,
-} tinyusb_usbdev_t;
-
-typedef char *tusb_desc_strarray_device_t[USB_STRING_DESCRIPTOR_ARRAY_SIZE];
-
-typedef struct {
-    bool external_phy;
-} tinyusb_config_t;
-
-static void configure_pins(usb_hal_context_t *usb)
-{
-    for (const usb_iopin_dsc_t *iopin = usb_periph_iopins; iopin->pin != -1; ++iopin) {
-        if ((usb->use_external_phy) || (iopin->ext_phy_only == 0)) {
-            esp_rom_gpio_pad_select_gpio(iopin->pin);
-            if (iopin->is_output) {
-                esp_rom_gpio_connect_out_signal(iopin->pin, iopin->func, false, false);
-            } else {
-                esp_rom_gpio_connect_in_signal(iopin->pin, iopin->func, false);
-                if ((iopin->pin != GPIO_FUNC_IN_LOW) && (iopin->pin != GPIO_FUNC_IN_HIGH)) {
-                    gpio_ll_input_enable(&GPIO, iopin->pin);
-                }
-            }
-            esp_rom_gpio_pad_unhold(iopin->pin);
-        }
-    }
-    if (!usb->use_external_phy) {
-        gpio_set_drive_capability(USBPHY_DM_NUM, GPIO_DRIVE_CAP_3);
-        gpio_set_drive_capability(USBPHY_DP_NUM, GPIO_DRIVE_CAP_3);
-    }
-}
-
-esp_err_t tinyusb_driver_install(const tinyusb_config_t *config)
-{
-    log_i("Driver installation...");
-
-    // Hal init
-    usb_hal_context_t hal = {
-        .use_external_phy = config->external_phy
-    };
-    usb_hal_init(&hal);
-    configure_pins(&hal);
-
-    if (!tusb_init()) {
-        log_e("Can't initialize the TinyUSB stack.");
-        return ESP_FAIL;
-    }
-    log_i("Driver installed");
-    return ESP_OK;
-}
-
-
-
-
-
-
-
-
-
-
-typedef char tusb_str_t[127];
-
-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(uint8_t itf){return NULL;}
-__attribute__ ((weak)) uint16_t tud_hid_get_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen){return 0;}
-__attribute__ ((weak)) void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, const uint8_t * buffer, uint16_t bufsize){}
-#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);
-            } else {
-                periph_module_reset(PERIPH_USB_MODULE);
-                periph_module_enable(PERIPH_USB_MODULE);
-            }
-            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 
-    if(!usb_did_persist || !usb_persist_enabled){
-        // 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_TINYUSB_ENABLED */

cores/esp32/esp32-hal-tinyusb.h

@@ -1,108 +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_TINYUSB_ENABLED
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "tusb.h"
-#include "tusb_option.h"
-#include "tusb_config.h"
-
-#define USB_ESPRESSIF_VID 0x303A
-#define USB_STRING_DESCRIPTOR_ARRAY_SIZE 10
-
-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_TINYUSB_DESC_PRODUCT_STRING,                 \
-        .manufacturer_name = CONFIG_TINYUSB_DESC_MANUFACTURER_STRING,       \
-        .serial_number = CONFIG_TINYUSB_DESC_SERIAL_STRING,                 \
-        .fw_version = CONFIG_TINYUSB_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_TINYUSB_ENABLED */
-#endif /* CONFIG_IDF_TARGET_ESP32S2 */

cores/esp32/esp32-hal-touch.c

@@ -13,25 +13,18 @@
 // limitations under the License.
 
 #include "esp32-hal-touch.h"
-#ifndef CONFIG_IDF_TARGET_ESP32C3
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_attr.h"
 #include "soc/rtc_io_reg.h"
-#include "soc/sens_reg.h"
-#include "soc/sens_struct.h"
 #include "soc/rtc_cntl_reg.h"
-#include "driver/touch_sensor.h"
+#include "soc/sens_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 "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
@@ -47,9 +40,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;
@@ -66,21 +58,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()
@@ -90,27 +77,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)
@@ -124,7 +99,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,
@@ -156,25 +130,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)
@@ -190,7 +145,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);
 
@@ -218,12 +172,8 @@ 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")));
 extern void touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), uint16_t threshold) __attribute__ ((weak, alias("__touchAttachInterrupt")));
 extern void touchSetCycles(uint16_t measure, uint16_t sleep) __attribute__ ((weak, alias("__touchSetCycles")));
-#endif

cores/esp32/esp32-hal-uart.c

@@ -23,25 +23,15 @@
 #include "soc/uart_struct.h"
 #include "soc/io_mux_reg.h"
 #include "soc/gpio_sig_map.h"
+#include "soc/dport_reg.h"
 #include "soc/rtc.h"
-#include "hal/uart_ll.h"
 #include "esp_intr_alloc.h"
 
 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
-#include "soc/dport_reg.h"
 #include "esp32/rom/ets_sys.h"
 #include "esp32/rom/uart.h"
-#elif CONFIG_IDF_TARGET_ESP32S2
-#include "soc/dport_reg.h"
-#include "esp32s2/rom/ets_sys.h"
-#include "esp32s2/rom/uart.h"
-#include "soc/periph_defs.h"
-#elif CONFIG_IDF_TARGET_ESP32C3
-#include "esp32c3/rom/ets_sys.h"
-#include "esp32c3/rom/uart.h"
-#include "soc/periph_defs.h"
 #else 
 #error Target CONFIG_IDF_TARGET is not supported
 #endif
@@ -51,25 +41,10 @@
 #include "esp_intr.h"
 #endif
 
-#if CONFIG_IDF_TARGET_ESP32
-#define UART_PORTS_NUM 3
 #define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:(    (u==2)?DR_REG_UART2_BASE:0)))
 #define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:(         (u==2)?U2RXD_IN_IDX:0)))
 #define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:(        (u==2)?U2TXD_OUT_IDX:0)))
 #define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:((u==2)?ETS_UART2_INTR_SOURCE:0)))
-#elif CONFIG_IDF_TARGET_ESP32S2
-#define UART_PORTS_NUM 2
-#define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:0))
-#define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:0))
-#define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:0))
-#define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:0))
-#else
-#define UART_PORTS_NUM 2
-#define UART_REG_BASE(u)    ((u==0)?DR_REG_UART_BASE:(      (u==1)?DR_REG_UART1_BASE:0))
-#define UART_RXD_IDX(u)     ((u==0)?U0RXD_IN_IDX:(          (u==1)?U1RXD_IN_IDX:0))
-#define UART_TXD_IDX(u)     ((u==0)?U0TXD_OUT_IDX:(         (u==1)?U1TXD_OUT_IDX:0))
-#define UART_INTR_SOURCE(u) ((u==0)?ETS_UART0_INTR_SOURCE:( (u==1)?ETS_UART1_INTR_SOURCE:0))
-#endif
 
 static int s_uart_debug_nr = 0;
 
@@ -87,35 +62,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;
@@ -123,15 +94,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 && !xQueueIsQueueFullFromISR(uart->queue)) {
                 xQueueSendFromISR(uart->queue, &c, &xHigherPriorityTaskWoken);
             }
         }
@@ -142,26 +107,22 @@ static void ARDUINO_ISR_ATTR _uart_isr(void *arg)
     }
 }
 
-static void uartEnableInterrupt(uart_t* uart, uint8_t rxfifo_full_thrhd)
+void uartEnableInterrupt(uart_t* uart)
 {
     UART_MUTEX_LOCK();
-    uart->dev->conf1.rxfifo_full_thrhd = rxfifo_full_thrhd;
-#if CONFIG_IDF_TARGET_ESP32
+    uart->dev->conf1.rxfifo_full_thrhd = 112;
     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();
 }
 
-static void uartDisableInterrupt(uart_t* uart)
+void uartDisableInterrupt(uart_t* uart)
 {
     UART_MUTEX_LOCK();
     uart->dev->conf1.val = 0;
@@ -174,45 +135,45 @@ static void uartDisableInterrupt(uart_t* uart)
     UART_MUTEX_UNLOCK();
 }
 
-static void uartDetachRx(uart_t* uart, uint8_t rxPin)
+void uartDetachRx(uart_t* uart)
 {
     if(uart == NULL) {
         return;
     }
-    pinMatrixInDetach(rxPin, false, false);
+    pinMatrixInDetach(UART_RXD_IDX(uart->num), false, false);
     uartDisableInterrupt(uart);
 }
 
-static void uartDetachTx(uart_t* uart, uint8_t txPin)
+void uartDetachTx(uart_t* uart)
 {
     if(uart == NULL) {
         return;
     }
-    pinMatrixOutDetach(txPin, false, false);
+    pinMatrixOutDetach(UART_TXD_IDX(uart->num), false, false);
 }
 
-static void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted, uint8_t rxfifo_full_thrhd)
+void uartAttachRx(uart_t* uart, uint8_t rxPin, bool inverted)
 {
-    if(uart == NULL || rxPin >= GPIO_PIN_COUNT) {
+    if(uart == NULL || rxPin > 39) {
         return;
     }
     pinMode(rxPin, INPUT);
-    uartEnableInterrupt(uart, rxfifo_full_thrhd);
     pinMatrixInAttach(rxPin, UART_RXD_IDX(uart->num), inverted);
+    uartEnableInterrupt(uart);
 }
 
-static void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
+void uartAttachTx(uart_t* uart, uint8_t txPin, bool inverted)
 {
-    if(uart == NULL || txPin >= GPIO_PIN_COUNT) {
+    if(uart == NULL || txPin > 39) {
         return;
     }
     pinMode(txPin, OUTPUT);
     pinMatrixOutAttach(txPin, UART_TXD_IDX(uart->num), inverted, false);
 }
 
-uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted, uint8_t rxfifo_full_thrhd)
+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;
     }
 
@@ -237,22 +198,16 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
             return NULL;
         }
     }
-#if CONFIG_IDF_TARGET_ESP32C3
-
-#else
     if(uart_nr == 1){
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART1_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART1_RST);
-#if CONFIG_IDF_TARGET_ESP32
     } else if(uart_nr == 2){
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART2_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART2_RST);
-#endif
     } else {
         DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_UART_CLK_EN);
         DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_UART_RST);
     }
-#endif
     uartFlush(uart);
     uartSetBaudRate(uart, baudrate);
     UART_MUTEX_LOCK();
@@ -264,15 +219,10 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
         uart->dev->conf0.stop_bit_num = ONE_STOP_BITS_CONF;
         uart->dev->rs485_conf.dl1_en = 1;
     }
-
-    // tx_idle_num : idle interval after tx FIFO is empty(unit: the time it takes to send one bit under current baudrate)
-    // Setting it to 0 prevents line idle time/delays when sending messages with small intervals
-    uart->dev->idle_conf.tx_idle_num = 0;  //
-
     UART_MUTEX_UNLOCK();
 
     if(rxPin != -1) {
-        uartAttachRx(uart, rxPin, inverted, rxfifo_full_thrhd);
+        uartAttachRx(uart, rxPin, inverted);
     }
 
     if(txPin != -1) {
@@ -282,7 +232,7 @@ uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rx
     return uart;
 }
 
-void uartEnd(uart_t* uart, uint8_t txPin, uint8_t rxPin)
+void uartEnd(uart_t* uart)
 {
     if(uart == NULL) {
         return;
@@ -299,8 +249,8 @@ void uartEnd(uart_t* uart, uint8_t txPin, uint8_t rxPin)
 
     UART_MUTEX_UNLOCK();
 
-    uartDetachRx(uart, rxPin);
-    uartDetachTx(uart, txPin);
+    uartDetachRx(uart);
+    uartDetachTx(uart);
 }
 
 size_t uartResizeRxBuffer(uart_t * uart, size_t new_size) {
@@ -313,7 +263,6 @@ size_t uartResizeRxBuffer(uart_t * uart, size_t new_size) {
         vQueueDelete(uart->queue);
         uart->queue = xQueueCreate(new_size, sizeof(uint8_t));
         if(uart->queue == NULL) {
-            UART_MUTEX_UNLOCK();
             return 0;
         }
     }
@@ -322,27 +271,12 @@ size_t uartResizeRxBuffer(uart_t * uart, size_t new_size) {
     return new_size;
 }
 
-void uartSetRxInvert(uart_t* uart, bool invert)
-{
-    if (uart == NULL)
-        return;
-    
-    if (invert)
-        uart->dev->conf0.rxd_inv = 1;
-    else
-        uart->dev->conf0.rxd_inv = 0;
-}
-
 uint32_t uartAvailable(uart_t* uart)
 {
     if(uart == NULL || uart->queue == NULL) {
         return 0;
     }
-#ifdef UART_READ_RX_FIFO
-    return (uxQueueMessagesWaiting(uart->queue) + uart->dev->status.rxfifo_cnt) ;
-#else
     return uxQueueMessagesWaiting(uart->queue);
-#endif
 }
 
 uint32_t uartAvailableForWrite(uart_t* uart)
@@ -353,45 +287,12 @@ uint32_t uartAvailableForWrite(uart_t* uart)
     return 0x7f - uart->dev->status.txfifo_cnt;
 }
 
-#ifdef UART_READ_RX_FIFO
-void uartRxFifoToQueue(uart_t* uart)
-{
-	uint8_t c;
-    UART_MUTEX_LOCK();
-	//disable interrupts
-	uart->dev->int_ena.val = 0;
-	uart->dev->int_clr.val = 0xffffffff;
-#if CONFIG_IDF_TARGET_ESP32
-	while (uart->dev->status.rxfifo_cnt || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
-		c = uart->dev->fifo.rw_byte;
-#else
-	uint32_t fifo_reg = UART_FIFO_AHB_REG(uart->num);
-	while (uart->dev->status.rxfifo_cnt) {
-		c = ESP_REG(fifo_reg);
-#endif
-		xQueueSend(uart->queue, &c, 0);
-	}
-	//enable interrupts
-	uart->dev->int_ena.rxfifo_full = 1;
-	uart->dev->int_ena.frm_err = 1;
-	uart->dev->int_ena.rxfifo_tout = 1;
-	uart->dev->int_clr.val = 0xffffffff;
-    UART_MUTEX_UNLOCK();
-}
-#endif
-
 uint8_t uartRead(uart_t* uart)
 {
     if(uart == NULL || uart->queue == NULL) {
         return 0;
     }
     uint8_t c;
-#ifdef UART_READ_RX_FIFO
-    if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
-    {
-    	uartRxFifoToQueue(uart);
-    }
-#endif
     if(xQueueReceive(uart->queue, &c, 0)) {
         return c;
     }
@@ -404,12 +305,6 @@ uint8_t uartPeek(uart_t* uart)
         return 0;
     }
     uint8_t c;
-#ifdef UART_READ_RX_FIFO
-    if ((uxQueueMessagesWaiting(uart->queue) == 0) && (uart->dev->status.rxfifo_cnt > 0))
-    {
-    	uartRxFifoToQueue(uart);
-    }
-#endif
     if(xQueuePeek(uart->queue, &c, 0)) {
         return c;
     }
@@ -423,11 +318,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();
 }
 
@@ -437,16 +328,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();
@@ -454,7 +338,7 @@ void uartWriteBuf(uart_t* uart, const uint8_t * data, size_t len)
 
 void uartFlush(uart_t* uart)
 {
-    uartFlushTxOnly(uart,true);
+    uartFlushTxOnly(uart,false);
 }
 
 void uartFlushTxOnly(uart_t* uart, bool txOnly)
@@ -464,7 +348,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 ){
@@ -478,11 +361,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();
 }
@@ -493,7 +371,9 @@ void uartSetBaudRate(uart_t* uart, uint32_t baud_rate)
         return;
     }
     UART_MUTEX_LOCK();
-    uart_ll_set_baudrate(uart->dev, baud_rate);
+    uint32_t clk_div = ((getApbFrequency()<<4)/baud_rate);
+    uart->dev->clk_div.div_int = clk_div>>4 ;
+    uart->dev->clk_div.div_frag = clk_div & 0xf;
     UART_MUTEX_UNLOCK();
 }
 
@@ -508,14 +388,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);
             }
@@ -523,11 +397,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
@@ -560,35 +430,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()
 {
@@ -599,11 +457,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;
@@ -612,7 +468,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;
@@ -631,6 +487,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;
@@ -648,7 +507,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);
@@ -690,17 +549,15 @@ unsigned long uartBaudrateDetect(uart_t *uart, bool flg)
 */
 void uartStartDetectBaudrate(uart_t *uart) {
   if(!uart) return;
-#ifndef CONFIG_IDF_TARGET_ESP32C3
+
   uart->dev->auto_baud.glitch_filt = 0x08;
   uart->dev->auto_baud.en = 0;
   uart->dev->auto_baud.en = 1;
-#endif
 }
 
 unsigned long
 uartDetectBaudrate(uart_t *uart)
 {
-#ifndef CONFIG_IDF_TARGET_ESP32C3
     static bool uartStateDetectingBaudrate = false;
 
     if(!uartStateDetectingBaudrate) {
@@ -735,18 +592,11 @@ uartDetectBaudrate(uart_t *uart)
     }
 
     return default_rates[i];
-#else
-    return 0;
-#endif
 }
 
 /*
  * Returns the status of the RX state machine, if the value is non-zero the state machine is active.
  */
 bool uartRxActive(uart_t* uart) {
-#if CONFIG_IDF_TARGET_ESP32
     return uart->dev->status.st_urx_out != 0;
-#else
-    return 0;
-#endif
 }

cores/esp32/esp32-hal-uart.h

@@ -51,8 +51,8 @@ extern "C" {
 struct uart_struct_t;
 typedef struct uart_struct_t uart_t;
 
-uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted, uint8_t rxfifo_full_thrhd);
-void uartEnd(uart_t* uart, uint8_t rxPin, uint8_t txPin);
+uart_t* uartBegin(uint8_t uart_nr, uint32_t baudrate, uint32_t config, int8_t rxPin, int8_t txPin, uint16_t queueLen, bool inverted);
+void uartEnd(uart_t* uart);
 
 uint32_t uartAvailable(uart_t* uart);
 uint32_t uartAvailableForWrite(uart_t* uart);
@@ -70,8 +70,6 @@ uint32_t uartGetBaudRate(uart_t* uart);
 
 size_t uartResizeRxBuffer(uart_t* uart, size_t new_size);
 
-void uartSetRxInvert(uart_t* uart, bool invert);
-
 void uartSetDebug(uart_t* uart);
 int uartGetDebug();
 

cores/esp32/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>
@@ -32,32 +36,8 @@
 #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 +65,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,27 +2,10 @@
 #include "freertos/task.h"
 #include "esp_task_wdt.h"
 #include "Arduino.h"
-#if ARDUINO_SERIAL_PORT //Serial used for USB CDC
-#include "USB.h"
-#endif
-
-#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;
 
@@ -30,9 +13,6 @@ void loopTask(void *pvParameters)
 {
     setup();
     for(;;) {
-#if CONFIG_FREERTOS_UNICORE
-        yieldIfNecessary();
-#endif
         if(loopTaskWDTEnabled){
             esp_task_wdt_reset();
         }
@@ -43,12 +23,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", CONFIG_ARDUINO_LOOP_STACK_SIZE, NULL, 1, &loopTaskHandle, ARDUINO_RUNNING_CORE);
+    xTaskCreateUniversal(loopTask, "loopTask", 8192, NULL, 1, &loopTaskHandle, CONFIG_ARDUINO_RUNNING_CORE);
 }
 
 #endif

cores/esp32/pgmspace.h

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

cores/esp32/wiring_shift.c

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

docs/ISSUE_TEMPLATE.md

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

docs/arduino-ide/boards_manager.md

@@ -4,7 +4,7 @@
 - Stable release link: `https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json`
 - Development release link: `https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json`
 
-Starting with 1.6.4, Arduino allows installation of third-party platform packages using Boards Manager. We have packages available for Windows, Mac OS, and Linux (x86, amd64, armhf and arm64).
+Starting with 1.6.4, Arduino allows installation of third-party platform packages using Boards Manager. We have packages available for Windows, Mac OS, and Linux (32, 64 bit and ARM).
 
 - Install the current upstream Arduino IDE at the 1.8 level or later. The current version is at the [Arduino website](http://www.arduino.cc/en/main/software).
 - Start Arduino and open Preferences window.

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 python3 get-pip.py && \
-  sudo pip3 install pyserial && \
+  sudo python get-pip.py && \
+  sudo pip install pyserial && \
   mkdir -p ~/Arduino/hardware/espressif && \
   cd ~/Arduino/hardware/espressif && \
   git clone https://github.com/espressif/arduino-esp32.git esp32 && \

docs/arduino-ide/mac.md

@@ -7,9 +7,9 @@ Installation instructions for Mac OS
   ```bash
   mkdir -p ~/Documents/Arduino/hardware/espressif && \
   cd ~/Documents/Arduino/hardware/espressif && \
-  git clone https://github.com/espressif/arduino-esp32.git esp32 --depth 1 && \
+  git clone https://github.com/espressif/arduino-esp32.git esp32 && \
   cd esp32 && \
-  git submodule update --init --recursive --depth 1 && \
+  git submodule update --init --recursive && \
   cd tools && \
   python get.py 
   ```

docs/esp-idf_component.md

@@ -72,11 +72,6 @@ If you are writing code that does not require Arduino to compile and you want yo
 #endif
 ```
 
-## FreeRTOS Tick Rate (Hz)
-
-You might notice that Arduino-esp32's `delay()` function will only work in multiples of 10ms. That is because, by default, esp-idf handles task events 100 times per second.
-To fix that behavior you need to set FreeRTOS tick rate to 1000Hz in `make menuconfig` -> `Component config` -> `FreeRTOS` -> `Tick rate`.
-
 ## Compilation Errors
 
 As commits are made to esp-idf and submodules, the codebases can develop incompatibilities which cause compilation errors.  If you have problems compiling, follow the instructions in [Issue #1142](https://github.com/espressif/arduino-esp32/issues/1142) to roll esp-idf back to a known good version.

libraries/ArduinoOTA/examples/OTAWebUpdater/OTAWebUpdater.ino

@@ -14,7 +14,7 @@ WebServer server(80);
  * Login page
  */
 
-const char* loginIndex =
+const char* loginIndex = 
  "<form name='loginForm'>"
     "<table width='20%' bgcolor='A09F9F' align='center'>"
         "<tr>"
@@ -25,9 +25,8 @@ const char* loginIndex =
             "<br>"
             "<br>"
         "</tr>"
-        "<tr>"
-             "<td>Username:</td>"
-             "<td><input type='text' size=25 name='userid'><br></td>"
+        "<td>Username:</td>"
+        "<td><input type='text' size=25 name='userid'><br></td>"
         "</tr>"
         "<br>"
         "<br>"
@@ -55,12 +54,12 @@ const char* loginIndex =
     "}"
     "}"
 "</script>";
-
+ 
 /*
  * Server Index Page
  */
-
-const char* serverIndex =
+ 
+const char* serverIndex = 
 "<script src='https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js'></script>"
 "<form method='POST' action='#' enctype='multipart/form-data' id='upload_form'>"
    "<input type='file' name='update'>"
@@ -89,7 +88,7 @@ const char* serverIndex =
   "return xhr;"
   "},"
   "success:function(d, s) {"
-  "console.log('success!')"
+  "console.log('success!')" 
  "},"
  "error: function (a, b, c) {"
  "}"

libraries/ArduinoOTA/src/ArduinoOTA.cpp

@@ -88,17 +88,6 @@ ArduinoOTAClass& ArduinoOTAClass::setPasswordHash(const char * password) {
     return *this;
 }
 
-ArduinoOTAClass& ArduinoOTAClass::setPartitionLabel(const char * partition_label) {
-    if (!_initialized && !_partition_label.length() && partition_label) {
-        _partition_label = partition_label;
-    }
-    return *this;
-}
-
-String ArduinoOTAClass::getPartitionLabel() {
-    return _partition_label;
-}
-
 ArduinoOTAClass& ArduinoOTAClass::setRebootOnSuccess(bool reboot){
     _rebootOnSuccess = reboot;
     return *this;
@@ -246,8 +235,7 @@ void ArduinoOTAClass::_onRx(){
 }
 
 void ArduinoOTAClass::_runUpdate() {
-    const char *partition_label = _partition_label.length() ? _partition_label.c_str() : NULL;
-    if (!Update.begin(_size, _cmd, -1, LOW, partition_label)) {
+    if (!Update.begin(_size, _cmd)) {
 
         log_e("Begin ERROR: %s", Update.errorString());
 
@@ -370,7 +358,7 @@ void ArduinoOTAClass::end() {
 
 void ArduinoOTAClass::handle() {
     if (!_initialized) {
-        return;
+        return; 
     }
     if (_state == OTA_RUNUPDATE) {
         _runUpdate();

libraries/ArduinoOTA/src/ArduinoOTA.h

@@ -44,10 +44,6 @@ class ArduinoOTAClass
     //Sets the password as above but in the form MD5(password). Default NULL
     ArduinoOTAClass& setPasswordHash(const char *password);
 
-    //Sets the partition label to write to when updating SPIFFS. Default NULL
-    ArduinoOTAClass &setPartitionLabel(const char *partition_label);
-    String getPartitionLabel();
-
     //Sets if the device should be rebooted after successful update. Default true
     ArduinoOTAClass& setRebootOnSuccess(bool reboot);
 
@@ -84,7 +80,6 @@ class ArduinoOTAClass
     int _port;
     String _password;
     String _hostname;
-    String _partition_label;
     String _nonce;
     WiFiUDP _udp_ota;
     bool _initialized;

libraries/AsyncUDP/src/AsyncUDP.cpp

@@ -150,7 +150,7 @@ static bool _udp_task_start(){
         }
     }
     if(!_udp_task_handle){
-        xTaskCreateUniversal(_udp_task, "async_udp", 4096, NULL, CONFIG_ARDUINO_UDP_TASK_PRIORITY, (TaskHandle_t*)&_udp_task_handle, CONFIG_ARDUINO_UDP_RUNNING_CORE);
+        xTaskCreateUniversal(_udp_task, "async_udp", 4096, NULL, 3, (TaskHandle_t*)&_udp_task_handle, CONFIG_ARDUINO_UDP_RUNNING_CORE);
         if(!_udp_task_handle){
             return false;
         }
@@ -277,22 +277,6 @@ 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)
 {
@@ -310,18 +294,18 @@ AsyncUDPPacket::AsyncUDPPacket(AsyncUDP *udp, pbuf *pb, const ip_addr_t *raddr,
     _localIp.type = _remoteIp.type;
 
     eth_hdr* eth = NULL;
-    udp_hdr* udphdr = (udp_hdr *)(_data - UDP_HLEN);
+    udp_hdr* udphdr = reinterpret_cast<udp_hdr*>(_data - UDP_HLEN);
     _localPort = ntohs(udphdr->dest);
     _remotePort = ntohs(udphdr->src);
 
     if (_remoteIp.type == IPADDR_TYPE_V4) {
-        eth = (eth_hdr *)(_data - UDP_HLEN - IP_HLEN - SIZEOF_ETH_HDR);
-        struct ip_hdr * iphdr = (struct ip_hdr *)(_data - UDP_HLEN - IP_HLEN);
+        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);
         _localIp.u_addr.ip4.addr = iphdr->dest.addr;
         _remoteIp.u_addr.ip4.addr = iphdr->src.addr;
     } else {
-        eth = (eth_hdr *)(_data - UDP_HLEN - IP6_HLEN - SIZEOF_ETH_HDR);
-        struct ip6_hdr * ip6hdr = (struct ip6_hdr *)(_data - UDP_HLEN - IP6_HLEN);
+        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);
         memcpy(&_localIp.u_addr.ip6.addr, (uint8_t *)ip6hdr->dest.addr, 16);
         memcpy(&_remoteIp.u_addr.ip6.addr, (uint8_t *)ip6hdr->src.addr, 16);
     }
@@ -495,7 +479,6 @@ AsyncUDP::AsyncUDP()
 {
     _pcb = NULL;
     _connected = false;
-	_lastErr = ERR_OK;
     _handler = NULL;
 }
 
@@ -534,8 +517,8 @@ bool AsyncUDP::connect(const ip_addr_t *addr, uint16_t port)
     }
     close();
     UDP_MUTEX_LOCK();
-    _lastErr = _udp_connect(_pcb, addr, port);
-    if(_lastErr != ERR_OK) {
+    err_t err = _udp_connect(_pcb, addr, port);
+    if(err != ERR_OK) {
         UDP_MUTEX_UNLOCK();
         return false;
     }
@@ -663,7 +646,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;
     }
-    _lastErr = ERR_OK;
+    err_t err = ERR_OK;
     pbuf* pbt = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);
     if(pbt != NULL) {
         uint8_t* dst = reinterpret_cast<uint8_t*>(pbt->payload);
@@ -673,16 +656,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){
-                _lastErr = _udp_sendto(_pcb, pbt, addr, port);
+                err = _udp_sendto(_pcb, pbt, addr, port);
             } else {
-                _lastErr = _udp_sendto_if(_pcb, pbt, addr, port, (struct netif *)nif);
+                err = _udp_sendto_if(_pcb, pbt, addr, port, (struct netif *)nif);
             }
         } else {
-            _lastErr = _udp_sendto(_pcb, pbt, addr, port);
+            err = _udp_sendto(_pcb, pbt, addr, port);
         }
         UDP_MUTEX_UNLOCK();
         pbuf_free(pbt);
-        if(_lastErr < ERR_OK) {
+        if(err < ERR_OK) {
             return 0;
         }
         return len;
@@ -699,8 +682,9 @@ 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);
     }
 }
 
@@ -886,10 +870,6 @@ 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,7 +58,6 @@ 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();
 
@@ -96,7 +95,6 @@ protected:
     udp_pcb *_pcb;
     //xSemaphoreHandle _lock;
     bool _connected;
-	esp_err_t _lastErr;
     AuPacketHandlerFunction _handler;
 
     bool _init();
@@ -146,7 +144,6 @@ 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/examples/BLE_Beacon_Scanner/BLE_Beacon_Scanner.ino

@@ -1,153 +0,0 @@
-/*
-   Based on Neil Kolban example for IDF: https://github.com/nkolban/esp32-snippets/blob/master/cpp_utils/tests/BLE%20Tests/SampleScan.cpp
-   Ported to Arduino ESP32 by Evandro Copercini
-   Changed to a beacon scanner to report iBeacon, EddystoneURL and EddystoneTLM beacons by beegee-tokyo
-*/
-
-#include <Arduino.h>
-
-#include <BLEDevice.h>
-#include <BLEUtils.h>
-#include <BLEScan.h>
-#include <BLEAdvertisedDevice.h>
-#include <BLEEddystoneURL.h>
-#include <BLEEddystoneTLM.h>
-#include <BLEBeacon.h>
-
-#define ENDIAN_CHANGE_U16(x) ((((x)&0xFF00) >> 8) + (((x)&0xFF) << 8))
-
-int scanTime = 5; //In seconds
-BLEScan *pBLEScan;
-
-class MyAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks
-{
-    void onResult(BLEAdvertisedDevice advertisedDevice)
-    {
-      if (advertisedDevice.haveName())
-      {
-        Serial.print("Device name: ");
-        Serial.println(advertisedDevice.getName().c_str());
-        Serial.println("");
-      }
-
-      if (advertisedDevice.haveServiceUUID())
-      {
-        BLEUUID devUUID = advertisedDevice.getServiceUUID();
-        Serial.print("Found ServiceUUID: ");
-        Serial.println(devUUID.toString().c_str());
-        Serial.println("");
-      }
-      else
-      {
-        if (advertisedDevice.haveManufacturerData() == true)
-        {
-          std::string strManufacturerData = advertisedDevice.getManufacturerData();
-
-          uint8_t cManufacturerData[100];
-          strManufacturerData.copy((char *)cManufacturerData, strManufacturerData.length(), 0);
-
-          if (strManufacturerData.length() == 25 && cManufacturerData[0] == 0x4C && cManufacturerData[1] == 0x00)
-          {
-            Serial.println("Found an iBeacon!");
-            BLEBeacon oBeacon = BLEBeacon();
-            oBeacon.setData(strManufacturerData);
-            Serial.printf("iBeacon Frame\n");
-            Serial.printf("ID: %04X Major: %d Minor: %d UUID: %s Power: %d\n", oBeacon.getManufacturerId(), ENDIAN_CHANGE_U16(oBeacon.getMajor()), ENDIAN_CHANGE_U16(oBeacon.getMinor()), oBeacon.getProximityUUID().toString().c_str(), oBeacon.getSignalPower());
-          }
-          else
-          {
-            Serial.println("Found another manufacturers beacon!");
-            Serial.printf("strManufacturerData: %d ", strManufacturerData.length());
-            for (int i = 0; i < strManufacturerData.length(); i++)
-            {
-              Serial.printf("[%X]", cManufacturerData[i]);
-            }
-            Serial.printf("\n");
-          }
-        }
-        return;
-      }
-
-      uint8_t *payLoad = advertisedDevice.getPayload();
-
-      BLEUUID checkUrlUUID = (uint16_t)0xfeaa;
-
-      if (advertisedDevice.getServiceUUID().equals(checkUrlUUID))
-      {
-        if (payLoad[11] == 0x10)
-        {
-          Serial.println("Found an EddystoneURL beacon!");
-          BLEEddystoneURL foundEddyURL = BLEEddystoneURL();
-          std::string eddyContent((char *)&payLoad[11]); // incomplete EddystoneURL struct!
-
-          foundEddyURL.setData(eddyContent);
-          std::string bareURL = foundEddyURL.getURL();
-          if (bareURL[0] == 0x00)
-          {
-            size_t payLoadLen = advertisedDevice.getPayloadLength();
-            Serial.println("DATA-->");
-            for (int idx = 0; idx < payLoadLen; idx++)
-            {
-              Serial.printf("0x%08X ", payLoad[idx]);
-            }
-            Serial.println("\nInvalid Data");
-            return;
-          }
-
-          Serial.printf("Found URL: %s\n", foundEddyURL.getURL().c_str());
-          Serial.printf("Decoded URL: %s\n", foundEddyURL.getDecodedURL().c_str());
-          Serial.printf("TX power %d\n", foundEddyURL.getPower());
-          Serial.println("\n");
-        }
-        else if (payLoad[11] == 0x20)
-        {
-          Serial.println("Found an EddystoneTLM beacon!");
-          BLEEddystoneTLM foundEddyURL = BLEEddystoneTLM();
-          std::string eddyContent((char *)&payLoad[11]); // incomplete EddystoneURL struct!
-
-          eddyContent = "01234567890123";
-
-          for (int idx = 0; idx < 14; idx++)
-          {
-            eddyContent[idx] = payLoad[idx + 11];
-          }
-
-          foundEddyURL.setData(eddyContent);
-          Serial.printf("Reported battery voltage: %dmV\n", foundEddyURL.getVolt());
-          Serial.printf("Reported temperature from TLM class: %.2fC\n", (double)foundEddyURL.getTemp());
-          int temp = (int)payLoad[16] + (int)(payLoad[15] << 8);
-          float calcTemp = temp / 256.0f;
-          Serial.printf("Reported temperature from data: %.2fC\n", calcTemp);
-          Serial.printf("Reported advertise count: %d\n", foundEddyURL.getCount());
-          Serial.printf("Reported time since last reboot: %ds\n", foundEddyURL.getTime());
-          Serial.println("\n");
-          Serial.print(foundEddyURL.toString().c_str());
-          Serial.println("\n");
-        }
-      }
-    }
-};
-
-void setup()
-{
-  Serial.begin(115200);
-  Serial.println("Scanning...");
-
-  BLEDevice::init("");
-  pBLEScan = BLEDevice::getScan(); //create new scan
-  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
-  pBLEScan->setActiveScan(true); //active scan uses more power, but get results faster
-  pBLEScan->setInterval(100);
-  pBLEScan->setWindow(99); // less or equal setInterval value
-}
-
-void loop()
-{
-  // put your main code here, to run repeatedly:
-  BLEScanResults foundDevices = pBLEScan->start(scanTime, false);
-  Serial.print("Devices found: ");
-  Serial.println(foundDevices.getCount());
-  Serial.println("Scan done!");
-  pBLEScan->clearResults(); // delete results fromBLEScan buffer to release memory
-  delay(2000);
-}

libraries/BLE/examples/BLE_Beacon_Scanner/BLE_Beacon_Scanner.md

@@ -1,9 +0,0 @@
-## BLE Beacon Scanner
-
-Initiates a BLE device scan.
-Checks if the discovered devices are 
-- an iBeacon
-- an Eddystone TLM beacon
-- an Eddystone URL beacon
-
-and sends the decoded beacon information over Serial log

libraries/BLE/examples/BLE_EddystoneTLM_Beacon/BLE_EddystoneTLM_Beacon.ino

@@ -1,116 +0,0 @@
-/*
-   EddystoneTLM beacon by BeeGee based on https://github.com/pcbreflux/espressif/blob/master/esp32/arduino/sketchbook/ESP32_Eddystone_TLM_deepsleep/ESP32_Eddystone_TLM_deepsleep.ino
-   EddystoneTLM frame specification https://github.com/google/eddystone/blob/master/eddystone-tlm/tlm-plain.md
-*/
-
-/*
-   Create a BLE server that will send periodic Eddystone URL frames.
-   The design of creating the BLE server is:
-   1. Create a BLE Server
-   2. Create advertising data
-   3. Start advertising.
-   4. wait
-   5. Stop advertising.
-   6. deep sleep
-   
-*/
-#include "sys/time.h"
-
-#include <Arduino.h>
-
-#include "BLEDevice.h"
-#include "BLEUtils.h"
-#include "BLEBeacon.h"
-#include "BLEAdvertising.h"
-#include "BLEEddystoneURL.h"
-
-#include "esp_sleep.h"
-
-#define GPIO_DEEP_SLEEP_DURATION 10     // sleep x seconds and then wake up
-RTC_DATA_ATTR static time_t last;    // remember last boot in RTC Memory
-RTC_DATA_ATTR static uint32_t bootcount; // remember number of boots in RTC Memory
-
-// See the following for generating UUIDs:
-// https://www.uuidgenerator.net/
-BLEAdvertising *pAdvertising;
-struct timeval nowTimeStruct;
-
-time_t lastTenth;
-
-#define BEACON_UUID "8ec76ea3-6668-48da-9866-75be8bc86f4d" // UUID 1 128-Bit (may use linux tool uuidgen or random numbers via https://www.uuidgenerator.net/)
-
-// Check
-// https://github.com/google/eddystone/blob/master/eddystone-tlm/tlm-plain.md
-// and http://www.hugi.scene.org/online/coding/hugi%2015%20-%20cmtadfix.htm
-// for the temperature value. It is a 8.8 fixed-point notation
-void setBeacon()
-{
-  char beacon_data[25];
-  uint16_t beconUUID = 0xFEAA;
-  uint16_t volt = random(2800, 3700); // 3300mV = 3.3V
-  float tempFloat = random(2000, 3100) / 100.0f;
-  Serial.printf("Random temperature is %.2fC\n", tempFloat);
-  int temp = (int)(tempFloat * 256); //(uint16_t)((float)23.00);
-  Serial.printf("Converted to 8.8 format %0X%0X\n", (temp >> 8), (temp & 0xFF));
-
-  BLEAdvertisementData oAdvertisementData = BLEAdvertisementData();
-  BLEAdvertisementData oScanResponseData = BLEAdvertisementData();
-
-  oScanResponseData.setFlags(0x06); // GENERAL_DISC_MODE 0x02 | BR_EDR_NOT_SUPPORTED 0x04
-  oScanResponseData.setCompleteServices(BLEUUID(beconUUID));
-
-  beacon_data[0] = 0x20;                // Eddystone Frame Type (Unencrypted Eddystone-TLM)
-  beacon_data[1] = 0x00;                // TLM version
-  beacon_data[2] = (volt >> 8);           // Battery voltage, 1 mV/bit i.e. 0xCE4 = 3300mV = 3.3V
-  beacon_data[3] = (volt & 0xFF);           //
-  beacon_data[4] = (temp >> 8);           // Beacon temperature
-  beacon_data[5] = (temp & 0xFF);           //
-  beacon_data[6] = ((bootcount & 0xFF000000) >> 24);  // Advertising PDU count
-  beacon_data[7] = ((bootcount & 0xFF0000) >> 16);  //
-  beacon_data[8] = ((bootcount & 0xFF00) >> 8);   //
-  beacon_data[9] = (bootcount & 0xFF);        //
-  beacon_data[10] = ((lastTenth & 0xFF000000) >> 24); // Time since power-on or reboot as 0.1 second resolution counter
-  beacon_data[11] = ((lastTenth & 0xFF0000) >> 16);   //
-  beacon_data[12] = ((lastTenth & 0xFF00) >> 8);    //
-  beacon_data[13] = (lastTenth & 0xFF);       //
-
-  oScanResponseData.setServiceData(BLEUUID(beconUUID), std::string(beacon_data, 14));
-  oAdvertisementData.setName("TLMBeacon");
-  pAdvertising->setAdvertisementData(oAdvertisementData);
-  pAdvertising->setScanResponseData(oScanResponseData);
-}
-
-void setup()
-{
-
-  Serial.begin(115200);
-  gettimeofday(&nowTimeStruct, NULL);
-
-  Serial.printf("start ESP32 %d\n", bootcount++);
-
-  Serial.printf("deep sleep (%lds since last reset, %lds since last boot)\n", nowTimeStruct.tv_sec, nowTimeStruct.tv_sec - last);
-
-  last = nowTimeStruct.tv_sec;
-  lastTenth = nowTimeStruct.tv_sec * 10; // Time since last reset as 0.1 second resolution counter
-
-  // Create the BLE Device
-  BLEDevice::init("TLMBeacon");
-
-  BLEDevice::setPower(ESP_PWR_LVL_N12);
-
-  pAdvertising = BLEDevice::getAdvertising();
-
-  setBeacon();
-  // Start advertising
-  pAdvertising->start();
-  Serial.println("Advertizing started for 10s ...");
-  delay(10000);
-  pAdvertising->stop();
-  Serial.printf("enter deep sleep for 10s\n");
-  esp_deep_sleep(1000000LL * GPIO_DEEP_SLEEP_DURATION);
-  Serial.printf("in deep sleep\n");
-}
-
-void loop()
-{
-}

libraries/BLE/examples/BLE_EddystoneTLM_Beacon/BLE_EddystoneTLM_Beacon.md

@@ -1,14 +0,0 @@
-## Eddystone TLM beacon
-EddystoneTLM beacon by BeeGee based on
-[pcbreflux ESP32 Eddystone TLM deepsleep](https://github.com/pcbreflux/espressif/blob/master/esp32/arduino/sketchbook/ESP32_Eddystone_TLM_deepsleep/ESP32_Eddystone_TLM_deepsleep.ino)
-
-[EddystoneTLM frame specification](https://github.com/google/eddystone/blob/master/eddystone-tlm/tlm-plain.md)
-
-   Create a BLE server that will send periodic Eddystone TLM frames.
-   The design of creating the BLE server is:
-   1. Create a BLE Server
-   2. Create advertising data
-   3. Start advertising.
-   4. wait
-   5. Stop advertising.
-   6. deep sleep

libraries/BLE/examples/BLE_EddystoneURL_Beacon/BLE_EddystoneURL_Beacon.ino

@@ -1,192 +0,0 @@
-/*
-   EddystoneURL beacon by BeeGee
-   EddystoneURL frame specification https://github.com/google/eddystone/blob/master/eddystone-url/README.md
-
-*/
-
-/*
-   Create a BLE server that will send periodic Eddystone URL frames.
-   The design of creating the BLE server is:
-   1. Create a BLE Server
-   2. Create advertising data
-   3. Start advertising.
-   4. wait
-   5. Stop advertising.
-   6. deep sleep
-
-*/
-#include "sys/time.h"
-
-#include <Arduino.h>
-
-#include "BLEDevice.h"
-#include "BLEUtils.h"
-#include "BLEBeacon.h"
-#include "BLEAdvertising.h"
-#include "BLEEddystoneURL.h"
-
-#include "esp_sleep.h"
-
-#define GPIO_DEEP_SLEEP_DURATION 10     // sleep x seconds and then wake up
-RTC_DATA_ATTR static time_t last;    // remember last boot in RTC Memory
-RTC_DATA_ATTR static uint32_t bootcount; // remember number of boots in RTC Memory
-
-// See the following for generating UUIDs:
-// https://www.uuidgenerator.net/
-BLEAdvertising *pAdvertising;
-struct timeval now;
-
-#define BEACON_UUID "8ec76ea3-6668-48da-9866-75be8bc86f4d" // UUID 1 128-Bit (may use linux tool uuidgen or random numbers via https://www.uuidgenerator.net/)
-
-static const char *eddystone_url_prefix_subs[] = {
-  "http://www.",
-  "https://www.",
-  "http://",
-  "https://",
-  "urn:uuid:",
-  NULL
-};
-
-static const char *eddystone_url_suffix_subs[] = {
-  ".com/",
-  ".org/",
-  ".edu/",
-  ".net/",
-  ".info/",
-  ".biz/",
-  ".gov/",
-  ".com",
-  ".org",
-  ".edu",
-  ".net",
-  ".info",
-  ".biz",
-  ".gov",
-  NULL
-};
-
-static int string_begin_with(const char *str, const char *prefix)
-{
-  int prefix_len = strlen(prefix);
-  if (strncmp(prefix, str, prefix_len) == 0)
-  {
-    return prefix_len;
-  }
-  return 0;
-}
-
-void setBeacon()
-{
-  BLEAdvertisementData oAdvertisementData = BLEAdvertisementData();
-  BLEAdvertisementData oScanResponseData = BLEAdvertisementData();
-
-  const char url[] = "https://d.giesecke.tk";
-
-  int scheme_len, ext_len = 1, i, idx, url_idx;
-  char *ret_data;
-  int url_len = strlen(url);
-
-  ret_data = (char *)calloc(1, url_len + 13);
-
-  ret_data[0] = 2;   // Len
-  ret_data[1] = 0x01;  // Type Flags
-  ret_data[2] = 0x06;  // GENERAL_DISC_MODE 0x02 | BR_EDR_NOT_SUPPORTED 0x04
-  ret_data[3] = 3;   // Len
-  ret_data[4] = 0x03;  // Type 16-Bit UUID
-  ret_data[5] = 0xAA;  // Eddystone UUID 2 -> 0xFEAA LSB
-  ret_data[6] = 0xFE;  // Eddystone UUID 1 MSB
-  ret_data[7] = 19; // Length of Beacon Data
-  ret_data[8] = 0x16;  // Type Service Data
-  ret_data[9] = 0xAA;  // Eddystone UUID 2 -> 0xFEAA LSB
-  ret_data[10] = 0xFE; // Eddystone UUID 1 MSB
-  ret_data[11] = 0x10; // Eddystone Frame Type
-  ret_data[12] = 0xF4; // Beacons TX power at 0m
-
-  i = 0, idx = 13, url_idx = 0;
-
-  //replace prefix
-  scheme_len = 0;
-  while (eddystone_url_prefix_subs[i] != NULL)
-  {
-    if ((scheme_len = string_begin_with(url, eddystone_url_prefix_subs[i])) > 0)
-    {
-      ret_data[idx] = i;
-      idx++;
-      url_idx += scheme_len;
-      break;
-    }
-    i++;
-  }
-  while (url_idx < url_len)
-  {
-    i = 0;
-    ret_data[idx] = url[url_idx];
-    ext_len = 1;
-    while (eddystone_url_suffix_subs[i] != NULL)
-    {
-      if ((ext_len = string_begin_with(&url[url_idx], eddystone_url_suffix_subs[i])) > 0)
-      {
-        ret_data[idx] = i;
-        break;
-      }
-      else
-      {
-        ext_len = 1; //inc 1
-      }
-      i++;
-    }
-    url_idx += ext_len;
-    idx++;
-  }
-  ret_data[7] = idx - 8;
-
-  Serial.printf("struct size %d url size %d reported len %d\n",
-                url_len + 13,
-                url_len, ret_data[7]);
-
-  Serial.printf("URL in data %s\n", &ret_data[13]);
-
-  std::string eddyStoneData(ret_data);
-
-  oAdvertisementData.addData(eddyStoneData);
-  oScanResponseData.setName("URLBeacon");
-  pAdvertising->setAdvertisementData(oAdvertisementData);
-  pAdvertising->setScanResponseData(oScanResponseData);
-}
-
-void setup()
-{
-
-  Serial.begin(115200);
-  gettimeofday(&now, NULL);
-
-  Serial.printf("start ESP32 %d\n", bootcount++);
-
-  Serial.printf("deep sleep (%lds since last reset, %lds since last boot)\n", now.tv_sec, now.tv_sec - last);
-
-  last = now.tv_sec;
-
-  // Create the BLE Device
-  BLEDevice::init("URLBeacon");
-
-  BLEDevice::setPower(ESP_PWR_LVL_N12);
-
-  // Create the BLE Server
-  // BLEServer *pServer = BLEDevice::createServer(); // <-- no longer required to instantiate BLEServer, less flash and ram usage
-
-  pAdvertising = BLEDevice::getAdvertising();
-
-  setBeacon();
-  // Start advertising
-  pAdvertising->start();
-  Serial.println("Advertizing started...");
-  delay(10000);
-  pAdvertising->stop();
-  Serial.printf("enter deep sleep\n");
-  esp_deep_sleep(1000000LL * GPIO_DEEP_SLEEP_DURATION);
-  Serial.printf("in deep sleep\n");
-}
-
-void loop()
-{
-}

libraries/BLE/examples/BLE_EddystoneURL_Beacon/BLE_EddystoneURL_Beacon.md

@@ -1,14 +0,0 @@
-## Eddystone URL beacon
-EddystoneURL beacon by BeeGee based on
-[pcbreflux ESP32 Eddystone URL deepsleep](https://github.com/pcbreflux/espressif/tree/master/esp32/arduino/sketchbook/ESP32_Eddystone_URL_deepsleep)
-
-[EddystoneURL frame specification](https://github.com/google/eddystone/blob/master/eddystone-url/README.md)
-
-   Create a BLE server that will send periodic Eddystone URL frames.
-   The design of creating the BLE server is:
-   1. Create a BLE Server
-   2. Create advertising data
-   3. Start advertising.
-   4. wait
-   5. Stop advertising.
-   6. deep sleep